| <!-- webkit-test-runner [ enableMetalShaderValidation=true ] --> |
| <style> |
| :root { background: #102030e0; color: #99ddbbcc; font-size: 15px; } |
| </style> |
| <script src="../../../resources/js-test-pre.js"></script> |
| <script> |
| globalThis.testRunner?.dumpAsText(); |
| globalThis.testRunner?.waitUntilDone(); |
| |
| const log = globalThis.$vm?.print ?? console.log; |
| |
| function gc() { |
| if (globalThis.GCController) { |
| globalThis.GCController.collect(); |
| } else if (globalThis.$vm) { |
| globalThis.$vm.gc(); |
| } else { |
| log('no GC available'); |
| } |
| } |
| |
| /** |
| * @param {GPUDevice} device |
| * @param {GPUCommandEncoder} commandEncoder |
| */ |
| function pseudoSubmit(device, commandEncoder) { |
| device.pushErrorScope('validation'); |
| commandEncoder.clearBuffer(device.createBuffer({size: 0, usage: 0}), 0, 0); |
| device.popErrorScope().then(() => {}); |
| } |
| |
| /** |
| * @param {GPUDevice} device |
| * @param {GPUBuffer} buffer |
| */ |
| function dissociateBuffer(device, buffer) { |
| let commandEncoder = device.createCommandEncoder(); |
| if (buffer.usage & GPUBufferUsage.COPY_DST) { |
| let writeBuffer = device.createBuffer({size: 16, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| commandEncoder.copyBufferToBuffer(writeBuffer, 0, buffer, 0, 0); |
| } else if (buffer.usage & GPUBufferUsage.COPY_SRC) { |
| let readBuffer = device.createBuffer({size: 16, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| commandEncoder.copyBufferToBuffer(buffer, 0, readBuffer, 0, 0); |
| } |
| } |
| |
| /** |
| * @template {any} T |
| * @param {GPUDevice} device |
| * @param {string} label |
| * @param {()=>T} payload |
| * @returns {Promise<T>} |
| */ |
| async function validationWrapper(device, label, payload) { |
| device.pushErrorScope('internal'); |
| device.pushErrorScope('out-of-memory'); |
| device.pushErrorScope('validation'); |
| let result = payload(); |
| let validationError = await device.popErrorScope(); |
| let outOfMemoryError = await device.popErrorScope(); |
| let internalError = await device.popErrorScope(); |
| let error = validationError ?? outOfMemoryError ?? internalError; |
| if (error) { |
| log('*'.repeat(25)); |
| log(error[Symbol.toStringTag]); |
| log(error.message); |
| log(label); |
| if (error.stack != `_`) { |
| log(error.stack); |
| } |
| log(location); |
| log('*'.repeat(25)); |
| throw error; |
| } |
| return result; |
| } |
| |
| /** |
| * @returns {Promise<HTMLVideoElement>} |
| */ |
| function videoWithData() { |
| const veryBrightVideo = `data:video/mp4;base64,AAAAHGZ0eXBpc29tAAACAGlzb21pc28ybXA0MQAAAAhmcmVlAAAAvG1kYXQAAAAfTgEFGkdWStxcTEM/lO/FETzRQ6gD7gAA7gIAA3EYgAAAAEgoAa8iNjAkszOL+e58c//cEe//0TT//scp1n/381P/RWP/zOW4QtxorfVogeh8nQDbQAAAAwAQMCcWUTAAAAMAAAMAAAMA84AAAAAVAgHQAyu+KT35E7gAADFgAAADABLQAAAAEgIB4AiS76MTkNbgAAF3AAAPSAAAABICAeAEn8+hBOTXYAADUgAAHRAAAAPibW9vdgAAAGxtdmhkAAAAAAAAAAAAAAAAAAAD6AAAAKcAAQAAAQAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAw10cmFrAAAAXHRraGQAAAADAAAAAAAAAAAAAAABAAAAAAAAAKcAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAABAAAAAABAAAAAQAAAAAAAkZWR0cwAAABxlbHN0AAAAAAAAAAEAAACnAAAAAAABAAAAAAKFbWRpYQAAACBtZGhkAAAAAAAAAAAAAAAAAABdwAAAD6BVxAAAAAAAMWhkbHIAAAAAAAAAAHZpZGUAAAAAAAAAAAAAAABDb3JlIE1lZGlhIFZpZGVvAAAAAixtaW5mAAAAFHZtaGQAAAABAAAAAAAAAAAAAAAkZGluZgAAABxkcmVmAAAAAAAAAAEAAAAMdXJsIAAAAAEAAAHsc3RibAAAARxzdHNkAAAAAAAAAAEAAAEMaHZjMQAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAQABAASAAAAEgAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABj//wAAAHVodmNDAQIgAAAAsAAAAAAAPPAA/P36+gAACwOgAAEAGEABDAH//wIgAAADALAAAAMAAAMAPBXAkKEAAQAmQgEBAiAAAAMAsAAAAwAAAwA8oBQgQcCTDLYgV7kWVYC1CRAJAICiAAEACUQBwChkuNBTJAAAAApmaWVsAQAAAAATY29scm5jbHgACQAQAAkAAAAAEHBhc3AAAAABAAAAAQAAABRidHJ0AAAAAAAALPwAACz8AAAAKHN0dHMAAAAAAAAAAwAAAAIAAAPoAAAAAQAAAAEAAAABAAAD6AAAABRzdHNzAAAAAAAAAAEAAAABAAAAEHNkdHAAAAAAIBAQGAAAAChjdHRzAAAAAAAAAAMAAAABAAAAAAAAAAEAAAfQAAAAAgAAAAAAAAAcc3RzYwAAAAAAAAABAAAAAQAAAAQAAAABAAAAJHN0c3oAAAAAAAAAAAAAAAQAAABvAAAAGQAAABYAAAAWAAAAFHN0Y28AAAAAAAAAAQAAACwAAABhdWR0YQAAAFltZXRhAAAAAAAAACFoZGxyAAAAAAAAAABtZGlyYXBwbAAAAAAAAAAAAAAAACxpbHN0AAAAJKl0b28AAAAcZGF0YQAAAAEAAAAATGF2ZjYwLjMuMTAw`; |
| let video = document.createElement('video'); |
| video.src = veryBrightVideo; |
| return new Promise(resolve => { |
| video.onloadeddata = () => { |
| resolve(video); |
| }; |
| }); |
| } |
| |
| /** |
| * @returns {Promise<string>} |
| */ |
| async function makeDataUrl(width, height, color0, color1) { |
| let offscreenCanvas = new OffscreenCanvas(width, height); |
| let ctx = offscreenCanvas.getContext('2d'); |
| let gradient = ctx.createLinearGradient(0, 0, width, height); |
| gradient.addColorStop(0, color0); |
| gradient.addColorStop(0.1, color1); |
| gradient.addColorStop(0.3, color0); |
| gradient.addColorStop(0.7, color1); |
| gradient.addColorStop(0.9, color0); |
| gradient.addColorStop(1, color1); |
| ctx.fillStyle = gradient; |
| ctx.fillRect(0, 0, width, height); |
| let blob = await offscreenCanvas.convertToBlob(); |
| let fileReader = new FileReader(); |
| fileReader.readAsDataURL(blob); |
| return new Promise(resolve => { |
| fileReader.onload = () => { |
| resolve(fileReader.result); |
| }; |
| }); |
| } |
| |
| async function imageWithData(width, height, color0, color1) { |
| let dataUrl = await makeDataUrl(width, height, color0, color1); |
| let img = document.createElement('img'); |
| img.src = dataUrl; |
| await img.decode(); |
| return img; |
| } |
| |
| onload = async () => { |
| try { |
| let promise0 = navigator.gpu.requestAdapter({ |
| }); |
| let promise1 = navigator.gpu.requestAdapter({ |
| }); |
| let adapter0 = await navigator.gpu.requestAdapter(); |
| let promise2 = adapter0.requestDevice({ |
| label: '\ue183\u0dbc\ud3d3\ub238\u{1fe0a}\u0e99\u01f7', |
| requiredFeatures: [ |
| 'depth-clip-control', |
| 'depth32float-stencil8', |
| 'texture-compression-astc', |
| 'indirect-first-instance', |
| 'shader-f16', |
| 'rg11b10ufloat-renderable' |
| ], |
| requiredLimits: { |
| maxBindGroups: 7, |
| maxColorAttachmentBytesPerSample: 55, |
| maxVertexBufferArrayStride: 17024, |
| maxStorageTexturesPerShaderStage: 43, |
| maxStorageBuffersPerShaderStage: 10, |
| maxDynamicStorageBuffersPerPipelineLayout: 8762, |
| maxBindingsPerBindGroup: 5530, |
| maxTextureDimension1D: 12687, |
| maxTextureDimension2D: 11464, |
| minUniformBufferOffsetAlignment: 32, |
| maxUniformBufferBindingSize: 211056528, |
| maxUniformBuffersPerShaderStage: 35, |
| maxInterStageShaderVariables: 111, |
| maxInterStageShaderComponents: 63, |
| maxSamplersPerShaderStage: 19, |
| }, |
| }); |
| let adapter1 = await navigator.gpu.requestAdapter({ |
| }); |
| let device0 = await promise2; |
| let querySet0 = device0.createQuerySet({ |
| label: '\u8735\u{1f69a}\u94af\u{1fca3}\u03fc\u8db0\u62de\u0a8d\uaa23\u0844\u0310', |
| type: 'occlusion', |
| count: 3183, |
| }); |
| let texture0 = device0.createTexture({ |
| label: '\u989e\u9d22\u05b3\u{1fdbb}\u1e2e\u3448\u{1ff41}\u4ab0\u{1f7f7}\u8fe2', |
| size: {width: 4704, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 5, |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler0 = device0.createSampler({ |
| label: '\uf806\u04e9\uf354', |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 40.036, |
| lodMaxClamp: 53.113, |
| maxAnisotropy: 10, |
| }); |
| let sampler1 = device0.createSampler({ |
| label: '\u671e\u00eb\u{1f9f2}\u0c0e\u6658\u9906\ue37c\u64fe\u8fdf\u01a0\u061d', |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 49.134, |
| lodMaxClamp: 74.836, |
| maxAnisotropy: 4, |
| }); |
| let sampler2 = device0.createSampler({ |
| label: '\u0011\ubfeb\uf8c0\u{1fddb}\u0851\u1ac3\ud4ca\u8c70\ubc96', |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| lodMinClamp: 38.058, |
| lodMaxClamp: 66.042, |
| }); |
| let querySet1 = device0.createQuerySet({ |
| type: 'occlusion', |
| count: 1276, |
| }); |
| let sampler3 = device0.createSampler({ |
| label: '\u8328\u06e8', |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| lodMinClamp: 25.027, |
| lodMaxClamp: 60.615, |
| }); |
| let commandEncoder0 = device0.createCommandEncoder({label: '\u0b3b\u5247\u{1fdf8}\u78d0\u42bc\u{1fef1}\u{1ff01}\ub0d4'}); |
| let commandBuffer0 = commandEncoder0.finish({ |
| label: '\ufd3c\uf439\u0537\u072a\u548e\u0266\ude19\u0aaf\u0f40\u048e', |
| }); |
| let promise3 = device0.queue.onSubmittedWorkDone(); |
| let textureView0 = texture0.createView({label: '\u{1f9b5}\u0e99\uf0b0\u0330\u07ae\u534c\u0c3c\ub207\u733b', mipLevelCount: 2}); |
| try { |
| await promise3; |
| } catch {} |
| let canvas0 = document.createElement('canvas'); |
| let imageData0 = new ImageData(80, 56); |
| let commandEncoder1 = device0.createCommandEncoder({}); |
| try { |
| commandEncoder1.insertDebugMarker('\ue180'); |
| } catch {} |
| let imageBitmap0 = await createImageBitmap(imageData0); |
| let querySet2 = device0.createQuerySet({ |
| type: 'occlusion', |
| count: 2279, |
| }); |
| let imageBitmap1 = await createImageBitmap(imageData0); |
| let textureView1 = texture0.createView({}); |
| try { |
| commandEncoder1.pushDebugGroup('\u1a5f'); |
| } catch {} |
| let imageBitmap2 = await createImageBitmap(imageBitmap0); |
| try { |
| window.someLabel = sampler0.label; |
| } catch {} |
| let texture1 = device0.createTexture({ |
| label: '\u031d\u09b0\u1dae\uc8f0\ud583\uf9cf\u25a7\u1477', |
| size: {width: 4544}, |
| sampleCount: 1, |
| dimension: '1d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST, |
| viewFormats: ['rg32uint'], |
| }); |
| let computePassEncoder0 = commandEncoder1.beginComputePass({label: '\u7ccd\uc531\u9440\u7420\u{1f762}\u19ee'}); |
| try { |
| device0.queue.writeTexture({ |
| texture: texture1, |
| mipLevel: 0, |
| origin: { x: 3141, y: 0, z: 0 }, |
| aspect: 'all', |
| }, new DataView(new ArrayBuffer(72)), /* required buffer size: 9776 */ |
| {offset: 520}, {width: 1157, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| let gpuCanvasContext0 = canvas0.getContext('webgpu'); |
| let bindGroupLayout0 = device0.createBindGroupLayout({ |
| label: '\u{1f968}\ud6dc\u{1ff1f}\u706a', |
| entries: [{ |
| binding: 1160, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| externalTexture: {}, |
| }], |
| }); |
| let querySet3 = device0.createQuerySet({ |
| label: '\u0eb5\u9194', |
| type: 'occlusion', |
| count: 2753, |
| }); |
| let texture2 = device0.createTexture({ |
| size: {width: 4704}, |
| sampleCount: 1, |
| dimension: '1d', |
| format: 'rg32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| viewFormats: [], |
| }); |
| let textureView2 = texture1.createView({label: '\uace2\u0fec', aspect: 'all', mipLevelCount: 1}); |
| document.body.prepend(canvas0); |
| let textureView3 = texture1.createView({format: 'rg32uint', baseMipLevel: 0}); |
| try { |
| device0.pushErrorScope('validation'); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture1, |
| mipLevel: 0, |
| origin: { x: 400, y: 0, z: 0 }, |
| aspect: 'all', |
| }, new ArrayBuffer(33302), /* required buffer size: 33302 */ |
| {offset: 630, rowsPerImage: 86}, {width: 4084, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let textureView4 = texture0.createView({baseMipLevel: 1, mipLevelCount: 3, baseArrayLayer: 0}); |
| let promise4 = adapter0.requestAdapterInfo(); |
| let pipelineLayout0 = device0.createPipelineLayout({ |
| label: '\u0b58\uef0e\u0b24\u31e0\u0028\u5efc\u{1f90f}\u26f8\u{1fe40}\u{1fa33}', |
| bindGroupLayouts: [bindGroupLayout0] |
| }); |
| let commandEncoder2 = device0.createCommandEncoder({label: '\u0d88\u{1fa54}\ub2df\u0976\ufa1e\u720f\u6df5\u7c9b'}); |
| try { |
| device0.queue.writeTexture({ |
| texture: texture1, |
| mipLevel: 0, |
| origin: { x: 194, y: 1, z: 0 }, |
| aspect: 'all', |
| }, new ArrayBuffer(16), /* required buffer size: 7 */ |
| {offset: 7}, {width: 482, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| let videoFrame0 = new VideoFrame(imageBitmap0, {timestamp: 0}); |
| let canvas1 = document.createElement('canvas'); |
| let img0 = await imageWithData(98, 98, '#64999d6f', '#0f01d74f'); |
| let commandEncoder3 = device0.createCommandEncoder({label: '\u{1ff33}\u0ac6\uf3f9\uc09c\u099d\u6f32\uf68b\u3e43\u{1fe18}\u{1fd85}'}); |
| try { |
| device0.queue.writeTexture({ |
| texture: texture1, |
| mipLevel: 0, |
| origin: { x: 57, y: 0, z: 0 }, |
| aspect: 'all', |
| }, new Float64Array(new ArrayBuffer(0)), /* required buffer size: 413 */ |
| {offset: 413, rowsPerImage: 48}, {width: 3935, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| let promise5 = device0.queue.onSubmittedWorkDone(); |
| let imageData1 = new ImageData(216, 256); |
| let bindGroupLayout1 = device0.createBindGroupLayout({ |
| label: '\u2cc2\u9444\u{1f7cd}', |
| entries: [{ |
| binding: 1646, |
| visibility: GPUShaderStage.COMPUTE, |
| sampler: { type: 'comparison' }, |
| }, { |
| binding: 3641, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', minBindingSize: 0, hasDynamicOffset: false }, |
| }, { |
| binding: 2862, |
| visibility: GPUShaderStage.FRAGMENT, |
| sampler: { type: 'filtering' }, |
| }], |
| }); |
| let querySet4 = device0.createQuerySet({ |
| label: '\u0a75\u0a4e\ua26f\u0b39\u{1fbcc}\u0bba\u519e\u0b30', |
| type: 'occlusion', |
| count: 2819, |
| }); |
| let commandBuffer1 = commandEncoder3.finish({ |
| }); |
| pseudoSubmit(device0, commandEncoder2); |
| let promise6 = device0.popErrorScope(); |
| let gpuCanvasContext1 = canvas1.getContext('webgpu'); |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| document.body.prepend(img0); |
| let textureView5 = texture1.createView({}); |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: ['rgba16float', 'rgba16float'], |
| colorSpace: 'srgb', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let offscreenCanvas0 = new OffscreenCanvas(392, 15); |
| let texture3 = device0.createTexture({ |
| label: '\u33d7\ueab9\uea25\u0f1f\u044d\u{1fdb1}\u02bd\u091f', |
| size: [66, 372, 1], |
| mipLevelCount: 9, |
| sampleCount: 1, |
| format: 'astc-6x6-unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let sampler4 = device0.createSampler({ |
| label: '\u07d2\u57c6\u8ae7\u{1f9c6}\u0645\uba5e\u07b6\u{1ff37}\uaec4\u006a\ub6c7', |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 74.916, |
| lodMaxClamp: 84.406, |
| maxAnisotropy: 11, |
| }); |
| try { |
| await promise6; |
| } catch {} |
| let offscreenCanvas1 = new OffscreenCanvas(674, 115); |
| let commandEncoder4 = device0.createCommandEncoder({label: '\u{1fd1f}\u{1fe53}\u0a2e\u1ab3\u0dc0\u64a3\ued95\u{1fb78}\u51ca\u07e8'}); |
| try { |
| device0.queue.writeTexture({ |
| texture: texture2, |
| mipLevel: 0, |
| origin: { x: 35, y: 1, z: 0 }, |
| aspect: 'all', |
| }, new ArrayBuffer(835), /* required buffer size: 835 */ |
| {offset: 835}, {width: 1721, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| let commandEncoder5 = device0.createCommandEncoder({label: '\u{1f8b3}\u09e6\u963a\u1274\ubc11\u292f\u2cec'}); |
| let querySet5 = device0.createQuerySet({ |
| label: '\u0d4d\uc4a5\ud0d3\u{1fc1b}\u{1faa4}\u{1f779}\u{1fb9d}\u0e78\u021e\u0d19\u{1f986}', |
| type: 'occlusion', |
| count: 312, |
| }); |
| let textureView6 = texture1.createView({label: '\u2d21\u9005\u03cc\u295b\u1dca\ubfa3\u{1f683}\u07cf\u0bc4\u9475'}); |
| try { |
| device0.queue.writeTexture({ |
| texture: texture2, |
| mipLevel: 0, |
| origin: { x: 1496, y: 0, z: 1 }, |
| aspect: 'all', |
| }, new Int8Array(new ArrayBuffer(40)), /* required buffer size: 772 */ |
| {offset: 772}, {width: 1815, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let shaderModule0 = device0.createShaderModule({ |
| label: '\uf419\u0040\uff5b\u7cd3', |
| code: `@group(0) @binding(1160) |
| var<storage, read_write> function0: array<u32>; |
| |
| @compute @workgroup_size(4, 4, 4) |
| fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {} |
| |
| struct S1 { |
| @location(110) f0: vec4<f16> |
| } |
| struct FragmentOutput0 { |
| @builtin(frag_depth) f0: f32, |
| @location(0) f1: vec2<f32> |
| } |
| |
| @fragment |
| fn fragment0(@location(30) a0: vec3<i32>, @location(24) a1: vec4<f32>, @location(65) a2: u32, @location(26) a3: i32, @location(64) a4: vec4<u32>, @location(6) a5: vec3<f16>, @location(25) a6: vec2<i32>, @builtin(sample_index) a7: u32, @location(48) a8: u32, @location(67) a9: vec4<f32>, @location(33) a10: i32, @location(69) a11: vec2<u32>, @location(23) a12: i32, @location(87) a13: f32, @location(66) a14: vec3<u32>, @location(40) a15: i32, @builtin(front_facing) a16: bool, @location(8) a17: vec4<i32>, @location(42) a18: vec3<u32>, a19: S1, @location(68) a20: f16, @builtin(sample_mask) a21: u32, @location(102) a22: f16, @location(11) a23: vec4<i32>, @location(105) a24: vec3<u32>, @location(16) a25: vec3<f32>, @location(35) a26: vec3<f16>, @location(51) a27: vec4<f16>, @location(61) a28: i32, @builtin(position) a29: vec4<f32>) -> FragmentOutput0 { |
| return FragmentOutput0(); |
| } |
| |
| struct S0 { |
| @location(6) f0: vec4<u32> |
| } |
| struct VertexOutput0 { |
| @location(16) f0: vec3<f32>, |
| @location(40) f1: i32, |
| @location(68) f2: f16, |
| @location(51) f3: vec4<f16>, |
| @location(25) f4: vec2<i32>, |
| @location(30) f5: vec3<i32>, |
| @location(33) f6: i32, |
| @location(69) f7: vec2<u32>, |
| @location(11) f8: vec4<i32>, |
| @builtin(position) f9: vec4<f32>, |
| @location(6) f10: vec3<f16>, |
| @location(35) f11: vec3<f16>, |
| @location(23) f12: i32, |
| @location(105) f13: vec3<u32>, |
| @location(67) f14: vec4<f32>, |
| @location(26) f15: i32, |
| @location(42) f16: vec3<u32>, |
| @location(65) f17: u32, |
| @location(102) f18: f16, |
| @location(24) f19: vec4<f32>, |
| @location(61) f20: i32, |
| @location(64) f21: vec4<u32>, |
| @location(110) f22: vec4<f16>, |
| @location(87) f23: f32, |
| @location(48) f24: u32, |
| @location(8) f25: vec4<i32>, |
| @location(66) f26: vec3<u32> |
| } |
| |
| @vertex |
| fn vertex0(@location(13) a0: u32, @location(8) a1: vec4<f16>, a2: S0, @location(2) a3: u32, @location(0) a4: vec3<f32>, @location(5) a5: vec3<u32>, @location(11) a6: u32, @location(9) a7: vec4<u32>, @location(1) a8: vec3<f16>, @location(12) a9: vec4<i32>, @location(7) a10: vec3<i32>, @builtin(instance_index) a11: u32, @location(10) a12: vec4<u32>, @location(14) a13: vec2<f32>, @location(4) a14: vec3<i32>, @location(15) a15: f16, @location(3) a16: vec2<f32>, @builtin(vertex_index) a17: u32) -> VertexOutput0 { |
| return VertexOutput0(); |
| } |
| |
| `, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| let buffer0 = device0.createBuffer({ |
| label: '\u0d8c\u0253\ucbb9\u97c1', |
| size: 16860, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE, |
| mappedAtCreation: true |
| }); |
| let textureView7 = texture2.createView({label: '\u21b3\u0d27\ue146'}); |
| document.body.prepend(canvas0); |
| let imageData2 = new ImageData(116, 52); |
| let bindGroupLayout2 = device0.createBindGroupLayout({ |
| label: '\u{1f6c9}\u{1f88c}\u283d\u657e', |
| entries: [], |
| }); |
| let textureView8 = texture1.createView({label: '\u46d9\u0203\ueb59\ubfd5\u37e6\u6b4b\u957f'}); |
| let computePassEncoder1 = commandEncoder5.beginComputePass({label: '\u9fdc\u{1fdde}\u{1fa7e}\u8ad5'}); |
| let pipeline0 = await device0.createComputePipelineAsync({ |
| label: '\u08ca\u26a6\uf4d4\u7f13\u0dab\u0f50\u0b12\u0884\ub9f3\uc457\u0e1c', |
| layout: pipelineLayout0, |
| compute: { |
| module: shaderModule0, |
| entryPoint: 'compute0', |
| constants: {}, |
| }, |
| }); |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let bindGroupLayout3 = device0.createBindGroupLayout({ |
| label: '\u5c73\u1007\u7e14\u{1fc79}', |
| entries: [{ |
| binding: 2495, |
| visibility: 0, |
| storageTexture: { format: 'rgba8unorm', access: 'read-only', viewDimension: '3d' }, |
| }], |
| }); |
| let bindGroup0 = device0.createBindGroup({ |
| label: '\uca49\u4c1b\u052f\u7f48\u{1ff6b}\u6665\u09d3\u0247\u{1fd29}\u5bd8\u0d3e', |
| layout: bindGroupLayout2, |
| entries: [], |
| }); |
| let texture4 = device0.createTexture({ |
| label: '\u0816\u{1fe3c}\ucbc3\u{1ffbc}\u951e\u0708\u2d9b\u{1faed}\ufdd8\u{1f77c}', |
| size: {width: 588}, |
| dimension: '1d', |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let sampler5 = device0.createSampler({ |
| label: '\u0ae1\uc5db\u0c13\u7453\u774e\ue3fd', |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 59.307, |
| lodMaxClamp: 60.473, |
| }); |
| try { |
| computePassEncoder0.end(); |
| } catch {} |
| try { |
| commandEncoder1.popDebugGroup(); |
| } catch {} |
| let promise7 = device0.queue.onSubmittedWorkDone(); |
| let pipeline1 = device0.createRenderPipeline({ |
| label: '\uecc8\u0535\u0fc6\ufdb8\u440a\u133e\u{1fb7a}\u3581\u3cac\u03b7', |
| layout: pipelineLayout0, |
| fragment: { |
| module: shaderModule0, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{ |
| format: 'rg8unorm', |
| blend: { |
| color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'}, |
| alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'}, |
| }, |
| writeMask: GPUColorWrite.GREEN | GPUColorWrite.RED |
| }, undefined] |
| }, |
| depthStencil: { |
| format: 'depth24plus-stencil8', |
| depthWriteEnabled: true, |
| depthCompare: 'less', |
| stencilFront: { |
| compare: 'always', |
| failOp: 'increment-clamp', |
| depthFailOp: 'keep', |
| passOp: 'decrement-wrap', |
| }, |
| stencilBack: { |
| compare: 'never', |
| failOp: 'decrement-clamp', |
| depthFailOp: 'replace', |
| passOp: 'increment-clamp', |
| }, |
| stencilReadMask: 1635, |
| stencilWriteMask: 2821, |
| depthBias: 84, |
| depthBiasSlopeScale: 20, |
| }, |
| vertex: { |
| module: shaderModule0, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 4052, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'snorm16x2', |
| offset: 1408, |
| shaderLocation: 15, |
| }, { |
| format: 'uint16x2', |
| offset: 2836, |
| shaderLocation: 2, |
| }, { |
| format: 'uint8x2', |
| offset: 3732, |
| shaderLocation: 10, |
| }, { |
| format: 'sint32x3', |
| offset: 2460, |
| shaderLocation: 4, |
| }, { |
| format: 'unorm8x4', |
| offset: 2248, |
| shaderLocation: 14, |
| }], |
| }, |
| { |
| arrayStride: 10944, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'uint8x2', |
| offset: 6688, |
| shaderLocation: 13, |
| }, { |
| format: 'sint8x2', |
| offset: 3514, |
| shaderLocation: 12, |
| }, { |
| format: 'float32', |
| offset: 6712, |
| shaderLocation: 3, |
| }, { |
| format: 'sint8x2', |
| offset: 6272, |
| shaderLocation: 7, |
| }, { |
| format: 'snorm16x2', |
| offset: 5632, |
| shaderLocation: 1, |
| }, { |
| format: 'snorm8x4', |
| offset: 9152, |
| shaderLocation: 8, |
| }, { |
| format: 'uint8x4', |
| offset: 6196, |
| shaderLocation: 5, |
| }], |
| }, |
| { |
| arrayStride: 5260, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'uint8x2', |
| offset: 302, |
| shaderLocation: 6, |
| }, { |
| format: 'uint8x4', |
| offset: 5076, |
| shaderLocation: 11, |
| }], |
| }, |
| { |
| arrayStride: 16468, |
| stepMode: 'instance', |
| attributes: [{ |
| format: 'uint32x3', |
| offset: 416, |
| shaderLocation: 9, |
| }], |
| }, |
| { |
| arrayStride: 8512, |
| stepMode: 'vertex', |
| attributes: [], |
| }, |
| { |
| arrayStride: 5900, |
| stepMode: 'instance', |
| attributes: [], |
| }, |
| { |
| arrayStride: 9616, |
| stepMode: 'vertex', |
| attributes: [], |
| }, |
| { |
| arrayStride: 15012, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'unorm16x4', |
| offset: 1532, |
| shaderLocation: 0, |
| }], |
| } |
| ] |
| }, |
| primitive: { |
| topology: 'line-list', |
| frontFace: 'cw', |
| }, |
| }); |
| let imageData3 = new ImageData(204, 208); |
| try { |
| window.someLabel = commandEncoder0.label; |
| } catch {} |
| let renderBundleEncoder0 = device0.createRenderBundleEncoder({ |
| label: '\u515d\u{1f94b}\u{1fec1}', |
| colorFormats: ['rg8unorm', undefined], |
| depthStencilFormat: 'depth32float-stencil8', |
| depthReadOnly: true, |
| stencilReadOnly: true |
| }); |
| let renderBundle0 = renderBundleEncoder0.finish({label: '\u99e1\u08d5\uf3c9\uaa12\u6637\ub38e\u04d0\u7404\u{1ff4d}'}); |
| try { |
| computePassEncoder1.setBindGroup(3, bindGroup0); |
| } catch {} |
| try { |
| computePassEncoder1.setBindGroup(1, bindGroup0, new Uint32Array(4766), 558, 0); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC, |
| viewFormats: ['astc-10x6-unorm-srgb', 'rgba16float', 'rg16sint', 'rgb10a2unorm'], |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| let texture5 = device0.createTexture({ |
| label: '\u{1f9ab}\u5d1b\u0434\ua338\u169c\u84fa\u06c6\u65c2\u0c2a\u5ab8\u0139', |
| size: {width: 1136, height: 9, depthOrArrayLayers: 143}, |
| mipLevelCount: 4, |
| dimension: '3d', |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: ['rgba16float', 'rgba16float', 'rgba16float'], |
| }); |
| let texture6 = gpuCanvasContext1.getCurrentTexture(); |
| try { |
| computePassEncoder1.setPipeline(pipeline0); |
| } catch {} |
| let promise8 = device0.createComputePipelineAsync({ |
| label: '\u5f3c\u0a39\u0cd4\u{1f94b}\uc183\u08b0\u{1fdb4}', |
| layout: pipelineLayout0, |
| compute: { |
| module: shaderModule0, |
| entryPoint: 'compute0', |
| constants: {}, |
| }, |
| }); |
| let commandEncoder6 = device0.createCommandEncoder({}); |
| let promise9 = device0.createRenderPipelineAsync({ |
| label: '\uc235\u{1f6f8}\u2939\ub1e6', |
| layout: pipelineLayout0, |
| fragment: { |
| module: shaderModule0, |
| entryPoint: 'fragment0', |
| targets: [{format: 'rg8unorm', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE}, undefined] |
| }, |
| depthStencil: { |
| format: 'depth24plus-stencil8', |
| depthWriteEnabled: true, |
| depthCompare: 'greater', |
| stencilFront: { |
| compare: 'less', |
| depthFailOp: 'replace', |
| }, |
| stencilBack: { |
| failOp: 'decrement-clamp', |
| passOp: 'zero', |
| }, |
| stencilReadMask: 1678, |
| depthBias: 6, |
| depthBiasSlopeScale: 32, |
| depthBiasClamp: 73, |
| }, |
| vertex: { |
| module: shaderModule0, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 5320, |
| attributes: [{ |
| format: 'sint16x2', |
| offset: 2108, |
| shaderLocation: 7, |
| }, { |
| format: 'unorm16x4', |
| offset: 3284, |
| shaderLocation: 3, |
| }, { |
| format: 'uint8x2', |
| offset: 730, |
| shaderLocation: 11, |
| }, { |
| format: 'snorm16x4', |
| offset: 2888, |
| shaderLocation: 8, |
| }, { |
| format: 'float32x3', |
| offset: 1368, |
| shaderLocation: 14, |
| }, { |
| format: 'uint32', |
| offset: 3156, |
| shaderLocation: 6, |
| }, { |
| format: 'unorm8x2', |
| offset: 2314, |
| shaderLocation: 1, |
| }, { |
| format: 'uint32x3', |
| offset: 4312, |
| shaderLocation: 2, |
| }, { |
| format: 'unorm8x4', |
| offset: 992, |
| shaderLocation: 0, |
| }, { |
| format: 'uint16x2', |
| offset: 1908, |
| shaderLocation: 5, |
| }], |
| }, |
| { |
| arrayStride: 12252, |
| stepMode: 'instance', |
| attributes: [{ |
| format: 'uint8x2', |
| offset: 11698, |
| shaderLocation: 10, |
| }], |
| }, |
| { |
| arrayStride: 15000, |
| stepMode: 'instance', |
| attributes: [{ |
| format: 'sint8x2', |
| offset: 7880, |
| shaderLocation: 12, |
| }], |
| }, |
| { |
| arrayStride: 12464, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'snorm16x4', |
| offset: 1080, |
| shaderLocation: 15, |
| }, { |
| format: 'uint32x3', |
| offset: 2320, |
| shaderLocation: 13, |
| }, { |
| format: 'sint16x4', |
| offset: 6808, |
| shaderLocation: 4, |
| }], |
| }, |
| { |
| arrayStride: 752, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'uint8x4', |
| offset: 52, |
| shaderLocation: 9, |
| }], |
| } |
| ] |
| }, |
| primitive: { |
| topology: 'line-list', |
| frontFace: 'cw', |
| cullMode: 'back', |
| unclippedDepth: true, |
| }, |
| }); |
| let video0 = await videoWithData(); |
| try { |
| window.someLabel = device0.label; |
| } catch {} |
| let bindGroupLayout4 = device0.createBindGroupLayout({ |
| label: '\u2838\u974a\ud8a5', |
| entries: [], |
| }); |
| let renderBundle1 = renderBundleEncoder0.finish({label: '\u5224\u233f\u0ea2\u1ccf\ue91a\u030f\u0ea7\u1644\u6545\u{1ff86}\u5986'}); |
| let sampler6 = device0.createSampler({ |
| label: '\u0eeb\u88cf', |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 7.024, |
| lodMaxClamp: 75.140, |
| maxAnisotropy: 5, |
| }); |
| let promise10 = adapter1.requestAdapterInfo(); |
| pseudoSubmit(device0, commandEncoder4); |
| let texture7 = device0.createTexture({ |
| label: '\u058f\udf82\uf61f\u0ab8', |
| size: [20, 240, 1], |
| mipLevelCount: 2, |
| dimension: '2d', |
| format: 'astc-5x4-unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['astc-5x4-unorm', 'astc-5x4-unorm-srgb'], |
| }); |
| let pipeline2 = await promise9; |
| let bindGroup1 = device0.createBindGroup({ |
| label: '\u6581\u010b\u{1f879}', |
| layout: bindGroupLayout2, |
| entries: [], |
| }); |
| let commandEncoder7 = device0.createCommandEncoder({label: '\u00dc\u{1f850}\udebd\ue5dd\u0d0c\u{1fd90}\u0c7e\ud124'}); |
| let texture8 = gpuCanvasContext1.getCurrentTexture(); |
| try { |
| computePassEncoder1.setBindGroup(6, bindGroup1, new Uint32Array(212), 161, 0); |
| } catch {} |
| try { |
| computePassEncoder1.setPipeline(pipeline0); |
| } catch {} |
| try { |
| commandEncoder1.copyTextureToTexture({ |
| texture: texture6, |
| mipLevel: 0, |
| origin: { x: 1, y: 0, z: 0 }, |
| aspect: 'all', |
| }, { |
| texture: texture5, |
| mipLevel: 3, |
| origin: { x: 94, y: 0, z: 4 }, |
| aspect: 'all', |
| }, {width: 0, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| computePassEncoder1.insertDebugMarker('\u{1f9f3}'); |
| } catch {} |
| let pipeline3 = await promise8; |
| let offscreenCanvas2 = new OffscreenCanvas(597, 767); |
| let texture9 = device0.createTexture({ |
| label: '\u0778\u8824\u854b\u0730\u{1f656}\u0285\u749b\u924b', |
| size: {width: 2064, height: 156, depthOrArrayLayers: 109}, |
| mipLevelCount: 9, |
| format: 'astc-12x12-unorm-srgb', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['astc-12x12-unorm'], |
| }); |
| let renderBundle2 = renderBundleEncoder0.finish({}); |
| let sampler7 = device0.createSampler({ |
| label: '\u21e5\u0b20\ua8aa\ub52e\u007c', |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 90.964, |
| lodMaxClamp: 97.764, |
| maxAnisotropy: 13, |
| }); |
| try { |
| computePassEncoder1.setPipeline(pipeline3); |
| } catch {} |
| try { |
| commandEncoder1.copyTextureToTexture({ |
| texture: texture6, |
| mipLevel: 0, |
| origin: { x: 1, y: 0, z: 0 }, |
| aspect: 'all', |
| }, { |
| texture: texture5, |
| mipLevel: 0, |
| origin: { x: 1101, y: 1, z: 105 }, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let promise11 = device0.queue.onSubmittedWorkDone(); |
| let buffer1 = device0.createBuffer({ |
| label: '\u6f4e\u006e\u{1f74b}\u6136\ua71e\u8cb6', |
| size: 18035, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.VERTEX |
| }); |
| let texture10 = device0.createTexture({ |
| size: [721, 48, 72], |
| mipLevelCount: 5, |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: ['r32sint'], |
| }); |
| let sampler8 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'nearest', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 20.911, |
| }); |
| try { |
| computePassEncoder1.setBindGroup(4, bindGroup1, new Uint32Array(5269), 5212, 0); |
| } catch {} |
| let arrayBuffer0 = buffer0.getMappedRange(0, 14348); |
| try { |
| offscreenCanvas1.getContext('webgpu'); |
| } catch {} |
| let commandEncoder8 = device0.createCommandEncoder({label: '\ud697\u{1f9ab}\u{1fd05}\u0b50\u{1fef0}\u891c\ube1b\ue352'}); |
| let querySet6 = device0.createQuerySet({ |
| label: '\u05fe\u{1fdb2}\u0bf6\u{1f9ec}\u970e\u0359\u1566\u4ff1\u{1faaa}', |
| type: 'occlusion', |
| count: 2525, |
| }); |
| let commandBuffer2 = commandEncoder6.finish({ |
| }); |
| let renderBundleEncoder1 = device0.createRenderBundleEncoder({ |
| label: '\u1a73\u021f\u{1fe39}\u04bf\u485d\uf164\ucf53\u{1fbc7}', |
| colorFormats: ['rg8unorm', undefined], |
| depthStencilFormat: 'depth32float-stencil8', |
| depthReadOnly: true, |
| stencilReadOnly: true |
| }); |
| let renderBundle3 = renderBundleEncoder1.finish({label: '\uc13d\ud5c9\ua14c\u08f5'}); |
| let externalTexture0 = device0.importExternalTexture({ |
| label: '\u{1fdb9}\u1a42\u{1fbb2}\u9890', |
| source: video0, |
| }); |
| try { |
| computePassEncoder1.setBindGroup(3, bindGroup0, new Uint32Array(8832), 4818, 0); |
| } catch {} |
| let pipeline4 = await device0.createComputePipelineAsync({ |
| label: '\ubc2f\u{1fd25}\u0e50\u09c7\u{1fdb0}', |
| layout: pipelineLayout0, |
| compute: { |
| module: shaderModule0, |
| entryPoint: 'compute0', |
| constants: {}, |
| }, |
| }); |
| try { |
| await promise4; |
| } catch {} |
| try { |
| offscreenCanvas0.getContext('webgpu'); |
| } catch {} |
| let texture11 = device0.createTexture({ |
| label: '\u04d1\u0a8b\ue30b\u5f83\u7a89\u09df\u{1feff}\u7169\uf3c5\uea69', |
| size: {width: 80, height: 960, depthOrArrayLayers: 1115}, |
| mipLevelCount: 11, |
| dimension: '3d', |
| format: 'rg16float', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| try { |
| device0.queue.submit([ |
| commandBuffer2, |
| commandBuffer0, |
| ]); |
| } catch {} |
| let videoFrame1 = new VideoFrame(canvas1, {timestamp: 0}); |
| let bindGroupLayout5 = device0.createBindGroupLayout({ |
| label: '\u9ed3\u{1fb28}\ubd04\u{1f70f}', |
| entries: [{ |
| binding: 4774, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '1d' }, |
| }, { |
| binding: 1145, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| sampler: { type: 'comparison' }, |
| }, { |
| binding: 4529, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| externalTexture: {}, |
| }], |
| }); |
| let bindGroupLayout6 = pipeline4.getBindGroupLayout(0); |
| let buffer2 = device0.createBuffer({label: '\ueda6\ueac7', size: 62669, usage: GPUBufferUsage.UNIFORM, mappedAtCreation: false}); |
| let texture12 = device0.createTexture({ |
| size: [2796, 108, 250], |
| mipLevelCount: 4, |
| format: 'astc-12x12-unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| viewFormats: ['astc-12x12-unorm-srgb', 'astc-12x12-unorm', 'astc-12x12-unorm-srgb'], |
| }); |
| try { |
| computePassEncoder1.setPipeline(pipeline0); |
| } catch {} |
| try { |
| offscreenCanvas2.getContext('webgl'); |
| } catch {} |
| let texture13 = device0.createTexture({ |
| label: '\u{1f820}\uf68a\u70e6\u7c48\u0f5f\u{1fea2}', |
| size: {width: 80, height: 960, depthOrArrayLayers: 1}, |
| mipLevelCount: 6, |
| format: 'astc-5x5-unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['astc-5x5-unorm'], |
| }); |
| let computePassEncoder2 = commandEncoder8.beginComputePass({label: '\u3483\u{1f9d8}\ud454\u04c6\uea9d'}); |
| let renderBundleEncoder2 = device0.createRenderBundleEncoder({ |
| label: '\ue89b\u{1f738}\u1914\u6da3\u6532', |
| colorFormats: ['rg8unorm', undefined], |
| depthStencilFormat: 'depth32float-stencil8' |
| }); |
| try { |
| device0.queue.writeTexture({ |
| texture: texture11, |
| mipLevel: 8, |
| origin: { x: 0, y: 0, z: 1 }, |
| aspect: 'all', |
| }, arrayBuffer0, /* required buffer size: 15436 */ |
| {offset: 632, bytesPerRow: 40, rowsPerImage: 185}, {width: 1, height: 1, depthOrArrayLayers: 3}); |
| } catch {} |
| let commandBuffer3 = commandEncoder7.finish({ |
| }); |
| let texture14 = device0.createTexture({ |
| label: '\u0d19\u{1fb4b}\u8cd3\u{1fa14}\u13eb', |
| size: [4704, 1, 2], |
| mipLevelCount: 8, |
| format: 'rg8snorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderBundleEncoder2.setBindGroup(0, bindGroup1, []); |
| } catch {} |
| try { |
| renderBundleEncoder2.setBindGroup(5, bindGroup0, new Uint32Array(1367), 833, 0); |
| } catch {} |
| try { |
| commandEncoder1.copyTextureToTexture({ |
| texture: texture8, |
| mipLevel: 0, |
| origin: { x: 1, y: 0, z: 0 }, |
| aspect: 'all', |
| }, { |
| texture: texture5, |
| mipLevel: 3, |
| origin: { x: 94, y: 0, z: 6 }, |
| aspect: 'all', |
| }, {width: 0, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| commandEncoder1.pushDebugGroup('\u0165'); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture12, |
| mipLevel: 0, |
| origin: { x: 396, y: 24, z: 228 }, |
| aspect: 'all', |
| }, new Float32Array(arrayBuffer0), /* required buffer size: 396824 */ |
| {offset: 172, bytesPerRow: 2854, rowsPerImage: 69}, {width: 2100, height: 12, depthOrArrayLayers: 3}); |
| } catch {} |
| document.body.prepend(img0); |
| let imageData4 = new ImageData(156, 124); |
| let querySet7 = device0.createQuerySet({ |
| type: 'occlusion', |
| count: 1302, |
| }); |
| let renderBundle4 = renderBundleEncoder2.finish({label: '\u0472\u{1f6d1}\u{1f847}\ua252\u4f5e\u0053\u814c\u{1fd0c}'}); |
| try { |
| computePassEncoder2.setBindGroup(5, bindGroup1); |
| } catch {} |
| let offscreenCanvas3 = new OffscreenCanvas(47, 353); |
| let pipelineLayout1 = device0.createPipelineLayout({label: '\u4345\u{1f9a3}', bindGroupLayouts: []}); |
| let buffer3 = device0.createBuffer({ |
| label: '\u524e\u0cb9\u09c1\uf8c2\u65a3\u614f', |
| size: 44052, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT |
| }); |
| let textureView9 = texture10.createView({label: '\u765d\u0341\u2cfe\u7e9a', baseMipLevel: 1}); |
| let computePassEncoder3 = commandEncoder1.beginComputePass({}); |
| let renderBundleEncoder3 = device0.createRenderBundleEncoder({colorFormats: ['rg8unorm', undefined], depthStencilFormat: 'depth32float-stencil8', depthReadOnly: true}); |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['astc-12x12-unorm-srgb', 'rgba8unorm'], |
| colorSpace: 'srgb', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device0.queue.submit([ |
| commandBuffer1, |
| commandBuffer3, |
| ]); |
| } catch {} |
| let pipeline5 = device0.createRenderPipeline({ |
| label: '\u05b5\u9f65\u1ab3\u0d72\u24d7\u0050\ud53f\uc7e3', |
| layout: pipelineLayout0, |
| fragment: { |
| module: shaderModule0, |
| entryPoint: 'fragment0', |
| targets: [{format: 'rg8unorm', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN}, undefined] |
| }, |
| depthStencil: { |
| format: 'depth32float-stencil8', |
| depthWriteEnabled: true, |
| depthCompare: 'greater', |
| stencilFront: { |
| compare: 'equal', |
| failOp: 'invert', |
| depthFailOp: 'zero', |
| passOp: 'increment-wrap', |
| }, |
| stencilBack: { |
| compare: 'greater-equal', |
| failOp: 'replace', |
| depthFailOp: 'invert', |
| passOp: 'increment-clamp', |
| }, |
| stencilReadMask: 2418, |
| stencilWriteMask: 2007, |
| depthBias: 31, |
| depthBiasClamp: 45, |
| }, |
| vertex: { |
| module: shaderModule0, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 5316, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'uint16x4', |
| offset: 3204, |
| shaderLocation: 9, |
| }, { |
| format: 'float16x2', |
| offset: 1892, |
| shaderLocation: 0, |
| }, { |
| format: 'uint8x4', |
| offset: 2428, |
| shaderLocation: 6, |
| }, { |
| format: 'uint16x4', |
| offset: 1348, |
| shaderLocation: 10, |
| }, { |
| format: 'sint8x4', |
| offset: 4404, |
| shaderLocation: 7, |
| }, { |
| format: 'sint32x3', |
| offset: 4596, |
| shaderLocation: 4, |
| }, { |
| format: 'uint32x3', |
| offset: 1144, |
| shaderLocation: 2, |
| }, { |
| format: 'uint32x4', |
| offset: 2856, |
| shaderLocation: 11, |
| }], |
| }, |
| { |
| arrayStride: 0, |
| stepMode: 'vertex', |
| attributes: [], |
| }, |
| { |
| arrayStride: 0, |
| stepMode: 'instance', |
| attributes: [{ |
| format: 'uint32x2', |
| offset: 7700, |
| shaderLocation: 13, |
| }, { |
| format: 'unorm8x4', |
| offset: 11268, |
| shaderLocation: 14, |
| }, { |
| format: 'uint8x4', |
| offset: 13912, |
| shaderLocation: 5, |
| }, { |
| format: 'float32x4', |
| offset: 5080, |
| shaderLocation: 3, |
| }, { |
| format: 'sint32', |
| offset: 10340, |
| shaderLocation: 12, |
| }], |
| }, |
| { |
| arrayStride: 3724, |
| attributes: [], |
| }, |
| { |
| arrayStride: 6532, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'unorm16x4', |
| offset: 4716, |
| shaderLocation: 8, |
| }, { |
| format: 'float32', |
| offset: 5048, |
| shaderLocation: 1, |
| }], |
| }, |
| { |
| arrayStride: 6308, |
| stepMode: 'vertex', |
| attributes: [], |
| }, |
| { |
| arrayStride: 0, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'snorm8x4', |
| offset: 8, |
| shaderLocation: 15, |
| }], |
| } |
| ] |
| }, |
| primitive: { |
| topology: 'triangle-list', |
| cullMode: 'front', |
| unclippedDepth: true, |
| }, |
| }); |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55) }; |
| } catch {} |
| try { |
| externalTexture0.label = '\ufea2\u0af9'; |
| } catch {} |
| let bindGroupLayout7 = pipeline3.getBindGroupLayout(0); |
| try { |
| computePassEncoder3.setPipeline(pipeline3); |
| } catch {} |
| try { |
| window.someLabel = device0.queue.label; |
| } catch {} |
| let textureView10 = texture8.createView({ |
| label: '\u{1f63c}\ub01b\u0d92\u19a1\u{1fbca}\u0491\u0525\u226c\ucf63\u8341', |
| dimension: '2d-array', |
| format: 'rgb10a2unorm' |
| }); |
| let renderBundle5 = renderBundleEncoder2.finish({label: '\u39bc\u{1fde7}'}); |
| try { |
| renderBundleEncoder3.setVertexBuffer(3, buffer1); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture11, |
| mipLevel: 6, |
| origin: { x: 0, y: 4, z: 8 }, |
| aspect: 'all', |
| }, new Float32Array(arrayBuffer0), /* required buffer size: 392062 */ |
| {offset: 744, bytesPerRow: 294, rowsPerImage: 166}, {width: 1, height: 4, depthOrArrayLayers: 9}); |
| } catch {} |
| let buffer4 = device0.createBuffer({size: 37307, usage: GPUBufferUsage.COPY_SRC}); |
| let sampler9 = device0.createSampler({ |
| label: '\u5105\u0a58\uf411', |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 62.680, |
| lodMaxClamp: 68.434, |
| maxAnisotropy: 7, |
| }); |
| try { |
| renderBundleEncoder3.setVertexBuffer(5, buffer1, 6260, 3625); |
| } catch {} |
| let promise12 = device0.popErrorScope(); |
| try { |
| renderBundleEncoder3.setBindGroup(2, bindGroup0); |
| } catch {} |
| try { |
| renderBundleEncoder3.setVertexBuffer(2, buffer1, 16808, 664); |
| } catch {} |
| let promise13 = device0.queue.onSubmittedWorkDone(); |
| let pipeline6 = await device0.createComputePipelineAsync({ |
| label: '\u0f29\uddd7\u94e0\uc7d0\u05c1\u0561', |
| layout: pipelineLayout1, |
| compute: { |
| module: shaderModule0, |
| entryPoint: 'compute0', |
| constants: {}, |
| }, |
| }); |
| let pipelineLayout2 = device0.createPipelineLayout({label: '\ud4a8\u08d7', bindGroupLayouts: [bindGroupLayout4, bindGroupLayout4]}); |
| let texture15 = gpuCanvasContext1.getCurrentTexture(); |
| let renderBundle6 = renderBundleEncoder0.finish(); |
| try { |
| renderBundleEncoder3.setVertexBuffer(6, buffer1, 11708, 2039); |
| } catch {} |
| let canvas2 = document.createElement('canvas'); |
| let video1 = await videoWithData(); |
| let promise14 = adapter1.requestAdapterInfo(); |
| let texture16 = device0.createTexture({ |
| label: '\u9f44\u{1ffd3}\u67bc\ud1b1\u{1fba6}\u7c81\u{1f6de}\u9167', |
| size: {width: 3520}, |
| dimension: '1d', |
| format: 'r32float', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler10 = device0.createSampler({ |
| label: '\uba32\u048f\u05a5\u31fd\u8d01\u0670\u524f\u9cc2\u{1f736}', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| lodMinClamp: 97.817, |
| lodMaxClamp: 98.810, |
| }); |
| try { |
| await promise13; |
| } catch {} |
| let commandEncoder9 = device0.createCommandEncoder(); |
| let querySet8 = device0.createQuerySet({ |
| label: '\u03bd\u0db8\u6b37\u4aaf', |
| type: 'occlusion', |
| count: 355, |
| }); |
| let sampler11 = device0.createSampler({ |
| label: '\u0316\u02c6\u08d6\u{1fed7}\udcb8\u{1f765}', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 96.219, |
| lodMaxClamp: 98.010, |
| compare: 'not-equal', |
| maxAnisotropy: 8, |
| }); |
| try { |
| computePassEncoder2.setBindGroup(5, bindGroup0); |
| } catch {} |
| try { |
| commandEncoder9.copyTextureToTexture({ |
| texture: texture12, |
| mipLevel: 3, |
| origin: { x: 84, y: 0, z: 183 }, |
| aspect: 'all', |
| }, { |
| texture: texture12, |
| mipLevel: 3, |
| origin: { x: 72, y: 0, z: 30 }, |
| aspect: 'all', |
| }, {width: 180, height: 24, depthOrArrayLayers: 11}); |
| } catch {} |
| gc(); |
| let video2 = await videoWithData(); |
| let querySet9 = device0.createQuerySet({ |
| label: '\u328d\u{1f781}', |
| type: 'occlusion', |
| count: 3508, |
| }); |
| let sampler12 = device0.createSampler({ |
| label: '\u0367\u722d\ua4b1\uc4fb', |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'nearest', |
| lodMinClamp: 48.806, |
| lodMaxClamp: 80.249, |
| compare: 'not-equal', |
| }); |
| try { |
| buffer4.unmap(); |
| } catch {} |
| try { |
| commandEncoder9.clearBuffer(buffer3); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| let pipeline7 = await device0.createComputePipelineAsync({ |
| label: '\u{1fad1}\u51ec\u0370\u0bb1\u018b', |
| layout: pipelineLayout0, |
| compute: { |
| module: shaderModule0, |
| entryPoint: 'compute0', |
| constants: {}, |
| }, |
| }); |
| let pipeline8 = device0.createRenderPipeline({ |
| label: '\ud7a8\ue710\u55e8\ud7e7\uae10\u{1ff9c}\u5622\udc9c\u1e81\u{1f6cd}', |
| layout: pipelineLayout1, |
| multisample: { |
| mask: 0x1cdd375a, |
| }, |
| fragment: { |
| module: shaderModule0, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{format: 'rg8unorm', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN}, undefined] |
| }, |
| depthStencil: { |
| format: 'depth32float-stencil8', |
| depthWriteEnabled: false, |
| depthCompare: 'not-equal', |
| stencilFront: { |
| compare: 'less', |
| failOp: 'increment-clamp', |
| depthFailOp: 'zero', |
| passOp: 'zero', |
| }, |
| stencilBack: { |
| failOp: 'replace', |
| depthFailOp: 'increment-clamp', |
| }, |
| stencilReadMask: 3819, |
| stencilWriteMask: 2376, |
| depthBias: 9, |
| depthBiasSlopeScale: 58, |
| depthBiasClamp: 88, |
| }, |
| vertex: { |
| module: shaderModule0, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 16860, |
| attributes: [{ |
| format: 'sint32x3', |
| offset: 3564, |
| shaderLocation: 7, |
| }, { |
| format: 'uint16x2', |
| offset: 10644, |
| shaderLocation: 9, |
| }, { |
| format: 'sint32x2', |
| offset: 11212, |
| shaderLocation: 12, |
| }, { |
| format: 'uint32x4', |
| offset: 16572, |
| shaderLocation: 11, |
| }, { |
| format: 'snorm16x2', |
| offset: 6796, |
| shaderLocation: 3, |
| }, { |
| format: 'snorm16x4', |
| offset: 16372, |
| shaderLocation: 15, |
| }, { |
| format: 'uint16x4', |
| offset: 6640, |
| shaderLocation: 6, |
| }, { |
| format: 'snorm8x2', |
| offset: 7904, |
| shaderLocation: 0, |
| }, { |
| format: 'snorm16x4', |
| offset: 13228, |
| shaderLocation: 14, |
| }, { |
| format: 'uint8x2', |
| offset: 128, |
| shaderLocation: 2, |
| }, { |
| format: 'float32x3', |
| offset: 6840, |
| shaderLocation: 8, |
| }, { |
| format: 'uint32x4', |
| offset: 4664, |
| shaderLocation: 10, |
| }], |
| }, |
| { |
| arrayStride: 896, |
| stepMode: 'instance', |
| attributes: [{ |
| format: 'uint32x4', |
| offset: 708, |
| shaderLocation: 5, |
| }, { |
| format: 'float32x2', |
| offset: 352, |
| shaderLocation: 1, |
| }, { |
| format: 'sint8x2', |
| offset: 886, |
| shaderLocation: 4, |
| }], |
| }, |
| { |
| arrayStride: 12700, |
| stepMode: 'instance', |
| attributes: [{ |
| format: 'uint32x4', |
| offset: 2856, |
| shaderLocation: 13, |
| }], |
| } |
| ] |
| }, |
| primitive: { |
| frontFace: 'ccw', |
| }, |
| }); |
| let videoFrame2 = new VideoFrame(canvas2, {timestamp: 0}); |
| let bindGroupLayout8 = pipeline0.getBindGroupLayout(0); |
| let texture17 = device0.createTexture({ |
| label: '\u77ea\u056c\u0440\u{1f7b8}\ubaef\u09be\u0403\u{1f8d7}\u0e3d', |
| size: [9088, 72, 1], |
| mipLevelCount: 3, |
| format: 'astc-8x6-unorm-srgb', |
| usage: GPUTextureUsage.COPY_SRC, |
| viewFormats: ['astc-8x6-unorm-srgb', 'astc-8x6-unorm', 'astc-8x6-unorm'], |
| }); |
| let renderBundleEncoder4 = device0.createRenderBundleEncoder({ |
| label: '\u{1f621}\u{1f8fc}\u0024\u6035\u09b6\u5b9c\uee5a', |
| colorFormats: ['r16sint', 'r8uint', 'rg16uint', 'r8uint', 'rg32sint', 'r8unorm'], |
| sampleCount: 4, |
| stencilReadOnly: true |
| }); |
| try { |
| computePassEncoder2.setBindGroup(1, bindGroup0); |
| } catch {} |
| try { |
| renderBundleEncoder4.setBindGroup(2, bindGroup1, new Uint32Array(796), 217, 0); |
| } catch {} |
| try { |
| texture1.destroy(); |
| } catch {} |
| try { |
| commandEncoder9.copyBufferToTexture({ |
| /* bytesInLastRow: 7840 widthInBlocks: 3920 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 12018 */ |
| offset: 4178, |
| buffer: buffer1, |
| }, { |
| texture: texture14, |
| mipLevel: 0, |
| origin: { x: 200, y: 0, z: 0 }, |
| aspect: 'all', |
| }, {width: 3920, height: 1, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer1); |
| } catch {} |
| try { |
| commandEncoder9.copyTextureToTexture({ |
| texture: texture15, |
| mipLevel: 0, |
| origin: { x: 0, y: 1, z: 0 }, |
| aspect: 'all', |
| }, { |
| texture: texture5, |
| mipLevel: 2, |
| origin: { x: 167, y: 0, z: 11 }, |
| aspect: 'all', |
| }, {width: 1, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: ['rgba8unorm-srgb'], |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let videoFrame3 = new VideoFrame(img0, {timestamp: 0}); |
| let buffer5 = device0.createBuffer({ |
| label: '\u1da2\uf507\u2a57\udca2\u019a\u76ea\u{1ffae}\u0c0c\u083f\udef0', |
| size: 24921, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE |
| }); |
| let renderBundle7 = renderBundleEncoder0.finish({label: '\u0572\uf151\u07eb\ucedc'}); |
| try { |
| computePassEncoder2.setBindGroup(5, bindGroup0); |
| } catch {} |
| try { |
| renderBundleEncoder4.setBindGroup(3, bindGroup1, new Uint32Array(8871), 967, 0); |
| } catch {} |
| let promise15 = device0.createRenderPipelineAsync({ |
| label: '\u0a74\u{1fdaa}\u0066\u{1fb2f}\u{1f7f7}\u0953\u0078\u9cff\u36c9\ufb6d\u{1fda2}', |
| layout: pipelineLayout2, |
| multisample: { |
| count: 4, |
| mask: 0xcff79e3d, |
| }, |
| fragment: { |
| module: shaderModule0, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{ |
| format: 'rg8unorm', |
| blend: { |
| color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'}, |
| alpha: {operation: 'subtract', srcFactor: 'src', dstFactor: 'src'}, |
| } |
| }, undefined] |
| }, |
| depthStencil: { |
| format: 'depth24plus-stencil8', |
| depthWriteEnabled: false, |
| depthCompare: 'greater', |
| stencilFront: { |
| compare: 'greater', |
| failOp: 'decrement-wrap', |
| depthFailOp: 'increment-wrap', |
| passOp: 'increment-wrap', |
| }, |
| stencilBack: { |
| compare: 'equal', |
| failOp: 'zero', |
| depthFailOp: 'decrement-wrap', |
| passOp: 'increment-wrap', |
| }, |
| stencilReadMask: 1798, |
| stencilWriteMask: 82, |
| depthBias: 37, |
| depthBiasSlopeScale: 67, |
| depthBiasClamp: 45, |
| }, |
| vertex: { |
| module: shaderModule0, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 16528, |
| attributes: [{ |
| format: 'uint16x4', |
| offset: 5944, |
| shaderLocation: 13, |
| }, { |
| format: 'uint16x4', |
| offset: 14788, |
| shaderLocation: 5, |
| }], |
| }, |
| { |
| arrayStride: 364, |
| stepMode: 'instance', |
| attributes: [{ |
| format: 'uint32', |
| offset: 252, |
| shaderLocation: 6, |
| }, { |
| format: 'sint8x2', |
| offset: 214, |
| shaderLocation: 7, |
| }, { |
| format: 'sint32x2', |
| offset: 224, |
| shaderLocation: 12, |
| }, { |
| format: 'float16x4', |
| offset: 32, |
| shaderLocation: 0, |
| }, { |
| format: 'float32x2', |
| offset: 268, |
| shaderLocation: 1, |
| }], |
| }, |
| { |
| arrayStride: 1136, |
| attributes: [{ |
| format: 'uint32x3', |
| offset: 548, |
| shaderLocation: 2, |
| }], |
| }, |
| { |
| arrayStride: 9336, |
| attributes: [], |
| }, |
| { |
| arrayStride: 12048, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'uint32x3', |
| offset: 940, |
| shaderLocation: 9, |
| }, { |
| format: 'uint32x4', |
| offset: 2324, |
| shaderLocation: 10, |
| }, { |
| format: 'snorm8x4', |
| offset: 3636, |
| shaderLocation: 15, |
| }, { |
| format: 'sint8x4', |
| offset: 9180, |
| shaderLocation: 4, |
| }, { |
| format: 'unorm8x4', |
| offset: 7260, |
| shaderLocation: 3, |
| }], |
| }, |
| { |
| arrayStride: 7408, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'snorm16x4', |
| offset: 5640, |
| shaderLocation: 8, |
| }, { |
| format: 'uint32x2', |
| offset: 2364, |
| shaderLocation: 11, |
| }, { |
| format: 'unorm8x2', |
| offset: 396, |
| shaderLocation: 14, |
| }], |
| } |
| ] |
| }, |
| primitive: { |
| topology: 'line-strip', |
| stripIndexFormat: 'uint32', |
| frontFace: 'cw', |
| cullMode: 'front', |
| unclippedDepth: true, |
| }, |
| }); |
| let video3 = await videoWithData(); |
| try { |
| await adapter1.requestAdapterInfo(); |
| } catch {} |
| let texture18 = device0.createTexture({ |
| label: '\u5cab\u{1f71a}\u053d\u060f\u079a\u06c6\u5043\u{1fbe9}\u545c', |
| size: [880, 1, 1], |
| mipLevelCount: 7, |
| format: 'r16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| viewFormats: ['r16float', 'r16float', 'r16float'], |
| }); |
| try { |
| renderBundleEncoder3.setVertexBuffer(1, buffer1); |
| } catch {} |
| let pipeline9 = device0.createComputePipeline({ |
| label: '\uf4d9\u3775\u85ce\u0017\u37ba', |
| layout: 'auto', |
| compute: { |
| module: shaderModule0, |
| entryPoint: 'compute0', |
| constants: {}, |
| }, |
| }); |
| let textureView11 = texture1.createView({}); |
| let renderBundleEncoder5 = device0.createRenderBundleEncoder({ |
| colorFormats: ['r16sint', 'r8uint', 'rg16uint', 'r8uint', 'rg32sint', 'r8unorm'], |
| sampleCount: 4, |
| stencilReadOnly: true |
| }); |
| let renderBundle8 = renderBundleEncoder5.finish({label: '\ue00d\u0a06\u0d90\uda36\ub8df\ucd17\u{1fd3f}\u{1fc87}\u01c4\u{1f9fa}'}); |
| try { |
| renderBundleEncoder3.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderBundleEncoder4.setVertexBuffer(5, buffer1, 3352, 1710); |
| } catch {} |
| try { |
| commandEncoder9.copyBufferToBuffer(buffer0, 11364, buffer3, 21572, 2284); |
| dissociateBuffer(device0, buffer0); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| commandEncoder9.clearBuffer(buffer3); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let computePassEncoder4 = commandEncoder9.beginComputePass({label: '\u5b0a\ua89d'}); |
| try { |
| renderBundleEncoder3.draw(24, 16, 8, 16); |
| } catch {} |
| try { |
| renderBundleEncoder3.drawIndexedIndirect(buffer3, 20796); |
| } catch {} |
| try { |
| renderBundleEncoder3.setVertexBuffer(6, buffer1); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| gc(); |
| let querySet10 = device0.createQuerySet({ |
| label: '\u5c03\u{1fec2}\u0ca9\u207a', |
| type: 'occlusion', |
| count: 2443, |
| }); |
| let texture19 = device0.createTexture({ |
| size: [721, 48, 755], |
| mipLevelCount: 4, |
| dimension: '3d', |
| format: 'rgba8unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| viewFormats: ['rgba8unorm', 'rgba8unorm', 'rgba8unorm-srgb'], |
| }); |
| try { |
| computePassEncoder4.setBindGroup(6, bindGroup0); |
| } catch {} |
| try { |
| computePassEncoder2.setBindGroup(0, bindGroup0, new Uint32Array(8983), 3323, 0); |
| } catch {} |
| try { |
| computePassEncoder4.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderBundleEncoder3.draw(40, 0); |
| } catch {} |
| try { |
| renderBundleEncoder3.setPipeline(pipeline8); |
| } catch {} |
| try { |
| await promise7; |
| } catch {} |
| let commandEncoder10 = device0.createCommandEncoder({label: '\uaddd\u03b3\u0f36\udcc3\u03f8\u944b\u8056'}); |
| let renderBundleEncoder6 = device0.createRenderBundleEncoder({ |
| label: '\u0b78\u6000\u5b3a\u{1fd12}\ud700', |
| colorFormats: ['r16sint', 'r8uint', 'rg16uint', 'r8uint', 'rg32sint', 'r8unorm'], |
| sampleCount: 4 |
| }); |
| let renderBundle9 = renderBundleEncoder5.finish({label: '\u{1f676}\u{1fd69}'}); |
| try { |
| computePassEncoder3.setBindGroup(1, bindGroup1, []); |
| } catch {} |
| try { |
| renderBundleEncoder3.draw(72); |
| } catch {} |
| try { |
| await device0.popErrorScope(); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['astc-10x8-unorm-srgb', 'bgra8unorm', 'stencil8', 'bgra8unorm-srgb'], |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 16844, new BigUint64Array(28576), 7192, 2480); |
| } catch {} |
| let pipeline10 = device0.createComputePipeline({ |
| label: '\uaaa9\u3c7e\u{1fcd6}\u0371\ud97c\u0a63\u047c', |
| layout: pipelineLayout0, |
| compute: { |
| module: shaderModule0, |
| entryPoint: 'compute0', |
| constants: {}, |
| }, |
| }); |
| let commandEncoder11 = device0.createCommandEncoder({label: '\ud7e2\u60af\u00e2\u{1fb77}\u0747\ue6b8\u597e\u{1f78c}\u6771'}); |
| try { |
| computePassEncoder4.setBindGroup(2, bindGroup1); |
| } catch {} |
| try { |
| computePassEncoder2.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderBundleEncoder3.drawIndexed(72, 56, 40, 688, 48); |
| } catch {} |
| try { |
| renderBundleEncoder3.drawIndexedIndirect(buffer3, 14524); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 19580, new Int16Array(9535), 3955); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture11, |
| mipLevel: 6, |
| origin: { x: 0, y: 3, z: 2 }, |
| aspect: 'all', |
| }, arrayBuffer0, /* required buffer size: 744364 */ |
| {offset: 142, bytesPerRow: 226, rowsPerImage: 235}, {width: 1, height: 4, depthOrArrayLayers: 15}); |
| } catch {} |
| let pipeline11 = device0.createRenderPipeline({ |
| layout: pipelineLayout1, |
| multisample: { |
| count: 4, |
| mask: 0xc74e8b91, |
| }, |
| fragment: { |
| module: shaderModule0, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{format: 'rg8unorm', writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN}, undefined] |
| }, |
| depthStencil: { |
| format: 'depth32float-stencil8', |
| depthWriteEnabled: false, |
| depthCompare: 'less-equal', |
| stencilFront: { |
| compare: 'not-equal', |
| depthFailOp: 'increment-clamp', |
| passOp: 'replace', |
| }, |
| stencilBack: { |
| compare: 'never', |
| failOp: 'increment-wrap', |
| depthFailOp: 'increment-clamp', |
| passOp: 'keep', |
| }, |
| stencilReadMask: 40, |
| stencilWriteMask: 3494, |
| depthBias: 35, |
| depthBiasSlopeScale: 94, |
| depthBiasClamp: 29, |
| }, |
| vertex: { |
| module: shaderModule0, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 6516, |
| stepMode: 'instance', |
| attributes: [], |
| }, |
| { |
| arrayStride: 15948, |
| stepMode: 'instance', |
| attributes: [], |
| }, |
| { |
| arrayStride: 0, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'float32x4', |
| offset: 336, |
| shaderLocation: 1, |
| }, { |
| format: 'snorm8x2', |
| offset: 1762, |
| shaderLocation: 8, |
| }, { |
| format: 'uint8x4', |
| offset: 16488, |
| shaderLocation: 10, |
| }, { |
| format: 'snorm8x4', |
| offset: 11864, |
| shaderLocation: 3, |
| }, { |
| format: 'uint32', |
| offset: 13852, |
| shaderLocation: 2, |
| }, { |
| format: 'sint8x4', |
| offset: 15536, |
| shaderLocation: 4, |
| }, { |
| format: 'uint32x4', |
| offset: 15756, |
| shaderLocation: 5, |
| }, { |
| format: 'float32x2', |
| offset: 9236, |
| shaderLocation: 15, |
| }, { |
| format: 'uint32x4', |
| offset: 7888, |
| shaderLocation: 9, |
| }, { |
| format: 'unorm16x2', |
| offset: 24, |
| shaderLocation: 14, |
| }, { |
| format: 'uint32x4', |
| offset: 1280, |
| shaderLocation: 6, |
| }, { |
| format: 'sint8x2', |
| offset: 2620, |
| shaderLocation: 12, |
| }, { |
| format: 'sint8x2', |
| offset: 11014, |
| shaderLocation: 7, |
| }], |
| }, |
| { |
| arrayStride: 6728, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'uint16x2', |
| offset: 1020, |
| shaderLocation: 13, |
| }], |
| }, |
| { |
| arrayStride: 1492, |
| attributes: [], |
| }, |
| { |
| arrayStride: 12836, |
| stepMode: 'instance', |
| attributes: [], |
| }, |
| { |
| arrayStride: 11568, |
| stepMode: 'instance', |
| attributes: [{ |
| format: 'uint8x2', |
| offset: 9084, |
| shaderLocation: 11, |
| }], |
| }, |
| { |
| arrayStride: 2612, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'snorm8x2', |
| offset: 132, |
| shaderLocation: 0, |
| }], |
| } |
| ] |
| }, |
| primitive: { |
| topology: 'triangle-strip', |
| stripIndexFormat: 'uint32', |
| frontFace: 'ccw', |
| cullMode: 'front', |
| unclippedDepth: true, |
| }, |
| }); |
| gc(); |
| let renderBundle10 = renderBundleEncoder6.finish(); |
| try { |
| renderBundleEncoder3.drawIndexed(24, 56, 80, -664, 32); |
| } catch {} |
| try { |
| renderBundleEncoder3.drawIndirect(buffer3, 4748); |
| } catch {} |
| try { |
| commandEncoder10.clearBuffer(buffer3, 1640, 13204); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture11, |
| mipLevel: 5, |
| origin: { x: 0, y: 0, z: 5 }, |
| aspect: 'all', |
| }, new ArrayBuffer(80150), /* required buffer size: 80150 */ |
| {offset: 370, bytesPerRow: 72, rowsPerImage: 121}, {width: 1, height: 20, depthOrArrayLayers: 10}); |
| } catch {} |
| let pipeline12 = await device0.createRenderPipelineAsync({ |
| label: '\ue040\u9015\u0b99\u07d1\ua9f8\u2372\u{1fa55}', |
| layout: pipelineLayout2, |
| multisample: { |
| }, |
| fragment: { |
| module: shaderModule0, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{ |
| format: 'rg8unorm', |
| blend: { |
| color: {operation: 'add', srcFactor: 'dst', dstFactor: 'one-minus-dst'}, |
| alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'}, |
| }, |
| writeMask: GPUColorWrite.RED |
| }, undefined] |
| }, |
| depthStencil: { |
| format: 'depth24plus-stencil8', |
| depthWriteEnabled: false, |
| depthCompare: 'less', |
| stencilFront: { |
| compare: 'greater', |
| failOp: 'replace', |
| depthFailOp: 'zero', |
| passOp: 'invert', |
| }, |
| stencilBack: { |
| compare: 'greater', |
| depthFailOp: 'replace', |
| }, |
| stencilWriteMask: 3345, |
| depthBias: 87, |
| depthBiasSlopeScale: 37, |
| depthBiasClamp: 52, |
| }, |
| vertex: { |
| module: shaderModule0, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 11452, |
| stepMode: 'instance', |
| attributes: [{ |
| format: 'snorm16x4', |
| offset: 8796, |
| shaderLocation: 14, |
| }, { |
| format: 'uint32', |
| offset: 2516, |
| shaderLocation: 11, |
| }, { |
| format: 'sint32x4', |
| offset: 4400, |
| shaderLocation: 4, |
| }, { |
| format: 'uint8x4', |
| offset: 432, |
| shaderLocation: 5, |
| }, { |
| format: 'snorm16x2', |
| offset: 8692, |
| shaderLocation: 0, |
| }, { |
| format: 'snorm8x4', |
| offset: 5972, |
| shaderLocation: 1, |
| }, { |
| format: 'uint32x4', |
| offset: 3156, |
| shaderLocation: 2, |
| }, { |
| format: 'uint16x2', |
| offset: 3736, |
| shaderLocation: 10, |
| }, { |
| format: 'uint8x2', |
| offset: 9902, |
| shaderLocation: 6, |
| }, { |
| format: 'uint8x4', |
| offset: 10800, |
| shaderLocation: 13, |
| }, { |
| format: 'uint32x3', |
| offset: 9160, |
| shaderLocation: 9, |
| }, { |
| format: 'unorm16x2', |
| offset: 11152, |
| shaderLocation: 8, |
| }, { |
| format: 'sint32x4', |
| offset: 5160, |
| shaderLocation: 7, |
| }], |
| }, |
| { |
| arrayStride: 0, |
| stepMode: 'instance', |
| attributes: [], |
| }, |
| { |
| arrayStride: 12944, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'snorm8x4', |
| offset: 12156, |
| shaderLocation: 3, |
| }, { |
| format: 'sint32', |
| offset: 3060, |
| shaderLocation: 12, |
| }, { |
| format: 'snorm8x2', |
| offset: 2584, |
| shaderLocation: 15, |
| }], |
| } |
| ] |
| }, |
| primitive: { |
| topology: 'line-strip', |
| frontFace: 'cw', |
| cullMode: 'back', |
| unclippedDepth: true, |
| }, |
| }); |
| let querySet11 = device0.createQuerySet({ |
| type: 'occlusion', |
| count: 2297, |
| }); |
| let sampler13 = device0.createSampler({ |
| label: '\uf008\u0150\u980f\u8874\u016e', |
| addressModeU: 'clamp-to-edge', |
| magFilter: 'nearest', |
| lodMinClamp: 84.045, |
| lodMaxClamp: 87.558, |
| }); |
| try { |
| computePassEncoder2.setBindGroup(6, bindGroup0, new Uint32Array(6045), 4824, 0); |
| } catch {} |
| try { |
| renderBundleEncoder3.drawIndexed(80); |
| } catch {} |
| try { |
| renderBundleEncoder3.drawIndexedIndirect(buffer3, 29252); |
| } catch {} |
| try { |
| buffer1.unmap(); |
| } catch {} |
| try { |
| commandEncoder11.copyTextureToTexture({ |
| texture: texture8, |
| mipLevel: 0, |
| origin: { x: 1, y: 0, z: 0 }, |
| aspect: 'all', |
| }, { |
| texture: texture5, |
| mipLevel: 1, |
| origin: { x: 387, y: 3, z: 14 }, |
| aspect: 'all', |
| }, {width: 0, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| let promise16 = device0.queue.onSubmittedWorkDone(); |
| let video4 = await videoWithData(); |
| let bindGroup2 = device0.createBindGroup({ |
| layout: bindGroupLayout8, |
| entries: [{ |
| binding: 1160, |
| resource: externalTexture0 |
| }], |
| }); |
| try { |
| computePassEncoder3.setBindGroup(3, bindGroup1); |
| } catch {} |
| try { |
| renderBundleEncoder4.setBindGroup(2, bindGroup1); |
| } catch {} |
| try { |
| renderBundleEncoder3.drawIndexed(16, 24); |
| } catch {} |
| let commandBuffer4 = commandEncoder11.finish({ |
| label: '\ub88e\u79cc\ude88\ud987\u48c9\u{1f6ce}\u0a11\u0a50\u{1f93a}', |
| }); |
| let renderBundle11 = renderBundleEncoder0.finish({}); |
| try { |
| computePassEncoder3.end(); |
| } catch {} |
| try { |
| renderBundleEncoder4.setBindGroup(0, bindGroup1); |
| } catch {} |
| try { |
| renderBundleEncoder3.draw(16); |
| } catch {} |
| try { |
| commandEncoder10.copyBufferToBuffer(buffer1, 9280, buffer3, 5036, 5120); |
| dissociateBuffer(device0, buffer1); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| video2.height = 48; |
| let commandBuffer5 = commandEncoder10.finish({ |
| label: '\u0520\ud63a\u{1fdb5}\u0f7c\u566b\u04cf\u7626\u0cf3', |
| }); |
| let textureView12 = texture12.createView({ |
| label: '\u4bd5\u01c7', |
| format: 'astc-12x12-unorm-srgb', |
| mipLevelCount: 1, |
| baseArrayLayer: 56, |
| arrayLayerCount: 51 |
| }); |
| let renderBundle12 = renderBundleEncoder1.finish(); |
| try { |
| renderBundleEncoder3.drawIndexedIndirect(buffer3, 23456); |
| } catch {} |
| try { |
| commandEncoder1.copyBufferToBuffer(buffer1, 17448, buffer3, 6196, 164); |
| dissociateBuffer(device0, buffer1); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture19, |
| mipLevel: 2, |
| origin: { x: 44, y: 0, z: 58 }, |
| aspect: 'all', |
| }, new DataView(arrayBuffer0), /* required buffer size: 1624242 */ |
| {offset: 630, bytesPerRow: 676, rowsPerImage: 52}, {width: 134, height: 10, depthOrArrayLayers: 47}); |
| } catch {} |
| let bindGroup3 = device0.createBindGroup({ |
| label: '\ub83f\u0ecf', |
| layout: bindGroupLayout6, |
| entries: [{ |
| binding: 1160, |
| resource: externalTexture0 |
| }], |
| }); |
| let texture20 = device0.createTexture({ |
| label: '\ubc95\u{1f7c7}\u533c\u0e54\u9d8a\u2f59\ue62d\u7367\u014a', |
| size: [20, 240, 1], |
| mipLevelCount: 8, |
| dimension: '2d', |
| format: 'astc-10x8-unorm-srgb', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['astc-10x8-unorm'], |
| }); |
| let computePassEncoder5 = commandEncoder1.beginComputePass({label: '\u{1ff4e}\u5692\u0370\u0e28\u0556'}); |
| let renderBundleEncoder7 = device0.createRenderBundleEncoder({ |
| label: '\u0080\u4d73\u3a71\u533a\u1075\u04c9\ufaae\u0064', |
| colorFormats: ['rg8unorm', undefined], |
| depthStencilFormat: 'depth32float-stencil8', |
| sampleCount: 1, |
| depthReadOnly: true |
| }); |
| try { |
| renderBundleEncoder4.setBindGroup(3, bindGroup2); |
| } catch {} |
| try { |
| renderBundleEncoder3.drawIndexed(56, 8); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture7, |
| mipLevel: 1, |
| origin: { x: 5, y: 0, z: 1 }, |
| aspect: 'all', |
| }, arrayBuffer0, /* required buffer size: 924 */ |
| {offset: 924, bytesPerRow: 176}, {width: 5, height: 92, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| try { |
| await promise14; |
| } catch {} |
| let commandEncoder12 = device0.createCommandEncoder({label: '\u{1fb0f}\u0871\udbf7\ub13a\ubae8'}); |
| try { |
| computePassEncoder2.end(); |
| } catch {} |
| try { |
| commandEncoder8.copyTextureToBuffer({ |
| texture: texture15, |
| mipLevel: 0, |
| origin: { x: 0, y: 0, z: 0 }, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 8 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 22352 */ |
| offset: 22344, |
| buffer: buffer3, |
| }, {width: 1, height: 1, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| let texture21 = gpuCanvasContext0.getCurrentTexture(); |
| let renderBundleEncoder8 = device0.createRenderBundleEncoder({colorFormats: ['rg8unorm', undefined], depthStencilFormat: 'depth32float-stencil8', depthReadOnly: true}); |
| try { |
| renderBundleEncoder3.drawIndexed(72); |
| } catch {} |
| try { |
| renderBundleEncoder3.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderBundleEncoder7.setVertexBuffer(0, buffer1, 4140, 4744); |
| } catch {} |
| let arrayBuffer1 = buffer0.getMappedRange(14352, 208); |
| try { |
| device0.queue.writeBuffer(buffer3, 15380, new BigUint64Array(43312), 33893, 2428); |
| } catch {} |
| canvas2.width = 742; |
| let sampler14 = device0.createSampler({ |
| label: '\u0158\u4c88', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 76.709, |
| lodMaxClamp: 81.515, |
| }); |
| try { |
| renderBundleEncoder7.setBindGroup(6, bindGroup2); |
| } catch {} |
| try { |
| renderBundleEncoder3.drawIndirect(buffer3, 31236); |
| } catch {} |
| try { |
| commandEncoder12.copyTextureToBuffer({ |
| texture: texture13, |
| mipLevel: 2, |
| origin: { x: 5, y: 5, z: 0 }, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 48 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 13392 */ |
| offset: 3104, |
| bytesPerRow: 256, |
| buffer: buffer3, |
| }, {width: 15, height: 205, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| commandEncoder8.clearBuffer(buffer3, 30344); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: ['astc-10x10-unorm-srgb', 'rg16uint'], |
| colorSpace: 'srgb', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let pipeline13 = await device0.createComputePipelineAsync({ |
| label: '\u{1fbfa}\uf877\u0a48\u0eb4\u090b\u4114\u{1f975}\u{1fccf}\u{1f958}\u0d6d\u384e', |
| layout: pipelineLayout1, |
| compute: { |
| module: shaderModule0, |
| entryPoint: 'compute0', |
| }, |
| }); |
| canvas2.height = 71; |
| let querySet12 = device0.createQuerySet({ |
| label: '\ucd76\u0039\u{1fd59}\ufc78\u{1ffe7}\u57f2\u06d0\u0d72\u047f\u6975\u{1ff3b}', |
| type: 'occlusion', |
| count: 2712, |
| }); |
| let texture22 = device0.createTexture({ |
| label: '\uf116\u{1fed0}\u7ff0\u0ae3\u0942\u4c2e\u{1ff87}\u76da\u{1ffa1}\u4812\u8878', |
| size: {width: 40}, |
| dimension: '1d', |
| format: 'r32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| viewFormats: ['r32float', 'r32float'], |
| }); |
| let texture23 = gpuCanvasContext0.getCurrentTexture(); |
| let textureView13 = texture3.createView({ |
| label: '\u{1f882}\u7109\u01a1\u7ada\u9dae\u05d9\u{1fba0}\u04a9\ua977\u07fd\uf0bf', |
| dimension: '2d-array', |
| aspect: 'all', |
| format: 'astc-6x6-unorm', |
| baseMipLevel: 7, |
| mipLevelCount: 1 |
| }); |
| let computePassEncoder6 = commandEncoder12.beginComputePass({label: '\u339d\u08c2\u0fc3\u3326\u02bd\uabf3\u798e\u838c\u3479'}); |
| let renderBundleEncoder9 = device0.createRenderBundleEncoder({ |
| label: '\u099a\ufa67\u19a4', |
| colorFormats: ['r16sint', 'r8uint', 'rg16uint', 'r8uint', 'rg32sint', 'r8unorm'], |
| sampleCount: 4 |
| }); |
| try { |
| computePassEncoder4.dispatchWorkgroups(4, 5, 4); |
| } catch {} |
| try { |
| renderBundleEncoder3.draw(8, 56, 8, 56); |
| } catch {} |
| try { |
| renderBundleEncoder3.drawIndexedIndirect(buffer3, 25248); |
| } catch {} |
| try { |
| commandEncoder8.copyBufferToBuffer(buffer4, 15800, buffer3, 19516, 9532); |
| dissociateBuffer(device0, buffer4); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| commandEncoder8.copyTextureToTexture({ |
| texture: texture19, |
| mipLevel: 1, |
| origin: { x: 36, y: 1, z: 51 }, |
| aspect: 'all', |
| }, { |
| texture: texture19, |
| mipLevel: 0, |
| origin: { x: 423, y: 3, z: 54 }, |
| aspect: 'all', |
| }, {width: 296, height: 0, depthOrArrayLayers: 232}); |
| } catch {} |
| let commandEncoder13 = device0.createCommandEncoder({label: '\uf266\udada\u6112\u0e90\uf0bd\u0e5c\u017f\ub664'}); |
| let sampler15 = device0.createSampler({ |
| label: '\u008f\udb6f\u0362', |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| maxAnisotropy: 16, |
| }); |
| try { |
| computePassEncoder6.setBindGroup(0, bindGroup3); |
| } catch {} |
| try { |
| computePassEncoder1.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderBundleEncoder4.setVertexBuffer(0, buffer1, 6204, 9229); |
| } catch {} |
| try { |
| device0.queue.submit([ |
| commandBuffer4, |
| ]); |
| } catch {} |
| let pipeline14 = device0.createComputePipeline({ |
| label: '\u{1ffa6}\u032e\u291e\u3d62\u5c58\u0645\u3fb3\u7e7e\uad53\uf1a1\u7a35', |
| layout: pipelineLayout0, |
| compute: { |
| module: shaderModule0, |
| entryPoint: 'compute0', |
| }, |
| }); |
| let commandEncoder14 = device0.createCommandEncoder({label: '\u5294\u{1f832}\uae68'}); |
| let computePassEncoder7 = commandEncoder14.beginComputePass({}); |
| try { |
| renderBundleEncoder3.draw(24, 80, 8, 80); |
| } catch {} |
| try { |
| commandEncoder13.clearBuffer(buffer3, 34568); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| computePassEncoder1.insertDebugMarker('\u96c8'); |
| } catch {} |
| let imageBitmap3 = await createImageBitmap(video3); |
| try { |
| canvas2.getContext('webgl2'); |
| } catch {} |
| let commandEncoder15 = device0.createCommandEncoder({label: '\u0350\u{1fd71}\u16aa\u7dfe\u08b9\u991f'}); |
| let querySet13 = device0.createQuerySet({ |
| label: '\u0273\u0057\u575a\u6fc0\u0001\u{1f947}\u{1fe4d}\u07c7', |
| type: 'occlusion', |
| count: 3891, |
| }); |
| let renderBundleEncoder10 = device0.createRenderBundleEncoder({ |
| colorFormats: ['rg8unorm', undefined], |
| depthStencilFormat: 'depth32float-stencil8', |
| depthReadOnly: true, |
| stencilReadOnly: true |
| }); |
| try { |
| computePassEncoder7.setBindGroup(5, bindGroup0); |
| } catch {} |
| try { |
| renderBundleEncoder10.setBindGroup(1, bindGroup1); |
| } catch {} |
| try { |
| renderBundleEncoder3.draw(48); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 5448, new BigUint64Array(43672), 19804, 2764); |
| } catch {} |
| let pipeline15 = device0.createComputePipeline({ |
| label: '\u6497\ud46c\u{1f64b}\u426a', |
| layout: pipelineLayout2, |
| compute: { |
| module: shaderModule0, |
| entryPoint: 'compute0', |
| constants: {}, |
| }, |
| }); |
| let canvas3 = document.createElement('canvas'); |
| let textureView14 = texture1.createView({label: '\ubabd\u0900\u{1f8e6}\u114c\u03be\u3405\u944f\u57a2', baseMipLevel: 0, arrayLayerCount: 1}); |
| let computePassEncoder8 = commandEncoder15.beginComputePass({label: '\u{1ff11}\u40af\u{1f6e8}\u17ac\uc35c\u12be\u{1f63d}\u6361\ue4da'}); |
| let renderBundleEncoder11 = device0.createRenderBundleEncoder({ |
| colorFormats: ['rg8unorm', undefined], |
| depthStencilFormat: 'depth32float-stencil8', |
| sampleCount: 1, |
| depthReadOnly: true |
| }); |
| try { |
| computePassEncoder4.dispatchWorkgroupsIndirect(buffer3, 42980); |
| } catch {} |
| try { |
| renderBundleEncoder3.drawIndexed(48); |
| } catch {} |
| try { |
| renderBundleEncoder10.setVertexBuffer(2, buffer1, 15912); |
| } catch {} |
| try { |
| buffer4.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 27088, new BigUint64Array(10375), 6673, 1088); |
| } catch {} |
| let pipeline16 = await promise15; |
| let imageData5 = new ImageData(40, 132); |
| let textureView15 = texture8.createView({label: '\u{1fcd9}\u406c\u{1f6bd}\u0e83', dimension: '2d', arrayLayerCount: 1}); |
| let computePassEncoder9 = commandEncoder8.beginComputePass(); |
| try { |
| computePassEncoder4.setBindGroup(6, bindGroup2); |
| } catch {} |
| try { |
| computePassEncoder8.setBindGroup(1, bindGroup3, new Uint32Array(1468), 1282, 0); |
| } catch {} |
| try { |
| commandEncoder13.copyBufferToBuffer(buffer4, 18880, buffer3, 28800, 9300); |
| dissociateBuffer(device0, buffer4); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 37708, new Float32Array(53906), 31207, 536); |
| } catch {} |
| let promise17 = device0.queue.onSubmittedWorkDone(); |
| let pipeline17 = await device0.createComputePipelineAsync({ |
| label: '\uc816\u072e\u{1f652}\u0f72\u21a8\u{1f8de}\ub316', |
| layout: 'auto', |
| compute: { |
| module: shaderModule0, |
| entryPoint: 'compute0', |
| constants: {}, |
| }, |
| }); |
| try { |
| canvas3.getContext('webgl'); |
| } catch {} |
| let texture24 = device0.createTexture({ |
| label: '\u{1f835}\u9fe9\uf111\u{1fe40}\uf1e2\u{1ffa7}\u8977\u09e5', |
| size: [2272, 18, 1], |
| mipLevelCount: 10, |
| format: 'rg16sint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderBundleEncoder12 = device0.createRenderBundleEncoder({ |
| label: '\u0161\u07ff\u{1fda3}\u{1f6e0}\u03f0\u{1f72d}\u52af', |
| colorFormats: ['rg8unorm', undefined], |
| depthStencilFormat: 'depth32float-stencil8', |
| depthReadOnly: true, |
| stencilReadOnly: true |
| }); |
| try { |
| renderBundleEncoder12.setBindGroup(5, bindGroup1, new Uint32Array(1111), 714, 0); |
| } catch {} |
| try { |
| renderBundleEncoder3.drawIndexed(8, 24, 48, -504, 48); |
| } catch {} |
| try { |
| commandEncoder13.copyTextureToTexture({ |
| texture: texture3, |
| mipLevel: 6, |
| origin: { x: 0, y: 0, z: 1 }, |
| aspect: 'all', |
| }, { |
| texture: texture3, |
| mipLevel: 5, |
| origin: { x: 6, y: 6, z: 0 }, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 35280, new DataView(new ArrayBuffer(64442)), 59702); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture3, |
| mipLevel: 2, |
| origin: { x: 0, y: 6, z: 0 }, |
| aspect: 'all', |
| }, new ArrayBuffer(2006), /* required buffer size: 2006 */ |
| {offset: 511, bytesPerRow: 133}, {width: 12, height: 72, depthOrArrayLayers: 1}); |
| } catch {} |
| let pipeline18 = await device0.createRenderPipelineAsync({ |
| label: '\u64f2\u{1f66b}\u73e2\u289d', |
| layout: pipelineLayout0, |
| fragment: { |
| module: shaderModule0, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{ |
| format: 'rg8unorm', |
| blend: { |
| color: {operation: 'subtract', srcFactor: 'one-minus-dst', dstFactor: 'one-minus-dst-alpha'}, |
| alpha: {operation: 'reverse-subtract', srcFactor: 'src', dstFactor: 'zero'}, |
| }, |
| writeMask: GPUColorWrite.RED |
| }, undefined] |
| }, |
| depthStencil: { |
| format: 'depth24plus-stencil8', |
| depthWriteEnabled: true, |
| depthCompare: 'not-equal', |
| stencilFront: { |
| compare: 'not-equal', |
| failOp: 'increment-wrap', |
| depthFailOp: 'increment-wrap', |
| passOp: 'decrement-clamp', |
| }, |
| stencilBack: { |
| compare: 'less-equal', |
| failOp: 'increment-clamp', |
| depthFailOp: 'invert', |
| passOp: 'zero', |
| }, |
| stencilWriteMask: 4050, |
| depthBiasSlopeScale: 13, |
| depthBiasClamp: 65, |
| }, |
| vertex: { |
| module: shaderModule0, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 2940, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'unorm8x2', |
| offset: 1932, |
| shaderLocation: 1, |
| }, { |
| format: 'sint8x2', |
| offset: 72, |
| shaderLocation: 4, |
| }, { |
| format: 'sint8x4', |
| offset: 1568, |
| shaderLocation: 12, |
| }, { |
| format: 'uint8x4', |
| offset: 988, |
| shaderLocation: 2, |
| }, { |
| format: 'uint32x2', |
| offset: 2660, |
| shaderLocation: 10, |
| }, { |
| format: 'uint16x4', |
| offset: 72, |
| shaderLocation: 5, |
| }, { |
| format: 'unorm8x2', |
| offset: 1272, |
| shaderLocation: 0, |
| }, { |
| format: 'uint8x2', |
| offset: 2530, |
| shaderLocation: 11, |
| }, { |
| format: 'sint16x2', |
| offset: 2772, |
| shaderLocation: 7, |
| }, { |
| format: 'uint16x4', |
| offset: 584, |
| shaderLocation: 9, |
| }, { |
| format: 'float32x2', |
| offset: 176, |
| shaderLocation: 15, |
| }, { |
| format: 'uint32x2', |
| offset: 2896, |
| shaderLocation: 13, |
| }, { |
| format: 'snorm16x2', |
| offset: 2316, |
| shaderLocation: 3, |
| }, { |
| format: 'uint32x4', |
| offset: 2516, |
| shaderLocation: 6, |
| }, { |
| format: 'float32x4', |
| offset: 884, |
| shaderLocation: 14, |
| }], |
| }, |
| { |
| arrayStride: 11232, |
| stepMode: 'instance', |
| attributes: [{ |
| format: 'snorm8x2', |
| offset: 5336, |
| shaderLocation: 8, |
| }], |
| } |
| ] |
| }, |
| primitive: { |
| frontFace: 'cw', |
| cullMode: 'back', |
| unclippedDepth: true, |
| }, |
| }); |
| try { |
| adapter1.label = '\u032d\u{1f8ce}\u032d\u0fd4\ue4c3\u126d\u024d'; |
| } catch {} |
| let texture25 = device0.createTexture({ |
| label: '\u{1f8f7}\u2275\u683d\u0878', |
| size: [10], |
| sampleCount: 1, |
| dimension: '1d', |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['r8sint'], |
| }); |
| let textureView16 = texture17.createView({label: '\u{1fa58}\u0658\u6c42', dimension: '2d-array', format: 'astc-8x6-unorm', mipLevelCount: 2}); |
| let sampler16 = device0.createSampler({ |
| label: '\u0309\ua8c6', |
| addressModeW: 'repeat', |
| lodMinClamp: 78.827, |
| lodMaxClamp: 93.666, |
| }); |
| try { |
| renderBundleEncoder11.setVertexBuffer(4, buffer1, 8648); |
| } catch {} |
| try { |
| await buffer5.mapAsync(GPUMapMode.WRITE, 0, 24216); |
| } catch {} |
| try { |
| await promise11; |
| } catch {} |
| let bindGroupLayout9 = device0.createBindGroupLayout({ |
| label: '\u296a\u4dfb\u7393\uf1c0\u9e05', |
| entries: [{ |
| binding: 791, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| sampler: { type: 'filtering' }, |
| }, { |
| binding: 4085, |
| visibility: GPUShaderStage.VERTEX, |
| externalTexture: {}, |
| }, { |
| binding: 4664, |
| visibility: GPUShaderStage.COMPUTE, |
| texture: { viewDimension: '2d-array', sampleType: 'sint', multisampled: false }, |
| }], |
| }); |
| let bindGroup4 = device0.createBindGroup({ |
| label: '\u87b0\u{1fc12}\u7752', |
| layout: bindGroupLayout6, |
| entries: [{ |
| binding: 1160, |
| resource: externalTexture0 |
| }], |
| }); |
| let querySet14 = device0.createQuerySet({ |
| label: '\u0bbf\uda98\u0aed\u016a\u{1ff8d}\u000d\u00f2\u97fc', |
| type: 'occlusion', |
| count: 2373, |
| }); |
| let textureView17 = texture5.createView({ |
| label: '\u{1f724}\u0dbb\uc98b\uda7b\u8af4\u8955\u0840\u0f52\u52d9\ub34e\uf990', |
| dimension: '3d', |
| baseMipLevel: 3, |
| baseArrayLayer: 0 |
| }); |
| let computePassEncoder10 = commandEncoder13.beginComputePass(); |
| try { |
| computePassEncoder8.setBindGroup(4, bindGroup3, new Uint32Array(4953), 434, 0); |
| } catch {} |
| try { |
| computePassEncoder7.setPipeline(pipeline13); |
| } catch {} |
| try { |
| renderBundleEncoder3.drawIndexedIndirect(buffer3, 36928); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 9108, new Int16Array(2778)); |
| } catch {} |
| let offscreenCanvas4 = new OffscreenCanvas(957, 199); |
| let querySet15 = device0.createQuerySet({ |
| type: 'occlusion', |
| count: 3460, |
| }); |
| let texture26 = device0.createTexture({ |
| label: '\u0149\ua851\u2e2f\u{1f62f}\u0b2a\u{1f956}', |
| size: {width: 3520}, |
| dimension: '1d', |
| format: 'rg16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| viewFormats: ['rg16uint', 'rg16uint'], |
| }); |
| try { |
| renderBundleEncoder3.setBindGroup(4, bindGroup4, []); |
| } catch {} |
| try { |
| renderBundleEncoder3.drawIndexed(80, 24, 80); |
| } catch {} |
| try { |
| renderBundleEncoder3.drawIndexedIndirect(buffer3, 40872); |
| } catch {} |
| try { |
| renderBundleEncoder3.drawIndirect(buffer3, 30992); |
| } catch {} |
| let offscreenCanvas5 = new OffscreenCanvas(316, 383); |
| let texture27 = device0.createTexture({ |
| label: '\u64af\u{1f629}\u95bb\u0ebd', |
| size: [2884, 192, 1], |
| mipLevelCount: 2, |
| format: 'depth32float-stencil8', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['depth32float-stencil8', 'depth32float-stencil8'], |
| }); |
| try { |
| renderBundleEncoder3.draw(24, 56, 32, 40); |
| } catch {} |
| try { |
| renderBundleEncoder3.drawIndirect(buffer3, 34680); |
| } catch {} |
| try { |
| querySet1.destroy(); |
| } catch {} |
| let pipeline19 = await device0.createComputePipelineAsync({ |
| label: '\u6d11\uc8e2\ue5bd\ud43c\u3395\u6bb0\u038c\u017f\u0a10\u0490\u{1ff97}', |
| layout: pipelineLayout0, |
| compute: { |
| module: shaderModule0, |
| entryPoint: 'compute0', |
| constants: {}, |
| }, |
| }); |
| try { |
| offscreenCanvas3.getContext('webgl'); |
| } catch {} |
| let bindGroup5 = device0.createBindGroup({ |
| label: '\u50e7\u0d7e\u0ccb\u{1fa6f}\u087e\ue542\u00d9\u4564\u{1f8ff}', |
| layout: bindGroupLayout4, |
| entries: [], |
| }); |
| let querySet16 = device0.createQuerySet({ |
| label: '\u6947\ueb33\u3cca\u{1fe0b}\u2394\u0fc2\u1bf1\u008b\u8b63', |
| type: 'occlusion', |
| count: 3902, |
| }); |
| let texture28 = device0.createTexture({ |
| label: '\u5b2c\uab5e\u0bbc\u5a7b\ue292\u0e29\ueba3', |
| size: {width: 80, height: 960, depthOrArrayLayers: 1}, |
| mipLevelCount: 10, |
| format: 'astc-8x8-unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['astc-8x8-unorm-srgb', 'astc-8x8-unorm', 'astc-8x8-unorm-srgb'], |
| }); |
| try { |
| renderBundleEncoder4.setBindGroup(6, bindGroup4); |
| } catch {} |
| try { |
| renderBundleEncoder3.setBindGroup(3, bindGroup3, new Uint32Array(3700), 1963, 0); |
| } catch {} |
| try { |
| renderBundleEncoder3.drawIndexed(80, 72); |
| } catch {} |
| try { |
| buffer4.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 34200, new Float32Array(3258), 1933); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let pipeline20 = device0.createRenderPipeline({ |
| label: '\u04a5\uda1d\u{1f860}\u{1fbc1}', |
| layout: pipelineLayout0, |
| multisample: { |
| mask: 0x59685ccd, |
| }, |
| fragment: { |
| module: shaderModule0, |
| entryPoint: 'fragment0', |
| targets: [{format: 'rg8unorm', writeMask: GPUColorWrite.ALL}, undefined] |
| }, |
| depthStencil: { |
| format: 'depth24plus-stencil8', |
| depthWriteEnabled: true, |
| depthCompare: 'less', |
| stencilFront: { |
| compare: 'less', |
| failOp: 'decrement-wrap', |
| depthFailOp: 'decrement-clamp', |
| passOp: 'zero', |
| }, |
| stencilBack: { |
| compare: 'less', |
| failOp: 'zero', |
| depthFailOp: 'increment-wrap', |
| passOp: 'decrement-wrap', |
| }, |
| stencilReadMask: 744, |
| stencilWriteMask: 666, |
| depthBiasSlopeScale: 50, |
| depthBiasClamp: 11, |
| }, |
| vertex: { |
| module: shaderModule0, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 5428, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'snorm16x2', |
| offset: 3788, |
| shaderLocation: 15, |
| }, { |
| format: 'unorm8x2', |
| offset: 4736, |
| shaderLocation: 8, |
| }, { |
| format: 'sint32x3', |
| offset: 204, |
| shaderLocation: 12, |
| }, { |
| format: 'uint16x2', |
| offset: 2796, |
| shaderLocation: 2, |
| }, { |
| format: 'uint16x4', |
| offset: 2532, |
| shaderLocation: 13, |
| }, { |
| format: 'unorm16x4', |
| offset: 5352, |
| shaderLocation: 14, |
| }, { |
| format: 'uint16x4', |
| offset: 2008, |
| shaderLocation: 9, |
| }, { |
| format: 'uint8x4', |
| offset: 4800, |
| shaderLocation: 5, |
| }, { |
| format: 'uint32x4', |
| offset: 2220, |
| shaderLocation: 6, |
| }, { |
| format: 'snorm16x2', |
| offset: 3132, |
| shaderLocation: 3, |
| }, { |
| format: 'uint16x2', |
| offset: 1104, |
| shaderLocation: 11, |
| }, { |
| format: 'float32x4', |
| offset: 2972, |
| shaderLocation: 1, |
| }, { |
| format: 'sint32x4', |
| offset: 5088, |
| shaderLocation: 7, |
| }, { |
| format: 'sint16x2', |
| offset: 4028, |
| shaderLocation: 4, |
| }], |
| }, |
| { |
| arrayStride: 7336, |
| attributes: [{ |
| format: 'unorm16x4', |
| offset: 3924, |
| shaderLocation: 0, |
| }, { |
| format: 'uint32x2', |
| offset: 4816, |
| shaderLocation: 10, |
| }], |
| } |
| ] |
| }, |
| primitive: { |
| topology: 'triangle-strip', |
| stripIndexFormat: 'uint16', |
| frontFace: 'cw', |
| cullMode: 'front', |
| }, |
| }); |
| try { |
| offscreenCanvas4.getContext('webgl'); |
| } catch {} |
| let bindGroup6 = device0.createBindGroup({ |
| label: '\u{1f72d}\u5b3c\ufb8c\u348c', |
| layout: bindGroupLayout7, |
| entries: [{ |
| binding: 1160, |
| resource: externalTexture0 |
| }], |
| }); |
| try { |
| computePassEncoder4.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderBundleEncoder12.setBindGroup(0, bindGroup4); |
| } catch {} |
| try { |
| renderBundleEncoder3.setPipeline(pipeline8); |
| } catch {} |
| let bindGroup7 = device0.createBindGroup({ |
| label: '\u6887\u{1fe85}\u{1fe29}\u{1ff06}\u0b9b', |
| layout: bindGroupLayout6, |
| entries: [{ |
| binding: 1160, |
| resource: externalTexture0 |
| }], |
| }); |
| let textureView18 = texture4.createView({label: '\u4d57\u7642\u{1fad4}\u{1ff8d}\u{1fbc1}\u{1f90d}\uc83e', mipLevelCount: 1}); |
| try { |
| computePassEncoder8.setBindGroup(1, bindGroup4, new Uint32Array(6109), 5689, 0); |
| } catch {} |
| try { |
| computePassEncoder9.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderBundleEncoder3.drawIndexedIndirect(buffer3, 10432); |
| } catch {} |
| try { |
| renderBundleEncoder3.drawIndirect(buffer3, 14836); |
| } catch {} |
| let arrayBuffer2 = buffer0.getMappedRange(15680, 720); |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let gpuCanvasContext2 = offscreenCanvas5.getContext('webgpu'); |
| let bindGroup8 = device0.createBindGroup({ |
| label: '\u9acb\uc0bc\u{1ffde}\u0c76\u3178\u{1fb49}\u0e69', |
| layout: bindGroupLayout6, |
| entries: [{ |
| binding: 1160, |
| resource: externalTexture0 |
| }], |
| }); |
| let sampler17 = device0.createSampler({ |
| label: '\ubb08\u3583\u3dc0\u01a4\udb2f\uc977', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| lodMaxClamp: 91.521, |
| }); |
| try { |
| renderBundleEncoder3.drawIndexed(24, 80); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 29496, new Int16Array(63324), 22784, 452); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let canvas4 = document.createElement('canvas'); |
| let textureView19 = texture2.createView({label: '\u0e8a\u5945\u{1fa81}\u5514\u{1f6af}\u0673\ueef3\u0497', format: 'rg32sint'}); |
| try { |
| renderBundleEncoder8.setVertexBuffer(4, buffer1, 3520, 43); |
| } catch {} |
| try { |
| device0.pushErrorScope('validation'); |
| } catch {} |
| let pipeline21 = device0.createComputePipeline({ |
| layout: pipelineLayout0, |
| compute: { |
| module: shaderModule0, |
| entryPoint: 'compute0', |
| constants: {}, |
| }, |
| }); |
| try { |
| await promise5; |
| } catch {} |
| let offscreenCanvas6 = new OffscreenCanvas(412, 410); |
| let img1 = await imageWithData(166, 100, '#bb957b22', '#1de26573'); |
| let textureView20 = texture15.createView({label: '\u0a6f\u109e\u{1fdbf}\u095f', format: 'rgb10a2unorm'}); |
| try { |
| computePassEncoder4.dispatchWorkgroups(2, 5); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture3, |
| mipLevel: 2, |
| origin: { x: 0, y: 42, z: 0 }, |
| aspect: 'all', |
| }, new Float64Array(arrayBuffer0), /* required buffer size: 743 */ |
| {offset: 563, bytesPerRow: 41, rowsPerImage: 275}, {width: 6, height: 30, depthOrArrayLayers: 1}); |
| } catch {} |
| let promise18 = device0.queue.onSubmittedWorkDone(); |
| let gpuCanvasContext3 = canvas4.getContext('webgpu'); |
| let canvas5 = document.createElement('canvas'); |
| let renderBundleEncoder13 = device0.createRenderBundleEncoder({ |
| label: '\u{1fc30}\uf0c6\u2159\u83b3\u7b52', |
| colorFormats: ['rg8unorm', undefined], |
| depthStencilFormat: 'depth32float-stencil8', |
| depthReadOnly: true |
| }); |
| try { |
| computePassEncoder9.setBindGroup(2, bindGroup2, new Uint32Array(8817), 5857, 0); |
| } catch {} |
| try { |
| computePassEncoder8.setPipeline(pipeline14); |
| } catch {} |
| try { |
| renderBundleEncoder3.drawIndirect(buffer3, 16544); |
| } catch {} |
| let pipeline22 = device0.createComputePipeline({ |
| label: '\uc4db\u0593\u0e98\u08a1\u74c3\ua2b7\ub04e', |
| layout: pipelineLayout2, |
| compute: { |
| module: shaderModule0, |
| entryPoint: 'compute0', |
| constants: {}, |
| }, |
| }); |
| try { |
| if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(0x55) }; |
| } catch {} |
| document.body.prepend(canvas4); |
| gc(); |
| let bindGroupLayout10 = pipeline7.getBindGroupLayout(0); |
| let pipelineLayout3 = device0.createPipelineLayout({bindGroupLayouts: [bindGroupLayout0, bindGroupLayout3, bindGroupLayout7, bindGroupLayout1]}); |
| let commandEncoder16 = device0.createCommandEncoder(); |
| let renderBundle13 = renderBundleEncoder3.finish({label: '\u29cb\ud96f\u{1fbe0}\u4c72\u{1f7c4}\u3320\u8dff\ubb3d'}); |
| let sampler18 = device0.createSampler({ |
| label: '\u0f3f\uc769\u0a1d\u003c\u0795', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| lodMinClamp: 17.112, |
| lodMaxClamp: 44.378, |
| }); |
| try { |
| renderBundleEncoder13.setPipeline(pipeline8); |
| } catch {} |
| try { |
| commandEncoder16.copyBufferToBuffer(buffer1, 9720, buffer3, 2588, 2812); |
| dissociateBuffer(device0, buffer1); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| let pipeline23 = device0.createComputePipeline({ |
| label: '\uaded\u132a', |
| layout: pipelineLayout2, |
| compute: { |
| module: shaderModule0, |
| entryPoint: 'compute0', |
| constants: {}, |
| }, |
| }); |
| try { |
| await promise12; |
| } catch {} |
| video4.width = 52; |
| try { |
| canvas5.getContext('webgl2'); |
| } catch {} |
| let shaderModule1 = device0.createShaderModule({ |
| label: '\uf1f2\u9c64\u{1fd36}\u0230\u{1fd4c}\u782c\u{1fd04}\u0450', |
| code: `@group(3) @binding(1646) |
| var<storage, read_write> field0: array<u32>; |
| @group(3) @binding(3641) |
| var<storage, read_write> local0: array<u32>; |
| @group(2) @binding(1160) |
| var<storage, read_write> type0: array<u32>; |
| |
| @compute @workgroup_size(2, 1, 2) |
| fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {} |
| |
| struct S3 { |
| @location(33) f0: vec3<i32> |
| } |
| struct FragmentOutput0 { |
| @location(2) f0: vec4<u32>, |
| @location(5) f1: vec3<f32>, |
| @location(3) f2: vec4<u32>, |
| @location(0) f3: vec4<i32>, |
| @location(1) f4: vec4<u32>, |
| @location(4) f5: vec3<i32> |
| } |
| |
| @fragment |
| fn fragment0(@location(12) a0: vec2<f32>, @location(70) a1: f32, @location(41) a2: vec2<u32>, @location(35) a3: u32, @location(25) a4: vec2<f16>, @location(43) a5: vec2<f32>, @location(32) a6: vec3<f16>, a7: S3, @location(15) a8: vec4<f32>) -> FragmentOutput0 { |
| return FragmentOutput0(); |
| } |
| |
| struct S2 { |
| @location(7) f0: vec4<f16>, |
| @location(2) f1: f32, |
| @location(8) f2: vec4<u32>, |
| @location(4) f3: i32, |
| @location(3) f4: u32 |
| } |
| struct VertexOutput0 { |
| @location(84) f27: vec2<f32>, |
| @location(64) f28: vec4<u32>, |
| @location(96) f29: vec2<f32>, |
| @builtin(position) f30: vec4<f32>, |
| @location(85) f31: f16, |
| @location(48) f32: vec2<i32>, |
| @location(12) f33: vec2<f32>, |
| @location(41) f34: vec2<u32>, |
| @location(52) f35: vec3<f32>, |
| @location(50) f36: f16, |
| @location(67) f37: vec3<i32>, |
| @location(51) f38: vec4<u32>, |
| @location(32) f39: vec3<f16>, |
| @location(35) f40: u32, |
| @location(109) f41: vec2<f32>, |
| @location(33) f42: vec3<i32>, |
| @location(86) f43: vec2<i32>, |
| @location(10) f44: f16, |
| @location(70) f45: f32, |
| @location(77) f46: vec4<f32>, |
| @location(25) f47: vec2<f16>, |
| @location(55) f48: vec3<f32>, |
| @location(43) f49: vec2<f32>, |
| @location(15) f50: vec4<f32>, |
| @location(105) f51: vec3<f32>, |
| @location(68) f52: f16, |
| @location(24) f53: f16, |
| @location(83) f54: vec4<f32> |
| } |
| |
| @vertex |
| fn vertex0(@location(6) a0: vec2<i32>, a1: S2, @location(1) a2: f32, @location(9) a3: i32, @location(0) a4: vec2<i32>, @location(11) a5: vec4<f32>, @location(14) a6: vec3<i32>) -> VertexOutput0 { |
| return VertexOutput0(); |
| } |
| |
| `, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| let pipelineLayout4 = device0.createPipelineLayout({ |
| label: '\u8a07\u01e4\u{1f986}\u{1f630}', |
| bindGroupLayouts: [bindGroupLayout6, bindGroupLayout4, bindGroupLayout7] |
| }); |
| let commandEncoder17 = device0.createCommandEncoder({label: '\u028e\u568b\u2521\u6187\uc279\u{1f996}'}); |
| let texture29 = device0.createTexture({ |
| size: [40, 480, 1], |
| mipLevelCount: 9, |
| format: 'astc-8x6-unorm', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView21 = texture20.createView({ |
| label: '\u{1f738}\u{1f8eb}\u0f9c\u{1fd59}\u06c0\ua66a\u0967\u{1fa1e}', |
| dimension: '2d', |
| aspect: 'all', |
| baseMipLevel: 6 |
| }); |
| let renderBundle14 = renderBundleEncoder5.finish({label: '\u07bf\u0909\ud930\u{1f899}\ud48f\u886b'}); |
| try { |
| renderBundleEncoder8.setBindGroup(5, bindGroup1); |
| } catch {} |
| try { |
| commandEncoder16.copyTextureToBuffer({ |
| texture: texture25, |
| mipLevel: 0, |
| origin: { x: 0, y: 0, z: 1 }, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 8 widthInBlocks: 8 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 35285 */ |
| offset: 35285, |
| buffer: buffer3, |
| }, {width: 8, height: 1, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| let promise19 = device0.createRenderPipelineAsync({ |
| label: '\u{1fad2}\u0ccf\u0b0c\u4d32\u7f86\u03dd\u2ef9\u{1fb2f}\ue8da', |
| layout: pipelineLayout0, |
| multisample: { |
| mask: 0x93dec81f, |
| }, |
| fragment: { |
| module: shaderModule1, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{format: 'r16sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE}, {format: 'r8uint', writeMask: GPUColorWrite.ALL}, {format: 'rg16uint'}, {format: 'r8uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN | GPUColorWrite.RED}, {format: 'rg32sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.RED}, {format: 'r8unorm', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN}] |
| }, |
| depthStencil: { |
| format: 'depth32float-stencil8', |
| depthWriteEnabled: false, |
| depthCompare: 'equal', |
| stencilFront: { |
| compare: 'less-equal', |
| failOp: 'increment-wrap', |
| depthFailOp: 'zero', |
| }, |
| stencilBack: { |
| compare: 'never', |
| failOp: 'increment-wrap', |
| depthFailOp: 'replace', |
| passOp: 'invert', |
| }, |
| stencilReadMask: 1384, |
| stencilWriteMask: 993, |
| depthBiasSlopeScale: 27, |
| depthBiasClamp: 39, |
| }, |
| vertex: { |
| module: shaderModule1, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 12792, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'uint32', |
| offset: 6096, |
| shaderLocation: 8, |
| }, { |
| format: 'sint32x4', |
| offset: 504, |
| shaderLocation: 9, |
| }, { |
| format: 'float32', |
| offset: 8572, |
| shaderLocation: 11, |
| }, { |
| format: 'snorm8x4', |
| offset: 6668, |
| shaderLocation: 2, |
| }, { |
| format: 'sint32x4', |
| offset: 4320, |
| shaderLocation: 6, |
| }, { |
| format: 'sint32x3', |
| offset: 9804, |
| shaderLocation: 14, |
| }, { |
| format: 'sint8x2', |
| offset: 3404, |
| shaderLocation: 0, |
| }, { |
| format: 'unorm10-10-10-2', |
| offset: 3436, |
| shaderLocation: 7, |
| }, { |
| format: 'uint32x4', |
| offset: 428, |
| shaderLocation: 3, |
| }, { |
| format: 'float32x4', |
| offset: 2932, |
| shaderLocation: 1, |
| }, { |
| format: 'sint16x4', |
| offset: 4652, |
| shaderLocation: 4, |
| }], |
| } |
| ] |
| }, |
| primitive: { |
| topology: 'triangle-strip', |
| stripIndexFormat: 'uint32', |
| frontFace: 'cw', |
| cullMode: 'back', |
| }, |
| }); |
| gc(); |
| let textureView22 = texture10.createView({baseMipLevel: 2, mipLevelCount: 2}); |
| let computePassEncoder11 = commandEncoder17.beginComputePass({label: '\u09b8\u{1fe04}\u062f\u0987\u7b5f\u{1fb18}\u071f\ua687'}); |
| try { |
| renderBundleEncoder7.setBindGroup(2, bindGroup3); |
| } catch {} |
| try { |
| renderBundleEncoder13.drawIndexedIndirect(buffer3, 23808); |
| } catch {} |
| try { |
| renderBundleEncoder13.drawIndirect(buffer3, 29732); |
| } catch {} |
| try { |
| commandEncoder16.clearBuffer(buffer3); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| let pipeline24 = device0.createComputePipeline({ |
| layout: pipelineLayout0, |
| compute: { |
| module: shaderModule0, |
| entryPoint: 'compute0', |
| }, |
| }); |
| gc(); |
| let videoFrame4 = new VideoFrame(offscreenCanvas5, {timestamp: 0}); |
| let pipelineLayout5 = device0.createPipelineLayout({ |
| label: '\u{1ff40}\uc427\u{1fcef}\u{1fa53}\u{1fdd1}\u0a2f\u575f\ub2b6\u{1f717}\u0794\uafed', |
| bindGroupLayouts: [bindGroupLayout7, bindGroupLayout2] |
| }); |
| let buffer6 = device0.createBuffer({ |
| label: '\u05d1\udbb0\u0766\u{1f860}\u{1ffaf}', |
| size: 65440, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE, |
| mappedAtCreation: true |
| }); |
| try { |
| renderBundleEncoder13.drawIndexed(32, 48, 80, 56, 24); |
| } catch {} |
| try { |
| renderBundleEncoder13.drawIndexedIndirect(buffer3, 504); |
| } catch {} |
| let arrayBuffer3 = buffer6.getMappedRange(62256, 164); |
| try { |
| commandEncoder16.copyTextureToTexture({ |
| texture: texture12, |
| mipLevel: 0, |
| origin: { x: 1512, y: 72, z: 223 }, |
| aspect: 'all', |
| }, { |
| texture: texture12, |
| mipLevel: 3, |
| origin: { x: 72, y: 0, z: 115 }, |
| aspect: 'all', |
| }, {width: 276, height: 12, depthOrArrayLayers: 24}); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: ['rgba32uint', 'rgba16float', 'rgba16float', 'rgba16float'], |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| let pipeline25 = device0.createComputePipeline({ |
| layout: pipelineLayout0, |
| compute: { |
| module: shaderModule1, |
| entryPoint: 'compute0', |
| }, |
| }); |
| let adapter2 = await promise1; |
| let img2 = await imageWithData(148, 33, '#794715f9', '#300f6f4b'); |
| try { |
| querySet14.label = '\ubebb\ub0cf\uda69'; |
| } catch {} |
| let renderBundleEncoder14 = device0.createRenderBundleEncoder({ |
| label: '\ud45d\u{1f7a2}\ucc48\u{1f60e}\u{1f862}\u{1f8b1}\u{1f811}\uf3c0\u7357\u02ad', |
| colorFormats: ['r16sint', 'r8uint', 'rg16uint', 'r8uint', 'rg32sint', 'r8unorm'], |
| sampleCount: 4 |
| }); |
| try { |
| computePassEncoder4.setBindGroup(0, bindGroup0); |
| } catch {} |
| try { |
| computePassEncoder7.dispatchWorkgroups(4, 4); |
| } catch {} |
| try { |
| renderBundleEncoder13.draw(80, 64); |
| } catch {} |
| try { |
| computePassEncoder1.pushDebugGroup('\uca5f'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 11036, new BigUint64Array(63781), 29020, 120); |
| } catch {} |
| let pipeline26 = await device0.createRenderPipelineAsync({ |
| label: '\ub7c8\u{1f92d}\u9d44\u033c\u09ba\u8507\u85a7\u{1fe0d}\u{1f7d3}\ua666\u6fc0', |
| layout: pipelineLayout5, |
| multisample: { |
| mask: 0xc2cc0429, |
| }, |
| fragment: { |
| module: shaderModule1, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{format: 'r16sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN | GPUColorWrite.RED}, {format: 'r8uint'}, { |
| format: 'rg16uint', |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED |
| }, {format: 'r8uint', writeMask: 0}, {format: 'rg32sint', writeMask: 0}, { |
| format: 'r8unorm', |
| blend: { |
| color: {operation: 'reverse-subtract', srcFactor: 'one-minus-dst-alpha', dstFactor: 'dst-alpha'}, |
| alpha: {operation: 'add', srcFactor: 'one-minus-src-alpha', dstFactor: 'src-alpha-saturated'}, |
| } |
| }] |
| }, |
| depthStencil: { |
| format: 'depth32float-stencil8', |
| depthWriteEnabled: false, |
| depthCompare: 'never', |
| stencilFront: { |
| compare: 'greater', |
| failOp: 'decrement-wrap', |
| passOp: 'decrement-wrap', |
| }, |
| stencilBack: { |
| compare: 'less-equal', |
| depthFailOp: 'increment-wrap', |
| passOp: 'increment-clamp', |
| }, |
| stencilReadMask: 4064, |
| stencilWriteMask: 3196, |
| depthBias: 92, |
| depthBiasSlopeScale: 87, |
| depthBiasClamp: 80, |
| }, |
| vertex: { |
| module: shaderModule1, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 15240, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'snorm8x2', |
| offset: 12212, |
| shaderLocation: 7, |
| }, { |
| format: 'sint8x2', |
| offset: 12550, |
| shaderLocation: 0, |
| }, { |
| format: 'snorm16x2', |
| offset: 11044, |
| shaderLocation: 1, |
| }, { |
| format: 'float16x2', |
| offset: 476, |
| shaderLocation: 11, |
| }, { |
| format: 'sint16x2', |
| offset: 10872, |
| shaderLocation: 9, |
| }], |
| }, |
| { |
| arrayStride: 10052, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'float32x2', |
| offset: 1972, |
| shaderLocation: 2, |
| }, { |
| format: 'uint8x2', |
| offset: 382, |
| shaderLocation: 8, |
| }, { |
| format: 'sint8x2', |
| offset: 3060, |
| shaderLocation: 6, |
| }, { |
| format: 'sint16x4', |
| offset: 9404, |
| shaderLocation: 4, |
| }], |
| }, |
| { |
| arrayStride: 3720, |
| stepMode: 'vertex', |
| attributes: [], |
| }, |
| { |
| arrayStride: 0, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'uint16x4', |
| offset: 10560, |
| shaderLocation: 3, |
| }, { |
| format: 'sint16x2', |
| offset: 4428, |
| shaderLocation: 14, |
| }], |
| } |
| ] |
| }, |
| primitive: { |
| topology: 'line-list', |
| cullMode: 'back', |
| unclippedDepth: true, |
| }, |
| }); |
| try { |
| await promise16; |
| } catch {} |
| let adapter3 = await promise0; |
| let textureView23 = texture5.createView({baseMipLevel: 0, mipLevelCount: 3}); |
| try { |
| computePassEncoder9.setBindGroup(6, bindGroup3); |
| } catch {} |
| try { |
| renderBundleEncoder7.setBindGroup(0, bindGroup2); |
| } catch {} |
| try { |
| renderBundleEncoder13.draw(48, 48); |
| } catch {} |
| try { |
| renderBundleEncoder13.drawIndexed(8); |
| } catch {} |
| try { |
| renderBundleEncoder13.drawIndirect(buffer3, 16460); |
| } catch {} |
| try { |
| renderBundleEncoder7.setVertexBuffer(5, buffer1, 15276, 439); |
| } catch {} |
| let promise20 = device0.popErrorScope(); |
| let gpuCanvasContext4 = offscreenCanvas6.getContext('webgpu'); |
| let promise21 = navigator.gpu.requestAdapter({ |
| }); |
| let canvas6 = document.createElement('canvas'); |
| let bindGroupLayout11 = device0.createBindGroupLayout({ |
| label: '\u0e38\u055e\uc42e\ua7b5\u0792', |
| entries: [{ |
| binding: 1548, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d-array', sampleType: 'sint', multisampled: false }, |
| }], |
| }); |
| let bindGroup9 = device0.createBindGroup({ |
| label: '\u{1fcea}\u0044\u{1fc21}\u061d', |
| layout: bindGroupLayout7, |
| entries: [{ |
| binding: 1160, |
| resource: externalTexture0 |
| }], |
| }); |
| let buffer7 = device0.createBuffer({size: 40176, usage: GPUBufferUsage.MAP_READ}); |
| let commandEncoder18 = device0.createCommandEncoder({}); |
| let texture30 = device0.createTexture({ |
| label: '\u245d\u62f6\ubb21\u9f18\u1321\u{1fbdb}', |
| size: {width: 10}, |
| dimension: '1d', |
| format: 'r16float', |
| usage: GPUTextureUsage.COPY_DST, |
| viewFormats: ['r16float'], |
| }); |
| let renderBundle15 = renderBundleEncoder13.finish({label: '\u0b39\u353d\u069a\u{1fd35}\u{1f8e5}\u{1fa99}\u09b8\u0614'}); |
| try { |
| renderBundleEncoder9.setBindGroup(0, bindGroup4); |
| } catch {} |
| let arrayBuffer4 = buffer6.getMappedRange(62424, 2660); |
| try { |
| commandEncoder16.copyTextureToTexture({ |
| texture: texture12, |
| mipLevel: 1, |
| origin: { x: 288, y: 12, z: 198 }, |
| aspect: 'all', |
| }, { |
| texture: texture12, |
| mipLevel: 2, |
| origin: { x: 12, y: 0, z: 91 }, |
| aspect: 'all', |
| }, {width: 684, height: 24, depthOrArrayLayers: 5}); |
| } catch {} |
| try { |
| computePassEncoder1.popDebugGroup(); |
| } catch {} |
| try { |
| gpuCanvasContext4.unconfigure(); |
| } catch {} |
| let textureView24 = texture12.createView({label: '\uc17e\u9190', baseMipLevel: 1, mipLevelCount: 2, baseArrayLayer: 100, arrayLayerCount: 20}); |
| let renderBundleEncoder15 = device0.createRenderBundleEncoder({ |
| label: '\u5855\u{1ff81}', |
| colorFormats: ['rg8unorm', undefined], |
| depthStencilFormat: 'depth32float-stencil8' |
| }); |
| try { |
| computePassEncoder6.setPipeline(pipeline10); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture18, |
| mipLevel: 5, |
| origin: { x: 4, y: 0, z: 1 }, |
| aspect: 'all', |
| }, arrayBuffer2, /* required buffer size: 467 */ |
| {offset: 467, rowsPerImage: 90}, {width: 13, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline27 = device0.createRenderPipeline({ |
| label: '\u9dce\u{1fddc}\ue712\ub69b\u929b\u{1fe66}\u{1f6ff}\u28b9\u{1fd1f}\uf474', |
| layout: pipelineLayout5, |
| fragment: { |
| module: shaderModule1, |
| entryPoint: 'fragment0', |
| targets: [{ |
| format: 'r16sint', |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED |
| }, {format: 'r8uint', writeMask: 0}, {format: 'rg16uint', writeMask: 0}, {format: 'r8uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN}, {format: 'rg32sint', writeMask: 0}, {format: 'r8unorm', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN}] |
| }, |
| depthStencil: { |
| format: 'stencil8', |
| depthWriteEnabled: false, |
| stencilFront: { |
| compare: 'never', |
| depthFailOp: 'decrement-wrap', |
| passOp: 'decrement-clamp', |
| }, |
| stencilBack: { |
| compare: 'always', |
| failOp: 'increment-wrap', |
| depthFailOp: 'increment-wrap', |
| passOp: 'decrement-clamp', |
| }, |
| stencilReadMask: 1589, |
| stencilWriteMask: 881, |
| depthBias: 47, |
| depthBiasSlopeScale: 71, |
| depthBiasClamp: 33, |
| }, |
| vertex: { |
| module: shaderModule1, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 0, |
| stepMode: 'instance', |
| attributes: [{ |
| format: 'sint16x2', |
| offset: 7392, |
| shaderLocation: 9, |
| }, { |
| format: 'snorm8x4', |
| offset: 2264, |
| shaderLocation: 11, |
| }, { |
| format: 'float32x4', |
| offset: 16360, |
| shaderLocation: 7, |
| }, { |
| format: 'unorm8x2', |
| offset: 12070, |
| shaderLocation: 1, |
| }, { |
| format: 'sint32x3', |
| offset: 4588, |
| shaderLocation: 6, |
| }, { |
| format: 'sint16x2', |
| offset: 4644, |
| shaderLocation: 4, |
| }, { |
| format: 'uint8x2', |
| offset: 9782, |
| shaderLocation: 3, |
| }, { |
| format: 'unorm16x2', |
| offset: 7512, |
| shaderLocation: 2, |
| }, { |
| format: 'sint32x2', |
| offset: 10796, |
| shaderLocation: 0, |
| }, { |
| format: 'uint32', |
| offset: 732, |
| shaderLocation: 8, |
| }, { |
| format: 'sint16x2', |
| offset: 2220, |
| shaderLocation: 14, |
| }], |
| } |
| ] |
| }, |
| primitive: { |
| topology: 'line-strip', |
| stripIndexFormat: 'uint32', |
| frontFace: 'ccw', |
| cullMode: 'back', |
| unclippedDepth: true, |
| }, |
| }); |
| let textureView25 = texture19.createView({label: '\u0e65\u0ec6\ubd5b', format: 'rgba8unorm', baseMipLevel: 2}); |
| try { |
| computePassEncoder8.end(); |
| } catch {} |
| try { |
| renderBundleEncoder8.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderBundleEncoder11.setVertexBuffer(7, buffer1, 16304); |
| } catch {} |
| try { |
| buffer1.unmap(); |
| } catch {} |
| try { |
| commandEncoder18.copyBufferToTexture({ |
| /* bytesInLastRow: 992 widthInBlocks: 62 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 34096 */ |
| offset: 34096, |
| bytesPerRow: 1024, |
| buffer: buffer4, |
| }, { |
| texture: texture12, |
| mipLevel: 0, |
| origin: { x: 1524, y: 12, z: 5 }, |
| aspect: 'all', |
| }, {width: 744, height: 72, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer4); |
| } catch {} |
| let pipeline28 = await device0.createRenderPipelineAsync({ |
| label: '\uc123\u{1fb96}\u0405\ub350\u09c1\u075a\uf4be', |
| layout: pipelineLayout3, |
| vertex: { |
| module: shaderModule1, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 0, |
| stepMode: 'instance', |
| attributes: [{ |
| format: 'snorm8x2', |
| offset: 1978, |
| shaderLocation: 2, |
| }, { |
| format: 'float32x3', |
| offset: 15768, |
| shaderLocation: 11, |
| }, { |
| format: 'uint32x2', |
| offset: 14108, |
| shaderLocation: 8, |
| }, { |
| format: 'sint8x4', |
| offset: 8052, |
| shaderLocation: 0, |
| }, { |
| format: 'sint32x4', |
| offset: 10940, |
| shaderLocation: 14, |
| }, { |
| format: 'unorm16x4', |
| offset: 10288, |
| shaderLocation: 1, |
| }, { |
| format: 'unorm16x4', |
| offset: 1968, |
| shaderLocation: 7, |
| }, { |
| format: 'sint16x4', |
| offset: 3752, |
| shaderLocation: 4, |
| }, { |
| format: 'uint32x3', |
| offset: 1372, |
| shaderLocation: 3, |
| }, { |
| format: 'sint8x4', |
| offset: 6704, |
| shaderLocation: 9, |
| }, { |
| format: 'sint16x2', |
| offset: 7572, |
| shaderLocation: 6, |
| }], |
| } |
| ] |
| }, |
| primitive: { |
| topology: 'line-list', |
| frontFace: 'ccw', |
| cullMode: 'back', |
| unclippedDepth: true, |
| }, |
| }); |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| document.body.prepend(video1); |
| let device1 = await adapter2.requestDevice({ |
| label: '\u{1fa95}\u089e\u032d', |
| requiredFeatures: [ |
| 'depth-clip-control', |
| 'depth32float-stencil8', |
| 'texture-compression-etc2', |
| 'texture-compression-astc', |
| 'indirect-first-instance', |
| 'shader-f16', |
| 'rg11b10ufloat-renderable', |
| 'bgra8unorm-storage' |
| ], |
| requiredLimits: { |
| maxBindGroups: 10, |
| maxColorAttachmentBytesPerSample: 33, |
| maxVertexAttributes: 29, |
| maxVertexBufferArrayStride: 27338, |
| maxStorageTexturesPerShaderStage: 28, |
| maxStorageBuffersPerShaderStage: 36, |
| maxDynamicStorageBuffersPerPipelineLayout: 2114, |
| maxBindingsPerBindGroup: 9050, |
| maxTextureDimension1D: 11529, |
| maxTextureDimension2D: 15797, |
| maxVertexBuffers: 12, |
| minStorageBufferOffsetAlignment: 32, |
| maxUniformBufferBindingSize: 223220592, |
| maxUniformBuffersPerShaderStage: 37, |
| maxInterStageShaderVariables: 55, |
| maxInterStageShaderComponents: 64, |
| }, |
| }); |
| let commandEncoder19 = device1.createCommandEncoder({label: '\u96f9\u7405\uf568\u0165\ud279\uda99\u0344\u0dad\u{1f972}'}); |
| let computePassEncoder12 = commandEncoder19.beginComputePass(); |
| try { |
| adapter2.label = '\u08d5\ua7cf\u0538\ub460\ue6df\u0b60\u8b69'; |
| } catch {} |
| let buffer8 = device1.createBuffer({label: '\uea26\u0d52\uab59', size: 37626, usage: GPUBufferUsage.STORAGE}); |
| try { |
| device1.pushErrorScope('out-of-memory'); |
| } catch {} |
| canvas3.height = 777; |
| let commandEncoder20 = device0.createCommandEncoder({label: '\uf0ec\u2d63\uf994'}); |
| try { |
| renderBundleEncoder12.setBindGroup(0, bindGroup1, new Uint32Array(3368), 2942, 0); |
| } catch {} |
| try { |
| renderBundleEncoder8.drawIndexed(40, 24); |
| } catch {} |
| try { |
| renderBundleEncoder8.drawIndexedIndirect(buffer3, 30856); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST, |
| viewFormats: ['r16sint'], |
| colorSpace: 'srgb', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| renderBundleEncoder8.drawIndirect(buffer3, 35444); |
| } catch {} |
| try { |
| await promise20; |
| } catch {} |
| document.body.prepend(canvas2); |
| let gpuCanvasContext5 = canvas6.getContext('webgpu'); |
| let commandBuffer6 = commandEncoder18.finish({ |
| label: '\u4a94\ufae1', |
| }); |
| let texture31 = device0.createTexture({ |
| label: '\u2e76\u236b\ua60a\u72a5\u{1ff3d}\u5c98\u07d1\u{1ff03}', |
| size: {width: 1136, height: 9, depthOrArrayLayers: 1}, |
| mipLevelCount: 11, |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rgb10a2unorm', 'rgb10a2unorm', 'rgb10a2unorm'], |
| }); |
| let renderBundle16 = renderBundleEncoder8.finish({label: '\u1567\u7c1d\u99a0\u5fe0\ub37f'}); |
| try { |
| commandEncoder20.copyBufferToTexture({ |
| /* bytesInLastRow: 13904 widthInBlocks: 1738 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 16984 */ |
| offset: 16984, |
| buffer: buffer4, |
| }, { |
| texture: texture1, |
| mipLevel: 0, |
| origin: { x: 775, y: 0, z: 0 }, |
| aspect: 'all', |
| }, {width: 1738, height: 0, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer4); |
| } catch {} |
| try { |
| commandEncoder16.pushDebugGroup('\u81f1'); |
| } catch {} |
| try { |
| gpuCanvasContext3.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rgba8unorm-srgb', 'rgba8unorm', 'astc-10x5-unorm-srgb', 'rgba8unorm-srgb'], |
| colorSpace: 'srgb', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| device0.queue.submit([ |
| ]); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 30096, new DataView(new ArrayBuffer(24397)), 22309); |
| } catch {} |
| let pipeline29 = device0.createRenderPipeline({ |
| label: '\uc039\u22d2\u0108\u0e4b\u648f\u{1f629}\uf965\u2827\u0b98', |
| layout: pipelineLayout5, |
| multisample: { |
| mask: 0x8f896934, |
| }, |
| fragment: { |
| module: shaderModule1, |
| entryPoint: 'fragment0', |
| targets: [{format: 'r16sint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN}, {format: 'r8uint'}, {format: 'rg16uint', writeMask: 0}, {format: 'r8uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN}, {format: 'rg32sint'}, {format: 'r8unorm', writeMask: GPUColorWrite.GREEN}] |
| }, |
| depthStencil: { |
| format: 'stencil8', |
| depthWriteEnabled: false, |
| stencilFront: { |
| compare: 'greater-equal', |
| failOp: 'zero', |
| depthFailOp: 'increment-clamp', |
| }, |
| stencilBack: { |
| compare: 'never', |
| failOp: 'keep', |
| depthFailOp: 'increment-wrap', |
| passOp: 'decrement-clamp', |
| }, |
| stencilReadMask: 2883, |
| depthBias: 92, |
| depthBiasClamp: 76, |
| }, |
| vertex: { |
| module: shaderModule1, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 9348, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'sint8x4', |
| offset: 6372, |
| shaderLocation: 6, |
| }, { |
| format: 'uint8x4', |
| offset: 9248, |
| shaderLocation: 8, |
| }, { |
| format: 'snorm16x2', |
| offset: 5120, |
| shaderLocation: 2, |
| }, { |
| format: 'unorm16x2', |
| offset: 5756, |
| shaderLocation: 1, |
| }, { |
| format: 'sint32x4', |
| offset: 7560, |
| shaderLocation: 9, |
| }, { |
| format: 'unorm8x4', |
| offset: 7488, |
| shaderLocation: 11, |
| }, { |
| format: 'uint16x4', |
| offset: 3564, |
| shaderLocation: 3, |
| }, { |
| format: 'sint8x4', |
| offset: 8068, |
| shaderLocation: 0, |
| }, { |
| format: 'float16x4', |
| offset: 1620, |
| shaderLocation: 7, |
| }, { |
| format: 'sint32x4', |
| offset: 132, |
| shaderLocation: 4, |
| }, { |
| format: 'sint8x4', |
| offset: 2140, |
| shaderLocation: 14, |
| }], |
| } |
| ] |
| }, |
| }); |
| let texture32 = device1.createTexture({ |
| label: '\u{1fc1d}\u{1f63c}\u0fa6\u808a', |
| size: [320], |
| dimension: '1d', |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['bgra8unorm-srgb'], |
| }); |
| let renderBundleEncoder16 = device1.createRenderBundleEncoder({ |
| label: '\u464d\u0a9e\u0fef\u17d5\u063e\u3428\u831d\u3144\ue531\u0f46', |
| colorFormats: ['rgb10a2uint'], |
| depthStencilFormat: 'depth32float-stencil8', |
| sampleCount: 4 |
| }); |
| try { |
| renderBundleEncoder16.setVertexBuffer(27, undefined, 819379979, 2973899079); |
| } catch {} |
| try { |
| computePassEncoder12.insertDebugMarker('\u61f7'); |
| } catch {} |
| try { |
| await promise18; |
| } catch {} |
| let canvas7 = document.createElement('canvas'); |
| let imageBitmap4 = await createImageBitmap(canvas4); |
| let commandEncoder21 = device1.createCommandEncoder(); |
| let imageData6 = new ImageData(200, 216); |
| let bindGroup10 = device0.createBindGroup({ |
| layout: bindGroupLayout4, |
| entries: [], |
| }); |
| let renderBundleEncoder17 = device0.createRenderBundleEncoder({ |
| colorFormats: ['r16sint', 'r8uint', 'rg16uint', 'r8uint', 'rg32sint', 'r8unorm'], |
| sampleCount: 4, |
| depthReadOnly: true |
| }); |
| let renderBundle17 = renderBundleEncoder7.finish({label: '\u2c96\u3faa\u527f\u7ce6\u1445\u5479\ud2e7\u0415\u4262\u0f0c\u0e36'}); |
| try { |
| renderBundleEncoder11.setPipeline(pipeline8); |
| } catch {} |
| try { |
| commandEncoder16.copyBufferToBuffer(buffer5, 1276, buffer3, 13420, 7340); |
| dissociateBuffer(device0, buffer5); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture14, |
| mipLevel: 0, |
| origin: { x: 1511, y: 0, z: 1 }, |
| aspect: 'all', |
| }, arrayBuffer0, /* required buffer size: 5499 */ |
| {offset: 41, rowsPerImage: 153}, {width: 2729, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| let gpuCanvasContext6 = canvas7.getContext('webgpu'); |
| let bindGroupLayout12 = device0.createBindGroupLayout({ |
| label: '\u0d33\u04e9\u0287\uca18\uf42c\ub2ee\u4610\u3ddd\u5ccb', |
| entries: [{ |
| binding: 5062, |
| visibility: GPUShaderStage.COMPUTE, |
| externalTexture: {}, |
| }, { |
| binding: 1161, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'bgra8unorm', access: 'read-only', viewDimension: '1d' }, |
| }, { |
| binding: 4533, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| externalTexture: {}, |
| }], |
| }); |
| let textureView26 = texture12.createView({ |
| label: '\ubdc9\u0887', |
| aspect: 'all', |
| baseMipLevel: 1, |
| mipLevelCount: 2, |
| baseArrayLayer: 35, |
| arrayLayerCount: 149 |
| }); |
| try { |
| renderBundleEncoder11.drawIndexedIndirect(buffer3, 42464); |
| } catch {} |
| try { |
| renderBundleEncoder11.drawIndirect(buffer3, 36560); |
| } catch {} |
| try { |
| renderBundleEncoder11.setPipeline(pipeline8); |
| } catch {} |
| try { |
| commandEncoder16.clearBuffer(buffer3); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| let texture33 = device1.createTexture({ |
| label: '\ud45f\u{1f72d}\u03e9\u{1f8a1}\u05de\u7b45\u0dda\u09b0\u0f7f\uc05c', |
| size: [4160, 205, 1], |
| mipLevelCount: 8, |
| format: 'stencil8', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| let renderBundle18 = renderBundleEncoder16.finish({label: '\u329d\u{1f6b6}\u{1ff4e}\u{1fa7e}\u091f\uf934'}); |
| let sampler19 = device1.createSampler({ |
| label: '\u9640\u26fa\u4bbc\u{1fab1}\u76ea\u3285\u2578\u{1f6d8}\ua1c4\uaed9', |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| lodMinClamp: 60.045, |
| lodMaxClamp: 80.732, |
| compare: 'less-equal', |
| }); |
| let promise22 = device1.popErrorScope(); |
| let videoFrame5 = new VideoFrame(canvas3, {timestamp: 0}); |
| let bindGroupLayout13 = device0.createBindGroupLayout({ |
| entries: [{ |
| binding: 2371, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| externalTexture: {}, |
| }, { |
| binding: 2457, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: 'cube-array', sampleType: 'float', multisampled: false }, |
| }], |
| }); |
| let bindGroup11 = device0.createBindGroup({ |
| label: '\ua9c4\ue4b9\uf277\ua07f\u03d3\u{1f904}', |
| layout: bindGroupLayout0, |
| entries: [{ |
| binding: 1160, |
| resource: externalTexture0 |
| }], |
| }); |
| let sampler20 = device0.createSampler({ |
| label: '\u{1fdaf}\ud8c7\ue8d9\u{1f7ef}\u{1fe74}\u6976', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 85.839, |
| lodMaxClamp: 94.276, |
| maxAnisotropy: 16, |
| }); |
| try { |
| computePassEncoder11.setBindGroup(4, bindGroup8, new Uint32Array(3961), 1722, 0); |
| } catch {} |
| try { |
| renderBundleEncoder11.draw(40, 72, 32, 56); |
| } catch {} |
| try { |
| renderBundleEncoder11.drawIndirect(buffer3, 17928); |
| } catch {} |
| try { |
| renderBundleEncoder4.setVertexBuffer(6, buffer1, 6100, 6254); |
| } catch {} |
| try { |
| commandEncoder20.copyBufferToBuffer(buffer0, 1844, buffer3, 9088, 12156); |
| dissociateBuffer(device0, buffer0); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 3632, new BigUint64Array(8792), 4499); |
| } catch {} |
| let pipeline30 = device0.createComputePipeline({ |
| layout: 'auto', |
| compute: { |
| module: shaderModule1, |
| entryPoint: 'compute0', |
| }, |
| }); |
| let imageData7 = new ImageData(176, 60); |
| try { |
| device1.queue.label = '\u40f3\u5326\ua993\u833a\uc51a\u04b5'; |
| } catch {} |
| let texture34 = device1.createTexture({ |
| label: '\u68d9\u5047\u8b66\ub8e0\ua66c\u559a\u{1f867}\uefcf\u{1fb16}\ub3cd\u589d', |
| size: [160, 17, 131], |
| sampleCount: 1, |
| format: 'r16uint', |
| usage: GPUTextureUsage.COPY_DST, |
| viewFormats: ['r16uint', 'r16uint', 'r16uint'], |
| }); |
| let textureView27 = texture32.createView({label: '\u0296\u0ae0\u83bb', format: 'bgra8unorm-srgb'}); |
| let renderBundleEncoder18 = device1.createRenderBundleEncoder({ |
| label: '\u865f\u{1fe29}\u0fb7\u6fa8\u0263\udb3b\ue765\u{1ff25}\u{1f857}\u1e95', |
| colorFormats: ['rgb10a2uint'], |
| depthStencilFormat: 'depth32float-stencil8', |
| sampleCount: 4, |
| depthReadOnly: true |
| }); |
| let sampler21 = device1.createSampler({ |
| label: '\ua871\uf0b3\uc69c', |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMaxClamp: 72.806, |
| }); |
| try { |
| device1.pushErrorScope('out-of-memory'); |
| } catch {} |
| let imageBitmap5 = await createImageBitmap(videoFrame4); |
| let commandEncoder22 = device0.createCommandEncoder({label: '\u{1ffe5}\uf672\ud275\u08a7\u0031\uaaff\u0275\uc480'}); |
| try { |
| buffer6.unmap(); |
| } catch {} |
| try { |
| commandEncoder20.copyBufferToTexture({ |
| /* bytesInLastRow: 342 widthInBlocks: 171 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 53712 */ |
| offset: 53712, |
| buffer: buffer6, |
| }, { |
| texture: texture14, |
| mipLevel: 4, |
| origin: { x: 6, y: 1, z: 0 }, |
| aspect: 'all', |
| }, {width: 171, height: 0, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer6); |
| } catch {} |
| try { |
| commandEncoder15.clearBuffer(buffer3); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture10, |
| mipLevel: 4, |
| origin: { x: 12, y: 3, z: 2 }, |
| aspect: 'all', |
| }, new ArrayBuffer(11155), /* required buffer size: 11155 */ |
| {offset: 100, bytesPerRow: 67, rowsPerImage: 165}, {width: 13, height: 0, depthOrArrayLayers: 2}); |
| } catch {} |
| gc(); |
| let canvas8 = document.createElement('canvas'); |
| try { |
| canvas8.getContext('webgl2'); |
| } catch {} |
| let textureView28 = texture34.createView({dimension: '2d-array', format: 'r16uint', mipLevelCount: 1, baseArrayLayer: 16, arrayLayerCount: 16}); |
| let computePassEncoder13 = commandEncoder21.beginComputePass({label: '\u531b\ubc95\ub58a\u0b80'}); |
| let sampler22 = device1.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMaxClamp: 92.661, |
| }); |
| let promise23 = device1.popErrorScope(); |
| offscreenCanvas0.height = 32; |
| let renderBundle19 = renderBundleEncoder18.finish({}); |
| canvas0.height = 798; |
| let commandEncoder23 = device0.createCommandEncoder({label: '\u{1fbc6}\u9860'}); |
| let querySet17 = device0.createQuerySet({ |
| label: '\u{1ffb1}\u9fc9', |
| type: 'occlusion', |
| count: 3813, |
| }); |
| let texture35 = device0.createTexture({ |
| label: '\uef06\u547d\u21c8\ud639\u0824\u092c\ufa4f\u{1fb04}\uc63d', |
| size: [40, 480, 1], |
| mipLevelCount: 2, |
| sampleCount: 1, |
| format: 'astc-8x8-unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['astc-8x8-unorm', 'astc-8x8-unorm'], |
| }); |
| let renderBundle20 = renderBundleEncoder10.finish({label: '\u0978\u4a7a\ub668\u0d90\u{1f77a}\u0366'}); |
| let sampler23 = device0.createSampler({ |
| label: '\u87b6\ud891\uf78b\u{1fef1}', |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 54.348, |
| lodMaxClamp: 82.649, |
| }); |
| try { |
| computePassEncoder10.setPipeline(pipeline24); |
| } catch {} |
| try { |
| renderBundleEncoder14.setBindGroup(6, bindGroup4, new Uint32Array(5296), 4593, 0); |
| } catch {} |
| try { |
| renderBundleEncoder11.draw(0, 72, 48, 80); |
| } catch {} |
| try { |
| renderBundleEncoder11.drawIndexedIndirect(buffer3, 22408); |
| } catch {} |
| try { |
| renderBundleEncoder11.drawIndirect(buffer3, 43736); |
| } catch {} |
| try { |
| commandEncoder16.popDebugGroup(); |
| } catch {} |
| try { |
| gpuCanvasContext3.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: ['rgba8unorm-srgb'], |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device0.queue.submit([ |
| commandBuffer6, |
| ]); |
| } catch {} |
| let texture36 = device1.createTexture({ |
| label: '\u37f2\ucb6b\u{1fc22}\u795c\u0332\u{1fba3}\uc547\u869a\u025c\ube4a\ud46c', |
| size: [80, 8, 131], |
| mipLevelCount: 6, |
| sampleCount: 1, |
| format: 'astc-10x8-unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['astc-10x8-unorm', 'astc-10x8-unorm-srgb', 'astc-10x8-unorm-srgb'], |
| }); |
| let renderBundleEncoder19 = device1.createRenderBundleEncoder({ |
| label: '\u8d40\u{1ff4e}\u7beb\u9ce1\u{1fc78}\u08f0\u2b87\u7c84\u5513\u02a7\ud68d', |
| colorFormats: ['r16uint', 'bgra8unorm', 'rgb10a2unorm'], |
| depthStencilFormat: 'depth24plus-stencil8', |
| depthReadOnly: true, |
| stencilReadOnly: true |
| }); |
| let renderBundle21 = renderBundleEncoder19.finish({label: '\u870c\u6767\u{1fbdd}\u0466\u0bef'}); |
| let querySet18 = device1.createQuerySet({ |
| label: '\uf95e\u0849\u{1fd79}\u047d\u840a\u0b0a\u100d\u391a\u018e\ubcc9\u{1fdcf}', |
| type: 'occlusion', |
| count: 3691, |
| }); |
| offscreenCanvas0.width = 99; |
| let commandEncoder24 = device1.createCommandEncoder({label: '\u{1f99b}\u{1fdc2}'}); |
| let sampler24 = device1.createSampler({ |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 52.333, |
| lodMaxClamp: 83.615, |
| }); |
| try { |
| device1.pushErrorScope('validation'); |
| } catch {} |
| let promise24 = device1.popErrorScope(); |
| try { |
| device1.queue.writeTexture({ |
| texture: texture36, |
| mipLevel: 3, |
| origin: { x: 0, y: 0, z: 57 }, |
| aspect: 'all', |
| }, new Int32Array(new ArrayBuffer(32)), /* required buffer size: 1367300 */ |
| {offset: 760, bytesPerRow: 140, rowsPerImage: 227}, {width: 0, height: 0, depthOrArrayLayers: 44}); |
| } catch {} |
| gc(); |
| try { |
| await device1.queue.onSubmittedWorkDone(); |
| } catch {} |
| let video5 = await videoWithData(); |
| let imageData8 = new ImageData(32, 72); |
| let videoFrame6 = new VideoFrame(canvas3, {timestamp: 0}); |
| let commandEncoder25 = device0.createCommandEncoder({label: '\ue943\u0846\ude95\u7805'}); |
| let textureView29 = texture16.createView({label: '\u0693\u0df4\u3a2e\u02fb\u08cf\u{1fd53}'}); |
| try { |
| computePassEncoder4.end(); |
| } catch {} |
| try { |
| renderBundleEncoder11.drawIndexed(72, 56, 32, 8); |
| } catch {} |
| try { |
| await promise24; |
| } catch {} |
| let querySet19 = device0.createQuerySet({ |
| label: '\uc19a\ubc0c\u5fa6\u96cc\u02c0\u0e96', |
| type: 'occlusion', |
| count: 2884, |
| }); |
| try { |
| renderBundleEncoder11.drawIndexedIndirect(buffer3, 42444); |
| } catch {} |
| try { |
| renderBundleEncoder11.drawIndirect(buffer3, 8856); |
| } catch {} |
| try { |
| renderBundleEncoder17.setVertexBuffer(6, buffer1); |
| } catch {} |
| try { |
| commandEncoder9.copyTextureToBuffer({ |
| texture: texture18, |
| mipLevel: 0, |
| origin: { x: 128, y: 0, z: 1 }, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 1492 widthInBlocks: 746 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 23074 */ |
| offset: 23074, |
| buffer: buffer3, |
| }, {width: 746, height: 1, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 71, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: video5, |
| origin: { x: 0, y: 10 }, |
| flipY: true, |
| }, { |
| texture: texture31, |
| mipLevel: 4, |
| origin: { x: 2, y: 1, z: 0 }, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 14, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| try { |
| buffer8.unmap(); |
| } catch {} |
| try { |
| device1.queue.writeTexture({ |
| texture: texture36, |
| mipLevel: 4, |
| origin: { x: 10, y: 0, z: 1 }, |
| aspect: 'all', |
| }, arrayBuffer4, /* required buffer size: 4985255 */ |
| {offset: 695, bytesPerRow: 280, rowsPerImage: 138}, {width: 0, height: 0, depthOrArrayLayers: 130}); |
| } catch {} |
| try { |
| await promise23; |
| } catch {} |
| let video6 = await videoWithData(); |
| let querySet20 = device1.createQuerySet({ |
| label: '\u0725\u0061\ude7c\u29a4\u02d9', |
| type: 'occlusion', |
| count: 57, |
| }); |
| let renderBundle22 = renderBundleEncoder19.finish(); |
| let imageData9 = new ImageData(56, 152); |
| let buffer9 = device1.createBuffer({ |
| label: '\u8869\u093d\u0307\u9608\u0daf\u0795\u{1fdbc}\u{1f720}\u5201', |
| size: 21524, |
| usage: GPUBufferUsage.COPY_DST |
| }); |
| let textureView30 = texture36.createView({ |
| label: '\u0ad4\u0e5d\u{1f91b}\u707d\u7d66\ueb79', |
| dimension: '2d', |
| format: 'astc-10x8-unorm-srgb', |
| baseMipLevel: 5, |
| baseArrayLayer: 43 |
| }); |
| let renderBundleEncoder20 = device1.createRenderBundleEncoder({colorFormats: ['r16uint', 'bgra8unorm', 'rgb10a2unorm'], depthStencilFormat: 'depth24plus-stencil8'}); |
| try { |
| computePassEncoder13.end(); |
| } catch {} |
| try { |
| commandEncoder21.clearBuffer(buffer9); |
| dissociateBuffer(device1, buffer9); |
| } catch {} |
| try { |
| device1.queue.writeTexture({ |
| texture: texture36, |
| mipLevel: 1, |
| origin: { x: 20, y: 0, z: 39 }, |
| aspect: 'all', |
| }, arrayBuffer3, /* required buffer size: 1808205 */ |
| {offset: 693, bytesPerRow: 232, rowsPerImage: 147}, {width: 10, height: 0, depthOrArrayLayers: 54}); |
| } catch {} |
| try { |
| await device1.queue.onSubmittedWorkDone(); |
| } catch {} |
| document.body.prepend(img0); |
| let renderBundleEncoder21 = device1.createRenderBundleEncoder({ |
| colorFormats: ['r16uint', 'bgra8unorm', 'rgb10a2unorm'], |
| depthStencilFormat: 'depth24plus-stencil8', |
| stencilReadOnly: true |
| }); |
| try { |
| buffer9.unmap(); |
| } catch {} |
| try { |
| commandEncoder24.clearBuffer(buffer9); |
| dissociateBuffer(device1, buffer9); |
| } catch {} |
| try { |
| commandEncoder24.insertDebugMarker('\u{1fade}'); |
| } catch {} |
| try { |
| device1.queue.writeBuffer(buffer9, 540, new BigUint64Array(50812), 13171, 2436); |
| } catch {} |
| let img3 = await imageWithData(60, 248, '#bc7ab89a', '#f66a2e8a'); |
| try { |
| renderBundleEncoder11.draw(56, 40, 16, 64); |
| } catch {} |
| try { |
| renderBundleEncoder12.setVertexBuffer(5, buffer1, 2560, 13611); |
| } catch {} |
| let promise25 = buffer7.mapAsync(GPUMapMode.READ); |
| try { |
| commandEncoder20.clearBuffer(buffer3); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| let pipelineLayout6 = device0.createPipelineLayout({label: '\u{1f959}\u{1ff39}\u9cb5\u92ee\u4f40\u{1f909}\ubca3', bindGroupLayouts: [bindGroupLayout11]}); |
| let renderBundleEncoder22 = device0.createRenderBundleEncoder({ |
| label: '\u{1faeb}\u0ad3\u{1fa12}\u6018\u{1f76c}\uec9c\u018b', |
| colorFormats: ['rg16uint', 'r16sint', 'r16float', 'rgba16sint'], |
| depthStencilFormat: 'depth32float-stencil8', |
| depthReadOnly: false, |
| stencilReadOnly: true |
| }); |
| try { |
| renderBundleEncoder15.setBindGroup(6, bindGroup1, new Uint32Array(2140), 312, 0); |
| } catch {} |
| try { |
| buffer1.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture26, |
| mipLevel: 0, |
| origin: { x: 296, y: 0, z: 0 }, |
| aspect: 'all', |
| }, new Float64Array(arrayBuffer3), /* required buffer size: 663 */ |
| {offset: 663}, {width: 2646, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline31 = device0.createRenderPipeline({ |
| label: '\u{1f962}\u0274\u9e69\u{1fc23}\u{1f6ef}\u{1fb86}\u03fd\u4d89\u6b48', |
| layout: pipelineLayout6, |
| fragment: { |
| module: shaderModule1, |
| entryPoint: 'fragment0', |
| targets: [{format: 'r16sint', writeMask: 0}, {format: 'r8uint', writeMask: GPUColorWrite.BLUE}, {format: 'rg16uint'}, {format: 'r8uint'}, {format: 'rg32sint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.RED}, {format: 'r8unorm', writeMask: GPUColorWrite.ALL}] |
| }, |
| depthStencil: { |
| format: 'depth24plus-stencil8', |
| depthWriteEnabled: true, |
| depthCompare: 'equal', |
| stencilFront: { |
| compare: 'greater', |
| failOp: 'replace', |
| depthFailOp: 'decrement-clamp', |
| passOp: 'decrement-clamp', |
| }, |
| stencilBack: { |
| compare: 'not-equal', |
| failOp: 'increment-wrap', |
| depthFailOp: 'increment-clamp', |
| passOp: 'replace', |
| }, |
| stencilWriteMask: 3948, |
| depthBias: 26, |
| depthBiasClamp: 91, |
| }, |
| vertex: { |
| module: shaderModule1, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 4236, |
| stepMode: 'instance', |
| attributes: [{ |
| format: 'uint32x4', |
| offset: 3704, |
| shaderLocation: 3, |
| }, { |
| format: 'float32x2', |
| offset: 2892, |
| shaderLocation: 1, |
| }, { |
| format: 'sint32x3', |
| offset: 2616, |
| shaderLocation: 9, |
| }], |
| }, |
| { |
| arrayStride: 3264, |
| attributes: [{ |
| format: 'sint8x2', |
| offset: 762, |
| shaderLocation: 0, |
| }, { |
| format: 'sint8x2', |
| offset: 2508, |
| shaderLocation: 14, |
| }, { |
| format: 'sint32x2', |
| offset: 232, |
| shaderLocation: 4, |
| }, { |
| format: 'snorm16x2', |
| offset: 200, |
| shaderLocation: 7, |
| }, { |
| format: 'float32x4', |
| offset: 668, |
| shaderLocation: 2, |
| }], |
| }, |
| { |
| arrayStride: 7884, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'uint16x2', |
| offset: 2920, |
| shaderLocation: 8, |
| }], |
| }, |
| { |
| arrayStride: 1260, |
| stepMode: 'instance', |
| attributes: [{ |
| format: 'snorm8x4', |
| offset: 1164, |
| shaderLocation: 11, |
| }, { |
| format: 'sint32', |
| offset: 1120, |
| shaderLocation: 6, |
| }], |
| } |
| ] |
| }, |
| primitive: { |
| topology: 'line-list', |
| cullMode: 'back', |
| unclippedDepth: true, |
| }, |
| }); |
| canvas6.height = 88; |
| let videoFrame7 = new VideoFrame(imageBitmap0, {timestamp: 0}); |
| let shaderModule2 = device0.createShaderModule({ |
| label: '\u76cc\u8c97\u4fef\u2622\u{1f8dc}\u{1f7ec}\udd11', |
| code: `@group(0) @binding(1548) |
| var<storage, read_write> i0: 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 S4 { |
| @builtin(sample_index) f0: u32, |
| @location(76) f1: vec2<u32>, |
| @location(61) f2: vec4<f32>, |
| @location(30) f3: u32, |
| @location(39) f4: vec2<f16>, |
| @location(86) f5: vec2<f32>, |
| @location(104) f6: vec2<i32>, |
| @location(99) f7: f32, |
| @location(91) f8: u32, |
| @location(20) f9: f16, |
| @location(74) f10: vec3<i32>, |
| @location(57) f11: vec4<i32>, |
| @location(4) f12: vec4<f16>, |
| @location(69) f13: vec4<f16>, |
| @location(37) f14: f32, |
| @location(43) f15: vec4<f32>, |
| @location(73) f16: vec4<i32>, |
| @location(56) f17: vec3<f32>, |
| @builtin(position) f18: vec4<f32>, |
| @location(63) f19: vec2<f16>, |
| @location(15) f20: vec2<u32> |
| } |
| struct FragmentOutput0 { |
| @location(2) f0: vec4<f32>, |
| @location(0) f1: vec4<f32>, |
| @location(1) f2: vec4<f32>, |
| @location(4) f3: vec2<f32>, |
| @location(3) f4: vec2<i32>, |
| @location(5) f5: vec2<i32> |
| } |
| |
| @fragment |
| fn fragment0(@location(34) a0: vec2<u32>, @location(100) a1: vec4<u32>, a2: S4, @location(9) a3: vec4<f32>, @location(36) a4: vec2<f16>, @location(16) a5: vec4<f32>, @builtin(front_facing) a6: bool, @builtin(sample_mask) a7: u32) -> FragmentOutput0 { |
| return FragmentOutput0(); |
| } |
| |
| struct VertexOutput0 { |
| @location(20) f55: f16, |
| @location(61) f56: vec4<f32>, |
| @location(37) f57: f32, |
| @location(34) f58: vec2<u32>, |
| @location(36) f59: vec2<f16>, |
| @location(9) f60: vec4<f32>, |
| @location(91) f61: u32, |
| @location(57) f62: vec4<i32>, |
| @location(56) f63: vec3<f32>, |
| @location(99) f64: f32, |
| @location(15) f65: vec2<u32>, |
| @location(76) f66: vec2<u32>, |
| @location(43) f67: vec4<f32>, |
| @location(39) f68: vec2<f16>, |
| @location(4) f69: vec4<f16>, |
| @builtin(position) f70: vec4<f32>, |
| @location(69) f71: vec4<f16>, |
| @location(74) f72: vec3<i32>, |
| @location(104) f73: vec2<i32>, |
| @location(16) f74: vec4<f32>, |
| @location(100) f75: vec4<u32>, |
| @location(30) f76: u32, |
| @location(63) f77: vec2<f16>, |
| @location(73) f78: vec4<i32>, |
| @location(86) f79: vec2<f32> |
| } |
| |
| @vertex |
| fn vertex0(@location(13) a0: vec3<f16>, @location(0) a1: u32, @location(5) a2: vec3<f16>, @builtin(instance_index) a3: u32, @location(15) a4: i32, @location(10) a5: u32, @location(14) a6: vec4<u32>, @builtin(vertex_index) a7: u32, @location(8) a8: vec2<i32>, @location(3) a9: vec4<u32>, @location(7) a10: vec2<f16>, @location(6) a11: vec2<i32>, @location(1) a12: i32, @location(12) a13: vec3<f32>, @location(4) a14: f16, @location(11) a15: vec3<u32>, @location(2) a16: u32) -> VertexOutput0 { |
| return VertexOutput0(); |
| } |
| |
| `, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| let querySet21 = device0.createQuerySet({ |
| label: '\uc5e4\u17d5\u3b19\u{1f673}\u0c07\u0ac7\uec7f\u8e76\u355e', |
| type: 'occlusion', |
| count: 1055, |
| }); |
| let texture37 = device0.createTexture({ |
| size: {width: 1136, height: 9, depthOrArrayLayers: 615}, |
| mipLevelCount: 7, |
| dimension: '3d', |
| format: 'r8uint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderBundle23 = renderBundleEncoder11.finish({label: '\ufa02\uda77\u{1f77e}\u{1fe43}\u0846'}); |
| try { |
| renderBundleEncoder22.setBindGroup(1, bindGroup6); |
| } catch {} |
| try { |
| commandEncoder16.copyBufferToBuffer(buffer1, 3692, buffer3, 2676, 328); |
| dissociateBuffer(device0, buffer1); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 21244, new Float32Array(27257), 11835, 1528); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1136, height: 9, depthOrArrayLayers: 1} |
| */ |
| { |
| source: canvas8, |
| origin: { x: 38, y: 31 }, |
| flipY: true, |
| }, { |
| texture: texture31, |
| mipLevel: 0, |
| origin: { x: 737, y: 0, z: 0 }, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 167, height: 9, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| await promise25; |
| } catch {} |
| let imageData10 = new ImageData(32, 244); |
| let texture38 = device0.createTexture({ |
| size: {width: 9088}, |
| dimension: '1d', |
| format: 'r32float', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['r32float', 'r32float'], |
| }); |
| let renderBundle24 = renderBundleEncoder0.finish({label: '\u0ea0\u095e\uea18\u{1fdb0}'}); |
| try { |
| computePassEncoder11.end(); |
| } catch {} |
| try { |
| renderBundleEncoder17.setBindGroup(5, bindGroup7); |
| } catch {} |
| try { |
| buffer4.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture22, |
| mipLevel: 0, |
| origin: { x: 10, y: 0, z: 0 }, |
| aspect: 'all', |
| }, new Uint8ClampedArray(arrayBuffer1), /* required buffer size: 614 */ |
| {offset: 562}, {width: 13, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| let pipeline32 = await device0.createComputePipelineAsync({ |
| label: '\u981f\u2c1e', |
| layout: 'auto', |
| compute: { |
| module: shaderModule1, |
| entryPoint: 'compute0', |
| constants: {}, |
| }, |
| }); |
| let pipeline33 = await promise19; |
| let texture39 = device1.createTexture({ |
| label: '\u018b\u5426\u{1f83c}\ua66c\u{1f80d}\ubac5\u{1f89e}\u0818\u0276\u1868\ucf0f', |
| size: {width: 720}, |
| dimension: '1d', |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['bgra8unorm-srgb'], |
| }); |
| let promise26 = device1.queue.onSubmittedWorkDone(); |
| document.body.prepend(canvas3); |
| let img4 = await imageWithData(166, 292, '#f35dab1f', '#2edf7408'); |
| let bindGroup12 = device0.createBindGroup({ |
| layout: bindGroupLayout7, |
| entries: [{ |
| binding: 1160, |
| resource: externalTexture0 |
| }], |
| }); |
| let pipelineLayout7 = device0.createPipelineLayout({ |
| label: '\u35ae\u7daa\ufd45\u0099\u082a\u090d', |
| bindGroupLayouts: [bindGroupLayout10, bindGroupLayout11, bindGroupLayout7, bindGroupLayout9] |
| }); |
| let commandEncoder26 = device0.createCommandEncoder({label: '\uf913\u804c\u8a10'}); |
| let querySet22 = device0.createQuerySet({ |
| label: '\u0acc\u7e1d\ue0df', |
| type: 'occlusion', |
| count: 3645, |
| }); |
| let texture40 = device0.createTexture({ |
| label: '\u652d\u20ee\u{1f975}\u{1f9f8}\u5231\u{1ff59}\u7b36\u{1f89f}\u027b\u074a', |
| size: [96, 96, 1], |
| mipLevelCount: 4, |
| format: 'astc-12x12-unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderBundleEncoder23 = device0.createRenderBundleEncoder({ |
| label: '\u73cf\u074d\u{1fd6f}\u{1fc7d}\u9a3b\u9aff\u096e\u{1fb34}\u2b69\u0949\uad1e', |
| colorFormats: ['rgba8unorm', 'r8sint', undefined], |
| sampleCount: 4, |
| stencilReadOnly: true |
| }); |
| let renderBundle25 = renderBundleEncoder11.finish({label: '\u9713\u{1f908}\u09da\u0b63\ubb61\u1048\u0950\u9a00\ub259\u26eb\u0aa6'}); |
| let sampler25 = device0.createSampler({ |
| label: '\u92f9\u{1fa22}\u7a6f\u{1fcd1}', |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 93.418, |
| lodMaxClamp: 95.969, |
| }); |
| try { |
| computePassEncoder7.insertDebugMarker('\u5d4b'); |
| } catch {} |
| let pipeline34 = device0.createRenderPipeline({ |
| label: '\u44c4\u012c\u{1f619}\ubc0c\u{1fb07}\u3b83\u0925', |
| layout: pipelineLayout2, |
| multisample: { |
| count: 1, |
| mask: 0x17301aab, |
| }, |
| fragment: { |
| module: shaderModule2, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{ |
| format: 'rgb10a2unorm', |
| blend: { |
| color: {operation: 'subtract', srcFactor: 'src-alpha', dstFactor: 'dst-alpha'}, |
| alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'}, |
| }, |
| writeMask: 0 |
| }, {format: 'bgra8unorm-srgb'}, { |
| format: 'rgba16float', |
| blend: { |
| color: {operation: 'add', srcFactor: 'dst-alpha', dstFactor: 'dst'}, |
| alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'}, |
| }, |
| writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED |
| }, {format: 'rg32sint', writeMask: GPUColorWrite.GREEN}, {format: 'rg16float', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA}, {format: 'r8sint', writeMask: 0}] |
| }, |
| depthStencil: { |
| format: 'depth32float-stencil8', |
| depthWriteEnabled: false, |
| depthCompare: 'less', |
| stencilFront: { |
| compare: 'greater', |
| failOp: 'decrement-wrap', |
| depthFailOp: 'decrement-wrap', |
| passOp: 'decrement-wrap', |
| }, |
| stencilBack: { |
| compare: 'greater-equal', |
| depthFailOp: 'keep', |
| passOp: 'decrement-clamp', |
| }, |
| stencilWriteMask: 3517, |
| depthBiasSlopeScale: 11, |
| depthBiasClamp: 60, |
| }, |
| vertex: { |
| module: shaderModule2, |
| entryPoint: 'vertex0', |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 10680, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'sint16x4', |
| offset: 4072, |
| shaderLocation: 15, |
| }, { |
| format: 'float32', |
| offset: 1612, |
| shaderLocation: 4, |
| }, { |
| format: 'uint32x3', |
| offset: 8704, |
| shaderLocation: 3, |
| }, { |
| format: 'uint16x2', |
| offset: 6804, |
| shaderLocation: 11, |
| }, { |
| format: 'snorm8x2', |
| offset: 9680, |
| shaderLocation: 13, |
| }, { |
| format: 'unorm8x4', |
| offset: 7404, |
| shaderLocation: 7, |
| }, { |
| format: 'uint32x3', |
| offset: 9900, |
| shaderLocation: 10, |
| }, { |
| format: 'uint16x2', |
| offset: 1384, |
| shaderLocation: 2, |
| }, { |
| format: 'uint32x4', |
| offset: 1992, |
| shaderLocation: 0, |
| }, { |
| format: 'sint32', |
| offset: 3216, |
| shaderLocation: 6, |
| }, { |
| format: 'sint16x4', |
| offset: 2160, |
| shaderLocation: 8, |
| }, { |
| format: 'float16x2', |
| offset: 3852, |
| shaderLocation: 5, |
| }, { |
| format: 'snorm16x2', |
| offset: 7992, |
| shaderLocation: 12, |
| }], |
| }, |
| { |
| arrayStride: 10220, |
| attributes: [{ |
| format: 'sint32', |
| offset: 6152, |
| shaderLocation: 1, |
| }], |
| }, |
| { |
| arrayStride: 7412, |
| attributes: [{ |
| format: 'uint16x4', |
| offset: 4200, |
| shaderLocation: 14, |
| }], |
| } |
| ] |
| }, |
| }); |
| try { |
| await promise22; |
| } catch {} |
| let bindGroup13 = device0.createBindGroup({ |
| label: '\u{1fc82}\u8cdd\u845e\ucda0\u0a0c\u{1fb47}\ubd3d', |
| layout: bindGroupLayout7, |
| entries: [{ |
| binding: 1160, |
| resource: externalTexture0 |
| }], |
| }); |
| let texture41 = device0.createTexture({ |
| label: '\u023c\u9506\u93e2\u4a44\u0e79\u4634\uf1b7\ua4e5', |
| size: {width: 20, height: 240, depthOrArrayLayers: 1}, |
| mipLevelCount: 5, |
| format: 'astc-10x6-unorm-srgb', |
| usage: GPUTextureUsage.COPY_SRC, |
| }); |
| let textureView31 = texture38.createView({label: '\u46c2\u0ca8\u0156\ue85a\u0f19'}); |
| try { |
| renderBundleEncoder12.setBindGroup(5, bindGroup6); |
| } catch {} |
| let pipeline35 = device0.createComputePipeline({ |
| label: '\u2071\u0875\u2602\u1601\u8861', |
| layout: pipelineLayout7, |
| compute: { |
| module: shaderModule1, |
| entryPoint: 'compute0', |
| constants: {}, |
| }, |
| }); |
| let querySet23 = device0.createQuerySet({ |
| label: '\u5240\u0966', |
| type: 'occlusion', |
| count: 3610, |
| }); |
| let renderBundleEncoder24 = device0.createRenderBundleEncoder({ |
| label: '\u0d26\u085f', |
| colorFormats: ['r16sint', 'r8uint', 'rg16uint', 'r8uint', 'rg32sint', 'r8unorm'], |
| sampleCount: 4, |
| depthReadOnly: true |
| }); |
| let renderBundle26 = renderBundleEncoder23.finish({label: '\uc383\u{1fc74}\u062e\u67d9\u{1feca}'}); |
| try { |
| commandEncoder9.copyBufferToBuffer(buffer0, 14760, buffer3, 3724, 112); |
| dissociateBuffer(device0, buffer0); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| let imageData11 = new ImageData(184, 72); |
| let computePassEncoder14 = commandEncoder24.beginComputePass({label: '\u0c0d\ua542\u04d5\u{1f731}\u22d1\u{1fc55}\u0420\u7f36\u0a64\u{1fa0d}'}); |
| let renderBundle27 = renderBundleEncoder18.finish({}); |
| try { |
| commandEncoder21.clearBuffer(buffer9); |
| dissociateBuffer(device1, buffer9); |
| } catch {} |
| let querySet24 = device1.createQuerySet({ |
| type: 'occlusion', |
| count: 517, |
| }); |
| try { |
| commandEncoder21.clearBuffer(buffer9); |
| dissociateBuffer(device1, buffer9); |
| } catch {} |
| let shaderModule3 = device0.createShaderModule({ |
| label: '\u072e\u6973\u0499\u3df8\u{1fb88}\u0aa5\u0721\ud8d1\u3f9f\u{1fa1b}', |
| code: `@group(0) @binding(1160) |
| var<storage, read_write> field1: array<u32>; |
| |
| @compute @workgroup_size(6, 1, 3) |
| fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {} |
| |
| struct S6 { |
| @builtin(position) f0: vec4<f32>, |
| @location(68) f1: vec4<u32>, |
| @location(10) f2: u32, |
| @location(85) f3: f16, |
| @location(84) f4: vec2<f16>, |
| @location(49) f5: u32, |
| @location(101) f6: u32, |
| @location(3) f7: vec2<f16>, |
| @location(34) f8: vec3<f16>, |
| @location(58) f9: vec4<f32>, |
| @location(52) f10: vec2<u32>, |
| @location(87) f11: vec4<f32>, |
| @location(29) f12: i32, |
| @location(97) f13: vec3<f32>, |
| @location(67) f14: u32, |
| @location(61) f15: vec3<i32>, |
| @location(56) f16: vec4<f32>, |
| @location(12) f17: vec4<f32>, |
| @location(8) f18: vec2<u32>, |
| @location(32) f19: vec2<f16>, |
| @location(83) f20: vec2<f32> |
| } |
| struct FragmentOutput0 { |
| @location(1) f0: vec4<f32>, |
| @location(0) f1: vec4<f32>, |
| @location(5) f2: vec4<f32>, |
| @location(3) f3: vec4<f32>, |
| @location(2) f4: vec4<u32> |
| } |
| |
| @fragment |
| fn fragment0(@location(17) a0: vec3<u32>, a1: S6) -> FragmentOutput0 { |
| return FragmentOutput0(); |
| } |
| |
| struct S5 { |
| @location(2) f0: vec2<f16>, |
| @location(9) f1: vec2<f16>, |
| @location(6) f2: vec2<i32>, |
| @location(10) f3: vec2<f16>, |
| @location(15) f4: vec2<i32>, |
| @location(13) f5: vec4<u32> |
| } |
| struct VertexOutput0 { |
| @location(65) f80: f16, |
| @location(45) f81: vec2<i32>, |
| @location(29) f82: i32, |
| @location(97) f83: vec3<f32>, |
| @location(34) f84: vec3<f16>, |
| @location(84) f85: vec2<f16>, |
| @location(3) f86: vec2<f16>, |
| @location(85) f87: f16, |
| @location(19) f88: vec3<f16>, |
| @location(15) f89: f32, |
| @location(61) f90: vec3<i32>, |
| @location(79) f91: vec2<u32>, |
| @location(2) f92: u32, |
| @location(17) f93: vec3<u32>, |
| @location(56) f94: vec4<f32>, |
| @location(101) f95: u32, |
| @location(10) f96: u32, |
| @location(52) f97: vec2<u32>, |
| @location(83) f98: vec2<f32>, |
| @location(8) f99: vec2<u32>, |
| @location(12) f100: vec4<f32>, |
| @location(67) f101: u32, |
| @location(49) f102: u32, |
| @location(87) f103: vec4<f32>, |
| @location(40) f104: vec2<u32>, |
| @location(68) f105: vec4<u32>, |
| @builtin(position) f106: vec4<f32>, |
| @location(80) f107: u32, |
| @location(32) f108: vec2<f16>, |
| @location(58) f109: vec4<f32> |
| } |
| |
| @vertex |
| fn vertex0(@location(3) a0: f16, @location(14) a1: vec4<f16>, @location(12) a2: vec3<i32>, a3: S5, @location(7) a4: vec3<f16>, @location(5) a5: vec3<u32>, @location(11) a6: vec4<u32>, @location(8) a7: vec2<i32>, @location(0) a8: vec2<f16>, @location(1) a9: vec2<f32>, @builtin(vertex_index) a10: u32) -> VertexOutput0 { |
| return VertexOutput0(); |
| } |
| |
| `, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| try { |
| commandEncoder16.copyBufferToBuffer(buffer0, 4056, buffer3, 20428, 4428); |
| dissociateBuffer(device0, buffer0); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| device0.queue.submit([ |
| ]); |
| } catch {} |
| let commandEncoder27 = device1.createCommandEncoder({label: '\u043a\u2b9e\u3a12\uc639\u046b\u{1fb0d}\uc1cb\u080f'}); |
| let renderBundleEncoder25 = device1.createRenderBundleEncoder({ |
| colorFormats: ['r16uint', 'bgra8unorm', 'rgb10a2unorm'], |
| depthStencilFormat: 'depth24plus-stencil8', |
| stencilReadOnly: true |
| }); |
| let renderBundle28 = renderBundleEncoder16.finish(); |
| try { |
| device1.queue.writeBuffer(buffer9, 19632, new DataView(new ArrayBuffer(22416)), 18410, 412); |
| } catch {} |
| let shaderModule4 = device0.createShaderModule({ |
| code: `@group(0) @binding(1160) |
| var<storage, read_write> function1: array<u32>; |
| |
| @compute @workgroup_size(6, 4, 2) |
| fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {} |
| |
| struct FragmentOutput0 { |
| @location(1) f0: vec4<f32>, |
| @location(4) f1: u32, |
| @location(2) f2: vec4<u32>, |
| @location(0) f3: vec2<f32>, |
| @location(3) f4: vec4<f32>, |
| @location(5) f5: vec4<f32> |
| } |
| |
| @fragment |
| fn fragment0(@builtin(front_facing) a0: bool, @builtin(sample_mask) a1: u32) -> FragmentOutput0 { |
| return FragmentOutput0(); |
| } |
| |
| |
| |
| @vertex |
| fn vertex0(@location(5) a0: vec2<f32>, @location(2) a1: u32, @location(12) a2: vec3<f16>, @location(0) a3: vec2<u32>, @location(8) a4: vec3<u32>, @location(13) a5: vec2<u32>, @location(11) a6: f16, @location(14) a7: vec3<i32>, @location(7) a8: vec2<f32>) -> @builtin(position) vec4<f32> { |
| return vec4<f32>(0.0, 0.0, 0.0, 1.0); |
| } |
| |
| `, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| let bindGroupLayout14 = device0.createBindGroupLayout({ |
| label: '\u78ee\ud1ba\u{1f84e}\u02c6\ufea1\u984b', |
| entries: [{ |
| binding: 4535, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', minBindingSize: 0, hasDynamicOffset: true }, |
| }, { |
| binding: 1395, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rgba8snorm', access: 'read-only', viewDimension: '1d' }, |
| }, { |
| binding: 3040, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| sampler: { type: 'non-filtering' }, |
| }], |
| }); |
| let renderBundleEncoder26 = device0.createRenderBundleEncoder({ |
| colorFormats: ['r16sint', 'r8uint', 'rg16uint', 'r8uint', 'rg32sint', 'r8unorm'], |
| sampleCount: 4, |
| stencilReadOnly: true |
| }); |
| let renderBundle29 = renderBundleEncoder9.finish({label: '\u0eb9\u0a67'}); |
| try { |
| computePassEncoder10.setPipeline(pipeline32); |
| } catch {} |
| try { |
| gpuCanvasContext4.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rgba8unorm-srgb', 'rgba8unorm', 'rgba32float'], |
| colorSpace: 'srgb', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| adapter1.label = '\u72c8\u086a\u0a92\u153a'; |
| } catch {} |
| let shaderModule5 = device0.createShaderModule({ |
| label: '\u46c5\u51bc\u0fa0\u032c\u4e5f\u04a5\u{1fb34}', |
| code: `@group(1) @binding(2495) |
| var<storage, read_write> field2: array<u32>; |
| @group(3) @binding(3641) |
| var<storage, read_write> type1: array<u32>; |
| @group(3) @binding(1646) |
| var<storage, read_write> i1: array<u32>; |
| @group(0) @binding(1160) |
| var<storage, read_write> function2: array<u32>; |
| |
| @compute @workgroup_size(7, 3, 4) |
| fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {} |
| |
| struct FragmentOutput0 { |
| @location(2) f0: vec3<f32>, |
| @location(1) f1: vec2<i32>, |
| @location(3) f2: vec4<i32>, |
| @builtin(frag_depth) f3: f32, |
| @location(0) f4: vec4<u32>, |
| @location(5) f5: vec2<i32> |
| } |
| |
| @fragment |
| fn fragment0(@location(99) a0: vec3<f16>, @location(97) a1: vec4<f32>, @location(19) a2: f32, @location(43) a3: vec2<f16>, @location(30) a4: vec4<u32>, @location(81) a5: vec3<i32>, @location(110) a6: vec3<f16>, @location(69) a7: vec4<u32>, @location(105) a8: vec3<f32>, @location(16) a9: vec4<i32>, @location(36) a10: vec3<f32>, @location(47) a11: i32, @location(11) a12: vec4<f16>, @location(31) a13: vec2<f16>, @location(9) a14: u32, @location(7) a15: vec3<f16>, @location(68) a16: vec4<i32>, @location(3) a17: vec4<f16>, @builtin(position) a18: vec4<f32>, @location(18) a19: vec4<i32>, @location(35) a20: vec2<f16>, @location(73) a21: f16, @builtin(sample_index) a22: u32, @location(48) a23: i32) -> FragmentOutput0 { |
| return FragmentOutput0(); |
| } |
| |
| struct VertexOutput0 { |
| @location(43) f110: vec2<f16>, |
| @location(19) f111: f32, |
| @location(11) f112: vec4<f16>, |
| @location(7) f113: vec3<f16>, |
| @location(81) f114: vec3<i32>, |
| @builtin(position) f115: vec4<f32>, |
| @location(97) f116: vec4<f32>, |
| @location(68) f117: vec4<i32>, |
| @location(16) f118: vec4<i32>, |
| @location(31) f119: vec2<f16>, |
| @location(47) f120: i32, |
| @location(110) f121: vec3<f16>, |
| @location(35) f122: vec2<f16>, |
| @location(30) f123: vec4<u32>, |
| @location(69) f124: vec4<u32>, |
| @location(9) f125: u32, |
| @location(44) f126: vec2<i32>, |
| @location(36) f127: vec3<f32>, |
| @location(3) f128: vec4<f16>, |
| @location(73) f129: f16, |
| @location(48) f130: i32, |
| @location(99) f131: vec3<f16>, |
| @location(18) f132: vec4<i32>, |
| @location(105) f133: vec3<f32> |
| } |
| |
| @vertex |
| fn vertex0() -> VertexOutput0 { |
| return VertexOutput0(); |
| } |
| |
| `, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| let renderBundle30 = renderBundleEncoder4.finish({label: '\u2ac4\u0312\uc2cc\uebbb\u7b55\u0710\uaba7'}); |
| try { |
| renderBundleEncoder12.setBindGroup(1, bindGroup1, new Uint32Array(7420), 490, 0); |
| } catch {} |
| let pipeline36 = await device0.createRenderPipelineAsync({ |
| label: '\ud9d4\ub430\uf011', |
| layout: pipelineLayout3, |
| multisample: { |
| mask: 0x98490d2e, |
| }, |
| fragment: { |
| module: shaderModule0, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{ |
| format: 'rg8unorm', |
| blend: { |
| color: {operation: 'add', srcFactor: 'one-minus-src', dstFactor: 'one-minus-src'}, |
| alpha: {operation: 'reverse-subtract', srcFactor: 'src-alpha-saturated', dstFactor: 'dst'}, |
| }, |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED |
| }, undefined] |
| }, |
| depthStencil: { |
| format: 'depth24plus-stencil8', |
| depthWriteEnabled: false, |
| depthCompare: 'greater-equal', |
| stencilFront: { |
| compare: 'never', |
| failOp: 'replace', |
| depthFailOp: 'increment-wrap', |
| passOp: 'replace', |
| }, |
| stencilBack: { |
| compare: 'never', |
| failOp: 'decrement-wrap', |
| depthFailOp: 'invert', |
| passOp: 'replace', |
| }, |
| stencilReadMask: 2735, |
| stencilWriteMask: 4078, |
| depthBias: 73, |
| depthBiasSlopeScale: 98, |
| }, |
| vertex: { |
| module: shaderModule0, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 14260, |
| stepMode: 'instance', |
| attributes: [{ |
| format: 'uint32x3', |
| offset: 2456, |
| shaderLocation: 10, |
| }, { |
| format: 'float16x4', |
| offset: 9308, |
| shaderLocation: 8, |
| }, { |
| format: 'float32x3', |
| offset: 11808, |
| shaderLocation: 3, |
| }], |
| }, |
| { |
| arrayStride: 7368, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'uint32', |
| offset: 2172, |
| shaderLocation: 2, |
| }, { |
| format: 'unorm16x2', |
| offset: 1908, |
| shaderLocation: 14, |
| }, { |
| format: 'sint32', |
| offset: 6816, |
| shaderLocation: 4, |
| }, { |
| format: 'float32x4', |
| offset: 2368, |
| shaderLocation: 1, |
| }, { |
| format: 'float16x4', |
| offset: 3008, |
| shaderLocation: 15, |
| }], |
| }, |
| { |
| arrayStride: 10780, |
| stepMode: 'instance', |
| attributes: [{ |
| format: 'uint32x3', |
| offset: 952, |
| shaderLocation: 11, |
| }, { |
| format: 'uint16x4', |
| offset: 6256, |
| shaderLocation: 9, |
| }, { |
| format: 'sint8x2', |
| offset: 6188, |
| shaderLocation: 7, |
| }], |
| }, |
| { |
| arrayStride: 12848, |
| stepMode: 'vertex', |
| attributes: [], |
| }, |
| { |
| arrayStride: 15596, |
| stepMode: 'instance', |
| attributes: [{ |
| format: 'sint32x3', |
| offset: 48, |
| shaderLocation: 12, |
| }], |
| }, |
| { |
| arrayStride: 14308, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'uint32x3', |
| offset: 5676, |
| shaderLocation: 5, |
| }], |
| }, |
| { |
| arrayStride: 13372, |
| stepMode: 'instance', |
| attributes: [{ |
| format: 'unorm16x4', |
| offset: 8148, |
| shaderLocation: 0, |
| }, { |
| format: 'uint32', |
| offset: 220, |
| shaderLocation: 13, |
| }], |
| }, |
| { |
| arrayStride: 12992, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'uint32x2', |
| offset: 2020, |
| shaderLocation: 6, |
| }], |
| } |
| ] |
| }, |
| primitive: { |
| topology: 'line-strip', |
| stripIndexFormat: 'uint16', |
| frontFace: 'ccw', |
| cullMode: 'none', |
| unclippedDepth: true, |
| }, |
| }); |
| let img5 = await imageWithData(52, 216, '#0eac75b6', '#bb4d8b47'); |
| let textureView32 = texture36.createView({label: '\ubc5b\uee05\u{1f921}', mipLevelCount: 1, baseArrayLayer: 11, arrayLayerCount: 106}); |
| try { |
| renderBundleEncoder20.setVertexBuffer(17, undefined, 3597416463); |
| } catch {} |
| try { |
| computePassEncoder14.insertDebugMarker('\u7b1a'); |
| } catch {} |
| let textureView33 = texture34.createView({ |
| label: '\u{1f64c}\u{1f912}\u{1f821}\u0dc7\u32ee\u0d22\u0558\ua29f', |
| baseArrayLayer: 68, |
| arrayLayerCount: 50 |
| }); |
| try { |
| commandEncoder27.clearBuffer(buffer9); |
| dissociateBuffer(device1, buffer9); |
| } catch {} |
| let promise27 = adapter3.requestAdapterInfo(); |
| let commandEncoder28 = device0.createCommandEncoder({}); |
| let querySet25 = device0.createQuerySet({ |
| label: '\u08a5\u{1fcd0}\u05ca\u2f18\u{1fb66}\u23bb\u0ed8\u6e4d\u0592\u{1ffc2}', |
| type: 'occlusion', |
| count: 1941, |
| }); |
| let textureView34 = texture37.createView({label: '\u05f6\u3c2b\uc348\u91c9\u{1fde8}\u0b22\u{1f7ab}\u56be\u{1f7de}\u16eb', baseMipLevel: 4}); |
| try { |
| commandEncoder28.copyBufferToBuffer(buffer5, 2640, buffer3, 21728, 20208); |
| dissociateBuffer(device0, buffer5); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| commandEncoder22.clearBuffer(buffer3); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| renderBundleEncoder26.pushDebugGroup('\uc427'); |
| } catch {} |
| try { |
| gpuCanvasContext4.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: ['rgba16float', 'rgba16uint', 'rgba16float', 'rgba16float'], |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture2, |
| mipLevel: 0, |
| origin: { x: 627, y: 1, z: 0 }, |
| aspect: 'all', |
| }, new ArrayBuffer(370), /* required buffer size: 370 */ |
| {offset: 370}, {width: 4058, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| let pipeline37 = device0.createRenderPipeline({ |
| label: '\u0bdb\u{1f824}\u{1ffd2}\u{1fc24}\ub477\uce9f\ua817\u0d77\u0bf9\u9e31', |
| layout: pipelineLayout3, |
| fragment: { |
| module: shaderModule3, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{format: 'r16float', writeMask: 0}, {format: 'rgba32float'}, {format: 'rgba32uint'}, { |
| format: 'rgba8unorm', |
| blend: { |
| color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'}, |
| alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'}, |
| } |
| }, undefined, {format: 'rgba16float'}] |
| }, |
| vertex: { |
| module: shaderModule3, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 15404, |
| stepMode: 'instance', |
| attributes: [{ |
| format: 'uint32', |
| offset: 12316, |
| shaderLocation: 5, |
| }, { |
| format: 'sint32x4', |
| offset: 6612, |
| shaderLocation: 15, |
| }, { |
| format: 'sint8x4', |
| offset: 14164, |
| shaderLocation: 12, |
| }, { |
| format: 'uint16x4', |
| offset: 3416, |
| shaderLocation: 13, |
| }, { |
| format: 'float32x2', |
| offset: 3472, |
| shaderLocation: 9, |
| }, { |
| format: 'float16x4', |
| offset: 14832, |
| shaderLocation: 7, |
| }, { |
| format: 'unorm16x2', |
| offset: 13000, |
| shaderLocation: 0, |
| }, { |
| format: 'unorm16x2', |
| offset: 14888, |
| shaderLocation: 10, |
| }, { |
| format: 'unorm16x2', |
| offset: 7964, |
| shaderLocation: 14, |
| }], |
| }, |
| { |
| arrayStride: 0, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'sint32x4', |
| offset: 1744, |
| shaderLocation: 8, |
| }, { |
| format: 'uint32', |
| offset: 2388, |
| shaderLocation: 11, |
| }], |
| }, |
| { |
| arrayStride: 7688, |
| stepMode: 'instance', |
| attributes: [{ |
| format: 'unorm8x4', |
| offset: 1856, |
| shaderLocation: 1, |
| }, { |
| format: 'unorm16x4', |
| offset: 5164, |
| shaderLocation: 2, |
| }, { |
| format: 'float32x4', |
| offset: 1412, |
| shaderLocation: 3, |
| }, { |
| format: 'sint32x2', |
| offset: 7260, |
| shaderLocation: 6, |
| }], |
| } |
| ] |
| }, |
| primitive: { |
| topology: 'line-list', |
| frontFace: 'ccw', |
| unclippedDepth: true, |
| }, |
| }); |
| try { |
| await promise26; |
| } catch {} |
| let imageBitmap6 = await createImageBitmap(imageBitmap4); |
| let bindGroupLayout15 = device0.createBindGroupLayout({ |
| entries: [{ |
| binding: 1495, |
| visibility: GPUShaderStage.FRAGMENT, |
| sampler: { type: 'filtering' }, |
| }, { |
| binding: 5491, |
| visibility: 0, |
| externalTexture: {}, |
| }, { |
| binding: 5397, |
| visibility: GPUShaderStage.COMPUTE, |
| externalTexture: {}, |
| }], |
| }); |
| let bindGroup14 = device0.createBindGroup({ |
| label: '\ucd7b\u0ce2\u0997\u3560\u05f8\ufa28\u9ee2\u0de7', |
| layout: bindGroupLayout15, |
| entries: [{ |
| binding: 1495, |
| resource: sampler20 |
| }, { |
| binding: 5491, |
| resource: externalTexture0 |
| }, { |
| binding: 5397, |
| resource: externalTexture0 |
| }], |
| }); |
| let sampler26 = device0.createSampler({ |
| label: '\u{1fc83}\u069a\u0e85\ue132\u0f3a\u4690\uab47\uef8c\uefd6\uf01c\u9164', |
| addressModeU: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 56.173, |
| lodMaxClamp: 81.575, |
| compare: 'less', |
| maxAnisotropy: 10, |
| }); |
| try { |
| commandEncoder28.clearBuffer(buffer3); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| renderBundleEncoder26.popDebugGroup(); |
| } catch {} |
| let videoFrame8 = new VideoFrame(video0, {timestamp: 0}); |
| let bindGroupLayout16 = device1.createBindGroupLayout({ |
| label: '\u035b\u{1f694}\u0a5a\u092b\ua481', |
| entries: [{ |
| binding: 7932, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'rg32uint', access: 'read-only', viewDimension: '1d' }, |
| }, { |
| binding: 6112, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rgba32uint', access: 'read-only', viewDimension: '2d' }, |
| }], |
| }); |
| let pipelineLayout8 = device1.createPipelineLayout({bindGroupLayouts: []}); |
| let commandEncoder29 = device1.createCommandEncoder({label: '\u{1f6c2}\u715d'}); |
| let textureView35 = texture33.createView({aspect: 'stencil-only', baseMipLevel: 6, mipLevelCount: 2}); |
| let renderBundleEncoder27 = device1.createRenderBundleEncoder({ |
| label: '\u0c31\u2ddf\u8168\u{1f7e6}\u0a88\u039a\ucbb9', |
| colorFormats: ['rgb10a2uint'], |
| depthStencilFormat: 'depth32float-stencil8', |
| sampleCount: 4, |
| stencilReadOnly: true |
| }); |
| let renderBundle31 = renderBundleEncoder20.finish({label: '\u4c1d\u8ee9\u0cc9\ubc6b\u{1f6ab}\u6d1b\u634f\u9edc\u4203\u0ef0'}); |
| try { |
| renderBundleEncoder27.setVertexBuffer(57, undefined, 2664305010); |
| } catch {} |
| try { |
| commandEncoder27.clearBuffer(buffer9); |
| dissociateBuffer(device1, buffer9); |
| } catch {} |
| let renderBundle32 = renderBundleEncoder2.finish({label: '\u2a01\u6836\u3da8\u0e7e\u08c3\u1280\u9204\u078d\u4479\u0b2a\u1839'}); |
| try { |
| renderBundleEncoder12.setBindGroup(0, bindGroup10); |
| } catch {} |
| try { |
| commandEncoder16.copyBufferToTexture({ |
| /* bytesInLastRow: 36 widthInBlocks: 9 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 15756 */ |
| offset: 15720, |
| buffer: buffer6, |
| }, { |
| texture: texture22, |
| mipLevel: 0, |
| origin: { x: 23, y: 0, z: 0 }, |
| aspect: 'all', |
| }, {width: 9, height: 1, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer6); |
| } catch {} |
| let shaderModule6 = device0.createShaderModule({ |
| label: '\u0eeb\u{1fb1d}\uce9a', |
| code: `@group(0) @binding(1548) |
| var<storage, read_write> type2: 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: vec4<f32>, |
| @location(6) f1: vec4<u32>, |
| @location(5) f2: vec4<f32>, |
| @location(0) f3: vec2<f32>, |
| @location(2) f4: vec4<u32>, |
| @location(1) f5: vec4<f32> |
| } |
| |
| @fragment |
| fn fragment0(@builtin(sample_mask) a0: u32, @builtin(position) a1: vec4<f32>, @builtin(sample_index) a2: u32, @builtin(front_facing) a3: bool) -> FragmentOutput0 { |
| return FragmentOutput0(); |
| } |
| |
| |
| |
| @vertex |
| fn vertex0(@location(14) a0: vec2<u32>, @location(13) a1: f32, @location(6) a2: vec2<f16>, @location(0) a3: vec2<f16>, @location(12) a4: u32, @builtin(vertex_index) a5: u32, @location(10) a6: f32, @location(2) a7: vec2<u32>, @location(3) a8: vec3<f16>) -> @builtin(position) vec4<f32> { |
| return vec4<f32>(0.0, 0.0, 0.0, 1.0); |
| } |
| |
| `, |
| hints: {}, |
| }); |
| let buffer10 = device0.createBuffer({label: '\u0646\u0818\u0429', size: 62069, usage: GPUBufferUsage.INDEX}); |
| let renderBundle33 = renderBundleEncoder9.finish({label: '\u06de\u20df\ufcb9\u0134\u9ae2\u1b2a\u06e7\u0fa7\u{1fea8}\u{1f820}'}); |
| try { |
| computePassEncoder6.setBindGroup(0, bindGroup2, new Uint32Array(7970), 1292, 0); |
| } catch {} |
| try { |
| renderBundleEncoder26.setBindGroup(1, bindGroup9); |
| } catch {} |
| let pipeline38 = await device0.createComputePipelineAsync({ |
| label: '\u{1f808}\ua4f0\uaea5\u{1f9da}\u{1fbd2}\uf284\u5d89\u0a26\ub318\u{1fa26}\u0f89', |
| layout: 'auto', |
| compute: { |
| module: shaderModule1, |
| entryPoint: 'compute0', |
| constants: {}, |
| }, |
| }); |
| let video7 = await videoWithData(); |
| let commandBuffer7 = commandEncoder21.finish({ |
| label: '\u{1fc2a}\u008e\u1a22\u{1f61f}\u964c', |
| }); |
| try { |
| computePassEncoder12.pushDebugGroup('\u477c'); |
| } catch {} |
| try { |
| await promise17; |
| } catch {} |
| let renderBundleEncoder28 = device0.createRenderBundleEncoder({ |
| label: '\ue7e3\uc3e5\u9278\u45f8\udb24\uf171', |
| colorFormats: ['r16sint', 'r8uint', 'rg16uint', 'r8uint', 'rg32sint', 'r8unorm'], |
| sampleCount: 4, |
| depthReadOnly: false |
| }); |
| let renderBundle34 = renderBundleEncoder3.finish({label: '\uf1e9\u558d\u65db\u795a\u{1fb36}\u0022'}); |
| try { |
| renderBundleEncoder28.setVertexBuffer(6, buffer1, 5080, 2840); |
| } catch {} |
| try { |
| buffer5.unmap(); |
| } catch {} |
| try { |
| commandEncoder17.copyBufferToBuffer(buffer6, 46664, buffer3, 37776, 4176); |
| dissociateBuffer(device0, buffer6); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| document.body.prepend(video2); |
| let imageBitmap7 = await createImageBitmap(canvas1); |
| let commandEncoder30 = device0.createCommandEncoder({label: '\udc15\ufb6a\u3467\u{1fb3b}\u0627\u63c3\ud2e7\u4f3d'}); |
| let renderBundleEncoder29 = device0.createRenderBundleEncoder({ |
| label: '\uf41f\u0424\u25f4\u{1fec8}\u4757\uedd6\u0a5c\u009b', |
| colorFormats: ['rg8unorm', undefined], |
| depthStencilFormat: 'depth32float-stencil8', |
| depthReadOnly: true, |
| stencilReadOnly: true |
| }); |
| try { |
| computePassEncoder7.setBindGroup(6, bindGroup4, []); |
| } catch {} |
| try { |
| computePassEncoder7.dispatchWorkgroups(5, 3, 2); |
| } catch {} |
| try { |
| renderBundleEncoder15.setVertexBuffer(6, buffer1, 16492, 669); |
| } catch {} |
| try { |
| device0.pushErrorScope('validation'); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture11, |
| mipLevel: 3, |
| origin: { x: 1, y: 13, z: 21 }, |
| aspect: 'all', |
| }, new Float64Array(arrayBuffer3), /* required buffer size: 1424450 */ |
| {offset: 51, bytesPerRow: 103, rowsPerImage: 145}, {width: 3, height: 55, depthOrArrayLayers: 96}); |
| } catch {} |
| let canvas9 = document.createElement('canvas'); |
| let buffer11 = device1.createBuffer({size: 5078, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let commandEncoder31 = device1.createCommandEncoder({label: '\u{1f6fd}\u0af0\u01c4\u{1f738}\u0df2\u02aa\ue133\u1f50'}); |
| let renderBundleEncoder30 = device1.createRenderBundleEncoder({ |
| label: '\u049f\u052f\u{1fa32}\u04eb\uc0e5\u{1f7e4}\ube24', |
| colorFormats: ['r16uint', 'bgra8unorm', 'rgb10a2unorm'], |
| depthStencilFormat: 'depth24plus-stencil8', |
| stencilReadOnly: true |
| }); |
| try { |
| await buffer11.mapAsync(GPUMapMode.WRITE, 944, 2028); |
| } catch {} |
| try { |
| commandEncoder31.copyTextureToTexture({ |
| texture: texture36, |
| mipLevel: 5, |
| origin: { x: 0, y: 0, z: 39 }, |
| aspect: 'all', |
| }, { |
| texture: texture36, |
| mipLevel: 5, |
| origin: { x: 0, y: 0, z: 94 }, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 3}); |
| } catch {} |
| try { |
| device1.queue.submit([ |
| commandBuffer7, |
| ]); |
| } catch {} |
| try { |
| computePassEncoder14.end(); |
| } catch {} |
| try { |
| renderBundleEncoder21.setVertexBuffer(98, undefined, 2644774804); |
| } catch {} |
| try { |
| commandEncoder24.clearBuffer(buffer9); |
| dissociateBuffer(device1, buffer9); |
| } catch {} |
| document.body.prepend(canvas6); |
| let video8 = await videoWithData(); |
| let videoFrame9 = videoFrame7.clone(); |
| let texture42 = device1.createTexture({ |
| label: '\u0c93\u{1ff1a}\u0afc', |
| size: [1040, 51, 48], |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: ['rgba16sint'], |
| }); |
| let sampler27 = device1.createSampler({ |
| label: '\u{1f9a1}\u0cd6\u29f6\u{1fd52}\ue95f\ub847\u{1f940}\u7b26\u{1fcb0}\ua5c3\u{1fd2c}', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'nearest', |
| lodMinClamp: 52.341, |
| lodMaxClamp: 53.535, |
| }); |
| try { |
| commandEncoder29.copyTextureToTexture({ |
| texture: texture36, |
| mipLevel: 0, |
| origin: { x: 30, y: 0, z: 45 }, |
| aspect: 'all', |
| }, { |
| texture: texture36, |
| mipLevel: 1, |
| origin: { x: 0, y: 0, z: 105 }, |
| aspect: 'all', |
| }, {width: 30, height: 0, depthOrArrayLayers: 2}); |
| } catch {} |
| try { |
| device1.queue.writeBuffer(buffer9, 2940, new Float32Array(62700), 18463, 1592); |
| } catch {} |
| let gpuCanvasContext7 = canvas9.getContext('webgpu'); |
| let adapter4 = await navigator.gpu.requestAdapter({ |
| }); |
| let imageData12 = new ImageData(88, 152); |
| let bindGroupLayout17 = pipeline31.getBindGroupLayout(0); |
| let pipelineLayout9 = device0.createPipelineLayout({ |
| label: '\ubd7c\u0198\u1234\u78a2\u053a\ub6a3\u0672\ud0a2\u0c5e\u{1fd1a}\u0512', |
| bindGroupLayouts: [bindGroupLayout6, bindGroupLayout2, bindGroupLayout15] |
| }); |
| let commandBuffer8 = commandEncoder26.finish({ |
| }); |
| let texture43 = device0.createTexture({ |
| label: '\u2da0\u1e48\u6889\u0a0d\u0295\u66b5\u3032\u281d\u{1fcc1}', |
| size: [20, 240, 1], |
| mipLevelCount: 6, |
| format: 'astc-5x4-unorm', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView36 = texture3.createView({label: '\u0ee9\u{1f855}', dimension: '2d-array', baseMipLevel: 8}); |
| try { |
| renderBundleEncoder17.setBindGroup(4, bindGroup10); |
| } catch {} |
| try { |
| commandEncoder22.clearBuffer(buffer3); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| let pipeline39 = await device0.createComputePipelineAsync({ |
| label: '\u0236\u{1fd3f}\u830b\u0080\u4a42\u{1f72f}\u583d\ucf68\u8af0\u25ce\u6e0d', |
| layout: pipelineLayout2, |
| compute: { |
| module: shaderModule1, |
| entryPoint: 'compute0', |
| constants: {}, |
| }, |
| }); |
| try { |
| await promise27; |
| } catch {} |
| try { |
| window.someLabel = device0.queue.label; |
| } catch {} |
| let buffer12 = device0.createBuffer({ |
| label: '\u{1fe16}\ufed3\u{1fd7d}\u0598\u{1fd5e}\u508f', |
| size: 35978, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE |
| }); |
| let querySet26 = device0.createQuerySet({ |
| label: '\u{1ffb3}\u{1fd87}\u0d69\u{1fd20}\u0763\ucf88\u0d3e', |
| type: 'occlusion', |
| count: 2273, |
| }); |
| let renderBundle35 = renderBundleEncoder12.finish({label: '\u01d2\uc1eb\u8f64\u0c78'}); |
| let sampler28 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| lodMinClamp: 3.820, |
| }); |
| try { |
| computePassEncoder7.dispatchWorkgroups(3, 4, 5); |
| } catch {} |
| try { |
| computePassEncoder6.end(); |
| } catch {} |
| try { |
| renderBundleEncoder29.setVertexBuffer(5, buffer1); |
| } catch {} |
| try { |
| texture11.destroy(); |
| } catch {} |
| try { |
| commandEncoder15.clearBuffer(buffer12, 32996, 1980); |
| dissociateBuffer(device0, buffer12); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 30820, new Float32Array(41040), 23336, 420); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture26, |
| mipLevel: 0, |
| origin: { x: 187, y: 0, z: 0 }, |
| aspect: 'all', |
| }, new Int16Array(arrayBuffer0), /* required buffer size: 12177 */ |
| {offset: 649, bytesPerRow: 11604, rowsPerImage: 52}, {width: 2882, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 284, height: 2, depthOrArrayLayers: 1} |
| */ |
| { |
| source: video6, |
| origin: { x: 1, y: 1 }, |
| flipY: true, |
| }, { |
| texture: texture31, |
| mipLevel: 2, |
| origin: { x: 0, y: 0, z: 0 }, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 9, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await promise10; |
| } catch {} |
| document.body.prepend(video0); |
| let computePassEncoder15 = commandEncoder31.beginComputePass({label: '\u0deb\u07e6\uc77f\u233a\u95e2\u{1ff51}\u6c83\u0c1d\u8c9e'}); |
| let renderBundleEncoder31 = device1.createRenderBundleEncoder({ |
| label: '\u{1f81c}\u{1fea4}\u5738\u3d14\u038e\u0646\u4edd\ufc46\u3370\u{1fc1c}', |
| colorFormats: ['rgba16uint', 'rg32float', 'rgb10a2uint', 'rg8uint', 'r8sint'], |
| depthStencilFormat: 'depth32float-stencil8', |
| sampleCount: 4 |
| }); |
| try { |
| device1.queue.writeTexture({ |
| texture: texture34, |
| mipLevel: 0, |
| origin: { x: 25, y: 7, z: 76 }, |
| aspect: 'all', |
| }, new Int16Array(arrayBuffer0), /* required buffer size: 434576 */ |
| {offset: 359, bytesPerRow: 431, rowsPerImage: 100}, {width: 100, height: 8, depthOrArrayLayers: 11}); |
| } catch {} |
| document.body.prepend(img3); |
| let canvas10 = document.createElement('canvas'); |
| let renderBundle36 = renderBundleEncoder14.finish({label: '\ua770\uc692\u{1fdee}\u3566'}); |
| let sampler29 = device0.createSampler({ |
| label: '\u6062\u{1fb67}\u{1f9ee}\u46a3\u0092\u0af0\u{1ffe1}\uce12\u0ddb\u{1fe5b}', |
| addressModeV: 'repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 94.589, |
| maxAnisotropy: 15, |
| }); |
| try { |
| computePassEncoder7.dispatchWorkgroups(5); |
| } catch {} |
| try { |
| renderBundleEncoder26.setBindGroup(1, bindGroup7, []); |
| } catch {} |
| try { |
| commandEncoder16.copyBufferToTexture({ |
| /* bytesInLastRow: 12 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 57214 */ |
| offset: 57214, |
| buffer: buffer6, |
| }, { |
| texture: texture30, |
| mipLevel: 0, |
| origin: { x: 4, y: 1, z: 0 }, |
| aspect: 'all', |
| }, {width: 6, height: 0, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer6); |
| } catch {} |
| try { |
| commandEncoder9.copyTextureToTexture({ |
| texture: texture6, |
| mipLevel: 0, |
| origin: { x: 0, y: 0, z: 1 }, |
| aspect: 'all', |
| }, { |
| texture: texture5, |
| mipLevel: 2, |
| origin: { x: 168, y: 1, z: 15 }, |
| aspect: 'all', |
| }, {width: 1, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.submit([ |
| commandBuffer8, |
| ]); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture10, |
| mipLevel: 3, |
| origin: { x: 2, y: 2, z: 1 }, |
| aspect: 'all', |
| }, arrayBuffer0, /* required buffer size: 578738 */ |
| {offset: 153, bytesPerRow: 305, rowsPerImage: 271}, {width: 57, height: 0, depthOrArrayLayers: 8}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 2, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageBitmap3, |
| origin: { x: 1, y: 1 }, |
| flipY: true, |
| }, { |
| texture: texture31, |
| mipLevel: 9, |
| origin: { x: 0, y: 1, z: 0 }, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture44 = device0.createTexture({ |
| size: {width: 880}, |
| dimension: '1d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rgb10a2uint', 'rgb10a2uint', 'rgb10a2uint'], |
| }); |
| let textureView37 = texture0.createView({label: '\u01c9\u2b60\u1eb0\u{1ff17}\u28ba', dimension: '2d-array', baseMipLevel: 1, mipLevelCount: 1}); |
| try { |
| computePassEncoder5.setPipeline(pipeline38); |
| } catch {} |
| try { |
| renderBundleEncoder29.setBindGroup(6, bindGroup7); |
| } catch {} |
| try { |
| commandEncoder30.copyTextureToBuffer({ |
| texture: texture15, |
| mipLevel: 0, |
| origin: { x: 0, y: 0, z: 0 }, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 8 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 10216 */ |
| offset: 10208, |
| buffer: buffer12, |
| }, {width: 1, height: 1, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer12); |
| } catch {} |
| let bindGroup15 = device0.createBindGroup({ |
| label: '\u{1fe4d}\u385d\u0739\ubed0\u070f', |
| layout: bindGroupLayout4, |
| entries: [], |
| }); |
| let texture45 = device0.createTexture({ |
| label: '\uf05f\uf40b\u0a84\u0ad8\ue4d2\u0770', |
| size: [588, 1, 235], |
| mipLevelCount: 4, |
| dimension: '3d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderBundleEncoder22.setBindGroup(3, bindGroup1); |
| } catch {} |
| try { |
| renderBundleEncoder26.insertDebugMarker('\u0bb0'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 22248, new DataView(new ArrayBuffer(55358)), 31426, 21004); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture12, |
| mipLevel: 2, |
| origin: { x: 0, y: 0, z: 63 }, |
| aspect: 'all', |
| }, new ArrayBuffer(32), /* required buffer size: 27525954 */ |
| {offset: 426, bytesPerRow: 706, rowsPerImage: 228}, {width: 480, height: 0, depthOrArrayLayers: 172}); |
| } catch {} |
| let commandEncoder32 = device1.createCommandEncoder(); |
| let textureView38 = texture42.createView({ |
| label: '\u{1fc8f}\ub962\u0d92\ua674\u0f03\u1db7\u{1f8bf}\u5c09\u4d7d', |
| format: 'rgba16sint', |
| baseMipLevel: 0 |
| }); |
| let computePassEncoder16 = commandEncoder29.beginComputePass({label: '\ua06b\u000d\u6764\u{1f6a6}\u03b4\u58d4\u{1fb83}'}); |
| try { |
| gpuCanvasContext3.configure({ |
| device: device1, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rgba8unorm-srgb', 'stencil8', 'bgra8unorm-srgb', 'astc-8x8-unorm-srgb'], |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| device1.queue.writeTexture({ |
| texture: texture34, |
| mipLevel: 0, |
| origin: { x: 34, y: 3, z: 43 }, |
| aspect: 'all', |
| }, new ArrayBuffer(32), /* required buffer size: 6683849 */ |
| {offset: 650, bytesPerRow: 495, rowsPerImage: 173}, {width: 102, height: 8, depthOrArrayLayers: 79}); |
| } catch {} |
| let pipelineLayout10 = device0.createPipelineLayout({ |
| label: '\u913b\u0937', |
| bindGroupLayouts: [bindGroupLayout2, bindGroupLayout15, bindGroupLayout15, bindGroupLayout8, bindGroupLayout0, bindGroupLayout6, bindGroupLayout7] |
| }); |
| try { |
| computePassEncoder10.end(); |
| } catch {} |
| try { |
| renderBundleEncoder15.setBindGroup(4, bindGroup14, []); |
| } catch {} |
| let arrayBuffer5 = buffer0.getMappedRange(14560, 976); |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData4, |
| origin: { x: 74, y: 60 }, |
| flipY: true, |
| }, { |
| texture: texture31, |
| mipLevel: 10, |
| origin: { x: 0, y: 0, z: 1 }, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 1, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let imageData13 = new ImageData(180, 152); |
| try { |
| canvas10.getContext('webgl2'); |
| } catch {} |
| let bindGroupLayout18 = device1.createBindGroupLayout({ |
| label: '\uc67c\u0f44\u443e\u{1f840}\u{1fa16}', |
| entries: [], |
| }); |
| let textureView39 = texture33.createView({dimension: '2d-array', aspect: 'all', baseMipLevel: 2, mipLevelCount: 3}); |
| try { |
| computePassEncoder12.popDebugGroup(); |
| } catch {} |
| try { |
| device1.destroy(); |
| } catch {} |
| let renderBundleEncoder32 = device0.createRenderBundleEncoder({ |
| label: '\u39c7\u0418\u{1ff5b}\u03ba\u8224\u{1fb63}\u4ef6', |
| colorFormats: ['rgb10a2unorm', 'bgra8unorm-srgb', 'rgba16float', 'rg32sint', 'rg16float', 'r8sint'], |
| depthReadOnly: true |
| }); |
| try { |
| computePassEncoder1.setPipeline(pipeline21); |
| } catch {} |
| try { |
| commandEncoder23.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 41640 */ |
| offset: 41640, |
| bytesPerRow: 0, |
| rowsPerImage: 375, |
| buffer: buffer6, |
| }, { |
| texture: texture11, |
| mipLevel: 2, |
| origin: { x: 18, y: 56, z: 22 }, |
| aspect: 'all', |
| }, {width: 0, height: 137, depthOrArrayLayers: 197}); |
| dissociateBuffer(device0, buffer6); |
| } catch {} |
| try { |
| commandEncoder15.resolveQuerySet(querySet1, 746, 362, buffer12, 17408); |
| } catch {} |
| let offscreenCanvas7 = new OffscreenCanvas(752, 691); |
| let computePassEncoder17 = commandEncoder30.beginComputePass({}); |
| let renderBundle37 = renderBundleEncoder12.finish({label: '\ua81d\u5ddd\ud4ba\u0779'}); |
| try { |
| computePassEncoder7.dispatchWorkgroups(5, 2); |
| } catch {} |
| try { |
| computePassEncoder7.dispatchWorkgroupsIndirect(buffer3, 16732); |
| } catch {} |
| try { |
| renderBundleEncoder15.setVertexBuffer(5, buffer1); |
| } catch {} |
| try { |
| buffer0.destroy(); |
| } catch {} |
| try { |
| commandEncoder28.copyTextureToBuffer({ |
| texture: texture18, |
| mipLevel: 4, |
| origin: { x: 17, y: 0, z: 0 }, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 32 widthInBlocks: 16 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 42418 */ |
| offset: 42386, |
| buffer: buffer3, |
| }, {width: 16, height: 1, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| commandEncoder15.copyTextureToTexture({ |
| texture: texture18, |
| mipLevel: 5, |
| origin: { x: 21, y: 1, z: 0 }, |
| aspect: 'all', |
| }, { |
| texture: texture30, |
| mipLevel: 0, |
| origin: { x: 1, y: 1, z: 0 }, |
| aspect: 'all', |
| }, {width: 5, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| device0.queue.submit([ |
| ]); |
| } catch {} |
| let gpuCanvasContext8 = offscreenCanvas7.getContext('webgpu'); |
| let textureView40 = texture3.createView({ |
| label: '\u{1ffb2}\u0cb3\u{1f6eb}\u08b4\u01ce\u491e\u{1fcf9}\u{1fd19}\u6b54\u4540', |
| dimension: '2d-array', |
| baseMipLevel: 8 |
| }); |
| try { |
| renderBundleEncoder17.setBindGroup(6, bindGroup6, new Uint32Array(6540), 6364, 0); |
| } catch {} |
| try { |
| renderBundleEncoder26.setVertexBuffer(4, buffer1, 40, 3090); |
| } catch {} |
| try { |
| commandEncoder16.copyBufferToBuffer(buffer0, 7460, buffer3, 33004, 6032); |
| dissociateBuffer(device0, buffer0); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| commandEncoder13.clearBuffer(buffer3); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 22624, new Float32Array(32256), 10915, 1340); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture19, |
| mipLevel: 3, |
| origin: { x: 38, y: 0, z: 10 }, |
| aspect: 'all', |
| }, arrayBuffer0, /* required buffer size: 250395 */ |
| {offset: 351, bytesPerRow: 216, rowsPerImage: 15}, {width: 33, height: 3, depthOrArrayLayers: 78}); |
| } catch {} |
| video6.height = 139; |
| offscreenCanvas3.width = 891; |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let device2 = await adapter4.requestDevice({ |
| requiredLimits: { |
| maxBindGroups: 9, |
| maxColorAttachmentBytesPerSample: 38, |
| maxVertexAttributes: 27, |
| maxVertexBufferArrayStride: 56471, |
| maxStorageBuffersPerShaderStage: 27, |
| maxDynamicStorageBuffersPerPipelineLayout: 57215, |
| maxBindingsPerBindGroup: 3849, |
| maxTextureDimension1D: 15592, |
| maxTextureDimension2D: 10351, |
| maxUniformBufferBindingSize: 135140657, |
| maxUniformBuffersPerShaderStage: 30, |
| maxInterStageShaderVariables: 33, |
| maxSamplersPerShaderStage: 20, |
| }, |
| }); |
| let texture46 = device0.createTexture({ |
| label: '\u088b\ue4d3\uc0ed\u2a44\u006f', |
| size: [1442, 96, 125], |
| mipLevelCount: 11, |
| dimension: '3d', |
| format: 'rgba32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler30 = device0.createSampler({ |
| label: '\u05b7\u91ca\ue5cd\u{1fc4c}\u605e\u0276\u0195', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 66.061, |
| lodMaxClamp: 75.046, |
| }); |
| try { |
| computePassEncoder1.setPipeline(pipeline22); |
| } catch {} |
| let pipeline40 = device0.createComputePipeline({ |
| label: '\u5ff0\u08ff\u0ece\u2986\u{1f98a}\u{1f62d}\u0a84\u0f29', |
| layout: pipelineLayout7, |
| compute: { |
| module: shaderModule5, |
| entryPoint: 'compute0', |
| constants: {}, |
| }, |
| }); |
| let imageData14 = new ImageData(248, 192); |
| let computePassEncoder18 = commandEncoder12.beginComputePass({label: '\uad40\u{1ff81}\u0f4b\u1a50\u288c'}); |
| try { |
| commandEncoder9.copyBufferToBuffer(buffer5, 10376, buffer3, 10700, 5072); |
| dissociateBuffer(device0, buffer5); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| let pipeline41 = device0.createComputePipeline({ |
| label: '\ua763\u7603\uced1\u{1f9b9}\u{1f99e}\u2ac4\u0e90\u{1f86f}', |
| layout: pipelineLayout7, |
| compute: { |
| module: shaderModule0, |
| entryPoint: 'compute0', |
| constants: {}, |
| }, |
| }); |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55) }; |
| } catch {} |
| let img6 = await imageWithData(107, 216, '#8c3493d1', '#71cf28d0'); |
| let device3 = await adapter3.requestDevice({ |
| label: '\u3f8f\u03e1\u01c8\u0a28', |
| requiredFeatures: [ |
| 'depth-clip-control', |
| 'depth32float-stencil8', |
| 'texture-compression-etc2', |
| 'shader-f16', |
| 'rg11b10ufloat-renderable', |
| 'bgra8unorm-storage' |
| ], |
| }); |
| let commandEncoder33 = device3.createCommandEncoder({label: '\u0025\u{1f652}\u{1fec9}\u{1fe1e}\ufd8b\u93dc\uce6a\u{1feaf}\u{1fa70}'}); |
| try { |
| await device3.queue.onSubmittedWorkDone(); |
| } catch {} |
| let offscreenCanvas8 = new OffscreenCanvas(418, 95); |
| try { |
| adapter2.label = '\u5907\u{1fb30}\u2e57\u51d6\u8f41\udc12'; |
| } catch {} |
| let img7 = await imageWithData(292, 190, '#41126ea9', '#98c96499'); |
| let textureView41 = texture15.createView({ |
| label: '\ud6cf\u025c\u{1f8cf}\u7cb4\uad80\ua5fc', |
| dimension: '2d-array', |
| format: 'astc-10x6-unorm-srgb', |
| baseArrayLayer: 0 |
| }); |
| try { |
| computePassEncoder7.dispatchWorkgroupsIndirect(buffer3, 39240); |
| } catch {} |
| try { |
| renderBundleEncoder24.setBindGroup(5, bindGroup13, []); |
| } catch {} |
| let imageData15 = new ImageData(208, 168); |
| let texture47 = device2.createTexture({ |
| label: '\u04ec\u{1ff0d}\u002f\u0e9b\ubcf4\u985a\u082c\uc28f\ucbd9\u44e1', |
| size: [207, 15, 37], |
| mipLevelCount: 2, |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rgba32sint', 'rgba32sint'], |
| }); |
| try { |
| gpuCanvasContext5.unconfigure(); |
| } catch {} |
| try { |
| await adapter2.requestAdapterInfo(); |
| } catch {} |
| try { |
| offscreenCanvas8.getContext('webgpu'); |
| } catch {} |
| try { |
| device3.queue.label = '\u5858\uf2b2\u{1febd}\u9cd4\ufc5d\ub16b'; |
| } catch {} |
| let commandEncoder34 = device3.createCommandEncoder({label: '\u521e\u0b7e\u{1fbf8}\u8db9\u5670\u08e7\u06c3\u0298\ud8b6'}); |
| let offscreenCanvas9 = new OffscreenCanvas(675, 206); |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let renderBundle38 = renderBundleEncoder15.finish({label: '\u4699\u{1f635}\u3829\u3655'}); |
| try { |
| renderBundleEncoder24.setBindGroup(5, bindGroup15); |
| } catch {} |
| try { |
| renderBundleEncoder22.setIndexBuffer(buffer10, 'uint32', 7176, 36683); |
| } catch {} |
| try { |
| texture40.destroy(); |
| } catch {} |
| try { |
| commandEncoder23.copyBufferToBuffer(buffer0, 2520, buffer3, 41604, 1160); |
| dissociateBuffer(device0, buffer0); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| commandEncoder13.copyTextureToBuffer({ |
| texture: texture22, |
| mipLevel: 0, |
| origin: { x: 9, y: 1, z: 0 }, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 80 widthInBlocks: 20 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 41556 */ |
| offset: 41556, |
| buffer: buffer3, |
| }, {width: 20, height: 0, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| commandEncoder25.copyTextureToTexture({ |
| texture: texture18, |
| mipLevel: 0, |
| origin: { x: 406, y: 0, z: 0 }, |
| aspect: 'all', |
| }, { |
| texture: texture18, |
| mipLevel: 6, |
| origin: { x: 3, y: 0, z: 0 }, |
| aspect: 'all', |
| }, {width: 9, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| let querySet27 = device1.createQuerySet({ |
| type: 'occlusion', |
| count: 237, |
| }); |
| let renderBundleEncoder33 = device1.createRenderBundleEncoder({ |
| label: '\u9489\ue429\u940e\u{1fcf7}\u04b9\u0a00\ua4fe\u0d85\u0fde\u4f7e\u08de', |
| colorFormats: ['r16uint', 'bgra8unorm', 'rgb10a2unorm'], |
| depthStencilFormat: 'depth24plus-stencil8', |
| depthReadOnly: true |
| }); |
| try { |
| commandEncoder32.copyBufferToBuffer(buffer11, 2608, buffer9, 17272, 1544); |
| dissociateBuffer(device1, buffer11); |
| dissociateBuffer(device1, buffer9); |
| } catch {} |
| try { |
| gpuCanvasContext5.configure({ |
| device: device1, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['astc-8x6-unorm', 'bgra8unorm-srgb', 'bgra8unorm', 'astc-5x4-unorm'], |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| try { |
| device1.queue.writeTexture({ |
| texture: texture34, |
| mipLevel: 0, |
| origin: { x: 8, y: 6, z: 15 }, |
| aspect: 'all', |
| }, new ArrayBuffer(13164529), /* required buffer size: 13164529 */ |
| {offset: 199, bytesPerRow: 448, rowsPerImage: 260}, {width: 149, height: 5, depthOrArrayLayers: 114}); |
| } catch {} |
| document.body.prepend(img3); |
| let imageBitmap8 = await createImageBitmap(imageData3); |
| let imageData16 = new ImageData(48, 80); |
| let querySet28 = device2.createQuerySet({ |
| label: '\u{1f895}\ua3ec\ue2a2\u8b88\u91e1\u0d6e\u0dab', |
| type: 'occlusion', |
| count: 1258, |
| }); |
| let renderBundleEncoder34 = device2.createRenderBundleEncoder({ |
| colorFormats: [], |
| depthStencilFormat: 'depth24plus-stencil8', |
| sampleCount: 4, |
| depthReadOnly: false, |
| stencilReadOnly: true |
| }); |
| let renderBundle39 = renderBundleEncoder34.finish({label: '\u44d5\u{1f76b}\u0ea6\u5a90\ua3fb'}); |
| let img8 = await imageWithData(177, 161, '#e1c736ca', '#9a5ed6c8'); |
| let video9 = await videoWithData(); |
| let sampler31 = device0.createSampler({ |
| label: '\u{1f64e}\u56db\ue5b1\u{1f877}\u76a8\u08f4\u1d28\u0aaf', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| lodMinClamp: 67.825, |
| lodMaxClamp: 79.611, |
| }); |
| try { |
| computePassEncoder7.setPipeline(pipeline41); |
| } catch {} |
| try { |
| renderBundleEncoder24.setBindGroup(6, bindGroup6); |
| } catch {} |
| try { |
| commandEncoder20.copyBufferToBuffer(buffer4, 7204, buffer12, 21780, 2648); |
| dissociateBuffer(device0, buffer4); |
| dissociateBuffer(device0, buffer12); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| try { |
| offscreenCanvas9.getContext('webgl'); |
| } catch {} |
| let textureView42 = texture13.createView({label: '\u{1f98a}\u0d7b\u5f24\u21da\uda29', mipLevelCount: 2, arrayLayerCount: 1}); |
| let computePassEncoder19 = commandEncoder20.beginComputePass({}); |
| try { |
| computePassEncoder17.setBindGroup(2, bindGroup7, new Uint32Array(3195), 480, 0); |
| } catch {} |
| try { |
| commandEncoder25.copyBufferToBuffer(buffer5, 8556, buffer3, 18072, 7984); |
| dissociateBuffer(device0, buffer5); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| gpuCanvasContext5.unconfigure(); |
| } catch {} |
| let img9 = await imageWithData(178, 33, '#174453fe', '#1fbc4cca'); |
| let canvas11 = document.createElement('canvas'); |
| let gpuCanvasContext9 = canvas11.getContext('webgpu'); |
| let offscreenCanvas10 = new OffscreenCanvas(791, 955); |
| let offscreenCanvas11 = new OffscreenCanvas(305, 52); |
| let texture48 = device2.createTexture({ |
| label: '\uf584\u{1ff6a}\u4f40\u45a6\u7007\u{1fdad}', |
| size: [1656, 120, 82], |
| mipLevelCount: 9, |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rgba8sint'], |
| }); |
| let renderBundleEncoder35 = device2.createRenderBundleEncoder({ |
| label: '\u0e06\u89ee\u8c5d\u49c0\u52b6\u0f6d\u045a\u{1fe30}\u730b', |
| colorFormats: [], |
| depthStencilFormat: 'depth24plus-stencil8', |
| sampleCount: 4, |
| depthReadOnly: true, |
| stencilReadOnly: true |
| }); |
| try { |
| device2.queue.writeTexture({ |
| texture: texture48, |
| mipLevel: 7, |
| origin: { x: 1, y: 0, z: 0 }, |
| aspect: 'all', |
| }, new ArrayBuffer(670), /* required buffer size: 670 */ |
| {offset: 670}, {width: 9, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| gc(); |
| try { |
| await adapter4.requestAdapterInfo(); |
| } catch {} |
| canvas0.height = 907; |
| video4.height = 96; |
| let offscreenCanvas12 = new OffscreenCanvas(964, 754); |
| let commandEncoder35 = device3.createCommandEncoder({label: '\u1797\ua2e5'}); |
| offscreenCanvas11.width = 207; |
| let offscreenCanvas13 = new OffscreenCanvas(835, 869); |
| let imageBitmap9 = await createImageBitmap(offscreenCanvas8); |
| let videoFrame10 = new VideoFrame(imageBitmap6, {timestamp: 0}); |
| let renderBundleEncoder36 = device0.createRenderBundleEncoder({ |
| label: '\u86df\ucdce', |
| colorFormats: ['rgba8unorm', 'r8sint', undefined], |
| sampleCount: 4, |
| depthReadOnly: true, |
| stencilReadOnly: false |
| }); |
| try { |
| renderBundleEncoder17.setBindGroup(6, bindGroup3); |
| } catch {} |
| try { |
| commandEncoder16.copyTextureToTexture({ |
| texture: texture18, |
| mipLevel: 5, |
| origin: { x: 20, y: 1, z: 0 }, |
| aspect: 'all', |
| }, { |
| texture: texture18, |
| mipLevel: 3, |
| origin: { x: 81, y: 1, z: 0 }, |
| aspect: 'all', |
| }, {width: 6, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| commandEncoder9.resolveQuerySet(querySet8, 77, 105, buffer12, 25344); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer12, 32412, new BigUint64Array(30794), 4910, 384); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let img10 = await imageWithData(281, 34, '#877ed0db', '#b2c34080'); |
| try { |
| gpuCanvasContext4.unconfigure(); |
| } catch {} |
| let adapter5 = await promise21; |
| try { |
| await adapter5.requestAdapterInfo(); |
| } catch {} |
| try { |
| device2.label = '\ub234\u{1f87b}\u046e\u691a\u6929\u0ee9\u07c8'; |
| } catch {} |
| let texture49 = device2.createTexture({ |
| label: '\u{1fa1d}\u{1fcb0}\uf02e\u{1f918}', |
| size: [207], |
| dimension: '1d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_SRC, |
| viewFormats: [], |
| }); |
| let renderBundleEncoder37 = device2.createRenderBundleEncoder({ |
| label: '\uc340\u0dce\u0a59\u{1fc33}\u709d\u8008\uba61\uc169\u1691\ub0e7', |
| colorFormats: [], |
| depthStencilFormat: 'depth24plus-stencil8', |
| sampleCount: 4, |
| stencilReadOnly: true |
| }); |
| let renderBundle40 = renderBundleEncoder34.finish({label: '\u0103\u1717\uf111\u0ef4\u04a4\u4ae7\u0956'}); |
| try { |
| device2.pushErrorScope('internal'); |
| } catch {} |
| let adapter6 = await navigator.gpu.requestAdapter({ |
| }); |
| let texture50 = device3.createTexture({ |
| size: {width: 860, height: 1, depthOrArrayLayers: 190}, |
| mipLevelCount: 4, |
| format: 'r16uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: ['r16uint', 'r16uint', 'r16uint'], |
| }); |
| let sampler32 = device3.createSampler({ |
| label: '\u{1fb38}\uddd8\uee54', |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| lodMaxClamp: 90.564, |
| }); |
| try { |
| gpuCanvasContext1.configure({ |
| device: device3, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['r16float', 'r32float', 'rgba8unorm-srgb', 'rgba8unorm-srgb'], |
| }); |
| } catch {} |
| document.body.prepend(img0); |
| let querySet29 = device3.createQuerySet({ |
| label: '\u7966\u{1f708}\u4d7e\u881f', |
| type: 'occlusion', |
| count: 390, |
| }); |
| pseudoSubmit(device3, commandEncoder33); |
| let texture51 = device3.createTexture({ |
| label: '\u95d3\u0a8d\u0be6\u{1fd48}\u0260\u0629\u0e81', |
| size: [6880, 1, 1], |
| mipLevelCount: 7, |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let sampler33 = device3.createSampler({ |
| label: '\ud89f\u6ee3\uec70\u8efb', |
| addressModeU: 'mirror-repeat', |
| magFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 54.255, |
| lodMaxClamp: 58.137, |
| compare: 'not-equal', |
| }); |
| let gpuCanvasContext10 = offscreenCanvas10.getContext('webgpu'); |
| let bindGroupLayout19 = device3.createBindGroupLayout({ |
| label: '\uac3b\u{1fb0c}\u{1fbb8}\u{1fb97}\u{1fb2b}\u90a1', |
| entries: [], |
| }); |
| let querySet30 = device3.createQuerySet({ |
| type: 'occlusion', |
| count: 3435, |
| }); |
| let texture52 = device3.createTexture({ |
| label: '\u05f7\u014c', |
| size: [1776, 20, 32], |
| mipLevelCount: 5, |
| format: 'etc2-rgba8unorm-srgb', |
| usage: GPUTextureUsage.COPY_SRC, |
| }); |
| let sampler34 = device3.createSampler({ |
| label: '\u38b8\u007d\u0ee5\u0e9c\u0443\u{1fd1c}\u08e2', |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 56.452, |
| lodMaxClamp: 85.476, |
| compare: 'equal', |
| maxAnisotropy: 6, |
| }); |
| try { |
| device3.queue.writeTexture({ |
| texture: texture51, |
| mipLevel: 5, |
| origin: { x: 64, y: 0, z: 0 }, |
| aspect: 'all', |
| }, arrayBuffer3, /* required buffer size: 997 */ |
| {offset: 777}, {width: 55, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| let bindGroupLayout20 = device2.createBindGroupLayout({ |
| label: '\u86fc\u8b39\u0505\u{1f6d3}\u{1fc55}\u{1fe51}\u5a16\u{1f84f}\u{1f871}\u85ed', |
| entries: [{ |
| binding: 3183, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| sampler: { type: 'filtering' }, |
| }, { |
| binding: 2585, |
| visibility: 0, |
| externalTexture: {}, |
| }], |
| }); |
| let commandEncoder36 = device2.createCommandEncoder({label: '\ud083\u03e0\u5ddc'}); |
| try { |
| renderBundleEncoder37.setVertexBuffer(50, undefined); |
| } catch {} |
| try { |
| querySet28.destroy(); |
| } catch {} |
| let gpuCanvasContext11 = offscreenCanvas13.getContext('webgpu'); |
| let video10 = await videoWithData(); |
| let sampler35 = device0.createSampler({ |
| label: '\u{1f603}\u5a06\u4518\u6087\u0cb9\u8ac7\u426d\u0cf9\u5f71', |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 22.798, |
| lodMaxClamp: 50.141, |
| maxAnisotropy: 3, |
| }); |
| try { |
| commandEncoder15.copyTextureToTexture({ |
| texture: texture8, |
| mipLevel: 0, |
| origin: { x: 0, y: 1, z: 1 }, |
| aspect: 'all', |
| }, { |
| texture: texture5, |
| mipLevel: 3, |
| origin: { x: 24, y: 1, z: 11 }, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder25.clearBuffer(buffer12, 19224, 5104); |
| dissociateBuffer(device0, buffer12); |
| } catch {} |
| let imageBitmap10 = await createImageBitmap(video7); |
| pseudoSubmit(device0, commandEncoder13); |
| let texture53 = device0.createTexture({ |
| label: '\ua067\u0567\u577e\u511a\u{1f6bd}\u042b\ucf82\ufa2f\u{1f8f0}\u0787', |
| size: {width: 9088, height: 72, depthOrArrayLayers: 1}, |
| mipLevelCount: 4, |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| let renderBundleEncoder38 = device0.createRenderBundleEncoder({ |
| label: '\u{1fe7e}\u0cf6\ufe81\u{1fcb9}\u0ebb\u{1f7dd}\u4cf1\ue96d\u0569\u{1f770}', |
| colorFormats: ['r16float', 'rgba32float', 'rgba32uint', 'rgba8unorm', undefined, 'rgba16float'], |
| stencilReadOnly: true |
| }); |
| try { |
| computePassEncoder19.setBindGroup(5, bindGroup9, new Uint32Array(6527), 1368, 0); |
| } catch {} |
| try { |
| querySet11.destroy(); |
| } catch {} |
| try { |
| commandEncoder9.resolveQuerySet(querySet26, 607, 347, buffer12, 7680); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture7, |
| mipLevel: 1, |
| origin: { x: 5, y: 28, z: 0 }, |
| aspect: 'all', |
| }, new Uint8Array(arrayBuffer2), /* required buffer size: 350 */ |
| {offset: 332, bytesPerRow: 2}, {width: 0, height: 40, depthOrArrayLayers: 1}); |
| } catch {} |
| let pipeline42 = device0.createRenderPipeline({ |
| label: '\u0b9a\u9a48', |
| layout: pipelineLayout5, |
| fragment: { |
| module: shaderModule4, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{format: 'r16float', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE}, {format: 'rgba32float', writeMask: GPUColorWrite.BLUE | GPUColorWrite.RED}, {format: 'rgba32uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE}, {format: 'rgba8unorm'}, undefined, {format: 'rgba16float'}] |
| }, |
| vertex: { |
| module: shaderModule4, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 2172, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'uint32', |
| offset: 1840, |
| shaderLocation: 8, |
| }, { |
| format: 'uint32', |
| offset: 72, |
| shaderLocation: 2, |
| }, { |
| format: 'snorm16x2', |
| offset: 940, |
| shaderLocation: 12, |
| }, { |
| format: 'uint8x4', |
| offset: 644, |
| shaderLocation: 13, |
| }, { |
| format: 'uint32x2', |
| offset: 948, |
| shaderLocation: 0, |
| }, { |
| format: 'unorm10-10-10-2', |
| offset: 2048, |
| shaderLocation: 11, |
| }, { |
| format: 'snorm16x2', |
| offset: 1860, |
| shaderLocation: 5, |
| }], |
| }, |
| { |
| arrayStride: 9936, |
| stepMode: 'instance', |
| attributes: [], |
| }, |
| { |
| arrayStride: 14420, |
| attributes: [{ |
| format: 'sint32x2', |
| offset: 2852, |
| shaderLocation: 14, |
| }, { |
| format: 'snorm16x2', |
| offset: 12232, |
| shaderLocation: 7, |
| }], |
| } |
| ] |
| }, |
| primitive: { |
| topology: 'point-list', |
| }, |
| }); |
| gc(); |
| let texture54 = device0.createTexture({ |
| size: {width: 10, height: 120, depthOrArrayLayers: 187}, |
| mipLevelCount: 4, |
| dimension: '3d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST, |
| viewFormats: ['rg8uint', 'rg8uint'], |
| }); |
| let computePassEncoder20 = commandEncoder22.beginComputePass({label: '\u53cf\ub0d3\ud604\u{1f9c2}'}); |
| let renderBundleEncoder39 = device0.createRenderBundleEncoder({ |
| colorFormats: ['rgb10a2unorm', 'bgra8unorm-srgb', 'rgba16float', 'rg32sint', 'rg16float', 'r8sint'], |
| depthReadOnly: true |
| }); |
| let sampler36 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| lodMinClamp: 60.675, |
| lodMaxClamp: 72.322, |
| }); |
| try { |
| computePassEncoder18.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderBundleEncoder39.setVertexBuffer(3, buffer1); |
| } catch {} |
| try { |
| commandEncoder9.resolveQuerySet(querySet14, 447, 1555, buffer12, 3584); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer12, 10184, new Int16Array(7011), 3556, 3216); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| if (!arrayBuffer4.detached) { new Uint8Array(arrayBuffer4).fill(0x55) }; |
| } catch {} |
| try { |
| commandEncoder34.label = '\u{1ff21}\ud49a\u{1fd4b}\u0b1e\ua1d5\u010b\u0590\u021f\ubc6c'; |
| } catch {} |
| let bindGroupLayout21 = device3.createBindGroupLayout({ |
| entries: [{ |
| binding: 188, |
| visibility: GPUShaderStage.COMPUTE, |
| sampler: { type: 'non-filtering' }, |
| }, { |
| binding: 636, |
| visibility: GPUShaderStage.FRAGMENT, |
| externalTexture: {}, |
| }], |
| }); |
| let querySet31 = device3.createQuerySet({ |
| label: '\udeba\u3399\ucb37\u1ffd\u0c89\u9a72\u03d3\u03fe', |
| type: 'occlusion', |
| count: 1993, |
| }); |
| let texture55 = device3.createTexture({ |
| label: '\ud7ae\u{1f8b0}\u0415\uf20b\u{1f7c7}\u3512\u0b62\u531e', |
| size: [1986], |
| dimension: '1d', |
| format: 'r8snorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder21 = commandEncoder34.beginComputePass({label: '\u5bda\u031e\u6ed1\u541a\u1ea7\uecfe\u4ff6\u180c\ufa86\uaedb\u2b4a'}); |
| try { |
| gpuCanvasContext11.configure({ |
| device: device3, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC, |
| viewFormats: ['eac-r11snorm', 'bgra8unorm', 'rgba8snorm', 'bgra8unorm-srgb'], |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let gpuCanvasContext12 = offscreenCanvas12.getContext('webgpu'); |
| let offscreenCanvas14 = new OffscreenCanvas(479, 476); |
| document.body.prepend(canvas11); |
| let imageData17 = new ImageData(100, 52); |
| let computePassEncoder22 = commandEncoder17.beginComputePass({label: '\u035a\ue328\udf25\u0973\u{1f6f0}\u0ad7\udaa3\u0d8a'}); |
| let renderBundleEncoder40 = device0.createRenderBundleEncoder({ |
| label: '\u77ca\u5943\u31dc\u8a26\u{1fc1e}', |
| colorFormats: ['rgb10a2unorm', 'bgra8unorm-srgb', 'rgba16float', 'rg32sint', 'rg16float', 'r8sint'], |
| depthReadOnly: true, |
| stencilReadOnly: true |
| }); |
| try { |
| commandEncoder23.copyBufferToTexture({ |
| /* bytesInLastRow: 64 widthInBlocks: 4 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 51216 */ |
| offset: 51216, |
| bytesPerRow: 256, |
| rowsPerImage: 43, |
| buffer: buffer6, |
| }, { |
| texture: texture35, |
| mipLevel: 0, |
| origin: { x: 0, y: 192, z: 1 }, |
| aspect: 'all', |
| }, {width: 32, height: 192, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer6); |
| } catch {} |
| try { |
| commandEncoder23.copyTextureToBuffer({ |
| texture: texture3, |
| mipLevel: 4, |
| origin: { x: 0, y: 6, z: 0 }, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 18192 */ |
| offset: 18192, |
| buffer: buffer3, |
| }, {width: 0, height: 6, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| commandEncoder15.copyTextureToTexture({ |
| texture: texture18, |
| mipLevel: 2, |
| origin: { x: 202, y: 0, z: 0 }, |
| aspect: 'all', |
| }, { |
| texture: texture30, |
| mipLevel: 0, |
| origin: { x: 1, y: 0, z: 0 }, |
| aspect: 'all', |
| }, {width: 0, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| device0.queue.submit([ |
| ]); |
| } catch {} |
| let pipeline43 = device0.createComputePipeline({ |
| label: '\u0771\u0e34\u5458\u3762\ua14b\u4240\u{1fdcb}\u{1fad3}\u0d09', |
| layout: pipelineLayout5, |
| compute: { |
| module: shaderModule0, |
| entryPoint: 'compute0', |
| constants: {}, |
| }, |
| }); |
| let pipelineLayout11 = device2.createPipelineLayout({ |
| label: '\u6afd\u96cc', |
| bindGroupLayouts: [bindGroupLayout20, bindGroupLayout20, bindGroupLayout20, bindGroupLayout20, bindGroupLayout20, bindGroupLayout20, bindGroupLayout20, bindGroupLayout20, bindGroupLayout20] |
| }); |
| let computePassEncoder23 = commandEncoder36.beginComputePass({label: '\u0358\u8ce8\u958c\uc6cd\u{1fb8c}\u173f'}); |
| let sampler37 = device2.createSampler({ |
| label: '\u7f23\u0dee\uec46\u{1f863}\uea48\u{1f90f}', |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| lodMinClamp: 55.877, |
| lodMaxClamp: 61.744, |
| }); |
| try { |
| device2.queue.writeTexture({ |
| texture: texture48, |
| mipLevel: 5, |
| origin: { x: 12, y: 0, z: 1 }, |
| aspect: 'all', |
| }, arrayBuffer4, /* required buffer size: 1467 */ |
| {offset: 803, bytesPerRow: 260}, {width: 36, height: 3, depthOrArrayLayers: 1}); |
| } catch {} |
| let gpuCanvasContext13 = offscreenCanvas14.getContext('webgpu'); |
| let shaderModule7 = device2.createShaderModule({ |
| label: '\u027e\u{1fc56}\u000c\u{1f6c1}\uf0ca\ue802\u6acf\u02e9\u69cc', |
| code: `@group(0) @binding(2585) |
| var<storage, read_write> i2: array<u32>; |
| @group(3) @binding(2585) |
| var<storage, read_write> i3: array<u32>; |
| @group(2) @binding(2585) |
| var<storage, read_write> local1: array<u32>; |
| @group(5) @binding(2585) |
| var<storage, read_write> i4: array<u32>; |
| @group(7) @binding(2585) |
| var<storage, read_write> function3: array<u32>; |
| @group(7) @binding(3183) |
| var<storage, read_write> parameter0: array<u32>; |
| @group(3) @binding(3183) |
| var<storage, read_write> field3: array<u32>; |
| @group(1) @binding(2585) |
| var<storage, read_write> function4: array<u32>; |
| @group(6) @binding(2585) |
| var<storage, read_write> global0: array<u32>; |
| @group(1) @binding(3183) |
| var<storage, read_write> parameter1: array<u32>; |
| @group(4) @binding(3183) |
| var<storage, read_write> parameter2: array<u32>; |
| @group(4) @binding(2585) |
| var<storage, read_write> parameter3: array<u32>; |
| @group(6) @binding(3183) |
| var<storage, read_write> global1: array<u32>; |
| @group(8) @binding(3183) |
| var<storage, read_write> global2: array<u32>; |
| |
| @compute @workgroup_size(4, 1, 2) |
| fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {} |
| |
| |
| |
| @fragment |
| fn fragment0(@builtin(position) a0: vec4<f32>) { |
| |
| } |
| |
| struct S7 { |
| @location(23) f0: vec2<i32>, |
| @location(22) f1: vec3<f16>, |
| @location(24) f2: vec2<u32> |
| } |
| |
| @vertex |
| fn vertex0(@location(14) a0: vec2<f32>, @builtin(vertex_index) a1: u32, @location(25) a2: u32, @location(20) a3: vec2<u32>, @builtin(instance_index) a4: u32, @location(8) a5: vec3<u32>, @location(15) a6: f32, @location(13) a7: i32, @location(21) a8: vec4<u32>, @location(19) a9: i32, @location(16) a10: f32, @location(5) a11: vec4<f16>, @location(1) a12: u32, @location(2) a13: vec4<u32>, a14: S7) -> @builtin(position) vec4<f32> { |
| return vec4<f32>(0.0, 0.0, 0.0, 1.0); |
| } |
| |
| `, |
| }); |
| try { |
| computePassEncoder23.insertDebugMarker('\u5359'); |
| } catch {} |
| try { |
| gpuCanvasContext6.configure({ |
| device: device2, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['bgra8unorm-srgb', 'r8sint', 'rgb9e5ufloat'], |
| colorSpace: 'display-p3', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let texture56 = device3.createTexture({ |
| label: '\u0374\u0a2e\u01d8', |
| size: [222, 2, 72], |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rg8uint', 'rg8uint', 'rg8uint'], |
| }); |
| let computePassEncoder24 = commandEncoder35.beginComputePass(); |
| let sampler38 = device3.createSampler({ |
| label: '\u0a91\u3831\u058e\ue5b1', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 33.015, |
| lodMaxClamp: 48.667, |
| maxAnisotropy: 16, |
| }); |
| try { |
| device3.queue.writeTexture({ |
| texture: texture56, |
| mipLevel: 0, |
| origin: { x: 11, y: 0, z: 25 }, |
| aspect: 'all', |
| }, arrayBuffer1, /* required buffer size: 4015433 */ |
| {offset: 799, bytesPerRow: 413, rowsPerImage: 243}, {width: 137, height: 1, depthOrArrayLayers: 41}); |
| } catch {} |
| let gpuCanvasContext14 = offscreenCanvas11.getContext('webgpu'); |
| let textureView43 = texture8.createView({label: '\u07ec\u4597', dimension: '2d-array', format: 'rg16sint'}); |
| try { |
| renderBundleEncoder32.setBindGroup(3, bindGroup6); |
| } catch {} |
| try { |
| renderBundleEncoder32.setBindGroup(5, bindGroup7, new Uint32Array(5437), 3443, 0); |
| } catch {} |
| try { |
| renderBundleEncoder38.setVertexBuffer(7, buffer1, 9688); |
| } catch {} |
| try { |
| commandEncoder9.copyBufferToBuffer(buffer4, 34132, buffer3, 34464, 1128); |
| dissociateBuffer(device0, buffer4); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 9156, new Float32Array(60734), 59008); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 73, height: 1, depthOrArrayLayers: 29} |
| */ |
| { |
| source: img0, |
| origin: { x: 48, y: 43 }, |
| flipY: true, |
| }, { |
| texture: texture45, |
| mipLevel: 3, |
| origin: { x: 18, y: 0, z: 8 }, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 42, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| let pipeline44 = await device0.createComputePipelineAsync({ |
| label: '\ua8bf\u2ff3\u{1fda8}\u3a17\u06f9\u030b', |
| layout: pipelineLayout0, |
| compute: { |
| module: shaderModule0, |
| entryPoint: 'compute0', |
| constants: {}, |
| }, |
| }); |
| try { |
| adapter5.label = '\u13cb\u9a8e\u0a37\u78d7\ub89e'; |
| } catch {} |
| let querySet32 = device0.createQuerySet({ |
| label: '\ub091\u380b\u{1fd54}\u0971\u02ca\u{1f617}', |
| type: 'occlusion', |
| count: 1164, |
| }); |
| let computePassEncoder25 = commandEncoder23.beginComputePass({}); |
| let renderBundle41 = renderBundleEncoder2.finish({}); |
| try { |
| computePassEncoder17.end(); |
| } catch {} |
| try { |
| renderBundleEncoder22.setBindGroup(2, bindGroup6); |
| } catch {} |
| try { |
| renderBundleEncoder39.setVertexBuffer(4, buffer1, 4244, 7701); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture5, |
| mipLevel: 0, |
| origin: { x: 176, y: 8, z: 56 }, |
| aspect: 'all', |
| }, arrayBuffer0, /* required buffer size: 9005044 */ |
| {offset: 590, bytesPerRow: 3209, rowsPerImage: 122}, {width: 393, height: 0, depthOrArrayLayers: 24}); |
| } catch {} |
| let pipeline45 = await device0.createRenderPipelineAsync({ |
| label: '\u4010\u2b51\u82bb\ufe1f\u05fc\u4c1c\uc9be\u0f96\u18de\u2224', |
| layout: pipelineLayout5, |
| multisample: { |
| }, |
| fragment: { |
| module: shaderModule1, |
| entryPoint: 'fragment0', |
| targets: [{format: 'r16sint', writeMask: 0}, {format: 'r8uint', writeMask: GPUColorWrite.ALL}, {format: 'rg16uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.RED}, {format: 'r8uint', writeMask: GPUColorWrite.BLUE}, {format: 'rg32sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.RED}, {format: 'r8unorm', writeMask: GPUColorWrite.ALL}] |
| }, |
| depthStencil: { |
| format: 'depth24plus-stencil8', |
| depthWriteEnabled: true, |
| depthCompare: 'less-equal', |
| stencilFront: { |
| compare: 'less', |
| depthFailOp: 'decrement-wrap', |
| passOp: 'decrement-clamp', |
| }, |
| stencilBack: { |
| compare: 'less', |
| failOp: 'zero', |
| passOp: 'zero', |
| }, |
| stencilReadMask: 3200, |
| stencilWriteMask: 3519, |
| depthBias: 85, |
| depthBiasSlopeScale: 10, |
| depthBiasClamp: 15, |
| }, |
| vertex: { |
| module: shaderModule1, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 16808, |
| attributes: [{ |
| format: 'uint32x4', |
| offset: 4680, |
| shaderLocation: 3, |
| }, { |
| format: 'sint8x2', |
| offset: 3582, |
| shaderLocation: 4, |
| }, { |
| format: 'sint32x2', |
| offset: 15072, |
| shaderLocation: 6, |
| }, { |
| format: 'sint16x4', |
| offset: 1828, |
| shaderLocation: 9, |
| }, { |
| format: 'float16x2', |
| offset: 2908, |
| shaderLocation: 7, |
| }, { |
| format: 'unorm8x4', |
| offset: 15136, |
| shaderLocation: 1, |
| }, { |
| format: 'sint32x4', |
| offset: 16568, |
| shaderLocation: 0, |
| }, { |
| format: 'float32x3', |
| offset: 11040, |
| shaderLocation: 11, |
| }], |
| }, |
| { |
| arrayStride: 10236, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'float32x2', |
| offset: 8820, |
| shaderLocation: 2, |
| }, { |
| format: 'sint16x2', |
| offset: 4172, |
| shaderLocation: 14, |
| }, { |
| format: 'uint32x4', |
| offset: 8180, |
| shaderLocation: 8, |
| }], |
| } |
| ] |
| }, |
| primitive: { |
| topology: 'line-strip', |
| stripIndexFormat: 'uint16', |
| frontFace: 'cw', |
| cullMode: 'front', |
| }, |
| }); |
| let buffer13 = device2.createBuffer({label: '\u81c6\ud658', size: 2374, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let renderBundle42 = renderBundleEncoder35.finish(); |
| let sampler39 = device2.createSampler({ |
| label: '\u86f1\uc7e9\u0b24\u0190\u4b7c\u{1f69c}\u{1fac7}\u0ba5\u0122\u764d\uc499', |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| minFilter: 'nearest', |
| lodMinClamp: 7.914, |
| lodMaxClamp: 68.090, |
| }); |
| let pipeline46 = device2.createRenderPipeline({ |
| label: '\u0f36\ueff8\ubfff\uf3de\ud038\u{1f991}\u70e5\u0578\u{1fcb3}\u{1fde3}\u{1fc1e}', |
| layout: pipelineLayout11, |
| multisample: { |
| mask: 0xa821af0e, |
| }, |
| fragment: {module: shaderModule7, entryPoint: 'fragment0', constants: {}, targets: []}, |
| depthStencil: { |
| format: 'depth24plus-stencil8', |
| depthWriteEnabled: true, |
| depthCompare: 'never', |
| stencilFront: { |
| compare: 'not-equal', |
| failOp: 'replace', |
| depthFailOp: 'decrement-clamp', |
| passOp: 'keep', |
| }, |
| stencilBack: { |
| compare: 'less', |
| failOp: 'decrement-wrap', |
| depthFailOp: 'replace', |
| passOp: 'decrement-wrap', |
| }, |
| stencilReadMask: 2552, |
| stencilWriteMask: 2311, |
| depthBias: 38, |
| depthBiasSlopeScale: 98, |
| depthBiasClamp: 100, |
| }, |
| vertex: { |
| module: shaderModule7, |
| entryPoint: 'vertex0', |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 49960, |
| stepMode: 'instance', |
| attributes: [{ |
| format: 'uint16x2', |
| offset: 24372, |
| shaderLocation: 25, |
| }, { |
| format: 'uint8x4', |
| offset: 36620, |
| shaderLocation: 1, |
| }, { |
| format: 'unorm8x4', |
| offset: 19176, |
| shaderLocation: 22, |
| }, { |
| format: 'unorm8x2', |
| offset: 7550, |
| shaderLocation: 5, |
| }, { |
| format: 'unorm10-10-10-2', |
| offset: 27064, |
| shaderLocation: 14, |
| }, { |
| format: 'uint32x4', |
| offset: 6100, |
| shaderLocation: 20, |
| }, { |
| format: 'snorm16x2', |
| offset: 33512, |
| shaderLocation: 15, |
| }, { |
| format: 'uint16x2', |
| offset: 29764, |
| shaderLocation: 24, |
| }, { |
| format: 'sint32x4', |
| offset: 15908, |
| shaderLocation: 23, |
| }, { |
| format: 'sint32x2', |
| offset: 46784, |
| shaderLocation: 19, |
| }], |
| }, |
| { |
| arrayStride: 22688, |
| stepMode: 'vertex', |
| attributes: [], |
| }, |
| { |
| arrayStride: 0, |
| stepMode: 'instance', |
| attributes: [{ |
| format: 'unorm16x2', |
| offset: 5696, |
| shaderLocation: 16, |
| }, { |
| format: 'uint32', |
| offset: 51312, |
| shaderLocation: 21, |
| }, { |
| format: 'uint16x2', |
| offset: 21076, |
| shaderLocation: 2, |
| }, { |
| format: 'uint8x2', |
| offset: 4236, |
| shaderLocation: 8, |
| }, { |
| format: 'sint32x3', |
| offset: 18596, |
| shaderLocation: 13, |
| }], |
| } |
| ] |
| }, |
| primitive: { |
| topology: 'line-strip', |
| stripIndexFormat: 'uint32', |
| cullMode: 'back', |
| }, |
| }); |
| gc(); |
| try { |
| computePassEncoder20.setPipeline(pipeline21); |
| } catch {} |
| try { |
| renderBundleEncoder24.setIndexBuffer(buffer10, 'uint32', 6720, 48150); |
| } catch {} |
| try { |
| computePassEncoder1.pushDebugGroup('\ubf78'); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture46, |
| mipLevel: 9, |
| origin: { x: 2, y: 1, z: 1 }, |
| aspect: 'all', |
| }, new Float64Array(arrayBuffer0), /* required buffer size: 122 */ |
| {offset: 122}, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let bindGroup16 = device3.createBindGroup({ |
| label: '\uc017\u0dbc\ucde1\u0d27\u5632\u6a57\u07ea\u031f\u{1fa21}', |
| layout: bindGroupLayout19, |
| entries: [], |
| }); |
| let texture57 = device3.createTexture({ |
| label: '\ue69b\u{1feae}\uedf6\u0c09\ufc17', |
| size: [860, 1, 110], |
| mipLevelCount: 9, |
| format: 'stencil8', |
| usage: GPUTextureUsage.COPY_DST, |
| viewFormats: ['stencil8', 'stencil8', 'stencil8'], |
| }); |
| let sampler40 = device3.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'nearest', |
| lodMaxClamp: 97.252, |
| maxAnisotropy: 1, |
| }); |
| try { |
| device3.queue.writeTexture({ |
| texture: texture55, |
| mipLevel: 0, |
| origin: { x: 89, y: 1, z: 1 }, |
| aspect: 'all', |
| }, new Int32Array(arrayBuffer4), /* required buffer size: 199 */ |
| {offset: 199}, {width: 1823, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| video8.width = 182; |
| let buffer14 = device2.createBuffer({label: '\u7880\u04bb\u{1f8d8}\u30b4\u5b82', size: 34523, usage: GPUBufferUsage.MAP_READ}); |
| let commandEncoder37 = device2.createCommandEncoder(); |
| let sampler41 = device2.createSampler({ |
| label: '\u{1f69c}\u{1fed0}\u03a5\u03c0\u{1ffc0}\uab57\u0fd5\ubf1c', |
| addressModeU: 'repeat', |
| magFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 49.865, |
| lodMaxClamp: 84.916, |
| compare: 'always', |
| }); |
| let pipeline47 = device2.createRenderPipeline({ |
| label: '\u3dc8\ubca4\u09d2\u{1fc8d}\u{1faa8}\u2248\ub07d\u{1fd49}\u{1f951}\u{1fd95}', |
| layout: pipelineLayout11, |
| fragment: {module: shaderModule7, entryPoint: 'fragment0', constants: {}, targets: []}, |
| depthStencil: { |
| format: 'stencil8', |
| depthWriteEnabled: false, |
| stencilFront: { |
| compare: 'not-equal', |
| failOp: 'zero', |
| depthFailOp: 'increment-wrap', |
| }, |
| stencilBack: { |
| compare: 'greater-equal', |
| depthFailOp: 'increment-clamp', |
| passOp: 'invert', |
| }, |
| stencilReadMask: 841, |
| depthBias: 45, |
| depthBiasSlopeScale: 23, |
| depthBiasClamp: 60, |
| }, |
| vertex: { |
| module: shaderModule7, |
| entryPoint: 'vertex0', |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 49780, |
| stepMode: 'instance', |
| attributes: [{ |
| format: 'uint8x2', |
| offset: 33704, |
| shaderLocation: 8, |
| }, { |
| format: 'float16x4', |
| offset: 8860, |
| shaderLocation: 15, |
| }, { |
| format: 'uint32x3', |
| offset: 29524, |
| shaderLocation: 25, |
| }, { |
| format: 'sint32x4', |
| offset: 42624, |
| shaderLocation: 13, |
| }, { |
| format: 'uint16x4', |
| offset: 22404, |
| shaderLocation: 20, |
| }, { |
| format: 'uint32x3', |
| offset: 8188, |
| shaderLocation: 24, |
| }, { |
| format: 'snorm8x2', |
| offset: 45682, |
| shaderLocation: 5, |
| }, { |
| format: 'snorm8x2', |
| offset: 43622, |
| shaderLocation: 16, |
| }, { |
| format: 'sint8x2', |
| offset: 2110, |
| shaderLocation: 23, |
| }, { |
| format: 'uint32x4', |
| offset: 29712, |
| shaderLocation: 2, |
| }], |
| }, |
| { |
| arrayStride: 53088, |
| stepMode: 'instance', |
| attributes: [{ |
| format: 'uint32x3', |
| offset: 40216, |
| shaderLocation: 21, |
| }], |
| }, |
| { |
| arrayStride: 23368, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'unorm8x2', |
| offset: 6520, |
| shaderLocation: 14, |
| }, { |
| format: 'sint32x3', |
| offset: 22956, |
| shaderLocation: 19, |
| }, { |
| format: 'uint32x4', |
| offset: 11784, |
| shaderLocation: 1, |
| }, { |
| format: 'float16x2', |
| offset: 376, |
| shaderLocation: 22, |
| }], |
| } |
| ] |
| }, |
| primitive: { |
| topology: 'line-list', |
| frontFace: 'cw', |
| cullMode: 'front', |
| }, |
| }); |
| let device4 = await adapter6.requestDevice({ |
| label: '\u0b08\u04f3\u0a86\ud08b\uc5f3\u43e9\udf44\u{1fb62}\u56fa\u{1ff50}', |
| }); |
| let texture58 = device0.createTexture({ |
| size: {width: 4544, height: 36, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'astc-8x6-unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['astc-8x6-unorm-srgb', 'astc-8x6-unorm-srgb'], |
| }); |
| let textureView44 = texture26.createView({label: '\ub476\u44e2\u{1fc96}\u16e7', dimension: '1d', baseMipLevel: 0, arrayLayerCount: 1}); |
| try { |
| renderBundleEncoder36.setBindGroup(1, bindGroup10); |
| } catch {} |
| try { |
| commandEncoder9.copyBufferToBuffer(buffer6, 5032, buffer3, 13736, 24816); |
| dissociateBuffer(device0, buffer6); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| computePassEncoder1.popDebugGroup(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer12, 34364, new Float32Array(33041), 12029, 288); |
| } catch {} |
| let promise28 = device0.queue.onSubmittedWorkDone(); |
| let texture59 = gpuCanvasContext3.getCurrentTexture(); |
| try { |
| renderBundleEncoder32.setBindGroup(3, bindGroup7); |
| } catch {} |
| try { |
| commandEncoder30.copyBufferToBuffer(buffer6, 30524, buffer3, 25092, 7248); |
| dissociateBuffer(device0, buffer6); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| commandEncoder25.copyTextureToTexture({ |
| texture: texture18, |
| mipLevel: 0, |
| origin: { x: 112, y: 0, z: 0 }, |
| aspect: 'all', |
| }, { |
| texture: texture30, |
| mipLevel: 0, |
| origin: { x: 4, y: 0, z: 0 }, |
| aspect: 'all', |
| }, {width: 3, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer12, 3432, new BigUint64Array(3173), 963, 1260); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 284, height: 2, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame10, |
| origin: { x: 220, y: 82 }, |
| flipY: false, |
| }, { |
| texture: texture31, |
| mipLevel: 2, |
| origin: { x: 47, y: 0, z: 0 }, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 52, height: 2, depthOrArrayLayers: 1}); |
| } catch {} |
| let pipeline48 = await device0.createComputePipelineAsync({ |
| label: '\u09aa\ud15f\ube72\u{1fa8b}', |
| layout: pipelineLayout2, |
| compute: { |
| module: shaderModule4, |
| entryPoint: 'compute0', |
| constants: {}, |
| }, |
| }); |
| offscreenCanvas3.width = 563; |
| try { |
| device0.label = '\ucbf9\u9356\u89ad\u0674\u{1fde9}\uf8f0\u67ae\u35f3\u0b74\u07af\u1c10'; |
| } catch {} |
| let querySet33 = device0.createQuerySet({ |
| label: '\u09cf\u4227\u0734\uf891\u088b', |
| type: 'occlusion', |
| count: 2742, |
| }); |
| let texture60 = device0.createTexture({ |
| label: '\u07a4\u693e\u4661\u{1fd5d}\u{1f8cf}\u12ff\ua588\u04ce', |
| size: [7040, 1, 1], |
| mipLevelCount: 7, |
| format: 'rg16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| try { |
| renderBundleEncoder40.setBindGroup(2, bindGroup2); |
| } catch {} |
| try { |
| gpuCanvasContext9.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['astc-6x6-unorm-srgb', 'depth24plus', 'rgba8unorm', 'rgba8unorm-srgb'], |
| colorSpace: 'srgb', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| await adapter0.requestAdapterInfo(); |
| } catch {} |
| try { |
| device2.queue.writeTexture({ |
| texture: texture48, |
| mipLevel: 4, |
| origin: { x: 40, y: 5, z: 0 }, |
| aspect: 'all', |
| }, new BigUint64Array(arrayBuffer3), /* required buffer size: 177844 */ |
| {offset: 506, bytesPerRow: 202, rowsPerImage: 219}, {width: 46, height: 2, depthOrArrayLayers: 5}); |
| } catch {} |
| let canvas12 = document.createElement('canvas'); |
| let texture61 = device0.createTexture({ |
| label: '\ube74\u308c\ufaed\u8148\uc2a2\u{1f8a7}\u3b6b\u7f8c', |
| size: {width: 2352, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 4, |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rg8sint'], |
| }); |
| try { |
| computePassEncoder19.setBindGroup(0, bindGroup3); |
| } catch {} |
| try { |
| computePassEncoder20.setBindGroup(2, bindGroup8, new Uint32Array(4409), 2230, 0); |
| } catch {} |
| try { |
| renderBundleEncoder38.setPipeline(pipeline42); |
| } catch {} |
| let gpuCanvasContext15 = canvas12.getContext('webgpu'); |
| try { |
| await promise28; |
| } catch {} |
| video8.width = 284; |
| let bindGroupLayout22 = device3.createBindGroupLayout({ |
| entries: [{ |
| binding: 624, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'rgba8uint', access: 'read-only', viewDimension: '3d' }, |
| }, { |
| binding: 644, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: 'cube-array', sampleType: 'uint', multisampled: false }, |
| }], |
| }); |
| let buffer15 = device3.createBuffer({ |
| label: '\u9fc5\ud977\u55a1\u0107\u07a9\u841c\uc313\ue11d\uddfe', |
| size: 22773, |
| usage: GPUBufferUsage.MAP_WRITE |
| }); |
| let externalTexture1 = device3.importExternalTexture({ |
| source: videoFrame1, |
| colorSpace: 'display-p3', |
| }); |
| let commandEncoder38 = device2.createCommandEncoder({label: '\u0644\u{1f840}\u9407\u6495\u0325\u50c9'}); |
| let texture62 = device2.createTexture({ |
| label: '\u{1fbdd}\u09f3\u{1f87d}\u0065\u{1fe21}\u{1fb99}\u03ec', |
| size: {width: 1520, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 4, |
| format: 'rgba8unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| viewFormats: ['rgba8unorm', 'rgba8unorm-srgb', 'rgba8unorm-srgb'], |
| }); |
| let renderBundle43 = renderBundleEncoder35.finish(); |
| let sampler42 = device2.createSampler({ |
| label: '\u0158\ubf04\u6cf1\u26d9', |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'clamp-to-edge', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 91.156, |
| lodMaxClamp: 98.261, |
| compare: 'less-equal', |
| }); |
| let promise29 = device2.queue.onSubmittedWorkDone(); |
| let texture63 = device4.createTexture({ |
| label: '\u{1ff4a}\u561e\u0659', |
| size: [1200, 1, 1], |
| mipLevelCount: 11, |
| sampleCount: 1, |
| format: 'depth24plus-stencil8', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let sampler43 = device4.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 61.761, |
| lodMaxClamp: 72.549, |
| maxAnisotropy: 16, |
| }); |
| try { |
| device4.queue.writeTexture({ |
| texture: texture63, |
| mipLevel: 7, |
| origin: { x: 0, y: 0, z: 0 }, |
| aspect: 'stencil-only', |
| }, new ArrayBuffer(48), /* required buffer size: 679 */ |
| {offset: 670}, {width: 9, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| let device5 = await adapter5.requestDevice({ |
| label: '\u4a66\u4f6c\u0de8\u087e\ud7cb\u{1f628}\u0a36\u0ae4', |
| requiredFeatures: [ |
| 'depth-clip-control', |
| 'depth32float-stencil8', |
| 'texture-compression-etc2', |
| 'texture-compression-astc', |
| 'indirect-first-instance', |
| 'shader-f16', |
| 'rg11b10ufloat-renderable', |
| 'bgra8unorm-storage' |
| ], |
| requiredLimits: { |
| maxBindGroups: 6, |
| maxColorAttachmentBytesPerSample: 46, |
| maxVertexAttributes: 24, |
| maxVertexBufferArrayStride: 11604, |
| maxStorageTexturesPerShaderStage: 30, |
| maxStorageBuffersPerShaderStage: 24, |
| maxDynamicStorageBuffersPerPipelineLayout: 9781, |
| maxBindingsPerBindGroup: 8408, |
| maxTextureDimension1D: 11662, |
| maxTextureDimension2D: 15462, |
| maxVertexBuffers: 12, |
| minStorageBufferOffsetAlignment: 128, |
| maxUniformBufferBindingSize: 196159058, |
| maxUniformBuffersPerShaderStage: 20, |
| maxInterStageShaderVariables: 113, |
| maxInterStageShaderComponents: 109, |
| maxSamplersPerShaderStage: 20, |
| }, |
| }); |
| let videoFrame11 = new VideoFrame(img8, {timestamp: 0}); |
| try { |
| device4.queue.label = '\u039c\u2ecb\u{1f8c0}\u5a05\u{1f8f3}\u{1fc7b}\u7d6f\ua365\u0c85'; |
| } catch {} |
| let renderBundleEncoder41 = device4.createRenderBundleEncoder({ |
| label: '\u4b73\u60d7\u5f47\u0998\u5095\u05d1\u1237\u38bc\u6660', |
| colorFormats: ['rg32float', 'rgba32sint'], |
| sampleCount: 1, |
| stencilReadOnly: true |
| }); |
| let sampler44 = device4.createSampler({ |
| label: '\u{1f6aa}\u96e4\u0184\u0a3b\u1fe5\u{1f663}', |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 47.469, |
| lodMaxClamp: 94.064, |
| compare: 'not-equal', |
| }); |
| let img11 = await imageWithData(101, 283, '#5d570e15', '#b51411c0'); |
| try { |
| renderBundleEncoder32.setBindGroup(6, bindGroup13); |
| } catch {} |
| try { |
| renderBundleEncoder38.drawIndirect(buffer3, 36028); |
| } catch {} |
| try { |
| commandEncoder30.copyBufferToTexture({ |
| /* bytesInLastRow: 7956 widthInBlocks: 1989 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 17716 */ |
| offset: 17716, |
| buffer: buffer5, |
| }, { |
| texture: texture26, |
| mipLevel: 0, |
| origin: { x: 414, y: 1, z: 0 }, |
| aspect: 'all', |
| }, {width: 1989, height: 0, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer5); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| adapter6.label = '\u06d1\uf94e'; |
| } catch {} |
| let commandEncoder39 = device3.createCommandEncoder({label: '\u9485\uc062'}); |
| try { |
| commandEncoder39.copyTextureToTexture({ |
| texture: texture51, |
| mipLevel: 0, |
| origin: { x: 103, y: 0, z: 0 }, |
| aspect: 'all', |
| }, { |
| texture: texture51, |
| mipLevel: 1, |
| origin: { x: 572, y: 0, z: 0 }, |
| aspect: 'all', |
| }, {width: 1662, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| let canvas13 = document.createElement('canvas'); |
| let querySet34 = device4.createQuerySet({ |
| label: '\u427e\u{1f852}\u0f4a\u7185\u03b0\ud6fe\u1578', |
| type: 'occlusion', |
| count: 2091, |
| }); |
| let texture64 = gpuCanvasContext6.getCurrentTexture(); |
| try { |
| gpuCanvasContext7.configure({ |
| device: device4, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: ['rgba16float', 'rgba16float', 'rgba16float'], |
| colorSpace: 'srgb', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| pseudoSubmit(device0, commandEncoder5); |
| let computePassEncoder26 = commandEncoder15.beginComputePass({label: '\u2c95\u0954\u9273\u3fea\u7965\u3328\u5fd8\u503d\u2b5c\u7d77\ubb1f'}); |
| let sampler45 = device0.createSampler({ |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 22.302, |
| maxAnisotropy: 3, |
| }); |
| try { |
| renderBundleEncoder39.setBindGroup(4, bindGroup11); |
| } catch {} |
| try { |
| renderBundleEncoder38.draw(16, 8, 0, 56); |
| } catch {} |
| try { |
| renderBundleEncoder38.drawIndexedIndirect(buffer3, 3604); |
| } catch {} |
| try { |
| renderBundleEncoder38.drawIndirect(buffer3, 41896); |
| } catch {} |
| try { |
| renderBundleEncoder36.setVertexBuffer(7, buffer1, 4440, 5988); |
| } catch {} |
| try { |
| texture60.destroy(); |
| } catch {} |
| try { |
| commandEncoder30.clearBuffer(buffer3); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| let pipeline49 = device0.createRenderPipeline({ |
| label: '\u65d4\ue59a\u7384\ua276\u{1fa48}', |
| layout: pipelineLayout5, |
| fragment: { |
| module: shaderModule6, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{format: 'r16float', writeMask: 0}, {format: 'rgba32float', writeMask: 0}, {format: 'rgba32uint'}, { |
| format: 'rgba8unorm', |
| blend: { |
| color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'}, |
| alpha: {operation: 'reverse-subtract', srcFactor: 'dst-alpha', dstFactor: 'dst'}, |
| }, |
| writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED |
| }, undefined, { |
| format: 'rgba16float', |
| blend: { |
| color: {operation: 'add', srcFactor: 'one-minus-dst', dstFactor: 'dst-alpha'}, |
| alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'}, |
| } |
| }] |
| }, |
| vertex: { |
| module: shaderModule6, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 12996, |
| stepMode: 'instance', |
| attributes: [{ |
| format: 'float32x3', |
| offset: 820, |
| shaderLocation: 0, |
| }, { |
| format: 'unorm10-10-10-2', |
| offset: 10172, |
| shaderLocation: 10, |
| }, { |
| format: 'float16x2', |
| offset: 12884, |
| shaderLocation: 13, |
| }], |
| }, |
| { |
| arrayStride: 7404, |
| attributes: [{ |
| format: 'snorm16x4', |
| offset: 6388, |
| shaderLocation: 3, |
| }, { |
| format: 'uint32x3', |
| offset: 916, |
| shaderLocation: 14, |
| }, { |
| format: 'unorm8x4', |
| offset: 3152, |
| shaderLocation: 6, |
| }], |
| }, |
| { |
| arrayStride: 180, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'uint32x4', |
| offset: 12, |
| shaderLocation: 12, |
| }, { |
| format: 'uint32x3', |
| offset: 168, |
| shaderLocation: 2, |
| }], |
| } |
| ] |
| }, |
| primitive: { |
| topology: 'line-strip', |
| stripIndexFormat: 'uint32', |
| frontFace: 'ccw', |
| cullMode: 'front', |
| }, |
| }); |
| gc(); |
| try { |
| canvas13.getContext('webgl'); |
| } catch {} |
| let shaderModule8 = device2.createShaderModule({ |
| code: `@group(0) @binding(2585) |
| var<storage, read_write> global3: array<u32>; |
| @group(3) @binding(2585) |
| var<storage, read_write> i5: array<u32>; |
| @group(5) @binding(3183) |
| var<storage, read_write> field4: array<u32>; |
| @group(7) @binding(2585) |
| var<storage, read_write> i6: array<u32>; |
| @group(1) @binding(3183) |
| var<storage, read_write> global4: array<u32>; |
| @group(6) @binding(3183) |
| var<storage, read_write> function5: array<u32>; |
| @group(8) @binding(2585) |
| var<storage, read_write> i7: array<u32>; |
| @group(2) @binding(2585) |
| var<storage, read_write> field5: array<u32>; |
| @group(5) @binding(2585) |
| var<storage, read_write> i8: array<u32>; |
| @group(7) @binding(3183) |
| var<storage, read_write> function6: array<u32>; |
| @group(2) @binding(3183) |
| var<storage, read_write> parameter4: array<u32>; |
| @group(4) @binding(2585) |
| var<storage, read_write> global5: array<u32>; |
| @group(3) @binding(3183) |
| var<storage, read_write> parameter5: array<u32>; |
| @group(1) @binding(2585) |
| var<storage, read_write> function7: array<u32>; |
| @group(0) @binding(3183) |
| var<storage, read_write> type3: array<u32>; |
| @group(4) @binding(3183) |
| var<storage, read_write> field6: array<u32>; |
| @group(8) @binding(3183) |
| var<storage, read_write> global6: 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>) {} |
| |
| |
| |
| @fragment |
| fn fragment0(@builtin(front_facing) a0: bool, @builtin(position) a1: vec4<f32>, @builtin(sample_mask) a2: u32) -> @builtin(sample_mask) u32 { |
| return u32(); |
| } |
| |
| struct S8 { |
| @location(20) f0: vec2<f16>, |
| @location(17) f1: vec4<i32>, |
| @location(24) f2: vec4<f16>, |
| @location(11) f3: vec3<f32>, |
| @location(26) f4: vec4<f32>, |
| @location(22) f5: vec4<f32>, |
| @location(25) f6: u32, |
| @location(19) f7: vec2<f32>, |
| @location(18) f8: vec3<i32>, |
| @location(21) f9: vec3<f32>, |
| @location(7) f10: vec4<u32>, |
| @location(8) f11: vec2<u32>, |
| @location(3) f12: vec2<f16>, |
| @location(12) f13: vec3<f16>, |
| @location(13) f14: vec2<u32> |
| } |
| |
| @vertex |
| fn vertex0(a0: S8, @builtin(vertex_index) a1: u32) -> @builtin(position) vec4<f32> { |
| return vec4<f32>(0.0, 0.0, 0.0, 1.0); |
| } |
| |
| `, |
| hints: {}, |
| }); |
| let commandEncoder40 = device2.createCommandEncoder({label: '\u{1fd6d}\u09b1\u0da5\u08d8\u0d6f\u{1f937}\uce2f'}); |
| try { |
| renderBundleEncoder37.setVertexBuffer(37, undefined, 3389912282, 87108669); |
| } catch {} |
| let pipeline50 = await device2.createComputePipelineAsync({ |
| label: '\uaafd\u08e8\u{1f652}\u3850\uadab', |
| layout: pipelineLayout11, |
| compute: { |
| module: shaderModule8, |
| entryPoint: 'compute0', |
| }, |
| }); |
| try { |
| if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55) }; |
| } catch {} |
| let imageData18 = new ImageData(184, 76); |
| let bindGroup17 = device0.createBindGroup({ |
| layout: bindGroupLayout7, |
| entries: [{ |
| binding: 1160, |
| resource: externalTexture0 |
| }], |
| }); |
| let buffer16 = device0.createBuffer({size: 4616, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let computePassEncoder27 = commandEncoder16.beginComputePass(); |
| try { |
| computePassEncoder9.setBindGroup(1, bindGroup10, new Uint32Array(7185), 379, 0); |
| } catch {} |
| try { |
| renderBundleEncoder32.setBindGroup(0, bindGroup6, new Uint32Array(845), 615, 0); |
| } catch {} |
| try { |
| renderBundleEncoder38.draw(0, 32, 0, 40); |
| } catch {} |
| try { |
| renderBundleEncoder38.drawIndexedIndirect(buffer3, 29700); |
| } catch {} |
| try { |
| renderBundleEncoder38.drawIndirect(buffer3, 30352); |
| } catch {} |
| try { |
| renderBundleEncoder40.setVertexBuffer(3, buffer1); |
| } catch {} |
| try { |
| commandEncoder9.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 31938 */ |
| offset: 31938, |
| bytesPerRow: 0, |
| rowsPerImage: 260, |
| buffer: buffer6, |
| }, { |
| texture: texture54, |
| mipLevel: 3, |
| origin: { x: 0, y: 4, z: 7 }, |
| aspect: 'all', |
| }, {width: 0, height: 10, depthOrArrayLayers: 10}); |
| dissociateBuffer(device0, buffer6); |
| } catch {} |
| try { |
| commandEncoder30.clearBuffer(buffer12, 32760, 2216); |
| dissociateBuffer(device0, buffer12); |
| } catch {} |
| try { |
| commandEncoder30.resolveQuerySet(querySet5, 264, 20, buffer12, 4096); |
| } catch {} |
| let pipeline51 = device0.createComputePipeline({ |
| label: '\ue81e\u7b40\u{1fadc}\u4b33\u056f\u53c6\u{1fa51}\u0233\u{1fd39}\u0ea5\u0594', |
| layout: pipelineLayout10, |
| compute: { |
| module: shaderModule1, |
| entryPoint: 'compute0', |
| constants: {}, |
| }, |
| }); |
| let bindGroupLayout23 = device2.createBindGroupLayout({ |
| label: '\u62a4\u515f\u{1f684}\u751a\u6b96', |
| entries: [{ |
| binding: 1590, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: 'cube', sampleType: 'sint', multisampled: false }, |
| }, { |
| binding: 1487, |
| visibility: GPUShaderStage.COMPUTE, |
| sampler: { type: 'comparison' }, |
| }], |
| }); |
| let commandBuffer9 = commandEncoder38.finish({ |
| label: '\u0f04\u370e\u5528', |
| }); |
| let computePassEncoder28 = commandEncoder37.beginComputePass({label: '\u8333\u2856\u5f73\u9464\u0080\u0fbf\u0444'}); |
| try { |
| computePassEncoder28.setPipeline(pipeline50); |
| } catch {} |
| let promise30 = device2.queue.onSubmittedWorkDone(); |
| let canvas14 = document.createElement('canvas'); |
| let querySet35 = device3.createQuerySet({ |
| label: '\u0297\u{1fea0}', |
| type: 'occlusion', |
| count: 3984, |
| }); |
| let textureView45 = texture57.createView({ |
| label: '\u004b\u0421\u0087\uaec5\u02f7', |
| aspect: 'stencil-only', |
| baseMipLevel: 2, |
| mipLevelCount: 3, |
| baseArrayLayer: 39, |
| arrayLayerCount: 40 |
| }); |
| let externalTexture2 = device3.importExternalTexture({ |
| source: video1, |
| }); |
| try { |
| device3.queue.writeTexture({ |
| texture: texture51, |
| mipLevel: 1, |
| origin: { x: 78, y: 0, z: 0 }, |
| aspect: 'all', |
| }, new Uint32Array(arrayBuffer2), /* required buffer size: 221 */ |
| {offset: 221, bytesPerRow: 6215}, {width: 1517, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder41 = device4.createCommandEncoder({label: '\u3470\uf79c\u8c3c\u8bfc\u{1f948}\u215d\u3068\u38aa\u0b4f\u089e'}); |
| let gpuCanvasContext16 = canvas14.getContext('webgpu'); |
| let bindGroup18 = device0.createBindGroup({ |
| label: '\u7d80\u{1f90a}\uf94c\u1d4d', |
| layout: bindGroupLayout4, |
| entries: [], |
| }); |
| let texture65 = device0.createTexture({ |
| label: '\u442f\u{1fe33}\u0630\u5625\u3330\uec1f', |
| size: [12, 100, 89], |
| format: 'astc-12x10-unorm', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['astc-12x10-unorm', 'astc-12x10-unorm'], |
| }); |
| let computePassEncoder29 = commandEncoder9.beginComputePass({}); |
| let renderBundleEncoder42 = device0.createRenderBundleEncoder({ |
| label: '\u70e8\ue5a0\u74f0\uf96f\u1692\ue09f', |
| colorFormats: ['rgba8unorm', 'r8sint', undefined], |
| sampleCount: 4, |
| depthReadOnly: true, |
| stencilReadOnly: true |
| }); |
| try { |
| commandEncoder25.clearBuffer(buffer12, 1588, 27036); |
| dissociateBuffer(device0, buffer12); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 12464, new DataView(new ArrayBuffer(1158)), 549, 292); |
| } catch {} |
| let offscreenCanvas15 = new OffscreenCanvas(692, 556); |
| let imageBitmap11 = await createImageBitmap(video6); |
| let renderBundle44 = renderBundleEncoder41.finish(); |
| let canvas15 = document.createElement('canvas'); |
| let commandEncoder42 = device5.createCommandEncoder({}); |
| try { |
| await device5.queue.onSubmittedWorkDone(); |
| } catch {} |
| let video11 = await videoWithData(); |
| let videoFrame12 = new VideoFrame(canvas10, {timestamp: 0}); |
| let sampler46 = device2.createSampler({ |
| label: '\u6ce3\ua3e2\u{1f8f3}\u2a87\u03a4\u4696\ub87f\u2a56\udc71\uc412\uabd0', |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 41.032, |
| lodMaxClamp: 97.966, |
| compare: 'greater-equal', |
| }); |
| try { |
| computePassEncoder23.setPipeline(pipeline50); |
| } catch {} |
| try { |
| commandEncoder40.copyTextureToTexture({ |
| texture: texture48, |
| mipLevel: 0, |
| origin: { x: 1071, y: 21, z: 47 }, |
| aspect: 'all', |
| }, { |
| texture: texture48, |
| mipLevel: 1, |
| origin: { x: 137, y: 5, z: 10 }, |
| aspect: 'all', |
| }, {width: 402, height: 44, depthOrArrayLayers: 5}); |
| } catch {} |
| try { |
| computePassEncoder28.pushDebugGroup('\u{1fa36}'); |
| } catch {} |
| let commandEncoder43 = device5.createCommandEncoder({label: '\uee53\uccd5\ua874\u4b23\u0a6a\uae8e\u{1f648}\u07e8\ud528\uf5f5'}); |
| let querySet36 = device5.createQuerySet({ |
| label: '\u0c75\u96bd\u0f22\u{1ff0a}\u8e19\u1b07\u789f\uad86', |
| type: 'occlusion', |
| count: 647, |
| }); |
| let imageBitmap12 = await createImageBitmap(offscreenCanvas9); |
| let sampler47 = device3.createSampler({ |
| label: '\u{1facb}\u092c\u0a05\u2ffa\ucd80\u1b83', |
| addressModeU: 'clamp-to-edge', |
| addressModeW: 'repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 95.015, |
| lodMaxClamp: 97.187, |
| }); |
| let imageData19 = new ImageData(248, 212); |
| let commandEncoder44 = device4.createCommandEncoder(); |
| let texture66 = device4.createTexture({ |
| size: {width: 600}, |
| dimension: '1d', |
| format: 'bgra8unorm-srgb', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder30 = commandEncoder44.beginComputePass({label: '\u038e\uc9ad\u0ff9\u5a93\u1e46\u37ce\u083a'}); |
| let renderBundle45 = renderBundleEncoder41.finish({label: '\u08be\u36e7\u0714\uf58f\u0fd6\u{1fc77}\u{1fdb1}\u{1fb6e}\u5c12\u291c'}); |
| try { |
| commandEncoder41.copyTextureToTexture({ |
| texture: texture63, |
| mipLevel: 9, |
| origin: { x: 0, y: 0, z: 1 }, |
| aspect: 'all', |
| }, { |
| texture: texture63, |
| mipLevel: 6, |
| origin: { x: 8, y: 0, z: 1 }, |
| aspect: 'all', |
| }, {width: 2, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await promise30; |
| } catch {} |
| try { |
| renderBundleEncoder38.drawIndexedIndirect(buffer3, 13284); |
| } catch {} |
| try { |
| querySet7.destroy(); |
| } catch {} |
| try { |
| commandEncoder28.copyBufferToBuffer(buffer16, 2328, buffer12, 1104, 1628); |
| dissociateBuffer(device0, buffer16); |
| dissociateBuffer(device0, buffer12); |
| } catch {} |
| try { |
| commandEncoder30.clearBuffer(buffer3); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| computePassEncoder22.pushDebugGroup('\u1e0b'); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let adapter7 = await navigator.gpu.requestAdapter({ |
| }); |
| let bindGroupLayout24 = device5.createBindGroupLayout({ |
| label: '\u0858\u3384\u{1ff2f}\u0b6b\u00c1\uaf1b', |
| entries: [], |
| }); |
| let bindGroup19 = device5.createBindGroup({ |
| label: '\u070c\ued06\u6344\ud1b4\u{1fdd7}\ue4f6\u058a\u4627\u035f\u{1fc95}\uf48c', |
| layout: bindGroupLayout24, |
| entries: [], |
| }); |
| let commandEncoder45 = device5.createCommandEncoder(); |
| offscreenCanvas9.width = 323; |
| let bindGroup20 = device5.createBindGroup({ |
| label: '\u96fc\u02ab\u0d64\u0d56\u1d59\u018d\ufaa5\u0333\u1e4f', |
| layout: bindGroupLayout24, |
| entries: [], |
| }); |
| let texture67 = device5.createTexture({ |
| label: '\u5c51\u236e\u09c5\u17a6\u07dd\u5925\ub42e\u{1fa54}\uea9b\udbaf', |
| size: {width: 30, height: 32, depthOrArrayLayers: 224}, |
| mipLevelCount: 5, |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: ['r16sint'], |
| }); |
| let textureView46 = texture67.createView({ |
| label: '\u11a0\uc066\u{1f632}\u0695\ufea8\u{1f746}\u{1f956}', |
| dimension: '2d', |
| baseMipLevel: 2, |
| baseArrayLayer: 9 |
| }); |
| let computePassEncoder31 = commandEncoder42.beginComputePass({label: '\ua20a\ue824\uc960\u6c5b'}); |
| try { |
| gpuCanvasContext16.configure({ |
| device: device5, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['bgra8unorm', 'bgra8unorm', 'bgra8unorm-srgb'], |
| colorSpace: 'display-p3', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let pipelineLayout12 = device3.createPipelineLayout({ |
| label: '\u{1f9d1}\u226e\u0a69\u0c51\u{1f65a}\u032e\u0d33\ufd85', |
| bindGroupLayouts: [bindGroupLayout21, bindGroupLayout21, bindGroupLayout21] |
| }); |
| try { |
| buffer15.unmap(); |
| } catch {} |
| try { |
| await buffer15.mapAsync(GPUMapMode.WRITE, 0, 18588); |
| } catch {} |
| try { |
| device3.queue.writeTexture({ |
| texture: texture51, |
| mipLevel: 6, |
| origin: { x: 12, y: 0, z: 0 }, |
| aspect: 'all', |
| }, arrayBuffer0, /* required buffer size: 1049 */ |
| {offset: 677, rowsPerImage: 255}, {width: 93, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| let video12 = await videoWithData(); |
| try { |
| computePassEncoder28.popDebugGroup(); |
| } catch {} |
| let pipeline52 = await device2.createRenderPipelineAsync({ |
| label: '\u45b7\u{1fe33}\u02c8\ufe83\u005f\u{1fcbf}\u{1fb57}\u0c3b\u7220\udde9', |
| layout: pipelineLayout11, |
| multisample: { |
| mask: 0x9cff90d1, |
| }, |
| fragment: {module: shaderModule8, entryPoint: 'fragment0', constants: {}, targets: []}, |
| depthStencil: { |
| format: 'stencil8', |
| depthWriteEnabled: false, |
| stencilFront: { |
| compare: 'equal', |
| failOp: 'increment-wrap', |
| depthFailOp: 'decrement-wrap', |
| passOp: 'decrement-clamp', |
| }, |
| stencilBack: { |
| compare: 'less-equal', |
| failOp: 'decrement-wrap', |
| depthFailOp: 'invert', |
| passOp: 'decrement-clamp', |
| }, |
| stencilReadMask: 3543, |
| depthBias: 46, |
| depthBiasSlopeScale: 15, |
| depthBiasClamp: 80, |
| }, |
| vertex: { |
| module: shaderModule8, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 14116, |
| stepMode: 'instance', |
| attributes: [{ |
| format: 'sint8x4', |
| offset: 11912, |
| shaderLocation: 17, |
| }], |
| }, |
| { |
| arrayStride: 53404, |
| stepMode: 'instance', |
| attributes: [{ |
| format: 'float32x2', |
| offset: 33680, |
| shaderLocation: 26, |
| }, { |
| format: 'uint8x4', |
| offset: 25608, |
| shaderLocation: 25, |
| }, { |
| format: 'snorm16x2', |
| offset: 45972, |
| shaderLocation: 3, |
| }, { |
| format: 'float16x4', |
| offset: 36540, |
| shaderLocation: 22, |
| }, { |
| format: 'unorm16x4', |
| offset: 2524, |
| shaderLocation: 20, |
| }, { |
| format: 'uint8x2', |
| offset: 9966, |
| shaderLocation: 7, |
| }, { |
| format: 'float32x2', |
| offset: 41288, |
| shaderLocation: 12, |
| }, { |
| format: 'uint16x2', |
| offset: 28116, |
| shaderLocation: 13, |
| }, { |
| format: 'float32x3', |
| offset: 21376, |
| shaderLocation: 24, |
| }, { |
| format: 'unorm16x4', |
| offset: 35332, |
| shaderLocation: 21, |
| }, { |
| format: 'uint32x3', |
| offset: 1076, |
| shaderLocation: 8, |
| }, { |
| format: 'float32x2', |
| offset: 14440, |
| shaderLocation: 19, |
| }], |
| }, |
| { |
| arrayStride: 14448, |
| stepMode: 'instance', |
| attributes: [], |
| }, |
| { |
| arrayStride: 25352, |
| stepMode: 'instance', |
| attributes: [], |
| }, |
| { |
| arrayStride: 4916, |
| stepMode: 'instance', |
| attributes: [], |
| }, |
| { |
| arrayStride: 42964, |
| stepMode: 'vertex', |
| attributes: [], |
| }, |
| { |
| arrayStride: 55480, |
| stepMode: 'instance', |
| attributes: [{ |
| format: 'sint16x2', |
| offset: 31340, |
| shaderLocation: 18, |
| }], |
| }, |
| { |
| arrayStride: 45608, |
| stepMode: 'instance', |
| attributes: [{ |
| format: 'snorm16x2', |
| offset: 23724, |
| shaderLocation: 11, |
| }], |
| } |
| ] |
| }, |
| primitive: { |
| topology: 'line-strip', |
| cullMode: 'back', |
| }, |
| }); |
| let commandEncoder46 = device5.createCommandEncoder({label: '\u18d9\ufa3b\u026e\u{1f731}\u0ce5\uc8a6\uefd4'}); |
| let computePassEncoder32 = commandEncoder46.beginComputePass({label: '\u505a\u00d2\u0f1d\u{1fca2}\u{1f776}\u0433\u{1fef1}\u326f'}); |
| let texture68 = device2.createTexture({ |
| label: '\u082f\u04a9\u{1fa11}\u1985\u0fea\u0b92\uf6a8\u96e9\uafae\u0a22', |
| size: [4890, 1, 144], |
| mipLevelCount: 12, |
| format: 'depth24plus-stencil8', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['depth24plus-stencil8'], |
| }); |
| try { |
| renderBundleEncoder37.setVertexBuffer(34, undefined, 1971821671); |
| } catch {} |
| let gpuCanvasContext17 = canvas15.getContext('webgpu'); |
| try { |
| offscreenCanvas15.getContext('webgpu'); |
| } catch {} |
| let commandEncoder47 = device5.createCommandEncoder({label: '\ub2bd\u0a69'}); |
| let querySet37 = device5.createQuerySet({ |
| label: '\u446d\u0b20\u5253\u9904\u0804\u01ba\uce62\u0f27\u{1ff30}', |
| type: 'occlusion', |
| count: 2650, |
| }); |
| try { |
| computePassEncoder32.setBindGroup(1, bindGroup19); |
| } catch {} |
| try { |
| computePassEncoder32.insertDebugMarker('\u{1fd62}'); |
| } catch {} |
| try { |
| gpuCanvasContext8.configure({ |
| device: device5, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['astc-8x5-unorm-srgb', 'rgba8unorm-srgb', 'rgba8unorm', 'rgba8unorm-srgb'], |
| colorSpace: 'display-p3', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let imageData20 = new ImageData(184, 120); |
| let buffer17 = device2.createBuffer({size: 46132, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE, mappedAtCreation: true}); |
| let querySet38 = device2.createQuerySet({ |
| label: '\u0bde\u55fc\u{1fe95}\u6266\ucaa9\u03ce\u{1ffa5}\ubf16\u{1ff36}\ub4dd', |
| type: 'occlusion', |
| count: 1319, |
| }); |
| let texture69 = device2.createTexture({ |
| label: '\u836b\u5560\uea6d\u{1f7b4}\udc33\u056d\u9e1a', |
| size: [237], |
| dimension: '1d', |
| format: 'r16uint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['r16uint', 'r16uint', 'r16uint'], |
| }); |
| let textureView47 = texture48.createView({baseMipLevel: 6, arrayLayerCount: 1}); |
| try { |
| renderBundleEncoder37.setVertexBuffer(49, undefined, 2015521719); |
| } catch {} |
| try { |
| commandEncoder40.copyTextureToTexture({ |
| texture: texture48, |
| mipLevel: 6, |
| origin: { x: 11, y: 0, z: 0 }, |
| aspect: 'all', |
| }, { |
| texture: texture48, |
| mipLevel: 7, |
| origin: { x: 4, y: 0, z: 0 }, |
| aspect: 'all', |
| }, {width: 0, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| let canvas16 = document.createElement('canvas'); |
| let commandEncoder48 = device2.createCommandEncoder({label: '\u{1fa30}\u99af\u6fa2\u4f01'}); |
| let querySet39 = device2.createQuerySet({ |
| label: '\ue4ba\u5fc6\u0f46\u{1f7c1}\u00e1\u1d11\ua1e6\u5500', |
| type: 'occlusion', |
| count: 357, |
| }); |
| let textureView48 = texture47.createView({aspect: 'all', mipLevelCount: 1, baseArrayLayer: 17, arrayLayerCount: 12}); |
| let renderBundle46 = renderBundleEncoder35.finish({label: '\u7ba9\u4c34\uad22\ufb1b\u{1f6ce}\u7990'}); |
| try { |
| computePassEncoder28.end(); |
| } catch {} |
| try { |
| device2.addEventListener('uncapturederror', e => { log('device2.uncapturederror'); log(e); e.label = device2.label; }); |
| } catch {} |
| let pipeline53 = await device2.createComputePipelineAsync({ |
| label: '\u0c01\u5ea4\u6571\u{1f916}\u1b47\u50c4\u845e', |
| layout: pipelineLayout11, |
| compute: { |
| module: shaderModule8, |
| entryPoint: 'compute0', |
| constants: {}, |
| }, |
| }); |
| let texture70 = device2.createTexture({ |
| label: '\uabb4\u0a75\u{1faae}\u{1f681}\u099b\u{1fcc4}\u2512\ub3fd\u0d07', |
| size: {width: 80, height: 27, depthOrArrayLayers: 137}, |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: ['rgb10a2unorm', 'rgb10a2unorm'], |
| }); |
| let renderBundle47 = renderBundleEncoder34.finish(); |
| try { |
| renderBundleEncoder37.setVertexBuffer(5, undefined); |
| } catch {} |
| let promise31 = device2.queue.onSubmittedWorkDone(); |
| let offscreenCanvas16 = new OffscreenCanvas(767, 989); |
| pseudoSubmit(device3, commandEncoder39); |
| try { |
| computePassEncoder24.setBindGroup(2, bindGroup16, new Uint32Array(7942), 4593, 0); |
| } catch {} |
| try { |
| gpuCanvasContext17.configure({ |
| device: device3, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| device3.destroy(); |
| } catch {} |
| let bindGroupLayout25 = pipeline33.getBindGroupLayout(0); |
| let computePassEncoder33 = commandEncoder30.beginComputePass({label: '\u2314\ub688\ub38e\u72a5\u39b7\u6379\u09ef'}); |
| let renderBundle48 = renderBundleEncoder23.finish({label: '\uc60b\u8e39\u{1f779}\u900b\u38c0\u{1f845}'}); |
| let sampler48 = device0.createSampler({ |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 90.046, |
| lodMaxClamp: 99.751, |
| maxAnisotropy: 12, |
| }); |
| try { |
| renderBundleEncoder38.drawIndexed(24, 8, 64); |
| } catch {} |
| try { |
| device0.pushErrorScope('out-of-memory'); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let pipeline54 = device0.createRenderPipeline({ |
| layout: pipelineLayout3, |
| fragment: { |
| module: shaderModule2, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{ |
| format: 'rgb10a2unorm', |
| blend: { |
| color: {operation: 'subtract', srcFactor: 'dst-alpha', dstFactor: 'one-minus-dst'}, |
| alpha: {operation: 'add', srcFactor: 'src', dstFactor: 'dst-alpha'}, |
| }, |
| writeMask: 0 |
| }, { |
| format: 'bgra8unorm-srgb', |
| blend: { |
| color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'}, |
| alpha: {operation: 'subtract', srcFactor: 'constant', dstFactor: 'one-minus-dst-alpha'}, |
| }, |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN | GPUColorWrite.RED |
| }, { |
| format: 'rgba16float', |
| blend: { |
| color: {operation: 'reverse-subtract', srcFactor: 'dst-alpha', dstFactor: 'src-alpha'}, |
| alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'}, |
| }, |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.RED |
| }, {format: 'rg32sint'}, { |
| format: 'rg16float', |
| blend: { |
| color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'}, |
| alpha: {operation: 'subtract', srcFactor: 'one-minus-src-alpha', dstFactor: 'src-alpha-saturated'}, |
| }, |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.RED |
| }, {format: 'r8sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN | GPUColorWrite.RED}] |
| }, |
| depthStencil: { |
| format: 'depth24plus-stencil8', |
| depthWriteEnabled: true, |
| depthCompare: 'greater', |
| stencilFront: { |
| compare: 'less-equal', |
| failOp: 'zero', |
| depthFailOp: 'zero', |
| passOp: 'replace', |
| }, |
| stencilBack: { |
| compare: 'less', |
| failOp: 'increment-wrap', |
| depthFailOp: 'increment-wrap', |
| passOp: 'zero', |
| }, |
| stencilWriteMask: 2941, |
| depthBias: 37, |
| depthBiasSlopeScale: 53, |
| depthBiasClamp: 63, |
| }, |
| vertex: { |
| module: shaderModule2, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 13244, |
| attributes: [], |
| }, |
| { |
| arrayStride: 14496, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'sint32x4', |
| offset: 1552, |
| shaderLocation: 15, |
| }, { |
| format: 'snorm16x2', |
| offset: 1660, |
| shaderLocation: 4, |
| }, { |
| format: 'snorm16x4', |
| offset: 1144, |
| shaderLocation: 12, |
| }, { |
| format: 'float32x3', |
| offset: 12600, |
| shaderLocation: 5, |
| }, { |
| format: 'sint32x4', |
| offset: 10616, |
| shaderLocation: 8, |
| }, { |
| format: 'uint8x4', |
| offset: 12164, |
| shaderLocation: 3, |
| }, { |
| format: 'uint32x2', |
| offset: 4688, |
| shaderLocation: 10, |
| }, { |
| format: 'uint16x4', |
| offset: 3564, |
| shaderLocation: 11, |
| }, { |
| format: 'float16x2', |
| offset: 13124, |
| shaderLocation: 13, |
| }, { |
| format: 'uint16x2', |
| offset: 12332, |
| shaderLocation: 0, |
| }, { |
| format: 'uint32x2', |
| offset: 6400, |
| shaderLocation: 2, |
| }, { |
| format: 'sint32x2', |
| offset: 3668, |
| shaderLocation: 6, |
| }, { |
| format: 'sint8x4', |
| offset: 11836, |
| shaderLocation: 1, |
| }, { |
| format: 'snorm16x2', |
| offset: 12928, |
| shaderLocation: 7, |
| }, { |
| format: 'uint32x2', |
| offset: 9900, |
| shaderLocation: 14, |
| }], |
| } |
| ] |
| }, |
| primitive: { |
| topology: 'line-list', |
| cullMode: 'none', |
| unclippedDepth: true, |
| }, |
| }); |
| let promise32 = adapter7.requestDevice({ |
| label: '\u{1fc9e}\u0418\u0409\u002f\u{1f780}\uc2ae\u080d\u76c6\uc7e0\u{1f9b3}\u8db7', |
| requiredFeatures: [ |
| 'depth-clip-control', |
| 'depth32float-stencil8', |
| 'shader-f16', |
| 'rg11b10ufloat-renderable', |
| 'bgra8unorm-storage' |
| ], |
| requiredLimits: { |
| maxColorAttachmentBytesPerSample: 41, |
| maxVertexAttributes: 24, |
| maxVertexBufferArrayStride: 16250, |
| maxStorageTexturesPerShaderStage: 29, |
| maxStorageBuffersPerShaderStage: 36, |
| maxDynamicStorageBuffersPerPipelineLayout: 52727, |
| maxBindingsPerBindGroup: 5819, |
| maxTextureDimension1D: 9652, |
| maxTextureDimension2D: 11612, |
| maxVertexBuffers: 12, |
| minStorageBufferOffsetAlignment: 64, |
| minUniformBufferOffsetAlignment: 32, |
| maxUniformBufferBindingSize: 196423672, |
| maxUniformBuffersPerShaderStage: 32, |
| maxInterStageShaderVariables: 45, |
| maxInterStageShaderComponents: 72, |
| maxSamplersPerShaderStage: 18, |
| }, |
| }); |
| let bindGroup21 = device5.createBindGroup({ |
| layout: bindGroupLayout24, |
| entries: [], |
| }); |
| let pipelineLayout13 = device5.createPipelineLayout({ |
| label: '\ua470\u0fa5\u{1f98b}\u2e4e\u0656\u072e', |
| bindGroupLayouts: [bindGroupLayout24, bindGroupLayout24, bindGroupLayout24, bindGroupLayout24, bindGroupLayout24] |
| }); |
| let buffer18 = device2.createBuffer({ |
| label: '\u059a\u8306\u04b0\u0f41\ufb5c\u02a3\u90bf', |
| size: 26171, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE |
| }); |
| let commandBuffer10 = commandEncoder37.finish(); |
| let textureView49 = texture48.createView({dimension: '3d', baseMipLevel: 2}); |
| let computePassEncoder34 = commandEncoder40.beginComputePass(); |
| let renderBundleEncoder43 = device2.createRenderBundleEncoder({ |
| colorFormats: [], |
| depthStencilFormat: 'depth24plus-stencil8', |
| sampleCount: 4, |
| depthReadOnly: true, |
| stencilReadOnly: true |
| }); |
| let renderBundle49 = renderBundleEncoder34.finish({label: '\udab9\u1630\uabb9\u5420\u1298\ued7f\u08b8\u1c98'}); |
| try { |
| computePassEncoder23.setPipeline(pipeline50); |
| } catch {} |
| let video13 = await videoWithData(); |
| let imageData21 = new ImageData(136, 136); |
| try { |
| offscreenCanvas16.getContext('bitmaprenderer'); |
| } catch {} |
| pseudoSubmit(device5, commandEncoder42); |
| let textureView50 = texture67.createView({ |
| label: '\u61dd\u{1fc30}\u0a2a\u7eb3\u0b99\u100b\ub812\uf5b3\u{1ffe2}\u88e2', |
| aspect: 'all', |
| baseMipLevel: 3, |
| mipLevelCount: 1, |
| baseArrayLayer: 125, |
| arrayLayerCount: 35 |
| }); |
| let renderBundleEncoder44 = device5.createRenderBundleEncoder({ |
| label: '\u0fcc\ud2a6\u0f9e\u0679\u0588\u{1fa48}\ue43f\u0df5\u005a\ub9e5\ub8ec', |
| colorFormats: ['rgba8sint', 'rg8sint', undefined, 'r8uint', undefined, 'rgba16sint', 'rgb10a2uint'], |
| sampleCount: 4, |
| depthReadOnly: true, |
| stencilReadOnly: true |
| }); |
| let renderBundle50 = renderBundleEncoder44.finish({}); |
| let querySet40 = device0.createQuerySet({ |
| label: '\u{1f9ec}\u{1f6ea}', |
| type: 'occlusion', |
| count: 2614, |
| }); |
| let renderBundle51 = renderBundleEncoder22.finish({label: '\u{1fffe}\u5662'}); |
| try { |
| computePassEncoder27.setBindGroup(2, bindGroup18); |
| } catch {} |
| try { |
| computePassEncoder26.setBindGroup(2, bindGroup8, new Uint32Array(8541), 2653, 0); |
| } catch {} |
| try { |
| renderBundleEncoder26.setBindGroup(4, bindGroup3, new Uint32Array(9401), 7982, 0); |
| } catch {} |
| try { |
| renderBundleEncoder38.draw(56, 72, 16); |
| } catch {} |
| try { |
| renderBundleEncoder40.setVertexBuffer(5, buffer1, 13860); |
| } catch {} |
| try { |
| device0.queue.submit([ |
| commandBuffer5, |
| ]); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer12, 25492, new DataView(new ArrayBuffer(37429)), 5540, 5232); |
| } catch {} |
| let gpuCanvasContext18 = canvas16.getContext('webgpu'); |
| try { |
| await promise31; |
| } catch {} |
| let canvas17 = document.createElement('canvas'); |
| let bindGroup22 = device0.createBindGroup({ |
| layout: bindGroupLayout8, |
| entries: [{ |
| binding: 1160, |
| resource: externalTexture0 |
| }], |
| }); |
| let pipelineLayout14 = device0.createPipelineLayout({ |
| bindGroupLayouts: [bindGroupLayout15, bindGroupLayout25, bindGroupLayout3, bindGroupLayout4, bindGroupLayout3, bindGroupLayout7, bindGroupLayout8] |
| }); |
| let renderBundle52 = renderBundleEncoder10.finish(); |
| try { |
| renderBundleEncoder26.setIndexBuffer(buffer10, 'uint32', 45336, 8752); |
| } catch {} |
| try { |
| commandEncoder28.copyBufferToBuffer(buffer1, 2224, buffer3, 26044, 13312); |
| dissociateBuffer(device0, buffer1); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| commandEncoder25.copyTextureToBuffer({ |
| texture: texture40, |
| mipLevel: 1, |
| origin: { x: 0, y: 12, z: 0 }, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 32 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 30528 */ |
| offset: 30528, |
| bytesPerRow: 256, |
| buffer: buffer12, |
| }, {width: 24, height: 24, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer12); |
| } catch {} |
| try { |
| commandEncoder28.copyTextureToTexture({ |
| texture: texture26, |
| mipLevel: 0, |
| origin: { x: 1125, y: 1, z: 0 }, |
| aspect: 'all', |
| }, { |
| texture: texture60, |
| mipLevel: 4, |
| origin: { x: 87, y: 0, z: 0 }, |
| aspect: 'all', |
| }, {width: 74, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| commandEncoder25.resolveQuerySet(querySet5, 54, 51, buffer12, 2304); |
| } catch {} |
| let pipeline55 = await device0.createComputePipelineAsync({ |
| label: '\u61de\u{1fd8f}\ua94e\u0ede\u3e47\u0a8c\u007f\ucd86\u{1f83a}', |
| layout: pipelineLayout9, |
| compute: { |
| module: shaderModule0, |
| entryPoint: 'compute0', |
| constants: {}, |
| }, |
| }); |
| let buffer19 = device2.createBuffer({size: 62780, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE}); |
| let commandEncoder49 = device2.createCommandEncoder({}); |
| let texture71 = device2.createTexture({ |
| size: [320, 110, 1], |
| mipLevelCount: 6, |
| sampleCount: 1, |
| format: 'stencil8', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['stencil8', 'stencil8'], |
| }); |
| let renderBundle53 = renderBundleEncoder43.finish({label: '\u{1fcbd}\u{1fe79}\ub40b\u0f98'}); |
| let promise33 = buffer13.mapAsync(GPUMapMode.WRITE, 0, 1468); |
| try { |
| commandEncoder49.clearBuffer(buffer19); |
| dissociateBuffer(device2, buffer19); |
| } catch {} |
| try { |
| gpuCanvasContext10.configure({ |
| device: device2, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| canvas15.height = 175; |
| let commandEncoder50 = device0.createCommandEncoder(); |
| let renderBundle54 = renderBundleEncoder11.finish({}); |
| try { |
| renderBundleEncoder38.drawIndexedIndirect(buffer3, 15200); |
| } catch {} |
| let arrayBuffer6 = buffer7.getMappedRange(0, 2380); |
| try { |
| await buffer6.mapAsync(GPUMapMode.WRITE, 8440); |
| } catch {} |
| try { |
| commandEncoder25.copyBufferToBuffer(buffer16, 2524, buffer12, 22000, 696); |
| dissociateBuffer(device0, buffer16); |
| dissociateBuffer(device0, buffer12); |
| } catch {} |
| try { |
| commandEncoder25.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 11180 */ |
| offset: 11180, |
| rowsPerImage: 21, |
| buffer: buffer4, |
| }, { |
| texture: texture59, |
| mipLevel: 0, |
| origin: { x: 0, y: 0, z: 1 }, |
| aspect: 'all', |
| }, {width: 0, height: 1, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer4); |
| } catch {} |
| try { |
| commandEncoder25.copyTextureToTexture({ |
| texture: texture40, |
| mipLevel: 1, |
| origin: { x: 0, y: 0, z: 1 }, |
| aspect: 'all', |
| }, { |
| texture: texture40, |
| mipLevel: 1, |
| origin: { x: 24, y: 12, z: 0 }, |
| aspect: 'all', |
| }, {width: 12, height: 36, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder50.resolveQuerySet(querySet1, 1157, 23, buffer12, 32000); |
| } catch {} |
| try { |
| renderBundleEncoder40.pushDebugGroup('\u0cdb'); |
| } catch {} |
| try { |
| canvas17.getContext('webgl2'); |
| } catch {} |
| let commandBuffer11 = commandEncoder41.finish({ |
| label: '\u0f5f\ua303', |
| }); |
| let texture72 = device4.createTexture({ |
| size: {width: 600}, |
| dimension: '1d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_SRC, |
| viewFormats: ['rgba8sint', 'rgba8sint'], |
| }); |
| let renderBundleEncoder45 = device4.createRenderBundleEncoder({ |
| label: '\u0ecd\u413b\u{1f8f9}\u{1f641}\u{1fc0d}\u2029\uc15e\u{1f7d1}\ud7c8\ue4bc\u084d', |
| colorFormats: ['rg32float', 'rgba32sint'], |
| depthReadOnly: true, |
| stencilReadOnly: false |
| }); |
| try { |
| await promise29; |
| } catch {} |
| let offscreenCanvas17 = new OffscreenCanvas(844, 40); |
| let bindGroupLayout26 = device4.createBindGroupLayout({ |
| label: '\u{1ffe5}\u08bf\u0961\u1607\uc3fd\u{1fd6a}\u94c9\u03f3\u{1ff86}\u0eda', |
| entries: [{ |
| binding: 754, |
| visibility: 0, |
| sampler: { type: 'filtering' }, |
| }, { |
| binding: 366, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba32uint', access: 'read-only', viewDimension: '2d-array' }, |
| }, { |
| binding: 879, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false }, |
| }], |
| }); |
| let pipelineLayout15 = device4.createPipelineLayout({ |
| label: '\u{1fd47}\u1fc6\u8b75\u0318', |
| bindGroupLayouts: [bindGroupLayout26, bindGroupLayout26, bindGroupLayout26, bindGroupLayout26] |
| }); |
| pseudoSubmit(device4, commandEncoder44); |
| let textureView51 = texture66.createView({label: '\u8f24\u{1fcee}\u5127\u{1f7bf}'}); |
| let renderBundleEncoder46 = device4.createRenderBundleEncoder({ |
| label: '\u82f0\u0221\ua810\u0512\u{1f8db}\u4321\uded7\u02f8\u0fa4', |
| colorFormats: ['rg32float', 'rgba32sint'], |
| stencilReadOnly: false |
| }); |
| let renderBundle55 = renderBundleEncoder45.finish({label: '\u2d76\ud4da\u077d\u8d82\uf1b2\ua7dc\u723c'}); |
| try { |
| renderBundleEncoder46.setVertexBuffer(98, undefined, 3729226227, 520930243); |
| } catch {} |
| let gpuCanvasContext19 = offscreenCanvas17.getContext('webgpu'); |
| let bindGroupLayout27 = device5.createBindGroupLayout({ |
| label: '\u9f09\u096e\u{1ff08}\ubb66\u0f88\u05a6\ub490', |
| entries: [{ |
| binding: 3496, |
| visibility: GPUShaderStage.VERTEX, |
| sampler: { type: 'filtering' }, |
| }, { |
| binding: 2772, |
| visibility: GPUShaderStage.FRAGMENT, |
| externalTexture: {}, |
| }, { |
| binding: 6385, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| externalTexture: {}, |
| }], |
| }); |
| let buffer20 = device5.createBuffer({ |
| label: '\u0101\u{1f6a9}\u{1f791}\u{1f824}\u5d2a\u09d2\ub0fc\u{1f64f}\u5b24\uf74e', |
| size: 32432, |
| usage: GPUBufferUsage.INDEX |
| }); |
| let sampler49 = device5.createSampler({ |
| label: '\ua1f0\u1b79\u0ebf\u{1fb22}', |
| addressModeV: 'mirror-repeat', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 30.808, |
| lodMaxClamp: 43.812, |
| compare: 'less', |
| }); |
| try { |
| await device5.popErrorScope(); |
| } catch {} |
| try { |
| if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(0x55) }; |
| } catch {} |
| try { |
| device4.queue.submit([ |
| ]); |
| } catch {} |
| try { |
| await device4.queue.onSubmittedWorkDone(); |
| } catch {} |
| let buffer21 = device5.createBuffer({ |
| label: '\ucd7c\u0b81\u0288\u{1fb62}\ua3f9\u{1fdfb}', |
| size: 30320, |
| usage: GPUBufferUsage.COPY_SRC, |
| mappedAtCreation: true |
| }); |
| let texture73 = device5.createTexture({ |
| label: '\u36f9\u040e\ub7cf\u{1fd63}\u{1fb6a}\ubbdd\u85da\u{1f62b}\ufa77\u86dd\u222f', |
| size: [30, 32, 342], |
| mipLevelCount: 4, |
| dimension: '3d', |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler50 = device5.createSampler({ |
| label: '\u0a90\u608e\u09f5\u224f\uccb5\u0a99\u5fb9\u{1fba5}\u00eb\u0f2e', |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'clamp-to-edge', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 35.381, |
| lodMaxClamp: 43.961, |
| }); |
| try { |
| computePassEncoder32.setBindGroup(2, bindGroup19, new Uint32Array(2094), 273, 0); |
| } catch {} |
| try { |
| await promise33; |
| } catch {} |
| let img12 = await imageWithData(200, 109, '#5473a1d8', '#2f622f52'); |
| let commandEncoder51 = device5.createCommandEncoder({label: '\u00e3\u{1f825}\u061a\ucb76\u{1f9a4}'}); |
| let texture74 = device5.createTexture({ |
| label: '\u8e53\ueadd\u0d0b\u0301\u56d2\u{1f8c8}\u{1fbbf}\u69cd\udcb1\uc2d2\ud267', |
| size: [120, 128, 224], |
| mipLevelCount: 2, |
| format: 'etc2-rgb8a1unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['etc2-rgb8a1unorm-srgb', 'etc2-rgb8a1unorm-srgb'], |
| }); |
| let textureView52 = texture73.createView({format: 'bgra8unorm', mipLevelCount: 3}); |
| try { |
| commandEncoder43.copyTextureToTexture({ |
| texture: texture74, |
| mipLevel: 0, |
| origin: { x: 80, y: 44, z: 122 }, |
| aspect: 'all', |
| }, { |
| texture: texture74, |
| mipLevel: 1, |
| origin: { x: 20, y: 24, z: 93 }, |
| aspect: 'all', |
| }, {width: 28, height: 36, depthOrArrayLayers: 94}); |
| } catch {} |
| let buffer22 = device4.createBuffer({size: 18020, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let texture75 = device4.createTexture({ |
| label: '\u{1ff9c}\u075e\u0115\u8162\u{1faf4}\ubeee\u63c7\u097f', |
| size: {width: 600, height: 1, depthOrArrayLayers: 74}, |
| mipLevelCount: 4, |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'rg16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rg16sint', 'rg16sint', 'rg16sint'], |
| }); |
| let textureView53 = texture66.createView({label: '\u{1f688}\u64f9\u0203\u{1fdf1}\u8a2e', dimension: '1d', aspect: 'all'}); |
| let renderBundle56 = renderBundleEncoder45.finish({}); |
| try { |
| renderBundleEncoder46.setVertexBuffer(62, undefined, 2032357105, 1403290832); |
| } catch {} |
| try { |
| device4.addEventListener('uncapturederror', e => { log('device4.uncapturederror'); log(e); e.label = device4.label; }); |
| } catch {} |
| try { |
| gpuCanvasContext7.configure({ |
| device: device4, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| viewFormats: ['rg16uint', 'bgra8unorm-srgb'], |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| try { |
| await device4.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| if (!arrayBuffer6.detached) { new Uint8Array(arrayBuffer6).fill(0x55) }; |
| } catch {} |
| let textureView54 = texture7.createView({baseArrayLayer: 0}); |
| let sampler51 = device0.createSampler({ |
| label: '\uf17b\u6ff2\u4972\uacb3\u64a1', |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'repeat', |
| minFilter: 'linear', |
| lodMinClamp: 54.740, |
| lodMaxClamp: 85.747, |
| }); |
| try { |
| renderBundleEncoder38.drawIndirect(buffer3, 37916); |
| } catch {} |
| try { |
| commandEncoder28.copyBufferToBuffer(buffer5, 16820, buffer3, 12688, 324); |
| dissociateBuffer(device0, buffer5); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| commandEncoder28.clearBuffer(buffer12, 25996, 3328); |
| dissociateBuffer(device0, buffer12); |
| } catch {} |
| try { |
| commandEncoder50.resolveQuerySet(querySet11, 1085, 685, buffer12, 29440); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture19, |
| mipLevel: 0, |
| origin: { x: 410, y: 27, z: 543 }, |
| aspect: 'all', |
| }, new Int16Array(new ArrayBuffer(0)), /* required buffer size: 13663411 */ |
| {offset: 563, bytesPerRow: 1234, rowsPerImage: 173}, {width: 271, height: 0, depthOrArrayLayers: 65}); |
| } catch {} |
| let canvas18 = document.createElement('canvas'); |
| let video14 = await videoWithData(); |
| let renderBundleEncoder47 = device5.createRenderBundleEncoder({ |
| label: '\u{1f61e}\u33de\u0d1d\u737e\u{1fe5a}\ua5c6\u07e4\u0990\u38f6\u2fbe\u0135', |
| colorFormats: ['r32sint', 'rgba8uint'], |
| depthStencilFormat: 'depth24plus-stencil8', |
| sampleCount: 4 |
| }); |
| try { |
| commandEncoder43.copyTextureToTexture({ |
| texture: texture74, |
| mipLevel: 1, |
| origin: { x: 0, y: 8, z: 115 }, |
| aspect: 'all', |
| }, { |
| texture: texture74, |
| mipLevel: 1, |
| origin: { x: 20, y: 12, z: 62 }, |
| aspect: 'all', |
| }, {width: 36, height: 28, depthOrArrayLayers: 7}); |
| } catch {} |
| try { |
| device5.queue.writeTexture({ |
| texture: texture74, |
| mipLevel: 1, |
| origin: { x: 20, y: 8, z: 110 }, |
| aspect: 'all', |
| }, arrayBuffer3, /* required buffer size: 1735357 */ |
| {offset: 221, bytesPerRow: 214, rowsPerImage: 180}, {width: 12, height: 36, depthOrArrayLayers: 46}); |
| } catch {} |
| let video15 = await videoWithData(); |
| try { |
| computePassEncoder34.end(); |
| } catch {} |
| try { |
| commandEncoder40.copyTextureToBuffer({ |
| texture: texture62, |
| mipLevel: 0, |
| origin: { x: 4, y: 0, z: 0 }, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 6000 widthInBlocks: 1500 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 25960 */ |
| offset: 25960, |
| bytesPerRow: 6400, |
| buffer: buffer19, |
| }, {width: 1500, height: 1, depthOrArrayLayers: 0}); |
| dissociateBuffer(device2, buffer19); |
| } catch {} |
| let canvas19 = document.createElement('canvas'); |
| let videoFrame13 = new VideoFrame(offscreenCanvas4, {timestamp: 0}); |
| let video16 = await videoWithData(); |
| let imageBitmap13 = await createImageBitmap(canvas7); |
| try { |
| canvas18.getContext('webgl2'); |
| } catch {} |
| let bindGroupLayout28 = device2.createBindGroupLayout({ |
| label: '\u{1f93e}\uba0d\u02d8\ud339\u7c42\u74ea', |
| entries: [], |
| }); |
| let commandEncoder52 = device2.createCommandEncoder({label: '\u{1fad5}\ua3db\u0149\ufa49\u72a9\u0eda\u494c\u1c31\ubedb\u{1fef0}\u{1fab0}'}); |
| let texture76 = device2.createTexture({ |
| label: '\u0edc\uce81', |
| size: {width: 475}, |
| dimension: '1d', |
| format: 'r16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['r16uint'], |
| }); |
| let texture77 = device2.createTexture({ |
| label: '\u{1fb24}\u{1f88c}\u8131', |
| size: {width: 475, height: 1, depthOrArrayLayers: 278}, |
| mipLevelCount: 4, |
| dimension: '3d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rgb10a2uint', 'rgb10a2uint'], |
| }); |
| let textureView55 = texture68.createView({ |
| dimension: '2d', |
| aspect: 'stencil-only', |
| baseMipLevel: 4, |
| mipLevelCount: 3, |
| baseArrayLayer: 58, |
| arrayLayerCount: 1 |
| }); |
| let renderBundle57 = renderBundleEncoder43.finish({}); |
| try { |
| commandEncoder48.copyBufferToBuffer(buffer13, 2288, buffer19, 6580, 80); |
| dissociateBuffer(device2, buffer13); |
| dissociateBuffer(device2, buffer19); |
| } catch {} |
| try { |
| commandEncoder49.insertDebugMarker('\ue06a'); |
| } catch {} |
| try { |
| device2.queue.writeBuffer(buffer19, 29824, new BigUint64Array(36550), 4761, 0); |
| } catch {} |
| try { |
| device2.queue.writeTexture({ |
| texture: texture48, |
| mipLevel: 4, |
| origin: { x: 9, y: 2, z: 2 }, |
| aspect: 'all', |
| }, arrayBuffer3, /* required buffer size: 106097 */ |
| {offset: 874, bytesPerRow: 549, rowsPerImage: 187}, {width: 91, height: 5, depthOrArrayLayers: 2}); |
| } catch {} |
| gc(); |
| let querySet41 = device4.createQuerySet({ |
| label: '\u25b3\ua386', |
| type: 'occlusion', |
| count: 1356, |
| }); |
| let texture78 = device4.createTexture({ |
| label: '\u0c32\ue4ae\ua1cd\u7c03\uf1a9\u9e57\u4cf6', |
| size: {width: 600, height: 1, depthOrArrayLayers: 134}, |
| format: 'depth24plus-stencil8', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: ['depth24plus-stencil8', 'depth24plus-stencil8', 'depth24plus-stencil8'], |
| }); |
| let renderBundle58 = renderBundleEncoder41.finish({label: '\ub576\u0758\uece4\uc4d3'}); |
| document.body.prepend(canvas3); |
| let imageData22 = new ImageData(20, 192); |
| let commandEncoder53 = device5.createCommandEncoder({}); |
| try { |
| computePassEncoder32.setBindGroup(0, bindGroup19, new Uint32Array(5358), 4142, 0); |
| } catch {} |
| try { |
| computePassEncoder32.end(); |
| } catch {} |
| try { |
| computePassEncoder31.insertDebugMarker('\u{1f812}'); |
| } catch {} |
| let canvas20 = document.createElement('canvas'); |
| video4.height = 138; |
| let img13 = await imageWithData(35, 39, '#bd345cab', '#8ac10889'); |
| document.body.prepend(canvas3); |
| try { |
| canvas19.getContext('webgpu'); |
| } catch {} |
| let adapter8 = await navigator.gpu.requestAdapter({ |
| }); |
| let commandEncoder54 = device4.createCommandEncoder({label: '\u52b5\u0e69\u2d85\ub155'}); |
| let querySet42 = device4.createQuerySet({ |
| label: '\u03f7\u0780\u0c30\u034e\ue57a\u036a\u6a4a\u08e8\u281d', |
| type: 'occlusion', |
| count: 2153, |
| }); |
| let renderBundleEncoder48 = device4.createRenderBundleEncoder({ |
| label: '\u08d8\u{1fb21}\u{1f857}\u3ad1\u{1fd1c}\u6d1b\u0fb3\u{1f9bb}\uc77c', |
| colorFormats: ['rg32float', 'rgba32sint'], |
| sampleCount: 1, |
| depthReadOnly: true |
| }); |
| let sampler52 = device4.createSampler({ |
| label: '\ua1e7\u12b1\u{1fc07}\u6196\u088e\ue1b0\u0570\u010a', |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 99.665, |
| maxAnisotropy: 2, |
| }); |
| try { |
| texture64.destroy(); |
| } catch {} |
| try { |
| commandEncoder54.insertDebugMarker('\u3628'); |
| } catch {} |
| try { |
| device4.destroy(); |
| } catch {} |
| let offscreenCanvas18 = new OffscreenCanvas(742, 45); |
| let bindGroup23 = device5.createBindGroup({ |
| label: '\uc504\uadd5\u1054\u9f8f\uee4b\u0f6b\u09e8\u1931\u0d30\ua2c1', |
| layout: bindGroupLayout24, |
| entries: [], |
| }); |
| let texture79 = gpuCanvasContext16.getCurrentTexture(); |
| try { |
| renderBundleEncoder47.setBindGroup(5, bindGroup19); |
| } catch {} |
| try { |
| gpuCanvasContext17.unconfigure(); |
| } catch {} |
| let offscreenCanvas19 = new OffscreenCanvas(35, 591); |
| document.body.prepend(video1); |
| try { |
| if (!arrayBuffer4.detached) { new Uint8Array(arrayBuffer4).fill(0x55) }; |
| } catch {} |
| let videoFrame14 = new VideoFrame(offscreenCanvas9, {timestamp: 0}); |
| let renderBundleEncoder49 = device5.createRenderBundleEncoder({ |
| label: '\u581b\u263b\u{1ffbc}\u0af1\u0f19\u{1f7d9}\u2b8c\u0b22\ue824\u{1f8af}\u0dda', |
| colorFormats: ['rgba8sint', 'rg8sint', undefined, 'r8uint', undefined, 'rgba16sint', 'rgb10a2uint'], |
| sampleCount: 4, |
| depthReadOnly: true, |
| stencilReadOnly: true |
| }); |
| let sampler53 = device5.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 90.415, |
| lodMaxClamp: 95.544, |
| maxAnisotropy: 18, |
| }); |
| let video17 = await videoWithData(); |
| try { |
| window.someLabel = device1.queue.label; |
| } catch {} |
| let offscreenCanvas20 = new OffscreenCanvas(584, 405); |
| let computePassEncoder35 = commandEncoder43.beginComputePass(); |
| let renderBundleEncoder50 = device5.createRenderBundleEncoder({ |
| colorFormats: ['r32sint', 'rgba8uint'], |
| depthStencilFormat: 'depth24plus-stencil8', |
| sampleCount: 4, |
| depthReadOnly: true |
| }); |
| try { |
| computePassEncoder35.setBindGroup(4, bindGroup21); |
| } catch {} |
| let promise34 = device5.queue.onSubmittedWorkDone(); |
| gc(); |
| let videoFrame15 = new VideoFrame(img6, {timestamp: 0}); |
| let commandEncoder55 = device0.createCommandEncoder({label: '\udb73\ud336\u8cf5\ud23b\u{1f873}\u0d93'}); |
| let computePassEncoder36 = commandEncoder28.beginComputePass({}); |
| let renderBundleEncoder51 = device0.createRenderBundleEncoder({ |
| label: '\u2274\u5f6a\u0401', |
| colorFormats: ['rg16uint', 'r16sint', 'r16float', 'rgba16sint'], |
| depthStencilFormat: 'depth32float-stencil8', |
| depthReadOnly: false |
| }); |
| try { |
| renderBundleEncoder28.setBindGroup(5, bindGroup10, new Uint32Array(7942), 2106, 0); |
| } catch {} |
| try { |
| renderBundleEncoder38.draw(40, 48, 72, 72); |
| } catch {} |
| try { |
| renderBundleEncoder38.drawIndexedIndirect(buffer3, 15588); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| commandEncoder55.copyBufferToBuffer(buffer16, 3040, buffer12, 19100, 332); |
| dissociateBuffer(device0, buffer16); |
| dissociateBuffer(device0, buffer12); |
| } catch {} |
| let pipeline56 = device0.createComputePipeline({ |
| label: '\u{1f9bc}\uafc6\u989a\u2ae1\ue3c7\ubce0\u40fe', |
| layout: pipelineLayout14, |
| compute: { |
| module: shaderModule3, |
| entryPoint: 'compute0', |
| constants: {}, |
| }, |
| }); |
| gc(); |
| let videoFrame16 = new VideoFrame(video0, {timestamp: 0}); |
| try { |
| renderBundleEncoder47.setBindGroup(2, bindGroup20); |
| } catch {} |
| let bindGroupLayout29 = device0.createBindGroupLayout({ |
| label: '\u367d\u4b7e\u2d0e\ub1c7\u{1f7e5}\u{1f8aa}\u{1f9f2}\ud975\ufd99\u0650', |
| entries: [{ |
| binding: 4823, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| externalTexture: {}, |
| }], |
| }); |
| let texture80 = device0.createTexture({ |
| label: '\u{1ff77}\u{1f8ef}\u0d9c\u{1fd06}\u2091\u{1f7a8}\u4956\u0e50\uc4ea\u11be', |
| size: [228, 12, 95], |
| format: 'astc-12x12-unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST, |
| viewFormats: ['astc-12x12-unorm-srgb', 'astc-12x12-unorm'], |
| }); |
| let computePassEncoder37 = commandEncoder50.beginComputePass({label: '\u9aaf\u{1ff59}\u02dc\u238e\u0578\u03f0\u3c3d\u{1ff31}'}); |
| let renderBundleEncoder52 = device0.createRenderBundleEncoder({ |
| label: '\u7277\u1679\u3536\uec97\u03f3\u{1fe08}\u04d8\u0ec0\u00cf', |
| colorFormats: ['r16sint', 'r8uint', 'rg16uint', 'r8uint', 'rg32sint', 'r8unorm'], |
| sampleCount: 4 |
| }); |
| try { |
| computePassEncoder22.setPipeline(pipeline32); |
| } catch {} |
| try { |
| renderBundleEncoder38.drawIndirect(buffer3, 28316); |
| } catch {} |
| try { |
| renderBundleEncoder28.setVertexBuffer(5, buffer1, 5224, 12733); |
| } catch {} |
| let promise35 = buffer16.mapAsync(GPUMapMode.WRITE, 2312, 1716); |
| try { |
| device0.queue.writeBuffer(buffer12, 29136, new Float32Array(17921), 8269, 1148); |
| } catch {} |
| try { |
| buffer6.label = '\uc980\u110d'; |
| } catch {} |
| let buffer23 = device0.createBuffer({ |
| label: '\u{1febc}\u2b7f\u311a\ud3bf\u0dff\u{1f74a}\u632b\u{1fa64}', |
| size: 51197, |
| usage: GPUBufferUsage.COPY_DST |
| }); |
| let computePassEncoder38 = commandEncoder55.beginComputePass(); |
| let renderBundle59 = renderBundleEncoder52.finish({label: '\u0084\u4926'}); |
| try { |
| computePassEncoder18.end(); |
| } catch {} |
| try { |
| renderBundleEncoder38.drawIndexed(56); |
| } catch {} |
| try { |
| renderBundleEncoder38.drawIndexedIndirect(buffer3, 37332); |
| } catch {} |
| try { |
| renderBundleEncoder38.drawIndirect(buffer3, 30860); |
| } catch {} |
| try { |
| commandEncoder25.copyBufferToBuffer(buffer1, 8344, buffer3, 6432, 8904); |
| dissociateBuffer(device0, buffer1); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| commandEncoder25.copyTextureToBuffer({ |
| texture: texture15, |
| mipLevel: 0, |
| origin: { x: 0, y: 0, z: 0 }, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 19736 */ |
| offset: 19736, |
| rowsPerImage: 171, |
| buffer: buffer23, |
| }, {width: 0, height: 1, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer23); |
| } catch {} |
| try { |
| commandEncoder25.clearBuffer(buffer12, 13992, 3644); |
| dissociateBuffer(device0, buffer12); |
| } catch {} |
| let img14 = await imageWithData(251, 229, '#ad41cfbf', '#82f6382e'); |
| let bindGroupLayout30 = device0.createBindGroupLayout({ |
| label: '\u08c6\ubd53\u5931\u47e8\u0e5c\uc4ac\u{1fb72}\u7f07\u68c8\u5430\u0536', |
| entries: [{ |
| binding: 694, |
| visibility: 0, |
| storageTexture: { format: 'r32sint', access: 'read-only', viewDimension: '3d' }, |
| }, { |
| binding: 566, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| sampler: { type: 'filtering' }, |
| }], |
| }); |
| let bindGroup24 = device0.createBindGroup({ |
| label: '\u907b\u48bb\ud803\u{1fe23}\u{1f757}\uaa9d\u0783', |
| layout: bindGroupLayout15, |
| entries: [{ |
| binding: 5491, |
| resource: externalTexture0 |
| }, { |
| binding: 1495, |
| resource: sampler36 |
| }, { |
| binding: 5397, |
| resource: externalTexture0 |
| }], |
| }); |
| let buffer24 = device0.createBuffer({size: 283, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE}); |
| let querySet43 = device0.createQuerySet({ |
| label: '\u156b\uda6c\u65a8\u59cf\u6a2d\u0b79\u0f4f\u2479\u0171', |
| type: 'occlusion', |
| count: 1080, |
| }); |
| let texture81 = device0.createTexture({ |
| label: '\u5ff0\u881a\u9654\u8eb5\ua964\u{1f8dc}\u084c\u9a38', |
| size: [1176, 1, 1025], |
| mipLevelCount: 5, |
| dimension: '3d', |
| format: 'rgba8snorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rgba8snorm'], |
| }); |
| let computePassEncoder39 = commandEncoder25.beginComputePass({}); |
| let renderBundleEncoder53 = device0.createRenderBundleEncoder({ |
| label: '\u07f0\u53c6\u45bb\u2694\u097c\u{1f70c}\ua1e5\u{1fb73}\u07e5\udf17\ue6ac', |
| colorFormats: ['rg8unorm', undefined], |
| depthStencilFormat: 'depth32float-stencil8' |
| }); |
| let renderBundle60 = renderBundleEncoder0.finish({label: '\u0cb7\u08c4\ud6a1\u26c6\ufb92'}); |
| let sampler54 = device0.createSampler({ |
| label: '\u{1f8b7}\u0e65\ub013\uf5cd\ud4b7\u0609\u08bc\u07f9\u03a2\u{1f897}\udfa7', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'mirror-repeat', |
| lodMinClamp: 68.425, |
| lodMaxClamp: 99.684, |
| compare: 'greater', |
| }); |
| try { |
| computePassEncoder36.setBindGroup(0, bindGroup10, []); |
| } catch {} |
| try { |
| computePassEncoder19.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderBundleEncoder24.setBindGroup(5, bindGroup6, new Uint32Array(805), 42, 0); |
| } catch {} |
| try { |
| renderBundleEncoder38.drawIndexedIndirect(buffer3, 19680); |
| } catch {} |
| try { |
| commandEncoder12.copyTextureToBuffer({ |
| texture: texture17, |
| mipLevel: 0, |
| origin: { x: 2352, y: 12, z: 0 }, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 5472 widthInBlocks: 342 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 19296 */ |
| offset: 19296, |
| buffer: buffer12, |
| }, {width: 2736, height: 6, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer12); |
| } catch {} |
| try { |
| commandEncoder12.clearBuffer(buffer12, 26736, 4416); |
| dissociateBuffer(device0, buffer12); |
| } catch {} |
| let bindGroup25 = device2.createBindGroup({ |
| layout: bindGroupLayout28, |
| entries: [], |
| }); |
| let commandEncoder56 = device2.createCommandEncoder({label: '\ue5d3\u{1f9e0}\u0b8a\u6c4a\u0309\u701b'}); |
| let computePassEncoder40 = commandEncoder52.beginComputePass({label: '\u0103\u077a\u005d'}); |
| let sampler55 = device2.createSampler({ |
| label: '\ub81c\u{1f63c}\ua678\u7d3c\u{1fe05}', |
| addressModeU: 'mirror-repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 97.241, |
| maxAnisotropy: 11, |
| }); |
| try { |
| commandEncoder40.copyTextureToTexture({ |
| texture: texture77, |
| mipLevel: 3, |
| origin: { x: 8, y: 1, z: 18 }, |
| aspect: 'all', |
| }, { |
| texture: texture77, |
| mipLevel: 2, |
| origin: { x: 57, y: 1, z: 31 }, |
| aspect: 'all', |
| }, {width: 48, height: 0, depthOrArrayLayers: 3}); |
| } catch {} |
| let texture82 = gpuCanvasContext7.getCurrentTexture(); |
| let textureView56 = texture73.createView({label: '\u0a67\u{1fe86}\u0f12', format: 'bgra8unorm', baseMipLevel: 2, mipLevelCount: 1}); |
| let renderBundle61 = renderBundleEncoder50.finish({}); |
| try { |
| device5.queue.writeTexture({ |
| texture: texture82, |
| mipLevel: 0, |
| origin: { x: 0, y: 0, z: 0 }, |
| aspect: 'all', |
| }, new Int8Array(arrayBuffer6), /* required buffer size: 587 */ |
| {offset: 583}, {width: 1, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| let device6 = await adapter8.requestDevice({ |
| requiredLimits: { |
| maxColorAttachmentBytesPerSample: 59, |
| maxVertexAttributes: 24, |
| maxVertexBufferArrayStride: 53215, |
| maxStorageTexturesPerShaderStage: 5, |
| maxDynamicStorageBuffersPerPipelineLayout: 53746, |
| maxBindingsPerBindGroup: 9036, |
| maxTextureDimension1D: 13090, |
| maxTextureDimension2D: 13725, |
| maxVertexBuffers: 9, |
| minUniformBufferOffsetAlignment: 32, |
| maxUniformBufferBindingSize: 255511045, |
| maxUniformBuffersPerShaderStage: 40, |
| maxInterStageShaderVariables: 26, |
| maxInterStageShaderComponents: 104, |
| maxSamplersPerShaderStage: 18, |
| }, |
| }); |
| let offscreenCanvas21 = new OffscreenCanvas(545, 281); |
| try { |
| adapter8.label = '\u909c\u40f2'; |
| } catch {} |
| let texture83 = device3.createTexture({ |
| label: '\u06c9\u{1f6cf}\u{1f85e}\u18b7\u28ee', |
| size: {width: 1776, height: 20, depthOrArrayLayers: 32}, |
| mipLevelCount: 3, |
| format: 'etc2-rgb8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['etc2-rgb8unorm-srgb', 'etc2-rgb8unorm', 'etc2-rgb8unorm'], |
| }); |
| let textureView57 = texture50.createView({label: '\u6677\u68f4\ud9dd\u1fcc', dimension: '2d', baseMipLevel: 2, mipLevelCount: 2, baseArrayLayer: 166}); |
| let promise36 = device3.popErrorScope(); |
| try { |
| device3.addEventListener('uncapturederror', e => { log('device3.uncapturederror'); log(e); e.label = device3.label; }); |
| } catch {} |
| try { |
| device3.queue.writeTexture({ |
| texture: texture56, |
| mipLevel: 0, |
| origin: { x: 5, y: 0, z: 15 }, |
| aspect: 'all', |
| }, new Uint16Array(new ArrayBuffer(56)), /* required buffer size: 3795015 */ |
| {offset: 959, bytesPerRow: 656, rowsPerImage: 118}, {width: 204, height: 2, depthOrArrayLayers: 50}); |
| } catch {} |
| let promise37 = device3.queue.onSubmittedWorkDone(); |
| let texture84 = device5.createTexture({ |
| label: '\ub9c5\u83d4\ucb12\u0f7d\uee8f\u40c0\u41d2\u9bea', |
| size: {width: 705, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 9, |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderBundle62 = renderBundleEncoder44.finish({label: '\u{1f76a}\u8cf6\uc62c\u{1f769}'}); |
| let sampler56 = device5.createSampler({ |
| label: '\u20f3\ub47b\ub8d2\u0a10\u0652\u{1fe8a}\u9140\u0625\u4b86\u0de9', |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| lodMinClamp: 19.565, |
| }); |
| try { |
| renderBundleEncoder49.setVertexBuffer(41, undefined); |
| } catch {} |
| try { |
| device5.queue.writeTexture({ |
| texture: texture84, |
| mipLevel: 6, |
| origin: { x: 6, y: 0, z: 0 }, |
| aspect: 'all', |
| }, arrayBuffer2, /* required buffer size: 335 */ |
| {offset: 335}, {width: 4, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| let gpuCanvasContext20 = offscreenCanvas18.getContext('webgpu'); |
| try { |
| await promise36; |
| } catch {} |
| let videoFrame17 = new VideoFrame(videoFrame6, {timestamp: 0}); |
| try { |
| canvas20.getContext('webgl'); |
| } catch {} |
| try { |
| offscreenCanvas19.getContext('bitmaprenderer'); |
| } catch {} |
| try { |
| if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55) }; |
| } catch {} |
| try { |
| offscreenCanvas21.getContext('2d'); |
| } catch {} |
| try { |
| textureView38.label = '\u{1fa94}\u0562\u20f7\u62ab\u{1ffb0}\u8d95\u4c3c\u5b3a\udc57'; |
| } catch {} |
| try { |
| gpuCanvasContext6.unconfigure(); |
| } catch {} |
| let externalTexture3 = device0.importExternalTexture({ |
| label: '\u340c\uce31\u{1f681}\u{1f9db}\uae76\u28f0\u82d5\u80fc\u{1fcd8}\u2108\u24c6', |
| source: videoFrame6, |
| colorSpace: 'srgb', |
| }); |
| try { |
| commandEncoder12.copyTextureToTexture({ |
| texture: texture12, |
| mipLevel: 2, |
| origin: { x: 468, y: 24, z: 0 }, |
| aspect: 'all', |
| }, { |
| texture: texture80, |
| mipLevel: 0, |
| origin: { x: 24, y: 0, z: 30 }, |
| aspect: 'all', |
| }, {width: 168, height: 0, depthOrArrayLayers: 36}); |
| } catch {} |
| try { |
| commandEncoder12.clearBuffer(buffer23, 9552, 14848); |
| dissociateBuffer(device0, buffer23); |
| } catch {} |
| try { |
| computePassEncoder22.popDebugGroup(); |
| } catch {} |
| let imageData23 = new ImageData(136, 168); |
| let commandEncoder57 = device6.createCommandEncoder({label: '\u3279\u{1ffd9}\u1a45'}); |
| pseudoSubmit(device6, commandEncoder57); |
| let texture85 = device6.createTexture({ |
| label: '\u33b3\ue0d1\u0560\u{1f6ce}\u{1f99d}', |
| size: [160, 960, 1], |
| mipLevelCount: 3, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rg8uint'], |
| }); |
| document.body.prepend(canvas3); |
| let bindGroupLayout31 = device2.createBindGroupLayout({ |
| label: '\u{1fea8}\u86bd\u{1f919}\u0d3b\uf931\u95a5\u{1fb06}', |
| entries: [{ |
| binding: 2479, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| sampler: { type: 'filtering' }, |
| }, { |
| binding: 3615, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: true }, |
| }], |
| }); |
| let computePassEncoder41 = commandEncoder40.beginComputePass({label: '\u8893\u4bff\u1f7e\u{1fe2d}\u3d10\u{1fa48}\u03f4\u074b\u01dd\u011a\uca7e'}); |
| let renderBundle63 = renderBundleEncoder43.finish({label: '\u052d\uf167\u01c1\u2b4f\u{1f85a}\u0a77\u0593\u{1f605}\u675c\u{1fe54}\uabd1'}); |
| try { |
| computePassEncoder41.setBindGroup(4, bindGroup25); |
| } catch {} |
| try { |
| renderBundleEncoder37.setVertexBuffer(9, undefined, 1201707677, 631816372); |
| } catch {} |
| try { |
| commandEncoder49.pushDebugGroup('\u{1fa32}'); |
| } catch {} |
| let sampler57 = device0.createSampler({ |
| label: '\uf6fa\ua9d4\ufcd2\ub3e2\uae96\u0280\u{1f795}\u1cfb\u079a\u0bc6', |
| addressModeU: 'repeat', |
| addressModeW: 'repeat', |
| lodMaxClamp: 70.565, |
| }); |
| try { |
| renderBundleEncoder38.drawIndexed(72); |
| } catch {} |
| try { |
| buffer24.destroy(); |
| } catch {} |
| try { |
| commandEncoder12.copyBufferToBuffer(buffer5, 19944, buffer12, 15792, 3424); |
| dissociateBuffer(device0, buffer5); |
| dissociateBuffer(device0, buffer12); |
| } catch {} |
| try { |
| commandEncoder12.copyTextureToBuffer({ |
| texture: texture60, |
| mipLevel: 5, |
| origin: { x: 45, y: 0, z: 0 }, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 620 widthInBlocks: 155 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 22920 */ |
| offset: 22920, |
| buffer: buffer12, |
| }, {width: 155, height: 0, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer12); |
| } catch {} |
| try { |
| gpuCanvasContext17.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: ['astc-10x5-unorm-srgb', 'rgba8unorm-srgb', 'rgba8unorm-srgb', 'astc-6x6-unorm'], |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let promise38 = device0.queue.onSubmittedWorkDone(); |
| let offscreenCanvas22 = new OffscreenCanvas(556, 371); |
| let textureView58 = texture85.createView({label: '\u0736\u2ca2\u0153\uf205\uf970\ua994', dimension: '2d', mipLevelCount: 2}); |
| let renderBundleEncoder54 = device6.createRenderBundleEncoder({ |
| label: '\u7be0\u0017\u6fb0\u{1f604}\u7bce\uc2b8\u{1fcdb}', |
| colorFormats: ['rg16uint', 'rgba8sint', 'rgb10a2uint', 'rg8sint', 'rgba32sint'], |
| depthReadOnly: true, |
| stencilReadOnly: true |
| }); |
| try { |
| await promise34; |
| } catch {} |
| let imageData24 = new ImageData(136, 152); |
| try { |
| offscreenCanvas20.getContext('webgpu'); |
| } catch {} |
| let buffer25 = device6.createBuffer({ |
| label: '\u2cb3\u{1ffc0}\u{1f82f}\ubd77\u04ee\u{1f6aa}', |
| size: 4300, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE |
| }); |
| let texture86 = device6.createTexture({ |
| label: '\u9490\u{1fd92}\u082e\u0631\ua6f6\udf71', |
| size: {width: 1590}, |
| dimension: '1d', |
| format: 'r16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| viewFormats: ['r16uint'], |
| }); |
| let renderBundle64 = renderBundleEncoder54.finish({}); |
| let imageBitmap14 = await createImageBitmap(canvas1); |
| let commandEncoder58 = device6.createCommandEncoder({label: '\ub198\u97f3\u0d18'}); |
| let computePassEncoder42 = commandEncoder58.beginComputePass({}); |
| let sampler58 = device6.createSampler({ |
| label: '\u{1f64f}\u1ae2\u06d9\u{1f820}\u{1feff}\u69bf\u01c2\u07bc\u{1f946}', |
| addressModeU: 'clamp-to-edge', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| lodMinClamp: 96.514, |
| lodMaxClamp: 99.695, |
| }); |
| let video18 = await videoWithData(); |
| try { |
| computePassEncoder35.setBindGroup(3, bindGroup21); |
| } catch {} |
| try { |
| renderBundleEncoder47.setVertexBuffer(71, undefined, 3360772369, 785381293); |
| } catch {} |
| try { |
| device5.queue.copyExternalImageToTexture(/* |
| {width: 22, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData10, |
| origin: { x: 3, y: 33 }, |
| flipY: true, |
| }, { |
| texture: texture84, |
| mipLevel: 5, |
| origin: { x: 4, y: 1, z: 0 }, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 11, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| let commandBuffer12 = commandEncoder45.finish(); |
| let texture87 = gpuCanvasContext3.getCurrentTexture(); |
| let renderBundleEncoder55 = device5.createRenderBundleEncoder({ |
| colorFormats: ['bgra8unorm', 'rg32sint', 'rgb10a2uint', 'rg16sint', 'r16float'], |
| depthReadOnly: true, |
| stencilReadOnly: true |
| }); |
| try { |
| buffer21.unmap(); |
| } catch {} |
| try { |
| commandEncoder51.copyTextureToTexture({ |
| texture: texture82, |
| mipLevel: 0, |
| origin: { x: 0, y: 0, z: 1 }, |
| aspect: 'all', |
| }, { |
| texture: texture82, |
| mipLevel: 0, |
| origin: { x: 1, y: 0, z: 0 }, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device5.queue.writeTexture({ |
| texture: texture82, |
| mipLevel: 0, |
| origin: { x: 0, y: 1, z: 1 }, |
| aspect: 'all', |
| }, arrayBuffer4, /* required buffer size: 197 */ |
| {offset: 197}, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let adapter9 = await navigator.gpu.requestAdapter({ |
| powerPreference: 'low-power', |
| }); |
| let device7 = await promise32; |
| let img15 = await imageWithData(42, 142, '#e159e3b3', '#400e57a5'); |
| let renderBundleEncoder56 = device0.createRenderBundleEncoder({ |
| label: '\u26c2\u8d98\u{1ff5b}\u5aa4\u0bfe\u0b74\uc453\u05bd\u965a\u07ef', |
| colorFormats: ['r16sint', 'r8uint', 'rg16uint', 'r8uint', 'rg32sint', 'r8unorm'], |
| sampleCount: 4 |
| }); |
| let sampler59 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 54.233, |
| lodMaxClamp: 82.396, |
| maxAnisotropy: 13, |
| }); |
| try { |
| commandEncoder12.copyTextureToTexture({ |
| texture: texture12, |
| mipLevel: 2, |
| origin: { x: 564, y: 0, z: 67 }, |
| aspect: 'all', |
| }, { |
| texture: texture40, |
| mipLevel: 1, |
| origin: { x: 0, y: 0, z: 0 }, |
| aspect: 'all', |
| }, {width: 0, height: 36, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| await promise35; |
| } catch {} |
| let textureView59 = texture79.createView({label: '\u0ce4\u9c50\ufb35', dimension: '2d-array', format: 'bgra8unorm-srgb'}); |
| let computePassEncoder43 = commandEncoder51.beginComputePass(); |
| let renderBundleEncoder57 = device5.createRenderBundleEncoder({ |
| label: '\u9006\u7395', |
| colorFormats: ['r32sint', 'rgba8uint'], |
| depthStencilFormat: 'depth24plus-stencil8', |
| sampleCount: 4, |
| depthReadOnly: true |
| }); |
| try { |
| renderBundleEncoder49.setVertexBuffer(89, undefined, 1796533354, 703946550); |
| } catch {} |
| try { |
| buffer21.unmap(); |
| } catch {} |
| try { |
| await device5.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| gpuCanvasContext2.unconfigure(); |
| } catch {} |
| let bindGroupLayout32 = device2.createBindGroupLayout({ |
| label: '\ud062\u2527\u799c', |
| entries: [{ |
| binding: 3338, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: 'cube-array', sampleType: 'unfilterable-float', multisampled: false }, |
| }, { |
| binding: 1520, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: '1d', sampleType: 'uint', multisampled: false }, |
| }, { |
| binding: 2084, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| externalTexture: {}, |
| }], |
| }); |
| let texture88 = device2.createTexture({ |
| size: {width: 761}, |
| dimension: '1d', |
| format: 'rg16float', |
| usage: GPUTextureUsage.COPY_DST, |
| viewFormats: ['rg16float'], |
| }); |
| let sampler60 = device2.createSampler({ |
| label: '\ud609\u6111\u34a2\u0674\u457a\u0c83\u{1fa48}\ub8ef\u0f73\u9da2', |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| minFilter: 'nearest', |
| lodMinClamp: 85.344, |
| lodMaxClamp: 99.692, |
| }); |
| try { |
| computePassEncoder23.setPipeline(pipeline53); |
| } catch {} |
| try { |
| renderBundleEncoder37.setBindGroup(5, bindGroup25); |
| } catch {} |
| try { |
| renderBundleEncoder37.setVertexBuffer(74, undefined, 1638112670); |
| } catch {} |
| try { |
| commandEncoder56.copyBufferToBuffer(buffer17, 25184, buffer19, 52508, 9928); |
| dissociateBuffer(device2, buffer17); |
| dissociateBuffer(device2, buffer19); |
| } catch {} |
| try { |
| commandEncoder49.copyTextureToTexture({ |
| texture: texture62, |
| mipLevel: 0, |
| origin: { x: 28, y: 1, z: 1 }, |
| aspect: 'all', |
| }, { |
| texture: texture62, |
| mipLevel: 0, |
| origin: { x: 263, y: 0, z: 0 }, |
| aspect: 'all', |
| }, {width: 193, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder49.clearBuffer(buffer19); |
| dissociateBuffer(device2, buffer19); |
| } catch {} |
| gc(); |
| let promise39 = navigator.gpu.requestAdapter({ |
| }); |
| let bindGroup26 = device5.createBindGroup({ |
| label: '\u035f\u0174\u2d0b\u611f\u{1fb16}\ud790\u7100\u{1fc88}\u{1fbae}', |
| layout: bindGroupLayout24, |
| entries: [], |
| }); |
| let commandBuffer13 = commandEncoder46.finish({ |
| }); |
| let textureView60 = texture67.createView({dimension: '2d', baseMipLevel: 4, baseArrayLayer: 15}); |
| let renderBundleEncoder58 = device5.createRenderBundleEncoder({ |
| label: '\u{1f9c5}\u{1ff59}\uff9a\u4785', |
| colorFormats: ['r32sint', 'rgba8uint'], |
| depthStencilFormat: 'depth24plus-stencil8', |
| sampleCount: 4, |
| stencilReadOnly: true |
| }); |
| try { |
| renderBundleEncoder57.setIndexBuffer(buffer20, 'uint32', 9804); |
| } catch {} |
| try { |
| gpuCanvasContext6.configure({ |
| device: device5, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: ['rg16uint', 'rg16float', 'rgba16float', 'depth24plus'], |
| colorSpace: 'display-p3', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device5.queue.submit([ |
| ]); |
| } catch {} |
| try { |
| device5.queue.writeTexture({ |
| texture: texture82, |
| mipLevel: 0, |
| origin: { x: 0, y: 0, z: 0 }, |
| aspect: 'all', |
| }, arrayBuffer4, /* required buffer size: 271 */ |
| {offset: 271}, {width: 1, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| offscreenCanvas22.getContext('bitmaprenderer'); |
| } catch {} |
| try { |
| computePassEncoder38.setBindGroup(0, bindGroup17, new Uint32Array(8519), 2286, 0); |
| } catch {} |
| try { |
| renderBundleEncoder38.draw(64, 72); |
| } catch {} |
| let pipeline57 = await device0.createComputePipelineAsync({ |
| label: '\u8ab1\u099d', |
| layout: pipelineLayout3, |
| compute: { |
| module: shaderModule2, |
| entryPoint: 'compute0', |
| constants: {}, |
| }, |
| }); |
| try { |
| if (!arrayBuffer6.detached) { new Uint8Array(arrayBuffer6).fill(0x55) }; |
| } catch {} |
| let img16 = await imageWithData(7, 195, '#d7d14b73', '#28b2c4de'); |
| let canvas21 = document.createElement('canvas'); |
| try { |
| device1.queue.label = '\uf2d0\u2922\u{1f87d}\u{1fe1b}'; |
| } catch {} |
| video16.width = 10; |
| canvas11.width = 881; |
| let canvas22 = document.createElement('canvas'); |
| pseudoSubmit(device6, commandEncoder58); |
| let texture89 = device6.createTexture({ |
| label: '\u403d\u{1f97b}\u49d6\u02f8\u{1fea0}\u812f\u{1fb84}\u5fb9\u{1fef0}\u0ab0', |
| size: {width: 247}, |
| dimension: '1d', |
| format: 'rg16float', |
| usage: GPUTextureUsage.COPY_SRC, |
| viewFormats: [], |
| }); |
| let textureView61 = texture89.createView({label: '\u{1f85e}\u07d6\uc833', dimension: '1d'}); |
| let renderBundle65 = renderBundleEncoder54.finish({label: '\u91e5\u0856\u08bb\u{1fd20}\uea2e\u0f37'}); |
| let sampler61 = device6.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 61.764, |
| lodMaxClamp: 63.758, |
| maxAnisotropy: 16, |
| }); |
| try { |
| device6.queue.writeTexture({ |
| texture: texture86, |
| mipLevel: 0, |
| origin: { x: 4, y: 1, z: 0 }, |
| aspect: 'all', |
| }, arrayBuffer4, /* required buffer size: 932 */ |
| {offset: 932, rowsPerImage: 252}, {width: 1576, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await promise37; |
| } catch {} |
| let renderBundleEncoder59 = device2.createRenderBundleEncoder({ |
| label: '\uc517\u{1fcc2}\u9675\uee87\ub44e\u0b52\ue54c\u0969', |
| colorFormats: [], |
| depthStencilFormat: 'depth24plus-stencil8', |
| sampleCount: 4 |
| }); |
| let sampler62 = device2.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'nearest', |
| lodMaxClamp: 82.144, |
| }); |
| try { |
| computePassEncoder23.setBindGroup(5, bindGroup25, new Uint32Array(9558), 5431, 0); |
| } catch {} |
| try { |
| computePassEncoder40.setPipeline(pipeline50); |
| } catch {} |
| let arrayBuffer7 = buffer13.getMappedRange(1384, 48); |
| try { |
| commandEncoder49.resolveQuerySet(querySet39, 188, 109, buffer19, 54528); |
| } catch {} |
| try { |
| device2.queue.writeBuffer(buffer19, 20896, new Float32Array(7801)); |
| } catch {} |
| canvas16.width = 482; |
| let textureView62 = texture76.createView({baseArrayLayer: 0}); |
| try { |
| computePassEncoder41.setPipeline(pipeline53); |
| } catch {} |
| try { |
| renderBundleEncoder37.setVertexBuffer(52, undefined, 2766876596, 1194567158); |
| } catch {} |
| let arrayBuffer8 = buffer13.getMappedRange(1432, 28); |
| try { |
| commandEncoder48.clearBuffer(buffer19); |
| dissociateBuffer(device2, buffer19); |
| } catch {} |
| try { |
| gpuCanvasContext17.configure({ |
| device: device2, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: ['rgba16float', 'rgba16float'], |
| colorSpace: 'display-p3', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device2.queue.writeBuffer(buffer19, 34388, new Float32Array(7341), 7221, 112); |
| } catch {} |
| try { |
| device2.queue.writeTexture({ |
| texture: texture88, |
| mipLevel: 0, |
| origin: { x: 88, y: 0, z: 0 }, |
| aspect: 'all', |
| }, new ArrayBuffer(2153), /* required buffer size: 2153 */ |
| {offset: 53, bytesPerRow: 2394}, {width: 525, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| let buffer26 = device7.createBuffer({size: 33187, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM}); |
| let commandEncoder59 = device7.createCommandEncoder({label: '\u{1fae3}\u51bf\u0ae3\u76c4\u91b7\u9907\uaeab\u4425\u2f9a'}); |
| let imageData25 = new ImageData(140, 208); |
| let commandEncoder60 = device5.createCommandEncoder({}); |
| try { |
| renderBundleEncoder57.insertDebugMarker('\u018f'); |
| } catch {} |
| try { |
| device5.queue.submit([ |
| commandBuffer12, |
| ]); |
| } catch {} |
| try { |
| device5.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame12, |
| origin: { x: 101, y: 9 }, |
| flipY: true, |
| }, { |
| texture: texture87, |
| mipLevel: 0, |
| origin: { x: 0, y: 1, z: 1 }, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let img17 = await imageWithData(156, 162, '#62a1649e', '#e28b4148'); |
| let buffer27 = device0.createBuffer({ |
| label: '\u002b\ue5ca\u{1fb39}\u4748\u0384\u{1f98a}', |
| size: 44988, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM, |
| mappedAtCreation: true |
| }); |
| try { |
| renderBundleEncoder38.draw(8, 16, 32, 48); |
| } catch {} |
| offscreenCanvas16.height = 417; |
| let offscreenCanvas23 = new OffscreenCanvas(509, 974); |
| try { |
| device6.queue.label = '\u0799\u{1f7e8}\uc5f1\u1166\u0d2e\u4c5a\u0d12\u1d0f'; |
| } catch {} |
| let commandEncoder61 = device6.createCommandEncoder(); |
| let textureView63 = texture85.createView({dimension: '2d-array', baseMipLevel: 2}); |
| let querySet44 = device6.createQuerySet({ |
| label: '\u{1ff1e}\u3dc1\u{1fe12}\u17a4\u{1fc18}\u030f\u{1f8aa}', |
| type: 'occlusion', |
| count: 624, |
| }); |
| let textureView64 = texture89.createView({label: '\u0add\u546b\u40ee\u0cdb\ua358\uc428', arrayLayerCount: 1}); |
| let renderBundleEncoder60 = device6.createRenderBundleEncoder({ |
| label: '\u1ca8\u03c5\u2d50\uedba\u{1fb00}\u{1fb39}\u3c05\u7d5a\u461e\ud729\u{1fb39}', |
| colorFormats: ['rg16uint', 'rgba8sint', 'rgb10a2uint', 'rg8sint', 'rgba32sint'], |
| stencilReadOnly: false |
| }); |
| let renderBundle66 = renderBundleEncoder60.finish({label: '\u5a4d\u{1fd79}\ucb8e\u021b\u{1fbea}'}); |
| try { |
| externalTexture1.label = '\u689d\u{1fb11}\u03ab\ucf76\u3b6e\u091b\u{1f618}\u{1fcd3}\u0dd0'; |
| } catch {} |
| let bindGroup27 = device5.createBindGroup({ |
| label: '\u6ac6\ucf30\u{1f7d8}\uba1f\u670b\u7447\u7ea4\u0cec\u6518', |
| layout: bindGroupLayout24, |
| entries: [], |
| }); |
| let textureView65 = texture87.createView({ |
| label: '\u04ce\u02c6\uc12f\u{1f68f}\u07a7\uc94f\u{1fc4d}\u06c7\u{1fcae}', |
| format: 'bgra8unorm-srgb', |
| mipLevelCount: 1 |
| }); |
| try { |
| device5.queue.writeTexture({ |
| texture: texture84, |
| mipLevel: 7, |
| origin: { x: 0, y: 1, z: 1 }, |
| aspect: 'all', |
| }, arrayBuffer4, /* required buffer size: 712 */ |
| {offset: 712}, {width: 3, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let offscreenCanvas24 = new OffscreenCanvas(816, 554); |
| let bindGroupLayout33 = device0.createBindGroupLayout({ |
| label: '\u0371\ub283\u{1fe5d}\u8061\uf828\u9c5c\uaa7a\u3b64', |
| entries: [{ |
| binding: 4754, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: true }, |
| }, { |
| binding: 4503, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', minBindingSize: 0, hasDynamicOffset: true }, |
| }], |
| }); |
| let renderBundleEncoder61 = device0.createRenderBundleEncoder({colorFormats: ['rg8unorm', undefined], depthStencilFormat: 'depth32float-stencil8', sampleCount: 1}); |
| try { |
| computePassEncoder25.setBindGroup(4, bindGroup18, new Uint32Array(9934), 147, 0); |
| } catch {} |
| try { |
| computePassEncoder5.setPipeline(pipeline19); |
| } catch {} |
| try { |
| renderBundleEncoder38.draw(8, 48, 32, 0); |
| } catch {} |
| try { |
| commandEncoder12.clearBuffer(buffer12, 1440, 3056); |
| dissociateBuffer(device0, buffer12); |
| } catch {} |
| offscreenCanvas7.height = 57; |
| let video19 = await videoWithData(); |
| let imageBitmap15 = await createImageBitmap(canvas9); |
| let adapter10 = await promise39; |
| let img18 = await imageWithData(105, 291, '#e957ecb1', '#acbfc79d'); |
| let imageBitmap16 = await createImageBitmap(imageBitmap1); |
| let promise40 = adapter0.requestAdapterInfo(); |
| let buffer28 = device5.createBuffer({ |
| label: '\ua8f1\u00d1\u09ba\u0c56', |
| size: 38346, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE |
| }); |
| let querySet45 = device5.createQuerySet({ |
| label: '\u34e4\u{1fc3b}\u{1f647}', |
| type: 'occlusion', |
| count: 3874, |
| }); |
| let texture90 = device5.createTexture({ |
| label: '\u0768\u614d\u0888\ueca7\u0447\u{1fda3}', |
| size: [2821, 1, 176], |
| mipLevelCount: 8, |
| format: 'depth32float-stencil8', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['depth32float-stencil8', 'depth32float-stencil8', 'depth32float-stencil8'], |
| }); |
| let computePassEncoder44 = commandEncoder47.beginComputePass({}); |
| let renderBundleEncoder62 = device5.createRenderBundleEncoder({ |
| label: '\u06f1\u0e2c\u0cf0\u0826\u52eb\u0afb\u03c7\u0ac5\u053e', |
| colorFormats: ['rgba8sint', 'rg8sint', undefined, 'r8uint', undefined, 'rgba16sint', 'rgb10a2uint'], |
| sampleCount: 4, |
| depthReadOnly: true |
| }); |
| try { |
| renderBundleEncoder58.setVertexBuffer(85, undefined, 79672398, 809660989); |
| } catch {} |
| let videoFrame18 = new VideoFrame(videoFrame10, {timestamp: 0}); |
| let textureView66 = texture71.createView({ |
| label: '\u52d4\u5ddd\u35b6\u4fe5\u032e\u0460', |
| dimension: '2d-array', |
| aspect: 'stencil-only', |
| baseMipLevel: 2, |
| mipLevelCount: 1 |
| }); |
| try { |
| computePassEncoder23.setPipeline(pipeline53); |
| } catch {} |
| try { |
| renderBundleEncoder37.setVertexBuffer(85, undefined, 3084872849, 958365805); |
| } catch {} |
| try { |
| commandEncoder49.copyTextureToBuffer({ |
| texture: texture62, |
| mipLevel: 3, |
| origin: { x: 115, y: 0, z: 0 }, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 16 widthInBlocks: 4 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 10592 */ |
| offset: 10592, |
| buffer: buffer19, |
| }, {width: 4, height: 0, depthOrArrayLayers: 0}); |
| dissociateBuffer(device2, buffer19); |
| } catch {} |
| try { |
| device2.queue.writeBuffer(buffer19, 3612, new Int16Array(10023), 9409, 392); |
| } catch {} |
| let video20 = await videoWithData(); |
| let textureView67 = texture79.createView({label: '\u5925\u51e2\u1ea2\ubcd3\u3d19'}); |
| let renderBundle67 = renderBundleEncoder47.finish({}); |
| try { |
| renderBundleEncoder57.setVertexBuffer(51, undefined); |
| } catch {} |
| let promise41 = buffer28.mapAsync(GPUMapMode.WRITE, 22152, 13012); |
| try { |
| computePassEncoder31.pushDebugGroup('\u7f73'); |
| } catch {} |
| try { |
| device5.queue.writeTexture({ |
| texture: texture87, |
| mipLevel: 0, |
| origin: { x: 0, y: 0, z: 1 }, |
| aspect: 'all', |
| }, new Float32Array(arrayBuffer0), /* required buffer size: 386 */ |
| {offset: 386, bytesPerRow: 39, rowsPerImage: 105}, {width: 0, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(video9); |
| try { |
| offscreenCanvas24.getContext('webgl2'); |
| } catch {} |
| let texture91 = device2.createTexture({ |
| size: [160, 1, 14], |
| mipLevelCount: 3, |
| dimension: '3d', |
| format: 'r8sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let pipeline58 = device2.createComputePipeline({ |
| label: '\u05c3\u9677\ua362\u0eb9\u0f73\u98e2\u{1ff26}\u4553\u417d\u3e1b', |
| layout: pipelineLayout11, |
| compute: { |
| module: shaderModule8, |
| entryPoint: 'compute0', |
| constants: {}, |
| }, |
| }); |
| document.body.prepend(video15); |
| let shaderModule9 = device0.createShaderModule({ |
| label: '\u{1fb15}\u036e\u{1fa20}\u07c7', |
| code: `@group(2) @binding(5397) |
| var<storage, read_write> i9: array<u32>; |
| @group(0) @binding(1160) |
| var<storage, read_write> local2: array<u32>; |
| @group(2) @binding(1495) |
| var<storage, read_write> function8: array<u32>; |
| |
| @compute @workgroup_size(6, 1, 4) |
| fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {} |
| |
| struct FragmentOutput0 { |
| @location(1) f0: vec4<i32>, |
| @location(4) f1: vec4<u32>, |
| @location(2) f2: vec4<i32>, |
| @builtin(frag_depth) f3: f32, |
| @builtin(sample_mask) f4: u32, |
| @location(0) f5: vec2<i32>, |
| @location(5) f6: vec4<i32>, |
| @location(3) f7: vec4<f32> |
| } |
| |
| @fragment |
| fn fragment0(@builtin(sample_index) a0: u32, @builtin(sample_mask) a1: u32, @builtin(front_facing) a2: bool, @builtin(position) a3: vec4<f32>) -> FragmentOutput0 { |
| return FragmentOutput0(); |
| } |
| |
| |
| |
| @vertex |
| fn vertex0(@builtin(vertex_index) a0: u32, @location(3) a1: i32) -> @builtin(position) vec4<f32> { |
| return vec4<f32>(0.0, 0.0, 0.0, 1.0); |
| } |
| |
| `, |
| hints: {}, |
| }); |
| let texture92 = device0.createTexture({ |
| label: '\ufa1b\uc87f', |
| size: {width: 2272, height: 18, depthOrArrayLayers: 1}, |
| mipLevelCount: 12, |
| format: 'rgb9e5ufloat', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| viewFormats: [], |
| }); |
| let computePassEncoder45 = commandEncoder12.beginComputePass(); |
| let renderBundle68 = renderBundleEncoder51.finish({label: '\ufdc7\ub823\u{1fc4e}\uedb4\ue1a3\u0dbe\uc73e'}); |
| try { |
| renderBundleEncoder38.drawIndexed(8, 24, 64, 208, 0); |
| } catch {} |
| try { |
| renderBundleEncoder36.setVertexBuffer(6, buffer1, 13064, 4205); |
| } catch {} |
| try { |
| buffer7.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer23, 8216, new DataView(new ArrayBuffer(36841)), 27593, 7244); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture44, |
| mipLevel: 0, |
| origin: { x: 22, y: 0, z: 1 }, |
| aspect: 'all', |
| }, arrayBuffer7, /* required buffer size: 577 */ |
| {offset: 577}, {width: 855, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let canvas23 = document.createElement('canvas'); |
| try { |
| adapter0.label = '\uf4ba\u4238\u01bc\uf20c\u113f\u{1f702}\uab6a\u7ec6\u878d\u25ec'; |
| } catch {} |
| let bindGroupLayout34 = device7.createBindGroupLayout({ |
| label: '\uceba\u031e\u0550\u411d\u7e1b\u3eea', |
| entries: [{ |
| binding: 783, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'uniform', minBindingSize: 614493, hasDynamicOffset: true }, |
| }], |
| }); |
| let commandEncoder62 = device7.createCommandEncoder(); |
| let texture93 = device7.createTexture({ |
| label: '\u02a9\u{1f683}\u3ac3', |
| size: [840, 40, 1], |
| dimension: '3d', |
| format: 'r8snorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['r8snorm'], |
| }); |
| let computePassEncoder46 = commandEncoder59.beginComputePass({}); |
| try { |
| canvas23.getContext('webgpu'); |
| } catch {} |
| let img19 = await imageWithData(56, 163, '#5c0deb8b', '#863116aa'); |
| let texture94 = device5.createTexture({ |
| label: '\u05f0\u0528\u049a\u889e', |
| size: [1410, 1, 1], |
| mipLevelCount: 11, |
| dimension: '2d', |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: ['bgra8unorm-srgb'], |
| }); |
| let renderBundle69 = renderBundleEncoder50.finish({label: '\uc927\u520d\u902e\ucc27\u6c44'}); |
| try { |
| renderBundleEncoder62.setIndexBuffer(buffer20, 'uint16', 1894, 12816); |
| } catch {} |
| try { |
| device7.queue.writeTexture({ |
| texture: texture93, |
| mipLevel: 0, |
| origin: { x: 291, y: 3, z: 0 }, |
| aspect: 'all', |
| }, arrayBuffer7, /* required buffer size: 5790 */ |
| {offset: 745, bytesPerRow: 140}, {width: 5, height: 37, depthOrArrayLayers: 1}); |
| } catch {} |
| let querySet46 = device2.createQuerySet({ |
| label: '\uff9e\u96ef\ua333\u{1f897}\u588b\u0b79', |
| type: 'occlusion', |
| count: 692, |
| }); |
| let texture95 = device2.createTexture({ |
| label: '\u{1fbbb}\u046c\u0bb2\u{1fa09}\uf6fa\u7f2d', |
| size: {width: 1380, height: 1, depthOrArrayLayers: 114}, |
| mipLevelCount: 9, |
| dimension: '3d', |
| format: 'rg8snorm', |
| usage: GPUTextureUsage.COPY_DST, |
| viewFormats: ['rg8snorm', 'rg8snorm'], |
| }); |
| try { |
| renderBundleEncoder37.setBindGroup(3, bindGroup25); |
| } catch {} |
| try { |
| commandEncoder49.popDebugGroup(); |
| } catch {} |
| let pipeline59 = device2.createComputePipeline({ |
| layout: pipelineLayout11, |
| compute: { |
| module: shaderModule7, |
| entryPoint: 'compute0', |
| constants: {}, |
| }, |
| }); |
| try { |
| device6.queue.writeTexture({ |
| texture: texture86, |
| mipLevel: 0, |
| origin: { x: 481, y: 0, z: 0 }, |
| aspect: 'all', |
| }, new Int32Array(new ArrayBuffer(80)), /* required buffer size: 450 */ |
| {offset: 450}, {width: 581, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let renderBundle70 = renderBundleEncoder9.finish({label: '\uf44a\u9654\u2117\u{1fe0d}\u46a8'}); |
| let sampler63 = device0.createSampler({ |
| label: '\ub0db\udd73\u05d8\ufab7\uc8a7\ufa5c\u58a6\u0991\u0d58\u8b71\ua5d4', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 37.925, |
| lodMaxClamp: 78.248, |
| }); |
| try { |
| renderBundleEncoder17.setBindGroup(3, bindGroup13); |
| } catch {} |
| try { |
| renderBundleEncoder38.drawIndexed(80, 64, 72, 344, 48); |
| } catch {} |
| try { |
| renderBundleEncoder38.drawIndexedIndirect(buffer3, 4396); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 1776, new DataView(new ArrayBuffer(34157)), 29805); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: img5, |
| origin: { x: 33, y: 209 }, |
| flipY: false, |
| }, { |
| texture: texture59, |
| mipLevel: 0, |
| origin: { x: 1, y: 0, z: 0 }, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline60 = device0.createComputePipeline({ |
| label: '\ude11\u{1fed2}', |
| layout: pipelineLayout0, |
| compute: { |
| module: shaderModule3, |
| entryPoint: 'compute0', |
| }, |
| }); |
| let pipeline61 = device0.createRenderPipeline({ |
| label: '\u85ff\ue2bc\u{1f739}\u2f3f\u867e', |
| layout: pipelineLayout2, |
| multisample: { |
| count: 4, |
| alphaToCoverageEnabled: true, |
| }, |
| fragment: { |
| module: shaderModule2, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{format: 'rgb10a2unorm', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED}, { |
| format: 'bgra8unorm-srgb', |
| blend: { |
| color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'}, |
| alpha: {operation: 'add', srcFactor: 'src-alpha', dstFactor: 'dst'}, |
| }, |
| writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED |
| }, { |
| format: 'rgba16float', |
| blend: { |
| color: {operation: 'add', srcFactor: 'src', dstFactor: 'dst-alpha'}, |
| alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'}, |
| }, |
| writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED |
| }, {format: 'rg32sint', writeMask: 0}, {format: 'rg16float', writeMask: GPUColorWrite.ALL}, {format: 'r8sint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN}] |
| }, |
| depthStencil: { |
| format: 'depth24plus-stencil8', |
| depthWriteEnabled: true, |
| depthCompare: 'never', |
| stencilFront: { |
| compare: 'not-equal', |
| failOp: 'increment-clamp', |
| passOp: 'increment-clamp', |
| }, |
| stencilBack: { |
| compare: 'less', |
| failOp: 'keep', |
| passOp: 'increment-clamp', |
| }, |
| depthBias: 65, |
| depthBiasClamp: 48, |
| }, |
| vertex: { |
| module: shaderModule2, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 9536, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'sint8x4', |
| offset: 8424, |
| shaderLocation: 1, |
| }, { |
| format: 'uint16x2', |
| offset: 9312, |
| shaderLocation: 14, |
| }, { |
| format: 'sint32x3', |
| offset: 6132, |
| shaderLocation: 8, |
| }, { |
| format: 'snorm8x2', |
| offset: 1024, |
| shaderLocation: 12, |
| }, { |
| format: 'sint8x2', |
| offset: 4282, |
| shaderLocation: 15, |
| }, { |
| format: 'sint8x4', |
| offset: 1140, |
| shaderLocation: 6, |
| }, { |
| format: 'unorm8x4', |
| offset: 5872, |
| shaderLocation: 13, |
| }], |
| }, |
| { |
| arrayStride: 1908, |
| stepMode: 'instance', |
| attributes: [{ |
| format: 'uint8x4', |
| offset: 108, |
| shaderLocation: 11, |
| }, { |
| format: 'uint16x4', |
| offset: 1844, |
| shaderLocation: 0, |
| }, { |
| format: 'float32x3', |
| offset: 144, |
| shaderLocation: 4, |
| }, { |
| format: 'uint32x2', |
| offset: 1464, |
| shaderLocation: 3, |
| }, { |
| format: 'uint32', |
| offset: 920, |
| shaderLocation: 10, |
| }, { |
| format: 'uint16x2', |
| offset: 1244, |
| shaderLocation: 2, |
| }], |
| }, |
| { |
| arrayStride: 0, |
| stepMode: 'instance', |
| attributes: [], |
| }, |
| { |
| arrayStride: 6968, |
| stepMode: 'instance', |
| attributes: [], |
| }, |
| { |
| arrayStride: 2836, |
| stepMode: 'vertex', |
| attributes: [], |
| }, |
| { |
| arrayStride: 5272, |
| attributes: [{ |
| format: 'unorm16x2', |
| offset: 3096, |
| shaderLocation: 5, |
| }, { |
| format: 'float16x2', |
| offset: 2148, |
| shaderLocation: 7, |
| }], |
| } |
| ] |
| }, |
| primitive: { |
| topology: 'line-list', |
| frontFace: 'ccw', |
| cullMode: 'front', |
| unclippedDepth: true, |
| }, |
| }); |
| let querySet47 = device7.createQuerySet({ |
| label: '\u2eff\u8e31\u0819\u40d6\u42d6', |
| type: 'occlusion', |
| count: 1505, |
| }); |
| let textureView68 = texture93.createView({label: '\u{1fdff}\u0c64\u0bd1\u23f5'}); |
| let computePassEncoder47 = commandEncoder62.beginComputePass({label: '\ua995\u1d77\u{1f95c}\u1f1a\u{1fdc7}'}); |
| try { |
| await device7.popErrorScope(); |
| } catch {} |
| offscreenCanvas17.width = 618; |
| let texture96 = device7.createTexture({ |
| label: '\u375c\ude1b\u07f2\u0208\u{1fe3f}\u9b03\u02d8\u0650\u7094\ubdcc\u0939', |
| size: {width: 1248, height: 1, depthOrArrayLayers: 223}, |
| mipLevelCount: 6, |
| format: 'depth32float-stencil8', |
| usage: GPUTextureUsage.COPY_DST, |
| viewFormats: [], |
| }); |
| let renderBundleEncoder63 = device7.createRenderBundleEncoder({ |
| label: '\uf4d4\u6436\ub004\u0f6d\ufac6\u{1fc8b}\u{1f613}\u{1fe95}\u04bf', |
| colorFormats: [], |
| depthStencilFormat: 'depth32float-stencil8', |
| depthReadOnly: true, |
| stencilReadOnly: true |
| }); |
| try { |
| computePassEncoder46.end(); |
| } catch {} |
| try { |
| commandEncoder59.resolveQuerySet(querySet47, 278, 945, buffer26, 11264); |
| } catch {} |
| let gpuCanvasContext21 = canvas21.getContext('webgpu'); |
| try { |
| await promise41; |
| } catch {} |
| let bindGroupLayout35 = device7.createBindGroupLayout({ |
| label: '\u93f2\u{1ff78}\u{1f80f}\u7923\ub6ba\u{1f76d}\u06d7\uad0c', |
| entries: [{ |
| binding: 4885, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rgba8snorm', access: 'read-only', viewDimension: '2d' }, |
| }, { |
| binding: 2560, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', minBindingSize: 0, hasDynamicOffset: false }, |
| }], |
| }); |
| let querySet48 = device7.createQuerySet({ |
| label: '\u9e93\u0cba\u79ed\u6872', |
| type: 'occlusion', |
| count: 1332, |
| }); |
| let renderBundleEncoder64 = device7.createRenderBundleEncoder({ |
| label: '\u51e5\u{1ff4e}', |
| colorFormats: [], |
| depthStencilFormat: 'depth32float-stencil8', |
| depthReadOnly: true |
| }); |
| try { |
| commandEncoder59.resolveQuerySet(querySet48, 712, 430, buffer26, 12032); |
| } catch {} |
| try { |
| canvas22.getContext('bitmaprenderer'); |
| } catch {} |
| let buffer29 = device2.createBuffer({ |
| label: '\u{1fb4d}\uddc7\ubb0c\u9483\ub376\u{1f6f6}\ud339\u44b4', |
| size: 21556, |
| usage: GPUBufferUsage.STORAGE |
| }); |
| let video21 = await videoWithData(); |
| let pipelineLayout16 = device7.createPipelineLayout({bindGroupLayouts: []}); |
| try { |
| if (!arrayBuffer6.detached) { new Uint8Array(arrayBuffer6).fill(0x55) }; |
| } catch {} |
| let offscreenCanvas25 = new OffscreenCanvas(269, 551); |
| let gpuCanvasContext22 = offscreenCanvas25.getContext('webgpu'); |
| try { |
| if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(0x55) }; |
| } catch {} |
| let videoFrame19 = new VideoFrame(img3, {timestamp: 0}); |
| let commandEncoder63 = device5.createCommandEncoder({label: '\u0666\u{1fbbc}\u1fd5'}); |
| let textureView69 = texture94.createView({ |
| label: '\u{1f9b6}\u1a17\u{1fb4d}\u4c56\u0504\u2a58\ued22\u01a8\u7366', |
| format: 'bgra8unorm-srgb', |
| baseMipLevel: 9, |
| mipLevelCount: 1 |
| }); |
| let renderBundleEncoder65 = device5.createRenderBundleEncoder({ |
| label: '\u{1f62e}\u1747\ua9ba\u{1f798}\u04d3', |
| colorFormats: ['rgba8sint', 'rg8sint', undefined, 'r8uint', undefined, 'rgba16sint', 'rgb10a2uint'], |
| sampleCount: 4, |
| depthReadOnly: true, |
| stencilReadOnly: true |
| }); |
| let promise42 = adapter7.requestAdapterInfo(); |
| let commandEncoder64 = device2.createCommandEncoder({label: '\u08fa\u8fe7\u046c'}); |
| let texture97 = device2.createTexture({ |
| label: '\u27e9\udf65\u3f0c\u{1f7b9}\u15e4', |
| size: {width: 2760, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 8, |
| format: 'r32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: ['r32float'], |
| }); |
| try { |
| commandEncoder48.clearBuffer(buffer19); |
| dissociateBuffer(device2, buffer19); |
| } catch {} |
| try { |
| device2.queue.writeBuffer(buffer19, 16972, new DataView(new ArrayBuffer(22991)), 15970, 2036); |
| } catch {} |
| try { |
| await device2.queue.onSubmittedWorkDone(); |
| } catch {} |
| let pipeline62 = await device2.createRenderPipelineAsync({ |
| label: '\u1ea4\uebd6\u4f43\u0624', |
| layout: pipelineLayout11, |
| multisample: { |
| count: 4, |
| mask: 0xdf01786c, |
| }, |
| fragment: {module: shaderModule8, entryPoint: 'fragment0', constants: {}, targets: []}, |
| depthStencil: { |
| format: 'depth24plus-stencil8', |
| depthWriteEnabled: true, |
| depthCompare: 'less', |
| stencilFront: { |
| compare: 'greater', |
| failOp: 'invert', |
| depthFailOp: 'decrement-clamp', |
| passOp: 'increment-clamp', |
| }, |
| stencilBack: { |
| compare: 'less', |
| failOp: 'decrement-clamp', |
| depthFailOp: 'replace', |
| passOp: 'keep', |
| }, |
| stencilReadMask: 4029, |
| stencilWriteMask: 3022, |
| depthBias: 46, |
| depthBiasSlopeScale: 51, |
| depthBiasClamp: 57, |
| }, |
| vertex: { |
| module: shaderModule8, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 40580, |
| attributes: [{ |
| format: 'sint32', |
| offset: 11980, |
| shaderLocation: 17, |
| }, { |
| format: 'uint8x2', |
| offset: 39716, |
| shaderLocation: 25, |
| }], |
| }, |
| { |
| arrayStride: 24284, |
| attributes: [], |
| }, |
| { |
| arrayStride: 30440, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'float32x3', |
| offset: 11676, |
| shaderLocation: 24, |
| }, { |
| format: 'unorm16x2', |
| offset: 5512, |
| shaderLocation: 26, |
| }, { |
| format: 'unorm10-10-10-2', |
| offset: 27848, |
| shaderLocation: 20, |
| }, { |
| format: 'snorm8x2', |
| offset: 11088, |
| shaderLocation: 11, |
| }, { |
| format: 'unorm16x4', |
| offset: 11308, |
| shaderLocation: 3, |
| }, { |
| format: 'uint16x2', |
| offset: 17388, |
| shaderLocation: 7, |
| }, { |
| format: 'uint32x4', |
| offset: 23280, |
| shaderLocation: 13, |
| }, { |
| format: 'sint8x2', |
| offset: 742, |
| shaderLocation: 18, |
| }, { |
| format: 'uint8x4', |
| offset: 29404, |
| shaderLocation: 8, |
| }, { |
| format: 'float16x2', |
| offset: 17184, |
| shaderLocation: 19, |
| }, { |
| format: 'float16x4', |
| offset: 28264, |
| shaderLocation: 21, |
| }], |
| }, |
| { |
| arrayStride: 0, |
| stepMode: 'vertex', |
| attributes: [], |
| }, |
| { |
| arrayStride: 44544, |
| stepMode: 'vertex', |
| attributes: [], |
| }, |
| { |
| arrayStride: 3072, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'unorm10-10-10-2', |
| offset: 1840, |
| shaderLocation: 22, |
| }], |
| }, |
| { |
| arrayStride: 12332, |
| stepMode: 'instance', |
| attributes: [{ |
| format: 'float16x4', |
| offset: 6640, |
| shaderLocation: 12, |
| }], |
| } |
| ] |
| }, |
| primitive: { |
| topology: 'line-list', |
| frontFace: 'cw', |
| cullMode: 'none', |
| }, |
| }); |
| let video22 = await videoWithData(); |
| let bindGroup28 = device0.createBindGroup({ |
| label: '\u0779\ue552\uf280\u14f4\u{1fc34}\u8c2f\u95eb\u{1f67c}\uf05f\ua491', |
| layout: bindGroupLayout10, |
| entries: [{ |
| binding: 1160, |
| resource: externalTexture3 |
| }], |
| }); |
| try { |
| renderBundleEncoder38.drawIndexed(80); |
| } catch {} |
| let gpuCanvasContext23 = offscreenCanvas23.getContext('webgpu'); |
| let canvas24 = document.createElement('canvas'); |
| let shaderModule10 = device2.createShaderModule({ |
| code: `@group(6) @binding(3183) |
| var<storage, read_write> parameter6: array<u32>; |
| @group(4) @binding(2585) |
| var<storage, read_write> local3: array<u32>; |
| @group(8) @binding(3183) |
| var<storage, read_write> function9: array<u32>; |
| @group(5) @binding(2585) |
| var<storage, read_write> local4: array<u32>; |
| @group(8) @binding(2585) |
| var<storage, read_write> global7: array<u32>; |
| @group(3) @binding(3183) |
| var<storage, read_write> parameter7: array<u32>; |
| @group(0) @binding(2585) |
| var<storage, read_write> parameter8: array<u32>; |
| @group(7) @binding(3183) |
| var<storage, read_write> i10: array<u32>; |
| @group(4) @binding(3183) |
| var<storage, read_write> global8: array<u32>; |
| @group(1) @binding(2585) |
| var<storage, read_write> field7: array<u32>; |
| @group(2) @binding(2585) |
| var<storage, read_write> global9: array<u32>; |
| |
| @compute @workgroup_size(7, 4, 4) |
| fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {} |
| |
| |
| |
| @fragment |
| fn fragment0(@location(15) a0: f32, @location(10) a1: f16, @builtin(front_facing) a2: bool, @location(6) a3: vec4<i32>, @builtin(position) a4: vec4<f32>, @location(19) a5: f32, @location(5) a6: vec2<f32>, @location(29) a7: vec4<u32>, @location(13) a8: vec2<i32>, @location(28) a9: u32, @location(21) a10: vec2<u32>) -> @builtin(frag_depth) f32 { |
| return f32(); |
| } |
| |
| struct S9 { |
| @location(1) f0: vec2<u32>, |
| @location(13) f1: vec2<f16>, |
| @location(8) f2: vec2<f32>, |
| @location(3) f3: vec2<f32> |
| } |
| struct VertexOutput0 { |
| @location(8) f134: f32, |
| @location(16) f135: vec2<f16>, |
| @location(1) f136: f16, |
| @location(12) f137: vec2<u32>, |
| @location(7) f138: vec3<i32>, |
| @location(0) f139: vec2<f32>, |
| @location(19) f140: f32, |
| @location(24) f141: f32, |
| @location(21) f142: vec2<u32>, |
| @location(23) f143: vec2<u32>, |
| @location(3) f144: vec2<f32>, |
| @location(9) f145: vec4<u32>, |
| @location(29) f146: vec4<u32>, |
| @location(4) f147: vec4<f32>, |
| @location(5) f148: vec2<f32>, |
| @location(2) f149: vec2<u32>, |
| @location(22) f150: u32, |
| @location(18) f151: f32, |
| @location(13) f152: vec2<i32>, |
| @location(27) f153: vec3<u32>, |
| @location(10) f154: f16, |
| @builtin(position) f155: vec4<f32>, |
| @location(31) f156: u32, |
| @location(15) f157: f32, |
| @location(20) f158: vec2<u32>, |
| @location(28) f159: u32, |
| @location(6) f160: vec4<i32>, |
| @location(32) f161: vec3<i32> |
| } |
| |
| @vertex |
| fn vertex0(@location(18) a0: vec2<i32>, @location(9) a1: u32, @location(7) a2: vec4<i32>, @location(16) a3: vec4<f16>, @location(25) a4: i32, @builtin(instance_index) a5: u32, @location(20) a6: i32, @location(19) a7: f16, @location(5) a8: vec4<f16>, @location(23) a9: i32, @location(22) a10: vec3<f16>, @location(10) a11: u32, @location(6) a12: vec2<f32>, @location(2) a13: vec4<f32>, @location(14) a14: vec3<u32>, @location(4) a15: vec4<f32>, @location(26) a16: vec2<f32>, a17: S9, @location(17) a18: vec4<u32>, @location(12) a19: u32, @location(11) a20: vec4<u32>) -> VertexOutput0 { |
| return VertexOutput0(); |
| } |
| |
| `, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| let bindGroupLayout36 = device2.createBindGroupLayout({ |
| label: '\ucf81\u{1ffde}\u8a05\u0018\u469d\u0308', |
| entries: [{ |
| binding: 3191, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'sint', multisampled: true }, |
| }], |
| }); |
| let sampler64 = device2.createSampler({ |
| label: '\uf70d\ua014\ub38c\u0079\u002d\u7574', |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'clamp-to-edge', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 27.697, |
| lodMaxClamp: 50.805, |
| }); |
| try { |
| computePassEncoder40.setBindGroup(7, bindGroup25, new Uint32Array(7313), 4292, 0); |
| } catch {} |
| try { |
| renderBundleEncoder59.setPipeline(pipeline62); |
| } catch {} |
| try { |
| buffer13.unmap(); |
| } catch {} |
| try { |
| commandEncoder48.copyTextureToBuffer({ |
| texture: texture49, |
| mipLevel: 0, |
| origin: { x: 17, y: 0, z: 0 }, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 1496 widthInBlocks: 187 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 28304 */ |
| offset: 26808, |
| buffer: buffer19, |
| }, {width: 187, height: 1, depthOrArrayLayers: 1}); |
| dissociateBuffer(device2, buffer19); |
| } catch {} |
| let renderBundle71 = renderBundleEncoder49.finish(); |
| let sampler65 = device5.createSampler({ |
| label: '\uddc5\u{1f90f}', |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 14.636, |
| lodMaxClamp: 20.518, |
| maxAnisotropy: 5, |
| }); |
| try { |
| renderBundleEncoder65.setBindGroup(0, bindGroup19); |
| } catch {} |
| let bindGroupLayout37 = device7.createBindGroupLayout({ |
| label: '\u0166\u06e0\u{1f616}', |
| entries: [{ |
| binding: 3038, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| externalTexture: {}, |
| }, { |
| binding: 3660, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| externalTexture: {}, |
| }, { |
| binding: 4730, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rgba32sint', access: 'read-only', viewDimension: '3d' }, |
| }], |
| }); |
| let textureView70 = texture93.createView({label: '\u0e6c\u{1fdc2}'}); |
| try { |
| device7.queue.writeTexture({ |
| texture: texture93, |
| mipLevel: 0, |
| origin: { x: 16, y: 19, z: 0 }, |
| aspect: 'all', |
| }, new BigInt64Array(arrayBuffer1), /* required buffer size: 6392 */ |
| {offset: 712, bytesPerRow: 813}, {width: 802, height: 7, depthOrArrayLayers: 1}); |
| } catch {} |
| let renderBundleEncoder66 = device6.createRenderBundleEncoder({ |
| label: '\u{1fddf}\u076a\u4281\ue464\ua89d\u6e49\u02dc', |
| colorFormats: ['rg16uint', 'rgba8sint', 'rgb10a2uint', 'rg8sint', 'rgba32sint'], |
| depthReadOnly: true |
| }); |
| let canvas25 = document.createElement('canvas'); |
| try { |
| canvas24.getContext('bitmaprenderer'); |
| } catch {} |
| let texture98 = device5.createTexture({ |
| label: '\u8903\ufb56\u0eac\u0e53', |
| size: {width: 120, height: 128, depthOrArrayLayers: 224}, |
| mipLevelCount: 8, |
| format: 'etc2-rgba8unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let promise43 = device5.popErrorScope(); |
| let imageBitmap17 = await createImageBitmap(imageBitmap13); |
| try { |
| canvas25.getContext('webgl'); |
| } catch {} |
| try { |
| if (!arrayBuffer7.detached) { new Uint8Array(arrayBuffer7).fill(0x55) }; |
| } catch {} |
| let buffer30 = device6.createBuffer({ |
| label: '\u378b\uf8fe\u368d\u033b\uaeed\u6704\u{1fe4e}\ua3f7', |
| size: 607, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX |
| }); |
| let renderBundleEncoder67 = device6.createRenderBundleEncoder({ |
| label: '\u{1f95b}\ua534\u8c23\u{1f9e8}\u0016\ue081\u0341\u01fe', |
| colorFormats: ['rg16uint', 'rgba8sint', 'rgb10a2uint', 'rg8sint', 'rgba32sint'], |
| stencilReadOnly: true |
| }); |
| let renderBundle72 = renderBundleEncoder54.finish({label: '\uece1\ueccb\u0ece\u{1ff0e}\u{1ff4b}\u56b0'}); |
| try { |
| commandEncoder61.copyBufferToTexture({ |
| /* bytesInLastRow: 54 widthInBlocks: 27 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 2940 */ |
| offset: 2886, |
| buffer: buffer25, |
| }, { |
| texture: texture86, |
| mipLevel: 0, |
| origin: { x: 1151, y: 0, z: 0 }, |
| aspect: 'all', |
| }, {width: 27, height: 1, depthOrArrayLayers: 1}); |
| dissociateBuffer(device6, buffer25); |
| } catch {} |
| try { |
| device6.queue.writeTexture({ |
| texture: texture86, |
| mipLevel: 0, |
| origin: { x: 478, y: 0, z: 0 }, |
| aspect: 'all', |
| }, arrayBuffer2, /* required buffer size: 1413 */ |
| {offset: 201, rowsPerImage: 112}, {width: 606, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| device6.queue.writeBuffer(buffer30, 604, new Int16Array(31699), 28288, 0); |
| } catch {} |
| try { |
| device6.queue.writeTexture({ |
| texture: texture86, |
| mipLevel: 0, |
| origin: { x: 1226, y: 0, z: 0 }, |
| aspect: 'all', |
| }, new ArrayBuffer(48), /* required buffer size: 208 */ |
| {offset: 208, bytesPerRow: 997, rowsPerImage: 29}, {width: 364, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture99 = device5.createTexture({ |
| label: '\u{1f8f0}\u1cf0\u040d\u86c7', |
| size: {width: 60, height: 64, depthOrArrayLayers: 1858}, |
| mipLevelCount: 3, |
| dimension: '3d', |
| format: 'rgb9e5ufloat', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rgb9e5ufloat', 'rgb9e5ufloat', 'rgb9e5ufloat'], |
| }); |
| let textureView71 = texture82.createView({label: '\u{1f8b2}\u87c6\u2b80\u46fa\u{1f7e6}', dimension: '2d'}); |
| let computePassEncoder48 = commandEncoder60.beginComputePass({}); |
| try { |
| renderBundleEncoder62.setIndexBuffer(buffer20, 'uint32', 29824, 2398); |
| } catch {} |
| try { |
| computePassEncoder31.popDebugGroup(); |
| } catch {} |
| try { |
| gpuCanvasContext8.unconfigure(); |
| } catch {} |
| let imageData26 = new ImageData(196, 164); |
| document.body.prepend(img7); |
| try { |
| await promise42; |
| } catch {} |
| let buffer31 = device6.createBuffer({ |
| label: '\u{1f82e}\u{1f73e}\uf195\u1fd9\u0553\u0853\u436b\u843d\u{1f778}', |
| size: 35072, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE |
| }); |
| let sampler66 = device6.createSampler({ |
| label: '\u7ab3\u0384\u9832\u{1f923}', |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| lodMinClamp: 33.340, |
| lodMaxClamp: 90.123, |
| }); |
| try { |
| device6.queue.writeTexture({ |
| texture: texture86, |
| mipLevel: 0, |
| origin: { x: 171, y: 1, z: 0 }, |
| aspect: 'all', |
| }, new Int16Array(arrayBuffer0), /* required buffer size: 483 */ |
| {offset: 483}, {width: 1037, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| let commandEncoder65 = device0.createCommandEncoder({}); |
| let renderBundle73 = renderBundleEncoder3.finish({label: '\u{1f86d}\u0355\u4e94\u02c3\u5cd8'}); |
| try { |
| renderBundleEncoder24.setBindGroup(3, bindGroup0); |
| } catch {} |
| try { |
| renderBundleEncoder38.draw(56, 64); |
| } catch {} |
| try { |
| buffer24.unmap(); |
| } catch {} |
| try { |
| commandEncoder65.clearBuffer(buffer23, 48056, 1696); |
| dissociateBuffer(device0, buffer23); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 32160, new BigUint64Array(60933), 23380, 1180); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture30, |
| mipLevel: 0, |
| origin: { x: 0, y: 1, z: 0 }, |
| aspect: 'all', |
| }, arrayBuffer0, /* required buffer size: 311 */ |
| {offset: 311}, {width: 10, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| await promise40; |
| } catch {} |
| let shaderModule11 = device0.createShaderModule({ |
| code: `@group(2) @binding(1160) |
| var<storage, read_write> i11: array<u32>; |
| @group(0) @binding(1160) |
| var<storage, read_write> local5: array<u32>; |
| |
| @compute @workgroup_size(2, 4, 2) |
| fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {} |
| |
| struct FragmentOutput0 { |
| @location(0) f0: vec2<f32>, |
| @builtin(frag_depth) f1: f32 |
| } |
| |
| @fragment |
| fn fragment0() -> FragmentOutput0 { |
| return FragmentOutput0(); |
| } |
| |
| struct S10 { |
| @location(9) f0: vec4<u32>, |
| @location(4) f1: u32, |
| @location(8) f2: vec4<i32>, |
| @location(15) f3: vec4<f32>, |
| @location(1) f4: i32 |
| } |
| |
| @vertex |
| fn vertex0(@location(10) a0: vec4<f16>, a1: S10, @location(12) a2: vec2<u32>, @location(2) a3: vec2<f16>, @builtin(instance_index) a4: u32, @location(11) a5: vec4<i32>, @location(7) a6: vec2<f32>, @location(5) a7: vec3<i32>) -> @builtin(position) vec4<f32> { |
| return vec4<f32>(0.0, 0.0, 0.0, 1.0); |
| } |
| |
| `, |
| sourceMap: {}, |
| }); |
| pseudoSubmit(device0, commandEncoder17); |
| let renderBundleEncoder68 = device0.createRenderBundleEncoder({ |
| label: '\u293f\u8b17\ue090\u872f\u2dfe\u2ed8\uab56\u05a4\u0926\u729a', |
| colorFormats: ['r16sint', 'r8uint', 'rg16uint', 'r8uint', 'rg32sint', 'r8unorm'], |
| sampleCount: 4, |
| stencilReadOnly: true |
| }); |
| try { |
| computePassEncoder5.setPipeline(pipeline38); |
| } catch {} |
| try { |
| renderBundleEncoder17.setBindGroup(2, bindGroup3, new Uint32Array(7536), 2723, 0); |
| } catch {} |
| try { |
| renderBundleEncoder38.draw(80, 16, 32, 16); |
| } catch {} |
| try { |
| renderBundleEncoder38.drawIndexedIndirect(buffer3, 37020); |
| } catch {} |
| try { |
| renderBundleEncoder42.setVertexBuffer(7, buffer1); |
| } catch {} |
| try { |
| gpuCanvasContext21.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| colorSpace: 'display-p3', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData20, |
| origin: { x: 77, y: 118 }, |
| flipY: true, |
| }, { |
| texture: texture59, |
| mipLevel: 0, |
| origin: { x: 0, y: 0, z: 0 }, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 1, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| let pipeline63 = device0.createRenderPipeline({ |
| label: '\u34e5\u08ab\uc659\u960f\u87be\uc0a2\ud4fe\ub3bf\u08ec\u0ba7\u{1f9e5}', |
| layout: pipelineLayout2, |
| multisample: { |
| count: 4, |
| mask: 0x91891456, |
| }, |
| fragment: { |
| module: shaderModule11, |
| entryPoint: 'fragment0', |
| targets: [{ |
| format: 'rg8unorm', |
| blend: { |
| color: {operation: 'reverse-subtract', srcFactor: 'zero', dstFactor: 'one-minus-src'}, |
| alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'}, |
| }, |
| writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED |
| }, undefined] |
| }, |
| depthStencil: { |
| format: 'depth24plus-stencil8', |
| depthWriteEnabled: false, |
| depthCompare: 'always', |
| stencilFront: { |
| compare: 'greater-equal', |
| failOp: 'increment-clamp', |
| depthFailOp: 'increment-clamp', |
| }, |
| stencilBack: { |
| compare: 'not-equal', |
| depthFailOp: 'keep', |
| }, |
| stencilReadMask: 1637, |
| depthBiasSlopeScale: 72, |
| depthBiasClamp: 94, |
| }, |
| vertex: { |
| module: shaderModule11, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 12736, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'snorm8x2', |
| offset: 10904, |
| shaderLocation: 2, |
| }, { |
| format: 'unorm8x4', |
| offset: 9796, |
| shaderLocation: 7, |
| }, { |
| format: 'uint8x4', |
| offset: 9652, |
| shaderLocation: 12, |
| }, { |
| format: 'uint32x3', |
| offset: 1288, |
| shaderLocation: 4, |
| }, { |
| format: 'snorm8x2', |
| offset: 11102, |
| shaderLocation: 15, |
| }, { |
| format: 'sint16x2', |
| offset: 10776, |
| shaderLocation: 5, |
| }, { |
| format: 'sint16x4', |
| offset: 1036, |
| shaderLocation: 11, |
| }, { |
| format: 'uint8x4', |
| offset: 12112, |
| shaderLocation: 9, |
| }, { |
| format: 'sint32x4', |
| offset: 3272, |
| shaderLocation: 1, |
| }, { |
| format: 'unorm10-10-10-2', |
| offset: 6256, |
| shaderLocation: 10, |
| }, { |
| format: 'sint32', |
| offset: 6940, |
| shaderLocation: 8, |
| }], |
| } |
| ] |
| }, |
| }); |
| let promise44 = adapter8.requestAdapterInfo(); |
| let sampler67 = device5.createSampler({ |
| label: '\u3756\u1c14\u092e\uec1c', |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| lodMinClamp: 68.196, |
| lodMaxClamp: 71.694, |
| }); |
| try { |
| renderBundleEncoder65.setBindGroup(1, bindGroup19); |
| } catch {} |
| try { |
| device5.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: video7, |
| origin: { x: 10, y: 4 }, |
| flipY: false, |
| }, { |
| texture: texture87, |
| mipLevel: 0, |
| origin: { x: 0, y: 0, z: 0 }, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let offscreenCanvas26 = new OffscreenCanvas(706, 510); |
| try { |
| renderBundleEncoder38.drawIndexedIndirect(buffer3, 43872); |
| } catch {} |
| try { |
| renderBundleEncoder38.drawIndirect(buffer3, 25984); |
| } catch {} |
| try { |
| gpuCanvasContext3.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer23, 36644, new DataView(new ArrayBuffer(14897)), 1454, 8100); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let videoFrame20 = new VideoFrame(videoFrame1, {timestamp: 0}); |
| try { |
| await promise38; |
| } catch {} |
| video10.height = 139; |
| let commandEncoder66 = device7.createCommandEncoder({label: '\uc083\u5d91\uf5e3\u08dd\uf9dd'}); |
| try { |
| gpuCanvasContext7.unconfigure(); |
| } catch {} |
| try { |
| await promise44; |
| } catch {} |
| document.body.prepend(video1); |
| video10.height = 50; |
| let offscreenCanvas27 = new OffscreenCanvas(653, 301); |
| let offscreenCanvas28 = new OffscreenCanvas(830, 934); |
| try { |
| await promise43; |
| } catch {} |
| let bindGroup29 = device5.createBindGroup({ |
| label: '\u0463\u0488\u0371\ua22d\ucc33\u{1f9b8}\u7dab\u{1fa5d}\u4487', |
| layout: bindGroupLayout24, |
| entries: [], |
| }); |
| let querySet49 = device5.createQuerySet({ |
| type: 'occlusion', |
| count: 3037, |
| }); |
| let renderBundleEncoder69 = device5.createRenderBundleEncoder({ |
| label: '\u0d80\ubec1\ua148\u03b1\u06dc\u{1fd01}', |
| colorFormats: ['bgra8unorm', 'rg32sint', 'rgb10a2uint', 'rg16sint', 'r16float'], |
| stencilReadOnly: false |
| }); |
| try { |
| renderBundleEncoder69.setBindGroup(0, bindGroup23); |
| } catch {} |
| try { |
| gpuCanvasContext15.configure({ |
| device: device5, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: ['rgba16float', 'rgba16float', 'astc-4x4-unorm'], |
| colorSpace: 'srgb', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| video8.height = 76; |
| let renderBundleEncoder70 = device6.createRenderBundleEncoder({ |
| label: '\u2b7b\u5941\u599a', |
| colorFormats: ['rg16uint', 'rgba8sint', 'rgb10a2uint', 'rg8sint', 'rgba32sint'], |
| depthReadOnly: true, |
| stencilReadOnly: true |
| }); |
| try { |
| buffer25.unmap(); |
| } catch {} |
| try { |
| commandEncoder61.clearBuffer(buffer30, 572, 4); |
| dissociateBuffer(device6, buffer30); |
| } catch {} |
| let gpuCanvasContext24 = offscreenCanvas28.getContext('webgpu'); |
| let shaderModule12 = device0.createShaderModule({ |
| label: '\u{1fc71}\u44d0\u951b\u06c7\ua4f7', |
| code: `@group(0) @binding(1160) |
| var<storage, read_write> field8: array<u32>; |
| |
| @compute @workgroup_size(2, 2, 1) |
| fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {} |
| |
| struct S12 { |
| @location(28) f0: f16 |
| } |
| struct FragmentOutput0 { |
| @location(5) f0: vec4<i32>, |
| @location(1) f1: vec4<i32>, |
| @location(4) f2: vec4<u32>, |
| @location(2) f3: vec2<i32>, |
| @location(3) f4: vec4<f32>, |
| @location(0) f5: vec2<i32> |
| } |
| |
| @fragment |
| fn fragment0(@builtin(front_facing) a0: bool, @location(71) a1: u32, @location(106) a2: vec2<u32>, @location(110) a3: vec2<f32>, @builtin(position) a4: vec4<f32>, @location(37) a5: vec2<f32>, @location(42) a6: vec2<i32>, @location(33) a7: vec3<f32>, @location(93) a8: vec3<f32>, @location(102) a9: vec3<i32>, @location(29) a10: vec2<i32>, @builtin(sample_index) a11: u32, @location(77) a12: u32, @location(39) a13: vec2<u32>, @location(101) a14: vec3<f32>, @location(48) a15: vec3<u32>, @location(50) a16: vec4<f32>, @location(10) a17: f16, @location(84) a18: f32, @location(66) a19: vec3<u32>, @location(100) a20: vec3<f32>, @location(109) a21: vec2<f32>, a22: S12, @builtin(sample_mask) a23: u32, @location(85) a24: vec2<i32>, @location(91) a25: vec2<f32>, @location(55) a26: vec2<u32>, @location(103) a27: vec3<u32>, @location(18) a28: vec4<u32>, @location(58) a29: f32, @location(87) a30: vec2<f32>, @location(89) a31: f16) -> FragmentOutput0 { |
| return FragmentOutput0(); |
| } |
| |
| struct S11 { |
| @location(12) f0: vec3<i32>, |
| @location(3) f1: vec3<f32>, |
| @location(5) f2: vec3<i32>, |
| @location(9) f3: vec3<i32>, |
| @builtin(vertex_index) f4: u32, |
| @location(15) f5: vec4<i32>, |
| @location(6) f6: vec4<f16>, |
| @location(8) f7: vec3<f16>, |
| @location(0) f8: i32, |
| @location(10) f9: vec3<u32>, |
| @location(14) f10: vec2<u32>, |
| @location(2) f11: vec2<f32>, |
| @location(4) f12: vec2<i32>, |
| @location(1) f13: f16, |
| @location(11) f14: vec2<f16> |
| } |
| struct VertexOutput0 { |
| @location(103) f162: vec3<u32>, |
| @location(101) f163: vec3<f32>, |
| @location(29) f164: vec2<i32>, |
| @location(39) f165: vec2<u32>, |
| @location(93) f166: vec3<f32>, |
| @builtin(position) f167: vec4<f32>, |
| @location(37) f168: vec2<f32>, |
| @location(109) f169: vec2<f32>, |
| @location(48) f170: vec3<u32>, |
| @location(100) f171: vec3<f32>, |
| @location(85) f172: vec2<i32>, |
| @location(18) f173: vec4<u32>, |
| @location(42) f174: vec2<i32>, |
| @location(66) f175: vec3<u32>, |
| @location(84) f176: f32, |
| @location(55) f177: vec2<u32>, |
| @location(102) f178: vec3<i32>, |
| @location(3) f179: vec2<f32>, |
| @location(106) f180: vec2<u32>, |
| @location(110) f181: vec2<f32>, |
| @location(89) f182: f16, |
| @location(91) f183: vec2<f32>, |
| @location(33) f184: vec3<f32>, |
| @location(87) f185: vec2<f32>, |
| @location(58) f186: f32, |
| @location(71) f187: u32, |
| @location(28) f188: f16, |
| @location(77) f189: u32, |
| @location(10) f190: f16, |
| @location(50) f191: vec4<f32> |
| } |
| |
| @vertex |
| fn vertex0(@location(7) a0: vec2<f16>, @location(13) a1: vec2<f16>, a2: S11, @builtin(instance_index) a3: u32) -> VertexOutput0 { |
| return VertexOutput0(); |
| } |
| |
| `, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| try { |
| renderBundleEncoder38.draw(72, 64, 8, 0); |
| } catch {} |
| try { |
| renderBundleEncoder38.drawIndexedIndirect(buffer3, 19200); |
| } catch {} |
| try { |
| renderBundleEncoder38.drawIndirect(buffer3, 33500); |
| } catch {} |
| try { |
| commandEncoder65.resolveQuerySet(querySet13, 3097, 32, buffer24, 0); |
| } catch {} |
| let buffer32 = device0.createBuffer({ |
| label: '\u{1f868}\u7e37\u{1fbda}\ua21d\ubd7f\u04df\u{1fc1b}\u0f43\u{1fea6}\u0b69\u0ee9', |
| size: 2993, |
| usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX |
| }); |
| let textureView72 = texture23.createView({ |
| label: '\u0745\u63ba\ue5dd\u8387\u{1f9f8}\u638e\u0be9\ucdbe\u0883', |
| dimension: '2d-array', |
| arrayLayerCount: 1 |
| }); |
| let renderBundleEncoder71 = device0.createRenderBundleEncoder({ |
| label: '\u64e4\u0f03', |
| colorFormats: ['r16float', 'rgba32float', 'rgba32uint', 'rgba8unorm', undefined, 'rgba16float'], |
| sampleCount: 1, |
| stencilReadOnly: false |
| }); |
| try { |
| computePassEncoder33.setBindGroup(3, bindGroup4); |
| } catch {} |
| try { |
| computePassEncoder20.setBindGroup(1, bindGroup28, new Uint32Array(7181), 1126, 0); |
| } catch {} |
| try { |
| computePassEncoder20.setPipeline(pipeline43); |
| } catch {} |
| try { |
| renderBundleEncoder38.drawIndexed(8, 40, 48, 752, 64); |
| } catch {} |
| try { |
| renderBundleEncoder38.drawIndexedIndirect(buffer3, 31720); |
| } catch {} |
| try { |
| renderBundleEncoder61.setPipeline(pipeline5); |
| } catch {} |
| try { |
| commandEncoder65.copyTextureToTexture({ |
| texture: texture60, |
| mipLevel: 3, |
| origin: { x: 308, y: 0, z: 1 }, |
| aspect: 'all', |
| }, { |
| texture: texture26, |
| mipLevel: 0, |
| origin: { x: 736, y: 0, z: 0 }, |
| aspect: 'all', |
| }, {width: 427, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageBitmap5, |
| origin: { x: 306, y: 185 }, |
| flipY: true, |
| }, { |
| texture: texture59, |
| mipLevel: 0, |
| origin: { x: 1, y: 1, z: 0 }, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| let pipeline64 = await device0.createComputePipelineAsync({ |
| layout: pipelineLayout3, |
| compute: { |
| module: shaderModule5, |
| entryPoint: 'compute0', |
| constants: {}, |
| }, |
| }); |
| document.body.prepend(canvas4); |
| try { |
| gpuCanvasContext20.unconfigure(); |
| } catch {} |
| let device8 = await adapter10.requestDevice({ |
| label: '\ue87b\u024b\uda31', |
| requiredFeatures: [ |
| 'depth-clip-control', |
| 'depth32float-stencil8', |
| 'texture-compression-etc2', |
| 'texture-compression-astc', |
| 'shader-f16', |
| 'rg11b10ufloat-renderable', |
| 'bgra8unorm-storage' |
| ], |
| }); |
| let texture100 = device6.createTexture({ |
| label: '\u{1febf}\u8d6f\u4aec\u{1fb8e}\u5b1a', |
| size: {width: 230, height: 1, depthOrArrayLayers: 35}, |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rg11b10ufloat', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| try { |
| commandEncoder61.clearBuffer(buffer30, 60, 220); |
| dissociateBuffer(device6, buffer30); |
| } catch {} |
| try { |
| device6.queue.writeTexture({ |
| texture: texture86, |
| mipLevel: 0, |
| origin: { x: 837, y: 0, z: 1 }, |
| aspect: 'all', |
| }, new Uint8ClampedArray(arrayBuffer1), /* required buffer size: 570 */ |
| {offset: 570}, {width: 305, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let videoFrame21 = new VideoFrame(offscreenCanvas6, {timestamp: 0}); |
| let commandBuffer14 = commandEncoder59.finish({ |
| label: '\u273b\u096c\u7838\u0c42\u09e8\u{1f6fc}\u{1fbd8}\u8da1\u3046', |
| }); |
| let renderBundle74 = renderBundleEncoder63.finish({label: '\u316e\u39e1\u8e61\u{1fb8d}\u6ba6\u3ca9'}); |
| try { |
| renderBundleEncoder64.setVertexBuffer(78, undefined, 1825097912, 2152477113); |
| } catch {} |
| let querySet50 = device2.createQuerySet({ |
| label: '\ua6a4\u95d1\u92d7\u{1f6c3}', |
| type: 'occlusion', |
| count: 2735, |
| }); |
| let texture101 = gpuCanvasContext15.getCurrentTexture(); |
| let textureView73 = texture95.createView({label: '\uaa00\u55fd\u{1f85e}', baseMipLevel: 0, mipLevelCount: 8}); |
| try { |
| renderBundleEncoder59.draw(72, 64, 48, 80); |
| } catch {} |
| try { |
| renderBundleEncoder59.setPipeline(pipeline62); |
| } catch {} |
| try { |
| commandEncoder48.copyBufferToBuffer(buffer18, 25404, buffer19, 38628, 16); |
| dissociateBuffer(device2, buffer18); |
| dissociateBuffer(device2, buffer19); |
| } catch {} |
| try { |
| commandEncoder48.resolveQuerySet(querySet39, 111, 105, buffer19, 6912); |
| } catch {} |
| try { |
| commandEncoder48.insertDebugMarker('\u0b16'); |
| } catch {} |
| let canvas26 = document.createElement('canvas'); |
| try { |
| if (!arrayBuffer8.detached) { new Uint8Array(arrayBuffer8).fill(0x55) }; |
| } catch {} |
| try { |
| device3.label = '\u881b\u{1fc19}\u9817\u653a'; |
| } catch {} |
| let gpuCanvasContext25 = offscreenCanvas27.getContext('webgpu'); |
| pseudoSubmit(device5, commandEncoder51); |
| let texture102 = device5.createTexture({ |
| size: {width: 1410, height: 1, depthOrArrayLayers: 256}, |
| mipLevelCount: 10, |
| format: 'depth32float-stencil8', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['depth32float-stencil8'], |
| }); |
| let computePassEncoder49 = commandEncoder63.beginComputePass({label: '\u0d00\u{1feaf}\u0571\ua8b0\u6b0b\u5817\u779e'}); |
| try { |
| renderBundleEncoder55.setBindGroup(5, bindGroup23); |
| } catch {} |
| let gpuCanvasContext26 = offscreenCanvas26.getContext('webgpu'); |
| let buffer33 = device7.createBuffer({ |
| label: '\u0b49\u085a\u1d03\u02a0\u05b2\u3d09', |
| size: 10874, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ |
| }); |
| let commandEncoder67 = device7.createCommandEncoder({label: '\uef53\ud8b7\u06f6\u44e8\u0c1d\u9b41\u0c9b\uf66a\u0288'}); |
| let promise45 = buffer33.mapAsync(GPUMapMode.READ, 10640, 196); |
| try { |
| commandEncoder66.resolveQuerySet(querySet48, 966, 268, buffer26, 8448); |
| } catch {} |
| let commandEncoder68 = device5.createCommandEncoder({}); |
| let textureView74 = texture90.createView({ |
| label: '\u0666\uffd1\u{1f7cc}\u{1f969}\u0b58', |
| aspect: 'depth-only', |
| baseMipLevel: 7, |
| baseArrayLayer: 35, |
| arrayLayerCount: 3 |
| }); |
| let computePassEncoder50 = commandEncoder53.beginComputePass(); |
| try { |
| renderBundleEncoder55.setBindGroup(1, bindGroup26, new Uint32Array(5103), 3355, 0); |
| } catch {} |
| let arrayBuffer9 = buffer28.getMappedRange(22152, 5608); |
| try { |
| commandEncoder68.copyTextureToTexture({ |
| texture: texture84, |
| mipLevel: 4, |
| origin: { x: 43, y: 0, z: 0 }, |
| aspect: 'all', |
| }, { |
| texture: texture84, |
| mipLevel: 7, |
| origin: { x: 2, y: 0, z: 0 }, |
| aspect: 'all', |
| }, {width: 0, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| let textureView75 = texture34.createView({label: '\u{1f69c}\u0d8d', mipLevelCount: 1, baseArrayLayer: 59, arrayLayerCount: 67}); |
| try { |
| commandEncoder32.copyBufferToBuffer(buffer11, 4292, buffer9, 12196, 296); |
| dissociateBuffer(device1, buffer11); |
| dissociateBuffer(device1, buffer9); |
| } catch {} |
| try { |
| await promise45; |
| } catch {} |
| try { |
| canvas26.getContext('webgl2'); |
| } catch {} |
| let querySet51 = device0.createQuerySet({ |
| label: '\u{1fcab}\u{1f879}\u03de\ufed3\u0d0c\uf5f2\u0af1', |
| type: 'occlusion', |
| count: 2954, |
| }); |
| let sampler68 = device0.createSampler({ |
| label: '\u09e5\u04fc\ud673\uce86', |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 15.293, |
| lodMaxClamp: 84.635, |
| maxAnisotropy: 19, |
| }); |
| try { |
| renderBundleEncoder61.drawIndexed(56, 40, 48, 40, 8); |
| } catch {} |
| try { |
| renderBundleEncoder40.setVertexBuffer(1, buffer1, 17820, 171); |
| } catch {} |
| try { |
| commandEncoder65.copyBufferToBuffer(buffer16, 888, buffer12, 15856, 1796); |
| dissociateBuffer(device0, buffer16); |
| dissociateBuffer(device0, buffer12); |
| } catch {} |
| try { |
| commandEncoder65.resolveQuerySet(querySet6, 2113, 333, buffer12, 4608); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer12, 35060, new Float32Array(50280), 49822, 188); |
| } catch {} |
| let texture103 = device5.createTexture({ |
| label: '\u5bbc\u{1feb9}\uaa98\u0357\u0204\u{1fafc}\ud383\u06f9\ue2e5\u{1f87d}\u047f', |
| size: {width: 120, height: 128, depthOrArrayLayers: 122}, |
| mipLevelCount: 5, |
| dimension: '3d', |
| format: 'r16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| viewFormats: ['r16float', 'r16float'], |
| }); |
| let computePassEncoder51 = commandEncoder68.beginComputePass({label: '\ufc53\u{1fb70}\ua70a'}); |
| let arrayBuffer10 = buffer28.getMappedRange(34688, 284); |
| try { |
| device5.destroy(); |
| } catch {} |
| let video23 = await videoWithData(); |
| let commandEncoder69 = device3.createCommandEncoder({label: '\u{1f7dd}\ufcbd\u0841'}); |
| let commandBuffer15 = commandEncoder69.finish({ |
| label: '\uf74b\ue5f7\u0a38\u0b28\uc884\u49f6\u78d5', |
| }); |
| let textureView76 = texture52.createView({ |
| label: '\u{1fcb1}\u05b1\u989e\u2ad8\u10d1\ub827\u01d2\u2059', |
| baseMipLevel: 2, |
| mipLevelCount: 2, |
| baseArrayLayer: 17, |
| arrayLayerCount: 14 |
| }); |
| let sampler69 = device3.createSampler({ |
| label: '\u{1faa4}\u1bdf', |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'clamp-to-edge', |
| minFilter: 'nearest', |
| lodMaxClamp: 97.454, |
| }); |
| try { |
| computePassEncoder21.setBindGroup(3, bindGroup16); |
| } catch {} |
| try { |
| if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(0x55) }; |
| } catch {} |
| let canvas27 = document.createElement('canvas'); |
| let videoFrame22 = new VideoFrame(img17, {timestamp: 0}); |
| let texture104 = device8.createTexture({ |
| label: '\u050e\u{1fb53}', |
| size: [110, 230, 210], |
| mipLevelCount: 2, |
| format: 'astc-10x10-unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let pipelineLayout17 = device0.createPipelineLayout({label: '\ue73b\u061d\u7d72\u7a42\u1e3e', bindGroupLayouts: [bindGroupLayout2]}); |
| try { |
| renderBundleEncoder61.drawIndexedIndirect(buffer3, 13972); |
| } catch {} |
| let arrayBuffer11 = buffer27.getMappedRange(8424, 9068); |
| try { |
| commandEncoder65.copyBufferToTexture({ |
| /* bytesInLastRow: 96 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 12272 */ |
| offset: 12272, |
| buffer: buffer1, |
| }, { |
| texture: texture40, |
| mipLevel: 0, |
| origin: { x: 0, y: 72, z: 0 }, |
| aspect: 'all', |
| }, {width: 72, height: 0, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer1); |
| } catch {} |
| try { |
| commandEncoder65.clearBuffer(buffer24, 264, 8); |
| dissociateBuffer(device0, buffer24); |
| } catch {} |
| try { |
| renderBundleEncoder40.popDebugGroup(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 588, height: 1, depthOrArrayLayers: 235} |
| */ |
| { |
| source: img4, |
| origin: { x: 4, y: 167 }, |
| flipY: true, |
| }, { |
| texture: texture45, |
| mipLevel: 0, |
| origin: { x: 328, y: 0, z: 182 }, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 154, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| let imageData27 = new ImageData(100, 232); |
| let textureView77 = texture100.createView({label: '\u0fb3\u8747\uce8b\u{1f9c2}\u7c3a', aspect: 'all', mipLevelCount: 1, baseArrayLayer: 0}); |
| let computePassEncoder52 = commandEncoder61.beginComputePass({label: '\u9f6e\u635b\u08de\u{1f8ec}\u6f1f\uae20\u9cad'}); |
| let sampler70 = device6.createSampler({ |
| label: '\u017e\ud1f0\uef6b\u0e7d\ue799\u03e0\uf020\u0d12\u0ff3\u{1fa4a}\u{1fce9}', |
| addressModeV: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 19.636, |
| lodMaxClamp: 57.288, |
| }); |
| try { |
| renderBundleEncoder70.setVertexBuffer(0, buffer30, 516, 89); |
| } catch {} |
| try { |
| device6.queue.writeBuffer(buffer30, 432, new Int16Array(33539), 1348, 24); |
| } catch {} |
| let querySet52 = device0.createQuerySet({ |
| label: '\ufdd3\ue191\u4a5e\uc2db\u{1fec2}', |
| type: 'occlusion', |
| count: 2111, |
| }); |
| let renderBundle75 = renderBundleEncoder13.finish({label: '\u{1f9a8}\u1ab3\u03fd\u{1fa85}\u89b7\u{1fc3c}\u{1fea0}'}); |
| try { |
| renderBundleEncoder61.drawIndirect(buffer3, 26900); |
| } catch {} |
| let imageBitmap18 = await createImageBitmap(imageData15); |
| let querySet53 = device8.createQuerySet({ |
| label: '\u7dac\u40cb\u0006\u{1f9b5}\u{1fc76}\u251c\u{1ff2d}', |
| type: 'occlusion', |
| count: 3623, |
| }); |
| let renderBundleEncoder72 = device8.createRenderBundleEncoder({ |
| label: '\u{1f6eb}\u0900\u6520\u95c9\ub550\u4c3c\uaa07\u28d6\ua32d\u64d8\u{1fd97}', |
| colorFormats: ['rg8sint', 'bgra8unorm-srgb', 'r16sint', 'r8uint', 'rgb10a2unorm', 'rg32uint'], |
| depthReadOnly: true |
| }); |
| try { |
| renderBundleEncoder72.setVertexBuffer(99, undefined, 2175118546, 576717748); |
| } catch {} |
| try { |
| gpuCanvasContext22.configure({ |
| device: device8, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['eac-r11unorm', 'rgba8unorm-srgb'], |
| colorSpace: 'display-p3', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let promise46 = device8.queue.onSubmittedWorkDone(); |
| let gpuCanvasContext27 = canvas27.getContext('webgpu'); |
| try { |
| await promise46; |
| } catch {} |
| let bindGroupLayout38 = device8.createBindGroupLayout({ |
| label: '\u64bb\u{1fe79}\u{1fdfd}\uc8ed\u0d4a\u{1f8a3}\u02dd\u09d6\u{1faae}\u058d\u{1ff28}', |
| entries: [{ |
| binding: 442, |
| visibility: GPUShaderStage.COMPUTE, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, { |
| binding: 232, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', minBindingSize: 0, hasDynamicOffset: true }, |
| }], |
| }); |
| try { |
| device8.queue.writeTexture({ |
| texture: texture104, |
| mipLevel: 0, |
| origin: { x: 50, y: 40, z: 122 }, |
| aspect: 'all', |
| }, new Uint8Array(arrayBuffer5), /* required buffer size: 44441 */ |
| {offset: 313, bytesPerRow: 232, rowsPerImage: 22}, {width: 30, height: 150, depthOrArrayLayers: 9}); |
| } catch {} |
| let querySet54 = device2.createQuerySet({ |
| label: '\u01a1\u5a11\ufdbd', |
| type: 'occlusion', |
| count: 2501, |
| }); |
| let commandBuffer16 = commandEncoder49.finish({ |
| label: '\u0259\u0931\u6e3c\u0dbf\u00ce', |
| }); |
| let texture105 = device2.createTexture({ |
| size: {width: 1520, height: 1, depthOrArrayLayers: 118}, |
| mipLevelCount: 11, |
| dimension: '3d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let computePassEncoder53 = commandEncoder56.beginComputePass({label: '\u0ab0\u{1f913}\u{1f7c6}\u{1ffc1}\u04c8\u02bc\u{1ff1f}\ub040\u941c\ubdd5'}); |
| let renderBundleEncoder73 = device2.createRenderBundleEncoder({ |
| label: '\u{1fdbe}\u686e\u5cdc', |
| colorFormats: [], |
| depthStencilFormat: 'depth24plus-stencil8', |
| sampleCount: 4, |
| stencilReadOnly: true |
| }); |
| try { |
| renderBundleEncoder59.draw(40, 40, 0, 32); |
| } catch {} |
| try { |
| renderBundleEncoder59.drawIndexed(48); |
| } catch {} |
| try { |
| commandEncoder48.resolveQuerySet(querySet50, 1482, 1193, buffer19, 41984); |
| } catch {} |
| try { |
| device2.queue.writeTexture({ |
| texture: texture77, |
| mipLevel: 2, |
| origin: { x: 4, y: 0, z: 15 }, |
| aspect: 'all', |
| }, arrayBuffer3, /* required buffer size: 2415357 */ |
| {offset: 841, bytesPerRow: 656, rowsPerImage: 184}, {width: 109, height: 1, depthOrArrayLayers: 21}); |
| } catch {} |
| let textureView78 = texture85.createView({dimension: '2d-array', mipLevelCount: 1}); |
| let renderBundleEncoder74 = device6.createRenderBundleEncoder({ |
| label: '\u{1fd6e}\ua9f7\u152e\u48ae\u973a\u056d\u{1f828}\u{1f83e}', |
| colorFormats: ['rg16uint', 'rgba8sint', 'rgb10a2uint', 'rg8sint', 'rgba32sint'], |
| sampleCount: 1, |
| depthReadOnly: true, |
| stencilReadOnly: true |
| }); |
| try { |
| renderBundleEncoder66.setVertexBuffer(5, buffer30, 348, 176); |
| } catch {} |
| try { |
| gpuCanvasContext12.configure({ |
| device: device6, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['r8unorm', 'r16uint', 'rg16float'], |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let renderBundleEncoder75 = device0.createRenderBundleEncoder({ |
| label: '\u0e17\u0703', |
| colorFormats: ['r8uint', undefined, 'rg16sint', 'r8uint', 'rg8sint', 'rgba8unorm', 'r8sint', 'r16sint'], |
| depthStencilFormat: 'depth32float-stencil8', |
| sampleCount: 4, |
| depthReadOnly: true, |
| stencilReadOnly: true |
| }); |
| let renderBundle76 = renderBundleEncoder3.finish({label: '\u0853\u53ce\u{1f984}'}); |
| try { |
| renderBundleEncoder61.draw(72); |
| } catch {} |
| try { |
| renderBundleEncoder38.drawIndexed(0, 80); |
| } catch {} |
| document.body.prepend(img13); |
| let pipelineLayout18 = device7.createPipelineLayout({ |
| label: '\u05ad\u452e\u{1ff27}\u{1f627}\ud1fa\u3eb9', |
| bindGroupLayouts: [bindGroupLayout37, bindGroupLayout37] |
| }); |
| try { |
| commandEncoder67.resolveQuerySet(querySet47, 79, 217, buffer26, 9984); |
| } catch {} |
| let querySet55 = device6.createQuerySet({ |
| label: '\ued1a\u27c3\u072f', |
| type: 'occlusion', |
| count: 2105, |
| }); |
| try { |
| renderBundleEncoder74.setVertexBuffer(2, buffer30, 452, 108); |
| } catch {} |
| gc(); |
| let img20 = await imageWithData(190, 17, '#0e3aa195', '#10e55785'); |
| let imageData28 = new ImageData(88, 256); |
| let computePassEncoder54 = commandEncoder65.beginComputePass(); |
| let renderBundle77 = renderBundleEncoder68.finish({}); |
| try { |
| computePassEncoder54.setBindGroup(3, bindGroup2, new Uint32Array(9402), 1612, 0); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; }); |
| } catch {} |
| let pipeline65 = await device0.createRenderPipelineAsync({ |
| label: '\u03e8\u0a44', |
| layout: pipelineLayout2, |
| fragment: { |
| module: shaderModule4, |
| entryPoint: 'fragment0', |
| targets: [{format: 'r16float', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE}, {format: 'rgba32float', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED}, {format: 'rgba32uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA}, {format: 'rgba8unorm', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN}, undefined, {format: 'rgba16float', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED}] |
| }, |
| depthStencil: { |
| format: 'depth24plus-stencil8', |
| depthWriteEnabled: false, |
| depthCompare: 'less', |
| stencilFront: { |
| compare: 'less', |
| failOp: 'increment-wrap', |
| depthFailOp: 'invert', |
| passOp: 'increment-clamp', |
| }, |
| stencilBack: { |
| compare: 'less-equal', |
| failOp: 'zero', |
| passOp: 'decrement-clamp', |
| }, |
| stencilWriteMask: 467, |
| depthBias: 60, |
| depthBiasSlopeScale: 3, |
| depthBiasClamp: 59, |
| }, |
| vertex: { |
| module: shaderModule4, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 7188, |
| attributes: [{ |
| format: 'snorm16x4', |
| offset: 5320, |
| shaderLocation: 11, |
| }, { |
| format: 'float32x4', |
| offset: 5440, |
| shaderLocation: 7, |
| }, { |
| format: 'uint16x4', |
| offset: 1656, |
| shaderLocation: 8, |
| }, { |
| format: 'uint32', |
| offset: 3180, |
| shaderLocation: 13, |
| }, { |
| format: 'snorm8x2', |
| offset: 3696, |
| shaderLocation: 12, |
| }, { |
| format: 'uint8x4', |
| offset: 632, |
| shaderLocation: 0, |
| }, { |
| format: 'sint32x4', |
| offset: 608, |
| shaderLocation: 14, |
| }, { |
| format: 'uint32x4', |
| offset: 4756, |
| shaderLocation: 2, |
| }], |
| }, |
| { |
| arrayStride: 2132, |
| stepMode: 'instance', |
| attributes: [], |
| }, |
| { |
| arrayStride: 12944, |
| stepMode: 'vertex', |
| attributes: [], |
| }, |
| { |
| arrayStride: 11632, |
| stepMode: 'instance', |
| attributes: [], |
| }, |
| { |
| arrayStride: 656, |
| attributes: [], |
| }, |
| { |
| arrayStride: 14348, |
| stepMode: 'vertex', |
| attributes: [], |
| }, |
| { |
| arrayStride: 12584, |
| stepMode: 'vertex', |
| attributes: [], |
| }, |
| { |
| arrayStride: 13812, |
| attributes: [{ |
| format: 'snorm8x2', |
| offset: 2100, |
| shaderLocation: 5, |
| }], |
| } |
| ] |
| }, |
| primitive: { |
| topology: 'line-list', |
| frontFace: 'cw', |
| cullMode: 'front', |
| unclippedDepth: true, |
| }, |
| }); |
| try { |
| if (!arrayBuffer9.detached) { new Uint8Array(arrayBuffer9).fill(0x55) }; |
| } catch {} |
| video3.height = 127; |
| offscreenCanvas15.height = 276; |
| let texture106 = device6.createTexture({ |
| label: '\u4550\uc3c7\u{1fe9c}\u6ca2\u{1fda6}\ubf85', |
| size: {width: 1455, height: 1, depthOrArrayLayers: 37}, |
| mipLevelCount: 10, |
| dimension: '3d', |
| format: 'rg16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let renderBundleEncoder76 = device6.createRenderBundleEncoder({ |
| label: '\u{1f6e7}\u{1f9af}\u01a4\uf607\u78f1\uaa07\ua907\u06a7', |
| colorFormats: ['rg16uint', 'rgba8sint', 'rgb10a2uint', 'rg8sint', 'rgba32sint'], |
| depthReadOnly: true, |
| stencilReadOnly: true |
| }); |
| let renderBundle78 = renderBundleEncoder67.finish({label: '\u{1fe55}\u{1f700}\u{1f98b}\u{1f732}\u{1fdc5}\u{1ffb7}\uaa99\uaab0\u55f4\u5bbf'}); |
| try { |
| await adapter2.requestAdapterInfo(); |
| } catch {} |
| let texture107 = device2.createTexture({ |
| label: '\u07da\u37ca\u8b5f\u37be\ud3ce\u63f1\uc2bb\u13d2\ueccf', |
| size: {width: 3040, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 8, |
| format: 'rgba8snorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let textureView79 = texture48.createView({baseMipLevel: 2, mipLevelCount: 6}); |
| let computePassEncoder55 = commandEncoder48.beginComputePass({}); |
| let renderBundleEncoder77 = device2.createRenderBundleEncoder({ |
| label: '\u0225\u{1f89c}\u02e4\uf836\ubae4\u599f\ud9bc\u{1fd0d}\u0d8d\u{1fa59}\uf128', |
| colorFormats: [], |
| depthStencilFormat: 'depth24plus-stencil8', |
| sampleCount: 4, |
| depthReadOnly: true, |
| stencilReadOnly: true |
| }); |
| try { |
| commandEncoder64.resolveQuerySet(querySet50, 773, 1667, buffer19, 3072); |
| } catch {} |
| let pipeline66 = device2.createComputePipeline({ |
| label: '\ub9f6\u{1fa91}\uc73b\u2d98\ua58a\u{1f84c}\u8601\u{1fb91}', |
| layout: pipelineLayout11, |
| compute: { |
| module: shaderModule8, |
| entryPoint: 'compute0', |
| constants: {}, |
| }, |
| }); |
| gc(); |
| let canvas28 = document.createElement('canvas'); |
| let imageBitmap19 = await createImageBitmap(videoFrame0); |
| let buffer34 = device6.createBuffer({ |
| label: '\ua2ae\u{1fc35}\u2925\u{1fdb7}', |
| size: 29433, |
| usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE |
| }); |
| let texture108 = device6.createTexture({ |
| label: '\u3de5\u{1ff92}\u090c\u3627\u1ea4\u197c\u01be\u0102', |
| size: [790, 1, 75], |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['r8sint', 'r8sint'], |
| }); |
| let promise47 = device6.popErrorScope(); |
| try { |
| device6.addEventListener('uncapturederror', e => { log('device6.uncapturederror'); log(e); e.label = device6.label; }); |
| } catch {} |
| try { |
| if (!arrayBuffer11.detached) { new Uint8Array(arrayBuffer11).fill(0x55) }; |
| } catch {} |
| try { |
| await promise47; |
| } catch {} |
| let querySet56 = device6.createQuerySet({ |
| type: 'occlusion', |
| count: 2110, |
| }); |
| let textureView80 = texture100.createView({label: '\u7e71\u2701\u{1f898}\uc456\u0f03\u0ff6', mipLevelCount: 1}); |
| try { |
| renderBundleEncoder76.setVertexBuffer(50, undefined, 2913971006, 922986669); |
| } catch {} |
| let img21 = await imageWithData(109, 143, '#a36aa600', '#e75f0297'); |
| let video24 = await videoWithData(); |
| let querySet57 = device6.createQuerySet({ |
| label: '\u1516\u57b5\u{1fbf8}\ub26f', |
| type: 'occlusion', |
| count: 3281, |
| }); |
| let sampler71 = device6.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMaxClamp: 89.795, |
| }); |
| try { |
| await buffer31.mapAsync(GPUMapMode.WRITE, 0, 23384); |
| } catch {} |
| let promise48 = device6.queue.onSubmittedWorkDone(); |
| let img22 = await imageWithData(152, 181, '#ec2ea400', '#36419cda'); |
| let commandEncoder70 = device7.createCommandEncoder({label: '\ua126\u0eac\u6580\uaa33\u{1f6ee}\ub7ca\u0794\u9062\u8767\u{1fdcf}'}); |
| let querySet58 = device7.createQuerySet({ |
| label: '\u{1f69d}\u{1f80d}\u9b80\u0596\u060e\u{1fb16}\u30db\u0756\uc700\u70c8', |
| type: 'occlusion', |
| count: 1762, |
| }); |
| let sampler72 = device7.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| lodMinClamp: 58.358, |
| lodMaxClamp: 62.559, |
| compare: 'greater-equal', |
| }); |
| try { |
| commandEncoder66.clearBuffer(buffer33, 6272, 4592); |
| dissociateBuffer(device7, buffer33); |
| } catch {} |
| let querySet59 = device2.createQuerySet({ |
| type: 'occlusion', |
| count: 2311, |
| }); |
| let textureView81 = texture95.createView({label: '\u19f0\u3db3\uaf8e\u{1feae}\u60ce\u0cbe', baseMipLevel: 6, mipLevelCount: 1}); |
| let computePassEncoder56 = commandEncoder64.beginComputePass({label: '\u088e\u7f02\ufbba\u003f\u{1ffb1}\u0d50\u2e11\u5150\u7f98\u129e\u07fb'}); |
| let renderBundle79 = renderBundleEncoder59.finish({label: '\uaa01\u7c1f\u54ba\uf1b2\u3018\u2da9\uefff\u{1ff80}\u087c\u{1f798}\u{1f89f}'}); |
| try { |
| renderBundleEncoder73.setBindGroup(6, bindGroup25, new Uint32Array(3493), 880, 0); |
| } catch {} |
| try { |
| gpuCanvasContext3.unconfigure(); |
| } catch {} |
| let offscreenCanvas29 = new OffscreenCanvas(1, 557); |
| let promise49 = adapter3.requestAdapterInfo(); |
| let texture109 = device8.createTexture({ |
| label: '\uf105\u41c4\u{1f970}\u{1f9ae}\ue2ea\u66a6\u0b1d\u{1f74f}\ua07b', |
| size: {width: 48, height: 640, depthOrArrayLayers: 1}, |
| mipLevelCount: 10, |
| dimension: '2d', |
| format: 'etc2-rgba8unorm-srgb', |
| usage: 0, |
| viewFormats: ['etc2-rgba8unorm-srgb', 'etc2-rgba8unorm', 'etc2-rgba8unorm-srgb'], |
| }); |
| let textureView82 = texture109.createView({mipLevelCount: 9}); |
| try { |
| texture109.destroy(); |
| } catch {} |
| try { |
| device8.queue.writeTexture({ |
| texture: texture104, |
| mipLevel: 0, |
| origin: { x: 10, y: 140, z: 31 }, |
| aspect: 'all', |
| }, new Int8Array(new ArrayBuffer(80)), /* required buffer size: 3222 */ |
| {offset: 962, bytesPerRow: 358}, {width: 70, height: 70, depthOrArrayLayers: 1}); |
| } catch {} |
| let textureView83 = texture93.createView({label: '\u0f43\u0a6f\u{1fc79}\uf109\uef16\u1af6\u152b\u{1fbd5}\u2600\ue51e\u{1f9c8}'}); |
| try { |
| if (!arrayBuffer7.detached) { new Uint8Array(arrayBuffer7).fill(0x55) }; |
| } catch {} |
| offscreenCanvas21.height = 214; |
| let canvas29 = document.createElement('canvas'); |
| let bindGroupLayout39 = device7.createBindGroupLayout({ |
| label: '\ue4c0\u704a\u083a\u8039', |
| entries: [{ |
| binding: 1190, |
| visibility: 0, |
| sampler: { type: 'filtering' }, |
| }, { |
| binding: 146, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rgba32float', access: 'read-only', viewDimension: '3d' }, |
| }], |
| }); |
| let externalTexture4 = device7.importExternalTexture({ |
| source: videoFrame14, |
| colorSpace: 'display-p3', |
| }); |
| try { |
| renderBundleEncoder64.setVertexBuffer(7, undefined, 2360499197, 274000500); |
| } catch {} |
| try { |
| device7.queue.writeTexture({ |
| texture: texture96, |
| mipLevel: 4, |
| origin: { x: 0, y: 0, z: 147 }, |
| aspect: 'stencil-only', |
| }, new BigUint64Array(arrayBuffer1), /* required buffer size: 1179243 */ |
| {offset: 170, bytesPerRow: 173, rowsPerImage: 235}, {width: 78, height: 1, depthOrArrayLayers: 30}); |
| } catch {} |
| try { |
| adapter1.label = '\uf993\uaec8\u005b\u02e9\u05ef\ub12b\u{1fac6}\u08a7'; |
| } catch {} |
| let renderBundleEncoder78 = device6.createRenderBundleEncoder({colorFormats: ['rg16uint', 'rgba8sint', 'rgb10a2uint', 'rg8sint', 'rgba32sint'], stencilReadOnly: true}); |
| try { |
| renderBundleEncoder76.setVertexBuffer(5, buffer30, 396); |
| } catch {} |
| offscreenCanvas12.height = 746; |
| try { |
| renderBundleEncoder61.drawIndexed(24, 48, 32, 112, 40); |
| } catch {} |
| try { |
| renderBundleEncoder61.drawIndexedIndirect(buffer3, 30436); |
| } catch {} |
| try { |
| renderBundleEncoder38.setVertexBuffer(7, buffer1); |
| } catch {} |
| try { |
| buffer1.unmap(); |
| } catch {} |
| let pipeline67 = await device0.createComputePipelineAsync({ |
| layout: pipelineLayout3, |
| compute: { |
| module: shaderModule12, |
| entryPoint: 'compute0', |
| constants: {}, |
| }, |
| }); |
| let renderBundleEncoder79 = device8.createRenderBundleEncoder({ |
| label: '\u{1fd18}\u{1f8fe}\u0363\u{1fce5}\u0c7e', |
| colorFormats: ['rg8sint', 'bgra8unorm-srgb', 'r16sint', 'r8uint', 'rgb10a2unorm', 'rg32uint'], |
| depthReadOnly: true |
| }); |
| try { |
| gpuCanvasContext19.configure({ |
| device: device8, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['etc2-rgb8unorm', 'rgba16float', 'rgba16float'], |
| colorSpace: 'display-p3', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device8.queue.writeTexture({ |
| texture: texture104, |
| mipLevel: 1, |
| origin: { x: 30, y: 10, z: 92 }, |
| aspect: 'all', |
| }, new ArrayBuffer(56), /* required buffer size: 126115 */ |
| {offset: 517, bytesPerRow: 310, rowsPerImage: 66}, {width: 30, height: 100, depthOrArrayLayers: 7}); |
| } catch {} |
| try { |
| gpuCanvasContext13.unconfigure(); |
| } catch {} |
| video23.width = 184; |
| let shaderModule13 = device4.createShaderModule({ |
| code: `@group(2) @binding(366) |
| var<storage, read_write> i12: array<u32>; |
| @group(2) @binding(879) |
| var<storage, read_write> parameter9: array<u32>; |
| @group(0) @binding(366) |
| var<storage, read_write> function10: array<u32>; |
| @group(1) @binding(754) |
| var<storage, read_write> i13: array<u32>; |
| @group(2) @binding(754) |
| var<storage, read_write> function11: array<u32>; |
| @group(3) @binding(879) |
| var<storage, read_write> parameter10: array<u32>; |
| @group(3) @binding(366) |
| var<storage, read_write> field9: array<u32>; |
| @group(3) @binding(754) |
| var<storage, read_write> function12: array<u32>; |
| @group(0) @binding(754) |
| var<storage, read_write> type4: array<u32>; |
| @group(1) @binding(366) |
| var<storage, read_write> global10: array<u32>; |
| @group(1) @binding(879) |
| var<storage, read_write> i14: array<u32>; |
| @group(0) @binding(879) |
| var<storage, read_write> field10: array<u32>; |
| |
| @compute @workgroup_size(1, 3, 3) |
| fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {} |
| |
| struct S13 { |
| @builtin(sample_index) f0: u32, |
| @builtin(front_facing) f1: bool |
| } |
| struct FragmentOutput0 { |
| @location(1) f0: vec4<i32>, |
| @location(0) f1: vec3<f32> |
| } |
| |
| @fragment |
| fn fragment0(@builtin(sample_mask) a0: u32, a1: S13, @builtin(position) a2: vec4<f32>) -> FragmentOutput0 { |
| return FragmentOutput0(); |
| } |
| |
| |
| |
| @vertex |
| fn vertex0(@location(15) a0: f16, @location(14) a1: vec4<f32>, @location(6) a2: vec3<u32>, @location(2) a3: vec2<f16>, @builtin(vertex_index) a4: u32, @location(1) a5: vec4<i32>, @location(4) a6: vec2<u32>, @location(7) a7: vec2<f32>, @location(0) a8: vec2<f32>, @location(8) a9: vec3<f32>, @location(11) a10: vec2<f32>, @location(10) a11: vec2<i32>, @location(13) a12: vec4<u32>, @location(9) a13: vec2<f32>) -> @builtin(position) vec4<f32> { |
| return vec4<f32>(0.0, 0.0, 0.0, 1.0); |
| } |
| |
| `, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| let texture110 = device4.createTexture({ |
| label: '\u{1f76e}\u86c9\ufafc\u323a\u{1fed9}\u01bc\u4ce7\ua623', |
| size: [600, 1, 148], |
| mipLevelCount: 3, |
| dimension: '3d', |
| format: 'rg16uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let sampler73 = device4.createSampler({ |
| label: '\u0e47\uc8e0\u089f\u0e58\u0905\ued18', |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| minFilter: 'nearest', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 61.627, |
| }); |
| try { |
| device4.queue.writeTexture({ |
| texture: texture63, |
| mipLevel: 9, |
| origin: { x: 0, y: 0, z: 0 }, |
| aspect: 'stencil-only', |
| }, new Float32Array(new ArrayBuffer(0)), /* required buffer size: 664 */ |
| {offset: 662, rowsPerImage: 247}, {width: 2, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| device4.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: canvas13, |
| origin: { x: 166, y: 18 }, |
| flipY: false, |
| }, { |
| texture: texture64, |
| mipLevel: 0, |
| origin: { x: 0, y: 0, z: 1 }, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let sampler74 = device8.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| lodMinClamp: 64.370, |
| lodMaxClamp: 72.847, |
| }); |
| let promise50 = device8.queue.onSubmittedWorkDone(); |
| let shaderModule14 = device0.createShaderModule({ |
| label: '\u0779\u91d5\u{1fc02}\u221c\ud1bf\u0cbd\ua682\u{1feb6}\uc554\u9b63\ud302', |
| code: `@group(2) @binding(5397) |
| var<storage, read_write> field11: array<u32>; |
| @group(2) @binding(5491) |
| var<storage, read_write> function13: array<u32>; |
| @group(2) @binding(1495) |
| var<storage, read_write> i15: array<u32>; |
| @group(0) @binding(1160) |
| var<storage, read_write> parameter11: array<u32>; |
| |
| @compute @workgroup_size(8, 1, 2) |
| fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {} |
| |
| struct S15 { |
| @builtin(position) f0: vec4<f32> |
| } |
| struct FragmentOutput0 { |
| @location(3) f0: vec4<i32>, |
| @location(1) f1: vec4<i32>, |
| @location(0) f2: vec2<u32>, |
| @location(2) f3: vec2<f32> |
| } |
| |
| @fragment |
| fn fragment0(@builtin(front_facing) a0: bool, @builtin(sample_mask) a1: u32, a2: S15) -> FragmentOutput0 { |
| return FragmentOutput0(); |
| } |
| |
| struct S14 { |
| @location(8) f0: vec2<f16>, |
| @location(14) f1: i32, |
| @location(10) f2: f32, |
| @location(7) f3: f32 |
| } |
| |
| @vertex |
| fn vertex0(@location(4) a0: vec2<f32>, a1: S14, @location(12) a2: i32, @location(11) a3: vec3<i32>, @location(13) a4: vec2<f16>, @location(9) a5: vec3<i32>, @location(3) a6: i32, @location(6) a7: vec4<i32>, @location(0) a8: vec3<f32>, @builtin(instance_index) a9: u32, @location(1) a10: f16, @location(5) a11: vec2<f16>, @location(15) a12: vec4<f16>, @location(2) a13: vec2<f16>, @builtin(vertex_index) a14: u32) -> @builtin(position) vec4<f32> { |
| return vec4<f32>(0.0, 0.0, 0.0, 1.0); |
| } |
| |
| `, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| let commandEncoder71 = device0.createCommandEncoder({label: '\u052f\u8289\u8c86\u0ae8'}); |
| let commandBuffer17 = commandEncoder71.finish({ |
| label: '\u{1fc5d}\u{1fd4c}\u{1fbb1}\u{1fb4d}\u{1fcc4}\u2c4b\u9d9d\ud6b5\u2c17', |
| }); |
| let renderBundleEncoder80 = device0.createRenderBundleEncoder({ |
| label: '\u48d1\u08d5', |
| colorFormats: ['r16float', 'rgba32float', 'rgba32uint', 'rgba8unorm', undefined, 'rgba16float'], |
| depthReadOnly: true, |
| stencilReadOnly: true |
| }); |
| try { |
| computePassEncoder7.end(); |
| } catch {} |
| try { |
| commandEncoder14.resolveQuerySet(querySet19, 2758, 48, buffer27, 16896); |
| } catch {} |
| try { |
| gpuCanvasContext19.configure({ |
| device: device0, |
| format: 'r16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['r16float'], |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| try { |
| device0.queue.submit([ |
| ]); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 294, height: 1, depthOrArrayLayers: 117} |
| */ |
| { |
| source: video6, |
| origin: { x: 4, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture45, |
| mipLevel: 1, |
| origin: { x: 259, y: 0, z: 5 }, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 11, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await promise49; |
| } catch {} |
| try { |
| adapter9.label = '\u{1f9d7}\u7cb0\u0527'; |
| } catch {} |
| let buffer35 = device2.createBuffer({ |
| label: '\u{1f83c}\ua1a1\u80c3\u{1faf9}\u7609\u326d\ue3ab\ubb22\u{1f886}', |
| size: 32910, |
| usage: GPUBufferUsage.VERTEX |
| }); |
| try { |
| computePassEncoder56.setBindGroup(3, bindGroup25); |
| } catch {} |
| try { |
| renderBundleEncoder77.setBindGroup(5, bindGroup25); |
| } catch {} |
| let promise51 = buffer18.mapAsync(GPUMapMode.WRITE, 11000, 9560); |
| try { |
| device2.queue.writeTexture({ |
| texture: texture48, |
| mipLevel: 2, |
| origin: { x: 66, y: 4, z: 5 }, |
| aspect: 'all', |
| }, arrayBuffer11, /* required buffer size: 2079731 */ |
| {offset: 15, bytesPerRow: 1664, rowsPerImage: 96}, {width: 345, height: 2, depthOrArrayLayers: 14}); |
| } catch {} |
| let querySet60 = device6.createQuerySet({ |
| label: '\u086a\u{1ffc7}\u3e37', |
| type: 'occlusion', |
| count: 1183, |
| }); |
| let texture111 = device6.createTexture({ |
| size: [400], |
| dimension: '1d', |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_SRC, |
| }); |
| let textureView84 = texture86.createView({baseMipLevel: 0}); |
| let querySet61 = device0.createQuerySet({ |
| label: '\u037e\u08ca\ud29a\u{1fa5e}\u4752\u{1f829}\u02d3\uef2e\ub1a9', |
| type: 'occlusion', |
| count: 1182, |
| }); |
| pseudoSubmit(device0, commandEncoder9); |
| let renderBundle80 = renderBundleEncoder39.finish({label: '\ua60e\u0759\u17d1\u3b50'}); |
| try { |
| renderBundleEncoder38.drawIndexed(8); |
| } catch {} |
| let arrayBuffer12 = buffer16.getMappedRange(2312, 1636); |
| try { |
| commandEncoder14.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 25276 */ |
| offset: 25276, |
| buffer: buffer4, |
| }, { |
| texture: texture59, |
| mipLevel: 0, |
| origin: { x: 0, y: 0, z: 0 }, |
| aspect: 'all', |
| }, {width: 0, height: 1, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer4); |
| } catch {} |
| try { |
| commandEncoder14.clearBuffer(buffer24, 252, 0); |
| dissociateBuffer(device0, buffer24); |
| } catch {} |
| canvas13.height = 405; |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| try { |
| window.someLabel = device8.queue.label; |
| } catch {} |
| let querySet62 = device8.createQuerySet({ |
| type: 'occlusion', |
| count: 3296, |
| }); |
| try { |
| gpuCanvasContext24.configure({ |
| device: device8, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rg32float', 'rgba16float', 'rgba16float', 'etc2-rgb8unorm-srgb'], |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| device8.queue.writeTexture({ |
| texture: texture104, |
| mipLevel: 0, |
| origin: { x: 10, y: 80, z: 45 }, |
| aspect: 'all', |
| }, arrayBuffer1, /* required buffer size: 108872 */ |
| {offset: 736, bytesPerRow: 146, rowsPerImage: 10}, {width: 60, height: 10, depthOrArrayLayers: 75}); |
| } catch {} |
| document.body.prepend(video13); |
| let offscreenCanvas30 = new OffscreenCanvas(163, 866); |
| let computePassEncoder57 = commandEncoder14.beginComputePass({label: '\u6c34\u{1fc64}\u{1f791}\u0157\ucae4\u3ab4'}); |
| try { |
| renderBundleEncoder32.setBindGroup(1, bindGroup13); |
| } catch {} |
| try { |
| renderBundleEncoder17.setVertexBuffer(1, buffer1, 15516, 1221); |
| } catch {} |
| try { |
| texture35.destroy(); |
| } catch {} |
| let textureView85 = texture108.createView({ |
| label: '\u6362\ue067\ue3b1\u048d\u{1fb41}\ua26a\u8a9e\u{1ff72}\u71f6\uf805\ud2aa', |
| dimension: '2d', |
| baseArrayLayer: 41 |
| }); |
| document.body.prepend(canvas17); |
| let img23 = await imageWithData(25, 79, '#7e116d13', '#6e369ad2'); |
| try { |
| window.someLabel = renderBundle56.label; |
| } catch {} |
| document.body.prepend(canvas5); |
| let renderBundleEncoder81 = device2.createRenderBundleEncoder({ |
| label: '\u0efc\uf235\u0401\u8e2f\u01c0\u0475\u2338', |
| colorFormats: ['bgra8unorm', 'rgba8unorm-srgb', 'rg32uint', 'bgra8unorm-srgb', undefined, 'rg16uint'], |
| depthStencilFormat: 'depth24plus-stencil8', |
| sampleCount: 4, |
| depthReadOnly: true, |
| stencilReadOnly: true |
| }); |
| try { |
| device2.queue.submit([ |
| commandBuffer9, |
| commandBuffer10, |
| commandBuffer16, |
| ]); |
| } catch {} |
| try { |
| computePassEncoder23.setPipeline(pipeline50); |
| } catch {} |
| try { |
| renderBundleEncoder37.setBindGroup(8, bindGroup25); |
| } catch {} |
| try { |
| renderBundleEncoder77.setVertexBuffer(0, buffer35, 19980, 8423); |
| } catch {} |
| let arrayBuffer13 = buffer17.getMappedRange(29840, 4968); |
| try { |
| gpuCanvasContext27.configure({ |
| device: device2, |
| format: 'depth16unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| let buffer36 = device0.createBuffer({size: 53512, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM}); |
| let texture112 = device0.createTexture({ |
| label: '\u2eda\u0c99\u0f35\u148b\ua966\ufbb9\u88f1\u44ec\u21f1\u6e70', |
| size: [80], |
| dimension: '1d', |
| format: 'rg16uint', |
| usage: GPUTextureUsage.COPY_DST, |
| viewFormats: [], |
| }); |
| let sampler75 = device0.createSampler({ |
| label: '\ud78a\u{1ff79}\u2546\u2a41\u2cad\u{1fc09}', |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'nearest', |
| lodMinClamp: 1.451, |
| lodMaxClamp: 50.693, |
| }); |
| try { |
| computePassEncoder25.end(); |
| } catch {} |
| try { |
| renderBundleEncoder61.setBindGroup(1, bindGroup3); |
| } catch {} |
| try { |
| renderBundleEncoder61.draw(40, 16, 64, 24); |
| } catch {} |
| try { |
| renderBundleEncoder38.drawIndexed(56, 8, 8, -776, 56); |
| } catch {} |
| try { |
| renderBundleEncoder80.setPipeline(pipeline49); |
| } catch {} |
| try { |
| device0.queue.submit([ |
| commandBuffer17, |
| ]); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer12, 4616, new DataView(new ArrayBuffer(26542)), 11645, 5544); |
| } catch {} |
| let bindGroup30 = device0.createBindGroup({ |
| label: '\u{1fb50}\u3851\u{1f925}\u{1f698}', |
| layout: bindGroupLayout2, |
| entries: [], |
| }); |
| let buffer37 = device0.createBuffer({label: '\u1f6a\u97c5\u0592\u002c\u2b02\u3322', size: 34545, usage: GPUBufferUsage.COPY_SRC}); |
| pseudoSubmit(device0, commandEncoder15); |
| let computePassEncoder58 = commandEncoder23.beginComputePass({label: '\uc174\u0021\u9614\u{1fd38}\u4ac6'}); |
| try { |
| renderBundleEncoder80.drawIndexedIndirect(buffer36, 11788); |
| } catch {} |
| try { |
| renderBundleEncoder24.setIndexBuffer(buffer27, 'uint16', 33262, 4169); |
| } catch {} |
| let promise52 = buffer5.mapAsync(GPUMapMode.WRITE, 14176, 3640); |
| try { |
| device0.queue.writeTexture({ |
| texture: texture46, |
| mipLevel: 5, |
| origin: { x: 2, y: 2, z: 0 }, |
| aspect: 'all', |
| }, new ArrayBuffer(11981), /* required buffer size: 11981 */ |
| {offset: 133, bytesPerRow: 516, rowsPerImage: 22}, {width: 31, height: 1, depthOrArrayLayers: 2}); |
| } catch {} |
| let promise53 = device0.createRenderPipelineAsync({ |
| label: '\u{1fd0d}\u8f3f\u{1ff40}\u8175\u343c\uc128\ue163\uebae\u7aef\u4e41\u{1fc3b}', |
| layout: pipelineLayout17, |
| fragment: { |
| module: shaderModule6, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{ |
| format: 'r16float', |
| blend: { |
| color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'}, |
| alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'}, |
| }, |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.RED |
| }, {format: 'rgba32float', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA}, {format: 'rgba32uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.RED}, { |
| format: 'rgba8unorm', |
| blend: { |
| color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'}, |
| alpha: {operation: 'add', srcFactor: 'one-minus-src-alpha', dstFactor: 'one-minus-dst'}, |
| } |
| }, undefined, { |
| format: 'rgba16float', |
| blend: { |
| color: {operation: 'add', srcFactor: 'one-minus-dst', dstFactor: 'src-alpha'}, |
| alpha: {operation: 'reverse-subtract', srcFactor: 'one-minus-src', dstFactor: 'one-minus-src-alpha'}, |
| }, |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN |
| }] |
| }, |
| depthStencil: { |
| format: 'stencil8', |
| depthWriteEnabled: false, |
| depthCompare: 'always', |
| stencilFront: { |
| compare: 'less-equal', |
| failOp: 'zero', |
| depthFailOp: 'zero', |
| passOp: 'decrement-clamp', |
| }, |
| stencilBack: { |
| compare: 'greater-equal', |
| failOp: 'increment-clamp', |
| depthFailOp: 'keep', |
| }, |
| stencilReadMask: 4064, |
| stencilWriteMask: 3622, |
| depthBias: 19, |
| depthBiasSlopeScale: 34, |
| depthBiasClamp: 67, |
| }, |
| vertex: { |
| module: shaderModule6, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 15832, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'unorm8x2', |
| offset: 14360, |
| shaderLocation: 0, |
| }, { |
| format: 'float32x4', |
| offset: 8052, |
| shaderLocation: 13, |
| }, { |
| format: 'float32', |
| offset: 2840, |
| shaderLocation: 10, |
| }, { |
| format: 'snorm16x2', |
| offset: 7720, |
| shaderLocation: 3, |
| }, { |
| format: 'uint16x2', |
| offset: 6388, |
| shaderLocation: 14, |
| }], |
| }, |
| { |
| arrayStride: 5652, |
| stepMode: 'instance', |
| attributes: [], |
| }, |
| { |
| arrayStride: 10320, |
| stepMode: 'vertex', |
| attributes: [], |
| }, |
| { |
| arrayStride: 10408, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'uint32x3', |
| offset: 1820, |
| shaderLocation: 12, |
| }, { |
| format: 'uint32', |
| offset: 3560, |
| shaderLocation: 2, |
| }], |
| }, |
| { |
| arrayStride: 3452, |
| stepMode: 'vertex', |
| attributes: [], |
| }, |
| { |
| arrayStride: 4848, |
| attributes: [], |
| }, |
| { |
| arrayStride: 14660, |
| stepMode: 'instance', |
| attributes: [], |
| }, |
| { |
| arrayStride: 1824, |
| stepMode: 'instance', |
| attributes: [{ |
| format: 'unorm10-10-10-2', |
| offset: 328, |
| shaderLocation: 6, |
| }], |
| } |
| ] |
| }, |
| primitive: { |
| topology: 'line-list', |
| frontFace: 'ccw', |
| unclippedDepth: true, |
| }, |
| }); |
| let img24 = await imageWithData(172, 149, '#ff5bc1a0', '#5e682adc'); |
| let videoFrame23 = new VideoFrame(video7, {timestamp: 0}); |
| try { |
| adapter8.label = '\u86ee\u908a\u768f\u716c'; |
| } catch {} |
| let querySet63 = device6.createQuerySet({ |
| label: '\u06b2\u7422\u7791\uc8f2\u1ed6\u7da7', |
| type: 'occlusion', |
| count: 4060, |
| }); |
| try { |
| computePassEncoder52.end(); |
| } catch {} |
| try { |
| commandEncoder61.copyTextureToTexture({ |
| texture: texture106, |
| mipLevel: 7, |
| origin: { x: 1, y: 0, z: 0 }, |
| aspect: 'all', |
| }, { |
| texture: texture106, |
| mipLevel: 0, |
| origin: { x: 302, y: 0, z: 17 }, |
| aspect: 'all', |
| }, {width: 10, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| commandEncoder61.resolveQuerySet(querySet57, 1716, 1564, buffer34, 12288); |
| } catch {} |
| try { |
| device6.queue.writeBuffer(buffer30, 380, new Int16Array(57198), 36251, 52); |
| } catch {} |
| try { |
| device6.queue.writeTexture({ |
| texture: texture86, |
| mipLevel: 0, |
| origin: { x: 651, y: 1, z: 0 }, |
| aspect: 'all', |
| }, new ArrayBuffer(125), /* required buffer size: 125 */ |
| {offset: 125}, {width: 845, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| let imageBitmap20 = await createImageBitmap(video9); |
| try { |
| offscreenCanvas30.getContext('webgl2'); |
| } catch {} |
| let renderBundleEncoder82 = device2.createRenderBundleEncoder({ |
| label: '\u0d9d\u3c2b\u797e\u0638', |
| colorFormats: ['bgra8unorm', 'rgba8unorm-srgb', 'rg32uint', 'bgra8unorm-srgb', undefined, 'rg16uint'], |
| depthStencilFormat: 'depth24plus-stencil8', |
| sampleCount: 4, |
| stencilReadOnly: false |
| }); |
| try { |
| renderBundleEncoder81.setBindGroup(3, bindGroup25); |
| } catch {} |
| try { |
| device2.queue.writeTexture({ |
| texture: texture76, |
| mipLevel: 0, |
| origin: { x: 227, y: 0, z: 0 }, |
| aspect: 'all', |
| }, arrayBuffer5, /* required buffer size: 1317 */ |
| {offset: 885}, {width: 216, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| let promise54 = device2.createComputePipelineAsync({ |
| layout: pipelineLayout11, |
| compute: { |
| module: shaderModule7, |
| entryPoint: 'compute0', |
| constants: {}, |
| }, |
| }); |
| let canvas30 = document.createElement('canvas'); |
| let video25 = await videoWithData(); |
| try { |
| canvas30.getContext('webgl'); |
| } catch {} |
| let shaderModule15 = device7.createShaderModule({ |
| label: '\u466b\u0870\ubc76\u{1fbf7}\u27ed\u4d5c\u0c1d\u0d98\u7e1c\u35fe\u02f9', |
| code: `@group(1) @binding(3038) |
| var<storage, read_write> parameter12: array<u32>; |
| @group(0) @binding(3038) |
| var<storage, read_write> function14: array<u32>; |
| @group(0) @binding(4730) |
| var<storage, read_write> type5: array<u32>; |
| @group(1) @binding(4730) |
| var<storage, read_write> type6: array<u32>; |
| @group(1) @binding(3660) |
| var<storage, read_write> local6: array<u32>; |
| |
| @compute @workgroup_size(7, 1, 1) |
| fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {} |
| |
| struct S17 { |
| @builtin(position) f0: vec4<f32> |
| } |
| struct FragmentOutput0 { |
| @location(0) f0: vec3<f32>, |
| @builtin(sample_mask) f1: u32 |
| } |
| |
| @fragment |
| fn fragment0(@builtin(sample_index) a0: u32, a1: S17, @builtin(front_facing) a2: bool, @builtin(sample_mask) a3: u32) -> FragmentOutput0 { |
| return FragmentOutput0(); |
| } |
| |
| struct S16 { |
| @location(16) f0: vec4<f32>, |
| @builtin(instance_index) f1: u32, |
| @location(17) f2: vec2<u32>, |
| @location(20) f3: i32, |
| @location(4) f4: i32 |
| } |
| |
| @vertex |
| fn vertex0(a0: S16, @location(6) a1: vec3<i32>, @location(11) a2: vec2<i32>, @location(23) a3: vec2<f32>, @location(19) a4: vec3<f16>, @builtin(vertex_index) a5: u32, @location(14) a6: vec3<f32>, @location(21) a7: i32, @location(2) a8: f16, @location(0) a9: f32, @location(12) a10: vec3<i32>, @location(22) a11: vec2<f16>, @location(13) a12: u32, @location(9) a13: vec3<u32>, @location(8) a14: vec3<u32>, @location(5) a15: vec3<u32>, @location(10) a16: vec2<f16>, @location(1) a17: f32, @location(3) a18: vec4<u32>, @location(7) a19: vec3<u32>, @location(15) a20: vec2<i32>, @location(18) a21: vec2<i32>) -> @builtin(position) vec4<f32> { |
| return vec4<f32>(0.0, 0.0, 0.0, 1.0); |
| } |
| |
| `, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| try { |
| renderBundleEncoder64.setVertexBuffer(9, undefined, 3850192367, 297040102); |
| } catch {} |
| try { |
| device7.queue.writeTexture({ |
| texture: texture93, |
| mipLevel: 0, |
| origin: { x: 415, y: 4, z: 0 }, |
| aspect: 'all', |
| }, new ArrayBuffer(19489), /* required buffer size: 19489 */ |
| {offset: 753, bytesPerRow: 656}, {width: 368, height: 29, depthOrArrayLayers: 1}); |
| } catch {} |
| let imageData29 = new ImageData(188, 216); |
| let shaderModule16 = device2.createShaderModule({ |
| label: '\u{1ff73}\ua2ea\u3e47\u4fc3\u{1fa50}', |
| code: `@group(2) @binding(3183) |
| var<storage, read_write> function15: array<u32>; |
| @group(8) @binding(2585) |
| var<storage, read_write> parameter13: array<u32>; |
| @group(7) @binding(3183) |
| var<storage, read_write> local7: array<u32>; |
| @group(0) @binding(3183) |
| var<storage, read_write> field12: array<u32>; |
| @group(1) @binding(3183) |
| var<storage, read_write> field13: array<u32>; |
| @group(8) @binding(3183) |
| var<storage, read_write> local8: array<u32>; |
| @group(4) @binding(2585) |
| var<storage, read_write> i16: array<u32>; |
| @group(6) @binding(3183) |
| var<storage, read_write> field14: array<u32>; |
| @group(5) @binding(3183) |
| var<storage, read_write> function16: array<u32>; |
| @group(1) @binding(2585) |
| var<storage, read_write> field15: array<u32>; |
| @group(6) @binding(2585) |
| var<storage, read_write> field16: array<u32>; |
| @group(0) @binding(2585) |
| var<storage, read_write> type7: array<u32>; |
| @group(7) @binding(2585) |
| var<storage, read_write> function17: array<u32>; |
| @group(4) @binding(3183) |
| var<storage, read_write> i17: array<u32>; |
| @group(2) @binding(2585) |
| var<storage, read_write> field17: array<u32>; |
| @group(3) @binding(3183) |
| var<storage, read_write> function18: array<u32>; |
| |
| @compute @workgroup_size(8, 2, 3) |
| fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {} |
| |
| struct FragmentOutput0 { |
| @location(5) f0: vec2<f32> |
| } |
| |
| @fragment |
| fn fragment0(@builtin(sample_index) a0: u32) -> FragmentOutput0 { |
| return FragmentOutput0(); |
| } |
| |
| struct S18 { |
| @location(20) f0: vec3<f32> |
| } |
| |
| @vertex |
| fn vertex0(@location(8) a0: vec3<i32>, @location(0) a1: i32, @builtin(vertex_index) a2: u32, @location(17) a3: vec3<f16>, @location(3) a4: vec3<f16>, @location(15) a5: vec3<i32>, @location(26) a6: u32, @location(24) a7: vec3<f16>, @location(19) a8: vec4<u32>, @location(7) a9: vec3<u32>, @location(21) a10: vec4<i32>, @location(18) a11: vec3<i32>, @location(14) a12: u32, @builtin(instance_index) a13: u32, @location(12) a14: vec3<i32>, @location(23) a15: vec3<i32>, @location(10) a16: vec3<f16>, @location(5) a17: vec4<i32>, @location(25) a18: vec4<i32>, @location(16) a19: vec3<i32>, @location(9) a20: vec2<f32>, @location(2) a21: u32, @location(6) a22: f16, @location(11) a23: f16, @location(1) a24: f16, @location(13) a25: vec2<f32>, a26: S18, @location(22) a27: vec4<u32>) -> @builtin(position) vec4<f32> { |
| return vec4<f32>(0.0, 0.0, 0.0, 1.0); |
| } |
| |
| `, |
| sourceMap: {}, |
| }); |
| let buffer38 = device2.createBuffer({ |
| label: '\ude64\u{1fb80}\u{1fd3f}\u0dfd\ua197\u0536\u0c15\ud74f\u57e4\u59d9\ub231', |
| size: 28858, |
| usage: GPUBufferUsage.INDIRECT, |
| mappedAtCreation: false |
| }); |
| let renderBundle81 = renderBundleEncoder34.finish({label: '\uaf12\u{1fdf6}\u702a\u{1f60a}\ud586'}); |
| let promise55 = device2.createComputePipelineAsync({ |
| label: '\ud092\u0e43\u3ff5\u0904\u0efb\u02b8', |
| layout: pipelineLayout11, |
| compute: { |
| module: shaderModule7, |
| entryPoint: 'compute0', |
| constants: {}, |
| }, |
| }); |
| let promise56 = navigator.gpu.requestAdapter(); |
| let offscreenCanvas31 = new OffscreenCanvas(221, 645); |
| document.body.prepend(video10); |
| let buffer39 = device7.createBuffer({ |
| label: '\u0f56\u55ff\ub4cf\u0a40', |
| size: 13434, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE |
| }); |
| pseudoSubmit(device7, commandEncoder70); |
| let renderBundle82 = renderBundleEncoder63.finish({label: '\u48bb\u0069\u410a\u0fcd\ua4fb\ub3a4\uf09c\ue718\u0f83\u{1f692}\uc3b8'}); |
| try { |
| device7.queue.writeTexture({ |
| texture: texture93, |
| mipLevel: 0, |
| origin: { x: 123, y: 11, z: 0 }, |
| aspect: 'all', |
| }, new ArrayBuffer(16), /* required buffer size: 35 */ |
| {offset: 35, bytesPerRow: 458}, {width: 435, height: 18, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline68 = device7.createComputePipeline({ |
| layout: pipelineLayout18, |
| compute: { |
| module: shaderModule15, |
| entryPoint: 'compute0', |
| constants: {}, |
| }, |
| }); |
| let textureView86 = texture93.createView({label: '\u6bad\u3116\u{1f8f0}\u0b6d\u{1fc1c}\u{1fc28}\u078d\u0f44'}); |
| let computePassEncoder59 = commandEncoder67.beginComputePass({label: '\u0986\u{1faaa}\u06df\u1aab\u0470\u{1fa8e}\u0c36\u5ee6\u7854'}); |
| try { |
| computePassEncoder47.setPipeline(pipeline68); |
| } catch {} |
| try { |
| device7.queue.writeTexture({ |
| texture: texture96, |
| mipLevel: 5, |
| origin: { x: 0, y: 1, z: 7 }, |
| aspect: 'stencil-only', |
| }, new ArrayBuffer(16), /* required buffer size: 268491 */ |
| {offset: 894, bytesPerRow: 153, rowsPerImage: 159}, {width: 39, height: 0, depthOrArrayLayers: 12}); |
| } catch {} |
| let offscreenCanvas32 = new OffscreenCanvas(419, 284); |
| let imageBitmap21 = await createImageBitmap(offscreenCanvas15); |
| let bindGroupLayout40 = device7.createBindGroupLayout({ |
| label: '\u8b86\u950e\u4351\u8776', |
| entries: [{ |
| binding: 1134, |
| visibility: GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rg32uint', access: 'read-only', viewDimension: '2d-array' }, |
| }, { |
| binding: 3448, |
| visibility: GPUShaderStage.FRAGMENT, |
| sampler: { type: 'non-filtering' }, |
| }], |
| }); |
| try { |
| renderBundleEncoder64.setVertexBuffer(10, undefined); |
| } catch {} |
| try { |
| gpuCanvasContext18.configure({ |
| device: device7, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rgba16float', 'rgba16float'], |
| colorSpace: 'srgb', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| adapter7.label = '\u0ae9\ua46d'; |
| } catch {} |
| let gpuCanvasContext28 = canvas28.getContext('webgpu'); |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| document.body.prepend(video23); |
| let imageData30 = new ImageData(124, 232); |
| try { |
| offscreenCanvas31.getContext('webgl'); |
| } catch {} |
| let imageBitmap22 = await createImageBitmap(video20); |
| try { |
| renderBundleEncoder81.setBindGroup(4, bindGroup25); |
| } catch {} |
| let canvas31 = document.createElement('canvas'); |
| try { |
| if (!arrayBuffer12.detached) { new Uint8Array(arrayBuffer12).fill(0x55) }; |
| } catch {} |
| let shaderModule17 = device0.createShaderModule({ |
| code: `@group(0) @binding(1160) |
| var<storage, read_write> global11: array<u32>; |
| |
| @compute @workgroup_size(5, 2, 4) |
| fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {} |
| |
| struct FragmentOutput0 { |
| @location(4) f0: vec3<i32>, |
| @location(6) f1: i32, |
| @location(7) f2: vec2<i32>, |
| @location(2) f3: vec2<i32>, |
| @location(3) f4: vec2<u32>, |
| @builtin(sample_mask) f5: u32, |
| @location(5) f6: vec4<f32>, |
| @location(0) f7: vec3<u32> |
| } |
| |
| @fragment |
| fn fragment0() -> FragmentOutput0 { |
| return FragmentOutput0(); |
| } |
| |
| |
| |
| @vertex |
| fn vertex0(@location(9) a0: vec3<f16>, @builtin(vertex_index) a1: u32, @location(15) a2: vec3<f32>, @location(11) a3: vec3<f16>, @location(8) a4: vec3<f32>, @location(5) a5: vec2<u32>, @location(10) a6: vec3<i32>, @location(6) a7: vec4<f16>, @location(0) a8: vec4<f32>, @location(13) a9: f32, @location(7) a10: vec2<i32>, @location(2) a11: vec2<f16>, @location(4) a12: vec3<i32>, @location(12) a13: vec2<u32>) -> @builtin(position) vec4<f32> { |
| return vec4<f32>(0.0, 0.0, 0.0, 1.0); |
| } |
| |
| `, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| let bindGroup31 = device0.createBindGroup({ |
| layout: bindGroupLayout7, |
| entries: [{ |
| binding: 1160, |
| resource: externalTexture0 |
| }], |
| }); |
| try { |
| renderBundleEncoder38.setVertexBuffer(4, buffer32); |
| } catch {} |
| try { |
| device0.pushErrorScope('validation'); |
| } catch {} |
| let promise57 = buffer7.mapAsync(GPUMapMode.READ, 0, 28620); |
| try { |
| device0.queue.writeTexture({ |
| texture: texture14, |
| mipLevel: 0, |
| origin: { x: 368, y: 0, z: 0 }, |
| aspect: 'all', |
| }, new ArrayBuffer(721309), /* required buffer size: 721309 */ |
| {offset: 171, bytesPerRow: 7594, rowsPerImage: 94}, {width: 3651, height: 1, depthOrArrayLayers: 2}); |
| } catch {} |
| let gpuCanvasContext29 = offscreenCanvas29.getContext('webgpu'); |
| try { |
| offscreenCanvas32.getContext('bitmaprenderer'); |
| } catch {} |
| let commandEncoder72 = device7.createCommandEncoder({}); |
| let textureView87 = texture93.createView({label: '\uc871\ufadf\u8ee3\u{1fe19}\u8eed\u2d59', aspect: 'all', baseArrayLayer: 0}); |
| let renderBundleEncoder83 = device7.createRenderBundleEncoder({ |
| colorFormats: ['rg8unorm', 'rg16float', undefined, undefined, undefined, 'r16uint', 'rgba16uint'], |
| depthStencilFormat: 'depth24plus-stencil8', |
| sampleCount: 4, |
| depthReadOnly: false |
| }); |
| try { |
| device7.queue.writeTexture({ |
| texture: texture93, |
| mipLevel: 0, |
| origin: { x: 61, y: 18, z: 0 }, |
| aspect: 'all', |
| }, new BigUint64Array(arrayBuffer7), /* required buffer size: 3528 */ |
| {offset: 642, bytesPerRow: 727}, {width: 705, height: 4, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(0x55) }; |
| } catch {} |
| let imageData31 = new ImageData(88, 168); |
| let imageData32 = new ImageData(60, 168); |
| let img25 = await imageWithData(192, 37, '#c7a7fc14', '#8b7348fc'); |
| let commandEncoder73 = device2.createCommandEncoder({}); |
| let sampler76 = device2.createSampler({ |
| label: '\u2ada\u0c5e\u8db1\u0471\u{1f815}\u9bc8\u43ff\u2aa9\u08cb\u{1f8bf}\u98e4', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'nearest', |
| lodMinClamp: 39.031, |
| lodMaxClamp: 42.647, |
| compare: 'greater', |
| }); |
| try { |
| renderBundleEncoder81.setVertexBuffer(2, buffer35, 31836, 243); |
| } catch {} |
| try { |
| commandEncoder73.resolveQuerySet(querySet39, 100, 145, buffer19, 12544); |
| } catch {} |
| try { |
| device2.queue.writeTexture({ |
| texture: texture76, |
| mipLevel: 0, |
| origin: { x: 173, y: 1, z: 0 }, |
| aspect: 'all', |
| }, new Int16Array(arrayBuffer5), /* required buffer size: 40 */ |
| {offset: 40}, {width: 192, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline69 = await promise55; |
| document.body.prepend(img4); |
| let querySet64 = device2.createQuerySet({ |
| label: '\u2bf3\u0afa\u{1f870}\uf204', |
| type: 'occlusion', |
| count: 3486, |
| }); |
| let renderBundle83 = renderBundleEncoder59.finish({label: '\ud4f8\u5a73\u02c4\u{1f65c}\u0714\u449e\u8f5e\u086c\u9592'}); |
| try { |
| computePassEncoder55.end(); |
| } catch {} |
| try { |
| computePassEncoder56.setPipeline(pipeline66); |
| } catch {} |
| try { |
| commandEncoder73.clearBuffer(buffer19); |
| dissociateBuffer(device2, buffer19); |
| } catch {} |
| let pipeline70 = await device2.createComputePipelineAsync({ |
| label: '\ue0cd\u{1f7bb}\u0db5\u080d\uadda', |
| layout: pipelineLayout11, |
| compute: { |
| module: shaderModule7, |
| entryPoint: 'compute0', |
| constants: {}, |
| }, |
| }); |
| let gpuCanvasContext30 = canvas31.getContext('webgpu'); |
| gc(); |
| let shaderModule18 = device2.createShaderModule({ |
| label: '\u0b22\u05fd\u0869\u22e7\uab70\u075d\u6d35\u6639', |
| code: `@group(1) @binding(2585) |
| var<storage, read_write> parameter14: array<u32>; |
| @group(3) @binding(2585) |
| var<storage, read_write> parameter15: array<u32>; |
| @group(8) @binding(3183) |
| var<storage, read_write> parameter16: array<u32>; |
| @group(4) @binding(2585) |
| var<storage, read_write> type8: array<u32>; |
| @group(5) @binding(3183) |
| var<storage, read_write> function19: array<u32>; |
| @group(7) @binding(2585) |
| var<storage, read_write> local9: array<u32>; |
| @group(2) @binding(2585) |
| var<storage, read_write> field18: array<u32>; |
| @group(5) @binding(2585) |
| var<storage, read_write> field19: array<u32>; |
| @group(8) @binding(2585) |
| var<storage, read_write> parameter17: array<u32>; |
| @group(6) @binding(3183) |
| var<storage, read_write> parameter18: array<u32>; |
| @group(1) @binding(3183) |
| var<storage, read_write> local10: array<u32>; |
| |
| @compute @workgroup_size(4, 2, 2) |
| fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {} |
| |
| struct S20 { |
| @builtin(sample_index) f0: u32, |
| @location(10) f1: f16, |
| @location(16) f2: vec3<i32>, |
| @location(19) f3: u32, |
| @location(5) f4: vec2<u32>, |
| @location(30) f5: f32, |
| @builtin(front_facing) f6: bool, |
| @location(17) f7: vec2<f32>, |
| @location(25) f8: vec3<u32>, |
| @location(31) f9: f16, |
| @location(12) f10: vec2<f32>, |
| @location(2) f11: vec2<i32>, |
| @builtin(sample_mask) f12: u32, |
| @location(23) f13: vec4<f32>, |
| @location(11) f14: f16, |
| @location(4) f15: vec4<i32>, |
| @location(13) f16: f32, |
| @location(21) f17: vec3<f32>, |
| @location(29) f18: f16 |
| } |
| struct FragmentOutput0 { |
| @location(5) f0: vec4<u32>, |
| @location(3) f1: vec4<f32>, |
| @location(0) f2: vec4<f32>, |
| @location(1) f3: vec4<f32>, |
| @builtin(frag_depth) f4: f32, |
| @location(2) f5: vec2<u32> |
| } |
| |
| @fragment |
| fn fragment0(@location(14) a0: vec4<f32>, @location(22) a1: vec2<i32>, @location(20) a2: f32, @location(26) a3: vec2<u32>, @location(9) a4: vec3<f32>, @builtin(position) a5: vec4<f32>, @location(15) a6: vec2<f32>, a7: S20, @location(1) a8: vec2<i32>, @location(18) a9: vec4<f16>, @location(3) a10: vec3<i32>) -> FragmentOutput0 { |
| return FragmentOutput0(); |
| } |
| |
| struct S19 { |
| @location(24) f0: f32, |
| @location(18) f1: vec2<u32>, |
| @location(21) f2: vec2<f32>, |
| @location(14) f3: vec3<i32>, |
| @location(15) f4: vec3<u32>, |
| @builtin(instance_index) f5: u32, |
| @location(25) f6: vec3<f32>, |
| @location(13) f7: vec2<i32>, |
| @location(26) f8: i32, |
| @location(12) f9: u32, |
| @location(0) f10: f32, |
| @location(6) f11: vec2<i32>, |
| @location(7) f12: i32 |
| } |
| struct VertexOutput0 { |
| @location(9) f192: vec3<f32>, |
| @location(11) f193: f16, |
| @location(26) f194: vec2<u32>, |
| @builtin(position) f195: vec4<f32>, |
| @location(17) f196: vec2<f32>, |
| @location(18) f197: vec4<f16>, |
| @location(16) f198: vec3<i32>, |
| @location(2) f199: vec2<i32>, |
| @location(3) f200: vec3<i32>, |
| @location(22) f201: vec2<i32>, |
| @location(15) f202: vec2<f32>, |
| @location(19) f203: u32, |
| @location(20) f204: f32, |
| @location(1) f205: vec2<i32>, |
| @location(4) f206: vec4<i32>, |
| @location(29) f207: f16, |
| @location(25) f208: vec3<u32>, |
| @location(10) f209: f16, |
| @location(21) f210: vec3<f32>, |
| @location(12) f211: vec2<f32>, |
| @location(31) f212: f16, |
| @location(13) f213: f32, |
| @location(14) f214: vec4<f32>, |
| @location(23) f215: vec4<f32>, |
| @location(30) f216: f32, |
| @location(5) f217: vec2<u32> |
| } |
| |
| @vertex |
| fn vertex0(@location(19) a0: f16, @location(20) a1: vec3<f16>, @location(4) a2: vec2<f16>, @location(9) a3: vec4<i32>, @location(10) a4: vec3<f16>, a5: S19, @builtin(vertex_index) a6: u32, @location(1) a7: vec3<i32>) -> VertexOutput0 { |
| return VertexOutput0(); |
| } |
| |
| `, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| let texture113 = device2.createTexture({ |
| label: '\u0342\u2817\u0cb6\u904a\u{1fcf5}', |
| size: [5520, 1, 1], |
| mipLevelCount: 3, |
| format: 'r32sint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let sampler77 = device2.createSampler({ |
| label: '\u648f\u9bbb\u{1feee}\u8c6d\u18db', |
| addressModeU: 'clamp-to-edge', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 43.939, |
| lodMaxClamp: 58.502, |
| maxAnisotropy: 7, |
| }); |
| let pipeline71 = device2.createRenderPipeline({ |
| label: '\ub9e8\u0175\ufda9', |
| layout: 'auto', |
| multisample: { |
| count: 4, |
| alphaToCoverageEnabled: true, |
| }, |
| fragment: { |
| module: shaderModule18, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{format: 'bgra8unorm'}, { |
| format: 'rgba8unorm-srgb', |
| blend: { |
| color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'}, |
| alpha: {operation: 'subtract', srcFactor: 'zero', dstFactor: 'dst-alpha'}, |
| } |
| }, {format: 'rg32uint'}, { |
| format: 'bgra8unorm-srgb', |
| blend: { |
| color: {operation: 'add', srcFactor: 'dst', dstFactor: 'one'}, |
| alpha: {operation: 'reverse-subtract', srcFactor: 'one', dstFactor: 'dst'}, |
| }, |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.RED |
| }, undefined, {format: 'rg16uint', writeMask: 0}] |
| }, |
| depthStencil: { |
| format: 'depth24plus-stencil8', |
| depthWriteEnabled: true, |
| depthCompare: 'greater-equal', |
| stencilFront: { |
| compare: 'equal', |
| failOp: 'increment-clamp', |
| depthFailOp: 'decrement-wrap', |
| passOp: 'increment-clamp', |
| }, |
| stencilBack: { |
| compare: 'less', |
| failOp: 'decrement-wrap', |
| depthFailOp: 'decrement-wrap', |
| passOp: 'decrement-clamp', |
| }, |
| stencilReadMask: 2722, |
| stencilWriteMask: 3938, |
| depthBias: 79, |
| depthBiasSlopeScale: 95, |
| depthBiasClamp: 84, |
| }, |
| vertex: { |
| module: shaderModule18, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 30136, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'uint32x2', |
| offset: 1948, |
| shaderLocation: 18, |
| }, { |
| format: 'snorm8x4', |
| offset: 25004, |
| shaderLocation: 20, |
| }, { |
| format: 'sint8x4', |
| offset: 10048, |
| shaderLocation: 7, |
| }, { |
| format: 'uint32x3', |
| offset: 21540, |
| shaderLocation: 15, |
| }, { |
| format: 'sint16x2', |
| offset: 27956, |
| shaderLocation: 13, |
| }, { |
| format: 'float16x2', |
| offset: 20640, |
| shaderLocation: 25, |
| }, { |
| format: 'sint32x4', |
| offset: 1260, |
| shaderLocation: 6, |
| }, { |
| format: 'snorm8x4', |
| offset: 17424, |
| shaderLocation: 24, |
| }, { |
| format: 'uint16x2', |
| offset: 4096, |
| shaderLocation: 12, |
| }, { |
| format: 'sint32x3', |
| offset: 616, |
| shaderLocation: 1, |
| }, { |
| format: 'sint8x2', |
| offset: 6364, |
| shaderLocation: 9, |
| }, { |
| format: 'float16x2', |
| offset: 23080, |
| shaderLocation: 19, |
| }, { |
| format: 'float32x3', |
| offset: 15648, |
| shaderLocation: 4, |
| }, { |
| format: 'float32x4', |
| offset: 25388, |
| shaderLocation: 0, |
| }, { |
| format: 'sint32x4', |
| offset: 21196, |
| shaderLocation: 14, |
| }], |
| }, |
| { |
| arrayStride: 41524, |
| stepMode: 'instance', |
| attributes: [{ |
| format: 'sint32', |
| offset: 41380, |
| shaderLocation: 26, |
| }, { |
| format: 'snorm8x4', |
| offset: 12648, |
| shaderLocation: 21, |
| }], |
| }, |
| { |
| arrayStride: 31252, |
| attributes: [{ |
| format: 'float32', |
| offset: 11208, |
| shaderLocation: 10, |
| }], |
| } |
| ] |
| }, |
| primitive: { |
| topology: 'line-strip', |
| stripIndexFormat: 'uint32', |
| cullMode: 'front', |
| }, |
| }); |
| pseudoSubmit(device2, commandEncoder36); |
| let renderBundleEncoder84 = device2.createRenderBundleEncoder({ |
| label: '\u068d\u0d21\ub6da\ua924\u20be\u00c6\u86de\ue6fa\ue115', |
| colorFormats: ['bgra8unorm', 'rgba8unorm-srgb', 'rg32uint', 'bgra8unorm-srgb', undefined, 'rg16uint'], |
| depthStencilFormat: 'depth24plus-stencil8', |
| sampleCount: 4 |
| }); |
| try { |
| renderBundleEncoder77.setBindGroup(4, bindGroup25); |
| } catch {} |
| let adapter11 = await navigator.gpu.requestAdapter({ |
| }); |
| offscreenCanvas1.width = 290; |
| let video26 = await videoWithData(); |
| let commandEncoder74 = device7.createCommandEncoder(); |
| let texture114 = device7.createTexture({ |
| size: {width: 4992}, |
| dimension: '1d', |
| format: 'r8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['r8unorm', 'r8unorm', 'r8unorm'], |
| }); |
| let textureView88 = texture93.createView({}); |
| let computePassEncoder60 = commandEncoder72.beginComputePass({label: '\u{1fb00}\u0f35\u0d63\u{1f7bf}\u3851\u{1fef2}\u0de3\u0e91'}); |
| try { |
| commandEncoder74.copyBufferToBuffer(buffer39, 7696, buffer33, 6812, 1616); |
| dissociateBuffer(device7, buffer39); |
| dissociateBuffer(device7, buffer33); |
| } catch {} |
| let adapter12 = await navigator.gpu.requestAdapter(); |
| try { |
| canvas29.getContext('webgpu'); |
| } catch {} |
| let querySet65 = device6.createQuerySet({ |
| label: '\u{1faca}\u0e35\u857a\u{1f842}\u02b1\u00d8\uc323\u754a', |
| type: 'occlusion', |
| count: 778, |
| }); |
| let sampler78 = device6.createSampler({ |
| label: '\ua1d1\u0e71\ued0f\u{1f629}\u5327\u003e\u44dc\u6e5f\u0199', |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 58.397, |
| lodMaxClamp: 91.303, |
| }); |
| try { |
| renderBundleEncoder78.setVertexBuffer(3, buffer30, 456, 89); |
| } catch {} |
| try { |
| commandEncoder61.copyBufferToBuffer(buffer25, 1912, buffer30, 412, 172); |
| dissociateBuffer(device6, buffer25); |
| dissociateBuffer(device6, buffer30); |
| } catch {} |
| let img26 = await imageWithData(73, 66, '#26ef3c4b', '#83b7d2fc'); |
| let video27 = await videoWithData(); |
| let buffer40 = device7.createBuffer({size: 25243, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT}); |
| let texture115 = device7.createTexture({ |
| label: '\u9796\u6823\ud9f8\u{1fb66}\u1196', |
| size: [1680], |
| dimension: '1d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rgb10a2unorm', 'rgb10a2unorm'], |
| }); |
| let sampler79 = device7.createSampler({ |
| label: '\u9e92\u{1f671}\u71af\u847e\u5c3e\u{1f9e2}', |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 60.028, |
| lodMaxClamp: 78.340, |
| maxAnisotropy: 17, |
| }); |
| try { |
| renderBundleEncoder64.setVertexBuffer(87, undefined, 2467832355, 491926512); |
| } catch {} |
| let pipeline72 = device7.createRenderPipeline({ |
| label: '\u0fc5\u084e\u3bec\u3305\u{1f85a}', |
| layout: pipelineLayout18, |
| multisample: { |
| count: 4, |
| }, |
| fragment: {module: shaderModule15, entryPoint: 'fragment0', constants: {}, targets: []}, |
| depthStencil: { |
| format: 'stencil8', |
| stencilFront: { |
| compare: 'equal', |
| failOp: 'replace', |
| depthFailOp: 'increment-wrap', |
| passOp: 'replace', |
| }, |
| stencilBack: { |
| compare: 'not-equal', |
| depthFailOp: 'increment-clamp', |
| passOp: 'zero', |
| }, |
| stencilReadMask: 1991, |
| stencilWriteMask: 2204, |
| depthBias: 91, |
| depthBiasSlopeScale: 7, |
| depthBiasClamp: 72, |
| }, |
| vertex: { |
| module: shaderModule15, |
| entryPoint: 'vertex0', |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 6080, |
| attributes: [{ |
| format: 'sint32x3', |
| offset: 404, |
| shaderLocation: 4, |
| }, { |
| format: 'uint16x4', |
| offset: 5600, |
| shaderLocation: 3, |
| }, { |
| format: 'sint32x3', |
| offset: 956, |
| shaderLocation: 6, |
| }, { |
| format: 'sint16x4', |
| offset: 5964, |
| shaderLocation: 21, |
| }, { |
| format: 'unorm16x4', |
| offset: 2872, |
| shaderLocation: 14, |
| }, { |
| format: 'uint32x4', |
| offset: 4512, |
| shaderLocation: 5, |
| }, { |
| format: 'uint16x2', |
| offset: 1136, |
| shaderLocation: 7, |
| }, { |
| format: 'uint32', |
| offset: 344, |
| shaderLocation: 9, |
| }, { |
| format: 'float32x4', |
| offset: 4860, |
| shaderLocation: 10, |
| }, { |
| format: 'float32x4', |
| offset: 1740, |
| shaderLocation: 1, |
| }, { |
| format: 'snorm8x2', |
| offset: 4806, |
| shaderLocation: 23, |
| }, { |
| format: 'sint16x2', |
| offset: 116, |
| shaderLocation: 15, |
| }, { |
| format: 'float32x3', |
| offset: 644, |
| shaderLocation: 22, |
| }, { |
| format: 'sint32', |
| offset: 2788, |
| shaderLocation: 18, |
| }, { |
| format: 'uint8x4', |
| offset: 1168, |
| shaderLocation: 8, |
| }, { |
| format: 'uint32x2', |
| offset: 2528, |
| shaderLocation: 13, |
| }], |
| }, |
| { |
| arrayStride: 11776, |
| stepMode: 'instance', |
| attributes: [], |
| }, |
| { |
| arrayStride: 3452, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'unorm8x2', |
| offset: 1040, |
| shaderLocation: 0, |
| }, { |
| format: 'sint32', |
| offset: 516, |
| shaderLocation: 20, |
| }, { |
| format: 'uint16x4', |
| offset: 340, |
| shaderLocation: 17, |
| }, { |
| format: 'sint16x4', |
| offset: 616, |
| shaderLocation: 11, |
| }, { |
| format: 'unorm8x4', |
| offset: 932, |
| shaderLocation: 2, |
| }, { |
| format: 'float32', |
| offset: 1276, |
| shaderLocation: 16, |
| }], |
| }, |
| { |
| arrayStride: 16104, |
| stepMode: 'vertex', |
| attributes: [], |
| }, |
| { |
| arrayStride: 1440, |
| attributes: [{ |
| format: 'snorm16x2', |
| offset: 856, |
| shaderLocation: 19, |
| }, { |
| format: 'sint8x2', |
| offset: 332, |
| shaderLocation: 12, |
| }], |
| } |
| ] |
| }, |
| primitive: { |
| cullMode: 'back', |
| unclippedDepth: true, |
| }, |
| }); |
| try { |
| if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(0x55) }; |
| } catch {} |
| let img27 = await imageWithData(160, 181, '#96f4acb0', '#4d4f2967'); |
| try { |
| gpuCanvasContext5.configure({ |
| device: device8, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rgba8unorm-srgb', 'astc-4x4-unorm-srgb', 'astc-12x10-unorm'], |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let sampler80 = device6.createSampler({ |
| label: '\u1362\u1236\ua265\u{1ff73}\u{1f821}\u44d1\u{1f71e}\u004e\uee41\u0c98\u0b50', |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 50.487, |
| maxAnisotropy: 7, |
| }); |
| let promise58 = device6.popErrorScope(); |
| let imageBitmap23 = await createImageBitmap(imageBitmap17); |
| let commandEncoder75 = device0.createCommandEncoder({label: '\ud42c\u{1f69e}\u9c57\u07c0\u7017\u2a6c'}); |
| let textureView89 = texture18.createView({label: '\u72c5\uc228\u95bc\u00aa\uf1e9\u0ae7\u7b89', dimension: '2d-array', mipLevelCount: 2}); |
| let renderBundleEncoder85 = device0.createRenderBundleEncoder({ |
| label: '\ud706\u8a7f\u0086\ue32b\u{1fbe4}\u682a\ua3d5\u{1fbae}\u{1fbbb}\u00fa', |
| colorFormats: ['r8uint', undefined, 'rg16sint', 'r8uint', 'rg8sint', 'rgba8unorm', 'r8sint', 'r16sint'], |
| depthStencilFormat: 'depth32float-stencil8', |
| sampleCount: 4 |
| }); |
| try { |
| renderBundleEncoder61.setBindGroup(0, bindGroup4, new Uint32Array(8505), 7060, 0); |
| } catch {} |
| let arrayBuffer14 = buffer6.getMappedRange(14120, 3256); |
| try { |
| commandEncoder75.copyBufferToBuffer(buffer16, 836, buffer3, 29888, 1304); |
| dissociateBuffer(device0, buffer16); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| commandEncoder75.copyTextureToBuffer({ |
| texture: texture2, |
| mipLevel: 0, |
| origin: { x: 336, y: 0, z: 1 }, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 4152 widthInBlocks: 519 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 26592 */ |
| offset: 26592, |
| bytesPerRow: 4352, |
| buffer: buffer12, |
| }, {width: 519, height: 1, depthOrArrayLayers: 0}); |
| dissociateBuffer(device0, buffer12); |
| } catch {} |
| try { |
| if (!arrayBuffer10.detached) { new Uint8Array(arrayBuffer10).fill(0x55) }; |
| } catch {} |
| let canvas32 = document.createElement('canvas'); |
| let commandEncoder76 = device8.createCommandEncoder({label: '\u{1f9fd}\u0760\u45a5\uae1c\u97b8\u0655\u08fc\u7d14\u{1ff58}\uca15\u{1fe1b}'}); |
| let renderBundle84 = renderBundleEncoder79.finish({label: '\u{1fec9}\u9cda\ue445\u17c9'}); |
| try { |
| if (!arrayBuffer11.detached) { new Uint8Array(arrayBuffer11).fill(0x55) }; |
| } catch {} |
| let video28 = await videoWithData(); |
| try { |
| if (!arrayBuffer5.detached) { new Uint8Array(arrayBuffer5).fill(0x55) }; |
| } catch {} |
| let sampler81 = device7.createSampler({ |
| label: '\u72ad\u1314\uab90\u5608', |
| addressModeU: 'mirror-repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 54.662, |
| lodMaxClamp: 68.184, |
| maxAnisotropy: 11, |
| }); |
| try { |
| commandEncoder74.copyBufferToBuffer(buffer40, 9212, buffer33, 5372, 5492); |
| dissociateBuffer(device7, buffer40); |
| dissociateBuffer(device7, buffer33); |
| } catch {} |
| let querySet66 = device2.createQuerySet({ |
| label: '\u0398\u9d7f', |
| type: 'occlusion', |
| count: 2179, |
| }); |
| let sampler82 = device2.createSampler({ |
| label: '\u{1f7d2}\ud521\u08ee\u162b\u531e\u{1f796}', |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| lodMinClamp: 6.024, |
| lodMaxClamp: 74.045, |
| }); |
| try { |
| renderBundleEncoder81.setBindGroup(0, bindGroup25); |
| } catch {} |
| let pipeline73 = device2.createRenderPipeline({ |
| layout: pipelineLayout11, |
| multisample: { |
| count: 4, |
| mask: 0x892db6c6, |
| }, |
| fragment: {module: shaderModule8, entryPoint: 'fragment0', targets: []}, |
| depthStencil: { |
| format: 'stencil8', |
| depthWriteEnabled: false, |
| stencilFront: { |
| compare: 'never', |
| failOp: 'replace', |
| passOp: 'increment-wrap', |
| }, |
| stencilBack: { |
| compare: 'less', |
| failOp: 'increment-clamp', |
| passOp: 'decrement-wrap', |
| }, |
| stencilWriteMask: 1028, |
| depthBiasSlopeScale: 41, |
| depthBiasClamp: 32, |
| }, |
| vertex: { |
| module: shaderModule8, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 24816, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'snorm16x2', |
| offset: 5304, |
| shaderLocation: 22, |
| }, { |
| format: 'uint32x4', |
| offset: 14624, |
| shaderLocation: 13, |
| }, { |
| format: 'float32', |
| offset: 11112, |
| shaderLocation: 12, |
| }, { |
| format: 'sint8x4', |
| offset: 748, |
| shaderLocation: 17, |
| }, { |
| format: 'sint32x2', |
| offset: 6756, |
| shaderLocation: 18, |
| }, { |
| format: 'uint32', |
| offset: 11708, |
| shaderLocation: 25, |
| }, { |
| format: 'uint8x2', |
| offset: 1080, |
| shaderLocation: 8, |
| }, { |
| format: 'uint32x3', |
| offset: 15612, |
| shaderLocation: 7, |
| }, { |
| format: 'snorm16x2', |
| offset: 20252, |
| shaderLocation: 21, |
| }, { |
| format: 'unorm10-10-10-2', |
| offset: 4960, |
| shaderLocation: 24, |
| }], |
| }, |
| { |
| arrayStride: 0, |
| stepMode: 'instance', |
| attributes: [{ |
| format: 'unorm10-10-10-2', |
| offset: 14924, |
| shaderLocation: 19, |
| }], |
| }, |
| { |
| arrayStride: 49292, |
| stepMode: 'instance', |
| attributes: [], |
| }, |
| { |
| arrayStride: 4260, |
| stepMode: 'instance', |
| attributes: [{ |
| format: 'snorm8x4', |
| offset: 224, |
| shaderLocation: 11, |
| }], |
| }, |
| { |
| arrayStride: 32080, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'snorm8x4', |
| offset: 8048, |
| shaderLocation: 3, |
| }], |
| }, |
| { |
| arrayStride: 47612, |
| stepMode: 'vertex', |
| attributes: [], |
| }, |
| { |
| arrayStride: 37136, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'snorm16x4', |
| offset: 32956, |
| shaderLocation: 20, |
| }, { |
| format: 'snorm8x2', |
| offset: 8000, |
| shaderLocation: 26, |
| }], |
| } |
| ] |
| }, |
| primitive: { |
| topology: 'triangle-strip', |
| stripIndexFormat: 'uint32', |
| frontFace: 'ccw', |
| cullMode: 'back', |
| }, |
| }); |
| try { |
| if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(0x55) }; |
| } catch {} |
| try { |
| await promise58; |
| } catch {} |
| let sampler83 = device7.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 20.642, |
| lodMaxClamp: 89.857, |
| }); |
| try { |
| renderBundleEncoder64.setVertexBuffer(13, undefined, 3637008638); |
| } catch {} |
| let arrayBuffer15 = buffer33.getMappedRange(10744, 56); |
| try { |
| commandEncoder74.copyBufferToBuffer(buffer40, 2684, buffer33, 7708, 2372); |
| dissociateBuffer(device7, buffer40); |
| dissociateBuffer(device7, buffer33); |
| } catch {} |
| try { |
| commandEncoder74.resolveQuerySet(querySet47, 1048, 20, buffer26, 15616); |
| } catch {} |
| try { |
| device7.queue.writeTexture({ |
| texture: texture96, |
| mipLevel: 2, |
| origin: { x: 0, y: 1, z: 21 }, |
| aspect: 'stencil-only', |
| }, new Float32Array(arrayBuffer7), /* required buffer size: 13952487 */ |
| {offset: 549, bytesPerRow: 598, rowsPerImage: 231}, {width: 312, height: 0, depthOrArrayLayers: 102}); |
| } catch {} |
| let pipeline74 = device7.createComputePipeline({ |
| label: '\ufee1\uaf8e\u680f\uc11c\ue483', |
| layout: pipelineLayout16, |
| compute: { |
| module: shaderModule15, |
| entryPoint: 'compute0', |
| constants: {}, |
| }, |
| }); |
| try { |
| await promise57; |
| } catch {} |
| gc(); |
| let querySet67 = device0.createQuerySet({ |
| label: '\u{1fcd5}\u0224\ued35\u3603', |
| type: 'occlusion', |
| count: 81, |
| }); |
| let texture116 = device0.createTexture({ |
| label: '\u8344\u684f\u4831\uf5c8\ub405\u25e7\ud533\u{1f760}\uc573\u0d91\u02d5', |
| size: {width: 1442, height: 96, depthOrArrayLayers: 1014}, |
| mipLevelCount: 5, |
| dimension: '3d', |
| format: 'rg16sint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rg16sint'], |
| }); |
| let textureView90 = texture60.createView({ |
| label: '\u{1fc84}\u0669\u05a5\u0eed\u{1f83b}\uf071\u{1fb87}', |
| dimension: '2d-array', |
| baseMipLevel: 5, |
| mipLevelCount: 1 |
| }); |
| try { |
| computePassEncoder39.setBindGroup(3, bindGroup5, new Uint32Array(4208), 1896, 0); |
| } catch {} |
| try { |
| renderBundleEncoder80.draw(72); |
| } catch {} |
| try { |
| renderBundleEncoder61.drawIndexedIndirect(buffer3, 18576); |
| } catch {} |
| try { |
| renderBundleEncoder80.setVertexBuffer(1, buffer32, 1064, 875); |
| } catch {} |
| try { |
| commandEncoder75.copyTextureToTexture({ |
| texture: texture19, |
| mipLevel: 2, |
| origin: { x: 57, y: 6, z: 26 }, |
| aspect: 'all', |
| }, { |
| texture: texture19, |
| mipLevel: 3, |
| origin: { x: 0, y: 0, z: 1 }, |
| aspect: 'all', |
| }, {width: 90, height: 6, depthOrArrayLayers: 79}); |
| } catch {} |
| try { |
| gpuCanvasContext3.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rgba16float', 'astc-6x5-unorm-srgb', 'rgba16float', 'astc-10x5-unorm'], |
| colorSpace: 'display-p3', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 40852, new Int16Array(39586), 13678, 1024); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 73, height: 1, depthOrArrayLayers: 29} |
| */ |
| { |
| source: canvas15, |
| origin: { x: 43, y: 26 }, |
| flipY: true, |
| }, { |
| texture: texture45, |
| mipLevel: 3, |
| origin: { x: 0, y: 0, z: 26 }, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 45, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| document.body.prepend(video1); |
| let offscreenCanvas33 = new OffscreenCanvas(462, 351); |
| let renderBundle85 = renderBundleEncoder83.finish(); |
| let promise59 = device7.queue.onSubmittedWorkDone(); |
| try { |
| gpuCanvasContext10.unconfigure(); |
| } catch {} |
| try { |
| if (!arrayBuffer6.detached) { new Uint8Array(arrayBuffer6).fill(0x55) }; |
| } catch {} |
| document.body.prepend(canvas11); |
| let img28 = await imageWithData(31, 75, '#b3e0427d', '#1fad1885'); |
| let imageBitmap24 = await createImageBitmap(canvas27); |
| let commandBuffer18 = commandEncoder73.finish({ |
| label: '\uc526\u{1ffa5}\u7ee6\u{1f96e}\u7d3b', |
| }); |
| try { |
| computePassEncoder53.setBindGroup(5, bindGroup25, new Uint32Array(3159), 2284, 0); |
| } catch {} |
| try { |
| commandEncoder48.resolveQuerySet(querySet39, 149, 52, buffer19, 56576); |
| } catch {} |
| try { |
| device2.queue.writeTexture({ |
| texture: texture107, |
| mipLevel: 1, |
| origin: { x: 236, y: 1, z: 0 }, |
| aspect: 'all', |
| }, arrayBuffer11, /* required buffer size: 934 */ |
| {offset: 934}, {width: 190, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let promise60 = device2.createComputePipelineAsync({ |
| label: '\ua44e\u{1fab9}\u{1f7e6}\u0674\u1a88', |
| layout: pipelineLayout11, |
| compute: { |
| module: shaderModule7, |
| entryPoint: 'compute0', |
| constants: {}, |
| }, |
| }); |
| let videoFrame24 = new VideoFrame(video12, {timestamp: 0}); |
| try { |
| if (!arrayBuffer11.detached) { new Uint8Array(arrayBuffer11).fill(0x55) }; |
| } catch {} |
| let device9 = await adapter11.requestDevice({ |
| label: '\u74e2\u034f\ua786\u931e', |
| requiredFeatures: [ |
| 'depth-clip-control', |
| 'depth32float-stencil8', |
| 'texture-compression-etc2', |
| 'texture-compression-astc', |
| 'indirect-first-instance', |
| 'shader-f16', |
| 'rg11b10ufloat-renderable', |
| 'bgra8unorm-storage' |
| ], |
| requiredLimits: { |
| maxBindGroups: 11, |
| maxColorAttachmentBytesPerSample: 41, |
| maxVertexAttributes: 29, |
| maxVertexBufferArrayStride: 47203, |
| maxStorageTexturesPerShaderStage: 11, |
| maxStorageBuffersPerShaderStage: 10, |
| maxDynamicStorageBuffersPerPipelineLayout: 52650, |
| maxBindingsPerBindGroup: 5558, |
| maxTextureDimension1D: 12656, |
| maxTextureDimension2D: 14700, |
| maxVertexBuffers: 12, |
| minStorageBufferOffsetAlignment: 64, |
| maxUniformBufferBindingSize: 57633682, |
| maxUniformBuffersPerShaderStage: 19, |
| maxInterStageShaderVariables: 34, |
| maxInterStageShaderComponents: 80, |
| maxSamplersPerShaderStage: 21, |
| }, |
| }); |
| let offscreenCanvas34 = new OffscreenCanvas(560, 459); |
| try { |
| offscreenCanvas33.getContext('webgl'); |
| } catch {} |
| let computePassEncoder61 = commandEncoder66.beginComputePass({}); |
| let renderBundle86 = renderBundleEncoder83.finish({}); |
| let sampler84 = device7.createSampler({ |
| label: '\u{1f6ba}\u039f\uc642\u066a\u{1fb4e}\ua926\uf4a0', |
| addressModeW: 'clamp-to-edge', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 83.378, |
| lodMaxClamp: 91.441, |
| }); |
| try { |
| computePassEncoder61.insertDebugMarker('\u1c44'); |
| } catch {} |
| try { |
| await promise59; |
| } catch {} |
| let video29 = await videoWithData(); |
| try { |
| canvas32.getContext('webgpu'); |
| } catch {} |
| let querySet68 = device6.createQuerySet({ |
| label: '\u60f7\uc3eb', |
| type: 'occlusion', |
| count: 1195, |
| }); |
| let textureView91 = texture100.createView({label: '\u779f\u0768\u6935\u1de1\u{1fa76}\u252d\u838a\u9578', baseMipLevel: 1}); |
| try { |
| commandEncoder61.clearBuffer(buffer30, 472, 36); |
| dissociateBuffer(device6, buffer30); |
| } catch {} |
| let promise61 = device6.queue.onSubmittedWorkDone(); |
| let texture117 = device6.createTexture({ |
| label: '\u0f0b\u0334\ud112\u{1f92e}\u079a\u022e\u0a3e\u09a8\u6271', |
| size: {width: 1980, height: 60, depthOrArrayLayers: 238}, |
| mipLevelCount: 10, |
| dimension: '3d', |
| format: 'rg16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rg16float', 'rg16float', 'rg16float'], |
| }); |
| let renderBundle87 = renderBundleEncoder60.finish({label: '\u{1fb9c}\u5125'}); |
| try { |
| commandEncoder61.clearBuffer(buffer30, 72, 136); |
| dissociateBuffer(device6, buffer30); |
| } catch {} |
| try { |
| await promise48; |
| } catch {} |
| let promise62 = adapter12.requestDevice({ |
| label: '\u03b7\ub8d5\u13aa\ub9be\u0b70\u{1f99d}\ua8e0\u028c\u0d70\u0a4a\u9435', |
| requiredFeatures: [ |
| 'depth-clip-control', |
| 'depth32float-stencil8', |
| 'texture-compression-etc2', |
| 'texture-compression-astc', |
| 'indirect-first-instance', |
| 'shader-f16', |
| 'rg11b10ufloat-renderable' |
| ], |
| }); |
| let texture118 = device9.createTexture({ |
| size: [40, 15, 47], |
| mipLevelCount: 4, |
| format: 'r8uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['r8uint'], |
| }); |
| try { |
| await promise50; |
| } catch {} |
| document.body.prepend(canvas3); |
| let textureView92 = texture107.createView({ |
| label: '\u0e83\ue912\u886f\ua075\u{1f9be}\u0aa9\udc7a\ue77d\u002f', |
| dimension: '2d-array', |
| baseMipLevel: 4 |
| }); |
| try { |
| computePassEncoder56.setPipeline(pipeline53); |
| } catch {} |
| try { |
| commandEncoder48.copyBufferToBuffer(buffer17, 3488, buffer19, 7124, 17876); |
| dissociateBuffer(device2, buffer17); |
| dissociateBuffer(device2, buffer19); |
| } catch {} |
| try { |
| device2.queue.writeTexture({ |
| texture: texture71, |
| mipLevel: 3, |
| origin: { x: 0, y: 10, z: 0 }, |
| aspect: 'stencil-only', |
| }, arrayBuffer10, /* required buffer size: 371 */ |
| {offset: 371}, {width: 40, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| let renderBundleEncoder86 = device7.createRenderBundleEncoder({ |
| label: '\u9923\u{1fe2d}\uffc4\ua435\u857b\u0692\ub2e6', |
| colorFormats: ['rg8unorm', 'rg16float', undefined, undefined, undefined, 'r16uint', 'rgba16uint'], |
| depthStencilFormat: 'depth24plus-stencil8', |
| sampleCount: 4 |
| }); |
| let renderBundle88 = renderBundleEncoder83.finish({label: '\u0bc8\ua7d5\ua695\u{1f99a}\u{1fd48}\ue1d8\u524e\ua56b\u9231\u08f7\u04a7'}); |
| try { |
| commandEncoder74.copyBufferToBuffer(buffer39, 412, buffer33, 9376, 816); |
| dissociateBuffer(device7, buffer39); |
| dissociateBuffer(device7, buffer33); |
| } catch {} |
| try { |
| device7.queue.writeTexture({ |
| texture: texture114, |
| mipLevel: 0, |
| origin: { x: 1021, y: 0, z: 0 }, |
| aspect: 'all', |
| }, arrayBuffer10, /* required buffer size: 4016 */ |
| {offset: 134}, {width: 3882, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| let pipeline75 = device7.createComputePipeline({ |
| label: '\u0b97\u054c\u84de', |
| layout: pipelineLayout18, |
| compute: { |
| module: shaderModule15, |
| entryPoint: 'compute0', |
| }, |
| }); |
| try { |
| await promise61; |
| } catch {} |
| let buffer41 = device6.createBuffer({size: 60202, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let textureView93 = texture85.createView({label: '\u43a0\u{1f649}\u814e\u02ef\u{1ff4c}\ud0ac', dimension: '2d-array', baseMipLevel: 2}); |
| try { |
| device6.queue.writeTexture({ |
| texture: texture108, |
| mipLevel: 0, |
| origin: { x: 179, y: 1, z: 1 }, |
| aspect: 'all', |
| }, new BigUint64Array(new ArrayBuffer(48)), /* required buffer size: 2913747 */ |
| {offset: 907, bytesPerRow: 404, rowsPerImage: 103}, {width: 192, height: 0, depthOrArrayLayers: 71}); |
| } catch {} |
| try { |
| if (!arrayBuffer6.detached) { new Uint8Array(arrayBuffer6).fill(0x55) }; |
| } catch {} |
| let bindGroupLayout41 = device7.createBindGroupLayout({ |
| entries: [{ |
| binding: 932, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', minBindingSize: 0, hasDynamicOffset: true }, |
| }, { |
| binding: 5657, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| sampler: { type: 'comparison' }, |
| }, { |
| binding: 930, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'uniform', minBindingSize: 0, hasDynamicOffset: false }, |
| }], |
| }); |
| let buffer42 = device7.createBuffer({ |
| label: '\u17cc\uba4c\u0ad2', |
| size: 41170, |
| usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX |
| }); |
| let renderBundle89 = renderBundleEncoder83.finish({label: '\u9b28\ufbf2\u662b\u7868\u8bc1\uc923\u170e\u51f0\u0c02'}); |
| let pipeline76 = device7.createRenderPipeline({ |
| label: '\u508a\u{1ff74}\u088c\u{1fe32}\ub67a\u0d57\u{1ff1e}\u{1f7cb}\u{1f90a}\u0816\u{1f603}', |
| layout: pipelineLayout16, |
| vertex: { |
| module: shaderModule15, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 3884, |
| stepMode: 'instance', |
| attributes: [{ |
| format: 'snorm8x2', |
| offset: 3870, |
| shaderLocation: 0, |
| }, { |
| format: 'float16x4', |
| offset: 3600, |
| shaderLocation: 14, |
| }, { |
| format: 'snorm8x2', |
| offset: 1246, |
| shaderLocation: 16, |
| }, { |
| format: 'snorm16x2', |
| offset: 1172, |
| shaderLocation: 10, |
| }, { |
| format: 'unorm8x2', |
| offset: 3588, |
| shaderLocation: 23, |
| }, { |
| format: 'uint32x2', |
| offset: 1836, |
| shaderLocation: 17, |
| }, { |
| format: 'snorm8x4', |
| offset: 760, |
| shaderLocation: 22, |
| }, { |
| format: 'uint32', |
| offset: 1576, |
| shaderLocation: 3, |
| }], |
| }, |
| { |
| arrayStride: 10188, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'snorm8x2', |
| offset: 264, |
| shaderLocation: 19, |
| }, { |
| format: 'sint8x4', |
| offset: 4064, |
| shaderLocation: 12, |
| }], |
| }, |
| { |
| arrayStride: 13268, |
| stepMode: 'instance', |
| attributes: [{ |
| format: 'float32x3', |
| offset: 5380, |
| shaderLocation: 1, |
| }, { |
| format: 'sint32', |
| offset: 3328, |
| shaderLocation: 4, |
| }, { |
| format: 'sint16x4', |
| offset: 664, |
| shaderLocation: 18, |
| }, { |
| format: 'sint32', |
| offset: 10336, |
| shaderLocation: 20, |
| }, { |
| format: 'uint16x4', |
| offset: 9816, |
| shaderLocation: 7, |
| }, { |
| format: 'snorm8x2', |
| offset: 3928, |
| shaderLocation: 2, |
| }], |
| }, |
| { |
| arrayStride: 14744, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'sint32', |
| offset: 7952, |
| shaderLocation: 6, |
| }, { |
| format: 'sint32', |
| offset: 6900, |
| shaderLocation: 21, |
| }, { |
| format: 'sint32x3', |
| offset: 9500, |
| shaderLocation: 15, |
| }], |
| }, |
| { |
| arrayStride: 5092, |
| attributes: [{ |
| format: 'uint8x2', |
| offset: 3518, |
| shaderLocation: 13, |
| }], |
| }, |
| { |
| arrayStride: 1232, |
| stepMode: 'instance', |
| attributes: [], |
| }, |
| { |
| arrayStride: 3360, |
| stepMode: 'instance', |
| attributes: [{ |
| format: 'sint32x3', |
| offset: 2660, |
| shaderLocation: 11, |
| }, { |
| format: 'uint8x2', |
| offset: 566, |
| shaderLocation: 5, |
| }, { |
| format: 'uint16x2', |
| offset: 1480, |
| shaderLocation: 8, |
| }], |
| }, |
| { |
| arrayStride: 11904, |
| stepMode: 'vertex', |
| attributes: [], |
| }, |
| { |
| arrayStride: 0, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'uint16x2', |
| offset: 7448, |
| shaderLocation: 9, |
| }], |
| } |
| ] |
| }, |
| primitive: { |
| topology: 'point-list', |
| frontFace: 'cw', |
| cullMode: 'back', |
| unclippedDepth: true, |
| }, |
| }); |
| try { |
| window.someLabel = device2.label; |
| } catch {} |
| try { |
| window.someLabel = pipeline62.label; |
| } catch {} |
| let shaderModule19 = device2.createShaderModule({ |
| code: `@group(4) @binding(3183) |
| var<storage, read_write> type9: array<u32>; |
| @group(8) @binding(2585) |
| var<storage, read_write> i18: array<u32>; |
| @group(5) @binding(3183) |
| var<storage, read_write> global12: array<u32>; |
| @group(3) @binding(3183) |
| var<storage, read_write> field20: array<u32>; |
| @group(5) @binding(2585) |
| var<storage, read_write> local11: array<u32>; |
| @group(0) @binding(2585) |
| var<storage, read_write> i19: array<u32>; |
| @group(6) @binding(2585) |
| var<storage, read_write> i20: array<u32>; |
| @group(8) @binding(3183) |
| var<storage, read_write> type10: array<u32>; |
| @group(6) @binding(3183) |
| var<storage, read_write> parameter19: array<u32>; |
| @group(3) @binding(2585) |
| var<storage, read_write> global13: array<u32>; |
| @group(1) @binding(2585) |
| var<storage, read_write> type11: array<u32>; |
| @group(4) @binding(2585) |
| var<storage, read_write> function20: array<u32>; |
| @group(2) @binding(2585) |
| var<storage, read_write> i21: array<u32>; |
| @group(7) @binding(3183) |
| var<storage, read_write> i22: array<u32>; |
| @group(1) @binding(3183) |
| var<storage, read_write> parameter20: array<u32>; |
| |
| @compute @workgroup_size(5, 2, 4) |
| fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {} |
| |
| struct FragmentOutput0 { |
| @location(0) f0: vec4<f32>, |
| @location(3) f1: vec4<f32>, |
| @location(2) f2: vec4<u32>, |
| @location(1) f3: vec4<f32>, |
| @location(5) f4: vec3<u32> |
| } |
| |
| @fragment |
| fn fragment0(@builtin(front_facing) a0: bool, @builtin(sample_mask) a1: u32) -> FragmentOutput0 { |
| return FragmentOutput0(); |
| } |
| |
| struct VertexOutput0 { |
| @builtin(position) f218: vec4<f32> |
| } |
| |
| @vertex |
| fn vertex0() -> VertexOutput0 { |
| return VertexOutput0(); |
| } |
| |
| `, |
| sourceMap: {}, |
| }); |
| let buffer43 = device2.createBuffer({ |
| label: '\u0d6e\uccb9\udcc3\u07e4\ud822', |
| size: 19740, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ |
| }); |
| let commandEncoder77 = device2.createCommandEncoder(); |
| let texture119 = device2.createTexture({ |
| label: '\ufa1a\u{1fd41}\u{1f772}\u990e\u{1fb95}', |
| size: [761], |
| dimension: '1d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| viewFormats: [], |
| }); |
| let computePassEncoder62 = commandEncoder77.beginComputePass({label: '\u00aa\ud464\u00f6\u{1fe1b}\u5f91\u66df\u0e94\u5eec\u1324\u{1f9d2}'}); |
| try { |
| renderBundleEncoder77.setVertexBuffer(83, undefined); |
| } catch {} |
| let promise63 = device2.createRenderPipelineAsync({ |
| label: '\u6f59\ufcf9\u0bfd\u0402', |
| layout: pipelineLayout11, |
| fragment: { |
| module: shaderModule18, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{ |
| format: 'bgra8unorm', |
| blend: { |
| color: {operation: 'subtract', srcFactor: 'zero', dstFactor: 'src-alpha'}, |
| alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'}, |
| }, |
| writeMask: GPUColorWrite.RED |
| }, { |
| format: 'rgba8unorm-srgb', |
| blend: { |
| color: {operation: 'subtract', srcFactor: 'one-minus-src', dstFactor: 'src'}, |
| alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'}, |
| } |
| }, {format: 'rg32uint'}, { |
| format: 'bgra8unorm-srgb', |
| blend: { |
| color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'}, |
| alpha: {operation: 'add', srcFactor: 'dst', dstFactor: 'src-alpha'}, |
| }, |
| writeMask: 0 |
| }, undefined, {format: 'rg16uint', writeMask: 0}] |
| }, |
| depthStencil: { |
| format: 'depth24plus-stencil8', |
| depthWriteEnabled: false, |
| depthCompare: 'less-equal', |
| stencilFront: { |
| compare: 'greater', |
| failOp: 'increment-wrap', |
| depthFailOp: 'decrement-clamp', |
| passOp: 'invert', |
| }, |
| stencilBack: { |
| compare: 'less', |
| failOp: 'zero', |
| depthFailOp: 'increment-clamp', |
| passOp: 'replace', |
| }, |
| stencilReadMask: 3893, |
| depthBiasSlopeScale: 24, |
| depthBiasClamp: 30, |
| }, |
| vertex: { |
| module: shaderModule18, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 3400, |
| stepMode: 'instance', |
| attributes: [{ |
| format: 'sint32x3', |
| offset: 2816, |
| shaderLocation: 1, |
| }, { |
| format: 'snorm8x4', |
| offset: 1936, |
| shaderLocation: 24, |
| }, { |
| format: 'sint32x4', |
| offset: 1420, |
| shaderLocation: 26, |
| }, { |
| format: 'sint16x4', |
| offset: 2608, |
| shaderLocation: 13, |
| }], |
| }, |
| { |
| arrayStride: 38008, |
| stepMode: 'instance', |
| attributes: [{ |
| format: 'snorm8x2', |
| offset: 17878, |
| shaderLocation: 20, |
| }, { |
| format: 'sint8x2', |
| offset: 16744, |
| shaderLocation: 14, |
| }, { |
| format: 'sint8x2', |
| offset: 11560, |
| shaderLocation: 7, |
| }, { |
| format: 'uint8x2', |
| offset: 37186, |
| shaderLocation: 15, |
| }, { |
| format: 'float32x2', |
| offset: 3196, |
| shaderLocation: 19, |
| }, { |
| format: 'uint32x3', |
| offset: 4456, |
| shaderLocation: 12, |
| }, { |
| format: 'float32x4', |
| offset: 18032, |
| shaderLocation: 10, |
| }], |
| }, |
| { |
| arrayStride: 0, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'uint32x3', |
| offset: 11128, |
| shaderLocation: 18, |
| }, { |
| format: 'float16x2', |
| offset: 9816, |
| shaderLocation: 21, |
| }, { |
| format: 'sint16x4', |
| offset: 29480, |
| shaderLocation: 6, |
| }, { |
| format: 'sint32x2', |
| offset: 52068, |
| shaderLocation: 9, |
| }, { |
| format: 'snorm8x4', |
| offset: 50732, |
| shaderLocation: 25, |
| }, { |
| format: 'float16x2', |
| offset: 47720, |
| shaderLocation: 4, |
| }, { |
| format: 'float16x2', |
| offset: 23036, |
| shaderLocation: 0, |
| }], |
| } |
| ] |
| }, |
| primitive: { |
| topology: 'triangle-strip', |
| frontFace: 'cw', |
| }, |
| }); |
| let imageData33 = new ImageData(232, 204); |
| let shaderModule20 = device2.createShaderModule({ |
| code: `@group(4) @binding(2585) |
| var<storage, read_write> function21: array<u32>; |
| @group(2) @binding(2585) |
| var<storage, read_write> i23: array<u32>; |
| @group(0) @binding(3183) |
| var<storage, read_write> local12: array<u32>; |
| @group(3) @binding(2585) |
| var<storage, read_write> local13: array<u32>; |
| @group(5) @binding(3183) |
| var<storage, read_write> local14: array<u32>; |
| @group(0) @binding(2585) |
| var<storage, read_write> global14: array<u32>; |
| @group(8) @binding(3183) |
| var<storage, read_write> i24: array<u32>; |
| @group(6) @binding(3183) |
| var<storage, read_write> field21: array<u32>; |
| @group(4) @binding(3183) |
| var<storage, read_write> i25: array<u32>; |
| @group(5) @binding(2585) |
| var<storage, read_write> type12: array<u32>; |
| @group(1) @binding(3183) |
| var<storage, read_write> local15: array<u32>; |
| @group(1) @binding(2585) |
| var<storage, read_write> field22: array<u32>; |
| @group(8) @binding(2585) |
| var<storage, read_write> parameter21: array<u32>; |
| @group(3) @binding(3183) |
| var<storage, read_write> global15: array<u32>; |
| |
| @compute @workgroup_size(7, 2, 4) |
| fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {} |
| |
| struct FragmentOutput0 { |
| @builtin(frag_depth) f0: f32, |
| @location(5) f1: vec4<u32>, |
| @location(3) f2: vec4<f32>, |
| @location(2) f3: vec2<u32>, |
| @location(1) f4: vec4<f32>, |
| @builtin(sample_mask) f5: u32, |
| @location(0) f6: vec4<f32>, |
| @location(4) f7: vec3<u32> |
| } |
| |
| @fragment |
| fn fragment0(@location(25) a0: vec2<f16>, @location(16) a1: f32, @location(17) a2: vec4<u32>, @location(30) a3: vec2<f16>) -> FragmentOutput0 { |
| return FragmentOutput0(); |
| } |
| |
| struct S21 { |
| @builtin(instance_index) f0: u32, |
| @location(13) f1: vec3<i32>, |
| @location(10) f2: vec2<f32>, |
| @location(24) f3: f16, |
| @location(6) f4: vec3<f32>, |
| @location(18) f5: f32, |
| @location(8) f6: i32, |
| @location(1) f7: vec3<f32>, |
| @location(17) f8: f32, |
| @location(16) f9: vec4<f32>, |
| @location(19) f10: f32, |
| @location(20) f11: vec3<i32>, |
| @location(22) f12: vec4<f32>, |
| @location(2) f13: vec2<u32>, |
| @location(12) f14: vec3<i32>, |
| @location(9) f15: vec4<f32>, |
| @location(15) f16: vec4<f32>, |
| @location(26) f17: f16, |
| @location(3) f18: vec4<f32> |
| } |
| struct VertexOutput0 { |
| @location(20) f219: vec3<i32>, |
| @location(25) f220: vec2<f16>, |
| @location(16) f221: f32, |
| @location(10) f222: vec3<u32>, |
| @location(3) f223: f16, |
| @location(5) f224: u32, |
| @location(26) f225: vec2<f16>, |
| @location(23) f226: u32, |
| @location(17) f227: vec4<u32>, |
| @builtin(position) f228: vec4<f32>, |
| @location(30) f229: vec2<f16> |
| } |
| |
| @vertex |
| fn vertex0(@builtin(vertex_index) a0: u32, @location(14) a1: vec2<f16>, @location(25) a2: vec2<u32>, a3: S21, @location(23) a4: u32) -> VertexOutput0 { |
| return VertexOutput0(); |
| } |
| |
| `, |
| sourceMap: {}, |
| }); |
| let texture120 = device2.createTexture({ |
| size: [828, 60, 1079], |
| mipLevelCount: 6, |
| dimension: '3d', |
| format: 'rg32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rg32sint', 'rg32sint'], |
| }); |
| let renderBundle90 = renderBundleEncoder35.finish({label: '\u7052\u7005\u{1fd47}\u51a3\uc0f0\u01a3\u43d1\u2a16'}); |
| let video30 = await videoWithData(); |
| let bindGroupLayout42 = device2.createBindGroupLayout({ |
| label: '\u2fb2\u6b15\u01a9\u0815\ued90\u1b9b\u{1ffec}\u0e54', |
| entries: [{ |
| binding: 835, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| externalTexture: {}, |
| }, { |
| binding: 3233, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba32sint', access: 'read-only', viewDimension: '3d' }, |
| }, { |
| binding: 1720, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d-array', sampleType: 'uint', multisampled: false }, |
| }], |
| }); |
| try { |
| device2.queue.writeTexture({ |
| texture: texture71, |
| mipLevel: 2, |
| origin: { x: 0, y: 12, z: 0 }, |
| aspect: 'stencil-only', |
| }, arrayBuffer3, /* required buffer size: 964 */ |
| {offset: 964}, {width: 80, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| let img29 = await imageWithData(237, 211, '#ae1272ba', '#7486688f'); |
| let commandEncoder78 = device7.createCommandEncoder({label: '\uf8ff\u085e\u4b1d\u0599\ub40e'}); |
| try { |
| commandEncoder74.copyBufferToBuffer(buffer40, 6420, buffer33, 1184, 7860); |
| dissociateBuffer(device7, buffer40); |
| dissociateBuffer(device7, buffer33); |
| } catch {} |
| try { |
| device7.queue.submit([ |
| commandBuffer14, |
| ]); |
| } catch {} |
| let video31 = await videoWithData(); |
| let renderBundle91 = renderBundleEncoder70.finish({label: '\ua3ef\u0a32\u0b20\u959d\u397f'}); |
| try { |
| renderBundleEncoder76.setVertexBuffer(4, buffer30, 156, 186); |
| } catch {} |
| let promise64 = buffer25.mapAsync(GPUMapMode.WRITE); |
| try { |
| commandEncoder61.clearBuffer(buffer41, 32336, 6884); |
| dissociateBuffer(device6, buffer41); |
| } catch {} |
| try { |
| commandEncoder61.resolveQuerySet(querySet65, 70, 530, buffer34, 22272); |
| } catch {} |
| try { |
| device6.queue.writeTexture({ |
| texture: texture86, |
| mipLevel: 0, |
| origin: { x: 264, y: 1, z: 0 }, |
| aspect: 'all', |
| }, arrayBuffer11, /* required buffer size: 798 */ |
| {offset: 798}, {width: 609, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let querySet69 = device0.createQuerySet({ |
| type: 'occlusion', |
| count: 2579, |
| }); |
| let renderBundleEncoder87 = device0.createRenderBundleEncoder({colorFormats: ['rgba8unorm', 'r8sint', undefined], sampleCount: 4, depthReadOnly: true}); |
| let renderBundle92 = renderBundleEncoder53.finish({label: '\ub70a\u02d2\ubff5\u61df\ub3ab\u3859\u0022\u063d'}); |
| try { |
| commandEncoder75.resolveQuerySet(querySet21, 147, 791, buffer12, 27904); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture26, |
| mipLevel: 0, |
| origin: { x: 239, y: 0, z: 0 }, |
| aspect: 'all', |
| }, arrayBuffer3, /* required buffer size: 9144 */ |
| {offset: 44}, {width: 2275, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| await promise51; |
| } catch {} |
| document.body.prepend(img17); |
| let bindGroupLayout43 = device7.createBindGroupLayout({ |
| label: '\u04df\u8eb4\u14fe\uf69d\u58cf\u0ba2', |
| entries: [{ |
| binding: 4028, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rgba16float', access: 'read-only', viewDimension: '1d' }, |
| }, { |
| binding: 3740, |
| visibility: GPUShaderStage.VERTEX, |
| externalTexture: {}, |
| }], |
| }); |
| let buffer44 = device7.createBuffer({ |
| label: '\u0ecb\u8312\u052d\u134d', |
| size: 59847, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE |
| }); |
| let pipeline77 = device7.createComputePipeline({ |
| label: '\u3352\uc03f\u0896\u02e3\u64fa\u0854\u{1fa4f}\uf156\u0c20\u{1fb36}\u{1fa7b}', |
| layout: pipelineLayout16, |
| compute: { |
| module: shaderModule15, |
| entryPoint: 'compute0', |
| }, |
| }); |
| let adapter13 = await promise56; |
| try { |
| await promise52; |
| } catch {} |
| let bindGroupLayout44 = device7.createBindGroupLayout({ |
| entries: [{ |
| binding: 4461, |
| visibility: 0, |
| sampler: { type: 'filtering' }, |
| }], |
| }); |
| let texture121 = device7.createTexture({ |
| label: '\ub13d\u0338\ufd41\u{1ff2f}\ue3c1\ue3cf\u12ef', |
| size: {width: 9984, height: 1, depthOrArrayLayers: 2}, |
| mipLevelCount: 11, |
| format: 'depth24plus-stencil8', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: ['depth24plus-stencil8'], |
| }); |
| let renderBundleEncoder88 = device7.createRenderBundleEncoder({ |
| label: '\u61ce\u5ac1\u04ad\ued16\uafbe\u{1fbc3}\ub5cb\u0cf7', |
| colorFormats: [], |
| depthStencilFormat: 'depth32float-stencil8' |
| }); |
| let renderBundle93 = renderBundleEncoder86.finish({label: '\u8f1d\ua5e1\u{1fc13}\u1d14\u63ec\u3d78\u015c'}); |
| let sampler85 = device7.createSampler({ |
| label: '\u{1f83e}\u71be\u2250\u042b\u03b3\u09b6\u5bf1\u94c0\u0b4e', |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| lodMaxClamp: 86.301, |
| compare: 'always', |
| }); |
| try { |
| renderBundleEncoder64.setVertexBuffer(10, buffer42, 14432, 9368); |
| } catch {} |
| try { |
| commandEncoder74.copyBufferToBuffer(buffer39, 10772, buffer40, 9628, 2352); |
| dissociateBuffer(device7, buffer39); |
| dissociateBuffer(device7, buffer40); |
| } catch {} |
| try { |
| device7.queue.writeBuffer(buffer40, 10208, new DataView(new ArrayBuffer(28629)), 23166, 2188); |
| } catch {} |
| let pipeline78 = device7.createComputePipeline({ |
| label: '\u{1f7a7}\u00ee\uf0fa\u{1fd67}\ua768\u13b4\u0649\u0a93\u{1f8ca}\u2ce4\u0025', |
| layout: pipelineLayout16, |
| compute: { |
| module: shaderModule15, |
| entryPoint: 'compute0', |
| constants: {}, |
| }, |
| }); |
| let bindGroup32 = device0.createBindGroup({ |
| label: '\u4dd5\u3f75\u5e13\u6b35\uc485\u7c88\u{1ffa9}\uc212\u80e5', |
| layout: bindGroupLayout4, |
| entries: [], |
| }); |
| let buffer45 = device0.createBuffer({ |
| label: '\ud0c6\u9b6c\u9330\uaec5\u03ec\u{1f881}\u01a7\u0984\u0fa6\u0cab', |
| size: 58308, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM, |
| mappedAtCreation: true |
| }); |
| let texture122 = device0.createTexture({ |
| label: '\u1d47\ue30e\u1143\u0a44\u{1fb41}\u4813\u94eb\u9887\u{1fae8}\uf3d3', |
| size: [20, 240, 1], |
| mipLevelCount: 7, |
| format: 'stencil8', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView94 = texture12.createView({dimension: '2d', aspect: 'all', baseMipLevel: 2, mipLevelCount: 1, baseArrayLayer: 244, arrayLayerCount: 1}); |
| try { |
| renderBundleEncoder80.drawIndexedIndirect(buffer3, 8000); |
| } catch {} |
| try { |
| renderBundleEncoder38.drawIndirect(buffer36, 21348); |
| } catch {} |
| try { |
| buffer0.unmap(); |
| } catch {} |
| try { |
| commandEncoder75.clearBuffer(buffer23, 27620, 13236); |
| dissociateBuffer(device0, buffer23); |
| } catch {} |
| let pipeline79 = await promise53; |
| let imageData34 = new ImageData(112, 220); |
| try { |
| renderBundleEncoder61.draw(56, 64, 0); |
| } catch {} |
| try { |
| renderBundleEncoder17.setVertexBuffer(0, buffer32, 1304); |
| } catch {} |
| try { |
| commandEncoder75.copyBufferToBuffer(buffer37, 13408, buffer3, 26920, 1940); |
| dissociateBuffer(device0, buffer37); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| commandEncoder75.clearBuffer(buffer3); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| gpuCanvasContext16.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rgba32sint', 'rgba8uint'], |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer12, 24400, new DataView(new ArrayBuffer(61873)), 6389, 316); |
| } catch {} |
| try { |
| await promise64; |
| } catch {} |
| let commandEncoder79 = device2.createCommandEncoder(); |
| let querySet70 = device2.createQuerySet({ |
| label: '\u0f63\ucaea\u{1fa97}\u894d\ue68c', |
| type: 'occlusion', |
| count: 1565, |
| }); |
| let commandBuffer19 = commandEncoder79.finish({ |
| label: '\u038b\u{1ff26}\u2bbd\u{1fdcd}\u0c1f\u0bea\u1468\u073d\u0a22\u{1fc16}\u7202', |
| }); |
| let textureView95 = texture101.createView({label: '\u0449\u12cb\u039f\u094e\u8d0d\udb51\uc23c\u3e80\u0f41\u0d30\ub137', dimension: '2d-array'}); |
| let renderBundle94 = renderBundleEncoder59.finish({label: '\u1dd3\u0fe1\u{1fc00}\u08fa\u{1f614}\u{1fbe0}\u4161\u40e5\u808b\uf0c0\ud7be'}); |
| try { |
| computePassEncoder62.setBindGroup(3, bindGroup25); |
| } catch {} |
| try { |
| renderBundleEncoder84.setBindGroup(4, bindGroup25); |
| } catch {} |
| try { |
| computePassEncoder23.insertDebugMarker('\u6619'); |
| } catch {} |
| try { |
| device2.queue.writeBuffer(buffer43, 17524, new Float32Array(33544), 16579, 392); |
| } catch {} |
| let gpuCanvasContext31 = offscreenCanvas34.getContext('webgpu'); |
| offscreenCanvas31.width = 239; |
| let commandEncoder80 = device7.createCommandEncoder({label: '\u5cbb\u08f8\u01c6\ud570\u0884\u{1fb55}\u{1fb4c}\u{1fd40}\u543f\u5f43\uc729'}); |
| try { |
| commandEncoder80.clearBuffer(buffer33, 5848, 4088); |
| dissociateBuffer(device7, buffer33); |
| } catch {} |
| try { |
| commandEncoder80.resolveQuerySet(querySet48, 550, 262, buffer26, 24832); |
| } catch {} |
| let video32 = await videoWithData(); |
| document.body.prepend(img8); |
| gc(); |
| let textureView96 = texture109.createView({dimension: '2d-array', format: 'etc2-rgba8unorm', baseMipLevel: 9, baseArrayLayer: 0, arrayLayerCount: 1}); |
| try { |
| device8.queue.writeTexture({ |
| texture: texture104, |
| mipLevel: 1, |
| origin: { x: 40, y: 60, z: 23 }, |
| aspect: 'all', |
| }, new Int8Array(arrayBuffer10), /* required buffer size: 52461 */ |
| {offset: 981, bytesPerRow: 44, rowsPerImage: 8}, {width: 0, height: 30, depthOrArrayLayers: 147}); |
| } catch {} |
| let texture123 = device6.createTexture({ |
| label: '\u0c96\u072e\u92b8\u38bd\u26ba', |
| size: {width: 564, height: 1, depthOrArrayLayers: 111}, |
| mipLevelCount: 10, |
| sampleCount: 1, |
| format: 'r16uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['r16uint'], |
| }); |
| let renderBundleEncoder89 = device6.createRenderBundleEncoder({colorFormats: ['rgba8unorm-srgb'], depthStencilFormat: 'depth24plus-stencil8', stencilReadOnly: true}); |
| let renderBundle95 = renderBundleEncoder74.finish({label: '\u282e\u8339\ueed9\u{1fbac}\u08be\u1cfb'}); |
| try { |
| commandEncoder61.copyBufferToBuffer(buffer31, 25312, buffer41, 57292, 2132); |
| dissociateBuffer(device6, buffer31); |
| dissociateBuffer(device6, buffer41); |
| } catch {} |
| try { |
| device6.queue.writeBuffer(buffer41, 2176, new DataView(new ArrayBuffer(19576)), 12787, 4556); |
| } catch {} |
| document.body.prepend(canvas28); |
| try { |
| renderBundleEncoder88.setVertexBuffer(4, buffer42, 18316); |
| } catch {} |
| try { |
| commandEncoder78.copyBufferToBuffer(buffer39, 12796, buffer33, 1408, 616); |
| dissociateBuffer(device7, buffer39); |
| dissociateBuffer(device7, buffer33); |
| } catch {} |
| try { |
| commandEncoder78.clearBuffer(buffer40, 7060, 3860); |
| dissociateBuffer(device7, buffer40); |
| } catch {} |
| try { |
| gpuCanvasContext17.configure({ |
| device: device7, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| try { |
| device7.queue.writeTexture({ |
| texture: texture115, |
| mipLevel: 0, |
| origin: { x: 751, y: 1, z: 1 }, |
| aspect: 'all', |
| }, new ArrayBuffer(32), /* required buffer size: 117 */ |
| {offset: 117}, {width: 378, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55) }; |
| } catch {} |
| let texture124 = device9.createTexture({ |
| label: '\u0d87\u911a\ua70e\uae70\u5ee3\ue673\u{1fb38}\u5ca8', |
| size: [512, 120, 1], |
| mipLevelCount: 4, |
| format: 'etc2-rgb8a1unorm', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['etc2-rgb8a1unorm'], |
| }); |
| let renderBundleEncoder90 = device9.createRenderBundleEncoder({ |
| colorFormats: [undefined, 'rgba8sint', 'rg32float', 'bgra8unorm', 'rg32uint', 'r32uint'], |
| depthStencilFormat: 'depth32float-stencil8', |
| sampleCount: 4, |
| depthReadOnly: true |
| }); |
| let commandEncoder81 = device9.createCommandEncoder({}); |
| let textureView97 = texture118.createView({ |
| label: '\u4bc2\ue945\u76ec\u2ae9\ua420\u6194\u6624', |
| dimension: '2d', |
| aspect: 'all', |
| baseMipLevel: 1, |
| mipLevelCount: 1, |
| baseArrayLayer: 38 |
| }); |
| let sampler86 = device9.createSampler({ |
| label: '\u{1fac3}\ua1ab\ue3a4\u2861\u3cfa\u20a2\u0404\u{1f9e2}\u184f', |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'repeat', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 13.932, |
| lodMaxClamp: 71.712, |
| compare: 'never', |
| }); |
| try { |
| gpuCanvasContext20.configure({ |
| device: device9, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rgba8unorm-srgb', 'depth24plus', 'rgba8unorm-srgb'], |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let computePassEncoder63 = commandEncoder61.beginComputePass({label: '\uc6d4\u01f1\u{1f8fa}\u2003\u87be'}); |
| try { |
| computePassEncoder63.end(); |
| } catch {} |
| try { |
| commandEncoder61.copyBufferToBuffer(buffer31, 15960, buffer41, 44352, 6632); |
| dissociateBuffer(device6, buffer31); |
| dissociateBuffer(device6, buffer41); |
| } catch {} |
| try { |
| commandEncoder61.clearBuffer(buffer41, 23784, 30552); |
| dissociateBuffer(device6, buffer41); |
| } catch {} |
| try { |
| gpuCanvasContext14.configure({ |
| device: device6, |
| format: 'bgra8unorm', |
| usage: 0, |
| viewFormats: ['bgra8unorm-srgb'], |
| colorSpace: 'display-p3', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| if (!arrayBuffer5.detached) { new Uint8Array(arrayBuffer5).fill(0x55) }; |
| } catch {} |
| let texture125 = device7.createTexture({ |
| label: '\uee4d\u089e', |
| size: {width: 1680, height: 80, depthOrArrayLayers: 3}, |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: ['r32uint', 'r32uint', 'r32uint'], |
| }); |
| try { |
| commandEncoder74.copyBufferToBuffer(buffer40, 22664, buffer33, 1392, 2504); |
| dissociateBuffer(device7, buffer40); |
| dissociateBuffer(device7, buffer33); |
| } catch {} |
| try { |
| commandEncoder78.resolveQuerySet(querySet58, 1427, 106, buffer26, 23808); |
| } catch {} |
| let promise65 = device7.queue.onSubmittedWorkDone(); |
| let pipeline80 = device7.createRenderPipeline({ |
| label: '\u0c73\u6e7e', |
| layout: pipelineLayout18, |
| multisample: { |
| count: 4, |
| mask: 0xdf2c1dd3, |
| }, |
| fragment: {module: shaderModule15, entryPoint: 'fragment0', constants: {}, targets: []}, |
| depthStencil: { |
| format: 'depth32float-stencil8', |
| depthWriteEnabled: false, |
| depthCompare: 'never', |
| stencilFront: { |
| compare: 'not-equal', |
| failOp: 'increment-clamp', |
| depthFailOp: 'zero', |
| passOp: 'replace', |
| }, |
| stencilBack: { |
| compare: 'greater-equal', |
| failOp: 'invert', |
| depthFailOp: 'zero', |
| passOp: 'decrement-wrap', |
| }, |
| stencilReadMask: 3710, |
| stencilWriteMask: 1915, |
| depthBias: 30, |
| depthBiasSlopeScale: 100, |
| depthBiasClamp: 92, |
| }, |
| vertex: { |
| module: shaderModule15, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 9228, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'unorm10-10-10-2', |
| offset: 2928, |
| shaderLocation: 1, |
| }, { |
| format: 'float32x3', |
| offset: 924, |
| shaderLocation: 22, |
| }, { |
| format: 'sint8x4', |
| offset: 7228, |
| shaderLocation: 18, |
| }, { |
| format: 'uint32', |
| offset: 5848, |
| shaderLocation: 9, |
| }, { |
| format: 'sint32x4', |
| offset: 8148, |
| shaderLocation: 21, |
| }, { |
| format: 'sint16x4', |
| offset: 6792, |
| shaderLocation: 15, |
| }, { |
| format: 'float16x4', |
| offset: 2908, |
| shaderLocation: 23, |
| }, { |
| format: 'uint16x2', |
| offset: 1772, |
| shaderLocation: 17, |
| }, { |
| format: 'uint16x2', |
| offset: 2076, |
| shaderLocation: 7, |
| }, { |
| format: 'sint32x2', |
| offset: 8048, |
| shaderLocation: 11, |
| }], |
| }, |
| { |
| arrayStride: 1980, |
| stepMode: 'instance', |
| attributes: [{ |
| format: 'snorm8x4', |
| offset: 1600, |
| shaderLocation: 16, |
| }, { |
| format: 'sint8x2', |
| offset: 1218, |
| shaderLocation: 4, |
| }, { |
| format: 'unorm8x4', |
| offset: 96, |
| shaderLocation: 19, |
| }, { |
| format: 'unorm10-10-10-2', |
| offset: 232, |
| shaderLocation: 14, |
| }, { |
| format: 'sint32', |
| offset: 1964, |
| shaderLocation: 12, |
| }, { |
| format: 'unorm10-10-10-2', |
| offset: 56, |
| shaderLocation: 0, |
| }, { |
| format: 'float32', |
| offset: 1896, |
| shaderLocation: 2, |
| }, { |
| format: 'sint16x2', |
| offset: 912, |
| shaderLocation: 6, |
| }, { |
| format: 'sint16x4', |
| offset: 636, |
| shaderLocation: 20, |
| }, { |
| format: 'snorm8x4', |
| offset: 1852, |
| shaderLocation: 10, |
| }, { |
| format: 'uint16x4', |
| offset: 1460, |
| shaderLocation: 13, |
| }, { |
| format: 'uint32x4', |
| offset: 1272, |
| shaderLocation: 5, |
| }], |
| }, |
| { |
| arrayStride: 8900, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'uint8x2', |
| offset: 8550, |
| shaderLocation: 8, |
| }, { |
| format: 'uint16x4', |
| offset: 4388, |
| shaderLocation: 3, |
| }], |
| } |
| ] |
| }, |
| }); |
| let offscreenCanvas35 = new OffscreenCanvas(684, 901); |
| try { |
| adapter11.label = '\uf80e\ubdb3\u064f\u7472'; |
| } catch {} |
| let querySet71 = device7.createQuerySet({ |
| label: '\ud756\u0aba', |
| type: 'occlusion', |
| count: 808, |
| }); |
| let texture126 = device7.createTexture({ |
| label: '\u4cd0\u{1fb5a}', |
| size: {width: 840, height: 40, depthOrArrayLayers: 1}, |
| mipLevelCount: 10, |
| format: 'r16uint', |
| usage: GPUTextureUsage.COPY_DST, |
| viewFormats: ['r16uint', 'r16uint', 'r16uint'], |
| }); |
| let textureView98 = texture121.createView({label: '\u425e\u{1fb62}', baseMipLevel: 2, mipLevelCount: 7, arrayLayerCount: 1}); |
| let sampler87 = device7.createSampler({ |
| label: '\u279b\u{1f9f1}\u0897\u0962\u{1ffd5}\u5625', |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'repeat', |
| magFilter: 'nearest', |
| lodMinClamp: 64.516, |
| lodMaxClamp: 94.154, |
| }); |
| try { |
| commandEncoder74.copyBufferToBuffer(buffer44, 48100, buffer40, 11696, 5712); |
| dissociateBuffer(device7, buffer44); |
| dissociateBuffer(device7, buffer40); |
| } catch {} |
| try { |
| commandEncoder74.clearBuffer(buffer40, 12116, 2668); |
| dissociateBuffer(device7, buffer40); |
| } catch {} |
| try { |
| await promise65; |
| } catch {} |
| document.body.prepend(canvas24); |
| let device10 = await promise62; |
| try { |
| offscreenCanvas35.getContext('2d'); |
| } catch {} |
| let querySet72 = device0.createQuerySet({ |
| label: '\u5c58\u07ba\u5b30\u003c\u0462\u6e6b\u{1f7c5}\u699d\u{1fc82}\u801c', |
| type: 'occlusion', |
| count: 2487, |
| }); |
| let texture127 = gpuCanvasContext12.getCurrentTexture(); |
| try { |
| computePassEncoder39.setBindGroup(3, bindGroup5); |
| } catch {} |
| try { |
| renderBundleEncoder38.draw(56, 40, 48, 40); |
| } catch {} |
| try { |
| renderBundleEncoder80.drawIndexed(16, 48, 48, 40, 64); |
| } catch {} |
| try { |
| renderBundleEncoder38.setPipeline(pipeline42); |
| } catch {} |
| let commandEncoder82 = device7.createCommandEncoder({label: '\u0ec3\u455a\u01d0'}); |
| let querySet73 = device7.createQuerySet({ |
| type: 'occlusion', |
| count: 2164, |
| }); |
| let textureView99 = texture125.createView({mipLevelCount: 1, baseArrayLayer: 0}); |
| let externalTexture5 = device7.importExternalTexture({ |
| label: '\u66a4\u{1fcb1}\u0148\ufea2', |
| source: videoFrame7, |
| colorSpace: 'display-p3', |
| }); |
| try { |
| commandEncoder74.copyBufferToBuffer(buffer44, 31716, buffer33, 5344, 736); |
| dissociateBuffer(device7, buffer44); |
| dissociateBuffer(device7, buffer33); |
| } catch {} |
| try { |
| commandEncoder74.clearBuffer(buffer33, 7072, 524); |
| dissociateBuffer(device7, buffer33); |
| } catch {} |
| try { |
| commandEncoder74.resolveQuerySet(querySet71, 432, 180, buffer26, 6656); |
| } catch {} |
| try { |
| device7.queue.writeBuffer(buffer40, 4928, new Float32Array(47091), 1128, 2056); |
| } catch {} |
| let texture128 = device6.createTexture({ |
| label: '\udee8\ue2f3\u{1fcc8}', |
| size: {width: 230, height: 1, depthOrArrayLayers: 1568}, |
| mipLevelCount: 4, |
| dimension: '3d', |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderBundle96 = renderBundleEncoder60.finish({label: '\u1287\u0947\u{1fc3c}\u4dbb\u{1f7a0}\u08d6\ud9ec\u0cd1\uae01'}); |
| let sampler88 = device6.createSampler({ |
| label: '\ud1b5\u9daa', |
| addressModeV: 'repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'nearest', |
| lodMaxClamp: 73.136, |
| }); |
| try { |
| renderBundleEncoder76.setVertexBuffer(6, buffer30); |
| } catch {} |
| try { |
| device6.addEventListener('uncapturederror', e => { log('device6.uncapturederror'); log(e); e.label = device6.label; }); |
| } catch {} |
| let promise66 = buffer41.mapAsync(GPUMapMode.READ, 18216, 15480); |
| try { |
| commandEncoder61.clearBuffer(buffer41, 47296, 2876); |
| dissociateBuffer(device6, buffer41); |
| } catch {} |
| try { |
| commandEncoder61.resolveQuerySet(querySet68, 81, 895, buffer34, 22016); |
| } catch {} |
| try { |
| commandEncoder61.pushDebugGroup('\u0f2e'); |
| } catch {} |
| try { |
| device6.queue.writeBuffer(buffer30, 64, new BigUint64Array(32935), 8826, 0); |
| } catch {} |
| try { |
| device6.queue.writeTexture({ |
| texture: texture86, |
| mipLevel: 0, |
| origin: { x: 468, y: 1, z: 0 }, |
| aspect: 'all', |
| }, new ArrayBuffer(942), /* required buffer size: 942 */ |
| {offset: 942, bytesPerRow: 1977, rowsPerImage: 88}, {width: 856, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device6.queue.copyExternalImageToTexture(/* |
| {width: 57, height: 1, depthOrArrayLayers: 392} |
| */ |
| { |
| source: video2, |
| origin: { x: 1, y: 2 }, |
| flipY: false, |
| }, { |
| texture: texture128, |
| mipLevel: 2, |
| origin: { x: 27, y: 0, z: 310 }, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 12, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let querySet74 = device8.createQuerySet({ |
| label: '\ucc67\u3cfa\u3795\u{1f6bc}\u08f0', |
| type: 'occlusion', |
| count: 2577, |
| }); |
| try { |
| adapter10.label = '\ub0c5\u{1fd9b}\u{1fc05}\u{1ff88}\u{1f74d}\u0a87\u062e\u0c24\u2c46\u{1f9b5}\u82d4'; |
| } catch {} |
| let computePassEncoder64 = commandEncoder76.beginComputePass({label: '\u{1feb8}\u{1faa0}\u0dda\u4701'}); |
| try { |
| computePassEncoder64.insertDebugMarker('\u{1fbde}'); |
| } catch {} |
| try { |
| gpuCanvasContext22.configure({ |
| device: device8, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| colorSpace: 'srgb', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| await device8.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| await adapter4.requestAdapterInfo(); |
| } catch {} |
| try { |
| if (!arrayBuffer14.detached) { new Uint8Array(arrayBuffer14).fill(0x55) }; |
| } catch {} |
| let bindGroup33 = device0.createBindGroup({ |
| label: '\u0494\u{1f8e5}', |
| layout: bindGroupLayout4, |
| entries: [], |
| }); |
| let commandEncoder83 = device0.createCommandEncoder({label: '\u{1fbe4}\u{1f859}\u0a11\u0388\uc2ee\u{1f637}\u0d0b\u54dd\u{1fdb3}\uc029\u4e86'}); |
| let sampler89 = device0.createSampler({ |
| label: '\u24c1\ud916\u0ea5\u{1f906}\u0e9e\u0352\u{1fb04}', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 79.781, |
| lodMaxClamp: 87.287, |
| }); |
| try { |
| renderBundleEncoder80.setBindGroup(3, bindGroup14); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 43680, new DataView(new ArrayBuffer(37227)), 15764, 312); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let pipeline81 = device0.createComputePipeline({ |
| label: '\u07f5\u{1f7b6}\u6bc3\u0f35\u{1fccc}\u68ae\u5ad8\u0e15\u896f\u0526\u1eb0', |
| layout: 'auto', |
| compute: { |
| module: shaderModule14, |
| entryPoint: 'compute0', |
| }, |
| }); |
| let video33 = await videoWithData(); |
| try { |
| adapter11.label = '\u6ca2\u7936\u4cc7\u8b6d\ubbc6\u01ba'; |
| } catch {} |
| let commandEncoder84 = device0.createCommandEncoder({label: '\u{1f9a7}\u{1fa07}'}); |
| let querySet75 = device0.createQuerySet({ |
| type: 'occlusion', |
| count: 2390, |
| }); |
| try { |
| renderBundleEncoder61.drawIndexedIndirect(buffer36, 35104); |
| } catch {} |
| try { |
| commandEncoder84.copyBufferToBuffer(buffer4, 34432, buffer12, 18280, 2724); |
| dissociateBuffer(device0, buffer4); |
| dissociateBuffer(device0, buffer12); |
| } catch {} |
| try { |
| commandEncoder84.clearBuffer(buffer24, 100, 52); |
| dissociateBuffer(device0, buffer24); |
| } catch {} |
| let pipeline82 = await device0.createRenderPipelineAsync({ |
| label: '\u{1f8de}\ud578\u35b3\u7389\u07dd\u04f6', |
| layout: pipelineLayout9, |
| fragment: { |
| module: shaderModule12, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{format: 'rg32sint', writeMask: GPUColorWrite.ALL}, {format: 'rgba16sint', writeMask: GPUColorWrite.GREEN}, {format: 'r16sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE}, {format: 'rgba32float', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE}, {format: 'rgb10a2uint', writeMask: 0}, {format: 'rg32sint', writeMask: GPUColorWrite.ALL}] |
| }, |
| depthStencil: { |
| format: 'depth32float-stencil8', |
| depthWriteEnabled: false, |
| depthCompare: 'greater', |
| stencilFront: { |
| compare: 'less-equal', |
| failOp: 'increment-clamp', |
| depthFailOp: 'zero', |
| passOp: 'zero', |
| }, |
| stencilBack: { |
| compare: 'greater', |
| depthFailOp: 'increment-clamp', |
| passOp: 'decrement-clamp', |
| }, |
| stencilReadMask: 732, |
| stencilWriteMask: 1607, |
| depthBias: 27, |
| depthBiasSlopeScale: 1, |
| depthBiasClamp: 26, |
| }, |
| vertex: { |
| module: shaderModule12, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 15880, |
| stepMode: 'instance', |
| attributes: [{ |
| format: 'uint8x2', |
| offset: 4366, |
| shaderLocation: 10, |
| }], |
| }, |
| { |
| arrayStride: 3432, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'unorm16x2', |
| offset: 152, |
| shaderLocation: 13, |
| }, { |
| format: 'float32x2', |
| offset: 76, |
| shaderLocation: 3, |
| }, { |
| format: 'unorm16x4', |
| offset: 1588, |
| shaderLocation: 2, |
| }, { |
| format: 'sint32x3', |
| offset: 1956, |
| shaderLocation: 4, |
| }, { |
| format: 'sint32', |
| offset: 1040, |
| shaderLocation: 9, |
| }, { |
| format: 'float32', |
| offset: 1136, |
| shaderLocation: 7, |
| }, { |
| format: 'snorm8x4', |
| offset: 1048, |
| shaderLocation: 1, |
| }, { |
| format: 'unorm8x2', |
| offset: 1920, |
| shaderLocation: 11, |
| }, { |
| format: 'uint32x2', |
| offset: 876, |
| shaderLocation: 14, |
| }, { |
| format: 'sint32x3', |
| offset: 708, |
| shaderLocation: 0, |
| }, { |
| format: 'unorm16x4', |
| offset: 876, |
| shaderLocation: 8, |
| }, { |
| format: 'sint16x2', |
| offset: 3160, |
| shaderLocation: 15, |
| }, { |
| format: 'sint8x2', |
| offset: 898, |
| shaderLocation: 12, |
| }], |
| }, |
| { |
| arrayStride: 9356, |
| stepMode: 'instance', |
| attributes: [{ |
| format: 'sint32x3', |
| offset: 8052, |
| shaderLocation: 5, |
| }, { |
| format: 'float32x4', |
| offset: 5024, |
| shaderLocation: 6, |
| }], |
| } |
| ] |
| }, |
| primitive: { |
| topology: 'triangle-strip', |
| frontFace: 'cw', |
| cullMode: 'back', |
| unclippedDepth: true, |
| }, |
| }); |
| try { |
| window.someLabel = device6.queue.label; |
| } catch {} |
| let computePassEncoder65 = commandEncoder61.beginComputePass({label: '\u65e6\u090f\u{1f831}\u{1fefd}\u8db2\u4668'}); |
| try { |
| computePassEncoder65.end(); |
| } catch {} |
| try { |
| gpuCanvasContext7.configure({ |
| device: device6, |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| viewFormats: ['depth24plus', 'rgb10a2uint', 'rgb10a2uint', 'rgb10a2uint'], |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device6.queue.copyExternalImageToTexture(/* |
| {width: 57, height: 1, depthOrArrayLayers: 392} |
| */ |
| { |
| source: offscreenCanvas17, |
| origin: { x: 176, y: 38 }, |
| flipY: true, |
| }, { |
| texture: texture128, |
| mipLevel: 2, |
| origin: { x: 14, y: 1, z: 170 }, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 43, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| let imageData35 = new ImageData(76, 212); |
| let pipelineLayout19 = device8.createPipelineLayout({label: '\u3c1d\u08d6\u{1fc59}', bindGroupLayouts: [bindGroupLayout38]}); |
| let commandBuffer20 = commandEncoder48.finish({ |
| label: '\u{1fa97}\u{1f873}', |
| }); |
| try { |
| computePassEncoder56.end(); |
| } catch {} |
| try { |
| renderBundleEncoder81.setBindGroup(7, bindGroup25); |
| } catch {} |
| try { |
| renderBundleEncoder84.setBindGroup(2, bindGroup25, new Uint32Array(4407), 2022, 0); |
| } catch {} |
| try { |
| renderBundleEncoder84.setVertexBuffer(7, buffer35); |
| } catch {} |
| try { |
| commandEncoder64.clearBuffer(buffer19, 59872); |
| dissociateBuffer(device2, buffer19); |
| } catch {} |
| let pipeline83 = await promise60; |
| let offscreenCanvas36 = new OffscreenCanvas(155, 330); |
| try { |
| window.someLabel = texture124.label; |
| } catch {} |
| let buffer46 = device9.createBuffer({label: '\u1d07\u0fb8', size: 10554, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let computePassEncoder66 = commandEncoder81.beginComputePass({}); |
| let renderBundle97 = renderBundleEncoder90.finish({label: '\uef02\uafbd\u07fc\u7871\u04a6\uc6b7\u35d4\uf38e\u0f31\uafca'}); |
| try { |
| gpuCanvasContext23.configure({ |
| device: device9, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| await promise66; |
| } catch {} |
| let video34 = await videoWithData(); |
| pseudoSubmit(device8, commandEncoder76); |
| let texture129 = device8.createTexture({ |
| label: '\u9069\u{1f6ba}', |
| size: {width: 840, height: 4, depthOrArrayLayers: 1}, |
| mipLevelCount: 3, |
| format: 'eac-r11snorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['eac-r11snorm', 'eac-r11snorm'], |
| }); |
| let querySet76 = device10.createQuerySet({ |
| label: '\u5995\u5c85\u7ac2\u{1f647}\ud989\u129b\u1f84', |
| type: 'occlusion', |
| count: 181, |
| }); |
| let sampler90 = device10.createSampler({ |
| addressModeV: 'repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 99.684, |
| lodMaxClamp: 99.847, |
| }); |
| let video35 = await videoWithData(); |
| pseudoSubmit(device9, commandEncoder81); |
| let texture130 = device9.createTexture({ |
| label: '\u{1f6f6}\ud082\u0e1b\u02dc\u{1fc2c}\u23d2\u09ea\ud5c5\u1a81', |
| size: {width: 160, height: 8, depthOrArrayLayers: 173}, |
| mipLevelCount: 4, |
| format: 'astc-10x8-unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| viewFormats: [], |
| }); |
| let offscreenCanvas37 = new OffscreenCanvas(334, 892); |
| let commandEncoder85 = device0.createCommandEncoder(); |
| let renderBundleEncoder91 = device0.createRenderBundleEncoder({ |
| label: '\u{1f634}\u8b74\ua26f\u{1fc1e}\u40ad\ueff8\u019b\u2ec5', |
| colorFormats: ['r8uint', undefined, 'rg16sint', 'r8uint', 'rg8sint', 'rgba8unorm', 'r8sint', 'r16sint'], |
| depthStencilFormat: 'depth32float-stencil8', |
| sampleCount: 4 |
| }); |
| try { |
| computePassEncoder9.setBindGroup(2, bindGroup3); |
| } catch {} |
| try { |
| computePassEncoder19.setBindGroup(1, bindGroup1, new Uint32Array(6166), 1743, 0); |
| } catch {} |
| try { |
| renderBundleEncoder61.setBindGroup(1, bindGroup15); |
| } catch {} |
| try { |
| commandEncoder83.resolveQuerySet(querySet8, 87, 66, buffer27, 3072); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture3, |
| mipLevel: 0, |
| origin: { x: 24, y: 96, z: 0 }, |
| aspect: 'all', |
| }, new ArrayBuffer(80), /* required buffer size: 370 */ |
| {offset: 370}, {width: 24, height: 6, depthOrArrayLayers: 0}); |
| } catch {} |
| let adapter14 = await navigator.gpu.requestAdapter({ |
| }); |
| let bindGroupLayout45 = device10.createBindGroupLayout({ |
| label: '\u{1fac3}\u{1f77b}\ue8f3\u8057\u02df\u793d\u3ff8\u79f9\u00cb\u5d3c\u0b5f', |
| entries: [{ |
| binding: 777, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| sampler: { type: 'comparison' }, |
| }], |
| }); |
| let querySet77 = device10.createQuerySet({ |
| label: '\u01e3\u{1f7d7}\ue7bf\u856c\u{1fd7a}', |
| type: 'occlusion', |
| count: 3760, |
| }); |
| let texture131 = device10.createTexture({ |
| size: {width: 1040, height: 64, depthOrArrayLayers: 1}, |
| mipLevelCount: 7, |
| format: 'rg16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| device10.pushErrorScope('internal'); |
| } catch {} |
| try { |
| gpuCanvasContext8.configure({ |
| device: device10, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: ['astc-10x5-unorm', 'astc-10x10-unorm', 'astc-5x4-unorm', 'rgba8unorm-srgb'], |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| try { |
| window.someLabel = sampler44.label; |
| } catch {} |
| try { |
| offscreenCanvas37.getContext('webgl2'); |
| } catch {} |
| let texture132 = device9.createTexture({ |
| label: '\u9ba5\udb54', |
| size: [512, 120, 1], |
| mipLevelCount: 7, |
| dimension: '2d', |
| format: 'rgba8unorm-srgb', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rgba8unorm-srgb'], |
| }); |
| try { |
| device9.queue.writeTexture({ |
| texture: texture130, |
| mipLevel: 0, |
| origin: { x: 10, y: 0, z: 3 }, |
| aspect: 'all', |
| }, new ArrayBuffer(32), /* required buffer size: 1908114 */ |
| {offset: 306, bytesPerRow: 334, rowsPerImage: 34}, {width: 50, height: 0, depthOrArrayLayers: 169}); |
| } catch {} |
| let gpuCanvasContext32 = offscreenCanvas36.getContext('webgpu'); |
| let img30 = await imageWithData(214, 38, '#c03e6732', '#24bede12'); |
| let video36 = await videoWithData(); |
| let bindGroupLayout46 = device8.createBindGroupLayout({ |
| entries: [{ |
| binding: 87, |
| visibility: GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', minBindingSize: 0, hasDynamicOffset: true }, |
| }], |
| }); |
| try { |
| renderBundleEncoder72.setVertexBuffer(31, undefined, 3250125943, 86890225); |
| } catch {} |
| try { |
| device8.destroy(); |
| } catch {} |
| let videoFrame25 = new VideoFrame(imageBitmap4, {timestamp: 0}); |
| let texture133 = device2.createTexture({ |
| size: {width: 160, height: 55, depthOrArrayLayers: 247}, |
| mipLevelCount: 3, |
| dimension: '3d', |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| viewFormats: ['r8sint', 'r8sint'], |
| }); |
| let sampler91 = device2.createSampler({ |
| label: '\u{1fb3c}\u0992\ua402\u0838\u0f6d\u0515\u58be\u8f17\uccc8', |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| lodMinClamp: 81.748, |
| lodMaxClamp: 90.147, |
| compare: 'always', |
| }); |
| try { |
| computePassEncoder41.setBindGroup(5, bindGroup25, new Uint32Array(1133), 1049, 0); |
| } catch {} |
| try { |
| commandEncoder64.resolveQuerySet(querySet28, 919, 182, buffer19, 35072); |
| } catch {} |
| let promise67 = device2.queue.onSubmittedWorkDone(); |
| try { |
| gpuCanvasContext9.unconfigure(); |
| } catch {} |
| try { |
| await promise67; |
| } catch {} |
| let canvas33 = document.createElement('canvas'); |
| let videoFrame26 = new VideoFrame(offscreenCanvas1, {timestamp: 0}); |
| let gpuCanvasContext33 = canvas33.getContext('webgpu'); |
| let commandEncoder86 = device6.createCommandEncoder({label: '\u373b\ue589\u0109\ubbae'}); |
| try { |
| device6.queue.writeBuffer(buffer30, 604, new BigUint64Array(59722), 19566, 0); |
| } catch {} |
| try { |
| device6.queue.writeTexture({ |
| texture: texture106, |
| mipLevel: 0, |
| origin: { x: 78, y: 0, z: 18 }, |
| aspect: 'all', |
| }, new BigUint64Array(arrayBuffer13), /* required buffer size: 5429060 */ |
| {offset: 688, bytesPerRow: 1500, rowsPerImage: 201}, {width: 343, height: 1, depthOrArrayLayers: 19}); |
| } catch {} |
| pseudoSubmit(device6, commandEncoder86); |
| let computePassEncoder67 = commandEncoder61.beginComputePass(); |
| let offscreenCanvas38 = new OffscreenCanvas(792, 772); |
| try { |
| offscreenCanvas38.getContext('bitmaprenderer'); |
| } catch {} |
| let pipelineLayout20 = device7.createPipelineLayout({ |
| label: '\u057c\u02fd\u3218\u0dba', |
| bindGroupLayouts: [bindGroupLayout35, bindGroupLayout35, bindGroupLayout34, bindGroupLayout41] |
| }); |
| let texture134 = device7.createTexture({ |
| label: '\u0701\u1706\ueafb\u0045\u6ce0\u46c5\u63fe\u{1f629}\ued30\ub92d', |
| size: [2496, 1, 1], |
| mipLevelCount: 5, |
| format: 'rg16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let sampler92 = device7.createSampler({ |
| label: '\u0fa6\u89cc\ua409\u{1fe6d}\u0d2d', |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 28.895, |
| lodMaxClamp: 48.699, |
| maxAnisotropy: 7, |
| }); |
| canvas0.height = 898; |
| let bindGroupLayout47 = device10.createBindGroupLayout({ |
| label: '\ucb69\u{1fbd3}\u74c1', |
| entries: [{ |
| binding: 587, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d-array', sampleType: 'float', multisampled: false }, |
| }, { |
| binding: 420, |
| visibility: 0, |
| buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: true }, |
| }, { |
| binding: 966, |
| visibility: GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rgba16sint', access: 'read-only', viewDimension: '2d-array' }, |
| }], |
| }); |
| let querySet78 = device10.createQuerySet({ |
| type: 'occlusion', |
| count: 1380, |
| }); |
| let sampler93 = device10.createSampler({ |
| label: '\ue0da\u0859\ua635\u3f92', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 64.703, |
| lodMaxClamp: 68.646, |
| compare: 'not-equal', |
| }); |
| let querySet79 = device9.createQuerySet({ |
| label: '\u07f5\u9629\u27a2\u{1f68c}\u07c1\u254f\uad5c', |
| type: 'occlusion', |
| count: 2859, |
| }); |
| let texture135 = device9.createTexture({ |
| label: '\ufbb3\u064b\u5f2e\u0bde\u{1fabd}', |
| size: {width: 40, height: 15, depthOrArrayLayers: 2}, |
| mipLevelCount: 6, |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'r8snorm', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| try { |
| await adapter3.requestAdapterInfo(); |
| } catch {} |
| let img31 = await imageWithData(172, 116, '#b0c133f2', '#95e99fe0'); |
| try { |
| gpuCanvasContext21.unconfigure(); |
| } catch {} |
| canvas0.height = 867; |
| let bindGroupLayout48 = device6.createBindGroupLayout({ |
| label: '\u027f\u093b\uf613\u{1ff15}\u7811\u9852', |
| entries: [{ |
| binding: 4378, |
| visibility: GPUShaderStage.VERTEX, |
| externalTexture: {}, |
| }, { |
| binding: 561, |
| visibility: GPUShaderStage.COMPUTE, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: true }, |
| }, { |
| binding: 3874, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: true }, |
| }], |
| }); |
| let texture136 = device6.createTexture({ |
| label: '\u0b00\u87e9\uad30\u002c\uc8be\u016d\u2549\u03f0\ufcbf\ufbf4', |
| size: [460, 1, 1], |
| mipLevelCount: 2, |
| format: 'rgba8unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rgba8unorm'], |
| }); |
| let renderBundleEncoder92 = device6.createRenderBundleEncoder({ |
| label: '\u9f67\u{1fa32}\u7b70\u0dfb\u{1f75f}\u{1fb53}\u60e6\u{1fb41}', |
| colorFormats: ['rg16uint', 'rgba8sint', 'rgb10a2uint', 'rg8sint', 'rgba32sint'], |
| stencilReadOnly: true |
| }); |
| try { |
| device6.queue.writeBuffer(buffer30, 336, new Int16Array(17622), 5297, 32); |
| } catch {} |
| let offscreenCanvas39 = new OffscreenCanvas(716, 1008); |
| try { |
| device8.queue.label = '\u00ab\u0287\u0fdc\u{1ff20}\u057d'; |
| } catch {} |
| let textureView100 = texture134.createView({label: '\u04e7\u3ed8\ua3b0\ucdad\ucc9c\u{1f719}', dimension: '2d-array', baseMipLevel: 1, mipLevelCount: 2}); |
| try { |
| commandEncoder78.copyTextureToTexture({ |
| texture: texture125, |
| mipLevel: 1, |
| origin: { x: 56, y: 7, z: 0 }, |
| aspect: 'all', |
| }, { |
| texture: texture125, |
| mipLevel: 0, |
| origin: { x: 903, y: 41, z: 2 }, |
| aspect: 'all', |
| }, {width: 250, height: 28, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| device7.queue.writeBuffer(buffer40, 8168, new BigUint64Array(8531), 6735, 1340); |
| } catch {} |
| let pipeline84 = device7.createComputePipeline({ |
| label: '\ue190\u1aa3\u4871\u29a8\u{1f6a7}', |
| layout: pipelineLayout18, |
| compute: { |
| module: shaderModule15, |
| entryPoint: 'compute0', |
| constants: {}, |
| }, |
| }); |
| let pipeline85 = await device7.createRenderPipelineAsync({ |
| label: '\u{1f930}\ud4f4\u5b31\u8e93\u321f\u080d\ud341\u4e47', |
| layout: pipelineLayout16, |
| fragment: {module: shaderModule15, entryPoint: 'fragment0', constants: {}, targets: []}, |
| depthStencil: { |
| format: 'depth24plus-stencil8', |
| depthWriteEnabled: true, |
| depthCompare: 'never', |
| stencilFront: { |
| compare: 'not-equal', |
| failOp: 'increment-wrap', |
| depthFailOp: 'invert', |
| passOp: 'invert', |
| }, |
| stencilBack: { |
| compare: 'less', |
| failOp: 'increment-clamp', |
| depthFailOp: 'invert', |
| passOp: 'increment-wrap', |
| }, |
| stencilReadMask: 1672, |
| stencilWriteMask: 3932, |
| depthBiasSlopeScale: 89, |
| }, |
| vertex: { |
| module: shaderModule15, |
| entryPoint: 'vertex0', |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 8668, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'uint8x2', |
| offset: 2916, |
| shaderLocation: 3, |
| }, { |
| format: 'sint16x4', |
| offset: 3936, |
| shaderLocation: 6, |
| }, { |
| format: 'sint16x4', |
| offset: 3444, |
| shaderLocation: 18, |
| }, { |
| format: 'uint8x4', |
| offset: 4712, |
| shaderLocation: 7, |
| }, { |
| format: 'sint32x2', |
| offset: 656, |
| shaderLocation: 12, |
| }, { |
| format: 'snorm16x2', |
| offset: 6516, |
| shaderLocation: 22, |
| }, { |
| format: 'float16x2', |
| offset: 7884, |
| shaderLocation: 1, |
| }, { |
| format: 'uint32x2', |
| offset: 3616, |
| shaderLocation: 9, |
| }, { |
| format: 'unorm8x2', |
| offset: 6114, |
| shaderLocation: 10, |
| }, { |
| format: 'float16x4', |
| offset: 4976, |
| shaderLocation: 2, |
| }, { |
| format: 'snorm16x4', |
| offset: 852, |
| shaderLocation: 0, |
| }, { |
| format: 'unorm10-10-10-2', |
| offset: 7392, |
| shaderLocation: 16, |
| }, { |
| format: 'sint32x3', |
| offset: 2988, |
| shaderLocation: 21, |
| }, { |
| format: 'uint16x4', |
| offset: 568, |
| shaderLocation: 5, |
| }, { |
| format: 'snorm16x4', |
| offset: 7260, |
| shaderLocation: 23, |
| }, { |
| format: 'sint32', |
| offset: 7660, |
| shaderLocation: 4, |
| }, { |
| format: 'sint32x4', |
| offset: 6232, |
| shaderLocation: 11, |
| }, { |
| format: 'uint16x4', |
| offset: 5568, |
| shaderLocation: 17, |
| }, { |
| format: 'float16x2', |
| offset: 3316, |
| shaderLocation: 19, |
| }, { |
| format: 'unorm8x2', |
| offset: 2066, |
| shaderLocation: 14, |
| }, { |
| format: 'uint8x2', |
| offset: 5182, |
| shaderLocation: 13, |
| }, { |
| format: 'uint16x2', |
| offset: 6736, |
| shaderLocation: 8, |
| }, { |
| format: 'sint8x2', |
| offset: 6206, |
| shaderLocation: 20, |
| }], |
| }, |
| { |
| arrayStride: 1824, |
| attributes: [], |
| }, |
| { |
| arrayStride: 12364, |
| stepMode: 'instance', |
| attributes: [{ |
| format: 'sint32', |
| offset: 9096, |
| shaderLocation: 15, |
| }], |
| } |
| ] |
| }, |
| primitive: { |
| topology: 'line-list', |
| frontFace: 'cw', |
| cullMode: 'back', |
| unclippedDepth: true, |
| }, |
| }); |
| let adapter15 = await navigator.gpu.requestAdapter({ |
| }); |
| let gpuCanvasContext34 = offscreenCanvas39.getContext('webgpu'); |
| let offscreenCanvas40 = new OffscreenCanvas(719, 270); |
| let texture137 = device9.createTexture({ |
| label: '\u15dc\u2665\u52db\ub7cc\u0e7d\ua83c\u585f\u5204\u81be\udbba\uc593', |
| size: {width: 640, height: 32, depthOrArrayLayers: 1}, |
| mipLevelCount: 8, |
| format: 'astc-8x8-unorm', |
| usage: GPUTextureUsage.COPY_SRC, |
| viewFormats: ['astc-8x8-unorm', 'astc-8x8-unorm', 'astc-8x8-unorm'], |
| }); |
| let textureView101 = texture118.createView({label: '\u58bf\u3310\u{1fd03}', baseMipLevel: 1, mipLevelCount: 2, baseArrayLayer: 8, arrayLayerCount: 3}); |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let imageData36 = new ImageData(64, 36); |
| let videoFrame27 = new VideoFrame(img24, {timestamp: 0}); |
| let gpuCanvasContext35 = offscreenCanvas40.getContext('webgpu'); |
| let pipelineLayout21 = device6.createPipelineLayout({ |
| label: '\u83ee\u{1f9c6}\u5338\u0697\ueb90\uc0cf\u40b6\u4f8d\u88fb\uea58\u0695', |
| bindGroupLayouts: [bindGroupLayout48, bindGroupLayout48] |
| }); |
| let commandEncoder87 = device6.createCommandEncoder({label: '\ue080\u{1f807}\u0e67\u0757'}); |
| let renderBundle98 = renderBundleEncoder92.finish({label: '\u{1fa6d}\ue721\u0716\ua2bb\u00f6'}); |
| try { |
| buffer30.destroy(); |
| } catch {} |
| try { |
| commandEncoder87.resolveQuerySet(querySet44, 514, 106, buffer34, 14080); |
| } catch {} |
| let offscreenCanvas41 = new OffscreenCanvas(728, 46); |
| let img32 = await imageWithData(170, 293, '#4fc80a7b', '#f24b3d91'); |
| try { |
| offscreenCanvas41.getContext('webgl2'); |
| } catch {} |
| let querySet80 = device2.createQuerySet({ |
| label: '\uecbd\u03ba\ucc6a\u{1fd0f}\u0244\u{1fbe3}', |
| type: 'occlusion', |
| count: 1536, |
| }); |
| let computePassEncoder68 = commandEncoder64.beginComputePass({}); |
| let sampler94 = device2.createSampler({ |
| label: '\u{1fb99}\u{1fc01}\u0e0c\u0038\u017b\uc6bc\u{1fe70}\u0497', |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 75.145, |
| maxAnisotropy: 2, |
| }); |
| try { |
| renderBundleEncoder84.setPipeline(pipeline71); |
| } catch {} |
| try { |
| await device2.queue.onSubmittedWorkDone(); |
| } catch {} |
| offscreenCanvas16.height = 1022; |
| let video37 = await videoWithData(); |
| let pipelineLayout22 = device10.createPipelineLayout({bindGroupLayouts: [bindGroupLayout47, bindGroupLayout47, bindGroupLayout45]}); |
| let sampler95 = device10.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 71.465, |
| lodMaxClamp: 72.713, |
| }); |
| try { |
| gpuCanvasContext10.configure({ |
| device: device10, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: ['astc-5x5-unorm', 'bgra8unorm-srgb', 'astc-10x5-unorm', 'rg32uint'], |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| try { |
| device10.queue.writeTexture({ |
| texture: texture131, |
| mipLevel: 6, |
| origin: { x: 0, y: 0, z: 0 }, |
| aspect: 'all', |
| }, new ArrayBuffer(24), /* required buffer size: 18 */ |
| {offset: 18}, {width: 2, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| let querySet81 = device10.createQuerySet({ |
| type: 'occlusion', |
| count: 1848, |
| }); |
| try { |
| gpuCanvasContext6.configure({ |
| device: device10, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC, |
| viewFormats: ['r32float', 'astc-6x6-unorm-srgb', 'rgba16float'], |
| colorSpace: 'display-p3', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let img33 = await imageWithData(260, 109, '#da72d65b', '#39af1241'); |
| let texture138 = device6.createTexture({ |
| size: [495], |
| sampleCount: 1, |
| dimension: '1d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: ['rg32uint'], |
| }); |
| let buffer47 = device7.createBuffer({label: '\u5ceb\u01cc\u{1fbc6}\u{1f78f}\u0b12\u0a9b\u099e', size: 24740, usage: GPUBufferUsage.INDIRECT}); |
| let textureView102 = texture96.createView({ |
| label: '\u1951\u5bbe\u{1f6c5}\u{1f7cb}\u{1f6e3}\u0c50\u{1f73c}\u08c0', |
| aspect: 'depth-only', |
| baseMipLevel: 3, |
| baseArrayLayer: 184, |
| arrayLayerCount: 11 |
| }); |
| let renderBundleEncoder93 = device7.createRenderBundleEncoder({ |
| label: '\u{1f692}\u9926\u1429\u6b7b\u024c', |
| colorFormats: [], |
| depthStencilFormat: 'depth32float-stencil8', |
| depthReadOnly: true, |
| stencilReadOnly: true |
| }); |
| let sampler96 = device7.createSampler({ |
| label: '\u04f3\ubfcf\u0b15\u0354\ube4d\u6bab\u1a54\u07a4\ue063', |
| addressModeU: 'clamp-to-edge', |
| addressModeW: 'mirror-repeat', |
| lodMinClamp: 35.070, |
| lodMaxClamp: 96.004, |
| }); |
| try { |
| renderBundleEncoder93.setVertexBuffer(10, buffer42, 2064, 38624); |
| } catch {} |
| try { |
| renderBundleEncoder38.draw(40); |
| } catch {} |
| try { |
| renderBundleEncoder38.drawIndexedIndirect(buffer36, 27416); |
| } catch {} |
| try { |
| renderBundleEncoder61.setPipeline(pipeline8); |
| } catch {} |
| try { |
| commandEncoder84.copyTextureToBuffer({ |
| texture: texture13, |
| mipLevel: 0, |
| origin: { x: 10, y: 280, z: 0 }, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 112 widthInBlocks: 7 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 35920 */ |
| offset: 3808, |
| bytesPerRow: 256, |
| buffer: buffer23, |
| }, {width: 35, height: 630, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer23); |
| } catch {} |
| try { |
| commandEncoder85.clearBuffer(buffer24, 184, 48); |
| dissociateBuffer(device0, buffer24); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 36180, new Float32Array(64756), 61452, 416); |
| } catch {} |
| let promise68 = adapter15.requestDevice({ |
| label: '\u12d5\u88b1\u{1f8af}\ufeb2\u{1fd77}\u36b1', |
| requiredFeatures: [ |
| 'texture-compression-astc', |
| 'shader-f16', |
| 'rg11b10ufloat-renderable' |
| ], |
| requiredLimits: { |
| maxBindGroups: 7, |
| maxColorAttachmentBytesPerSample: 43, |
| maxVertexBufferArrayStride: 40887, |
| maxStorageTexturesPerShaderStage: 42, |
| maxStorageBuffersPerShaderStage: 31, |
| maxDynamicStorageBuffersPerPipelineLayout: 36380, |
| maxBindingsPerBindGroup: 8761, |
| maxTextureDimension1D: 14023, |
| maxTextureDimension2D: 9135, |
| maxVertexBuffers: 11, |
| minStorageBufferOffsetAlignment: 64, |
| minUniformBufferOffsetAlignment: 128, |
| maxUniformBufferBindingSize: 242500217, |
| maxUniformBuffersPerShaderStage: 37, |
| maxInterStageShaderVariables: 73, |
| maxInterStageShaderComponents: 119, |
| }, |
| }); |
| let imageBitmap25 = await createImageBitmap(video1); |
| try { |
| gpuCanvasContext31.unconfigure(); |
| } catch {} |
| let shaderModule21 = device7.createShaderModule({ |
| label: '\u{1fa9a}\ue099\uae1c\u1279\u313a\u0d27', |
| code: `@group(3) @binding(932) |
| var<storage, read_write> field23: array<u32>; |
| @group(3) @binding(930) |
| var<storage, read_write> function22: array<u32>; |
| @group(0) @binding(4885) |
| var<storage, read_write> global16: array<u32>; |
| @group(3) @binding(5657) |
| var<storage, read_write> function23: array<u32>; |
| |
| @compute @workgroup_size(3, 1, 3) |
| fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {} |
| |
| struct S23 { |
| @builtin(sample_mask) f0: u32 |
| } |
| struct FragmentOutput0 { |
| @builtin(sample_mask) f0: u32, |
| @location(0) f1: vec3<u32> |
| } |
| |
| @fragment |
| fn fragment0(@builtin(sample_index) a0: u32, a1: S23, @builtin(front_facing) a2: bool) -> FragmentOutput0 { |
| return FragmentOutput0(); |
| } |
| |
| struct S22 { |
| @location(10) f0: vec3<f32> |
| } |
| |
| @vertex |
| fn vertex0(@location(11) a0: f32, @location(20) a1: vec3<i32>, @location(9) a2: vec2<u32>, @location(23) a3: vec4<f32>, a4: S22, @location(5) a5: f32, @location(6) a6: u32, @location(0) a7: vec2<i32>, @location(17) a8: vec2<u32>, @location(1) a9: vec2<u32>, @location(12) a10: vec4<f16>, @location(2) a11: vec4<i32>, @location(8) a12: vec2<f32>, @builtin(instance_index) a13: u32) -> @builtin(position) vec4<f32> { |
| return vec4<f32>(0.0, 0.0, 0.0, 1.0); |
| } |
| |
| `, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| try { |
| renderBundleEncoder88.setVertexBuffer(60, undefined, 587408777); |
| } catch {} |
| try { |
| commandEncoder82.copyBufferToTexture({ |
| /* bytesInLastRow: 2 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 1374 */ |
| offset: 1374, |
| buffer: buffer44, |
| }, { |
| texture: texture126, |
| mipLevel: 7, |
| origin: { x: 2, y: 0, z: 0 }, |
| aspect: 'all', |
| }, {width: 1, height: 1, depthOrArrayLayers: 0}); |
| dissociateBuffer(device7, buffer44); |
| } catch {} |
| let pipeline86 = device7.createRenderPipeline({ |
| label: '\u0c1f\ua104\u0831\u02ee\u{1fcdc}\u0cce\u{1fce1}\u6fc3', |
| layout: pipelineLayout16, |
| multisample: { |
| count: 4, |
| mask: 0x7daa7a6e, |
| }, |
| fragment: {module: shaderModule21, entryPoint: 'fragment0', constants: {}, targets: []}, |
| depthStencil: { |
| format: 'stencil8', |
| depthWriteEnabled: false, |
| depthCompare: 'always', |
| stencilFront: { |
| compare: 'less-equal', |
| failOp: 'increment-wrap', |
| depthFailOp: 'increment-clamp', |
| passOp: 'increment-wrap', |
| }, |
| stencilBack: { |
| compare: 'equal', |
| failOp: 'zero', |
| depthFailOp: 'decrement-clamp', |
| passOp: 'increment-clamp', |
| }, |
| stencilReadMask: 188, |
| depthBias: 34, |
| depthBiasSlopeScale: 13, |
| }, |
| vertex: { |
| module: shaderModule21, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 15944, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'uint16x4', |
| offset: 13380, |
| shaderLocation: 9, |
| }, { |
| format: 'unorm16x4', |
| offset: 14268, |
| shaderLocation: 11, |
| }], |
| }, |
| { |
| arrayStride: 15708, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'sint32x4', |
| offset: 6268, |
| shaderLocation: 20, |
| }], |
| }, |
| { |
| arrayStride: 10808, |
| stepMode: 'instance', |
| attributes: [{ |
| format: 'uint32x3', |
| offset: 6824, |
| shaderLocation: 1, |
| }, { |
| format: 'uint32x4', |
| offset: 7764, |
| shaderLocation: 6, |
| }, { |
| format: 'sint32x3', |
| offset: 9436, |
| shaderLocation: 2, |
| }, { |
| format: 'float32x2', |
| offset: 2604, |
| shaderLocation: 5, |
| }, { |
| format: 'unorm16x4', |
| offset: 9260, |
| shaderLocation: 10, |
| }, { |
| format: 'float32', |
| offset: 1664, |
| shaderLocation: 23, |
| }, { |
| format: 'unorm10-10-10-2', |
| offset: 9780, |
| shaderLocation: 8, |
| }], |
| }, |
| { |
| arrayStride: 16140, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'float32x3', |
| offset: 15340, |
| shaderLocation: 12, |
| }, { |
| format: 'sint8x4', |
| offset: 8116, |
| shaderLocation: 0, |
| }, { |
| format: 'uint8x4', |
| offset: 3136, |
| shaderLocation: 17, |
| }], |
| } |
| ] |
| }, |
| primitive: { |
| topology: 'line-list', |
| frontFace: 'ccw', |
| unclippedDepth: true, |
| }, |
| }); |
| let imageBitmap26 = await createImageBitmap(imageData23); |
| let bindGroupLayout49 = device10.createBindGroupLayout({ |
| label: '\u3c5b\u101d\u1522\ud438\u{1fe28}\u6b50', |
| entries: [{ |
| binding: 646, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba32sint', access: 'read-only', viewDimension: '2d' }, |
| }, { |
| binding: 173, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', minBindingSize: 0, hasDynamicOffset: true }, |
| }, { |
| binding: 343, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rg32uint', access: 'read-only', viewDimension: '3d' }, |
| }], |
| }); |
| let commandEncoder88 = device10.createCommandEncoder({}); |
| try { |
| device10.queue.writeTexture({ |
| texture: texture131, |
| mipLevel: 0, |
| origin: { x: 537, y: 4, z: 0 }, |
| aspect: 'all', |
| }, new ArrayBuffer(265), /* required buffer size: 265 */ |
| {offset: 265, bytesPerRow: 1321}, {width: 284, height: 35, depthOrArrayLayers: 0}); |
| } catch {} |
| video35.height = 219; |
| let texture139 = device9.createTexture({ |
| size: [256, 60, 1], |
| mipLevelCount: 8, |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: ['depth32float', 'depth32float'], |
| }); |
| let promise69 = device9.popErrorScope(); |
| let shaderModule22 = device10.createShaderModule({ |
| label: '\u0bcf\u{1fb8d}\u0916\uf8b5', |
| code: `@group(2) @binding(777) |
| var<storage, read_write> global17: array<u32>; |
| @group(1) @binding(420) |
| var<storage, read_write> field24: array<u32>; |
| @group(0) @binding(587) |
| var<storage, read_write> field25: array<u32>; |
| @group(1) @binding(587) |
| var<storage, read_write> global18: array<u32>; |
| @group(0) @binding(420) |
| var<storage, read_write> parameter22: array<u32>; |
| |
| @compute @workgroup_size(8, 1, 3) |
| fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {} |
| |
| struct S25 { |
| @location(1) f0: vec4<i32>, |
| @location(14) f1: vec2<i32> |
| } |
| struct FragmentOutput0 { |
| @location(5) f0: vec4<f32>, |
| @location(4) f1: vec4<i32>, |
| @location(1) f2: vec4<u32>, |
| @location(0) f3: vec2<f32>, |
| @location(3) f4: u32, |
| @location(2) f5: vec4<f32>, |
| @location(7) f6: i32 |
| } |
| |
| @fragment |
| fn fragment0(@location(2) a0: vec4<f16>, @builtin(sample_index) a1: u32, @location(0) a2: vec4<i32>, @location(13) a3: vec4<f32>, @location(8) a4: vec2<f32>, a5: S25, @location(11) a6: vec3<u32>, @location(12) a7: vec2<f32>, @location(3) a8: vec3<f16>, @location(4) a9: f16) -> FragmentOutput0 { |
| return FragmentOutput0(); |
| } |
| |
| struct S24 { |
| @location(13) f0: vec3<f32> |
| } |
| struct VertexOutput0 { |
| @location(11) f230: vec3<u32>, |
| @location(4) f231: f16, |
| @location(13) f232: vec4<f32>, |
| @location(10) f233: vec4<i32>, |
| @location(1) f234: vec4<i32>, |
| @builtin(position) f235: vec4<f32>, |
| @location(8) f236: vec2<f32>, |
| @location(2) f237: vec4<f16>, |
| @location(12) f238: vec2<f32>, |
| @location(6) f239: u32, |
| @location(0) f240: vec4<i32>, |
| @location(9) f241: i32, |
| @location(14) f242: vec2<i32>, |
| @location(3) f243: vec3<f16> |
| } |
| |
| @vertex |
| fn vertex0(@location(4) a0: f16, @location(7) a1: vec3<f16>, @location(8) a2: vec2<u32>, @location(12) a3: vec2<u32>, @location(10) a4: i32, @location(0) a5: vec2<u32>, @location(11) a6: f16, a7: S24) -> VertexOutput0 { |
| return VertexOutput0(); |
| } |
| |
| `, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| let buffer48 = device10.createBuffer({ |
| label: '\uaaee\u0905\u3b08\u{1f701}\u4df6\u3cb3\u070e\u7a2e\u3123\u30d4\ufab6', |
| size: 42836, |
| usage: GPUBufferUsage.INDIRECT |
| }); |
| let commandEncoder89 = device10.createCommandEncoder({label: '\u57a1\u24a8\u24d6\u0196\u095a'}); |
| try { |
| buffer48.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext32.configure({ |
| device: device10, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['bgra8unorm-srgb', 'r8unorm'], |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| let textureView103 = texture132.createView({label: '\u25f8\u815d\u4056\u7238\ufbd1\u{1f87e}\u{1fd94}', dimension: '2d', baseMipLevel: 2}); |
| let img34 = await imageWithData(74, 193, '#1624d110', '#e80c6c44'); |
| try { |
| gpuCanvasContext32.unconfigure(); |
| } catch {} |
| let shaderModule23 = device8.createShaderModule({ |
| label: '\u38b0\u{1f866}\u{1ff99}\u11cb\ua3c4\u0ffb\ue36a\u0e9d\u0344', |
| code: `@group(0) @binding(232) |
| var<storage, read_write> field26: array<u32>; |
| @group(0) @binding(442) |
| var<storage, read_write> function24: array<u32>; |
| |
| @compute @workgroup_size(7, 3, 1) |
| fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {} |
| |
| struct S27 { |
| @builtin(sample_mask) f0: u32 |
| } |
| struct FragmentOutput0 { |
| @location(4) f0: vec4<f32>, |
| @location(1) f1: vec4<f32>, |
| @location(5) f2: vec4<u32>, |
| @location(0) f3: vec2<i32>, |
| @location(2) f4: vec2<i32>, |
| @location(3) f5: vec3<u32> |
| } |
| |
| @fragment |
| fn fragment0(a0: S27, @builtin(sample_index) a1: u32, @builtin(position) a2: vec4<f32>, @builtin(front_facing) a3: bool) -> FragmentOutput0 { |
| return FragmentOutput0(); |
| } |
| |
| struct S26 { |
| @location(3) f0: i32, |
| @location(7) f1: i32, |
| @location(12) f2: vec3<f32>, |
| @location(13) f3: vec3<i32>, |
| @location(11) f4: vec3<i32>, |
| @location(9) f5: f32, |
| @location(2) f6: f32, |
| @builtin(instance_index) f7: u32, |
| @location(6) f8: vec3<u32>, |
| @builtin(vertex_index) f9: u32, |
| @location(8) f10: vec4<i32>, |
| @location(14) f11: f16, |
| @location(5) f12: u32, |
| @location(4) f13: vec4<f16>, |
| @location(1) f14: vec3<f32>, |
| @location(0) f15: u32 |
| } |
| |
| @vertex |
| fn vertex0(a0: S26, @location(15) a1: vec3<u32>, @location(10) a2: vec4<f32>) -> @builtin(position) vec4<f32> { |
| return vec4<f32>(0.0, 0.0, 0.0, 1.0); |
| } |
| |
| `, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| let bindGroupLayout50 = device8.createBindGroupLayout({ |
| entries: [{ |
| binding: 134, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| externalTexture: {}, |
| }], |
| }); |
| let texture140 = gpuCanvasContext27.getCurrentTexture(); |
| let textureView104 = texture140.createView({ |
| label: '\uecbf\ube89\u{1fed5}\u{1f9be}\u0eb9\u6550\u{1faeb}\u81bc', |
| dimension: '2d-array', |
| aspect: 'depth-only' |
| }); |
| let sampler97 = device8.createSampler({ |
| label: '\u1fba\u{1f89b}\u0038\ub31a\u0778', |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| lodMinClamp: 10.177, |
| lodMaxClamp: 96.464, |
| compare: 'equal', |
| maxAnisotropy: 1, |
| }); |
| let externalTexture6 = device8.importExternalTexture({ |
| label: '\ue262\u{1f83a}\u08f1', |
| source: video30, |
| colorSpace: 'srgb', |
| }); |
| try { |
| device8.queue.writeTexture({ |
| texture: texture129, |
| mipLevel: 1, |
| origin: { x: 32, y: 0, z: 0 }, |
| aspect: 'all', |
| }, arrayBuffer1, /* required buffer size: 1326 */ |
| {offset: 782, bytesPerRow: 571}, {width: 272, height: 4, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| if (!arrayBuffer7.detached) { new Uint8Array(arrayBuffer7).fill(0x55) }; |
| } catch {} |
| let img35 = await imageWithData(49, 115, '#c1c0153d', '#15ce4f81'); |
| let video38 = await videoWithData(); |
| let imageData37 = new ImageData(60, 208); |
| let renderBundle99 = renderBundleEncoder67.finish({label: '\u0932\uc2d9\u0cce\u{1f9ba}\u056c\u0147'}); |
| let sampler98 = device6.createSampler({ |
| label: '\u{1fbcf}\ufcdd\u7ae2\ue7fd', |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 4.464, |
| maxAnisotropy: 1, |
| }); |
| let commandEncoder90 = device6.createCommandEncoder({label: '\u1714\u2079\ud3b8'}); |
| let computePassEncoder69 = commandEncoder90.beginComputePass(); |
| let renderBundleEncoder94 = device6.createRenderBundleEncoder({ |
| label: '\u9f78\u3fae\u02f7\u2ccb', |
| colorFormats: ['rg32uint', 'r32sint', 'rgb10a2uint', 'rg8uint', 'rgba8unorm-srgb', 'rgb10a2uint', undefined], |
| depthStencilFormat: 'depth24plus-stencil8', |
| sampleCount: 4, |
| depthReadOnly: true, |
| stencilReadOnly: true |
| }); |
| try { |
| commandEncoder87.clearBuffer(buffer41, 38260, 580); |
| dissociateBuffer(device6, buffer41); |
| } catch {} |
| let videoFrame28 = new VideoFrame(canvas31, {timestamp: 0}); |
| let querySet82 = device8.createQuerySet({ |
| label: '\u6b8f\u7d00\udaf2\u0db4\u{1fd03}\ue2c3\u0b8b', |
| type: 'occlusion', |
| count: 1204, |
| }); |
| let renderBundleEncoder95 = device8.createRenderBundleEncoder({ |
| label: '\ua4ab\u0832\u8573\u04e9\u60e1\uea51\u01ca', |
| colorFormats: ['rg8sint', 'bgra8unorm-srgb', 'r16sint', 'r8uint', 'rgb10a2unorm', 'rg32uint'], |
| depthReadOnly: true, |
| stencilReadOnly: true |
| }); |
| let renderBundle100 = renderBundleEncoder79.finish({label: '\u7619\u{1f626}\ucadf\ub3ff\u0a57'}); |
| let pipeline87 = device8.createRenderPipeline({ |
| label: '\ud9bc\u2052\u72f3\u{1fcb9}\u6251\udc56\ufde4\u{1f9c2}\u532f', |
| layout: pipelineLayout19, |
| fragment: { |
| module: shaderModule23, |
| entryPoint: 'fragment0', |
| targets: [{format: 'rg8sint', writeMask: 0}, { |
| format: 'bgra8unorm-srgb', |
| blend: { |
| color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'}, |
| alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'}, |
| }, |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE |
| }, {format: 'r16sint', writeMask: 0}, {format: 'r8uint', writeMask: 0}, {format: 'rgb10a2unorm', writeMask: GPUColorWrite.ALL}, {format: 'rg32uint', writeMask: 0}] |
| }, |
| vertex: { |
| module: shaderModule23, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 0, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'float32x2', |
| offset: 124, |
| shaderLocation: 4, |
| }, { |
| format: 'unorm16x2', |
| offset: 920, |
| shaderLocation: 12, |
| }, { |
| format: 'uint32', |
| offset: 916, |
| shaderLocation: 6, |
| }, { |
| format: 'uint32x3', |
| offset: 1832, |
| shaderLocation: 0, |
| }, { |
| format: 'unorm16x2', |
| offset: 620, |
| shaderLocation: 10, |
| }, { |
| format: 'snorm8x4', |
| offset: 1572, |
| shaderLocation: 1, |
| }], |
| }, |
| { |
| arrayStride: 616, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'sint8x4', |
| offset: 252, |
| shaderLocation: 7, |
| }, { |
| format: 'sint16x2', |
| offset: 236, |
| shaderLocation: 3, |
| }, { |
| format: 'float32x3', |
| offset: 360, |
| shaderLocation: 2, |
| }, { |
| format: 'sint32x4', |
| offset: 292, |
| shaderLocation: 8, |
| }, { |
| format: 'uint8x2', |
| offset: 114, |
| shaderLocation: 5, |
| }, { |
| format: 'sint8x2', |
| offset: 472, |
| shaderLocation: 11, |
| }, { |
| format: 'float32', |
| offset: 408, |
| shaderLocation: 14, |
| }, { |
| format: 'uint32x3', |
| offset: 68, |
| shaderLocation: 15, |
| }], |
| }, |
| { |
| arrayStride: 640, |
| attributes: [], |
| }, |
| { |
| arrayStride: 652, |
| stepMode: 'instance', |
| attributes: [{ |
| format: 'sint16x4', |
| offset: 432, |
| shaderLocation: 13, |
| }], |
| }, |
| { |
| arrayStride: 1780, |
| attributes: [{ |
| format: 'unorm16x4', |
| offset: 1272, |
| shaderLocation: 9, |
| }], |
| } |
| ] |
| }, |
| }); |
| let texture141 = device6.createTexture({ |
| label: '\u{1fcb9}\u8208\u67a3\u{1f7a7}\u015e\u{1f78e}\u06cd', |
| size: [920, 1, 13], |
| mipLevelCount: 6, |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: ['rg32uint', 'rg32uint'], |
| }); |
| try { |
| commandEncoder87.copyBufferToBuffer(buffer31, 9316, buffer41, 30996, 23964); |
| dissociateBuffer(device6, buffer31); |
| dissociateBuffer(device6, buffer41); |
| } catch {} |
| try { |
| commandEncoder87.copyTextureToTexture({ |
| texture: texture128, |
| mipLevel: 0, |
| origin: { x: 65, y: 1, z: 2 }, |
| aspect: 'all', |
| }, { |
| texture: texture128, |
| mipLevel: 3, |
| origin: { x: 5, y: 0, z: 15 }, |
| aspect: 'all', |
| }, {width: 16, height: 0, depthOrArrayLayers: 35}); |
| } catch {} |
| try { |
| commandEncoder87.clearBuffer(buffer30, 192, 364); |
| dissociateBuffer(device6, buffer30); |
| } catch {} |
| let pipelineLayout23 = device0.createPipelineLayout({ |
| label: '\u02e8\u9ae2\ud908\u3794\u{1f6a8}\u8113\u4696\u00ef\ueb46\u{1ff39}', |
| bindGroupLayouts: [bindGroupLayout1] |
| }); |
| let commandEncoder91 = device0.createCommandEncoder({}); |
| let computePassEncoder70 = commandEncoder91.beginComputePass({label: '\u{1fac2}\u0f98'}); |
| let sampler99 = device0.createSampler({ |
| label: '\u735a\u335c\u4e26\uc7e5\uecc8', |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'clamp-to-edge', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 98.577, |
| lodMaxClamp: 98.765, |
| compare: 'equal', |
| }); |
| try { |
| computePassEncoder54.end(); |
| } catch {} |
| try { |
| renderBundleEncoder61.draw(40, 56, 24, 40); |
| } catch {} |
| try { |
| renderBundleEncoder87.setVertexBuffer(2, buffer1, 6388, 9792); |
| } catch {} |
| try { |
| commandEncoder85.copyTextureToTexture({ |
| texture: texture26, |
| mipLevel: 0, |
| origin: { x: 509, y: 1, z: 0 }, |
| aspect: 'all', |
| }, { |
| texture: texture60, |
| mipLevel: 3, |
| origin: { x: 107, y: 1, z: 0 }, |
| aspect: 'all', |
| }, {width: 515, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder83.resolveQuerySet(querySet23, 1280, 925, buffer12, 12288); |
| } catch {} |
| try { |
| renderBundleEncoder91.insertDebugMarker('\udf20'); |
| } catch {} |
| try { |
| gpuCanvasContext19.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['bgra8unorm-srgb', 'bgra8unorm-srgb', 'bgra8unorm'], |
| colorSpace: 'display-p3', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture19, |
| mipLevel: 1, |
| origin: { x: 56, y: 0, z: 125 }, |
| aspect: 'all', |
| }, arrayBuffer2, /* required buffer size: 1871729 */ |
| {offset: 20, bytesPerRow: 955, rowsPerImage: 102}, {width: 216, height: 22, depthOrArrayLayers: 20}); |
| } catch {} |
| try { |
| renderBundleEncoder43.label = '\u0ec4\u06e9\ubba4\u9360\u5cda\u015d\u{1fc42}\u4593\u0389\u0297\u0f51'; |
| } catch {} |
| try { |
| computePassEncoder40.setBindGroup(1, bindGroup25, []); |
| } catch {} |
| try { |
| renderBundleEncoder73.setBindGroup(7, bindGroup25); |
| } catch {} |
| try { |
| renderBundleEncoder77.setBindGroup(2, bindGroup25, new Uint32Array(5597), 1938, 0); |
| } catch {} |
| try { |
| renderBundleEncoder84.draw(72); |
| } catch {} |
| try { |
| renderBundleEncoder84.drawIndexed(32, 32, 24, -696); |
| } catch {} |
| try { |
| device2.queue.submit([ |
| commandBuffer19, |
| ]); |
| } catch {} |
| try { |
| device2.queue.writeTexture({ |
| texture: texture119, |
| mipLevel: 0, |
| origin: { x: 436, y: 0, z: 1 }, |
| aspect: 'all', |
| }, new BigUint64Array(arrayBuffer9), /* required buffer size: 230 */ |
| {offset: 230}, {width: 52, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline88 = await promise54; |
| let renderBundleEncoder96 = device10.createRenderBundleEncoder({ |
| label: '\u{1fca2}\u0bd0\u{1fe3d}', |
| colorFormats: ['rg16sint', 'rg32float', 'rgba16sint', 'rg16sint', undefined, 'r32uint'], |
| depthStencilFormat: 'depth24plus-stencil8' |
| }); |
| let sampler100 = device10.createSampler({ |
| label: '\udd96\u9676\ud206\u575d\u{1ffbf}\u{1fb95}\u0b4b\u{1fb69}', |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 7.703, |
| maxAnisotropy: 1, |
| }); |
| try { |
| if (!arrayBuffer12.detached) { new Uint8Array(arrayBuffer12).fill(0x55) }; |
| } catch {} |
| try { |
| await promise69; |
| } catch {} |
| try { |
| await adapter14.requestAdapterInfo(); |
| } catch {} |
| try { |
| window.someLabel = device5.queue.label; |
| } catch {} |
| let bindGroupLayout51 = device6.createBindGroupLayout({ |
| entries: [{ |
| binding: 3211, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rgba32uint', access: 'read-only', viewDimension: '2d-array' }, |
| }], |
| }); |
| let commandBuffer21 = commandEncoder87.finish({ |
| }); |
| try { |
| device6.queue.writeTexture({ |
| texture: texture100, |
| mipLevel: 0, |
| origin: { x: 72, y: 0, z: 16 }, |
| aspect: 'all', |
| }, new ArrayBuffer(80), /* required buffer size: 507376 */ |
| {offset: 226, bytesPerRow: 735, rowsPerImage: 138}, {width: 150, height: 0, depthOrArrayLayers: 6}); |
| } catch {} |
| let promise70 = device6.queue.onSubmittedWorkDone(); |
| try { |
| device6.queue.copyExternalImageToTexture(/* |
| {width: 28, height: 1, depthOrArrayLayers: 196} |
| */ |
| { |
| source: offscreenCanvas5, |
| origin: { x: 173, y: 356 }, |
| flipY: true, |
| }, { |
| texture: texture128, |
| mipLevel: 3, |
| origin: { x: 2, y: 1, z: 144 }, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 8, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| await promise70; |
| } catch {} |
| let imageData38 = new ImageData(244, 120); |
| try { |
| window.someLabel = renderBundle72.label; |
| } catch {} |
| let commandEncoder92 = device1.createCommandEncoder({label: '\u0974\u3d71\u3df9\ud6ec\udcb0\u6135\u{1f8b1}\u2be7\u49f4'}); |
| let textureView105 = texture89.createView({label: '\u{1fb43}\ud3ba\u5a37\u5534\u9dc6\u404a\ud427\u5d14', mipLevelCount: 1}); |
| let renderBundleEncoder97 = device6.createRenderBundleEncoder({ |
| colorFormats: ['rg16uint', 'rgba8sint', 'rgb10a2uint', 'rg8sint', 'rgba32sint'], |
| depthReadOnly: true, |
| stencilReadOnly: true |
| }); |
| let sampler101 = device6.createSampler({ |
| label: '\u{1fd92}\u565c\u073d\u0ac1\uf00c\u{1f8e5}\ub105', |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 68.049, |
| lodMaxClamp: 95.399, |
| maxAnisotropy: 8, |
| }); |
| try { |
| commandEncoder92.resolveQuerySet(querySet55, 1671, 167, buffer34, 18944); |
| } catch {} |
| video24.width = 62; |
| let offscreenCanvas42 = new OffscreenCanvas(324, 353); |
| let img36 = await imageWithData(123, 233, '#4321e9a8', '#8d96064e'); |
| let buffer49 = device7.createBuffer({ |
| label: '\u0bdd\u1e4f\u0a38\u009f\u5c75\ud23d\u3f2a', |
| size: 13463, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE |
| }); |
| let renderBundleEncoder98 = device7.createRenderBundleEncoder({ |
| label: '\u{1ffea}\u7e59\u{1f98e}\u046d\uc0c5\uec09\u{1f89d}\uc430\u03bd\u{1fb9d}\u{1f827}', |
| colorFormats: ['rg8unorm', 'rg16float', undefined, undefined, undefined, 'r16uint', 'rgba16uint'], |
| depthStencilFormat: 'depth24plus-stencil8', |
| sampleCount: 4, |
| stencilReadOnly: true |
| }); |
| let externalTexture7 = device7.importExternalTexture({ |
| label: '\u{1f6fd}\u{1f643}\u3f91\u0f04\u8d84\u{1f60a}\u07a0\u7a70\u{1f6d9}', |
| source: video18, |
| colorSpace: 'srgb', |
| }); |
| let querySet83 = device9.createQuerySet({ |
| label: '\u28f1\u07f3\u{1f97d}\u7963\u0742\uf816', |
| type: 'occlusion', |
| count: 1287, |
| }); |
| video4.height = 28; |
| let buffer50 = device7.createBuffer({label: '\u09eb\u0270\u{1fb03}', size: 55770, usage: GPUBufferUsage.COPY_DST}); |
| let textureView106 = texture114.createView({label: '\u{1fdf7}\ub5ca\u0b83\u185f\u30ca'}); |
| try { |
| commandEncoder82.copyBufferToTexture({ |
| /* bytesInLastRow: 348 widthInBlocks: 348 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 8458 */ |
| offset: 8458, |
| bytesPerRow: 768, |
| rowsPerImage: 64, |
| buffer: buffer44, |
| }, { |
| texture: texture93, |
| mipLevel: 0, |
| origin: { x: 249, y: 1, z: 0 }, |
| aspect: 'all', |
| }, {width: 348, height: 39, depthOrArrayLayers: 0}); |
| dissociateBuffer(device7, buffer44); |
| } catch {} |
| let querySet84 = device6.createQuerySet({ |
| label: '\u08d1\ua230\u{1fed8}\ufc38\u27f3\u0f9b\u7872\u566f\uc560', |
| type: 'occlusion', |
| count: 3421, |
| }); |
| try { |
| commandEncoder92.copyBufferToBuffer(buffer25, 1672, buffer30, 480, 60); |
| dissociateBuffer(device6, buffer25); |
| dissociateBuffer(device6, buffer30); |
| } catch {} |
| try { |
| commandEncoder92.clearBuffer(buffer30, 36, 284); |
| dissociateBuffer(device6, buffer30); |
| } catch {} |
| let gpuCanvasContext36 = offscreenCanvas42.getContext('webgpu'); |
| let imageData39 = new ImageData(136, 104); |
| let offscreenCanvas43 = new OffscreenCanvas(871, 897); |
| let bindGroupLayout52 = device10.createBindGroupLayout({ |
| label: '\u6cf7\u03c1\u0cc7\ue85e\u04eb\u{1ff2d}', |
| entries: [{ |
| binding: 778, |
| visibility: GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', minBindingSize: 0, hasDynamicOffset: true }, |
| }, { |
| binding: 279, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'uniform', minBindingSize: 0, hasDynamicOffset: true }, |
| }, { |
| binding: 423, |
| visibility: 0, |
| buffer: { type: 'read-only-storage', minBindingSize: 821739, hasDynamicOffset: true }, |
| }], |
| }); |
| let textureView107 = texture131.createView({ |
| label: '\u0325\ud1f5\ue233\u1189\u6e0e\uf380\u8638\ue035\udb8f\u1db5', |
| dimension: '2d-array', |
| mipLevelCount: 2, |
| baseArrayLayer: 0 |
| }); |
| let computePassEncoder71 = commandEncoder88.beginComputePass({label: '\u0660\ub31e\ucf43\u42fd\u0125'}); |
| let renderBundleEncoder99 = device10.createRenderBundleEncoder({ |
| label: '\u{1feba}\ucd7f\ud12c\ue409\ueba6\u620f\u8fdd\ub028\u3907\ua7ec', |
| colorFormats: ['rg16sint', 'rg32float', 'rgba16sint', 'rg16sint', undefined, 'r32uint'], |
| depthStencilFormat: 'depth24plus-stencil8' |
| }); |
| try { |
| computePassEncoder71.insertDebugMarker('\u{1fb6b}'); |
| } catch {} |
| try { |
| gpuCanvasContext26.configure({ |
| device: device10, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| device10.queue.writeTexture({ |
| texture: texture131, |
| mipLevel: 6, |
| origin: { x: 7, y: 0, z: 1 }, |
| aspect: 'all', |
| }, new Float64Array(new ArrayBuffer(0)), /* required buffer size: 640 */ |
| {offset: 640, bytesPerRow: 131}, {width: 6, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device10.queue.copyExternalImageToTexture(/* |
| {width: 16, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData14, |
| origin: { x: 121, y: 23 }, |
| flipY: false, |
| }, { |
| texture: texture131, |
| mipLevel: 6, |
| origin: { x: 5, y: 0, z: 0 }, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 3, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| let pipeline89 = device10.createRenderPipeline({ |
| layout: pipelineLayout22, |
| fragment: { |
| module: shaderModule22, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{format: 'rg32float', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.RED}, {format: 'rgba8uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE}, { |
| format: 'rgba16float', |
| blend: { |
| color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'}, |
| alpha: {operation: 'add', srcFactor: 'one-minus-constant', dstFactor: 'dst-alpha'}, |
| }, |
| writeMask: 0 |
| }, {format: 'r16uint', writeMask: 0}, {format: 'rg8sint', writeMask: GPUColorWrite.ALL}, { |
| format: 'bgra8unorm', |
| blend: { |
| color: {operation: 'reverse-subtract', srcFactor: 'one', dstFactor: 'src'}, |
| alpha: {operation: 'subtract', srcFactor: 'one-minus-src', dstFactor: 'one'}, |
| }, |
| writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN |
| }] |
| }, |
| depthStencil: { |
| format: 'depth24plus-stencil8', |
| depthWriteEnabled: false, |
| depthCompare: 'greater-equal', |
| stencilFront: { |
| failOp: 'replace', |
| depthFailOp: 'zero', |
| passOp: 'decrement-wrap', |
| }, |
| stencilBack: { |
| compare: 'not-equal', |
| failOp: 'invert', |
| depthFailOp: 'replace', |
| passOp: 'invert', |
| }, |
| stencilReadMask: 3491, |
| stencilWriteMask: 2937, |
| depthBias: 100, |
| depthBiasSlopeScale: 79, |
| depthBiasClamp: 6, |
| }, |
| vertex: { |
| module: shaderModule22, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 1308, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'float16x2', |
| offset: 700, |
| shaderLocation: 7, |
| }, { |
| format: 'float32x2', |
| offset: 156, |
| shaderLocation: 11, |
| }, { |
| format: 'uint8x2', |
| offset: 432, |
| shaderLocation: 0, |
| }, { |
| format: 'uint32x2', |
| offset: 20, |
| shaderLocation: 8, |
| }], |
| }, |
| { |
| arrayStride: 1120, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'float32x3', |
| offset: 4, |
| shaderLocation: 13, |
| }, { |
| format: 'uint8x4', |
| offset: 1072, |
| shaderLocation: 12, |
| }], |
| }, |
| { |
| arrayStride: 920, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'sint16x2', |
| offset: 736, |
| shaderLocation: 10, |
| }], |
| }, |
| { |
| arrayStride: 1056, |
| attributes: [{ |
| format: 'unorm16x2', |
| offset: 756, |
| shaderLocation: 4, |
| }], |
| } |
| ] |
| }, |
| primitive: { |
| frontFace: 'cw', |
| }, |
| }); |
| let img37 = await imageWithData(94, 22, '#25c1512f', '#fa4ca945'); |
| let bindGroupLayout53 = pipeline89.getBindGroupLayout(1); |
| let textureView108 = texture131.createView({dimension: '2d-array', aspect: 'all', baseMipLevel: 5, mipLevelCount: 1}); |
| let computePassEncoder72 = commandEncoder89.beginComputePass({label: '\u0894\uaa48\u{1f981}\ub184\u1e72\uf888\u408e'}); |
| let canvas34 = document.createElement('canvas'); |
| let offscreenCanvas44 = new OffscreenCanvas(971, 966); |
| let sampler102 = device2.createSampler({ |
| label: '\u0941\u7fd1\u20aa\u0f49\u080e', |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 98.550, |
| compare: 'always', |
| maxAnisotropy: 8, |
| }); |
| try { |
| renderBundleEncoder84.drawIndexedIndirect(buffer38, 7160); |
| } catch {} |
| let gpuCanvasContext37 = offscreenCanvas43.getContext('webgpu'); |
| gc(); |
| try { |
| await adapter1.requestAdapterInfo(); |
| } catch {} |
| let gpuCanvasContext38 = canvas34.getContext('webgpu'); |
| let shaderModule24 = device2.createShaderModule({ |
| label: '\u0ba6\u{1fd33}\u7f77\u{1fc3b}\u0f58\uf767', |
| code: `@group(4) @binding(3183) |
| var<storage, read_write> function25: array<u32>; |
| @group(5) @binding(2585) |
| var<storage, read_write> global19: array<u32>; |
| @group(3) @binding(2585) |
| var<storage, read_write> field27: array<u32>; |
| @group(0) @binding(2585) |
| var<storage, read_write> parameter23: array<u32>; |
| @group(6) @binding(3183) |
| var<storage, read_write> global20: array<u32>; |
| @group(7) @binding(2585) |
| var<storage, read_write> global21: array<u32>; |
| @group(8) @binding(3183) |
| var<storage, read_write> type13: array<u32>; |
| @group(4) @binding(2585) |
| var<storage, read_write> local16: array<u32>; |
| @group(6) @binding(2585) |
| var<storage, read_write> global22: array<u32>; |
| @group(2) @binding(2585) |
| var<storage, read_write> function26: array<u32>; |
| @group(8) @binding(2585) |
| var<storage, read_write> local17: array<u32>; |
| @group(5) @binding(3183) |
| var<storage, read_write> field28: array<u32>; |
| @group(7) @binding(3183) |
| var<storage, read_write> i26: array<u32>; |
| @group(1) @binding(3183) |
| var<storage, read_write> parameter24: array<u32>; |
| @group(3) @binding(3183) |
| var<storage, read_write> local18: array<u32>; |
| @group(1) @binding(2585) |
| var<storage, read_write> type14: array<u32>; |
| @group(2) @binding(3183) |
| var<storage, read_write> local19: array<u32>; |
| |
| @compute @workgroup_size(2, 2, 3) |
| fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {} |
| |
| |
| |
| @fragment |
| fn fragment0(@location(18) a0: vec3<f32>, @location(13) a1: vec4<f16>, @location(19) a2: vec4<f32>, @location(20) a3: vec3<u32>, @location(3) a4: vec4<u32>, @location(17) a5: f16, @location(12) a6: vec3<i32>, @builtin(sample_index) a7: u32, @builtin(position) a8: vec4<f32>, @location(4) a9: i32, @location(0) a10: vec4<u32>, @location(2) a11: f16) -> @builtin(sample_mask) u32 { |
| return u32(); |
| } |
| |
| struct S28 { |
| @location(14) f0: vec2<f32>, |
| @location(22) f1: vec4<f32>, |
| @location(7) f2: u32, |
| @location(13) f3: vec2<u32>, |
| @builtin(vertex_index) f4: u32, |
| @location(9) f5: vec3<f16>, |
| @builtin(instance_index) f6: u32, |
| @location(20) f7: vec3<f16>, |
| @location(2) f8: f32, |
| @location(21) f9: vec3<f16>, |
| @location(4) f10: vec3<u32>, |
| @location(1) f11: vec4<u32>, |
| @location(6) f12: vec3<f32>, |
| @location(18) f13: vec2<i32>, |
| @location(24) f14: vec4<f16>, |
| @location(25) f15: vec2<f32>, |
| @location(5) f16: u32, |
| @location(8) f17: vec2<f32>, |
| @location(17) f18: vec2<f16>, |
| @location(15) f19: vec3<f32>, |
| @location(19) f20: i32, |
| @location(12) f21: f16, |
| @location(11) f22: u32, |
| @location(23) f23: vec2<f32>, |
| @location(0) f24: vec2<f32>, |
| @location(26) f25: vec4<f32> |
| } |
| struct VertexOutput0 { |
| @builtin(position) f244: vec4<f32>, |
| @location(20) f245: vec3<u32>, |
| @location(14) f246: vec4<f16>, |
| @location(25) f247: vec4<u32>, |
| @location(10) f248: vec2<u32>, |
| @location(18) f249: vec3<f32>, |
| @location(0) f250: vec4<u32>, |
| @location(13) f251: vec4<f16>, |
| @location(7) f252: vec2<f32>, |
| @location(29) f253: vec3<u32>, |
| @location(21) f254: vec4<i32>, |
| @location(26) f255: vec2<i32>, |
| @location(2) f256: f16, |
| @location(4) f257: i32, |
| @location(3) f258: vec4<u32>, |
| @location(5) f259: f16, |
| @location(6) f260: vec2<f16>, |
| @location(9) f261: vec2<u32>, |
| @location(12) f262: vec3<i32>, |
| @location(19) f263: vec4<f32>, |
| @location(30) f264: vec2<f32>, |
| @location(31) f265: vec4<i32>, |
| @location(17) f266: f16 |
| } |
| |
| @vertex |
| fn vertex0(@location(16) a0: i32, @location(10) a1: vec3<u32>, @location(3) a2: vec3<f32>, a3: S28) -> VertexOutput0 { |
| return VertexOutput0(); |
| } |
| |
| `, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| let renderBundle101 = renderBundleEncoder35.finish({label: '\u007e\uc2df\u0417\u{1f9f1}\u8595\ub75b'}); |
| try { |
| computePassEncoder53.setPipeline(pipeline83); |
| } catch {} |
| try { |
| renderBundleEncoder84.drawIndexedIndirect(buffer38, 22608); |
| } catch {} |
| try { |
| renderBundleEncoder82.setVertexBuffer(1, buffer35, 29968, 1913); |
| } catch {} |
| let arrayBuffer16 = buffer17.getMappedRange(34808, 7180); |
| let pipeline90 = device2.createRenderPipeline({ |
| layout: 'auto', |
| fragment: {module: shaderModule7, entryPoint: 'fragment0', constants: {}, targets: []}, |
| depthStencil: { |
| format: 'depth24plus-stencil8', |
| depthWriteEnabled: false, |
| depthCompare: 'never', |
| stencilFront: { |
| depthFailOp: 'increment-clamp', |
| passOp: 'replace', |
| }, |
| stencilBack: { |
| compare: 'greater-equal', |
| failOp: 'invert', |
| depthFailOp: 'increment-clamp', |
| passOp: 'decrement-wrap', |
| }, |
| stencilReadMask: 2477, |
| stencilWriteMask: 2951, |
| depthBias: 32, |
| depthBiasSlopeScale: 96, |
| }, |
| vertex: { |
| module: shaderModule7, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 21252, |
| attributes: [{ |
| format: 'uint8x2', |
| offset: 3890, |
| shaderLocation: 1, |
| }, { |
| format: 'uint16x2', |
| offset: 15968, |
| shaderLocation: 8, |
| }, { |
| format: 'unorm8x2', |
| offset: 5578, |
| shaderLocation: 14, |
| }, { |
| format: 'uint8x2', |
| offset: 8392, |
| shaderLocation: 2, |
| }, { |
| format: 'uint8x4', |
| offset: 8792, |
| shaderLocation: 25, |
| }, { |
| format: 'float32', |
| offset: 4076, |
| shaderLocation: 15, |
| }, { |
| format: 'snorm16x4', |
| offset: 2316, |
| shaderLocation: 16, |
| }, { |
| format: 'float16x2', |
| offset: 6076, |
| shaderLocation: 22, |
| }, { |
| format: 'snorm16x2', |
| offset: 11324, |
| shaderLocation: 5, |
| }, { |
| format: 'sint32', |
| offset: 7232, |
| shaderLocation: 19, |
| }, { |
| format: 'uint16x2', |
| offset: 13868, |
| shaderLocation: 24, |
| }, { |
| format: 'uint8x2', |
| offset: 7788, |
| shaderLocation: 20, |
| }, { |
| format: 'sint32x4', |
| offset: 17680, |
| shaderLocation: 13, |
| }], |
| }, |
| { |
| arrayStride: 39512, |
| attributes: [{ |
| format: 'uint32x2', |
| offset: 38716, |
| shaderLocation: 21, |
| }, { |
| format: 'sint8x2', |
| offset: 14244, |
| shaderLocation: 23, |
| }], |
| } |
| ] |
| }, |
| primitive: { |
| topology: 'line-list', |
| frontFace: 'cw', |
| cullMode: 'front', |
| }, |
| }); |
| try { |
| offscreenCanvas44.getContext('2d'); |
| } catch {} |
| let adapter16 = await navigator.gpu.requestAdapter({ |
| }); |
| let commandEncoder93 = device2.createCommandEncoder({label: '\uf258\uc854\u{1f9b0}\u416a'}); |
| let texture142 = device2.createTexture({ |
| size: [1522, 1, 15], |
| mipLevelCount: 9, |
| dimension: '2d', |
| format: 'depth24plus-stencil8', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: ['depth24plus-stencil8', 'depth24plus-stencil8'], |
| }); |
| let renderBundle102 = renderBundleEncoder37.finish(); |
| let sampler103 = device2.createSampler({ |
| label: '\uc182\u5183\u76ea\ucac9\u{1ff60}\u39ce\uc41b\ud1fd\u3427\ucfab\u407f', |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'repeat', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMaxClamp: 24.637, |
| }); |
| try { |
| computePassEncoder62.setBindGroup(3, bindGroup25); |
| } catch {} |
| try { |
| renderBundleEncoder84.draw(16, 48, 64, 8); |
| } catch {} |
| try { |
| renderBundleEncoder84.drawIndexedIndirect(buffer38, 13536); |
| } catch {} |
| try { |
| commandEncoder93.resolveQuerySet(querySet54, 832, 217, buffer19, 34816); |
| } catch {} |
| try { |
| device2.queue.writeTexture({ |
| texture: texture71, |
| mipLevel: 2, |
| origin: { x: 0, y: 3, z: 0 }, |
| aspect: 'all', |
| }, new Int16Array(arrayBuffer8), /* required buffer size: 152 */ |
| {offset: 152}, {width: 80, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| let pipeline91 = await device2.createComputePipelineAsync({ |
| label: '\u{1faee}\u2195', |
| layout: pipelineLayout11, |
| compute: { |
| module: shaderModule7, |
| entryPoint: 'compute0', |
| constants: {}, |
| }, |
| }); |
| gc(); |
| let shaderModule25 = device6.createShaderModule({ |
| code: `@group(1) @binding(4378) |
| var<storage, read_write> global23: array<u32>; |
| @group(0) @binding(3874) |
| var<storage, read_write> i27: array<u32>; |
| @group(1) @binding(561) |
| var<storage, read_write> type15: array<u32>; |
| @group(1) @binding(3874) |
| var<storage, read_write> parameter25: array<u32>; |
| @group(0) @binding(4378) |
| var<storage, read_write> global24: array<u32>; |
| @group(0) @binding(561) |
| var<storage, read_write> local20: array<u32>; |
| |
| @compute @workgroup_size(1, 2, 1) |
| fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {} |
| |
| struct FragmentOutput0 { |
| @location(4) f0: vec4<f32>, |
| @location(0) f1: vec4<f32> |
| } |
| |
| @fragment |
| fn fragment0(@builtin(sample_mask) a0: u32) -> FragmentOutput0 { |
| return FragmentOutput0(); |
| } |
| |
| struct S29 { |
| @location(17) f0: vec2<f16>, |
| @location(4) f1: vec4<f16>, |
| @location(11) f2: vec4<f32> |
| } |
| |
| @vertex |
| fn vertex0(@location(3) a0: u32, @location(1) a1: i32, @location(12) a2: vec2<i32>, @location(20) a3: vec4<u32>, @builtin(instance_index) a4: u32, @location(19) a5: vec4<i32>, @location(23) a6: f32, @location(6) a7: vec3<u32>, @location(15) a8: u32, @location(21) a9: vec2<i32>, @location(18) a10: f16, @location(22) a11: f32, @location(5) a12: vec4<f16>, @location(2) a13: u32, @location(9) a14: vec4<f16>, @location(13) a15: vec2<i32>, @location(14) a16: vec3<i32>, @location(10) a17: vec3<i32>, @location(8) a18: f16, @location(7) a19: i32, a20: S29, @location(0) a21: vec3<f16>, @location(16) a22: f16, @builtin(vertex_index) a23: u32) -> @builtin(position) vec4<f32> { |
| return vec4<f32>(0.0, 0.0, 0.0, 1.0); |
| } |
| |
| `, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| let commandEncoder94 = device6.createCommandEncoder({label: '\u{1f838}\u6a5c\u{1fa7e}\ud3e1\u006e\ua449\u647f\u06fa\u03da\u{1f708}'}); |
| try { |
| device6.queue.writeTexture({ |
| texture: texture128, |
| mipLevel: 0, |
| origin: { x: 84, y: 0, z: 334 }, |
| aspect: 'all', |
| }, new Uint8ClampedArray(arrayBuffer1), /* required buffer size: 2578829 */ |
| {offset: 621, bytesPerRow: 368, rowsPerImage: 226}, {width: 30, height: 0, depthOrArrayLayers: 32}); |
| } catch {} |
| let img38 = await imageWithData(280, 223, '#2d4caf47', '#def09494'); |
| canvas31.height = 523; |
| try { |
| if (!arrayBuffer5.detached) { new Uint8Array(arrayBuffer5).fill(0x55) }; |
| } catch {} |
| let imageBitmap27 = await createImageBitmap(canvas22); |
| let bindGroup34 = device0.createBindGroup({ |
| label: '\u8443\u5a36\u05fc\u05c5\u3859\ud9e0\u6d4d\u8ee3\u{1f98f}\u0879', |
| layout: bindGroupLayout0, |
| entries: [{ |
| binding: 1160, |
| resource: externalTexture0 |
| }], |
| }); |
| let querySet85 = device0.createQuerySet({ |
| type: 'occlusion', |
| count: 1399, |
| }); |
| let sampler104 = device0.createSampler({ |
| label: '\u6e73\ud92f\u{1ff84}\u0969\ub2d6\u0678\u0283\u{1ffc3}\u646e\ud07a\u{1ff79}', |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 20.445, |
| lodMaxClamp: 87.648, |
| }); |
| try { |
| renderBundleEncoder61.setBindGroup(3, bindGroup30, new Uint32Array(5683), 2779, 0); |
| } catch {} |
| try { |
| renderBundleEncoder61.draw(0, 8, 56); |
| } catch {} |
| try { |
| commandEncoder65.copyTextureToBuffer({ |
| texture: texture12, |
| mipLevel: 0, |
| origin: { x: 336, y: 24, z: 52 }, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 2320 widthInBlocks: 145 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 26928 */ |
| offset: 22048, |
| bytesPerRow: 2560, |
| buffer: buffer3, |
| }, {width: 1740, height: 24, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| commandEncoder85.copyTextureToTexture({ |
| texture: texture19, |
| mipLevel: 3, |
| origin: { x: 36, y: 1, z: 29 }, |
| aspect: 'all', |
| }, { |
| texture: texture19, |
| mipLevel: 2, |
| origin: { x: 57, y: 6, z: 115 }, |
| aspect: 'all', |
| }, {width: 40, height: 1, depthOrArrayLayers: 37}); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: ['rgba8unorm-srgb'], |
| colorSpace: 'srgb', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture45, |
| mipLevel: 2, |
| origin: { x: 0, y: 0, z: 12 }, |
| aspect: 'all', |
| }, arrayBuffer14, /* required buffer size: 1202696 */ |
| {offset: 836, bytesPerRow: 681, rowsPerImage: 49}, {width: 144, height: 1, depthOrArrayLayers: 37}); |
| } catch {} |
| let promise71 = device0.queue.onSubmittedWorkDone(); |
| offscreenCanvas11.height = 722; |
| let commandBuffer22 = commandEncoder94.finish({ |
| label: '\u0f1d\ue84d\u6aba\u{1ff04}\u7e14\u{1f989}\u9ece\u0675', |
| }); |
| let texture143 = device6.createTexture({ |
| label: '\u20ba\uf9d7\u{1fe06}\u0dfb\uac13\ua4db\u0016\u02f3\u72be\udbc7\u7188', |
| size: [1590], |
| dimension: '1d', |
| format: 'rg16uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| device6.queue.writeTexture({ |
| texture: texture108, |
| mipLevel: 0, |
| origin: { x: 89, y: 0, z: 3 }, |
| aspect: 'all', |
| }, new Uint16Array(new ArrayBuffer(48)), /* required buffer size: 2151419 */ |
| {offset: 964, bytesPerRow: 266, rowsPerImage: 172}, {width: 111, height: 1, depthOrArrayLayers: 48}); |
| } catch {} |
| let promise72 = device6.createRenderPipelineAsync({ |
| label: '\u{1f66c}\u0347\u7d1c\u0f82\u2d1b\uefd2\u0387', |
| layout: pipelineLayout21, |
| fragment: { |
| module: shaderModule25, |
| entryPoint: 'fragment0', |
| targets: [{format: 'rgba8unorm-srgb', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE}] |
| }, |
| depthStencil: { |
| format: 'depth24plus-stencil8', |
| depthWriteEnabled: false, |
| depthCompare: 'not-equal', |
| stencilFront: { |
| compare: 'never', |
| failOp: 'zero', |
| depthFailOp: 'keep', |
| passOp: 'decrement-clamp', |
| }, |
| stencilBack: { |
| failOp: 'decrement-clamp', |
| depthFailOp: 'decrement-wrap', |
| passOp: 'increment-wrap', |
| }, |
| stencilReadMask: 1010, |
| stencilWriteMask: 2836, |
| depthBias: 60, |
| depthBiasClamp: 78, |
| }, |
| vertex: { |
| module: shaderModule25, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 14888, |
| stepMode: 'instance', |
| attributes: [{ |
| format: 'float32x4', |
| offset: 4284, |
| shaderLocation: 22, |
| }, { |
| format: 'sint8x4', |
| offset: 3252, |
| shaderLocation: 13, |
| }, { |
| format: 'sint16x4', |
| offset: 11932, |
| shaderLocation: 19, |
| }, { |
| format: 'float32', |
| offset: 9000, |
| shaderLocation: 9, |
| }, { |
| format: 'uint32', |
| offset: 2476, |
| shaderLocation: 15, |
| }, { |
| format: 'uint8x2', |
| offset: 3136, |
| shaderLocation: 3, |
| }, { |
| format: 'sint16x2', |
| offset: 8868, |
| shaderLocation: 12, |
| }, { |
| format: 'uint32x2', |
| offset: 13924, |
| shaderLocation: 20, |
| }, { |
| format: 'sint8x2', |
| offset: 7228, |
| shaderLocation: 21, |
| }, { |
| format: 'float32x2', |
| offset: 4392, |
| shaderLocation: 11, |
| }, { |
| format: 'sint16x4', |
| offset: 11952, |
| shaderLocation: 10, |
| }, { |
| format: 'sint8x2', |
| offset: 8770, |
| shaderLocation: 14, |
| }, { |
| format: 'sint16x2', |
| offset: 8884, |
| shaderLocation: 7, |
| }, { |
| format: 'float16x2', |
| offset: 11328, |
| shaderLocation: 5, |
| }, { |
| format: 'float32x2', |
| offset: 10592, |
| shaderLocation: 18, |
| }, { |
| format: 'float32x4', |
| offset: 920, |
| shaderLocation: 8, |
| }], |
| }, |
| { |
| arrayStride: 15548, |
| stepMode: 'instance', |
| attributes: [{ |
| format: 'unorm16x4', |
| offset: 2600, |
| shaderLocation: 0, |
| }], |
| }, |
| { |
| arrayStride: 17656, |
| attributes: [{ |
| format: 'uint32x3', |
| offset: 10836, |
| shaderLocation: 2, |
| }, { |
| format: 'sint32x2', |
| offset: 12732, |
| shaderLocation: 1, |
| }, { |
| format: 'float32x4', |
| offset: 16324, |
| shaderLocation: 23, |
| }], |
| }, |
| { |
| arrayStride: 30980, |
| stepMode: 'instance', |
| attributes: [{ |
| format: 'snorm16x4', |
| offset: 19080, |
| shaderLocation: 17, |
| }, { |
| format: 'snorm8x4', |
| offset: 10600, |
| shaderLocation: 4, |
| }], |
| }, |
| { |
| arrayStride: 32700, |
| stepMode: 'vertex', |
| attributes: [], |
| }, |
| { |
| arrayStride: 36628, |
| stepMode: 'instance', |
| attributes: [{ |
| format: 'float16x2', |
| offset: 14524, |
| shaderLocation: 16, |
| }], |
| }, |
| { |
| arrayStride: 0, |
| attributes: [{ |
| format: 'uint32x3', |
| offset: 6712, |
| shaderLocation: 6, |
| }], |
| } |
| ] |
| }, |
| primitive: { |
| topology: 'line-strip', |
| stripIndexFormat: 'uint16', |
| frontFace: 'cw', |
| }, |
| }); |
| try { |
| gpuCanvasContext36.unconfigure(); |
| } catch {} |
| let buffer51 = device0.createBuffer({ |
| label: '\u{1f73a}\u{1ffff}\uee24\u0f7a\u04a4\u0c64\ufb08', |
| size: 3017, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ |
| }); |
| let texture144 = gpuCanvasContext14.getCurrentTexture(); |
| try { |
| renderBundleEncoder61.drawIndexedIndirect(buffer36, 35128); |
| } catch {} |
| let arrayBuffer17 = buffer5.getMappedRange(14808, 272); |
| try { |
| commandEncoder65.clearBuffer(buffer3); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture80, |
| mipLevel: 0, |
| origin: { x: 48, y: 0, z: 32 }, |
| aspect: 'all', |
| }, new ArrayBuffer(16), /* required buffer size: 4841828 */ |
| {offset: 992, bytesPerRow: 429, rowsPerImage: 182}, {width: 144, height: 0, depthOrArrayLayers: 63}); |
| } catch {} |
| let computePassEncoder73 = commandEncoder83.beginComputePass({label: '\uf3c3\u01df\ucf4b'}); |
| try { |
| computePassEncoder39.setBindGroup(1, bindGroup12); |
| } catch {} |
| try { |
| computePassEncoder36.setPipeline(pipeline25); |
| } catch {} |
| try { |
| renderBundleEncoder61.draw(24); |
| } catch {} |
| try { |
| renderBundleEncoder61.drawIndexed(72); |
| } catch {} |
| try { |
| commandEncoder84.clearBuffer(buffer3); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture58, |
| mipLevel: 1, |
| origin: { x: 640, y: 12, z: 0 }, |
| aspect: 'all', |
| }, new Uint16Array(new ArrayBuffer(24)), /* required buffer size: 380 */ |
| {offset: 380, bytesPerRow: 2525, rowsPerImage: 39}, {width: 1160, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let pipeline92 = await device0.createRenderPipelineAsync({ |
| label: '\u{1f90b}\u{1f731}\ua72b\u885e\u72ea\u{1fae4}\u5ba2', |
| layout: pipelineLayout23, |
| multisample: { |
| }, |
| vertex: { |
| module: shaderModule4, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 0, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'uint16x4', |
| offset: 15688, |
| shaderLocation: 0, |
| }, { |
| format: 'unorm16x4', |
| offset: 16924, |
| shaderLocation: 5, |
| }, { |
| format: 'float32x2', |
| offset: 15180, |
| shaderLocation: 12, |
| }, { |
| format: 'uint32', |
| offset: 15136, |
| shaderLocation: 2, |
| }, { |
| format: 'uint32x4', |
| offset: 14880, |
| shaderLocation: 8, |
| }, { |
| format: 'sint8x2', |
| offset: 1332, |
| shaderLocation: 14, |
| }, { |
| format: 'unorm16x4', |
| offset: 1488, |
| shaderLocation: 11, |
| }], |
| }, |
| { |
| arrayStride: 12820, |
| attributes: [{ |
| format: 'uint32x3', |
| offset: 3488, |
| shaderLocation: 13, |
| }], |
| }, |
| { |
| arrayStride: 14592, |
| stepMode: 'instance', |
| attributes: [], |
| }, |
| { |
| arrayStride: 6540, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'snorm8x4', |
| offset: 6236, |
| shaderLocation: 7, |
| }], |
| } |
| ] |
| }, |
| primitive: { |
| topology: 'line-strip', |
| stripIndexFormat: 'uint32', |
| frontFace: 'ccw', |
| unclippedDepth: true, |
| }, |
| }); |
| try { |
| if (!arrayBuffer9.detached) { new Uint8Array(arrayBuffer9).fill(0x55) }; |
| } catch {} |
| let bindGroup35 = device7.createBindGroup({ |
| label: '\u3f44\u7af8\u007b\u{1f61c}', |
| layout: bindGroupLayout44, |
| entries: [{ |
| binding: 4461, |
| resource: sampler83 |
| }], |
| }); |
| let querySet86 = device7.createQuerySet({ |
| label: '\u{1fcce}\u1e3f', |
| type: 'occlusion', |
| count: 1440, |
| }); |
| let texture145 = device7.createTexture({ |
| size: {width: 420, height: 20, depthOrArrayLayers: 1}, |
| mipLevelCount: 7, |
| format: 'r8snorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder61.setBindGroup(3, bindGroup35, []); |
| } catch {} |
| try { |
| renderBundleEncoder93.setBindGroup(0, bindGroup35); |
| } catch {} |
| try { |
| commandEncoder74.clearBuffer(buffer50, 28848, 7164); |
| dissociateBuffer(device7, buffer50); |
| } catch {} |
| try { |
| commandEncoder78.resolveQuerySet(querySet47, 934, 503, buffer26, 27904); |
| } catch {} |
| try { |
| device7.queue.writeBuffer(buffer40, 8036, new BigUint64Array(19381), 19230, 20); |
| } catch {} |
| let offscreenCanvas45 = new OffscreenCanvas(207, 342); |
| let img39 = await imageWithData(278, 233, '#cd1b8d84', '#9be9a7d1'); |
| let texture146 = device8.createTexture({ |
| label: '\uc3e6\ud562\ue717', |
| size: [50, 10, 40], |
| mipLevelCount: 2, |
| format: 'astc-10x10-unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST, |
| viewFormats: [], |
| }); |
| let renderBundleEncoder100 = device8.createRenderBundleEncoder({ |
| label: '\u{1fa40}\u03b0\ub16b\u{1fd5c}\u0471\u91a4\u0110\u04b0\u{1fd4e}', |
| colorFormats: ['rg8sint', 'bgra8unorm-srgb', 'r16sint', 'r8uint', 'rgb10a2unorm', 'rg32uint'], |
| depthReadOnly: false, |
| stencilReadOnly: true |
| }); |
| let pipeline93 = device8.createComputePipeline({ |
| label: '\u3b26\ue5ce\u0945\u0cc8\u{1fceb}', |
| layout: pipelineLayout19, |
| compute: { |
| module: shaderModule23, |
| entryPoint: 'compute0', |
| constants: {}, |
| }, |
| }); |
| let imageData40 = new ImageData(32, 44); |
| let commandEncoder95 = device10.createCommandEncoder({label: '\uf4d9\u06d3'}); |
| let textureView109 = texture131.createView({label: '\u5ce1\u4c17', dimension: '2d-array', aspect: 'all', baseMipLevel: 4, baseArrayLayer: 0}); |
| let computePassEncoder74 = commandEncoder95.beginComputePass({label: '\u5756\u868d\u5e89\u950d\u43e8\ua415\u26f5\u01d5'}); |
| try { |
| renderBundleEncoder96.setVertexBuffer(50, undefined, 981846451, 2091285391); |
| } catch {} |
| let promise73 = adapter14.requestDevice({ |
| label: '\u09fd\ud3c5\u0fa4\u{1fda2}\uf6f5\u51a5\u1450\u0a3b', |
| requiredFeatures: [ |
| 'depth32float-stencil8', |
| 'texture-compression-etc2', |
| 'texture-compression-astc', |
| 'indirect-first-instance', |
| 'shader-f16', |
| 'rg11b10ufloat-renderable', |
| 'bgra8unorm-storage' |
| ], |
| requiredLimits: { |
| maxBindGroups: 5, |
| maxColorAttachmentBytesPerSample: 34, |
| maxVertexAttributes: 19, |
| maxVertexBufferArrayStride: 23461, |
| maxStorageTexturesPerShaderStage: 15, |
| maxStorageBuffersPerShaderStage: 34, |
| maxDynamicStorageBuffersPerPipelineLayout: 64175, |
| maxBindingsPerBindGroup: 6138, |
| maxTextureDimension1D: 10254, |
| maxTextureDimension2D: 16202, |
| maxVertexBuffers: 12, |
| minStorageBufferOffsetAlignment: 32, |
| maxUniformBufferBindingSize: 202685382, |
| maxUniformBuffersPerShaderStage: 16, |
| maxInterStageShaderVariables: 83, |
| maxInterStageShaderComponents: 64, |
| maxSamplersPerShaderStage: 20, |
| }, |
| }); |
| gc(); |
| let promise74 = navigator.gpu.requestAdapter({ |
| }); |
| try { |
| offscreenCanvas45.getContext('bitmaprenderer'); |
| } catch {} |
| let img40 = await imageWithData(27, 175, '#13291890', '#6ad9ed1a'); |
| let commandEncoder96 = device0.createCommandEncoder({}); |
| let commandBuffer23 = commandEncoder75.finish({ |
| label: '\u{1fa55}\ubcce\u90d0\u{1f997}\u{1fc74}\u0ea5\u{1fca9}\u0022\udadd', |
| }); |
| let textureView110 = texture45.createView({label: '\u{1f73e}\u3c7e\u0a7e\u5520\uca13', baseMipLevel: 2, mipLevelCount: 2}); |
| let renderBundleEncoder101 = device0.createRenderBundleEncoder({ |
| label: '\u{1f761}\u{1f9e5}\u{1f87f}', |
| colorFormats: ['rg8unorm', undefined], |
| depthStencilFormat: 'depth32float-stencil8', |
| depthReadOnly: true |
| }); |
| let renderBundle103 = renderBundleEncoder68.finish({label: '\ue359\uae17\uaad6\u02bf\u07c6\u0850\u0e83\u{1faba}'}); |
| let sampler105 = device0.createSampler({ |
| label: '\uaefc\u6cf0\u{1fc0f}', |
| addressModeU: 'repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 89.412, |
| lodMaxClamp: 90.256, |
| maxAnisotropy: 10, |
| }); |
| try { |
| renderBundleEncoder80.setBindGroup(0, bindGroup34); |
| } catch {} |
| try { |
| renderBundleEncoder85.setIndexBuffer(buffer10, 'uint32', 47216, 8595); |
| } catch {} |
| try { |
| commandEncoder96.resolveQuerySet(querySet10, 1350, 17, buffer24, 0); |
| } catch {} |
| try { |
| device0.queue.submit([ |
| commandBuffer23, |
| commandBuffer4, |
| ]); |
| } catch {} |
| let promise75 = device0.queue.onSubmittedWorkDone(); |
| gc(); |
| let img41 = await imageWithData(242, 68, '#7c7935da', '#1202e075'); |
| try { |
| if (!arrayBuffer4.detached) { new Uint8Array(arrayBuffer4).fill(0x55) }; |
| } catch {} |
| let canvas35 = document.createElement('canvas'); |
| let video39 = await videoWithData(); |
| let buffer52 = device9.createBuffer({ |
| label: '\u02ab\u6341\u9270\u0c1b\u0525\u060d', |
| size: 41636, |
| usage: GPUBufferUsage.QUERY_RESOLVE, |
| mappedAtCreation: false |
| }); |
| try { |
| gpuCanvasContext12.configure({ |
| device: device9, |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| colorSpace: 'display-p3', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let texture147 = device9.createTexture({ |
| label: '\u9253\uaed1\u8ad9\u16c6\u32a0\u{1f9b9}\u{1febe}\ub0fa\uf8a7\u{1fb58}', |
| size: [40], |
| dimension: '1d', |
| format: 'rg8snorm', |
| usage: GPUTextureUsage.COPY_DST, |
| viewFormats: ['rg8snorm'], |
| }); |
| let gpuCanvasContext39 = canvas35.getContext('webgpu'); |
| try { |
| adapter9.label = '\u033f\u03f1\ud362\ub439\uda80\ucbe4\u{1f788}\u813f\u6037'; |
| } catch {} |
| try { |
| if (!arrayBuffer9.detached) { new Uint8Array(arrayBuffer9).fill(0x55) }; |
| } catch {} |
| let offscreenCanvas46 = new OffscreenCanvas(98, 925); |
| try { |
| offscreenCanvas46.getContext('webgpu'); |
| } catch {} |
| let commandEncoder97 = device7.createCommandEncoder({}); |
| let renderBundleEncoder102 = device7.createRenderBundleEncoder({ |
| label: '\u283c\u7337\u6e79\u7fb3\u61cb\ud4da\u8c99\u09a3\u46cc', |
| colorFormats: [], |
| depthStencilFormat: 'depth32float-stencil8' |
| }); |
| try { |
| renderBundleEncoder64.setVertexBuffer(5, buffer42, 40908); |
| } catch {} |
| try { |
| commandEncoder97.clearBuffer(buffer50, 29200, 11096); |
| dissociateBuffer(device7, buffer50); |
| } catch {} |
| try { |
| commandEncoder97.resolveQuerySet(querySet86, 1001, 343, buffer26, 4608); |
| } catch {} |
| let querySet87 = device6.createQuerySet({ |
| label: '\u1aeb\u1339\u{1f8cf}\u0aab\u4fe6\ub1f5\ueeba\u{1f650}', |
| type: 'occlusion', |
| count: 2559, |
| }); |
| let computePassEncoder75 = commandEncoder92.beginComputePass({}); |
| let renderBundleEncoder103 = device6.createRenderBundleEncoder({colorFormats: ['rgba8unorm-srgb'], depthStencilFormat: 'depth24plus-stencil8', depthReadOnly: true}); |
| let sampler106 = device6.createSampler({ |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 42.121, |
| lodMaxClamp: 97.594, |
| maxAnisotropy: 16, |
| }); |
| try { |
| device6.queue.writeTexture({ |
| texture: texture136, |
| mipLevel: 0, |
| origin: { x: 57, y: 0, z: 0 }, |
| aspect: 'all', |
| }, arrayBuffer1, /* required buffer size: 792 */ |
| {offset: 792}, {width: 354, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| offscreenCanvas5.height = 921; |
| let buffer53 = device0.createBuffer({ |
| label: '\u0b0b\u3bc6', |
| size: 13920, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ, |
| mappedAtCreation: true |
| }); |
| let texture148 = device0.createTexture({ |
| label: '\ua961\u8e51\ub6d7\uacd0\u0a7b\u0cdb\u050a\u8c0c\u0ae2\u5e2a', |
| size: [80, 960, 1], |
| mipLevelCount: 9, |
| format: 'astc-8x8-unorm', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderBundleEncoder104 = device0.createRenderBundleEncoder({ |
| label: '\ue652\u0b47\u0ab3\u2784\u1751\u9bc2', |
| colorFormats: ['r8sint', 'rg8uint', 'rgba32sint', 'rgba8unorm', 'r8uint'], |
| depthStencilFormat: 'depth24plus-stencil8', |
| sampleCount: 1, |
| depthReadOnly: true, |
| stencilReadOnly: true |
| }); |
| let renderBundle104 = renderBundleEncoder6.finish({label: '\u409e\ufb21\u0fa5\u{1f9eb}\u6758\uf8ca\u0060'}); |
| try { |
| computePassEncoder36.setBindGroup(3, bindGroup10); |
| } catch {} |
| try { |
| computePassEncoder57.setPipeline(pipeline81); |
| } catch {} |
| try { |
| renderBundleEncoder61.draw(48, 72, 64); |
| } catch {} |
| try { |
| renderBundleEncoder80.drawIndexed(64, 80, 16, -608, 0); |
| } catch {} |
| try { |
| commandEncoder65.copyBufferToBuffer(buffer45, 32884, buffer12, 4472, 15068); |
| dissociateBuffer(device0, buffer45); |
| dissociateBuffer(device0, buffer12); |
| } catch {} |
| try { |
| commandEncoder85.copyBufferToTexture({ |
| /* bytesInLastRow: 350 widthInBlocks: 175 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 17044 */ |
| offset: 17044, |
| buffer: buffer37, |
| }, { |
| texture: texture18, |
| mipLevel: 2, |
| origin: { x: 35, y: 0, z: 0 }, |
| aspect: 'all', |
| }, {width: 175, height: 0, depthOrArrayLayers: 1}); |
| dissociateBuffer(device0, buffer37); |
| } catch {} |
| try { |
| commandEncoder84.clearBuffer(buffer12, 11424, 14316); |
| dissociateBuffer(device0, buffer12); |
| } catch {} |
| try { |
| commandEncoder84.resolveQuerySet(querySet69, 790, 1636, buffer27, 27648); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer51, 3012, new DataView(new ArrayBuffer(27422)), 2269, 0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture30, |
| mipLevel: 0, |
| origin: { x: 0, y: 0, z: 0 }, |
| aspect: 'all', |
| }, arrayBuffer13, /* required buffer size: 152 */ |
| {offset: 134}, {width: 9, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| let texture149 = device9.createTexture({ |
| label: '\u7b32\u{1fefb}\u35c6\u747e', |
| size: {width: 40, height: 15, depthOrArrayLayers: 1}, |
| sampleCount: 1, |
| format: 'astc-8x5-unorm', |
| usage: GPUTextureUsage.COPY_SRC, |
| viewFormats: ['astc-8x5-unorm'], |
| }); |
| let renderBundleEncoder105 = device9.createRenderBundleEncoder({ |
| label: '\ucbdd\u4b94\u013d\u13c3\u0cec\ub6f5\u{1fdce}', |
| colorFormats: [undefined, 'rgba8sint', 'rg32float', 'bgra8unorm', 'rg32uint', 'r32uint'], |
| depthStencilFormat: 'depth32float-stencil8', |
| sampleCount: 4, |
| depthReadOnly: true |
| }); |
| try { |
| renderBundleEncoder105.setVertexBuffer(60, undefined, 1893619484, 1240299974); |
| } catch {} |
| try { |
| device9.queue.writeTexture({ |
| texture: texture135, |
| mipLevel: 4, |
| origin: { x: 0, y: 0, z: 1 }, |
| aspect: 'all', |
| }, arrayBuffer8, /* required buffer size: 31 */ |
| {offset: 31}, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let offscreenCanvas47 = new OffscreenCanvas(211, 475); |
| let commandEncoder98 = device0.createCommandEncoder({}); |
| let querySet88 = device0.createQuerySet({ |
| type: 'occlusion', |
| count: 3979, |
| }); |
| try { |
| renderBundleEncoder80.drawIndexedIndirect(buffer3, 38900); |
| } catch {} |
| try { |
| commandEncoder85.copyBufferToBuffer(buffer37, 25836, buffer53, 5668, 2816); |
| dissociateBuffer(device0, buffer37); |
| dissociateBuffer(device0, buffer53); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let pipeline94 = device0.createRenderPipeline({ |
| label: '\u3b53\u015f\ucfc4\u6aae\u39f8\u{1f82d}\u0150', |
| layout: pipelineLayout2, |
| multisample: { |
| mask: 0x6bc250ff, |
| }, |
| fragment: { |
| module: shaderModule14, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{format: 'rg16uint', writeMask: 0}, {format: 'r16sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.RED}, {format: 'r16float'}, {format: 'rgba16sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN | GPUColorWrite.RED}] |
| }, |
| depthStencil: { |
| format: 'depth24plus-stencil8', |
| depthWriteEnabled: true, |
| depthCompare: 'never', |
| stencilFront: { |
| compare: 'greater', |
| depthFailOp: 'increment-clamp', |
| passOp: 'decrement-clamp', |
| }, |
| stencilBack: { |
| failOp: 'invert', |
| depthFailOp: 'zero', |
| }, |
| stencilReadMask: 1092, |
| depthBias: 30, |
| depthBiasSlopeScale: 80, |
| depthBiasClamp: 77, |
| }, |
| vertex: { |
| module: shaderModule14, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 5472, |
| stepMode: 'instance', |
| attributes: [{ |
| format: 'unorm16x4', |
| offset: 2756, |
| shaderLocation: 15, |
| }, { |
| format: 'snorm8x4', |
| offset: 2504, |
| shaderLocation: 10, |
| }, { |
| format: 'float32x3', |
| offset: 1040, |
| shaderLocation: 5, |
| }, { |
| format: 'snorm8x4', |
| offset: 2708, |
| shaderLocation: 2, |
| }, { |
| format: 'snorm8x2', |
| offset: 2502, |
| shaderLocation: 8, |
| }, { |
| format: 'unorm16x2', |
| offset: 2640, |
| shaderLocation: 13, |
| }, { |
| format: 'snorm8x2', |
| offset: 2044, |
| shaderLocation: 1, |
| }, { |
| format: 'snorm8x2', |
| offset: 4458, |
| shaderLocation: 4, |
| }, { |
| format: 'sint16x4', |
| offset: 2136, |
| shaderLocation: 6, |
| }, { |
| format: 'sint32x4', |
| offset: 4892, |
| shaderLocation: 14, |
| }, { |
| format: 'sint32', |
| offset: 3604, |
| shaderLocation: 3, |
| }, { |
| format: 'sint32', |
| offset: 5152, |
| shaderLocation: 11, |
| }], |
| }, |
| { |
| arrayStride: 4872, |
| attributes: [], |
| }, |
| { |
| arrayStride: 2088, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'sint16x4', |
| offset: 272, |
| shaderLocation: 9, |
| }, { |
| format: 'float16x4', |
| offset: 316, |
| shaderLocation: 7, |
| }, { |
| format: 'snorm8x4', |
| offset: 652, |
| shaderLocation: 0, |
| }, { |
| format: 'sint32', |
| offset: 444, |
| shaderLocation: 12, |
| }], |
| } |
| ] |
| }, |
| primitive: { |
| topology: 'point-list', |
| frontFace: 'cw', |
| }, |
| }); |
| try { |
| await promise71; |
| } catch {} |
| let commandEncoder99 = device9.createCommandEncoder({label: '\u0257\u2f3c\u{1f8df}\u05aa\u{1fb5c}\u0af7\u4356\u067c\u84fe'}); |
| try { |
| computePassEncoder66.pushDebugGroup('\u895a'); |
| } catch {} |
| let bindGroupLayout54 = pipeline89.getBindGroupLayout(0); |
| let commandEncoder100 = device10.createCommandEncoder({label: '\u0bb6\u{1fe5f}\ua929\ua1de\ucf49\u17f0\ud69e\u{1fad6}'}); |
| let texture150 = device10.createTexture({ |
| label: '\u9d60\u{1f9b0}', |
| size: [120], |
| dimension: '1d', |
| format: 'rg16uint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView111 = texture131.createView({label: '\u0aa7\u0f28\u0762\u{1f9dc}', baseMipLevel: 2, mipLevelCount: 2}); |
| try { |
| device10.queue.writeTexture({ |
| texture: texture131, |
| mipLevel: 0, |
| origin: { x: 201, y: 36, z: 1 }, |
| aspect: 'all', |
| }, arrayBuffer16, /* required buffer size: 484 */ |
| {offset: 484, bytesPerRow: 3519}, {width: 824, height: 25, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline95 = await device10.createRenderPipelineAsync({ |
| label: '\u509a\u02a6\u{1fd98}\ue943\uc15f\u{1fbd5}', |
| layout: 'auto', |
| multisample: { |
| count: 4, |
| }, |
| fragment: { |
| module: shaderModule22, |
| entryPoint: 'fragment0', |
| targets: [{ |
| format: 'rg32float', |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED |
| }, {format: 'rgba8uint', writeMask: GPUColorWrite.RED}, {format: 'rgba16float', writeMask: 0}, { |
| format: 'r16uint', |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED |
| }, {format: 'rg8sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.RED}, {format: 'bgra8unorm', writeMask: 0}] |
| }, |
| depthStencil: { |
| format: 'depth32float-stencil8', |
| depthWriteEnabled: true, |
| depthCompare: 'greater-equal', |
| stencilFront: { |
| compare: 'equal', |
| failOp: 'decrement-clamp', |
| passOp: 'decrement-clamp', |
| }, |
| stencilBack: { |
| compare: 'greater', |
| depthFailOp: 'zero', |
| }, |
| stencilReadMask: 2150, |
| stencilWriteMask: 4000, |
| depthBias: 62, |
| depthBiasSlopeScale: 25, |
| depthBiasClamp: 38, |
| }, |
| vertex: { |
| module: shaderModule22, |
| entryPoint: 'vertex0', |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 1988, |
| attributes: [{ |
| format: 'uint32', |
| offset: 856, |
| shaderLocation: 0, |
| }, { |
| format: 'uint32', |
| offset: 1504, |
| shaderLocation: 12, |
| }, { |
| format: 'unorm8x4', |
| offset: 1512, |
| shaderLocation: 13, |
| }, { |
| format: 'sint8x4', |
| offset: 1512, |
| shaderLocation: 10, |
| }], |
| }, |
| { |
| arrayStride: 1564, |
| stepMode: 'instance', |
| attributes: [{ |
| format: 'float32x4', |
| offset: 760, |
| shaderLocation: 4, |
| }, { |
| format: 'uint32x4', |
| offset: 1180, |
| shaderLocation: 8, |
| }, { |
| format: 'snorm8x2', |
| offset: 412, |
| shaderLocation: 11, |
| }, { |
| format: 'unorm10-10-10-2', |
| offset: 880, |
| shaderLocation: 7, |
| }], |
| } |
| ] |
| }, |
| }); |
| let canvas36 = document.createElement('canvas'); |
| let textureView112 = texture89.createView({label: '\u{1ffe7}\ue107\u9f0e\u05fa\u{1faba}\u890f\u3cdc\uc5e4\u63a6\u0c6e\u931b', dimension: '1d'}); |
| try { |
| device6.queue.copyExternalImageToTexture(/* |
| {width: 115, height: 1, depthOrArrayLayers: 784} |
| */ |
| { |
| source: video11, |
| origin: { x: 4, y: 10 }, |
| flipY: false, |
| }, { |
| texture: texture128, |
| mipLevel: 1, |
| origin: { x: 66, y: 1, z: 443 }, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 11, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline96 = await device6.createComputePipelineAsync({ |
| label: '\ue1f5\u{1fad6}\u2a03\ua858\u0060\ud41d\u0c42\uf953\u7f71', |
| layout: 'auto', |
| compute: { |
| module: shaderModule25, |
| entryPoint: 'compute0', |
| constants: {}, |
| }, |
| }); |
| try { |
| await promise75; |
| } catch {} |
| let imageData41 = new ImageData(204, 256); |
| let querySet89 = device10.createQuerySet({ |
| type: 'occlusion', |
| count: 3533, |
| }); |
| let renderBundle105 = renderBundleEncoder99.finish({}); |
| let sampler107 = device10.createSampler({ |
| label: '\u7b86\u7b70\u{1fc0c}', |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'clamp-to-edge', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 31.787, |
| lodMaxClamp: 71.667, |
| }); |
| try { |
| device10.queue.writeTexture({ |
| texture: texture131, |
| mipLevel: 1, |
| origin: { x: 134, y: 11, z: 0 }, |
| aspect: 'all', |
| }, new Float32Array(arrayBuffer1), /* required buffer size: 31576 */ |
| {offset: 1000, bytesPerRow: 1624}, {width: 336, height: 19, depthOrArrayLayers: 1}); |
| } catch {} |
| let pipeline97 = device10.createComputePipeline({ |
| label: '\u0a4c\u9577\u0ff0\u06dd\u{1fa58}\u0107\u0625\uc9fb\u492a\udb8b\u07e4', |
| layout: pipelineLayout22, |
| compute: { |
| module: shaderModule22, |
| entryPoint: 'compute0', |
| constants: {}, |
| }, |
| }); |
| let gpuCanvasContext40 = canvas36.getContext('webgpu'); |
| document.body.prepend(canvas12); |
| offscreenCanvas30.width = 72; |
| let img42 = await imageWithData(255, 271, '#ab3f62fc', '#2678e2e6'); |
| let computePassEncoder76 = commandEncoder93.beginComputePass({}); |
| let renderBundleEncoder106 = device2.createRenderBundleEncoder({colorFormats: [], depthStencilFormat: 'depth24plus-stencil8', sampleCount: 4, stencilReadOnly: true}); |
| let renderBundle106 = renderBundleEncoder43.finish({label: '\u1a64\uac30\u1f31\u25d9\u6121\ua1a4\ua99a\u0aca\u{1fa31}\u0fcf'}); |
| try { |
| renderBundleEncoder84.drawIndirect(buffer38, 6984); |
| } catch {} |
| try { |
| await device2.queue.onSubmittedWorkDone(); |
| } catch {} |
| let gpuCanvasContext41 = offscreenCanvas47.getContext('webgpu'); |
| try { |
| gpuCanvasContext39.unconfigure(); |
| } catch {} |
| let querySet90 = device7.createQuerySet({ |
| type: 'occlusion', |
| count: 3221, |
| }); |
| let texture151 = device7.createTexture({ |
| label: '\u8d7f\uecdc\u6c58\u32ae\u6208\u{1fa4c}\uc639\u24f5', |
| size: {width: 1248, height: 1, depthOrArrayLayers: 249}, |
| mipLevelCount: 1, |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| renderBundleEncoder102.setBindGroup(2, bindGroup35); |
| } catch {} |
| try { |
| device7.queue.writeBuffer(buffer50, 2292, new BigUint64Array(60087), 2111, 4656); |
| } catch {} |
| try { |
| if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55) }; |
| } catch {} |
| let bindGroupLayout55 = device2.createBindGroupLayout({ |
| label: '\u0e6e\u29c5\u0253\u33fa\ud6cf\u06a6\u{1f99b}\u{1fcb4}', |
| entries: [{ |
| binding: 3171, |
| visibility: 0, |
| externalTexture: {}, |
| }], |
| }); |
| let sampler108 = device2.createSampler({ |
| label: '\u0ede\u26d5\u9c78\u4078\u6c29\u{1ffa9}\u038f\u0699\ub2a0\ue776\u0c46', |
| addressModeU: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 0.958, |
| lodMaxClamp: 37.076, |
| compare: 'never', |
| maxAnisotropy: 14, |
| }); |
| try { |
| computePassEncoder41.setBindGroup(8, bindGroup25); |
| } catch {} |
| try { |
| renderBundleEncoder84.drawIndexedIndirect(buffer38, 27692); |
| } catch {} |
| try { |
| renderBundleEncoder84.drawIndirect(buffer38, 9844); |
| } catch {} |
| try { |
| renderBundleEncoder84.setPipeline(pipeline71); |
| } catch {} |
| let promise76 = device2.createComputePipelineAsync({ |
| label: '\u8420\u2f7e\uf454\udb30\ua4eb\u0959\u7ad5\u512c', |
| layout: pipelineLayout11, |
| compute: { |
| module: shaderModule7, |
| entryPoint: 'compute0', |
| constants: {}, |
| }, |
| }); |
| let computePassEncoder77 = commandEncoder99.beginComputePass({}); |
| try { |
| await device9.queue.onSubmittedWorkDone(); |
| } catch {} |
| let device11 = await adapter16.requestDevice({ |
| label: '\ua5ba\u0ff7\u{1f6a5}\u17db\u1743\u5b34', |
| requiredFeatures: [ |
| 'depth-clip-control', |
| 'depth32float-stencil8', |
| 'texture-compression-etc2', |
| 'texture-compression-astc', |
| 'indirect-first-instance', |
| 'shader-f16', |
| 'rg11b10ufloat-renderable', |
| 'bgra8unorm-storage' |
| ], |
| requiredLimits: { |
| maxBindGroups: 5, |
| maxColorAttachmentBytesPerSample: 33, |
| maxVertexAttributes: 17, |
| maxVertexBufferArrayStride: 24454, |
| maxStorageTexturesPerShaderStage: 18, |
| maxStorageBuffersPerShaderStage: 10, |
| maxDynamicStorageBuffersPerPipelineLayout: 56122, |
| maxBindingsPerBindGroup: 7210, |
| maxTextureDimension1D: 15228, |
| maxTextureDimension2D: 8555, |
| maxVertexBuffers: 10, |
| minStorageBufferOffsetAlignment: 32, |
| minUniformBufferOffsetAlignment: 64, |
| maxUniformBufferBindingSize: 134276143, |
| maxUniformBuffersPerShaderStage: 39, |
| maxInterStageShaderVariables: 23, |
| maxInterStageShaderComponents: 68, |
| maxSamplersPerShaderStage: 21, |
| }, |
| }); |
| let video40 = await videoWithData(); |
| let adapter17 = await promise74; |
| let canvas37 = document.createElement('canvas'); |
| try { |
| await adapter0.requestAdapterInfo(); |
| } catch {} |
| let buffer54 = device7.createBuffer({ |
| label: '\u3754\u0be5\ub1d4\ua210\u0289\u9e77\u0b81\u{1fe72}\u{1f823}', |
| size: 18020, |
| usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| mappedAtCreation: true |
| }); |
| let querySet91 = device7.createQuerySet({ |
| label: '\ufcaf\u7f07\u27bd\u0a00\u0763', |
| type: 'occlusion', |
| count: 658, |
| }); |
| let textureView113 = texture126.createView({ |
| label: '\u8047\u015b\u{1ff8d}\u0105\ucf66\uff86\u01cb\u02c4\u83ac\u{1fc19}\u0620', |
| dimension: '2d-array', |
| baseMipLevel: 7, |
| mipLevelCount: 2 |
| }); |
| let renderBundleEncoder107 = device7.createRenderBundleEncoder({ |
| label: '\u0f5c\u01e2\u{1fdaa}\u018e\uc903', |
| colorFormats: ['rg8unorm', 'rg16float', undefined, undefined, undefined, 'r16uint', 'rgba16uint'], |
| depthStencilFormat: 'depth24plus-stencil8', |
| sampleCount: 4, |
| depthReadOnly: true |
| }); |
| let renderBundle107 = renderBundleEncoder83.finish({label: '\u{1f7f2}\ub821\u1c3e\u2de5\uf6dd\u{1fd0f}\u{1fc67}\ucaf4'}); |
| try { |
| renderBundleEncoder88.setBindGroup(3, bindGroup35); |
| } catch {} |
| try { |
| computePassEncoder47.insertDebugMarker('\ud0fa'); |
| } catch {} |
| let device12 = await promise73; |
| let querySet92 = device12.createQuerySet({ |
| label: '\ub237\u024c\u04e2\u34e6', |
| type: 'occlusion', |
| count: 3921, |
| }); |
| try { |
| gpuCanvasContext26.configure({ |
| device: device12, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['depth16unorm', 'rgba16float', 'rgba16float', 'r32float'], |
| colorSpace: 'srgb', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let imageData42 = new ImageData(208, 176); |
| try { |
| if (!arrayBuffer6.detached) { new Uint8Array(arrayBuffer6).fill(0x55) }; |
| } catch {} |
| let shaderModule26 = device6.createShaderModule({ |
| label: '\u334f\u03f8\u{1faee}\u54be\u15ee\u0b00\u09ae\u{1fdc0}\u0144', |
| code: `@group(1) @binding(3874) |
| var<storage, read_write> global25: array<u32>; |
| @group(1) @binding(4378) |
| var<storage, read_write> parameter26: array<u32>; |
| @group(0) @binding(3874) |
| var<storage, read_write> type16: array<u32>; |
| @group(1) @binding(561) |
| var<storage, read_write> parameter27: array<u32>; |
| @group(0) @binding(561) |
| var<storage, read_write> global26: array<u32>; |
| @group(0) @binding(4378) |
| var<storage, read_write> parameter28: array<u32>; |
| |
| @compute @workgroup_size(7, 4, 4) |
| fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {} |
| |
| struct FragmentOutput0 { |
| @location(3) f0: vec3<u32>, |
| @location(4) f1: vec4<f32>, |
| @location(2) f2: vec4<u32>, |
| @location(5) f3: vec4<u32>, |
| @location(0) f4: vec2<u32>, |
| @location(1) f5: vec3<i32> |
| } |
| |
| @fragment |
| fn fragment0(@location(25) a0: vec3<f16>) -> FragmentOutput0 { |
| return FragmentOutput0(); |
| } |
| |
| struct VertexOutput0 { |
| @location(2) f267: f32, |
| @location(25) f268: vec3<f16>, |
| @location(18) f269: vec4<u32>, |
| @builtin(position) f270: vec4<f32>, |
| @location(24) f271: f16 |
| } |
| |
| @vertex |
| fn vertex0(@location(17) a0: vec4<u32>, @builtin(instance_index) a1: u32, @location(13) a2: vec3<u32>, @location(6) a3: vec4<u32>, @location(23) a4: vec2<u32>, @location(7) a5: f16, @location(3) a6: vec3<f16>, @location(14) a7: vec4<f32>, @location(11) a8: vec3<i32>, @location(12) a9: vec3<f16>) -> VertexOutput0 { |
| return VertexOutput0(); |
| } |
| |
| `, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| let textureView114 = texture123.createView({dimension: '2d', baseMipLevel: 1, mipLevelCount: 2, baseArrayLayer: 89}); |
| let renderBundleEncoder108 = device6.createRenderBundleEncoder({ |
| label: '\u0f74\u0c06\u5dd1\u1996', |
| colorFormats: ['rgba8unorm-srgb'], |
| depthStencilFormat: 'depth24plus-stencil8', |
| sampleCount: 1 |
| }); |
| try { |
| device6.queue.writeTexture({ |
| texture: texture136, |
| mipLevel: 1, |
| origin: { x: 52, y: 0, z: 0 }, |
| aspect: 'all', |
| }, arrayBuffer9, /* required buffer size: 720 */ |
| {offset: 720, rowsPerImage: 265}, {width: 147, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await device6.queue.onSubmittedWorkDone(); |
| } catch {} |
| document.body.prepend(canvas8); |
| let shaderModule27 = device7.createShaderModule({ |
| label: '\u901f\u844c\u{1fc63}\u{1f8ba}\u{1fddd}\u0c69\u2d1d\u0fd4\u0c32\uc21d\udb73', |
| code: `@group(0) @binding(3660) |
| var<storage, read_write> field29: array<u32>; |
| @group(0) @binding(4730) |
| var<storage, read_write> global27: array<u32>; |
| @group(1) @binding(4730) |
| var<storage, read_write> global28: array<u32>; |
| @group(1) @binding(3660) |
| var<storage, read_write> field30: array<u32>; |
| |
| @compute @workgroup_size(7, 4, 1) |
| fn compute0(@builtin(global_invocation_id) global_id : vec3<u32>, @builtin(local_invocation_id) local_id : vec3<u32>) {} |
| |
| struct S30 { |
| @location(27) f0: f16, |
| @location(23) f1: vec3<f32> |
| } |
| |
| @fragment |
| fn fragment0(@builtin(front_facing) a0: bool, @location(19) a1: vec4<i32>, @location(29) a2: vec3<u32>, @location(41) a3: vec3<f16>, @location(9) a4: vec4<f32>, @builtin(position) a5: vec4<f32>, @location(11) a6: vec2<f16>, @location(7) a7: f16, @location(22) a8: vec4<i32>, @location(6) a9: i32, @builtin(sample_mask) a10: u32, @location(25) a11: vec4<f16>, @location(5) a12: i32, a13: S30, @builtin(sample_index) a14: u32, @location(15) a15: vec4<f16>, @location(3) a16: vec3<f32>, @location(16) a17: i32, @location(38) a18: i32, @location(43) a19: vec2<i32>, @location(44) a20: f16, @location(30) a21: vec4<i32>, @location(37) a22: vec4<u32>, @location(32) a23: vec4<i32>, @location(13) a24: u32, @location(2) a25: vec4<f32>) { |
| |
| } |
| |
| struct VertexOutput0 { |
| @location(5) f272: i32, |
| @location(41) f273: vec3<f16>, |
| @location(32) f274: vec4<i32>, |
| @location(6) f275: i32, |
| @location(23) f276: vec3<f32>, |
| @builtin(position) f277: vec4<f32>, |
| @location(27) f278: f16, |
| @location(22) f279: vec4<i32>, |
| @location(25) f280: vec4<f16>, |
| @location(3) f281: vec3<f32>, |
| @location(11) f282: vec2<f16>, |
| @location(37) f283: vec4<u32>, |
| @location(15) f284: vec4<f16>, |
| @location(44) f285: f16, |
| @location(19) f286: vec4<i32>, |
| @location(9) f287: vec4<f32>, |
| @location(13) f288: u32, |
| @location(38) f289: i32, |
| @location(28) f290: vec2<u32>, |
| @location(21) f291: vec4<f32>, |
| @location(17) f292: vec4<i32>, |
| @location(30) f293: vec4<i32>, |
| @location(31) f294: vec2<f16>, |
| @location(29) f295: vec3<u32>, |
| @location(7) f296: f16, |
| @location(2) f297: vec4<f32>, |
| @location(16) f298: i32, |
| @location(43) f299: vec2<i32> |
| } |
| |
| @vertex |
| fn vertex0(@location(2) a0: vec3<i32>, @location(0) a1: vec2<f16>, @location(20) a2: vec2<f32>, @location(6) a3: vec4<f32>) -> VertexOutput0 { |
| return VertexOutput0(); |
| } |
| |
| `, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| let pipelineLayout24 = device7.createPipelineLayout({label: '\u0dba\ua5a0', bindGroupLayouts: [bindGroupLayout34, bindGroupLayout40]}); |
| let commandEncoder101 = device7.createCommandEncoder({label: '\ud2f8\u{1f900}'}); |
| let texture152 = device7.createTexture({ |
| label: '\ub4d5\u{1fc80}\u2bf4\u803e\u6a48\u03c9\u0898\u3915\ua06f\u{1fadb}\u{1f8e0}', |
| size: {width: 2496, height: 1, depthOrArrayLayers: 196}, |
| mipLevelCount: 5, |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rg8unorm'], |
| }); |
| let renderBundle108 = renderBundleEncoder86.finish({label: '\uc271\u2c96\u29d0\ue810\u8f0c\uf2b6\u0830\u04d5\u4dea\uc9e0\uce97'}); |
| try { |
| computePassEncoder60.end(); |
| } catch {} |
| try { |
| commandEncoder78.copyTextureToBuffer({ |
| texture: texture125, |
| mipLevel: 1, |
| origin: { x: 133, y: 3, z: 0 }, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 464 widthInBlocks: 116 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 27100 */ |
| offset: 27100, |
| bytesPerRow: 512, |
| buffer: buffer50, |
| }, {width: 116, height: 5, depthOrArrayLayers: 0}); |
| dissociateBuffer(device7, buffer50); |
| } catch {} |
| try { |
| commandEncoder101.clearBuffer(buffer40, 21560, 40); |
| dissociateBuffer(device7, buffer40); |
| } catch {} |
| try { |
| computePassEncoder59.insertDebugMarker('\uc880'); |
| } catch {} |
| try { |
| device7.queue.writeTexture({ |
| texture: texture114, |
| mipLevel: 0, |
| origin: { x: 2458, y: 0, z: 0 }, |
| aspect: 'all', |
| }, arrayBuffer6, /* required buffer size: 999 */ |
| {offset: 999}, {width: 970, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| device12.pushErrorScope('validation'); |
| } catch {} |
| let commandEncoder102 = device12.createCommandEncoder({label: '\u96a7\u11d7'}); |
| try { |
| await device12.queue.onSubmittedWorkDone(); |
| } catch {} |
| let commandEncoder103 = device11.createCommandEncoder({label: '\uef91\u{1f9a5}\ua26e'}); |
| let texture153 = device11.createTexture({ |
| label: '\u33ea\uee8e\u0d38', |
| size: [31, 15, 205], |
| mipLevelCount: 2, |
| sampleCount: 1, |
| format: 'rgba8snorm', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rgba8snorm'], |
| }); |
| let gpuCanvasContext42 = canvas37.getContext('webgpu'); |
| let querySet93 = device12.createQuerySet({ |
| label: '\u89bb\u009b\u9116\u33dd\u0bfc\u{1f877}\u3624\u9546\uffb0\u{1ffc4}\u{1f7b7}', |
| type: 'occlusion', |
| count: 1288, |
| }); |
| let texture154 = gpuCanvasContext3.getCurrentTexture(); |
| let textureView115 = texture154.createView({label: '\u2d7e\u9b20\u{1f897}\u9cf4\u{1f8e4}'}); |
| let sampler109 = device12.createSampler({ |
| label: '\uf1c2\u{1fbdc}\ub40a\u{1f655}\u00c4', |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 93.026, |
| maxAnisotropy: 6, |
| }); |
| let videoFrame29 = new VideoFrame(canvas20, {timestamp: 0}); |
| try { |
| window.someLabel = querySet87.label; |
| } catch {} |
| let texture155 = device6.createTexture({ |
| label: '\ub5f2\u{1f72f}\u380d\u8faf\uacbc\u12b6\u{1f676}', |
| size: {width: 480, height: 4, depthOrArrayLayers: 1}, |
| mipLevelCount: 7, |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderBundle109 = renderBundleEncoder103.finish({label: '\u6157\u{1fd93}\ua0d2\u0a60\ue28e\u46af\u8a29\u2b05\u3654'}); |
| let sampler110 = device6.createSampler({ |
| label: '\u4933\u33c4', |
| addressModeU: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 21.742, |
| lodMaxClamp: 22.279, |
| }); |
| try { |
| computePassEncoder67.setPipeline(pipeline96); |
| } catch {} |
| try { |
| buffer31.destroy(); |
| } catch {} |
| let img43 = await imageWithData(132, 48, '#104671e2', '#2c7c7cb3'); |
| try { |
| gpuCanvasContext18.unconfigure(); |
| } catch {} |
| let canvas38 = document.createElement('canvas'); |
| let querySet94 = device12.createQuerySet({ |
| label: '\u0075\u0016\u0f53\u8e53\ucaae\u550b\u{1ff9f}\u4348', |
| type: 'occlusion', |
| count: 1596, |
| }); |
| try { |
| device12.queue.writeTexture({ |
| texture: texture154, |
| mipLevel: 0, |
| origin: { x: 0, y: 1, z: 0 }, |
| aspect: 'all', |
| }, arrayBuffer16, /* required buffer size: 715 */ |
| {offset: 715, rowsPerImage: 213}, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let img44 = await imageWithData(255, 41, '#423bf4e0', '#32d49f07'); |
| try { |
| canvas38.getContext('webgl2'); |
| } catch {} |
| let querySet95 = device10.createQuerySet({ |
| label: '\u0dc5\u5aa4\u08ba\u9903\ud75b\uff9b\u{1faa9}\u0b2c', |
| type: 'occlusion', |
| count: 2315, |
| }); |
| let renderBundle110 = renderBundleEncoder99.finish({}); |
| let sampler111 = device10.createSampler({ |
| label: '\u{1fe4b}\u{1f929}\ud9f6\u9c8c\u09ee\u05bf\u{1fc76}\u{1fdf5}\u6f55', |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'clamp-to-edge', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 88.248, |
| lodMaxClamp: 93.334, |
| }); |
| let promise77 = device10.createRenderPipelineAsync({ |
| layout: pipelineLayout22, |
| multisample: { |
| count: 4, |
| mask: 0xca623cff, |
| }, |
| fragment: { |
| module: shaderModule22, |
| entryPoint: 'fragment0', |
| constants: {}, |
| targets: [{ |
| format: 'rg32float', |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED |
| }, { |
| format: 'rgba8uint', |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED |
| }, { |
| format: 'rgba16float', |
| blend: { |
| color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'}, |
| alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'}, |
| }, |
| writeMask: GPUColorWrite.BLUE | GPUColorWrite.RED |
| }, {format: 'r16uint', writeMask: 0}, {format: 'rg8sint'}, { |
| format: 'bgra8unorm', |
| blend: { |
| color: {operation: 'reverse-subtract', srcFactor: 'constant', dstFactor: 'constant'}, |
| alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'}, |
| }, |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.RED |
| }] |
| }, |
| depthStencil: { |
| format: 'depth24plus-stencil8', |
| depthWriteEnabled: true, |
| depthCompare: 'less', |
| stencilFront: { |
| compare: 'greater', |
| failOp: 'increment-clamp', |
| depthFailOp: 'invert', |
| passOp: 'increment-wrap', |
| }, |
| stencilBack: { |
| compare: 'less-equal', |
| failOp: 'zero', |
| depthFailOp: 'increment-clamp', |
| passOp: 'decrement-clamp', |
| }, |
| stencilReadMask: 2112, |
| stencilWriteMask: 622, |
| depthBias: 99, |
| depthBiasSlopeScale: 40, |
| }, |
| vertex: { |
| module: shaderModule22, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 1444, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'float32x3', |
| offset: 700, |
| shaderLocation: 4, |
| }, { |
| format: 'sint8x2', |
| offset: 1122, |
| shaderLocation: 10, |
| }, { |
| format: 'unorm10-10-10-2', |
| offset: 776, |
| shaderLocation: 7, |
| }, { |
| format: 'uint16x2', |
| offset: 964, |
| shaderLocation: 12, |
| }], |
| }, |
| { |
| arrayStride: 1168, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'float32', |
| offset: 864, |
| shaderLocation: 13, |
| }, { |
| format: 'uint8x2', |
| offset: 134, |
| shaderLocation: 0, |
| }, { |
| format: 'uint8x4', |
| offset: 528, |
| shaderLocation: 8, |
| }, { |
| format: 'float32x4', |
| offset: 1060, |
| shaderLocation: 11, |
| }], |
| } |
| ] |
| }, |
| }); |
| try { |
| if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(0x55) }; |
| } catch {} |
| offscreenCanvas31.height = 433; |
| let imageData43 = new ImageData(172, 124); |
| let texture156 = device2.createTexture({ |
| size: {width: 207, height: 15, depthOrArrayLayers: 39}, |
| mipLevelCount: 7, |
| dimension: '3d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rgb10a2unorm', 'rgb10a2unorm'], |
| }); |
| let renderBundleEncoder109 = device2.createRenderBundleEncoder({ |
| label: '\u08a8\ua611\u6901\u{1ffb3}', |
| colorFormats: [], |
| depthStencilFormat: 'depth24plus-stencil8', |
| sampleCount: 4, |
| stencilReadOnly: true |
| }); |
| let renderBundle111 = renderBundleEncoder59.finish({label: '\udd94\udb06\u07fa\u{1fd6a}\ue4b3\u0b62\u{1fc3b}\u97a2\u0c06\u0fa6'}); |
| try { |
| renderBundleEncoder84.drawIndexedIndirect(buffer38, 200); |
| } catch {} |
| try { |
| if (!arrayBuffer11.detached) { new Uint8Array(arrayBuffer11).fill(0x55) }; |
| } catch {} |
| gc(); |
| let commandEncoder104 = device10.createCommandEncoder({label: '\u2d50\u7065\u0a96\u{1fe42}'}); |
| let querySet96 = device10.createQuerySet({ |
| label: '\u766f\u2d82\u8664\ubace\u8db9\u0dd9\u{1f6a7}', |
| type: 'occlusion', |
| count: 2799, |
| }); |
| let computePassEncoder78 = commandEncoder100.beginComputePass({label: '\ucc39\u0d79\uee54\u0b32\u{1f89e}\uccaa\u5eb8\u9717\u01dd\ue5d8\u0bb3'}); |
| let renderBundle112 = renderBundleEncoder96.finish(); |
| try { |
| gpuCanvasContext35.unconfigure(); |
| } catch {} |
| let pipelineLayout25 = device0.createPipelineLayout({ |
| bindGroupLayouts: [bindGroupLayout15, bindGroupLayout25, bindGroupLayout13, bindGroupLayout29, bindGroupLayout10, bindGroupLayout17] |
| }); |
| let querySet97 = device0.createQuerySet({ |
| label: '\u7b26\u041a\u5e2b\u752f\u27dd\u{1ff64}', |
| type: 'occlusion', |
| count: 2062, |
| }); |
| let textureView116 = texture16.createView({label: '\u04fc\u0cd8\ud1b6\u73aa\u0031', aspect: 'all'}); |
| try { |
| computePassEncoder57.setBindGroup(3, bindGroup17); |
| } catch {} |
| try { |
| renderBundleEncoder85.setBindGroup(0, bindGroup30); |
| } catch {} |
| try { |
| renderBundleEncoder91.setBindGroup(4, bindGroup4, new Uint32Array(2210), 526, 0); |
| } catch {} |
| try { |
| renderBundleEncoder80.draw(80, 64, 72, 48); |
| } catch {} |
| try { |
| renderBundleEncoder104.setVertexBuffer(7, buffer32, 1720); |
| } catch {} |
| try { |
| commandEncoder96.copyBufferToBuffer(buffer45, 19652, buffer3, 7392, 22724); |
| dissociateBuffer(device0, buffer45); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 147, height: 1, depthOrArrayLayers: 58} |
| */ |
| { |
| source: video33, |
| origin: { x: 0, y: 3 }, |
| flipY: false, |
| }, { |
| texture: texture45, |
| mipLevel: 2, |
| origin: { x: 48, y: 0, z: 55 }, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 16, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| let pipeline98 = device0.createComputePipeline({ |
| label: '\u0170\u{1f61f}\u877d\u6742\u0af5', |
| layout: pipelineLayout5, |
| compute: { |
| module: shaderModule3, |
| entryPoint: 'compute0', |
| constants: {}, |
| }, |
| }); |
| let renderBundleEncoder110 = device11.createRenderBundleEncoder({ |
| label: '\u{1fd8d}\ucca8\u56de\u9197\u521d\u09e5\u9822\uc0ba', |
| colorFormats: ['rgba8uint', 'r16float'], |
| depthStencilFormat: 'depth24plus-stencil8' |
| }); |
| let textureView117 = texture154.createView({label: '\u0e1f\ufffb'}); |
| try { |
| device12.queue.writeTexture({ |
| texture: texture154, |
| mipLevel: 0, |
| origin: { x: 0, y: 0, z: 1 }, |
| aspect: 'all', |
| }, new BigInt64Array(arrayBuffer15), /* required buffer size: 38 */ |
| {offset: 38, rowsPerImage: 128}, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(canvas18); |
| let img45 = await imageWithData(292, 48, '#9c53950b', '#f1000238'); |
| let querySet98 = device6.createQuerySet({ |
| label: '\u67e1\u82cb\u4faf\ud39a\u0d0d\u04a6\u042a\u0627', |
| type: 'occlusion', |
| count: 310, |
| }); |
| let renderBundleEncoder111 = device6.createRenderBundleEncoder({ |
| label: '\u85bf\ub100\u0ada\u0832\u0ed7\u{1fb0b}\ufc31\u5da5', |
| colorFormats: ['rg16uint', 'rgba8sint', 'rgb10a2uint', 'rg8sint', 'rgba32sint'], |
| stencilReadOnly: true |
| }); |
| try { |
| device6.queue.writeTexture({ |
| texture: texture106, |
| mipLevel: 2, |
| origin: { x: 109, y: 0, z: 1 }, |
| aspect: 'all', |
| }, new ArrayBuffer(231081), /* required buffer size: 231081 */ |
| {offset: 682, bytesPerRow: 699, rowsPerImage: 47}, {width: 107, height: 1, depthOrArrayLayers: 8}); |
| } catch {} |
| let bindGroupLayout56 = device1.createBindGroupLayout({ |
| label: '\u0e1f\uaef4\u9432\u3a83\udec5\u3b21\u0c1b\u0cac\u0bd9\u0b42\uab2a', |
| entries: [{ |
| binding: 3176, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d-array', sampleType: 'uint', multisampled: false }, |
| }, { |
| binding: 5681, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| externalTexture: {}, |
| }, { |
| binding: 4251, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rgba8uint', access: 'read-only', viewDimension: '2d-array' }, |
| }], |
| }); |
| let commandEncoder105 = device1.createCommandEncoder({label: '\u4222\u00d0\u{1fcf0}\u0fcd\u2f4f\u0754\ufadf\u{1fe86}\ufa13\ue171'}); |
| let commandBuffer24 = commandEncoder24.finish({ |
| label: '\ud959\u0c72\u1230\u06c6\uf8b8\u{1f9e9}\ua978', |
| }); |
| pseudoSubmit(device1, commandEncoder31); |
| let textureView118 = texture33.createView({label: '\u{1f6d1}\uc6dc\u6216\u0912\u4fb5', dimension: '2d-array', baseMipLevel: 7}); |
| try { |
| device1.queue.writeBuffer(buffer9, 20128, new Float32Array(19569), 18022, 156); |
| } catch {} |
| try { |
| device1.queue.writeTexture({ |
| texture: texture36, |
| mipLevel: 4, |
| origin: { x: 0, y: 0, z: 13 }, |
| aspect: 'all', |
| }, new Int32Array(new ArrayBuffer(72)), /* required buffer size: 726751 */ |
| {offset: 267, bytesPerRow: 44, rowsPerImage: 209}, {width: 0, height: 0, depthOrArrayLayers: 80}); |
| } catch {} |
| canvas2.width = 13; |
| let img46 = await imageWithData(174, 34, '#c1d21653', '#d37a6bb5'); |
| try { |
| adapter14.label = '\ue435\u8b7f\u{1fc54}\u0d75'; |
| } catch {} |
| let texture157 = device11.createTexture({ |
| size: {width: 55, height: 30, depthOrArrayLayers: 178}, |
| mipLevelCount: 8, |
| dimension: '3d', |
| format: 'rg16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderBundleEncoder112 = device11.createRenderBundleEncoder({ |
| label: '\u08b7\u08a6\u71df\u018d\ub3ee\ue984\u0cbb\u05f1\u750a\u04e0\u7e42', |
| colorFormats: ['r8uint', 'rg32uint', 'rgba16uint', 'rg8sint', 'r8uint'], |
| depthReadOnly: true |
| }); |
| try { |
| device11.queue.writeTexture({ |
| texture: texture157, |
| mipLevel: 0, |
| origin: { x: 7, y: 0, z: 20 }, |
| aspect: 'all', |
| }, new ArrayBuffer(32), /* required buffer size: 1892568 */ |
| {offset: 478, bytesPerRow: 170, rowsPerImage: 148}, {width: 40, height: 30, depthOrArrayLayers: 76}); |
| } catch {} |
| let texture158 = device11.createTexture({ |
| label: '\u0eed\u63e1\u{1fa85}\u0b34\u0450\u7150\u{1ff07}\u310d\u09d9\u7a4d\u85c9', |
| size: {width: 222, height: 120, depthOrArrayLayers: 61}, |
| mipLevelCount: 3, |
| dimension: '2d', |
| format: 'rgba16float', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView119 = texture157.createView({baseMipLevel: 3, mipLevelCount: 4, baseArrayLayer: 0}); |
| let renderBundleEncoder113 = device11.createRenderBundleEncoder({ |
| label: '\u09a4\u058e\u{1fe6d}\ua43b\u221b\u846f\ud0e7\ufe18\uad2d\u{1fd3f}', |
| colorFormats: ['r8uint', 'rg32uint', 'rgba16uint', 'rg8sint', 'r8uint'], |
| depthReadOnly: true |
| }); |
| let renderBundle113 = renderBundleEncoder110.finish({label: '\u28f6\u0ee8\ue4bb\u4392\u9edb\u08c5\u60ec\u3c81'}); |
| try { |
| await device11.queue.onSubmittedWorkDone(); |
| } catch {} |
| let img47 = await imageWithData(131, 135, '#ec245917', '#fc27423f'); |
| try { |
| await adapter3.requestAdapterInfo(); |
| } catch {} |
| let renderBundleEncoder114 = device6.createRenderBundleEncoder({ |
| label: '\uae49\u{1f6a6}\u{1fc54}\u{1f854}\ucad4\u0530\ue8b1\u92e5\u7de1', |
| colorFormats: ['rg16sint', undefined], |
| sampleCount: 4 |
| }); |
| try { |
| await device6.queue.onSubmittedWorkDone(); |
| } catch {} |
| let offscreenCanvas48 = new OffscreenCanvas(114, 130); |
| let commandEncoder106 = device10.createCommandEncoder({label: '\u0ef5\u0285\ud3b5\u{1fcb1}\u442e\u058f\u73bb'}); |
| let querySet99 = device10.createQuerySet({ |
| type: 'occlusion', |
| count: 3803, |
| }); |
| let commandBuffer25 = commandEncoder104.finish({ |
| }); |
| try { |
| await device10.queue.onSubmittedWorkDone(); |
| } catch {} |
| let pipeline99 = device10.createComputePipeline({ |
| label: '\u7bf9\u022a\u{1fce3}\u{1fc12}\u9781\u040c\u{1fd79}\uf1ec\u4eac\u{1f804}', |
| layout: pipelineLayout22, |
| compute: { |
| module: shaderModule22, |
| entryPoint: 'compute0', |
| constants: {}, |
| }, |
| }); |
| document.body.prepend(img4); |
| let textureView120 = texture43.createView({ |
| label: '\u21e8\u{1fc8d}\u0953\ud901\u0da7\uf38f\u{1f9d8}', |
| dimension: '2d-array', |
| baseMipLevel: 3, |
| mipLevelCount: 1 |
| }); |
| try { |
| renderBundleEncoder38.draw(8, 64, 64, 16); |
| } catch {} |
| try { |
| renderBundleEncoder80.drawIndexedIndirect(buffer36, 3216); |
| } catch {} |
| try { |
| commandEncoder85.copyBufferToBuffer(buffer0, 15264, buffer24, 116, 72); |
| dissociateBuffer(device0, buffer0); |
| dissociateBuffer(device0, buffer24); |
| } catch {} |
| try { |
| commandEncoder96.clearBuffer(buffer3, 39364, 3560); |
| dissociateBuffer(device0, buffer3); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture44, |
| mipLevel: 0, |
| origin: { x: 76, y: 0, z: 0 }, |
| aspect: 'all', |
| }, new ArrayBuffer(409), /* required buffer size: 409 */ |
| {offset: 409, bytesPerRow: 2968}, {width: 710, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroupLayout57 = device0.createBindGroupLayout({ |
| label: '\ufd02\ue6be\u7cbf\u0156', |
| entries: [], |
| }); |
| let bindGroup36 = device0.createBindGroup({ |
| label: '\u05e7\ucc17\u06bf\u2ce5\u{1fee6}\u4f61\uf6c2\u5c92\u096d', |
| layout: bindGroupLayout10, |
| entries: [{ |
| binding: 1160, |
| resource: externalTexture3 |
| }], |
| }); |
| let texture159 = device0.createTexture({ |
| label: '\u0532\u0abc\u0f68\u0151\ub4c5\ub26c\u0304\u{1f8e3}\ua0e8\u027d\u{1fe2d}', |
| size: {width: 880, height: 1, depthOrArrayLayers: 1116}, |
| mipLevelCount: 6, |
| dimension: '3d', |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderBundle114 = renderBundleEncoder51.finish({label: '\ua768\ud497\u{1fc7b}\u{1f9e8}\uf9f9\u{1ff29}\uc964\u03b4\u0e2d'}); |
| let sampler112 = device0.createSampler({ |
| label: '\ub543\u0905\u0b4c\u{1f9fc}\u1536\u{1fcd0}\uc7f7\uf289\u062d\uc417\u{1f6b0}', |
| addressModeU: 'repeat', |
| addressModeV: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 40.111, |
| lodMaxClamp: 57.790, |
| maxAnisotropy: 11, |
| }); |
| try { |
| renderBundleEncoder36.setBindGroup(1, bindGroup22); |
| } catch {} |
| try { |
| renderBundleEncoder80.draw(56, 8); |
| } catch {} |
| try { |
| renderBundleEncoder42.setVertexBuffer(5, buffer1); |
| } catch {} |
| try { |
| buffer3.destroy(); |
| } catch {} |
| try { |
| await buffer51.mapAsync(GPUMapMode.READ, 368, 620); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture159, |
| mipLevel: 0, |
| origin: { x: 446, y: 0, z: 661 }, |
| aspect: 'all', |
| }, new ArrayBuffer(194431385), /* required buffer size: 194431385 */ |
| {offset: 73, bytesPerRow: 5338, rowsPerImage: 232}, {width: 322, height: 0, depthOrArrayLayers: 158}); |
| } catch {} |
| let texture160 = device2.createTexture({ |
| label: '\u5935\u088b\u2c40\u{1f7bb}\u603b\u44fb\uf467\u0206\u891d\u{1f8d8}', |
| size: [3, 3, 1], |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: ['rgba32sint', 'rgba32sint', 'rgba32sint'], |
| }); |
| try { |
| renderBundleEncoder84.drawIndexedIndirect(buffer38, 18648); |
| } catch {} |
| try { |
| renderBundleEncoder84.drawIndirect(buffer38, 28680); |
| } catch {} |
| try { |
| renderBundleEncoder84.setPipeline(pipeline71); |
| } catch {} |
| try { |
| device2.queue.writeBuffer(buffer43, 12936, new Int16Array(23587), 12003, 984); |
| } catch {} |
| try { |
| gpuCanvasContext27.unconfigure(); |
| } catch {} |
| try { |
| offscreenCanvas48.getContext('2d'); |
| } catch {} |
| let videoFrame30 = new VideoFrame(video17, {timestamp: 0}); |
| let querySet100 = device9.createQuerySet({ |
| label: '\u{1fc0e}\u{1fb30}\u{1ff42}\u45fb\udf8b\u0512\u5678\u{1fa45}\u{1f74d}\u0cbb', |
| type: 'occlusion', |
| count: 535, |
| }); |
| let textureView121 = texture135.createView({label: '\u03d5\u1d96\u09cc', baseMipLevel: 5, mipLevelCount: 1}); |
| let imageData44 = new ImageData(180, 168); |
| let bindGroupLayout58 = device0.createBindGroupLayout({ |
| entries: [], |
| }); |
| let commandBuffer26 = commandEncoder96.finish({ |
| label: '\u09dd\u06c7\u49b3\u{1f7dd}\u{1f9bb}\ub006\ubb55\u{1fe3f}\u036a\u0b0c\u{1f96d}', |
| }); |
| let textureView122 = texture54.createView({baseMipLevel: 2, mipLevelCount: 1, arrayLayerCount: 1}); |
| let renderBundleEncoder115 = device0.createRenderBundleEncoder({ |
| label: '\u0fc0\u{1fe7e}\uc474\u6a30', |
| colorFormats: ['r16float', 'rgba32float', 'rgba32uint', 'rgba8unorm', undefined, 'rgba16float'], |
| sampleCount: 1, |
| depthReadOnly: true, |
| stencilReadOnly: true |
| }); |
| try { |
| renderBundleEncoder38.drawIndirect(buffer36, 10704); |
| } catch {} |
| try { |
| commandEncoder65.copyBufferToBuffer(buffer1, 13216, buffer24, 132, 64); |
| dissociateBuffer(device0, buffer1); |
| dissociateBuffer(device0, buffer24); |
| } catch {} |
| try { |
| commandEncoder84.clearBuffer(buffer23, 19764, 8076); |
| dissociateBuffer(device0, buffer23); |
| } catch {} |
| let promise78 = device0.queue.onSubmittedWorkDone(); |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData34, |
| origin: { x: 66, y: 33 }, |
| flipY: true, |
| }, { |
| texture: texture59, |
| mipLevel: 0, |
| origin: { x: 0, y: 0, z: 1 }, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline100 = device0.createRenderPipeline({ |
| label: '\u01d6\u87a4\u033d\u4eb2\u{1fece}\u8b15\uef01\ua175', |
| layout: pipelineLayout5, |
| fragment: { |
| module: shaderModule11, |
| entryPoint: 'fragment0', |
| targets: [{ |
| format: 'rg8unorm', |
| blend: { |
| color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'}, |
| alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'}, |
| }, |
| writeMask: GPUColorWrite.RED |
| }, undefined] |
| }, |
| depthStencil: { |
| format: 'depth32float-stencil8', |
| depthWriteEnabled: true, |
| depthCompare: 'not-equal', |
| stencilFront: { |
| compare: 'never', |
| failOp: 'replace', |
| passOp: 'decrement-wrap', |
| }, |
| stencilBack: { |
| compare: 'greater-equal', |
| depthFailOp: 'increment-wrap', |
| passOp: 'replace', |
| }, |
| stencilReadMask: 984, |
| stencilWriteMask: 2471, |
| depthBiasClamp: 41, |
| }, |
| vertex: { |
| module: shaderModule11, |
| entryPoint: 'vertex0', |
| buffers: [ |
| { |
| arrayStride: 40, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'sint16x2', |
| offset: 32, |
| shaderLocation: 8, |
| }, { |
| format: 'uint8x4', |
| offset: 4, |
| shaderLocation: 12, |
| }, { |
| format: 'sint8x2', |
| offset: 26, |
| shaderLocation: 1, |
| }, { |
| format: 'float32x4', |
| offset: 8, |
| shaderLocation: 2, |
| }], |
| }, |
| { |
| arrayStride: 6040, |
| stepMode: 'vertex', |
| attributes: [{ |
| format: 'uint8x4', |
| offset: 1796, |
| shaderLocation: 4, |
| }, { |
| format: 'sint16x2', |
| offset: 524, |
| shaderLocation: 11, |
| }, { |
| format: 'unorm8x4', |
| offset: 4536, |
| shaderLocation: 7, |
| }, { |
| format: 'sint16x2', |
| offset: 2340, |
| shaderLocation: 5, |
| }], |
| }, |
| { |
| arrayStride: 7044, |
| stepMode: 'instance', |
| attributes: [{ |
| format: 'uint16x4', |
| offset: 2692, |
| shaderLocation: 9, |
| }, { |
| format: 'unorm8x2', |
| offset: 5508, |
| shaderLocation: 15, |
| }, { |
| format: 'unorm16x2', |
| offset: 572, |
| shaderLocation: 10, |
| }], |
| } |
| ] |
| }, |
| primitive: { |
| frontFace: 'cw', |
| cullMode: 'back', |
| unclippedDepth: true, |
| }, |
| }); |
| let textureView123 = texture157.createView({ |
| label: '\u06dd\u3405\u39ba\ufd55\uad0f\u009e\u9a48\u0461', |
| baseMipLevel: 5, |
| mipLevelCount: 1, |
| arrayLayerCount: 1 |
| }); |
| let renderBundleEncoder116 = device11.createRenderBundleEncoder({ |
| label: '\ufad8\u59a1\u028a\udc7d\ubca0\u{1faea}\u7928\u0486\u0b59\u0410', |
| colorFormats: ['rgba8uint', 'r16float'], |
| depthStencilFormat: 'depth24plus-stencil8' |
| }); |
| let renderBundle115 = renderBundleEncoder110.finish({label: '\u04cc\u{1f807}'}); |
| try { |
| device11.pushErrorScope('internal'); |
| } catch {} |
| try { |
| gpuCanvasContext13.configure({ |
| device: device11, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device11.queue.writeTexture({ |
| texture: texture157, |
| mipLevel: 3, |
| origin: { x: 2, y: 0, z: 2 }, |
| aspect: 'all', |
| }, new Uint32Array(arrayBuffer12), /* required buffer size: 1054472 */ |
| {offset: 656, bytesPerRow: 220, rowsPerImage: 252}, {width: 4, height: 3, depthOrArrayLayers: 20}); |
| } catch {} |
| let canvas39 = document.createElement('canvas'); |
| try { |
| window.someLabel = texture55.label; |
| } catch {} |
| try { |
| await promise78; |
| } catch {} |
| let offscreenCanvas49 = new OffscreenCanvas(722, 246); |
| let renderBundleEncoder117 = device4.createRenderBundleEncoder({colorFormats: ['rg32float', 'rgba32sint']}); |
| try { |
| renderBundleEncoder48.pushDebugGroup('\ub07d'); |
| } 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(); |
| videoFrame14.close(); |
| videoFrame15.close(); |
| videoFrame16.close(); |
| videoFrame17.close(); |
| videoFrame18.close(); |
| videoFrame19.close(); |
| videoFrame20.close(); |
| videoFrame21.close(); |
| videoFrame22.close(); |
| videoFrame23.close(); |
| videoFrame24.close(); |
| videoFrame25.close(); |
| videoFrame26.close(); |
| videoFrame27.close(); |
| videoFrame28.close(); |
| videoFrame29.close(); |
| videoFrame30.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> |
| |
