| <!-- webkit-test-runner [ enableMetalShaderValidation=true ] --> |
| <style> |
| :root { background: #102030e0; color: #99ddbbcc; font-size: 15px; } |
| </style> |
| <script src="../../../resources/js-test-pre.js"></script> |
| <script id="shared"> |
| const log = console.log; |
| |
| async function gc() { |
| await 0; |
| if (globalThis.GCController) { |
| globalThis.GCController.collect(); |
| } else if (globalThis.$vm) { |
| globalThis.$vm.gc(); |
| } else { |
| log('no GC available'); |
| } |
| } |
| |
| /** |
| * @param {GPUDevice} device |
| * @param {GPUComputePassEncoder} computePassEncoder |
| */ |
| function clearResourceUsages(device, computePassEncoder) { |
| let code = `@compute @workgroup_size(1) fn c() {}`; |
| let module = device.createShaderModule({code}); |
| computePassEncoder.setPipeline(device.createComputePipeline( |
| { |
| layout: 'auto', |
| compute: {module}, |
| })); |
| computePassEncoder.dispatchWorkgroups(1); |
| } |
| |
| /** |
| * @template {any} T |
| * @param {GPUDevice} device |
| * @param {string} label |
| * @param {()=>T} payload |
| * @returns {Promise<T>} |
| */ |
| async function validationWrapper(device, label, payload) { |
| device.pushErrorScope('internal'); |
| device.pushErrorScope('out-of-memory'); |
| device.pushErrorScope('validation'); |
| let result = payload(); |
| let validationError = await device.popErrorScope(); |
| let outOfMemoryError = await device.popErrorScope(); |
| let internalError = await device.popErrorScope(); |
| let error = validationError ?? outOfMemoryError ?? internalError; |
| if (error) { |
| log('*'.repeat(25)); |
| log(error[Symbol.toStringTag]); |
| log(error.message); |
| log(label); |
| if (error.stack != `_`) { |
| log(error.stack); |
| } |
| log(location); |
| log('*'.repeat(25)); |
| throw error; |
| } |
| return result; |
| } |
| |
| const videoUrls = [ |
| |
| ]; |
| |
| /** |
| * @param {number} index |
| * @returns {Promise<HTMLVideoElement>} |
| */ |
| function videoWithData(index) { |
| let video = document.createElement('video'); |
| video.src = videoUrls[index % videoUrls.length]; |
| return new Promise(resolve => { |
| video.onloadeddata = () => { |
| resolve(video); |
| }; |
| }); |
| } |
| |
| /** |
| * @returns {Promise<string>} |
| */ |
| async function makeDataUrl(width, height, color0, color1) { |
| let offscreenCanvas = new OffscreenCanvas(width, height); |
| let ctx = offscreenCanvas.getContext('2d'); |
| let gradient = ctx.createLinearGradient(0, 0, width, height); |
| gradient.addColorStop(0, color0); |
| gradient.addColorStop(0.1, color1); |
| gradient.addColorStop(0.3, color0); |
| gradient.addColorStop(0.7, color1); |
| gradient.addColorStop(0.9, color0); |
| gradient.addColorStop(1, color1); |
| ctx.fillStyle = gradient; |
| ctx.fillRect(0, 0, width, height); |
| let blob = await offscreenCanvas.convertToBlob(); |
| let fileReader = new FileReader(); |
| fileReader.readAsDataURL(blob); |
| return new Promise(resolve => { |
| fileReader.onload = () => { |
| resolve(fileReader.result); |
| }; |
| }); |
| } |
| |
| async function imageWithData(width, height, color0, color1) { |
| let dataUrl = await makeDataUrl(width, height, color0, color1); |
| let img = document.createElement('img'); |
| img.src = dataUrl; |
| await img.decode(); |
| return img; |
| } |
| |
| /** |
| * @param {string} payload |
| * @returns {string} |
| */ |
| function toBlobUrl(payload) { |
| let blob = new Blob([payload], {type: 'text/javascript'}); |
| return URL.createObjectURL(blob); |
| } |
| </script> |
| |
| <script> |
| globalThis.testRunner?.dumpAsText(); |
| globalThis.testRunner?.waitUntilDone(); |
| |
| |
| async function window0() { |
| let adapter0 = await navigator.gpu.requestAdapter({}); |
| let device0 = await adapter0.requestDevice({ |
| defaultQueue: {}, |
| requiredFeatures: [ |
| 'depth-clip-control', |
| 'depth32float-stencil8', |
| 'texture-compression-etc2', |
| 'texture-compression-astc', |
| 'shader-f16', |
| 'rg11b10ufloat-renderable', |
| 'bgra8unorm-storage', |
| ], |
| requiredLimits: { |
| maxUniformBufferBindingSize: 25383437, |
| maxStorageBufferBindingSize: 144870969, |
| maxInterStageShaderVariables: 16, |
| }, |
| }); |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let texture0 = device0.createTexture({ |
| size: [246, 1, 1], |
| format: 'depth24plus', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView0 = texture0.createView({dimension: '2d-array'}); |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| let texture1 = device0.createTexture({ |
| size: {width: 615}, |
| dimension: '1d', |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView1 = texture0.createView({aspect: 'depth-only'}); |
| let textureView2 = texture1.createView({format: 'r32uint', baseMipLevel: 0}); |
| let texture2 = device0.createTexture({size: [40, 45, 2], mipLevelCount: 3, format: 'r32uint', usage: GPUTextureUsage.RENDER_ATTACHMENT}); |
| let sampler0 = device0.createSampler({ |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 94.34, |
| compare: 'greater-equal', |
| }); |
| try { |
| device0.queue.writeTexture({ |
| texture: texture1, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(131).fill(83), /* required buffer size: 131 */ |
| {offset: 131}, {width: 10, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer0 = device0.createBuffer({ |
| size: 2085, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM, |
| }); |
| let texture3 = device0.createTexture({ |
| size: [492, 1, 389], |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let sampler1 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'repeat', addressModeW: 'repeat', lodMaxClamp: 35.20}); |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| let veryExplicitBindGroupLayout0 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 144, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '1d' }, |
| }, |
| { |
| binding: 323, |
| visibility: GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let textureView3 = texture2.createView({mipLevelCount: 1, arrayLayerCount: 1}); |
| let sampler2 = device0.createSampler({ |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| lodMaxClamp: 94.36, |
| compare: 'less-equal', |
| }); |
| await gc(); |
| let veryExplicitBindGroupLayout1 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 144, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '1d' }, |
| }, |
| { |
| binding: 323, |
| visibility: GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let pipelineLayout0 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout0]}); |
| let textureView4 = texture1.createView({arrayLayerCount: 1}); |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let imageData0 = new ImageData(28, 88); |
| let buffer1 = device0.createBuffer({ |
| size: 11438, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder0 = device0.createCommandEncoder(); |
| let textureView5 = texture1.createView({}); |
| try { |
| device0.queue.writeTexture({ |
| texture: texture3, |
| mipLevel: 0, |
| origin: {x: 20, y: 0, z: 5}, |
| aspect: 'all', |
| }, new Uint8Array(687_909).fill(66), /* required buffer size: 687_909 */ |
| {offset: 117, bytesPerRow: 267, rowsPerImage: 28}, {width: 61, height: 0, depthOrArrayLayers: 93}); |
| } catch {} |
| let pipelineLayout1 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout1, veryExplicitBindGroupLayout0]}); |
| let buffer2 = device0.createBuffer({ |
| size: 1096, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder1 = device0.createCommandEncoder({}); |
| let texture4 = device0.createTexture({ |
| size: [153], |
| dimension: '1d', |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let sampler3 = device0.createSampler({addressModeU: 'repeat', lodMinClamp: 62.03, lodMaxClamp: 69.93}); |
| await gc(); |
| let pipelineLayout2 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout0]}); |
| let texture5 = device0.createTexture({ |
| size: {width: 32}, |
| sampleCount: 1, |
| dimension: '1d', |
| format: 'rgba8snorm', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder0 = commandEncoder1.beginComputePass({}); |
| try { |
| commandEncoder0.clearBuffer(buffer2); |
| } catch {} |
| let imageData1 = new ImageData(64, 8); |
| try { |
| adapter0.label = '\uc132\ucee8\u051e\ue648\u7929\u0c35\u0660\u{1fc2f}'; |
| } catch {} |
| let commandEncoder2 = device0.createCommandEncoder({}); |
| let textureView6 = texture0.createView({dimension: '2d-array', mipLevelCount: 1}); |
| let texture6 = device0.createTexture({ |
| size: [246, 1, 307], |
| mipLevelCount: 2, |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let computePassEncoder1 = commandEncoder2.beginComputePass({}); |
| let textureView7 = texture4.createView({}); |
| let texture7 = device0.createTexture({ |
| size: [940, 5, 1], |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder2 = commandEncoder0.beginComputePass({}); |
| let veryExplicitBindGroupLayout2 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 39, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| { |
| binding: 41, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: true }, |
| }, |
| ], |
| }); |
| let commandEncoder3 = device0.createCommandEncoder({}); |
| let texture8 = device0.createTexture({ |
| size: {width: 1880, height: 10, depthOrArrayLayers: 1}, |
| sampleCount: 4, |
| format: 'depth32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let sampler4 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 49.71, |
| compare: 'always', |
| maxAnisotropy: 2, |
| }); |
| try { |
| commandEncoder3.copyBufferToBuffer(buffer0, 748, buffer2, 92, 48); |
| } catch {} |
| let commandEncoder4 = device0.createCommandEncoder({}); |
| let textureView8 = texture8.createView({baseMipLevel: 0}); |
| let promise0 = device0.queue.onSubmittedWorkDone(); |
| let commandEncoder5 = device0.createCommandEncoder({}); |
| let renderBundleEncoder0 = device0.createRenderBundleEncoder({colorFormats: ['rg8unorm'], stencilReadOnly: true}); |
| let renderBundle0 = renderBundleEncoder0.finish({}); |
| try { |
| await promise0; |
| } catch {} |
| let shaderModule0 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| requires packed_4x8_integer_dot_product; |
| |
| /* zero global variables used */ |
| fn fn2() -> mat4x3h { |
| var out: mat4x3h; |
| fn1(mat2x4f(bitcast<vec4f>(firstTrailingBit(vec2u(unconst_u32(499), unconst_u32(29))).yxyx), bitcast<vec4f>(firstTrailingBit(vec2u(unconst_u32(499), unconst_u32(29))).rrgr))); |
| if bool(unpack2x16unorm(unconst_u32(9)).y) { |
| } |
| let vf12: vec4i = unpack4xI8(unconst_u32(348)); |
| var vf13: vec4h = fract(vec4h(unconst_f16(5515.2), unconst_f16(2051.9), unconst_f16(4877.5), unconst_f16(4683.7))); |
| let ptr0: ptr<function, vec4h> = &vf13; |
| return out; |
| } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| struct T2 { |
| @size(32) f0: array<array<array<mat3x3h, 1>, 1>, 1>, |
| @size(32) f1: vec2f, |
| @align(32) f2: array<mat2x4h, 8>, |
| @align(16) f3: array<mat2x2f, 22>, |
| @size(224) f4: array<array<array<array<f32, 12>, 2>, 1>, 1>, |
| @size(96) f5: array<array<array<mat4x3h, 1>, 1>, 1>, |
| @align(32) @size(288) f6: mat3x3f, |
| @align(32) f7: array<mat4x2f, 1>, |
| @align(32) @size(32) f8: f16, |
| @size(640) f9: array<mat2x2f, 16>, |
| f10: mat2x3f, |
| @size(32) f11: array<mat3x3h, 1>, |
| @align(16) @size(32) f12: mat2x3h, |
| @align(8) f13: array<array<vec2h, 1>, 8>, |
| @align(32) @size(64) f14: array<u32, 1>, |
| @align(32) @size(32) f15: array<array<i32, 4>, 1>, |
| @align(32) f16: array<vec2f, 4>, |
| @align(32) @size(160) f17: mat3x2h, |
| @align(16) @size(448) f18: array<array<array<array<f16, 1>, 6>, 8>, 1>, |
| } |
| |
| struct VertexOutput0 { |
| @builtin(position) f0: vec4f, |
| } |
| |
| @group(0) @binding(323) var<storage, read> buffer3: array<array<array<array<array<array<f16, 3>, 1>, 1>, 1>, 36>, 4>; |
| |
| alias vec3b = vec3<bool>; |
| |
| @group(0) @binding(144) var st0: texture_storage_1d<r32uint, read_write>; |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| /* zero global variables used */ |
| fn fn0(a0: ptr<storage, array<f16, 62>, read_write>) -> vec2u { |
| var out: vec2u; |
| let vf0: vec3u = (vec3u(unconst_u32(928), unconst_u32(56), unconst_u32(114)) << vec3u(unconst_u32(95), unconst_u32(180), unconst_u32(194))); |
| let vf1: vec3i = (vec3i(unconst_i32(133), unconst_i32(85), unconst_i32(-50)) % unconst_i32(171)); |
| var vf2: vec3i = sign(vec3i(unconst_i32(260), unconst_i32(118), unconst_i32(-105))); |
| out = vec2u(unpack2x16unorm(unconst_u32(220))); |
| var vf3: f16 = determinant(mat2x2h(unconst_f16(1009.2), unconst_f16(20713.9), unconst_f16(893.5), unconst_f16(-7742.7))); |
| vf3 = (*a0)[61]; |
| let vf4: vec2f = log2(vec2f(unconst_f32(0.1547), unconst_f32(0.2949))); |
| return out; |
| } |
| |
| struct FragmentOutput0 { |
| @location(7) @interpolate(flat) f0: i32, |
| @location(0) f1: vec2f, |
| } |
| |
| /* zero global variables used */ |
| fn fn1(a0: mat2x4f) -> FragmentOutput0 { |
| var out: FragmentOutput0; |
| var vf5: u32 = pack2x16snorm(vec2f(unconst_f32(-0.1187), unconst_f32(0.4261))); |
| var vf6: f16 = cosh(unconst_f16(17565.5)); |
| vf5 = pack4xI8(unpack4xI8(unconst_u32(85))); |
| let vf7: u32 = (unconst_u32(149) >> unconst_u32(136)); |
| let vf8: u32 = pack2x16snorm(vec2f(unconst_f32(0.3459), unconst_f32(0.2375))); |
| vf6 *= f16((bitcast<vec4f>(unpack4xI8(unconst_u32(192))) + a0[unconst_u32(265)])[3]); |
| vf5 *= vf8; |
| while bool(cosh(unconst_f16(548.2))) { |
| let vf9: mat2x4f = a0; |
| out.f0 *= bitcast<i32>(a0[unconst_u32(164)][unconst_u32(45)]); |
| out.f0 |= bitcast<i32>(determinant(mat2x2f())); |
| while bool(faceForward(vec2f(unconst_f32(-0.1467), unconst_f32(0.1254)), vec2f(unconst_f32(0.04802), unconst_f32(0.02589)), vec2f(unconst_f32(0.00437), unconst_f32(0.3803)))[1]) { |
| out.f0 = i32(pack2x16snorm(vec2f(unconst_f32(0.3062), unconst_f32(0.1661)))); |
| out.f1 = reflect(vec4f(unconst_f32(0.06079), unconst_f32(-0.1079), unconst_f32(0.3512), unconst_f32(0.02669)), vec4f(unconst_f32(0.4370), unconst_f32(-0.04797), unconst_f32(0.1101), unconst_f32(0.1270))).xy; |
| out.f1 = bitcast<vec2f>(countOneBits(vec3i(unconst_i32(271), unconst_i32(95), unconst_i32(27))).rg); |
| for (var it0=u32(cross(vec3f(unconst_f32(0.00855), unconst_f32(0.05515), unconst_f32(0.03448)), vec3f(unconst_f32(0.01159), unconst_f32(0.2301), unconst_f32(0.00686))).g); it0<bitcast<u32>(cross(vec3f(unconst_f32(0.1055), unconst_f32(-0.00803), unconst_f32(0.02509)), vec3f(unconst_f32(0.2434), unconst_f32(0.2189), unconst_f32(0.09950))).b); it0++) { |
| out.f1 = bitcast<vec2f>((vec2u(u32(any(vec2<bool>(unconst_bool(false), unconst_bool(true))))) << vec2u(unconst_u32(234), unconst_u32(34)))); |
| } |
| var vf10: f16 = exp(unconst_f16(17989.7)); |
| return out; |
| } |
| out.f1 *= faceForward(vec2f(unconst_f32(-0.2950), unconst_f32(0.00151)), vec2f(unconst_f32(0.06799), unconst_f32(0.2408)), vec2f(unconst_f32(0.2159), unconst_f32(0.6899))); |
| break; |
| } |
| var vf11: vec2f = trunc(vec2f(unconst_f32(0.02276), unconst_f32(0.1710))); |
| return out; |
| } |
| |
| struct T1 { |
| @align(16) @size(864) f0: array<atomic<u32>>, |
| } |
| |
| struct T0 { |
| @size(864) f0: array<u32>, |
| } |
| |
| /* used global variables: buffer3 */ |
| @vertex |
| fn vertex0(@location(13) @interpolate(flat, sample) a0: vec4u, @location(0) @interpolate(flat, center) a1: u32) -> VertexOutput0 { |
| var out: VertexOutput0; |
| out = VertexOutput0(vec4f(f32(buffer3[unconst_u32(120)][unconst_u32(96)][unconst_u32(166)][unconst_u32(207)][0][2]))); |
| fn1(mat2x4f(f32(buffer3[3][u32(buffer3[3][unconst_u32(4)][unconst_u32(109)][unconst_u32(33)][0][2])][0][0][0][2]), f32(buffer3[3][u32(buffer3[3][unconst_u32(4)][unconst_u32(109)][unconst_u32(33)][0][2])][0][0][0][2]), f32(buffer3[3][u32(buffer3[3][unconst_u32(4)][unconst_u32(109)][unconst_u32(33)][0][2])][0][0][0][2]), f32(buffer3[3][u32(buffer3[3][unconst_u32(4)][unconst_u32(109)][unconst_u32(33)][0][2])][0][0][0][2]), f32(buffer3[3][u32(buffer3[3][unconst_u32(4)][unconst_u32(109)][unconst_u32(33)][0][2])][0][0][0][2]), f32(buffer3[3][u32(buffer3[3][unconst_u32(4)][unconst_u32(109)][unconst_u32(33)][0][2])][0][0][0][2]), f32(buffer3[3][u32(buffer3[3][unconst_u32(4)][unconst_u32(109)][unconst_u32(33)][0][2])][0][0][0][2]), f32(buffer3[3][u32(buffer3[3][unconst_u32(4)][unconst_u32(109)][unconst_u32(33)][0][2])][0][0][0][2]))); |
| let ptr1: ptr<storage, f16, read> = &buffer3[3][unconst_u32(56)][0][unconst_u32(125)][0][2]; |
| loop { |
| let ptr2: ptr<storage, f16, read> = &(*&buffer3)[3][35][0][unconst_u32(515)][unconst_u32(586)][unconst_u32(90)]; |
| break; |
| _ = buffer3; |
| } |
| out.f0 = vec4f(f32((*&buffer3)[unconst_u32(216)][35][(vec3u(unconst_u32(98), unconst_u32(141), unconst_u32(573)) ^ vec3u(unconst_u32(176), unconst_u32(200), unconst_u32(107)))[0]][0][0][unconst_u32(91)])); |
| return out; |
| _ = buffer3; |
| } |
| |
| /* zero global variables used */ |
| @fragment |
| fn fragment0() -> FragmentOutput0 { |
| var out: FragmentOutput0; |
| while any((vec3i(unconst_i32(235), unconst_i32(231), unconst_i32(69)) <= vec3i(unconst_i32(31), unconst_i32(201), unconst_i32(-132)))) { |
| switch i32(fract(vec3f(unconst_f32(-0.2123), unconst_f32(0.00404), unconst_f32(0.05033)))[0]) { |
| default { |
| let vf14: vec2h = exp(vec2h(unconst_f16(23580.6), unconst_f16(9140.8))); |
| break; |
| } |
| } |
| var vf15 = fn2(); |
| break; |
| } |
| var vf16 = fn2(); |
| let vf17: vec4i = unpack4xI8(u32(exp2(vec3h(unconst_f16(2704.6), unconst_f16(-7565.7), unconst_f16(3556.6))).x)); |
| fn2(); |
| return out; |
| } |
| |
| /* used global variables: st0 */ |
| @compute @workgroup_size(1, 1, 1) |
| fn compute0() { |
| let vf18: i32 = dot4I8Packed(unconst_u32(111), unconst_u32(157)); |
| let vf19: i32 = ~unconst_i32(103); |
| let vf20: u32 = textureDimensions(st0); |
| var vf21: i32 = vf19; |
| let vf22: i32 = dot4I8Packed(unconst_u32(81), unconst_u32(73)); |
| textureStore(st0, unconst_i32(21), vec4u(vec4u(unconst_u32(31), unconst_u32(60), unconst_u32(52), unconst_u32(230)))); |
| { |
| var vf23: u32 = pack4x8snorm(vec4f(unconst_f32(-0.3193), unconst_f32(0.03785), unconst_f32(0.1991), unconst_f32(0.01304))); |
| vf23 <<= pack4xU8(vec4u((mat4x4h(unconst_f16(22299.3), unconst_f16(14176.8), unconst_f16(2124.1), unconst_f16(843.7), unconst_f16(1254.6), unconst_f16(4748.2), unconst_f16(3191.4), unconst_f16(-29884.2), unconst_f16(4274.8), unconst_f16(6203.8), unconst_f16(1572.7), unconst_f16(12483.6), unconst_f16(-3127.1), unconst_f16(10151.4), unconst_f16(22907.2), unconst_f16(6185.1)) + mat4x4h(bitcast<vec4h>(ldexp(vec2f(unconst_f32(0.1216), unconst_f32(0.00192)), vec2i(unconst_i32(1), unconst_i32(39)))), bitcast<vec4h>(ldexp(vec2f(unconst_f32(0.1216), unconst_f32(0.00192)), vec2i(unconst_i32(1), unconst_i32(39)))), bitcast<vec4h>(ldexp(vec2f(unconst_f32(0.1216), unconst_f32(0.00192)), vec2i(unconst_i32(1), unconst_i32(39)))), bitcast<vec4h>(ldexp(vec2f(unconst_f32(0.1216), unconst_f32(0.00192)), vec2i(unconst_i32(1), unconst_i32(39))))))[unconst_i32(0)])); |
| vf23 |= textureDimensions(st0); |
| vf23 ^= textureLoad(st0, unconst_i32(84)).a; |
| var vf24: vec4i = (vec4i(unconst_i32(405), unconst_i32(419), unconst_i32(202), unconst_i32(-189)) << vec4u(unconst_u32(281), unconst_u32(408), unconst_u32(193), unconst_u32(121))); |
| _ = st0; |
| } |
| var vf25: i32 = vf22; |
| vf21 = bitcast<i32>(exp2(vec2h(unconst_f16(7497.9), unconst_f16(13424.6)))); |
| let vf26: vec3<bool> = (vec3f(unconst_f32(0.1332), unconst_f32(0.08108), unconst_f32(0.1406)) > vec3f(unconst_f32(0.3195), unconst_f32(0.08953), unconst_f32(0.3006))); |
| var vf27: i32 = vf18; |
| var vf28: i32 = vf22; |
| var vf29: vec2f = atan(vec2f(unconst_f32(0.2721), unconst_f32(0.06034))); |
| let vf30: vec2f = unpack2x16snorm(unconst_u32(62)); |
| _ = st0; |
| }`, |
| }); |
| let buffer4 = device0.createBuffer({size: 4276, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let textureView9 = texture4.createView({}); |
| let textureView10 = texture4.createView({}); |
| try { |
| await shaderModule0.getCompilationInfo(); |
| } catch {} |
| let buffer5 = device0.createBuffer({ |
| size: 18635, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder6 = device0.createCommandEncoder({}); |
| let textureView11 = texture5.createView({aspect: 'all', format: 'rgba8snorm'}); |
| let computePassEncoder3 = commandEncoder6.beginComputePass({}); |
| let computePassEncoder4 = commandEncoder3.beginComputePass({}); |
| let sampler5 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'repeat', minFilter: 'linear', lodMaxClamp: 93.17}); |
| let shaderModule1 = device0.createShaderModule({ |
| label: '\ue846\u{1f75b}\u9f4b\u7d7b\u9948\u084b\ue6ac\u{1fdd5}\u{1fcca}\u0fb5\u74e2', |
| code: ` |
| enable f16; |
| |
| requires unrestricted_pointer_parameters; |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| struct FragmentOutput1 { |
| @location(0) f0: vec2f, |
| @location(1) f1: u32, |
| } |
| |
| var<workgroup> vw1: mat3x4f; |
| |
| struct T2 { |
| @size(32) f0: mat3x2f, |
| @size(32) f1: array<atomic<u32>, 1>, |
| @size(352) f2: array<atomic<u32>, 2>, |
| @align(32) @size(448) f3: array<u32>, |
| } |
| |
| var<workgroup> vw5: atomic<u32>; |
| |
| var<workgroup> vw8: array<T0, 1>; |
| |
| var<workgroup> vw6: array<mat2x4h, 1>; |
| |
| struct T1 { |
| @align(32) @size(864) f0: array<u32>, |
| } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| alias vec3b = vec3<bool>; |
| |
| var<private> vp2 = modf(vec2f(0.05758, 0.2194)); |
| |
| var<private> vp0: T0 = T0(vec2h(11208.4, 4794.4)); |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| var<workgroup> vw3: atomic<i32>; |
| |
| @group(0) @binding(144) var st1: texture_storage_1d<r32uint, read_write>; |
| |
| var<workgroup> vw2: array<FragmentOutput1, 10>; |
| |
| var<workgroup> vw10: vec4<bool>; |
| |
| var<workgroup> vw7: atomic<u32>; |
| |
| /* zero global variables used */ |
| fn fn2() -> T0 { |
| var out: T0; |
| switch i32(any((vec3u(unconst_u32(766), unconst_u32(69), unconst_u32(40)) >= vec3u(unconst_u32(148), unconst_u32(68), unconst_u32(61))))) { |
| default { |
| let ptr4: ptr<workgroup, mat3x4f> = &vw1; |
| var vf34 = fn1(); |
| let vf35: f32 = log2(f32(all((vec3f(unconst_f32(0.1487), unconst_f32(0.02642), unconst_f32(0.2936)) <= vec3f(unconst_f32(0.00357), unconst_f32(0.01827), unconst_f32(0.02726)))))); |
| while bool(asin(unconst_f16(7991.0))) { |
| if bool(extractBits(vec3u(unconst_u32(23), unconst_u32(175), unconst_u32(132)), unconst_u32(113), unconst_u32(60)).z) { |
| var vf36: f16 = vw8[unconst_u32(126)].f0[atomicExchange(&(*&vw4), unconst_u32(63))]; |
| } |
| vw9[u32(vw6[unconst_u32(7)][unconst_u32(42)][unconst_u32(133)])][unconst_u32(94)] ^= vec2i(bitcast<i32>(vw2[9].f0[unconst_u32(118)])); |
| var vf37 = fn1(); |
| let ptr5: ptr<workgroup, vec2f> = &(*&vw2)[unconst_u32(48)].f0; |
| } |
| while bool(vf34[0][3].f0.g) { |
| vp0 = T0(vec2h((*&vw9)[unconst_u32(202)][0])); |
| } |
| break; |
| } |
| } |
| return out; |
| } |
| |
| struct T0 { |
| @size(36) f0: vec2h, |
| } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| var<workgroup> vw0: T0; |
| |
| var<workgroup> vw11: atomic<i32>; |
| |
| var<private> vp1: T0 = T0(); |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| var<private> vp3 = modf(f16(15817.4)); |
| |
| var<workgroup> vw4: atomic<u32>; |
| |
| var<workgroup> vw9: array<array<vec2i, 1>, 1>; |
| |
| /* zero global variables used */ |
| fn fn1() -> array<array<FragmentOutput1, 4>, 1> { |
| var out: array<array<FragmentOutput1, 4>, 1>; |
| { |
| vw2[vec4u((*&vw6)[bitcast<u32>((*&vw9)[(*&vw2)[9].f1][unconst_u32(72)][1])][unconst_u32(97)]).b] = FragmentOutput1(vw2[9].f0, pack2x16unorm(vw2[9].f0)); |
| atomicStore(&vw5, unconst_u32(281)); |
| let vf31: u32 = dot4U8Packed(unconst_u32(137), bitcast<u32>(vp1.f0)); |
| fn0(); |
| fn0(); |
| fn0(); |
| fn0(); |
| } |
| var vf32: vec4<bool> = workgroupUniformLoad(&vw10); |
| fn0(); |
| vw2[unconst_u32(268)].f1 <<= bitcast<u32>((*&vw8)[0].f0); |
| vf32 = vec4<bool>(vw8[unconst_u32(239)].f0.grrr); |
| let ptr3: ptr<workgroup, array<vec2i, 1>> = &vw9[unconst_u32(279)]; |
| atomicMax(&vw11, unconst_i32(185)); |
| fn0(); |
| vp1 = T0(vec2h(vw2[unconst_u32(42)].f0)); |
| fn0(); |
| let vf33: i32 = countLeadingZeros(unconst_i32(-27)); |
| return out; |
| } |
| |
| /* zero global variables used */ |
| fn fn0() { |
| vp3.whole -= vp3.fract; |
| vp0 = T0(vec2h(vp3.fract)); |
| } |
| |
| /* used global variables: st1 */ |
| @fragment |
| fn fragment1() -> FragmentOutput1 { |
| var out: FragmentOutput1; |
| let vf38: vec2<bool> = (vec2f(unconst_f32(0.1055), unconst_f32(0.2407)) > vec2f(unconst_f32(0.3525), unconst_f32(0.00792))); |
| fn0(); |
| for (var it1=(vec3u(unconst_u32(54), unconst_u32(15), unconst_u32(149)) - vec3u(unconst_u32(2), unconst_u32(80), unconst_u32(284)))[0]; it1<bitcast<u32>(vp1.f0); it1++) { |
| let vf39: vec4f = acosh(vec4f(unconst_f32(0.03707), unconst_f32(0.1577), unconst_f32(0.3955), unconst_f32(0.1252))); |
| let ptr6 = &vp2; |
| fn0(); |
| { |
| vp0.f0 += bitcast<vec2h>(pack4xU8Clamp(vec4u(unconst_u32(287), unconst_u32(159), unconst_u32(80), unconst_u32(553)))); |
| fn0(); |
| fn0(); |
| var vf40: u32 = pack2x16snorm(vec2f(unconst_f32(0.05871), unconst_f32(0.2275))); |
| } |
| var vf41: vec2f = unpack2x16float(unconst_u32(203)); |
| fn0(); |
| fn0(); |
| break; |
| } |
| vp3.fract *= f16(vf38[unconst_u32(351)]); |
| var vf42: vec2f = unpack2x16unorm(unconst_u32(398)); |
| textureStore(st1, unconst_i32(218), vec4u(vec4u(unconst_u32(333), unconst_u32(173), unconst_u32(41), unconst_u32(87)))); |
| out.f1 = bitcast<vec2u>(unpack2x16unorm(unconst_u32(51))).x; |
| out.f1 = pack4xI8Clamp((vec4i(unconst_i32(18), unconst_i32(103), unconst_i32(85), unconst_i32(207)) & vec4i(unconst_i32(22), unconst_i32(-165), unconst_i32(141), unconst_i32(-314)))); |
| fn0(); |
| fn0(); |
| let vf43: vec4i = (vec4i(unconst_i32(195), unconst_i32(77), unconst_i32(153), unconst_i32(276)) & vec4i(unconst_i32(86), unconst_i32(-6), unconst_i32(259), unconst_i32(163))); |
| var vf44: vec4f = cos(vec4f(unconst_f32(0.1538), unconst_f32(0.1635), unconst_f32(0.5199), unconst_f32(0.00432))); |
| out.f1 |= pack4x8unorm(unpack4x8unorm(unconst_u32(7))); |
| discard; |
| if bool(vp2.whole[1]) { |
| fn0(); |
| fn0(); |
| } |
| return out; |
| _ = st1; |
| } |
| |
| /* used global variables: st1 */ |
| @compute @workgroup_size(1, 1, 1) |
| fn compute1() { |
| vw10 = vec4<bool>(bool(atomicExchange(&vw4, textureLoad(st1, unconst_i32(51)).y))); |
| var vf45: vec2i = reverseBits(vec2i(unconst_i32(405), unconst_i32(119))); |
| var vf46 = fn1(); |
| fn1(); |
| vw10 = vec4<bool>(bool((*&vw2)[9].f1)); |
| fn1(); |
| let vf47: f16 = dot(vec2h(unconst_f16(22655.3), unconst_f16(1401.4)), vec2h(unconst_f16(16951.4), unconst_f16(7204.6))); |
| fn1(); |
| fn0(); |
| _ = st1; |
| }`, |
| }); |
| let bindGroup0 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout2, |
| entries: [ |
| {binding: 41, resource: textureView8}, |
| {binding: 39, resource: {buffer: buffer5, offset: 256, size: 5516}}, |
| ], |
| }); |
| let commandEncoder7 = device0.createCommandEncoder(); |
| let textureView12 = texture7.createView({dimension: '2d-array'}); |
| let computePassEncoder5 = commandEncoder4.beginComputePass({}); |
| let sampler6 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| lodMaxClamp: 99.36, |
| maxAnisotropy: 1, |
| }); |
| try { |
| commandEncoder5.clearBuffer(buffer2, 56, 832); |
| } catch {} |
| let commandEncoder8 = device0.createCommandEncoder({}); |
| let texture9 = device0.createTexture({ |
| size: [32, 32, 21], |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView13 = texture9.createView({dimension: 'cube', baseArrayLayer: 6, arrayLayerCount: 6}); |
| let computePassEncoder6 = commandEncoder8.beginComputePass({}); |
| try { |
| computePassEncoder6.setBindGroup(0, bindGroup0); |
| } catch {} |
| try { |
| buffer1.unmap(); |
| } catch {} |
| let buffer7 = device0.createBuffer({ |
| label: '\ub32c\u{1fea1}\u{1fa69}\ue24b\u{1fa03}', |
| size: 555, |
| usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder9 = device0.createCommandEncoder(); |
| let textureView14 = texture5.createView({}); |
| let textureView15 = texture0.createView({label: '\u6e0c\u86c3\u{1ff65}\u5160\u8194\u0b37\u8f3d\ufe0e\udc63\u05dc\uc549'}); |
| let computePassEncoder7 = commandEncoder9.beginComputePass({}); |
| let sampler7 = device0.createSampler({ |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 88.02, |
| compare: 'equal', |
| maxAnisotropy: 10, |
| }); |
| let imageData2 = new ImageData(60, 24); |
| let bindGroup1 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [{binding: 144, resource: textureView5}, {binding: 323, resource: {buffer: buffer2, offset: 0}}], |
| }); |
| let buffer8 = device0.createBuffer({ |
| size: 3020, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM, |
| mappedAtCreation: false, |
| }); |
| let commandEncoder10 = device0.createCommandEncoder({}); |
| let textureView16 = texture9.createView({dimension: '2d'}); |
| let textureView17 = texture7.createView({format: 'rg8unorm'}); |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| await buffer4.mapAsync(GPUMapMode.WRITE, 0, 52); |
| } catch {} |
| let pipeline0 = device0.createRenderPipeline({ |
| layout: pipelineLayout1, |
| fragment: {module: shaderModule1, targets: [{format: 'rg8unorm', writeMask: GPUColorWrite.ALL}]}, |
| vertex: { |
| module: shaderModule0, |
| buffers: [ |
| { |
| arrayStride: 96, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'uint8x2', offset: 2, shaderLocation: 0}, |
| {format: 'uint16x2', offset: 12, shaderLocation: 13}, |
| ], |
| }, |
| ], |
| }, |
| primitive: { |
| topology: 'triangle-strip', |
| stripIndexFormat: 'uint32', |
| frontFace: 'cw', |
| cullMode: 'back', |
| unclippedDepth: true, |
| }, |
| }); |
| try { |
| computePassEncoder2.setBindGroup(1, bindGroup0, new Uint32Array(1161), 208, 0); |
| } catch {} |
| try { |
| commandEncoder5.copyTextureToTexture({ |
| texture: texture1, |
| mipLevel: 0, |
| origin: {x: 478, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture3, |
| mipLevel: 0, |
| origin: {x: 223, y: 0, z: 182}, |
| aspect: 'all', |
| }, |
| {width: 75, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup2 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [ |
| {binding: 323, resource: {buffer: buffer5, offset: 2048, size: 13364}}, |
| {binding: 144, resource: textureView2}, |
| ], |
| }); |
| let texture10 = device0.createTexture({ |
| size: {width: 307, height: 7, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder8 = commandEncoder5.beginComputePass({}); |
| try { |
| computePassEncoder1.setBindGroup(1, bindGroup2, new Uint32Array(3161), 10, 0); |
| } catch {} |
| try { |
| commandEncoder7.copyBufferToTexture({ |
| /* bytesInLastRow: 4 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 1804 */ |
| offset: 1804, |
| bytesPerRow: 11008, |
| rowsPerImage: 336, |
| buffer: buffer8, |
| }, { |
| texture: texture10, |
| mipLevel: 0, |
| origin: {x: 21, y: 1, z: 0}, |
| aspect: 'all', |
| }, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer9 = device0.createBuffer({size: 350, usage: GPUBufferUsage.MAP_WRITE}); |
| let commandEncoder11 = device0.createCommandEncoder({}); |
| let sampler8 = device0.createSampler({ |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| maxAnisotropy: 10, |
| }); |
| try { |
| computePassEncoder3.setBindGroup(1, bindGroup1, new Uint32Array(2897), 516, 0); |
| } catch {} |
| try { |
| commandEncoder11.copyTextureToTexture({ |
| texture: texture1, |
| mipLevel: 0, |
| origin: {x: 68, y: 1, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture3, |
| mipLevel: 0, |
| origin: {x: 100, y: 0, z: 121}, |
| aspect: 'all', |
| }, |
| {width: 24, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline1 = device0.createComputePipeline({layout: pipelineLayout1, compute: {module: shaderModule0, constants: {}}}); |
| let pipeline2 = await device0.createRenderPipelineAsync({ |
| layout: pipelineLayout1, |
| fragment: { |
| module: shaderModule1, |
| entryPoint: 'fragment1', |
| targets: [{format: 'rg8unorm', writeMask: GPUColorWrite.BLUE | GPUColorWrite.RED}], |
| }, |
| vertex: { |
| module: shaderModule0, |
| buffers: [ |
| { |
| arrayStride: 2048, |
| stepMode: 'vertex', |
| attributes: [ |
| {format: 'uint32', offset: 392, shaderLocation: 13}, |
| {format: 'uint32', offset: 308, shaderLocation: 0}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-list', frontFace: 'cw', unclippedDepth: true}, |
| }); |
| let bindGroup3 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [{binding: 323, resource: {buffer: buffer2, offset: 0}}, {binding: 144, resource: textureView4}], |
| }); |
| let commandEncoder12 = device0.createCommandEncoder({}); |
| let computePassEncoder9 = commandEncoder11.beginComputePass({}); |
| let sampler9 = device0.createSampler({ |
| label: '\u020a\u98b6\u02a2\ue2b8\u0666\u0192\ud788\u0693\u0e97\u{1fb4a}\u0755', |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| }); |
| try { |
| computePassEncoder1.setBindGroup(3, bindGroup1, new Uint32Array(52), 3, 0); |
| } catch {} |
| let buffer10 = device0.createBuffer({size: 17576, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE}); |
| let sampler10 = device0.createSampler({ |
| label: '\u{1f73d}\ua3f9\u1d11\ucbae\u{1ff5e}\ubc5f\u5826\u8c44\ue4f8\u20d8\u20e1', |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| lodMaxClamp: 60.44, |
| }); |
| let offscreenCanvas0 = new OffscreenCanvas(145, 399); |
| let bindGroup4 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [ |
| {binding: 323, resource: {buffer: buffer5, offset: 3328, size: 1200}}, |
| {binding: 144, resource: textureView2}, |
| ], |
| }); |
| let commandEncoder13 = device0.createCommandEncoder({}); |
| let computePassEncoder10 = commandEncoder13.beginComputePass({}); |
| let arrayBuffer0 = buffer4.getMappedRange(0, 4); |
| try { |
| commandEncoder12.copyTextureToBuffer({ |
| texture: texture1, |
| mipLevel: 0, |
| origin: {x: 312, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 596 widthInBlocks: 149 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1264 */ |
| offset: 1264, |
| bytesPerRow: 36096, |
| rowsPerImage: 1028, |
| buffer: buffer5, |
| }, {width: 149, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let textureView18 = texture0.createView({aspect: 'all'}); |
| let computePassEncoder11 = commandEncoder7.beginComputePass({}); |
| let sampler11 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'repeat', lodMaxClamp: 99.64}); |
| try { |
| computePassEncoder8.setBindGroup(1, bindGroup2); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 123, height: 1, depthOrArrayLayers: 153} |
| */ |
| { |
| source: imageData0, |
| origin: { x: 6, y: 87 }, |
| flipY: false, |
| }, { |
| texture: texture6, |
| mipLevel: 1, |
| origin: {x: 44, y: 0, z: 34}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 7, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture11 = device0.createTexture({ |
| size: [1880, 10, 1], |
| mipLevelCount: 1, |
| format: 'r32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture12 = device0.createTexture({ |
| size: [307, 7, 256], |
| mipLevelCount: 3, |
| dimension: '3d', |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rg8unorm'], |
| }); |
| let computePassEncoder12 = commandEncoder12.beginComputePass({}); |
| try { |
| computePassEncoder8.setPipeline(pipeline1); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 123, height: 1, depthOrArrayLayers: 153} |
| */ |
| { |
| source: imageData1, |
| origin: { x: 1, y: 2 }, |
| flipY: true, |
| }, { |
| texture: texture6, |
| mipLevel: 1, |
| origin: {x: 15, y: 1, z: 10}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 14, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| sampler8.label = '\u06ae\uc71d\u505f\u9722'; |
| } catch {} |
| let textureView19 = texture9.createView({dimension: 'cube'}); |
| let sampler12 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| lodMinClamp: 72.45, |
| lodMaxClamp: 86.90, |
| }); |
| try { |
| computePassEncoder11.setBindGroup(1, bindGroup3); |
| } catch {} |
| try { |
| computePassEncoder1.setBindGroup(0, bindGroup2, new Uint32Array(4186), 73, 0); |
| } catch {} |
| let commandEncoder14 = device0.createCommandEncoder({label: '\u0259\u{1f63b}\u58af\u{1fe26}\u2594\u{1f710}\u{1fdb5}'}); |
| let texture13 = device0.createTexture({ |
| label: '\uf69e\u886d\ufa68\uadf5\u2a4a', |
| size: {width: 1968, height: 1, depthOrArrayLayers: 94}, |
| format: 'r32float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder13 = commandEncoder10.beginComputePass({}); |
| let sampler13 = device0.createSampler({ |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 83.88, |
| compare: 'always', |
| maxAnisotropy: 18, |
| }); |
| try { |
| commandEncoder14.copyBufferToTexture({ |
| /* bytesInLastRow: 246 widthInBlocks: 123 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 820 */ |
| offset: 820, |
| bytesPerRow: 27904, |
| buffer: buffer1, |
| }, { |
| texture: texture7, |
| mipLevel: 0, |
| origin: {x: 264, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 123, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer2, 376, new DataView(new ArrayBuffer(32932)), 501, 260); |
| } catch {} |
| try { |
| device0.queue.label = '\u82d0\u0c66\u0573\u7260'; |
| } catch {} |
| let texture14 = device0.createTexture({ |
| size: [984, 1, 32], |
| format: 'r32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView20 = texture3.createView({ |
| label: '\u{1f7e4}\u{1fd43}\u83f5\u80e2\u0406\u802e\ua655\u0fae\u{1f941}\u{1fc22}\u{1fda0}', |
| mipLevelCount: 1, |
| }); |
| try { |
| computePassEncoder5.setBindGroup(0, bindGroup0); |
| } catch {} |
| try { |
| buffer2.unmap(); |
| } catch {} |
| let shaderModule2 = device0.createShaderModule({ |
| code: ` |
| diagnostic(info, xyz); |
| |
| enable f16; |
| |
| requires unrestricted_pointer_parameters; |
| |
| var<workgroup> vw13: atomic<i32>; |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| @group(0) @binding(144) var st2: texture_storage_1d<r32uint, read_write>; |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| var<workgroup> vw18: array<array<atomic<u32>, 1>, 39>; |
| |
| struct T2 { |
| @align(16) @size(1008) f0: array<atomic<u32>>, |
| } |
| |
| var<workgroup> vw16: VertexOutput1; |
| |
| struct T1 { |
| @size(128) f0: vec2i, |
| @align(8) @size(736) f1: array<atomic<i32>>, |
| } |
| |
| @group(0) @binding(323) var<storage, read> buffer11: array<array<array<array<f16, 1>, 3>, 8>, 18>; |
| |
| struct FragmentOutput2 { |
| @location(0) f0: vec2f, |
| @location(5) @interpolate(linear) f1: f32, |
| } |
| |
| var<workgroup> vw17: vec2i; |
| |
| var<workgroup> vw20: FragmentOutput2; |
| |
| var<private> vp4: FragmentOutput2 = FragmentOutput2(vec2f(0.1685, 0.2553), f32(-0.03630)); |
| |
| struct VertexOutput1 { |
| @builtin(position) f1: vec4f, |
| } |
| |
| var<workgroup> vw15: mat4x4h; |
| |
| var<workgroup> vw14: array<mat4x2h, 1>; |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| var<workgroup> vw19: array<atomic<i32>, 6>; |
| |
| struct T0 { |
| @size(864) f0: array<u32>, |
| } |
| |
| var<workgroup> vw21: array<array<atomic<u32>, 1>, 3>; |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| struct T3 { |
| @align(32) @size(864) f0: array<f16>, |
| } |
| |
| var<workgroup> vw12: atomic<u32>; |
| |
| /* used global variables: buffer11 */ |
| fn fn0(a0: ptr<uniform, VertexOutput1>) -> FragmentOutput2 { |
| var out: FragmentOutput2; |
| let vf48: u32 = pack2x16float(vec2f(unconst_f32(-0.1590), unconst_f32(0.2879))); |
| out.f1 = f32((vec3i(unconst_i32(43), unconst_i32(100), unconst_i32(131)) ^ vec3i(unconst_i32(364), unconst_i32(75), unconst_i32(29)))[1]); |
| let ptr7: ptr<storage, array<f16, 1>, read> = &(*&buffer11)[unconst_u32(1)][unconst_u32(720)][unconst_u32(209)]; |
| vp4 = FragmentOutput2(vec2f(f32((*&buffer11)[17][7][u32(buffer11[pack2x16float(vec2f(unconst_f32(0.1295), unconst_f32(0.06867)))][unconst_u32(29)][2][u32((*&buffer11)[unconst_u32(2)][7][2][0])])][0])), f32((*&buffer11)[17][7][u32(buffer11[pack2x16float(vec2f(unconst_f32(0.1295), unconst_f32(0.06867)))][unconst_u32(29)][2][u32((*&buffer11)[unconst_u32(2)][7][2][0])])][0])); |
| let ptr8: ptr<storage, array<f16, 1>, read> = &buffer11[17][7][2]; |
| let ptr9: ptr<storage, f16, read> = &buffer11[unconst_u32(124)][7][2][unconst_u32(16)]; |
| let ptr10: ptr<storage, f16, read> = &buffer11[unconst_u32(174)][u32(buffer11[17][7][2][0])][unconst_u32(16)][0]; |
| { |
| out.f1 += f32((*&buffer11)[17][7][2][0]); |
| switch i32(buffer11[17][unconst_u32(37)][u32(buffer11[unconst_u32(72)][7][2][unconst_u32(80)])][0]) { |
| default { |
| let ptr11: ptr<storage, array<array<f16, 1>, 3>, read> = &(*&buffer11)[17][7]; |
| let vf49: vec4<bool> = (vec4f(unconst_f32(0.1032), unconst_f32(0.1105), unconst_f32(0.04588), unconst_f32(0.2258)) < vec4f(unconst_f32(0.09814), unconst_f32(0.03240), unconst_f32(0.1214), unconst_f32(0.03619))); |
| let ptr12: ptr<storage, f16, read> = &(*&buffer11)[17][7][2][unconst_u32(52)]; |
| let ptr13: ptr<storage, array<array<f16, 1>, 3>, read> = &buffer11[17][unconst_u32(18)]; |
| _ = buffer11; |
| } |
| } |
| out.f0 = vec2f(f32((*&buffer11)[17][unconst_u32(272)][2][unconst_u32(244)])); |
| var vf50: vec2u = insertBits(vec2u(unconst_u32(12), unconst_u32(48)), vec2u(bitcast<u32>(vp4.f1)), unconst_u32(109), unconst_u32(243)); |
| let ptr14: ptr<storage, array<f16, 1>, read> = &(*&buffer11)[unconst_u32(80)][unconst_u32(106)][2]; |
| vp4 = FragmentOutput2(vec2f(f32((*&buffer11)[unconst_u32(237)][7][unconst_u32(115)][unconst_u32(81)])), f32((*&buffer11)[unconst_u32(237)][7][unconst_u32(115)][unconst_u32(81)])); |
| return out; |
| _ = buffer11; |
| } |
| let ptr15: ptr<storage, array<array<f16, 1>, 3>, read> = &buffer11[17][7]; |
| return out; |
| _ = buffer11; |
| } |
| |
| override override0 = true; |
| |
| /* used global variables: buffer11 */ |
| @vertex |
| fn vertex1(@location(0) a0: f32) -> VertexOutput1 { |
| var out: VertexOutput1; |
| out.f1 += vec4f(f32(buffer11[unconst_u32(79)][7][u32((*&buffer11)[unconst_u32(190)][7][unconst_u32(250)][0])][unconst_u32(457)])); |
| vp4.f1 = f32(buffer11[17][unconst_u32(324)][2][0]); |
| out = VertexOutput1(vec4f(f32((*&buffer11)[unconst_u32(315)][unconst_u32(19)][u32(buffer11[17][7][2][0])][0]))); |
| let ptr16: ptr<storage, f16, read> = &(*&buffer11)[unconst_u32(12)][7][2][0]; |
| vp4.f0 = vec2f(f32((*&buffer11)[unconst_u32(691)][unconst_u32(303)][2][0])); |
| vp4.f0 += vec2f(f32(buffer11[17][7][unconst_u32(19)][0])); |
| out = VertexOutput1(vec4f(f32((*&buffer11)[17][7][2][0]))); |
| out = VertexOutput1(vec4f(f32(buffer11[17][u32(buffer11[unconst_u32(38)][7][2][0])][2][0]))); |
| out.f1 -= vec4f(f32(buffer11[17][7][unconst_u32(28)][unconst_u32(49)])); |
| return out; |
| _ = buffer11; |
| } |
| |
| /* used global variables: st2 */ |
| @fragment |
| fn fragment2() -> FragmentOutput2 { |
| var out: FragmentOutput2; |
| let vf51: bool = override0; |
| vp4 = FragmentOutput2(vec2f(log(vec2h(unconst_f16(-6222.3), unconst_f16(12486.8)))), bitcast<f32>(log(vec2h(unconst_f16(-6222.3), unconst_f16(12486.8))))); |
| var vf52: vec4f = pow(pow(vec4f(unconst_f32(0.1774), unconst_f32(-0.02059), unconst_f32(-0.1334), unconst_f32(-0.1585)), vec4f(unconst_f32(0.1541), unconst_f32(-0.06037), unconst_f32(0.1825), unconst_f32(0.03583))), vec4f(unconst_f32(-0.00619), unconst_f32(0.05903), unconst_f32(0.3068), unconst_f32(0.03372))); |
| var vf53: f32 = vp4.f0[unconst_u32(388)]; |
| var vf54: vec4<bool> = (vec4i(unconst_i32(107), unconst_i32(501), unconst_i32(244), unconst_i32(27)) > vec4i(unconst_i32(24), unconst_i32(-143), unconst_i32(228), unconst_i32(63))); |
| var vf55: vec2f = sign(vec2f(unconst_f32(0.2010), unconst_f32(0.03168))); |
| let vf56: mat2x3f = transpose(mat3x2f(vec2f(countOneBits(vec4i(unconst_i32(39), unconst_i32(488), unconst_i32(108), unconst_i32(169))).bg), vec2f(countOneBits(vec4i(unconst_i32(39), unconst_i32(488), unconst_i32(108), unconst_i32(169))).yy), vec2f(countOneBits(vec4i(unconst_i32(39), unconst_i32(488), unconst_i32(108), unconst_i32(169))).ar))); |
| switch bitcast<i32>(vp4.f0[unconst_u32(156)]) { |
| default { |
| let vf57: f32 = inverseSqrt(unconst_f32(0.1448)); |
| } |
| } |
| let vf58: f16 = determinant(mat2x2h()); |
| var vf59: vec3f = reflect(vec3f(unconst_f32(0.06366), unconst_f32(1.000), unconst_f32(0.2202)), vec3f(unconst_f32(-0.1147), unconst_f32(-0.02535), unconst_f32(0.08317))); |
| var vf60: u32 = pack4x8unorm(vec4f(unconst_f32(0.1792), unconst_f32(0.02724), unconst_f32(0.1626), unconst_f32(0.1549))); |
| vf60 >>= textureLoad(st2, unconst_i32(-50)).w; |
| let vf61: vec2i = countTrailingZeros(vec2i(unconst_i32(-52), unconst_i32(19))); |
| let vf62: f16 = ldexp(unconst_f16(6932.8), unconst_i32(221)); |
| vf60 &= bitcast<vec4u>(quantizeToF16(vec4f(unconst_f32(0.4013), unconst_f32(0.00949), unconst_f32(0.2278), unconst_f32(0.00304)))).w; |
| return out; |
| _ = override0; |
| _ = st2; |
| } |
| |
| /* used global variables: st2 */ |
| @compute @workgroup_size(1, 1, 1) |
| fn compute2(@builtin(workgroup_id) a0: vec3u) { |
| if bool(atomicLoad(&vw18[unconst_u32(166)][0])) { |
| vw16.f1 = vec4f(f32(atomicLoad(&(*&vw13)))); |
| vw20 = FragmentOutput2(unpack2x16unorm(atomicExchange(&(*&vw21)[unconst_u32(120)][unconst_u32(185)], unconst_u32(767))), f32(atomicExchange(&(*&vw21)[unconst_u32(120)][unconst_u32(185)], unconst_u32(767)))); |
| var vf63: u32 = atomicLoad(&(*&vw21)[unconst_u32(195)][unconst_u32(728)]); |
| var vf64: i32 = atomicLoad(&(*&vw19)[5]); |
| } |
| let ptr17: ptr<workgroup, array<array<atomic<u32>, 1>, 39>> = &vw18; |
| let ptr18: ptr<workgroup, atomic<u32>> = &vw18[38][0]; |
| var vf65: vec4h = vw15[unconst_u32(204)]; |
| vw20.f1 = vec2f(vw17)[0]; |
| atomicCompareExchangeWeak(&vw21[unconst_u32(333)][unconst_u32(445)], unconst_u32(168), unconst_u32(407)); |
| vw17 = vec2i(bitcast<i32>(vw20.f1)); |
| let ptr19: ptr<workgroup, array<atomic<i32>, 6>> = &vw19; |
| switch bitcast<i32>((*&vw14)[0][unconst_i32(2)]) { |
| default { |
| var vf66: u32 = atomicExchange(&(*&vw21)[unconst_u32(148)][unconst_u32(52)], unconst_u32(502)); |
| while bool(atomicLoad(&(*&vw18)[unconst_u32(258)][unconst_u32(167)])) { |
| let ptr20: ptr<private, f32> = &vp4.f1; |
| return; |
| } |
| textureStore(st2, unconst_i32(706), vec4u(vec4u(unconst_u32(65), unconst_u32(139), unconst_u32(88), unconst_u32(223)))); |
| _ = st2; |
| } |
| } |
| let vf67: f16 = (*&vw14)[unconst_u32(19)][unconst_u32(49)][unconst_u32(2)]; |
| vw17 = vec2i(i32(atomicExchange(&(*ptr17)[38][unconst_u32(251)], unconst_u32(412)))); |
| _ = st2; |
| }`, |
| }); |
| let buffer12 = device0.createBuffer({ |
| size: 32580, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE, |
| mappedAtCreation: false, |
| }); |
| let textureView21 = texture13.createView({baseArrayLayer: 19, arrayLayerCount: 9}); |
| let texture15 = device0.createTexture({ |
| size: {width: 940}, |
| dimension: '1d', |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder14 = commandEncoder14.beginComputePass({}); |
| try { |
| computePassEncoder2.setPipeline(pipeline1); |
| } catch {} |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55); }; |
| } catch {} |
| let buffer13 = device0.createBuffer({ |
| size: 4086, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX, |
| }); |
| let renderBundleEncoder1 = device0.createRenderBundleEncoder({colorFormats: ['rg8unorm'], depthReadOnly: true, stencilReadOnly: true}); |
| let renderBundle1 = renderBundleEncoder1.finish({}); |
| let sampler14 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'mirror-repeat', addressModeW: 'mirror-repeat'}); |
| try { |
| computePassEncoder7.setPipeline(pipeline1); |
| } catch {} |
| let commandEncoder15 = device0.createCommandEncoder({}); |
| let texture16 = device0.createTexture({ |
| size: [153, 3, 1], |
| mipLevelCount: 1, |
| format: 'r32sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView22 = texture14.createView({dimension: '2d'}); |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| commandEncoder15.copyBufferToBuffer(buffer1, 2688, buffer12, 2516, 792); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer12, 524, new Float32Array(19788), 901, 952); |
| } catch {} |
| let gpuCanvasContext0 = offscreenCanvas0.getContext('webgpu'); |
| let buffer14 = device0.createBuffer({ |
| label: '\u{1fe03}\u0c82\uc6d3\u0cd3\u9ba7\u0e55\ub34f', |
| size: 33683, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let textureView23 = texture16.createView({}); |
| let textureView24 = texture2.createView({baseMipLevel: 0, mipLevelCount: 1, arrayLayerCount: 1}); |
| let computePassEncoder15 = commandEncoder15.beginComputePass({}); |
| try { |
| computePassEncoder0.setPipeline(pipeline1); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture10, |
| mipLevel: 0, |
| origin: {x: 36, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(7).fill(105), /* required buffer size: 7 */ |
| {offset: 7, rowsPerImage: 24}, {width: 92, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let renderBundleEncoder2 = device0.createRenderBundleEncoder({colorFormats: ['rg8unorm'], depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| computePassEncoder4.setBindGroup(2, bindGroup0); |
| } catch {} |
| try { |
| computePassEncoder11.setPipeline(pipeline1); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer13, 376, new Float32Array(24745), 4037, 136); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture10, |
| mipLevel: 0, |
| origin: {x: 22, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(72).fill(36), /* required buffer size: 72 */ |
| {offset: 72, bytesPerRow: 331}, {width: 120, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let veryExplicitBindGroupLayout3 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 144, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '1d' }, |
| }, |
| { |
| binding: 323, |
| visibility: GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let pipelineLayout3 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout0]}); |
| let commandEncoder16 = device0.createCommandEncoder({}); |
| let textureView25 = texture7.createView({dimension: '2d-array', format: 'rg8unorm', mipLevelCount: 1}); |
| let texture17 = device0.createTexture({ |
| size: [492, 1, 1], |
| mipLevelCount: 2, |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder16 = commandEncoder16.beginComputePass(); |
| try { |
| computePassEncoder4.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder2.setBindGroup(3, bindGroup4); |
| } catch {} |
| try { |
| renderBundleEncoder2.setBindGroup(3, bindGroup4, new Uint32Array(4870), 1_211, 0); |
| } catch {} |
| let textureView26 = texture2.createView({dimension: '2d', mipLevelCount: 1}); |
| let renderBundle2 = renderBundleEncoder2.finish(); |
| try { |
| computePassEncoder4.setBindGroup(1, bindGroup3); |
| } catch {} |
| try { |
| computePassEncoder10.setBindGroup(1, bindGroup3, new Uint32Array(583), 126, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer13, 432, new DataView(new ArrayBuffer(3079)), 417, 372); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let bindGroup5 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout2, |
| entries: [{binding: 41, resource: textureView8}, {binding: 39, resource: {buffer: buffer2, offset: 0}}], |
| }); |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| buffer10.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture11, |
| mipLevel: 0, |
| origin: {x: 74, y: 3, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(143).fill(120), /* required buffer size: 143 */ |
| {offset: 143, bytesPerRow: 3858}, {width: 952, height: 4, depthOrArrayLayers: 0}); |
| } catch {} |
| let veryExplicitBindGroupLayout4 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 39, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| { |
| binding: 41, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: true }, |
| }, |
| ], |
| }); |
| let sampler15 = device0.createSampler({ |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 41.93, |
| lodMaxClamp: 87.15, |
| maxAnisotropy: 20, |
| }); |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let veryExplicitBindGroupLayout5 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 33, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| {binding: 54, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'comparison' }}, |
| {binding: 77, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| { |
| binding: 119, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '2d' }, |
| }, |
| {binding: 155, visibility: GPUShaderStage.COMPUTE, externalTexture: {}}, |
| ], |
| }); |
| let buffer15 = device0.createBuffer({size: 1293, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE}); |
| let commandEncoder17 = device0.createCommandEncoder(); |
| let textureView27 = texture14.createView({dimension: '2d', baseArrayLayer: 9}); |
| let computePassEncoder17 = commandEncoder17.beginComputePass({}); |
| try { |
| computePassEncoder9.setPipeline(pipeline1); |
| } catch {} |
| try { |
| computePassEncoder1.setBindGroup(2, bindGroup3, []); |
| } catch {} |
| try { |
| computePassEncoder15.setPipeline(pipeline1); |
| } catch {} |
| let promise1 = device0.queue.onSubmittedWorkDone(); |
| let recycledExplicitBindGroupLayout0 = pipeline0.getBindGroupLayout(1); |
| try { |
| computePassEncoder4.setBindGroup(0, bindGroup4); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder4); computePassEncoder4.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| try { |
| await promise1; |
| } catch {} |
| let buffer16 = device0.createBuffer({ |
| size: 1673, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let textureView28 = texture8.createView({baseMipLevel: 0, mipLevelCount: 1}); |
| try { |
| computePassEncoder5.setBindGroup(2, bindGroup5); |
| } catch {} |
| try { |
| computePassEncoder11.setPipeline(pipeline1); |
| } catch {} |
| try { |
| computePassEncoder14.insertDebugMarker('\u0f75'); |
| } catch {} |
| let bindGroup6 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout2, |
| entries: [ |
| {binding: 41, resource: textureView8}, |
| {binding: 39, resource: {buffer: buffer5, offset: 1792, size: 544}}, |
| ], |
| }); |
| let buffer17 = device0.createBuffer({label: '\ud11e\u{1f603}', size: 7388, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let commandEncoder18 = device0.createCommandEncoder({}); |
| let texture18 = device0.createTexture({ |
| size: [32, 32, 50], |
| mipLevelCount: 1, |
| dimension: '3d', |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder2.setBindGroup(1, bindGroup4); |
| } catch {} |
| try { |
| computePassEncoder3.setBindGroup(0, bindGroup1, new Uint32Array(3930), 8, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder4); computePassEncoder4.dispatchWorkgroupsIndirect(buffer12, 5_840); }; |
| } catch {} |
| let pipeline3 = await device0.createComputePipelineAsync({layout: pipelineLayout2, compute: {module: shaderModule1, constants: {}}}); |
| let bindGroup7 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout2, |
| entries: [{binding: 39, resource: {buffer: buffer10, offset: 512}}, {binding: 41, resource: textureView28}], |
| }); |
| let commandEncoder19 = device0.createCommandEncoder(); |
| let textureView29 = texture18.createView({aspect: 'all'}); |
| let computePassEncoder18 = commandEncoder18.beginComputePass({label: '\u{1f67c}\u42c8\u096e\u88c4\u{1ff21}'}); |
| try { |
| computePassEncoder9.setBindGroup(0, bindGroup2); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder4); computePassEncoder4.dispatchWorkgroups(2, 1, 1); }; |
| } catch {} |
| try { |
| computePassEncoder13.setPipeline(pipeline3); |
| } catch {} |
| let buffer18 = device0.createBuffer({size: 2718, usage: GPUBufferUsage.INDEX}); |
| let computePassEncoder19 = commandEncoder19.beginComputePass({}); |
| let renderBundleEncoder3 = device0.createRenderBundleEncoder({colorFormats: ['rg8unorm'], stencilReadOnly: true}); |
| try { |
| computePassEncoder16.setBindGroup(3, bindGroup1, new Uint32Array(257), 35, 0); |
| } catch {} |
| try { |
| computePassEncoder17.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder3.setBindGroup(2, bindGroup5); |
| } catch {} |
| let buffer19 = device0.createBuffer({ |
| size: 7226, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE, |
| }); |
| let querySet0 = device0.createQuerySet({type: 'occlusion', count: 488}); |
| let textureView30 = texture10.createView({mipLevelCount: 1}); |
| let sampler16 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| mipmapFilter: 'nearest', |
| lodMaxClamp: 69.53, |
| maxAnisotropy: 1, |
| }); |
| try { |
| computePassEncoder18.setBindGroup(2, bindGroup5, new Uint32Array(96), 20, 0); |
| } catch {} |
| try { |
| computePassEncoder19.setPipeline(pipeline1); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture7, |
| mipLevel: 0, |
| origin: {x: 80, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(230).fill(112), /* required buffer size: 230 */ |
| {offset: 230}, {width: 20, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| computePassEncoder11.setBindGroup(2, bindGroup5); |
| } catch {} |
| try { |
| computePassEncoder17.setBindGroup(0, bindGroup3, new Uint32Array(285), 80, 0); |
| } catch {} |
| try { |
| computePassEncoder4.end(); |
| } catch {} |
| try { |
| renderBundleEncoder3.setPipeline(pipeline2); |
| } catch {} |
| let imageData3 = new ImageData(12, 52); |
| let buffer20 = device0.createBuffer({ |
| size: 26025, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder20 = device0.createCommandEncoder({}); |
| let commandBuffer0 = commandEncoder3.finish(); |
| let texture19 = device0.createTexture({ |
| size: [80, 90, 1], |
| mipLevelCount: 2, |
| sampleCount: 1, |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| let computePassEncoder20 = commandEncoder20.beginComputePass({}); |
| try { |
| renderBundleEncoder3.setBindGroup(3, bindGroup5, new Uint32Array(1436), 12, 0); |
| } catch {} |
| try { |
| renderBundleEncoder3.setIndexBuffer(buffer0, 'uint32', 40, 558); |
| } catch {} |
| try { |
| renderBundleEncoder3.setVertexBuffer(6, buffer14, 364, 8_884); |
| } catch {} |
| let img0 = await imageWithData(20, 89, '#10101010', '#20202020'); |
| let buffer21 = device0.createBuffer({size: 39542, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX}); |
| try { |
| computePassEncoder16.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderBundleEncoder3.setPipeline(pipeline2); |
| } catch {} |
| let texture20 = device0.createTexture({size: [984, 1, 1], format: 'rg8unorm', usage: GPUTextureUsage.COPY_SRC}); |
| try { |
| computePassEncoder1.setBindGroup(1, bindGroup6); |
| } catch {} |
| try { |
| computePassEncoder18.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderBundleEncoder3.setBindGroup(3, bindGroup5); |
| } catch {} |
| try { |
| renderBundleEncoder3.setVertexBuffer(0, undefined, 0, 367_731_839); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 123, height: 1, depthOrArrayLayers: 153} |
| */ |
| { |
| source: offscreenCanvas0, |
| origin: { x: 44, y: 35 }, |
| flipY: false, |
| }, { |
| texture: texture6, |
| mipLevel: 1, |
| origin: {x: 5, y: 0, z: 77}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 31, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let veryExplicitBindGroupLayout6 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 45, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'uniform', hasDynamicOffset: false }}, |
| { |
| binding: 64, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| {binding: 68, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| { |
| binding: 97, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| externalTexture: {}, |
| }, |
| ], |
| }); |
| let bindGroup8 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [ |
| {binding: 144, resource: textureView5}, |
| {binding: 323, resource: {buffer: buffer20, offset: 6400, size: 3044}}, |
| ], |
| }); |
| let renderBundle3 = renderBundleEncoder3.finish({}); |
| try { |
| computePassEncoder1.setBindGroup(0, bindGroup4); |
| } catch {} |
| try { |
| computePassEncoder12.setBindGroup(0, bindGroup2, new Uint32Array(10000), 2_039, 0); |
| } catch {} |
| let pipeline4 = await device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| fragment: { |
| module: shaderModule1, |
| constants: {}, |
| targets: [{ |
| format: 'rg8unorm', |
| blend: { |
| color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'}, |
| alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'}, |
| }, |
| writeMask: GPUColorWrite.BLUE | GPUColorWrite.RED, |
| }], |
| }, |
| vertex: { |
| module: shaderModule0, |
| buffers: [ |
| { |
| arrayStride: 48, |
| stepMode: 'instance', |
| attributes: [{format: 'uint32', offset: 0, shaderLocation: 13}, {format: 'uint32x4', offset: 0, shaderLocation: 0}], |
| }, |
| ], |
| }, |
| primitive: {cullMode: 'front'}, |
| }); |
| let buffer22 = device0.createBuffer({ |
| size: 2724, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, |
| }); |
| let texture21 = device0.createTexture({ |
| size: [80, 90, 1], |
| mipLevelCount: 1, |
| dimension: '2d', |
| format: 'r32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder10.setPipeline(pipeline3); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer13, 1700, new DataView(new ArrayBuffer(3443)), 603, 236); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let imageData4 = new ImageData(76, 4); |
| let buffer23 = device0.createBuffer({size: 2592, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let texture22 = device0.createTexture({ |
| size: {width: 40, height: 45, depthOrArrayLayers: 5}, |
| mipLevelCount: 1, |
| format: 'r32float', |
| usage: GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder15.setBindGroup(1, bindGroup2); |
| } catch {} |
| try { |
| computePassEncoder6.setPipeline(pipeline3); |
| } catch {} |
| try { |
| computePassEncoder12.setBindGroup(2, bindGroup1); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 246, height: 1, depthOrArrayLayers: 307} |
| */ |
| { |
| source: img0, |
| origin: { x: 0, y: 8 }, |
| flipY: true, |
| }, { |
| texture: texture6, |
| mipLevel: 0, |
| origin: {x: 178, y: 0, z: 3}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer24 = device0.createBuffer({ |
| size: 395, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| try { |
| computePassEncoder20.setPipeline(pipeline1); |
| } catch {} |
| let bindGroup9 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout0, |
| entries: [ |
| {binding: 144, resource: textureView5}, |
| {binding: 323, resource: {buffer: buffer15, offset: 0, size: 940}}, |
| ], |
| }); |
| let commandEncoder21 = device0.createCommandEncoder({}); |
| let texture23 = device0.createTexture({ |
| size: [984, 1, 302], |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder21 = commandEncoder21.beginComputePass(); |
| let sampler17 = device0.createSampler({ |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 99.33, |
| compare: 'not-equal', |
| maxAnisotropy: 13, |
| }); |
| try { |
| computePassEncoder10.setBindGroup(1, bindGroup6); |
| } catch {} |
| let shaderModule3 = device0.createShaderModule({ |
| code: ` |
| requires unrestricted_pointer_parameters; |
| |
| enable f16; |
| |
| var<workgroup> vw22: VertexOutput2; |
| |
| struct FragmentOutput3 { |
| @location(0) f0: vec4f, |
| } |
| |
| struct T1 { |
| @align(32) @size(864) f0: array<vec4h>, |
| } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| var<private> vp5 = modf(vec4h(14954.3, 932.9, 15541.3, 10579.1)); |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| @group(0) @binding(323) var<storage, read> buffer25: array<array<array<vec2h, 1>, 216>>; |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| var<private> vp6: array<array<f16, 1>, 1> = array(array<f16, 1>()); |
| |
| struct VertexOutput2 { |
| @invariant @builtin(position) f2: vec4f, |
| } |
| |
| /* used global variables: st3 */ |
| fn fn0() -> array<VertexOutput2, 1> { |
| var out: array<VertexOutput2, 1>; |
| textureStore(st3, unconst_i32(502), vec4u(vec4u(unconst_u32(177), unconst_u32(397), unconst_u32(92), unconst_u32(28)))); |
| vp6[unconst_u32(660)][unconst_u32(100)] *= f16(atomicLoad(&(*&vw24))); |
| let vf68: vec4h = exp(vec4h(unconst_f16(44.79), unconst_f16(4496.1), unconst_f16(1447.5), unconst_f16(2668.9))); |
| let ptr21: ptr<private, array<f16, 1>> = &vp6[0]; |
| let ptr22: ptr<workgroup, vec4f> = &vw23.f0; |
| vw22 = VertexOutput2(vec4f(bitcast<f32>(atomicLoad(&vw24)))); |
| let vf69: vec4f = step(vec4f(unconst_f32(-0.00363), unconst_f32(0.2203), unconst_f32(-0.04871), unconst_f32(0.03188)), vw22.f2); |
| { |
| let ptr23: ptr<private, f16> = &vp6[0][0]; |
| out[unconst_u32(521)].f2 = unpack4x8unorm(pack4xI8(vec4i(unconst_i32(180), unconst_i32(147), unconst_i32(189), unconst_i32(217)))); |
| let ptr24: ptr<private, f16> = &vp6[unconst_u32(156)][u32(vp6[0][unconst_u32(2)])]; |
| textureStore(st3, vec3i(ceil(vec3h(unconst_f16(21984.8), unconst_f16(9705.5), unconst_f16(8135.0))))[1], vec4u(vec4u(unconst_u32(165), unconst_u32(26), unconst_u32(353), unconst_u32(393)))); |
| let ptr25: ptr<private, array<f16, 1>> = &vp6[unconst_u32(18)]; |
| vw22 = VertexOutput2(workgroupUniformLoad(&vw23).f0); |
| vp6[unconst_u32(141)][unconst_u32(136)] = vec4h((*&vw22).f2).g; |
| _ = st3; |
| } |
| var vf70: vec3h = asinh(vec3h(unconst_f16(2048.5), unconst_f16(4942.9), unconst_f16(732.7))); |
| workgroupBarrier(); |
| return out; |
| _ = st3; |
| } |
| |
| alias vec3b = vec3<bool>; |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| struct T0 { |
| @align(16) @size(864) f0: array<atomic<u32>>, |
| } |
| |
| var<workgroup> vw23: FragmentOutput3; |
| |
| var<workgroup> vw24: atomic<i32>; |
| |
| @id(33144) override override1: i32 = 68; |
| |
| @group(0) @binding(144) var st3: texture_storage_1d<r32uint, read_write>; |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| override override2 = 0.1454; |
| |
| /* used global variables: buffer25 */ |
| @vertex |
| fn vertex2(@builtin(instance_index) a0: u32) -> VertexOutput2 { |
| var out: VertexOutput2; |
| vp5.fract = buffer25[unconst_u32(132)][unconst_u32(5)][0].grgr; |
| out.f2 += vec4f(f32((*&buffer25)[arrayLength(&(*&buffer25))][unconst_u32(23)][bitcast<u32>((*&buffer25)[arrayLength(&(*&buffer25))][unconst_u32(13)][0])][bitcast<u32>((*&buffer25)[unconst_u32(111)][unconst_u32(475)][unconst_u32(53)])])); |
| vp5.whole = vec4h(countOneBits(vec4u(unconst_u32(47), unconst_u32(114), unconst_u32(72), unconst_u32(12)))); |
| let ptr26: ptr<storage, array<array<vec2h, 1>, 216>, read> = &(*&buffer25)[arrayLength(&(*&buffer25))]; |
| return out; |
| _ = buffer25; |
| } |
| |
| /* zero global variables used */ |
| @fragment |
| fn fragment3() -> FragmentOutput3 { |
| var out: FragmentOutput3; |
| out.f0 *= quantizeToF16(vec4f(unconst_f32(0.00463), unconst_f32(0.1476), unconst_f32(0.00235), unconst_f32(0.1956))); |
| let ptr27: ptr<private, f16> = &vp6[0][unconst_u32(38)]; |
| let vf71: vec4u = unpack4xU8(unconst_u32(105)); |
| return out; |
| } |
| |
| /* used global variables: st3 */ |
| @compute @workgroup_size(2, 1, 2) |
| fn compute3() { |
| vp5.whole -= vec4h(f16(override2)); |
| fn0(); |
| let ptr28: ptr<workgroup, vec4f> = &vw22.f2; |
| var vf72: vec4f = saturate(vec4f(floor(unconst_f32(0.07633)))); |
| textureStore(st3, unconst_i32(294), vec4u(vec4u(unconst_u32(16), unconst_u32(20), unconst_u32(69), unconst_u32(112)))); |
| vw23.f0 -= vec4f(tan(unconst_f32(0.1676))); |
| vp6[0][unconst_u32(25)] = f16(acos(unconst_f32(-0.02863))); |
| let ptr29: ptr<workgroup, atomic<i32>> = &(*&vw24); |
| var vf73 = fn0(); |
| var vf74 = fn0(); |
| _ = override2; |
| _ = st3; |
| }`, |
| }); |
| let textureView31 = texture21.createView({dimension: '2d-array'}); |
| try { |
| computePassEncoder21.setBindGroup(1, bindGroup8); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer19, 784, new Float32Array(1139), 687, 8); |
| } catch {} |
| let imageData5 = new ImageData(16, 8); |
| try { |
| commandEncoder11.label = '\u2bbe\u{1fa74}\u9d64\u3ff3\u8a3b\ue2dc\u{1fca3}\u07e2\ua28f\u5642'; |
| } catch {} |
| let textureView32 = texture9.createView({dimension: 'cube', mipLevelCount: 1}); |
| try { |
| computePassEncoder1.setBindGroup(0, bindGroup0, []); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let buffer26 = device0.createBuffer({size: 3461, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let texture24 = device0.createTexture({ |
| size: [307, 7, 1], |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let sampler18 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 99.53, |
| maxAnisotropy: 14, |
| }); |
| try { |
| computePassEncoder5.setPipeline(pipeline3); |
| } catch {} |
| let shaderModule4 = device0.createShaderModule({ |
| code: ` |
| requires unrestricted_pointer_parameters; |
| |
| enable f16; |
| |
| var<private> vp8: mat3x4f = mat3x4f(); |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| var<private> vp9: VertexOutput3 = VertexOutput3(); |
| |
| struct FragmentOutput4 { |
| @location(4) @interpolate(flat) f0: u32, |
| @location(0) @interpolate(perspective) f1: vec4f, |
| } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| struct T0 { |
| @align(16) @size(864) f0: array<u32>, |
| } |
| |
| var<private> vp7: VertexOutput3 = VertexOutput3(vec4f(0.1044, 0.04199, 0.2290, 0.09493), vec2f(0.00896, 0.08359)); |
| |
| struct T1 { |
| @align(32) @size(864) f0: array<u32>, |
| } |
| |
| /* zero global variables used */ |
| fn fn0() -> mat4x2f { |
| var out: mat4x2f; |
| let ptr30: ptr<private, bool> = &vp10[unconst_u32(113)]; |
| vp9 = VertexOutput3(vp9.f4.yyyx, vp9.f4); |
| var vf75: u32 = pack2x16snorm(vec2f(unconst_f32(0.1435), unconst_f32(-0.00751))); |
| if bool(asinh(unconst_f32(0.05180))) { |
| while bool(vp7.f3[1]) { |
| let vf76: vec2i = (bitcast<vec2i>(sin(vec4h(unconst_f16(7791.3), unconst_f16(13437.8), unconst_f16(5190.1), unconst_f16(-18448.9)))) >> vec2u(unconst_u32(5), unconst_u32(483))); |
| let vf77: vec2<bool> = (vec2f(unconst_f32(0.2938), unconst_f32(0.1716)) <= vec2f(unconst_f32(-0.4423), unconst_f32(0.1726))); |
| var vf78: vec3u = (vec3u(unconst_u32(293), unconst_u32(114), unconst_u32(461)) | vec3u(abs(vec4h((vec4i(unconst_i32(280), unconst_i32(518), unconst_i32(93), unconst_i32(-3)) << vec4u(unconst_u32(21), unconst_u32(115), unconst_u32(149), unconst_u32(79))))).wyz)); |
| vp9 = VertexOutput3(bitcast<vec4f>( ~vec4i(unconst_i32(208), unconst_i32(-169), unconst_i32(199), unconst_i32(203))), vec2f( ~vec4i(unconst_i32(208), unconst_i32(-169), unconst_i32(199), unconst_i32(203)).bg)); |
| let vf79: u32 = pack4xU8Clamp(vec4u(unconst_u32(223), unconst_u32(289), unconst_u32(88), unconst_u32(101))); |
| } |
| } |
| return out; |
| } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| @group(0) @binding(323) var<storage, read> buffer27: array<array<array<array<i32, 9>, 12>, 2>>; |
| |
| alias vec3b = vec3<bool>; |
| |
| @group(0) @binding(144) var st4: texture_storage_1d<r32uint, read_write>; |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| var<private> vp10: array<bool, 1> = array(bool(false)); |
| |
| struct VertexOutput3 { |
| @builtin(position) f3: vec4f, |
| @location(1) @interpolate(perspective, either) f4: vec2f, |
| } |
| |
| /* used global variables: buffer27 */ |
| @vertex |
| fn vertex3() -> VertexOutput3 { |
| var out: VertexOutput3; |
| let ptr31: ptr<storage, i32, read> = &(*&buffer27)[arrayLength(&(*&buffer27))][1][11][8]; |
| for (var it2=u32(buffer27[unconst_u32(3)][1][11][8]); it2<u32((*&buffer27)[unconst_u32(157)][1][11][8]); it2++) { |
| out = VertexOutput3(vec4f(f32((*&buffer27)[unconst_i32(196)][1][11][8])), vec2f(bitcast<f32>((*&buffer27)[unconst_i32(196)][1][11][8]))); |
| { |
| let vf80: f16 = asinh(unconst_f16(4935.4)); |
| let ptr32: ptr<private, VertexOutput3> = &vp7; |
| } |
| let ptr33: ptr<storage, i32, read> = &buffer27[arrayLength(&buffer27)][1][11][8]; |
| break; |
| _ = buffer27; |
| } |
| out.f3 *= vec4f(bitcast<f32>((*&buffer27)[u32(buffer27[arrayLength(&buffer27)][unconst_u32(261)][11][8])][unconst_u32(58)][unconst_u32(68)][unconst_u32(127)])); |
| let ptr34: ptr<storage, array<i32, 9>, read> = &(*&buffer27)[bitcast<u32>((*&buffer27)[arrayLength(&(*&buffer27))][1][11][8])][1][11]; |
| let ptr35: ptr<storage, i32, read> = &buffer27[arrayLength(&buffer27)][1][unconst_u32(138)][8]; |
| var vf81: f32 = determinant(mat4x4f(vp9.f4[unconst_u32(88)], vp9.f4[unconst_u32(88)], vp9.f4[unconst_u32(88)], vp9.f4[unconst_u32(88)], vp9.f4[unconst_u32(88)], vp9.f4[unconst_u32(88)], vp9.f4[unconst_u32(88)], vp9.f4[unconst_u32(88)], vp9.f4[unconst_u32(88)], vp9.f4[unconst_u32(88)], vp9.f4[unconst_u32(88)], vp9.f4[unconst_u32(88)], vp9.f4[unconst_u32(88)], vp9.f4[unconst_u32(88)], vp9.f4[unconst_u32(88)], vp9.f4[unconst_u32(88)])); |
| out.f3 = vec4f(bitcast<f32>(buffer27[u32((*&buffer27)[arrayLength(&(*&buffer27))][1][11][8])][unconst_u32(173)][11][8])); |
| let ptr36: ptr<storage, array<i32, 9>, read> = &(*&buffer27)[arrayLength(&(*&buffer27))][unconst_u32(68)][unconst_u32(137)]; |
| let ptr37: ptr<storage, array<array<array<i32, 9>, 12>, 2>, read> = &(*&buffer27)[arrayLength(&(*&buffer27))]; |
| let ptr38: ptr<storage, array<i32, 9>, read> = &(*ptr37)[unconst_u32(24)][11]; |
| vp9 = VertexOutput3(vec4f(bitcast<f32>(buffer27[unconst_u32(237)][u32((*ptr34)[8])][unconst_u32(115)][unconst_u32(286)])), vec2f(f32(buffer27[unconst_u32(237)][u32((*ptr34)[8])][unconst_u32(115)][unconst_u32(286)]))); |
| let ptr39: ptr<storage, i32, read> = &buffer27[unconst_u32(372)][unconst_u32(37)][unconst_u32(125)][unconst_u32(102)]; |
| let ptr40: ptr<storage, i32, read> = &(*ptr36)[unconst_u32(93)]; |
| return out; |
| _ = buffer27; |
| } |
| |
| /* used global variables: st4 */ |
| @fragment |
| fn fragment4() -> FragmentOutput4 { |
| var out: FragmentOutput4; |
| vp8 -= mat3x4f(bitcast<f32>(textureDimensions(st4)), bitcast<f32>(textureDimensions(st4)), bitcast<f32>(textureDimensions(st4)), f32(textureDimensions(st4)), f32(textureDimensions(st4)), f32(textureDimensions(st4)), f32(textureDimensions(st4)), bitcast<f32>(textureDimensions(st4)), bitcast<f32>(textureDimensions(st4)), bitcast<f32>(textureDimensions(st4)), f32(textureDimensions(st4)), bitcast<f32>(textureDimensions(st4))); |
| var vf82: vec2f = quantizeToF16(vec2f(unconst_f32(0.05966), unconst_f32(0.07439))); |
| let vf83: vec3h = -vec3h(unconst_f16(30128.8), unconst_f16(4335.3), unconst_f16(-47587.8)); |
| var vf84: vec3<bool> = (vec3<bool>(unconst_bool(false), unconst_bool(false), unconst_bool(false)) == vec3<bool>(unconst_bool(true), unconst_bool(false), unconst_bool(true))); |
| var vf85: bool = (unconst_bool(false) && unconst_bool(true)); |
| loop { |
| let ptr41: ptr<private, bool> = &vp10[unconst_u32(102)]; |
| out.f1 = vec4f((vec4h(unconst_f16(2942.8), unconst_f16(8496.0), unconst_f16(29266.0), unconst_f16(7458.1)) <= vec4h(unconst_f16(857.9), unconst_f16(18223.3), unconst_f16(1996.0), unconst_f16(24212.4)))); |
| vp8 = mat3x4f(vec4f(unpack4xI8(unconst_u32(302))), vec4f(unpack4xI8(unconst_u32(302))), vec4f(unpack4xI8(unconst_u32(302)))); |
| break; |
| } |
| let ptr42: ptr<function, vec2f> = &vf82; |
| var vf86: f32 = vp7.f3[unconst_u32(132)]; |
| vp7 = VertexOutput3(mix(vec3f(unconst_f32(0.1117), unconst_f32(0.2858), unconst_f32(0.01980)), vec3f(unconst_f32(0.1881), unconst_f32(0.1059), unconst_f32(0.1839)), unconst_f32(0.1015)).zyzy, mix(vec3f(unconst_f32(0.1117), unconst_f32(0.2858), unconst_f32(0.01980)), vec3f(unconst_f32(0.1881), unconst_f32(0.1059), unconst_f32(0.1839)), unconst_f32(0.1015)).zy); |
| let vf87: vec3h = acosh(vec3h(f16((bool(vp9.f4[unconst_u32(462)]) && bool((unconst_u32(209) >> unconst_u32(214))))))); |
| let vf88: f16 = length(vec2h(unconst_f16(858.8), unconst_f16(5426.9))); |
| let vf89: vec3<bool> = (vec3<bool>(unconst_bool(false), unconst_bool(false), unconst_bool(true)) == vec3<bool>(unconst_bool(false), unconst_bool(true), unconst_bool(false))); |
| let vf90: vec2f = quantizeToF16(vec2f(f32(vp10[bitcast<u32>((vec2i(i32(tan(unconst_f16(45892.6)))) / vec2i(unconst_i32(92), unconst_i32(-110))).y)]))); |
| let vf91: vec3h = vf83; |
| return out; |
| _ = st4; |
| }`, |
| }); |
| let pipelineLayout4 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout6]}); |
| let texture25 = device0.createTexture({ |
| size: [80, 90, 1], |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture26 = device0.createTexture({ |
| size: {width: 40, height: 45, depthOrArrayLayers: 1}, |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_SRC, |
| }); |
| try { |
| computePassEncoder1.setBindGroup(0, bindGroup3); |
| } catch {} |
| try { |
| computePassEncoder15.setPipeline(pipeline1); |
| } catch {} |
| try { |
| computePassEncoder14.setPipeline(pipeline1); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| } catch {} |
| let pipeline5 = device0.createRenderPipeline({ |
| layout: pipelineLayout2, |
| fragment: {module: shaderModule0, constants: {}, targets: [{format: 'rg8unorm', writeMask: GPUColorWrite.ALPHA}]}, |
| vertex: { |
| module: shaderModule0, |
| buffers: [ |
| { |
| arrayStride: 512, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'uint16x4', offset: 60, shaderLocation: 13}, |
| {format: 'uint8x2', offset: 0, shaderLocation: 0}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-list', frontFace: 'cw', cullMode: 'back', unclippedDepth: true}, |
| }); |
| let bindGroup10 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout2, |
| entries: [{binding: 39, resource: {buffer: buffer12, offset: 7168}}, {binding: 41, resource: textureView8}], |
| }); |
| let texture27 = device0.createTexture({ |
| size: {width: 153, height: 3, depthOrArrayLayers: 1}, |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView33 = texture18.createView({}); |
| try { |
| computePassEncoder21.setPipeline(pipeline3); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture21, |
| mipLevel: 0, |
| origin: {x: 37, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(3).fill(31), /* required buffer size: 3 */ |
| {offset: 3, bytesPerRow: 55}, {width: 1, height: 17, depthOrArrayLayers: 0}); |
| } catch {} |
| let promise2 = device0.queue.onSubmittedWorkDone(); |
| let bindGroup11 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout2, |
| entries: [ |
| {binding: 39, resource: {buffer: buffer16, offset: 256, size: 604}}, |
| {binding: 41, resource: textureView28}, |
| ], |
| }); |
| let pipelineLayout5 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout2]}); |
| let textureView34 = texture25.createView({mipLevelCount: 1}); |
| let texture28 = device0.createTexture({ |
| size: [153], |
| dimension: '1d', |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView35 = texture7.createView({}); |
| try { |
| computePassEncoder1.setPipeline(pipeline3); |
| } catch {} |
| try { |
| computePassEncoder20.insertDebugMarker('\u6723'); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| document.body.append(img0); |
| let videoFrame0 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-ncl', primaries: 'bt470m', transfer: 'iec6196624'} }); |
| let texture29 = device0.createTexture({ |
| size: [20, 22, 39], |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture30 = device0.createTexture({ |
| size: [20], |
| dimension: '1d', |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| viewFormats: [], |
| }); |
| let textureView36 = texture6.createView({mipLevelCount: 1}); |
| try { |
| computePassEncoder14.setBindGroup(1, bindGroup5); |
| } catch {} |
| try { |
| computePassEncoder20.setBindGroup(1, bindGroup8, new Uint32Array(9), 2, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder1); computePassEncoder1.dispatchWorkgroupsIndirect(buffer14, 2_188); }; |
| } catch {} |
| try { |
| buffer13.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| } catch {} |
| let imageData6 = new ImageData(32, 8); |
| let recycledExplicitBindGroupLayout1 = pipeline3.getBindGroupLayout(0); |
| let textureView37 = texture24.createView({}); |
| let textureView38 = texture15.createView({dimension: '1d'}); |
| try { |
| computePassEncoder11.pushDebugGroup('\ufd36'); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 123, height: 1, depthOrArrayLayers: 153} |
| */ |
| { |
| source: imageData1, |
| origin: { x: 8, y: 1 }, |
| flipY: false, |
| }, { |
| texture: texture6, |
| mipLevel: 1, |
| origin: {x: 36, y: 0, z: 3}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let videoFrame1 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420', timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte240m', primaries: 'smpte170m', transfer: 'smpteSt4281'} }); |
| let textureView39 = texture27.createView({}); |
| try { |
| computePassEncoder11.setBindGroup(0, bindGroup2); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder11); computePassEncoder11.dispatchWorkgroupsIndirect(buffer22, 32); }; |
| } catch {} |
| try { |
| computePassEncoder3.setPipeline(pipeline1); |
| } catch {} |
| let offscreenCanvas1 = new OffscreenCanvas(10, 63); |
| let bindGroup12 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [{binding: 144, resource: textureView5}, {binding: 323, resource: {buffer: buffer12, offset: 0}}], |
| }); |
| let commandEncoder22 = device0.createCommandEncoder({}); |
| let textureView40 = texture24.createView({baseMipLevel: 0}); |
| let textureView41 = texture13.createView({arrayLayerCount: 8}); |
| let pipelineLayout6 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout6]}); |
| let buffer28 = device0.createBuffer({size: 13233, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ, mappedAtCreation: false}); |
| let commandEncoder23 = device0.createCommandEncoder({}); |
| let texture31 = device0.createTexture({ |
| size: {width: 153}, |
| dimension: '1d', |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder12.setPipeline(pipeline3); |
| } catch {} |
| try { |
| buffer18.unmap(); |
| } catch {} |
| try { |
| commandEncoder23.clearBuffer(buffer24, 8, 24); |
| } catch {} |
| let commandEncoder24 = device0.createCommandEncoder({}); |
| let querySet1 = device0.createQuerySet({type: 'occlusion', count: 442}); |
| let renderPassEncoder0 = commandEncoder23.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView36, |
| depthSlice: 17, |
| clearValue: { r: -888.1, g: -775.2, b: -587.4, a: -48.25, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet1, |
| }); |
| try { |
| computePassEncoder0.setBindGroup(1, bindGroup3); |
| } catch {} |
| try { |
| computePassEncoder1.setBindGroup(2, bindGroup11, new Uint32Array(2600), 272, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer1, 'uint32', 3_488, 800); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(6, buffer2, 0); |
| } catch {} |
| try { |
| commandEncoder24.copyBufferToBuffer(buffer20, 1956, buffer24, 28, 108); |
| } catch {} |
| let buffer29 = device0.createBuffer({size: 6777, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM}); |
| let commandEncoder25 = device0.createCommandEncoder({}); |
| let renderPassEncoder1 = commandEncoder25.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView36, |
| depthSlice: 41, |
| clearValue: { r: -664.3, g: -119.6, b: -206.6, a: -997.3, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| computePassEncoder18.setBindGroup(0, bindGroup11); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(3, bindGroup1, new Uint32Array(63), 5, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(2, buffer14, 1_348, 812); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture14, |
| mipLevel: 0, |
| origin: {x: 172, y: 0, z: 12}, |
| aspect: 'all', |
| }, new Uint8Array(4_827).fill(249), /* required buffer size: 4_827 */ |
| {offset: 71, bytesPerRow: 116, rowsPerImage: 41}, {width: 23, height: 0, depthOrArrayLayers: 2}); |
| } catch {} |
| let buffer30 = device0.createBuffer({size: 849, usage: GPUBufferUsage.MAP_WRITE}); |
| let commandEncoder26 = device0.createCommandEncoder({}); |
| let texture32 = device0.createTexture({ |
| size: [3760], |
| dimension: '1d', |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder22 = commandEncoder24.beginComputePass(); |
| let sampler19 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMaxClamp: 96.85, |
| compare: 'less', |
| }); |
| try { |
| computePassEncoder15.setBindGroup(0, bindGroup1); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(0, bindGroup2); |
| } catch {} |
| try { |
| renderPassEncoder0.executeBundles([renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer22, 'uint32', 24, 113); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let commandEncoder27 = device0.createCommandEncoder({}); |
| let texture33 = gpuCanvasContext0.getCurrentTexture(); |
| let computePassEncoder23 = commandEncoder27.beginComputePass({}); |
| let renderPassEncoder2 = commandEncoder26.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView36, |
| depthSlice: 207, |
| clearValue: { r: -70.14, g: 668.7, b: -994.3, a: -130.0, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet0, |
| }); |
| try { |
| computePassEncoder23.setBindGroup(2, bindGroup11, new Uint32Array(1997), 98, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(0, bindGroup4); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture32, |
| mipLevel: 0, |
| origin: {x: 280, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(95).fill(240), /* required buffer size: 95 */ |
| {offset: 95}, {width: 568, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let computePassEncoder24 = commandEncoder22.beginComputePass({}); |
| try { |
| computePassEncoder24.setBindGroup(3, bindGroup5); |
| } catch {} |
| try { |
| computePassEncoder12.setBindGroup(0, bindGroup9, new Uint32Array(239), 51, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder1); computePassEncoder1.dispatchWorkgroupsIndirect(buffer20, 6_640); }; |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(2, bindGroup11, new Uint32Array(117), 42, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.executeBundles([renderBundle0]); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer0, 24, new Float32Array(10533), 2779, 156); |
| } catch {} |
| let commandEncoder28 = device0.createCommandEncoder({}); |
| let texture34 = device0.createTexture({ |
| size: {width: 307, height: 7, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| sampleCount: 1, |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderPassEncoder3 = commandEncoder28.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView36, |
| depthSlice: 264, |
| clearValue: { r: 205.2, g: 221.6, b: 163.9, a: 54.07, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| maxDrawCount: 760797, |
| }); |
| try { |
| renderPassEncoder1.setBindGroup(1, bindGroup9, new Uint32Array(2448), 29, 0); |
| } catch {} |
| let buffer31 = device0.createBuffer({size: 3356, usage: GPUBufferUsage.INDIRECT}); |
| let sampler20 = device0.createSampler({addressModeV: 'repeat', minFilter: 'nearest'}); |
| try { |
| computePassEncoder13.setBindGroup(0, bindGroup8); |
| } catch {} |
| try { |
| computePassEncoder15.setBindGroup(3, bindGroup5, new Uint32Array(1335), 36, 0); |
| } catch {} |
| try { |
| computePassEncoder23.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(2, bindGroup11); |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer24, 'uint16', 84, 61); |
| } catch {} |
| try { |
| renderPassEncoder2.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(4, buffer1, 0); |
| } catch {} |
| let imageData7 = new ImageData(32, 32); |
| let autogeneratedBindGroupLayout0 = pipeline4.getBindGroupLayout(0); |
| let textureView42 = texture25.createView({aspect: 'all'}); |
| let texture35 = device0.createTexture({size: [40], dimension: '1d', format: 'rg8unorm', usage: GPUTextureUsage.TEXTURE_BINDING}); |
| let externalTexture0 = device0.importExternalTexture({source: videoFrame1}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder15); computePassEncoder15.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder1.setViewport(137.98719807818688, 0.2474324897073923, 62.91178043480473, 0.42233059870196976, 0.39115170891367546, 0.617714441671543); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(2, buffer14, 8_700, 2_832); |
| } catch {} |
| try { |
| computePassEncoder22.setPipeline(pipeline3); |
| } catch {} |
| try { |
| buffer13.unmap(); |
| } catch {} |
| let buffer32 = device0.createBuffer({ |
| size: 14445, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let texture36 = device0.createTexture({ |
| size: {width: 984, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 3, |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| computePassEncoder24.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder1.executeBundles([renderBundle1, renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(3, buffer21, 5_844); |
| } catch {} |
| try { |
| computePassEncoder13.setBindGroup(0, bindGroup2, new Uint32Array(6232), 1_916, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(2, bindGroup1); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer2, 'uint32', 88, 291); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| let commandEncoder29 = device0.createCommandEncoder({}); |
| let texture37 = device0.createTexture({ |
| size: [615, 15, 1], |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder25 = commandEncoder29.beginComputePass({}); |
| try { |
| computePassEncoder25.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(0, bindGroup12); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(1, bindGroup4, new Uint32Array(1435), 453, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer14, 'uint32', 6_184, 11_670); |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let texture38 = device0.createTexture({ |
| size: [615, 15, 140], |
| mipLevelCount: 4, |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_SRC, |
| }); |
| let sampler21 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 97.95, |
| compare: 'greater', |
| maxAnisotropy: 13, |
| }); |
| try { |
| renderPassEncoder3.setBindGroup(1, bindGroup5); |
| } catch {} |
| try { |
| renderPassEncoder3.setScissorRect(8, 0, 59, 0); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55); }; |
| } catch {} |
| await gc(); |
| let sampler22 = device0.createSampler({addressModeV: 'mirror-repeat', compare: 'greater-equal'}); |
| try { |
| renderPassEncoder0.executeBundles([renderBundle2, renderBundle1, renderBundle2, renderBundle2]); |
| } catch {} |
| try { |
| await gc(); |
| buffer9.destroy(); |
| await gc(); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| await promise2; |
| } catch {} |
| let img1 = await imageWithData(45, 7, '#10101010', '#20202020'); |
| let commandEncoder30 = device0.createCommandEncoder(); |
| let texture39 = device0.createTexture({ |
| size: {width: 246, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler23 = device0.createSampler({lodMaxClamp: 96.98, compare: 'never'}); |
| try { |
| computePassEncoder15.setBindGroup(0, bindGroup1, new Uint32Array(388), 57, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(2, bindGroup4, new Uint32Array(3879), 702, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.setViewport(110.56935899706683, 0.8348473471649053, 45.30448687541059, 0.11561609407429727, 0.3388181383471299, 0.5345513268054743); |
| } catch {} |
| let promise3 = device0.queue.onSubmittedWorkDone(); |
| let videoFrame2 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-ncl', primaries: 'smpteRp431', transfer: 'smpteSt4281'} }); |
| let veryExplicitBindGroupLayout7 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 9, |
| visibility: GPUShaderStage.COMPUTE, |
| texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| ], |
| }); |
| let buffer33 = device0.createBuffer({ |
| size: 3903, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let querySet2 = device0.createQuerySet({type: 'occlusion', count: 172}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder15); computePassEncoder15.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer22, 'uint16', 470, 269); |
| } catch {} |
| let arrayBuffer1 = buffer4.getMappedRange(8, 8); |
| try { |
| computePassEncoder11.popDebugGroup(); |
| } catch {} |
| let textureView43 = texture30.createView({}); |
| let renderPassEncoder4 = commandEncoder30.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView36, |
| depthSlice: 165, |
| clearValue: { r: 117.6, g: 190.3, b: 487.0, a: 866.2, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| computePassEncoder10.setBindGroup(0, bindGroup2, []); |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer18, 'uint32', 316, 69); |
| } catch {} |
| let pipeline6 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule3, entryPoint: 'compute3'}}); |
| let texture40 = device0.createTexture({ |
| size: [10, 11, 1], |
| sampleCount: 4, |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView44 = texture40.createView({}); |
| try { |
| renderPassEncoder4.setVertexBuffer(1, buffer5, 716, 2_163); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55); }; |
| } catch {} |
| try { |
| computePassEncoder1.setBindGroup(0, bindGroup1, []); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder3); computePassEncoder3.dispatchWorkgroupsIndirect(buffer1, 772); }; |
| } catch {} |
| let pipeline7 = await device0.createRenderPipelineAsync({ |
| layout: pipelineLayout2, |
| fragment: { |
| module: shaderModule0, |
| entryPoint: 'fragment0', |
| targets: [{ |
| format: 'rg8unorm', |
| blend: { |
| color: {operation: 'add', srcFactor: 'constant', dstFactor: 'zero'}, |
| alpha: {operation: 'subtract', srcFactor: 'one-minus-dst', dstFactor: 'zero'}, |
| }, |
| writeMask: 0, |
| }], |
| }, |
| vertex: { |
| module: shaderModule2, |
| entryPoint: 'vertex1', |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 124, |
| stepMode: 'instance', |
| attributes: [{format: 'float32x2', offset: 16, shaderLocation: 0}], |
| }, |
| ], |
| }, |
| }); |
| let bindGroup13 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 41, resource: textureView28}, |
| {binding: 39, resource: {buffer: buffer16, offset: 512, size: 716}}, |
| ], |
| }); |
| let texture41 = device0.createTexture({ |
| size: {width: 1230, height: 30, depthOrArrayLayers: 41}, |
| mipLevelCount: 1, |
| dimension: '3d', |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture42 = device0.createTexture({ |
| size: {width: 246, height: 1, depthOrArrayLayers: 42}, |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let textureView45 = texture20.createView({dimension: '2d-array', arrayLayerCount: 1}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder10); computePassEncoder10.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| renderPassEncoder4.setPipeline(pipeline2); |
| } catch {} |
| let commandEncoder31 = device0.createCommandEncoder({label: '\u3aa5\u{1fee6}\u0b39\u0963\uc411'}); |
| let texture43 = device0.createTexture({ |
| size: {width: 307, height: 7, depthOrArrayLayers: 22}, |
| mipLevelCount: 3, |
| dimension: '3d', |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| renderPassEncoder3.setBindGroup(0, bindGroup8); |
| } catch {} |
| try { |
| renderPassEncoder3.end(); |
| } catch {} |
| try { |
| renderPassEncoder2.setScissorRect(58, 0, 17, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer18, 'uint32', 508, 131); |
| } catch {} |
| try { |
| commandEncoder31.copyBufferToTexture({ |
| /* bytesInLastRow: 22 widthInBlocks: 11 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 1456 */ |
| offset: 1456, |
| bytesPerRow: 65280, |
| buffer: buffer26, |
| }, { |
| texture: texture42, |
| mipLevel: 0, |
| origin: {x: 18, y: 0, z: 2}, |
| aspect: 'all', |
| }, {width: 11, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let textureView46 = texture36.createView({dimension: '2d', mipLevelCount: 1}); |
| let computePassEncoder26 = commandEncoder28.beginComputePass(); |
| let sampler24 = device0.createSampler({addressModeV: 'repeat', mipmapFilter: 'nearest', maxAnisotropy: 1}); |
| try { |
| renderPassEncoder2.setViewport(12.859589232338454, 0.02642375300329103, 87.98263855924348, 0.1455144423072313, 0.3335643426348581, 0.9904383824052189); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer12, 1604, new BigUint64Array(877)); |
| } catch {} |
| let promise4 = device0.queue.onSubmittedWorkDone(); |
| let gpuCanvasContext1 = offscreenCanvas1.getContext('webgpu'); |
| let commandEncoder32 = device0.createCommandEncoder(); |
| let texture44 = device0.createTexture({ |
| size: {width: 470, height: 2, depthOrArrayLayers: 6}, |
| dimension: '3d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderPassEncoder5 = commandEncoder31.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView46, |
| clearValue: { r: -801.3, g: 609.6, b: 201.1, a: -831.6, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| renderPassEncoder2.setBlendConstant({ r: -445.5, g: 675.7, b: -79.01, a: -367.2, }); |
| } catch {} |
| try { |
| renderPassEncoder2.setPipeline(pipeline2); |
| } catch {} |
| try { |
| commandEncoder32.copyBufferToBuffer(buffer32, 2036, buffer19, 2288, 508); |
| } catch {} |
| try { |
| commandEncoder32.resolveQuerySet(querySet0, 145, 38, buffer12, 9472); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| let shaderModule5 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| requires unrestricted_pointer_parameters; |
| |
| diagnostic(info, xyz); |
| |
| @group(0) @binding(144) var st5: texture_storage_1d<r32uint, read_write>; |
| |
| struct T0 { |
| @size(288) f0: vec2i, |
| @align(32) @size(32) f1: atomic<u32>, |
| @align(32) @size(544) f2: array<array<array<mat2x2h, 1>, 1>>, |
| } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| struct T2 { |
| @align(32) @size(384) f0: mat4x4f, |
| @align(32) @size(32) f1: mat4x2h, |
| @size(448) f2: array<u32>, |
| } |
| |
| var<private> vp11: S2 = S2(); |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| struct S0 { |
| @location(7) @interpolate(perspective, first) f0: vec2h, |
| @location(10) f1: f16, |
| @location(12) @interpolate(flat, center) f2: vec4u, |
| @location(0) f3: i32, |
| @builtin(vertex_index) f4: u32, |
| @location(5) f5: vec2i, |
| @location(2) @interpolate(flat) f6: vec2u, |
| @location(9) f7: vec4f, |
| } |
| |
| @group(0) @binding(323) var<storage, read> buffer34: array<VertexOutput5, 54>; |
| |
| struct VertexOutput5 { |
| @invariant @builtin(position) f6: vec4f, |
| } |
| |
| struct FragmentOutput5 { |
| @location(0) @interpolate(linear) f0: vec4f, |
| @location(6) f1: vec2f, |
| } |
| |
| struct S3 { |
| @location(11) @interpolate(flat, centroid) f0: vec4i, |
| } |
| |
| var<workgroup> vw26: f32; |
| |
| var<workgroup> vw27: atomic<i32>; |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| struct S4 { |
| @builtin(sample_mask) f0: u32, |
| } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| struct S1 { |
| @location(14) f0: vec4h, |
| @location(1) f1: vec4h, |
| @location(8) @interpolate(perspective) f2: vec4f, |
| @location(3) @interpolate(flat, first) f3: vec2i, |
| } |
| |
| struct T1 { |
| @size(864) f0: array<mat2x4h>, |
| } |
| |
| struct VertexOutput4 { |
| @invariant @builtin(position) f5: vec4f, |
| } |
| |
| var<workgroup> vw25: S2; |
| |
| struct S2 { |
| @location(15) f0: f16, |
| } |
| |
| /* used global variables: buffer34 */ |
| @vertex |
| fn vertex4(@location(13) @interpolate(linear, center) a0: f32, @builtin(instance_index) a1: u32, a2: S0, a3: S1, @location(4) a4: vec2f, @location(6) a5: f16, a6: S2, a7: S3) -> VertexOutput4 { |
| var out: VertexOutput4; |
| out = VertexOutput4(unpack4x8snorm(a2.f6[unconst_u32(131)])); |
| let ptr43: ptr<storage, VertexOutput5, read> = &(*&buffer34)[53]; |
| let ptr44: ptr<storage, VertexOutput5, read> = &(*ptr43); |
| let vf92: vec4h = a3.f1; |
| let ptr45: ptr<storage, VertexOutput5, read> = &buffer34[unconst_u32(6)]; |
| out = VertexOutput4(bitcast<vec4f>(a2.f6.yyyy)); |
| out.f5 -= vec4f((*ptr43).f6[unconst_u32(60)]); |
| { |
| out.f5 *= vec4f(a2.f0.gggg); |
| vp11.f0 = vec4h(unpack4x8unorm(unconst_u32(9)))[0]; |
| for (var it3=bitcast<u32>(a2.f0); it3<a2.f4; it3++) { |
| let vf93: u32 = dot4U8Packed(unconst_u32(65), unconst_u32(208)); |
| var vf94: u32 = a1; |
| let vf95: vec2h = a2.f0; |
| break; |
| } |
| var vf96: vec4f = a2.f7; |
| vf96 = vec4f(a0); |
| let vf97: f16 = a2.f1; |
| out = VertexOutput4(vec4f(f32(vp11.f0))); |
| } |
| out = VertexOutput4((*&buffer34)[u32(a2.f3)].f6); |
| let vf98: vec4h = tan(vec4h(unconst_f16(7402.7), unconst_f16(-15738.9), unconst_f16(8561.4), unconst_f16(707.1))); |
| var vf99: f32 = (*ptr43).f6[unconst_u32(7)]; |
| let vf100: vec2h = a2.f0; |
| var vf101: vec2u = a2.f6; |
| return out; |
| _ = buffer34; |
| } |
| |
| /* used global variables: buffer34 */ |
| @vertex |
| fn vertex5() -> VertexOutput5 { |
| var out: VertexOutput5; |
| let ptr46: ptr<private, f16> = &vp11.f0; |
| out.f6 = buffer34[53].f6; |
| let ptr47: ptr<storage, vec4f, read> = &buffer34[unconst_u32(872)].f6; |
| let ptr48: ptr<storage, vec4f, read> = &(*&buffer34)[unconst_u32(52)].f6; |
| out = buffer34[unconst_u32(108)]; |
| out = VertexOutput5(faceForward(vec2f(unconst_f32(0.09349), unconst_f32(0.1547)), vec2f(f32((*ptr46))), vec2f(unconst_f32(-0.1480), unconst_f32(0.1702))).gggr); |
| out.f6 = vec4f((*ptr48)[pack4xU8(vec4u((vec4u(unconst_u32(38), unconst_u32(33), unconst_u32(72), unconst_u32(328)) > vec4u(unconst_u32(153), unconst_u32(373), unconst_u32(1000), unconst_u32(294)))))]); |
| var vf102: vec3f = fma(vec3f(unconst_f32(0.1452), unconst_f32(0.1724), unconst_f32(0.2533)), vec3f(unconst_f32(0.1083), unconst_f32(0.3187), unconst_f32(0.00035)), vec3f(unconst_f32(0.2419), unconst_f32(-0.1092), unconst_f32(0.1509))); |
| var vf103: vec3f = normalize(unpack2x16float(unconst_u32(543)).rgr); |
| var vf104: vec4h = (vec4h(unconst_f16(2311.9), unconst_f16(22588.5), unconst_f16(-3080.6), unconst_f16(2483.1)) * unconst_f16(2536.9)); |
| let ptr49: ptr<storage, vec4f, read> = &(*&buffer34)[53].f6; |
| vf103 = (*ptr49).rrb; |
| return out; |
| _ = buffer34; |
| } |
| |
| /* used global variables: st5 */ |
| @fragment |
| fn fragment5(@location(1) @interpolate(perspective, either) a0: vec2f, @builtin(front_facing) a1: bool, @builtin(sample_index) a2: u32, @invariant @builtin(position) a3: vec4f, a4: S4) -> FragmentOutput5 { |
| var out: FragmentOutput5; |
| textureStore(st5, (vec4i(unconst_i32(110), unconst_i32(182), unconst_i32(211), unconst_i32(278)) >> vec4u(unconst_u32(26), unconst_u32(160), unconst_u32(835), unconst_u32(137)))[0], vec4u(unpack4xU8(u32((bool((vec4i(unconst_i32(63), unconst_i32(28), unconst_i32(89), unconst_i32(74)) >> vec4u(unconst_u32(119), unconst_u32(38), unconst_u32(816), unconst_u32(184))).y) || unconst_bool(true)))))); |
| var vf105: vec4h = reflect(vec4h(unconst_f16(1390.8), unconst_f16(12449.6), unconst_f16(-25190.0), unconst_f16(13656.6)), vec4h(unconst_f16(5524.6), unconst_f16(2519.5), unconst_f16(4418.9), unconst_f16(4909.4))); |
| var vf106: vec4<bool> = (vec4u(a4.f0) >= vec4u(exp(vec4h(unconst_f16(13833.1), unconst_f16(23958.7), unconst_f16(11827.5), unconst_f16(24011.7))))); |
| return out; |
| _ = st5; |
| } |
| |
| /* used global variables: st5 */ |
| @compute @workgroup_size(1, 1, 1) |
| fn compute4() { |
| var vf107: vec4i = extractBits(vec4i(unconst_i32(141), unconst_i32(17), unconst_i32(166), unconst_i32(19)), bitcast<u32>(atomicLoad(&vw27)), unconst_u32(90)); |
| var vf108: f32 = workgroupUniformLoad(&vw26); |
| let ptr50: ptr<private, f16> = &vp11.f0; |
| vw25 = S2(f16(length(unconst_f32(0.00609)))); |
| let ptr51: ptr<function, f32> = &vf108; |
| let vf109: vec2u = (vec2u(unconst_u32(9), unconst_u32(24)) << vec2u(unconst_u32(11), unconst_u32(233))); |
| var vf110: u32 = textureDimensions(st5); |
| switch atomicLoad(&(*&vw27)) { |
| default { |
| let vf111: vec3h = fma(vec3h(unconst_f16(17271.6), unconst_f16(5564.3), unconst_f16(3376.9)), vec3h(unconst_f16(3980.1), unconst_f16(27549.0), unconst_f16(7676.0)), vec3h(unconst_f16(3072.0), unconst_f16(5840.0), unconst_f16(8524.8))); |
| let vf112: vec3h = fma(vec3h(unconst_f16(3071.7), unconst_f16(-8731.3), unconst_f16(-3095.8)), vec3h(unconst_f16(1562.8), unconst_f16(19654.8), unconst_f16(1346.4)), vec3h(unconst_f16(-9478.1), unconst_f16(40098.8), unconst_f16(10210.2))); |
| textureStore(st5, unconst_i32(66), vec4u(vec4u(unconst_u32(45), unconst_u32(92), unconst_u32(49), unconst_u32(43)))); |
| _ = st5; |
| } |
| } |
| vf108 = bitcast<f32>(vf109[1]); |
| let ptr52: ptr<function, f32> = &(*ptr51); |
| var vf113: i32 = atomicExchange(&vw27, unconst_i32(51)); |
| vw25.f0 *= vw25.f0; |
| let vf114: u32 = pack4xU8(vec4u(unconst_u32(186), unconst_u32(180), unconst_u32(60), unconst_u32(100))); |
| let ptr53: ptr<function, f32> = &(*ptr51); |
| _ = st5; |
| } |
| |
| /* used global variables: st5 */ |
| @compute @workgroup_size(1, 1, 1) |
| fn compute5() { |
| let ptr54: ptr<workgroup, S2> = &(*&vw25); |
| vw25.f0 -= (*ptr54).f0; |
| { |
| textureStore(st5, unconst_i32(450), vec4u(vec4u(unconst_u32(325), unconst_u32(62), unconst_u32(36), unconst_u32(264)))); |
| _ = st5; |
| } |
| _ = st5; |
| }`, |
| }); |
| try { |
| computePassEncoder3.end(); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(0, bindGroup2, new Uint32Array(10000), 844, 0); |
| } catch {} |
| let arrayBuffer2 = buffer4.getMappedRange(16, 24); |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 123, height: 1, depthOrArrayLayers: 153} |
| */ |
| { |
| source: offscreenCanvas0, |
| origin: { x: 9, y: 288 }, |
| flipY: false, |
| }, { |
| texture: texture6, |
| mipLevel: 1, |
| origin: {x: 2, y: 0, z: 4}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 4, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer35 = device0.createBuffer({size: 11440, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder15); computePassEncoder15.dispatchWorkgroupsIndirect(buffer31, 108); }; |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(0, bindGroup13); |
| } catch {} |
| try { |
| commandEncoder32.resolveQuerySet(querySet1, 240, 18, buffer12, 11520); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| try { |
| await promise3; |
| } catch {} |
| let textureView47 = texture18.createView({}); |
| let texture45 = device0.createTexture({ |
| size: {width: 470, height: 2, depthOrArrayLayers: 1}, |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let computePassEncoder27 = commandEncoder32.beginComputePass({}); |
| let renderBundleEncoder4 = device0.createRenderBundleEncoder({colorFormats: ['rg8unorm'], depthReadOnly: true}); |
| try { |
| computePassEncoder13.setBindGroup(0, bindGroup3, new Uint32Array(927), 10, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.executeBundles([renderBundle1, renderBundle2]); |
| } catch {} |
| try { |
| commandEncoder6.copyBufferToTexture({ |
| /* bytesInLastRow: 52 widthInBlocks: 13 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 772 */ |
| offset: 772, |
| bytesPerRow: 5120, |
| buffer: buffer26, |
| }, { |
| texture: texture1, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 13, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await promise4; |
| } catch {} |
| let bindGroup14 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout1, |
| entries: [{binding: 323, resource: {buffer: buffer10, offset: 256}}, {binding: 144, resource: textureView4}], |
| }); |
| let commandBuffer1 = commandEncoder6.finish(); |
| let texture46 = device0.createTexture({ |
| size: {width: 1880, height: 10, depthOrArrayLayers: 1}, |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder22.setBindGroup(0, bindGroup8, new Uint32Array(365), 22, 0); |
| } catch {} |
| try { |
| computePassEncoder27.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder2.beginOcclusionQuery(97); |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer19, 'uint16', 570, 5); |
| } catch {} |
| try { |
| renderPassEncoder2.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(4, buffer5); |
| } catch {} |
| try { |
| renderBundleEncoder4.setIndexBuffer(buffer2, 'uint32', 92, 248); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer1]); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture25, |
| mipLevel: 0, |
| origin: {x: 4, y: 17, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(98).fill(6), /* required buffer size: 98 */ |
| {offset: 98, bytesPerRow: 287, rowsPerImage: 60}, {width: 71, height: 6, depthOrArrayLayers: 0}); |
| } catch {} |
| let veryExplicitBindGroupLayout8 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 125, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '2d-array' }, |
| }, |
| { |
| binding: 166, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let texture47 = device0.createTexture({ |
| size: [80], |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderBundleEncoder5 = device0.createRenderBundleEncoder({colorFormats: ['rg8unorm']}); |
| try { |
| renderPassEncoder2.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer18, 'uint16', 170, 41); |
| } catch {} |
| try { |
| renderPassEncoder4.setVertexBuffer(1, buffer32); |
| } catch {} |
| try { |
| buffer8.unmap(); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let textureView48 = texture46.createView({arrayLayerCount: 1}); |
| let sampler25 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| minFilter: 'linear', |
| lodMaxClamp: 62.80, |
| }); |
| try { |
| computePassEncoder2.setBindGroup(0, bindGroup4); |
| } catch {} |
| try { |
| computePassEncoder26.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder5.setBindGroup(1, bindGroup8, new Uint32Array(22), 2, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.beginOcclusionQuery(203); |
| } catch {} |
| try { |
| renderBundleEncoder5.setBindGroup(1, bindGroup13); |
| } catch {} |
| let veryExplicitBindGroupLayout9 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 144, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '1d' }, |
| }, |
| { |
| binding: 323, |
| visibility: GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| try { |
| computePassEncoder11.setBindGroup(2, bindGroup6, new Uint32Array(409), 6, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(1, bindGroup5, []); |
| } catch {} |
| try { |
| renderPassEncoder1.executeBundles([renderBundle1, renderBundle2, renderBundle2, renderBundle1, renderBundle2, renderBundle2, renderBundle2]); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer1, 'uint16', 3_892, 1_031); |
| } catch {} |
| try { |
| renderPassEncoder0.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderBundleEncoder4.setBindGroup(2, bindGroup3); |
| } catch {} |
| try { |
| renderBundleEncoder4.setBindGroup(2, bindGroup6, new Uint32Array(748), 20, 0); |
| } catch {} |
| try { |
| renderBundleEncoder4.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderBundleEncoder5.setVertexBuffer(7, buffer24, 72, 11); |
| } catch {} |
| await gc(); |
| let commandEncoder33 = device0.createCommandEncoder({}); |
| let computePassEncoder28 = commandEncoder33.beginComputePass({}); |
| try { |
| computePassEncoder15.setBindGroup(1, bindGroup1, new Uint32Array(5012), 448, 0); |
| } catch {} |
| try { |
| computePassEncoder28.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(0, bindGroup3); |
| } catch {} |
| try { |
| renderBundleEncoder4.setVertexBuffer(3, buffer14, 1_612, 12_445); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer5, 3704, new DataView(new ArrayBuffer(19102)), 804, 2852); |
| } catch {} |
| let pipelineLayout7 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout5]}); |
| let buffer36 = device0.createBuffer({size: 7116, usage: GPUBufferUsage.MAP_WRITE}); |
| let renderBundle4 = renderBundleEncoder5.finish({}); |
| let sampler26 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| mipmapFilter: 'nearest', |
| lodMaxClamp: 66.55, |
| compare: 'greater', |
| }); |
| try { |
| renderPassEncoder2.setBindGroup(0, bindGroup4, new Uint32Array(939), 182, 0); |
| } catch {} |
| try { |
| renderBundleEncoder4.setBindGroup(1, bindGroup1); |
| } catch {} |
| try { |
| buffer13.unmap(); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let commandEncoder34 = device0.createCommandEncoder({}); |
| let texture48 = device0.createTexture({ |
| size: {width: 940, height: 5, depthOrArrayLayers: 1}, |
| mipLevelCount: 7, |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder29 = commandEncoder34.beginComputePass({}); |
| try { |
| computePassEncoder14.setBindGroup(3, bindGroup11); |
| } catch {} |
| try { |
| computePassEncoder10.setBindGroup(0, bindGroup8, new Uint32Array(2711), 155, 0); |
| } catch {} |
| try { |
| computePassEncoder29.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder4.executeBundles([renderBundle1, renderBundle2, renderBundle3]); |
| } catch {} |
| try { |
| renderPassEncoder5.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderBundleEncoder4.setBindGroup(0, bindGroup13, new Uint32Array(6851), 659, 0); |
| } catch {} |
| let arrayBuffer3 = buffer4.getMappedRange(40, 0); |
| let pipeline8 = device0.createRenderPipeline({ |
| layout: pipelineLayout1, |
| fragment: { |
| module: shaderModule2, |
| entryPoint: 'fragment2', |
| targets: [{ |
| format: 'rg8unorm', |
| blend: { |
| color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'}, |
| alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'}, |
| }, |
| }], |
| }, |
| vertex: {module: shaderModule5, entryPoint: 'vertex5', constants: {}, buffers: []}, |
| primitive: {topology: 'line-list', cullMode: 'back', unclippedDepth: true}, |
| }); |
| document.body.append(img0); |
| let commandEncoder35 = device0.createCommandEncoder({}); |
| let texture49 = device0.createTexture({ |
| size: [246, 1, 5], |
| mipLevelCount: 2, |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder30 = commandEncoder35.beginComputePass(); |
| try { |
| renderPassEncoder1.setBindGroup(1, bindGroup3); |
| } catch {} |
| try { |
| renderPassEncoder2.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder2.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderBundleEncoder4.setPipeline(pipeline5); |
| } catch {} |
| let img2 = await imageWithData(7, 16, '#10101010', '#20202020'); |
| let bindGroup15 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout6, |
| entries: [ |
| {binding: 68, resource: {buffer: buffer12, offset: 1280, size: 2096}}, |
| {binding: 45, resource: {buffer: buffer0, offset: 256, size: 748}}, |
| {binding: 97, resource: externalTexture0}, |
| {binding: 64, resource: {buffer: buffer19, offset: 2560, size: 360}}, |
| ], |
| }); |
| let buffer37 = device0.createBuffer({ |
| size: 11131, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder36 = device0.createCommandEncoder(); |
| let computePassEncoder31 = commandEncoder36.beginComputePass({}); |
| try { |
| computePassEncoder21.setBindGroup(0, bindGroup0, []); |
| } catch {} |
| try { |
| buffer2.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture30, |
| mipLevel: 0, |
| origin: {x: 13, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(52).fill(43), /* required buffer size: 52 */ |
| {offset: 52}, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer38 = device0.createBuffer({size: 421, usage: GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX}); |
| let textureView49 = texture25.createView({}); |
| let texture50 = device0.createTexture({ |
| size: [246], |
| dimension: '1d', |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView50 = texture13.createView({dimension: '2d', baseArrayLayer: 25}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder1); computePassEncoder1.dispatchWorkgroupsIndirect(buffer12, 1_028); }; |
| } catch {} |
| try { |
| computePassEncoder31.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder0.beginOcclusionQuery(75); |
| } catch {} |
| try { |
| renderPassEncoder0.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder4.executeBundles([renderBundle1]); |
| } catch {} |
| try { |
| renderBundleEncoder4.setPipeline(pipeline5); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer24, 20, new Float32Array(10768), 1326, 24); |
| } catch {} |
| let texture51 = gpuCanvasContext1.getCurrentTexture(); |
| let textureView51 = texture16.createView({dimension: '2d-array', aspect: 'all'}); |
| let renderBundle5 = renderBundleEncoder4.finish({}); |
| try { |
| computePassEncoder18.setBindGroup(0, bindGroup3); |
| } catch {} |
| try { |
| computePassEncoder9.setBindGroup(2, bindGroup6, new Uint32Array(383), 6, 0); |
| } catch {} |
| try { |
| computePassEncoder30.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder5.setBindGroup(0, bindGroup2, new Uint32Array(107), 41, 0); |
| } catch {} |
| let bindGroup16 = device0.createBindGroup({layout: veryExplicitBindGroupLayout7, entries: [{binding: 9, resource: textureView30}]}); |
| let buffer39 = device0.createBuffer({size: 4475, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let commandEncoder37 = device0.createCommandEncoder(); |
| let texture52 = device0.createTexture({ |
| size: {width: 1230}, |
| dimension: '1d', |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder24.setBindGroup(0, bindGroup2); |
| } catch {} |
| try { |
| computePassEncoder12.setBindGroup(0, bindGroup12, new Uint32Array(402), 20, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.setBindGroup(0, bindGroup4); |
| } catch {} |
| try { |
| renderPassEncoder2.beginOcclusionQuery(23); |
| } catch {} |
| let commandEncoder38 = device0.createCommandEncoder(); |
| let textureView52 = texture44.createView({mipLevelCount: 1}); |
| let textureView53 = texture8.createView({aspect: 'depth-only', baseMipLevel: 0, arrayLayerCount: 1}); |
| try { |
| computePassEncoder5.setBindGroup(2, bindGroup15); |
| } catch {} |
| let buffer40 = device0.createBuffer({size: 47796, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX}); |
| let commandEncoder39 = device0.createCommandEncoder({}); |
| let querySet3 = device0.createQuerySet({type: 'occlusion', count: 1098}); |
| let renderPassEncoder6 = commandEncoder37.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView46, |
| clearValue: { r: 323.7, g: -103.6, b: 550.7, a: 777.8, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| }); |
| let sampler27 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'repeat', addressModeW: 'repeat', magFilter: 'linear'}); |
| try { |
| computePassEncoder21.setBindGroup(0, bindGroup2, new Uint32Array(200), 62, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder15); computePassEncoder15.dispatchWorkgroupsIndirect(buffer33, 868); }; |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(2, bindGroup13, new Uint32Array(3385), 1_821, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer19, 'uint16', 758, 341); |
| } catch {} |
| try { |
| commandEncoder38.copyBufferToTexture({ |
| /* bytesInLastRow: 392 widthInBlocks: 49 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 2176 */ |
| offset: 2176, |
| buffer: buffer37, |
| }, { |
| texture: texture27, |
| mipLevel: 0, |
| origin: {x: 18, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 49, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder39.clearBuffer(buffer40); |
| } catch {} |
| let buffer41 = device0.createBuffer({size: 34651, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX}); |
| let commandEncoder40 = device0.createCommandEncoder({}); |
| let computePassEncoder32 = commandEncoder39.beginComputePass({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder22); computePassEncoder22.dispatchWorkgroups(2, 1); }; |
| } catch {} |
| try { |
| computePassEncoder32.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(0, bindGroup12); |
| } catch {} |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer8, 'uint16', 24, 247); |
| } catch {} |
| try { |
| renderPassEncoder5.setPipeline(pipeline5); |
| } catch {} |
| try { |
| commandEncoder40.copyBufferToTexture({ |
| /* bytesInLastRow: 420 widthInBlocks: 210 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 1650 */ |
| offset: 1650, |
| rowsPerImage: 14, |
| buffer: buffer21, |
| }, { |
| texture: texture32, |
| mipLevel: 0, |
| origin: {x: 1260, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 210, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder38.copyTextureToBuffer({ |
| texture: texture1, |
| mipLevel: 0, |
| origin: {x: 168, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 444 widthInBlocks: 111 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1260 */ |
| offset: 1260, |
| buffer: buffer19, |
| }, {width: 111, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline9 = await device0.createComputePipelineAsync({layout: pipelineLayout3, compute: {module: shaderModule2}}); |
| let textureView54 = texture40.createView({}); |
| let renderPassEncoder7 = commandEncoder38.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView46, |
| clearValue: { r: 395.9, g: 417.6, b: -619.1, a: 93.93, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder24); computePassEncoder24.dispatchWorkgroupsIndirect(buffer31, 1_956); }; |
| } catch {} |
| try { |
| renderPassEncoder5.setBindGroup(0, bindGroup12, new Uint32Array(4178), 369, 0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture12, |
| mipLevel: 0, |
| origin: {x: 44, y: 1, z: 20}, |
| aspect: 'all', |
| }, new Uint8Array(2_159).fill(181), /* required buffer size: 2_159 */ |
| {offset: 555, bytesPerRow: 64, rowsPerImage: 25}, {width: 2, height: 1, depthOrArrayLayers: 2}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 123, height: 1, depthOrArrayLayers: 153} |
| */ |
| { |
| source: videoFrame0, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture6, |
| mipLevel: 1, |
| origin: {x: 11, y: 0, z: 1}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let renderPassEncoder8 = commandEncoder40.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView46, |
| clearValue: { r: -262.4, g: 502.6, b: -818.1, a: -610.7, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| renderPassEncoder8.setBindGroup(0, bindGroup2, new Uint32Array(2246), 45, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.beginOcclusionQuery(86); |
| } catch {} |
| try { |
| renderPassEncoder7.setIndexBuffer(buffer22, 'uint32', 16, 298); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer0]); |
| } catch {} |
| let commandEncoder41 = device0.createCommandEncoder(); |
| let texture53 = device0.createTexture({ |
| size: {width: 246, height: 1, depthOrArrayLayers: 70}, |
| dimension: '3d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder33 = commandEncoder41.beginComputePass({}); |
| try { |
| computePassEncoder6.setBindGroup(0, bindGroup1, new Uint32Array(113), 56, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.end(); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(1, buffer5); |
| } catch {} |
| try { |
| commandEncoder30.copyBufferToTexture({ |
| /* bytesInLastRow: 324 widthInBlocks: 162 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 224 */ |
| offset: 224, |
| buffer: buffer35, |
| }, { |
| texture: texture15, |
| mipLevel: 0, |
| origin: {x: 42, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 162, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder42 = device0.createCommandEncoder({}); |
| let texture54 = device0.createTexture({ |
| size: {width: 307, height: 7, depthOrArrayLayers: 1}, |
| sampleCount: 1, |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView55 = texture49.createView({mipLevelCount: 1, baseArrayLayer: 1, arrayLayerCount: 1}); |
| try { |
| renderPassEncoder2.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder2.setScissorRect(37, 0, 15, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.setVertexBuffer(0, buffer13); |
| } catch {} |
| let promise5 = device0.queue.onSubmittedWorkDone(); |
| let buffer42 = device0.createBuffer({ |
| size: 6756, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder43 = device0.createCommandEncoder({}); |
| let texture55 = device0.createTexture({ |
| size: {width: 153}, |
| dimension: '1d', |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder34 = commandEncoder42.beginComputePass({}); |
| let renderPassEncoder9 = commandEncoder43.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView36, |
| depthSlice: 118, |
| clearValue: { r: -737.1, g: 723.4, b: -718.8, a: -188.8, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| maxDrawCount: 241943496, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder2); computePassEncoder2.dispatchWorkgroupsIndirect(buffer32, 6_312); }; |
| } catch {} |
| try { |
| computePassEncoder33.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderPassEncoder5.draw(317, 1, 131_187_321, 1); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexedIndirect(buffer1, 220); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer39, 340, new BigUint64Array(1351), 262, 28); |
| } catch {} |
| let buffer43 = device0.createBuffer({size: 414, usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX}); |
| let commandBuffer2 = commandEncoder30.finish(); |
| let texture56 = device0.createTexture({ |
| size: {width: 80, height: 90, depthOrArrayLayers: 14}, |
| mipLevelCount: 3, |
| dimension: '2d', |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| let renderBundleEncoder6 = device0.createRenderBundleEncoder({colorFormats: ['rg8unorm'], depthReadOnly: true, stencilReadOnly: false}); |
| let renderBundle6 = renderBundleEncoder6.finish({}); |
| let sampler28 = device0.createSampler({ |
| addressModeV: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| maxAnisotropy: 10, |
| }); |
| try { |
| computePassEncoder23.setBindGroup(1, bindGroup11, []); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexed(27, 0, 67, 37_461_592); |
| } catch {} |
| try { |
| await buffer26.mapAsync(GPUMapMode.WRITE, 32, 256); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer24, 24, new Float32Array(13834), 7178, 8); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture10, |
| mipLevel: 1, |
| origin: {x: 83, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(47).fill(59), /* required buffer size: 47 */ |
| {offset: 47, bytesPerRow: 57}, {width: 14, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder44 = device0.createCommandEncoder({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder12); computePassEncoder12.dispatchWorkgroups(1, 2); }; |
| } catch {} |
| try { |
| computePassEncoder34.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(2, bindGroup15, new Uint32Array(1432), 7, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.draw(253, 0, 321_980_350, 1); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexedIndirect(buffer22, 52); |
| } catch {} |
| try { |
| await shaderModule4.getCompilationInfo(); |
| } catch {} |
| try { |
| commandEncoder44.copyBufferToTexture({ |
| /* bytesInLastRow: 298 widthInBlocks: 149 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 5970 */ |
| offset: 5970, |
| buffer: buffer35, |
| }, { |
| texture: texture7, |
| mipLevel: 0, |
| origin: {x: 30, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 149, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let videoFrame3 = new VideoFrame(videoFrame1, {timestamp: 0}); |
| let texture57 = device0.createTexture({size: [940, 5, 1], format: 'rg8unorm', usage: GPUTextureUsage.RENDER_ATTACHMENT}); |
| let textureView56 = texture30.createView({}); |
| try { |
| computePassEncoder26.setBindGroup(1, bindGroup11); |
| } catch {} |
| try { |
| computePassEncoder11.end(); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndirect(buffer42, 704); |
| } catch {} |
| try { |
| renderPassEncoder9.setPipeline(pipeline7); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| await promise5; |
| } catch {} |
| let commandEncoder45 = device0.createCommandEncoder(); |
| let sampler29 = device0.createSampler({ |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| maxAnisotropy: 6, |
| }); |
| try { |
| renderPassEncoder2.setBindGroup(0, bindGroup12); |
| } catch {} |
| try { |
| renderPassEncoder5.draw(139, 1, 228_395_748, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexed(7, 1, 3, 201_007_460, 1); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndirect(buffer22, 572); |
| } catch {} |
| try { |
| renderPassEncoder8.setIndexBuffer(buffer1, 'uint32', 2_628, 4_718); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(7, undefined, 295_040_850); |
| } catch {} |
| let commandEncoder46 = device0.createCommandEncoder({}); |
| let commandBuffer3 = commandEncoder7.finish(); |
| let texture58 = device0.createTexture({ |
| size: [1968, 1, 1], |
| mipLevelCount: 1, |
| sampleCount: 1, |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture59 = device0.createTexture({size: [20, 22, 9], format: 'rg8unorm', usage: GPUTextureUsage.COPY_SRC}); |
| let renderPassEncoder10 = commandEncoder46.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView46, |
| clearValue: { r: -618.6, g: 176.5, b: 844.3, a: -156.0, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder10); computePassEncoder10.dispatchWorkgroupsIndirect(buffer20, 848); }; |
| } catch {} |
| try { |
| renderPassEncoder5.executeBundles([renderBundle0, renderBundle1, renderBundle6]); |
| } catch {} |
| try { |
| renderPassEncoder8.setScissorRect(35, 0, 353, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexed(10, 1, 7, 349_796_677); |
| } catch {} |
| try { |
| buffer33.unmap(); |
| } catch {} |
| try { |
| commandEncoder45.resolveQuerySet(querySet3, 331, 6, buffer2, 0); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let texture60 = device0.createTexture({ |
| size: [80, 90, 12], |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder35 = commandEncoder45.beginComputePass({}); |
| try { |
| computePassEncoder35.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder8.setScissorRect(260, 0, 1, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexed(5, 0, 13, 431_223_658); |
| } catch {} |
| try { |
| commandEncoder44.copyBufferToTexture({ |
| /* bytesInLastRow: 2 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 476 */ |
| offset: 476, |
| buffer: buffer15, |
| }, { |
| texture: texture48, |
| mipLevel: 6, |
| origin: {x: 3, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer3]); |
| } catch {} |
| document.body.prepend(img0); |
| let imageData8 = new ImageData(72, 12); |
| let shaderModule6 = device0.createShaderModule({ |
| code: ` |
| diagnostic(info, xyz); |
| |
| requires unrestricted_pointer_parameters; |
| |
| enable f16; |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| @group(0) @binding(323) var<storage, read> buffer44: array<array<array<array<array<f16, 3>, 1>, 4>, 36>>; |
| |
| struct FragmentOutput6 { |
| @location(2) @interpolate(flat, sample) f0: vec4u, |
| @builtin(sample_mask) f1: u32, |
| @location(0) @interpolate(linear, center) f2: vec2f, |
| } |
| |
| var<workgroup> vw28: mat4x2f; |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| alias vec3b = vec3<bool>; |
| |
| /* zero global variables used */ |
| fn fn1(a0: vec4f) -> array<f16, 1> { |
| var out: array<f16, 1>; |
| var vf127: vec4h = trunc(vec4h(unconst_f16(6427.9), unconst_f16(22657.9), unconst_f16(4149.7), unconst_f16(2190.5))); |
| let vf128: vec4<bool> = (vec4h(unconst_f16(6684.3), unconst_f16(13732.6), unconst_f16(12233.1), unconst_f16(22894.3)) > vec4h(unconst_f16(7486.1), unconst_f16(16228.9), unconst_f16(4616.5), unconst_f16(4841.2))); |
| var vf129: bool = (unconst_bool(false) && unconst_bool(true)); |
| vf127 = vec4h(inverseSqrt(vec4f(unconst_f32(0.00953), unconst_f32(0.06479), unconst_f32(0.1578), unconst_f32(0.1030)))); |
| vf129 = any( !vec2<bool>(unconst_bool(false), unconst_bool(false))); |
| let ptr56: ptr<function, vec4h> = &vf127; |
| return out; |
| } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| var<workgroup> vw29: array<array<array<vec4u, 1>, 1>, 1>; |
| |
| /* zero global variables used */ |
| fn fn0(a0: ptr<storage, atomic<i32>, read_write>) -> array<mat3x3h, 1> { |
| var out: array<mat3x3h, 1>; |
| var vf115: vec2i = abs(vec2i(unconst_i32(26), unconst_i32(321))); |
| var vf116: vec3<bool> = (vec3f(f32(dot4I8Packed(unconst_u32(168), countTrailingZeros(vec3u(unconst_u32(163), unconst_u32(93), unconst_u32(4))).b))) > vec3f((vec3i(unconst_i32(24), unconst_i32(65), unconst_i32(57)) | vec3i(unconst_i32(76), unconst_i32(141), unconst_i32(29))))); |
| let vf117: vec4i = ~vec4i(unconst_i32(78), unconst_i32(109), unconst_i32(122), unconst_i32(310)); |
| let ptr55: ptr<storage, atomic<i32>, read_write> = &(*a0); |
| loop { |
| let vf118: vec2h = cos(vec2h(unconst_f16(28171.7), unconst_f16(1622.6))); |
| out[unconst_u32(277)] = mat3x3h(max(vec3h(unconst_f16(16515.4), unconst_f16(-11294.9), unconst_f16(16595.4)), smoothstep(vec2h(unconst_f16(4613.0), unconst_f16(2523.6)), cos(vec2h(unconst_f16(22363.0), unconst_f16(2064.3))), max(vec3h(unconst_f16(958.5), unconst_f16(55124.1), unconst_f16(5410.7)), vec3h(unconst_f16(199.3), unconst_f16(-18853.3), unconst_f16(9539.2))).rb).rgr), max(vec3h(unconst_f16(16515.4), unconst_f16(-11294.9), unconst_f16(16595.4)), smoothstep(vec2h(unconst_f16(4613.0), unconst_f16(2523.6)), cos(vec2h(unconst_f16(22363.0), unconst_f16(2064.3))), max(vec3h(unconst_f16(958.5), unconst_f16(55124.1), unconst_f16(5410.7)), vec3h(unconst_f16(199.3), unconst_f16(-18853.3), unconst_f16(9539.2))).rb).rgr), max(vec3h(unconst_f16(16515.4), unconst_f16(-11294.9), unconst_f16(16595.4)), smoothstep(vec2h(unconst_f16(4613.0), unconst_f16(2523.6)), cos(vec2h(unconst_f16(22363.0), unconst_f16(2064.3))), max(vec3h(unconst_f16(958.5), unconst_f16(55124.1), unconst_f16(5410.7)), vec3h(unconst_f16(199.3), unconst_f16(-18853.3), unconst_f16(9539.2))).rb).rgr)); |
| let vf119: vec3h = step(vec3h(unconst_f16(5214.5), unconst_f16(4438.1), unconst_f16(6044.8)), vec3h(unconst_f16(22832.8), unconst_f16(37632.0), unconst_f16(11373.8))); |
| atomicAnd(&(*a0), bitcast<i32>(smoothstep(vec2h(unconst_f16(2449.1), unconst_f16(3669.7)), vec2h(unconst_f16(33652.4), unconst_f16(3919.4)), vec2h(unconst_f16(563.9), unconst_f16(29498.6))))); |
| var vf120: f16 = vf119[unconst_u32(23)]; |
| break; |
| } |
| let vf121: f16 = fract(unconst_f16(13063.4)); |
| { |
| atomicAnd(&(*a0), unconst_i32(-59)); |
| var vf122: vec3f = exp(vec3f(unconst_f32(-0.4193), unconst_f32(0.04075), unconst_f32(0.2412))); |
| var vf123: vec2u = insertBits(vec2u(unconst_u32(43), unconst_u32(218)), vec2u(unconst_u32(46), unconst_u32(120)), unconst_u32(249), unconst_u32(286)); |
| var vf124: bool = any(unconst_bool(true)); |
| let vf125: mat3x2h = (mat3x2h(unconst_f16(15027.0), unconst_f16(22816.4), unconst_f16(30502.1), unconst_f16(3888.8), unconst_f16(22543.5), unconst_f16(13183.2)) - mat3x2h()); |
| } |
| atomicAdd(&(*a0), unconst_i32(149)); |
| var vf126: vec4h = exp2(vec4h(unconst_f16(2236.0), unconst_f16(1626.9), unconst_f16(631.7), unconst_f16(3.393))); |
| vf115 *= vec2i(i32(all(vec2<bool>(unconst_bool(false), unconst_bool(true))))); |
| out[unconst_u32(72)] = mat3x3h(f16(length(vec4f(unconst_f32(0.1178), unconst_f32(-0.2225), unconst_f32(0.1992), unconst_f32(0.1880)))), f16(length(vec4f(unconst_f32(0.1178), unconst_f32(-0.2225), unconst_f32(0.1992), unconst_f32(0.1880)))), f16(length(vec4f(unconst_f32(0.1178), unconst_f32(-0.2225), unconst_f32(0.1992), unconst_f32(0.1880)))), f16(length(vec4f(unconst_f32(0.1178), unconst_f32(-0.2225), unconst_f32(0.1992), unconst_f32(0.1880)))), f16(length(vec4f(unconst_f32(0.1178), unconst_f32(-0.2225), unconst_f32(0.1992), unconst_f32(0.1880)))), f16(length(vec4f(unconst_f32(0.1178), unconst_f32(-0.2225), unconst_f32(0.1992), unconst_f32(0.1880)))), f16(length(vec4f(unconst_f32(0.1178), unconst_f32(-0.2225), unconst_f32(0.1992), unconst_f32(0.1880)))), f16(length(vec4f(unconst_f32(0.1178), unconst_f32(-0.2225), unconst_f32(0.1992), unconst_f32(0.1880)))), f16(length(vec4f(unconst_f32(0.1178), unconst_f32(-0.2225), unconst_f32(0.1992), unconst_f32(0.1880))))); |
| return out; |
| } |
| |
| var<workgroup> vw30: atomic<u32>; |
| |
| @group(0) @binding(144) var st6: texture_storage_1d<r32uint, read_write>; |
| |
| var<workgroup> vw31: array<f16, 20>; |
| |
| struct T0 { |
| @align(32) @size(864) f0: array<u32>, |
| } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| /* used global variables: buffer44 */ |
| @vertex |
| fn vertex6(@location(4) a0: vec2u, @location(14) @interpolate(flat, first) a1: vec4u, @location(12) a2: i32, @builtin(instance_index) a3: u32, @location(7) a4: vec2f, @location(9) a5: vec2f, @location(3) a6: vec4u) -> @builtin(position) vec4f { |
| var out: vec4f; |
| out = vec4f(f32(buffer44[unconst_u32(436)][unconst_u32(9)][3][0][2])); |
| let ptr57: ptr<storage, array<array<array<array<f16, 3>, 1>, 4>, 36>, read> = &buffer44[unconst_u32(39)]; |
| var vf130 = fn1(vec4f(f32((*ptr57)[35][3][unconst_u32(196)][2]))); |
| var vf131: vec3i = reverseBits(vec3i(i32((*&buffer44)[arrayLength(&(*&buffer44))][unconst_u32(28)][3][unconst_u32(115)][2]))); |
| fn1(vec4f(f32((*ptr57)[unconst_u32(211)][3][unconst_u32(121)][2]))); |
| out = vec4f(f32(buffer44[unconst_u32(34)][unconst_u32(6)][3][0][2])); |
| vf130[unconst_u32(192)] = (*&buffer44)[unconst_u32(104)][unconst_u32(155)][3][0][2]; |
| var vf132 = fn1(vec4f(f32(buffer44[arrayLength(&buffer44)][unconst_u32(121)][3][unconst_u32(299)][2]))); |
| return out; |
| _ = buffer44; |
| } |
| |
| /* zero global variables used */ |
| @fragment |
| fn fragment6() -> FragmentOutput6 { |
| var out: FragmentOutput6; |
| loop { |
| let vf133: vec2h = ldexp(vec2h(unconst_f16(1242.0), unconst_f16(5351.9)), vec2i(unconst_i32(343), unconst_i32(57))); |
| if bool(pack2x16float(vec2f(unconst_f32(0.08194), unconst_f32(0.01941)))) { |
| var vf134: u32 = firstTrailingBit(unconst_u32(33)); |
| let vf135: vec2h = saturate(vec2h(unconst_f16(9959.1), unconst_f16(47280.8))); |
| let vf136: i32 = max(unconst_i32(89), unconst_i32(26)); |
| return out; |
| } |
| out.f1 <<= vec3u(sin(vec3h(unconst_f16(9232.6), unconst_f16(1055.3), unconst_f16(11219.3))))[1]; |
| let vf137: u32 = pack4x8snorm(vec4f(unconst_f32(0.6363), unconst_f32(0.1649), unconst_f32(0.03280), unconst_f32(0.06223))); |
| break; |
| } |
| for (var it4=vec3u(sqrt(vec3h(unconst_f16(23264.2), unconst_f16(7368.5), unconst_f16(1653.3)))).x; it4<u32((vec3i(unconst_i32(-486), unconst_i32(-456), unconst_i32(45)) % unconst_i32(-517)).g); it4++) { |
| out.f0 = vec4u(u32((unconst_bool(true) || unconst_bool(false)))); |
| var vf138: vec2h = faceForward(vec2h(unconst_f16(20928.8), unconst_f16(2836.2)), vec2h(unconst_f16(5871.7), unconst_f16(19636.2)), vec2h(unconst_f16(1830.6), unconst_f16(9390.3))); |
| let vf139: bool = (unconst_bool(false) || unconst_bool(false)); |
| out.f2 = vec2f(extractBits(vec2i(unconst_i32(25), unconst_i32(221)), bitcast<u32>(unpack2x16float(countTrailingZeros(vec2u(unconst_u32(114), unconst_u32(126)))[1]).r), unconst_u32(15))); |
| break; |
| } |
| discard; |
| return out; |
| } |
| |
| /* used global variables: st6 */ |
| @compute @workgroup_size(3, 1, 1) |
| fn compute6() { |
| let ptr58: ptr<workgroup, f16> = &vw31[19]; |
| var vf140: vec2f = vw28[unconst_u32(89)]; |
| let ptr59: ptr<workgroup, vec4u> = &vw29[0][unconst_u32(111)][unconst_u32(283)]; |
| var vf141 = fn1(bitcast<vec4f>(vw29[0][unconst_u32(221)][0])); |
| fn1(vec4f((*&vw29)[unconst_u32(458)][0][unconst_u32(96)])); |
| let ptr60: ptr<workgroup, array<array<array<vec4u, 1>, 1>, 1>> = &vw29; |
| var vf142 = fn1(vec4f(vw29[unconst_u32(617)][(*ptr60)[0][0][pack4xU8((*ptr60)[unconst_u32(64)][0][unconst_u32(38)])][unconst_u32(26)]][0])); |
| fn1(bitcast<vec4f>((*ptr60)[unconst_u32(103)][0][0])); |
| while bool((vec2u(unconst_u32(96), unconst_u32(416)) % vec2u(unconst_u32(76), unconst_u32(87)))[1]) { |
| textureStore(st6, unconst_i32(74), vec4u(vec4u(unconst_u32(406), unconst_u32(210), unconst_u32(154), unconst_u32(157)))); |
| let vf143: u32 = (*&vw29)[0][u32(quantizeToF16(unconst_f32(0.3625)))][unconst_u32(171)][unconst_u32(194)]; |
| _ = st6; |
| } |
| vw31[unconst_u32(85)] = f16(transpose(mat4x4f())[unconst_i32(2)].r); |
| let ptr61: ptr<workgroup, array<array<vec4u, 1>, 1>> = &vw29[0]; |
| textureStore(st6, unconst_i32(47), vec4u(vec4u(unconst_u32(109), unconst_u32(109), unconst_u32(297), unconst_u32(421)))); |
| atomicCompareExchangeWeak(&vw30, unconst_u32(351), unconst_u32(375)); |
| var vf144: vec4f = mix(vec4f(unconst_f32(0.4628), unconst_f32(0.03794), unconst_f32(0.04814), unconst_f32(0.1048)), vec4f(unconst_f32(0.1297), unconst_f32(0.2993), unconst_f32(0.04617), unconst_f32(0.05888)), unconst_f32(0.01531)); |
| fn1(unpack4x8unorm(atomicLoad(&vw30))); |
| _ = st6; |
| } |
| |
| /* zero global variables used */ |
| @compute @workgroup_size(2, 2, 1) |
| fn compute7() { |
| vw29[unconst_u32(514)][unconst_u32(110)][unconst_u32(357)] = vw29[0][unconst_u32(16)][0]; |
| vw29[unconst_u32(239)][unconst_u32(186)][unconst_u32(30)] = unpack4xU8(u32(vw31[19])); |
| fn1(vw28[unconst_u32(286)].grgr); |
| vw31[unconst_u32(595)] = f16(vw29[0][unconst_u32(50)][0][unconst_u32(533)]); |
| var vf145: vec4h = tanh(vec4h(unconst_f16(-8023.0), unconst_f16(619.2), unconst_f16(254.1), unconst_f16(5090.1))); |
| let ptr62: ptr<workgroup, f16> = &vw31[unconst_u32(93)]; |
| vf145 += vec4h((*&vw31)[19]); |
| if bool(vw29[unconst_u32(44)][0][unconst_u32(9)][unconst_u32(267)]) { |
| fn1(unpack4x8snorm(vw29[0][unconst_u32(101)][unconst_u32(88)][u32((*&vw31)[19])])); |
| var vf146 = fn1(vec4f((*&vw29)[unconst_u32(25)][0][0])); |
| fn1(vec4f(vw29[unconst_u32(305)][0][0])); |
| let ptr63: ptr<workgroup, array<vec4u, 1>> = &vw29[0][unconst_u32(448)]; |
| } |
| var vf147 = fn1(vec4f((*&vw29)[unconst_u32(271)][unconst_u32(248)][unconst_u32(53)])); |
| var vf148 = fn1(vec4f(f32(firstTrailingBit(unconst_i32(309))))); |
| fn1(bitcast<vec4f>((*&vw29)[0][0][unconst_u32(492)])); |
| let ptr64: ptr<workgroup, mat4x2f> = &(*&vw28); |
| return; |
| }`, |
| }); |
| let textureView57 = texture58.createView({dimension: '2d-array', baseMipLevel: 0}); |
| try { |
| renderPassEncoder5.draw(326, 2, 722_779_560, 1); |
| } catch {} |
| let pipeline10 = await device0.createRenderPipelineAsync({ |
| layout: pipelineLayout1, |
| fragment: { |
| module: shaderModule1, |
| targets: [{ |
| format: 'rg8unorm', |
| blend: { |
| color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'}, |
| alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'}, |
| }, |
| writeMask: GPUColorWrite.RED, |
| }], |
| }, |
| vertex: { |
| module: shaderModule6, |
| entryPoint: 'vertex6', |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 140, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'float32x4', offset: 16, shaderLocation: 9}, |
| {format: 'uint16x4', offset: 36, shaderLocation: 4}, |
| {format: 'unorm10-10-10-2', offset: 4, shaderLocation: 7}, |
| {format: 'uint32x3', offset: 4, shaderLocation: 3}, |
| {format: 'uint16x2', offset: 8, shaderLocation: 14}, |
| {format: 'sint16x2', offset: 0, shaderLocation: 12}, |
| ], |
| }, |
| ], |
| }, |
| }); |
| let imageData9 = new ImageData(36, 60); |
| let textureView58 = texture58.createView({mipLevelCount: 1}); |
| try { |
| computePassEncoder27.setBindGroup(3, bindGroup13, new Uint32Array(2074), 74, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder22); computePassEncoder22.dispatchWorkgroupsIndirect(buffer2, 36); }; |
| } catch {} |
| try { |
| renderPassEncoder8.setIndexBuffer(buffer24, 'uint16', 28, 49); |
| } catch {} |
| let arrayBuffer4 = buffer4.getMappedRange(48, 0); |
| try { |
| commandEncoder44.copyBufferToBuffer(buffer26, 732, buffer24, 4, 40); |
| } catch {} |
| try { |
| if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(0x55); }; |
| } catch {} |
| let buffer45 = device0.createBuffer({size: 555, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let renderPassEncoder11 = commandEncoder44.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView55, |
| clearValue: { r: 384.0, g: 3.701, b: -14.07, a: 848.8, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| maxDrawCount: 139302822, |
| }); |
| let sampler30 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'repeat', addressModeW: 'clamp-to-edge', compare: 'less'}); |
| try { |
| renderPassEncoder6.setBindGroup(2, bindGroup2); |
| } catch {} |
| try { |
| renderPassEncoder2.executeBundles([renderBundle1]); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexedIndirect(buffer7, 56); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndirect(buffer15, 204); |
| } catch {} |
| try { |
| renderPassEncoder9.setIndexBuffer(buffer24, 'uint32', 16, 27); |
| } catch {} |
| let videoFrame4 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt470bg', primaries: 'bt470m', transfer: 'log'} }); |
| let buffer46 = device0.createBuffer({size: 11779, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let texture61 = gpuCanvasContext0.getCurrentTexture(); |
| let externalTexture1 = device0.importExternalTexture({source: videoFrame1}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder10); computePassEncoder10.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder9.setBindGroup(2, bindGroup11); |
| } catch {} |
| try { |
| renderPassEncoder6.setScissorRect(702, 0, 33, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexed(30, 0, 18, 546_223_565, 1); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexedIndirect(buffer20, 13_884); |
| } catch {} |
| try { |
| renderPassEncoder1.setPipeline(pipeline8); |
| } catch {} |
| let veryExplicitBindGroupLayout10 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 45, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'uniform', hasDynamicOffset: false }}, |
| { |
| binding: 64, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| {binding: 68, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| { |
| binding: 97, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| externalTexture: {}, |
| }, |
| ], |
| }); |
| let texture62 = device0.createTexture({ |
| size: [1230, 30, 1], |
| mipLevelCount: 4, |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| renderPassEncoder11.setBindGroup(2, bindGroup4, []); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexed(0, 0, 12, 18_355_077); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexedIndirect(buffer33, 1_360); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndirect(buffer21, 10_672); |
| } catch {} |
| try { |
| renderPassEncoder9.setPipeline(pipeline0); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer2]); |
| } catch {} |
| let buffer47 = device0.createBuffer({size: 13032, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE}); |
| try { |
| computePassEncoder21.setBindGroup(0, bindGroup3); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexed(19, 0, 151, 968_981_948, 2); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndirect(buffer2, 176); |
| } catch {} |
| offscreenCanvas1.height = 80; |
| let buffer48 = device0.createBuffer({ |
| size: 5886, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE, |
| }); |
| let textureView59 = texture34.createView({mipLevelCount: 1, baseArrayLayer: 0}); |
| try { |
| computePassEncoder21.setBindGroup(0, bindGroup3, []); |
| } catch {} |
| try { |
| computePassEncoder30.setBindGroup(2, bindGroup5, new Uint32Array(1847), 5, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexed(60, 0, 6, 427_869_387, 2); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexedIndirect(buffer12, 18_440); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndirect(buffer2, 28); |
| } catch {} |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer8, 'uint32', 8, 24); |
| } catch {} |
| try { |
| renderPassEncoder1.setPipeline(pipeline5); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer39, 1312, new Int16Array(671), 255, 48); |
| } catch {} |
| await gc(); |
| try { |
| globalThis.someLabel = externalTexture1.label; |
| } catch {} |
| let shaderModule7 = device0.createShaderModule({ |
| code: ` |
| requires readonly_and_readwrite_storage_textures; |
| |
| enable f16; |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| /* zero global variables used */ |
| fn fn1() -> array<u32, 48> { |
| var out: array<u32, 48>; |
| var vf151: f32 = tanh(unconst_f32(-0.00428)); |
| if bool((vec2u(unconst_u32(530), unconst_u32(334)) + unconst_u32(233)).g) { |
| var vf152: vec2<bool> = (vec2h(unconst_f16(6920.8), unconst_f16(4406.0)) >= vec2h(unconst_f16(360.6), unconst_f16(5574.1))); |
| out[47] ^= pack4x8snorm((vec4f(unconst_f32(0.1657), unconst_f32(0.03885), unconst_f32(0.3547), unconst_f32(0.08484)) - unconst_f32(0.05353))); |
| var vf153: vec3i = (vec3i(unconst_i32(218), unconst_i32(16), unconst_i32(61)) << vec3u(unconst_u32(137), unconst_u32(21), unconst_u32(191))); |
| var vf154: u32 = pack4xI8(vec4i(unconst_i32(1), unconst_i32(128), unconst_i32(216), unconst_i32(278))); |
| vf152 = vec2<bool>((vec3i(unconst_i32(71), unconst_i32(-210), unconst_i32(238)) << vec3u(unconst_u32(118), unconst_u32(656), unconst_u32(48))).xx); |
| } |
| vf151 = bitcast<f32>(reverseBits(vec2u(unconst_u32(175), unconst_u32(359)))[1]); |
| vf151 = tan(vec4f(unconst_f32(0.1808), unconst_f32(0.3295), unconst_f32(0.3726), unconst_f32(0.1871)))[2]; |
| vf151 = acosh(vec3f(unconst_f32(0.1828), unconst_f32(0.00138), unconst_f32(0.02276)))[0]; |
| let ptr65: ptr<function, f32> = &vf151; |
| let ptr66: ptr<function, f32> = &(*ptr65); |
| var vf155: vec3f = log(vec3f(unconst_f32(0.5618), unconst_f32(0.09101), unconst_f32(0.02027))); |
| { |
| let vf156: u32 = pack2x16snorm(vec2f((vec3f(unconst_f32(0.1343), unconst_f32(0.1344), unconst_f32(0.1523)) >= min(vec3f(unconst_f32(0.2705), unconst_f32(-0.2801), unconst_f32(-0.00394)), vec3f(unconst_f32(0.1096), unconst_f32(0.1386), unconst_f32(0.1936)))).rb)); |
| for (var it5=pack4xU8Clamp(vec4u(reflect((mat3x2h() * vec3h(unconst_f16(-7615.8), unconst_f16(8825.0), unconst_f16(2407.9))).yxyx, vec4h(unconst_f16(-9662.0), unconst_f16(11518.2), unconst_f16(46853.0), unconst_f16(3628.6))))); it5<u32(radians(vec4f(unconst_f32(0.2895), unconst_f32(0.00665), unconst_f32(0.1046), unconst_f32(0.06190)))[3]); it5++) { |
| out[unconst_u32(164)] = reverseBits(vec4u(unconst_u32(145), unconst_u32(159), unconst_u32(27), unconst_u32(74)))[2]; |
| out[47] >>= pack4xU8(vec4u(unconst_u32(25), unconst_u32(57), unconst_u32(257), unconst_u32(140))); |
| var vf157: vec2f = unpack2x16snorm(unconst_u32(91)); |
| out[unconst_u32(202)] += insertBits(vec4u(unconst_u32(169), unconst_u32(45), unconst_u32(41), unconst_u32(3)), vec4u(unconst_u32(153), unconst_u32(26), unconst_u32(10), unconst_u32(116)), unconst_u32(158), unconst_u32(192))[0]; |
| var vf158: vec2h = abs(vec2h(unconst_f16(8017.3), unconst_f16(28588.6))); |
| } |
| } |
| var vf159: vec4h = ldexp(vec4h(unconst_f16(12028.8), unconst_f16(862.5), unconst_f16(5532.2), unconst_f16(8521.2)), vec4i(unconst_i32(63), unconst_i32(259), unconst_i32(87), unconst_i32(422))); |
| return out; |
| } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| @group(0) @binding(144) var st7: texture_storage_1d<r32uint, read_write>; |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| struct FragmentOutput7 { |
| @location(7) @interpolate(flat, either) f0: vec4f, |
| @location(0) @interpolate(flat) f1: u32, |
| @location(4) f2: u32, |
| @location(1) f3: vec2i, |
| } |
| |
| struct T0 { |
| @align(32) @size(864) f0: array<array<array<vec2h, 1>, 13>>, |
| } |
| |
| /* zero global variables used */ |
| fn fn0() -> array<f32, 48> { |
| var out: array<f32, 48>; |
| out[unconst_u32(4)] = bitcast<f32>(dot4I8Packed(unconst_u32(153), unconst_u32(1))); |
| out[unconst_u32(139)] = tan(vec2f(unconst_f32(0.3520), unconst_f32(0.6529))).x; |
| var vf149: vec4i = insertBits(vec4i(unconst_i32(85), unconst_i32(137), unconst_i32(81), unconst_i32(12)), vec4i(unconst_i32(230), unconst_i32(54), unconst_i32(98), unconst_i32(48)), unconst_u32(190), unconst_u32(141)); |
| var vf150: vec2f = unpack2x16snorm(unconst_u32(7)); |
| out[unconst_u32(201)] = sinh(unconst_f32(0.07436)); |
| return out; |
| } |
| |
| /* zero global variables used */ |
| fn fn2() -> VertexOutput6 { |
| var out: VertexOutput6; |
| let vf160: vec4u = (vec4u(unconst_u32(269), unconst_u32(32), unconst_u32(126), unconst_u32(79)) % unconst_u32(271)); |
| while bool(pack4xU8(vec4u(unconst_u32(111), unconst_u32(702), unconst_u32(148), unconst_u32(561)))) { |
| out.f7 -= vec4f(f32( !unconst_bool(false))); |
| var vf161 = fn0(); |
| if bool(min(vec2u(unconst_u32(276), unconst_u32(102)), vec2u(unconst_u32(327), unconst_u32(224)))[1]) { |
| out = VertexOutput6(unpack2x16float(unconst_u32(61)).xxxx); |
| var vf162 = fn0(); |
| fn0(); |
| out.f7 += vec4f(ceil(vec4h(unconst_f16(10224.6), unconst_f16(7221.9), unconst_f16(-938.9), unconst_f16(177.9)))); |
| break; |
| } |
| for (var it6=u32(vf161[47]); it6<u32(tanh(vec4h(unconst_f16(51791.7), unconst_f16(10827.8), unconst_f16(14899.6), unconst_f16(8283.5))).a); it6++) { |
| let vf163: vec2u = (unconst_u32(55) + vec2u(unconst_u32(60), unconst_u32(16))); |
| { |
| var vf164 = fn0(); |
| break; |
| } |
| break; |
| } |
| let vf165: vec3f = clamp(vec3f(unconst_f32(0.7826), unconst_f32(0.2204), unconst_f32(0.3156)), vec3f(unconst_f32(0.5195), unconst_f32(0.00039), unconst_f32(0.01459)), vec3f(unconst_f32(0.07251), unconst_f32(0.01514), unconst_f32(0.08111))); |
| var vf166 = fn1(); |
| var vf167 = fn1(); |
| break; |
| } |
| out.f7 = bitcast<vec4f>((vec2u(unconst_u32(6), unconst_u32(138)) ^ vec2u(unconst_u32(53), unconst_u32(413))).xyxx); |
| let vf168: i32 = dot4I8Packed(unconst_u32(32), unconst_u32(35)); |
| out.f7 *= vec4f(f32(pack4xU8(vec4u(unconst_u32(454), unconst_u32(82), unconst_u32(449), unconst_u32(106))))); |
| fn0(); |
| fn0(); |
| out.f7 = vec4f((vec2u(unconst_u32(102), unconst_u32(55)) ^ vec2u(unconst_u32(38), unconst_u32(155))).rgrg); |
| out = VertexOutput6(vec4f(f32(pack2x16snorm(vec2f(bitcast<f32>(pack4x8unorm(vec4f(unconst_f32(0.1145), unconst_f32(0.1097), unconst_f32(0.3078), unconst_f32(0.2213))))))))); |
| { |
| let vf169: vec3f = ldexp(vec3f(unconst_f32(0.03879), unconst_f32(0.08090), unconst_f32(-0.05693)), bitcast<vec3i>(acos(vec2f(unconst_f32(-0.4558), unconst_f32(0.02800))).rrr)); |
| out.f7 = vec4f(f32(any(unconst_bool(false)))); |
| fn0(); |
| out.f7 = vec4f(ceil(vec3h(unconst_f16(10860.5), unconst_f16(10411.5), unconst_f16(18026.3))).zyyz); |
| var vf170: vec4h = sin(vec4h(unconst_f16(4156.6), unconst_f16(26621.0), unconst_f16(-793.6), unconst_f16(16509.0))); |
| out.f7 = bitcast<vec4f>( ~bitcast<vec2i>(extractBits(vec2u(unconst_u32(59), unconst_u32(11)), unconst_u32(310), unconst_u32(133))).xxyx); |
| let vf171: vec2i = ~vec2i(unconst_i32(58), unconst_i32(1000)); |
| return out; |
| } |
| fn0(); |
| loop { |
| var vf172: vec3i = firstLeadingBit(vec3i(asin(vec4f(unconst_f32(0.01306), unconst_f32(0.5135), unconst_f32(0.00156), unconst_f32(0.07843))).rgg)); |
| out = VertexOutput6(vec4f(max(vec3i(unconst_i32(82), unconst_i32(454), unconst_i32(4)), vec3i(faceForward(vec2h(unconst_f16(7952.2), unconst_f16(604.4)), vec2h(unconst_f16(16084.2), unconst_f16(5479.3)), bitcast<vec2h>(pack2x16snorm(vec2f(unconst_f32(0.06661), unconst_f32(0.2020))))).xxx)).rrrg)); |
| break; |
| } |
| fn1(); |
| let vf173: i32 = (unconst_i32(30) - bitcast<vec4i>((vec4u(unconst_u32(277), unconst_u32(77), unconst_u32(10), unconst_u32(6)) % pack4xU8Clamp(vf160))).y); |
| out.f7 += vec4f(f32((unconst_f16(6194.6) == unconst_f16(8120.5)))); |
| return out; |
| } |
| |
| struct VertexOutput6 { |
| @builtin(position) f7: vec4f, |
| } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| /* zero global variables used */ |
| @vertex |
| fn vertex7() -> VertexOutput6 { |
| var out: VertexOutput6; |
| var vf174 = fn1(); |
| out = VertexOutput6(vec4f(saturate(vec3h(unconst_f16(60000.0), unconst_f16(7064.6), unconst_f16(13992.1))).bbgg)); |
| fn2(); |
| var vf175 = fn1(); |
| return out; |
| } |
| |
| /* zero global variables used */ |
| @fragment |
| fn fragment7(@invariant @builtin(position) a0: vec4f) -> FragmentOutput7 { |
| var out: FragmentOutput7; |
| let vf176: f16 = sinh(unconst_f16(17850.1)); |
| fn2(); |
| out.f2 -= bitcast<u32>(mix(vec2h(unconst_f16(9196.8), unconst_f16(24262.3)), vec2h(unconst_f16(16743.3), unconst_f16(6303.0)), vec2h(unconst_f16(2440.8), unconst_f16(1018.3)))); |
| out = FragmentOutput7(vec4f((vec4u(unconst_u32(17), unconst_u32(287), unconst_u32(47), unconst_u32(287)) | bitcast<vec4u>(a0))), (vec4u(unconst_u32(17), unconst_u32(287), unconst_u32(47), unconst_u32(287)) | bitcast<vec4u>(a0)).w, pack4xU8((vec4u(unconst_u32(17), unconst_u32(287), unconst_u32(47), unconst_u32(287)) | bitcast<vec4u>(a0))), bitcast<vec2i>((vec4u(unconst_u32(17), unconst_u32(287), unconst_u32(47), unconst_u32(287)) | bitcast<vec4u>(a0)).aa)); |
| let vf177: vec4i = unpack4xI8(unconst_u32(226)); |
| if bool(pack4xI8(vec4i(unconst_i32(164), unconst_i32(-139), unconst_i32(8), unconst_i32(321)))) { |
| fn1(); |
| } |
| var vf178 = fn1(); |
| out = FragmentOutput7(vec4f(f32(vf176)), u32(vf176), u32(vf176), vec2i(i32(vf176))); |
| var vf179: vec2f = degrees(vec2f(unconst_f32(0.04505), unconst_f32(0.03644))); |
| fn0(); |
| vf179 = unpack2x16snorm(pack4xI8(vec4i(unconst_i32(356), unconst_i32(92), unconst_i32(-22), unconst_i32(213)))); |
| return out; |
| } |
| |
| /* used global variables: st7 */ |
| @compute @workgroup_size(4, 1, 3) |
| fn compute8() { |
| var vf180 = fn1(); |
| textureStore(st7, unconst_i32(735), vec4u(vec4u(unconst_u32(66), unconst_u32(400), unconst_u32(88), unconst_u32(321)))); |
| let vf181: u32 = pack4xU8(vec4u(unconst_u32(127), unconst_u32(253), unconst_u32(302), unconst_u32(915))); |
| vf180[unconst_u32(238)] = u32(any((vec2h(unconst_f16(9833.8), unconst_f16(12084.6)) == vec2h(unconst_f16(-11696.8), unconst_f16(6244.5))))); |
| var vf182: vec2<bool> = (vec2h(tan(unconst_f16(1420.5))) == vec2h(unconst_f16(5651.7), unconst_f16(42374.8))); |
| let vf183: f16 = tan(unconst_f16(21965.6)); |
| let vf184: vec2h = cosh(vec2h(unconst_f16(848.6), unconst_f16(10933.2))); |
| fn1(); |
| let vf185: vec4<bool> = (vec4u(unconst_u32(110), unconst_u32(90), unconst_u32(105), unconst_u32(171)) <= vec4u(unconst_u32(259), unconst_u32(226), unconst_u32(159), unconst_u32(152))); |
| var vf186 = fn1(); |
| _ = st7; |
| }`, |
| }); |
| let bindGroup17 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout0, |
| entries: [ |
| {binding: 323, resource: {buffer: buffer5, offset: 1792, size: 14300}}, |
| {binding: 144, resource: textureView5}, |
| ], |
| }); |
| let commandEncoder47 = device0.createCommandEncoder(); |
| try { |
| computePassEncoder16.setBindGroup(0, bindGroup1); |
| } catch {} |
| try { |
| renderPassEncoder7.setBindGroup(0, bindGroup9); |
| } catch {} |
| try { |
| renderPassEncoder5.draw(13, 0, 1_486_251_930); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexed(73, 0, 10, 648_210_709, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexedIndirect(buffer14, 3_672); |
| } catch {} |
| try { |
| computePassEncoder20.pushDebugGroup('\u01a5'); |
| } catch {} |
| let bindGroup18 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout10, |
| entries: [ |
| {binding: 97, resource: externalTexture1}, |
| {binding: 45, resource: {buffer: buffer1, offset: 1792, size: 118}}, |
| {binding: 64, resource: {buffer: buffer47, offset: 1024}}, |
| {binding: 68, resource: {buffer: buffer12, offset: 4864}}, |
| ], |
| }); |
| let commandEncoder48 = device0.createCommandEncoder({}); |
| let computePassEncoder36 = commandEncoder47.beginComputePass({}); |
| let externalTexture2 = device0.importExternalTexture({source: videoFrame0}); |
| try { |
| computePassEncoder2.setBindGroup(1, bindGroup9, new Uint32Array(946), 92, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(0, bindGroup2); |
| } catch {} |
| try { |
| renderPassEncoder6.setBlendConstant({ r: -856.1, g: -833.3, b: 742.5, a: 200.2, }); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexedIndirect(buffer2, 348); |
| } catch {} |
| try { |
| renderPassEncoder5.setPipeline(pipeline7); |
| } catch {} |
| try { |
| commandEncoder48.copyTextureToTexture({ |
| texture: texture20, |
| mipLevel: 0, |
| origin: {x: 57, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture39, |
| mipLevel: 0, |
| origin: {x: 69, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 8, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 123, height: 1, depthOrArrayLayers: 153} |
| */ |
| { |
| source: videoFrame0, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture6, |
| mipLevel: 1, |
| origin: {x: 41, y: 0, z: 2}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup19 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout9, |
| entries: [ |
| {binding: 144, resource: textureView2}, |
| {binding: 323, resource: {buffer: buffer16, offset: 0, size: 988}}, |
| ], |
| }); |
| let commandEncoder49 = device0.createCommandEncoder({}); |
| let texture63 = device0.createTexture({ |
| size: {width: 246, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 4, |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder37 = commandEncoder48.beginComputePass(); |
| let sampler31 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| mipmapFilter: 'nearest', |
| }); |
| try { |
| computePassEncoder36.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder5.draw(15, 0, 694_471_199); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexedIndirect(buffer12, 688); |
| } catch {} |
| try { |
| renderPassEncoder10.setIndexBuffer(buffer24, 'uint16', 30, 21); |
| } catch {} |
| try { |
| renderPassEncoder7.setVertexBuffer(3, buffer43, 0); |
| } catch {} |
| try { |
| computePassEncoder20.popDebugGroup(); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| await gc(); |
| let videoFrame5 = new VideoFrame(img0, {timestamp: 0}); |
| let bindGroup20 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout0, |
| entries: [ |
| {binding: 323, resource: {buffer: buffer5, offset: 3072, size: 936}}, |
| {binding: 144, resource: textureView2}, |
| ], |
| }); |
| let textureView60 = texture25.createView({dimension: '2d-array', format: 'r32uint'}); |
| let computePassEncoder38 = commandEncoder49.beginComputePass({}); |
| try { |
| computePassEncoder9.setBindGroup(1, bindGroup1, new Uint32Array(13), 6, 0); |
| } catch {} |
| try { |
| computePassEncoder37.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder2.executeBundles([renderBundle0, renderBundle1]); |
| } catch {} |
| try { |
| renderPassEncoder5.setBlendConstant({ r: -549.2, g: -60.70, b: -571.7, a: -385.1, }); |
| } catch {} |
| try { |
| renderPassEncoder5.draw(45, 32, 34_910_729); |
| } catch {} |
| let arrayBuffer5 = buffer26.getMappedRange(56, 0); |
| let buffer50 = device0.createBuffer({size: 464, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let textureView61 = texture11.createView({dimension: '2d-array'}); |
| try { |
| computePassEncoder14.setBindGroup(2, bindGroup15); |
| } catch {} |
| try { |
| computePassEncoder28.setBindGroup(2, bindGroup11, new Uint32Array(717), 114, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.draw(243, 4, 1_032_973_949); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndirect(buffer20, 8_800); |
| } catch {} |
| let commandEncoder50 = device0.createCommandEncoder({}); |
| let texture64 = gpuCanvasContext1.getCurrentTexture(); |
| let textureView62 = texture20.createView({dimension: '2d'}); |
| let renderPassEncoder12 = commandEncoder50.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView55, |
| clearValue: { r: -314.0, g: 155.4, b: 874.9, a: -869.1, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| }); |
| let sampler32 = device0.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'mirror-repeat', magFilter: 'nearest', lodMaxClamp: 95.74}); |
| try { |
| renderPassEncoder7.setBlendConstant({ r: 144.8, g: -823.2, b: -942.4, a: -143.0, }); |
| } catch {} |
| try { |
| renderPassEncoder5.drawIndexed(0, 4, 113, 372_856_005, 5); |
| } catch {} |
| try { |
| renderPassEncoder12.setPipeline(pipeline10); |
| } catch {} |
| let veryExplicitBindGroupLayout11 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 39, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| { |
| binding: 41, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: true }, |
| }, |
| ], |
| }); |
| let bindGroup21 = device0.createBindGroup({ |
| label: '\u{1fdf6}\u{1fd53}\u{1fd9e}\u{1fa9f}\u0be0\u3313\u0257\u{1f96a}\u0b35\uc621', |
| layout: veryExplicitBindGroupLayout2, |
| entries: [ |
| {binding: 41, resource: textureView8}, |
| {binding: 39, resource: {buffer: buffer15, offset: 0, size: 852}}, |
| ], |
| }); |
| let textureView63 = texture16.createView({dimension: '2d-array', arrayLayerCount: 1}); |
| let texture65 = device0.createTexture({ |
| size: {width: 1230, height: 30, depthOrArrayLayers: 1}, |
| format: 'astc-6x6-unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['astc-6x6-unorm-srgb'], |
| }); |
| try { |
| computePassEncoder17.setBindGroup(1, bindGroup11); |
| } catch {} |
| try { |
| computePassEncoder23.setBindGroup(0, bindGroup8, new Uint32Array(186), 0, 0); |
| } catch {} |
| try { |
| computePassEncoder22.end(); |
| } catch {} |
| try { |
| computePassEncoder38.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderPassEncoder5.end(); |
| } catch {} |
| try { |
| renderPassEncoder0.executeBundles([renderBundle2, renderBundle4]); |
| } catch {} |
| try { |
| renderPassEncoder10.setIndexBuffer(buffer37, 'uint32', 1_752, 2_260); |
| } catch {} |
| let buffer51 = device0.createBuffer({ |
| size: 3253, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder51 = device0.createCommandEncoder({}); |
| let textureView64 = texture11.createView({baseArrayLayer: 0}); |
| let computePassEncoder39 = commandEncoder24.beginComputePass({}); |
| try { |
| computePassEncoder12.setBindGroup(2, bindGroup15, new Uint32Array(143), 47, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder12); computePassEncoder12.dispatchWorkgroupsIndirect(buffer32, 3_464); }; |
| } catch {} |
| try { |
| computePassEncoder39.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer2, 'uint16', 70, 215); |
| } catch {} |
| try { |
| renderPassEncoder7.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder9.setVertexBuffer(4, buffer38, 0, 3); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let bindGroup22 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 41, resource: textureView8}, |
| {binding: 39, resource: {buffer: buffer33, offset: 2560, size: 456}}, |
| ], |
| }); |
| let texture66 = device0.createTexture({ |
| size: [470, 2, 1], |
| mipLevelCount: 5, |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView65 = texture7.createView({arrayLayerCount: 1}); |
| let computePassEncoder40 = commandEncoder51.beginComputePass({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder13); computePassEncoder13.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder9.setBindGroup(1, bindGroup1, []); |
| } catch {} |
| try { |
| renderPassEncoder10.setBlendConstant({ r: -643.6, g: -270.7, b: 300.7, a: 469.7, }); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let buffer52 = device0.createBuffer({size: 1152, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT}); |
| let texture67 = device0.createTexture({ |
| size: [984], |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'r8uint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView66 = texture67.createView({arrayLayerCount: 1}); |
| try { |
| computePassEncoder40.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(0, bindGroup4); |
| } catch {} |
| try { |
| renderPassEncoder10.setBindGroup(3, bindGroup22, new Uint32Array(2543), 304, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.executeBundles([renderBundle3]); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(0, buffer5, 0, 2_149); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer16, 120, new Float32Array(4058), 1659, 60); |
| } catch {} |
| let autogeneratedBindGroupLayout1 = pipeline4.getBindGroupLayout(0); |
| let commandEncoder52 = device0.createCommandEncoder({}); |
| let textureView67 = texture63.createView({mipLevelCount: 1}); |
| let sampler33 = device0.createSampler({addressModeV: 'repeat', mipmapFilter: 'linear', lodMaxClamp: 94.91, compare: 'never'}); |
| try { |
| renderPassEncoder1.setBindGroup(0, bindGroup1); |
| } catch {} |
| try { |
| renderPassEncoder2.draw(318, 0, 69_761_831); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexed(0, 0, 1, 736_064_943, 2); |
| } catch {} |
| try { |
| renderPassEncoder6.setVertexBuffer(0, buffer22, 0); |
| } catch {} |
| let bindGroup23 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout6, |
| entries: [ |
| {binding: 97, resource: externalTexture0}, |
| {binding: 45, resource: {buffer: buffer2, offset: 512}}, |
| {binding: 68, resource: {buffer: buffer20, offset: 4352, size: 2460}}, |
| {binding: 64, resource: {buffer: buffer37, offset: 0, size: 280}}, |
| ], |
| }); |
| let pipelineLayout8 = device0.createPipelineLayout({bindGroupLayouts: [autogeneratedBindGroupLayout0]}); |
| let buffer53 = device0.createBuffer({ |
| size: 912, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM, |
| }); |
| let texture68 = device0.createTexture({ |
| size: [1968, 1, 43], |
| mipLevelCount: 6, |
| dimension: '3d', |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder41 = commandEncoder52.beginComputePass({}); |
| let sampler34 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| }); |
| try { |
| computePassEncoder20.setBindGroup(3, bindGroup16); |
| } catch {} |
| try { |
| computePassEncoder41.setBindGroup(1, bindGroup5, new Uint32Array(807), 17, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder6); computePassEncoder6.dispatchWorkgroupsIndirect(buffer13, 1_040); }; |
| } catch {} |
| try { |
| computePassEncoder41.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderPassEncoder9.executeBundles([renderBundle6, renderBundle6, renderBundle6, renderBundle0, renderBundle2, renderBundle6, renderBundle2]); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexed(4, 0, 0, 1_533_328_693, 1); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer31, 360); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndirect(buffer48, 872); |
| } catch {} |
| try { |
| renderPassEncoder8.setPipeline(pipeline0); |
| } catch {} |
| let texture69 = device0.createTexture({ |
| size: [940, 5, 1], |
| mipLevelCount: 1, |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView68 = texture13.createView({dimension: '2d', baseArrayLayer: 1}); |
| let computePassEncoder42 = commandEncoder31.beginComputePass({}); |
| let renderBundleEncoder7 = device0.createRenderBundleEncoder({colorFormats: ['rg8unorm']}); |
| try { |
| computePassEncoder27.setBindGroup(2, bindGroup15); |
| } catch {} |
| try { |
| computePassEncoder42.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder0.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderBundleEncoder7.setBindGroup(0, bindGroup1); |
| } catch {} |
| let imageData10 = new ImageData(80, 8); |
| try { |
| renderPassEncoder12.setViewport(168.77384961753623, 0.7784968900512585, 51.79570103668932, 0.11262016576285468, 0.4260844069190286, 0.5072620521942122); |
| } catch {} |
| try { |
| renderPassEncoder2.draw(165, 0, 961_634_382); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndirect(buffer47, 2_168); |
| } catch {} |
| try { |
| renderPassEncoder11.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(0, buffer38, 0, 16); |
| } catch {} |
| let recycledExplicitBindGroupLayout2 = pipeline2.getBindGroupLayout(0); |
| let bindGroup24 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 39, resource: {buffer: buffer15, offset: 512, size: 540}}, |
| {binding: 41, resource: textureView53}, |
| ], |
| }); |
| let commandEncoder53 = device0.createCommandEncoder({}); |
| let textureView69 = texture44.createView({}); |
| let computePassEncoder43 = commandEncoder53.beginComputePass({}); |
| try { |
| computePassEncoder20.setBindGroup(0, bindGroup20); |
| } catch {} |
| try { |
| computePassEncoder15.end(); |
| } catch {} |
| try { |
| renderBundleEncoder7.setIndexBuffer(buffer24, 'uint16', 66, 82); |
| } catch {} |
| try { |
| device0.pushErrorScope('internal'); |
| } catch {} |
| try { |
| commandEncoder15.resolveQuerySet(querySet2, 61, 3, buffer29, 0); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'display-p3', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture52, |
| mipLevel: 0, |
| origin: {x: 104, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(158).fill(11), /* required buffer size: 158 */ |
| {offset: 158}, {width: 16, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup25 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout3, |
| entries: [ |
| {binding: 323, resource: {buffer: buffer47, offset: 1024, size: 1780}}, |
| {binding: 144, resource: textureView2}, |
| ], |
| }); |
| let commandEncoder54 = device0.createCommandEncoder({}); |
| let querySet4 = device0.createQuerySet({type: 'occlusion', count: 1432}); |
| let commandBuffer4 = commandEncoder15.finish(); |
| let texture70 = device0.createTexture({ |
| size: {width: 40, height: 45, depthOrArrayLayers: 34}, |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder44 = commandEncoder54.beginComputePass({}); |
| try { |
| computePassEncoder44.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndirect(buffer1, 1_704); |
| } catch {} |
| try { |
| renderBundleEncoder7.setBindGroup(0, bindGroup21, new Uint32Array(1777), 230, 0); |
| } catch {} |
| try { |
| renderBundleEncoder7.setIndexBuffer(buffer22, 'uint32', 144, 158); |
| } catch {} |
| try { |
| if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(0x55); }; |
| } catch {} |
| let buffer54 = device0.createBuffer({size: 196, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let texture71 = device0.createTexture({ |
| size: [1880, 10, 1], |
| format: 'r8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView70 = texture0.createView({}); |
| try { |
| renderPassEncoder7.executeBundles([renderBundle6, renderBundle5, renderBundle4]); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexed(8, 0, 0, 41_150_979); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer20, 16); |
| } catch {} |
| try { |
| renderBundleEncoder7.setBindGroup(1, bindGroup3); |
| } catch {} |
| try { |
| renderBundleEncoder7.setBindGroup(3, bindGroup20, new Uint32Array(1714), 71, 0); |
| } catch {} |
| try { |
| renderBundleEncoder7.setIndexBuffer(buffer52, 'uint32', 132, 85); |
| } catch {} |
| try { |
| renderBundleEncoder7.setPipeline(pipeline4); |
| } catch {} |
| let textureView71 = texture67.createView({}); |
| let sampler35 = device0.createSampler({addressModeV: 'mirror-repeat', magFilter: 'linear', mipmapFilter: 'linear'}); |
| try { |
| computePassEncoder43.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderPassEncoder12.setBindGroup(0, bindGroup6); |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(3, bindGroup4, new Uint32Array(1565), 109, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.executeBundles([renderBundle1, renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexed(2, 0, 0, 135_469_115); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer22, 440); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndirect(buffer33, 76); |
| } catch {} |
| try { |
| renderBundleEncoder7.setIndexBuffer(buffer13, 'uint16', 244, 1_629); |
| } catch {} |
| let arrayBuffer6 = buffer26.getMappedRange(32, 0); |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let pipeline11 = device0.createComputePipeline({layout: pipelineLayout3, compute: {module: shaderModule3}}); |
| let buffer55 = device0.createBuffer({size: 1551, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX}); |
| let texture72 = device0.createTexture({ |
| size: {width: 470, height: 2, depthOrArrayLayers: 1}, |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| let externalTexture3 = device0.importExternalTexture({source: videoFrame5}); |
| try { |
| renderPassEncoder2.draw(11, 0, 204_579_557); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexed(4, 0, 0, 2_147_483_647); |
| } catch {} |
| try { |
| renderPassEncoder8.setVertexBuffer(5, undefined, 0, 130_218_354); |
| } catch {} |
| try { |
| renderBundleEncoder7.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderBundleEncoder7.setVertexBuffer(2, buffer22, 40); |
| } catch {} |
| await gc(); |
| let commandEncoder55 = device0.createCommandEncoder({}); |
| let computePassEncoder45 = commandEncoder55.beginComputePass({}); |
| try { |
| computePassEncoder23.setBindGroup(0, bindGroup4, new Uint32Array(1363), 80, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexed(8, 0, 3, -1_780_492_896); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(6, buffer32, 2_912); |
| } catch {} |
| try { |
| renderBundleEncoder7.setBindGroup(0, bindGroup20); |
| } catch {} |
| try { |
| renderBundleEncoder7.setBindGroup(0, bindGroup4, new Uint32Array(310), 49, 0); |
| } catch {} |
| try { |
| renderBundleEncoder7.draw(46, 18, 502_744_259, 1_325_795_533); |
| } catch {} |
| try { |
| renderBundleEncoder7.drawIndexed(118, 66, 2, 27_535_057, 50_502_357); |
| } catch {} |
| try { |
| renderBundleEncoder7.drawIndexedIndirect(buffer2, 72); |
| } catch {} |
| try { |
| renderBundleEncoder7.drawIndirect(buffer33, 748); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let textureView72 = texture27.createView({dimension: '2d-array', aspect: 'all'}); |
| let sampler36 = device0.createSampler({ |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| maxAnisotropy: 9, |
| }); |
| try { |
| computePassEncoder45.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderPassEncoder2.draw(51, 0, 164_097_941); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer47, 1_204); |
| } catch {} |
| try { |
| renderBundleEncoder7.setBindGroup(3, bindGroup21); |
| } catch {} |
| try { |
| renderBundleEncoder7.draw(327, 106, 1_278_578_936, 703_126_413); |
| } catch {} |
| try { |
| renderBundleEncoder7.drawIndexed(46, 234, 514, 629_251_389, 4_001_056_179); |
| } catch {} |
| try { |
| renderBundleEncoder7.drawIndexedIndirect(buffer12, 5_456); |
| } catch {} |
| try { |
| renderBundleEncoder7.setPipeline(pipeline0); |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let textureView73 = texture46.createView({label: '\u5968\u2e58\u3981\ua96b\u{1f69a}\u6125\u0961\u{1ff53}', dimension: '2d-array'}); |
| let texture73 = device0.createTexture({ |
| size: {width: 1230, height: 30, depthOrArrayLayers: 1}, |
| mipLevelCount: 5, |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['r8sint', 'r8sint'], |
| }); |
| try { |
| computePassEncoder36.setBindGroup(3, bindGroup6); |
| } catch {} |
| try { |
| renderPassEncoder2.beginOcclusionQuery(189); |
| } catch {} |
| try { |
| renderPassEncoder2.draw(36, 0, 229_201_233); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer52, 332); |
| } catch {} |
| try { |
| renderPassEncoder12.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderBundleEncoder7.setVertexBuffer(4, buffer42, 888, 859); |
| } catch {} |
| let pipeline12 = device0.createRenderPipeline({ |
| layout: 'auto', |
| fragment: { |
| module: shaderModule2, |
| constants: {override0: 1}, |
| targets: [{format: 'rg8unorm', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA}], |
| }, |
| vertex: { |
| module: shaderModule2, |
| constants: {}, |
| buffers: [{arrayStride: 16, attributes: [{format: 'snorm16x2', offset: 4, shaderLocation: 0}]}], |
| }, |
| primitive: {topology: 'line-list', frontFace: 'cw', cullMode: 'front', unclippedDepth: true}, |
| }); |
| let bindGroup26 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout0, |
| entries: [ |
| {binding: 144, resource: textureView2}, |
| {binding: 323, resource: {buffer: buffer37, offset: 0, size: 5544}}, |
| ], |
| }); |
| let commandEncoder56 = device0.createCommandEncoder({}); |
| let renderPassEncoder13 = commandEncoder56.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView46, |
| clearValue: { r: 167.3, g: 456.4, b: -457.9, a: 701.7, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| maxDrawCount: 608946359, |
| }); |
| try { |
| renderPassEncoder2.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexed(3, 0, 4, -1_678_080_045); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer12, 5_960); |
| } catch {} |
| try { |
| renderBundleEncoder7.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderBundleEncoder7.setVertexBuffer(3, buffer7); |
| } catch {} |
| let commandEncoder57 = device0.createCommandEncoder({}); |
| let textureView74 = texture14.createView({baseArrayLayer: 1, arrayLayerCount: 1}); |
| try { |
| computePassEncoder29.setBindGroup(3, bindGroup0); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(1, bindGroup2, new Uint32Array(1809), 412, 0); |
| } catch {} |
| try { |
| renderPassEncoder6.end(); |
| } catch {} |
| try { |
| renderPassEncoder10.setScissorRect(88, 0, 36, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(24, 5, 351_054_413, 1_166_255_423); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndirect(buffer13, 360); |
| } catch {} |
| try { |
| renderPassEncoder10.setVertexBuffer(1, buffer55, 0, 652); |
| } catch {} |
| try { |
| renderBundleEncoder7.setPipeline(pipeline4); |
| } catch {} |
| try { |
| commandEncoder57.clearBuffer(buffer45, 96, 68); |
| } catch {} |
| let computePassEncoder46 = commandEncoder57.beginComputePass(); |
| let renderPassEncoder14 = commandEncoder37.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView36, |
| depthSlice: 285, |
| clearValue: { r: -436.4, g: -191.7, b: -172.3, a: 654.2, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| maxDrawCount: 59718792, |
| }); |
| try { |
| computePassEncoder46.setBindGroup(2, bindGroup22); |
| } catch {} |
| try { |
| computePassEncoder46.setPipeline(pipeline11); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(0, bindGroup26, new Uint32Array(1022), 250, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.executeBundles([renderBundle6, renderBundle0, renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder2.draw(36, 0, 443_564_580); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexed(114, 226, 71, 65_121_707, 1_202_222_214); |
| } catch {} |
| try { |
| renderPassEncoder0.drawIndexedIndirect(buffer33, 704); |
| } catch {} |
| try { |
| renderPassEncoder10.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder10.setVertexBuffer(6, buffer40, 0); |
| } catch {} |
| try { |
| renderBundleEncoder7.setIndexBuffer(buffer38, 'uint32', 108); |
| } catch {} |
| try { |
| buffer2.unmap(); |
| } catch {} |
| let pipeline13 = device0.createComputePipeline({layout: pipelineLayout0, compute: {module: shaderModule0, constants: {}}}); |
| let veryExplicitBindGroupLayout12 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 125, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '2d-array' }, |
| }, |
| { |
| binding: 166, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let bindGroup27 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout6, |
| entries: [ |
| {binding: 97, resource: externalTexture2}, |
| {binding: 45, resource: {buffer: buffer24, offset: 0, size: 121}}, |
| {binding: 64, resource: {buffer: buffer51, offset: 0, size: 868}}, |
| {binding: 68, resource: {buffer: buffer20, offset: 7168, size: 2952}}, |
| ], |
| }); |
| try { |
| computePassEncoder30.setBindGroup(2, bindGroup13); |
| } catch {} |
| try { |
| renderPassEncoder10.setBindGroup(2, bindGroup11, new Uint32Array(401), 62, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.draw(391, 0, 326_708_995); |
| } catch {} |
| try { |
| computePassEncoder7.insertDebugMarker('\u69bc'); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let veryExplicitBindGroupLayout13 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 39, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| { |
| binding: 41, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: true }, |
| }, |
| ], |
| }); |
| try { |
| computePassEncoder31.setBindGroup(0, bindGroup8); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexed(0, 0, 1, 244_302_270); |
| } catch {} |
| try { |
| renderPassEncoder10.setVertexBuffer(5, buffer51, 0, 279); |
| } catch {} |
| try { |
| renderBundleEncoder7.setIndexBuffer(buffer22, 'uint16', 244, 166); |
| } catch {} |
| try { |
| computePassEncoder18.insertDebugMarker('\uc27f'); |
| } catch {} |
| let buffer56 = device0.createBuffer({size: 4570, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX}); |
| let commandEncoder58 = device0.createCommandEncoder({}); |
| let texture74 = device0.createTexture({size: {width: 80}, dimension: '1d', format: 'rg8unorm', usage: GPUTextureUsage.COPY_DST}); |
| let textureView75 = texture29.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 2}); |
| try { |
| computePassEncoder46.setBindGroup(1, bindGroup24, new Uint32Array(3843), 336, 0); |
| } catch {} |
| try { |
| renderPassEncoder11.setBindGroup(3, bindGroup4); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(0, buffer38, 28, 89); |
| } catch {} |
| try { |
| renderBundleEncoder7.setBindGroup(1, bindGroup27); |
| } catch {} |
| try { |
| renderBundleEncoder7.setIndexBuffer(buffer22, 'uint32', 324, 731); |
| } catch {} |
| let arrayBuffer7 = buffer26.getMappedRange(40, 0); |
| try { |
| commandEncoder58.copyBufferToTexture({ |
| /* bytesInLastRow: 64 widthInBlocks: 4 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 928 */ |
| offset: 928, |
| buffer: buffer37, |
| }, { |
| texture: texture65, |
| mipLevel: 0, |
| origin: {x: 54, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 24, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder58.copyTextureToBuffer({ |
| texture: texture65, |
| mipLevel: 0, |
| origin: {x: 396, y: 6, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 208 widthInBlocks: 13 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 3888 */ |
| offset: 3888, |
| buffer: buffer37, |
| }, {width: 78, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder58.clearBuffer(buffer23); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let texture75 = device0.createTexture({ |
| size: [246, 1, 1], |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let texture76 = gpuCanvasContext0.getCurrentTexture(); |
| let textureView76 = texture14.createView({dimension: '2d-array', baseMipLevel: 0, baseArrayLayer: 2, arrayLayerCount: 1}); |
| let renderPassEncoder15 = commandEncoder58.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView36, |
| depthSlice: 189, |
| clearValue: { r: 178.1, g: 415.4, b: 647.5, a: -324.6, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| }); |
| let sampler37 = device0.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'repeat', lodMinClamp: 19.26}); |
| try { |
| computePassEncoder10.end(); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(1, bindGroup8, new Uint32Array(2471), 329, 0); |
| } catch {} |
| try { |
| renderBundleEncoder7.setBindGroup(3, bindGroup3, new Uint32Array(237), 18, 0); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'display-p3', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let commandEncoder59 = device0.createCommandEncoder({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder24); computePassEncoder24.dispatchWorkgroupsIndirect(buffer12, 564); }; |
| } catch {} |
| try { |
| renderPassEncoder7.setBindGroup(3, bindGroup11); |
| } catch {} |
| try { |
| renderPassEncoder12.setBindGroup(2, bindGroup22, new Uint32Array(454), 41, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer20, 1_768); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(2, buffer21, 7_504, 1_654); |
| } catch {} |
| try { |
| renderBundleEncoder7.setIndexBuffer(buffer0, 'uint16', 48, 853); |
| } catch {} |
| try { |
| renderPassEncoder1.insertDebugMarker('\u0741'); |
| } catch {} |
| let texture77 = device0.createTexture({ |
| size: [246, 1, 92], |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView77 = texture49.createView({dimension: '2d', mipLevelCount: 1}); |
| let computePassEncoder47 = commandEncoder13.beginComputePass({}); |
| let sampler38 = device0.createSampler({ |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 52.15, |
| lodMaxClamp: 75.89, |
| compare: 'never', |
| }); |
| try { |
| computePassEncoder30.setBindGroup(0, bindGroup13, []); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(0, bindGroup20, new Uint32Array(4254), 2_215, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.executeBundles([renderBundle0, renderBundle3]); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(284, 130, 724_180_047, 731_260_958); |
| } catch {} |
| try { |
| renderPassEncoder1.drawIndirect(buffer7, 36); |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer52, 'uint32', 652, 42); |
| } catch {} |
| try { |
| renderBundleEncoder7.setPipeline(pipeline8); |
| } catch {} |
| let computePassEncoder48 = commandEncoder59.beginComputePass({}); |
| try { |
| renderPassEncoder14.setBindGroup(2, bindGroup8, new Uint32Array(1310), 123, 0); |
| } catch {} |
| try { |
| renderPassEncoder12.executeBundles([renderBundle3]); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexedIndirect(buffer47, 3_068); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndirect(buffer51, 716); |
| } catch {} |
| try { |
| renderBundleEncoder7.setBindGroup(1, bindGroup26); |
| } catch {} |
| try { |
| renderBundleEncoder7.drawIndexedIndirect(buffer52, 84); |
| } catch {} |
| try { |
| renderBundleEncoder7.setPipeline(pipeline12); |
| } catch {} |
| let promise6 = shaderModule3.getCompilationInfo(); |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let renderBundleEncoder8 = device0.createRenderBundleEncoder({colorFormats: ['rg8unorm'], depthReadOnly: true}); |
| try { |
| computePassEncoder48.setPipeline(pipeline13); |
| } catch {} |
| try { |
| renderPassEncoder0.draw(309, 294, 421_682_223, 385_157_652); |
| } catch {} |
| try { |
| renderPassEncoder1.drawIndexed(2, 0, 2, 373_586_229); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndirect(buffer21, 12_856); |
| } catch {} |
| try { |
| renderBundleEncoder8.setBindGroup(2, bindGroup21); |
| } catch {} |
| try { |
| renderBundleEncoder7.setPipeline(pipeline7); |
| } catch {} |
| try { |
| buffer40.unmap(); |
| } catch {} |
| let pipeline14 = await device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| fragment: { |
| module: shaderModule1, |
| targets: [{format: 'rg8unorm', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED}], |
| }, |
| vertex: {module: shaderModule3, buffers: []}, |
| }); |
| let commandEncoder60 = device0.createCommandEncoder(); |
| let computePassEncoder49 = commandEncoder60.beginComputePass(); |
| let renderBundle7 = renderBundleEncoder7.finish(); |
| try { |
| computePassEncoder35.setBindGroup(0, bindGroup1); |
| } catch {} |
| try { |
| computePassEncoder32.setBindGroup(1, bindGroup4, new Uint32Array(2242), 603, 0); |
| } catch {} |
| try { |
| computePassEncoder49.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder0.end(); |
| } catch {} |
| try { |
| renderPassEncoder9.setStencilReference(528); |
| } catch {} |
| try { |
| renderPassEncoder1.drawIndexedIndirect(buffer2, 740); |
| } catch {} |
| try { |
| renderPassEncoder1.drawIndirect(buffer48, 784); |
| } catch {} |
| try { |
| renderPassEncoder10.setPipeline(pipeline14); |
| } catch {} |
| try { |
| renderPassEncoder7.setVertexBuffer(0, undefined); |
| } catch {} |
| try { |
| renderBundleEncoder8.setBindGroup(3, bindGroup6); |
| } catch {} |
| try { |
| commandEncoder23.copyBufferToTexture({ |
| /* bytesInLastRow: 144 widthInBlocks: 36 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 200 */ |
| offset: 200, |
| buffer: buffer35, |
| }, { |
| texture: texture1, |
| mipLevel: 0, |
| origin: {x: 46, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 36, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let commandEncoder61 = device0.createCommandEncoder({}); |
| let texture78 = device0.createTexture({ |
| size: {width: 470, height: 2, depthOrArrayLayers: 645}, |
| dimension: '3d', |
| format: 'r8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView78 = texture28.createView({baseMipLevel: 0}); |
| let renderBundleEncoder9 = device0.createRenderBundleEncoder({colorFormats: ['rg8unorm'], stencilReadOnly: true}); |
| let sampler39 = device0.createSampler({ |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| lodMinClamp: 35.49, |
| lodMaxClamp: 36.93, |
| compare: 'always', |
| }); |
| try { |
| renderPassEncoder13.setBlendConstant({ r: 251.2, g: -51.07, b: -599.8, a: 141.4, }); |
| } catch {} |
| try { |
| renderPassEncoder2.draw(270, 0, 14_167_836); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexed(5, 0, 2, 776_567_538); |
| } catch {} |
| try { |
| renderPassEncoder1.drawIndexedIndirect(buffer22, 152); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(5, buffer5, 7_164, 2_956); |
| } catch {} |
| try { |
| renderBundleEncoder8.setPipeline(pipeline4); |
| } catch {} |
| try { |
| commandEncoder23.copyBufferToTexture({ |
| /* bytesInLastRow: 206 widthInBlocks: 103 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 4794 */ |
| offset: 4794, |
| buffer: buffer17, |
| }, { |
| texture: texture15, |
| mipLevel: 0, |
| origin: {x: 228, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 103, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let textureView79 = texture43.createView({mipLevelCount: 1}); |
| let renderPassEncoder16 = commandEncoder23.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView67, |
| clearValue: { r: -710.1, g: 439.6, b: -839.5, a: -115.8, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| maxDrawCount: 86115252, |
| }); |
| let sampler40 = device0.createSampler({addressModeU: 'repeat'}); |
| try { |
| renderPassEncoder15.setVertexBuffer(3, buffer38); |
| } catch {} |
| try { |
| renderBundleEncoder9.setVertexBuffer(6, buffer1, 1_712, 1_838); |
| } catch {} |
| try { |
| buffer12.unmap(); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer4]); |
| buffer29.destroy(); |
| } catch {} |
| try { |
| await promise6; |
| } catch {} |
| let videoFrame6 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX', timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte170m', primaries: 'jedecP22Phosphors', transfer: 'gamma28curve'} }); |
| let commandEncoder62 = device0.createCommandEncoder({}); |
| let computePassEncoder50 = commandEncoder62.beginComputePass({}); |
| let externalTexture4 = device0.importExternalTexture({source: videoFrame1, colorSpace: 'display-p3'}); |
| try { |
| computePassEncoder50.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder10.setBindGroup(0, bindGroup5); |
| } catch {} |
| try { |
| renderPassEncoder2.draw(156, 0, 1_907_823_602); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndirect(buffer52, 200); |
| } catch {} |
| try { |
| renderPassEncoder16.setIndexBuffer(buffer13, 'uint32', 224, 559); |
| } catch {} |
| try { |
| renderBundleEncoder8.setBindGroup(3, bindGroup11, []); |
| } catch {} |
| try { |
| renderBundleEncoder9.setIndexBuffer(buffer52, 'uint16', 468, 33); |
| } catch {} |
| try { |
| renderBundleEncoder9.setPipeline(pipeline10); |
| } catch {} |
| try { |
| await gc(); |
| buffer29.destroy(); |
| await gc(); |
| } catch {} |
| try { |
| commandEncoder61.copyTextureToTexture({ |
| texture: texture0, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'depth-only', |
| }, |
| { |
| texture: texture0, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'depth-only', |
| }, |
| {width: 246, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline15 = await device0.createRenderPipelineAsync({ |
| layout: pipelineLayout3, |
| fragment: { |
| module: shaderModule0, |
| constants: {}, |
| targets: [{ |
| format: 'rg8unorm', |
| blend: { |
| color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'}, |
| alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'}, |
| }, |
| writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED, |
| }], |
| }, |
| vertex: {module: shaderModule4, entryPoint: 'vertex3', constants: {}, buffers: []}, |
| primitive: {topology: 'triangle-strip', cullMode: 'front', unclippedDepth: true}, |
| }); |
| await gc(); |
| let texture79 = device0.createTexture({ |
| size: {width: 3760, height: 20, depthOrArrayLayers: 1}, |
| format: 'rgba8snorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture80 = device0.createTexture({ |
| size: {width: 940, height: 5, depthOrArrayLayers: 1}, |
| mipLevelCount: 3, |
| dimension: '2d', |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| try { |
| computePassEncoder24.end(); |
| } catch {} |
| try { |
| renderPassEncoder10.setScissorRect(319, 0, 21, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndexed(0, 0, 2, -1_206_657_170, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder7.setVertexBuffer(5, buffer32, 252, 262); |
| } catch {} |
| try { |
| renderBundleEncoder8.setBindGroup(3, bindGroup8, new Uint32Array(3310), 941, 0); |
| } catch {} |
| try { |
| renderBundleEncoder9.setVertexBuffer(1, buffer21, 3_664, 4_897); |
| } catch {} |
| let videoFrame7 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A', timestamp: 0, colorSpace: {fullRange: false, matrix: 'fcc', primaries: 'bt470bg', transfer: 'iec61966-2-1'} }); |
| let texture81 = device0.createTexture({ |
| size: {width: 32, height: 32, depthOrArrayLayers: 21}, |
| mipLevelCount: 1, |
| format: 'astc-8x8-unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderPassEncoder17 = commandEncoder22.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView36, |
| depthSlice: 29, |
| clearValue: { r: -642.8, g: 4.867, b: -627.9, a: 936.8, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet0, |
| maxDrawCount: 456257210, |
| }); |
| let sampler41 = device0.createSampler({ |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 88.62, |
| maxAnisotropy: 12, |
| }); |
| try { |
| computePassEncoder47.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(3, bindGroup21); |
| } catch {} |
| try { |
| renderPassEncoder15.setBindGroup(2, bindGroup22, new Uint32Array(1698), 309, 0); |
| } catch {} |
| try { |
| renderPassEncoder16.setViewport(50.28739921621562, 0.36440031198676737, 96.5280012780812, 0.2636675869432258, 0.6255790711552413, 0.8402284544791379); |
| } catch {} |
| try { |
| renderPassEncoder1.drawIndexed(0, 0, 2, 44_424_465); |
| } catch {} |
| try { |
| renderPassEncoder1.drawIndexedIndirect(buffer31, 784); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndirect(buffer1, 784); |
| } catch {} |
| try { |
| renderPassEncoder12.setIndexBuffer(buffer38, 'uint32', 176, 90); |
| } catch {} |
| try { |
| renderPassEncoder10.setVertexBuffer(1, buffer38); |
| } catch {} |
| let commandEncoder63 = device0.createCommandEncoder({}); |
| let texture82 = device0.createTexture({ |
| size: [10, 11, 8], |
| dimension: '3d', |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderPassEncoder18 = commandEncoder63.beginRenderPass({ |
| colorAttachments: [{view: textureView36, depthSlice: 117, loadOp: 'clear', storeOp: 'store'}], |
| maxDrawCount: 12753001, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder31); computePassEncoder31.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder35); computePassEncoder35.dispatchWorkgroupsIndirect(buffer47, 520); }; |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(0, bindGroup12); |
| } catch {} |
| try { |
| renderPassEncoder13.executeBundles([renderBundle3, renderBundle2, renderBundle2, renderBundle3]); |
| } catch {} |
| try { |
| renderPassEncoder1.drawIndirect(buffer47, 2_260); |
| } catch {} |
| try { |
| renderPassEncoder16.setIndexBuffer(buffer8, 'uint32', 216, 438); |
| } catch {} |
| try { |
| renderBundleEncoder8.setPipeline(pipeline15); |
| } catch {} |
| try { |
| renderBundleEncoder9.setVertexBuffer(1, buffer43, 292, 1); |
| } catch {} |
| try { |
| commandEncoder61.copyBufferToTexture({ |
| /* bytesInLastRow: 1088 widthInBlocks: 136 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 344 */ |
| offset: 344, |
| buffer: buffer56, |
| }, { |
| texture: texture24, |
| mipLevel: 0, |
| origin: {x: 19, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 136, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder61.resolveQuerySet(querySet4, 184, 11, buffer53, 0); |
| } catch {} |
| let pipeline16 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule0, constants: {}}}); |
| let bindGroup28 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout6, |
| entries: [ |
| {binding: 97, resource: externalTexture3}, |
| {binding: 64, resource: {buffer: buffer40, offset: 15872}}, |
| {binding: 68, resource: {buffer: buffer37, offset: 7680, size: 600}}, |
| {binding: 45, resource: {buffer: buffer16, offset: 256, size: 104}}, |
| ], |
| }); |
| let buffer57 = device0.createBuffer({ |
| size: 5022, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM, |
| }); |
| let commandEncoder64 = device0.createCommandEncoder({}); |
| let querySet5 = device0.createQuerySet({type: 'occlusion', count: 117}); |
| let texture83 = device0.createTexture({ |
| size: {width: 307, height: 7, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture84 = device0.createTexture({ |
| size: {width: 40, height: 45, depthOrArrayLayers: 1}, |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let renderBundle8 = renderBundleEncoder8.finish({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder31); computePassEncoder31.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder13); computePassEncoder13.dispatchWorkgroupsIndirect(buffer2, 236); }; |
| } catch {} |
| try { |
| renderPassEncoder1.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderBundleEncoder9.setBindGroup(1, bindGroup27, []); |
| } catch {} |
| try { |
| buffer39.unmap(); |
| } catch {} |
| let textureView80 = texture41.createView({mipLevelCount: 1}); |
| let renderPassEncoder19 = commandEncoder64.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView77, |
| clearValue: { r: -483.4, g: -730.3, b: 310.1, a: -710.7, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| computePassEncoder49.setBindGroup(3, bindGroup0); |
| } catch {} |
| try { |
| renderPassEncoder12.setBindGroup(0, bindGroup19); |
| } catch {} |
| try { |
| renderPassEncoder2.drawIndirect(buffer48, 376); |
| } catch {} |
| try { |
| renderPassEncoder7.setIndexBuffer(buffer56, 'uint16', 2, 791); |
| } catch {} |
| try { |
| renderPassEncoder2.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder8.setVertexBuffer(1, buffer21, 1_384, 9_585); |
| } catch {} |
| try { |
| renderBundleEncoder9.setBindGroup(1, bindGroup24, new Uint32Array(7260), 2_340, 0); |
| } catch {} |
| try { |
| commandEncoder61.copyTextureToBuffer({ |
| texture: texture66, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 82 widthInBlocks: 41 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 2152 */ |
| offset: 2152, |
| bytesPerRow: 2304, |
| rowsPerImage: 203, |
| buffer: buffer40, |
| }, {width: 41, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let img3 = await imageWithData(80, 118, '#10101010', '#20202020'); |
| let buffer58 = device0.createBuffer({size: 7009, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let commandEncoder65 = device0.createCommandEncoder(); |
| let texture85 = device0.createTexture({ |
| size: [615], |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture86 = device0.createTexture({ |
| size: {width: 1968, height: 1, depthOrArrayLayers: 67}, |
| mipLevelCount: 3, |
| dimension: '3d', |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder51 = commandEncoder61.beginComputePass(); |
| let sampler42 = device0.createSampler({ |
| label: '\u8998\u{1f9d1}\u{1f8bd}\udf0d\u3421\u05d9\u{1f733}\u2125\u02da', |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| lodMaxClamp: 92.07, |
| compare: 'less', |
| maxAnisotropy: 1, |
| }); |
| try { |
| computePassEncoder38.setBindGroup(0, bindGroup4); |
| } catch {} |
| try { |
| computePassEncoder51.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderPassEncoder19.setBindGroup(2, bindGroup25, []); |
| } catch {} |
| try { |
| renderPassEncoder1.drawIndirect(buffer32, 4_400); |
| } catch {} |
| try { |
| renderPassEncoder13.setIndexBuffer(buffer14, 'uint16', 1_458, 5_416); |
| } catch {} |
| try { |
| renderBundleEncoder9.setBindGroup(1, bindGroup12); |
| } catch {} |
| try { |
| renderBundleEncoder9.setIndexBuffer(buffer37, 'uint32', 1_136, 913); |
| } catch {} |
| try { |
| renderBundleEncoder9.setVertexBuffer(5, buffer37, 0, 2_332); |
| } catch {} |
| let arrayBuffer8 = buffer26.getMappedRange(48, 0); |
| try { |
| buffer38.unmap(); |
| } catch {} |
| try { |
| commandEncoder65.copyTextureToTexture({ |
| texture: texture77, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 25}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture80, |
| mipLevel: 0, |
| origin: {x: 130, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 24, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer57, 1264, new BigUint64Array(3274), 334, 304); |
| } catch {} |
| let imageData11 = new ImageData(16, 40); |
| let autogeneratedBindGroupLayout2 = pipeline16.getBindGroupLayout(0); |
| let commandEncoder66 = device0.createCommandEncoder({}); |
| let texture87 = device0.createTexture({ |
| size: [984, 1, 1], |
| mipLevelCount: 2, |
| format: 'depth32float-stencil8', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderPassEncoder20 = commandEncoder66.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView77, |
| clearValue: { r: -942.3, g: -591.3, b: -135.4, a: -794.0, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet5, |
| maxDrawCount: 313806939, |
| }); |
| try { |
| renderPassEncoder1.drawIndexedIndirect(buffer1, 1_700); |
| } catch {} |
| try { |
| renderBundleEncoder9.setBindGroup(0, bindGroup13); |
| } catch {} |
| try { |
| buffer48.unmap(); |
| } catch {} |
| try { |
| commandEncoder65.copyTextureToBuffer({ |
| texture: texture65, |
| mipLevel: 0, |
| origin: {x: 504, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 784 widthInBlocks: 49 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 2448 */ |
| offset: 2448, |
| bytesPerRow: 12288, |
| buffer: buffer33, |
| }, {width: 294, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(img3); |
| let textureView81 = texture85.createView({}); |
| let texture88 = device0.createTexture({ |
| size: [246, 1, 29], |
| format: 'r8uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder20.setBindGroup(2, bindGroup5, []); |
| } catch {} |
| try { |
| renderPassEncoder12.setBindGroup(0, bindGroup26); |
| } catch {} |
| try { |
| renderPassEncoder15.setBindGroup(1, bindGroup26, new Uint32Array(2629), 301, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.executeBundles([renderBundle4, renderBundle3, renderBundle1, renderBundle3, renderBundle1]); |
| } catch {} |
| try { |
| renderPassEncoder1.drawIndexed(1, 6, 1, -2_003_345_413, 1_403_539_600); |
| } catch {} |
| try { |
| renderPassEncoder1.drawIndirect(buffer1, 1_284); |
| } catch {} |
| try { |
| renderPassEncoder14.setIndexBuffer(buffer57, 'uint32', 156, 879); |
| } catch {} |
| let bindGroup29 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout5, |
| entries: [ |
| {binding: 77, resource: {buffer: buffer42, offset: 2048, size: 624}}, |
| {binding: 119, resource: textureView16}, |
| {binding: 33, resource: {buffer: buffer37, offset: 1024, size: 2452}}, |
| {binding: 54, resource: sampler22}, |
| {binding: 155, resource: externalTexture2}, |
| ], |
| }); |
| let commandEncoder67 = device0.createCommandEncoder({}); |
| let textureView82 = texture81.createView({dimension: 'cube-array', baseMipLevel: 0, baseArrayLayer: 1, arrayLayerCount: 6}); |
| let texture89 = device0.createTexture({ |
| size: {width: 1230, height: 30, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView83 = texture81.createView({dimension: '2d', baseArrayLayer: 11, arrayLayerCount: 1}); |
| let computePassEncoder52 = commandEncoder65.beginComputePass({}); |
| try { |
| computePassEncoder31.setBindGroup(0, bindGroup25, new Uint32Array(500), 8, 0); |
| } catch {} |
| try { |
| computePassEncoder13.end(); |
| } catch {} |
| try { |
| renderPassEncoder1.drawIndexed(0, 176, 1, 297_812_143, 353_210_029); |
| } catch {} |
| try { |
| renderPassEncoder1.drawIndirect(buffer14, 7_184); |
| } catch {} |
| try { |
| renderPassEncoder7.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderBundleEncoder9.setIndexBuffer(buffer8, 'uint32', 312, 79); |
| } catch {} |
| try { |
| renderBundleEncoder9.setVertexBuffer(2, buffer24, 0, 17); |
| } catch {} |
| let imageBitmap0 = await createImageBitmap(videoFrame7); |
| let commandEncoder68 = device0.createCommandEncoder(); |
| let texture90 = device0.createTexture({ |
| size: {width: 40, height: 45, depthOrArrayLayers: 45}, |
| format: 'rgba8snorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder53 = commandEncoder67.beginComputePass({}); |
| let renderBundle9 = renderBundleEncoder9.finish({}); |
| try { |
| computePassEncoder33.setBindGroup(0, bindGroup26, new Uint32Array(3913), 103, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder12); computePassEncoder12.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder1.end(); |
| } catch {} |
| try { |
| adapter0.label = '\u{1fd3e}\u01bc\u13d6\u0bf6\u{1f859}\ub106'; |
| } catch {} |
| let buffer59 = device0.createBuffer({size: 6103, usage: GPUBufferUsage.MAP_READ}); |
| let commandEncoder69 = device0.createCommandEncoder({}); |
| let texture91 = device0.createTexture({ |
| size: {width: 10, height: 11, depthOrArrayLayers: 1}, |
| sampleCount: 1, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer57, 'uint16', 1_042, 52); |
| } catch {} |
| try { |
| renderPassEncoder17.setPipeline(pipeline2); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| let arrayBuffer9 = buffer26.getMappedRange(64, 72); |
| document.body.prepend(img1); |
| let bindGroup30 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout3, |
| entries: [ |
| {binding: 323, resource: {buffer: buffer37, offset: 256, size: 2460}}, |
| {binding: 144, resource: textureView2}, |
| ], |
| }); |
| let commandBuffer5 = commandEncoder10.finish(); |
| let textureView84 = texture79.createView({dimension: '2d-array', baseArrayLayer: 0}); |
| let texture92 = device0.createTexture({ |
| size: {width: 80, height: 90, depthOrArrayLayers: 1}, |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let computePassEncoder54 = commandEncoder68.beginComputePass({}); |
| try { |
| computePassEncoder35.setBindGroup(2, bindGroup26, new Uint32Array(1524), 243, 0); |
| } catch {} |
| try { |
| computePassEncoder54.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderPassEncoder13.setBindGroup(1, bindGroup22); |
| } catch {} |
| try { |
| renderPassEncoder13.setIndexBuffer(buffer0, 'uint32', 616, 14); |
| } catch {} |
| try { |
| buffer0.unmap(); |
| } catch {} |
| try { |
| commandEncoder25.copyBufferToTexture({ |
| /* bytesInLastRow: 984 widthInBlocks: 984 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 4040 */ |
| offset: 4040, |
| bytesPerRow: 14848, |
| buffer: buffer48, |
| }, { |
| texture: texture87, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'stencil-only', |
| }, {width: 984, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline17 = device0.createRenderPipeline({ |
| layout: pipelineLayout2, |
| fragment: { |
| module: shaderModule2, |
| constants: {}, |
| targets: [{ |
| format: 'rg8unorm', |
| blend: { |
| color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'}, |
| alpha: {operation: 'subtract', srcFactor: 'one-minus-dst', dstFactor: 'src'}, |
| }, |
| writeMask: GPUColorWrite.RED, |
| }], |
| }, |
| vertex: { |
| module: shaderModule6, |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 208, |
| attributes: [ |
| {format: 'uint16x4', offset: 0, shaderLocation: 4}, |
| {format: 'uint16x4', offset: 24, shaderLocation: 3}, |
| {format: 'sint32', offset: 24, shaderLocation: 12}, |
| {format: 'float16x2', offset: 56, shaderLocation: 7}, |
| {format: 'uint32', offset: 20, shaderLocation: 14}, |
| {format: 'snorm16x4', offset: 48, shaderLocation: 9}, |
| ], |
| }, |
| ], |
| }, |
| }); |
| let bindGroup31 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout1, |
| entries: [ |
| {binding: 144, resource: textureView5}, |
| {binding: 323, resource: {buffer: buffer16, offset: 0, size: 924}}, |
| ], |
| }); |
| let pipelineLayout9 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout3]}); |
| let commandEncoder70 = device0.createCommandEncoder(); |
| let texture93 = device0.createTexture({ |
| size: [40, 45, 1], |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture94 = device0.createTexture({ |
| size: [246, 1, 38], |
| format: 'r8uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView85 = texture42.createView({dimension: '2d', baseMipLevel: 0, mipLevelCount: 1, baseArrayLayer: 7}); |
| let computePassEncoder55 = commandEncoder70.beginComputePass(); |
| let sampler43 = device0.createSampler({addressModeV: 'repeat', lodMinClamp: 76.47, lodMaxClamp: 90.37, compare: 'never'}); |
| try { |
| computePassEncoder14.setBindGroup(3, bindGroup29); |
| } catch {} |
| try { |
| computePassEncoder9.setBindGroup(2, bindGroup5, new Uint32Array(2481), 992, 0); |
| } catch {} |
| try { |
| computePassEncoder55.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder8.setIndexBuffer(buffer22, 'uint32', 1_408, 186); |
| } catch {} |
| try { |
| renderPassEncoder16.setPipeline(pipeline0); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({device: device0, format: 'bgra8unorm', usage: GPUTextureUsage.STORAGE_BINDING}); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture24, |
| mipLevel: 0, |
| origin: {x: 257, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(297).fill(201), /* required buffer size: 297 */ |
| {offset: 297, bytesPerRow: 407}, {width: 50, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline18 = device0.createComputePipeline({layout: pipelineLayout1, compute: {module: shaderModule2, constants: {}}}); |
| let commandEncoder71 = device0.createCommandEncoder({}); |
| let textureView86 = texture91.createView({dimension: '2d-array', format: 'rgba16float', baseArrayLayer: 0}); |
| let computePassEncoder56 = commandEncoder25.beginComputePass(); |
| try { |
| computePassEncoder44.setBindGroup(0, bindGroup4); |
| } catch {} |
| try { |
| computePassEncoder56.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(1, bindGroup8); |
| } catch {} |
| try { |
| renderPassEncoder18.setVertexBuffer(6, buffer21, 0, 1_930); |
| } catch {} |
| let arrayBuffer10 = buffer26.getMappedRange(192, 4); |
| let bindGroup32 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout9, |
| entries: [{binding: 323, resource: {buffer: buffer42, offset: 768}}, {binding: 144, resource: textureView2}], |
| }); |
| let commandEncoder72 = device0.createCommandEncoder({}); |
| let textureView87 = texture81.createView({dimension: 'cube'}); |
| let computePassEncoder57 = commandEncoder72.beginComputePass({}); |
| let renderPassEncoder21 = commandEncoder69.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView36, |
| depthSlice: 130, |
| clearValue: { r: -855.4, g: 374.1, b: 446.7, a: 706.0, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| maxDrawCount: 200863693, |
| }); |
| try { |
| computePassEncoder37.setBindGroup(0, bindGroup31); |
| } catch {} |
| try { |
| computePassEncoder49.setBindGroup(2, bindGroup16, new Uint32Array(3617), 1_157, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder12); computePassEncoder12.dispatchWorkgroupsIndirect(buffer12, 4_776); }; |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(2, bindGroup24); |
| } catch {} |
| try { |
| renderPassEncoder15.setIndexBuffer(buffer1, 'uint16', 5_976, 435); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer5]); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture12, |
| mipLevel: 0, |
| origin: {x: 26, y: 0, z: 118}, |
| aspect: 'all', |
| }, new Uint8Array(74_493).fill(205), /* required buffer size: 74_493 */ |
| {offset: 255, bytesPerRow: 160, rowsPerImage: 66}, {width: 79, height: 2, depthOrArrayLayers: 8}); |
| } catch {} |
| let commandEncoder73 = device0.createCommandEncoder({}); |
| let texture95 = device0.createTexture({ |
| size: [1230, 30, 1], |
| format: 'rg32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView88 = texture74.createView({dimension: '1d', format: 'rg8unorm'}); |
| let computePassEncoder58 = commandEncoder71.beginComputePass(); |
| try { |
| computePassEncoder32.setBindGroup(2, bindGroup16); |
| } catch {} |
| try { |
| computePassEncoder8.setBindGroup(2, bindGroup11, new Uint32Array(946), 8, 0); |
| } catch {} |
| try { |
| computePassEncoder57.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder9.setBindGroup(0, bindGroup26); |
| } catch {} |
| try { |
| renderPassEncoder16.executeBundles([renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder18.setPipeline(pipeline4); |
| } catch {} |
| let commandEncoder74 = device0.createCommandEncoder({}); |
| let querySet6 = device0.createQuerySet({type: 'occlusion', count: 150}); |
| let textureView89 = texture91.createView({dimension: '2d-array', format: 'rgba16float', mipLevelCount: 1}); |
| let renderPassEncoder22 = commandEncoder73.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView46, |
| clearValue: { r: 132.0, g: -522.7, b: 942.1, a: -680.9, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet1, |
| }); |
| try { |
| commandEncoder74.copyBufferToBuffer(buffer10, 13000, buffer53, 104, 132); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer19, 548, new Float32Array(9351), 854, 196); |
| } catch {} |
| let querySet7 = device0.createQuerySet({type: 'occlusion', count: 359}); |
| let textureView90 = texture82.createView({baseArrayLayer: 0}); |
| let renderPassEncoder23 = commandEncoder74.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView55, |
| clearValue: { r: -847.1, g: -288.0, b: 462.9, a: 715.3, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| renderPassEncoder12.setBindGroup(1, bindGroup27, []); |
| } catch {} |
| try { |
| renderPassEncoder20.setPipeline(pipeline14); |
| } catch {} |
| document.body.prepend(img2); |
| let bindGroup33 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout10, |
| entries: [ |
| {binding: 45, resource: {buffer: buffer2, offset: 0}}, |
| {binding: 97, resource: externalTexture4}, |
| {binding: 68, resource: {buffer: buffer5, offset: 1536, size: 2184}}, |
| {binding: 64, resource: {buffer: buffer40, offset: 2048}}, |
| ], |
| }); |
| let texture96 = device0.createTexture({ |
| size: {width: 492, height: 1, depthOrArrayLayers: 46}, |
| mipLevelCount: 3, |
| format: 'depth24plus-stencil8', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture97 = device0.createTexture({ |
| size: {width: 153, height: 3, depthOrArrayLayers: 1}, |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let texture98 = gpuCanvasContext0.getCurrentTexture(); |
| let externalTexture5 = device0.importExternalTexture({source: videoFrame3}); |
| try { |
| computePassEncoder2.end(); |
| } catch {} |
| try { |
| renderPassEncoder2.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder9.setVertexBuffer(6, buffer14, 12_684); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture73, |
| mipLevel: 0, |
| origin: {x: 11, y: 4, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(215).fill(129), /* required buffer size: 215 */ |
| {offset: 215, bytesPerRow: 467}, {width: 444, height: 6, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup34 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout0, |
| entries: [ |
| {binding: 144, resource: textureView2}, |
| {binding: 323, resource: {buffer: buffer42, offset: 256, size: 2352}}, |
| ], |
| }); |
| let buffer60 = device0.createBuffer({ |
| size: 7883, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let textureView91 = texture41.createView({}); |
| let computePassEncoder59 = commandEncoder0.beginComputePass({}); |
| let externalTexture6 = device0.importExternalTexture({source: videoFrame3}); |
| try { |
| computePassEncoder1.end(); |
| } catch {} |
| try { |
| computePassEncoder53.setPipeline(pipeline16); |
| } catch {} |
| try { |
| commandEncoder2.copyBufferToTexture({ |
| /* bytesInLastRow: 1304 widthInBlocks: 163 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 3744 */ |
| offset: 3744, |
| buffer: buffer57, |
| }, { |
| texture: texture46, |
| mipLevel: 0, |
| origin: {x: 66, y: 1, z: 0}, |
| aspect: 'all', |
| }, {width: 163, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer19, 3224, new DataView(new ArrayBuffer(7629)), 1153, 572); |
| } catch {} |
| document.body.append(img3); |
| let autogeneratedBindGroupLayout3 = pipeline4.getBindGroupLayout(0); |
| let bindGroup35 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 41, resource: textureView53}, |
| {binding: 39, resource: {buffer: buffer5, offset: 2560, size: 2240}}, |
| ], |
| }); |
| let texture99 = device0.createTexture({ |
| size: {width: 153, height: 3, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView92 = texture31.createView({format: 'rg8unorm'}); |
| let renderPassEncoder24 = commandEncoder2.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView67, |
| clearValue: { r: -964.2, g: 571.1, b: -249.3, a: -917.7, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet4, |
| }); |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 80, height: 90, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData3, |
| origin: { x: 0, y: 1 }, |
| flipY: true, |
| }, { |
| texture: texture92, |
| mipLevel: 0, |
| origin: {x: 14, y: 18, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 17, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture100 = device0.createTexture({ |
| size: {width: 153, height: 3, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder56.setBindGroup(3, bindGroup13); |
| } catch {} |
| try { |
| computePassEncoder19.setBindGroup(3, bindGroup0, new Uint32Array(852), 263, 0); |
| } catch {} |
| try { |
| computePassEncoder58.setPipeline(pipeline13); |
| } catch {} |
| try { |
| renderPassEncoder17.setBindGroup(2, bindGroup13, new Uint32Array(5610), 1_268, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.executeBundles([renderBundle1, renderBundle1, renderBundle4]); |
| } catch {} |
| try { |
| renderPassEncoder13.setPipeline(pipeline7); |
| } catch {} |
| let videoFrame8 = new VideoFrame(img1, {timestamp: 0}); |
| let texture101 = device0.createTexture({ |
| size: {width: 153, height: 3, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'r8uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder49.setBindGroup(2, bindGroup0); |
| } catch {} |
| try { |
| computePassEncoder52.setPipeline(pipeline18); |
| } catch {} |
| try { |
| renderPassEncoder19.setBindGroup(2, bindGroup29); |
| } catch {} |
| try { |
| renderPassEncoder23.executeBundles([renderBundle3]); |
| } catch {} |
| try { |
| renderPassEncoder14.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder14.setVertexBuffer(6, buffer51, 0, 15); |
| } catch {} |
| let arrayBuffer11 = buffer26.getMappedRange(152, 12); |
| let promise7 = device0.queue.onSubmittedWorkDone(); |
| let pipeline19 = device0.createComputePipeline({layout: pipelineLayout9, compute: {module: shaderModule3}}); |
| try { |
| adapter0.label = '\u{1fc64}\u0975\u78ef\u{1fac7}\u0a75\u{1facf}\u5ae8\u625a\u{1fd29}\u01e9\u95d6'; |
| } catch {} |
| let recycledExplicitBindGroupLayout3 = pipeline3.getBindGroupLayout(0); |
| let buffer61 = device0.createBuffer({size: 3256, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let commandEncoder75 = device0.createCommandEncoder({}); |
| let texture102 = device0.createTexture({ |
| size: [307, 7, 1], |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderPassEncoder25 = commandEncoder75.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView36, |
| depthSlice: 153, |
| clearValue: { r: -340.2, g: -940.2, b: -657.0, a: -885.9, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| computePassEncoder8.setBindGroup(0, bindGroup9, new Uint32Array(835), 45, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder8); computePassEncoder8.dispatchWorkgroupsIndirect(buffer7, 24); }; |
| } catch {} |
| try { |
| renderPassEncoder2.beginOcclusionQuery(62); |
| } catch {} |
| try { |
| renderPassEncoder22.executeBundles([renderBundle0, renderBundle7]); |
| } catch {} |
| try { |
| renderPassEncoder10.setPipeline(pipeline7); |
| } catch {} |
| let videoFrame9 = new VideoFrame(img1, {timestamp: 0}); |
| let commandEncoder76 = device0.createCommandEncoder({}); |
| let texture103 = device0.createTexture({ |
| size: [20, 22, 28], |
| mipLevelCount: 1, |
| sampleCount: 1, |
| format: 'r32sint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView93 = texture89.createView({mipLevelCount: 1}); |
| try { |
| computePassEncoder23.setPipeline(pipeline9); |
| } catch {} |
| try { |
| computePassEncoder59.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder2.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder16.executeBundles([renderBundle1]); |
| } catch {} |
| try { |
| renderPassEncoder25.setVertexBuffer(4, buffer5, 0); |
| } catch {} |
| try { |
| await buffer28.mapAsync(GPUMapMode.READ, 0, 4824); |
| } catch {} |
| try { |
| commandEncoder76.copyTextureToTexture({ |
| texture: texture60, |
| mipLevel: 0, |
| origin: {x: 18, y: 20, z: 3}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture3, |
| mipLevel: 0, |
| origin: {x: 71, y: 0, z: 316}, |
| aspect: 'all', |
| }, |
| {width: 14, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let videoFrame10 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt709', primaries: 'bt2020', transfer: 'smpte170m'} }); |
| let autogeneratedBindGroupLayout4 = pipeline14.getBindGroupLayout(0); |
| let bindGroup36 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout13, |
| entries: [ |
| {binding: 41, resource: textureView53}, |
| {binding: 39, resource: {buffer: buffer7, offset: 0, size: 476}}, |
| ], |
| }); |
| let texture104 = device0.createTexture({ |
| size: [307, 7, 1], |
| mipLevelCount: 2, |
| format: 'r32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture105 = device0.createTexture({ |
| size: [307, 7, 386], |
| dimension: '3d', |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView94 = texture87.createView({ |
| label: '\u5f9c\u{1fd00}\ufb50\u0e46\u8c65\u45eb', |
| baseMipLevel: 0, |
| mipLevelCount: 1, |
| arrayLayerCount: 1, |
| }); |
| try { |
| computePassEncoder12.end(); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(1, bindGroup34); |
| } catch {} |
| try { |
| renderPassEncoder21.setIndexBuffer(buffer1, 'uint16', 4_100, 3_376); |
| } catch {} |
| try { |
| commandEncoder12.copyBufferToTexture({ |
| /* bytesInLastRow: 44 widthInBlocks: 11 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 444 */ |
| offset: 444, |
| bytesPerRow: 512, |
| buffer: buffer15, |
| }, { |
| texture: texture21, |
| mipLevel: 0, |
| origin: {x: 14, y: 18, z: 0}, |
| aspect: 'all', |
| }, {width: 11, height: 6, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder76.resolveQuerySet(querySet0, 7, 20, buffer19, 256); |
| } catch {} |
| document.body.append(img3); |
| let buffer62 = device0.createBuffer({ |
| size: 5435, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let texture106 = device0.createTexture({ |
| size: [10, 11, 29], |
| mipLevelCount: 1, |
| format: 'rg16sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder60 = commandEncoder76.beginComputePass(); |
| try { |
| computePassEncoder29.setPipeline(pipeline13); |
| } catch {} |
| try { |
| renderPassEncoder2.end(); |
| } catch {} |
| try { |
| renderPassEncoder11.executeBundles([renderBundle1, renderBundle1, renderBundle4, renderBundle0, renderBundle4, renderBundle7, renderBundle4, renderBundle9, renderBundle1]); |
| } catch {} |
| try { |
| renderPassEncoder11.setPipeline(pipeline10); |
| } catch {} |
| try { |
| commandEncoder12.copyBufferToTexture({ |
| /* bytesInLastRow: 12 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1780 */ |
| offset: 1780, |
| bytesPerRow: 5632, |
| buffer: buffer12, |
| }, { |
| texture: texture25, |
| mipLevel: 0, |
| origin: {x: 37, y: 26, z: 0}, |
| aspect: 'all', |
| }, {width: 3, height: 20, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup37 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [{binding: 323, resource: {buffer: buffer12, offset: 7680}}, {binding: 144, resource: textureView2}], |
| }); |
| let commandEncoder77 = device0.createCommandEncoder({}); |
| let texture107 = device0.createTexture({ |
| size: [470, 2, 1], |
| mipLevelCount: 4, |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView95 = texture85.createView({dimension: '1d', mipLevelCount: 1}); |
| try { |
| computePassEncoder51.setBindGroup(0, bindGroup9, new Uint32Array(427), 3, 0); |
| } catch {} |
| try { |
| renderPassEncoder18.setVertexBuffer(1, buffer32); |
| } catch {} |
| try { |
| await promise7; |
| } catch {} |
| let img4 = await imageWithData(16, 1, '#10101010', '#20202020'); |
| let commandEncoder78 = device0.createCommandEncoder({}); |
| let texture108 = device0.createTexture({ |
| size: {width: 40, height: 45, depthOrArrayLayers: 1}, |
| mipLevelCount: 4, |
| sampleCount: 1, |
| format: 'rg16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture109 = device0.createTexture({ |
| size: [80, 90, 69], |
| dimension: '3d', |
| format: 'r8uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder61 = commandEncoder78.beginComputePass({}); |
| let sampler44 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'repeat', lodMaxClamp: 44.91}); |
| try { |
| computePassEncoder48.setBindGroup(0, bindGroup25, new Uint32Array(1540), 89, 0); |
| } catch {} |
| try { |
| computePassEncoder60.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderPassEncoder22.executeBundles([renderBundle4, renderBundle9, renderBundle6, renderBundle9, renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder11.setIndexBuffer(buffer22, 'uint16', 1_434, 344); |
| } catch {} |
| try { |
| renderPassEncoder9.setVertexBuffer(3, buffer22, 88, 12); |
| } catch {} |
| let bindGroup38 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout10, |
| entries: [ |
| {binding: 68, resource: {buffer: buffer47, offset: 6144, size: 804}}, |
| {binding: 97, resource: externalTexture6}, |
| {binding: 64, resource: {buffer: buffer47, offset: 7168, size: 148}}, |
| {binding: 45, resource: {buffer: buffer57, offset: 512, size: 1717}}, |
| ], |
| }); |
| let pipelineLayout10 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout10]}); |
| let buffer63 = device0.createBuffer({ |
| size: 8031, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE, |
| }); |
| let texture110 = device0.createTexture({ |
| size: [470, 2, 1], |
| mipLevelCount: 2, |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderPassEncoder26 = commandEncoder77.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView36, |
| depthSlice: 157, |
| clearValue: { r: -185.9, g: -185.4, b: -708.4, a: -601.6, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet4, |
| maxDrawCount: 113017289, |
| }); |
| try { |
| computePassEncoder19.setBindGroup(2, bindGroup0, new Uint32Array(1666), 45, 0); |
| } catch {} |
| try { |
| renderPassEncoder23.setBindGroup(1, bindGroup17); |
| } catch {} |
| try { |
| renderPassEncoder18.executeBundles([renderBundle2]); |
| } catch {} |
| let buffer64 = device0.createBuffer({size: 10161, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let commandEncoder79 = device0.createCommandEncoder({}); |
| let querySet8 = device0.createQuerySet({type: 'occlusion', count: 53}); |
| let texture111 = device0.createTexture({ |
| label: '\ud601\u7282\u5206\u6c2b\u{1fb81}\uc8d7\u9085\u{1fe06}\u2262\u75ba', |
| size: {width: 246, height: 1, depthOrArrayLayers: 9}, |
| mipLevelCount: 2, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder62 = commandEncoder79.beginComputePass(); |
| let sampler45 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| compare: 'always', |
| }); |
| try { |
| computePassEncoder21.setBindGroup(0, bindGroup26); |
| } catch {} |
| try { |
| computePassEncoder62.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder26.setBindGroup(0, bindGroup1, new Uint32Array(3460), 350, 0); |
| } catch {} |
| try { |
| renderPassEncoder16.setIndexBuffer(buffer57, 'uint32', 1_296, 441); |
| } catch {} |
| try { |
| commandEncoder12.clearBuffer(buffer23); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture14, |
| mipLevel: 0, |
| origin: {x: 133, y: 0, z: 3}, |
| aspect: 'all', |
| }, new Uint8Array(39_321).fill(68), /* required buffer size: 39_321 */ |
| {offset: 9, bytesPerRow: 504, rowsPerImage: 39}, {width: 125, height: 0, depthOrArrayLayers: 3}); |
| } catch {} |
| let pipelineLayout11 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout2]}); |
| let buffer65 = device0.createBuffer({ |
| label: '\u7713\u62ce\u4469\u35db\u65ab\u0a47\u{1f6ca}', |
| size: 8803, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let texture112 = device0.createTexture({ |
| size: [246, 1, 1], |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture113 = device0.createTexture({ |
| size: [20, 22, 70], |
| mipLevelCount: 1, |
| format: 'r8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder31); computePassEncoder31.dispatchWorkgroupsIndirect(buffer2, 152); }; |
| } catch {} |
| try { |
| computePassEncoder6.end(); |
| } catch {} |
| try { |
| computePassEncoder61.setPipeline(pipeline13); |
| } catch {} |
| try { |
| renderPassEncoder25.setBindGroup(2, bindGroup29, new Uint32Array(2394), 582, 0); |
| } catch {} |
| try { |
| renderPassEncoder21.setPipeline(pipeline12); |
| } catch {} |
| let imageData12 = new ImageData(32, 28); |
| try { |
| device0.label = '\udddb\u0c7e\u0f37\u0754\u07d9\ue034\u{1fa4b}'; |
| } catch {} |
| let texture114 = device0.createTexture({ |
| size: [3760, 20, 1], |
| mipLevelCount: 5, |
| sampleCount: 1, |
| dimension: '2d', |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder13.setVertexBuffer(4, buffer37, 0, 3_389); |
| } catch {} |
| let veryExplicitBindGroupLayout14 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 21, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '2d-array' }, |
| }, |
| ], |
| }); |
| let texture115 = device0.createTexture({ |
| size: {width: 32, height: 32, depthOrArrayLayers: 21}, |
| format: 'rgba32uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder63 = commandEncoder12.beginComputePass({}); |
| try { |
| renderPassEncoder19.setBindGroup(2, bindGroup25, new Uint32Array(3512), 1_098, 0); |
| } catch {} |
| try { |
| commandEncoder26.copyBufferToTexture({ |
| /* bytesInLastRow: 16 widthInBlocks: 4 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 516 */ |
| offset: 516, |
| bytesPerRow: 95232, |
| buffer: buffer42, |
| }, { |
| texture: texture21, |
| mipLevel: 0, |
| origin: {x: 0, y: 31, z: 0}, |
| aspect: 'all', |
| }, {width: 4, height: 4, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder8.copyTextureToTexture({ |
| texture: texture65, |
| mipLevel: 0, |
| origin: {x: 102, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture65, |
| mipLevel: 0, |
| origin: {x: 102, y: 6, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 96, height: 6, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder80 = device0.createCommandEncoder({}); |
| let textureView96 = texture115.createView({dimension: 'cube-array', format: 'rgba32uint', mipLevelCount: 1, baseArrayLayer: 3, arrayLayerCount: 6}); |
| let texture116 = device0.createTexture({ |
| size: {width: 615, height: 15, depthOrArrayLayers: 1}, |
| dimension: '2d', |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder64 = commandEncoder26.beginComputePass({}); |
| let renderPassEncoder27 = commandEncoder8.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView55, |
| clearValue: { r: 694.4, g: 364.4, b: 149.2, a: -739.7, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet1, |
| maxDrawCount: 282124339, |
| }); |
| try { |
| renderPassEncoder23.setIndexBuffer(buffer60, 'uint16', 570, 170); |
| } catch {} |
| try { |
| renderPassEncoder16.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder23.setVertexBuffer(3, buffer24); |
| } catch {} |
| let commandEncoder81 = device0.createCommandEncoder({}); |
| let texture117 = device0.createTexture({ |
| size: [40, 45, 68], |
| format: 'rg32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView97 = texture1.createView({}); |
| let computePassEncoder65 = commandEncoder81.beginComputePass({}); |
| let sampler46 = device0.createSampler({addressModeU: 'repeat', addressModeW: 'repeat', lodMaxClamp: 88.09}); |
| try { |
| computePassEncoder64.setPipeline(pipeline11); |
| } catch {} |
| try { |
| renderPassEncoder19.setPipeline(pipeline8); |
| } catch {} |
| try { |
| commandEncoder80.copyBufferToTexture({ |
| /* bytesInLastRow: 90 widthInBlocks: 45 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 154 */ |
| offset: 154, |
| bytesPerRow: 14592, |
| buffer: buffer50, |
| }, { |
| texture: texture10, |
| mipLevel: 0, |
| origin: {x: 5, y: 2, z: 0}, |
| aspect: 'all', |
| }, {width: 45, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let commandEncoder82 = device0.createCommandEncoder(); |
| let texture118 = device0.createTexture({ |
| size: {width: 1880, height: 10, depthOrArrayLayers: 1}, |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView98 = texture31.createView({}); |
| let computePassEncoder66 = commandEncoder80.beginComputePass({}); |
| let sampler47 = device0.createSampler({ |
| label: '\u0018\u3e90\u{1f86d}\u7d22\u{1fe49}\u5eaf', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'nearest', |
| lodMaxClamp: 88.90, |
| }); |
| try { |
| renderPassEncoder26.setBindGroup(1, bindGroup6); |
| } catch {} |
| try { |
| renderPassEncoder9.setVertexBuffer(0, buffer55); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| commandEncoder82.copyBufferToTexture({ |
| /* bytesInLastRow: 224 widthInBlocks: 28 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 400 */ |
| offset: 400, |
| bytesPerRow: 22272, |
| buffer: buffer48, |
| }, { |
| texture: texture46, |
| mipLevel: 0, |
| origin: {x: 35, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 28, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let bindGroup39 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 41, resource: textureView53}, |
| {binding: 39, resource: {buffer: buffer32, offset: 0, size: 2824}}, |
| ], |
| }); |
| let commandEncoder83 = device0.createCommandEncoder(); |
| let texture119 = device0.createTexture({ |
| size: [1968, 1, 1], |
| format: 'rg16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture120 = device0.createTexture({ |
| size: {width: 1968, height: 1, depthOrArrayLayers: 140}, |
| mipLevelCount: 2, |
| dimension: '2d', |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| renderPassEncoder16.setBindGroup(1, bindGroup29, new Uint32Array(2092), 607, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.draw(326, 0, 164_228_066); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndexedIndirect(buffer42, 1_364); |
| } catch {} |
| try { |
| renderPassEncoder9.drawIndirect(buffer31, 440); |
| } catch {} |
| try { |
| renderPassEncoder22.setIndexBuffer(buffer62, 'uint32', 3_204); |
| } catch {} |
| try { |
| commandEncoder83.copyTextureToBuffer({ |
| texture: texture83, |
| mipLevel: 0, |
| origin: {x: 29, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 320 widthInBlocks: 40 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 152 */ |
| offset: 152, |
| rowsPerImage: 566, |
| buffer: buffer33, |
| }, {width: 40, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let texture121 = device0.createTexture({ |
| size: {width: 10, height: 11, depthOrArrayLayers: 1}, |
| format: 'r32sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture122 = device0.createTexture({ |
| size: [3760], |
| dimension: '1d', |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView99 = texture94.createView({mipLevelCount: 1, baseArrayLayer: 2, arrayLayerCount: 1}); |
| let computePassEncoder67 = commandEncoder83.beginComputePass(); |
| let renderPassEncoder28 = commandEncoder82.beginRenderPass({colorAttachments: [{view: textureView93, loadOp: 'clear', storeOp: 'discard'}]}); |
| try { |
| computePassEncoder25.setBindGroup(1, bindGroup24, new Uint32Array(1028), 49, 0); |
| } catch {} |
| try { |
| computePassEncoder66.setPipeline(pipeline18); |
| } catch {} |
| try { |
| renderPassEncoder9.end(); |
| } catch {} |
| try { |
| renderPassEncoder17.beginOcclusionQuery(1); |
| } catch {} |
| try { |
| renderPassEncoder14.executeBundles([renderBundle6, renderBundle8, renderBundle4]); |
| } catch {} |
| try { |
| commandEncoder43.copyTextureToTexture({ |
| texture: texture48, |
| mipLevel: 5, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture50, |
| mipLevel: 0, |
| origin: {x: 98, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder43.clearBuffer(buffer40); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer53, 276, new DataView(new ArrayBuffer(12847)), 1163, 168); |
| } catch {} |
| let veryExplicitBindGroupLayout15 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 183, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let commandEncoder84 = device0.createCommandEncoder({}); |
| let texture123 = device0.createTexture({ |
| size: [153, 3, 1], |
| mipLevelCount: 2, |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let externalTexture7 = device0.importExternalTexture({source: videoFrame5}); |
| try { |
| computePassEncoder63.setPipeline(pipeline19); |
| } catch {} |
| try { |
| renderPassEncoder17.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder23.setIndexBuffer(buffer62, 'uint16', 480, 19); |
| } catch {} |
| try { |
| renderPassEncoder7.setVertexBuffer(3, buffer1); |
| } catch {} |
| try { |
| commandEncoder43.copyBufferToBuffer(buffer33, 628, buffer65, 844, 896); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let bindGroup40 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout8, |
| entries: [ |
| {binding: 166, resource: {buffer: buffer57, offset: 768, size: 824}}, |
| {binding: 125, resource: textureView61}, |
| ], |
| }); |
| let buffer66 = device0.createBuffer({size: 30408, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE}); |
| let commandEncoder85 = device0.createCommandEncoder({}); |
| let texture124 = device0.createTexture({ |
| size: {width: 20, height: 22, depthOrArrayLayers: 33}, |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView100 = texture13.createView({dimension: '2d', baseArrayLayer: 15, arrayLayerCount: 1}); |
| let computePassEncoder68 = commandEncoder84.beginComputePass({}); |
| let renderPassEncoder29 = commandEncoder43.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView67, |
| clearValue: { r: -821.8, g: 514.4, b: 395.0, a: -802.7, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| }); |
| let sampler48 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| lodMaxClamp: 99.29, |
| }); |
| try { |
| computePassEncoder65.setBindGroup(2, bindGroup26); |
| } catch {} |
| try { |
| computePassEncoder41.setPipeline(pipeline18); |
| } catch {} |
| try { |
| renderPassEncoder26.setBindGroup(2, bindGroup16, new Uint32Array(558), 197, 0); |
| } catch {} |
| try { |
| renderPassEncoder10.setViewport(255.7142562674074, 0.006477133565259585, 511.33464688516983, 0.3142693230289368, 0.6169244098550516, 0.865015494021779); |
| } catch {} |
| try { |
| renderPassEncoder11.setPipeline(pipeline2); |
| } catch {} |
| let buffer67 = device0.createBuffer({ |
| size: 4973, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM, |
| }); |
| let texture125 = device0.createTexture({ |
| size: [984, 1, 1], |
| mipLevelCount: 2, |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder69 = commandEncoder85.beginComputePass(); |
| try { |
| { clearResourceUsages(device0, computePassEncoder51); computePassEncoder51.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder18); computePassEncoder18.dispatchWorkgroupsIndirect(buffer47, 460); }; |
| } catch {} |
| try { |
| computePassEncoder8.end(); |
| } catch {} |
| try { |
| computePassEncoder69.setPipeline(pipeline18); |
| } catch {} |
| try { |
| renderPassEncoder7.executeBundles([renderBundle6]); |
| } catch {} |
| try { |
| renderPassEncoder10.setViewport(204.43655821118082, 0.0135238988219889, 445.00026974789597, 0.7612203188600888, 0.30354488976725613, 0.816936146327412); |
| } catch {} |
| try { |
| renderPassEncoder22.setPipeline(pipeline2); |
| } catch {} |
| try { |
| commandEncoder5.copyBufferToTexture({ |
| /* bytesInLastRow: 38 widthInBlocks: 19 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 4244 */ |
| offset: 4244, |
| bytesPerRow: 22016, |
| buffer: buffer42, |
| }, { |
| texture: texture6, |
| mipLevel: 1, |
| origin: {x: 3, y: 0, z: 4}, |
| aspect: 'all', |
| }, {width: 19, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer41, 1744, new Float32Array(4573), 580, 148); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 984, height: 1, depthOrArrayLayers: 140} |
| */ |
| { |
| source: imageBitmap0, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture120, |
| mipLevel: 1, |
| origin: {x: 78, y: 0, z: 7}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup41 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout4, |
| entries: [ |
| {binding: 144, resource: textureView97}, |
| {binding: 323, resource: {buffer: buffer37, offset: 256, size: 2548}}, |
| ], |
| }); |
| let commandEncoder86 = device0.createCommandEncoder(); |
| let texture126 = device0.createTexture({ |
| size: {width: 246, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 3, |
| format: 'rg16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView101 = texture84.createView({}); |
| try { |
| computePassEncoder17.setBindGroup(1, bindGroup12, []); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder23); computePassEncoder23.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder65.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder27.executeBundles([renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder27.setVertexBuffer(3, buffer56, 12); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 123, height: 1, depthOrArrayLayers: 153} |
| */ |
| { |
| source: videoFrame10, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture6, |
| mipLevel: 1, |
| origin: {x: 32, y: 0, z: 152}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup42 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout8, |
| entries: [ |
| {binding: 125, resource: textureView61}, |
| {binding: 166, resource: {buffer: buffer1, offset: 512, size: 142}}, |
| ], |
| }); |
| let commandEncoder87 = device0.createCommandEncoder({}); |
| let texture127 = device0.createTexture({ |
| size: {width: 307, height: 7, depthOrArrayLayers: 1}, |
| mipLevelCount: 5, |
| format: 'rg32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture128 = device0.createTexture({ |
| size: [80, 90, 1], |
| mipLevelCount: 2, |
| dimension: '2d', |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| let renderPassEncoder30 = commandEncoder5.beginRenderPass({colorAttachments: [{view: textureView79, depthSlice: 0, loadOp: 'load', storeOp: 'store'}]}); |
| let sampler49 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 50.70, |
| maxAnisotropy: 17, |
| }); |
| try { |
| renderPassEncoder20.setIndexBuffer(buffer63, 'uint16', 204, 3_025); |
| } catch {} |
| try { |
| renderPassEncoder8.setPipeline(pipeline10); |
| } catch {} |
| try { |
| commandEncoder86.resolveQuerySet(querySet4, 229, 6, buffer57, 0); |
| } catch {} |
| try { |
| commandEncoder87.insertDebugMarker('\uf5bb'); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let bindGroup43 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout9, |
| entries: [ |
| {binding: 144, resource: textureView5}, |
| {binding: 323, resource: {buffer: buffer32, offset: 3072, size: 2620}}, |
| ], |
| }); |
| let pipelineLayout12 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout0]}); |
| let texture129 = device0.createTexture({size: [80, 90, 6], format: 'rg8sint', usage: GPUTextureUsage.TEXTURE_BINDING, viewFormats: []}); |
| try { |
| computePassEncoder9.setBindGroup(2, bindGroup29, new Uint32Array(2644), 64, 0); |
| } catch {} |
| try { |
| renderPassEncoder16.setPipeline(pipeline4); |
| } catch {} |
| try { |
| commandEncoder87.resolveQuerySet(querySet6, 5, 49, buffer55, 256); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let texture130 = device0.createTexture({ |
| size: [80, 90, 102], |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture131 = device0.createTexture({ |
| size: {width: 153}, |
| dimension: '1d', |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| viewFormats: [], |
| }); |
| let computePassEncoder70 = commandEncoder86.beginComputePass({}); |
| let renderPassEncoder31 = commandEncoder87.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView79, |
| depthSlice: 6, |
| clearValue: { r: 204.6, g: 870.5, b: -363.2, a: -424.6, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| maxDrawCount: 28925414, |
| }); |
| let sampler50 = device0.createSampler({addressModeU: 'repeat', addressModeW: 'repeat', magFilter: 'linear', minFilter: 'linear'}); |
| try { |
| computePassEncoder45.setBindGroup(0, bindGroup12); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder48); computePassEncoder48.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder31); computePassEncoder31.dispatchWorkgroupsIndirect(buffer31, 692); }; |
| } catch {} |
| try { |
| renderPassEncoder12.setBindGroup(0, bindGroup25, new Uint32Array(3359), 126, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer53, 80, new DataView(new ArrayBuffer(15423)), 1333, 192); |
| } catch {} |
| let bindGroup44 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout8, |
| entries: [ |
| {binding: 166, resource: {buffer: buffer65, offset: 2816, size: 1537}}, |
| {binding: 125, resource: textureView31}, |
| ], |
| }); |
| let buffer68 = device0.createBuffer({ |
| size: 9520, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder88 = device0.createCommandEncoder({}); |
| let texture132 = device0.createTexture({ |
| size: {width: 3760, height: 20, depthOrArrayLayers: 1}, |
| format: 'rg16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture133 = device0.createTexture({ |
| size: {width: 1968, height: 1, depthOrArrayLayers: 1}, |
| sampleCount: 1, |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView102 = texture14.createView({baseArrayLayer: 27, arrayLayerCount: 4}); |
| let computePassEncoder71 = commandEncoder88.beginComputePass({}); |
| let sampler51 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'mirror-repeat', minFilter: 'nearest'}); |
| try { |
| renderPassEncoder11.setBindGroup(2, bindGroup11); |
| } catch {} |
| try { |
| renderPassEncoder22.executeBundles([renderBundle0, renderBundle7, renderBundle6, renderBundle1]); |
| } catch {} |
| try { |
| renderPassEncoder16.setIndexBuffer(buffer19, 'uint32', 5_156, 489); |
| } catch {} |
| document.body.prepend(img0); |
| let commandEncoder89 = device0.createCommandEncoder({}); |
| let texture134 = device0.createTexture({ |
| size: {width: 10, height: 11, depthOrArrayLayers: 1}, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture135 = device0.createTexture({size: [80], dimension: '1d', format: 'r8uint', usage: GPUTextureUsage.COPY_SRC}); |
| try { |
| computePassEncoder42.setBindGroup(0, bindGroup42); |
| } catch {} |
| try { |
| renderPassEncoder23.setBlendConstant({ r: 255.3, g: 864.3, b: 187.2, a: -265.2, }); |
| } catch {} |
| try { |
| renderPassEncoder13.setIndexBuffer(buffer13, 'uint32', 128, 671); |
| } catch {} |
| try { |
| commandEncoder89.copyBufferToTexture({ |
| /* bytesInLastRow: 104 widthInBlocks: 26 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 2500 */ |
| offset: 2500, |
| buffer: buffer60, |
| }, { |
| texture: texture111, |
| mipLevel: 1, |
| origin: {x: 24, y: 0, z: 1}, |
| aspect: 'all', |
| }, {width: 26, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer23, 568, new BigUint64Array(5744), 420, 0); |
| } catch {} |
| let imageData13 = new ImageData(48, 40); |
| let commandEncoder90 = device0.createCommandEncoder(); |
| let texture136 = device0.createTexture({ |
| size: [80, 90, 1], |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder25.setBindGroup(1, bindGroup19); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder20); computePassEncoder20.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder67.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder22.setBindGroup(1, bindGroup30, new Uint32Array(3178), 1_092, 0); |
| } catch {} |
| try { |
| commandEncoder89.clearBuffer(buffer47); |
| } catch {} |
| try { |
| if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55); }; |
| } catch {} |
| let commandEncoder91 = device0.createCommandEncoder({}); |
| let texture137 = device0.createTexture({ |
| size: {width: 615, height: 15, depthOrArrayLayers: 1}, |
| mipLevelCount: 1, |
| format: 'rg32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder72 = commandEncoder89.beginComputePass({}); |
| try { |
| computePassEncoder68.setPipeline(pipeline13); |
| } catch {} |
| try { |
| renderPassEncoder31.executeBundles([renderBundle4]); |
| } catch {} |
| try { |
| renderPassEncoder8.setIndexBuffer(buffer22, 'uint16', 100, 533); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| let texture138 = device0.createTexture({ |
| size: [940, 5, 1], |
| mipLevelCount: 1, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView103 = texture2.createView({mipLevelCount: 1, arrayLayerCount: 1}); |
| let computePassEncoder73 = commandEncoder91.beginComputePass({}); |
| try { |
| computePassEncoder45.setBindGroup(2, bindGroup29); |
| } catch {} |
| try { |
| computePassEncoder35.setBindGroup(1, bindGroup17, new Uint32Array(249), 6, 0); |
| } catch {} |
| try { |
| computePassEncoder48.end(); |
| } catch {} |
| try { |
| computePassEncoder70.setPipeline(pipeline18); |
| } catch {} |
| try { |
| buffer20.unmap(); |
| } catch {} |
| let texture139 = device0.createTexture({ |
| size: {width: 1968, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| dimension: '2d', |
| format: 'r32sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture140 = device0.createTexture({ |
| size: {width: 153}, |
| dimension: '1d', |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder74 = commandEncoder59.beginComputePass({label: '\ud336\u{1f92a}\u1cc8\u{1faae}\ub046\u{1f920}\u{1fc0e}\u{1fc8f}'}); |
| try { |
| computePassEncoder31.end(); |
| } catch {} |
| try { |
| computePassEncoder73.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder22.beginOcclusionQuery(26); |
| } catch {} |
| try { |
| renderPassEncoder7.setPipeline(pipeline14); |
| } catch {} |
| try { |
| commandEncoder90.copyBufferToTexture({ |
| /* bytesInLastRow: 403 widthInBlocks: 403 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 286 */ |
| offset: 286, |
| buffer: buffer0, |
| }, { |
| texture: texture71, |
| mipLevel: 0, |
| origin: {x: 163, y: 1, z: 0}, |
| aspect: 'all', |
| }, {width: 403, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder90.copyTextureToBuffer({ |
| texture: texture39, |
| mipLevel: 1, |
| origin: {x: 7, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 108 widthInBlocks: 54 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 4106 */ |
| offset: 4106, |
| bytesPerRow: 512, |
| buffer: buffer62, |
| }, {width: 54, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture141 = device0.createTexture({ |
| size: {width: 615}, |
| dimension: '1d', |
| format: 'r32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView104 = texture52.createView({}); |
| let computePassEncoder75 = commandEncoder36.beginComputePass({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder17); computePassEncoder17.dispatchWorkgroupsIndirect(buffer47, 284); }; |
| } catch {} |
| try { |
| renderPassEncoder7.setPipeline(pipeline8); |
| } catch {} |
| try { |
| buffer7.unmap(); |
| } catch {} |
| let pipeline20 = device0.createRenderPipeline({ |
| layout: pipelineLayout2, |
| fragment: { |
| module: shaderModule1, |
| targets: [{ |
| format: 'rg8unorm', |
| blend: { |
| color: {operation: 'add', srcFactor: 'one', dstFactor: 'one-minus-src'}, |
| alpha: {operation: 'subtract', srcFactor: 'dst-alpha', dstFactor: 'one-minus-constant'}, |
| }, |
| writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN, |
| }], |
| }, |
| vertex: {module: shaderModule5, entryPoint: 'vertex5', constants: {}, buffers: []}, |
| primitive: {topology: 'point-list', frontFace: 'cw', cullMode: 'front'}, |
| }); |
| let bindGroup45 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout9, |
| entries: [ |
| {binding: 323, resource: {buffer: buffer40, offset: 8192, size: 5528}}, |
| {binding: 144, resource: textureView5}, |
| ], |
| }); |
| let textureView105 = texture141.createView({aspect: 'all'}); |
| let textureView106 = texture77.createView({baseArrayLayer: 51, arrayLayerCount: 2}); |
| let recycledExplicitBindGroupLayout4 = pipeline7.getBindGroupLayout(0); |
| let commandEncoder92 = device0.createCommandEncoder({}); |
| let querySet9 = device0.createQuerySet({type: 'occlusion', count: 261}); |
| let texture142 = device0.createTexture({ |
| size: [940, 5, 1], |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder76 = commandEncoder90.beginComputePass({}); |
| try { |
| computePassEncoder75.setPipeline(pipeline19); |
| } catch {} |
| try { |
| renderPassEncoder17.setBindGroup(0, bindGroup30); |
| } catch {} |
| try { |
| renderPassEncoder19.setBindGroup(3, bindGroup5, new Uint32Array(1955), 32, 0); |
| } catch {} |
| try { |
| renderPassEncoder13.setIndexBuffer(buffer56, 'uint16', 2_600, 245); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer67, 4756, new BigUint64Array(19944), 13422, 8); |
| } catch {} |
| let querySet10 = device0.createQuerySet({type: 'occlusion', count: 493}); |
| let texture143 = device0.createTexture({ |
| size: {width: 492, height: 1, depthOrArrayLayers: 1}, |
| format: 'r8sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture144 = device0.createTexture({ |
| size: {width: 307}, |
| dimension: '1d', |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder11.setVertexBuffer(1, buffer22, 596); |
| } catch {} |
| let texture145 = device0.createTexture({ |
| size: {width: 1968, height: 1, depthOrArrayLayers: 1}, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder77 = commandEncoder92.beginComputePass({}); |
| try { |
| renderPassEncoder18.setBindGroup(1, bindGroup43, new Uint32Array(50), 16, 0); |
| } catch {} |
| try { |
| renderPassEncoder22.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder27.setIndexBuffer(buffer41, 'uint16', 10_836, 1_757); |
| } catch {} |
| try { |
| renderPassEncoder23.setVertexBuffer(4, buffer22, 0); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| let texture146 = device0.createTexture({ |
| size: {width: 984, height: 1, depthOrArrayLayers: 63}, |
| mipLevelCount: 2, |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder17); computePassEncoder17.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder18.end(); |
| } catch {} |
| try { |
| computePassEncoder74.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderPassEncoder13.setBindGroup(2, bindGroup44, new Uint32Array(788), 267, 0); |
| } catch {} |
| try { |
| renderPassEncoder16.setIndexBuffer(buffer13, 'uint16', 320, 582); |
| } catch {} |
| let videoFrame11 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-cl', primaries: 'film', transfer: 'smpte240m'} }); |
| let textureView107 = texture0.createView({dimension: '2d-array', aspect: 'all'}); |
| let computePassEncoder78 = commandEncoder18.beginComputePass({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder35); computePassEncoder35.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| renderPassEncoder19.setIndexBuffer(buffer24, 'uint16', 246, 4); |
| } catch {} |
| let recycledExplicitBindGroupLayout5 = pipeline5.getBindGroupLayout(0); |
| let texture147 = device0.createTexture({ |
| label: '\u0d8b\u4258\u{1fdad}\ue999\uab22\u052f\u0978\ua6a5\u0ba8\u68c3', |
| size: {width: 940, height: 5, depthOrArrayLayers: 1}, |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView108 = texture96.createView({mipLevelCount: 1, baseArrayLayer: 0, arrayLayerCount: 35}); |
| let sampler52 = device0.createSampler({addressModeW: 'mirror-repeat', lodMaxClamp: 56.10}); |
| try { |
| computePassEncoder72.setPipeline(pipeline19); |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(3, bindGroup24, new Uint32Array(149), 21, 0); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({device: device0, format: 'rgba16float', usage: GPUTextureUsage.RENDER_ATTACHMENT, colorSpace: 'srgb'}); |
| } catch {} |
| let texture148 = device0.createTexture({ |
| size: {width: 1880, height: 10, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| sampleCount: 1, |
| format: 'rg16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture149 = device0.createTexture({ |
| size: {width: 3760, height: 20, depthOrArrayLayers: 1}, |
| mipLevelCount: 4, |
| format: 'r8uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| computePassEncoder62.setBindGroup(1, bindGroup6); |
| } catch {} |
| try { |
| computePassEncoder9.setBindGroup(0, bindGroup30, new Uint32Array(930), 154, 0); |
| } catch {} |
| try { |
| renderPassEncoder24.setBindGroup(1, bindGroup38); |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let buffer69 = device0.createBuffer({ |
| size: 2977, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM, |
| }); |
| let commandEncoder93 = device0.createCommandEncoder(); |
| let texture150 = device0.createTexture({ |
| size: {width: 1880, height: 10, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView109 = texture111.createView({mipLevelCount: 1, arrayLayerCount: 1}); |
| let sampler53 = device0.createSampler({addressModeU: 'repeat', magFilter: 'linear', minFilter: 'nearest', mipmapFilter: 'linear'}); |
| try { |
| renderPassEncoder28.setPipeline(pipeline15); |
| } catch {} |
| try { |
| renderPassEncoder27.setVertexBuffer(2, buffer14); |
| } catch {} |
| try { |
| commandEncoder93.copyBufferToTexture({ |
| /* bytesInLastRow: 147 widthInBlocks: 147 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 846 */ |
| offset: 846, |
| bytesPerRow: 14080, |
| buffer: buffer51, |
| }, { |
| texture: texture73, |
| mipLevel: 1, |
| origin: {x: 61, y: 1, z: 0}, |
| aspect: 'all', |
| }, {width: 147, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.append(img2); |
| let videoFrame12 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-ncl', primaries: 'bt2020', transfer: 'iec61966-2-1'} }); |
| let recycledExplicitBindGroupLayout6 = pipeline15.getBindGroupLayout(0); |
| let bindGroup46 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout2, |
| entries: [ |
| {binding: 39, resource: {buffer: buffer20, offset: 4864, size: 824}}, |
| {binding: 41, resource: textureView8}, |
| ], |
| }); |
| let texture151 = device0.createTexture({ |
| size: [153, 3, 1], |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture152 = device0.createTexture({ |
| size: [307, 7, 1], |
| mipLevelCount: 2, |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let sampler54 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| maxAnisotropy: 2, |
| }); |
| try { |
| renderPassEncoder25.setVertexBuffer(4, buffer51, 100); |
| } catch {} |
| let arrayBuffer12 = buffer28.getMappedRange(0, 320); |
| try { |
| computePassEncoder33.insertDebugMarker('\u{1f9dc}'); |
| } catch {} |
| let veryExplicitBindGroupLayout16 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 34, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: 'cube-array', sampleType: 'uint', multisampled: false }, |
| }, |
| {binding: 73, visibility: GPUShaderStage.VERTEX, sampler: { type: 'comparison' }}, |
| { |
| binding: 133, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', hasDynamicOffset: true }, |
| }, |
| { |
| binding: 430, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| sampler: { type: 'filtering' }, |
| }, |
| ], |
| }); |
| let buffer70 = device0.createBuffer({ |
| size: 68, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| let texture153 = device0.createTexture({ |
| size: [80, 90, 3], |
| mipLevelCount: 2, |
| format: 'rg16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder79 = commandEncoder93.beginComputePass({}); |
| let sampler55 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 47.79, |
| maxAnisotropy: 9, |
| }); |
| try { |
| computePassEncoder23.setBindGroup(0, bindGroup43, new Uint32Array(162), 11, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder23); computePassEncoder23.dispatchWorkgroupsIndirect(buffer62, 2_440); }; |
| } catch {} |
| try { |
| renderPassEncoder30.setIndexBuffer(buffer67, 'uint32', 1_212, 295); |
| } catch {} |
| try { |
| renderPassEncoder14.setVertexBuffer(6, buffer38, 4, 77); |
| } catch {} |
| let pipeline21 = await device0.createRenderPipelineAsync({ |
| layout: pipelineLayout3, |
| fragment: {module: shaderModule1, constants: {}, targets: [{format: 'rg8unorm'}]}, |
| vertex: { |
| module: shaderModule6, |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 148, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'uint32x3', offset: 16, shaderLocation: 3}, |
| {format: 'uint16x4', offset: 0, shaderLocation: 4}, |
| ], |
| }, |
| { |
| arrayStride: 816, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'sint32x2', offset: 108, shaderLocation: 12}, |
| {format: 'unorm16x2', offset: 4, shaderLocation: 7}, |
| {format: 'uint32', offset: 572, shaderLocation: 14}, |
| {format: 'unorm16x2', offset: 148, shaderLocation: 9}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {frontFace: 'cw', cullMode: 'front', unclippedDepth: true}, |
| }); |
| let texture154 = device0.createTexture({ |
| size: {width: 20, height: 22, depthOrArrayLayers: 49}, |
| sampleCount: 1, |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder38); computePassEncoder38.dispatchWorkgroupsIndirect(buffer12, 11_028); }; |
| } catch {} |
| try { |
| computePassEncoder77.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder23.setIndexBuffer(buffer62, 'uint16', 116, 224); |
| } catch {} |
| try { |
| renderPassEncoder13.setPipeline(pipeline21); |
| } catch {} |
| try { |
| renderPassEncoder24.setVertexBuffer(2, buffer51, 452, 722); |
| } catch {} |
| try { |
| renderPassEncoder20.insertDebugMarker('\u048d'); |
| } catch {} |
| let pipeline22 = await device0.createRenderPipelineAsync({ |
| layout: pipelineLayout9, |
| multisample: {mask: 0x3d79c9b5}, |
| fragment: { |
| module: shaderModule3, |
| constants: {}, |
| targets: [{format: 'rg8unorm', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN}], |
| }, |
| vertex: {module: shaderModule4, buffers: []}, |
| primitive: {unclippedDepth: true}, |
| }); |
| let bindGroup47 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout1, |
| entries: [ |
| {binding: 323, resource: {buffer: buffer63, offset: 0, size: 1600}}, |
| {binding: 144, resource: textureView97}, |
| ], |
| }); |
| let querySet11 = device0.createQuerySet({type: 'occlusion', count: 2000}); |
| let texture155 = device0.createTexture({ |
| size: [40, 45, 21], |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder27.setIndexBuffer(buffer8, 'uint16', 186, 670); |
| } catch {} |
| try { |
| computePassEncoder36.insertDebugMarker('\ube81'); |
| } catch {} |
| let videoFrame13 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'fcc', primaries: 'jedecP22Phosphors', transfer: 'gamma22curve'} }); |
| let texture156 = device0.createTexture({ |
| size: [1230, 30, 1], |
| mipLevelCount: 3, |
| dimension: '2d', |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture157 = device0.createTexture({ |
| size: [40, 45, 34], |
| dimension: '3d', |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| computePassEncoder38.setBindGroup(3, bindGroup16); |
| } catch {} |
| try { |
| renderPassEncoder7.executeBundles([renderBundle5, renderBundle6, renderBundle4]); |
| } catch {} |
| let pipeline23 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule5, entryPoint: 'compute5'}}); |
| let texture158 = device0.createTexture({ |
| size: {width: 1968, height: 1, depthOrArrayLayers: 47}, |
| mipLevelCount: 2, |
| format: 'rg16sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView110 = texture32.createView({}); |
| try { |
| computePassEncoder79.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder27.setIndexBuffer(buffer37, 'uint16', 2_212, 2_568); |
| } catch {} |
| let bindGroup48 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout3, |
| entries: [ |
| {binding: 323, resource: {buffer: buffer65, offset: 768, size: 1524}}, |
| {binding: 144, resource: textureView97}, |
| ], |
| }); |
| let commandEncoder94 = device0.createCommandEncoder({}); |
| let texture159 = device0.createTexture({ |
| size: {width: 10, height: 11, depthOrArrayLayers: 1}, |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder80 = commandEncoder94.beginComputePass({}); |
| try { |
| computePassEncoder51.end(); |
| } catch {} |
| try { |
| computePassEncoder76.setPipeline(pipeline23); |
| } catch {} |
| try { |
| renderPassEncoder27.setBindGroup(0, bindGroup47, new Uint32Array(633), 187, 0); |
| } catch {} |
| try { |
| renderPassEncoder13.setScissorRect(177, 1, 335, 0); |
| } catch {} |
| try { |
| commandEncoder61.copyBufferToTexture({ |
| /* bytesInLastRow: 2138 widthInBlocks: 1069 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 144 */ |
| offset: 144, |
| rowsPerImage: 818, |
| buffer: buffer21, |
| }, { |
| texture: texture133, |
| mipLevel: 0, |
| origin: {x: 37, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 1069, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture160 = device0.createTexture({ |
| size: [615, 15, 1], |
| mipLevelCount: 2, |
| format: 'r32sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder81 = commandEncoder61.beginComputePass(); |
| let sampler56 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'nearest', |
| minFilter: 'linear', |
| lodMaxClamp: 85.15, |
| maxAnisotropy: 1, |
| }); |
| try { |
| computePassEncoder42.setBindGroup(0, bindGroup47); |
| } catch {} |
| try { |
| computePassEncoder78.setPipeline(pipeline19); |
| } catch {} |
| document.body.prepend(img0); |
| let buffer71 = device0.createBuffer({ |
| size: 39902, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let texture161 = device0.createTexture({ |
| size: [984, 1, 1], |
| mipLevelCount: 3, |
| sampleCount: 1, |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture162 = device0.createTexture({ |
| size: {width: 40, height: 45, depthOrArrayLayers: 1}, |
| mipLevelCount: 4, |
| dimension: '2d', |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_SRC, |
| }); |
| try { |
| computePassEncoder63.setBindGroup(3, bindGroup46); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder23); computePassEncoder23.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder16.setBindGroup(0, bindGroup4, new Uint32Array(341), 176, 0); |
| } catch {} |
| let commandEncoder95 = device0.createCommandEncoder({}); |
| let texture163 = device0.createTexture({ |
| size: {width: 153, height: 3, depthOrArrayLayers: 1}, |
| sampleCount: 1, |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder82 = commandEncoder95.beginComputePass({}); |
| try { |
| computePassEncoder82.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder28.end(); |
| } catch {} |
| try { |
| renderPassEncoder24.setVertexBuffer(2, buffer20, 5_584, 1_755); |
| } catch {} |
| try { |
| buffer54.unmap(); |
| } catch {} |
| try { |
| computePassEncoder32.pushDebugGroup('\ueecb'); |
| } catch {} |
| document.body.append(img2); |
| let bindGroup49 = device0.createBindGroup({ |
| label: '\u6840\ud0ea\ub0ab\u{1ffac}\u2af5', |
| layout: veryExplicitBindGroupLayout16, |
| entries: [ |
| {binding: 430, resource: sampler44}, |
| {binding: 133, resource: {buffer: buffer68, offset: 768, size: 1790}}, |
| {binding: 73, resource: sampler13}, |
| {binding: 34, resource: textureView96}, |
| ], |
| }); |
| let buffer72 = device0.createBuffer({size: 3265, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let commandEncoder96 = device0.createCommandEncoder({}); |
| let commandBuffer6 = commandEncoder82.finish(); |
| let texture164 = device0.createTexture({ |
| size: {width: 246, height: 1, depthOrArrayLayers: 48}, |
| mipLevelCount: 2, |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture165 = gpuCanvasContext1.getCurrentTexture(); |
| let computePassEncoder83 = commandEncoder96.beginComputePass({}); |
| let sampler57 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| maxAnisotropy: 18, |
| }); |
| try { |
| computePassEncoder47.setBindGroup(2, bindGroup21, new Uint32Array(3796), 1_561, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder35); computePassEncoder35.dispatchWorkgroupsIndirect(buffer69, 664); }; |
| } catch {} |
| try { |
| renderPassEncoder20.setBindGroup(2, bindGroup17); |
| } catch {} |
| try { |
| renderPassEncoder25.setVertexBuffer(0, buffer21); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 40, height: 45, depthOrArrayLayers: 1} |
| */ |
| { |
| source: img4, |
| origin: { x: 1, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture84, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture166 = device0.createTexture({ |
| size: {width: 40, height: 45, depthOrArrayLayers: 38}, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder75.setBindGroup(1, bindGroup40); |
| } catch {} |
| try { |
| computePassEncoder19.setBindGroup(2, bindGroup27, new Uint32Array(386), 131, 0); |
| } catch {} |
| try { |
| renderPassEncoder22.setPipeline(pipeline7); |
| } catch {} |
| try { |
| await shaderModule2.getCompilationInfo(); |
| } catch {} |
| try { |
| buffer19.unmap(); |
| } catch {} |
| let offscreenCanvas2 = new OffscreenCanvas(41, 119); |
| let texture167 = device0.createTexture({ |
| size: [470, 2, 1], |
| dimension: '2d', |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder74.setBindGroup(0, bindGroup25, new Uint32Array(1081), 123, 0); |
| } catch {} |
| try { |
| computePassEncoder83.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder27.setBindGroup(0, bindGroup8, new Uint32Array(1264), 52, 0); |
| } catch {} |
| try { |
| renderPassEncoder12.setVertexBuffer(6, buffer55, 0, 584); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let videoFrame14 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt709', primaries: 'bt470m', transfer: 'smpte240m'} }); |
| let bindGroup50 = device0.createBindGroup({layout: veryExplicitBindGroupLayout7, entries: [{binding: 9, resource: textureView65}]}); |
| let texture168 = device0.createTexture({ |
| size: {width: 80, height: 90, depthOrArrayLayers: 1}, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder7.setIndexBuffer(buffer52, 'uint32', 284, 90); |
| } catch {} |
| let bindGroup51 = device0.createBindGroup({layout: veryExplicitBindGroupLayout7, entries: [{binding: 9, resource: textureView18}]}); |
| let commandEncoder97 = device0.createCommandEncoder({}); |
| let textureView111 = texture115.createView({dimension: 'cube-array', baseArrayLayer: 6, arrayLayerCount: 6}); |
| let renderPassEncoder32 = commandEncoder97.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView55, |
| clearValue: { r: 400.5, g: 889.4, b: -666.5, a: 933.8, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet1, |
| maxDrawCount: 80008217, |
| }); |
| let sampler58 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| lodMaxClamp: 61.80, |
| }); |
| try { |
| computePassEncoder72.setBindGroup(2, bindGroup51, []); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder16); computePassEncoder16.dispatchWorkgroupsIndirect(buffer20, 4_864); }; |
| } catch {} |
| try { |
| renderPassEncoder7.setBlendConstant({ r: 928.5, g: 840.0, b: 440.2, a: 518.8, }); |
| } catch {} |
| let bindGroup52 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout8, |
| entries: [ |
| {binding: 125, resource: textureView21}, |
| {binding: 166, resource: {buffer: buffer57, offset: 512, size: 3905}}, |
| ], |
| }); |
| let texture169 = device0.createTexture({ |
| size: [1230, 30, 1], |
| mipLevelCount: 1, |
| format: 'rg32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder79.setBindGroup(1, bindGroup31, new Uint32Array(158), 25, 0); |
| } catch {} |
| try { |
| renderPassEncoder11.setBindGroup(0, bindGroup11); |
| } catch {} |
| try { |
| renderPassEncoder8.setPipeline(pipeline8); |
| } catch {} |
| let texture170 = device0.createTexture({ |
| size: {width: 615, height: 15, depthOrArrayLayers: 1}, |
| mipLevelCount: 3, |
| format: 'r8sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView112 = texture14.createView({dimension: '2d', baseArrayLayer: 13}); |
| try { |
| computePassEncoder57.setBindGroup(1, bindGroup35, []); |
| } catch {} |
| try { |
| computePassEncoder35.end(); |
| } catch {} |
| try { |
| renderPassEncoder8.draw(151, 184, 454_454_892, 883_555_986); |
| } catch {} |
| try { |
| renderPassEncoder32.setPipeline(pipeline20); |
| } catch {} |
| try { |
| renderPassEncoder12.setVertexBuffer(7, buffer70, 0, 5); |
| } catch {} |
| let videoFrame15 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-ncl', primaries: 'bt2020', transfer: 'gamma28curve'} }); |
| let bindGroup53 = device0.createBindGroup({layout: veryExplicitBindGroupLayout7, entries: [{binding: 9, resource: textureView1}]}); |
| let textureView113 = texture53.createView({}); |
| let sampler59 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| lodMaxClamp: 94.70, |
| compare: 'greater', |
| }); |
| try { |
| computePassEncoder30.setBindGroup(0, bindGroup8, new Uint32Array(114), 5, 0); |
| } catch {} |
| try { |
| computePassEncoder71.setPipeline(pipeline23); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(0, 52, 40, 402_679_497, 145_092_889); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer65, 2_400); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer70, 0); |
| } catch {} |
| try { |
| renderPassEncoder15.setIndexBuffer(buffer13, 'uint32', 196, 534); |
| } catch {} |
| try { |
| renderPassEncoder32.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder20.setVertexBuffer(1, buffer37, 84, 731); |
| } catch {} |
| let gpuCanvasContext2 = offscreenCanvas2.getContext('webgpu'); |
| let querySet12 = device0.createQuerySet({type: 'occlusion', count: 652}); |
| let commandBuffer7 = commandEncoder45.finish({}); |
| let texture171 = device0.createTexture({ |
| size: [40, 45, 1], |
| mipLevelCount: 2, |
| format: 'rg32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder38.setBindGroup(3, bindGroup27); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder21); computePassEncoder21.dispatchWorkgroupsIndirect(buffer14, 8_736); }; |
| } catch {} |
| try { |
| computePassEncoder80.setPipeline(pipeline19); |
| } catch {} |
| try { |
| renderPassEncoder24.setVertexBuffer(6, buffer43, 0, 33); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let bindGroup54 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout0, |
| entries: [ |
| {binding: 144, resource: textureView5}, |
| {binding: 323, resource: {buffer: buffer51, offset: 0, size: 1292}}, |
| ], |
| }); |
| let commandEncoder98 = device0.createCommandEncoder({}); |
| let querySet13 = device0.createQuerySet({type: 'occlusion', count: 652}); |
| let texture172 = device0.createTexture({ |
| size: [615, 15, 1], |
| format: 'r16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder84 = commandEncoder98.beginComputePass(); |
| try { |
| computePassEncoder81.setPipeline(pipeline23); |
| } catch {} |
| try { |
| renderPassEncoder18.setBindGroup(2, bindGroup22); |
| } catch {} |
| try { |
| renderPassEncoder8.draw(68, 386, 820_498_439, 49_991_776); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(1, 61, 67, -2_082_215_954, 470_214_812); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer60, 4); |
| } catch {} |
| try { |
| computePassEncoder32.popDebugGroup(); |
| } catch {} |
| let texture173 = device0.createTexture({ |
| size: [1230, 30, 1], |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture174 = device0.createTexture({ |
| size: {width: 492, height: 1, depthOrArrayLayers: 6}, |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'r8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder84.setPipeline(pipeline11); |
| } catch {} |
| try { |
| renderPassEncoder7.setBindGroup(1, bindGroup8); |
| } catch {} |
| try { |
| renderPassEncoder7.draw(256, 66, 104_525_186, 255_863_518); |
| } catch {} |
| try { |
| renderPassEncoder25.setPipeline(pipeline0); |
| } catch {} |
| let pipeline24 = await device0.createRenderPipelineAsync({ |
| layout: pipelineLayout9, |
| fragment: {module: shaderModule3, targets: [{format: 'rg8unorm', writeMask: 0}]}, |
| vertex: {module: shaderModule3, constants: {}, buffers: []}, |
| }); |
| let imageData14 = new ImageData(4, 4); |
| let texture175 = device0.createTexture({ |
| size: {width: 10, height: 11, depthOrArrayLayers: 1}, |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture176 = device0.createTexture({ |
| size: {width: 470, height: 2, depthOrArrayLayers: 1}, |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder16.end(); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| commandEncoder16.copyTextureToTexture({ |
| texture: texture127, |
| mipLevel: 1, |
| origin: {x: 11, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture171, |
| mipLevel: 1, |
| origin: {x: 3, y: 4, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 8, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup55 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout3, |
| entries: [ |
| {binding: 323, resource: {buffer: buffer33, offset: 0, size: 1668}}, |
| {binding: 144, resource: textureView5}, |
| ], |
| }); |
| let pipelineLayout13 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout4, autogeneratedBindGroupLayout4]}); |
| let buffer73 = device0.createBuffer({ |
| size: 1789, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let texture177 = device0.createTexture({ |
| size: [470, 2, 1], |
| dimension: '2d', |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView114 = texture85.createView({}); |
| let computePassEncoder85 = commandEncoder16.beginComputePass({}); |
| try { |
| computePassEncoder42.setBindGroup(2, bindGroup49, new Uint32Array(753), 174, 1); |
| } catch {} |
| try { |
| renderPassEncoder7.draw(37, 584, 1_122_973_271, 145_753_121); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndexedIndirect(buffer33, 1_804); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndirect(buffer14, 1_876); |
| } catch {} |
| try { |
| renderPassEncoder31.setIndexBuffer(buffer1, 'uint32', 5_040, 190); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer7, commandBuffer6]); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture100, |
| mipLevel: 0, |
| origin: {x: 20, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(21).fill(225), /* required buffer size: 21 */ |
| {offset: 21}, {width: 10, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder99 = device0.createCommandEncoder({}); |
| let texture178 = device0.createTexture({ |
| size: {width: 615, height: 15, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| sampleCount: 1, |
| format: 'rg16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView115 = texture135.createView({ |
| label: '\u0f46\u18f8\u{1fcaf}\ucf48\ub5f3\u307c\u{1ffbb}\u75e8\u050b', |
| baseArrayLayer: 0, |
| arrayLayerCount: 1, |
| }); |
| try { |
| computePassEncoder62.setBindGroup(2, bindGroup1, new Uint32Array(4330), 506, 0); |
| } catch {} |
| try { |
| computePassEncoder85.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderPassEncoder7.draw(156, 32, 1_124_961_095, 893_035_784); |
| } catch {} |
| let bindGroup56 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout12, |
| entries: [ |
| {binding: 166, resource: {buffer: buffer69, offset: 512, size: 216}}, |
| {binding: 125, resource: textureView61}, |
| ], |
| }); |
| let texture179 = device0.createTexture({ |
| size: [940, 5, 1], |
| mipLevelCount: 3, |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture180 = gpuCanvasContext1.getCurrentTexture(); |
| let textureView116 = texture91.createView({dimension: '2d-array'}); |
| let renderBundleEncoder10 = device0.createRenderBundleEncoder({ |
| label: '\u0ca3\ub64f\u5dcd\uedbc\u{1fb74}\ua19b\u0c9b\u0163\u51bd\u6e53\u{1feea}', |
| colorFormats: ['rg8unorm'], |
| depthReadOnly: true, |
| }); |
| try { |
| computePassEncoder70.setBindGroup(1, bindGroup30, []); |
| } catch {} |
| try { |
| renderPassEncoder8.setScissorRect(11, 0, 7, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.draw(120, 182, 329_665_677, 828_091_665); |
| } catch {} |
| try { |
| renderPassEncoder27.setIndexBuffer(buffer66, 'uint16', 4_218, 3_642); |
| } catch {} |
| try { |
| renderBundleEncoder10.setPipeline(pipeline0); |
| } catch {} |
| let texture181 = device0.createTexture({ |
| size: [1880, 10, 1], |
| format: 'r32sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture182 = device0.createTexture({ |
| size: {width: 940, height: 5, depthOrArrayLayers: 1}, |
| format: 'r8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| let computePassEncoder86 = commandEncoder99.beginComputePass({}); |
| try { |
| computePassEncoder45.dispatchWorkgroups(1); |
| } catch {} |
| try { |
| renderPassEncoder10.setBindGroup(2, bindGroup6); |
| } catch {} |
| try { |
| renderPassEncoder8.draw(439, 96, 275_380_152, 718_430_461); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndirect(buffer33, 648); |
| } catch {} |
| try { |
| renderBundleEncoder10.setIndexBuffer(buffer56, 'uint32', 168, 544); |
| } catch {} |
| try { |
| device0.pushErrorScope('internal'); |
| } catch {} |
| let pipeline25 = await device0.createComputePipelineAsync({layout: pipelineLayout0, compute: {module: shaderModule3}}); |
| let videoFrame16 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-ncl', primaries: 'smpteSt4281', transfer: 'smpte170m'} }); |
| let texture183 = device0.createTexture({ |
| size: {width: 80, height: 90, depthOrArrayLayers: 14}, |
| mipLevelCount: 2, |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture184 = device0.createTexture({size: [470], dimension: '1d', format: 'r8uint', usage: GPUTextureUsage.COPY_SRC}); |
| let renderBundleEncoder11 = device0.createRenderBundleEncoder({colorFormats: ['rg8unorm'], depthReadOnly: true}); |
| let renderBundle10 = renderBundleEncoder10.finish({}); |
| let sampler60 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'repeat', minFilter: 'linear', lodMaxClamp: 86.10}); |
| try { |
| computePassEncoder72.setPipeline(pipeline3); |
| } catch {} |
| try { |
| computePassEncoder86.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderPassEncoder7.drawIndexedIndirect(buffer7, 20); |
| } catch {} |
| try { |
| renderPassEncoder25.setVertexBuffer(2, buffer20, 136, 1_676); |
| } catch {} |
| try { |
| renderBundleEncoder11.setBindGroup(0, bindGroup43, []); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 40, height: 45, depthOrArrayLayers: 3} |
| */ |
| { |
| source: videoFrame15, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture153, |
| mipLevel: 1, |
| origin: {x: 0, y: 3, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline26 = device0.createRenderPipeline({ |
| layout: pipelineLayout0, |
| fragment: {module: shaderModule0, targets: [{format: 'rg8unorm', writeMask: 0}]}, |
| vertex: {module: shaderModule7, buffers: []}, |
| primitive: {unclippedDepth: true}, |
| }); |
| let commandEncoder100 = device0.createCommandEncoder({}); |
| let texture185 = device0.createTexture({ |
| size: [470, 2, 1], |
| mipLevelCount: 2, |
| sampleCount: 1, |
| dimension: '2d', |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture186 = device0.createTexture({size: [153, 3, 116], dimension: '3d', format: 'r8sint', usage: GPUTextureUsage.RENDER_ATTACHMENT}); |
| let computePassEncoder87 = commandEncoder100.beginComputePass(); |
| try { |
| { clearResourceUsages(device0, computePassEncoder38); computePassEncoder38.dispatchWorkgroupsIndirect(buffer12, 25_528); }; |
| } catch {} |
| try { |
| computePassEncoder87.setPipeline(pipeline25); |
| } catch {} |
| try { |
| renderPassEncoder7.setBindGroup(0, bindGroup1, new Uint32Array(1132), 126, 0); |
| } catch {} |
| try { |
| renderPassEncoder15.setViewport(235.99979558657384, 0.2176417643044678, 3.816494775741497, 0.42278211372255237, 0.2987209770656566, 0.565899449460517); |
| } catch {} |
| try { |
| renderBundleEncoder11.setIndexBuffer(buffer41, 'uint32', 8_644, 8_937); |
| } catch {} |
| let bindGroup57 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout9, |
| entries: [ |
| {binding: 144, resource: textureView97}, |
| {binding: 323, resource: {buffer: buffer37, offset: 2816, size: 1684}}, |
| ], |
| }); |
| let commandEncoder101 = device0.createCommandEncoder({}); |
| let texture187 = device0.createTexture({ |
| size: [153, 3, 1], |
| mipLevelCount: 2, |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture188 = device0.createTexture({ |
| size: [1880, 10, 1], |
| mipLevelCount: 3, |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_DST, |
| viewFormats: [], |
| }); |
| let computePassEncoder88 = commandEncoder101.beginComputePass(); |
| try { |
| computePassEncoder39.setBindGroup(1, bindGroup40, new Uint32Array(2301), 354, 0); |
| } catch {} |
| try { |
| renderPassEncoder24.setBindGroup(3, bindGroup57, new Uint32Array(4666), 2_569, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.end(); |
| } catch {} |
| try { |
| renderPassEncoder27.beginOcclusionQuery(165); |
| } catch {} |
| try { |
| renderPassEncoder20.setViewport(172.1290316073837, 0.3090693898578025, 32.27046356503438, 0.006455227368975552, 0.7598275241028215, 0.9691579396317894); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer71, 712); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer65, 1_444); |
| } catch {} |
| try { |
| renderBundleEncoder11.setIndexBuffer(buffer66, 'uint32', 3_292, 6_304); |
| } catch {} |
| try { |
| renderBundleEncoder11.setVertexBuffer(3, buffer60, 28, 33); |
| } catch {} |
| try { |
| commandEncoder38.copyBufferToBuffer(buffer53, 220, buffer13, 476, 48); |
| } catch {} |
| try { |
| commandEncoder38.copyBufferToTexture({ |
| /* bytesInLastRow: 10 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 1006 */ |
| offset: 1006, |
| bytesPerRow: 36864, |
| buffer: buffer67, |
| }, { |
| texture: texture28, |
| mipLevel: 0, |
| origin: {x: 18, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 5, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder38.clearBuffer(buffer24, 4, 32); |
| } catch {} |
| try { |
| renderPassEncoder19.pushDebugGroup('\ud064'); |
| } catch {} |
| try { |
| renderPassEncoder19.popDebugGroup(); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture27, |
| mipLevel: 0, |
| origin: {x: 5, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(206).fill(155), /* required buffer size: 206 */ |
| {offset: 206}, {width: 19, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture189 = device0.createTexture({ |
| size: {width: 3760, height: 20, depthOrArrayLayers: 1}, |
| format: 'r16sint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder88.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexed(64, 180, 9, 899_643_309, 172_897_643); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndexedIndirect(buffer21, 3_728); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer7, 32); |
| } catch {} |
| try { |
| renderPassEncoder16.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderBundleEncoder11.setBindGroup(1, bindGroup2); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'srgb', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let videoFrame17 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt470bg', primaries: 'bt470bg', transfer: 'smpte170m'} }); |
| let commandEncoder102 = device0.createCommandEncoder({}); |
| let commandBuffer8 = commandEncoder38.finish({}); |
| let texture190 = device0.createTexture({ |
| size: {width: 153, height: 3, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture191 = device0.createTexture({ |
| size: [615, 15, 1], |
| mipLevelCount: 2, |
| format: 'r8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView117 = texture149.createView({mipLevelCount: 1, baseArrayLayer: 0}); |
| let computePassEncoder89 = commandEncoder102.beginComputePass({}); |
| try { |
| computePassEncoder89.setPipeline(pipeline25); |
| } catch {} |
| try { |
| renderPassEncoder8.drawIndirect(buffer21, 1_048); |
| } catch {} |
| try { |
| renderBundleEncoder11.setBindGroup(3, bindGroup34); |
| } catch {} |
| try { |
| renderBundleEncoder11.setIndexBuffer(buffer19, 'uint32', 1_452, 533); |
| } catch {} |
| let arrayBuffer13 = buffer28.getMappedRange(320, 3068); |
| let texture192 = device0.createTexture({ |
| size: {width: 1968, height: 1, depthOrArrayLayers: 58}, |
| mipLevelCount: 4, |
| format: 'rg16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture193 = device0.createTexture({size: [1230], sampleCount: 1, dimension: '1d', format: 'r8sint', usage: GPUTextureUsage.COPY_SRC}); |
| let textureView118 = texture152.createView({dimension: '2d-array', mipLevelCount: 1}); |
| let renderBundle11 = renderBundleEncoder11.finish({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder38); computePassEncoder38.dispatchWorkgroupsIndirect(buffer62, 712); }; |
| } catch {} |
| try { |
| renderPassEncoder8.end(); |
| } catch {} |
| try { |
| renderPassEncoder25.executeBundles([renderBundle4, renderBundle10, renderBundle3, renderBundle4]); |
| } catch {} |
| try { |
| renderPassEncoder19.setVertexBuffer(0, buffer21); |
| } catch {} |
| try { |
| commandEncoder40.copyBufferToTexture({ |
| /* bytesInLastRow: 44 widthInBlocks: 22 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 3088 */ |
| offset: 3088, |
| buffer: buffer21, |
| }, { |
| texture: texture167, |
| mipLevel: 0, |
| origin: {x: 57, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 22, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer19, 1432, new Int16Array(39), 1, 4); |
| } catch {} |
| let pipeline27 = device0.createComputePipeline({layout: pipelineLayout3, compute: {module: shaderModule5, entryPoint: 'compute4', constants: {}}}); |
| let buffer74 = device0.createBuffer({ |
| size: 5076, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder103 = device0.createCommandEncoder({}); |
| let texture194 = device0.createTexture({ |
| size: [1968, 1, 53], |
| mipLevelCount: 1, |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder11.setVertexBuffer(3, buffer1); |
| } catch {} |
| let texture195 = device0.createTexture({ |
| size: {width: 1880, height: 10, depthOrArrayLayers: 1}, |
| mipLevelCount: 3, |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView119 = texture28.createView({}); |
| let computePassEncoder90 = commandEncoder103.beginComputePass({}); |
| let renderPassEncoder33 = commandEncoder40.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView93, |
| clearValue: { r: -3.059, g: -210.3, b: -49.26, a: -568.4, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| maxDrawCount: 69579579, |
| }); |
| try { |
| computePassEncoder83.setBindGroup(1, bindGroup49, [0]); |
| } catch {} |
| try { |
| computePassEncoder75.setPipeline(pipeline25); |
| } catch {} |
| try { |
| computePassEncoder90.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderPassEncoder26.setBindGroup(1, bindGroup11, new Uint32Array(6799), 807, 0); |
| } catch {} |
| try { |
| renderPassEncoder27.endOcclusionQuery(); |
| } catch {} |
| let arrayBuffer14 = buffer26.getMappedRange(136, 0); |
| let querySet14 = device0.createQuerySet({type: 'occlusion', count: 220}); |
| let texture196 = device0.createTexture({ |
| size: [246, 1, 1], |
| format: 'rg16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture197 = device0.createTexture({ |
| size: [3760, 20, 1], |
| mipLevelCount: 6, |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let textureView120 = texture70.createView({mipLevelCount: 1}); |
| try { |
| computePassEncoder26.setBindGroup(2, bindGroup41); |
| } catch {} |
| try { |
| computePassEncoder45.setBindGroup(3, bindGroup47, new Uint32Array(512), 136, 0); |
| } catch {} |
| try { |
| computePassEncoder74.end(); |
| } catch {} |
| try { |
| renderPassEncoder27.setBindGroup(0, bindGroup34); |
| } catch {} |
| try { |
| renderPassEncoder13.setVertexBuffer(3, buffer38, 0); |
| } catch {} |
| try { |
| device0.pushErrorScope('internal'); |
| } catch {} |
| try { |
| commandEncoder59.copyBufferToTexture({ |
| /* bytesInLastRow: 448 widthInBlocks: 56 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 2168 */ |
| offset: 2168, |
| bytesPerRow: 6400, |
| buffer: buffer56, |
| }, { |
| texture: texture112, |
| mipLevel: 0, |
| origin: {x: 137, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 56, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture52, |
| mipLevel: 0, |
| origin: {x: 9, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(333).fill(2), /* required buffer size: 333 */ |
| {offset: 333, bytesPerRow: 760}, {width: 366, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 123, height: 1, depthOrArrayLayers: 153} |
| */ |
| { |
| source: videoFrame0, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture6, |
| mipLevel: 1, |
| origin: {x: 35, y: 0, z: 11}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let imageData15 = new ImageData(96, 8); |
| let commandEncoder104 = device0.createCommandEncoder({}); |
| let texture198 = device0.createTexture({ |
| size: {width: 246, height: 1, depthOrArrayLayers: 16}, |
| mipLevelCount: 3, |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView121 = texture101.createView({dimension: '2d-array', mipLevelCount: 1}); |
| let computePassEncoder91 = commandEncoder59.beginComputePass(); |
| let renderBundleEncoder12 = device0.createRenderBundleEncoder({colorFormats: ['rg8unorm'], depthReadOnly: true}); |
| try { |
| renderPassEncoder32.setBindGroup(3, bindGroup22, new Uint32Array(8), 1, 0); |
| } catch {} |
| try { |
| renderBundleEncoder12.setIndexBuffer(buffer74, 'uint32', 636, 1_002); |
| } catch {} |
| try { |
| renderBundleEncoder12.setVertexBuffer(5, buffer22, 0); |
| } catch {} |
| try { |
| commandEncoder104.copyBufferToBuffer(buffer32, 5796, buffer71, 1760, 608); |
| } catch {} |
| let texture199 = device0.createTexture({ |
| size: [3760, 20, 1], |
| mipLevelCount: 2, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderBundle12 = renderBundleEncoder12.finish({}); |
| let sampler61 = device0.createSampler({ |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| lodMaxClamp: 89.34, |
| compare: 'always', |
| maxAnisotropy: 1, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder33); computePassEncoder33.dispatchWorkgroupsIndirect(buffer60, 868); }; |
| } catch {} |
| try { |
| commandEncoder104.copyBufferToTexture({ |
| /* bytesInLastRow: 8 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 5940 */ |
| offset: 5940, |
| buffer: buffer64, |
| }, { |
| texture: texture108, |
| mipLevel: 0, |
| origin: {x: 0, y: 6, z: 0}, |
| aspect: 'all', |
| }, {width: 2, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup58 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout6, |
| entries: [ |
| {binding: 323, resource: {buffer: buffer60, offset: 256, size: 1192}}, |
| {binding: 144, resource: textureView2}, |
| ], |
| }); |
| let buffer75 = device0.createBuffer({size: 3174, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE}); |
| let texture200 = device0.createTexture({ |
| size: [492, 1, 1], |
| sampleCount: 1, |
| format: 'rg16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture201 = device0.createTexture({ |
| size: {width: 1230, height: 30, depthOrArrayLayers: 721}, |
| mipLevelCount: 3, |
| dimension: '3d', |
| format: 'r8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let texture202 = gpuCanvasContext1.getCurrentTexture(); |
| let computePassEncoder92 = commandEncoder104.beginComputePass({}); |
| try { |
| computePassEncoder23.setBindGroup(1, bindGroup16); |
| } catch {} |
| try { |
| renderPassEncoder22.setBindGroup(1, bindGroup41, new Uint32Array(1542), 535, 0); |
| } catch {} |
| try { |
| renderPassEncoder21.setBlendConstant({ r: 251.9, g: -387.8, b: 770.4, a: -225.1, }); |
| } catch {} |
| try { |
| buffer71.unmap(); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| document.body.append(img1); |
| let recycledExplicitBindGroupLayout7 = pipeline18.getBindGroupLayout(1); |
| let bindGroup59 = device0.createBindGroup({layout: veryExplicitBindGroupLayout14, entries: [{binding: 21, resource: textureView60}]}); |
| let texture203 = device0.createTexture({ |
| size: [20, 22, 1], |
| sampleCount: 1, |
| format: 'rgba8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView122 = texture111.createView({mipLevelCount: 1, arrayLayerCount: 2}); |
| try { |
| computePassEncoder21.end(); |
| } catch {} |
| try { |
| computePassEncoder91.setPipeline(pipeline18); |
| } catch {} |
| try { |
| renderPassEncoder33.executeBundles([renderBundle8, renderBundle1, renderBundle8]); |
| } catch {} |
| try { |
| commandEncoder21.copyBufferToTexture({ |
| /* bytesInLastRow: 8 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 3176 */ |
| offset: 3176, |
| buffer: buffer10, |
| }, { |
| texture: texture111, |
| mipLevel: 1, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture197, |
| mipLevel: 1, |
| origin: {x: 227, y: 3, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(45).fill(199), /* required buffer size: 45 */ |
| {offset: 45, rowsPerImage: 2}, {width: 566, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 470, height: 2, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame15, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture45, |
| mipLevel: 0, |
| origin: {x: 71, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| texture34.label = '\u46d3\u5195\u830b\u4def\u{1f89b}\ue225\u05a2\u0dee\u5440\u0d75\u0cea'; |
| } catch {} |
| let veryExplicitBindGroupLayout17 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 21, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'r32uint', access: 'read-write', viewDimension: '2d-array' }, |
| }, |
| ], |
| }); |
| let commandEncoder105 = device0.createCommandEncoder(); |
| let texture204 = device0.createTexture({ |
| size: [40, 45, 14], |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let sampler62 = device0.createSampler({ |
| addressModeU: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 92.76, |
| maxAnisotropy: 20, |
| }); |
| try { |
| renderPassEncoder13.setPipeline(pipeline12); |
| } catch {} |
| try { |
| renderPassEncoder12.setVertexBuffer(3, buffer21, 0, 5_997); |
| } catch {} |
| let arrayBuffer15 = buffer26.getMappedRange(200, 36); |
| try { |
| commandEncoder105.copyBufferToTexture({ |
| /* bytesInLastRow: 520 widthInBlocks: 130 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1684 */ |
| offset: 1684, |
| buffer: buffer10, |
| }, { |
| texture: texture173, |
| mipLevel: 0, |
| origin: {x: 136, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 130, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer47, 784, new Int16Array(8895), 324, 24); |
| } catch {} |
| let buffer76 = device0.createBuffer({ |
| size: 544, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let texture205 = device0.createTexture({ |
| size: [246, 1, 1], |
| format: 'rg16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderPassEncoder34 = commandEncoder105.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView93, |
| clearValue: { r: 24.70, g: 60.70, b: -85.06, a: -815.0, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| maxDrawCount: 282169661, |
| }); |
| try { |
| computePassEncoder59.setBindGroup(3, bindGroup38); |
| } catch {} |
| try { |
| computePassEncoder91.setBindGroup(0, bindGroup2, new Uint32Array(273), 5, 0); |
| } catch {} |
| try { |
| renderPassEncoder17.beginOcclusionQuery(19); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture87, |
| mipLevel: 1, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'stencil-only', |
| }, new Uint8Array(174).fill(57), /* required buffer size: 174 */ |
| {offset: 174}, {width: 492, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture206 = device0.createTexture({ |
| size: {width: 153, height: 3, depthOrArrayLayers: 1}, |
| mipLevelCount: 3, |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture207 = device0.createTexture({ |
| size: [615], |
| sampleCount: 1, |
| dimension: '1d', |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rg8unorm'], |
| }); |
| let renderPassEncoder35 = commandEncoder21.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView101, |
| clearValue: { r: -782.1, g: -419.8, b: 451.9, a: 258.9, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| maxDrawCount: 142532300, |
| }); |
| try { |
| computePassEncoder80.setBindGroup(0, bindGroup6); |
| } catch {} |
| try { |
| renderPassEncoder11.setIndexBuffer(buffer74, 'uint32', 1_808, 104); |
| } catch {} |
| try { |
| externalTexture4.label = '\u7af0\udeae'; |
| } catch {} |
| let commandEncoder106 = device0.createCommandEncoder({}); |
| let texture208 = device0.createTexture({ |
| size: {width: 940, height: 5, depthOrArrayLayers: 1}, |
| dimension: '2d', |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder92.setPipeline(pipeline18); |
| } catch {} |
| try { |
| renderPassEncoder22.setIndexBuffer(buffer0, 'uint32', 376, 162); |
| } catch {} |
| try { |
| renderPassEncoder21.setVertexBuffer(3, buffer21, 10_900, 10_186); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 470, height: 2, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData12, |
| origin: { x: 3, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture45, |
| mipLevel: 0, |
| origin: {x: 227, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| if (!arrayBuffer14.detached) { new Uint8Array(arrayBuffer14).fill(0x55); }; |
| } catch {} |
| let commandEncoder107 = device0.createCommandEncoder({}); |
| let texture209 = device0.createTexture({ |
| size: [32, 32, 21], |
| mipLevelCount: 1, |
| format: 'rg32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let sampler63 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| }); |
| try { |
| renderPassEncoder12.setBindGroup(1, bindGroup0); |
| } catch {} |
| try { |
| renderPassEncoder17.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder19.executeBundles([renderBundle9, renderBundle1]); |
| } catch {} |
| try { |
| renderPassEncoder30.setBlendConstant({ r: 574.2, g: -515.2, b: 422.7, a: -769.0, }); |
| } catch {} |
| try { |
| renderPassEncoder35.setIndexBuffer(buffer63, 'uint32', 396, 571); |
| } catch {} |
| let textureView123 = texture209.createView({dimension: 'cube-array', baseArrayLayer: 2, arrayLayerCount: 6}); |
| let textureView124 = texture191.createView({dimension: '2d', mipLevelCount: 1, arrayLayerCount: 1}); |
| let computePassEncoder93 = commandEncoder107.beginComputePass(); |
| let renderPassEncoder36 = commandEncoder106.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView55, |
| clearValue: { r: -830.4, g: 568.3, b: -933.5, a: -343.4, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet0, |
| }); |
| try { |
| computePassEncoder75.setBindGroup(0, bindGroup57); |
| } catch {} |
| try { |
| globalThis.someLabel = externalTexture5.label; |
| } catch {} |
| let veryExplicitBindGroupLayout18 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 775, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let commandEncoder108 = device0.createCommandEncoder(); |
| let texture210 = device0.createTexture({ |
| size: [1968, 1, 9], |
| mipLevelCount: 5, |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder38.end(); |
| } catch {} |
| try { |
| renderPassEncoder26.beginOcclusionQuery(82); |
| } catch {} |
| try { |
| renderPassEncoder36.executeBundles([renderBundle5]); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer19, 1472, new Int16Array(11497), 1447, 56); |
| } catch {} |
| await gc(); |
| let buffer77 = device0.createBuffer({size: 9592, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE}); |
| let computePassEncoder94 = commandEncoder49.beginComputePass({}); |
| let renderPassEncoder37 = commandEncoder108.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView120, |
| depthSlice: 14, |
| clearValue: { r: -454.7, g: 947.0, b: -891.6, a: 532.5, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| maxDrawCount: 1444098, |
| }); |
| try { |
| renderPassEncoder29.setIndexBuffer(buffer41, 'uint32', 2_160, 2_579); |
| } catch {} |
| try { |
| renderPassEncoder18.setPipeline(pipeline24); |
| } catch {} |
| let buffer78 = device0.createBuffer({size: 40445, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| try { |
| computePassEncoder63.setBindGroup(1, bindGroup22, new Uint32Array(1424), 639, 0); |
| } catch {} |
| try { |
| computePassEncoder17.end(); |
| } catch {} |
| try { |
| computePassEncoder94.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder25.setBindGroup(3, bindGroup50, new Uint32Array(654), 48, 0); |
| } catch {} |
| try { |
| renderPassEncoder25.setIndexBuffer(buffer57, 'uint32', 20, 938); |
| } catch {} |
| try { |
| renderPassEncoder21.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder24.setVertexBuffer(2, buffer71, 0); |
| } catch {} |
| try { |
| commandEncoder17.copyBufferToTexture({ |
| /* bytesInLastRow: 12 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1644 */ |
| offset: 1644, |
| bytesPerRow: 30720, |
| buffer: buffer57, |
| }, { |
| texture: texture100, |
| mipLevel: 1, |
| origin: {x: 7, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 3, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| let commandEncoder109 = device0.createCommandEncoder({}); |
| let textureView125 = texture79.createView({dimension: '2d-array'}); |
| let texture211 = device0.createTexture({ |
| size: {width: 153, height: 3, depthOrArrayLayers: 1}, |
| mipLevelCount: 3, |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| let computePassEncoder95 = commandEncoder17.beginComputePass({}); |
| let sampler64 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'mirror-repeat', lodMaxClamp: 92.43}); |
| try { |
| computePassEncoder60.setBindGroup(1, bindGroup36, new Uint32Array(2328), 519, 0); |
| } catch {} |
| try { |
| computePassEncoder93.setPipeline(pipeline19); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| try { |
| commandEncoder109.copyBufferToBuffer(buffer32, 264, buffer66, 1052, 5952); |
| } catch {} |
| try { |
| commandEncoder109.copyTextureToTexture({ |
| texture: texture126, |
| mipLevel: 1, |
| origin: {x: 71, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture196, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 5, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(img3); |
| let computePassEncoder96 = commandEncoder109.beginComputePass({}); |
| let renderBundleEncoder13 = device0.createRenderBundleEncoder({colorFormats: ['rg8unorm'], depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| computePassEncoder34.setBindGroup(0, bindGroup42, new Uint32Array(1974), 72, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder45); computePassEncoder45.dispatchWorkgroupsIndirect(buffer20, 820); }; |
| } catch {} |
| try { |
| renderPassEncoder32.setBindGroup(2, bindGroup13, new Uint32Array(4282), 171, 0); |
| } catch {} |
| try { |
| renderBundleEncoder13.setBindGroup(3, bindGroup27); |
| } catch {} |
| try { |
| renderBundleEncoder13.setBindGroup(3, bindGroup20, new Uint32Array(478), 3, 0); |
| } catch {} |
| try { |
| renderBundleEncoder13.setIndexBuffer(buffer24, 'uint32', 48, 34); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| let texture212 = device0.createTexture({ |
| size: {width: 246, height: 1, depthOrArrayLayers: 104}, |
| dimension: '3d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView126 = texture130.createView({dimension: '2d', baseArrayLayer: 15}); |
| let renderBundle13 = renderBundleEncoder13.finish({}); |
| try { |
| renderPassEncoder23.setVertexBuffer(1, undefined, 248_651_288); |
| } catch {} |
| try { |
| if (!arrayBuffer4.detached) { new Uint8Array(arrayBuffer4).fill(0x55); }; |
| } catch {} |
| await gc(); |
| let sampler65 = device0.createSampler({magFilter: 'linear', minFilter: 'linear', mipmapFilter: 'linear', lodMaxClamp: 81.25, maxAnisotropy: 2}); |
| try { |
| renderPassEncoder33.setBindGroup(1, bindGroup36); |
| } catch {} |
| try { |
| renderPassEncoder34.setBindGroup(3, bindGroup56, new Uint32Array(1754), 543, 0); |
| } catch {} |
| try { |
| renderPassEncoder26.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder19.setPipeline(pipeline10); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 246, height: 1, depthOrArrayLayers: 307} |
| */ |
| { |
| source: imageData4, |
| origin: { x: 4, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture6, |
| mipLevel: 0, |
| origin: {x: 3, y: 0, z: 17}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 2, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(img0); |
| let bindGroup60 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout3, |
| entries: [ |
| {binding: 323, resource: {buffer: buffer37, offset: 2304, size: 1312}}, |
| {binding: 144, resource: textureView97}, |
| ], |
| }); |
| let texture213 = device0.createTexture({size: [307, 7, 1], format: 'rg8unorm', usage: GPUTextureUsage.COPY_DST}); |
| let textureView127 = texture38.createView({baseMipLevel: 0, mipLevelCount: 1}); |
| try { |
| renderPassEncoder34.executeBundles([renderBundle11]); |
| } catch {} |
| try { |
| renderPassEncoder19.setPipeline(pipeline0); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer8]); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let pipelineLayout14 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout7]}); |
| let textureView128 = texture203.createView({dimension: '2d-array', format: 'rgba8sint'}); |
| let textureView129 = texture191.createView({dimension: '2d-array', mipLevelCount: 1}); |
| try { |
| computePassEncoder28.setBindGroup(0, bindGroup4, new Uint32Array(1322), 73, 0); |
| } catch {} |
| try { |
| renderPassEncoder32.beginOcclusionQuery(11); |
| } catch {} |
| try { |
| renderPassEncoder31.executeBundles([renderBundle11, renderBundle6]); |
| } catch {} |
| try { |
| renderPassEncoder10.setIndexBuffer(buffer66, 'uint32', 3_840, 4_597); |
| } catch {} |
| try { |
| renderPassEncoder35.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderPassEncoder36.setVertexBuffer(1, buffer40); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer37, 660, new BigUint64Array(2134), 618, 192); |
| } catch {} |
| let bindGroup61 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [ |
| {binding: 144, resource: textureView2}, |
| {binding: 323, resource: {buffer: buffer47, offset: 1536, size: 968}}, |
| ], |
| }); |
| let buffer79 = device0.createBuffer({ |
| size: 9647, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let textureView130 = texture208.createView({dimension: '2d-array'}); |
| let sampler66 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 87.33, |
| compare: 'greater', |
| }); |
| try { |
| computePassEncoder78.setBindGroup(3, bindGroup22); |
| } catch {} |
| try { |
| computePassEncoder23.setBindGroup(2, bindGroup29, new Uint32Array(8657), 1_145, 0); |
| } catch {} |
| try { |
| computePassEncoder95.setPipeline(pipeline13); |
| } catch {} |
| try { |
| renderPassEncoder15.executeBundles([renderBundle1, renderBundle3, renderBundle9]); |
| } catch {} |
| try { |
| renderPassEncoder23.setPipeline(pipeline24); |
| } catch {} |
| try { |
| renderPassEncoder30.setVertexBuffer(7, buffer32, 1_732, 3_141); |
| } catch {} |
| let buffer80 = device0.createBuffer({ |
| size: 3354, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder110 = device0.createCommandEncoder({}); |
| let texture214 = gpuCanvasContext0.getCurrentTexture(); |
| try { |
| computePassEncoder96.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder36.setVertexBuffer(2, buffer24, 0, 123); |
| } catch {} |
| try { |
| commandEncoder110.copyBufferToTexture({ |
| /* bytesInLastRow: 16 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 9656 */ |
| offset: 9656, |
| bytesPerRow: 23040, |
| buffer: buffer12, |
| }, { |
| texture: texture168, |
| mipLevel: 0, |
| origin: {x: 3, y: 22, z: 0}, |
| aspect: 'all', |
| }, {width: 2, height: 3, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer81 = device0.createBuffer({ |
| size: 18614, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE, |
| }); |
| let commandEncoder111 = device0.createCommandEncoder(); |
| let texture215 = device0.createTexture({ |
| size: [153, 3, 11], |
| mipLevelCount: 5, |
| dimension: '3d', |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder97 = commandEncoder110.beginComputePass({}); |
| try { |
| computePassEncoder97.setPipeline(pipeline25); |
| } catch {} |
| try { |
| renderPassEncoder32.executeBundles([renderBundle11]); |
| } catch {} |
| try { |
| renderPassEncoder37.setViewport(25.37568470455248, 31.68210002388615, 4.1808338615647695, 3.8966770339722827, 0.7460416486058818, 0.9986797655597477); |
| } catch {} |
| try { |
| renderPassEncoder20.setPipeline(pipeline14); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1968, height: 1, depthOrArrayLayers: 140} |
| */ |
| { |
| source: imageData7, |
| origin: { x: 6, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture120, |
| mipLevel: 0, |
| origin: {x: 222, y: 0, z: 15}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(img4); |
| let textureView131 = texture141.createView({}); |
| let texture216 = device0.createTexture({ |
| size: {width: 470, height: 2, depthOrArrayLayers: 1}, |
| mipLevelCount: 1, |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView132 = texture85.createView({}); |
| let computePassEncoder98 = commandEncoder111.beginComputePass({}); |
| let renderBundleEncoder14 = device0.createRenderBundleEncoder({colorFormats: ['r8uint', 'r8sint'], stencilReadOnly: true}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder20); computePassEncoder20.dispatchWorkgroupsIndirect(buffer52, 232); }; |
| } catch {} |
| try { |
| computePassEncoder98.setPipeline(pipeline19); |
| } catch {} |
| try { |
| renderPassEncoder25.setBindGroup(2, bindGroup15); |
| } catch {} |
| try { |
| renderPassEncoder11.setBindGroup(0, bindGroup43, new Uint32Array(6970), 152, 0); |
| } catch {} |
| try { |
| renderPassEncoder31.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderBundleEncoder14.setBindGroup(3, bindGroup25); |
| } catch {} |
| try { |
| renderBundleEncoder14.setBindGroup(1, bindGroup46, new Uint32Array(963), 174, 0); |
| } catch {} |
| let texture217 = device0.createTexture({ |
| size: {width: 307}, |
| dimension: '1d', |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder36.setBindGroup(3, bindGroup38, new Uint32Array(1150), 92, 0); |
| } catch {} |
| try { |
| renderBundleEncoder14.setBindGroup(2, bindGroup9); |
| } catch {} |
| try { |
| renderBundleEncoder14.setVertexBuffer(0, buffer60, 0, 493); |
| } catch {} |
| document.body.prepend(img1); |
| let bindGroup62 = device0.createBindGroup({layout: autogeneratedBindGroupLayout2, entries: [{binding: 144, resource: textureView2}]}); |
| let commandEncoder112 = device0.createCommandEncoder({}); |
| let renderBundle14 = renderBundleEncoder14.finish({}); |
| try { |
| computePassEncoder23.end(); |
| } catch {} |
| try { |
| renderPassEncoder29.setBindGroup(1, bindGroup9, new Uint32Array(4158), 290, 0); |
| } catch {} |
| try { |
| renderPassEncoder37.executeBundles([renderBundle5, renderBundle10, renderBundle12, renderBundle12, renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder34.setStencilReference(187); |
| } catch {} |
| document.body.append(img4); |
| let recycledExplicitBindGroupLayout8 = pipeline24.getBindGroupLayout(0); |
| let commandEncoder113 = device0.createCommandEncoder({}); |
| let texture218 = device0.createTexture({ |
| size: {width: 940, height: 5, depthOrArrayLayers: 1}, |
| mipLevelCount: 4, |
| format: 'r8sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let computePassEncoder99 = commandEncoder113.beginComputePass({}); |
| try { |
| computePassEncoder82.setBindGroup(1, bindGroup2); |
| } catch {} |
| try { |
| renderPassEncoder12.setBindGroup(2, bindGroup36, new Uint32Array(1538), 232, 0); |
| } catch {} |
| try { |
| commandEncoder112.resolveQuerySet(querySet1, 88, 5, buffer2, 256); |
| } catch {} |
| let bindGroup63 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout6, |
| entries: [ |
| {binding: 64, resource: {buffer: buffer71, offset: 4096, size: 3936}}, |
| {binding: 97, resource: externalTexture3}, |
| {binding: 68, resource: {buffer: buffer40, offset: 5632}}, |
| {binding: 45, resource: {buffer: buffer1, offset: 1536, size: 1936}}, |
| ], |
| }); |
| let commandEncoder114 = device0.createCommandEncoder({}); |
| let texture219 = device0.createTexture({ |
| size: {width: 940, height: 5, depthOrArrayLayers: 1}, |
| dimension: '2d', |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView133 = texture131.createView({}); |
| let computePassEncoder100 = commandEncoder112.beginComputePass({}); |
| try { |
| renderPassEncoder12.setIndexBuffer(buffer66, 'uint32', 15_376, 1_325); |
| } catch {} |
| try { |
| renderPassEncoder31.setPipeline(pipeline26); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| commandEncoder114.copyBufferToTexture({ |
| /* bytesInLastRow: 22 widthInBlocks: 11 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 166 */ |
| offset: 166, |
| buffer: buffer17, |
| }, { |
| texture: texture212, |
| mipLevel: 0, |
| origin: {x: 9, y: 0, z: 8}, |
| aspect: 'all', |
| }, {width: 11, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| let commandEncoder115 = device0.createCommandEncoder({}); |
| let texture220 = device0.createTexture({ |
| size: {width: 1968, height: 1, depthOrArrayLayers: 26}, |
| mipLevelCount: 3, |
| dimension: '3d', |
| format: 'r8sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder9); computePassEncoder9.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| computePassEncoder99.setPipeline(pipeline19); |
| } catch {} |
| try { |
| commandEncoder27.copyBufferToBuffer(buffer32, 372, buffer24, 20, 0); |
| } catch {} |
| try { |
| commandEncoder27.copyBufferToTexture({ |
| /* bytesInLastRow: 50 widthInBlocks: 25 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 1654 */ |
| offset: 1654, |
| buffer: buffer57, |
| }, { |
| texture: texture213, |
| mipLevel: 0, |
| origin: {x: 33, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 25, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| renderPassEncoder15.insertDebugMarker('\u4f8a'); |
| } catch {} |
| let pipeline28 = device0.createRenderPipeline({ |
| layout: 'auto', |
| multisample: {mask: 0x796ed45}, |
| fragment: { |
| module: shaderModule3, |
| entryPoint: 'fragment3', |
| constants: {}, |
| targets: [{format: 'rg8unorm', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN}], |
| }, |
| vertex: {module: shaderModule7, entryPoint: 'vertex7', constants: {}, buffers: []}, |
| primitive: {topology: 'line-list', frontFace: 'cw', cullMode: 'back'}, |
| }); |
| let buffer82 = device0.createBuffer({ |
| size: 274, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM, |
| }); |
| let textureView134 = texture68.createView({format: 'rg8unorm', mipLevelCount: 1}); |
| let computePassEncoder101 = commandEncoder114.beginComputePass({}); |
| let sampler67 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| mipmapFilter: 'linear', |
| compare: 'less', |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder33); computePassEncoder33.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| renderPassEncoder10.executeBundles([renderBundle6]); |
| } catch {} |
| try { |
| renderPassEncoder29.setPipeline(pipeline21); |
| } catch {} |
| try { |
| renderPassEncoder11.setVertexBuffer(2, buffer14, 0, 11_737); |
| } catch {} |
| document.body.append(img2); |
| let texture221 = device0.createTexture({ |
| size: [10, 11, 32], |
| mipLevelCount: 1, |
| format: 'r8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder102 = commandEncoder115.beginComputePass({}); |
| let renderPassEncoder38 = commandEncoder27.beginRenderPass({colorAttachments: [{view: textureView101, loadOp: 'clear', storeOp: 'discard'}]}); |
| let sampler68 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 61.85, |
| maxAnisotropy: 17, |
| }); |
| try { |
| computePassEncoder34.setBindGroup(3, bindGroup31, new Uint32Array(753), 38, 0); |
| } catch {} |
| try { |
| renderPassEncoder23.setBindGroup(0, bindGroup57, new Uint32Array(2827), 141, 0); |
| } catch {} |
| try { |
| renderPassEncoder23.drawIndexedIndirect(buffer42, 1_740); |
| } catch {} |
| try { |
| renderPassEncoder23.drawIndirect(buffer51, 12); |
| } catch {} |
| try { |
| renderPassEncoder29.setPipeline(pipeline10); |
| } catch {} |
| try { |
| renderPassEncoder26.insertDebugMarker('\u2e94'); |
| } catch {} |
| let pipeline29 = await device0.createRenderPipelineAsync({ |
| layout: pipelineLayout9, |
| fragment: { |
| module: shaderModule7, |
| targets: [{format: 'r8uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE}, {format: 'r8sint', writeMask: GPUColorWrite.ALL | GPUColorWrite.RED}], |
| }, |
| vertex: { |
| module: shaderModule0, |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 928, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'uint32x4', offset: 8, shaderLocation: 13}, |
| {format: 'uint8x2', offset: 16, shaderLocation: 0}, |
| ], |
| }, |
| ], |
| }, |
| }); |
| let bindGroup64 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout16, |
| entries: [ |
| {binding: 34, resource: textureView111}, |
| {binding: 73, resource: sampler33}, |
| {binding: 430, resource: sampler31}, |
| {binding: 133, resource: {buffer: buffer20, offset: 8960, size: 6495}}, |
| ], |
| }); |
| let buffer83 = device0.createBuffer({ |
| size: 10167, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE, |
| }); |
| try { |
| computePassEncoder64.setBindGroup(3, bindGroup35); |
| } catch {} |
| try { |
| computePassEncoder100.setPipeline(pipeline11); |
| } catch {} |
| try { |
| renderPassEncoder13.executeBundles([renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder23.drawIndexedIndirect(buffer69, 276); |
| } catch {} |
| try { |
| renderPassEncoder23.drawIndirect(buffer81, 3_584); |
| } catch {} |
| try { |
| renderPassEncoder24.setVertexBuffer(2, buffer22, 0, 1_275); |
| } catch {} |
| let veryExplicitBindGroupLayout19 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 44, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false }, |
| }, |
| ], |
| }); |
| let buffer84 = device0.createBuffer({ |
| size: 26119, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| try { |
| computePassEncoder81.setBindGroup(2, bindGroup54, new Uint32Array(1004), 322, 0); |
| } catch {} |
| try { |
| renderPassEncoder24.setBindGroup(3, bindGroup2); |
| } catch {} |
| try { |
| renderPassEncoder23.draw(504, 594, 1_409_897_769, 104_628_798); |
| } catch {} |
| try { |
| renderPassEncoder23.drawIndexed(12, 71, 33, 838_837_730, 596_381_921); |
| } catch {} |
| try { |
| renderPassEncoder23.drawIndexedIndirect(buffer20, 7_636); |
| } catch {} |
| try { |
| renderPassEncoder14.setVertexBuffer(1, buffer73, 0, 571); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| let bindGroup65 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout2, |
| entries: [{binding: 144, resource: textureView2}, {binding: 323, resource: {buffer: buffer74, offset: 512}}], |
| }); |
| try { |
| computePassEncoder56.setBindGroup(0, bindGroup58, new Uint32Array(601), 113, 0); |
| } catch {} |
| try { |
| computePassEncoder102.setPipeline(pipeline23); |
| } catch {} |
| try { |
| renderPassEncoder23.end(); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| commandEncoder74.copyTextureToBuffer({ |
| texture: texture119, |
| mipLevel: 0, |
| origin: {x: 155, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 524 widthInBlocks: 131 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 5144 */ |
| offset: 5144, |
| bytesPerRow: 2560, |
| buffer: buffer65, |
| }, {width: 131, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| await gc(); |
| let buffer85 = device0.createBuffer({ |
| size: 5026, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let texture222 = gpuCanvasContext1.getCurrentTexture(); |
| let textureView135 = texture118.createView({dimension: '2d', format: 'rgba32sint', baseArrayLayer: 0}); |
| let computePassEncoder103 = commandEncoder74.beginComputePass(); |
| try { |
| computePassEncoder0.setBindGroup(2, bindGroup41, new Uint32Array(302), 9, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder33); computePassEncoder33.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder45.end(); |
| } catch {} |
| try { |
| renderPassEncoder18.setPipeline(pipeline15); |
| } catch {} |
| let veryExplicitBindGroupLayout20 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 22, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 51, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: 'cube-array', sampleType: 'uint', multisampled: false }, |
| }, |
| { |
| binding: 60, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| externalTexture: {}, |
| }, |
| { |
| binding: 67, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 80, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 114, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: true }, |
| }, |
| { |
| binding: 160, |
| visibility: GPUShaderStage.COMPUTE, |
| texture: { viewDimension: '1d', sampleType: 'sint', multisampled: false }, |
| }, |
| { |
| binding: 188, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'r32float', access: 'read-only', viewDimension: '1d' }, |
| }, |
| { |
| binding: 390, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| sampler: { type: 'filtering' }, |
| }, |
| ], |
| }); |
| let computePassEncoder104 = commandEncoder55.beginComputePass({}); |
| try { |
| computePassEncoder101.setPipeline(pipeline18); |
| } catch {} |
| try { |
| renderPassEncoder18.setBindGroup(0, bindGroup61); |
| } catch {} |
| try { |
| renderPassEncoder32.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder30.setIndexBuffer(buffer52, 'uint16', 274, 395); |
| } catch {} |
| try { |
| renderPassEncoder12.setPipeline(pipeline12); |
| } catch {} |
| try { |
| renderPassEncoder38.pushDebugGroup('\u8bf4'); |
| } catch {} |
| try { |
| if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55); }; |
| } catch {} |
| let buffer86 = device0.createBuffer({ |
| size: 27119, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let texture223 = device0.createTexture({ |
| size: [984, 1, 1], |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_DST, |
| viewFormats: ['rg8unorm', 'rg8unorm'], |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder33); computePassEncoder33.dispatchWorkgroupsIndirect(buffer1, 448); }; |
| } catch {} |
| try { |
| renderPassEncoder13.setVertexBuffer(1, buffer51, 268, 2_484); |
| } catch {} |
| try { |
| if (!arrayBuffer8.detached) { new Uint8Array(arrayBuffer8).fill(0x55); }; |
| } catch {} |
| let videoFrame18 = new VideoFrame(offscreenCanvas1, {timestamp: 0}); |
| try { |
| computePassEncoder104.setPipeline(pipeline18); |
| } catch {} |
| try { |
| renderPassEncoder26.setBindGroup(1, bindGroup43); |
| } catch {} |
| try { |
| renderPassEncoder14.setBindGroup(3, bindGroup6, new Uint32Array(2718), 768, 0); |
| } catch {} |
| try { |
| renderPassEncoder24.executeBundles([renderBundle2]); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture92, |
| mipLevel: 0, |
| origin: {x: 12, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(92).fill(107), /* required buffer size: 92 */ |
| {offset: 92}, {width: 8, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| if (!arrayBuffer10.detached) { new Uint8Array(arrayBuffer10).fill(0x55); }; |
| } catch {} |
| let videoFrame19 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte170m', primaries: 'bt709', transfer: 'linear'} }); |
| try { |
| computePassEncoder103.setPipeline(pipeline13); |
| } catch {} |
| try { |
| renderPassEncoder33.setBlendConstant({ r: -587.4, g: -323.4, b: 87.13, a: -432.1, }); |
| } catch {} |
| try { |
| renderPassEncoder21.setIndexBuffer(buffer8, 'uint32', 1_004, 20); |
| } catch {} |
| try { |
| renderPassEncoder35.setPipeline(pipeline4); |
| } catch {} |
| let renderBundleEncoder15 = device0.createRenderBundleEncoder({colorFormats: ['r8uint', 'r8sint'], depthReadOnly: true}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder75); computePassEncoder75.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder22.setBindGroup(0, bindGroup30, []); |
| } catch {} |
| try { |
| renderPassEncoder18.draw(170, 34, 629_999_836, 302_944_534); |
| } catch {} |
| try { |
| renderPassEncoder18.drawIndirect(buffer71, 10_184); |
| } catch {} |
| try { |
| renderPassEncoder29.setVertexBuffer(1, buffer7, 128); |
| } catch {} |
| try { |
| renderBundleEncoder15.setBindGroup(3, bindGroup21); |
| } catch {} |
| try { |
| renderBundleEncoder15.setIndexBuffer(buffer74, 'uint32', 308, 114); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture82, |
| mipLevel: 0, |
| origin: {x: 0, y: 1, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(68).fill(94), /* required buffer size: 68 */ |
| {offset: 68, bytesPerRow: 106}, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 615, height: 15, depthOrArrayLayers: 1} |
| */ |
| { |
| source: offscreenCanvas0, |
| origin: { x: 17, y: 60 }, |
| flipY: false, |
| }, { |
| texture: texture89, |
| mipLevel: 1, |
| origin: {x: 54, y: 1, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 28, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder116 = device0.createCommandEncoder({}); |
| let textureView136 = texture53.createView({}); |
| let computePassEncoder105 = commandEncoder116.beginComputePass(); |
| try { |
| computePassEncoder105.setPipeline(pipeline27); |
| } catch {} |
| try { |
| renderPassEncoder24.executeBundles([renderBundle10, renderBundle11, renderBundle10]); |
| } catch {} |
| try { |
| renderPassEncoder18.draw(22, 373, 798_951_637, 2_575_700_424); |
| } catch {} |
| try { |
| renderPassEncoder18.drawIndirect(buffer20, 1_848); |
| } catch {} |
| try { |
| renderPassEncoder16.setIndexBuffer(buffer81, 'uint16', 136, 1_833); |
| } catch {} |
| try { |
| renderPassEncoder21.setPipeline(pipeline12); |
| } catch {} |
| try { |
| renderBundleEncoder15.setVertexBuffer(1, buffer73); |
| } catch {} |
| try { |
| renderPassEncoder24.executeBundles([renderBundle1, renderBundle4, renderBundle12, renderBundle1]); |
| } catch {} |
| try { |
| renderPassEncoder18.drawIndirect(buffer71, 3_680); |
| } catch {} |
| try { |
| renderBundleEncoder15.setBindGroup(1, bindGroup20, new Uint32Array(519), 98, 0); |
| } catch {} |
| try { |
| renderBundleEncoder15.setIndexBuffer(buffer74, 'uint32', 2_112, 800); |
| } catch {} |
| let textureView137 = texture27.createView({dimension: '2d-array', mipLevelCount: 1}); |
| try { |
| computePassEncoder34.setBindGroup(3, bindGroup42, new Uint32Array(2137), 666, 0); |
| } catch {} |
| try { |
| computePassEncoder9.end(); |
| } catch {} |
| try { |
| renderPassEncoder18.draw(186, 149, 988_399_350, 51_548_223); |
| } catch {} |
| try { |
| renderPassEncoder24.setPipeline(pipeline8); |
| } catch {} |
| try { |
| renderBundleEncoder15.setIndexBuffer(buffer0, 'uint32', 1_584, 174); |
| } catch {} |
| try { |
| renderBundleEncoder15.setPipeline(pipeline29); |
| } catch {} |
| try { |
| renderBundleEncoder15.setVertexBuffer(5, buffer86, 0); |
| } catch {} |
| try { |
| commandEncoder11.copyBufferToBuffer(buffer55, 116, buffer66, 528, 572); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer70, 4, new Int16Array(7544), 1926, 12); |
| } catch {} |
| try { |
| computePassEncoder89.setBindGroup(0, bindGroup26); |
| } catch {} |
| try { |
| renderPassEncoder26.setBindGroup(1, bindGroup38); |
| } catch {} |
| try { |
| renderPassEncoder26.beginOcclusionQuery(79); |
| } catch {} |
| try { |
| renderPassEncoder37.executeBundles([renderBundle0, renderBundle4, renderBundle8, renderBundle5]); |
| } catch {} |
| try { |
| renderPassEncoder18.draw(297, 72, 310_753_450, 1_233_899_501); |
| } catch {} |
| try { |
| renderPassEncoder18.drawIndirect(buffer82, 40); |
| } catch {} |
| try { |
| renderPassEncoder14.setIndexBuffer(buffer37, 'uint32', 332, 1_154); |
| } catch {} |
| try { |
| renderPassEncoder21.setPipeline(pipeline20); |
| } catch {} |
| try { |
| renderBundleEncoder15.setBindGroup(0, bindGroup60, new Uint32Array(259), 79, 0); |
| } catch {} |
| try { |
| renderBundleEncoder15.setIndexBuffer(buffer14, 'uint32', 2_016, 15_656); |
| } catch {} |
| try { |
| renderBundleEncoder15.setVertexBuffer(2, buffer86); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer47, 120, new Float32Array(946)); |
| } catch {} |
| let imageData16 = new ImageData(24, 8); |
| let computePassEncoder106 = commandEncoder11.beginComputePass({}); |
| try { |
| renderPassEncoder26.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder21.executeBundles([renderBundle3]); |
| } catch {} |
| try { |
| renderPassEncoder17.setIndexBuffer(buffer67, 'uint16', 766, 189); |
| } catch {} |
| try { |
| renderPassEncoder24.setPipeline(pipeline10); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer47, 5736, new Int16Array(5433), 400, 2048); |
| } catch {} |
| document.body.append(img4); |
| let bindGroup66 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [{binding: 41, resource: textureView8}, {binding: 39, resource: {buffer: buffer68, offset: 4352}}], |
| }); |
| let commandEncoder117 = device0.createCommandEncoder({}); |
| let computePassEncoder107 = commandEncoder117.beginComputePass({}); |
| let renderBundle15 = renderBundleEncoder15.finish({}); |
| let sampler69 = device0.createSampler({ |
| addressModeV: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 77.50, |
| maxAnisotropy: 6, |
| }); |
| try { |
| computePassEncoder30.setBindGroup(0, bindGroup5); |
| } catch {} |
| try { |
| computePassEncoder106.setPipeline(pipeline19); |
| } catch {} |
| try { |
| renderPassEncoder37.setBindGroup(3, bindGroup58); |
| } catch {} |
| try { |
| renderPassEncoder18.draw(1, 72, 578_547_956, 580_306_040); |
| } catch {} |
| try { |
| renderPassEncoder20.setPipeline(pipeline24); |
| } catch {} |
| let arrayBuffer16 = buffer28.getMappedRange(3392, 236); |
| let promise8 = device0.queue.onSubmittedWorkDone(); |
| let texture224 = device0.createTexture({ |
| size: {width: 1968, height: 1, depthOrArrayLayers: 195}, |
| mipLevelCount: 3, |
| dimension: '3d', |
| format: 'r8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let sampler70 = device0.createSampler({addressModeU: 'repeat', lodMinClamp: 72.40, lodMaxClamp: 86.49, compare: 'equal'}); |
| try { |
| computePassEncoder107.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderPassEncoder17.setBindGroup(2, bindGroup35, new Uint32Array(503), 113, 0); |
| } catch {} |
| try { |
| renderPassEncoder18.end(); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let commandEncoder118 = device0.createCommandEncoder({}); |
| let querySet15 = device0.createQuerySet({type: 'occlusion', count: 498}); |
| let commandBuffer9 = commandEncoder63.finish(); |
| let textureView138 = texture216.createView({ |
| label: '\u{1fcfc}\u{1fa68}\u02e7\u5a1f\u4237\ued43\u0ae7\u{1fccf}\u{1f99e}', |
| dimension: '2d', |
| aspect: 'all', |
| format: 'r8sint', |
| }); |
| let computePassEncoder108 = commandEncoder118.beginComputePass(); |
| try { |
| computePassEncoder89.setBindGroup(1, bindGroup54, new Uint32Array(1146), 279, 0); |
| } catch {} |
| try { |
| computePassEncoder108.setPipeline(pipeline27); |
| } catch {} |
| try { |
| renderPassEncoder37.setIndexBuffer(buffer0, 'uint16', 32, 193); |
| } catch {} |
| try { |
| renderPassEncoder33.setVertexBuffer(1, buffer32, 76); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| renderPassEncoder14.insertDebugMarker('\u39f2'); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture86, |
| mipLevel: 0, |
| origin: {x: 230, y: 0, z: 13}, |
| aspect: 'all', |
| }, new Uint8Array(151_656).fill(24), /* required buffer size: 151_656 */ |
| {offset: 43, bytesPerRow: 179, rowsPerImage: 77}, {width: 27, height: 0, depthOrArrayLayers: 12}); |
| } catch {} |
| let commandEncoder119 = device0.createCommandEncoder({}); |
| let computePassEncoder109 = commandEncoder119.beginComputePass(); |
| let sampler71 = device0.createSampler({}); |
| try { |
| computePassEncoder109.setPipeline(pipeline19); |
| } catch {} |
| try { |
| renderPassEncoder17.executeBundles([renderBundle5, renderBundle1, renderBundle0, renderBundle8, renderBundle4, renderBundle1]); |
| } catch {} |
| try { |
| renderPassEncoder36.setIndexBuffer(buffer18, 'uint32', 64, 94); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1968, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageBitmap0, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture133, |
| mipLevel: 0, |
| origin: {x: 578, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer87 = device0.createBuffer({ |
| size: 706, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE, |
| }); |
| let textureView139 = texture209.createView({dimension: 'cube-array', baseArrayLayer: 1, arrayLayerCount: 6}); |
| let textureView140 = texture46.createView({dimension: '2d-array'}); |
| try { |
| renderPassEncoder37.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder24.setVertexBuffer(3, buffer13, 92, 1_519); |
| } catch {} |
| let imageData17 = new ImageData(72, 12); |
| try { |
| renderPassEncoder30.setIndexBuffer(buffer66, 'uint16', 8_180, 985); |
| } catch {} |
| let arrayBuffer17 = buffer28.getMappedRange(3632, 340); |
| try { |
| device0.queue.submit([commandBuffer9]); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 615, height: 15, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData1, |
| origin: { x: 12, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture89, |
| mipLevel: 1, |
| origin: {x: 35, y: 2, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 18, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(img3); |
| let bindGroup67 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout4, |
| entries: [ |
| {binding: 323, resource: {buffer: buffer16, offset: 0, size: 920}}, |
| {binding: 144, resource: textureView2}, |
| ], |
| }); |
| let buffer88 = device0.createBuffer({size: 3850, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX}); |
| let commandEncoder120 = device0.createCommandEncoder(); |
| let textureView141 = texture65.createView({dimension: '2d', arrayLayerCount: 1}); |
| try { |
| renderPassEncoder33.setVertexBuffer(5, buffer24, 0); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| try { |
| renderPassEncoder38.popDebugGroup(); |
| } catch {} |
| try { |
| await promise8; |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let textureView142 = texture19.createView({mipLevelCount: 1}); |
| let computePassEncoder110 = commandEncoder120.beginComputePass(); |
| try { |
| computePassEncoder110.setPipeline(pipeline23); |
| } catch {} |
| try { |
| renderPassEncoder22.setBindGroup(3, bindGroup49, new Uint32Array(223), 20, 1); |
| } catch {} |
| try { |
| renderPassEncoder12.setVertexBuffer(7, buffer79, 628); |
| } catch {} |
| let arrayBuffer18 = buffer28.getMappedRange(4024, 0); |
| offscreenCanvas1.width = 860; |
| let bindGroup68 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout2, |
| entries: [ |
| {binding: 144, resource: textureView5}, |
| {binding: 323, resource: {buffer: buffer37, offset: 1024, size: 1780}}, |
| ], |
| }); |
| let commandEncoder121 = device0.createCommandEncoder({}); |
| let texture225 = device0.createTexture({ |
| size: {width: 80, height: 90, depthOrArrayLayers: 1}, |
| dimension: '2d', |
| format: 'r8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| let texture226 = gpuCanvasContext0.getCurrentTexture(); |
| let textureView143 = texture67.createView({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder75); computePassEncoder75.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder20.end(); |
| } catch {} |
| try { |
| computePassEncoder47.setPipeline(pipeline18); |
| } catch {} |
| try { |
| renderPassEncoder21.executeBundles([renderBundle3, renderBundle1, renderBundle6]); |
| } catch {} |
| try { |
| renderPassEncoder27.setStencilReference(878); |
| } catch {} |
| try { |
| renderPassEncoder15.setPipeline(pipeline14); |
| } catch {} |
| let commandBuffer10 = commandEncoder20.finish(); |
| let renderPassEncoder39 = commandEncoder121.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView55, |
| clearValue: { r: -256.6, g: 774.9, b: -78.31, a: 463.8, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| }); |
| let sampler72 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| lodMaxClamp: 88.55, |
| }); |
| try { |
| renderPassEncoder34.setVertexBuffer(6, buffer33, 0, 7); |
| } catch {} |
| let commandEncoder122 = device0.createCommandEncoder({}); |
| let texture227 = device0.createTexture({ |
| size: [10, 11, 8], |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView144 = texture144.createView({baseMipLevel: 0}); |
| let computePassEncoder111 = commandEncoder122.beginComputePass({}); |
| try { |
| computePassEncoder81.setBindGroup(0, bindGroup3); |
| } catch {} |
| try { |
| computePassEncoder111.setPipeline(pipeline23); |
| } catch {} |
| try { |
| renderPassEncoder33.setBindGroup(0, bindGroup38, []); |
| } catch {} |
| try { |
| renderPassEncoder33.executeBundles([renderBundle1]); |
| } catch {} |
| try { |
| renderPassEncoder10.setPipeline(pipeline4); |
| } catch {} |
| let arrayBuffer19 = buffer28.getMappedRange(4056, 4); |
| try { |
| device0.queue.writeTexture({ |
| texture: texture198, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 4}, |
| aspect: 'all', |
| }, new Uint8Array(224_693).fill(151), /* required buffer size: 224_693 */ |
| {offset: 21, bytesPerRow: 238, rowsPerImage: 236}, {width: 49, height: 0, depthOrArrayLayers: 5}); |
| } catch {} |
| try { |
| renderPassEncoder13.setIndexBuffer(buffer13, 'uint32', 936, 901); |
| } catch {} |
| try { |
| renderPassEncoder20.setVertexBuffer(5, buffer51); |
| } catch {} |
| try { |
| buffer4.unmap(); |
| } catch {} |
| let bindGroup69 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 323, resource: {buffer: buffer63, offset: 768, size: 3556}}, |
| {binding: 144, resource: textureView4}, |
| ], |
| }); |
| let commandEncoder123 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder30.setBindGroup(3, bindGroup46, []); |
| } catch {} |
| try { |
| renderPassEncoder26.executeBundles([renderBundle5, renderBundle6, renderBundle4, renderBundle5, renderBundle8]); |
| } catch {} |
| try { |
| renderPassEncoder17.setStencilReference(1528); |
| } catch {} |
| try { |
| commandEncoder123.copyBufferToTexture({ |
| /* bytesInLastRow: 163 widthInBlocks: 163 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 2232 */ |
| offset: 2232, |
| buffer: buffer71, |
| }, { |
| texture: texture72, |
| mipLevel: 0, |
| origin: {x: 5, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 163, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder123.copyTextureToTexture({ |
| texture: texture6, |
| mipLevel: 1, |
| origin: {x: 15, y: 0, z: 2}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture23, |
| mipLevel: 0, |
| origin: {x: 22, y: 0, z: 51}, |
| aspect: 'all', |
| }, |
| {width: 6, height: 0, depthOrArrayLayers: 11}); |
| } catch {} |
| let buffer89 = device0.createBuffer({ |
| size: 4315, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder124 = device0.createCommandEncoder({}); |
| let computePassEncoder112 = commandEncoder124.beginComputePass({}); |
| let arrayBuffer20 = buffer28.getMappedRange(3984, 16); |
| try { |
| commandEncoder123.copyBufferToTexture({ |
| /* bytesInLastRow: 782 widthInBlocks: 391 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 798 */ |
| offset: 798, |
| buffer: buffer53, |
| }, { |
| texture: texture116, |
| mipLevel: 0, |
| origin: {x: 62, y: 11, z: 0}, |
| aspect: 'all', |
| }, {width: 391, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 80, height: 90, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame7, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture128, |
| mipLevel: 0, |
| origin: {x: 11, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup70 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 39, resource: {buffer: buffer87, offset: 0, size: 452}}, |
| {binding: 41, resource: textureView8}, |
| ], |
| }); |
| let textureView145 = texture1.createView({dimension: '1d', mipLevelCount: 1}); |
| let externalTexture8 = device0.importExternalTexture({source: videoFrame19}); |
| try { |
| computePassEncoder112.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderPassEncoder29.executeBundles([renderBundle11, renderBundle3, renderBundle13]); |
| } catch {} |
| try { |
| renderPassEncoder34.setPipeline(pipeline5); |
| } catch {} |
| try { |
| await buffer72.mapAsync(GPUMapMode.READ, 0, 1048); |
| } catch {} |
| let autogeneratedBindGroupLayout5 = pipeline6.getBindGroupLayout(0); |
| let texture228 = device0.createTexture({ |
| size: {width: 1968, height: 1, depthOrArrayLayers: 1}, |
| format: 'r8uint', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| let textureView146 = texture119.createView({arrayLayerCount: 1}); |
| try { |
| computePassEncoder110.setBindGroup(2, bindGroup68, new Uint32Array(1734), 565, 0); |
| } catch {} |
| try { |
| renderPassEncoder21.setVertexBuffer(0, buffer38, 160, 3); |
| } catch {} |
| try { |
| commandEncoder123.copyBufferToBuffer(buffer71, 4248, buffer33, 1532, 256); |
| } catch {} |
| try { |
| commandEncoder123.copyBufferToTexture({ |
| /* bytesInLastRow: 758 widthInBlocks: 379 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 2018 */ |
| offset: 2018, |
| buffer: buffer37, |
| }, { |
| texture: texture167, |
| mipLevel: 0, |
| origin: {x: 4, y: 1, z: 0}, |
| aspect: 'all', |
| }, {width: 379, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder125 = device0.createCommandEncoder({}); |
| let textureView147 = texture5.createView({}); |
| try { |
| computePassEncoder92.setBindGroup(0, bindGroup4, new Uint32Array(2186), 549, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder75); computePassEncoder75.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| renderPassEncoder11.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderPassEncoder34.setVertexBuffer(0, buffer2, 0, 55); |
| } catch {} |
| let bindGroup71 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout7, |
| entries: [ |
| {binding: 144, resource: textureView97}, |
| {binding: 323, resource: {buffer: buffer20, offset: 256, size: 1412}}, |
| ], |
| }); |
| let pipelineLayout15 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout7]}); |
| let buffer90 = device0.createBuffer({size: 2880, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT}); |
| let texture229 = device0.createTexture({ |
| size: [470], |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'rgba8snorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let textureView148 = texture129.createView({aspect: 'all', arrayLayerCount: 1}); |
| let computePassEncoder113 = commandEncoder123.beginComputePass(); |
| let renderPassEncoder40 = commandEncoder125.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView101, |
| clearValue: { r: -235.4, g: -821.6, b: 669.8, a: 628.7, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| }); |
| let externalTexture9 = device0.importExternalTexture({source: videoFrame12, colorSpace: 'display-p3'}); |
| try { |
| renderPassEncoder10.setIndexBuffer(buffer38, 'uint16', 128, 3); |
| } catch {} |
| try { |
| renderPassEncoder35.setPipeline(pipeline20); |
| } catch {} |
| try { |
| renderPassEncoder32.setVertexBuffer(0, buffer55); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| let imageData18 = new ImageData(8, 64); |
| let bindGroup72 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 39, resource: {buffer: buffer19, offset: 256, size: 1168}}, |
| {binding: 41, resource: textureView8}, |
| ], |
| }); |
| let commandEncoder126 = device0.createCommandEncoder(); |
| let texture230 = device0.createTexture({ |
| size: {width: 1968, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder114 = commandEncoder126.beginComputePass({}); |
| let sampler73 = device0.createSampler({ |
| label: '\u02d1\u0d26\u2ba9\uf22c\u{1fbdf}\u362c\u09e1\uefcb\u00c9', |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 90.49, |
| maxAnisotropy: 17, |
| }); |
| try { |
| computePassEncoder54.setBindGroup(1, bindGroup1); |
| } catch {} |
| try { |
| computePassEncoder114.setPipeline(pipeline11); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer40, 24400, new BigUint64Array(6167), 8, 40); |
| } catch {} |
| document.body.prepend(img0); |
| let recycledExplicitBindGroupLayout9 = pipeline15.getBindGroupLayout(0); |
| let buffer91 = device0.createBuffer({size: 3356, usage: GPUBufferUsage.UNIFORM}); |
| let textureView149 = texture41.createView({baseArrayLayer: 0}); |
| try { |
| computePassEncoder113.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder26.setBindGroup(1, bindGroup71); |
| } catch {} |
| try { |
| renderPassEncoder38.executeBundles([renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder32.setVertexBuffer(4, buffer51); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let bindGroup73 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout9, |
| entries: [ |
| {binding: 323, resource: {buffer: buffer5, offset: 0, size: 4684}}, |
| {binding: 144, resource: textureView145}, |
| ], |
| }); |
| let commandEncoder127 = device0.createCommandEncoder({}); |
| let texture231 = gpuCanvasContext1.getCurrentTexture(); |
| try { |
| computePassEncoder76.setBindGroup(1, bindGroup54); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder75); computePassEncoder75.dispatchWorkgroupsIndirect(buffer21, 6_516); }; |
| } catch {} |
| try { |
| renderPassEncoder38.setBindGroup(1, bindGroup35, []); |
| } catch {} |
| try { |
| renderPassEncoder16.setVertexBuffer(5, buffer38); |
| } catch {} |
| try { |
| commandEncoder127.copyBufferToBuffer(buffer78, 1836, buffer53, 312, 40); |
| } catch {} |
| try { |
| commandEncoder127.copyBufferToTexture({ |
| /* bytesInLastRow: 1 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 2722 */ |
| offset: 2722, |
| bytesPerRow: 25088, |
| buffer: buffer69, |
| }, { |
| texture: texture227, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder127.copyTextureToTexture({ |
| texture: texture110, |
| mipLevel: 1, |
| origin: {x: 22, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture110, |
| mipLevel: 1, |
| origin: {x: 7, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 23, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let img5 = await imageWithData(105, 4, '#10101010', '#20202020'); |
| try { |
| textureView139.label = '\ue0c3\u{1f77c}\u0d5c\u0eff\u4165\u7280\ufb36\u6bf4'; |
| } catch {} |
| let commandEncoder128 = device0.createCommandEncoder(); |
| let texture232 = device0.createTexture({size: [32, 32, 21], mipLevelCount: 2, format: 'rgb10a2unorm', usage: GPUTextureUsage.RENDER_ATTACHMENT}); |
| let computePassEncoder115 = commandEncoder128.beginComputePass({}); |
| let sampler74 = device0.createSampler({addressModeU: 'repeat', addressModeW: 'repeat', mipmapFilter: 'nearest'}); |
| let externalTexture10 = device0.importExternalTexture({source: videoFrame17, colorSpace: 'srgb'}); |
| try { |
| computePassEncoder7.setBindGroup(3, bindGroup54, new Uint32Array(4185), 689, 0); |
| } catch {} |
| try { |
| renderPassEncoder35.setBlendConstant({ r: -736.2, g: 682.4, b: -122.5, a: 260.8, }); |
| } catch {} |
| try { |
| commandEncoder127.copyBufferToTexture({ |
| /* bytesInLastRow: 1290 widthInBlocks: 645 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 502 */ |
| offset: 502, |
| buffer: buffer17, |
| }, { |
| texture: texture133, |
| mipLevel: 0, |
| origin: {x: 10, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 645, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline30 = await device0.createComputePipelineAsync({layout: pipelineLayout9, compute: {module: shaderModule3, constants: {}}}); |
| document.body.append(img3); |
| let texture233 = device0.createTexture({ |
| size: [1880, 10, 1], |
| mipLevelCount: 2, |
| format: 'astc-8x5-unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder116 = commandEncoder127.beginComputePass({}); |
| try { |
| computePassEncoder93.setBindGroup(0, bindGroup39, new Uint32Array(1955), 375, 0); |
| } catch {} |
| try { |
| computePassEncoder115.setPipeline(pipeline27); |
| } catch {} |
| try { |
| globalThis.someLabel = externalTexture4.label; |
| } catch {} |
| let commandEncoder129 = device0.createCommandEncoder({}); |
| let texture234 = device0.createTexture({size: [32, 32, 21], sampleCount: 1, format: 'r8sint', usage: GPUTextureUsage.COPY_DST, viewFormats: []}); |
| let textureView150 = texture32.createView({}); |
| try { |
| computePassEncoder40.setBindGroup(0, bindGroup61); |
| } catch {} |
| try { |
| renderPassEncoder13.setStencilReference(67); |
| } catch {} |
| let computePassEncoder117 = commandEncoder129.beginComputePass({}); |
| try { |
| computePassEncoder26.setBindGroup(3, bindGroup42, new Uint32Array(2268), 794, 0); |
| } catch {} |
| try { |
| renderPassEncoder26.setBindGroup(2, bindGroup50, new Uint32Array(1917), 36, 0); |
| } catch {} |
| try { |
| renderPassEncoder17.executeBundles([renderBundle8, renderBundle10, renderBundle4]); |
| } catch {} |
| let bindGroup74 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout11, |
| entries: [ |
| {binding: 41, resource: textureView8}, |
| {binding: 39, resource: {buffer: buffer65, offset: 512, size: 1776}}, |
| ], |
| }); |
| let buffer92 = device0.createBuffer({ |
| size: 17802, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM, |
| }); |
| let texture235 = device0.createTexture({ |
| size: {width: 307, height: 7, depthOrArrayLayers: 1}, |
| mipLevelCount: 7, |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder99.setBindGroup(2, bindGroup49, [3584]); |
| } catch {} |
| try { |
| computePassEncoder117.setPipeline(pipeline23); |
| } catch {} |
| try { |
| renderPassEncoder40.setBindGroup(2, bindGroup74); |
| } catch {} |
| try { |
| renderPassEncoder22.executeBundles([renderBundle11]); |
| } catch {} |
| try { |
| renderPassEncoder15.setVertexBuffer(6, buffer43, 20, 94); |
| } catch {} |
| try { |
| gpuCanvasContext2.unconfigure(); |
| } catch {} |
| try { |
| if (!arrayBuffer13.detached) { new Uint8Array(arrayBuffer13).fill(0x55); }; |
| } catch {} |
| let buffer93 = device0.createBuffer({ |
| size: 988, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| let textureView151 = texture227.createView({mipLevelCount: 1}); |
| try { |
| renderPassEncoder37.setPipeline(pipeline17); |
| } catch {} |
| try { |
| renderPassEncoder12.setVertexBuffer(0, buffer13, 900); |
| } catch {} |
| let promise9 = device0.queue.onSubmittedWorkDone(); |
| let commandEncoder130 = device0.createCommandEncoder(); |
| let computePassEncoder118 = commandEncoder130.beginComputePass(); |
| try { |
| computePassEncoder79.setBindGroup(1, bindGroup70); |
| } catch {} |
| try { |
| computePassEncoder116.setPipeline(pipeline30); |
| } catch {} |
| try { |
| renderPassEncoder12.setBindGroup(0, bindGroup50, new Uint32Array(817), 154, 0); |
| } catch {} |
| try { |
| renderPassEncoder22.executeBundles([renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder37.setBlendConstant({ r: -824.9, g: -594.5, b: 239.0, a: 622.2, }); |
| } catch {} |
| try { |
| renderPassEncoder34.setVertexBuffer(2, buffer56, 1_524, 214); |
| } catch {} |
| try { |
| renderPassEncoder32.insertDebugMarker('\u0955'); |
| } catch {} |
| let bindGroup75 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout5, |
| entries: [ |
| {binding: 323, resource: {buffer: buffer33, offset: 256, size: 972}}, |
| {binding: 144, resource: textureView145}, |
| ], |
| }); |
| let pipelineLayout16 = device0.createPipelineLayout({bindGroupLayouts: []}); |
| let commandEncoder131 = device0.createCommandEncoder(); |
| let computePassEncoder119 = commandEncoder131.beginComputePass({}); |
| try { |
| computePassEncoder92.setBindGroup(3, bindGroup41); |
| } catch {} |
| try { |
| computePassEncoder96.setBindGroup(2, bindGroup57, new Uint32Array(709), 240, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder40); computePassEncoder40.dispatchWorkgroupsIndirect(buffer62, 776); }; |
| } catch {} |
| try { |
| computePassEncoder118.setPipeline(pipeline19); |
| } catch {} |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture150, |
| mipLevel: 0, |
| origin: {x: 270, y: 1, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(203).fill(156), /* required buffer size: 203 */ |
| {offset: 203}, {width: 172, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1230, height: 30, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData10, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture89, |
| mipLevel: 0, |
| origin: {x: 340, y: 1, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 7, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder132 = device0.createCommandEncoder({}); |
| let querySet16 = device0.createQuerySet({type: 'occlusion', count: 340}); |
| let textureView152 = texture223.createView({dimension: '2d-array', baseMipLevel: 0}); |
| let computePassEncoder120 = commandEncoder132.beginComputePass({}); |
| let sampler75 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| lodMinClamp: 80.62, |
| lodMaxClamp: 87.75, |
| compare: 'equal', |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder75); computePassEncoder75.dispatchWorkgroupsIndirect(buffer83, 980); }; |
| } catch {} |
| try { |
| renderPassEncoder16.executeBundles([renderBundle6, renderBundle2, renderBundle13, renderBundle6, renderBundle12]); |
| } catch {} |
| try { |
| renderPassEncoder39.setVertexBuffer(3, buffer86, 2_508); |
| } catch {} |
| let promise10 = device0.queue.onSubmittedWorkDone(); |
| let bindGroup76 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout16, |
| entries: [ |
| {binding: 73, resource: sampler75}, |
| {binding: 34, resource: textureView96}, |
| {binding: 133, resource: {buffer: buffer68, offset: 1280}}, |
| {binding: 430, resource: sampler12}, |
| ], |
| }); |
| let commandEncoder133 = device0.createCommandEncoder({}); |
| let computePassEncoder121 = commandEncoder133.beginComputePass({}); |
| let sampler76 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'repeat', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 67.24, |
| }); |
| try { |
| computePassEncoder119.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder25.setBindGroup(3, bindGroup5, new Uint32Array(316), 31, 0); |
| } catch {} |
| try { |
| renderPassEncoder32.setIndexBuffer(buffer41, 'uint32', 1_696, 10_694); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let pipeline31 = await device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| fragment: { |
| module: shaderModule3, |
| entryPoint: 'fragment3', |
| targets: [{ |
| format: 'rg8unorm', |
| blend: { |
| color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'}, |
| alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'}, |
| }, |
| writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED, |
| }], |
| }, |
| vertex: {module: shaderModule3, buffers: []}, |
| primitive: {topology: 'line-strip', stripIndexFormat: 'uint32', frontFace: 'cw'}, |
| }); |
| try { |
| globalThis.someLabel = externalTexture4.label; |
| } catch {} |
| let commandEncoder134 = device0.createCommandEncoder({}); |
| let querySet17 = device0.createQuerySet({type: 'occlusion', count: 169}); |
| let texture236 = device0.createTexture({ |
| size: [80, 90, 69], |
| mipLevelCount: 3, |
| dimension: '3d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView153 = texture204.createView({dimension: '2d', baseArrayLayer: 2}); |
| let renderPassEncoder41 = commandEncoder134.beginRenderPass({ |
| label: '\ubecc\u0f3a\udd1b\ue72d\u683f', |
| colorAttachments: [{ |
| view: textureView36, |
| depthSlice: 288, |
| clearValue: { r: 513.3, g: 386.9, b: 713.9, a: -783.4, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet14, |
| }); |
| try { |
| computePassEncoder121.setPipeline(pipeline11); |
| } catch {} |
| let bindGroup77 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout3, |
| entries: [{binding: 323, resource: {buffer: buffer47, offset: 512}}, {binding: 144, resource: textureView2}], |
| }); |
| let pipelineLayout17 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout20]}); |
| let commandEncoder135 = device0.createCommandEncoder({}); |
| let computePassEncoder122 = commandEncoder135.beginComputePass({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder89); computePassEncoder89.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder89); computePassEncoder89.dispatchWorkgroupsIndirect(buffer85, 2_020); }; |
| } catch {} |
| try { |
| renderPassEncoder22.setIndexBuffer(buffer85, 'uint32', 720, 56); |
| } catch {} |
| try { |
| renderPassEncoder12.setPipeline(pipeline14); |
| } catch {} |
| try { |
| buffer10.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| await gc(); |
| let texture237 = device0.createTexture({ |
| size: {width: 940, height: 5, depthOrArrayLayers: 1}, |
| sampleCount: 4, |
| format: 'rg16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| renderPassEncoder21.setBindGroup(3, bindGroup60); |
| } catch {} |
| try { |
| renderPassEncoder11.executeBundles([renderBundle4, renderBundle7]); |
| } catch {} |
| try { |
| renderPassEncoder20.setIndexBuffer(buffer82, 'uint32', 124, 9); |
| } catch {} |
| try { |
| renderPassEncoder15.setPipeline(pipeline22); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture41, |
| mipLevel: 0, |
| origin: {x: 322, y: 7, z: 8}, |
| aspect: 'all', |
| }, new Uint8Array(174_593).fill(154), /* required buffer size: 174_593 */ |
| {offset: 79, bytesPerRow: 975, rowsPerImage: 59}, {width: 241, height: 2, depthOrArrayLayers: 4}); |
| } catch {} |
| let commandEncoder136 = device0.createCommandEncoder({}); |
| let computePassEncoder123 = commandEncoder136.beginComputePass({}); |
| try { |
| computePassEncoder47.setBindGroup(2, bindGroup17); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder75); computePassEncoder75.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder12.executeBundles([renderBundle3, renderBundle12]); |
| } catch {} |
| try { |
| renderPassEncoder29.setVertexBuffer(1, buffer80, 908, 69); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let pipeline32 = device0.createComputePipeline({layout: pipelineLayout9, compute: {module: shaderModule0}}); |
| let querySet18 = device0.createQuerySet({type: 'occlusion', count: 1390}); |
| let sampler77 = device0.createSampler({addressModeU: 'mirror-repeat', lodMaxClamp: 68.79}); |
| try { |
| computePassEncoder123.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder14.setBindGroup(3, bindGroup59, new Uint32Array(4131), 576, 0); |
| } catch {} |
| try { |
| renderPassEncoder30.end(); |
| } catch {} |
| try { |
| renderPassEncoder40.setPipeline(pipeline20); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 80, height: 90, depthOrArrayLayers: 1} |
| */ |
| { |
| source: offscreenCanvas0, |
| origin: { x: 17, y: 5 }, |
| flipY: false, |
| }, { |
| texture: texture92, |
| mipLevel: 0, |
| origin: {x: 14, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 33, height: 7, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup78 = device0.createBindGroup({layout: autogeneratedBindGroupLayout2, entries: [{binding: 144, resource: textureView145}]}); |
| let texture238 = device0.createTexture({ |
| size: {width: 20, height: 22, depthOrArrayLayers: 1}, |
| dimension: '2d', |
| format: 'r8uint', |
| usage: GPUTextureUsage.COPY_DST, |
| viewFormats: [], |
| }); |
| let textureView154 = texture111.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 1}); |
| let computePassEncoder124 = commandEncoder5.beginComputePass({}); |
| try { |
| computePassEncoder124.setPipeline(pipeline23); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer10]); |
| } catch {} |
| let videoFrame20 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'yCgCo', primaries: 'bt709', transfer: 'iec6196624'} }); |
| let commandEncoder137 = device0.createCommandEncoder(); |
| let textureView155 = texture148.createView({dimension: '2d-array', mipLevelCount: 1}); |
| try { |
| computePassEncoder107.setBindGroup(0, bindGroup40, new Uint32Array(1028), 41, 0); |
| } catch {} |
| try { |
| computePassEncoder14.setPipeline(pipeline11); |
| } catch {} |
| try { |
| computePassEncoder120.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder13.setBindGroup(1, bindGroup22, new Uint32Array(422), 22, 0); |
| } catch {} |
| try { |
| renderPassEncoder17.executeBundles([renderBundle6, renderBundle6]); |
| } catch {} |
| try { |
| renderPassEncoder39.setScissorRect(23, 0, 15, 0); |
| } catch {} |
| try { |
| renderPassEncoder41.setPipeline(pipeline4); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer45, 120, new Int16Array(19667), 5776, 12); |
| } catch {} |
| try { |
| await promise9; |
| } catch {} |
| let buffer94 = device0.createBuffer({size: 8361, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let textureView156 = texture194.createView({aspect: 'all', arrayLayerCount: 15}); |
| try { |
| computePassEncoder86.setBindGroup(0, bindGroup9); |
| } catch {} |
| try { |
| computePassEncoder122.setPipeline(pipeline23); |
| } catch {} |
| try { |
| renderPassEncoder32.setVertexBuffer(7, buffer73); |
| } catch {} |
| let buffer95 = device0.createBuffer({ |
| size: 2704, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let commandEncoder138 = device0.createCommandEncoder({}); |
| let textureView157 = texture38.createView({mipLevelCount: 1, baseArrayLayer: 0}); |
| let computePassEncoder125 = commandEncoder137.beginComputePass({}); |
| let sampler78 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| minFilter: 'nearest', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 91.23, |
| maxAnisotropy: 1, |
| }); |
| try { |
| computePassEncoder40.end(); |
| } catch {} |
| try { |
| computePassEncoder125.setPipeline(pipeline3); |
| } catch {} |
| let arrayBuffer21 = buffer26.getMappedRange(144, 0); |
| let commandEncoder139 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder34.setBindGroup(0, bindGroup30, new Uint32Array(2523), 188, 0); |
| } catch {} |
| try { |
| renderPassEncoder34.draw(39, 0, 372_826_944); |
| } catch {} |
| try { |
| commandEncoder138.copyBufferToBuffer(buffer61, 356, buffer13, 592, 1244); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 984, height: 1, depthOrArrayLayers: 140} |
| */ |
| { |
| source: img4, |
| origin: { x: 5, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture120, |
| mipLevel: 1, |
| origin: {x: 62, y: 0, z: 138}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder140 = device0.createCommandEncoder({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder33); computePassEncoder33.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder34.end(); |
| } catch {} |
| try { |
| renderPassEncoder29.setPipeline(pipeline10); |
| } catch {} |
| try { |
| commandEncoder139.copyBufferToBuffer(buffer64, 1796, buffer71, 4008, 2352); |
| } catch {} |
| await gc(); |
| try { |
| computePassEncoder117.setBindGroup(1, bindGroup38); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder33); computePassEncoder33.dispatchWorkgroupsIndirect(buffer71, 1_664); }; |
| } catch {} |
| try { |
| renderPassEncoder25.setBindGroup(1, bindGroup40, new Uint32Array(4502), 263, 0); |
| } catch {} |
| try { |
| renderPassEncoder10.executeBundles([renderBundle4, renderBundle4, renderBundle6, renderBundle10, renderBundle6, renderBundle1, renderBundle4, renderBundle12, renderBundle4, renderBundle8]); |
| } catch {} |
| let commandEncoder141 = device0.createCommandEncoder({}); |
| let texture239 = device0.createTexture({ |
| size: {width: 307, height: 7, depthOrArrayLayers: 1}, |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView158 = texture181.createView({aspect: 'all'}); |
| try { |
| computePassEncoder116.setBindGroup(0, bindGroup58); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder86); computePassEncoder86.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder13.setScissorRect(85, 0, 63, 0); |
| } catch {} |
| try { |
| renderPassEncoder25.setIndexBuffer(buffer13, 'uint32', 1_692, 82); |
| } catch {} |
| try { |
| renderPassEncoder39.insertDebugMarker('\ua1f3'); |
| } catch {} |
| let bindGroup79 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout8, |
| entries: [{binding: 125, resource: textureView21}, {binding: 166, resource: {buffer: buffer70, offset: 0}}], |
| }); |
| let texture240 = device0.createTexture({ |
| size: {width: 3760, height: 20, depthOrArrayLayers: 1}, |
| mipLevelCount: 7, |
| format: 'depth24plus-stencil8', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView159 = texture126.createView({format: 'rg16sint', mipLevelCount: 1}); |
| try { |
| computePassEncoder50.setBindGroup(0, bindGroup35, []); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder75); computePassEncoder75.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder86.end(); |
| } catch {} |
| try { |
| renderPassEncoder13.setBindGroup(2, bindGroup13); |
| } catch {} |
| try { |
| renderPassEncoder19.setBindGroup(1, bindGroup42, new Uint32Array(9875), 833, 0); |
| } catch {} |
| try { |
| device0.pushErrorScope('validation'); |
| } catch {} |
| let bindGroup80 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout2, |
| entries: [ |
| {binding: 323, resource: {buffer: buffer20, offset: 9216, size: 4900}}, |
| {binding: 144, resource: textureView2}, |
| ], |
| }); |
| let commandBuffer11 = commandEncoder105.finish({}); |
| let textureView160 = texture171.createView({dimension: '2d-array', baseMipLevel: 0, mipLevelCount: 1}); |
| let computePassEncoder126 = commandEncoder139.beginComputePass({}); |
| let sampler79 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'mirror-repeat', magFilter: 'nearest', compare: 'not-equal'}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder116); computePassEncoder116.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder126.setPipeline(pipeline23); |
| } catch {} |
| try { |
| renderPassEncoder38.setBlendConstant({ r: -898.9, g: 756.8, b: -40.63, a: -903.6, }); |
| } catch {} |
| try { |
| renderPassEncoder16.setIndexBuffer(buffer2, 'uint16', 586, 34); |
| } catch {} |
| try { |
| renderPassEncoder14.setPipeline(pipeline7); |
| } catch {} |
| try { |
| commandEncoder141.copyBufferToTexture({ |
| /* bytesInLastRow: 1 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 25339 */ |
| offset: 250, |
| bytesPerRow: 3584, |
| buffer: buffer21, |
| }, { |
| texture: texture157, |
| mipLevel: 0, |
| origin: {x: 9, y: 5, z: 3}, |
| aspect: 'all', |
| }, {width: 1, height: 8, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| commandEncoder141.resolveQuerySet(querySet13, 13, 122, buffer32, 9216); |
| } catch {} |
| try { |
| commandEncoder138.insertDebugMarker('\u0c57'); |
| } catch {} |
| let bindGroup81 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout8, |
| entries: [ |
| {binding: 323, resource: {buffer: buffer68, offset: 1280, size: 5740}}, |
| {binding: 144, resource: textureView97}, |
| ], |
| }); |
| let buffer96 = device0.createBuffer({ |
| size: 1724, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder142 = device0.createCommandEncoder(); |
| let computePassEncoder127 = commandEncoder142.beginComputePass({}); |
| try { |
| computePassEncoder66.setPipeline(pipeline18); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| await promise10; |
| } catch {} |
| let commandEncoder143 = device0.createCommandEncoder({}); |
| let computePassEncoder128 = commandEncoder51.beginComputePass({}); |
| try { |
| renderPassEncoder14.setIndexBuffer(buffer52, 'uint16', 364, 188); |
| } catch {} |
| try { |
| renderPassEncoder39.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder24.setVertexBuffer(1, buffer86, 0, 3_272); |
| } catch {} |
| let arrayBuffer22 = buffer28.getMappedRange(3976, 0); |
| try { |
| commandEncoder99.resolveQuerySet(querySet18, 164, 12, buffer53, 0); |
| } catch {} |
| let texture241 = gpuCanvasContext1.getCurrentTexture(); |
| let computePassEncoder129 = commandEncoder141.beginComputePass(); |
| try { |
| computePassEncoder97.setBindGroup(1, bindGroup48); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder89); computePassEncoder89.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder33.setBindGroup(3, bindGroup52); |
| } catch {} |
| try { |
| renderPassEncoder14.executeBundles([renderBundle5, renderBundle10]); |
| } catch {} |
| try { |
| renderPassEncoder41.setIndexBuffer(buffer85, 'uint32', 640, 561); |
| } catch {} |
| try { |
| commandEncoder99.copyBufferToTexture({ |
| /* bytesInLastRow: 10 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 488 */ |
| offset: 488, |
| bytesPerRow: 8960, |
| rowsPerImage: 1468, |
| buffer: buffer78, |
| }, { |
| texture: texture136, |
| mipLevel: 0, |
| origin: {x: 2, y: 12, z: 0}, |
| aspect: 'all', |
| }, {width: 5, height: 14, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let bindGroup82 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout3, |
| entries: [ |
| {binding: 144, resource: textureView97}, |
| {binding: 323, resource: {buffer: buffer95, offset: 512, size: 876}}, |
| ], |
| }); |
| let commandEncoder144 = device0.createCommandEncoder({}); |
| let texture242 = device0.createTexture({ |
| label: '\uf5c1\u0eae', |
| size: {width: 307}, |
| dimension: '1d', |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| let textureView161 = texture177.createView({}); |
| let computePassEncoder130 = commandEncoder143.beginComputePass({}); |
| let sampler80 = device0.createSampler({ |
| addressModeV: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 42.22, |
| maxAnisotropy: 20, |
| }); |
| try { |
| computePassEncoder127.setPipeline(pipeline30); |
| } catch {} |
| try { |
| commandEncoder144.copyTextureToTexture({ |
| texture: texture166, |
| mipLevel: 0, |
| origin: {x: 7, y: 12, z: 12}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture145, |
| mipLevel: 0, |
| origin: {x: 963, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 5, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let textureView162 = texture81.createView({dimension: 'cube-array', baseMipLevel: 0, baseArrayLayer: 1, arrayLayerCount: 6}); |
| let computePassEncoder131 = commandEncoder140.beginComputePass({label: '\u0c35\ucd53\ucf51\u{1fdc7}\u0659\u1a22'}); |
| try { |
| commandEncoder144.copyTextureToTexture({ |
| texture: texture194, |
| mipLevel: 0, |
| origin: {x: 70, y: 0, z: 3}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture136, |
| mipLevel: 0, |
| origin: {x: 6, y: 11, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 12, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 80, height: 90, depthOrArrayLayers: 1} |
| */ |
| { |
| source: img5, |
| origin: { x: 6, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture92, |
| mipLevel: 0, |
| origin: {x: 20, y: 26, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 8, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let veryExplicitBindGroupLayout21 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 34, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: 'cube-array', sampleType: 'uint', multisampled: false }, |
| }, |
| {binding: 73, visibility: GPUShaderStage.VERTEX, sampler: { type: 'comparison' }}, |
| { |
| binding: 133, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', hasDynamicOffset: true }, |
| }, |
| { |
| binding: 430, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| sampler: { type: 'filtering' }, |
| }, |
| ], |
| }); |
| let computePassEncoder132 = commandEncoder99.beginComputePass({}); |
| try { |
| computePassEncoder127.setBindGroup(2, bindGroup27, new Uint32Array(3991), 641, 0); |
| } catch {} |
| try { |
| computePassEncoder89.end(); |
| } catch {} |
| try { |
| computePassEncoder71.setPipeline(pipeline18); |
| } catch {} |
| try { |
| renderPassEncoder31.setVertexBuffer(5, buffer74, 0); |
| } catch {} |
| try { |
| commandEncoder102.copyBufferToTexture({ |
| /* bytesInLastRow: 64 widthInBlocks: 16 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 20 */ |
| offset: 20, |
| bytesPerRow: 256, |
| buffer: buffer64, |
| }, { |
| texture: texture153, |
| mipLevel: 0, |
| origin: {x: 5, y: 33, z: 1}, |
| aspect: 'all', |
| }, {width: 16, height: 15, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| if (!arrayBuffer13.detached) { new Uint8Array(arrayBuffer13).fill(0x55); }; |
| } catch {} |
| let texture243 = device0.createTexture({ |
| size: {width: 1968, height: 1, depthOrArrayLayers: 63}, |
| mipLevelCount: 4, |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder29.setBindGroup(0, bindGroup55, new Uint32Array(1372), 425, 0); |
| } catch {} |
| try { |
| computePassEncoder132.setPipeline(pipeline23); |
| } catch {} |
| try { |
| commandEncoder102.copyBufferToTexture({ |
| /* bytesInLastRow: 160 widthInBlocks: 10 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 160 */ |
| offset: 160, |
| bytesPerRow: 70656, |
| buffer: buffer71, |
| }, { |
| texture: texture233, |
| mipLevel: 1, |
| origin: {x: 168, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 80, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.append(img1); |
| let commandBuffer12 = commandEncoder102.finish(); |
| let texture244 = device0.createTexture({ |
| size: [1968, 1, 746], |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder133 = commandEncoder138.beginComputePass(); |
| try { |
| computePassEncoder120.setBindGroup(3, bindGroup67, new Uint32Array(2085), 197, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder75); computePassEncoder75.dispatchWorkgroupsIndirect(buffer32, 1_200); }; |
| } catch {} |
| try { |
| renderPassEncoder41.setVertexBuffer(6, buffer73, 176); |
| } catch {} |
| try { |
| commandEncoder144.copyBufferToTexture({ |
| /* bytesInLastRow: 28 widthInBlocks: 14 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 6412 */ |
| offset: 6412, |
| rowsPerImage: 1402, |
| buffer: buffer32, |
| }, { |
| texture: texture39, |
| mipLevel: 1, |
| origin: {x: 7, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 14, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let computePassEncoder134 = commandEncoder144.beginComputePass(); |
| try { |
| computePassEncoder125.setBindGroup(0, bindGroup57, new Uint32Array(1350), 118, 0); |
| } catch {} |
| try { |
| renderPassEncoder29.setBindGroup(0, bindGroup12, new Uint32Array(871), 240, 0); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| document.body.prepend(img3); |
| let buffer97 = device0.createBuffer({size: 10716, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT}); |
| let commandEncoder145 = device0.createCommandEncoder({}); |
| let textureView163 = texture206.createView({mipLevelCount: 1}); |
| let texture245 = device0.createTexture({ |
| label: '\u0298\u2609\u82de\uc3ca\u437d\ub76e', |
| size: [470], |
| dimension: '1d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderPassEncoder42 = commandEncoder145.beginRenderPass({ |
| colorAttachments: [{view: textureView93, loadOp: 'clear', storeOp: 'discard'}], |
| maxDrawCount: 32821574, |
| }); |
| let sampler81 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 43.52, |
| lodMaxClamp: 53.32, |
| maxAnisotropy: 4, |
| }); |
| try { |
| computePassEncoder37.setBindGroup(2, bindGroup24); |
| } catch {} |
| try { |
| computePassEncoder107.setBindGroup(2, bindGroup16, new Uint32Array(3750), 905, 0); |
| } catch {} |
| try { |
| renderPassEncoder33.setBindGroup(2, bindGroup40); |
| } catch {} |
| try { |
| renderPassEncoder27.setViewport(35.86780413991016, 0.48667952937090464, 46.79085458745626, 0.03390787672240354, 0.7653656853802696, 0.9273250006151104); |
| } catch {} |
| try { |
| renderPassEncoder39.setIndexBuffer(buffer52, 'uint16', 318, 162); |
| } catch {} |
| try { |
| buffer69.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer63, 2264, new Float32Array(3907), 1442, 172); |
| } catch {} |
| try { |
| if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55); }; |
| } catch {} |
| await gc(); |
| let videoFrame21 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'rgb', primaries: 'smpte240m', transfer: 'linear'} }); |
| try { |
| computePassEncoder53.setBindGroup(2, bindGroup2); |
| } catch {} |
| try { |
| computePassEncoder58.setBindGroup(0, bindGroup49, new Uint32Array(972), 21, 1); |
| } catch {} |
| try { |
| computePassEncoder130.setPipeline(pipeline11); |
| } catch {} |
| try { |
| renderPassEncoder27.setBindGroup(2, bindGroup69); |
| } catch {} |
| try { |
| renderPassEncoder38.setPipeline(pipeline7); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 40, height: 45, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame20, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture84, |
| mipLevel: 0, |
| origin: {x: 0, y: 32, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| offscreenCanvas2.width = 254; |
| let commandEncoder146 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder38.setBindGroup(1, bindGroup64, [256]); |
| } catch {} |
| try { |
| renderPassEncoder25.setVertexBuffer(4, buffer96, 0); |
| } catch {} |
| try { |
| commandEncoder146.copyBufferToTexture({ |
| /* bytesInLastRow: 10112 widthInBlocks: 632 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 608 */ |
| offset: 608, |
| rowsPerImage: 120, |
| buffer: buffer57, |
| }, { |
| texture: texture118, |
| mipLevel: 0, |
| origin: {x: 296, y: 1, z: 0}, |
| aspect: 'all', |
| }, {width: 632, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder146.copyTextureToTexture({ |
| texture: texture201, |
| mipLevel: 1, |
| origin: {x: 97, y: 4, z: 6}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture78, |
| mipLevel: 0, |
| origin: {x: 354, y: 0, z: 136}, |
| aspect: 'all', |
| }, |
| {width: 5, height: 0, depthOrArrayLayers: 24}); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture131, |
| mipLevel: 0, |
| origin: {x: 19, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(508).fill(118), /* required buffer size: 508 */ |
| {offset: 508, rowsPerImage: 10}, {width: 8, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let textureView164 = texture111.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 1}); |
| let textureView165 = texture50.createView({aspect: 'all', arrayLayerCount: 1}); |
| let computePassEncoder135 = commandEncoder146.beginComputePass({}); |
| try { |
| computePassEncoder0.setBindGroup(0, bindGroup1); |
| } catch {} |
| try { |
| computePassEncoder128.setPipeline(pipeline25); |
| } catch {} |
| try { |
| renderPassEncoder42.setIndexBuffer(buffer83, 'uint16', 1_232, 6_332); |
| } catch {} |
| try { |
| renderPassEncoder14.setPipeline(pipeline14); |
| } catch {} |
| let adapter1 = await navigator.gpu.requestAdapter({}); |
| let recycledExplicitBindGroupLayout10 = pipeline18.getBindGroupLayout(0); |
| let commandEncoder147 = device0.createCommandEncoder(); |
| let computePassEncoder136 = commandEncoder147.beginComputePass({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder125); computePassEncoder125.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder131.setPipeline(pipeline23); |
| } catch {} |
| try { |
| renderPassEncoder29.executeBundles([renderBundle0, renderBundle11, renderBundle12, renderBundle1, renderBundle3, renderBundle12]); |
| } catch {} |
| try { |
| renderPassEncoder11.setStencilReference(653); |
| } catch {} |
| let buffer98 = device0.createBuffer({size: 32033, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE}); |
| let texture246 = device0.createTexture({ |
| size: [20, 22, 17], |
| dimension: '3d', |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView166 = texture172.createView({}); |
| try { |
| computePassEncoder119.setBindGroup(1, bindGroup80); |
| } catch {} |
| try { |
| computePassEncoder99.setBindGroup(0, bindGroup43, new Uint32Array(5513), 749, 0); |
| } catch {} |
| try { |
| computePassEncoder33.end(); |
| } catch {} |
| try { |
| computePassEncoder92.setPipeline(pipeline11); |
| } catch {} |
| try { |
| renderPassEncoder29.setIndexBuffer(buffer14, 'uint16', 46, 2_098); |
| } catch {} |
| try { |
| renderPassEncoder37.setVertexBuffer(1, buffer56); |
| } catch {} |
| try { |
| commandEncoder41.copyTextureToTexture({ |
| texture: texture91, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture91, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 3, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder41.resolveQuerySet(querySet2, 0, 4, buffer84, 0); |
| } catch {} |
| let promise11 = device0.queue.onSubmittedWorkDone(); |
| let querySet19 = device0.createQuerySet({type: 'occlusion', count: 90}); |
| let textureView167 = texture15.createView({}); |
| try { |
| computePassEncoder61.setBindGroup(0, bindGroup4); |
| } catch {} |
| try { |
| renderPassEncoder42.setBindGroup(0, bindGroup20); |
| } catch {} |
| try { |
| renderPassEncoder24.setIndexBuffer(buffer8, 'uint32', 388, 325); |
| } catch {} |
| try { |
| renderPassEncoder10.setVertexBuffer(6, buffer42, 0); |
| } catch {} |
| try { |
| commandEncoder41.copyBufferToTexture({ |
| /* bytesInLastRow: 8 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 128 */ |
| offset: 128, |
| rowsPerImage: 11, |
| buffer: buffer77, |
| }, { |
| texture: texture111, |
| mipLevel: 1, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture208, |
| mipLevel: 0, |
| origin: {x: 494, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(58).fill(144), /* required buffer size: 58 */ |
| {offset: 58}, {width: 68, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 80, height: 90, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame15, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture128, |
| mipLevel: 0, |
| origin: {x: 7, y: 6, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(img5); |
| let shaderModule8 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| requires packed_4x8_integer_dot_product; |
| |
| /* zero global variables used */ |
| fn fn0() -> array<mat2x3f, 1> { |
| var out: array<mat2x3f, 1>; |
| var vf187: f32 = distance(vec4f(unconst_f32(0.1426), unconst_f32(0.2141), unconst_f32(-0.5179), unconst_f32(0.01555)), vec4f(unconst_f32(0.2508), unconst_f32(0.02161), unconst_f32(0.6303), unconst_f32(0.02479))); |
| out[unconst_u32(41)] += mat2x3f(vec3f(acosh(vec4h(unconst_f16(1199.5), unconst_f16(1185.4), unconst_f16(7777.7), unconst_f16(4120.0))).xwy), vec3f(acosh(vec4h(unconst_f16(1199.5), unconst_f16(1185.4), unconst_f16(7777.7), unconst_f16(4120.0))).xzy)); |
| let vf188: vec2h = fma(vec2h(unconst_f16(1508.1), unconst_f16(9742.6)), vec2h(unconst_f16(7866.9), unconst_f16(20435.3)), vec2h(unconst_f16(12304.4), unconst_f16(28123.8))); |
| switch bitcast<i32>(min(vec2h(unconst_f16(9183.8), unconst_f16(10926.1)), vec2h(unconst_f16(5930.3), unconst_f16(7019.8)))) { |
| default { |
| var vf189: bool = all(vec3<bool>(unconst_bool(false), unconst_bool(false), unconst_bool(true))); |
| let vf190: f16 = length(vec4h(unconst_f16(25.27), unconst_f16(6248.2), unconst_f16(358.7), unconst_f16(18122.3))); |
| break; |
| } |
| } |
| let vf191: vec2f = ldexp(vec2f(unconst_f32(0.2186), unconst_f32(0.09342)), vec2i(unconst_i32(50), unconst_i32(14))); |
| vf187 += vec2f((vec2i(unconst_i32(99), unconst_i32(2)) < vec2i(unconst_i32(4), unconst_i32(466)))).g; |
| var vf192: vec2h = (unconst_f16(4919.0) - vec2h(unconst_f16(11149.0), unconst_f16(20827.1))); |
| out[unconst_u32(25)] += mat2x3f(vec3f((unconst_f16(1857.1) - vec2h(unconst_f16(10329.9), unconst_f16(-6715.1))).yyx), vec3f((unconst_f16(1857.1) - vec2h(unconst_f16(10329.9), unconst_f16(-6715.1))).xxx)); |
| let vf193: vec2h = (unconst_f16(7091.0) - vec2h(unconst_f16(8809.4), unconst_f16(16966.0))); |
| vf192 = vec2h(inverseSqrt(vec4f(unconst_f32(-0.5249), unconst_f32(0.2988), unconst_f32(0.2150), unconst_f32(0.02225))).ga); |
| out[0] = mat2x3f(vec3f(mix(vec4h(unconst_f16(15335.9), unconst_f16(2558.0), unconst_f16(1855.0), unconst_f16(9500.9)), vf188.grgr, unconst_f16(16979.5)).zzw), vec3f(mix(vec4h(unconst_f16(15335.9), unconst_f16(2558.0), unconst_f16(1855.0), unconst_f16(9500.9)), vf188.grgr, unconst_f16(16979.5)).bgb)); |
| let ptr67: ptr<function, f32> = &vf187; |
| let vf194: vec4h = acosh(vec4h(unconst_f16(11699.7), unconst_f16(9217.7), unconst_f16(23200.0), unconst_f16(-18276.2))); |
| var vf195: vec2f = exp2(vec2f(unconst_f32(0.09077), unconst_f32(0.02163))); |
| let ptr68: ptr<function, vec2h> = &vf192; |
| return out; |
| } |
| |
| var<workgroup> vw33: mat2x4h; |
| |
| @group(0) @binding(323) var<storage, read> buffer99: array<array<mat2x4f, 27>, 1>; |
| |
| struct T0 { |
| @align(8) @size(104) f0: array<u32>, |
| } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| var<workgroup> vw37: atomic<i32>; |
| |
| var<workgroup> vw39: atomic<i32>; |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| struct VertexOutput7 { |
| @location(1) f8: vec4f, |
| @location(13) @interpolate(flat, centroid) f9: vec4i, |
| @location(10) f10: f32, |
| @location(5) f11: i32, |
| @invariant @builtin(position) f12: vec4f, |
| @location(9) @interpolate(flat, first) f13: vec2i, |
| @location(6) @interpolate(flat, either) f14: vec4i, |
| } |
| |
| var<workgroup> vw32: atomic<u32>; |
| |
| var<workgroup> vw35: u32; |
| |
| struct T1 { |
| @size(8) f0: array<atomic<i32>>, |
| } |
| |
| var<workgroup> vw36: mat3x4f; |
| |
| struct S5 { |
| @builtin(vertex_index) f0: u32, |
| } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| var<workgroup> vw34: VertexOutput7; |
| |
| var<workgroup> vw38: array<atomic<u32>, 1>; |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| /* used global variables: buffer99 */ |
| @vertex |
| fn vertex8(a0: S5, @location(4) @interpolate(linear, center) a1: vec4f, @location(13) a2: vec2h) -> VertexOutput7 { |
| var out: VertexOutput7; |
| out.f14 = bitcast<vec4i>((*&buffer99)[pack4xI8Clamp((vec4i(unconst_i32(169), unconst_i32(2), unconst_i32(92), unconst_i32(218)) & vec4i(unconst_i32(24), unconst_i32(-4), unconst_i32(22), unconst_i32(68))))][bitcast<u32>(fma(vec2h(unconst_f16(7545.9), unconst_f16(5154.9)), vec2h(insertBits(vec4i(unconst_i32(25), unconst_i32(20), unconst_i32(301), unconst_i32(193)), vec4i(unconst_i32(30), unconst_i32(74), unconst_i32(118), unconst_i32(193)), unconst_u32(185), unconst_u32(39)).bb), vec2h(unconst_f16(8610.0), unconst_f16(12327.2))))][unconst_i32(0)]); |
| var vf196 = fn0(); |
| fn0(); |
| if (unconst_f16(6229.6) == unconst_f16(1003.3)) { |
| var vf197 = fn0(); |
| fn0(); |
| fn0(); |
| out.f9 &= bitcast<vec4i>(buffer99[0][26][unconst_i32(0)]); |
| out.f10 *= log2(vec2f(unconst_f32(0.01979), unconst_f32(0.2767))).x; |
| fn0(); |
| let vf198: vec4f = buffer99[0][unconst_u32(60)][unconst_u32(17)]; |
| _ = buffer99; |
| } |
| out.f14 = vec4i(i32(vf196[0][unconst_u32(1)][unconst_u32(523)])); |
| if bool(buffer99[unconst_u32(87)][26][vec4u((*&buffer99)[0][26][unconst_i32(0)]).b][unconst_u32(101)]) { |
| var vf199 = fn0(); |
| out.f12 += vf199[0][unconst_u32(219)].xzzy; |
| let ptr69: ptr<storage, array<mat2x4f, 27>, read> = &buffer99[pack4x8unorm((*&buffer99)[0][26][unconst_i32(0)])]; |
| fn0(); |
| let ptr70: ptr<storage, array<mat2x4f, 27>, read> = &buffer99[u32(buffer99[0][unconst_u32(175)][unconst_u32(102)][unconst_u32(76)])]; |
| return out; |
| _ = buffer99; |
| } |
| vf196[unconst_u32(24)] = mat2x3f((*&buffer99)[0][26][unconst_i32(0)].aaa, (*&buffer99)[0][26][unconst_i32(0)].xwx); |
| out.f14 = bitcast<vec4i>(a1); |
| var vf200: vec2h = tan(vec2h(unconst_f16(8112.9), unconst_f16(12942.1))); |
| for (var it7=u32(refract(vec4f(unconst_f32(0.05019), unconst_f32(0.03637), unconst_f32(0.4191), unconst_f32(0.2650)), vec4f(unconst_f32(0.09097), unconst_f32(0.1405), unconst_f32(-0.04434), unconst_f32(0.02508)), unconst_f32(0.02851)).z); it7<u32(vf196[0][unconst_i32(0)][1]); it7++) { |
| fn0(); |
| var vf201 = fn0(); |
| } |
| out.f8 = vec4f(pow(vec2h(buffer99[0][26][unconst_i32(0)].ba), vec2h(unconst_f16(6381.7), unconst_f16(3251.8))).rrgr); |
| fn0(); |
| fn0(); |
| let vf202: vec4f = (*&buffer99)[unconst_u32(12)][26][unconst_u32(64)]; |
| return out; |
| _ = buffer99; |
| } |
| |
| /* zero global variables used */ |
| @compute @workgroup_size(1, 1, 1) |
| fn compute9() { |
| fn0(); |
| let vf203: u32 = atomicExchange(&(*&vw38)[0], unconst_u32(44)); |
| let ptr71: ptr<workgroup, vec4i> = &vw34.f9; |
| }`, |
| }); |
| let texture247 = device0.createTexture({ |
| label: '\ucef3\u0890\u{1ff65}\u076c', |
| size: [40, 45, 4], |
| format: 'rg16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| let computePassEncoder137 = commandEncoder41.beginComputePass({}); |
| try { |
| computePassEncoder117.setBindGroup(1, bindGroup51, new Uint32Array(1008), 81, 0); |
| } catch {} |
| try { |
| computePassEncoder135.setPipeline(pipeline30); |
| } catch {} |
| try { |
| renderPassEncoder11.executeBundles([renderBundle13, renderBundle2, renderBundle10, renderBundle11, renderBundle4]); |
| } catch {} |
| try { |
| device0.pushErrorScope('validation'); |
| } catch {} |
| try { |
| adapter1.label = '\u0c59\ua64b\u0b57'; |
| } catch {} |
| let bindGroup83 = device0.createBindGroup({ |
| label: '\u9feb\u002f\u8fe3\uad9d\u0bba', |
| layout: veryExplicitBindGroupLayout11, |
| entries: [{binding: 41, resource: textureView28}, {binding: 39, resource: {buffer: buffer66, offset: 1536}}], |
| }); |
| let texture248 = device0.createTexture({ |
| size: {width: 20, height: 22, depthOrArrayLayers: 1}, |
| sampleCount: 4, |
| format: 'rg16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler82 = device0.createSampler({addressModeU: 'repeat', addressModeW: 'mirror-repeat', minFilter: 'linear', lodMaxClamp: 95.17}); |
| try { |
| computePassEncoder83.setBindGroup(0, bindGroup40); |
| } catch {} |
| try { |
| renderPassEncoder40.setBindGroup(3, bindGroup60, new Uint32Array(840), 61, 0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture234, |
| mipLevel: 0, |
| origin: {x: 0, y: 1, z: 6}, |
| aspect: 'all', |
| }, new Uint8Array(2_341).fill(166), /* required buffer size: 2_341 */ |
| {offset: 229, bytesPerRow: 162}, {width: 6, height: 14, depthOrArrayLayers: 1}); |
| } catch {} |
| let promise12 = adapter1.requestDevice({ |
| defaultQueue: {}, |
| requiredLimits: {maxUniformBufferBindingSize: 21932530, maxStorageBufferBindingSize: 140703806}, |
| }); |
| let imageData19 = new ImageData(4, 4); |
| let buffer100 = device0.createBuffer({ |
| size: 9801, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| try { |
| computePassEncoder52.setBindGroup(0, bindGroup19, new Uint32Array(1472), 294, 0); |
| } catch {} |
| try { |
| computePassEncoder134.setPipeline(pipeline30); |
| } catch {} |
| try { |
| renderPassEncoder35.setBlendConstant({ r: 370.0, g: 698.5, b: 104.6, a: 960.2, }); |
| } catch {} |
| try { |
| renderPassEncoder26.setStencilReference(55); |
| } catch {} |
| try { |
| renderPassEncoder22.setPipeline(pipeline28); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let recycledExplicitBindGroupLayout11 = pipeline9.getBindGroupLayout(0); |
| try { |
| computePassEncoder52.setBindGroup(1, bindGroup43); |
| } catch {} |
| try { |
| computePassEncoder0.setBindGroup(0, bindGroup71, new Uint32Array(21), 0, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder99); computePassEncoder99.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder22.drawIndirect(buffer85, 340); |
| } catch {} |
| try { |
| renderPassEncoder32.setPipeline(pipeline5); |
| } catch {} |
| let bindGroup84 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout6, |
| entries: [ |
| {binding: 68, resource: {buffer: buffer37, offset: 256, size: 2392}}, |
| {binding: 45, resource: {buffer: buffer16, offset: 0, size: 505}}, |
| {binding: 97, resource: externalTexture5}, |
| {binding: 64, resource: {buffer: buffer87, offset: 0, size: 192}}, |
| ], |
| }); |
| let textureView168 = texture2.createView({mipLevelCount: 1, arrayLayerCount: 1}); |
| try { |
| computePassEncoder53.setBindGroup(3, bindGroup73); |
| } catch {} |
| try { |
| computePassEncoder133.setPipeline(pipeline11); |
| } catch {} |
| try { |
| renderPassEncoder38.setBindGroup(0, bindGroup26); |
| } catch {} |
| try { |
| renderPassEncoder22.end(); |
| } catch {} |
| try { |
| commandEncoder73.copyBufferToTexture({ |
| /* bytesInLastRow: 22 widthInBlocks: 11 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 152 */ |
| offset: 152, |
| bytesPerRow: 1792, |
| buffer: buffer61, |
| }, { |
| texture: texture210, |
| mipLevel: 3, |
| origin: {x: 60, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 11, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| commandEncoder73.copyTextureToBuffer({ |
| texture: texture128, |
| mipLevel: 0, |
| origin: {x: 13, y: 29, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 10 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 708 */ |
| offset: 708, |
| bytesPerRow: 8704, |
| rowsPerImage: 514, |
| buffer: buffer16, |
| }, {width: 5, height: 9, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder73.copyTextureToTexture({ |
| texture: texture199, |
| mipLevel: 0, |
| origin: {x: 225, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture173, |
| mipLevel: 0, |
| origin: {x: 773, y: 1, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 4, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture164, |
| mipLevel: 1, |
| origin: {x: 0, y: 0, z: 8}, |
| aspect: 'all', |
| }, new Uint8Array(56_547).fill(216), /* required buffer size: 56_547 */ |
| {offset: 3, bytesPerRow: 62, rowsPerImage: 57}, {width: 30, height: 0, depthOrArrayLayers: 17}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 40, height: 45, depthOrArrayLayers: 3} |
| */ |
| { |
| source: videoFrame5, |
| origin: { x: 0, y: 4 }, |
| flipY: true, |
| }, { |
| texture: texture153, |
| mipLevel: 1, |
| origin: {x: 16, y: 3, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 7, height: 14, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer101 = device0.createBuffer({size: 5336, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let computePassEncoder138 = commandEncoder73.beginComputePass(); |
| let sampler83 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'repeat', addressModeW: 'mirror-repeat'}); |
| try { |
| computePassEncoder44.setBindGroup(1, bindGroup71, new Uint32Array(2884), 1_007, 0); |
| } catch {} |
| try { |
| renderPassEncoder27.setBindGroup(1, bindGroup13); |
| } catch {} |
| try { |
| renderPassEncoder25.setPipeline(pipeline21); |
| } catch {} |
| try { |
| await promise11; |
| } catch {} |
| let commandEncoder148 = device0.createCommandEncoder({}); |
| let texture249 = device0.createTexture({size: {width: 153}, dimension: '1d', format: 'rg32uint', usage: GPUTextureUsage.COPY_SRC}); |
| let textureView169 = texture88.createView({baseArrayLayer: 1, arrayLayerCount: 2}); |
| try { |
| renderPassEncoder13.setBindGroup(1, bindGroup21, new Uint32Array(112), 1, 0); |
| } catch {} |
| try { |
| renderPassEncoder25.setIndexBuffer(buffer56, 'uint16', 832, 449); |
| } catch {} |
| try { |
| await shaderModule8.getCompilationInfo(); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| try { |
| if (!arrayBuffer5.detached) { new Uint8Array(arrayBuffer5).fill(0x55); }; |
| } catch {} |
| let buffer102 = device0.createBuffer({ |
| size: 15553, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder149 = device0.createCommandEncoder({}); |
| let computePassEncoder139 = commandEncoder148.beginComputePass({}); |
| let externalTexture11 = device0.importExternalTexture({source: videoFrame6}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder99); computePassEncoder99.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder14.setVertexBuffer(2, buffer1, 0, 1_799); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 80, height: 90, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData10, |
| origin: { x: 8, y: 1 }, |
| flipY: false, |
| }, { |
| texture: texture92, |
| mipLevel: 0, |
| origin: {x: 15, y: 3, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 5, height: 4, depthOrArrayLayers: 0}); |
| } catch {} |
| let imageBitmap1 = await createImageBitmap(videoFrame11); |
| let computePassEncoder140 = commandEncoder149.beginComputePass({}); |
| try { |
| computePassEncoder105.setPipeline(pipeline19); |
| } catch {} |
| try { |
| renderPassEncoder15.setIndexBuffer(buffer56, 'uint16', 124, 536); |
| } catch {} |
| await gc(); |
| let sampler84 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| mipmapFilter: 'nearest', |
| lodMaxClamp: 94.63, |
| compare: 'always', |
| }); |
| try { |
| computePassEncoder140.setPipeline(pipeline18); |
| } catch {} |
| try { |
| renderPassEncoder24.setBindGroup(3, bindGroup42, new Uint32Array(2503), 84, 0); |
| } catch {} |
| try { |
| renderPassEncoder17.executeBundles([renderBundle10]); |
| } catch {} |
| try { |
| renderPassEncoder12.setPipeline(pipeline26); |
| } catch {} |
| let canvas0 = document.createElement('canvas'); |
| let sampler85 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 91.29, |
| maxAnisotropy: 6, |
| }); |
| try { |
| computePassEncoder46.setBindGroup(0, bindGroup58); |
| } catch {} |
| try { |
| computePassEncoder129.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder32.executeBundles([renderBundle1, renderBundle6, renderBundle11, renderBundle1, renderBundle4]); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer69, 92, new Float32Array(1329), 148, 28); |
| } catch {} |
| let pipeline33 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule8, entryPoint: 'compute9', constants: {}}}); |
| try { |
| computePassEncoder56.setBindGroup(1, bindGroup45, new Uint32Array(1188), 449, 0); |
| } catch {} |
| try { |
| renderPassEncoder29.setBindGroup(3, bindGroup79); |
| } catch {} |
| try { |
| renderPassEncoder19.setIndexBuffer(buffer52, 'uint16', 58, 0); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer12, commandBuffer11]); |
| } catch {} |
| let bindGroup85 = device0.createBindGroup({layout: veryExplicitBindGroupLayout17, entries: [{binding: 21, resource: textureView57}]}); |
| let texture250 = device0.createTexture({ |
| size: {width: 32, height: 32, depthOrArrayLayers: 666}, |
| mipLevelCount: 3, |
| dimension: '3d', |
| format: 'rg16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder60.setBindGroup(0, bindGroup56, new Uint32Array(79), 3, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder52); computePassEncoder52.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder137.setPipeline(pipeline33); |
| } catch {} |
| try { |
| renderPassEncoder14.setViewport(178.16121554089094, 0.38851293122108743, 59.803231844452434, 0.3250737418924507, 0.765936257503689, 0.8122943214842925); |
| } catch {} |
| try { |
| renderPassEncoder20.setPipeline(pipeline12); |
| } catch {} |
| let commandEncoder150 = device0.createCommandEncoder(); |
| try { |
| computePassEncoder136.setBindGroup(1, bindGroup21); |
| } catch {} |
| try { |
| computePassEncoder133.setBindGroup(0, bindGroup25, new Uint32Array(3013), 836, 0); |
| } catch {} |
| try { |
| renderPassEncoder39.setPipeline(pipeline17); |
| } catch {} |
| try { |
| computePassEncoder50.setBindGroup(0, bindGroup19, new Uint32Array(542), 47, 0); |
| } catch {} |
| try { |
| computePassEncoder139.setPipeline(pipeline32); |
| } catch {} |
| try { |
| renderPassEncoder17.setBindGroup(1, bindGroup81); |
| } catch {} |
| try { |
| renderPassEncoder41.setBindGroup(0, bindGroup81, new Uint32Array(315), 39, 0); |
| } catch {} |
| try { |
| renderPassEncoder26.setIndexBuffer(buffer62, 'uint32', 952, 1_249); |
| } catch {} |
| try { |
| commandEncoder150.copyBufferToBuffer(buffer84, 10872, buffer37, 1344, 2952); |
| } catch {} |
| try { |
| commandEncoder150.copyBufferToTexture({ |
| /* bytesInLastRow: 44 widthInBlocks: 11 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 428 */ |
| offset: 428, |
| bytesPerRow: 19200, |
| buffer: buffer35, |
| }, { |
| texture: texture102, |
| mipLevel: 0, |
| origin: {x: 145, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 11, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer100, 860, new Float32Array(3360), 344, 524); |
| } catch {} |
| let buffer103 = device0.createBuffer({ |
| size: 5635, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM, |
| }); |
| let textureView170 = texture238.createView({}); |
| let computePassEncoder141 = commandEncoder150.beginComputePass({}); |
| let sampler86 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| lodMinClamp: 99.40, |
| lodMaxClamp: 99.85, |
| }); |
| try { |
| computePassEncoder81.setBindGroup(1, bindGroup71, new Uint32Array(6197), 397, 0); |
| } catch {} |
| try { |
| computePassEncoder99.end(); |
| } catch {} |
| try { |
| renderPassEncoder33.setBindGroup(1, bindGroup35); |
| } catch {} |
| try { |
| renderPassEncoder17.beginOcclusionQuery(24); |
| } catch {} |
| try { |
| renderPassEncoder11.setVertexBuffer(7, buffer79, 1_204, 516); |
| } catch {} |
| document.body.prepend(img0); |
| try { |
| adapter1.label = '\u0905\u35e9\u9a5d\u8a56'; |
| } catch {} |
| let buffer104 = device0.createBuffer({ |
| size: 28589, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| mappedAtCreation: false, |
| }); |
| let commandEncoder151 = device0.createCommandEncoder(); |
| let texture251 = device0.createTexture({ |
| size: [1968, 1, 220], |
| dimension: '3d', |
| format: 'rg16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder7.setBindGroup(2, bindGroup72, new Uint32Array(828), 39, 0); |
| } catch {} |
| document.body.prepend(img4); |
| let bindGroup86 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 323, resource: {buffer: buffer19, offset: 0, size: 2792}}, |
| {binding: 144, resource: textureView5}, |
| ], |
| }); |
| let computePassEncoder142 = commandEncoder151.beginComputePass({}); |
| try { |
| computePassEncoder138.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderPassEncoder17.setBindGroup(2, bindGroup11, new Uint32Array(1335), 41, 0); |
| } catch {} |
| try { |
| renderPassEncoder17.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder27.setIndexBuffer(buffer38, 'uint32', 0, 87); |
| } catch {} |
| try { |
| commandEncoder113.copyBufferToBuffer(buffer15, 192, buffer24, 60, 0); |
| } catch {} |
| try { |
| commandEncoder113.copyBufferToTexture({ |
| /* bytesInLastRow: 60 widthInBlocks: 15 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 940 */ |
| offset: 940, |
| buffer: buffer33, |
| }, { |
| texture: texture102, |
| mipLevel: 0, |
| origin: {x: 51, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 15, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer5, 600, new BigUint64Array(2539), 5, 52); |
| } catch {} |
| let commandEncoder152 = device0.createCommandEncoder(); |
| let computePassEncoder143 = commandEncoder152.beginComputePass({}); |
| let sampler87 = device0.createSampler({magFilter: 'linear', minFilter: 'linear', mipmapFilter: 'linear', lodMaxClamp: 92.50}); |
| try { |
| computePassEncoder136.setPipeline(pipeline11); |
| } catch {} |
| try { |
| renderPassEncoder11.setBindGroup(0, bindGroup20); |
| } catch {} |
| try { |
| renderPassEncoder11.setIndexBuffer(buffer14, 'uint32', 5_564, 3_646); |
| } catch {} |
| let commandEncoder153 = device0.createCommandEncoder({}); |
| let texture252 = device0.createTexture({ |
| size: {width: 615, height: 15, depthOrArrayLayers: 17}, |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderPassEncoder43 = commandEncoder113.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView93, |
| clearValue: { r: 784.4, g: 289.6, b: -570.1, a: 467.2, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet17, |
| maxDrawCount: 35322159, |
| }); |
| try { |
| computePassEncoder125.end(); |
| } catch {} |
| try { |
| computePassEncoder143.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder41.setVertexBuffer(1, buffer22); |
| } catch {} |
| try { |
| buffer101.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture210, |
| mipLevel: 2, |
| origin: {x: 157, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(20).fill(114), /* required buffer size: 20 */ |
| {offset: 20}, {width: 70, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let gpuCanvasContext3 = canvas0.getContext('webgpu'); |
| let buffer105 = device0.createBuffer({ |
| size: 14329, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder154 = device0.createCommandEncoder({}); |
| let texture253 = device0.createTexture({ |
| size: {width: 10, height: 11, depthOrArrayLayers: 134}, |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder44.setBindGroup(0, bindGroup75); |
| } catch {} |
| try { |
| computePassEncoder94.setBindGroup(0, bindGroup71, new Uint32Array(2168), 2_168, 0); |
| } catch {} |
| try { |
| renderPassEncoder32.setBindGroup(2, bindGroup24); |
| } catch {} |
| try { |
| renderPassEncoder31.setVertexBuffer(2, buffer2); |
| } catch {} |
| canvas0.height = 173; |
| let commandEncoder155 = device0.createCommandEncoder(); |
| let computePassEncoder144 = commandEncoder154.beginComputePass({}); |
| try { |
| computePassEncoder85.setBindGroup(0, bindGroup8, new Uint32Array(49), 5, 0); |
| } catch {} |
| try { |
| computePassEncoder75.end(); |
| } catch {} |
| try { |
| computePassEncoder141.setPipeline(pipeline19); |
| } catch {} |
| try { |
| renderPassEncoder36.setBindGroup(2, bindGroup78, []); |
| } catch {} |
| try { |
| renderPassEncoder37.setPipeline(pipeline15); |
| } catch {} |
| let arrayBuffer23 = buffer26.getMappedRange(168, 8); |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let bindGroup87 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout10, |
| entries: [ |
| {binding: 97, resource: externalTexture3}, |
| {binding: 45, resource: {buffer: buffer43, offset: 0, size: 182}}, |
| {binding: 68, resource: {buffer: buffer60, offset: 1536, size: 1044}}, |
| {binding: 64, resource: {buffer: buffer60, offset: 1536, size: 268}}, |
| ], |
| }); |
| let buffer106 = device0.createBuffer({ |
| size: 16135, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE, |
| }); |
| let texture254 = device0.createTexture({ |
| size: {width: 1230, height: 30, depthOrArrayLayers: 3}, |
| dimension: '3d', |
| format: 'rg16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder145 = commandEncoder155.beginComputePass({}); |
| try { |
| computePassEncoder144.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder32.setBindGroup(0, bindGroup82, []); |
| } catch {} |
| try { |
| renderPassEncoder32.beginOcclusionQuery(96); |
| } catch {} |
| try { |
| renderPassEncoder32.drawIndexed(916, 1, 135, 2_147_483_647); |
| } catch {} |
| try { |
| renderPassEncoder32.drawIndexedIndirect(buffer69, 16); |
| } catch {} |
| try { |
| renderPassEncoder26.setVertexBuffer(3, buffer79, 0, 324); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 1968, height: 1, depthOrArrayLayers: 746} |
| */ |
| { |
| source: imageData16, |
| origin: { x: 14, y: 2 }, |
| flipY: false, |
| }, { |
| texture: texture244, |
| mipLevel: 0, |
| origin: {x: 24, y: 0, z: 2}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline34 = device0.createRenderPipeline({ |
| layout: pipelineLayout4, |
| fragment: { |
| module: shaderModule7, |
| entryPoint: 'fragment7', |
| targets: [{format: 'r8uint'}, {format: 'r8sint', writeMask: 0}], |
| }, |
| vertex: {module: shaderModule7, buffers: []}, |
| primitive: {topology: 'line-list', cullMode: 'front', unclippedDepth: false}, |
| }); |
| let buffer107 = device0.createBuffer({ |
| size: 25136, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| let commandEncoder156 = device0.createCommandEncoder({}); |
| let commandBuffer13 = commandEncoder137.finish({}); |
| try { |
| computePassEncoder142.setPipeline(pipeline18); |
| } catch {} |
| try { |
| renderPassEncoder25.setBindGroup(0, bindGroup17); |
| } catch {} |
| try { |
| renderPassEncoder32.endOcclusionQuery(); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer13]); |
| } catch {} |
| let bindGroup88 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout10, |
| entries: [ |
| {binding: 64, resource: {buffer: buffer47, offset: 8192}}, |
| {binding: 97, resource: externalTexture4}, |
| {binding: 45, resource: {buffer: buffer8, offset: 0}}, |
| {binding: 68, resource: {buffer: buffer75, offset: 0, size: 568}}, |
| ], |
| }); |
| let buffer108 = device0.createBuffer({ |
| label: '\u{1f872}\ufad4\u1a32\u2467\u80db\u2275\u{1fe0e}', |
| size: 1765, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX, |
| }); |
| let commandEncoder157 = device0.createCommandEncoder({}); |
| let textureView171 = texture193.createView({arrayLayerCount: 1}); |
| let computePassEncoder146 = commandEncoder157.beginComputePass({}); |
| try { |
| computePassEncoder145.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder32.drawIndexedIndirect(buffer21, 268); |
| } catch {} |
| try { |
| renderPassEncoder42.setPipeline(pipeline21); |
| } catch {} |
| try { |
| renderPassEncoder20.setVertexBuffer(2, buffer74); |
| } catch {} |
| let arrayBuffer24 = buffer72.getMappedRange(224, 288); |
| try { |
| commandEncoder36.insertDebugMarker('\u{1f685}'); |
| } catch {} |
| await gc(); |
| let commandBuffer14 = commandEncoder36.finish(); |
| let sampler88 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| lodMaxClamp: 92.18, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder46); computePassEncoder46.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder12.setBindGroup(0, bindGroup26); |
| } catch {} |
| try { |
| renderPassEncoder12.drawIndexed(132, 506, 23, 315_026_510, 484_159_141); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer62, 952, new Float32Array(2201), 251, 204); |
| } catch {} |
| try { |
| if (!arrayBuffer8.detached) { new Uint8Array(arrayBuffer8).fill(0x55); }; |
| } catch {} |
| let bindGroup89 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout1, |
| entries: [ |
| {binding: 144, resource: textureView2}, |
| {binding: 323, resource: {buffer: buffer104, offset: 6912, size: 2124}}, |
| ], |
| }); |
| let computePassEncoder147 = commandEncoder156.beginComputePass({}); |
| let renderBundleEncoder16 = device0.createRenderBundleEncoder({ |
| colorFormats: ['rg32uint'], |
| depthStencilFormat: 'depth24plus-stencil8', |
| depthReadOnly: true, |
| stencilReadOnly: true, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder50); computePassEncoder50.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| computePassEncoder146.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder32.draw(40, 0, 857_937_993); |
| } catch {} |
| try { |
| renderPassEncoder32.drawIndexed(0, 1, 467, 114_040_420, 0); |
| } catch {} |
| try { |
| renderBundleEncoder16.setBindGroup(1, bindGroup54); |
| } catch {} |
| let pipeline35 = device0.createComputePipeline({layout: 'auto', compute: {module: shaderModule8, entryPoint: 'compute9'}}); |
| let textureView172 = texture57.createView({}); |
| let renderBundle16 = renderBundleEncoder16.finish({}); |
| try { |
| computePassEncoder134.setBindGroup(2, bindGroup34); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder44); computePassEncoder44.dispatchWorkgroups(4); }; |
| } catch {} |
| try { |
| renderPassEncoder27.setBindGroup(0, bindGroup89, new Uint32Array(63), 7, 0); |
| } catch {} |
| try { |
| renderPassEncoder21.setStencilReference(192); |
| } catch {} |
| try { |
| renderPassEncoder32.draw(360, 0, 54_253_529); |
| } catch {} |
| try { |
| renderPassEncoder12.drawIndirect(buffer12, 9_784); |
| } catch {} |
| try { |
| renderPassEncoder16.setPipeline(pipeline31); |
| } catch {} |
| try { |
| buffer24.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture71, |
| mipLevel: 0, |
| origin: {x: 265, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(316).fill(216), /* required buffer size: 316 */ |
| {offset: 316}, {width: 45, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 80, height: 90, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData8, |
| origin: { x: 7, y: 1 }, |
| flipY: false, |
| }, { |
| texture: texture128, |
| mipLevel: 0, |
| origin: {x: 32, y: 13, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 11, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder158 = device0.createCommandEncoder({}); |
| let textureView173 = texture35.createView({}); |
| let renderPassEncoder44 = commandEncoder153.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView55, |
| clearValue: { r: 643.7, g: -393.4, b: -34.12, a: 262.7, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder116); computePassEncoder116.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| renderPassEncoder12.draw(309, 10, 994_146_366, 2_268_513_823); |
| } catch {} |
| try { |
| renderPassEncoder37.setPipeline(pipeline17); |
| } catch {} |
| try { |
| commandEncoder158.copyBufferToTexture({ |
| /* bytesInLastRow: 486 widthInBlocks: 243 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 3280 */ |
| offset: 3280, |
| bytesPerRow: 12800, |
| buffer: buffer65, |
| }, { |
| texture: texture52, |
| mipLevel: 0, |
| origin: {x: 27, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 243, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder158.insertDebugMarker('\u7b3a'); |
| } catch {} |
| let bindGroup90 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout2, |
| entries: [ |
| {binding: 39, resource: {buffer: buffer20, offset: 256, size: 3100}}, |
| {binding: 41, resource: textureView8}, |
| ], |
| }); |
| let buffer109 = device0.createBuffer({size: 26749, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE}); |
| let commandEncoder159 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder0.setBindGroup(1, bindGroup69, new Uint32Array(611), 250, 0); |
| } catch {} |
| try { |
| renderPassEncoder24.beginOcclusionQuery(87); |
| } catch {} |
| try { |
| renderPassEncoder32.drawIndexed(12, 0, 180, 451_990_484); |
| } catch {} |
| try { |
| renderPassEncoder32.drawIndirect(buffer21, 3_356); |
| } catch {} |
| try { |
| renderPassEncoder44.setIndexBuffer(buffer2, 'uint16', 212, 91); |
| } catch {} |
| try { |
| renderPassEncoder31.setVertexBuffer(3, undefined, 0, 173_226_635); |
| } catch {} |
| try { |
| commandEncoder159.copyTextureToTexture({ |
| texture: texture166, |
| mipLevel: 0, |
| origin: {x: 2, y: 11, z: 2}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture112, |
| mipLevel: 0, |
| origin: {x: 32, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 14, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let recycledExplicitBindGroupLayout12 = pipeline20.getBindGroupLayout(0); |
| let buffer110 = device0.createBuffer({size: 2608, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM}); |
| let renderPassEncoder45 = commandEncoder158.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView101, |
| clearValue: { r: -418.2, g: 612.6, b: 488.0, a: -784.4, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder50); computePassEncoder50.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder12.draw(374, 270, 214_886_257, 882_002_545); |
| } catch {} |
| try { |
| renderPassEncoder32.drawIndexed(265, 0, 105, 373_096_869); |
| } catch {} |
| try { |
| renderPassEncoder12.drawIndirect(buffer1, 1_328); |
| } catch {} |
| try { |
| renderPassEncoder32.setVertexBuffer(5, buffer2, 208, 114); |
| } catch {} |
| let pipeline36 = await device0.createComputePipelineAsync({layout: pipelineLayout1, compute: {module: shaderModule1, constants: {}}}); |
| let textureView174 = texture123.createView({dimension: '2d-array', mipLevelCount: 1}); |
| let computePassEncoder148 = commandEncoder159.beginComputePass({}); |
| try { |
| computePassEncoder104.setBindGroup(0, bindGroup75, new Uint32Array(728), 19, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder137); computePassEncoder137.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| computePassEncoder147.setPipeline(pipeline13); |
| } catch {} |
| try { |
| renderPassEncoder45.executeBundles([renderBundle4, renderBundle4, renderBundle11]); |
| } catch {} |
| try { |
| renderPassEncoder32.draw(35, 0, 410_554_684); |
| } catch {} |
| try { |
| renderPassEncoder42.setIndexBuffer(buffer19, 'uint16', 4_066, 510); |
| } catch {} |
| try { |
| renderPassEncoder42.setVertexBuffer(4, buffer42, 0, 1_427); |
| } catch {} |
| try { |
| pipeline29.label = '\u3b85\ue3f9\ub3f8'; |
| } catch {} |
| try { |
| computePassEncoder148.setPipeline(pipeline25); |
| } catch {} |
| try { |
| renderPassEncoder24.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder38.executeBundles([renderBundle12]); |
| } catch {} |
| try { |
| renderPassEncoder12.draw(30, 53, 1_258_039_412, 121_431_764); |
| } catch {} |
| try { |
| renderPassEncoder32.drawIndexed(627, 0, 367, 333_211_435); |
| } catch {} |
| try { |
| renderPassEncoder32.drawIndexedIndirect(buffer51, 56); |
| } catch {} |
| try { |
| renderPassEncoder29.setVertexBuffer(1, buffer93, 24, 115); |
| } catch {} |
| document.body.prepend(canvas0); |
| let textureView175 = texture125.createView({mipLevelCount: 1}); |
| let sampler89 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| maxAnisotropy: 20, |
| }); |
| try { |
| renderPassEncoder37.executeBundles([renderBundle6, renderBundle12, renderBundle5]); |
| } catch {} |
| try { |
| renderPassEncoder12.draw(8, 146, 33_748_607, 311_722_382); |
| } catch {} |
| try { |
| renderPassEncoder12.drawIndirect(buffer83, 564); |
| } catch {} |
| try { |
| renderPassEncoder26.setPipeline(pipeline28); |
| } catch {} |
| let imageData20 = new ImageData(32, 12); |
| let commandEncoder160 = device0.createCommandEncoder(); |
| let textureView176 = texture209.createView({dimension: 'cube-array', baseArrayLayer: 7, arrayLayerCount: 6}); |
| let textureView177 = texture168.createView({}); |
| try { |
| computePassEncoder47.setBindGroup(3, bindGroup24); |
| } catch {} |
| try { |
| renderPassEncoder12.end(); |
| } catch {} |
| try { |
| renderPassEncoder39.executeBundles([renderBundle1, renderBundle10, renderBundle13, renderBundle11, renderBundle13, renderBundle6]); |
| } catch {} |
| try { |
| renderPassEncoder43.setViewport(441.8342173626416, 6.59340067610229, 622.7759592962082, 22.405200916217765, 0.45820810876216744, 0.6374612529568464); |
| } catch {} |
| try { |
| renderPassEncoder26.draw(31, 89, 322_769_769, 408_060_598); |
| } catch {} |
| try { |
| renderPassEncoder32.drawIndexed(819, 0, 568, 662_552_769); |
| } catch {} |
| try { |
| renderPassEncoder26.drawIndirect(buffer81, 2_588); |
| } catch {} |
| try { |
| computePassEncoder138.pushDebugGroup('\ua011'); |
| } catch {} |
| let imageData21 = new ImageData(40, 20); |
| let buffer111 = device0.createBuffer({ |
| size: 28442, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| let textureView178 = texture81.createView({dimension: 'cube', baseArrayLayer: 1}); |
| let computePassEncoder149 = commandEncoder160.beginComputePass({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder29); computePassEncoder29.dispatchWorkgroupsIndirect(buffer102, 6_728); }; |
| } catch {} |
| try { |
| renderPassEncoder26.draw(31, 19, 391_769_119, 265_814_448); |
| } catch {} |
| try { |
| renderPassEncoder26.drawIndexed(51, 294, 11, 284_811_949, 793_833_973); |
| } catch {} |
| try { |
| renderPassEncoder19.setVertexBuffer(2, buffer43, 0, 10); |
| } catch {} |
| let buffer112 = device0.createBuffer({size: 12726, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE}); |
| let commandEncoder161 = device0.createCommandEncoder({}); |
| let texture255 = device0.createTexture({ |
| size: {width: 984, height: 1, depthOrArrayLayers: 31}, |
| mipLevelCount: 3, |
| format: 'depth24plus-stencil8', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView179 = texture97.createView({dimension: '2d-array', baseMipLevel: 0}); |
| let renderPassEncoder46 = commandEncoder161.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView134, |
| depthSlice: 9, |
| clearValue: { r: 244.1, g: 937.7, b: 610.7, a: 987.4, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| renderPassEncoder32.drawIndexedIndirect(buffer92, 3_684); |
| } catch {} |
| try { |
| renderPassEncoder26.drawIndirect(buffer12, 1_264); |
| } catch {} |
| try { |
| renderPassEncoder45.setVertexBuffer(3, buffer40, 8_408, 14_758); |
| } catch {} |
| try { |
| commandEncoder50.resolveQuerySet(querySet10, 105, 0, buffer8, 1024); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer14]); |
| } catch {} |
| document.body.append(canvas0); |
| let commandBuffer15 = commandEncoder50.finish(); |
| let texture256 = device0.createTexture({ |
| size: {width: 1968, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 4, |
| format: 'rg32uint', |
| usage: GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| computePassEncoder52.end(); |
| } catch {} |
| try { |
| renderPassEncoder32.drawIndexedIndirect(buffer87, 12); |
| } catch {} |
| try { |
| commandEncoder65.copyBufferToBuffer(buffer46, 4308, buffer24, 28, 32); |
| } catch {} |
| try { |
| commandEncoder65.copyBufferToTexture({ |
| /* bytesInLastRow: 56 widthInBlocks: 14 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 2520 */ |
| offset: 2520, |
| bytesPerRow: 5888, |
| rowsPerImage: 1403, |
| buffer: buffer48, |
| }, { |
| texture: texture108, |
| mipLevel: 0, |
| origin: {x: 7, y: 29, z: 0}, |
| aspect: 'all', |
| }, {width: 14, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder65.copyTextureToBuffer({ |
| texture: texture36, |
| mipLevel: 2, |
| origin: {x: 35, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 48 widthInBlocks: 24 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 1134 */ |
| offset: 1134, |
| bytesPerRow: 39936, |
| buffer: buffer37, |
| }, {width: 24, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 123, height: 1, depthOrArrayLayers: 153} |
| */ |
| { |
| source: videoFrame12, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture6, |
| mipLevel: 1, |
| origin: {x: 15, y: 0, z: 8}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let shaderModule9 = device0.createShaderModule({ |
| code: ` |
| diagnostic(info, xyz); |
| |
| enable f16; |
| |
| requires packed_4x8_integer_dot_product; |
| |
| /* zero global variables used */ |
| fn fn1() { |
| var vf216 = fn0(); |
| var vf217: vec2f = unpack2x16float(unconst_u32(372)); |
| var vf218: vec2f = unpack2x16float(unconst_u32(148)); |
| vf217 = vec2f(sinh(unconst_f32(0.09020))); |
| if bool((vec4i(unconst_i32(88), unconst_i32(35), unconst_i32(-127), unconst_i32(510)) << vec4u(unconst_u32(256), unconst_u32(2), unconst_u32(60), unconst_u32(282)))[3]) { |
| } |
| loop { |
| let vf219: vec3f = saturate(vec3f(unconst_f32(0.01449), unconst_f32(-0.01685), unconst_f32(0.01552))); |
| var vf220: bool = (unconst_f16(8164.5) < unconst_f16(2399.4)); |
| vf220 = bool(pack4x8unorm(vec4f(unconst_f32(-0.6885), unconst_f32(0.05012), unconst_f32(0.5448), unconst_f32(0.1845)))); |
| break; |
| } |
| vf217 = vec2f(f32(length(vec2h(unconst_f16(5598.8), unconst_f16(1483.2))))); |
| switch i32(vf216.f15[2]) { |
| default { |
| var vf221 = fn0(); |
| let vf222: f16 = asin(unconst_f16(3102.2)); |
| break; |
| _ = override3; |
| } |
| } |
| vf217 = cross(vec3f(unconst_f32(0.1592), unconst_f32(0.03913), unconst_f32(0.06845)), vec3f(unconst_f32(0.6021), unconst_f32(0.08388), unconst_f32(-0.2612))).bg; |
| var vf223 = fn0(); |
| let ptr72: ptr<function, i32> = &vf223.f16; |
| vf218 = vec2f(bitcast<f32>(vf223.f16)); |
| _ = override3; |
| } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| struct T0 { |
| f0: f32, |
| } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| struct VertexOutput8 { |
| @invariant @builtin(position) f15: vec4f, |
| @location(7) f16: i32, |
| } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| /* zero global variables used */ |
| fn fn0() -> VertexOutput8 { |
| var out: VertexOutput8; |
| let vf204: vec4i = unpack4xI8(unconst_u32(18)); |
| out.f16 ^= vec2i( !vec2<bool>(unconst_bool(true), unconst_bool(false))).x; |
| out = VertexOutput8(bitcast<vec4f>(unpack4xI8(u32(log(unconst_f16(8526.7))))), unpack4xI8(u32(log(unconst_f16(8526.7))))[2]); |
| out.f16 += vf204[unconst_u32(193)]; |
| out = VertexOutput8(log2(unpack4x8unorm(unconst_u32(80)).br).xxxy, bitcast<vec2i>(log2(unpack4x8unorm(unconst_u32(80)).br))[0]); |
| var vf205: u32 = pack4xI8Clamp(vec4i(unconst_i32(310), unconst_i32(-150), unconst_i32(93), unconst_i32(403))); |
| let vf206: vec2<bool> = select(vec2<bool>(unconst_bool(true), unconst_bool(true)), vec2<bool>(unconst_bool(false), unconst_bool(false)), vec2<bool>(unconst_bool(true), unconst_bool(true))); |
| let vf207: u32 = pack4x8snorm(vec4f(unconst_f32(-0.03361), unconst_f32(-0.00133), unconst_f32(0.2899), unconst_f32(0.3913))); |
| while bool(pack4x8snorm(unpack4x8unorm(unconst_u32(137)))) { |
| var vf208: vec2f = unpack2x16unorm(unconst_u32(12)); |
| let vf209: vec2u = insertBits(vec2u(pack4x8snorm(vec4f(unconst_f32(0.06249), unconst_f32(0.1804), unconst_f32(0.04796), unconst_f32(0.09093)))), vec2u(unconst_u32(68), unconst_u32(32)), unconst_u32(52), ~vec4u(unconst_u32(85), unconst_u32(323), unconst_u32(143), unconst_u32(914)).a); |
| let vf210: f32 = distance(vec3f(unconst_f32(0.3098), unconst_f32(0.05215), unconst_f32(0.01388)), vec3f(unconst_f32(0.1648), unconst_f32(0.1415), unconst_f32(0.07508))); |
| if bool(faceForward(vec3f(unconst_f32(-0.00126), unconst_f32(-0.07049), unconst_f32(0.5806)), fma(vec3f(unconst_f32(0.1924), unconst_f32(0.1859), unconst_f32(-0.1756)), vec3f(unconst_f32(0.2901), unconst_f32(0.08623), unconst_f32(0.00388)), vec3f(unconst_f32(0.00506), unconst_f32(0.06619), unconst_f32(0.1299))), vec3f(unconst_f32(0.1247), unconst_f32(0.3422), unconst_f32(0.3592))).z) { |
| out.f15 = vec4f(tanh(unconst_f32(0.09897))); |
| out.f15 -= vec4f(f32(asinh(unconst_f16(-21704.3)))); |
| var vf211: f32 = fma(unconst_f32(0.1397), unconst_f32(0.07337), unconst_f32(0.2475)); |
| var vf212: i32 = override3; |
| break; |
| _ = override3; |
| } |
| break; |
| _ = override3; |
| } |
| while bool(vf204[2]) { |
| out = VertexOutput8(vec4f(tan(vec3h(unconst_f16(20801.3), unconst_f16(-6080.0), unconst_f16(36354.1))).rbbb), i32(tan(vec3h(unconst_f16(20801.3), unconst_f16(-6080.0), unconst_f16(36354.1)))[0])); |
| let vf213: vec3h = sinh(acosh(vec4h(unconst_f16(-7523.1), unconst_f16(13278.1), unconst_f16(5513.5), unconst_f16(2019.2))).zyz); |
| var vf214: vec3i = (vec3i(unconst_i32(-40), unconst_i32(-60), unconst_i32(28)) + bitcast<vec3i>(clamp(vec4f(unconst_f32(0.4943), unconst_f32(-0.2108), unconst_f32(0.5430), unconst_f32(0.2339)), vec4f(bitcast<f32>(insertBits(u32(min(unconst_f16(15484.7), unconst_f16(522.3))), unconst_u32(147), unconst_u32(306), unconst_u32(150)))), vec4f(f32(pack4xU8(vec4u(unconst_u32(80), unconst_u32(326), unconst_u32(14), unconst_u32(78)))))).wyz)); |
| out.f15 -= bitcast<vec4f>((vec3i(unconst_i32(312), unconst_i32(81), unconst_i32(330)) + vec3i(unconst_i32(397), unconst_i32(22), unconst_i32(191))).yyyz); |
| return out; |
| } |
| var vf215: i32 = vf204[unconst_u32(175)]; |
| return out; |
| _ = override3; |
| } |
| |
| override override3: i32; |
| |
| @group(0) @binding(125) var st9: texture_storage_2d_array<r32float, read_write>; |
| |
| struct T1 { |
| f0: atomic<i32>, |
| } |
| |
| /* used global variables: buffer113, st9 */ |
| fn fn2() -> VertexOutput8 { |
| var out: VertexOutput8; |
| while bool(normalize(vec2f(unconst_f32(0.6305), unconst_f32(0.2210)))[0]) { |
| let vf224: f16 = acosh(unconst_f16(22966.2)); |
| fn0(); |
| fn0(); |
| fn0(); |
| out.f15 = vec4f((vec2i(bitcast<i32>(extractBits(unconst_u32(202), unconst_u32(725), unconst_u32(8)))) | vec2i(unconst_i32(1), unconst_i32(107))).grrg); |
| return out; |
| _ = override3; |
| } |
| var vf225: f16 = floor(f16(textureDimensions(st9)[1])); |
| let vf226: vec2f = unpack2x16snorm(unconst_u32(42)); |
| var vf227 = fn0(); |
| if bool((*&buffer113).g) { |
| out.f16 = i32(all((vec2f(f32(dot(vec3i(unconst_i32(116), unconst_i32(191), unconst_i32(6)), vec3i(unconst_i32(37), unconst_i32(66), unconst_i32(239))))) < vec2f(unconst_f32(0.08934), unconst_f32(0.2423))))); |
| out = VertexOutput8(vec4f(radians(vec4h(f16((abs(vec3h(unconst_f16(19386.6), unconst_f16(1229.1), unconst_f16(58.51))).b <= unconst_f16(11004.7)))))), i32(radians(vec4h(f16((abs(vec3h(unconst_f16(19386.6), unconst_f16(1229.1), unconst_f16(58.51))).b <= unconst_f16(11004.7))))).r)); |
| var vf228: u32 = textureNumLayers(st9); |
| for (var it8=pack4x8unorm(quantizeToF16(vec4f(unconst_f32(0.09900), unconst_f32(0.00195), unconst_f32(0.2841), unconst_f32(-0.04257)))); it8<u32(log2(vec3f(unconst_f32(0.2416), unconst_f32(0.3935), unconst_f32(0.1192)))[1]); it8++) { |
| let vf229: vec3h = fract(vec3h(unconst_f16(27198.6), unconst_f16(-1822.7), unconst_f16(27316.5))); |
| var vf230 = fn0(); |
| let vf231: vec3h = fract(vec3h(unconst_f16(4847.6), unconst_f16(8488.3), unconst_f16(21258.1))); |
| _ = override3; |
| } |
| textureStore(st9, vec2i(unconst_i32(194), unconst_i32(87)), unconst_i32(41), vec4f(vec4f(unconst_f32(-0.03345), unconst_f32(-0.01516), unconst_f32(0.1483), unconst_f32(0.01804)))); |
| return out; |
| _ = override3; |
| _ = st9; |
| } |
| return out; |
| _ = override3; |
| _ = st9; |
| _ = buffer113; |
| } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| @group(0) @binding(166) var<uniform> buffer113: vec2h; |
| |
| struct S6 { |
| @builtin(num_workgroups) @size(16) f0: vec3u, |
| } |
| |
| /* zero global variables used */ |
| @vertex @must_use |
| fn vertex9(@builtin(vertex_index) a0: u32, @location(9) @interpolate(flat) a1: vec2i) -> VertexOutput8 { |
| var out: VertexOutput8; |
| fn1(); |
| return out; |
| _ = override3; |
| } |
| |
| /* used global variables: buffer113, st9 */ |
| @fragment |
| fn fragment8(@builtin(position) a0: vec4f, @builtin(front_facing) a1: bool) -> @location(200) @interpolate(perspective, centroid) vec2f { |
| var out: vec2f; |
| out = (vec3f(f32((bool(textureDimensions(st9).r) || unconst_bool(false)))) / unconst_f32(0.1003)).yx; |
| fn2(); |
| out = vec2f(buffer113); |
| fn2(); |
| fn2(); |
| out = asin(vec3f(unconst_f32(0.02056), unconst_f32(0.3598), unconst_f32(-0.07031))).rb; |
| out = bitcast<vec2f>(unpack4xI8(unconst_u32(125)).rb); |
| textureStore(st9, vec2i(unconst_i32(184), unconst_i32(255)), unconst_i32(30), vec4f(vec4f(unconst_f32(0.1224), unconst_f32(-0.00613), unconst_f32(0.2452), unconst_f32(0.00201)))); |
| let vf232: vec3u = countTrailingZeros(vec3u(unconst_u32(212), unconst_u32(39), unconst_u32(143))); |
| out -= unpack2x16unorm( ~unconst_u32(20)); |
| var vf233: vec3f = mix(vec3f(unconst_f32(0.04535), unconst_f32(0.00958), unconst_f32(0.4644)), saturate(vec3f(unconst_f32(0.07660), unconst_f32(0.00708), unconst_f32(0.1365))), unconst_f32(0.6175)); |
| fn0(); |
| for (var it9=textureNumLayers(st9); it9<bitcast<u32>((*&buffer113)); it9++) { |
| var vf234: vec3f = pow(vec3f(unconst_f32(0.02760), unconst_f32(0.1740), unconst_f32(0.05170)), vec3f(unconst_f32(0.2252), unconst_f32(0.1214), unconst_f32(0.2841))); |
| let ptr73: ptr<function, vec3f> = &vf234; |
| var vf235: f32 = a0[unconst_u32(209)]; |
| break; |
| } |
| textureStore(st9, vec2i(unconst_i32(125), unconst_i32(50)), unconst_i32(405), vec4f(vec4f(unconst_f32(0.07443), unconst_f32(-0.1940), unconst_f32(-0.2082), unconst_f32(0.08973)))); |
| textureStore(st9, vec2i(unconst_i32(141), unconst_i32(97)), unconst_i32(65), vec4f(vec4f(unconst_f32(0.3971), unconst_f32(0.05327), unconst_f32(0.1769), unconst_f32(0.06950)))); |
| return out; |
| _ = override3; |
| _ = st9; |
| _ = buffer113; |
| } |
| |
| /* used global variables: buffer113, st9 */ |
| @compute @workgroup_size(5, 2, 1) |
| fn compute10(@builtin(local_invocation_id) a0: vec3u, @builtin(workgroup_id) a1: vec3u) { |
| textureStore(st9, vec2i(i32(pack4xI8(vec4i(unpack4x8snorm(unconst_u32(264)))))), bitcast<i32>(textureNumLayers(st9)), vec4f(vec4f(unconst_f32(0.08884), unconst_f32(0.01925), unconst_f32(0.1500), unconst_f32(0.1810)))); |
| textureStore(st9, vec2i(unconst_i32(45), unconst_i32(32)), unconst_i32(301), vec4f(vec4f(unconst_f32(0.8096), unconst_f32(0.00877), unconst_f32(0.2543), unconst_f32(0.06527)))); |
| textureStore(st9, vec2i(unconst_i32(-155), unconst_i32(179)), unconst_i32(56), vec4f(vec4f(unconst_f32(0.01924), unconst_f32(0.5725), unconst_f32(0.1111), unconst_f32(0.2641)))); |
| textureStore(st9, vec2i(unconst_i32(346), unconst_i32(75)), unconst_i32(170), vec4f(vec4f(unconst_f32(0.1695), unconst_f32(0.2078), unconst_f32(0.01679), unconst_f32(0.06400)))); |
| let vf236: f16 = determinant(mat3x3h(unconst_f16(1052.0), unconst_f16(5095.5), unconst_f16(1719.8), unconst_f16(16437.0), unconst_f16(-8421.1), unconst_f16(-7800.8), unconst_f16(38037.9), unconst_f16(21243.1), unconst_f16(-2952.3))); |
| var vf237: u32 = textureNumLayers(st9); |
| vf237 <<= u32(buffer113[unconst_u32(20)]); |
| _ = st9; |
| _ = buffer113; |
| } |
| |
| /* used global variables: buffer113, st9 */ |
| @compute @workgroup_size(1, 1, 2) |
| fn compute11(a0: S6, @builtin(local_invocation_id) a1: vec3u) { |
| var vf238: bool = (unconst_bool(false) || unconst_bool(false)); |
| if bool(a0.f0[2]) { |
| while bool((firstLeadingBit(vec2i(unconst_i32(63), unconst_i32(70))).xxxy | vec4i(textureDimensions(st9).grgg))[2]) { |
| textureStore(st9, vec2i(unconst_i32(344), unconst_i32(46)), unconst_i32(32), vec4f(vec4f(buffer113.gggr))); |
| var vf239: u32 = a0.f0[unconst_u32(143)]; |
| _ = buffer113; |
| _ = st9; |
| } |
| fn2(); |
| var vf240 = fn0(); |
| vf240.f15 = unpack4x8snorm(insertBits(unconst_u32(5), unconst_u32(41), unconst_u32(26), bitcast<u32>(cosh(vec2h(unconst_f16(4011.0), unconst_f16(39987.9)))))); |
| _ = override3; |
| _ = buffer113; |
| _ = st9; |
| } |
| var vf241: vec4i = extractBits(vec4i(unconst_i32(512), unconst_i32(227), unconst_i32(-16), unconst_i32(422)), unconst_u32(315), unconst_u32(73)); |
| fn0(); |
| let vf242: vec3h = pow(vec3h(unconst_f16(-6134.2), unconst_f16(13217.4), unconst_f16(-2976.8)), vec3h(unconst_f16(7059.0), unconst_f16(7933.8), unconst_f16(79.25))); |
| textureStore(st9, vec2i(unconst_i32(217), unconst_i32(185)), unconst_i32(153), vec4f(vec4f(unconst_f32(0.4748), unconst_f32(0.03500), unconst_f32(0.2293), unconst_f32(-0.07821)))); |
| _ = override3; |
| _ = st9; |
| _ = buffer113; |
| }`, |
| }); |
| let commandEncoder162 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder140.setBindGroup(2, bindGroup78, new Uint32Array(5198), 1_850, 0); |
| } catch {} |
| try { |
| renderPassEncoder26.end(); |
| } catch {} |
| try { |
| renderPassEncoder32.drawIndexed(310, 0, 541, 247_949_822); |
| } catch {} |
| try { |
| renderPassEncoder32.drawIndexedIndirect(buffer70, 4); |
| } catch {} |
| try { |
| renderPassEncoder32.drawIndirect(buffer70, 32); |
| } catch {} |
| try { |
| renderPassEncoder15.setVertexBuffer(0, buffer5, 7_884, 428); |
| } catch {} |
| try { |
| commandEncoder77.copyBufferToTexture({ |
| /* bytesInLastRow: 100 widthInBlocks: 100 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 2863 */ |
| offset: 2863, |
| buffer: buffer86, |
| }, { |
| texture: texture219, |
| mipLevel: 0, |
| origin: {x: 153, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 100, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline37 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule9, entryPoint: 'compute11', constants: {override3: 1}}}); |
| let buffer114 = device0.createBuffer({ |
| size: 191, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE, |
| }); |
| let commandEncoder163 = device0.createCommandEncoder({}); |
| let textureView180 = texture7.createView({dimension: '2d'}); |
| let sampler90 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 96.54, |
| compare: 'less-equal', |
| maxAnisotropy: 11, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder137); computePassEncoder137.dispatchWorkgroups(2, 1, 2); }; |
| } catch {} |
| try { |
| computePassEncoder149.setPipeline(pipeline13); |
| } catch {} |
| try { |
| renderPassEncoder32.drawIndirect(buffer83, 1_348); |
| } catch {} |
| try { |
| commandEncoder65.copyBufferToBuffer(buffer20, 9504, buffer72, 60, 1112); |
| } catch {} |
| try { |
| commandEncoder163.resolveQuerySet(querySet9, 98, 1, buffer114, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer74, 556, new Float32Array(10426), 1198, 116); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let commandEncoder164 = device0.createCommandEncoder({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder133); computePassEncoder133.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| renderPassEncoder15.setBindGroup(3, bindGroup60, new Uint32Array(585), 2, 0); |
| } catch {} |
| try { |
| renderPassEncoder32.draw(176, 0, 372_044_939, 1); |
| } catch {} |
| document.body.prepend(img4); |
| let canvas1 = document.createElement('canvas'); |
| let commandBuffer16 = commandEncoder77.finish(); |
| let externalTexture12 = device0.importExternalTexture({source: videoFrame4, colorSpace: 'srgb'}); |
| try { |
| renderPassEncoder32.end(); |
| } catch {} |
| try { |
| renderPassEncoder33.executeBundles([renderBundle1, renderBundle1, renderBundle0, renderBundle3]); |
| } catch {} |
| try { |
| renderPassEncoder43.setPipeline(pipeline0); |
| } catch {} |
| try { |
| commandEncoder164.clearBuffer(buffer108, 140, 28); |
| } catch {} |
| await gc(); |
| let computePassEncoder150 = commandEncoder65.beginComputePass({}); |
| try { |
| computePassEncoder71.setBindGroup(1, bindGroup89, new Uint32Array(149), 13, 0); |
| } catch {} |
| try { |
| computePassEncoder150.setPipeline(pipeline35); |
| } catch {} |
| try { |
| renderPassEncoder20.setBindGroup(1, bindGroup22, new Uint32Array(6851), 2_816, 0); |
| } catch {} |
| try { |
| renderPassEncoder14.executeBundles([renderBundle4]); |
| } catch {} |
| try { |
| buffer97.unmap(); |
| } catch {} |
| try { |
| commandEncoder164.copyTextureToTexture({ |
| texture: texture79, |
| mipLevel: 0, |
| origin: {x: 343, y: 3, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture90, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 3, height: 3, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer15]); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture89, |
| mipLevel: 1, |
| origin: {x: 47, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(99).fill(19), /* required buffer size: 99 */ |
| {offset: 99, bytesPerRow: 649}, {width: 314, height: 7, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let querySet20 = device0.createQuerySet({type: 'occlusion', count: 185}); |
| let computePassEncoder151 = commandEncoder162.beginComputePass({}); |
| try { |
| computePassEncoder119.setBindGroup(0, bindGroup12); |
| } catch {} |
| let promise13 = device0.queue.onSubmittedWorkDone(); |
| let recycledExplicitBindGroupLayout13 = pipeline7.getBindGroupLayout(0); |
| let buffer115 = device0.createBuffer({ |
| size: 1736, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM, |
| }); |
| let texture257 = device0.createTexture({ |
| size: [1880, 10, 1], |
| dimension: '2d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView181 = texture194.createView({dimension: '2d'}); |
| let sampler91 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'mirror-repeat', addressModeW: 'mirror-repeat'}); |
| try { |
| renderPassEncoder35.setBindGroup(2, bindGroup42, new Uint32Array(1739), 77, 0); |
| } catch {} |
| try { |
| renderPassEncoder36.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderPassEncoder45.setVertexBuffer(6, buffer40); |
| } catch {} |
| try { |
| computePassEncoder138.popDebugGroup(); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer16]); |
| } catch {} |
| let bindGroup91 = device0.createBindGroup({layout: veryExplicitBindGroupLayout14, entries: [{binding: 21, resource: textureView57}]}); |
| let commandBuffer17 = commandEncoder97.finish({}); |
| try { |
| computePassEncoder151.setPipeline(pipeline33); |
| } catch {} |
| try { |
| renderPassEncoder19.setVertexBuffer(6, buffer56, 644, 1_328); |
| } catch {} |
| try { |
| buffer102.unmap(); |
| } catch {} |
| let veryExplicitBindGroupLayout22 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 33, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| {binding: 54, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'comparison' }}, |
| {binding: 77, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| { |
| binding: 119, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '2d' }, |
| }, |
| {binding: 155, visibility: GPUShaderStage.COMPUTE, externalTexture: {}}, |
| ], |
| }); |
| let commandEncoder165 = device0.createCommandEncoder({}); |
| let texture258 = device0.createTexture({ |
| size: {width: 153, height: 3, depthOrArrayLayers: 1}, |
| mipLevelCount: 4, |
| sampleCount: 1, |
| format: 'depth24plus-stencil8', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderPassEncoder47 = commandEncoder165.beginRenderPass({colorAttachments: [{view: textureView134, depthSlice: 40, loadOp: 'clear', storeOp: 'discard'}]}); |
| try { |
| computePassEncoder139.setBindGroup(0, bindGroup25, new Uint32Array(133), 10, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder85); computePassEncoder85.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| renderPassEncoder13.setVertexBuffer(1, buffer85, 0, 1_242); |
| } catch {} |
| try { |
| buffer115.unmap(); |
| } catch {} |
| try { |
| commandEncoder163.clearBuffer(buffer28, 2632, 168); |
| } catch {} |
| try { |
| externalTexture9.label = '\u{1f96e}\udcd3\uf1e8\ub9bc\u02f7\u1ae4\u067a\u{1f610}\u29cd\u9a00'; |
| } catch {} |
| let commandEncoder166 = device0.createCommandEncoder({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder46); computePassEncoder46.dispatchWorkgroupsIndirect(buffer52, 180); }; |
| } catch {} |
| try { |
| renderPassEncoder17.setBindGroup(0, bindGroup1); |
| } catch {} |
| try { |
| renderPassEncoder35.setBindGroup(0, bindGroup73, new Uint32Array(699), 38, 0); |
| } catch {} |
| try { |
| renderPassEncoder35.drawIndexedIndirect(buffer70, 4); |
| } catch {} |
| try { |
| renderPassEncoder15.setIndexBuffer(buffer92, 'uint32', 7_588, 2_047); |
| } catch {} |
| try { |
| commandEncoder164.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1220 */ |
| offset: 1220, |
| bytesPerRow: 3328, |
| buffer: buffer84, |
| }, { |
| texture: texture175, |
| mipLevel: 0, |
| origin: {x: 0, y: 1, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let promise14 = device0.queue.onSubmittedWorkDone(); |
| let computePassEncoder152 = commandEncoder164.beginComputePass({}); |
| let sampler92 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'repeat', lodMinClamp: 74.10, lodMaxClamp: 84.67}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder151); computePassEncoder151.dispatchWorkgroupsIndirect(buffer62, 396); }; |
| } catch {} |
| try { |
| renderPassEncoder27.setBindGroup(2, bindGroup82); |
| } catch {} |
| try { |
| renderPassEncoder43.setBindGroup(1, bindGroup58, new Uint32Array(2042), 607, 0); |
| } catch {} |
| try { |
| renderPassEncoder35.drawIndexedIndirect(buffer89, 240); |
| } catch {} |
| try { |
| renderPassEncoder35.drawIndirect(buffer60, 792); |
| } catch {} |
| try { |
| renderPassEncoder27.setIndexBuffer(buffer108, 'uint32', 24, 359); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer17]); |
| } catch {} |
| let gpuCanvasContext4 = canvas1.getContext('webgpu'); |
| let bindGroup92 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout3, |
| entries: [ |
| {binding: 144, resource: textureView145}, |
| {binding: 323, resource: {buffer: buffer33, offset: 256, size: 1216}}, |
| ], |
| }); |
| let querySet21 = device0.createQuerySet({type: 'occlusion', count: 288}); |
| let texture259 = device0.createTexture({ |
| size: {width: 492, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'depth24plus-stencil8', |
| usage: GPUTextureUsage.COPY_DST, |
| viewFormats: ['depth24plus-stencil8'], |
| }); |
| let textureView182 = texture21.createView({dimension: '2d-array'}); |
| try { |
| computePassEncoder152.setPipeline(pipeline25); |
| } catch {} |
| try { |
| renderPassEncoder15.setBindGroup(0, bindGroup69, new Uint32Array(616), 89, 0); |
| } catch {} |
| try { |
| renderPassEncoder41.setIndexBuffer(buffer89, 'uint32', 624, 144); |
| } catch {} |
| try { |
| commandEncoder163.copyBufferToTexture({ |
| /* bytesInLastRow: 26 widthInBlocks: 13 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 2852 */ |
| offset: 2852, |
| rowsPerImage: 1127, |
| buffer: buffer80, |
| }, { |
| texture: texture190, |
| mipLevel: 0, |
| origin: {x: 19, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 13, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let videoFrame22 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-cl', primaries: 'bt470m', transfer: 'hlg'} }); |
| let texture260 = device0.createTexture({size: [984], dimension: '1d', format: 'r8uint', usage: GPUTextureUsage.COPY_SRC}); |
| let computePassEncoder153 = commandEncoder163.beginComputePass(); |
| try { |
| renderPassEncoder35.draw(114, 326, 1_243_395_296, 61_912_001); |
| } catch {} |
| try { |
| renderPassEncoder35.drawIndexed(28, 349, 17, 329_730_128, 356_979_686); |
| } catch {} |
| try { |
| renderPassEncoder35.drawIndirect(buffer33, 948); |
| } catch {} |
| try { |
| renderPassEncoder46.setIndexBuffer(buffer67, 'uint32', 36, 823); |
| } catch {} |
| let arrayBuffer25 = buffer26.getMappedRange(240, 0); |
| try { |
| device0.queue.writeTexture({ |
| texture: texture203, |
| mipLevel: 0, |
| origin: {x: 0, y: 5, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(119).fill(3), /* required buffer size: 119 */ |
| {offset: 119}, {width: 0, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let computePassEncoder154 = commandEncoder166.beginComputePass({}); |
| let sampler93 = device0.createSampler({ |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 68.32, |
| }); |
| try { |
| renderPassEncoder44.setVertexBuffer(1, buffer5, 852, 1_184); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| await gc(); |
| let recycledExplicitBindGroupLayout14 = pipeline5.getBindGroupLayout(0); |
| let bindGroup93 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout4, |
| entries: [ |
| {binding: 39, resource: {buffer: buffer81, offset: 1280, size: 5628}}, |
| {binding: 41, resource: textureView53}, |
| ], |
| }); |
| let pipelineLayout18 = device0.createPipelineLayout({bindGroupLayouts: [veryExplicitBindGroupLayout5]}); |
| let querySet22 = device0.createQuerySet({type: 'occlusion', count: 77}); |
| try { |
| computePassEncoder7.setBindGroup(0, bindGroup81, new Uint32Array(2908), 8, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder139); computePassEncoder139.dispatchWorkgroupsIndirect(buffer2, 680); }; |
| } catch {} |
| try { |
| computePassEncoder124.setPipeline(pipeline19); |
| } catch {} |
| try { |
| computePassEncoder153.setPipeline(pipeline37); |
| } catch {} |
| try { |
| renderPassEncoder15.draw(345, 96, 156_830_206, 11_736_963); |
| } catch {} |
| try { |
| renderPassEncoder35.drawIndexed(0, 51, 2, -2_050_116_145, 609_783_089); |
| } catch {} |
| try { |
| renderPassEncoder15.drawIndirect(buffer114, 12); |
| } catch {} |
| try { |
| buffer28.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture225, |
| mipLevel: 0, |
| origin: {x: 10, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(92).fill(41), /* required buffer size: 92 */ |
| {offset: 92, bytesPerRow: 113}, {width: 8, height: 19, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline38 = await device0.createComputePipelineAsync({layout: pipelineLayout3, compute: {module: shaderModule8}}); |
| let buffer116 = device0.createBuffer({ |
| size: 814, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE, |
| }); |
| let querySet23 = device0.createQuerySet({type: 'occlusion', count: 1892}); |
| try { |
| computePassEncoder129.setBindGroup(0, bindGroup92); |
| } catch {} |
| try { |
| computePassEncoder85.end(); |
| } catch {} |
| try { |
| computePassEncoder154.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderPassEncoder41.setBlendConstant({ r: 718.4, g: -150.3, b: 960.8, a: 871.0, }); |
| } catch {} |
| try { |
| renderPassEncoder13.setViewport(35.957043929367686, 0.3906617468418573, 527.1402194531695, 0.3079656581032337, 0.8126004257518021, 0.8542464949171331); |
| } catch {} |
| try { |
| renderPassEncoder15.drawIndirect(buffer97, 168); |
| } catch {} |
| try { |
| commandEncoder16.copyBufferToTexture({ |
| /* bytesInLastRow: 1120 widthInBlocks: 140 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 80 */ |
| offset: 80, |
| bytesPerRow: 7168, |
| buffer: buffer42, |
| }, { |
| texture: texture24, |
| mipLevel: 0, |
| origin: {x: 50, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 140, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder167 = device0.createCommandEncoder({}); |
| let computePassEncoder155 = commandEncoder16.beginComputePass({}); |
| try { |
| computePassEncoder57.setBindGroup(2, bindGroup44); |
| } catch {} |
| try { |
| computePassEncoder137.setBindGroup(3, bindGroup60, new Uint32Array(3024), 122, 0); |
| } catch {} |
| try { |
| computePassEncoder116.end(); |
| } catch {} |
| try { |
| renderPassEncoder14.setScissorRect(11, 0, 29, 0); |
| } catch {} |
| try { |
| renderPassEncoder38.setViewport(37.12303208180343, 41.760680288937756, 0.9437596957084109, 1.8763246990122755, 0.2801549338967556, 0.5246252165030834); |
| } catch {} |
| try { |
| renderPassEncoder15.draw(151, 591, 120_167_919, 1_259_729_520); |
| } catch {} |
| try { |
| renderPassEncoder15.drawIndexed(12, 292, 120, 311_091_000, 412_333_163); |
| } catch {} |
| try { |
| renderPassEncoder15.drawIndexedIndirect(buffer70, 8); |
| } catch {} |
| try { |
| renderPassEncoder41.setPipeline(pipeline24); |
| } catch {} |
| try { |
| renderPassEncoder14.setVertexBuffer(6, buffer2, 0, 250); |
| } catch {} |
| try { |
| commandEncoder167.resolveQuerySet(querySet3, 51, 79, buffer85, 768); |
| } catch {} |
| try { |
| gpuCanvasContext3.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture130, |
| mipLevel: 0, |
| origin: {x: 22, y: 0, z: 5}, |
| aspect: 'all', |
| }, new Uint8Array(117_013).fill(12), /* required buffer size: 117_013 */ |
| {offset: 55, bytesPerRow: 121, rowsPerImage: 34}, {width: 18, height: 15, depthOrArrayLayers: 29}); |
| } catch {} |
| let promise15 = device0.queue.onSubmittedWorkDone(); |
| let bindGroup94 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout14, |
| entries: [ |
| {binding: 144, resource: textureView5}, |
| {binding: 323, resource: {buffer: buffer5, offset: 768, size: 2104}}, |
| ], |
| }); |
| let buffer117 = device0.createBuffer({ |
| size: 41426, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder168 = device0.createCommandEncoder({}); |
| let texture261 = device0.createTexture({ |
| size: [307, 7, 1], |
| mipLevelCount: 1, |
| sampleCount: 4, |
| format: 'rg16sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let sampler94 = device0.createSampler({addressModeU: 'repeat', addressModeW: 'mirror-repeat', mipmapFilter: 'nearest'}); |
| let externalTexture13 = device0.importExternalTexture({source: videoFrame14}); |
| try { |
| renderPassEncoder46.setBindGroup(2, bindGroup59); |
| } catch {} |
| try { |
| renderPassEncoder15.drawIndexed(234, 0, 117, 484_374_354, 1_147_917_687); |
| } catch {} |
| try { |
| renderPassEncoder33.setVertexBuffer(0, buffer37); |
| } catch {} |
| let buffer118 = device0.createBuffer({size: 6041, usage: GPUBufferUsage.MAP_READ}); |
| let commandBuffer18 = commandEncoder127.finish({label: '\u{1fd24}\u7399'}); |
| let texture262 = device0.createTexture({ |
| size: [307, 7, 1], |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder25.setBindGroup(0, bindGroup71, new Uint32Array(730), 7, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder44); computePassEncoder44.dispatchWorkgroupsIndirect(buffer107, 1_948); }; |
| } catch {} |
| try { |
| computePassEncoder143.end(); |
| } catch {} |
| try { |
| computePassEncoder155.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderPassEncoder15.end(); |
| } catch {} |
| try { |
| renderPassEncoder35.draw(131, 102, 615_966_006, 283_947_747); |
| } catch {} |
| try { |
| renderPassEncoder33.setIndexBuffer(buffer106, 'uint32', 2_420, 6_605); |
| } catch {} |
| let commandEncoder169 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder40.setBindGroup(1, bindGroup0, new Uint32Array(2543), 1_768, 0); |
| } catch {} |
| try { |
| renderPassEncoder35.end(); |
| } catch {} |
| try { |
| renderPassEncoder41.drawIndexed(2, 71, 1, 312_747_587, 358_869_684); |
| } catch {} |
| try { |
| renderPassEncoder41.drawIndirect(buffer13, 1_364); |
| } catch {} |
| try { |
| renderPassEncoder11.setPipeline(pipeline17); |
| } catch {} |
| try { |
| commandEncoder152.resolveQuerySet(querySet5, 18, 8, buffer19, 256); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 80, height: 90, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame0, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture92, |
| mipLevel: 0, |
| origin: {x: 20, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let videoFrame23 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: false, matrix: 'rgb', primaries: 'smpteSt4281', transfer: 'gamma22curve'} }); |
| let commandEncoder170 = device0.createCommandEncoder(); |
| let computePassEncoder156 = commandEncoder58.beginComputePass({}); |
| try { |
| computePassEncoder156.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderPassEncoder46.setBindGroup(0, bindGroup52, new Uint32Array(292), 66, 0); |
| } catch {} |
| try { |
| renderPassEncoder41.drawIndexed(1, 221, 6, 490_443_521, 744_404_980); |
| } catch {} |
| try { |
| renderPassEncoder41.drawIndexedIndirect(buffer86, 20); |
| } catch {} |
| try { |
| renderPassEncoder41.drawIndirect(buffer13, 1_840); |
| } catch {} |
| try { |
| renderPassEncoder38.setIndexBuffer(buffer76, 'uint16', 148, 14); |
| } catch {} |
| let textureView183 = texture67.createView({mipLevelCount: 1}); |
| let computePassEncoder157 = commandEncoder167.beginComputePass({}); |
| let sampler95 = device0.createSampler({addressModeU: 'repeat', addressModeW: 'repeat', compare: 'less'}); |
| try { |
| computePassEncoder157.setPipeline(pipeline30); |
| } catch {} |
| try { |
| renderPassEncoder42.setBindGroup(2, bindGroup24, []); |
| } catch {} |
| try { |
| renderPassEncoder41.setPipeline(pipeline2); |
| } catch {} |
| try { |
| commandEncoder169.insertDebugMarker('\u06b0'); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer18]); |
| } catch {} |
| let imageData22 = new ImageData(24, 88); |
| let commandEncoder171 = device0.createCommandEncoder(); |
| let computePassEncoder158 = commandEncoder169.beginComputePass({}); |
| try { |
| computePassEncoder43.setBindGroup(1, bindGroup62, []); |
| } catch {} |
| try { |
| computePassEncoder44.end(); |
| } catch {} |
| try { |
| computePassEncoder158.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderPassEncoder33.setBindGroup(0, bindGroup45, new Uint32Array(798), 35, 0); |
| } catch {} |
| try { |
| renderPassEncoder45.setViewport(36.48888629986804, 41.6548890879704, 0.2162198737084153, 1.7790948216884146, 0.6768141617886493, 0.6970039296920072); |
| } catch {} |
| try { |
| commandEncoder168.copyTextureToTexture({ |
| texture: texture109, |
| mipLevel: 0, |
| origin: {x: 3, y: 0, z: 4}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture238, |
| mipLevel: 0, |
| origin: {x: 1, y: 1, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 1, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder170.resolveQuerySet(querySet15, 40, 3, buffer1, 1280); |
| } catch {} |
| let commandEncoder172 = device0.createCommandEncoder({}); |
| let computePassEncoder159 = commandEncoder170.beginComputePass({}); |
| let renderPassEncoder48 = commandEncoder172.beginRenderPass({ |
| label: '\ud8fa\u0734\u096a\u02b9\u0cd8\u35da\u0207\u{1fd1f}\u5697\u0e3a', |
| colorAttachments: [{ |
| view: textureView101, |
| clearValue: { r: -857.0, g: 703.9, b: 468.3, a: -847.1, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet20, |
| }); |
| try { |
| computePassEncoder141.setBindGroup(1, bindGroup48); |
| } catch {} |
| try { |
| computePassEncoder84.setBindGroup(0, bindGroup70, new Uint32Array(1820), 8, 0); |
| } catch {} |
| try { |
| computePassEncoder135.end(); |
| } catch {} |
| try { |
| renderPassEncoder13.setBindGroup(2, bindGroup91); |
| } catch {} |
| try { |
| renderPassEncoder20.setBindGroup(2, bindGroup73, new Uint32Array(3860), 42, 0); |
| } catch {} |
| try { |
| renderPassEncoder37.setPipeline(pipeline22); |
| } catch {} |
| try { |
| gpuCanvasContext3.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| let buffer119 = device0.createBuffer({ |
| size: 2489, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| let commandEncoder173 = device0.createCommandEncoder(); |
| let commandBuffer19 = commandEncoder152.finish(); |
| let renderBundleEncoder17 = device0.createRenderBundleEncoder({colorFormats: ['rg8unorm'], depthReadOnly: false, stencilReadOnly: true}); |
| let renderBundle17 = renderBundleEncoder17.finish({}); |
| let externalTexture14 = device0.importExternalTexture({source: videoFrame17}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder137); computePassEncoder137.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder0.setPipeline(pipeline35); |
| } catch {} |
| try { |
| computePassEncoder159.setPipeline(pipeline36); |
| } catch {} |
| try { |
| renderPassEncoder20.setBindGroup(3, bindGroup74); |
| } catch {} |
| try { |
| await promise15; |
| } catch {} |
| let buffer120 = device0.createBuffer({ |
| size: 8117, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let texture263 = device0.createTexture({ |
| size: [1880], |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'r8sint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder160 = commandEncoder173.beginComputePass(); |
| try { |
| computePassEncoder110.setBindGroup(3, bindGroup42, new Uint32Array(2465), 425, 0); |
| } catch {} |
| try { |
| computePassEncoder160.setPipeline(pipeline36); |
| } catch {} |
| try { |
| renderPassEncoder13.setPipeline(pipeline31); |
| } catch {} |
| let commandBuffer20 = commandEncoder21.finish(); |
| let sampler96 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'mirror-repeat', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| compare: 'not-equal', |
| }); |
| try { |
| computePassEncoder49.setBindGroup(2, bindGroup21); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder29); computePassEncoder29.dispatchWorkgroups(3); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder133); computePassEncoder133.dispatchWorkgroupsIndirect(buffer120, 2_028); }; |
| } catch {} |
| try { |
| renderPassEncoder21.executeBundles([renderBundle4]); |
| } catch {} |
| try { |
| renderPassEncoder46.setVertexBuffer(4, buffer13, 0, 348); |
| } catch {} |
| let autogeneratedBindGroupLayout6 = pipeline4.getBindGroupLayout(0); |
| let sampler97 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| lodMaxClamp: 96.67, |
| }); |
| try { |
| computePassEncoder146.setBindGroup(0, bindGroup8, new Uint32Array(208), 11, 0); |
| } catch {} |
| try { |
| renderPassEncoder44.setBindGroup(0, bindGroup21, new Uint32Array(520), 11, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 123, height: 1, depthOrArrayLayers: 153} |
| */ |
| { |
| source: imageData16, |
| origin: { x: 5, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture6, |
| mipLevel: 1, |
| origin: {x: 62, y: 0, z: 14}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 7, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer121 = device0.createBuffer({ |
| size: 8186, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, |
| }); |
| try { |
| renderPassEncoder41.end(); |
| } catch {} |
| try { |
| renderPassEncoder48.beginOcclusionQuery(11); |
| } catch {} |
| try { |
| renderPassEncoder48.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder33.setIndexBuffer(buffer82, 'uint32', 12, 90); |
| } catch {} |
| try { |
| renderPassEncoder36.setVertexBuffer(2, buffer111, 0, 697); |
| } catch {} |
| let commandEncoder174 = device0.createCommandEncoder({}); |
| let commandBuffer21 = commandEncoder134.finish(); |
| let sampler98 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 96.67, |
| }); |
| try { |
| computePassEncoder156.setBindGroup(3, bindGroup5); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let commandEncoder175 = device0.createCommandEncoder({}); |
| let texture264 = device0.createTexture({size: [1968, 1, 36], mipLevelCount: 3, format: 'rgb10a2unorm', usage: GPUTextureUsage.COPY_SRC}); |
| let computePassEncoder161 = commandEncoder168.beginComputePass({}); |
| try { |
| computePassEncoder161.setPipeline(pipeline33); |
| } catch {} |
| try { |
| renderPassEncoder47.executeBundles([renderBundle2, renderBundle3, renderBundle2]); |
| } catch {} |
| try { |
| renderPassEncoder27.setIndexBuffer(buffer104, 'uint16', 9_988, 1_648); |
| } catch {} |
| try { |
| commandEncoder175.copyBufferToBuffer(buffer65, 3872, buffer47, 3020, 1336); |
| } catch {} |
| try { |
| commandEncoder146.copyBufferToTexture({ |
| /* bytesInLastRow: 512 widthInBlocks: 64 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 1504 */ |
| offset: 1504, |
| bytesPerRow: 57856, |
| buffer: buffer64, |
| }, { |
| texture: texture137, |
| mipLevel: 0, |
| origin: {x: 31, y: 2, z: 0}, |
| aspect: 'all', |
| }, {width: 64, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer48, 176, new BigUint64Array(5036), 0, 4); |
| } catch {} |
| let promise16 = device0.queue.onSubmittedWorkDone(); |
| let pipeline39 = await device0.createComputePipelineAsync({layout: pipelineLayout3, compute: {module: shaderModule7}}); |
| let pipeline40 = await device0.createRenderPipelineAsync({ |
| layout: pipelineLayout0, |
| fragment: { |
| module: shaderModule0, |
| constants: {}, |
| targets: [{ |
| format: 'rg8unorm', |
| blend: { |
| color: {operation: 'reverse-subtract', srcFactor: 'one-minus-dst-alpha', dstFactor: 'one-minus-constant'}, |
| alpha: {operation: 'add', srcFactor: 'src-alpha-saturated', dstFactor: 'one-minus-dst-alpha'}, |
| }, |
| }], |
| }, |
| vertex: {module: shaderModule3, constants: {}, buffers: []}, |
| primitive: {frontFace: 'cw', cullMode: 'back'}, |
| }); |
| try { |
| await promise16; |
| } catch {} |
| let buffer122 = device0.createBuffer({ |
| size: 6606, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| try { |
| renderPassEncoder11.setBindGroup(0, bindGroup94); |
| } catch {} |
| try { |
| renderPassEncoder44.setPipeline(pipeline21); |
| } catch {} |
| try { |
| commandEncoder54.copyBufferToTexture({ |
| /* bytesInLastRow: 1936 widthInBlocks: 242 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 120 */ |
| offset: 120, |
| bytesPerRow: 8960, |
| buffer: buffer10, |
| }, { |
| texture: texture169, |
| mipLevel: 0, |
| origin: {x: 156, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 242, height: 30, depthOrArrayLayers: 0}); |
| } catch {} |
| let promise17 = device0.queue.onSubmittedWorkDone(); |
| let commandBuffer22 = commandEncoder54.finish(); |
| let computePassEncoder162 = commandEncoder175.beginComputePass({}); |
| try { |
| computePassEncoder133.setBindGroup(1, bindGroup13); |
| } catch {} |
| try { |
| computePassEncoder162.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder24.setIndexBuffer(buffer89, 'uint32', 160, 261); |
| } catch {} |
| try { |
| buffer119.unmap(); |
| } catch {} |
| try { |
| commandEncoder171.copyBufferToTexture({ |
| /* bytesInLastRow: 40 widthInBlocks: 20 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 1222 */ |
| offset: 1222, |
| rowsPerImage: 798, |
| buffer: buffer110, |
| }, { |
| texture: texture167, |
| mipLevel: 0, |
| origin: {x: 33, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 20, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder174.copyTextureToBuffer({ |
| texture: texture206, |
| mipLevel: 0, |
| origin: {x: 4, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 352 widthInBlocks: 22 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 1920 */ |
| offset: 1920, |
| rowsPerImage: 2439, |
| buffer: buffer57, |
| }, {width: 22, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| computePassEncoder153.pushDebugGroup('\u0af2'); |
| } catch {} |
| try { |
| computePassEncoder153.popDebugGroup(); |
| } catch {} |
| let textureView184 = texture170.createView({mipLevelCount: 1}); |
| let computePassEncoder163 = commandEncoder171.beginComputePass({label: '\u{1f61e}\u7a96\u061f'}); |
| let sampler99 = device0.createSampler({addressModeU: 'repeat', lodMaxClamp: 86.09}); |
| try { |
| computePassEncoder60.setBindGroup(0, bindGroup70); |
| } catch {} |
| try { |
| computePassEncoder46.end(); |
| } catch {} |
| try { |
| renderPassEncoder38.setScissorRect(5, 15, 0, 1); |
| } catch {} |
| try { |
| renderPassEncoder25.setViewport(172.21992884766976, 0.11217052949601214, 10.519353456686556, 0.5011116839807332, 0.45070729494272765, 0.8987900066380355); |
| } catch {} |
| try { |
| renderPassEncoder19.setVertexBuffer(3, buffer22, 0, 664); |
| } catch {} |
| try { |
| commandEncoder146.resolveQuerySet(querySet3, 84, 95, buffer96, 0); |
| } catch {} |
| try { |
| gpuCanvasContext2.unconfigure(); |
| } catch {} |
| try { |
| await promise17; |
| } catch {} |
| await gc(); |
| let recycledExplicitBindGroupLayout15 = pipeline30.getBindGroupLayout(0); |
| let commandEncoder176 = device0.createCommandEncoder({}); |
| let commandBuffer23 = commandEncoder146.finish(); |
| let texture265 = device0.createTexture({ |
| size: {width: 470, height: 2, depthOrArrayLayers: 54}, |
| dimension: '3d', |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView185 = texture91.createView({}); |
| let computePassEncoder164 = commandEncoder176.beginComputePass({}); |
| let renderPassEncoder49 = commandEncoder174.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView120, |
| depthSlice: 33, |
| clearValue: { r: -726.1, g: -707.6, b: -24.14, a: 434.8, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| maxDrawCount: 24799625, |
| }); |
| try { |
| computePassEncoder163.setBindGroup(2, bindGroup5, new Uint32Array(5538), 403, 0); |
| } catch {} |
| try { |
| computePassEncoder163.setPipeline(pipeline19); |
| } catch {} |
| try { |
| renderPassEncoder31.setBindGroup(0, bindGroup16, new Uint32Array(1566), 396, 0); |
| } catch {} |
| try { |
| renderPassEncoder25.end(); |
| } catch {} |
| try { |
| renderPassEncoder43.setViewport(894.9703241128443, 26.812269528463304, 12.1390674944498, 1.873168012508372, 0.8689580690217936, 0.872970916350216); |
| } catch {} |
| try { |
| commandEncoder57.copyBufferToTexture({ |
| /* bytesInLastRow: 32 widthInBlocks: 8 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1504 */ |
| offset: 1504, |
| buffer: buffer81, |
| }, { |
| texture: texture205, |
| mipLevel: 0, |
| origin: {x: 21, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 8, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer20, commandBuffer23, commandBuffer19]); |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let textureView186 = texture91.createView({}); |
| let computePassEncoder165 = commandEncoder57.beginComputePass({}); |
| try { |
| computePassEncoder149.setBindGroup(0, bindGroup4); |
| } catch {} |
| try { |
| computePassEncoder155.setBindGroup(0, bindGroup17, new Uint32Array(1454), 33, 0); |
| } catch {} |
| try { |
| computePassEncoder139.end(); |
| } catch {} |
| try { |
| computePassEncoder164.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderPassEncoder29.setBindGroup(3, bindGroup22); |
| } catch {} |
| try { |
| renderPassEncoder48.setBindGroup(2, bindGroup71, new Uint32Array(822), 36, 0); |
| } catch {} |
| try { |
| commandEncoder75.copyBufferToTexture({ |
| /* bytesInLastRow: 8 widthInBlocks: 4 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 8 */ |
| offset: 8, |
| bytesPerRow: 19200, |
| buffer: buffer35, |
| }, { |
| texture: texture159, |
| mipLevel: 0, |
| origin: {x: 0, y: 2, z: 0}, |
| aspect: 'all', |
| }, {width: 4, height: 3, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder148.copyTextureToTexture({ |
| texture: texture23, |
| mipLevel: 0, |
| origin: {x: 5, y: 0, z: 25}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture74, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 11, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(canvas1); |
| let texture266 = device0.createTexture({ |
| size: [1230], |
| dimension: '1d', |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView187 = texture194.createView({format: 'rg8sint', baseArrayLayer: 2, arrayLayerCount: 24}); |
| let computePassEncoder166 = commandEncoder75.beginComputePass({}); |
| let sampler100 = device0.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'repeat', magFilter: 'linear', lodMaxClamp: 98.92}); |
| try { |
| computePassEncoder57.setBindGroup(1, bindGroup93); |
| } catch {} |
| try { |
| computePassEncoder133.setBindGroup(0, bindGroup12, new Uint32Array(2312), 180, 0); |
| } catch {} |
| try { |
| renderPassEncoder20.setIndexBuffer(buffer76, 'uint32', 8, 0); |
| } catch {} |
| try { |
| commandEncoder148.copyBufferToBuffer(buffer77, 2836, buffer13, 220, 536); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 80, height: 90, depthOrArrayLayers: 69} |
| */ |
| { |
| source: imageBitmap1, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture236, |
| mipLevel: 0, |
| origin: {x: 51, y: 3, z: 3}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup95 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout2, |
| entries: [{binding: 39, resource: {buffer: buffer10, offset: 1280}}, {binding: 41, resource: textureView53}], |
| }); |
| let texture267 = device0.createTexture({ |
| size: {width: 307}, |
| dimension: '1d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView188 = texture88.createView({dimension: '2d-array', baseArrayLayer: 2, arrayLayerCount: 1}); |
| try { |
| computePassEncoder58.setBindGroup(0, bindGroup69, new Uint32Array(271), 14, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder161); computePassEncoder161.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder43.setBindGroup(3, bindGroup13, new Uint32Array(1140), 25, 0); |
| } catch {} |
| try { |
| renderPassEncoder39.setIndexBuffer(buffer76, 'uint32', 56, 159); |
| } catch {} |
| try { |
| commandEncoder148.resolveQuerySet(querySet16, 21, 186, buffer85, 256); |
| } catch {} |
| try { |
| if (!arrayBuffer16.detached) { new Uint8Array(arrayBuffer16).fill(0x55); }; |
| } catch {} |
| let commandEncoder177 = device0.createCommandEncoder({label: '\ud8c0\u41dc\u{1fd33}\u9d15\u343c\u767b\u4111'}); |
| let textureView189 = texture229.createView({}); |
| let externalTexture15 = device0.importExternalTexture({source: videoFrame0}); |
| try { |
| computePassEncoder165.setPipeline(pipeline19); |
| } catch {} |
| try { |
| renderPassEncoder40.setIndexBuffer(buffer90, 'uint16', 442, 216); |
| } catch {} |
| try { |
| renderPassEncoder45.setPipeline(pipeline10); |
| } catch {} |
| try { |
| commandEncoder148.clearBuffer(buffer23); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 40, height: 45, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame4, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture84, |
| mipLevel: 0, |
| origin: {x: 2, y: 21, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture268 = device0.createTexture({ |
| size: [1230, 30, 11], |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderPassEncoder50 = commandEncoder148.beginRenderPass({colorAttachments: [{view: textureView101, loadOp: 'clear', storeOp: 'discard'}]}); |
| let sampler101 = device0.createSampler({addressModeV: 'mirror-repeat', minFilter: 'linear', mipmapFilter: 'linear', lodMaxClamp: 93.00}); |
| try { |
| computePassEncoder0.setBindGroup(0, bindGroup70); |
| } catch {} |
| try { |
| renderPassEncoder29.setBindGroup(3, bindGroup49, [768]); |
| } catch {} |
| try { |
| if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(0x55); }; |
| } catch {} |
| let buffer123 = device0.createBuffer({size: 599, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX}); |
| let commandEncoder178 = device0.createCommandEncoder({}); |
| let texture269 = gpuCanvasContext1.getCurrentTexture(); |
| try { |
| { clearResourceUsages(device0, computePassEncoder161); computePassEncoder161.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| computePassEncoder137.end(); |
| } catch {} |
| try { |
| renderPassEncoder39.setBindGroup(0, bindGroup36); |
| } catch {} |
| try { |
| renderPassEncoder16.setPipeline(pipeline22); |
| } catch {} |
| try { |
| renderPassEncoder37.setVertexBuffer(0, buffer111, 3_104, 356); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer87, 20, new BigUint64Array(6710), 2705, 12); |
| } catch {} |
| try { |
| await promise14; |
| } catch {} |
| let commandEncoder179 = device0.createCommandEncoder({}); |
| let textureView190 = texture141.createView({arrayLayerCount: 1}); |
| let computePassEncoder167 = commandEncoder178.beginComputePass(); |
| let renderBundleEncoder18 = device0.createRenderBundleEncoder({ |
| colorFormats: ['rg32uint'], |
| depthStencilFormat: 'depth24plus-stencil8', |
| depthReadOnly: true, |
| stencilReadOnly: true, |
| }); |
| try { |
| computePassEncoder108.setBindGroup(2, bindGroup38); |
| } catch {} |
| try { |
| computePassEncoder167.setPipeline(pipeline13); |
| } catch {} |
| try { |
| renderPassEncoder16.drawIndexedIndirect(buffer97, 2_812); |
| } catch {} |
| try { |
| renderPassEncoder16.drawIndirect(buffer107, 5_516); |
| } catch {} |
| try { |
| renderPassEncoder16.setIndexBuffer(buffer67, 'uint32', 424, 9); |
| } catch {} |
| try { |
| renderPassEncoder36.setPipeline(pipeline24); |
| } catch {} |
| let pipeline41 = await device0.createComputePipelineAsync({layout: pipelineLayout2, compute: {module: shaderModule2, constants: {}}}); |
| let commandEncoder180 = device0.createCommandEncoder({}); |
| let renderPassEncoder51 = commandEncoder180.beginRenderPass({ |
| colorAttachments: [{view: textureView55, loadOp: 'load', storeOp: 'store'}], |
| occlusionQuerySet: querySet15, |
| }); |
| let renderBundle18 = renderBundleEncoder18.finish({}); |
| try { |
| computePassEncoder167.setBindGroup(0, bindGroup12); |
| } catch {} |
| try { |
| computePassEncoder166.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder21.setVertexBuffer(4, buffer38, 0, 71); |
| } catch {} |
| try { |
| computePassEncoder57.pushDebugGroup('\ueecb'); |
| } catch {} |
| let buffer124 = device0.createBuffer({ |
| size: 5210, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE, |
| }); |
| let texture270 = device0.createTexture({ |
| size: {width: 10, height: 11, depthOrArrayLayers: 8}, |
| dimension: '3d', |
| format: 'rg8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder150); computePassEncoder150.dispatchWorkgroupsIndirect(buffer32, 1_424); }; |
| } catch {} |
| try { |
| renderPassEncoder16.drawIndexed(0, 71, 0, 228_886_063, 478_628_956); |
| } catch {} |
| try { |
| renderPassEncoder16.drawIndirect(buffer47, 3_204); |
| } catch {} |
| try { |
| renderPassEncoder38.setPipeline(pipeline31); |
| } catch {} |
| try { |
| renderPassEncoder17.setVertexBuffer(3, buffer111, 0, 7_434); |
| } catch {} |
| try { |
| commandEncoder41.copyTextureToTexture({ |
| texture: texture39, |
| mipLevel: 0, |
| origin: {x: 23, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture128, |
| mipLevel: 1, |
| origin: {x: 1, y: 2, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 11, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let promise18 = device0.queue.onSubmittedWorkDone(); |
| try { |
| adapter1.label = '\u0bdd\u95f6\u0413\u2288\u82e5\u1f71\uf91f\uca2d\u{1fcf2}\u06e5'; |
| } catch {} |
| let commandEncoder181 = device0.createCommandEncoder({}); |
| let commandBuffer24 = commandEncoder41.finish(); |
| let textureView191 = texture166.createView({dimension: '2d', baseArrayLayer: 8}); |
| let renderPassEncoder52 = commandEncoder177.beginRenderPass({ |
| colorAttachments: [{view: textureView118, loadOp: 'clear', storeOp: 'discard'}], |
| occlusionQuerySet: querySet9, |
| }); |
| let sampler102 = device0.createSampler({addressModeV: 'mirror-repeat', mipmapFilter: 'nearest', compare: 'less'}); |
| try { |
| computePassEncoder29.setBindGroup(0, bindGroup1); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder119); computePassEncoder119.dispatchWorkgroupsIndirect(buffer13, 1_068); }; |
| } catch {} |
| try { |
| renderPassEncoder47.setBindGroup(1, bindGroup79); |
| } catch {} |
| try { |
| renderPassEncoder16.drawIndexed(0, 246, 0, -2_015_055_619, 1_037_585_307); |
| } catch {} |
| try { |
| renderPassEncoder21.setIndexBuffer(buffer0, 'uint16', 22, 135); |
| } catch {} |
| try { |
| renderPassEncoder21.setVertexBuffer(5, buffer111, 0); |
| } catch {} |
| try { |
| commandEncoder181.copyBufferToBuffer(buffer32, 3572, buffer19, 2116, 172); |
| } catch {} |
| try { |
| computePassEncoder57.popDebugGroup(); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer21, commandBuffer22, commandBuffer24]); |
| } catch {} |
| let buffer125 = device0.createBuffer({size: 25131, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM}); |
| let commandBuffer25 = commandEncoder181.finish({}); |
| let renderPassEncoder53 = commandEncoder179.beginRenderPass({ |
| label: '\u5d60\u{1f84a}\u0f01\u0766\u0fd9\u{1ff78}\ud0ee\u{1fc8d}\u0db0\ub464\u{1fb3d}', |
| colorAttachments: [{ |
| view: textureView134, |
| depthSlice: 37, |
| clearValue: { r: 499.1, g: -16.00, b: 657.1, a: 890.2, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| renderPassEncoder47.setBindGroup(2, bindGroup12, new Uint32Array(2680), 235, 0); |
| } catch {} |
| try { |
| renderPassEncoder16.drawIndirect(buffer7, 220); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer25]); |
| } catch {} |
| let imageData23 = new ImageData(72, 68); |
| try { |
| renderPassEncoder16.drawIndexedIndirect(buffer102, 52); |
| } catch {} |
| try { |
| renderPassEncoder16.drawIndirect(buffer102, 9_164); |
| } catch {} |
| document.body.append(img3); |
| let texture271 = device0.createTexture({ |
| size: [940, 5, 48], |
| dimension: '3d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView192 = texture260.createView({aspect: 'all'}); |
| let sampler103 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 70.92, |
| maxAnisotropy: 18, |
| }); |
| try { |
| computePassEncoder142.setBindGroup(0, bindGroup75, new Uint32Array(1924), 209, 0); |
| } catch {} |
| try { |
| renderPassEncoder27.setBindGroup(2, bindGroup54, new Uint32Array(800), 30, 0); |
| } catch {} |
| try { |
| renderPassEncoder44.executeBundles([renderBundle17]); |
| } catch {} |
| try { |
| renderPassEncoder16.draw(195, 131, 281_136_427, 1_233_727_526); |
| } catch {} |
| try { |
| renderPassEncoder16.drawIndexed(1, 112, 0, -1_465_743_786, 167_009_391); |
| } catch {} |
| try { |
| renderPassEncoder16.drawIndirect(buffer48, 1_068); |
| } catch {} |
| try { |
| renderPassEncoder48.setIndexBuffer(buffer120, 'uint16', 3_078, 100); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let veryExplicitBindGroupLayout23 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 39, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| { |
| binding: 41, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: true }, |
| }, |
| ], |
| }); |
| let buffer126 = device0.createBuffer({ |
| size: 24580, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| mappedAtCreation: false, |
| }); |
| let texture272 = gpuCanvasContext1.getCurrentTexture(); |
| try { |
| computePassEncoder49.setBindGroup(1, bindGroup53); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder29); computePassEncoder29.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| renderPassEncoder51.setBlendConstant({ r: 221.7, g: -217.2, b: 817.6, a: -356.9, }); |
| } catch {} |
| try { |
| renderPassEncoder50.setViewport(22.03745440019402, 31.168295800139862, 16.579327668218703, 6.738772073303138, 0.04581180130140883, 0.27051242089635197); |
| } catch {} |
| try { |
| renderPassEncoder16.drawIndexed(0, 96, 0, 44_905_835, 888_872_692); |
| } catch {} |
| try { |
| renderPassEncoder16.drawIndirect(buffer83, 4_724); |
| } catch {} |
| try { |
| renderPassEncoder24.setIndexBuffer(buffer1, 'uint16', 6_684, 1_158); |
| } catch {} |
| try { |
| renderPassEncoder52.setPipeline(pipeline12); |
| } catch {} |
| let recycledExplicitBindGroupLayout16 = pipeline32.getBindGroupLayout(0); |
| let buffer127 = device0.createBuffer({size: 1137, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let texture273 = device0.createTexture({size: [153, 3, 80], dimension: '3d', format: 'rg16sint', usage: GPUTextureUsage.RENDER_ATTACHMENT}); |
| let renderBundleEncoder19 = device0.createRenderBundleEncoder({colorFormats: ['r8uint', 'r8sint'], stencilReadOnly: true}); |
| try { |
| computePassEncoder163.setBindGroup(0, bindGroup46); |
| } catch {} |
| try { |
| computePassEncoder62.setPipeline(pipeline37); |
| } catch {} |
| try { |
| renderPassEncoder42.setBindGroup(1, bindGroup44, new Uint32Array(747), 22, 0); |
| } catch {} |
| try { |
| renderPassEncoder16.drawIndexed(0, 178, 0, 197_921_443, 1_725_499_300); |
| } catch {} |
| try { |
| renderPassEncoder16.setIndexBuffer(buffer18, 'uint32', 84, 273); |
| } catch {} |
| try { |
| renderPassEncoder38.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderBundleEncoder19.setPipeline(pipeline34); |
| } catch {} |
| try { |
| device0.pushErrorScope('out-of-memory'); |
| } catch {} |
| let arrayBuffer26 = buffer26.getMappedRange(248, 8); |
| try { |
| computePassEncoder88.pushDebugGroup('\ua576'); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 470, height: 2, depthOrArrayLayers: 54} |
| */ |
| { |
| source: img3, |
| origin: { x: 0, y: 26 }, |
| flipY: false, |
| }, { |
| texture: texture265, |
| mipLevel: 0, |
| origin: {x: 27, y: 0, z: 19}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 21, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await promise18; |
| } catch {} |
| let shaderModule10 = device0.createShaderModule({ |
| code: ` |
| requires readonly_and_readwrite_storage_textures; |
| |
| enable f16; |
| |
| diagnostic(info, xyz); |
| |
| override override7: u32 = 399; |
| |
| override override8: u32; |
| |
| @id(8813) override override12: f32; |
| |
| override override14: f32; |
| |
| /* zero global variables used */ |
| fn fn0(a0: ptr<uniform, VertexOutput9>) { |
| var vf243: bool = override13; |
| vf243 = bool(abs(vec3u(unconst_u32(199), unconst_u32(109), unconst_u32(655))).g); |
| let vf244: vec2h = atanh(vec2h(unconst_f16(-18151.8), unconst_f16(1169.3))); |
| let vf245: f16 = override5; |
| _ = override5; |
| _ = override13; |
| } |
| |
| @id(24264) override override15: i32; |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| override override5: f16 = -28567.5; |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| struct T0 { |
| f0: f32, |
| } |
| |
| struct VertexOutput9 { |
| @location(14) @interpolate(flat, sample) f17: u32, |
| @location(2) @interpolate(perspective, center) f18: f16, |
| @location(15) @interpolate(perspective, sample) f19: f32, |
| @builtin(position) f20: vec4f, |
| } |
| |
| override override4: u32; |
| |
| override override9: bool; |
| |
| /* zero global variables used */ |
| fn fn1() -> T0 { |
| var out: T0; |
| var vf246: vec2i = ~vec2i(unconst_i32(270), unconst_i32(-4)); |
| switch bitcast<i32>(sin(vec2h(unconst_f16(3701.8), unconst_f16(38993.2)))) { |
| default { |
| out.f0 = bitcast<f32>(pack4xU8(firstLeadingBit(vec4u(transpose(mat3x2f())[unconst_i32(0)].zzyz)))); |
| let vf247: vec3f = sqrt(vec3f(unconst_f32(0.6527), unconst_f32(-0.00765), unconst_f32(0.8034))); |
| { |
| loop { |
| out.f0 = f32(pack4x8snorm(vec4f(unconst_f32(0.3167), unconst_f32(-0.04137), unconst_f32(0.02590), unconst_f32(0.2245)))); |
| break; |
| } |
| var vf248: vec3i = (vec3i(unconst_i32(97), unconst_i32(3), unconst_i32(29)) | vec3i(unconst_i32(40), unconst_i32(45), unconst_i32(7))); |
| var vf249: f32 = exp2(unconst_f32(0.06810)); |
| } |
| let vf250: bool = all(unconst_bool(false)); |
| out = T0(unpack2x16unorm(unconst_u32(158)).y); |
| break; |
| } |
| } |
| { |
| { |
| if bool(sin(vec4f(unconst_f32(0.1375), unconst_f32(0.06164), unconst_f32(0.03808), unconst_f32(0.01311))).b) { |
| var vf251: i32 = override15; |
| _ = override15; |
| } |
| let vf252: vec3h = sin(vec3h(unconst_f16(-15435.8), unconst_f16(4132.6), unconst_f16(6976.2))); |
| let vf253: vec3h = sin(vec3h(unconst_f16(6214.3), unconst_f16(5212.4), unconst_f16(603.1))); |
| let vf254: vec3h = faceForward(vec3h(unconst_f16(8310.3), unconst_f16(10520.9), unconst_f16(7525.9)), vec3h(unconst_f16(1550.0), unconst_f16(24118.6), unconst_f16(10747.9)), vec3h(unconst_f16(4525.3), unconst_f16(7523.3), unconst_f16(1625.7))); |
| _ = override15; |
| } |
| out.f0 = trunc(unconst_f32(0.00712)); |
| out = T0(cross(vec3f(cross(vec3h(unconst_f16(20078.5), unconst_f16(4497.9), unconst_f16(2780.5)), vec3h(unconst_f16(19735.3), unconst_f16(3523.5), unconst_f16(10158.9)))), vec3f(unconst_f32(0.06705), unconst_f32(0.00382), unconst_f32(0.08519)))[2]); |
| out = T0(f32(override13)); |
| _ = override15; |
| _ = override13; |
| } |
| loop { |
| out.f0 += f32((unconst_f32(0.02281) >= bitcast<f32>(override8))); |
| let vf255: f32 = override14; |
| out.f0 = override12; |
| break; |
| _ = override8; |
| _ = override12; |
| _ = override14; |
| } |
| let vf256: u32 = override10; |
| return out; |
| _ = override10; |
| _ = override15; |
| _ = override8; |
| _ = override14; |
| _ = override12; |
| _ = override13; |
| } |
| |
| override override11: f16; |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| @group(0) @binding(125) var st10: texture_storage_2d_array<r32float, read_write>; |
| |
| @id(26056) override override10: u32; |
| |
| override override6: i32 = 112; |
| |
| override override13 = true; |
| |
| /* zero global variables used */ |
| @vertex |
| fn vertex10(@location(14) a0: vec2h) -> VertexOutput9 { |
| var out: VertexOutput9; |
| out.f20 = exp(vec3f(unconst_f32(0.1847), unconst_f32(0.2205), unconst_f32(0.08515))).xzzx; |
| let vf257: i32 = override15; |
| var vf258: mat4x2h = transpose(mat2x4h(unconst_f16(11297.9), unconst_f16(-13781.2), unconst_f16(-25341.4), unconst_f16(-20941.0), unconst_f16(12830.2), unconst_f16(26015.1), unconst_f16(-5024.3), unconst_f16(2690.5))); |
| var vf259: u32 = pack4xI8Clamp(vec4i(unconst_i32(283), unconst_i32(21), unconst_i32(212), unconst_i32(61))); |
| { |
| var vf260: bool = (unconst_bool(false) || unconst_bool(true)); |
| } |
| let ptr74: ptr<function, mat4x2h> = &vf258; |
| var vf261 = fn1(); |
| while bool(override6) { |
| out.f17 |= u32(saturate(unconst_f32(0.2327))); |
| for (var it10=bitcast<u32>(radians(vec2h(unconst_f16(5422.3), unconst_f16(891.3)))); it10<bitcast<u32>(override6); it10++) { |
| let vf262: u32 = pack4xU8(vec4u(unconst_u32(187), unconst_u32(162), unconst_u32(50), unconst_u32(1))); |
| var vf263: vec3<bool> = (vec3h(unconst_f16(1024.9), unconst_f16(4418.8), unconst_f16(8857.5)) >= vec3h(unconst_f16(530.0), unconst_f16(7382.5), unconst_f16(14663.1))); |
| out.f20 = vec4f( ~vec4i(unconst_i32(205), unconst_i32(563), unconst_i32(303), unconst_i32(67))); |
| break; |
| } |
| var vf264 = fn1(); |
| out.f17 = vec3u(acos(vec3h(unconst_f16(16722.0), unconst_f16(17708.4), unconst_f16(7164.3))))[0]; |
| fn1(); |
| out.f18 += f16(unpack2x16snorm(unconst_u32(231))[1]); |
| out.f17 ^= insertBits(vec2u(unconst_u32(82), unconst_u32(19)), vec2u(u32( !bool(override6))), unconst_u32(8), unconst_u32(120))[1]; |
| break; |
| _ = override6; |
| _ = override14; |
| _ = override12; |
| _ = override8; |
| _ = override13; |
| _ = override15; |
| _ = override10; |
| } |
| let vf265: u32 = pack4x8unorm(vec4f(unconst_f32(0.04122), unconst_f32(0.1252), unconst_f32(0.02908), unconst_f32(0.1504))); |
| vf258 = mat4x2h(vf258[unconst_u32(47)][unconst_u32(193)], vf258[unconst_u32(47)][unconst_u32(193)], vf258[unconst_u32(47)][unconst_u32(193)], vf258[unconst_u32(47)][unconst_u32(193)], vf258[unconst_u32(47)][unconst_u32(193)], vf258[unconst_u32(47)][unconst_u32(193)], vf258[unconst_u32(47)][unconst_u32(193)], vf258[unconst_u32(47)][unconst_u32(193)]); |
| return out; |
| _ = override12; |
| _ = override6; |
| _ = override15; |
| _ = override10; |
| _ = override13; |
| _ = override8; |
| _ = override14; |
| } |
| |
| /* used global variables: st10 */ |
| @compute @workgroup_size(1, 1, 1) |
| fn compute12() { |
| let vf266: f32 = override12; |
| switch i32(atan2(vec4h(faceForward(vec4f(unconst_f32(0.3925), unconst_f32(0.09009), unconst_f32(0.2680), unconst_f32(0.1600)), vec4f(unconst_f32(0.1274), unconst_f32(0.06581), unconst_f32(0.08532), unconst_f32(0.5406)), vec4f(unconst_f32(0.03829), unconst_f32(0.04538), unconst_f32(0.1204), unconst_f32(0.09037))))[3], unconst_f16(-10817.4))) { |
| default { |
| var vf267: f32 = override12; |
| let vf268: vec4i = countOneBits(vec4i(unconst_i32(434), unconst_i32(328), unconst_i32(0), unconst_i32(174))); |
| _ = override12; |
| } |
| } |
| textureStore(st10, vec2i(unconst_i32(-192), unconst_i32(23)), unconst_i32(58), vec4f(vec4f(unconst_f32(-0.07948), unconst_f32(0.2272), unconst_f32(0.04103), unconst_f32(0.5135)))); |
| let vf269: f32 = ldexp(unconst_f32(0.00264), unconst_i32(233)); |
| textureStore(st10, vec2i(unconst_i32(199), unconst_i32(147)), unconst_i32(251), vec4f(vec4f(unconst_f32(0.03272), unconst_f32(0.02084), unconst_f32(0.2167), unconst_f32(0.1312)))); |
| var vf270: f32 = override14; |
| var vf271: vec4f = textureLoad(st10, vec2i(unconst_i32(266), unconst_i32(122)), unconst_i32(58)); |
| var vf272: i32 = override15; |
| textureStore(st10, vec2i(unconst_i32(-553), unconst_i32(57)), unconst_i32(507), vec4f(vec4f(unconst_f32(0.2253), unconst_f32(0.01818), unconst_f32(0.1638), unconst_f32(0.00748)))); |
| let vf273: bool = override13; |
| _ = override13; |
| _ = override12; |
| _ = override14; |
| _ = override15; |
| _ = st10; |
| }`, |
| }); |
| let bindGroup96 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout3, |
| entries: [ |
| {binding: 144, resource: textureView4}, |
| {binding: 323, resource: {buffer: buffer125, offset: 6400, size: 888}}, |
| ], |
| }); |
| let buffer129 = device0.createBuffer({size: 10395, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE}); |
| let texture274 = device0.createTexture({ |
| size: [32, 32, 21], |
| mipLevelCount: 2, |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder16.draw(265, 481, 82_097_211, 57_918_545); |
| } catch {} |
| try { |
| renderPassEncoder40.setIndexBuffer(buffer67, 'uint16', 1_508, 227); |
| } catch {} |
| try { |
| renderPassEncoder44.setVertexBuffer(1, buffer33, 628); |
| } catch {} |
| try { |
| renderBundleEncoder19.setIndexBuffer(buffer56, 'uint32', 1_008, 423); |
| } catch {} |
| try { |
| renderBundleEncoder19.setVertexBuffer(6, buffer14, 0, 2_518); |
| } catch {} |
| try { |
| computePassEncoder128.setBindGroup(0, bindGroup60, new Uint32Array(2154), 271, 0); |
| } catch {} |
| try { |
| renderPassEncoder52.executeBundles([renderBundle8]); |
| } catch {} |
| try { |
| renderPassEncoder16.drawIndexedIndirect(buffer107, 7_012); |
| } catch {} |
| try { |
| renderBundleEncoder19.setBindGroup(2, bindGroup68, []); |
| } catch {} |
| try { |
| renderBundleEncoder19.setBindGroup(0, bindGroup41, new Uint32Array(3430), 322, 0); |
| } catch {} |
| try { |
| renderBundleEncoder19.setPipeline(pipeline29); |
| } catch {} |
| try { |
| renderBundleEncoder19.setVertexBuffer(2, buffer105, 0); |
| } catch {} |
| document.body.prepend(canvas0); |
| let recycledExplicitBindGroupLayout17 = pipeline7.getBindGroupLayout(0); |
| let textureView193 = texture49.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 1}); |
| let renderBundle19 = renderBundleEncoder19.finish({}); |
| try { |
| computePassEncoder47.setBindGroup(2, bindGroup17); |
| } catch {} |
| try { |
| renderPassEncoder16.drawIndexedIndirect(buffer21, 5_172); |
| } catch {} |
| try { |
| renderPassEncoder16.drawIndirect(buffer7, 536); |
| } catch {} |
| let renderBundleEncoder20 = device0.createRenderBundleEncoder({colorFormats: ['rg32uint'], depthStencilFormat: 'depth24plus-stencil8', depthReadOnly: true}); |
| try { |
| renderPassEncoder44.setBindGroup(1, bindGroup17); |
| } catch {} |
| try { |
| renderPassEncoder48.setViewport(14.929800446239895, 28.383638773852304, 1.0789774788189197, 3.2135103688293065, 0.09121940413593232, 0.13150825272852693); |
| } catch {} |
| try { |
| renderPassEncoder16.drawIndirect(buffer85, 212); |
| } catch {} |
| try { |
| renderBundleEncoder20.setIndexBuffer(buffer83, 'uint32', 308, 1_583); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| document.body.append(canvas0); |
| let buffer130 = device0.createBuffer({ |
| size: 1078, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let texture275 = device0.createTexture({size: [984, 1, 3], mipLevelCount: 3, format: 'r8sint', usage: GPUTextureUsage.TEXTURE_BINDING}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder119); computePassEncoder119.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder33.setBindGroup(3, bindGroup68, new Uint32Array(1509), 513, 0); |
| } catch {} |
| try { |
| renderBundleEncoder20.setBindGroup(2, bindGroup42); |
| } catch {} |
| try { |
| renderBundleEncoder20.setIndexBuffer(buffer37, 'uint16', 1_396, 137); |
| } catch {} |
| try { |
| renderBundleEncoder20.setVertexBuffer(0, buffer22, 0, 119); |
| } catch {} |
| try { |
| buffer129.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture32, |
| mipLevel: 0, |
| origin: {x: 100, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(30).fill(15), /* required buffer size: 30 */ |
| {offset: 30}, {width: 115, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| await gc(); |
| let videoFrame24 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX', timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte170m', primaries: 'bt2020', transfer: 'log'} }); |
| let renderBundle20 = renderBundleEncoder20.finish({}); |
| let sampler104 = device0.createSampler({ |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 73.86, |
| maxAnisotropy: 11, |
| }); |
| try { |
| computePassEncoder26.setBindGroup(0, bindGroup94); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder58); computePassEncoder58.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder129); computePassEncoder129.dispatchWorkgroupsIndirect(buffer70, 8); }; |
| } catch {} |
| try { |
| renderPassEncoder29.setBindGroup(1, bindGroup25); |
| } catch {} |
| try { |
| renderPassEncoder14.setBindGroup(1, bindGroup68, new Uint32Array(198), 25, 0); |
| } catch {} |
| try { |
| renderPassEncoder16.end(); |
| } catch {} |
| try { |
| renderPassEncoder50.setVertexBuffer(6, buffer14, 0, 13_022); |
| } catch {} |
| try { |
| commandEncoder23.copyTextureToTexture({ |
| texture: texture78, |
| mipLevel: 0, |
| origin: {x: 24, y: 0, z: 230}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture228, |
| mipLevel: 0, |
| origin: {x: 711, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 55, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let bindGroup97 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout5, |
| entries: [ |
| {binding: 54, resource: sampler79}, |
| {binding: 119, resource: textureView158}, |
| {binding: 77, resource: {buffer: buffer63, offset: 256, size: 396}}, |
| {binding: 155, resource: externalTexture2}, |
| {binding: 33, resource: {buffer: buffer124, offset: 1536, size: 540}}, |
| ], |
| }); |
| let buffer131 = device0.createBuffer({ |
| size: 8641, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX, |
| }); |
| let computePassEncoder168 = commandEncoder23.beginComputePass({}); |
| let sampler105 = device0.createSampler({addressModeV: 'clamp-to-edge', addressModeW: 'mirror-repeat', mipmapFilter: 'nearest'}); |
| try { |
| renderPassEncoder21.setBindGroup(3, bindGroup48); |
| } catch {} |
| try { |
| renderPassEncoder47.setIndexBuffer(buffer124, 'uint32', 1_804, 955); |
| } catch {} |
| try { |
| renderPassEncoder37.setPipeline(pipeline17); |
| } catch {} |
| try { |
| renderPassEncoder48.setVertexBuffer(4, buffer100); |
| } catch {} |
| let bindGroup98 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout4, |
| entries: [ |
| {binding: 323, resource: {buffer: buffer75, offset: 768, size: 1436}}, |
| {binding: 144, resource: textureView2}, |
| ], |
| }); |
| let buffer132 = device0.createBuffer({size: 9715, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let textureView194 = texture161.createView({dimension: '2d-array', mipLevelCount: 1}); |
| let renderBundleEncoder21 = device0.createRenderBundleEncoder({colorFormats: ['rg8unorm']}); |
| let sampler106 = device0.createSampler({ |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMaxClamp: 52.35, |
| }); |
| let externalTexture16 = device0.importExternalTexture({source: videoFrame23}); |
| try { |
| renderPassEncoder38.setBindGroup(1, bindGroup21, new Uint32Array(1348), 128, 0); |
| } catch {} |
| try { |
| renderPassEncoder53.executeBundles([renderBundle13, renderBundle0, renderBundle11, renderBundle6]); |
| } catch {} |
| try { |
| renderPassEncoder27.setIndexBuffer(buffer56, 'uint16', 632, 500); |
| } catch {} |
| try { |
| renderBundleEncoder21.setBindGroup(0, bindGroup39, new Uint32Array(409), 98, 0); |
| } catch {} |
| try { |
| renderBundleEncoder21.setIndexBuffer(buffer38, 'uint16', 172, 63); |
| } catch {} |
| try { |
| renderBundleEncoder21.setPipeline(pipeline4); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer98, 1360, new Float32Array(22), 1, 0); |
| } catch {} |
| let pipeline42 = device0.createRenderPipeline({ |
| layout: pipelineLayout1, |
| fragment: {module: shaderModule2, constants: {override0: 1}, targets: [{format: 'rg8unorm'}]}, |
| vertex: {module: shaderModule4, entryPoint: 'vertex3', constants: {}, buffers: []}, |
| }); |
| try { |
| gpuCanvasContext2.unconfigure(); |
| } catch {} |
| try { |
| await promise13; |
| } catch {} |
| let buffer133 = device0.createBuffer({ |
| label: '\u4895\u0354\u077e\u5521\u3e58\u4b6b\u3f57\ud3a3\u{1fb25}', |
| size: 6972, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let commandEncoder182 = device0.createCommandEncoder({}); |
| let sampler107 = device0.createSampler({addressModeW: 'mirror-repeat', minFilter: 'linear'}); |
| try { |
| computePassEncoder39.end(); |
| } catch {} |
| try { |
| renderPassEncoder40.setIndexBuffer(buffer22, 'uint16', 438, 248); |
| } catch {} |
| try { |
| renderBundleEncoder21.setBindGroup(2, bindGroup25); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 615, height: 15, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData20, |
| origin: { x: 9, y: 2 }, |
| flipY: false, |
| }, { |
| texture: texture116, |
| mipLevel: 0, |
| origin: {x: 171, y: 9, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 3, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder183 = device0.createCommandEncoder({}); |
| let textureView195 = texture80.createView({dimension: '2d-array', format: 'r8sint', mipLevelCount: 1}); |
| try { |
| computePassEncoder168.setPipeline(pipeline25); |
| } catch {} |
| try { |
| renderPassEncoder39.setBindGroup(0, bindGroup61, new Uint32Array(1087), 88, 0); |
| } catch {} |
| try { |
| renderPassEncoder24.setIndexBuffer(buffer103, 'uint16', 2_450, 291); |
| } catch {} |
| try { |
| renderPassEncoder38.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder29.setVertexBuffer(2, buffer117, 0); |
| } catch {} |
| try { |
| renderBundleEncoder21.setBindGroup(2, bindGroup61); |
| } catch {} |
| try { |
| renderBundleEncoder21.setPipeline(pipeline14); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture253, |
| mipLevel: 0, |
| origin: {x: 4, y: 2, z: 8}, |
| aspect: 'all', |
| }, new Uint8Array(12_594).fill(111), /* required buffer size: 12_594 */ |
| {offset: 425, bytesPerRow: 39, rowsPerImage: 24}, {width: 1, height: 1, depthOrArrayLayers: 14}); |
| } catch {} |
| let promise19 = device0.queue.onSubmittedWorkDone(); |
| try { |
| adapter1.label = '\u0e53\ubbeb\u0d4f\u3d2f\u{1f66c}\u{1fe2a}\u8a97\uc423\uaac1\u04a7'; |
| } catch {} |
| let commandEncoder184 = device0.createCommandEncoder({}); |
| let texture276 = device0.createTexture({ |
| size: [1968, 1, 78], |
| mipLevelCount: 5, |
| format: 'depth24plus-stencil8', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let computePassEncoder169 = commandEncoder183.beginComputePass(); |
| try { |
| computePassEncoder169.setPipeline(pipeline32); |
| } catch {} |
| try { |
| renderPassEncoder38.setBindGroup(1, bindGroup86, new Uint32Array(1166), 172, 0); |
| } catch {} |
| try { |
| renderBundleEncoder21.setIndexBuffer(buffer67, 'uint16', 480, 157); |
| } catch {} |
| try { |
| renderBundleEncoder21.setVertexBuffer(0, buffer55, 256); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer98, 12676, new DataView(new ArrayBuffer(2304)), 956, 40); |
| } catch {} |
| let commandEncoder185 = device0.createCommandEncoder(); |
| let texture277 = device0.createTexture({ |
| size: {width: 984, height: 1, depthOrArrayLayers: 441}, |
| mipLevelCount: 4, |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder170 = commandEncoder24.beginComputePass(); |
| try { |
| computePassEncoder96.setBindGroup(2, bindGroup64, [2304]); |
| } catch {} |
| try { |
| renderPassEncoder19.setBindGroup(0, bindGroup2, new Uint32Array(2941), 45, 0); |
| } catch {} |
| try { |
| renderPassEncoder17.setIndexBuffer(buffer122, 'uint16', 32, 1_327); |
| } catch {} |
| try { |
| renderPassEncoder51.setVertexBuffer(0, buffer88, 2_304); |
| } catch {} |
| try { |
| renderBundleEncoder21.setVertexBuffer(1, buffer38, 12, 56); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture21, |
| mipLevel: 0, |
| origin: {x: 58, y: 5, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(74).fill(130), /* required buffer size: 74 */ |
| {offset: 74, bytesPerRow: 99}, {width: 9, height: 19, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 246, height: 1, depthOrArrayLayers: 307} |
| */ |
| { |
| source: videoFrame24, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture6, |
| mipLevel: 0, |
| origin: {x: 42, y: 0, z: 23}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| globalThis.someLabel = textureView111.label; |
| } catch {} |
| let bindGroup99 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout16, |
| entries: [ |
| {binding: 323, resource: {buffer: buffer119, offset: 0, size: 1472}}, |
| {binding: 144, resource: textureView2}, |
| ], |
| }); |
| let commandEncoder186 = device0.createCommandEncoder({}); |
| let textureView196 = texture229.createView({arrayLayerCount: 1}); |
| let computePassEncoder171 = commandEncoder184.beginComputePass({}); |
| let renderPassEncoder54 = commandEncoder186.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView36, |
| depthSlice: 190, |
| clearValue: { r: 177.2, g: -14.85, b: -232.4, a: -121.8, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| maxDrawCount: 14688991, |
| }); |
| try { |
| computePassEncoder148.setBindGroup(0, bindGroup53); |
| } catch {} |
| try { |
| computePassEncoder53.setBindGroup(2, bindGroup70, new Uint32Array(507), 21, 0); |
| } catch {} |
| try { |
| computePassEncoder170.setPipeline(pipeline33); |
| } catch {} |
| try { |
| renderPassEncoder17.setViewport(1.7272215886332434, 0.7289382667443219, 219.12080670547584, 0.013698171926536686, 0.45635960225396377, 0.8168287812175108); |
| } catch {} |
| try { |
| renderBundleEncoder21.setBindGroup(1, bindGroup0); |
| } catch {} |
| try { |
| renderBundleEncoder21.setBindGroup(0, bindGroup52, new Uint32Array(1663), 57, 0); |
| } catch {} |
| try { |
| renderBundleEncoder21.setIndexBuffer(buffer92, 'uint32', 344, 3_019); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| } catch {} |
| let pipeline43 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule9, entryPoint: 'compute11', constants: {override3: 1}}}); |
| document.body.prepend(canvas1); |
| let commandEncoder187 = device0.createCommandEncoder({}); |
| let textureView197 = texture183.createView({mipLevelCount: 1, baseArrayLayer: 0, arrayLayerCount: 3}); |
| let computePassEncoder172 = commandEncoder187.beginComputePass({}); |
| try { |
| computePassEncoder170.setBindGroup(0, bindGroup73, new Uint32Array(661), 175, 0); |
| } catch {} |
| try { |
| renderPassEncoder54.setIndexBuffer(buffer67, 'uint32', 480, 564); |
| } catch {} |
| try { |
| renderPassEncoder43.setVertexBuffer(2, buffer1, 0, 1_890); |
| } catch {} |
| try { |
| renderBundleEncoder21.setIndexBuffer(buffer76, 'uint16', 0, 132); |
| } catch {} |
| try { |
| renderBundleEncoder21.setPipeline(pipeline42); |
| } catch {} |
| let computePassEncoder173 = commandEncoder185.beginComputePass(); |
| try { |
| computePassEncoder171.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderPassEncoder39.setBindGroup(3, bindGroup34, new Uint32Array(3764), 90, 0); |
| } catch {} |
| try { |
| renderBundleEncoder21.setBindGroup(1, bindGroup51, new Uint32Array(799), 105, 0); |
| } catch {} |
| try { |
| renderBundleEncoder21.setIndexBuffer(buffer104, 'uint16', 7_800, 3_697); |
| } catch {} |
| try { |
| computePassEncoder88.popDebugGroup(); |
| } catch {} |
| try { |
| commandEncoder182.insertDebugMarker('\ub7b9'); |
| } catch {} |
| let buffer134 = device0.createBuffer({size: 22986, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM}); |
| try { |
| computePassEncoder118.setBindGroup(1, bindGroup64, [0]); |
| } catch {} |
| try { |
| computePassEncoder172.setPipeline(pipeline18); |
| } catch {} |
| try { |
| renderPassEncoder53.setIndexBuffer(buffer14, 'uint16', 4_394, 11_510); |
| } catch {} |
| try { |
| renderBundleEncoder21.setBindGroup(2, bindGroup5); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture119, |
| mipLevel: 0, |
| origin: {x: 88, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(126).fill(132), /* required buffer size: 126 */ |
| {offset: 126}, {width: 121, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder188 = device0.createCommandEncoder({}); |
| let texture278 = gpuCanvasContext1.getCurrentTexture(); |
| try { |
| { clearResourceUsages(device0, computePassEncoder167); computePassEncoder167.dispatchWorkgroupsIndirect(buffer89, 148); }; |
| } catch {} |
| try { |
| renderPassEncoder44.setIndexBuffer(buffer106, 'uint32', 196, 841); |
| } catch {} |
| try { |
| renderPassEncoder20.setPipeline(pipeline31); |
| } catch {} |
| try { |
| renderBundleEncoder21.setBindGroup(0, bindGroup26, new Uint32Array(277), 52, 0); |
| } catch {} |
| try { |
| renderPassEncoder13.insertDebugMarker('\uab5b'); |
| } catch {} |
| try { |
| gpuCanvasContext4.unconfigure(); |
| } catch {} |
| let videoFrame25 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: true, matrix: 'fcc', primaries: 'film', transfer: 'iec6196624'} }); |
| let renderBundleEncoder22 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2unorm', 'rg16sint'], depthReadOnly: true, stencilReadOnly: true}); |
| let sampler108 = device0.createSampler({addressModeV: 'repeat', lodMaxClamp: 58.45, compare: 'equal'}); |
| try { |
| computePassEncoder58.setBindGroup(0, bindGroup81, new Uint32Array(3340), 89, 0); |
| } catch {} |
| try { |
| computePassEncoder173.setPipeline(pipeline30); |
| } catch {} |
| try { |
| renderPassEncoder46.setVertexBuffer(6, buffer43, 0, 37); |
| } catch {} |
| try { |
| renderBundleEncoder21.setBindGroup(1, bindGroup30); |
| } catch {} |
| try { |
| renderBundleEncoder22.setBindGroup(2, bindGroup1, new Uint32Array(524), 92, 0); |
| } catch {} |
| try { |
| renderBundleEncoder22.setIndexBuffer(buffer8, 'uint16', 96, 39); |
| } catch {} |
| try { |
| renderBundleEncoder21.setVertexBuffer(2, buffer74, 348); |
| } catch {} |
| let arrayBuffer27 = buffer26.getMappedRange(184, 0); |
| try { |
| commandEncoder182.copyBufferToBuffer(buffer55, 28, buffer132, 68, 296); |
| } catch {} |
| let commandEncoder189 = device0.createCommandEncoder({}); |
| let computePassEncoder174 = commandEncoder189.beginComputePass({}); |
| try { |
| computePassEncoder174.setPipeline(pipeline19); |
| } catch {} |
| try { |
| renderPassEncoder20.setBindGroup(3, bindGroup16, new Uint32Array(1791), 236, 0); |
| } catch {} |
| try { |
| renderPassEncoder29.setViewport(169.31747534721484, 0.1323659397013882, 73.84020701794618, 0.4272327062052206, 0.033144936012354576, 0.7978273105685754); |
| } catch {} |
| try { |
| renderPassEncoder49.setIndexBuffer(buffer107, 'uint16', 552, 6_063); |
| } catch {} |
| try { |
| renderPassEncoder33.setPipeline(pipeline22); |
| } catch {} |
| try { |
| renderBundleEncoder21.drawIndexedIndirect(buffer107, 5_084); |
| } catch {} |
| try { |
| renderBundleEncoder21.drawIndirect(buffer121, 1_880); |
| } catch {} |
| try { |
| renderBundleEncoder22.setIndexBuffer(buffer60, 'uint16', 298, 1_288); |
| } catch {} |
| try { |
| renderBundleEncoder21.setVertexBuffer(1, buffer14, 4_008, 2_820); |
| } catch {} |
| try { |
| commandEncoder188.copyBufferToBuffer(buffer95, 196, buffer79, 624, 60); |
| } catch {} |
| try { |
| gpuCanvasContext2.unconfigure(); |
| } catch {} |
| try { |
| await promise19; |
| } catch {} |
| let bindGroup100 = device0.createBindGroup({layout: autogeneratedBindGroupLayout2, entries: [{binding: 144, resource: textureView2}]}); |
| let commandEncoder190 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder147.setBindGroup(0, bindGroup25); |
| } catch {} |
| try { |
| renderBundleEncoder21.drawIndexedIndirect(buffer13, 3_936); |
| } catch {} |
| try { |
| renderBundleEncoder21.setPipeline(pipeline26); |
| } catch {} |
| let promise20 = shaderModule1.getCompilationInfo(); |
| let bindGroup101 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout6, |
| entries: [ |
| {binding: 144, resource: textureView145}, |
| {binding: 323, resource: {buffer: buffer124, offset: 0, size: 1340}}, |
| ], |
| }); |
| let buffer135 = device0.createBuffer({size: 6398, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX}); |
| let commandEncoder191 = device0.createCommandEncoder({}); |
| let textureView198 = texture97.createView({dimension: '2d-array'}); |
| try { |
| computePassEncoder150.setBindGroup(0, bindGroup8); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder161); computePassEncoder161.dispatchWorkgroupsIndirect(buffer2, 16); }; |
| } catch {} |
| try { |
| renderPassEncoder33.draw(329, 51, 1_272_462_675, 1_503_186_683); |
| } catch {} |
| try { |
| renderPassEncoder33.drawIndexedIndirect(buffer62, 408); |
| } catch {} |
| try { |
| renderPassEncoder33.drawIndirect(buffer131, 832); |
| } catch {} |
| try { |
| renderPassEncoder52.setIndexBuffer(buffer117, 'uint16', 10_648, 584); |
| } catch {} |
| try { |
| renderPassEncoder39.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder47.setVertexBuffer(5, buffer80, 0, 207); |
| } catch {} |
| try { |
| renderBundleEncoder21.setBindGroup(2, bindGroup87, new Uint32Array(1036), 190, 0); |
| } catch {} |
| try { |
| renderBundleEncoder21.drawIndexed(57, 55, 138, 269_657_684, 431_189_335); |
| } catch {} |
| try { |
| renderBundleEncoder21.drawIndexedIndirect(buffer90, 72); |
| } catch {} |
| try { |
| renderBundleEncoder22.setVertexBuffer(7, buffer102); |
| } catch {} |
| try { |
| commandEncoder188.copyBufferToBuffer(buffer73, 352, buffer74, 2064, 84); |
| } catch {} |
| try { |
| renderPassEncoder47.insertDebugMarker('\u{1fbe7}'); |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let buffer136 = device0.createBuffer({ |
| size: 17814, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder192 = device0.createCommandEncoder({}); |
| let textureView199 = texture228.createView({label: '\u0375\u00d2\u2db1\u{1fd63}\uf174\u9e54\ue2ee', baseArrayLayer: 0}); |
| let computePassEncoder175 = commandEncoder188.beginComputePass({}); |
| try { |
| computePassEncoder100.setBindGroup(0, bindGroup74); |
| } catch {} |
| try { |
| renderPassEncoder29.setStencilReference(282); |
| } catch {} |
| try { |
| renderPassEncoder53.setViewport(1045.6533740009957, 0.17955172584369627, 412.00354643342047, 0.2596693063656096, 0.8020642323537057, 0.9346435370264887); |
| } catch {} |
| try { |
| renderPassEncoder33.drawIndexedIndirect(buffer21, 18_500); |
| } catch {} |
| try { |
| renderPassEncoder33.drawIndirect(buffer102, 4_324); |
| } catch {} |
| try { |
| renderPassEncoder53.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder21.setVertexBuffer(2, buffer85); |
| } catch {} |
| try { |
| renderBundleEncoder21.setBindGroup(0, bindGroup101); |
| } catch {} |
| try { |
| renderBundleEncoder21.setBindGroup(2, bindGroup96, new Uint32Array(194), 16, 0); |
| } catch {} |
| await gc(); |
| let bindGroup102 = device0.createBindGroup({layout: autogeneratedBindGroupLayout2, entries: [{binding: 144, resource: textureView97}]}); |
| let textureView200 = texture55.createView({label: '\ubf27\u0998\u{1f9dc}\u73bf\uc7c1\u{1fd7b}\uee2d\u078d', arrayLayerCount: 1}); |
| let renderPassEncoder55 = commandEncoder191.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView142, |
| clearValue: { r: -683.9, g: -377.8, b: -444.0, a: -978.6, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| }); |
| let renderBundle21 = renderBundleEncoder22.finish({}); |
| try { |
| computePassEncoder175.setPipeline(pipeline30); |
| } catch {} |
| try { |
| renderPassEncoder38.setBindGroup(3, bindGroup13, new Uint32Array(1755), 1_701, 0); |
| } catch {} |
| try { |
| renderPassEncoder33.draw(52, 361, 282_120_181, 311_776_933); |
| } catch {} |
| try { |
| renderPassEncoder33.drawIndexedIndirect(buffer70, 0); |
| } catch {} |
| try { |
| renderBundleEncoder21.setPipeline(pipeline15); |
| } catch {} |
| try { |
| renderBundleEncoder21.setVertexBuffer(0, buffer70, 12, 9); |
| } catch {} |
| try { |
| buffer63.unmap(); |
| } catch {} |
| try { |
| commandEncoder190.insertDebugMarker('\ua86c'); |
| } catch {} |
| let imageBitmap2 = await createImageBitmap(videoFrame20); |
| let bindGroup103 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout6, |
| entries: [ |
| {binding: 144, resource: textureView5}, |
| {binding: 323, resource: {buffer: buffer136, offset: 512, size: 7028}}, |
| ], |
| }); |
| let textureView201 = texture227.createView({mipLevelCount: 1}); |
| let computePassEncoder176 = commandEncoder182.beginComputePass(); |
| let renderBundle22 = renderBundleEncoder21.finish({}); |
| let sampler109 = device0.createSampler({addressModeU: 'mirror-repeat', maxAnisotropy: 1}); |
| try { |
| computePassEncoder36.setBindGroup(1, bindGroup34); |
| } catch {} |
| try { |
| computePassEncoder141.setBindGroup(0, bindGroup47, new Uint32Array(82), 3, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder151); computePassEncoder151.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| computePassEncoder176.setPipeline(pipeline25); |
| } catch {} |
| try { |
| renderPassEncoder33.drawIndexed(0, 312, 0, 110_935_173, 280_907_715); |
| } catch {} |
| try { |
| renderPassEncoder49.setIndexBuffer(buffer96, 'uint16', 350, 111); |
| } catch {} |
| let recycledExplicitBindGroupLayout18 = pipeline0.getBindGroupLayout(0); |
| let bindGroup104 = device0.createBindGroup({layout: veryExplicitBindGroupLayout7, entries: [{binding: 9, resource: textureView67}]}); |
| let texture279 = device0.createTexture({ |
| size: {width: 32, height: 32, depthOrArrayLayers: 21}, |
| sampleCount: 1, |
| format: 'r8uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder37.setBindGroup(3, bindGroup87, new Uint32Array(2247), 398, 0); |
| } catch {} |
| try { |
| computePassEncoder76.setPipeline(pipeline38); |
| } catch {} |
| try { |
| renderPassEncoder39.setBindGroup(2, bindGroup74); |
| } catch {} |
| try { |
| renderPassEncoder33.drawIndexed(2, 4, 4, 349_165_567, 342_311_292); |
| } catch {} |
| try { |
| renderPassEncoder33.drawIndexedIndirect(buffer65, 2_020); |
| } catch {} |
| try { |
| renderPassEncoder33.drawIndirect(buffer1, 2_524); |
| } catch {} |
| try { |
| renderPassEncoder50.setIndexBuffer(buffer41, 'uint32', 4_312, 7_846); |
| } catch {} |
| try { |
| renderPassEncoder19.setPipeline(pipeline42); |
| } catch {} |
| try { |
| renderPassEncoder40.setVertexBuffer(6, buffer111); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| try { |
| if (!arrayBuffer13.detached) { new Uint8Array(arrayBuffer13).fill(0x55); }; |
| } catch {} |
| let imageData24 = new ImageData(24, 80); |
| let texture280 = device0.createTexture({ |
| size: [470, 2, 1], |
| format: 'rg16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let computePassEncoder177 = commandEncoder192.beginComputePass(); |
| try { |
| renderPassEncoder14.setBindGroup(2, bindGroup91, []); |
| } catch {} |
| try { |
| renderPassEncoder27.setBindGroup(1, bindGroup58, new Uint32Array(1599), 45, 0); |
| } catch {} |
| try { |
| renderPassEncoder33.end(); |
| } catch {} |
| try { |
| renderPassEncoder48.setIndexBuffer(buffer96, 'uint32', 132, 207); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer57, 572, new BigUint64Array(27781), 5171, 236); |
| } catch {} |
| let promise21 = device0.queue.onSubmittedWorkDone(); |
| try { |
| await promise21; |
| } catch {} |
| let veryExplicitBindGroupLayout24 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 246, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| ], |
| }); |
| let computePassEncoder178 = commandEncoder40.beginComputePass({}); |
| try { |
| computePassEncoder146.setBindGroup(2, bindGroup59, new Uint32Array(3665), 572, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder133); computePassEncoder133.dispatchWorkgroups(3); }; |
| } catch {} |
| try { |
| renderPassEncoder13.setBindGroup(2, bindGroup48); |
| } catch {} |
| try { |
| renderPassEncoder53.setVertexBuffer(0, buffer117, 0, 1_201); |
| } catch {} |
| try { |
| device0.pushErrorScope('out-of-memory'); |
| } catch {} |
| try { |
| commandEncoder190.copyBufferToBuffer(buffer4, 156, buffer41, 3200, 388); |
| } catch {} |
| try { |
| commandEncoder190.copyBufferToTexture({ |
| /* bytesInLastRow: 127 widthInBlocks: 127 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 651 */ |
| offset: 651, |
| bytesPerRow: 6400, |
| buffer: buffer52, |
| }, { |
| texture: texture71, |
| mipLevel: 0, |
| origin: {x: 50, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 127, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await promise20; |
| } catch {} |
| let commandEncoder193 = device0.createCommandEncoder({}); |
| let computePassEncoder179 = commandEncoder193.beginComputePass(); |
| try { |
| computePassEncoder161.setBindGroup(1, bindGroup61, new Uint32Array(210), 101, 0); |
| } catch {} |
| try { |
| computePassEncoder179.setPipeline(pipeline37); |
| } catch {} |
| try { |
| renderPassEncoder27.executeBundles([renderBundle6, renderBundle12, renderBundle11]); |
| } catch {} |
| try { |
| renderPassEncoder43.setStencilReference(1590); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| commandEncoder190.copyBufferToBuffer(buffer97, 524, buffer2, 8, 112); |
| } catch {} |
| let buffer137 = device0.createBuffer({size: 4684, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let querySet24 = device0.createQuerySet({type: 'occlusion', count: 1598}); |
| let computePassEncoder180 = commandEncoder190.beginComputePass(); |
| let sampler110 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'repeat', lodMaxClamp: 94.83}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder170); computePassEncoder170.dispatchWorkgroupsIndirect(buffer86, 10_760); }; |
| } catch {} |
| try { |
| renderPassEncoder51.setIndexBuffer(buffer89, 'uint32', 1_772, 171); |
| } catch {} |
| let arrayBuffer28 = buffer72.getMappedRange(16, 36); |
| try { |
| device0.queue.writeTexture({ |
| texture: texture208, |
| mipLevel: 0, |
| origin: {x: 48, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(22).fill(186), /* required buffer size: 22 */ |
| {offset: 22, rowsPerImage: 4}, {width: 29, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let promise22 = device0.queue.onSubmittedWorkDone(); |
| let pipeline44 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule0, constants: {}}}); |
| let bindGroup105 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout14, |
| entries: [ |
| {binding: 323, resource: {buffer: buffer71, offset: 6912, size: 4104}}, |
| {binding: 144, resource: textureView145}, |
| ], |
| }); |
| let textureView202 = texture106.createView({dimension: '2d', baseArrayLayer: 4}); |
| try { |
| computePassEncoder148.setBindGroup(3, bindGroup96, new Uint32Array(2573), 31, 0); |
| } catch {} |
| try { |
| computePassEncoder177.setPipeline(pipeline19); |
| } catch {} |
| try { |
| renderPassEncoder42.setBindGroup(0, bindGroup19, new Uint32Array(2452), 23, 0); |
| } catch {} |
| try { |
| renderPassEncoder44.setIndexBuffer(buffer37, 'uint16', 3_334, 1_000); |
| } catch {} |
| try { |
| renderPassEncoder37.setVertexBuffer(1, buffer73); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let bindGroup106 = device0.createBindGroup({layout: autogeneratedBindGroupLayout2, entries: [{binding: 144, resource: textureView145}]}); |
| let buffer138 = device0.createBuffer({size: 2285, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT}); |
| let sampler111 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'clamp-to-edge', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 74.57, |
| compare: 'greater-equal', |
| }); |
| try { |
| computePassEncoder167.setBindGroup(0, bindGroup26); |
| } catch {} |
| try { |
| computePassEncoder66.setBindGroup(3, bindGroup27, new Uint32Array(91), 4, 0); |
| } catch {} |
| try { |
| renderPassEncoder29.setBindGroup(2, bindGroup46); |
| } catch {} |
| try { |
| renderPassEncoder47.setPipeline(pipeline21); |
| } catch {} |
| document.body.prepend(img3); |
| let commandEncoder194 = device0.createCommandEncoder({}); |
| let textureView203 = texture103.createView({baseArrayLayer: 0, arrayLayerCount: 9}); |
| let renderPassEncoder56 = commandEncoder194.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView142, |
| clearValue: { r: 257.7, g: 825.0, b: -293.9, a: -89.60, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| }); |
| let renderBundleEncoder23 = device0.createRenderBundleEncoder({colorFormats: ['rg32uint'], depthStencilFormat: 'depth24plus-stencil8', depthReadOnly: true}); |
| try { |
| computePassEncoder152.setPipeline(pipeline9); |
| } catch {} |
| try { |
| renderPassEncoder47.setBindGroup(2, bindGroup84, new Uint32Array(3092), 1_355, 0); |
| } catch {} |
| try { |
| renderBundleEncoder23.setVertexBuffer(5, buffer131, 1_924, 323); |
| } catch {} |
| let textureView204 = texture72.createView({}); |
| let renderBundle23 = renderBundleEncoder23.finish({}); |
| let sampler112 = device0.createSampler({addressModeU: 'mirror-repeat', magFilter: 'nearest', lodMinClamp: 2.358}); |
| try { |
| renderPassEncoder24.setScissorRect(10, 0, 6, 0); |
| } catch {} |
| try { |
| buffer9.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let bindGroup107 = device0.createBindGroup({ |
| label: '\u5c12\u832e\u0d30\u0e51\uebfb\u155e\ueb2e\uc721', |
| layout: recycledExplicitBindGroupLayout13, |
| entries: [ |
| {binding: 144, resource: textureView145}, |
| {binding: 323, resource: {buffer: buffer111, offset: 7936, size: 3852}}, |
| ], |
| }); |
| let commandEncoder195 = device0.createCommandEncoder({}); |
| let texture281 = device0.createTexture({ |
| size: [3760, 20, 1], |
| format: 'r8uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| let computePassEncoder181 = commandEncoder195.beginComputePass({}); |
| let externalTexture17 = device0.importExternalTexture({source: videoFrame7}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder150); computePassEncoder150.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder21.setBindGroup(3, bindGroup47); |
| } catch {} |
| try { |
| renderPassEncoder51.setBindGroup(3, bindGroup101, new Uint32Array(83), 83, 0); |
| } catch {} |
| try { |
| renderPassEncoder42.setPipeline(pipeline42); |
| } catch {} |
| document.body.append(img4); |
| let commandEncoder196 = device0.createCommandEncoder({}); |
| let querySet25 = device0.createQuerySet({type: 'occlusion', count: 1058}); |
| let textureView205 = texture177.createView({dimension: '2d', baseMipLevel: 0, baseArrayLayer: 0}); |
| let computePassEncoder182 = commandEncoder196.beginComputePass({}); |
| try { |
| renderPassEncoder38.setBindGroup(0, bindGroup30); |
| } catch {} |
| try { |
| renderPassEncoder45.setPipeline(pipeline31); |
| } catch {} |
| try { |
| renderPassEncoder21.setVertexBuffer(2, buffer117); |
| } catch {} |
| let pipeline45 = device0.createRenderPipeline({ |
| layout: 'auto', |
| multisample: {mask: 0x1c7617e2}, |
| fragment: { |
| module: shaderModule0, |
| targets: [{format: 'rg8unorm', writeMask: GPUColorWrite.BLUE | GPUColorWrite.RED}], |
| }, |
| vertex: { |
| module: shaderModule9, |
| constants: {override3: 1}, |
| buffers: [ |
| { |
| arrayStride: 360, |
| stepMode: 'instance', |
| attributes: [{format: 'sint16x2', offset: 20, shaderLocation: 9}], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-list'}, |
| }); |
| let commandEncoder197 = device0.createCommandEncoder(); |
| let textureView206 = texture178.createView({dimension: '2d-array', aspect: 'all', mipLevelCount: 1}); |
| try { |
| computePassEncoder72.setBindGroup(1, bindGroup40, new Uint32Array(4097), 1_203, 0); |
| } catch {} |
| try { |
| renderPassEncoder19.setIndexBuffer(buffer60, 'uint16', 1_090, 1_146); |
| } catch {} |
| try { |
| renderPassEncoder53.setPipeline(pipeline20); |
| } catch {} |
| let recycledExplicitBindGroupLayout19 = pipeline2.getBindGroupLayout(0); |
| let textureView207 = texture84.createView({dimension: '2d-array'}); |
| let sampler113 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'repeat', addressModeW: 'repeat', mipmapFilter: 'nearest'}); |
| try { |
| computePassEncoder36.setBindGroup(2, bindGroup68, new Uint32Array(1569), 166, 0); |
| } catch {} |
| try { |
| renderPassEncoder24.setBindGroup(2, bindGroup96); |
| } catch {} |
| try { |
| renderPassEncoder43.setIndexBuffer(buffer124, 'uint16', 592, 280); |
| } catch {} |
| try { |
| commandEncoder197.copyBufferToTexture({ |
| /* bytesInLastRow: 24 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 7132 */ |
| offset: 7132, |
| bytesPerRow: 34816, |
| buffer: buffer83, |
| }, { |
| texture: texture25, |
| mipLevel: 0, |
| origin: {x: 57, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 6, height: 27, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| computePassEncoder168.insertDebugMarker('\u0b27'); |
| } catch {} |
| let bindGroup108 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout9, |
| entries: [ |
| {binding: 144, resource: textureView4}, |
| {binding: 323, resource: {buffer: buffer125, offset: 3072, size: 4364}}, |
| ], |
| }); |
| let buffer139 = device0.createBuffer({size: 452, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX}); |
| let commandEncoder198 = device0.createCommandEncoder(); |
| let computePassEncoder183 = commandEncoder197.beginComputePass(); |
| let sampler114 = device0.createSampler({addressModeU: 'mirror-repeat', lodMaxClamp: 75.81, compare: 'greater-equal'}); |
| let commandEncoder199 = device0.createCommandEncoder({}); |
| let sampler115 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'repeat', lodMaxClamp: 63.86, compare: 'greater'}); |
| try { |
| renderPassEncoder36.setBindGroup(1, bindGroup13); |
| } catch {} |
| try { |
| renderPassEncoder51.setVertexBuffer(0, buffer33, 0); |
| } catch {} |
| let buffer140 = device0.createBuffer({size: 8020, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX}); |
| let texture282 = device0.createTexture({ |
| size: {width: 307, height: 7, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'depth24plus-stencil8', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| renderPassEncoder48.setBindGroup(2, bindGroup2); |
| } catch {} |
| try { |
| renderPassEncoder14.setVertexBuffer(1, undefined, 0, 45_702_030); |
| } catch {} |
| try { |
| commandEncoder198.copyTextureToTexture({ |
| texture: texture26, |
| mipLevel: 0, |
| origin: {x: 25, y: 12, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture50, |
| mipLevel: 0, |
| origin: {x: 35, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 10, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder200 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder67.setBindGroup(2, bindGroup93, new Uint32Array(566), 169, 0); |
| } catch {} |
| try { |
| commandEncoder199.copyBufferToTexture({ |
| /* bytesInLastRow: 1488 widthInBlocks: 186 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 8888 */ |
| offset: 8888, |
| buffer: buffer1, |
| }, { |
| texture: texture110, |
| mipLevel: 0, |
| origin: {x: 24, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 186, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture69, |
| mipLevel: 0, |
| origin: {x: 106, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(19).fill(147), /* required buffer size: 19 */ |
| {offset: 19, bytesPerRow: 186}, {width: 135, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer141 = device0.createBuffer({ |
| size: 2480, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM, |
| mappedAtCreation: false, |
| }); |
| let texture283 = device0.createTexture({ |
| size: [10, 11, 1], |
| sampleCount: 4, |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let computePassEncoder184 = commandEncoder198.beginComputePass({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder147); computePassEncoder147.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| computePassEncoder64.setPipeline(pipeline23); |
| } catch {} |
| try { |
| computePassEncoder182.setPipeline(pipeline11); |
| } catch {} |
| try { |
| renderPassEncoder20.setBindGroup(2, bindGroup42, new Uint32Array(710), 36, 0); |
| } catch {} |
| let arrayBuffer29 = buffer26.getMappedRange(264, 20); |
| try { |
| commandEncoder200.copyBufferToTexture({ |
| /* bytesInLastRow: 80 widthInBlocks: 20 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 3036 */ |
| offset: 3036, |
| bytesPerRow: 41984, |
| buffer: buffer56, |
| }, { |
| texture: texture229, |
| mipLevel: 0, |
| origin: {x: 231, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 20, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer133, 92, new BigUint64Array(2651), 378, 92); |
| } catch {} |
| let promise23 = device0.queue.onSubmittedWorkDone(); |
| await gc(); |
| let bindGroup109 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout16, |
| entries: [ |
| {binding: 430, resource: sampler87}, |
| {binding: 133, resource: {buffer: buffer20, offset: 1024, size: 6480}}, |
| {binding: 73, resource: sampler17}, |
| {binding: 34, resource: textureView111}, |
| ], |
| }); |
| let textureView208 = texture65.createView({format: 'astc-6x6-unorm-srgb'}); |
| let computePassEncoder185 = commandEncoder199.beginComputePass(); |
| let renderPassEncoder57 = commandEncoder200.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView79, |
| depthSlice: 9, |
| clearValue: { r: -78.21, g: -679.5, b: -485.2, a: 514.7, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| maxDrawCount: 105636845, |
| }); |
| try { |
| computePassEncoder34.setBindGroup(2, bindGroup72); |
| } catch {} |
| try { |
| computePassEncoder173.setBindGroup(0, bindGroup42, new Uint32Array(1731), 4, 0); |
| } catch {} |
| try { |
| computePassEncoder184.setPipeline(pipeline19); |
| } catch {} |
| try { |
| renderPassEncoder17.setBindGroup(0, bindGroup57); |
| } catch {} |
| try { |
| renderPassEncoder44.setIndexBuffer(buffer122, 'uint16', 2_302, 801); |
| } catch {} |
| try { |
| renderPassEncoder29.setPipeline(pipeline21); |
| } catch {} |
| let arrayBuffer30 = buffer26.getMappedRange(176, 0); |
| try { |
| gpuCanvasContext4.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let buffer142 = device0.createBuffer({size: 941, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let commandEncoder201 = device0.createCommandEncoder({}); |
| let querySet26 = device0.createQuerySet({type: 'occlusion', count: 262}); |
| let texture284 = device0.createTexture({ |
| size: {width: 80, height: 90, depthOrArrayLayers: 69}, |
| mipLevelCount: 1, |
| dimension: '3d', |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.COPY_SRC, |
| }); |
| let textureView209 = texture221.createView({dimension: '2d', baseArrayLayer: 9}); |
| let computePassEncoder186 = commandEncoder201.beginComputePass({}); |
| try { |
| renderPassEncoder13.setIndexBuffer(buffer130, 'uint32', 132, 12); |
| } catch {} |
| let canvas2 = document.createElement('canvas'); |
| let buffer143 = device0.createBuffer({size: 1954, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX}); |
| let commandEncoder202 = device0.createCommandEncoder({}); |
| let computePassEncoder187 = commandEncoder202.beginComputePass({}); |
| let externalTexture18 = device0.importExternalTexture({source: videoFrame17}); |
| try { |
| computePassEncoder153.setPipeline(pipeline43); |
| } catch {} |
| try { |
| computePassEncoder180.setPipeline(pipeline43); |
| } catch {} |
| try { |
| renderPassEncoder38.setBindGroup(3, bindGroup87); |
| } catch {} |
| try { |
| renderPassEncoder50.setBindGroup(0, bindGroup25, new Uint32Array(265), 12, 0); |
| } catch {} |
| try { |
| renderPassEncoder48.executeBundles([renderBundle2, renderBundle12, renderBundle11]); |
| } catch {} |
| try { |
| renderPassEncoder19.setIndexBuffer(buffer41, 'uint16', 1_888, 816); |
| } catch {} |
| try { |
| renderPassEncoder57.setVertexBuffer(7, buffer96, 8, 14); |
| } catch {} |
| try { |
| gpuCanvasContext4.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| document.body.append(canvas0); |
| let bindGroup110 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout11, |
| entries: [ |
| {binding: 323, resource: {buffer: buffer111, offset: 3072, size: 6540}}, |
| {binding: 144, resource: textureView5}, |
| ], |
| }); |
| let sampler116 = device0.createSampler({ |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 87.33, |
| maxAnisotropy: 4, |
| }); |
| try { |
| computePassEncoder115.setBindGroup(0, bindGroup34); |
| } catch {} |
| try { |
| computePassEncoder117.setBindGroup(1, bindGroup79, new Uint32Array(270), 30, 0); |
| } catch {} |
| try { |
| computePassEncoder133.end(); |
| } catch {} |
| try { |
| computePassEncoder181.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderPassEncoder44.executeBundles([renderBundle7, renderBundle9]); |
| } catch {} |
| try { |
| renderPassEncoder47.setStencilReference(982); |
| } catch {} |
| let commandEncoder203 = device0.createCommandEncoder({}); |
| let textureView210 = texture90.createView({baseArrayLayer: 12, arrayLayerCount: 8}); |
| let textureView211 = texture256.createView({mipLevelCount: 1}); |
| let computePassEncoder188 = commandEncoder203.beginComputePass({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder50); computePassEncoder50.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder147); computePassEncoder147.dispatchWorkgroupsIndirect(buffer87, 36); }; |
| } catch {} |
| try { |
| computePassEncoder185.setPipeline(pipeline11); |
| } catch {} |
| try { |
| commandEncoder138.resolveQuerySet(querySet20, 22, 16, buffer103, 512); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 80, height: 90, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame23, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture92, |
| mipLevel: 0, |
| origin: {x: 14, y: 47, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandBuffer26 = commandEncoder138.finish(); |
| let texture285 = device0.createTexture({size: [984, 1, 26], mipLevelCount: 3, format: 'rg8unorm', usage: GPUTextureUsage.TEXTURE_BINDING}); |
| let sampler117 = device0.createSampler({ |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 88.00, |
| maxAnisotropy: 8, |
| }); |
| try { |
| renderPassEncoder13.setVertexBuffer(1, buffer136, 536, 491); |
| } catch {} |
| document.body.prepend(canvas1); |
| let veryExplicitBindGroupLayout25 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 44, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false }, |
| }, |
| ], |
| }); |
| let recycledExplicitBindGroupLayout20 = pipeline8.getBindGroupLayout(1); |
| let buffer144 = device0.createBuffer({ |
| size: 17979, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE, |
| }); |
| let textureView212 = texture114.createView({dimension: '2d', baseMipLevel: 1, mipLevelCount: 1}); |
| try { |
| computePassEncoder102.setBindGroup(0, bindGroup98, new Uint32Array(3683), 396, 0); |
| } catch {} |
| try { |
| renderPassEncoder57.setPipeline(pipeline31); |
| } catch {} |
| await gc(); |
| let bindGroup111 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout20, |
| entries: [ |
| {binding: 80, resource: {buffer: buffer119, offset: 512, size: 216}}, |
| {binding: 22, resource: {buffer: buffer40, offset: 512}}, |
| {binding: 390, resource: sampler100}, |
| {binding: 160, resource: textureView95}, |
| {binding: 51, resource: textureView96}, |
| {binding: 188, resource: textureView131}, |
| {binding: 60, resource: externalTexture15}, |
| {binding: 67, resource: {buffer: buffer89, offset: 512, size: 2240}}, |
| {binding: 114, resource: {buffer: buffer74, offset: 0, size: 4380}}, |
| ], |
| }); |
| let commandEncoder204 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder66.setBindGroup(0, bindGroup40); |
| } catch {} |
| try { |
| computePassEncoder50.end(); |
| } catch {} |
| try { |
| computePassEncoder188.setPipeline(pipeline38); |
| } catch {} |
| try { |
| renderPassEncoder24.setBindGroup(3, bindGroup100, new Uint32Array(522), 13, 0); |
| } catch {} |
| try { |
| renderPassEncoder36.setPipeline(pipeline2); |
| } catch {} |
| try { |
| commandEncoder62.copyBufferToTexture({ |
| /* bytesInLastRow: 210 widthInBlocks: 105 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 360 */ |
| offset: 360, |
| buffer: buffer8, |
| }, { |
| texture: texture7, |
| mipLevel: 0, |
| origin: {x: 58, y: 2, z: 0}, |
| aspect: 'all', |
| }, {width: 105, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await promise22; |
| } catch {} |
| let buffer145 = device0.createBuffer({ |
| size: 6594, |
| usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| let commandEncoder205 = device0.createCommandEncoder({}); |
| let textureView213 = texture54.createView({dimension: '2d-array', mipLevelCount: 1}); |
| let computePassEncoder189 = commandEncoder62.beginComputePass({}); |
| try { |
| computePassEncoder183.setPipeline(pipeline11); |
| } catch {} |
| try { |
| renderPassEncoder11.setScissorRect(23, 0, 43, 0); |
| } catch {} |
| let querySet27 = device0.createQuerySet({type: 'occlusion', count: 624}); |
| let computePassEncoder190 = commandEncoder205.beginComputePass({}); |
| let sampler118 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 87.84, |
| compare: 'always', |
| maxAnisotropy: 1, |
| }); |
| try { |
| computePassEncoder70.setBindGroup(0, bindGroup26); |
| } catch {} |
| try { |
| renderPassEncoder10.setIndexBuffer(buffer120, 'uint32', 1_260, 336); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer26]); |
| } catch {} |
| let promise24 = device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule7, constants: {}}}); |
| offscreenCanvas0.width = 749; |
| let querySet28 = device0.createQuerySet({type: 'occlusion', count: 227}); |
| let textureView214 = texture80.createView({dimension: '2d-array', format: 'r8sint', mipLevelCount: 1}); |
| let computePassEncoder191 = commandEncoder204.beginComputePass({}); |
| try { |
| computePassEncoder110.setBindGroup(1, bindGroup109, [5376]); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder92); computePassEncoder92.dispatchWorkgroupsIndirect(buffer114, 0); }; |
| } catch {} |
| try { |
| renderPassEncoder24.setVertexBuffer(4, buffer56); |
| } catch {} |
| let commandEncoder206 = device0.createCommandEncoder(); |
| let textureView215 = texture81.createView({dimension: 'cube', baseMipLevel: 0, baseArrayLayer: 6}); |
| let textureView216 = texture0.createView({dimension: '2d-array', aspect: 'depth-only', baseMipLevel: 0}); |
| try { |
| renderPassEncoder24.setIndexBuffer(buffer102, 'uint16', 684, 2_212); |
| } catch {} |
| try { |
| renderPassEncoder38.setVertexBuffer(2, buffer56, 0, 1_242); |
| } catch {} |
| try { |
| commandEncoder206.copyBufferToBuffer(buffer126, 96, buffer72, 340, 1428); |
| } catch {} |
| let buffer146 = device0.createBuffer({size: 21232, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let texture286 = gpuCanvasContext3.getCurrentTexture(); |
| let textureView217 = texture148.createView({mipLevelCount: 1}); |
| let computePassEncoder192 = commandEncoder206.beginComputePass({}); |
| try { |
| computePassEncoder189.setPipeline(pipeline27); |
| } catch {} |
| try { |
| renderPassEncoder36.setBindGroup(0, bindGroup38, []); |
| } catch {} |
| try { |
| renderPassEncoder57.executeBundles([renderBundle9]); |
| } catch {} |
| try { |
| renderPassEncoder55.setVertexBuffer(4, buffer55, 508, 42); |
| } catch {} |
| let commandEncoder207 = device0.createCommandEncoder({}); |
| let textureView218 = texture60.createView({dimension: '2d'}); |
| let renderPassEncoder58 = commandEncoder207.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView172, |
| clearValue: { r: 408.1, g: 558.1, b: 870.9, a: 817.4, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| computePassEncoder127.setBindGroup(0, bindGroup68); |
| } catch {} |
| try { |
| computePassEncoder167.end(); |
| } catch {} |
| try { |
| renderPassEncoder19.setViewport(146.75324431553355, 0.9902287090900082, 42.43583211755888, 0.00169724000425971, 0.7578387990503729, 0.9305702144511402); |
| } catch {} |
| try { |
| commandEncoder178.copyBufferToTexture({ |
| /* bytesInLastRow: 156 widthInBlocks: 39 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 324 */ |
| offset: 324, |
| bytesPerRow: 9216, |
| buffer: buffer137, |
| }, { |
| texture: texture126, |
| mipLevel: 2, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 39, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| renderPassEncoder17.insertDebugMarker('\u1c94'); |
| } catch {} |
| try { |
| await promise23; |
| } catch {} |
| let bindGroup112 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout1, |
| entries: [ |
| {binding: 323, resource: {buffer: buffer42, offset: 256, size: 2876}}, |
| {binding: 144, resource: textureView145}, |
| ], |
| }); |
| let texture287 = gpuCanvasContext1.getCurrentTexture(); |
| let textureView219 = texture11.createView({}); |
| let renderPassEncoder59 = commandEncoder178.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView134, |
| depthSlice: 3, |
| clearValue: { r: -560.3, g: -855.5, b: 807.3, a: -227.2, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| computePassEncoder187.setPipeline(pipeline37); |
| } catch {} |
| try { |
| renderPassEncoder36.setBindGroup(1, bindGroup45, new Uint32Array(953), 28, 0); |
| } catch {} |
| try { |
| renderPassEncoder27.beginOcclusionQuery(41); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture251, |
| mipLevel: 0, |
| origin: {x: 307, y: 0, z: 72}, |
| aspect: 'all', |
| }, new Uint8Array(450_687).fill(210), /* required buffer size: 450_687 */ |
| {offset: 111, bytesPerRow: 894, rowsPerImage: 14}, {width: 221, height: 0, depthOrArrayLayers: 37}); |
| } catch {} |
| let buffer147 = device0.createBuffer({size: 14661, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE}); |
| let texture288 = device0.createTexture({ |
| size: [80, 90, 45], |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| let textureView220 = texture71.createView({dimension: '2d-array', format: 'r8uint'}); |
| let offscreenCanvas3 = new OffscreenCanvas(244, 280); |
| let imageData25 = new ImageData(4, 32); |
| let textureView221 = texture258.createView({dimension: '2d-array', aspect: 'depth-only', mipLevelCount: 1}); |
| let sampler119 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'mirror-repeat', addressModeW: 'repeat', lodMaxClamp: 69.44}); |
| try { |
| computePassEncoder69.setBindGroup(0, bindGroup59, new Uint32Array(1762), 370, 0); |
| } catch {} |
| try { |
| renderPassEncoder50.setBindGroup(0, bindGroup58, new Uint32Array(176), 58, 0); |
| } catch {} |
| try { |
| computePassEncoder70.pushDebugGroup('\u0ddb'); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture32, |
| mipLevel: 0, |
| origin: {x: 1682, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(7).fill(30), /* required buffer size: 7 */ |
| {offset: 7}, {width: 454, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let shaderModule11 = device0.createShaderModule({ |
| code: ` |
| requires packed_4x8_integer_dot_product; |
| |
| enable f16; |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| @group(0) @binding(144) var st11: texture_storage_1d<r32uint, read_write>; |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| struct T0 { |
| @align(32) @size(864) f0: array<u32>, |
| } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| @id(42511) override override16: i32; |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| struct VertexOutput10 { |
| @location(6) f21: vec4h, |
| @location(14) @interpolate(flat, either) f22: vec4i, |
| @location(15) f23: vec4i, |
| @location(13) @interpolate(flat, either) f24: vec4f, |
| @location(7) @interpolate(flat) f25: vec4u, |
| @builtin(position) f26: vec4f, |
| @location(4) f27: vec4i, |
| } |
| |
| struct VertexOutput11 { |
| @location(11) f28: f16, |
| @location(1) @interpolate(perspective, sample) f29: vec2f, |
| @location(8) @interpolate(flat, first) f30: vec2i, |
| @location(6) f31: vec2f, |
| @location(0) @interpolate(flat, sample) f32: vec4u, |
| @location(4) @interpolate(flat, either) f33: vec4i, |
| @location(3) f34: vec2h, |
| @location(10) @interpolate(flat, either) f35: vec2i, |
| @builtin(position) f36: vec4f, |
| @location(15) @interpolate(flat, first) f37: vec4i, |
| @location(2) f38: f32, |
| } |
| |
| /* zero global variables used */ |
| @vertex |
| fn vertex11(@location(7) a0: vec2u) -> VertexOutput10 { |
| var out: VertexOutput10; |
| let vf274: vec2f = min(vec2f(unconst_f32(-0.2147), unconst_f32(0.2707)), vec2f(f32((unconst_bool(false) && unconst_bool(false))))); |
| var vf275: u32 = dot(vec4u(unconst_u32(631), unconst_u32(94), unconst_u32(165), unconst_u32(282)), abs(vec3u(acos(vec3h(unconst_f16(9915.2), unconst_f16(5450.5), unconst_f16(12030.0))))).ggbr); |
| let vf276: f32 = sqrt(unconst_f32(0.00144)); |
| let vf277: bool = (unconst_bool(false) && unconst_bool(true)); |
| var vf278: f16 = smoothstep(unconst_f16(735.6), unconst_f16(6079.9), unconst_f16(40666.4)); |
| switch vec3i(acos(vec3h(refract(vec4f(unconst_f32(-0.04074), unconst_f32(0.02494), unconst_f32(0.02260), unconst_f32(0.3109)), vec4f((vec4i(unconst_i32(108), unconst_i32(48), unconst_i32(276), unconst_i32(42)) != bitcast<vec4i>(radians(vec3f(unconst_f32(0.3002), unconst_f32(0.01551), unconst_f32(0.07194))).zyxz))), unconst_f32(0.06649)).ggg)))[0] { |
| default { |
| let vf279: u32 = pack4x8snorm(vec4f(unconst_f32(0.3181), unconst_f32(-0.2238), unconst_f32(0.1228), unconst_f32(0.4140))); |
| let vf280: u32 = pack4x8snorm(vec4f(unconst_f32(-0.1071), unconst_f32(0.2351), unconst_f32(-0.06115), unconst_f32(0.1490))); |
| let vf281: vec2h = min(vec2h(unconst_f16(-9703.9), unconst_f16(15542.2)), vec2h(unconst_f16(21107.7), unconst_f16(12483.6))); |
| out.f26 -= unpack4x8snorm(pack4x8snorm(vec4f(unconst_f32(0.3051), unconst_f32(0.2004), unconst_f32(0.3439), unconst_f32(0.01155)))); |
| var vf282: u32 = a0[unconst_u32(19)]; |
| let vf283: i32 = override16; |
| break; |
| _ = override16; |
| } |
| } |
| return out; |
| _ = override16; |
| } |
| |
| /* zero global variables used */ |
| @vertex |
| fn vertex12() -> VertexOutput11 { |
| var out: VertexOutput11; |
| let vf284: vec3h = atan2(vec3h(unconst_f16(19826.5), unconst_f16(3063.0), unconst_f16(9699.7)), vec3h(unconst_f16(511.1), unconst_f16(5678.7), unconst_f16(5086.6))); |
| switch vec3i(vf284)[2] { |
| default { |
| { |
| var vf285: i32 = dot4I8Packed(unconst_u32(199), unconst_u32(185)); |
| var vf286: vec4i = extractBits(vec4i(unpack2x16float(vec4u(step(vec4h(f16(countTrailingZeros(unconst_i32(114)))), vec4h(unconst_f16(5721.0), unconst_f16(7899.3), unconst_f16(7283.1), unconst_f16(38730.8)))).y).ggrr), unconst_u32(279), unconst_u32(926)); |
| out.f36 = vec4f(f32(override16)); |
| var vf287: i32 = countTrailingZeros(unconst_i32(-154)); |
| break; |
| _ = override16; |
| } |
| _ = override16; |
| } |
| } |
| out.f30 = vec2i(saturate(vec3h(unconst_f16(14644.6), unconst_f16(8815.6), unconst_f16(15548.9))).bg); |
| let vf288: vec3h = cross(vec3h(unconst_f16(38964.8), unconst_f16(21554.2), unconst_f16(11928.8)), vec3h(unconst_f16(-1790.4), unconst_f16(6753.4), unconst_f16(550.6))); |
| let vf289: i32 = override16; |
| let vf290: vec3u = max(vec3u(u32(trunc(unconst_f16(2581.2)))), vec3u(unconst_u32(151), unconst_u32(52), unconst_u32(155))); |
| out = VertexOutput11(sqrt(vec3h(unconst_f16(3116.6), unconst_f16(-12296.6), unconst_f16(4410.8))).r, vec2f(sqrt(vec3h(unconst_f16(3116.6), unconst_f16(-12296.6), unconst_f16(4410.8))).gg), vec2i(sqrt(vec3h(unconst_f16(3116.6), unconst_f16(-12296.6), unconst_f16(4410.8))).zz), vec2f(sqrt(vec3h(unconst_f16(3116.6), unconst_f16(-12296.6), unconst_f16(4410.8))).zz), vec4u(sqrt(vec3h(unconst_f16(3116.6), unconst_f16(-12296.6), unconst_f16(4410.8))).xzzz), vec4i(sqrt(vec3h(unconst_f16(3116.6), unconst_f16(-12296.6), unconst_f16(4410.8))).grrr), sqrt(vec3h(unconst_f16(3116.6), unconst_f16(-12296.6), unconst_f16(4410.8))).rb, vec2i(sqrt(vec3h(unconst_f16(3116.6), unconst_f16(-12296.6), unconst_f16(4410.8))).rb), vec4f(sqrt(vec3h(unconst_f16(3116.6), unconst_f16(-12296.6), unconst_f16(4410.8))).grrr), vec4i(sqrt(vec3h(unconst_f16(3116.6), unconst_f16(-12296.6), unconst_f16(4410.8))).rgrr), vec3f(sqrt(vec3h(unconst_f16(3116.6), unconst_f16(-12296.6), unconst_f16(4410.8))))[2]); |
| let vf291: vec3u = countLeadingZeros(vec3u(u32((unconst_bool(true) || bool(inverseSqrt(vec2h(countLeadingZeros(vec3u(unconst_u32(10), unconst_u32(15), unconst_u32(57))).zx)).g))))); |
| let vf292: f16 = sin(unconst_f16(9643.1)); |
| let vf293: u32 = pack4xU8(vec4u(unconst_u32(40), unconst_u32(145), unconst_u32(90), unconst_u32(102))); |
| out.f32 = vec4u(pack4x8snorm(vec4f(unconst_f32(0.00582), unconst_f32(0.1480), unconst_f32(0.2355), unconst_f32(0.3811)))); |
| var vf294: vec4f = exp2(vec4f(unconst_f32(-0.00565), unconst_f32(0.1497), unconst_f32(-0.1527), unconst_f32(0.09265))); |
| out.f34 = bitcast<vec2h>(vf294[unconst_u32(83)]); |
| var vf295: vec3h = cross(vec3h(unconst_f16(16189.7), unconst_f16(9660.2), unconst_f16(2466.9)), vec3h(unconst_f16(10276.3), unconst_f16(7415.7), unconst_f16(6420.5))); |
| while bool(exp2(vec4f(unconst_f32(0.1538), unconst_f32(-0.1250), unconst_f32(0.1936), unconst_f32(0.3704)))[1]) { |
| out = VertexOutput11(f16(distance(vec2f(unconst_f32(0.2537), unconst_f32(0.09032)), vec2f(unconst_f32(-0.3492), unconst_f32(0.06305)))), vec2f(distance(vec2f(unconst_f32(0.2537), unconst_f32(0.09032)), vec2f(unconst_f32(-0.3492), unconst_f32(0.06305)))), vec2i(bitcast<i32>(distance(vec2f(unconst_f32(0.2537), unconst_f32(0.09032)), vec2f(unconst_f32(-0.3492), unconst_f32(0.06305))))), vec2f(distance(vec2f(unconst_f32(0.2537), unconst_f32(0.09032)), vec2f(unconst_f32(-0.3492), unconst_f32(0.06305)))), vec4u(bitcast<u32>(distance(vec2f(unconst_f32(0.2537), unconst_f32(0.09032)), vec2f(unconst_f32(-0.3492), unconst_f32(0.06305))))), vec4i(i32(distance(vec2f(unconst_f32(0.2537), unconst_f32(0.09032)), vec2f(unconst_f32(-0.3492), unconst_f32(0.06305))))), bitcast<vec2h>(distance(vec2f(unconst_f32(0.2537), unconst_f32(0.09032)), vec2f(unconst_f32(-0.3492), unconst_f32(0.06305)))), vec2i(i32(distance(vec2f(unconst_f32(0.2537), unconst_f32(0.09032)), vec2f(unconst_f32(-0.3492), unconst_f32(0.06305))))), vec4f(distance(vec2f(unconst_f32(0.2537), unconst_f32(0.09032)), vec2f(unconst_f32(-0.3492), unconst_f32(0.06305)))), vec4i(bitcast<i32>(distance(vec2f(unconst_f32(0.2537), unconst_f32(0.09032)), vec2f(unconst_f32(-0.3492), unconst_f32(0.06305))))), distance(vec2f(unconst_f32(0.2537), unconst_f32(0.09032)), vec2f(unconst_f32(-0.3492), unconst_f32(0.06305)))); |
| let vf296: vec2i = extractBits(vec2i(unconst_i32(428), unconst_i32(93)), u32(dot4I8Packed(unconst_u32(31), unconst_u32(230))), unconst_u32(93)); |
| let vf297: vec4h = faceForward(vec4h(unconst_f16(21751.5), unconst_f16(42882.0), unconst_f16(3547.0), unconst_f16(11633.5)), vec4h(unconst_f16(54392.7), unconst_f16(9420.5), unconst_f16(13908.0), unconst_f16(16691.8)), vec4h(unconst_f16(29477.4), unconst_f16(20259.9), unconst_f16(9068.5), unconst_f16(-1126.6))); |
| let vf298: vec2i = extractBits(vec2i(unconst_i32(877), unconst_i32(112)), u32(vf296[unconst_u32(49)]), unconst_u32(31)); |
| out.f38 += vec3f((vec3f(unconst_f32(0.2958), unconst_f32(0.09016), unconst_f32(0.1296)) <= floor(vec2f(unconst_f32(0.1648), unconst_f32(0.01152))).xxx))[1]; |
| } |
| return out; |
| _ = override16; |
| } |
| |
| /* used global variables: st11 */ |
| @compute @workgroup_size(1, 1, 1) |
| fn compute13() { |
| let vf299: vec4h = normalize(vec4h(unconst_f16(60000.0), unconst_f16(12604.4), unconst_f16(16826.5), unconst_f16(24461.9))); |
| textureStore(st11, unconst_i32(196), vec4u(vec4u(unconst_u32(41), unconst_u32(16), unconst_u32(155), unconst_u32(121)))); |
| var vf300: vec2<bool> = (vec2f(unconst_f32(0.3951), unconst_f32(0.06366)) < vec2f(unconst_f32(0.2311), unconst_f32(-0.2759))); |
| var vf301: i32 = override16; |
| vf301 += insertBits(vec2i(unconst_i32(42), unconst_i32(74)), vec2i(unconst_i32(38), unconst_i32(-41)), unconst_u32(393), unconst_u32(29))[0]; |
| vf301 |= vec4i( !vec4<bool>(unconst_bool(true), unconst_bool(true), unconst_bool(false), unconst_bool(false)))[3]; |
| vf301 -= vec2i(vf300)[0]; |
| let ptr75: ptr<function, vec2<bool>> = &vf300; |
| vf301 = bitcast<i32>(pack4x8unorm(vec4f(unconst_f32(-0.1011), unconst_f32(0.1890), unconst_f32(0.2380), unconst_f32(0.1103)))); |
| _ = override16; |
| _ = st11; |
| }`, |
| }); |
| let buffer148 = device0.createBuffer({size: 43082, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let textureView222 = texture154.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 25}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder92); computePassEncoder92.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| computePassEncoder161.end(); |
| } catch {} |
| try { |
| computePassEncoder190.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderPassEncoder27.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder21.setPipeline(pipeline7); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 40, height: 45, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageBitmap1, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture84, |
| mipLevel: 0, |
| origin: {x: 6, y: 3, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext3.unconfigure(); |
| } catch {} |
| let bindGroup113 = device0.createBindGroup({layout: veryExplicitBindGroupLayout14, entries: [{binding: 21, resource: textureView60}]}); |
| let buffer149 = device0.createBuffer({size: 3360, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM}); |
| let computePassEncoder193 = commandEncoder168.beginComputePass({}); |
| try { |
| computePassEncoder146.setBindGroup(3, bindGroup62); |
| } catch {} |
| try { |
| computePassEncoder122.setBindGroup(3, bindGroup15, new Uint32Array(4630), 394, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder127); computePassEncoder127.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder191.setPipeline(pipeline1); |
| } catch {} |
| try { |
| computePassEncoder49.pushDebugGroup('\u04f8'); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture154, |
| mipLevel: 0, |
| origin: {x: 5, y: 4, z: 17}, |
| aspect: 'all', |
| }, new Uint8Array(5_724).fill(151), /* required buffer size: 5_724 */ |
| {offset: 0, bytesPerRow: 26, rowsPerImage: 220}, {width: 2, height: 1, depthOrArrayLayers: 2}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 615, height: 15, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData16, |
| origin: { x: 0, y: 1 }, |
| flipY: false, |
| }, { |
| texture: texture89, |
| mipLevel: 1, |
| origin: {x: 2, y: 1, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 3, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(0x55); }; |
| } catch {} |
| let autogeneratedBindGroupLayout7 = pipeline4.getBindGroupLayout(0); |
| let commandEncoder208 = device0.createCommandEncoder({}); |
| let textureView223 = texture58.createView({}); |
| let computePassEncoder194 = commandEncoder208.beginComputePass(); |
| let sampler120 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'repeat', addressModeW: 'repeat', lodMaxClamp: 94.55}); |
| try { |
| computePassEncoder194.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderPassEncoder17.beginOcclusionQuery(55); |
| } catch {} |
| try { |
| renderPassEncoder17.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder47.setPipeline(pipeline5); |
| } catch {} |
| try { |
| computePassEncoder70.popDebugGroup(); |
| } catch {} |
| try { |
| computePassEncoder132.insertDebugMarker('\u8927'); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 984, height: 1, depthOrArrayLayers: 140} |
| */ |
| { |
| source: imageData21, |
| origin: { x: 4, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture120, |
| mipLevel: 1, |
| origin: {x: 195, y: 0, z: 17}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let gpuCanvasContext5 = canvas2.getContext('webgpu'); |
| await gc(); |
| let bindGroup114 = device0.createBindGroup({layout: autogeneratedBindGroupLayout2, entries: [{binding: 144, resource: textureView97}]}); |
| let textureView224 = texture65.createView({dimension: '2d-array', baseMipLevel: 0}); |
| let sampler121 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeW: 'repeat', |
| minFilter: 'nearest', |
| lodMaxClamp: 76.42, |
| compare: 'always', |
| maxAnisotropy: 1, |
| }); |
| try { |
| computePassEncoder80.setBindGroup(1, bindGroup97, new Uint32Array(1834), 294, 0); |
| } catch {} |
| try { |
| computePassEncoder192.setPipeline(pipeline41); |
| } catch {} |
| try { |
| renderPassEncoder14.executeBundles([renderBundle8]); |
| } catch {} |
| try { |
| renderPassEncoder21.setBlendConstant({ r: 538.5, g: -167.1, b: -394.2, a: 753.8, }); |
| } catch {} |
| let bindGroup115 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout12, |
| entries: [ |
| {binding: 166, resource: {buffer: buffer65, offset: 512, size: 152}}, |
| {binding: 125, resource: textureView21}, |
| ], |
| }); |
| let commandEncoder209 = device0.createCommandEncoder(); |
| let texture289 = device0.createTexture({ |
| size: {width: 40}, |
| dimension: '1d', |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder195 = commandEncoder209.beginComputePass({}); |
| let externalTexture19 = device0.importExternalTexture({source: videoFrame20}); |
| try { |
| renderPassEncoder37.setBindGroup(0, bindGroup58); |
| } catch {} |
| try { |
| renderPassEncoder24.executeBundles([renderBundle12]); |
| } catch {} |
| try { |
| renderPassEncoder37.drawIndexed(8, 149, 11, -2_047_378_921, 569_277_789); |
| } catch {} |
| try { |
| renderPassEncoder37.drawIndexedIndirect(buffer89, 112); |
| } catch {} |
| let commandEncoder210 = device0.createCommandEncoder({}); |
| let texture290 = gpuCanvasContext4.getCurrentTexture(); |
| let textureView225 = texture116.createView({dimension: '2d-array'}); |
| let computePassEncoder196 = commandEncoder210.beginComputePass({}); |
| try { |
| computePassEncoder150.end(); |
| } catch {} |
| try { |
| computePassEncoder196.setPipeline(pipeline36); |
| } catch {} |
| try { |
| renderPassEncoder11.setBindGroup(1, bindGroup97); |
| } catch {} |
| try { |
| renderPassEncoder52.setBindGroup(3, bindGroup43, new Uint32Array(40), 3, 0); |
| } catch {} |
| try { |
| renderPassEncoder51.beginOcclusionQuery(459); |
| } catch {} |
| try { |
| renderPassEncoder51.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder37.draw(0, 75, 0, 1_757_927_516); |
| } catch {} |
| try { |
| renderPassEncoder37.drawIndexedIndirect(buffer21, 30_392); |
| } catch {} |
| try { |
| renderPassEncoder37.drawIndirect(buffer102, 1_892); |
| } catch {} |
| try { |
| renderPassEncoder17.setVertexBuffer(4, buffer37, 0, 1_583); |
| } catch {} |
| try { |
| commandEncoder65.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 268 */ |
| offset: 268, |
| bytesPerRow: 1024, |
| buffer: buffer48, |
| }, { |
| texture: texture175, |
| mipLevel: 0, |
| origin: {x: 3, y: 1, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder211 = device0.createCommandEncoder(); |
| let texture291 = device0.createTexture({ |
| size: [470, 2, 1], |
| mipLevelCount: 3, |
| sampleCount: 1, |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView226 = texture18.createView({}); |
| let renderPassEncoder60 = commandEncoder65.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView101, |
| clearValue: { r: 227.7, g: -958.8, b: -477.1, a: 278.8, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| }); |
| let sampler122 = device0.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'repeat', magFilter: 'nearest'}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder151); computePassEncoder151.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder147.end(); |
| } catch {} |
| try { |
| renderPassEncoder46.setBindGroup(2, bindGroup43, []); |
| } catch {} |
| try { |
| renderPassEncoder37.drawIndexed(28, 3, 5, 49_714_539, 724_293_540); |
| } catch {} |
| try { |
| renderPassEncoder57.setPipeline(pipeline10); |
| } catch {} |
| try { |
| renderPassEncoder20.setVertexBuffer(7, buffer145, 476, 1_070); |
| } catch {} |
| try { |
| commandEncoder211.copyTextureToTexture({ |
| texture: texture247, |
| mipLevel: 0, |
| origin: {x: 6, y: 12, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture119, |
| mipLevel: 0, |
| origin: {x: 124, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 4, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let commandEncoder212 = device0.createCommandEncoder({}); |
| let computePassEncoder197 = commandEncoder212.beginComputePass({}); |
| let sampler123 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeW: 'mirror-repeat', lodMaxClamp: 74.31}); |
| try { |
| computePassEncoder56.setBindGroup(3, bindGroup115, new Uint32Array(2204), 375, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder149); computePassEncoder149.dispatchWorkgroupsIndirect(buffer1, 3_008); }; |
| } catch {} |
| try { |
| computePassEncoder197.setPipeline(pipeline33); |
| } catch {} |
| try { |
| renderPassEncoder52.beginOcclusionQuery(20); |
| } catch {} |
| try { |
| renderPassEncoder52.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder37.draw(0, 115, 0, 2_092_110_602); |
| } catch {} |
| try { |
| renderPassEncoder37.drawIndexed(2, 54, 14, 576_862_989, 2_132_989_996); |
| } catch {} |
| try { |
| renderPassEncoder37.drawIndexedIndirect(buffer102, 3_140); |
| } catch {} |
| try { |
| renderPassEncoder37.drawIndirect(buffer119, 276); |
| } catch {} |
| try { |
| renderPassEncoder50.setVertexBuffer(4, buffer79); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| try { |
| buffer16.unmap(); |
| } catch {} |
| document.body.prepend(canvas0); |
| let texture292 = device0.createTexture({ |
| size: [492, 1, 31], |
| mipLevelCount: 3, |
| dimension: '3d', |
| format: 'rg8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView227 = texture130.createView({ |
| label: '\ua57a\u{1f719}\ue137\u8f33\u0190\u3e09\u{1feb1}\u06b4', |
| baseArrayLayer: 24, |
| arrayLayerCount: 29, |
| }); |
| let computePassEncoder198 = commandEncoder156.beginComputePass({}); |
| try { |
| renderPassEncoder56.executeBundles([renderBundle4]); |
| } catch {} |
| try { |
| renderPassEncoder37.drawIndexedIndirect(buffer117, 1_820); |
| } catch {} |
| try { |
| renderPassEncoder37.drawIndirect(buffer31, 328); |
| } catch {} |
| try { |
| renderPassEncoder47.setVertexBuffer(0, buffer117, 4_764, 5_151); |
| } catch {} |
| try { |
| buffer63.unmap(); |
| } catch {} |
| let veryExplicitBindGroupLayout26 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 78, |
| visibility: GPUShaderStage.COMPUTE, |
| texture: { viewDimension: '2d-array', sampleType: 'float', multisampled: false }, |
| }, |
| ], |
| }); |
| try { |
| computePassEncoder5.setBindGroup(0, bindGroup20, new Uint32Array(1152), 159, 0); |
| } catch {} |
| try { |
| computePassEncoder193.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder40.executeBundles([renderBundle12]); |
| } catch {} |
| try { |
| commandEncoder211.copyTextureToTexture({ |
| texture: texture116, |
| mipLevel: 0, |
| origin: {x: 56, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture116, |
| mipLevel: 0, |
| origin: {x: 68, y: 1, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 117, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer150 = device0.createBuffer({ |
| size: 8929, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder213 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder14.setBindGroup(2, bindGroup115, new Uint32Array(702), 143, 0); |
| } catch {} |
| try { |
| renderPassEncoder37.drawIndexed(0, 430, 11, 584_709_186, 297_190_770); |
| } catch {} |
| try { |
| renderPassEncoder37.drawIndexedIndirect(buffer93, 108); |
| } catch {} |
| try { |
| renderPassEncoder37.drawIndirect(buffer90, 664); |
| } catch {} |
| let bindGroup116 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout19, |
| entries: [{binding: 323, resource: {buffer: buffer12, offset: 4864}}, {binding: 144, resource: textureView145}], |
| }); |
| let buffer151 = device0.createBuffer({ |
| size: 21097, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let texture293 = device0.createTexture({ |
| size: {width: 32}, |
| dimension: '1d', |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView228 = texture45.createView({dimension: '2d-array'}); |
| try { |
| computePassEncoder129.setBindGroup(3, bindGroup72, new Uint32Array(1073), 141, 0); |
| } catch {} |
| try { |
| computePassEncoder186.setPipeline(pipeline41); |
| } catch {} |
| try { |
| renderPassEncoder48.beginOcclusionQuery(0); |
| } catch {} |
| try { |
| renderPassEncoder17.setBlendConstant({ r: -648.6, g: 558.2, b: -965.5, a: 173.2, }); |
| } catch {} |
| try { |
| renderPassEncoder37.drawIndexedIndirect(buffer102, 1_644); |
| } catch {} |
| try { |
| buffer19.unmap(); |
| } catch {} |
| try { |
| computePassEncoder49.popDebugGroup(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 40, height: 45, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData8, |
| origin: { x: 4, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture84, |
| mipLevel: 0, |
| origin: {x: 5, y: 6, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 2, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline46 = await device0.createComputePipelineAsync({layout: pipelineLayout2, compute: {module: shaderModule6, entryPoint: 'compute6', constants: {}}}); |
| let buffer152 = device0.createBuffer({ |
| size: 9610, |
| usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder214 = device0.createCommandEncoder({}); |
| let computePassEncoder199 = commandEncoder214.beginComputePass({}); |
| try { |
| computePassEncoder178.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder59.setBindGroup(1, bindGroup64, new Uint32Array(68), 23, 1); |
| } catch {} |
| try { |
| renderPassEncoder60.setScissorRect(4, 28, 12, 7); |
| } catch {} |
| try { |
| renderPassEncoder37.drawIndirect(buffer102, 8_260); |
| } catch {} |
| try { |
| commandEncoder211.copyBufferToBuffer(buffer149, 308, buffer121, 1288, 824); |
| } catch {} |
| let pipeline47 = await device0.createComputePipelineAsync({layout: pipelineLayout9, compute: {module: shaderModule2, constants: {}}}); |
| let recycledExplicitBindGroupLayout21 = pipeline7.getBindGroupLayout(0); |
| let buffer153 = device0.createBuffer({ |
| size: 1644, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder215 = device0.createCommandEncoder({}); |
| let textureView229 = texture178.createView({dimension: '2d-array', aspect: 'all', mipLevelCount: 1}); |
| let computePassEncoder200 = commandEncoder211.beginComputePass({}); |
| let sampler124 = device0.createSampler({addressModeU: 'repeat', lodMinClamp: 23.99}); |
| try { |
| renderPassEncoder54.setBindGroup(3, bindGroup75); |
| } catch {} |
| try { |
| renderPassEncoder48.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder37.drawIndexedIndirect(buffer89, 348); |
| } catch {} |
| try { |
| renderPassEncoder19.setIndexBuffer(buffer111, 'uint32', 4_792, 5_274); |
| } catch {} |
| try { |
| renderPassEncoder54.setPipeline(pipeline10); |
| } catch {} |
| let querySet29 = device0.createQuerySet({type: 'occlusion', count: 635}); |
| try { |
| computePassEncoder102.setBindGroup(1, bindGroup47, new Uint32Array(5858), 2_685, 0); |
| } catch {} |
| try { |
| renderPassEncoder37.draw(0, 230, 0, 430_025_407); |
| } catch {} |
| try { |
| renderPassEncoder56.setVertexBuffer(3, buffer135, 0, 181); |
| } catch {} |
| try { |
| commandEncoder213.resolveQuerySet(querySet21, 130, 0, buffer130, 0); |
| } catch {} |
| try { |
| commandEncoder215.insertDebugMarker('\uff0a'); |
| } catch {} |
| try { |
| gpuCanvasContext2.unconfigure(); |
| } catch {} |
| try { |
| if (!arrayBuffer15.detached) { new Uint8Array(arrayBuffer15).fill(0x55); }; |
| } catch {} |
| let texture294 = device0.createTexture({ |
| label: '\u5f58\u{1fc2c}\u4783\u1262\u0aaa\u72e7\u{1f94d}\u{1f80a}', |
| size: {width: 10, height: 11, depthOrArrayLayers: 8}, |
| dimension: '3d', |
| format: 'r8uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView230 = texture137.createView({dimension: '2d-array'}); |
| let computePassEncoder201 = commandEncoder213.beginComputePass({}); |
| let sampler125 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'repeat', addressModeW: 'clamp-to-edge', lodMaxClamp: 64.81}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder92); computePassEncoder92.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder59.setBindGroup(3, bindGroup91, new Uint32Array(1017), 187, 0); |
| } catch {} |
| try { |
| renderPassEncoder19.executeBundles([renderBundle1, renderBundle6]); |
| } catch {} |
| try { |
| renderPassEncoder37.draw(0, 278, 0, 1_275_364_033); |
| } catch {} |
| try { |
| renderPassEncoder37.drawIndexedIndirect(buffer87, 0); |
| } catch {} |
| try { |
| commandEncoder215.copyBufferToTexture({ |
| /* bytesInLastRow: 305 widthInBlocks: 305 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 1211 */ |
| offset: 1211, |
| bytesPerRow: 4608, |
| rowsPerImage: 172, |
| buffer: buffer42, |
| }, { |
| texture: texture62, |
| mipLevel: 1, |
| origin: {x: 100, y: 2, z: 0}, |
| aspect: 'all', |
| }, {width: 305, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer0, 68, new Int16Array(7014), 2936, 24); |
| } catch {} |
| let gpuCanvasContext6 = offscreenCanvas3.getContext('webgpu'); |
| let buffer154 = device0.createBuffer({size: 23853, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE}); |
| let commandEncoder216 = device0.createCommandEncoder({}); |
| let commandBuffer27 = commandEncoder216.finish(); |
| let computePassEncoder202 = commandEncoder215.beginComputePass({}); |
| try { |
| computePassEncoder199.setPipeline(pipeline39); |
| } catch {} |
| try { |
| renderPassEncoder14.setIndexBuffer(buffer13, 'uint32', 116, 239); |
| } catch {} |
| let pipeline48 = await device0.createRenderPipelineAsync({ |
| layout: pipelineLayout2, |
| fragment: { |
| module: shaderModule2, |
| targets: [{format: 'rg8unorm', writeMask: GPUColorWrite.GREEN | GPUColorWrite.RED}], |
| }, |
| vertex: { |
| module: shaderModule8, |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 28, |
| attributes: [{format: 'float32', offset: 0, shaderLocation: 13}, {format: 'unorm8x2', offset: 2, shaderLocation: 4}], |
| }, |
| ], |
| }, |
| primitive: {frontFace: 'cw', cullMode: 'back'}, |
| }); |
| let bindGroup117 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout9, |
| entries: [ |
| {binding: 323, resource: {buffer: buffer119, offset: 512, size: 872}}, |
| {binding: 144, resource: textureView145}, |
| ], |
| }); |
| try { |
| computePassEncoder129.end(); |
| } catch {} |
| try { |
| computePassEncoder200.setPipeline(pipeline11); |
| } catch {} |
| try { |
| renderPassEncoder52.setBindGroup(0, bindGroup25); |
| } catch {} |
| try { |
| renderPassEncoder48.setBindGroup(1, bindGroup106, new Uint32Array(2310), 692, 0); |
| } catch {} |
| try { |
| renderPassEncoder37.drawIndexed(3, 341, 23, 122_712_473, 392_719_039); |
| } catch {} |
| try { |
| renderPassEncoder37.drawIndexedIndirect(buffer126, 4_636); |
| } catch {} |
| try { |
| renderPassEncoder40.setPipeline(pipeline0); |
| } catch {} |
| try { |
| commandEncoder141.copyTextureToBuffer({ |
| texture: texture101, |
| mipLevel: 1, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 5 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 767 */ |
| offset: 767, |
| bytesPerRow: 15616, |
| buffer: buffer106, |
| }, {width: 5, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.append(img0); |
| let commandEncoder217 = device0.createCommandEncoder({}); |
| let computePassEncoder203 = commandEncoder141.beginComputePass({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder25); computePassEncoder25.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder54.setBlendConstant({ r: -280.4, g: -869.0, b: -185.8, a: 887.0, }); |
| } catch {} |
| try { |
| renderPassEncoder37.drawIndexed(1, 212, 9, -2_031_769_071, 1_136_214_681); |
| } catch {} |
| try { |
| renderPassEncoder37.drawIndexedIndirect(buffer12, 5_408); |
| } catch {} |
| try { |
| renderPassEncoder37.drawIndirect(buffer87, 168); |
| } catch {} |
| try { |
| renderPassEncoder27.setIndexBuffer(buffer97, 'uint16', 58, 1_324); |
| } catch {} |
| try { |
| renderPassEncoder42.setVertexBuffer(4, buffer152, 380, 5_622); |
| } catch {} |
| let pipeline49 = device0.createRenderPipeline({ |
| layout: pipelineLayout11, |
| fragment: { |
| module: shaderModule6, |
| constants: {}, |
| targets: [{ |
| format: 'rg8unorm', |
| blend: { |
| color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'}, |
| alpha: {operation: 'subtract', srcFactor: 'one', dstFactor: 'src-alpha'}, |
| }, |
| writeMask: GPUColorWrite.RED, |
| }], |
| }, |
| vertex: {module: shaderModule7, buffers: []}, |
| primitive: {topology: 'triangle-strip', frontFace: 'cw', cullMode: 'back'}, |
| }); |
| let bindGroup118 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout7, |
| entries: [ |
| {binding: 144, resource: textureView5}, |
| {binding: 323, resource: {buffer: buffer124, offset: 2304, size: 1240}}, |
| ], |
| }); |
| let commandEncoder218 = device0.createCommandEncoder(); |
| let texture295 = device0.createTexture({ |
| size: [246, 1, 35], |
| dimension: '3d', |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder204 = commandEncoder218.beginComputePass({}); |
| try { |
| computePassEncoder196.setBindGroup(0, bindGroup80); |
| } catch {} |
| try { |
| renderPassEncoder39.setBlendConstant({ r: -37.29, g: 293.0, b: 479.8, a: -645.0, }); |
| } catch {} |
| try { |
| renderPassEncoder37.draw(0, 29, 0, 853_033_683); |
| } catch {} |
| try { |
| commandEncoder217.copyBufferToTexture({ |
| /* bytesInLastRow: 1132 widthInBlocks: 283 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 2280 */ |
| offset: 2280, |
| bytesPerRow: 13056, |
| buffer: buffer69, |
| }, { |
| texture: texture141, |
| mipLevel: 0, |
| origin: {x: 31, y: 0, z: 1}, |
| aspect: 'all', |
| }, {width: 283, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let recycledExplicitBindGroupLayout22 = pipeline19.getBindGroupLayout(0); |
| let commandEncoder219 = device0.createCommandEncoder({}); |
| let texture296 = device0.createTexture({ |
| size: [32, 32, 204], |
| mipLevelCount: 1, |
| dimension: '3d', |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView231 = texture78.createView({dimension: '3d', format: 'r8uint', baseArrayLayer: 0, arrayLayerCount: 1}); |
| try { |
| computePassEncoder132.setBindGroup(1, bindGroup107, new Uint32Array(2072), 234, 0); |
| } catch {} |
| try { |
| computePassEncoder203.setPipeline(pipeline43); |
| } catch {} |
| try { |
| renderPassEncoder57.setBindGroup(1, bindGroup110, new Uint32Array(903), 66, 0); |
| } catch {} |
| try { |
| renderPassEncoder52.executeBundles([renderBundle4]); |
| } catch {} |
| try { |
| renderPassEncoder37.draw(0, 11, 0, 7_382_850); |
| } catch {} |
| try { |
| renderPassEncoder20.setIndexBuffer(buffer8, 'uint16', 2, 158); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer80, 188, new Float32Array(1051), 693, 132); |
| } catch {} |
| let pipeline50 = await promise24; |
| document.body.prepend(img3); |
| let imageBitmap3 = await createImageBitmap(videoFrame25); |
| let imageData26 = new ImageData(104, 72); |
| let commandEncoder220 = device0.createCommandEncoder(); |
| let textureView232 = texture295.createView({}); |
| let computePassEncoder205 = commandEncoder217.beginComputePass({}); |
| let renderBundleEncoder24 = device0.createRenderBundleEncoder({colorFormats: ['rg8unorm'], depthReadOnly: true, stencilReadOnly: true}); |
| let renderBundle24 = renderBundleEncoder24.finish({}); |
| let sampler126 = device0.createSampler({addressModeU: 'clamp-to-edge', lodMaxClamp: 63.99, maxAnisotropy: 1}); |
| try { |
| computePassEncoder103.setBindGroup(1, bindGroup47, new Uint32Array(1427), 140, 0); |
| } catch {} |
| try { |
| computePassEncoder201.setPipeline(pipeline43); |
| } catch {} |
| try { |
| renderPassEncoder37.end(); |
| } catch {} |
| try { |
| renderPassEncoder43.executeBundles([renderBundle4]); |
| } catch {} |
| try { |
| renderPassEncoder52.setIndexBuffer(buffer111, 'uint16', 7_104, 274); |
| } catch {} |
| try { |
| renderPassEncoder40.setPipeline(pipeline8); |
| } catch {} |
| try { |
| commandEncoder220.copyTextureToTexture({ |
| texture: texture91, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture91, |
| mipLevel: 0, |
| origin: {x: 0, y: 3, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 1, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup119 = device0.createBindGroup({layout: autogeneratedBindGroupLayout5, entries: [{binding: 144, resource: textureView2}]}); |
| let commandEncoder221 = device0.createCommandEncoder({}); |
| let texture297 = device0.createTexture({ |
| size: [153, 3, 1], |
| format: 'rg16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| computePassEncoder181.setBindGroup(3, bindGroup97, new Uint32Array(3580), 211, 0); |
| } catch {} |
| try { |
| computePassEncoder198.setPipeline(pipeline18); |
| } catch {} |
| try { |
| renderPassEncoder49.executeBundles([renderBundle17, renderBundle24, renderBundle3, renderBundle17, renderBundle12]); |
| } catch {} |
| try { |
| renderPassEncoder43.setPipeline(pipeline12); |
| } catch {} |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| try { |
| commandEncoder108.copyBufferToBuffer(buffer87, 84, buffer106, 580, 92); |
| } catch {} |
| try { |
| commandEncoder221.copyBufferToTexture({ |
| /* bytesInLastRow: 4 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 684 */ |
| offset: 684, |
| bytesPerRow: 49408, |
| buffer: buffer126, |
| }, { |
| texture: texture82, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 1}, |
| aspect: 'all', |
| }, {width: 2, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| await gc(); |
| let computePassEncoder206 = commandEncoder219.beginComputePass({}); |
| let renderPassEncoder61 = commandEncoder108.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView231, |
| depthSlice: 387, |
| clearValue: { r: 503.2, g: -379.6, b: 59.52, a: -924.0, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }, { |
| view: textureView138, |
| clearValue: { r: 518.6, g: 495.2, b: -672.6, a: -239.6, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet12, |
| }); |
| try { |
| computePassEncoder64.setBindGroup(1, bindGroup68, new Uint32Array(486), 469, 0); |
| } catch {} |
| try { |
| renderPassEncoder38.setBindGroup(1, bindGroup110); |
| } catch {} |
| try { |
| renderPassEncoder56.setVertexBuffer(5, buffer140, 472, 1_098); |
| } catch {} |
| try { |
| commandEncoder220.copyBufferToTexture({ |
| /* bytesInLastRow: 28 widthInBlocks: 28 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 1448 */ |
| offset: 1448, |
| bytesPerRow: 5632, |
| buffer: buffer120, |
| }, { |
| texture: texture123, |
| mipLevel: 0, |
| origin: {x: 24, y: 1, z: 0}, |
| aspect: 'all', |
| }, {width: 28, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| renderPassEncoder13.insertDebugMarker('\u7b77'); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let textureView233 = texture268.createView({mipLevelCount: 1, baseArrayLayer: 0}); |
| let computePassEncoder207 = commandEncoder221.beginComputePass(); |
| try { |
| computePassEncoder121.setBindGroup(3, bindGroup50); |
| } catch {} |
| try { |
| device0.pushErrorScope('out-of-memory'); |
| } catch {} |
| let commandEncoder222 = device0.createCommandEncoder({}); |
| let textureView234 = texture229.createView({}); |
| let computePassEncoder208 = commandEncoder222.beginComputePass({}); |
| try { |
| computePassEncoder107.setBindGroup(0, bindGroup47); |
| } catch {} |
| try { |
| computePassEncoder56.setBindGroup(1, bindGroup52, new Uint32Array(635), 17, 0); |
| } catch {} |
| try { |
| renderPassEncoder44.setBindGroup(3, bindGroup52, new Uint32Array(2088), 87, 0); |
| } catch {} |
| try { |
| renderPassEncoder36.setPipeline(pipeline20); |
| } catch {} |
| try { |
| gpuCanvasContext5.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| } catch {} |
| let canvas3 = document.createElement('canvas'); |
| let videoFrame26 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: true, matrix: 'fcc', primaries: 'smpte170m', transfer: 'bt1361ExtendedColourGamut'} }); |
| try { |
| canvas3.getContext('webgl2'); |
| } catch {} |
| let textureView235 = texture296.createView({dimension: '3d', baseArrayLayer: 0}); |
| let computePassEncoder209 = commandEncoder220.beginComputePass({}); |
| let sampler127 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 97.63, |
| }); |
| try { |
| computePassEncoder205.setPipeline(pipeline43); |
| } catch {} |
| try { |
| renderPassEncoder40.setBindGroup(1, bindGroup113); |
| } catch {} |
| try { |
| renderPassEncoder46.setBindGroup(3, bindGroup27, new Uint32Array(578), 92, 0); |
| } catch {} |
| try { |
| renderPassEncoder14.setVertexBuffer(0, buffer100, 0, 1_356); |
| } catch {} |
| document.body.prepend(img4); |
| let commandEncoder223 = device0.createCommandEncoder(); |
| let texture298 = device0.createTexture({ |
| size: {width: 940, height: 5, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let renderPassEncoder62 = commandEncoder223.beginRenderPass({ |
| colorAttachments: [{view: textureView231, depthSlice: 54, loadOp: 'clear', storeOp: 'discard'}, {view: textureView138, loadOp: 'load', storeOp: 'store'}], |
| }); |
| let sampler128 = device0.createSampler({addressModeW: 'repeat', magFilter: 'nearest'}); |
| try { |
| buffer75.unmap(); |
| } catch {} |
| let bindGroup120 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout21, |
| entries: [ |
| {binding: 34, resource: textureView96}, |
| {binding: 73, resource: sampler84}, |
| {binding: 133, resource: {buffer: buffer133, offset: 256}}, |
| {binding: 430, resource: sampler99}, |
| ], |
| }); |
| let sampler129 = device0.createSampler({addressModeV: 'mirror-repeat', compare: 'less'}); |
| try { |
| computePassEncoder60.setBindGroup(2, bindGroup109, new Uint32Array(442), 173, 1); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder29); computePassEncoder29.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder61.setPipeline(pipeline29); |
| } catch {} |
| let shaderModule12 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| diagnostic(info, xyz); |
| |
| requires pointer_composite_access; |
| |
| override override19: i32; |
| |
| override override26 = false; |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| @id(52866) override override20: f32; |
| |
| struct VertexOutput12 { |
| @builtin(position) f39: vec4f, |
| } |
| |
| @group(0) @binding(166) var<uniform> buffer155: u32; |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| struct FragmentOutput8 { |
| @builtin(frag_depth) f0: f32, |
| @location(2) @interpolate(flat, centroid) f1: vec4f, |
| @location(0) @interpolate(flat) f2: vec4u, |
| } |
| |
| override override22: i32; |
| |
| struct S9 { |
| @builtin(local_invocation_id) @size(16) f0: vec3u, |
| } |
| |
| override override21: u32; |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| struct S8 { |
| @location(6) f0: i32, |
| } |
| |
| @group(0) @binding(125) var st12: texture_storage_2d_array<r32float, read_write>; |
| |
| var<workgroup> vw40: VertexOutput12; |
| |
| override override25 = 0.04430; |
| |
| @id(5098) override override23: f16 = 946.3; |
| |
| struct T0 { |
| f0: vec2h, |
| } |
| |
| struct S7 { |
| @location(14) f0: vec2i, |
| @location(11) @interpolate(flat, centroid) f1: f16, |
| @location(8) @interpolate(perspective, sample) f2: vec2f, |
| } |
| |
| @id(36360) override override27 = 0.4869; |
| |
| @id(27282) override override17: f16; |
| |
| @id(23879) override override24: f16 = -6598.6; |
| |
| @id(17693) override override18 = true; |
| |
| /* used global variables: buffer155, st12 */ |
| fn fn0(a0: ptr<storage, array<vec2<bool>>, read>, a1: array<vec2u, 1>) -> array<f16, 1> { |
| var out: array<f16, 1>; |
| let ptr76: ptr<uniform, u32> = &(*&buffer155); |
| let vf302: vec2u = a1[0]; |
| textureStore(st12, extractBits(vec2i(i32(pack4xU8(vec4u(unconst_u32(67), unconst_u32(17), unconst_u32(34), unconst_u32(79))))), unconst_u32(273), unconst_u32(279)), unconst_i32(4), vec4f(textureLoad(st12, vec2i(unconst_i32(12), unconst_i32(103)), bitcast<i32>(pack2x16snorm(vec2f(unconst_f32(0.00123), unconst_f32(0.1738))))))); |
| if bool(pack2x16unorm(vec2f(unconst_f32(0.2157), unconst_f32(0.1308)))) { |
| textureStore(st12, vec2i(unconst_i32(54), unconst_i32(201)), unconst_i32(223), vec4f(vec4f(unconst_f32(-0.2313), unconst_f32(0.3949), unconst_f32(-0.1348), unconst_f32(0.3833)))); |
| out[unconst_u32(15)] = vec2h((*a0)[arrayLength(&(*a0))])[0]; |
| var vf303: i32 = override22; |
| out[unconst_u32(88)] = f16((vec2i(unconst_i32(7), unconst_i32(232)) - unconst_i32(-88))[0]); |
| let ptr77: ptr<uniform, u32> = &buffer155; |
| let vf304: vec4<bool> = (vec4h(unconst_f16(15957.0), unconst_f16(12889.5), unconst_f16(2308.5), unconst_f16(397.6)) != vec4h(unconst_f16(4445.3), unconst_f16(11298.6), unconst_f16(14205.0), unconst_f16(769.3))); |
| out[unconst_u32(613)] = f16(all((vec4h(unconst_f16(5468.4), unconst_f16(2945.0), unconst_f16(17599.7), unconst_f16(20365.2)) != vec4h(unconst_f16(15325.1), unconst_f16(-8317.5), unconst_f16(11385.4), unconst_f16(7276.3))))); |
| _ = override22; |
| _ = buffer155; |
| _ = st12; |
| } |
| textureStore(st12, vec2i(unconst_i32(-4), unconst_i32(50)), bitcast<vec4i>(ceil(vec4f(unconst_f32(0.5666), unconst_f32(0.3783), unconst_f32(0.3281), unconst_f32(-0.2463)))).y, vec4f(vec4f(unconst_f32(0.05313), unconst_f32(0.3179), unconst_f32(0.01458), unconst_f32(0.1671)))); |
| let ptr78: ptr<storage, vec2<bool>, read> = &(*a0)[unconst_u32(325)]; |
| let vf305: vec2f = unpack2x16float(unconst_u32(619)); |
| var vf306: u32 = vf302[unconst_u32(115)]; |
| let ptr79: ptr<uniform, u32> = &(*ptr76); |
| let ptr80: ptr<function, u32> = &vf306; |
| return out; |
| _ = override22; |
| _ = st12; |
| _ = buffer155; |
| } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| /* zero global variables used */ |
| @vertex @must_use |
| fn vertex13(a0: S7, a1: S8, @location(4) a2: vec4i, @location(7) @interpolate(flat, either) a3: i32, @location(2) @interpolate(flat, sample) a4: vec2i, @location(9) @interpolate(flat) a5: vec2u, @location(15) a6: vec4u, @location(10) a7: vec4u, @location(0) @interpolate(flat, centroid) a8: vec4u, @location(12) a9: u32, @location(13) @interpolate(linear) a10: vec2h) -> VertexOutput12 { |
| var out: VertexOutput12; |
| var vf307: vec4f = log(vec4f(unconst_f32(0.1119), unconst_f32(-0.1158), unconst_f32(0.4750), unconst_f32(0.7946))); |
| var vf308: i32 = a4[unconst_u32(54)]; |
| var vf309: bool = override18; |
| let vf310: i32 = a4[unconst_u32(62)]; |
| return out; |
| _ = override18; |
| } |
| |
| /* zero global variables used */ |
| @fragment |
| fn fragment9() -> FragmentOutput8 { |
| var out: FragmentOutput8; |
| out.f2 |= unpack4xU8(pack4xU8(vec4u(unconst_u32(253), unconst_u32(190), unconst_u32(83), unconst_u32(535)))); |
| var vf311: mat3x4f = (mat3x4f(unconst_f32(0.06248), unconst_f32(0.2264), unconst_f32(0.00227), unconst_f32(0.1877), unconst_f32(0.3191), unconst_f32(0.1000), unconst_f32(0.4797), unconst_f32(0.3206), unconst_f32(0.07241), unconst_f32(0.2231), unconst_f32(0.2616), unconst_f32(0.1943)) + mat3x4f(vec4f(step(bitcast<vec2h>(dot4U8Packed(unconst_u32(48), unconst_u32(189))), vec2h(unconst_f16(2324.0), unconst_f16(5007.3))).rrgg), vec4f(step(bitcast<vec2h>(dot4U8Packed(unconst_u32(48), unconst_u32(189))), vec2h(unconst_f16(2324.0), unconst_f16(5007.3))).rgrr), vec4f(step(bitcast<vec2h>(dot4U8Packed(unconst_u32(48), unconst_u32(189))), vec2h(unconst_f16(2324.0), unconst_f16(5007.3))).xyxy))); |
| var vf312: vec4u = extractBits(vec4u(unconst_u32(65), unconst_u32(226), unconst_u32(71), unconst_u32(112)), unconst_u32(69), unconst_u32(355)); |
| return out; |
| } |
| |
| /* used global variables: buffer155, st12 */ |
| @compute @workgroup_size(3, 1, 2) |
| fn compute14(a0: S9) { |
| var vf313: bool = override26; |
| vf313 = bool(vw40.f39[0]); |
| let vf314: vec4f = acos(vec4f(unconst_f32(0.01991), unconst_f32(0.4109), unconst_f32(0.01736), unconst_f32(-0.1122))); |
| var vf315: u32 = textureNumLayers(st12); |
| let vf316: f16 = override23; |
| vf313 = bool(buffer155); |
| loop { |
| textureStore(st12, vec2i(unconst_i32(173), unconst_i32(529)), unconst_i32(-313), vec4f(vec4f(unconst_f32(0.01171), unconst_f32(0.06891), unconst_f32(0.03731), unconst_f32(0.3261)))); |
| let vf317: f16 = acos(f16(override20)); |
| break; |
| _ = override20; |
| _ = st12; |
| } |
| workgroupBarrier(); |
| var vf318: u32 = pack2x16unorm(vec2f(unconst_f32(-0.04106), unconst_f32(0.2015))); |
| vf315 = bitcast<vec2u>(step(vec2f(unconst_f32(0.03479), unconst_f32(0.01126)), vec2f(unconst_f32(0.1782), unconst_f32(0.7855)))).y; |
| var vf319: vec2h = tanh(vec2h(unconst_f16(5937.2), unconst_f16(6579.3))); |
| textureBarrier(); |
| let ptr81: ptr<workgroup, VertexOutput12> = &(*&vw40); |
| let vf320: f32 = override27; |
| textureStore(st12, vec2i(unconst_i32(302), unconst_i32(124)), unconst_i32(648), vec4f(vec4f(unconst_f32(0.07655), unconst_f32(0.1113), unconst_f32(0.08207), unconst_f32(0.1417)))); |
| _ = override20; |
| _ = override27; |
| _ = override23; |
| _ = override26; |
| _ = buffer155; |
| _ = st12; |
| }`, |
| }); |
| let bindGroup121 = device0.createBindGroup({ |
| layout: veryExplicitBindGroupLayout13, |
| entries: [ |
| {binding: 39, resource: {buffer: buffer98, offset: 5376, size: 4324}}, |
| {binding: 41, resource: textureView53}, |
| ], |
| }); |
| let buffer156 = device0.createBuffer({size: 29128, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM}); |
| let commandEncoder224 = device0.createCommandEncoder({}); |
| let querySet30 = device0.createQuerySet({type: 'occlusion', count: 371}); |
| let computePassEncoder210 = commandEncoder224.beginComputePass({label: '\u2f0e\u2c8f\u8daf\u801f\u0764\u4889'}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder119); computePassEncoder119.dispatchWorkgroupsIndirect(buffer131, 768); }; |
| } catch {} |
| try { |
| renderPassEncoder59.setViewport(949.2924912788644, 0.4140345197566826, 819.4688392428487, 0.4071303937020217, 0.617213433441621, 0.8030020285334046); |
| } catch {} |
| try { |
| renderPassEncoder51.setVertexBuffer(0, buffer32, 0); |
| } catch {} |
| try { |
| gpuCanvasContext6.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'srgb', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let bindGroup122 = device0.createBindGroup({layout: veryExplicitBindGroupLayout19, entries: [{binding: 44, resource: textureView218}]}); |
| let commandEncoder225 = device0.createCommandEncoder({}); |
| let texture299 = device0.createTexture({ |
| size: {width: 1968}, |
| dimension: '1d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder211 = commandEncoder225.beginComputePass({}); |
| try { |
| computePassEncoder180.setBindGroup(1, bindGroup115, new Uint32Array(48), 5, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| computePassEncoder209.setPipeline(pipeline44); |
| } catch {} |
| try { |
| renderPassEncoder53.executeBundles([renderBundle12, renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder58.setPipeline(pipeline8); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 470, height: 2, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData9, |
| origin: { x: 2, y: 4 }, |
| flipY: false, |
| }, { |
| texture: texture45, |
| mipLevel: 0, |
| origin: {x: 72, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer157 = device0.createBuffer({ |
| size: 6317, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM, |
| }); |
| let commandEncoder226 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder49.setBindGroup(0, bindGroup68); |
| } catch {} |
| try { |
| computePassEncoder204.setPipeline(pipeline11); |
| } catch {} |
| try { |
| renderPassEncoder10.setBindGroup(0, bindGroup5); |
| } catch {} |
| try { |
| renderPassEncoder36.setBindGroup(1, bindGroup102, new Uint32Array(2132), 28, 0); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| colorSpace: 'display-p3', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| await gc(); |
| let videoFrame27 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt470bg', primaries: 'bt470m', transfer: 'log'} }); |
| let buffer158 = device0.createBuffer({size: 14032, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let commandEncoder227 = device0.createCommandEncoder({}); |
| let texture300 = device0.createTexture({ |
| size: [492, 1, 58], |
| mipLevelCount: 4, |
| dimension: '3d', |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView236 = texture147.createView({label: '\u88be\u1065\u0697\u{1fdfb}', dimension: '2d-array', baseArrayLayer: 0}); |
| let computePassEncoder212 = commandEncoder226.beginComputePass(); |
| try { |
| computePassEncoder170.setBindGroup(3, bindGroup1, new Uint32Array(6853), 4_145, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder26); computePassEncoder26.dispatchWorkgroupsIndirect(buffer97, 708); }; |
| } catch {} |
| try { |
| computePassEncoder202.setPipeline(pipeline3); |
| } catch {} |
| let arrayBuffer31 = buffer72.getMappedRange(0, 0); |
| await gc(); |
| let bindGroup123 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout21, |
| entries: [ |
| {binding: 144, resource: textureView97}, |
| {binding: 323, resource: {buffer: buffer152, offset: 3072, size: 2704}}, |
| ], |
| }); |
| let texture301 = device0.createTexture({ |
| size: [20, 22, 1], |
| sampleCount: 1, |
| format: 'depth24plus-stencil8', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder213 = commandEncoder227.beginComputePass({}); |
| try { |
| computePassEncoder110.setBindGroup(2, bindGroup119, new Uint32Array(2936), 520, 0); |
| } catch {} |
| try { |
| computePassEncoder211.setPipeline(pipeline47); |
| } catch {} |
| try { |
| renderPassEncoder48.setIndexBuffer(buffer56, 'uint16', 342, 562); |
| } catch {} |
| try { |
| computePassEncoder208.setPipeline(pipeline13); |
| } catch {} |
| try { |
| adapter1.label = '\u0b53\u0aa9\u0e3e\u0b6d'; |
| } catch {} |
| let bindGroup124 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout16, |
| entries: [ |
| {binding: 323, resource: {buffer: buffer32, offset: 2560, size: 2652}}, |
| {binding: 144, resource: textureView2}, |
| ], |
| }); |
| let commandEncoder228 = device0.createCommandEncoder(); |
| let computePassEncoder214 = commandEncoder228.beginComputePass({}); |
| try { |
| computePassEncoder132.setBindGroup(3, bindGroup103); |
| } catch {} |
| try { |
| renderPassEncoder10.setBindGroup(0, bindGroup117, new Uint32Array(2008), 117, 0); |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let autogeneratedBindGroupLayout8 = pipeline4.getBindGroupLayout(0); |
| let buffer159 = device0.createBuffer({ |
| size: 10408, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder229 = device0.createCommandEncoder({}); |
| let texture302 = device0.createTexture({ |
| size: {width: 153, height: 3, depthOrArrayLayers: 1}, |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder189.setBindGroup(0, bindGroup82); |
| } catch {} |
| try { |
| computePassEncoder196.setBindGroup(1, bindGroup92, new Uint32Array(1789), 249, 0); |
| } catch {} |
| try { |
| computePassEncoder212.setPipeline(pipeline47); |
| } catch {} |
| try { |
| renderPassEncoder19.setBindGroup(2, bindGroup62, new Uint32Array(940), 12, 0); |
| } catch {} |
| try { |
| renderPassEncoder61.setIndexBuffer(buffer66, 'uint16', 4_470, 3_951); |
| } catch {} |
| try { |
| renderPassEncoder11.setPipeline(pipeline42); |
| } catch {} |
| try { |
| renderPassEncoder44.setVertexBuffer(0, buffer13, 0, 278); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 470, height: 2, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageBitmap3, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture45, |
| mipLevel: 0, |
| origin: {x: 106, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer160 = device0.createBuffer({size: 11414, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX}); |
| let commandEncoder230 = device0.createCommandEncoder({}); |
| let querySet31 = device0.createQuerySet({type: 'occlusion', count: 1288}); |
| let computePassEncoder215 = commandEncoder229.beginComputePass({}); |
| let sampler130 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 78.02, |
| }); |
| try { |
| computePassEncoder66.setBindGroup(3, bindGroup97); |
| } catch {} |
| try { |
| computePassEncoder176.setBindGroup(0, bindGroup110, new Uint32Array(1552), 102, 0); |
| } catch {} |
| try { |
| computePassEncoder206.setPipeline(pipeline16); |
| } catch {} |
| try { |
| renderPassEncoder43.setBindGroup(1, bindGroup11); |
| } catch {} |
| try { |
| renderPassEncoder57.setVertexBuffer(3, buffer105, 0, 815); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture295, |
| mipLevel: 0, |
| origin: {x: 19, y: 0, z: 11}, |
| aspect: 'all', |
| }, new Uint8Array(145_406).fill(242), /* required buffer size: 145_406 */ |
| {offset: 254, bytesPerRow: 288, rowsPerImage: 252}, {width: 58, height: 0, depthOrArrayLayers: 3}); |
| } catch {} |
| let veryExplicitBindGroupLayout27 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 2, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let bindGroup125 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout1, |
| entries: [ |
| {binding: 144, resource: textureView145}, |
| {binding: 323, resource: {buffer: buffer84, offset: 3072, size: 4812}}, |
| ], |
| }); |
| let buffer161 = device0.createBuffer({ |
| size: 8873, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder231 = device0.createCommandEncoder({label: '\ud9a8\u{1f743}\uedd3\u009d\u0c95\u0148\u{1f9a2}'}); |
| let querySet32 = device0.createQuerySet({type: 'occlusion', count: 114}); |
| try { |
| computePassEncoder7.setBindGroup(1, bindGroup67); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder0); computePassEncoder0.dispatchWorkgroups(1, 2); }; |
| } catch {} |
| try { |
| computePassEncoder25.end(); |
| } catch {} |
| try { |
| computePassEncoder210.setPipeline(pipeline19); |
| } catch {} |
| try { |
| renderPassEncoder53.setBindGroup(0, bindGroup99, new Uint32Array(3277), 341, 0); |
| } catch {} |
| try { |
| renderPassEncoder53.drawIndirect(buffer87, 216); |
| } catch {} |
| try { |
| renderPassEncoder62.setPipeline(pipeline29); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer53, 32, new BigUint64Array(56002), 4107, 32); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 20, height: 22, depthOrArrayLayers: 17} |
| */ |
| { |
| source: img2, |
| origin: { x: 4, y: 1 }, |
| flipY: true, |
| }, { |
| texture: texture236, |
| mipLevel: 2, |
| origin: {x: 0, y: 1, z: 1}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let videoFrame28 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-ncl', primaries: 'bt470m', transfer: 'bt2020_10bit'} }); |
| let bindGroup126 = device0.createBindGroup({ |
| layout: autogeneratedBindGroupLayout8, |
| entries: [ |
| {binding: 323, resource: {buffer: buffer86, offset: 4608, size: 12720}}, |
| {binding: 144, resource: textureView97}, |
| ], |
| }); |
| let commandEncoder232 = device0.createCommandEncoder({}); |
| let texture303 = device0.createTexture({ |
| size: {width: 80}, |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_SRC, |
| }); |
| try { |
| renderPassEncoder45.executeBundles([renderBundle4, renderBundle24]); |
| } catch {} |
| try { |
| renderPassEncoder62.setPipeline(pipeline29); |
| } catch {} |
| let bindGroup127 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout3, |
| entries: [ |
| {binding: 323, resource: {buffer: buffer5, offset: 2304, size: 984}}, |
| {binding: 144, resource: textureView4}, |
| ], |
| }); |
| let textureView237 = texture220.createView({mipLevelCount: 1, baseArrayLayer: 0}); |
| let computePassEncoder216 = commandEncoder29.beginComputePass({}); |
| let externalTexture20 = device0.importExternalTexture({source: videoFrame26}); |
| try { |
| renderPassEncoder53.drawIndexed(1_161, 55, 1_181, 226_415_161, 122_959_359); |
| } catch {} |
| try { |
| renderPassEncoder53.drawIndexedIndirect(buffer69, 256); |
| } catch {} |
| try { |
| renderPassEncoder59.setVertexBuffer(1, undefined, 0, 215_313_450); |
| } catch {} |
| try { |
| if (!arrayBuffer18.detached) { new Uint8Array(arrayBuffer18).fill(0x55); }; |
| } catch {} |
| document.body.prepend(canvas0); |
| let veryExplicitBindGroupLayout28 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 2, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let bindGroup128 = device0.createBindGroup({ |
| layout: recycledExplicitBindGroupLayout7, |
| entries: [{binding: 323, resource: {buffer: buffer68, offset: 1024}}, {binding: 144, resource: textureView97}], |
| }); |
| let computePassEncoder217 = commandEncoder230.beginComputePass({}); |
| try { |
| computePassEncoder191.setBindGroup(1, bindGroup105, new Uint32Array(8161), 102, 0); |
| } catch {} |
| try { |
| computePassEncoder216.setPipeline(pipeline41); |
| } catch {} |
| try { |
| renderPassEncoder53.end(); |
| } catch {} |
| try { |
| renderPassEncoder54.setViewport(18.009962214854784, 0.8440206225266744, 106.25593715203586, 0.023101474858522212, 0.4255724220607108, 0.741590832913253); |
| } catch {} |
| try { |
| renderPassEncoder58.setIndexBuffer(buffer141, 'uint32', 220, 253); |
| } catch {} |
| try { |
| commandEncoder179.resolveQuerySet(querySet32, 3, 7, buffer77, 2048); |
| } catch {} |
| let texture304 = device0.createTexture({ |
| size: [940], |
| dimension: '1d', |
| format: 'r8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView238 = texture67.createView({aspect: 'all'}); |
| let renderPassEncoder63 = commandEncoder231.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView134, |
| depthSlice: 19, |
| clearValue: { r: 367.0, g: -607.7, b: 188.1, a: 31.84, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| computePassEncoder98.setBindGroup(0, bindGroup118, []); |
| } catch {} |
| try { |
| computePassEncoder207.setPipeline(pipeline23); |
| } catch {} |
| try { |
| renderPassEncoder60.setBindGroup(2, bindGroup57); |
| } catch {} |
| try { |
| commandEncoder179.copyBufferToTexture({ |
| /* bytesInLastRow: 8 widthInBlocks: 4 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 1228 */ |
| offset: 1228, |
| bytesPerRow: 4096, |
| buffer: buffer64, |
| }, { |
| texture: texture136, |
| mipLevel: 0, |
| origin: {x: 10, y: 18, z: 0}, |
| aspect: 'all', |
| }, {width: 4, height: 6, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 40, height: 45, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData1, |
| origin: { x: 7, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture84, |
| mipLevel: 0, |
| origin: {x: 10, y: 23, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let pipeline51 = await device0.createRenderPipelineAsync({ |
| layout: 'auto', |
| fragment: { |
| module: shaderModule7, |
| targets: [{ |
| format: 'r8uint', |
| writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED, |
| }, {format: 'r8sint'}], |
| }, |
| vertex: { |
| module: shaderModule0, |
| buffers: [ |
| { |
| arrayStride: 0, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'uint8x4', offset: 160, shaderLocation: 13}, |
| {format: 'uint32x4', offset: 100, shaderLocation: 0}, |
| ], |
| }, |
| ], |
| }, |
| primitive: {topology: 'line-strip', stripIndexFormat: 'uint32', frontFace: 'cw', cullMode: 'back'}, |
| }); |
| let buffer162 = device0.createBuffer({size: 1766, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let texture305 = device0.createTexture({ |
| size: {width: 4824, height: 20, depthOrArrayLayers: 1}, |
| mipLevelCount: 4, |
| format: 'astc-12x10-unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| try { |
| renderPassEncoder39.setBindGroup(1, bindGroup19, new Uint32Array(3824), 651, 0); |
| } catch {} |
| try { |
| renderPassEncoder19.setVertexBuffer(2, buffer96); |
| } catch {} |
| try { |
| commandEncoder179.copyTextureToBuffer({ |
| texture: texture26, |
| mipLevel: 0, |
| origin: {x: 4, y: 6, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 16 widthInBlocks: 8 aspectSpecificFormat.texelBlockSize: 2 */ |
| /* end: 1996 */ |
| offset: 1996, |
| bytesPerRow: 43520, |
| buffer: buffer66, |
| }, {width: 8, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup129 = device0.createBindGroup({ |
| label: '\u0ad7\u0553\u34fd\u0119\u0326\u{1fdb7}', |
| layout: veryExplicitBindGroupLayout10, |
| entries: [ |
| {binding: 64, resource: {buffer: buffer119, offset: 256, size: 496}}, |
| {binding: 45, resource: {buffer: buffer126, offset: 6656}}, |
| {binding: 68, resource: {buffer: buffer37, offset: 2560, size: 1372}}, |
| {binding: 97, resource: externalTexture12}, |
| ], |
| }); |
| let sampler131 = device0.createSampler({magFilter: 'linear', minFilter: 'linear', mipmapFilter: 'linear', maxAnisotropy: 10}); |
| try { |
| device0.queue.writeBuffer(buffer116, 24, new BigUint64Array(3017), 26, 0); |
| } catch {} |
| let texture306 = device0.createTexture({ |
| size: {width: 615, height: 15, depthOrArrayLayers: 1}, |
| format: 'depth24plus-stencil8', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView239 = texture225.createView({mipLevelCount: 1, arrayLayerCount: 1}); |
| let computePassEncoder218 = commandEncoder179.beginComputePass({}); |
| let sampler132 = device0.createSampler({addressModeU: 'clamp-to-edge', minFilter: 'linear', lodMaxClamp: 96.03}); |
| try { |
| computePassEncoder111.setBindGroup(1, bindGroup58, []); |
| } catch {} |
| try { |
| renderPassEncoder42.setBindGroup(1, bindGroup92); |
| } catch {} |
| try { |
| renderPassEncoder17.setBindGroup(3, bindGroup125, new Uint32Array(2316), 1_293, 0); |
| } catch {} |
| try { |
| renderPassEncoder42.drawIndexedIndirect(buffer131, 2_548); |
| } catch {} |
| try { |
| gpuCanvasContext3.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| } catch {} |
| let pipeline52 = device0.createComputePipeline({layout: pipelineLayout9, compute: {module: shaderModule5, entryPoint: 'compute4'}}); |
| try { |
| gpuCanvasContext6.unconfigure(); |
| } catch {} |
| let commandEncoder233 = device0.createCommandEncoder({}); |
| let texture307 = device0.createTexture({ |
| size: {width: 10, height: 11, depthOrArrayLayers: 4}, |
| format: 'rg16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView240 = texture52.createView({aspect: 'all'}); |
| try { |
| computePassEncoder83.setBindGroup(2, bindGroup102); |
| } catch {} |
| try { |
| renderPassEncoder10.setBindGroup(2, bindGroup113); |
| } catch {} |
| try { |
| renderPassEncoder14.setBindGroup(2, bindGroup71, new Uint32Array(420), 10, 0); |
| } catch {} |
| try { |
| renderPassEncoder42.draw(600, 44, 250_212_836, 1_908_996_446); |
| } catch {} |
| try { |
| renderPassEncoder42.drawIndexed(35, 9, 104, 175_325_256, 86_248_662); |
| } catch {} |
| try { |
| renderPassEncoder42.drawIndirect(buffer144, 140); |
| } catch {} |
| try { |
| commandEncoder232.copyBufferToBuffer(buffer20, 1152, buffer65, 696, 180); |
| } catch {} |
| let buffer163 = device0.createBuffer({ |
| label: '\u{1fac3}\ubf75\uae6b\u{1f85f}', |
| size: 5563, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder234 = device0.createCommandEncoder({}); |
| let texture308 = device0.createTexture({size: [153], dimension: '1d', format: 'r8sint', usage: GPUTextureUsage.TEXTURE_BINDING}); |
| try { |
| computePassEncoder88.setBindGroup(2, bindGroup54, []); |
| } catch {} |
| try { |
| renderPassEncoder42.end(); |
| } catch {} |
| try { |
| renderPassEncoder19.setPipeline(pipeline31); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 80, height: 90, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame23, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture128, |
| mipLevel: 0, |
| origin: {x: 3, y: 5, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| videoFrame0.close(); |
| videoFrame1.close(); |
| videoFrame2.close(); |
| videoFrame3.close(); |
| videoFrame4.close(); |
| videoFrame5.close(); |
| videoFrame8.close(); |
| videoFrame9.close(); |
| videoFrame10.close(); |
| videoFrame11.close(); |
| videoFrame12.close(); |
| videoFrame13.close(); |
| videoFrame14.close(); |
| videoFrame17.close(); |
| videoFrame18.close(); |
| videoFrame20.close(); |
| videoFrame21.close(); |
| videoFrame22.close(); |
| videoFrame23.close(); |
| videoFrame24.close(); |
| videoFrame25.close(); |
| videoFrame26.close(); |
| videoFrame27.close(); |
| videoFrame28.close(); |
| } |
| |
| onload = async () => { |
| try { |
| let sharedScript = document.querySelector('#shared').textContent; |
| |
| let workers = [ |
| |
| ]; |
| let promises = [ window0() ]; |
| log('promises created'); |
| let results = await Promise.allSettled(promises); |
| for (let result of results) { |
| if (result.status === 'rejected') { throw result.reason; } |
| } |
| log('the end') |
| log(location); |
| } catch (e) { |
| log('error'); |
| log(e); |
| log(e[Symbol.toStringTag]); |
| log(e.stack); |
| if (e instanceof GPUPipelineError) { |
| log(`${e} - ${e.reason}`); |
| |
| } else if (e instanceof DOMException) { |
| if (e.name === 'OperationError') { |
| log(e.message); |
| |
| } else if (e.name === 'InvalidStateError') { |
| } else { |
| log(e); |
| |
| } |
| } else if (e instanceof GPUValidationError) { |
| |
| } else if (e instanceof GPUOutOfMemoryError) { |
| |
| } else if (e instanceof TypeError) { |
| log(e); |
| |
| } else { |
| log('unexpected error type'); |
| log(e); |
| |
| } |
| } |
| debug('Pass') |
| globalThis.testRunner?.notifyDone(); |
| }; |
| </script> |
| |
