| <style> |
| :root { background: #102030e0; color: #99ddbbcc; font-size: 15px; } |
| </style> |
| <script src="../../../resources/js-test-pre.js"></script> |
| <script> |
| globalThis.testRunner?.dumpAsText(); |
| globalThis.testRunner?.waitUntilDone(); |
| |
| function log(label) { |
| } |
| |
| function gc() { |
| if (globalThis.GCController) { |
| globalThis.GCController.collect(); |
| } else if (globalThis.$vm) { |
| globalThis.$vm.gc(); |
| } else { |
| log('no GC available'); |
| } |
| } |
| |
| /** |
| * @param {GPUDevice} device |
| */ |
| function pseudoSubmit(device) { |
| for (let i = 0; i < 63; i++) { |
| device.createCommandEncoder(); |
| } |
| } |
| |
| /** |
| * @param {GPUDevice} device |
| * @param {GPUBuffer} buffer |
| */ |
| function dissociateBuffer(device, buffer) { |
| let commandEncoder = device.createCommandEncoder(); |
| if (buffer.usage & GPUBufferUsage.COPY_DST) { |
| let writeBuffer = device.createBuffer({size: 16, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| commandEncoder.copyBufferToBuffer(writeBuffer, 0, buffer, 0, 0); |
| } else if (buffer.usage & GPUBufferUsage.COPY_SRC) { |
| let readBuffer = device.createBuffer({size: 16, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| commandEncoder.copyBufferToBuffer(buffer, 0, readBuffer, 0, 0); |
| } |
| } |
| |
| /** |
| * @template {any} T |
| * @param {GPUDevice} device |
| * @param {string} label |
| * @param {()=>T} payload |
| * @returns {Promise<T>} |
| */ |
| async function validationWrapper(device, label, payload) { |
| device.pushErrorScope('internal'); |
| device.pushErrorScope('out-of-memory'); |
| device.pushErrorScope('validation'); |
| let result = payload(); |
| let validationError = await device.popErrorScope(); |
| let outOfMemoryError = await device.popErrorScope(); |
| let internalError = await device.popErrorScope(); |
| let error = validationError ?? outOfMemoryError ?? internalError; |
| if (error) { |
| log('*'.repeat(25)); |
| log(error[Symbol.toStringTag]); |
| log(error.message); |
| log(label); |
| if (error.stack != `_`) { |
| log(error.stack); |
| } |
| log(location); |
| log('*'.repeat(25)); |
| throw error; |
| } |
| return result; |
| } |
| |
| /** |
| * @returns {Promise<HTMLVideoElement>} |
| */ |
| function videoWithData() { |
| const veryBrightVideo = `data:video/mp4;base64,AAAAHGZ0eXBpc29tAAACAGlzb21pc28ybXA0MQAAAAhmcmVlAAAAvG1kYXQAAAAfTgEFGkdWStxcTEM/lO/FETzRQ6gD7gAA7gIAA3EYgAAAAEgoAa8iNjAkszOL+e58c//cEe//0TT//scp1n/381P/RWP/zOW4QtxorfVogeh8nQDbQAAAAwAQMCcWUTAAAAMAAAMAAAMA84AAAAAVAgHQAyu+KT35E7gAADFgAAADABLQAAAAEgIB4AiS76MTkNbgAAF3AAAPSAAAABICAeAEn8+hBOTXYAADUgAAHRAAAAPibW9vdgAAAGxtdmhkAAAAAAAAAAAAAAAAAAAD6AAAAKcAAQAAAQAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAw10cmFrAAAAXHRraGQAAAADAAAAAAAAAAAAAAABAAAAAAAAAKcAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAABAAAAAABAAAAAQAAAAAAAkZWR0cwAAABxlbHN0AAAAAAAAAAEAAACnAAAAAAABAAAAAAKFbWRpYQAAACBtZGhkAAAAAAAAAAAAAAAAAABdwAAAD6BVxAAAAAAAMWhkbHIAAAAAAAAAAHZpZGUAAAAAAAAAAAAAAABDb3JlIE1lZGlhIFZpZGVvAAAAAixtaW5mAAAAFHZtaGQAAAABAAAAAAAAAAAAAAAkZGluZgAAABxkcmVmAAAAAAAAAAEAAAAMdXJsIAAAAAEAAAHsc3RibAAAARxzdHNkAAAAAAAAAAEAAAEMaHZjMQAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAQABAASAAAAEgAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABj//wAAAHVodmNDAQIgAAAAsAAAAAAAPPAA/P36+gAACwOgAAEAGEABDAH//wIgAAADALAAAAMAAAMAPBXAkKEAAQAmQgEBAiAAAAMAsAAAAwAAAwA8oBQgQcCTDLYgV7kWVYC1CRAJAICiAAEACUQBwChkuNBTJAAAAApmaWVsAQAAAAATY29scm5jbHgACQAQAAkAAAAAEHBhc3AAAAABAAAAAQAAABRidHJ0AAAAAAAALPwAACz8AAAAKHN0dHMAAAAAAAAAAwAAAAIAAAPoAAAAAQAAAAEAAAABAAAD6AAAABRzdHNzAAAAAAAAAAEAAAABAAAAEHNkdHAAAAAAIBAQGAAAAChjdHRzAAAAAAAAAAMAAAABAAAAAAAAAAEAAAfQAAAAAgAAAAAAAAAcc3RzYwAAAAAAAAABAAAAAQAAAAQAAAABAAAAJHN0c3oAAAAAAAAAAAAAAAQAAABvAAAAGQAAABYAAAAWAAAAFHN0Y28AAAAAAAAAAQAAACwAAABhdWR0YQAAAFltZXRhAAAAAAAAACFoZGxyAAAAAAAAAABtZGlyYXBwbAAAAAAAAAAAAAAAACxpbHN0AAAAJKl0b28AAAAcZGF0YQAAAAEAAAAATGF2ZjYwLjMuMTAw`; |
| let video = document.createElement('video'); |
| video.src = veryBrightVideo; |
| return new Promise(resolve => { |
| video.onloadeddata = () => { |
| resolve(video); |
| }; |
| }); |
| } |
| |
| /** |
| * @returns {Promise<string>} |
| */ |
| async function makeDataUrl(width, height, color0, color1) { |
| let offscreenCanvas = new OffscreenCanvas(width, height); |
| let ctx = offscreenCanvas.getContext('2d'); |
| let gradient = ctx.createLinearGradient(0, 0, width, height); |
| gradient.addColorStop(0, color0); |
| gradient.addColorStop(0.1, color1); |
| gradient.addColorStop(0.3, color0); |
| gradient.addColorStop(0.7, color1); |
| gradient.addColorStop(0.9, color0); |
| gradient.addColorStop(1, color1); |
| ctx.fillStyle = gradient; |
| ctx.fillRect(0, 0, width, height); |
| let blob = await offscreenCanvas.convertToBlob(); |
| let fileReader = new FileReader(); |
| fileReader.readAsDataURL(blob); |
| return new Promise(resolve => { |
| fileReader.onload = () => { |
| resolve(fileReader.result); |
| }; |
| }); |
| } |
| |
| async function imageWithData(width, height, color0, color1) { |
| let dataUrl = await makeDataUrl(width, height, color0, color1); |
| let img = document.createElement('img'); |
| img.src = dataUrl; |
| await img.decode(); |
| return img; |
| } |
| |
| onload = async () => { |
| try { |
| let adapter0 = await navigator.gpu.requestAdapter({}); |
| let device0 = await adapter0.requestDevice({ |
| label: '\u4860\u{1ff2d}\u0147\u{1fa91}', |
| requiredFeatures: [ |
| 'depth-clip-control', |
| 'depth32float-stencil8', |
| 'texture-compression-etc2', |
| 'texture-compression-astc', |
| 'indirect-first-instance', |
| 'shader-f16', |
| 'rg11b10ufloat-renderable', |
| 'bgra8unorm-storage', |
| ], |
| requiredLimits: { |
| maxBindGroups: 4, |
| maxColorAttachmentBytesPerSample: 45, |
| maxVertexAttributes: 18, |
| maxVertexBufferArrayStride: 45434, |
| maxStorageTexturesPerShaderStage: 5, |
| maxStorageBuffersPerShaderStage: 28, |
| maxDynamicStorageBuffersPerPipelineLayout: 65239, |
| maxDynamicUniformBuffersPerPipelineLayout: 38362, |
| maxBindingsPerBindGroup: 7670, |
| maxTextureArrayLayers: 793, |
| maxTextureDimension1D: 14728, |
| maxTextureDimension2D: 15163, |
| maxBindGroupsPlusVertexBuffers: 25, |
| minUniformBufferOffsetAlignment: 32, |
| maxUniformBufferBindingSize: 35992523, |
| maxStorageBufferBindingSize: 170485015, |
| maxUniformBuffersPerShaderStage: 24, |
| maxSampledTexturesPerShaderStage: 20, |
| maxInterStageShaderVariables: 42, |
| maxInterStageShaderComponents: 86, |
| maxSamplersPerShaderStage: 21, |
| }, |
| }); |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| let canvas0 = document.createElement('canvas'); |
| let commandEncoder0 = device0.createCommandEncoder({label: '\u0c87\u4fef\u2422\u638e\u{1ffec}\u0d67\ua0e2\u{1fafe}\u5e6d\u{1fefb}'}); |
| let texture0 = device0.createTexture({ |
| label: '\ufaf3\u00c9\u6cc6\u42f9\u6c2e\u02a8\u4cce\ucb14', |
| size: [1296, 60, 41], |
| mipLevelCount: 11, |
| sampleCount: 1, |
| format: 'astc-12x10-unorm', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| let textureView0 = texture0.createView({ |
| label: '\ud69e\u{1fc85}\u{1fc6f}\u3b4e\u3a90\u2221\u644b\uc6cb\u0e8a', |
| format: 'astc-12x10-unorm', |
| baseMipLevel: 4, |
| mipLevelCount: 6, |
| baseArrayLayer: 7, |
| arrayLayerCount: 12, |
| }); |
| try { |
| device0.queue.writeTexture({ |
| texture: texture0, |
| mipLevel: 1, |
| origin: {x: 216, y: 0, z: 2}, |
| aspect: 'all', |
| }, new DataView(new ArrayBuffer(80)), /* required buffer size: 1_036_983 */ |
| {offset: 973, bytesPerRow: 274, rowsPerImage: 270}, {width: 12, height: 20, depthOrArrayLayers: 15}); |
| } catch {} |
| let offscreenCanvas0 = new OffscreenCanvas(1628, 2139); |
| let video0 = await videoWithData(); |
| let texture1 = device0.createTexture({ |
| label: '\u34b1\u0152\u{1f93e}', |
| size: {width: 640, height: 64, depthOrArrayLayers: 302}, |
| mipLevelCount: 2, |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let textureView1 = texture0.createView({dimension: '2d', baseMipLevel: 9, baseArrayLayer: 35}); |
| let computePassEncoder0 = commandEncoder0.beginComputePass(); |
| try { |
| await device0.popErrorScope(); |
| } catch {} |
| let gpuCanvasContext0 = offscreenCanvas0.getContext('webgpu'); |
| let querySet0 = device0.createQuerySet({type: 'occlusion', count: 2850}); |
| let renderBundleEncoder0 = device0.createRenderBundleEncoder({ |
| colorFormats: ['r16uint', 'rgba16uint', 'rg16sint', 'r8sint', 'rg32uint', 'rg8unorm', 'rgb10a2unorm'], |
| sampleCount: 4, |
| depthReadOnly: true, |
| stencilReadOnly: true, |
| }); |
| let canvas1 = document.createElement('canvas'); |
| let querySet1 = device0.createQuerySet({label: '\u{1f845}\u{1f812}\u{1f6bf}\u09e3\ufc82\uaf29\u0ecc', type: 'occlusion', count: 338}); |
| try { |
| gpuCanvasContext0.configure({device: device0, format: 'bgra8unorm', usage: GPUTextureUsage.STORAGE_BINDING, colorSpace: 'srgb'}); |
| } catch {} |
| let videoFrame0 = new VideoFrame(offscreenCanvas0, {timestamp: 0}); |
| let textureView2 = texture0.createView({ |
| label: '\u08f3\u{1ff8e}\u8259\u0c3b\u{1f6d1}\u05ca', |
| baseMipLevel: 5, |
| mipLevelCount: 4, |
| baseArrayLayer: 12, |
| arrayLayerCount: 20, |
| }); |
| let renderBundle0 = renderBundleEncoder0.finish({label: '\uea89\u2291\u{1f892}\ue403'}); |
| let offscreenCanvas1 = new OffscreenCanvas(165, 394); |
| let bindGroupLayout0 = device0.createBindGroupLayout({ |
| label: '\u{1fc8b}\u912f\u2be0\u5333\ud46a', |
| entries: [{binding: 5545, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, externalTexture: {}}], |
| }); |
| let pipelineLayout0 = device0.createPipelineLayout({ |
| label: '\u0fca\ue3c1\u4f80\u{1f982}\ud88c\u5814\u03dc\u096a\u6c9d\u0dd0\u{1f9bd}', |
| bindGroupLayouts: [bindGroupLayout0, bindGroupLayout0, bindGroupLayout0], |
| }); |
| let commandEncoder1 = device0.createCommandEncoder({label: '\u{1f62a}\u2f4f\u{1fd73}\u{1fad3}\u0d1d'}); |
| let commandBuffer0 = commandEncoder1.finish({label: '\u23b2\ua964\ua35e\u0851\u6750\u425c\u{1fc82}'}); |
| let texture2 = device0.createTexture({ |
| label: '\u0966\u054b\u73a1\u{1fa6e}\u0283\ueb06\u{1fc8b}\uf6d1', |
| size: [324, 15, 138], |
| mipLevelCount: 7, |
| dimension: '3d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let texture3 = gpuCanvasContext0.getCurrentTexture(); |
| let textureView3 = texture3.createView({ |
| label: '\ub495\u0305\u90c5\u{1ff3c}\u{1fbe0}\u{1fb69}\u92ff\u{1fbdb}\u8859', |
| dimension: '2d-array', |
| format: 'bgra8unorm', |
| }); |
| let textureView4 = texture0.createView({ |
| label: '\u{1f995}\u885c\u{1f863}\u{1f9aa}\u{1f9a6}\u112b\u{1fb54}\u81b8\udab3\u00d7', |
| dimension: '2d', |
| baseMipLevel: 1, |
| mipLevelCount: 1, |
| baseArrayLayer: 40, |
| }); |
| let promise0 = device0.queue.onSubmittedWorkDone(); |
| let shaderModule0 = device0.createShaderModule({ |
| label: '\ub946\u09fd\u1be3\u3f4d\u0c64\u{1fcb5}\u0cb2\ud8e8\u{1ff6d}\ubf1b', |
| code: `@group(1) @binding(5545) |
| var<storage, read_write> field0: array<u32>; |
| @group(2) @binding(5545) |
| var<storage, read_write> type0: array<u32>; |
| |
| @compute @workgroup_size(2, 4, 3) |
| fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {} |
| |
| struct S1 { |
| @location(25) f0: vec4<u32>, |
| @location(12) f1: f16, |
| @location(27) f2: vec2<i32>, |
| @location(11) f3: f16, |
| @location(21) f4: vec2<f32>, |
| @location(14) f5: vec4<f16> |
| } |
| struct FragmentOutput0 { |
| @location(2) f0: vec3<i32>, |
| @location(1) f1: vec4<u32>, |
| @location(4) f2: vec4<u32>, |
| @location(6) f3: vec4<f32>, |
| @location(3) f4: vec4<i32>, |
| @location(5) f5: vec3<f32>, |
| @location(0) f6: vec2<u32> |
| } |
| |
| @fragment |
| fn fragment0(a0: S1, @location(7) a1: vec3<u32>, @location(19) a2: vec2<f32>, @location(9) a3: i32, @location(39) a4: vec4<f16>, @location(20) a5: vec4<f32>) -> FragmentOutput0 { |
| return FragmentOutput0(); |
| } |
| |
| struct S0 { |
| @location(2) f0: vec2<f16>, |
| @location(17) f1: f32 |
| } |
| struct VertexOutput0 { |
| @location(37) f0: vec2<f16>, |
| @location(14) f1: vec4<f16>, |
| @location(19) f2: vec2<f32>, |
| @location(22) f3: vec2<i32>, |
| @location(21) f4: vec2<f32>, |
| @location(28) f5: f32, |
| @location(11) f6: f16, |
| @location(7) f7: vec3<u32>, |
| @location(39) f8: vec4<f16>, |
| @location(9) f9: i32, |
| @location(12) f10: f16, |
| @location(24) f11: i32, |
| @location(20) f12: vec4<f32>, |
| @location(25) f13: vec4<u32>, |
| @location(0) f14: f32, |
| @builtin(position) f15: vec4<f32>, |
| @location(27) f16: vec2<i32>, |
| @location(35) f17: vec3<u32>, |
| @location(15) f18: vec4<i32> |
| } |
| |
| @vertex |
| fn vertex0(@location(10) a0: vec4<f16>, a1: S0, @location(13) a2: vec4<f32>, @builtin(vertex_index) a3: u32, @builtin(instance_index) a4: u32, @location(11) a5: f16) -> VertexOutput0 { |
| return VertexOutput0(); |
| } |
| |
| `, |
| hints: {}, |
| }); |
| let textureView5 = texture0.createView({label: '\u3a8b\uc3b4\u{1f7a5}\u3d81', dimension: '2d', baseArrayLayer: 10}); |
| let renderBundle1 = renderBundleEncoder0.finish({label: '\u2118\u0852\u0aae\u{1f63c}\u{1fcb6}\u8af8\u0db8\u3694\u{1fa92}\u990e'}); |
| let externalTexture0 = device0.importExternalTexture({label: '\u6643\u2f6c\u{1fcfc}\u00cc\u0cb7\u4aa2', source: videoFrame0}); |
| video0.width = 214; |
| let canvas2 = document.createElement('canvas'); |
| let pipelineLayout1 = device0.createPipelineLayout({ |
| label: '\u779d\u0299\u62ec\u05b5\u4648\u84ed', |
| bindGroupLayouts: [bindGroupLayout0, bindGroupLayout0, bindGroupLayout0], |
| }); |
| let texture4 = device0.createTexture({ |
| size: [80, 8, 1], |
| mipLevelCount: 4, |
| sampleCount: 1, |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView6 = texture0.createView({baseMipLevel: 1, mipLevelCount: 1, baseArrayLayer: 20, arrayLayerCount: 19}); |
| try { |
| device0.queue.writeTexture({ |
| texture: texture1, |
| mipLevel: 1, |
| origin: {x: 9, y: 2, z: 4}, |
| aspect: 'all', |
| }, new Int8Array(new ArrayBuffer(32)), /* required buffer size: 3_083_794 */ |
| {offset: 446, bytesPerRow: 1628, rowsPerImage: 157}, {width: 193, height: 10, depthOrArrayLayers: 13}); |
| } catch {} |
| let texture5 = device0.createTexture({ |
| label: '\u302b\uf5e6\ub948\u0c72\u{1f738}\u7fda', |
| size: {width: 1296, height: 60, depthOrArrayLayers: 41}, |
| mipLevelCount: 6, |
| format: 'r16uint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView7 = texture1.createView({label: '\u92c1\u0816', baseMipLevel: 1, arrayLayerCount: 1}); |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 20, height: 2, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame0, |
| origin: { x: 90226773, y: 715438519 }, |
| flipY: false, |
| }, { |
| texture: texture4, |
| mipLevel: 2, |
| origin: {x: 4, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline0 = device0.createComputePipeline({layout: pipelineLayout1, compute: {module: shaderModule0, entryPoint: 'compute0'}}); |
| let imageBitmap0 = await createImageBitmap(offscreenCanvas0); |
| let bindGroupLayout1 = device0.createBindGroupLayout({ |
| label: '\u08b2\u{1fc2f}', |
| entries: [ |
| { |
| binding: 2527, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| sampler: { type: 'filtering' }, |
| }, |
| { |
| binding: 5302, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false }, |
| }, |
| ], |
| }); |
| let texture6 = device0.createTexture({ |
| label: '\u0313\u3acb\u5c18\u046e\u{1f88b}', |
| size: [952], |
| dimension: '1d', |
| format: 'rg16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| viewFormats: ['rg16sint', 'rg16sint', 'rg16sint'], |
| }); |
| try { |
| device0.queue.writeTexture({ |
| texture: texture6, |
| mipLevel: 0, |
| origin: {x: 82, y: 0, z: 0}, |
| aspect: 'all', |
| }, new ArrayBuffer(40), /* required buffer size: 960 */ |
| {offset: 960}, {width: 14, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 80, height: 8, depthOrArrayLayers: 1} |
| */ |
| { |
| source: video0, |
| origin: { x: 0, y: 1 }, |
| flipY: true, |
| }, { |
| texture: texture4, |
| mipLevel: 0, |
| origin: {x: 0, y: 2, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let shaderModule1 = device0.createShaderModule({ |
| label: '\u737b\uc0ef\u0401', |
| code: `@group(0) @binding(5545) |
| var<storage, read_write> function0: array<u32>; |
| @group(1) @binding(5545) |
| var<storage, read_write> local0: array<u32>; |
| @group(2) @binding(5545) |
| var<storage, read_write> local1: array<u32>; |
| |
| @compute @workgroup_size(7, 4, 3) |
| fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {} |
| |
| struct FragmentOutput0 { |
| @location(1) f0: vec4<u32>, |
| @location(0) f1: vec3<u32>, |
| @location(2) f2: vec4<i32>, |
| @builtin(sample_mask) f3: u32, |
| @location(5) f4: vec4<f32>, |
| @location(4) f5: vec3<u32>, |
| @location(6) f6: vec4<f32>, |
| @location(3) f7: i32 |
| } |
| |
| @fragment |
| fn fragment0(@builtin(sample_index) a0: u32, @builtin(position) a1: vec4<f32>, @builtin(front_facing) a2: bool, @builtin(sample_mask) a3: u32) -> FragmentOutput0 { |
| return FragmentOutput0(); |
| } |
| |
| |
| |
| @vertex |
| fn vertex0(@location(6) a0: i32, @location(13) a1: vec4<u32>) -> @builtin(position) vec4<f32> { |
| return vec4<f32>(0.0, 0.0, 0.0, 1.0); |
| } |
| |
| `, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| let renderBundle2 = renderBundleEncoder0.finish({label: '\u4056\u5b6f'}); |
| let externalTexture1 = device0.importExternalTexture({source: videoFrame0, colorSpace: 'srgb'}); |
| try { |
| device0.queue.writeTexture({ |
| texture: texture0, |
| mipLevel: 7, |
| origin: {x: 0, y: 0, z: 2}, |
| aspect: 'all', |
| }, new Uint32Array(new ArrayBuffer(8)), /* required buffer size: 6_395 */ |
| {offset: 587, bytesPerRow: 44, rowsPerImage: 6}, {width: 0, height: 0, depthOrArrayLayers: 23}); |
| } catch {} |
| let textureView8 = texture5.createView({baseMipLevel: 1, mipLevelCount: 4, baseArrayLayer: 9, arrayLayerCount: 6}); |
| let renderBundle3 = renderBundleEncoder0.finish({}); |
| let imageData0 = new ImageData(136, 252); |
| let commandEncoder2 = device0.createCommandEncoder({label: '\u{1fcd1}\u8996\u{1fa2b}\uebe8\u0c18\ua194'}); |
| let textureView9 = texture2.createView({ |
| label: '\ub342\u4a40\ua779\u{1fcd1}\u02f8\u049e\u057d\u1d7d\uc09f\ud593\u{1f9e3}', |
| baseMipLevel: 3, |
| mipLevelCount: 1, |
| }); |
| let renderBundle4 = renderBundleEncoder0.finish(); |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 162, height: 7, depthOrArrayLayers: 69} |
| */ |
| { |
| source: video0, |
| origin: { x: 1, y: 1 }, |
| flipY: true, |
| }, { |
| texture: texture2, |
| mipLevel: 1, |
| origin: {x: 7, y: 0, z: 15}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await promise0; |
| } catch {} |
| let bindGroupLayout2 = device0.createBindGroupLayout({ |
| label: '\u0ec3\u0962\u03a5\u6fdd\u09c8\u3fdd\u{1fbb9}', |
| entries: [ |
| { |
| binding: 5287, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rg32sint', access: 'read-only', viewDimension: '1d' }, |
| }, |
| { |
| binding: 765, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| sampler: { type: 'filtering' }, |
| }, |
| { |
| binding: 5830, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '3d' }, |
| }, |
| ], |
| }); |
| let texture7 = device0.createTexture({ |
| label: '\u07c4\u{1fa28}\u82d4\u0015\u1f8d\ud148\u071d\u0ad9\u{1fd08}\u6082', |
| size: {width: 1905, height: 4, depthOrArrayLayers: 1}, |
| format: 'rg16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rg16sint', 'rg16sint'], |
| }); |
| let texture8 = gpuCanvasContext0.getCurrentTexture(); |
| let textureView10 = texture5.createView({ |
| label: '\u0150\u5d62\u0bea\u6f00\u47e7\u{1fb33}\u09a8\ua40c\u281c\u{1f710}', |
| dimension: '2d-array', |
| mipLevelCount: 4, |
| baseArrayLayer: 10, |
| arrayLayerCount: 26, |
| }); |
| let pipeline1 = await device0.createRenderPipelineAsync({ |
| layout: pipelineLayout0, |
| multisample: {count: 4}, |
| fragment: { |
| module: shaderModule1, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{format: 'r16uint', writeMask: 0}, {format: 'rgba16uint', writeMask: GPUColorWrite.GREEN | GPUColorWrite.RED}, {format: 'rg16sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE}, { |
| format: 'r8sint', |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED, |
| }, {format: 'rg32uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED}, { |
| format: 'rg8unorm', |
| blend: { |
| color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'}, |
| alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'}, |
| }, |
| writeMask: 0, |
| }, {format: 'rgb10a2unorm', writeMask: GPUColorWrite.BLUE}], |
| }, |
| depthStencil: { |
| format: 'depth24plus-stencil8', |
| depthWriteEnabled: true, |
| depthCompare: 'equal', |
| stencilFront: {failOp: 'zero', depthFailOp: 'increment-clamp', passOp: 'replace'}, |
| stencilBack: {compare: 'greater-equal', failOp: 'decrement-wrap', depthFailOp: 'invert', passOp: 'replace'}, |
| stencilReadMask: 1699201482, |
| stencilWriteMask: 1503589498, |
| depthBiasClamp: 684.3477200033667, |
| }, |
| vertex: { |
| module: shaderModule1, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 18576, |
| stepMode: 'instance', |
| attributes: [{format: 'sint16x4', offset: 584, shaderLocation: 6}], |
| }, |
| { |
| arrayStride: 16968, |
| stepMode: 'instance', |
| attributes: [{format: 'uint8x2', offset: 1998, shaderLocation: 13}], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-list', frontFace: 'ccw', cullMode: 'front', unclippedDepth: true}, |
| }); |
| let gpuCanvasContext1 = offscreenCanvas1.getContext('webgpu'); |
| try { |
| window.someLabel = textureView8.label; |
| } catch {} |
| let commandEncoder3 = device0.createCommandEncoder({label: '\uc558\u0b9e\u4052\u9242\u{1f6ce}\ubdad\u874c\ue826\uee5e\ud4fe\u{1fb7b}'}); |
| let commandBuffer1 = commandEncoder2.finish({label: '\u{1ffbf}\uf6dc\u4f8f'}); |
| let texture9 = device0.createTexture({ |
| label: '\u9547\u{1fc5b}\ue2b1\uc7c6\u36a3\u{1fc50}', |
| size: [162, 7, 73], |
| mipLevelCount: 3, |
| dimension: '3d', |
| format: 'r16uint', |
| usage: GPUTextureUsage.COPY_DST, |
| viewFormats: ['r16uint', 'r16uint', 'r16uint'], |
| }); |
| let renderBundleEncoder1 = device0.createRenderBundleEncoder({ |
| label: '\u0282\uad0b\u7022\u0a61\u00cd\u056f\ub677\ub11f\u02dc', |
| colorFormats: ['r16uint', 'rgba16uint', 'rg16sint', 'r8sint', 'rg32uint', 'rg8unorm', 'rgb10a2unorm'], |
| sampleCount: 4, |
| }); |
| let renderBundle5 = renderBundleEncoder0.finish({}); |
| try { |
| texture5.destroy(); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture6, |
| mipLevel: 0, |
| origin: {x: 55, y: 0, z: 0}, |
| aspect: 'all', |
| }, new BigUint64Array(new ArrayBuffer(80)), /* required buffer size: 85 */ |
| {offset: 85}, {width: 572, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let gpuCanvasContext2 = canvas1.getContext('webgpu'); |
| let shaderModule2 = device0.createShaderModule({ |
| label: '\u9d06\u{1fd5e}', |
| code: `@group(0) @binding(5545) |
| var<storage, read_write> function1: array<u32>; |
| @group(1) @binding(5545) |
| var<storage, read_write> parameter0: array<u32>; |
| |
| @compute @workgroup_size(6, 2, 2) |
| fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {} |
| |
| struct FragmentOutput0 { |
| @location(6) f0: vec4<f32>, |
| @location(3) f1: vec4<i32>, |
| @location(1) f2: vec4<u32>, |
| @location(5) f3: vec3<f32>, |
| @location(2) f4: vec2<i32>, |
| @location(4) f5: vec3<u32>, |
| @builtin(sample_mask) f6: u32, |
| @location(0) f7: vec4<u32> |
| } |
| |
| @fragment |
| fn fragment0() -> FragmentOutput0 { |
| return FragmentOutput0(); |
| } |
| |
| struct S2 { |
| @location(2) f0: u32, |
| @location(17) f1: vec3<f16>, |
| @location(15) f2: vec2<i32>, |
| @location(10) f3: i32, |
| @location(6) f4: u32, |
| @location(5) f5: vec2<f32>, |
| @location(8) f6: vec3<f32>, |
| @location(7) f7: i32, |
| @location(14) f8: vec2<f32> |
| } |
| |
| @vertex |
| fn vertex0(@location(9) a0: vec4<f32>, @location(11) a1: vec2<f16>, @location(4) a2: vec2<i32>, @location(1) a3: vec4<u32>, @location(16) a4: vec2<i32>, @location(3) a5: vec3<u32>, @location(0) a6: vec3<i32>, a7: S2, @location(13) a8: i32, @location(12) a9: f32, @builtin(vertex_index) a10: u32, @builtin(instance_index) a11: u32) -> @builtin(position) vec4<f32> { |
| return vec4<f32>(0.0, 0.0, 0.0, 1.0); |
| } |
| |
| `, |
| }); |
| let textureView11 = texture1.createView({label: '\u337c\udfc1\u0a29\ucd0f\u3f88\u8045\u0c7f\ude7d', mipLevelCount: 1}); |
| let renderBundleEncoder2 = device0.createRenderBundleEncoder({ |
| colorFormats: ['r16uint', 'rgba16uint', 'rg16sint', 'r8sint', 'rg32uint', 'rg8unorm', 'rgb10a2unorm'], |
| sampleCount: 4, |
| stencilReadOnly: true, |
| }); |
| try { |
| device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; }); |
| } catch {} |
| gc(); |
| let shaderModule3 = device0.createShaderModule({ |
| label: '\u1ace\u1656\ubece\u0038', |
| code: `@group(2) @binding(5545) |
| var<storage, read_write> function2: array<u32>; |
| @group(1) @binding(5545) |
| var<storage, read_write> type1: array<u32>; |
| |
| @compute @workgroup_size(7, 1, 4) |
| fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {} |
| |
| struct S4 { |
| @location(11) f0: vec4<f16>, |
| @location(18) f1: vec4<f32>, |
| @location(38) f2: vec4<i32>, |
| @location(31) f3: vec2<f16>, |
| @location(24) f4: vec3<f32> |
| } |
| struct FragmentOutput0 { |
| @location(4) f0: vec4<u32>, |
| @location(3) f1: vec4<i32>, |
| @location(6) f2: vec4<f32>, |
| @location(2) f3: vec2<i32>, |
| @location(5) f4: vec4<f32>, |
| @location(1) f5: vec4<u32>, |
| @location(0) f6: u32 |
| } |
| |
| @fragment |
| fn fragment0(@location(21) a0: vec3<f16>, @location(16) a1: f32, @location(7) a2: vec3<i32>, @location(33) a3: vec4<f16>, @location(0) a4: vec2<f16>, @location(9) a5: vec3<f32>, @location(40) a6: f32, @location(20) a7: vec4<f32>, @location(10) a8: vec4<u32>, @builtin(front_facing) a9: bool, @location(13) a10: vec4<u32>, @location(6) a11: vec4<i32>, a12: S4, @location(15) a13: u32, @location(3) a14: vec3<i32>, @location(2) a15: vec2<u32>, @location(34) a16: vec4<f32>, @builtin(sample_mask) a17: u32, @location(4) a18: vec3<i32>, @location(36) a19: vec2<f32>, @location(28) a20: vec3<u32>, @location(23) a21: u32, @location(30) a22: vec2<u32>) -> FragmentOutput0 { |
| return FragmentOutput0(); |
| } |
| |
| struct S3 { |
| @location(0) f0: vec2<u32>, |
| @location(12) f1: vec4<f32>, |
| @location(9) f2: vec2<i32>, |
| @location(6) f3: vec3<f32> |
| } |
| struct VertexOutput0 { |
| @location(11) f19: vec4<f16>, |
| @location(28) f20: vec3<u32>, |
| @location(9) f21: vec3<f32>, |
| @location(40) f22: f32, |
| @location(7) f23: vec3<i32>, |
| @location(13) f24: vec4<u32>, |
| @location(41) f25: vec3<i32>, |
| @location(29) f26: vec3<f16>, |
| @location(16) f27: f32, |
| @location(6) f28: vec4<i32>, |
| @location(23) f29: u32, |
| @location(21) f30: vec3<f16>, |
| @location(4) f31: vec3<i32>, |
| @location(38) f32: vec4<i32>, |
| @location(24) f33: vec3<f32>, |
| @location(31) f34: vec2<f16>, |
| @location(33) f35: vec4<f16>, |
| @location(18) f36: vec4<f32>, |
| @location(34) f37: vec4<f32>, |
| @location(0) f38: vec2<f16>, |
| @builtin(position) f39: vec4<f32>, |
| @location(15) f40: u32, |
| @location(37) f41: vec3<f16>, |
| @location(36) f42: vec2<f32>, |
| @location(20) f43: vec4<f32>, |
| @location(30) f44: vec2<u32>, |
| @location(25) f45: vec3<f32>, |
| @location(3) f46: vec3<i32>, |
| @location(10) f47: vec4<u32>, |
| @location(2) f48: vec2<u32>, |
| @location(8) f49: f32, |
| @location(27) f50: vec2<i32> |
| } |
| |
| @vertex |
| fn vertex0(@location(4) a0: u32, @location(14) a1: vec4<f16>, @location(13) a2: vec4<u32>, @location(5) a3: u32, @location(16) a4: vec2<i32>, @location(7) a5: vec4<f16>, @location(3) a6: vec2<i32>, @location(11) a7: vec4<f32>, @builtin(instance_index) a8: u32, @location(17) a9: vec2<f16>, @location(8) a10: u32, @location(15) a11: vec4<u32>, @builtin(vertex_index) a12: u32, a13: S3, @location(1) a14: vec2<i32>, @location(2) a15: vec4<f16>, @location(10) a16: vec3<u32>) -> VertexOutput0 { |
| return VertexOutput0(); |
| } |
| |
| `, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| let pipelineLayout2 = device0.createPipelineLayout({label: '\uf6b5\u5913', bindGroupLayouts: [bindGroupLayout1]}); |
| let renderBundle6 = renderBundleEncoder0.finish({label: '\u0b83\ub706\ubbf7\u2d34\u09d1\ua373\u1c57\u9bbd\u3056\u02ce\u0c41'}); |
| let sampler0 = device0.createSampler({ |
| label: '\u{1f661}\u2980\u06b8\u{1f676}\u02b9', |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'mirror-repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| lodMinClamp: 67.46, |
| lodMaxClamp: 88.83, |
| }); |
| try { |
| device0.queue.writeTexture({ |
| texture: texture4, |
| mipLevel: 0, |
| origin: {x: 2, y: 1, z: 0}, |
| aspect: 'all', |
| }, new ArrayBuffer(64), /* required buffer size: 1_516 */ |
| {offset: 554, bytesPerRow: 369}, {width: 56, height: 3, depthOrArrayLayers: 1}); |
| } catch {} |
| let commandEncoder4 = device0.createCommandEncoder(); |
| let querySet2 = device0.createQuerySet({label: '\u{1fe53}\u790b', type: 'occlusion', count: 2769}); |
| let textureView12 = texture4.createView({label: '\u{1f92a}\u0293\u{1f931}\u{1fa70}\u83fc', baseMipLevel: 0, mipLevelCount: 2}); |
| let computePassEncoder1 = commandEncoder3.beginComputePass({}); |
| let renderBundleEncoder3 = device0.createRenderBundleEncoder({ |
| colorFormats: ['r16uint', 'rgba16uint', 'rg16sint', 'r8sint', 'rg32uint', 'rg8unorm', 'rgb10a2unorm'], |
| sampleCount: 4, |
| depthReadOnly: true, |
| stencilReadOnly: true, |
| }); |
| try { |
| computePassEncoder0.setPipeline(pipeline0); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let pipeline2 = device0.createComputePipeline({layout: pipelineLayout2, compute: {module: shaderModule0, entryPoint: 'compute0', constants: {}}}); |
| try { |
| canvas0.getContext('webgl2'); |
| } catch {} |
| let querySet3 = device0.createQuerySet({label: '\u{1feb8}\u077e\uc813\udd45\u{1f9d5}\u0fe7\uc0bb\ua175\u8e7b', type: 'occlusion', count: 2381}); |
| let texture10 = device0.createTexture({ |
| label: '\u9b43\ua7c8\u2ea4\u0693', |
| size: {width: 952, height: 2, depthOrArrayLayers: 266}, |
| mipLevelCount: 6, |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: ['r8sint', 'r8sint', 'r8sint'], |
| }); |
| try { |
| commandEncoder4.copyTextureToTexture({ |
| texture: texture6, |
| mipLevel: 0, |
| origin: {x: 66, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture7, |
| mipLevel: 0, |
| origin: {x: 758, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 543, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture10, |
| mipLevel: 5, |
| origin: {x: 6, y: 0, z: 0}, |
| aspect: 'all', |
| }, new ArrayBuffer(56), /* required buffer size: 253_733 */ |
| {offset: 689, bytesPerRow: 297, rowsPerImage: 284}, {width: 15, height: 0, depthOrArrayLayers: 4}); |
| } catch {} |
| let pipeline3 = device0.createRenderPipeline({ |
| label: '\u1e02\ub7f8\u0743\u0cbd', |
| layout: pipelineLayout0, |
| multisample: {}, |
| fragment: { |
| module: shaderModule0, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{format: 'r16uint', writeMask: GPUColorWrite.ALL}, {format: 'rgba16uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE}, {format: 'rg16sint'}, {format: 'r8sint', writeMask: 0}, {format: 'rg32uint', writeMask: GPUColorWrite.ALL}, { |
| format: 'rg8unorm', |
| blend: { |
| color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'}, |
| alpha: {operation: 'reverse-subtract', srcFactor: 'one-minus-dst', dstFactor: 'one-minus-dst-alpha'}, |
| }, |
| writeMask: GPUColorWrite.GREEN | GPUColorWrite.RED, |
| }, { |
| format: 'rgb10a2unorm', |
| blend: { |
| color: {operation: 'reverse-subtract', srcFactor: 'src-alpha-saturated', dstFactor: 'zero'}, |
| alpha: {operation: 'subtract', srcFactor: 'dst', dstFactor: 'one-minus-src-alpha'}, |
| }, |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.RED, |
| }], |
| }, |
| depthStencil: { |
| format: 'depth24plus-stencil8', |
| depthWriteEnabled: true, |
| depthCompare: 'greater-equal', |
| stencilFront: {compare: 'less', depthFailOp: 'decrement-wrap', passOp: 'decrement-clamp'}, |
| stencilBack: {compare: 'not-equal', failOp: 'replace', depthFailOp: 'decrement-clamp', passOp: 'increment-clamp'}, |
| stencilReadMask: 1176262068, |
| stencilWriteMask: 3937675444, |
| depthBias: 174978864, |
| depthBiasClamp: 371.76370545301825, |
| }, |
| vertex: { |
| module: shaderModule0, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 204, |
| attributes: [ |
| {format: 'float32x4', offset: 16, shaderLocation: 17}, |
| {format: 'snorm16x2', offset: 12, shaderLocation: 13}, |
| {format: 'snorm16x4', offset: 48, shaderLocation: 10}, |
| {format: 'unorm8x4', offset: 8, shaderLocation: 11}, |
| {format: 'unorm10-10-10-2', offset: 8, shaderLocation: 2}, |
| ], |
| }, |
| ], |
| }, |
| primitive: { |
| topology: 'triangle-strip', |
| stripIndexFormat: 'uint32', |
| frontFace: 'ccw', |
| cullMode: 'front', |
| unclippedDepth: true, |
| }, |
| }); |
| let canvas3 = document.createElement('canvas'); |
| let pipelineLayout3 = device0.createPipelineLayout({ |
| label: '\u6d9b\u049b\u{1f7ca}\uec6c\u5fc7\u283f\u0e17\u54ff\uacfc', |
| bindGroupLayouts: [bindGroupLayout0], |
| }); |
| let querySet4 = device0.createQuerySet({type: 'occlusion', count: 4039}); |
| let commandBuffer2 = commandEncoder4.finish({label: '\u{1f9cc}\u0eee\u{1fa48}\u0894\ue040\u0463\ud0aa\u2ea8\u09ec\u91f8\u{1fc9a}'}); |
| let renderBundleEncoder4 = device0.createRenderBundleEncoder({ |
| label: '\ub420\u495c\u04be\u6b0a\u{1fb45}\u{1fd0c}\u096f\u{1fc66}\u68a7', |
| colorFormats: ['r16uint', 'rgba16uint', 'rg16sint', 'r8sint', 'rg32uint', 'rg8unorm', 'rgb10a2unorm'], |
| sampleCount: 4, |
| stencilReadOnly: true, |
| }); |
| try { |
| renderBundleEncoder2.setVertexBuffer(1008, undefined); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let buffer0 = device0.createBuffer({ |
| label: '\u{1fa3d}\ubc03\u{1f912}\u0081\u{1fe82}\u{1f902}\u0e7a', |
| size: 284842, |
| usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM, |
| }); |
| let commandEncoder5 = device0.createCommandEncoder({label: '\u1b3e\u3691\uced7\ue8d9\u4d84\u079e\u7c2f\udb11\ub572\u055f\u082e'}); |
| let textureView13 = texture2.createView({label: '\ud10f\u05fd', aspect: 'all', mipLevelCount: 4}); |
| let externalTexture2 = device0.importExternalTexture({source: videoFrame0}); |
| try { |
| computePassEncoder1.setPipeline(pipeline0); |
| } catch {} |
| try { |
| commandEncoder5.copyTextureToTexture({ |
| texture: texture1, |
| mipLevel: 1, |
| origin: {x: 18, y: 0, z: 9}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture1, |
| mipLevel: 0, |
| origin: {x: 8, y: 2, z: 11}, |
| aspect: 'all', |
| }, |
| {width: 228, height: 29, depthOrArrayLayers: 11}); |
| } catch {} |
| let imageData1 = new ImageData(128, 220); |
| let bindGroupLayout3 = device0.createBindGroupLayout({label: '\uee1d\u0a68\u00bf\ue99c', entries: []}); |
| let commandEncoder6 = device0.createCommandEncoder({}); |
| try { |
| commandEncoder5.resolveQuerySet(querySet0, 1988, 770, buffer0, 216064); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 20, height: 1, depthOrArrayLayers: 8} |
| */ |
| { |
| source: imageData0, |
| origin: { x: 26, y: 42 }, |
| flipY: true, |
| }, { |
| texture: texture2, |
| mipLevel: 4, |
| origin: {x: 0, y: 0, z: 1}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let querySet5 = device0.createQuerySet({label: '\u73c1\u0214\u1b2f\uc23d\uba34\u7226\u0ccc\u0033\u3f40', type: 'occlusion', count: 193}); |
| let textureView14 = texture8.createView({label: '\u7052\uf019\ue987\u5b88\u{1fb39}\u972d\u0ca8', dimension: '2d-array'}); |
| try { |
| commandEncoder6.copyTextureToTexture({ |
| texture: texture1, |
| mipLevel: 0, |
| origin: {x: 41, y: 7, z: 6}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture1, |
| mipLevel: 1, |
| origin: {x: 32, y: 3, z: 12}, |
| aspect: 'all', |
| }, |
| {width: 149, height: 12, depthOrArrayLayers: 21}); |
| } catch {} |
| try { |
| commandEncoder5.insertDebugMarker('\u7d1a'); |
| } catch {} |
| let bindGroup0 = device0.createBindGroup({layout: bindGroupLayout3, entries: []}); |
| let querySet6 = device0.createQuerySet({label: '\u1541\ua05d\u0f49\udfa5\u05a6\u1b5e', type: 'occlusion', count: 3535}); |
| let textureView15 = texture2.createView({ |
| label: '\u0ab1\u{1fd82}\ub8a4\u{1fb99}\u2750\u{1ffe1}\u0809\u0500\ua901\u0bb0\u8f10', |
| format: 'rgb10a2unorm', |
| }); |
| let computePassEncoder2 = commandEncoder6.beginComputePass({label: '\ud0df\u0dd8\u2bd4\u0f3c\u{1f760}\udce5\ubacf'}); |
| try { |
| renderBundleEncoder1.setVertexBuffer(2887, undefined, 1631479893, 1367869783); |
| } catch {} |
| let gpuCanvasContext3 = canvas3.getContext('webgpu'); |
| offscreenCanvas0.width = 1101; |
| let shaderModule4 = device0.createShaderModule({ |
| label: '\ue2fb\udead\u7b1b\udc2e\u840b\u6cb4\u2d69\u192c\u{1f7a6}\u1650\u0dae', |
| code: `@group(0) @binding(2527) |
| var<storage, read_write> global0: array<u32>; |
| @group(0) @binding(5302) |
| var<storage, read_write> n0: array<u32>; |
| |
| @compute @workgroup_size(5, 4, 1) |
| fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {} |
| |
| struct S6 { |
| @builtin(sample_index) f0: u32, |
| @location(33) f1: u32, |
| @location(11) f2: vec4<u32>, |
| @location(5) f3: vec3<f16>, |
| @location(21) f4: vec4<u32>, |
| @builtin(front_facing) f5: bool, |
| @location(37) f6: vec4<f32>, |
| @location(8) f7: vec4<i32>, |
| @location(15) f8: vec4<f32>, |
| @location(0) f9: vec3<f32>, |
| @location(1) f10: vec4<u32>, |
| @location(28) f11: vec4<i32>, |
| @location(36) f12: vec2<i32>, |
| @location(25) f13: vec2<i32>, |
| @location(35) f14: vec3<f16>, |
| @location(41) f15: f16, |
| @builtin(sample_mask) f16: u32, |
| @location(34) f17: vec2<i32>, |
| @location(19) f18: vec4<f16>, |
| @location(9) f19: vec3<f32>, |
| @location(29) f20: vec2<f16>, |
| @location(14) f21: vec2<f16>, |
| @builtin(position) f22: vec4<f32>, |
| @location(4) f23: vec3<f16>, |
| @location(18) f24: i32, |
| @location(17) f25: vec3<f16> |
| } |
| struct FragmentOutput0 { |
| @location(1) f0: vec4<u32>, |
| @location(2) f1: vec2<i32>, |
| @location(4) f2: vec3<u32>, |
| @location(6) f3: vec4<f32>, |
| @location(3) f4: vec2<i32>, |
| @builtin(sample_mask) f5: u32, |
| @location(5) f6: vec3<f32>, |
| @location(0) f7: vec4<u32> |
| } |
| |
| @fragment |
| fn fragment0(@location(38) a0: vec3<i32>, a1: S6, @location(20) a2: f32, @location(26) a3: f32, @location(22) a4: u32, @location(39) a5: vec3<f32>, @location(24) a6: f32, @location(40) a7: f32, @location(3) a8: vec3<f32>, @location(6) a9: vec2<u32>, @location(2) a10: u32, @location(31) a11: vec2<f32>, @location(27) a12: vec2<f16>, @location(16) a13: vec2<f32>) -> FragmentOutput0 { |
| return FragmentOutput0(); |
| } |
| |
| struct S5 { |
| @location(6) f0: u32, |
| @location(13) f1: vec2<f16>, |
| @location(12) f2: vec4<i32>, |
| @builtin(vertex_index) f3: u32 |
| } |
| struct VertexOutput0 { |
| @location(16) f51: vec2<f32>, |
| @location(38) f52: vec3<i32>, |
| @location(35) f53: vec3<f16>, |
| @location(39) f54: vec3<f32>, |
| @location(6) f55: vec2<u32>, |
| @location(19) f56: vec4<f16>, |
| @location(40) f57: f32, |
| @location(1) f58: vec4<u32>, |
| @location(27) f59: vec2<f16>, |
| @location(14) f60: vec2<f16>, |
| @location(41) f61: f16, |
| @location(36) f62: vec2<i32>, |
| @location(5) f63: vec3<f16>, |
| @location(25) f64: vec2<i32>, |
| @location(15) f65: vec4<f32>, |
| @location(26) f66: f32, |
| @location(22) f67: u32, |
| @builtin(position) f68: vec4<f32>, |
| @location(17) f69: vec3<f16>, |
| @location(8) f70: vec4<i32>, |
| @location(11) f71: vec4<u32>, |
| @location(9) f72: vec3<f32>, |
| @location(0) f73: vec3<f32>, |
| @location(33) f74: u32, |
| @location(34) f75: vec2<i32>, |
| @location(28) f76: vec4<i32>, |
| @location(24) f77: f32, |
| @location(21) f78: vec4<u32>, |
| @location(37) f79: vec4<f32>, |
| @location(3) f80: vec3<f32>, |
| @location(29) f81: vec2<f16>, |
| @location(2) f82: u32, |
| @location(4) f83: vec3<f16>, |
| @location(20) f84: f32, |
| @location(31) f85: vec2<f32>, |
| @location(18) f86: i32 |
| } |
| |
| @vertex |
| fn vertex0(@location(5) a0: vec4<f16>, @location(16) a1: f32, @location(2) a2: vec2<u32>, a3: S5) -> VertexOutput0 { |
| return VertexOutput0(); |
| } |
| |
| `, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| let pipelineLayout4 = device0.createPipelineLayout({bindGroupLayouts: [bindGroupLayout2, bindGroupLayout0, bindGroupLayout3, bindGroupLayout3]}); |
| let buffer1 = device0.createBuffer({ |
| label: '\u{1f78b}\u04f7\u03c8\u0d88\u{1f627}\u0ad3\u6af5\u06f4\u8c0a', |
| size: 337160, |
| usage: GPUBufferUsage.INDEX, |
| mappedAtCreation: true, |
| }); |
| let commandEncoder7 = device0.createCommandEncoder({label: '\u0763\u0576\uc123\u3660\u0dca\u0f76'}); |
| let querySet7 = device0.createQuerySet({ |
| label: '\u0361\udec1\u{1fc34}\ub51c\u0727\u4bcf\u527b\u0ca5\u0eca\u04d0', |
| type: 'occlusion', |
| count: 1319, |
| }); |
| let texture11 = device0.createTexture({ |
| label: '\u647d\u{1ff0f}\u3b41\u{1ff4b}\u14d0\u956e\u8c2b\u1bea', |
| size: {width: 1296, height: 60, depthOrArrayLayers: 41}, |
| mipLevelCount: 11, |
| format: 'astc-6x6-unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderBundle7 = renderBundleEncoder1.finish({label: '\u9dff\u067d\u0fea\u{1ffdd}\u341d'}); |
| try { |
| computePassEncoder1.end(); |
| } catch {} |
| try { |
| renderBundleEncoder4.setBindGroup(2, bindGroup0, []); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 20, height: 2, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData0, |
| origin: { x: 22, y: 7 }, |
| flipY: true, |
| }, { |
| texture: texture4, |
| mipLevel: 2, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let offscreenCanvas2 = new OffscreenCanvas(914, 225); |
| let buffer2 = device0.createBuffer({size: 263719, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ, mappedAtCreation: false}); |
| let computePassEncoder3 = commandEncoder7.beginComputePass({}); |
| try { |
| computePassEncoder0.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderBundleEncoder4.setBindGroup(2, bindGroup0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer2, 105984, new DataView(new ArrayBuffer(22612)), 11853, 1636); |
| } catch {} |
| let pipeline4 = device0.createComputePipeline({layout: pipelineLayout2, compute: {module: shaderModule0, entryPoint: 'compute0', constants: {}}}); |
| let bindGroup1 = device0.createBindGroup({ |
| label: '\u9e01\u0e0c\u{1f726}\u3fef\u{1f8d5}\u452d\u099d\u959a\ue09a', |
| layout: bindGroupLayout3, |
| entries: [], |
| }); |
| let querySet8 = device0.createQuerySet({ |
| label: '\u6513\u{1fbce}\u2905\u077d\u0b29\udcb9\ueca8\u0a45\ub279\u43b7\uc633', |
| type: 'occlusion', |
| count: 2110, |
| }); |
| let texture12 = device0.createTexture({ |
| label: '\u{1fa36}\u27c7\u921e\u0b10\u0771\u0643\u8ba4\u2f35\u{1f7d4}\u73db', |
| size: {width: 320, height: 32, depthOrArrayLayers: 679}, |
| mipLevelCount: 6, |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView16 = texture5.createView({ |
| label: '\u{1fb88}\u9f87\u{1fcaf}\u{1fa53}\u0859', |
| baseMipLevel: 4, |
| baseArrayLayer: 16, |
| arrayLayerCount: 20, |
| }); |
| try { |
| renderBundleEncoder2.setBindGroup(2, bindGroup1); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['bgra8unorm', 'bgra8unorm'], |
| colorSpace: 'srgb', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let commandEncoder8 = device0.createCommandEncoder(); |
| try { |
| computePassEncoder0.setPipeline(pipeline0); |
| } catch {} |
| try { |
| device0.pushErrorScope('out-of-memory'); |
| } catch {} |
| try { |
| commandEncoder3.copyTextureToTexture({ |
| texture: texture6, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture7, |
| mipLevel: 0, |
| origin: {x: 92, y: 1, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 910, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 5, height: 1, depthOrArrayLayers: 2} |
| */ |
| { |
| source: imageBitmap0, |
| origin: { x: 9072748, y: 96949814 }, |
| flipY: false, |
| }, { |
| texture: texture2, |
| mipLevel: 6, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let promise1 = device0.createComputePipelineAsync({ |
| label: '\u5a97\u06ba\u071c\u71bb\u{1fd50}\ub781\u0ed4\u44a6', |
| layout: pipelineLayout1, |
| compute: {module: shaderModule3, entryPoint: 'compute0', constants: {}}, |
| }); |
| let gpuCanvasContext4 = canvas2.getContext('webgpu'); |
| try { |
| offscreenCanvas2.getContext('webgl'); |
| } catch {} |
| let commandEncoder9 = device0.createCommandEncoder({label: '\ucae5\u0438\u59d1\ubd57'}); |
| let externalTexture3 = device0.importExternalTexture({label: '\u4190\u0dc8\uf107\ue8b6\u{1fbe3}\uacdf\u178e', source: videoFrame0, colorSpace: 'srgb'}); |
| try { |
| computePassEncoder3.end(); |
| } catch {} |
| try { |
| commandEncoder9.resolveQuerySet(querySet4, 3746, 35, buffer0, 75264); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer2, 18356, new DataView(new ArrayBuffer(60905)), 37050, 460); |
| } catch {} |
| let bindGroupLayout4 = device0.createBindGroupLayout({ |
| label: '\u1364\u0030\u0678\u0ca3\u07c6\u0e02\u{1f726}', |
| entries: [ |
| { |
| binding: 5665, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: 'cube-array', sampleType: 'uint', multisampled: false }, |
| }, |
| ], |
| }); |
| let texture13 = device0.createTexture({ |
| label: '\u{1f764}\u12da\u042b\u{1fc3c}\u{1ff45}', |
| size: [640, 64, 285], |
| mipLevelCount: 2, |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rg8unorm'], |
| }); |
| let textureView17 = texture9.createView({label: '\ub960\ueb4a', format: 'r16uint', baseMipLevel: 2}); |
| let renderBundle8 = renderBundleEncoder1.finish({label: '\u8630\u051b\u{1f89b}\ud319\u8f91\u02bd\u625f'}); |
| let externalTexture4 = device0.importExternalTexture({label: '\ub448\u4033\u04d2\u0af8\uca6f', source: videoFrame0, colorSpace: 'display-p3'}); |
| try { |
| renderBundleEncoder2.setIndexBuffer(buffer1, 'uint32', 185192, 103828); |
| } catch {} |
| try { |
| commandEncoder5.copyTextureToBuffer({ |
| texture: texture6, |
| mipLevel: 0, |
| origin: {x: 6, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 3448 widthInBlocks: 862 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 2952 */ |
| offset: 2952, |
| bytesPerRow: 3584, |
| buffer: buffer2, |
| }, {width: 862, height: 0, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer2); |
| } catch {} |
| let textureView18 = texture0.createView({ |
| label: '\ua80e\uea06\u2e07\u0d18\u{1f778}\u0784\u4d5d\u05c8', |
| dimension: '2d', |
| baseMipLevel: 1, |
| mipLevelCount: 2, |
| }); |
| let renderBundleEncoder5 = device0.createRenderBundleEncoder({ |
| label: '\u094b\u0d16\u588c\u0ae1\u3579\u0608\u883c\u99ff', |
| colorFormats: ['r16uint', 'rgba16uint', 'rg16sint', 'r8sint', 'rg32uint', 'rg8unorm', 'rgb10a2unorm'], |
| sampleCount: 4, |
| }); |
| let sampler1 = device0.createSampler({ |
| label: '\udabd\ue0af', |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 20.69, |
| lodMaxClamp: 29.33, |
| maxAnisotropy: 1, |
| }); |
| try { |
| renderBundleEncoder5.setIndexBuffer(buffer1, 'uint32', 235112, 62404); |
| } catch {} |
| try { |
| commandEncoder9.clearBuffer(buffer2, 103428, 52708); |
| dissociateBuffer(device0, buffer2); |
| } catch {} |
| let pipeline5 = device0.createComputePipeline({ |
| label: '\u0ff8\u05cc\u0f53\u06c9\uaf69', |
| layout: pipelineLayout2, |
| compute: {module: shaderModule2, entryPoint: 'compute0', constants: {}}, |
| }); |
| let pipeline6 = await device0.createRenderPipelineAsync({ |
| label: '\u4f19\u0367\udf32\u026a\uad8c\u50d0\u{1fbbf}\u02ac', |
| layout: 'auto', |
| multisample: {count: 4, mask: 0x3e583233}, |
| fragment: { |
| module: shaderModule4, |
| entryPoint: 'fragment0', |
| targets: [{format: 'r16uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.RED}, {format: 'rgba16uint', writeMask: GPUColorWrite.ALPHA}, {format: 'rg16sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA}, {format: 'r8sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.RED}, {format: 'rg32uint'}, {format: 'rg8unorm', writeMask: GPUColorWrite.ALL}, { |
| format: 'rgb10a2unorm', |
| blend: { |
| color: {operation: 'subtract', srcFactor: 'zero', dstFactor: 'dst-alpha'}, |
| alpha: {operation: 'subtract', srcFactor: 'src', dstFactor: 'dst-alpha'}, |
| }, |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN, |
| }], |
| }, |
| vertex: { |
| module: shaderModule4, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 1764, |
| attributes: [ |
| {format: 'uint32x4', offset: 196, shaderLocation: 2}, |
| {format: 'float32x3', offset: 76, shaderLocation: 16}, |
| {format: 'sint32x4', offset: 288, shaderLocation: 12}, |
| {format: 'unorm10-10-10-2', offset: 236, shaderLocation: 13}, |
| {format: 'float32x3', offset: 52, shaderLocation: 5}, |
| ], |
| }, |
| {arrayStride: 0, attributes: []}, |
| {arrayStride: 17052, stepMode: 'instance', attributes: []}, |
| {arrayStride: 7516, attributes: [{format: 'uint8x4', offset: 132, shaderLocation: 6}]}, |
| ], |
| }, |
| primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint32', frontFace: 'cw', unclippedDepth: false}, |
| }); |
| gc(); |
| let bindGroupLayout5 = device0.createBindGroupLayout({ |
| label: '\uf4dc\u{1fd54}\u440d\u5202\u5ac9\u{1fb55}\u0cfb\ueea3', |
| entries: [{binding: 5278, visibility: GPUShaderStage.VERTEX, externalTexture: {}}], |
| }); |
| let commandEncoder10 = device0.createCommandEncoder(); |
| try { |
| renderBundleEncoder5.setBindGroup(1, bindGroup0, new Uint32Array(9652), 4748, 0); |
| } catch {} |
| let imageBitmap1 = await createImageBitmap(offscreenCanvas0); |
| let texture14 = device0.createTexture({ |
| size: {width: 1905}, |
| dimension: '1d', |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let texture15 = gpuCanvasContext0.getCurrentTexture(); |
| let renderBundleEncoder6 = device0.createRenderBundleEncoder({ |
| label: '\u{1f8c4}\u7fc3\uea10\ubd4e\u20b8\u0f7f\u{1fd11}\u{1fd8c}', |
| colorFormats: ['r16uint', 'rgba16uint', 'rg16sint', 'r8sint', 'rg32uint', 'rg8unorm', 'rgb10a2unorm'], |
| sampleCount: 4, |
| depthReadOnly: true, |
| }); |
| let renderBundle9 = renderBundleEncoder3.finish(); |
| let externalTexture5 = device0.importExternalTexture({label: '\u70f1\u0222\u47e1\u{1fafd}\u5cdf\u63c9\u075c\u0cdd\uc917\u{1f65e}', source: videoFrame0}); |
| try { |
| renderBundleEncoder2.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderBundleEncoder6.setVertexBuffer(2587, undefined); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer2]); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer2, 141776, new BigUint64Array(63945), 25379, 2180); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 80, height: 8, depthOrArrayLayers: 1} |
| */ |
| { |
| source: offscreenCanvas1, |
| origin: { x: 63, y: 86 }, |
| flipY: false, |
| }, { |
| texture: texture4, |
| mipLevel: 0, |
| origin: {x: 29, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 10, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let externalTexture6 = device0.importExternalTexture({source: video0, colorSpace: 'display-p3'}); |
| try { |
| computePassEncoder0.setPipeline(pipeline0); |
| } catch {} |
| try { |
| buffer1.unmap(); |
| } catch {} |
| try { |
| commandEncoder7.resolveQuerySet(querySet4, 2384, 1613, buffer0, 181760); |
| } catch {} |
| let pipeline7 = device0.createRenderPipeline({ |
| label: '\u032a\u0794\u{1fe5f}', |
| layout: pipelineLayout0, |
| multisample: {count: 4, mask: 0xb7e11937}, |
| fragment: { |
| module: shaderModule2, |
| entryPoint: 'fragment0', |
| targets: [{format: 'r16uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN}, {format: 'rgba16uint', writeMask: GPUColorWrite.ALPHA}, {format: 'rg16sint'}, {format: 'r8sint'}, {format: 'rg32uint'}, { |
| format: 'rg8unorm', |
| blend: { |
| color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'}, |
| alpha: {operation: 'subtract', srcFactor: 'one-minus-dst', dstFactor: 'src-alpha-saturated'}, |
| }, |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA, |
| }, { |
| format: 'rgb10a2unorm', |
| blend: { |
| color: {operation: 'reverse-subtract', srcFactor: 'src-alpha', dstFactor: 'one-minus-dst-alpha'}, |
| alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'}, |
| }, |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED, |
| }], |
| }, |
| vertex: { |
| module: shaderModule2, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 0, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'float16x4', offset: 7856, shaderLocation: 12}, |
| {format: 'uint8x2', offset: 6846, shaderLocation: 6}, |
| {format: 'sint32x3', offset: 8280, shaderLocation: 4}, |
| {format: 'sint16x2', offset: 34116, shaderLocation: 10}, |
| {format: 'float32x2', offset: 5376, shaderLocation: 9}, |
| {format: 'sint32x3', offset: 3556, shaderLocation: 15}, |
| {format: 'uint32x2', offset: 4096, shaderLocation: 2}, |
| {format: 'unorm16x4', offset: 15796, shaderLocation: 8}, |
| {format: 'sint8x2', offset: 4562, shaderLocation: 7}, |
| {format: 'sint32x4', offset: 8664, shaderLocation: 13}, |
| {format: 'float32x4', offset: 17748, shaderLocation: 17}, |
| {format: 'float32', offset: 404, shaderLocation: 11}, |
| {format: 'uint8x2', offset: 10726, shaderLocation: 1}, |
| {format: 'uint32', offset: 14740, shaderLocation: 3}, |
| {format: 'unorm16x2', offset: 4872, shaderLocation: 14}, |
| {format: 'sint32x2', offset: 1760, shaderLocation: 0}, |
| {format: 'sint16x4', offset: 27964, shaderLocation: 16}, |
| {format: 'unorm10-10-10-2', offset: 656, shaderLocation: 5}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-list', cullMode: 'front', unclippedDepth: true}, |
| }); |
| offscreenCanvas2.width = 344; |
| let canvas4 = document.createElement('canvas'); |
| try { |
| canvas4.getContext('webgl2'); |
| } catch {} |
| let buffer3 = device0.createBuffer({ |
| label: '\u2c1f\u8046\u622f\u8b16\u096e\u05a5', |
| size: 212041, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE, |
| }); |
| let commandEncoder11 = device0.createCommandEncoder(); |
| let texture16 = device0.createTexture({ |
| label: '\u25c8\ue05f\ua55c\u2c02\u095b\u09dc', |
| size: {width: 952, height: 2, depthOrArrayLayers: 154}, |
| mipLevelCount: 6, |
| dimension: '3d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rg32uint', 'rg32uint'], |
| }); |
| try { |
| renderBundleEncoder4.setIndexBuffer(buffer1, 'uint16', 172182, 41176); |
| } catch {} |
| try { |
| commandEncoder9.copyTextureToTexture({ |
| texture: texture13, |
| mipLevel: 1, |
| origin: {x: 14, y: 9, z: 10}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture14, |
| mipLevel: 0, |
| origin: {x: 92, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 207, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 40, height: 1, depthOrArrayLayers: 17} |
| */ |
| { |
| source: imageBitmap1, |
| origin: { x: 50, y: 683443940 }, |
| flipY: false, |
| }, { |
| texture: texture2, |
| mipLevel: 3, |
| origin: {x: 1, y: 0, z: 5}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline8 = device0.createComputePipeline({ |
| label: '\u6603\u08d7', |
| layout: pipelineLayout1, |
| compute: {module: shaderModule1, entryPoint: 'compute0'}, |
| }); |
| let imageBitmap2 = await createImageBitmap(offscreenCanvas2); |
| let commandEncoder12 = device0.createCommandEncoder({label: '\u57a1\u{1f741}\ua97f\uc63b\ud6e6'}); |
| let textureView19 = texture8.createView({label: '\u3cf7\u091f\u{1f93f}', dimension: '2d-array', baseArrayLayer: 0}); |
| let computePassEncoder4 = commandEncoder7.beginComputePass({label: '\uf1da\u2924\u{1fcc3}\ufe56\ud750\u{1fd7b}'}); |
| let renderBundleEncoder7 = device0.createRenderBundleEncoder({ |
| label: '\u{1f9a2}\uf67d\uf9d1\u{1fa26}\u0e6d\u2454\u{1f9b6}\uc416', |
| colorFormats: ['r16uint', 'rgba16uint', 'rg16sint', 'r8sint', 'rg32uint', 'rg8unorm', 'rgb10a2unorm'], |
| sampleCount: 4, |
| }); |
| try { |
| renderBundleEncoder4.setPipeline(pipeline7); |
| } catch {} |
| try { |
| commandEncoder10.clearBuffer(buffer2, 157452, 18244); |
| dissociateBuffer(device0, buffer2); |
| } catch {} |
| try { |
| commandEncoder8.resolveQuerySet(querySet8, 1186, 885, buffer0, 251648); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture4, |
| mipLevel: 2, |
| origin: {x: 3, y: 0, z: 0}, |
| aspect: 'all', |
| }, new BigUint64Array(new ArrayBuffer(24)), /* required buffer size: 742 */ |
| {offset: 742, rowsPerImage: 87}, {width: 9, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let querySet9 = device0.createQuerySet({label: '\u0e55\u{1f9d3}\u{1fe71}\u0182\u2898\uf1e8', type: 'occlusion', count: 1077}); |
| let textureView20 = texture1.createView({ |
| label: '\u0ce6\u802d\ub431\u0196\u0de8\u4d05\ua353\u0d1d\u0781\u296e\uac1d', |
| dimension: '3d', |
| baseMipLevel: 1, |
| }); |
| let renderBundleEncoder8 = device0.createRenderBundleEncoder({ |
| label: '\ua4a3\u0347\u0328\u41d9\u{1f813}\u64a4\uc2ee\ub137\u64b1', |
| colorFormats: ['r16uint', 'rgba16uint', 'rg16sint', 'r8sint', 'rg32uint', 'rg8unorm', 'rgb10a2unorm'], |
| sampleCount: 4, |
| depthReadOnly: true, |
| stencilReadOnly: true, |
| }); |
| try { |
| computePassEncoder0.setBindGroup(2, bindGroup0); |
| } catch {} |
| try { |
| renderBundleEncoder2.setPipeline(pipeline7); |
| } catch {} |
| try { |
| commandEncoder11.copyBufferToBuffer(buffer3, 61048, buffer2, 261872, 1692); |
| dissociateBuffer(device0, buffer3); |
| dissociateBuffer(device0, buffer2); |
| } catch {} |
| try { |
| commandEncoder5.clearBuffer(buffer2, 262880, 308); |
| dissociateBuffer(device0, buffer2); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer2, 620, new BigUint64Array(58379), 1084, 5116); |
| } catch {} |
| let textureView21 = texture0.createView({label: '\u592f\u3911', mipLevelCount: 8, baseArrayLayer: 9, arrayLayerCount: 25}); |
| try { |
| renderBundleEncoder2.setBindGroup(1, bindGroup0); |
| } catch {} |
| try { |
| commandEncoder12.copyBufferToBuffer(buffer3, 20696, buffer2, 158812, 20168); |
| dissociateBuffer(device0, buffer3); |
| dissociateBuffer(device0, buffer2); |
| } catch {} |
| try { |
| commandEncoder9.resolveQuerySet(querySet0, 243, 53, buffer0, 171776); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer0]); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| document.body.prepend(canvas4); |
| let commandBuffer3 = commandEncoder12.finish({label: '\u683d\u1410\u{1fa8f}\u5630\u4661\uaa24\u63ae\u6080\u5161'}); |
| let texture17 = device0.createTexture({ |
| size: {width: 160, height: 16, depthOrArrayLayers: 75}, |
| dimension: '3d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_SRC, |
| viewFormats: ['rg32uint', 'rg32uint'], |
| }); |
| let textureView22 = texture5.createView({label: '\u{1f848}\u5f89\u{1f9ee}\u01a5', dimension: '2d', baseMipLevel: 3}); |
| try { |
| renderBundleEncoder4.setBindGroup(0, bindGroup0, new Uint32Array(7306), 5305, 0); |
| } catch {} |
| try { |
| commandEncoder5.copyBufferToTexture({ |
| /* bytesInLastRow: 2360 widthInBlocks: 1180 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 15988 */ |
| offset: 13628, |
| buffer: buffer3, |
| }, { |
| texture: texture14, |
| mipLevel: 0, |
| origin: {x: 58, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 1180, height: 1, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| let videoFrame1 = new VideoFrame(canvas2, {timestamp: 0}); |
| let commandEncoder13 = device0.createCommandEncoder({label: '\uc734\u0b68\u1d81\u1052\u5d0c\u2859\uc44a\u0d4b\u0370\u5431'}); |
| let commandBuffer4 = commandEncoder9.finish(); |
| let textureView23 = texture13.createView({ |
| label: '\u030e\uee42\u{1fcfc}\u07de\u{1fa3e}', |
| baseMipLevel: 1, |
| mipLevelCount: 1, |
| baseArrayLayer: 140, |
| arrayLayerCount: 84, |
| }); |
| try { |
| computePassEncoder0.setBindGroup(2, bindGroup1, new Uint32Array(8980), 4824, 0); |
| } catch {} |
| try { |
| commandEncoder8.copyTextureToBuffer({ |
| texture: texture6, |
| mipLevel: 0, |
| origin: {x: 106, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 800 widthInBlocks: 200 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 22496 */ |
| offset: 22496, |
| buffer: buffer2, |
| }, {width: 200, height: 0, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer2); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer1, commandBuffer3]); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer2, 9076, new BigUint64Array(4965), 195, 1020); |
| } catch {} |
| let pipeline9 = await device0.createComputePipelineAsync({ |
| label: '\uefc3\ua1e9\u5f28\ub731\ue583\u{1fa4a}\u{1fe3e}', |
| layout: 'auto', |
| compute: {module: shaderModule0, entryPoint: 'compute0', constants: {}}, |
| }); |
| try { |
| gpuCanvasContext4.unconfigure(); |
| } catch {} |
| document.body.prepend(video0); |
| let querySet10 = device0.createQuerySet({label: '\u0595\u2c66\u9d5f\u{1fb49}\ucdaf\u001b\u{1f6d3}', type: 'occlusion', count: 3932}); |
| let texture18 = device0.createTexture({ |
| label: '\u{1fe50}\ueabf\u0cc6\ue4ab\u{1f72a}\u388f\u1f03\u209c\u67b1\u7ed5\u{1fe28}', |
| size: [952, 2, 183], |
| mipLevelCount: 6, |
| dimension: '3d', |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| let textureView24 = texture3.createView({label: '\u{1fd60}\ud70e\u6b5b\ue5f9\ua4ef\u7d08', dimension: '2d-array'}); |
| let computePassEncoder5 = commandEncoder8.beginComputePass({label: '\ufacb\ufb7b'}); |
| let externalTexture7 = device0.importExternalTexture({label: '\u2e1e\ue50e\udc79\u0141\u{1f842}\ud8bf\ub4a4', source: video0, colorSpace: 'srgb'}); |
| try { |
| computePassEncoder0.setBindGroup(3, bindGroup1, new Uint32Array(4848), 3711, 0); |
| } catch {} |
| try { |
| renderBundleEncoder8.setPipeline(pipeline7); |
| } catch {} |
| try { |
| commandEncoder10.copyTextureToTexture({ |
| texture: texture16, |
| mipLevel: 3, |
| origin: {x: 6, y: 0, z: 3}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture1, |
| mipLevel: 0, |
| origin: {x: 460, y: 7, z: 116}, |
| aspect: 'all', |
| }, |
| {width: 1, height: 0, depthOrArrayLayers: 12}); |
| } catch {} |
| try { |
| commandEncoder3.resolveQuerySet(querySet1, 128, 90, buffer0, 108032); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 10, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: offscreenCanvas2, |
| origin: { x: 36, y: 32 }, |
| flipY: true, |
| }, { |
| texture: texture4, |
| mipLevel: 3, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline10 = device0.createComputePipeline({layout: pipelineLayout3, compute: {module: shaderModule3, entryPoint: 'compute0'}}); |
| let commandEncoder14 = device0.createCommandEncoder({label: '\u50f0\ucfa2\u0ceb\ubd66\u0e59\u{1fdcc}\ue841\u019e\u9473'}); |
| let querySet11 = device0.createQuerySet({label: '\u13e4\u792c\uca7a\u1f7f\u{1f761}\u621a\u068b', type: 'occlusion', count: 2227}); |
| let texture19 = device0.createTexture({ |
| label: '\u8bad\u0e53\uecb9\u0c73\u08c2\u893e\u{1f8cf}\u014d\udc01\uc4ca\u{1ff5e}', |
| size: [162, 7, 1854], |
| mipLevelCount: 4, |
| dimension: '3d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let renderBundle10 = renderBundleEncoder5.finish({label: '\u074e\uba15\u7b4b\u018f\u8ab2\u50bf\u0d2d\u0f48\u2a88\u09c7\u0bf0'}); |
| let externalTexture8 = device0.importExternalTexture({ |
| label: '\ud3fd\u4770\u0f8e\u0189\u73fa\u{1fb39}\ucfaf\u0d59', |
| source: video0, |
| colorSpace: 'display-p3', |
| }); |
| try { |
| computePassEncoder2.setBindGroup(3, bindGroup1); |
| } catch {} |
| try { |
| renderBundleEncoder2.setPipeline(pipeline7); |
| } catch {} |
| try { |
| commandEncoder13.copyTextureToTexture({ |
| texture: texture16, |
| mipLevel: 0, |
| origin: {x: 24, y: 0, z: 19}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture1, |
| mipLevel: 0, |
| origin: {x: 18, y: 18, z: 10}, |
| aspect: 'all', |
| }, |
| {width: 590, height: 2, depthOrArrayLayers: 43}); |
| } catch {} |
| try { |
| commandEncoder3.clearBuffer(buffer2, 32776, 186556); |
| dissociateBuffer(device0, buffer2); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer2, 86516, new Float32Array(36634), 6616, 488); |
| } catch {} |
| gc(); |
| let adapter1 = await navigator.gpu.requestAdapter({}); |
| let textureView25 = texture11.createView({ |
| label: '\u983f\u{1f83e}\u3c8a\ud5fc\ube57\u7905\ue59b\ua5dc', |
| aspect: 'all', |
| baseMipLevel: 6, |
| baseArrayLayer: 8, |
| arrayLayerCount: 2, |
| }); |
| let renderBundle11 = renderBundleEncoder1.finish({}); |
| try { |
| computePassEncoder5.setBindGroup(1, bindGroup0); |
| } catch {} |
| try { |
| querySet1.destroy(); |
| } catch {} |
| try { |
| commandEncoder13.resolveQuerySet(querySet0, 1160, 1010, buffer0, 143104); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture4, |
| mipLevel: 3, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, new ArrayBuffer(48), /* required buffer size: 480 */ |
| {offset: 452}, {width: 7, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| let bindGroup2 = device0.createBindGroup({layout: bindGroupLayout0, entries: [{binding: 5545, resource: externalTexture4}]}); |
| let texture20 = device0.createTexture({ |
| size: [320, 32, 1], |
| mipLevelCount: 1, |
| format: 'r16uint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderBundleEncoder2.setBindGroup(0, bindGroup0, new Uint32Array(119), 48, 0); |
| } catch {} |
| try { |
| renderBundleEncoder6.setPipeline(pipeline6); |
| } catch {} |
| try { |
| commandEncoder10.copyBufferToTexture({ |
| /* bytesInLastRow: 392 widthInBlocks: 196 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 22678 */ |
| offset: 22678, |
| buffer: buffer3, |
| }, { |
| texture: texture14, |
| mipLevel: 0, |
| origin: {x: 284, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 196, height: 0, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer2, 3160, new BigUint64Array(21238), 16287, 500); |
| } catch {} |
| document.body.prepend(canvas0); |
| let commandEncoder15 = device0.createCommandEncoder({label: '\u63e3\u0622\u{1f647}\u0363\u0047\u{1f7ea}'}); |
| let textureView26 = texture12.createView({label: '\u{1fa3c}\u44bd', dimension: '2d', baseMipLevel: 1, mipLevelCount: 3, baseArrayLayer: 674}); |
| let computePassEncoder6 = commandEncoder11.beginComputePass({label: '\u9c7d\u091f\u1af7\ua1a0\u05fa\u{1fa64}\ua57b\u9e91\uc312'}); |
| try { |
| renderBundleEncoder6.setPipeline(pipeline7); |
| } catch {} |
| try { |
| commandEncoder13.copyBufferToBuffer(buffer3, 118628, buffer2, 174532, 156); |
| dissociateBuffer(device0, buffer3); |
| dissociateBuffer(device0, buffer2); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 81, height: 3, depthOrArrayLayers: 34} |
| */ |
| { |
| source: canvas0, |
| origin: { x: 6, y: 75 }, |
| flipY: false, |
| }, { |
| texture: texture2, |
| mipLevel: 2, |
| origin: {x: 4, y: 0, z: 1}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 13, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder16 = device0.createCommandEncoder({}); |
| let texture21 = device0.createTexture({ |
| size: [648, 30, 41], |
| mipLevelCount: 9, |
| format: 'astc-8x6-unorm-srgb', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['astc-8x6-unorm-srgb', 'astc-8x6-unorm'], |
| }); |
| let textureView27 = texture17.createView({label: '\u2ff0\u8c1e\u6390\u{1fb90}\u8536'}); |
| let renderBundleEncoder9 = device0.createRenderBundleEncoder({ |
| label: '\u0e59\u98f2\u0e2c\u0c8d\uc5e0\u0341\ud582\u{1f6c6}', |
| colorFormats: ['r16uint', 'rgba16uint', 'rg16sint', 'r8sint', 'rg32uint', 'rg8unorm', 'rgb10a2unorm'], |
| sampleCount: 4, |
| }); |
| let sampler2 = device0.createSampler({ |
| label: '\u{1ffc3}\u1b56\u4daf\u{1fef5}\u{1ff7b}\u0310\u{1fa33}', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'repeat', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 56.41, |
| lodMaxClamp: 83.94, |
| }); |
| try { |
| computePassEncoder2.end(); |
| } catch {} |
| try { |
| commandEncoder16.copyBufferToTexture({ |
| /* bytesInLastRow: 1616 widthInBlocks: 404 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 36224 */ |
| offset: 32816, |
| bytesPerRow: 1792, |
| buffer: buffer3, |
| }, { |
| texture: texture7, |
| mipLevel: 0, |
| origin: {x: 372, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 404, height: 2, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| gpuCanvasContext3.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rgba16float', 'rgba16float', 'rgba16float'], |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer2, 53944, new Float32Array(52762), 10142, 344); |
| } catch {} |
| let video1 = await videoWithData(); |
| let bindGroup3 = device0.createBindGroup({ |
| label: '\ud103\u468b\u{1fd51}\u{1fd20}', |
| layout: bindGroupLayout1, |
| entries: [{binding: 2527, resource: sampler2}, {binding: 5302, resource: textureView22}], |
| }); |
| let commandEncoder17 = device0.createCommandEncoder({label: '\u5923\u{1fee4}\uf2fa\u{1ffa2}\ud2a9\u{1febc}'}); |
| let texture22 = device0.createTexture({ |
| label: '\ub2e2\uf2c9\u0bc3\ud17d\u6b3d\u59ed\u0021\u09ca\u48e6\ue430\u0424', |
| size: {width: 640, height: 64, depthOrArrayLayers: 302}, |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture23 = gpuCanvasContext0.getCurrentTexture(); |
| let textureView28 = texture11.createView({ |
| label: '\uaee7\u{1fbb4}\u3832\u{1fca9}\ufd02\u{1fac2}\u8c01\u{1fa95}\uf269\u{1fbd0}', |
| dimension: '2d', |
| baseMipLevel: 1, |
| mipLevelCount: 1, |
| baseArrayLayer: 25, |
| }); |
| try { |
| computePassEncoder0.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderBundleEncoder2.setBindGroup(0, bindGroup0); |
| } catch {} |
| try { |
| commandEncoder14.copyBufferToTexture({ |
| /* bytesInLastRow: 1656 widthInBlocks: 414 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 49752 */ |
| offset: 49752, |
| bytesPerRow: 1792, |
| rowsPerImage: 13, |
| buffer: buffer3, |
| }, { |
| texture: texture7, |
| mipLevel: 0, |
| origin: {x: 319, y: 1, z: 0}, |
| aspect: 'all', |
| }, {width: 414, height: 1, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| commandEncoder5.resolveQuerySet(querySet4, 1741, 1192, buffer0, 136448); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 40, height: 4, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageBitmap0, |
| origin: { x: 2795869, y: 1032392876 }, |
| flipY: true, |
| }, { |
| texture: texture4, |
| mipLevel: 1, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 4, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let video2 = await videoWithData(); |
| let querySet12 = device0.createQuerySet({ |
| label: '\u0f08\ufda7\uad97\u3b7e\u5976\ud613\u{1fbba}\u{1fa2d}\u04e2\u{1fd4d}', |
| type: 'occlusion', |
| count: 3881, |
| }); |
| let texture24 = device0.createTexture({ |
| label: '\u962c\u0986\u0b1b\uf6db\u0332', |
| size: [3810], |
| dimension: '1d', |
| format: 'r16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView29 = texture14.createView({label: '\u{1f753}\u3aff\u086e\ufd9d\u{1fe41}\u0962\u0d10'}); |
| let renderBundle12 = renderBundleEncoder2.finish({label: '\u8859\u9085\u089e\ua46b\ua9df\u{1f72c}\u05aa\u4ee0\u{1f9a8}\u039b\u3f8a'}); |
| let externalTexture9 = device0.importExternalTexture({label: '\u{1fd01}\u6d32\u{1f9c0}\ub952\u4302\u{1f6f2}\uad22', source: videoFrame0, colorSpace: 'srgb'}); |
| try { |
| commandEncoder13.copyTextureToTexture({ |
| texture: texture11, |
| mipLevel: 3, |
| origin: {x: 0, y: 0, z: 8}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture11, |
| mipLevel: 9, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 6, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder16.pushDebugGroup('\u07e4'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer2, 15304, new DataView(new ArrayBuffer(22292)), 7817, 5024); |
| } catch {} |
| let pipeline11 = await device0.createComputePipelineAsync({ |
| label: '\uf73c\u6317\ud28a\udd09\u0375\u{1fd8f}\u{1fdd2}\u661e\u73ec\u6001', |
| layout: pipelineLayout3, |
| compute: {module: shaderModule1, entryPoint: 'compute0', constants: {}}, |
| }); |
| let commandEncoder18 = device0.createCommandEncoder(); |
| let textureView30 = texture4.createView({dimension: '2d', mipLevelCount: 1}); |
| let externalTexture10 = device0.importExternalTexture({label: '\u0868\u{1fba5}\u2d2f\u{1fd38}\u0e40\u{1fcf1}\u6124', source: video2, colorSpace: 'srgb'}); |
| try { |
| computePassEncoder4.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderBundleEncoder4.setPipeline(pipeline6); |
| } catch {} |
| try { |
| commandEncoder15.copyBufferToBuffer(buffer3, 40972, buffer2, 39848, 41560); |
| dissociateBuffer(device0, buffer3); |
| dissociateBuffer(device0, buffer2); |
| } catch {} |
| try { |
| commandEncoder13.clearBuffer(buffer2, 233000, 23920); |
| dissociateBuffer(device0, buffer2); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let pipeline12 = await device0.createRenderPipelineAsync({ |
| label: '\u{1fa58}\u0cac', |
| layout: pipelineLayout2, |
| multisample: {count: 4}, |
| depthStencil: { |
| format: 'stencil8', |
| depthWriteEnabled: false, |
| stencilFront: {compare: 'equal', failOp: 'zero', depthFailOp: 'keep'}, |
| stencilBack: {compare: 'greater', failOp: 'increment-wrap', passOp: 'decrement-wrap'}, |
| stencilReadMask: 1281310471, |
| stencilWriteMask: 1111448909, |
| depthBias: -2011575621, |
| depthBiasSlopeScale: 0.0, |
| depthBiasClamp: 758.9532701538141, |
| }, |
| vertex: { |
| module: shaderModule3, |
| entryPoint: 'vertex0', |
| buffers: [ |
| {arrayStride: 0, stepMode: 'instance', attributes: []}, |
| { |
| arrayStride: 21288, |
| attributes: [ |
| {format: 'unorm16x4', offset: 296, shaderLocation: 2}, |
| {format: 'uint8x4', offset: 3300, shaderLocation: 4}, |
| ], |
| }, |
| { |
| arrayStride: 0, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'uint16x2', offset: 172, shaderLocation: 15}, |
| {format: 'uint8x4', offset: 444, shaderLocation: 13}, |
| {format: 'float16x2', offset: 12848, shaderLocation: 14}, |
| {format: 'sint32', offset: 22916, shaderLocation: 9}, |
| {format: 'uint32x3', offset: 12344, shaderLocation: 0}, |
| {format: 'sint16x4', offset: 6248, shaderLocation: 1}, |
| {format: 'uint32x4', offset: 8828, shaderLocation: 5}, |
| {format: 'sint32x4', offset: 17432, shaderLocation: 3}, |
| {format: 'snorm16x4', offset: 4952, shaderLocation: 17}, |
| ], |
| }, |
| { |
| arrayStride: 6000, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'uint32', offset: 168, shaderLocation: 8}, |
| {format: 'uint8x2', offset: 98, shaderLocation: 10}, |
| ], |
| }, |
| { |
| arrayStride: 3448, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'sint32x4', offset: 440, shaderLocation: 16}, |
| {format: 'unorm10-10-10-2', offset: 160, shaderLocation: 12}, |
| {format: 'unorm16x4', offset: 284, shaderLocation: 11}, |
| ], |
| }, |
| {arrayStride: 472, stepMode: 'vertex', attributes: []}, |
| { |
| arrayStride: 2700, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'unorm8x4', offset: 160, shaderLocation: 7}, |
| {format: 'float32', offset: 36, shaderLocation: 6}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {frontFace: 'cw', unclippedDepth: true}, |
| }); |
| let bindGroupLayout6 = device0.createBindGroupLayout({ |
| label: '\ud7cd\u{1f812}', |
| entries: [ |
| {binding: 2153, visibility: GPUShaderStage.COMPUTE, externalTexture: {}}, |
| { |
| binding: 7175, |
| visibility: 0, |
| storageTexture: { format: 'r32uint', access: 'write-only', viewDimension: '2d' }, |
| }, |
| ], |
| }); |
| let pipelineLayout5 = device0.createPipelineLayout({ |
| label: '\u{1fe77}\u117d\u{1fc35}\u022b\u03e2\udee0\u{1f6e7}\u{1f8ba}\u06de\u{1fa27}\u0b91', |
| bindGroupLayouts: [bindGroupLayout2, bindGroupLayout4, bindGroupLayout2], |
| }); |
| let buffer4 = device0.createBuffer({label: '\u71ad\u61fb\u{1f7da}', size: 116783, usage: GPUBufferUsage.MAP_WRITE}); |
| let commandEncoder19 = device0.createCommandEncoder({label: '\u035b\ua970'}); |
| let texture25 = device0.createTexture({ |
| size: [320], |
| dimension: '1d', |
| format: 'r16uint', |
| usage: GPUTextureUsage.COPY_SRC, |
| viewFormats: ['r16uint', 'r16uint', 'r16uint'], |
| }); |
| let textureView31 = texture14.createView({label: '\uf615\u{1fb32}', dimension: '1d'}); |
| let computePassEncoder7 = commandEncoder5.beginComputePass({label: '\u41e4\u042b\u92fa\u0060\ub7ca'}); |
| let renderBundle13 = renderBundleEncoder3.finish({label: '\u8c10\u0e80\uafdd\u0662\ua672\u4209\u{1f9fe}\ucb65\u012a'}); |
| try { |
| renderBundleEncoder7.setVertexBuffer(5441, undefined, 0); |
| } catch {} |
| try { |
| commandEncoder18.copyBufferToBuffer(buffer3, 96096, buffer2, 174972, 11768); |
| dissociateBuffer(device0, buffer3); |
| dissociateBuffer(device0, buffer2); |
| } catch {} |
| try { |
| commandEncoder6.clearBuffer(buffer2, 148552, 3396); |
| dissociateBuffer(device0, buffer2); |
| } catch {} |
| try { |
| commandEncoder17.resolveQuerySet(querySet2, 260, 1731, buffer0, 107776); |
| } catch {} |
| try { |
| commandEncoder16.popDebugGroup(); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture11, |
| mipLevel: 4, |
| origin: {x: 0, y: 0, z: 1}, |
| aspect: 'all', |
| }, new ArrayBuffer(8), /* required buffer size: 1_925_921 */ |
| {offset: 641, bytesPerRow: 420, rowsPerImage: 191}, {width: 60, height: 0, depthOrArrayLayers: 25}); |
| } catch {} |
| let pipeline13 = device0.createComputePipeline({ |
| label: '\u7f3d\u0c5f', |
| layout: pipelineLayout4, |
| compute: {module: shaderModule0, entryPoint: 'compute0'}, |
| }); |
| let canvas5 = document.createElement('canvas'); |
| let offscreenCanvas3 = new OffscreenCanvas(630, 350); |
| try { |
| commandEncoder18.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 8432 */ |
| offset: 8432, |
| bytesPerRow: 0, |
| rowsPerImage: 287, |
| buffer: buffer3, |
| }, { |
| texture: texture0, |
| mipLevel: 7, |
| origin: {x: 0, y: 0, z: 2}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 27}); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| renderBundleEncoder8.insertDebugMarker('\u{1f765}'); |
| } catch {} |
| let commandEncoder20 = device0.createCommandEncoder({label: '\u0660\u{1fcd2}\u8b0e\u1819'}); |
| let textureView32 = texture16.createView({ |
| label: '\u0806\u8fc5\ub686\u0bc1\u{1fe01}\u05de', |
| baseMipLevel: 1, |
| mipLevelCount: 2, |
| arrayLayerCount: 1, |
| }); |
| let sampler3 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 89.02, |
| lodMaxClamp: 90.38, |
| maxAnisotropy: 5, |
| }); |
| try { |
| computePassEncoder0.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderBundleEncoder8.setBindGroup(3, bindGroup2, new Uint32Array(7038), 592, 0); |
| } catch {} |
| try { |
| buffer1.unmap(); |
| } catch {} |
| try { |
| commandEncoder17.clearBuffer(buffer2, 73636, 14892); |
| dissociateBuffer(device0, buffer2); |
| } catch {} |
| try { |
| commandEncoder18.resolveQuerySet(querySet0, 2579, 256, buffer0, 276736); |
| } catch {} |
| let adapter2 = await navigator.gpu.requestAdapter(); |
| let offscreenCanvas4 = new OffscreenCanvas(272, 656); |
| let shaderModule5 = device0.createShaderModule({ |
| label: '\u3e2b\u{1f7f3}\u06bd\u1f7e\u01c5\u0418\u{1f935}\u2ef0\u44b0\u7a45', |
| code: `@group(0) @binding(5545) |
| var<storage, read_write> field1: array<u32>; |
| |
| @compute @workgroup_size(8, 3, 4) |
| fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {} |
| |
| struct FragmentOutput0 { |
| @location(3) f0: vec2<i32>, |
| @location(6) f1: vec4<f32>, |
| @location(5) f2: vec3<f32>, |
| @location(4) f3: vec2<u32>, |
| @location(0) f4: vec2<u32>, |
| @location(2) f5: vec2<i32>, |
| @location(1) f6: vec4<u32> |
| } |
| |
| @fragment |
| fn fragment0(@location(32) a0: f16, @builtin(front_facing) a1: bool, @location(29) a2: u32, @location(14) a3: vec3<f32>) -> FragmentOutput0 { |
| return FragmentOutput0(); |
| } |
| |
| struct S7 { |
| @location(15) f0: i32, |
| @location(8) f1: u32, |
| @location(1) f2: vec3<f16>, |
| @location(12) f3: vec3<f32>, |
| @location(17) f4: vec3<i32> |
| } |
| struct VertexOutput0 { |
| @location(17) f87: vec4<u32>, |
| @location(9) f88: vec4<f32>, |
| @location(26) f89: vec2<f32>, |
| @location(32) f90: f16, |
| @location(1) f91: f16, |
| @location(29) f92: u32, |
| @location(14) f93: vec3<f32>, |
| @builtin(position) f94: vec4<f32> |
| } |
| |
| @vertex |
| fn vertex0(a0: S7, @location(7) a1: vec3<i32>, @location(3) a2: vec4<u32>, @location(14) a3: vec3<i32>, @location(2) a4: vec4<f32>, @location(16) a5: vec3<f32>) -> VertexOutput0 { |
| return VertexOutput0(); |
| } |
| |
| `, |
| hints: {}, |
| }); |
| let textureView33 = texture12.createView({dimension: '2d', baseMipLevel: 2, mipLevelCount: 2, baseArrayLayer: 150}); |
| try { |
| renderBundleEncoder4.setBindGroup(1, bindGroup0); |
| } catch {} |
| try { |
| renderBundleEncoder6.setPipeline(pipeline6); |
| } catch {} |
| try { |
| querySet12.destroy(); |
| } catch {} |
| try { |
| commandEncoder3.resolveQuerySet(querySet7, 846, 187, buffer0, 59648); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['bgra8unorm-srgb', 'bgra8unorm-srgb'], |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let pipeline14 = device0.createRenderPipeline({ |
| layout: pipelineLayout1, |
| fragment: { |
| module: shaderModule3, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{format: 'r16uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.RED}, {format: 'rgba16uint'}, {format: 'rg16sint', writeMask: GPUColorWrite.GREEN}, {format: 'r8sint', writeMask: 0}, {format: 'rg32uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN | GPUColorWrite.RED}, {format: 'rg8unorm'}, {format: 'rgb10a2unorm', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN}], |
| }, |
| vertex: { |
| module: shaderModule3, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 7604, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'snorm16x2', offset: 64, shaderLocation: 2}, |
| {format: 'uint32', offset: 1280, shaderLocation: 0}, |
| {format: 'uint8x2', offset: 54, shaderLocation: 10}, |
| {format: 'uint32', offset: 640, shaderLocation: 15}, |
| {format: 'snorm16x4', offset: 880, shaderLocation: 6}, |
| {format: 'float32x2', offset: 220, shaderLocation: 7}, |
| {format: 'unorm16x4', offset: 40, shaderLocation: 11}, |
| {format: 'uint32x3', offset: 668, shaderLocation: 5}, |
| {format: 'uint32x4', offset: 1036, shaderLocation: 8}, |
| {format: 'unorm10-10-10-2', offset: 108, shaderLocation: 14}, |
| {format: 'uint32x4', offset: 48, shaderLocation: 4}, |
| {format: 'sint8x4', offset: 1104, shaderLocation: 9}, |
| {format: 'sint32x4', offset: 356, shaderLocation: 1}, |
| {format: 'uint32x3', offset: 120, shaderLocation: 13}, |
| {format: 'snorm8x2', offset: 496, shaderLocation: 17}, |
| ], |
| }, |
| { |
| arrayStride: 11340, |
| attributes: [ |
| {format: 'unorm16x4', offset: 628, shaderLocation: 12}, |
| {format: 'sint32', offset: 684, shaderLocation: 16}, |
| {format: 'sint32x4', offset: 4960, shaderLocation: 3}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'triangle-list', frontFace: 'cw', cullMode: 'back', unclippedDepth: true}, |
| }); |
| let commandEncoder21 = device0.createCommandEncoder({label: '\u466f\u1c96\u494b\u0905\u{1f7f9}\u0a50\u53c2'}); |
| let textureView34 = texture18.createView({label: '\u041a\u{1fb58}\u{1fcd6}\u33a4\ua50e\u{1fa8e}\u274f\u3f6b', baseMipLevel: 1, mipLevelCount: 3}); |
| let computePassEncoder8 = commandEncoder21.beginComputePass({}); |
| let externalTexture11 = device0.importExternalTexture({label: '\u{1f7fa}\u0842\u0d8e\ud920\u83e5\u25ac\u96b6\u3406\ud0e9', source: videoFrame1}); |
| try { |
| renderBundleEncoder7.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderBundleEncoder6.setVertexBuffer(4834, undefined); |
| } catch {} |
| try { |
| commandEncoder20.copyTextureToTexture({ |
| texture: texture24, |
| mipLevel: 0, |
| origin: {x: 3467, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture9, |
| mipLevel: 2, |
| origin: {x: 1, y: 0, z: 2}, |
| aspect: 'all', |
| }, |
| {width: 6, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| commandEncoder18.resolveQuerySet(querySet9, 239, 300, buffer0, 145664); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer2, 21108, new DataView(new ArrayBuffer(46124)), 25273, 7116); |
| } catch {} |
| let gpuCanvasContext5 = offscreenCanvas3.getContext('webgpu'); |
| let canvas6 = document.createElement('canvas'); |
| let offscreenCanvas5 = new OffscreenCanvas(583, 272); |
| try { |
| canvas5.getContext('2d'); |
| } catch {} |
| let bindGroup4 = device0.createBindGroup({ |
| label: '\u01ad\u8f7e\ud812\u7a6b\uc90b\u1d7b\u9621', |
| layout: bindGroupLayout0, |
| entries: [{binding: 5545, resource: externalTexture3}], |
| }); |
| let commandEncoder22 = device0.createCommandEncoder(); |
| let textureView35 = texture24.createView({label: '\u0539\u{1f6a0}\u{1f653}\u05f0\ua4d9\u3100\u2c1f\u0085', baseArrayLayer: 0}); |
| let renderBundle14 = renderBundleEncoder4.finish({}); |
| try { |
| device0.queue.writeBuffer(buffer2, 41660, new Int16Array(60996), 47554, 7820); |
| } catch {} |
| let pipelineLayout6 = device0.createPipelineLayout({ |
| label: '\ub2bc\u06e1\uf8bc\ue657\u0801\u{1f801}\u7f1b\ub51c', |
| bindGroupLayouts: [bindGroupLayout0, bindGroupLayout3], |
| }); |
| try { |
| commandEncoder13.copyBufferToTexture({ |
| /* bytesInLastRow: 40 widthInBlocks: 10 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 3148 */ |
| offset: 3148, |
| bytesPerRow: 256, |
| buffer: buffer3, |
| }, { |
| texture: texture2, |
| mipLevel: 5, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 10, height: 1, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| commandEncoder22.copyTextureToTexture({ |
| texture: texture13, |
| mipLevel: 0, |
| origin: {x: 185, y: 4, z: 63}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture14, |
| mipLevel: 0, |
| origin: {x: 174, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 280, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(video0); |
| gc(); |
| let canvas7 = document.createElement('canvas'); |
| let shaderModule6 = device0.createShaderModule({ |
| label: '\u050a\u88af\u{1fe39}\u0227\u{1fdeb}\u{1f64c}\u20e0\u{1fe7e}\u2852', |
| code: `@group(0) @binding(765) |
| var<storage, read_write> n1: array<u32>; |
| @group(2) @binding(5830) |
| var<storage, read_write> field2: array<u32>; |
| @group(2) @binding(5287) |
| var<storage, read_write> type2: array<u32>; |
| @group(2) @binding(765) |
| var<storage, read_write> function3: array<u32>; |
| @group(0) @binding(5287) |
| var<storage, read_write> type3: array<u32>; |
| |
| @compute @workgroup_size(4, 3, 1) |
| fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {} |
| |
| struct FragmentOutput0 { |
| @location(3) f0: vec4<i32>, |
| @location(2) f1: vec3<i32>, |
| @location(1) f2: vec4<u32>, |
| @location(4) f3: vec2<u32>, |
| @location(5) f4: vec4<f32>, |
| @location(0) f5: u32, |
| @location(6) f6: vec4<f32> |
| } |
| |
| @fragment |
| fn fragment0(@location(38) a0: vec2<i32>, @location(34) a1: i32, @location(39) a2: vec3<i32>, @location(3) a3: vec4<f32>) -> FragmentOutput0 { |
| return FragmentOutput0(); |
| } |
| |
| struct VertexOutput0 { |
| @location(40) f95: f32, |
| @location(6) f96: vec2<u32>, |
| @location(18) f97: u32, |
| @location(12) f98: u32, |
| @location(41) f99: vec4<f16>, |
| @builtin(position) f100: vec4<f32>, |
| @location(22) f101: i32, |
| @location(19) f102: f32, |
| @location(13) f103: f32, |
| @location(8) f104: i32, |
| @location(20) f105: f16, |
| @location(11) f106: vec4<u32>, |
| @location(10) f107: vec4<i32>, |
| @location(4) f108: vec4<u32>, |
| @location(35) f109: i32, |
| @location(3) f110: vec4<f32>, |
| @location(31) f111: i32, |
| @location(26) f112: vec2<i32>, |
| @location(38) f113: vec2<i32>, |
| @location(34) f114: i32, |
| @location(1) f115: vec2<u32>, |
| @location(39) f116: vec3<i32>, |
| @location(16) f117: f16, |
| @location(21) f118: u32, |
| @location(32) f119: vec3<u32>, |
| @location(24) f120: vec3<f16>, |
| @location(15) f121: vec4<i32>, |
| @location(25) f122: vec3<f32>, |
| @location(37) f123: vec4<i32>, |
| @location(27) f124: vec3<f32>, |
| @location(14) f125: vec3<u32> |
| } |
| |
| @vertex |
| fn vertex0(@builtin(instance_index) a0: u32, @location(16) a1: f32) -> VertexOutput0 { |
| return VertexOutput0(); |
| } |
| |
| `, |
| hints: {}, |
| }); |
| let commandEncoder23 = device0.createCommandEncoder(); |
| let sampler4 = device0.createSampler({ |
| label: '\u0aea\u028a\u027b\u045d\u{1f758}\u081d\u{1f7ad}\u{1fcf4}', |
| addressModeU: 'repeat', |
| minFilter: 'nearest', |
| lodMaxClamp: 45.30, |
| }); |
| try { |
| computePassEncoder8.setBindGroup(0, bindGroup4, []); |
| } catch {} |
| try { |
| computePassEncoder8.setBindGroup(3, bindGroup1, new Uint32Array(528), 397, 0); |
| } catch {} |
| try { |
| renderBundleEncoder7.setBindGroup(1, bindGroup0, new Uint32Array(5910), 1254, 0); |
| } catch {} |
| try { |
| renderBundleEncoder6.setIndexBuffer(buffer1, 'uint16', 257304, 21762); |
| } catch {} |
| try { |
| commandEncoder6.copyBufferToBuffer(buffer3, 206176, buffer2, 245368, 4540); |
| dissociateBuffer(device0, buffer3); |
| dissociateBuffer(device0, buffer2); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer2, 11232, new Float32Array(15161), 11902, 1284); |
| } catch {} |
| let imageBitmap3 = await createImageBitmap(imageBitmap0); |
| let renderBundleEncoder10 = device0.createRenderBundleEncoder({ |
| colorFormats: ['r16uint', 'rgba16uint', 'rg16sint', 'r8sint', 'rg32uint', 'rg8unorm', 'rgb10a2unorm'], |
| sampleCount: 4, |
| depthReadOnly: true, |
| stencilReadOnly: true, |
| }); |
| try { |
| computePassEncoder8.setBindGroup(1, bindGroup4, new Uint32Array(7016), 2112, 0); |
| } catch {} |
| try { |
| commandEncoder20.copyBufferToTexture({ |
| /* bytesInLastRow: 696 widthInBlocks: 174 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1720 */ |
| offset: 1720, |
| bytesPerRow: 1024, |
| buffer: buffer3, |
| }, { |
| texture: texture6, |
| mipLevel: 0, |
| origin: {x: 191, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 174, height: 1, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| let pipeline15 = await device0.createRenderPipelineAsync({ |
| label: '\u0002\u076e', |
| layout: pipelineLayout1, |
| fragment: { |
| module: shaderModule0, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{format: 'r16uint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.RED}, {format: 'rgba16uint', writeMask: GPUColorWrite.ALPHA}, {format: 'rg16sint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN}, {format: 'r8sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.RED}, {format: 'rg32uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA}, {format: 'rg8unorm'}, { |
| format: 'rgb10a2unorm', |
| blend: { |
| color: {operation: 'subtract', srcFactor: 'src-alpha-saturated', dstFactor: 'src'}, |
| alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'}, |
| }, |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED, |
| }], |
| }, |
| depthStencil: { |
| format: 'stencil8', |
| depthCompare: 'always', |
| stencilFront: {compare: 'greater-equal', failOp: 'invert', depthFailOp: 'increment-clamp', passOp: 'zero'}, |
| stencilBack: {compare: 'greater-equal', depthFailOp: 'decrement-clamp', passOp: 'increment-wrap'}, |
| stencilReadMask: 112956267, |
| stencilWriteMask: 2026152666, |
| depthBias: -2141771313, |
| depthBiasClamp: 496.50205213773904, |
| }, |
| vertex: { |
| module: shaderModule0, |
| entryPoint: 'vertex0', |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 0, |
| attributes: [ |
| {format: 'unorm16x4', offset: 5956, shaderLocation: 10}, |
| {format: 'snorm16x4', offset: 1340, shaderLocation: 11}, |
| {format: 'float32x4', offset: 7448, shaderLocation: 13}, |
| ], |
| }, |
| {arrayStride: 14360, stepMode: 'instance', attributes: []}, |
| { |
| arrayStride: 4236, |
| stepMode: 'instance', |
| attributes: [{format: 'unorm8x2', offset: 272, shaderLocation: 2}], |
| }, |
| { |
| arrayStride: 992, |
| stepMode: 'instance', |
| attributes: [{format: 'snorm8x4', offset: 40, shaderLocation: 17}], |
| }, |
| ], |
| }, |
| primitive: {topology: 'point-list', frontFace: 'ccw', cullMode: 'back', unclippedDepth: true}, |
| }); |
| video1.height = 130; |
| let imageData2 = new ImageData(64, 204); |
| let buffer5 = device0.createBuffer({size: 609504, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ, mappedAtCreation: true}); |
| let textureView36 = texture1.createView({label: '\uc696\u2e52\u0818\udb40', baseMipLevel: 1}); |
| try { |
| renderBundleEncoder10.setBindGroup(3, bindGroup2); |
| } catch {} |
| try { |
| commandEncoder19.resolveQuerySet(querySet10, 1957, 1144, buffer0, 139008); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture14, |
| mipLevel: 0, |
| origin: {x: 283, y: 0, z: 0}, |
| aspect: 'all', |
| }, new ArrayBuffer(110), /* required buffer size: 110 */ |
| {offset: 110, bytesPerRow: 2310}, {width: 1055, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let textureView37 = texture18.createView({label: '\ub71d\u9dd2\u{1fa26}\u{1feb8}\u00b4', baseMipLevel: 2, mipLevelCount: 3, baseArrayLayer: 0}); |
| try { |
| commandEncoder18.copyTextureToTexture({ |
| texture: texture24, |
| mipLevel: 0, |
| origin: {x: 692, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture9, |
| mipLevel: 0, |
| origin: {x: 7, y: 2, z: 3}, |
| aspect: 'all', |
| }, |
| {width: 96, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture2, |
| mipLevel: 3, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, new DataView(new ArrayBuffer(8)), /* required buffer size: 312_414 */ |
| {offset: 482, bytesPerRow: 146, rowsPerImage: 178}, {width: 19, height: 1, depthOrArrayLayers: 13}); |
| } catch {} |
| let pipelineLayout7 = device0.createPipelineLayout({ |
| label: '\u131d\u0f78\uf86f\u4811\u{1f726}\uaa45\u{1f612}\u8055\u7580\u0bd3', |
| bindGroupLayouts: [bindGroupLayout4, bindGroupLayout3, bindGroupLayout5, bindGroupLayout4], |
| }); |
| let renderBundle15 = renderBundleEncoder4.finish(); |
| try { |
| computePassEncoder0.setPipeline(pipeline11); |
| } catch {} |
| try { |
| renderBundleEncoder6.setVertexBuffer(5862, undefined, 0, 601713446); |
| } catch {} |
| try { |
| commandEncoder15.copyTextureToTexture({ |
| texture: texture13, |
| mipLevel: 1, |
| origin: {x: 1, y: 1, z: 69}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture14, |
| mipLevel: 0, |
| origin: {x: 213, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 306, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder18.resolveQuerySet(querySet5, 30, 76, buffer0, 26112); |
| } catch {} |
| try { |
| commandEncoder3.insertDebugMarker('\ua1c6'); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture7, |
| mipLevel: 0, |
| origin: {x: 16, y: 0, z: 0}, |
| aspect: 'all', |
| }, new ArrayBuffer(56), /* required buffer size: 356 */ |
| {offset: 356, bytesPerRow: 7531, rowsPerImage: 141}, {width: 1816, height: 4, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 10, height: 1, depthOrArrayLayers: 4} |
| */ |
| { |
| source: canvas3, |
| origin: { x: 18, y: 19 }, |
| flipY: true, |
| }, { |
| texture: texture2, |
| mipLevel: 5, |
| origin: {x: 3, y: 0, z: 1}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let canvas8 = document.createElement('canvas'); |
| let bindGroup5 = device0.createBindGroup({ |
| label: '\u{1f82b}\u31bc\u30ec\uf098\uabd8\u{1fa1f}\u1839\u0160\u532c', |
| layout: bindGroupLayout5, |
| entries: [{binding: 5278, resource: externalTexture11}], |
| }); |
| let commandEncoder24 = device0.createCommandEncoder({label: '\u3b60\u022a\u0b49\u18bb\u{1fde1}\ub73e'}); |
| try { |
| buffer3.unmap(); |
| } catch {} |
| try { |
| commandEncoder14.copyTextureToBuffer({ |
| texture: texture16, |
| mipLevel: 5, |
| origin: {x: 4, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 128 widthInBlocks: 16 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 40232 */ |
| offset: 16552, |
| bytesPerRow: 256, |
| rowsPerImage: 46, |
| buffer: buffer2, |
| }, {width: 16, height: 1, depthOrArrayLayers: 3}); |
| dissociateBuffer(device0, buffer2); |
| } catch {} |
| try { |
| commandEncoder15.clearBuffer(buffer2, 120100, 110800); |
| dissociateBuffer(device0, buffer2); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer2, 124684, new DataView(new ArrayBuffer(61999)), 8475, 756); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 162, height: 7, depthOrArrayLayers: 69} |
| */ |
| { |
| source: imageBitmap1, |
| origin: { x: 85, y: 292982320 }, |
| flipY: true, |
| }, { |
| texture: texture2, |
| mipLevel: 1, |
| origin: {x: 69, y: 1, z: 4}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 24, height: 3, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline16 = device0.createRenderPipeline({ |
| label: '\u{1f739}\u0f05\ua6ba\uf80f', |
| layout: pipelineLayout1, |
| fragment: { |
| module: shaderModule5, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{format: 'r16uint'}, {format: 'rgba16uint'}, {format: 'rg16sint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED}, {format: 'r8sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE}, {format: 'rg32uint'}, { |
| format: 'rg8unorm', |
| blend: { |
| color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'}, |
| alpha: {operation: 'reverse-subtract', srcFactor: 'one-minus-src', dstFactor: 'dst'}, |
| }, |
| }, {format: 'rgb10a2unorm', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN}], |
| }, |
| depthStencil: { |
| format: 'depth32float-stencil8', |
| depthWriteEnabled: false, |
| depthCompare: 'greater-equal', |
| stencilFront: {compare: 'not-equal', failOp: 'replace', depthFailOp: 'increment-wrap', passOp: 'zero'}, |
| stencilBack: {compare: 'less', failOp: 'increment-wrap', depthFailOp: 'replace', passOp: 'decrement-wrap'}, |
| stencilReadMask: 1210015868, |
| stencilWriteMask: 215221563, |
| depthBias: -1759680477, |
| depthBiasSlopeScale: 977.7018536892883, |
| depthBiasClamp: 0.0, |
| }, |
| vertex: { |
| module: shaderModule5, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 7380, |
| attributes: [ |
| {format: 'float32', offset: 304, shaderLocation: 1}, |
| {format: 'snorm8x2', offset: 1052, shaderLocation: 12}, |
| {format: 'sint16x4', offset: 492, shaderLocation: 15}, |
| {format: 'float16x4', offset: 2880, shaderLocation: 16}, |
| {format: 'sint32x3', offset: 464, shaderLocation: 17}, |
| {format: 'uint16x4', offset: 5708, shaderLocation: 8}, |
| ], |
| }, |
| { |
| arrayStride: 35188, |
| stepMode: 'instance', |
| attributes: [{format: 'sint16x2', offset: 1144, shaderLocation: 7}], |
| }, |
| {arrayStride: 1972, attributes: []}, |
| { |
| arrayStride: 5072, |
| attributes: [ |
| {format: 'float32', offset: 524, shaderLocation: 2}, |
| {format: 'sint8x4', offset: 564, shaderLocation: 14}, |
| {format: 'uint32', offset: 160, shaderLocation: 3}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'point-list', frontFace: 'cw', unclippedDepth: true}, |
| }); |
| let gpuCanvasContext6 = canvas6.getContext('webgpu'); |
| let offscreenCanvas6 = new OffscreenCanvas(433, 978); |
| let bindGroupLayout7 = pipeline4.getBindGroupLayout(0); |
| let buffer6 = device0.createBuffer({label: '\u04c6\u63d3', size: 128698, usage: GPUBufferUsage.MAP_WRITE}); |
| let querySet13 = device0.createQuerySet({label: '\u136e\u206c', type: 'occlusion', count: 1249}); |
| let externalTexture12 = device0.importExternalTexture({ |
| label: '\u753c\u0e53\u88ce\u0aea\u{1f9bc}\u2283\u{1fb06}\u78a2\u{1f821}\u{1fd3d}', |
| source: video0, |
| colorSpace: 'display-p3', |
| }); |
| try { |
| renderBundleEncoder7.setBindGroup(3, bindGroup3); |
| } catch {} |
| try { |
| buffer6.unmap(); |
| } catch {} |
| let bindGroup6 = device0.createBindGroup({ |
| label: '\u3e06\u{1fc79}\u4020\u6119\u0fa8', |
| layout: bindGroupLayout0, |
| entries: [{binding: 5545, resource: externalTexture4}], |
| }); |
| let pipelineLayout8 = device0.createPipelineLayout({ |
| label: '\ufeca\u1ac6\u{1fbc0}\u0db7\u{1f94a}\u{1f975}\u037d\ue0f9\u95f4\u0a48\ue8a8', |
| bindGroupLayouts: [bindGroupLayout5, bindGroupLayout3, bindGroupLayout1], |
| }); |
| let renderBundleEncoder11 = device0.createRenderBundleEncoder({ |
| label: '\u2029\u{1faf2}\u84a2\uefd0\u{1fe60}\u6b13\u{1fecf}\ubc36\u{1ff25}\u081a\u4551', |
| colorFormats: ['r16uint', 'rgba16uint', 'rg16sint', 'r8sint', 'rg32uint', 'rg8unorm', 'rgb10a2unorm'], |
| sampleCount: 4, |
| stencilReadOnly: true, |
| }); |
| let externalTexture13 = device0.importExternalTexture({label: '\u3bf3\u{1f604}\u{1fd6a}\u0092\u844e\u08de', source: videoFrame0, colorSpace: 'display-p3'}); |
| try { |
| commandEncoder3.copyTextureToBuffer({ |
| texture: texture25, |
| mipLevel: 0, |
| origin: {x: 22, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 60 widthInBlocks: 30 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 7388 */ |
| offset: 7388, |
| buffer: buffer2, |
| }, {width: 30, height: 0, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer2); |
| } catch {} |
| try { |
| commandEncoder6.clearBuffer(buffer5); |
| dissociateBuffer(device0, buffer5); |
| } catch {} |
| gc(); |
| let bindGroupLayout8 = device0.createBindGroupLayout({ |
| label: '\u03cd\u4100\u1aa6\u{1fbbe}', |
| entries: [ |
| {binding: 2351, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, externalTexture: {}}, |
| {binding: 5527, visibility: GPUShaderStage.VERTEX, externalTexture: {}}, |
| ], |
| }); |
| let texture26 = device0.createTexture({ |
| size: {width: 320}, |
| dimension: '1d', |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rg8unorm'], |
| }); |
| let textureView38 = texture20.createView({ |
| label: '\u040a\ub9ca\u133f\u30da\u0cc0\ub465\ud618\u06b9\u0ef2\u275e\u{1f7a8}', |
| dimension: '2d-array', |
| arrayLayerCount: 1, |
| }); |
| try { |
| computePassEncoder6.setBindGroup(0, bindGroup0); |
| } catch {} |
| let buffer7 = device0.createBuffer({label: '\u6065\u0299', size: 25605, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE}); |
| let commandEncoder25 = device0.createCommandEncoder({label: '\u1428\u11e5\u23b2\u5905\ude5c\u0518\u072e\u{1f71d}\u678b\u036b'}); |
| try { |
| computePassEncoder5.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderBundleEncoder11.setIndexBuffer(buffer1, 'uint32'); |
| } catch {} |
| try { |
| renderBundleEncoder11.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderBundleEncoder7.setVertexBuffer(5954, undefined, 2183438201, 1749976678); |
| } catch {} |
| try { |
| commandEncoder20.copyBufferToTexture({ |
| /* bytesInLastRow: 5684 widthInBlocks: 1421 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 38308 */ |
| offset: 38308, |
| bytesPerRow: 5888, |
| buffer: buffer3, |
| }, { |
| texture: texture7, |
| mipLevel: 0, |
| origin: {x: 484, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 1421, height: 4, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| let shaderModule7 = device0.createShaderModule({ |
| code: `@group(2) @binding(5545) |
| var<storage, read_write> parameter1: array<u32>; |
| @group(0) @binding(5545) |
| var<storage, read_write> field3: array<u32>; |
| @group(1) @binding(5545) |
| var<storage, read_write> type4: array<u32>; |
| |
| @compute @workgroup_size(7, 2, 1) |
| fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {} |
| |
| struct FragmentOutput0 { |
| @location(0) f0: u32, |
| @location(6) f1: vec4<f32>, |
| @location(1) f2: vec4<u32>, |
| @location(3) f3: vec4<i32>, |
| @location(4) f4: vec2<u32>, |
| @location(2) f5: vec3<i32>, |
| @location(5) f6: vec2<f32> |
| } |
| |
| @fragment |
| fn fragment0(@builtin(sample_mask) a0: u32, @builtin(position) a1: vec4<f32>) -> FragmentOutput0 { |
| return FragmentOutput0(); |
| } |
| |
| |
| |
| @vertex |
| fn vertex0(@location(9) a0: vec3<u32>, @location(13) a1: vec4<u32>, @location(5) a2: vec4<u32>, @builtin(instance_index) a3: u32) -> @builtin(position) vec4<f32> { |
| return vec4<f32>(0.0, 0.0, 0.0, 1.0); |
| } |
| |
| `, |
| hints: {}, |
| }); |
| let bindGroupLayout9 = device0.createBindGroupLayout({ |
| label: '\u{1fbdf}\u975c\u01b0\uf7cf\u0cec\u093f', |
| entries: [ |
| {binding: 6435, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| { |
| binding: 6622, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: true }, |
| }, |
| ], |
| }); |
| let commandEncoder26 = device0.createCommandEncoder({label: '\ud0e6\u{1f65b}\u496e\u043e\u{1f943}\uba10\uc36a\u7761\u076d'}); |
| try { |
| computePassEncoder4.setPipeline(pipeline13); |
| } catch {} |
| try { |
| renderBundleEncoder6.setPipeline(pipeline6); |
| } catch {} |
| try { |
| buffer6.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture7, |
| mipLevel: 0, |
| origin: {x: 156, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint16Array(new ArrayBuffer(16)), /* required buffer size: 877 */ |
| {offset: 877}, {width: 972, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 40, height: 4, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData0, |
| origin: { x: 7, y: 19 }, |
| flipY: true, |
| }, { |
| texture: texture4, |
| mipLevel: 1, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 13, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext6.unconfigure(); |
| } catch {} |
| let shaderModule8 = device0.createShaderModule({ |
| code: `@group(1) @binding(5545) |
| var<storage, read_write> global1: array<u32>; |
| @group(0) @binding(5830) |
| var<storage, read_write> local2: array<u32>; |
| @group(0) @binding(765) |
| var<storage, read_write> parameter2: array<u32>; |
| |
| @compute @workgroup_size(1, 4, 4) |
| fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {} |
| |
| struct S8 { |
| @builtin(sample_mask) f0: u32, |
| @location(37) f1: vec3<i32>, |
| @builtin(position) f2: vec4<f32>, |
| @location(27) f3: vec2<i32>, |
| @location(36) f4: u32 |
| } |
| struct FragmentOutput0 { |
| @location(0) f0: u32, |
| @location(5) f1: vec4<f32>, |
| @location(2) f2: vec2<i32>, |
| @location(3) f3: vec3<i32>, |
| @location(1) f4: vec4<u32>, |
| @location(6) f5: vec4<f32>, |
| @location(4) f6: vec4<u32> |
| } |
| |
| @fragment |
| fn fragment0(@location(41) a0: vec3<u32>, @location(31) a1: vec2<f32>, @location(4) a2: vec4<u32>, @builtin(sample_index) a3: u32, @location(33) a4: vec2<f16>, @location(0) a5: i32, @builtin(front_facing) a6: bool, @location(14) a7: vec2<i32>, @location(21) a8: vec3<f32>, @location(13) a9: f32, a10: S8, @location(16) a11: f16, @location(20) a12: vec3<f32>, @location(17) a13: i32, @location(12) a14: vec3<f16>, @location(28) a15: u32) -> FragmentOutput0 { |
| return FragmentOutput0(); |
| } |
| |
| struct VertexOutput0 { |
| @location(13) f126: f32, |
| @location(28) f127: u32, |
| @location(21) f128: vec3<f32>, |
| @location(41) f129: vec3<u32>, |
| @location(17) f130: i32, |
| @location(20) f131: vec3<f32>, |
| @location(31) f132: vec2<f32>, |
| @location(14) f133: vec2<i32>, |
| @location(16) f134: f16, |
| @builtin(position) f135: vec4<f32>, |
| @location(0) f136: i32, |
| @location(37) f137: vec3<i32>, |
| @location(33) f138: vec2<f16>, |
| @location(12) f139: vec3<f16>, |
| @location(4) f140: vec4<u32>, |
| @location(36) f141: u32, |
| @location(27) f142: vec2<i32> |
| } |
| |
| @vertex |
| fn vertex0(@location(8) a0: vec4<f16>, @location(2) a1: i32, @location(17) a2: vec2<f32>, @location(14) a3: vec4<u32>, @location(9) a4: u32, @location(3) a5: f16, @location(4) a6: i32) -> VertexOutput0 { |
| return VertexOutput0(); |
| } |
| |
| `, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| let commandEncoder27 = device0.createCommandEncoder({label: '\u6680\u35fc\u{1fbe7}\u43fa\u4069\u18a5\u0a84\u0244'}); |
| let computePassEncoder9 = commandEncoder25.beginComputePass({label: '\u67d6\u0a8f\u{1fb4d}\u8c3b'}); |
| try { |
| commandEncoder17.copyBufferToTexture({ |
| /* bytesInLastRow: 20 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1748 */ |
| offset: 1748, |
| bytesPerRow: 512, |
| buffer: buffer3, |
| }, { |
| texture: texture2, |
| mipLevel: 5, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 5, height: 0, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| commandEncoder15.copyTextureToTexture({ |
| texture: texture11, |
| mipLevel: 8, |
| origin: {x: 0, y: 0, z: 11}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture11, |
| mipLevel: 4, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline17 = device0.createRenderPipeline({ |
| label: '\u0bdb\ub180\u{1f93e}\u{1fdd0}\u{1f8c6}\uf4f1\u0d8f\u{1f811}', |
| layout: pipelineLayout2, |
| multisample: {count: 4, mask: 0xa55d1615}, |
| fragment: { |
| module: shaderModule6, |
| entryPoint: 'fragment0', |
| targets: [{format: 'r16uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED}, {format: 'rgba16uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED}, {format: 'rg16sint'}, {format: 'r8sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA}, {format: 'rg32uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN}, { |
| format: 'rg8unorm', |
| blend: { |
| color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'}, |
| alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'}, |
| }, |
| writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED, |
| }, { |
| format: 'rgb10a2unorm', |
| blend: { |
| color: {operation: 'add', srcFactor: 'one', dstFactor: 'one-minus-dst'}, |
| alpha: {operation: 'subtract', srcFactor: 'src', dstFactor: 'one-minus-dst-alpha'}, |
| }, |
| }], |
| }, |
| vertex: { |
| module: shaderModule6, |
| entryPoint: 'vertex0', |
| buffers: [ |
| {arrayStride: 9112, stepMode: 'instance', attributes: []}, |
| { |
| arrayStride: 2656, |
| stepMode: 'instance', |
| attributes: [{format: 'float32x4', offset: 712, shaderLocation: 16}], |
| }, |
| ], |
| }, |
| }); |
| let device1 = await adapter1.requestDevice({ |
| label: '\u4233\uf7ee\u1fa7\ufc5e\u0100\u0262\ud938\ue188\u0866\ue26b', |
| defaultQueue: {label: '\u{1fa75}\ucb5a\udf0f\u7e81\u0ba6\u{1fd50}'}, |
| requiredFeatures: [ |
| 'depth-clip-control', |
| 'depth32float-stencil8', |
| 'texture-compression-astc', |
| 'indirect-first-instance', |
| 'shader-f16', |
| 'rg11b10ufloat-renderable', |
| 'bgra8unorm-storage', |
| ], |
| requiredLimits: { |
| maxBindGroups: 6, |
| maxColorAttachmentBytesPerSample: 46, |
| maxVertexAttributes: 20, |
| maxVertexBufferArrayStride: 50960, |
| maxStorageTexturesPerShaderStage: 34, |
| maxStorageBuffersPerShaderStage: 21, |
| maxDynamicStorageBuffersPerPipelineLayout: 34630, |
| maxDynamicUniformBuffersPerPipelineLayout: 36503, |
| maxBindingsPerBindGroup: 5423, |
| maxTextureArrayLayers: 1786, |
| maxTextureDimension1D: 16115, |
| maxTextureDimension2D: 13523, |
| maxVertexBuffers: 9, |
| maxBindGroupsPlusVertexBuffers: 28, |
| minStorageBufferOffsetAlignment: 32, |
| maxUniformBufferBindingSize: 110534293, |
| maxStorageBufferBindingSize: 148940278, |
| maxUniformBuffersPerShaderStage: 20, |
| maxSampledTexturesPerShaderStage: 24, |
| maxInterStageShaderVariables: 79, |
| maxInterStageShaderComponents: 124, |
| }, |
| }); |
| let querySet14 = device1.createQuerySet({label: '\u0f5c\u{1f758}\u0725\u1c1d\ucada', type: 'occlusion', count: 2616}); |
| let sampler5 = device1.createSampler({ |
| label: '\u64e7\u4882\u0681\ua81f\u1c0f\u076e\u403b\u{1fb01}', |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| lodMaxClamp: 93.98, |
| }); |
| try { |
| querySet14.destroy(); |
| } catch {} |
| let bindGroup7 = device0.createBindGroup({label: '\u5e0a\ub937\u0399\u9989\u8bfa\ucb8b', layout: bindGroupLayout3, entries: []}); |
| let commandEncoder28 = device0.createCommandEncoder({label: '\uc6d1\ub8da'}); |
| let renderBundle16 = renderBundleEncoder1.finish({label: '\u8c1a\u01f4\u0045\u{1f90d}\u{1f9f4}'}); |
| let arrayBuffer0 = buffer5.getMappedRange(34264); |
| try { |
| commandEncoder16.copyTextureToBuffer({ |
| texture: texture25, |
| mipLevel: 0, |
| origin: {x: 34, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 220 widthInBlocks: 110 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 21344 */ |
| offset: 21344, |
| buffer: buffer2, |
| }, {width: 110, height: 1, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer2); |
| } catch {} |
| try { |
| commandEncoder20.clearBuffer(buffer5); |
| dissociateBuffer(device0, buffer5); |
| } catch {} |
| try { |
| commandEncoder13.resolveQuerySet(querySet12, 1799, 2007, buffer0, 186880); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture4, |
| mipLevel: 0, |
| origin: {x: 8, y: 1, z: 0}, |
| aspect: 'all', |
| }, new Int32Array(arrayBuffer0), /* required buffer size: 958 */ |
| {offset: 640, bytesPerRow: 278}, {width: 10, height: 2, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| adapter0.label = '\u0ac1\u023b\ub7c4\u0c1b\u{1f7d8}\ue4d7\u31b5\ud2e4\ubc42'; |
| } catch {} |
| let commandEncoder29 = device1.createCommandEncoder({label: '\uc21f\u{1fa5c}\u2b8d\u46d2\u3652\u00d1\u3ec4\u5493\u{1f7cd}\uf5d3\u3c9e'}); |
| let externalTexture14 = device1.importExternalTexture({label: '\u3843\uedd5\ue1f3\u992e\u2cdf', source: videoFrame1, colorSpace: 'display-p3'}); |
| let imageData3 = new ImageData(252, 20); |
| let texture27 = gpuCanvasContext1.getCurrentTexture(); |
| let computePassEncoder10 = commandEncoder17.beginComputePass({label: '\u2cab\ue4ad\u{1face}\u{1fb98}\u6af4\u{1fba7}'}); |
| let renderBundleEncoder12 = device0.createRenderBundleEncoder({ |
| label: '\u5ef2\u0d86\u8de2\u0c4d\u070b\u97b6', |
| colorFormats: ['r16uint', 'rgba16uint', 'rg16sint', 'r8sint', 'rg32uint', 'rg8unorm', 'rgb10a2unorm'], |
| sampleCount: 4, |
| }); |
| let arrayBuffer1 = buffer5.getMappedRange(11408, 16840); |
| try { |
| commandEncoder16.copyTextureToTexture({ |
| texture: texture24, |
| mipLevel: 0, |
| origin: {x: 7, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture9, |
| mipLevel: 1, |
| origin: {x: 47, y: 0, z: 5}, |
| aspect: 'all', |
| }, |
| {width: 6, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder18.resolveQuerySet(querySet2, 1470, 1041, buffer0, 214784); |
| } catch {} |
| let texture28 = gpuCanvasContext1.getCurrentTexture(); |
| let computePassEncoder11 = commandEncoder23.beginComputePass({label: '\u068a\u0dca'}); |
| let renderBundleEncoder13 = device0.createRenderBundleEncoder({ |
| label: '\u0f3c\u02d0\u46c3\u3592\u0164\u{1fbac}', |
| colorFormats: ['r16uint', 'rgba16uint', 'rg16sint', 'r8sint', 'rg32uint', 'rg8unorm', 'rgb10a2unorm'], |
| sampleCount: 4, |
| stencilReadOnly: false, |
| }); |
| try { |
| renderBundleEncoder8.setVertexBuffer(3999, undefined, 0, 2811181418); |
| } catch {} |
| try { |
| commandEncoder28.clearBuffer(buffer5); |
| dissociateBuffer(device0, buffer5); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture2, |
| mipLevel: 2, |
| origin: {x: 2, y: 0, z: 2}, |
| aspect: 'all', |
| }, new ArrayBuffer(48), /* required buffer size: 39_846 */ |
| {offset: 832, bytesPerRow: 310, rowsPerImage: 123}, {width: 66, height: 3, depthOrArrayLayers: 2}); |
| } catch {} |
| try { |
| device0.destroy(); |
| } catch {} |
| let imageData4 = new ImageData(140, 72); |
| let commandEncoder30 = device1.createCommandEncoder({label: '\u{1fb7b}\u6bc4\uedeb\u{1f700}\u0524\ufa4a\ub330\u{1f8e4}\u0f46\u3a82'}); |
| let querySet15 = device1.createQuerySet({type: 'occlusion', count: 857}); |
| gc(); |
| let texture29 = device1.createTexture({ |
| label: '\u{1f7a2}\u{1fd65}\u0c50\u6edf\u8005\u{1fe66}\u00a8\u0b71\u3871\u056a\uf609', |
| size: [240, 1, 1947], |
| mipLevelCount: 10, |
| dimension: '3d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rg8uint'], |
| }); |
| try { |
| gpuCanvasContext3.configure({ |
| device: device1, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| let imageData5 = new ImageData(12, 164); |
| let buffer8 = device1.createBuffer({ |
| label: '\u41ea\ue7e8\u8b05\u0759\u5d75', |
| size: 49036, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM, |
| }); |
| let computePassEncoder12 = commandEncoder30.beginComputePass({}); |
| let sampler6 = device1.createSampler({ |
| label: '\ud9b5\u0c9e\u{1feaf}\u{1f9c4}\u{1f67a}\uf218\u33c7\uf03d\u{1f8ea}', |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 18.46, |
| lodMaxClamp: 80.90, |
| maxAnisotropy: 19, |
| }); |
| try { |
| device1.addEventListener('uncapturederror', e => { log('device1.uncapturederror'); log(e); e.label = device1.label; }); |
| } catch {} |
| try { |
| commandEncoder29.resolveQuerySet(querySet14, 1114, 67, buffer8, 19968); |
| } catch {} |
| document.body.prepend(video0); |
| video1.width = 205; |
| gc(); |
| try { |
| canvas7.getContext('2d'); |
| } catch {} |
| let promise2 = adapter2.requestAdapterInfo(); |
| let bindGroup8 = device0.createBindGroup({ |
| label: '\u061c\ue8c3\u0ecf\ued20\ua38b\u2666\uc4a0\u4108\u13e9\u0367', |
| layout: bindGroupLayout0, |
| entries: [{binding: 5545, resource: externalTexture7}], |
| }); |
| let buffer9 = device0.createBuffer({ |
| label: '\u22a7\u04b2\u{1fac2}\u8f6a\u3e01\ua40b\u0f30\u0e4e\u{1fcee}\u0e67\u{1f7ef}', |
| size: 3012, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM, |
| }); |
| let texture30 = device0.createTexture({ |
| label: '\u{1f834}\u0f60\u0d59', |
| size: {width: 1905, height: 4, depthOrArrayLayers: 26}, |
| mipLevelCount: 5, |
| dimension: '3d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: ['rgba16uint'], |
| }); |
| let renderBundleEncoder14 = device0.createRenderBundleEncoder({ |
| label: '\u0f4f\uf685\u5ca5\u0390\u{1fb6d}\u13ec', |
| colorFormats: ['r16uint', 'rgba16uint', 'rg16sint', 'r8sint', 'rg32uint', 'rg8unorm', 'rgb10a2unorm'], |
| sampleCount: 4, |
| depthReadOnly: true, |
| stencilReadOnly: true, |
| }); |
| try { |
| computePassEncoder11.end(); |
| } catch {} |
| try { |
| renderBundleEncoder6.setBindGroup(0, bindGroup8); |
| } catch {} |
| try { |
| renderBundleEncoder13.setPipeline(pipeline7); |
| } catch {} |
| try { |
| commandEncoder3.copyTextureToBuffer({ |
| texture: texture14, |
| mipLevel: 0, |
| origin: {x: 89, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 2928 widthInBlocks: 1464 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 25224 */ |
| offset: 22296, |
| buffer: buffer2, |
| }, {width: 1464, height: 1, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer2); |
| } catch {} |
| try { |
| commandEncoder16.clearBuffer(buffer2, 90276, 101464); |
| dissociateBuffer(device0, buffer2); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer7, 10040, new BigUint64Array(5193), 3583, 16); |
| } catch {} |
| let textureView39 = texture29.createView({baseMipLevel: 1, mipLevelCount: 8}); |
| document.body.prepend(canvas2); |
| let commandEncoder31 = device1.createCommandEncoder(); |
| let textureView40 = texture29.createView({ |
| label: '\u060c\uc692\u885d\u0c28\uc582\u{1f757}\u953a', |
| format: 'rg8uint', |
| baseMipLevel: 1, |
| mipLevelCount: 5, |
| arrayLayerCount: 1, |
| }); |
| let renderBundleEncoder15 = device1.createRenderBundleEncoder({ |
| label: '\u4ccd\u{1f903}\u{1fbb9}\u{1f749}\u6e18\u030c\u{1fad0}\u0585\u0fbd\ufcc8', |
| colorFormats: ['rgba8uint', 'rg8uint', 'rgba8uint', 'rgba32uint'], |
| depthReadOnly: true, |
| }); |
| let renderBundle17 = renderBundleEncoder15.finish({label: '\uf3fe\u0de4\u19d1\u35fa\u8095\u007a\uce14\ue33d\uf25b\ub58b'}); |
| let sampler7 = device1.createSampler({ |
| label: '\u00f6\u955f\u0837\u{1f8f1}\u097c', |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| lodMaxClamp: 91.11, |
| }); |
| let adapter3 = await navigator.gpu.requestAdapter({}); |
| let sampler8 = device1.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 9.727, |
| lodMaxClamp: 45.13, |
| maxAnisotropy: 13, |
| }); |
| try { |
| commandEncoder29.clearBuffer(buffer8); |
| dissociateBuffer(device1, buffer8); |
| } catch {} |
| try { |
| device1.destroy(); |
| } catch {} |
| try { |
| await promise2; |
| } catch {} |
| document.body.prepend(canvas8); |
| let canvas9 = document.createElement('canvas'); |
| let video3 = await videoWithData(); |
| try { |
| offscreenCanvas6.getContext('webgpu'); |
| } catch {} |
| gc(); |
| try { |
| offscreenCanvas5.getContext('webgl'); |
| } catch {} |
| let videoFrame2 = new VideoFrame(canvas8, {timestamp: 0}); |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let canvas10 = document.createElement('canvas'); |
| let offscreenCanvas7 = new OffscreenCanvas(974, 503); |
| let video4 = await videoWithData(); |
| let videoFrame3 = new VideoFrame(offscreenCanvas0, {timestamp: 0}); |
| try { |
| adapter0.label = '\u{1ff8d}\u4348\u0128\u0b13'; |
| } catch {} |
| try { |
| offscreenCanvas4.getContext('webgl'); |
| } catch {} |
| let video5 = await videoWithData(); |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| canvas9.width = 241; |
| let videoFrame4 = new VideoFrame(offscreenCanvas5, {timestamp: 0}); |
| gc(); |
| let canvas11 = document.createElement('canvas'); |
| let gpuCanvasContext7 = offscreenCanvas7.getContext('webgpu'); |
| try { |
| canvas11.getContext('webgl'); |
| } catch {} |
| let promise3 = adapter1.requestAdapterInfo(); |
| try { |
| await promise3; |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| try { |
| window.someLabel = device1.queue.label; |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| gc(); |
| try { |
| canvas9.getContext('2d'); |
| } catch {} |
| let imageBitmap4 = await createImageBitmap(imageBitmap1); |
| try { |
| canvas8.getContext('webgpu'); |
| } catch {} |
| let buffer10 = device0.createBuffer({ |
| label: '\u20b5\ub2d3\ueb01\u0d35\u0159\ua9a0\u0421\u9564\ub46b\uddcc', |
| size: 203647, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ, |
| }); |
| let textureView41 = texture17.createView({}); |
| try { |
| computePassEncoder8.end(); |
| } catch {} |
| try { |
| commandEncoder14.copyTextureToBuffer({ |
| texture: texture14, |
| mipLevel: 0, |
| origin: {x: 495, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 1718 widthInBlocks: 859 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 8018 */ |
| offset: 6300, |
| buffer: buffer7, |
| }, {width: 859, height: 1, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer7); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer10, 4944, new Int16Array(61969), 58767, 312); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 10, height: 1, depthOrArrayLayers: 4} |
| */ |
| { |
| source: imageBitmap2, |
| origin: { x: 18, y: 12 }, |
| flipY: true, |
| }, { |
| texture: texture2, |
| mipLevel: 5, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| canvas10.getContext('bitmaprenderer'); |
| } catch {} |
| let bindGroup9 = device0.createBindGroup({layout: bindGroupLayout5, entries: [{binding: 5278, resource: externalTexture4}]}); |
| let pipelineLayout9 = device0.createPipelineLayout({ |
| label: '\ue078\u2951\ufe0a\ued35\ucf10', |
| bindGroupLayouts: [bindGroupLayout1, bindGroupLayout3, bindGroupLayout1], |
| }); |
| let buffer11 = device0.createBuffer({ |
| label: '\u14d3\u5d4a\u063d\u{1fbef}\u71a9\u9d6f\u0c97\u85e9\u0e25', |
| size: 69441, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ, |
| }); |
| let renderBundleEncoder16 = device0.createRenderBundleEncoder({ |
| label: '\u0ee7\u{1ffb4}\ud8fa\ub3da', |
| colorFormats: ['r16uint', 'rgba16uint', 'rg16sint', 'r8sint', 'rg32uint', 'rg8unorm', 'rgb10a2unorm'], |
| sampleCount: 4, |
| }); |
| let renderBundle18 = renderBundleEncoder13.finish({label: '\uc410\u081f\u922b\u0119\u59be\u0a5c\u00a0\u0890'}); |
| let externalTexture15 = device0.importExternalTexture({label: '\u{1f7fb}\ue62e\u4b22', source: videoFrame3, colorSpace: 'srgb'}); |
| try { |
| renderBundleEncoder12.setPipeline(pipeline7); |
| } catch {} |
| try { |
| if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55) }; |
| } catch {} |
| canvas6.width = 1041; |
| let img0 = await imageWithData(212, 256, '#57681310', '#150efc0d'); |
| try { |
| window.someLabel = renderBundleEncoder7.label; |
| } catch {} |
| let offscreenCanvas8 = new OffscreenCanvas(925, 692); |
| let texture31 = device0.createTexture({ |
| label: '\u0ab7\u2295\u0d39\u22f5\u00fa\u05df\uaeca\uc70d\u{1fd29}\u0312\uc1df', |
| size: [324], |
| dimension: '1d', |
| format: 'r16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| viewFormats: [], |
| }); |
| let computePassEncoder13 = commandEncoder22.beginComputePass({label: '\u{1ff60}\u{1fc17}\ua414\u6312'}); |
| let renderBundle19 = renderBundleEncoder8.finish({label: '\u465e\u40ea\uc4a5\u{1ff38}\u965f\u0157'}); |
| let externalTexture16 = device0.importExternalTexture({source: video4, colorSpace: 'srgb'}); |
| try { |
| commandEncoder3.clearBuffer(buffer2, 130944, 62220); |
| dissociateBuffer(device0, buffer2); |
| } catch {} |
| try { |
| commandEncoder24.pushDebugGroup('\u501e'); |
| } catch {} |
| let pipeline18 = await promise1; |
| let pipeline19 = device0.createRenderPipeline({ |
| label: '\u3da0\u{1fc01}\ud4fd\u6ca9\u{1fe3f}', |
| layout: pipelineLayout0, |
| fragment: { |
| module: shaderModule6, |
| entryPoint: 'fragment0', |
| targets: [{format: 'r16uint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN}, {format: 'rgba16uint'}, {format: 'rg16sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.RED}, {format: 'r8sint'}, {format: 'rg32uint', writeMask: 0}, {format: 'rg8unorm', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.RED}, { |
| format: 'rgb10a2unorm', |
| blend: { |
| color: {operation: 'subtract', srcFactor: 'dst-alpha', dstFactor: 'zero'}, |
| alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'}, |
| }, |
| writeMask: GPUColorWrite.GREEN | GPUColorWrite.RED, |
| }], |
| }, |
| depthStencil: { |
| format: 'depth24plus-stencil8', |
| depthWriteEnabled: false, |
| depthCompare: 'equal', |
| stencilFront: {compare: 'less-equal', failOp: 'increment-clamp', depthFailOp: 'zero', passOp: 'increment-wrap'}, |
| stencilBack: {compare: 'equal', passOp: 'increment-wrap'}, |
| stencilReadMask: 1060893830, |
| depthBiasSlopeScale: 936.6375495453337, |
| }, |
| vertex: { |
| module: shaderModule6, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 5728, |
| stepMode: 'instance', |
| attributes: [{format: 'unorm10-10-10-2', offset: 1292, shaderLocation: 16}], |
| }, |
| ], |
| }, |
| primitive: { |
| topology: 'triangle-strip', |
| stripIndexFormat: 'uint16', |
| frontFace: 'cw', |
| cullMode: 'front', |
| unclippedDepth: true, |
| }, |
| }); |
| let promise4 = adapter2.requestAdapterInfo(); |
| let video6 = await videoWithData(); |
| let gpuCanvasContext8 = offscreenCanvas8.getContext('webgpu'); |
| let imageBitmap5 = await createImageBitmap(offscreenCanvas3); |
| canvas4.height = 100; |
| gc(); |
| let videoFrame5 = new VideoFrame(canvas7, {timestamp: 0}); |
| try { |
| await promise4; |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| document.body.prepend(canvas2); |
| let videoFrame6 = new VideoFrame(imageBitmap4, {timestamp: 0}); |
| let promise5 = adapter3.requestAdapterInfo(); |
| try { |
| await promise5; |
| } catch {} |
| offscreenCanvas5.height = 1329; |
| let canvas12 = document.createElement('canvas'); |
| let videoFrame7 = new VideoFrame(videoFrame1, {timestamp: 0}); |
| video5.height = 129; |
| let offscreenCanvas9 = new OffscreenCanvas(345, 971); |
| let img1 = await imageWithData(288, 22, '#6f3dc19d', '#481cf0c7'); |
| let gpuCanvasContext9 = offscreenCanvas9.getContext('webgpu'); |
| let canvas13 = document.createElement('canvas'); |
| let imageBitmap6 = await createImageBitmap(offscreenCanvas1); |
| let commandEncoder32 = device0.createCommandEncoder({label: '\u{1f6a3}\u01fb\u37c6\u4fe9\u009e'}); |
| let querySet16 = device0.createQuerySet({label: '\ue88c\uf3a8', type: 'occlusion', count: 18}); |
| let textureView42 = texture2.createView({label: '\u{1ffec}\u{1f777}\u726f\u0f52\u5c69\u8eff\u0dae', mipLevelCount: 6}); |
| let externalTexture17 = device0.importExternalTexture({source: video3, colorSpace: 'display-p3'}); |
| try { |
| renderBundleEncoder10.setBindGroup(2, bindGroup7, new Uint32Array(5299), 242, 0); |
| } catch {} |
| try { |
| renderBundleEncoder12.setVertexBuffer(93, undefined, 0, 4159095344); |
| } catch {} |
| try { |
| commandEncoder16.copyBufferToTexture({ |
| /* bytesInLastRow: 6904 widthInBlocks: 3452 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 14182 */ |
| offset: 14182, |
| buffer: buffer3, |
| }, { |
| texture: texture24, |
| mipLevel: 0, |
| origin: {x: 30, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 3452, height: 1, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| commandEncoder6.copyTextureToTexture({ |
| texture: texture17, |
| mipLevel: 0, |
| origin: {x: 15, y: 1, z: 2}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture1, |
| mipLevel: 1, |
| origin: {x: 5, y: 3, z: 22}, |
| aspect: 'all', |
| }, |
| {width: 132, height: 12, depthOrArrayLayers: 61}); |
| } catch {} |
| try { |
| commandEncoder20.resolveQuerySet(querySet6, 2007, 750, buffer0, 190720); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture1, |
| mipLevel: 1, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, arrayBuffer0, /* required buffer size: 58_060 */ |
| {offset: 262, bytesPerRow: 2638, rowsPerImage: 90}, {width: 300, height: 22, depthOrArrayLayers: 1}); |
| } catch {} |
| gc(); |
| gc(); |
| let videoFrame8 = new VideoFrame(canvas8, {timestamp: 0}); |
| let imageData6 = new ImageData(76, 52); |
| try { |
| canvas13.getContext('bitmaprenderer'); |
| } catch {} |
| try { |
| adapter0.label = '\ub593\u02ad\u0475\u0968\u0ef0\ucc89\u{1fb77}\u02b5\u8769\u0989'; |
| } catch {} |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55) }; |
| } catch {} |
| let canvas14 = document.createElement('canvas'); |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| try { |
| adapter0.label = '\ub8ce\u{1fc6e}\u{1fb35}\u2f0d\ud99a'; |
| } catch {} |
| let gpuCanvasContext10 = canvas14.getContext('webgpu'); |
| gc(); |
| let gpuCanvasContext11 = canvas12.getContext('webgpu'); |
| try { |
| device1.label = '\u99b4\u0c34\u42a2\u0e65\u067a\u9d46\uf2ec\ua7f4\u0197\u0ac9\u079c'; |
| } catch {} |
| let imageData7 = new ImageData(256, 140); |
| gc(); |
| try { |
| adapter1.label = '\u0436\u2ada\u0aca\ufb77\u0ae6'; |
| } catch {} |
| let img2 = await imageWithData(95, 101, '#373ffd17', '#623ce846'); |
| let videoFrame9 = new VideoFrame(img2, {timestamp: 0}); |
| let canvas15 = document.createElement('canvas'); |
| try { |
| canvas15.getContext('2d'); |
| } catch {} |
| let img3 = await imageWithData(249, 227, '#0cb42831', '#d5c0a373'); |
| let bindGroup10 = device0.createBindGroup({layout: bindGroupLayout3, entries: []}); |
| let buffer12 = device0.createBuffer({size: 51421, usage: GPUBufferUsage.MAP_WRITE}); |
| let commandEncoder33 = device0.createCommandEncoder({label: '\u{1f7dc}\u85ef\u01d6\u085f\u08dc\ud15f\u9846'}); |
| let textureView43 = texture23.createView({baseMipLevel: 0, arrayLayerCount: 1}); |
| let sampler9 = device0.createSampler({ |
| label: '\ud22b\u0e41\u0a3c\u{1feb8}\uea91\u{1fb2d}\u{1f9d7}\u5127', |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 6.304, |
| compare: 'not-equal', |
| }); |
| try { |
| computePassEncoder9.setBindGroup(0, bindGroup10); |
| } catch {} |
| try { |
| computePassEncoder10.insertDebugMarker('\u{1f9ab}'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer7, 2520, new DataView(new ArrayBuffer(27463)), 19749, 296); |
| } catch {} |
| let pipeline20 = device0.createComputePipeline({layout: pipelineLayout7, compute: {module: shaderModule2, entryPoint: 'compute0'}}); |
| try { |
| gpuCanvasContext10.unconfigure(); |
| } catch {} |
| gc(); |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55) }; |
| } catch {} |
| let device2 = await adapter3.requestDevice({ |
| requiredLimits: { |
| maxBindGroups: 8, |
| maxColorAttachmentBytesPerSample: 37, |
| maxVertexAttributes: 24, |
| maxVertexBufferArrayStride: 60715, |
| maxStorageTexturesPerShaderStage: 6, |
| maxStorageBuffersPerShaderStage: 17, |
| maxDynamicStorageBuffersPerPipelineLayout: 3819, |
| maxDynamicUniformBuffersPerPipelineLayout: 13570, |
| maxBindingsPerBindGroup: 8492, |
| maxTextureArrayLayers: 689, |
| maxTextureDimension1D: 11172, |
| maxTextureDimension2D: 12698, |
| maxBindGroupsPlusVertexBuffers: 27, |
| minUniformBufferOffsetAlignment: 128, |
| maxUniformBufferBindingSize: 203955250, |
| maxStorageBufferBindingSize: 138348779, |
| maxUniformBuffersPerShaderStage: 19, |
| maxSampledTexturesPerShaderStage: 17, |
| maxInterStageShaderVariables: 94, |
| maxInterStageShaderComponents: 68, |
| maxSamplersPerShaderStage: 21, |
| }, |
| }); |
| let offscreenCanvas10 = new OffscreenCanvas(721, 906); |
| gc(); |
| let offscreenCanvas11 = new OffscreenCanvas(456, 279); |
| let offscreenCanvas12 = new OffscreenCanvas(205, 145); |
| try { |
| device2.label = '\u0c9a\u5a58\ufad7\ud2a2\u{1fa63}'; |
| } catch {} |
| let commandEncoder34 = device2.createCommandEncoder({label: '\u1307\u{1fa64}\uf509'}); |
| let texture32 = device2.createTexture({ |
| size: [126, 1, 481], |
| mipLevelCount: 5, |
| format: 'depth24plus', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView44 = texture32.createView({ |
| label: '\u61de\u8222\uc3d5\u085f\u{1f806}', |
| aspect: 'depth-only', |
| baseMipLevel: 3, |
| mipLevelCount: 1, |
| baseArrayLayer: 72, |
| arrayLayerCount: 31, |
| }); |
| let commandEncoder35 = device2.createCommandEncoder(); |
| let textureView45 = texture32.createView({ |
| label: '\u087f\u0db1\ua6ee\u62c5\u182a\u004c', |
| dimension: '2d', |
| aspect: 'depth-only', |
| baseMipLevel: 3, |
| mipLevelCount: 1, |
| baseArrayLayer: 444, |
| arrayLayerCount: 1, |
| }); |
| let gpuCanvasContext12 = offscreenCanvas11.getContext('webgpu'); |
| let videoFrame10 = new VideoFrame(canvas3, {timestamp: 0}); |
| try { |
| gpuCanvasContext6.unconfigure(); |
| } catch {} |
| let bindGroupLayout10 = device0.createBindGroupLayout({ |
| label: '\u0977\u{1f89d}\ua961\u07b9\u09a3\u0639\u0e74\u5440\u0e97\u0b1c', |
| entries: [{binding: 5419, visibility: 0, externalTexture: {}}], |
| }); |
| let textureView46 = texture6.createView({format: 'rg16sint'}); |
| let computePassEncoder14 = commandEncoder26.beginComputePass(); |
| let renderBundleEncoder17 = device0.createRenderBundleEncoder({ |
| label: '\u0f78\u1627\u40c6\u0a71\u58b0\u22c4\u{1fa59}\u{1ff88}\uea6d\u7cf5', |
| colorFormats: ['r16uint', 'rgba16uint', 'rg16sint', 'r8sint', 'rg32uint', 'rg8unorm', 'rgb10a2unorm'], |
| sampleCount: 4, |
| }); |
| try { |
| renderBundleEncoder10.setPipeline(pipeline7); |
| } catch {} |
| try { |
| commandEncoder24.copyBufferToTexture({ |
| /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 2260 */ |
| offset: 2260, |
| buffer: buffer3, |
| }, { |
| texture: texture4, |
| mipLevel: 2, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 1, height: 1, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| commandEncoder15.clearBuffer(buffer2, 66776, 88016); |
| dissociateBuffer(device0, buffer2); |
| } catch {} |
| try { |
| commandEncoder32.insertDebugMarker('\ud0b6'); |
| } catch {} |
| let promise6 = device0.createComputePipelineAsync({ |
| label: '\u4e00\u08ec\u166c\u0ccf\u5b4c\u6924\u6b29\u{1f8da}\u0f27', |
| layout: pipelineLayout1, |
| compute: {module: shaderModule6, entryPoint: 'compute0', constants: {}}, |
| }); |
| let gpuCanvasContext13 = offscreenCanvas12.getContext('webgpu'); |
| try { |
| offscreenCanvas10.getContext('bitmaprenderer'); |
| } catch {} |
| gc(); |
| let video7 = await videoWithData(); |
| let bindGroupLayout11 = device2.createBindGroupLayout({ |
| label: '\u{1fb40}\u0e3f\u03a1\u0107\u{1f85e}', |
| entries: [{binding: 2190, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, externalTexture: {}}], |
| }); |
| let commandEncoder36 = device2.createCommandEncoder({label: '\u9994\uc388'}); |
| let querySet17 = device2.createQuerySet({ |
| label: '\u97a6\u0c1b\u0830\u17f4\u{1fbfb}\u3895\u82bc\ud9be\ue15b\u4033', |
| type: 'occlusion', |
| count: 2458, |
| }); |
| let textureView47 = texture32.createView({dimension: '2d', aspect: 'depth-only', baseMipLevel: 2, baseArrayLayer: 306, arrayLayerCount: 1}); |
| let computePassEncoder15 = commandEncoder36.beginComputePass({label: '\u0c46\u{1f668}\u6924\u0cf6\u376d\u0cce\ue617\u8a55\u{1f90e}\u02a0\u0d4f'}); |
| try { |
| computePassEncoder15.end(); |
| } catch {} |
| let pipelineLayout10 = device2.createPipelineLayout({bindGroupLayouts: [bindGroupLayout11, bindGroupLayout11, bindGroupLayout11]}); |
| let commandEncoder37 = device2.createCommandEncoder({label: '\u0daa\ucb56\u068f\u2831\u0042\uaeb1'}); |
| let textureView48 = texture32.createView({ |
| label: '\uc03e\u03df\ud7ab\u00ae\u{1fa65}\u{1f643}', |
| aspect: 'depth-only', |
| format: 'depth24plus', |
| baseMipLevel: 4, |
| baseArrayLayer: 145, |
| arrayLayerCount: 325, |
| }); |
| let externalTexture18 = device2.importExternalTexture({label: '\u{1feb7}\u2e62\u8db0', source: videoFrame6, colorSpace: 'srgb'}); |
| let promise7 = navigator.gpu.requestAdapter({}); |
| let shaderModule9 = device2.createShaderModule({ |
| label: '\u5be1\u{1fff7}\u037e\u089d\u7547', |
| code: `@group(0) @binding(2190) |
| var<storage, read_write> function4: array<u32>; |
| @group(2) @binding(2190) |
| var<storage, read_write> function5: array<u32>; |
| @group(1) @binding(2190) |
| var<storage, read_write> type5: array<u32>; |
| |
| @compute @workgroup_size(7, 1, 4) |
| fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {} |
| |
| struct S10 { |
| @builtin(sample_index) f0: u32, |
| @location(25) f1: vec2<i32>, |
| @builtin(front_facing) f2: bool, |
| @location(63) f3: vec4<f32>, |
| @location(84) f4: vec2<f16> |
| } |
| struct FragmentOutput0 { |
| @location(6) f0: vec2<i32>, |
| @builtin(sample_mask) f1: u32, |
| @location(0) f2: f32, |
| @location(1) f3: vec4<i32> |
| } |
| |
| @fragment |
| fn fragment0(@location(76) a0: vec4<i32>, @location(16) a1: vec4<i32>, @location(49) a2: vec4<f16>, @location(50) a3: f32, @location(48) a4: vec3<f16>, a5: S10, @location(93) a6: vec3<i32>, @location(43) a7: vec3<f32>, @builtin(position) a8: vec4<f32>, @builtin(sample_mask) a9: u32, @location(52) a10: vec4<i32>, @location(40) a11: vec4<u32>) -> FragmentOutput0 { |
| return FragmentOutput0(); |
| } |
| |
| struct S9 { |
| @location(11) f0: vec2<f16>, |
| @location(16) f1: vec2<f32>, |
| @location(12) f2: f16, |
| @location(19) f3: vec3<i32>, |
| @location(7) f4: vec4<i32>, |
| @location(15) f5: vec4<i32>, |
| @location(3) f6: vec4<f32>, |
| @builtin(instance_index) f7: u32, |
| @location(13) f8: vec2<f16>, |
| @location(21) f9: vec4<u32>, |
| @location(20) f10: vec3<i32>, |
| @location(6) f11: i32, |
| @location(10) f12: i32, |
| @location(4) f13: vec4<u32>, |
| @location(17) f14: vec4<f16>, |
| @location(8) f15: vec2<i32>, |
| @location(14) f16: vec2<i32> |
| } |
| struct VertexOutput0 { |
| @location(84) f143: vec2<f16>, |
| @location(16) f144: vec4<i32>, |
| @location(25) f145: vec2<i32>, |
| @builtin(position) f146: vec4<f32>, |
| @location(49) f147: vec4<f16>, |
| @location(52) f148: vec4<i32>, |
| @location(50) f149: f32, |
| @location(76) f150: vec4<i32>, |
| @location(48) f151: vec3<f16>, |
| @location(93) f152: vec3<i32>, |
| @location(40) f153: vec4<u32>, |
| @location(63) f154: vec4<f32>, |
| @location(43) f155: vec3<f32> |
| } |
| |
| @vertex |
| fn vertex0(@location(23) a0: vec4<f16>, @location(18) a1: vec4<f16>, @builtin(vertex_index) a2: u32, a3: S9, @location(2) a4: f32, @location(9) a5: vec3<u32>, @location(5) a6: vec3<f16>, @location(22) a7: vec4<u32>, @location(0) a8: vec3<f32>, @location(1) a9: f32) -> VertexOutput0 { |
| return VertexOutput0(); |
| } |
| |
| `, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| let commandEncoder38 = device2.createCommandEncoder({label: '\u4a55\u{1fd5e}\u{1ff1c}\u9444\u042b\u3be9'}); |
| let textureView49 = texture32.createView({ |
| label: '\u7990\u0f20\u3417\ucf3b\u{1f9df}\u07cb\ud4e7', |
| aspect: 'depth-only', |
| format: 'depth24plus', |
| baseMipLevel: 4, |
| baseArrayLayer: 69, |
| arrayLayerCount: 298, |
| }); |
| let pipeline21 = device2.createRenderPipeline({ |
| label: '\u{1fb7e}\ue3d8\u752a\u{1f9ae}', |
| layout: pipelineLayout10, |
| fragment: { |
| module: shaderModule9, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{format: 'r16float', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.RED}, {format: 'rg16sint', writeMask: GPUColorWrite.ALL}], |
| }, |
| vertex: { |
| module: shaderModule9, |
| entryPoint: 'vertex0', |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 4140, |
| stepMode: 'vertex', |
| attributes: [{format: 'float32', offset: 60, shaderLocation: 3}], |
| }, |
| { |
| arrayStride: 136, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'uint32x2', offset: 32, shaderLocation: 4}, |
| {format: 'sint32', offset: 16, shaderLocation: 14}, |
| {format: 'uint16x2', offset: 12, shaderLocation: 9}, |
| ], |
| }, |
| { |
| arrayStride: 7144, |
| attributes: [ |
| {format: 'snorm8x4', offset: 3444, shaderLocation: 17}, |
| {format: 'uint16x4', offset: 24, shaderLocation: 22}, |
| {format: 'uint32', offset: 3228, shaderLocation: 21}, |
| {format: 'float32', offset: 572, shaderLocation: 16}, |
| {format: 'float32x2', offset: 468, shaderLocation: 12}, |
| {format: 'unorm16x4', offset: 8, shaderLocation: 23}, |
| {format: 'sint32x4', offset: 1680, shaderLocation: 19}, |
| {format: 'sint32', offset: 204, shaderLocation: 7}, |
| ], |
| }, |
| { |
| arrayStride: 18936, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'sint32', offset: 2792, shaderLocation: 10}, |
| {format: 'sint16x2', offset: 4344, shaderLocation: 15}, |
| {format: 'snorm16x2', offset: 3256, shaderLocation: 2}, |
| {format: 'sint32', offset: 320, shaderLocation: 8}, |
| {format: 'sint32x4', offset: 9120, shaderLocation: 6}, |
| {format: 'float16x4', offset: 360, shaderLocation: 13}, |
| {format: 'float32x3', offset: 940, shaderLocation: 0}, |
| {format: 'float16x2', offset: 8984, shaderLocation: 1}, |
| {format: 'sint32x3', offset: 2628, shaderLocation: 20}, |
| {format: 'snorm16x2', offset: 3348, shaderLocation: 18}, |
| {format: 'float16x4', offset: 4216, shaderLocation: 11}, |
| ], |
| }, |
| {arrayStride: 6900, attributes: []}, |
| {arrayStride: 928, attributes: []}, |
| { |
| arrayStride: 3916, |
| stepMode: 'instance', |
| attributes: [{format: 'float32x3', offset: 524, shaderLocation: 5}], |
| }, |
| ], |
| }, |
| }); |
| let imageData8 = new ImageData(128, 128); |
| let commandEncoder39 = device1.createCommandEncoder({}); |
| let texture33 = device1.createTexture({ |
| label: '\u072a\u3796\ub5e0', |
| size: [1260, 6, 1454], |
| mipLevelCount: 8, |
| dimension: '3d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: ['rg8uint', 'rg8uint', 'rg8uint'], |
| }); |
| let computePassEncoder16 = commandEncoder31.beginComputePass({label: '\u9f3e\u0ee3'}); |
| let renderBundleEncoder18 = device1.createRenderBundleEncoder({label: '\u03c1\u0906\u{1fe1b}', colorFormats: ['rgba8uint', 'rg8uint', 'rgba8uint', 'rgba32uint']}); |
| let externalTexture19 = device1.importExternalTexture({ |
| label: '\u130c\ucd6e\ub393\u0812\u9f8a\uafa6\u5ae5\u{1fc2d}\u{1fbaa}\ubd52\u0e01', |
| source: videoFrame5, |
| colorSpace: 'display-p3', |
| }); |
| try { |
| commandEncoder39.copyTextureToTexture({ |
| texture: texture29, |
| mipLevel: 6, |
| origin: {x: 0, y: 0, z: 5}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture33, |
| mipLevel: 6, |
| origin: {x: 0, y: 0, z: 1}, |
| aspect: 'all', |
| }, |
| {width: 1, height: 0, depthOrArrayLayers: 6}); |
| } catch {} |
| try { |
| gpuCanvasContext4.unconfigure(); |
| } catch {} |
| let offscreenCanvas13 = new OffscreenCanvas(40, 34); |
| let img4 = await imageWithData(270, 55, '#928c7a19', '#a723d5c8'); |
| let gpuCanvasContext14 = offscreenCanvas13.getContext('webgpu'); |
| let img5 = await imageWithData(266, 3, '#9a820e6c', '#beb152ec'); |
| let imageBitmap7 = await createImageBitmap(imageData2); |
| let bindGroupLayout12 = device2.createBindGroupLayout({ |
| label: '\u6470\u3751\u4242\uef4f\u{1fe4e}\u{1f80f}\u5d33\uc047\u5310\u07c5\u9ee3', |
| entries: [ |
| { |
| binding: 3689, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '1d', sampleType: 'depth', multisampled: false }, |
| }, |
| { |
| binding: 2460, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'read-only-storage', minBindingSize: 0, hasDynamicOffset: true }, |
| }, |
| { |
| binding: 8040, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba8snorm', access: 'write-only', viewDimension: '3d' }, |
| }, |
| ], |
| }); |
| let buffer13 = device2.createBuffer({ |
| label: '\ub740\u0e25\u83ad\u1ba4\u01ed\u8536\u92d9', |
| size: 279705, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE, |
| }); |
| let texture34 = device2.createTexture({ |
| label: '\uea82\ub48e\u{1fd4c}\u{1f789}\u4010\u2c16\u79d1\uae57', |
| size: [126, 1, 4], |
| dimension: '3d', |
| format: 'rg16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| let textureView50 = texture32.createView({ |
| label: '\u85fa\ue2d6\u0996\u{1fb6d}\u0410\u{1f6f6}\u{1fade}\uaad3\udc12\u{1face}', |
| dimension: '2d', |
| baseMipLevel: 2, |
| mipLevelCount: 1, |
| baseArrayLayer: 364, |
| }); |
| try { |
| device2.queue.writeTexture({ |
| texture: texture34, |
| mipLevel: 0, |
| origin: {x: 16, y: 0, z: 0}, |
| aspect: 'all', |
| }, arrayBuffer0, /* required buffer size: 55_009 */ |
| {offset: 365, bytesPerRow: 227, rowsPerImage: 240}, {width: 41, height: 1, depthOrArrayLayers: 2}); |
| } catch {} |
| let pipeline22 = await device2.createComputePipelineAsync({ |
| label: '\u46a8\ue6e1\u0b10\u1eb2\u{1fc04}\u{1f83d}\u{1fbc1}\u181a\u0019', |
| layout: pipelineLayout10, |
| compute: {module: shaderModule9, entryPoint: 'compute0', constants: {}}, |
| }); |
| let pipeline23 = device2.createRenderPipeline({ |
| label: '\u6789\u0374\uefc1\u{1f6ba}\u{1fec9}\u0a97\u0cd1\u{1ff68}\u0c1e', |
| layout: pipelineLayout10, |
| multisample: {mask: 0x64f30645}, |
| fragment: { |
| module: shaderModule9, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{ |
| format: 'r16float', |
| blend: { |
| color: {operation: 'reverse-subtract', srcFactor: 'one-minus-src', dstFactor: 'one-minus-dst-alpha'}, |
| alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'}, |
| }, |
| }, {format: 'rg16sint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN}], |
| }, |
| vertex: { |
| module: shaderModule9, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 756, |
| attributes: [ |
| {format: 'float32x3', offset: 256, shaderLocation: 11}, |
| {format: 'float32x2', offset: 68, shaderLocation: 18}, |
| ], |
| }, |
| { |
| arrayStride: 2600, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'float16x4', offset: 228, shaderLocation: 16}, |
| {format: 'snorm8x4', offset: 408, shaderLocation: 12}, |
| {format: 'float16x2', offset: 76, shaderLocation: 17}, |
| {format: 'uint8x2', offset: 566, shaderLocation: 9}, |
| {format: 'sint32x2', offset: 412, shaderLocation: 15}, |
| {format: 'sint32x4', offset: 128, shaderLocation: 6}, |
| {format: 'unorm16x4', offset: 540, shaderLocation: 13}, |
| {format: 'snorm8x4', offset: 636, shaderLocation: 3}, |
| {format: 'uint32', offset: 24, shaderLocation: 4}, |
| {format: 'unorm8x2', offset: 514, shaderLocation: 1}, |
| {format: 'sint32', offset: 1180, shaderLocation: 14}, |
| {format: 'sint32x2', offset: 12, shaderLocation: 20}, |
| {format: 'uint32x4', offset: 56, shaderLocation: 22}, |
| {format: 'sint32x3', offset: 1140, shaderLocation: 8}, |
| {format: 'float32x4', offset: 108, shaderLocation: 0}, |
| {format: 'unorm16x4', offset: 684, shaderLocation: 23}, |
| {format: 'unorm8x2', offset: 366, shaderLocation: 5}, |
| {format: 'float32x4', offset: 64, shaderLocation: 2}, |
| {format: 'sint16x4', offset: 492, shaderLocation: 19}, |
| {format: 'sint32x4', offset: 588, shaderLocation: 10}, |
| {format: 'sint32x4', offset: 0, shaderLocation: 7}, |
| {format: 'uint8x2', offset: 354, shaderLocation: 21}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'point-list', frontFace: 'cw', cullMode: 'front'}, |
| }); |
| gc(); |
| let querySet18 = device2.createQuerySet({label: '\ua39c\u4bd0\u{1fdd9}\ua0ac\u3602\u9df5\uc389\u{1f9a9}', type: 'occlusion', count: 198}); |
| let computePassEncoder17 = commandEncoder36.beginComputePass({label: '\u{1fc68}\uc93b\u083b\u{1f8d1}\ud032\u1bf3'}); |
| let renderBundleEncoder19 = device2.createRenderBundleEncoder({ |
| label: '\u0b67\uc6d2\u08b0\u568d\u089d\u324b\u235d\u{1fd94}\u{1f692}\uaa0a', |
| colorFormats: ['r16float', 'rg16sint'], |
| depthReadOnly: true, |
| }); |
| let renderBundle20 = renderBundleEncoder19.finish({label: '\u{1ff5b}\u{1f68d}\u{1fd5d}'}); |
| let externalTexture20 = device2.importExternalTexture({ |
| label: '\u341a\u306b\u{1fad7}\u3d84\ua815\u{1fd34}\u0d2d', |
| source: videoFrame3, |
| colorSpace: 'display-p3', |
| }); |
| try { |
| device2.queue.writeBuffer(buffer13, 41792, new Float32Array(16249), 14374, 716); |
| } catch {} |
| let pipeline24 = device2.createComputePipeline({ |
| label: '\ucf1c\u{1fa50}\u46f5\ub44b\u03cf', |
| layout: pipelineLayout10, |
| compute: {module: shaderModule9, entryPoint: 'compute0', constants: {}}, |
| }); |
| let pipeline25 = device2.createRenderPipeline({ |
| label: '\ue641\u{1fc72}\u{1f9a1}\ua236\u1cf2\u09ed\u0533', |
| layout: pipelineLayout10, |
| fragment: { |
| module: shaderModule9, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{format: 'r16float', writeMask: GPUColorWrite.BLUE}, {format: 'rg16sint', writeMask: GPUColorWrite.ALL}], |
| }, |
| depthStencil: { |
| format: 'depth24plus-stencil8', |
| depthWriteEnabled: false, |
| depthCompare: 'less-equal', |
| stencilFront: {compare: 'never', failOp: 'decrement-wrap', depthFailOp: 'increment-clamp', passOp: 'increment-wrap'}, |
| stencilBack: {compare: 'less-equal', failOp: 'replace', depthFailOp: 'decrement-clamp', passOp: 'invert'}, |
| stencilReadMask: 3702655734, |
| stencilWriteMask: 2701951432, |
| depthBiasSlopeScale: 400.34210795972643, |
| depthBiasClamp: 618.3923327985416, |
| }, |
| vertex: { |
| module: shaderModule9, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 2852, |
| stepMode: 'vertex', |
| attributes: [ |
| {format: 'snorm8x2', offset: 128, shaderLocation: 3}, |
| {format: 'float16x4', offset: 1036, shaderLocation: 17}, |
| {format: 'uint32x4', offset: 696, shaderLocation: 4}, |
| {format: 'sint32x3', offset: 296, shaderLocation: 8}, |
| {format: 'snorm16x4', offset: 172, shaderLocation: 16}, |
| ], |
| }, |
| { |
| arrayStride: 4956, |
| stepMode: 'vertex', |
| attributes: [ |
| {format: 'sint32x4', offset: 36, shaderLocation: 7}, |
| {format: 'sint8x2', offset: 278, shaderLocation: 15}, |
| {format: 'snorm8x2', offset: 1010, shaderLocation: 12}, |
| {format: 'snorm16x4', offset: 1276, shaderLocation: 0}, |
| {format: 'unorm8x4', offset: 88, shaderLocation: 2}, |
| {format: 'float32x4', offset: 252, shaderLocation: 5}, |
| ], |
| }, |
| { |
| arrayStride: 4296, |
| stepMode: 'instance', |
| attributes: [{format: 'sint32x4', offset: 724, shaderLocation: 19}], |
| }, |
| { |
| arrayStride: 3032, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'unorm10-10-10-2', offset: 464, shaderLocation: 13}, |
| {format: 'uint16x2', offset: 444, shaderLocation: 22}, |
| {format: 'snorm8x2', offset: 62, shaderLocation: 18}, |
| {format: 'unorm10-10-10-2', offset: 216, shaderLocation: 11}, |
| {format: 'sint8x4', offset: 32, shaderLocation: 20}, |
| {format: 'uint16x2', offset: 1128, shaderLocation: 9}, |
| {format: 'uint32x2', offset: 776, shaderLocation: 21}, |
| {format: 'snorm8x4', offset: 580, shaderLocation: 1}, |
| {format: 'sint32x2', offset: 72, shaderLocation: 10}, |
| {format: 'sint32', offset: 2308, shaderLocation: 14}, |
| {format: 'sint32x2', offset: 1028, shaderLocation: 6}, |
| {format: 'unorm8x4', offset: 312, shaderLocation: 23}, |
| ], |
| }, |
| ], |
| }, |
| }); |
| let imageData9 = new ImageData(200, 4); |
| let bindGroup11 = device2.createBindGroup({layout: bindGroupLayout11, entries: [{binding: 2190, resource: externalTexture18}]}); |
| let commandEncoder40 = device2.createCommandEncoder(); |
| let computePassEncoder18 = commandEncoder38.beginComputePass({}); |
| let renderBundleEncoder20 = device2.createRenderBundleEncoder({ |
| label: '\uf34b\u093a\u2269\u5039\u281c\ue3ea\u0039', |
| colorFormats: ['r16float', 'rg16sint'], |
| stencilReadOnly: true, |
| }); |
| let renderBundle21 = renderBundleEncoder20.finish({label: '\ud4d5\u{1feb0}\u214f\uf9e0\u0109\u78e1'}); |
| try { |
| computePassEncoder17.setBindGroup(3, bindGroup11, new Uint32Array(3759), 2125, 0); |
| } catch {} |
| try { |
| device2.queue.writeBuffer(buffer13, 111308, new Int16Array(61242), 40747, 1992); |
| } catch {} |
| try { |
| device2.queue.writeTexture({ |
| texture: texture34, |
| mipLevel: 0, |
| origin: {x: 54, y: 0, z: 0}, |
| aspect: 'all', |
| }, new ArrayBuffer(24), /* required buffer size: 91 */ |
| {offset: 91}, {width: 9, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| gc(); |
| let imageData10 = new ImageData(160, 28); |
| let commandEncoder41 = device2.createCommandEncoder({label: '\u9f31\u{1fcb6}\uf316\ue6a9\u5170\u0ba6\u{1fb60}\u{1fe83}\u{1fef4}\u0bc3'}); |
| let textureView51 = texture32.createView({label: '\u7a17\ufbe7', dimension: '2d', aspect: 'depth-only', baseMipLevel: 4, baseArrayLayer: 36}); |
| let externalTexture21 = device2.importExternalTexture({label: '\u{1feef}\ua187\u0031\u{1faf8}\u31e5', source: video4, colorSpace: 'display-p3'}); |
| try { |
| commandEncoder40.clearBuffer(buffer13, 39020, 35452); |
| dissociateBuffer(device2, buffer13); |
| } catch {} |
| let pipeline26 = device2.createRenderPipeline({ |
| label: '\u{1fdfa}\u9e3a\u{1fe02}\ub897', |
| layout: pipelineLayout10, |
| multisample: {count: 4, mask: 0x6c22fa6f}, |
| fragment: { |
| module: shaderModule9, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{ |
| format: 'r16float', |
| writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED, |
| }, {format: 'rg16sint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.RED}], |
| }, |
| depthStencil: { |
| format: 'depth24plus-stencil8', |
| depthWriteEnabled: false, |
| depthCompare: 'less', |
| stencilFront: {compare: 'greater-equal', failOp: 'increment-wrap', depthFailOp: 'zero'}, |
| stencilBack: {compare: 'greater', failOp: 'increment-clamp', passOp: 'increment-wrap'}, |
| stencilWriteMask: 2658160395, |
| depthBiasSlopeScale: 432.9544787652186, |
| depthBiasClamp: 386.5909222144228, |
| }, |
| vertex: { |
| module: shaderModule9, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 16392, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'sint8x2', offset: 1126, shaderLocation: 6}, |
| {format: 'float32', offset: 8, shaderLocation: 12}, |
| {format: 'float16x2', offset: 2756, shaderLocation: 17}, |
| {format: 'snorm16x4', offset: 2728, shaderLocation: 3}, |
| {format: 'uint16x2', offset: 0, shaderLocation: 21}, |
| {format: 'snorm16x2', offset: 3652, shaderLocation: 11}, |
| {format: 'float32', offset: 1924, shaderLocation: 23}, |
| {format: 'uint8x4', offset: 232, shaderLocation: 4}, |
| {format: 'uint32x4', offset: 2252, shaderLocation: 22}, |
| {format: 'unorm10-10-10-2', offset: 4428, shaderLocation: 18}, |
| {format: 'float16x2', offset: 148, shaderLocation: 2}, |
| {format: 'float32x4', offset: 96, shaderLocation: 1}, |
| {format: 'snorm16x2', offset: 896, shaderLocation: 16}, |
| {format: 'snorm8x2', offset: 594, shaderLocation: 5}, |
| {format: 'sint32x4', offset: 2992, shaderLocation: 15}, |
| {format: 'sint16x4', offset: 2156, shaderLocation: 19}, |
| {format: 'uint8x2', offset: 4752, shaderLocation: 9}, |
| {format: 'snorm8x4', offset: 2744, shaderLocation: 13}, |
| {format: 'sint32x2', offset: 1228, shaderLocation: 7}, |
| {format: 'sint8x4', offset: 10472, shaderLocation: 14}, |
| {format: 'sint32x4', offset: 3492, shaderLocation: 10}, |
| {format: 'sint32x2', offset: 348, shaderLocation: 20}, |
| {format: 'sint32x2', offset: 116, shaderLocation: 8}, |
| ], |
| }, |
| { |
| arrayStride: 0, |
| stepMode: 'instance', |
| attributes: [{format: 'unorm10-10-10-2', offset: 340, shaderLocation: 0}], |
| }, |
| ], |
| }, |
| }); |
| try { |
| computePassEncoder18.setPipeline(pipeline22); |
| } catch {} |
| try { |
| texture32.destroy(); |
| } catch {} |
| let pipeline27 = await device2.createComputePipelineAsync({ |
| label: '\u3ddd\u{1f757}\uabea', |
| layout: pipelineLayout10, |
| compute: {module: shaderModule9, entryPoint: 'compute0', constants: {}}, |
| }); |
| let pipeline28 = device2.createRenderPipeline({ |
| layout: pipelineLayout10, |
| fragment: { |
| module: shaderModule9, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{ |
| format: 'r16float', |
| blend: { |
| color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'}, |
| alpha: {operation: 'subtract', srcFactor: 'src-alpha-saturated', dstFactor: 'one-minus-constant'}, |
| }, |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA, |
| }, { |
| format: 'rg16sint', |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED, |
| }], |
| }, |
| vertex: { |
| module: shaderModule9, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 41356, |
| stepMode: 'vertex', |
| attributes: [ |
| {format: 'snorm8x4', offset: 2700, shaderLocation: 3}, |
| {format: 'uint32x2', offset: 2912, shaderLocation: 21}, |
| {format: 'snorm8x2', offset: 104, shaderLocation: 16}, |
| {format: 'unorm16x4', offset: 5852, shaderLocation: 11}, |
| {format: 'unorm16x4', offset: 8540, shaderLocation: 17}, |
| {format: 'sint32x3', offset: 19476, shaderLocation: 20}, |
| {format: 'snorm8x2', offset: 1692, shaderLocation: 0}, |
| {format: 'sint16x4', offset: 3148, shaderLocation: 15}, |
| {format: 'snorm8x4', offset: 27040, shaderLocation: 23}, |
| {format: 'float32x3', offset: 8996, shaderLocation: 1}, |
| {format: 'snorm8x2', offset: 5860, shaderLocation: 12}, |
| {format: 'snorm16x4', offset: 4728, shaderLocation: 18}, |
| {format: 'sint16x4', offset: 4424, shaderLocation: 6}, |
| {format: 'sint16x2', offset: 14560, shaderLocation: 7}, |
| {format: 'float16x2', offset: 4532, shaderLocation: 13}, |
| {format: 'uint32x4', offset: 33032, shaderLocation: 4}, |
| {format: 'float32x3', offset: 2320, shaderLocation: 2}, |
| ], |
| }, |
| { |
| arrayStride: 16016, |
| attributes: [ |
| {format: 'uint32', offset: 1392, shaderLocation: 9}, |
| {format: 'sint32', offset: 13964, shaderLocation: 10}, |
| {format: 'sint32x2', offset: 332, shaderLocation: 14}, |
| ], |
| }, |
| {arrayStride: 1084, attributes: [{format: 'sint8x2', offset: 106, shaderLocation: 8}]}, |
| { |
| arrayStride: 0, |
| attributes: [ |
| {format: 'float16x2', offset: 9704, shaderLocation: 5}, |
| {format: 'sint16x4', offset: 912, shaderLocation: 19}, |
| ], |
| }, |
| {arrayStride: 6820, stepMode: 'instance', attributes: []}, |
| {arrayStride: 112, stepMode: 'instance', attributes: []}, |
| {arrayStride: 7888, attributes: []}, |
| { |
| arrayStride: 0, |
| stepMode: 'instance', |
| attributes: [{format: 'uint16x2', offset: 1448, shaderLocation: 22}], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-list', frontFace: 'ccw', cullMode: 'front', unclippedDepth: false}, |
| }); |
| document.body.prepend(canvas3); |
| let renderBundle22 = renderBundleEncoder20.finish({label: '\ub365\udda5\uc3bc\ubd65\u1d33\u0e72'}); |
| try { |
| device2.queue.writeBuffer(buffer13, 60376, new BigUint64Array(57989), 1547, 612); |
| } catch {} |
| try { |
| device2.queue.writeTexture({ |
| texture: texture34, |
| mipLevel: 0, |
| origin: {x: 4, y: 0, z: 0}, |
| aspect: 'all', |
| }, arrayBuffer1, /* required buffer size: 82_315 */ |
| {offset: 327, bytesPerRow: 452, rowsPerImage: 181}, {width: 44, height: 1, depthOrArrayLayers: 2}); |
| } catch {} |
| document.body.prepend(video5); |
| let img6 = await imageWithData(28, 237, '#72cc3d1b', '#f49ff1d4'); |
| let textureView52 = texture32.createView({ |
| label: '\u{1ffab}\ubd3a', |
| aspect: 'depth-only', |
| baseMipLevel: 4, |
| baseArrayLayer: 338, |
| arrayLayerCount: 3, |
| }); |
| let computePassEncoder19 = commandEncoder37.beginComputePass(); |
| try { |
| device2.queue.writeTexture({ |
| texture: texture34, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, arrayBuffer1, /* required buffer size: 148 */ |
| {offset: 148, bytesPerRow: 536}, {width: 76, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let promise8 = device2.queue.onSubmittedWorkDone(); |
| let bindGroupLayout13 = device2.createBindGroupLayout({label: '\u2d68\u{1fb89}\ub9df\ud1d9\u1262\uac74\u0521\u5966\u0a88\u6d7b', entries: []}); |
| let commandEncoder42 = device2.createCommandEncoder({}); |
| let querySet19 = device2.createQuerySet({label: '\u{1f844}\u0858\u99e4\u289a\u{1fb38}', type: 'occlusion', count: 2605}); |
| let commandBuffer5 = commandEncoder40.finish(); |
| let computePassEncoder20 = commandEncoder41.beginComputePass({label: '\u4862\ub5de\u0c86\u78c6\u0baa\ucea7\u5c57\u087a\u091b\uf388'}); |
| try { |
| commandEncoder42.copyBufferToTexture({ |
| /* bytesInLastRow: 476 widthInBlocks: 119 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 2540 */ |
| offset: 2540, |
| buffer: buffer13, |
| }, { |
| texture: texture34, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 1}, |
| aspect: 'all', |
| }, {width: 119, height: 1, depthOrArrayLayers: 0}); |
| dissociateBuffer(device2, buffer13); |
| } catch {} |
| try { |
| gpuCanvasContext6.configure({ |
| device: device2, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: ['bgra8unorm', 'bgra8unorm'], |
| colorSpace: 'srgb', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let img7 = await imageWithData(251, 248, '#c3357df2', '#5d0ee3c8'); |
| try { |
| gpuCanvasContext13.unconfigure(); |
| } catch {} |
| let img8 = await imageWithData(154, 94, '#3b4a691a', '#e29484d1'); |
| try { |
| adapter2.label = '\u532d\u{1fd2c}\u7b9b\u{1ff18}'; |
| } catch {} |
| try { |
| await promise8; |
| } catch {} |
| let bindGroup12 = device2.createBindGroup({layout: bindGroupLayout13, entries: []}); |
| try { |
| computePassEncoder20.setBindGroup(0, bindGroup12); |
| } catch {} |
| let commandEncoder43 = device2.createCommandEncoder({}); |
| let computePassEncoder21 = commandEncoder43.beginComputePass({label: '\u0bc7\u3079\u0f53\u5684\ubd62\u{1f845}\u04f1\u0388\u{1fc52}'}); |
| let renderBundleEncoder21 = device2.createRenderBundleEncoder({ |
| label: '\uad70\u5ad9\ub770\u{1fd23}\u{1fa41}\ub4c6\u4189\u{1fa95}\u0370\u{1f98a}', |
| colorFormats: ['rg32uint', 'rg16uint', 'r32uint', 'r16sint', 'rg32sint', 'rg32sint'], |
| depthReadOnly: true, |
| stencilReadOnly: true, |
| }); |
| try { |
| computePassEncoder20.setBindGroup(1, bindGroup12, new Uint32Array(9424), 8173, 0); |
| } catch {} |
| let pipeline29 = device2.createComputePipeline({ |
| label: '\u{1fb5a}\u9eeb\u9db4\ubc8a\u{1fefe}\ue5a4\udded\u3a25\u{1f7b2}\u1fa1\u1436', |
| layout: pipelineLayout10, |
| compute: {module: shaderModule9, entryPoint: 'compute0'}, |
| }); |
| let bindGroupLayout14 = device2.createBindGroupLayout({ |
| label: '\u056d\u01cd\u0a06', |
| entries: [ |
| { |
| binding: 4304, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false }, |
| }, |
| { |
| binding: 5786, |
| visibility: 0, |
| buffer: { type: 'storage', minBindingSize: 112906804, hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let texture35 = device2.createTexture({ |
| label: '\u4d35\u{1fedc}\u{1f6e5}\u90dd\u9b90\ufeb8\u0e9d\u963b\ua9b8\u08ea\u7ff1', |
| size: [504, 1, 1917], |
| mipLevelCount: 11, |
| dimension: '3d', |
| format: 'rg16uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rg16uint'], |
| }); |
| let renderBundle23 = renderBundleEncoder21.finish({}); |
| try { |
| commandEncoder35.copyBufferToTexture({ |
| /* bytesInLastRow: 200 widthInBlocks: 50 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 13784 */ |
| offset: 13784, |
| buffer: buffer13, |
| }, { |
| texture: texture34, |
| mipLevel: 0, |
| origin: {x: 17, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 50, height: 0, depthOrArrayLayers: 0}); |
| dissociateBuffer(device2, buffer13); |
| } catch {} |
| let pipeline30 = device2.createComputePipeline({ |
| label: '\u0fb2\u04b5\u0d7b\u0ac9\u06ac\u{1faf5}\u{1f790}\u9024\u0174\u{1ff29}\u0e5e', |
| layout: pipelineLayout10, |
| compute: {module: shaderModule9, entryPoint: 'compute0', constants: {}}, |
| }); |
| let pipeline31 = device2.createRenderPipeline({ |
| label: '\u6829\u9480\u0027\u14aa\u02d7', |
| layout: pipelineLayout10, |
| depthStencil: { |
| format: 'depth24plus-stencil8', |
| depthWriteEnabled: true, |
| depthCompare: 'never', |
| stencilFront: {compare: 'greater-equal', failOp: 'increment-clamp', depthFailOp: 'decrement-clamp', passOp: 'zero'}, |
| stencilBack: {compare: 'less-equal', failOp: 'zero', depthFailOp: 'decrement-clamp', passOp: 'decrement-wrap'}, |
| stencilReadMask: 963010486, |
| depthBias: 0, |
| depthBiasSlopeScale: 465.64750483085083, |
| depthBiasClamp: 58.277541759286265, |
| }, |
| vertex: { |
| module: shaderModule9, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 20840, |
| attributes: [ |
| {format: 'sint32x4', offset: 11692, shaderLocation: 7}, |
| {format: 'float16x2', offset: 2204, shaderLocation: 16}, |
| {format: 'snorm8x4', offset: 20836, shaderLocation: 3}, |
| {format: 'uint32', offset: 1080, shaderLocation: 21}, |
| {format: 'sint32', offset: 4840, shaderLocation: 10}, |
| {format: 'float32x2', offset: 10936, shaderLocation: 2}, |
| {format: 'float32', offset: 2804, shaderLocation: 11}, |
| {format: 'uint32x2', offset: 4404, shaderLocation: 4}, |
| {format: 'float32x4', offset: 7712, shaderLocation: 0}, |
| {format: 'unorm16x4', offset: 9596, shaderLocation: 13}, |
| {format: 'uint32', offset: 13256, shaderLocation: 22}, |
| {format: 'float32', offset: 376, shaderLocation: 23}, |
| {format: 'sint32x2', offset: 1356, shaderLocation: 20}, |
| {format: 'sint32', offset: 1396, shaderLocation: 14}, |
| ], |
| }, |
| { |
| arrayStride: 11000, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'sint32', offset: 6024, shaderLocation: 8}, |
| {format: 'uint8x4', offset: 2260, shaderLocation: 9}, |
| {format: 'sint8x2', offset: 192, shaderLocation: 19}, |
| ], |
| }, |
| { |
| arrayStride: 0, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'unorm8x2', offset: 8450, shaderLocation: 18}, |
| {format: 'sint32x3', offset: 2044, shaderLocation: 6}, |
| {format: 'unorm10-10-10-2', offset: 8076, shaderLocation: 1}, |
| {format: 'unorm8x2', offset: 12068, shaderLocation: 5}, |
| {format: 'unorm16x2', offset: 396, shaderLocation: 12}, |
| ], |
| }, |
| { |
| arrayStride: 5320, |
| attributes: [ |
| {format: 'sint16x4', offset: 2428, shaderLocation: 15}, |
| {format: 'snorm16x2', offset: 500, shaderLocation: 17}, |
| ], |
| }, |
| ], |
| }, |
| }); |
| document.body.prepend(video4); |
| gc(); |
| let video8 = await videoWithData(); |
| let bindGroup13 = device2.createBindGroup({ |
| label: '\u{1f6b0}\u7bea', |
| layout: bindGroupLayout11, |
| entries: [{binding: 2190, resource: externalTexture18}], |
| }); |
| let texture36 = device2.createTexture({ |
| label: '\ufa98\u604a\u{1ff89}\u{1fc3e}', |
| size: [96], |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'r32uint', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['r32uint', 'r32uint'], |
| }); |
| let textureView53 = texture36.createView({baseArrayLayer: 0}); |
| let renderBundle24 = renderBundleEncoder21.finish(); |
| try { |
| device2.queue.writeTexture({ |
| texture: texture34, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Int8Array(arrayBuffer1), /* required buffer size: 691 */ |
| {offset: 691, rowsPerImage: 87}, {width: 126, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let promise9 = device2.createRenderPipelineAsync({ |
| label: '\u1365\u0c97\u05d5\u026a\u6805', |
| layout: pipelineLayout10, |
| multisample: {mask: 0x8b059df5}, |
| fragment: { |
| module: shaderModule9, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{ |
| format: 'r16float', |
| blend: { |
| color: {operation: 'add', srcFactor: 'one-minus-dst-alpha', dstFactor: 'one'}, |
| alpha: {operation: 'reverse-subtract', srcFactor: 'src-alpha-saturated', dstFactor: 'zero'}, |
| }, |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN, |
| }, {format: 'rg16sint'}], |
| }, |
| vertex: { |
| module: shaderModule9, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 0, |
| attributes: [ |
| {format: 'sint8x4', offset: 2616, shaderLocation: 8}, |
| {format: 'float32x3', offset: 12596, shaderLocation: 5}, |
| {format: 'uint8x4', offset: 5740, shaderLocation: 9}, |
| {format: 'float32', offset: 5728, shaderLocation: 18}, |
| {format: 'snorm16x2', offset: 8528, shaderLocation: 13}, |
| {format: 'sint32x4', offset: 2816, shaderLocation: 7}, |
| ], |
| }, |
| { |
| arrayStride: 356, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'sint16x2', offset: 20, shaderLocation: 15}, |
| {format: 'float32x3', offset: 72, shaderLocation: 1}, |
| {format: 'snorm8x2', offset: 30, shaderLocation: 17}, |
| {format: 'unorm8x2', offset: 112, shaderLocation: 23}, |
| {format: 'sint16x4', offset: 12, shaderLocation: 19}, |
| {format: 'sint16x4', offset: 32, shaderLocation: 6}, |
| ], |
| }, |
| { |
| arrayStride: 15040, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'snorm8x2', offset: 142, shaderLocation: 16}, |
| {format: 'sint32x3', offset: 4932, shaderLocation: 14}, |
| {format: 'float16x4', offset: 3220, shaderLocation: 12}, |
| {format: 'snorm8x4', offset: 668, shaderLocation: 3}, |
| {format: 'uint32x3', offset: 3352, shaderLocation: 4}, |
| {format: 'uint32x4', offset: 724, shaderLocation: 22}, |
| {format: 'float32x2', offset: 356, shaderLocation: 2}, |
| {format: 'float32x4', offset: 6756, shaderLocation: 0}, |
| ], |
| }, |
| { |
| arrayStride: 4384, |
| stepMode: 'instance', |
| attributes: [{format: 'sint32x4', offset: 584, shaderLocation: 10}], |
| }, |
| { |
| arrayStride: 14076, |
| stepMode: 'instance', |
| attributes: [{format: 'float32x2', offset: 144, shaderLocation: 11}], |
| }, |
| {arrayStride: 1196, stepMode: 'vertex', attributes: []}, |
| {arrayStride: 8464, attributes: []}, |
| { |
| arrayStride: 6216, |
| stepMode: 'vertex', |
| attributes: [ |
| {format: 'sint16x4', offset: 2992, shaderLocation: 20}, |
| {format: 'uint8x4', offset: 508, shaderLocation: 21}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-strip', frontFace: 'ccw', cullMode: 'front'}, |
| }); |
| try { |
| gpuCanvasContext6.unconfigure(); |
| } catch {} |
| offscreenCanvas9.width = 454; |
| let offscreenCanvas14 = new OffscreenCanvas(529, 250); |
| let shaderModule10 = device2.createShaderModule({ |
| label: '\u8c1c\u00d1\u2473\u0e9a\u0bb8\u0b1d\u{1f9e8}\u61c2\ub973\u07b9\u7990', |
| code: `@group(1) @binding(2190) |
| var<storage, read_write> n2: array<u32>; |
| @group(0) @binding(2190) |
| var<storage, read_write> function6: array<u32>; |
| @group(2) @binding(2190) |
| var<storage, read_write> function7: array<u32>; |
| |
| @compute @workgroup_size(8, 1, 4) |
| fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {} |
| |
| struct S12 { |
| @location(56) f0: vec3<f32>, |
| @location(14) f1: vec4<i32>, |
| @location(19) f2: vec3<u32>, |
| @location(25) f3: vec4<i32>, |
| @location(53) f4: vec4<u32>, |
| @location(81) f5: vec2<u32>, |
| @builtin(sample_index) f6: u32, |
| @location(52) f7: vec4<u32>, |
| @location(44) f8: vec3<u32>, |
| @location(39) f9: vec4<u32>, |
| @location(68) f10: u32, |
| @location(13) f11: vec3<f16>, |
| @location(88) f12: f32, |
| @builtin(front_facing) f13: bool, |
| @location(74) f14: i32, |
| @location(15) f15: vec2<u32>, |
| @builtin(sample_mask) f16: u32, |
| @location(22) f17: f16, |
| @location(7) f18: vec2<f32>, |
| @location(17) f19: vec2<f32>, |
| @location(86) f20: f16, |
| @location(2) f21: u32, |
| @location(32) f22: vec4<u32>, |
| @location(11) f23: f32, |
| @location(82) f24: vec2<u32>, |
| @location(36) f25: vec2<u32>, |
| @location(64) f26: f16, |
| @location(60) f27: f32, |
| @location(3) f28: u32, |
| @location(61) f29: vec4<u32>, |
| @location(90) f30: f32, |
| @builtin(position) f31: vec4<f32> |
| } |
| struct FragmentOutput0 { |
| @location(0) f0: f32, |
| @location(2) f1: f32, |
| @location(1) f2: vec4<i32> |
| } |
| |
| @fragment |
| fn fragment0(@location(66) a0: vec4<u32>, @location(16) a1: f32, a2: S12) -> FragmentOutput0 { |
| return FragmentOutput0(); |
| } |
| |
| struct S11 { |
| @location(2) f0: i32, |
| @location(9) f1: vec2<i32>, |
| @location(17) f2: vec4<f32>, |
| @location(0) f3: vec3<f32>, |
| @location(6) f4: vec2<f16>, |
| @location(22) f5: vec3<f16>, |
| @location(16) f6: vec4<f16>, |
| @location(14) f7: vec2<f16>, |
| @location(12) f8: vec4<f16>, |
| @location(11) f9: vec4<u32> |
| } |
| struct VertexOutput0 { |
| @location(7) f156: vec2<f32>, |
| @location(16) f157: f32, |
| @location(22) f158: f16, |
| @builtin(position) f159: vec4<f32>, |
| @location(53) f160: vec4<u32>, |
| @location(44) f161: vec3<u32>, |
| @location(17) f162: vec2<f32>, |
| @location(64) f163: f16, |
| @location(36) f164: vec2<u32>, |
| @location(90) f165: f32, |
| @location(3) f166: u32, |
| @location(81) f167: vec2<u32>, |
| @location(56) f168: vec3<f32>, |
| @location(39) f169: vec4<u32>, |
| @location(88) f170: f32, |
| @location(14) f171: vec4<i32>, |
| @location(19) f172: vec3<u32>, |
| @location(86) f173: f16, |
| @location(52) f174: vec4<u32>, |
| @location(2) f175: u32, |
| @location(11) f176: f32, |
| @location(15) f177: vec2<u32>, |
| @location(60) f178: f32, |
| @location(74) f179: i32, |
| @location(32) f180: vec4<u32>, |
| @location(13) f181: vec3<f16>, |
| @location(61) f182: vec4<u32>, |
| @location(82) f183: vec2<u32>, |
| @location(25) f184: vec4<i32>, |
| @location(66) f185: vec4<u32>, |
| @location(68) f186: u32 |
| } |
| |
| @vertex |
| fn vertex0(@location(5) a0: vec3<f32>, @location(23) a1: vec2<f16>, a2: S11, @location(21) a3: vec2<i32>, @location(10) a4: vec3<f16>, @location(7) a5: vec2<f32>, @location(19) a6: vec3<f32>, @builtin(instance_index) a7: u32, @location(20) a8: vec2<i32>, @location(15) a9: vec4<i32>, @location(8) a10: vec3<f16>, @location(4) a11: vec4<i32>, @location(1) a12: f16) -> VertexOutput0 { |
| return VertexOutput0(); |
| } |
| |
| `, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| let bindGroup14 = device2.createBindGroup({ |
| label: '\uf3c8\u2f14\u0de8\u06d4\u31f7\u{1f77a}\u92f1\u0a10\uc52d\uf215', |
| layout: bindGroupLayout13, |
| entries: [], |
| }); |
| let commandEncoder44 = device2.createCommandEncoder({label: '\u3803\u{1fc3d}\u0937'}); |
| let textureView54 = texture35.createView({label: '\u0e36\u00db', baseMipLevel: 10, arrayLayerCount: 1}); |
| let computePassEncoder22 = commandEncoder35.beginComputePass({label: '\u6367\u{1fdbd}\ued83\u0b90\u7305\u{1ffc2}\u057c'}); |
| let renderBundleEncoder22 = device2.createRenderBundleEncoder({ |
| label: '\u4505\uf378\udb71\u00d2\u0143', |
| colorFormats: ['rg32uint', 'rg16uint', 'r32uint', 'r16sint', 'rg32sint', 'rg32sint'], |
| sampleCount: 1, |
| stencilReadOnly: true, |
| }); |
| try { |
| computePassEncoder20.setBindGroup(2, bindGroup13, new Uint32Array(8435), 6428, 0); |
| } catch {} |
| try { |
| renderBundleEncoder22.setBindGroup(5, bindGroup14, new Uint32Array(4119), 3987, 0); |
| } catch {} |
| try { |
| buffer13.destroy(); |
| } catch {} |
| try { |
| device1.queue.label = '\u9b6d\u0517\u405d\u8a80\ub731'; |
| } catch {} |
| gc(); |
| let bindGroup15 = device2.createBindGroup({ |
| label: '\u0940\ud646\u0006\u0ac5\u661c\u7f0f\ue983\u061d\uc6ef', |
| layout: bindGroupLayout11, |
| entries: [{binding: 2190, resource: externalTexture20}], |
| }); |
| let commandEncoder45 = device2.createCommandEncoder({}); |
| let texture37 = device2.createTexture({ |
| label: '\u{1fc59}\uee96\u0919\u2f54\u02bf\ucaad\u0b34\ubed9\u846b\ub5e3\u8738', |
| size: {width: 504}, |
| dimension: '1d', |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['r32uint', 'r32uint'], |
| }); |
| try { |
| computePassEncoder18.setPipeline(pipeline22); |
| } catch {} |
| try { |
| commandEncoder44.copyBufferToTexture({ |
| /* bytesInLastRow: 692 widthInBlocks: 173 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 3260 */ |
| offset: 3260, |
| bytesPerRow: 768, |
| buffer: buffer13, |
| }, { |
| texture: texture37, |
| mipLevel: 0, |
| origin: {x: 31, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 173, height: 0, depthOrArrayLayers: 1}); |
| dissociateBuffer(device2, buffer13); |
| } catch {} |
| try { |
| device2.queue.writeTexture({ |
| texture: texture37, |
| mipLevel: 0, |
| origin: {x: 21, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8ClampedArray(new ArrayBuffer(0)), /* required buffer size: 692 */ |
| {offset: 692, rowsPerImage: 286}, {width: 147, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| video8.width = 128; |
| let commandEncoder46 = device2.createCommandEncoder(); |
| let commandBuffer6 = commandEncoder42.finish({label: '\ub0ec\u5708\u8fe5\ufc92'}); |
| let texture38 = device2.createTexture({ |
| label: '\u{1fdcb}\u5cbc\u08f2\u{1f7a6}\u91e7\u{1fb2d}', |
| size: [252], |
| dimension: '1d', |
| format: 'rg32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rg32sint', 'rg32sint'], |
| }); |
| let textureView55 = texture32.createView({ |
| label: '\udcee\u{1fab9}\ud933\u04de\u0903\u008a\u{1f79d}\u{1f65a}\u610a\ude5e\u{1f897}', |
| dimension: '2d', |
| aspect: 'depth-only', |
| baseMipLevel: 4, |
| baseArrayLayer: 319, |
| }); |
| let renderBundleEncoder23 = device2.createRenderBundleEncoder({ |
| colorFormats: ['rg32uint', 'rg16uint', 'r32uint', 'r16sint', 'rg32sint', 'rg32sint'], |
| depthReadOnly: true, |
| stencilReadOnly: true, |
| }); |
| try { |
| computePassEncoder17.setBindGroup(0, bindGroup12); |
| } catch {} |
| try { |
| renderBundleEncoder22.setBindGroup(3, bindGroup15); |
| } catch {} |
| try { |
| renderBundleEncoder23.setVertexBuffer(1598, undefined, 0, 2498043206); |
| } catch {} |
| try { |
| buffer13.unmap(); |
| } catch {} |
| let bindGroupLayout15 = device2.createBindGroupLayout({ |
| label: '\u{1fc74}\u{1f76e}\u0712\u{1f751}\u{1fc06}\u6664\u787b\u1e26\uf395\u674b', |
| entries: [{binding: 4823, visibility: 0, sampler: { type: 'comparison' }}], |
| }); |
| let bindGroup16 = device2.createBindGroup({ |
| label: '\u8255\u0bf0\uff0f\u05d5\u058f\u507c\u{1fb1b}\u{1fe47}\u0ea5\u{1f82e}\u0868', |
| layout: bindGroupLayout13, |
| entries: [], |
| }); |
| let querySet20 = device2.createQuerySet({type: 'occlusion', count: 1126}); |
| let textureView56 = texture37.createView({label: '\u9340\u2cdd\u00a9\ue2c3'}); |
| let externalTexture22 = device2.importExternalTexture({label: '\ue23c\ua54f\u42d3\u4c6a', source: video5}); |
| try { |
| renderBundleEncoder22.setBindGroup(2, bindGroup15, new Uint32Array(8814), 349, 0); |
| } catch {} |
| let pipeline32 = await device2.createComputePipelineAsync({layout: pipelineLayout10, compute: {module: shaderModule10, entryPoint: 'compute0', constants: {}}}); |
| let img9 = await imageWithData(187, 22, '#f8c07a94', '#11fb575f'); |
| let imageBitmap8 = await createImageBitmap(canvas10); |
| let gpuCanvasContext15 = offscreenCanvas14.getContext('webgpu'); |
| document.body.prepend(img7); |
| let img10 = await imageWithData(72, 17, '#6614d901', '#0f7260de'); |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| try { |
| gpuCanvasContext2.unconfigure(); |
| } catch {} |
| let promise10 = adapter0.requestAdapterInfo(); |
| try { |
| window.someLabel = texture19.label; |
| } catch {} |
| canvas6.height = 655; |
| try { |
| externalTexture1.label = '\u9b37\u{1ff1e}\u{1fe16}\u707b\u342b\ucc6b\u{1fb17}\uadb0\u{1f7c9}\u{1f780}\u{1f85c}'; |
| } catch {} |
| try { |
| await promise10; |
| } catch {} |
| let canvas16 = document.createElement('canvas'); |
| let commandEncoder47 = device2.createCommandEncoder({label: '\u01db\ue039\u5e94\ud19e\u0233'}); |
| let textureView57 = texture36.createView({ |
| label: '\u0624\u5739\ue660\u017d\u{1fae8}\ud9a9\ua0ee\u{1f9c5}\u4739\u8718', |
| dimension: '1d', |
| arrayLayerCount: 1, |
| }); |
| let offscreenCanvas15 = new OffscreenCanvas(659, 941); |
| let textureView58 = texture36.createView({label: '\u019f\u3f8a\uf64a\u7b39'}); |
| try { |
| commandEncoder46.clearBuffer(buffer13, 21008, 168052); |
| dissociateBuffer(device2, buffer13); |
| } catch {} |
| try { |
| await device2.queue.onSubmittedWorkDone(); |
| } catch {} |
| let pipeline33 = await promise9; |
| let offscreenCanvas16 = new OffscreenCanvas(822, 138); |
| try { |
| adapter3.label = '\ucb2d\u31f1\u{1febc}'; |
| } catch {} |
| let textureView59 = texture36.createView({label: '\ua201\u5fb6\ud7f2\uf47e\u014f'}); |
| let renderBundleEncoder24 = device2.createRenderBundleEncoder({ |
| label: '\u215a\ue63f\u4c91', |
| colorFormats: ['r16float', 'rg16sint'], |
| depthReadOnly: true, |
| stencilReadOnly: false, |
| }); |
| try { |
| renderBundleEncoder23.setBindGroup(5, bindGroup14, []); |
| } catch {} |
| try { |
| renderBundleEncoder23.setBindGroup(7, bindGroup15, new Uint32Array(8667), 6211, 0); |
| } catch {} |
| try { |
| buffer13.unmap(); |
| } catch {} |
| video7.width = 46; |
| let commandEncoder48 = device2.createCommandEncoder({label: '\uf081\u{1fb48}\u9cc2\u953c\u2be9\ua4cd\udc0b\ue727'}); |
| let renderBundle25 = renderBundleEncoder23.finish({label: '\ue215\u{1fade}\u0bbb\uc9fa\u7a4f\u7736\ubb3e\u566d\u7fc8\u6e6a'}); |
| let externalTexture23 = device2.importExternalTexture({label: '\u0cdb\u0a6b\u0945\u{1f6af}\u{1feee}', source: videoFrame7, colorSpace: 'srgb'}); |
| try { |
| computePassEncoder19.setBindGroup(7, bindGroup16, new Uint32Array(1206), 210, 0); |
| } catch {} |
| try { |
| renderBundleEncoder24.setBindGroup(0, bindGroup14); |
| } catch {} |
| try { |
| gpuCanvasContext10.configure({ |
| device: device2, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| let commandEncoder49 = device2.createCommandEncoder(); |
| let textureView60 = texture35.createView({ |
| label: '\u0ee4\u00b9\u4b23\u9334\ub3e0\u04bc\u3021\u0b71\ubeab\u97ac\uef32', |
| baseMipLevel: 2, |
| mipLevelCount: 6, |
| }); |
| let externalTexture24 = device2.importExternalTexture({source: video4, colorSpace: 'srgb'}); |
| try { |
| renderBundleEncoder22.setBindGroup(4, bindGroup16, new Uint32Array(1990), 1774, 0); |
| } catch {} |
| try { |
| buffer13.unmap(); |
| } catch {} |
| try { |
| commandEncoder48.insertDebugMarker('\u6fcf'); |
| } catch {} |
| try { |
| gpuCanvasContext15.configure({ |
| device: device2, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: ['rgba16float'], |
| colorSpace: 'display-p3', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let pipeline34 = await device2.createComputePipelineAsync({layout: pipelineLayout10, compute: {module: shaderModule10, entryPoint: 'compute0'}}); |
| let canvas17 = document.createElement('canvas'); |
| gc(); |
| let querySet21 = device2.createQuerySet({ |
| label: '\u{1f98f}\u0017\u{1f8e7}\u{1fa68}\u00a6\u{1fdb5}\u{1fc5f}\u8ad2\u{1fdca}\u082f', |
| type: 'occlusion', |
| count: 2874, |
| }); |
| let sampler10 = device2.createSampler({ |
| label: '\uf76e\ubf01\u9026\u8ba8\u0844\u46e7', |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 54.63, |
| maxAnisotropy: 12, |
| }); |
| try { |
| commandEncoder46.clearBuffer(buffer13, 229436, 16788); |
| dissociateBuffer(device2, buffer13); |
| } catch {} |
| canvas16.width = 3084; |
| let offscreenCanvas17 = new OffscreenCanvas(896, 143); |
| try { |
| adapter0.label = '\u0fbb\u476b\u6246\u1208\u21a7\u{1f8f8}\u228a\u{1fe8f}\u07fe\u{1f6d1}'; |
| } catch {} |
| let videoFrame11 = new VideoFrame(imageBitmap7, {timestamp: 0}); |
| let commandEncoder50 = device2.createCommandEncoder({label: '\u{1fd0e}\u0e97\ud8f7\uc228\uc4f5\ub206'}); |
| let textureView61 = texture35.createView({label: '\u2d9f\u5411\udf1c\u{1f60d}\u0336\u1dca', baseArrayLayer: 0}); |
| try { |
| commandEncoder48.clearBuffer(buffer13, 206032, 53272); |
| dissociateBuffer(device2, buffer13); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device2, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: ['rgba8unorm-srgb', 'rgba8unorm'], |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| canvas1.height = 246; |
| try { |
| canvas17.getContext('2d'); |
| } catch {} |
| try { |
| offscreenCanvas17.getContext('bitmaprenderer'); |
| } catch {} |
| let imageBitmap9 = await createImageBitmap(imageBitmap2); |
| offscreenCanvas9.width = 634; |
| let bindGroupLayout16 = device2.createBindGroupLayout({ |
| label: '\u0358\u7110\u0435\u07a7\u0df3\ud9c1\ub8be', |
| entries: [ |
| {binding: 4625, visibility: 0, externalTexture: {}}, |
| {binding: 3086, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, externalTexture: {}}, |
| ], |
| }); |
| let bindGroup17 = device2.createBindGroup({label: '\u09a0\u{1f9aa}\u079a\u03ea\u{1f86e}\u076a', layout: bindGroupLayout13, entries: []}); |
| let texture39 = device2.createTexture({ |
| label: '\uc40c\uc300\u4755\udb55\u0155\u4e96\u037e', |
| size: [504, 1, 1], |
| mipLevelCount: 6, |
| format: 'r16float', |
| usage: GPUTextureUsage.COPY_SRC, |
| viewFormats: ['r16float', 'r16float', 'r16float'], |
| }); |
| let sampler11 = device2.createSampler({ |
| label: '\ue244\u{1f8ab}\u{1ffb0}\ua0a6', |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| lodMinClamp: 64.50, |
| lodMaxClamp: 86.24, |
| }); |
| try { |
| computePassEncoder22.setBindGroup(5, bindGroup16, new Uint32Array(3580), 2328, 0); |
| } catch {} |
| try { |
| buffer13.unmap(); |
| } catch {} |
| let commandEncoder51 = device2.createCommandEncoder({label: '\u7cb0\u0c13\u77a9\u6029'}); |
| let commandBuffer7 = commandEncoder45.finish({}); |
| let renderBundle26 = renderBundleEncoder20.finish(); |
| let promise11 = device2.queue.onSubmittedWorkDone(); |
| let commandEncoder52 = device2.createCommandEncoder({label: '\u2ec7\u06ac\u1c8e'}); |
| let textureView62 = texture37.createView({label: '\u{1fe0f}\u591a\u{1f685}\u{1fc65}\u0231\u0c9a'}); |
| let video9 = await videoWithData(); |
| try { |
| offscreenCanvas15.getContext('webgl2'); |
| } catch {} |
| document.body.prepend(img4); |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55) }; |
| } catch {} |
| gc(); |
| let shaderModule11 = device2.createShaderModule({ |
| code: `@group(2) @binding(2190) |
| var<storage, read_write> local3: array<u32>; |
| @group(0) @binding(2190) |
| var<storage, read_write> field4: array<u32>; |
| @group(1) @binding(2190) |
| var<storage, read_write> local4: array<u32>; |
| |
| @compute @workgroup_size(3, 2, 1) |
| fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {} |
| |
| struct FragmentOutput0 { |
| @location(3) f0: vec2<i32>, |
| @location(5) f1: vec4<i32>, |
| @location(4) f2: vec3<i32>, |
| @location(0) f3: vec3<u32>, |
| @location(1) f4: vec3<u32>, |
| @location(2) f5: u32 |
| } |
| |
| @fragment |
| fn fragment0(@builtin(sample_mask) a0: u32, @builtin(sample_index) a1: u32) -> FragmentOutput0 { |
| return FragmentOutput0(); |
| } |
| |
| struct S13 { |
| @location(12) f0: vec4<f16>, |
| @location(22) f1: vec4<i32>, |
| @location(21) f2: i32, |
| @location(3) f3: vec3<i32>, |
| @location(13) f4: vec3<i32>, |
| @builtin(vertex_index) f5: u32, |
| @location(17) f6: vec2<f32>, |
| @location(19) f7: vec3<i32>, |
| @location(6) f8: vec3<f32>, |
| @location(10) f9: vec3<f32>, |
| @location(9) f10: f32, |
| @location(5) f11: vec4<i32> |
| } |
| |
| @vertex |
| fn vertex0(@location(8) a0: vec2<u32>, @location(1) a1: vec3<i32>, @location(23) a2: f32, @location(4) a3: u32, @location(15) a4: vec4<f16>, @location(11) a5: vec4<u32>, @location(14) a6: vec3<i32>, @location(16) a7: vec3<u32>, a8: S13, @location(2) a9: vec3<i32>, @builtin(instance_index) a10: u32, @location(20) a11: vec2<f32>, @location(18) a12: vec3<i32>, @location(0) a13: f32) -> @builtin(position) vec4<f32> { |
| return vec4<f32>(0.0, 0.0, 0.0, 1.0); |
| } |
| |
| `, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| let commandEncoder53 = device2.createCommandEncoder({label: '\u0415\ub6d6\u1422\u038a\u{1fec2}'}); |
| let texture40 = device2.createTexture({ |
| size: {width: 192, height: 24, depthOrArrayLayers: 1}, |
| mipLevelCount: 7, |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['r16sint'], |
| }); |
| let textureView63 = texture37.createView({ |
| label: '\u0f88\u026a\u8d19\u061f\u{1ff7f}\uf586\u{1faaf}\u0301\u0f08', |
| format: 'r32uint', |
| mipLevelCount: 1, |
| }); |
| let sampler12 = device2.createSampler({ |
| label: '\u8c36\u6fae\u05bc\u{1ff53}\u01f7\u{1fc7a}', |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 15.57, |
| lodMaxClamp: 16.70, |
| maxAnisotropy: 3, |
| }); |
| try { |
| commandEncoder49.copyTextureToBuffer({ |
| texture: texture35, |
| mipLevel: 8, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 171324 */ |
| offset: 1084, |
| bytesPerRow: 256, |
| rowsPerImage: 133, |
| buffer: buffer13, |
| }, {width: 1, height: 0, depthOrArrayLayers: 6}); |
| dissociateBuffer(device2, buffer13); |
| } catch {} |
| try { |
| commandEncoder46.clearBuffer(buffer13, 1884, 256056); |
| dissociateBuffer(device2, buffer13); |
| } catch {} |
| let pipeline35 = device2.createComputePipeline({ |
| label: '\uab00\u{1ff9b}\u{1f880}\u23f1\uc433\u{1fde3}\u0400\u0b45', |
| layout: pipelineLayout10, |
| compute: {module: shaderModule11, entryPoint: 'compute0'}, |
| }); |
| let pipeline36 = await device2.createRenderPipelineAsync({ |
| layout: pipelineLayout10, |
| fragment: { |
| module: shaderModule9, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{ |
| format: 'r16float', |
| blend: { |
| color: {operation: 'reverse-subtract', srcFactor: 'constant', dstFactor: 'one-minus-dst'}, |
| alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'}, |
| }, |
| writeMask: GPUColorWrite.BLUE, |
| }, {format: 'rg16sint', writeMask: GPUColorWrite.ALPHA}], |
| }, |
| depthStencil: { |
| format: 'depth24plus-stencil8', |
| depthWriteEnabled: false, |
| depthCompare: 'not-equal', |
| stencilFront: {compare: 'greater', failOp: 'increment-wrap', depthFailOp: 'decrement-clamp'}, |
| stencilBack: {compare: 'equal', failOp: 'decrement-wrap', depthFailOp: 'increment-clamp', passOp: 'decrement-clamp'}, |
| stencilReadMask: 442508420, |
| stencilWriteMask: 3801116839, |
| depthBias: -1885621641, |
| depthBiasSlopeScale: 271.4811071908712, |
| }, |
| vertex: { |
| module: shaderModule9, |
| entryPoint: 'vertex0', |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 3832, |
| attributes: [ |
| {format: 'sint32x4', offset: 2752, shaderLocation: 10}, |
| {format: 'float32x3', offset: 428, shaderLocation: 23}, |
| {format: 'sint16x2', offset: 1356, shaderLocation: 7}, |
| ], |
| }, |
| { |
| arrayStride: 3764, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'unorm8x4', offset: 96, shaderLocation: 2}, |
| {format: 'sint32', offset: 644, shaderLocation: 8}, |
| {format: 'snorm16x4', offset: 312, shaderLocation: 0}, |
| {format: 'float16x2', offset: 604, shaderLocation: 13}, |
| {format: 'float16x2', offset: 924, shaderLocation: 1}, |
| ], |
| }, |
| { |
| arrayStride: 5880, |
| attributes: [ |
| {format: 'sint32x4', offset: 3200, shaderLocation: 6}, |
| {format: 'sint16x4', offset: 1340, shaderLocation: 19}, |
| {format: 'sint32x4', offset: 788, shaderLocation: 20}, |
| {format: 'snorm8x2', offset: 424, shaderLocation: 3}, |
| {format: 'sint8x4', offset: 420, shaderLocation: 15}, |
| {format: 'float32', offset: 48, shaderLocation: 18}, |
| {format: 'uint32x3', offset: 1400, shaderLocation: 9}, |
| {format: 'uint32x4', offset: 268, shaderLocation: 4}, |
| {format: 'sint32x4', offset: 192, shaderLocation: 14}, |
| {format: 'float32x2', offset: 320, shaderLocation: 11}, |
| {format: 'snorm16x4', offset: 596, shaderLocation: 17}, |
| {format: 'uint16x2', offset: 1792, shaderLocation: 21}, |
| {format: 'float32x2', offset: 408, shaderLocation: 16}, |
| {format: 'snorm8x2', offset: 918, shaderLocation: 5}, |
| ], |
| }, |
| { |
| arrayStride: 4788, |
| attributes: [ |
| {format: 'uint8x2', offset: 216, shaderLocation: 22}, |
| {format: 'unorm16x4', offset: 1244, shaderLocation: 12}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint32', frontFace: 'cw', cullMode: 'front'}, |
| }); |
| let bindGroupLayout17 = device2.createBindGroupLayout({ |
| label: '\u5475\uf7c8\u58d8\ub999\u{1f6d1}\ub00c\u{1ff97}\u9381\ue2de', |
| entries: [{binding: 1686, visibility: GPUShaderStage.VERTEX, externalTexture: {}}], |
| }); |
| let computePassEncoder23 = commandEncoder44.beginComputePass({label: '\u177c\u39d7\u0475'}); |
| let externalTexture25 = device2.importExternalTexture({label: '\u{1fae3}\u8fe8\u04d6\u{1f9ca}\udcf8\u{1f6f6}\u0733', source: video7}); |
| try { |
| commandEncoder48.copyBufferToTexture({ |
| /* bytesInLastRow: 32 widthInBlocks: 16 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 11044 */ |
| offset: 9732, |
| bytesPerRow: 256, |
| buffer: buffer13, |
| }, { |
| texture: texture40, |
| mipLevel: 1, |
| origin: {x: 12, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 16, height: 6, depthOrArrayLayers: 1}); |
| dissociateBuffer(device2, buffer13); |
| } catch {} |
| try { |
| device2.destroy(); |
| } catch {} |
| try { |
| offscreenCanvas16.getContext('2d'); |
| } catch {} |
| let gpuCanvasContext16 = canvas16.getContext('webgpu'); |
| try { |
| await promise11; |
| } catch {} |
| let img11 = await imageWithData(59, 234, '#09e0ce97', '#9e4810a8'); |
| let imageBitmap10 = await createImageBitmap(canvas4); |
| let img12 = await imageWithData(281, 286, '#58f635cf', '#b9c82a71'); |
| let video10 = await videoWithData(); |
| let img13 = await imageWithData(266, 195, '#fcb88ddb', '#f6faa3e1'); |
| try { |
| if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55) }; |
| } catch {} |
| video0.width = 98; |
| let video11 = await videoWithData(); |
| let imageBitmap11 = await createImageBitmap(canvas11); |
| let videoFrame12 = new VideoFrame(offscreenCanvas7, {timestamp: 0}); |
| video8.width = 285; |
| let offscreenCanvas18 = new OffscreenCanvas(340, 379); |
| let gpuCanvasContext17 = offscreenCanvas18.getContext('webgpu'); |
| try { |
| gpuCanvasContext3.unconfigure(); |
| } catch {} |
| let imageData11 = new ImageData(196, 252); |
| let videoFrame13 = new VideoFrame(img4, {timestamp: 0}); |
| try { |
| gpuCanvasContext2.unconfigure(); |
| } catch {} |
| document.body.prepend(canvas0); |
| document.body.prepend(video10); |
| let offscreenCanvas19 = new OffscreenCanvas(959, 955); |
| try { |
| renderBundleEncoder10.label = '\u03bd\u4940'; |
| } catch {} |
| gc(); |
| let device3 = await adapter2.requestDevice({ |
| label: '\u49f2\u{1f6f2}\u03e5\u0c03\u032b\u2a42\u0c2a\u8da4\ue2b9\u663a', |
| defaultQueue: {label: '\ue805\u3091\uebcb\u0f55\u4fb2\uea18'}, |
| requiredFeatures: [ |
| 'depth-clip-control', |
| 'texture-compression-etc2', |
| 'texture-compression-astc', |
| 'indirect-first-instance', |
| 'shader-f16', |
| 'bgra8unorm-storage', |
| ], |
| requiredLimits: { |
| maxBindGroups: 6, |
| maxColorAttachmentBytesPerSample: 42, |
| maxVertexAttributes: 22, |
| maxVertexBufferArrayStride: 35503, |
| maxStorageTexturesPerShaderStage: 32, |
| maxStorageBuffersPerShaderStage: 13, |
| maxDynamicStorageBuffersPerPipelineLayout: 42644, |
| maxDynamicUniformBuffersPerPipelineLayout: 60338, |
| maxBindingsPerBindGroup: 9709, |
| maxTextureArrayLayers: 807, |
| maxTextureDimension1D: 13384, |
| maxTextureDimension2D: 13337, |
| maxVertexBuffers: 11, |
| maxBindGroupsPlusVertexBuffers: 29, |
| minStorageBufferOffsetAlignment: 128, |
| maxUniformBufferBindingSize: 167514248, |
| maxStorageBufferBindingSize: 186160228, |
| maxUniformBuffersPerShaderStage: 14, |
| maxSampledTexturesPerShaderStage: 16, |
| maxInterStageShaderVariables: 39, |
| maxInterStageShaderComponents: 103, |
| maxSamplersPerShaderStage: 21, |
| }, |
| }); |
| video6.width = 282; |
| let commandEncoder54 = device3.createCommandEncoder({label: '\u5985\u0c69\u{1f7a4}\u6222\u{1fe6c}'}); |
| let texture41 = device3.createTexture({ |
| label: '\u6d45\u{1fa0b}\u2a3b\u0b97\u7dba', |
| size: [288, 32, 502], |
| mipLevelCount: 3, |
| format: 'r16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['r16float', 'r16float'], |
| }); |
| try { |
| gpuCanvasContext11.configure({ |
| device: device3, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC, |
| viewFormats: ['rgba16float', 'rgba16float', 'rgba16float', 'rgba16float'], |
| colorSpace: 'display-p3', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device3.queue.writeTexture({ |
| texture: texture41, |
| mipLevel: 2, |
| origin: {x: 9, y: 5, z: 1}, |
| aspect: 'all', |
| }, arrayBuffer1, /* required buffer size: 1_544_134 */ |
| {offset: 796, bytesPerRow: 192, rowsPerImage: 57}, {width: 21, height: 2, depthOrArrayLayers: 142}); |
| } catch {} |
| videoFrame0.close(); |
| videoFrame1.close(); |
| videoFrame2.close(); |
| videoFrame3.close(); |
| videoFrame4.close(); |
| videoFrame5.close(); |
| videoFrame6.close(); |
| videoFrame7.close(); |
| videoFrame8.close(); |
| videoFrame9.close(); |
| videoFrame10.close(); |
| videoFrame11.close(); |
| videoFrame12.close(); |
| videoFrame13.close(); |
| log('the end') |
| log(location); |
| } catch (e) { |
| log('error'); |
| log(e); |
| log(e[Symbol.toStringTag]); |
| log(e.stack); |
| if (e instanceof GPUPipelineError) { |
| log(`${e} - ${e.reason}`); |
| |
| } else if (e instanceof DOMException) { |
| if (e.name === 'OperationError') { |
| log(e.message); |
| |
| } else if (e.name === 'InvalidStateError') { |
| } else { |
| log(e); |
| |
| } |
| } else if (e instanceof GPUValidationError) { |
| |
| } else if (e instanceof GPUOutOfMemoryError) { |
| |
| } else if (e instanceof TypeError) { |
| log(e); |
| |
| } else { |
| log('unexpected error type'); |
| log(e); |
| |
| } |
| } |
| debug('Pass') |
| globalThis.testRunner?.notifyDone(); |
| }; |
| </script> |
| |
