| <style> |
| :root { background: #102030e0; color: #99ddbbcc; font-size: 15px; } |
| </style> |
| <script src="../../../resources/js-test-pre.js"></script> |
| <script id="shared"> |
| const log = console.log; |
| |
| async function gc() { |
| await 0; |
| if (globalThis.GCController) { |
| globalThis.GCController.collect(); |
| } else if (globalThis.$vm) { |
| globalThis.$vm.gc(); |
| } else { |
| log('no GC available'); |
| } |
| } |
| |
| /** |
| * @param {GPUDevice} device |
| * @param {GPUComputePassEncoder} computePassEncoder |
| */ |
| function clearResourceUsages(device, computePassEncoder) { |
| let code = `@compute @workgroup_size(1) fn c() {}`; |
| let module = device.createShaderModule({code}); |
| computePassEncoder.setPipeline(device.createComputePipeline( |
| { |
| layout: 'auto', |
| compute: {module}, |
| })); |
| computePassEncoder.dispatchWorkgroups(1); |
| } |
| |
| /** |
| * @template {any} T |
| * @param {GPUDevice} device |
| * @param {string} label |
| * @param {()=>T} payload |
| * @returns {Promise<T>} |
| */ |
| async function validationWrapper(device, label, payload) { |
| device.pushErrorScope('internal'); |
| device.pushErrorScope('out-of-memory'); |
| device.pushErrorScope('validation'); |
| let result = payload(); |
| let validationError = await device.popErrorScope(); |
| let outOfMemoryError = await device.popErrorScope(); |
| let internalError = await device.popErrorScope(); |
| let error = validationError ?? outOfMemoryError ?? internalError; |
| if (error) { |
| log('*'.repeat(25)); |
| log(error[Symbol.toStringTag]); |
| log(error.message); |
| log(label); |
| if (error.stack != `_`) { |
| log(error.stack); |
| } |
| log(location); |
| log('*'.repeat(25)); |
| throw error; |
| } |
| return result; |
| } |
| |
| const videoUrls = [ |
| |
| ]; |
| |
| /** |
| * @param {number} index |
| * @returns {Promise<HTMLVideoElement>} |
| */ |
| function videoWithData(index) { |
| let video = document.createElement('video'); |
| video.src = videoUrls[index % videoUrls.length]; |
| return new Promise(resolve => { |
| video.onloadeddata = () => { |
| resolve(video); |
| }; |
| }); |
| } |
| |
| /** |
| * @returns {Promise<string>} |
| */ |
| async function makeDataUrl(width, height, color0, color1) { |
| let offscreenCanvas = new OffscreenCanvas(width, height); |
| let ctx = offscreenCanvas.getContext('2d'); |
| let gradient = ctx.createLinearGradient(0, 0, width, height); |
| gradient.addColorStop(0, color0); |
| gradient.addColorStop(0.1, color1); |
| gradient.addColorStop(0.3, color0); |
| gradient.addColorStop(0.7, color1); |
| gradient.addColorStop(0.9, color0); |
| gradient.addColorStop(1, color1); |
| ctx.fillStyle = gradient; |
| ctx.fillRect(0, 0, width, height); |
| let blob = await offscreenCanvas.convertToBlob(); |
| let fileReader = new FileReader(); |
| fileReader.readAsDataURL(blob); |
| return new Promise(resolve => { |
| fileReader.onload = () => { |
| resolve(fileReader.result); |
| }; |
| }); |
| } |
| |
| async function imageWithData(width, height, color0, color1) { |
| let dataUrl = await makeDataUrl(width, height, color0, color1); |
| let img = document.createElement('img'); |
| img.src = dataUrl; |
| await img.decode(); |
| return img; |
| } |
| |
| /** |
| * @param {string} payload |
| * @returns {string} |
| */ |
| function toBlobUrl(payload) { |
| let blob = new Blob([payload], {type: 'text/javascript'}); |
| return URL.createObjectURL(blob); |
| } |
| </script> |
| |
| <script> |
| globalThis.testRunner?.dumpAsText(); |
| globalThis.testRunner?.waitUntilDone(); |
| |
| |
| async function window0() { |
| let adapter0 = await navigator.gpu.requestAdapter({}); |
| let device0 = await adapter0.requestDevice({ |
| requiredFeatures: [ |
| 'depth-clip-control', |
| 'depth32float-stencil8', |
| 'texture-compression-etc2', |
| 'indirect-first-instance', |
| 'shader-f16', |
| 'rg11b10ufloat-renderable', |
| 'timestamp-query', |
| ], |
| }); |
| let commandEncoder0 = device0.createCommandEncoder({}); |
| let computePassEncoder0 = commandEncoder0.beginComputePass({}); |
| let sampler0 = device0.createSampler({ |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 69.31, |
| compare: 'never', |
| maxAnisotropy: 4, |
| }); |
| try { |
| sampler0.label = '\ua98e\u0bdf\u0664\ua608\u4a3b\ua1fa\u4c04'; |
| } catch {} |
| let renderBundleEncoder0 = device0.createRenderBundleEncoder({label: '\u0555\u{1fef4}\ub3da\u3450\u00db\u0484\u0f95\u081a\u9125', colorFormats: ['r32sint']}); |
| let sampler1 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| minFilter: 'nearest', |
| lodMaxClamp: 98.07, |
| }); |
| await gc(); |
| let texture0 = device0.createTexture({size: [51, 1, 13], dimension: '3d', format: 'r32sint', usage: GPUTextureUsage.TEXTURE_BINDING}); |
| let sampler2 = device0.createSampler({addressModeV: 'repeat', lodMinClamp: 67.44, lodMaxClamp: 81.29, compare: 'equal', maxAnisotropy: 1}); |
| let videoFrame0 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt709', primaries: 'smpte170m', transfer: 'gamma22curve'} }); |
| let buffer0 = device0.createBuffer({ |
| size: 10882, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| try { |
| renderBundleEncoder0.setVertexBuffer(2, buffer0, 0, 293); |
| } catch {} |
| let buffer1 = device0.createBuffer({size: 590, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let texture1 = device0.createTexture({ |
| size: {width: 51, height: 1, depthOrArrayLayers: 61}, |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| try { |
| renderBundleEncoder0.setVertexBuffer(2, buffer0, 0); |
| } catch {} |
| let promise0 = device0.queue.onSubmittedWorkDone(); |
| try { |
| device0.label = '\u{1ff07}\ubc8d\ub51b\u4da8\u0645\u{1faec}'; |
| } catch {} |
| try { |
| renderBundleEncoder0.setIndexBuffer(buffer0, 'uint32', 6_368, 1_711); |
| } catch {} |
| try { |
| renderBundleEncoder0.setVertexBuffer(3, buffer0, 204, 3_319); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer0, 708, new BigUint64Array(6608), 2792, 108); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let buffer2 = device0.createBuffer({size: 5719, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT}); |
| let textureView0 = texture0.createView({label: '\u02b8\udbf8\ufcf9\uc762\uaa46\uca56\u9a94\uca25\u082c'}); |
| await gc(); |
| let veryExplicitBindGroupLayout0 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 19, visibility: GPUShaderStage.VERTEX, externalTexture: {}}, |
| {binding: 44, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}}, |
| { |
| binding: 47, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| {binding: 59, visibility: GPUShaderStage.COMPUTE, externalTexture: {}}, |
| {binding: 131, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| ], |
| }); |
| let commandEncoder1 = device0.createCommandEncoder({}); |
| let texture2 = device0.createTexture({ |
| size: {width: 48, height: 910, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_SRC, |
| }); |
| let textureView1 = texture2.createView({dimension: '2d-array', mipLevelCount: 1, arrayLayerCount: 1}); |
| let computePassEncoder1 = commandEncoder1.beginComputePass({}); |
| try { |
| device0.pushErrorScope('internal'); |
| } catch {} |
| let veryExplicitBindGroupLayout1 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 19, visibility: GPUShaderStage.VERTEX, externalTexture: {}}, |
| {binding: 44, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}}, |
| { |
| binding: 47, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| {binding: 59, visibility: GPUShaderStage.COMPUTE, externalTexture: {}}, |
| {binding: 131, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| ], |
| }); |
| let pipelineLayout0 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout1]}); |
| let commandEncoder2 = device0.createCommandEncoder(); |
| let computePassEncoder2 = commandEncoder2.beginComputePass(); |
| let renderBundle0 = renderBundleEncoder0.finish({}); |
| let sampler3 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 77.08, |
| maxAnisotropy: 3, |
| }); |
| try { |
| device0.queue.writeBuffer(buffer2, 628, new BigUint64Array(6137), 770, 316); |
| } catch {} |
| let promise1 = device0.queue.onSubmittedWorkDone(); |
| let commandEncoder3 = device0.createCommandEncoder({}); |
| try { |
| commandEncoder3.insertDebugMarker('\u{1ffd1}'); |
| } catch {} |
| let sampler4 = device0.createSampler({addressModeU: 'mirror-repeat', magFilter: 'linear', mipmapFilter: 'linear', lodMaxClamp: 88.02}); |
| let texture3 = device0.createTexture({ |
| size: {width: 25}, |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder3 = commandEncoder3.beginComputePass({}); |
| let sampler5 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| maxAnisotropy: 7, |
| }); |
| try { |
| await promise1; |
| } catch {} |
| let pipelineLayout1 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout0, veryExplicitBindGroupLayout1]}); |
| let sampler6 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'repeat', mipmapFilter: 'nearest', lodMaxClamp: 61.26}); |
| let texture4 = device0.createTexture({ |
| size: [8], |
| dimension: '1d', |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let sampler7 = device0.createSampler({addressModeU: 'clamp-to-edge', addressModeV: 'repeat', lodMaxClamp: 69.62}); |
| let promise2 = device0.queue.onSubmittedWorkDone(); |
| let veryExplicitBindGroupLayout2 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 19, visibility: GPUShaderStage.VERTEX, externalTexture: {}}, |
| {binding: 44, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}}, |
| { |
| binding: 47, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| {binding: 59, visibility: GPUShaderStage.COMPUTE, externalTexture: {}}, |
| {binding: 131, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| ], |
| }); |
| let commandEncoder4 = device0.createCommandEncoder({}); |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| try { |
| commandEncoder4.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 3472 */ |
| offset: 3472, |
| bytesPerRow: 15872, |
| buffer: buffer0, |
| }, { |
| texture: texture4, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder4.copyTextureToTexture({ |
| texture: texture4, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture1, |
| mipLevel: 0, |
| origin: {x: 38, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder5 = device0.createCommandEncoder({}); |
| let texture5 = device0.createTexture({ |
| size: [51], |
| dimension: '1d', |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder4 = commandEncoder4.beginComputePass({}); |
| let sampler8 = device0.createSampler({addressModeU: 'repeat', lodMaxClamp: 99.99}); |
| let buffer3 = device0.createBuffer({size: 5272, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE}); |
| let textureView2 = texture0.createView({label: '\u0c80\u{1fbe7}\u1324\u4415\u6986'}); |
| let computePassEncoder5 = commandEncoder5.beginComputePass({}); |
| try { |
| buffer2.unmap(); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let pipelineLayout2 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout1]}); |
| let commandEncoder6 = device0.createCommandEncoder({}); |
| try { |
| commandEncoder6.pushDebugGroup('\u0101'); |
| } catch {} |
| try { |
| commandEncoder6.insertDebugMarker('\u{1fbec}'); |
| } catch {} |
| let texture6 = device0.createTexture({ |
| size: {width: 51}, |
| dimension: '1d', |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| commandEncoder6.copyBufferToBuffer(buffer1, 76, buffer0, 2316, 8); |
| } catch {} |
| try { |
| commandEncoder6.popDebugGroup(); |
| } catch {} |
| let commandEncoder7 = device0.createCommandEncoder({}); |
| let computePassEncoder6 = commandEncoder6.beginComputePass({}); |
| try { |
| commandEncoder7.copyBufferToTexture({ |
| /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 364 */ |
| offset: 364, |
| rowsPerImage: 348, |
| buffer: buffer3, |
| }, { |
| texture: texture3, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| globalThis.someLabel = device0.queue.label; |
| } catch {} |
| let commandEncoder8 = device0.createCommandEncoder({}); |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let querySet0 = device0.createQuerySet({type: 'occlusion', count: 1509}); |
| let renderBundleEncoder1 = device0.createRenderBundleEncoder({colorFormats: ['r32sint'], depthReadOnly: true, stencilReadOnly: false}); |
| try { |
| renderBundleEncoder1.setVertexBuffer(6, buffer0); |
| } catch {} |
| try { |
| buffer1.unmap(); |
| } catch {} |
| let videoFrame1 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte170m', primaries: 'film', transfer: 'unspecified'} }); |
| try { |
| globalThis.someLabel = commandEncoder6.label; |
| } catch {} |
| let buffer4 = device0.createBuffer({ |
| size: 3118, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE, |
| }); |
| let querySet1 = device0.createQuerySet({type: 'timestamp', count: 314}); |
| let textureView3 = texture2.createView({dimension: '2d', mipLevelCount: 1}); |
| let computePassEncoder7 = commandEncoder8.beginComputePass({}); |
| let buffer5 = device0.createBuffer({ |
| size: 11807, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE, |
| }); |
| let commandEncoder9 = device0.createCommandEncoder({}); |
| let renderBundle1 = renderBundleEncoder1.finish({}); |
| try { |
| commandEncoder7.copyTextureToBuffer({ |
| texture: texture4, |
| mipLevel: 0, |
| origin: {x: 3, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 7744 */ |
| offset: 7744, |
| buffer: buffer5, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture6, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(300).fill(222), /* required buffer size: 300 */ |
| {offset: 300}, {width: 11, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder7.copyBufferToBuffer(buffer1, 4, buffer0, 1520, 0); |
| } catch {} |
| let buffer6 = device0.createBuffer({size: 14013, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let commandEncoder10 = device0.createCommandEncoder({}); |
| let texture7 = device0.createTexture({ |
| size: {width: 25, height: 1, depthOrArrayLayers: 44}, |
| dimension: '3d', |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let computePassEncoder8 = commandEncoder9.beginComputePass({}); |
| try { |
| commandEncoder7.copyBufferToTexture({ |
| /* bytesInLastRow: 48 widthInBlocks: 12 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 0 */ |
| offset: 0, |
| bytesPerRow: 5120, |
| buffer: buffer0, |
| }, { |
| texture: texture5, |
| mipLevel: 0, |
| origin: {x: 6, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 12, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder10.resolveQuerySet(querySet1, 220, 0, buffer0, 1024); |
| } catch {} |
| let commandEncoder11 = device0.createCommandEncoder({}); |
| let texture8 = device0.createTexture({ |
| size: [700, 4, 1], |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| let computePassEncoder9 = commandEncoder10.beginComputePass({timestampWrites: {querySet: querySet1, beginningOfPassWriteIndex: 62}}); |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| await promise2; |
| } catch {} |
| let videoFrame2 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: false, matrix: 'yCgCo', primaries: 'smpte432', transfer: 'linear'} }); |
| let pipelineLayout3 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout2]}); |
| let commandEncoder12 = device0.createCommandEncoder({}); |
| let texture9 = device0.createTexture({size: [96, 1820, 1], format: 'rgba8sint', usage: GPUTextureUsage.STORAGE_BINDING}); |
| let computePassEncoder10 = commandEncoder12.beginComputePass({}); |
| try { |
| commandEncoder7.copyTextureToBuffer({ |
| texture: texture2, |
| mipLevel: 0, |
| origin: {x: 0, y: 155, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 44 widthInBlocks: 11 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 172 */ |
| offset: 172, |
| bytesPerRow: 25088, |
| buffer: buffer5, |
| }, {width: 11, height: 98, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await promise0; |
| } catch {} |
| let veryExplicitBindGroupLayout3 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 52, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}}, |
| { |
| binding: 110, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 141, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: true }, |
| }, |
| ], |
| }); |
| let texture10 = device0.createTexture({ |
| size: [5600, 34, 1], |
| mipLevelCount: 2, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rgba8sint', 'rgba8sint'], |
| }); |
| let textureView4 = texture5.createView({}); |
| try { |
| commandEncoder11.copyBufferToBuffer(buffer3, 472, buffer2, 340, 1080); |
| } catch {} |
| try { |
| commandEncoder7.copyBufferToTexture({ |
| /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 640 */ |
| offset: 640, |
| bytesPerRow: 9984, |
| buffer: buffer3, |
| }, { |
| texture: texture4, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| await gc(); |
| let textureView5 = texture6.createView({}); |
| let texture11 = device0.createTexture({ |
| size: {width: 24, height: 455, depthOrArrayLayers: 1}, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| device0.queue.writeBuffer(buffer4, 356, new Int16Array(5674), 368, 984); |
| } catch {} |
| let buffer7 = device0.createBuffer({size: 5558, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.VERTEX}); |
| let commandEncoder13 = device0.createCommandEncoder({}); |
| try { |
| commandEncoder11.copyBufferToTexture({ |
| /* bytesInLastRow: 20 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 276 */ |
| offset: 276, |
| rowsPerImage: 259, |
| buffer: buffer3, |
| }, { |
| texture: texture5, |
| mipLevel: 0, |
| origin: {x: 13, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 5, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder13.copyTextureToTexture({ |
| texture: texture7, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 1}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture4, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer2, 160, new BigUint64Array(20559), 1030, 32); |
| } catch {} |
| let promise3 = device0.queue.onSubmittedWorkDone(); |
| let commandEncoder14 = device0.createCommandEncoder({}); |
| let computePassEncoder11 = commandEncoder7.beginComputePass({}); |
| try { |
| commandEncoder13.copyBufferToTexture({ |
| /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 3976 */ |
| offset: 3976, |
| bytesPerRow: 5632, |
| buffer: buffer6, |
| }, { |
| texture: texture1, |
| mipLevel: 0, |
| origin: {x: 4, y: 0, z: 1}, |
| aspect: 'all', |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer8 = device0.createBuffer({ |
| size: 15261, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let textureView6 = texture5.createView({dimension: '1d', mipLevelCount: 1}); |
| let sampler9 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'clamp-to-edge', minFilter: 'nearest', mipmapFilter: 'nearest'}); |
| try { |
| commandEncoder11.copyBufferToTexture({ |
| /* bytesInLastRow: 28 widthInBlocks: 7 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 164 */ |
| offset: 164, |
| bytesPerRow: 28672, |
| buffer: buffer1, |
| }, { |
| texture: texture11, |
| mipLevel: 0, |
| origin: {x: 0, y: 47, z: 0}, |
| aspect: 'all', |
| }, {width: 7, height: 18, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture12 = device0.createTexture({ |
| size: [96, 1820, 296], |
| dimension: '3d', |
| format: 'r32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder12 = commandEncoder11.beginComputePass({timestampWrites: {querySet: querySet1}}); |
| try { |
| commandEncoder13.copyBufferToBuffer(buffer7, 3196, buffer0, 4212, 140); |
| } catch {} |
| let texture13 = device0.createTexture({ |
| label: '\ud8e7\u{1fbe5}\u8250\u3584\uc904\u00f9', |
| size: [1400, 8, 459], |
| dimension: '3d', |
| format: 'rgba32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture14 = device0.createTexture({ |
| size: {width: 48}, |
| dimension: '1d', |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let computePassEncoder13 = commandEncoder13.beginComputePass({timestampWrites: {querySet: querySet1}}); |
| try { |
| buffer1.unmap(); |
| } catch {} |
| try { |
| adapter0.label = '\u6b66\u03b7\u086d\u{1f736}'; |
| } catch {} |
| let commandEncoder15 = device0.createCommandEncoder(); |
| let textureView7 = texture13.createView({}); |
| let texture15 = device0.createTexture({ |
| size: {width: 192, height: 3640, depthOrArrayLayers: 1}, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let textureView8 = texture1.createView({label: '\u0352\u0c23', baseMipLevel: 0, baseArrayLayer: 16, arrayLayerCount: 1}); |
| let computePassEncoder14 = commandEncoder15.beginComputePass({timestampWrites: {querySet: querySet1, beginningOfPassWriteIndex: 209, endOfPassWriteIndex: 38}}); |
| let sampler10 = device0.createSampler({addressModeU: 'repeat', lodMaxClamp: 52.15}); |
| let textureView9 = texture12.createView({}); |
| let textureView10 = texture10.createView({dimension: '2d-array', mipLevelCount: 1}); |
| let computePassEncoder15 = commandEncoder14.beginComputePass({}); |
| let texture16 = device0.createTexture({ |
| size: {width: 8, height: 8, depthOrArrayLayers: 722}, |
| dimension: '3d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| let textureView11 = texture0.createView({format: 'r32sint', arrayLayerCount: 1}); |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let textureView12 = texture1.createView({baseArrayLayer: 12, arrayLayerCount: 8}); |
| let sampler11 = device0.createSampler({ |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 32.07, |
| maxAnisotropy: 5, |
| }); |
| try { |
| device0.queue.writeBuffer(buffer4, 64, new Int16Array(7351), 592, 244); |
| } catch {} |
| try { |
| await promise3; |
| } catch {} |
| let commandEncoder16 = device0.createCommandEncoder({}); |
| let textureView13 = texture6.createView({}); |
| try { |
| commandEncoder16.copyBufferToBuffer(buffer8, 560, buffer4, 256, 120); |
| } catch {} |
| await gc(); |
| let commandEncoder17 = device0.createCommandEncoder({}); |
| let texture17 = device0.createTexture({ |
| size: {width: 102, height: 1, depthOrArrayLayers: 18}, |
| dimension: '2d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView14 = texture11.createView({dimension: '2d-array'}); |
| let sampler12 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'repeat'}); |
| let buffer9 = device0.createBuffer({size: 6642, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM}); |
| let texture18 = device0.createTexture({ |
| size: [192, 3640, 1], |
| mipLevelCount: 1, |
| sampleCount: 1, |
| format: 'etc2-rgb8unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| commandEncoder17.copyBufferToBuffer(buffer3, 720, buffer4, 360, 608); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer5, 3320, new Float32Array(5402), 48, 200); |
| } catch {} |
| await gc(); |
| let commandEncoder18 = device0.createCommandEncoder({}); |
| let texture19 = device0.createTexture({ |
| label: '\u{1f8b0}\u0d7f\uecdc\uf3e6\u2e60\u0d45\u0809\u23c4', |
| size: {width: 1400, height: 8, depthOrArrayLayers: 1}, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder16 = commandEncoder18.beginComputePass(); |
| let renderPassEncoder0 = commandEncoder17.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView10, |
| clearValue: { r: -821.9, g: 477.5, b: 977.4, a: 956.9, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet0, |
| }); |
| let buffer10 = device0.createBuffer({ |
| size: 10748, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let texture20 = device0.createTexture({ |
| size: [8, 8, 12], |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| viewFormats: [], |
| }); |
| let computePassEncoder17 = commandEncoder16.beginComputePass({}); |
| try { |
| adapter0.label = '\ue5c9\u8bd4\u6ffb\u020c\u9ca8\u07c5\ude87\ub3b1\u8ee7'; |
| } catch {} |
| let buffer11 = device0.createBuffer({ |
| size: 18211, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM, |
| }); |
| let commandEncoder19 = device0.createCommandEncoder({}); |
| let texture21 = device0.createTexture({size: [192, 3640, 1], mipLevelCount: 2, format: 'rgba8sint', usage: GPUTextureUsage.COPY_DST}); |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer5, 'uint16', 766, 1_754); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(6, buffer10, 688); |
| } catch {} |
| try { |
| commandEncoder19.clearBuffer(buffer2, 984, 1464); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 3168, new Float32Array(4809), 1123, 32); |
| } catch {} |
| let commandEncoder20 = device0.createCommandEncoder(); |
| let textureView15 = texture3.createView({}); |
| let computePassEncoder18 = commandEncoder19.beginComputePass({}); |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer11, 'uint32', 3_284, 19); |
| } catch {} |
| try { |
| commandEncoder20.clearBuffer(buffer5, 592, 2244); |
| } catch {} |
| let texture22 = device0.createTexture({ |
| size: {width: 51, height: 1, depthOrArrayLayers: 186}, |
| dimension: '3d', |
| format: 'r32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| commandEncoder20.copyBufferToTexture({ |
| /* bytesInLastRow: 56 widthInBlocks: 14 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 352 */ |
| offset: 352, |
| bytesPerRow: 768, |
| buffer: buffer8, |
| }, { |
| texture: texture6, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 14, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer2, 256, new BigUint64Array(2556), 128, 20); |
| } catch {} |
| let commandEncoder21 = device0.createCommandEncoder({}); |
| let computePassEncoder19 = commandEncoder20.beginComputePass({}); |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer5, 'uint16', 3_046, 4_545); |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| await gc(); |
| let textureView16 = texture10.createView({mipLevelCount: 1}); |
| let computePassEncoder20 = commandEncoder21.beginComputePass({label: '\u6140\u0747\u646a\u{1fb57}'}); |
| let commandEncoder22 = device0.createCommandEncoder({}); |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| try { |
| commandEncoder22.copyBufferToTexture({ |
| /* bytesInLastRow: 8 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1996 */ |
| offset: 1996, |
| buffer: buffer10, |
| }, { |
| texture: texture6, |
| mipLevel: 0, |
| origin: {x: 11, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder22.copyTextureToTexture({ |
| texture: texture4, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture1, |
| mipLevel: 0, |
| origin: {x: 4, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| await gc(); |
| let commandEncoder23 = device0.createCommandEncoder(); |
| let sampler13 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| compare: 'not-equal', |
| maxAnisotropy: 2, |
| }); |
| try { |
| renderPassEncoder0.setVertexBuffer(5, buffer10, 0); |
| } catch {} |
| try { |
| buffer3.unmap(); |
| } catch {} |
| let commandEncoder24 = device0.createCommandEncoder({}); |
| let textureView17 = texture17.createView({baseArrayLayer: 1, arrayLayerCount: 2}); |
| let renderPassEncoder1 = commandEncoder23.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView16, |
| clearValue: { r: -979.0, g: -681.3, b: 174.6, a: -194.6, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| commandEncoder22.copyBufferToTexture({ |
| /* bytesInLastRow: 16 widthInBlocks: 4 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1340 */ |
| offset: 1340, |
| rowsPerImage: 303, |
| buffer: buffer7, |
| }, { |
| texture: texture1, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 1}, |
| aspect: 'all', |
| }, {width: 4, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let sampler14 = device0.createSampler({addressModeV: 'repeat', lodMaxClamp: 61.20, compare: 'less-equal'}); |
| try { |
| renderPassEncoder0.setVertexBuffer(2, buffer10, 0, 714); |
| } catch {} |
| let buffer12 = device0.createBuffer({ |
| size: 1248, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let computePassEncoder21 = commandEncoder24.beginComputePass({}); |
| let sampler15 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| lodMaxClamp: 78.08, |
| compare: 'not-equal', |
| }); |
| let externalTexture0 = device0.importExternalTexture({source: videoFrame2}); |
| let veryExplicitBindGroupLayout4 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 3, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 49, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 52, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'storage', minBindingSize: 26, hasDynamicOffset: false }, |
| }, |
| { |
| binding: 85, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'rgba32uint', access: 'write-only', viewDimension: '3d' }, |
| }, |
| { |
| binding: 322, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 356, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '3d' }, |
| }, |
| ], |
| }); |
| let commandEncoder25 = device0.createCommandEncoder(); |
| let texture23 = device0.createTexture({ |
| size: [1400, 8, 1], |
| sampleCount: 1, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture24 = device0.createTexture({ |
| size: [5600, 34, 1], |
| mipLevelCount: 2, |
| sampleCount: 1, |
| dimension: '2d', |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder22 = commandEncoder25.beginComputePass({}); |
| try { |
| commandEncoder22.copyBufferToTexture({ |
| /* bytesInLastRow: 24 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 5236 */ |
| offset: 5236, |
| buffer: buffer11, |
| }, { |
| texture: texture5, |
| mipLevel: 0, |
| origin: {x: 32, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 6, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer4, 344, new DataView(new ArrayBuffer(1826)), 789, 336); |
| } catch {} |
| let commandEncoder26 = device0.createCommandEncoder({}); |
| let computePassEncoder23 = commandEncoder22.beginComputePass({}); |
| let sampler16 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'mirror-repeat', lodMinClamp: 7.595}); |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer5, 'uint32', 2_660, 3_499); |
| } catch {} |
| try { |
| commandEncoder26.clearBuffer(buffer12); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture21, |
| mipLevel: 0, |
| origin: {x: 3, y: 1086, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(28).fill(173), /* required buffer size: 28 */ |
| {offset: 28, bytesPerRow: 78}, {width: 18, height: 933, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer13 = device0.createBuffer({ |
| size: 26361, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let texture25 = device0.createTexture({size: [12], dimension: '1d', format: 'rgba8sint', usage: GPUTextureUsage.STORAGE_BINDING}); |
| let computePassEncoder24 = commandEncoder26.beginComputePass({timestampWrites: {querySet: querySet1, endOfPassWriteIndex: 117}}); |
| try { |
| renderPassEncoder1.setViewport(496.1939486924673, 18.404412277502313, 3679.5822441318364, 8.164237808870901, 0.8823043472908201, 0.9082167255748383); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer11, 'uint32', 4_520, 693); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(4, buffer7); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer4, 1644, new Float32Array(12233), 547, 60); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(3, buffer7, 0, 691); |
| } catch {} |
| let videoFrame3 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt709', primaries: 'unspecified', transfer: 'bt2020_12bit'} }); |
| let commandEncoder27 = device0.createCommandEncoder({}); |
| let renderBundleEncoder2 = device0.createRenderBundleEncoder({colorFormats: ['r32sint'], depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| renderPassEncoder1.executeBundles([]); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(5, undefined); |
| } catch {} |
| try { |
| commandEncoder27.copyTextureToTexture({ |
| texture: texture7, |
| mipLevel: 0, |
| origin: {x: 9, y: 0, z: 3}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture1, |
| mipLevel: 0, |
| origin: {x: 13, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let veryExplicitBindGroupLayout5 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 19, visibility: GPUShaderStage.VERTEX, externalTexture: {}}, |
| {binding: 44, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}}, |
| { |
| binding: 47, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| {binding: 59, visibility: GPUShaderStage.COMPUTE, externalTexture: {}}, |
| {binding: 131, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| ], |
| }); |
| let commandEncoder28 = device0.createCommandEncoder({}); |
| let textureView18 = texture18.createView({dimension: '2d-array'}); |
| let renderPassEncoder2 = commandEncoder28.beginRenderPass({colorAttachments: [{view: textureView16, loadOp: 'load', storeOp: 'store'}], maxDrawCount: 12527436}); |
| let promise4 = device0.queue.onSubmittedWorkDone(); |
| let renderBundle2 = renderBundleEncoder2.finish({}); |
| try { |
| renderPassEncoder1.setBlendConstant({ r: 936.6, g: 213.3, b: -234.3, a: 839.1, }); |
| } catch {} |
| try { |
| renderPassEncoder1.setScissorRect(177, 2, 2687, 0); |
| } catch {} |
| try { |
| commandEncoder27.copyBufferToTexture({ |
| /* bytesInLastRow: 8 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 2368 */ |
| offset: 2368, |
| buffer: buffer0, |
| }, { |
| texture: texture4, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder29 = device0.createCommandEncoder({label: '\u{1fe76}\ub5e7'}); |
| let texture26 = device0.createTexture({size: [2800], dimension: '1d', format: 'rgba8sint', usage: GPUTextureUsage.COPY_SRC, viewFormats: []}); |
| let sampler17 = device0.createSampler({addressModeW: 'repeat', compare: 'not-equal'}); |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer11, 'uint32', 6_020, 64); |
| } catch {} |
| try { |
| commandEncoder27.copyBufferToTexture({ |
| /* bytesInLastRow: 24 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 164 */ |
| offset: 164, |
| bytesPerRow: 12544, |
| buffer: buffer6, |
| }, { |
| texture: texture11, |
| mipLevel: 0, |
| origin: {x: 1, y: 24, z: 0}, |
| aspect: 'all', |
| }, {width: 6, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup0 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [ |
| {binding: 44, resource: externalTexture0}, |
| {binding: 131, resource: externalTexture0}, |
| {binding: 19, resource: externalTexture0}, |
| {binding: 47, resource: {buffer: buffer4, offset: 0, size: 852}}, |
| {binding: 59, resource: externalTexture0}, |
| ], |
| }); |
| let texture27 = device0.createTexture({ |
| size: [24, 455, 1], |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let renderBundleEncoder3 = device0.createRenderBundleEncoder({colorFormats: ['r32sint'], stencilReadOnly: true}); |
| let sampler18 = device0.createSampler({addressModeU: 'repeat', addressModeW: 'mirror-repeat', lodMaxClamp: 98.38}); |
| try { |
| computePassEncoder2.setBindGroup(2, bindGroup0); |
| } catch {} |
| try { |
| renderPassEncoder2.end(); |
| } catch {} |
| try { |
| renderBundleEncoder3.setVertexBuffer(4, buffer0, 2_976, 564); |
| } catch {} |
| try { |
| renderPassEncoder1.insertDebugMarker('\u6fb5'); |
| } catch {} |
| let buffer14 = device0.createBuffer({ |
| size: 1482, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder30 = device0.createCommandEncoder({}); |
| let renderPassEncoder3 = commandEncoder27.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView10, |
| clearValue: { r: -77.20, g: -933.9, b: 303.5, a: -782.7, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| maxDrawCount: 344916775, |
| }); |
| let sampler19 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 93.53, |
| maxAnisotropy: 10, |
| }); |
| try { |
| renderBundleEncoder3.setVertexBuffer(0, buffer12); |
| } catch {} |
| try { |
| computePassEncoder16.setBindGroup(0, bindGroup0); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(2, buffer7); |
| } catch {} |
| try { |
| renderBundleEncoder3.setVertexBuffer(3, buffer13, 7_128); |
| } catch {} |
| try { |
| await promise4; |
| } catch {} |
| let bindGroup1 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout2, |
| entries: [ |
| {binding: 19, resource: externalTexture0}, |
| {binding: 47, resource: {buffer: buffer14, offset: 0, size: 732}}, |
| {binding: 44, resource: externalTexture0}, |
| {binding: 131, resource: externalTexture0}, |
| {binding: 59, resource: externalTexture0}, |
| ], |
| }); |
| let computePassEncoder25 = commandEncoder29.beginComputePass({timestampWrites: {querySet: querySet1, beginningOfPassWriteIndex: 98}}); |
| let sampler20 = device0.createSampler({addressModeU: 'mirror-repeat', lodMaxClamp: 99.31}); |
| try { |
| computePassEncoder20.setBindGroup(3, bindGroup1, new Uint32Array(865), 65, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(2, bindGroup0); |
| } catch {} |
| try { |
| renderPassEncoder3.executeBundles([]); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(3, buffer14); |
| } catch {} |
| try { |
| renderBundleEncoder3.setBindGroup(3, bindGroup0); |
| } catch {} |
| try { |
| renderBundleEncoder3.setIndexBuffer(buffer0, 'uint32', 688, 6_083); |
| } catch {} |
| let commandEncoder31 = device0.createCommandEncoder({}); |
| let commandBuffer0 = commandEncoder28.finish(); |
| let texture28 = device0.createTexture({ |
| size: {width: 5600, height: 34, depthOrArrayLayers: 1}, |
| mipLevelCount: 7, |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let renderPassEncoder4 = commandEncoder30.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView10, |
| clearValue: { r: 343.7, g: -581.3, b: 440.4, a: 396.0, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| renderPassEncoder0.setBindGroup(2, bindGroup0); |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer10, 'uint16', 6_726, 743); |
| } catch {} |
| try { |
| renderPassEncoder4.setVertexBuffer(2, buffer10, 0); |
| } catch {} |
| try { |
| renderBundleEncoder3.setBindGroup(2, bindGroup1, new Uint32Array(3582), 179, 0); |
| } catch {} |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| try { |
| commandEncoder31.copyBufferToTexture({ |
| /* bytesInLastRow: 20 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 3228 */ |
| offset: 3228, |
| bytesPerRow: 32256, |
| buffer: buffer6, |
| }, { |
| texture: texture27, |
| mipLevel: 0, |
| origin: {x: 1, y: 201, z: 0}, |
| aspect: 'all', |
| }, {width: 5, height: 31, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 96, height: 1820, depthOrArrayLayers: 296} |
| */ |
| { |
| source: videoFrame2, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture12, |
| mipLevel: 0, |
| origin: {x: 26, y: 220, z: 174}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let videoFrame4 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-ncl', primaries: 'unspecified', transfer: 'bt2020_12bit'} }); |
| let computePassEncoder26 = commandEncoder31.beginComputePass(); |
| try { |
| device0.queue.submit([commandBuffer0]); |
| } catch {} |
| let querySet2 = device0.createQuerySet({type: 'occlusion', count: 315}); |
| let sampler21 = device0.createSampler({ |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 93.26, |
| maxAnisotropy: 20, |
| }); |
| try { |
| renderPassEncoder3.setBindGroup(3, bindGroup0, []); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(2, bindGroup0, new Uint32Array(2670), 18, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.executeBundles([]); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer14, 'uint32', 352, 252); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let bindGroup2 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout3, |
| entries: [ |
| {binding: 52, resource: externalTexture0}, |
| {binding: 110, resource: {buffer: buffer5, offset: 1792, size: 4948}}, |
| {binding: 141, resource: {buffer: buffer14, offset: 512, size: 64}}, |
| ], |
| }); |
| let buffer15 = device0.createBuffer({size: 15288, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let commandEncoder32 = device0.createCommandEncoder({}); |
| let texture29 = device0.createTexture({ |
| size: {width: 192}, |
| dimension: '1d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder15.setBindGroup(2, bindGroup0); |
| } catch {} |
| try { |
| renderBundleEncoder3.setBindGroup(3, bindGroup2, [512]); |
| } catch {} |
| try { |
| renderBundleEncoder3.setBindGroup(3, bindGroup2, new Uint32Array(2720), 917, 1); |
| } catch {} |
| try { |
| commandEncoder32.copyBufferToTexture({ |
| /* bytesInLastRow: 16 widthInBlocks: 4 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 472 */ |
| offset: 472, |
| bytesPerRow: 53248, |
| buffer: buffer7, |
| }, { |
| texture: texture11, |
| mipLevel: 0, |
| origin: {x: 2, y: 53, z: 0}, |
| aspect: 'all', |
| }, {width: 4, height: 19, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer4, 340, new DataView(new ArrayBuffer(518)), 205, 12); |
| } catch {} |
| let img0 = await imageWithData(2, 6, '#10101010', '#20202020'); |
| let texture30 = device0.createTexture({ |
| size: {width: 5600, height: 34, depthOrArrayLayers: 1}, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let renderBundleEncoder4 = device0.createRenderBundleEncoder({colorFormats: ['rgba8sint'], depthReadOnly: true, stencilReadOnly: true}); |
| let sampler22 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'repeat', lodMaxClamp: 57.57}); |
| try { |
| computePassEncoder12.setBindGroup(0, bindGroup1, new Uint32Array(586), 176, 0); |
| } catch {} |
| try { |
| computePassEncoder25.end(); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(3, bindGroup1); |
| } catch {} |
| try { |
| renderPassEncoder0.beginOcclusionQuery(126); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer0, 'uint16', 2_642, 1_142); |
| } catch {} |
| try { |
| renderPassEncoder4.setVertexBuffer(5, buffer13, 0, 6_793); |
| } catch {} |
| try { |
| renderBundleEncoder4.setBindGroup(0, bindGroup1); |
| } catch {} |
| try { |
| renderBundleEncoder3.setBindGroup(0, bindGroup0, new Uint32Array(4765), 49, 0); |
| } catch {} |
| try { |
| renderBundleEncoder3.setIndexBuffer(buffer0, 'uint32', 2_688, 954); |
| } catch {} |
| try { |
| commandEncoder29.copyTextureToBuffer({ |
| texture: texture26, |
| mipLevel: 0, |
| origin: {x: 103, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 2296 widthInBlocks: 574 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1148 */ |
| offset: 1148, |
| bytesPerRow: 11776, |
| buffer: buffer13, |
| }, {width: 574, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer16 = device0.createBuffer({size: 4988, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE}); |
| let commandEncoder33 = device0.createCommandEncoder({}); |
| let textureView19 = texture18.createView({dimension: '2d-array'}); |
| let texture31 = device0.createTexture({ |
| size: [5600, 34, 1], |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder27 = commandEncoder33.beginComputePass({timestampWrites: {querySet: querySet1}}); |
| try { |
| renderPassEncoder1.setBlendConstant({ r: 679.7, g: -607.8, b: -248.9, a: 664.7, }); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(2, buffer7, 0); |
| } catch {} |
| try { |
| renderBundleEncoder4.setVertexBuffer(0, buffer10, 2_528, 426); |
| } catch {} |
| try { |
| commandEncoder32.clearBuffer(buffer3); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture14, |
| mipLevel: 0, |
| origin: {x: 7, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(14).fill(205), /* required buffer size: 14 */ |
| {offset: 14, bytesPerRow: 55}, {width: 13, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let videoFrame5 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt709', primaries: 'smpteRp431', transfer: 'unspecified'} }); |
| try { |
| adapter0.label = '\ub684\udd25\ud592\u1bcc\u1641\uae7f\u12d8\u0f84'; |
| } catch {} |
| let commandEncoder34 = device0.createCommandEncoder({label: '\u9eb6\u{1f958}\u{1ff28}\u{1f8c9}\u{1ff52}\u0af8\u{1ff35}\u0897\u012e\u3b3e'}); |
| let texture32 = device0.createTexture({size: [1400, 8, 1], mipLevelCount: 1, format: 'rgba8sint', usage: GPUTextureUsage.STORAGE_BINDING}); |
| let textureView20 = texture0.createView({baseArrayLayer: 0}); |
| let computePassEncoder28 = commandEncoder34.beginComputePass({}); |
| try { |
| computePassEncoder16.setBindGroup(3, bindGroup0); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(3, bindGroup0); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(1, bindGroup0, new Uint32Array(272), 36, 0); |
| } catch {} |
| try { |
| renderBundleEncoder3.setBindGroup(3, bindGroup0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 2068, new Int16Array(13907), 6195, 220); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 96, height: 1820, depthOrArrayLayers: 296} |
| */ |
| { |
| source: videoFrame1, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture12, |
| mipLevel: 0, |
| origin: {x: 0, y: 729, z: 19}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let renderPassEncoder5 = commandEncoder29.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView16, |
| clearValue: { r: -51.26, g: 658.7, b: -283.8, a: 262.7, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| renderPassEncoder4.setBindGroup(0, bindGroup0); |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(0, bindGroup1, new Uint32Array(818), 28, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderBundleEncoder3.setBindGroup(2, bindGroup1); |
| } catch {} |
| try { |
| renderBundleEncoder3.setBindGroup(0, bindGroup2, new Uint32Array(1657), 80, 1); |
| } catch {} |
| try { |
| renderBundleEncoder3.setVertexBuffer(6, buffer13); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture22, |
| mipLevel: 0, |
| origin: {x: 6, y: 0, z: 22}, |
| aspect: 'all', |
| }, new Uint8Array(225).fill(131), /* required buffer size: 225 */ |
| {offset: 225, bytesPerRow: 0, rowsPerImage: 18}, {width: 0, height: 0, depthOrArrayLayers: 39}); |
| } catch {} |
| try { |
| computePassEncoder13.setBindGroup(0, bindGroup0, new Uint32Array(267), 13, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.beginOcclusionQuery(69); |
| } catch {} |
| try { |
| renderPassEncoder0.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderBundleEncoder3.setBindGroup(3, bindGroup1); |
| } catch {} |
| try { |
| renderBundleEncoder4.setVertexBuffer(4, buffer13); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| commandEncoder32.copyBufferToTexture({ |
| /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 3772 */ |
| offset: 3772, |
| buffer: buffer11, |
| }, { |
| texture: texture4, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder32.copyTextureToTexture({ |
| texture: texture4, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture6, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup3 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [ |
| {binding: 19, resource: externalTexture0}, |
| {binding: 59, resource: externalTexture0}, |
| {binding: 44, resource: externalTexture0}, |
| {binding: 47, resource: {buffer: buffer10, offset: 256}}, |
| {binding: 131, resource: externalTexture0}, |
| ], |
| }); |
| let computePassEncoder29 = commandEncoder32.beginComputePass({}); |
| try { |
| renderPassEncoder5.setBindGroup(3, bindGroup0); |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(3, bindGroup2, new Uint32Array(2100), 87, 1); |
| } catch {} |
| try { |
| renderPassEncoder5.setVertexBuffer(2, buffer13, 0, 168); |
| } catch {} |
| try { |
| renderBundleEncoder4.setBindGroup(1, bindGroup0, new Uint32Array(5741), 350, 0); |
| } catch {} |
| let imageData0 = new ImageData(64, 28); |
| let bindGroup4 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 52, resource: {buffer: buffer8, offset: 1024, size: 420}}, |
| {binding: 3, resource: {buffer: buffer0, offset: 1024, size: 2288}}, |
| {binding: 322, resource: {buffer: buffer0, offset: 256, size: 1096}}, |
| {binding: 356, resource: textureView9}, |
| {binding: 85, resource: textureView7}, |
| {binding: 49, resource: {buffer: buffer14, offset: 512, size: 440}}, |
| ], |
| }); |
| let textureView21 = texture23.createView({dimension: '2d-array'}); |
| let sampler23 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'mirror-repeat', addressModeW: 'mirror-repeat', compare: 'never'}); |
| try { |
| renderPassEncoder1.setBindGroup(2, bindGroup1); |
| } catch {} |
| try { |
| renderPassEncoder1.setScissorRect(342, 3, 200, 3); |
| } catch {} |
| try { |
| renderPassEncoder3.pushDebugGroup('\uef2d'); |
| } catch {} |
| let bindGroup5 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout5, |
| entries: [ |
| {binding: 19, resource: externalTexture0}, |
| {binding: 131, resource: externalTexture0}, |
| {binding: 47, resource: {buffer: buffer4, offset: 256, size: 548}}, |
| {binding: 44, resource: externalTexture0}, |
| {binding: 59, resource: externalTexture0}, |
| ], |
| }); |
| let texture33 = device0.createTexture({ |
| size: [2800, 17, 1], |
| mipLevelCount: 3, |
| format: 'r8snorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderBundle3 = renderBundleEncoder3.finish({}); |
| try { |
| computePassEncoder21.setBindGroup(1, bindGroup5); |
| } catch {} |
| try { |
| buffer15.unmap(); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| let buffer17 = device0.createBuffer({size: 667, usage: GPUBufferUsage.INDEX, mappedAtCreation: false}); |
| let commandEncoder35 = device0.createCommandEncoder({}); |
| let textureView22 = texture27.createView({}); |
| let computePassEncoder30 = commandEncoder35.beginComputePass({}); |
| let sampler24 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 98.41, |
| }); |
| try { |
| renderPassEncoder0.setVertexBuffer(0, buffer14, 260); |
| } catch {} |
| try { |
| renderBundleEncoder4.setBindGroup(0, bindGroup1); |
| } catch {} |
| try { |
| renderBundleEncoder4.setVertexBuffer(2, undefined, 832_774_062); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer5, 1756, new Int16Array(1715), 58, 564); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture12, |
| mipLevel: 0, |
| origin: {x: 16, y: 10, z: 30}, |
| aspect: 'all', |
| }, new Uint8Array(426_518).fill(131), /* required buffer size: 426_518 */ |
| {offset: 50, bytesPerRow: 40, rowsPerImage: 173}, {width: 7, height: 109, depthOrArrayLayers: 62}); |
| } catch {} |
| let textureView23 = texture4.createView({aspect: 'all'}); |
| let sampler25 = device0.createSampler({ |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 76.74, |
| maxAnisotropy: 3, |
| }); |
| let externalTexture1 = device0.importExternalTexture({source: videoFrame1, colorSpace: 'srgb'}); |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer17, 'uint32', 196, 121); |
| } catch {} |
| try { |
| renderBundleEncoder4.setBindGroup(3, bindGroup1, []); |
| } catch {} |
| try { |
| renderBundleEncoder4.setIndexBuffer(buffer10, 'uint16', 2_458, 309); |
| } catch {} |
| let buffer18 = device0.createBuffer({ |
| size: 3117, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| mappedAtCreation: false, |
| }); |
| try { |
| computePassEncoder22.setBindGroup(3, bindGroup1, new Uint32Array(575), 60, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(2, bindGroup0, new Uint32Array(1661), 63, 0); |
| } catch {} |
| try { |
| renderBundleEncoder4.setBindGroup(0, bindGroup2, [256]); |
| } catch {} |
| try { |
| renderBundleEncoder4.setIndexBuffer(buffer17, 'uint32', 32, 131); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let bindGroup6 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 85, resource: textureView7}, |
| {binding: 356, resource: textureView9}, |
| {binding: 3, resource: {buffer: buffer5, offset: 1024, size: 4048}}, |
| {binding: 49, resource: {buffer: buffer4, offset: 0, size: 588}}, |
| {binding: 52, resource: {buffer: buffer0, offset: 3072, size: 1340}}, |
| {binding: 322, resource: {buffer: buffer5, offset: 768, size: 2760}}, |
| ], |
| }); |
| let renderBundle4 = renderBundleEncoder4.finish({}); |
| try { |
| computePassEncoder5.setBindGroup(2, bindGroup0, new Uint32Array(1465), 112, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(3, bindGroup5, []); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(0, bindGroup0, new Uint32Array(256), 1, 0); |
| } catch {} |
| try { |
| await buffer15.mapAsync(GPUMapMode.WRITE, 3664); |
| } catch {} |
| let canvas0 = document.createElement('canvas'); |
| let textureView24 = texture31.createView({mipLevelCount: 1}); |
| try { |
| renderPassEncoder1.setBindGroup(3, bindGroup5, new Uint32Array(151), 16, 0); |
| } catch {} |
| let gpuCanvasContext0 = canvas0.getContext('webgpu'); |
| let canvas1 = document.createElement('canvas'); |
| let textureView25 = texture12.createView({}); |
| let sampler26 = device0.createSampler({addressModeU: 'repeat', addressModeW: 'repeat', lodMaxClamp: 95.73, maxAnisotropy: 1}); |
| try { |
| computePassEncoder18.setBindGroup(1, bindGroup5); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(2, bindGroup0); |
| } catch {} |
| try { |
| renderPassEncoder4.executeBundles([renderBundle4, renderBundle4]); |
| } catch {} |
| let gpuCanvasContext1 = canvas1.getContext('webgpu'); |
| let imageData1 = new ImageData(108, 104); |
| let videoFrame6 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte170m', primaries: 'smpte170m', transfer: 'gamma28curve'} }); |
| let textureView26 = texture18.createView({ |
| label: '\uf273\u0948\u0b91\u0a5a\ufa10\u9eca\u05e2\u0931\u81fb\uc3c4\u03a4', |
| dimension: '2d-array', |
| arrayLayerCount: 1, |
| }); |
| try { |
| renderPassEncoder4.executeBundles([renderBundle4, renderBundle4]); |
| } catch {} |
| try { |
| renderPassEncoder1.setBlendConstant({ r: 961.8, g: 902.8, b: -808.3, a: 731.6, }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer12, 104, new BigUint64Array(22053), 886, 96); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 96, height: 1820, depthOrArrayLayers: 296} |
| */ |
| { |
| source: videoFrame2, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture12, |
| mipLevel: 0, |
| origin: {x: 25, y: 1501, z: 18}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder36 = device0.createCommandEncoder(); |
| try { |
| computePassEncoder13.setBindGroup(2, bindGroup5, new Uint32Array(166), 12, 0); |
| } catch {} |
| try { |
| commandEncoder36.copyTextureToBuffer({ |
| texture: texture29, |
| mipLevel: 0, |
| origin: {x: 8, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 412 widthInBlocks: 103 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1160 */ |
| offset: 1160, |
| rowsPerImage: 540, |
| buffer: buffer12, |
| }, {width: 103, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer2, 1008, new BigUint64Array(597), 23, 160); |
| } catch {} |
| let promise5 = device0.queue.onSubmittedWorkDone(); |
| let commandEncoder37 = device0.createCommandEncoder({}); |
| let computePassEncoder31 = commandEncoder36.beginComputePass(); |
| try { |
| renderPassEncoder3.setBindGroup(0, bindGroup5, new Uint32Array(54), 8, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(4, undefined, 248_106_079, 186_586_152); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer4, 84, new Float32Array(145), 17, 100); |
| } catch {} |
| let promise6 = device0.queue.onSubmittedWorkDone(); |
| let commandEncoder38 = device0.createCommandEncoder({}); |
| let texture34 = device0.createTexture({ |
| size: {width: 48, height: 910, depthOrArrayLayers: 1}, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture35 = device0.createTexture({ |
| size: {width: 1400, height: 8, depthOrArrayLayers: 2}, |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let renderPassEncoder6 = commandEncoder37.beginRenderPass({colorAttachments: [{view: textureView21, loadOp: 'clear', storeOp: 'discard'}]}); |
| try { |
| computePassEncoder6.setBindGroup(0, bindGroup0); |
| } catch {} |
| try { |
| commandEncoder38.copyBufferToBuffer(buffer10, 2192, buffer13, 404, 3184); |
| } catch {} |
| try { |
| renderPassEncoder3.popDebugGroup(); |
| } catch {} |
| let bindGroup7 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout5, |
| entries: [ |
| {binding: 44, resource: externalTexture0}, |
| {binding: 59, resource: externalTexture1}, |
| {binding: 131, resource: externalTexture0}, |
| {binding: 19, resource: externalTexture0}, |
| {binding: 47, resource: {buffer: buffer10, offset: 3328, size: 1476}}, |
| ], |
| }); |
| let textureView27 = texture34.createView({}); |
| let computePassEncoder32 = commandEncoder38.beginComputePass({}); |
| try { |
| computePassEncoder14.setBindGroup(2, bindGroup6, new Uint32Array(2308), 866, 0); |
| } catch {} |
| try { |
| renderPassEncoder6.executeBundles([renderBundle4]); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(1, buffer12, 128, 328); |
| } catch {} |
| let promise7 = device0.queue.onSubmittedWorkDone(); |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| try { |
| globalThis.someLabel = device0.label; |
| } catch {} |
| let textureView28 = texture35.createView({mipLevelCount: 1, arrayLayerCount: 1}); |
| try { |
| renderPassEncoder6.executeBundles([renderBundle4]); |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer10, 'uint16', 666, 1_086); |
| } catch {} |
| try { |
| renderPassEncoder5.setVertexBuffer(2, buffer14); |
| } catch {} |
| let textureView29 = texture7.createView({arrayLayerCount: 1}); |
| try { |
| computePassEncoder0.setBindGroup(0, bindGroup6); |
| } catch {} |
| try { |
| computePassEncoder11.setBindGroup(1, bindGroup4, new Uint32Array(1353), 77, 0); |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(2, bindGroup5); |
| } catch {} |
| document.body.append(canvas1); |
| let bindGroup8 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 85, resource: textureView7}, |
| {binding: 49, resource: {buffer: buffer0, offset: 2560, size: 688}}, |
| {binding: 3, resource: {buffer: buffer4, offset: 512, size: 1972}}, |
| {binding: 52, resource: {buffer: buffer0, offset: 4608, size: 88}}, |
| {binding: 322, resource: {buffer: buffer10, offset: 256, size: 1228}}, |
| {binding: 356, resource: textureView9}, |
| ], |
| }); |
| let texture36 = device0.createTexture({ |
| size: {width: 24, height: 455, depthOrArrayLayers: 1}, |
| mipLevelCount: 3, |
| sampleCount: 1, |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder5.setBindGroup(0, bindGroup7); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(7, buffer0, 0, 3_613); |
| } catch {} |
| let buffer19 = device0.createBuffer({size: 1283, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM}); |
| let texture37 = device0.createTexture({ |
| size: [8, 8, 12], |
| dimension: '2d', |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| try { |
| computePassEncoder1.pushDebugGroup('\ubb86'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer4, 284, new BigUint64Array(1020), 18, 32); |
| } catch {} |
| let buffer20 = device0.createBuffer({size: 21887, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE}); |
| let commandEncoder39 = device0.createCommandEncoder({}); |
| let textureView30 = texture6.createView({dimension: '1d'}); |
| let renderPassEncoder7 = commandEncoder39.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView16, |
| clearValue: { r: -222.0, g: 69.87, b: 633.8, a: 622.1, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| }); |
| let externalTexture2 = device0.importExternalTexture({source: videoFrame2}); |
| try { |
| computePassEncoder11.setBindGroup(2, bindGroup1, new Uint32Array(2515), 55, 0); |
| } catch {} |
| let sampler27 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| maxAnisotropy: 5, |
| }); |
| try { |
| computePassEncoder21.setBindGroup(1, bindGroup4); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| await promise7; |
| } catch {} |
| let textureView31 = texture4.createView({label: '\u6ff3\ud3a9\u{1fac0}\u7dae\u{1f637}\u1257\u{1f9bc}\u{1f844}\u{1fea0}'}); |
| try { |
| renderPassEncoder4.setBindGroup(3, bindGroup0); |
| } catch {} |
| let buffer21 = device0.createBuffer({size: 2655, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.VERTEX}); |
| let commandEncoder40 = device0.createCommandEncoder({}); |
| let computePassEncoder33 = commandEncoder40.beginComputePass({}); |
| try { |
| computePassEncoder10.setBindGroup(1, bindGroup5, new Uint32Array(1736), 9, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.setBindGroup(0, bindGroup8, new Uint32Array(3441), 107, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 96, height: 1820, depthOrArrayLayers: 296} |
| */ |
| { |
| source: videoFrame0, |
| origin: { x: 0, y: 1 }, |
| flipY: true, |
| }, { |
| texture: texture12, |
| mipLevel: 0, |
| origin: {x: 1, y: 1028, z: 33}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let textureView32 = texture13.createView({}); |
| let textureView33 = texture4.createView({}); |
| let externalTexture3 = device0.importExternalTexture({source: videoFrame0, colorSpace: 'srgb'}); |
| let imageData2 = new ImageData(20, 76); |
| try { |
| computePassEncoder5.setBindGroup(1, bindGroup5); |
| } catch {} |
| try { |
| renderPassEncoder5.setBindGroup(3, bindGroup7, new Uint32Array(1058), 300, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(2, buffer10, 1_588, 5_167); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 96, height: 1820, depthOrArrayLayers: 296} |
| */ |
| { |
| source: canvas0, |
| origin: { x: 7, y: 32 }, |
| flipY: true, |
| }, { |
| texture: texture12, |
| mipLevel: 0, |
| origin: {x: 6, y: 139, z: 147}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 21, height: 6, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await promise6; |
| } catch {} |
| try { |
| computePassEncoder11.setBindGroup(3, bindGroup6); |
| } catch {} |
| let textureView34 = texture21.createView({mipLevelCount: 1, baseArrayLayer: 0}); |
| try { |
| computePassEncoder28.setBindGroup(3, bindGroup5, new Uint32Array(1865), 764, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.setIndexBuffer(buffer17, 'uint16', 6, 43); |
| } catch {} |
| try { |
| renderPassEncoder6.setVertexBuffer(2, buffer0, 0); |
| } catch {} |
| let commandEncoder41 = device0.createCommandEncoder({}); |
| let texture38 = device0.createTexture({ |
| size: {width: 8, height: 8, depthOrArrayLayers: 12}, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderBundleEncoder5 = device0.createRenderBundleEncoder({colorFormats: ['r32sint'], depthReadOnly: true, stencilReadOnly: true}); |
| let renderBundle5 = renderBundleEncoder5.finish({}); |
| let sampler28 = device0.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'clamp-to-edge', lodMaxClamp: 77.54}); |
| try { |
| computePassEncoder30.setBindGroup(3, bindGroup4); |
| } catch {} |
| try { |
| computePassEncoder10.setBindGroup(0, bindGroup7, new Uint32Array(508), 68, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.setBindGroup(1, bindGroup8, new Uint32Array(769), 4, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.setScissorRect(1560, 1, 348, 6); |
| } catch {} |
| try { |
| device0.pushErrorScope('internal'); |
| } catch {} |
| try { |
| await buffer1.mapAsync(GPUMapMode.WRITE, 8, 72); |
| } catch {} |
| let texture39 = device0.createTexture({ |
| size: [25, 1, 1], |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView35 = texture2.createView({dimension: '2d-array', mipLevelCount: 1}); |
| let computePassEncoder34 = commandEncoder41.beginComputePass({}); |
| try { |
| renderPassEncoder0.setBindGroup(0, bindGroup5, new Uint32Array(4522), 281, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.beginOcclusionQuery(67); |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer10, 'uint32', 2_636, 350); |
| } catch {} |
| let bindGroup9 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [ |
| {binding: 19, resource: externalTexture3}, |
| {binding: 59, resource: externalTexture0}, |
| {binding: 44, resource: externalTexture1}, |
| {binding: 47, resource: {buffer: buffer0, offset: 512, size: 680}}, |
| {binding: 131, resource: externalTexture2}, |
| ], |
| }); |
| let textureView36 = texture39.createView({dimension: '2d-array'}); |
| let textureView37 = texture23.createView({baseMipLevel: 0, arrayLayerCount: 1}); |
| try { |
| renderPassEncoder7.setBlendConstant({ r: -94.63, g: 302.5, b: -11.51, a: 995.6, }); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer19, 'uint16', 328, 290); |
| } catch {} |
| try { |
| renderPassEncoder5.setVertexBuffer(4, buffer7, 2_260, 115); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 96, height: 1820, depthOrArrayLayers: 296} |
| */ |
| { |
| source: videoFrame5, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture12, |
| mipLevel: 0, |
| origin: {x: 30, y: 342, z: 15}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup10 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 52, resource: {buffer: buffer10, offset: 768, size: 1436}}, |
| {binding: 356, resource: textureView25}, |
| {binding: 322, resource: {buffer: buffer5, offset: 2560, size: 1548}}, |
| {binding: 85, resource: textureView7}, |
| {binding: 3, resource: {buffer: buffer10, offset: 1024}}, |
| {binding: 49, resource: {buffer: buffer8, offset: 512, size: 852}}, |
| ], |
| }); |
| let commandEncoder42 = device0.createCommandEncoder({}); |
| let texture40 = device0.createTexture({ |
| size: [25, 1, 2], |
| mipLevelCount: 1, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let computePassEncoder35 = commandEncoder42.beginComputePass({}); |
| try { |
| computePassEncoder19.setBindGroup(2, bindGroup0); |
| } catch {} |
| try { |
| renderPassEncoder7.setBindGroup(3, bindGroup7); |
| } catch {} |
| let bindGroup11 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [ |
| {binding: 47, resource: {buffer: buffer5, offset: 6144, size: 492}}, |
| {binding: 19, resource: externalTexture0}, |
| {binding: 59, resource: externalTexture2}, |
| {binding: 44, resource: externalTexture1}, |
| {binding: 131, resource: externalTexture1}, |
| ], |
| }); |
| let buffer22 = device0.createBuffer({ |
| size: 15589, |
| usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder43 = device0.createCommandEncoder(); |
| let textureView38 = texture39.createView({dimension: '2d-array'}); |
| let sampler29 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'mirror-repeat', lodMaxClamp: 71.69}); |
| try { |
| computePassEncoder4.setBindGroup(2, bindGroup4, new Uint32Array(1796), 86, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(2, bindGroup5, new Uint32Array(522), 54, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.endOcclusionQuery(); |
| } catch {} |
| try { |
| commandEncoder43.copyBufferToBuffer(buffer11, 3348, buffer16, 244, 492); |
| } catch {} |
| try { |
| computePassEncoder6.insertDebugMarker('\u08ee'); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture18, |
| mipLevel: 0, |
| origin: {x: 24, y: 996, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(52).fill(254), /* required buffer size: 52 */ |
| {offset: 52, bytesPerRow: 223}, {width: 88, height: 104, depthOrArrayLayers: 0}); |
| } catch {} |
| let computePassEncoder36 = commandEncoder43.beginComputePass({}); |
| try { |
| computePassEncoder12.setBindGroup(0, bindGroup4); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(2, bindGroup5); |
| } catch {} |
| try { |
| renderPassEncoder5.setBindGroup(0, bindGroup7, new Uint32Array(7737), 497, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.setVertexBuffer(0, buffer0, 0, 1_799); |
| } catch {} |
| let texture41 = device0.createTexture({ |
| size: {width: 5600}, |
| dimension: '1d', |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let textureView39 = texture33.createView({dimension: '2d-array', format: 'r8snorm', mipLevelCount: 1, arrayLayerCount: 1}); |
| try { |
| renderPassEncoder5.end(); |
| } catch {} |
| try { |
| commandEncoder29.clearBuffer(buffer3); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 96, height: 1820, depthOrArrayLayers: 296} |
| */ |
| { |
| source: videoFrame1, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture12, |
| mipLevel: 0, |
| origin: {x: 37, y: 523, z: 127}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture42 = device0.createTexture({ |
| size: [25, 1, 1], |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder37 = commandEncoder29.beginComputePass(); |
| let sampler30 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'repeat', addressModeW: 'repeat', magFilter: 'nearest'}); |
| try { |
| renderPassEncoder7.setViewport(981.5180925527513, 30.04836669446285, 3567.6508630422427, 0.0782795093228465, 0.6832262337153818, 0.8131623021283898); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(7, buffer13); |
| } catch {} |
| try { |
| computePassEncoder1.popDebugGroup(); |
| } catch {} |
| let veryExplicitBindGroupLayout6 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 41, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'r32uint', access: 'read-only', viewDimension: '2d-array' }, |
| }, |
| ], |
| }); |
| let bindGroup12 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout5, |
| entries: [ |
| {binding: 19, resource: externalTexture1}, |
| {binding: 44, resource: externalTexture1}, |
| {binding: 131, resource: externalTexture1}, |
| {binding: 47, resource: {buffer: buffer4, offset: 0, size: 1364}}, |
| {binding: 59, resource: externalTexture0}, |
| ], |
| }); |
| let commandEncoder44 = device0.createCommandEncoder(); |
| let computePassEncoder38 = commandEncoder44.beginComputePass({}); |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| try { |
| await promise5; |
| } catch {} |
| let bindGroup13 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout3, |
| entries: [ |
| {binding: 52, resource: externalTexture1}, |
| {binding: 110, resource: {buffer: buffer18, offset: 0, size: 740}}, |
| {binding: 141, resource: {buffer: buffer18, offset: 1024, size: 188}}, |
| ], |
| }); |
| let pipelineLayout4 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout1, veryExplicitBindGroupLayout1]}); |
| let commandEncoder45 = device0.createCommandEncoder({}); |
| let textureView40 = texture21.createView({dimension: '2d-array', mipLevelCount: 1}); |
| let computePassEncoder39 = commandEncoder45.beginComputePass({}); |
| let videoFrame7 = new VideoFrame(videoFrame4, {timestamp: 0}); |
| let buffer23 = device0.createBuffer({ |
| size: 13619, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let textureView41 = texture35.createView({mipLevelCount: 1}); |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer23, 'uint32', 124, 3_233); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 456, new DataView(new ArrayBuffer(2767)), 13, 108); |
| } catch {} |
| let promise8 = device0.queue.onSubmittedWorkDone(); |
| document.body.append(canvas1); |
| await gc(); |
| try { |
| adapter0.label = '\u{1ff5e}\u6150'; |
| } catch {} |
| let textureView42 = texture39.createView({dimension: '2d-array', aspect: 'all', mipLevelCount: 1}); |
| let textureView43 = texture9.createView({}); |
| let sampler31 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 92.42, |
| }); |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer17, 'uint16', 556, 11); |
| } catch {} |
| try { |
| renderPassEncoder6.setVertexBuffer(1, buffer12, 180); |
| } catch {} |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| try { |
| computePassEncoder39.setBindGroup(2, bindGroup12); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| try { |
| globalThis.someLabel = device0.queue.label; |
| } catch {} |
| let pipelineLayout5 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout3]}); |
| try { |
| computePassEncoder27.setBindGroup(0, bindGroup0); |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(0, bindGroup5); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(3, bindGroup7, new Uint32Array(3544), 542, 0); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'srgb', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer16, 240, new DataView(new ArrayBuffer(5762)), 8, 1028); |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| canvas1.height = 1200; |
| let veryExplicitBindGroupLayout7 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 41, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'r32uint', access: 'read-only', viewDimension: '2d-array' }, |
| }, |
| ], |
| }); |
| try { |
| computePassEncoder22.setBindGroup(1, bindGroup13, new Uint32Array(1373), 341, 1); |
| } catch {} |
| try { |
| renderPassEncoder6.setScissorRect(2, 0, 587, 0); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| } catch {} |
| let pipelineLayout6 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout1, veryExplicitBindGroupLayout4]}); |
| let sampler32 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'repeat', addressModeW: 'mirror-repeat'}); |
| try { |
| device0.queue.writeBuffer(buffer5, 2084, new DataView(new ArrayBuffer(19491)), 252, 104); |
| } catch {} |
| let veryExplicitBindGroupLayout8 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 3, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 49, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 52, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'storage', minBindingSize: 26, hasDynamicOffset: false }, |
| }, |
| { |
| binding: 85, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'rgba32uint', access: 'write-only', viewDimension: '3d' }, |
| }, |
| { |
| binding: 322, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 356, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '3d' }, |
| }, |
| ], |
| }); |
| let commandEncoder46 = device0.createCommandEncoder({}); |
| let textureView44 = texture24.createView({dimension: '2d-array', mipLevelCount: 1}); |
| let computePassEncoder40 = commandEncoder46.beginComputePass({timestampWrites: {querySet: querySet1, beginningOfPassWriteIndex: 249, endOfPassWriteIndex: 115}}); |
| let sampler33 = device0.createSampler({addressModeV: 'mirror-repeat', minFilter: 'linear', lodMaxClamp: 95.97, maxAnisotropy: 1}); |
| try { |
| renderPassEncoder4.setVertexBuffer(6, buffer7, 0, 562); |
| } catch {} |
| try { |
| device0.pushErrorScope('validation'); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| await promise8; |
| } catch {} |
| let commandEncoder47 = device0.createCommandEncoder(); |
| let sampler34 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 93.30, |
| maxAnisotropy: 20, |
| }); |
| try { |
| renderPassEncoder0.setBindGroup(1, bindGroup0); |
| } catch {} |
| try { |
| commandEncoder47.copyBufferToTexture({ |
| /* bytesInLastRow: 916 widthInBlocks: 229 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 740 */ |
| offset: 740, |
| bytesPerRow: 48640, |
| rowsPerImage: 361, |
| buffer: buffer11, |
| }, { |
| texture: texture41, |
| mipLevel: 0, |
| origin: {x: 545, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 229, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup14 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout5, |
| entries: [ |
| {binding: 47, resource: {buffer: buffer14, offset: 256, size: 524}}, |
| {binding: 59, resource: externalTexture2}, |
| {binding: 19, resource: externalTexture0}, |
| {binding: 131, resource: externalTexture3}, |
| {binding: 44, resource: externalTexture3}, |
| ], |
| }); |
| let commandEncoder48 = device0.createCommandEncoder({}); |
| let computePassEncoder41 = commandEncoder47.beginComputePass({}); |
| try { |
| computePassEncoder41.setBindGroup(0, bindGroup11); |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(3, bindGroup11); |
| } catch {} |
| try { |
| renderPassEncoder1.setScissorRect(29, 6, 197, 15); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture4, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(271).fill(106), /* required buffer size: 271 */ |
| {offset: 271}, {width: 3, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let promise9 = device0.queue.onSubmittedWorkDone(); |
| await gc(); |
| let computePassEncoder42 = commandEncoder48.beginComputePass(); |
| let sampler35 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 96.11, |
| maxAnisotropy: 11, |
| }); |
| try { |
| renderPassEncoder7.setViewport(2462.0354652799606, 3.8382786319787288, 1316.8227611346247, 13.420165054392012, 0.6385560447177122, 0.6399360139856379); |
| } catch {} |
| let pipelineLayout7 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout2]}); |
| let textureView45 = texture40.createView({aspect: 'all', arrayLayerCount: 1}); |
| try { |
| computePassEncoder38.setBindGroup(1, bindGroup12); |
| } catch {} |
| try { |
| computePassEncoder9.setBindGroup(2, bindGroup2, new Uint32Array(1076), 32, 1); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer5, 1880, new DataView(new ArrayBuffer(17759)), 5856, 344); |
| } catch {} |
| let veryExplicitBindGroupLayout9 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 52, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}}, |
| { |
| binding: 110, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 141, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: true }, |
| }, |
| ], |
| }); |
| let bindGroup15 = device0.createBindGroup({layout: veryExplicitBindGroupLayout6, entries: [{binding: 41, resource: textureView42}]}); |
| let textureView46 = texture26.createView({}); |
| try { |
| computePassEncoder19.setBindGroup(0, bindGroup4); |
| } catch {} |
| try { |
| computePassEncoder15.setBindGroup(1, bindGroup11, new Uint32Array(2147), 191, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.setScissorRect(5, 0, 1093, 4); |
| } catch {} |
| let bindGroup16 = device0.createBindGroup({layout: veryExplicitBindGroupLayout7, entries: [{binding: 41, resource: textureView36}]}); |
| let commandEncoder49 = device0.createCommandEncoder({}); |
| let renderPassEncoder8 = commandEncoder49.beginRenderPass({colorAttachments: [{view: textureView29, depthSlice: 23, loadOp: 'load', storeOp: 'store'}]}); |
| let sampler36 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'repeat', minFilter: 'nearest', compare: 'greater-equal'}); |
| try { |
| renderPassEncoder4.setStencilReference(171); |
| } catch {} |
| try { |
| renderPassEncoder7.setVertexBuffer(7, undefined, 0, 729_784_924); |
| } catch {} |
| try { |
| await promise9; |
| } catch {} |
| let veryExplicitBindGroupLayout10 = device0.createBindGroupLayout({entries: []}); |
| let commandEncoder50 = device0.createCommandEncoder(); |
| let texture43 = device0.createTexture({ |
| size: {width: 5600, height: 34, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderPassEncoder9 = commandEncoder50.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView27, |
| clearValue: { r: -723.1, g: 882.7, b: -746.5, a: -479.7, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet0, |
| timestampWrites: {querySet: querySet1, beginningOfPassWriteIndex: 41, endOfPassWriteIndex: 264}, |
| }); |
| try { |
| renderPassEncoder9.insertDebugMarker('\u4f64'); |
| } catch {} |
| let textureView47 = texture10.createView({mipLevelCount: 1}); |
| let sampler37 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 81.92, |
| maxAnisotropy: 6, |
| }); |
| try { |
| computePassEncoder37.setBindGroup(3, bindGroup1); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture21, |
| mipLevel: 1, |
| origin: {x: 2, y: 1441, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(232).fill(7), /* required buffer size: 232 */ |
| {offset: 232, bytesPerRow: 61}, {width: 4, height: 152, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let textureView48 = texture34.createView({dimension: '2d-array'}); |
| let sampler38 = device0.createSampler({addressModeU: 'repeat', addressModeW: 'mirror-repeat', lodMaxClamp: 79.41}); |
| try { |
| renderPassEncoder8.setBindGroup(0, bindGroup8); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(2, bindGroup12, new Uint32Array(605), 60, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.setBlendConstant({ r: 439.7, g: 664.4, b: 154.3, a: 294.9, }); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| document.body.prepend(canvas1); |
| let bindGroup17 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout9, |
| entries: [ |
| {binding: 52, resource: externalTexture0}, |
| {binding: 110, resource: {buffer: buffer10, offset: 3328, size: 2144}}, |
| {binding: 141, resource: {buffer: buffer18, offset: 256, size: 68}}, |
| ], |
| }); |
| let buffer24 = device0.createBuffer({ |
| size: 547, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, |
| }); |
| let textureView49 = texture13.createView({}); |
| try { |
| computePassEncoder34.setBindGroup(3, bindGroup14, new Uint32Array(2138), 610, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.setScissorRect(3, 0, 2, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.setIndexBuffer(buffer24, 'uint32', 24, 124); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture6, |
| mipLevel: 0, |
| origin: {x: 9, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(65).fill(111), /* required buffer size: 65 */ |
| {offset: 65}, {width: 14, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| document.body.append(canvas0); |
| let commandEncoder51 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder0.setVertexBuffer(6, buffer7, 336, 2_039); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer21, 48, new Int16Array(15468), 2865, 20); |
| } catch {} |
| let commandEncoder52 = device0.createCommandEncoder({}); |
| let computePassEncoder43 = commandEncoder52.beginComputePass({}); |
| let renderPassEncoder10 = commandEncoder51.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView29, |
| depthSlice: 2, |
| clearValue: { r: 820.9, g: -811.3, b: 950.9, a: 126.4, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet2, |
| }); |
| try { |
| computePassEncoder23.setBindGroup(3, bindGroup14); |
| } catch {} |
| try { |
| computePassEncoder4.setBindGroup(2, bindGroup12, new Uint32Array(3802), 70, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.beginOcclusionQuery(90); |
| } catch {} |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer16, 'uint16', 294, 135); |
| } catch {} |
| try { |
| device0.pushErrorScope('internal'); |
| } catch {} |
| document.body.append(img0); |
| let bindGroup18 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout5, |
| entries: [ |
| {binding: 44, resource: externalTexture2}, |
| {binding: 59, resource: externalTexture2}, |
| {binding: 131, resource: externalTexture1}, |
| {binding: 47, resource: {buffer: buffer5, offset: 1024, size: 2136}}, |
| {binding: 19, resource: externalTexture3}, |
| ], |
| }); |
| let buffer25 = device0.createBuffer({ |
| size: 4670, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let commandEncoder53 = device0.createCommandEncoder({}); |
| let texture44 = device0.createTexture({ |
| size: {width: 700, height: 4, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let renderPassEncoder11 = commandEncoder53.beginRenderPass({colorAttachments: [{view: textureView44, loadOp: 'clear', storeOp: 'store'}]}); |
| try { |
| computePassEncoder33.setBindGroup(1, bindGroup2, [256]); |
| } catch {} |
| try { |
| renderPassEncoder11.setBindGroup(0, bindGroup2, [0]); |
| } catch {} |
| let shaderModule0 = device0.createShaderModule({ |
| code: ` |
| requires readonly_and_readwrite_storage_textures; |
| |
| enable f16; |
| |
| @group(0) @binding(224) var et0: texture_external; |
| |
| /* zero global variables used */ |
| fn fn0() -> array<S0, 1> { |
| var out: array<S0, 1>; |
| out[unconst_u32(66)].f2 ^= vec2i(bitcast<i32>(pack4xU8Clamp(vec4u(unconst_u32(42), unconst_u32(193), unconst_u32(2), unconst_u32(151))))); |
| var vf0: vec2f = atanh(vec2f(unconst_f32(0.1336), unconst_f32(0.03284))); |
| out[unconst_u32(261)] = S0(vec4h(unpack4xI8(unconst_u32(146)))[3], unpack4xI8(unconst_u32(146)).ar, unpack4xI8(unconst_u32(146)).zz, vec2h(unpack4xI8(unconst_u32(146)).zy)); |
| return out; |
| } |
| |
| /* used global variables: et0 */ |
| @must_use |
| fn fn2(a0: array<T3, 1>) -> array<T3, 1> { |
| var out: array<T3, 1>; |
| while bool(cos(vec2f(unconst_f32(0.04130), unconst_f32(-0.1021)))[1]) { |
| var vf7: vec4h = refract(vec4h(unconst_f16(13978.2), unconst_f16(-1178.4), unconst_f16(23570.1), unconst_f16(15645.8)), vec4h(unconst_f16(25532.8), unconst_f16(12396.4), unconst_f16(292.8), unconst_f16(1915.7)), unconst_f16(782.3)); |
| out[unconst_u32(93)] = T3(f32(override0)); |
| vf7 = bitcast<vec4h>(select(vec2f(unconst_f32(0.1827), unconst_f32(0.09836)), vec2f(unconst_f32(0.07434), unconst_f32(0.01815)), unconst_bool(true))); |
| let vf8: vec3h = sin(vec3h(unconst_f16(474.8), unconst_f16(12707.6), unconst_f16(-4107.8))); |
| _ = override0; |
| } |
| var vf9: u32 = pack4x8unorm(vec4f(unconst_f32(0.1927), unconst_f32(0.00758), unconst_f32(0.05117), unconst_f32(0.2624))); |
| let ptr2: ptr<function, u32> = &vf9; |
| let vf10: vec3i = (vec3i(unconst_i32(-77), unconst_i32(30), unconst_i32(34)) / unconst_i32(13)); |
| switch i32(all((vec3h(unconst_f16(2282.6), unconst_f16(-1431.9), unconst_f16(477.7)) >= vec3h(unconst_f16(10829.5), unconst_f16(27673.7), unconst_f16(21749.2))))) { |
| default { |
| out[0].f0 += a0[0].f0; |
| let vf11: vec4h = pow(vec4h(unconst_f16(7.441), unconst_f16(-12316.0), unconst_f16(4152.0), unconst_f16(5700.6)), vec4h(unconst_f16(187.4), unconst_f16(2542.7), unconst_f16(18354.0), unconst_f16(-9333.8))); |
| var vf12: array<T3, 1> = a0; |
| var vf13: T3 = a0[0]; |
| } |
| } |
| var vf14: vec2u = textureDimensions(et0); |
| return out; |
| _ = override0; |
| _ = et0; |
| } |
| |
| struct T0 { |
| @size(16) f0: array<array<vec2h, 2>>, |
| } |
| |
| struct T2 { |
| @size(8) f0: atomic<u32>, |
| } |
| |
| /* zero global variables used */ |
| @must_use |
| fn fn5(a0: ptr<private, S1>) -> mat3x3h { |
| var out: mat3x3h; |
| var vf21: f32 = cosh(unconst_f32(0.2620)); |
| var vf22: vec3f = ceil(vec3f((vec4f(unconst_f32(0.1101), unconst_f32(0.8208), unconst_f32(0.00661), unconst_f32(0.06211)) >= vec4f(unconst_f32(0.04874), unconst_f32(0.07311), unconst_f32(0.08680), unconst_f32(0.1976))).rgb)); |
| out -= mat3x3h(f16((*a0).f1), f16((*a0).f1), f16((*a0).f1), f16((*a0).f1), f16((*a0).f1), f16((*a0).f1), f16((*a0).f1), f16((*a0).f1), f16((*a0).f1)); |
| vf22 = bitcast<vec3f>(min(vec4u(unconst_u32(76), unconst_u32(59), unconst_u32(28), unconst_u32(400)), vec4u(unconst_u32(375), unconst_u32(19), unconst_u32(77), unconst_u32(357))).wwx); |
| return out; |
| } |
| |
| override override0: f16; |
| |
| struct S1 { |
| @location(3) @interpolate(flat, either) f0: vec4i, |
| @location(14) @interpolate(flat, first) f1: f32, |
| } |
| |
| var<workgroup> vw1: T3; |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| struct T3 { |
| @size(16) f0: f32, |
| } |
| |
| var<workgroup> vw0: array<mat4x4f, 1>; |
| |
| var<workgroup> vw4: array<array<atomic<i32>, 2>, 8>; |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| /* zero global variables used */ |
| fn fn3(a0: array<mat2x3f, 1>) -> array<mat2x4h, 1> { |
| var out: array<mat2x4h, 1>; |
| while bool(pack4xU8(vec4u((vec4i(unconst_i32(197), unconst_i32(10), unconst_i32(263), unconst_i32(178)) != bitcast<vec4i>(inverseSqrt(vec3f(unconst_f32(-0.1147), unconst_f32(0.5787), unconst_f32(0.1043))).zzzx))))) { |
| let vf15: vec4f = mix(vec4f(unconst_f32(0.03975), unconst_f32(0.1287), unconst_f32(0.2832), unconst_f32(0.1243)), vec4f(unconst_f32(0.06593), unconst_f32(0.02866), unconst_f32(0.2056), unconst_f32(0.2138)), unconst_f32(0.3966)); |
| var vf16: mat2x3f = a0[0]; |
| let vf17: vec4f = vf15; |
| } |
| var vf18: vec4u = (vec4u(unconst_u32(105), unconst_u32(129), unconst_u32(183), unconst_u32(135)) - vec4u(unconst_u32(282), unconst_u32(708), unconst_u32(77), unconst_u32(225))); |
| out[0] -= mat2x4h(vec4h((vec2u(unconst_u32(293), unconst_u32(62)) == vec2u(unconst_u32(375), unconst_u32(79))).xyyx), vec4h((vec2u(unconst_u32(293), unconst_u32(62)) == vec2u(unconst_u32(375), unconst_u32(79))).grrg)); |
| while bool(a0[unconst_u32(17)][unconst_i32(1)].y) { |
| out[unconst_u32(92)] = mat2x4h(f16(a0[unconst_u32(262)][unconst_u32(450)][unconst_u32(47)]), f16(a0[unconst_u32(262)][unconst_u32(450)][unconst_u32(47)]), f16(a0[unconst_u32(262)][unconst_u32(450)][unconst_u32(47)]), f16(a0[unconst_u32(262)][unconst_u32(450)][unconst_u32(47)]), f16(a0[unconst_u32(262)][unconst_u32(450)][unconst_u32(47)]), f16(a0[unconst_u32(262)][unconst_u32(450)][unconst_u32(47)]), f16(a0[unconst_u32(262)][unconst_u32(450)][unconst_u32(47)]), f16(a0[unconst_u32(262)][unconst_u32(450)][unconst_u32(47)])); |
| break; |
| } |
| vf18 = vec4u(inverseSqrt(vec3h(unconst_f16(3948.3), unconst_f16(10568.1), unconst_f16(14244.6))).xyxy); |
| out[0] = mat2x4h(f16(pack4xU8(vec4u((vec4<bool>(unconst_bool(true), unconst_bool(true), unconst_bool(true), unconst_bool(true)) == vec4<bool>(unconst_bool(true), unconst_bool(true), unconst_bool(false), unconst_bool(true)))))), f16(pack4xU8(vec4u((vec4<bool>(unconst_bool(true), unconst_bool(true), unconst_bool(true), unconst_bool(true)) == vec4<bool>(unconst_bool(true), unconst_bool(true), unconst_bool(false), unconst_bool(true)))))), f16(pack4xU8(vec4u((vec4<bool>(unconst_bool(true), unconst_bool(true), unconst_bool(true), unconst_bool(true)) == vec4<bool>(unconst_bool(true), unconst_bool(true), unconst_bool(false), unconst_bool(true)))))), f16(pack4xU8(vec4u((vec4<bool>(unconst_bool(true), unconst_bool(true), unconst_bool(true), unconst_bool(true)) == vec4<bool>(unconst_bool(true), unconst_bool(true), unconst_bool(false), unconst_bool(true)))))), f16(pack4xU8(vec4u((vec4<bool>(unconst_bool(true), unconst_bool(true), unconst_bool(true), unconst_bool(true)) == vec4<bool>(unconst_bool(true), unconst_bool(true), unconst_bool(false), unconst_bool(true)))))), f16(pack4xU8(vec4u((vec4<bool>(unconst_bool(true), unconst_bool(true), unconst_bool(true), unconst_bool(true)) == vec4<bool>(unconst_bool(true), unconst_bool(true), unconst_bool(false), unconst_bool(true)))))), f16(pack4xU8(vec4u((vec4<bool>(unconst_bool(true), unconst_bool(true), unconst_bool(true), unconst_bool(true)) == vec4<bool>(unconst_bool(true), unconst_bool(true), unconst_bool(false), unconst_bool(true)))))), f16(pack4xU8(vec4u((vec4<bool>(unconst_bool(true), unconst_bool(true), unconst_bool(true), unconst_bool(true)) == vec4<bool>(unconst_bool(true), unconst_bool(true), unconst_bool(false), unconst_bool(true))))))); |
| var vf19: mat2x3f = a0[0]; |
| return out; |
| } |
| |
| alias vec3b = vec3<bool>; |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| var<workgroup> vw2: array<atomic<u32>, 15>; |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| /* zero global variables used */ |
| @must_use |
| fn fn4(a0: mat2x3f, a1: S1) -> S0 { |
| var out: S0; |
| out.f0 -= f16(tanh(vec2f(unconst_f32(0.1105), unconst_f32(0.00797))).y); |
| out.f2 = vec2i(reflect(vec3h(unconst_f16(5279.1), unconst_f16(2734.4), unconst_f16(18713.8)), vec3h(countOneBits(vec2u(unconst_u32(114), unconst_u32(19))).yxy)).zz); |
| let vf20: i32 = a1.f0[unconst_u32(24)]; |
| return out; |
| } |
| |
| struct S0 { |
| @location(9) f0: f16, |
| @location(5) @interpolate(flat, sample) f1: vec2i, |
| @location(11) @interpolate(flat, sample) f2: vec2i, |
| @location(4) @interpolate(linear) f3: vec2h, |
| } |
| |
| struct T1 { |
| @align(16) @size(128) f0: array<array<atomic<u32>, 1>, 1>, |
| @align(64) @size(832) f1: T0, |
| } |
| |
| /* zero global variables used */ |
| fn fn1(a0: ptr<storage, array<atomic<u32>>, read_write>) -> T3 { |
| var out: T3; |
| out.f0 *= f32(arrayLength(&(*a0))); |
| let ptr0: ptr<storage, atomic<u32>, read_write> = &(*a0)[unconst_u32(146)]; |
| atomicStore(&(*a0)[unconst_u32(120)], unconst_u32(148)); |
| out = T3(f32(atomicLoad(&(*ptr0)))); |
| let ptr1: ptr<storage, atomic<u32>, read_write> = &(*a0)[unconst_u32(387)]; |
| let vf1: u32 = pack4xU8(vec4u(unconst_u32(294), unconst_u32(53), unconst_u32(30), unconst_u32(351))); |
| atomicCompareExchangeWeak(&(*a0)[unconst_u32(57)], unconst_u32(235), unconst_u32(379)); |
| switch i32(atomicLoad(&(*ptr0))) { |
| default { |
| out.f0 = vec3f(sign(vec3i(unconst_i32(159), unconst_i32(146), unconst_i32(139))))[0]; |
| let vf2: vec3i = sign(vec3i(unconst_i32(134), unconst_i32(59), unconst_i32(350))); |
| } |
| } |
| var vf3: u32 = reverseBits(unconst_u32(335)); |
| var vf4: f16 = fma(unconst_f16(6867.8), unconst_f16(16466.1), f16(vf1)); |
| var vf5: vec2f = (vec2f(unconst_f32(-0.04498), unconst_f32(0.1981)) / unconst_f32(0.05735)); |
| var vf6: vec2<bool> = (vec2<bool>(unconst_bool(true), unconst_bool(false)) | vec2<bool>(unconst_bool(true), unconst_bool(false))); |
| return out; |
| } |
| |
| var<workgroup> vw3: bool; |
| |
| /* zero global variables used */ |
| @vertex |
| fn vertex0(a0: S0, a1: S1, @location(2) @interpolate(flat, first) a2: vec4f, @location(1) @interpolate(linear, sample) a3: f32) -> @builtin(position) vec4f { |
| var out: vec4f; |
| return out; |
| } |
| |
| /* zero global variables used */ |
| @compute @workgroup_size(1, 1, 1) |
| fn compute0(@builtin(local_invocation_id) a0: vec3u) { |
| vw0[unconst_u32(325)] = mat4x4f(bitcast<f32>(atomicLoad(&vw4[7][1])), bitcast<f32>(atomicLoad(&vw4[7][1])), bitcast<f32>(atomicLoad(&vw4[7][1])), bitcast<f32>(atomicLoad(&vw4[7][1])), bitcast<f32>(atomicLoad(&vw4[7][1])), f32(atomicLoad(&vw4[7][1])), bitcast<f32>(atomicLoad(&vw4[7][1])), bitcast<f32>(atomicLoad(&vw4[7][1])), bitcast<f32>(atomicLoad(&vw4[7][1])), bitcast<f32>(atomicLoad(&vw4[7][1])), f32(atomicLoad(&vw4[7][1])), bitcast<f32>(atomicLoad(&vw4[7][1])), f32(atomicLoad(&vw4[7][1])), f32(atomicLoad(&vw4[7][1])), bitcast<f32>(atomicLoad(&vw4[7][1])), bitcast<f32>(atomicLoad(&vw4[7][1]))); |
| vw1 = T3((*&vw0)[unconst_u32(73)][unconst_i32(1)][2]); |
| _ = fn3(array<mat2x3f, 1>(mat2x3f(bitcast<vec3f>((vec3u(unconst_u32(27), unconst_u32(108), unconst_u32(130)) & vec3u(unconst_u32(292), unconst_u32(187), unconst_u32(414)))), vec3f((vec3u(unconst_u32(27), unconst_u32(108), unconst_u32(130)) & vec3u(unconst_u32(292), unconst_u32(187), unconst_u32(414))))))); |
| let ptr3: ptr<workgroup, atomic<u32>> = &vw2[14]; |
| var vf23 = fn3(array<mat2x3f, 1>(mat2x3f(f32(atomicLoad(&vw4[7][unconst_u32(341)])), f32(atomicLoad(&vw4[7][unconst_u32(341)])), bitcast<f32>(atomicLoad(&vw4[7][unconst_u32(341)])), f32(atomicLoad(&vw4[7][unconst_u32(341)])), f32(atomicLoad(&vw4[7][unconst_u32(341)])), bitcast<f32>(atomicLoad(&vw4[7][unconst_u32(341)]))))); |
| _ = fn3(array<mat2x3f, 1>(mat2x3f(bitcast<f32>(atomicLoad(&(*&vw2)[14])), f32(atomicLoad(&(*&vw2)[14])), bitcast<f32>(atomicLoad(&(*&vw2)[14])), bitcast<f32>(atomicLoad(&(*&vw2)[14])), bitcast<f32>(atomicLoad(&(*&vw2)[14])), f32(atomicLoad(&(*&vw2)[14]))))); |
| vw1.f0 = bitcast<f32>(atomicLoad(&(*&vw4)[7][1])); |
| for (var it0=bitcast<vec3u>(min(vec3i(unconst_i32(100), unconst_i32(125), unconst_i32(75)), vec3i(unconst_i32(164), unconst_i32(127), unconst_i32(5))))[1]; it0<atomicLoad(&(*&vw2)[14]); it0++) { |
| vw1.f0 = vw0[atomicLoad(&(*&vw2)[14])][unconst_i32(1)].r; |
| var vf24: i32 = atomicLoad(&(*&vw4)[unconst_u32(231)][1]); |
| vw0[unconst_u32(148)] = mat4x4f(vec4f(sin(vec3h(unconst_f16(6123.6), unconst_f16(14604.5), unconst_f16(23848.9))).yyxx), vec4f(sin(vec3h(unconst_f16(6123.6), unconst_f16(14604.5), unconst_f16(23848.9))).yxzy), vec4f(sin(vec3h(unconst_f16(6123.6), unconst_f16(14604.5), unconst_f16(23848.9))).bggr), vec4f(sin(vec3h(unconst_f16(6123.6), unconst_f16(14604.5), unconst_f16(23848.9))).rgbb)); |
| let ptr4: ptr<workgroup, atomic<i32>> = &vw4[7][unconst_u32(186)]; |
| var vf25 = fn3(array<mat2x3f, 1>(mat2x3f((*&vw1).f0, (*&vw1).f0, (*&vw1).f0, (*&vw1).f0, (*&vw1).f0, (*&vw1).f0))); |
| return; |
| } |
| vw0[unconst_u32(109)] -= mat4x4f((*&vw0)[unconst_u32(16)][unconst_u32(31)], (*&vw0)[unconst_u32(16)][unconst_u32(31)], (*&vw0)[unconst_u32(16)][unconst_u32(31)], (*&vw0)[unconst_u32(16)][unconst_u32(31)]); |
| atomicCompareExchangeWeak(&vw2[unconst_u32(108)], unconst_u32(206), unconst_u32(6)); |
| switch atomicLoad(&vw4[unconst_u32(377)][unconst_u32(71)]) { |
| default { |
| vw1.f0 *= vec2f((vec2h(unconst_f16(8770.3), unconst_f16(5688.5)) < vec2h(unconst_f16(24236.8), unconst_f16(-4230.0)))).r; |
| break; |
| } |
| } |
| var vf26: vec4f = (*&vw0)[0][unconst_u32(288)]; |
| }`, |
| }); |
| let veryExplicitBindGroupLayout11 = device0.createBindGroupLayout({ |
| label: '\ue137\ufc59', |
| entries: [ |
| {binding: 52, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}}, |
| { |
| binding: 110, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 141, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: true }, |
| }, |
| ], |
| }); |
| let pipelineLayout8 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout9]}); |
| let commandEncoder54 = device0.createCommandEncoder({}); |
| let computePassEncoder44 = commandEncoder54.beginComputePass({}); |
| let renderBundleEncoder6 = device0.createRenderBundleEncoder({colorFormats: ['r32sint'], stencilReadOnly: true}); |
| let sampler39 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| lodMaxClamp: 55.09, |
| compare: 'greater-equal', |
| }); |
| try { |
| computePassEncoder28.setBindGroup(1, bindGroup9); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(0, bindGroup5, new Uint32Array(204), 31, 0); |
| } catch {} |
| let commandEncoder55 = device0.createCommandEncoder({}); |
| let computePassEncoder45 = commandEncoder55.beginComputePass(); |
| try { |
| computePassEncoder2.setBindGroup(0, bindGroup18, new Uint32Array(336), 51, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.setBindGroup(2, bindGroup13, new Uint32Array(50), 3, 1); |
| } catch {} |
| try { |
| renderPassEncoder0.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder11.setIndexBuffer(buffer19, 'uint16', 4, 275); |
| } catch {} |
| try { |
| renderPassEncoder11.setVertexBuffer(6, buffer0); |
| } catch {} |
| try { |
| renderBundleEncoder6.setBindGroup(3, bindGroup2, new Uint32Array(888), 147, 1); |
| } catch {} |
| try { |
| renderBundleEncoder6.setIndexBuffer(buffer23, 'uint16', 436, 2_100); |
| } catch {} |
| let pipeline0 = await device0.createComputePipelineAsync({layout: pipelineLayout0, compute: {module: shaderModule0, constants: {}}}); |
| let imageData3 = new ImageData(80, 36); |
| let textureView50 = texture25.createView({}); |
| try { |
| computePassEncoder20.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder9.setBindGroup(0, bindGroup14); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(1, bindGroup11, new Uint32Array(4379), 774, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.setIndexBuffer(buffer19, 'uint16', 126, 582); |
| } catch {} |
| try { |
| renderPassEncoder6.setVertexBuffer(3, buffer24, 0, 215); |
| } catch {} |
| try { |
| renderBundleEncoder6.setBindGroup(2, bindGroup9); |
| } catch {} |
| try { |
| renderBundleEncoder6.setIndexBuffer(buffer17, 'uint16', 196, 108); |
| } catch {} |
| let commandEncoder56 = device0.createCommandEncoder({}); |
| let computePassEncoder46 = commandEncoder56.beginComputePass({timestampWrites: {querySet: querySet1, beginningOfPassWriteIndex: 302, endOfPassWriteIndex: 225}}); |
| let sampler40 = device0.createSampler({ |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMaxClamp: 95.36, |
| }); |
| try { |
| computePassEncoder44.setBindGroup(2, bindGroup8); |
| } catch {} |
| try { |
| computePassEncoder11.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer10, 'uint32', 316, 6_361); |
| } catch {} |
| try { |
| renderPassEncoder7.setVertexBuffer(2, buffer21, 960, 15); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture33, |
| mipLevel: 0, |
| origin: {x: 39, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(392).fill(90), /* required buffer size: 392 */ |
| {offset: 392, rowsPerImage: 19}, {width: 97, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.append(canvas0); |
| await gc(); |
| let recycledExplicitBindGroupLayout0 = pipeline0.getBindGroupLayout(0); |
| let texture45 = device0.createTexture({ |
| size: {width: 102}, |
| dimension: '1d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderBundle6 = renderBundleEncoder6.finish({}); |
| let arrayBuffer0 = buffer15.getMappedRange(3664, 4); |
| let promise10 = device0.queue.onSubmittedWorkDone(); |
| let buffer26 = device0.createBuffer({ |
| size: 25077, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE, |
| }); |
| let commandEncoder57 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder9.setBindGroup(0, bindGroup11, []); |
| } catch {} |
| try { |
| renderPassEncoder11.setBindGroup(1, bindGroup15, new Uint32Array(3052), 672, 0); |
| } catch {} |
| try { |
| renderPassEncoder11.executeBundles([renderBundle0]); |
| } catch {} |
| try { |
| computePassEncoder9.pushDebugGroup('\u0e60'); |
| } catch {} |
| let texture46 = device0.createTexture({ |
| size: {width: 8, height: 8, depthOrArrayLayers: 142}, |
| dimension: '3d', |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_SRC, |
| }); |
| let computePassEncoder47 = commandEncoder57.beginComputePass({timestampWrites: {querySet: querySet1, beginningOfPassWriteIndex: 137}}); |
| try { |
| computePassEncoder7.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder7.setVertexBuffer(7, buffer14, 0); |
| } catch {} |
| try { |
| await promise10; |
| } catch {} |
| let pipelineLayout9 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout5]}); |
| let commandEncoder58 = device0.createCommandEncoder({}); |
| let texture47 = gpuCanvasContext0.getCurrentTexture(); |
| let computePassEncoder48 = commandEncoder58.beginComputePass({}); |
| try { |
| renderPassEncoder6.setBindGroup(0, bindGroup18); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(0, bindGroup15, new Uint32Array(1473), 45, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.setVertexBuffer(0, buffer24, 212, 150); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 96, height: 1820, depthOrArrayLayers: 296} |
| */ |
| { |
| source: canvas1, |
| origin: { x: 16, y: 371 }, |
| flipY: true, |
| }, { |
| texture: texture12, |
| mipLevel: 0, |
| origin: {x: 3, y: 20, z: 27}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 41, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(img0); |
| try { |
| computePassEncoder48.setBindGroup(0, bindGroup12, new Uint32Array(152), 86, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.setViewport(1993.288110218435, 27.55155377183065, 2003.5356197780513, 0.1806501682826565, 0.956988936058862, 0.9950911689460299); |
| } catch {} |
| try { |
| renderPassEncoder11.setIndexBuffer(buffer16, 'uint16', 1_260, 785); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer25, 216, new Int16Array(9963), 1136, 88); |
| } catch {} |
| let veryExplicitBindGroupLayout12 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 51, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let bindGroup19 = device0.createBindGroup({layout: veryExplicitBindGroupLayout10, entries: []}); |
| let buffer27 = device0.createBuffer({size: 2661, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let commandEncoder59 = device0.createCommandEncoder({}); |
| let texture48 = gpuCanvasContext0.getCurrentTexture(); |
| try { |
| computePassEncoder17.setBindGroup(2, bindGroup4, new Uint32Array(3412), 195, 0); |
| } catch {} |
| try { |
| computePassEncoder37.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(1, buffer7, 1_316, 1_270); |
| } catch {} |
| try { |
| commandEncoder59.copyBufferToBuffer(buffer15, 988, buffer3, 524, 384); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| colorSpace: 'display-p3', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let texture49 = device0.createTexture({ |
| size: [12, 1, 41], |
| sampleCount: 1, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder36.setBindGroup(2, bindGroup17, new Uint32Array(2117), 40, 1); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(1, bindGroup16, new Uint32Array(3494), 257, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(7, buffer0, 6_544, 54); |
| } catch {} |
| try { |
| commandEncoder59.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 808 */ |
| offset: 808, |
| buffer: buffer0, |
| }, { |
| texture: texture38, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 5}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer28 = device0.createBuffer({ |
| size: 20693, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder60 = device0.createCommandEncoder({label: '\ud394\u58bf'}); |
| try { |
| computePassEncoder27.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder9.setVertexBuffer(1, buffer22, 0); |
| } catch {} |
| let arrayBuffer1 = buffer15.getMappedRange(3672, 44); |
| try { |
| commandEncoder60.resolveQuerySet(querySet0, 311, 261, buffer26, 5376); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer16, 716, new DataView(new ArrayBuffer(1744))); |
| } catch {} |
| let sampler41 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| lodMaxClamp: 95.33, |
| compare: 'never', |
| maxAnisotropy: 1, |
| }); |
| try { |
| computePassEncoder36.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(2, bindGroup11); |
| } catch {} |
| try { |
| renderPassEncoder9.end(); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer16, 'uint32', 2_728, 528); |
| } catch {} |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55); }; |
| } catch {} |
| let commandBuffer1 = commandEncoder50.finish(); |
| let textureView51 = texture25.createView({baseArrayLayer: 0}); |
| let textureView52 = texture20.createView({dimension: '2d', mipLevelCount: 1}); |
| let sampler42 = device0.createSampler({ |
| addressModeV: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| maxAnisotropy: 7, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder27); computePassEncoder27.dispatchWorkgroups(1, 1, 2); }; |
| } catch {} |
| try { |
| renderPassEncoder0.beginOcclusionQuery(372); |
| } catch {} |
| try { |
| renderPassEncoder10.setIndexBuffer(buffer26, 'uint16', 4_526, 6_658); |
| } catch {} |
| try { |
| renderPassEncoder8.setVertexBuffer(1, buffer7, 484, 802); |
| } catch {} |
| try { |
| commandEncoder60.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 120 */ |
| offset: 120, |
| buffer: buffer10, |
| }, { |
| texture: texture20, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| let pipeline1 = await device0.createComputePipelineAsync({layout: pipelineLayout1, compute: {module: shaderModule0, constants: {}}}); |
| let bindGroup20 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout2, |
| entries: [ |
| {binding: 19, resource: externalTexture3}, |
| {binding: 59, resource: externalTexture2}, |
| {binding: 47, resource: {buffer: buffer26, offset: 512, size: 2360}}, |
| {binding: 44, resource: externalTexture1}, |
| {binding: 131, resource: externalTexture0}, |
| ], |
| }); |
| let computePassEncoder49 = commandEncoder59.beginComputePass(); |
| let renderPassEncoder12 = commandEncoder60.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView44, |
| clearValue: { r: 673.1, g: 680.0, b: -176.5, a: 727.1, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| }); |
| let externalTexture4 = device0.importExternalTexture({source: videoFrame2, colorSpace: 'display-p3'}); |
| try { |
| computePassEncoder48.setBindGroup(0, bindGroup19); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer24, 'uint32', 544, 0); |
| } catch {} |
| try { |
| renderPassEncoder12.setVertexBuffer(5, buffer22, 0, 997); |
| } catch {} |
| try { |
| renderPassEncoder4.insertDebugMarker('\u{1fc62}'); |
| } catch {} |
| let renderBundleEncoder7 = device0.createRenderBundleEncoder({colorFormats: ['r32sint'], depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| computePassEncoder33.setBindGroup(3, bindGroup15, new Uint32Array(2057), 1_065, 0); |
| } catch {} |
| try { |
| computePassEncoder18.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder7.setBindGroup(2, bindGroup7, new Uint32Array(1271), 112, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(3, buffer21); |
| } catch {} |
| try { |
| computePassEncoder9.popDebugGroup(); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer1]); |
| } catch {} |
| let imageBitmap0 = await createImageBitmap(videoFrame4); |
| let texture50 = device0.createTexture({ |
| size: {width: 1400, height: 8, depthOrArrayLayers: 15}, |
| mipLevelCount: 8, |
| dimension: '3d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderBundleEncoder8 = device0.createRenderBundleEncoder({colorFormats: ['rgba8sint'], depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| computePassEncoder42.setBindGroup(1, bindGroup5); |
| } catch {} |
| try { |
| renderPassEncoder8.executeBundles([renderBundle2, renderBundle2, renderBundle6, renderBundle6]); |
| } catch {} |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55); }; |
| } catch {} |
| let buffer29 = device0.createBuffer({ |
| size: 15227, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder61 = device0.createCommandEncoder({}); |
| let texture51 = device0.createTexture({ |
| size: [25, 1, 1], |
| mipLevelCount: 2, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let computePassEncoder50 = commandEncoder61.beginComputePass({}); |
| let renderBundleEncoder9 = device0.createRenderBundleEncoder({colorFormats: ['r32sint'], sampleCount: 1, stencilReadOnly: false}); |
| try { |
| renderPassEncoder4.setBlendConstant({ r: 354.8, g: -593.3, b: 451.2, a: -639.1, }); |
| } catch {} |
| try { |
| renderPassEncoder8.setViewport(16.195234642014373, 0.3919902835332618, 3.559455022002895, 0.08936283320584842, 0.49161907901334945, 0.88835639103303); |
| } catch {} |
| try { |
| renderBundleEncoder7.setIndexBuffer(buffer29, 'uint16', 436, 3_642); |
| } catch {} |
| let texture52 = device0.createTexture({ |
| size: {width: 48}, |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView53 = texture45.createView({}); |
| try { |
| computePassEncoder1.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder7.setBindGroup(1, bindGroup13, new Uint32Array(391), 29, 1); |
| } catch {} |
| try { |
| renderBundleEncoder8.setIndexBuffer(buffer17, 'uint16', 666, 0); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let texture53 = device0.createTexture({ |
| size: {width: 12, height: 1, depthOrArrayLayers: 66}, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| try { |
| computePassEncoder32.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder7.setBindGroup(0, bindGroup20); |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(3, bindGroup7, new Uint32Array(4467), 1, 0); |
| } catch {} |
| try { |
| renderPassEncoder10.setVertexBuffer(2, buffer13, 0, 741); |
| } catch {} |
| try { |
| renderBundleEncoder8.setBindGroup(2, bindGroup0); |
| } catch {} |
| try { |
| renderBundleEncoder7.setBindGroup(2, bindGroup20, new Uint32Array(466), 13, 0); |
| } catch {} |
| try { |
| renderBundleEncoder8.setVertexBuffer(0, buffer22); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture13, |
| mipLevel: 0, |
| origin: {x: 173, y: 0, z: 8}, |
| aspect: 'all', |
| }, new Uint8Array(17_552).fill(71), /* required buffer size: 17_552 */ |
| {offset: 64, bytesPerRow: 1592, rowsPerImage: 2}, {width: 98, height: 1, depthOrArrayLayers: 6}); |
| } catch {} |
| let pipelineLayout10 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout3]}); |
| let textureView54 = texture39.createView({dimension: '2d-array', aspect: 'all'}); |
| try { |
| renderPassEncoder10.executeBundles([renderBundle1, renderBundle3]); |
| } catch {} |
| try { |
| buffer19.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture12, |
| mipLevel: 0, |
| origin: {x: 9, y: 323, z: 64}, |
| aspect: 'all', |
| }, new Uint8Array(1_173_959).fill(26), /* required buffer size: 1_173_959 */ |
| {offset: 36, bytesPerRow: 147, rowsPerImage: 575}, {width: 32, height: 511, depthOrArrayLayers: 14}); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let recycledExplicitBindGroupLayout1 = pipeline0.getBindGroupLayout(0); |
| let commandEncoder62 = device0.createCommandEncoder({}); |
| let texture54 = device0.createTexture({ |
| size: {width: 1400}, |
| dimension: '1d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderPassEncoder13 = commandEncoder62.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView21, |
| clearValue: { r: 251.8, g: 755.7, b: 993.8, a: -631.4, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| computePassEncoder10.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder12.setIndexBuffer(buffer29, 'uint32', 72, 1_448); |
| } catch {} |
| try { |
| renderBundleEncoder7.setIndexBuffer(buffer19, 'uint16', 184, 106); |
| } catch {} |
| try { |
| renderBundleEncoder7.setVertexBuffer(2, buffer21, 0, 932); |
| } catch {} |
| let videoFrame8 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-cl', primaries: 'bt470bg', transfer: 'gamma22curve'} }); |
| let commandEncoder63 = device0.createCommandEncoder({}); |
| let computePassEncoder51 = commandEncoder63.beginComputePass({timestampWrites: {querySet: querySet1, beginningOfPassWriteIndex: 234}}); |
| let renderBundleEncoder10 = device0.createRenderBundleEncoder({colorFormats: ['r32sint'], depthReadOnly: true}); |
| let externalTexture5 = device0.importExternalTexture({source: videoFrame7, colorSpace: 'display-p3'}); |
| try { |
| computePassEncoder40.setBindGroup(0, bindGroup18, new Uint32Array(119), 15, 0); |
| } catch {} |
| try { |
| computePassEncoder26.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder4.executeBundles([renderBundle4]); |
| } catch {} |
| try { |
| renderBundleEncoder10.setBindGroup(3, bindGroup11, new Uint32Array(165), 32, 0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture22, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 14}, |
| aspect: 'all', |
| }, new Uint8Array(1_413).fill(89), /* required buffer size: 1_413 */ |
| {offset: 153, bytesPerRow: 30, rowsPerImage: 7}, {width: 2, height: 0, depthOrArrayLayers: 7}); |
| } catch {} |
| let commandEncoder64 = device0.createCommandEncoder({}); |
| let computePassEncoder52 = commandEncoder64.beginComputePass({}); |
| let sampler43 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'mirror-repeat'}); |
| try { |
| computePassEncoder24.setBindGroup(0, bindGroup11); |
| } catch {} |
| try { |
| renderPassEncoder12.setIndexBuffer(buffer19, 'uint32', 288, 126); |
| } catch {} |
| try { |
| renderPassEncoder10.setVertexBuffer(2, buffer7, 0, 605); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer4, 512, new Float32Array(5927), 616, 8); |
| } catch {} |
| document.body.prepend(img0); |
| let videoFrame9 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-ncl', primaries: 'smpte432', transfer: 'pq'} }); |
| try { |
| globalThis.someLabel = computePassEncoder28.label; |
| } catch {} |
| let pipelineLayout11 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout4]}); |
| try { |
| renderPassEncoder0.setBindGroup(2, bindGroup15, new Uint32Array(643), 12, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.setVertexBuffer(3, buffer29); |
| } catch {} |
| try { |
| renderBundleEncoder10.setBindGroup(2, bindGroup17, [0]); |
| } catch {} |
| try { |
| renderBundleEncoder10.setIndexBuffer(buffer26, 'uint16', 2_122, 1_288); |
| } catch {} |
| let veryExplicitBindGroupLayout13 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 52, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}}, |
| { |
| binding: 110, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 141, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: true }, |
| }, |
| ], |
| }); |
| let commandEncoder65 = device0.createCommandEncoder({}); |
| let texture55 = device0.createTexture({ |
| size: {width: 192, height: 3640, depthOrArrayLayers: 1}, |
| mipLevelCount: 1, |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderPassEncoder14 = commandEncoder65.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView37, |
| clearValue: { r: 210.0, g: 575.8, b: 239.6, a: -47.17, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| maxDrawCount: 359945016, |
| }); |
| try { |
| computePassEncoder27.setBindGroup(0, bindGroup11, new Uint32Array(871), 182, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder10); computePassEncoder10.dispatchWorkgroupsIndirect(buffer22, 6_216); }; |
| } catch {} |
| try { |
| computePassEncoder16.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder11.setBindGroup(0, bindGroup11); |
| } catch {} |
| try { |
| renderPassEncoder6.executeBundles([renderBundle4]); |
| } catch {} |
| try { |
| renderPassEncoder14.setVertexBuffer(4, buffer12, 164, 172); |
| } catch {} |
| let arrayBuffer2 = buffer1.getMappedRange(8, 16); |
| let commandEncoder66 = device0.createCommandEncoder({}); |
| let texture56 = device0.createTexture({ |
| size: [102, 1, 393], |
| dimension: '3d', |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture57 = device0.createTexture({ |
| size: [12, 1, 57], |
| dimension: '3d', |
| format: 'r32sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let textureView55 = texture17.createView({baseArrayLayer: 10, arrayLayerCount: 2}); |
| let renderPassEncoder15 = commandEncoder66.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView21, |
| clearValue: { r: 619.6, g: -799.1, b: 297.1, a: -636.5, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| maxDrawCount: 128027364, |
| }); |
| try { |
| computePassEncoder8.setBindGroup(2, bindGroup19); |
| } catch {} |
| try { |
| computePassEncoder11.setBindGroup(1, bindGroup15, new Uint32Array(3002), 29, 0); |
| } catch {} |
| try { |
| computePassEncoder51.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder10.beginOcclusionQuery(9); |
| } catch {} |
| try { |
| renderPassEncoder13.setIndexBuffer(buffer19, 'uint32', 56, 15); |
| } catch {} |
| try { |
| renderBundleEncoder9.setBindGroup(3, bindGroup8, new Uint32Array(7), 0, 0); |
| } catch {} |
| try { |
| renderBundleEncoder7.setIndexBuffer(buffer16, 'uint32', 4, 615); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 96, height: 1820, depthOrArrayLayers: 296} |
| */ |
| { |
| source: videoFrame3, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture12, |
| mipLevel: 0, |
| origin: {x: 18, y: 115, z: 69}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture58 = device0.createTexture({ |
| size: [25, 1, 122], |
| dimension: '3d', |
| format: 'rgba32float', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder6.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(1, bindGroup13, new Uint32Array(312), 7, 1); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(3, buffer28); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| canvas1.height = 61; |
| let buffer30 = device0.createBuffer({ |
| size: 1707, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let textureView56 = texture58.createView({dimension: '3d'}); |
| let texture59 = device0.createTexture({ |
| size: [102, 1, 1], |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let renderBundle7 = renderBundleEncoder7.finish({}); |
| let sampler44 = device0.createSampler({ |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 73.60, |
| maxAnisotropy: 18, |
| }); |
| try { |
| computePassEncoder37.setBindGroup(0, bindGroup5); |
| } catch {} |
| try { |
| computePassEncoder9.setBindGroup(1, bindGroup18, new Uint32Array(684), 37, 0); |
| } catch {} |
| try { |
| computePassEncoder12.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderBundleEncoder10.setVertexBuffer(5, buffer7, 1_044, 862); |
| } catch {} |
| try { |
| renderPassEncoder13.insertDebugMarker('\u7acb'); |
| } catch {} |
| try { |
| globalThis.someLabel = externalTexture1.label; |
| } catch {} |
| let commandEncoder67 = device0.createCommandEncoder(); |
| let textureView57 = texture1.createView({aspect: 'all', baseMipLevel: 0, baseArrayLayer: 15, arrayLayerCount: 2}); |
| let computePassEncoder53 = commandEncoder67.beginComputePass(); |
| try { |
| computePassEncoder32.setBindGroup(3, bindGroup4); |
| } catch {} |
| try { |
| computePassEncoder48.setBindGroup(2, bindGroup6, new Uint32Array(100), 6, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.setBindGroup(0, bindGroup9, []); |
| } catch {} |
| try { |
| renderBundleEncoder10.setIndexBuffer(buffer28, 'uint16', 15_004, 1_542); |
| } catch {} |
| let recycledExplicitBindGroupLayout2 = pipeline0.getBindGroupLayout(0); |
| let textureView58 = texture56.createView({format: 'rgba32float'}); |
| try { |
| computePassEncoder46.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(2, bindGroup14); |
| } catch {} |
| try { |
| renderPassEncoder10.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder7.setIndexBuffer(buffer14, 'uint32', 56, 184); |
| } catch {} |
| try { |
| globalThis.someLabel = computePassEncoder24.label; |
| } catch {} |
| let renderBundle8 = renderBundleEncoder8.finish({}); |
| let sampler45 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| lodMinClamp: 97.16, |
| lodMaxClamp: 98.72, |
| maxAnisotropy: 1, |
| }); |
| try { |
| computePassEncoder30.setBindGroup(3, bindGroup17, new Uint32Array(1547), 235, 1); |
| } catch {} |
| try { |
| renderBundleEncoder10.setVertexBuffer(4, buffer12, 0, 169); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer4, 392, new Int16Array(13512), 185, 44); |
| } catch {} |
| let promise11 = device0.queue.onSubmittedWorkDone(); |
| let imageData4 = new ImageData(256, 60); |
| let commandEncoder68 = device0.createCommandEncoder({}); |
| let texture60 = device0.createTexture({ |
| size: [24, 455, 1], |
| dimension: '2d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView59 = texture20.createView({dimension: '2d'}); |
| let computePassEncoder54 = commandEncoder68.beginComputePass({}); |
| try { |
| computePassEncoder31.setBindGroup(1, bindGroup16); |
| } catch {} |
| try { |
| computePassEncoder3.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder7.setBindGroup(3, bindGroup17, [256]); |
| } catch {} |
| try { |
| renderPassEncoder13.executeBundles([renderBundle8, renderBundle8]); |
| } catch {} |
| try { |
| renderPassEncoder12.setVertexBuffer(7, buffer28, 6_096, 782); |
| } catch {} |
| try { |
| await promise11; |
| } catch {} |
| await gc(); |
| let buffer31 = device0.createBuffer({size: 9980, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM}); |
| let renderBundleEncoder11 = device0.createRenderBundleEncoder({colorFormats: ['rgba8sint'], sampleCount: 1, stencilReadOnly: true}); |
| let renderBundle9 = renderBundleEncoder10.finish({}); |
| try { |
| computePassEncoder38.setBindGroup(3, bindGroup16, new Uint32Array(925), 111, 0); |
| } catch {} |
| try { |
| renderPassEncoder14.setBindGroup(3, bindGroup11, new Uint32Array(27), 2, 0); |
| } catch {} |
| try { |
| renderPassEncoder14.setIndexBuffer(buffer19, 'uint32', 40, 135); |
| } catch {} |
| let commandEncoder69 = device0.createCommandEncoder({}); |
| let texture61 = device0.createTexture({ |
| size: [51, 1, 1], |
| mipLevelCount: 1, |
| sampleCount: 1, |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let computePassEncoder55 = commandEncoder69.beginComputePass({}); |
| let renderBundle10 = renderBundleEncoder11.finish(); |
| let externalTexture6 = device0.importExternalTexture({source: videoFrame0}); |
| try { |
| renderPassEncoder6.setBindGroup(0, bindGroup11, new Uint32Array(1691), 446, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer26, 'uint32', 2_508, 98); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(3, buffer10, 0, 3_836); |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let textureView60 = texture5.createView({}); |
| let renderBundleEncoder12 = device0.createRenderBundleEncoder({colorFormats: ['rgba8sint'], depthReadOnly: true}); |
| try { |
| computePassEncoder51.setBindGroup(0, bindGroup15, new Uint32Array(2003), 42, 0); |
| } catch {} |
| try { |
| computePassEncoder31.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(1, bindGroup12, []); |
| } catch {} |
| try { |
| renderBundleEncoder9.setBindGroup(3, bindGroup14); |
| } catch {} |
| try { |
| renderBundleEncoder12.setBindGroup(1, bindGroup8, new Uint32Array(204), 21, 0); |
| } catch {} |
| try { |
| renderBundleEncoder12.setVertexBuffer(3, buffer7, 0, 1_911); |
| } catch {} |
| let imageBitmap1 = await createImageBitmap(videoFrame4); |
| let buffer32 = device0.createBuffer({ |
| size: 6907, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder70 = device0.createCommandEncoder({}); |
| let sampler46 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| minFilter: 'linear', |
| lodMaxClamp: 84.68, |
| }); |
| try { |
| computePassEncoder43.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder7.executeBundles([renderBundle10, renderBundle10, renderBundle10, renderBundle10, renderBundle10]); |
| } catch {} |
| try { |
| renderPassEncoder7.setIndexBuffer(buffer5, 'uint32', 2_188, 372); |
| } catch {} |
| try { |
| commandEncoder70.copyTextureToTexture({ |
| texture: texture12, |
| mipLevel: 0, |
| origin: {x: 19, y: 196, z: 98}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture22, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 1}, |
| aspect: 'all', |
| }, |
| {width: 5, height: 0, depthOrArrayLayers: 40}); |
| } catch {} |
| let shaderModule1 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| requires pointer_composite_access; |
| |
| var<workgroup> vw5: VertexOutput0; |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| struct VertexOutput0 { |
| @invariant @builtin(position) f0: vec4f, |
| @location(13) f1: vec2f, |
| @location(5) f2: vec2h, |
| @location(15) @interpolate(flat, sample) f3: u32, |
| } |
| |
| var<workgroup> vw11: array<mat4x3f, 1>; |
| |
| var<workgroup> vw9: array<mat4x3f, 1>; |
| |
| var<workgroup> vw7: array<array<atomic<u32>, 1>, 13>; |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| var<workgroup> vw6: mat3x2h; |
| |
| @group(0) @binding(224) var et1: texture_external; |
| |
| var<workgroup> vw13: array<atomic<u32>, 1>; |
| |
| var<workgroup> vw8: VertexOutput0; |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| var<workgroup> vw12: VertexOutput0; |
| |
| /* used global variables: et1 */ |
| fn fn0(a0: ptr<function, array<array<array<VertexOutput0, 1>, 1>, 1>>, a1: array<f16, 10>) -> array<vec4f, 1> { |
| var out: array<vec4f, 1>; |
| var vf27: f16 = (*a0)[0][unconst_u32(293)][0].f2[(*a0)[0][0][0].f3]; |
| let vf28: vec4f = textureLoad(et1, vec2u(unconst_u32(179), unconst_u32(141))); |
| out[unconst_u32(66)] -= vec4f((*a0)[unconst_u32(290)][unconst_u32(317)][0].f2.grgr); |
| (*a0)[unconst_u32(200)][unconst_u32(128)][unconst_u32(255)].f3 = bitcast<vec2u>((*a0)[0][unconst_u32(29)][0].f1).r; |
| let ptr5: ptr<function, array<array<VertexOutput0, 1>, 1>> = &(*a0)[unconst_u32(190)]; |
| let vf29: f16 = (*a0)[unconst_u32(57)][unconst_u32(183)][unconst_u32(70)].f2[unconst_u32(33)]; |
| var vf30: vec4f = (vec4f(unconst_f32(0.02067), unconst_f32(0.2849), unconst_f32(-0.2143), unconst_f32(0.1019)) / vec4f(unconst_f32(-0.00735), unconst_f32(0.3968), unconst_f32(0.06572), unconst_f32(0.03588))); |
| let ptr6: ptr<function, u32> = &(*a0)[bitcast<u32>((*a0)[unconst_u32(258)][0][unconst_u32(333)].f0[unconst_u32(107)])][0][unconst_u32(154)].f3; |
| let ptr7: ptr<function, array<VertexOutput0, 1>> = &(*a0)[0][0]; |
| let ptr8: ptr<function, vec4f> = &(*a0)[0][0][unconst_u32(2)].f0; |
| return out; |
| _ = et1; |
| } |
| |
| struct T0 { |
| @align(16) @size(144) f0: array<u32>, |
| } |
| |
| var<workgroup> vw10: atomic<i32>; |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| /* zero global variables used */ |
| @vertex |
| fn vertex1(@location(3) @interpolate(flat) a0: vec4u) -> @builtin(position) vec4f { |
| var out: vec4f; |
| out = vec4f(f32((unconst_bool(true) || unconst_bool(false)))); |
| let vf31: vec2f = abs(vec2f(unconst_f32(0.1334), unconst_f32(0.02505))); |
| out = vec4f( !vec2<bool>(unconst_bool(true), unconst_bool(false)).yyxx); |
| return out; |
| } |
| |
| /* zero global variables used */ |
| @vertex |
| fn vertex2(@builtin(vertex_index) a0: u32, @location(6) a1: u32, @location(12) a2: f16, @location(2) @interpolate(flat, sample) a3: vec2h, @location(14) a4: vec2f, @location(13) a5: f32) -> VertexOutput0 { |
| var out: VertexOutput0; |
| let vf32: vec3h = asin(vec3h(unconst_f16(7518.4), unconst_f16(5647.5), unconst_f16(6529.4))); |
| out.f1 = vec2f(f32(pack2x16unorm(vec2f(unconst_f32(0.03036), unconst_f32(0.09520))))); |
| var vf33: vec2h = a3; |
| let vf34: vec2f = a4; |
| out = VertexOutput0(vec4f(f32(a2)), vec2f(f32(a2)), vec2h(a2), u32(a2)); |
| return out; |
| }`, |
| }); |
| let recycledExplicitBindGroupLayout3 = pipeline0.getBindGroupLayout(0); |
| let bindGroup21 = device0.createBindGroup({layout: veryExplicitBindGroupLayout10, entries: []}); |
| let renderPassEncoder16 = commandEncoder70.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView44, |
| clearValue: { r: 877.0, g: -893.4, b: -594.5, a: 223.2, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder27); computePassEncoder27.dispatchWorkgroupsIndirect(buffer9, 264); }; |
| } catch {} |
| try { |
| computePassEncoder42.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder0.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer0, 'uint16', 6_722, 66); |
| } catch {} |
| try { |
| renderPassEncoder14.setVertexBuffer(1, buffer12); |
| } catch {} |
| try { |
| renderBundleEncoder12.setBindGroup(2, bindGroup18); |
| } catch {} |
| try { |
| renderBundleEncoder9.setIndexBuffer(buffer29, 'uint32', 212, 5_939); |
| } catch {} |
| try { |
| renderBundleEncoder12.setVertexBuffer(7, buffer13); |
| } catch {} |
| let texture62 = device0.createTexture({ |
| size: [8], |
| dimension: '1d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let textureView61 = texture16.createView({}); |
| try { |
| computePassEncoder34.setBindGroup(2, bindGroup17, new Uint32Array(156), 24, 1); |
| } catch {} |
| try { |
| computePassEncoder24.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder16.setIndexBuffer(buffer10, 'uint32', 2_472, 2_890); |
| } catch {} |
| try { |
| renderBundleEncoder9.setVertexBuffer(2, buffer32); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'display-p3', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| computePassEncoder37.setBindGroup(2, bindGroup6, []); |
| } catch {} |
| try { |
| renderPassEncoder13.setViewport(578.4971508374547, 3.0972436712632208, 135.34751160997905, 0.8951493556821464, 0.12160731188612672, 0.3302233986554911); |
| } catch {} |
| try { |
| renderPassEncoder7.setVertexBuffer(3, buffer29, 880, 1_048); |
| } catch {} |
| try { |
| renderBundleEncoder12.setVertexBuffer(6, buffer22, 0, 383); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 96, height: 1820, depthOrArrayLayers: 296} |
| */ |
| { |
| source: videoFrame4, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture12, |
| mipLevel: 0, |
| origin: {x: 10, y: 11, z: 17}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder71 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder16.setBindGroup(1, bindGroup18, new Uint32Array(1630), 803, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder37); computePassEncoder37.dispatchWorkgroupsIndirect(buffer22, 3_060); }; |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(3, bindGroup16, new Uint32Array(945), 207, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer17, 'uint16', 18, 324); |
| } catch {} |
| let promise12 = shaderModule0.getCompilationInfo(); |
| let pipelineLayout12 = device0.createPipelineLayout({bindGroupLayouts: [recycledExplicitBindGroupLayout1]}); |
| let commandEncoder72 = device0.createCommandEncoder({}); |
| let computePassEncoder56 = commandEncoder71.beginComputePass({}); |
| let renderPassEncoder17 = commandEncoder72.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView44, |
| clearValue: { r: 549.9, g: -766.4, b: 992.6, a: -839.4, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet0, |
| }); |
| try { |
| computePassEncoder33.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder9.setBindGroup(1, bindGroup13, [512]); |
| } catch {} |
| try { |
| renderBundleEncoder12.setBindGroup(3, bindGroup15, new Uint32Array(969), 6, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 96, height: 1820, depthOrArrayLayers: 296} |
| */ |
| { |
| source: canvas1, |
| origin: { x: 1, y: 5 }, |
| flipY: false, |
| }, { |
| texture: texture12, |
| mipLevel: 0, |
| origin: {x: 28, y: 746, z: 51}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 17, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder73 = device0.createCommandEncoder({}); |
| let renderBundle11 = renderBundleEncoder12.finish({}); |
| try { |
| computePassEncoder19.setBindGroup(1, bindGroup11); |
| } catch {} |
| try { |
| renderPassEncoder17.beginOcclusionQuery(157); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(3, buffer0); |
| } catch {} |
| try { |
| commandEncoder73.copyTextureToTexture({ |
| texture: texture45, |
| mipLevel: 0, |
| origin: {x: 13, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture60, |
| mipLevel: 0, |
| origin: {x: 1, y: 79, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 4, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder73.clearBuffer(buffer19, 328, 212); |
| } catch {} |
| let img1 = await imageWithData(12, 180, '#10101010', '#20202020'); |
| let textureView62 = texture28.createView({mipLevelCount: 1}); |
| try { |
| computePassEncoder18.setBindGroup(0, bindGroup4, new Uint32Array(2338), 174, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder10); computePassEncoder10.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 96, height: 1820, depthOrArrayLayers: 296} |
| */ |
| { |
| source: videoFrame1, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture12, |
| mipLevel: 0, |
| origin: {x: 7, y: 206, z: 77}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture63 = device0.createTexture({ |
| size: [51, 1, 89], |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView63 = texture22.createView({arrayLayerCount: 1}); |
| let computePassEncoder57 = commandEncoder73.beginComputePass({}); |
| let sampler47 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| }); |
| try { |
| computePassEncoder56.setBindGroup(0, bindGroup20, new Uint32Array(2610), 187, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder37); computePassEncoder37.dispatchWorkgroupsIndirect(buffer13, 3_560); }; |
| } catch {} |
| try { |
| computePassEncoder37.end(); |
| } catch {} |
| try { |
| computePassEncoder56.setPipeline(pipeline1); |
| } catch {} |
| let imageData5 = new ImageData(40, 140); |
| try { |
| globalThis.someLabel = externalTexture4.label; |
| } catch {} |
| let texture64 = device0.createTexture({ |
| label: '\u{1ff78}\u115f\u0ae2\u0c0c\u{1f6aa}', |
| size: {width: 48, height: 910, depthOrArrayLayers: 1}, |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| try { |
| renderPassEncoder13.setBindGroup(2, bindGroup12, new Uint32Array(3281), 866, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer17, 'uint16', 48, 224); |
| } catch {} |
| try { |
| renderBundleEncoder9.setVertexBuffer(0, buffer24, 0, 69); |
| } catch {} |
| let texture65 = device0.createTexture({ |
| size: [12], |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let texture66 = gpuCanvasContext0.getCurrentTexture(); |
| try { |
| renderPassEncoder14.setBindGroup(2, bindGroup1); |
| } catch {} |
| try { |
| renderPassEncoder11.setBindGroup(0, bindGroup20, new Uint32Array(251), 9, 0); |
| } catch {} |
| try { |
| renderPassEncoder14.setVertexBuffer(4, buffer10, 2_504, 1_787); |
| } catch {} |
| try { |
| commandEncoder29.copyBufferToBuffer(buffer15, 5228, buffer29, 184, 6648); |
| } catch {} |
| try { |
| commandEncoder29.copyBufferToTexture({ |
| /* bytesInLastRow: 223 widthInBlocks: 223 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 1401 */ |
| offset: 1178, |
| bytesPerRow: 2304, |
| rowsPerImage: 367, |
| buffer: buffer32, |
| }, { |
| texture: texture33, |
| mipLevel: 0, |
| origin: {x: 2577, y: 8, z: 0}, |
| aspect: 'all', |
| }, {width: 223, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| let veryExplicitBindGroupLayout14 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 37, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'comparison' }}, |
| { |
| binding: 53, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let commandEncoder74 = device0.createCommandEncoder({}); |
| let textureView64 = texture61.createView({baseMipLevel: 0}); |
| let textureView65 = texture49.createView({baseArrayLayer: 0, arrayLayerCount: 1}); |
| let renderBundle12 = renderBundleEncoder9.finish({}); |
| let sampler48 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 77.55, |
| maxAnisotropy: 19, |
| }); |
| let externalTexture7 = device0.importExternalTexture({source: videoFrame7}); |
| try { |
| renderPassEncoder17.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder7.executeBundles([renderBundle10, renderBundle10]); |
| } catch {} |
| let bindGroup22 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout5, |
| entries: [ |
| {binding: 131, resource: externalTexture6}, |
| {binding: 19, resource: externalTexture5}, |
| {binding: 59, resource: externalTexture5}, |
| {binding: 44, resource: externalTexture4}, |
| {binding: 47, resource: {buffer: buffer30, offset: 256, size: 564}}, |
| ], |
| }); |
| let commandEncoder75 = device0.createCommandEncoder({}); |
| let computePassEncoder58 = commandEncoder29.beginComputePass({}); |
| let renderPassEncoder18 = commandEncoder75.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView22, |
| clearValue: { r: 837.7, g: 527.2, b: 362.6, a: 741.7, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| timestampWrites: {querySet: querySet1, beginningOfPassWriteIndex: 123}, |
| maxDrawCount: 312044909, |
| }); |
| try { |
| renderPassEncoder6.setBindGroup(1, bindGroup20, new Uint32Array(75), 7, 0); |
| } catch {} |
| let commandEncoder76 = device0.createCommandEncoder(); |
| let texture67 = device0.createTexture({ |
| size: [12, 1, 1], |
| mipLevelCount: 1, |
| format: 'r32sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView66 = texture38.createView({dimension: 'cube', baseArrayLayer: 0}); |
| let computePassEncoder59 = commandEncoder74.beginComputePass({timestampWrites: {querySet: querySet1, endOfPassWriteIndex: 102}}); |
| let renderPassEncoder19 = commandEncoder76.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView47, |
| clearValue: { r: -136.3, g: -887.6, b: 573.0, a: -268.1, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| maxDrawCount: 67402291, |
| }); |
| let commandEncoder77 = device0.createCommandEncoder(); |
| try { |
| { clearResourceUsages(device0, computePassEncoder16); computePassEncoder16.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder17.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder0.setBlendConstant({ r: 88.04, g: -921.2, b: 232.9, a: -958.2, }); |
| } catch {} |
| try { |
| commandEncoder77.copyBufferToTexture({ |
| /* bytesInLastRow: 8 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 820 */ |
| offset: 820, |
| bytesPerRow: 1536, |
| buffer: buffer27, |
| }, { |
| texture: texture64, |
| mipLevel: 0, |
| origin: {x: 4, y: 47, z: 0}, |
| aspect: 'all', |
| }, {width: 2, height: 47, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder77.copyTextureToBuffer({ |
| texture: texture28, |
| mipLevel: 6, |
| origin: {x: 5, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 88 widthInBlocks: 22 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 2752 */ |
| offset: 2752, |
| buffer: buffer29, |
| }, {width: 22, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let buffer33 = device0.createBuffer({ |
| size: 21465, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder78 = device0.createCommandEncoder({}); |
| let computePassEncoder60 = commandEncoder77.beginComputePass({}); |
| let sampler49 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| lodMinClamp: 47.77, |
| lodMaxClamp: 71.73, |
| }); |
| let arrayBuffer3 = buffer1.getMappedRange(32, 4); |
| try { |
| device0.queue.writeTexture({ |
| texture: texture33, |
| mipLevel: 0, |
| origin: {x: 1067, y: 3, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(107).fill(179), /* required buffer size: 107 */ |
| {offset: 107}, {width: 76, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder79 = device0.createCommandEncoder(); |
| let texture68 = device0.createTexture({ |
| size: {width: 48}, |
| dimension: '1d', |
| format: 'r8uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView67 = texture39.createView({}); |
| let renderPassEncoder20 = commandEncoder78.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView62, |
| clearValue: { r: -269.4, g: 429.9, b: -715.6, a: 179.6, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet2, |
| timestampWrites: {querySet: querySet1, beginningOfPassWriteIndex: 297, endOfPassWriteIndex: 205}, |
| }); |
| try { |
| computePassEncoder55.setBindGroup(0, bindGroup8, new Uint32Array(2336), 517, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder16); computePassEncoder16.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder8.setPipeline(pipeline0); |
| } catch {} |
| let textureView68 = texture37.createView({ |
| label: '\u057a\u7698\u4a77\u{1ff5b}\u{1ff09}\u3152\ub824\uf70f\u0d00\u{1fa9f}', |
| dimension: '2d', |
| aspect: 'all', |
| }); |
| let sampler50 = device0.createSampler({addressModeV: 'mirror-repeat', lodMaxClamp: 56.03, maxAnisotropy: 1}); |
| try { |
| computePassEncoder18.setBindGroup(3, bindGroup4); |
| } catch {} |
| try { |
| renderPassEncoder18.setStencilReference(1419); |
| } catch {} |
| try { |
| renderPassEncoder10.setIndexBuffer(buffer28, 'uint16', 1_144, 3_900); |
| } catch {} |
| try { |
| commandEncoder79.copyBufferToTexture({ |
| /* bytesInLastRow: 8 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 6308 */ |
| offset: 6308, |
| bytesPerRow: 9728, |
| buffer: buffer32, |
| }, { |
| texture: texture36, |
| mipLevel: 0, |
| origin: {x: 6, y: 59, z: 0}, |
| aspect: 'all', |
| }, {width: 2, height: 59, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder79.clearBuffer(buffer0, 652, 720); |
| } catch {} |
| try { |
| commandEncoder79.resolveQuerySet(querySet1, 74, 10, buffer24, 0); |
| } catch {} |
| let bindGroup23 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout2, |
| entries: [ |
| {binding: 47, resource: {buffer: buffer8, offset: 2048, size: 6036}}, |
| {binding: 59, resource: externalTexture5}, |
| {binding: 44, resource: externalTexture4}, |
| {binding: 19, resource: externalTexture3}, |
| {binding: 131, resource: externalTexture5}, |
| ], |
| }); |
| let commandEncoder80 = device0.createCommandEncoder({}); |
| let textureView69 = texture39.createView({dimension: '2d-array'}); |
| try { |
| computePassEncoder54.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(1, bindGroup13, [768]); |
| } catch {} |
| try { |
| buffer30.unmap(); |
| } catch {} |
| try { |
| commandEncoder80.resolveQuerySet(querySet0, 24, 563, buffer11, 768); |
| } catch {} |
| let textureView70 = texture42.createView({dimension: '2d-array'}); |
| let computePassEncoder61 = commandEncoder80.beginComputePass({}); |
| let sampler51 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 86.03, |
| maxAnisotropy: 6, |
| }); |
| try { |
| computePassEncoder3.setBindGroup(2, bindGroup19); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let renderPassEncoder21 = commandEncoder79.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView29, |
| depthSlice: 12, |
| clearValue: { r: -910.8, g: 344.1, b: 92.74, a: -546.7, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| computePassEncoder47.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder7.setVertexBuffer(7, buffer29, 824, 630); |
| } catch {} |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| let promise13 = device0.queue.onSubmittedWorkDone(); |
| let imageData6 = new ImageData(8, 116); |
| let textureView71 = texture35.createView({mipLevelCount: 1}); |
| let sampler52 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| maxAnisotropy: 1, |
| }); |
| try { |
| computePassEncoder11.setBindGroup(0, bindGroup22); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder11); computePassEncoder11.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder29.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder19.setBindGroup(1, bindGroup8); |
| } catch {} |
| try { |
| await buffer6.mapAsync(GPUMapMode.WRITE, 3936, 848); |
| } catch {} |
| let videoFrame10 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt470bg', primaries: 'smpte240m', transfer: 'log'} }); |
| let veryExplicitBindGroupLayout15 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 113, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'r32uint', access: 'write-only', viewDimension: '2d-array' }, |
| }, |
| ], |
| }); |
| let bindGroup24 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout9, |
| entries: [ |
| {binding: 110, resource: {buffer: buffer18, offset: 0, size: 984}}, |
| {binding: 141, resource: {buffer: buffer14, offset: 0, size: 108}}, |
| {binding: 52, resource: externalTexture1}, |
| ], |
| }); |
| let buffer34 = device0.createBuffer({size: 24538, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX}); |
| let texture69 = device0.createTexture({ |
| size: {width: 2800, height: 17, depthOrArrayLayers: 1}, |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder57.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder19.setIndexBuffer(buffer33, 'uint32', 532, 3_534); |
| } catch {} |
| let pipelineLayout13 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout12]}); |
| let commandEncoder81 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder34.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder16.setBindGroup(3, bindGroup2, [256]); |
| } catch {} |
| try { |
| renderPassEncoder8.insertDebugMarker('\ufcbe'); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| } catch {} |
| let commandEncoder82 = device0.createCommandEncoder(); |
| let arrayBuffer4 = buffer6.getMappedRange(3936, 100); |
| let bindGroup25 = device0.createBindGroup({layout: veryExplicitBindGroupLayout6, entries: [{binding: 41, resource: textureView69}]}); |
| let buffer35 = device0.createBuffer({size: 1, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM}); |
| let sampler53 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| minFilter: 'linear', |
| lodMaxClamp: 99.47, |
| }); |
| try { |
| computePassEncoder43.setBindGroup(0, bindGroup1); |
| } catch {} |
| try { |
| computePassEncoder23.setPipeline(pipeline1); |
| } catch {} |
| try { |
| commandEncoder82.copyBufferToTexture({ |
| /* bytesInLastRow: 80 widthInBlocks: 10 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 536 */ |
| offset: 536, |
| bytesPerRow: 15872, |
| rowsPerImage: 282, |
| buffer: buffer27, |
| }, { |
| texture: texture18, |
| mipLevel: 0, |
| origin: {x: 20, y: 2220, z: 0}, |
| aspect: 'all', |
| }, {width: 40, height: 312, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder82.insertDebugMarker('\u{1f65c}'); |
| } catch {} |
| let commandBuffer2 = commandEncoder82.finish(); |
| let textureView72 = texture5.createView({}); |
| let computePassEncoder62 = commandEncoder81.beginComputePass({}); |
| try { |
| computePassEncoder20.setBindGroup(0, bindGroup18, []); |
| } catch {} |
| try { |
| renderPassEncoder12.executeBundles([renderBundle5]); |
| } catch {} |
| try { |
| renderPassEncoder20.setViewport(3173.2481826326425, 28.752741518978183, 1941.2829792563236, 0.5746016473862664, 0.9447439228654875, 0.9740035994035461); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| canvas1.height = 546; |
| let buffer36 = device0.createBuffer({ |
| size: 8755, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| let sampler54 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 81.34, |
| compare: 'always', |
| maxAnisotropy: 6, |
| }); |
| let externalTexture8 = device0.importExternalTexture({source: videoFrame4}); |
| try { |
| computePassEncoder45.setBindGroup(3, bindGroup6); |
| } catch {} |
| try { |
| computePassEncoder10.setBindGroup(2, bindGroup2, new Uint32Array(1983), 692, 1); |
| } catch {} |
| try { |
| computePassEncoder11.end(); |
| } catch {} |
| try { |
| computePassEncoder30.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder7.executeBundles([renderBundle10, renderBundle10, renderBundle10]); |
| } catch {} |
| try { |
| renderPassEncoder4.setIndexBuffer(buffer19, 'uint16', 32, 12); |
| } catch {} |
| try { |
| renderPassEncoder18.setVertexBuffer(3, buffer36, 32, 2_185); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer2]); |
| } catch {} |
| let renderPassEncoder22 = commandEncoder7.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView27, |
| clearValue: { r: -953.1, g: -904.7, b: -768.7, a: 303.7, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| maxDrawCount: 109793684, |
| }); |
| try { |
| computePassEncoder58.setBindGroup(2, bindGroup24, new Uint32Array(2044), 1_184, 1); |
| } catch {} |
| try { |
| computePassEncoder15.setPipeline(pipeline1); |
| } catch {} |
| let offscreenCanvas0 = new OffscreenCanvas(98, 72); |
| try { |
| adapter0.label = '\u{1f664}\u96e5\u0ec4\u9297\u{1f908}\u51a6\u63cb\u0c72'; |
| } catch {} |
| let textureView73 = texture68.createView({}); |
| try { |
| computePassEncoder52.setBindGroup(3, bindGroup24, new Uint32Array(164), 23, 1); |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(0, bindGroup21); |
| } catch {} |
| try { |
| renderPassEncoder20.setBindGroup(0, bindGroup24, new Uint32Array(2073), 490, 1); |
| } catch {} |
| try { |
| renderPassEncoder10.setStencilReference(601); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(3, buffer32); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({device: device0, format: 'rgba8unorm', usage: GPUTextureUsage.STORAGE_BINDING}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer35, 0, new Int16Array(12536), 2263, 0); |
| } catch {} |
| let promise14 = device0.createComputePipelineAsync({layout: pipelineLayout2, compute: {module: shaderModule0, entryPoint: 'compute0'}}); |
| document.body.append(canvas1); |
| let veryExplicitBindGroupLayout16 = device0.createBindGroupLayout({ |
| entries: [{binding: 224, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}}], |
| }); |
| let bindGroup26 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout3, |
| entries: [ |
| {binding: 141, resource: {buffer: buffer23, offset: 768, size: 4716}}, |
| {binding: 110, resource: {buffer: buffer28, offset: 3328, size: 8440}}, |
| {binding: 52, resource: externalTexture7}, |
| ], |
| }); |
| let buffer37 = device0.createBuffer({size: 1963, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE}); |
| let commandEncoder83 = device0.createCommandEncoder({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder16); computePassEncoder16.dispatchWorkgroupsIndirect(buffer8, 4_120); }; |
| } catch {} |
| try { |
| computePassEncoder10.end(); |
| } catch {} |
| try { |
| computePassEncoder19.setPipeline(pipeline0); |
| } catch {} |
| try { |
| commandEncoder12.copyBufferToBuffer(buffer7, 344, buffer35, 0, 0); |
| } catch {} |
| let commandEncoder84 = device0.createCommandEncoder({}); |
| let texture70 = device0.createTexture({ |
| size: [2800, 17, 1], |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| computePassEncoder42.setBindGroup(3, bindGroup6); |
| } catch {} |
| try { |
| computePassEncoder48.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder17.executeBundles([renderBundle0, renderBundle1]); |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer26, 'uint16', 8_384, 569); |
| } catch {} |
| try { |
| renderPassEncoder17.setVertexBuffer(7, buffer24); |
| } catch {} |
| try { |
| commandEncoder12.copyTextureToBuffer({ |
| texture: texture14, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 68 widthInBlocks: 17 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 5636 */ |
| offset: 5636, |
| buffer: buffer36, |
| }, {width: 17, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let computePassEncoder63 = commandEncoder83.beginComputePass(); |
| try { |
| { clearResourceUsages(device0, computePassEncoder27); computePassEncoder27.dispatchWorkgroupsIndirect(buffer4, 36); }; |
| } catch {} |
| try { |
| renderPassEncoder13.setBindGroup(3, bindGroup0); |
| } catch {} |
| try { |
| renderPassEncoder16.executeBundles([renderBundle7]); |
| } catch {} |
| try { |
| renderPassEncoder16.setVertexBuffer(3, buffer21, 104); |
| } catch {} |
| let commandEncoder85 = device0.createCommandEncoder({}); |
| let texture71 = device0.createTexture({ |
| size: [24, 455, 226], |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let textureView74 = texture10.createView({label: '\u0b45\u0a9e\udfab\ucb1a', dimension: '2d-array', mipLevelCount: 1}); |
| try { |
| renderPassEncoder12.setIndexBuffer(buffer23, 'uint32', 1_484, 3_894); |
| } catch {} |
| let bindGroup27 = device0.createBindGroup({layout: veryExplicitBindGroupLayout6, entries: [{binding: 41, resource: textureView54}]}); |
| let querySet3 = device0.createQuerySet({type: 'timestamp', count: 284}); |
| let computePassEncoder64 = commandEncoder84.beginComputePass({}); |
| let renderPassEncoder23 = commandEncoder85.beginRenderPass({ |
| colorAttachments: [{view: textureView47, loadOp: 'clear', storeOp: 'store'}], |
| timestampWrites: {querySet: querySet1, beginningOfPassWriteIndex: 252}, |
| }); |
| try { |
| computePassEncoder0.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder14.setIndexBuffer(buffer24, 'uint16', 98, 151); |
| } catch {} |
| try { |
| commandEncoder12.copyBufferToTexture({ |
| /* bytesInLastRow: 5348 widthInBlocks: 1337 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 956 */ |
| offset: 956, |
| bytesPerRow: 22528, |
| buffer: buffer3, |
| }, { |
| texture: texture70, |
| mipLevel: 0, |
| origin: {x: 253, y: 5, z: 0}, |
| aspect: 'all', |
| }, {width: 1337, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| try { |
| commandEncoder12.copyBufferToTexture({ |
| /* bytesInLastRow: 2732 widthInBlocks: 683 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 224 */ |
| offset: 224, |
| bytesPerRow: 12800, |
| buffer: buffer26, |
| }, { |
| texture: texture54, |
| mipLevel: 0, |
| origin: {x: 192, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 683, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let commandEncoder86 = device0.createCommandEncoder(); |
| let computePassEncoder65 = commandEncoder12.beginComputePass({}); |
| let renderPassEncoder24 = commandEncoder86.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView44, |
| clearValue: { r: -44.29, g: 180.0, b: -384.7, a: -996.6, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| timestampWrites: {querySet: querySet3, beginningOfPassWriteIndex: 4294967295, endOfPassWriteIndex: 58}, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder27); computePassEncoder27.dispatchWorkgroupsIndirect(buffer4, 1_160); }; |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(3, bindGroup21); |
| } catch {} |
| try { |
| renderPassEncoder14.setVertexBuffer(0, buffer24, 104); |
| } catch {} |
| let arrayBuffer5 = buffer6.getMappedRange(4040, 24); |
| let gpuCanvasContext2 = offscreenCanvas0.getContext('webgpu'); |
| let recycledExplicitBindGroupLayout4 = pipeline0.getBindGroupLayout(0); |
| let commandEncoder87 = device0.createCommandEncoder({}); |
| let texture72 = device0.createTexture({ |
| size: [24], |
| dimension: '1d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView75 = texture3.createView({aspect: 'all', baseArrayLayer: 0}); |
| try { |
| computePassEncoder41.setBindGroup(1, bindGroup21, new Uint32Array(4434), 16, 0); |
| } catch {} |
| try { |
| computePassEncoder55.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder22.setIndexBuffer(buffer17, 'uint32', 100, 133); |
| } catch {} |
| try { |
| commandEncoder87.copyTextureToTexture({ |
| texture: texture69, |
| mipLevel: 0, |
| origin: {x: 257, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture65, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({device: device0, format: 'bgra8unorm', usage: GPUTextureUsage.COPY_DST}); |
| } catch {} |
| let promise15 = device0.queue.onSubmittedWorkDone(); |
| let commandEncoder88 = device0.createCommandEncoder({}); |
| let textureView76 = texture36.createView({mipLevelCount: 1}); |
| let renderPassEncoder25 = commandEncoder87.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView44, |
| clearValue: { r: 656.3, g: -612.5, b: 13.07, a: 293.8, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet0, |
| }); |
| let renderBundleEncoder13 = device0.createRenderBundleEncoder({colorFormats: ['r32sint'], stencilReadOnly: true}); |
| let renderBundle13 = renderBundleEncoder13.finish({}); |
| let sampler55 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| compare: 'less', |
| maxAnisotropy: 17, |
| }); |
| try { |
| commandEncoder88.copyTextureToTexture({ |
| texture: texture24, |
| mipLevel: 1, |
| origin: {x: 474, y: 2, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture1, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 11, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder89 = device0.createCommandEncoder({}); |
| let textureView77 = texture39.createView({dimension: '2d-array', mipLevelCount: 1}); |
| let computePassEncoder66 = commandEncoder88.beginComputePass({}); |
| let sampler56 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 68.62, |
| maxAnisotropy: 16, |
| }); |
| try { |
| computePassEncoder22.setBindGroup(2, bindGroup13, [0]); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder16); computePassEncoder16.dispatchWorkgroupsIndirect(buffer33, 6_236); }; |
| } catch {} |
| try { |
| computePassEncoder27.end(); |
| } catch {} |
| try { |
| computePassEncoder53.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder25.beginOcclusionQuery(203); |
| } catch {} |
| try { |
| renderPassEncoder25.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer17, 'uint32', 232, 7); |
| } catch {} |
| try { |
| renderPassEncoder16.setVertexBuffer(7, buffer7, 0, 872); |
| } catch {} |
| try { |
| await buffer27.mapAsync(GPUMapMode.WRITE, 496, 276); |
| } catch {} |
| try { |
| commandEncoder33.copyTextureToTexture({ |
| texture: texture37, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 1}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture41, |
| mipLevel: 0, |
| origin: {x: 485, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| if (!arrayBuffer5.detached) { new Uint8Array(arrayBuffer5).fill(0x55); }; |
| } catch {} |
| let texture73 = gpuCanvasContext2.getCurrentTexture(); |
| let textureView78 = texture58.createView({}); |
| let computePassEncoder67 = commandEncoder89.beginComputePass({}); |
| let sampler57 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'repeat', lodMaxClamp: 79.32}); |
| try { |
| computePassEncoder46.setBindGroup(0, bindGroup12); |
| } catch {} |
| try { |
| renderPassEncoder24.setIndexBuffer(buffer14, 'uint16', 256, 19); |
| } catch {} |
| let computePassEncoder68 = commandEncoder33.beginComputePass(); |
| try { |
| computePassEncoder45.setBindGroup(0, bindGroup12); |
| } catch {} |
| try { |
| computePassEncoder66.setBindGroup(3, bindGroup19, new Uint32Array(289), 32, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder20); computePassEncoder20.dispatchWorkgroupsIndirect(buffer32, 1_284); }; |
| } catch {} |
| try { |
| computePassEncoder39.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder7.setIndexBuffer(buffer24, 'uint32', 28, 362); |
| } catch {} |
| try { |
| texture58.label = '\u77b8\u5d42\ua330\u0002'; |
| } catch {} |
| let bindGroup28 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout11, |
| entries: [ |
| {binding: 141, resource: {buffer: buffer18, offset: 1024, size: 436}}, |
| {binding: 52, resource: externalTexture2}, |
| {binding: 110, resource: {buffer: buffer22, offset: 1024, size: 2972}}, |
| ], |
| }); |
| try { |
| renderPassEncoder25.executeBundles([renderBundle1, renderBundle3, renderBundle7, renderBundle13, renderBundle1, renderBundle7]); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer28, 'uint32', 5_496, 3_582); |
| } catch {} |
| try { |
| renderPassEncoder23.setVertexBuffer(2, buffer14); |
| } catch {} |
| try { |
| await promise13; |
| } catch {} |
| let videoFrame11 = new VideoFrame(videoFrame7, {timestamp: 0}); |
| let bindGroup29 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout9, |
| entries: [ |
| {binding: 52, resource: externalTexture7}, |
| {binding: 141, resource: {buffer: buffer23, offset: 3840, size: 2212}}, |
| {binding: 110, resource: {buffer: buffer28, offset: 7680, size: 3364}}, |
| ], |
| }); |
| let texture74 = gpuCanvasContext2.getCurrentTexture(); |
| let textureView79 = texture60.createView({}); |
| try { |
| renderPassEncoder1.setBindGroup(3, bindGroup16, new Uint32Array(1391), 99, 0); |
| } catch {} |
| try { |
| renderPassEncoder19.setBlendConstant({ r: -915.2, g: -717.1, b: 61.82, a: 569.2, }); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 96, height: 1820, depthOrArrayLayers: 296} |
| */ |
| { |
| source: videoFrame8, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture12, |
| mipLevel: 0, |
| origin: {x: 6, y: 547, z: 86}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let img2 = await imageWithData(163, 67, '#10101010', '#20202020'); |
| let buffer38 = device0.createBuffer({ |
| size: 12489, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| try { |
| computePassEncoder24.setBindGroup(3, bindGroup8, new Uint32Array(177), 3, 0); |
| } catch {} |
| try { |
| computePassEncoder13.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(3, bindGroup14, new Uint32Array(2312), 226, 0); |
| } catch {} |
| let arrayBuffer6 = buffer1.getMappedRange(40, 0); |
| try { |
| device0.queue.writeTexture({ |
| texture: texture53, |
| mipLevel: 0, |
| origin: {x: 6, y: 0, z: 13}, |
| aspect: 'all', |
| }, new Uint8Array(447).fill(83), /* required buffer size: 447 */ |
| {offset: 297, bytesPerRow: 25, rowsPerImage: 2}, {width: 0, height: 0, depthOrArrayLayers: 4}); |
| } catch {} |
| let recycledExplicitBindGroupLayout5 = pipeline0.getBindGroupLayout(0); |
| let bindGroup30 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout9, |
| entries: [ |
| {binding: 110, resource: {buffer: buffer23, offset: 512, size: 4776}}, |
| {binding: 52, resource: externalTexture4}, |
| {binding: 141, resource: {buffer: buffer23, offset: 12288, size: 208}}, |
| ], |
| }); |
| let buffer39 = device0.createBuffer({size: 42, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let commandEncoder90 = device0.createCommandEncoder({}); |
| let texture75 = device0.createTexture({ |
| size: [24], |
| dimension: '1d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder69 = commandEncoder90.beginComputePass(); |
| try { |
| computePassEncoder40.setBindGroup(0, bindGroup29, new Uint32Array(35), 2, 1); |
| } catch {} |
| try { |
| computePassEncoder38.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder22.setIndexBuffer(buffer29, 'uint32', 6_248, 8_721); |
| } catch {} |
| let pipeline2 = await device0.createComputePipelineAsync({ |
| label: '\u339c\u09a5\ud4c3\u0fdf\u55ba\u0600', |
| layout: pipelineLayout5, |
| compute: {module: shaderModule0, constants: {}}, |
| }); |
| let buffer40 = device0.createBuffer({ |
| size: 252, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| try { |
| computePassEncoder63.setBindGroup(0, bindGroup25, new Uint32Array(252), 51, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(1, bindGroup18); |
| } catch {} |
| try { |
| renderPassEncoder15.setBindGroup(1, bindGroup8, new Uint32Array(10000), 196, 0); |
| } catch {} |
| let arrayBuffer7 = buffer1.getMappedRange(48, 0); |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| let texture76 = device0.createTexture({ |
| size: [48, 910, 1], |
| mipLevelCount: 2, |
| dimension: '2d', |
| format: 'rg16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let texture77 = gpuCanvasContext0.getCurrentTexture(); |
| try { |
| { clearResourceUsages(device0, computePassEncoder20); computePassEncoder20.dispatchWorkgroupsIndirect(buffer22, 1_596); }; |
| } catch {} |
| try { |
| computePassEncoder59.setPipeline(pipeline1); |
| } catch {} |
| try { |
| await buffer39.mapAsync(GPUMapMode.WRITE, 0, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer19, 100, new DataView(new ArrayBuffer(12136)), 148, 80); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 96, height: 1820, depthOrArrayLayers: 296} |
| */ |
| { |
| source: videoFrame3, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture12, |
| mipLevel: 0, |
| origin: {x: 8, y: 195, z: 8}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let querySet4 = device0.createQuerySet({type: 'timestamp', count: 392}); |
| try { |
| computePassEncoder3.setBindGroup(0, bindGroup24, new Uint32Array(432), 27, 1); |
| } catch {} |
| try { |
| computePassEncoder49.setPipeline(pipeline2); |
| } catch {} |
| try { |
| buffer5.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer13, 7600, new Int16Array(28455), 71, 592); |
| } catch {} |
| try { |
| if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(0x55); }; |
| } catch {} |
| document.body.prepend(canvas1); |
| let commandEncoder91 = device0.createCommandEncoder(); |
| try { |
| computePassEncoder32.setBindGroup(2, bindGroup27, new Uint32Array(992), 13, 0); |
| } catch {} |
| try { |
| computePassEncoder63.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder4.executeBundles([renderBundle4]); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer0, 'uint32', 732, 431); |
| } catch {} |
| try { |
| commandEncoder91.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 112 */ |
| offset: 112, |
| bytesPerRow: 768, |
| buffer: buffer7, |
| }, { |
| texture: texture62, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(canvas1); |
| let imageData7 = new ImageData(4, 92); |
| let bindGroup31 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout5, |
| entries: [ |
| {binding: 59, resource: externalTexture7}, |
| {binding: 131, resource: externalTexture8}, |
| {binding: 44, resource: externalTexture0}, |
| {binding: 19, resource: externalTexture0}, |
| {binding: 47, resource: {buffer: buffer22, offset: 3584, size: 788}}, |
| ], |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder46); computePassEncoder46.dispatchWorkgroups(1, 1, 2); }; |
| } catch {} |
| try { |
| computePassEncoder45.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(3, bindGroup5, new Uint32Array(2231), 145, 0); |
| } catch {} |
| try { |
| renderPassEncoder18.setIndexBuffer(buffer34, 'uint16', 1_874, 4_105); |
| } catch {} |
| try { |
| renderPassEncoder4.setVertexBuffer(6, buffer28); |
| } catch {} |
| let arrayBuffer8 = buffer6.getMappedRange(4216, 8); |
| try { |
| commandEncoder91.copyBufferToTexture({ |
| /* bytesInLastRow: 124 widthInBlocks: 31 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 132 */ |
| offset: 132, |
| bytesPerRow: 3584, |
| buffer: buffer25, |
| }, { |
| texture: texture52, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 31, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipelineLayout14 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout4]}); |
| let commandEncoder92 = device0.createCommandEncoder({}); |
| let computePassEncoder70 = commandEncoder92.beginComputePass({}); |
| try { |
| computePassEncoder35.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(1, buffer14, 0, 288); |
| } catch {} |
| let buffer41 = device0.createBuffer({ |
| size: 801, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let textureView80 = texture39.createView({}); |
| let computePassEncoder71 = commandEncoder91.beginComputePass({}); |
| try { |
| computePassEncoder69.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder24.setBindGroup(0, bindGroup19); |
| } catch {} |
| try { |
| renderPassEncoder18.setBindGroup(2, bindGroup17, new Uint32Array(1761), 238, 1); |
| } catch {} |
| try { |
| renderPassEncoder21.executeBundles([]); |
| } catch {} |
| let commandEncoder93 = device0.createCommandEncoder({}); |
| let textureView81 = texture30.createView({dimension: '2d-array'}); |
| try { |
| computePassEncoder63.setBindGroup(3, bindGroup11, []); |
| } catch {} |
| try { |
| computePassEncoder67.setPipeline(pipeline2); |
| } catch {} |
| try { |
| commandEncoder93.copyBufferToTexture({ |
| /* bytesInLastRow: 12 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 2660 */ |
| offset: 2660, |
| buffer: buffer26, |
| }, { |
| texture: texture3, |
| mipLevel: 0, |
| origin: {x: 14, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 3, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup32 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [ |
| {binding: 131, resource: externalTexture8}, |
| {binding: 59, resource: externalTexture6}, |
| {binding: 44, resource: externalTexture4}, |
| {binding: 19, resource: externalTexture6}, |
| {binding: 47, resource: {buffer: buffer4, offset: 0, size: 896}}, |
| ], |
| }); |
| let texture78 = device0.createTexture({ |
| size: [12, 1, 79], |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rgba8uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder15.setBindGroup(0, bindGroup11); |
| } catch {} |
| try { |
| computePassEncoder31.setBindGroup(0, bindGroup9, new Uint32Array(1415), 14, 0); |
| } catch {} |
| try { |
| computePassEncoder16.end(); |
| } catch {} |
| try { |
| renderPassEncoder24.setBindGroup(1, bindGroup23); |
| } catch {} |
| try { |
| renderPassEncoder14.setBindGroup(0, bindGroup13, new Uint32Array(113), 1, 1); |
| } catch {} |
| try { |
| renderPassEncoder0.executeBundles([renderBundle8]); |
| } catch {} |
| try { |
| await promise12; |
| } catch {} |
| document.body.append(img1); |
| let bindGroup33 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 131, resource: externalTexture6}, |
| {binding: 19, resource: externalTexture7}, |
| {binding: 44, resource: externalTexture1}, |
| {binding: 47, resource: {buffer: buffer0, offset: 7936, size: 540}}, |
| {binding: 59, resource: externalTexture2}, |
| ], |
| }); |
| let buffer42 = device0.createBuffer({ |
| size: 17285, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let commandEncoder94 = device0.createCommandEncoder({}); |
| let textureView82 = texture12.createView({dimension: '3d'}); |
| try { |
| computePassEncoder14.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder24.setBindGroup(3, bindGroup32, new Uint32Array(1423), 68, 0); |
| } catch {} |
| try { |
| commandEncoder93.copyBufferToTexture({ |
| /* bytesInLastRow: 8 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 548 */ |
| offset: 548, |
| buffer: buffer30, |
| }, { |
| texture: texture51, |
| mipLevel: 1, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(img1); |
| let buffer43 = device0.createBuffer({ |
| size: 707, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE, |
| }); |
| let textureView83 = texture75.createView({baseMipLevel: 0}); |
| let computePassEncoder72 = commandEncoder93.beginComputePass({timestampWrites: {querySet: querySet1, beginningOfPassWriteIndex: 285, endOfPassWriteIndex: 58}}); |
| let renderPassEncoder26 = commandEncoder94.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView29, |
| depthSlice: 11, |
| clearValue: { r: -340.3, g: 918.1, b: 498.1, a: -995.9, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet0, |
| }); |
| try { |
| computePassEncoder72.setPipeline(pipeline0); |
| } catch {} |
| try { |
| buffer13.unmap(); |
| } catch {} |
| try { |
| commandEncoder18.resolveQuerySet(querySet0, 45, 785, buffer8, 1024); |
| } catch {} |
| let computePassEncoder73 = commandEncoder18.beginComputePass({}); |
| try { |
| computePassEncoder72.setBindGroup(1, bindGroup26, [1024]); |
| } catch {} |
| try { |
| computePassEncoder20.end(); |
| } catch {} |
| try { |
| renderPassEncoder25.setBindGroup(1, bindGroup20); |
| } catch {} |
| let arrayBuffer9 = buffer6.getMappedRange(4280, 80); |
| let recycledExplicitBindGroupLayout6 = pipeline1.getBindGroupLayout(0); |
| let bindGroup34 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout8, |
| entries: [ |
| {binding: 322, resource: {buffer: buffer8, offset: 1024, size: 2080}}, |
| {binding: 356, resource: textureView82}, |
| {binding: 3, resource: {buffer: buffer22, offset: 768, size: 3904}}, |
| {binding: 85, resource: textureView32}, |
| {binding: 52, resource: {buffer: buffer5, offset: 3840, size: 2052}}, |
| {binding: 49, resource: {buffer: buffer26, offset: 2048, size: 13904}}, |
| ], |
| }); |
| let commandEncoder95 = device0.createCommandEncoder(); |
| let computePassEncoder74 = commandEncoder95.beginComputePass({timestampWrites: {querySet: querySet4, beginningOfPassWriteIndex: 22, endOfPassWriteIndex: 107}}); |
| try { |
| computePassEncoder56.setBindGroup(1, bindGroup30, [0]); |
| } catch {} |
| try { |
| computePassEncoder53.setBindGroup(1, bindGroup24, new Uint32Array(550), 181, 1); |
| } catch {} |
| try { |
| computePassEncoder52.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(0, bindGroup5, new Uint32Array(156), 0, 0); |
| } catch {} |
| try { |
| renderPassEncoder13.setIndexBuffer(buffer23, 'uint32', 3_864, 296); |
| } catch {} |
| let computePassEncoder75 = commandEncoder21.beginComputePass(); |
| let sampler58 = device0.createSampler({ |
| addressModeU: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 61.93, |
| lodMaxClamp: 82.41, |
| maxAnisotropy: 14, |
| }); |
| try { |
| renderPassEncoder24.setBindGroup(3, bindGroup23); |
| } catch {} |
| try { |
| buffer9.unmap(); |
| } catch {} |
| let commandEncoder96 = device0.createCommandEncoder({}); |
| let sampler59 = device0.createSampler({addressModeV: 'repeat', magFilter: 'nearest', lodMinClamp: 98.59, lodMaxClamp: 98.80}); |
| try { |
| computePassEncoder61.setBindGroup(0, bindGroup14, new Uint32Array(105), 45, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(1, bindGroup14); |
| } catch {} |
| try { |
| commandEncoder96.copyBufferToBuffer(buffer21, 256, buffer43, 68, 32); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer0, 8, new Float32Array(11663), 274, 748); |
| } catch {} |
| document.body.prepend(canvas0); |
| let imageData8 = new ImageData(92, 16); |
| let commandEncoder97 = device0.createCommandEncoder({}); |
| let textureView84 = texture75.createView({aspect: 'all', format: 'rg32uint'}); |
| let computePassEncoder76 = commandEncoder97.beginComputePass({timestampWrites: {querySet: querySet4, beginningOfPassWriteIndex: 27, endOfPassWriteIndex: 300}}); |
| try { |
| renderPassEncoder12.setBindGroup(0, bindGroup20, new Uint32Array(1550), 355, 0); |
| } catch {} |
| try { |
| renderPassEncoder24.executeBundles([renderBundle2, renderBundle7, renderBundle5]); |
| } catch {} |
| try { |
| renderPassEncoder24.setVertexBuffer(6, buffer36, 0, 3_182); |
| } catch {} |
| try { |
| buffer27.unmap(); |
| } catch {} |
| try { |
| commandEncoder96.copyBufferToTexture({ |
| /* bytesInLastRow: 12 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 328 */ |
| offset: 328, |
| bytesPerRow: 27136, |
| buffer: buffer30, |
| }, { |
| texture: texture76, |
| mipLevel: 0, |
| origin: {x: 17, y: 351, z: 0}, |
| aspect: 'all', |
| }, {width: 3, height: 29, depthOrArrayLayers: 0}); |
| } catch {} |
| let textureView85 = texture6.createView({}); |
| let computePassEncoder77 = commandEncoder96.beginComputePass({}); |
| try { |
| buffer17.unmap(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 96, height: 1820, depthOrArrayLayers: 296} |
| */ |
| { |
| source: imageData8, |
| origin: { x: 0, y: 1 }, |
| flipY: false, |
| }, { |
| texture: texture12, |
| mipLevel: 0, |
| origin: {x: 35, y: 108, z: 79}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 13, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| let img3 = await imageWithData(186, 109, '#10101010', '#20202020'); |
| let imageData9 = new ImageData(20, 36); |
| let bindGroup35 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout9, |
| entries: [ |
| {binding: 52, resource: externalTexture8}, |
| {binding: 141, resource: {buffer: buffer23, offset: 2304, size: 588}}, |
| {binding: 110, resource: {buffer: buffer14, offset: 0, size: 872}}, |
| ], |
| }); |
| let commandEncoder98 = device0.createCommandEncoder({}); |
| let textureView86 = texture39.createView({aspect: 'all'}); |
| try { |
| computePassEncoder9.setBindGroup(3, bindGroup35, [1536]); |
| } catch {} |
| try { |
| computePassEncoder51.setBindGroup(3, bindGroup21, new Uint32Array(1981), 286, 0); |
| } catch {} |
| try { |
| renderPassEncoder16.setBindGroup(2, bindGroup23); |
| } catch {} |
| try { |
| renderPassEncoder24.setBindGroup(2, bindGroup22, new Uint32Array(2733), 436, 0); |
| } catch {} |
| try { |
| renderPassEncoder11.executeBundles([renderBundle0]); |
| } catch {} |
| try { |
| commandEncoder98.copyBufferToBuffer(buffer23, 1328, buffer3, 656, 372); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 96, height: 1820, depthOrArrayLayers: 296} |
| */ |
| { |
| source: offscreenCanvas0, |
| origin: { x: 5, y: 10 }, |
| flipY: true, |
| }, { |
| texture: texture12, |
| mipLevel: 0, |
| origin: {x: 15, y: 664, z: 20}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 4, height: 5, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext2.unconfigure(); |
| } catch {} |
| let buffer44 = device0.createBuffer({ |
| size: 214, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, |
| }); |
| let texture79 = device0.createTexture({ |
| size: {width: 1400, height: 8, depthOrArrayLayers: 66}, |
| mipLevelCount: 3, |
| dimension: '3d', |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView87 = texture41.createView({arrayLayerCount: 1}); |
| let computePassEncoder78 = commandEncoder98.beginComputePass({timestampWrites: {querySet: querySet3, endOfPassWriteIndex: 36}}); |
| let renderBundleEncoder14 = device0.createRenderBundleEncoder({colorFormats: ['rgba8uint'], stencilReadOnly: true}); |
| try { |
| computePassEncoder66.setBindGroup(2, bindGroup32); |
| } catch {} |
| try { |
| computePassEncoder9.setBindGroup(3, bindGroup17, new Uint32Array(9), 0, 1); |
| } catch {} |
| try { |
| computePassEncoder40.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder21.setBlendConstant({ r: 149.9, g: 606.3, b: 314.0, a: -326.4, }); |
| } catch {} |
| try { |
| renderPassEncoder13.setVertexBuffer(6, buffer24, 0, 334); |
| } catch {} |
| try { |
| renderBundleEncoder14.setBindGroup(2, bindGroup34, new Uint32Array(2838), 403, 0); |
| } catch {} |
| try { |
| renderBundleEncoder14.setIndexBuffer(buffer10, 'uint32', 380, 3_155); |
| } catch {} |
| document.body.prepend(img0); |
| let bindGroup36 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout3, |
| entries: [ |
| {binding: 52, resource: externalTexture7}, |
| {binding: 141, resource: {buffer: buffer26, offset: 2816, size: 272}}, |
| {binding: 110, resource: {buffer: buffer0, offset: 1024, size: 1852}}, |
| ], |
| }); |
| let commandEncoder99 = device0.createCommandEncoder({}); |
| let texture80 = device0.createTexture({ |
| size: [51, 1, 173], |
| mipLevelCount: 1, |
| dimension: '3d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderPassEncoder27 = commandEncoder99.beginRenderPass({ |
| colorAttachments: [{view: textureView29, depthSlice: 5, loadOp: 'load', storeOp: 'discard'}], |
| timestampWrites: {querySet: querySet1}, |
| }); |
| let renderBundle14 = renderBundleEncoder14.finish({}); |
| try { |
| computePassEncoder33.setBindGroup(1, bindGroup11); |
| } catch {} |
| try { |
| computePassEncoder49.setBindGroup(0, bindGroup2, new Uint32Array(2272), 351, 1); |
| } catch {} |
| try { |
| renderPassEncoder23.setBindGroup(0, bindGroup15, new Uint32Array(119), 9, 0); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| gpuCanvasContext2.unconfigure(); |
| } catch {} |
| try { |
| computePassEncoder31.setBindGroup(2, bindGroup34); |
| } catch {} |
| try { |
| computePassEncoder6.setBindGroup(1, bindGroup24, new Uint32Array(761), 363, 1); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer24, 'uint32', 20, 86); |
| } catch {} |
| try { |
| buffer38.unmap(); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let commandEncoder100 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder61.setPipeline(pipeline1); |
| } catch {} |
| try { |
| commandEncoder100.copyBufferToTexture({ |
| /* bytesInLastRow: 388 widthInBlocks: 97 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 248 */ |
| offset: 248, |
| buffer: buffer27, |
| }, { |
| texture: texture70, |
| mipLevel: 0, |
| origin: {x: 788, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 97, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let textureView88 = texture64.createView({}); |
| let computePassEncoder79 = commandEncoder100.beginComputePass({timestampWrites: {querySet: querySet4}}); |
| try { |
| renderPassEncoder11.setStencilReference(625); |
| } catch {} |
| try { |
| renderPassEncoder19.setIndexBuffer(buffer30, 'uint32', 208, 354); |
| } catch {} |
| let bindGroup37 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [ |
| {binding: 47, resource: {buffer: buffer14, offset: 256, size: 724}}, |
| {binding: 131, resource: externalTexture0}, |
| {binding: 59, resource: externalTexture4}, |
| {binding: 19, resource: externalTexture4}, |
| {binding: 44, resource: externalTexture7}, |
| ], |
| }); |
| let buffer45 = device0.createBuffer({ |
| size: 4204, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM, |
| }); |
| let textureView89 = texture3.createView({format: 'r32sint'}); |
| try { |
| renderPassEncoder25.setBindGroup(3, bindGroup22, new Uint32Array(256), 38, 0); |
| } catch {} |
| try { |
| renderPassEncoder16.executeBundles([renderBundle1]); |
| } catch {} |
| let texture81 = device0.createTexture({ |
| size: {width: 1400, height: 8, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView90 = texture71.createView({dimension: '3d'}); |
| try { |
| computePassEncoder79.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder22.setBindGroup(0, bindGroup32); |
| } catch {} |
| try { |
| renderPassEncoder7.setBindGroup(1, bindGroup22, new Uint32Array(1215), 3, 0); |
| } catch {} |
| let arrayBuffer10 = buffer6.getMappedRange(4224, 24); |
| let bindGroup38 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout12, |
| entries: [{binding: 51, resource: {buffer: buffer41, offset: 0, size: 324}}], |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder46); computePassEncoder46.dispatchWorkgroupsIndirect(buffer43, 8); }; |
| } catch {} |
| try { |
| computePassEncoder38.setPipeline(pipeline2); |
| } catch {} |
| try { |
| computePassEncoder22.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder16.executeBundles([renderBundle5]); |
| } catch {} |
| try { |
| renderPassEncoder11.setIndexBuffer(buffer41, 'uint32', 68, 25); |
| } catch {} |
| try { |
| computePassEncoder24.pushDebugGroup('\u2dad'); |
| } catch {} |
| let videoFrame12 = videoFrame9.clone(); |
| let commandEncoder101 = device0.createCommandEncoder(); |
| let sampler60 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| }); |
| try { |
| computePassEncoder46.end(); |
| } catch {} |
| try { |
| renderPassEncoder17.setBindGroup(1, bindGroup22); |
| } catch {} |
| try { |
| renderPassEncoder14.setBindGroup(2, bindGroup22, new Uint32Array(279), 53, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.setVertexBuffer(3, undefined); |
| } catch {} |
| try { |
| commandEncoder101.copyBufferToTexture({ |
| /* bytesInLastRow: 3 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 340 */ |
| offset: 340, |
| buffer: buffer45, |
| }, { |
| texture: texture33, |
| mipLevel: 2, |
| origin: {x: 35, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 3, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let commandEncoder102 = device0.createCommandEncoder(); |
| let computePassEncoder80 = commandEncoder102.beginComputePass({}); |
| try { |
| renderPassEncoder6.setScissorRect(330, 0, 4, 2); |
| } catch {} |
| try { |
| renderPassEncoder24.setVertexBuffer(5, buffer7, 0, 162); |
| } catch {} |
| try { |
| commandEncoder101.copyBufferToTexture({ |
| /* bytesInLastRow: 8 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 880 */ |
| offset: 880, |
| buffer: buffer45, |
| }, { |
| texture: texture6, |
| mipLevel: 0, |
| origin: {x: 8, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let promise16 = device0.queue.onSubmittedWorkDone(); |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55); }; |
| } catch {} |
| let buffer46 = device0.createBuffer({ |
| size: 35143, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder103 = device0.createCommandEncoder({}); |
| let texture82 = device0.createTexture({ |
| size: {width: 192}, |
| sampleCount: 1, |
| dimension: '1d', |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler61 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| maxAnisotropy: 19, |
| }); |
| try { |
| computePassEncoder77.setBindGroup(3, bindGroup12, new Uint32Array(1421), 111, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder45); computePassEncoder45.dispatchWorkgroupsIndirect(buffer38, 460); }; |
| } catch {} |
| try { |
| computePassEncoder45.end(); |
| } catch {} |
| try { |
| renderPassEncoder22.setIndexBuffer(buffer42, 'uint16', 4_590, 436); |
| } catch {} |
| try { |
| renderPassEncoder12.setVertexBuffer(1, buffer30); |
| } catch {} |
| try { |
| commandEncoder101.copyBufferToBuffer(buffer24, 112, buffer21, 20, 56); |
| } catch {} |
| try { |
| gpuCanvasContext2.unconfigure(); |
| } catch {} |
| let imageData10 = new ImageData(8, 20); |
| let recycledExplicitBindGroupLayout7 = pipeline2.getBindGroupLayout(0); |
| let buffer47 = device0.createBuffer({ |
| size: 939, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder104 = device0.createCommandEncoder({}); |
| let texture83 = device0.createTexture({ |
| size: {width: 1400, height: 8, depthOrArrayLayers: 8}, |
| dimension: '3d', |
| format: 'rgba8uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let renderPassEncoder28 = commandEncoder101.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView64, |
| clearValue: { r: -836.9, g: -499.5, b: 209.4, a: 651.4, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| timestampWrites: {querySet: querySet4, beginningOfPassWriteIndex: 292}, |
| maxDrawCount: 57159403, |
| }); |
| let sampler62 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 97.84, |
| maxAnisotropy: 1, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder15); computePassEncoder15.dispatchWorkgroupsIndirect(buffer8, 512); }; |
| } catch {} |
| try { |
| renderPassEncoder8.executeBundles([renderBundle6]); |
| } catch {} |
| try { |
| renderPassEncoder25.setVertexBuffer(7, buffer21, 0); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| commandEncoder103.copyBufferToTexture({ |
| /* bytesInLastRow: 2500 widthInBlocks: 625 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 2376 */ |
| offset: 2376, |
| buffer: buffer46, |
| }, { |
| texture: texture54, |
| mipLevel: 0, |
| origin: {x: 85, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 625, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder55.copyTextureToTexture({ |
| texture: texture34, |
| mipLevel: 0, |
| origin: {x: 2, y: 186, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture34, |
| mipLevel: 0, |
| origin: {x: 1, y: 92, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 4, height: 411, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture52, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(119).fill(141), /* required buffer size: 119 */ |
| {offset: 119}, {width: 4, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let promise17 = device0.queue.onSubmittedWorkDone(); |
| let bindGroup39 = device0.createBindGroup({layout: veryExplicitBindGroupLayout15, entries: [{binding: 113, resource: textureView36}]}); |
| let commandBuffer3 = commandEncoder55.finish(); |
| let renderPassEncoder29 = commandEncoder104.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView64, |
| clearValue: { r: -537.4, g: 226.2, b: -674.2, a: -416.3, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet0, |
| maxDrawCount: 317183475, |
| }); |
| try { |
| computePassEncoder15.end(); |
| } catch {} |
| try { |
| computePassEncoder4.setPipeline(pipeline0); |
| } catch {} |
| try { |
| commandEncoder103.copyBufferToTexture({ |
| /* bytesInLastRow: 1572 widthInBlocks: 393 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 3656 */ |
| offset: 3656, |
| bytesPerRow: 12800, |
| buffer: buffer46, |
| }, { |
| texture: texture41, |
| mipLevel: 0, |
| origin: {x: 2834, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 393, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder14.copyTextureToTexture({ |
| texture: texture40, |
| mipLevel: 0, |
| origin: {x: 4, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture53, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer3]); |
| } catch {} |
| let buffer48 = device0.createBuffer({size: 1676, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX, mappedAtCreation: false}); |
| let commandEncoder105 = device0.createCommandEncoder({}); |
| let computePassEncoder81 = commandEncoder103.beginComputePass({}); |
| let renderPassEncoder30 = commandEncoder14.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView64, |
| clearValue: { r: -93.60, g: -313.5, b: 267.9, a: -319.6, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet0, |
| }); |
| try { |
| renderPassEncoder14.setBindGroup(3, bindGroup30, new Uint32Array(831), 167, 1); |
| } catch {} |
| try { |
| renderPassEncoder24.setIndexBuffer(buffer16, 'uint16', 1_660, 74); |
| } catch {} |
| try { |
| commandEncoder56.clearBuffer(buffer32, 224, 544); |
| } catch {} |
| try { |
| computePassEncoder24.popDebugGroup(); |
| } catch {} |
| document.body.prepend(img1); |
| let pipelineLayout15 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout0]}); |
| let buffer49 = device0.createBuffer({ |
| size: 6785, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder106 = device0.createCommandEncoder({}); |
| let commandBuffer4 = commandEncoder56.finish(); |
| let renderPassEncoder31 = commandEncoder105.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView44, |
| clearValue: { r: 314.4, g: 706.4, b: 760.2, a: 15.13, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| renderPassEncoder30.setIndexBuffer(buffer5, 'uint32', 1_072, 430); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 96, height: 1820, depthOrArrayLayers: 296} |
| */ |
| { |
| source: canvas1, |
| origin: { x: 29, y: 288 }, |
| flipY: true, |
| }, { |
| texture: texture12, |
| mipLevel: 0, |
| origin: {x: 5, y: 171, z: 8}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 2, height: 34, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let texture84 = device0.createTexture({size: [51], dimension: '1d', format: 'rgb10a2uint', usage: GPUTextureUsage.COPY_DST}); |
| let textureView91 = texture71.createView({}); |
| let externalTexture9 = device0.importExternalTexture({source: videoFrame5}); |
| try { |
| computePassEncoder78.setBindGroup(1, bindGroup6); |
| } catch {} |
| try { |
| computePassEncoder32.setBindGroup(3, bindGroup6, new Uint32Array(141), 14, 0); |
| } catch {} |
| try { |
| computePassEncoder49.dispatchWorkgroups(1, 1); |
| } catch {} |
| try { |
| renderPassEncoder17.setBindGroup(0, bindGroup26, new Uint32Array(940), 485, 1); |
| } catch {} |
| try { |
| renderPassEncoder24.setIndexBuffer(buffer48, 'uint16', 196, 6); |
| } catch {} |
| try { |
| renderPassEncoder21.setVertexBuffer(2, buffer13, 0, 2_841); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer38, 612, new DataView(new ArrayBuffer(2596)), 97, 1544); |
| } catch {} |
| try { |
| await promise16; |
| } catch {} |
| let computePassEncoder82 = commandEncoder106.beginComputePass({}); |
| let sampler63 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'nearest', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 89.57, |
| }); |
| try { |
| renderPassEncoder20.setBindGroup(1, bindGroup33, new Uint32Array(890), 25, 0); |
| } catch {} |
| try { |
| renderPassEncoder19.setIndexBuffer(buffer16, 'uint16', 512, 368); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer4]); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture12, |
| mipLevel: 0, |
| origin: {x: 22, y: 35, z: 23}, |
| aspect: 'all', |
| }, new Uint8Array(327_595).fill(3), /* required buffer size: 327_595 */ |
| {offset: 88, bytesPerRow: 51, rowsPerImage: 138}, {width: 9, height: 74, depthOrArrayLayers: 47}); |
| } catch {} |
| let bindGroup40 = device0.createBindGroup({layout: veryExplicitBindGroupLayout10, entries: []}); |
| let pipelineLayout16 = device0.createPipelineLayout({bindGroupLayouts: [recycledExplicitBindGroupLayout6]}); |
| let commandEncoder107 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder68.setBindGroup(2, bindGroup17, new Uint32Array(1466), 436, 1); |
| } catch {} |
| try { |
| computePassEncoder50.setPipeline(pipeline2); |
| } catch {} |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| try { |
| commandEncoder107.copyTextureToTexture({ |
| texture: texture50, |
| mipLevel: 1, |
| origin: {x: 53, y: 1, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture62, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| } catch {} |
| try { |
| buffer38.label = '\u8751\u0c05\u00ed\ub2bc\u0fd8'; |
| } catch {} |
| let veryExplicitBindGroupLayout17 = device0.createBindGroupLayout({entries: []}); |
| let bindGroup41 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout2, |
| entries: [ |
| {binding: 44, resource: externalTexture6}, |
| {binding: 19, resource: externalTexture9}, |
| {binding: 47, resource: {buffer: buffer23, offset: 512, size: 1484}}, |
| {binding: 131, resource: externalTexture7}, |
| {binding: 59, resource: externalTexture1}, |
| ], |
| }); |
| let computePassEncoder83 = commandEncoder107.beginComputePass({}); |
| try { |
| computePassEncoder49.end(); |
| } catch {} |
| try { |
| renderPassEncoder13.setIndexBuffer(buffer0, 'uint16', 256, 636); |
| } catch {} |
| try { |
| renderPassEncoder18.setVertexBuffer(7, buffer46, 8_132, 7_394); |
| } catch {} |
| try { |
| commandEncoder59.copyTextureToBuffer({ |
| texture: texture42, |
| mipLevel: 0, |
| origin: {x: 5, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 2028 */ |
| offset: 2028, |
| buffer: buffer36, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder43); computePassEncoder43.dispatchWorkgroupsIndirect(buffer13, 6_584); }; |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(1, bindGroup33); |
| } catch {} |
| try { |
| renderPassEncoder28.setBlendConstant({ r: -727.2, g: -317.3, b: 531.6, a: -517.7, }); |
| } catch {} |
| try { |
| renderPassEncoder19.setViewport(1092.4000239331524, 19.408265460957683, 1646.8865083930439, 13.122243226275039, 0.6347347446003176, 0.7607113616762632); |
| } catch {} |
| try { |
| renderPassEncoder11.setIndexBuffer(buffer33, 'uint32', 5_836, 363); |
| } catch {} |
| let commandEncoder108 = device0.createCommandEncoder({}); |
| let computePassEncoder84 = commandEncoder59.beginComputePass({}); |
| let externalTexture10 = device0.importExternalTexture({source: videoFrame0}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder43); computePassEncoder43.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder71.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder28.setBindGroup(2, bindGroup25); |
| } catch {} |
| try { |
| renderPassEncoder28.setBindGroup(3, bindGroup36, new Uint32Array(444), 58, 1); |
| } catch {} |
| try { |
| renderPassEncoder14.setBlendConstant({ r: 207.9, g: 689.1, b: -642.3, a: -8.651, }); |
| } catch {} |
| try { |
| buffer39.unmap(); |
| } catch {} |
| let buffer50 = device0.createBuffer({ |
| size: 41255, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let commandEncoder109 = device0.createCommandEncoder(); |
| let sampler64 = device0.createSampler({addressModeU: 'clamp-to-edge', addressModeW: 'repeat', lodMaxClamp: 67.70}); |
| try { |
| computePassEncoder23.setBindGroup(1, bindGroup24, [0]); |
| } catch {} |
| try { |
| renderPassEncoder17.setBindGroup(1, bindGroup25, new Uint32Array(272), 77, 0); |
| } catch {} |
| try { |
| renderPassEncoder17.executeBundles([renderBundle2, renderBundle3, renderBundle7]); |
| } catch {} |
| try { |
| renderPassEncoder31.setVertexBuffer(3, buffer13); |
| } catch {} |
| let shaderModule2 = device0.createShaderModule({ |
| code: ` |
| requires pointer_composite_access; |
| |
| enable f16; |
| |
| /* zero global variables used */ |
| fn fn1(a0: ptr<storage, array<u32>, read>, a1: array<FragmentOutput0, 4>, a2: ptr<storage, array<array<array<array<vec2u, 1>, 1>, 1>>, read>, a3: array<array<array<vec2h, 1>, 1>, 42>) -> FragmentOutput0 { |
| var out: FragmentOutput0; |
| _ = fn0(); |
| let ptr10: ptr<storage, array<vec2u, 1>, read> = &(*a2)[unconst_u32(183)][unconst_u32(82)][0]; |
| out.f0 = (*a2)[unconst_u32(381)][unconst_u32(192)][unconst_u32(138)][0].rrrg; |
| return out; |
| } |
| |
| struct FragmentOutput0 { |
| @location(0) @interpolate(flat) f0: vec4u, |
| @location(1) f1: u32, |
| } |
| |
| @group(0) @binding(41) var st0: texture_storage_2d_array<r32uint, read>; |
| |
| struct T3 { |
| @align(8) @size(544) f0: array<atomic<u32>>, |
| } |
| |
| var<private> vp0: mat3x2f = mat3x2f(0.07928, 0.00624, 0.00477, 0.1047, 0.04484, 0.1023); |
| |
| /* zero global variables used */ |
| @must_use |
| fn fn3(a0: FragmentOutput0) -> vec4h { |
| var out: vec4h; |
| let vf52: vec3<bool> = (vec3h(f16((unconst_u32(85) >> pack4xU8(a0.f0)))) != vec3h(unpack4xI8(unconst_u32(136)).agb)); |
| _ = fn0(); |
| for (var it1=u32(sin(vec4f(unconst_f32(0.5019), unconst_f32(0.2657), unconst_f32(0.1581), unconst_f32(-0.4677))).w); it1<u32(vf52[unconst_u32(433)]); it1++) { |
| vp0 = mat3x2f(vec2f(a0.f0.rb), bitcast<vec2f>(a0.f0.xw), vec2f(a0.f0.gb)); |
| var vf53 = fn0(); |
| vp0 += mat3x2f(bitcast<vec2f>((vec2u(unconst_u32(207), unconst_u32(402)) << vec2u(unconst_u32(45), unconst_u32(22)))), vec2f((vec2u(unconst_u32(207), unconst_u32(402)) << vec2u(unconst_u32(45), unconst_u32(22)))), vec2f((vec2u(unconst_u32(207), unconst_u32(402)) << vec2u(unconst_u32(45), unconst_u32(22))))); |
| } |
| var vf54: FragmentOutput0 = a0; |
| vp0 = mat3x2f(vec2f(smoothstep(vec3h(unconst_f16(16985.9), unconst_f16(9040.7), unconst_f16(-753.4)), vec3h(unconst_f16(2422.4), unconst_f16(-7276.7), unconst_f16(4754.2)), vec3h(unconst_f16(17804.3), unconst_f16(3671.0), unconst_f16(15267.4))).rr), vec2f(smoothstep(vec3h(unconst_f16(16985.9), unconst_f16(9040.7), unconst_f16(-753.4)), vec3h(unconst_f16(2422.4), unconst_f16(-7276.7), unconst_f16(4754.2)), vec3h(unconst_f16(17804.3), unconst_f16(3671.0), unconst_f16(15267.4))).yy), vec2f(smoothstep(vec3h(unconst_f16(16985.9), unconst_f16(9040.7), unconst_f16(-753.4)), vec3h(unconst_f16(2422.4), unconst_f16(-7276.7), unconst_f16(4754.2)), vec3h(unconst_f16(17804.3), unconst_f16(3671.0), unconst_f16(15267.4))).yz)); |
| while bool(a0.f1) { |
| var vf55: vec3f = atanh(vec3f(unconst_f32(0.00240), unconst_f32(0.05647), unconst_f32(0.2005))); |
| var vf56 = fn0(); |
| _ = fn0(); |
| vf55 = vec3f(degrees(vec3h(unconst_f16(1410.8), unconst_f16(1155.1), unconst_f16(224.7)))); |
| break; |
| } |
| let vf57: vec2i = reverseBits(countOneBits(vec4i(unconst_i32(219), unconst_i32(313), unconst_i32(28), unconst_i32(161))).gb); |
| vf54 = FragmentOutput0(vec4u((vec3h(unconst_f16(262.3), unconst_f16(94.84), unconst_f16(-2956.7)) != vec3h(unconst_f16(9145.1), unconst_f16(4524.9), unconst_f16(9305.2))).bbbg), vec3u((vec3h(unconst_f16(262.3), unconst_f16(94.84), unconst_f16(-2956.7)) != vec3h(unconst_f16(9145.1), unconst_f16(4524.9), unconst_f16(9305.2))))[1]); |
| vp0 = mat3x2f(radians(f32(firstTrailingBit(unconst_i32(100)))), radians(f32(firstTrailingBit(unconst_i32(100)))), radians(f32(firstTrailingBit(unconst_i32(100)))), radians(f32(firstTrailingBit(unconst_i32(100)))), radians(f32(firstTrailingBit(unconst_i32(100)))), radians(f32(firstTrailingBit(unconst_i32(100))))); |
| return out; |
| } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| var<workgroup> vw15: array<atomic<i32>, 1>; |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| struct T0 { |
| @size(64) f0: i32, |
| @size(244) f1: array<array<atomic<i32>, 1>>, |
| } |
| |
| struct T1 { |
| @align(64) @size(64) f0: array<atomic<i32>, 1>, |
| } |
| |
| /* zero global variables used */ |
| fn fn5(a0: FragmentOutput0, a1: ptr<storage, array<mat4x4h, 1>, read_write>) -> FragmentOutput0 { |
| var out: FragmentOutput0; |
| out.f1 &= pack4xI8(vec4i(unconst_i32(346), unconst_i32(247), unconst_i32(88), unconst_i32(25))); |
| out.f1 -= bitcast<u32>(unpack4x8snorm(unconst_u32(16)).b); |
| let vf62: vec2f = unpack2x16float(unconst_u32(8)); |
| let vf63: f32 = vp0[unconst_u32(338)][unconst_u32(194)]; |
| out.f1 = a0.f0[unconst_u32(218)]; |
| let vf64: vec4f = unpack4x8snorm(pack2x16unorm(vf62)); |
| return out; |
| } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| struct T2 { |
| @align(32) @size(32) f0: mat4x2h, |
| @size(192) f1: array<mat4x4f>, |
| } |
| |
| var<workgroup> vw14: vec4<bool>; |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| struct T4 { |
| @size(60) f0: array<u32>, |
| } |
| |
| /* zero global variables used */ |
| @must_use |
| fn fn0() -> T5 { |
| var out: T5; |
| out.f0 &= countLeadingZeros(vec2u(unconst_u32(191), unconst_u32(87))); |
| out.f0 = vec2u(u32(dot(vec4i(unconst_i32(-49), unconst_i32(231), unconst_i32(151), unconst_i32(66)), vec4i(unconst_i32(240), unconst_i32(46), unconst_i32(240), unconst_i32(179))))); |
| var vf35: vec4h = acosh(vec4h(f16(vp0[unconst_u32(460)][unconst_u32(137)]))); |
| { |
| loop { |
| let vf36: vec4u = unpack4xU8(unconst_u32(510)); |
| return out; |
| break; |
| } |
| out.f0 = vec2u(unpack2x16float(u32(vp0[unconst_i32(1)].g))); |
| out.f0 = bitcast<vec2u>(step(vec4h(unconst_f16(13955.3), unconst_f16(16140.3), unconst_f16(429.5), unconst_f16(22535.2)), vec4h(unconst_f16(5071.6), unconst_f16(10760.4), unconst_f16(36547.5), unconst_f16(12033.3)))); |
| vp0 -= mat3x2f(ldexp(vec2f(unconst_f32(0.1742), unconst_f32(0.2547)), extractBits(bitcast<vec3i>(faceForward(vec4f(unconst_f32(-0.2292), unconst_f32(0.3358), unconst_f32(0.1382), unconst_f32(0.2145)), vec4f(unconst_f32(0.04507), unconst_f32(0.2098), unconst_f32(0.03304), unconst_f32(0.04156)), vec4f(unconst_f32(-0.1386), unconst_f32(0.01177), unconst_f32(0.00760), unconst_f32(0.07708))).abg), unconst_u32(229), unconst_u32(307)).gg), ldexp(vec2f(unconst_f32(0.1742), unconst_f32(0.2547)), extractBits(bitcast<vec3i>(faceForward(vec4f(unconst_f32(-0.2292), unconst_f32(0.3358), unconst_f32(0.1382), unconst_f32(0.2145)), vec4f(unconst_f32(0.04507), unconst_f32(0.2098), unconst_f32(0.03304), unconst_f32(0.04156)), vec4f(unconst_f32(-0.1386), unconst_f32(0.01177), unconst_f32(0.00760), unconst_f32(0.07708))).abg), unconst_u32(229), unconst_u32(307)).gg), ldexp(vec2f(unconst_f32(0.1742), unconst_f32(0.2547)), extractBits(bitcast<vec3i>(faceForward(vec4f(unconst_f32(-0.2292), unconst_f32(0.3358), unconst_f32(0.1382), unconst_f32(0.2145)), vec4f(unconst_f32(0.04507), unconst_f32(0.2098), unconst_f32(0.03304), unconst_f32(0.04156)), vec4f(unconst_f32(-0.1386), unconst_f32(0.01177), unconst_f32(0.00760), unconst_f32(0.07708))).abg), unconst_u32(229), unconst_u32(307)).gg)); |
| vp0 -= mat3x2f(faceForward(vec4f(unconst_f32(0.1691), unconst_f32(0.03432), unconst_f32(0.09125), unconst_f32(0.7437)), vec4f(unconst_f32(0.3817), unconst_f32(0.05206), unconst_f32(0.01983), unconst_f32(-0.5813)), vec4f(unconst_f32(0.08068), unconst_f32(-0.4556), unconst_f32(0.4222), unconst_f32(0.06549))).bb, faceForward(vec4f(unconst_f32(0.1691), unconst_f32(0.03432), unconst_f32(0.09125), unconst_f32(0.7437)), vec4f(unconst_f32(0.3817), unconst_f32(0.05206), unconst_f32(0.01983), unconst_f32(-0.5813)), vec4f(unconst_f32(0.08068), unconst_f32(-0.4556), unconst_f32(0.4222), unconst_f32(0.06549))).xw, faceForward(vec4f(unconst_f32(0.1691), unconst_f32(0.03432), unconst_f32(0.09125), unconst_f32(0.7437)), vec4f(unconst_f32(0.3817), unconst_f32(0.05206), unconst_f32(0.01983), unconst_f32(-0.5813)), vec4f(unconst_f32(0.08068), unconst_f32(-0.4556), unconst_f32(0.4222), unconst_f32(0.06549))).bb); |
| } |
| let ptr9: ptr<private, mat3x2f> = &vp0; |
| vp0 = mat3x2f(f32(dot(vec4i(unconst_i32(11), unconst_i32(93), unconst_i32(-64), unconst_i32(99)), vec4i(dot(vec4i(unconst_i32(41), unconst_i32(97), unconst_i32(552), unconst_i32(37)), bitcast<vec4i>((*ptr9)[unconst_u32(187)].rrgg))))), bitcast<f32>(dot(vec4i(unconst_i32(11), unconst_i32(93), unconst_i32(-64), unconst_i32(99)), vec4i(dot(vec4i(unconst_i32(41), unconst_i32(97), unconst_i32(552), unconst_i32(37)), bitcast<vec4i>((*ptr9)[unconst_u32(187)].rrgg))))), f32(dot(vec4i(unconst_i32(11), unconst_i32(93), unconst_i32(-64), unconst_i32(99)), vec4i(dot(vec4i(unconst_i32(41), unconst_i32(97), unconst_i32(552), unconst_i32(37)), bitcast<vec4i>((*ptr9)[unconst_u32(187)].rrgg))))), f32(dot(vec4i(unconst_i32(11), unconst_i32(93), unconst_i32(-64), unconst_i32(99)), vec4i(dot(vec4i(unconst_i32(41), unconst_i32(97), unconst_i32(552), unconst_i32(37)), bitcast<vec4i>((*ptr9)[unconst_u32(187)].rrgg))))), f32(dot(vec4i(unconst_i32(11), unconst_i32(93), unconst_i32(-64), unconst_i32(99)), vec4i(dot(vec4i(unconst_i32(41), unconst_i32(97), unconst_i32(552), unconst_i32(37)), bitcast<vec4i>((*ptr9)[unconst_u32(187)].rrgg))))), bitcast<f32>(dot(vec4i(unconst_i32(11), unconst_i32(93), unconst_i32(-64), unconst_i32(99)), vec4i(dot(vec4i(unconst_i32(41), unconst_i32(97), unconst_i32(552), unconst_i32(37)), bitcast<vec4i>((*ptr9)[unconst_u32(187)].rrgg)))))); |
| if bool(reverseBits(vec3u(unconst_u32(47), unconst_u32(64), unconst_u32(127))).r) { |
| var vf37: vec2i = countOneBits(vec2i(unconst_i32(112), unconst_i32(654))); |
| var vf38: vec4h = -vec4h(unconst_f16(3513.2), unconst_f16(-3741.9), unconst_f16(7853.4), unconst_f16(30988.5)); |
| vp0 = mat3x2f(bitcast<f32>(firstTrailingBit(unconst_u32(247))), f32(firstTrailingBit(unconst_u32(247))), bitcast<f32>(firstTrailingBit(unconst_u32(247))), bitcast<f32>(firstTrailingBit(unconst_u32(247))), f32(firstTrailingBit(unconst_u32(247))), bitcast<f32>(firstTrailingBit(unconst_u32(247)))); |
| out.f0 >>= ~vec3u(unconst_u32(318), unconst_u32(20), unconst_u32(100)).rg; |
| vf38 = vec4h(f16(vf37[unconst_u32(202)])); |
| switch i32(vf38[pack2x16snorm(transpose(mat2x4f(unconst_f32(0.04207), unconst_f32(0.6199), unconst_f32(0.1515), unconst_f32(0.00466), unconst_f32(0.01600), unconst_f32(0.3082), unconst_f32(0.02669), unconst_f32(-0.01929)))[unconst_i32(0)])]) { |
| default { |
| var vf39: u32 = pack4xI8(vec4i(unconst_i32(142), unconst_i32(-49), unconst_i32(427), unconst_i32(203))); |
| break; |
| } |
| } |
| let vf40: vec3u = (vec3u(unconst_u32(189), unconst_u32(123), unconst_u32(45)) / unconst_u32(263)); |
| } |
| out.f0 = bitcast<vec2u>(vp0[unconst_i32(0)]); |
| let vf41: vec4h = cos(vec4h(unconst_f16(11137.8), unconst_f16(8369.9), unconst_f16(-2045.0), unconst_f16(5824.3))); |
| var vf42: vec3h = cos(vec3h(unconst_f16(-9123.0), unconst_f16(10622.0), unconst_f16(26222.8))); |
| switch bitcast<i32>(transpose(mat2x3f(unconst_f32(0.1325), unconst_f32(0.3782), unconst_f32(0.1217), unconst_f32(0.2228), unconst_f32(0.01937), unconst_f32(0.08235)))[unconst_i32(0)][1]) { |
| default { |
| var vf43: vec2h = cosh(vec2h(unconst_f16(17947.7), unconst_f16(6121.7))); |
| switch bitcast<vec4i>((unconst_u32(70) % vec4u(unconst_u32(10), unconst_u32(162), unconst_u32(49), unconst_u32(82)))).x { |
| default { |
| out.f0 = vec2u((vec3i(unconst_i32(1), unconst_i32(155), unconst_i32(196)) > vec3i(unconst_i32(21), unconst_i32(38), unconst_i32(121))).bb); |
| vp0 -= mat3x2f((vec4f(unconst_f32(0.04714), unconst_f32(0.1448), unconst_f32(0.09031), unconst_f32(0.1085)) * unconst_f32(0.4823)).zz, (vec4f(unconst_f32(0.04714), unconst_f32(0.1448), unconst_f32(0.09031), unconst_f32(0.1085)) * unconst_f32(0.4823)).xx, (vec4f(unconst_f32(0.04714), unconst_f32(0.1448), unconst_f32(0.09031), unconst_f32(0.1085)) * unconst_f32(0.4823)).bg); |
| } |
| } |
| var vf44: vec2h = inverseSqrt(vec2h(unconst_f16(-16889.2), unconst_f16(2283.8))); |
| vp0 += mat3x2f(vec2f(sign(vec3h(unconst_f16(12099.9), unconst_f16(471.9), unconst_f16(717.5))).rr), vec2f(sign(vec3h(unconst_f16(12099.9), unconst_f16(471.9), unconst_f16(717.5))).bb), vec2f(sign(vec3h(unconst_f16(12099.9), unconst_f16(471.9), unconst_f16(717.5))).xy)); |
| return out; |
| } |
| } |
| return out; |
| } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| /* zero global variables used */ |
| fn fn4(a0: vec2i, a1: array<vec4f, 14>) -> vec2f { |
| var out: vec2f; |
| vw14 = vec4<bool>(a1[13]); |
| out = unpack2x16float(pack2x16unorm(vec2f(unconst_f32(1.000), unconst_f32(0.01584)))); |
| var vf58: f32 = vp0[unconst_u32(92)][min(u32((unconst_bool(true) || unconst_bool(true))), unconst_u32(50))]; |
| var vf59 = fn0(); |
| vw14 = vec4<bool>(unpack4xU8(pack4xU8Clamp(vec4u(asinh(vec4h(unconst_f16(-4917.7), unconst_f16(36660.9), unconst_f16(7192.0), unconst_f16(4742.4))))))); |
| let ptr11: ptr<function, vec2u> = &vf59.f0; |
| var vf60: f16 = atan(unconst_f16(38142.8)); |
| vp0 -= mat3x2f(vec2f(max(vec4u(unconst_u32(140), unconst_u32(24), unconst_u32(188), unconst_u32(76)), vec4u(unconst_u32(131), unconst_u32(159), unconst_u32(69), unconst_u32(301))).bb), bitcast<vec2f>(max(vec4u(unconst_u32(140), unconst_u32(24), unconst_u32(188), unconst_u32(76)), vec4u(unconst_u32(131), unconst_u32(159), unconst_u32(69), unconst_u32(301))).ga), vec2f(max(vec4u(unconst_u32(140), unconst_u32(24), unconst_u32(188), unconst_u32(76)), vec4u(unconst_u32(131), unconst_u32(159), unconst_u32(69), unconst_u32(301))).xx)); |
| out = vec2f(bitcast<f32>(sign(unconst_i32(-97)))); |
| var vf61 = fn0(); |
| vp0 = mat3x2f(f32(atomicLoad(&vw15[unconst_u32(90)])), bitcast<f32>(atomicLoad(&vw15[unconst_u32(90)])), bitcast<f32>(atomicLoad(&vw15[unconst_u32(90)])), f32(atomicLoad(&vw15[unconst_u32(90)])), f32(atomicLoad(&vw15[unconst_u32(90)])), f32(atomicLoad(&vw15[unconst_u32(90)]))); |
| return out; |
| } |
| |
| alias vec3b = vec3<bool>; |
| |
| struct T5 { |
| @size(88) f0: vec2u, |
| } |
| |
| /* zero global variables used */ |
| @must_use |
| fn fn2() -> f32 { |
| var out: f32; |
| vp0 = mat3x2f(bitcast<vec2f>(atan2(vec4h(unconst_f16(13570.7), unconst_f16(21970.9), unconst_f16(3894.4), unconst_f16(9785.3)), vec4h(unconst_f16(5594.6), unconst_f16(25327.4), unconst_f16(8744.2), unconst_f16(9307.0)))), bitcast<vec2f>(atan2(vec4h(unconst_f16(13570.7), unconst_f16(21970.9), unconst_f16(3894.4), unconst_f16(9785.3)), vec4h(unconst_f16(5594.6), unconst_f16(25327.4), unconst_f16(8744.2), unconst_f16(9307.0)))), bitcast<vec2f>(atan2(vec4h(unconst_f16(13570.7), unconst_f16(21970.9), unconst_f16(3894.4), unconst_f16(9785.3)), vec4h(unconst_f16(5594.6), unconst_f16(25327.4), unconst_f16(8744.2), unconst_f16(9307.0))))); |
| let vf45: vec3u = (vec3u(unconst_u32(305), unconst_u32(47), unconst_u32(107)) & vec3u(unconst_u32(176), unconst_u32(85), unconst_u32(151))); |
| var vf46: vec2f = tan(vec2f(unconst_f32(-0.02686), unconst_f32(0.1122))); |
| let vf47: vec4f = inverseSqrt(vec4f(unconst_f32(0.01316), unconst_f32(0.06161), unconst_f32(0.2003), unconst_f32(0.1391))); |
| vf46 *= vec2f(f32((unconst_f32(0.05227) <= unconst_f32(0.6863)))); |
| vf46 -= tan(vec2f(unconst_f32(0.2007), unconst_f32(0.09655))); |
| let vf48: vec4i = (vec4i(unconst_i32(26), unconst_i32(25), unconst_i32(115), unconst_i32(89)) % vec4i(bitcast<i32>(degrees(unconst_f32(0.08782))))); |
| var vf49: vec3u = vf45; |
| vf46 -= vp0[unconst_i32(0)]; |
| let vf50: u32 = (unconst_u32(286) % u32(fract(unconst_f16(-9401.7)))); |
| vf46 -= vec2f(vf46[unconst_u32(234)]); |
| let vf51: vec2<bool> = !vec2<bool>(bool(vf45[unconst_u32(79)])); |
| vf46 = bitcast<vec2f>(atan2(vec4h(unconst_f16(-34099.5), unconst_f16(7898.7), unconst_f16(4964.7), unconst_f16(4011.5)), vec4h(unconst_f16(-4369.6), unconst_f16(16859.5), unconst_f16(26130.5), unconst_f16(20937.5)))); |
| out += bitcast<f32>(firstTrailingBit(unconst_i32(242))); |
| return out; |
| } |
| |
| /* zero global variables used */ |
| @fragment |
| fn fragment0(@builtin(position) a0: vec4f, @builtin(sample_mask) a1: u32) -> FragmentOutput0 { |
| var out: FragmentOutput0; |
| var vf65: vec2f = vp0[unconst_u32(443)]; |
| var vf66 = fn3(FragmentOutput0(unpack4xU8(pack2x16snorm(unpack2x16snorm(a1))), pack2x16snorm(unpack2x16snorm(a1)))); |
| let vf67: vec4u = reverseBits(vec4u(unconst_u32(216), unconst_u32(233), unconst_u32(92), unconst_u32(56))); |
| let vf68: vec4u = (vec4u(unconst_u32(232), unconst_u32(575), unconst_u32(287), unconst_u32(1)) / vec4u(unconst_u32(7), unconst_u32(158), unconst_u32(93), unconst_u32(201))); |
| _ = fn0(); |
| if bool(vf67[unconst_u32(112)]) { |
| out.f1 &= u32(a0[a1]); |
| let vf69: f32 = distance(vec3f(unconst_f32(0.1944), unconst_f32(-0.4086), unconst_f32(0.01186)), vec3f(fma(vec3h(unconst_f16(8286.1), unconst_f16(11855.5), unconst_f16(5086.9)), vec3h(unconst_f16(26211.8), unconst_f16(28531.8), unconst_f16(3273.2)), vec3h(unconst_f16(119.3), unconst_f16(102.7), unconst_f16(8680.4))))); |
| _ = fn3(FragmentOutput0(reverseBits(vec4u(unconst_u32(176), unconst_u32(134), unconst_u32(216), unconst_u32(43))), reverseBits(vec4u(unconst_u32(176), unconst_u32(134), unconst_u32(216), unconst_u32(43)))[2])); |
| var vf70: i32 = clamp(unconst_i32(53), unconst_i32(182), unconst_i32(154)); |
| out = FragmentOutput0(unpack4xU8(u32((unconst_f16(24574.1) >= unconst_f16(23556.1)))), u32((unconst_f16(24574.1) >= unconst_f16(23556.1)))); |
| var vf71: vec2h = fma(vec2h(abs(vec3f(unconst_f32(0.01501), unconst_f32(0.01149), unconst_f32(0.1873))).zy), vec2h(unconst_f16(2166.5), unconst_f16(13099.2)), vec2h(unconst_f16(5129.5), unconst_f16(7970.1))); |
| } |
| out.f1 -= vec2u((vec2h(unconst_f16(3187.8), unconst_f16(16394.5)) <= vec2h(unconst_f16(22775.9), unconst_f16(497.2))))[0]; |
| var vf72: u32 = insertBits(unconst_u32(100), unconst_u32(41), unconst_u32(8), unconst_u32(406)); |
| let vf73: vec3u = (vec3u(unconst_u32(169), unconst_u32(107), unconst_u32(145)) >> vec3u(unconst_u32(100), unconst_u32(320), unconst_u32(227))); |
| _ = fn0(); |
| var vf74: vec4h = normalize(vec4h(unconst_f16(8562.7), unconst_f16(38.71), unconst_f16(13784.2), unconst_f16(7708.3))); |
| return out; |
| } |
| |
| /* zero global variables used */ |
| @compute @workgroup_size(1, 2, 1) |
| fn compute1() { |
| vp0 = mat3x2f(f32(reverseBits(u32(atomicLoad(&vw15[0])))), bitcast<f32>(reverseBits(u32(atomicLoad(&vw15[0])))), f32(reverseBits(u32(atomicLoad(&vw15[0])))), f32(reverseBits(u32(atomicLoad(&vw15[0])))), bitcast<f32>(reverseBits(u32(atomicLoad(&vw15[0])))), bitcast<f32>(reverseBits(u32(atomicLoad(&vw15[0]))))); |
| } |
| |
| /* used global variables: st0 */ |
| @compute @workgroup_size(1, 1, 1) |
| fn compute2() { |
| let ptr12: ptr<workgroup, array<atomic<i32>, 1>> = &(*&vw15); |
| let ptr13: ptr<workgroup, atomic<i32>> = &vw15[unconst_u32(43)]; |
| vp0 = mat3x2f(tan(vec4f(unconst_f32(0.04492), unconst_f32(0.1932), unconst_f32(0.4088), unconst_f32(0.06223))).zz, tan(vec4f(unconst_f32(0.04492), unconst_f32(0.1932), unconst_f32(0.4088), unconst_f32(0.06223))).yx, tan(vec4f(unconst_f32(0.04492), unconst_f32(0.1932), unconst_f32(0.4088), unconst_f32(0.06223))).ab); |
| while (unconst_f32(0.03491) < unconst_f32(0.3081)) { |
| vp0 = mat3x2f(f32(pack2x16float(vec2f(unconst_f32(0.1656), unconst_f32(0.5552)))), bitcast<f32>(pack2x16float(vec2f(unconst_f32(0.1656), unconst_f32(0.5552)))), bitcast<f32>(pack2x16float(vec2f(unconst_f32(0.1656), unconst_f32(0.5552)))), f32(pack2x16float(vec2f(unconst_f32(0.1656), unconst_f32(0.5552)))), bitcast<f32>(pack2x16float(vec2f(unconst_f32(0.1656), unconst_f32(0.5552)))), f32(pack2x16float(vec2f(unconst_f32(0.1656), unconst_f32(0.5552))))); |
| _ = fn4(vec2i(atomicLoad(&vw15[0])), array<vec4f, 14>(vec4f(pow(vec4h(unconst_f16(16177.7), unconst_f16(4708.0), unconst_f16(10518.8), unconst_f16(888.1)), vec4h(unconst_f16(9525.8), unconst_f16(674.4), unconst_f16(18935.2), unconst_f16(2427.1)))), vec4f(pow(vec4h(unconst_f16(16177.7), unconst_f16(4708.0), unconst_f16(10518.8), unconst_f16(888.1)), vec4h(unconst_f16(9525.8), unconst_f16(674.4), unconst_f16(18935.2), unconst_f16(2427.1)))), vec4f(pow(vec4h(unconst_f16(16177.7), unconst_f16(4708.0), unconst_f16(10518.8), unconst_f16(888.1)), vec4h(unconst_f16(9525.8), unconst_f16(674.4), unconst_f16(18935.2), unconst_f16(2427.1)))), vec4f(pow(vec4h(unconst_f16(16177.7), unconst_f16(4708.0), unconst_f16(10518.8), unconst_f16(888.1)), vec4h(unconst_f16(9525.8), unconst_f16(674.4), unconst_f16(18935.2), unconst_f16(2427.1)))), vec4f(pow(vec4h(unconst_f16(16177.7), unconst_f16(4708.0), unconst_f16(10518.8), unconst_f16(888.1)), vec4h(unconst_f16(9525.8), unconst_f16(674.4), unconst_f16(18935.2), unconst_f16(2427.1)))), vec4f(pow(vec4h(unconst_f16(16177.7), unconst_f16(4708.0), unconst_f16(10518.8), unconst_f16(888.1)), vec4h(unconst_f16(9525.8), unconst_f16(674.4), unconst_f16(18935.2), unconst_f16(2427.1)))), vec4f(pow(vec4h(unconst_f16(16177.7), unconst_f16(4708.0), unconst_f16(10518.8), unconst_f16(888.1)), vec4h(unconst_f16(9525.8), unconst_f16(674.4), unconst_f16(18935.2), unconst_f16(2427.1)))), vec4f(pow(vec4h(unconst_f16(16177.7), unconst_f16(4708.0), unconst_f16(10518.8), unconst_f16(888.1)), vec4h(unconst_f16(9525.8), unconst_f16(674.4), unconst_f16(18935.2), unconst_f16(2427.1)))), vec4f(pow(vec4h(unconst_f16(16177.7), unconst_f16(4708.0), unconst_f16(10518.8), unconst_f16(888.1)), vec4h(unconst_f16(9525.8), unconst_f16(674.4), unconst_f16(18935.2), unconst_f16(2427.1)))), vec4f(pow(vec4h(unconst_f16(16177.7), unconst_f16(4708.0), unconst_f16(10518.8), unconst_f16(888.1)), vec4h(unconst_f16(9525.8), unconst_f16(674.4), unconst_f16(18935.2), unconst_f16(2427.1)))), vec4f(pow(vec4h(unconst_f16(16177.7), unconst_f16(4708.0), unconst_f16(10518.8), unconst_f16(888.1)), vec4h(unconst_f16(9525.8), unconst_f16(674.4), unconst_f16(18935.2), unconst_f16(2427.1)))), vec4f(pow(vec4h(unconst_f16(16177.7), unconst_f16(4708.0), unconst_f16(10518.8), unconst_f16(888.1)), vec4h(unconst_f16(9525.8), unconst_f16(674.4), unconst_f16(18935.2), unconst_f16(2427.1)))), vec4f(pow(vec4h(unconst_f16(16177.7), unconst_f16(4708.0), unconst_f16(10518.8), unconst_f16(888.1)), vec4h(unconst_f16(9525.8), unconst_f16(674.4), unconst_f16(18935.2), unconst_f16(2427.1)))), vec4f(pow(vec4h(unconst_f16(16177.7), unconst_f16(4708.0), unconst_f16(10518.8), unconst_f16(888.1)), vec4h(unconst_f16(9525.8), unconst_f16(674.4), unconst_f16(18935.2), unconst_f16(2427.1)))))); |
| vp0 += mat3x2f(bitcast<f32>(atomicExchange(&vw15[0], unconst_i32(163))), f32(atomicExchange(&vw15[0], unconst_i32(163))), bitcast<f32>(atomicExchange(&vw15[0], unconst_i32(163))), bitcast<f32>(atomicExchange(&vw15[0], unconst_i32(163))), bitcast<f32>(atomicExchange(&vw15[0], unconst_i32(163))), f32(atomicExchange(&vw15[0], unconst_i32(163)))); |
| } |
| atomicAnd(&vw15[unconst_u32(44)], unconst_i32(160)); |
| let ptr14: ptr<workgroup, atomic<i32>> = &vw15[unconst_u32(136)]; |
| vp0 += mat3x2f(bitcast<vec2f>(textureDimensions(st0)), vec2f(textureDimensions(st0)), bitcast<vec2f>(textureDimensions(st0))); |
| vw14 = vec4<bool>(bool(atomicExchange(&(*ptr12)[unconst_u32(207)], i32(vw14[u32(atomicLoad(&vw15[0]))])))); |
| _ = st0; |
| }`, |
| }); |
| try { |
| computePassEncoder62.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder23.setBindGroup(1, bindGroup38); |
| } catch {} |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer46, 'uint32', 30_460, 662); |
| } catch {} |
| try { |
| renderPassEncoder12.setVertexBuffer(4, buffer24); |
| } catch {} |
| try { |
| commandEncoder109.resolveQuerySet(querySet0, 408, 34, buffer23, 512); |
| } catch {} |
| let commandEncoder110 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder60.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder30.setBindGroup(3, bindGroup26, [1024]); |
| } catch {} |
| try { |
| renderPassEncoder11.setBindGroup(1, bindGroup5, new Uint32Array(1155), 353, 0); |
| } catch {} |
| try { |
| renderPassEncoder20.executeBundles([renderBundle9]); |
| } catch {} |
| try { |
| renderPassEncoder10.setIndexBuffer(buffer19, 'uint32', 276, 135); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| commandEncoder110.copyBufferToTexture({ |
| /* bytesInLastRow: 20 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1036 */ |
| offset: 1036, |
| bytesPerRow: 9984, |
| buffer: buffer37, |
| }, { |
| texture: texture72, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 5, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let canvas2 = document.createElement('canvas'); |
| let computePassEncoder85 = commandEncoder109.beginComputePass({timestampWrites: {querySet: querySet4, endOfPassWriteIndex: 362}}); |
| try { |
| computePassEncoder28.setPipeline(pipeline0); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| buffer28.unmap(); |
| } catch {} |
| try { |
| commandEncoder110.copyBufferToTexture({ |
| /* bytesInLastRow: 28 widthInBlocks: 7 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 856 */ |
| offset: 856, |
| rowsPerImage: 41, |
| buffer: buffer26, |
| }, { |
| texture: texture59, |
| mipLevel: 0, |
| origin: {x: 7, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 7, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder110.resolveQuerySet(querySet4, 126, 72, buffer12, 0); |
| } catch {} |
| try { |
| adapter0.label = '\ufebc\u4dbd\u{1fada}\u{1fb46}\u0bb0'; |
| } catch {} |
| let veryExplicitBindGroupLayout18 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 2, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| ], |
| }); |
| let texture85 = device0.createTexture({ |
| size: {width: 2800, height: 17, depthOrArrayLayers: 1}, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder43.end(); |
| } catch {} |
| try { |
| renderPassEncoder29.setBindGroup(1, bindGroup31); |
| } catch {} |
| try { |
| renderPassEncoder11.setIndexBuffer(buffer47, 'uint16', 50, 267); |
| } catch {} |
| try { |
| commandEncoder110.copyBufferToTexture({ |
| /* bytesInLastRow: 24 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 60 */ |
| offset: 60, |
| bytesPerRow: 11520, |
| buffer: buffer18, |
| }, { |
| texture: texture60, |
| mipLevel: 0, |
| origin: {x: 0, y: 5, z: 0}, |
| aspect: 'all', |
| }, {width: 6, height: 169, depthOrArrayLayers: 0}); |
| } catch {} |
| let promise18 = device0.queue.onSubmittedWorkDone(); |
| let pipeline3 = device0.createRenderPipeline({ |
| layout: pipelineLayout4, |
| multisample: {mask: 0x167fa53c}, |
| fragment: {module: shaderModule2, constants: {}, targets: [{format: 'rgba8uint'}]}, |
| vertex: { |
| module: shaderModule0, |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 0, |
| stepMode: 'vertex', |
| attributes: [ |
| {format: 'sint32', offset: 96, shaderLocation: 3}, |
| {format: 'sint16x4', offset: 184, shaderLocation: 11}, |
| {format: 'snorm16x2', offset: 440, shaderLocation: 9}, |
| {format: 'float32', offset: 24, shaderLocation: 14}, |
| {format: 'float32', offset: 100, shaderLocation: 4}, |
| {format: 'unorm8x4', offset: 240, shaderLocation: 2}, |
| {format: 'snorm16x4', offset: 456, shaderLocation: 1}, |
| {format: 'sint32x4', offset: 164, shaderLocation: 5}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-list', cullMode: 'front', unclippedDepth: true}, |
| }); |
| let buffer51 = device0.createBuffer({ |
| size: 9639, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX, |
| }); |
| let texture86 = device0.createTexture({ |
| size: {width: 25, height: 1, depthOrArrayLayers: 46}, |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView92 = texture40.createView({aspect: 'all', format: 'rgba8sint', arrayLayerCount: 1}); |
| try { |
| computePassEncoder13.setBindGroup(1, bindGroup11); |
| } catch {} |
| try { |
| computePassEncoder84.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder10.setBindGroup(2, bindGroup0, []); |
| } catch {} |
| try { |
| renderPassEncoder28.setIndexBuffer(buffer10, 'uint16', 124, 719); |
| } catch {} |
| try { |
| commandEncoder52.copyBufferToTexture({ |
| /* bytesInLastRow: 1040 widthInBlocks: 130 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 272 */ |
| offset: 272, |
| buffer: buffer48, |
| }, { |
| texture: texture85, |
| mipLevel: 0, |
| origin: {x: 121, y: 4, z: 0}, |
| aspect: 'all', |
| }, {width: 130, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 96, height: 1820, depthOrArrayLayers: 296} |
| */ |
| { |
| source: offscreenCanvas0, |
| origin: { x: 1, y: 63 }, |
| flipY: true, |
| }, { |
| texture: texture12, |
| mipLevel: 0, |
| origin: {x: 11, y: 463, z: 35}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 17, height: 8, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandBuffer5 = commandEncoder52.finish(); |
| let textureView93 = texture38.createView({dimension: 'cube', baseArrayLayer: 1}); |
| try { |
| computePassEncoder33.setBindGroup(0, bindGroup8); |
| } catch {} |
| try { |
| computePassEncoder59.setBindGroup(0, bindGroup16, new Uint32Array(2023), 336, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder13); computePassEncoder13.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| computePassEncoder68.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(2, bindGroup24, new Uint32Array(1704), 324, 1); |
| } catch {} |
| try { |
| renderPassEncoder20.setIndexBuffer(buffer23, 'uint32', 16, 560); |
| } catch {} |
| try { |
| renderPassEncoder30.setVertexBuffer(4, buffer22); |
| } catch {} |
| let computePassEncoder86 = commandEncoder110.beginComputePass({timestampWrites: {querySet: querySet4}}); |
| let renderPassEncoder32 = commandEncoder108.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView37, |
| clearValue: { r: -155.7, g: -551.9, b: -675.6, a: -809.6, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| }); |
| let sampler65 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'nearest', |
| lodMaxClamp: 99.58, |
| }); |
| try { |
| computePassEncoder86.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder30.setBindGroup(0, bindGroup14, new Uint32Array(370), 28, 0); |
| } catch {} |
| await gc(); |
| let renderBundleEncoder15 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2uint'], depthReadOnly: true}); |
| try { |
| computePassEncoder14.setBindGroup(3, bindGroup19); |
| } catch {} |
| try { |
| renderBundleEncoder15.setBindGroup(0, bindGroup40, new Uint32Array(377), 76, 0); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer5]); |
| } catch {} |
| try { |
| globalThis.someLabel = device0.label; |
| } catch {} |
| let bindGroup42 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout0, |
| entries: [ |
| {binding: 19, resource: externalTexture8}, |
| {binding: 44, resource: externalTexture3}, |
| {binding: 131, resource: externalTexture9}, |
| {binding: 59, resource: externalTexture10}, |
| {binding: 47, resource: {buffer: buffer41, offset: 0, size: 508}}, |
| ], |
| }); |
| let textureView94 = texture59.createView({dimension: '2d-array', aspect: 'all'}); |
| let renderBundle15 = renderBundleEncoder15.finish({}); |
| try { |
| computePassEncoder41.setBindGroup(0, bindGroup34); |
| } catch {} |
| try { |
| computePassEncoder76.setBindGroup(2, bindGroup26, new Uint32Array(272), 112, 1); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder13); computePassEncoder13.dispatchWorkgroupsIndirect(buffer9, 748); }; |
| } catch {} |
| try { |
| computePassEncoder78.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(0, bindGroup9, new Uint32Array(619), 91, 0); |
| } catch {} |
| try { |
| renderPassEncoder12.setVertexBuffer(1, buffer24, 0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture20, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 4}, |
| aspect: 'all', |
| }, new Uint8Array(121).fill(42), /* required buffer size: 121 */ |
| {offset: 121}, {width: 1, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 96, height: 1820, depthOrArrayLayers: 296} |
| */ |
| { |
| source: imageData10, |
| origin: { x: 0, y: 3 }, |
| flipY: false, |
| }, { |
| texture: texture12, |
| mipLevel: 0, |
| origin: {x: 12, y: 675, z: 39}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 6, height: 5, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| canvas2.getContext('webgpu'); |
| } catch {} |
| let textureView95 = texture26.createView({arrayLayerCount: 1}); |
| let sampler66 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'clamp-to-edge', |
| minFilter: 'nearest', |
| compare: 'less', |
| maxAnisotropy: 1, |
| }); |
| try { |
| computePassEncoder72.setBindGroup(0, bindGroup31); |
| } catch {} |
| try { |
| computePassEncoder51.pushDebugGroup('\u7a77'); |
| } catch {} |
| try { |
| computePassEncoder51.popDebugGroup(); |
| } catch {} |
| let veryExplicitBindGroupLayout19 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 3, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 49, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 52, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'storage', minBindingSize: 26, hasDynamicOffset: false }, |
| }, |
| { |
| binding: 85, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'rgba32uint', access: 'write-only', viewDimension: '3d' }, |
| }, |
| { |
| binding: 322, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 356, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '3d' }, |
| }, |
| ], |
| }); |
| let texture87 = device0.createTexture({ |
| size: {width: 700, height: 4, depthOrArrayLayers: 1}, |
| format: 'rgba8uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView96 = texture31.createView({dimension: '2d-array', baseArrayLayer: 0}); |
| try { |
| computePassEncoder38.setBindGroup(0, bindGroup35, new Uint32Array(534), 40, 1); |
| } catch {} |
| try { |
| computePassEncoder13.end(); |
| } catch {} |
| try { |
| computePassEncoder70.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder3.executeBundles([renderBundle8, renderBundle8, renderBundle8, renderBundle8, renderBundle8]); |
| } catch {} |
| try { |
| renderPassEncoder27.setIndexBuffer(buffer46, 'uint16', 5_684, 1_342); |
| } catch {} |
| try { |
| commandEncoder13.copyBufferToBuffer(buffer21, 260, buffer18, 492, 116); |
| } catch {} |
| try { |
| commandEncoder13.resolveQuerySet(querySet2, 141, 4, buffer44, 0); |
| } catch {} |
| let texture88 = device0.createTexture({ |
| size: [96, 1820, 434], |
| mipLevelCount: 5, |
| dimension: '3d', |
| format: 'rgba8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder66.setPipeline(pipeline0); |
| } catch {} |
| try { |
| buffer11.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| } catch {} |
| try { |
| if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55); }; |
| } catch {} |
| let buffer52 = device0.createBuffer({ |
| size: 11452, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let texture89 = device0.createTexture({ |
| size: {width: 48, height: 910, depthOrArrayLayers: 1}, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler67 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 84.60, |
| lodMaxClamp: 93.41, |
| maxAnisotropy: 18, |
| }); |
| try { |
| computePassEncoder12.setBindGroup(1, bindGroup26, new Uint32Array(4994), 227, 1); |
| } catch {} |
| try { |
| renderPassEncoder7.setBindGroup(2, bindGroup38); |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(2, bindGroup39, new Uint32Array(1766), 587, 0); |
| } catch {} |
| let commandEncoder111 = device0.createCommandEncoder({}); |
| let commandBuffer6 = commandEncoder13.finish(); |
| let textureView97 = texture33.createView({mipLevelCount: 1}); |
| let texture90 = device0.createTexture({ |
| size: {width: 700, height: 4, depthOrArrayLayers: 1}, |
| format: 'r32sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView98 = texture40.createView({dimension: '2d', baseMipLevel: 0}); |
| let computePassEncoder87 = commandEncoder111.beginComputePass({}); |
| try { |
| computePassEncoder83.setBindGroup(1, bindGroup14); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder72); computePassEncoder72.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder76.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder23.setIndexBuffer(buffer34, 'uint16', 6_080, 78); |
| } catch {} |
| try { |
| renderPassEncoder11.setVertexBuffer(3, buffer10, 0, 3_017); |
| } catch {} |
| let promise19 = device0.queue.onSubmittedWorkDone(); |
| try { |
| adapter0.label = '\ua6b4\u{1fb84}\u9a78\u97ee\u0f52\u8520\u0523\u{1f803}'; |
| } catch {} |
| let commandEncoder112 = device0.createCommandEncoder(); |
| let computePassEncoder88 = commandEncoder112.beginComputePass({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder38); computePassEncoder38.dispatchWorkgroupsIndirect(buffer43, 360); }; |
| } catch {} |
| try { |
| computePassEncoder54.setPipeline(pipeline0); |
| } catch {} |
| try { |
| computePassEncoder75.setPipeline(pipeline2); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| let commandEncoder113 = device0.createCommandEncoder({}); |
| let texture91 = device0.createTexture({ |
| size: {width: 12, height: 1, depthOrArrayLayers: 1}, |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let computePassEncoder89 = commandEncoder113.beginComputePass({timestampWrites: {querySet: querySet3, endOfPassWriteIndex: 57}}); |
| let sampler68 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 58.35, |
| maxAnisotropy: 5, |
| }); |
| try { |
| computePassEncoder8.setBindGroup(0, bindGroup20); |
| } catch {} |
| try { |
| computePassEncoder64.setPipeline(pipeline2); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let commandEncoder114 = device0.createCommandEncoder({}); |
| let sampler69 = device0.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'repeat', lodMinClamp: 9.544}); |
| try { |
| computePassEncoder5.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder30.setBindGroup(0, bindGroup17, new Uint32Array(2190), 7, 1); |
| } catch {} |
| try { |
| renderPassEncoder15.setIndexBuffer(buffer23, 'uint16', 1_254, 2_271); |
| } catch {} |
| try { |
| renderPassEncoder31.setVertexBuffer(4, undefined); |
| } catch {} |
| try { |
| commandEncoder114.copyBufferToBuffer(buffer10, 4560, buffer3, 1692, 952); |
| } catch {} |
| try { |
| commandEncoder114.resolveQuerySet(querySet4, 4, 75, buffer25, 768); |
| } catch {} |
| await gc(); |
| let imageBitmap2 = await createImageBitmap(imageData8); |
| let textureView99 = texture18.createView({format: 'etc2-rgb8unorm-srgb'}); |
| try { |
| renderPassEncoder0.setBindGroup(2, bindGroup22, new Uint32Array(60), 10, 0); |
| } catch {} |
| try { |
| renderPassEncoder16.executeBundles([renderBundle13]); |
| } catch {} |
| try { |
| renderPassEncoder19.setIndexBuffer(buffer44, 'uint32', 48, 72); |
| } catch {} |
| try { |
| adapter0.label = '\u02ca\u{1fd02}\u{1fb93}\ud48b\u{1f63b}\u30ea\u7b63\u3ef0\u0ce1\u038d'; |
| } catch {} |
| let bindGroup43 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout5, |
| entries: [ |
| {binding: 19, resource: externalTexture0}, |
| {binding: 44, resource: externalTexture4}, |
| {binding: 59, resource: externalTexture8}, |
| {binding: 131, resource: externalTexture3}, |
| {binding: 47, resource: {buffer: buffer29, offset: 512, size: 2200}}, |
| ], |
| }); |
| let texture92 = device0.createTexture({ |
| size: {width: 1400, height: 8, depthOrArrayLayers: 1}, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let textureView100 = texture62.createView({mipLevelCount: 1}); |
| let sampler70 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| minFilter: 'nearest', |
| lodMaxClamp: 79.95, |
| }); |
| try { |
| computePassEncoder33.setBindGroup(3, bindGroup35, [0]); |
| } catch {} |
| try { |
| computePassEncoder38.end(); |
| } catch {} |
| try { |
| renderPassEncoder12.setViewport(5004.279355112527, 4.458389569069665, 193.03177691460084, 23.287252933469716, 0.6133120103855297, 0.8971088636989719); |
| } catch {} |
| try { |
| renderPassEncoder7.setIndexBuffer(buffer49, 'uint16', 18, 370); |
| } catch {} |
| try { |
| commandEncoder44.clearBuffer(buffer38, 552, 324); |
| } catch {} |
| try { |
| commandEncoder114.resolveQuerySet(querySet2, 8, 1, buffer44, 0); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| let bindGroup44 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [ |
| {binding: 59, resource: externalTexture0}, |
| {binding: 47, resource: {buffer: buffer5, offset: 1280, size: 3048}}, |
| {binding: 19, resource: externalTexture6}, |
| {binding: 44, resource: externalTexture3}, |
| {binding: 131, resource: externalTexture5}, |
| ], |
| }); |
| let texture93 = device0.createTexture({ |
| size: [48], |
| sampleCount: 1, |
| dimension: '1d', |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder47.setBindGroup(0, bindGroup2, [0]); |
| } catch {} |
| try { |
| renderPassEncoder30.setBindGroup(0, bindGroup13, [1024]); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer37, 156, new Float32Array(2204), 288, 52); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| await promise15; |
| } catch {} |
| try { |
| globalThis.someLabel = computePassEncoder88.label; |
| } catch {} |
| let commandEncoder115 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder8.setBindGroup(3, bindGroup42); |
| } catch {} |
| try { |
| renderPassEncoder25.setBindGroup(1, bindGroup0, new Uint32Array(428), 7, 0); |
| } catch {} |
| try { |
| commandEncoder44.copyTextureToTexture({ |
| texture: texture53, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 4}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture16, |
| mipLevel: 0, |
| origin: {x: 0, y: 1, z: 16}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| let textureView101 = texture9.createView({}); |
| try { |
| computePassEncoder77.setBindGroup(0, bindGroup38, new Uint32Array(1349), 465, 0); |
| } catch {} |
| try { |
| renderPassEncoder14.setViewport(605.5852888096485, 3.660779165175893, 792.8495348675528, 2.074182268681728, 0.6533155065001948, 0.6913371307530455); |
| } catch {} |
| let texture94 = device0.createTexture({size: {width: 12}, dimension: '1d', format: 'r32sint', usage: GPUTextureUsage.TEXTURE_BINDING}); |
| let computePassEncoder90 = commandEncoder114.beginComputePass(); |
| let sampler71 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 82.91, |
| maxAnisotropy: 8, |
| }); |
| let externalTexture11 = device0.importExternalTexture({source: videoFrame9}); |
| try { |
| computePassEncoder77.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder15.setIndexBuffer(buffer38, 'uint16', 726, 942); |
| } catch {} |
| try { |
| commandEncoder115.copyBufferToTexture({ |
| /* bytesInLastRow: 52 widthInBlocks: 13 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1348 */ |
| offset: 1348, |
| bytesPerRow: 43264, |
| buffer: buffer20, |
| }, { |
| texture: texture61, |
| mipLevel: 0, |
| origin: {x: 8, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 13, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder115.resolveQuerySet(querySet3, 4, 21, buffer24, 0); |
| } catch {} |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55); }; |
| } catch {} |
| let bindGroup45 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout6, |
| entries: [ |
| {binding: 47, resource: {buffer: buffer5, offset: 1024, size: 1984}}, |
| {binding: 44, resource: externalTexture11}, |
| {binding: 131, resource: externalTexture7}, |
| {binding: 19, resource: externalTexture11}, |
| {binding: 59, resource: externalTexture5}, |
| ], |
| }); |
| let commandEncoder116 = device0.createCommandEncoder({}); |
| let texture95 = gpuCanvasContext1.getCurrentTexture(); |
| let computePassEncoder91 = commandEncoder115.beginComputePass({}); |
| let sampler72 = device0.createSampler({ |
| addressModeV: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 95.03, |
| maxAnisotropy: 9, |
| }); |
| try { |
| computePassEncoder44.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder28.setBindGroup(2, bindGroup22); |
| } catch {} |
| try { |
| commandEncoder44.copyBufferToTexture({ |
| /* bytesInLastRow: 1632 widthInBlocks: 408 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 416 */ |
| offset: 416, |
| bytesPerRow: 15104, |
| buffer: buffer25, |
| }, { |
| texture: texture54, |
| mipLevel: 0, |
| origin: {x: 76, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 408, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder44.copyTextureToBuffer({ |
| texture: texture62, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1132 */ |
| offset: 1132, |
| buffer: buffer12, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder117 = device0.createCommandEncoder({}); |
| let computePassEncoder92 = commandEncoder117.beginComputePass({}); |
| try { |
| computePassEncoder61.setBindGroup(1, bindGroup45); |
| } catch {} |
| try { |
| computePassEncoder21.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder15.setBindGroup(3, bindGroup28, [0]); |
| } catch {} |
| let computePassEncoder93 = commandEncoder116.beginComputePass({}); |
| let renderBundleEncoder16 = device0.createRenderBundleEncoder({colorFormats: ['r32sint'], stencilReadOnly: false}); |
| try { |
| renderBundleEncoder16.setBindGroup(2, bindGroup23); |
| } catch {} |
| try { |
| renderBundleEncoder16.setIndexBuffer(buffer51, 'uint32', 340, 1_119); |
| } catch {} |
| try { |
| commandEncoder44.copyTextureToBuffer({ |
| texture: texture39, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 20 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 600 */ |
| offset: 600, |
| buffer: buffer37, |
| }, {width: 5, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 96, height: 1820, depthOrArrayLayers: 296} |
| */ |
| { |
| source: videoFrame9, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture12, |
| mipLevel: 0, |
| origin: {x: 39, y: 31, z: 65}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder118 = device0.createCommandEncoder({}); |
| let renderPassEncoder33 = commandEncoder44.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView76, |
| clearValue: { r: -129.8, g: -448.0, b: -713.1, a: 24.21, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| }); |
| let sampler73 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| lodMaxClamp: 6.166, |
| compare: 'not-equal', |
| }); |
| try { |
| computePassEncoder88.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder16.setVertexBuffer(6, buffer40, 56, 23); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let commandEncoder119 = device0.createCommandEncoder(); |
| let querySet5 = device0.createQuerySet({type: 'timestamp', count: 1152}); |
| let textureView102 = texture69.createView({dimension: '2d-array'}); |
| let sampler74 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| lodMaxClamp: 94.30, |
| compare: 'greater-equal', |
| maxAnisotropy: 1, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder61); computePassEncoder61.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| computePassEncoder2.setPipeline(pipeline0); |
| } catch {} |
| try { |
| commandEncoder119.copyBufferToTexture({ |
| /* bytesInLastRow: 20 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 560 */ |
| offset: 560, |
| bytesPerRow: 16896, |
| buffer: buffer21, |
| }, { |
| texture: texture34, |
| mipLevel: 0, |
| origin: {x: 11, y: 39, z: 0}, |
| aspect: 'all', |
| }, {width: 5, height: 12, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| renderPassEncoder31.insertDebugMarker('\uda9e'); |
| } catch {} |
| let videoFrame13 = new VideoFrame(canvas2, {timestamp: 0}); |
| let commandEncoder120 = device0.createCommandEncoder({}); |
| let texture96 = device0.createTexture({ |
| size: [51, 1, 580], |
| dimension: '3d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let externalTexture12 = device0.importExternalTexture({source: videoFrame9}); |
| try { |
| computePassEncoder87.setBindGroup(0, bindGroup16); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder8); computePassEncoder8.dispatchWorkgroups(1, 2); }; |
| } catch {} |
| try { |
| computePassEncoder73.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(2, buffer30, 156); |
| } catch {} |
| try { |
| renderBundleEncoder16.setBindGroup(3, bindGroup28, [0]); |
| } catch {} |
| try { |
| buffer11.unmap(); |
| } catch {} |
| try { |
| commandEncoder118.copyBufferToTexture({ |
| /* bytesInLastRow: 112 widthInBlocks: 28 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 424 */ |
| offset: 424, |
| bytesPerRow: 2304, |
| buffer: buffer7, |
| }, { |
| texture: texture21, |
| mipLevel: 1, |
| origin: {x: 0, y: 77, z: 0}, |
| aspect: 'all', |
| }, {width: 28, height: 569, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder121 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder61.setBindGroup(2, bindGroup39, new Uint32Array(722), 26, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder61); computePassEncoder61.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder91.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder25.setVertexBuffer(3, buffer49, 0); |
| } catch {} |
| try { |
| renderBundleEncoder16.setIndexBuffer(buffer17, 'uint16', 114, 64); |
| } catch {} |
| try { |
| commandEncoder121.copyTextureToTexture({ |
| texture: texture49, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture34, |
| mipLevel: 0, |
| origin: {x: 0, y: 10, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 4, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let promise20 = device0.queue.onSubmittedWorkDone(); |
| document.body.prepend(canvas1); |
| let bindGroup46 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout1, |
| entries: [ |
| {binding: 131, resource: externalTexture1}, |
| {binding: 47, resource: {buffer: buffer14, offset: 0, size: 680}}, |
| {binding: 59, resource: externalTexture2}, |
| {binding: 44, resource: externalTexture10}, |
| {binding: 19, resource: externalTexture10}, |
| ], |
| }); |
| let buffer53 = device0.createBuffer({ |
| size: 5201, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let texture97 = device0.createTexture({ |
| size: [102, 1, 19], |
| mipLevelCount: 2, |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView103 = texture91.createView({dimension: '2d-array', arrayLayerCount: 1}); |
| let renderBundle16 = renderBundleEncoder16.finish(); |
| let sampler75 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'clamp-to-edge', lodMaxClamp: 50.50, compare: 'equal'}); |
| try { |
| computePassEncoder24.setBindGroup(1, bindGroup20, new Uint32Array(2102), 106, 0); |
| } catch {} |
| try { |
| computePassEncoder23.setPipeline(pipeline1); |
| } catch {} |
| try { |
| computePassEncoder83.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder30.setBindGroup(2, bindGroup25, new Uint32Array(378), 99, 0); |
| } catch {} |
| try { |
| commandEncoder119.copyBufferToTexture({ |
| /* bytesInLastRow: 20 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 2808 */ |
| offset: 2808, |
| rowsPerImage: 342, |
| buffer: buffer26, |
| }, { |
| texture: texture14, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 5, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| computePassEncoder23.insertDebugMarker('\u6982'); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 96, height: 1820, depthOrArrayLayers: 296} |
| */ |
| { |
| source: videoFrame7, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture12, |
| mipLevel: 0, |
| origin: {x: 2, y: 1311, z: 9}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| adapter0.label = '\u0505\u0e87\u{1f8a3}\u0919\u794c'; |
| } catch {} |
| let recycledExplicitBindGroupLayout8 = pipeline0.getBindGroupLayout(0); |
| let bindGroup47 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout0, |
| entries: [ |
| {binding: 44, resource: externalTexture9}, |
| {binding: 59, resource: externalTexture10}, |
| {binding: 19, resource: externalTexture9}, |
| {binding: 47, resource: {buffer: buffer23, offset: 1024, size: 7616}}, |
| {binding: 131, resource: externalTexture7}, |
| ], |
| }); |
| let commandEncoder122 = device0.createCommandEncoder({}); |
| let commandBuffer7 = commandEncoder120.finish(); |
| let computePassEncoder94 = commandEncoder118.beginComputePass({}); |
| try { |
| renderPassEncoder25.setBindGroup(2, bindGroup17, [0]); |
| } catch {} |
| try { |
| globalThis.someLabel = device0.queue.label; |
| } catch {} |
| let bindGroup48 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout5, |
| entries: [ |
| {binding: 131, resource: externalTexture7}, |
| {binding: 19, resource: externalTexture5}, |
| {binding: 59, resource: externalTexture0}, |
| {binding: 44, resource: externalTexture10}, |
| {binding: 47, resource: {buffer: buffer31, offset: 0, size: 4920}}, |
| ], |
| }); |
| let buffer54 = device0.createBuffer({ |
| size: 145, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder123 = device0.createCommandEncoder({}); |
| let textureView104 = texture61.createView({dimension: '2d-array', baseMipLevel: 0}); |
| try { |
| computePassEncoder93.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder26.setBindGroup(0, bindGroup38, new Uint32Array(2842), 946, 0); |
| } catch {} |
| try { |
| renderPassEncoder15.setIndexBuffer(buffer24, 'uint16', 68, 135); |
| } catch {} |
| try { |
| commandEncoder119.clearBuffer(buffer18, 1484, 1168); |
| } catch {} |
| try { |
| externalTexture5.label = '\u5975\u{1f893}'; |
| } catch {} |
| let bindGroup49 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout1, |
| entries: [ |
| {binding: 59, resource: externalTexture3}, |
| {binding: 131, resource: externalTexture12}, |
| {binding: 47, resource: {buffer: buffer46, offset: 2560, size: 424}}, |
| {binding: 44, resource: externalTexture1}, |
| {binding: 19, resource: externalTexture2}, |
| ], |
| }); |
| let commandEncoder124 = device0.createCommandEncoder({}); |
| let computePassEncoder95 = commandEncoder123.beginComputePass({}); |
| let sampler76 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'mirror-repeat', lodMinClamp: 31.47, maxAnisotropy: 1}); |
| try { |
| computePassEncoder64.setBindGroup(2, bindGroup34); |
| } catch {} |
| try { |
| computePassEncoder85.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder25.setVertexBuffer(7, buffer13, 0, 11_389); |
| } catch {} |
| try { |
| commandEncoder122.copyBufferToBuffer(buffer1, 0, buffer51, 40, 56); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture4, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(816).fill(223), /* required buffer size: 816 */ |
| {offset: 816}, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let commandEncoder125 = device0.createCommandEncoder({}); |
| let texture98 = device0.createTexture({ |
| size: [25, 1, 172], |
| dimension: '3d', |
| format: 'rg32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture99 = device0.createTexture({ |
| size: [25, 1, 38], |
| dimension: '3d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder96 = commandEncoder119.beginComputePass(); |
| try { |
| renderPassEncoder6.setBindGroup(3, bindGroup18); |
| } catch {} |
| try { |
| renderPassEncoder21.setVertexBuffer(3, buffer24); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 96, height: 1820, depthOrArrayLayers: 296} |
| */ |
| { |
| source: imageData2, |
| origin: { x: 2, y: 16 }, |
| flipY: true, |
| }, { |
| texture: texture12, |
| mipLevel: 0, |
| origin: {x: 1, y: 667, z: 83}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 3, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await promise18; |
| } catch {} |
| let imageData11 = new ImageData(36, 4); |
| let texture100 = device0.createTexture({ |
| label: '\ue8dc\u5ecc\u0f7f\u{1ff31}\u77ca\u5ef0\u737b\u439d', |
| size: [700, 4, 71], |
| dimension: '3d', |
| format: 'rg32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView105 = texture76.createView({dimension: '2d-array', mipLevelCount: 1, baseArrayLayer: 0}); |
| try { |
| renderPassEncoder25.setBindGroup(3, bindGroup17, new Uint32Array(6296), 2_966, 1); |
| } catch {} |
| try { |
| renderPassEncoder33.setVertexBuffer(2, buffer54, 16, 37); |
| } catch {} |
| try { |
| commandEncoder122.copyTextureToBuffer({ |
| texture: texture68, |
| mipLevel: 0, |
| origin: {x: 8, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 1 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 1459 */ |
| offset: 1459, |
| buffer: buffer29, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let veryExplicitBindGroupLayout20 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 52, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}}, |
| { |
| binding: 110, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 141, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: true }, |
| }, |
| ], |
| }); |
| let texture101 = device0.createTexture({ |
| size: {width: 48, height: 910, depthOrArrayLayers: 22}, |
| dimension: '3d', |
| format: 'rg32float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture102 = device0.createTexture({ |
| size: {width: 48, height: 910, depthOrArrayLayers: 1}, |
| mipLevelCount: 4, |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: ['rgb10a2uint'], |
| }); |
| let renderPassEncoder34 = commandEncoder125.beginRenderPass({ |
| colorAttachments: [{view: textureView44, loadOp: 'clear', storeOp: 'store'}], |
| occlusionQuerySet: querySet2, |
| timestampWrites: {querySet: querySet5, beginningOfPassWriteIndex: 681}, |
| }); |
| try { |
| computePassEncoder1.setBindGroup(0, bindGroup22); |
| } catch {} |
| try { |
| renderPassEncoder33.setBindGroup(3, bindGroup24, [0]); |
| } catch {} |
| try { |
| renderPassEncoder17.setIndexBuffer(buffer46, 'uint32', 3_808, 333); |
| } catch {} |
| let commandEncoder126 = device0.createCommandEncoder({}); |
| let querySet6 = device0.createQuerySet({type: 'timestamp', count: 75}); |
| let texture103 = device0.createTexture({ |
| size: {width: 51, height: 1, depthOrArrayLayers: 39}, |
| dimension: '3d', |
| format: 'rg32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderBundleEncoder17 = device0.createRenderBundleEncoder({colorFormats: ['rgba8uint'], depthReadOnly: true}); |
| try { |
| computePassEncoder66.setBindGroup(3, bindGroup34, new Uint32Array(408), 26, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder2); computePassEncoder2.dispatchWorkgroupsIndirect(buffer29, 4_940); }; |
| } catch {} |
| try { |
| renderPassEncoder29.setIndexBuffer(buffer38, 'uint16', 9_470, 90); |
| } catch {} |
| try { |
| renderPassEncoder18.setVertexBuffer(3, buffer53); |
| } catch {} |
| try { |
| renderBundleEncoder17.setBindGroup(0, bindGroup28, [0]); |
| } catch {} |
| try { |
| renderBundleEncoder17.setVertexBuffer(2, buffer49, 184, 1_703); |
| } catch {} |
| let pipeline4 = device0.createRenderPipeline({ |
| layout: 'auto', |
| fragment: { |
| module: shaderModule2, |
| targets: [{ |
| format: 'rgba8uint', |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN, |
| }], |
| }, |
| vertex: { |
| module: shaderModule0, |
| buffers: [ |
| { |
| arrayStride: 0, |
| attributes: [ |
| {format: 'sint32', offset: 908, shaderLocation: 11}, |
| {format: 'unorm10-10-10-2', offset: 156, shaderLocation: 2}, |
| {format: 'float16x2', offset: 72, shaderLocation: 9}, |
| {format: 'sint32x2', offset: 668, shaderLocation: 5}, |
| {format: 'snorm8x4', offset: 196, shaderLocation: 4}, |
| {format: 'unorm10-10-10-2', offset: 1012, shaderLocation: 14}, |
| {format: 'float16x4', offset: 80, shaderLocation: 1}, |
| ], |
| }, |
| { |
| arrayStride: 1100, |
| stepMode: 'vertex', |
| attributes: [{format: 'sint8x4', offset: 184, shaderLocation: 3}], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-strip', stripIndexFormat: 'uint16', frontFace: 'cw', cullMode: 'front'}, |
| }); |
| await gc(); |
| let texture104 = device0.createTexture({ |
| size: {width: 25, height: 1, depthOrArrayLayers: 136}, |
| mipLevelCount: 1, |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'rg32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView106 = texture25.createView({baseArrayLayer: 0, arrayLayerCount: 1}); |
| let computePassEncoder97 = commandEncoder126.beginComputePass({}); |
| let renderBundle17 = renderBundleEncoder17.finish(); |
| try { |
| renderPassEncoder27.executeBundles([renderBundle0, renderBundle7]); |
| } catch {} |
| try { |
| renderPassEncoder29.setIndexBuffer(buffer34, 'uint32', 624, 1_142); |
| } catch {} |
| let arrayBuffer11 = buffer15.getMappedRange(3720, 252); |
| try { |
| await promise19; |
| } catch {} |
| let textureView107 = texture100.createView({baseMipLevel: 0}); |
| try { |
| renderPassEncoder25.setIndexBuffer(buffer47, 'uint32', 132, 19); |
| } catch {} |
| try { |
| commandEncoder124.copyBufferToTexture({ |
| /* bytesInLastRow: 108 widthInBlocks: 27 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1476 */ |
| offset: 1476, |
| bytesPerRow: 13056, |
| buffer: buffer32, |
| }, { |
| texture: texture69, |
| mipLevel: 0, |
| origin: {x: 65, y: 2, z: 0}, |
| aspect: 'all', |
| }, {width: 27, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder121.copyTextureToTexture({ |
| texture: texture103, |
| mipLevel: 0, |
| origin: {x: 5, y: 0, z: 2}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture98, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 1}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let promise21 = device0.queue.onSubmittedWorkDone(); |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 96, height: 1820, depthOrArrayLayers: 296} |
| */ |
| { |
| source: imageData7, |
| origin: { x: 0, y: 6 }, |
| flipY: true, |
| }, { |
| texture: texture12, |
| mipLevel: 0, |
| origin: {x: 2, y: 682, z: 103}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext2.unconfigure(); |
| } catch {} |
| try { |
| await promise17; |
| } catch {} |
| offscreenCanvas0.height = 741; |
| let commandEncoder127 = device0.createCommandEncoder({}); |
| let texture105 = device0.createTexture({ |
| size: [24, 455, 1], |
| sampleCount: 4, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder98 = commandEncoder127.beginComputePass({}); |
| let renderPassEncoder35 = commandEncoder121.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView44, |
| clearValue: { r: -725.4, g: -820.9, b: -949.3, a: 571.9, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| timestampWrites: {querySet: querySet6, beginningOfPassWriteIndex: 62, endOfPassWriteIndex: 42}, |
| maxDrawCount: 420833853, |
| }); |
| try { |
| computePassEncoder89.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder34.setBindGroup(2, bindGroup2, new Uint32Array(3955), 62, 1); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| commandEncoder122.copyTextureToTexture({ |
| texture: texture59, |
| mipLevel: 0, |
| origin: {x: 15, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture92, |
| mipLevel: 0, |
| origin: {x: 260, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 44, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let shaderModule3 = device0.createShaderModule({ |
| code: ` |
| requires readonly_and_readwrite_storage_textures; |
| |
| diagnostic(info, xyz); |
| |
| enable f16; |
| |
| requires unrestricted_pointer_parameters; |
| |
| override override10 = 0.07520; |
| |
| override override3: u32 = 475; |
| |
| @id(17947) override override4: f16; |
| |
| struct T7 { |
| @size(96) f0: array<T0, 1>, |
| } |
| |
| @id(27645) override override7: f32; |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| struct T6 { |
| @size(64) f0: T0, |
| @align(32) @size(1152) f1: array<u32>, |
| } |
| |
| struct T8 { |
| f0: array<atomic<i32>>, |
| } |
| |
| override override5 = 0.02793; |
| |
| struct T4 { |
| @align(8) @size(104) f0: atomic<u32>, |
| } |
| |
| struct T9 { |
| @size(1952) f0: array<u32>, |
| } |
| |
| override override11 = true; |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| /* zero global variables used */ |
| fn fn1(a0: array<array<array<array<vec2u, 1>, 1>, 1>, 1>, a1: ptr<function, mat4x4f>) { |
| let vf78: vec2u = a0[unconst_u32(142)][0][unconst_u32(58)][0]; |
| var vf79 = fn0(FragmentOutput1(vec2i(i32(vw16[38][0])), vec4f(f32(vw16[38][0])))); |
| _ = override9; |
| _ = override5; |
| } |
| |
| @group(0) @binding(224) var et2: texture_external; |
| |
| @id(41508) override override12: bool; |
| |
| override override9: f16 = 27610.2; |
| |
| struct T5 { |
| @align(64) @size(2880) f0: T3, |
| } |
| |
| var<workgroup> vw16: array<array<f16, 1>, 39>; |
| |
| @id(41706) override override8: u32; |
| |
| @id(56084) override override2: i32; |
| |
| struct T0 { |
| @align(8) @size(8) f0: atomic<u32>, |
| } |
| |
| struct T2 { |
| @align(32) @size(32) f0: array<u32>, |
| } |
| |
| struct T3 { |
| @size(768) f0: array<T0>, |
| } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| @id(59150) override override1: f16 = 2523.9; |
| |
| struct T1 { |
| @size(532) f0: array<array<array<i32, 1>, 1>>, |
| } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| @id(21050) override override6 = 0.1538; |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| /* zero global variables used */ |
| fn fn0(a0: FragmentOutput1) -> array<FragmentOutput1, 1> { |
| var out: array<FragmentOutput1, 1>; |
| vw16[unconst_u32(280)][unconst_u32(137)] *= override9; |
| vw16[unconst_u32(112)][unconst_u32(133)] -= f16(a0.f1[3]); |
| while bool(fract(unconst_f16(4491.4))) { |
| let vf75: i32 = a0.f0[unconst_u32(92)]; |
| let ptr15: ptr<workgroup, array<f16, 1>> = &(*&vw16)[38]; |
| out[unconst_u32(56)].f1 = vec4f(reflect(vec2h(unconst_f16(3306.4), unconst_f16(15003.4)), vec2h(unconst_f16(12717.5), unconst_f16(27334.9))).yxyy); |
| var vf76: vec2h = pow(vec2h(unconst_f16(4897.2), unconst_f16(8047.4)), vec2h(unconst_f16(16519.3), unconst_f16(10149.3))); |
| vw16[unconst_u32(2)][unconst_u32(574)] -= atan(vec3h(unconst_f16(4728.5), unconst_f16(3612.2), unconst_f16(2892.9))).g; |
| vf76 += vec2h(vw16[unconst_u32(42)][0]); |
| break; |
| } |
| out[unconst_u32(46)].f0 = vec2i(i32(ldexp(unconst_f16(11593.5), unconst_i32(112)))); |
| for (var it2=u32(normalize(vec4h((*&vw16)[38][unconst_u32(650)])).w); it2<u32(vw16[unconst_u32(13)][0]); it2++) { |
| var vf77: u32 = pack4xI8(vec4i(unconst_i32(47), unconst_i32(13), unconst_i32(221), unconst_i32(99))); |
| vw16[unconst_u32(204)][bitcast<u32>(override5)] = vw16[38][0]; |
| _ = override5; |
| } |
| return out; |
| _ = override9; |
| _ = override5; |
| } |
| |
| struct FragmentOutput1 { |
| @location(1) f0: vec2i, |
| @location(0) f1: vec4f, |
| } |
| |
| /* zero global variables used */ |
| @vertex |
| fn vertex3(@location(14) a0: vec2f) -> @builtin(position) vec4f { |
| var out: vec4f; |
| out -= vec4f(f32(override3)); |
| let vf80: vec4h = tanh(vec4h(unconst_f16(7907.6), unconst_f16(4593.0), unconst_f16(3552.8), unconst_f16(2824.1))); |
| out -= vec4f(f32(override9)); |
| out += vec4f(f32(vf80[vec3u(cross(vec3f(unconst_f32(0.1764), unconst_f32(0.1132), unconst_f32(0.1292)), vec3f(override5))).r])); |
| out -= vec4f(f32(length(vec4h(unconst_f16(4216.8), unconst_f16(3989.5), unconst_f16(3237.3), unconst_f16(3153.5))))); |
| var vf81: u32 = dot(vec3u(unconst_u32(119), unconst_u32(246), unconst_u32(10)), vec3u( !vec3<bool>(unconst_bool(false), unconst_bool(false), unconst_bool(true)))); |
| out *= vec4f(f32(length(vec4h(unconst_f16(1662.6), unconst_f16(13763.4), unconst_f16(6929.7), unconst_f16(2842.5))))); |
| vf81 *= bitcast<u32>(override7); |
| return out; |
| _ = override9; |
| _ = override7; |
| _ = override5; |
| _ = override3; |
| } |
| |
| /* used global variables: et2 */ |
| @fragment |
| fn fragment1() -> FragmentOutput1 { |
| var out: FragmentOutput1; |
| out.f1 = vec4f(f32(dot(vec4u(unconst_u32(239), unconst_u32(643), unconst_u32(124), unconst_u32(9)), bitcast<vec4u>(radians(vec2f(unconst_f32(0.2252), unconst_f32(0.07049))).grgg)))); |
| out.f1 = vec4f(extractBits(vec4i(unconst_i32(23), unconst_i32(197), unconst_i32(4), unconst_i32(24)), countTrailingZeros(vec3u(sin(vec3f(unconst_f32(0.5545), unconst_f32(0.05370), unconst_f32(0.03692))))[2]), unconst_u32(48))); |
| var vf82: u32 = dot(vec4u(unconst_u32(304), unconst_u32(92), unconst_u32(118), unconst_u32(117)), vec4u(unconst_u32(91), unconst_u32(30), unconst_u32(63), unconst_u32(84))); |
| vf82 = textureDimensions(et2)[1]; |
| var vf83: vec4h = exp2(vec4h(unconst_f16(3165.6), unconst_f16(11263.0), unconst_f16(733.2), unconst_f16(18435.6))); |
| var vf84: u32 = override3; |
| { |
| out.f1 = vec4f(f32(override2)); |
| out.f0 ^= vec2i(i32(distance(vec2f(unconst_f32(0.04109), unconst_f32(-0.3371)), vec2f(unconst_f32(0.09276), unconst_f32(0.1869))))); |
| var vf85: vec3f = cos(ceil(vec4f(unconst_f32(0.1155), unconst_f32(0.02175), unconst_f32(0.1143), unconst_f32(0.1845))).aar); |
| while any(unconst_bool(false)) { |
| out.f0 = vec2i(i32(acos(unconst_f32(0.4501)))); |
| out = FragmentOutput1((vec3i(atan2(vec4f(unconst_f32(0.1345), unconst_f32(0.09332), unconst_f32(0.3777), unconst_f32(0.2953)), vec4f(unconst_f32(0.02535), unconst_f32(-0.2176), unconst_f32(0.1725), unconst_f32(0.01457))).yzx) ^ vec3i(unconst_i32(16), unconst_i32(83), unconst_i32(352))).zy, bitcast<vec4f>((vec3i(atan2(vec4f(unconst_f32(0.1345), unconst_f32(0.09332), unconst_f32(0.3777), unconst_f32(0.2953)), vec4f(unconst_f32(0.02535), unconst_f32(-0.2176), unconst_f32(0.1725), unconst_f32(0.01457))).yzx) ^ vec3i(unconst_i32(16), unconst_i32(83), unconst_i32(352))).yzxz)); |
| var vf86: u32 = (unconst_u32(123) << unconst_u32(127)); |
| var vf87: vec2f = unpack2x16snorm(unconst_u32(33)); |
| } |
| let vf88: vec4h = asinh(vec4h(unconst_f16(39729.2), unconst_f16(12453.3), unconst_f16(24711.8), unconst_f16(463.7))); |
| out.f1 *= vec4f(f32(any(bool(override3)))); |
| _ = override3; |
| _ = override2; |
| } |
| return out; |
| _ = override2; |
| _ = override3; |
| _ = et2; |
| }`, |
| }); |
| let textureView108 = texture53.createView({label: '\u0f26\u0572\u{1f6e5}', baseArrayLayer: 6, arrayLayerCount: 4}); |
| let renderPassEncoder36 = commandEncoder122.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView104, |
| clearValue: { r: 340.2, g: -754.1, b: -32.70, a: 480.5, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| }); |
| let sampler77 = device0.createSampler({addressModeU: 'repeat', addressModeW: 'repeat', minFilter: 'nearest', lodMaxClamp: 90.48}); |
| try { |
| computePassEncoder2.end(); |
| } catch {} |
| try { |
| renderPassEncoder21.setBindGroup(3, bindGroup37); |
| } catch {} |
| try { |
| renderPassEncoder10.setBindGroup(0, bindGroup47, new Uint32Array(5050), 106, 0); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let texture106 = device0.createTexture({ |
| size: [102], |
| sampleCount: 1, |
| dimension: '1d', |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler78 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| lodMaxClamp: 93.83, |
| }); |
| try { |
| computePassEncoder74.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder19.setBindGroup(1, bindGroup49); |
| } catch {} |
| try { |
| renderPassEncoder22.setViewport(43.035345846069795, 73.22579401409813, 4.959662264894595, 48.28580009592271, 0.18929043431574333, 0.643598533967332); |
| } catch {} |
| try { |
| commandEncoder2.resolveQuerySet(querySet4, 58, 116, buffer0, 0); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 96, height: 1820, depthOrArrayLayers: 296} |
| */ |
| { |
| source: canvas2, |
| origin: { x: 113, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture12, |
| mipLevel: 0, |
| origin: {x: 0, y: 35, z: 42}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 28, height: 19, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup50 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout12, |
| entries: [{binding: 51, resource: {buffer: buffer42, offset: 4096, size: 144}}], |
| }); |
| let commandBuffer8 = commandEncoder2.finish(); |
| let textureView109 = texture24.createView({dimension: '2d-array', mipLevelCount: 1}); |
| try { |
| computePassEncoder76.setBindGroup(2, bindGroup23); |
| } catch {} |
| try { |
| computePassEncoder80.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder7.executeBundles([renderBundle10]); |
| } catch {} |
| try { |
| buffer48.unmap(); |
| } catch {} |
| let buffer55 = device0.createBuffer({ |
| size: 3989, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, |
| }); |
| let querySet7 = device0.createQuerySet({type: 'timestamp', count: 67}); |
| let computePassEncoder99 = commandEncoder124.beginComputePass({}); |
| try { |
| computePassEncoder39.setBindGroup(1, bindGroup14); |
| } catch {} |
| try { |
| computePassEncoder55.setBindGroup(1, bindGroup8, new Uint32Array(690), 85, 0); |
| } catch {} |
| try { |
| computePassEncoder58.setPipeline(pipeline1); |
| } catch {} |
| try { |
| computePassEncoder82.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder14.setBindGroup(0, bindGroup32); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer7, commandBuffer8]); |
| } catch {} |
| let bindGroup51 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout1, |
| entries: [ |
| {binding: 47, resource: {buffer: buffer23, offset: 4352, size: 2116}}, |
| {binding: 131, resource: externalTexture3}, |
| {binding: 59, resource: externalTexture3}, |
| {binding: 44, resource: externalTexture2}, |
| {binding: 19, resource: externalTexture6}, |
| ], |
| }); |
| let buffer56 = device0.createBuffer({ |
| size: 7321, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| mappedAtCreation: false, |
| }); |
| let texture107 = device0.createTexture({ |
| size: {width: 48, height: 910, depthOrArrayLayers: 1}, |
| format: 'rgba8unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView110 = texture107.createView({dimension: '2d-array'}); |
| try { |
| computePassEncoder90.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder34.setScissorRect(105, 5, 1053, 8); |
| } catch {} |
| try { |
| renderPassEncoder36.setIndexBuffer(buffer24, 'uint32', 76, 13); |
| } catch {} |
| try { |
| buffer45.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture92, |
| mipLevel: 0, |
| origin: {x: 49, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(16).fill(247), /* required buffer size: 16 */ |
| {offset: 16}, {width: 283, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup52 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout2, |
| entries: [ |
| {binding: 59, resource: externalTexture10}, |
| {binding: 44, resource: externalTexture3}, |
| {binding: 131, resource: externalTexture6}, |
| {binding: 47, resource: {buffer: buffer28, offset: 512, size: 8308}}, |
| {binding: 19, resource: externalTexture4}, |
| ], |
| }); |
| let commandEncoder128 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder14.setBindGroup(1, bindGroup17, [0]); |
| } catch {} |
| try { |
| computePassEncoder36.setBindGroup(2, bindGroup39, new Uint32Array(3010), 73, 0); |
| } catch {} |
| try { |
| computePassEncoder92.setPipeline(pipeline2); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| let promise22 = device0.queue.onSubmittedWorkDone(); |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 700, height: 4, depthOrArrayLayers: 71} |
| */ |
| { |
| source: videoFrame3, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture100, |
| mipLevel: 0, |
| origin: {x: 49, y: 1, z: 3}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline5 = await device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| fragment: { |
| module: shaderModule3, |
| constants: {56_084: 1}, |
| targets: [{ |
| format: 'rgba8unorm-srgb', |
| blend: { |
| color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'}, |
| alpha: {operation: 'add', srcFactor: 'dst', dstFactor: 'constant'}, |
| }, |
| writeMask: 0, |
| }], |
| }, |
| vertex: { |
| module: shaderModule0, |
| buffers: [ |
| { |
| arrayStride: 88, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'float16x4', offset: 4, shaderLocation: 2}, |
| {format: 'sint32x2', offset: 0, shaderLocation: 5}, |
| {format: 'sint32x4', offset: 8, shaderLocation: 11}, |
| {format: 'sint32x4', offset: 0, shaderLocation: 3}, |
| {format: 'float32x2', offset: 8, shaderLocation: 1}, |
| {format: 'snorm8x2', offset: 2, shaderLocation: 4}, |
| {format: 'unorm8x4', offset: 32, shaderLocation: 9}, |
| {format: 'float32', offset: 28, shaderLocation: 14}, |
| ], |
| }, |
| ], |
| }, |
| }); |
| let commandEncoder129 = device0.createCommandEncoder(); |
| let texture108 = device0.createTexture({ |
| size: [8, 8, 769], |
| dimension: '3d', |
| format: 'rg32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView111 = texture98.createView({baseArrayLayer: 0}); |
| let renderPassEncoder37 = commandEncoder129.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView104, |
| clearValue: { r: 953.8, g: -17.29, b: -37.44, a: -959.3, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet2, |
| maxDrawCount: 222607638, |
| }); |
| let sampler79 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 97.86, |
| }); |
| try { |
| computePassEncoder95.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder4.setIndexBuffer(buffer30, 'uint16', 316, 58); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| document.body.prepend(canvas1); |
| let texture109 = device0.createTexture({ |
| label: '\uacb9\u0ab1\u0662', |
| size: {width: 1400}, |
| dimension: '1d', |
| format: 'r32sint', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView112 = texture26.createView({}); |
| let computePassEncoder100 = commandEncoder128.beginComputePass({}); |
| try { |
| buffer54.unmap(); |
| } catch {} |
| try { |
| await buffer39.mapAsync(GPUMapMode.WRITE, 0, 0); |
| } catch {} |
| let pipeline6 = await device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| fragment: {module: shaderModule2, constants: {}, targets: [{format: 'rgba8uint', writeMask: 0}]}, |
| vertex: { |
| module: shaderModule3, |
| entryPoint: 'vertex3', |
| constants: {27_645: 1}, |
| buffers: [{arrayStride: 1032, attributes: [{format: 'unorm16x2', offset: 20, shaderLocation: 14}]}], |
| }, |
| primitive: {topology: 'line-strip', stripIndexFormat: 'uint16', frontFace: 'cw', unclippedDepth: true}, |
| }); |
| let bindGroup53 = device0.createBindGroup({layout: veryExplicitBindGroupLayout6, entries: [{binding: 41, resource: textureView77}]}); |
| let buffer57 = device0.createBuffer({size: 13553, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM}); |
| let textureView113 = texture14.createView({baseMipLevel: 0}); |
| try { |
| computePassEncoder8.end(); |
| } catch {} |
| try { |
| computePassEncoder96.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder21.executeBundles([renderBundle6]); |
| } catch {} |
| try { |
| commandEncoder9.copyBufferToTexture({ |
| /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 888 */ |
| offset: 888, |
| bytesPerRow: 4608, |
| buffer: buffer18, |
| }, { |
| texture: texture14, |
| mipLevel: 0, |
| origin: {x: 14, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder9.copyTextureToTexture({ |
| texture: texture51, |
| mipLevel: 1, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture54, |
| mipLevel: 0, |
| origin: {x: 357, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer33, 1900, new Int16Array(12591), 487, 688); |
| } catch {} |
| let promise23 = device0.queue.onSubmittedWorkDone(); |
| try { |
| if (!arrayBuffer7.detached) { new Uint8Array(arrayBuffer7).fill(0x55); }; |
| } catch {} |
| document.body.prepend(canvas2); |
| let imageData12 = new ImageData(64, 4); |
| let commandEncoder130 = device0.createCommandEncoder({}); |
| let texture110 = device0.createTexture({ |
| size: [2800, 17, 1], |
| mipLevelCount: 5, |
| format: 'rgba8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderBundleEncoder18 = device0.createRenderBundleEncoder({colorFormats: ['rgba8uint'], depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| computePassEncoder36.setBindGroup(0, bindGroup5, new Uint32Array(1506), 4, 0); |
| } catch {} |
| try { |
| renderPassEncoder13.setIndexBuffer(buffer0, 'uint16', 856, 717); |
| } catch {} |
| try { |
| renderBundleEncoder18.setBindGroup(0, bindGroup48); |
| } catch {} |
| try { |
| renderBundleEncoder18.setIndexBuffer(buffer10, 'uint16', 2_146, 1_453); |
| } catch {} |
| let arrayBuffer12 = buffer6.getMappedRange(4496, 48); |
| try { |
| commandEncoder9.resolveQuerySet(querySet6, 21, 1, buffer54, 0); |
| } catch {} |
| let commandBuffer9 = commandEncoder130.finish(); |
| let textureView114 = texture38.createView({dimension: 'cube', aspect: 'all', mipLevelCount: 1, baseArrayLayer: 1}); |
| let computePassEncoder101 = commandEncoder9.beginComputePass({timestampWrites: {querySet: querySet7, endOfPassWriteIndex: 34}}); |
| try { |
| computePassEncoder29.setBindGroup(1, bindGroup9); |
| } catch {} |
| try { |
| renderPassEncoder24.setIndexBuffer(buffer10, 'uint32', 676, 166); |
| } catch {} |
| try { |
| renderBundleEncoder18.setIndexBuffer(buffer55, 'uint32', 596, 0); |
| } catch {} |
| try { |
| renderBundleEncoder18.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderBundleEncoder18.setVertexBuffer(6, buffer21); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer9]); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer18, 100, new DataView(new ArrayBuffer(5752)), 408, 792); |
| } catch {} |
| let renderBundle18 = renderBundleEncoder18.finish({}); |
| try { |
| computePassEncoder30.setBindGroup(1, bindGroup4, new Uint32Array(1919), 252, 0); |
| } catch {} |
| try { |
| renderPassEncoder21.setBindGroup(2, bindGroup13, new Uint32Array(2373), 205, 1); |
| } catch {} |
| try { |
| renderPassEncoder32.setViewport(600.323844342656, 2.2154238840061904, 414.90692297785586, 1.1067093232809613, 0.2739671962019866, 0.50806569246114); |
| } catch {} |
| try { |
| renderPassEncoder29.setVertexBuffer(7, buffer33, 1_036, 1_391); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({device: device0, format: 'rgba8unorm', usage: GPUTextureUsage.RENDER_ATTACHMENT, alphaMode: 'opaque'}); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let bindGroup54 = device0.createBindGroup({layout: veryExplicitBindGroupLayout10, entries: []}); |
| let buffer58 = device0.createBuffer({ |
| size: 1579, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM, |
| }); |
| let texture111 = device0.createTexture({ |
| size: [12, 1, 60], |
| dimension: '3d', |
| format: 'rgba8unorm-srgb', |
| usage: GPUTextureUsage.COPY_SRC, |
| viewFormats: [], |
| }); |
| let textureView115 = texture41.createView({label: '\u{1fa5b}\u6a15\u{1ff36}\u445b\u4f9f\u9bda\u6e25\u{1fc95}\ue313'}); |
| try { |
| computePassEncoder30.setBindGroup(0, bindGroup45, new Uint32Array(4807), 90, 0); |
| } catch {} |
| try { |
| computePassEncoder65.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder33.executeBundles([renderBundle7]); |
| } catch {} |
| try { |
| renderPassEncoder4.insertDebugMarker('\u74af'); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| let commandEncoder131 = device0.createCommandEncoder({}); |
| let texture112 = device0.createTexture({ |
| size: {width: 8, height: 8, depthOrArrayLayers: 31}, |
| dimension: '3d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder102 = commandEncoder131.beginComputePass(); |
| try { |
| computePassEncoder30.setBindGroup(0, bindGroup41, new Uint32Array(1081), 112, 0); |
| } catch {} |
| try { |
| computePassEncoder72.end(); |
| } catch {} |
| try { |
| renderPassEncoder11.setIndexBuffer(buffer49, 'uint32', 1_432, 199); |
| } catch {} |
| try { |
| renderPassEncoder35.setVertexBuffer(2, buffer47, 248, 15); |
| } catch {} |
| try { |
| buffer8.unmap(); |
| } catch {} |
| let bindGroup55 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [ |
| {binding: 131, resource: externalTexture7}, |
| {binding: 47, resource: {buffer: buffer53, offset: 256, size: 1244}}, |
| {binding: 44, resource: externalTexture4}, |
| {binding: 19, resource: externalTexture3}, |
| {binding: 59, resource: externalTexture7}, |
| ], |
| }); |
| let textureView116 = texture65.createView({label: '\u0e4b\u53b2\u6ca5\u0208', format: 'rgb10a2uint', arrayLayerCount: 1}); |
| let computePassEncoder103 = commandEncoder93.beginComputePass({}); |
| let renderBundleEncoder19 = device0.createRenderBundleEncoder({colorFormats: ['rgba8unorm-srgb'], stencilReadOnly: true}); |
| let sampler80 = device0.createSampler({addressModeU: 'repeat', lodMaxClamp: 98.70, maxAnisotropy: 1}); |
| try { |
| computePassEncoder70.setBindGroup(0, bindGroup4, new Uint32Array(945), 37, 0); |
| } catch {} |
| try { |
| renderPassEncoder21.setIndexBuffer(buffer29, 'uint16', 3_820, 762); |
| } catch {} |
| try { |
| renderBundleEncoder19.setBindGroup(1, bindGroup45); |
| } catch {} |
| try { |
| renderBundleEncoder19.setIndexBuffer(buffer50, 'uint32', 8_112, 3_505); |
| } catch {} |
| let pipeline7 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule2, entryPoint: 'compute2', constants: {}}}); |
| let bindGroup56 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout1, |
| entries: [ |
| {binding: 19, resource: externalTexture0}, |
| {binding: 47, resource: {buffer: buffer0, offset: 4608, size: 3164}}, |
| {binding: 44, resource: externalTexture7}, |
| {binding: 59, resource: externalTexture11}, |
| {binding: 131, resource: externalTexture3}, |
| ], |
| }); |
| let commandEncoder132 = device0.createCommandEncoder(); |
| let textureView117 = texture106.createView({dimension: '1d'}); |
| try { |
| computePassEncoder101.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderBundleEncoder19.setVertexBuffer(4, buffer54, 0, 30); |
| } catch {} |
| try { |
| buffer55.unmap(); |
| } catch {} |
| try { |
| commandEncoder132.copyTextureToTexture({ |
| texture: texture80, |
| mipLevel: 0, |
| origin: {x: 33, y: 0, z: 30}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture44, |
| mipLevel: 0, |
| origin: {x: 124, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 7, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let computePassEncoder104 = commandEncoder132.beginComputePass(); |
| let renderBundle19 = renderBundleEncoder19.finish({}); |
| try { |
| computePassEncoder6.setBindGroup(2, bindGroup17, [512]); |
| } catch {} |
| try { |
| computePassEncoder100.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderPassEncoder37.setBlendConstant({ r: 526.2, g: 740.1, b: -839.5, a: 680.8, }); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| document.body.append(canvas2); |
| let commandEncoder133 = device0.createCommandEncoder({label: '\u450e\u{1fc12}'}); |
| let shaderModule4 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| enable f16; |
| |
| requires unrestricted_pointer_parameters; |
| |
| override override16: f32; |
| |
| /* zero global variables used */ |
| fn fn0(a0: mat2x4h) -> VertexOutput1 { |
| var out: VertexOutput1; |
| for (var it3=override19; it3<pack4x8unorm(vec4f(unconst_f32(0.1511), unconst_f32(0.2280), unconst_f32(0.06641), unconst_f32(0.05694))); it3++) { |
| let vf89: vec2i = firstTrailingBit(vec2i(i32(pack4xU8Clamp(vec4u(unconst_u32(127), unconst_u32(276), unconst_u32(229), unconst_u32(174)))))); |
| let vf90: vec4<bool> = (vec4u(unconst_u32(416), unconst_u32(503), unconst_u32(511), unconst_u32(9)) >= vec4u(unconst_u32(111), unconst_u32(140), unconst_u32(26), unconst_u32(214))); |
| let vf91: u32 = override13; |
| break; |
| _ = override13; |
| } |
| let vf92: u32 = pack2x16float(vec2f(unconst_f32(0.1240), unconst_f32(0.04453))); |
| var vf93: mat3x4h = (unconst_f16(16502.3) * mat3x4h()); |
| out.f4 -= vec2h((vec2u(unconst_u32(141), unconst_u32(82)) ^ vec2u(unconst_u32(333), unconst_u32(55)))); |
| if bool(sign(vec4h(unconst_f16(7621.3), unconst_f16(181.2), unconst_f16(-6469.5), unconst_f16(9187.3))).x) { |
| let vf94: vec2h = acos(vec2h(unconst_f16(223.3), unconst_f16(8434.6))); |
| out.f9 &= vec3u(round(vec3f(unconst_f32(0.00213), unconst_f32(-0.03865), unconst_f32(-0.3377)))).g; |
| var vf95: vec4i = firstTrailingBit(vec4i(unconst_i32(358), unconst_i32(608), unconst_i32(105), unconst_i32(487))); |
| var vf96: vec2h = degrees(vec2h(unconst_f16(10756.7), unconst_f16(3329.9))); |
| var vf97: vec4<bool> = (vec4<bool>(unconst_bool(true), unconst_bool(false), unconst_bool(true), unconst_bool(false)) | vec4<bool>(bool(override19))); |
| let vf98: u32 = pack2x16snorm(vec2f(unconst_f32(0.00201), unconst_f32(0.5478))); |
| _ = override19; |
| } |
| out.f17 = unpack4x8unorm(vf92); |
| var vf99: vec4h = sign(vec4h(unconst_f16(5579.2), unconst_f16(25460.6), unconst_f16(6474.4), unconst_f16(23636.5))); |
| var vf100: vec3h = cosh(vec3h((vec2i(unconst_i32(3), unconst_i32(111)) | vec2i(unconst_i32(10), unconst_i32(388))).ggr)); |
| let vf101: f16 = max(vf93[unconst_i32(0)][1], unconst_f16(3345.9)); |
| loop { |
| out.f9 ^= pack4xU8(countOneBits(vec4u(unconst_u32(136), unconst_u32(152), unconst_u32(216), unconst_u32(112)))); |
| out.f9 = u32((unconst_i32(5) >> vec4u(a0[unconst_i32(1)])[1])); |
| break; |
| } |
| var vf102: i32 = dot4I8Packed(unconst_u32(231), unconst_u32(86)); |
| var vf103: vec3<bool> = (vec3<bool>(unconst_bool(true), unconst_bool(true), unconst_bool(false)) & vec3<bool>(unconst_bool(false), unconst_bool(true), unconst_bool(false))); |
| let vf104: f16 = vf93[unconst_u32(134)][unconst_u32(430)]; |
| return out; |
| _ = override13; |
| _ = override19; |
| } |
| |
| /* zero global variables used */ |
| fn fn3() -> T1 { |
| var out: T1; |
| out.f0[unconst_u32(154)][unconst_u32(107)][unconst_u32(488)][unconst_u32(84)] -= vec4i(i32(override18)); |
| _ = fn0(mat2x4h(bitcast<vec4h>((vec2i(unconst_i32(142), unconst_i32(9)) & vec2i(unconst_i32(91), unconst_i32(233)))), bitcast<vec4h>((vec2i(unconst_i32(142), unconst_i32(9)) & vec2i(unconst_i32(91), unconst_i32(233)))))); |
| if bool(cosh(vec4f(unconst_f32(-0.1274), unconst_f32(0.2837), unconst_f32(0.2738), unconst_f32(0.00219))).z) { |
| var vf117 = fn0(mat2x4h(vec4h( ~vec3u(unconst_u32(74), unconst_u32(98), unconst_u32(17)).xyzx), vec4h( ~vec3u(unconst_u32(74), unconst_u32(98), unconst_u32(17)).zxyz))); |
| let ptr16: ptr<function, vec4f> = &vf117.f17; |
| let ptr17: ptr<function, f16> = &vf117.f10; |
| fn1(); |
| _ = override17; |
| _ = override19; |
| _ = override13; |
| } |
| let vf118: vec4h = sqrt(vec4h(unconst_f16(16092.3), unconst_f16(35340.1), unconst_f16(1156.3), unconst_f16(40965.0))); |
| _ = fn2(); |
| { |
| out.f0[unconst_u32(25)][unconst_u32(225)][unconst_u32(121)][unconst_u32(94)] = bitcast<vec4i>(unpack2x16float(unconst_u32(223)).yyxx); |
| out = T1(array<array<array<array<vec4i, 1>, 1>, 1>, 1>(array<array<array<vec4i, 1>, 1>, 1>(array<array<vec4i, 1>, 1>(array<vec4i, 1>(vec4i((vec3i(unconst_i32(-850), unconst_i32(47), unconst_i32(61)) < vec3i(i32(override19))).grbb)))))); |
| out.f0[unconst_u32(912)][unconst_u32(235)][unconst_u32(128)][0] &= unpack4xI8(pack4x8unorm(vec4f(unconst_f32(0.1257), unconst_f32(0.1473), unconst_f32(0.04484), unconst_f32(0.1394)))); |
| fn0(mat2x4h(vec4h(extractBits(vec4u(unconst_u32(897), unconst_u32(137), unconst_u32(129), unconst_u32(354)), unconst_u32(563), unconst_u32(137))), vec4h(extractBits(vec4u(unconst_u32(897), unconst_u32(137), unconst_u32(129), unconst_u32(354)), unconst_u32(563), unconst_u32(137))))); |
| _ = override19; |
| _ = override13; |
| } |
| out.f0[unconst_u32(78)][unconst_u32(47)][unconst_u32(167)][unconst_u32(177)] ^= unpack4xI8((unconst_u32(86) >> unconst_u32(161))); |
| out.f0[unconst_u32(232)][unconst_u32(402)][unconst_u32(79)][unconst_u32(65)] *= vec4i(vf118); |
| var vf119: vec2f = unpack2x16snorm(bitcast<u32>(min(bitcast<vec2i>(sqrt(vec4f(unconst_f32(0.1390), unconst_f32(-0.08291), unconst_f32(0.1579), unconst_f32(0.01972))).yz), vec2i(unconst_i32(216), unconst_i32(504))).g)); |
| var vf120 = fn2(); |
| out.f0[unconst_u32(62)][unconst_u32(213)][unconst_u32(379)][u32(override16)] ^= vec4i(i32(override16)); |
| let ptr18: ptr<function, vec2f> = &vf119; |
| return out; |
| _ = override13; |
| _ = override16; |
| _ = override17; |
| _ = override19; |
| _ = override14; |
| _ = override18; |
| } |
| |
| override override17: u32; |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| @id(59101) override override15: f32; |
| |
| /* zero global variables used */ |
| @must_use |
| fn fn5(a0: ptr<function, array<array<mat2x2f, 1>, 1>>, a1: T1) -> array<mat4x2h, 1> { |
| var out: array<mat4x2h, 1>; |
| var vf126: vec4i = a1.f0[0][unconst_u32(47)][unconst_u32(28)][0]; |
| var vf127: f32 = (*a0)[unconst_u32(59)][0][unconst_u32(158)][unconst_u32(38)]; |
| var vf128: i32 = a1.f0[unconst_u32(103)][0][0][unconst_u32(146)][unconst_u32(781)]; |
| (*a0)[0][unconst_u32(89)] = mat2x2f(bitcast<f32>(a1.f0[unconst_u32(17)][0][unconst_u32(247)][0][unconst_u32(67)]), f32(a1.f0[unconst_u32(17)][0][unconst_u32(247)][0][unconst_u32(67)]), f32(a1.f0[unconst_u32(17)][0][unconst_u32(247)][0][unconst_u32(67)]), f32(a1.f0[unconst_u32(17)][0][unconst_u32(247)][0][unconst_u32(67)])); |
| let vf129: vec4i = a1.f0[unconst_u32(175)][0][0][unconst_u32(11)]; |
| let ptr20: ptr<function, mat2x2f> = &(*a0)[0][unconst_u32(34)]; |
| let vf130: array<vec4i, 1> = a1.f0[0][unconst_u32(221)][0]; |
| return out; |
| } |
| |
| /* zero global variables used */ |
| fn fn1() { |
| var vf105 = fn0(mat2x4h(atan2(vec4h(unconst_f16(20775.5), unconst_f16(1529.3), unconst_f16(10225.3), unconst_f16(332.1)), vec4h(unconst_f16(5003.3), unconst_f16(5315.4), unconst_f16(2097.3), unconst_f16(8582.0))), atan2(vec4h(unconst_f16(20775.5), unconst_f16(1529.3), unconst_f16(10225.3), unconst_f16(332.1)), vec4h(unconst_f16(5003.3), unconst_f16(5315.4), unconst_f16(2097.3), unconst_f16(8582.0))))); |
| fn0(mat2x4h(vec4h(fract(vec3f(atan(vec4h(unconst_f16(9736.9), unconst_f16(37310.5), unconst_f16(8793.5), unconst_f16(17347.6))).xyy)).gbgr), vec4h(fract(vec3f(atan(vec4h(unconst_f16(9736.9), unconst_f16(37310.5), unconst_f16(8793.5), unconst_f16(17347.6))).xyy)).grrb))); |
| let vf106: f32 = vf105.f8[unconst_u32(102)]; |
| var vf107: f32 = vf105.f15[unconst_u32(53)]; |
| vf107 *= bitcast<f32>(vf105.f4); |
| let vf108: i32 = vf105.f7[unconst_u32(37)]; |
| loop { |
| var vf109 = fn0(mat2x4h(pow(vec4h(unconst_f16(7474.0), unconst_f16(-4725.5), unconst_f16(37598.0), unconst_f16(-10030.3)), vec4h(unconst_f16(37775.7), unconst_f16(6492.0), unconst_f16(-1421.2), unconst_f16(7707.9))), pow(vec4h(unconst_f16(7474.0), unconst_f16(-4725.5), unconst_f16(37598.0), unconst_f16(-10030.3)), vec4h(unconst_f16(37775.7), unconst_f16(6492.0), unconst_f16(-1421.2), unconst_f16(7707.9))))); |
| vf109 = VertexOutput1(vec2h(step(vec2f(unconst_f32(0.5439), unconst_f32(0.02259)), vec2f(unconst_f32(0.2149), unconst_f32(0.07371)))), i32(step(vec2f(unconst_f32(0.5439), unconst_f32(0.02259)), vec2f(unconst_f32(0.2149), unconst_f32(0.07371)))[1]), pack2x16float(step(vec2f(unconst_f32(0.5439), unconst_f32(0.02259)), vec2f(unconst_f32(0.2149), unconst_f32(0.07371)))), vec2i(step(vec2f(unconst_f32(0.5439), unconst_f32(0.02259)), vec2f(unconst_f32(0.2149), unconst_f32(0.07371)))), step(vec2f(unconst_f32(0.5439), unconst_f32(0.02259)), vec2f(unconst_f32(0.2149), unconst_f32(0.07371))), pack2x16snorm(step(vec2f(unconst_f32(0.5439), unconst_f32(0.02259)), vec2f(unconst_f32(0.2149), unconst_f32(0.07371)))), f16(step(vec2f(unconst_f32(0.5439), unconst_f32(0.02259)), vec2f(unconst_f32(0.2149), unconst_f32(0.07371))).y), step(vec2f(unconst_f32(0.5439), unconst_f32(0.02259)), vec2f(unconst_f32(0.2149), unconst_f32(0.07371))), bitcast<vec4i>(step(vec2f(unconst_f32(0.5439), unconst_f32(0.02259)), vec2f(unconst_f32(0.2149), unconst_f32(0.07371))).xxxy), bitcast<vec2i>(step(vec2f(unconst_f32(0.5439), unconst_f32(0.02259)), vec2f(unconst_f32(0.2149), unconst_f32(0.07371)))), step(vec2f(unconst_f32(0.5439), unconst_f32(0.02259)), vec2f(unconst_f32(0.2149), unconst_f32(0.07371))).yyyx, step(vec2f(unconst_f32(0.5439), unconst_f32(0.02259)), vec2f(unconst_f32(0.2149), unconst_f32(0.07371))).ggrg, vec2i(step(vec2f(unconst_f32(0.5439), unconst_f32(0.02259)), vec2f(unconst_f32(0.2149), unconst_f32(0.07371)))), step(vec2f(unconst_f32(0.5439), unconst_f32(0.02259)), vec2f(unconst_f32(0.2149), unconst_f32(0.07371))).yyxy, vec2i(step(vec2f(unconst_f32(0.5439), unconst_f32(0.02259)), vec2f(unconst_f32(0.2149), unconst_f32(0.07371)))).g); |
| break; |
| _ = override19; |
| _ = override13; |
| } |
| for (var it4=bitcast<vec2u>(firstLeadingBit(vec2i(unconst_i32(255), unconst_i32(172))))[0]; it4<u32(any((vec2f(vf105.f11[unconst_u32(76)]) == vec2f(vf105.f12.bb)))); it4++) { |
| if bool(pack4x8unorm(vec4f(unconst_f32(0.1382), unconst_f32(0.1961), unconst_f32(0.06345), unconst_f32(-0.5391)))) { |
| fn0(mat2x4h(f16(atan(unconst_f32(0.1606))), f16(atan(unconst_f32(0.1606))), f16(atan(unconst_f32(0.1606))), f16(atan(unconst_f32(0.1606))), f16(atan(unconst_f32(0.1606))), f16(atan(unconst_f32(0.1606))), f16(atan(unconst_f32(0.1606))), f16(atan(unconst_f32(0.1606))))); |
| _ = override19; |
| _ = override13; |
| } |
| fn0(mat2x4h(bitcast<vec4h>(unpack2x16float(unconst_u32(60))), bitcast<vec4h>(unpack2x16float(unconst_u32(60))))); |
| let vf110: vec2h = faceForward(vec2h(unconst_f16(4063.6), unconst_f16(1300.9)), bitcast<vec2h>(pack4xU8(vec4u(unconst_u32(33), unconst_u32(509), unconst_u32(36), unconst_u32(111)))), vec2h(unconst_f16(1397.4), unconst_f16(4363.1))); |
| var vf111: vec4h = max(vec4h(unconst_f16(30289.1), unconst_f16(15184.1), unconst_f16(3345.9), unconst_f16(31852.3)), vec4h(unconst_f16(5729.4), unconst_f16(7243.9), unconst_f16(23.80), unconst_f16(7687.3))); |
| vf111 = bitcast<vec4h>(unpack2x16float(unconst_u32(104))); |
| var vf112 = fn0(mat2x4h(saturate(unconst_f16(1699.6)), saturate(unconst_f16(1699.6)), saturate(unconst_f16(1699.6)), saturate(unconst_f16(1699.6)), saturate(unconst_f16(1699.6)), saturate(unconst_f16(1699.6)), saturate(unconst_f16(1699.6)), saturate(unconst_f16(1699.6)))); |
| vf112 = VertexOutput1(fract(vec2h(vf112.f7)), bitcast<i32>(fract(vec2h(vf112.f7))), bitcast<u32>(fract(vec2h(vf112.f7))), vec2i(fract(vec2h(vf112.f7))), vec2f(fract(vec2h(vf112.f7))), bitcast<u32>(fract(vec2h(vf112.f7))), fract(vec2h(vf112.f7))[1], vec2f(fract(vec2h(vf112.f7))), vec4i(fract(vec2h(vf112.f7)).grgg), vec2i(fract(vec2h(vf112.f7))), vec4f(fract(vec2h(vf112.f7)).grrg), vec4f(fract(vec2h(vf112.f7)).xxyx), vec2i(fract(vec2h(vf112.f7))), vec4f(fract(vec2h(vf112.f7)).grgg), bitcast<i32>(fract(vec2h(vf112.f7)))); |
| break; |
| _ = override19; |
| _ = override13; |
| } |
| var vf113: f16 = atanh(unconst_f16(-14490.5)); |
| fn0(mat2x4h(f16((unconst_bool(false) && unconst_bool(false))), f16((unconst_bool(false) && unconst_bool(false))), f16((unconst_bool(false) && unconst_bool(false))), f16((unconst_bool(false) && unconst_bool(false))), f16((unconst_bool(false) && unconst_bool(false))), f16((unconst_bool(false) && unconst_bool(false))), f16((unconst_bool(false) && unconst_bool(false))), f16((unconst_bool(false) && unconst_bool(false))))); |
| vf113 += f16(vf105.f14[3]); |
| vf105 = VertexOutput1(bitcast<vec2h>(override17), i32(override17), override17, vec2i(bitcast<i32>(override17)), unpack2x16unorm(override17), override17, f16(override17), vec2f(f32(override17)), unpack4xI8(override17), vec2i(bitcast<i32>(override17)), vec4f(bitcast<f32>(override17)), vec4f(bitcast<f32>(override17)), vec2i(bitcast<i32>(override17)), unpack4x8snorm(override17), bitcast<i32>(override17)); |
| return; |
| _ = override13; |
| _ = override17; |
| _ = override19; |
| } |
| |
| /* zero global variables used */ |
| fn fn4() -> VertexOutput1 { |
| var out: VertexOutput1; |
| _ = fn2(); |
| var vf121: vec4i = unpack4xI8(unconst_u32(86)); |
| var vf122: i32 = vf121[unconst_u32(56)]; |
| fn0(mat2x4h(f16(vf122), f16(vf122), f16(vf122), f16(vf122), f16(vf122), f16(vf122), f16(vf122), f16(vf122))); |
| var vf123 = fn0(mat2x4h(vec4h(countOneBits(vec3i(unconst_i32(29), unconst_i32(-379), unconst_i32(151))).zzzz), vec4h(countOneBits(vec3i(unconst_i32(29), unconst_i32(-379), unconst_i32(151))).zyxx))); |
| let ptr19: ptr<function, vec2f> = &vf123.f8; |
| out.f13 = vf123.f16; |
| var vf124 = fn2(); |
| vf121 = vec4i(vf121[unconst_u32(44)]); |
| out.f15 = vec4f(cos(vec4h(unconst_f16(7449.3), unconst_f16(11447.4), unconst_f16(10900.5), unconst_f16(9449.3)))); |
| var vf125 = fn0(mat2x4h(bitcast<vec4h>(vf123.f13), bitcast<vec4h>(vf123.f13))); |
| out.f11 = vec2f(vf125.f12.zz); |
| return out; |
| _ = override18; |
| _ = override14; |
| _ = override13; |
| _ = override19; |
| } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| @id(17064) override override19: u32 = 171; |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| alias vec3b = vec3<bool>; |
| |
| /* zero global variables used */ |
| fn fn7(a0: ptr<function, mat2x3h>) -> T1 { |
| var out: T1; |
| (*a0) += mat2x3h(vec3h(transpose(mat4x4f())[unconst_i32(1)].wyy), vec3h(transpose(mat4x4f())[unconst_i32(2)].yyw)); |
| return out; |
| } |
| |
| /* zero global variables used */ |
| fn fn8(a0: T1, a1: ptr<private, VertexOutput1>) { |
| let ptr21: ptr<private, f16> = &(*a1).f10; |
| (*a1).f8 = bitcast<vec2f>(a0.f0[unconst_u32(195)][unconst_u32(168)][unconst_u32(51)][0].xw); |
| let vf133: vec4i = a0.f0[unconst_u32(8)][unconst_u32(23)][0][bitcast<u32>((*a1).f18)]; |
| } |
| |
| @id(11106) override override18: u32 = 7; |
| |
| struct VertexOutput1 { |
| @location(10) @interpolate(linear, either) f4: vec2h, |
| @location(14) @interpolate(flat, sample) f5: i32, |
| @location(7) @interpolate(flat, either) f6: u32, |
| @location(1) f7: vec2i, |
| @location(0) @interpolate(perspective, centroid) f8: vec2f, |
| @location(6) @interpolate(flat, sample) f9: u32, |
| @location(9) @interpolate(flat, sample) f10: f16, |
| @location(11) f11: vec2f, |
| @location(5) f12: vec4i, |
| @location(15) f13: vec2i, |
| @location(12) f14: vec4f, |
| @location(13) @interpolate(linear, centroid) f15: vec4f, |
| @location(8) f16: vec2i, |
| @builtin(position) f17: vec4f, |
| @location(4) f18: i32, |
| } |
| |
| @id(17018) override override14 = false; |
| |
| struct T1 { |
| f0: array<array<array<array<vec4i, 1>, 1>, 1>, 1>, |
| } |
| |
| override override13: u32; |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| /* zero global variables used */ |
| fn fn6(a0: VertexOutput1) -> vec2i { |
| var out: vec2i; |
| var vf131 = fn2(); |
| var vf132: i32 = sign(unconst_i32(53)); |
| fn0(mat2x4h(length(unconst_f16(5630.9)), length(unconst_f16(5630.9)), length(unconst_f16(5630.9)), length(unconst_f16(5630.9)), length(unconst_f16(5630.9)), length(unconst_f16(5630.9)), length(unconst_f16(5630.9)), length(unconst_f16(5630.9)))); |
| while bool(a0.f15[unconst_u32(250)]) { |
| out &= vec2i(i32(a0.f9)); |
| } |
| return out; |
| _ = override13; |
| _ = override19; |
| _ = override14; |
| _ = override18; |
| } |
| |
| struct T0 { |
| @align(16) @size(16) f0: array<atomic<u32>, 1>, |
| } |
| |
| /* zero global variables used */ |
| @must_use |
| fn fn2() -> array<mat3x2h, 1> { |
| var out: array<mat3x2h, 1>; |
| out[unconst_u32(66)] = mat3x2h(f16(override14), f16(override14), f16(override14), f16(override14), f16(override14), f16(override14)); |
| out[unconst_u32(639)] = mat3x2h(floor(vec2h(unconst_f16(435.0), unconst_f16(5621.2))), floor(vec2h(unconst_f16(435.0), unconst_f16(5621.2))), floor(vec2h(unconst_f16(435.0), unconst_f16(5621.2)))); |
| out[unconst_u32(157)] = mat3x2h(vec2h((vec2u(unconst_u32(37), unconst_u32(5)) <= vec2u(unconst_u32(111), unconst_u32(182)))), vec2h((vec2u(unconst_u32(37), unconst_u32(5)) <= vec2u(unconst_u32(111), unconst_u32(182)))), vec2h((vec2u(unconst_u32(37), unconst_u32(5)) <= vec2u(unconst_u32(111), unconst_u32(182))))); |
| let vf114: vec2h = saturate(vec2h(unconst_f16(7003.5), unconst_f16(10637.9))); |
| let vf115: u32 = override18; |
| let vf116: vec4h = trunc(vec4h(unconst_f16(9178.8), unconst_f16(16307.0), unconst_f16(4806.2), unconst_f16(38836.2))); |
| return out; |
| _ = override14; |
| _ = override18; |
| } |
| |
| /* zero global variables used */ |
| @vertex |
| fn vertex4(@location(13) a0: vec4i) -> VertexOutput1 { |
| var out: VertexOutput1; |
| out.f8 = ldexp(vec2f(unconst_f32(0.07138), unconst_f32(0.01457)), vec2i(unconst_i32(118), unconst_i32(370))); |
| var vf134: vec4f = unpack4x8unorm(unconst_u32(113)); |
| var vf135: vec4f = unpack4x8unorm(unconst_u32(219)); |
| return out; |
| } |
| |
| /* zero global variables used */ |
| @fragment |
| fn fragment2() -> @location(200) vec4f { |
| var out: vec4f; |
| out += vec4f(override16); |
| var vf136 = fn6(VertexOutput1(bitcast<vec2h>(insertBits(bitcast<i32>(unpack4x8unorm(unconst_u32(143))[0]), unconst_i32(13), unconst_u32(61), unconst_u32(149))), insertBits(bitcast<i32>(unpack4x8unorm(unconst_u32(143))[0]), unconst_i32(13), unconst_u32(61), unconst_u32(149)), u32(insertBits(bitcast<i32>(unpack4x8unorm(unconst_u32(143))[0]), unconst_i32(13), unconst_u32(61), unconst_u32(149))), vec2i(insertBits(bitcast<i32>(unpack4x8unorm(unconst_u32(143))[0]), unconst_i32(13), unconst_u32(61), unconst_u32(149))), vec2f(bitcast<f32>(insertBits(bitcast<i32>(unpack4x8unorm(unconst_u32(143))[0]), unconst_i32(13), unconst_u32(61), unconst_u32(149)))), u32(insertBits(bitcast<i32>(unpack4x8unorm(unconst_u32(143))[0]), unconst_i32(13), unconst_u32(61), unconst_u32(149))), f16(insertBits(bitcast<i32>(unpack4x8unorm(unconst_u32(143))[0]), unconst_i32(13), unconst_u32(61), unconst_u32(149))), vec2f(bitcast<f32>(insertBits(bitcast<i32>(unpack4x8unorm(unconst_u32(143))[0]), unconst_i32(13), unconst_u32(61), unconst_u32(149)))), vec4i(insertBits(bitcast<i32>(unpack4x8unorm(unconst_u32(143))[0]), unconst_i32(13), unconst_u32(61), unconst_u32(149))), vec2i(insertBits(bitcast<i32>(unpack4x8unorm(unconst_u32(143))[0]), unconst_i32(13), unconst_u32(61), unconst_u32(149))), vec4f(bitcast<f32>(insertBits(bitcast<i32>(unpack4x8unorm(unconst_u32(143))[0]), unconst_i32(13), unconst_u32(61), unconst_u32(149)))), vec4f(bitcast<f32>(insertBits(bitcast<i32>(unpack4x8unorm(unconst_u32(143))[0]), unconst_i32(13), unconst_u32(61), unconst_u32(149)))), vec2i(insertBits(bitcast<i32>(unpack4x8unorm(unconst_u32(143))[0]), unconst_i32(13), unconst_u32(61), unconst_u32(149))), vec4f(f32(insertBits(bitcast<i32>(unpack4x8unorm(unconst_u32(143))[0]), unconst_i32(13), unconst_u32(61), unconst_u32(149)))), insertBits(bitcast<i32>(unpack4x8unorm(unconst_u32(143))[0]), unconst_i32(13), unconst_u32(61), unconst_u32(149)))); |
| fn4(); |
| loop { |
| out -= vec4f(cross(vec3h(unconst_f16(10551.0), unconst_f16(6421.7), unconst_f16(29305.3)), vec3h(f16(pack2x16unorm(vec2f(unconst_f32(0.2386), unconst_f32(0.3134)))))).xyxy); |
| break; |
| } |
| if bool(override18) { |
| if bool(unpack2x16unorm(unconst_u32(211))[1]) { |
| var vf137: vec3i = extractBits(vec3i(bitcast<i32>(override17)), unconst_u32(266), unconst_u32(13)); |
| _ = override17; |
| } |
| _ = override17; |
| } |
| var vf138 = fn4(); |
| return out; |
| _ = override19; |
| _ = override16; |
| _ = override17; |
| _ = override13; |
| _ = override18; |
| _ = override14; |
| } |
| |
| /* zero global variables used */ |
| @compute @workgroup_size(4, 1, 1) |
| fn compute3() { |
| let vf139: vec2<bool> = !vec2<bool>(bool(atan2(vec3f((vec3i(unconst_i32(6), unconst_i32(77), unconst_i32(178)) == vec3i(unconst_i32(66), unconst_i32(469), unconst_i32(39)))).g, unconst_f32(0.1253)))); |
| var vf140: vec3i = (vec3i(unconst_i32(166), unconst_i32(33), unconst_i32(3)) ^ vec3i(unconst_i32(14), unconst_i32(175), unconst_i32(135))); |
| let vf141: u32 = override17; |
| var vf142: i32 = firstLeadingBit(unconst_i32(17)); |
| var vf143: u32 = override17; |
| fn1(); |
| let vf144: vec2<bool> = (vec2f(unconst_f32(0.2640), unconst_f32(0.1757)) < vec2f(unconst_f32(0.2598), unconst_f32(0.01920))); |
| vf140 = vec3i((vec4u(unconst_u32(7), unconst_u32(19), unconst_u32(268), unconst_u32(179)) >= unpack4xU8(override19)).bbb); |
| fn1(); |
| vf140 = vec3i(bitcast<i32>(vf141)); |
| _ = fn2(); |
| fn0(mat2x4h(f16(vf141), f16(vf141), f16(vf141), f16(vf141), f16(vf141), f16(vf141), f16(vf141), f16(vf141))); |
| fn0(mat2x4h(smoothstep(unconst_f16(3398.3), unconst_f16(4755.1), unconst_f16(3630.3)), smoothstep(unconst_f16(3398.3), unconst_f16(4755.1), unconst_f16(3630.3)), smoothstep(unconst_f16(3398.3), unconst_f16(4755.1), unconst_f16(3630.3)), smoothstep(unconst_f16(3398.3), unconst_f16(4755.1), unconst_f16(3630.3)), smoothstep(unconst_f16(3398.3), unconst_f16(4755.1), unconst_f16(3630.3)), smoothstep(unconst_f16(3398.3), unconst_f16(4755.1), unconst_f16(3630.3)), smoothstep(unconst_f16(3398.3), unconst_f16(4755.1), unconst_f16(3630.3)), smoothstep(unconst_f16(3398.3), unconst_f16(4755.1), unconst_f16(3630.3)))); |
| _ = override14; |
| _ = override13; |
| _ = override18; |
| _ = override17; |
| _ = override19; |
| }`, |
| }); |
| let bindGroup57 = device0.createBindGroup({ |
| label: '\u0165\ua2d8\ub03d\ubdbe\u{1fbc5}\ucaec', |
| layout: veryExplicitBindGroupLayout20, |
| entries: [ |
| {binding: 52, resource: externalTexture11}, |
| {binding: 141, resource: {buffer: buffer43, offset: 0, size: 112}}, |
| {binding: 110, resource: {buffer: buffer53, offset: 512, size: 752}}, |
| ], |
| }); |
| let pipelineLayout17 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout19]}); |
| let commandEncoder134 = device0.createCommandEncoder(); |
| let texture113 = device0.createTexture({ |
| size: {width: 25, height: 1, depthOrArrayLayers: 1}, |
| format: 'rgba8uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let renderPassEncoder38 = commandEncoder133.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView96, |
| clearValue: { r: 160.1, g: 136.4, b: 542.5, a: 403.7, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet0, |
| timestampWrites: {querySet: querySet6, endOfPassWriteIndex: 42}, |
| maxDrawCount: 93339768, |
| }); |
| let sampler81 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| }); |
| try { |
| renderPassEncoder34.setStencilReference(546); |
| } catch {} |
| let arrayBuffer13 = buffer6.getMappedRange(4464, 0); |
| try { |
| await promise22; |
| } catch {} |
| let bindGroup58 = device0.createBindGroup({layout: veryExplicitBindGroupLayout16, entries: [{binding: 224, resource: externalTexture5}]}); |
| let commandEncoder135 = device0.createCommandEncoder({}); |
| let textureView118 = texture13.createView({}); |
| let texture114 = device0.createTexture({ |
| size: [8, 8, 12], |
| sampleCount: 1, |
| format: 'rgba8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder105 = commandEncoder135.beginComputePass(); |
| let renderPassEncoder39 = commandEncoder134.beginRenderPass({colorAttachments: [{view: textureView92, loadOp: 'load', storeOp: 'store'}]}); |
| try { |
| computePassEncoder82.setBindGroup(1, bindGroup27, new Uint32Array(5104), 80, 0); |
| } catch {} |
| try { |
| await promise20; |
| } catch {} |
| let shaderModule5 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| requires packed_4x8_integer_dot_product; |
| |
| diagnostic(info, xyz); |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| /* zero global variables used */ |
| @must_use |
| fn fn2(a0: FragmentOutput2) -> vec4u { |
| var out: vec4u; |
| if bool(override26) { |
| let vf158: i32 = max(unconst_i32(178), unconst_i32(-19)); |
| let vf159: f32 = smoothstep(unconst_f32(0.00835), cosh(vec4f(bitcast<f32>(override27))).y, unconst_f32(-0.1427)); |
| _ = override27; |
| } |
| let vf160: f16 = sin(unconst_f16(4766.6)); |
| out *= unpack4xU8(u32(sin(unconst_f16(11205.4)))); |
| out <<= unpack4xU8(u32(vf160)); |
| var vf161: bool = all(unconst_bool(false)); |
| let vf162: vec3f = tanh(vec3f(unconst_f32(0.3591), unconst_f32(0.3151), unconst_f32(0.1893))); |
| return out; |
| _ = override26; |
| _ = override27; |
| } |
| |
| override override20: f16; |
| |
| override override21: f16 = 10297.1; |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| @id(11551) override override28: bool; |
| |
| /* zero global variables used */ |
| fn fn1(a0: ptr<uniform, mat3x4h>, a1: u32) -> array<array<FragmentOutput2, 1>, 1> { |
| var out: array<array<FragmentOutput2, 1>, 1>; |
| var vf148: vec4h = exp2(vec4h(unconst_f16(29013.6), unconst_f16(6745.6), unconst_f16(18513.2), unconst_f16(5900.3))); |
| let vf149: i32 = override26; |
| { |
| out[u32(exp(vec4f(unconst_f32(0.01275), unconst_f32(0.08083), unconst_f32(0.02139), unconst_f32(0.2901)))[3])][0].f0 = vec2f(degrees(unconst_f32(0.04541))); |
| if bool(insertBits(vec4u(unconst_u32(75), unconst_u32(66), unconst_u32(7), unconst_u32(234)), vec4u(unconst_u32(104), unconst_u32(13), unconst_u32(132), unconst_u32(143)), u32(fma(unconst_f32(0.1455), unconst_f32(0.00891), unconst_f32(0.2195))), unconst_u32(27))[3]) { |
| var vf150: f16 = override21; |
| var vf151: vec4u = (unconst_u32(569) + vec4u(unconst_u32(180), unconst_u32(137), unconst_u32(212), unconst_u32(361))); |
| _ = override21; |
| } |
| out[unconst_u32(154)][unconst_u32(378)].f2 *= insertBits(vec4u(unconst_u32(124), unconst_u32(128), unconst_u32(167), unconst_u32(2)), vec4u(unconst_u32(467), unconst_u32(170), unconst_u32(2), unconst_u32(426)), unconst_u32(84), unconst_u32(416)); |
| out[unconst_u32(15)][unconst_u32(460)] = FragmentOutput2(vec2f(f32(override28)), u32(override28), vec4u(u32(override28))); |
| var vf152: f32 = degrees(unconst_f32(-0.02302)); |
| var vf153: vec4u = insertBits(vec4u(unconst_u32(318), unconst_u32(11), unconst_u32(141), unconst_u32(30)), vec4u(unconst_u32(226), unconst_u32(212), unconst_u32(330), unconst_u32(273)), unconst_u32(547), unconst_u32(45)); |
| return out; |
| _ = override28; |
| _ = override21; |
| } |
| let vf154: vec3f = floor(vec3f(unconst_f32(0.4716), unconst_f32(0.1661), unconst_f32(0.1295))); |
| vf148 += (*a0)[unconst_i32(1)]; |
| var vf155: u32 = ~unconst_u32(16); |
| loop { |
| var vf156: u32 = a1; |
| out[0][unconst_u32(182)].f2 = vec4u(sign(vec2h(unconst_f16(74.84), unconst_f16(4821.0))).rggg); |
| var vf157: bool = override28; |
| break; |
| _ = override28; |
| } |
| return out; |
| _ = override28; |
| _ = override21; |
| _ = override26; |
| } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| /* zero global variables used */ |
| fn fn3(a0: ptr<workgroup, array<atomic<u32>, 1>>) { |
| var vf163: bool = override28; |
| let vf164: vec4<bool> = (vec4h(unconst_f16(424.6), unconst_f16(24407.9), unconst_f16(-31384.2), unconst_f16(23190.0)) <= vec4h(unconst_f16(14517.8), unconst_f16(3983.3), unconst_f16(7021.1), unconst_f16(-4574.6))); |
| if bool(override27) { |
| var vf165: vec4i = (vec4i(unconst_i32(171), unconst_i32(291), unconst_i32(22), unconst_i32(333)) << vec4u(unconst_u32(126), unconst_u32(142), unconst_u32(34), unconst_u32(2))); |
| } |
| atomicOr(&(*a0)[unconst_u32(55)], unconst_u32(110)); |
| vf163 = bool(atomicLoad(&(*a0)[0])); |
| atomicSub(&(*a0)[unconst_u32(108)], unconst_u32(1)); |
| _ = override28; |
| _ = override27; |
| } |
| |
| override override26: i32; |
| |
| override override24: f32; |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| alias vec3b = vec3<bool>; |
| |
| @id(8953) override override23: u32 = 197; |
| |
| /* zero global variables used */ |
| fn fn0(a0: ptr<storage, atomic<i32>, read_write>) -> array<mat4x3f, 1> { |
| var out: array<mat4x3f, 1>; |
| out[unconst_u32(42)] -= mat4x3f(bitcast<vec3f>(unpack4xI8(unconst_u32(157)).aga), vec3f(unpack4xI8(unconst_u32(157)).zxy), bitcast<vec3f>(unpack4xI8(unconst_u32(157)).yyy), bitcast<vec3f>(unpack4xI8(unconst_u32(157)).rrr)); |
| let vf145: vec4h = round(vec4h(unconst_f16(7598.0), unconst_f16(10570.9), unconst_f16(3015.0), unconst_f16(13680.6))); |
| switch i32(cross(asinh(vf145.zww), vec3h(unconst_f16(545.9), unconst_f16(925.4), unconst_f16(12874.5)))[2]) { |
| default { |
| atomicMax(&(*a0), unconst_i32(173)); |
| atomicCompareExchangeWeak(&(*a0), unconst_i32(11), unconst_i32(222)); |
| var vf146: bool = (bool(atomicLoad(&(*a0))) || unconst_bool(true)); |
| out[u32(vf146)] = mat4x3f(bitcast<vec3f>(countLeadingZeros(vec2i(unconst_i32(-214), unconst_i32(79))).grr), vec3f(countLeadingZeros(vec2i(unconst_i32(-214), unconst_i32(79))).yxy), vec3f(countLeadingZeros(vec2i(unconst_i32(-214), unconst_i32(79))).xxy), bitcast<vec3f>(countLeadingZeros(vec2i(unconst_i32(-214), unconst_i32(79))).ggg)); |
| break; |
| } |
| } |
| atomicCompareExchangeWeak(&(*a0), unconst_i32(126), unconst_i32(98)); |
| var vf147: vec3h = cos(vec3h(unconst_f16(961.6), unconst_f16(4937.5), unconst_f16(8985.8))); |
| return out; |
| } |
| |
| struct T0 { |
| @align(32) @size(1088) f0: array<atomic<u32>>, |
| } |
| |
| override override22 = false; |
| |
| override override25 = true; |
| |
| @id(35989) override override27: u32; |
| |
| struct FragmentOutput2 { |
| @location(6) @interpolate(perspective) f0: vec2f, |
| @location(3) f1: u32, |
| @location(0) f2: vec4u, |
| } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| /* zero global variables used */ |
| @fragment |
| fn fragment3() -> FragmentOutput2 { |
| var out: FragmentOutput2; |
| var vf166: bool = override22; |
| vf166 = bool(ceil(vec2h(unconst_f16(5110.5), unconst_f16(6563.5))).x); |
| return out; |
| _ = override22; |
| }`, |
| }); |
| let bindGroup59 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout3, |
| entries: [ |
| {binding: 59, resource: externalTexture3}, |
| {binding: 131, resource: externalTexture10}, |
| {binding: 44, resource: externalTexture8}, |
| {binding: 47, resource: {buffer: buffer29, offset: 6400, size: 1760}}, |
| {binding: 19, resource: externalTexture6}, |
| ], |
| }); |
| let commandEncoder136 = device0.createCommandEncoder(); |
| let texture115 = device0.createTexture({ |
| size: {width: 51, height: 1, depthOrArrayLayers: 54}, |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let externalTexture13 = device0.importExternalTexture({label: '\uf6a5\udc27\u05a2\u33e7\u7c68\u61b0\u{1f6ca}\u0c18\u0c91', source: videoFrame11}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder61); computePassEncoder61.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder41.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder29.setBindGroup(3, bindGroup40, new Uint32Array(177), 6, 0); |
| } catch {} |
| try { |
| commandEncoder136.copyTextureToTexture({ |
| texture: texture86, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 12}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture6, |
| mipLevel: 0, |
| origin: {x: 5, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 4, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| computePassEncoder105.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(0, bindGroup32, new Uint32Array(1482), 63, 0); |
| } catch {} |
| let promise24 = device0.queue.onSubmittedWorkDone(); |
| try { |
| globalThis.someLabel = externalTexture5.label; |
| } catch {} |
| let querySet8 = device0.createQuerySet({type: 'occlusion', count: 358}); |
| let computePassEncoder106 = commandEncoder136.beginComputePass({}); |
| try { |
| computePassEncoder98.setBindGroup(1, bindGroup18, new Uint32Array(2470), 458, 0); |
| } catch {} |
| let bindGroup60 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 19, resource: externalTexture12}, |
| {binding: 131, resource: externalTexture12}, |
| {binding: 44, resource: externalTexture10}, |
| {binding: 47, resource: {buffer: buffer25, offset: 0, size: 1212}}, |
| {binding: 59, resource: externalTexture9}, |
| ], |
| }); |
| let commandEncoder137 = device0.createCommandEncoder({}); |
| let texture116 = device0.createTexture({ |
| size: [700, 4, 1], |
| mipLevelCount: 7, |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['r32sint'], |
| }); |
| let textureView119 = texture51.createView({dimension: '2d-array', mipLevelCount: 1}); |
| let renderPassEncoder40 = commandEncoder137.beginRenderPass({colorAttachments: [{view: textureView29, depthSlice: 10, loadOp: 'load', storeOp: 'store'}]}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder24); computePassEncoder24.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder23.setIndexBuffer(buffer46, 'uint32', 1_316, 4_451); |
| } catch {} |
| try { |
| await promise24; |
| } catch {} |
| try { |
| globalThis.someLabel = externalTexture1.label; |
| } catch {} |
| let texture117 = device0.createTexture({ |
| size: {width: 1400, height: 8, depthOrArrayLayers: 1}, |
| mipLevelCount: 7, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| computePassEncoder80.setBindGroup(3, bindGroup39, new Uint32Array(3736), 258, 0); |
| } catch {} |
| try { |
| computePassEncoder97.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderPassEncoder26.setBindGroup(2, bindGroup27, new Uint32Array(925), 16, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.executeBundles([renderBundle10, renderBundle10, renderBundle8]); |
| } catch {} |
| try { |
| renderPassEncoder4.setIndexBuffer(buffer11, 'uint32', 972, 4_371); |
| } catch {} |
| try { |
| renderPassEncoder15.setVertexBuffer(6, buffer40, 0, 18); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture53, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 10}, |
| aspect: 'all', |
| }, new Uint8Array(233_834).fill(143), /* required buffer size: 233_834 */ |
| {offset: 338, bytesPerRow: 138, rowsPerImage: 94}, {width: 5, height: 0, depthOrArrayLayers: 19}); |
| } catch {} |
| let bindGroup61 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout5, |
| entries: [ |
| {binding: 131, resource: externalTexture10}, |
| {binding: 47, resource: {buffer: buffer0, offset: 2048, size: 2460}}, |
| {binding: 19, resource: externalTexture5}, |
| {binding: 59, resource: externalTexture2}, |
| {binding: 44, resource: externalTexture0}, |
| ], |
| }); |
| let buffer59 = device0.createBuffer({size: 3530, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE}); |
| let renderBundleEncoder20 = device0.createRenderBundleEncoder({colorFormats: ['rgba8uint'], depthReadOnly: true}); |
| try { |
| computePassEncoder83.setBindGroup(0, bindGroup12); |
| } catch {} |
| try { |
| renderPassEncoder11.setBindGroup(2, bindGroup44); |
| } catch {} |
| try { |
| renderBundleEncoder20.setBindGroup(0, bindGroup26, [6144]); |
| } catch {} |
| try { |
| renderBundleEncoder20.setIndexBuffer(buffer33, 'uint16', 10_632, 1_408); |
| } catch {} |
| try { |
| buffer14.unmap(); |
| } catch {} |
| try { |
| await buffer27.mapAsync(GPUMapMode.WRITE, 176, 172); |
| } catch {} |
| let textureView120 = texture14.createView({mipLevelCount: 1}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder83); computePassEncoder83.dispatchWorkgroupsIndirect(buffer33, 3_200); }; |
| } catch {} |
| try { |
| computePassEncoder87.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderBundleEncoder20.setPipeline(pipeline3); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer5, 2148, new DataView(new ArrayBuffer(870)), 119, 52); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture4, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(137).fill(11), /* required buffer size: 137 */ |
| {offset: 137}, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline8 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule2, entryPoint: 'compute1', constants: {}}}); |
| let texture118 = device0.createTexture({ |
| size: [51], |
| dimension: '1d', |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder83.end(); |
| } catch {} |
| try { |
| renderBundleEncoder20.setIndexBuffer(buffer33, 'uint32', 5_108, 8_571); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| commandEncoder107.copyBufferToTexture({ |
| /* bytesInLastRow: 52 widthInBlocks: 13 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 260 */ |
| offset: 260, |
| bytesPerRow: 67072, |
| buffer: buffer55, |
| }, { |
| texture: texture60, |
| mipLevel: 0, |
| origin: {x: 0, y: 42, z: 0}, |
| aspect: 'all', |
| }, {width: 13, height: 71, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder107.copyTextureToBuffer({ |
| texture: texture68, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 183 */ |
| offset: 183, |
| bytesPerRow: 2048, |
| buffer: buffer29, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| renderPassEncoder1.pushDebugGroup('\u0fa7'); |
| } catch {} |
| let veryExplicitBindGroupLayout21 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 51, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let bindGroup62 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [ |
| {binding: 47, resource: {buffer: buffer43, offset: 0, size: 420}}, |
| {binding: 19, resource: externalTexture12}, |
| {binding: 131, resource: externalTexture3}, |
| {binding: 59, resource: externalTexture8}, |
| {binding: 44, resource: externalTexture0}, |
| ], |
| }); |
| let commandEncoder138 = device0.createCommandEncoder({}); |
| let computePassEncoder107 = commandEncoder138.beginComputePass({timestampWrites: {querySet: querySet3, beginningOfPassWriteIndex: 157}}); |
| let renderBundleEncoder21 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2uint'], stencilReadOnly: true}); |
| let sampler82 = device0.createSampler({ |
| label: '\u0973\u0c5c\u9ca1\u{1fd54}\u407a\u{1fa03}\u{1fc05}', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder36); computePassEncoder36.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder29.executeBundles([renderBundle13, renderBundle12]); |
| } catch {} |
| try { |
| renderPassEncoder23.setIndexBuffer(buffer16, 'uint32', 1_368, 52); |
| } catch {} |
| try { |
| renderBundleEncoder20.setBindGroup(1, bindGroup53); |
| } catch {} |
| try { |
| renderPassEncoder1.popDebugGroup(); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let pipeline9 = await device0.createComputePipelineAsync({ |
| layout: pipelineLayout11, |
| compute: {module: shaderModule4, constants: {override17: 1, override13: 1}}, |
| }); |
| let commandEncoder139 = device0.createCommandEncoder({}); |
| let textureView121 = texture28.createView({baseMipLevel: 1, mipLevelCount: 1}); |
| let computePassEncoder108 = commandEncoder107.beginComputePass({}); |
| let renderBundle20 = renderBundleEncoder21.finish({}); |
| let sampler83 = device0.createSampler({addressModeU: 'repeat', addressModeW: 'mirror-repeat', lodMaxClamp: 96.57}); |
| try { |
| renderPassEncoder32.setBindGroup(2, bindGroup23, new Uint32Array(833), 54, 0); |
| } catch {} |
| try { |
| renderBundleEncoder20.setBindGroup(1, bindGroup47); |
| } catch {} |
| try { |
| renderBundleEncoder20.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderBundleEncoder20.setVertexBuffer(1, buffer32, 384, 2_051); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| buffer15.unmap(); |
| } catch {} |
| let computePassEncoder109 = commandEncoder139.beginComputePass(); |
| let sampler84 = device0.createSampler({ |
| label: '\ue55d\uc8cc\u0cfc\uf747\ufe1e\u8eda\u{1f88e}\u2f85\u020f', |
| addressModeU: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 92.13, |
| maxAnisotropy: 3, |
| }); |
| try { |
| computePassEncoder48.setBindGroup(0, bindGroup47, new Uint32Array(6019), 2_622, 0); |
| } catch {} |
| try { |
| computePassEncoder98.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder17.setViewport(4079.268422215495, 30.295711056978632, 615.4533707775785, 1.5951916911875972, 0.07246021213501952, 0.27577989684861315); |
| } catch {} |
| try { |
| renderBundleEncoder20.setBindGroup(0, bindGroup61, new Uint32Array(2499), 310, 0); |
| } catch {} |
| try { |
| buffer34.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer21, 348, new Float32Array(3264), 186, 88); |
| } catch {} |
| let commandEncoder140 = device0.createCommandEncoder({}); |
| let texture119 = device0.createTexture({ |
| size: [12, 1, 11], |
| dimension: '3d', |
| format: 'r32sint', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder110 = commandEncoder140.beginComputePass({timestampWrites: {querySet: querySet7, beginningOfPassWriteIndex: 27}}); |
| let renderBundle21 = renderBundleEncoder20.finish({}); |
| try { |
| computePassEncoder9.setPipeline(pipeline2); |
| } catch {} |
| try { |
| buffer46.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer21, 0, new BigUint64Array(259), 72, 4); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 96, height: 1820, depthOrArrayLayers: 296} |
| */ |
| { |
| source: imageData0, |
| origin: { x: 16, y: 3 }, |
| flipY: true, |
| }, { |
| texture: texture12, |
| mipLevel: 0, |
| origin: {x: 26, y: 144, z: 97}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 12, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(canvas2); |
| let commandEncoder141 = device0.createCommandEncoder({}); |
| let querySet9 = device0.createQuerySet({type: 'timestamp', count: 31}); |
| let texture120 = device0.createTexture({ |
| size: {width: 1400, height: 8, depthOrArrayLayers: 386}, |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rgba8unorm-srgb', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder36.setBindGroup(1, bindGroup2, [0]); |
| } catch {} |
| try { |
| renderPassEncoder20.setBindGroup(0, bindGroup25); |
| } catch {} |
| try { |
| renderPassEncoder25.beginOcclusionQuery(234); |
| } catch {} |
| try { |
| renderPassEncoder25.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder30.setVertexBuffer(4, buffer22, 0, 268); |
| } catch {} |
| try { |
| buffer4.unmap(); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let buffer60 = device0.createBuffer({ |
| size: 14691, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let texture121 = device0.createTexture({ |
| size: {width: 8, height: 8, depthOrArrayLayers: 485}, |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler85 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| lodMaxClamp: 98.31, |
| }); |
| try { |
| computePassEncoder36.setBindGroup(0, bindGroup44, new Uint32Array(418), 169, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder61); computePassEncoder61.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder24); computePassEncoder24.dispatchWorkgroupsIndirect(buffer56, 1_696); }; |
| } catch {} |
| try { |
| computePassEncoder99.end(); |
| } catch {} |
| try { |
| renderPassEncoder17.setBindGroup(3, bindGroup53, new Uint32Array(2578), 73, 0); |
| } catch {} |
| let buffer61 = device0.createBuffer({ |
| size: 1825, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let texture122 = device0.createTexture({ |
| size: [24], |
| dimension: '1d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView122 = texture35.createView({mipLevelCount: 1, baseArrayLayer: 0}); |
| let renderPassEncoder41 = commandEncoder141.beginRenderPass({ |
| label: '\u7f36\ub3a4\u{1fc98}\u058b\u{1fe0f}\u{1f8c2}\u09d6', |
| colorAttachments: [{view: textureView62, loadOp: 'load', storeOp: 'discard'}], |
| }); |
| let sampler86 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| compare: 'greater', |
| }); |
| try { |
| computePassEncoder24.end(); |
| } catch {} |
| try { |
| renderPassEncoder7.setBindGroup(3, bindGroup49, []); |
| } catch {} |
| try { |
| renderPassEncoder10.executeBundles([renderBundle3, renderBundle3]); |
| } catch {} |
| try { |
| commandEncoder26.copyTextureToTexture({ |
| texture: texture29, |
| mipLevel: 0, |
| origin: {x: 24, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture51, |
| mipLevel: 1, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 6, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder142 = device0.createCommandEncoder(); |
| let computePassEncoder111 = commandEncoder142.beginComputePass({}); |
| try { |
| computePassEncoder53.setBindGroup(3, bindGroup53); |
| } catch {} |
| try { |
| computePassEncoder5.setBindGroup(1, bindGroup27, new Uint32Array(1420), 210, 0); |
| } catch {} |
| try { |
| renderPassEncoder15.setIndexBuffer(buffer49, 'uint32', 1_020, 2_597); |
| } catch {} |
| try { |
| commandEncoder26.copyBufferToBuffer(buffer6, 936, buffer33, 672, 3216); |
| } catch {} |
| let promise25 = device0.queue.onSubmittedWorkDone(); |
| document.body.prepend(canvas0); |
| let imageData13 = new ImageData(60, 36); |
| let bindGroup63 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout5, |
| entries: [ |
| {binding: 44, resource: externalTexture7}, |
| {binding: 47, resource: {buffer: buffer22, offset: 768, size: 5352}}, |
| {binding: 131, resource: externalTexture13}, |
| {binding: 59, resource: externalTexture5}, |
| {binding: 19, resource: externalTexture6}, |
| ], |
| }); |
| let textureView123 = texture82.createView({aspect: 'all', format: 'r32sint'}); |
| let renderPassEncoder42 = commandEncoder124.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView62, |
| clearValue: { r: -113.0, g: 454.7, b: 958.9, a: -432.8, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| timestampWrites: {querySet: querySet5, beginningOfPassWriteIndex: 1121}, |
| maxDrawCount: 140001855, |
| }); |
| try { |
| computePassEncoder40.setBindGroup(0, bindGroup41); |
| } catch {} |
| try { |
| computePassEncoder63.setBindGroup(3, bindGroup21, new Uint32Array(5053), 699, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder61); computePassEncoder61.dispatchWorkgroupsIndirect(buffer56, 1_372); }; |
| } catch {} |
| try { |
| renderPassEncoder31.setBindGroup(0, bindGroup9, []); |
| } catch {} |
| try { |
| commandEncoder26.copyTextureToBuffer({ |
| texture: texture118, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 16 widthInBlocks: 4 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 508 */ |
| offset: 508, |
| bytesPerRow: 26880, |
| buffer: buffer12, |
| }, {width: 4, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let sampler87 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 70.01, |
| maxAnisotropy: 18, |
| }); |
| try { |
| computePassEncoder102.setBindGroup(0, bindGroup50); |
| } catch {} |
| try { |
| renderPassEncoder15.setVertexBuffer(4, buffer33, 8_700, 1_019); |
| } catch {} |
| let buffer62 = device0.createBuffer({size: 638, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX}); |
| try { |
| computePassEncoder85.setBindGroup(3, bindGroup27); |
| } catch {} |
| try { |
| computePassEncoder36.end(); |
| } catch {} |
| try { |
| computePassEncoder110.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(3, bindGroup43, new Uint32Array(130), 4, 0); |
| } catch {} |
| try { |
| commandEncoder43.copyBufferToTexture({ |
| /* bytesInLastRow: 24 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 2772 */ |
| offset: 2772, |
| bytesPerRow: 50432, |
| buffer: buffer18, |
| }, { |
| texture: texture34, |
| mipLevel: 0, |
| origin: {x: 0, y: 246, z: 0}, |
| aspect: 'all', |
| }, {width: 6, height: 35, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.append(canvas0); |
| let commandEncoder143 = device0.createCommandEncoder(); |
| let textureView124 = texture111.createView({}); |
| let renderBundleEncoder22 = device0.createRenderBundleEncoder({colorFormats: ['r32sint']}); |
| let sampler88 = device0.createSampler({ |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| minFilter: 'nearest', |
| mipmapFilter: 'linear', |
| maxAnisotropy: 1, |
| }); |
| try { |
| computePassEncoder102.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(1, bindGroup32, []); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 700, height: 4, depthOrArrayLayers: 71} |
| */ |
| { |
| source: videoFrame2, |
| origin: { x: 0, y: 1 }, |
| flipY: true, |
| }, { |
| texture: texture100, |
| mipLevel: 0, |
| origin: {x: 40, y: 0, z: 15}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext2.unconfigure(); |
| } catch {} |
| let renderBundle22 = renderBundleEncoder22.finish({}); |
| try { |
| computePassEncoder68.setBindGroup(0, bindGroup40, new Uint32Array(3216), 57, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder22.setBindGroup(3, bindGroup51); |
| } catch {} |
| try { |
| commandEncoder26.copyBufferToBuffer(buffer32, 2348, buffer0, 692, 2064); |
| } catch {} |
| let pipeline10 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule2, entryPoint: 'compute1'}}); |
| let pipeline11 = await device0.createRenderPipelineAsync({ |
| layout: pipelineLayout4, |
| multisample: {mask: 0x8c59012}, |
| fragment: { |
| module: shaderModule2, |
| targets: [{format: 'rgba8uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN}], |
| }, |
| vertex: { |
| module: shaderModule0, |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 628, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'sint16x2', offset: 144, shaderLocation: 5}, |
| {format: 'sint32x2', offset: 404, shaderLocation: 3}, |
| {format: 'unorm10-10-10-2', offset: 136, shaderLocation: 2}, |
| {format: 'float32x3', offset: 28, shaderLocation: 14}, |
| {format: 'unorm16x4', offset: 56, shaderLocation: 4}, |
| {format: 'float32x2', offset: 340, shaderLocation: 1}, |
| {format: 'snorm8x2', offset: 70, shaderLocation: 9}, |
| ], |
| }, |
| { |
| arrayStride: 136, |
| stepMode: 'instance', |
| attributes: [{format: 'sint32', offset: 8, shaderLocation: 11}], |
| }, |
| ], |
| }, |
| }); |
| let texture123 = device0.createTexture({ |
| size: [25, 1, 256], |
| format: 'rgba8unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder47.setBindGroup(2, bindGroup50); |
| } catch {} |
| try { |
| computePassEncoder0.setBindGroup(1, bindGroup4, new Uint32Array(37), 23, 0); |
| } catch {} |
| try { |
| renderPassEncoder19.setIndexBuffer(buffer49, 'uint16', 1_308, 77); |
| } catch {} |
| try { |
| commandEncoder143.clearBuffer(buffer0, 420, 980); |
| } catch {} |
| document.body.append(canvas2); |
| let imageBitmap3 = await createImageBitmap(videoFrame12); |
| try { |
| adapter0.label = '\ud9be\u6144\u353d\u{1fcdd}\ub15d\u03e4'; |
| } catch {} |
| let commandEncoder144 = device0.createCommandEncoder({}); |
| let computePassEncoder112 = commandEncoder143.beginComputePass(); |
| try { |
| computePassEncoder105.setBindGroup(1, bindGroup30, [256]); |
| } catch {} |
| try { |
| renderPassEncoder42.setBindGroup(0, bindGroup17, new Uint32Array(1718), 25, 1); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 96, height: 1820, depthOrArrayLayers: 296} |
| */ |
| { |
| source: offscreenCanvas0, |
| origin: { x: 0, y: 133 }, |
| flipY: true, |
| }, { |
| texture: texture12, |
| mipLevel: 0, |
| origin: {x: 5, y: 240, z: 111}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 9, height: 22, depthOrArrayLayers: 0}); |
| } catch {} |
| let offscreenCanvas1 = new OffscreenCanvas(89, 243); |
| try { |
| adapter0.label = '\udcd7\u642c\u64b5\u0461\u{1ffbe}\uaa41\u{1f657}\u{1fb8b}\u{1f881}\u{1fab5}\u07d6'; |
| } catch {} |
| let commandEncoder145 = device0.createCommandEncoder({}); |
| let texture124 = device0.createTexture({ |
| size: {width: 8}, |
| dimension: '1d', |
| format: 'rgba8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let renderPassEncoder43 = commandEncoder144.beginRenderPass({colorAttachments: [{view: textureView22, loadOp: 'load', storeOp: 'store'}], maxDrawCount: 129318721}); |
| try { |
| computePassEncoder0.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderPassEncoder0.beginOcclusionQuery(330); |
| } catch {} |
| try { |
| renderPassEncoder0.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(6, buffer21, 0, 205); |
| } catch {} |
| try { |
| commandEncoder26.copyBufferToBuffer(buffer43, 92, buffer36, 504, 16); |
| } catch {} |
| let pipeline12 = await device0.createRenderPipelineAsync({ |
| layout: pipelineLayout2, |
| fragment: { |
| module: shaderModule2, |
| targets: [{format: 'rgba8uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN}], |
| }, |
| vertex: { |
| module: shaderModule0, |
| buffers: [ |
| { |
| arrayStride: 128, |
| attributes: [ |
| {format: 'snorm16x2', offset: 28, shaderLocation: 2}, |
| {format: 'float32', offset: 4, shaderLocation: 4}, |
| {format: 'sint8x2', offset: 12, shaderLocation: 3}, |
| {format: 'unorm16x2', offset: 0, shaderLocation: 1}, |
| {format: 'sint32x4', offset: 0, shaderLocation: 11}, |
| {format: 'unorm8x2', offset: 30, shaderLocation: 14}, |
| {format: 'sint32x3', offset: 52, shaderLocation: 5}, |
| {format: 'float32', offset: 20, shaderLocation: 9}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'point-list', cullMode: 'front'}, |
| }); |
| let commandEncoder146 = device0.createCommandEncoder(); |
| let computePassEncoder113 = commandEncoder26.beginComputePass(); |
| try { |
| { clearResourceUsages(device0, computePassEncoder48); computePassEncoder48.dispatchWorkgroupsIndirect(buffer40, 60); }; |
| } catch {} |
| try { |
| computePassEncoder103.setPipeline(pipeline7); |
| } catch {} |
| try { |
| commandEncoder146.copyBufferToBuffer(buffer26, 3572, buffer37, 20, 508); |
| } catch {} |
| let bindGroup64 = device0.createBindGroup({layout: veryExplicitBindGroupLayout7, entries: [{binding: 41, resource: textureView36}]}); |
| let buffer63 = device0.createBuffer({ |
| size: 3793, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| mappedAtCreation: false, |
| }); |
| let commandEncoder147 = device0.createCommandEncoder({}); |
| let texture125 = device0.createTexture({ |
| size: {width: 8, height: 8, depthOrArrayLayers: 11}, |
| dimension: '3d', |
| format: 'rgba8unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let computePassEncoder114 = commandEncoder147.beginComputePass({timestampWrites: {querySet: querySet4, beginningOfPassWriteIndex: 332, endOfPassWriteIndex: 68}}); |
| try { |
| computePassEncoder61.setBindGroup(0, bindGroup44, new Uint32Array(400), 88, 0); |
| } catch {} |
| try { |
| computePassEncoder108.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder40.setBindGroup(2, bindGroup37, new Uint32Array(441), 51, 0); |
| } catch {} |
| try { |
| renderPassEncoder38.executeBundles([renderBundle8, renderBundle10, renderBundle8]); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 96, height: 1820, depthOrArrayLayers: 296} |
| */ |
| { |
| source: videoFrame12, |
| origin: { x: 0, y: 1 }, |
| flipY: true, |
| }, { |
| texture: texture12, |
| mipLevel: 0, |
| origin: {x: 4, y: 87, z: 18}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext2.unconfigure(); |
| } catch {} |
| let querySet10 = device0.createQuerySet({type: 'timestamp', count: 67}); |
| try { |
| computePassEncoder59.setBindGroup(0, bindGroup47); |
| } catch {} |
| try { |
| renderPassEncoder29.beginOcclusionQuery(41); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 8, height: 8, depthOrArrayLayers: 11} |
| */ |
| { |
| source: videoFrame4, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture125, |
| mipLevel: 0, |
| origin: {x: 0, y: 1, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let gpuCanvasContext3 = offscreenCanvas1.getContext('webgpu'); |
| await gc(); |
| let img4 = await imageWithData(12, 42, '#10101010', '#20202020'); |
| let bindGroup65 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [ |
| {binding: 19, resource: externalTexture11}, |
| {binding: 59, resource: externalTexture5}, |
| {binding: 47, resource: {buffer: buffer28, offset: 9472, size: 1224}}, |
| {binding: 44, resource: externalTexture11}, |
| {binding: 131, resource: externalTexture1}, |
| ], |
| }); |
| let buffer64 = device0.createBuffer({ |
| size: 23061, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE, |
| }); |
| let texture126 = device0.createTexture({ |
| size: {width: 700}, |
| dimension: '1d', |
| format: 'rgba8uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder115 = commandEncoder146.beginComputePass({}); |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 96, height: 1820, depthOrArrayLayers: 296} |
| */ |
| { |
| source: imageData8, |
| origin: { x: 2, y: 1 }, |
| flipY: true, |
| }, { |
| texture: texture12, |
| mipLevel: 0, |
| origin: {x: 0, y: 231, z: 98}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 16, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder148 = device0.createCommandEncoder({}); |
| let computePassEncoder116 = commandEncoder43.beginComputePass({timestampWrites: {querySet: querySet3, beginningOfPassWriteIndex: 166, endOfPassWriteIndex: 254}}); |
| let renderBundleEncoder23 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2uint'], depthReadOnly: true}); |
| try { |
| computePassEncoder109.setBindGroup(1, bindGroup8, new Uint32Array(773), 89, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroups(1, 1, 1); }; |
| } catch {} |
| try { |
| computePassEncoder116.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(2, bindGroup13, new Uint32Array(389), 66, 1); |
| } catch {} |
| try { |
| renderPassEncoder29.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder28.executeBundles([renderBundle2]); |
| } catch {} |
| try { |
| renderBundleEncoder23.setIndexBuffer(buffer19, 'uint16', 192, 78); |
| } catch {} |
| await gc(); |
| let buffer65 = device0.createBuffer({ |
| size: 10242, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let commandEncoder149 = device0.createCommandEncoder({}); |
| let textureView125 = texture108.createView({}); |
| try { |
| computePassEncoder17.setBindGroup(1, bindGroup37, new Uint32Array(1104), 79, 0); |
| } catch {} |
| try { |
| renderBundleEncoder23.setBindGroup(3, bindGroup12); |
| } catch {} |
| try { |
| renderBundleEncoder23.setIndexBuffer(buffer14, 'uint32', 108, 427); |
| } catch {} |
| try { |
| renderBundleEncoder23.setVertexBuffer(3, buffer0, 824); |
| } catch {} |
| try { |
| if (!arrayBuffer7.detached) { new Uint8Array(arrayBuffer7).fill(0x55); }; |
| } catch {} |
| let commandEncoder150 = device0.createCommandEncoder({}); |
| let textureView126 = texture101.createView({dimension: '3d'}); |
| let computePassEncoder117 = commandEncoder150.beginComputePass({timestampWrites: {querySet: querySet5, beginningOfPassWriteIndex: 547}}); |
| let renderBundle23 = renderBundleEncoder23.finish({}); |
| try { |
| computePassEncoder14.setBindGroup(0, bindGroup38); |
| } catch {} |
| try { |
| computePassEncoder111.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderPassEncoder39.executeBundles([renderBundle4]); |
| } catch {} |
| try { |
| renderPassEncoder16.setIndexBuffer(buffer0, 'uint32', 6_888, 753); |
| } catch {} |
| let arrayBuffer14 = buffer27.getMappedRange(176, 8); |
| try { |
| buffer64.unmap(); |
| } catch {} |
| let texture127 = device0.createTexture({ |
| size: [102, 1, 14], |
| mipLevelCount: 4, |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView127 = texture72.createView({}); |
| let computePassEncoder118 = commandEncoder145.beginComputePass({timestampWrites: {querySet: querySet5, beginningOfPassWriteIndex: 396}}); |
| let renderPassEncoder44 = commandEncoder149.beginRenderPass({ |
| colorAttachments: [{view: textureView47, loadOp: 'load', storeOp: 'discard'}], |
| maxDrawCount: 227354704, |
| }); |
| try { |
| computePassEncoder96.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder3.executeBundles([renderBundle10]); |
| } catch {} |
| try { |
| commandEncoder148.copyBufferToBuffer(buffer64, 3308, buffer21, 736, 76); |
| } catch {} |
| let commandEncoder151 = device0.createCommandEncoder(); |
| let texture128 = device0.createTexture({size: [51, 1, 61], format: 'rgba8unorm-srgb', usage: GPUTextureUsage.COPY_DST, viewFormats: []}); |
| let computePassEncoder119 = commandEncoder151.beginComputePass(); |
| try { |
| computePassEncoder21.setBindGroup(1, bindGroup13, new Uint32Array(2389), 714, 1); |
| } catch {} |
| try { |
| computePassEncoder81.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderPassEncoder35.setBindGroup(3, bindGroup31, new Uint32Array(418), 39, 0); |
| } catch {} |
| try { |
| renderPassEncoder44.setVertexBuffer(4, buffer29); |
| } catch {} |
| let buffer66 = device0.createBuffer({ |
| size: 9435, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE, |
| mappedAtCreation: false, |
| }); |
| let commandEncoder152 = device0.createCommandEncoder({}); |
| let textureView128 = texture92.createView({}); |
| try { |
| computePassEncoder107.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder23.setIndexBuffer(buffer19, 'uint16', 116, 170); |
| } catch {} |
| try { |
| buffer57.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| canvas1.width = 666; |
| let imageBitmap4 = await createImageBitmap(img3); |
| let bindGroup66 = device0.createBindGroup({layout: veryExplicitBindGroupLayout10, entries: []}); |
| let pipelineLayout18 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout1]}); |
| let sampler89 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| lodMaxClamp: 74.41, |
| }); |
| try { |
| computePassEncoder106.setBindGroup(1, bindGroup47, []); |
| } catch {} |
| try { |
| computePassEncoder96.setBindGroup(1, bindGroup36, new Uint32Array(364), 2, 1); |
| } catch {} |
| try { |
| buffer37.unmap(); |
| } catch {} |
| let texture129 = device0.createTexture({ |
| size: {width: 51}, |
| dimension: '1d', |
| format: 'rgba8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView129 = texture53.createView({dimension: '2d', format: 'rgba8sint', baseArrayLayer: 5}); |
| let computePassEncoder120 = commandEncoder152.beginComputePass({}); |
| let renderPassEncoder45 = commandEncoder148.beginRenderPass({ |
| colorAttachments: [{view: textureView37, loadOp: 'clear', storeOp: 'discard'}], |
| timestampWrites: {querySet: querySet7, endOfPassWriteIndex: 16}, |
| maxDrawCount: 216329204, |
| }); |
| try { |
| computePassEncoder84.setBindGroup(0, bindGroup37); |
| } catch {} |
| try { |
| computePassEncoder58.setBindGroup(1, bindGroup31, new Uint32Array(617), 203, 0); |
| } catch {} |
| try { |
| renderPassEncoder34.setBindGroup(2, bindGroup27, new Uint32Array(3206), 2_695, 0); |
| } catch {} |
| try { |
| buffer66.unmap(); |
| } catch {} |
| try { |
| await buffer15.mapAsync(GPUMapMode.WRITE); |
| } catch {} |
| let sampler90 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| maxAnisotropy: 8, |
| }); |
| try { |
| renderPassEncoder11.setBindGroup(2, bindGroup51, new Uint32Array(930), 34, 0); |
| } catch {} |
| try { |
| renderPassEncoder24.executeBundles([renderBundle16, renderBundle22, renderBundle0, renderBundle2, renderBundle7, renderBundle0]); |
| } catch {} |
| let buffer67 = device0.createBuffer({size: 16718, usage: GPUBufferUsage.MAP_WRITE}); |
| let renderBundleEncoder24 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2uint'], stencilReadOnly: true}); |
| try { |
| computePassEncoder51.setBindGroup(0, bindGroup48); |
| } catch {} |
| try { |
| computePassEncoder30.end(); |
| } catch {} |
| try { |
| computePassEncoder94.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder22.setBindGroup(3, bindGroup2, [0]); |
| } catch {} |
| try { |
| renderBundleEncoder24.setIndexBuffer(buffer28, 'uint16', 5_964, 3_285); |
| } catch {} |
| try { |
| adapter0.label = '\u81c0\u0bc8\u0bf6\u002e\u09bd\u06d9\u0fb5\u344a'; |
| } catch {} |
| let buffer68 = device0.createBuffer({size: 50086, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE}); |
| let computePassEncoder121 = commandEncoder35.beginComputePass({}); |
| let renderBundle24 = renderBundleEncoder24.finish({}); |
| try { |
| computePassEncoder113.setPipeline(pipeline0); |
| } catch {} |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer36, 760, new DataView(new ArrayBuffer(5362)), 398, 24); |
| } catch {} |
| try { |
| await promise21; |
| } catch {} |
| let commandEncoder153 = device0.createCommandEncoder({}); |
| let sampler91 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'repeat', addressModeW: 'mirror-repeat', lodMaxClamp: 55.45}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder108); computePassEncoder108.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| await promise25; |
| } catch {} |
| let computePassEncoder122 = commandEncoder153.beginComputePass(); |
| try { |
| computePassEncoder69.setBindGroup(2, bindGroup8); |
| } catch {} |
| try { |
| renderPassEncoder18.setBindGroup(0, bindGroup56, new Uint32Array(676), 16, 0); |
| } catch {} |
| try { |
| renderPassEncoder39.setViewport(8.442765763891739, 0.22093678861879373, 6.886420490709532, 0.351729032645744, 0.8589656342140672, 0.9083212092979314); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| buffer53.unmap(); |
| } catch {} |
| let bindGroup67 = device0.createBindGroup({layout: veryExplicitBindGroupLayout16, entries: [{binding: 224, resource: externalTexture3}]}); |
| let texture130 = device0.createTexture({ |
| size: {width: 2800}, |
| dimension: '1d', |
| format: 'rgba8unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| try { |
| computePassEncoder95.setBindGroup(0, bindGroup8, new Uint32Array(2193), 58, 0); |
| } catch {} |
| try { |
| computePassEncoder117.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder4.setVertexBuffer(2, buffer54, 0, 4); |
| } catch {} |
| let bindGroup68 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout3, |
| entries: [ |
| {binding: 59, resource: externalTexture7}, |
| {binding: 44, resource: externalTexture5}, |
| {binding: 47, resource: {buffer: buffer18, offset: 0, size: 740}}, |
| {binding: 19, resource: externalTexture6}, |
| {binding: 131, resource: externalTexture7}, |
| ], |
| }); |
| let textureView130 = texture126.createView({aspect: 'all'}); |
| let sampler92 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| minFilter: 'nearest', |
| }); |
| try { |
| computePassEncoder77.setBindGroup(1, bindGroup51, new Uint32Array(202), 21, 0); |
| } catch {} |
| try { |
| computePassEncoder98.setPipeline(pipeline9); |
| } catch {} |
| try { |
| computePassEncoder104.setPipeline(pipeline8); |
| } catch {} |
| let promise26 = device0.queue.onSubmittedWorkDone(); |
| let bindGroup69 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout12, |
| entries: [{binding: 51, resource: {buffer: buffer42, offset: 2048, size: 216}}], |
| }); |
| let buffer69 = device0.createBuffer({size: 12257, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM}); |
| let commandEncoder154 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder48.end(); |
| } catch {} |
| try { |
| computePassEncoder106.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder6.executeBundles([renderBundle4, renderBundle4]); |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer10, 'uint32', 1_720, 1_353); |
| } catch {} |
| try { |
| commandEncoder154.copyBufferToTexture({ |
| /* bytesInLastRow: 12 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 532 */ |
| offset: 532, |
| buffer: buffer62, |
| }, { |
| texture: texture52, |
| mipLevel: 0, |
| origin: {x: 13, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 3, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer43, 88, new DataView(new ArrayBuffer(9280)), 44, 352); |
| } catch {} |
| try { |
| gpuCanvasContext3.unconfigure(); |
| } catch {} |
| let bindGroup70 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout7, |
| entries: [ |
| {binding: 110, resource: {buffer: buffer29, offset: 768, size: 760}}, |
| {binding: 52, resource: externalTexture7}, |
| {binding: 141, resource: {buffer: buffer22, offset: 4608, size: 96}}, |
| ], |
| }); |
| let buffer70 = device0.createBuffer({ |
| size: 9501, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let textureView131 = texture129.createView({format: 'rgba8uint'}); |
| let computePassEncoder123 = commandEncoder154.beginComputePass(); |
| try { |
| renderPassEncoder18.setBindGroup(3, bindGroup13, [256]); |
| } catch {} |
| try { |
| renderPassEncoder23.setBindGroup(3, bindGroup48, new Uint32Array(2014), 153, 0); |
| } catch {} |
| try { |
| renderPassEncoder44.setIndexBuffer(buffer55, 'uint16', 1_402, 12); |
| } catch {} |
| try { |
| gpuCanvasContext3.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let bindGroup71 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout2, |
| entries: [ |
| {binding: 131, resource: externalTexture9}, |
| {binding: 19, resource: externalTexture10}, |
| {binding: 59, resource: externalTexture2}, |
| {binding: 44, resource: externalTexture8}, |
| {binding: 47, resource: {buffer: buffer64, offset: 10496, size: 7260}}, |
| ], |
| }); |
| let commandEncoder155 = device0.createCommandEncoder({}); |
| let texture131 = device0.createTexture({ |
| size: {width: 8, height: 8, depthOrArrayLayers: 85}, |
| dimension: '3d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView132 = texture36.createView({aspect: 'all', mipLevelCount: 1}); |
| let computePassEncoder124 = commandEncoder58.beginComputePass({}); |
| let renderPassEncoder46 = commandEncoder155.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView132, |
| clearValue: { r: 886.2, g: -130.2, b: 839.9, a: -927.0, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| }); |
| let sampler93 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'nearest', |
| lodMaxClamp: 95.63, |
| }); |
| try { |
| computePassEncoder90.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder40.setBindGroup(3, bindGroup36, new Uint32Array(6646), 2_193, 1); |
| } catch {} |
| try { |
| renderPassEncoder20.executeBundles([renderBundle5]); |
| } catch {} |
| try { |
| renderPassEncoder4.setVertexBuffer(4, buffer12, 0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture62, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(25).fill(99), /* required buffer size: 25 */ |
| {offset: 25}, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| document.body.prepend(canvas1); |
| let imageData14 = new ImageData(12, 100); |
| let autogeneratedBindGroupLayout0 = pipeline5.getBindGroupLayout(0); |
| try { |
| computePassEncoder97.setPipeline(pipeline8); |
| } catch {} |
| try { |
| computePassEncoder114.setPipeline(pipeline10); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let bindGroup72 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout20, |
| entries: [ |
| {binding: 52, resource: externalTexture10}, |
| {binding: 141, resource: {buffer: buffer30, offset: 0, size: 460}}, |
| {binding: 110, resource: {buffer: buffer30, offset: 512, size: 728}}, |
| ], |
| }); |
| let commandEncoder156 = device0.createCommandEncoder(); |
| let textureView133 = texture72.createView({baseArrayLayer: 0}); |
| let computePassEncoder125 = commandEncoder156.beginComputePass({}); |
| try { |
| renderPassEncoder10.setBindGroup(1, bindGroup5, new Uint32Array(1314), 252, 0); |
| } catch {} |
| try { |
| renderPassEncoder26.setIndexBuffer(buffer63, 'uint16', 390, 1_056); |
| } catch {} |
| try { |
| buffer32.unmap(); |
| } catch {} |
| let recycledExplicitBindGroupLayout9 = pipeline3.getBindGroupLayout(1); |
| let buffer71 = device0.createBuffer({size: 34712, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT}); |
| let sampler94 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 94.65, |
| }); |
| try { |
| computePassEncoder112.setPipeline(pipeline10); |
| } catch {} |
| try { |
| renderPassEncoder37.setBindGroup(3, bindGroup5, new Uint32Array(2209), 148, 0); |
| } catch {} |
| let pipeline13 = await device0.createComputePipelineAsync({layout: pipelineLayout5, compute: {module: shaderModule4, constants: {override17: 1, override13: 1}}}); |
| let texture132 = device0.createTexture({ |
| size: {width: 96, height: 1820, depthOrArrayLayers: 434}, |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let textureView134 = texture125.createView({aspect: 'all', baseArrayLayer: 0}); |
| try { |
| computePassEncoder125.setPipeline(pipeline13); |
| } catch {} |
| try { |
| renderPassEncoder21.executeBundles([renderBundle6, renderBundle13]); |
| } catch {} |
| let promise27 = device0.queue.onSubmittedWorkDone(); |
| let textureView135 = texture25.createView({}); |
| try { |
| computePassEncoder3.end(); |
| } catch {} |
| try { |
| renderPassEncoder36.setBindGroup(3, bindGroup7); |
| } catch {} |
| try { |
| renderPassEncoder37.setVertexBuffer(6, buffer62); |
| } catch {} |
| try { |
| commandEncoder3.copyBufferToBuffer(buffer55, 216, buffer32, 656, 60); |
| } catch {} |
| try { |
| commandEncoder3.copyTextureToTexture({ |
| texture: texture87, |
| mipLevel: 0, |
| origin: {x: 63, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture124, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext3.configure({device: device0, format: 'bgra8unorm', usage: GPUTextureUsage.COPY_DST}); |
| } catch {} |
| document.body.append(img4); |
| let buffer72 = device0.createBuffer({size: 43288, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE}); |
| let computePassEncoder126 = commandEncoder3.beginComputePass({timestampWrites: {querySet: querySet10, endOfPassWriteIndex: 54}}); |
| let sampler95 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 79.60, |
| maxAnisotropy: 12, |
| }); |
| try { |
| computePassEncoder119.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder23.setBindGroup(1, bindGroup17, new Uint32Array(373), 6, 1); |
| } catch {} |
| try { |
| renderPassEncoder12.setIndexBuffer(buffer16, 'uint32', 392, 972); |
| } catch {} |
| try { |
| renderPassEncoder38.setVertexBuffer(4, buffer29); |
| } catch {} |
| let bindGroup73 = device0.createBindGroup({layout: autogeneratedBindGroupLayout0, entries: [{binding: 224, resource: externalTexture2}]}); |
| let texture133 = device0.createTexture({ |
| size: [12, 1, 1], |
| sampleCount: 1, |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| computePassEncoder118.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderPassEncoder16.setBindGroup(2, bindGroup65, new Uint32Array(283), 19, 0); |
| } catch {} |
| let imageData15 = new ImageData(12, 140); |
| let buffer73 = device0.createBuffer({ |
| size: 4078, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE, |
| }); |
| let commandEncoder157 = device0.createCommandEncoder({}); |
| let sampler96 = device0.createSampler({addressModeV: 'mirror-repeat', minFilter: 'linear', mipmapFilter: 'linear'}); |
| try { |
| computePassEncoder44.setBindGroup(0, bindGroup64); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 96, height: 1820, depthOrArrayLayers: 296} |
| */ |
| { |
| source: imageData12, |
| origin: { x: 3, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture12, |
| mipLevel: 0, |
| origin: {x: 13, y: 325, z: 152}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 7, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer74 = device0.createBuffer({size: 18386, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX}); |
| let commandEncoder158 = device0.createCommandEncoder({}); |
| let texture134 = device0.createTexture({ |
| size: [700, 4, 1], |
| mipLevelCount: 2, |
| format: 'rgba8uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder127 = commandEncoder158.beginComputePass({timestampWrites: {querySet: querySet7, beginningOfPassWriteIndex: 12, endOfPassWriteIndex: 66}}); |
| try { |
| computePassEncoder52.setBindGroup(3, bindGroup2, new Uint32Array(752), 166, 1); |
| } catch {} |
| try { |
| computePassEncoder109.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder13.executeBundles([renderBundle10]); |
| } catch {} |
| try { |
| renderPassEncoder31.setVertexBuffer(6, buffer55, 0, 711); |
| } catch {} |
| try { |
| commandEncoder157.copyBufferToTexture({ |
| /* bytesInLastRow: 824 widthInBlocks: 103 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 1488 */ |
| offset: 1488, |
| bytesPerRow: 12032, |
| buffer: buffer46, |
| }, { |
| texture: texture100, |
| mipLevel: 0, |
| origin: {x: 166, y: 1, z: 1}, |
| aspect: 'all', |
| }, {width: 103, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder157.copyTextureToTexture({ |
| texture: texture125, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 1}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture128, |
| mipLevel: 0, |
| origin: {x: 8, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer19, 856, new Float32Array(4054), 322, 28); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let renderPassEncoder47 = commandEncoder157.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView134, |
| depthSlice: 7, |
| clearValue: { r: -720.6, g: 674.9, b: -399.3, a: 281.8, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| }); |
| let sampler97 = device0.createSampler({addressModeW: 'repeat', lodMaxClamp: 80.55}); |
| try { |
| computePassEncoder12.setBindGroup(0, bindGroup46); |
| } catch {} |
| try { |
| device0.pushErrorScope('internal'); |
| } catch {} |
| try { |
| gpuCanvasContext3.configure({device: device0, format: 'rgba8unorm', usage: GPUTextureUsage.COPY_DST}); |
| } catch {} |
| try { |
| await promise26; |
| } catch {} |
| let imageData16 = new ImageData(12, 56); |
| let buffer75 = device0.createBuffer({size: 3891, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let texture135 = device0.createTexture({size: [24], dimension: '1d', format: 'rgb10a2uint', usage: GPUTextureUsage.TEXTURE_BINDING}); |
| try { |
| computePassEncoder14.setBindGroup(3, bindGroup26, new Uint32Array(3627), 1_363, 1); |
| } catch {} |
| try { |
| computePassEncoder122.setPipeline(pipeline1); |
| } catch {} |
| await gc(); |
| let sampler98 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'repeat', lodMinClamp: 28.86, compare: 'less'}); |
| try { |
| computePassEncoder121.setPipeline(pipeline10); |
| } catch {} |
| try { |
| renderPassEncoder41.setVertexBuffer(2, buffer53, 0); |
| } catch {} |
| let videoFrame14 = new VideoFrame(imageBitmap0, {timestamp: 0}); |
| let commandEncoder159 = device0.createCommandEncoder({}); |
| let computePassEncoder128 = commandEncoder159.beginComputePass(); |
| try { |
| computePassEncoder65.setBindGroup(1, bindGroup38); |
| } catch {} |
| try { |
| computePassEncoder124.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder33.executeBundles([renderBundle13]); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture69, |
| mipLevel: 0, |
| origin: {x: 342, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(46).fill(143), /* required buffer size: 46 */ |
| {offset: 46, bytesPerRow: 403}, {width: 92, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await promise23; |
| } catch {} |
| let textureView136 = texture75.createView({}); |
| let texture136 = device0.createTexture({ |
| size: {width: 700, height: 4, depthOrArrayLayers: 13}, |
| dimension: '3d', |
| format: 'rgba8uint', |
| usage: GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let textureView137 = texture132.createView({baseMipLevel: 0, mipLevelCount: 1, arrayLayerCount: 1}); |
| let sampler99 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeW: 'repeat', |
| lodMinClamp: 3.689, |
| lodMaxClamp: 5.785, |
| compare: 'equal', |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder112); computePassEncoder112.dispatchWorkgroupsIndirect(buffer56, 240); }; |
| } catch {} |
| try { |
| computePassEncoder126.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(0, bindGroup62, new Uint32Array(644), 168, 0); |
| } catch {} |
| await gc(); |
| let buffer76 = device0.createBuffer({size: 5472, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| try { |
| computePassEncoder115.setPipeline(pipeline0); |
| } catch {} |
| try { |
| buffer19.unmap(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 8, height: 8, depthOrArrayLayers: 11} |
| */ |
| { |
| source: imageData2, |
| origin: { x: 3, y: 5 }, |
| flipY: true, |
| }, { |
| texture: texture125, |
| mipLevel: 0, |
| origin: {x: 0, y: 2, z: 1}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| if (!arrayBuffer8.detached) { new Uint8Array(arrayBuffer8).fill(0x55); }; |
| } catch {} |
| try { |
| externalTexture6.label = '\ued2d\uce10\u0c86\ubc4b\u1c1b\ua253\u4b1e'; |
| } catch {} |
| let textureView138 = texture56.createView({}); |
| let sampler100 = device0.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'mirror-repeat'}); |
| try { |
| computePassEncoder61.end(); |
| } catch {} |
| try { |
| computePassEncoder123.setPipeline(pipeline7); |
| } catch {} |
| try { |
| commandEncoder80.copyBufferToTexture({ |
| /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 5156 */ |
| offset: 5156, |
| bytesPerRow: 26880, |
| rowsPerImage: 415, |
| buffer: buffer74, |
| }, { |
| texture: texture5, |
| mipLevel: 0, |
| origin: {x: 13, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer75, 492, new Float32Array(40248), 17777, 380); |
| } catch {} |
| let buffer77 = device0.createBuffer({ |
| size: 5433, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE, |
| }); |
| let commandEncoder160 = device0.createCommandEncoder({}); |
| let computePassEncoder129 = commandEncoder160.beginComputePass({ |
| label: '\u0436\u3006\u5478\u{1fcf2}\u0f42\u063f\u91d7\uc98d\u3b04\ucae3\u0607', |
| timestampWrites: {querySet: querySet9, beginningOfPassWriteIndex: 18}, |
| }); |
| let renderPassEncoder48 = commandEncoder80.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView134, |
| depthSlice: 2, |
| clearValue: { r: 908.6, g: -464.5, b: 38.38, a: -908.7, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet8, |
| timestampWrites: {querySet: querySet7, beginningOfPassWriteIndex: 31, endOfPassWriteIndex: 3}, |
| maxDrawCount: 47677609, |
| }); |
| try { |
| computePassEncoder103.setBindGroup(0, bindGroup40, new Uint32Array(3219), 11, 0); |
| } catch {} |
| try { |
| computePassEncoder120.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder7.setViewport(4286.200410563862, 6.677558496511649, 447.4354113598497, 9.42248168849351, 0.09592806626293482, 0.6044917172718856); |
| } catch {} |
| try { |
| renderPassEncoder22.setVertexBuffer(1, buffer12, 64); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer12, 68, new Float32Array(5282), 294, 56); |
| } catch {} |
| try { |
| gpuCanvasContext2.unconfigure(); |
| } catch {} |
| let buffer78 = device0.createBuffer({ |
| size: 13542, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE, |
| }); |
| let renderBundleEncoder25 = device0.createRenderBundleEncoder({colorFormats: ['rgba8unorm-srgb'], sampleCount: 1, stencilReadOnly: true}); |
| try { |
| computePassEncoder51.setBindGroup(1, bindGroup71); |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(0, bindGroup59); |
| } catch {} |
| try { |
| renderPassEncoder40.executeBundles([renderBundle12]); |
| } catch {} |
| try { |
| renderPassEncoder40.setVertexBuffer(4, buffer74, 0, 18_070); |
| } catch {} |
| try { |
| renderBundleEncoder25.setIndexBuffer(buffer47, 'uint16', 26, 27); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer12, 36, new Float32Array(21672), 10, 80); |
| } catch {} |
| let bindGroup74 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout6, |
| entries: [ |
| {binding: 19, resource: externalTexture6}, |
| {binding: 47, resource: {buffer: buffer22, offset: 256, size: 1020}}, |
| {binding: 59, resource: externalTexture6}, |
| {binding: 44, resource: externalTexture5}, |
| {binding: 131, resource: externalTexture12}, |
| ], |
| }); |
| let buffer79 = device0.createBuffer({size: 6476, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let renderBundle25 = renderBundleEncoder25.finish({}); |
| try { |
| computePassEncoder75.setBindGroup(2, bindGroup19); |
| } catch {} |
| try { |
| renderPassEncoder18.setBindGroup(1, bindGroup62); |
| } catch {} |
| try { |
| renderPassEncoder1.setStencilReference(324); |
| } catch {} |
| try { |
| renderPassEncoder48.setVertexBuffer(5, buffer74); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture124, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(130).fill(64), /* required buffer size: 130 */ |
| {offset: 130}, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline14 = device0.createComputePipeline({ |
| layout: pipelineLayout9, |
| compute: {module: shaderModule4, entryPoint: 'compute3', constants: {override13: 1, 11_106: 1, override17: 1}}, |
| }); |
| try { |
| await promise27; |
| } catch {} |
| let commandEncoder161 = device0.createCommandEncoder(); |
| let textureView139 = texture119.createView({}); |
| let sampler101 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| lodMaxClamp: 74.96, |
| compare: 'less-equal', |
| maxAnisotropy: 1, |
| }); |
| try { |
| computePassEncoder35.setBindGroup(3, bindGroup26, new Uint32Array(66), 0, 1); |
| } catch {} |
| try { |
| computePassEncoder127.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderPassEncoder26.executeBundles([renderBundle12, renderBundle7, renderBundle7]); |
| } catch {} |
| try { |
| renderPassEncoder31.setIndexBuffer(buffer5, 'uint16', 3_056, 1_407); |
| } catch {} |
| try { |
| renderPassEncoder30.setVertexBuffer(1, buffer53); |
| } catch {} |
| try { |
| commandEncoder161.copyTextureToTexture({ |
| texture: texture20, |
| mipLevel: 0, |
| origin: {x: 2, y: 1, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture20, |
| mipLevel: 0, |
| origin: {x: 1, y: 1, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture61, |
| mipLevel: 0, |
| origin: {x: 6, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(112).fill(96), /* required buffer size: 112 */ |
| {offset: 112}, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 25, height: 1, depthOrArrayLayers: 256} |
| */ |
| { |
| source: videoFrame2, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture123, |
| mipLevel: 0, |
| origin: {x: 10, y: 0, z: 84}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline15 = device0.createComputePipeline({layout: pipelineLayout16, compute: {module: shaderModule0}}); |
| try { |
| adapter0.label = '\u0ee6\u0460\u0ea5\u697a\u{1ff94}\u0e9c\u0a35\u4986\u{1f63f}'; |
| } catch {} |
| let shaderModule6 = device0.createShaderModule({ |
| code: ` |
| requires pointer_composite_access; |
| |
| enable f16; |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| var<private> vp2 = array(array(modf(f16(2647.7)), modf(f16(9820.9)), modf(f16(8444.6)), modf(f16(1681.4)), modf(f16(-31134.6)), modf(f16(8655.5)), modf(f16(-6615.8)), modf(f16(1037.7)), modf(f16(6324.6)))); |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| struct VertexOutput3 { |
| @location(14) f26: vec4h, |
| @location(2) f27: f16, |
| @location(12) @interpolate(perspective, either) f28: f32, |
| @location(4) @interpolate(flat, either) f29: u32, |
| @location(13) f30: i32, |
| @location(6) f31: vec2i, |
| @location(0) @interpolate(flat, either) f32: vec4i, |
| @invariant @builtin(position) f33: vec4f, |
| @location(11) f34: vec2i, |
| @location(1) @interpolate(flat, either) f35: vec4f, |
| @location(5) f36: vec2u, |
| @location(3) @interpolate(flat, first) f37: vec4u, |
| @location(7) f38: vec2h, |
| @location(10) f39: vec4f, |
| @location(9) f40: vec2i, |
| @location(8) f41: vec2h, |
| @location(15) f42: vec4h, |
| } |
| |
| /* zero global variables used */ |
| @must_use |
| fn fn4(a0: bool) -> array<array<vec2h, 25>, 1> { |
| var out: array<array<vec2h, 25>, 1>; |
| out[bitcast<u32>(asinh(vec2h(unconst_f16(8296.9), unconst_f16(-2872.3))))][unconst_u32(793)] *= vec2h(firstLeadingBit(vec2u(unconst_u32(95), unconst_u32(18)))); |
| vp1 = modf(vec2f(f32(round(unconst_f16(28.08))))); |
| let ptr33 = &vp1; |
| return out; |
| } |
| |
| struct T1 { |
| @size(124) f0: atomic<u32>, |
| @size(176) f1: array<u32>, |
| } |
| |
| var<workgroup> vw18: array<f16, 6>; |
| |
| struct VertexOutput2 { |
| @location(10) f19: vec4f, |
| @location(6) f20: vec4u, |
| @location(7) @interpolate(linear) f21: f32, |
| @location(2) @interpolate(flat, first) f22: f16, |
| @location(13) f23: u32, |
| @location(11) @interpolate(linear) f24: f16, |
| @invariant @builtin(position) f25: vec4f, |
| } |
| |
| struct T0 { |
| @size(112) f0: array<u32>, |
| } |
| |
| /* zero global variables used */ |
| fn fn2() { |
| var vf170 = fn1(); |
| let vf171: vec2h = (*&vw17)[unconst_u32(110)]; |
| let ptr31: ptr<workgroup, f16> = &(*&vw18)[unconst_u32(21)]; |
| vp1 = modf(vec2f(f32((unconst_bool(true) || bool(vp2[0][8].fract))))); |
| { |
| let ptr32: ptr<workgroup, f16> = &(*&vw18)[5]; |
| vw17 -= mat3x2h(vp2[0][8].fract, vp2[0][8].fract, vp2[0][8].fract, vp2[0][8].fract, vp2[0][8].fract, vp2[0][8].fract); |
| var vf172 = fn1(); |
| var vf173: f16 = vw17[unconst_u32(52)][unconst_u32(34)]; |
| var vf174: array<f16, 6> = workgroupUniformLoad(&vw18); |
| vf173 = f16(countLeadingZeros(vec3i(unconst_i32(413), unconst_i32(98), unconst_i32(276))).b); |
| return; |
| } |
| loop { |
| _ = fn1(); |
| _ = fn1(); |
| _ = fn1(); |
| var vf175: vec2h = asinh(vec2h(unconst_f16(-21044.5), unconst_f16(5546.3))); |
| let vf176: vec2f = saturate(vec2f(unconst_f32(0.3988), unconst_f32(0.01553))); |
| vw17 = mat3x2h(vec2h(saturate(vec4f(unconst_f32(0.00578), unconst_f32(0.1738), unconst_f32(0.1272), unconst_f32(0.06751))).xy), vec2h(saturate(vec4f(unconst_f32(0.00578), unconst_f32(0.1738), unconst_f32(0.1272), unconst_f32(0.06751))).bb), vec2h(saturate(vec4f(unconst_f32(0.00578), unconst_f32(0.1738), unconst_f32(0.1272), unconst_f32(0.06751))).ba)); |
| break; |
| } |
| vp1 = modf(vec2f(bitcast<f32>(pack4x8snorm(vec4f(unconst_f32(0.1444), unconst_f32(0.07044), unconst_f32(0.01040), unconst_f32(0.1651)))))); |
| _ = fn1(); |
| vw17 = mat3x2h((*&vw18)[5], (*&vw18)[5], (*&vw18)[5], (*&vw18)[5], (*&vw18)[5], (*&vw18)[5]); |
| _ = fn1(); |
| vw18[unconst_u32(48)] = vw18[unconst_u32(2)]; |
| return; |
| } |
| |
| var<workgroup> vw17: mat3x2h; |
| |
| /* zero global variables used */ |
| @must_use |
| fn fn3(a0: ptr<uniform, mat4x3h>) -> i32 { |
| var out: i32; |
| var vf177: vec4f = trunc(vec4f(unconst_f32(0.04514), unconst_f32(0.2446), unconst_f32(0.06187), unconst_f32(0.06527))); |
| out &= i32(reflect(vec2f(unconst_f32(0.09447), unconst_f32(0.1379)), vec2f(unconst_f32(0.01700), unconst_f32(0.04331))).g); |
| var vf178: vec2u = abs(vec2u(unconst_u32(124), unconst_u32(158))); |
| var vf179: f16 = (*a0)[unconst_u32(5)][unconst_u32(42)]; |
| while bool((vec2i(unconst_i32(297), unconst_i32(142)) << vec2u(unconst_u32(200), unconst_u32(264))).x) { |
| var vf180: vec2f = degrees(vec2f(unconst_f32(0.2072), unconst_f32(0.08339))); |
| out &= i32(abs(vec3h(unconst_f16(8359.9), unconst_f16(6651.9), unconst_f16(2232.8))).z); |
| let vf181: u32 = pack4x8snorm(vec4f(unconst_f32(0.4041), unconst_f32(0.3055), unconst_f32(0.1640), unconst_f32(0.01199))); |
| let vf182: f16 = ceil((*a0)[unconst_i32(2)][2]); |
| var vf183: u32 = pack4x8snorm(vec4f(unconst_f32(0.02603), unconst_f32(0.3189), unconst_f32(0.01619), unconst_f32(0.2446))); |
| break; |
| } |
| var vf184: vec4f = trunc(vec4f(unconst_f32(0.1318), unconst_f32(0.00525), unconst_f32(-0.3796), unconst_f32(0.1966))); |
| vf179 = vec2h(reflect(vec2f(unconst_f32(0.4410), unconst_f32(0.3450)), unpack4x8snorm(unconst_u32(8)).wz))[1]; |
| return out; |
| } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| struct FragmentOutput3 { |
| @location(5) @interpolate(flat) f0: vec2f, |
| @location(4) f1: vec2i, |
| @location(0) f2: vec4u, |
| } |
| |
| /* zero global variables used */ |
| fn fn0(a0: ptr<function, array<array<array<f16, 3>, 1>, 1>>, a1: FragmentOutput3) -> VertexOutput2 { |
| var out: VertexOutput2; |
| out.f21 -= f32(vp2[vec2u(a1.f1)[0]][unconst_u32(205)].fract); |
| let ptr22: ptr<private, f16> = &vp2[unconst_u32(77)][unconst_u32(42)].fract; |
| let vf167: f32 = distance(vec2f(unconst_f32(0.2990), unconst_f32(0.1419)), vec2f(unconst_f32(0.2621), unconst_f32(0.09963))); |
| return out; |
| } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| alias vec3b = vec3<bool>; |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| var<private> vp1 = modf(vec2f(-0.1100, 0.3420)); |
| |
| /* zero global variables used */ |
| @must_use |
| fn fn1() -> FragmentOutput3 { |
| var out: FragmentOutput3; |
| let ptr23: ptr<workgroup, mat3x2h> = &(*&vw17); |
| let ptr24: ptr<workgroup, array<f16, 6>> = &(*&vw18); |
| let ptr25: ptr<private, f16> = &vp2[unconst_u32(88)][8].fract; |
| out.f2 = vec4u((*&vw17)[unconst_i32(1)].xxxy); |
| let ptr26: ptr<private, vec2f> = &vp1.fract; |
| let ptr27: ptr<workgroup, f16> = &(*ptr24)[unconst_u32(154)]; |
| var vf168: f16 = vw17[unconst_u32(131)][unconst_u32(161)]; |
| vp2[0][unconst_u32(47)] = modf(vw17[unconst_u32(33)][unconst_u32(314)]); |
| var vf169: vec3f = round(vec3f(unconst_f32(0.3111), unconst_f32(0.1859), unconst_f32(0.2885))); |
| let ptr28: ptr<workgroup, mat3x2h> = &vw17; |
| let ptr29: ptr<private, f16> = &(*ptr25); |
| let ptr30: ptr<workgroup, mat3x2h> = &vw17; |
| vf169 = vec3f(f32((*ptr24)[5])); |
| return out; |
| } |
| |
| /* zero global variables used */ |
| @vertex |
| fn vertex5(@builtin(instance_index) a0: u32, @location(11) @interpolate(flat, first) a1: vec4i, @location(1) a2: vec2u, @location(12) a3: u32, @location(14) a4: vec2f, @builtin(vertex_index) a5: u32) -> VertexOutput2 { |
| var out: VertexOutput2; |
| switch i32(vp2[0][unconst_u32(29)].fract) { |
| default { |
| for (var it5=u32(asinh(vec3h(unconst_f16(-2218.1), unconst_f16(15679.9), unconst_f16(30115.8))).y); it5<a2[unconst_u32(246)]; it5++) { |
| let vf185: vec2u = a2; |
| break; |
| } |
| break; |
| } |
| } |
| let vf186: u32 = pack2x16snorm(vec2f(unconst_f32(-0.03176), unconst_f32(0.6982))); |
| let ptr34 = &vp2[u32(floor(unconst_f32(0.6386)))]; |
| let ptr35 = &(*ptr34)[8]; |
| var vf187: vec2f = unpack2x16float(unconst_u32(4)); |
| vp2[unconst_u32(17)][unconst_u32(370)].whole = vp2[0][8].whole; |
| out.f25 = vec4f(f32(vp2[unconst_u32(203)][unconst_u32(31)].whole)); |
| var vf188: vec2f = cos(vec2f(unconst_f32(0.3874), unconst_f32(0.3504))); |
| let ptr36 = &(*ptr34)[8]; |
| for (var it6=a3; it6<u32(vp2[0][8].whole); it6++) { |
| var vf189 = fn4(bool(vp2[unconst_u32(289)][unconst_u32(147)].fract)); |
| break; |
| } |
| return out; |
| } |
| |
| /* zero global variables used */ |
| @vertex |
| fn vertex6() -> VertexOutput3 { |
| var out: VertexOutput3; |
| out.f42 -= bitcast<vec4h>(unpack2x16snorm(unconst_u32(637))); |
| out.f42 = vec4h(f16(min(unconst_f32(0.05750), unconst_f32(0.1697)))); |
| _ = fn4(bool(vp2[0][unconst_u32(126)].fract)); |
| let ptr37 = &vp2; |
| out.f27 = (*ptr37)[0][unconst_u32(181)].whole; |
| return out; |
| } |
| |
| /* zero global variables used */ |
| @fragment |
| fn fragment4(@location(12) @interpolate(linear) a0: f32, @location(10) @interpolate(perspective, first) a1: vec4f, @location(11) a2: vec2i, @location(9) @interpolate(flat) a3: vec2i) -> FragmentOutput3 { |
| var out: FragmentOutput3; |
| var vf190 = fn4(bool(unpack2x16float(unconst_u32(107)).y)); |
| if bool(countLeadingZeros(unconst_u32(97))) { |
| let ptr38 = &vp2[unconst_u32(13)][8]; |
| } |
| return out; |
| }`, |
| }); |
| let bindGroup75 = device0.createBindGroup({layout: veryExplicitBindGroupLayout7, entries: [{binding: 41, resource: textureView42}]}); |
| let buffer80 = device0.createBuffer({ |
| size: 12604, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE, |
| }); |
| try { |
| computePassEncoder129.setPipeline(pipeline15); |
| } catch {} |
| try { |
| renderPassEncoder16.setIndexBuffer(buffer17, 'uint16', 168, 184); |
| } catch {} |
| try { |
| commandEncoder161.copyBufferToTexture({ |
| /* bytesInLastRow: 380 widthInBlocks: 95 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 4616 */ |
| offset: 4616, |
| bytesPerRow: 29440, |
| buffer: buffer26, |
| }, { |
| texture: texture92, |
| mipLevel: 0, |
| origin: {x: 61, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 95, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder161.copyTextureToBuffer({ |
| texture: texture107, |
| mipLevel: 0, |
| origin: {x: 7, y: 64, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 44 widthInBlocks: 11 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 68 */ |
| offset: 68, |
| bytesPerRow: 3584, |
| buffer: buffer21, |
| }, {width: 11, height: 48, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| renderPassEncoder44.pushDebugGroup('\u{1f66f}'); |
| } catch {} |
| try { |
| renderPassEncoder44.popDebugGroup(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 25, height: 1, depthOrArrayLayers: 256} |
| */ |
| { |
| source: imageData3, |
| origin: { x: 3, y: 6 }, |
| flipY: true, |
| }, { |
| texture: texture123, |
| mipLevel: 0, |
| origin: {x: 3, y: 0, z: 29}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 10, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup76 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout13, |
| entries: [ |
| {binding: 110, resource: {buffer: buffer18, offset: 256, size: 692}}, |
| {binding: 141, resource: {buffer: buffer31, offset: 512, size: 6880}}, |
| {binding: 52, resource: externalTexture7}, |
| ], |
| }); |
| let pipelineLayout19 = device0.createPipelineLayout({bindGroupLayouts: [recycledExplicitBindGroupLayout2, recycledExplicitBindGroupLayout2]}); |
| let buffer81 = device0.createBuffer({size: 5201, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE, mappedAtCreation: false}); |
| let textureView140 = texture92.createView({dimension: '2d-array'}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder97); computePassEncoder97.dispatchWorkgroups(1, 2); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder108); computePassEncoder108.dispatchWorkgroupsIndirect(buffer30, 372); }; |
| } catch {} |
| try { |
| computePassEncoder128.setPipeline(pipeline1); |
| } catch {} |
| try { |
| commandEncoder161.copyBufferToTexture({ |
| /* bytesInLastRow: 20 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1152 */ |
| offset: 1152, |
| bytesPerRow: 17664, |
| buffer: buffer11, |
| }, { |
| texture: texture52, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 5, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder161.insertDebugMarker('\ubcee'); |
| } catch {} |
| try { |
| adapter0.label = '\u47e9\u{1fe02}\ue52e\ue964\u{1fcff}\u060d'; |
| } catch {} |
| let recycledExplicitBindGroupLayout10 = pipeline14.getBindGroupLayout(0); |
| let commandEncoder162 = device0.createCommandEncoder(); |
| let textureView141 = texture136.createView({baseArrayLayer: 0}); |
| let renderBundleEncoder26 = device0.createRenderBundleEncoder({colorFormats: ['rgba8uint'], depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| renderBundleEncoder26.setBindGroup(2, bindGroup28, new Uint32Array(2230), 644, 1); |
| } catch {} |
| try { |
| renderBundleEncoder26.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderBundleEncoder26.setVertexBuffer(4, buffer32, 0); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| let commandEncoder163 = device0.createCommandEncoder({}); |
| let texture137 = device0.createTexture({ |
| size: [1400, 8, 1], |
| format: 'rgba8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let computePassEncoder130 = commandEncoder162.beginComputePass({timestampWrites: {querySet: querySet5}}); |
| try { |
| computePassEncoder79.setBindGroup(0, bindGroup49, []); |
| } catch {} |
| try { |
| computePassEncoder54.setBindGroup(0, bindGroup62, new Uint32Array(906), 17, 0); |
| } catch {} |
| try { |
| renderPassEncoder15.setBindGroup(2, bindGroup46, new Uint32Array(917), 176, 0); |
| } catch {} |
| try { |
| renderBundleEncoder26.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderBundleEncoder26.setVertexBuffer(0, buffer24); |
| } catch {} |
| try { |
| commandEncoder161.resolveQuerySet(querySet5, 1, 7, buffer47, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer35, 0, new Int16Array(4367), 418, 0); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| if (!arrayBuffer8.detached) { new Uint8Array(arrayBuffer8).fill(0x55); }; |
| } catch {} |
| let bindGroup77 = device0.createBindGroup({layout: veryExplicitBindGroupLayout7, entries: [{binding: 41, resource: textureView38}]}); |
| let commandEncoder164 = device0.createCommandEncoder(); |
| let querySet11 = device0.createQuerySet({label: '\ub457\ud146\u2d20\u0d90\u{1f6b2}', type: 'timestamp', count: 1876}); |
| let textureView142 = texture105.createView({}); |
| let renderBundleEncoder27 = device0.createRenderBundleEncoder({colorFormats: ['rgba8unorm-srgb'], depthReadOnly: true, stencilReadOnly: true}); |
| let externalTexture14 = device0.importExternalTexture({source: videoFrame7}); |
| try { |
| computePassEncoder77.setBindGroup(2, bindGroup54); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder90); computePassEncoder90.dispatchWorkgroupsIndirect(buffer33, 4_448); }; |
| } catch {} |
| try { |
| renderBundleEncoder27.setPipeline(pipeline5); |
| } catch {} |
| let arrayBuffer15 = buffer6.getMappedRange(4472, 0); |
| let bindGroup78 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout3, |
| entries: [ |
| {binding: 52, resource: externalTexture10}, |
| {binding: 110, resource: {buffer: buffer69, offset: 1536, size: 744}}, |
| {binding: 141, resource: {buffer: buffer12, offset: 256}}, |
| ], |
| }); |
| let querySet12 = device0.createQuerySet({type: 'timestamp', count: 11}); |
| let textureView143 = texture6.createView({dimension: '1d'}); |
| let img5 = await imageWithData(26, 40, '#10101010', '#20202020'); |
| let bindGroup79 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout9, |
| entries: [ |
| {binding: 44, resource: externalTexture4}, |
| {binding: 19, resource: externalTexture3}, |
| {binding: 47, resource: {buffer: buffer12, offset: 0}}, |
| {binding: 131, resource: externalTexture1}, |
| {binding: 59, resource: externalTexture3}, |
| ], |
| }); |
| let buffer82 = device0.createBuffer({ |
| size: 8279, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder165 = device0.createCommandEncoder({}); |
| let texture138 = device0.createTexture({ |
| size: {width: 700, height: 4, depthOrArrayLayers: 1}, |
| sampleCount: 4, |
| format: 'rgba8unorm-srgb', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let renderBundleEncoder28 = device0.createRenderBundleEncoder({colorFormats: ['rgba8uint']}); |
| let sampler102 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| minFilter: 'linear', |
| compare: 'less-equal', |
| }); |
| try { |
| computePassEncoder130.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderBundleEncoder26.setBindGroup(1, bindGroup20, new Uint32Array(2748), 2_311, 0); |
| } catch {} |
| try { |
| renderBundleEncoder28.setIndexBuffer(buffer50, 'uint16', 4_108, 5_337); |
| } catch {} |
| try { |
| renderBundleEncoder26.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderBundleEncoder26.setVertexBuffer(4, undefined, 59_941_626); |
| } catch {} |
| try { |
| commandEncoder163.copyBufferToTexture({ |
| /* bytesInLastRow: 588 widthInBlocks: 147 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 2328 */ |
| offset: 2328, |
| rowsPerImage: 12, |
| buffer: buffer52, |
| }, { |
| texture: texture137, |
| mipLevel: 0, |
| origin: {x: 98, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 147, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let commandEncoder166 = device0.createCommandEncoder(); |
| let texture139 = device0.createTexture({ |
| size: {width: 102}, |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| let texture140 = gpuCanvasContext3.getCurrentTexture(); |
| try { |
| renderPassEncoder8.setVertexBuffer(5, buffer30, 0); |
| } catch {} |
| try { |
| renderBundleEncoder27.setBindGroup(1, bindGroup70, [5632]); |
| } catch {} |
| try { |
| renderBundleEncoder27.setBindGroup(0, bindGroup29, new Uint32Array(2013), 341, 1); |
| } catch {} |
| try { |
| renderBundleEncoder27.setPipeline(pipeline5); |
| } catch {} |
| let computePassEncoder131 = commandEncoder163.beginComputePass({timestampWrites: {querySet: querySet7, endOfPassWriteIndex: 38}}); |
| let sampler103 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'mirror-repeat', lodMinClamp: 58.22, lodMaxClamp: 94.62}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder112); computePassEncoder112.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(1, bindGroup73); |
| } catch {} |
| try { |
| renderPassEncoder19.setBindGroup(2, bindGroup73, new Uint32Array(2958), 586, 0); |
| } catch {} |
| try { |
| renderBundleEncoder26.setIndexBuffer(buffer44, 'uint16', 54, 34); |
| } catch {} |
| let commandEncoder167 = device0.createCommandEncoder({}); |
| let textureView144 = texture68.createView({mipLevelCount: 1}); |
| let renderPassEncoder49 = commandEncoder167.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView79, |
| clearValue: { r: -914.9, g: 909.6, b: -979.0, a: 762.8, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet2, |
| }); |
| let sampler104 = device0.createSampler({addressModeV: 'repeat'}); |
| try { |
| computePassEncoder117.setBindGroup(3, bindGroup27, new Uint32Array(131), 33, 0); |
| } catch {} |
| try { |
| computePassEncoder131.setPipeline(pipeline10); |
| } catch {} |
| try { |
| renderPassEncoder33.setBindGroup(3, bindGroup24, new Uint32Array(3068), 538, 1); |
| } catch {} |
| try { |
| renderBundleEncoder26.setBindGroup(0, bindGroup20); |
| } catch {} |
| try { |
| renderBundleEncoder26.drawIndexed(0, 264, 1, 147_518_592, 1_392_566_813); |
| } catch {} |
| try { |
| commandEncoder165.copyBufferToBuffer(buffer8, 3372, buffer32, 1368, 2048); |
| } catch {} |
| try { |
| commandEncoder161.copyTextureToBuffer({ |
| texture: texture126, |
| mipLevel: 0, |
| origin: {x: 43, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 1084 widthInBlocks: 271 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1944 */ |
| offset: 1944, |
| buffer: buffer37, |
| }, {width: 271, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture79, |
| mipLevel: 2, |
| origin: {x: 6, y: 0, z: 1}, |
| aspect: 'all', |
| }, new Uint8Array(2_220).fill(179), /* required buffer size: 2_220 */ |
| {offset: 114, bytesPerRow: 27, rowsPerImage: 39}, {width: 1, height: 0, depthOrArrayLayers: 3}); |
| } catch {} |
| try { |
| gpuCanvasContext3.unconfigure(); |
| } catch {} |
| let recycledExplicitBindGroupLayout11 = pipeline14.getBindGroupLayout(0); |
| let bindGroup80 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout11, |
| entries: [ |
| {binding: 52, resource: externalTexture8}, |
| {binding: 141, resource: {buffer: buffer30, offset: 256, size: 576}}, |
| {binding: 110, resource: {buffer: buffer4, offset: 1280, size: 712}}, |
| ], |
| }); |
| let texture141 = device0.createTexture({ |
| size: {width: 96, height: 1820, depthOrArrayLayers: 898}, |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'r32sint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['r32sint'], |
| }); |
| let textureView145 = texture101.createView({}); |
| try { |
| computePassEncoder42.setBindGroup(0, bindGroup47, new Uint32Array(3789), 490, 0); |
| } catch {} |
| try { |
| computePassEncoder54.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder10.executeBundles([renderBundle1, renderBundle16]); |
| } catch {} |
| try { |
| renderPassEncoder22.setIndexBuffer(buffer49, 'uint32', 1_116, 64); |
| } catch {} |
| try { |
| renderPassEncoder45.setVertexBuffer(4, buffer30, 184); |
| } catch {} |
| try { |
| renderBundleEncoder26.drawIndexedIndirect(buffer66, 1_852); |
| } catch {} |
| try { |
| renderBundleEncoder26.drawIndirect(buffer71, 6_624); |
| } catch {} |
| try { |
| renderBundleEncoder28.setPipeline(pipeline6); |
| } catch {} |
| try { |
| commandEncoder166.copyTextureToBuffer({ |
| texture: texture110, |
| mipLevel: 0, |
| origin: {x: 1637, y: 3, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 2188 widthInBlocks: 547 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1532 */ |
| offset: 1532, |
| bytesPerRow: 5120, |
| buffer: buffer70, |
| }, {width: 547, height: 3, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder166.insertDebugMarker('\u3b7f'); |
| } catch {} |
| document.body.prepend(canvas0); |
| let texture142 = device0.createTexture({ |
| size: [12, 1, 1], |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let computePassEncoder132 = commandEncoder164.beginComputePass({timestampWrites: {querySet: querySet12}}); |
| let renderBundle26 = renderBundleEncoder28.finish({}); |
| try { |
| computePassEncoder84.setBindGroup(0, bindGroup1, []); |
| } catch {} |
| try { |
| renderPassEncoder11.setIndexBuffer(buffer42, 'uint32', 2_772, 1_044); |
| } catch {} |
| try { |
| renderBundleEncoder26.drawIndexed(0, 2, 0, 90_818_124, 813_907_933); |
| } catch {} |
| try { |
| renderBundleEncoder26.setPipeline(pipeline4); |
| } catch {} |
| let arrayBuffer16 = buffer1.getMappedRange(64, 0); |
| try { |
| device0.queue.writeTexture({ |
| texture: texture69, |
| mipLevel: 0, |
| origin: {x: 402, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(26).fill(171), /* required buffer size: 26 */ |
| {offset: 26, bytesPerRow: 1081, rowsPerImage: 52}, {width: 270, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let shaderModule7 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| requires readonly_and_readwrite_storage_textures; |
| |
| enable f16; |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| override override29 = -0.09463; |
| |
| struct VertexOutput5 { |
| @location(14) f48: vec2h, |
| @location(6) @interpolate(perspective, either) f49: vec2f, |
| @builtin(position) f50: vec4f, |
| @location(12) @interpolate(perspective, centroid) f51: f32, |
| @location(5) @interpolate(flat, sample) f52: i32, |
| @location(15) @interpolate(flat, sample) f53: f32, |
| @location(9) @interpolate(flat, center) f54: vec2u, |
| } |
| |
| struct S2 { |
| @location(1) f0: vec4i, |
| } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| /* used global variables: et5 */ |
| fn fn2() -> S2 { |
| var out: S2; |
| out.f0 -= bitcast<vec4i>(normalize(exp(vec3f(f32((unconst_f32(0.2969) <= unconst_f32(0.2051))))).rgbr)); |
| let vf205: u32 = pack4xI8Clamp(bitcast<vec4i>(textureDimensions(et5).yxyy)); |
| fn0(); |
| var vf206: vec4i = unpack4xI8(unconst_u32(10)); |
| var vf207: u32 = pack2x16float(vec2f(unconst_f32(0.3383), unconst_f32(0.2331))); |
| out.f0 -= vec4i(i32(all(unconst_bool(false)))); |
| out.f0 = vec4i(i32(atan2(unconst_f16(10818.6), unconst_f16(5577.0)))); |
| out = S2(bitcast<vec4i>(ldexp(vec3f(unconst_f32(0.3133), unconst_f32(0.2090), unconst_f32(0.06456)), vec3i(i32((unconst_f32(0.04865) <= unconst_f32(0.1888))))).rbrr)); |
| out.f0 *= vec4i(ldexp(vec3f(unconst_f32(0.05978), unconst_f32(0.1308), unconst_f32(-0.2196)), vec3i(unconst_i32(-34), unconst_i32(-150), unconst_i32(32))).zyyx); |
| var vf208 = fn0(); |
| let ptr40: ptr<function, f32> = &vf208[unconst_u32(135)].f1; |
| var vf209 = fn0(); |
| vf207 ^= pack4xI8(vf209[unconst_u32(119)].f0); |
| var vf210 = fn0(); |
| return out; |
| _ = override29; |
| _ = et5; |
| } |
| |
| alias vec3b = vec3<bool>; |
| |
| /* zero global variables used */ |
| fn fn3(a0: VertexOutput4) { |
| switch i32(override29) { |
| default { |
| } |
| } |
| return; |
| _ = override29; |
| } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| /* zero global variables used */ |
| fn fn4(a0: S2, a1: vec4f) -> T0 { |
| var out: T0; |
| var vf211 = fn0(); |
| vf211[1].f1 -= f32(vf211[unconst_u32(251)].f0.r); |
| out = T0(array<i32, 1>(bitcast<vec3i>(exp2(vec3f(unconst_f32(0.2502), unconst_f32(0.1137), unconst_f32(-0.1634))))[0])); |
| var vf212: f16 = distance(vec2h(unconst_f16(4505.6), unconst_f16(8087.3)), vec2h(unconst_f16(1586.2), unconst_f16(1664.9))); |
| vf212 = vec2h((vec2f(unconst_f32(0.2376), unconst_f32(0.1422)) > vec2f(unconst_f32(0.3096), unconst_f32(0.08396)))).r; |
| vf211[1].f0 = firstTrailingBit(vec3i(unconst_i32(221), unconst_i32(9), unconst_i32(327))).gbbb; |
| vf212 -= f16(vf211[unconst_u32(418)].f0[1]); |
| _ = fn0(); |
| let ptr41: ptr<function, f32> = &vf211[1].f1; |
| let ptr42: ptr<function, f32> = &vf211[1].f1; |
| _ = fn0(); |
| _ = fn0(); |
| return out; |
| _ = override29; |
| } |
| |
| struct T0 { |
| f0: array<i32, 1>, |
| } |
| |
| struct VertexOutput4 { |
| @location(8) f43: vec4u, |
| @location(5) @interpolate(linear, either) f44: f32, |
| @invariant @builtin(position) f45: vec4f, |
| @location(1) @interpolate(linear, center) f46: vec2f, |
| @location(15) f47: vec4f, |
| } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| @group(0) @binding(224) var et5: texture_external; |
| |
| /* used global variables: et5 */ |
| fn fn1() -> S2 { |
| var out: S2; |
| out.f0 |= vec4i(log(vec3h(unconst_f16(-14236.6), unconst_f16(5388.7), unconst_f16(5869.0))).zyyx); |
| var vf195 = fn0(); |
| var vf196 = fn0(); |
| out = S2(unpack4xI8(countTrailingZeros(unconst_u32(68)))); |
| fn0(); |
| _ = fn0(); |
| loop { |
| var vf197: f32 = override29; |
| var vf198: i32 = reverseBits(unconst_i32(54)); |
| vf197 += bitcast<vec3f>(((vec3u(unconst_u32(54), unconst_u32(107), unconst_u32(225)) & vec3u(unconst_u32(63), unconst_u32(15), unconst_u32(196))) & vec3u(cross(vec3h(f16(vf198)), vec3h(unconst_f16(4259.8), unconst_f16(-5853.4), unconst_f16(2118.9))))))[1]; |
| fn0(); |
| vf198 = i32(cross(vec3h(unconst_f16(20397.8), unconst_f16(5495.9), unconst_f16(13407.9)), vec3h(unconst_f16(14779.1), unconst_f16(6203.0), unconst_f16(2401.0)))[0]); |
| break; |
| _ = override29; |
| } |
| var vf199: u32 = pack4xU8Clamp(vec4u(unconst_u32(100), unconst_u32(227), unconst_u32(234), unconst_u32(201))); |
| if bool(vf195[1].f0[unconst_u32(75)]) { |
| var vf200: vec2f = unpack2x16unorm(unconst_u32(15)); |
| var vf201: vec2i = insertBits(vec2i(unconst_i32(32), unconst_i32(-142)), vec2i(unconst_i32(6), unconst_i32(35)), unconst_u32(77), unconst_u32(252)); |
| var vf202 = fn0(); |
| out.f0 = vec4i(vf202[unconst_u32(354)].f0[unconst_u32(35)]); |
| var vf203: vec2i = insertBits(vec2i(bitcast<i32>(vf200[vec4u(textureLoad(et5, vec2u(unconst_u32(158), unconst_u32(216))))[1]])), vec2i(unconst_i32(186), unconst_i32(277)), unconst_u32(5), unconst_u32(87)); |
| _ = override29; |
| _ = et5; |
| } |
| vf195[unconst_u32(179)] = FragmentOutput4(bitcast<vec4i>(textureDimensions(et5).rggg), vec2f(textureDimensions(et5))[0]); |
| let vf204: bool = all(unconst_bool(false)); |
| return out; |
| _ = override29; |
| _ = et5; |
| } |
| |
| /* zero global variables used */ |
| fn fn0() -> array<FragmentOutput4, 2> { |
| var out: array<FragmentOutput4, 2>; |
| out[unconst_u32(445)].f0 -= vec4i(refract(vec3h(unconst_f16(2292.9), unconst_f16(8412.2), unconst_f16(9685.0)), step(vec4h(unconst_f16(6627.9), unconst_f16(10482.0), unconst_f16(1302.3), unconst_f16(5311.5)), refract(vec3h(unconst_f16(3160.0), unconst_f16(4427.4), unconst_f16(714.6)), vec3h(unconst_f16(-6674.9), unconst_f16(4836.8), unconst_f16(229.4)), vec3h(mix(vec3f(length(unconst_f32(0.02828))), vec3f(unconst_f32(0.07087), unconst_f32(0.2080), unconst_f32(0.3468)), unconst_f32(0.1502)))[2]).bbbb).grb, unconst_f16(15027.2)).grbg); |
| out[unconst_u32(261)].f0 = bitcast<vec4i>(inverseSqrt(vec3f(unconst_f32(0.2000), unconst_f32(0.1557), unconst_f32(-0.02962))).bbbg); |
| out[unconst_u32(55)].f1 *= bitcast<f32>(dot4I8Packed(unconst_u32(229), unconst_u32(484))); |
| out[1] = FragmentOutput4(vec4i(step(vec4h(unconst_f16(39087.0), unconst_f16(7099.5), unconst_f16(12800.7), unconst_f16(1419.3)), vec4h(unconst_f16(2662.8), unconst_f16(8527.6), unconst_f16(18736.2), unconst_f16(27291.3)))), vec4f(step(vec4h(unconst_f16(39087.0), unconst_f16(7099.5), unconst_f16(12800.7), unconst_f16(1419.3)), vec4h(unconst_f16(2662.8), unconst_f16(8527.6), unconst_f16(18736.2), unconst_f16(27291.3)))).r); |
| var vf191: u32 = pack2x16snorm(vec2f(unconst_f32(0.00852), unconst_f32(0.1045))); |
| var vf192: vec4h = step(vec4h(unconst_f16(983.0), unconst_f16(6049.6), unconst_f16(5566.7), unconst_f16(9011.4)), vec4h(unconst_f16(38.71), unconst_f16(2991.4), unconst_f16(14769.9), unconst_f16(3327.8))); |
| let vf193: i32 = dot4I8Packed(pack2x16snorm(inverseSqrt(vec3f(unconst_f32(0.08704), unconst_f32(0.03003), unconst_f32(0.2032))).yy), unconst_u32(163)); |
| var vf194: vec3h = refract(vec3h(unconst_f16(19960.6), unconst_f16(3183.1), unconst_f16(4029.8)), vec3h(unconst_f16(9143.7), unconst_f16(5383.7), unconst_f16(13502.2)), unconst_f16(1521.0)); |
| vf191 >>= bitcast<u32>(extractBits(unconst_i32(13), unconst_u32(253), unconst_u32(9))); |
| vf191 = u32(fma(vec3h(unconst_f16(14050.8), unconst_f16(-11596.7), unconst_f16(-2919.3)), vec3h(unconst_f16(626.7), unconst_f16(611.5), unconst_f16(5715.1)), vec3h(unconst_f16(1404.4), unconst_f16(6657.0), unconst_f16(1951.8))).g); |
| vf192 -= vec4h(f16(override29)); |
| let ptr39: ptr<function, vec4h> = &vf192; |
| return out; |
| _ = override29; |
| } |
| |
| struct FragmentOutput4 { |
| @location(0) @interpolate(flat) f0: vec4i, |
| @location(2) f1: f32, |
| } |
| |
| /* used global variables: et5 */ |
| @vertex |
| fn vertex7(@location(11) @interpolate(perspective, center) a0: f16, @location(7) a1: f16, @location(8) a2: f32, @location(2) a3: f32, a4: S2, @location(3) a5: vec2u, @builtin(instance_index) a6: u32, @location(15) a7: f32, @location(10) @interpolate(perspective) a8: vec2f) -> VertexOutput4 { |
| var out: VertexOutput4; |
| out.f46 = vec2f(ceil(unconst_f32(0.05191))); |
| for (var it7=bitcast<u32>(a8[unconst_u32(314)]); it7<textureDimensions(et5)[0]; it7++) { |
| var vf213: f16 = sinh(unconst_f16(8229.3)); |
| out.f47 -= atan2(vec2f(unconst_f32(0.02701), unconst_f32(0.08008)), vec2f(unconst_f32(0.3892), unconst_f32(0.04852))).gggg; |
| out.f47 += vec4f(a4.f0); |
| _ = fn1(); |
| out.f46 *= vec2f(max(unconst_f32(0.03563), unconst_f32(-0.00167))); |
| var vf214 = fn1(); |
| _ = override29; |
| _ = et5; |
| } |
| var vf215 = fn1(); |
| var vf216 = fn1(); |
| _ = fn1(); |
| vf215.f0 -= vf216.f0; |
| while bool(a4.f0[0]) { |
| out.f44 = f32(a0); |
| out.f46 *= vec2f((vec2h(unconst_f16(9301.9), unconst_f16(10869.1)) / vec2h(unconst_f16(300.7), unconst_f16(9672.0)))); |
| } |
| var vf217 = fn1(); |
| return out; |
| _ = override29; |
| _ = et5; |
| } |
| |
| /* used global variables: et5 */ |
| @vertex @must_use |
| fn vertex8(@location(13) @interpolate(flat, either) a0: vec4f, @location(0) @interpolate(perspective) a1: vec2f, @location(9) a2: vec4h, @location(4) a3: f16) -> VertexOutput5 { |
| var out: VertexOutput5; |
| var vf218: vec2f = a1; |
| var vf219: vec4f = textureLoad(et5, vec2u(unconst_u32(167), unconst_u32(38))); |
| out.f50 = vec4f(f32(a3)); |
| let vf220: vec2u = textureDimensions(et5); |
| out.f50 -= vec4f(override29); |
| out.f54 = vec2u(vf218); |
| loop { |
| var vf221: u32 = pack2x16float(vec2f(unconst_f32(0.1700), unconst_f32(0.1733))); |
| _ = fn0(); |
| let vf222: vec2u = textureDimensions(et5); |
| fn0(); |
| break; |
| _ = override29; |
| _ = et5; |
| } |
| let vf223: f32 = tanh(unconst_f32(-0.1737)); |
| out.f52 *= clamp(vec2i(unconst_i32(166), unconst_i32(396)), vec2i(unconst_i32(594), unconst_i32(473)), vec2i(unconst_i32(159), unconst_i32(239)))[0]; |
| var vf224 = fn1(); |
| let ptr43: ptr<function, S2> = &vf224; |
| out.f49 = vec2f(vf223); |
| var vf225: bool = all(unconst_bool(false)); |
| return out; |
| _ = override29; |
| _ = et5; |
| } |
| |
| /* used global variables: et5 */ |
| @fragment |
| fn fragment5(@location(8) a0: vec4u) -> FragmentOutput4 { |
| var out: FragmentOutput4; |
| let vf226: vec3h = log2(vec3h(unconst_f16(10056.6), unconst_f16(-1513.7), unconst_f16(10472.6))); |
| _ = fn2(); |
| fn3(VertexOutput4(vec4u(log2(vec3h(unconst_f16(5399.0), unconst_f16(12303.7), unconst_f16(6623.6))).bggr), f32(log2(vec3h(unconst_f16(5399.0), unconst_f16(12303.7), unconst_f16(6623.6)))[0]), vec4f(log2(vec3h(unconst_f16(5399.0), unconst_f16(12303.7), unconst_f16(6623.6))).zxxz), vec2f(log2(vec3h(unconst_f16(5399.0), unconst_f16(12303.7), unconst_f16(6623.6))).yy), vec4f(log2(vec3h(unconst_f16(5399.0), unconst_f16(12303.7), unconst_f16(6623.6))).rgrb))); |
| out.f0 += vec4i(log2(vec3h(unconst_f16(202.9), unconst_f16(8356.7), unconst_f16(8794.1))).bbrr); |
| fn3(VertexOutput4(unpack4xU8(u32(vf226[unconst_u32(176)])), f32(vf226[unconst_u32(176)]), vec4f(f32(vf226[unconst_u32(176)])), vec2f(f32(vf226[unconst_u32(176)])), vec4f(f32(vf226[unconst_u32(176)])))); |
| fn3(VertexOutput4(vec4u(cosh(saturate(vec4h(unconst_f16(1822.0), unconst_f16(10482.3), unconst_f16(9994.7), unconst_f16(16580.0))).zyx).xyzz), f32(cosh(saturate(vec4h(unconst_f16(1822.0), unconst_f16(10482.3), unconst_f16(9994.7), unconst_f16(16580.0))).zyx)[1]), vec4f(cosh(saturate(vec4h(unconst_f16(1822.0), unconst_f16(10482.3), unconst_f16(9994.7), unconst_f16(16580.0))).zyx).gbbr), vec2f(cosh(saturate(vec4h(unconst_f16(1822.0), unconst_f16(10482.3), unconst_f16(9994.7), unconst_f16(16580.0))).zyx).zy), vec4f(cosh(saturate(vec4h(unconst_f16(1822.0), unconst_f16(10482.3), unconst_f16(9994.7), unconst_f16(16580.0))).zyx).yyzz))); |
| _ = fn0(); |
| out.f1 = vec2f(textureDimensions(et5))[0]; |
| out.f1 += f32(insertBits(vec4i(unconst_i32(-242), unconst_i32(140), unconst_i32(119), unconst_i32(238)), vec4i(unconst_i32(162), unconst_i32(157), unconst_i32(151), unconst_i32(-66)), u32(vf226[unconst_u32(109)]), unconst_u32(139)).y); |
| fn0(); |
| out.f0 *= vec4i(saturate(vec4h(unconst_f16(3285.5), unconst_f16(5066.7), unconst_f16(16882.9), unconst_f16(2649.4)))); |
| var vf227: vec3h = vf226; |
| return out; |
| _ = override29; |
| _ = et5; |
| } |
| |
| /* zero global variables used */ |
| @compute @workgroup_size(3, 2, 4) |
| fn compute4(@builtin(local_invocation_id) a0: vec3u) { |
| } |
| |
| /* zero global variables used */ |
| @compute @workgroup_size(1, 3, 2) |
| fn compute5() { |
| var vf228 = fn4(S2(vec4i(i32(round(f16(any(bool(max(vec4h(unconst_f16(33515.0), unconst_f16(40476.2), unconst_f16(34308.4), unconst_f16(2061.1)), vec4h(unconst_f16(11184.2), unconst_f16(1184.5), unconst_f16(29000.0), unconst_f16(7110.4)))[1]))))))), vec4f((vec2i(unconst_i32(6), unconst_i32(196)) <= vec2i(unconst_i32(202), unconst_i32(609))).xyyy)); |
| while bool(exp2(vec3f(unconst_f32(0.05213), unconst_f32(0.03795), unconst_f32(0.07220))).y) { |
| _ = fn4(S2(vec4i(i32(override29))), vec4f(f32((unconst_bool(false) || unconst_bool(false))))); |
| while (unconst_bool(true) || unconst_bool(true)) { |
| break; |
| } |
| var vf229 = fn4(S2(vec4i(tanh(vec3h(unconst_f16(18391.1), unconst_f16(1271.2), unconst_f16(3176.8))).rbrb)), vec4f(bitcast<f32>(pack4xU8Clamp(vec4u(unconst_u32(91), unconst_u32(582), unconst_u32(171), unconst_u32(27)))))); |
| let vf230: vec3h = reflect(vec3h(mix(vec2f(unconst_f32(0.2360), unconst_f32(0.04347)), vec2f(unconst_f32(1.000), unconst_f32(0.2981)), unconst_f32(0.2516)).xyy), vec3h(unconst_f16(1903.0), unconst_f16(4389.0), unconst_f16(2957.5))); |
| break; |
| _ = override29; |
| } |
| let vf231: vec2h = asin(vec2h(unconst_f16(1956.9), unconst_f16(8633.2))); |
| vf228.f0[unconst_u32(8)] *= bitcast<i32>(unpack2x16snorm(unconst_u32(190)).r); |
| var vf232: vec4u = countOneBits(vec4u(unconst_u32(61), unconst_u32(55), unconst_u32(57), unconst_u32(149))); |
| _ = override29; |
| }`, |
| }); |
| let buffer83 = device0.createBuffer({size: 9938, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let commandEncoder168 = device0.createCommandEncoder({}); |
| let querySet13 = device0.createQuerySet({type: 'timestamp', count: 17}); |
| let sampler105 = device0.createSampler({addressModeU: 'repeat', addressModeW: 'mirror-repeat', lodMaxClamp: 87.50}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder51); computePassEncoder51.dispatchWorkgroupsIndirect(buffer51, 424); }; |
| } catch {} |
| try { |
| computePassEncoder132.setPipeline(pipeline10); |
| } catch {} |
| try { |
| renderBundleEncoder26.setBindGroup(3, bindGroup68, []); |
| } catch {} |
| try { |
| renderBundleEncoder26.setVertexBuffer(0, buffer54, 0); |
| } catch {} |
| let videoFrame15 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt709', primaries: 'smpte240m', transfer: 'smpte170m'} }); |
| let recycledExplicitBindGroupLayout12 = pipeline14.getBindGroupLayout(0); |
| let bindGroup81 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout10, |
| entries: [ |
| {binding: 47, resource: {buffer: buffer25, offset: 0, size: 840}}, |
| {binding: 131, resource: externalTexture13}, |
| {binding: 19, resource: externalTexture3}, |
| {binding: 59, resource: externalTexture9}, |
| {binding: 44, resource: externalTexture1}, |
| ], |
| }); |
| let commandEncoder169 = device0.createCommandEncoder(); |
| let textureView146 = texture7.createView({baseMipLevel: 0}); |
| let renderBundle27 = renderBundleEncoder27.finish({}); |
| try { |
| renderPassEncoder6.setVertexBuffer(5, buffer10, 0); |
| } catch {} |
| try { |
| renderBundleEncoder26.setIndexBuffer(buffer65, 'uint16', 1_016, 3_821); |
| } catch {} |
| try { |
| computePassEncoder94.pushDebugGroup('\u0dd0'); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 25, height: 1, depthOrArrayLayers: 256} |
| */ |
| { |
| source: videoFrame8, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture123, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 18}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let videoFrame16 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420', timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte240m', primaries: 'smpteSt4281', transfer: 'iec61966-2-1'} }); |
| let commandEncoder170 = device0.createCommandEncoder({}); |
| let textureView147 = texture119.createView({aspect: 'all'}); |
| let textureView148 = texture55.createView({dimension: '2d-array', aspect: 'all', baseArrayLayer: 0}); |
| try { |
| computePassEncoder82.setBindGroup(0, bindGroup1); |
| } catch {} |
| try { |
| computePassEncoder98.setBindGroup(0, bindGroup4, new Uint32Array(1876), 127, 0); |
| } catch {} |
| try { |
| computePassEncoder97.end(); |
| } catch {} |
| try { |
| renderPassEncoder34.executeBundles([renderBundle2, renderBundle16, renderBundle7, renderBundle0, renderBundle0, renderBundle13]); |
| } catch {} |
| try { |
| renderPassEncoder17.setIndexBuffer(buffer38, 'uint32', 3_372, 380); |
| } catch {} |
| try { |
| renderPassEncoder8.setVertexBuffer(7, buffer12, 0); |
| } catch {} |
| try { |
| renderBundleEncoder26.setVertexBuffer(7, buffer33, 0, 18_495); |
| } catch {} |
| try { |
| commandEncoder170.copyBufferToTexture({ |
| /* bytesInLastRow: 7276 widthInBlocks: 1819 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 2204 */ |
| offset: 2204, |
| bytesPerRow: 7424, |
| buffer: buffer82, |
| }, { |
| texture: texture110, |
| mipLevel: 0, |
| origin: {x: 218, y: 1, z: 0}, |
| aspect: 'all', |
| }, {width: 1819, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| let veryExplicitBindGroupLayout22 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 191, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let commandEncoder171 = device0.createCommandEncoder({}); |
| let texture143 = device0.createTexture({ |
| size: {width: 8}, |
| dimension: '1d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderPassEncoder50 = commandEncoder170.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView29, |
| depthSlice: 14, |
| clearValue: { r: 410.9, g: -530.1, b: 636.6, a: -657.1, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| }); |
| let renderBundleEncoder29 = device0.createRenderBundleEncoder({colorFormats: ['rgba8sint'], depthReadOnly: false}); |
| try { |
| renderBundleEncoder29.setIndexBuffer(buffer17, 'uint32', 52, 74); |
| } catch {} |
| try { |
| renderBundleEncoder29.setVertexBuffer(6, buffer46, 0); |
| } catch {} |
| let bindGroup82 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [ |
| {binding: 19, resource: externalTexture9}, |
| {binding: 131, resource: externalTexture5}, |
| {binding: 44, resource: externalTexture12}, |
| {binding: 47, resource: {buffer: buffer57, offset: 1536, size: 1648}}, |
| {binding: 59, resource: externalTexture11}, |
| ], |
| }); |
| let texture144 = device0.createTexture({ |
| size: [25], |
| dimension: '1d', |
| format: 'rgba8unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView149 = texture123.createView({dimension: '2d', baseArrayLayer: 48}); |
| let computePassEncoder133 = commandEncoder165.beginComputePass({timestampWrites: {querySet: querySet12, beginningOfPassWriteIndex: 5, endOfPassWriteIndex: 8}}); |
| let renderPassEncoder51 = commandEncoder166.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView134, |
| depthSlice: 0, |
| clearValue: { r: 630.1, g: 849.8, b: 947.5, a: 648.0, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| renderPassEncoder31.setIndexBuffer(buffer30, 'uint32', 124, 21); |
| } catch {} |
| try { |
| renderBundleEncoder29.setIndexBuffer(buffer33, 'uint32', 8_536, 1_357); |
| } catch {} |
| try { |
| renderBundleEncoder26.setVertexBuffer(0, buffer32, 264, 140); |
| } catch {} |
| try { |
| buffer7.unmap(); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| let querySet14 = device0.createQuerySet({type: 'timestamp', count: 507}); |
| let textureView150 = texture118.createView({}); |
| let renderPassEncoder52 = commandEncoder168.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView134, |
| depthSlice: 9, |
| clearValue: { r: 126.3, g: 540.6, b: 140.5, a: 843.1, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet2, |
| }); |
| try { |
| computePassEncoder119.setBindGroup(1, bindGroup64); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder108); computePassEncoder108.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| renderPassEncoder47.executeBundles([renderBundle27]); |
| } catch {} |
| try { |
| renderBundleEncoder26.setPipeline(pipeline11); |
| } catch {} |
| try { |
| renderBundleEncoder29.setVertexBuffer(0, buffer82, 0, 1_562); |
| } catch {} |
| try { |
| commandEncoder161.copyBufferToTexture({ |
| /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 948 */ |
| offset: 948, |
| bytesPerRow: 5120, |
| rowsPerImage: 949, |
| buffer: buffer63, |
| }, { |
| texture: texture21, |
| mipLevel: 0, |
| origin: {x: 7, y: 547, z: 0}, |
| aspect: 'all', |
| }, {width: 1, height: 888, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder169.copyTextureToTexture({ |
| texture: texture29, |
| mipLevel: 0, |
| origin: {x: 17, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture38, |
| mipLevel: 0, |
| origin: {x: 0, y: 1, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let buffer84 = device0.createBuffer({ |
| size: 1076, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE, |
| }); |
| let commandEncoder172 = device0.createCommandEncoder(); |
| let computePassEncoder134 = commandEncoder172.beginComputePass({}); |
| let renderPassEncoder53 = commandEncoder169.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView29, |
| depthSlice: 11, |
| clearValue: { r: 837.1, g: 587.7, b: -37.90, a: -326.3, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| }); |
| let renderBundle28 = renderBundleEncoder26.finish(); |
| try { |
| computePassEncoder106.setBindGroup(0, bindGroup63); |
| } catch {} |
| try { |
| computePassEncoder52.setBindGroup(0, bindGroup37, new Uint32Array(632), 182, 0); |
| } catch {} |
| try { |
| renderPassEncoder12.executeBundles([renderBundle5, renderBundle22, renderBundle1]); |
| } catch {} |
| try { |
| renderBundleEncoder29.setBindGroup(2, bindGroup32, new Uint32Array(492), 176, 0); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| colorSpace: 'srgb', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let veryExplicitBindGroupLayout23 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 41, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'r32uint', access: 'read-only', viewDimension: '2d-array' }, |
| }, |
| ], |
| }); |
| let texture145 = device0.createTexture({ |
| size: {width: 700, height: 4, depthOrArrayLayers: 245}, |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView151 = texture70.createView({dimension: '2d-array'}); |
| let computePassEncoder135 = commandEncoder126.beginComputePass({}); |
| let sampler106 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'mirror-repeat'}); |
| try { |
| computePassEncoder133.setPipeline(pipeline10); |
| } catch {} |
| try { |
| renderPassEncoder10.setIndexBuffer(buffer47, 'uint16', 378, 90); |
| } catch {} |
| try { |
| renderPassEncoder35.setVertexBuffer(7, buffer12, 0, 83); |
| } catch {} |
| try { |
| commandEncoder161.copyTextureToTexture({ |
| texture: texture142, |
| mipLevel: 0, |
| origin: {x: 3, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture52, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| } catch {} |
| document.body.append(canvas1); |
| let textureView152 = texture87.createView({dimension: '2d-array', mipLevelCount: 1}); |
| let computePassEncoder136 = commandEncoder171.beginComputePass({}); |
| let renderBundle29 = renderBundleEncoder29.finish({}); |
| try { |
| computePassEncoder119.setBindGroup(3, bindGroup77); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder104); computePassEncoder104.dispatchWorkgroups(2, 1); }; |
| } catch {} |
| try { |
| renderPassEncoder30.beginOcclusionQuery(489); |
| } catch {} |
| try { |
| renderPassEncoder35.setIndexBuffer(buffer26, 'uint32', 2_576, 149); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| commandEncoder161.resolveQuerySet(querySet11, 348, 403, buffer66, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer36, 1096, new Float32Array(21072), 3374, 16); |
| } catch {} |
| let pipeline16 = device0.createRenderPipeline({ |
| layout: pipelineLayout9, |
| fragment: { |
| module: shaderModule5, |
| entryPoint: 'fragment3', |
| constants: {}, |
| targets: [{format: 'rgb10a2uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN}], |
| }, |
| vertex: { |
| module: shaderModule3, |
| constants: {27_645: 1, override9: 1, override3: 1}, |
| buffers: [ |
| { |
| arrayStride: 520, |
| stepMode: 'instance', |
| attributes: [{format: 'unorm16x2', offset: 8, shaderLocation: 14}], |
| }, |
| ], |
| }, |
| primitive: {topology: 'triangle-strip', frontFace: 'cw', cullMode: 'back'}, |
| }); |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let commandEncoder173 = device0.createCommandEncoder(); |
| let textureView153 = texture60.createView({dimension: '2d-array'}); |
| let computePassEncoder137 = commandEncoder161.beginComputePass({timestampWrites: {querySet: querySet4, endOfPassWriteIndex: 15}}); |
| let renderPassEncoder54 = commandEncoder173.beginRenderPass({colorAttachments: [{view: textureView121, loadOp: 'load', storeOp: 'store'}]}); |
| let sampler107 = device0.createSampler({addressModeW: 'mirror-repeat', mipmapFilter: 'nearest', lodMaxClamp: 87.84}); |
| try { |
| computePassEncoder123.setBindGroup(1, bindGroup36, [5376]); |
| } catch {} |
| try { |
| renderPassEncoder41.setBlendConstant({ r: 925.5, g: -670.4, b: 993.2, a: 736.8, }); |
| } catch {} |
| try { |
| renderPassEncoder17.setVertexBuffer(6, buffer53, 0, 2_089); |
| } catch {} |
| await gc(); |
| let autogeneratedBindGroupLayout1 = pipeline7.getBindGroupLayout(0); |
| let bindGroup83 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout12, |
| entries: [{binding: 51, resource: {buffer: buffer22, offset: 3328, size: 3720}}], |
| }); |
| let buffer85 = device0.createBuffer({size: 3204, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM}); |
| let texture146 = device0.createTexture({ |
| size: [5600], |
| dimension: '1d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder21.setBindGroup(0, bindGroup56); |
| } catch {} |
| try { |
| renderPassEncoder1.end(); |
| } catch {} |
| try { |
| renderPassEncoder49.setIndexBuffer(buffer73, 'uint32', 2_144, 234); |
| } catch {} |
| try { |
| renderPassEncoder41.setVertexBuffer(7, buffer40, 4); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| let texture147 = gpuCanvasContext0.getCurrentTexture(); |
| let textureView154 = texture33.createView({label: '\u0ab4\u821c\u{1fd65}\u42d7\u1552\ucac6\u3be5\u08a2\u5923\u088d\u08e8', mipLevelCount: 1}); |
| let renderPassEncoder55 = commandEncoder23.beginRenderPass({colorAttachments: [{view: textureView47, loadOp: 'clear', storeOp: 'discard'}]}); |
| try { |
| computePassEncoder70.setBindGroup(0, bindGroup56, new Uint32Array(9755), 99, 0); |
| } catch {} |
| try { |
| await buffer83.mapAsync(GPUMapMode.WRITE, 1312, 1948); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture70, |
| mipLevel: 0, |
| origin: {x: 121, y: 5, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(199).fill(211), /* required buffer size: 199 */ |
| {offset: 199, rowsPerImage: 100}, {width: 718, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline17 = device0.createComputePipeline({ |
| layout: 'auto', |
| compute: {module: shaderModule4, constants: {override13: 1, override17: 1, 17_018: 1}}, |
| }); |
| let veryExplicitBindGroupLayout24 = device0.createBindGroupLayout({ |
| label: '\u0621\u0464\ude4a', |
| entries: [ |
| { |
| binding: 133, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let commandEncoder174 = device0.createCommandEncoder(); |
| let querySet15 = device0.createQuerySet({type: 'occlusion', count: 277}); |
| let textureView155 = texture69.createView({format: 'rgb10a2uint'}); |
| let sampler108 = device0.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'repeat', lodMaxClamp: 90.99}); |
| try { |
| computePassEncoder134.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder24.setStencilReference(1815); |
| } catch {} |
| try { |
| renderPassEncoder32.setIndexBuffer(buffer30, 'uint16', 668, 39); |
| } catch {} |
| document.body.append(canvas1); |
| let bindGroup84 = device0.createBindGroup({ |
| label: '\ude0d\u00dc\u50b8\u{1fb35}', |
| layout: recycledExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 59, resource: externalTexture11}, |
| {binding: 44, resource: externalTexture0}, |
| {binding: 47, resource: {buffer: buffer64, offset: 2816, size: 3720}}, |
| {binding: 19, resource: externalTexture3}, |
| {binding: 131, resource: externalTexture13}, |
| ], |
| }); |
| let commandEncoder175 = device0.createCommandEncoder(); |
| let texture148 = device0.createTexture({ |
| size: {width: 2800, height: 17, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| sampleCount: 1, |
| format: 'rgba8unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let computePassEncoder138 = commandEncoder174.beginComputePass({timestampWrites: {querySet: querySet7}}); |
| let sampler109 = device0.createSampler({addressModeV: 'repeat', magFilter: 'nearest', mipmapFilter: 'linear', lodMaxClamp: 51.92}); |
| try { |
| computePassEncoder39.setBindGroup(3, bindGroup70, new Uint32Array(611), 198, 1); |
| } catch {} |
| try { |
| renderPassEncoder37.executeBundles([renderBundle1, renderBundle22]); |
| } catch {} |
| try { |
| renderPassEncoder29.setIndexBuffer(buffer40, 'uint32', 32, 67); |
| } catch {} |
| let arrayBuffer17 = buffer15.getMappedRange(136, 24); |
| try { |
| commandEncoder175.copyBufferToTexture({ |
| /* bytesInLastRow: 28 widthInBlocks: 7 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 3716 */ |
| offset: 3716, |
| buffer: buffer3, |
| }, { |
| texture: texture72, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 7, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture64, |
| mipLevel: 0, |
| origin: {x: 0, y: 223, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(487).fill(106), /* required buffer size: 487 */ |
| {offset: 487, bytesPerRow: 67}, {width: 14, height: 10, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 25, height: 1, depthOrArrayLayers: 256} |
| */ |
| { |
| source: videoFrame6, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture123, |
| mipLevel: 0, |
| origin: {x: 4, y: 0, z: 33}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let canvas3 = document.createElement('canvas'); |
| let bindGroup85 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout22, |
| entries: [{binding: 191, resource: {buffer: buffer25, offset: 2816, size: 388}}], |
| }); |
| let pipelineLayout20 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout0]}); |
| let buffer86 = device0.createBuffer({size: 3897, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let textureView156 = texture88.createView({mipLevelCount: 1}); |
| let computePassEncoder139 = commandEncoder175.beginComputePass({}); |
| let sampler110 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'nearest', |
| minFilter: 'linear', |
| lodMaxClamp: 94.18, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder70); computePassEncoder70.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder139.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder23.setBindGroup(1, bindGroup59); |
| } catch {} |
| try { |
| buffer65.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer52, 1208, new BigUint64Array(3106), 332, 68); |
| } catch {} |
| let textureView157 = texture33.createView({dimension: '2d-array', aspect: 'all', mipLevelCount: 1}); |
| try { |
| computePassEncoder136.setPipeline(pipeline13); |
| } catch {} |
| try { |
| renderPassEncoder55.end(); |
| } catch {} |
| try { |
| renderPassEncoder41.setVertexBuffer(3, buffer21, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer16, 3952, new Float32Array(2639), 12, 0); |
| } catch {} |
| let img6 = await imageWithData(9, 105, '#10101010', '#20202020'); |
| let imageData17 = new ImageData(32, 4); |
| let commandEncoder176 = device0.createCommandEncoder({}); |
| let textureView158 = texture55.createView({dimension: '2d-array', baseArrayLayer: 0}); |
| let computePassEncoder140 = commandEncoder23.beginComputePass({}); |
| let renderPassEncoder56 = commandEncoder176.beginRenderPass({ |
| colorAttachments: [{view: textureView37, loadOp: 'clear', storeOp: 'discard'}], |
| occlusionQuerySet: querySet15, |
| timestampWrites: {querySet: querySet7}, |
| maxDrawCount: 540918897, |
| }); |
| let sampler111 = device0.createSampler({ |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 94.60, |
| maxAnisotropy: 20, |
| }); |
| try { |
| computePassEncoder52.setBindGroup(0, bindGroup45); |
| } catch {} |
| try { |
| computePassEncoder108.end(); |
| } catch {} |
| try { |
| computePassEncoder135.setPipeline(pipeline10); |
| } catch {} |
| try { |
| renderPassEncoder30.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder15.executeBundles([renderBundle10, renderBundle10, renderBundle10]); |
| } catch {} |
| try { |
| renderPassEncoder50.setIndexBuffer(buffer28, 'uint16', 3_076, 2_664); |
| } catch {} |
| try { |
| commandEncoder107.copyBufferToTexture({ |
| /* bytesInLastRow: 64 widthInBlocks: 16 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 3700 */ |
| offset: 3700, |
| bytesPerRow: 37376, |
| buffer: buffer70, |
| }, { |
| texture: texture21, |
| mipLevel: 1, |
| origin: {x: 19, y: 200, z: 0}, |
| aspect: 'all', |
| }, {width: 16, height: 529, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| let buffer87 = device0.createBuffer({ |
| size: 1317, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandBuffer10 = commandEncoder107.finish(); |
| let textureView159 = texture121.createView({mipLevelCount: 1}); |
| let sampler112 = device0.createSampler({addressModeU: 'repeat', minFilter: 'linear', mipmapFilter: 'nearest', lodMaxClamp: 87.24}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder114); computePassEncoder114.dispatchWorkgroupsIndirect(buffer22, 3_304); }; |
| } catch {} |
| try { |
| computePassEncoder140.setPipeline(pipeline7); |
| } catch {} |
| let videoFrame17 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX', timestamp: 0, colorSpace: {fullRange: true, matrix: 'unspecified', primaries: 'bt470m', transfer: 'smpte170m'} }); |
| let bindGroup86 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout11, |
| entries: [ |
| {binding: 52, resource: externalTexture13}, |
| {binding: 110, resource: {buffer: buffer57, offset: 0, size: 3712}}, |
| {binding: 141, resource: {buffer: buffer57, offset: 1024, size: 940}}, |
| ], |
| }); |
| let texture149 = device0.createTexture({size: [51], dimension: '1d', format: 'r32sint', usage: GPUTextureUsage.STORAGE_BINDING}); |
| try { |
| computePassEncoder39.setBindGroup(0, bindGroup22, new Uint32Array(346), 93, 0); |
| } catch {} |
| try { |
| computePassEncoder137.setPipeline(pipeline15); |
| } catch {} |
| try { |
| renderPassEncoder17.setIndexBuffer(buffer40, 'uint32', 16, 71); |
| } catch {} |
| let imageBitmap5 = await createImageBitmap(videoFrame4); |
| let buffer88 = device0.createBuffer({ |
| size: 2444, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| try { |
| computePassEncoder47.setBindGroup(0, bindGroup55); |
| } catch {} |
| try { |
| computePassEncoder94.setBindGroup(2, bindGroup76, new Uint32Array(1737), 304, 1); |
| } catch {} |
| try { |
| computePassEncoder138.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderPassEncoder35.setBindGroup(2, bindGroup62); |
| } catch {} |
| try { |
| renderPassEncoder37.beginOcclusionQuery(76); |
| } catch {} |
| try { |
| renderPassEncoder37.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder4.executeBundles([renderBundle29, renderBundle8]); |
| } catch {} |
| try { |
| renderPassEncoder52.setVertexBuffer(1, buffer70); |
| } catch {} |
| let commandEncoder177 = device0.createCommandEncoder(); |
| let computePassEncoder141 = commandEncoder177.beginComputePass({timestampWrites: {querySet: querySet13, beginningOfPassWriteIndex: 12, endOfPassWriteIndex: 9}}); |
| try { |
| computePassEncoder96.setPipeline(pipeline7); |
| } catch {} |
| try { |
| computePassEncoder141.setPipeline(pipeline1); |
| } catch {} |
| let commandEncoder178 = device0.createCommandEncoder(); |
| let querySet16 = device0.createQuerySet({type: 'timestamp', count: 998}); |
| let textureView160 = texture65.createView({baseArrayLayer: 0}); |
| let computePassEncoder142 = commandEncoder178.beginComputePass({timestampWrites: {querySet: querySet3, beginningOfPassWriteIndex: 265, endOfPassWriteIndex: 49}}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder52); computePassEncoder52.dispatchWorkgroupsIndirect(buffer4, 8); }; |
| } catch {} |
| try { |
| renderPassEncoder34.setBindGroup(2, bindGroup2, [0]); |
| } catch {} |
| try { |
| renderPassEncoder23.executeBundles([renderBundle10, renderBundle29]); |
| } catch {} |
| let buffer89 = device0.createBuffer({size: 9566, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE}); |
| let querySet17 = device0.createQuerySet({type: 'occlusion', count: 1247}); |
| let sampler113 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'mirror-repeat', mipmapFilter: 'nearest'}); |
| try { |
| computePassEncoder7.setBindGroup(2, bindGroup50); |
| } catch {} |
| try { |
| computePassEncoder142.setPipeline(pipeline10); |
| } catch {} |
| try { |
| renderPassEncoder26.setIndexBuffer(buffer89, 'uint32', 7_088, 562); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| } catch {} |
| let commandEncoder179 = device0.createCommandEncoder({}); |
| let renderPassEncoder57 = commandEncoder179.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView37, |
| clearValue: { r: 437.6, g: 736.6, b: 367.6, a: 142.9, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| timestampWrites: {querySet: querySet13, beginningOfPassWriteIndex: 14}, |
| }); |
| try { |
| computePassEncoder40.setBindGroup(1, bindGroup59); |
| } catch {} |
| try { |
| renderPassEncoder53.setBindGroup(2, bindGroup9, new Uint32Array(447), 22, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 700, height: 4, depthOrArrayLayers: 71} |
| */ |
| { |
| source: videoFrame6, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture100, |
| mipLevel: 0, |
| origin: {x: 165, y: 0, z: 2}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer90 = device0.createBuffer({size: 25097, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM}); |
| let commandEncoder180 = device0.createCommandEncoder({}); |
| let computePassEncoder143 = commandEncoder180.beginComputePass({}); |
| let sampler114 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 86.60, |
| lodMaxClamp: 96.11, |
| }); |
| try { |
| computePassEncoder143.setPipeline(pipeline15); |
| } catch {} |
| try { |
| renderPassEncoder53.setIndexBuffer(buffer47, 'uint32', 396, 57); |
| } catch {} |
| try { |
| renderPassEncoder10.setVertexBuffer(6, buffer51, 708, 284); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture103, |
| mipLevel: 0, |
| origin: {x: 9, y: 0, z: 1}, |
| aspect: 'all', |
| }, new Uint8Array(11_274).fill(221), /* required buffer size: 11_274 */ |
| {offset: 74, bytesPerRow: 25, rowsPerImage: 64}, {width: 2, height: 0, depthOrArrayLayers: 8}); |
| } catch {} |
| let commandEncoder181 = device0.createCommandEncoder(); |
| let computePassEncoder144 = commandEncoder181.beginComputePass({}); |
| try { |
| computePassEncoder114.end(); |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(3, bindGroup18, []); |
| } catch {} |
| try { |
| renderPassEncoder54.setBlendConstant({ r: 670.6, g: 729.7, b: 723.5, a: -209.6, }); |
| } catch {} |
| try { |
| renderPassEncoder42.setIndexBuffer(buffer0, 'uint16', 1_906, 2_748); |
| } catch {} |
| try { |
| buffer11.unmap(); |
| } catch {} |
| try { |
| computePassEncoder94.popDebugGroup(); |
| } catch {} |
| let gpuCanvasContext4 = canvas3.getContext('webgpu'); |
| let autogeneratedBindGroupLayout2 = pipeline5.getBindGroupLayout(0); |
| let bindGroup87 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout11, |
| entries: [ |
| {binding: 131, resource: externalTexture10}, |
| {binding: 47, resource: {buffer: buffer4, offset: 512, size: 496}}, |
| {binding: 19, resource: externalTexture7}, |
| {binding: 59, resource: externalTexture9}, |
| {binding: 44, resource: externalTexture3}, |
| ], |
| }); |
| let computePassEncoder145 = commandEncoder147.beginComputePass({timestampWrites: {querySet: querySet4}}); |
| try { |
| computePassEncoder128.setBindGroup(1, bindGroup45); |
| } catch {} |
| try { |
| renderPassEncoder6.executeBundles([renderBundle29]); |
| } catch {} |
| try { |
| externalTexture0.label = '\u{1fc36}\u00e1'; |
| } catch {} |
| let bindGroup88 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [ |
| {binding: 59, resource: externalTexture2}, |
| {binding: 19, resource: externalTexture13}, |
| {binding: 47, resource: {buffer: buffer8, offset: 256, size: 4484}}, |
| {binding: 44, resource: externalTexture2}, |
| {binding: 131, resource: externalTexture14}, |
| ], |
| }); |
| try { |
| computePassEncoder145.setPipeline(pipeline8); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let commandEncoder182 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder94.setBindGroup(0, bindGroup5, new Uint32Array(4589), 1_403, 0); |
| } catch {} |
| try { |
| computePassEncoder144.setPipeline(pipeline17); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer2, 472, new Int16Array(8935), 2160, 160); |
| } catch {} |
| let computePassEncoder146 = commandEncoder182.beginComputePass({}); |
| try { |
| computePassEncoder12.setBindGroup(3, bindGroup80, [0]); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder54); computePassEncoder54.dispatchWorkgroupsIndirect(buffer33, 5_036); }; |
| } catch {} |
| try { |
| renderPassEncoder10.setBindGroup(0, bindGroup51); |
| } catch {} |
| try { |
| renderPassEncoder43.setIndexBuffer(buffer24, 'uint16', 24, 341); |
| } catch {} |
| let texture150 = device0.createTexture({ |
| size: {width: 48, height: 910, depthOrArrayLayers: 1}, |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder105.setBindGroup(1, bindGroup19, new Uint32Array(3310), 1_178, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder84); computePassEncoder84.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder51.end(); |
| } catch {} |
| try { |
| computePassEncoder146.setPipeline(pipeline10); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 8, height: 8, depthOrArrayLayers: 11} |
| */ |
| { |
| source: imageData10, |
| origin: { x: 1, y: 4 }, |
| flipY: false, |
| }, { |
| texture: texture125, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 4}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup89 = device0.createBindGroup({layout: autogeneratedBindGroupLayout2, entries: [{binding: 224, resource: externalTexture11}]}); |
| let pipelineLayout21 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout9, veryExplicitBindGroupLayout12]}); |
| let commandEncoder183 = device0.createCommandEncoder({}); |
| let texture151 = device0.createTexture({ |
| size: [25, 1, 22], |
| dimension: '3d', |
| format: 'r16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture152 = device0.createTexture({ |
| size: {width: 25, height: 1, depthOrArrayLayers: 207}, |
| mipLevelCount: 2, |
| dimension: '2d', |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView161 = texture49.createView({dimension: '2d', aspect: 'all', baseArrayLayer: 5}); |
| let computePassEncoder147 = commandEncoder63.beginComputePass({}); |
| try { |
| computePassEncoder100.setBindGroup(0, bindGroup20); |
| } catch {} |
| try { |
| renderPassEncoder32.setVertexBuffer(0, buffer24, 28, 197); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| } catch {} |
| let pipeline18 = device0.createRenderPipeline({ |
| layout: pipelineLayout7, |
| fragment: { |
| module: shaderModule2, |
| targets: [{ |
| format: 'rgba8uint', |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN, |
| }], |
| }, |
| vertex: { |
| module: shaderModule0, |
| entryPoint: 'vertex0', |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 24, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'float32x2', offset: 0, shaderLocation: 9}, |
| {format: 'snorm8x4', offset: 0, shaderLocation: 2}, |
| {format: 'float32x4', offset: 0, shaderLocation: 14}, |
| {format: 'sint8x4', offset: 0, shaderLocation: 3}, |
| {format: 'sint8x4', offset: 4, shaderLocation: 5}, |
| {format: 'sint32x4', offset: 0, shaderLocation: 11}, |
| {format: 'snorm16x2', offset: 0, shaderLocation: 4}, |
| {format: 'unorm16x2', offset: 0, shaderLocation: 1}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-list', frontFace: 'cw', cullMode: 'front', unclippedDepth: false}, |
| }); |
| let veryExplicitBindGroupLayout25 = device0.createBindGroupLayout({entries: []}); |
| let computePassEncoder148 = commandEncoder183.beginComputePass({}); |
| let sampler115 = device0.createSampler({addressModeU: 'mirror-repeat', magFilter: 'nearest', minFilter: 'linear', lodMaxClamp: 92.60}); |
| try { |
| computePassEncoder22.setBindGroup(2, bindGroup86, new Uint32Array(1537), 216, 1); |
| } catch {} |
| try { |
| renderPassEncoder4.executeBundles([renderBundle4, renderBundle8]); |
| } catch {} |
| try { |
| adapter0.label = '\u062c\uec25\ud8ff'; |
| } catch {} |
| let bindGroup90 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout8, |
| entries: [ |
| {binding: 49, resource: {buffer: buffer43, offset: 0, size: 216}}, |
| {binding: 356, resource: textureView63}, |
| {binding: 3, resource: {buffer: buffer60, offset: 0, size: 5328}}, |
| {binding: 322, resource: {buffer: buffer50, offset: 4864, size: 11456}}, |
| {binding: 85, resource: textureView32}, |
| {binding: 52, resource: {buffer: buffer54, offset: 0, size: 32}}, |
| ], |
| }); |
| let commandEncoder184 = device0.createCommandEncoder({}); |
| let renderPassEncoder58 = commandEncoder184.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView134, |
| depthSlice: 0, |
| clearValue: { r: -294.7, g: 984.1, b: 606.6, a: 731.3, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| timestampWrites: {querySet: querySet16, beginningOfPassWriteIndex: 600, endOfPassWriteIndex: 567}, |
| }); |
| try { |
| computePassEncoder64.setBindGroup(1, bindGroup84); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder106); computePassEncoder106.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder52.end(); |
| } catch {} |
| try { |
| computePassEncoder115.insertDebugMarker('\u88c4'); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer10]); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer2, 812, new DataView(new ArrayBuffer(33229)), 4423, 864); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 700, height: 4, depthOrArrayLayers: 71} |
| */ |
| { |
| source: img2, |
| origin: { x: 2, y: 1 }, |
| flipY: true, |
| }, { |
| texture: texture100, |
| mipLevel: 0, |
| origin: {x: 129, y: 0, z: 10}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 34, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder16.label = '\u638d\u03b9\u0c48\u527e\u{1f6fc}\u62b6\u5d4e'; |
| } catch {} |
| let texture153 = device0.createTexture({ |
| size: {width: 48, height: 910, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| dimension: '2d', |
| format: 'rgba8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| renderPassEncoder53.executeBundles([renderBundle2, renderBundle16, renderBundle22, renderBundle13]); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer24, 'uint16', 52, 143); |
| } catch {} |
| let commandEncoder185 = device0.createCommandEncoder({label: '\u0272\u4f59\u{1fcc8}\u7ea2\u{1f9da}\u{1fac4}\u{1ff56}'}); |
| let textureView162 = texture10.createView({dimension: '2d-array', mipLevelCount: 1}); |
| let externalTexture15 = device0.importExternalTexture({source: videoFrame7}); |
| try { |
| computePassEncoder147.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder56.setBindGroup(1, bindGroup43, new Uint32Array(206), 93, 0); |
| } catch {} |
| try { |
| commandEncoder64.copyBufferToBuffer(buffer6, 492, buffer38, 3836, 3844); |
| } catch {} |
| try { |
| commandEncoder64.copyBufferToTexture({ |
| /* bytesInLastRow: 492 widthInBlocks: 123 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 880 */ |
| offset: 880, |
| buffer: buffer50, |
| }, { |
| texture: texture148, |
| mipLevel: 1, |
| origin: {x: 217, y: 3, z: 0}, |
| aspect: 'all', |
| }, {width: 123, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer13, 3328, new DataView(new ArrayBuffer(19719)), 3687, 8060); |
| } catch {} |
| await gc(); |
| let textureView163 = texture107.createView({dimension: '2d-array', format: 'rgba8unorm-srgb', baseMipLevel: 0}); |
| let renderPassEncoder59 = commandEncoder185.beginRenderPass({colorAttachments: [{view: textureView103, loadOp: 'clear', storeOp: 'discard'}]}); |
| try { |
| computePassEncoder116.setBindGroup(1, bindGroup89, new Uint32Array(13), 2, 0); |
| } catch {} |
| let arrayBuffer18 = buffer1.getMappedRange(24, 0); |
| try { |
| device0.queue.writeBuffer(buffer13, 4008, new DataView(new ArrayBuffer(1021)), 165, 52); |
| } catch {} |
| let imageData18 = new ImageData(12, 36); |
| let bindGroup91 = device0.createBindGroup({layout: veryExplicitBindGroupLayout23, entries: [{binding: 41, resource: textureView38}]}); |
| let textureView164 = texture96.createView({}); |
| try { |
| computePassEncoder148.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder28.setBindGroup(3, bindGroup48, new Uint32Array(3966), 51, 0); |
| } catch {} |
| try { |
| renderPassEncoder40.executeBundles([renderBundle16]); |
| } catch {} |
| let bindGroup92 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout3, |
| entries: [ |
| {binding: 19, resource: externalTexture10}, |
| {binding: 59, resource: externalTexture2}, |
| {binding: 47, resource: {buffer: buffer30, offset: 256, size: 468}}, |
| {binding: 131, resource: externalTexture15}, |
| {binding: 44, resource: externalTexture1}, |
| ], |
| }); |
| let textureView165 = texture29.createView({}); |
| let computePassEncoder149 = commandEncoder64.beginComputePass({timestampWrites: {querySet: querySet10, endOfPassWriteIndex: 34}}); |
| try { |
| computePassEncoder47.setBindGroup(1, bindGroup31, new Uint32Array(2509), 632, 0); |
| } catch {} |
| try { |
| computePassEncoder149.setPipeline(pipeline10); |
| } catch {} |
| try { |
| renderPassEncoder46.setBindGroup(1, bindGroup1, new Uint32Array(1361), 232, 0); |
| } catch {} |
| try { |
| device0.pushErrorScope('internal'); |
| } catch {} |
| document.body.prepend(img3); |
| let videoFrame18 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte170m', primaries: 'film', transfer: 'linear'} }); |
| let bindGroup93 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout11, |
| entries: [ |
| {binding: 141, resource: {buffer: buffer22, offset: 512, size: 2500}}, |
| {binding: 110, resource: {buffer: buffer14, offset: 0, size: 696}}, |
| {binding: 52, resource: externalTexture1}, |
| ], |
| }); |
| let buffer91 = device0.createBuffer({ |
| size: 31688, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let textureView166 = texture105.createView({aspect: 'all'}); |
| let sampler116 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'repeat'}); |
| try { |
| computePassEncoder50.setBindGroup(3, bindGroup43, new Uint32Array(771), 89, 0); |
| } catch {} |
| try { |
| renderPassEncoder19.setBindGroup(3, bindGroup61); |
| } catch {} |
| try { |
| renderPassEncoder17.setIndexBuffer(buffer78, 'uint16', 2_610, 805); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture33, |
| mipLevel: 2, |
| origin: {x: 108, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(252).fill(236), /* required buffer size: 252 */ |
| {offset: 252}, {width: 133, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| if (!arrayBuffer18.detached) { new Uint8Array(arrayBuffer18).fill(0x55); }; |
| } catch {} |
| let videoFrame19 = videoFrame0.clone(); |
| let sampler117 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| lodMinClamp: 67.34, |
| lodMaxClamp: 98.77, |
| compare: 'not-equal', |
| }); |
| try { |
| computePassEncoder0.setBindGroup(2, bindGroup29, [1792]); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder82); computePassEncoder82.dispatchWorkgroupsIndirect(buffer60, 720); }; |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer18, 868, new Float32Array(11812), 837, 200); |
| } catch {} |
| let veryExplicitBindGroupLayout26 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 19, visibility: GPUShaderStage.VERTEX, externalTexture: {}}, |
| {binding: 44, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}}, |
| { |
| binding: 47, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| {binding: 59, visibility: GPUShaderStage.COMPUTE, externalTexture: {}}, |
| {binding: 131, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| ], |
| }); |
| let bindGroup94 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout3, |
| entries: [ |
| {binding: 59, resource: externalTexture8}, |
| {binding: 19, resource: externalTexture6}, |
| {binding: 44, resource: externalTexture5}, |
| {binding: 131, resource: externalTexture15}, |
| {binding: 47, resource: {buffer: buffer43, offset: 0, size: 452}}, |
| ], |
| }); |
| let commandEncoder186 = device0.createCommandEncoder({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder42); computePassEncoder42.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder50.setVertexBuffer(2, buffer46, 2_520, 3_451); |
| } catch {} |
| try { |
| commandEncoder186.insertDebugMarker('\ub948'); |
| } catch {} |
| let pipeline19 = device0.createComputePipeline({layout: pipelineLayout8, compute: {module: shaderModule0}}); |
| let bindGroup95 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout18, |
| entries: [{binding: 2, resource: {buffer: buffer91, offset: 0, size: 7996}}], |
| }); |
| let computePassEncoder150 = commandEncoder186.beginComputePass({timestampWrites: {querySet: querySet13, beginningOfPassWriteIndex: 0}}); |
| try { |
| computePassEncoder150.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder51.setIndexBuffer(buffer41, 'uint32', 40, 48); |
| } catch {} |
| let commandEncoder187 = device0.createCommandEncoder({}); |
| let querySet18 = device0.createQuerySet({type: 'timestamp', count: 553}); |
| try { |
| computePassEncoder56.setBindGroup(2, bindGroup54); |
| } catch {} |
| try { |
| renderPassEncoder43.setBindGroup(2, bindGroup12, new Uint32Array(833), 183, 0); |
| } catch {} |
| try { |
| renderPassEncoder49.beginOcclusionQuery(60); |
| } catch {} |
| try { |
| commandEncoder187.copyBufferToTexture({ |
| /* bytesInLastRow: 16 widthInBlocks: 8 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 868 */ |
| offset: 868, |
| bytesPerRow: 1280, |
| rowsPerImage: 1226, |
| buffer: buffer21, |
| }, { |
| texture: texture151, |
| mipLevel: 0, |
| origin: {x: 17, y: 0, z: 10}, |
| aspect: 'all', |
| }, {width: 8, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer65, 1364, new DataView(new ArrayBuffer(5386)), 812, 1956); |
| } catch {} |
| let buffer92 = device0.createBuffer({ |
| size: 7276, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM, |
| }); |
| let commandEncoder188 = device0.createCommandEncoder({}); |
| let textureView167 = texture2.createView({mipLevelCount: 1}); |
| try { |
| computePassEncoder105.setBindGroup(3, bindGroup34, []); |
| } catch {} |
| try { |
| computePassEncoder77.setBindGroup(0, bindGroup89, new Uint32Array(921), 285, 0); |
| } catch {} |
| try { |
| computePassEncoder84.dispatchWorkgroups(2, 2, 1); |
| } catch {} |
| try { |
| renderPassEncoder17.beginOcclusionQuery(116); |
| } catch {} |
| try { |
| renderPassEncoder49.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder27.executeBundles([renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder18.setIndexBuffer(buffer47, 'uint16', 10, 108); |
| } catch {} |
| try { |
| buffer82.unmap(); |
| } catch {} |
| try { |
| commandEncoder187.copyTextureToTexture({ |
| texture: texture62, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture20, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let videoFrame20 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX', timestamp: 0, colorSpace: {fullRange: false, matrix: 'yCgCo', primaries: 'bt470bg', transfer: 'smpteSt4281'} }); |
| try { |
| globalThis.someLabel = externalTexture8.label; |
| } catch {} |
| let bindGroup96 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout24, |
| entries: [{binding: 133, resource: {buffer: buffer26, offset: 512, size: 4488}}], |
| }); |
| let commandEncoder189 = device0.createCommandEncoder(); |
| let texture154 = gpuCanvasContext0.getCurrentTexture(); |
| let computePassEncoder151 = commandEncoder188.beginComputePass({}); |
| let sampler118 = device0.createSampler({addressModeU: 'mirror-repeat'}); |
| let externalTexture16 = device0.importExternalTexture({source: videoFrame13, colorSpace: 'display-p3'}); |
| try { |
| computePassEncoder74.setBindGroup(1, bindGroup16, new Uint32Array(5005), 879, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder40); computePassEncoder40.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder151.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder47.setBindGroup(2, bindGroup52); |
| } catch {} |
| try { |
| renderPassEncoder18.setBindGroup(0, bindGroup24, new Uint32Array(73), 2, 1); |
| } catch {} |
| try { |
| renderPassEncoder6.setVertexBuffer(0, undefined, 112_119_992, 278_506_074); |
| } catch {} |
| let bindGroup97 = device0.createBindGroup({layout: veryExplicitBindGroupLayout25, entries: []}); |
| try { |
| computePassEncoder78.setBindGroup(0, bindGroup1, new Uint32Array(361), 76, 0); |
| } catch {} |
| try { |
| renderPassEncoder52.beginOcclusionQuery(16); |
| } catch {} |
| try { |
| renderPassEncoder50.executeBundles([renderBundle9]); |
| } catch {} |
| try { |
| renderPassEncoder44.setIndexBuffer(buffer28, 'uint16', 2_884, 241); |
| } catch {} |
| try { |
| buffer90.unmap(); |
| } catch {} |
| try { |
| globalThis.someLabel = commandEncoder87.label; |
| } catch {} |
| let commandEncoder190 = device0.createCommandEncoder({}); |
| let textureView168 = texture75.createView({}); |
| let texture155 = device0.createTexture({ |
| size: {width: 25, height: 1, depthOrArrayLayers: 1}, |
| sampleCount: 4, |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| let computePassEncoder152 = commandEncoder187.beginComputePass({}); |
| let renderPassEncoder60 = commandEncoder190.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView134, |
| depthSlice: 1, |
| clearValue: { r: -927.1, g: -511.1, b: 564.4, a: 171.4, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet15, |
| maxDrawCount: 65283592, |
| }); |
| try { |
| computePassEncoder152.setPipeline(pipeline17); |
| } catch {} |
| try { |
| renderPassEncoder60.setBindGroup(3, bindGroup87, new Uint32Array(2690), 195, 0); |
| } catch {} |
| try { |
| renderPassEncoder48.setVertexBuffer(2, buffer29, 0, 763); |
| } catch {} |
| try { |
| device0.pushErrorScope('validation'); |
| } catch {} |
| try { |
| commandEncoder189.copyTextureToBuffer({ |
| texture: texture24, |
| mipLevel: 1, |
| origin: {x: 1117, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 176 widthInBlocks: 44 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 4512 */ |
| offset: 4512, |
| bytesPerRow: 39168, |
| rowsPerImage: 200, |
| buffer: buffer32, |
| }, {width: 44, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let commandEncoder191 = device0.createCommandEncoder({}); |
| let texture156 = device0.createTexture({ |
| label: '\u5695\u{1f93c}\u{1fac0}\ud8c3', |
| size: [5600], |
| dimension: '1d', |
| format: 'rgba8uint', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderPassEncoder61 = commandEncoder191.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView109, |
| clearValue: { r: 692.7, g: -962.0, b: -287.9, a: 338.6, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet17, |
| maxDrawCount: 445850383, |
| }); |
| try { |
| renderPassEncoder53.setBindGroup(0, bindGroup28, [0]); |
| } catch {} |
| try { |
| renderPassEncoder17.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder25.setViewport(795.7380093353968, 17.00500730418102, 3659.9363507609146, 4.1455358607424175, 0.3111585454582547, 0.8582695110303208); |
| } catch {} |
| try { |
| commandEncoder189.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 2104 */ |
| offset: 2104, |
| buffer: buffer73, |
| }, { |
| texture: texture100, |
| mipLevel: 0, |
| origin: {x: 59, y: 1, z: 6}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let promise28 = device0.queue.onSubmittedWorkDone(); |
| try { |
| await promise28; |
| } catch {} |
| let veryExplicitBindGroupLayout27 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 133, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let bindGroup98 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [ |
| {binding: 44, resource: externalTexture6}, |
| {binding: 19, resource: externalTexture5}, |
| {binding: 131, resource: externalTexture2}, |
| {binding: 59, resource: externalTexture4}, |
| {binding: 47, resource: {buffer: buffer5, offset: 512, size: 6920}}, |
| ], |
| }); |
| let renderPassEncoder62 = commandEncoder189.beginRenderPass({colorAttachments: [{view: textureView164, depthSlice: 123, loadOp: 'clear', storeOp: 'discard'}]}); |
| let sampler119 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| maxAnisotropy: 1, |
| }); |
| try { |
| renderPassEncoder19.setBindGroup(2, bindGroup45, new Uint32Array(371), 22, 0); |
| } catch {} |
| let buffer93 = device0.createBuffer({ |
| size: 1237, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE, |
| }); |
| let sampler120 = device0.createSampler({addressModeU: 'repeat', mipmapFilter: 'nearest', lodMaxClamp: 99.70}); |
| try { |
| computePassEncoder92.setBindGroup(0, bindGroup80, [0]); |
| } catch {} |
| try { |
| computePassEncoder58.setBindGroup(0, bindGroup33, new Uint32Array(56), 4, 0); |
| } catch {} |
| try { |
| renderPassEncoder52.endOcclusionQuery(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 25, height: 1, depthOrArrayLayers: 256} |
| */ |
| { |
| source: videoFrame16, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture123, |
| mipLevel: 0, |
| origin: {x: 5, y: 0, z: 32}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer94 = device0.createBuffer({size: 7419, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE}); |
| let renderBundleEncoder30 = device0.createRenderBundleEncoder({colorFormats: ['rgba8sint'], depthReadOnly: true}); |
| try { |
| computePassEncoder141.setBindGroup(0, bindGroup82); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder144); computePassEncoder144.dispatchWorkgroupsIndirect(buffer22, 1_696); }; |
| } catch {} |
| try { |
| renderBundleEncoder30.setBindGroup(0, bindGroup43); |
| } catch {} |
| try { |
| renderBundleEncoder30.setVertexBuffer(4, buffer13, 0, 1_008); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer33, 4384, new BigUint64Array(31760), 7206, 656); |
| } catch {} |
| let commandEncoder192 = device0.createCommandEncoder({}); |
| let querySet19 = device0.createQuerySet({type: 'occlusion', count: 450}); |
| let computePassEncoder153 = commandEncoder192.beginComputePass(); |
| let renderBundle30 = renderBundleEncoder30.finish(); |
| try { |
| computePassEncoder130.setBindGroup(1, bindGroup96); |
| } catch {} |
| try { |
| computePassEncoder94.setBindGroup(0, bindGroup43, new Uint32Array(2133), 122, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder12); computePassEncoder12.dispatchWorkgroupsIndirect(buffer46, 15_756); }; |
| } catch {} |
| try { |
| renderPassEncoder43.executeBundles([renderBundle10, renderBundle4, renderBundle30, renderBundle10, renderBundle10]); |
| } catch {} |
| let arrayBuffer19 = buffer1.getMappedRange(72, 0); |
| try { |
| buffer78.unmap(); |
| } catch {} |
| try { |
| globalThis.someLabel = externalTexture4.label; |
| } catch {} |
| let commandEncoder193 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder153.setPipeline(pipeline13); |
| } catch {} |
| try { |
| renderPassEncoder14.executeBundles([renderBundle29]); |
| } catch {} |
| try { |
| renderPassEncoder17.setIndexBuffer(buffer50, 'uint32', 700, 7_636); |
| } catch {} |
| try { |
| device0.pushErrorScope('out-of-memory'); |
| } catch {} |
| try { |
| gpuCanvasContext3.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| let buffer95 = device0.createBuffer({size: 5139, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX}); |
| let renderPassEncoder63 = commandEncoder193.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView164, |
| depthSlice: 575, |
| clearValue: { r: 334.7, g: -336.6, b: 201.1, a: -146.3, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| renderPassEncoder56.executeBundles([renderBundle4]); |
| } catch {} |
| try { |
| renderPassEncoder13.setVertexBuffer(0, buffer10, 0); |
| } catch {} |
| try { |
| computePassEncoder34.insertDebugMarker('\u65be'); |
| } catch {} |
| let imageBitmap6 = await createImageBitmap(img0); |
| let bindGroup99 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout22, |
| entries: [{binding: 191, resource: {buffer: buffer85, offset: 0}}], |
| }); |
| let sampler121 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 99.58, |
| compare: 'greater', |
| maxAnisotropy: 11, |
| }); |
| try { |
| computePassEncoder34.setBindGroup(0, bindGroup11, new Uint32Array(266), 15, 0); |
| } catch {} |
| try { |
| computePassEncoder84.end(); |
| } catch {} |
| try { |
| renderPassEncoder13.setIndexBuffer(buffer88, 'uint32', 432, 618); |
| } catch {} |
| try { |
| renderPassEncoder19.setVertexBuffer(7, buffer87, 0, 49); |
| } catch {} |
| let commandEncoder194 = device0.createCommandEncoder({}); |
| let textureView169 = texture127.createView({dimension: '2d-array', mipLevelCount: 2, arrayLayerCount: 6}); |
| let computePassEncoder154 = commandEncoder59.beginComputePass({}); |
| try { |
| computePassEncoder19.setBindGroup(0, bindGroup18); |
| } catch {} |
| try { |
| computePassEncoder154.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder30.setBindGroup(1, bindGroup84, new Uint32Array(3080), 352, 0); |
| } catch {} |
| try { |
| renderPassEncoder52.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder35.setVertexBuffer(2, buffer30, 0, 412); |
| } catch {} |
| try { |
| commandEncoder194.copyBufferToTexture({ |
| /* bytesInLastRow: 72 widthInBlocks: 18 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 112 */ |
| offset: 112, |
| buffer: buffer10, |
| }, { |
| texture: texture14, |
| mipLevel: 0, |
| origin: {x: 6, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 18, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder194.copyTextureToBuffer({ |
| texture: texture52, |
| mipLevel: 0, |
| origin: {x: 10, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 72 widthInBlocks: 18 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 3032 */ |
| offset: 3032, |
| bytesPerRow: 5120, |
| buffer: buffer23, |
| }, {width: 18, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 2800, height: 17, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData7, |
| origin: { x: 0, y: 7 }, |
| flipY: false, |
| }, { |
| texture: texture148, |
| mipLevel: 0, |
| origin: {x: 289, y: 4, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| videoFrame0.close(); |
| videoFrame1.close(); |
| videoFrame2.close(); |
| videoFrame3.close(); |
| videoFrame5.close(); |
| videoFrame6.close(); |
| videoFrame8.close(); |
| videoFrame9.close(); |
| videoFrame10.close(); |
| videoFrame11.close(); |
| videoFrame12.close(); |
| videoFrame13.close(); |
| videoFrame15.close(); |
| videoFrame16.close(); |
| videoFrame17.close(); |
| videoFrame18.close(); |
| videoFrame19.close(); |
| videoFrame20.close(); |
| } |
| |
| onload = async () => { |
| try { |
| let sharedScript = document.querySelector('#shared').textContent; |
| |
| let workers = [ |
| |
| ]; |
| let promises = [ window0() ]; |
| log('promises created'); |
| let results = await Promise.allSettled(promises); |
| for (let result of results) { |
| if (result.status === 'rejected') { throw result.reason; } |
| } |
| log('the end') |
| log(location); |
| } catch (e) { |
| log('error'); |
| log(e); |
| log(e[Symbol.toStringTag]); |
| log(e.stack); |
| if (e instanceof GPUPipelineError) { |
| log(`${e} - ${e.reason}`); |
| |
| } else if (e instanceof DOMException) { |
| if (e.name === 'OperationError') { |
| log(e.message); |
| |
| } else if (e.name === 'InvalidStateError') { |
| } else { |
| log(e); |
| |
| } |
| } else if (e instanceof GPUValidationError) { |
| |
| } else if (e instanceof GPUOutOfMemoryError) { |
| |
| } else if (e instanceof TypeError) { |
| log(e); |
| |
| } else { |
| log('unexpected error type'); |
| log(e); |
| |
| } |
| } |
| debug('Pass') |
| globalThis.testRunner?.notifyDone(); |
| }; |
| </script> |
| |
