| <style> |
| :root { background: #102030e0; color: #99ddbbcc; font-size: 15px; } |
| </style> |
| <script src="../../../resources/js-test-pre.js"></script> |
| <script id="shared"> |
| const log = globalThis.$vm?.print ?? console.log; |
| |
| async function gc() { |
| await 0; |
| if (globalThis.GCController) { |
| globalThis.GCController.collect(); |
| } else if (globalThis.$vm) { |
| globalThis.$vm.gc(); |
| } else { |
| log('no GC available'); |
| } |
| } |
| |
| /** |
| * @param {GPUDevice} device |
| * @param {GPUComputePassEncoder} computePassEncoder |
| */ |
| function clearResourceUsages(device, computePassEncoder) { |
| let code = `@compute @workgroup_size(1) fn c() {}`; |
| let module = device.createShaderModule({code}); |
| computePassEncoder.setPipeline(device.createComputePipeline( |
| { |
| layout: 'auto', |
| compute: {module}, |
| })); |
| computePassEncoder.dispatchWorkgroups(1); |
| } |
| |
| /** |
| * @template {any} T |
| * @param {GPUDevice} device |
| * @param {string} label |
| * @param {()=>T} payload |
| * @returns {Promise<T>} |
| */ |
| async function validationWrapper(device, label, payload) { |
| device.pushErrorScope('internal'); |
| device.pushErrorScope('out-of-memory'); |
| device.pushErrorScope('validation'); |
| let result = payload(); |
| let validationError = await device.popErrorScope(); |
| let outOfMemoryError = await device.popErrorScope(); |
| let internalError = await device.popErrorScope(); |
| let error = validationError ?? outOfMemoryError ?? internalError; |
| if (error) { |
| log('*'.repeat(25)); |
| log(error[Symbol.toStringTag]); |
| log(error.message); |
| log(label); |
| if (error.stack != `_`) { |
| log(error.stack); |
| } |
| log(location); |
| log('*'.repeat(25)); |
| throw error; |
| } |
| return result; |
| } |
| |
| const videoUrls = [ |
| |
| ]; |
| |
| /** |
| * @param {number} index |
| * @returns {Promise<HTMLVideoElement>} |
| */ |
| function videoWithData(index) { |
| let video = document.createElement('video'); |
| video.src = videoUrls[index % videoUrls.length]; |
| return new Promise(resolve => { |
| video.onloadeddata = () => { |
| resolve(video); |
| }; |
| }); |
| } |
| |
| /** |
| * @returns {Promise<string>} |
| */ |
| async function makeDataUrl(width, height, color0, color1) { |
| let offscreenCanvas = new OffscreenCanvas(width, height); |
| let ctx = offscreenCanvas.getContext('2d'); |
| let gradient = ctx.createLinearGradient(0, 0, width, height); |
| gradient.addColorStop(0, color0); |
| gradient.addColorStop(0.1, color1); |
| gradient.addColorStop(0.3, color0); |
| gradient.addColorStop(0.7, color1); |
| gradient.addColorStop(0.9, color0); |
| gradient.addColorStop(1, color1); |
| ctx.fillStyle = gradient; |
| ctx.fillRect(0, 0, width, height); |
| let blob = await offscreenCanvas.convertToBlob(); |
| let fileReader = new FileReader(); |
| fileReader.readAsDataURL(blob); |
| return new Promise(resolve => { |
| fileReader.onload = () => { |
| resolve(fileReader.result); |
| }; |
| }); |
| } |
| |
| async function imageWithData(width, height, color0, color1) { |
| let dataUrl = await makeDataUrl(width, height, color0, color1); |
| let img = document.createElement('img'); |
| img.src = dataUrl; |
| await img.decode(); |
| return img; |
| } |
| |
| /** |
| * @param {string} payload |
| * @returns {string} |
| */ |
| function toBlobUrl(payload) { |
| let blob = new Blob([payload], {type: 'text/javascript'}); |
| return URL.createObjectURL(blob); |
| } |
| </script> |
| <script> |
| globalThis.testRunner?.waitUntilDone(); |
| |
| async function window0() { |
| let adapter0 = await navigator.gpu.requestAdapter({}); |
| let device0 = await adapter0.requestDevice({ |
| label: '\u1f1b\uf236\u06a6\u0ae8\ua453\u{1fc53}\ucd8a', |
| defaultQueue: {label: '\u8cd1\ued29\u07cf\u{1f8b9}\u96c8'}, |
| requiredFeatures: [ |
| 'depth-clip-control', |
| 'depth32float-stencil8', |
| 'texture-compression-etc2', |
| 'texture-compression-astc', |
| 'indirect-first-instance', |
| 'shader-f16', |
| 'bgra8unorm-storage', |
| ], |
| requiredLimits: { |
| maxBindGroups: 4, |
| maxDynamicUniformBuffersPerPipelineLayout: 8, |
| minStorageBufferOffsetAlignment: 256, |
| maxUniformBufferBindingSize: 62928294, |
| maxStorageBufferBindingSize: 159659193, |
| }, |
| }); |
| let commandEncoder0 = device0.createCommandEncoder(); |
| let texture0 = device0.createTexture({ |
| size: {width: 220, height: 20, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'etc2-rgb8unorm-srgb', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let buffer0 = device0.createBuffer({size: 247, usage: GPUBufferUsage.MAP_WRITE}); |
| let buffer1 = device0.createBuffer({ |
| label: '\u3f96\u{1f730}\ufe66\ud48d\u{1fe04}\u0eda\u0bbc\u02cc', |
| size: 1531, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let commandEncoder1 = device0.createCommandEncoder(); |
| let texture1 = device0.createTexture({size: [36, 1, 1], format: 'rgba16sint', usage: GPUTextureUsage.COPY_SRC}); |
| let computePassEncoder0 = commandEncoder1.beginComputePass({}); |
| let buffer2 = device0.createBuffer({ |
| label: '\u5e63\u03a8\u9f84\u092a\u18a7\ua069\uad9f\u52a7\ucc77', |
| size: 8433, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| try { |
| buffer2.unmap(); |
| } catch {} |
| let bindGroupLayout0 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 103, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'rgba8unorm', access: 'write-only', viewDimension: '3d' }, |
| }, |
| { |
| binding: 176, |
| visibility: 0, |
| storageTexture: { format: 'rgba16uint', access: 'write-only', viewDimension: '3d' }, |
| }, |
| ], |
| }); |
| let commandEncoder2 = device0.createCommandEncoder({}); |
| let texture2 = device0.createTexture({ |
| size: {width: 560, height: 582, depthOrArrayLayers: 7}, |
| dimension: '3d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView0 = texture2.createView({dimension: '3d'}); |
| let renderBundleEncoder0 = device0.createRenderBundleEncoder({colorFormats: ['rgba16sint'], sampleCount: 1, stencilReadOnly: true}); |
| let sampler0 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMaxClamp: 63.40, |
| }); |
| try { |
| renderBundleEncoder0.setIndexBuffer(buffer1, 'uint16', 968, 4); |
| } catch {} |
| try { |
| renderBundleEncoder0.setVertexBuffer(7, buffer2, 0); |
| } catch {} |
| let texture3 = device0.createTexture({ |
| size: {width: 192, height: 1, depthOrArrayLayers: 262}, |
| dimension: '3d', |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView1 = texture0.createView({dimension: '2d-array', aspect: 'all', mipLevelCount: 1}); |
| let renderBundle0 = renderBundleEncoder0.finish(); |
| try { |
| globalThis.someLabel = device0.label; |
| } catch {} |
| let pipelineLayout0 = device0.createPipelineLayout({label: '\u042b\uf445\u0434\ua17a\uff5c\u{1fd6f}\u06cb', bindGroupLayouts: [bindGroupLayout0]}); |
| let texture4 = device0.createTexture({ |
| label: '\uf16a\u2e93\u{1fea1}\ud00a\u{1fdae}\u9da7\uf4e6\ubdf5', |
| size: {width: 70, height: 72, depthOrArrayLayers: 20}, |
| dimension: '3d', |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView2 = texture0.createView({dimension: '2d-array', aspect: 'all', mipLevelCount: 1}); |
| try { |
| device0.pushErrorScope('internal'); |
| } catch {} |
| try { |
| buffer1.unmap(); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| let shaderModule0 = device0.createShaderModule({ |
| label: '\u{1ffa5}\u04be', |
| code: ` |
| enable f16; |
| |
| requires unrestricted_pointer_parameters; |
| |
| diagnostic(info, xyz); |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| @group(0) @binding(103) var st0: texture_storage_3d<rgba8unorm, write>; |
| |
| @group(0) @binding(176) var st1: texture_storage_3d<rgba16uint, write>; |
| |
| struct T0 { |
| @align(64) @size(64) f0: mat2x2h, |
| @size(320) f1: array<vec2i, 1>, |
| f2: array<vec2i, 40>, |
| } |
| |
| struct T1 { |
| f0: f32, |
| @size(144) f1: array<vec4f>, |
| } |
| |
| struct S0 { |
| @location(4) f0: vec2f, |
| } |
| |
| struct VertexOutput0 { |
| @builtin(position) f0: vec4f, |
| @location(4) @interpolate(flat, sample) f1: vec4u, |
| @location(10) f2: f32, |
| @location(0) f3: f32, |
| @location(8) @interpolate(linear, sample) f4: vec4f, |
| @location(5) @interpolate(linear) f5: vec2h, |
| @location(15) f6: vec2u, |
| @location(14) f7: i32, |
| } |
| |
| struct FragmentOutput0 { |
| @builtin(sample_mask) f0: u32, |
| @location(0) f1: vec4i, |
| } |
| |
| override override0: bool; |
| |
| override override1: u32 = 25; |
| |
| var<workgroup> vw0: mat4x3f; |
| |
| var<workgroup> vw1: S0; |
| |
| var<workgroup> vw2: S0; |
| |
| var<workgroup> vw3: mat3x4h; |
| |
| var<workgroup> vw4: mat2x3h; |
| |
| var<private> vp0: S0 = S0(); |
| |
| @vertex |
| fn vertex0(@location(11) a0: u32, @location(9) @interpolate(flat, center) a1: vec4u, a2: S0, @location(3) a3: vec2i) -> VertexOutput0 { |
| var out: VertexOutput0; |
| out.f3 -= vec2f(firstLeadingBit(vec2i(unconst_i32(84), unconst_i32(-538)))).r; |
| let vf0: vec3f = inverseSqrt(vec3f(unconst_f32(0.05185), unconst_f32(0.3398), unconst_f32(0.1379))); |
| var vf1: S0 = a2; |
| out.f6 -= vec2u(override1); |
| out.f5 *= vec2h(unpack4xI8(u32(unconst_u32(83))).gr); |
| out.f2 = vp0.f0.y; |
| out.f6 += vec2u(countOneBits(vec4i(unconst_i32(103), unconst_i32(554), unconst_i32(85), unconst_i32(-228))).bb); |
| let vf2: bool = override0; |
| out.f4 += vec4f(f32(any(bool(unconst_bool(false))))); |
| out.f1 *= bitcast<vec4u>(unpack4xI8(pack4xI8Clamp(unpack4xI8(u32(unconst_u32(14)))))); |
| out.f7 = i32(determinant(mat3x3h(vec3h(unpack2x16float(u32(unconst_u32(385))).xxy), vec3h(unpack2x16float(u32(unconst_u32(385))).rgg), vec3h(unpack2x16float(u32(unconst_u32(385))).rrg)))); |
| var vf3: vec2f = a2.f0; |
| let vf4: f16 = determinant(mat3x3h(f16(vf3[u32(unconst_u32(53))]), f16(vf3[u32(unconst_u32(53))]), f16(vf3[u32(unconst_u32(53))]), f16(vf3[u32(unconst_u32(53))]), f16(vf3[u32(unconst_u32(53))]), f16(vf3[u32(unconst_u32(53))]), f16(vf3[u32(unconst_u32(53))]), f16(vf3[u32(unconst_u32(53))]), f16(vf3[u32(unconst_u32(53))]))); |
| let vf5: vec4h = degrees(vec4h(unconst_f16(21347.6), unconst_f16(12805.4), unconst_f16(195.6), unconst_f16(3855.6))); |
| let vf6: vec4i = countOneBits(vec4i(unconst_i32(364), unconst_i32(331), unconst_i32(131), unconst_i32(49))); |
| vp0.f0 += unpack2x16snorm(a1[u32(unconst_u32(9))]); |
| var vf7: bool = any(bool(unconst_bool(false))); |
| out.f2 = f32(pack4xU8(vec4u(unconst_u32(42), unconst_u32(425), unconst_u32(178), unconst_u32(117)))); |
| let ptr0: ptr<private, S0> = &vp0; |
| out.f4 -= vp0.f0.gggr; |
| out.f4 += vec4f(f32(vf5[u32(unconst_u32(87))])); |
| return out; |
| _ = override0; |
| _ = override1; |
| } |
| |
| @fragment |
| fn fragment0(@location(8) a0: vec4f, @location(4) a1: vec4u) -> FragmentOutput0 { |
| var out: FragmentOutput0; |
| let vf8: vec3f = tan(vec3f(unconst_f32(0.4395), unconst_f32(0.1132), unconst_f32(0.2976))); |
| var vf9: vec4h = normalize(vec4h(unconst_f16(-7661.0), unconst_f16(988.7), unconst_f16(786.0), unconst_f16(2880.2))); |
| out.f1 -= vec4i(a0); |
| let vf10: vec3f = tan(vec3f(unconst_f32(0.2049), unconst_f32(0.05386), unconst_f32(0.1620))); |
| let ptr1: ptr<private, S0> = &vp0; |
| out = FragmentOutput0(pack2x16unorm(vp0.f0), bitcast<vec4i>(vp0.f0.rgrg)); |
| var vf11: f32 = a0[override1]; |
| out.f0 |= u32((*ptr1).f0[u32(unconst_u32(121))]); |
| out.f0 <<= bitcast<u32>(tan(vec3f(unconst_f32(0.3263), unconst_f32(0.03503), unconst_f32(0.2125))).x); |
| vp0.f0 = vp0.f0; |
| out.f1 |= vec4i(i32(override0)); |
| return out; |
| _ = override1; |
| _ = override0; |
| } |
| |
| @compute @workgroup_size(1, 1, 1) |
| fn compute0() { |
| var vf12: f16 = vw4[u32(unconst_u32(56))][u32(unconst_u32(101))]; |
| let ptr2: ptr<workgroup, vec2f> = &vw2.f0; |
| let vf13: mat4x3f = workgroupUniformLoad(&vw0); |
| var vf14: f32 = exp(f32(unconst_f32(0.08708))); |
| vw2.f0 += vec2f(tan(vec3h(unconst_f16(11870.7), unconst_f16(3528.5), unconst_f16(3064.0))).gb); |
| vw4 -= mat2x3h(f16(exp(f32(unconst_f32(0.00705)))), f16(exp(f32(unconst_f32(0.00705)))), f16(exp(f32(unconst_f32(0.00705)))), f16(exp(f32(unconst_f32(0.00705)))), f16(exp(f32(unconst_f32(0.00705)))), f16(exp(f32(unconst_f32(0.00705))))); |
| vw4 = mat2x3h(vec3h((*&vw2).f0.rrg), vec3h((*&vw2).f0.xyx)); |
| vf12 -= f16(override0); |
| _ = override0; |
| }`, |
| sourceMap: {}, |
| }); |
| let texture5 = device0.createTexture({ |
| size: {width: 73, height: 1, depthOrArrayLayers: 54}, |
| dimension: '3d', |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture6 = device0.createTexture({ |
| size: [96, 1, 1], |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView3 = texture5.createView({}); |
| try { |
| await buffer0.mapAsync(GPUMapMode.WRITE, 0, 24); |
| } catch {} |
| try { |
| commandEncoder2.copyTextureToTexture({ |
| texture: texture3, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 107}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture5, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 6}, |
| aspect: 'all', |
| }, |
| {width: 4, height: 0, depthOrArrayLayers: 2}); |
| } catch {} |
| try { |
| commandEncoder2.insertDebugMarker('\u31a5'); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let shaderModule1 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| requires readonly_and_readwrite_storage_textures; |
| |
| requires pointer_composite_access; |
| |
| requires packed_4x8_integer_dot_product; |
| |
| requires packed_4x8_integer_dot_product; |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| @group(0) @binding(103) var st2: texture_storage_3d<rgba8unorm, write>; |
| |
| @group(0) @binding(176) var st3: texture_storage_3d<rgba16uint, write>; |
| |
| struct T0 { |
| f0: mat2x4h, |
| @align(16) @size(16) f1: vec2i, |
| @size(624) f2: array<array<array<array<atomic<u32>, 1>, 1>, 6>>, |
| } |
| |
| struct S1 { |
| @location(15) f0: f32, |
| @builtin(instance_index) f1: u32, |
| @location(10) f2: vec2f, |
| @location(0) f3: vec4f, |
| @location(7) @interpolate(flat, sample) f4: vec2i, |
| } |
| |
| struct S2 { |
| @location(13) @interpolate(linear, center) f0: vec4f, |
| @location(9) @interpolate(flat, center) f1: vec4i, |
| } |
| |
| struct VertexOutput1 { |
| @location(2) f8: vec2i, |
| @location(12) @interpolate(linear, centroid) f9: f16, |
| @builtin(position) f10: vec4f, |
| } |
| |
| override override2 = 0.1127; |
| |
| fn fn0() -> array<S2, 1> { |
| var out: array<S2, 1>; |
| var vf15: vec4h = asin(vec4h(unconst_f16(939.1), unconst_f16(45897.9), unconst_f16(5480.5), unconst_f16(3341.5))); |
| let vf16: i32 = dot4I8Packed(u32(unconst_u32(125)), u32(unconst_u32(404))); |
| vf15 = vec4h(vf15[u32(unconst_u32(22))]); |
| vf15 -= vec4h(f16(override2)); |
| var vf17: f16 = vf15[u32(unconst_u32(220))]; |
| vf17 += dot(vec2h(unconst_f16(14421.5), unconst_f16(8077.8)), vec2h(unconst_f16(11659.0), unconst_f16(933.1))); |
| vf17 = vf15.g; |
| var vf18: vec2f = cosh(vec2f(unconst_f32(0.1709), unconst_f32(0.2085))); |
| out[u32(dot(vec2h(unconst_f16(31755.3), unconst_f16(-17544.9)), vec2h(unconst_f16(9057.5), unconst_f16(21069.4))))] = S2(vec4f(f32(length(vec2h(unconst_f16(8092.1), unconst_f16(409.9))))), vec4i(i32(length(vec2h(unconst_f16(8092.1), unconst_f16(409.9)))))); |
| vf15 += bitcast<vec4h>(vf18); |
| let vf19: vec2f = cosh(vec2f(unconst_f32(-0.04846), unconst_f32(-0.07237))); |
| var vf20: bool = any(bool(unconst_bool(false))); |
| var vf21: f16 = vf15[u32(unconst_u32(475))]; |
| out[u32(unconst_u32(271))].f1 = vec4i(vf16); |
| var vf22: vec2h = round(vec2h(unconst_f16(132.8), unconst_f16(1180.0))); |
| let vf23: f32 = vf19[u32(unconst_u32(159))]; |
| var vf24: f32 = vf23; |
| vf24 -= refract(vec4f(unconst_f32(0.1515), unconst_f32(0.02979), unconst_f32(-0.05912), unconst_f32(0.3204)), vec4f(unconst_f32(0.1218), unconst_f32(-0.2674), unconst_f32(0.00204), unconst_f32(0.3202)), f32(unconst_f32(0.1880))).g; |
| vf21 = f16(any(bool(round(vec2h(unconst_f16(37794.2), unconst_f16(2555.7)))[0]))); |
| var vf25: f32 = vf18[u32(unconst_u32(198))]; |
| vf22 -= bitcast<vec2h>(vf23); |
| vf20 = bool(vf21); |
| vf15 *= vec4h(f16(pack4x8snorm(vec4f(unconst_f32(0.3399), unconst_f32(0.2771), unconst_f32(0.00742), unconst_f32(0.00935))))); |
| vf15 = vf15; |
| let ptr3: ptr<function, f32> = &vf24; |
| return out; |
| _ = override2; |
| } |
| |
| var<workgroup> vw5: vec4<bool>; |
| |
| var<workgroup> vw6: vec4h; |
| |
| var<workgroup> vw7: vec2h; |
| |
| var<workgroup> vw8: mat2x4f; |
| |
| var<workgroup> vw9: array<array<S2, 1>, 1>; |
| |
| var<workgroup> vw10: atomic<i32>; |
| |
| var<workgroup> vw11: S2; |
| |
| @vertex |
| fn vertex1(a0: S1, a1: S2) -> VertexOutput1 { |
| var out: VertexOutput1; |
| out.f9 = cos(vec3h(f16(override2))).r; |
| out.f10 -= a0.f3; |
| var vf26 = fn0(); |
| vf26[0] = S2(transpose(mat2x3f(unconst_f32(0.05471), unconst_f32(-0.00654), unconst_f32(0.3878), unconst_f32(0.1215), unconst_f32(0.09587), unconst_f32(-0.4084)))[unconst_i32(1)].rrgg, vec4i(transpose(mat2x3f(unconst_f32(0.05471), unconst_f32(-0.00654), unconst_f32(0.3878), unconst_f32(0.1215), unconst_f32(0.09587), unconst_f32(-0.4084)))[unconst_i32(2)].gggg)); |
| out.f10 = vec4f(f32(determinant(mat2x2h()))); |
| fn0(); |
| vf26[pack4xI8Clamp(vf26[0].f1)].f0 = vec4f(atanh(vec2h(a1.f0.ar)).rrgr); |
| fn0(); |
| vf26[u32(unconst_u32(3))].f1 = bitcast<vec4i>(vf26[u32(unconst_u32(611))].f0); |
| vf26[u32(unconst_u32(96))] = S2(vec4f(f32(all(vec2<bool>(unconst_bool(false), unconst_bool(true))))), vec4i(i32(all(vec2<bool>(unconst_bool(false), unconst_bool(true)))))); |
| vf26[pack4xI8Clamp(a1.f1)] = vf26[u32(unconst_u32(350))]; |
| return out; |
| _ = override2; |
| } |
| |
| @compute @workgroup_size(2, 1, 1) |
| fn compute1() { |
| vw6 = vec4h((*&vw9)[u32(unconst_u32(124))][u32(unconst_u32(315))].f1); |
| atomicCompareExchangeWeak(&vw10, unconst_i32(29), unconst_i32(248)); |
| vw5 = vec4<bool>(vw9[0][0].f0); |
| textureStore(st2, vec3i(unconst_i32(397), unconst_i32(1), unconst_i32(215)), vec4f(vec4f(unconst_f32(0.2742), unconst_f32(0.1447), unconst_f32(0.2709), unconst_f32(0.04326)))); |
| let ptr4: ptr<workgroup, vec4i> = &vw9[0][0].f1; |
| var vf27: i32 = atomicExchange(&vw10, i32(vw5[u32(unconst_u32(42))])); |
| let ptr5: ptr<workgroup, vec4i> = &vw9[u32(unconst_u32(231))][0].f1; |
| vf27 *= bitcast<i32>((*&vw8)[unconst_i32(1)].b); |
| let ptr6: ptr<workgroup, vec4i> = &(*&vw9)[u32(unconst_u32(58))][0].f1; |
| let ptr7: ptr<workgroup, vec4i> = &vw9[bitcast<vec4u>((*&vw9)[u32(unconst_u32(583))][0].f1).r][0].f1; |
| let ptr8: ptr<workgroup, vec4i> = &(*ptr6); |
| atomicMax(&vw10, i32(unconst_i32(734))); |
| vf27 = atomicExchange(&vw10, i32(unconst_i32(-144))); |
| let vf28: f32 = override2; |
| vw7 = bitcast<vec2h>((*ptr4)[u32(unconst_u32(26))]); |
| atomicStore(&vw10, i32(unconst_i32(11))); |
| let ptr9: ptr<workgroup, vec4i> = &vw11.f1; |
| _ = override2; |
| }`, |
| sourceMap: {}, |
| }); |
| let bindGroup0 = device0.createBindGroup({ |
| layout: bindGroupLayout0, |
| entries: [{binding: 176, resource: textureView0}, {binding: 103, resource: textureView3}], |
| }); |
| let pipelineLayout1 = device0.createPipelineLayout({bindGroupLayouts: []}); |
| let texture7 = device0.createTexture({ |
| size: [36, 1, 202], |
| dimension: '3d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let bindGroup1 = device0.createBindGroup({ |
| layout: bindGroupLayout0, |
| entries: [{binding: 103, resource: textureView3}, {binding: 176, resource: textureView0}], |
| }); |
| let textureView4 = texture7.createView({label: '\u1989\ub645\u683d'}); |
| try { |
| computePassEncoder0.setBindGroup(0, bindGroup0, new Uint32Array(918), 79, 0); |
| } catch {} |
| try { |
| commandEncoder2.clearBuffer(buffer1, 276, 116); |
| } catch {} |
| let bindGroup2 = device0.createBindGroup({ |
| layout: bindGroupLayout0, |
| entries: [{binding: 103, resource: textureView3}, {binding: 176, resource: textureView0}], |
| }); |
| let buffer3 = device0.createBuffer({ |
| label: '\ud851\u7ef0\u89fc\ua334\u{1f9a2}', |
| size: 619, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| let commandEncoder3 = device0.createCommandEncoder({}); |
| let texture8 = device0.createTexture({ |
| label: '\u{1f813}\u7590\u{1fe62}\u1d39\u34a3\u2296\u0ccf', |
| size: {width: 73, height: 1, depthOrArrayLayers: 1}, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView5 = texture6.createView({dimension: '2d', aspect: 'all', baseArrayLayer: 0}); |
| let computePassEncoder1 = commandEncoder3.beginComputePass({}); |
| let renderPassEncoder0 = commandEncoder0.beginRenderPass({colorAttachments: [{view: textureView5, loadOp: 'clear', storeOp: 'store'}]}); |
| try { |
| computePassEncoder0.setBindGroup(3, bindGroup1); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(2, bindGroup2, new Uint32Array(1466), 480, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.executeBundles([renderBundle0, renderBundle0]); |
| } catch {} |
| try { |
| commandEncoder2.copyBufferToBuffer(buffer3, 288, buffer2, 3412, 116); |
| } catch {} |
| try { |
| commandEncoder2.clearBuffer(buffer3, 196, 28); |
| } catch {} |
| let commandEncoder4 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder0.setBindGroup(0, bindGroup0, new Uint32Array(308), 41, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer1, 'uint16', 108, 169); |
| } catch {} |
| try { |
| buffer1.unmap(); |
| } catch {} |
| try { |
| commandEncoder2.copyBufferToBuffer(buffer3, 40, buffer1, 180, 84); |
| } catch {} |
| let bindGroupLayout1 = device0.createBindGroupLayout({entries: [{binding: 277, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'filtering' }}]}); |
| let sampler1 = device0.createSampler({ |
| addressModeU: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 98.24, |
| lodMaxClamp: 98.32, |
| maxAnisotropy: 3, |
| }); |
| let computePassEncoder2 = commandEncoder4.beginComputePass({}); |
| let renderPassEncoder1 = commandEncoder2.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView4, |
| depthSlice: 173, |
| clearValue: { r: -798.4, g: 620.9, b: -350.2, a: 220.1, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| }); |
| let arrayBuffer0 = buffer0.getMappedRange(8, 0); |
| try { |
| renderBundle0.label = '\uc3af\u068f\u01b4\u0f08\u0ae0\uf682\u0a04\uce24'; |
| } catch {} |
| let bindGroup3 = device0.createBindGroup({ |
| label: '\u{1fd63}\u7511\ud2ef\u{1faff}\u22fa\ub430\u{1ffd2}\u{1f9e5}\u{1fbca}\u{1f79b}', |
| layout: bindGroupLayout0, |
| entries: [{binding: 103, resource: textureView3}, {binding: 176, resource: textureView0}], |
| }); |
| let commandEncoder5 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder0.setBindGroup(0, bindGroup2); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer1, 'uint16', 200, 110); |
| } catch {} |
| let pipelineLayout2 = device0.createPipelineLayout({bindGroupLayouts: []}); |
| let computePassEncoder3 = commandEncoder5.beginComputePass({}); |
| try { |
| renderPassEncoder1.setBindGroup(0, bindGroup3, new Uint32Array(1169), 13, 0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture5, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 12}, |
| aspect: 'all', |
| }, new Uint8Array(2_112).fill(36), /* required buffer size: 2_112 */ |
| {offset: 267, bytesPerRow: 123, rowsPerImage: 1}, {width: 29, height: 0, depthOrArrayLayers: 16}); |
| } catch {} |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55); }; |
| } catch {} |
| let bindGroup4 = device0.createBindGroup({layout: bindGroupLayout1, entries: [{binding: 277, resource: sampler1}]}); |
| let buffer4 = device0.createBuffer({ |
| size: 27964, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| let commandEncoder6 = device0.createCommandEncoder({label: '\u1ac3\u0e22\u{1f940}\ue7b9\ubb20\uf204\u{1fe8f}\ua5c2\u1bec'}); |
| let renderPassEncoder2 = commandEncoder6.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView4, |
| depthSlice: 136, |
| clearValue: { r: -408.2, g: 708.6, b: 595.9, a: -7.452, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| computePassEncoder2.setBindGroup(1, bindGroup2, []); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(0, bindGroup1, new Uint32Array(1462), 736, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(0, buffer3, 132, 12); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture7, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 5}, |
| aspect: 'all', |
| }, new Uint8Array(268_352).fill(157), /* required buffer size: 268_352 */ |
| {offset: 32, bytesPerRow: 40, rowsPerImage: 86}, {width: 1, height: 0, depthOrArrayLayers: 79}); |
| } catch {} |
| await gc(); |
| let buffer5 = device0.createBuffer({size: 27075, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let commandEncoder7 = device0.createCommandEncoder({}); |
| let textureView6 = texture6.createView({label: '\u0ac0\u3246\u5dbe\u{1f755}\ucd1b\u0763', dimension: '2d', baseMipLevel: 0}); |
| let texture9 = device0.createTexture({ |
| label: '\u035e\ueb5d\u06b2', |
| size: [73, 1, 1], |
| mipLevelCount: 3, |
| dimension: '2d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder4 = commandEncoder7.beginComputePass({label: '\u0c91\ud0ba\uaa4d\u031d\u0694'}); |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer4, 'uint16', 2_828, 2_138); |
| } catch {} |
| let bindGroup5 = device0.createBindGroup({layout: bindGroupLayout1, entries: [{binding: 277, resource: sampler1}]}); |
| try { |
| computePassEncoder4.setBindGroup(0, bindGroup2, new Uint32Array(2289), 1_180, 0); |
| } catch {} |
| await gc(); |
| let bindGroupLayout2 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 94, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d-array', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| { |
| binding: 567, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba8snorm', access: 'write-only', viewDimension: '2d' }, |
| }, |
| { |
| binding: 132, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false }, |
| }, |
| { |
| binding: 243, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| { |
| binding: 398, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| { |
| binding: 42, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| externalTexture: {}, |
| }, |
| { |
| binding: 999, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d-array', sampleType: 'sint', multisampled: false }, |
| }, |
| { |
| binding: 35, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '1d' }, |
| }, |
| { |
| binding: 421, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let bindGroup6 = device0.createBindGroup({ |
| label: '\u682d\ua11a\u4afa\u15ac\u5455\uf2c6', |
| layout: bindGroupLayout0, |
| entries: [{binding: 176, resource: textureView0}, {binding: 103, resource: textureView3}], |
| }); |
| let texture10 = device0.createTexture({ |
| size: [110, 10, 1], |
| mipLevelCount: 3, |
| sampleCount: 1, |
| format: 'depth24plus-stencil8', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture11 = device0.createTexture({ |
| size: [36, 1, 534], |
| mipLevelCount: 1, |
| dimension: '3d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView7 = texture3.createView({}); |
| let sampler2 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 77.80, |
| lodMaxClamp: 98.57, |
| maxAnisotropy: 10, |
| }); |
| try { |
| renderPassEncoder2.setVertexBuffer(0, buffer2, 1_168); |
| } catch {} |
| let bindGroupLayout3 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 225, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| { |
| binding: 58, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let texture12 = device0.createTexture({ |
| label: '\u0e12\u{1fddf}\u0388', |
| size: [70, 72, 1], |
| mipLevelCount: 1, |
| format: 'rgba8snorm', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder0.setBindGroup(3, bindGroup4); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(2, bindGroup1, new Uint32Array(575), 33, 0); |
| } catch {} |
| let commandEncoder8 = device0.createCommandEncoder({}); |
| let texture13 = device0.createTexture({ |
| size: [147], |
| dimension: '1d', |
| format: 'r32sint', |
| usage: GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let texture14 = device0.createTexture({ |
| label: '\u0038\u03e0', |
| size: [96, 1, 36], |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let computePassEncoder5 = commandEncoder8.beginComputePass({}); |
| try { |
| computePassEncoder4.setBindGroup(1, bindGroup0, new Uint32Array(651), 139, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(1, bindGroup6); |
| } catch {} |
| try { |
| computePassEncoder4.label = '\u{1f7bc}\u05c3\u2820\u579e\u{1f922}'; |
| } catch {} |
| let buffer6 = device0.createBuffer({size: 2238, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX}); |
| let texture15 = device0.createTexture({ |
| size: {width: 73}, |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'r32sint', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder1.setBindGroup(0, bindGroup6, new Uint32Array(2394), 2_164, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer1, 'uint32', 156, 479); |
| } catch {} |
| let bindGroup7 = device0.createBindGroup({ |
| label: '\u0ac8\u72fe\u{1fc77}\u30bf', |
| layout: bindGroupLayout0, |
| entries: [{binding: 103, resource: textureView3}, {binding: 176, resource: textureView0}], |
| }); |
| let buffer7 = device0.createBuffer({size: 31115, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE}); |
| let commandEncoder9 = device0.createCommandEncoder({}); |
| let textureView8 = texture2.createView({}); |
| let textureView9 = texture10.createView({dimension: '2d-array', aspect: 'stencil-only', format: 'stencil8', mipLevelCount: 1}); |
| try { |
| computePassEncoder4.setBindGroup(1, bindGroup5, new Uint32Array(115), 1, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer1, 'uint16', 24, 464); |
| } catch {} |
| try { |
| globalThis.someLabel = sampler1.label; |
| } catch {} |
| let texture16 = device0.createTexture({ |
| size: [64, 64, 22], |
| mipLevelCount: 2, |
| format: 'depth24plus', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture17 = device0.createTexture({ |
| label: '\u396f\u2d02\u9810\uab34\u7937\u{1f7e3}', |
| size: [192, 1, 262], |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let computePassEncoder6 = commandEncoder9.beginComputePass({}); |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer4, 'uint32', 11_428, 7_089); |
| } catch {} |
| let textureView10 = texture15.createView({}); |
| let texture18 = device0.createTexture({ |
| size: {width: 96, height: 1, depthOrArrayLayers: 131}, |
| dimension: '3d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView11 = texture13.createView({label: '\u0b57\u{1ff60}\u681f\u661a\u1f28\u07cc'}); |
| let sampler3 = device0.createSampler({ |
| label: '\u0618\u20de\u{1f8d5}\ua3ed\u7f10', |
| addressModeU: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| }); |
| try { |
| renderPassEncoder1.setVertexBuffer(4, undefined, 0); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| let bindGroup8 = device0.createBindGroup({ |
| layout: bindGroupLayout0, |
| entries: [{binding: 103, resource: textureView3}, {binding: 176, resource: textureView8}], |
| }); |
| let commandEncoder10 = device0.createCommandEncoder({label: '\u0abd\u7b04\uf099\u3f88\u{1fd7a}\u04d4\uf2c1\ucddc\u4820\u3e71'}); |
| let textureView12 = texture10.createView({dimension: '2d-array', baseMipLevel: 0, mipLevelCount: 2}); |
| let renderPassEncoder3 = commandEncoder10.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView6, |
| clearValue: { r: -393.8, g: 434.2, b: -186.8, a: -390.2, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| }); |
| let promise0 = device0.queue.onSubmittedWorkDone(); |
| let buffer8 = device0.createBuffer({ |
| label: '\u0951\u1e8e\u8ac2', |
| size: 2758, |
| usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| let querySet0 = device0.createQuerySet({type: 'occlusion', count: 227}); |
| let textureView13 = texture10.createView({ |
| label: '\uf46e\u02f2\u0d09\uec98\u0ba7', |
| format: 'depth24plus-stencil8', |
| mipLevelCount: 1, |
| arrayLayerCount: 1, |
| }); |
| try { |
| computePassEncoder1.setBindGroup(2, bindGroup6); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(3, bindGroup3, new Uint32Array(1782), 21, 0); |
| } catch {} |
| let imageData0 = new ImageData(32, 116); |
| let bindGroup9 = device0.createBindGroup({ |
| layout: bindGroupLayout0, |
| entries: [{binding: 176, resource: textureView0}, {binding: 103, resource: textureView7}], |
| }); |
| let texture19 = device0.createTexture({ |
| size: [140, 145, 1], |
| format: 'rgba8snorm', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder0.setBindGroup(0, bindGroup9, new Uint32Array(702), 232, 0); |
| } catch {} |
| let bindGroupLayout4 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 511, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let bindGroup10 = device0.createBindGroup({ |
| label: '\u{1f662}\u2449\u{1f9b6}\u0dd6', |
| layout: bindGroupLayout3, |
| entries: [ |
| {binding: 225, resource: textureView13}, |
| {binding: 58, resource: {buffer: buffer4, offset: 256, size: 8346}}, |
| ], |
| }); |
| let buffer9 = device0.createBuffer({size: 9435, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE}); |
| let texture20 = device0.createTexture({ |
| size: [110, 10, 51], |
| mipLevelCount: 3, |
| dimension: '2d', |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView14 = texture19.createView({}); |
| try { |
| computePassEncoder6.setBindGroup(2, bindGroup7); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(1, bindGroup2); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(5, buffer3, 28); |
| } catch {} |
| let arrayBuffer1 = buffer0.getMappedRange(16, 0); |
| try { |
| sampler3.label = '\u{1fd38}\u140a\u0afe\u{1fb8e}\u{1ff93}'; |
| } catch {} |
| let bindGroup11 = device0.createBindGroup({layout: bindGroupLayout1, entries: [{binding: 277, resource: sampler2}]}); |
| let texture21 = device0.createTexture({ |
| label: '\u{1fc98}\u378a\uabea\u7dc8\u{1fbe7}\ua49c\u05d7\u07ef\u1da6\u0c40\u{1f8f8}', |
| size: [96, 1, 24], |
| format: 'rg8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture22 = device0.createTexture({ |
| label: '\ua858\u2f02\u07f3\u0155\u0c95', |
| size: {width: 295, height: 1, depthOrArrayLayers: 1}, |
| sampleCount: 4, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder1.setBindGroup(3, bindGroup10, new Uint32Array(1254), 4, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(7, buffer8); |
| } catch {} |
| let commandEncoder11 = device0.createCommandEncoder({label: '\u94ed\u025d'}); |
| let textureView15 = texture6.createView({dimension: '2d-array'}); |
| let renderPassEncoder4 = commandEncoder11.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView4, |
| depthSlice: 137, |
| clearValue: { r: -53.83, g: 202.0, b: -940.1, a: 473.0, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet0, |
| maxDrawCount: 241155204, |
| }); |
| try { |
| renderPassEncoder4.executeBundles([renderBundle0]); |
| } catch {} |
| let bindGroupLayout5 = device0.createBindGroupLayout({ |
| label: '\u0a7c\u{1ffa1}\u08b6\u3621\u02ef\u0496', |
| entries: [ |
| { |
| binding: 211, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| sampler: { type: 'filtering' }, |
| }, |
| { |
| binding: 62, |
| visibility: GPUShaderStage.COMPUTE, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| { |
| binding: 86, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '3d', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| ], |
| }); |
| let texture23 = device0.createTexture({ |
| size: {width: 64, height: 64, depthOrArrayLayers: 207}, |
| mipLevelCount: 4, |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'r16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture24 = device0.createTexture({ |
| label: '\u6840\ubc94\u{1f644}\ucc50\u{1fc7f}\u0a64', |
| size: {width: 220}, |
| dimension: '1d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView16 = texture14.createView({dimension: '2d', baseArrayLayer: 8}); |
| try { |
| computePassEncoder3.setBindGroup(0, bindGroup10, new Uint32Array(149), 6, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(3, bindGroup10); |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer1, 'uint32', 192, 529); |
| } catch {} |
| let buffer10 = device0.createBuffer({ |
| size: 16926, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| let commandEncoder12 = device0.createCommandEncoder({}); |
| let texture25 = device0.createTexture({ |
| size: {width: 384, height: 1, depthOrArrayLayers: 524}, |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'r32float', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture26 = device0.createTexture({ |
| size: [70, 72, 1], |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder7 = commandEncoder12.beginComputePass({}); |
| try { |
| computePassEncoder2.setBindGroup(3, bindGroup8, new Uint32Array(3000), 650, 0); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| let textureView17 = texture25.createView({mipLevelCount: 1}); |
| try { |
| renderPassEncoder4.setBindGroup(3, bindGroup5); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(1, bindGroup7, new Uint32Array(2465), 108, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.setBlendConstant({ r: -366.0, g: 54.19, b: -77.26, a: -87.93, }); |
| } catch {} |
| let imageData1 = new ImageData(108, 8); |
| let buffer11 = device0.createBuffer({ |
| size: 13055, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let commandEncoder13 = device0.createCommandEncoder({}); |
| let computePassEncoder8 = commandEncoder13.beginComputePass({}); |
| try { |
| computePassEncoder1.setBindGroup(0, bindGroup1, new Uint32Array(3583), 2_583, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(1, bindGroup5); |
| } catch {} |
| try { |
| renderPassEncoder2.setViewport(26.02835255080396, 0.6839984790346014, 7.8317143952165775, 0.06855447020665686, 0.9425023575430436, 0.9797368762746984); |
| } catch {} |
| try { |
| renderPassEncoder4.setIndexBuffer(buffer10, 'uint32', 3_256, 796); |
| } catch {} |
| try { |
| buffer2.unmap(); |
| } catch {} |
| let shaderModule2 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| enable f16; |
| |
| enable f16; |
| |
| requires unrestricted_pointer_parameters; |
| |
| diagnostic(info, xyz); |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| @group(0) @binding(103) var st4: texture_storage_3d<rgba8unorm, write>; |
| |
| @group(0) @binding(176) var st5: texture_storage_3d<rgba16uint, write>; |
| |
| struct T0 { |
| @align(16) @size(80) f0: array<u32>, |
| } |
| |
| struct T1 { |
| @align(128) @size(640) f0: array<u32>, |
| } |
| |
| struct T2 { |
| @align(64) @size(384) f0: array<array<atomic<u32>, 1>>, |
| } |
| |
| struct T3 { |
| f0: f32, |
| } |
| |
| struct S3 { |
| @location(7) @interpolate(flat) f0: f32, |
| } |
| |
| struct S4 { |
| @builtin(instance_index) f0: u32, |
| } |
| |
| struct VertexOutput2 { |
| @builtin(position) f11: vec4f, |
| } |
| |
| struct FragmentOutput1 { |
| @location(0) @interpolate(flat, centroid) f0: vec4i, |
| } |
| |
| alias vec3b = vec3<bool>; |
| |
| fn fn0() { |
| var vf29: vec2u = insertBits(vec2u(unconst_u32(38), unconst_u32(304)), vec2u(unconst_u32(69), unconst_u32(49)), insertBits(vec2u(unconst_u32(44), unconst_u32(83)), vec2u(unconst_u32(148), unconst_u32(169)), u32(unconst_u32(59)), bitcast<u32>(sqrt(vec3f(unconst_f32(-0.1676), unconst_f32(0.2897), unconst_f32(0.00003))).b)).y, u32(unconst_u32(33))); |
| let ptr10: ptr<function, vec2u> = &vf29; |
| vf29 <<= vec2u(sqrt(vec3f(unconst_f32(0.02282), unconst_f32(0.09096), unconst_f32(0.03228))).zy); |
| let ptr11: ptr<function, vec2u> = &(*ptr10); |
| let ptr12: ptr<function, vec2u> = &vf29; |
| vf29 ^= bitcast<vec2u>(sqrt(vec3f(unconst_f32(0.1685), unconst_f32(0.1318), unconst_f32(0.06017))).bb); |
| var vf30: vec3f = log2(vec3f(unconst_f32(0.1118), unconst_f32(-0.2218), unconst_f32(0.02198))); |
| let vf31: vec3f = sqrt(vec3f(f32((*ptr10)[u32(unconst_u32(87))]))); |
| vf29 ^= vec2u(bitcast<u32>(vf30[u32(unconst_u32(68))])); |
| let ptr13: ptr<function, vec2u> = &vf29; |
| } |
| |
| fn fn1(a0: array<FragmentOutput1, 1>) -> array<vec4i, 1> { |
| var out: array<vec4i, 1>; |
| let vf32: i32 = a0[pack4xI8(unpack4xI8(u32(unconst_u32(210))))].f0[u32(unconst_u32(59))]; |
| out[0] = vec4i(i32(any(bool(unconst_bool(true))))); |
| var vf33: vec2h = log(vec2h(unconst_f16(24126.7), unconst_f16(846.7))); |
| vf33 = vec2h(a0[0].f0.rb); |
| let vf34: vec4i = a0[0].f0; |
| var vf35: u32 = pack4xU8Clamp(vec4u(unconst_u32(207), unconst_u32(106), unconst_u32(50), unconst_u32(25))); |
| var vf36: vec3h = radians(vec3h(unconst_f16(11335.2), unconst_f16(29059.7), unconst_f16(2589.2))); |
| var vf37: f32 = tan(f32(unconst_f32(0.07821))); |
| var vf38: vec4i = a0[0].f0; |
| vf37 += vec3f(exp(vec3h(unconst_f16(6744.2), unconst_f16(18593.5), unconst_f16(5.480)))).z; |
| vf37 -= f32(a0[0].f0[u32(unconst_u32(207))]); |
| vf33 += vec2h(a0[0].f0.xz); |
| vf38 &= bitcast<vec4i>(exp(vec2f(unconst_f32(0.2595), unconst_f32(0.1600))).grgg); |
| out[u32(unconst_u32(118))] &= vf38; |
| let vf39: array<FragmentOutput1, 1> = a0; |
| var vf40: vec4i = unpack4xI8(u32(unconst_u32(238))); |
| out[u32(unconst_u32(194))] ^= vec4i(i32(pack4x8unorm(vec4f(f32(vf40[u32(unconst_u32(25))]))))); |
| out[0] *= vf34; |
| let vf41: FragmentOutput1 = a0[0]; |
| vf36 = vec3h(f16(any(bool(unconst_bool(false))))); |
| vf38 *= a0[0].f0; |
| let vf42: i32 = sign(i32(unconst_i32(137))); |
| let ptr14: ptr<function, vec4i> = &vf40; |
| var vf43: u32 = dot4U8Packed(u32((*ptr14)[u32(unconst_u32(574))]), u32(unconst_u32(690))); |
| return out; |
| } |
| |
| var<workgroup> vw12: VertexOutput2; |
| |
| var<workgroup> vw13: VertexOutput2; |
| |
| var<workgroup> vw14: VertexOutput2; |
| |
| var<workgroup> vw15: S3; |
| |
| var<workgroup> vw16: VertexOutput2; |
| |
| var<workgroup> vw17: S4; |
| |
| var<workgroup> vw18: S3; |
| |
| @vertex @must_use |
| fn vertex2(@location(9) @interpolate(flat) a0: vec4u, @location(1) @interpolate(flat) a1: vec2u, a2: S3, a3: S4) -> VertexOutput2 { |
| var out: VertexOutput2; |
| out.f11 -= fract(vec2f(unconst_f32(-0.1969), unconst_f32(0.08946))).yyyy; |
| out = VertexOutput2(vec4f(a1.rgrr)); |
| var vf44 = fn1(array<FragmentOutput1, 1>(FragmentOutput1())); |
| let ptr15: ptr<function, vec4i> = &vf44[0]; |
| var vf45 = fn1(array<FragmentOutput1, 1>(FragmentOutput1(vec4i(i32(a2.f0))))); |
| out.f11 += vec4f(bitcast<f32>(vf44[0][u32(unconst_u32(330))])); |
| var vf46: u32 = pack4xI8Clamp(vec4i(fract(vec2f(unconst_f32(0.03817), unconst_f32(0.00828))).ggrg)); |
| out = VertexOutput2(fract(vec2f(unconst_f32(0.1417), unconst_f32(0.5319))).xyyy); |
| out.f11 = vec4f(insertBits(vec4u(unconst_u32(34), unconst_u32(581), unconst_u32(71), unconst_u32(131)), vec4u(unconst_u32(80), unconst_u32(326), unconst_u32(56), unconst_u32(230)), u32(unconst_u32(160)), u32(unconst_u32(147)))); |
| let ptr16: ptr<function, vec4i> = &vf45[0]; |
| vf44[u32(unconst_u32(877))] ^= vec4i(bitcast<i32>(vf46)); |
| return out; |
| } |
| |
| @fragment |
| fn fragment1(@builtin(sample_mask) a0: u32, @invariant @builtin(position) a1: vec4f) -> FragmentOutput1 { |
| var out: FragmentOutput1; |
| out.f0 = vec4i(i32(acos(f16(unconst_f16(4117.6))))); |
| discard; |
| out = FragmentOutput1(vec4i(faceForward(vec3f(unconst_f32(-0.1062), unconst_f32(0.09335), unconst_f32(0.06871)), vec3f(unconst_f32(0.2243), unconst_f32(0.01310), unconst_f32(0.5064)), vec3f(unconst_f32(0.1255), unconst_f32(1.000), unconst_f32(0.2007))).xzyx)); |
| let vf47: u32 = pack4xI8Clamp(vec4i(unconst_i32(0), unconst_i32(49), unconst_i32(179), unconst_i32(48))); |
| return out; |
| } |
| |
| @compute @workgroup_size(1, 1, 1) |
| fn compute2() { |
| let ptr17: ptr<workgroup, VertexOutput2> = &vw14; |
| vw14 = VertexOutput2(vec4f(f32(pack4xI8(vec4i(unconst_i32(54), unconst_i32(56), unconst_i32(114), unconst_i32(52)))))); |
| let vf48: f16 = acos(f16(unconst_f16(7502.1))); |
| let ptr18: ptr<workgroup, f32> = &vw18.f0; |
| textureStore(st4, vec3i(i32(vf48)), vec4f(vec4f(unconst_f32(0.05117), unconst_f32(0.1385), unconst_f32(0.08572), unconst_f32(0.00274)))); |
| var vf49: f32 = (*&vw12).f11[u32(unconst_u32(114))]; |
| let ptr19: ptr<workgroup, f32> = &vw15.f0; |
| }`, |
| }); |
| let buffer12 = device0.createBuffer({ |
| size: 988, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder14 = device0.createCommandEncoder({}); |
| let textureView18 = texture14.createView({label: '\u95b5\u{1ff8f}\u{1fbee}', baseMipLevel: 0, arrayLayerCount: 1}); |
| let computePassEncoder9 = commandEncoder14.beginComputePass({}); |
| try { |
| computePassEncoder2.setBindGroup(2, bindGroup0, new Uint32Array(1947), 280, 0); |
| } catch {} |
| try { |
| buffer9.unmap(); |
| } catch {} |
| let buffer13 = device0.createBuffer({size: 12116, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE}); |
| let textureView19 = texture11.createView({label: '\u06ca\u04c9\u{1fcfa}\u0f3d\u{1fbc1}'}); |
| let sampler4 = device0.createSampler({ |
| label: '\uf163\u1899\ub617\uc414\u0747\u703e', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'clamp-to-edge', |
| minFilter: 'nearest', |
| lodMinClamp: 19.20, |
| lodMaxClamp: 39.83, |
| }); |
| try { |
| renderPassEncoder4.beginOcclusionQuery(65); |
| } catch {} |
| try { |
| computePassEncoder4.setBindGroup(3, bindGroup1); |
| } catch {} |
| try { |
| computePassEncoder0.setBindGroup(0, bindGroup10, new Uint32Array(2544), 188, 0); |
| } catch {} |
| let arrayBuffer2 = buffer0.getMappedRange(0, 0); |
| try { |
| await promise0; |
| } catch {} |
| let buffer14 = device0.createBuffer({ |
| label: '\u{1f677}\u7d69\u63cf\u2251', |
| size: 5744, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE, |
| }); |
| let commandEncoder15 = device0.createCommandEncoder({}); |
| let textureView20 = texture6.createView({label: '\u005f\u4603\u31b4\uc8df\ud3a8\u{1f92b}', arrayLayerCount: 1}); |
| try { |
| renderPassEncoder2.setBindGroup(1, bindGroup3); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(3, bindGroup3, new Uint32Array(1402), 182, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.endOcclusionQuery(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 288, new DataView(new ArrayBuffer(14178)), 992, 108); |
| } catch {} |
| let imageData2 = new ImageData(76, 28); |
| try { |
| renderPassEncoder4.setIndexBuffer(buffer1, 'uint32', 416, 79); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(3, buffer12, 56); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 73, height: 1, depthOrArrayLayers: 54} |
| */ |
| { |
| source: imageData2, |
| origin: { x: 2, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture5, |
| mipLevel: 0, |
| origin: {x: 5, y: 0, z: 9}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 3, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroupLayout6 = device0.createBindGroupLayout({ |
| label: '\udad1\uf309\u{1f9a8}', |
| entries: [ |
| { |
| binding: 11, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'storage', minBindingSize: 660, hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let commandEncoder16 = device0.createCommandEncoder({}); |
| let querySet1 = device0.createQuerySet({type: 'occlusion', count: 406}); |
| let textureView21 = texture20.createView({label: '\u9757\u0fb2\u{1f60d}\u5da3', mipLevelCount: 1, baseArrayLayer: 4, arrayLayerCount: 7}); |
| let computePassEncoder10 = commandEncoder16.beginComputePass({}); |
| try { |
| renderPassEncoder3.setBlendConstant({ r: -722.8, g: -469.1, b: 888.4, a: 231.7, }); |
| } catch {} |
| try { |
| renderPassEncoder4.setStencilReference(1172); |
| } catch {} |
| try { |
| renderPassEncoder4.setIndexBuffer(buffer13, 'uint32', 5_076, 4_838); |
| } catch {} |
| let computePassEncoder11 = commandEncoder15.beginComputePass({label: '\u9b5c\u0188\u{1fed4}\u1bde\ua07d'}); |
| try { |
| renderPassEncoder3.executeBundles([renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder4.setIndexBuffer(buffer1, 'uint16', 130, 17); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(0, buffer8); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 73, height: 1, depthOrArrayLayers: 54} |
| */ |
| { |
| source: imageData0, |
| origin: { x: 2, y: 18 }, |
| flipY: false, |
| }, { |
| texture: texture5, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 33}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 4, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup12 = device0.createBindGroup({layout: bindGroupLayout1, entries: [{binding: 277, resource: sampler2}]}); |
| let commandEncoder17 = device0.createCommandEncoder({}); |
| let texture27 = device0.createTexture({ |
| size: [295, 1, 1], |
| mipLevelCount: 4, |
| format: 'depth24plus-stencil8', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderPassEncoder5 = commandEncoder17.beginRenderPass({ |
| label: '\u{1fdc1}\ud112\u{1f6c4}', |
| colorAttachments: [{ |
| view: textureView16, |
| clearValue: { r: -918.5, g: -8.116, b: 826.2, a: -797.4, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer10, 'uint32', 452, 3_634); |
| } catch {} |
| let bindGroup13 = device0.createBindGroup({ |
| layout: bindGroupLayout3, |
| entries: [ |
| {binding: 225, resource: textureView13}, |
| {binding: 58, resource: {buffer: buffer10, offset: 768, size: 4680}}, |
| ], |
| }); |
| let texture28 = device0.createTexture({ |
| size: {width: 70, height: 72, depthOrArrayLayers: 1}, |
| format: 'stencil8', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let sampler5 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 83.08, |
| lodMaxClamp: 85.71, |
| maxAnisotropy: 16, |
| }); |
| try { |
| computePassEncoder9.setBindGroup(1, bindGroup13); |
| } catch {} |
| try { |
| computePassEncoder5.setBindGroup(0, bindGroup4, new Uint32Array(1136), 456, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.setIndexBuffer(buffer13, 'uint32', 6_100, 3_873); |
| } catch {} |
| let bindGroup14 = device0.createBindGroup({ |
| label: '\u50cb\u46fe\u505d\u07c2\u5383\u0b39\u{1fbf7}\u{1f911}\ucdcb', |
| layout: bindGroupLayout3, |
| entries: [ |
| {binding: 58, resource: {buffer: buffer11, offset: 0, size: 8693}}, |
| {binding: 225, resource: textureView13}, |
| ], |
| }); |
| let buffer15 = device0.createBuffer({ |
| label: '\uf87d\uab18\u0442\ua1d8\u78c7\u{1f9a4}\u3204\u042f', |
| size: 9092, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let textureView22 = texture20.createView({ |
| label: '\u7e2b\u045e\u0429\u01c7\u5512\u{1fd8a}\u068a\u{1f9cf}\u{1fef3}\u0d69', |
| dimension: '2d', |
| mipLevelCount: 1, |
| baseArrayLayer: 1, |
| }); |
| try { |
| computePassEncoder0.setBindGroup(2, bindGroup7, new Uint32Array(1172), 202, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer1, 'uint16', 2, 147); |
| } catch {} |
| let textureView23 = texture18.createView({baseMipLevel: 0, baseArrayLayer: 0}); |
| let texture29 = device0.createTexture({ |
| label: '\u79de\u0d60\u2bc2\u0441\u019d\u65fc\u8668\u979e', |
| size: {width: 280}, |
| dimension: '1d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let sampler6 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeW: 'clamp-to-edge', |
| lodMinClamp: 44.83, |
| lodMaxClamp: 71.69, |
| compare: 'less-equal', |
| }); |
| try { |
| computePassEncoder2.end(); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(7, buffer10, 0, 453); |
| } catch {} |
| await gc(); |
| let bindGroup15 = device0.createBindGroup({ |
| label: '\u{1fb6f}\ud1aa\ud401\u06a5\u{1f723}\u421c\u{1fa76}', |
| layout: bindGroupLayout6, |
| entries: [{binding: 11, resource: {buffer: buffer15, offset: 1792}}], |
| }); |
| let commandEncoder18 = device0.createCommandEncoder({}); |
| let commandBuffer0 = commandEncoder4.finish(); |
| let texture30 = device0.createTexture({ |
| size: {width: 560, height: 582, depthOrArrayLayers: 1}, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| viewFormats: ['rgba16sint'], |
| }); |
| let computePassEncoder12 = commandEncoder18.beginComputePass({}); |
| try { |
| computePassEncoder0.setBindGroup(2, bindGroup13); |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(2, bindGroup10, []); |
| } catch {} |
| try { |
| renderPassEncoder4.beginOcclusionQuery(2); |
| } catch {} |
| try { |
| renderPassEncoder4.endOcclusionQuery(); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let imageData3 = new ImageData(44, 28); |
| let commandEncoder19 = device0.createCommandEncoder({label: '\u4d39\u4b2e\uf6d5\u0bca'}); |
| let texture31 = device0.createTexture({ |
| size: {width: 48, height: 1, depthOrArrayLayers: 47}, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView24 = texture29.createView({}); |
| let computePassEncoder13 = commandEncoder19.beginComputePass({}); |
| try { |
| computePassEncoder0.end(); |
| } catch {} |
| try { |
| renderPassEncoder0.executeBundles([renderBundle0]); |
| } catch {} |
| try { |
| commandEncoder1.copyBufferToBuffer(buffer7, 8940, buffer5, 4384, 3240); |
| } catch {} |
| let offscreenCanvas0 = new OffscreenCanvas(20, 21); |
| let buffer16 = device0.createBuffer({ |
| label: '\ub3e4\ubfd2\ucdbe\u0430\u{1fa74}\ud009\u636c\ueab5\u{1f74c}\u{1fe20}', |
| size: 11156, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let textureView25 = texture7.createView({}); |
| try { |
| renderPassEncoder2.executeBundles([renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer4, 'uint32', 19_380, 56); |
| } catch {} |
| try { |
| commandEncoder1.copyBufferToTexture({ |
| /* bytesInLastRow: 136 widthInBlocks: 17 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 200 */ |
| offset: 200, |
| bytesPerRow: 32000, |
| rowsPerImage: 247, |
| buffer: buffer7, |
| }, { |
| texture: texture24, |
| mipLevel: 0, |
| origin: {x: 12, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 17, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 73, height: 1, depthOrArrayLayers: 54} |
| */ |
| { |
| source: imageData3, |
| origin: { x: 12, y: 9 }, |
| flipY: false, |
| }, { |
| texture: texture5, |
| mipLevel: 0, |
| origin: {x: 3, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 4, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder20 = device0.createCommandEncoder({}); |
| let texture32 = device0.createTexture({ |
| size: {width: 73, height: 1, depthOrArrayLayers: 1}, |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder12.setBindGroup(3, bindGroup5, new Uint32Array(688), 144, 0); |
| } catch {} |
| try { |
| commandEncoder20.copyBufferToTexture({ |
| /* bytesInLastRow: 72 widthInBlocks: 9 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 600 */ |
| offset: 600, |
| bytesPerRow: 25088, |
| buffer: buffer7, |
| }, { |
| texture: texture6, |
| mipLevel: 0, |
| origin: {x: 3, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 9, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder1.clearBuffer(buffer11, 2080, 760); |
| } catch {} |
| let buffer17 = device0.createBuffer({size: 2938, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let texture33 = device0.createTexture({ |
| size: [560, 582, 1], |
| format: 'depth32float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture34 = device0.createTexture({ |
| size: {width: 295, height: 1, depthOrArrayLayers: 17}, |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder14 = commandEncoder1.beginComputePass({label: '\uc59f\u9858\u9e96\u{1fdd3}\u90e0'}); |
| try { |
| renderPassEncoder3.setBindGroup(2, bindGroup8, new Uint32Array(2000), 109, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.executeBundles([]); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture18, |
| mipLevel: 0, |
| origin: {x: 9, y: 0, z: 1}, |
| aspect: 'all', |
| }, new Uint8Array(878_948).fill(128), /* required buffer size: 878_948 */ |
| {offset: 26, bytesPerRow: 66, rowsPerImage: 193}, {width: 12, height: 0, depthOrArrayLayers: 70}); |
| } catch {} |
| let bindGroup16 = device0.createBindGroup({ |
| label: '\u350e\u1369\u9a5c\u06bb', |
| layout: bindGroupLayout0, |
| entries: [{binding: 176, resource: textureView8}, {binding: 103, resource: textureView3}], |
| }); |
| let commandEncoder21 = device0.createCommandEncoder(); |
| try { |
| computePassEncoder12.setBindGroup(1, bindGroup9); |
| } catch {} |
| try { |
| computePassEncoder3.setBindGroup(1, bindGroup6, new Uint32Array(180), 155, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(2, bindGroup5, new Uint32Array(775), 55, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.beginOcclusionQuery(0); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(5, buffer12); |
| } catch {} |
| try { |
| commandEncoder20.clearBuffer(buffer3, 120, 24); |
| } catch {} |
| try { |
| commandEncoder20.resolveQuerySet(querySet0, 29, 42, buffer6, 0); |
| } catch {} |
| let buffer18 = device0.createBuffer({ |
| size: 5719, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let textureView26 = texture34.createView({aspect: 'all', arrayLayerCount: 1}); |
| let renderBundleEncoder1 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2uint'], depthReadOnly: true}); |
| let renderBundle1 = renderBundleEncoder1.finish({}); |
| try { |
| computePassEncoder13.setBindGroup(1, bindGroup7); |
| } catch {} |
| try { |
| renderPassEncoder4.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder2.executeBundles([renderBundle0, renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder5.setVertexBuffer(0, buffer8); |
| } catch {} |
| try { |
| commandEncoder20.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 144 */ |
| offset: 144, |
| bytesPerRow: 12544, |
| buffer: buffer3, |
| }, { |
| texture: texture32, |
| mipLevel: 0, |
| origin: {x: 17, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let gpuCanvasContext0 = offscreenCanvas0.getContext('webgpu'); |
| let buffer19 = device0.createBuffer({size: 9888, usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE}); |
| let textureView27 = texture22.createView({}); |
| let computePassEncoder15 = commandEncoder21.beginComputePass({}); |
| let sampler7 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| magFilter: 'nearest', |
| lodMinClamp: 70.08, |
| lodMaxClamp: 73.68, |
| }); |
| try { |
| computePassEncoder7.setBindGroup(2, bindGroup7, new Uint32Array(129), 23, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(2, bindGroup16); |
| } catch {} |
| try { |
| renderPassEncoder5.setVertexBuffer(7, buffer12); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer2, 280, new Float32Array(12639), 121, 156); |
| } catch {} |
| await gc(); |
| let buffer20 = device0.createBuffer({size: 635, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT}); |
| let commandEncoder22 = device0.createCommandEncoder({label: '\u3462\udaf1\u0b97\u7bbd\u{1ff92}\u0f58\u0ca8'}); |
| let computePassEncoder16 = commandEncoder20.beginComputePass(); |
| let renderPassEncoder6 = commandEncoder22.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView5, |
| clearValue: { r: -875.6, g: -367.5, b: -56.20, a: 64.03, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| renderPassEncoder1.setBindGroup(1, bindGroup14); |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer10, 'uint32', 3_524, 752); |
| } catch {} |
| let commandEncoder23 = device0.createCommandEncoder({}); |
| let texture35 = gpuCanvasContext0.getCurrentTexture(); |
| let textureView28 = texture3.createView({aspect: 'all'}); |
| let renderPassEncoder7 = commandEncoder23.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView19, |
| depthSlice: 293, |
| clearValue: { r: -996.6, g: -819.4, b: 659.1, a: -201.7, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet0, |
| }); |
| try { |
| renderPassEncoder1.executeBundles([renderBundle0, renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(4, buffer6, 0, 502); |
| } catch {} |
| try { |
| if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55); }; |
| } catch {} |
| try { |
| computePassEncoder10.setBindGroup(0, bindGroup3); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(3, bindGroup6, new Uint32Array(951), 2, 0); |
| } catch {} |
| let buffer21 = device0.createBuffer({ |
| size: 13170, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let commandEncoder24 = device0.createCommandEncoder(); |
| let computePassEncoder17 = commandEncoder24.beginComputePass({}); |
| let sampler8 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 81.44, |
| maxAnisotropy: 11, |
| }); |
| try { |
| computePassEncoder14.setBindGroup(3, bindGroup11); |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer21, 'uint16', 11_190, 32); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(2, buffer10, 0, 2_880); |
| } catch {} |
| let shaderModule3 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| requires readonly_and_readwrite_storage_textures; |
| |
| diagnostic(info, xyz); |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| @group(0) @binding(103) var st6: texture_storage_3d<rgba8unorm, write>; |
| |
| @group(0) @binding(176) var st7: texture_storage_3d<rgba16uint, write>; |
| |
| struct T0 { |
| @align(16) @size(16) f0: array<array<atomic<u32>, 1>>, |
| } |
| |
| struct T1 { |
| @size(128) f0: array<array<array<array<atomic<i32>, 1>, 1>, 1>>, |
| } |
| |
| struct T2 { |
| @align(64) @size(448) f0: array<atomic<i32>>, |
| } |
| |
| struct T3 { |
| @size(8) f0: array<u32>, |
| } |
| |
| struct FragmentOutput2 { |
| @location(0) f0: vec4i, |
| @location(5) @interpolate(perspective, sample) f1: vec2f, |
| @builtin(sample_mask) f2: u32, |
| @location(4) f3: vec4f, |
| } |
| |
| var<workgroup> vw19: array<atomic<i32>, 1>; |
| |
| var<workgroup> vw20: FragmentOutput2; |
| |
| var<workgroup> vw21: FragmentOutput2; |
| |
| var<private> vp1 = array(modf(f16(2628.8)), modf(f16(1164.1)), modf(f16(8341.4)), modf(f16(16079.8)), modf(f16(10205.6)), modf(f16(2010.2)), modf(f16(10410.1)), modf(f16(8688.9)), modf(f16(2858.1)), modf(f16(4805.4)), modf(f16(23514.1)), modf(f16(9922.7)), modf(f16(3082.1)), modf(f16(184.0)), modf(f16(26471.5)), modf(f16(1592.3)), modf(f16(18645.6)), modf(f16(-26209.4)), modf(f16(1536.3)), modf(f16(17110.9)), modf(f16(2083.9)), modf(f16(10535.7)), modf(f16(28160.3)), modf(f16(3099.7)), modf(f16(-17931.9)), modf(f16(2097.9)), modf(f16(5539.1)), modf(f16(835.0)), modf(f16(290.1)), modf(f16(11590.5)), modf(f16(4862.1)), modf(f16(3396.8)), modf(f16(-15859.7)), modf(f16(3637.2)), modf(f16(5239.3)), modf(f16(4573.7)), modf(f16(-3050.5)), modf(f16(13568.2)), modf(f16(2290.6)), modf(f16(-23701.7))); |
| |
| @fragment |
| fn fragment2() -> FragmentOutput2 { |
| var out: FragmentOutput2; |
| out.f0 = bitcast<vec4i>(pow(vec2f(unconst_f32(0.09710), unconst_f32(0.3528)), vec2f(unconst_f32(0.04970), unconst_f32(0.01549))).ggrr); |
| let vf50: vec4h = cosh(vec4h(unconst_f16(15814.8), unconst_f16(665.7), unconst_f16(981.0), unconst_f16(-3240.3))); |
| let vf51: vec4h = vf50; |
| out.f1 = vec2f(f32(vp1[39].whole)); |
| out.f2 -= u32(vp1[39].whole); |
| out.f3 = vec4f(f32(vp1[39].fract)); |
| let ptr20 = &vp1[39]; |
| let vf52: vec4h = vf50; |
| out.f2 *= u32(vp1[39].fract); |
| let ptr21 = &(*ptr20); |
| let vf53: f16 = vf50[u32(unconst_u32(188))]; |
| let ptr22: ptr<private, f16> = &vp1[u32(unconst_u32(408))].fract; |
| let ptr23: ptr<private, f16> = &(*ptr20).whole; |
| let vf54: vec4f = log(vec4f(unconst_f32(0.1841), unconst_f32(0.1240), unconst_f32(0.2457), unconst_f32(0.02834))); |
| return out; |
| } |
| |
| @compute @workgroup_size(4, 1, 1) |
| fn compute3(@builtin(num_workgroups) a0: vec3u) { |
| vw21.f3 += unpack4x8snorm(pack4xI8(vec4i(unconst_i32(61), unconst_i32(121), unconst_i32(48), unconst_i32(387)))); |
| vw20.f3 -= vw21.f3; |
| let vf55: f32 = (*&vw20).f3[u32(unconst_u32(238))]; |
| let vf56: vec2f = unpack2x16float(u32(unconst_u32(456))); |
| let ptr24: ptr<workgroup, FragmentOutput2> = &vw21; |
| vw21.f0 = vec4i(bitcast<i32>(vw20.f1[u32(unconst_u32(202))])); |
| vw20 = FragmentOutput2(vec4i(vw21.f0[u32(unconst_u32(22))]), vec2f(f32(vw21.f0[u32(unconst_u32(22))])), bitcast<u32>(vw21.f0[u32(unconst_u32(22))]), vec4f(f32(vw21.f0[u32(unconst_u32(22))]))); |
| let ptr25: ptr<workgroup, vec4i> = &vw20.f0; |
| let vf57: vec3u = a0; |
| vp1[u32(unconst_u32(29))] = modf(normalize(vec4h(unconst_f16(18620.9), unconst_f16(8754.8), unconst_f16(1582.6), unconst_f16(32423.9))).y); |
| let ptr26: ptr<workgroup, vec4i> = &vw20.f0; |
| let vf58: vec2h = abs(vec2h(unconst_f16(4460.1), unconst_f16(11625.8))); |
| let ptr27: ptr<workgroup, vec4i> = &(*ptr25); |
| let ptr28: ptr<workgroup, vec4f> = &(*&vw21).f3; |
| var vf59: vec2h = vf58; |
| let ptr29: ptr<workgroup, u32> = &(*ptr24).f2; |
| let ptr30: ptr<workgroup, vec4i> = &(*&vw21).f0; |
| var vf60: f32 = (*&vw20).f1[u32(unconst_u32(232))]; |
| vf59 = bitcast<vec2h>((*&vw21).f1[u32(unconst_u32(83))]); |
| var vf61: u32 = pack2x16float(vec2f(unconst_f32(0.03597), unconst_f32(-0.2529))); |
| }`, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| try { |
| computePassEncoder15.setBindGroup(3, bindGroup3, new Uint32Array(53), 12, 0); |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(3, bindGroup12, new Uint32Array(6558), 1_660, 0); |
| } catch {} |
| let texture36 = device0.createTexture({ |
| size: {width: 36, height: 1, depthOrArrayLayers: 1}, |
| dimension: '2d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder9.setBindGroup(0, bindGroup6); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer21, 'uint32', 1_708, 399); |
| } catch {} |
| try { |
| renderPassEncoder4.setVertexBuffer(0, buffer15, 0); |
| } catch {} |
| let buffer22 = device0.createBuffer({ |
| size: 2340, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| mappedAtCreation: false, |
| }); |
| let texture37 = device0.createTexture({ |
| label: '\u10e1\u0cc4', |
| size: {width: 440}, |
| dimension: '1d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let textureView29 = texture7.createView({}); |
| let bindGroup17 = device0.createBindGroup({ |
| layout: bindGroupLayout4, |
| entries: [{binding: 511, resource: {buffer: buffer21, offset: 2304, size: 840}}], |
| }); |
| let buffer23 = device0.createBuffer({ |
| size: 22704, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM, |
| }); |
| try { |
| computePassEncoder10.setBindGroup(1, bindGroup8); |
| } catch {} |
| try { |
| renderPassEncoder0.executeBundles([renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder6.setStencilReference(176); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(5, buffer8); |
| } catch {} |
| let img0 = await imageWithData(93, 18, '#10101010', '#20202020'); |
| let commandEncoder25 = device0.createCommandEncoder({}); |
| let texture38 = device0.createTexture({ |
| size: {width: 384, height: 1, depthOrArrayLayers: 1}, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let sampler9 = device0.createSampler({ |
| label: '\ua8b5\u{1f89e}\u8d82\u7ed8\u0809\u2229\u0217\u7238\u{1ff09}', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 53.78, |
| lodMaxClamp: 90.46, |
| compare: 'not-equal', |
| }); |
| try { |
| computePassEncoder6.setBindGroup(0, bindGroup9); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(1, buffer6, 644); |
| } catch {} |
| try { |
| device0.queue.label = '\u01ad\ua518\u00f7\u{1f78f}\u02cc\u{1f74a}\u0779'; |
| } catch {} |
| let querySet2 = device0.createQuerySet({ |
| label: '\uec8b\u920d\u8bb6\u{1f920}\u97b7\ud5a0\uae97\u251b\uf880\ubaba', |
| type: 'occlusion', |
| count: 1004, |
| }); |
| let textureView30 = texture12.createView({}); |
| let computePassEncoder18 = commandEncoder25.beginComputePass({}); |
| try { |
| computePassEncoder1.setBindGroup(3, bindGroup14, new Uint32Array(243), 11, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.setBlendConstant({ r: 785.5, g: -448.8, b: 534.2, a: -684.6, }); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(1, buffer4, 0); |
| } catch {} |
| let promise1 = device0.queue.onSubmittedWorkDone(); |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| document.body.prepend(img0); |
| let textureView31 = texture6.createView({dimension: '2d-array', baseMipLevel: 0}); |
| try { |
| computePassEncoder12.setBindGroup(3, bindGroup13); |
| } catch {} |
| try { |
| computePassEncoder11.setBindGroup(2, bindGroup4, []); |
| } catch {} |
| try { |
| computePassEncoder17.setBindGroup(2, bindGroup4, new Uint32Array(3047), 562, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(0, buffer8); |
| } catch {} |
| try { |
| if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(0x55); }; |
| } catch {} |
| let commandEncoder26 = device0.createCommandEncoder({}); |
| let texture39 = device0.createTexture({ |
| size: {width: 295, height: 1, depthOrArrayLayers: 1}, |
| format: 'depth24plus', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture40 = device0.createTexture({ |
| size: {width: 73, height: 1, depthOrArrayLayers: 1}, |
| sampleCount: 1, |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| let computePassEncoder19 = commandEncoder26.beginComputePass(); |
| try { |
| renderPassEncoder5.setBindGroup(1, bindGroup8, new Uint32Array(2263), 31, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.setStencilReference(213); |
| } catch {} |
| let sampler10 = device0.createSampler({ |
| label: '\ua0f8\u076b', |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'clamp-to-edge', |
| magFilter: 'nearest', |
| lodMinClamp: 18.51, |
| lodMaxClamp: 86.49, |
| compare: 'greater', |
| }); |
| let texture41 = device0.createTexture({ |
| size: [192, 1, 5], |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder4.setBindGroup(3, bindGroup14, new Uint32Array(613), 89, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 236, new Float32Array(441), 31, 0); |
| } catch {} |
| let bindGroupLayout7 = device0.createBindGroupLayout({ |
| label: '\u04d1\u522a', |
| entries: [ |
| { |
| binding: 54, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| {binding: 53, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| ], |
| }); |
| let commandEncoder27 = device0.createCommandEncoder({}); |
| let textureView32 = texture11.createView({arrayLayerCount: 1}); |
| try { |
| computePassEncoder3.setBindGroup(2, bindGroup8, new Uint32Array(1433), 1_012, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer21, 'uint16', 2_502, 148); |
| } catch {} |
| let textureView33 = texture21.createView({arrayLayerCount: 12}); |
| try { |
| computePassEncoder1.setBindGroup(2, bindGroup17); |
| } catch {} |
| try { |
| renderPassEncoder2.setIndexBuffer(buffer13, 'uint32', 404, 1_390); |
| } catch {} |
| try { |
| commandEncoder27.copyBufferToTexture({ |
| /* bytesInLastRow: 240 widthInBlocks: 30 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 2272 */ |
| offset: 2272, |
| buffer: buffer23, |
| }, { |
| texture: texture8, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 30, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder27.clearBuffer(buffer6, 228, 152); |
| } catch {} |
| let buffer24 = device0.createBuffer({ |
| size: 5033, |
| usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder28 = device0.createCommandEncoder({}); |
| let texture42 = device0.createTexture({ |
| size: {width: 192, height: 1, depthOrArrayLayers: 262}, |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let textureView34 = texture29.createView({dimension: '1d', aspect: 'all'}); |
| let renderPassEncoder8 = commandEncoder28.beginRenderPass({ |
| label: '\u072d\u075d\u0133\u5373\u2df3\u0f9d', |
| colorAttachments: [{ |
| view: textureView4, |
| depthSlice: 182, |
| clearValue: { r: -523.9, g: -589.3, b: 948.6, a: 225.2, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| maxDrawCount: 53331445, |
| }); |
| try { |
| renderPassEncoder5.setBindGroup(2, bindGroup0, new Uint32Array(272), 51, 0); |
| } catch {} |
| try { |
| commandEncoder27.copyBufferToTexture({ |
| /* bytesInLastRow: 16 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 152 */ |
| offset: 152, |
| bytesPerRow: 1280, |
| buffer: buffer11, |
| }, { |
| texture: texture30, |
| mipLevel: 0, |
| origin: {x: 55, y: 152, z: 0}, |
| aspect: 'all', |
| }, {width: 2, height: 67, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder29 = device0.createCommandEncoder({}); |
| let texture43 = device0.createTexture({ |
| label: '\uf688\u{1f6cc}\u5d41', |
| size: {width: 70, height: 72, depthOrArrayLayers: 1}, |
| sampleCount: 1, |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder6.executeBundles([renderBundle0, renderBundle0, renderBundle0]); |
| } catch {} |
| try { |
| buffer9.unmap(); |
| } catch {} |
| try { |
| computePassEncoder18.pushDebugGroup('\u8214'); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture43, |
| mipLevel: 0, |
| origin: {x: 1, y: 15, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(63).fill(239), /* required buffer size: 63 */ |
| {offset: 63, bytesPerRow: 147, rowsPerImage: 32}, {width: 25, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| let textureView35 = texture9.createView({mipLevelCount: 1}); |
| let computePassEncoder20 = commandEncoder29.beginComputePass({}); |
| let renderPassEncoder9 = commandEncoder27.beginRenderPass({colorAttachments: [{view: textureView20, loadOp: 'clear', storeOp: 'store'}]}); |
| let sampler11 = device0.createSampler({ |
| label: '\u{1f725}\ua633\u0681\u7d3d\u0a94\ub24d', |
| addressModeU: 'repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 24.85, |
| lodMaxClamp: 83.62, |
| maxAnisotropy: 20, |
| }); |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer21, 'uint32', 3_792, 2_504); |
| } catch {} |
| let bindGroup18 = device0.createBindGroup({ |
| layout: bindGroupLayout6, |
| entries: [{binding: 11, resource: {buffer: buffer21, offset: 768, size: 1668}}], |
| }); |
| let commandEncoder30 = device0.createCommandEncoder(); |
| let textureView36 = texture26.createView({dimension: '2d-array', aspect: 'all'}); |
| let computePassEncoder21 = commandEncoder30.beginComputePass(); |
| try { |
| renderPassEncoder8.setBindGroup(1, bindGroup7, new Uint32Array(1657), 74, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.executeBundles([renderBundle0, renderBundle0]); |
| } catch {} |
| try { |
| computePassEncoder6.setBindGroup(2, bindGroup10, new Uint32Array(1142), 50, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.setBindGroup(1, bindGroup10, new Uint32Array(414), 50, 0); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(0, buffer18, 0, 289); |
| } catch {} |
| try { |
| computePassEncoder10.pushDebugGroup('\u{1ff60}'); |
| } catch {} |
| let buffer25 = device0.createBuffer({size: 17662, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT}); |
| let textureView37 = texture17.createView({mipLevelCount: 1}); |
| try { |
| renderPassEncoder4.setBindGroup(3, bindGroup4, new Uint32Array(1419), 164, 0); |
| } catch {} |
| try { |
| computePassEncoder18.popDebugGroup(); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer0]); |
| } catch {} |
| let videoFrame0 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte240m', primaries: 'smpte170m', transfer: 'unspecified'} }); |
| try { |
| commandEncoder6.label = '\u{1ff56}\u{1f6ec}\ud67c\u58e3\ua096\u{1fa57}\uc12d\u{1fd92}'; |
| } catch {} |
| let commandEncoder31 = device0.createCommandEncoder({}); |
| let texture44 = device0.createTexture({ |
| label: '\uf25f\u0be0\u{1f73d}\ubd30', |
| size: [295, 1, 57], |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| let computePassEncoder22 = commandEncoder31.beginComputePass({}); |
| try { |
| renderPassEncoder7.setBindGroup(2, bindGroup6); |
| } catch {} |
| try { |
| renderPassEncoder9.setBindGroup(3, bindGroup13, new Uint32Array(903), 114, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer6, 112, new Float32Array(4738), 156, 48); |
| } catch {} |
| let textureView38 = texture43.createView({}); |
| let renderBundleEncoder2 = device0.createRenderBundleEncoder({ |
| label: '\u0cc6\u3bd6\ub822\uf155\u079d\ued42\u746b', |
| colorFormats: ['rgb10a2uint'], |
| depthReadOnly: true, |
| }); |
| let renderBundle2 = renderBundleEncoder2.finish({}); |
| try { |
| renderPassEncoder7.setBindGroup(2, bindGroup16); |
| } catch {} |
| try { |
| renderPassEncoder9.setIndexBuffer(buffer4, 'uint32', 4_620, 2_448); |
| } catch {} |
| try { |
| device0.queue.label = '\u{1f997}\u2610\u4fae'; |
| } catch {} |
| let bindGroupLayout8 = device0.createBindGroupLayout({ |
| label: '\u{1fe3b}\u53a6\u{1ff16}\u7885', |
| entries: [ |
| { |
| binding: 27, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| try { |
| computePassEncoder13.setBindGroup(2, bindGroup1, new Uint32Array(203), 60, 0); |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(2, bindGroup12); |
| } catch {} |
| try { |
| renderPassEncoder9.setIndexBuffer(buffer13, 'uint32', 5_860, 370); |
| } catch {} |
| try { |
| renderPassEncoder8.setVertexBuffer(6, buffer4); |
| } catch {} |
| let promise2 = device0.queue.onSubmittedWorkDone(); |
| try { |
| globalThis.someLabel = textureView23.label; |
| } catch {} |
| let bindGroup19 = device0.createBindGroup({ |
| label: '\u{1ff9f}\u0d9e\u0427\u{1f8c1}\ufd88', |
| layout: bindGroupLayout4, |
| entries: [{binding: 511, resource: {buffer: buffer24, offset: 256, size: 564}}], |
| }); |
| let commandEncoder32 = device0.createCommandEncoder({}); |
| let texture45 = device0.createTexture({ |
| size: {width: 140, height: 145, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder23 = commandEncoder32.beginComputePass({}); |
| try { |
| computePassEncoder6.setBindGroup(2, bindGroup7, []); |
| } catch {} |
| try { |
| renderPassEncoder7.setBindGroup(2, bindGroup1); |
| } catch {} |
| try { |
| renderPassEncoder8.setVertexBuffer(2, buffer10); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture9, |
| mipLevel: 1, |
| origin: {x: 4, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(193).fill(240), /* required buffer size: 193 */ |
| {offset: 193}, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(img0); |
| let bindGroup20 = device0.createBindGroup({ |
| layout: bindGroupLayout4, |
| entries: [{binding: 511, resource: {buffer: buffer12, offset: 0, size: 268}}], |
| }); |
| let textureView39 = texture16.createView({dimension: '2d', aspect: 'depth-only', mipLevelCount: 1, baseArrayLayer: 4}); |
| let sampler12 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 61.86, |
| lodMaxClamp: 83.92, |
| }); |
| try { |
| computePassEncoder17.setBindGroup(3, bindGroup7, new Uint32Array(4161), 2_255, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(3, bindGroup3); |
| } catch {} |
| let commandEncoder33 = device0.createCommandEncoder(); |
| let texture46 = device0.createTexture({ |
| size: [280, 291, 1], |
| format: 'depth32float-stencil8', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture47 = device0.createTexture({ |
| size: {width: 384, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let computePassEncoder24 = commandEncoder33.beginComputePass({}); |
| let sampler13 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'mirror-repeat', |
| magFilter: 'nearest', |
| mipmapFilter: 'linear', |
| lodMinClamp: 99.58, |
| lodMaxClamp: 99.68, |
| compare: 'never', |
| maxAnisotropy: 1, |
| }); |
| try { |
| buffer12.unmap(); |
| } catch {} |
| let buffer26 = device0.createBuffer({ |
| size: 3113, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| mappedAtCreation: false, |
| }); |
| let commandEncoder34 = device0.createCommandEncoder({}); |
| let computePassEncoder25 = commandEncoder34.beginComputePass({}); |
| try { |
| computePassEncoder14.setBindGroup(3, bindGroup2); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer23, 'uint16', 1_230, 827); |
| } catch {} |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55); }; |
| } catch {} |
| let textureView40 = texture22.createView({}); |
| let texture48 = device0.createTexture({ |
| size: {width: 440}, |
| dimension: '1d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder3.setBindGroup(2, bindGroup13, new Uint32Array(1428), 274, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.setVertexBuffer(1, buffer18, 0); |
| } catch {} |
| try { |
| computePassEncoder10.popDebugGroup(); |
| } catch {} |
| try { |
| await promise2; |
| } catch {} |
| let videoFrame1 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX', timestamp: 0, colorSpace: {fullRange: true, matrix: 'unspecified', primaries: 'bt470m', transfer: 'smpte170m'} }); |
| let bindGroup21 = device0.createBindGroup({ |
| label: '\uc82a\u{1f9fc}\u{1f885}\u{1f674}\u8177', |
| layout: bindGroupLayout3, |
| entries: [{binding: 225, resource: textureView13}, {binding: 58, resource: {buffer: buffer16, offset: 512}}], |
| }); |
| let buffer27 = device0.createBuffer({ |
| size: 1824, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let textureView41 = texture42.createView({mipLevelCount: 1}); |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 96, height: 1, depthOrArrayLayers: 131} |
| */ |
| { |
| source: imageData0, |
| origin: { x: 4, y: 35 }, |
| flipY: true, |
| }, { |
| texture: texture18, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 17}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 12, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.append(img0); |
| let texture49 = device0.createTexture({ |
| size: {width: 384}, |
| dimension: '1d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder4.setBindGroup(1, bindGroup7, new Uint32Array(3120), 139, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(5, buffer15); |
| } catch {} |
| try { |
| device0.pushErrorScope('validation'); |
| } catch {} |
| let promise3 = device0.queue.onSubmittedWorkDone(); |
| let shaderModule4 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| requires unrestricted_pointer_parameters; |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| @group(0) @binding(103) var st8: texture_storage_3d<rgba8unorm, write>; |
| |
| @group(0) @binding(176) var st9: texture_storage_3d<rgba16uint, write>; |
| |
| struct T0 { |
| @size(128) f0: array<array<atomic<u32>, 5>, 1>, |
| @size(1216) f1: array<array<array<array<atomic<i32>, 1>, 1>, 1>>, |
| } |
| |
| struct T1 { |
| @align(64) @size(448) f0: array<u32>, |
| } |
| |
| struct T2 { |
| @align(32) @size(1280) f0: array<atomic<i32>>, |
| } |
| |
| struct S5 { |
| @location(15) f0: f32, |
| @location(10) f1: vec4u, |
| @location(9) @interpolate(flat, centroid) f2: vec2u, |
| @location(13) @interpolate(flat, sample) f3: vec2i, |
| @location(3) @interpolate(flat) f4: vec4i, |
| @location(12) @interpolate(flat, centroid) f5: vec4i, |
| @location(1) f6: vec4f, |
| @location(0) f7: vec2i, |
| } |
| |
| struct S6 { |
| @location(11) @interpolate(flat) f0: vec4i, |
| @location(2) @interpolate(flat, sample) f1: u32, |
| } |
| |
| struct S7 { |
| @location(5) f0: vec2h, |
| } |
| |
| struct VertexOutput3 { |
| @builtin(position) f12: vec4f, |
| @location(10) @interpolate(flat, sample) f13: vec4u, |
| @location(11) @interpolate(flat, centroid) f14: vec4u, |
| @location(14) @interpolate(flat, center) f15: vec4u, |
| @location(8) @interpolate(flat, centroid) f16: vec2u, |
| @location(9) f17: f16, |
| } |
| |
| struct FragmentOutput3 { |
| @location(0) f0: vec4i, |
| @location(7) f1: f32, |
| } |
| |
| struct FragmentOutput4 { |
| @location(1) @interpolate(flat) f0: i32, |
| @location(3) @interpolate(flat) f1: vec4i, |
| @location(0) f2: vec4u, |
| } |
| |
| alias vec3b = vec3<bool>; |
| |
| fn fn0() -> mat3x3h { |
| var out: mat3x3h; |
| let vf62: vec4f = asin(vec4f(unconst_f32(0.04794), unconst_f32(0.09500), unconst_f32(0.08847), unconst_f32(0.09376))); |
| var vf63: vec3f = sin(vec3f(unconst_f32(0.06197), unconst_f32(-0.3807), unconst_f32(0.1705))); |
| out = mat3x3h(f16(pack4xU8Clamp(vec4u(unconst_u32(78), unconst_u32(3), unconst_u32(121), unconst_u32(151)))), f16(pack4xU8Clamp(vec4u(unconst_u32(78), unconst_u32(3), unconst_u32(121), unconst_u32(151)))), f16(pack4xU8Clamp(vec4u(unconst_u32(78), unconst_u32(3), unconst_u32(121), unconst_u32(151)))), f16(pack4xU8Clamp(vec4u(unconst_u32(78), unconst_u32(3), unconst_u32(121), unconst_u32(151)))), f16(pack4xU8Clamp(vec4u(unconst_u32(78), unconst_u32(3), unconst_u32(121), unconst_u32(151)))), f16(pack4xU8Clamp(vec4u(unconst_u32(78), unconst_u32(3), unconst_u32(121), unconst_u32(151)))), f16(pack4xU8Clamp(vec4u(unconst_u32(78), unconst_u32(3), unconst_u32(121), unconst_u32(151)))), f16(pack4xU8Clamp(vec4u(unconst_u32(78), unconst_u32(3), unconst_u32(121), unconst_u32(151)))), f16(pack4xU8Clamp(vec4u(unconst_u32(78), unconst_u32(3), unconst_u32(121), unconst_u32(151))))); |
| let vf64: vec3h = mix(vec3h(asin(vec4f(unconst_f32(0.04242), unconst_f32(0.1437), unconst_f32(0.07283), unconst_f32(0.02475))).zyy), vec3h(unconst_f16(24526.7), unconst_f16(13408.7), unconst_f16(4117.5)), vec3h(unconst_f16(3019.2), unconst_f16(176.6), unconst_f16(20660.2))); |
| var vf65: vec2f = unpack2x16unorm(u32(unconst_u32(374))); |
| let vf66: vec3h = vf64; |
| vf63 = vec3f(firstTrailingBit(vec2i(unconst_i32(82), unconst_i32(373))).grr); |
| vf63 -= vec3f(vf63[u32(unconst_u32(39))]); |
| let vf67: vec4f = vf62; |
| vf65 = vf67.bg; |
| var vf68: vec4f = vf62; |
| let vf69: f32 = vf68[u32(unconst_u32(123))]; |
| vf63 -= vec3f(mix(vec3h(unconst_f16(13105.0), unconst_f16(4302.1), unconst_f16(4596.7)), vec3h(unconst_f16(85.65), unconst_f16(1187.4), unconst_f16(2308.2)), vec3h(unconst_f16(52.82), unconst_f16(36536.9), unconst_f16(17793.1)))); |
| out = mat3x3h(vec3h(vf62.brb), vec3h(vf62.aaa), vec3h(vf62.xyz)); |
| let vf70: f32 = vf67[u32(unconst_u32(128))]; |
| var vf71: f16 = vf64[u32(unconst_u32(205))]; |
| return out; |
| } |
| |
| fn fn1() -> mat3x2f { |
| var out: mat3x2f; |
| let vf72: vec4i = insertBits(vec4i(unconst_i32(568), unconst_i32(406), unconst_i32(199), unconst_i32(154)), vec4i(i32(distance(vec3h(unconst_f16(5649.1), unconst_f16(13164.3), unconst_f16(5953.7)), vec3h(unconst_f16(15390.8), unconst_f16(13504.1), unconst_f16(12919.6))))), u32(unconst_u32(16)), u32(unconst_u32(56))); |
| out = mat3x2f(bitcast<vec2f>(countOneBits(vec2u(tan(vec2h(unconst_f16(16068.8), unconst_f16(1239.5)))))), vec2f(countOneBits(vec2u(tan(vec2h(unconst_f16(16068.8), unconst_f16(1239.5)))))), bitcast<vec2f>(countOneBits(vec2u(tan(vec2h(unconst_f16(16068.8), unconst_f16(1239.5))))))); |
| out = mat3x2f(f32(pack4xU8Clamp(vec4u(unconst_u32(74), unconst_u32(15), unconst_u32(208), unconst_u32(47)))), bitcast<f32>(pack4xU8Clamp(vec4u(unconst_u32(74), unconst_u32(15), unconst_u32(208), unconst_u32(47)))), f32(pack4xU8Clamp(vec4u(unconst_u32(74), unconst_u32(15), unconst_u32(208), unconst_u32(47)))), f32(pack4xU8Clamp(vec4u(unconst_u32(74), unconst_u32(15), unconst_u32(208), unconst_u32(47)))), f32(pack4xU8Clamp(vec4u(unconst_u32(74), unconst_u32(15), unconst_u32(208), unconst_u32(47)))), bitcast<f32>(pack4xU8Clamp(vec4u(unconst_u32(74), unconst_u32(15), unconst_u32(208), unconst_u32(47))))); |
| out = mat3x2f(fma(vec4f(unconst_f32(-0.1352), unconst_f32(0.2386), unconst_f32(0.1366), unconst_f32(-0.3942)), vec4f(unconst_f32(0.05106), unconst_f32(0.1597), unconst_f32(0.02934), unconst_f32(0.07998)), vec4f(unconst_f32(0.03112), unconst_f32(0.04883), unconst_f32(0.00852), unconst_f32(0.1949))).zy, fma(vec4f(unconst_f32(-0.1352), unconst_f32(0.2386), unconst_f32(0.1366), unconst_f32(-0.3942)), vec4f(unconst_f32(0.05106), unconst_f32(0.1597), unconst_f32(0.02934), unconst_f32(0.07998)), vec4f(unconst_f32(0.03112), unconst_f32(0.04883), unconst_f32(0.00852), unconst_f32(0.1949))).xy, fma(vec4f(unconst_f32(-0.1352), unconst_f32(0.2386), unconst_f32(0.1366), unconst_f32(-0.3942)), vec4f(unconst_f32(0.05106), unconst_f32(0.1597), unconst_f32(0.02934), unconst_f32(0.07998)), vec4f(unconst_f32(0.03112), unconst_f32(0.04883), unconst_f32(0.00852), unconst_f32(0.1949))).zw); |
| var vf73: u32 = pack4xU8Clamp(vec4u(unconst_u32(770), unconst_u32(105), unconst_u32(415), unconst_u32(176))); |
| var vf74: u32 = pack4xU8Clamp(vec4u(unconst_u32(49), unconst_u32(108), unconst_u32(136), unconst_u32(49))); |
| let vf75: vec4i = insertBits(vec4i(unconst_i32(207), unconst_i32(769), unconst_i32(27), unconst_i32(72)), vec4i(unconst_i32(4), unconst_i32(20), unconst_i32(8), unconst_i32(-67)), u32(unconst_u32(518)), u32(unconst_u32(104))); |
| var vf76: vec3f = acosh(vec3f(unconst_f32(0.1097), unconst_f32(0.07716), unconst_f32(0.1612))); |
| let vf77: vec3h = sqrt(vec3h(unconst_f16(12582.9), unconst_f16(7266.4), unconst_f16(5594.7))); |
| let vf78: vec4f = fma(vec4f(unconst_f32(0.3194), unconst_f32(0.07576), unconst_f32(0.06474), unconst_f32(-0.6655)), vec4f(unconst_f32(0.01362), unconst_f32(0.2505), unconst_f32(0.2713), unconst_f32(0.1063)), vec4f(unconst_f32(0.08233), unconst_f32(0.04981), unconst_f32(0.2091), unconst_f32(0.3599))); |
| let ptr31: ptr<function, vec3f> = &vf76; |
| let ptr32: ptr<function, u32> = &vf74; |
| var vf79: f16 = distance(vec3h(unconst_f16(3607.3), unconst_f16(3010.2), unconst_f16(10483.3)), vec3h(unconst_f16(13906.7), unconst_f16(3756.0), unconst_f16(2273.9))); |
| return out; |
| } |
| |
| var<workgroup> vw22: vec2f; |
| |
| var<workgroup> vw23: array<atomic<u32>, 3>; |
| |
| var<workgroup> vw24: atomic<i32>; |
| |
| var<workgroup> vw25: array<array<atomic<i32>, 1>, 58>; |
| |
| var<workgroup> vw26: atomic<u32>; |
| |
| var<workgroup> vw27: mat3x2f; |
| |
| @vertex |
| fn vertex3(@location(7) @interpolate(flat) a0: vec4h, @location(6) @interpolate(perspective, centroid) a1: vec4f, @location(4) @interpolate(flat) a2: vec2u, @location(14) @interpolate(flat, centroid) a3: f16, a4: S5, a5: S6, a6: S7, @location(8) a7: f32, @builtin(instance_index) a8: u32) -> VertexOutput3 { |
| var out: VertexOutput3; |
| var vf80 = fn1(); |
| var vf81 = fn0(); |
| return out; |
| } |
| |
| @fragment |
| fn fragment3(@location(15) a0: vec2u, @location(14) @interpolate(flat, centroid) a1: i32) -> FragmentOutput3 { |
| var out: FragmentOutput3; |
| var vf82 = fn1(); |
| let vf83: bool = any(bool(unconst_bool(true))); |
| out.f0 |= vec4i(i32(any(vec4<bool>(unconst_bool(false), unconst_bool(false), unconst_bool(true), unconst_bool(false))))); |
| var vf84 = fn1(); |
| fn1(); |
| var vf85 = fn1(); |
| fn1(); |
| var vf86: bool = any(bool(unconst_bool(true))); |
| fn1(); |
| vf86 = bool(saturate(vec4h(unconst_f16(7245.7), unconst_f16(15715.4), unconst_f16(7858.3), unconst_f16(16044.8))).y); |
| let ptr33: ptr<function, bool> = &vf86; |
| var vf87: vec4f = log2(vec4f(unconst_f32(0.1987), unconst_f32(0.1409), unconst_f32(0.2786), unconst_f32(0.03715))); |
| var vf88 = fn1(); |
| let vf89: vec2u = a0; |
| fn1(); |
| vf88 = mat3x2f(bitcast<vec2f>(radians(vec4h(unconst_f16(966.1), unconst_f16(15657.5), unconst_f16(1825.0), unconst_f16(11847.8)))), bitcast<vec2f>(radians(vec4h(unconst_f16(966.1), unconst_f16(15657.5), unconst_f16(1825.0), unconst_f16(11847.8)))), bitcast<vec2f>(radians(vec4h(unconst_f16(966.1), unconst_f16(15657.5), unconst_f16(1825.0), unconst_f16(11847.8))))); |
| var vf90: vec4f = log2(vec4f(unconst_f32(0.09000), unconst_f32(-0.1741), unconst_f32(0.4234), unconst_f32(0.4815))); |
| var vf91 = fn1(); |
| let vf92: f32 = vf91[u32(unconst_u32(127))][u32(unconst_u32(178))]; |
| vf91 = mat3x2f(bitcast<f32>(a1), f32(a1), f32(a1), bitcast<f32>(a1), bitcast<f32>(a1), bitcast<f32>(a1)); |
| return out; |
| } |
| |
| @fragment |
| fn fragment4() -> FragmentOutput4 { |
| var out: FragmentOutput4; |
| out.f0 = bitcast<i32>(unpack4x8snorm(u32(unconst_u32(95)))[2]); |
| let vf93: f32 = log(f32(unconst_f32(0.7861))); |
| var vf94: vec4f = unpack4x8snorm(u32(unconst_u32(191))); |
| let vf95: vec4f = unpack4x8snorm(u32(unconst_u32(17))); |
| let vf96: vec4f = cosh(vec4f(unconst_f32(0.2417), unconst_f32(0.03778), unconst_f32(0.4769), unconst_f32(0.01684))); |
| var vf97: f32 = vf94[u32(unconst_u32(167))]; |
| let vf98: f32 = vf93; |
| let vf99: vec4f = vf95; |
| fn1(); |
| return out; |
| } |
| |
| @compute @workgroup_size(3, 1, 1) |
| fn compute4() { |
| let ptr34: ptr<workgroup, atomic<i32>> = &(*&vw24); |
| fn0(); |
| let vf100: u32 = countLeadingZeros(u32(unconst_u32(328))); |
| var vf101: u32 = pack4xU8(vec4u(unconst_u32(162), unconst_u32(77), unconst_u32(33), unconst_u32(908))); |
| atomicSub(&vw25[u32(unconst_u32(35))][u32(unconst_u32(36))], i32(unconst_i32(217))); |
| let ptr35: ptr<workgroup, vec2f> = &vw22; |
| var vf102 = fn0(); |
| vf102 = mat3x3h(f16(vf101), f16(vf101), f16(vf101), f16(vf101), f16(vf101), f16(vf101), f16(vf101), f16(vf101), f16(vf101)); |
| vf101 = bitcast<u32>(reflect(vec2h(unconst_f16(5217.7), unconst_f16(9327.4)), vec2h(unconst_f16(13838.3), unconst_f16(19559.5)))); |
| var vf103 = fn0(); |
| atomicMax(&vw24, i32(unconst_i32(274))); |
| textureStore(st8, vec3i(unconst_i32(9), unconst_i32(17), unconst_i32(309)), vec4f(vec4f(unconst_f32(-0.2632), unconst_f32(0.2698), unconst_f32(0.05573), unconst_f32(0.2452)))); |
| var vf104 = fn1(); |
| fn0(); |
| let ptr36: ptr<workgroup, atomic<i32>> = &(*&vw25)[u32(unconst_u32(339))][0]; |
| fn1(); |
| atomicMax(&vw24, i32(unconst_i32(106))); |
| var vf105: i32 = atomicLoad(&(*ptr36)); |
| var vf106 = fn1(); |
| let ptr37: ptr<workgroup, array<atomic<u32>, 3>> = &(*&vw23); |
| let vf107: vec2u = firstTrailingBit(vec2u(unconst_u32(268), unconst_u32(17))); |
| fn0(); |
| }`, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| let buffer28 = device0.createBuffer({ |
| size: 5775, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder35 = device0.createCommandEncoder({}); |
| let texture50 = device0.createTexture({ |
| size: {width: 110, height: 10, depthOrArrayLayers: 78}, |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder8.setBindGroup(3, bindGroup9); |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(1, bindGroup2, new Uint32Array(696), 18, 0); |
| } catch {} |
| try { |
| commandEncoder35.copyBufferToBuffer(buffer4, 22360, buffer11, 6472, 2964); |
| } catch {} |
| await gc(); |
| let buffer29 = device0.createBuffer({size: 2780, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE, mappedAtCreation: false}); |
| let commandEncoder36 = device0.createCommandEncoder({}); |
| let texture51 = device0.createTexture({ |
| label: '\uc8cf\u75b3\u{1fadd}\u6213\u0627\ue685\u632d', |
| size: {width: 560}, |
| dimension: '1d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder26 = commandEncoder36.beginComputePass(); |
| try { |
| renderPassEncoder3.executeBundles([renderBundle0, renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder4.setIndexBuffer(buffer4, 'uint16', 6_748, 6_140); |
| } catch {} |
| try { |
| commandEncoder35.copyBufferToTexture({ |
| /* bytesInLastRow: 12 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1316 */ |
| offset: 1316, |
| bytesPerRow: 2304, |
| rowsPerImage: 549, |
| buffer: buffer4, |
| }, { |
| texture: texture5, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 9}, |
| aspect: 'all', |
| }, {width: 3, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(img0); |
| let buffer30 = device0.createBuffer({size: 58, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE}); |
| let computePassEncoder27 = commandEncoder35.beginComputePass({label: '\u1ef3\u2cf7\u0073\u1750\u{1fe43}\u7a3a\u04a3'}); |
| try { |
| renderPassEncoder4.setBindGroup(3, bindGroup9); |
| } catch {} |
| try { |
| renderPassEncoder7.insertDebugMarker('\u0f8c'); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'display-p3', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let promise4 = device0.queue.onSubmittedWorkDone(); |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 73, height: 1, depthOrArrayLayers: 54} |
| */ |
| { |
| source: videoFrame1, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture5, |
| mipLevel: 0, |
| origin: {x: 6, y: 0, z: 2}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer31 = device0.createBuffer({size: 1755, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let textureView42 = texture27.createView({label: '\u{1f738}\u0162', aspect: 'stencil-only', mipLevelCount: 2}); |
| let sampler14 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 98.47, |
| maxAnisotropy: 12, |
| }); |
| try { |
| computePassEncoder16.setBindGroup(3, bindGroup16, new Uint32Array(606), 10, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(3, bindGroup8); |
| } catch {} |
| try { |
| renderPassEncoder1.setBindGroup(1, bindGroup12, new Uint32Array(755), 64, 0); |
| } catch {} |
| document.body.append(img0); |
| try { |
| renderPassEncoder0.executeBundles([renderBundle0]); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture47, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(11).fill(183), /* required buffer size: 11 */ |
| {offset: 11}, {width: 32, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 73, height: 1, depthOrArrayLayers: 54} |
| */ |
| { |
| source: imageData2, |
| origin: { x: 15, y: 2 }, |
| flipY: false, |
| }, { |
| texture: texture5, |
| mipLevel: 0, |
| origin: {x: 9, y: 0, z: 8}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 7, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup22 = device0.createBindGroup({layout: bindGroupLayout8, entries: [{binding: 27, resource: {buffer: buffer16, offset: 0}}]}); |
| let buffer32 = device0.createBuffer({size: 9070, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ, mappedAtCreation: false}); |
| let sampler15 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 96.80, |
| lodMaxClamp: 99.98, |
| }); |
| try { |
| renderPassEncoder4.setVertexBuffer(6, buffer10, 0, 271); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer18, 1896, new BigUint64Array(21079), 4685, 72); |
| } catch {} |
| let img1 = await imageWithData(43, 46, '#10101010', '#20202020'); |
| let buffer33 = device0.createBuffer({size: 24679, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let commandEncoder37 = device0.createCommandEncoder({label: '\u05af\uf332\u9a40\u{1fe76}\u8635\u{1fe1d}\u06c4\u009b\u0e38'}); |
| let textureView43 = texture8.createView({dimension: '2d-array', baseMipLevel: 0}); |
| let externalTexture0 = device0.importExternalTexture({label: '\uf7b5\u00a5', source: videoFrame0}); |
| try { |
| renderPassEncoder4.setBindGroup(3, bindGroup9); |
| } catch {} |
| try { |
| renderPassEncoder7.setIndexBuffer(buffer21, 'uint16', 1_420, 6_820); |
| } catch {} |
| try { |
| buffer19.unmap(); |
| } catch {} |
| try { |
| commandEncoder37.copyBufferToTexture({ |
| /* bytesInLastRow: 24 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 1792 */ |
| offset: 1792, |
| bytesPerRow: 55808, |
| buffer: buffer7, |
| }, { |
| texture: texture6, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 3, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder37.copyTextureToBuffer({ |
| texture: texture28, |
| mipLevel: 0, |
| origin: {x: 0, y: 19, z: 0}, |
| aspect: 'stencil-only', |
| }, { |
| /* bytesInLastRow: 70 widthInBlocks: 70 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 184 */ |
| offset: 184, |
| buffer: buffer26, |
| }, {width: 70, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture51, |
| mipLevel: 0, |
| origin: {x: 36, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(192).fill(149), /* required buffer size: 192 */ |
| {offset: 192, rowsPerImage: 9}, {width: 42, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer34 = device0.createBuffer({size: 9615, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let renderPassEncoder10 = commandEncoder37.beginRenderPass({colorAttachments: [{view: textureView38, loadOp: 'load', storeOp: 'store'}]}); |
| try { |
| renderPassEncoder2.setBindGroup(2, bindGroup11, new Uint32Array(2528), 588, 0); |
| } catch {} |
| try { |
| renderPassEncoder10.setScissorRect(2, 10, 5, 20); |
| } catch {} |
| let texture52 = device0.createTexture({size: [140], sampleCount: 1, dimension: '1d', format: 'rgb10a2uint', usage: GPUTextureUsage.COPY_DST}); |
| let textureView44 = texture4.createView({baseArrayLayer: 0}); |
| let sampler16 = device0.createSampler({addressModeU: 'clamp-to-edge', addressModeW: 'clamp-to-edge', magFilter: 'nearest', lodMaxClamp: 75.45}); |
| try { |
| computePassEncoder9.setBindGroup(3, bindGroup13); |
| } catch {} |
| try { |
| computePassEncoder21.setBindGroup(2, bindGroup19, new Uint32Array(192), 66, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.executeBundles([renderBundle0, renderBundle0]); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let commandEncoder38 = device0.createCommandEncoder({}); |
| let commandBuffer1 = commandEncoder38.finish(); |
| let sampler17 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 57.98, |
| lodMaxClamp: 97.63, |
| maxAnisotropy: 4, |
| }); |
| try { |
| computePassEncoder27.setBindGroup(0, bindGroup6, new Uint32Array(6134), 5_019, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(2, bindGroup8, new Uint32Array(3866), 884, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.setViewport(22.475898138163537, 0.9371507246081682, 8.661867426964486, 0.027844123909638693, 0.6326354053367029, 0.7065691887287074); |
| } catch {} |
| let promise5 = device0.queue.onSubmittedWorkDone(); |
| document.body.prepend(img0); |
| await gc(); |
| let imageData4 = new ImageData(8, 24); |
| let commandEncoder39 = device0.createCommandEncoder({}); |
| let texture53 = device0.createTexture({ |
| size: {width: 36, height: 1, depthOrArrayLayers: 46}, |
| dimension: '3d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder28 = commandEncoder39.beginComputePass(); |
| try { |
| computePassEncoder18.setBindGroup(0, bindGroup2, new Uint32Array(195), 58, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.executeBundles([renderBundle0, renderBundle0, renderBundle0, renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder7.setVertexBuffer(1, buffer2, 1_748); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| let buffer35 = device0.createBuffer({size: 29881, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let commandEncoder40 = device0.createCommandEncoder({}); |
| let renderPassEncoder11 = commandEncoder40.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView38, |
| clearValue: { r: 321.1, g: 682.2, b: 406.5, a: -727.8, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| maxDrawCount: 36510126, |
| }); |
| try { |
| computePassEncoder10.setBindGroup(1, bindGroup7); |
| } catch {} |
| let commandEncoder41 = device0.createCommandEncoder({}); |
| let computePassEncoder29 = commandEncoder41.beginComputePass(); |
| try { |
| renderPassEncoder5.setBindGroup(1, bindGroup19, new Uint32Array(5403), 157, 0); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let textureView45 = texture17.createView({mipLevelCount: 1}); |
| try { |
| renderPassEncoder5.executeBundles([renderBundle0]); |
| } catch {} |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55); }; |
| } catch {} |
| let commandEncoder42 = device0.createCommandEncoder({label: '\u{1f66b}\uc894\u9ca5\u04cd\uc112\u{1fbf4}\u555d'}); |
| try { |
| computePassEncoder1.insertDebugMarker('\ue002'); |
| } catch {} |
| let buffer36 = device0.createBuffer({size: 4447, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let commandEncoder43 = device0.createCommandEncoder({}); |
| let querySet3 = device0.createQuerySet({type: 'occlusion', count: 146}); |
| let computePassEncoder30 = commandEncoder43.beginComputePass({}); |
| try { |
| computePassEncoder29.setBindGroup(3, bindGroup17); |
| } catch {} |
| try { |
| renderPassEncoder10.setBindGroup(1, bindGroup0); |
| } catch {} |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer21, 'uint16', 3_776, 4_858); |
| } catch {} |
| try { |
| await promise1; |
| } catch {} |
| let bindGroup23 = device0.createBindGroup({ |
| layout: bindGroupLayout0, |
| entries: [{binding: 103, resource: textureView3}, {binding: 176, resource: textureView8}], |
| }); |
| let buffer37 = device0.createBuffer({size: 3455, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM}); |
| let commandEncoder44 = device0.createCommandEncoder({}); |
| let textureView46 = texture28.createView({dimension: '2d', aspect: 'stencil-only'}); |
| let computePassEncoder31 = commandEncoder44.beginComputePass({}); |
| try { |
| computePassEncoder27.setBindGroup(0, bindGroup12, new Uint32Array(687), 32, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.setBindGroup(0, bindGroup0, new Uint32Array(311), 12, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(0, buffer3); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer1]); |
| } catch {} |
| let commandEncoder45 = device0.createCommandEncoder({}); |
| let sampler18 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 14.97, |
| lodMaxClamp: 46.50, |
| }); |
| try { |
| renderPassEncoder3.setBindGroup(3, bindGroup10); |
| } catch {} |
| try { |
| renderPassEncoder2.setScissorRect(10, 0, 8, 0); |
| } catch {} |
| try { |
| commandEncoder42.copyTextureToTexture({ |
| texture: texture4, |
| mipLevel: 0, |
| origin: {x: 13, y: 21, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture5, |
| mipLevel: 0, |
| origin: {x: 10, y: 0, z: 25}, |
| aspect: 'all', |
| }, |
| {width: 14, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| document.body.prepend(img1); |
| let shaderModule5 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| requires readonly_and_readwrite_storage_textures; |
| |
| diagnostic(info, xyz); |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| @group(0) @binding(103) var st10: texture_storage_3d<rgba8unorm, write>; |
| |
| @group(0) @binding(176) var st11: texture_storage_3d<rgba16uint, write>; |
| |
| struct T0 { |
| @align(8) @size(40) f0: array<u32>, |
| } |
| |
| struct S8 { |
| @location(14) @interpolate(flat) f0: vec2i, |
| @location(4) @interpolate(flat) f1: vec2i, |
| } |
| |
| struct VertexOutput4 { |
| @builtin(position) f18: vec4f, |
| @location(5) f19: f16, |
| @location(11) @interpolate(flat, centroid) f20: vec4u, |
| @location(3) f21: vec2h, |
| @location(6) @interpolate(flat, centroid) f22: vec2i, |
| @location(7) @interpolate(flat, sample) f23: i32, |
| } |
| |
| alias vec3b = vec3<bool>; |
| |
| fn fn0(a0: ptr<storage, array<S8>, read>) -> vec2u { |
| var out: vec2u; |
| let ptr38: ptr<private, S8> = &vp2[u32(unconst_u32(346))]; |
| vp2[u32(unconst_u32(204))].f0 |= vp2[bitcast<vec2u>((*ptr38).f1).g].f1; |
| vp2[u32(unconst_u32(438))].f1 = bitcast<vec2i>(vp3[0][0]); |
| let ptr39: ptr<storage, S8, read> = &(*a0)[i32(unconst_i32(40))]; |
| var vf108: u32 = vp3[u32(unconst_u32(17))][u32(unconst_u32(162))][u32(unconst_u32(62))]; |
| var vf109: i32 = (*ptr39).f0[bitcast<u32>((*ptr38).f0[u32(unconst_u32(793))])]; |
| let ptr40: ptr<storage, vec2i, read> = &(*ptr39).f0; |
| vf108 |= u32((*ptr38).f0[1]); |
| return out; |
| } |
| |
| fn fn1() { |
| let ptr41: ptr<private, vec2u> = &vp3[0][u32(unconst_u32(8))]; |
| vp3[u32(unconst_u32(307))][0] = vp3[0][0]; |
| let ptr42: ptr<private, vec2u> = &(*ptr41); |
| let ptr43: ptr<private, vec2u> = &vp3[0][u32(unconst_u32(66))]; |
| } |
| |
| fn fn2() -> array<array<array<array<array<vec2h, 1>, 1>, 42>, 1>, 1> { |
| var out: array<array<array<array<array<vec2h, 1>, 1>, 42>, 1>, 1>; |
| vp2[u32(unconst_u32(21))] = S8(vec2i(sign(vec4f(unconst_f32(-0.07538), unconst_f32(0.00993), unconst_f32(0.02765), unconst_f32(0.3565))).wz), bitcast<vec2i>(sign(vec4f(unconst_f32(-0.07538), unconst_f32(0.00993), unconst_f32(0.02765), unconst_f32(0.3565))).gr)); |
| let ptr44: ptr<private, vec2i> = &vp2[u32(unconst_u32(84))].f1; |
| let vf110: vec4u = countTrailingZeros(vp3[0][0].yxxx); |
| out[u32(unconst_u32(24))][u32(unconst_u32(177))][u32(unconst_u32(109))][u32(unconst_u32(494))][u32(unconst_u32(292))] *= bitcast<vec2h>(vp3[u32(unconst_u32(233))][0][u32(unconst_u32(153))]); |
| let ptr45: ptr<private, vec2i> = &vp2[0].f1; |
| vp2[u32(unconst_u32(147))].f0 |= vec2i(i32(pack4x8snorm(vec4f(unconst_f32(0.4613), unconst_f32(0.00191), unconst_f32(0.04739), unconst_f32(0.2163))))); |
| let ptr46: ptr<private, vec2u> = &vp3[bitcast<u32>(vp2[u32(unconst_u32(12))].f1.r)][u32(unconst_u32(42))]; |
| var vf111: vec3h = log2(vec3h(unconst_f16(-1184.2), unconst_f16(6996.6), unconst_f16(4325.9))); |
| vf111 -= vec3h(f16(vf110[u32(unconst_u32(238))])); |
| vp2[u32(unconst_u32(136))].f0 -= vec2i(floor(vec2f(unconst_f32(0.02629), unconst_f32(0.6027)))); |
| var vf112: vec4u = unpack4xU8(u32(unconst_u32(66))); |
| vp3[u32(unconst_u32(158))][u32(unconst_u32(408))] = vec2u(u32(vp2[0].f0[u32(unconst_u32(441))])); |
| vp3[u32(unconst_u32(130))][u32(unconst_u32(256))] >>= vec2u((*ptr44)); |
| let ptr47: ptr<private, vec2u> = &vp3[u32(unconst_u32(90))][0]; |
| out[vp3[u32(unconst_u32(47))][0].g][u32(unconst_u32(295))][u32(unconst_u32(455))][u32(unconst_u32(20))][u32(unconst_u32(63))] = vec2h(acos(vec3f(unconst_f32(0.06152), unconst_f32(0.03587), unconst_f32(0.03940))).yz); |
| return out; |
| } |
| |
| var<workgroup> vw28: array<atomic<u32>, 1>; |
| |
| var<workgroup> vw29: S8; |
| |
| var<workgroup> vw30: array<S8, 2>; |
| |
| var<private> vp2: array<S8, 1> = array<S8, 1>(S8(vec2i(203, 29), vec2i(187, 95))); |
| |
| var<private> vp3: array<array<vec2u, 1>, 1> = array<array<vec2u, 1>, 1>(array(vec2u(260, 111))); |
| |
| @vertex |
| fn vertex4(a0: S8, @location(13) a1: vec4i, @location(6) a2: vec4u) -> VertexOutput4 { |
| var out: VertexOutput4; |
| vp3[u32(exp(f16(unconst_f16(5041.6))))][0] <<= a2.ww; |
| fn1(); |
| out.f20 += vp3[0][0].rrgg; |
| fn1(); |
| fn1(); |
| let ptr48: ptr<private, vec2i> = &vp2[0].f1; |
| out.f21 = vec2h(vp3[0][0]); |
| var vf113: i32 = vp2[0].f1[u32(unconst_u32(565))]; |
| let vf114: u32 = pack4x8unorm(vec4f(unconst_f32(0.1596), unconst_f32(0.3442), unconst_f32(0.2455), unconst_f32(-0.02050))); |
| let ptr49: ptr<private, vec2u> = &vp3[0][u32(unconst_u32(128))]; |
| fn1(); |
| var vf115: u32 = vp3[u32(unconst_u32(172))][0][u32(unconst_u32(117))]; |
| let vf116: u32 = pack2x16unorm(vec2f(unconst_f32(0.05855), unconst_f32(-0.5275))); |
| out.f20 *= unpack4xU8(u32(exp(f16(unconst_f16(14144.7))))); |
| fn1(); |
| fn1(); |
| fn1(); |
| fn1(); |
| fn1(); |
| out.f21 = vec2h((*ptr48)); |
| let ptr50: ptr<private, array<S8, 1>> = &vp2; |
| out.f18 += vec4f(vp3[u32(unconst_u32(145))][u32(unconst_u32(49))].xyxy); |
| fn1(); |
| fn1(); |
| vf115 *= vec2u(vp2[0].f1)[0]; |
| return out; |
| } |
| |
| @fragment |
| fn fragment5() -> @location(200) @interpolate(linear, center) vec4u { |
| var out: vec4u; |
| vp2[0] = S8(vp2[0].f1, vp2[0].f1); |
| fn2(); |
| out &= unpack4xU8(bitcast<u32>(vp2[u32(unconst_u32(228))].f0[u32(unconst_u32(122))])); |
| vp2[u32(unconst_u32(3))] = S8(vec2i(vp2[0].f1[u32(unconst_u32(131))]), vec2i(vp2[0].f1[u32(unconst_u32(131))])); |
| var vf117 = fn2(); |
| vp3[u32(unconst_u32(101))][0] = vec2u(u32(vf117[bitcast<u32>(vf117[u32(unconst_u32(49))][0][u32(unconst_u32(94))][0][0])][0][41][u32(unconst_u32(31))][bitcast<u32>(vf117[u32(unconst_u32(64))][u32(unconst_u32(90))][u32(unconst_u32(201))][u32(unconst_u32(45))][0])][u32(unconst_u32(9))])); |
| let ptr51: ptr<function, vec2h> = &vf117[u32(unconst_u32(64))][0][41][u32(unconst_u32(42))][u32(unconst_u32(33))]; |
| vp2[u32(unconst_u32(42))] = S8(vec2i(bitcast<i32>(floor(f32(unconst_f32(0.2505))))), vec2i(bitcast<i32>(floor(f32(unconst_f32(0.2505)))))); |
| return out; |
| } |
| |
| @compute @workgroup_size(1, 1, 1) |
| fn compute5(@builtin(num_workgroups) a0: vec3u, @builtin(local_invocation_index) a1: u32) { |
| var vf118 = fn2(); |
| let ptr52: ptr<workgroup, atomic<u32>> = &(*&vw28)[0]; |
| var vf119: f16 = vf118[u32(unconst_u32(479))][u32(unconst_u32(293))][41][u32(unconst_u32(72))][u32(unconst_u32(83))][u32(unconst_u32(84))]; |
| let ptr53: ptr<function, vec2h> = &vf118[u32(unconst_u32(5))][0][bitcast<u32>(vf118[0][0][u32(unconst_u32(137))][u32(unconst_u32(724))][u32(unconst_u32(68))])][0][u32(unconst_u32(57))]; |
| fn2(); |
| let ptr54: ptr<function, array<vec2h, 1>> = &vf118[0][0][u32(unconst_u32(3))][u32(unconst_u32(40))]; |
| }`, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| let buffer38 = device0.createBuffer({size: 12982, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ, mappedAtCreation: false}); |
| let commandEncoder46 = device0.createCommandEncoder(); |
| let computePassEncoder32 = commandEncoder46.beginComputePass({}); |
| let renderPassEncoder12 = commandEncoder42.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView6, |
| clearValue: { r: 507.9, g: 397.9, b: 7.328, a: -568.7, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet1, |
| maxDrawCount: 341703515, |
| }); |
| try { |
| computePassEncoder7.setBindGroup(3, bindGroup1); |
| } catch {} |
| try { |
| commandEncoder45.clearBuffer(buffer26, 148, 688); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer25, 540, new Int16Array(6236), 712, 2504); |
| } catch {} |
| let bindGroup24 = device0.createBindGroup({ |
| layout: bindGroupLayout3, |
| entries: [ |
| {binding: 225, resource: textureView39}, |
| {binding: 58, resource: {buffer: buffer10, offset: 2560, size: 4417}}, |
| ], |
| }); |
| let textureView47 = texture23.createView({dimension: '3d', baseMipLevel: 1, mipLevelCount: 1}); |
| let computePassEncoder33 = commandEncoder45.beginComputePass({label: '\uf2d6\u09e1\ucb09\u0284\u{1fe87}\u2f12\u0c27\u08a3\u{1ff3c}\u264f\u3d59'}); |
| try { |
| computePassEncoder11.setBindGroup(0, bindGroup4, new Uint32Array(1332), 605, 0); |
| } catch {} |
| try { |
| renderPassEncoder10.setBindGroup(0, bindGroup5, new Uint32Array(314), 10, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(1, buffer12, 40, 121); |
| } catch {} |
| let bindGroup25 = device0.createBindGroup({ |
| layout: bindGroupLayout6, |
| entries: [{binding: 11, resource: {buffer: buffer37, offset: 0, size: 912}}], |
| }); |
| let buffer39 = device0.createBuffer({size: 21921, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let commandEncoder47 = device0.createCommandEncoder(); |
| let texture54 = device0.createTexture({ |
| size: {width: 140, height: 145, depthOrArrayLayers: 2}, |
| dimension: '3d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView48 = texture20.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 5}); |
| let computePassEncoder34 = commandEncoder47.beginComputePass({}); |
| let sampler19 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| lodMinClamp: 43.55, |
| lodMaxClamp: 61.43, |
| maxAnisotropy: 1, |
| }); |
| try { |
| computePassEncoder33.setBindGroup(3, bindGroup2, new Uint32Array(1269), 85, 0); |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(0, bindGroup20, new Uint32Array(625), 38, 0); |
| } catch {} |
| let videoFrame2 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt470bg', primaries: 'bt709', transfer: 'pq'} }); |
| let commandEncoder48 = device0.createCommandEncoder(); |
| let renderPassEncoder13 = commandEncoder48.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView20, |
| clearValue: { r: 233.0, g: -381.1, b: -625.6, a: -355.6, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| renderPassEncoder6.executeBundles([renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder8.setVertexBuffer(5, buffer24, 0, 115); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| colorSpace: 'srgb', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let bindGroup26 = device0.createBindGroup({ |
| layout: bindGroupLayout6, |
| entries: [{binding: 11, resource: {buffer: buffer28, offset: 1280, size: 1012}}], |
| }); |
| let querySet4 = device0.createQuerySet({type: 'occlusion', count: 703}); |
| let texture55 = device0.createTexture({ |
| size: {width: 560, height: 582, depthOrArrayLayers: 1}, |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| computePassEncoder6.setBindGroup(2, bindGroup8, new Uint32Array(548), 44, 0); |
| } catch {} |
| try { |
| await promise5; |
| } catch {} |
| let commandEncoder49 = device0.createCommandEncoder({}); |
| let textureView49 = texture31.createView({label: '\u084d\u0a22\u{1fe1a}\u{1fa09}\u88ac', dimension: '2d', mipLevelCount: 1}); |
| let renderPassEncoder14 = commandEncoder49.beginRenderPass({colorAttachments: [{view: textureView38, loadOp: 'load', storeOp: 'store'}]}); |
| try { |
| computePassEncoder34.setBindGroup(0, bindGroup7, new Uint32Array(3428), 630, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.beginOcclusionQuery(3); |
| } catch {} |
| try { |
| renderPassEncoder7.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder2.executeBundles([renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer20, 'uint32', 0, 70); |
| } catch {} |
| try { |
| buffer19.unmap(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 96, height: 1, depthOrArrayLayers: 131} |
| */ |
| { |
| source: videoFrame0, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture18, |
| mipLevel: 0, |
| origin: {x: 7, y: 0, z: 50}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| await gc(); |
| let bindGroup27 = device0.createBindGroup({ |
| label: '\u1e04\ud416\u{1ff21}\u3e36\u09ea\uba48\u0482', |
| layout: bindGroupLayout1, |
| entries: [{binding: 277, resource: sampler8}], |
| }); |
| let texture56 = device0.createTexture({ |
| label: '\u2cff\ud382\ub529\ud44b\u28e8\uefaa\u{1f957}\ua92e\u{1fbd4}\u0cf7', |
| size: [440, 40, 62], |
| mipLevelCount: 2, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let textureView50 = texture31.createView({baseArrayLayer: 4, arrayLayerCount: 2}); |
| try { |
| computePassEncoder5.setBindGroup(3, bindGroup23, new Uint32Array(454), 2, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(2, buffer18, 544, 1_276); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| } catch {} |
| let buffer40 = device0.createBuffer({size: 65536, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, mappedAtCreation: false}); |
| let textureView51 = texture2.createView({aspect: 'all', mipLevelCount: 1}); |
| try { |
| computePassEncoder10.setBindGroup(1, bindGroup4); |
| } catch {} |
| try { |
| computePassEncoder28.setBindGroup(2, bindGroup6, new Uint32Array(445), 99, 0); |
| } catch {} |
| try { |
| renderPassEncoder14.setBindGroup(1, bindGroup9); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| try { |
| if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55); }; |
| } catch {} |
| let buffer41 = device0.createBuffer({size: 6425, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let commandEncoder50 = device0.createCommandEncoder({}); |
| let computePassEncoder35 = commandEncoder50.beginComputePass({}); |
| try { |
| computePassEncoder18.setBindGroup(0, bindGroup5, new Uint32Array(2152), 364, 0); |
| } catch {} |
| try { |
| renderPassEncoder12.setBindGroup(2, bindGroup23); |
| } catch {} |
| try { |
| renderPassEncoder14.setIndexBuffer(buffer15, 'uint32', 560, 4_414); |
| } catch {} |
| document.body.append(img0); |
| await gc(); |
| let buffer42 = device0.createBuffer({ |
| size: 1841, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX, |
| }); |
| let texture57 = device0.createTexture({ |
| size: [560, 582, 1], |
| mipLevelCount: 3, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| renderPassEncoder7.beginOcclusionQuery(142); |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer20, 'uint32', 108, 64); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| let bindGroup28 = device0.createBindGroup({ |
| layout: bindGroupLayout3, |
| entries: [ |
| {binding: 225, resource: textureView13}, |
| {binding: 58, resource: {buffer: buffer23, offset: 1024, size: 7889}}, |
| ], |
| }); |
| try { |
| buffer5.unmap(); |
| } catch {} |
| try { |
| await promise4; |
| } catch {} |
| let commandEncoder51 = device0.createCommandEncoder(); |
| let textureView52 = texture43.createView({dimension: '2d-array'}); |
| let computePassEncoder36 = commandEncoder51.beginComputePass({}); |
| try { |
| computePassEncoder31.setBindGroup(3, bindGroup0); |
| } catch {} |
| try { |
| computePassEncoder29.setBindGroup(1, bindGroup9, new Uint32Array(2903), 486, 0); |
| } catch {} |
| try { |
| renderPassEncoder12.setBindGroup(1, bindGroup0, new Uint32Array(611), 69, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.executeBundles([renderBundle0, renderBundle0]); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let pipeline0 = await device0.createComputePipelineAsync({layout: pipelineLayout0, compute: {module: shaderModule3}}); |
| let commandEncoder52 = device0.createCommandEncoder({}); |
| let querySet5 = device0.createQuerySet({label: '\u9c8a\uce74\u{1ff9b}', type: 'occlusion', count: 65}); |
| let computePassEncoder37 = commandEncoder52.beginComputePass({}); |
| let sampler20 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| lodMinClamp: 8.898, |
| lodMaxClamp: 94.63, |
| }); |
| try { |
| computePassEncoder29.setBindGroup(1, bindGroup16); |
| } catch {} |
| try { |
| computePassEncoder29.setPipeline(pipeline0); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer23, 1196, new DataView(new ArrayBuffer(535)), 3); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let texture58 = device0.createTexture({ |
| size: [220, 20, 1], |
| dimension: '2d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| computePassEncoder17.setBindGroup(3, bindGroup16); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer20, 'uint32', 172, 5); |
| } catch {} |
| try { |
| renderPassEncoder11.setVertexBuffer(3, buffer2); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer9, 2632, new Int16Array(4536), 66, 404); |
| } catch {} |
| let commandEncoder53 = device0.createCommandEncoder(); |
| let renderPassEncoder15 = commandEncoder53.beginRenderPass({ |
| colorAttachments: [{view: textureView38, loadOp: 'clear', storeOp: 'discard'}], |
| occlusionQuerySet: querySet5, |
| }); |
| try { |
| computePassEncoder23.setBindGroup(0, bindGroup12); |
| } catch {} |
| try { |
| renderPassEncoder14.setIndexBuffer(buffer13, 'uint32', 592, 8_835); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let imageData5 = new ImageData(40, 88); |
| let bindGroup29 = device0.createBindGroup({ |
| layout: bindGroupLayout5, |
| entries: [ |
| {binding: 86, resource: textureView47}, |
| {binding: 62, resource: textureView39}, |
| {binding: 211, resource: sampler18}, |
| ], |
| }); |
| let commandEncoder54 = device0.createCommandEncoder({}); |
| let texture59 = device0.createTexture({ |
| size: [147, 1, 1], |
| format: 'depth24plus', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView53 = texture16.createView({dimension: 'cube-array', mipLevelCount: 1, arrayLayerCount: 6}); |
| let computePassEncoder38 = commandEncoder54.beginComputePass({}); |
| let sampler21 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 68.22, |
| lodMaxClamp: 80.07, |
| }); |
| try { |
| computePassEncoder27.setBindGroup(1, bindGroup18, new Uint32Array(1076), 449, 0); |
| } catch {} |
| try { |
| computePassEncoder7.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder6.executeBundles([renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder1.setVertexBuffer(0, buffer6, 60, 155); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer14, 940, new DataView(new ArrayBuffer(4095)), 1614, 240); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 96, height: 1, depthOrArrayLayers: 131} |
| */ |
| { |
| source: imageData3, |
| origin: { x: 0, y: 8 }, |
| flipY: true, |
| }, { |
| texture: texture18, |
| mipLevel: 0, |
| origin: {x: 15, y: 0, z: 9}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup30 = device0.createBindGroup({ |
| label: '\ue0eb\u2916\uc9e4\u05ab\u{1fe99}\u{1fce8}\u{1fbae}\ue78a\u{1ff53}\u38ce\u{1f7b0}', |
| layout: bindGroupLayout7, |
| entries: [ |
| {binding: 54, resource: {buffer: buffer19, offset: 256, size: 2788}}, |
| {binding: 53, resource: externalTexture0}, |
| ], |
| }); |
| let querySet6 = device0.createQuerySet({type: 'occlusion', count: 169}); |
| let texture60 = device0.createTexture({ |
| size: [280, 291, 1], |
| mipLevelCount: 2, |
| dimension: '2d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder7.endOcclusionQuery(); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| await gc(); |
| let textureView54 = texture33.createView({dimension: '2d-array'}); |
| try { |
| computePassEncoder29.setBindGroup(3, bindGroup11); |
| } catch {} |
| try { |
| computePassEncoder23.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder11.setStencilReference(1671); |
| } catch {} |
| let commandEncoder55 = device0.createCommandEncoder({}); |
| let commandBuffer2 = commandEncoder55.finish(); |
| let textureView55 = texture16.createView({ |
| label: '\u0a15\u{1fe97}', |
| dimension: 'cube-array', |
| aspect: 'all', |
| mipLevelCount: 1, |
| baseArrayLayer: 1, |
| arrayLayerCount: 6, |
| }); |
| try { |
| renderPassEncoder3.executeBundles([renderBundle0, renderBundle0, renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder9.setVertexBuffer(5, buffer4); |
| } catch {} |
| try { |
| buffer36.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer26, 2148, new BigUint64Array(6187), 349, 8); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture54, |
| mipLevel: 0, |
| origin: {x: 9, y: 105, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(112).fill(220), /* required buffer size: 112 */ |
| {offset: 112, bytesPerRow: 76}, {width: 6, height: 8, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer43 = device0.createBuffer({ |
| label: '\ua104\u010d\ud69a', |
| size: 5311, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder56 = device0.createCommandEncoder({}); |
| let texture61 = device0.createTexture({size: [48], dimension: '1d', format: 'rgb10a2uint', usage: GPUTextureUsage.COPY_SRC}); |
| let computePassEncoder39 = commandEncoder56.beginComputePass({}); |
| try { |
| computePassEncoder32.setBindGroup(2, bindGroup2, []); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(7, buffer12, 40, 4); |
| } catch {} |
| let textureView56 = texture14.createView({label: '\ub444\u3593\u04eb\u{1fe2d}', format: 'rgba16sint', baseArrayLayer: 1, arrayLayerCount: 6}); |
| try { |
| computePassEncoder36.setBindGroup(2, bindGroup18); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(2, bindGroup0, []); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer28, 'uint16', 6, 1_654); |
| } catch {} |
| let commandEncoder57 = device0.createCommandEncoder({label: '\uc819\ue42a\ucdd3\u{1fe77}\u075e\uc931\u917a\u{1f908}\u0889'}); |
| let textureView57 = texture10.createView({aspect: 'depth-only', baseMipLevel: 1, mipLevelCount: 1}); |
| let computePassEncoder40 = commandEncoder57.beginComputePass({}); |
| try { |
| renderPassEncoder9.setBindGroup(3, bindGroup10, new Uint32Array(1023), 272, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.setVertexBuffer(3, buffer28, 0, 942); |
| } catch {} |
| let buffer44 = device0.createBuffer({ |
| size: 19274, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let sampler22 = device0.createSampler({ |
| label: '\u{1fcfc}\u7ee7\u4eee\u{1fb9a}\u{1fd70}\u5e37\ue88f\u22e1\u9045\u0e69', |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| lodMinClamp: 34.86, |
| lodMaxClamp: 55.12, |
| }); |
| try { |
| computePassEncoder5.setBindGroup(1, bindGroup5, new Uint32Array(1617), 17, 0); |
| } catch {} |
| try { |
| computePassEncoder28.end(); |
| } catch {} |
| try { |
| computePassEncoder15.setPipeline(pipeline0); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let bindGroup31 = device0.createBindGroup({ |
| label: '\u2028\u94eb', |
| layout: bindGroupLayout2, |
| entries: [ |
| {binding: 999, resource: textureView31}, |
| {binding: 35, resource: textureView10}, |
| {binding: 42, resource: externalTexture0}, |
| {binding: 421, resource: {buffer: buffer8, offset: 768, size: 52}}, |
| {binding: 243, resource: textureView13}, |
| {binding: 398, resource: textureView57}, |
| {binding: 567, resource: textureView30}, |
| {binding: 94, resource: textureView12}, |
| {binding: 132, resource: textureView35}, |
| ], |
| }); |
| let textureView58 = texture29.createView({label: '\u9475\uc84a\u{1feb0}\u0b96\u483f'}); |
| let renderPassEncoder16 = commandEncoder39.beginRenderPass({ |
| label: '\u{1fb19}\u6e63\u329d\u7782\u{1f951}', |
| colorAttachments: [{view: textureView4, depthSlice: 162, loadOp: 'load', storeOp: 'store'}], |
| }); |
| try { |
| computePassEncoder3.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder16.setBindGroup(3, bindGroup22, new Uint32Array(1321), 33, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.setScissorRect(37, 0, 10, 0); |
| } catch {} |
| try { |
| computePassEncoder4.setBindGroup(3, bindGroup10); |
| } catch {} |
| let textureView59 = texture5.createView({ |
| label: '\u3887\u0518\u0955\u0ff1\u0805\uf819\u{1f7e3}\u{1f65b}\ub9b9\u0971', |
| dimension: '3d', |
| format: 'rgba8unorm', |
| }); |
| try { |
| computePassEncoder25.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder1.end(); |
| } catch {} |
| try { |
| renderPassEncoder12.setVertexBuffer(4, buffer28, 164, 1_018); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer2]); |
| } catch {} |
| let promise6 = device0.queue.onSubmittedWorkDone(); |
| let buffer45 = device0.createBuffer({size: 20431, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT}); |
| let commandEncoder58 = device0.createCommandEncoder({}); |
| let computePassEncoder41 = commandEncoder2.beginComputePass({}); |
| let renderPassEncoder17 = commandEncoder58.beginRenderPass({ |
| label: '\u01a9\u0876\u0bef\u1869\u0026\u5b3c\u609d\u7570\ue309', |
| colorAttachments: [{ |
| view: textureView15, |
| clearValue: { r: -0.9335, g: 142.3, b: -792.2, a: -131.4, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet3, |
| }); |
| try { |
| computePassEncoder9.setBindGroup(2, bindGroup4, new Uint32Array(577), 81, 0); |
| } catch {} |
| try { |
| computePassEncoder18.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder17.setVertexBuffer(4, buffer4); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 24, new Float32Array(492), 38, 0); |
| } catch {} |
| let commandEncoder59 = device0.createCommandEncoder({label: '\u{1f885}\u{1f90b}\u0b7a\u97a3\u0472\u{1fa75}\uc339\u65f3\u{1ffd4}\u8746'}); |
| let commandBuffer3 = commandEncoder59.finish({label: '\ubcee\ub86f\u{1fa69}'}); |
| try { |
| computePassEncoder34.setBindGroup(2, bindGroup5); |
| } catch {} |
| try { |
| computePassEncoder30.setBindGroup(3, bindGroup24, new Uint32Array(717), 32, 0); |
| } catch {} |
| try { |
| computePassEncoder7.setPipeline(pipeline0); |
| } catch {} |
| try { |
| computePassEncoder1.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(1, bindGroup27); |
| } catch {} |
| let buffer46 = device0.createBuffer({size: 10795, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM}); |
| let textureView60 = texture59.createView({dimension: '2d-array', aspect: 'depth-only'}); |
| try { |
| computePassEncoder35.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder14.setBlendConstant({ r: -551.2, g: -212.2, b: 163.7, a: 467.2, }); |
| } catch {} |
| try { |
| renderPassEncoder4.setVertexBuffer(7, buffer24, 0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture7, |
| mipLevel: 0, |
| origin: {x: 15, y: 0, z: 81}, |
| aspect: 'all', |
| }, new Uint8Array(14_334).fill(73), /* required buffer size: 14_334 */ |
| {offset: 78, bytesPerRow: 36, rowsPerImage: 44}, {width: 1, height: 0, depthOrArrayLayers: 10}); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let buffer47 = device0.createBuffer({size: 8242, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE, mappedAtCreation: false}); |
| let sampler23 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 61.04, |
| lodMaxClamp: 64.24, |
| }); |
| try { |
| computePassEncoder30.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder9.setVertexBuffer(1, buffer8); |
| } catch {} |
| let videoFrame3 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A', timestamp: 0, colorSpace: {fullRange: true, matrix: 'fcc', primaries: 'bt709', transfer: 'bt1361ExtendedColourGamut'} }); |
| let commandEncoder60 = device0.createCommandEncoder({}); |
| let texture62 = device0.createTexture({ |
| size: {width: 48}, |
| sampleCount: 1, |
| dimension: '1d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let textureView61 = texture33.createView({dimension: '2d-array', arrayLayerCount: 1}); |
| let computePassEncoder42 = commandEncoder60.beginComputePass(); |
| let sampler24 = device0.createSampler({ |
| label: '\u9285\u{1f70d}\ud6b1\u073c\u8d8a\uaaec\u{1f8e0}\u6b43\u0347\ud7c5', |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 17.10, |
| lodMaxClamp: 85.70, |
| maxAnisotropy: 14, |
| }); |
| try { |
| computePassEncoder21.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(0, bindGroup1, new Uint32Array(3587), 52, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.beginOcclusionQuery(42); |
| } catch {} |
| try { |
| await promise3; |
| } catch {} |
| let texture63 = device0.createTexture({ |
| size: [110, 10, 1], |
| mipLevelCount: 1, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let sampler25 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 86.63, |
| lodMaxClamp: 91.63, |
| }); |
| try { |
| renderPassEncoder16.setBindGroup(2, bindGroup17); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture38, |
| mipLevel: 0, |
| origin: {x: 5, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(17).fill(137), /* required buffer size: 17 */ |
| {offset: 17, rowsPerImage: 80}, {width: 171, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(img0); |
| await gc(); |
| try { |
| renderPassEncoder16.setBindGroup(2, bindGroup28, new Uint32Array(125), 62, 0); |
| } catch {} |
| let buffer48 = device0.createBuffer({label: '\uad95\u69c0\uc554', size: 4757, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let commandEncoder61 = device0.createCommandEncoder(); |
| let texture64 = device0.createTexture({ |
| size: {width: 384, height: 1, depthOrArrayLayers: 4}, |
| format: 'depth24plus-stencil8', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder43 = commandEncoder61.beginComputePass({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder1); computePassEncoder1.dispatchWorkgroupsIndirect(buffer8, 264); }; |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(3, bindGroup24, new Uint32Array(2037), 348, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.endOcclusionQuery(); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture8, |
| mipLevel: 0, |
| origin: {x: 7, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(858).fill(76), /* required buffer size: 858 */ |
| {offset: 858, rowsPerImage: 87}, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let imageData6 = new ImageData(60, 24); |
| let bindGroup32 = device0.createBindGroup({layout: bindGroupLayout6, entries: [{binding: 11, resource: {buffer: buffer12, offset: 0}}]}); |
| let buffer49 = device0.createBuffer({ |
| size: 1732, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM, |
| }); |
| let texture65 = device0.createTexture({ |
| size: {width: 73, height: 1, depthOrArrayLayers: 24}, |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder4.setBindGroup(1, bindGroup28); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder1); computePassEncoder1.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder32.setPipeline(pipeline0); |
| } catch {} |
| let commandEncoder62 = device0.createCommandEncoder({}); |
| let texture66 = device0.createTexture({ |
| label: '\u7f85\uf0a2\ua319\u081e\ubaf6\u5490\u{1faa4}\u003a\u{1ffcb}\u8a0e', |
| size: [560, 582, 1], |
| mipLevelCount: 3, |
| sampleCount: 1, |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_SRC, |
| }); |
| let computePassEncoder44 = commandEncoder62.beginComputePass({label: '\uc78a\u62b9\u0033\u86fc\ud0e1\u2ee0\u0c57\u0e15\u0b3c\u65ff\u7240'}); |
| try { |
| computePassEncoder37.setPipeline(pipeline0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture8, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(131).fill(155), /* required buffer size: 131 */ |
| {offset: 131}, {width: 9, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture67 = device0.createTexture({ |
| label: '\u0bfb\uf703\u{1f916}\u3318\u{1fbc0}\u{1fbc3}', |
| size: {width: 36, height: 1, depthOrArrayLayers: 11}, |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: ['rgba16sint'], |
| }); |
| try { |
| computePassEncoder5.setBindGroup(0, bindGroup11, new Uint32Array(934), 111, 0); |
| } catch {} |
| try { |
| computePassEncoder42.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder10.setBindGroup(3, bindGroup6, new Uint32Array(1415), 186, 0); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let bindGroup33 = device0.createBindGroup({layout: bindGroupLayout1, entries: [{binding: 277, resource: sampler7}]}); |
| let buffer50 = device0.createBuffer({ |
| size: 1490, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder63 = device0.createCommandEncoder(); |
| let computePassEncoder45 = commandEncoder63.beginComputePass(); |
| let sampler26 = device0.createSampler({ |
| label: '\ud406\u2a56\u{1fffb}\u0f3d\u{1ffb2}\u3092\uef4b\u02de', |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMaxClamp: 99.12, |
| }); |
| try { |
| computePassEncoder8.setBindGroup(0, bindGroup8, new Uint32Array(455), 1, 0); |
| } catch {} |
| try { |
| computePassEncoder1.end(); |
| } catch {} |
| try { |
| renderPassEncoder11.setVertexBuffer(0, buffer3, 88, 176); |
| } catch {} |
| try { |
| await promise6; |
| } catch {} |
| let computePassEncoder46 = commandEncoder3.beginComputePass({}); |
| try { |
| computePassEncoder43.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(1, bindGroup31, new Uint32Array(4675), 102, 0); |
| } catch {} |
| try { |
| renderPassEncoder17.setViewport(90.25700842093102, 0.08292614958652778, 3.6823953367973252, 0.03180822545249983, 0.5753112786032316, 0.7666719561514712); |
| } catch {} |
| let pipelineLayout3 = device0.createPipelineLayout({bindGroupLayouts: []}); |
| let buffer51 = device0.createBuffer({ |
| label: '\uaffc\u5eb4\u{1faae}\u0eb1\u07eb', |
| size: 3176, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let externalTexture1 = device0.importExternalTexture({source: videoFrame2}); |
| try { |
| computePassEncoder5.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder17.setVertexBuffer(7, buffer6); |
| } catch {} |
| try { |
| computePassEncoder11.pushDebugGroup('\u0c41'); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 96, height: 1, depthOrArrayLayers: 131} |
| */ |
| { |
| source: offscreenCanvas0, |
| origin: { x: 6, y: 1 }, |
| flipY: true, |
| }, { |
| texture: texture18, |
| mipLevel: 0, |
| origin: {x: 11, y: 0, z: 18}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 3, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(0x55); }; |
| } catch {} |
| let buffer52 = device0.createBuffer({size: 1684, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX, mappedAtCreation: false}); |
| let commandEncoder64 = device0.createCommandEncoder(); |
| let textureView62 = texture46.createView({dimension: '2d-array', aspect: 'depth-only'}); |
| let renderPassEncoder18 = commandEncoder64.beginRenderPass({colorAttachments: [{view: textureView36, loadOp: 'clear', storeOp: 'store'}]}); |
| let sampler27 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 10.93, |
| lodMaxClamp: 58.42, |
| maxAnisotropy: 19, |
| }); |
| try { |
| computePassEncoder34.setBindGroup(2, bindGroup19, new Uint32Array(1436), 150, 0); |
| } catch {} |
| try { |
| computePassEncoder10.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(2, bindGroup0, new Uint32Array(4830), 679, 0); |
| } catch {} |
| document.body.append(img1); |
| let buffer53 = device0.createBuffer({ |
| size: 7273, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE, |
| }); |
| let sampler28 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 72.68, |
| maxAnisotropy: 17, |
| }); |
| try { |
| computePassEncoder12.setBindGroup(3, bindGroup6); |
| } catch {} |
| try { |
| computePassEncoder32.setBindGroup(0, bindGroup25, new Uint32Array(502), 94, 0); |
| } catch {} |
| try { |
| computePassEncoder14.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder12.setBindGroup(3, bindGroup8, new Uint32Array(2038), 428, 0); |
| } catch {} |
| try { |
| renderPassEncoder17.setVertexBuffer(3, buffer10); |
| } catch {} |
| try { |
| if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(0x55); }; |
| } catch {} |
| let texture68 = device0.createTexture({ |
| size: {width: 36, height: 1, depthOrArrayLayers: 24}, |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let renderBundleEncoder3 = device0.createRenderBundleEncoder({colorFormats: ['rgba16sint'], depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| computePassEncoder10.setBindGroup(0, bindGroup8, new Uint32Array(1824), 561, 0); |
| } catch {} |
| try { |
| computePassEncoder4.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(1, bindGroup17); |
| } catch {} |
| try { |
| renderPassEncoder14.setIndexBuffer(buffer4, 'uint16', 610, 7_146); |
| } catch {} |
| try { |
| renderBundleEncoder3.setBindGroup(3, bindGroup1, new Uint32Array(815), 424, 0); |
| } catch {} |
| let shaderModule6 = device0.createShaderModule({ |
| label: '\u0c62\u126a', |
| code: ` |
| enable f16; |
| |
| requires unrestricted_pointer_parameters; |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| @group(0) @binding(176) var st12: texture_storage_3d<rgba16uint, write>; |
| |
| struct T0 { |
| @align(32) @size(224) f0: array<array<array<f16, 1>, 14>>, |
| } |
| |
| struct T1 { |
| @size(248) f0: array<vec2i>, |
| } |
| |
| struct T2 { |
| @align(32) @size(64) f0: atomic<u32>, |
| @size(4096) f1: array<u32>, |
| } |
| |
| struct T3 { |
| @align(16) @size(48) f0: array<array<mat4x4h, 1>, 1>, |
| } |
| |
| struct VertexOutput5 { |
| @location(15) @interpolate(flat, centroid) f24: vec4i, |
| @builtin(position) f25: vec4f, |
| @location(4) @interpolate(flat, sample) f26: f16, |
| } |
| |
| struct FragmentOutput5 { |
| @builtin(sample_mask) f0: u32, |
| @location(0) f1: vec4i, |
| } |
| |
| alias vec3b = vec3<bool>; |
| |
| var<workgroup> vw31: mat3x4h; |
| |
| var<workgroup> vw32: FragmentOutput5; |
| |
| var<workgroup> vw33: FragmentOutput5; |
| |
| var<workgroup> vw34: array<FragmentOutput5, 1>; |
| |
| var<private> vp4: VertexOutput5 = VertexOutput5(vec4i(123, 11, 8, -89), vec4f(0.2610, -0.05641, 0.00933, 0.2370), f16(4444.8)); |
| |
| var<private> vp5: FragmentOutput5 = FragmentOutput5(); |
| |
| @vertex |
| fn vertex5(@location(7) @interpolate(flat, centroid) a0: vec2i, @location(0) a1: vec2i) -> VertexOutput5 { |
| var out: VertexOutput5; |
| out.f24 += vec4i(i32(vp4.f26)); |
| let ptr55: ptr<private, f16> = &vp4.f26; |
| var vf120: f32 = vp4.f25[vec3u(saturate(vec3f(unconst_f32(0.4408), unconst_f32(0.1741), unconst_f32(0.08870))))[0]]; |
| out.f24 *= vec4i(floor(vec4h(unconst_f16(7988.0), unconst_f16(5838.3), unconst_f16(3534.9), unconst_f16(3089.9)))); |
| var vf121: vec4u = max(vec4u(unconst_u32(117), unconst_u32(7), unconst_u32(148), unconst_u32(86)), vec4u(unconst_u32(267), unconst_u32(107), unconst_u32(1000), unconst_u32(161))); |
| var vf122: u32 = vf121[u32(unconst_u32(304))]; |
| out.f24 = a1.yxyy; |
| vp4.f25 = unpack4x8snorm(vp5.f0); |
| out.f25 = acosh(vec4f(unconst_f32(0.01233), unconst_f32(-0.3400), unconst_f32(0.08932), unconst_f32(0.3074))); |
| let vf123: i32 = a0[u32(unconst_u32(42))]; |
| let vf124: u32 = pack4xI8(vec4i(unconst_i32(11), unconst_i32(145), unconst_i32(36), unconst_i32(70))); |
| var vf125: vec2i = a1; |
| out.f26 = f16(vp5.f0); |
| let ptr56: ptr<private, vec4i> = &vp5.f1; |
| let ptr57: ptr<function, f32> = &vf120; |
| vp5.f0 *= u32((*ptr57)); |
| var vf126: u32 = pack4xI8(vec4i(unconst_i32(130), unconst_i32(239), unconst_i32(135), unconst_i32(98))); |
| out = VertexOutput5(vec4i(i32(vf126)), vec4f(bitcast<f32>(vf126)), f16(vf126)); |
| let vf127: vec2i = a0; |
| var vf128: i32 = vf125[u32(unconst_u32(30))]; |
| let vf129: vec4f = step(vec4f(unconst_f32(0.2225), unconst_f32(0.00236), unconst_f32(0.2676), unconst_f32(0.02082)), vec4f(f32((*ptr56)[u32(unconst_u32(209))]))); |
| let ptr58: ptr<function, vec4u> = &vf121; |
| return out; |
| } |
| |
| @fragment |
| fn fragment6() -> FragmentOutput5 { |
| var out: FragmentOutput5; |
| out.f0 = countTrailingZeros(vec3u(unpack2x16snorm(u32(unconst_u32(90))).xyx)).r; |
| let ptr59: ptr<private, f16> = &vp4.f26; |
| var vf130: vec2f = log(vec2f(unconst_f32(0.1184), unconst_f32(0.1955))); |
| let ptr60: ptr<private, FragmentOutput5> = &vp5; |
| let vf131: vec2f = smoothstep(vec2f(unconst_f32(0.2379), unconst_f32(0.05978)), vec2f(unconst_f32(0.6442), unconst_f32(0.08395)), vec2f(unconst_f32(0.05456), unconst_f32(0.3774))); |
| out.f1 *= vec4i(firstLeadingBit(i32(unconst_i32(438)))); |
| out.f1 ^= vec4i(i32(vp4.f26)); |
| out = FragmentOutput5(insertBits(vec2u(unconst_u32(163), unconst_u32(66)), vec2u(unconst_u32(79), unconst_u32(6)), u32(unconst_u32(21)), u32(unconst_u32(155)))[0], bitcast<vec4i>(insertBits(vec2u(unconst_u32(163), unconst_u32(66)), vec2u(unconst_u32(79), unconst_u32(6)), u32(unconst_u32(21)), u32(unconst_u32(155))).xyxy)); |
| vp5.f1 = unpack4xI8(pack4x8snorm(vec4f(unconst_f32(0.01959), unconst_f32(-0.1335), unconst_f32(-0.3388), unconst_f32(0.1872)))); |
| let ptr61: ptr<private, vec4i> = &vp4.f24; |
| var vf132: vec2f = vf131; |
| out.f1 *= vec4i(insertBits(vec2u(unconst_u32(739), unconst_u32(305)), vec2u(unconst_u32(75), unconst_u32(324)), u32(unconst_u32(1000)), u32(unconst_u32(208))).xxxx); |
| let ptr62: ptr<private, FragmentOutput5> = &vp5; |
| let ptr63: ptr<function, vec2f> = &vf132; |
| let vf133: f32 = vf131[u32(unconst_u32(314))]; |
| let ptr64: ptr<private, u32> = &(*ptr62).f0; |
| var vf134: vec3h = cross(vec3h(unconst_f16(6121.9), unconst_f16(2749.9), unconst_f16(20207.2)), vec3h(unconst_f16(18748.4), unconst_f16(42426.6), unconst_f16(12552.3))); |
| let ptr65: ptr<private, FragmentOutput5> = &vp5; |
| let vf135: i32 = (*ptr60).f1[u32(unconst_u32(263))]; |
| var vf136: i32 = (*ptr62).f1[u32(unconst_u32(304))]; |
| vf130 = bitcast<vec2f>((*ptr65).f1.ab); |
| return out; |
| }`, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| let buffer54 = device0.createBuffer({ |
| label: '\u6a19\u06da\u04be\u7247\uf928\u{1fe15}\ub122', |
| size: 11252, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM, |
| }); |
| let commandEncoder65 = device0.createCommandEncoder(); |
| let renderPassEncoder19 = commandEncoder65.beginRenderPass({ |
| label: '\u07a6\u{1f67f}\u3a24\u0528\ud2cd\u{1fcc6}\uc4c6\u225a\ueb71\u9d22', |
| colorAttachments: [{ |
| view: textureView16, |
| clearValue: { r: 11.37, g: -87.86, b: 80.10, a: 29.25, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| computePassEncoder3.setBindGroup(0, bindGroup7, new Uint32Array(2802), 399, 0); |
| } catch {} |
| try { |
| computePassEncoder36.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderBundleEncoder3.setIndexBuffer(buffer10, 'uint32', 292, 5_312); |
| } catch {} |
| try { |
| renderBundleEncoder3.setVertexBuffer(6, buffer10, 5_380); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer3]); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture38, |
| mipLevel: 0, |
| origin: {x: 107, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(175).fill(120), /* required buffer size: 175 */ |
| {offset: 175}, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 96, height: 1, depthOrArrayLayers: 131} |
| */ |
| { |
| source: imageData5, |
| origin: { x: 6, y: 19 }, |
| flipY: false, |
| }, { |
| texture: texture18, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer55 = device0.createBuffer({size: 32162, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let textureView63 = texture10.createView({dimension: '2d-array', baseMipLevel: 1, mipLevelCount: 1}); |
| try { |
| computePassEncoder5.setBindGroup(0, bindGroup12, new Uint32Array(596), 291, 0); |
| } catch {} |
| try { |
| computePassEncoder9.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderBundleEncoder3.setBindGroup(3, bindGroup22, new Uint32Array(1624), 36, 0); |
| } catch {} |
| try { |
| renderBundleEncoder3.setIndexBuffer(buffer42, 'uint32', 4, 575); |
| } catch {} |
| try { |
| renderBundleEncoder3.setVertexBuffer(6, buffer3, 0, 137); |
| } catch {} |
| try { |
| computePassEncoder3.insertDebugMarker('\ua07f'); |
| } catch {} |
| try { |
| renderBundleEncoder3.insertDebugMarker('\u01de'); |
| } catch {} |
| let bindGroup34 = device0.createBindGroup({ |
| layout: bindGroupLayout8, |
| entries: [{binding: 27, resource: {buffer: buffer8, offset: 0, size: 358}}], |
| }); |
| let renderBundle3 = renderBundleEncoder3.finish({}); |
| let sampler29 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'mirror-repeat', |
| minFilter: 'nearest', |
| lodMinClamp: 39.27, |
| lodMaxClamp: 50.06, |
| }); |
| try { |
| computePassEncoder26.setBindGroup(0, bindGroup25); |
| } catch {} |
| try { |
| computePassEncoder4.dispatchWorkgroupsIndirect(buffer26, 44); |
| } catch {} |
| try { |
| renderPassEncoder15.setIndexBuffer(buffer44, 'uint16', 2_966, 3_849); |
| } catch {} |
| try { |
| renderPassEncoder11.setVertexBuffer(3, buffer12, 24, 3); |
| } catch {} |
| let commandEncoder66 = device0.createCommandEncoder({label: '\u04fd\u{1fd33}\u0851\ua978\u{1fdf3}'}); |
| let texture69 = device0.createTexture({ |
| size: {width: 192}, |
| dimension: '1d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let renderPassEncoder20 = commandEncoder66.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView52, |
| clearValue: { r: 747.4, g: -827.3, b: -795.7, a: -689.6, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| }); |
| let sampler30 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 67.86, |
| maxAnisotropy: 8, |
| }); |
| try { |
| renderPassEncoder7.setBindGroup(3, bindGroup17, new Uint32Array(1556), 291, 0); |
| } catch {} |
| try { |
| renderPassEncoder14.setIndexBuffer(buffer50, 'uint16', 118, 315); |
| } catch {} |
| let canvas0 = document.createElement('canvas'); |
| let sampler31 = device0.createSampler({ |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 66.80, |
| maxAnisotropy: 13, |
| }); |
| try { |
| computePassEncoder9.setBindGroup(3, bindGroup34, new Uint32Array(1505), 271, 0); |
| } catch {} |
| try { |
| computePassEncoder26.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder2.executeBundles([renderBundle0]); |
| } catch {} |
| let sampler32 = device0.createSampler({ |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 87.18, |
| compare: 'less', |
| maxAnisotropy: 14, |
| }); |
| try { |
| computePassEncoder29.setBindGroup(0, bindGroup27); |
| } catch {} |
| try { |
| computePassEncoder26.setBindGroup(0, bindGroup7, new Uint32Array(354), 227, 0); |
| } catch {} |
| try { |
| computePassEncoder44.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder4.beginOcclusionQuery(20); |
| } catch {} |
| try { |
| renderPassEncoder14.executeBundles([renderBundle1]); |
| } catch {} |
| try { |
| renderPassEncoder14.setVertexBuffer(5, buffer50, 220, 436); |
| } catch {} |
| try { |
| renderPassEncoder9.insertDebugMarker('\u3090'); |
| } catch {} |
| let commandEncoder67 = device0.createCommandEncoder({}); |
| let querySet7 = device0.createQuerySet({type: 'occlusion', count: 274}); |
| let computePassEncoder47 = commandEncoder67.beginComputePass({}); |
| let sampler33 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 85.58, |
| maxAnisotropy: 4, |
| }); |
| try { |
| computePassEncoder18.setBindGroup(0, bindGroup7); |
| } catch {} |
| try { |
| renderPassEncoder15.setBindGroup(3, bindGroup7); |
| } catch {} |
| try { |
| renderPassEncoder4.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder4.executeBundles([renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder6.setViewport(63.175236927911186, 0.5447279634374392, 15.792586307660072, 0.3681254983202363, 0.9564349314816643, 0.9909721520638055); |
| } catch {} |
| try { |
| renderPassEncoder20.setIndexBuffer(buffer30, 'uint16', 2, 17); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let buffer56 = device0.createBuffer({ |
| label: '\u{1fb3a}\u4430\u00ae\u3a86', |
| size: 21544, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, |
| }); |
| let textureView64 = texture20.createView({dimension: '2d', format: 'rgba32sint', mipLevelCount: 1, baseArrayLayer: 1}); |
| try { |
| computePassEncoder9.setBindGroup(3, bindGroup5); |
| } catch {} |
| try { |
| computePassEncoder10.setBindGroup(2, bindGroup26, new Uint32Array(821), 57, 0); |
| } catch {} |
| try { |
| computePassEncoder4.end(); |
| } catch {} |
| try { |
| renderPassEncoder15.setBindGroup(3, bindGroup24, []); |
| } catch {} |
| try { |
| renderPassEncoder11.setBindGroup(1, bindGroup4, new Uint32Array(1509), 47, 0); |
| } catch {} |
| document.body.prepend(canvas0); |
| let buffer57 = device0.createBuffer({ |
| size: 3811, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM, |
| }); |
| let textureView65 = texture26.createView({dimension: '2d-array', mipLevelCount: 1}); |
| let computePassEncoder48 = commandEncoder7.beginComputePass({}); |
| try { |
| computePassEncoder11.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer54, 'uint32', 8_348, 213); |
| } catch {} |
| try { |
| computePassEncoder11.popDebugGroup(); |
| } catch {} |
| let bindGroup35 = device0.createBindGroup({layout: bindGroupLayout1, entries: [{binding: 277, resource: sampler14}]}); |
| let buffer58 = device0.createBuffer({size: 2236, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM}); |
| let commandEncoder68 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder46.setBindGroup(3, bindGroup30); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder10); computePassEncoder10.dispatchWorkgroupsIndirect(buffer50, 356); }; |
| } catch {} |
| try { |
| computePassEncoder48.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(0, bindGroup22, new Uint32Array(707), 291, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.setIndexBuffer(buffer15, 'uint32', 924, 144); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(4, buffer8, 524); |
| } catch {} |
| let imageData7 = new ImageData(36, 4); |
| let bindGroup36 = device0.createBindGroup({ |
| layout: bindGroupLayout2, |
| entries: [ |
| {binding: 35, resource: textureView11}, |
| {binding: 398, resource: textureView13}, |
| {binding: 999, resource: textureView65}, |
| {binding: 94, resource: textureView12}, |
| {binding: 421, resource: {buffer: buffer58, offset: 0, size: 948}}, |
| {binding: 243, resource: textureView39}, |
| {binding: 567, resource: textureView14}, |
| {binding: 42, resource: externalTexture0}, |
| {binding: 132, resource: textureView48}, |
| ], |
| }); |
| let commandEncoder69 = device0.createCommandEncoder(); |
| let texture70 = device0.createTexture({ |
| size: [73], |
| dimension: '1d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler34 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 0.8019, |
| lodMaxClamp: 45.14, |
| maxAnisotropy: 9, |
| }); |
| let externalTexture2 = device0.importExternalTexture({ |
| label: '\u{1f968}\u{1f80f}\u7d75\udd31\uc002\u0b52\ubab9\u0b61\u0ad8', |
| source: videoFrame1, |
| colorSpace: 'srgb', |
| }); |
| try { |
| renderPassEncoder0.setBindGroup(1, bindGroup27); |
| } catch {} |
| try { |
| renderPassEncoder7.setVertexBuffer(6, buffer8, 0, 31); |
| } catch {} |
| try { |
| buffer25.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| document.body.append(canvas0); |
| let bindGroup37 = device0.createBindGroup({ |
| layout: bindGroupLayout0, |
| entries: [{binding: 103, resource: textureView28}, {binding: 176, resource: textureView8}], |
| }); |
| let texture71 = device0.createTexture({ |
| size: [55, 5, 1], |
| mipLevelCount: 1, |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: ['rgb10a2uint'], |
| }); |
| let textureView66 = texture1.createView({}); |
| let computePassEncoder49 = commandEncoder69.beginComputePass({label: '\uf922\u{1fbb1}\u07c7\uc926\u1f93\u{1f637}\u08f4'}); |
| try { |
| computePassEncoder34.setBindGroup(2, bindGroup3); |
| } catch {} |
| try { |
| computePassEncoder45.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder16.setBindGroup(1, bindGroup10, new Uint32Array(751), 2, 0); |
| } catch {} |
| try { |
| renderPassEncoder11.setIndexBuffer(buffer21, 'uint16', 96, 3_967); |
| } catch {} |
| try { |
| commandEncoder68.copyBufferToTexture({ |
| /* bytesInLastRow: 52 widthInBlocks: 13 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1016 */ |
| offset: 1016, |
| buffer: buffer27, |
| }, { |
| texture: texture65, |
| mipLevel: 0, |
| origin: {x: 20, y: 0, z: 5}, |
| aspect: 'all', |
| }, {width: 13, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| let textureView67 = texture39.createView({dimension: '2d-array', mipLevelCount: 1}); |
| let sampler35 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| addressModeW: 'clamp-to-edge', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 18.34, |
| lodMaxClamp: 99.06, |
| maxAnisotropy: 1, |
| }); |
| try { |
| computePassEncoder18.setBindGroup(0, bindGroup16, new Uint32Array(1136), 542, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder26); computePassEncoder26.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder10.end(); |
| } catch {} |
| try { |
| renderPassEncoder4.executeBundles([renderBundle3, renderBundle0, renderBundle0]); |
| } catch {} |
| try { |
| buffer50.unmap(); |
| } catch {} |
| let computePassEncoder50 = commandEncoder16.beginComputePass({}); |
| try { |
| computePassEncoder19.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder18.setBindGroup(0, bindGroup10, new Uint32Array(572), 128, 0); |
| } catch {} |
| try { |
| commandEncoder68.resolveQuerySet(querySet0, 0, 10, buffer51, 512); |
| } catch {} |
| let buffer59 = device0.createBuffer({ |
| size: 2193, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| let commandEncoder70 = device0.createCommandEncoder({}); |
| let sampler36 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 7.759, |
| lodMaxClamp: 61.87, |
| }); |
| try { |
| computePassEncoder22.setPipeline(pipeline0); |
| } catch {} |
| try { |
| commandEncoder68.copyBufferToTexture({ |
| /* bytesInLastRow: 328 widthInBlocks: 82 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 240 */ |
| offset: 240, |
| rowsPerImage: 123, |
| buffer: buffer27, |
| }, { |
| texture: texture44, |
| mipLevel: 0, |
| origin: {x: 6, y: 0, z: 5}, |
| aspect: 'all', |
| }, {width: 82, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| globalThis.someLabel = textureView25.label; |
| } catch {} |
| let bindGroup38 = device0.createBindGroup({ |
| label: '\u690a\uf79d', |
| layout: bindGroupLayout6, |
| entries: [{binding: 11, resource: {buffer: buffer40, offset: 28416}}], |
| }); |
| let computePassEncoder51 = commandEncoder70.beginComputePass({label: '\u{1f858}\u{1fbba}\uf657\u4044\ufb22\u0441'}); |
| let renderPassEncoder21 = commandEncoder68.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView6, |
| clearValue: { r: 576.1, g: -828.3, b: 914.9, a: 850.6, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| }); |
| let sampler37 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 10.35, |
| lodMaxClamp: 16.56, |
| maxAnisotropy: 17, |
| }); |
| try { |
| computePassEncoder18.setBindGroup(1, bindGroup13, new Uint32Array(1195), 205, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.setBindGroup(2, bindGroup30, new Uint32Array(3521), 527, 0); |
| } catch {} |
| try { |
| renderPassEncoder14.executeBundles([renderBundle2, renderBundle2]); |
| } catch {} |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer13, 'uint32', 940, 3_245); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture67, |
| mipLevel: 0, |
| origin: {x: 19, y: 0, z: 2}, |
| aspect: 'all', |
| }, new Uint8Array(74).fill(144), /* required buffer size: 74 */ |
| {offset: 74}, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup39 = device0.createBindGroup({ |
| layout: bindGroupLayout6, |
| entries: [{binding: 11, resource: {buffer: buffer50, offset: 0, size: 980}}], |
| }); |
| let commandEncoder71 = device0.createCommandEncoder({}); |
| let computePassEncoder52 = commandEncoder71.beginComputePass({}); |
| try { |
| computePassEncoder50.setBindGroup(0, bindGroup26); |
| } catch {} |
| try { |
| computePassEncoder50.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder10.setBindGroup(2, bindGroup8); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture65, |
| mipLevel: 0, |
| origin: {x: 27, y: 0, z: 14}, |
| aspect: 'all', |
| }, new Uint8Array(27).fill(26), /* required buffer size: 27 */ |
| {offset: 27, rowsPerImage: 69}, {width: 12, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder72 = device0.createCommandEncoder({}); |
| let renderPassEncoder22 = commandEncoder72.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView38, |
| clearValue: { r: 729.5, g: -331.5, b: -810.3, a: 269.4, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| }); |
| let sampler38 = device0.createSampler({ |
| label: '\u4658\uf8ff\u0800\u{1fbc3}\u05f1', |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 54.35, |
| lodMaxClamp: 75.96, |
| }); |
| try { |
| computePassEncoder43.setBindGroup(3, bindGroup17); |
| } catch {} |
| try { |
| computePassEncoder47.setBindGroup(2, bindGroup8, new Uint32Array(4423), 610, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder18); computePassEncoder18.dispatchWorkgroupsIndirect(buffer3, 340); }; |
| } catch {} |
| try { |
| computePassEncoder26.end(); |
| } catch {} |
| try { |
| renderPassEncoder12.setIndexBuffer(buffer21, 'uint32', 2_408, 281); |
| } catch {} |
| try { |
| device0.pushErrorScope('internal'); |
| } catch {} |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 73, height: 1, depthOrArrayLayers: 54} |
| */ |
| { |
| source: imageData7, |
| origin: { x: 4, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture5, |
| mipLevel: 0, |
| origin: {x: 70, y: 0, z: 4}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 3, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer60 = device0.createBuffer({size: 1432, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE}); |
| let commandEncoder73 = device0.createCommandEncoder({}); |
| let texture72 = device0.createTexture({ |
| size: {width: 70, height: 72, depthOrArrayLayers: 276}, |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let computePassEncoder53 = commandEncoder73.beginComputePass({}); |
| let sampler39 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| lodMinClamp: 23.04, |
| lodMaxClamp: 48.50, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder18); computePassEncoder18.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder17.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder14.setVertexBuffer(3, buffer10); |
| } catch {} |
| try { |
| commandEncoder36.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 3808 */ |
| offset: 3808, |
| rowsPerImage: 1830, |
| buffer: buffer11, |
| }, { |
| texture: texture40, |
| mipLevel: 0, |
| origin: {x: 43, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture51, |
| mipLevel: 0, |
| origin: {x: 38, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(57).fill(129), /* required buffer size: 57 */ |
| {offset: 57, rowsPerImage: 3}, {width: 113, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let computePassEncoder54 = commandEncoder36.beginComputePass(); |
| try { |
| computePassEncoder43.setBindGroup(2, bindGroup4, new Uint32Array(1109), 185, 0); |
| } catch {} |
| try { |
| renderPassEncoder14.setScissorRect(28, 13, 10, 2); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer27, 'uint32', 740, 322); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 73, height: 1, depthOrArrayLayers: 54} |
| */ |
| { |
| source: imageData6, |
| origin: { x: 0, y: 10 }, |
| flipY: false, |
| }, { |
| texture: texture5, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 8}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 33, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(canvas0); |
| let imageData8 = new ImageData(8, 24); |
| let commandEncoder74 = device0.createCommandEncoder({}); |
| let texture73 = device0.createTexture({ |
| size: [55, 5, 41], |
| mipLevelCount: 2, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let textureView68 = texture62.createView({}); |
| let renderPassEncoder23 = commandEncoder74.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView36, |
| clearValue: { r: -316.9, g: 865.7, b: 599.1, a: -647.2, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet3, |
| maxDrawCount: 336395403, |
| }); |
| let sampler40 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 4.366, |
| lodMaxClamp: 93.54, |
| }); |
| try { |
| computePassEncoder12.setBindGroup(0, bindGroup9, new Uint32Array(53), 2, 0); |
| } catch {} |
| try { |
| computePassEncoder39.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(2, bindGroup28, new Uint32Array(2083), 64, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.executeBundles([renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder22.setIndexBuffer(buffer10, 'uint32', 2_700, 7_853); |
| } catch {} |
| document.body.append(canvas0); |
| let commandEncoder75 = device0.createCommandEncoder({}); |
| let texture74 = device0.createTexture({ |
| size: {width: 73, height: 1, depthOrArrayLayers: 35}, |
| mipLevelCount: 2, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let renderPassEncoder24 = commandEncoder75.beginRenderPass({colorAttachments: [{view: textureView52, loadOp: 'load', storeOp: 'store'}]}); |
| try { |
| computePassEncoder13.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder14.setViewport(17.586159251107347, 51.20227765667542, 1.3113871328753293, 15.370376167385334, 0.9417810292882771, 0.9606309683538449); |
| } catch {} |
| await gc(); |
| let commandEncoder76 = device0.createCommandEncoder({}); |
| let renderPassEncoder25 = commandEncoder76.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView5, |
| clearValue: { r: -339.8, g: -349.1, b: 34.54, a: 280.9, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| renderPassEncoder12.beginOcclusionQuery(32); |
| } catch {} |
| try { |
| renderPassEncoder16.setBlendConstant({ r: 432.6, g: 275.0, b: -214.2, a: 480.0, }); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(4, buffer18, 0, 179); |
| } catch {} |
| let commandEncoder77 = device0.createCommandEncoder({label: '\u54f8\u8cfa\uadc4\u{1fb1c}\u5b14\u36d5\u0a66'}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder18); computePassEncoder18.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(1, bindGroup11); |
| } catch {} |
| try { |
| renderPassEncoder12.endOcclusionQuery(); |
| } catch {} |
| try { |
| commandEncoder77.copyTextureToTexture({ |
| texture: texture1, |
| mipLevel: 0, |
| origin: {x: 5, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture38, |
| mipLevel: 0, |
| origin: {x: 32, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 10, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let gpuCanvasContext1 = canvas0.getContext('webgpu'); |
| let bindGroup40 = device0.createBindGroup({ |
| layout: bindGroupLayout3, |
| entries: [ |
| {binding: 225, resource: textureView57}, |
| {binding: 58, resource: {buffer: buffer37, offset: 0, size: 3333}}, |
| ], |
| }); |
| let commandEncoder78 = device0.createCommandEncoder({}); |
| let textureView69 = texture37.createView({}); |
| let renderPassEncoder26 = commandEncoder78.beginRenderPass({colorAttachments: [{view: textureView52, loadOp: 'clear', storeOp: 'store'}]}); |
| try { |
| computePassEncoder12.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder22.setBindGroup(2, bindGroup29, []); |
| } catch {} |
| try { |
| commandEncoder77.copyBufferToTexture({ |
| /* bytesInLastRow: 64 widthInBlocks: 4 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 5680 */ |
| offset: 5680, |
| bytesPerRow: 1792, |
| rowsPerImage: 0, |
| buffer: buffer23, |
| }, { |
| texture: texture20, |
| mipLevel: 2, |
| origin: {x: 3, y: 0, z: 1}, |
| aspect: 'all', |
| }, {width: 4, height: 0, depthOrArrayLayers: 33}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer46, 1252, new DataView(new ArrayBuffer(33200)), 2643, 1396); |
| } catch {} |
| let bindGroup41 = device0.createBindGroup({ |
| label: '\u5ae4\u0134\u68da\u0808\u9a3c\u{1f740}\u{1fab1}\u{1fbc5}\u{1fa16}\u96c2\u7e9f', |
| layout: bindGroupLayout8, |
| entries: [{binding: 27, resource: {buffer: buffer27, offset: 256, size: 212}}], |
| }); |
| let commandEncoder79 = device0.createCommandEncoder({label: '\ufc0b\u0fc5\u{1f815}\uc4ea\u2f7d\u0149\u9ca6'}); |
| let computePassEncoder55 = commandEncoder79.beginComputePass({}); |
| let renderPassEncoder27 = commandEncoder77.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView52, |
| clearValue: { r: 654.8, g: 56.36, b: 795.3, a: 304.3, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| maxDrawCount: 91560532, |
| }); |
| try { |
| computePassEncoder12.setBindGroup(3, bindGroup39); |
| } catch {} |
| try { |
| renderPassEncoder25.setBindGroup(2, bindGroup4); |
| } catch {} |
| try { |
| renderPassEncoder25.setVertexBuffer(5, buffer12); |
| } catch {} |
| try { |
| renderPassEncoder9.insertDebugMarker('\u8dc5'); |
| } catch {} |
| await gc(); |
| let videoFrame4 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: false, matrix: 'yCgCo', primaries: 'smpte170m', transfer: 'unspecified'} }); |
| try { |
| computePassEncoder53.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder25.executeBundles([renderBundle0, renderBundle3, renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder12.setIndexBuffer(buffer10, 'uint16', 2_852, 9); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture51, |
| mipLevel: 0, |
| origin: {x: 257, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(310).fill(135), /* required buffer size: 310 */ |
| {offset: 310}, {width: 50, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| computePassEncoder3.setBindGroup(0, bindGroup0); |
| } catch {} |
| try { |
| renderPassEncoder24.setVertexBuffer(1, buffer3, 0); |
| } catch {} |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55); }; |
| } catch {} |
| let commandEncoder80 = device0.createCommandEncoder({label: '\u00ff\u{1ffe0}\u00ec\u971d\u0044\u92c6\u{1f6f5}'}); |
| let textureView70 = texture15.createView({baseMipLevel: 0}); |
| let computePassEncoder56 = commandEncoder80.beginComputePass({}); |
| try { |
| computePassEncoder22.setBindGroup(0, bindGroup16); |
| } catch {} |
| try { |
| computePassEncoder18.end(); |
| } catch {} |
| try { |
| renderPassEncoder20.setBindGroup(0, bindGroup10, new Uint32Array(2076), 381, 0); |
| } catch {} |
| try { |
| renderPassEncoder16.setIndexBuffer(buffer15, 'uint16', 412, 1_045); |
| } catch {} |
| try { |
| renderPassEncoder27.setVertexBuffer(0, buffer6, 376); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer23, 2880, new Float32Array(12418), 132, 12); |
| } catch {} |
| let imageData9 = new ImageData(12, 48); |
| let videoFrame5 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: false, matrix: 'rgb', primaries: 'smpte432', transfer: 'log'} }); |
| try { |
| adapter0.label = '\ue5e1\u5e4d\u5237\u0d3e'; |
| } catch {} |
| let bindGroup42 = device0.createBindGroup({ |
| layout: bindGroupLayout2, |
| entries: [ |
| {binding: 42, resource: externalTexture2}, |
| {binding: 132, resource: textureView22}, |
| {binding: 94, resource: textureView54}, |
| {binding: 398, resource: textureView39}, |
| {binding: 35, resource: textureView11}, |
| {binding: 999, resource: textureView36}, |
| {binding: 421, resource: {buffer: buffer19, offset: 0, size: 468}}, |
| {binding: 567, resource: textureView30}, |
| {binding: 243, resource: textureView39}, |
| ], |
| }); |
| let computePassEncoder57 = commandEncoder25.beginComputePass({}); |
| try { |
| computePassEncoder49.setBindGroup(3, bindGroup22, new Uint32Array(463), 31, 0); |
| } catch {} |
| try { |
| computePassEncoder44.end(); |
| } catch {} |
| try { |
| renderPassEncoder18.setScissorRect(16, 37, 9, 9); |
| } catch {} |
| try { |
| renderPassEncoder15.setIndexBuffer(buffer4, 'uint16', 16_400, 459); |
| } catch {} |
| try { |
| commandEncoder62.copyBufferToTexture({ |
| /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1708 */ |
| offset: 1708, |
| bytesPerRow: 20224, |
| rowsPerImage: 9, |
| buffer: buffer41, |
| }, { |
| texture: texture32, |
| mipLevel: 0, |
| origin: {x: 16, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup43 = device0.createBindGroup({ |
| label: '\u7406\u04c2\u0579\u{1fe06}\u{1fac7}\u{1f7e5}', |
| layout: bindGroupLayout1, |
| entries: [{binding: 277, resource: sampler26}], |
| }); |
| let buffer61 = device0.createBuffer({size: 3084, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let sampler41 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| magFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 76.83, |
| lodMaxClamp: 82.30, |
| }); |
| try { |
| computePassEncoder47.setBindGroup(0, bindGroup36, new Uint32Array(2899), 133, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder12); computePassEncoder12.dispatchWorkgroupsIndirect(buffer3, 264); }; |
| } catch {} |
| try { |
| renderPassEncoder24.setIndexBuffer(buffer28, 'uint32', 1_548, 321); |
| } catch {} |
| let pipeline1 = await device0.createRenderPipelineAsync({ |
| label: '\u9e5a\uc93e\uabd9\udb58\u951e\ueed9\u{1f85f}\u0e4e', |
| layout: pipelineLayout0, |
| multisample: {}, |
| fragment: { |
| module: shaderModule5, |
| constants: {}, |
| targets: [{format: 'rgb10a2uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN}], |
| }, |
| vertex: { |
| module: shaderModule2, |
| constants: {}, |
| buffers: [ |
| { |
| arrayStride: 84, |
| stepMode: 'vertex', |
| attributes: [ |
| {format: 'uint8x4', offset: 4, shaderLocation: 1}, |
| {format: 'uint32x2', offset: 4, shaderLocation: 9}, |
| {format: 'snorm8x2', offset: 0, shaderLocation: 7}, |
| ], |
| }, |
| ], |
| }, |
| }); |
| let videoFrame6 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt709', primaries: 'smpte240m', transfer: 'bt2020_12bit'} }); |
| let buffer62 = device0.createBuffer({ |
| size: 26892, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder81 = device0.createCommandEncoder({}); |
| let commandBuffer4 = commandEncoder62.finish(); |
| let renderPassEncoder28 = commandEncoder81.beginRenderPass({colorAttachments: [{view: textureView52, loadOp: 'load', storeOp: 'store'}]}); |
| let sampler42 = device0.createSampler({ |
| label: '\u5065\u1ce3\u0ea7\u5490', |
| addressModeU: 'repeat', |
| addressModeW: 'clamp-to-edge', |
| mipmapFilter: 'nearest', |
| lodMaxClamp: 76.28, |
| maxAnisotropy: 1, |
| }); |
| try { |
| computePassEncoder27.setBindGroup(0, bindGroup27, new Uint32Array(114), 7, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder9); computePassEncoder9.dispatchWorkgroups(5); }; |
| } catch {} |
| try { |
| computePassEncoder40.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder18.setBindGroup(3, bindGroup28, new Uint32Array(386), 23, 0); |
| } catch {} |
| let videoFrame7 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-ncl', primaries: 'smpteRp431', transfer: 'gamma28curve'} }); |
| let textureView71 = texture37.createView({aspect: 'all'}); |
| let sampler43 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| }); |
| try { |
| renderPassEncoder4.setBindGroup(1, bindGroup16, new Uint32Array(159), 13, 0); |
| } catch {} |
| try { |
| renderPassEncoder12.setVertexBuffer(5, buffer56, 0); |
| } catch {} |
| try { |
| renderPassEncoder19.pushDebugGroup('\u8ec4'); |
| } catch {} |
| try { |
| renderPassEncoder19.popDebugGroup(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer2, 2964, new Int16Array(28051), 1969, 1660); |
| } catch {} |
| let textureView72 = texture19.createView({label: '\u86f6\u0aed\u4515\u7c22\u0592\u{1fba9}\uc3ab\ue32a\u1429\u{1fd2c}\u{1f9ff}', aspect: 'all'}); |
| let texture75 = device0.createTexture({ |
| size: {width: 140, height: 145, depthOrArrayLayers: 1}, |
| mipLevelCount: 5, |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler44 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 40.05, |
| lodMaxClamp: 63.96, |
| maxAnisotropy: 10, |
| }); |
| try { |
| computePassEncoder23.setBindGroup(2, bindGroup4); |
| } catch {} |
| try { |
| computePassEncoder8.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder3.executeBundles([renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer4, 'uint32', 6_324, 13_520); |
| } catch {} |
| let bindGroup44 = device0.createBindGroup({ |
| layout: bindGroupLayout5, |
| entries: [ |
| {binding: 86, resource: textureView17}, |
| {binding: 211, resource: sampler31}, |
| {binding: 62, resource: textureView13}, |
| ], |
| }); |
| let commandEncoder82 = device0.createCommandEncoder({}); |
| let texture76 = device0.createTexture({ |
| label: '\u08f6\u013b\uc5a1\u05b8\u6e07', |
| size: {width: 64, height: 64, depthOrArrayLayers: 22}, |
| mipLevelCount: 4, |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let computePassEncoder58 = commandEncoder82.beginComputePass({}); |
| try { |
| computePassEncoder43.setBindGroup(2, bindGroup30, new Uint32Array(3317), 1_396, 0); |
| } catch {} |
| try { |
| renderPassEncoder6.setScissorRect(13, 0, 20, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer42, 'uint16', 248, 224); |
| } catch {} |
| try { |
| renderPassEncoder14.setVertexBuffer(2, buffer3); |
| } catch {} |
| try { |
| await buffer41.mapAsync(GPUMapMode.WRITE, 24, 144); |
| } catch {} |
| try { |
| computePassEncoder19.setPipeline(pipeline0); |
| } catch {} |
| try { |
| computePassEncoder20.insertDebugMarker('\u3187'); |
| } catch {} |
| try { |
| if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(0x55); }; |
| } catch {} |
| document.body.prepend(img0); |
| let texture77 = device0.createTexture({ |
| size: {width: 73}, |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder55.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder8.executeBundles([renderBundle3, renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder12.setVertexBuffer(7, buffer62, 8_320, 120); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| await gc(); |
| try { |
| computePassEncoder24.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder15.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder14.setVertexBuffer(7, buffer59, 0, 507); |
| } catch {} |
| try { |
| if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(0x55); }; |
| } catch {} |
| document.body.append(img0); |
| let buffer63 = device0.createBuffer({ |
| size: 20249, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| try { |
| computePassEncoder25.setPipeline(pipeline0); |
| } catch {} |
| try { |
| computePassEncoder27.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder24.setBindGroup(0, bindGroup43, new Uint32Array(422), 12, 0); |
| } catch {} |
| try { |
| renderPassEncoder17.setBlendConstant({ r: -828.0, g: -340.6, b: 164.8, a: 54.44, }); |
| } catch {} |
| try { |
| renderPassEncoder13.setScissorRect(0, 0, 14, 0); |
| } catch {} |
| try { |
| renderPassEncoder20.setIndexBuffer(buffer57, 'uint32', 1_716, 52); |
| } catch {} |
| try { |
| renderPassEncoder14.setPipeline(pipeline1); |
| } catch {} |
| document.body.append(canvas0); |
| let sampler45 = device0.createSampler({ |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| lodMaxClamp: 79.85, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder22); computePassEncoder22.dispatchWorkgroupsIndirect(buffer45, 4_460); }; |
| } catch {} |
| try { |
| computePassEncoder46.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder28.setBindGroup(1, bindGroup0); |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer10, 'uint32', 5_564, 1_195); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 96, height: 1, depthOrArrayLayers: 131} |
| */ |
| { |
| source: imageData0, |
| origin: { x: 1, y: 15 }, |
| flipY: true, |
| }, { |
| texture: texture18, |
| mipLevel: 0, |
| origin: {x: 35, y: 0, z: 4}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(canvas0); |
| let bindGroupLayout9 = device0.createBindGroupLayout({ |
| label: '\ua606\u8933\u6970\u{1f96d}\u0e8a\ub4b6\u00ce\u53ea\u09ab\u314f', |
| entries: [ |
| { |
| binding: 96, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false }, |
| }, |
| { |
| binding: 127, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| sampler: { type: 'non-filtering' }, |
| }, |
| { |
| binding: 113, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| sampler: { type: 'non-filtering' }, |
| }, |
| ], |
| }); |
| let commandEncoder83 = device0.createCommandEncoder(); |
| let textureView73 = texture40.createView({dimension: '2d-array'}); |
| let computePassEncoder59 = commandEncoder83.beginComputePass({}); |
| let sampler46 = device0.createSampler({ |
| label: '\u0a44\u0b68\u0978\u{1f85b}\u{1fc00}\u4577\ufd66\u0101\u0510\u8841\ue268', |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 8.264, |
| lodMaxClamp: 45.59, |
| }); |
| try { |
| renderPassEncoder10.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder18.setVertexBuffer(7, buffer43, 836, 105); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer1, 148, new DataView(new ArrayBuffer(19732)), 183, 300); |
| } catch {} |
| let shaderModule7 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| requires packed_4x8_integer_dot_product; |
| |
| diagnostic(info, xyz); |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| @group(0) @binding(103) var st13: texture_storage_3d<rgba8unorm, write>; |
| |
| @group(0) @binding(176) var st14: texture_storage_3d<rgba16uint, write>; |
| |
| struct T0 { |
| @size(16) f0: array<atomic<u32>, 1>, |
| @size(4) f1: f16, |
| } |
| |
| struct VertexOutput6 { |
| @builtin(position) f27: vec4f, |
| @location(5) @interpolate(flat, center) f28: u32, |
| @location(11) @interpolate(flat, centroid) f29: vec4u, |
| @location(14) @interpolate(flat) f30: vec4i, |
| @location(4) @interpolate(flat, center) f31: vec4u, |
| } |
| |
| struct FragmentOutput6 { |
| @builtin(sample_mask) f0: u32, |
| @location(0) f1: vec4i, |
| } |
| |
| fn fn0(a0: array<mat3x3f, 1>) -> VertexOutput6 { |
| var out: VertexOutput6; |
| let vf137: f32 = inverseSqrt(f32(unconst_f32(0.02485))); |
| var vf138: i32 = insertBits(i32(unconst_i32(68)), i32(unconst_i32(259)), insertBits(vec3u(unconst_u32(151), unconst_u32(3), unconst_u32(371)), vec3u(cosh(vec3f(unconst_f32(0.1696), unconst_f32(0.2278), unconst_f32(0.08995)))), u32(unconst_u32(169)), u32(unconst_u32(263))).b, u32(unconst_u32(47))); |
| out.f30 -= vp6.f1; |
| var vf139: mat2x4f = transpose(mat4x2f(unconst_f32(0.1381), unconst_f32(0.3233), unconst_f32(0.00822), unconst_f32(0.07840), unconst_f32(0.1308), unconst_f32(0.3194), unconst_f32(0.3896), unconst_f32(0.3217))); |
| var vf140: f32 = a0[u32(unconst_u32(137))][u32(unconst_u32(174))][u32(unconst_u32(716))]; |
| let vf141: vec2h = radians(vec2h(unconst_f16(9485.9), unconst_f16(5009.0))); |
| out.f29 &= vec4u(bitcast<u32>(inverseSqrt(f32(unconst_f32(0.05802))))); |
| out.f27 = vec4f(f32(all(vec3<bool>(unconst_bool(false), unconst_bool(true), unconst_bool(true))))); |
| var vf142: f32 = min(f32(unpack4xU8(u32(unconst_u32(208))).b), f32(unconst_f32(0.01462))); |
| var vf143: vec3f = cosh(vec3f(unconst_f32(0.2942), unconst_f32(0.1615), unconst_f32(0.02495))); |
| let ptr66: ptr<private, u32> = &vp6.f0; |
| let vf144: u32 = pack4xU8(vec4u(unconst_u32(70), unconst_u32(222), unconst_u32(12), unconst_u32(381))); |
| let vf145: u32 = vf144; |
| out.f31 <<= vec4u(fract(vec2h(unconst_f16(6757.5), unconst_f16(1596.7))).yxxx); |
| out.f30 = vec4i(vp6.f1[countTrailingZeros(vec2u(unconst_u32(198), unconst_u32(162)))[0]]); |
| out.f27 += a0[0][unconst_i32(0)].xyyz; |
| var vf146: bool = all(vec3<bool>(unconst_bool(false), unconst_bool(false), unconst_bool(false))); |
| out.f31 |= vec4u(bitcast<u32>(vf143[u32(unconst_u32(717))])); |
| let vf147: mat3x3f = a0[(*ptr66)]; |
| let vf148: vec2h = vf141; |
| return out; |
| } |
| |
| var<workgroup> vw35: atomic<i32>; |
| |
| var<private> vp6: FragmentOutput6 = FragmentOutput6(u32(10), vec4i(331, 9, 237, 46)); |
| |
| @vertex @must_use |
| fn vertex6(@location(13) a0: vec4f, @location(8) a1: vec4u, @location(9) a2: vec2u) -> VertexOutput6 { |
| var out: VertexOutput6; |
| vp6 = FragmentOutput6(pack2x16unorm(acos(vec2f(unconst_f32(0.07900), unconst_f32(0.4495)))), bitcast<vec4i>(acos(vec2f(unconst_f32(0.07900), unconst_f32(0.4495))).xxyy)); |
| return out; |
| } |
| |
| @fragment |
| fn fragment7(@location(15) @interpolate(flat, center) a0: vec4i) -> FragmentOutput6 { |
| var out: FragmentOutput6; |
| var vf149: i32 = vp6.f1[u32(unconst_u32(58))]; |
| var vf150: f16 = ldexp(f16(unconst_f16(305.1)), i32(unconst_i32(51))); |
| var vf151: vec4i = a0; |
| var vf152: vec2f = radians(vec2f(unconst_f32(0.03723), unconst_f32(0.2875))); |
| vf152 = vec2f(f32(vf150)); |
| var vf153: f32 = vf152[u32(unconst_u32(127))]; |
| out.f1 = vec4i(vf152.ggrg); |
| out = FragmentOutput6(u32(vp6.f1.y), vp6.f1); |
| return out; |
| } |
| |
| @compute @workgroup_size(1, 1, 1) |
| fn compute6() { |
| var vf154 = fn0(array<mat3x3f, 1>(mat3x3f(unconst_f32(0.2777), unconst_f32(0.2941), unconst_f32(0.1098), unconst_f32(0.1346), unconst_f32(0.4172), unconst_f32(0.1203), unconst_f32(0.2888), unconst_f32(0.03180), unconst_f32(0.2428)))); |
| fn0(array<mat3x3f, 1>(mat3x3f(f32(countOneBits(u32(unconst_u32(300)))), f32(countOneBits(u32(unconst_u32(300)))), bitcast<f32>(countOneBits(u32(unconst_u32(300)))), f32(countOneBits(u32(unconst_u32(300)))), f32(countOneBits(u32(unconst_u32(300)))), bitcast<f32>(countOneBits(u32(unconst_u32(300)))), bitcast<f32>(countOneBits(u32(unconst_u32(300)))), bitcast<f32>(countOneBits(u32(unconst_u32(300)))), f32(countOneBits(u32(unconst_u32(300))))))); |
| textureStore(st13, vec3i(unconst_i32(246), unconst_i32(354), unconst_i32(240)), vec4f(vec4f(unconst_f32(0.02391), unconst_f32(0.3128), unconst_f32(0.2820), unconst_f32(0.2335)))); |
| var vf155: vec4f = step(vec4f(unconst_f32(0.02543), unconst_f32(0.1070), unconst_f32(0.06531), unconst_f32(0.1308)), vec4f(unconst_f32(0.4046), unconst_f32(0.1547), unconst_f32(-0.02784), unconst_f32(0.01303))); |
| vf155 += vec4f(f32(vp6.f0)); |
| workgroupBarrier(); |
| atomicAnd(&vw35, i32(unconst_i32(-385))); |
| let ptr67: ptr<private, vec4i> = &vp6.f1; |
| vf155 += vec4f(f32(vf154.f28)); |
| let ptr68: ptr<function, vec4i> = &vf154.f30; |
| atomicCompareExchangeWeak(&vw35, unconst_i32(8), unconst_i32(532)); |
| let ptr69: ptr<function, VertexOutput6> = &vf154; |
| let ptr70: ptr<private, u32> = &vp6.f0; |
| let ptr71: ptr<private, FragmentOutput6> = &vp6; |
| fn0(array<mat3x3f, 1>(mat3x3f(vec3f(reflect(vec4h(f16(pack2x16unorm(vec2f(unconst_f32(0.1608), unconst_f32(0.4268))))), vec4h(unconst_f16(1558.2), unconst_f16(23028.6), unconst_f16(280.9), unconst_f16(15346.4))).xyz), vec3f(reflect(vec4h(f16(pack2x16unorm(vec2f(unconst_f32(0.1608), unconst_f32(0.4268))))), vec4h(unconst_f16(1558.2), unconst_f16(23028.6), unconst_f16(280.9), unconst_f16(15346.4))).xxy), vec3f(reflect(vec4h(f16(pack2x16unorm(vec2f(unconst_f32(0.1608), unconst_f32(0.4268))))), vec4h(unconst_f16(1558.2), unconst_f16(23028.6), unconst_f16(280.9), unconst_f16(15346.4))).xzy)))); |
| vf154.f28 <<= u32(sign(f16(unconst_f16(9963.3)))); |
| fn0(array<mat3x3f, 1>(mat3x3f(bitcast<f32>(vp6.f1[u32(unconst_u32(30))]), f32(vp6.f1[u32(unconst_u32(30))]), bitcast<f32>(vp6.f1[u32(unconst_u32(30))]), f32(vp6.f1[u32(unconst_u32(30))]), f32(vp6.f1[u32(unconst_u32(30))]), f32(vp6.f1[u32(unconst_u32(30))]), f32(vp6.f1[u32(unconst_u32(30))]), bitcast<f32>(vp6.f1[u32(unconst_u32(30))]), f32(vp6.f1[u32(unconst_u32(30))])))); |
| vf154.f30 = vec4i((*ptr69).f31); |
| let vf156: vec4i = unpack4xI8(u32(unconst_u32(434))); |
| var vf157: i32 = (*ptr68)[u32(unconst_u32(1))]; |
| textureStore(st13, vec3i(unconst_i32(579), unconst_i32(85), unconst_i32(86)), vec4f(vec4f(vf154.f29))); |
| }`, |
| sourceMap: {}, |
| }); |
| let commandEncoder84 = device0.createCommandEncoder({}); |
| let texture78 = device0.createTexture({ |
| size: {width: 280, height: 291, depthOrArrayLayers: 1}, |
| mipLevelCount: 3, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let renderPassEncoder29 = commandEncoder84.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView6, |
| clearValue: { r: 718.4, g: 674.1, b: -683.7, a: -177.2, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet4, |
| }); |
| let buffer64 = device0.createBuffer({ |
| size: 7976, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| let commandEncoder85 = device0.createCommandEncoder({}); |
| let computePassEncoder60 = commandEncoder85.beginComputePass(); |
| try { |
| renderPassEncoder29.beginOcclusionQuery(5); |
| } catch {} |
| try { |
| renderPassEncoder29.endOcclusionQuery(); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| let sampler47 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 34.53, |
| maxAnisotropy: 5, |
| }); |
| try { |
| computePassEncoder59.setBindGroup(3, bindGroup7, new Uint32Array(1592), 501, 0); |
| } catch {} |
| try { |
| renderPassEncoder23.setVertexBuffer(7, buffer15, 1_116, 678); |
| } catch {} |
| let videoFrame8 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX', timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte170m', primaries: 'bt709', transfer: 'linear'} }); |
| let bindGroup45 = device0.createBindGroup({ |
| layout: bindGroupLayout4, |
| entries: [{binding: 511, resource: {buffer: buffer11, offset: 5120, size: 4700}}], |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder8); computePassEncoder8.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder25.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder21.setBlendConstant({ r: 122.8, g: -846.5, b: -431.1, a: 138.8, }); |
| } catch {} |
| try { |
| renderPassEncoder11.setIndexBuffer(buffer10, 'uint32', 280, 855); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture50, |
| mipLevel: 1, |
| origin: {x: 0, y: 0, z: 10}, |
| aspect: 'all', |
| }, new Uint8Array(20_082).fill(115), /* required buffer size: 20_082 */ |
| {offset: 362, bytesPerRow: 145, rowsPerImage: 68}, {width: 20, height: 0, depthOrArrayLayers: 3}); |
| } catch {} |
| await gc(); |
| let bindGroup46 = device0.createBindGroup({layout: bindGroupLayout8, entries: [{binding: 27, resource: {buffer: buffer15, offset: 256}}]}); |
| let commandEncoder86 = device0.createCommandEncoder({}); |
| let computePassEncoder61 = commandEncoder86.beginComputePass({label: '\u07e2\u0775\u1fa3\uc76a\u{1fefe}\u{1ff54}\u031e\u0433'}); |
| let sampler48 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 22.77, |
| lodMaxClamp: 75.98, |
| maxAnisotropy: 15, |
| }); |
| try { |
| computePassEncoder58.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder28.setPipeline(pipeline1); |
| } catch {} |
| document.body.append(img0); |
| let textureView74 = texture72.createView({}); |
| let externalTexture3 = device0.importExternalTexture({source: videoFrame6, colorSpace: 'srgb'}); |
| try { |
| computePassEncoder53.setBindGroup(0, bindGroup2); |
| } catch {} |
| try { |
| computePassEncoder36.setBindGroup(1, bindGroup29, new Uint32Array(57), 15, 0); |
| } catch {} |
| try { |
| computePassEncoder24.pushDebugGroup('\u0587'); |
| } catch {} |
| try { |
| computePassEncoder24.popDebugGroup(); |
| } catch {} |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55); }; |
| } catch {} |
| let textureView75 = texture37.createView({}); |
| try { |
| computePassEncoder53.setBindGroup(0, bindGroup8, new Uint32Array(3539), 60, 0); |
| } catch {} |
| try { |
| if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55); }; |
| } catch {} |
| let commandEncoder87 = device0.createCommandEncoder(); |
| let texture79 = device0.createTexture({ |
| size: [280, 291, 1], |
| mipLevelCount: 3, |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| viewFormats: [], |
| }); |
| let computePassEncoder62 = commandEncoder87.beginComputePass(); |
| let renderBundleEncoder4 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2uint'], stencilReadOnly: false}); |
| try { |
| computePassEncoder13.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder28.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder4.setBindGroup(1, bindGroup36, new Uint32Array(3725), 11, 0); |
| } catch {} |
| try { |
| renderBundleEncoder4.setIndexBuffer(buffer44, 'uint32', 3_584, 2_218); |
| } catch {} |
| try { |
| renderBundleEncoder4.setPipeline(pipeline1); |
| } catch {} |
| document.body.prepend(canvas0); |
| let buffer65 = device0.createBuffer({ |
| label: '\u08ff\ueecf\u8359\u0da2\u25df\u8b58', |
| size: 1220, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let querySet8 = device0.createQuerySet({ |
| label: '\u8a24\u8df3\u{1f8c3}\u{1f76d}\u8886\u{1f887}\u5788\u0d3c\uf34f\u{1fe8c}\uf75c', |
| type: 'occlusion', |
| count: 361, |
| }); |
| let renderBundle4 = renderBundleEncoder4.finish({label: '\ufcd5\ue461\ucacf\ue8ef\u8de6\u7ca3\u031e\u08b6\u0f13\u0ae1\uc4a8'}); |
| try { |
| renderPassEncoder7.setBindGroup(1, bindGroup26, new Uint32Array(3010), 1_316, 0); |
| } catch {} |
| try { |
| buffer50.unmap(); |
| } catch {} |
| try { |
| await buffer35.mapAsync(GPUMapMode.READ, 0, 4756); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer42, 52, new BigUint64Array(12897), 1799, 20); |
| } catch {} |
| let bindGroupLayout10 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 5, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| sampler: { type: 'comparison' }, |
| }, |
| ], |
| }); |
| let buffer66 = device0.createBuffer({size: 22324, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let commandEncoder88 = device0.createCommandEncoder({label: '\u{1fef0}\u0f14\u0cea\u6a26\u03f1\u37a4\uef88'}); |
| let renderPassEncoder30 = commandEncoder88.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView73, |
| clearValue: { r: -372.3, g: 795.7, b: -268.6, a: -809.1, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet6, |
| }); |
| try { |
| computePassEncoder35.setBindGroup(1, bindGroup24); |
| } catch {} |
| try { |
| computePassEncoder9.end(); |
| } catch {} |
| try { |
| computePassEncoder33.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder18.setBindGroup(1, bindGroup22); |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer27, 'uint16', 498, 115); |
| } catch {} |
| try { |
| renderPassEncoder30.setPipeline(pipeline1); |
| } catch {} |
| try { |
| commandEncoder14.copyBufferToTexture({ |
| /* bytesInLastRow: 28 widthInBlocks: 7 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 3084 */ |
| offset: 3084, |
| rowsPerImage: 482, |
| buffer: buffer48, |
| }, { |
| texture: texture32, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 7, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder89 = device0.createCommandEncoder({}); |
| let textureView76 = texture65.createView({label: '\u0c72\u10b0', baseArrayLayer: 5, arrayLayerCount: 4}); |
| let computePassEncoder63 = commandEncoder89.beginComputePass({}); |
| let externalTexture4 = device0.importExternalTexture({source: videoFrame0}); |
| try { |
| computePassEncoder32.setBindGroup(1, bindGroup22, new Uint32Array(318), 86, 0); |
| } catch {} |
| try { |
| computePassEncoder35.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder28.setVertexBuffer(5, buffer12, 0, 42); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'srgb', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer50, 328, new DataView(new ArrayBuffer(6355)), 45, 196); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 96, height: 1, depthOrArrayLayers: 131} |
| */ |
| { |
| source: imageData2, |
| origin: { x: 20, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture18, |
| mipLevel: 0, |
| origin: {x: 9, y: 0, z: 37}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| await gc(); |
| let bindGroup47 = device0.createBindGroup({ |
| layout: bindGroupLayout2, |
| entries: [ |
| {binding: 398, resource: textureView13}, |
| {binding: 421, resource: {buffer: buffer63, offset: 7168, size: 2492}}, |
| {binding: 94, resource: textureView61}, |
| {binding: 132, resource: textureView35}, |
| {binding: 999, resource: textureView36}, |
| {binding: 35, resource: textureView11}, |
| {binding: 243, resource: textureView13}, |
| {binding: 42, resource: externalTexture2}, |
| {binding: 567, resource: textureView72}, |
| ], |
| }); |
| let textureView77 = texture10.createView({dimension: '2d-array', aspect: 'depth-only', baseMipLevel: 0, mipLevelCount: 1, baseArrayLayer: 0}); |
| let computePassEncoder64 = commandEncoder14.beginComputePass({label: '\u{1ff98}\u0877\u98f4\ub06f'}); |
| try { |
| computePassEncoder46.setBindGroup(3, bindGroup42); |
| } catch {} |
| try { |
| computePassEncoder22.end(); |
| } catch {} |
| try { |
| renderPassEncoder19.setBindGroup(1, bindGroup47, new Uint32Array(827), 132, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer18, 420, new DataView(new ArrayBuffer(6399)), 915, 24); |
| } catch {} |
| let videoFrame9 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420', timestamp: 0, colorSpace: {fullRange: true, matrix: 'unspecified', primaries: 'smpte240m', transfer: 'linear'} }); |
| try { |
| externalTexture2.label = '\u0ef3\ua17d\u01ee\u0cf6\u0c63\u09bc\u1f8d'; |
| } catch {} |
| let texture80 = device0.createTexture({ |
| size: [64, 64, 22], |
| mipLevelCount: 6, |
| format: 'astc-8x8-unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let computePassEncoder65 = commandEncoder31.beginComputePass({}); |
| try { |
| computePassEncoder17.setBindGroup(3, bindGroup4); |
| } catch {} |
| try { |
| computePassEncoder57.setBindGroup(0, bindGroup11, new Uint32Array(543), 14, 0); |
| } catch {} |
| try { |
| computePassEncoder52.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder23.setVertexBuffer(6, buffer6, 0, 938); |
| } catch {} |
| let commandEncoder90 = device0.createCommandEncoder(); |
| let computePassEncoder66 = commandEncoder90.beginComputePass({}); |
| try { |
| renderPassEncoder21.setScissorRect(16, 0, 21, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(4, buffer6, 0, 59); |
| } catch {} |
| let buffer67 = device0.createBuffer({ |
| label: '\ua1ec\u0c4e\ud0d2\u0c45\u0919\u{1ff88}\u{1fb2f}\ucac1\u57e4', |
| size: 3305, |
| usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX, |
| }); |
| try { |
| computePassEncoder25.setBindGroup(1, bindGroup29); |
| } catch {} |
| try { |
| computePassEncoder8.end(); |
| } catch {} |
| try { |
| computePassEncoder61.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder10.setBindGroup(0, bindGroup42); |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(2, bindGroup12, new Uint32Array(763), 67, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer54, 'uint16', 7_170, 653); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture52, |
| mipLevel: 0, |
| origin: {x: 54, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(66).fill(75), /* required buffer size: 66 */ |
| {offset: 66, bytesPerRow: 85}, {width: 14, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let promise7 = device0.queue.onSubmittedWorkDone(); |
| let videoFrame10 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-cl', primaries: 'bt470bg', transfer: 'iec6196624'} }); |
| try { |
| adapter0.label = '\u0988\u01ea\u2430'; |
| } catch {} |
| let buffer68 = device0.createBuffer({ |
| size: 542, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM, |
| mappedAtCreation: false, |
| }); |
| let texture81 = device0.createTexture({ |
| label: '\u3e17\u1574\ud5a3\u{1fc8f}', |
| size: {width: 295, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 6, |
| dimension: '2d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView78 = texture23.createView({mipLevelCount: 1}); |
| let renderPassEncoder31 = commandEncoder13.beginRenderPass({colorAttachments: [{view: textureView73, loadOp: 'load', storeOp: 'store'}]}); |
| try { |
| computePassEncoder41.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer64, 'uint16', 7_534, 17); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(7, buffer24, 148, 331); |
| } catch {} |
| try { |
| await promise7; |
| } catch {} |
| document.body.append(canvas0); |
| let commandEncoder91 = device0.createCommandEncoder({label: '\u0afc\u{1fcfe}\u95a4\u0a35\u0ebd\u{1ff2a}\u{1f9dc}\ue456\u{1fb93}\u5616'}); |
| let computePassEncoder67 = commandEncoder91.beginComputePass({label: '\u00a6\u6ccb\ue906\u{1fbb7}\u0e91\uf006\u9ec8\u{1ff64}\uca46\u{1fe68}'}); |
| try { |
| computePassEncoder13.setBindGroup(1, bindGroup36); |
| } catch {} |
| try { |
| renderPassEncoder14.setBindGroup(2, bindGroup36); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 96, height: 1, depthOrArrayLayers: 131} |
| */ |
| { |
| source: videoFrame5, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture18, |
| mipLevel: 0, |
| origin: {x: 14, y: 0, z: 5}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let commandEncoder92 = device0.createCommandEncoder(); |
| try { |
| computePassEncoder39.setBindGroup(3, bindGroup19, new Uint32Array(241), 25, 0); |
| } catch {} |
| try { |
| computePassEncoder63.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder19.setBindGroup(1, bindGroup19); |
| } catch {} |
| try { |
| renderPassEncoder6.setBlendConstant({ r: 337.9, g: 869.7, b: 246.2, a: -371.4, }); |
| } catch {} |
| try { |
| renderPassEncoder11.setVertexBuffer(0, buffer67, 448, 176); |
| } catch {} |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| try { |
| buffer41.unmap(); |
| } catch {} |
| try { |
| commandEncoder92.copyBufferToBuffer(buffer41, 1916, buffer59, 72, 172); |
| } catch {} |
| try { |
| commandEncoder92.copyTextureToBuffer({ |
| texture: texture47, |
| mipLevel: 1, |
| origin: {x: 12, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 288 widthInBlocks: 72 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1604 */ |
| offset: 1604, |
| bytesPerRow: 19968, |
| buffer: buffer51, |
| }, {width: 72, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| globalThis.someLabel = externalTexture2.label; |
| } catch {} |
| let shaderModule8 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| enable f16; |
| |
| requires packed_4x8_integer_dot_product; |
| |
| requires pointer_composite_access; |
| |
| diagnostic(info, xyz); |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| @group(0) @binding(176) var st15: texture_storage_3d<rgba16uint, write>; |
| |
| struct T0 { |
| @align(16) @size(320) f0: array<mat2x4h>, |
| } |
| |
| struct VertexOutput7 { |
| @location(3) f32: vec4h, |
| @builtin(position) f33: vec4f, |
| } |
| |
| var<workgroup> vw36: array<vec2i, 1>; |
| |
| var<private> vp7 = frexp(vec3h(7260.3, -33957.7, 935.2)); |
| |
| var<private> vp8: VertexOutput7 = VertexOutput7(); |
| |
| @vertex |
| fn vertex7(@location(8) a0: vec2u, @location(15) a1: u32) -> @builtin(position) vec4f { |
| var out: vec4f; |
| let vf158: vec2h = sin(vec2h(unconst_f16(29781.0), unconst_f16(3815.5))); |
| var vf159: f32 = vp8.f33[u32(unconst_u32(78))]; |
| vp7 = frexp(sin(vec2h(unconst_f16(563.7), unconst_f16(7201.4))).xyx); |
| let vf160: f16 = vf158[u32(unconst_u32(121))]; |
| vp7 = frexp(vp8.f32.wyz); |
| var vf161: u32 = a0[u32(unconst_u32(152))]; |
| vp8.f33 *= vec4f(f32(vf158[u32(unconst_u32(96))])); |
| var vf162: vec2h = vf158; |
| vp8 = VertexOutput7(vp7.fract.yxxx, vec4f(vp7.fract.yzyx)); |
| let vf163: vec2f = radians(vec2f(unconst_f32(0.07121), unconst_f32(0.03270))); |
| var vf164: u32 = a1; |
| var vf165: vec2h = abs(vp8.f32.ba); |
| var vf166: f16 = vf165[bitcast<u32>(sin(vec2h(unconst_f16(4539.9), unconst_f16(2179.8))))]; |
| return out; |
| } |
| |
| @vertex @must_use |
| fn vertex8(@location(15) a0: i32, @location(12) @interpolate(flat) a1: vec2f, @location(4) a2: vec4f) -> VertexOutput7 { |
| var out: VertexOutput7; |
| var vf167: vec4i = unpack4xI8(u32(unconst_u32(224))); |
| out.f32 = vec4h(vp8.f33); |
| out.f32 = cross(vec3h(unconst_f16(4331.4), unconst_f16(2315.1), unconst_f16(620.6)), vec3h(unconst_f16(8764.1), unconst_f16(-14591.0), unconst_f16(6691.1))).zxxx; |
| let vf168: f16 = length(vec4h(unconst_f16(2893.6), unconst_f16(9937.7), unconst_f16(11087.1), unconst_f16(6506.4))); |
| vf167 = vec4i(i32(a1[bitcast<u32>(reflect(vec3f(unconst_f32(0.06941), unconst_f32(0.1859), unconst_f32(0.1929)), vec3f(unconst_f32(0.2299), unconst_f32(0.06723), unconst_f32(0.09090)))[2])])); |
| var vf169: vec4f = a2; |
| var vf170: vec4f = fma(vec4f(unconst_f32(0.04527), unconst_f32(0.01571), unconst_f32(0.05583), unconst_f32(0.1202)), vec4f(unconst_f32(-0.09779), unconst_f32(0.09675), unconst_f32(0.1079), unconst_f32(0.1898)), vec4f(unconst_f32(0.4194), unconst_f32(0.1206), unconst_f32(0.3295), unconst_f32(0.1862))); |
| var vf171: f32 = vp8.f33[u32(vp8.f32[u32(unconst_u32(87))])]; |
| let vf172: vec3f = sign(vec3f(unconst_f32(0.3830), unconst_f32(0.04410), unconst_f32(0.03823))); |
| let vf173: vec2u = firstLeadingBit(vec2u(unconst_u32(345), unconst_u32(26))); |
| let ptr72: ptr<private, vec4f> = &vp8.f33; |
| return out; |
| } |
| |
| @compute @workgroup_size(2, 1, 1) |
| fn compute7() { |
| vw36[u32(unconst_u32(12))] = vec2i(sin(vec2h(unconst_f16(8578.9), unconst_f16(11784.4)))); |
| var vf174: vec2f = acos(vec2f(unconst_f32(0.6671), unconst_f32(0.1985))); |
| vw36[0] = vp7.exp.rg; |
| vp8.f32 = atan(vec3h(unconst_f16(2559.4), unconst_f16(3846.3), unconst_f16(7774.9))).rggr; |
| }`, |
| sourceMap: {}, |
| }); |
| let commandEncoder93 = device0.createCommandEncoder({}); |
| let textureView79 = texture26.createView({dimension: '2d-array', arrayLayerCount: 1}); |
| try { |
| computePassEncoder20.setBindGroup(1, bindGroup41, new Uint32Array(4368), 803, 0); |
| } catch {} |
| try { |
| computePassEncoder49.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder13.setViewport(91.68703716164704, 0.8203603926484702, 2.12503740968694, 0.09664570661214122, 0.3075201304721641, 0.5558685057961178); |
| } catch {} |
| try { |
| renderPassEncoder30.setIndexBuffer(buffer28, 'uint32', 1_600, 536); |
| } catch {} |
| try { |
| renderPassEncoder14.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder10.setVertexBuffer(0, buffer2, 0); |
| } catch {} |
| try { |
| buffer44.unmap(); |
| } catch {} |
| let renderPassEncoder32 = commandEncoder92.beginRenderPass({ |
| label: '\u{1ffdb}\u0506', |
| colorAttachments: [{ |
| view: textureView5, |
| clearValue: { r: 806.6, g: 281.2, b: -307.4, a: -600.2, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| maxDrawCount: 273241393, |
| }); |
| try { |
| computePassEncoder40.setBindGroup(2, bindGroup18, new Uint32Array(993), 73, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder53); computePassEncoder53.dispatchWorkgroups(2, 2); }; |
| } catch {} |
| let bindGroup48 = device0.createBindGroup({ |
| label: '\udbce\u{1ffae}\u{1f965}\u0451\u090d\u6262\u7339\u2cbd', |
| layout: bindGroupLayout3, |
| entries: [ |
| {binding: 58, resource: {buffer: buffer10, offset: 2560, size: 6500}}, |
| {binding: 225, resource: textureView13}, |
| ], |
| }); |
| let commandEncoder94 = device0.createCommandEncoder({}); |
| let sampler49 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 54.03, |
| lodMaxClamp: 70.90, |
| maxAnisotropy: 19, |
| }); |
| try { |
| computePassEncoder12.end(); |
| } catch {} |
| try { |
| renderPassEncoder26.setPipeline(pipeline1); |
| } catch {} |
| try { |
| buffer56.unmap(); |
| } catch {} |
| try { |
| commandEncoder18.copyBufferToBuffer(buffer34, 1712, buffer55, 300, 2888); |
| } catch {} |
| try { |
| commandEncoder18.copyBufferToTexture({ |
| /* bytesInLastRow: 472 widthInBlocks: 118 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 224 */ |
| offset: 224, |
| bytesPerRow: 8704, |
| buffer: buffer49, |
| }, { |
| texture: texture55, |
| mipLevel: 0, |
| origin: {x: 99, y: 101, z: 0}, |
| aspect: 'all', |
| }, {width: 118, height: 97, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder94.copyTextureToBuffer({ |
| texture: texture2, |
| mipLevel: 0, |
| origin: {x: 163, y: 36, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 40 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 1624 */ |
| offset: 1624, |
| bytesPerRow: 13568, |
| rowsPerImage: 736, |
| buffer: buffer23, |
| }, {width: 5, height: 298, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| textureView42.label = '\u08cd\u7b5f\u0c14\u2399\u{1f902}\u255c\u06b3\u0cfe'; |
| } catch {} |
| let textureView80 = texture0.createView({label: '\ua280\u3f04', dimension: '2d-array', mipLevelCount: 1, arrayLayerCount: 1}); |
| let computePassEncoder68 = commandEncoder94.beginComputePass({}); |
| let sampler50 = device0.createSampler({ |
| label: '\u160c\u{1f81f}\u002e\u03df\u1768\uf1ef\u6da7\u9ec2\u4e6b\u{1f925}\u0499', |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'nearest', |
| lodMinClamp: 90.03, |
| lodMaxClamp: 97.32, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder53); computePassEncoder53.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder3); computePassEncoder3.dispatchWorkgroupsIndirect(buffer24, 136); }; |
| } catch {} |
| try { |
| renderPassEncoder17.setIndexBuffer(buffer54, 'uint16', 3_294, 769); |
| } catch {} |
| document.body.append(canvas0); |
| let bindGroup49 = device0.createBindGroup({layout: bindGroupLayout8, entries: [{binding: 27, resource: {buffer: buffer58, offset: 0}}]}); |
| let texture82 = device0.createTexture({ |
| size: {width: 440, height: 40, depthOrArrayLayers: 24}, |
| mipLevelCount: 2, |
| dimension: '2d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_SRC, |
| }); |
| let textureView81 = texture41.createView({ |
| label: '\u740d\u019b\u{1f99c}\u{1febf}\u0fc8\u6bd2\u{1f85e}\u56b0\u054f\u37d5\u04b5', |
| baseArrayLayer: 0, |
| arrayLayerCount: 1, |
| }); |
| try { |
| renderPassEncoder0.setVertexBuffer(6, buffer28, 1_268, 1_719); |
| } catch {} |
| try { |
| commandEncoder93.copyBufferToTexture({ |
| /* bytesInLastRow: 176 widthInBlocks: 44 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 644 */ |
| offset: 644, |
| bytesPerRow: 2304, |
| buffer: buffer28, |
| }, { |
| texture: texture79, |
| mipLevel: 1, |
| origin: {x: 3, y: 1, z: 0}, |
| aspect: 'all', |
| }, {width: 44, height: 22, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder18.copyTextureToTexture({ |
| texture: texture8, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture81, |
| mipLevel: 3, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup50 = device0.createBindGroup({ |
| layout: bindGroupLayout4, |
| entries: [{binding: 511, resource: {buffer: buffer50, offset: 256, size: 284}}], |
| }); |
| let computePassEncoder69 = commandEncoder93.beginComputePass(); |
| try { |
| computePassEncoder3.setBindGroup(3, bindGroup36); |
| } catch {} |
| try { |
| renderPassEncoder27.setStencilReference(804); |
| } catch {} |
| try { |
| renderPassEncoder28.setViewport(45.755126203254044, 55.96459691185869, 12.096748006965782, 0.022405052872582144, 0.3546890453591003, 0.45275867612049836); |
| } catch {} |
| let pipelineLayout4 = device0.createPipelineLayout({bindGroupLayouts: []}); |
| let buffer69 = device0.createBuffer({size: 12469, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let texture83 = device0.createTexture({size: [64, 64, 22], dimension: '2d', format: 'rgb10a2uint', usage: GPUTextureUsage.COPY_DST}); |
| let renderPassEncoder33 = commandEncoder18.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView32, |
| depthSlice: 18, |
| clearValue: { r: -53.42, g: 642.9, b: 916.0, a: 941.1, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| maxDrawCount: 342672468, |
| }); |
| try { |
| computePassEncoder56.setBindGroup(2, bindGroup9, new Uint32Array(145), 6, 0); |
| } catch {} |
| let textureView82 = texture67.createView({dimension: '3d', arrayLayerCount: 1}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder3); computePassEncoder3.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder24.setPipeline(pipeline0); |
| } catch {} |
| try { |
| computePassEncoder54.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(3, bindGroup22); |
| } catch {} |
| try { |
| renderPassEncoder12.setVertexBuffer(0, buffer67, 20); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let bindGroup51 = device0.createBindGroup({ |
| layout: bindGroupLayout9, |
| entries: [ |
| {binding: 96, resource: {buffer: buffer63, offset: 2560, size: 3324}}, |
| {binding: 127, resource: sampler15}, |
| {binding: 113, resource: sampler42}, |
| ], |
| }); |
| let texture84 = device0.createTexture({ |
| size: [220, 20, 1], |
| mipLevelCount: 2, |
| dimension: '2d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| viewFormats: [], |
| }); |
| let textureView83 = texture20.createView({label: '\ue38d\u3272\u151e\ufe4d\u04db', mipLevelCount: 1, baseArrayLayer: 3, arrayLayerCount: 3}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder53); computePassEncoder53.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder57.setPipeline(pipeline0); |
| } catch {} |
| let buffer70 = device0.createBuffer({size: 10629, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM}); |
| let commandEncoder95 = device0.createCommandEncoder({}); |
| let texture85 = device0.createTexture({ |
| size: {width: 192, height: 1, depthOrArrayLayers: 262}, |
| dimension: '3d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| let renderPassEncoder34 = commandEncoder95.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView32, |
| depthSlice: 149, |
| clearValue: { r: 710.1, g: 116.4, b: -664.4, a: -515.8, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| computePassEncoder34.setBindGroup(2, bindGroup43); |
| } catch {} |
| try { |
| computePassEncoder65.setBindGroup(1, bindGroup23, new Uint32Array(77), 7, 0); |
| } catch {} |
| try { |
| computePassEncoder47.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder14.setViewport(58.58347340095297, 66.7628049618577, 9.797146580905313, 3.533177817285342, 0.6618308771676491, 0.7825195218023538); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 96, height: 1, depthOrArrayLayers: 131} |
| */ |
| { |
| source: imageData4, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture18, |
| mipLevel: 0, |
| origin: {x: 5, y: 0, z: 2}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| await gc(); |
| let buffer71 = device0.createBuffer({size: 23759, usage: GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM}); |
| let texture86 = device0.createTexture({ |
| size: {width: 280, height: 291, depthOrArrayLayers: 1}, |
| mipLevelCount: 6, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| computePassEncoder15.setBindGroup(0, bindGroup3, new Uint32Array(1103), 13, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.setViewport(32.81439388308239, 0.2869181006256122, 1.6166643841375266, 0.24513148008411323, 0.4994465387658973, 0.6316555079539039); |
| } catch {} |
| let bindGroup52 = device0.createBindGroup({ |
| layout: bindGroupLayout3, |
| entries: [ |
| {binding: 58, resource: {buffer: buffer57, offset: 0, size: 3444}}, |
| {binding: 225, resource: textureView13}, |
| ], |
| }); |
| let commandEncoder96 = device0.createCommandEncoder({}); |
| let computePassEncoder70 = commandEncoder96.beginComputePass({}); |
| try { |
| computePassEncoder16.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder31.setBindGroup(2, bindGroup52, new Uint32Array(411), 113, 0); |
| } catch {} |
| try { |
| renderPassEncoder22.setIndexBuffer(buffer42, 'uint32', 688, 217); |
| } catch {} |
| let textureView84 = texture37.createView({dimension: '1d'}); |
| try { |
| computePassEncoder68.setBindGroup(2, bindGroup8); |
| } catch {} |
| try { |
| computePassEncoder3.end(); |
| } catch {} |
| try { |
| renderPassEncoder13.setBindGroup(0, bindGroup52, new Uint32Array(577), 36, 0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture73, |
| mipLevel: 1, |
| origin: {x: 12, y: 0, z: 2}, |
| aspect: 'all', |
| }, new Uint8Array(399).fill(209), /* required buffer size: 399 */ |
| {offset: 49, bytesPerRow: 35, rowsPerImage: 5}, {width: 3, height: 0, depthOrArrayLayers: 3}); |
| } catch {} |
| let commandEncoder97 = device0.createCommandEncoder(); |
| let textureView85 = texture3.createView({}); |
| let computePassEncoder71 = commandEncoder97.beginComputePass({}); |
| let renderPassEncoder35 = commandEncoder5.beginRenderPass({ |
| colorAttachments: [{view: textureView16, loadOp: 'load', storeOp: 'discard'}], |
| occlusionQuerySet: querySet1, |
| }); |
| try { |
| computePassEncoder6.setBindGroup(2, bindGroup16, new Uint32Array(197), 27, 0); |
| } catch {} |
| try { |
| computePassEncoder58.setPipeline(pipeline0); |
| } catch {} |
| try { |
| computePassEncoder6.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(1, bindGroup6, []); |
| } catch {} |
| try { |
| buffer18.unmap(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 96, height: 1, depthOrArrayLayers: 131} |
| */ |
| { |
| source: videoFrame10, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture18, |
| mipLevel: 0, |
| origin: {x: 36, y: 0, z: 13}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(img0); |
| let buffer72 = device0.createBuffer({ |
| label: '\u38a0\ud95d\uc3bf\u7391\uda0f\u84e6\u2b7e', |
| size: 19840, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let textureView86 = texture79.createView({label: '\ud69c\u1be3\u{1f896}\u070c\u049a\u9a90\u7d56\u3b33', dimension: '2d-array', mipLevelCount: 1}); |
| try { |
| computePassEncoder53.dispatchWorkgroupsIndirect(buffer8, 40); |
| } catch {} |
| try { |
| renderPassEncoder4.executeBundles([renderBundle3, renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder0.setStencilReference(794); |
| } catch {} |
| try { |
| renderPassEncoder31.setIndexBuffer(buffer26, 'uint32', 1_904, 249); |
| } catch {} |
| try { |
| renderPassEncoder26.setPipeline(pipeline1); |
| } catch {} |
| let bindGroup53 = device0.createBindGroup({ |
| layout: bindGroupLayout7, |
| entries: [{binding: 54, resource: {buffer: buffer27, offset: 0}}, {binding: 53, resource: externalTexture3}], |
| }); |
| let sampler51 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 3.571, |
| lodMaxClamp: 98.87, |
| compare: 'always', |
| maxAnisotropy: 20, |
| }); |
| try { |
| computePassEncoder69.setBindGroup(3, bindGroup42, []); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder53); computePassEncoder53.dispatchWorkgroupsIndirect(buffer22, 212); }; |
| } catch {} |
| try { |
| renderPassEncoder14.setIndexBuffer(buffer51, 'uint16', 62, 118); |
| } catch {} |
| try { |
| renderPassEncoder10.setVertexBuffer(5, buffer12); |
| } catch {} |
| let textureView87 = texture18.createView({baseMipLevel: 0}); |
| try { |
| computePassEncoder47.setBindGroup(2, bindGroup22, []); |
| } catch {} |
| try { |
| computePassEncoder64.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder23.setBindGroup(3, bindGroup53, new Uint32Array(612), 350, 0); |
| } catch {} |
| let imageData10 = new ImageData(20, 20); |
| let buffer73 = device0.createBuffer({ |
| label: '\u8abc\ucf9d\u008b\u03f7\u5cdb\u{1fd91}\u{1f8a8}\u{1ff7b}\u6a99\u0f39\u34bc', |
| size: 31166, |
| usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM, |
| }); |
| let commandEncoder98 = device0.createCommandEncoder({label: '\u4844\ufc7c\u0a6f\ufffe\u{1f6a1}\u04ee\u5e91\u{1f681}'}); |
| let texture87 = device0.createTexture({ |
| size: [220, 20, 156], |
| dimension: '3d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let sampler52 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 98.97, |
| maxAnisotropy: 14, |
| }); |
| try { |
| computePassEncoder25.setBindGroup(3, bindGroup41); |
| } catch {} |
| try { |
| renderPassEncoder35.beginOcclusionQuery(52); |
| } catch {} |
| try { |
| renderPassEncoder3.executeBundles([renderBundle3]); |
| } catch {} |
| try { |
| renderPassEncoder33.setIndexBuffer(buffer70, 'uint32', 368, 633); |
| } catch {} |
| try { |
| buffer42.unmap(); |
| } catch {} |
| let shaderModule9 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| requires unrestricted_pointer_parameters; |
| |
| diagnostic(info, xyz); |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| @group(0) @binding(103) var st16: texture_storage_3d<rgba8unorm, write>; |
| |
| @group(0) @binding(176) var st17: texture_storage_3d<rgba16uint, write>; |
| |
| struct T0 { |
| @align(16) @size(16) f0: array<u32>, |
| } |
| |
| struct T1 { |
| @align(16) @size(896) f0: array<mat4x3h, 4>, |
| @align(64) @size(128) f1: array<atomic<u32>, 1>, |
| @align(64) @size(1152) f2: atomic<u32>, |
| @align(8) @size(2816) f3: array<array<atomic<u32>, 80>>, |
| } |
| |
| struct T2 { |
| @size(224) f0: array<u32>, |
| } |
| |
| struct S9 { |
| @location(4) f0: f16, |
| @location(14) f1: vec4i, |
| } |
| |
| struct VertexOutput8 { |
| @builtin(position) f34: vec4f, |
| } |
| |
| fn fn0() { |
| vp10 = bitcast<u32>(pow(f32(unconst_f32(0.05921)), f32(unconst_f32(0.3468)))); |
| vp9 = S9(vec4h(vp9.f1).y, vp9.f1); |
| vp9.f1 *= vec4i(bitcast<i32>(pow(bitcast<f32>(fma(vec2h(unconst_f16(1579.3), unconst_f16(-5721.1)), vec2h(unconst_f16(1847.8), unconst_f16(-5518.7)), vec2h(unconst_f16(5813.2), unconst_f16(1960.2)))), f32(unconst_f32(0.5570))))); |
| vp9 = S9(f16(unpack4x8snorm(u32(unconst_u32(162)))[0]), vec4i(unpack4x8snorm(u32(unconst_u32(162))))); |
| let ptr73: ptr<private, vec4f> = &vp11[u32(unconst_u32(29))].f34; |
| let vf175: f32 = pow(f32(unconst_f32(0.5171)), f32(unconst_f32(0.08916))); |
| let ptr74: ptr<private, VertexOutput8> = &vp11[9]; |
| var vf176: vec3h = cross(vec3h(unconst_f16(440.8), unconst_f16(2476.4), unconst_f16(19689.3)), vec3h(unconst_f16(4410.3), unconst_f16(29780.3), unconst_f16(32387.0))); |
| vp11[u32(unconst_u32(9))].f34 -= saturate(vec3f(unconst_f32(0.00495), unconst_f32(0.5651), unconst_f32(0.05611))).zxzx; |
| let ptr75: ptr<private, u32> = &vp10; |
| } |
| |
| fn fn1(a0: array<i32, 4>) { |
| let vf177: i32 = a0[u32(unconst_u32(106))]; |
| let ptr76: ptr<private, vec4f> = &vp11[u32(unconst_u32(250))].f34; |
| vp10 |= bitcast<u32>(vp9.f1[3]); |
| let vf178: vec4f = faceForward(vec4f(unconst_f32(0.07808), unconst_f32(0.07483), unconst_f32(0.2867), unconst_f32(0.2702)), vec4f(unconst_f32(0.1020), unconst_f32(0.04246), unconst_f32(0.1351), unconst_f32(0.2677)), vec4f(unconst_f32(0.1322), unconst_f32(0.00220), unconst_f32(0.01970), unconst_f32(-0.3912))); |
| let ptr77: ptr<private, VertexOutput8> = &vp11[u32(unconst_u32(173))]; |
| let vf179: vec3h = smoothstep(vec3h(unconst_f16(-539.0), unconst_f16(14870.0), unconst_f16(1558.9)), vec3h(unconst_f16(15772.6), unconst_f16(5182.2), unconst_f16(10763.4)), vec3h(unconst_f16(8476.0), unconst_f16(14536.8), unconst_f16(48278.0))); |
| } |
| |
| fn fn2() -> array<VertexOutput8, 1> { |
| var out: array<VertexOutput8, 1>; |
| fn1(array<i32, 4>(bitcast<i32>(vp11[u32(unconst_u32(32))].f34.y), vec4i(vp11[u32(unconst_u32(32))].f34)[2], bitcast<vec4i>(vp11[u32(unconst_u32(32))].f34)[0], bitcast<vec4i>(vp11[u32(unconst_u32(32))].f34)[3])); |
| vp9.f1 += bitcast<vec4i>(unpack2x16snorm(u32(unconst_u32(2))).yxyy); |
| vp9.f1 = vec4i(vp11[u32(unconst_u32(195))].f34); |
| var vf180: f32 = ceil(f32(unconst_f32(0.1058))); |
| fn1(array<i32, 4>(i32(vp9.f0), i32(vp9.f0), i32(vp9.f0), i32(vp9.f0))); |
| let vf181: vec3f = quantizeToF16(vec3f(unconst_f32(0.02993), unconst_f32(0.1157), unconst_f32(0.2194))); |
| var vf182: vec2f = unpack2x16unorm(u32(unconst_u32(567))); |
| fn1(array<i32, 4>(bitcast<i32>(vf181[u32(unconst_u32(136))]), bitcast<i32>(vf181[u32(unconst_u32(136))]), bitcast<i32>(vf181[u32(unconst_u32(136))]), i32(vf181[u32(unconst_u32(136))]))); |
| fn1(array<i32, 4>(vec2i(unpack2x16unorm(u32(unconst_u32(54))))[1], bitcast<vec2i>(unpack2x16unorm(u32(unconst_u32(54)))).y, i32(unpack2x16unorm(u32(unconst_u32(54))).r), i32(unpack2x16unorm(u32(unconst_u32(54))).x))); |
| vp10 *= bitcast<u32>(vp11[u32(unconst_u32(519))].f34.b); |
| vp10 = bitcast<u32>(vp11[u32(unconst_u32(355))].f34[u32(unconst_u32(42))]); |
| return out; |
| } |
| |
| var<workgroup> vw37: array<atomic<i32>, 21>; |
| |
| var<workgroup> vw38: vec4<bool>; |
| |
| var<workgroup> vw39: S9; |
| |
| var<workgroup> vw40: VertexOutput8; |
| |
| var<workgroup> vw41: S9; |
| |
| var<workgroup> vw42: array<VertexOutput8, 1>; |
| |
| var<workgroup> vw43: atomic<u32>; |
| |
| var<private> vp9: S9 = S9(); |
| |
| var<private> vp10: u32 = u32(137); |
| |
| var<private> vp11: array<VertexOutput8, 10> = array(VertexOutput8(vec4f(0.2049, 0.02493, 0.00388, 0.1816)), VertexOutput8(vec4f(0.06921, 0.5519, 0.1122, 0.4268)), VertexOutput8(), VertexOutput8(vec4f(0.1428, 0.4054, 0.1027, -0.03782)), VertexOutput8(), VertexOutput8(), VertexOutput8(vec4f(0.00109, 0.06991, 0.1564, 0.4761)), VertexOutput8(), VertexOutput8(), VertexOutput8()); |
| |
| @vertex |
| fn vertex9(@location(11) a0: i32, @location(0) @interpolate(flat) a1: f32, a2: S9, @location(7) @interpolate(flat, sample) a3: u32, @builtin(vertex_index) a4: u32, @location(10) a5: vec2h, @location(8) a6: i32, @location(6) a7: vec4f, @location(9) @interpolate(flat, center) a8: u32, @location(2) a9: vec2i, @builtin(instance_index) a10: u32, @location(13) @interpolate(flat, centroid) a11: i32) -> VertexOutput8 { |
| var out: VertexOutput8; |
| fn1(array<i32, 4>(i32(unconst_i32(89)), i32(unconst_i32(30)), i32(unconst_i32(33)), i32(unconst_i32(175)))); |
| fn1(array<i32, 4>(i32(unconst_i32(4)), i32(unconst_i32(17)), i32(unconst_i32(97)), i32(unconst_i32(229)))); |
| out.f34 = vec4f(vp11[9].f34[u32(degrees(f32(unconst_f32(0.08271))))]); |
| vp11[u32(unconst_u32(232))].f34 -= bitcast<vec4f>(vp9.f1); |
| vp9.f0 += f16(vp11[9].f34.w); |
| let ptr78: ptr<private, VertexOutput8> = &vp11[9]; |
| fn2(); |
| vp9 = S9(a2.f0, vec4i(i32(a2.f0))); |
| vp11[u32(unconst_u32(55))] = VertexOutput8(vec4f(saturate(vec2h(unconst_f16(866.2), unconst_f16(2838.1))).grgr)); |
| fn1(array<i32, 4>(i32(unconst_i32(264)), i32(unconst_i32(4)), i32(unconst_i32(134)), i32(unconst_i32(80)))); |
| out.f34 = a7; |
| fn1(array<i32, 4>(vec4i(vp11[9].f34)[3], i32(vp11[9].f34[3]), vec4i(vp11[9].f34).w, i32(vp11[9].f34[1]))); |
| var vf183 = fn2(); |
| vf183[u32(unconst_u32(49))] = vf183[0]; |
| let ptr79: ptr<function, VertexOutput8> = &vf183[0]; |
| fn1(array<i32, 4>(bitcast<i32>(unpack2x16snorm(u32(unconst_u32(9))).y), bitcast<vec2i>(unpack2x16snorm(u32(unconst_u32(9))))[0], bitcast<vec2i>(unpack2x16snorm(u32(unconst_u32(9)))).r, bitcast<i32>(unpack2x16snorm(u32(unconst_u32(9))).y))); |
| var vf184: vec2h = a5; |
| out.f34 += (*ptr78).f34; |
| vf183[u32(unconst_u32(294))].f34 = (*ptr79).f34; |
| vp11[u32(unconst_u32(25))].f34 = vec4f(f32(a5[u32(unconst_u32(50))])); |
| out.f34 = vp11[9].f34; |
| fn1(array<i32, 4>(bitcast<i32>(pack4xU8Clamp(vec4u(unconst_u32(71), unconst_u32(478), unconst_u32(228), unconst_u32(206)))), i32(pack4xU8Clamp(vec4u(unconst_u32(71), unconst_u32(478), unconst_u32(228), unconst_u32(206)))), i32(pack4xU8Clamp(vec4u(unconst_u32(71), unconst_u32(478), unconst_u32(228), unconst_u32(206)))), i32(pack4xU8Clamp(vec4u(unconst_u32(71), unconst_u32(478), unconst_u32(228), unconst_u32(206)))))); |
| fn1(array<i32, 4>(i32((*ptr78).f34[u32(unconst_u32(38))]), i32((*ptr78).f34[u32(unconst_u32(38))]), bitcast<i32>((*ptr78).f34[u32(unconst_u32(38))]), i32((*ptr78).f34[u32(unconst_u32(38))]))); |
| let ptr80: ptr<private, vec4i> = &vp9.f1; |
| return out; |
| } |
| |
| @compute @workgroup_size(1, 2, 1) |
| fn compute8() { |
| fn0(); |
| vw38 = vec4<bool>(bool(atomicLoad(&(*&vw37)[20]))); |
| vw41.f0 += f16(atomicLoad(&vw37[pack4x8snorm(vw42[u32(vw39.f1[u32(unconst_u32(119))])].f34)])); |
| vp10 = u32(vw42[0].f34[3]); |
| }`, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| let commandBuffer5 = commandEncoder98.finish(); |
| try { |
| computePassEncoder70.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder35.endOcclusionQuery(); |
| } catch {} |
| let texture88 = device0.createTexture({ |
| size: [140, 145, 1], |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| buffer33.unmap(); |
| } catch {} |
| let videoFrame11 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX', timestamp: 0, colorSpace: {fullRange: false, matrix: 'unspecified', primaries: 'bt2020', transfer: 'bt2020_12bit'} }); |
| try { |
| computePassEncoder66.setBindGroup(1, bindGroup1, new Uint32Array(34), 1, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.executeBundles([renderBundle3, renderBundle3, renderBundle3]); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| document.body.prepend(canvas0); |
| let texture89 = device0.createTexture({ |
| size: {width: 192, height: 1, depthOrArrayLayers: 31}, |
| mipLevelCount: 2, |
| sampleCount: 1, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder7.setBindGroup(3, bindGroup29); |
| } catch {} |
| try { |
| renderPassEncoder2.executeBundles([renderBundle3, renderBundle3, renderBundle0]); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 96, height: 1, depthOrArrayLayers: 131} |
| */ |
| { |
| source: img1, |
| origin: { x: 11, y: 10 }, |
| flipY: true, |
| }, { |
| texture: texture18, |
| mipLevel: 0, |
| origin: {x: 9, y: 0, z: 19}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture90 = device0.createTexture({ |
| size: [560, 582, 1], |
| mipLevelCount: 2, |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView88 = texture51.createView({label: '\u1fa5\u003c\u4d83\u{1fa14}\u6d46', dimension: '1d'}); |
| try { |
| computePassEncoder46.setBindGroup(0, bindGroup2); |
| } catch {} |
| try { |
| computePassEncoder58.setPipeline(pipeline0); |
| } catch {} |
| let bindGroup54 = device0.createBindGroup({ |
| label: '\u29c7\u{1f8ea}\uac06\u440d', |
| layout: bindGroupLayout0, |
| entries: [{binding: 176, resource: textureView8}, {binding: 103, resource: textureView3}], |
| }); |
| let commandEncoder99 = device0.createCommandEncoder({label: '\udf3e\u04e4\u535a\u4e5e\udf14\u9e9f'}); |
| let renderPassEncoder36 = commandEncoder99.beginRenderPass({ |
| label: '\u091d\u047d\u03b9\u04b5', |
| colorAttachments: [{view: textureView38, loadOp: 'load', storeOp: 'discard'}], |
| maxDrawCount: 257680737, |
| }); |
| let sampler53 = device0.createSampler({ |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 45.89, |
| lodMaxClamp: 94.73, |
| maxAnisotropy: 11, |
| }); |
| try { |
| computePassEncoder5.setBindGroup(1, bindGroup27); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder15); computePassEncoder15.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer57, 'uint16', 2, 129); |
| } catch {} |
| await gc(); |
| try { |
| computePassEncoder20.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder7.setBindGroup(2, bindGroup52, new Uint32Array(1515), 128, 0); |
| } catch {} |
| try { |
| renderPassEncoder12.setVertexBuffer(6, buffer6); |
| } catch {} |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55); }; |
| } catch {} |
| try { |
| computePassEncoder38.setBindGroup(2, bindGroup40); |
| } catch {} |
| try { |
| computePassEncoder63.setBindGroup(1, bindGroup33, new Uint32Array(200), 10, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder53); computePassEncoder53.dispatchWorkgroupsIndirect(buffer15, 5_820); }; |
| } catch {} |
| try { |
| computePassEncoder38.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder5.executeBundles([renderBundle0, renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder33.setIndexBuffer(buffer43, 'uint32', 176, 579); |
| } catch {} |
| try { |
| renderPassEncoder22.setVertexBuffer(7, buffer4, 0); |
| } catch {} |
| let shaderModule10 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| enable f16; |
| |
| requires packed_4x8_integer_dot_product; |
| |
| diagnostic(info, xyz); |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| @group(0) @binding(103) var st18: texture_storage_3d<rgba8unorm, write>; |
| |
| @group(0) @binding(176) var st19: texture_storage_3d<rgba16uint, write>; |
| |
| struct T0 { |
| @align(8) @size(1088) f0: array<atomic<i32>>, |
| } |
| |
| struct T1 { |
| f0: vec4i, |
| @align(16) @size(16) f1: vec2f, |
| @align(16) @size(304) f2: mat2x2f, |
| @align(16) @size(864) f3: array<mat4x4h, 2>, |
| } |
| |
| struct T2 { |
| @align(16) @size(16) f0: array<array<atomic<u32>, 1>>, |
| } |
| |
| struct T3 { |
| @size(2944) f0: array<i32>, |
| } |
| |
| struct VertexOutput9 { |
| @builtin(position) f35: vec4f, |
| } |
| |
| struct FragmentOutput7 { |
| @location(3) @interpolate(linear) f0: f32, |
| @location(0) @interpolate(flat, center) f1: vec4u, |
| @location(6) f2: vec4u, |
| } |
| |
| alias vec3b = vec3<bool>; |
| |
| override override3: i32; |
| |
| fn fn0() -> VertexOutput9 { |
| var out: VertexOutput9; |
| let vf185: vec4f = quantizeToF16(vec4f(unconst_f32(-0.02473), unconst_f32(0.2391), unconst_f32(-0.00355), unconst_f32(0.05767))); |
| out = VertexOutput9(vf185); |
| var vf186: vec4f = vf185; |
| out.f35 = quantizeToF16(vec4f(unconst_f32(0.00253), unconst_f32(0.00581), unconst_f32(0.03095), unconst_f32(0.1295))); |
| return out; |
| } |
| |
| fn fn1() -> array<VertexOutput9, 1> { |
| var out: array<VertexOutput9, 1>; |
| out[u32(unconst_u32(378))] = VertexOutput9(saturate(vec2f(unconst_f32(-0.01898), unconst_f32(0.1512))).rrrg); |
| out[u32(unconst_u32(10))] = VertexOutput9(vec4f(countLeadingZeros(vec3u(unconst_u32(168), unconst_u32(347), unconst_u32(4))).yzzx)); |
| fn0(); |
| let vf187: f32 = asinh(f32(unconst_f32(0.00311))); |
| out[u32(unconst_u32(184))].f35 += saturate(vec2f(unconst_f32(0.2640), unconst_f32(0.08649))).rrrr; |
| out[u32(unconst_u32(144))].f35 = bitcast<vec4f>(countLeadingZeros(vec3u(unconst_u32(46), unconst_u32(229), unconst_u32(166))).xzyx); |
| out[u32(unconst_u32(168))] = VertexOutput9(vec4f(f32(asinh(f16(unconst_f16(12680.8)))))); |
| out[u32(unconst_u32(17))] = VertexOutput9(vec4f(asinh(f32(unconst_f32(0.01640))))); |
| let vf188: i32 = override3; |
| var vf189 = fn0(); |
| var vf190: i32 = override3; |
| return out; |
| _ = override3; |
| } |
| |
| var<workgroup> vw44: atomic<u32>; |
| |
| var<workgroup> vw45: array<VertexOutput9, 3>; |
| |
| @vertex |
| fn vertex10() -> VertexOutput9 { |
| var out: VertexOutput9; |
| out = VertexOutput9(vec4f(f32(dot4I8Packed(u32(unconst_u32(23)), u32(unconst_u32(44)))))); |
| out.f35 = faceForward(vec2f(unconst_f32(0.04221), unconst_f32(0.1726)), fma(vec3f(unconst_f32(0.1477), unconst_f32(0.1042), unconst_f32(0.1685)), vec3f(f32(pack4xU8Clamp(vec4u(unconst_u32(72), unconst_u32(244), unconst_u32(101), unconst_u32(23))))), log(vec2f(unconst_f32(0.00609), unconst_f32(0.3018))).ggr).br, vec2f(unconst_f32(0.09662), unconst_f32(0.3441))).xyyx; |
| out.f35 = faceForward(vec2f(unconst_f32(0.09074), unconst_f32(0.3308)), vec2f(unconst_f32(0.01877), unconst_f32(0.09188)), vec2f(unconst_f32(0.07924), unconst_f32(0.2704))).rggg; |
| var vf191: i32 = override3; |
| var vf192 = fn0(); |
| var vf193: vec3f = sqrt(vec3f(unconst_f32(0.4294), unconst_f32(-0.6491), unconst_f32(0.1035))); |
| out.f35 = unpack4x8snorm(pack4xU8Clamp(bitcast<vec4u>(vf192.f35))); |
| fn0(); |
| out.f35 = vec4f(f32(sqrt(f16(unconst_f16(15047.2))))); |
| let vf194: vec2f = pow(vec2f(unconst_f32(0.1251), unconst_f32(0.01698)), vec2f(unconst_f32(0.3009), unconst_f32(0.07460))); |
| out.f35 -= vf193.brrr; |
| fn1(); |
| let vf195: bool = any(vec4<bool>(unconst_bool(true), unconst_bool(false), unconst_bool(false), unconst_bool(false))); |
| var vf196 = fn1(); |
| out.f35 *= vf193.bbgr; |
| vf193 -= bitcast<vec3f>(abs(vec4i(unconst_i32(160), unconst_i32(-198), unconst_i32(278), unconst_i32(404))).zyy); |
| let vf197: i32 = dot4I8Packed(u32(unconst_u32(90)), u32(unconst_u32(19))); |
| let vf198: vec3f = sqrt(vec3f(f32(pack4xU8Clamp(vec4u(unconst_u32(122), unconst_u32(82), unconst_u32(28), unconst_u32(63)))))); |
| vf191 *= dot4I8Packed(u32(unconst_u32(53)), u32(unconst_u32(459))); |
| vf196[u32(unconst_u32(137))] = VertexOutput9(vec4f(vf196[u32(unconst_u32(542))].f35[u32(unconst_u32(57))])); |
| vf193 = bitcast<vec3f>(abs(vec4i(unconst_i32(304), unconst_i32(421), unconst_i32(64), unconst_i32(60))).rrb); |
| fn0(); |
| return out; |
| _ = override3; |
| } |
| |
| @fragment |
| fn fragment8(@location(2) a0: vec2i, @location(12) a1: f16) -> FragmentOutput7 { |
| var out: FragmentOutput7; |
| var vf199: vec2i = a0; |
| fn0(); |
| vf199 += vec2i(i32(determinant(mat2x2f(unconst_f32(-0.1032), unconst_f32(0.06426), unconst_f32(0.04717), unconst_f32(0.09675))))); |
| out.f1 <<= vec4u(tanh(vec2h(unconst_f16(23825.7), unconst_f16(3241.4))).yxxy); |
| var vf200: f32 = determinant(mat2x2f(unconst_f32(0.1714), unconst_f32(0.07874), unconst_f32(0.2536), unconst_f32(0.01299))); |
| vf200 = f32(clamp(u32(unconst_u32(19)), u32(unconst_u32(70)), u32(unconst_u32(315)))); |
| let ptr81: ptr<function, f32> = &vf200; |
| let vf201: i32 = insertBits(i32(unconst_i32(28)), i32(unconst_i32(63)), u32(unconst_u32(30)), u32(unconst_u32(12))); |
| out.f0 = f32(a1); |
| out.f2 -= unpack4xU8(bitcast<u32>(vf201)); |
| out.f0 = f32(pack4xI8Clamp(vec4i(unconst_i32(72), unconst_i32(2), unconst_i32(21), unconst_i32(1)))); |
| out.f2 *= vec4u(bitcast<u32>(vf201)); |
| return out; |
| } |
| |
| @compute @workgroup_size(1, 1, 1) |
| fn compute9(@builtin(workgroup_id) a0: vec3u) { |
| let vf202: u32 = atomicExchange(&vw44, u32(unconst_u32(11))); |
| let vf203: u32 = atomicLoad(&(*&vw44)); |
| let ptr82: ptr<workgroup, atomic<u32>> = &(*&vw44); |
| var vf204 = fn1(); |
| atomicCompareExchangeWeak(&vw44, unconst_u32(6), unconst_u32(392)); |
| vw45[pack4xU8Clamp(vec4u(vf204[u32(unconst_u32(506))].f35))] = VertexOutput9(unpack4x8snorm(atomicLoad(&(*ptr82)))); |
| let vf205: array<VertexOutput9, 3> = workgroupUniformLoad(&vw45); |
| fn1(); |
| _ = override3; |
| }`, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| let buffer74 = device0.createBuffer({ |
| label: '\u241f\uec56\ud970\u0632\uee78\u22db\u0f1e\u{1fc8c}', |
| size: 5039, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ, |
| }); |
| let commandEncoder100 = device0.createCommandEncoder(); |
| let querySet9 = device0.createQuerySet({type: 'occlusion', count: 99}); |
| try { |
| computePassEncoder32.setBindGroup(0, bindGroup47); |
| } catch {} |
| try { |
| computePassEncoder38.setBindGroup(0, bindGroup2, new Uint32Array(3861), 139, 0); |
| } catch {} |
| try { |
| computePassEncoder62.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder34.executeBundles([renderBundle0, renderBundle0, renderBundle3, renderBundle3]); |
| } catch {} |
| try { |
| renderPassEncoder3.setIndexBuffer(buffer16, 'uint16', 482, 255); |
| } catch {} |
| try { |
| renderPassEncoder12.setVertexBuffer(6, buffer72, 0); |
| } catch {} |
| try { |
| commandEncoder100.copyBufferToBuffer(buffer42, 236, buffer22, 40, 392); |
| } catch {} |
| try { |
| commandEncoder100.copyBufferToTexture({ |
| /* bytesInLastRow: 72 widthInBlocks: 18 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 2688 */ |
| offset: 2688, |
| bytesPerRow: 28672, |
| buffer: buffer51, |
| }, { |
| texture: texture88, |
| mipLevel: 0, |
| origin: {x: 16, y: 32, z: 0}, |
| aspect: 'all', |
| }, {width: 18, height: 5, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer4]); |
| } catch {} |
| let buffer75 = device0.createBuffer({size: 5762, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let textureView89 = texture51.createView({aspect: 'all'}); |
| let texture91 = device0.createTexture({ |
| size: {width: 110, height: 10, depthOrArrayLayers: 1}, |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| let textureView90 = texture78.createView({dimension: '2d-array', mipLevelCount: 1}); |
| let computePassEncoder72 = commandEncoder100.beginComputePass(); |
| let renderBundleEncoder5 = device0.createRenderBundleEncoder({colorFormats: ['rgba16sint'], depthReadOnly: true}); |
| try { |
| renderPassEncoder29.setBindGroup(0, bindGroup45); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| let buffer76 = device0.createBuffer({ |
| size: 38812, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| let commandEncoder101 = device0.createCommandEncoder({}); |
| let textureView91 = texture39.createView({dimension: '2d', aspect: 'all'}); |
| let computePassEncoder73 = commandEncoder101.beginComputePass({}); |
| try { |
| computePassEncoder11.setBindGroup(3, bindGroup17, new Uint32Array(921), 47, 0); |
| } catch {} |
| try { |
| computePassEncoder60.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder7.setBindGroup(3, bindGroup9, new Uint32Array(2349), 201, 0); |
| } catch {} |
| try { |
| renderBundleEncoder5.setVertexBuffer(6, buffer56); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer11, 2656, new BigUint64Array(1318), 53, 64); |
| } catch {} |
| let buffer77 = device0.createBuffer({ |
| label: '\u7afb\u{1fbb3}\u0dcd\u{1f693}', |
| size: 6018, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM, |
| mappedAtCreation: false, |
| }); |
| try { |
| computePassEncoder15.end(); |
| } catch {} |
| try { |
| renderPassEncoder31.setBindGroup(3, bindGroup8, new Uint32Array(1379), 235, 0); |
| } catch {} |
| try { |
| renderPassEncoder34.executeBundles([renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder29.setViewport(45.76208559116681, 0.4833706511646809, 45.46785964863729, 0.04919451053929141, 0.3169837851481946, 0.8133929864013272); |
| } catch {} |
| try { |
| renderPassEncoder33.setIndexBuffer(buffer42, 'uint32', 120, 827); |
| } catch {} |
| try { |
| renderBundleEncoder5.setIndexBuffer(buffer57, 'uint16', 622, 1); |
| } catch {} |
| try { |
| renderBundleEncoder5.setVertexBuffer(7, buffer62, 0, 3_951); |
| } catch {} |
| try { |
| buffer4.unmap(); |
| } catch {} |
| try { |
| commandEncoder21.copyBufferToTexture({ |
| /* bytesInLastRow: 56 widthInBlocks: 7 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 320 */ |
| offset: 320, |
| rowsPerImage: 1266, |
| buffer: buffer51, |
| }, { |
| texture: texture81, |
| mipLevel: 3, |
| origin: {x: 3, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 7, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder21.copyTextureToTexture({ |
| texture: texture65, |
| mipLevel: 0, |
| origin: {x: 6, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture52, |
| mipLevel: 0, |
| origin: {x: 5, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 31, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer5]); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer54, 360, new Int16Array(3945), 244, 216); |
| } catch {} |
| canvas0.width = 675; |
| let buffer78 = device0.createBuffer({size: 2652, usage: GPUBufferUsage.INDIRECT, mappedAtCreation: false}); |
| let texture92 = device0.createTexture({ |
| label: '\ub927\ufa24\u188b\ue860', |
| size: [220, 20, 1], |
| sampleCount: 1, |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder56.setBindGroup(1, bindGroup13); |
| } catch {} |
| try { |
| computePassEncoder51.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder23.setBindGroup(0, bindGroup6, new Uint32Array(1240), 529, 0); |
| } catch {} |
| try { |
| commandEncoder21.copyBufferToTexture({ |
| /* bytesInLastRow: 240 widthInBlocks: 30 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 160 */ |
| offset: 160, |
| buffer: buffer75, |
| }, { |
| texture: texture77, |
| mipLevel: 0, |
| origin: {x: 3, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 30, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.append(canvas0); |
| let videoFrame12 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt470bg', primaries: 'smpte240m', transfer: 'hlg'} }); |
| let bindGroup55 = device0.createBindGroup({layout: bindGroupLayout1, entries: [{binding: 277, resource: sampler48}]}); |
| let texture93 = device0.createTexture({ |
| size: [55, 5, 1], |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder74 = commandEncoder21.beginComputePass({}); |
| try { |
| renderBundleEncoder5.setBindGroup(1, bindGroup0); |
| } catch {} |
| try { |
| renderBundleEncoder5.setIndexBuffer(buffer54, 'uint16', 2_788, 292); |
| } catch {} |
| let externalTexture5 = device0.importExternalTexture({source: videoFrame9}); |
| try { |
| computePassEncoder43.setBindGroup(3, bindGroup10); |
| } catch {} |
| try { |
| computePassEncoder57.setBindGroup(2, bindGroup50, new Uint32Array(713), 287, 0); |
| } catch {} |
| try { |
| computePassEncoder74.setPipeline(pipeline0); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| let buffer79 = device0.createBuffer({size: 4383, usage: GPUBufferUsage.INDEX}); |
| try { |
| computePassEncoder42.setBindGroup(3, bindGroup35); |
| } catch {} |
| try { |
| computePassEncoder73.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(3, bindGroup2); |
| } catch {} |
| try { |
| renderPassEncoder10.setViewport(28.662741173277034, 33.7862170978539, 10.379756806058513, 11.636311393024773, 0.3722126658934751, 0.39069421066259746); |
| } catch {} |
| try { |
| renderBundleEncoder5.insertDebugMarker('\u{1fad8}'); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| } catch {} |
| let bindGroup56 = device0.createBindGroup({ |
| label: '\u{1fe95}\uadae\u0a35', |
| layout: bindGroupLayout9, |
| entries: [ |
| {binding: 113, resource: sampler38}, |
| {binding: 127, resource: sampler46}, |
| {binding: 96, resource: {buffer: buffer50, offset: 0, size: 236}}, |
| ], |
| }); |
| let textureView92 = texture77.createView({aspect: 'all'}); |
| let renderBundle5 = renderBundleEncoder5.finish({}); |
| try { |
| computePassEncoder31.setBindGroup(1, bindGroup54); |
| } catch {} |
| try { |
| computePassEncoder53.end(); |
| } catch {} |
| try { |
| renderPassEncoder4.setIndexBuffer(buffer71, 'uint32', 1_436, 4_882); |
| } catch {} |
| try { |
| commandEncoder73.copyTextureToBuffer({ |
| texture: texture92, |
| mipLevel: 0, |
| origin: {x: 19, y: 11, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 64 widthInBlocks: 8 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 448 */ |
| offset: 448, |
| rowsPerImage: 198, |
| buffer: buffer44, |
| }, {width: 8, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder73.clearBuffer(buffer53, 216, 316); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 96, height: 1, depthOrArrayLayers: 131} |
| */ |
| { |
| source: canvas0, |
| origin: { x: 28, y: 77 }, |
| flipY: true, |
| }, { |
| texture: texture18, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 41}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 55, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroupLayout11 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 52, |
| visibility: GPUShaderStage.COMPUTE, |
| texture: { viewDimension: '3d', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| { |
| binding: 57, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false }, |
| }, |
| ], |
| }); |
| let sampler54 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'clamp-to-edge', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 15.95, |
| lodMaxClamp: 60.47, |
| }); |
| try { |
| renderPassEncoder22.setBindGroup(1, bindGroup49, new Uint32Array(447), 18, 0); |
| } catch {} |
| let imageData11 = new ImageData(32, 4); |
| let texture94 = device0.createTexture({ |
| size: {width: 55, height: 5, depthOrArrayLayers: 6}, |
| mipLevelCount: 2, |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView93 = texture61.createView({baseMipLevel: 0, arrayLayerCount: 1}); |
| let computePassEncoder75 = commandEncoder73.beginComputePass(); |
| try { |
| computePassEncoder68.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder2.executeBundles([renderBundle5, renderBundle3, renderBundle0, renderBundle3]); |
| } catch {} |
| try { |
| renderPassEncoder19.setIndexBuffer(buffer77, 'uint16', 1_902, 640); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 96, height: 1, depthOrArrayLayers: 131} |
| */ |
| { |
| source: imageData11, |
| origin: { x: 4, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture18, |
| mipLevel: 0, |
| origin: {x: 8, y: 0, z: 27}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let querySet10 = device0.createQuerySet({type: 'occlusion', count: 335}); |
| let sampler55 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'clamp-to-edge', |
| lodMinClamp: 39.74, |
| lodMaxClamp: 98.79, |
| maxAnisotropy: 1, |
| }); |
| try { |
| computePassEncoder49.setBindGroup(1, bindGroup4, new Uint32Array(1663), 16, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder6); computePassEncoder6.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder56.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder32.setBindGroup(0, bindGroup49); |
| } catch {} |
| try { |
| renderPassEncoder9.setBindGroup(0, bindGroup35, new Uint32Array(1660), 228, 0); |
| } catch {} |
| try { |
| renderPassEncoder23.beginOcclusionQuery(43); |
| } catch {} |
| try { |
| renderPassEncoder28.setPipeline(pipeline1); |
| } catch {} |
| try { |
| querySet3.destroy(); |
| } catch {} |
| try { |
| if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55); }; |
| } catch {} |
| let sampler56 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 10.91, |
| lodMaxClamp: 34.96, |
| maxAnisotropy: 18, |
| }); |
| try { |
| computePassEncoder72.setBindGroup(0, bindGroup40); |
| } catch {} |
| try { |
| computePassEncoder65.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder8.setBlendConstant({ r: -604.9, g: -593.3, b: -31.49, a: -815.2, }); |
| } catch {} |
| try { |
| renderPassEncoder17.setVertexBuffer(7, buffer65, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.insertDebugMarker('\ub7d2'); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let commandEncoder102 = device0.createCommandEncoder({}); |
| let texture95 = device0.createTexture({ |
| size: [55, 5, 39], |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let computePassEncoder76 = commandEncoder102.beginComputePass({}); |
| try { |
| computePassEncoder76.setBindGroup(3, bindGroup8); |
| } catch {} |
| try { |
| computePassEncoder6.end(); |
| } catch {} |
| try { |
| computePassEncoder45.setPipeline(pipeline0); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({device: device0, format: 'rgba16float', usage: GPUTextureUsage.COPY_SRC, alphaMode: 'premultiplied'}); |
| } catch {} |
| let bindGroup57 = device0.createBindGroup({ |
| layout: bindGroupLayout9, |
| entries: [ |
| {binding: 113, resource: sampler25}, |
| {binding: 127, resource: sampler35}, |
| {binding: 96, resource: {buffer: buffer50, offset: 256, size: 120}}, |
| ], |
| }); |
| let commandEncoder103 = device0.createCommandEncoder({}); |
| let computePassEncoder77 = commandEncoder9.beginComputePass({}); |
| let renderPassEncoder37 = commandEncoder103.beginRenderPass({ |
| colorAttachments: [{view: textureView8, depthSlice: 0, loadOp: 'clear', storeOp: 'store'}], |
| maxDrawCount: 240569899, |
| }); |
| try { |
| computePassEncoder11.setBindGroup(0, bindGroup37); |
| } catch {} |
| try { |
| renderPassEncoder31.setIndexBuffer(buffer76, 'uint32', 540, 3_705); |
| } catch {} |
| try { |
| renderPassEncoder4.setVertexBuffer(3, buffer50); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let pipeline2 = device0.createComputePipeline({layout: pipelineLayout0, compute: {module: shaderModule5}}); |
| let promise8 = device0.createRenderPipelineAsync({ |
| label: '\ua0fd\u242c\u095c\u{1ff01}\u089a\ufc02', |
| layout: pipelineLayout0, |
| multisample: {mask: 0x4dc67973}, |
| fragment: { |
| module: shaderModule3, |
| constants: {}, |
| targets: [{format: 'rgba16sint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN}], |
| }, |
| vertex: {module: shaderModule10, constants: {override3: 0}, buffers: []}, |
| primitive: {topology: 'point-list', cullMode: 'front', unclippedDepth: false}, |
| }); |
| let img2 = await imageWithData(15, 54, '#10101010', '#20202020'); |
| try { |
| computePassEncoder77.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder34.setVertexBuffer(0, buffer62, 0, 9_452); |
| } catch {} |
| try { |
| buffer59.unmap(); |
| } catch {} |
| let buffer80 = device0.createBuffer({size: 23351, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX}); |
| let sampler57 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 82.11, |
| lodMaxClamp: 91.55, |
| }); |
| try { |
| computePassEncoder67.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(6, buffer62, 796, 1_968); |
| } catch {} |
| await gc(); |
| let commandEncoder104 = device0.createCommandEncoder({}); |
| let computePassEncoder78 = commandEncoder104.beginComputePass({}); |
| let sampler58 = device0.createSampler({ |
| addressModeV: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 47.96, |
| lodMaxClamp: 89.92, |
| maxAnisotropy: 7, |
| }); |
| try { |
| computePassEncoder55.setBindGroup(0, bindGroup18); |
| } catch {} |
| try { |
| renderPassEncoder9.setBindGroup(1, bindGroup39); |
| } catch {} |
| try { |
| renderPassEncoder24.setStencilReference(185); |
| } catch {} |
| try { |
| renderPassEncoder20.setViewport(41.378700977712946, 6.49761849464134, 23.296775326624726, 42.22117714635374, 0.35819460018002225, 0.9546759883358251); |
| } catch {} |
| try { |
| if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(0x55); }; |
| } catch {} |
| let textureView94 = texture71.createView({baseMipLevel: 0}); |
| try { |
| renderPassEncoder23.setVertexBuffer(3, buffer42); |
| } catch {} |
| let commandEncoder105 = device0.createCommandEncoder(); |
| let textureView95 = texture16.createView({ |
| label: '\u0579\u9ead\u{1f673}\u03aa\ue315\u807a\ua13e\u{1fae0}', |
| dimension: 'cube-array', |
| mipLevelCount: 1, |
| baseArrayLayer: 1, |
| arrayLayerCount: 6, |
| }); |
| let renderBundleEncoder6 = device0.createRenderBundleEncoder({colorFormats: ['rgba16uint'], stencilReadOnly: true}); |
| try { |
| computePassEncoder45.setBindGroup(1, bindGroup22); |
| } catch {} |
| try { |
| computePassEncoder30.setBindGroup(1, bindGroup20, new Uint32Array(664), 50, 0); |
| } catch {} |
| try { |
| computePassEncoder66.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder10.setBindGroup(2, bindGroup4); |
| } catch {} |
| try { |
| renderPassEncoder7.beginOcclusionQuery(17); |
| } catch {} |
| try { |
| renderPassEncoder28.executeBundles([renderBundle2]); |
| } catch {} |
| try { |
| renderPassEncoder9.setIndexBuffer(buffer54, 'uint32', 1_956, 5_239); |
| } catch {} |
| try { |
| renderBundleEncoder6.setIndexBuffer(buffer80, 'uint16', 8_162, 662); |
| } catch {} |
| let texture96 = gpuCanvasContext0.getCurrentTexture(); |
| let computePassEncoder79 = commandEncoder105.beginComputePass({}); |
| try { |
| computePassEncoder38.setBindGroup(1, bindGroup48, new Uint32Array(4596), 2_125, 0); |
| } catch {} |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer20, 'uint32', 72, 17); |
| } catch {} |
| let bindGroup58 = device0.createBindGroup({ |
| label: '\ud4cd\u07ad\u050c\u31a6\u0477\ub20a\uc6fd\u069e\u{1f7d3}\u{1fdf1}', |
| layout: bindGroupLayout6, |
| entries: [{binding: 11, resource: {buffer: buffer12, offset: 0, size: 672}}], |
| }); |
| let commandEncoder106 = device0.createCommandEncoder(); |
| let computePassEncoder80 = commandEncoder106.beginComputePass({label: '\u23cb\uf1b8\u6b92\u{1fc3d}\u99a8\u0acc\uaac2\u2599'}); |
| let renderBundle6 = renderBundleEncoder6.finish({}); |
| try { |
| computePassEncoder61.setBindGroup(0, bindGroup35, new Uint32Array(469), 264, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder46); computePassEncoder46.dispatchWorkgroupsIndirect(buffer24, 348); }; |
| } catch {} |
| try { |
| renderPassEncoder4.setVertexBuffer(7, buffer15, 0); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| } catch {} |
| let commandEncoder107 = device0.createCommandEncoder({}); |
| let texture97 = device0.createTexture({ |
| size: [384, 1, 524], |
| dimension: '3d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderPassEncoder38 = commandEncoder107.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView51, |
| depthSlice: 5, |
| clearValue: { r: 313.6, g: 807.9, b: -842.4, a: -831.3, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| maxDrawCount: 138148182, |
| }); |
| try { |
| computePassEncoder34.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(2, bindGroup0, []); |
| } catch {} |
| try { |
| renderPassEncoder7.setStencilReference(2022); |
| } catch {} |
| try { |
| renderPassEncoder20.setIndexBuffer(buffer59, 'uint32', 312, 766); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer9, 3504, new DataView(new ArrayBuffer(2220)), 835, 160); |
| } catch {} |
| let commandEncoder108 = device0.createCommandEncoder(); |
| let texture98 = device0.createTexture({ |
| size: {width: 64, height: 64, depthOrArrayLayers: 22}, |
| mipLevelCount: 2, |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder46.end(); |
| } catch {} |
| try { |
| computePassEncoder31.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(0, bindGroup40, new Uint32Array(1093), 422, 0); |
| } catch {} |
| try { |
| renderPassEncoder21.executeBundles([renderBundle5, renderBundle5]); |
| } catch {} |
| try { |
| renderPassEncoder9.setVertexBuffer(0, buffer59); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture93, |
| mipLevel: 0, |
| origin: {x: 15, y: 1, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(159).fill(90), /* required buffer size: 159 */ |
| {offset: 159, bytesPerRow: 121}, {width: 19, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup59 = device0.createBindGroup({ |
| layout: bindGroupLayout7, |
| entries: [{binding: 54, resource: {buffer: buffer72, offset: 1536}}, {binding: 53, resource: externalTexture0}], |
| }); |
| let buffer81 = device0.createBuffer({ |
| label: '\u0cdf\u01b3\u{1f9b1}\u0c64\u{1f9e3}\u0054', |
| size: 5956, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM, |
| }); |
| let computePassEncoder81 = commandEncoder108.beginComputePass(); |
| let renderPassEncoder39 = commandEncoder3.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView16, |
| clearValue: { r: 805.5, g: -857.0, b: 703.4, a: 460.6, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| }); |
| let sampler59 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 30.97, |
| }); |
| try { |
| computePassEncoder72.setBindGroup(3, bindGroup47); |
| } catch {} |
| try { |
| computePassEncoder72.end(); |
| } catch {} |
| try { |
| renderPassEncoder33.setBindGroup(1, bindGroup28); |
| } catch {} |
| try { |
| renderPassEncoder26.setBindGroup(1, bindGroup20, new Uint32Array(3170), 386, 0); |
| } catch {} |
| try { |
| renderPassEncoder26.executeBundles([renderBundle4]); |
| } catch {} |
| try { |
| renderPassEncoder37.setScissorRect(159, 9, 68, 147); |
| } catch {} |
| try { |
| renderPassEncoder38.setIndexBuffer(buffer42, 'uint16', 368, 426); |
| } catch {} |
| try { |
| renderPassEncoder13.setVertexBuffer(0, buffer67); |
| } catch {} |
| let bindGroup60 = device0.createBindGroup({ |
| layout: bindGroupLayout5, |
| entries: [ |
| {binding: 86, resource: textureView78}, |
| {binding: 211, resource: sampler20}, |
| {binding: 62, resource: textureView39}, |
| ], |
| }); |
| let buffer82 = device0.createBuffer({ |
| size: 1101, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let texture99 = device0.createTexture({ |
| size: [73, 1, 1], |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let renderPassEncoder40 = commandEncoder100.beginRenderPass({ |
| colorAttachments: [{view: textureView25, depthSlice: 125, loadOp: 'load', storeOp: 'store'}], |
| maxDrawCount: 343140706, |
| }); |
| try { |
| renderPassEncoder28.setBindGroup(1, bindGroup49); |
| } catch {} |
| try { |
| renderPassEncoder7.endOcclusionQuery(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer1, 400, new DataView(new ArrayBuffer(9015)), 124, 652); |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let sampler60 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'clamp-to-edge', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 66.78, |
| lodMaxClamp: 87.01, |
| }); |
| try { |
| renderPassEncoder23.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder7.executeBundles([renderBundle0, renderBundle3]); |
| } catch {} |
| try { |
| renderPassEncoder26.setIndexBuffer(buffer20, 'uint16', 42, 75); |
| } catch {} |
| document.body.append(canvas0); |
| let renderBundleEncoder7 = device0.createRenderBundleEncoder({colorFormats: ['rgba16sint'], stencilReadOnly: true}); |
| try { |
| computePassEncoder59.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder38.setIndexBuffer(buffer51, 'uint16', 216, 1_012); |
| } catch {} |
| try { |
| renderBundleEncoder7.setVertexBuffer(7, buffer3, 20); |
| } catch {} |
| let promise9 = device0.queue.onSubmittedWorkDone(); |
| document.body.prepend(img2); |
| let buffer83 = device0.createBuffer({ |
| size: 17091, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let renderBundle7 = renderBundleEncoder7.finish(); |
| let sampler61 = device0.createSampler({ |
| label: '\u0704\u{1ff85}\u267c', |
| addressModeU: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 66.96, |
| lodMaxClamp: 79.62, |
| compare: 'never', |
| maxAnisotropy: 13, |
| }); |
| try { |
| computePassEncoder71.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder24.setIndexBuffer(buffer44, 'uint16', 2_762, 2_365); |
| } catch {} |
| try { |
| renderPassEncoder22.setPipeline(pipeline1); |
| } catch {} |
| let arrayBuffer3 = buffer35.getMappedRange(520, 116); |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC, |
| colorSpace: 'display-p3', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let bindGroup61 = device0.createBindGroup({ |
| label: '\u0830\ua071\u968a\u20e0\u4a9f\u0077', |
| layout: bindGroupLayout6, |
| entries: [{binding: 11, resource: {buffer: buffer63, offset: 256, size: 4252}}], |
| }); |
| try { |
| computePassEncoder76.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder36.setBindGroup(1, bindGroup41, new Uint32Array(2020), 11, 0); |
| } catch {} |
| try { |
| renderPassEncoder20.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder26.insertDebugMarker('\u0f6b'); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 73, height: 1, depthOrArrayLayers: 54} |
| */ |
| { |
| source: imageData3, |
| origin: { x: 0, y: 1 }, |
| flipY: false, |
| }, { |
| texture: texture5, |
| mipLevel: 0, |
| origin: {x: 20, y: 0, z: 1}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 3, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder109 = device0.createCommandEncoder({}); |
| let texture100 = device0.createTexture({ |
| label: '\ucd6c\u{1fa62}', |
| size: {width: 64, height: 64, depthOrArrayLayers: 22}, |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| computePassEncoder57.setBindGroup(2, bindGroup31); |
| } catch {} |
| try { |
| computePassEncoder67.setBindGroup(2, bindGroup58, new Uint32Array(3818), 112, 0); |
| } catch {} |
| try { |
| computePassEncoder76.setPipeline(pipeline2); |
| } catch {} |
| let commandEncoder110 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder73.setBindGroup(0, bindGroup37); |
| } catch {} |
| try { |
| computePassEncoder61.setBindGroup(3, bindGroup48, new Uint32Array(2706), 226, 0); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(3, bindGroup18); |
| } catch {} |
| try { |
| renderPassEncoder36.setVertexBuffer(2, buffer12); |
| } catch {} |
| try { |
| commandEncoder109.copyTextureToTexture({ |
| texture: texture14, |
| mipLevel: 0, |
| origin: {x: 22, y: 0, z: 3}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture60, |
| mipLevel: 1, |
| origin: {x: 16, y: 24, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder109.resolveQuerySet(querySet7, 8, 69, buffer46, 512); |
| } catch {} |
| let videoFrame13 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte170m', primaries: 'bt2020', transfer: 'smpte170m'} }); |
| let commandEncoder111 = device0.createCommandEncoder({}); |
| let querySet11 = device0.createQuerySet({type: 'occlusion', count: 1532}); |
| let textureView96 = texture63.createView({dimension: '2d-array', baseMipLevel: 0, mipLevelCount: 1}); |
| let computePassEncoder82 = commandEncoder110.beginComputePass(); |
| try { |
| renderPassEncoder31.setIndexBuffer(buffer70, 'uint32', 780, 2_396); |
| } catch {} |
| try { |
| commandEncoder111.copyBufferToTexture({ |
| /* bytesInLastRow: 28 widthInBlocks: 7 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 276 */ |
| offset: 276, |
| bytesPerRow: 12544, |
| buffer: buffer11, |
| }, { |
| texture: texture32, |
| mipLevel: 0, |
| origin: {x: 22, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 7, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder111.resolveQuerySet(querySet9, 22, 5, buffer64, 512); |
| } catch {} |
| await gc(); |
| let commandEncoder112 = device0.createCommandEncoder({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder11); computePassEncoder11.dispatchWorkgroupsIndirect(buffer81, 976); }; |
| } catch {} |
| try { |
| computePassEncoder11.end(); |
| } catch {} |
| try { |
| computePassEncoder81.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(1, bindGroup28, new Uint32Array(2580), 50, 0); |
| } catch {} |
| try { |
| renderPassEncoder20.setPipeline(pipeline1); |
| } catch {} |
| let arrayBuffer4 = buffer35.getMappedRange(0, 28); |
| let commandEncoder113 = device0.createCommandEncoder(); |
| let renderPassEncoder41 = commandEncoder111.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView8, |
| depthSlice: 1, |
| clearValue: { r: -472.8, g: 308.1, b: -803.9, a: -461.2, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| computePassEncoder50.setBindGroup(0, bindGroup2, new Uint32Array(53), 14, 0); |
| } catch {} |
| try { |
| renderPassEncoder19.executeBundles([renderBundle5]); |
| } catch {} |
| let commandEncoder114 = device0.createCommandEncoder(); |
| let textureView97 = texture47.createView({ |
| label: '\u09f3\u0860\u5db2\u08cf\u96b3\u6760\u{1f669}\u05ee\u{1fadc}', |
| dimension: '2d-array', |
| format: 'rgb10a2uint', |
| mipLevelCount: 1, |
| }); |
| let renderPassEncoder42 = commandEncoder114.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView73, |
| clearValue: { r: -254.5, g: -978.0, b: -115.7, a: 450.8, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55); }; |
| } catch {} |
| try { |
| globalThis.someLabel = commandEncoder4.label; |
| } catch {} |
| let buffer84 = device0.createBuffer({ |
| size: 27762, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let textureView98 = texture91.createView({label: '\u068c\u460c\u0bfe\udef6\u1813\ud0a7\ua6cd\u7704\u300d\u3ae8', format: 'rgba16uint'}); |
| let computePassEncoder83 = commandEncoder15.beginComputePass({}); |
| try { |
| computePassEncoder29.setBindGroup(1, bindGroup57, new Uint32Array(751), 110, 0); |
| } catch {} |
| try { |
| computePassEncoder69.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder42.executeBundles([renderBundle2, renderBundle1]); |
| } catch {} |
| let computePassEncoder84 = commandEncoder112.beginComputePass({}); |
| try { |
| computePassEncoder59.setBindGroup(0, bindGroup1); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder59); computePassEncoder59.dispatchWorkgroupsIndirect(buffer78, 432); }; |
| } catch {} |
| try { |
| computePassEncoder59.end(); |
| } catch {} |
| try { |
| computePassEncoder80.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder35.setIndexBuffer(buffer30, 'uint32', 4, 4); |
| } catch {} |
| try { |
| renderPassEncoder20.setVertexBuffer(3, buffer8, 0); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'srgb', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 96, height: 1, depthOrArrayLayers: 131} |
| */ |
| { |
| source: img1, |
| origin: { x: 6, y: 4 }, |
| flipY: false, |
| }, { |
| texture: texture18, |
| mipLevel: 0, |
| origin: {x: 28, y: 0, z: 32}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.append(canvas0); |
| let offscreenCanvas1 = new OffscreenCanvas(380, 156); |
| let imageData12 = new ImageData(32, 12); |
| let commandEncoder115 = device0.createCommandEncoder({label: '\u{1ffb2}\u0aab\u0722\u0f8f\u032c\ubfef\u316c\u{1f8ea}\u0409\ubd14\u001b'}); |
| let texture101 = device0.createTexture({ |
| size: [64], |
| dimension: '1d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder85 = commandEncoder109.beginComputePass({}); |
| let renderPassEncoder43 = commandEncoder83.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView38, |
| clearValue: { r: -978.9, g: 678.3, b: -523.1, a: -840.9, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| maxDrawCount: 42765863, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder50); computePassEncoder50.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder78.setPipeline(pipeline2); |
| } catch {} |
| try { |
| buffer31.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer54, 960, new DataView(new ArrayBuffer(16916)), 1395, 1808); |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| try { |
| offscreenCanvas1.getContext('2d'); |
| } catch {} |
| let bindGroup62 = device0.createBindGroup({ |
| layout: bindGroupLayout11, |
| entries: [{binding: 57, resource: textureView48}, {binding: 52, resource: textureView47}], |
| }); |
| let pipelineLayout5 = device0.createPipelineLayout({bindGroupLayouts: []}); |
| let buffer85 = device0.createBuffer({ |
| label: '\u07f7\u4bf4\u086a', |
| size: 17742, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let textureView99 = texture2.createView({}); |
| let renderPassEncoder44 = commandEncoder115.beginRenderPass({ |
| colorAttachments: [{view: textureView98, loadOp: 'load', storeOp: 'discard'}], |
| occlusionQuerySet: querySet4, |
| maxDrawCount: 84849259, |
| }); |
| let sampler62 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 69.44, |
| lodMaxClamp: 93.08, |
| maxAnisotropy: 5, |
| }); |
| try { |
| computePassEncoder61.setBindGroup(0, bindGroup37); |
| } catch {} |
| try { |
| computePassEncoder62.setBindGroup(2, bindGroup52, new Uint32Array(3391), 57, 0); |
| } catch {} |
| try { |
| renderPassEncoder34.setBindGroup(2, bindGroup41); |
| } catch {} |
| try { |
| renderPassEncoder17.setBindGroup(0, bindGroup50, new Uint32Array(5014), 730, 0); |
| } catch {} |
| try { |
| renderPassEncoder17.setScissorRect(2, 0, 11, 0); |
| } catch {} |
| try { |
| renderPassEncoder26.setPipeline(pipeline1); |
| } catch {} |
| let arrayBuffer5 = buffer35.getMappedRange(32, 8); |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture30, |
| mipLevel: 0, |
| origin: {x: 71, y: 98, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(122).fill(135), /* required buffer size: 122 */ |
| {offset: 122, bytesPerRow: 632}, {width: 68, height: 34, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| if (!arrayBuffer4.detached) { new Uint8Array(arrayBuffer4).fill(0x55); }; |
| } catch {} |
| let bindGroupLayout12 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 39, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'uint', multisampled: true }, |
| }, |
| ], |
| }); |
| let buffer86 = device0.createBuffer({ |
| label: '\u8460\u034b\u0f09\u2b77\u6dd2\uf4f5\u2528', |
| size: 3728, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| let commandEncoder116 = device0.createCommandEncoder({}); |
| let texture102 = device0.createTexture({ |
| label: '\u2c1e\u0100\u0b0c\u01dc\u{1fe85}\u{1fe82}\u7bae\u0b3e', |
| size: {width: 73, height: 1, depthOrArrayLayers: 1}, |
| sampleCount: 4, |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView100 = texture30.createView({format: 'rgba16sint', arrayLayerCount: 1}); |
| try { |
| computePassEncoder30.setBindGroup(0, bindGroup16, new Uint32Array(3454), 85, 0); |
| } catch {} |
| try { |
| computePassEncoder84.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder19.setBindGroup(2, bindGroup34, new Uint32Array(1201), 220, 0); |
| } catch {} |
| try { |
| renderPassEncoder14.setViewport(8.106110482023922, 52.85146264733003, 46.647254449198606, 0.8845238629239057, 0.9396636089550949, 0.9468029626430029); |
| } catch {} |
| try { |
| commandEncoder116.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 208 */ |
| offset: 208, |
| bytesPerRow: 17152, |
| rowsPerImage: 172, |
| buffer: buffer41, |
| }, { |
| texture: texture5, |
| mipLevel: 0, |
| origin: {x: 18, y: 0, z: 27}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| document.body.append(canvas0); |
| let commandEncoder117 = device0.createCommandEncoder({}); |
| let textureView101 = texture102.createView({dimension: '2d'}); |
| let textureView102 = texture59.createView({}); |
| let sampler63 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 42.58, |
| lodMaxClamp: 74.33, |
| compare: 'greater', |
| maxAnisotropy: 9, |
| }); |
| try { |
| computePassEncoder60.setBindGroup(0, bindGroup54); |
| } catch {} |
| try { |
| renderPassEncoder40.setBindGroup(1, bindGroup13); |
| } catch {} |
| try { |
| renderPassEncoder12.setIndexBuffer(buffer20, 'uint16', 428, 5); |
| } catch {} |
| try { |
| renderPassEncoder31.setVertexBuffer(2, buffer59); |
| } catch {} |
| let promise10 = device0.queue.onSubmittedWorkDone(); |
| let bindGroup63 = device0.createBindGroup({layout: bindGroupLayout6, entries: [{binding: 11, resource: {buffer: buffer62, offset: 768}}]}); |
| let sampler64 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 92.11, |
| lodMaxClamp: 98.97, |
| }); |
| try { |
| renderPassEncoder4.executeBundles([renderBundle3, renderBundle7]); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| let commandEncoder118 = device0.createCommandEncoder({}); |
| let computePassEncoder86 = commandEncoder117.beginComputePass({}); |
| try { |
| computePassEncoder14.setBindGroup(3, bindGroup48); |
| } catch {} |
| try { |
| renderPassEncoder15.executeBundles([renderBundle1]); |
| } catch {} |
| try { |
| buffer51.unmap(); |
| } catch {} |
| let buffer87 = device0.createBuffer({ |
| size: 8579, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder119 = device0.createCommandEncoder({}); |
| let renderPassEncoder45 = commandEncoder119.beginRenderPass({ |
| label: '\u0cd7\u0ebf\u0eef\u0166\u17bb', |
| colorAttachments: [{ |
| view: textureView79, |
| clearValue: { r: -625.7, g: -762.9, b: 373.0, a: 926.3, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet10, |
| }); |
| try { |
| computePassEncoder85.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder9.setBindGroup(0, bindGroup52); |
| } catch {} |
| try { |
| renderPassEncoder27.setIndexBuffer(buffer84, 'uint32', 440, 1_780); |
| } catch {} |
| try { |
| renderPassEncoder32.setVertexBuffer(7, buffer83, 0, 1_353); |
| } catch {} |
| try { |
| commandEncoder113.copyBufferToTexture({ |
| /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 308 */ |
| offset: 308, |
| buffer: buffer86, |
| }, { |
| texture: texture76, |
| mipLevel: 3, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 1, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| let pipeline3 = await device0.createComputePipelineAsync({layout: pipelineLayout0, compute: {module: shaderModule4}}); |
| try { |
| adapter0.label = '\u4a64\udaa1\u07c8\uefac\u{1fd72}\u0e49\u{1fbf7}\u9246\uecc2\u4440'; |
| } catch {} |
| let commandEncoder120 = device0.createCommandEncoder(); |
| let querySet12 = device0.createQuerySet({type: 'occlusion', count: 483}); |
| let computePassEncoder87 = commandEncoder120.beginComputePass({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder34); computePassEncoder34.dispatchWorkgroupsIndirect(buffer81, 604); }; |
| } catch {} |
| try { |
| computePassEncoder83.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder14.setBindGroup(0, bindGroup34); |
| } catch {} |
| try { |
| renderPassEncoder29.setBindGroup(1, bindGroup18, new Uint32Array(20), 4, 0); |
| } catch {} |
| try { |
| commandEncoder118.copyBufferToTexture({ |
| /* bytesInLastRow: 36 widthInBlocks: 9 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1764 */ |
| offset: 1764, |
| rowsPerImage: 791, |
| buffer: buffer69, |
| }, { |
| texture: texture93, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 9, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| renderPassEncoder15.insertDebugMarker('\uc0bf'); |
| } catch {} |
| let bindGroupLayout13 = device0.createBindGroupLayout({ |
| label: '\ud0f5\u0ff0\ue979\ua61b\ud351\u13e6\u07d7\u592d\u63cc\u622b\u07e2', |
| entries: [ |
| {binding: 272, visibility: GPUShaderStage.VERTEX, buffer: { type: 'uniform', hasDynamicOffset: false }}, |
| ], |
| }); |
| let texture103 = device0.createTexture({ |
| size: [73, 1, 22], |
| dimension: '2d', |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let computePassEncoder88 = commandEncoder116.beginComputePass({}); |
| let sampler65 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| lodMinClamp: 41.22, |
| lodMaxClamp: 98.31, |
| }); |
| try { |
| computePassEncoder73.setBindGroup(3, bindGroup58); |
| } catch {} |
| try { |
| computePassEncoder17.setBindGroup(0, bindGroup3, new Uint32Array(745), 473, 0); |
| } catch {} |
| try { |
| renderPassEncoder26.setVertexBuffer(4, buffer50, 0); |
| } catch {} |
| try { |
| commandEncoder118.copyBufferToBuffer(buffer83, 2956, buffer62, 4660, 1472); |
| } catch {} |
| let canvas1 = document.createElement('canvas'); |
| let computePassEncoder89 = commandEncoder118.beginComputePass({}); |
| let renderPassEncoder46 = commandEncoder113.beginRenderPass({ |
| label: '\u5ed1\u0894\u24f2\u0e5c\u0450\uc30b\u{1ffe6}', |
| colorAttachments: [{view: textureView82, depthSlice: 7, loadOp: 'clear', storeOp: 'discard'}], |
| }); |
| try { |
| computePassEncoder17.setBindGroup(1, bindGroup44, new Uint32Array(1861), 526, 0); |
| } catch {} |
| try { |
| renderPassEncoder36.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder40.insertDebugMarker('\uf04f'); |
| } catch {} |
| let bindGroup64 = device0.createBindGroup({ |
| layout: bindGroupLayout5, |
| entries: [ |
| {binding: 62, resource: textureView102}, |
| {binding: 211, resource: sampler41}, |
| {binding: 86, resource: textureView17}, |
| ], |
| }); |
| let commandEncoder121 = device0.createCommandEncoder(); |
| let textureView103 = texture102.createView({baseMipLevel: 0}); |
| let textureView104 = texture23.createView({aspect: 'all', mipLevelCount: 1}); |
| let renderPassEncoder47 = commandEncoder121.beginRenderPass({ |
| colorAttachments: [{view: textureView5, loadOp: 'load', storeOp: 'store'}], |
| occlusionQuerySet: querySet12, |
| maxDrawCount: 125031860, |
| }); |
| try { |
| computePassEncoder45.setBindGroup(3, bindGroup58, new Uint32Array(26), 0, 0); |
| } catch {} |
| try { |
| computePassEncoder87.setPipeline(pipeline3); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 96, height: 1, depthOrArrayLayers: 131} |
| */ |
| { |
| source: img1, |
| origin: { x: 7, y: 17 }, |
| flipY: false, |
| }, { |
| texture: texture18, |
| mipLevel: 0, |
| origin: {x: 41, y: 0, z: 34}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| canvas1.getContext('2d'); |
| } catch {} |
| try { |
| renderPassEncoder36.setBindGroup(3, bindGroup55, new Uint32Array(2242), 787, 0); |
| } catch {} |
| try { |
| renderPassEncoder35.beginOcclusionQuery(144); |
| } catch {} |
| try { |
| renderPassEncoder35.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder20.setPipeline(pipeline1); |
| } catch {} |
| let bindGroup65 = device0.createBindGroup({ |
| layout: bindGroupLayout4, |
| entries: [{binding: 511, resource: {buffer: buffer50, offset: 256, size: 396}}], |
| }); |
| let commandEncoder122 = device0.createCommandEncoder({}); |
| let computePassEncoder90 = commandEncoder122.beginComputePass({}); |
| let sampler66 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 28.04, |
| maxAnisotropy: 7, |
| }); |
| try { |
| device0.queue.writeTexture({ |
| texture: texture11, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 102}, |
| aspect: 'all', |
| }, new Uint8Array(2_941).fill(64), /* required buffer size: 2_941 */ |
| {offset: 81, bytesPerRow: 130, rowsPerImage: 1}, {width: 7, height: 0, depthOrArrayLayers: 23}); |
| } catch {} |
| let bindGroup66 = device0.createBindGroup({ |
| layout: bindGroupLayout9, |
| entries: [ |
| {binding: 127, resource: sampler64}, |
| {binding: 96, resource: {buffer: buffer12, offset: 0}}, |
| {binding: 113, resource: sampler22}, |
| ], |
| }); |
| let commandEncoder123 = device0.createCommandEncoder({label: '\u{1ff8a}\u0e9b\u0b2c\u2215\ufea0\u5e77\u{1fc46}\u{1f9db}\u{1fcfd}'}); |
| let computePassEncoder91 = commandEncoder123.beginComputePass({label: '\u6068\u{1fa39}\ue857\u96c7'}); |
| let sampler67 = device0.createSampler({ |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 43.91, |
| }); |
| try { |
| renderPassEncoder35.setVertexBuffer(4, buffer24, 0, 171); |
| } catch {} |
| try { |
| buffer14.unmap(); |
| } catch {} |
| try { |
| computePassEncoder90.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder19.setBindGroup(1, bindGroup54); |
| } catch {} |
| try { |
| renderPassEncoder35.setBindGroup(2, bindGroup44, new Uint32Array(483), 36, 0); |
| } catch {} |
| let textureView105 = texture22.createView({ |
| label: '\u890f\u0596\u0322\ucf37\u{1f680}\u06d4\u{1f8d3}\u{1fdb7}\u{1f992}\u{1f96c}', |
| aspect: 'all', |
| arrayLayerCount: 1, |
| }); |
| try { |
| computePassEncoder89.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder4.setBindGroup(1, bindGroup0, new Uint32Array(810), 73, 0); |
| } catch {} |
| try { |
| renderPassEncoder26.executeBundles([renderBundle2]); |
| } catch {} |
| let arrayBuffer6 = buffer35.getMappedRange(40, 12); |
| try { |
| await buffer36.mapAsync(GPUMapMode.WRITE, 256, 444); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer9, 328, new Float32Array(1408), 629, 92); |
| } catch {} |
| await gc(); |
| let bindGroupLayout14 = device0.createBindGroupLayout({ |
| label: '\u0e5c\u0214\u7dbb', |
| entries: [ |
| { |
| binding: 172, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'float', multisampled: false }, |
| }, |
| { |
| binding: 57, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| { |
| binding: 153, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', minBindingSize: 0, hasDynamicOffset: false }, |
| }, |
| { |
| binding: 462, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 264, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| sampler: { type: 'comparison' }, |
| }, |
| { |
| binding: 9, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba8snorm', access: 'read-only', viewDimension: '2d' }, |
| }, |
| { |
| binding: 51, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 8, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '3d' }, |
| }, |
| { |
| binding: 67, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '1d' }, |
| }, |
| ], |
| }); |
| let querySet13 = device0.createQuerySet({label: '\u{1fc39}\u{1ff0d}\u3e83\u9553\u0a00\u559a', type: 'occlusion', count: 328}); |
| let texture104 = device0.createTexture({ |
| size: [64], |
| sampleCount: 1, |
| dimension: '1d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let externalTexture6 = device0.importExternalTexture({label: '\u0661\u455b\u01aa\u155c', source: videoFrame7}); |
| try { |
| computePassEncoder71.setBindGroup(0, bindGroup54, new Uint32Array(547), 22, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder50); computePassEncoder50.dispatchWorkgroupsIndirect(buffer50, 128); }; |
| } catch {} |
| try { |
| renderPassEncoder28.setBindGroup(2, bindGroup41); |
| } catch {} |
| try { |
| renderPassEncoder22.executeBundles([renderBundle4, renderBundle2, renderBundle2, renderBundle1, renderBundle4]); |
| } catch {} |
| try { |
| renderPassEncoder8.setIndexBuffer(buffer82, 'uint16', 352, 16); |
| } catch {} |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture83, |
| mipLevel: 0, |
| origin: {x: 19, y: 1, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(391).fill(136), /* required buffer size: 391 */ |
| {offset: 223, bytesPerRow: 4, rowsPerImage: 37}, {width: 1, height: 5, depthOrArrayLayers: 2}); |
| } catch {} |
| try { |
| adapter0.label = '\u{1faf5}\u96de\u037d\u5793\u3348\u0d2f\u{1f630}\u5f7d\u7aa1\u784e\u0f44'; |
| } catch {} |
| let texture105 = device0.createTexture({ |
| label: '\ud419\u6823\u06b3\u0489\u016a\u{1f914}', |
| size: [36, 1, 18], |
| dimension: '3d', |
| format: 'r32sint', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView106 = texture77.createView({label: '\u2a9e\u07e6\u376b\u0447\u3154', arrayLayerCount: 1}); |
| try { |
| computePassEncoder36.setBindGroup(0, bindGroup1); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(3, bindGroup13, new Uint32Array(772), 455, 0); |
| } catch {} |
| try { |
| renderPassEncoder15.setPipeline(pipeline1); |
| } catch {} |
| let textureView107 = texture105.createView({aspect: 'all'}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder73); computePassEncoder73.dispatchWorkgroupsIndirect(buffer42, 652); }; |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer82, 24, new DataView(new ArrayBuffer(8597)), 373, 284); |
| } catch {} |
| document.body.append(img1); |
| let bindGroup67 = device0.createBindGroup({ |
| layout: bindGroupLayout4, |
| entries: [{binding: 511, resource: {buffer: buffer11, offset: 1536, size: 8676}}], |
| }); |
| try { |
| computePassEncoder45.setBindGroup(0, bindGroup10, new Uint32Array(3487), 1_097, 0); |
| } catch {} |
| try { |
| renderPassEncoder23.setBindGroup(2, bindGroup48); |
| } catch {} |
| try { |
| renderPassEncoder19.setBlendConstant({ r: -883.5, g: -799.6, b: -355.9, a: -247.0, }); |
| } catch {} |
| try { |
| renderPassEncoder8.setViewport(2.001624356202766, 0.5402923408959516, 0.2707699341761901, 0.09136486904618263, 0.3554263047514914, 0.6216146109017195); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture103, |
| mipLevel: 0, |
| origin: {x: 11, y: 0, z: 3}, |
| aspect: 'all', |
| }, new Uint8Array(6_297).fill(170), /* required buffer size: 6_297 */ |
| {offset: 73, bytesPerRow: 389, rowsPerImage: 8}, {width: 18, height: 0, depthOrArrayLayers: 3}); |
| } catch {} |
| let bindGroup68 = device0.createBindGroup({ |
| layout: bindGroupLayout7, |
| entries: [ |
| {binding: 53, resource: externalTexture6}, |
| {binding: 54, resource: {buffer: buffer2, offset: 0, size: 1192}}, |
| ], |
| }); |
| try { |
| computePassEncoder79.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder4.setStencilReference(99); |
| } catch {} |
| let commandEncoder124 = device0.createCommandEncoder(); |
| try { |
| computePassEncoder74.setBindGroup(0, bindGroup47, new Uint32Array(1248), 70, 0); |
| } catch {} |
| try { |
| computePassEncoder91.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder32.setBindGroup(3, bindGroup41, new Uint32Array(1808), 1_490, 0); |
| } catch {} |
| try { |
| renderPassEncoder18.setIndexBuffer(buffer26, 'uint32', 204, 627); |
| } catch {} |
| try { |
| commandEncoder124.copyBufferToBuffer(buffer10, 4316, buffer53, 388, 376); |
| } catch {} |
| try { |
| commandEncoder124.copyBufferToTexture({ |
| /* bytesInLastRow: 348 widthInBlocks: 87 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 2968 */ |
| offset: 2968, |
| bytesPerRow: 19456, |
| rowsPerImage: 2195, |
| buffer: buffer10, |
| }, { |
| texture: texture55, |
| mipLevel: 0, |
| origin: {x: 203, y: 3, z: 0}, |
| aspect: 'all', |
| }, {width: 87, height: 63, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 96, height: 1, depthOrArrayLayers: 131} |
| */ |
| { |
| source: videoFrame4, |
| origin: { x: 1, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture18, |
| mipLevel: 0, |
| origin: {x: 27, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await promise9; |
| } catch {} |
| let commandEncoder125 = device0.createCommandEncoder(); |
| try { |
| computePassEncoder86.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder38.setVertexBuffer(5, buffer56, 0, 5_759); |
| } catch {} |
| try { |
| commandEncoder124.copyBufferToBuffer(buffer51, 308, buffer11, 3624, 8); |
| } catch {} |
| let videoFrame14 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA', timestamp: 0, colorSpace: { |
| fullRange: true, |
| matrix: 'bt709', |
| primaries: 'jedecP22Phosphors', |
| transfer: 'bt1361ExtendedColourGamut', |
| } }); |
| let commandEncoder126 = device0.createCommandEncoder({}); |
| let texture106 = device0.createTexture({ |
| size: {width: 64, height: 64, depthOrArrayLayers: 22}, |
| mipLevelCount: 2, |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView108 = texture46.createView({}); |
| try { |
| computePassEncoder5.setBindGroup(3, bindGroup17); |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(3, bindGroup5, new Uint32Array(2454), 139, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(2, buffer6, 0); |
| } catch {} |
| try { |
| commandEncoder125.copyBufferToTexture({ |
| /* bytesInLastRow: 8 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 80 */ |
| offset: 80, |
| bytesPerRow: 256, |
| rowsPerImage: 265, |
| buffer: buffer47, |
| }, { |
| texture: texture94, |
| mipLevel: 1, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let textureView109 = texture105.createView({aspect: 'all'}); |
| let texture107 = gpuCanvasContext1.getCurrentTexture(); |
| let textureView110 = texture0.createView({dimension: '2d', aspect: 'all', mipLevelCount: 1}); |
| let renderPassEncoder48 = commandEncoder125.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView65, |
| clearValue: { r: 905.8, g: -913.3, b: -197.5, a: 513.1, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| computePassEncoder50.setBindGroup(2, bindGroup66, []); |
| } catch {} |
| try { |
| computePassEncoder88.setPipeline(pipeline2); |
| } catch {} |
| let texture108 = device0.createTexture({ |
| size: {width: 295, height: 1, depthOrArrayLayers: 123}, |
| sampleCount: 1, |
| format: 'depth24plus', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder40.setBindGroup(0, bindGroup23, new Uint32Array(452), 170, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.setBindGroup(2, bindGroup49); |
| } catch {} |
| try { |
| renderPassEncoder48.setBindGroup(3, bindGroup13, new Uint32Array(860), 83, 0); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| document.body.prepend(img2); |
| let commandEncoder127 = device0.createCommandEncoder({}); |
| let computePassEncoder92 = commandEncoder127.beginComputePass(); |
| let sampler68 = device0.createSampler({ |
| label: '\u0f63\u05b8\udaf2\u{1fd4a}\ub08f\u{1fa34}', |
| addressModeU: 'repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 15.70, |
| maxAnisotropy: 15, |
| }); |
| try { |
| computePassEncoder30.setBindGroup(2, bindGroup42, new Uint32Array(4595), 1_427, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder36); computePassEncoder36.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder29.setBindGroup(0, bindGroup28, new Uint32Array(278), 3, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.setScissorRect(0, 0, 17, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.setVertexBuffer(2, buffer51, 16); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer54, 2576, new Int16Array(4114)); |
| } catch {} |
| let buffer88 = device0.createBuffer({size: 14067, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM}); |
| let texture109 = device0.createTexture({ |
| size: {width: 440}, |
| dimension: '1d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let sampler69 = device0.createSampler({ |
| label: '\ue96a\u0b92\u{1f72f}\ufa45\u0cce\u3e34\u003d\u01d4\u{1fc47}\u0c0d', |
| addressModeU: 'repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'nearest', |
| lodMinClamp: 54.27, |
| lodMaxClamp: 54.76, |
| }); |
| let externalTexture7 = device0.importExternalTexture({source: videoFrame14}); |
| try { |
| computePassEncoder75.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder14.setIndexBuffer(buffer86, 'uint16', 868, 62); |
| } catch {} |
| try { |
| renderPassEncoder43.setVertexBuffer(2, buffer67, 0); |
| } catch {} |
| try { |
| await shaderModule4.getCompilationInfo(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 96, height: 1, depthOrArrayLayers: 131} |
| */ |
| { |
| source: imageData3, |
| origin: { x: 10, y: 6 }, |
| flipY: true, |
| }, { |
| texture: texture18, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 13, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder128 = device0.createCommandEncoder({}); |
| let texture110 = device0.createTexture({ |
| size: [295, 1, 19], |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder93 = commandEncoder128.beginComputePass({}); |
| let renderPassEncoder49 = commandEncoder126.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView5, |
| clearValue: { r: 975.3, g: -343.2, b: 272.8, a: 388.6, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| maxDrawCount: 61360249, |
| }); |
| try { |
| computePassEncoder92.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(2, bindGroup6); |
| } catch {} |
| try { |
| renderPassEncoder29.setIndexBuffer(buffer70, 'uint16', 2_248, 4_135); |
| } catch {} |
| try { |
| commandEncoder124.copyBufferToTexture({ |
| /* bytesInLastRow: 1024 widthInBlocks: 128 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 440 */ |
| offset: 440, |
| buffer: buffer34, |
| }, { |
| texture: texture38, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 128, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let promise11 = device0.queue.onSubmittedWorkDone(); |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 73, height: 1, depthOrArrayLayers: 54} |
| */ |
| { |
| source: videoFrame13, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture5, |
| mipLevel: 0, |
| origin: {x: 14, y: 0, z: 13}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| await gc(); |
| let videoFrame15 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-cl', primaries: 'bt470bg', transfer: 'linear'} }); |
| let commandEncoder129 = device0.createCommandEncoder({}); |
| let computePassEncoder94 = commandEncoder129.beginComputePass(); |
| let renderPassEncoder50 = commandEncoder124.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView74, |
| depthSlice: 173, |
| clearValue: { r: 449.7, g: -522.6, b: -477.7, a: 456.4, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| computePassEncoder75.setBindGroup(1, bindGroup19, new Uint32Array(154), 37, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder50); computePassEncoder50.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| renderPassEncoder12.setBindGroup(3, bindGroup68); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let imageBitmap0 = await createImageBitmap(imageData8); |
| let commandEncoder130 = device0.createCommandEncoder({}); |
| let textureView111 = texture88.createView({label: '\ua34e\u{1f622}\u02ac\u{1fd60}\u3f76\u8c17\u1388', dimension: '2d-array'}); |
| try { |
| computePassEncoder81.setBindGroup(2, bindGroup49); |
| } catch {} |
| try { |
| computePassEncoder37.setBindGroup(0, bindGroup55, new Uint32Array(3313), 382, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder38); computePassEncoder38.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder93.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder11.setBindGroup(1, bindGroup5, new Uint32Array(2070), 11, 0); |
| } catch {} |
| try { |
| renderPassEncoder28.executeBundles([renderBundle1]); |
| } catch {} |
| try { |
| renderPassEncoder4.setVertexBuffer(5, buffer10, 1_320, 1_975); |
| } catch {} |
| try { |
| computePassEncoder94.pushDebugGroup('\u0c9f'); |
| } catch {} |
| try { |
| computePassEncoder71.insertDebugMarker('\ua8b9'); |
| } catch {} |
| let texture111 = gpuCanvasContext1.getCurrentTexture(); |
| let textureView112 = texture30.createView({format: 'rgba16sint', mipLevelCount: 1, baseArrayLayer: 0}); |
| let computePassEncoder95 = commandEncoder130.beginComputePass(); |
| try { |
| computePassEncoder85.setBindGroup(1, bindGroup35); |
| } catch {} |
| try { |
| renderPassEncoder33.setBindGroup(0, bindGroup61); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 295, height: 1, depthOrArrayLayers: 19} |
| */ |
| { |
| source: videoFrame7, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture110, |
| mipLevel: 0, |
| origin: {x: 16, y: 0, z: 3}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture112 = device0.createTexture({ |
| size: {width: 48, height: 1, depthOrArrayLayers: 22}, |
| dimension: '2d', |
| format: 'depth24plus', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView113 = texture45.createView({dimension: '2d-array', mipLevelCount: 1}); |
| try { |
| computePassEncoder71.setBindGroup(1, bindGroup4); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder30); computePassEncoder30.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder36); computePassEncoder36.dispatchWorkgroupsIndirect(buffer15, 3_360); }; |
| } catch {} |
| try { |
| computePassEncoder82.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder17.setIndexBuffer(buffer15, 'uint16', 286, 185); |
| } catch {} |
| try { |
| renderPassEncoder34.setVertexBuffer(5, buffer62, 2_384); |
| } catch {} |
| let bindGroup69 = device0.createBindGroup({ |
| label: '\u0739\uaa34\uf8d1\u6217\u0477\u0abf\u{1ff60}\u4fd0\u7aa8\u05a6\ud439', |
| layout: bindGroupLayout13, |
| entries: [{binding: 272, resource: {buffer: buffer64, offset: 512, size: 192}}], |
| }); |
| try { |
| computePassEncoder16.setBindGroup(3, bindGroup66, new Uint32Array(2333), 1_160, 0); |
| } catch {} |
| try { |
| computePassEncoder95.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder14.setBindGroup(1, bindGroup24, []); |
| } catch {} |
| document.body.prepend(img1); |
| let bindGroup70 = device0.createBindGroup({layout: bindGroupLayout12, entries: [{binding: 39, resource: textureView103}]}); |
| let pipelineLayout6 = device0.createPipelineLayout({label: '\ue5e9\u0ded', bindGroupLayouts: [bindGroupLayout3]}); |
| let sampler70 = device0.createSampler({ |
| label: '\u{1f6bc}\u{1fede}\udf20\uf8d1\u3c1c\ucff7\u0fe6\u043f', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 29.57, |
| }); |
| try { |
| renderPassEncoder4.beginOcclusionQuery(32); |
| } catch {} |
| try { |
| buffer26.unmap(); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let commandEncoder131 = device0.createCommandEncoder(); |
| let texture113 = device0.createTexture({ |
| size: [64], |
| dimension: '1d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder96 = commandEncoder131.beginComputePass({label: '\u{1ffe2}\uc5df\u{1faa6}\u0f82\u0164\uc92a\u3191\u0ab6\u94a3\u8fb7'}); |
| try { |
| computePassEncoder47.setBindGroup(0, bindGroup37); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder61); computePassEncoder61.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder34); computePassEncoder34.dispatchWorkgroupsIndirect(buffer64, 260); }; |
| } catch {} |
| try { |
| computePassEncoder94.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder29.setIndexBuffer(buffer82, 'uint16', 0, 102); |
| } catch {} |
| try { |
| renderPassEncoder5.setVertexBuffer(4, buffer87, 560, 484); |
| } catch {} |
| try { |
| buffer83.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture70, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(143).fill(115), /* required buffer size: 143 */ |
| {offset: 143}, {width: 9, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| try { |
| bindGroup61.label = '\u0c7d\u0d3d\u68e1'; |
| } catch {} |
| let bindGroup71 = device0.createBindGroup({layout: bindGroupLayout10, entries: [{binding: 5, resource: sampler32}]}); |
| try { |
| renderPassEncoder3.setBindGroup(2, bindGroup4); |
| } catch {} |
| try { |
| renderPassEncoder4.setIndexBuffer(buffer15, 'uint16', 6_948, 994); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer52, 124, new BigUint64Array(1951), 224, 48); |
| } catch {} |
| let bindGroup72 = device0.createBindGroup({ |
| layout: bindGroupLayout3, |
| entries: [ |
| {binding: 225, resource: textureView39}, |
| {binding: 58, resource: {buffer: buffer44, offset: 0, size: 6001}}, |
| ], |
| }); |
| let commandEncoder132 = device0.createCommandEncoder({}); |
| let computePassEncoder97 = commandEncoder132.beginComputePass({label: '\u0152\u90a8\u016d\u{1f65e}\ub71c\u3386\u{1fbe6}\u6455'}); |
| try { |
| computePassEncoder40.setBindGroup(3, bindGroup52); |
| } catch {} |
| try { |
| computePassEncoder67.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder4.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder43.setVertexBuffer(1, buffer8, 92, 295); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer22, 920, new Float32Array(308)); |
| } catch {} |
| let sampler71 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| lodMinClamp: 93.68, |
| lodMaxClamp: 97.71, |
| compare: 'not-equal', |
| }); |
| try { |
| computePassEncoder80.setBindGroup(2, bindGroup4, new Uint32Array(5279), 539, 0); |
| } catch {} |
| try { |
| renderPassEncoder38.setVertexBuffer(2, buffer51); |
| } catch {} |
| let arrayBuffer7 = buffer35.getMappedRange(56, 52); |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| let textureView114 = texture63.createView({dimension: '2d-array'}); |
| let sampler72 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| }); |
| try { |
| computePassEncoder17.setBindGroup(3, bindGroup47); |
| } catch {} |
| try { |
| computePassEncoder47.setBindGroup(0, bindGroup16, new Uint32Array(2313), 205, 0); |
| } catch {} |
| try { |
| renderPassEncoder47.beginOcclusionQuery(40); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer81, 436, new Int16Array(2032)); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture8, |
| mipLevel: 0, |
| origin: {x: 9, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(375).fill(80), /* required buffer size: 375 */ |
| {offset: 375}, {width: 4, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup73 = device0.createBindGroup({ |
| layout: bindGroupLayout3, |
| entries: [ |
| {binding: 58, resource: {buffer: buffer81, offset: 512, size: 4363}}, |
| {binding: 225, resource: textureView108}, |
| ], |
| }); |
| let commandEncoder133 = device0.createCommandEncoder({}); |
| let externalTexture8 = device0.importExternalTexture({source: videoFrame3}); |
| try { |
| computePassEncoder73.end(); |
| } catch {} |
| try { |
| renderPassEncoder19.setBindGroup(0, bindGroup65); |
| } catch {} |
| try { |
| renderPassEncoder24.setBindGroup(1, bindGroup54, new Uint32Array(2303), 55, 0); |
| } catch {} |
| try { |
| renderPassEncoder47.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder15.executeBundles([renderBundle2, renderBundle1, renderBundle1]); |
| } catch {} |
| try { |
| renderPassEncoder14.setIndexBuffer(buffer82, 'uint16', 532, 50); |
| } catch {} |
| document.body.prepend(canvas1); |
| let renderPassEncoder51 = commandEncoder101.beginRenderPass({ |
| label: '\u0984\u{1ffde}\u07d7', |
| colorAttachments: [{ |
| view: textureView98, |
| clearValue: { r: 242.7, g: 606.4, b: 510.5, a: 425.1, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| maxDrawCount: 1234567890, |
| }); |
| let sampler73 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'repeat', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMaxClamp: 93.17, |
| maxAnisotropy: 1, |
| }); |
| try { |
| computePassEncoder20.setBindGroup(0, bindGroup60); |
| } catch {} |
| try { |
| computePassEncoder38.end(); |
| } catch {} |
| try { |
| renderPassEncoder44.setBindGroup(1, bindGroup39); |
| } catch {} |
| try { |
| renderPassEncoder7.setViewport(26.28884470204025, 0.1542674133054449, 6.686596033944005, 0.11837418827153506, 0.40984960444539853, 0.9403904667974389); |
| } catch {} |
| try { |
| renderPassEncoder48.setIndexBuffer(buffer23, 'uint16', 4_748, 2_119); |
| } catch {} |
| try { |
| buffer1.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| viewFormats: [], |
| }); |
| } catch {} |
| let promise12 = device0.queue.onSubmittedWorkDone(); |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let buffer89 = device0.createBuffer({ |
| size: 2246, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder134 = device0.createCommandEncoder({}); |
| let commandBuffer6 = commandEncoder54.finish(); |
| let textureView115 = texture45.createView({dimension: '2d-array', mipLevelCount: 1}); |
| let computePassEncoder98 = commandEncoder133.beginComputePass(); |
| let renderPassEncoder52 = commandEncoder134.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView52, |
| clearValue: { r: 213.5, g: -46.41, b: 181.3, a: -637.9, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet11, |
| }); |
| try { |
| renderPassEncoder17.setBindGroup(2, bindGroup52); |
| } catch {} |
| try { |
| renderPassEncoder7.beginOcclusionQuery(101); |
| } catch {} |
| try { |
| renderPassEncoder35.setIndexBuffer(buffer62, 'uint16', 320, 878); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let imageBitmap1 = await createImageBitmap(videoFrame14); |
| let bindGroup74 = device0.createBindGroup({ |
| label: '\u{1f600}\ucf3b\u0e9d\u09f6\u03f6\u161a', |
| layout: bindGroupLayout0, |
| entries: [{binding: 103, resource: textureView59}, {binding: 176, resource: textureView99}], |
| }); |
| let buffer90 = device0.createBuffer({ |
| size: 2054, |
| usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE, |
| mappedAtCreation: false, |
| }); |
| let texture114 = device0.createTexture({ |
| size: {width: 73}, |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler74 = device0.createSampler({ |
| label: '\u0dd6\u{1f9fc}\u6771\u2353\ucf81\ubcaa', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 5.891, |
| lodMaxClamp: 21.52, |
| maxAnisotropy: 13, |
| }); |
| try { |
| computePassEncoder62.setBindGroup(2, bindGroup25); |
| } catch {} |
| try { |
| computePassEncoder98.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder25.setBindGroup(1, bindGroup49); |
| } catch {} |
| try { |
| renderPassEncoder50.executeBundles([renderBundle5, renderBundle3, renderBundle0, renderBundle5, renderBundle5]); |
| } catch {} |
| try { |
| device0.pushErrorScope('validation'); |
| } catch {} |
| try { |
| computePassEncoder94.popDebugGroup(); |
| } catch {} |
| let videoFrame16 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt709', primaries: 'bt2020', transfer: 'unspecified'} }); |
| let commandEncoder135 = device0.createCommandEncoder({}); |
| let texture115 = device0.createTexture({ |
| size: {width: 295, height: 1, depthOrArrayLayers: 1}, |
| sampleCount: 4, |
| format: 'depth24plus', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| computePassEncoder96.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(1, bindGroup11); |
| } catch {} |
| try { |
| renderPassEncoder44.setBindGroup(2, bindGroup31, new Uint32Array(142), 28, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder31.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder42.setVertexBuffer(6, buffer59, 480, 295); |
| } catch {} |
| let arrayBuffer8 = buffer36.getMappedRange(256, 120); |
| try { |
| commandEncoder135.copyTextureToTexture({ |
| texture: texture14, |
| mipLevel: 0, |
| origin: {x: 27, y: 0, z: 4}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture78, |
| mipLevel: 2, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 6, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder135.clearBuffer(buffer18, 1480, 240); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture89, |
| mipLevel: 0, |
| origin: {x: 23, y: 0, z: 2}, |
| aspect: 'all', |
| }, new Uint8Array(200).fill(79), /* required buffer size: 200 */ |
| {offset: 200, bytesPerRow: 311}, {width: 38, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let bindGroup75 = device0.createBindGroup({layout: bindGroupLayout1, entries: [{binding: 277, resource: sampler58}]}); |
| let textureView116 = texture28.createView({dimension: '2d-array', aspect: 'stencil-only', baseMipLevel: 0}); |
| let computePassEncoder99 = commandEncoder135.beginComputePass({}); |
| try { |
| computePassEncoder99.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder43.setVertexBuffer(4, buffer56, 0); |
| } catch {} |
| let videoFrame17 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX', timestamp: 0, colorSpace: {fullRange: false, matrix: 'yCgCo', primaries: 'smpte170m', transfer: 'log'} }); |
| let bindGroup76 = device0.createBindGroup({ |
| layout: bindGroupLayout13, |
| entries: [{binding: 272, resource: {buffer: buffer82, offset: 0, size: 358}}], |
| }); |
| let buffer91 = device0.createBuffer({ |
| size: 15459, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder136 = device0.createCommandEncoder({label: '\udd70\u087a\u02e1'}); |
| let textureView117 = texture65.createView({label: '\u0660\u07cc\u6451\uea8f', format: 'rgb10a2uint', baseArrayLayer: 5, arrayLayerCount: 6}); |
| let sampler75 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 26.33, |
| maxAnisotropy: 5, |
| }); |
| let externalTexture9 = device0.importExternalTexture({source: videoFrame5}); |
| try { |
| renderPassEncoder38.setBindGroup(2, bindGroup45); |
| } catch {} |
| try { |
| renderPassEncoder21.setVertexBuffer(7, buffer87, 1_156, 459); |
| } catch {} |
| try { |
| commandEncoder136.resolveQuerySet(querySet6, 17, 7, buffer24, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer11, 420, new DataView(new ArrayBuffer(12935)), 3086, 1144); |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let bindGroup77 = device0.createBindGroup({ |
| label: '\u773b\u0b85\u8629\ucd51\u032d\u{1f7a8}\u4553', |
| layout: bindGroupLayout14, |
| entries: [ |
| {binding: 462, resource: {buffer: buffer64, offset: 512}}, |
| {binding: 172, resource: textureView110}, |
| {binding: 51, resource: {buffer: buffer76, offset: 3584}}, |
| {binding: 9, resource: textureView14}, |
| {binding: 67, resource: textureView10}, |
| {binding: 264, resource: sampler71}, |
| {binding: 153, resource: {buffer: buffer12, offset: 0}}, |
| {binding: 8, resource: textureView107}, |
| {binding: 57, resource: textureView91}, |
| ], |
| }); |
| let computePassEncoder100 = commandEncoder136.beginComputePass({}); |
| let promise13 = device0.queue.onSubmittedWorkDone(); |
| let commandEncoder137 = device0.createCommandEncoder({}); |
| let renderPassEncoder53 = commandEncoder137.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView31, |
| clearValue: { r: 77.30, g: -133.6, b: -617.6, a: 164.9, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| }); |
| let externalTexture10 = device0.importExternalTexture({ |
| label: '\u6775\u8e70\u34b7\u7801\u8133\ud1c5\u0136\u{1fc2c}\u096f\u7d74', |
| source: videoFrame10, |
| colorSpace: 'srgb', |
| }); |
| try { |
| computePassEncoder74.setBindGroup(2, bindGroup12, new Uint32Array(4886), 296, 0); |
| } catch {} |
| try { |
| renderPassEncoder53.setIndexBuffer(buffer43, 'uint16', 600, 573); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| let bindGroup78 = device0.createBindGroup({ |
| label: '\ud640\ub2d3\u0426\u{1f858}\ue5ff\u{1fc22}\u{1fcaf}', |
| layout: bindGroupLayout14, |
| entries: [ |
| {binding: 264, resource: sampler9}, |
| {binding: 51, resource: {buffer: buffer15, offset: 512}}, |
| {binding: 153, resource: {buffer: buffer15, offset: 1024}}, |
| {binding: 8, resource: textureView109}, |
| {binding: 9, resource: textureView14}, |
| {binding: 57, resource: textureView14}, |
| {binding: 172, resource: textureView30}, |
| {binding: 462, resource: {buffer: buffer87, offset: 0, size: 2932}}, |
| {binding: 67, resource: textureView11}, |
| ], |
| }); |
| let buffer92 = device0.createBuffer({ |
| size: 5397, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE, |
| mappedAtCreation: false, |
| }); |
| try { |
| computePassEncoder83.setBindGroup(3, bindGroup55); |
| } catch {} |
| try { |
| computePassEncoder100.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder35.setBindGroup(0, bindGroup11, new Uint32Array(2026), 444, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.setVertexBuffer(3, buffer2); |
| } catch {} |
| document.body.prepend(img0); |
| await gc(); |
| let commandEncoder138 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder97.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder4.setIndexBuffer(buffer84, 'uint16', 1_784, 1_350); |
| } catch {} |
| try { |
| commandEncoder138.copyTextureToBuffer({ |
| texture: texture84, |
| mipLevel: 0, |
| origin: {x: 8, y: 1, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 188 widthInBlocks: 47 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 4476 */ |
| offset: 4476, |
| bytesPerRow: 17152, |
| buffer: buffer76, |
| }, {width: 47, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer93 = device0.createBuffer({size: 6333, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM}); |
| let texture116 = device0.createTexture({ |
| size: [192, 1, 30], |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView118 = texture13.createView({}); |
| let computePassEncoder101 = commandEncoder138.beginComputePass({}); |
| let sampler76 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 85.38, |
| compare: 'greater-equal', |
| }); |
| try { |
| computePassEncoder31.setBindGroup(0, bindGroup24); |
| } catch {} |
| try { |
| computePassEncoder90.setBindGroup(0, bindGroup39, new Uint32Array(680), 52, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(3, bindGroup47, new Uint32Array(970), 10, 0); |
| } catch {} |
| try { |
| computePassEncoder17.setBindGroup(0, bindGroup7); |
| } catch {} |
| try { |
| computePassEncoder101.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder20.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder37.setVertexBuffer(7, buffer83, 6_944); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 73, height: 1, depthOrArrayLayers: 54} |
| */ |
| { |
| source: videoFrame2, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture5, |
| mipLevel: 0, |
| origin: {x: 4, y: 0, z: 1}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup79 = device0.createBindGroup({ |
| layout: bindGroupLayout0, |
| entries: [{binding: 103, resource: textureView3}, {binding: 176, resource: textureView8}], |
| }); |
| let commandEncoder139 = device0.createCommandEncoder({}); |
| let textureView119 = texture34.createView({baseArrayLayer: 1, arrayLayerCount: 7}); |
| try { |
| computePassEncoder36.setBindGroup(1, bindGroup35, new Uint32Array(1319), 285, 0); |
| } catch {} |
| try { |
| await promise11; |
| } catch {} |
| await gc(); |
| let imageData13 = new ImageData(48, 68); |
| let buffer94 = device0.createBuffer({ |
| label: '\u089e\u83d3\u6d6c\u07bf\u033a', |
| size: 2557, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let texture117 = device0.createTexture({ |
| size: [73], |
| dimension: '1d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| viewFormats: [], |
| }); |
| let computePassEncoder102 = commandEncoder139.beginComputePass({label: '\ubd5f\u0b77\u8d1d\u0034\ua700\u3d3a\u{1fd80}\u5bf2\ucf1e\u678d\u{1fa1c}'}); |
| try { |
| computePassEncoder34.setBindGroup(0, bindGroup8); |
| } catch {} |
| try { |
| computePassEncoder102.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder38.setIndexBuffer(buffer81, 'uint32', 804, 948); |
| } catch {} |
| try { |
| computePassEncoder5.setBindGroup(0, bindGroup7); |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(0, bindGroup74); |
| } catch {} |
| let bindGroupLayout15 = device0.createBindGroupLayout({ |
| entries: [{binding: 44, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, externalTexture: {}}], |
| }); |
| let textureView120 = texture40.createView({dimension: '2d-array'}); |
| try { |
| computePassEncoder19.setBindGroup(1, bindGroup27); |
| } catch {} |
| try { |
| renderPassEncoder29.setIndexBuffer(buffer62, 'uint32', 7_268, 4_493); |
| } catch {} |
| try { |
| renderPassEncoder11.setPipeline(pipeline1); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 73, height: 1, depthOrArrayLayers: 54} |
| */ |
| { |
| source: videoFrame5, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture5, |
| mipLevel: 0, |
| origin: {x: 15, y: 0, z: 1}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| document.body.prepend(img1); |
| try { |
| adapter0.label = '\u7fe3\u73c6\uc5b5\u83de\u5ef8\uee55\uf9e4'; |
| } catch {} |
| let sampler77 = device0.createSampler({ |
| label: '\u{1fae2}\u9f2e\u92f6\u{1fb66}\u0f42\udc3d\u{1f73d}\udbae\udb26\ubda3', |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 96.41, |
| maxAnisotropy: 15, |
| }); |
| try { |
| computePassEncoder87.setBindGroup(2, bindGroup73); |
| } catch {} |
| try { |
| renderPassEncoder40.setBindGroup(2, bindGroup69, []); |
| } catch {} |
| let bindGroup80 = device0.createBindGroup({layout: bindGroupLayout6, entries: [{binding: 11, resource: {buffer: buffer76, offset: 6912}}]}); |
| let sampler78 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 45.80, |
| lodMaxClamp: 76.30, |
| maxAnisotropy: 10, |
| }); |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 96, height: 1, depthOrArrayLayers: 131} |
| */ |
| { |
| source: videoFrame16, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture18, |
| mipLevel: 0, |
| origin: {x: 18, y: 0, z: 4}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder140 = device0.createCommandEncoder({label: '\u{1f9a4}\u3563\u0be6\ud55d\u{1f93f}\u0632\u0014\u{1f917}\u{1f8a1}'}); |
| let texture118 = device0.createTexture({ |
| size: [110, 10, 26], |
| mipLevelCount: 2, |
| format: 'depth24plus', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let computePassEncoder103 = commandEncoder140.beginComputePass({}); |
| try { |
| computePassEncoder100.setBindGroup(0, bindGroup8, new Uint32Array(397), 31, 0); |
| } catch {} |
| try { |
| computePassEncoder103.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder2.setBindGroup(3, bindGroup10); |
| } catch {} |
| try { |
| renderPassEncoder24.setBindGroup(0, bindGroup18, new Uint32Array(139), 9, 0); |
| } catch {} |
| try { |
| renderPassEncoder18.setViewport(11.721937547712768, 4.254930791749911, 14.858393419905648, 41.75300153661143, 0.4697011585202099, 0.7269280835744327); |
| } catch {} |
| try { |
| renderPassEncoder16.setIndexBuffer(buffer21, 'uint16', 4_366, 45); |
| } catch {} |
| try { |
| await promise13; |
| } catch {} |
| let texture119 = device0.createTexture({ |
| size: [147, 1, 16], |
| mipLevelCount: 2, |
| dimension: '2d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder98.setBindGroup(2, bindGroup68); |
| } catch {} |
| try { |
| renderPassEncoder39.setBindGroup(0, bindGroup75, new Uint32Array(3052), 1_982, 0); |
| } catch {} |
| try { |
| renderPassEncoder52.setIndexBuffer(buffer80, 'uint32', 1_076, 10_696); |
| } catch {} |
| try { |
| await promise10; |
| } catch {} |
| let bindGroup81 = device0.createBindGroup({ |
| layout: bindGroupLayout11, |
| entries: [{binding: 57, resource: textureView22}, {binding: 52, resource: textureView17}], |
| }); |
| let commandEncoder141 = device0.createCommandEncoder({}); |
| let renderPassEncoder54 = commandEncoder141.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView94, |
| clearValue: { r: 600.0, g: 23.14, b: -184.8, a: -709.8, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet13, |
| }); |
| let sampler79 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'nearest', |
| lodMinClamp: 0.7821, |
| lodMaxClamp: 46.20, |
| compare: 'less', |
| }); |
| try { |
| computePassEncoder30.end(); |
| } catch {} |
| try { |
| renderPassEncoder40.setBindGroup(1, bindGroup37); |
| } catch {} |
| try { |
| renderPassEncoder11.executeBundles([renderBundle1]); |
| } catch {} |
| try { |
| renderPassEncoder27.setPipeline(pipeline1); |
| } catch {} |
| try { |
| commandEncoder43.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 688 */ |
| offset: 688, |
| bytesPerRow: 3584, |
| rowsPerImage: 1542, |
| buffer: buffer4, |
| }, { |
| texture: texture20, |
| mipLevel: 2, |
| origin: {x: 7, y: 0, z: 8}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder43.copyTextureToBuffer({ |
| texture: texture8, |
| mipLevel: 0, |
| origin: {x: 5, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 64 widthInBlocks: 8 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 1624 */ |
| offset: 1624, |
| bytesPerRow: 8448, |
| buffer: buffer92, |
| }, {width: 8, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer95 = device0.createBuffer({ |
| size: 20654, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| try { |
| renderPassEncoder4.setBindGroup(3, bindGroup51); |
| } catch {} |
| try { |
| commandEncoder43.copyBufferToTexture({ |
| /* bytesInLastRow: 12 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 80 */ |
| offset: 80, |
| bytesPerRow: 9728, |
| buffer: buffer95, |
| }, { |
| texture: texture79, |
| mipLevel: 2, |
| origin: {x: 5, y: 6, z: 0}, |
| aspect: 'all', |
| }, {width: 3, height: 20, depthOrArrayLayers: 0}); |
| } catch {} |
| let computePassEncoder104 = commandEncoder43.beginComputePass({}); |
| try { |
| computePassEncoder29.setBindGroup(3, bindGroup44, new Uint32Array(713), 4, 0); |
| } catch {} |
| try { |
| renderPassEncoder31.executeBundles([renderBundle1]); |
| } catch {} |
| try { |
| await promise12; |
| } catch {} |
| let bindGroup82 = device0.createBindGroup({layout: bindGroupLayout10, entries: [{binding: 5, resource: sampler61}]}); |
| let commandEncoder142 = device0.createCommandEncoder({}); |
| let renderPassEncoder55 = commandEncoder142.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView99, |
| depthSlice: 1, |
| clearValue: { r: -844.5, g: 741.0, b: -202.9, a: 38.24, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| maxDrawCount: 32962157, |
| }); |
| try { |
| computePassEncoder104.setPipeline(pipeline2); |
| } catch {} |
| let bindGroupLayout16 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 0, visibility: GPUShaderStage.FRAGMENT, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| ], |
| }); |
| let buffer96 = device0.createBuffer({size: 19798, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let texture120 = device0.createTexture({ |
| size: {width: 140, height: 145, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'depth24plus', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder78.setBindGroup(0, bindGroup58, new Uint32Array(1699), 1_072, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder34); computePassEncoder34.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| renderPassEncoder7.beginOcclusionQuery(15); |
| } catch {} |
| try { |
| renderPassEncoder44.executeBundles([renderBundle6, renderBundle6, renderBundle6]); |
| } catch {} |
| try { |
| renderPassEncoder44.setVertexBuffer(0, buffer6); |
| } catch {} |
| try { |
| renderPassEncoder54.setBlendConstant({ r: 348.5, g: -990.4, b: 2.658, a: -196.0, }); |
| } catch {} |
| try { |
| renderPassEncoder7.setIndexBuffer(buffer84, 'uint16', 10_466, 3_308); |
| } catch {} |
| try { |
| renderPassEncoder32.setVertexBuffer(2, buffer43, 1_152, 101); |
| } catch {} |
| let pipeline4 = device0.createComputePipeline({layout: pipelineLayout0, compute: {module: shaderModule5, constants: {}}}); |
| let imageData14 = new ImageData(4, 8); |
| let bindGroup83 = device0.createBindGroup({ |
| layout: bindGroupLayout2, |
| entries: [ |
| {binding: 999, resource: textureView79}, |
| {binding: 132, resource: textureView48}, |
| {binding: 567, resource: textureView30}, |
| {binding: 243, resource: textureView57}, |
| {binding: 94, resource: textureView60}, |
| {binding: 421, resource: {buffer: buffer76, offset: 9472}}, |
| {binding: 398, resource: textureView57}, |
| {binding: 42, resource: externalTexture1}, |
| {binding: 35, resource: textureView10}, |
| ], |
| }); |
| let commandEncoder143 = device0.createCommandEncoder({}); |
| let sampler80 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'nearest', |
| lodMaxClamp: 99.20, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder61); computePassEncoder61.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder54.setBindGroup(2, bindGroup17); |
| } catch {} |
| try { |
| renderPassEncoder12.setIndexBuffer(buffer91, 'uint16', 1_810, 2_157); |
| } catch {} |
| try { |
| renderPassEncoder15.setPipeline(pipeline1); |
| } catch {} |
| let bindGroup84 = device0.createBindGroup({ |
| layout: bindGroupLayout0, |
| entries: [{binding: 176, resource: textureView99}, {binding: 103, resource: textureView44}], |
| }); |
| let commandEncoder144 = device0.createCommandEncoder(); |
| try { |
| computePassEncoder78.setBindGroup(2, bindGroup41); |
| } catch {} |
| try { |
| renderPassEncoder7.endOcclusionQuery(); |
| } catch {} |
| try { |
| computePassEncoder58.insertDebugMarker('\u0c22'); |
| } catch {} |
| let shaderModule11 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| enable f16; |
| |
| requires readonly_and_readwrite_storage_textures; |
| |
| diagnostic(info, xyz); |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| @group(0) @binding(103) var st20: texture_storage_3d<rgba8unorm, write>; |
| |
| @group(0) @binding(176) var st21: texture_storage_3d<rgba16uint, write>; |
| |
| struct T0 { |
| @align(256) @size(1024) f0: atomic<u32>, |
| } |
| |
| struct T1 { |
| @align(8) @size(8) f0: array<u32>, |
| } |
| |
| struct T2 { |
| @align(16) @size(16) f0: array<atomic<u32>>, |
| } |
| |
| struct T3 { |
| @size(8) f0: atomic<i32>, |
| } |
| |
| struct VertexOutput10 { |
| @builtin(position) f36: vec4f, |
| } |
| |
| override override4 = 0.3008; |
| |
| override override5 = true; |
| |
| override override6 = true; |
| |
| var<workgroup> vw46: T3; |
| |
| var<workgroup> vw47: atomic<u32>; |
| |
| var<workgroup> vw48: atomic<i32>; |
| |
| var<workgroup> vw49: atomic<u32>; |
| |
| var<private> vp12 = frexp(vec2f(0.03212, -0.00775)); |
| |
| var<private> vp13 = frexp(f16(13505.7)); |
| |
| @vertex |
| fn vertex11() -> VertexOutput10 { |
| var out: VertexOutput10; |
| vp12.exp = vec2i(inverseSqrt(vec4f(unconst_f32(0.1385), unconst_f32(0.1174), unconst_f32(0.2165), unconst_f32(0.00192))).ra); |
| let vf206: u32 = pack2x16snorm(vec2f(unconst_f32(0.05382), unconst_f32(0.01739))); |
| vp13 = frexp(f16(pow(vec3f(unconst_f32(-0.08490), unconst_f32(0.02883), unconst_f32(-0.07836)), vec3f(unconst_f32(0.2919), unconst_f32(0.06211), unconst_f32(0.1246))).y)); |
| out.f36 = vec4f(pow(vec3h(pow(vec3f(unconst_f32(0.01135), unconst_f32(0.1670), unconst_f32(0.09860)), vec3f(unconst_f32(0.01704), unconst_f32(0.1490), unconst_f32(0.2933)))), vec3h(f16(pack4xU8(vec4u(unconst_u32(670), unconst_u32(172), unconst_u32(98), unconst_u32(293)))))).brbb); |
| vp12.exp = vec2i(i32(pack4xU8(unpack4xU8(u32(override5))))); |
| let vf207: vec3f = pow(vec3f(unconst_f32(0.4839), unconst_f32(0.00615), unconst_f32(0.1891)), vec3f(unconst_f32(0.1452), unconst_f32(-0.6357), unconst_f32(0.06832))); |
| var vf208: u32 = pack2x16snorm(vec2f(unconst_f32(0.05199), unconst_f32(0.05463))); |
| out.f36 -= vec4f(mix(vec2h(unconst_f16(4833.6), unconst_f16(4672.7)), vec2h(unconst_f16(18861.7), unconst_f16(9219.2)), vec2h(unconst_f16(45883.1), unconst_f16(3438.3))).rgrr); |
| out = VertexOutput10(inverseSqrt(vec4f(unconst_f32(0.09193), unconst_f32(0.3293), unconst_f32(0.06277), unconst_f32(0.3062)))); |
| vp12.exp = vec2i(vp13.exp); |
| let ptr83: ptr<private, i32> = &vp13.exp; |
| vf208 &= u32(pow(vec3f(unconst_f32(0.2183), unconst_f32(0.1391), unconst_f32(0.04610)), vec3f(unconst_f32(0.00135), unconst_f32(0.00358), unconst_f32(0.03856))).b); |
| vp12 = frexp(radians(vec2f(unconst_f32(0.07077), unconst_f32(-0.06785)))); |
| out.f36 = vec4f(f32(override5)); |
| return out; |
| _ = override5; |
| } |
| |
| @compute @workgroup_size(2, 1, 1) |
| fn compute10(@builtin(local_invocation_id) a0: vec3u) { |
| vp13 = frexp(abs(vec3h(vp12.fract.yxx)).r); |
| var vf209: f32 = smoothstep(f32(unconst_f32(0.04582)), f32(unconst_f32(-0.06231)), f32(unconst_f32(0.03230))); |
| var vf210: vec3f = normalize(vec3f(bitcast<f32>(pack2x16unorm(vec2f(unconst_f32(0.04964), unconst_f32(0.01100)))))); |
| vp12.fract -= vec2f(f32(vp13.fract)); |
| var vf211: i32 = atomicLoad(&vw46.f0); |
| let ptr84: ptr<workgroup, T3> = &vw46; |
| var vf212: i32 = atomicLoad(&vw46.f0); |
| var vf213: vec4u = unpack4xU8(u32(unconst_u32(49))); |
| let vf214: f16 = acosh(f16(unconst_f16(4717.2))); |
| let ptr85: ptr<workgroup, T3> = &vw46; |
| vf210 = vec3f(f32(atomicLoad(&(*&vw46).f0))); |
| }`, |
| hints: {}, |
| }); |
| let bindGroupLayout17 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 78, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'filtering' }}, |
| { |
| binding: 113, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '3d' }, |
| }, |
| ], |
| }); |
| let buffer97 = device0.createBuffer({size: 12231, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let renderPassEncoder56 = commandEncoder144.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView94, |
| clearValue: { r: 602.9, g: 511.5, b: 982.7, a: -590.9, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet11, |
| }); |
| try { |
| renderPassEncoder39.setBindGroup(1, bindGroup25); |
| } catch {} |
| try { |
| renderPassEncoder25.setStencilReference(37); |
| } catch {} |
| try { |
| buffer36.unmap(); |
| } catch {} |
| try { |
| commandEncoder143.copyBufferToTexture({ |
| /* bytesInLastRow: 32 widthInBlocks: 8 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1512 */ |
| offset: 1480, |
| bytesPerRow: 6656, |
| buffer: buffer72, |
| }, { |
| texture: texture50, |
| mipLevel: 1, |
| origin: {x: 4, y: 0, z: 14}, |
| aspect: 'all', |
| }, {width: 8, height: 1, depthOrArrayLayers: 1}); |
| } catch {} |
| try { |
| computePassEncoder45.insertDebugMarker('\udda4'); |
| } catch {} |
| let bindGroup85 = device0.createBindGroup({ |
| layout: bindGroupLayout5, |
| entries: [ |
| {binding: 211, resource: sampler49}, |
| {binding: 62, resource: textureView57}, |
| {binding: 86, resource: textureView23}, |
| ], |
| }); |
| try { |
| computePassEncoder96.setBindGroup(3, bindGroup44); |
| } catch {} |
| try { |
| computePassEncoder56.setBindGroup(2, bindGroup41, new Uint32Array(1884), 1_360, 0); |
| } catch {} |
| try { |
| renderPassEncoder23.setIndexBuffer(buffer21, 'uint16', 2_598, 1_194); |
| } catch {} |
| let textureView121 = texture20.createView({dimension: '2d-array', baseMipLevel: 0, mipLevelCount: 1, baseArrayLayer: 1, arrayLayerCount: 5}); |
| let computePassEncoder105 = commandEncoder143.beginComputePass({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder24.setBindGroup(2, bindGroup43); |
| } catch {} |
| try { |
| device0.pushErrorScope('out-of-memory'); |
| } catch {} |
| try { |
| buffer0.unmap(); |
| } catch {} |
| let commandEncoder145 = device0.createCommandEncoder({}); |
| let texture121 = device0.createTexture({ |
| size: [36, 1, 1], |
| mipLevelCount: 2, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let renderPassEncoder57 = commandEncoder145.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView120, |
| clearValue: { r: 128.4, g: -970.0, b: 462.2, a: -219.0, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| computePassEncoder104.setBindGroup(0, bindGroup69); |
| } catch {} |
| try { |
| computePassEncoder29.setBindGroup(0, bindGroup39, new Uint32Array(468), 113, 0); |
| } catch {} |
| try { |
| renderPassEncoder47.executeBundles([renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder47.setIndexBuffer(buffer95, 'uint16', 2_156, 331); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| let bindGroup86 = device0.createBindGroup({ |
| label: '\u55c9\u6cdf\u02ea\u041c\u44ac\uf4ae\u{1fb0e}', |
| layout: bindGroupLayout5, |
| entries: [ |
| {binding: 86, resource: textureView17}, |
| {binding: 62, resource: textureView57}, |
| {binding: 211, resource: sampler54}, |
| ], |
| }); |
| let textureView122 = texture49.createView({label: '\u03e4\ud680\u0d31\u7834\u{1faf2}\u64ea\u991c\u6bfe\u{1fa0b}', aspect: 'all'}); |
| let texture122 = device0.createTexture({ |
| size: [220, 20, 156], |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder101.setBindGroup(0, bindGroup79); |
| } catch {} |
| try { |
| computePassEncoder105.setPipeline(pipeline2); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer6]); |
| } catch {} |
| let videoFrame18 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt470bg', primaries: 'unspecified', transfer: 'iec61966-2-1'} }); |
| try { |
| globalThis.someLabel = externalTexture0.label; |
| } catch {} |
| let textureView123 = texture117.createView({}); |
| let sampler81 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'nearest', |
| mipmapFilter: 'linear', |
| lodMinClamp: 29.35, |
| lodMaxClamp: 36.35, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder60); computePassEncoder60.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder4.setIndexBuffer(buffer28, 'uint32', 100, 801); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({device: device0, format: 'rgba8unorm', usage: GPUTextureUsage.COPY_DST}); |
| } catch {} |
| let buffer98 = device0.createBuffer({ |
| size: 5728, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder146 = device0.createCommandEncoder({}); |
| let textureView124 = texture65.createView({baseArrayLayer: 2, arrayLayerCount: 6}); |
| let sampler82 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| lodMinClamp: 54.62, |
| lodMaxClamp: 87.88, |
| maxAnisotropy: 1, |
| }); |
| try { |
| computePassEncoder68.setBindGroup(3, bindGroup43, []); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(3, bindGroup9, new Uint32Array(2613), 66, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 147, height: 1, depthOrArrayLayers: 9} |
| */ |
| { |
| source: videoFrame12, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture110, |
| mipLevel: 1, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| await gc(); |
| let videoFrame19 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: false, matrix: 'fcc', primaries: 'bt470m', transfer: 'bt2020_10bit'} }); |
| let bindGroupLayout18 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 204, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| { |
| binding: 116, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| sampler: { type: 'filtering' }, |
| }, |
| ], |
| }); |
| let bindGroup87 = device0.createBindGroup({ |
| layout: bindGroupLayout17, |
| entries: [{binding: 78, resource: sampler59}, {binding: 113, resource: textureView109}], |
| }); |
| let sampler83 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 5.439, |
| lodMaxClamp: 53.48, |
| }); |
| try { |
| renderPassEncoder36.setBindGroup(1, bindGroup85); |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(0, bindGroup68, new Uint32Array(579), 20, 0); |
| } catch {} |
| try { |
| renderPassEncoder29.setViewport(30.309218784495187, 0.4881356777107151, 58.55187182788767, 0.16552821604416243, 0.6390498684764568, 0.8399279239191656); |
| } catch {} |
| try { |
| renderPassEncoder11.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder42.setVertexBuffer(1, buffer94, 60); |
| } catch {} |
| let texture123 = device0.createTexture({ |
| size: {width: 70, height: 72, depthOrArrayLayers: 1}, |
| dimension: '2d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView125 = texture25.createView({label: '\u13ff\u4d29\u1eb9\u09aa\u0a0a', dimension: '3d', aspect: 'all', mipLevelCount: 1}); |
| let computePassEncoder106 = commandEncoder146.beginComputePass({}); |
| try { |
| renderPassEncoder19.executeBundles([renderBundle7, renderBundle3]); |
| } catch {} |
| try { |
| renderPassEncoder36.setIndexBuffer(buffer53, 'uint32', 1_072, 42); |
| } catch {} |
| let arrayBuffer9 = buffer35.getMappedRange(184, 68); |
| let commandEncoder147 = device0.createCommandEncoder({}); |
| let texture124 = device0.createTexture({ |
| size: {width: 110}, |
| dimension: '1d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let renderPassEncoder58 = commandEncoder147.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView51, |
| depthSlice: 4, |
| clearValue: { r: 346.4, g: 268.6, b: -685.2, a: -186.8, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet6, |
| }); |
| try { |
| device0.queue.writeBuffer(buffer56, 1316, new DataView(new ArrayBuffer(23048)), 3911, 2468); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 73, height: 1, depthOrArrayLayers: 54} |
| */ |
| { |
| source: imageData1, |
| origin: { x: 4, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture5, |
| mipLevel: 0, |
| origin: {x: 11, y: 0, z: 30}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let sampler84 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 59.25, |
| lodMaxClamp: 74.25, |
| maxAnisotropy: 1, |
| }); |
| try { |
| computePassEncoder106.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder38.setIndexBuffer(buffer83, 'uint32', 2_228, 2_628); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer26, 28, new BigUint64Array(575), 94, 276); |
| } catch {} |
| let commandEncoder148 = device0.createCommandEncoder({}); |
| let externalTexture11 = device0.importExternalTexture({label: '\u0be0\u{1fa8b}', source: videoFrame8}); |
| try { |
| computePassEncoder21.setBindGroup(2, bindGroup41, []); |
| } catch {} |
| try { |
| computePassEncoder61.setBindGroup(2, bindGroup29, new Uint32Array(2229), 1_699, 0); |
| } catch {} |
| try { |
| renderPassEncoder56.executeBundles([renderBundle2, renderBundle1, renderBundle2]); |
| } catch {} |
| try { |
| renderPassEncoder42.setBlendConstant({ r: -265.2, g: -128.3, b: -272.7, a: 45.37, }); |
| } catch {} |
| try { |
| renderPassEncoder6.setVertexBuffer(4, buffer62, 0, 3_762); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| commandEncoder148.copyBufferToTexture({ |
| /* bytesInLastRow: 256 widthInBlocks: 64 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 188 */ |
| offset: 188, |
| bytesPerRow: 3584, |
| buffer: buffer48, |
| }, { |
| texture: texture79, |
| mipLevel: 0, |
| origin: {x: 4, y: 13, z: 0}, |
| aspect: 'all', |
| }, {width: 64, height: 97, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| if (!arrayBuffer4.detached) { new Uint8Array(arrayBuffer4).fill(0x55); }; |
| } catch {} |
| let buffer99 = device0.createBuffer({ |
| size: 18764, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| let commandEncoder149 = device0.createCommandEncoder({}); |
| let texture125 = device0.createTexture({ |
| label: '\u86c1\u04ef\u0262\u1303\u0e6f\u35b5\u050c\ue54a\uf43d', |
| size: [70, 72, 1531], |
| mipLevelCount: 1, |
| dimension: '3d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| let computePassEncoder107 = commandEncoder149.beginComputePass({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder5); computePassEncoder5.dispatchWorkgroupsIndirect(buffer73, 164); }; |
| } catch {} |
| try { |
| computePassEncoder107.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder35.executeBundles([renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder35.setIndexBuffer(buffer91, 'uint32', 3_936, 75); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| await gc(); |
| let buffer100 = device0.createBuffer({ |
| size: 2410, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder150 = device0.createCommandEncoder({}); |
| let textureView126 = texture87.createView({baseArrayLayer: 0}); |
| let computePassEncoder108 = commandEncoder150.beginComputePass({label: '\u047a\u0170'}); |
| let renderPassEncoder59 = commandEncoder148.beginRenderPass({colorAttachments: [{view: textureView31, loadOp: 'clear', storeOp: 'discard'}]}); |
| let sampler85 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'clamp-to-edge', |
| minFilter: 'nearest', |
| lodMinClamp: 85.50, |
| lodMaxClamp: 92.03, |
| }); |
| let externalTexture12 = device0.importExternalTexture({source: videoFrame3}); |
| try { |
| computePassEncoder42.setBindGroup(0, bindGroup37, new Uint32Array(16), 2, 0); |
| } catch {} |
| try { |
| computePassEncoder108.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder46.executeBundles([renderBundle3]); |
| } catch {} |
| try { |
| buffer56.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({device: device0, format: 'rgba16float', usage: GPUTextureUsage.COPY_DST}); |
| } catch {} |
| let buffer101 = device0.createBuffer({ |
| size: 34143, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder151 = device0.createCommandEncoder({label: '\u0aab\u3446\u059b'}); |
| try { |
| renderPassEncoder52.setBindGroup(3, bindGroup39, new Uint32Array(210), 23, 0); |
| } catch {} |
| try { |
| renderPassEncoder16.setIndexBuffer(buffer30, 'uint32', 0, 3); |
| } catch {} |
| try { |
| commandEncoder151.copyTextureToTexture({ |
| texture: texture65, |
| mipLevel: 0, |
| origin: {x: 14, y: 0, z: 1}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture84, |
| mipLevel: 1, |
| origin: {x: 12, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 15, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture54, |
| mipLevel: 0, |
| origin: {x: 3, y: 15, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(175).fill(54), /* required buffer size: 175 */ |
| {offset: 175, bytesPerRow: 32, rowsPerImage: 111}, {width: 1, height: 14, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer102 = device0.createBuffer({ |
| size: 1004, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder152 = device0.createCommandEncoder({}); |
| let texture126 = device0.createTexture({ |
| size: {width: 147, height: 1, depthOrArrayLayers: 40}, |
| mipLevelCount: 3, |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let computePassEncoder109 = commandEncoder151.beginComputePass({}); |
| try { |
| computePassEncoder98.setBindGroup(2, bindGroup49); |
| } catch {} |
| try { |
| computePassEncoder57.setBindGroup(1, bindGroup44, new Uint32Array(96), 0, 0); |
| } catch {} |
| try { |
| renderPassEncoder10.setVertexBuffer(6, buffer10, 0, 2_989); |
| } catch {} |
| await gc(); |
| let commandEncoder153 = device0.createCommandEncoder({label: '\ub7e9\u{1f9b4}\u7976\u7ff1\u360a\u24b7\u{1f6f1}\ub0ce\u5463'}); |
| let sampler86 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| lodMinClamp: 40.70, |
| lodMaxClamp: 82.35, |
| }); |
| try { |
| renderPassEncoder36.setBindGroup(0, bindGroup53); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let computePassEncoder110 = commandEncoder153.beginComputePass(); |
| let sampler87 = device0.createSampler({ |
| label: '\uc031\u2f43\u0bc0\u0469\uf995\u04fd\u8e1b\u5f1a\ucf79', |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 70.03, |
| maxAnisotropy: 5, |
| }); |
| try { |
| computePassEncoder36.setBindGroup(1, bindGroup34, new Uint32Array(3183), 1_212, 0); |
| } catch {} |
| try { |
| renderPassEncoder47.setBindGroup(0, bindGroup50, new Uint32Array(6117), 455, 0); |
| } catch {} |
| try { |
| renderPassEncoder32.setVertexBuffer(6, buffer86); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer44, 8196, new BigUint64Array(17330), 609, 540); |
| } catch {} |
| let commandEncoder154 = device0.createCommandEncoder({}); |
| let computePassEncoder111 = commandEncoder152.beginComputePass({}); |
| let sampler88 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 86.02, |
| compare: 'greater', |
| maxAnisotropy: 9, |
| }); |
| try { |
| computePassEncoder94.setBindGroup(0, bindGroup16, []); |
| } catch {} |
| try { |
| renderPassEncoder34.setIndexBuffer(buffer71, 'uint32', 1_820, 4_422); |
| } catch {} |
| try { |
| renderPassEncoder14.setVertexBuffer(4, buffer15, 0, 1_530); |
| } catch {} |
| let arrayBuffer10 = buffer35.getMappedRange(256, 8); |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer97, 364, new BigUint64Array(16964), 2905, 92); |
| } catch {} |
| let bindGroup88 = device0.createBindGroup({ |
| layout: bindGroupLayout11, |
| entries: [{binding: 52, resource: textureView104}, {binding: 57, resource: textureView22}], |
| }); |
| let commandEncoder155 = device0.createCommandEncoder({}); |
| let textureView127 = texture92.createView({}); |
| let computePassEncoder112 = commandEncoder155.beginComputePass(); |
| try { |
| computePassEncoder110.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder11.setBindGroup(2, bindGroup29, new Uint32Array(8460), 885, 0); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 295, height: 1, depthOrArrayLayers: 19} |
| */ |
| { |
| source: img1, |
| origin: { x: 0, y: 4 }, |
| flipY: true, |
| }, { |
| texture: texture110, |
| mipLevel: 0, |
| origin: {x: 28, y: 0, z: 11}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 8, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let computePassEncoder113 = commandEncoder154.beginComputePass({}); |
| let renderBundleEncoder8 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2uint'], sampleCount: 4, depthReadOnly: true, stencilReadOnly: true}); |
| let renderBundle8 = renderBundleEncoder8.finish({}); |
| let sampler89 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 56.95, |
| lodMaxClamp: 60.89, |
| }); |
| try { |
| computePassEncoder55.setBindGroup(1, bindGroup44); |
| } catch {} |
| try { |
| computePassEncoder61.end(); |
| } catch {} |
| try { |
| computePassEncoder113.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder31.setBindGroup(1, bindGroup30, []); |
| } catch {} |
| try { |
| renderPassEncoder12.executeBundles([renderBundle7]); |
| } catch {} |
| let commandEncoder156 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder50.setBindGroup(2, bindGroup36, new Uint32Array(2165), 499, 0); |
| } catch {} |
| try { |
| computePassEncoder5.end(); |
| } catch {} |
| try { |
| renderPassEncoder52.setBindGroup(2, bindGroup29); |
| } catch {} |
| try { |
| renderPassEncoder24.setVertexBuffer(7, buffer10, 2_236, 2_309); |
| } catch {} |
| try { |
| commandEncoder86.copyBufferToTexture({ |
| /* bytesInLastRow: 12 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 4948 */ |
| offset: 4948, |
| buffer: buffer95, |
| }, { |
| texture: texture5, |
| mipLevel: 0, |
| origin: {x: 13, y: 0, z: 5}, |
| aspect: 'all', |
| }, {width: 3, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder156.resolveQuerySet(querySet2, 265, 178, buffer19, 256); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 73, height: 1, depthOrArrayLayers: 54} |
| */ |
| { |
| source: videoFrame13, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture5, |
| mipLevel: 0, |
| origin: {x: 9, y: 0, z: 11}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup89 = device0.createBindGroup({ |
| label: '\ue269\u{1f95b}\u934d\u2df4\u{1f9b5}\u5c59\u{1faea}\ude18\uae48\u3f94\u0ea9', |
| layout: bindGroupLayout15, |
| entries: [{binding: 44, resource: externalTexture4}], |
| }); |
| let commandEncoder157 = device0.createCommandEncoder({}); |
| let computePassEncoder114 = commandEncoder86.beginComputePass(); |
| let sampler90 = device0.createSampler({ |
| label: '\u9bf2\u{1ffe6}\ube26\ubc51\u95a1\u3b01\u{1f885}\uee9c\ucf72', |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 81.46, |
| lodMaxClamp: 98.90, |
| maxAnisotropy: 19, |
| }); |
| try { |
| computePassEncoder109.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder51.setBindGroup(1, bindGroup64, new Uint32Array(756), 110, 0); |
| } catch {} |
| let buffer103 = device0.createBuffer({ |
| size: 431, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| let commandEncoder158 = device0.createCommandEncoder(); |
| let computePassEncoder115 = commandEncoder8.beginComputePass({}); |
| let renderPassEncoder60 = commandEncoder157.beginRenderPass({colorAttachments: [{view: textureView82, depthSlice: 8, loadOp: 'load', storeOp: 'discard'}]}); |
| let sampler91 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 98.43, |
| maxAnisotropy: 18, |
| }); |
| try { |
| computePassEncoder115.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder10.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder2.setVertexBuffer(6, buffer24); |
| } catch {} |
| let querySet14 = device0.createQuerySet({label: '\ua53d\u59d3\u7d7c', type: 'occlusion', count: 589}); |
| let computePassEncoder116 = commandEncoder156.beginComputePass({}); |
| let sampler92 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 59.79, |
| lodMaxClamp: 87.45, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder47); computePassEncoder47.dispatchWorkgroupsIndirect(buffer25, 1_264); }; |
| } catch {} |
| try { |
| commandEncoder158.copyBufferToTexture({ |
| /* bytesInLastRow: 480 widthInBlocks: 60 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 1024 */ |
| offset: 1024, |
| bytesPerRow: 23296, |
| rowsPerImage: 1205, |
| buffer: buffer83, |
| }, { |
| texture: texture30, |
| mipLevel: 0, |
| origin: {x: 58, y: 6, z: 0}, |
| aspect: 'all', |
| }, {width: 60, height: 23, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| computePassEncoder112.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder0.setStencilReference(721); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| let texture127 = gpuCanvasContext0.getCurrentTexture(); |
| let textureView128 = texture10.createView({dimension: '2d-array', aspect: 'depth-only', mipLevelCount: 1}); |
| try { |
| computePassEncoder110.setBindGroup(0, bindGroup74, new Uint32Array(5788), 1_826, 0); |
| } catch {} |
| try { |
| computePassEncoder114.setPipeline(pipeline0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer5, 3288, new Int16Array(8732), 224, 688); |
| } catch {} |
| try { |
| globalThis.someLabel = computePassEncoder112.label; |
| } catch {} |
| let shaderModule12 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| requires pointer_composite_access; |
| |
| requires readonly_and_readwrite_storage_textures; |
| |
| requires readonly_and_readwrite_storage_textures; |
| |
| diagnostic(info, xyz); |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| @group(0) @binding(58) var<uniform> buffer104: array<array<array<array<vec4f, 13>, 1>, 16>, 1>; |
| |
| @group(0) @binding(225) var tex0: texture_depth_2d; |
| |
| struct T0 { |
| @align(64) @size(3328) f0: array<atomic<i32>>, |
| } |
| |
| struct T1 { |
| @size(3328) f0: array<u32>, |
| } |
| |
| struct T2 { |
| @align(64) @size(64) f0: array<vec2h>, |
| } |
| |
| struct T3 { |
| @align(128) @size(256) f0: mat3x2h, |
| @size(3072) f1: array<array<mat2x4h, 1>>, |
| } |
| |
| struct T4 { |
| @size(256) f0: array<atomic<u32>, 1>, |
| @align(256) @size(3072) f1: array<atomic<u32>>, |
| } |
| |
| struct VertexOutput11 { |
| @invariant @builtin(position) f37: vec4f, |
| } |
| |
| alias vec3b = vec3<bool>; |
| |
| fn fn0() -> array<array<array<u32, 1>, 58>, 1> { |
| var out: array<array<array<u32, 1>, 58>, 1>; |
| out[u32(unconst_u32(154))][pack4xU8(vec4u(buffer104[0][u32(unconst_u32(117))][u32(unconst_u32(51))][bitcast<u32>((*&buffer104)[0][15][0][u32(unconst_u32(99))][u32(unconst_u32(110))])]))][0] = pack4x8unorm(buffer104[u32(unconst_u32(82))][15][0][12]); |
| out[u32(unconst_u32(223))][57][u32(unconst_u32(153))] = pack4xU8(bitcast<vec4u>((*&buffer104)[u32(unconst_u32(2))][15][u32(unconst_u32(82))][12])); |
| out[0][u32(unconst_u32(90))][u32(unconst_u32(554))] = pack4xU8(vec4u((*&buffer104)[0][15][0][12])); |
| out[u32(unconst_u32(277))][u32(unconst_u32(5))][u32((*&buffer104)[bitcast<u32>(buffer104[0][u32(unconst_u32(115))][u32(unconst_u32(166))][u32(unconst_u32(444))][u32(unconst_u32(473))])][u32(unconst_u32(145))][0][12][3])] >>= bitcast<u32>(radians(vec2h(unconst_f16(12268.8), unconst_f16(21544.1)))); |
| let ptr86: ptr<uniform, vec4f> = &(*&buffer104)[0][u32(unconst_u32(173))][u32(unconst_u32(81))][12]; |
| out[u32(unconst_u32(326))][u32(unconst_u32(52))][0] <<= pack4x8unorm(buffer104[u32(unconst_u32(95))][u32(unconst_u32(27))][0][pack4x8snorm(buffer104[0][15][pack2x16unorm(vec2f(unconst_f32(0.1874), unconst_f32(0.2190)))][12])]); |
| out[0][u32((*&buffer104)[pack4xU8Clamp(vec4u(buffer104[0][15][0][12]))][15][u32(unconst_u32(188))][u32(unconst_u32(10))][u32(unconst_u32(440))])][bitcast<u32>(buffer104[bitcast<vec4u>((*&buffer104)[u32(unconst_u32(8))][u32(unconst_u32(59))][pack4x8snorm(buffer104[u32(unconst_u32(210))][u32(unconst_u32(37))][u32(unconst_u32(307))][12])][12]).z][15][0][12][3])] *= u32((*&buffer104)[u32(unconst_u32(91))][u32(unconst_u32(235))][u32(unconst_u32(219))][u32(unconst_u32(132))][u32(unconst_u32(501))]); |
| let ptr87: ptr<uniform, vec4f> = &(*&buffer104)[u32(unconst_u32(292))][15][0][12]; |
| let vf215: f32 = buffer104[0][u32(unconst_u32(774))][u32(unconst_u32(114))][u32(unconst_u32(410))][u32(unconst_u32(137))]; |
| out[u32(unconst_u32(198))][57][u32(unconst_u32(28))] |= bitcast<u32>(buffer104[0][15][u32(unconst_u32(124))][u32(unconst_u32(60))][u32(unconst_u32(50))]); |
| out[u32(unconst_u32(201))][u32(unconst_u32(74))][u32(unconst_u32(48))] = u32(tan(f16(unconst_f16(369.7)))); |
| out[u32(unconst_u32(297))][u32(unconst_u32(161))][u32(unconst_u32(325))] = pack4x8snorm(buffer104[u32(unconst_u32(10))][15][u32(unconst_u32(46))][12]); |
| out[0][u32(unconst_u32(199))][0] *= bitcast<u32>(buffer104[pack4x8snorm(buffer104[0][15][0][12])][15][0][12][u32(unconst_u32(97))]); |
| let ptr88: ptr<uniform, array<array<vec4f, 13>, 1>> = &buffer104[0][u32(unconst_u32(227))]; |
| let ptr89: ptr<uniform, vec4f> = &(*&buffer104)[0][15][0][12]; |
| let ptr90: ptr<uniform, array<array<array<array<vec4f, 13>, 1>, 16>, 1>> = &(*&buffer104); |
| return out; |
| } |
| |
| fn fn1() -> array<VertexOutput11, 1> { |
| var out: array<VertexOutput11, 1>; |
| let vf216: vec2f = unpack2x16unorm(u32(unconst_u32(11))); |
| var vf217: f32 = textureLoad(tex0, vec2i(unconst_i32(-21), unconst_i32(32)), i32(unconst_i32(46))); |
| let vf218: vec4h = exp2(vec4h(unconst_f16(11792.3), unconst_f16(4429.7), unconst_f16(-12386.5), unconst_f16(19334.0))); |
| var vf219: vec4f = sin(vec4f(unconst_f32(0.5282), unconst_f32(0.2169), unconst_f32(-0.01403), unconst_f32(0.07062))); |
| let vf220: u32 = pack2x16snorm(vec2f(unconst_f32(0.1324), unconst_f32(0.02418))); |
| let vf221: u32 = textureNumLevels(tex0); |
| let vf222: f32 = vf219[u32(unconst_u32(197))]; |
| vf219 = bitcast<vec4f>(countOneBits(vec3i(unconst_i32(178), unconst_i32(563), unconst_i32(198))).brgb); |
| var vf223: u32 = vf220; |
| let ptr91: ptr<function, u32> = &vf223; |
| let vf224: f32 = vf219[u32(unconst_u32(117))]; |
| var vf225: u32 = vf221; |
| var vf226: f32 = vf216[pack4xI8Clamp(vec4i(unconst_i32(54), unconst_i32(647), unconst_i32(3), unconst_i32(192)))]; |
| return out; |
| } |
| |
| var<workgroup> vw50: array<array<array<mat3x3f, 1>, 1>, 1>; |
| |
| var<workgroup> vw51: array<atomic<i32>, 21>; |
| |
| var<workgroup> vw52: atomic<i32>; |
| |
| var<workgroup> vw53: array<vec2i, 1>; |
| |
| var<workgroup> vw54: VertexOutput11; |
| |
| @vertex |
| fn vertex12(@location(2) a0: vec4f, @location(12) a1: vec2h) -> VertexOutput11 { |
| var out: VertexOutput11; |
| var vf227 = fn1(); |
| vf227[u32(vf227[u32(unconst_u32(74))].f37[u32(unconst_u32(123))])].f37 *= vf227[u32(unconst_u32(330))].f37; |
| var vf228 = fn1(); |
| vf228[u32(unconst_u32(1))].f37 *= vf228[0].f37; |
| let ptr92: ptr<function, vec4f> = &vf227[u32(unconst_u32(90))].f37; |
| out.f37 += bitcast<vec4f>(textureDimensions(tex0).xyxx); |
| var vf229 = fn1(); |
| fn1(); |
| out = VertexOutput11(vec4f(determinant(mat4x4f(unconst_f32(0.05077), unconst_f32(0.07971), unconst_f32(0.2079), unconst_f32(0.1197), unconst_f32(0.09585), unconst_f32(0.08026), unconst_f32(0.06861), unconst_f32(0.2036), unconst_f32(0.1884), unconst_f32(0.00260), unconst_f32(0.2690), unconst_f32(0.2116), unconst_f32(0.3501), unconst_f32(0.04959), unconst_f32(-0.1941), unconst_f32(0.00771))))); |
| return out; |
| } |
| |
| @compute @workgroup_size(1, 1, 1) |
| fn compute11() { |
| fn0(); |
| vw54.f37 -= (*&vw50)[u32(unconst_u32(67))][0][u32(unconst_u32(51))][u32(unconst_u32(47))].zyzx; |
| var vf230 = fn1(); |
| vw53[u32(unconst_u32(258))] = vec2i(vw50[u32(unconst_u32(55))][0][0][unconst_i32(2)].rr); |
| let ptr93: ptr<workgroup, VertexOutput11> = &(*&vw54); |
| }`, |
| }); |
| let bindGroup90 = device0.createBindGroup({layout: bindGroupLayout15, entries: [{binding: 44, resource: externalTexture8}]}); |
| let buffer105 = device0.createBuffer({ |
| size: 2845, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM, |
| }); |
| let computePassEncoder117 = commandEncoder158.beginComputePass({label: '\u447b\u{1f6fb}\u101e\u6b14\u01f1\u8b56'}); |
| let sampler93 = device0.createSampler({ |
| label: '\u5d06\u97fc\u05c3\u0027\ucdb8', |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 50.08, |
| lodMaxClamp: 79.42, |
| compare: 'less-equal', |
| maxAnisotropy: 9, |
| }); |
| try { |
| computePassEncoder77.setBindGroup(3, bindGroup86, new Uint32Array(2888), 397, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer52, 740, new Float32Array(5727), 419, 16); |
| } catch {} |
| let bindGroup91 = device0.createBindGroup({ |
| layout: bindGroupLayout13, |
| entries: [{binding: 272, resource: {buffer: buffer100, offset: 0, size: 208}}], |
| }); |
| let buffer106 = device0.createBuffer({ |
| label: '\u337a\uc3ef\u{1f9cc}\u530e\u{1fc6d}\u5044\u113e\u{1f7b5}\u070e\u32c6\ue9b5', |
| size: 3844, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder159 = device0.createCommandEncoder({}); |
| let externalTexture13 = device0.importExternalTexture({source: videoFrame8}); |
| try { |
| computePassEncoder116.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder25.setBindGroup(1, bindGroup16, new Uint32Array(532), 318, 0); |
| } catch {} |
| try { |
| commandEncoder159.copyBufferToTexture({ |
| /* bytesInLastRow: 84 widthInBlocks: 21 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1944 */ |
| offset: 1944, |
| bytesPerRow: 7680, |
| buffer: buffer100, |
| }, { |
| texture: texture83, |
| mipLevel: 0, |
| origin: {x: 9, y: 7, z: 0}, |
| aspect: 'all', |
| }, {width: 21, height: 5, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55); }; |
| } catch {} |
| let videoFrame20 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt709', primaries: 'jedecP22Phosphors', transfer: 'bt2020_12bit'} }); |
| let commandEncoder160 = device0.createCommandEncoder({}); |
| let textureView129 = texture86.createView({ |
| label: '\u7a2d\u{1f6eb}\ue72a\u087e\ub62d\u{1fda7}\uea97\u05b6\u887f', |
| baseMipLevel: 1, |
| mipLevelCount: 1, |
| }); |
| let computePassEncoder118 = commandEncoder159.beginComputePass(); |
| let renderPassEncoder61 = commandEncoder160.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView29, |
| depthSlice: 185, |
| clearValue: { r: -230.2, g: 533.6, b: -628.1, a: -9.904, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet9, |
| maxDrawCount: 376292232, |
| }); |
| try { |
| computePassEncoder117.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder19.setBindGroup(1, bindGroup49, new Uint32Array(3800), 407, 0); |
| } catch {} |
| let img3 = await imageWithData(92, 30, '#10101010', '#20202020'); |
| try { |
| computePassEncoder95.setBindGroup(3, bindGroup13, new Uint32Array(112), 19, 0); |
| } catch {} |
| try { |
| renderPassEncoder44.setIndexBuffer(buffer42, 'uint16', 196, 301); |
| } catch {} |
| let videoFrame21 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt470bg', primaries: 'smpte240m', transfer: 'iec6196624'} }); |
| let commandEncoder161 = device0.createCommandEncoder({}); |
| let textureView130 = texture119.createView({mipLevelCount: 1, arrayLayerCount: 1}); |
| let computePassEncoder119 = commandEncoder161.beginComputePass(); |
| try { |
| computePassEncoder119.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder45.setBindGroup(3, bindGroup89, []); |
| } catch {} |
| try { |
| renderPassEncoder45.executeBundles([renderBundle0, renderBundle0, renderBundle3, renderBundle3, renderBundle7]); |
| } catch {} |
| try { |
| renderPassEncoder42.setPipeline(pipeline1); |
| } catch {} |
| try { |
| buffer47.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| colorSpace: 'display-p3', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let imageBitmap2 = await createImageBitmap(videoFrame10); |
| let commandEncoder162 = device0.createCommandEncoder({}); |
| let computePassEncoder120 = commandEncoder162.beginComputePass({}); |
| try { |
| computePassEncoder40.setBindGroup(3, bindGroup72); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| document.body.append(img2); |
| let bindGroup92 = device0.createBindGroup({ |
| layout: bindGroupLayout5, |
| entries: [ |
| {binding: 211, resource: sampler59}, |
| {binding: 86, resource: textureView104}, |
| {binding: 62, resource: textureView57}, |
| ], |
| }); |
| let texture128 = device0.createTexture({ |
| size: {width: 220, height: 20, depthOrArrayLayers: 1}, |
| mipLevelCount: 4, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| computePassEncoder120.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder33.setIndexBuffer(buffer83, 'uint16', 4_786, 2_978); |
| } catch {} |
| try { |
| renderPassEncoder29.setVertexBuffer(6, buffer18, 1_448); |
| } catch {} |
| try { |
| computePassEncoder111.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder46.setBindGroup(0, bindGroup81, new Uint32Array(1094), 195, 0); |
| } catch {} |
| try { |
| renderPassEncoder2.end(); |
| } catch {} |
| try { |
| renderPassEncoder48.setVertexBuffer(1, buffer101, 0, 2_529); |
| } catch {} |
| try { |
| commandEncoder6.copyBufferToBuffer(buffer89, 320, buffer23, 8748, 140); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer25, 2684, new DataView(new ArrayBuffer(13791)), 1555, 108); |
| } catch {} |
| let imageData15 = new ImageData(84, 20); |
| let buffer107 = device0.createBuffer({ |
| size: 25156, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE, |
| }); |
| let commandEncoder163 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder50.end(); |
| } catch {} |
| try { |
| computePassEncoder118.setPipeline(pipeline4); |
| } catch {} |
| try { |
| commandEncoder16.copyBufferToTexture({ |
| /* bytesInLastRow: 240 widthInBlocks: 30 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 928 */ |
| offset: 928, |
| bytesPerRow: 2816, |
| buffer: buffer41, |
| }, { |
| texture: texture69, |
| mipLevel: 0, |
| origin: {x: 70, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 30, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture129 = device0.createTexture({ |
| size: {width: 140, height: 145, depthOrArrayLayers: 1}, |
| mipLevelCount: 3, |
| dimension: '2d', |
| format: 'depth24plus', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let computePassEncoder121 = commandEncoder163.beginComputePass({label: '\u28e4\u{1ff66}\u646a\u7307\u0568\ua772\ue6c3\u03ce'}); |
| let renderPassEncoder62 = commandEncoder6.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView97, |
| clearValue: { r: -80.12, g: 381.8, b: -355.7, a: 873.4, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| computePassEncoder121.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder56.setBindGroup(1, bindGroup29); |
| } catch {} |
| try { |
| renderPassEncoder33.setIndexBuffer(buffer95, 'uint32', 548, 1_773); |
| } catch {} |
| try { |
| renderPassEncoder26.setVertexBuffer(4, buffer2, 1_428); |
| } catch {} |
| try { |
| renderPassEncoder35.insertDebugMarker('\udefa'); |
| } catch {} |
| let bindGroup93 = device0.createBindGroup({ |
| layout: bindGroupLayout7, |
| entries: [ |
| {binding: 54, resource: {buffer: buffer63, offset: 1024, size: 3688}}, |
| {binding: 53, resource: externalTexture1}, |
| ], |
| }); |
| let buffer108 = device0.createBuffer({ |
| label: '\u{1f7cc}\u3348\u{1f797}', |
| size: 4700, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ, |
| }); |
| let texture130 = device0.createTexture({ |
| label: '\u5be6\u{1fae0}\u858d\u216d\u01e1', |
| size: [36, 1, 12], |
| mipLevelCount: 2, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let textureView131 = texture61.createView({baseMipLevel: 0, baseArrayLayer: 0}); |
| let computePassEncoder122 = commandEncoder16.beginComputePass({}); |
| try { |
| computePassEncoder94.setBindGroup(1, bindGroup27, new Uint32Array(3274), 177, 0); |
| } catch {} |
| try { |
| computePassEncoder122.setPipeline(pipeline2); |
| } catch {} |
| try { |
| computePassEncoder119.insertDebugMarker('\u036c'); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer51, 1848, new Int16Array(5797), 330, 72); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture86, |
| mipLevel: 1, |
| origin: {x: 6, y: 23, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(105).fill(88), /* required buffer size: 105 */ |
| {offset: 105, bytesPerRow: 53, rowsPerImage: 39}, {width: 0, height: 15, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup94 = device0.createBindGroup({ |
| layout: bindGroupLayout0, |
| entries: [{binding: 103, resource: textureView85}, {binding: 176, resource: textureView51}], |
| }); |
| let commandEncoder164 = device0.createCommandEncoder({}); |
| let computePassEncoder123 = commandEncoder164.beginComputePass(); |
| let externalTexture14 = device0.importExternalTexture({source: videoFrame6}); |
| try { |
| computePassEncoder75.setBindGroup(3, bindGroup48); |
| } catch {} |
| try { |
| computePassEncoder108.setPipeline(pipeline4); |
| } catch {} |
| try { |
| computePassEncoder123.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder16.setBindGroup(0, bindGroup37, new Uint32Array(2713), 323, 0); |
| } catch {} |
| try { |
| renderPassEncoder30.setIndexBuffer(buffer105, 'uint16', 144, 679); |
| } catch {} |
| try { |
| buffer10.unmap(); |
| } catch {} |
| let texture131 = device0.createTexture({ |
| size: {width: 140, height: 145, depthOrArrayLayers: 10}, |
| dimension: '3d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder9.setBindGroup(3, bindGroup88, new Uint32Array(4984), 959, 0); |
| } catch {} |
| try { |
| renderPassEncoder61.setIndexBuffer(buffer15, 'uint32', 1_024, 1_188); |
| } catch {} |
| let commandEncoder165 = device0.createCommandEncoder({}); |
| let querySet15 = device0.createQuerySet({type: 'occlusion', count: 450}); |
| let computePassEncoder124 = commandEncoder165.beginComputePass({}); |
| let sampler94 = device0.createSampler({ |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 36.95, |
| lodMaxClamp: 87.06, |
| maxAnisotropy: 20, |
| }); |
| try { |
| computePassEncoder117.setBindGroup(0, bindGroup43); |
| } catch {} |
| try { |
| computePassEncoder88.setBindGroup(2, bindGroup42, new Uint32Array(798), 122, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder71); computePassEncoder71.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder40); computePassEncoder40.dispatchWorkgroupsIndirect(buffer54, 4_560); }; |
| } catch {} |
| try { |
| renderPassEncoder11.setBindGroup(0, bindGroup79, new Uint32Array(12), 0, 0); |
| } catch {} |
| try { |
| renderPassEncoder11.draw(0, 85, 0, 312_040_344); |
| } catch {} |
| try { |
| renderPassEncoder11.drawIndirect(buffer90, 260); |
| } catch {} |
| let bindGroup95 = device0.createBindGroup({layout: bindGroupLayout6, entries: [{binding: 11, resource: {buffer: buffer102, offset: 0}}]}); |
| let commandEncoder166 = device0.createCommandEncoder({}); |
| let computePassEncoder125 = commandEncoder166.beginComputePass(); |
| try { |
| computePassEncoder71.end(); |
| } catch {} |
| try { |
| computePassEncoder23.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder11.draw(0, 79, 1, 797_414_109); |
| } catch {} |
| try { |
| renderPassEncoder11.drawIndexed(128, 98, 16, 68_770_610, 570_100_848); |
| } catch {} |
| let videoFrame22 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'unspecified', primaries: 'bt470m', transfer: 'bt709'} }); |
| let commandBuffer7 = commandEncoder97.finish(); |
| let textureView132 = texture112.createView({aspect: 'depth-only', mipLevelCount: 1, baseArrayLayer: 7, arrayLayerCount: 1}); |
| let sampler95 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| mipmapFilter: 'linear', |
| lodMinClamp: 9.854, |
| lodMaxClamp: 38.97, |
| }); |
| try { |
| renderPassEncoder11.drawIndexed(85, 134, 11, 395_962_503, 1_060_046_481); |
| } catch {} |
| let commandEncoder167 = device0.createCommandEncoder({}); |
| let textureView133 = texture20.createView({mipLevelCount: 1, baseArrayLayer: 1, arrayLayerCount: 2}); |
| let computePassEncoder126 = commandEncoder167.beginComputePass({}); |
| let sampler96 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| maxAnisotropy: 10, |
| }); |
| try { |
| computePassEncoder51.setBindGroup(2, bindGroup75, new Uint32Array(2561), 738, 0); |
| } catch {} |
| try { |
| computePassEncoder124.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder35.setBindGroup(0, bindGroup93); |
| } catch {} |
| try { |
| renderPassEncoder57.setBindGroup(3, bindGroup73, new Uint32Array(3643), 2_442, 0); |
| } catch {} |
| let imageData16 = new ImageData(12, 16); |
| let bindGroup96 = device0.createBindGroup({layout: bindGroupLayout1, entries: [{binding: 277, resource: sampler12}]}); |
| try { |
| computePassEncoder112.setBindGroup(0, bindGroup1); |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(0, bindGroup7, []); |
| } catch {} |
| try { |
| renderPassEncoder11.drawIndexed(5, 0, 74, 926_558_333, 43_022_389); |
| } catch {} |
| try { |
| renderPassEncoder14.setPipeline(pipeline1); |
| } catch {} |
| let commandEncoder168 = device0.createCommandEncoder({}); |
| let texture132 = device0.createTexture({ |
| size: [440], |
| dimension: '1d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let computePassEncoder127 = commandEncoder168.beginComputePass({}); |
| let renderBundleEncoder9 = device0.createRenderBundleEncoder({ |
| label: '\u5290\u4482\u6547\u{1f9d8}\u{1f90d}\u{1ff8f}\u0f75\u00c4\uba26', |
| colorFormats: ['rgb10a2unorm'], |
| depthStencilFormat: 'depth24plus', |
| }); |
| let sampler97 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'clamp-to-edge', |
| magFilter: 'linear', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 40.58, |
| lodMaxClamp: 44.94, |
| }); |
| try { |
| computePassEncoder108.setBindGroup(0, bindGroup16, []); |
| } catch {} |
| try { |
| computePassEncoder33.setBindGroup(3, bindGroup85, new Uint32Array(673), 108, 0); |
| } catch {} |
| try { |
| renderPassEncoder42.setBindGroup(0, bindGroup16, new Uint32Array(1059), 513, 0); |
| } catch {} |
| try { |
| renderPassEncoder11.drawIndexed(57, 20, 17, 76_148_165, 266_750_746); |
| } catch {} |
| try { |
| renderPassEncoder11.drawIndexedIndirect(buffer20, 104); |
| } catch {} |
| try { |
| renderPassEncoder11.drawIndirect(buffer19, 324); |
| } catch {} |
| try { |
| renderBundleEncoder9.setBindGroup(3, bindGroup8); |
| } catch {} |
| try { |
| renderBundleEncoder9.setBindGroup(2, bindGroup24, new Uint32Array(432), 19, 0); |
| } catch {} |
| try { |
| renderBundleEncoder9.setVertexBuffer(6, buffer62, 0); |
| } catch {} |
| try { |
| computePassEncoder98.setBindGroup(2, bindGroup11, new Uint32Array(2318), 14, 0); |
| } catch {} |
| try { |
| computePassEncoder39.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder41.setBindGroup(0, bindGroup27); |
| } catch {} |
| try { |
| renderPassEncoder53.setViewport(30.158332463208048, 0.3703301249095359, 22.527001102130544, 0.31567622919086413, 0.8306538929313358, 0.8710582432348876); |
| } catch {} |
| try { |
| renderPassEncoder11.draw(0, 191, 0, 802_813_346); |
| } catch {} |
| try { |
| renderPassEncoder11.drawIndexed(144, 101, 7, 688_451_846, 3_444_187); |
| } catch {} |
| try { |
| renderPassEncoder11.drawIndexedIndirect(buffer100, 672); |
| } catch {} |
| try { |
| renderPassEncoder41.setVertexBuffer(0, buffer83); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| let bindGroup97 = device0.createBindGroup({ |
| label: '\u150b\u37a6\u3a24\u2203\u0435\u{1fa0a}\u40d7', |
| layout: bindGroupLayout7, |
| entries: [{binding: 54, resource: {buffer: buffer107, offset: 6400}}, {binding: 53, resource: externalTexture12}], |
| }); |
| let texture133 = device0.createTexture({ |
| size: {width: 73, height: 1, depthOrArrayLayers: 51}, |
| dimension: '3d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let renderBundle9 = renderBundleEncoder9.finish({}); |
| try { |
| computePassEncoder69.end(); |
| } catch {} |
| try { |
| computePassEncoder126.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder25.setIndexBuffer(buffer105, 'uint16', 318, 179); |
| } catch {} |
| try { |
| renderPassEncoder28.setVertexBuffer(4, buffer91, 744, 681); |
| } catch {} |
| try { |
| buffer83.unmap(); |
| } catch {} |
| try { |
| commandEncoder93.copyTextureToBuffer({ |
| texture: texture79, |
| mipLevel: 2, |
| origin: {x: 28, y: 14, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 44 widthInBlocks: 11 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 740 */ |
| offset: 740, |
| bytesPerRow: 26880, |
| rowsPerImage: 413, |
| buffer: buffer87, |
| }, {width: 11, height: 3, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 96, height: 1, depthOrArrayLayers: 131} |
| */ |
| { |
| source: videoFrame16, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture18, |
| mipLevel: 0, |
| origin: {x: 8, y: 0, z: 8}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder169 = device0.createCommandEncoder(); |
| let computePassEncoder128 = commandEncoder169.beginComputePass({label: '\ua675\u0475\ub0b9\u85fc\uf737'}); |
| try { |
| computePassEncoder97.setBindGroup(0, bindGroup67, new Uint32Array(1727), 366, 0); |
| } catch {} |
| try { |
| computePassEncoder127.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder11.drawIndexedIndirect(buffer42, 4); |
| } catch {} |
| try { |
| renderPassEncoder14.setPipeline(pipeline1); |
| } catch {} |
| try { |
| commandEncoder93.copyBufferToTexture({ |
| /* bytesInLastRow: 8 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 3808 */ |
| offset: 3808, |
| bytesPerRow: 20224, |
| buffer: buffer11, |
| }, { |
| texture: texture81, |
| mipLevel: 0, |
| origin: {x: 43, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder93.resolveQuerySet(querySet2, 186, 818, buffer72, 2816); |
| } catch {} |
| try { |
| computePassEncoder96.insertDebugMarker('\ufa0b'); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| let bindGroupLayout19 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 361, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: true }, |
| }, |
| ], |
| }); |
| let buffer109 = device0.createBuffer({ |
| label: '\u9d73\u523a', |
| size: 2549, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| let commandEncoder170 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder117.setBindGroup(0, bindGroup23, new Uint32Array(1532), 488, 0); |
| } catch {} |
| try { |
| computePassEncoder128.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder11.drawIndexed(62, 140, 3, 139_945_384, 919_621_341); |
| } catch {} |
| try { |
| renderPassEncoder11.drawIndexedIndirect(buffer101, 1_764); |
| } catch {} |
| try { |
| renderPassEncoder11.drawIndirect(buffer95, 11_444); |
| } catch {} |
| try { |
| if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55); }; |
| } catch {} |
| let videoFrame23 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX', timestamp: 0, colorSpace: {fullRange: true, matrix: 'yCgCo', primaries: 'smpteRp431', transfer: 'iec6196624'} }); |
| let texture134 = device0.createTexture({ |
| size: {width: 440, height: 40, depthOrArrayLayers: 53}, |
| mipLevelCount: 2, |
| format: 'astc-8x5-unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let computePassEncoder129 = commandEncoder93.beginComputePass({}); |
| try { |
| computePassEncoder125.setPipeline(pipeline4); |
| } catch {} |
| try { |
| commandEncoder170.copyBufferToTexture({ |
| /* bytesInLastRow: 2696 widthInBlocks: 337 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 424 */ |
| offset: 424, |
| bytesPerRow: 27648, |
| buffer: buffer83, |
| }, { |
| texture: texture90, |
| mipLevel: 0, |
| origin: {x: 31, y: 124, z: 0}, |
| aspect: 'all', |
| }, {width: 337, height: 240, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.append(img3); |
| let computePassEncoder130 = commandEncoder170.beginComputePass({}); |
| try { |
| computePassEncoder49.setBindGroup(0, bindGroup42); |
| } catch {} |
| try { |
| computePassEncoder126.setBindGroup(1, bindGroup92, new Uint32Array(2033), 376, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder17); computePassEncoder17.dispatchWorkgroupsIndirect(buffer91, 180); }; |
| } catch {} |
| try { |
| computePassEncoder130.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder19.executeBundles([renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder11.draw(0, 373, 0, 92_941_230); |
| } catch {} |
| try { |
| renderPassEncoder11.drawIndexed(2, 238, 28, -1_603_230_451, 208_718_946); |
| } catch {} |
| try { |
| renderPassEncoder11.drawIndexedIndirect(buffer50, 232); |
| } catch {} |
| try { |
| renderPassEncoder11.drawIndirect(buffer15, 2_708); |
| } catch {} |
| try { |
| renderPassEncoder35.setIndexBuffer(buffer82, 'uint16', 28, 225); |
| } catch {} |
| try { |
| renderPassEncoder52.setVertexBuffer(5, undefined, 0, 1_158_042_292); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture86, |
| mipLevel: 1, |
| origin: {x: 25, y: 27, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(56).fill(190), /* required buffer size: 56 */ |
| {offset: 56, bytesPerRow: 613}, {width: 59, height: 11, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup98 = device0.createBindGroup({ |
| label: '\u339e\u0c14\u0d4e\u07fa\u3a12\u{1fca8}\u1431', |
| layout: bindGroupLayout18, |
| entries: [{binding: 204, resource: externalTexture3}, {binding: 116, resource: sampler30}], |
| }); |
| let commandEncoder171 = device0.createCommandEncoder(); |
| try { |
| computePassEncoder66.setBindGroup(2, bindGroup22, new Uint32Array(862), 355, 0); |
| } catch {} |
| try { |
| computePassEncoder129.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder11.draw(0, 117, 0, 3_961_748_105); |
| } catch {} |
| try { |
| renderPassEncoder11.drawIndexedIndirect(buffer50, 180); |
| } catch {} |
| try { |
| commandEncoder171.copyTextureToBuffer({ |
| texture: texture131, |
| mipLevel: 0, |
| origin: {x: 5, y: 29, z: 1}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 12 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 948 */ |
| offset: 948, |
| bytesPerRow: 3840, |
| buffer: buffer93, |
| }, {width: 3, height: 8, depthOrArrayLayers: 0}); |
| } catch {} |
| let textureView134 = texture90.createView({mipLevelCount: 1, baseArrayLayer: 0}); |
| let computePassEncoder131 = commandEncoder171.beginComputePass({label: '\u0844\u47e8'}); |
| try { |
| renderPassEncoder11.drawIndexed(9, 43, 8, 73_958_844, 136_920_061); |
| } catch {} |
| try { |
| commandEncoder82.label = '\u05a5\u7295'; |
| } catch {} |
| let buffer110 = device0.createBuffer({size: 64461, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC}); |
| let textureView135 = texture121.createView({dimension: '2d-array', format: 'rgba16sint', mipLevelCount: 1}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder47); computePassEncoder47.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder47); computePassEncoder47.dispatchWorkgroupsIndirect(buffer20, 0); }; |
| } catch {} |
| try { |
| renderPassEncoder11.draw(0, 316, 0, 281_349_712); |
| } catch {} |
| try { |
| renderPassEncoder11.drawIndexedIndirect(buffer22, 284); |
| } catch {} |
| let commandEncoder172 = device0.createCommandEncoder({}); |
| let textureView136 = texture70.createView({format: 'rgb10a2uint', arrayLayerCount: 1}); |
| let computePassEncoder132 = commandEncoder172.beginComputePass({}); |
| try { |
| computePassEncoder132.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder11.drawIndexedIndirect(buffer100, 140); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer74, 824, new BigUint64Array(45), 3, 0); |
| } catch {} |
| let bindGroup99 = device0.createBindGroup({ |
| layout: bindGroupLayout13, |
| entries: [{binding: 272, resource: {buffer: buffer8, offset: 0, size: 278}}], |
| }); |
| let buffer111 = device0.createBuffer({ |
| size: 3122, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let texture135 = device0.createTexture({ |
| size: {width: 64, height: 64, depthOrArrayLayers: 22}, |
| mipLevelCount: 2, |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_SRC, |
| }); |
| try { |
| computePassEncoder126.setBindGroup(0, bindGroup58); |
| } catch {} |
| try { |
| renderPassEncoder11.draw(0, 103, 0, 313_371_217); |
| } catch {} |
| try { |
| renderPassEncoder11.drawIndexed(4, 82, 73, 539_809_840, 90_586_416); |
| } catch {} |
| try { |
| renderPassEncoder11.drawIndexedIndirect(buffer25, 1_376); |
| } catch {} |
| let commandEncoder173 = device0.createCommandEncoder({}); |
| let texture136 = device0.createTexture({ |
| size: [280], |
| dimension: '1d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler98 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMaxClamp: 89.47, |
| }); |
| try { |
| computePassEncoder65.setBindGroup(0, bindGroup17); |
| } catch {} |
| try { |
| computePassEncoder128.setBindGroup(1, bindGroup24, new Uint32Array(921), 193, 0); |
| } catch {} |
| try { |
| renderPassEncoder11.drawIndexed(23, 106, 13, 27_750_970, 930_239_674); |
| } catch {} |
| try { |
| renderPassEncoder11.drawIndexedIndirect(buffer67, 420); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let buffer112 = device0.createBuffer({ |
| size: 11718, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let texture137 = device0.createTexture({ |
| size: [280, 291, 478], |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| computePassEncoder131.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder11.draw(0, 370, 0, 1_153_361_435); |
| } catch {} |
| try { |
| renderPassEncoder11.drawIndirect(buffer64, 1_192); |
| } catch {} |
| try { |
| renderPassEncoder43.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder33.setVertexBuffer(4, buffer64, 0, 1_510); |
| } catch {} |
| try { |
| commandEncoder173.copyBufferToBuffer(buffer65, 256, buffer82, 100, 396); |
| } catch {} |
| try { |
| commandEncoder173.copyBufferToTexture({ |
| /* bytesInLastRow: 16 widthInBlocks: 4 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 2920 */ |
| offset: 2920, |
| bytesPerRow: 34560, |
| buffer: buffer28, |
| }, { |
| texture: texture32, |
| mipLevel: 0, |
| origin: {x: 9, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 4, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let bindGroup100 = device0.createBindGroup({layout: bindGroupLayout10, entries: [{binding: 5, resource: sampler9}]}); |
| let texture138 = device0.createTexture({ |
| size: {width: 73, height: 1, depthOrArrayLayers: 32}, |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let computePassEncoder133 = commandEncoder173.beginComputePass(); |
| try { |
| computePassEncoder117.setBindGroup(2, bindGroup20, []); |
| } catch {} |
| try { |
| renderPassEncoder11.draw(0, 286, 0, 380_455_159); |
| } catch {} |
| try { |
| renderPassEncoder11.drawIndexedIndirect(buffer91, 68); |
| } catch {} |
| try { |
| renderPassEncoder24.setVertexBuffer(3, buffer6, 344); |
| } catch {} |
| let pipeline5 = await device0.createComputePipelineAsync({layout: pipelineLayout6, compute: {module: shaderModule12, entryPoint: 'compute11'}}); |
| let buffer113 = device0.createBuffer({size: 11118, usage: GPUBufferUsage.INDEX}); |
| let textureView137 = texture119.createView({mipLevelCount: 1, baseArrayLayer: 2, arrayLayerCount: 1}); |
| let sampler99 = device0.createSampler({ |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 96.72, |
| maxAnisotropy: 16, |
| }); |
| let externalTexture15 = device0.importExternalTexture({source: videoFrame18}); |
| try { |
| computePassEncoder126.setBindGroup(0, bindGroup39, new Uint32Array(3868), 2_888, 0); |
| } catch {} |
| try { |
| renderPassEncoder11.draw(0, 37, 0, 238_247_602); |
| } catch {} |
| try { |
| renderPassEncoder11.drawIndexed(37, 47, 22, 212_332_789, 448_551_578); |
| } catch {} |
| try { |
| renderPassEncoder11.drawIndexedIndirect(buffer87, 1_428); |
| } catch {} |
| try { |
| renderPassEncoder40.setVertexBuffer(0, buffer8, 320, 304); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer102, 168, new DataView(new ArrayBuffer(13841)), 2470, 48); |
| } catch {} |
| let buffer114 = device0.createBuffer({ |
| size: 1089, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE, |
| mappedAtCreation: false, |
| }); |
| let textureView138 = texture135.createView({mipLevelCount: 1, baseArrayLayer: 2, arrayLayerCount: 1}); |
| try { |
| computePassEncoder57.setBindGroup(1, bindGroup92, new Uint32Array(193), 9, 0); |
| } catch {} |
| try { |
| computePassEncoder34.end(); |
| } catch {} |
| try { |
| computePassEncoder133.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder54.setBindGroup(3, bindGroup44); |
| } catch {} |
| try { |
| renderPassEncoder11.end(); |
| } catch {} |
| try { |
| renderPassEncoder9.setVertexBuffer(6, buffer82, 0); |
| } catch {} |
| try { |
| commandEncoder47.copyTextureToTexture({ |
| texture: texture51, |
| mipLevel: 0, |
| origin: {x: 36, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture49, |
| mipLevel: 0, |
| origin: {x: 68, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 85, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder174 = device0.createCommandEncoder({}); |
| let texture139 = device0.createTexture({ |
| size: [64, 64, 22], |
| mipLevelCount: 3, |
| format: 'depth24plus', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder89.setBindGroup(0, bindGroup39); |
| } catch {} |
| try { |
| renderPassEncoder20.setBindGroup(0, bindGroup44, new Uint32Array(267), 1, 0); |
| } catch {} |
| try { |
| renderPassEncoder13.setScissorRect(39, 0, 0, 0); |
| } catch {} |
| try { |
| renderPassEncoder27.setIndexBuffer(buffer82, 'uint32', 752, 108); |
| } catch {} |
| try { |
| renderPassEncoder30.setPipeline(pipeline1); |
| } catch {} |
| try { |
| buffer53.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer109, 408, new Float32Array(6220), 1550, 104); |
| } catch {} |
| let commandEncoder175 = device0.createCommandEncoder(); |
| let texture140 = device0.createTexture({ |
| size: {width: 147}, |
| dimension: '1d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderPassEncoder63 = commandEncoder174.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView99, |
| depthSlice: 1, |
| clearValue: { r: 804.9, g: 69.95, b: 651.0, a: 569.1, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet9, |
| }); |
| let renderBundleEncoder10 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2uint'], depthReadOnly: true, stencilReadOnly: true}); |
| try { |
| renderPassEncoder9.setStencilReference(157); |
| } catch {} |
| try { |
| renderBundleEncoder10.setBindGroup(2, bindGroup75); |
| } catch {} |
| try { |
| buffer103.unmap(); |
| } catch {} |
| try { |
| commandEncoder47.clearBuffer(buffer61); |
| } catch {} |
| document.body.append(img1); |
| let imageData17 = new ImageData(88, 12); |
| let buffer115 = device0.createBuffer({ |
| label: '\u7ae4\u{1fc3a}', |
| size: 458, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let texture141 = device0.createTexture({ |
| label: '\u{1f7d9}\u0cd4\u876c\u7c80\u03ec\u{1f979}\u{1fc8c}\u0db5\u5f51\uc3a2', |
| size: {width: 384, height: 1, depthOrArrayLayers: 524}, |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView139 = texture2.createView({mipLevelCount: 1}); |
| let computePassEncoder134 = commandEncoder47.beginComputePass({}); |
| let renderBundle10 = renderBundleEncoder10.finish({}); |
| let externalTexture16 = device0.importExternalTexture({source: videoFrame5}); |
| try { |
| renderPassEncoder53.setBindGroup(3, bindGroup61); |
| } catch {} |
| try { |
| renderPassEncoder26.setBindGroup(0, bindGroup64, new Uint32Array(986), 320, 0); |
| } catch {} |
| try { |
| renderPassEncoder51.setBlendConstant({ r: -419.2, g: 900.4, b: 219.4, a: 724.0, }); |
| } catch {} |
| try { |
| renderPassEncoder35.setVertexBuffer(7, buffer86); |
| } catch {} |
| try { |
| commandEncoder40.copyTextureToTexture({ |
| texture: texture57, |
| mipLevel: 1, |
| origin: {x: 48, y: 48, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture6, |
| mipLevel: 0, |
| origin: {x: 11, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 9, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let bindGroup101 = device0.createBindGroup({layout: bindGroupLayout12, entries: [{binding: 39, resource: textureView103}]}); |
| let buffer116 = device0.createBuffer({ |
| size: 7234, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| try { |
| computePassEncoder134.setPipeline(pipeline2); |
| } catch {} |
| let texture142 = device0.createTexture({ |
| label: '\u0cdc\u8ef3\u{1f773}\u58c8\u2e7b\u346d\ufcce', |
| size: [384, 1, 524], |
| mipLevelCount: 2, |
| dimension: '3d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder91.setBindGroup(1, bindGroup25, new Uint32Array(1202), 21, 0); |
| } catch {} |
| try { |
| computePassEncoder36.end(); |
| } catch {} |
| try { |
| renderPassEncoder57.setBindGroup(0, bindGroup47); |
| } catch {} |
| let videoFrame24 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt709', primaries: 'bt709', transfer: 'bt2020_12bit'} }); |
| let bindGroup102 = device0.createBindGroup({ |
| layout: bindGroupLayout14, |
| entries: [ |
| {binding: 172, resource: textureView110}, |
| {binding: 462, resource: {buffer: buffer63, offset: 2560, size: 272}}, |
| {binding: 67, resource: textureView11}, |
| {binding: 8, resource: textureView109}, |
| {binding: 264, resource: sampler9}, |
| {binding: 57, resource: textureView108}, |
| {binding: 9, resource: textureView14}, |
| {binding: 51, resource: {buffer: buffer84, offset: 10496, size: 2368}}, |
| {binding: 153, resource: {buffer: buffer99, offset: 1792}}, |
| ], |
| }); |
| let texture143 = device0.createTexture({ |
| label: '\u0621\u1756\u66c5\u855b\u036d\u9a32\ube07\u{1f727}\u2de5\u{1f9e4}', |
| size: [110], |
| dimension: '1d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_SRC, |
| }); |
| let renderPassEncoder64 = commandEncoder40.beginRenderPass({ |
| label: '\u34fc\u{1f724}\uf671\u0b3c\u52d0', |
| colorAttachments: [{ |
| view: textureView52, |
| clearValue: { r: -518.0, g: -707.3, b: -852.2, a: 820.5, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet10, |
| }); |
| let sampler100 = device0.createSampler({ |
| label: '\u{1fddc}\ud30d\u046e\u0754\u0cc6\u7567\u{1f99b}', |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 40.28, |
| lodMaxClamp: 74.70, |
| maxAnisotropy: 14, |
| }); |
| try { |
| computePassEncoder17.setBindGroup(2, bindGroup10, new Uint32Array(157), 4, 0); |
| } catch {} |
| try { |
| renderPassEncoder37.setBindGroup(3, bindGroup30, new Uint32Array(2111), 174, 0); |
| } catch {} |
| try { |
| renderPassEncoder26.setIndexBuffer(buffer95, 'uint32', 6_800, 1_240); |
| } catch {} |
| try { |
| await buffer5.mapAsync(GPUMapMode.READ, 0, 5056); |
| } catch {} |
| try { |
| commandEncoder51.copyBufferToBuffer(buffer84, 204, buffer23, 724, 5440); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer7]); |
| } catch {} |
| try { |
| if (!arrayBuffer9.detached) { new Uint8Array(arrayBuffer9).fill(0x55); }; |
| } catch {} |
| let bindGroup103 = device0.createBindGroup({ |
| layout: bindGroupLayout13, |
| entries: [{binding: 272, resource: {buffer: buffer37, offset: 0, size: 1058}}], |
| }); |
| let commandEncoder176 = device0.createCommandEncoder({}); |
| let textureView140 = texture19.createView({}); |
| try { |
| renderPassEncoder37.executeBundles([renderBundle6]); |
| } catch {} |
| try { |
| commandEncoder51.copyBufferToBuffer(buffer95, 2836, buffer61, 344, 516); |
| } catch {} |
| let pipelineLayout7 = device0.createPipelineLayout({bindGroupLayouts: []}); |
| let commandEncoder177 = device0.createCommandEncoder({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder40); computePassEncoder40.dispatchWorkgroupsIndirect(buffer54, 1_724); }; |
| } catch {} |
| try { |
| renderPassEncoder40.setBindGroup(0, bindGroup31, new Uint32Array(761), 40, 0); |
| } catch {} |
| document.body.prepend(img1); |
| let imageData18 = new ImageData(16, 16); |
| let commandEncoder178 = device0.createCommandEncoder({}); |
| let computePassEncoder135 = commandEncoder176.beginComputePass({label: '\u{1f7f3}\u0e99\uae37\uda16'}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder47); computePassEncoder47.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| renderPassEncoder16.setVertexBuffer(1, buffer59, 116); |
| } catch {} |
| try { |
| globalThis.someLabel = externalTexture12.label; |
| } catch {} |
| let buffer117 = device0.createBuffer({size: 21285, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let textureView141 = texture23.createView({ |
| label: '\u{1fe20}\ua21c\u0a9e\ub701\u{1f873}\u6b4b\u{1fd31}\u6724\u{1f8ad}', |
| aspect: 'all', |
| baseMipLevel: 2, |
| mipLevelCount: 1, |
| arrayLayerCount: 1, |
| }); |
| let computePassEncoder136 = commandEncoder175.beginComputePass({}); |
| try { |
| renderPassEncoder28.setBindGroup(3, bindGroup51, []); |
| } catch {} |
| try { |
| renderPassEncoder27.setIndexBuffer(buffer30, 'uint16', 18, 10); |
| } catch {} |
| try { |
| renderPassEncoder9.setVertexBuffer(0, buffer102, 0); |
| } catch {} |
| try { |
| commandEncoder177.copyBufferToTexture({ |
| /* bytesInLastRow: 280 widthInBlocks: 280 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 332 */ |
| offset: 332, |
| bytesPerRow: 18432, |
| buffer: buffer95, |
| }, { |
| texture: texture46, |
| mipLevel: 0, |
| origin: {x: 0, y: 65, z: 0}, |
| aspect: 'stencil-only', |
| }, {width: 280, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let imageData19 = new ImageData(88, 80); |
| let pipelineLayout8 = device0.createPipelineLayout({bindGroupLayouts: [bindGroupLayout2]}); |
| let buffer118 = device0.createBuffer({size: 688, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE}); |
| try { |
| computePassEncoder113.setBindGroup(3, bindGroup57); |
| } catch {} |
| try { |
| computePassEncoder60.end(); |
| } catch {} |
| try { |
| computePassEncoder135.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder0.setBindGroup(1, bindGroup56, new Uint32Array(3200), 542, 0); |
| } catch {} |
| let promise14 = shaderModule7.getCompilationInfo(); |
| let promise15 = device0.queue.onSubmittedWorkDone(); |
| let commandEncoder179 = device0.createCommandEncoder({}); |
| let computePassEncoder137 = commandEncoder178.beginComputePass({}); |
| let renderPassEncoder65 = commandEncoder177.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView5, |
| clearValue: { r: -617.1, g: -255.1, b: -621.4, a: 398.3, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| maxDrawCount: 122772277, |
| }); |
| try { |
| computePassEncoder136.setPipeline(pipeline0); |
| } catch {} |
| try { |
| commandEncoder51.copyBufferToBuffer(buffer43, 960, buffer81, 832, 2088); |
| } catch {} |
| try { |
| commandEncoder179.copyBufferToTexture({ |
| /* bytesInLastRow: 88 widthInBlocks: 22 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 292 */ |
| offset: 292, |
| buffer: buffer56, |
| }, { |
| texture: texture113, |
| mipLevel: 0, |
| origin: {x: 17, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 22, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder179.copyTextureToTexture({ |
| texture: texture4, |
| mipLevel: 0, |
| origin: {x: 1, y: 11, z: 3}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture5, |
| mipLevel: 0, |
| origin: {x: 25, y: 0, z: 1}, |
| aspect: 'all', |
| }, |
| {width: 4, height: 0, depthOrArrayLayers: 4}); |
| } catch {} |
| let bindGroup104 = device0.createBindGroup({layout: bindGroupLayout15, entries: [{binding: 44, resource: externalTexture13}]}); |
| let texture144 = device0.createTexture({ |
| size: [147], |
| sampleCount: 1, |
| dimension: '1d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder138 = commandEncoder179.beginComputePass({label: '\u0150\u{1faed}\u06e4\u{1f6d2}\u{1fb9a}\ubf38\u0ea1\u6937'}); |
| try { |
| computePassEncoder95.setBindGroup(0, bindGroup86, new Uint32Array(4985), 1_196, 0); |
| } catch {} |
| try { |
| computePassEncoder137.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder43.setIndexBuffer(buffer115, 'uint16', 208, 1); |
| } catch {} |
| try { |
| renderPassEncoder6.setVertexBuffer(5, buffer100, 0, 1_102); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let commandBuffer8 = commandEncoder85.finish(); |
| let computePassEncoder139 = commandEncoder51.beginComputePass({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder117); computePassEncoder117.dispatchWorkgroupsIndirect(buffer25, 644); }; |
| } catch {} |
| try { |
| computePassEncoder139.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder22.setBindGroup(3, bindGroup45); |
| } catch {} |
| try { |
| renderPassEncoder12.setBindGroup(2, bindGroup16, new Uint32Array(18), 4, 0); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer8]); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 73, height: 1, depthOrArrayLayers: 32} |
| */ |
| { |
| source: imageData16, |
| origin: { x: 3, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture138, |
| mipLevel: 0, |
| origin: {x: 26, y: 0, z: 1}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(img1); |
| try { |
| adapter0.label = '\u0134\uf05e'; |
| } catch {} |
| let renderBundleEncoder11 = device0.createRenderBundleEncoder({ |
| label: '\u2143\uf8e1', |
| colorFormats: ['rgb10a2unorm'], |
| depthStencilFormat: 'depth24plus', |
| stencilReadOnly: true, |
| }); |
| try { |
| renderPassEncoder58.executeBundles([renderBundle6]); |
| } catch {} |
| try { |
| renderPassEncoder48.setVertexBuffer(3, buffer109, 48); |
| } catch {} |
| try { |
| renderBundleEncoder11.setBindGroup(0, bindGroup10); |
| } catch {} |
| try { |
| renderBundleEncoder11.setIndexBuffer(buffer13, 'uint16', 522, 1_919); |
| } catch {} |
| try { |
| buffer28.unmap(); |
| } catch {} |
| let textureView142 = texture143.createView({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder101); computePassEncoder101.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer91, 'uint16', 6_312, 894); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer83, 2232, new BigUint64Array(5731), 767, 260); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| renderPassEncoder53.setVertexBuffer(4, buffer83); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer115, 20, new BigUint64Array(14283), 901, 4); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture49, |
| mipLevel: 0, |
| origin: {x: 35, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(87).fill(75), /* required buffer size: 87 */ |
| {offset: 87}, {width: 182, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| if (!arrayBuffer9.detached) { new Uint8Array(arrayBuffer9).fill(0x55); }; |
| } catch {} |
| let commandEncoder180 = device0.createCommandEncoder({}); |
| let computePassEncoder140 = commandEncoder180.beginComputePass({}); |
| let sampler101 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'nearest', |
| lodMinClamp: 11.32, |
| lodMaxClamp: 99.08, |
| }); |
| try { |
| computePassEncoder63.setBindGroup(2, bindGroup39, new Uint32Array(2585), 18, 0); |
| } catch {} |
| try { |
| computePassEncoder117.end(); |
| } catch {} |
| try { |
| renderPassEncoder64.setBindGroup(3, bindGroup37, new Uint32Array(137), 1, 0); |
| } catch {} |
| try { |
| renderPassEncoder53.setVertexBuffer(7, buffer43, 0); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let querySet16 = device0.createQuerySet({type: 'occlusion', count: 640}); |
| let commandBuffer9 = commandEncoder158.finish(); |
| try { |
| renderPassEncoder48.setBindGroup(2, bindGroup52, new Uint32Array(520), 86, 0); |
| } catch {} |
| try { |
| renderPassEncoder23.setIndexBuffer(buffer42, 'uint16', 1_028, 268); |
| } catch {} |
| try { |
| renderBundleEncoder11.setBindGroup(2, bindGroup26); |
| } catch {} |
| try { |
| renderBundleEncoder11.setBindGroup(2, bindGroup26, new Uint32Array(1146), 48, 0); |
| } catch {} |
| try { |
| renderBundleEncoder11.setVertexBuffer(4, buffer103, 0, 29); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture49, |
| mipLevel: 0, |
| origin: {x: 6, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(112).fill(188), /* required buffer size: 112 */ |
| {offset: 112}, {width: 6, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer119 = device0.createBuffer({size: 11535, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.UNIFORM}); |
| let textureView143 = texture5.createView({}); |
| let sampler102 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 20.11, |
| lodMaxClamp: 52.02, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder40); computePassEncoder40.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder112); computePassEncoder112.dispatchWorkgroupsIndirect(buffer105, 416); }; |
| } catch {} |
| try { |
| renderPassEncoder61.beginOcclusionQuery(34); |
| } catch {} |
| try { |
| renderPassEncoder22.setIndexBuffer(buffer82, 'uint16', 24, 69); |
| } catch {} |
| try { |
| renderPassEncoder10.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder11.setBindGroup(1, bindGroup54, new Uint32Array(584), 123, 0); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({device: device0, format: 'bgra8unorm', usage: GPUTextureUsage.COPY_DST, colorSpace: 'srgb'}); |
| } catch {} |
| let commandEncoder181 = device0.createCommandEncoder({}); |
| let texture145 = device0.createTexture({ |
| size: {width: 48, height: 1, depthOrArrayLayers: 1}, |
| format: 'depth24plus', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| try { |
| computePassEncoder17.end(); |
| } catch {} |
| try { |
| computePassEncoder140.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder28.setScissorRect(2, 0, 31, 11); |
| } catch {} |
| try { |
| renderPassEncoder46.setIndexBuffer(buffer57, 'uint32', 716, 1_536); |
| } catch {} |
| try { |
| renderBundleEncoder11.setIndexBuffer(buffer105, 'uint32', 480, 87); |
| } catch {} |
| try { |
| renderBundleEncoder11.setVertexBuffer(7, buffer89); |
| } catch {} |
| try { |
| commandEncoder181.copyTextureToTexture({ |
| texture: texture131, |
| mipLevel: 0, |
| origin: {x: 19, y: 28, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture84, |
| mipLevel: 0, |
| origin: {x: 47, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 4, height: 2, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.append(canvas1); |
| let buffer120 = device0.createBuffer({ |
| size: 2101, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let textureView144 = texture121.createView({mipLevelCount: 1}); |
| let sampler103 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 70.79, |
| lodMaxClamp: 87.98, |
| }); |
| try { |
| renderPassEncoder61.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder22.setIndexBuffer(buffer59, 'uint16', 618, 66); |
| } catch {} |
| try { |
| renderPassEncoder45.setVertexBuffer(3, undefined); |
| } catch {} |
| try { |
| renderBundleEncoder11.setBindGroup(3, bindGroup50, new Uint32Array(303), 10, 0); |
| } catch {} |
| try { |
| commandEncoder24.copyTextureToTexture({ |
| texture: texture79, |
| mipLevel: 1, |
| origin: {x: 0, y: 8, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture44, |
| mipLevel: 0, |
| origin: {x: 25, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 10, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let computePassEncoder141 = commandEncoder181.beginComputePass({}); |
| let renderBundleEncoder12 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2uint'], sampleCount: 4, stencilReadOnly: true}); |
| try { |
| computePassEncoder79.setBindGroup(0, bindGroup79); |
| } catch {} |
| try { |
| renderPassEncoder29.executeBundles([renderBundle5, renderBundle7]); |
| } catch {} |
| try { |
| renderPassEncoder49.setVertexBuffer(5, buffer4, 916, 3_441); |
| } catch {} |
| try { |
| renderBundleEncoder11.setBindGroup(3, bindGroup72, new Uint32Array(6079), 68, 0); |
| } catch {} |
| try { |
| commandEncoder24.copyBufferToTexture({ |
| /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1924 */ |
| offset: 1924, |
| rowsPerImage: 265, |
| buffer: buffer7, |
| }, { |
| texture: texture52, |
| mipLevel: 0, |
| origin: {x: 15, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer9]); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| document.body.prepend(canvas0); |
| await gc(); |
| let texture146 = device0.createTexture({ |
| label: '\ua1ad\uab35\ua31b\u0001\u0796', |
| size: {width: 192, height: 1, depthOrArrayLayers: 55}, |
| mipLevelCount: 5, |
| format: 'depth24plus', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder142 = commandEncoder24.beginComputePass({}); |
| let renderBundleEncoder13 = device0.createRenderBundleEncoder({colorFormats: ['rgba16sint'], depthReadOnly: true}); |
| try { |
| renderPassEncoder19.setIndexBuffer(buffer1, 'uint16', 28, 3); |
| } catch {} |
| try { |
| renderBundleEncoder13.setBindGroup(3, bindGroup101, []); |
| } catch {} |
| try { |
| renderBundleEncoder13.setVertexBuffer(7, buffer65); |
| } catch {} |
| let bindGroup105 = device0.createBindGroup({ |
| label: '\uf179\u07aa\u943a\u{1fea3}\u0e5c\ud272\u89c8', |
| layout: bindGroupLayout2, |
| entries: [ |
| {binding: 421, resource: {buffer: buffer87, offset: 1024, size: 192}}, |
| {binding: 42, resource: externalTexture5}, |
| {binding: 398, resource: textureView57}, |
| {binding: 243, resource: textureView91}, |
| {binding: 35, resource: textureView118}, |
| {binding: 94, resource: textureView63}, |
| {binding: 567, resource: textureView14}, |
| {binding: 132, resource: textureView64}, |
| {binding: 999, resource: textureView79}, |
| ], |
| }); |
| let textureView145 = texture55.createView({dimension: '2d-array'}); |
| try { |
| computePassEncoder101.setBindGroup(1, bindGroup103, new Uint32Array(3527), 156, 0); |
| } catch {} |
| try { |
| renderBundleEncoder13.setVertexBuffer(6, buffer15, 116); |
| } catch {} |
| try { |
| await promise15; |
| } catch {} |
| let bindGroup106 = device0.createBindGroup({ |
| layout: bindGroupLayout17, |
| entries: [{binding: 78, resource: sampler56}, {binding: 113, resource: textureView109}], |
| }); |
| let textureView146 = texture105.createView({label: '\u0902\u0f56', dimension: '3d', aspect: 'all'}); |
| let texture147 = device0.createTexture({ |
| size: {width: 192, height: 1, depthOrArrayLayers: 262}, |
| dimension: '3d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder127.setBindGroup(0, bindGroup0); |
| } catch {} |
| try { |
| renderPassEncoder5.setBindGroup(1, bindGroup54, new Uint32Array(3680), 113, 0); |
| } catch {} |
| try { |
| renderPassEncoder49.setStencilReference(17); |
| } catch {} |
| try { |
| renderPassEncoder57.setViewport(46.73079930747636, 0.18432837143760883, 23.177218678183426, 0.025061073792121143, 0.6940334567536122, 0.8109878259282833); |
| } catch {} |
| try { |
| renderPassEncoder48.setVertexBuffer(6, buffer99, 1_708); |
| } catch {} |
| try { |
| renderBundleEncoder11.setBindGroup(0, bindGroup92, []); |
| } catch {} |
| try { |
| renderBundleEncoder12.setIndexBuffer(buffer120, 'uint32', 740, 429); |
| } catch {} |
| try { |
| renderBundleEncoder13.setVertexBuffer(1, buffer43); |
| } catch {} |
| try { |
| await promise14; |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let textureView147 = texture40.createView({dimension: '2d-array', baseMipLevel: 0}); |
| let sampler104 = device0.createSampler({ |
| addressModeV: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 95.97, |
| lodMaxClamp: 99.42, |
| compare: 'less', |
| maxAnisotropy: 19, |
| }); |
| try { |
| computePassEncoder19.setBindGroup(3, bindGroup91); |
| } catch {} |
| try { |
| computePassEncoder7.setBindGroup(2, bindGroup98, new Uint32Array(131), 3, 0); |
| } catch {} |
| try { |
| computePassEncoder142.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer112, 'uint32', 572, 845); |
| } catch {} |
| try { |
| renderPassEncoder13.setVertexBuffer(0, buffer101); |
| } catch {} |
| try { |
| renderBundleEncoder12.setBindGroup(3, bindGroup35, new Uint32Array(1959), 87, 0); |
| } catch {} |
| try { |
| renderBundleEncoder11.setIndexBuffer(buffer84, 'uint32', 5_276, 2_475); |
| } catch {} |
| try { |
| renderBundleEncoder13.setVertexBuffer(7, buffer62, 400, 2_684); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture20, |
| mipLevel: 2, |
| origin: {x: 4, y: 1, z: 2}, |
| aspect: 'all', |
| }, new Uint8Array(190_848).fill(223), /* required buffer size: 190_848 */ |
| {offset: 448, bytesPerRow: 136, rowsPerImage: 56}, {width: 8, height: 0, depthOrArrayLayers: 26}); |
| } catch {} |
| let promise16 = device0.queue.onSubmittedWorkDone(); |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 73, height: 1, depthOrArrayLayers: 54} |
| */ |
| { |
| source: videoFrame13, |
| origin: { x: 0, y: 1 }, |
| flipY: true, |
| }, { |
| texture: texture5, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer121 = device0.createBuffer({ |
| size: 2398, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM, |
| }); |
| let commandEncoder182 = device0.createCommandEncoder({label: '\ue3db\u{1f740}'}); |
| let texture148 = gpuCanvasContext1.getCurrentTexture(); |
| let computePassEncoder143 = commandEncoder182.beginComputePass({}); |
| let sampler105 = device0.createSampler({addressModeV: 'clamp-to-edge', addressModeW: 'clamp-to-edge', lodMinClamp: 65.11, lodMaxClamp: 85.78}); |
| try { |
| computePassEncoder139.setBindGroup(2, bindGroup43); |
| } catch {} |
| try { |
| computePassEncoder57.setBindGroup(0, bindGroup19, new Uint32Array(1902), 624, 0); |
| } catch {} |
| try { |
| computePassEncoder138.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(1, bindGroup37, new Uint32Array(445), 55, 0); |
| } catch {} |
| try { |
| renderBundleEncoder12.setBindGroup(0, bindGroup75, new Uint32Array(108), 14, 0); |
| } catch {} |
| try { |
| renderBundleEncoder12.setIndexBuffer(buffer53, 'uint32', 52, 225); |
| } catch {} |
| try { |
| renderBundleEncoder13.setVertexBuffer(2, buffer51); |
| } catch {} |
| let bindGroup107 = device0.createBindGroup({ |
| layout: bindGroupLayout5, |
| entries: [ |
| {binding: 211, resource: sampler56}, |
| {binding: 62, resource: textureView91}, |
| {binding: 86, resource: textureView125}, |
| ], |
| }); |
| let textureView148 = texture7.createView({}); |
| try { |
| computePassEncoder91.setBindGroup(1, bindGroup11); |
| } catch {} |
| try { |
| computePassEncoder143.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder44.setBindGroup(3, bindGroup68); |
| } catch {} |
| try { |
| renderPassEncoder40.setIndexBuffer(buffer89, 'uint16', 876, 211); |
| } catch {} |
| try { |
| renderBundleEncoder11.insertDebugMarker('\u7ec0'); |
| } catch {} |
| let texture149 = device0.createTexture({ |
| size: [384, 1, 1], |
| format: 'depth24plus', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView149 = texture118.createView({aspect: 'depth-only', mipLevelCount: 1, baseArrayLayer: 1, arrayLayerCount: 2}); |
| try { |
| computePassEncoder97.setBindGroup(0, bindGroup56, new Uint32Array(1419), 182, 0); |
| } catch {} |
| try { |
| computePassEncoder141.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder65.setBindGroup(3, bindGroup85); |
| } catch {} |
| try { |
| renderPassEncoder33.setBindGroup(2, bindGroup41, new Uint32Array(1176), 302, 0); |
| } catch {} |
| try { |
| renderPassEncoder9.setIndexBuffer(buffer81, 'uint32', 1_500, 140); |
| } catch {} |
| try { |
| renderPassEncoder25.setVertexBuffer(2, buffer83, 388); |
| } catch {} |
| try { |
| renderBundleEncoder11.setIndexBuffer(buffer26, 'uint32', 888, 29); |
| } catch {} |
| try { |
| renderBundleEncoder12.setVertexBuffer(4, buffer62, 0, 3_515); |
| } catch {} |
| try { |
| computePassEncoder25.insertDebugMarker('\u83d2'); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 147, height: 1, depthOrArrayLayers: 9} |
| */ |
| { |
| source: imageBitmap0, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture110, |
| mipLevel: 1, |
| origin: {x: 17, y: 0, z: 4}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture150 = device0.createTexture({ |
| size: [55, 5, 39], |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rgb10a2uint'], |
| }); |
| let texture151 = gpuCanvasContext0.getCurrentTexture(); |
| try { |
| renderPassEncoder38.setScissorRect(83, 104, 282, 88); |
| } catch {} |
| let imageData20 = new ImageData(12, 64); |
| let commandEncoder183 = device0.createCommandEncoder({}); |
| let sampler106 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| lodMinClamp: 35.75, |
| lodMaxClamp: 78.34, |
| }); |
| try { |
| renderPassEncoder31.setIndexBuffer(buffer115, 'uint32', 92, 8); |
| } catch {} |
| try { |
| renderBundleEncoder13.setBindGroup(3, bindGroup55, new Uint32Array(1499), 249, 0); |
| } catch {} |
| try { |
| commandEncoder183.copyTextureToTexture({ |
| texture: texture130, |
| mipLevel: 1, |
| origin: {x: 6, y: 0, z: 3}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture7, |
| mipLevel: 0, |
| origin: {x: 14, y: 0, z: 20}, |
| aspect: 'all', |
| }, |
| {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder183.resolveQuerySet(querySet1, 34, 4, buffer46, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 140, height: 145, depthOrArrayLayers: 239} |
| */ |
| { |
| source: offscreenCanvas1, |
| origin: { x: 20, y: 5 }, |
| flipY: true, |
| }, { |
| texture: texture137, |
| mipLevel: 1, |
| origin: {x: 8, y: 24, z: 26}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 66, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup108 = device0.createBindGroup({ |
| label: '\u93e5\u{1fd03}\u{1fbdb}', |
| layout: bindGroupLayout11, |
| entries: [{binding: 52, resource: textureView47}, {binding: 57, resource: textureView20}], |
| }); |
| let commandEncoder184 = device0.createCommandEncoder({}); |
| let computePassEncoder144 = commandEncoder183.beginComputePass({}); |
| try { |
| renderPassEncoder55.setBindGroup(3, bindGroup28); |
| } catch {} |
| try { |
| renderPassEncoder32.executeBundles([renderBundle3]); |
| } catch {} |
| try { |
| renderBundleEncoder12.setBindGroup(2, bindGroup35); |
| } catch {} |
| try { |
| renderBundleEncoder11.setBindGroup(0, bindGroup22, new Uint32Array(3178), 1_230, 0); |
| } catch {} |
| try { |
| renderBundleEncoder13.setIndexBuffer(buffer79, 'uint16', 874, 1_144); |
| } catch {} |
| try { |
| commandEncoder184.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 5452 */ |
| offset: 5452, |
| bytesPerRow: 6656, |
| buffer: buffer91, |
| }, { |
| texture: texture75, |
| mipLevel: 2, |
| origin: {x: 0, y: 2, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 3, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let offscreenCanvas2 = new OffscreenCanvas(174, 70); |
| let textureView150 = texture25.createView({label: '\u0083\u0793\ua35c\u{1fc47}\u06f1\u0cfd\u02ca\u7266', mipLevelCount: 1}); |
| let computePassEncoder145 = commandEncoder184.beginComputePass({}); |
| try { |
| computePassEncoder47.end(); |
| } catch {} |
| try { |
| computePassEncoder144.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder18.executeBundles([renderBundle7, renderBundle7]); |
| } catch {} |
| try { |
| renderPassEncoder29.setIndexBuffer(buffer109, 'uint32', 1_060, 605); |
| } catch {} |
| try { |
| renderPassEncoder27.setVertexBuffer(5, buffer42, 0, 62); |
| } catch {} |
| try { |
| renderBundleEncoder11.setBindGroup(2, bindGroup53); |
| } catch {} |
| try { |
| renderBundleEncoder11.setBindGroup(2, bindGroup42, new Uint32Array(355), 213, 0); |
| } catch {} |
| try { |
| commandEncoder67.insertDebugMarker('\u0a15'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer112, 1604, new Int16Array(2806), 510, 104); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 96, height: 1, depthOrArrayLayers: 131} |
| */ |
| { |
| source: imageData1, |
| origin: { x: 5, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture18, |
| mipLevel: 0, |
| origin: {x: 20, y: 0, z: 15}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 10, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(img3); |
| let commandEncoder185 = device0.createCommandEncoder({label: '\uee3a\u{1f66e}'}); |
| try { |
| computePassEncoder145.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder44.beginOcclusionQuery(6); |
| } catch {} |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer91, 'uint16', 56, 2_983); |
| } catch {} |
| try { |
| renderBundleEncoder11.setBindGroup(2, bindGroup81); |
| } catch {} |
| try { |
| commandEncoder67.copyTextureToTexture({ |
| texture: texture79, |
| mipLevel: 0, |
| origin: {x: 14, y: 197, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture76, |
| mipLevel: 2, |
| origin: {x: 1, y: 1, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 147, height: 1, depthOrArrayLayers: 9} |
| */ |
| { |
| source: videoFrame13, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture110, |
| mipLevel: 1, |
| origin: {x: 5, y: 0, z: 1}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| renderPassEncoder54.setBindGroup(1, bindGroup44, new Uint32Array(3242), 3_242, 0); |
| } catch {} |
| try { |
| renderPassEncoder63.setBlendConstant({ r: -768.2, g: -729.3, b: 978.2, a: 556.5, }); |
| } catch {} |
| try { |
| renderPassEncoder10.setPipeline(pipeline1); |
| } catch {} |
| await gc(); |
| let texture152 = gpuCanvasContext0.getCurrentTexture(); |
| let computePassEncoder146 = commandEncoder67.beginComputePass(); |
| let renderPassEncoder66 = commandEncoder185.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView5, |
| clearValue: { r: -679.6, g: 139.4, b: -997.9, a: 350.3, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet9, |
| }); |
| let renderBundle11 = renderBundleEncoder13.finish({label: '\u{1f637}\u00e6\ufc85\ud1aa\u0d0e\u{1fbb1}\u0291\u7e91\u25be\u6f47\u3b5f'}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder110); computePassEncoder110.dispatchWorkgroupsIndirect(buffer72, 52); }; |
| } catch {} |
| try { |
| renderPassEncoder20.setBindGroup(2, bindGroup48); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 96, height: 1, depthOrArrayLayers: 131} |
| */ |
| { |
| source: imageData8, |
| origin: { x: 0, y: 7 }, |
| flipY: false, |
| }, { |
| texture: texture18, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 47}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer122 = device0.createBuffer({size: 2312, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let commandEncoder186 = device0.createCommandEncoder({}); |
| let computePassEncoder147 = commandEncoder186.beginComputePass({label: '\u{1f61a}\u0a14\u{1f81e}\u8c21\u{1fc39}\u{1f922}\ucad3'}); |
| try { |
| renderPassEncoder56.setBindGroup(1, bindGroup31); |
| } catch {} |
| try { |
| renderPassEncoder49.executeBundles([renderBundle5]); |
| } catch {} |
| try { |
| renderBundleEncoder12.setBindGroup(0, bindGroup13); |
| } catch {} |
| try { |
| renderBundleEncoder11.setIndexBuffer(buffer16, 'uint16', 7_544, 1_470); |
| } catch {} |
| try { |
| buffer47.unmap(); |
| } catch {} |
| let promise17 = device0.queue.onSubmittedWorkDone(); |
| let videoFrame25 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX', timestamp: 0, colorSpace: {fullRange: true, matrix: 'unspecified', primaries: 'smpteRp431', transfer: 'smpte240m'} }); |
| let textureView151 = texture18.createView({}); |
| try { |
| computePassEncoder147.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder22.setBindGroup(2, bindGroup105, []); |
| } catch {} |
| try { |
| renderPassEncoder31.setIndexBuffer(buffer80, 'uint16', 3_238, 1_792); |
| } catch {} |
| try { |
| renderBundleEncoder11.setVertexBuffer(1, buffer112, 0, 1_581); |
| } catch {} |
| try { |
| buffer56.unmap(); |
| } catch {} |
| let videoFrame26 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-cl', primaries: 'smpte240m', transfer: 'pq'} }); |
| let texture153 = device0.createTexture({ |
| size: [560, 582, 1], |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let externalTexture17 = device0.importExternalTexture({source: videoFrame23, colorSpace: 'srgb'}); |
| try { |
| computePassEncoder146.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder44.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder9.executeBundles([renderBundle11, renderBundle11, renderBundle5]); |
| } catch {} |
| let textureView152 = texture125.createView({aspect: 'all'}); |
| try { |
| renderPassEncoder52.setBindGroup(1, bindGroup44, new Uint32Array(1094), 64, 0); |
| } catch {} |
| try { |
| renderPassEncoder58.setVertexBuffer(1, buffer65, 420, 27); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| let buffer123 = device0.createBuffer({size: 0, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM}); |
| try { |
| computePassEncoder39.setBindGroup(0, bindGroup50); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder42); computePassEncoder42.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder40); computePassEncoder40.dispatchWorkgroupsIndirect(buffer72, 2_204); }; |
| } catch {} |
| try { |
| renderBundleEncoder12.setIndexBuffer(buffer53, 'uint32', 2_404, 1_160); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 73, height: 1, depthOrArrayLayers: 32} |
| */ |
| { |
| source: videoFrame20, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture138, |
| mipLevel: 0, |
| origin: {x: 7, y: 0, z: 11}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let pipelineLayout9 = device0.createPipelineLayout({bindGroupLayouts: []}); |
| try { |
| renderPassEncoder7.setBindGroup(2, bindGroup74, new Uint32Array(97), 1, 0); |
| } catch {} |
| try { |
| renderPassEncoder4.executeBundles([renderBundle11]); |
| } catch {} |
| let gpuCanvasContext2 = offscreenCanvas2.getContext('webgpu'); |
| let imageData21 = new ImageData(56, 12); |
| let commandEncoder187 = device0.createCommandEncoder(); |
| let computePassEncoder148 = commandEncoder187.beginComputePass({}); |
| let renderBundle12 = renderBundleEncoder12.finish(); |
| try { |
| computePassEncoder103.setBindGroup(3, bindGroup49); |
| } catch {} |
| try { |
| computePassEncoder110.end(); |
| } catch {} |
| try { |
| renderPassEncoder49.setVertexBuffer(3, undefined, 1_251_762_401, 140_067_163); |
| } catch {} |
| try { |
| renderBundleEncoder11.setBindGroup(1, bindGroup12, new Uint32Array(429), 60, 0); |
| } catch {} |
| try { |
| if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55); }; |
| } catch {} |
| let querySet17 = device0.createQuerySet({ |
| label: '\u658e\u1e35\udc9d\u{1fdaa}\ub1bb\u{1f712}\u90fe\u{1fd7c}\u{1fc0f}\u{1f9c2}\u57c4', |
| type: 'occlusion', |
| count: 752, |
| }); |
| try { |
| computePassEncoder142.setBindGroup(1, bindGroup25); |
| } catch {} |
| try { |
| computePassEncoder101.end(); |
| } catch {} |
| try { |
| computePassEncoder148.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder5.setBindGroup(2, bindGroup40, new Uint32Array(2334), 72, 0); |
| } catch {} |
| try { |
| renderPassEncoder62.setIndexBuffer(buffer42, 'uint16', 396, 13); |
| } catch {} |
| try { |
| renderBundleEncoder11.setBindGroup(3, bindGroup7); |
| } catch {} |
| try { |
| renderBundleEncoder11.setBindGroup(3, bindGroup31, new Uint32Array(332), 107, 0); |
| } catch {} |
| try { |
| renderBundleEncoder11.setVertexBuffer(1, buffer91); |
| } catch {} |
| try { |
| commandEncoder138.copyBufferToBuffer(buffer23, 10488, buffer103, 60, 16); |
| } catch {} |
| let commandEncoder188 = device0.createCommandEncoder(); |
| let textureView153 = texture134.createView({ |
| label: '\u0e02\u82f4\u{1fb30}\u3d57\u{1f76c}\uf984\u765e', |
| mipLevelCount: 1, |
| baseArrayLayer: 36, |
| arrayLayerCount: 2, |
| }); |
| try { |
| renderPassEncoder62.setBindGroup(2, bindGroup75); |
| } catch {} |
| try { |
| renderPassEncoder38.setBindGroup(1, bindGroup34, new Uint32Array(186), 85, 0); |
| } catch {} |
| try { |
| renderPassEncoder47.setVertexBuffer(7, undefined); |
| } catch {} |
| try { |
| renderBundleEncoder11.setIndexBuffer(buffer86, 'uint32', 1_844, 200); |
| } catch {} |
| try { |
| renderBundleEncoder11.setVertexBuffer(7, buffer59); |
| } catch {} |
| try { |
| commandEncoder138.copyBufferToTexture({ |
| /* bytesInLastRow: 200 widthInBlocks: 25 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 168 */ |
| offset: 168, |
| rowsPerImage: 34, |
| buffer: buffer117, |
| }, { |
| texture: texture63, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 25, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder138.copyTextureToTexture({ |
| texture: texture89, |
| mipLevel: 1, |
| origin: {x: 33, y: 0, z: 1}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture7, |
| mipLevel: 0, |
| origin: {x: 9, y: 0, z: 5}, |
| aspect: 'all', |
| }, |
| {width: 6, height: 0, depthOrArrayLayers: 14}); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| document.body.append(img3); |
| let videoFrame27 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt709', primaries: 'jedecP22Phosphors', transfer: 'unspecified'} }); |
| let bindGroup109 = device0.createBindGroup({ |
| layout: bindGroupLayout7, |
| entries: [{binding: 53, resource: externalTexture5}, {binding: 54, resource: {buffer: buffer40, offset: 22016}}], |
| }); |
| let textureView154 = texture83.createView({label: '\u8ed5\u0343', dimension: 'cube-array', baseArrayLayer: 2, arrayLayerCount: 6}); |
| let computePassEncoder149 = commandEncoder138.beginComputePass({}); |
| try { |
| computePassEncoder128.setBindGroup(0, bindGroup54); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder42); computePassEncoder42.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder112.end(); |
| } catch {} |
| try { |
| renderPassEncoder48.setBindGroup(3, bindGroup84, new Uint32Array(105), 16, 0); |
| } catch {} |
| try { |
| renderPassEncoder31.setVertexBuffer(4, buffer28); |
| } catch {} |
| try { |
| renderBundleEncoder11.setIndexBuffer(buffer59, 'uint16', 442, 194); |
| } catch {} |
| try { |
| commandEncoder188.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 944 */ |
| offset: 944, |
| bytesPerRow: 0, |
| rowsPerImage: 1117, |
| buffer: buffer26, |
| }, { |
| texture: texture20, |
| mipLevel: 2, |
| origin: {x: 4, y: 0, z: 2}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 6}); |
| } catch {} |
| try { |
| commandEncoder153.insertDebugMarker('\u9235'); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| await promise17; |
| } catch {} |
| let bindGroupLayout20 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 152, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| ], |
| }); |
| let buffer124 = device0.createBuffer({size: 5182, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let textureView155 = texture143.createView({aspect: 'all'}); |
| let computePassEncoder150 = commandEncoder155.beginComputePass({}); |
| let renderPassEncoder67 = commandEncoder153.beginRenderPass({ |
| colorAttachments: [{view: textureView0, depthSlice: 0, loadOp: 'clear', storeOp: 'discard'}], |
| maxDrawCount: 324117812, |
| }); |
| let renderBundleEncoder14 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2unorm'], depthStencilFormat: 'depth24plus', sampleCount: 1, depthReadOnly: true}); |
| let sampler107 = device0.createSampler({ |
| label: '\u3ff2\u8915\u{1f8f7}\ud161\u0236\u9a04\u{1fa7c}', |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 76.97, |
| lodMaxClamp: 98.63, |
| compare: 'less', |
| maxAnisotropy: 14, |
| }); |
| try { |
| renderPassEncoder8.setBindGroup(1, bindGroup82); |
| } catch {} |
| try { |
| renderPassEncoder56.setBindGroup(2, bindGroup11, new Uint32Array(518), 102, 0); |
| } catch {} |
| try { |
| renderPassEncoder30.setIndexBuffer(buffer57, 'uint16', 562, 298); |
| } catch {} |
| try { |
| renderBundleEncoder11.setVertexBuffer(7, buffer98, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer52, 100, new Int16Array(21924), 230, 0); |
| } catch {} |
| try { |
| await promise16; |
| } catch {} |
| try { |
| globalThis.someLabel = device0.label; |
| } catch {} |
| let bindGroup110 = device0.createBindGroup({layout: bindGroupLayout13, entries: [{binding: 272, resource: {buffer: buffer16, offset: 512}}]}); |
| let commandEncoder189 = device0.createCommandEncoder({}); |
| let texture154 = device0.createTexture({size: [64], dimension: '1d', format: 'rgba16uint', usage: GPUTextureUsage.COPY_SRC}); |
| let textureView156 = texture74.createView({label: '\u5acc\u289c\uab0e', dimension: '2d', mipLevelCount: 1}); |
| let renderBundle13 = renderBundleEncoder11.finish({}); |
| try { |
| renderBundleEncoder14.setBindGroup(0, bindGroup94); |
| } catch {} |
| try { |
| renderBundleEncoder14.setBindGroup(1, bindGroup19, new Uint32Array(216), 129, 0); |
| } catch {} |
| try { |
| renderBundleEncoder14.setIndexBuffer(buffer42, 'uint16', 260, 20); |
| } catch {} |
| try { |
| renderBundleEncoder14.setVertexBuffer(5, buffer72); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture47, |
| mipLevel: 1, |
| origin: {x: 74, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(109).fill(13), /* required buffer size: 109 */ |
| {offset: 109}, {width: 5, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let textureView157 = texture151.createView({dimension: '2d', arrayLayerCount: 1}); |
| let renderBundleEncoder15 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2uint'], depthReadOnly: true}); |
| try { |
| computePassEncoder149.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderBundleEncoder14.setBindGroup(1, bindGroup100, new Uint32Array(1915), 83, 0); |
| } catch {} |
| try { |
| renderBundleEncoder15.setIndexBuffer(buffer70, 'uint32', 4_908, 554); |
| } catch {} |
| try { |
| renderBundleEncoder14.setVertexBuffer(0, buffer15, 0, 9_092); |
| } catch {} |
| let arrayBuffer11 = buffer35.getMappedRange(296, 100); |
| try { |
| commandEncoder189.copyBufferToTexture({ |
| /* bytesInLastRow: 120 widthInBlocks: 15 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 632 */ |
| offset: 632, |
| buffer: buffer56, |
| }, { |
| texture: texture130, |
| mipLevel: 0, |
| origin: {x: 5, y: 0, z: 1}, |
| aspect: 'all', |
| }, {width: 15, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.append(canvas1); |
| try { |
| computePassEncoder42.setBindGroup(0, bindGroup16); |
| } catch {} |
| try { |
| renderPassEncoder51.setBindGroup(0, bindGroup35, new Uint32Array(372), 68, 0); |
| } catch {} |
| try { |
| renderPassEncoder19.setIndexBuffer(buffer115, 'uint16', 30, 61); |
| } catch {} |
| try { |
| renderBundleEncoder15.setPipeline(pipeline1); |
| } catch {} |
| try { |
| await buffer31.mapAsync(GPUMapMode.WRITE, 0, 188); |
| } catch {} |
| try { |
| commandEncoder189.copyBufferToBuffer(buffer10, 384, buffer121, 360, 8); |
| } catch {} |
| try { |
| renderPassEncoder58.pushDebugGroup('\u0508'); |
| } catch {} |
| try { |
| computePassEncoder88.insertDebugMarker('\u1a4b'); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| let imageData22 = new ImageData(12, 44); |
| try { |
| renderPassEncoder55.setBindGroup(2, bindGroup107, new Uint32Array(1290), 59, 0); |
| } catch {} |
| try { |
| renderPassEncoder24.setIndexBuffer(buffer114, 'uint16', 6, 8); |
| } catch {} |
| try { |
| renderBundleEncoder14.setIndexBuffer(buffer120, 'uint16', 738, 175); |
| } catch {} |
| try { |
| renderBundleEncoder14.setVertexBuffer(0, buffer89); |
| } catch {} |
| try { |
| textureView22.label = '\u4ffd\u0ebe\u9355\u5181\u4ecb\u0013\u0ee9'; |
| } catch {} |
| let computePassEncoder151 = commandEncoder189.beginComputePass({}); |
| let renderPassEncoder68 = commandEncoder188.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView38, |
| clearValue: { r: 429.2, g: -907.4, b: -388.6, a: 949.6, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet6, |
| maxDrawCount: 119585885, |
| }); |
| try { |
| computePassEncoder45.setBindGroup(0, bindGroup94, new Uint32Array(201), 15, 0); |
| } catch {} |
| try { |
| renderPassEncoder64.beginOcclusionQuery(23); |
| } catch {} |
| try { |
| renderPassEncoder64.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder18.setVertexBuffer(5, buffer101, 0, 16_078); |
| } catch {} |
| try { |
| renderBundleEncoder14.setBindGroup(2, bindGroup57); |
| } catch {} |
| try { |
| renderBundleEncoder15.setIndexBuffer(buffer4, 'uint16', 2_712, 740); |
| } catch {} |
| try { |
| buffer80.unmap(); |
| } catch {} |
| let texture155 = device0.createTexture({size: [560, 582, 1], format: 'rgba8unorm-srgb', usage: GPUTextureUsage.COPY_SRC}); |
| try { |
| renderPassEncoder17.setScissorRect(3, 0, 4, 0); |
| } catch {} |
| try { |
| renderPassEncoder36.setVertexBuffer(5, buffer91, 7_392); |
| } catch {} |
| try { |
| renderBundleEncoder14.setBindGroup(0, bindGroup26); |
| } catch {} |
| try { |
| renderBundleEncoder15.setBindGroup(0, bindGroup53, new Uint32Array(6427), 1_316, 0); |
| } catch {} |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| try { |
| buffer12.unmap(); |
| } catch {} |
| try { |
| if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55); }; |
| } catch {} |
| let imageData23 = new ImageData(60, 28); |
| let buffer125 = device0.createBuffer({size: 4918, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM}); |
| let sampler108 = device0.createSampler({addressModeU: 'repeat', addressModeV: 'mirror-repeat', addressModeW: 'repeat', lodMaxClamp: 93.88}); |
| let externalTexture18 = device0.importExternalTexture({source: videoFrame26, colorSpace: 'display-p3'}); |
| try { |
| computePassEncoder85.setBindGroup(1, bindGroup66); |
| } catch {} |
| try { |
| computePassEncoder54.setBindGroup(3, bindGroup43, new Uint32Array(3813), 314, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder128); computePassEncoder128.dispatchWorkgroupsIndirect(buffer115, 28); }; |
| } catch {} |
| try { |
| computePassEncoder151.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder62.setBindGroup(0, bindGroup1, new Uint32Array(1465), 1_111, 0); |
| } catch {} |
| try { |
| renderPassEncoder46.executeBundles([renderBundle11, renderBundle5, renderBundle11]); |
| } catch {} |
| try { |
| renderPassEncoder22.setVertexBuffer(1, undefined, 0); |
| } catch {} |
| try { |
| renderBundleEncoder14.setVertexBuffer(7, buffer98, 0, 486); |
| } catch {} |
| try { |
| await shaderModule0.getCompilationInfo(); |
| } catch {} |
| let commandEncoder190 = device0.createCommandEncoder({label: '\u{1fcc2}\u07f3\u0065\u{1f6b8}\ud7b3'}); |
| let textureView158 = texture141.createView({mipLevelCount: 1, arrayLayerCount: 1}); |
| let renderPassEncoder69 = commandEncoder190.beginRenderPass({ |
| colorAttachments: [{view: textureView139, depthSlice: 6, loadOp: 'load', storeOp: 'store'}], |
| maxDrawCount: 155324445, |
| }); |
| try { |
| computePassEncoder78.setBindGroup(3, bindGroup96); |
| } catch {} |
| try { |
| computePassEncoder124.setBindGroup(0, bindGroup98, new Uint32Array(5568), 3_691, 0); |
| } catch {} |
| try { |
| renderPassEncoder28.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder15.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder14.setVertexBuffer(6, undefined, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 280, height: 291, depthOrArrayLayers: 478} |
| */ |
| { |
| source: videoFrame19, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture137, |
| mipLevel: 0, |
| origin: {x: 146, y: 23, z: 90}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let renderBundle14 = renderBundleEncoder14.finish(); |
| try { |
| computePassEncoder125.setBindGroup(1, bindGroup42); |
| } catch {} |
| try { |
| computePassEncoder42.end(); |
| } catch {} |
| try { |
| renderPassEncoder24.setBindGroup(1, bindGroup55); |
| } catch {} |
| try { |
| renderPassEncoder48.setBindGroup(2, bindGroup24, new Uint32Array(2264), 852, 0); |
| } catch {} |
| try { |
| renderPassEncoder14.executeBundles([renderBundle2, renderBundle2, renderBundle2]); |
| } catch {} |
| try { |
| renderPassEncoder67.setIndexBuffer(buffer50, 'uint16', 592, 401); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| } catch {} |
| try { |
| adapter0.label = '\u{1fda2}\uc8e2\u{1f754}\u0433\u07dd\u062a'; |
| } catch {} |
| let texture156 = device0.createTexture({ |
| size: [64, 64, 22], |
| format: 'depth24plus', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder152 = commandEncoder60.beginComputePass({}); |
| try { |
| computePassEncoder41.setBindGroup(1, bindGroup85, new Uint32Array(315), 123, 0); |
| } catch {} |
| try { |
| renderPassEncoder16.executeBundles([renderBundle3, renderBundle0, renderBundle3, renderBundle11]); |
| } catch {} |
| try { |
| renderPassEncoder10.setIndexBuffer(buffer80, 'uint16', 1_702, 2_272); |
| } catch {} |
| try { |
| renderBundleEncoder15.setIndexBuffer(buffer16, 'uint16', 1_584, 608); |
| } catch {} |
| try { |
| renderBundleEncoder15.setPipeline(pipeline1); |
| } catch {} |
| let commandEncoder191 = device0.createCommandEncoder({}); |
| let textureView159 = texture90.createView({baseMipLevel: 0, mipLevelCount: 1}); |
| let computePassEncoder153 = commandEncoder191.beginComputePass({}); |
| let renderBundle15 = renderBundleEncoder15.finish({}); |
| try { |
| renderPassEncoder53.setViewport(90.5906327388818, 0.3216213975588047, 0.3633813622753664, 0.6451178508013696, 0.11890421152365926, 0.8919953151629716); |
| } catch {} |
| let arrayBuffer12 = buffer31.getMappedRange(0, 20); |
| try { |
| renderPassEncoder46.pushDebugGroup('\u00b7'); |
| } catch {} |
| try { |
| renderPassEncoder58.popDebugGroup(); |
| } catch {} |
| try { |
| if (!arrayBuffer9.detached) { new Uint8Array(arrayBuffer9).fill(0x55); }; |
| } catch {} |
| let texture157 = device0.createTexture({ |
| label: '\u097b\ua1a6\u{1f7f2}', |
| size: {width: 147}, |
| dimension: '1d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView160 = texture4.createView({label: '\u{1f8ea}\u{1ff7d}\u8934\u2f33\u8e14\u{1fcae}\u4c1d\ufb18\u{1ffe6}\ucc9a\ub625'}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder45); computePassEncoder45.dispatchWorkgroups(3); }; |
| } catch {} |
| try { |
| renderPassEncoder3.setBindGroup(1, bindGroup72); |
| } catch {} |
| try { |
| renderPassEncoder67.executeBundles([renderBundle6]); |
| } catch {} |
| try { |
| renderPassEncoder43.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder61.setVertexBuffer(7, buffer28, 0, 2_055); |
| } catch {} |
| try { |
| buffer101.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer99, 1360, new DataView(new ArrayBuffer(5830)), 638); |
| } catch {} |
| let buffer126 = device0.createBuffer({ |
| label: '\ud7e4\u3b10\u{1f77b}\u8449\uab5b', |
| size: 8656, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM, |
| }); |
| let sampler109 = device0.createSampler({ |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 51.46, |
| lodMaxClamp: 52.73, |
| maxAnisotropy: 11, |
| }); |
| try { |
| computePassEncoder150.setPipeline(pipeline3); |
| } catch {} |
| try { |
| buffer57.unmap(); |
| } catch {} |
| let buffer127 = device0.createBuffer({ |
| size: 2928, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let textureView161 = texture110.createView({aspect: 'all', mipLevelCount: 1}); |
| try { |
| computePassEncoder153.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder62.setBindGroup(0, bindGroup37, new Uint32Array(981), 1, 0); |
| } catch {} |
| try { |
| renderPassEncoder67.setIndexBuffer(buffer83, 'uint16', 1_350, 266); |
| } catch {} |
| let textureView162 = texture23.createView({label: '\uce8a\ufad2\u06f9', mipLevelCount: 1}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder40); computePassEncoder40.dispatchWorkgroupsIndirect(buffer115, 76); }; |
| } catch {} |
| try { |
| computePassEncoder152.setPipeline(pipeline0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 140, height: 145, depthOrArrayLayers: 239} |
| */ |
| { |
| source: img3, |
| origin: { x: 2, y: 4 }, |
| flipY: true, |
| }, { |
| texture: texture137, |
| mipLevel: 1, |
| origin: {x: 59, y: 2, z: 83}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 5, height: 4, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup111 = device0.createBindGroup({ |
| label: '\u03a7\u00ce\u{1fbc2}\u04d7\u6baf\u36aa\u7cfc\u02ef\u6233\u{1fc65}', |
| layout: bindGroupLayout1, |
| entries: [{binding: 277, resource: sampler87}], |
| }); |
| let texture158 = device0.createTexture({ |
| size: [64, 64, 3], |
| dimension: '3d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let sampler110 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'clamp-to-edge', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 87.53, |
| lodMaxClamp: 87.90, |
| compare: 'not-equal', |
| }); |
| try { |
| computePassEncoder21.setBindGroup(3, bindGroup50); |
| } catch {} |
| try { |
| computePassEncoder79.setBindGroup(1, bindGroup56, new Uint32Array(758), 104, 0); |
| } catch {} |
| try { |
| computePassEncoder45.end(); |
| } catch {} |
| try { |
| renderPassEncoder31.setBindGroup(3, bindGroup17, new Uint32Array(46), 0, 0); |
| } catch {} |
| try { |
| renderPassEncoder49.setIndexBuffer(buffer116, 'uint32', 620, 46); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| } catch {} |
| let buffer128 = device0.createBuffer({ |
| size: 4496, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder192 = device0.createCommandEncoder({}); |
| let commandBuffer10 = commandEncoder63.finish(); |
| let renderBundleEncoder16 = device0.createRenderBundleEncoder({colorFormats: ['rgba16sint'], depthReadOnly: true, stencilReadOnly: true}); |
| let renderBundle16 = renderBundleEncoder16.finish({}); |
| let sampler111 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMaxClamp: 71.52, |
| }); |
| try { |
| computePassEncoder115.setBindGroup(1, bindGroup75); |
| } catch {} |
| try { |
| renderPassEncoder37.setBindGroup(2, bindGroup31, []); |
| } catch {} |
| try { |
| renderPassEncoder9.setIndexBuffer(buffer95, 'uint32', 5_072, 5_197); |
| } catch {} |
| try { |
| renderPassEncoder8.setVertexBuffer(4, buffer83, 2_228); |
| } catch {} |
| try { |
| commandEncoder192.copyBufferToTexture({ |
| /* bytesInLastRow: 156 widthInBlocks: 39 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 3976 */ |
| offset: 3976, |
| bytesPerRow: 256, |
| buffer: buffer117, |
| }, { |
| texture: texture49, |
| mipLevel: 0, |
| origin: {x: 39, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 39, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture54, |
| mipLevel: 0, |
| origin: {x: 11, y: 23, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(384).fill(246), /* required buffer size: 384 */ |
| {offset: 384, bytesPerRow: 167}, {width: 16, height: 20, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder193 = device0.createCommandEncoder({}); |
| let querySet18 = device0.createQuerySet({label: '\u0a51\ub552\u033b\u2163\u{1f855}\u{1faa8}', type: 'occlusion', count: 127}); |
| let computePassEncoder154 = commandEncoder192.beginComputePass({}); |
| let renderPassEncoder70 = commandEncoder193.beginRenderPass({ |
| label: '\u2df0\uc89b\u01e7\u6a36\u6c84\ubf2d', |
| colorAttachments: [{view: textureView134, depthSlice: 0, loadOp: 'clear', storeOp: 'discard'}], |
| }); |
| let sampler112 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 33.93, |
| lodMaxClamp: 90.44, |
| maxAnisotropy: 14, |
| }); |
| try { |
| computePassEncoder128.end(); |
| } catch {} |
| try { |
| computePassEncoder154.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(2, bindGroup94); |
| } catch {} |
| try { |
| renderPassEncoder20.setBindGroup(3, bindGroup69, new Uint32Array(135), 24, 0); |
| } catch {} |
| try { |
| renderPassEncoder56.setVertexBuffer(7, buffer59, 0, 101); |
| } catch {} |
| try { |
| commandEncoder169.copyTextureToTexture({ |
| texture: texture121, |
| mipLevel: 0, |
| origin: {x: 11, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture8, |
| mipLevel: 0, |
| origin: {x: 7, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let buffer129 = device0.createBuffer({size: 6109, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT}); |
| let commandBuffer11 = commandEncoder169.finish(); |
| try { |
| renderPassEncoder69.setIndexBuffer(buffer86, 'uint32', 872, 39); |
| } catch {} |
| try { |
| renderPassEncoder67.setVertexBuffer(6, buffer116, 0, 57); |
| } catch {} |
| let textureView163 = texture150.createView({}); |
| try { |
| computePassEncoder31.setBindGroup(0, bindGroup0); |
| } catch {} |
| try { |
| renderPassEncoder67.setIndexBuffer(buffer10, 'uint16', 1_504, 3_088); |
| } catch {} |
| let bindGroup112 = device0.createBindGroup({ |
| layout: bindGroupLayout19, |
| entries: [{binding: 361, resource: {buffer: buffer116, offset: 0, size: 1368}}], |
| }); |
| let texture159 = device0.createTexture({ |
| size: {width: 36, height: 1, depthOrArrayLayers: 1}, |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderBundleEncoder17 = device0.createRenderBundleEncoder({colorFormats: ['rgba16sint']}); |
| try { |
| computePassEncoder83.setBindGroup(1, bindGroup93, new Uint32Array(1082), 190, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.beginOcclusionQuery(2); |
| } catch {} |
| let buffer130 = device0.createBuffer({ |
| size: 724, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder194 = device0.createCommandEncoder({}); |
| let textureView164 = texture157.createView({dimension: '1d'}); |
| try { |
| renderPassEncoder34.setBindGroup(2, bindGroup28); |
| } catch {} |
| try { |
| renderPassEncoder33.setVertexBuffer(2, buffer89); |
| } catch {} |
| try { |
| commandEncoder194.copyTextureToBuffer({ |
| texture: texture66, |
| mipLevel: 2, |
| origin: {x: 6, y: 38, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 180 */ |
| offset: 180, |
| bytesPerRow: 27136, |
| buffer: buffer95, |
| }, {width: 0, height: 25, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(img2); |
| let texture160 = device0.createTexture({size: {width: 192}, dimension: '1d', format: 'rgb10a2unorm', usage: GPUTextureUsage.COPY_SRC}); |
| let computePassEncoder155 = commandEncoder194.beginComputePass({}); |
| try { |
| computePassEncoder65.setBindGroup(3, bindGroup62, new Uint32Array(1261), 72, 0); |
| } catch {} |
| try { |
| renderPassEncoder16.setBindGroup(1, bindGroup95); |
| } catch {} |
| try { |
| renderPassEncoder14.setIndexBuffer(buffer64, 'uint32', 920, 1_119); |
| } catch {} |
| try { |
| renderBundleEncoder17.setVertexBuffer(3, buffer89, 508, 1_308); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer11]); |
| } catch {} |
| let imageBitmap3 = await createImageBitmap(imageData8); |
| let commandEncoder195 = device0.createCommandEncoder(); |
| let texture161 = device0.createTexture({ |
| size: [280, 291, 1], |
| mipLevelCount: 2, |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder156 = commandEncoder195.beginComputePass({}); |
| let renderBundle17 = renderBundleEncoder17.finish(); |
| try { |
| renderPassEncoder49.setBindGroup(3, bindGroup5); |
| } catch {} |
| try { |
| renderPassEncoder25.executeBundles([renderBundle3]); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 73, height: 1, depthOrArrayLayers: 54} |
| */ |
| { |
| source: videoFrame21, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture5, |
| mipLevel: 0, |
| origin: {x: 4, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer131 = device0.createBuffer({size: 13030, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE}); |
| let commandEncoder196 = device0.createCommandEncoder(); |
| let textureView165 = texture31.createView({dimension: '2d', aspect: 'all', baseArrayLayer: 11}); |
| try { |
| computePassEncoder40.end(); |
| } catch {} |
| let arrayBuffer13 = buffer31.getMappedRange(24, 16); |
| try { |
| commandEncoder196.copyBufferToTexture({ |
| /* bytesInLastRow: 1060 widthInBlocks: 265 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1124 */ |
| offset: 1124, |
| buffer: buffer128, |
| }, { |
| texture: texture47, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 265, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder57.copyTextureToTexture({ |
| texture: texture131, |
| mipLevel: 0, |
| origin: {x: 63, y: 35, z: 2}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture32, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 6, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder57.clearBuffer(buffer35, 940, 9676); |
| } catch {} |
| try { |
| commandEncoder57.insertDebugMarker('\u0dd6'); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer10]); |
| } catch {} |
| let texture162 = device0.createTexture({ |
| size: {width: 384, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 1, |
| sampleCount: 1, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let textureView166 = texture26.createView({dimension: '2d-array'}); |
| let computePassEncoder157 = commandEncoder196.beginComputePass(); |
| let renderPassEncoder71 = commandEncoder57.beginRenderPass({ |
| colorAttachments: [{view: textureView65, loadOp: 'load', storeOp: 'discard'}], |
| occlusionQuerySet: querySet8, |
| }); |
| try { |
| computePassEncoder24.setBindGroup(1, bindGroup93, new Uint32Array(95), 4, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.setBindGroup(0, bindGroup89); |
| } catch {} |
| try { |
| renderPassEncoder53.setBindGroup(1, bindGroup11, new Uint32Array(967), 117, 0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture79, |
| mipLevel: 2, |
| origin: {x: 8, y: 5, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(513).fill(19), /* required buffer size: 513 */ |
| {offset: 513, bytesPerRow: 20}, {width: 2, height: 32, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup113 = device0.createBindGroup({ |
| layout: bindGroupLayout4, |
| entries: [{binding: 511, resource: {buffer: buffer58, offset: 0, size: 720}}], |
| }); |
| let texture163 = gpuCanvasContext0.getCurrentTexture(); |
| let textureView167 = texture132.createView({}); |
| let sampler113 = device0.createSampler({ |
| label: '\u{1fafc}\u{1f8a7}\ubca3\udf54\u0d66\u00f3\u0b80\u{1fd67}\u1e0c\u5bbe\u4376', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 43.31, |
| lodMaxClamp: 61.39, |
| compare: 'less-equal', |
| }); |
| try { |
| buffer52.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture52, |
| mipLevel: 0, |
| origin: {x: 12, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(213).fill(197), /* required buffer size: 213 */ |
| {offset: 213}, {width: 4, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.append(img3); |
| let bindGroupLayout21 = device0.createBindGroupLayout({ |
| label: '\u20af\u2d2d\u7e93\u5575', |
| entries: [ |
| { |
| binding: 606, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| sampler: { type: 'filtering' }, |
| }, |
| { |
| binding: 190, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32float', access: 'read-write', viewDimension: '2d-array' }, |
| }, |
| {binding: 125, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| { |
| binding: 222, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'uniform', minBindingSize: 1399, hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let texture164 = device0.createTexture({ |
| size: {width: 280, height: 291, depthOrArrayLayers: 1}, |
| format: 'r32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder31); computePassEncoder31.dispatchWorkgroupsIndirect(buffer25, 472); }; |
| } catch {} |
| try { |
| computePassEncoder157.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder9.setBlendConstant({ r: -405.5, g: -815.2, b: 11.96, a: -250.7, }); |
| } catch {} |
| let bindGroupLayout22 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 31, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba16uint', access: 'write-only', viewDimension: '1d' }, |
| }, |
| { |
| binding: 132, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| {binding: 75, visibility: GPUShaderStage.COMPUTE, externalTexture: {}}, |
| { |
| binding: 159, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 337, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false }, |
| }, |
| {binding: 265, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'filtering' }}, |
| { |
| binding: 29, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| sampler: { type: 'comparison' }, |
| }, |
| { |
| binding: 4, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 44, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 298, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 178, |
| visibility: GPUShaderStage.COMPUTE, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| { |
| binding: 304, |
| visibility: GPUShaderStage.COMPUTE, |
| texture: { viewDimension: 'cube-array', sampleType: 'sint', multisampled: false }, |
| }, |
| { |
| binding: 244, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| externalTexture: {}, |
| }, |
| ], |
| }); |
| let texture165 = device0.createTexture({ |
| size: {width: 96, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'rg8sint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let sampler114 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'mirror-repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| lodMinClamp: 3.367, |
| lodMaxClamp: 47.35, |
| }); |
| try { |
| computePassEncoder54.setBindGroup(3, bindGroup103, new Uint32Array(2677), 68, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder79); computePassEncoder79.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder156.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder8.setViewport(9.689598963351767, 0.1465328768621783, 23.031566855264114, 0.21778297627580062, 0.8142694685499997, 0.9881277112299279); |
| } catch {} |
| try { |
| renderPassEncoder44.setVertexBuffer(4, buffer87, 1_500); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture103, |
| mipLevel: 0, |
| origin: {x: 9, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(30_119).fill(250), /* required buffer size: 30_119 */ |
| {offset: 89, bytesPerRow: 105, rowsPerImage: 26}, {width: 5, height: 0, depthOrArrayLayers: 12}); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let commandEncoder197 = device0.createCommandEncoder({}); |
| let querySet19 = device0.createQuerySet({type: 'occlusion', count: 618}); |
| let textureView168 = texture164.createView({dimension: '2d-array', format: 'r32float'}); |
| let texture166 = device0.createTexture({ |
| size: {width: 73, height: 1, depthOrArrayLayers: 38}, |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder158 = commandEncoder197.beginComputePass(); |
| try { |
| computePassEncoder158.setBindGroup(1, bindGroup111, new Uint32Array(817), 181, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder79); computePassEncoder79.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder155.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder7.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder60.setIndexBuffer(buffer115, 'uint16', 12, 176); |
| } catch {} |
| try { |
| computePassEncoder24.insertDebugMarker('\u6b8f'); |
| } catch {} |
| let commandEncoder198 = device0.createCommandEncoder({}); |
| let texture167 = device0.createTexture({ |
| label: '\u4d43\u0f34\u{1f60d}\u{1fe20}\u8708\u0b5b', |
| size: [64, 64, 22], |
| format: 'r8sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture168 = device0.createTexture({ |
| label: '\uf9f9\u34f5\u0654\u{1fe6e}\uae6f\u7718\u6443\u1cbb', |
| size: {width: 295, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 4, |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let renderPassEncoder72 = commandEncoder198.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView32, |
| depthSlice: 504, |
| clearValue: { r: 62.40, g: 227.7, b: 401.3, a: 781.5, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| }); |
| let sampler115 = device0.createSampler({ |
| label: '\u{1f6d0}\u32f2\u04ab\u{1fa2a}\u7298', |
| addressModeU: 'repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 31.70, |
| maxAnisotropy: 6, |
| }); |
| try { |
| renderPassEncoder24.setBindGroup(1, bindGroup25, new Uint32Array(1318), 415, 0); |
| } catch {} |
| try { |
| renderPassEncoder43.executeBundles([renderBundle4]); |
| } catch {} |
| let imageData24 = new ImageData(4, 56); |
| let bindGroup114 = device0.createBindGroup({ |
| layout: bindGroupLayout9, |
| entries: [ |
| {binding: 96, resource: {buffer: buffer2, offset: 2048, size: 636}}, |
| {binding: 113, resource: sampler0}, |
| {binding: 127, resource: sampler16}, |
| ], |
| }); |
| let buffer132 = device0.createBuffer({ |
| size: 2417, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| let texture169 = device0.createTexture({ |
| label: '\u{1fe19}\u{1f8d1}\ucfc9\u25bd\ub551\u2da6\uac94\u766c\u0974', |
| size: {width: 220}, |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder99.setBindGroup(0, bindGroup27, []); |
| } catch {} |
| try { |
| computePassEncoder158.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder27.setBindGroup(0, bindGroup68); |
| } catch {} |
| try { |
| renderPassEncoder65.setVertexBuffer(3, buffer10, 8_268); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let bindGroup115 = device0.createBindGroup({ |
| layout: bindGroupLayout9, |
| entries: [ |
| {binding: 96, resource: {buffer: buffer106, offset: 256}}, |
| {binding: 127, resource: sampler50}, |
| {binding: 113, resource: sampler19}, |
| ], |
| }); |
| let buffer133 = device0.createBuffer({size: 6751, usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE}); |
| let textureView169 = texture104.createView({mipLevelCount: 1}); |
| let textureView170 = texture98.createView({dimension: 'cube-array', mipLevelCount: 1, baseArrayLayer: 2, arrayLayerCount: 6}); |
| try { |
| renderPassEncoder9.setIndexBuffer(buffer121, 'uint16', 508, 226); |
| } catch {} |
| try { |
| computePassEncoder73.label = '\u8657\u1ce7\u1dec\u{1ff90}\u{1fa9d}\u6c2d\u0cbb\u37e2\ua947'; |
| } catch {} |
| let pipelineLayout10 = device0.createPipelineLayout({label: '\u07ec\u7d0d\u{1f61e}\u{1f92f}\u{1ff36}\uc85d\ub513\u0923', bindGroupLayouts: []}); |
| let commandEncoder199 = device0.createCommandEncoder({}); |
| let textureView171 = texture167.createView({ |
| dimension: 'cube-array', |
| aspect: 'all', |
| format: 'r8sint', |
| mipLevelCount: 1, |
| baseArrayLayer: 1, |
| arrayLayerCount: 6, |
| }); |
| let computePassEncoder159 = commandEncoder199.beginComputePass({}); |
| try { |
| renderPassEncoder9.setIndexBuffer(buffer27, 'uint32', 456, 65); |
| } catch {} |
| try { |
| renderPassEncoder14.setVertexBuffer(7, buffer111, 0, 306); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| gpuCanvasContext2.unconfigure(); |
| } catch {} |
| let commandEncoder200 = device0.createCommandEncoder({}); |
| let texture170 = device0.createTexture({ |
| size: {width: 36, height: 1, depthOrArrayLayers: 19}, |
| mipLevelCount: 2, |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let textureView172 = texture39.createView({aspect: 'depth-only'}); |
| let computePassEncoder160 = commandEncoder200.beginComputePass(); |
| try { |
| computePassEncoder151.setBindGroup(0, bindGroup79, new Uint32Array(1560), 121, 0); |
| } catch {} |
| try { |
| renderPassEncoder36.setBindGroup(0, bindGroup9, new Uint32Array(3217), 297, 0); |
| } catch {} |
| try { |
| buffer117.unmap(); |
| } catch {} |
| try { |
| renderPassEncoder46.popDebugGroup(); |
| } catch {} |
| let buffer134 = device0.createBuffer({size: 8465, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let commandEncoder201 = device0.createCommandEncoder({}); |
| let texture171 = device0.createTexture({ |
| size: {width: 70, height: 72, depthOrArrayLayers: 91}, |
| dimension: '3d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let renderPassEncoder73 = commandEncoder201.beginRenderPass({colorAttachments: [{view: textureView139, depthSlice: 0, loadOp: 'clear', storeOp: 'discard'}]}); |
| try { |
| computePassEncoder104.setBindGroup(1, bindGroup12); |
| } catch {} |
| try { |
| computePassEncoder79.end(); |
| } catch {} |
| try { |
| computePassEncoder159.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder66.end(); |
| } catch {} |
| try { |
| commandEncoder105.resolveQuerySet(querySet9, 5, 7, buffer53, 768); |
| } catch {} |
| let bindGroupLayout23 = device0.createBindGroupLayout({ |
| label: '\u3b89\ud75a\u{1f968}\u1304', |
| entries: [ |
| { |
| binding: 63, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'r32float', access: 'write-only', viewDimension: '3d' }, |
| }, |
| { |
| binding: 28, |
| visibility: GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rg32float', access: 'read-only', viewDimension: '1d' }, |
| }, |
| ], |
| }); |
| let bindGroup116 = device0.createBindGroup({ |
| layout: bindGroupLayout8, |
| entries: [{binding: 27, resource: {buffer: buffer119, offset: 2048, size: 3626}}], |
| }); |
| let texture172 = device0.createTexture({ |
| label: '\u0794\u09c2\u{1f852}\ud8ba\u{1fc6d}\u08cd\u806e\u0715\u{1fc62}', |
| size: {width: 192}, |
| dimension: '1d', |
| format: 'rg32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder67.setBindGroup(2, bindGroup95, []); |
| } catch {} |
| try { |
| renderPassEncoder38.setBindGroup(0, bindGroup75); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer115, 120, new Float32Array(8934), 328, 32); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 73, height: 1, depthOrArrayLayers: 32} |
| */ |
| { |
| source: videoFrame15, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture138, |
| mipLevel: 0, |
| origin: {x: 10, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder202 = device0.createCommandEncoder(); |
| let commandBuffer12 = commandEncoder185.finish(); |
| let texture173 = device0.createTexture({ |
| size: [147, 1, 67], |
| mipLevelCount: 1, |
| dimension: '3d', |
| format: 'r32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture174 = device0.createTexture({ |
| size: [36, 1, 20], |
| dimension: '3d', |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let texture175 = gpuCanvasContext1.getCurrentTexture(); |
| let textureView173 = texture53.createView({mipLevelCount: 1}); |
| try { |
| renderPassEncoder71.beginOcclusionQuery(12); |
| } catch {} |
| try { |
| commandEncoder105.copyBufferToTexture({ |
| /* bytesInLastRow: 80 widthInBlocks: 10 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 0 */ |
| offset: 0, |
| bytesPerRow: 4608, |
| buffer: buffer7, |
| }, { |
| texture: texture78, |
| mipLevel: 1, |
| origin: {x: 7, y: 37, z: 0}, |
| aspect: 'all', |
| }, {width: 10, height: 27, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer52, 912, new DataView(new ArrayBuffer(13209)), 850, 112); |
| } catch {} |
| let commandEncoder203 = device0.createCommandEncoder({label: '\u2b25\ucfc4\u05b7\u{1f619}\u{1f89c}\u{1fb42}'}); |
| let texture176 = device0.createTexture({ |
| size: [36], |
| dimension: '1d', |
| format: 'rg32float', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder161 = commandEncoder203.beginComputePass({label: '\u2020\u3e00'}); |
| try { |
| computePassEncoder107.setBindGroup(2, bindGroup35, []); |
| } catch {} |
| try { |
| computePassEncoder160.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder71.endOcclusionQuery(); |
| } catch {} |
| try { |
| commandEncoder105.copyTextureToBuffer({ |
| texture: texture135, |
| mipLevel: 0, |
| origin: {x: 10, y: 10, z: 1}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 48 widthInBlocks: 12 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 688 */ |
| offset: 688, |
| rowsPerImage: 187, |
| buffer: buffer74, |
| }, {width: 12, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let textureView174 = texture172.createView({label: '\u{1fe7e}\u2075\u8b87\u{1ff07}\u430f', mipLevelCount: 1, baseArrayLayer: 0}); |
| let computePassEncoder162 = commandEncoder202.beginComputePass({}); |
| try { |
| renderPassEncoder35.beginOcclusionQuery(6); |
| } catch {} |
| try { |
| renderPassEncoder35.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder28.setVertexBuffer(6, buffer43, 12, 1_119); |
| } catch {} |
| document.body.append(img0); |
| let bindGroup117 = device0.createBindGroup({ |
| label: '\uf6a2\uc51c\u3e0d\u0ef8\u093e\uf540\u0f04\u3c3b', |
| layout: bindGroupLayout1, |
| entries: [{binding: 277, resource: sampler56}], |
| }); |
| let commandEncoder204 = device0.createCommandEncoder({}); |
| let textureView175 = texture173.createView({aspect: 'all', mipLevelCount: 1}); |
| try { |
| computePassEncoder136.setBindGroup(0, bindGroup54); |
| } catch {} |
| try { |
| renderPassEncoder43.setBindGroup(0, bindGroup47, new Uint32Array(25), 5, 0); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer12]); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture98, |
| mipLevel: 1, |
| origin: {x: 8, y: 3, z: 1}, |
| aspect: 'all', |
| }, new Uint8Array(885).fill(120), /* required buffer size: 885 */ |
| {offset: 68, bytesPerRow: 19, rowsPerImage: 21}, {width: 0, height: 2, depthOrArrayLayers: 3}); |
| } catch {} |
| let commandEncoder205 = device0.createCommandEncoder({}); |
| let textureView176 = texture164.createView({dimension: '2d-array', mipLevelCount: 1}); |
| let computePassEncoder163 = commandEncoder205.beginComputePass({label: '\u04a1\ua0d0\ucfe0\uf2ed\u7fe2'}); |
| let renderPassEncoder74 = commandEncoder204.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView97, |
| clearValue: { r: 593.7, g: -236.2, b: -587.8, a: -766.3, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| computePassEncoder118.setBindGroup(2, bindGroup104, new Uint32Array(442), 47, 0); |
| } catch {} |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| let videoFrame28 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-cl', primaries: 'unspecified', transfer: 'pq'} }); |
| let commandEncoder206 = device0.createCommandEncoder({}); |
| let textureView177 = texture169.createView({}); |
| let computePassEncoder164 = commandEncoder206.beginComputePass({}); |
| let renderPassEncoder75 = commandEncoder105.beginRenderPass({colorAttachments: [{view: textureView8, depthSlice: 2, loadOp: 'load', storeOp: 'discard'}]}); |
| try { |
| computePassEncoder129.setBindGroup(2, bindGroup41, new Uint32Array(440), 8, 0); |
| } catch {} |
| try { |
| computePassEncoder163.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder18.setBindGroup(0, bindGroup58); |
| } catch {} |
| let arrayBuffer14 = buffer35.getMappedRange(640, 672); |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| if (!arrayBuffer10.detached) { new Uint8Array(arrayBuffer10).fill(0x55); }; |
| } catch {} |
| let bindGroup118 = device0.createBindGroup({ |
| layout: bindGroupLayout6, |
| entries: [{binding: 11, resource: {buffer: buffer19, offset: 2304, size: 1360}}], |
| }); |
| let buffer135 = device0.createBuffer({size: 44083, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let commandEncoder207 = device0.createCommandEncoder({label: '\u1c3a\u90c4\u8462\u{1fd48}'}); |
| let renderPassEncoder76 = commandEncoder207.beginRenderPass({ |
| label: '\u01a7\u079a', |
| colorAttachments: [{ |
| view: textureView98, |
| clearValue: { r: -143.4, g: -64.54, b: 117.1, a: -506.0, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet4, |
| maxDrawCount: 148445028, |
| }); |
| let sampler116 = device0.createSampler({ |
| label: '\u0dcc\u0914\ubb64\u{1fcb4}\u01fe\u090f\u52e9\u3819\u0a14\u0982', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 18.51, |
| lodMaxClamp: 22.91, |
| }); |
| let commandEncoder208 = device0.createCommandEncoder(); |
| try { |
| computePassEncoder162.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder51.setBlendConstant({ r: 911.5, g: 828.8, b: 263.1, a: -592.3, }); |
| } catch {} |
| try { |
| renderPassEncoder37.setIndexBuffer(buffer85, 'uint32', 2_268, 3_051); |
| } catch {} |
| let videoFrame29 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBX', timestamp: 0, colorSpace: {fullRange: false, matrix: 'fcc', primaries: 'jedecP22Phosphors', transfer: 'linear'} }); |
| let texture177 = device0.createTexture({ |
| label: '\udd23\u02d2\u98de\u4468\u031d\u92c5\u{1f6e3}\u0a12', |
| size: [280, 291, 1], |
| mipLevelCount: 3, |
| format: 'depth24plus', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder165 = commandEncoder208.beginComputePass({}); |
| try { |
| renderPassEncoder30.setScissorRect(10, 0, 3, 0); |
| } catch {} |
| try { |
| renderPassEncoder72.setVertexBuffer(3, buffer98, 160, 393); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture79, |
| mipLevel: 1, |
| origin: {x: 3, y: 8, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(269).fill(153), /* required buffer size: 269 */ |
| {offset: 269, bytesPerRow: 217}, {width: 41, height: 29, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext2.unconfigure(); |
| } catch {} |
| let bindGroup119 = device0.createBindGroup({ |
| layout: bindGroupLayout4, |
| entries: [{binding: 511, resource: {buffer: buffer28, offset: 256, size: 1380}}], |
| }); |
| try { |
| computePassEncoder149.setBindGroup(3, bindGroup106, new Uint32Array(460), 5, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder127); computePassEncoder127.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder127); computePassEncoder127.dispatchWorkgroupsIndirect(buffer3, 136); }; |
| } catch {} |
| try { |
| computePassEncoder161.setPipeline(pipeline5); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let commandEncoder209 = device0.createCommandEncoder({label: '\u05d2\u0d37\ua1a8\ucb4a'}); |
| let computePassEncoder166 = commandEncoder209.beginComputePass({}); |
| let sampler117 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'repeat', |
| magFilter: 'nearest', |
| lodMinClamp: 71.17, |
| lodMaxClamp: 95.19, |
| }); |
| try { |
| computePassEncoder31.end(); |
| } catch {} |
| try { |
| computePassEncoder164.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder7.setBindGroup(2, bindGroup60); |
| } catch {} |
| try { |
| renderPassEncoder44.setBindGroup(2, bindGroup41, new Uint32Array(1299), 130, 0); |
| } catch {} |
| try { |
| buffer71.unmap(); |
| } catch {} |
| let videoFrame30 = videoFrame2.clone(); |
| let texture178 = device0.createTexture({size: [42, 96, 22], format: 'astc-6x6-unorm-srgb', usage: GPUTextureUsage.COPY_DST}); |
| let computePassEncoder167 = commandEncoder44.beginComputePass({}); |
| let sampler118 = device0.createSampler({ |
| label: '\u0b2b\u0fda\ucee3\u52ac\uc4bd\uc0a6\u013c\u01dd\u{1fa01}', |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 76.93, |
| lodMaxClamp: 89.81, |
| }); |
| try { |
| computePassEncoder165.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder60.setBindGroup(1, bindGroup114); |
| } catch {} |
| try { |
| renderPassEncoder51.setIndexBuffer(buffer76, 'uint16', 7_236, 193); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer87, 2596, new DataView(new ArrayBuffer(10928)), 3644, 1792); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| await gc(); |
| let bindGroup120 = device0.createBindGroup({ |
| label: '\ue2c8\u{1fd3d}\ud384\u53ff\u04ff\uae8a\ud08e\u0135\u{1fb90}\u34d0\u013e', |
| layout: bindGroupLayout15, |
| entries: [{binding: 44, resource: externalTexture8}], |
| }); |
| let textureView178 = texture176.createView({label: '\uade9\u06ac\ucc15\u0358\udf18\u21bb\u58a8\u984a\uc545\uaf81\ufa01'}); |
| try { |
| renderPassEncoder10.setBindGroup(1, bindGroup106); |
| } catch {} |
| try { |
| renderPassEncoder36.setIndexBuffer(buffer51, 'uint32', 952, 381); |
| } catch {} |
| let videoFrame31 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-ncl', primaries: 'smpte432', transfer: 'gamma22curve'} }); |
| try { |
| computePassEncoder166.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder60.setBindGroup(0, bindGroup74, new Uint32Array(784), 287, 0); |
| } catch {} |
| let commandEncoder210 = device0.createCommandEncoder({label: '\u6a89\u0dcc\u{1fc7a}\u{1f75f}\u3286\u2069\u2b79'}); |
| let texture179 = device0.createTexture({ |
| size: {width: 220, height: 20, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| sampleCount: 1, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder123.setBindGroup(3, bindGroup120, new Uint32Array(2777), 24, 0); |
| } catch {} |
| try { |
| computePassEncoder167.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder70.executeBundles([renderBundle11]); |
| } catch {} |
| try { |
| renderPassEncoder17.setIndexBuffer(buffer95, 'uint16', 1_752, 4_991); |
| } catch {} |
| try { |
| renderPassEncoder50.setVertexBuffer(2, buffer98, 0, 1_640); |
| } catch {} |
| let bindGroup121 = device0.createBindGroup({ |
| layout: bindGroupLayout4, |
| entries: [{binding: 511, resource: {buffer: buffer95, offset: 1792, size: 480}}], |
| }); |
| let commandEncoder211 = device0.createCommandEncoder({label: '\uff15\u6ba9\ue774\u{1fb29}\u24e7\u238c\u1b54\ua46a\u{1f7af}'}); |
| let computePassEncoder168 = commandEncoder210.beginComputePass(); |
| try { |
| computePassEncoder127.end(); |
| } catch {} |
| try { |
| computePassEncoder168.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder46.executeBundles([renderBundle7]); |
| } catch {} |
| try { |
| renderPassEncoder68.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder48.setVertexBuffer(2, buffer89, 0, 819); |
| } catch {} |
| try { |
| commandEncoder211.copyTextureToTexture({ |
| texture: texture110, |
| mipLevel: 0, |
| origin: {x: 25, y: 0, z: 2}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture18, |
| mipLevel: 0, |
| origin: {x: 24, y: 0, z: 5}, |
| aspect: 'all', |
| }, |
| {width: 10, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({device: device0, format: 'rgba16float', usage: GPUTextureUsage.RENDER_ATTACHMENT, colorSpace: 'srgb'}); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 280, height: 291, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame7, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture161, |
| mipLevel: 0, |
| origin: {x: 1, y: 187, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext2.unconfigure(); |
| } catch {} |
| await gc(); |
| let bindGroup122 = device0.createBindGroup({ |
| layout: bindGroupLayout2, |
| entries: [ |
| {binding: 94, resource: textureView132}, |
| {binding: 132, resource: textureView22}, |
| {binding: 243, resource: textureView108}, |
| {binding: 421, resource: {buffer: buffer92, offset: 768, size: 3552}}, |
| {binding: 398, resource: textureView172}, |
| {binding: 999, resource: textureView121}, |
| {binding: 35, resource: textureView70}, |
| {binding: 567, resource: textureView140}, |
| {binding: 42, resource: externalTexture4}, |
| ], |
| }); |
| let querySet20 = device0.createQuerySet({type: 'occlusion', count: 1105}); |
| try { |
| computePassEncoder116.setBindGroup(3, bindGroup86, new Uint32Array(287), 29, 0); |
| } catch {} |
| try { |
| renderPassEncoder8.setBindGroup(0, bindGroup120, new Uint32Array(6524), 560, 0); |
| } catch {} |
| try { |
| buffer12.unmap(); |
| } catch {} |
| let commandEncoder212 = device0.createCommandEncoder({label: '\u007a\u024d\uab27\u9794\u2630\u{1fc74}'}); |
| let texture180 = device0.createTexture({ |
| size: {width: 64, height: 64, depthOrArrayLayers: 18}, |
| dimension: '3d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_SRC, |
| }); |
| let computePassEncoder169 = commandEncoder212.beginComputePass({}); |
| let renderPassEncoder77 = commandEncoder211.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView163, |
| depthSlice: 24, |
| clearValue: { r: 559.1, g: -48.92, b: 784.2, a: -980.9, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet11, |
| maxDrawCount: 132052912, |
| }); |
| try { |
| computePassEncoder94.setBindGroup(3, bindGroup100, new Uint32Array(2944), 2_944, 0); |
| } catch {} |
| try { |
| renderPassEncoder51.setIndexBuffer(buffer26, 'uint16', 1_178, 37); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer42, 448, new DataView(new ArrayBuffer(731)), 56, 20); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 140, height: 145, depthOrArrayLayers: 239} |
| */ |
| { |
| source: imageData22, |
| origin: { x: 1, y: 6 }, |
| flipY: true, |
| }, { |
| texture: texture137, |
| mipLevel: 1, |
| origin: {x: 0, y: 8, z: 80}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 3, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| if (!arrayBuffer4.detached) { new Uint8Array(arrayBuffer4).fill(0x55); }; |
| } catch {} |
| let bindGroup123 = device0.createBindGroup({ |
| layout: bindGroupLayout3, |
| entries: [{binding: 225, resource: textureView108}, {binding: 58, resource: {buffer: buffer81, offset: 256}}], |
| }); |
| let querySet21 = device0.createQuerySet({ |
| label: '\u19bd\u{1f86f}\u{1fa51}\u{1f7e8}\u031f\u{1fa69}\u0630\u7463\u{1fc3a}\u83e7\u9d7f', |
| type: 'occlusion', |
| count: 694, |
| }); |
| try { |
| renderPassEncoder52.executeBundles([renderBundle2, renderBundle2]); |
| } catch {} |
| try { |
| commandEncoder168.copyBufferToBuffer(buffer3, 12, buffer50, 12, 80); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer100, 772, new BigUint64Array(23543), 3238, 12); |
| } catch {} |
| try { |
| if (!arrayBuffer14.detached) { new Uint8Array(arrayBuffer14).fill(0x55); }; |
| } catch {} |
| let canvas2 = document.createElement('canvas'); |
| let commandEncoder213 = device0.createCommandEncoder({}); |
| let texture181 = device0.createTexture({ |
| size: {width: 147}, |
| mipLevelCount: 1, |
| sampleCount: 1, |
| dimension: '1d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let computePassEncoder170 = commandEncoder168.beginComputePass({}); |
| let renderPassEncoder78 = commandEncoder213.beginRenderPass({ |
| label: '\uff21\u834a\ucf6c\u{1f718}\u{1fbc5}', |
| colorAttachments: [{ |
| view: textureView156, |
| clearValue: { r: 922.3, g: -405.3, b: 711.5, a: -105.0, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| }); |
| let sampler119 = device0.createSampler({ |
| label: '\ud82f\u8fe9\u{1f6e6}', |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'clamp-to-edge', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 16.91, |
| lodMaxClamp: 78.12, |
| }); |
| try { |
| computePassEncoder123.setBindGroup(0, bindGroup92, new Uint32Array(1577), 68, 0); |
| } catch {} |
| try { |
| computePassEncoder169.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder54.setBindGroup(1, bindGroup98, new Uint32Array(614), 59, 0); |
| } catch {} |
| try { |
| renderPassEncoder74.setVertexBuffer(5, buffer115, 0); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST, |
| colorSpace: 'display-p3', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| let buffer136 = device0.createBuffer({ |
| label: '\ua7ac\u{1f79f}\u0f02\ucf56\uc50f', |
| size: 655, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE, |
| }); |
| try { |
| computePassEncoder78.end(); |
| } catch {} |
| try { |
| computePassEncoder170.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder67.setVertexBuffer(6, buffer42, 0, 379); |
| } catch {} |
| try { |
| commandEncoder104.clearBuffer(buffer96, 5348, 156); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer124, 552, new BigUint64Array(549), 185, 144); |
| } catch {} |
| let videoFrame32 = new VideoFrame(videoFrame8, {timestamp: 0}); |
| let bindGroup124 = device0.createBindGroup({ |
| layout: bindGroupLayout23, |
| entries: [{binding: 63, resource: textureView175}, {binding: 28, resource: textureView174}], |
| }); |
| let texture182 = device0.createTexture({ |
| size: [64, 64, 22], |
| format: 'depth24plus', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder102.setBindGroup(0, bindGroup37); |
| } catch {} |
| try { |
| computePassEncoder136.setBindGroup(2, bindGroup104, new Uint32Array(1774), 135, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.setIndexBuffer(buffer131, 'uint16', 634, 1_833); |
| } catch {} |
| try { |
| renderPassEncoder26.setVertexBuffer(7, buffer56); |
| } catch {} |
| try { |
| commandEncoder104.copyBufferToTexture({ |
| /* bytesInLastRow: 620 widthInBlocks: 155 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 2380 */ |
| offset: 2380, |
| bytesPerRow: 27392, |
| buffer: buffer100, |
| }, { |
| texture: texture79, |
| mipLevel: 0, |
| origin: {x: 25, y: 18, z: 0}, |
| aspect: 'all', |
| }, {width: 155, height: 96, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture183 = device0.createTexture({ |
| size: {width: 295}, |
| dimension: '1d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder171 = commandEncoder104.beginComputePass({}); |
| try { |
| computePassEncoder171.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder29.setBindGroup(1, bindGroup61); |
| } catch {} |
| try { |
| renderPassEncoder46.setIndexBuffer(buffer131, 'uint16', 146, 277); |
| } catch {} |
| try { |
| renderPassEncoder51.setVertexBuffer(0, buffer24, 824, 1_971); |
| } catch {} |
| let bindGroup125 = device0.createBindGroup({ |
| label: '\uef72\uea6c\u0db3\u0117\ud22c\ud046', |
| layout: bindGroupLayout6, |
| entries: [{binding: 11, resource: {buffer: buffer65, offset: 0}}], |
| }); |
| let commandEncoder214 = device0.createCommandEncoder(); |
| let computePassEncoder172 = commandEncoder214.beginComputePass({label: '\u0f2a\u050b\u091a\u07ec\u{1fc33}\u1c79\ucd6c'}); |
| let sampler120 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'repeat', |
| magFilter: 'nearest', |
| lodMinClamp: 46.39, |
| lodMaxClamp: 51.35, |
| }); |
| try { |
| computePassEncoder114.setBindGroup(0, bindGroup34); |
| } catch {} |
| try { |
| computePassEncoder77.setBindGroup(0, bindGroup6, new Uint32Array(1062), 3, 0); |
| } catch {} |
| try { |
| renderPassEncoder39.setBindGroup(0, bindGroup12, new Uint32Array(732), 49, 0); |
| } catch {} |
| try { |
| renderPassEncoder20.setViewport(68.9729530708249, 1.1061837314567802, 0.41709976258613113, 33.74003349570095, 0.602409604321413, 0.7879344676928945); |
| } catch {} |
| try { |
| renderPassEncoder75.setVertexBuffer(0, buffer111); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 96, height: 1, depthOrArrayLayers: 131} |
| */ |
| { |
| source: videoFrame17, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture18, |
| mipLevel: 0, |
| origin: {x: 15, y: 0, z: 41}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| globalThis.someLabel = externalTexture1.label; |
| } catch {} |
| let commandEncoder215 = device0.createCommandEncoder({}); |
| let querySet22 = device0.createQuerySet({type: 'occlusion', count: 445}); |
| try { |
| computePassEncoder167.setBindGroup(3, bindGroup48); |
| } catch {} |
| try { |
| computePassEncoder172.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder43.setBindGroup(2, bindGroup56); |
| } catch {} |
| try { |
| renderPassEncoder7.setIndexBuffer(buffer76, 'uint32', 2_868, 14_864); |
| } catch {} |
| try { |
| renderPassEncoder67.setVertexBuffer(2, buffer89); |
| } catch {} |
| try { |
| renderPassEncoder45.insertDebugMarker('\u6357'); |
| } catch {} |
| let computePassEncoder173 = commandEncoder215.beginComputePass({}); |
| try { |
| computePassEncoder173.setPipeline(pipeline3); |
| } catch {} |
| document.body.append(img2); |
| let imageData25 = new ImageData(28, 8); |
| try { |
| querySet7.label = '\u300a\uff34\u7817\u4ca7\u0e97\u6d80\u9b52\u{1fe13}\u72c7\uef25\u7682'; |
| } catch {} |
| let bindGroup126 = device0.createBindGroup({ |
| layout: bindGroupLayout9, |
| entries: [ |
| {binding: 96, resource: {buffer: buffer11, offset: 4096, size: 72}}, |
| {binding: 127, resource: sampler101}, |
| {binding: 113, resource: sampler20}, |
| ], |
| }); |
| try { |
| renderPassEncoder54.setBindGroup(1, bindGroup9); |
| } catch {} |
| try { |
| renderPassEncoder20.setBindGroup(3, bindGroup69, new Uint32Array(2218), 12, 0); |
| } catch {} |
| try { |
| renderPassEncoder27.executeBundles([renderBundle15]); |
| } catch {} |
| let commandEncoder216 = device0.createCommandEncoder(); |
| let texture184 = gpuCanvasContext1.getCurrentTexture(); |
| let textureView179 = texture99.createView({dimension: '2d-array'}); |
| let renderPassEncoder79 = commandEncoder216.beginRenderPass({ |
| colorAttachments: [{view: textureView32, depthSlice: 112, loadOp: 'load', storeOp: 'discard'}], |
| maxDrawCount: 55033984, |
| }); |
| try { |
| renderPassEncoder28.setBindGroup(0, bindGroup27, []); |
| } catch {} |
| try { |
| renderPassEncoder54.beginOcclusionQuery(12); |
| } catch {} |
| try { |
| buffer8.unmap(); |
| } catch {} |
| let bindGroup127 = device0.createBindGroup({ |
| label: '\u0f87\u{1f609}\uee64', |
| layout: bindGroupLayout15, |
| entries: [{binding: 44, resource: externalTexture18}], |
| }); |
| let pipelineLayout11 = device0.createPipelineLayout({bindGroupLayouts: []}); |
| let commandEncoder217 = device0.createCommandEncoder({label: '\u0517\u07de\ua60e\u{1fd4a}\u4bf9\u{1f6fb}\u4d76'}); |
| let textureView180 = texture167.createView({dimension: 'cube-array', baseArrayLayer: 1, arrayLayerCount: 6}); |
| let texture185 = device0.createTexture({ |
| label: '\ud60c\u30fd\u8bbb\uf798\uc3ca\uaaee\u0922\u0694\u83bc', |
| size: [280, 291, 1], |
| format: 'depth24plus', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let computePassEncoder174 = commandEncoder217.beginComputePass({}); |
| try { |
| computePassEncoder174.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder67.setIndexBuffer(buffer13, 'uint16', 2_152, 1_442); |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let bindGroup128 = device0.createBindGroup({layout: bindGroupLayout10, entries: [{binding: 5, resource: sampler51}]}); |
| let commandEncoder218 = device0.createCommandEncoder({}); |
| let texture186 = device0.createTexture({ |
| size: [560], |
| dimension: '1d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView181 = texture51.createView({}); |
| let computePassEncoder175 = commandEncoder218.beginComputePass({}); |
| try { |
| computePassEncoder77.dispatchWorkgroups(5, 1); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| let bindGroupLayout24 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 52, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| sampler: { type: 'comparison' }, |
| }, |
| ], |
| }); |
| let texture187 = device0.createTexture({size: {width: 70}, dimension: '1d', format: 'rgba16sint', usage: GPUTextureUsage.STORAGE_BINDING}); |
| let textureView182 = texture182.createView({dimension: '2d', aspect: 'depth-only', baseArrayLayer: 2}); |
| try { |
| computePassEncoder139.setBindGroup(2, bindGroup91); |
| } catch {} |
| try { |
| computePassEncoder175.setPipeline(pipeline2); |
| } catch {} |
| try { |
| await shaderModule1.getCompilationInfo(); |
| } catch {} |
| let shaderModule13 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| requires readonly_and_readwrite_storage_textures; |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| @group(0) @binding(35) var st22: texture_storage_1d<r32sint, read_write>; |
| |
| @group(0) @binding(42) var et0: texture_external; |
| |
| @group(0) @binding(94) var tex1: texture_2d_array<f32>; |
| |
| @group(0) @binding(132) var tex2: texture_2d<i32>; |
| |
| @group(0) @binding(243) var tex3: texture_depth_2d; |
| |
| @group(0) @binding(398) var tex4: texture_depth_2d; |
| |
| @group(0) @binding(421) var<storage, read> buffer137: T0; |
| |
| @group(0) @binding(567) var st23: texture_storage_2d<rgba8snorm, write>; |
| |
| @group(0) @binding(999) var tex5: texture_2d_array<i32>; |
| |
| struct T0 { |
| f0: array<u32>, |
| } |
| |
| struct VertexOutput12 { |
| @builtin(position) f38: vec4f, |
| } |
| |
| struct VertexOutput13 { |
| @builtin(position) f39: vec4f, |
| @location(9) @interpolate(flat, sample) f40: u32, |
| @location(5) f41: vec4u, |
| @location(6) f42: i32, |
| } |
| |
| struct VertexOutput14 { |
| @builtin(position) f43: vec4f, |
| } |
| |
| struct FragmentOutput8 { |
| @location(0) f0: vec4u, |
| @location(7) f1: vec4i, |
| @location(6) f2: vec2i, |
| } |
| |
| struct FragmentOutput9 { |
| @location(0) @interpolate(linear, centroid) f0: vec4f, |
| } |
| |
| fn fn0() -> array<i32, 39> { |
| var out: array<i32, 39>; |
| let vf231: u32 = atomicExchange(&vw55, u32(unconst_u32(182))); |
| textureStore(st22, i32(unconst_i32(131)), vec4i(vec4i(unconst_i32(24), unconst_i32(33), unconst_i32(25), unconst_i32(14)))); |
| var vf232: vec2u = textureDimensions(tex2); |
| let vf233: u32 = textureNumLevels(tex1); |
| var vf234: vec2u = textureDimensions(tex3); |
| out[u32(unconst_u32(14))] ^= bitcast<i32>(atomicLoad(&vw55)); |
| let vf235: bool = all(bool(unconst_bool(true))); |
| textureStore(st23, vec2i(bitcast<i32>(textureLoad(tex3, vec2i(unconst_i32(-254), unconst_i32(8)), i32(unconst_i32(89))))), vec4f(vec4f(unconst_f32(0.7199), unconst_f32(0.04554), unconst_f32(0.4185), unconst_f32(0.1026)))); |
| vf234 <<= vec2u(u32(vf235)); |
| let ptr94: ptr<workgroup, VertexOutput14> = &(*&vw56); |
| var vf236: u32 = vf234[vf232[u32(unconst_u32(83))]]; |
| vf232 = vec2u(min(vec3h(unconst_f16(11220.2), unconst_f16(135.6), unconst_f16(2054.9)), vec3h(unconst_f16(5497.0), unconst_f16(8771.1), unconst_f16(92.07))).zz); |
| var vf237: vec4i = textureLoad(tex5, vec2i(unconst_i32(59), unconst_i32(128)), i32(unconst_i32(51)), i32(unconst_i32(188))); |
| let ptr95: ptr<workgroup, atomic<u32>> = &vw55; |
| let ptr96: ptr<function, vec4i> = &vf237; |
| var vf238: u32 = atomicLoad(&vw55); |
| vf234 = vec2u(atomicExchange(&(*ptr95), u32(unconst_u32(851)))); |
| let vf239: vec2u = textureDimensions(tex1); |
| var vf240: u32 = textureNumLevels(tex1); |
| let vf241: u32 = vf231; |
| return out; |
| } |
| |
| var<workgroup> vw55: atomic<u32>; |
| |
| var<workgroup> vw56: VertexOutput14; |
| |
| @vertex |
| fn vertex13(@builtin(vertex_index) a0: u32, @location(9) @interpolate(flat, center) a1: vec2f, @location(15) a2: vec4i) -> VertexOutput12 { |
| var out: VertexOutput12; |
| let vf242: vec2u = textureDimensions(tex5); |
| let vf243: u32 = textureNumLevels(tex5); |
| out.f38 = unpack4x8unorm(textureNumLevels(tex4)); |
| out = VertexOutput12(unpack4x8unorm(pack4xI8Clamp(vec4i(unconst_i32(-189), unconst_i32(186), unconst_i32(79), unconst_i32(59))))); |
| var vf244: u32 = arrayLength(&buffer137.f0); |
| out.f38 = bitcast<vec4f>(vf242.yxxy); |
| vf244 <<= bitcast<u32>(faceForward(vec2h(unconst_f16(-3874.3), unconst_f16(15712.3)), vec2h(unconst_f16(35605.4), unconst_f16(2440.6)), vec2h(unconst_f16(29358.5), unconst_f16(8625.5)))); |
| let vf245: vec2u = countOneBits(vec2u(unconst_u32(83), unconst_u32(72))); |
| let vf246: vec2u = textureDimensions(tex3); |
| vf244 += textureDimensions(tex5)[1]; |
| out.f38 = vec4f(faceForward(vec2h(unconst_f16(10259.4), unconst_f16(-27803.2)), bitcast<vec2h>(buffer137.f0[arrayLength(&buffer137.f0) - 1]), vec2h(unconst_f16(6870.8), unconst_f16(1535.6))).rrgr); |
| var vf247: f16 = log2(f16(unconst_f16(21326.9))); |
| var vf248: u32 = arrayLength(&(*&buffer137).f0); |
| let ptr97: ptr<storage, u32, read> = &buffer137.f0[arrayLength(&buffer137.f0) - 1]; |
| var vf249: u32 = pack4xI8Clamp(vec4i(unconst_i32(174), unconst_i32(64), unconst_i32(184), unconst_i32(67))); |
| let ptr98: ptr<storage, u32, read> = &buffer137.f0[arrayLength(&buffer137.f0)]; |
| let vf250: vec4f = textureLoad(tex1, vec2i(unconst_i32(199), unconst_i32(58)), i32(unconst_i32(162)), bitcast<i32>(textureDimensions(tex2)[0])); |
| return out; |
| } |
| |
| @vertex |
| fn vertex14() -> VertexOutput13 { |
| var out: VertexOutput13; |
| let vf251: u32 = textureNumLevels(tex1); |
| out.f39 = vec4f(extractBits(vec3i(unconst_i32(50), unconst_i32(129), unconst_i32(114)), pack4x8unorm(vec4f(unconst_f32(-0.00789), unconst_f32(0.5104), unconst_f32(0.02833), unconst_f32(-0.00773))), textureDimensions(tex2).y).xzyz); |
| var vf252: f32 = distance(vec2f(unconst_f32(0.03542), unconst_f32(0.1037)), vec2f(abs(f32(unconst_f32(-0.1201))))); |
| let vf253: f32 = distance(vec2f(unconst_f32(0.1611), unconst_f32(0.4981)), vec2f(unconst_f32(0.5526), unconst_f32(0.3021))); |
| out.f39 *= vec4f(bitcast<f32>((*&buffer137).f0[arrayLength(&(*&buffer137).f0)])); |
| out.f40 <<= bitcast<u32>(fma(vec2h(unconst_f16(12658.2), unconst_f16(4877.6)), vec2h(unconst_f16(-13811.2), unconst_f16(24135.6)), vec2h(unconst_f16(9458.8), unconst_f16(489.3)))); |
| out.f39 -= vec4f(textureLoad(tex2, vec2i(unconst_i32(18), unconst_i32(252)), i32(unconst_i32(384)))); |
| var vf254: u32 = pack4x8unorm(bitcast<vec4f>(reverseBits(vec2i(unconst_i32(118), unconst_i32(76))).yxxy)); |
| out.f41 *= unpack4xU8(textureNumLevels(tex3)); |
| var vf255: vec2h = clamp(vec2h(unconst_f16(-3343.8), unconst_f16(2901.0)), vec2h(unconst_f16(24144.5), unconst_f16(8467.3)), vec2h(unconst_f16(-2751.8), unconst_f16(-14841.2))); |
| out.f42 *= bitcast<vec2i>(textureDimensions(tex3, i32(unconst_i32(59)))).g; |
| out.f39 += vec4f(reflect(vec2h(unconst_f16(4303.9), unconst_f16(17788.1)), vec2h(unconst_f16(5367.7), unconst_f16(16638.4))).yxxx); |
| var vf256: vec2u = textureDimensions(tex4); |
| let ptr99: ptr<storage, T0, read> = &buffer137; |
| vf252 = bitcast<f32>(dot4I8Packed(u32(unconst_u32(176)), u32(unconst_u32(180)))); |
| var vf257: u32 = vf251; |
| out.f42 ^= i32((*&buffer137).f0[arrayLength(&(*&buffer137).f0) - 1]); |
| return out; |
| } |
| |
| @vertex |
| fn vertex15(@location(5) @interpolate(flat) a0: vec2h) -> VertexOutput14 { |
| var out: VertexOutput14; |
| out.f43 *= vec4f(bitcast<f32>(pack4xI8Clamp(vec4i(unconst_i32(336), unconst_i32(68), unconst_i32(185), unconst_i32(178))))); |
| out.f43 *= bitcast<vec4f>(textureDimensions(et0).xxyy); |
| let ptr100: ptr<storage, array<u32>, read> = &buffer137.f0; |
| let ptr101: ptr<storage, array<u32>, read> = &buffer137.f0; |
| let ptr102: ptr<storage, u32, read> = &(*&buffer137).f0[u32(unconst_u32(551))]; |
| var vf258: vec2u = textureDimensions(tex2); |
| let ptr103: ptr<storage, array<u32>, read> = &(*ptr100); |
| let ptr104: ptr<storage, u32, read> = &buffer137.f0[arrayLength(&buffer137.f0) - 1]; |
| var vf259: vec3h = acos(vec3h(unconst_f16(2350.6), unconst_f16(5057.2), unconst_f16(4388.7))); |
| vf259 *= vec3h(f16(buffer137.f0[arrayLength(&buffer137.f0)])); |
| let ptr105: ptr<storage, u32, read> = &(*&buffer137).f0[arrayLength(&(*&buffer137).f0) - 1]; |
| let ptr106: ptr<storage, u32, read> = &buffer137.f0[bitcast<vec2i>(insertBits(vec2u(unconst_u32(461), unconst_u32(240)), vec2u(unconst_u32(252), unconst_u32(63)), u32(unconst_u32(51)), u32(unconst_u32(88)))).r]; |
| vf258 |= vec2u(textureNumLevels(tex1)); |
| var vf260: vec2u = textureDimensions(tex1, i32(unconst_i32(366))); |
| return out; |
| } |
| |
| @fragment |
| fn fragment9() -> FragmentOutput8 { |
| var out: FragmentOutput8; |
| out.f1 |= vec4i(i32(buffer137.f0[arrayLength(&buffer137.f0)])); |
| let vf261: vec4h = refract(vec4h(unconst_f16(3874.3), unconst_f16(24478.2), unconst_f16(-24328.8), unconst_f16(12688.4)), vec4h(unconst_f16(-31754.2), unconst_f16(726.6), unconst_f16(4184.9), unconst_f16(15869.0)), f16(unconst_f16(3701.8))); |
| out.f0 -= vec4u(vf261); |
| let ptr107: ptr<storage, u32, read> = &buffer137.f0[i32(unconst_i32(39))]; |
| out.f2 = vec2i(i32(vf261[u32(unconst_u32(128))])); |
| out.f2 = vec2i(bitcast<i32>((*&buffer137).f0[u32(unconst_u32(21))])); |
| let ptr108: ptr<storage, array<u32>, read> = &buffer137.f0; |
| let vf262: u32 = pack2x16unorm(vec2f(unconst_f32(0.02720), unconst_f32(0.2128))); |
| let vf263: vec3f = asin(textureLoad(et0, vec2u(unconst_u32(20), unconst_u32(45))).rrb); |
| out.f1 += bitcast<vec4i>(textureDimensions(et0).xyyy); |
| out.f2 |= vec2i(i32(buffer137.f0[u32(unconst_u32(36))])); |
| out.f2 = vec2i(bitcast<i32>(textureNumLevels(tex2))); |
| let ptr109: ptr<storage, u32, read> = &buffer137.f0[i32(unconst_i32(-380))]; |
| let ptr110: ptr<storage, u32, read> = &(*&buffer137).f0[u32(unconst_u32(214))]; |
| var vf264: f32 = vf263[u32(unconst_u32(123))]; |
| let ptr111: ptr<storage, u32, read> = &(*&buffer137).f0[arrayLength(&(*&buffer137).f0)]; |
| let ptr112: ptr<storage, u32, read> = &buffer137.f0[arrayLength(&buffer137.f0)]; |
| let vf265: vec4h = normalize(vec4h(f16((*&buffer137).f0[u32(unconst_u32(236))]))); |
| let vf266: f16 = vf261[u32(unconst_u32(6))]; |
| out.f2 = vec2i(i32((*ptr108)[i32(unconst_i32(142))])); |
| var vf267: vec4h = normalize(refract(vec4h(unconst_f16(2013.7), unconst_f16(1316.8), unconst_f16(22856.2), unconst_f16(7595.4)), vec4h(unconst_f16(9049.0), unconst_f16(9563.4), unconst_f16(6347.0), unconst_f16(7148.2)), f16(fract(vec4f(unconst_f32(0.03118), unconst_f32(0.2074), unconst_f32(0.04416), unconst_f32(0.1155))).b))); |
| textureStore(st23, vec2i(unconst_i32(45), unconst_i32(502)), vec4f(vec4f(unconst_f32(-0.04105), unconst_f32(0.2080), unconst_f32(0.1728), unconst_f32(0.01811)))); |
| let ptr113: ptr<storage, u32, read> = &(*ptr108)[u32(unconst_u32(122))]; |
| return out; |
| } |
| |
| @fragment |
| fn fragment10() -> FragmentOutput9 { |
| var out: FragmentOutput9; |
| textureStore(st23, vec2i(unconst_i32(292), unconst_i32(110)), vec4f(vec4f(unconst_f32(0.9010), unconst_f32(0.1022), unconst_f32(0.01056), unconst_f32(0.00137)))); |
| var vf268: vec4f = cos(vec4f(bitcast<f32>(dot4U8Packed(textureDimensions(tex2)[0], u32(unconst_u32(210)))))); |
| out.f0 *= clamp(vec3f(unconst_f32(-0.2518), unconst_f32(0.5207), unconst_f32(0.07175)), vec3f(unconst_f32(0.02148), unconst_f32(0.09244), unconst_f32(0.6234)), vec3f(unconst_f32(0.02631), unconst_f32(-0.2411), unconst_f32(0.1090))).xzyy; |
| var vf269: u32 = textureNumLevels(tex2); |
| var vf270: vec4i = textureLoad(tex2, vec2i(unconst_i32(45), unconst_i32(221)), i32(unconst_i32(135))); |
| let vf271: u32 = dot4U8Packed(u32(unconst_u32(193)), u32(unconst_u32(302))); |
| let ptr114: ptr<function, vec4f> = &vf268; |
| return out; |
| } |
| |
| @compute @workgroup_size(1, 2, 1) |
| fn compute12(@builtin(local_invocation_id) a0: vec3u) { |
| vw56.f43 = unpack4x8unorm(a0[u32(unconst_u32(71))]); |
| var vf272 = fn0(); |
| fn0(); |
| let vf273: vec3h = cross(vec3h(unconst_f16(19698.4), unconst_f16(-13700.1), unconst_f16(-41792.0)), vec3h(unconst_f16(9465.2), unconst_f16(8385.6), unconst_f16(8879.6))); |
| textureStore(st23, vec2i(unconst_i32(79), unconst_i32(284)), vec4f(vec4f(unconst_f32(0.06529), unconst_f32(0.1829), unconst_f32(0.1053), unconst_f32(0.03838)))); |
| var vf274 = fn0(); |
| fn0(); |
| var vf275: vec2f = radians(vec2f(unconst_f32(0.1159), unconst_f32(0.1922))); |
| fn0(); |
| fn0(); |
| let vf276: u32 = textureNumLayers(tex1); |
| vf274[u32(unconst_u32(381))] = i32(vf273[1]); |
| let vf277: u32 = atomicLoad(&vw55); |
| fn0(); |
| let ptr115: ptr<function, i32> = &vf274[38]; |
| var vf278 = fn0(); |
| var vf279: vec3u = a0; |
| }`, |
| sourceMap: {}, |
| }); |
| let commandEncoder219 = device0.createCommandEncoder(); |
| let textureView183 = texture98.createView({dimension: 'cube-array', mipLevelCount: 1, baseArrayLayer: 4, arrayLayerCount: 6}); |
| let texture188 = device0.createTexture({ |
| size: [560, 582, 1], |
| sampleCount: 1, |
| format: 'depth24plus', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder176 = commandEncoder219.beginComputePass({}); |
| try { |
| computePassEncoder176.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder51.setBindGroup(3, bindGroup61); |
| } catch {} |
| try { |
| renderPassEncoder54.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder72.setViewport(9.551801025184794, 0.6617482129186207, 5.083310862463955, 0.2636590524598485, 0.7826364344059625, 0.9005129258205499); |
| } catch {} |
| try { |
| renderPassEncoder52.setPipeline(pipeline1); |
| } catch {} |
| let bindGroup129 = device0.createBindGroup({label: '\u0b9f\u2d40', layout: bindGroupLayout20, entries: [{binding: 152, resource: textureView108}]}); |
| let textureView184 = texture104.createView({}); |
| let texture189 = device0.createTexture({size: [110, 10, 81], format: 'rgba32float', usage: GPUTextureUsage.COPY_DST}); |
| let sampler121 = device0.createSampler({ |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'nearest', |
| lodMinClamp: 48.57, |
| lodMaxClamp: 92.02, |
| maxAnisotropy: 1, |
| }); |
| try { |
| computePassEncoder19.setBindGroup(3, bindGroup92, new Uint32Array(7), 1, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder100); computePassEncoder100.dispatchWorkgroupsIndirect(buffer67, 3_292); }; |
| } catch {} |
| try { |
| computePassEncoder77.end(); |
| } catch {} |
| try { |
| renderPassEncoder58.setBindGroup(0, bindGroup18); |
| } catch {} |
| try { |
| renderPassEncoder77.setVertexBuffer(2, buffer85); |
| } catch {} |
| try { |
| commandEncoder9.copyBufferToTexture({ |
| /* bytesInLastRow: 88 widthInBlocks: 22 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 6408 */ |
| offset: 6408, |
| bytesPerRow: 15104, |
| buffer: buffer39, |
| }, { |
| texture: texture70, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 22, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 36, height: 1, depthOrArrayLayers: 20} |
| */ |
| { |
| source: videoFrame12, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture174, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let gpuCanvasContext3 = canvas2.getContext('webgpu'); |
| let buffer138 = device0.createBuffer({ |
| size: 4465, |
| usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let renderPassEncoder80 = commandEncoder9.beginRenderPass({ |
| colorAttachments: [{view: textureView145, loadOp: 'clear', storeOp: 'store'}], |
| occlusionQuerySet: querySet2, |
| maxDrawCount: 50781338, |
| }); |
| let externalTexture19 = device0.importExternalTexture({source: videoFrame20, colorSpace: 'display-p3'}); |
| try { |
| computePassEncoder167.setBindGroup(2, bindGroup55, []); |
| } catch {} |
| try { |
| renderPassEncoder79.setBindGroup(2, bindGroup100); |
| } catch {} |
| try { |
| renderPassEncoder32.setBindGroup(2, bindGroup68, new Uint32Array(2312), 343, 0); |
| } catch {} |
| try { |
| renderPassEncoder41.setViewport(236.3408965215245, 340.6369759885509, 103.7735944464909, 187.8198254364005, 0.3679188880805878, 0.7788752957854537); |
| } catch {} |
| try { |
| computePassEncoder125.insertDebugMarker('\u4aad'); |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let buffer139 = device0.createBuffer({ |
| size: 38651, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, |
| }); |
| let texture190 = gpuCanvasContext0.getCurrentTexture(); |
| let textureView185 = texture55.createView({baseMipLevel: 0}); |
| let sampler122 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 4.506, |
| lodMaxClamp: 6.203, |
| }); |
| try { |
| renderPassEncoder26.setBindGroup(3, bindGroup95); |
| } catch {} |
| try { |
| renderPassEncoder77.setBindGroup(0, bindGroup17, new Uint32Array(1208), 711, 0); |
| } catch {} |
| try { |
| renderPassEncoder72.setIndexBuffer(buffer52, 'uint16', 1_684); |
| } catch {} |
| try { |
| renderPassEncoder33.setVertexBuffer(1, buffer62, 0, 3_109); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 73, height: 1, depthOrArrayLayers: 32} |
| */ |
| { |
| source: imageData14, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture138, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 6}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup130 = device0.createBindGroup({ |
| layout: bindGroupLayout0, |
| entries: [{binding: 103, resource: textureView160}, {binding: 176, resource: textureView158}], |
| }); |
| let commandEncoder220 = device0.createCommandEncoder({}); |
| let texture191 = device0.createTexture({ |
| label: '\ufee2\u0d27\u0547\u0a19\u0156\u{1f892}\u{1fa3a}\uc22d\u{1f61f}\u51a0\u4510', |
| size: {width: 560, height: 582, depthOrArrayLayers: 1}, |
| mipLevelCount: 4, |
| sampleCount: 1, |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder177 = commandEncoder220.beginComputePass({}); |
| try { |
| computePassEncoder177.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder64.setBindGroup(1, bindGroup49, new Uint32Array(862), 31, 0); |
| } catch {} |
| let arrayBuffer15 = buffer31.getMappedRange(48, 20); |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| colorSpace: 'srgb', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(0x55); }; |
| } catch {} |
| let texture192 = gpuCanvasContext1.getCurrentTexture(); |
| try { |
| renderPassEncoder78.setIndexBuffer(buffer51, 'uint32', 204, 3); |
| } catch {} |
| try { |
| renderPassEncoder47.pushDebugGroup('\u{1fbaa}'); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| } catch {} |
| document.body.prepend(canvas1); |
| let bindGroup131 = device0.createBindGroup({layout: bindGroupLayout20, entries: [{binding: 152, resource: textureView102}]}); |
| let commandEncoder221 = device0.createCommandEncoder({}); |
| let computePassEncoder178 = commandEncoder221.beginComputePass({}); |
| try { |
| computePassEncoder100.end(); |
| } catch {} |
| try { |
| renderPassEncoder68.beginOcclusionQuery(29); |
| } catch {} |
| try { |
| renderPassEncoder68.endOcclusionQuery(); |
| } catch {} |
| try { |
| commandEncoder136.copyBufferToTexture({ |
| /* bytesInLastRow: 120 widthInBlocks: 15 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 40 */ |
| offset: 40, |
| bytesPerRow: 14592, |
| rowsPerImage: 164, |
| buffer: buffer48, |
| }, { |
| texture: texture90, |
| mipLevel: 0, |
| origin: {x: 155, y: 68, z: 0}, |
| aspect: 'all', |
| }, {width: 15, height: 46, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer32, 1828, new Int16Array(1884), 109, 1308); |
| } catch {} |
| let texture193 = device0.createTexture({ |
| label: '\u{1fdef}\u{1fb7c}\ub4df\u{1f939}\u{1fe40}', |
| size: {width: 220, height: 20, depthOrArrayLayers: 40}, |
| mipLevelCount: 1, |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| let textureView186 = texture11.createView({label: '\ub99c\u827d\u0b08\u{1fe1c}\ued40\ue5fe\ua82e\u07b7\u{1fe20}\u0c11\u{1fd6b}'}); |
| let computePassEncoder179 = commandEncoder136.beginComputePass({}); |
| try { |
| computePassEncoder41.setBindGroup(1, bindGroup50, new Uint32Array(1061), 217, 0); |
| } catch {} |
| try { |
| renderPassEncoder23.setBindGroup(1, bindGroup117, new Uint32Array(245), 128, 0); |
| } catch {} |
| let commandEncoder222 = device0.createCommandEncoder({}); |
| let texture194 = device0.createTexture({ |
| size: [70, 72, 25], |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| let textureView187 = texture51.createView({dimension: '1d'}); |
| let computePassEncoder180 = commandEncoder222.beginComputePass(); |
| let sampler123 = device0.createSampler({ |
| label: '\udc16\u00ee', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 82.93, |
| compare: 'equal', |
| maxAnisotropy: 13, |
| }); |
| try { |
| computePassEncoder180.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder73.setBindGroup(3, bindGroup116); |
| } catch {} |
| try { |
| renderPassEncoder57.setBindGroup(0, bindGroup94, new Uint32Array(1563), 283, 0); |
| } catch {} |
| try { |
| renderPassEncoder35.setIndexBuffer(buffer64, 'uint16', 1_554, 1_186); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 140, height: 145, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData8, |
| origin: { x: 0, y: 4 }, |
| flipY: true, |
| }, { |
| texture: texture161, |
| mipLevel: 1, |
| origin: {x: 28, y: 5, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 5, depthOrArrayLayers: 0}); |
| } catch {} |
| await gc(); |
| let shaderModule14 = device0.createShaderModule({ |
| label: '\uf815\u092e\u8a8b\u5f25', |
| code: ` |
| enable f16; |
| |
| requires pointer_composite_access; |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| @group(0) @binding(103) var st24: texture_storage_3d<rgba8unorm, write>; |
| |
| @group(0) @binding(176) var st25: texture_storage_3d<rgba16uint, write>; |
| |
| struct T0 { |
| @align(16) @size(80) f0: array<u32>, |
| } |
| |
| struct VertexOutput15 { |
| @builtin(position) f44: vec4f, |
| } |
| |
| struct VertexOutput16 { |
| @location(5) @interpolate(flat) f45: u32, |
| @invariant @builtin(position) f46: vec4f, |
| @location(10) f47: vec2i, |
| @location(12) f48: u32, |
| } |
| |
| struct FragmentOutput10 { |
| @location(5) f0: vec2f, |
| @location(0) f1: vec4u, |
| } |
| |
| @id(56650) override override7 = 0.1572; |
| |
| @id(48486) override override8: i32; |
| |
| fn fn0(a0: ptr<workgroup, VertexOutput16>, a1: ptr<function, VertexOutput15>) -> VertexOutput16 { |
| var out: VertexOutput16; |
| vp14[u32(unconst_u32(323))][u32(unconst_u32(231))].f48 += vp14[u32(unconst_u32(63))][u32(unconst_u32(195))].f48; |
| vp14[vec2u(vp14[0][u32(unconst_u32(428))].f47)[0]][0] = VertexOutput16(u32(vp14[u32(unconst_u32(40))][0].f47.x), vec4f(vp14[u32(unconst_u32(40))][0].f47.xyxy), vp14[u32(unconst_u32(40))][0].f47, vec2u(vp14[u32(unconst_u32(40))][0].f47)[1]); |
| let ptr116: ptr<private, vec2i> = &vp14[u32(unconst_u32(114))][u32(unconst_u32(297))].f47; |
| let ptr117: ptr<private, u32> = &vp14[u32(unconst_u32(173))][0].f48; |
| return out; |
| } |
| |
| fn fn1() { |
| vp14[0][u32(unconst_u32(154))].f48 = u32(override8); |
| _ = override8; |
| } |
| |
| fn fn2(a0: array<vec4u, 1>, a1: array<mat4x2f, 1>) -> mat3x4h { |
| var out: mat3x4h; |
| let ptr118: ptr<private, u32> = &vp14[0][0].f45; |
| let vf280: f32 = override7; |
| fn1(); |
| out -= mat3x4h(f16(vp14[u32(unconst_u32(168))][0].f48), f16(vp14[u32(unconst_u32(168))][0].f48), f16(vp14[u32(unconst_u32(168))][0].f48), f16(vp14[u32(unconst_u32(168))][0].f48), f16(vp14[u32(unconst_u32(168))][0].f48), f16(vp14[u32(unconst_u32(168))][0].f48), f16(vp14[u32(unconst_u32(168))][0].f48), f16(vp14[u32(unconst_u32(168))][0].f48), f16(vp14[u32(unconst_u32(168))][0].f48), f16(vp14[u32(unconst_u32(168))][0].f48), f16(vp14[u32(unconst_u32(168))][0].f48), f16(vp14[u32(unconst_u32(168))][0].f48)); |
| out = mat3x4h(bitcast<vec4h>(vp14[0][u32(unconst_u32(726))].f47), bitcast<vec4h>(vp14[0][u32(unconst_u32(726))].f47), bitcast<vec4h>(vp14[0][u32(unconst_u32(726))].f47)); |
| let vf281: mat4x2f = a1[0]; |
| out = mat3x4h(vec4h(a0[u32(unconst_u32(160))]), vec4h(a0[u32(unconst_u32(160))]), vec4h(a0[u32(unconst_u32(160))])); |
| var vf282: i32 = vp14[u32(unconst_u32(138))][u32(unconst_u32(379))].f47[u32(unconst_u32(266))]; |
| vf282 &= vp14[u32(unconst_u32(110))][0].f47.x; |
| out = mat3x4h(f16(override8), f16(override8), f16(override8), f16(override8), f16(override8), f16(override8), f16(override8), f16(override8), f16(override8), f16(override8), f16(override8), f16(override8)); |
| fn1(); |
| vp14[vec2u(vp14[u32(unconst_u32(139))][u32(unconst_u32(153))].f47)[1]][pack4x8unorm(vp14[0][u32(unconst_u32(108))].f46)].f45 = u32(vf281[u32(unconst_u32(252))][u32(unconst_u32(997))]); |
| fn1(); |
| out -= mat3x4h(f16(vp14[0][0].f45), f16(vp14[0][0].f45), f16(vp14[0][0].f45), f16(vp14[0][0].f45), f16(vp14[0][0].f45), f16(vp14[0][0].f45), f16(vp14[0][0].f45), f16(vp14[0][0].f45), f16(vp14[0][0].f45), f16(vp14[0][0].f45), f16(vp14[0][0].f45), f16(vp14[0][0].f45)); |
| return out; |
| _ = override8; |
| _ = override7; |
| } |
| |
| var<workgroup> vw57: array<array<FragmentOutput10, 1>, 1>; |
| |
| var<workgroup> vw58: VertexOutput15; |
| |
| var<private> vp14: array<array<VertexOutput16, 1>, 1> = array(array(VertexOutput16(u32(341), vec4f(0.1388, 0.09089, 0.2193, 0.00364), vec2i(157, 16), u32(137)))); |
| |
| @vertex |
| fn vertex16(@location(7) @interpolate(flat, center) a0: i32, @location(15) @interpolate(flat) a1: vec2u) -> VertexOutput15 { |
| var out: VertexOutput15; |
| out = VertexOutput15(vec4f(bitcast<f32>(vp14[0][u32(unconst_u32(770))].f48))); |
| vp14[u32(unconst_u32(349))][u32(unconst_u32(32))].f45 >>= vec2u(vp14[0][0].f47).y; |
| let vf283: i32 = vp14[u32(unconst_u32(128))][0].f47[u32(unconst_u32(8))]; |
| var vf284: i32 = a0; |
| let vf285: f32 = vp14[0][u32(unconst_u32(620))].f46[u32(unconst_u32(147))]; |
| return out; |
| } |
| |
| @vertex |
| fn vertex17(@location(5) @interpolate(flat, center) a0: vec2u) -> VertexOutput16 { |
| var out: VertexOutput16; |
| var vf286: f32 = vp14[u32(unconst_u32(53))][0].f46[u32(unconst_u32(17))]; |
| var vf287: i32 = vp14[0][u32(unconst_u32(105))].f47[u32(unconst_u32(210))]; |
| out.f48 *= vec2u(vp14[u32(unconst_u32(86))][u32(unconst_u32(35))].f47).y; |
| let ptr119: ptr<private, vec2i> = &vp14[0][0].f47; |
| out.f45 = vp14[0][u32(unconst_u32(20))].f48; |
| vp14[u32(unconst_u32(197))][u32(unconst_u32(539))].f45 ^= vp14[u32(unconst_u32(17))][0].f48; |
| out.f45 &= vp14[0][u32(unconst_u32(0))].f48; |
| let ptr120: ptr<private, VertexOutput16> = &vp14[0][0]; |
| return out; |
| } |
| |
| @fragment |
| fn fragment11(@builtin(sample_mask) a0: u32, @location(11) @interpolate(flat) a1: vec4u) -> FragmentOutput10 { |
| var out: FragmentOutput10; |
| vp14[u32(unconst_u32(406))][u32(unconst_u32(299))].f48 *= pack2x16float(vec2f(unconst_f32(0.05549), unconst_f32(0.09671))); |
| fn1(); |
| vp14[u32(unconst_u32(61))][u32(unconst_u32(6))].f46 += bitcast<vec4f>(vp14[u32(unconst_u32(485))][0].f47.grrg); |
| out.f0 += bitcast<vec2f>(a1.xz); |
| out.f1 |= unpack4xU8(vp14[0][u32(unconst_u32(270))].f45); |
| let ptr121: ptr<private, vec4f> = &vp14[0][0].f46; |
| vp14[u32(unconst_u32(358))][u32(unconst_u32(59))].f45 >>= bitcast<vec2u>(vp14[0][0].f47).y; |
| vp14[u32(unconst_u32(62))][u32(unconst_u32(28))] = VertexOutput16(vec2u(vp14[u32(unconst_u32(21))][u32(unconst_u32(192))].f47).g, vec4f(vp14[u32(unconst_u32(21))][u32(unconst_u32(192))].f47.xyyy), vp14[u32(unconst_u32(21))][u32(unconst_u32(192))].f47, bitcast<u32>(vp14[u32(unconst_u32(21))][u32(unconst_u32(192))].f47[1])); |
| out.f0 += vec2f(vp14[0][0].f47); |
| let ptr122: ptr<private, u32> = &vp14[u32(unconst_u32(565))][0].f45; |
| var vf288 = fn2(array<vec4u, 1>(bitcast<vec4u>(vp14[u32(unconst_u32(225))][0].f46)), array<mat4x2f, 1>(mat4x2f(bitcast<f32>(vp14[u32(unconst_u32(58))][u32(unconst_u32(191))].f45), bitcast<f32>(vp14[u32(unconst_u32(58))][u32(unconst_u32(191))].f45), f32(vp14[u32(unconst_u32(58))][u32(unconst_u32(191))].f45), f32(vp14[u32(unconst_u32(58))][u32(unconst_u32(191))].f45), bitcast<f32>(vp14[u32(unconst_u32(58))][u32(unconst_u32(191))].f45), f32(vp14[u32(unconst_u32(58))][u32(unconst_u32(191))].f45), bitcast<f32>(vp14[u32(unconst_u32(58))][u32(unconst_u32(191))].f45), f32(vp14[u32(unconst_u32(58))][u32(unconst_u32(191))].f45)))); |
| out.f1 = vec4u(vp14[u32(unconst_u32(148))][u32(unconst_u32(217))].f45); |
| fn1(); |
| let ptr123: ptr<private, u32> = &vp14[u32(unconst_u32(106))][u32(vf288[u32(unconst_u32(93))][u32(unconst_u32(20))])].f48; |
| fn1(); |
| out.f1 <<= bitcast<vec4u>(vp14[0][0].f46); |
| let ptr124: ptr<private, u32> = &vp14[0][0].f45; |
| vp14[u32(unconst_u32(41))][0].f47 |= vec2i(bitcast<i32>((*ptr123))); |
| fn1(); |
| var vf289: f16 = vf288[u32(unconst_u32(43))][u32(unconst_u32(8))]; |
| let vf290: u32 = pack2x16float(unpack4x8snorm(u32(unconst_u32(19))).zy); |
| var vf291 = fn2(array<vec4u, 1>(vec4u(vp14[0][0].f47.gggg)), array<mat4x2f, 1>(mat4x2f(unconst_f32(0.1038), unconst_f32(0.09140), unconst_f32(0.1138), unconst_f32(0.1225), unconst_f32(0.00846), unconst_f32(0.1548), unconst_f32(0.00597), unconst_f32(0.2969)))); |
| return out; |
| _ = override8; |
| _ = override7; |
| } |
| |
| @compute @workgroup_size(3, 1, 1) |
| fn compute13() { |
| let ptr125: ptr<private, vec2i> = &vp14[u32(unconst_u32(17))][0].f47; |
| vw57[0][u32(unconst_u32(74))].f1 ^= bitcast<vec4u>(vw57[bitcast<u32>(cross(vec3f(unconst_f32(0.2857), unconst_f32(0.05832), unconst_f32(0.07622)), vec3f(unconst_f32(0.3864), unconst_f32(0.2686), unconst_f32(0.04109)))[0])][u32(unconst_u32(103))].f0.yyyx); |
| let ptr126: ptr<workgroup, vec4u> = &(*&vw57)[0][u32(unconst_u32(211))].f1; |
| let vf292: f32 = override7; |
| let vf293: i32 = vp14[u32(unconst_u32(172))][u32(unconst_u32(282))].f47[u32(unconst_u32(343))]; |
| let vf294: f32 = log2(f32(unconst_f32(0.06391))); |
| _ = override7; |
| }`, |
| hints: {}, |
| }); |
| let texture195 = gpuCanvasContext1.getCurrentTexture(); |
| try { |
| computePassEncoder90.setBindGroup(0, bindGroup103, new Uint32Array(1583), 283, 0); |
| } catch {} |
| try { |
| renderPassEncoder7.beginOcclusionQuery(33); |
| } catch {} |
| try { |
| globalThis.someLabel = textureView175.label; |
| } catch {} |
| let commandEncoder223 = device0.createCommandEncoder(); |
| let querySet23 = device0.createQuerySet({label: '\u{1fb1d}\ub07c\u{1fe16}\u{1f7e9}\u5aef\u9d2d\ud04b', type: 'occlusion', count: 227}); |
| try { |
| renderPassEncoder7.endOcclusionQuery(); |
| } catch {} |
| try { |
| commandEncoder223.copyBufferToTexture({ |
| /* bytesInLastRow: 20 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 2544 */ |
| offset: 2544, |
| buffer: buffer41, |
| }, { |
| texture: texture32, |
| mipLevel: 0, |
| origin: {x: 10, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 5, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup132 = device0.createBindGroup({ |
| label: '\ud60b\uc036\u1d30', |
| layout: bindGroupLayout24, |
| entries: [{binding: 52, resource: sampler110}], |
| }); |
| let texture196 = device0.createTexture({size: [96, 1, 1], mipLevelCount: 1, format: 'depth24plus', usage: GPUTextureUsage.COPY_DST}); |
| let textureView188 = texture84.createView({mipLevelCount: 1, baseArrayLayer: 0}); |
| let renderPassEncoder81 = commandEncoder223.beginRenderPass({ |
| colorAttachments: [{view: textureView186, depthSlice: 304, loadOp: 'clear', storeOp: 'discard'}], |
| occlusionQuerySet: querySet5, |
| }); |
| try { |
| computePassEncoder135.setBindGroup(1, bindGroup2); |
| } catch {} |
| try { |
| computePassEncoder167.setBindGroup(0, bindGroup7, new Uint32Array(3906), 2_397, 0); |
| } catch {} |
| try { |
| computePassEncoder178.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder59.setBindGroup(3, bindGroup85, new Uint32Array(287), 22, 0); |
| } catch {} |
| try { |
| renderPassEncoder54.setIndexBuffer(buffer71, 'uint16', 2_916, 1_688); |
| } catch {} |
| let buffer140 = device0.createBuffer({ |
| label: '\uadeb\u32db\u0540\u{1f622}\u448c\u{1ff9f}', |
| size: 13323, |
| usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let sampler124 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'nearest', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 27.40, |
| lodMaxClamp: 57.12, |
| }); |
| try { |
| computePassEncoder20.setBindGroup(0, bindGroup71); |
| } catch {} |
| try { |
| computePassEncoder111.setBindGroup(0, bindGroup101, new Uint32Array(3076), 454, 0); |
| } catch {} |
| try { |
| computePassEncoder179.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder29.end(); |
| } catch {} |
| try { |
| renderPassEncoder15.setPipeline(pipeline1); |
| } catch {} |
| try { |
| commandEncoder84.copyBufferToTexture({ |
| /* bytesInLastRow: 8 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1556 */ |
| offset: 1556, |
| bytesPerRow: 10752, |
| rowsPerImage: 354, |
| buffer: buffer10, |
| }, { |
| texture: texture158, |
| mipLevel: 0, |
| origin: {x: 0, y: 1, z: 0}, |
| aspect: 'all', |
| }, {width: 2, height: 6, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder224 = device0.createCommandEncoder({}); |
| let texture197 = gpuCanvasContext2.getCurrentTexture(); |
| let textureView189 = texture101.createView({label: '\u03ab\u{1fc65}\u02c5\u7059\ua471\u2f80\u1cad\u6792\u{1fc77}\u4979', baseArrayLayer: 0}); |
| try { |
| computePassEncoder104.setBindGroup(2, bindGroup100, new Uint32Array(685), 340, 0); |
| } catch {} |
| try { |
| renderPassEncoder63.setIndexBuffer(buffer113, 'uint32', 480, 1_370); |
| } catch {} |
| try { |
| renderPassEncoder72.setVertexBuffer(6, buffer115, 16); |
| } catch {} |
| try { |
| renderPassEncoder47.popDebugGroup(); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| document.body.append(img1); |
| try { |
| adapter0.label = '\u15ef\u3006\u0de6\u{1fb25}\u0572\ueda3\u{1fa28}\u0bf9\uf8e4\u{1ffdd}'; |
| } catch {} |
| let textureView190 = texture18.createView({}); |
| let computePassEncoder181 = commandEncoder84.beginComputePass({}); |
| try { |
| computePassEncoder181.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder76.setBindGroup(2, bindGroup0); |
| } catch {} |
| try { |
| renderPassEncoder15.setIndexBuffer(buffer70, 'uint16', 402, 2); |
| } catch {} |
| try { |
| renderPassEncoder8.setVertexBuffer(3, buffer98, 936, 91); |
| } catch {} |
| try { |
| commandEncoder224.copyTextureToBuffer({ |
| texture: texture151, |
| mipLevel: 0, |
| origin: {x: 0, y: 3, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 112 */ |
| offset: 112, |
| bytesPerRow: 62464, |
| buffer: buffer56, |
| }, {width: 0, height: 4, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| document.body.prepend(img3); |
| let querySet24 = device0.createQuerySet({type: 'occlusion', count: 496}); |
| let computePassEncoder182 = commandEncoder224.beginComputePass(); |
| try { |
| computePassEncoder19.setBindGroup(0, bindGroup76, new Uint32Array(79), 14, 0); |
| } catch {} |
| try { |
| computePassEncoder182.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder47.setBindGroup(1, bindGroup70); |
| } catch {} |
| let arrayBuffer16 = buffer35.getMappedRange(400, 64); |
| try { |
| computePassEncoder149.pushDebugGroup('\u24c4'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer112, 2092, new BigUint64Array(17849), 3154, 68); |
| } catch {} |
| let buffer141 = device0.createBuffer({ |
| label: '\u{1fccf}\u0b9a\u0bde\u7768\u74d8\u42d2\u{1f9db}\u0557\u03f5\u9466', |
| size: 11815, |
| usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder225 = device0.createCommandEncoder({label: '\u046f\u2c80\u08ac\u023e\u0735\u{1ff85}\u7409\u05b5\u{1fc71}\u0b65'}); |
| let textureView191 = texture15.createView({}); |
| try { |
| renderPassEncoder15.setIndexBuffer(buffer133, 'uint32', 3_016, 4); |
| } catch {} |
| try { |
| commandEncoder225.resolveQuerySet(querySet16, 44, 105, buffer24, 512); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 96, height: 1, depthOrArrayLayers: 131} |
| */ |
| { |
| source: videoFrame8, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture18, |
| mipLevel: 0, |
| origin: {x: 39, y: 0, z: 2}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer142 = device0.createBuffer({ |
| label: '\u0d0b\u65bd\uced6\uf04a\u6a06\u0684\u0d1f\u{1fc91}', |
| size: 28648, |
| usage: GPUBufferUsage.MAP_WRITE, |
| }); |
| let texture198 = device0.createTexture({ |
| label: '\u30b2\uf854\u{1f778}\ub9ce\udaa3\u0ea5\u1b8c\u6889\u3e48', |
| size: [295, 1, 813], |
| mipLevelCount: 2, |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder183 = commandEncoder225.beginComputePass(); |
| let externalTexture20 = device0.importExternalTexture({source: videoFrame1}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder108); computePassEncoder108.dispatchWorkgroupsIndirect(buffer105, 900); }; |
| } catch {} |
| try { |
| renderPassEncoder10.setBindGroup(0, bindGroup92); |
| } catch {} |
| try { |
| renderPassEncoder58.setBindGroup(2, bindGroup105, new Uint32Array(2561), 1_036, 0); |
| } catch {} |
| try { |
| buffer118.unmap(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 73, height: 1, depthOrArrayLayers: 32} |
| */ |
| { |
| source: videoFrame21, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture138, |
| mipLevel: 0, |
| origin: {x: 12, y: 0, z: 5}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| if (!arrayBuffer15.detached) { new Uint8Array(arrayBuffer15).fill(0x55); }; |
| } catch {} |
| let buffer143 = device0.createBuffer({ |
| size: 6180, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let sampler125 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 27.57, |
| maxAnisotropy: 8, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder102); computePassEncoder102.dispatchWorkgroupsIndirect(buffer101, 11_824); }; |
| } catch {} |
| try { |
| renderPassEncoder23.setBindGroup(3, bindGroup94); |
| } catch {} |
| try { |
| renderPassEncoder46.setBindGroup(0, bindGroup45, new Uint32Array(1175), 479, 0); |
| } catch {} |
| try { |
| gpuCanvasContext3.configure({device: device0, format: 'rgba8unorm', usage: GPUTextureUsage.COPY_SRC, colorSpace: 'display-p3'}); |
| } catch {} |
| let bindGroupLayout25 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 101, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| { |
| binding: 20, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '2d' }, |
| }, |
| { |
| binding: 321, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'uniform', minBindingSize: 208, hasDynamicOffset: false }, |
| }, |
| { |
| binding: 329, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| sampler: { type: 'filtering' }, |
| }, |
| { |
| binding: 333, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '1d', sampleType: 'sint', multisampled: false }, |
| }, |
| { |
| binding: 17, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false }, |
| }, |
| { |
| binding: 13, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let buffer144 = device0.createBuffer({size: 6126, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let commandEncoder226 = device0.createCommandEncoder({}); |
| let texture199 = device0.createTexture({ |
| size: {width: 64, height: 64, depthOrArrayLayers: 22}, |
| sampleCount: 1, |
| format: 'r32sint', |
| usage: GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder82.setBindGroup(0, bindGroup37); |
| } catch {} |
| try { |
| computePassEncoder136.setBindGroup(1, bindGroup35, new Uint32Array(878), 25, 0); |
| } catch {} |
| try { |
| computePassEncoder108.end(); |
| } catch {} |
| try { |
| renderPassEncoder12.setBindGroup(1, bindGroup122); |
| } catch {} |
| try { |
| commandEncoder150.copyBufferToBuffer(buffer39, 3468, buffer5, 4484, 816); |
| } catch {} |
| try { |
| computePassEncoder149.popDebugGroup(); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture75, |
| mipLevel: 1, |
| origin: {x: 10, y: 4, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(29).fill(26), /* required buffer size: 29 */ |
| {offset: 29, bytesPerRow: 10}, {width: 0, height: 24, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer145 = device0.createBuffer({ |
| size: 2045, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let texture200 = device0.createTexture({ |
| size: {width: 55, height: 5, depthOrArrayLayers: 53}, |
| sampleCount: 1, |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder184 = commandEncoder226.beginComputePass(); |
| let renderPassEncoder82 = commandEncoder150.beginRenderPass({colorAttachments: [{view: textureView51, depthSlice: 1, loadOp: 'clear', storeOp: 'store'}]}); |
| let renderBundleEncoder18 = device0.createRenderBundleEncoder({label: '\uef71\ueb1f', colorFormats: ['rgb10a2uint'], depthReadOnly: true}); |
| try { |
| computePassEncoder146.setBindGroup(0, bindGroup82); |
| } catch {} |
| try { |
| computePassEncoder13.setBindGroup(2, bindGroup82, new Uint32Array(4375), 466, 0); |
| } catch {} |
| try { |
| renderPassEncoder81.setVertexBuffer(6, buffer91, 0, 6_141); |
| } catch {} |
| try { |
| renderBundleEncoder18.setBindGroup(1, bindGroup71, []); |
| } catch {} |
| try { |
| texture54.destroy(); |
| } catch {} |
| document.body.append(img0); |
| let textureView192 = texture200.createView({dimension: '2d', baseArrayLayer: 16}); |
| let textureView193 = texture72.createView({baseMipLevel: 0}); |
| let sampler126 = device0.createSampler({ |
| addressModeW: 'repeat', |
| magFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 93.29, |
| lodMaxClamp: 99.44, |
| compare: 'less', |
| }); |
| try { |
| computePassEncoder85.setBindGroup(2, bindGroup4); |
| } catch {} |
| try { |
| renderPassEncoder54.setBindGroup(2, bindGroup131, []); |
| } catch {} |
| try { |
| renderPassEncoder37.setScissorRect(18, 53, 14, 94); |
| } catch {} |
| try { |
| renderPassEncoder54.setVertexBuffer(5, buffer65); |
| } catch {} |
| try { |
| renderBundleEncoder18.setIndexBuffer(buffer83, 'uint32', 1_084, 19); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 140, height: 145, depthOrArrayLayers: 239} |
| */ |
| { |
| source: img0, |
| origin: { x: 30, y: 3 }, |
| flipY: false, |
| }, { |
| texture: texture137, |
| mipLevel: 1, |
| origin: {x: 35, y: 15, z: 8}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 4, height: 3, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| document.body.prepend(canvas1); |
| let bindGroup133 = device0.createBindGroup({ |
| layout: bindGroupLayout0, |
| entries: [{binding: 103, resource: textureView7}, {binding: 176, resource: textureView0}], |
| }); |
| let commandEncoder227 = device0.createCommandEncoder(); |
| let computePassEncoder185 = commandEncoder227.beginComputePass({}); |
| try { |
| renderPassEncoder76.beginOcclusionQuery(135); |
| } catch {} |
| try { |
| renderPassEncoder69.executeBundles([renderBundle6]); |
| } catch {} |
| try { |
| renderPassEncoder38.setVertexBuffer(2, buffer50, 0); |
| } catch {} |
| try { |
| renderBundleEncoder18.setBindGroup(0, bindGroup112, [0]); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer6, 44, new Int16Array(1633), 177, 152); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let canvas3 = document.createElement('canvas'); |
| let videoFrame33 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420', timestamp: 0, colorSpace: {fullRange: false, matrix: 'yCgCo', primaries: 'smpteSt4281', transfer: 'gamma22curve'} }); |
| let commandEncoder228 = device0.createCommandEncoder({}); |
| try { |
| renderPassEncoder38.setVertexBuffer(5, buffer56, 2_116, 1_640); |
| } catch {} |
| try { |
| renderBundleEncoder18.setBindGroup(1, bindGroup121); |
| } catch {} |
| try { |
| renderBundleEncoder18.setPipeline(pipeline1); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer94, 684, new Int16Array(6506), 1017, 116); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture90, |
| mipLevel: 0, |
| origin: {x: 44, y: 32, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(191).fill(147), /* required buffer size: 191 */ |
| {offset: 191, bytesPerRow: 147}, {width: 11, height: 100, depthOrArrayLayers: 0}); |
| } catch {} |
| let gpuCanvasContext4 = canvas3.getContext('webgpu'); |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let buffer146 = device0.createBuffer({ |
| size: 638, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, |
| }); |
| let renderPassEncoder83 = commandEncoder228.beginRenderPass({ |
| label: '\uec13\ud5d9\ueaf4\u0de5\u332f\u3026\u{1f6ee}\uce4f', |
| colorAttachments: [{view: textureView97, loadOp: 'clear', storeOp: 'discard'}], |
| occlusionQuerySet: querySet11, |
| }); |
| try { |
| renderPassEncoder40.setViewport(35.12494601013924, 0.16574573584553143, 0.7952448865590162, 0.05072539237939795, 0.1766990325621226, 0.4474579077878201); |
| } catch {} |
| try { |
| renderPassEncoder15.setIndexBuffer(buffer109, 'uint32', 552, 14); |
| } catch {} |
| try { |
| renderBundleEncoder18.setBindGroup(0, bindGroup9, new Uint32Array(1281), 75, 0); |
| } catch {} |
| let commandEncoder229 = device0.createCommandEncoder({}); |
| let texture201 = device0.createTexture({ |
| label: '\ufd5f\u6534\ue321\u{1f7e2}\u633b\u1e01\u0602\u37aa', |
| size: {width: 55}, |
| dimension: '1d', |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_SRC, |
| }); |
| let renderBundleEncoder19 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2uint'], sampleCount: 4, stencilReadOnly: true}); |
| try { |
| computePassEncoder183.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder73.setBindGroup(1, bindGroup127, new Uint32Array(512), 69, 0); |
| } catch {} |
| try { |
| renderPassEncoder80.executeBundles([renderBundle4, renderBundle1]); |
| } catch {} |
| try { |
| renderPassEncoder8.setVertexBuffer(2, buffer83); |
| } catch {} |
| try { |
| commandEncoder229.copyBufferToTexture({ |
| /* bytesInLastRow: 720 widthInBlocks: 90 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 736 */ |
| offset: 736, |
| buffer: buffer99, |
| }, { |
| texture: texture157, |
| mipLevel: 0, |
| origin: {x: 3, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 90, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.prepend(img1); |
| let bindGroup134 = device0.createBindGroup({layout: bindGroupLayout1, entries: [{binding: 277, resource: sampler4}]}); |
| let commandEncoder230 = device0.createCommandEncoder(); |
| let textureView194 = texture61.createView({}); |
| let computePassEncoder186 = commandEncoder230.beginComputePass({}); |
| let renderPassEncoder84 = commandEncoder229.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView5, |
| clearValue: { r: -469.2, g: 985.4, b: 762.0, a: 341.4, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| computePassEncoder184.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder77.setIndexBuffer(buffer26, 'uint16', 400, 448); |
| } catch {} |
| try { |
| renderBundleEncoder18.setIndexBuffer(buffer10, 'uint16', 2_828, 2_967); |
| } catch {} |
| await gc(); |
| let imageData26 = new ImageData(8, 20); |
| let buffer147 = device0.createBuffer({ |
| size: 8253, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| mappedAtCreation: false, |
| }); |
| let sampler127 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 86.27, |
| }); |
| try { |
| computePassEncoder13.setBindGroup(2, bindGroup67); |
| } catch {} |
| try { |
| computePassEncoder98.setBindGroup(3, bindGroup34, new Uint32Array(2614), 36, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder94); computePassEncoder94.dispatchWorkgroupsIndirect(buffer146, 264); }; |
| } catch {} |
| try { |
| computePassEncoder186.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder61.setBindGroup(2, bindGroup43); |
| } catch {} |
| try { |
| renderBundleEncoder19.setBindGroup(0, bindGroup32); |
| } catch {} |
| try { |
| renderBundleEncoder19.setVertexBuffer(0, buffer99, 2_520); |
| } catch {} |
| let texture202 = device0.createTexture({ |
| size: [280, 291, 18], |
| dimension: '3d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let sampler128 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 16.47, |
| lodMaxClamp: 96.24, |
| maxAnisotropy: 6, |
| }); |
| try { |
| computePassEncoder154.setBindGroup(2, bindGroup33); |
| } catch {} |
| try { |
| renderPassEncoder28.setBindGroup(2, bindGroup88, new Uint32Array(465), 182, 0); |
| } catch {} |
| try { |
| renderPassEncoder27.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder18.setBindGroup(0, bindGroup79); |
| } catch {} |
| try { |
| renderBundleEncoder19.setIndexBuffer(buffer50, 'uint32', 196, 263); |
| } catch {} |
| try { |
| renderBundleEncoder19.setVertexBuffer(1, undefined, 403_446_179, 732_183_310); |
| } catch {} |
| try { |
| buffer88.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext4.unconfigure(); |
| } catch {} |
| let commandEncoder231 = device0.createCommandEncoder({}); |
| let textureView195 = texture26.createView({ |
| label: '\u91c4\u0849\u2e23\u0d4f\u0ed4\u{1f9f7}\u{1fbf3}\u{1f9f3}\u0a5f\u5823\ubab6', |
| dimension: '2d-array', |
| baseMipLevel: 0, |
| }); |
| let renderPassEncoder85 = commandEncoder231.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView8, |
| depthSlice: 2, |
| clearValue: { r: 741.7, g: -699.0, b: -814.0, a: 506.0, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet15, |
| }); |
| try { |
| computePassEncoder82.setBindGroup(3, bindGroup4, new Uint32Array(981), 439, 0); |
| } catch {} |
| try { |
| renderPassEncoder55.setBindGroup(1, bindGroup118); |
| } catch {} |
| try { |
| renderPassEncoder76.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder56.setVertexBuffer(1, buffer138, 968, 621); |
| } catch {} |
| try { |
| renderBundleEncoder19.setVertexBuffer(4, buffer56); |
| } catch {} |
| try { |
| gpuCanvasContext3.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let imageData27 = new ImageData(12, 64); |
| let commandEncoder232 = device0.createCommandEncoder({label: '\u00aa\u0f0a\u{1f9d2}\u08bb'}); |
| try { |
| renderPassEncoder3.setVertexBuffer(7, buffer101); |
| } catch {} |
| try { |
| renderBundleEncoder19.setBindGroup(0, bindGroup29, new Uint32Array(542), 55, 0); |
| } catch {} |
| try { |
| renderBundleEncoder18.setIndexBuffer(buffer52, 'uint32', 72, 265); |
| } catch {} |
| try { |
| renderPassEncoder21.insertDebugMarker('\u{1f7d5}'); |
| } catch {} |
| try { |
| if (!arrayBuffer9.detached) { new Uint8Array(arrayBuffer9).fill(0x55); }; |
| } catch {} |
| let videoFrame34 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'smpte170m', primaries: 'jedecP22Phosphors', transfer: 'logSqrt'} }); |
| let buffer148 = device0.createBuffer({ |
| label: '\uea54\u{1f87a}\ucd67\u{1ffb2}\u5bc7\uda93\u005d\u{1fa53}', |
| size: 976, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let sampler129 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 46.87, |
| lodMaxClamp: 61.44, |
| compare: 'equal', |
| maxAnisotropy: 2, |
| }); |
| try { |
| computePassEncoder185.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder76.setViewport(55.73442005528224, 3.122048056669678, 14.419815805395098, 6.2987477308707085, 0.7829735686529619, 0.9213233314533037); |
| } catch {} |
| try { |
| renderPassEncoder26.setIndexBuffer(buffer64, 'uint16', 724, 1_228); |
| } catch {} |
| try { |
| renderPassEncoder36.setVertexBuffer(2, buffer76, 1_756, 14_567); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| try { |
| commandEncoder232.copyBufferToTexture({ |
| /* bytesInLastRow: 176 widthInBlocks: 44 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1076 */ |
| offset: 1076, |
| bytesPerRow: 5632, |
| buffer: buffer83, |
| }, { |
| texture: texture191, |
| mipLevel: 1, |
| origin: {x: 17, y: 20, z: 0}, |
| aspect: 'all', |
| }, {width: 44, height: 28, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture133, |
| mipLevel: 0, |
| origin: {x: 8, y: 0, z: 8}, |
| aspect: 'all', |
| }, new Uint8Array(85_111).fill(63), /* required buffer size: 85_111 */ |
| {offset: 247, bytesPerRow: 136, rowsPerImage: 78}, {width: 22, height: 0, depthOrArrayLayers: 9}); |
| } catch {} |
| let textureView196 = texture92.createView({dimension: '2d-array'}); |
| let computePassEncoder187 = commandEncoder232.beginComputePass(); |
| let renderBundleEncoder20 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2uint'], sampleCount: 4}); |
| let sampler130 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 90.59, |
| lodMaxClamp: 92.90, |
| maxAnisotropy: 5, |
| }); |
| try { |
| computePassEncoder165.setBindGroup(1, bindGroup58); |
| } catch {} |
| try { |
| computePassEncoder116.setBindGroup(0, bindGroup94, new Uint32Array(215), 46, 0); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let commandEncoder233 = device0.createCommandEncoder({}); |
| let computePassEncoder188 = commandEncoder233.beginComputePass({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder102); computePassEncoder102.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder39.setBindGroup(0, bindGroup75); |
| } catch {} |
| try { |
| renderBundleEncoder20.setBindGroup(1, bindGroup5, new Uint32Array(272), 0, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer2, 2640, new BigUint64Array(596), 29, 32); |
| } catch {} |
| let commandEncoder234 = device0.createCommandEncoder(); |
| let textureView197 = texture161.createView({dimension: '2d-array', mipLevelCount: 1}); |
| let computePassEncoder189 = commandEncoder234.beginComputePass(); |
| try { |
| computePassEncoder33.setBindGroup(1, bindGroup65); |
| } catch {} |
| try { |
| computePassEncoder102.end(); |
| } catch {} |
| try { |
| computePassEncoder187.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder5.setBindGroup(0, bindGroup40, new Uint32Array(4448), 929, 0); |
| } catch {} |
| try { |
| renderPassEncoder31.setViewport(11.012076656870747, 0.2743430612132235, 48.142470615482495, 0.0925883458776223, 0.9113735874306068, 0.9407875257013131); |
| } catch {} |
| try { |
| renderPassEncoder3.setVertexBuffer(2, undefined); |
| } catch {} |
| try { |
| renderBundleEncoder20.setIndexBuffer(buffer125, 'uint16', 612, 1_028); |
| } catch {} |
| try { |
| renderBundleEncoder19.setVertexBuffer(0, buffer82, 356, 252); |
| } catch {} |
| let texture203 = device0.createTexture({ |
| size: {width: 440}, |
| dimension: '1d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder179.setBindGroup(1, bindGroup81, new Uint32Array(2952), 597, 0); |
| } catch {} |
| try { |
| renderPassEncoder18.setVertexBuffer(2, undefined, 164_980_430); |
| } catch {} |
| try { |
| renderBundleEncoder20.setBindGroup(3, bindGroup131, new Uint32Array(349), 73, 0); |
| } catch {} |
| try { |
| renderBundleEncoder18.setIndexBuffer(buffer76, 'uint16', 528, 7_030); |
| } catch {} |
| try { |
| renderBundleEncoder18.setVertexBuffer(6, buffer109, 112, 33); |
| } catch {} |
| let texture204 = device0.createTexture({ |
| label: '\u32eb\ud4c3\uee52\u0217', |
| size: [55, 5, 1], |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder190 = commandEncoder139.beginComputePass({}); |
| let renderBundle18 = renderBundleEncoder19.finish(); |
| let sampler131 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 13.61, |
| lodMaxClamp: 95.15, |
| }); |
| try { |
| computePassEncoder189.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder63.setVertexBuffer(6, undefined, 81_893_342, 927_713_344); |
| } catch {} |
| try { |
| renderBundleEncoder18.setBindGroup(1, bindGroup134, []); |
| } catch {} |
| try { |
| renderBundleEncoder18.setVertexBuffer(1, buffer140, 504); |
| } catch {} |
| try { |
| buffer89.unmap(); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 560, height: 582, depthOrArrayLayers: 1} |
| */ |
| { |
| source: canvas2, |
| origin: { x: 34, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture191, |
| mipLevel: 0, |
| origin: {x: 6, y: 29, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 105, height: 13, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup135 = device0.createBindGroup({ |
| layout: bindGroupLayout17, |
| entries: [{binding: 78, resource: sampler54}, {binding: 113, resource: textureView107}], |
| }); |
| let buffer149 = device0.createBuffer({ |
| size: 35723, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder235 = device0.createCommandEncoder({label: '\u{1fdb2}\u9853\ubcc7\u3452'}); |
| let sampler132 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'clamp-to-edge', |
| lodMinClamp: 35.82, |
| lodMaxClamp: 48.88, |
| }); |
| try { |
| computePassEncoder190.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder41.setIndexBuffer(buffer130, 'uint32', 228, 346); |
| } catch {} |
| try { |
| gpuCanvasContext3.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| } catch {} |
| try { |
| if (!arrayBuffer15.detached) { new Uint8Array(arrayBuffer15).fill(0x55); }; |
| } catch {} |
| let commandEncoder236 = device0.createCommandEncoder(); |
| let computePassEncoder191 = commandEncoder236.beginComputePass({}); |
| let sampler133 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 8.533, |
| lodMaxClamp: 99.98, |
| maxAnisotropy: 8, |
| }); |
| try { |
| computePassEncoder33.setBindGroup(3, bindGroup124, new Uint32Array(4425), 3, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder167); computePassEncoder167.dispatchWorkgroupsIndirect(buffer84, 3_628); }; |
| } catch {} |
| try { |
| computePassEncoder137.setPipeline(pipeline4); |
| } catch {} |
| try { |
| computePassEncoder188.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder47.setBlendConstant({ r: 678.8, g: 822.2, b: -158.8, a: -443.2, }); |
| } catch {} |
| try { |
| renderBundleEncoder18.setVertexBuffer(6, buffer59, 0, 423); |
| } catch {} |
| try { |
| commandEncoder235.copyTextureToBuffer({ |
| texture: texture143, |
| mipLevel: 0, |
| origin: {x: 16, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 48 widthInBlocks: 12 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 4292 */ |
| offset: 4292, |
| buffer: buffer9, |
| }, {width: 12, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| } catch {} |
| let buffer150 = device0.createBuffer({size: 8852, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let texture205 = device0.createTexture({ |
| size: [70, 72, 1], |
| mipLevelCount: 1, |
| sampleCount: 1, |
| format: 'r32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView198 = texture131.createView({label: '\ud6cc\u00ca\u3486\u0bfb', format: 'rgb10a2uint'}); |
| let renderBundle19 = renderBundleEncoder18.finish({}); |
| let sampler134 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMaxClamp: 74.62, |
| compare: 'equal', |
| maxAnisotropy: 14, |
| }); |
| try { |
| computePassEncoder118.setBindGroup(0, bindGroup2); |
| } catch {} |
| try { |
| computePassEncoder191.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderBundleEncoder20.setBindGroup(3, bindGroup1); |
| } catch {} |
| try { |
| renderBundleEncoder20.setBindGroup(2, bindGroup29, new Uint32Array(844), 271, 0); |
| } catch {} |
| let buffer151 = device0.createBuffer({ |
| size: 54718, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder237 = device0.createCommandEncoder({}); |
| let computePassEncoder192 = commandEncoder237.beginComputePass({}); |
| try { |
| computePassEncoder192.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder64.setScissorRect(15, 16, 9, 1); |
| } catch {} |
| try { |
| renderBundleEncoder20.setBindGroup(3, bindGroup133, []); |
| } catch {} |
| try { |
| renderBundleEncoder20.setIndexBuffer(buffer86, 'uint16', 530, 30); |
| } catch {} |
| try { |
| buffer63.unmap(); |
| } catch {} |
| try { |
| commandEncoder235.copyBufferToBuffer(buffer103, 236, buffer147, 552, 0); |
| } catch {} |
| let buffer152 = device0.createBuffer({size: 105, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM}); |
| let texture206 = device0.createTexture({ |
| label: '\u8cdb\u3cc2\u{1f64e}\u6b2a\u4326\u0dce\u04e9\u0c3e\u03bb\uf7da\uf340', |
| size: [48], |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView199 = texture56.createView({mipLevelCount: 1, baseArrayLayer: 12, arrayLayerCount: 3}); |
| let computePassEncoder193 = commandEncoder235.beginComputePass({}); |
| try { |
| computePassEncoder86.setBindGroup(3, bindGroup34); |
| } catch {} |
| try { |
| renderPassEncoder30.setPipeline(pipeline1); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer96, 2940, new DataView(new ArrayBuffer(1435)), 7, 296); |
| } catch {} |
| try { |
| computePassEncoder135.label = '\u{1fc03}\u2508\u{1f9f3}\uea2a\u{1ffd3}\u5b4a\ua3eb\u302d\u02c1\u0c48'; |
| } catch {} |
| let texture207 = device0.createTexture({ |
| size: [110, 10, 36], |
| format: 'depth24plus', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| computePassEncoder115.setBindGroup(3, bindGroup71); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder116); computePassEncoder116.dispatchWorkgroupsIndirect(buffer130, 32); }; |
| } catch {} |
| try { |
| renderPassEncoder74.setBindGroup(1, bindGroup66, new Uint32Array(3412), 96, 0); |
| } catch {} |
| try { |
| renderPassEncoder43.setVertexBuffer(7, buffer103, 0); |
| } catch {} |
| try { |
| renderBundleEncoder20.setBindGroup(0, bindGroup134, []); |
| } catch {} |
| try { |
| renderBundleEncoder20.setBindGroup(3, bindGroup70, new Uint32Array(744), 26, 0); |
| } catch {} |
| try { |
| renderBundleEncoder20.setIndexBuffer(buffer112, 'uint16', 132, 112); |
| } catch {} |
| let pipelineLayout12 = device0.createPipelineLayout({bindGroupLayouts: [bindGroupLayout6]}); |
| let buffer153 = device0.createBuffer({size: 6370, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let querySet25 = device0.createQuerySet({type: 'occlusion', count: 1475}); |
| let texture208 = device0.createTexture({ |
| size: [64, 64, 22], |
| mipLevelCount: 2, |
| format: 'depth24plus', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView200 = texture137.createView({format: 'rgb10a2unorm', mipLevelCount: 1}); |
| let renderBundle20 = renderBundleEncoder20.finish(); |
| try { |
| computePassEncoder193.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder57.setBindGroup(3, bindGroup22, new Uint32Array(654), 6, 0); |
| } catch {} |
| try { |
| renderPassEncoder12.executeBundles([renderBundle16, renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder37.setVertexBuffer(2, buffer6, 412, 297); |
| } catch {} |
| try { |
| buffer57.unmap(); |
| } catch {} |
| let texture209 = device0.createTexture({ |
| size: {width: 295}, |
| dimension: '1d', |
| format: 'rgba32float', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView201 = texture192.createView({dimension: '2d-array', aspect: 'all', baseArrayLayer: 0, arrayLayerCount: 1}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder116); computePassEncoder116.dispatchWorkgroupsIndirect(buffer73, 25_908); }; |
| } catch {} |
| try { |
| renderPassEncoder58.setIndexBuffer(buffer77, 'uint32', 400, 257); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture206, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(547).fill(194), /* required buffer size: 547 */ |
| {offset: 547}, {width: 9, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 140, height: 145, depthOrArrayLayers: 239} |
| */ |
| { |
| source: imageData8, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture137, |
| mipLevel: 1, |
| origin: {x: 16, y: 55, z: 7}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer154 = device0.createBuffer({size: 18627, usage: GPUBufferUsage.MAP_WRITE}); |
| let commandEncoder238 = device0.createCommandEncoder({}); |
| try { |
| computePassEncoder57.setBindGroup(3, bindGroup73); |
| } catch {} |
| try { |
| computePassEncoder162.setBindGroup(3, bindGroup64, new Uint32Array(166), 43, 0); |
| } catch {} |
| try { |
| renderPassEncoder83.setPipeline(pipeline1); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| let arrayBuffer17 = buffer35.getMappedRange(464, 8); |
| try { |
| buffer6.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| let imageData28 = new ImageData(28, 52); |
| let computePassEncoder194 = commandEncoder238.beginComputePass({}); |
| let sampler135 = device0.createSampler({ |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| minFilter: 'linear', |
| lodMinClamp: 61.92, |
| lodMaxClamp: 83.14, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder136); computePassEncoder136.dispatchWorkgroupsIndirect(buffer72, 4_616); }; |
| } catch {} |
| try { |
| computePassEncoder194.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder32.setIndexBuffer(buffer109, 'uint16', 752, 258); |
| } catch {} |
| let shaderModule15 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| requires packed_4x8_integer_dot_product; |
| |
| diagnostic(info, xyz); |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| @group(0) @binding(103) var st26: texture_storage_3d<rgba8unorm, write>; |
| |
| @group(0) @binding(176) var st27: texture_storage_3d<rgba16uint, write>; |
| |
| struct T0 { |
| @align(4) @size(16) f0: f16, |
| @size(188) f1: array<atomic<u32>>, |
| } |
| |
| struct FragmentOutput11 { |
| @location(0) f0: vec4u, |
| } |
| |
| alias vec3b = vec3<bool>; |
| |
| @id(26749) override override9: bool; |
| |
| override override10: u32 = 55; |
| |
| @id(30525) override override11: bool; |
| |
| fn fn0() -> FragmentOutput11 { |
| var out: FragmentOutput11; |
| var vf295: vec4i = unpack4xI8(u32(unconst_u32(406))); |
| out.f0 ^= vec4u(unpack2x16snorm(u32(unconst_u32(103))).rggg); |
| let vf296: vec4h = pow(vec4h(unconst_f16(14190.7), unconst_f16(-3351.9), unconst_f16(9253.2), unconst_f16(1467.8)), vec4h(insertBits(vec3i(smoothstep(vec2f(unconst_f32(0.03481), unconst_f32(0.07413)), vec2f(unconst_f32(0.2155), unconst_f32(0.07687)), vec2f(unconst_f32(0.04415), unconst_f32(0.00528))).ggr), vec3i(unconst_i32(54), unconst_i32(13), unconst_i32(100)), u32(unconst_u32(246)), u32(unconst_u32(78))).zzyz)); |
| let vf297: vec3h = refract(vec3h(unconst_f16(-1049.6), unconst_f16(16707.7), unconst_f16(1454.7)), vec3h(unconst_f16(1390.1), unconst_f16(58577.8), unconst_f16(261.1)), f16(unconst_f16(17658.5))); |
| out.f0 -= vec4u(ceil(vec4h(unconst_f16(-1217.8), unconst_f16(17856.5), unconst_f16(7423.3), unconst_f16(610.6)))); |
| vf295 &= vec4i(refract(vec3h(unconst_f16(13542.4), unconst_f16(6263.1), unconst_f16(5039.4)), vec3h(unconst_f16(47624.9), unconst_f16(3271.0), unconst_f16(8079.6)), f16(unconst_f16(-12809.3))).zzxy); |
| let vf298: i32 = vf295[u32(unconst_u32(107))]; |
| var vf299: vec3i = insertBits(vec3i(i32(abs(f32(unconst_f32(0.00854))))), vec3i(unconst_i32(80), unconst_i32(117), unconst_i32(199)), u32(unconst_u32(9)), u32(unconst_u32(80))); |
| out.f0 &= vec4u(u32(override11)); |
| var vf300: u32 = pack2x16float(vec2f(unconst_f32(0.6511), unconst_f32(0.1832))); |
| let vf301: vec3u = countTrailingZeros(vec3u(unconst_u32(559), unconst_u32(58), unconst_u32(1))); |
| vf295 *= vec4i(i32(override11)); |
| return out; |
| _ = override11; |
| } |
| |
| @fragment |
| fn fragment12() -> FragmentOutput11 { |
| var out: FragmentOutput11; |
| out.f0 = vec4u(u32(override9)); |
| fn0(); |
| out = FragmentOutput11(unpack4xU8(max(u32(unconst_u32(484)), u32(unconst_u32(183))))); |
| let vf302: vec3f = asin(vec3f(unconst_f32(0.01290), unconst_f32(0.1127), unconst_f32(0.1454))); |
| fn0(); |
| out = FragmentOutput11(vec4u(u32(override11))); |
| out.f0 = vec4u(degrees(vec2f(unconst_f32(0.1120), unconst_f32(-0.3167))).gggr); |
| out = FragmentOutput11(bitcast<vec4u>(countTrailingZeros(vec2i(unconst_i32(640), unconst_i32(-173))).yxxx)); |
| var vf303: u32 = dot4U8Packed(u32(override11), u32(unconst_u32(621))); |
| return out; |
| _ = override11; |
| _ = override9; |
| } |
| |
| @compute @workgroup_size(1, 1, 1) |
| fn compute14() { |
| var vf304: u32 = pack4x8snorm(vec4f(unconst_f32(0.1703), unconst_f32(0.2063), unconst_f32(0.04431), unconst_f32(0.3510))); |
| }`, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| let buffer155 = device0.createBuffer({ |
| size: 10190, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let textureView202 = texture91.createView({label: '\ufe43\u0847\u1091\u0071'}); |
| try { |
| computePassEncoder105.setBindGroup(1, bindGroup107); |
| } catch {} |
| try { |
| computePassEncoder13.setBindGroup(1, bindGroup48, new Uint32Array(649), 90, 0); |
| } catch {} |
| try { |
| computePassEncoder136.end(); |
| } catch {} |
| try { |
| renderPassEncoder8.executeBundles([renderBundle5]); |
| } catch {} |
| try { |
| renderPassEncoder8.setIndexBuffer(buffer80, 'uint16', 7_390, 677); |
| } catch {} |
| let commandEncoder239 = device0.createCommandEncoder({}); |
| let commandBuffer13 = commandEncoder175.finish(); |
| let sampler136 = device0.createSampler({ |
| addressModeV: 'repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 77.71, |
| lodMaxClamp: 78.96, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder94); computePassEncoder94.dispatchWorkgroupsIndirect(buffer82, 108); }; |
| } catch {} |
| try { |
| renderPassEncoder25.setVertexBuffer(2, buffer109, 640, 218); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture148, |
| mipLevel: 0, |
| origin: {x: 76, y: 9, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(461).fill(151), /* required buffer size: 461 */ |
| {offset: 461, bytesPerRow: 197}, {width: 43, height: 12, depthOrArrayLayers: 0}); |
| } catch {} |
| let videoFrame35 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA', timestamp: 0, colorSpace: {fullRange: false, matrix: 'fcc', primaries: 'bt470bg', transfer: 'gamma22curve'} }); |
| let commandEncoder240 = device0.createCommandEncoder(); |
| let querySet26 = device0.createQuerySet({type: 'occlusion', count: 641}); |
| let computePassEncoder195 = commandEncoder239.beginComputePass({}); |
| let sampler137 = device0.createSampler({ |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 88.18, |
| lodMaxClamp: 92.98, |
| maxAnisotropy: 6, |
| }); |
| try { |
| computePassEncoder142.setBindGroup(1, bindGroup44); |
| } catch {} |
| try { |
| computePassEncoder153.setBindGroup(3, bindGroup118, new Uint32Array(3071), 260, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 70, height: 72, depthOrArrayLayers: 25} |
| */ |
| { |
| source: imageData10, |
| origin: { x: 13, y: 3 }, |
| flipY: true, |
| }, { |
| texture: texture194, |
| mipLevel: 0, |
| origin: {x: 3, y: 5, z: 1}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 4, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.append(img1); |
| let bindGroup136 = device0.createBindGroup({layout: bindGroupLayout20, entries: [{binding: 152, resource: textureView108}]}); |
| let texture210 = gpuCanvasContext2.getCurrentTexture(); |
| let computePassEncoder196 = commandEncoder240.beginComputePass({}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder118); computePassEncoder118.dispatchWorkgroupsIndirect(buffer73, 144); }; |
| } catch {} |
| try { |
| computePassEncoder196.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder74.executeBundles([renderBundle15, renderBundle10, renderBundle10, renderBundle1, renderBundle10]); |
| } catch {} |
| try { |
| renderPassEncoder69.setVertexBuffer(0, buffer43, 0); |
| } catch {} |
| let bindGroupLayout26 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 49, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'uniform', minBindingSize: 0, hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let texture211 = device0.createTexture({ |
| size: {width: 220, height: 20, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'etc2-rgba8unorm-srgb', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder82.setBindGroup(3, bindGroup36); |
| } catch {} |
| try { |
| computePassEncoder195.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder18.setBindGroup(1, bindGroup60); |
| } catch {} |
| try { |
| renderPassEncoder77.executeBundles([renderBundle2, renderBundle10]); |
| } catch {} |
| try { |
| renderPassEncoder19.setScissorRect(13, 0, 39, 0); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| try { |
| buffer3.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_SRC, |
| colorSpace: 'display-p3', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let bindGroup137 = device0.createBindGroup({ |
| label: '\u008b\u{1fe44}\u{1f651}\u02a4\u4c6a\u53c5', |
| layout: bindGroupLayout26, |
| entries: [{binding: 49, resource: {buffer: buffer89, offset: 0, size: 600}}], |
| }); |
| let commandEncoder241 = device0.createCommandEncoder({label: '\ua041\ud343\u18b7\u1d92'}); |
| let texture212 = device0.createTexture({ |
| size: {width: 440, height: 40, depthOrArrayLayers: 1}, |
| mipLevelCount: 4, |
| format: 'depth24plus', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let sampler138 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeW: 'repeat', |
| mipmapFilter: 'linear', |
| lodMinClamp: 34.63, |
| lodMaxClamp: 67.13, |
| compare: 'not-equal', |
| }); |
| try { |
| computePassEncoder48.setBindGroup(0, bindGroup0); |
| } catch {} |
| try { |
| computePassEncoder123.end(); |
| } catch {} |
| try { |
| renderPassEncoder18.setBindGroup(1, bindGroup124, new Uint32Array(763), 110, 0); |
| } catch {} |
| try { |
| renderPassEncoder70.setIndexBuffer(buffer151, 'uint16', 2_550, 3_561); |
| } catch {} |
| try { |
| commandEncoder241.clearBuffer(buffer144, 724, 236); |
| } catch {} |
| let commandBuffer14 = commandEncoder164.finish(); |
| let texture213 = device0.createTexture({ |
| size: {width: 73, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 3, |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let renderPassEncoder86 = commandEncoder241.beginRenderPass({ |
| label: '\u{1fcc0}\u146f\ue4dd\uc440\u{1fa1b}\ufe9d\u{1f9d3}\u38c1\u{1f95f}\u0c8e', |
| colorAttachments: [{ |
| view: textureView202, |
| clearValue: { r: -984.5, g: 907.7, b: 92.78, a: 971.4, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| }); |
| let sampler139 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 94.91, |
| lodMaxClamp: 96.67, |
| compare: 'greater', |
| maxAnisotropy: 7, |
| }); |
| try { |
| computePassEncoder85.setBindGroup(0, bindGroup0); |
| } catch {} |
| try { |
| computePassEncoder23.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder80.setIndexBuffer(buffer30, 'uint32', 16, 5); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({device: device0, format: 'rgba16float', usage: GPUTextureUsage.TEXTURE_BINDING, colorSpace: 'srgb'}); |
| } catch {} |
| try { |
| renderPassEncoder8.setVertexBuffer(3, buffer128); |
| } catch {} |
| let shaderModule16 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| requires readonly_and_readwrite_storage_textures; |
| |
| diagnostic(info, xyz); |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| @group(0) @binding(103) var st28: texture_storage_3d<rgba8unorm, write>; |
| |
| @group(0) @binding(176) var st29: texture_storage_3d<rgba16uint, write>; |
| |
| struct T0 { |
| @align(32) @size(288) f0: f16, |
| } |
| |
| struct T1 { |
| @size(640) f0: array<vec4h>, |
| } |
| |
| struct T2 { |
| @size(60) f0: array<f32>, |
| } |
| |
| struct FragmentOutput12 { |
| @location(0) @interpolate(flat) f0: vec4u, |
| } |
| |
| struct S10 { |
| @location(8) @interpolate(flat, centroid) f0: vec2u, |
| @location(11) @interpolate(flat, centroid) f1: vec4u, |
| } |
| |
| struct S11 { |
| @location(10) @interpolate(flat, sample) f0: vec4u, |
| } |
| |
| struct FragmentOutput13 { |
| @location(2) @interpolate(flat) f0: vec4u, |
| @location(1) @interpolate(linear) f1: vec4f, |
| @location(0) @interpolate(flat) f2: vec4i, |
| } |
| |
| struct FragmentOutput14 { |
| @location(4) @interpolate(linear) f0: f32, |
| @location(0) f1: vec4u, |
| } |
| |
| alias vec3b = vec3<bool>; |
| |
| fn fn0() -> FragmentOutput14 { |
| var out: FragmentOutput14; |
| out.f0 = unpack2x16snorm(u32(unconst_u32(575))).y; |
| var vf305: u32 = reverseBits(u32(unconst_u32(0))); |
| var vf306: vec3f = atan2(vec3f(unconst_f32(0.06234), unconst_f32(0.00172), unconst_f32(0.07151)), vec3f(unconst_f32(0.2999), unconst_f32(0.07801), unconst_f32(0.1738))); |
| let ptr127: ptr<function, u32> = &vf305; |
| var vf307: u32 = clamp(u32(unconst_u32(127)), u32(unconst_u32(301)), u32(unconst_u32(106))); |
| let ptr128: ptr<private, i32> = &vp15.exp; |
| let vf308: vec2f = inverseSqrt(vec2f(unconst_f32(0.4950), unconst_f32(0.02343))); |
| out.f1 -= bitcast<vec4u>(unpack2x16snorm(u32(unconst_u32(80))).xxxx); |
| var vf309: u32 = pack2x16unorm(vec2f(unconst_f32(0.1247), unconst_f32(-0.03901))); |
| let vf310: vec2h = log(vec2h(atan2(vf306, vec3f(unconst_f32(0.07927), unconst_f32(0.05242), unconst_f32(0.2055))).gb)); |
| var vf311: vec4f = inverseSqrt(vec4f(unconst_f32(0.05835), unconst_f32(0.05545), unconst_f32(0.1345), unconst_f32(0.2160))); |
| vf305 ^= u32(inverseSqrt(vec2f(f32(vf309)))[1]); |
| var vf312: f32 = vf311[u32(unconst_u32(172))]; |
| vf311 = atan2(vec3f(unconst_f32(0.1376), unconst_f32(0.06258), unconst_f32(0.01803)), vec3f(unconst_f32(0.2119), unconst_f32(-0.00502), unconst_f32(0.05863))).zzzz; |
| vf305 >>= u32(vf312); |
| out.f0 -= f32((*ptr127)); |
| var vf313: vec2f = inverseSqrt(vec2f(unconst_f32(0.3228), unconst_f32(0.02327))); |
| vf305 = bitcast<u32>(reverseBits(vec2i(unconst_i32(46), unconst_i32(102)))[0]); |
| return out; |
| } |
| |
| fn fn1() -> vec2<bool> { |
| var out: vec2<bool>; |
| out = vec2<bool>(bool(vp15.fract)); |
| let vf314: vec4h = trunc(vec4h(unconst_f16(6876.4), unconst_f16(2731.8), unconst_f16(10252.9), unconst_f16(19806.1))); |
| out = vec2<bool>(cross(vec3f(unconst_f32(0.09229), unconst_f32(-0.1708), unconst_f32(0.01431)), vec3f(unconst_f32(0.1198), unconst_f32(0.2830), unconst_f32(0.08248))).gb); |
| vp15 = frexp(f32(vf314[u32(unconst_u32(230))])); |
| vp15.fract = length(vec4f(unconst_f32(0.2011), unconst_f32(0.4949), unconst_f32(0.05517), unconst_f32(0.2427))); |
| var vf315: vec3f = max(vec3f(unconst_f32(0.2660), unconst_f32(0.06936), unconst_f32(0.00120)), vec3f(unconst_f32(0.05703), unconst_f32(0.4443), unconst_f32(0.02661))); |
| let vf316: vec3f = cross(vec3f(unconst_f32(0.02584), unconst_f32(0.04271), unconst_f32(0.01091)), cross(vec3f(unconst_f32(0.09580), unconst_f32(0.05802), unconst_f32(0.09480)), vec3f(unconst_f32(0.1092), unconst_f32(0.1208), unconst_f32(0.4482)))); |
| var vf317: vec3f = cross(vec3f(unconst_f32(0.4973), unconst_f32(0.07133), unconst_f32(0.1771)), vec3f(unconst_f32(0.05427), unconst_f32(0.4196), unconst_f32(0.4005))); |
| let vf318: f16 = determinant(mat4x4h()); |
| let vf319: f16 = determinant(mat4x4h()); |
| vf315 = vec3f(bitcast<f32>(vp15.exp)); |
| vf315 -= vec3f(vf317[u32(unconst_u32(860))]); |
| let vf320: f32 = vf316[u32(unconst_u32(57))]; |
| return out; |
| } |
| |
| fn fn2() -> vec4f { |
| var out: vec4f; |
| var vf321: vec4<bool> = select(vec4<bool>(unconst_bool(false), unconst_bool(true), unconst_bool(true), unconst_bool(true)), vec4<bool>(unconst_bool(false), unconst_bool(false), unconst_bool(true), unconst_bool(false)), bool(unconst_bool(true))); |
| let ptr129: ptr<private, f32> = &vp15.fract; |
| vp15.fract *= f32(pack2x16unorm(vec2f(unconst_f32(0.1201), unconst_f32(0.1286)))); |
| vp15 = frexp(f32(vf321[u32(unconst_u32(90))])); |
| vf321 = vec4<bool>(bool(dot4I8Packed(u32(unconst_u32(17)), u32(unconst_u32(74))))); |
| let vf322: u32 = pack2x16unorm(vec2f(unconst_f32(0.02880), unconst_f32(0.09441))); |
| let vf323: u32 = pack2x16unorm(vec2f(unconst_f32(0.09584), unconst_f32(0.09533))); |
| vf321 = vec4<bool>(bool((*ptr129))); |
| let vf324: u32 = vf323; |
| let ptr130: ptr<private, i32> = &vp15.exp; |
| vp15.fract += asin(vec2f(unconst_f32(0.04879), unconst_f32(0.00944))).y; |
| out *= vec4f((*ptr129)); |
| var vf325: vec2h = round(vec2h(unconst_f16(82.61), unconst_f16(8022.3))); |
| vf325 += bitcast<vec2h>((*ptr130)); |
| vf325 = vec2h(asin(vec2f(unconst_f32(0.4066), unconst_f32(0.1276)))); |
| return out; |
| } |
| |
| var<workgroup> vw59: mat4x2f; |
| |
| var<workgroup> vw60: array<vec2u, 29>; |
| |
| var<private> vp15 = frexp(f32(0.06752)); |
| |
| @fragment |
| fn fragment13() -> FragmentOutput12 { |
| var out: FragmentOutput12; |
| out.f0 += vec4u(u32(countLeadingZeros(i32(unconst_i32(6))))); |
| var vf326: i32 = countLeadingZeros(i32(unconst_i32(605))); |
| out.f0 &= vec4u(saturate(vec2h(unconst_f16(9077.7), unconst_f16(921.2))).rrgg); |
| vf326 = i32(exp2(vec3f(unconst_f32(0.05081), unconst_f32(0.2669), unconst_f32(0.00597)))[2]); |
| var vf327: vec4h = trunc(vec4h(f16(vp15.exp))); |
| var vf328: u32 = dot(vec4u(unconst_u32(89), unconst_u32(48), unconst_u32(104), unconst_u32(73)), vec4u(tan(vec2h(unconst_f16(12351.4), unconst_f16(7583.6))).rgrr)); |
| var vf329 = fn2(); |
| discard; |
| return out; |
| } |
| |
| @fragment |
| fn fragment14(a0: S10, a1: S11, @location(14) @interpolate(flat) a2: vec4u) -> FragmentOutput13 { |
| var out: FragmentOutput13; |
| var vf330: vec4f = reflect(vec4f(unconst_f32(0.01867), unconst_f32(0.6168), unconst_f32(0.08959), unconst_f32(0.1748)), vec4f(unconst_f32(0.00194), unconst_f32(-0.1062), unconst_f32(0.08288), unconst_f32(-0.05856))); |
| var vf331: S10 = a0; |
| let vf332: vec3h = log(vec3h(unconst_f16(1853.4), unconst_f16(5441.2), unconst_f16(11097.6))); |
| out = FragmentOutput13(vec4u(vf330), vf330, vec4i(vf330)); |
| var vf333: vec2u = a0.f0; |
| out.f1 = vec4f(sinh(vec4h(unconst_f16(2033.6), unconst_f16(1797.3), unconst_f16(13149.8), unconst_f16(12467.5)))); |
| vf333 = vec2u(bitcast<u32>(vp15.fract)); |
| var vf334 = fn2(); |
| fn2(); |
| vf333 += bitcast<vec2u>(normalize(vec4h(unconst_f16(21843.7), unconst_f16(94.75), unconst_f16(2720.2), unconst_f16(2963.4)))); |
| vf330 -= bitcast<vec4f>(reverseBits(vec4i(unconst_i32(-379), unconst_i32(109), unconst_i32(224), unconst_i32(834)))); |
| return out; |
| } |
| |
| @fragment |
| fn fragment15() -> FragmentOutput14 { |
| var out: FragmentOutput14; |
| out.f1 &= vec4u(quantizeToF16(vec3f(unconst_f32(0.2089), unconst_f32(0.1175), unconst_f32(0.4391))).bggb); |
| var vf335: bool = any(vec2<bool>(unconst_bool(true), unconst_bool(false))); |
| let ptr131 = &vp15; |
| var vf336 = fn2(); |
| var vf337: u32 = pack2x16snorm(vec2f(f32(pack2x16snorm(vec2f(bitcast<f32>(vp15.exp)))))); |
| var vf338 = fn2(); |
| let ptr132: ptr<function, vec4f> = &vf338; |
| let vf339: vec4f = floor(vec4f(unconst_f32(-0.04946), unconst_f32(0.06749), unconst_f32(0.1724), unconst_f32(0.2325))); |
| var vf340 = fn2(); |
| vf335 = bool((*ptr131).exp); |
| vf336 += vec4f(f32(min(f16(unconst_f16(89.94)), f16(unconst_f16(38246.2))))); |
| let ptr133: ptr<private, f32> = &(*ptr131).fract; |
| out.f0 -= radians(vec4f(unconst_f32(0.1964), unconst_f32(0.2555), unconst_f32(0.1022), unconst_f32(0.1246))).r; |
| vf340 += vec4f(f32(vf337)); |
| vf337 >>= u32(vf339[bitcast<vec3u>(acosh(vec3f(unconst_f32(0.2710), unconst_f32(0.1976), unconst_f32(0.2619))))[0]]); |
| vf340 = acosh(vec3f(unconst_f32(0.1227), unconst_f32(0.3436), unconst_f32(0.2556))).zyyx; |
| fn2(); |
| vf340 = vec4f((*ptr133)); |
| var vf341 = fn2(); |
| var vf342: bool = any(vec2<bool>(unconst_bool(false), unconst_bool(true))); |
| return out; |
| } |
| |
| @compute @workgroup_size(1, 2, 1) |
| fn compute15() { |
| let ptr134: ptr<workgroup, vec2u> = &(*&vw60)[28]; |
| storageBarrier(); |
| var vf343 = fn2(); |
| vw59 -= workgroupUniformLoad(&vw59); |
| vw59 = mat4x2f(vec2f(workgroupUniformLoad(&vw60)[28]), vec2f(workgroupUniformLoad(&vw60)[28]), bitcast<vec2f>(workgroupUniformLoad(&vw60)[28]), bitcast<vec2f>(workgroupUniformLoad(&vw60)[28])); |
| let ptr135 = &vp15; |
| vf343 -= vec4f((*&vw60)[28].gggg); |
| let ptr136: ptr<workgroup, vec2u> = &(*&vw60)[28]; |
| textureStore(st28, vec3i(unconst_i32(62), unconst_i32(101), unconst_i32(146)), vec4f(vec4f(unconst_f32(0.01458), unconst_f32(0.00351), unconst_f32(0.4589), unconst_f32(0.1896)))); |
| let vf344: vec2f = vw59[u32(unconst_u32(346))]; |
| var vf345 = fn2(); |
| var vf346 = fn1(); |
| vw59 = mat4x2f(vf344, vf344, vf344, vf344); |
| vw59 = mat4x2f(bitcast<f32>((*ptr134)[u32(unconst_u32(86))]), f32((*ptr134)[u32(unconst_u32(86))]), bitcast<f32>((*ptr134)[u32(unconst_u32(86))]), bitcast<f32>((*ptr134)[u32(unconst_u32(86))]), f32((*ptr134)[u32(unconst_u32(86))]), bitcast<f32>((*ptr134)[u32(unconst_u32(86))]), bitcast<f32>((*ptr134)[u32(unconst_u32(86))]), f32((*ptr134)[u32(unconst_u32(86))])); |
| let vf347: vec4u = insertBits(vec4u(unconst_u32(513), unconst_u32(122), unconst_u32(3), unconst_u32(30)), vw60[28].rgrr, u32(unconst_u32(74)), u32(unconst_u32(29))); |
| vf346 = vec2<bool>(bool(vw60[workgroupUniformLoad(&vw60)[28][1]][(*&vw60)[u32(unconst_u32(69))][0]])); |
| fn2(); |
| vw60[bitcast<u32>(fma(f32(unconst_f32(0.06410)), f32(unconst_f32(0.00024)), f32(unconst_f32(0.01623))))] = vec2u(u32(vp15.fract)); |
| } |
| |
| @compute @workgroup_size(1, 1, 1) |
| fn compute16() { |
| vw59 = mat4x2f(bitcast<vec2f>((*&vw60)[28]), bitcast<vec2f>((*&vw60)[28]), vec2f((*&vw60)[28]), vec2f((*&vw60)[28])); |
| vw59 = mat4x2f(length(f32(unconst_f32(-0.05544))), length(f32(unconst_f32(-0.05544))), length(f32(unconst_f32(-0.05544))), length(f32(unconst_f32(-0.05544))), length(f32(unconst_f32(-0.05544))), length(f32(unconst_f32(-0.05544))), length(f32(unconst_f32(-0.05544))), length(f32(unconst_f32(-0.05544)))); |
| textureStore(st28, vec3i(unconst_i32(-8), unconst_i32(275), unconst_i32(-1)), vec4f(vec4f(unconst_f32(0.2614), unconst_f32(-0.00240), unconst_f32(0.3538), unconst_f32(0.09359)))); |
| fn2(); |
| var vf348 = fn2(); |
| vw59 += mat4x2f(vw59[u32(unconst_u32(149))], vw59[u32(unconst_u32(149))], vw59[u32(unconst_u32(149))], vw59[u32(unconst_u32(149))]); |
| var vf349 = fn1(); |
| fn1(); |
| vf348 *= workgroupUniformLoad(&vw59)[unconst_i32(0)].rggg; |
| var vf350: mat4x2f = workgroupUniformLoad(&vw59); |
| let vf351: f32 = length(f32(unconst_f32(0.05813))); |
| vw59 = mat4x2f(vp15.fract, vp15.fract, vp15.fract, vp15.fract, vp15.fract, vp15.fract, vp15.fract, vp15.fract); |
| vf350 = mat4x2f(vw59[u32(unconst_u32(166))], vw59[u32(unconst_u32(166))], vw59[u32(unconst_u32(166))], vw59[u32(unconst_u32(166))]); |
| let ptr137: ptr<function, mat4x2f> = &vf350; |
| let vf352: f32 = length(f32(unconst_f32(0.2392))); |
| let ptr138: ptr<workgroup, vec2u> = &(*&vw60)[u32(unconst_u32(63))]; |
| vf349 = vf349; |
| var vf353 = fn2(); |
| var vf354 = fn1(); |
| let vf355: vec2f = (*ptr137)[u32(unconst_u32(91))]; |
| let ptr139: ptr<workgroup, vec2u> = &(*&vw60)[28]; |
| fn1(); |
| }`, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| let buffer156 = device0.createBuffer({ |
| size: 5295, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder242 = device0.createCommandEncoder({}); |
| let textureView203 = texture145.createView({dimension: '2d-array'}); |
| let sampler140 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 52.03, |
| lodMaxClamp: 93.77, |
| maxAnisotropy: 17, |
| }); |
| try { |
| computePassEncoder179.setBindGroup(1, bindGroup101, []); |
| } catch {} |
| try { |
| computePassEncoder7.setBindGroup(0, bindGroup16, new Uint32Array(1402), 316, 0); |
| } catch {} |
| try { |
| renderPassEncoder30.setPipeline(pipeline1); |
| } catch {} |
| try { |
| commandEncoder242.copyBufferToTexture({ |
| /* bytesInLastRow: 8 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 960 */ |
| offset: 960, |
| bytesPerRow: 4096, |
| buffer: buffer125, |
| }, { |
| texture: texture81, |
| mipLevel: 4, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 73, height: 1, depthOrArrayLayers: 32} |
| */ |
| { |
| source: videoFrame30, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture138, |
| mipLevel: 0, |
| origin: {x: 9, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup138 = device0.createBindGroup({ |
| label: '\ub0b4\u7c6c\u866c\ua51c\u7dd7', |
| layout: bindGroupLayout4, |
| entries: [{binding: 511, resource: {buffer: buffer143, offset: 0}}], |
| }); |
| let computePassEncoder197 = commandEncoder242.beginComputePass({}); |
| try { |
| computePassEncoder174.setBindGroup(0, bindGroup111, new Uint32Array(290), 43, 0); |
| } catch {} |
| try { |
| computePassEncoder197.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder83.setBindGroup(0, bindGroup98, new Uint32Array(2346), 75, 0); |
| } catch {} |
| try { |
| renderPassEncoder34.setIndexBuffer(buffer82, 'uint32', 88, 23); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture148, |
| mipLevel: 0, |
| origin: {x: 94, y: 16, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(19).fill(29), /* required buffer size: 19 */ |
| {offset: 19, bytesPerRow: 107}, {width: 3, height: 5, depthOrArrayLayers: 0}); |
| } catch {} |
| let sampler141 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| lodMinClamp: 73.04, |
| lodMaxClamp: 98.28, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder116); computePassEncoder116.dispatchWorkgroupsIndirect(buffer130, 76); }; |
| } catch {} |
| try { |
| renderPassEncoder36.setIndexBuffer(buffer100, 'uint32', 104, 233); |
| } catch {} |
| try { |
| buffer122.unmap(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 560, height: 582, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame24, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture191, |
| mipLevel: 0, |
| origin: {x: 42, y: 40, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer157 = device0.createBuffer({size: 2931, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX}); |
| let commandEncoder243 = device0.createCommandEncoder({}); |
| let computePassEncoder198 = commandEncoder243.beginComputePass({}); |
| let renderBundleEncoder21 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2uint'], depthReadOnly: true}); |
| let renderBundle21 = renderBundleEncoder21.finish({label: '\uccbd\u99c7\u99df\ufaa7\u3c85\u{1feb0}\uec02\u6a72'}); |
| try { |
| renderPassEncoder64.setBindGroup(3, bindGroup121); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 280, height: 291, depthOrArrayLayers: 478} |
| */ |
| { |
| source: imageBitmap2, |
| origin: { x: 0, y: 1 }, |
| flipY: false, |
| }, { |
| texture: texture137, |
| mipLevel: 0, |
| origin: {x: 30, y: 35, z: 12}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let offscreenCanvas3 = new OffscreenCanvas(132, 227); |
| let bindGroup139 = device0.createBindGroup({ |
| layout: bindGroupLayout21, |
| entries: [ |
| {binding: 606, resource: sampler62}, |
| {binding: 222, resource: {buffer: buffer145, offset: 0, size: 1669}}, |
| {binding: 125, resource: externalTexture9}, |
| {binding: 190, resource: textureView168}, |
| ], |
| }); |
| let commandEncoder244 = device0.createCommandEncoder({}); |
| let computePassEncoder199 = commandEncoder244.beginComputePass({label: '\u00b1\u0ab9\u00f1\u{1fc98}\u4500\ufb49\u7ed8'}); |
| try { |
| computePassEncoder176.setBindGroup(3, bindGroup93); |
| } catch {} |
| try { |
| computePassEncoder87.setBindGroup(0, bindGroup118, new Uint32Array(1583), 485, 0); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer13]); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let commandEncoder245 = device0.createCommandEncoder({}); |
| let texture214 = device0.createTexture({ |
| size: [64, 64, 22], |
| mipLevelCount: 1, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let computePassEncoder200 = commandEncoder245.beginComputePass(); |
| try { |
| computePassEncoder198.setPipeline(pipeline2); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let bindGroup140 = device0.createBindGroup({ |
| layout: bindGroupLayout21, |
| entries: [ |
| {binding: 606, resource: sampler1}, |
| {binding: 125, resource: externalTexture2}, |
| {binding: 190, resource: textureView168}, |
| {binding: 222, resource: {buffer: buffer127, offset: 0}}, |
| ], |
| }); |
| let commandEncoder246 = device0.createCommandEncoder({}); |
| let textureView204 = texture12.createView({dimension: '2d-array'}); |
| let renderPassEncoder87 = commandEncoder246.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView152, |
| depthSlice: 1183, |
| clearValue: { r: 424.4, g: -725.7, b: -999.5, a: -982.9, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| computePassEncoder20.setPipeline(pipeline2); |
| } catch {} |
| try { |
| computePassEncoder200.setPipeline(pipeline5); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer127, 992, new DataView(new ArrayBuffer(7038)), 476, 248); |
| } catch {} |
| let videoFrame36 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: false, matrix: 'unspecified', primaries: 'smpte240m', transfer: 'iec61966-2-1'} }); |
| let textureView205 = texture177.createView({ |
| label: '\uc5bf\u6d88\u{1f849}\ubfc6\ua368\u{1fd36}\u9026\ub25b\uc910\u{1fce2}\u04e8', |
| mipLevelCount: 1, |
| }); |
| try { |
| computePassEncoder163.setBindGroup(1, bindGroup86, new Uint32Array(1528), 132, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder85); computePassEncoder85.dispatchWorkgroups(2); }; |
| } catch {} |
| let arrayBuffer18 = buffer35.getMappedRange(112, 28); |
| let promise18 = device0.queue.onSubmittedWorkDone(); |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 147, height: 1, depthOrArrayLayers: 9} |
| */ |
| { |
| source: imageData20, |
| origin: { x: 1, y: 25 }, |
| flipY: true, |
| }, { |
| texture: texture110, |
| mipLevel: 1, |
| origin: {x: 86, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let buffer158 = device0.createBuffer({ |
| size: 778, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder247 = device0.createCommandEncoder({}); |
| let computePassEncoder201 = commandEncoder247.beginComputePass(); |
| try { |
| computePassEncoder189.setBindGroup(0, bindGroup52, new Uint32Array(526), 150, 0); |
| } catch {} |
| try { |
| computePassEncoder201.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder49.executeBundles([renderBundle5]); |
| } catch {} |
| try { |
| renderPassEncoder6.setIndexBuffer(buffer128, 'uint32', 240, 19); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let gpuCanvasContext5 = offscreenCanvas3.getContext('webgpu'); |
| let buffer159 = device0.createBuffer({ |
| size: 7183, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let texture215 = device0.createTexture({ |
| label: '\u0576\u8472\u{1fee8}\ude79\u9071\u5b93\u1aee', |
| size: [36, 1, 46], |
| format: 'depth24plus', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder181.setBindGroup(1, bindGroup117, new Uint32Array(2107), 499, 0); |
| } catch {} |
| try { |
| computePassEncoder199.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder22.setBindGroup(1, bindGroup24, new Uint32Array(1824), 968, 0); |
| } catch {} |
| try { |
| device0.pushErrorScope('internal'); |
| } catch {} |
| let commandEncoder248 = device0.createCommandEncoder(); |
| let computePassEncoder202 = commandEncoder248.beginComputePass({label: '\u219c\u1765\u92a4\uc752\u42b9\uf8e7\u{1f75d}\u{1ff0d}\u9b61\u04b0\ubbce'}); |
| let sampler142 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 96.29, |
| lodMaxClamp: 97.11, |
| maxAnisotropy: 17, |
| }); |
| try { |
| renderPassEncoder43.setVertexBuffer(3, buffer76, 0); |
| } catch {} |
| try { |
| computePassEncoder202.setPipeline(pipeline3); |
| } catch {} |
| let bindGroup141 = device0.createBindGroup({ |
| layout: bindGroupLayout3, |
| entries: [ |
| {binding: 58, resource: {buffer: buffer138, offset: 0, size: 3420}}, |
| {binding: 225, resource: textureView91}, |
| ], |
| }); |
| let sampler143 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 43.92, |
| lodMaxClamp: 60.61, |
| maxAnisotropy: 12, |
| }); |
| try { |
| computePassEncoder168.setBindGroup(2, bindGroup34); |
| } catch {} |
| try { |
| computePassEncoder163.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder62.setVertexBuffer(7, buffer146); |
| } catch {} |
| try { |
| await promise18; |
| } catch {} |
| let textureView206 = texture19.createView({dimension: '2d-array'}); |
| let texture216 = device0.createTexture({ |
| size: {width: 36, height: 1, depthOrArrayLayers: 177}, |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView207 = texture143.createView({}); |
| try { |
| computePassEncoder63.setBindGroup(3, bindGroup118); |
| } catch {} |
| try { |
| renderPassEncoder49.setVertexBuffer(7, buffer76, 6_600); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 73, height: 1, depthOrArrayLayers: 32} |
| */ |
| { |
| source: imageData21, |
| origin: { x: 14, y: 1 }, |
| flipY: false, |
| }, { |
| texture: texture138, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 3, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let imageData29 = new ImageData(80, 12); |
| let sampler144 = device0.createSampler({ |
| label: '\u0b37\ue024\u0c90\u0120\ucd91\ua961\u2c0c', |
| addressModeV: 'repeat', |
| addressModeW: 'clamp-to-edge', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 94.64, |
| lodMaxClamp: 97.05, |
| compare: 'greater-equal', |
| maxAnisotropy: 1, |
| }); |
| try { |
| renderPassEncoder71.setBindGroup(2, bindGroup40, new Uint32Array(2299), 2, 0); |
| } catch {} |
| try { |
| renderPassEncoder60.setIndexBuffer(buffer84, 'uint32', 1_876, 2_442); |
| } catch {} |
| try { |
| renderPassEncoder80.setPipeline(pipeline1); |
| } catch {} |
| try { |
| device0.pushErrorScope('validation'); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture89, |
| mipLevel: 1, |
| origin: {x: 16, y: 0, z: 28}, |
| aspect: 'all', |
| }, new Uint8Array(43).fill(225), /* required buffer size: 43 */ |
| {offset: 43}, {width: 11, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let externalTexture21 = device0.importExternalTexture({source: videoFrame4, colorSpace: 'srgb'}); |
| try { |
| renderPassEncoder79.setBindGroup(1, bindGroup121); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 73, height: 1, depthOrArrayLayers: 32} |
| */ |
| { |
| source: imageBitmap1, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture138, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let textureView208 = texture173.createView({baseArrayLayer: 0}); |
| try { |
| renderPassEncoder87.setBindGroup(0, bindGroup94); |
| } catch {} |
| try { |
| device0.pushErrorScope('out-of-memory'); |
| } catch {} |
| let imageBitmap4 = await createImageBitmap(imageData27); |
| let commandEncoder249 = device0.createCommandEncoder(); |
| let renderPassEncoder88 = commandEncoder249.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView197, |
| clearValue: { r: -27.64, g: -129.7, b: 78.03, a: -753.0, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| }); |
| let sampler145 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 89.29, |
| lodMaxClamp: 96.07, |
| maxAnisotropy: 1, |
| }); |
| try { |
| computePassEncoder115.setBindGroup(2, bindGroup106, []); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder116); computePassEncoder116.dispatchWorkgroupsIndirect(buffer159, 304); }; |
| } catch {} |
| try { |
| renderPassEncoder56.setBindGroup(3, bindGroup113); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer112, 1068, new BigUint64Array(15205), 2148, 532); |
| } catch {} |
| let videoFrame37 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRX', timestamp: 0, colorSpace: {fullRange: false, matrix: 'unspecified', primaries: 'film', transfer: 'iec6196624'} }); |
| let commandEncoder250 = device0.createCommandEncoder({label: '\u{1f829}\u{1fc25}\u06b7\uce2b\u994b\ub625\u6357\u05b5\u14c2\u07ca\uf2ff'}); |
| let textureView209 = texture137.createView({mipLevelCount: 1}); |
| try { |
| renderPassEncoder78.setBindGroup(1, bindGroup58); |
| } catch {} |
| try { |
| renderPassEncoder22.setBindGroup(0, bindGroup5, new Uint32Array(294), 13, 0); |
| } catch {} |
| try { |
| renderPassEncoder30.setIndexBuffer(buffer86, 'uint32', 256, 522); |
| } catch {} |
| try { |
| renderPassEncoder22.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder6.setVertexBuffer(3, buffer138, 1_284, 878); |
| } catch {} |
| let texture217 = device0.createTexture({ |
| size: [280, 291, 1], |
| mipLevelCount: 4, |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler146 = device0.createSampler({ |
| addressModeV: 'repeat', |
| addressModeW: 'clamp-to-edge', |
| minFilter: 'nearest', |
| lodMinClamp: 77.56, |
| lodMaxClamp: 92.40, |
| }); |
| try { |
| computePassEncoder64.setBindGroup(3, bindGroup116); |
| } catch {} |
| try { |
| computePassEncoder121.setBindGroup(3, bindGroup56, new Uint32Array(794), 461, 0); |
| } catch {} |
| try { |
| renderPassEncoder81.setVertexBuffer(1, buffer94, 1_148, 52); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let texture218 = device0.createTexture({ |
| size: [220, 20, 4], |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let renderPassEncoder89 = commandEncoder250.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView79, |
| clearValue: { r: 681.2, g: -94.14, b: -206.6, a: -507.0, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet12, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder189); computePassEncoder189.dispatchWorkgroupsIndirect(buffer89, 176); }; |
| } catch {} |
| try { |
| computePassEncoder118.end(); |
| } catch {} |
| try { |
| renderPassEncoder26.executeBundles([renderBundle2]); |
| } catch {} |
| try { |
| if (!arrayBuffer10.detached) { new Uint8Array(arrayBuffer10).fill(0x55); }; |
| } catch {} |
| await gc(); |
| let texture219 = device0.createTexture({ |
| size: {width: 220, height: 20, depthOrArrayLayers: 1}, |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture220 = device0.createTexture({ |
| size: [55, 5, 1], |
| sampleCount: 1, |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_SRC, |
| viewFormats: [], |
| }); |
| let computePassEncoder203 = commandEncoder159.beginComputePass(); |
| let sampler147 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| minFilter: 'nearest', |
| lodMinClamp: 94.77, |
| lodMaxClamp: 96.29, |
| }); |
| try { |
| computePassEncoder203.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder28.executeBundles([renderBundle19, renderBundle4]); |
| } catch {} |
| try { |
| renderPassEncoder41.setScissorRect(127, 120, 16, 107); |
| } catch {} |
| let promise19 = device0.queue.onSubmittedWorkDone(); |
| document.body.prepend(canvas1); |
| let videoFrame38 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'BGRA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt2020-cl', primaries: 'smpteSt4281', transfer: 'logSqrt'} }); |
| let bindGroup142 = device0.createBindGroup({ |
| label: '\ua7c9\u{1fda4}\u395c\u201c\u{1f8eb}\ueb1a', |
| layout: bindGroupLayout11, |
| entries: [{binding: 52, resource: textureView175}, {binding: 57, resource: textureView20}], |
| }); |
| let commandEncoder251 = device0.createCommandEncoder({}); |
| let textureView210 = texture213.createView({dimension: '2d-array', format: 'rgba32float', baseMipLevel: 0, mipLevelCount: 1}); |
| try { |
| computePassEncoder130.setBindGroup(1, bindGroup137); |
| } catch {} |
| try { |
| commandEncoder251.resolveQuerySet(querySet10, 40, 107, buffer138, 768); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer61, 632, new Int16Array(13921), 1260, 168); |
| } catch {} |
| let bindGroup143 = device0.createBindGroup({ |
| layout: bindGroupLayout6, |
| entries: [{binding: 11, resource: {buffer: buffer12, offset: 0, size: 676}}], |
| }); |
| let commandEncoder252 = device0.createCommandEncoder({}); |
| let querySet27 = device0.createQuerySet({type: 'occlusion', count: 418}); |
| let textureView211 = texture205.createView({dimension: '2d-array'}); |
| let texture221 = device0.createTexture({ |
| size: {width: 73, height: 1, depthOrArrayLayers: 10}, |
| mipLevelCount: 2, |
| sampleCount: 1, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView212 = texture85.createView({baseMipLevel: 0}); |
| let computePassEncoder204 = commandEncoder251.beginComputePass({label: '\u0cc0\u60ba\u4569\u3a26\ue02c'}); |
| let sampler148 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 41.28, |
| lodMaxClamp: 69.04, |
| maxAnisotropy: 10, |
| }); |
| try { |
| computePassEncoder141.setBindGroup(0, bindGroup54, new Uint32Array(44), 2, 0); |
| } catch {} |
| try { |
| computePassEncoder170.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder20.setBindGroup(0, bindGroup56); |
| } catch {} |
| try { |
| renderPassEncoder42.setIndexBuffer(buffer128, 'uint32', 596, 159); |
| } catch {} |
| try { |
| renderPassEncoder16.setVertexBuffer(7, buffer138, 1_900); |
| } catch {} |
| try { |
| commandEncoder252.copyBufferToTexture({ |
| /* bytesInLastRow: 32 widthInBlocks: 8 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 92 */ |
| offset: 92, |
| buffer: buffer34, |
| }, { |
| texture: texture158, |
| mipLevel: 0, |
| origin: {x: 16, y: 2, z: 0}, |
| aspect: 'all', |
| }, {width: 8, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| let buffer160 = device0.createBuffer({ |
| size: 10858, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let querySet28 = device0.createQuerySet({type: 'occlusion', count: 1918}); |
| try { |
| renderPassEncoder77.setViewport(45.477922443405014, 4.8284378107369585, 5.302597466803445, 0.022758491058333583, 0.1342871813699148, 0.3152727179990512); |
| } catch {} |
| try { |
| renderPassEncoder87.setVertexBuffer(0, buffer100, 424); |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let bindGroup144 = device0.createBindGroup({ |
| layout: bindGroupLayout2, |
| entries: [ |
| {binding: 42, resource: externalTexture3}, |
| {binding: 243, resource: textureView39}, |
| {binding: 999, resource: textureView81}, |
| {binding: 567, resource: textureView30}, |
| {binding: 421, resource: {buffer: buffer11, offset: 4864, size: 572}}, |
| {binding: 132, resource: textureView20}, |
| {binding: 94, resource: textureView60}, |
| {binding: 398, resource: textureView39}, |
| {binding: 35, resource: textureView191}, |
| ], |
| }); |
| let buffer161 = device0.createBuffer({size: 5165, usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE}); |
| let commandEncoder253 = device0.createCommandEncoder({}); |
| let texture222 = device0.createTexture({ |
| size: [73], |
| sampleCount: 1, |
| dimension: '1d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder205 = commandEncoder252.beginComputePass({}); |
| let sampler149 = device0.createSampler({ |
| label: '\u0850\u6c61\ub0e7', |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 15.60, |
| lodMaxClamp: 24.80, |
| compare: 'not-equal', |
| maxAnisotropy: 7, |
| }); |
| try { |
| computePassEncoder197.setBindGroup(0, bindGroup9, new Uint32Array(603), 22, 0); |
| } catch {} |
| try { |
| renderPassEncoder55.setStencilReference(516); |
| } catch {} |
| try { |
| buffer0.unmap(); |
| } catch {} |
| try { |
| commandEncoder253.clearBuffer(buffer100, 104, 420); |
| } catch {} |
| let commandEncoder254 = device0.createCommandEncoder({}); |
| let textureView213 = texture135.createView({ |
| label: '\u{1fdcf}\u04f3\u{1f810}\u0c39\ueb0c\u004f\u7bff\u0539\u5dc8', |
| mipLevelCount: 1, |
| baseArrayLayer: 2, |
| arrayLayerCount: 2, |
| }); |
| let computePassEncoder206 = commandEncoder253.beginComputePass({}); |
| let renderPassEncoder90 = commandEncoder254.beginRenderPass({ |
| label: '\u0df4\ufc94\ubf86\u{1fbf8}\u{1fd0e}\u3de8\u07c9', |
| colorAttachments: [{ |
| view: textureView99, |
| depthSlice: 3, |
| clearValue: { r: -345.3, g: 418.9, b: 967.9, a: 917.0, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| computePassEncoder205.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder87.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder73.setVertexBuffer(1, buffer106, 0, 1_996); |
| } catch {} |
| let arrayBuffer19 = buffer5.getMappedRange(1272, 668); |
| try { |
| if (!arrayBuffer11.detached) { new Uint8Array(arrayBuffer11).fill(0x55); }; |
| } catch {} |
| let commandEncoder255 = device0.createCommandEncoder({}); |
| let textureView214 = texture206.createView({}); |
| let renderPassEncoder91 = commandEncoder255.beginRenderPass({ |
| label: '\uf322\u{1fdf8}\u6d7b\u8266\u{1f778}\u0f66\u0685\u{1f775}', |
| colorAttachments: [{ |
| view: textureView202, |
| clearValue: { r: 735.6, g: -920.0, b: -693.5, a: -651.5, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet18, |
| }); |
| try { |
| computePassEncoder167.setBindGroup(2, bindGroup30, new Uint32Array(187), 122, 0); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| let commandEncoder256 = device0.createCommandEncoder({}); |
| let texture223 = device0.createTexture({ |
| size: [55, 5, 1], |
| mipLevelCount: 1, |
| sampleCount: 4, |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderPassEncoder92 = commandEncoder256.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView197, |
| clearValue: { r: -202.4, g: 392.0, b: 994.4, a: 687.6, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet6, |
| }); |
| let sampler150 = device0.createSampler({ |
| label: '\u{1fc53}\uef07', |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 10.53, |
| lodMaxClamp: 50.61, |
| maxAnisotropy: 12, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder94); computePassEncoder94.dispatchWorkgroupsIndirect(buffer64, 2_220); }; |
| } catch {} |
| try { |
| computePassEncoder204.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder87.draw(0, 280, 0, 870_858_773); |
| } catch {} |
| try { |
| renderPassEncoder87.drawIndirect(buffer82, 212); |
| } catch {} |
| let commandEncoder257 = device0.createCommandEncoder({}); |
| let computePassEncoder207 = commandEncoder257.beginComputePass({}); |
| try { |
| computePassEncoder198.setBindGroup(1, bindGroup82, new Uint32Array(7), 1, 0); |
| } catch {} |
| try { |
| computePassEncoder206.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder33.setBindGroup(0, bindGroup74, new Uint32Array(2540), 988, 0); |
| } catch {} |
| try { |
| renderPassEncoder87.end(); |
| } catch {} |
| try { |
| renderPassEncoder28.setPipeline(pipeline1); |
| } catch {} |
| try { |
| commandEncoder246.copyBufferToTexture({ |
| /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 2792 */ |
| offset: 2792, |
| bytesPerRow: 24576, |
| buffer: buffer106, |
| }, { |
| texture: texture93, |
| mipLevel: 0, |
| origin: {x: 11, y: 1, z: 0}, |
| aspect: 'all', |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder246.copyTextureToTexture({ |
| texture: texture179, |
| mipLevel: 0, |
| origin: {x: 3, y: 6, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture6, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 32, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder246.clearBuffer(buffer99); |
| } catch {} |
| let buffer162 = device0.createBuffer({size: 10772, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let commandEncoder258 = device0.createCommandEncoder({label: '\u425c\u02d6\u875b\u{1f640}\u0065\u{1f970}\u998d\u099f\ub37f'}); |
| let computePassEncoder208 = commandEncoder246.beginComputePass(); |
| try { |
| computePassEncoder86.setBindGroup(2, bindGroup93); |
| } catch {} |
| try { |
| renderPassEncoder70.setBindGroup(0, bindGroup100, new Uint32Array(1078), 316, 0); |
| } catch {} |
| try { |
| renderPassEncoder61.setIndexBuffer(buffer42, 'uint32', 300, 32); |
| } catch {} |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| try { |
| commandEncoder258.copyBufferToTexture({ |
| /* bytesInLastRow: 32 widthInBlocks: 4 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 544 */ |
| offset: 544, |
| bytesPerRow: 34304, |
| buffer: buffer43, |
| }, { |
| texture: texture159, |
| mipLevel: 0, |
| origin: {x: 20, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 4, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let promise20 = device0.queue.onSubmittedWorkDone(); |
| let textureView215 = texture218.createView({dimension: '2d'}); |
| let renderPassEncoder93 = commandEncoder258.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView98, |
| clearValue: { r: 427.0, g: -79.59, b: -365.0, a: 973.4, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| occlusionQuerySet: querySet23, |
| maxDrawCount: 498912885, |
| }); |
| let sampler151 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 27.56, |
| lodMaxClamp: 58.81, |
| compare: 'less-equal', |
| maxAnisotropy: 18, |
| }); |
| try { |
| computePassEncoder64.setBindGroup(0, bindGroup88, new Uint32Array(261), 17, 0); |
| } catch {} |
| try { |
| computePassEncoder207.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder64.setBindGroup(0, bindGroup34); |
| } catch {} |
| try { |
| renderPassEncoder27.executeBundles([renderBundle2, renderBundle19]); |
| } catch {} |
| try { |
| renderPassEncoder86.setVertexBuffer(1, buffer156, 628, 242); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture157, |
| mipLevel: 0, |
| origin: {x: 8, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(364).fill(235), /* required buffer size: 364 */ |
| {offset: 364, bytesPerRow: 148}, {width: 18, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture224 = device0.createTexture({ |
| size: {width: 55}, |
| dimension: '1d', |
| format: 'rg8snorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture225 = device0.createTexture({ |
| size: [440, 40, 312], |
| dimension: '3d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let sampler152 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 80.33, |
| lodMaxClamp: 80.49, |
| compare: 'equal', |
| }); |
| try { |
| renderPassEncoder34.setBlendConstant({ r: -66.70, g: -547.6, b: 1.412, a: -741.9, }); |
| } catch {} |
| try { |
| renderPassEncoder90.setIndexBuffer(buffer54, 'uint32', 1_252, 2_325); |
| } catch {} |
| let bindGroupLayout27 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 20, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rg32sint', access: 'read-only', viewDimension: '3d' }, |
| }, |
| ], |
| }); |
| let texture226 = device0.createTexture({ |
| size: [96, 1, 131], |
| dimension: '3d', |
| format: 'rg32sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder151.setBindGroup(0, bindGroup6, new Uint32Array(1991), 640, 0); |
| } catch {} |
| try { |
| renderPassEncoder74.executeBundles([renderBundle1, renderBundle19]); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 36, height: 1, depthOrArrayLayers: 177} |
| */ |
| { |
| source: imageBitmap3, |
| origin: { x: 1, y: 4 }, |
| flipY: false, |
| }, { |
| texture: texture216, |
| mipLevel: 0, |
| origin: {x: 4, y: 0, z: 24}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let commandEncoder259 = device0.createCommandEncoder({}); |
| let textureView216 = texture226.createView({baseMipLevel: 0}); |
| let renderPassEncoder94 = commandEncoder259.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView197, |
| clearValue: { r: -32.86, g: -450.1, b: 100.4, a: 94.97, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| computePassEncoder208.setPipeline(pipeline2); |
| } catch {} |
| let buffer163 = device0.createBuffer({ |
| size: 12047, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE, |
| }); |
| let textureView217 = texture79.createView({mipLevelCount: 1}); |
| try { |
| renderPassEncoder24.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder72.setVertexBuffer(5, buffer2, 0); |
| } catch {} |
| try { |
| computePassEncoder155.pushDebugGroup('\u{1fd58}'); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer14]); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer94, 600, new Int16Array(6805), 1645, 224); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 70, height: 72, depthOrArrayLayers: 25} |
| */ |
| { |
| source: videoFrame12, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture194, |
| mipLevel: 0, |
| origin: {x: 4, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture227 = device0.createTexture({ |
| size: {width: 147, height: 1, depthOrArrayLayers: 1}, |
| format: 'rgba32float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| let renderBundleEncoder22 = device0.createRenderBundleEncoder({colorFormats: ['rgba16uint'], stencilReadOnly: true}); |
| try { |
| computePassEncoder171.setBindGroup(0, bindGroup20); |
| } catch {} |
| try { |
| computePassEncoder198.setBindGroup(2, bindGroup24, new Uint32Array(2335), 775, 0); |
| } catch {} |
| try { |
| renderPassEncoder39.setBindGroup(3, bindGroup94); |
| } catch {} |
| try { |
| renderPassEncoder63.executeBundles([renderBundle6, renderBundle6]); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 36, height: 1, depthOrArrayLayers: 20} |
| */ |
| { |
| source: img2, |
| origin: { x: 6, y: 36 }, |
| flipY: true, |
| }, { |
| texture: texture174, |
| mipLevel: 0, |
| origin: {x: 13, y: 0, z: 2}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext4.unconfigure(); |
| } catch {} |
| try { |
| await promise19; |
| } catch {} |
| let commandEncoder260 = device0.createCommandEncoder(); |
| let textureView218 = texture143.createView({dimension: '1d'}); |
| try { |
| computePassEncoder67.setBindGroup(1, bindGroup142); |
| } catch {} |
| try { |
| computePassEncoder94.end(); |
| } catch {} |
| try { |
| renderPassEncoder86.setIndexBuffer(buffer27, 'uint16', 180, 46); |
| } catch {} |
| try { |
| renderPassEncoder67.setVertexBuffer(6, buffer148, 128); |
| } catch {} |
| try { |
| renderBundleEncoder22.setIndexBuffer(buffer133, 'uint16', 1_588, 96); |
| } catch {} |
| try { |
| renderBundleEncoder22.setVertexBuffer(7, buffer145, 324, 385); |
| } catch {} |
| try { |
| commandEncoder129.clearBuffer(buffer2, 2288, 156); |
| } catch {} |
| try { |
| computePassEncoder155.popDebugGroup(); |
| } catch {} |
| try { |
| commandEncoder129.insertDebugMarker('\u12e3'); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| let imageData30 = new ImageData(64, 148); |
| let texture228 = device0.createTexture({size: {width: 192}, dimension: '1d', format: 'rgba32float', usage: GPUTextureUsage.COPY_DST}); |
| try { |
| renderPassEncoder17.executeBundles([renderBundle17, renderBundle0, renderBundle0, renderBundle5]); |
| } catch {} |
| try { |
| renderPassEncoder54.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder22.setBindGroup(0, bindGroup48, new Uint32Array(1747), 170, 0); |
| } catch {} |
| try { |
| commandEncoder129.copyBufferToTexture({ |
| /* bytesInLastRow: 88 widthInBlocks: 11 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 1352 */ |
| offset: 1352, |
| rowsPerImage: 1357, |
| buffer: buffer66, |
| }, { |
| texture: texture159, |
| mipLevel: 0, |
| origin: {x: 4, y: 1, z: 0}, |
| aspect: 'all', |
| }, {width: 11, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer164 = device0.createBuffer({size: 10867, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let texture229 = device0.createTexture({ |
| size: [384, 1, 524], |
| mipLevelCount: 1, |
| dimension: '3d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let computePassEncoder209 = commandEncoder129.beginComputePass({}); |
| let renderBundle22 = renderBundleEncoder22.finish({label: '\u9e73\u{1fd11}\uedb4\u144b\u6c38\u57da\u0309\u39f3'}); |
| let sampler153 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'repeat', |
| minFilter: 'nearest', |
| lodMinClamp: 19.81, |
| lodMaxClamp: 78.15, |
| maxAnisotropy: 1, |
| }); |
| try { |
| computePassEncoder209.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder6.setBindGroup(2, bindGroup54); |
| } catch {} |
| try { |
| renderPassEncoder50.setBindGroup(3, bindGroup66, new Uint32Array(2349), 2, 0); |
| } catch {} |
| try { |
| renderPassEncoder35.beginOcclusionQuery(5); |
| } catch {} |
| try { |
| renderPassEncoder16.setVertexBuffer(6, buffer158, 240, 205); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture157, |
| mipLevel: 0, |
| origin: {x: 13, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(34).fill(190), /* required buffer size: 34 */ |
| {offset: 34}, {width: 7, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 280, height: 291, depthOrArrayLayers: 1} |
| */ |
| { |
| source: videoFrame14, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture161, |
| mipLevel: 0, |
| origin: {x: 98, y: 4, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.append(img2); |
| let textureView219 = texture109.createView({}); |
| try { |
| renderPassEncoder70.setBindGroup(0, bindGroup141, new Uint32Array(2922), 5, 0); |
| } catch {} |
| try { |
| renderPassEncoder67.setScissorRect(325, 146, 21, 23); |
| } catch {} |
| try { |
| commandEncoder260.copyBufferToTexture({ |
| /* bytesInLastRow: 36 widthInBlocks: 36 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 4356 */ |
| offset: 4356, |
| rowsPerImage: 1542, |
| buffer: buffer117, |
| }, { |
| texture: texture27, |
| mipLevel: 3, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'stencil-only', |
| }, {width: 36, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| } catch {} |
| document.body.append(img1); |
| let bindGroup145 = device0.createBindGroup({ |
| layout: bindGroupLayout7, |
| entries: [ |
| {binding: 53, resource: externalTexture10}, |
| {binding: 54, resource: {buffer: buffer161, offset: 0, size: 2296}}, |
| ], |
| }); |
| try { |
| renderPassEncoder5.setBindGroup(2, bindGroup107, new Uint32Array(6111), 635, 0); |
| } catch {} |
| try { |
| commandEncoder260.copyBufferToBuffer(buffer160, 28, buffer51, 1212, 144); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer100, 208, new Int16Array(10776), 317, 188); |
| } catch {} |
| let bindGroup146 = device0.createBindGroup({ |
| layout: bindGroupLayout26, |
| entries: [{binding: 49, resource: {buffer: buffer57, offset: 0, size: 372}}], |
| }); |
| let commandEncoder261 = device0.createCommandEncoder(); |
| let texture230 = device0.createTexture({ |
| label: '\u2a74\u07b6\u0963\ud6d2\u07bf\u021d\uea53\u47f1', |
| size: [440, 40, 8], |
| format: 'eac-rg11unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['eac-rg11unorm'], |
| }); |
| let textureView220 = texture143.createView({mipLevelCount: 1}); |
| let computePassEncoder210 = commandEncoder260.beginComputePass({}); |
| try { |
| computePassEncoder190.setBindGroup(0, bindGroup64); |
| } catch {} |
| try { |
| computePassEncoder210.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder35.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder52.setIndexBuffer(buffer143, 'uint32', 2_400, 126); |
| } catch {} |
| try { |
| await promise20; |
| } catch {} |
| let shaderModule17 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| requires packed_4x8_integer_dot_product; |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| @group(0) @binding(35) var st30: texture_storage_1d<r32sint, read_write>; |
| |
| @group(0) @binding(42) var et1: texture_external; |
| |
| @group(0) @binding(94) var tex6: texture_2d_array<f32>; |
| |
| @group(0) @binding(132) var tex7: texture_2d<i32>; |
| |
| @group(0) @binding(243) var tex8: texture_depth_2d; |
| |
| @group(0) @binding(398) var tex9: texture_depth_2d; |
| |
| @group(0) @binding(421) var<storage, read> buffer165: u32; |
| |
| @group(0) @binding(999) var tex10: texture_2d_array<i32>; |
| |
| struct T0 { |
| @align(4) @size(4) f0: array<f16, 1>, |
| } |
| |
| struct FragmentOutput15 { |
| @location(0) @interpolate(flat, sample) f0: vec4u, |
| } |
| |
| alias vec3b = vec3<bool>; |
| |
| fn fn0(a0: ptr<uniform, vec2u>) -> u32 { |
| var out: u32; |
| let vf356: vec2u = textureDimensions(tex7, bitcast<i32>((*a0)[u32(unconst_u32(301))])); |
| var vf357: vec4f = textureLoad(et1, vec2u(unconst_u32(207), unconst_u32(107))); |
| vf357 += vec4f(bitcast<f32>(textureNumLevels(tex7))); |
| var vf358: u32 = vf356[u32(unconst_u32(770))]; |
| var vf359: vec2u = vf356; |
| let ptr140: ptr<uniform, vec2u> = &(*a0); |
| let vf360: u32 = vf359[u32(unconst_u32(132))]; |
| return out; |
| } |
| |
| fn fn1() -> mat3x2h { |
| var out: mat3x2h; |
| out -= mat3x2h(vec2h(textureDimensions(tex7)), vec2h(textureDimensions(tex7)), vec2h(textureDimensions(tex7))); |
| out = mat3x2h(vec2h(max(vec2i(unconst_i32(144), unconst_i32(35)), vec2i(unconst_i32(53), unconst_i32(308)))), vec2h(max(vec2i(unconst_i32(144), unconst_i32(35)), vec2i(unconst_i32(53), unconst_i32(308)))), vec2h(max(vec2i(unconst_i32(144), unconst_i32(35)), vec2i(unconst_i32(53), unconst_i32(308))))); |
| out -= mat3x2h(cosh(vec3h(unconst_f16(574.0), unconst_f16(10931.5), unconst_f16(16336.9))).rg, cosh(vec3h(unconst_f16(574.0), unconst_f16(10931.5), unconst_f16(16336.9))).zz, cosh(vec3h(unconst_f16(574.0), unconst_f16(10931.5), unconst_f16(16336.9))).gr); |
| out += mat3x2h(vec2h(unpack2x16snorm(u32(unconst_u32(224)))), vec2h(unpack2x16snorm(u32(unconst_u32(224)))), vec2h(unpack2x16snorm(u32(unconst_u32(224))))); |
| var vf361: vec3h = cosh(vec3h(unconst_f16(-4475.7), unconst_f16(4574.3), unconst_f16(7283.6))); |
| vf361 *= refract(vec3h(unconst_f16(5250.2), unconst_f16(3684.9), unconst_f16(17795.8)), vec3h(unconst_f16(362.2), unconst_f16(21479.3), unconst_f16(3020.4)), f16(unconst_f16(28978.6))); |
| var vf362: vec2u = textureDimensions(tex7); |
| var vf363: u32 = firstLeadingBit(u32(unconst_u32(39))); |
| vf363 <<= pack4xI8Clamp(textureLoad(tex7, vec2i(unconst_i32(40), unconst_i32(171)), i32(unconst_i32(176)))); |
| var vf364: vec2i = max(vec2i(unconst_i32(305), unconst_i32(355)), vec2i(unconst_i32(55), unconst_i32(-35))); |
| return out; |
| } |
| |
| fn fn2() -> array<T0, 36> { |
| var out: array<T0, 36>; |
| var vf365 = fn1(); |
| var vf366: u32 = dot4U8Packed(u32(unconst_u32(82)), u32(unconst_u32(163))); |
| return out; |
| } |
| |
| var<workgroup> vw61: FragmentOutput15; |
| |
| var<workgroup> vw62: array<mat3x2h, 1>; |
| |
| @fragment |
| fn fragment16(@builtin(position) a0: vec4f) -> FragmentOutput15 { |
| var out: FragmentOutput15; |
| let ptr141: ptr<storage, u32, read> = &(*&buffer165); |
| var vf367: u32 = dot4U8Packed(u32(unconst_u32(31)), u32(unconst_u32(15))); |
| vf367 >>= u32(textureLoad(et1, vec2u(unconst_u32(34), unconst_u32(150))).a); |
| let vf368: f32 = a0[u32(unconst_u32(260))]; |
| var vf369: vec2u = textureDimensions(et1); |
| out.f0 += unpack4xU8(u32(a0[u32(unconst_u32(98))])); |
| vf367 &= u32(a0[u32(unconst_u32(141))]); |
| vf367 += (*ptr141); |
| let ptr142: ptr<storage, u32, read> = &buffer165; |
| discard; |
| var vf370: f32 = vf368; |
| var vf371: vec4h = saturate(vec4h(unconst_f16(30699.5), unconst_f16(7565.8), unconst_f16(2886.9), unconst_f16(14225.1))); |
| vf369 ^= bitcast<vec2u>(textureLoad(et1, vec2u((*ptr141))).wz); |
| return out; |
| } |
| |
| @compute @workgroup_size(1, 2, 1) |
| fn compute17() { |
| vw62[u32(unconst_u32(188))] = mat3x2h(f16((*&vw61).f0[u32(unconst_u32(76))]), f16((*&vw61).f0[u32(unconst_u32(76))]), f16((*&vw61).f0[u32(unconst_u32(76))]), f16((*&vw61).f0[u32(unconst_u32(76))]), f16((*&vw61).f0[u32(unconst_u32(76))]), f16((*&vw61).f0[u32(unconst_u32(76))])); |
| var vf372 = fn2(); |
| vw61 = FragmentOutput15(vec4u(textureNumLevels(tex10))); |
| vf372[u32(unconst_u32(168))] = T0(array<f16, 1>(vec4h(vw61.f0).x)); |
| var vf373 = fn1(); |
| vf373 -= mat3x2h(vec2h(transpose(mat2x4f(unconst_f32(0.05872), unconst_f32(0.1892), unconst_f32(0.1885), unconst_f32(0.2020), unconst_f32(0.1788), unconst_f32(0.1463), unconst_f32(0.03870), unconst_f32(0.2350)))[unconst_i32(3)]), vec2h(transpose(mat2x4f(unconst_f32(0.05872), unconst_f32(0.1892), unconst_f32(0.1885), unconst_f32(0.2020), unconst_f32(0.1788), unconst_f32(0.1463), unconst_f32(0.03870), unconst_f32(0.2350)))[unconst_i32(1)]), vec2h(transpose(mat2x4f(unconst_f32(0.05872), unconst_f32(0.1892), unconst_f32(0.1885), unconst_f32(0.2020), unconst_f32(0.1788), unconst_f32(0.1463), unconst_f32(0.03870), unconst_f32(0.2350)))[unconst_i32(1)])); |
| vf372[u32(unconst_u32(291))] = vf372[35]; |
| vw61 = FragmentOutput15(vec4u(u32(vf372[u32(unconst_u32(8))].f0[u32(unconst_u32(81))]))); |
| vf372[bitcast<u32>(vw62[0][u32(unconst_u32(33))])] = T0(array<f16, 1>(vf373[u32(unconst_u32(104))][1])); |
| let vf374: vec3f = exp(vec3f(unconst_f32(0.06140), unconst_f32(0.06730), unconst_f32(0.07548))); |
| let ptr143: ptr<function, T0> = &vf372[35]; |
| vf373 = mat3x2h(f16(sqrt(f32(unconst_f32(0.6988)))), f16(sqrt(f32(unconst_f32(0.6988)))), f16(sqrt(f32(unconst_f32(0.6988)))), f16(sqrt(f32(unconst_f32(0.6988)))), f16(sqrt(f32(unconst_f32(0.6988)))), f16(sqrt(f32(unconst_f32(0.6988))))); |
| fn2(); |
| var vf375: u32 = pack4xU8(vec4u(unconst_u32(23), unconst_u32(227), unconst_u32(132), unconst_u32(10))); |
| var vf376 = fn1(); |
| let vf377: u32 = textureNumLevels(tex8); |
| let ptr144: ptr<workgroup, FragmentOutput15> = &(*&vw61); |
| var vf378: vec2u = textureDimensions(tex7); |
| vw61.f0 = vf378.xxyx; |
| let vf379: vec3h = tan(vec3h(unconst_f16(4209.6), unconst_f16(2315.8), unconst_f16(3488.2))); |
| let vf380: vec4i = textureLoad(tex10, vec2i(unconst_i32(746), unconst_i32(804)), i32(unconst_i32(163)), i32(unconst_i32(451))); |
| vf372[u32(unconst_u32(123))] = T0(array<f16, 1>(vf372[35].f0[0])); |
| }`, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| let bindGroup147 = device0.createBindGroup({layout: bindGroupLayout27, entries: [{binding: 20, resource: textureView216}]}); |
| let buffer166 = device0.createBuffer({ |
| label: '\u4ebc\u{1f836}\u7034\u{1fce2}\u4ca4\u{1ffd0}', |
| size: 4657, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| let computePassEncoder211 = commandEncoder261.beginComputePass(); |
| let sampler154 = device0.createSampler({ |
| label: '\u{1ff4d}\u7603\u{1f64d}\ue2ae\u9e74\u{1f6b6}\uf56a', |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 38.28, |
| lodMaxClamp: 90.42, |
| maxAnisotropy: 15, |
| }); |
| try { |
| computePassEncoder64.setBindGroup(2, bindGroup131); |
| } catch {} |
| try { |
| computePassEncoder168.setBindGroup(3, bindGroup81, new Uint32Array(1452), 36, 0); |
| } catch {} |
| try { |
| computePassEncoder211.setPipeline(pipeline2); |
| } catch {} |
| try { |
| computePassEncoder25.setBindGroup(3, bindGroup10, new Uint32Array(5655), 24, 0); |
| } catch {} |
| try { |
| renderPassEncoder65.setIndexBuffer(buffer85, 'uint16', 2_990, 5_608); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 70, height: 72, depthOrArrayLayers: 25} |
| */ |
| { |
| source: imageData11, |
| origin: { x: 10, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture194, |
| mipLevel: 0, |
| origin: {x: 29, y: 13, z: 2}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 10, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture231 = device0.createTexture({size: {width: 220}, dimension: '1d', format: 'rgba16uint', usage: GPUTextureUsage.TEXTURE_BINDING}); |
| try { |
| renderPassEncoder36.setBindGroup(2, bindGroup135, new Uint32Array(551), 5, 0); |
| } catch {} |
| try { |
| renderPassEncoder62.executeBundles([renderBundle21]); |
| } catch {} |
| try { |
| renderPassEncoder10.setViewport(65.79311583817953, 39.42025707126985, 1.2723530110788328, 6.947091648952119, 0.073414566718637, 0.4081260361017597); |
| } catch {} |
| try { |
| renderPassEncoder34.setIndexBuffer(buffer10, 'uint16', 454, 2_208); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({device: device0, format: 'rgba16float', usage: GPUTextureUsage.TEXTURE_BINDING, colorSpace: 'srgb'}); |
| } catch {} |
| let promise21 = device0.queue.onSubmittedWorkDone(); |
| try { |
| gpuCanvasContext0.unconfigure(); |
| } catch {} |
| try { |
| await promise21; |
| } catch {} |
| let commandEncoder262 = device0.createCommandEncoder({label: '\u4162\uf29c\u0380\ue5bb\u004f\u0bc6\ua5cb\u{1fb00}\u9b5a\u84b5'}); |
| let textureView221 = texture142.createView({format: 'rgba16sint', mipLevelCount: 1}); |
| try { |
| renderPassEncoder39.setBindGroup(2, bindGroup55, new Uint32Array(529), 4, 0); |
| } catch {} |
| try { |
| buffer89.unmap(); |
| } catch {} |
| let commandEncoder263 = device0.createCommandEncoder({}); |
| let computePassEncoder212 = commandEncoder262.beginComputePass({}); |
| let renderPassEncoder95 = commandEncoder263.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView197, |
| clearValue: { r: -780.2, g: -174.2, b: -320.2, a: 144.6, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet21, |
| }); |
| let renderBundleEncoder23 = device0.createRenderBundleEncoder({colorFormats: ['rgba16uint']}); |
| try { |
| computePassEncoder57.setBindGroup(0, bindGroup41, []); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder48); computePassEncoder48.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder189); computePassEncoder189.dispatchWorkgroupsIndirect(buffer120, 408); }; |
| } catch {} |
| try { |
| computePassEncoder212.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder43.end(); |
| } catch {} |
| try { |
| renderPassEncoder42.setIndexBuffer(buffer83, 'uint16', 1_438, 1_706); |
| } catch {} |
| try { |
| renderPassEncoder79.setVertexBuffer(6, buffer130); |
| } catch {} |
| try { |
| buffer51.unmap(); |
| } catch {} |
| let textureView222 = texture149.createView({label: '\ufd58\u{1f891}\u0e3f\u9643', aspect: 'depth-only'}); |
| let computePassEncoder213 = commandEncoder83.beginComputePass({label: '\ub321\u{1fa20}\u{1fe67}'}); |
| try { |
| computePassEncoder125.setBindGroup(0, bindGroup143, new Uint32Array(1173), 81, 0); |
| } catch {} |
| try { |
| renderPassEncoder26.setScissorRect(23, 19, 13, 13); |
| } catch {} |
| try { |
| renderPassEncoder18.setIndexBuffer(buffer112, 'uint32', 1_772, 842); |
| } catch {} |
| try { |
| renderPassEncoder37.setVertexBuffer(4, buffer140); |
| } catch {} |
| try { |
| renderBundleEncoder23.setBindGroup(1, bindGroup98, new Uint32Array(314), 9, 0); |
| } catch {} |
| try { |
| renderBundleEncoder23.setIndexBuffer(buffer116, 'uint16', 1_946, 573); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture38, |
| mipLevel: 0, |
| origin: {x: 49, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(98).fill(120), /* required buffer size: 98 */ |
| {offset: 98}, {width: 51, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let imageData31 = new ImageData(16, 80); |
| let bindGroup148 = device0.createBindGroup({ |
| layout: bindGroupLayout18, |
| entries: [{binding: 116, resource: sampler44}, {binding: 204, resource: externalTexture11}], |
| }); |
| try { |
| computePassEncoder89.setBindGroup(1, bindGroup85); |
| } catch {} |
| try { |
| computePassEncoder213.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderBundleEncoder23.setBindGroup(1, bindGroup8); |
| } catch {} |
| try { |
| renderBundleEncoder23.setBindGroup(2, bindGroup142, new Uint32Array(2660), 50, 0); |
| } catch {} |
| let commandEncoder264 = device0.createCommandEncoder({}); |
| let textureView223 = texture224.createView({}); |
| let texture232 = device0.createTexture({ |
| size: {width: 96}, |
| dimension: '1d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let renderPassEncoder96 = commandEncoder264.beginRenderPass({ |
| label: '\u9cb1\u2943\u{1fdb5}\u0cf7\uc50a\u0e70\u{1ffd4}\u8570', |
| colorAttachments: [{ |
| view: textureView73, |
| clearValue: { r: -534.0, g: -544.0, b: -458.7, a: -307.6, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| }); |
| try { |
| renderBundleEncoder23.setBindGroup(2, bindGroup129, new Uint32Array(278), 129, 0); |
| } catch {} |
| try { |
| renderBundleEncoder23.setVertexBuffer(2, undefined); |
| } catch {} |
| let bindGroup149 = device0.createBindGroup({ |
| label: '\ue863\u08ce\u03b9\ua19a\u{1f701}\uc90c\u{1fe4f}\u7404', |
| layout: bindGroupLayout10, |
| entries: [{binding: 5, resource: sampler134}], |
| }); |
| let commandEncoder265 = device0.createCommandEncoder({}); |
| let computePassEncoder214 = commandEncoder265.beginComputePass({}); |
| try { |
| computePassEncoder197.setBindGroup(2, bindGroup88, new Uint32Array(335), 85, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder85); computePassEncoder85.dispatchWorkgroupsIndirect(buffer25, 164); }; |
| } catch {} |
| try { |
| renderPassEncoder52.setBindGroup(2, bindGroup125, new Uint32Array(976), 162, 0); |
| } catch {} |
| try { |
| renderPassEncoder80.setScissorRect(59, 26, 66, 125); |
| } catch {} |
| try { |
| renderBundleEncoder23.setBindGroup(1, bindGroup76, new Uint32Array(387), 89, 0); |
| } catch {} |
| let commandEncoder266 = device0.createCommandEncoder(); |
| let texture233 = device0.createTexture({size: [110, 10, 40], format: 'rgba16sint', usage: GPUTextureUsage.TEXTURE_BINDING}); |
| let textureView224 = texture57.createView({dimension: '2d-array', format: 'rgba16sint', mipLevelCount: 1}); |
| try { |
| computePassEncoder62.setBindGroup(3, bindGroup64, new Uint32Array(3513), 1_373, 0); |
| } catch {} |
| try { |
| computePassEncoder214.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder62.setBindGroup(0, bindGroup146, new Uint32Array(55), 2, 0); |
| } catch {} |
| try { |
| renderPassEncoder0.executeBundles([renderBundle17, renderBundle3, renderBundle17, renderBundle17, renderBundle16]); |
| } catch {} |
| try { |
| renderPassEncoder77.setIndexBuffer(buffer131, 'uint16', 2_730, 1_727); |
| } catch {} |
| try { |
| renderPassEncoder52.setVertexBuffer(7, buffer116, 0, 76); |
| } catch {} |
| try { |
| commandEncoder266.copyBufferToTexture({ |
| /* bytesInLastRow: 16 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 352 */ |
| offset: 352, |
| buffer: buffer17, |
| }, { |
| texture: texture213, |
| mipLevel: 0, |
| origin: {x: 30, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup150 = device0.createBindGroup({ |
| layout: bindGroupLayout2, |
| entries: [ |
| {binding: 243, resource: textureView172}, |
| {binding: 999, resource: textureView21}, |
| {binding: 567, resource: textureView72}, |
| {binding: 94, resource: textureView1}, |
| {binding: 35, resource: textureView10}, |
| {binding: 398, resource: textureView172}, |
| {binding: 132, resource: textureView20}, |
| {binding: 421, resource: {buffer: buffer37, offset: 768, size: 72}}, |
| {binding: 42, resource: externalTexture20}, |
| ], |
| }); |
| let texture234 = device0.createTexture({ |
| size: [560, 582, 58], |
| mipLevelCount: 3, |
| dimension: '3d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| let textureView225 = texture221.createView({ |
| label: '\u0bb6\u5d13\u{1fbcd}\u59b4\u{1ff06}\u0582\u{1fcdb}\ud2ab\ufb40\u{1fab2}\u0512', |
| dimension: '2d', |
| mipLevelCount: 1, |
| baseArrayLayer: 2, |
| }); |
| let computePassEncoder215 = commandEncoder266.beginComputePass({label: '\ud1cf\u4edb\udda9\u806a\u5ce0\u{1fee2}'}); |
| let externalTexture22 = device0.importExternalTexture({label: '\u0b68\u{1f6e7}', source: videoFrame18}); |
| try { |
| computePassEncoder27.setBindGroup(3, bindGroup31, new Uint32Array(1974), 219, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder189); computePassEncoder189.dispatchWorkgroupsIndirect(buffer111, 240); }; |
| } catch {} |
| try { |
| computePassEncoder75.end(); |
| } catch {} |
| try { |
| renderPassEncoder24.setBindGroup(0, bindGroup99); |
| } catch {} |
| try { |
| renderPassEncoder65.setVertexBuffer(1, buffer24, 4); |
| } catch {} |
| try { |
| buffer8.unmap(); |
| } catch {} |
| try { |
| commandEncoder73.copyTextureToTexture({ |
| texture: texture101, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture6, |
| mipLevel: 0, |
| origin: {x: 4, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer51, 2508, new BigUint64Array(4243), 115, 20); |
| } catch {} |
| let commandEncoder267 = device0.createCommandEncoder({label: '\u0eca\u0a67\uac58\u4c6b\uffc7\u{1fdbb}\uef13'}); |
| let texture235 = device0.createTexture({ |
| label: '\u08ba\u0beb\u{1fc26}\u{1fa57}\u8470', |
| size: [384, 1, 1], |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let renderPassEncoder97 = commandEncoder73.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView79, |
| clearValue: { r: 169.1, g: -688.6, b: -148.0, a: -172.3, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| maxDrawCount: 28288112, |
| }); |
| try { |
| computePassEncoder159.setBindGroup(1, bindGroup87); |
| } catch {} |
| try { |
| computePassEncoder121.setBindGroup(1, bindGroup51, new Uint32Array(276), 106, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder82); computePassEncoder82.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder215.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder45.beginOcclusionQuery(14); |
| } catch {} |
| try { |
| renderPassEncoder19.setIndexBuffer(buffer42, 'uint32', 468, 150); |
| } catch {} |
| try { |
| renderBundleEncoder23.setBindGroup(3, bindGroup82); |
| } catch {} |
| try { |
| renderBundleEncoder23.setVertexBuffer(3, buffer15, 0, 41); |
| } catch {} |
| try { |
| buffer128.unmap(); |
| } catch {} |
| try { |
| commandEncoder267.copyBufferToTexture({ |
| /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1760 */ |
| offset: 1760, |
| bytesPerRow: 5632, |
| buffer: buffer17, |
| }, { |
| texture: texture93, |
| mipLevel: 0, |
| origin: {x: 3, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let textureView226 = texture226.createView({}); |
| let computePassEncoder216 = commandEncoder267.beginComputePass({}); |
| try { |
| renderPassEncoder25.setBindGroup(3, bindGroup135, []); |
| } catch {} |
| try { |
| renderPassEncoder23.setBindGroup(2, bindGroup117, new Uint32Array(998), 249, 0); |
| } catch {} |
| await gc(); |
| let bindGroup151 = device0.createBindGroup({layout: bindGroupLayout19, entries: [{binding: 361, resource: {buffer: buffer12, offset: 0}}]}); |
| let buffer167 = device0.createBuffer({ |
| size: 974, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let renderBundle23 = renderBundleEncoder23.finish({}); |
| try { |
| computePassEncoder114.setBindGroup(1, bindGroup47, []); |
| } catch {} |
| try { |
| computePassEncoder88.setBindGroup(2, bindGroup142, new Uint32Array(506), 12, 0); |
| } catch {} |
| try { |
| computePassEncoder216.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder92.setBindGroup(2, bindGroup88); |
| } catch {} |
| try { |
| renderPassEncoder55.executeBundles([renderBundle22, renderBundle22]); |
| } catch {} |
| try { |
| renderPassEncoder74.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder62.insertDebugMarker('\u0ec0'); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let textureView227 = texture15.createView({}); |
| try { |
| renderPassEncoder35.setIndexBuffer(buffer70, 'uint32', 2_352, 316); |
| } catch {} |
| let canvas4 = document.createElement('canvas'); |
| let bindGroup152 = device0.createBindGroup({ |
| layout: bindGroupLayout21, |
| entries: [ |
| {binding: 125, resource: externalTexture0}, |
| {binding: 190, resource: textureView211}, |
| {binding: 606, resource: sampler87}, |
| {binding: 222, resource: {buffer: buffer64, offset: 0}}, |
| ], |
| }); |
| try { |
| buffer50.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer14, 640, new Int16Array(6796), 15, 576); |
| } catch {} |
| document.body.append(img3); |
| let commandEncoder268 = device0.createCommandEncoder({label: '\u525e\u002c\u01a1\u6689\u{1f84b}\u0b35\u0aa3'}); |
| let renderPassEncoder98 = commandEncoder268.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView4, |
| depthSlice: 66, |
| clearValue: { r: -704.2, g: -261.2, b: -313.1, a: 236.1, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| }); |
| let sampler155 = device0.createSampler({ |
| label: '\u{1f841}\u1f4c\uf188\u0717\uf881\u7451\u42ec\u9a3d\u1756\u961b', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'nearest', |
| lodMinClamp: 94.10, |
| lodMaxClamp: 96.11, |
| }); |
| try { |
| renderPassEncoder45.endOcclusionQuery(); |
| } catch {} |
| try { |
| await buffer74.mapAsync(GPUMapMode.READ, 208, 152); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture24, |
| mipLevel: 0, |
| origin: {x: 21, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(141).fill(79), /* required buffer size: 141 */ |
| {offset: 141}, {width: 43, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup153 = device0.createBindGroup({layout: bindGroupLayout20, entries: [{binding: 152, resource: textureView57}]}); |
| let commandEncoder269 = device0.createCommandEncoder(); |
| let computePassEncoder217 = commandEncoder269.beginComputePass({}); |
| try { |
| computePassEncoder177.setBindGroup(0, bindGroup114, new Uint32Array(1848), 781, 0); |
| } catch {} |
| try { |
| computePassEncoder217.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder88.setBindGroup(2, bindGroup10); |
| } catch {} |
| try { |
| renderPassEncoder96.executeBundles([renderBundle21]); |
| } catch {} |
| try { |
| renderPassEncoder22.setVertexBuffer(6, buffer65, 80, 92); |
| } catch {} |
| let bindGroupLayout28 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 178, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '1d', sampleType: 'sint', multisampled: false }, |
| }, |
| { |
| binding: 39, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let bindGroup154 = device0.createBindGroup({ |
| layout: bindGroupLayout14, |
| entries: [ |
| {binding: 57, resource: textureView172}, |
| {binding: 462, resource: {buffer: buffer107, offset: 256, size: 1692}}, |
| {binding: 51, resource: {buffer: buffer149, offset: 7424, size: 23064}}, |
| {binding: 67, resource: textureView10}, |
| {binding: 9, resource: textureView140}, |
| {binding: 172, resource: textureView110}, |
| {binding: 264, resource: sampler6}, |
| {binding: 153, resource: {buffer: buffer26, offset: 0, size: 650}}, |
| {binding: 8, resource: textureView109}, |
| ], |
| }); |
| let commandEncoder270 = device0.createCommandEncoder(); |
| let textureView228 = texture16.createView({dimension: '2d', aspect: 'depth-only', mipLevelCount: 1}); |
| try { |
| renderPassEncoder73.setBindGroup(0, bindGroup100); |
| } catch {} |
| try { |
| renderPassEncoder74.setBindGroup(1, bindGroup41, new Uint32Array(2023), 118, 0); |
| } catch {} |
| try { |
| renderPassEncoder93.setVertexBuffer(7, buffer103); |
| } catch {} |
| try { |
| commandEncoder270.copyBufferToTexture({ |
| /* bytesInLastRow: 1896 widthInBlocks: 237 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 1552 */ |
| offset: 1552, |
| buffer: buffer39, |
| }, { |
| texture: texture48, |
| mipLevel: 0, |
| origin: {x: 3, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 237, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder270.copyTextureToBuffer({ |
| texture: texture219, |
| mipLevel: 0, |
| origin: {x: 37, y: 1, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 88 widthInBlocks: 22 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 1560 */ |
| offset: 1560, |
| bytesPerRow: 5120, |
| rowsPerImage: 1113, |
| buffer: buffer96, |
| }, {width: 22, height: 3, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup155 = device0.createBindGroup({ |
| layout: bindGroupLayout26, |
| entries: [{binding: 49, resource: {buffer: buffer101, offset: 3584, size: 3513}}], |
| }); |
| let computePassEncoder218 = commandEncoder270.beginComputePass({label: '\u0dcd\u{1f71a}\ufc88\u0134\ubffd\u{1fb43}\u0268\udeda\ua3fa\u6060\u{1f97a}'}); |
| try { |
| computePassEncoder218.setPipeline(pipeline3); |
| } catch {} |
| try { |
| gpuCanvasContext2.unconfigure(); |
| } catch {} |
| let bindGroupLayout29 = device0.createBindGroupLayout({ |
| label: '\u079b\u18b3\u01f3\ud65d\u0427\ue20f\u0f2e\u66de\u{1ff72}', |
| entries: [ |
| { |
| binding: 131, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let texture236 = device0.createTexture({ |
| size: {width: 384}, |
| dimension: '1d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder3.setBindGroup(0, bindGroup5, new Uint32Array(266), 2, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 96, height: 1, depthOrArrayLayers: 131} |
| */ |
| { |
| source: imageBitmap0, |
| origin: { x: 2, y: 6 }, |
| flipY: false, |
| }, { |
| texture: texture18, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 50}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| await gc(); |
| let sampler156 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'mirror-repeat', |
| minFilter: 'nearest', |
| lodMaxClamp: 86.68, |
| }); |
| let textureView229 = texture173.createView({label: '\u{1f831}\u0ba9\u18c3\u2c8a\ue17f\u{1fc7b}\u{1fda4}\u{1feb6}\u3590\u{1f87e}'}); |
| let textureView230 = texture46.createView({aspect: 'stencil-only'}); |
| let bindGroupLayout30 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 86, |
| visibility: GPUShaderStage.COMPUTE, |
| buffer: { type: 'read-only-storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 517, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba8uint', access: 'write-only', viewDimension: '2d-array' }, |
| }, |
| { |
| binding: 566, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| externalTexture: {}, |
| }, |
| { |
| binding: 577, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba32float', access: 'write-only', viewDimension: '2d-array' }, |
| }, |
| ], |
| }); |
| let texture237 = device0.createTexture({ |
| size: {width: 55, height: 5, depthOrArrayLayers: 32}, |
| dimension: '2d', |
| format: 'rgba8uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture238 = gpuCanvasContext3.getCurrentTexture(); |
| let textureView231 = texture234.createView({mipLevelCount: 1}); |
| try { |
| computePassEncoder158.setBindGroup(0, bindGroup145, []); |
| } catch {} |
| try { |
| renderPassEncoder70.setVertexBuffer(0, buffer62, 8_984); |
| } catch {} |
| let imageData32 = new ImageData(112, 28); |
| let textureView232 = texture237.createView({baseArrayLayer: 5, arrayLayerCount: 2}); |
| try { |
| computePassEncoder120.setBindGroup(0, bindGroup9, []); |
| } catch {} |
| try { |
| computePassEncoder80.setBindGroup(1, bindGroup20, new Uint32Array(2764), 399, 0); |
| } catch {} |
| try { |
| computePassEncoder147.pushDebugGroup('\u3461'); |
| } catch {} |
| let texture239 = device0.createTexture({ |
| size: [70], |
| dimension: '1d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| renderPassEncoder95.setIndexBuffer(buffer21, 'uint32', 1_628, 1_850); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 36, height: 1, depthOrArrayLayers: 177} |
| */ |
| { |
| source: img1, |
| origin: { x: 1, y: 15 }, |
| flipY: true, |
| }, { |
| texture: texture216, |
| mipLevel: 0, |
| origin: {x: 5, y: 0, z: 94}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 6, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup156 = device0.createBindGroup({layout: bindGroupLayout16, entries: [{binding: 0, resource: {buffer: buffer107, offset: 1280}}]}); |
| let buffer168 = device0.createBuffer({ |
| label: '\u702f\u08d0\u5542\uc0c8\u7570', |
| size: 6907, |
| usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE, |
| mappedAtCreation: false, |
| }); |
| try { |
| renderPassEncoder77.setPipeline(pipeline1); |
| } catch {} |
| let bindGroupLayout31 = device0.createBindGroupLayout({ |
| label: '\ue38d\u07de\u015e\u{1f6b7}\u0055\u0815', |
| entries: [ |
| { |
| binding: 362, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false }, |
| }, |
| ], |
| }); |
| let bindGroup157 = device0.createBindGroup({ |
| layout: bindGroupLayout4, |
| entries: [{binding: 511, resource: {buffer: buffer53, offset: 512, size: 1132}}], |
| }); |
| let texture240 = device0.createTexture({ |
| size: {width: 192, height: 1, depthOrArrayLayers: 262}, |
| dimension: '3d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| computePassEncoder120.setBindGroup(2, bindGroup93); |
| } catch {} |
| try { |
| computePassEncoder205.setBindGroup(3, bindGroup42, new Uint32Array(594), 71, 0); |
| } catch {} |
| try { |
| renderPassEncoder30.setBindGroup(2, bindGroup135); |
| } catch {} |
| try { |
| renderPassEncoder83.setVertexBuffer(0, buffer141, 2_188, 329); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture194, |
| mipLevel: 0, |
| origin: {x: 6, y: 40, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(240_386).fill(41), /* required buffer size: 240_386 */ |
| {offset: 6, bytesPerRow: 451, rowsPerImage: 74}, {width: 28, height: 15, depthOrArrayLayers: 8}); |
| } catch {} |
| try { |
| renderPassEncoder84.setIndexBuffer(buffer121, 'uint16', 32, 22); |
| } catch {} |
| try { |
| buffer163.unmap(); |
| } catch {} |
| let textureView233 = texture237.createView({format: 'rgba8uint', baseMipLevel: 0, baseArrayLayer: 2, arrayLayerCount: 5}); |
| try { |
| computePassEncoder116.end(); |
| } catch {} |
| try { |
| renderPassEncoder47.setBindGroup(2, bindGroup51, new Uint32Array(5063), 80, 0); |
| } catch {} |
| try { |
| computePassEncoder157.insertDebugMarker('\u5b1f'); |
| } catch {} |
| let commandBuffer15 = commandEncoder156.finish(); |
| try { |
| computePassEncoder177.setBindGroup(0, bindGroup48, new Uint32Array(998), 89, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder85); computePassEncoder85.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder38.setBindGroup(3, bindGroup55, new Uint32Array(1305), 236, 0); |
| } catch {} |
| try { |
| renderPassEncoder73.executeBundles([renderBundle22, renderBundle22]); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer15]); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let commandEncoder271 = device0.createCommandEncoder({}); |
| let textureView234 = texture150.createView({mipLevelCount: 1}); |
| try { |
| computePassEncoder97.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder78.setVertexBuffer(7, buffer56); |
| } catch {} |
| try { |
| commandEncoder271.clearBuffer(buffer143); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let bindGroup158 = device0.createBindGroup({ |
| label: '\uf21b\u957d\u0080\u74b0\u3fbc', |
| layout: bindGroupLayout25, |
| entries: [ |
| {binding: 17, resource: textureView6}, |
| {binding: 329, resource: sampler7}, |
| {binding: 20, resource: textureView192}, |
| {binding: 321, resource: {buffer: buffer112, offset: 1280, size: 1136}}, |
| {binding: 101, resource: textureView57}, |
| {binding: 333, resource: textureView189}, |
| {binding: 13, resource: {buffer: buffer37, offset: 0, size: 524}}, |
| ], |
| }); |
| let textureView235 = texture131.createView({}); |
| let renderPassEncoder99 = commandEncoder271.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView156, |
| clearValue: { r: -201.1, g: -791.9, b: 579.7, a: -729.4, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| maxDrawCount: 605310578, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder189); computePassEncoder189.dispatchWorkgroupsIndirect(buffer94, 88); }; |
| } catch {} |
| try { |
| renderPassEncoder91.setBindGroup(2, bindGroup17); |
| } catch {} |
| try { |
| renderPassEncoder81.setIndexBuffer(buffer15, 'uint16', 2_378, 1_377); |
| } catch {} |
| let gpuCanvasContext6 = canvas4.getContext('webgpu'); |
| try { |
| computePassEncoder211.setBindGroup(2, bindGroup27); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder82); computePassEncoder82.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder58.beginOcclusionQuery(9); |
| } catch {} |
| try { |
| renderPassEncoder58.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder65.setIndexBuffer(buffer81, 'uint16', 1_148, 1_733); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture222, |
| mipLevel: 0, |
| origin: {x: 17, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(459).fill(105), /* required buffer size: 459 */ |
| {offset: 459, bytesPerRow: 79}, {width: 6, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| document.body.append(img1); |
| let shaderModule18 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| requires pointer_composite_access; |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| @group(0) @binding(35) var st31: texture_storage_1d<r32sint, read_write>; |
| |
| @group(0) @binding(42) var et2: texture_external; |
| |
| @group(0) @binding(94) var tex11: texture_2d_array<f32>; |
| |
| @group(0) @binding(132) var tex12: texture_2d<i32>; |
| |
| @group(0) @binding(243) var tex13: texture_depth_2d; |
| |
| @group(0) @binding(398) var tex14: texture_depth_2d; |
| |
| @group(0) @binding(421) var<storage, read> buffer169: T0; |
| |
| @group(0) @binding(567) var st32: texture_storage_2d<rgba8snorm, write>; |
| |
| @group(0) @binding(999) var tex15: texture_2d_array<i32>; |
| |
| struct T0 { |
| f0: u32, |
| } |
| |
| struct VertexOutput17 { |
| @builtin(position) f49: vec4f, |
| } |
| |
| alias vec3b = vec3<bool>; |
| |
| override override12: u32 = 364; |
| |
| fn fn0() { |
| var vf381: vec4f = sign(vec4f(unconst_f32(0.2196), unconst_f32(0.1157), unconst_f32(0.05305), unconst_f32(0.3316))); |
| vf381 += bitcast<vec4f>(countTrailingZeros(vec3i(unconst_i32(157), unconst_i32(41), unconst_i32(58))).bggr); |
| var vf382: vec4f = sign(vec4f(unconst_f32(-0.03208), unconst_f32(0.06847), unconst_f32(0.1620), unconst_f32(0.2077))); |
| vf381 = saturate(vec4f(unconst_f32(0.01672), unconst_f32(0.01560), unconst_f32(0.1700), unconst_f32(0.4003))); |
| var vf383: vec3f = cross(vec3f(unconst_f32(0.05818), unconst_f32(0.3770), unconst_f32(0.09462)), vec3f(unconst_f32(0.02106), unconst_f32(0.05238), unconst_f32(-0.00197))); |
| var vf384: u32 = override12; |
| var vf385: vec4h = sin(vec4h(unconst_f16(13662.5), unconst_f16(6294.4), unconst_f16(7603.5), unconst_f16(-9578.4))); |
| vf383 = vec3f(sin(vec4h(unconst_f16(5962.7), unconst_f16(6722.6), unconst_f16(20163.5), unconst_f16(-3190.9))).wwx); |
| var vf386: vec4f = textureLoad(et2, vec2u(buffer169.f0)); |
| let vf387: vec2f = max(vec2f(unconst_f32(0.9625), unconst_f32(0.1669)), vec2f(unconst_f32(0.1918), unconst_f32(0.3157))); |
| vf382 = unpack4x8unorm(pack2x16float(vec2f(unconst_f32(-0.2276), unconst_f32(-0.05161)))); |
| vf383 *= vec3f(f32(atan(f16(unconst_f16(-2915.9))))); |
| let vf388: vec3f = smoothstep(vec3f(unconst_f32(0.1551), unconst_f32(0.02510), unconst_f32(0.06394)), vec3f(unconst_f32(0.1667), unconst_f32(0.09344), unconst_f32(0.09173)), vec3f(unconst_f32(0.1213), unconst_f32(0.03578), unconst_f32(0.1550))); |
| var vf389: vec3i = countTrailingZeros(vec3i(asinh(vec3h(unconst_f16(-2153.1), unconst_f16(5215.6), unconst_f16(7580.0))))); |
| var vf390: vec4f = min(vec4f(unconst_f32(0.02023), unconst_f32(0.04272), unconst_f32(0.1519), unconst_f32(0.1167)), vec4f(unconst_f32(0.1153), unconst_f32(0.1182), unconst_f32(0.2394), unconst_f32(0.02427))); |
| var vf391: vec4f = saturate(vec4f(unconst_f32(0.06651), unconst_f32(0.00645), unconst_f32(0.01818), unconst_f32(0.5856))); |
| var vf392: vec3h = asinh(vec3h(unconst_f16(4129.8), unconst_f16(1019.3), unconst_f16(3904.8))); |
| _ = override12; |
| } |
| |
| var<workgroup> vw63: atomic<u32>; |
| |
| var<workgroup> vw64: atomic<u32>; |
| |
| var<workgroup> vw65: T0; |
| |
| var<workgroup> vw66: atomic<i32>; |
| |
| var<workgroup> vw67: mat2x3h; |
| |
| var<workgroup> vw68: T0; |
| |
| @vertex |
| fn vertex18(@location(2) a0: vec2h, @location(15) a1: i32, @location(13) @interpolate(flat, sample) a2: i32, @location(12) a3: vec4u, @location(6) a4: i32, @location(14) @interpolate(linear) a5: vec4f, @location(1) @interpolate(flat, centroid) a6: f16, @location(11) a7: i32) -> VertexOutput17 { |
| var out: VertexOutput17; |
| out = VertexOutput17(unpack4x8unorm(textureNumLevels(tex14))); |
| out.f49 = bitcast<vec4f>(textureDimensions(tex13, i32(unconst_i32(9))).yxyx); |
| out = VertexOutput17(bitcast<vec4f>(textureDimensions(tex14, i32(unconst_i32(239))).rrgr)); |
| fn0(); |
| out = VertexOutput17(vec4f(bitcast<f32>(buffer169.f0))); |
| out.f49 = vec4f(inverseSqrt(vec2h(unconst_f16(-2022.8), unconst_f16(8532.7))).xxxx); |
| out.f49 += vec4f(f32((*&buffer169).f0)); |
| let vf393: vec2f = unpack2x16snorm(u32(unconst_u32(29))); |
| var vf394: u32 = pack2x16snorm(vec2f(unconst_f32(0.1848), unconst_f32(0.02907))); |
| fn0(); |
| out = VertexOutput17(unpack2x16snorm(u32(unconst_u32(539))).xyxx); |
| out.f49 = unpack4x8snorm(textureNumLevels(tex15)); |
| let vf395: u32 = textureNumLevels(tex15); |
| vf394 = bitcast<u32>(vf393[u32(unconst_u32(34))]); |
| fn0(); |
| var vf396: vec4i = textureLoad(tex12, vec2i(unconst_i32(377), unconst_i32(-7)), i32(unconst_i32(139))); |
| return out; |
| _ = override12; |
| } |
| |
| @fragment |
| fn fragment17(@location(4) a0: vec4u) -> @location(200) @interpolate(linear, center) vec4u { |
| var out: vec4u; |
| fn0(); |
| out ^= vec4u(pack2x16float(vec2f(unconst_f32(0.1372), unconst_f32(0.1703)))); |
| var vf397: vec2u = textureDimensions(tex12); |
| textureStore(st32, vec2i(unconst_i32(-529), unconst_i32(378)), vec4f(vec4f(f32(dot4U8Packed(u32(unconst_u32(108)), u32(unconst_u32(306))))))); |
| textureStore(st32, vec2i(unconst_i32(6), unconst_i32(122)), vec4f(vec4f(unconst_f32(0.05247), unconst_f32(0.1019), unconst_f32(0.2661), unconst_f32(0.1937)))); |
| fn0(); |
| fn0(); |
| fn0(); |
| fn0(); |
| fn0(); |
| fn0(); |
| vf397 <<= textureDimensions(tex12, i32(unconst_i32(99))); |
| let ptr145: ptr<storage, u32, read> = &buffer169.f0; |
| let ptr146: ptr<storage, u32, read> = &(*&buffer169).f0; |
| return out; |
| _ = override12; |
| } |
| |
| @compute @workgroup_size(1, 1, 1) |
| fn compute18(@builtin(workgroup_id) a0: vec3u) { |
| let vf398: u32 = textureNumLevels(tex11); |
| vw68.f0 = textureDimensions(tex11)[0]; |
| var vf399: u32 = textureNumLevels(tex12); |
| var vf400: vec2u = textureDimensions(tex15); |
| let vf401: vec2u = textureDimensions(tex12); |
| var vf402: u32 = textureNumLayers(tex15); |
| atomicMin(&vw66, i32(unconst_i32(72))); |
| var vf403: u32 = atomicExchange(&(*&vw64), u32(unconst_u32(68))); |
| let vf404: vec2u = textureDimensions(tex13); |
| var vf405: u32 = atomicLoad(&(*&vw64)); |
| let vf406: u32 = atomicLoad(&(*&vw63)); |
| atomicAnd(&vw66, i32(unconst_i32(15))); |
| let ptr147: ptr<function, u32> = &vf403; |
| atomicStore(&vw63, u32(unconst_u32(111))); |
| vw65.f0 ^= vf399; |
| var vf407: u32 = atomicExchange(&(*&vw64), u32(unconst_u32(136))); |
| }`, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| let bindGroupLayout32 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 143, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rgba8unorm', access: 'write-only', viewDimension: '2d' }, |
| }, |
| { |
| binding: 18, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| { |
| binding: 911, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'rgba16uint', access: 'read-only', viewDimension: '2d-array' }, |
| }, |
| { |
| binding: 157, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| { |
| binding: 193, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'sint', multisampled: false }, |
| }, |
| { |
| binding: 178, |
| visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| storageTexture: { format: 'rgba32sint', access: 'read-only', viewDimension: '2d-array' }, |
| }, |
| ], |
| }); |
| let bindGroup159 = device0.createBindGroup({ |
| layout: bindGroupLayout18, |
| entries: [{binding: 204, resource: externalTexture5}, {binding: 116, resource: sampler57}], |
| }); |
| let buffer170 = device0.createBuffer({ |
| size: 736, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let texture241 = device0.createTexture({ |
| label: '\u{1fdf6}\u0d92', |
| size: {width: 70, height: 72, depthOrArrayLayers: 1}, |
| format: 'rgba32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture242 = device0.createTexture({size: [560, 582, 1], mipLevelCount: 1, format: 'rgb10a2unorm', usage: GPUTextureUsage.COPY_SRC}); |
| let sampler157 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 88.91, |
| lodMaxClamp: 95.79, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder141); computePassEncoder141.dispatchWorkgroupsIndirect(buffer130, 0); }; |
| } catch {} |
| try { |
| renderPassEncoder15.executeBundles([renderBundle21, renderBundle1]); |
| } catch {} |
| try { |
| renderPassEncoder7.setIndexBuffer(buffer143, 'uint16', 1_642, 1_438); |
| } catch {} |
| try { |
| if (!arrayBuffer17.detached) { new Uint8Array(arrayBuffer17).fill(0x55); }; |
| } catch {} |
| let texture243 = device0.createTexture({ |
| size: {width: 48, height: 1, depthOrArrayLayers: 42}, |
| sampleCount: 1, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView236 = texture16.createView({ |
| label: '\u081c\u946a\ufdb6', |
| dimension: 'cube-array', |
| aspect: 'depth-only', |
| mipLevelCount: 1, |
| baseArrayLayer: 5, |
| arrayLayerCount: 6, |
| }); |
| let sampler158 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'nearest', |
| lodMinClamp: 19.72, |
| lodMaxClamp: 46.05, |
| compare: 'greater', |
| }); |
| try { |
| computePassEncoder83.setBindGroup(0, bindGroup125, new Uint32Array(5), 1, 0); |
| } catch {} |
| try { |
| renderPassEncoder99.executeBundles([renderBundle7, renderBundle0, renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder36.setVertexBuffer(7, buffer6, 384, 330); |
| } catch {} |
| let bindGroup160 = device0.createBindGroup({ |
| label: '\ufffb\u7292\u064b\uedf5\ua7ed\u{1f6bc}\u994a\u032d\u09a7\u{1fbb3}\u8ed0', |
| layout: bindGroupLayout22, |
| entries: [ |
| {binding: 298, resource: {buffer: buffer160, offset: 3584, size: 248}}, |
| {binding: 44, resource: {buffer: buffer143, offset: 0}}, |
| {binding: 178, resource: textureView182}, |
| {binding: 159, resource: {buffer: buffer141, offset: 1024, size: 2212}}, |
| {binding: 75, resource: externalTexture20}, |
| {binding: 265, resource: sampler75}, |
| {binding: 337, resource: textureView22}, |
| {binding: 29, resource: sampler149}, |
| {binding: 31, resource: textureView177}, |
| {binding: 132, resource: {buffer: buffer50, offset: 0, size: 636}}, |
| {binding: 244, resource: externalTexture20}, |
| {binding: 304, resource: textureView171}, |
| {binding: 4, resource: {buffer: buffer82, offset: 0, size: 466}}, |
| ], |
| }); |
| let buffer171 = device0.createBuffer({size: 5320, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX}); |
| let textureView237 = texture243.createView({dimension: '2d', baseArrayLayer: 12}); |
| let textureView238 = texture20.createView({label: '\u0312\u{1f605}', dimension: '2d', mipLevelCount: 1, baseArrayLayer: 24}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder120); computePassEncoder120.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder35.setIndexBuffer(buffer113, 'uint32', 1_584, 4_967); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture235, |
| mipLevel: 0, |
| origin: {x: 101, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(575).fill(251), /* required buffer size: 575 */ |
| {offset: 575, rowsPerImage: 52}, {width: 22, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext1.unconfigure(); |
| } catch {} |
| let textureView239 = texture217.createView({label: '\u{1f8ca}\ufc4b\u1c25', dimension: '2d-array', aspect: 'all', mipLevelCount: 1}); |
| let texture244 = device0.createTexture({ |
| size: {width: 384, height: 1, depthOrArrayLayers: 28}, |
| mipLevelCount: 2, |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder14.setBindGroup(3, bindGroup57); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder177); computePassEncoder177.dispatchWorkgroupsIndirect(buffer138, 340); }; |
| } catch {} |
| try { |
| renderPassEncoder47.setVertexBuffer(6, buffer67, 0); |
| } catch {} |
| document.body.prepend(canvas1); |
| let textureView240 = texture241.createView({dimension: '2d-array'}); |
| try { |
| computePassEncoder80.setBindGroup(3, bindGroup87, new Uint32Array(3323), 2_284, 0); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| let querySet29 = device0.createQuerySet({label: '\u07d4\u046e\u{1fd8c}', type: 'occlusion', count: 153}); |
| let textureView241 = texture106.createView({mipLevelCount: 1, baseArrayLayer: 7, arrayLayerCount: 3}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder82); computePassEncoder82.dispatchWorkgroupsIndirect(buffer8, 1_356); }; |
| } catch {} |
| try { |
| computePassEncoder216.setPipeline(pipeline5); |
| } catch {} |
| try { |
| buffer90.unmap(); |
| } catch {} |
| try { |
| computePassEncoder64.insertDebugMarker('\ueea5'); |
| } catch {} |
| let bindGroup161 = device0.createBindGroup({layout: bindGroupLayout13, entries: [{binding: 272, resource: {buffer: buffer4, offset: 768}}]}); |
| let textureView242 = texture97.createView({label: '\u086e\u{1f8a5}\ubfd3\u0adc\uc1cc'}); |
| try { |
| computePassEncoder187.setBindGroup(2, bindGroup39); |
| } catch {} |
| try { |
| renderPassEncoder94.setBindGroup(1, bindGroup105, new Uint32Array(908), 3, 0); |
| } catch {} |
| try { |
| renderPassEncoder86.setIndexBuffer(buffer70, 'uint16', 238, 1_609); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| } catch {} |
| let buffer172 = device0.createBuffer({size: 5218, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let texture245 = device0.createTexture({ |
| size: {width: 110, height: 10, depthOrArrayLayers: 78}, |
| dimension: '3d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder119.setBindGroup(1, bindGroup104, new Uint32Array(2596), 242, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder141); computePassEncoder141.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder67.setBindGroup(3, bindGroup66, []); |
| } catch {} |
| try { |
| renderPassEncoder78.setBindGroup(2, bindGroup14, new Uint32Array(3748), 1_136, 0); |
| } catch {} |
| document.body.append(canvas3); |
| let buffer173 = device0.createBuffer({ |
| size: 1290, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let texture246 = device0.createTexture({ |
| size: {width: 192, height: 1, depthOrArrayLayers: 1}, |
| mipLevelCount: 1, |
| format: 'rg11b10ufloat', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| try { |
| renderPassEncoder85.executeBundles([renderBundle6, renderBundle6]); |
| } catch {} |
| try { |
| renderPassEncoder30.setViewport(61.58868584271414, 0.13895765069893684, 0.18416842085040105, 0.5832341655488852, 0.3544541533040968, 0.45163029835127744); |
| } catch {} |
| try { |
| computePassEncoder147.popDebugGroup(); |
| } catch {} |
| try { |
| gpuCanvasContext2.unconfigure(); |
| } catch {} |
| let bindGroup162 = device0.createBindGroup({ |
| layout: bindGroupLayout25, |
| entries: [ |
| {binding: 13, resource: {buffer: buffer102, offset: 0, size: 748}}, |
| {binding: 17, resource: textureView64}, |
| {binding: 329, resource: sampler25}, |
| {binding: 101, resource: textureView39}, |
| {binding: 20, resource: textureView215}, |
| {binding: 333, resource: textureView70}, |
| {binding: 321, resource: {buffer: buffer12, offset: 0}}, |
| ], |
| }); |
| let querySet30 = device0.createQuerySet({type: 'occlusion', count: 1477}); |
| let textureView243 = texture47.createView({mipLevelCount: 1}); |
| try { |
| renderPassEncoder99.setIndexBuffer(buffer59, 'uint16', 248, 110); |
| } catch {} |
| let pipeline6 = device0.createComputePipeline({layout: pipelineLayout0, compute: {module: shaderModule15, constants: {}}}); |
| let buffer174 = device0.createBuffer({ |
| size: 8885, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let texture247 = device0.createTexture({ |
| size: [192, 1, 262], |
| dimension: '3d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let textureView244 = texture126.createView({label: '\u0992\u0b10', format: 'rgb10a2uint', mipLevelCount: 1}); |
| let sampler159 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| }); |
| try { |
| computePassEncoder167.setBindGroup(0, bindGroup54, new Uint32Array(2878), 224, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder120); computePassEncoder120.dispatchWorkgroups(2, 1); }; |
| } catch {} |
| try { |
| renderPassEncoder83.setVertexBuffer(7, buffer85, 1_500, 5_930); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 70, height: 72, depthOrArrayLayers: 1} |
| */ |
| { |
| source: img1, |
| origin: { x: 7, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture191, |
| mipLevel: 3, |
| origin: {x: 4, y: 20, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 9, height: 3, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer175 = device0.createBuffer({size: 5856, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM}); |
| let querySet31 = device0.createQuerySet({label: '\uc340\u0837\ub7b7\u0972\u8b17', type: 'occlusion', count: 411}); |
| try { |
| computePassEncoder153.setBindGroup(0, bindGroup44, new Uint32Array(21), 4, 0); |
| } catch {} |
| try { |
| renderPassEncoder30.setBindGroup(0, bindGroup1); |
| } catch {} |
| try { |
| renderPassEncoder51.setIndexBuffer(buffer27, 'uint16', 294, 263); |
| } catch {} |
| try { |
| renderPassEncoder34.setBindGroup(2, bindGroup7); |
| } catch {} |
| try { |
| renderPassEncoder27.executeBundles([renderBundle21, renderBundle21]); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 36, height: 1, depthOrArrayLayers: 177} |
| */ |
| { |
| source: imageData0, |
| origin: { x: 0, y: 30 }, |
| flipY: true, |
| }, { |
| texture: texture216, |
| mipLevel: 0, |
| origin: {x: 5, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 14, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let textureView245 = texture205.createView({}); |
| try { |
| computePassEncoder217.setBindGroup(1, bindGroup75, new Uint32Array(2668), 914, 0); |
| } catch {} |
| let textureView246 = texture241.createView({dimension: '2d-array'}); |
| let textureView247 = texture198.createView({dimension: '3d', mipLevelCount: 1}); |
| let externalTexture23 = device0.importExternalTexture({source: videoFrame28, colorSpace: 'display-p3'}); |
| try { |
| renderPassEncoder78.setBindGroup(2, bindGroup22); |
| } catch {} |
| try { |
| renderPassEncoder49.setIndexBuffer(buffer173, 'uint32', 4, 47); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer3, 64, new Int16Array(26264), 5726, 72); |
| } catch {} |
| let img4 = await imageWithData(50, 88, '#10101010', '#20202020'); |
| let texture248 = device0.createTexture({size: [440], dimension: '1d', format: 'rgb10a2uint', usage: GPUTextureUsage.TEXTURE_BINDING}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder7); computePassEncoder7.dispatchWorkgroupsIndirect(buffer148, 76); }; |
| } catch {} |
| try { |
| renderPassEncoder55.setBindGroup(1, bindGroup134, new Uint32Array(2382), 320, 0); |
| } catch {} |
| try { |
| renderPassEncoder47.setStencilReference(62); |
| } catch {} |
| try { |
| renderPassEncoder41.setVertexBuffer(4, buffer148, 252); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture222, |
| mipLevel: 0, |
| origin: {x: 7, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(123).fill(50), /* required buffer size: 123 */ |
| {offset: 123, rowsPerImage: 14}, {width: 4, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let textureView248 = texture180.createView({label: '\u{1f844}\u0f2a\u{1fe61}\ub9f6\u245b\u{1fbf4}\u5330\uc958'}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder120); computePassEncoder120.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| let promise22 = device0.queue.onSubmittedWorkDone(); |
| let texture249 = device0.createTexture({ |
| label: '\u9f4b\u47ab\u4b62\u{1fa86}\ufd88\u1678\u003c', |
| size: [48, 1, 103], |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder48.setVertexBuffer(3, buffer109, 404); |
| } catch {} |
| try { |
| gpuCanvasContext0.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| let bindGroup163 = device0.createBindGroup({ |
| layout: bindGroupLayout23, |
| entries: [{binding: 63, resource: textureView208}, {binding: 28, resource: textureView178}], |
| }); |
| let buffer176 = device0.createBuffer({ |
| size: 5826, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let texture250 = gpuCanvasContext3.getCurrentTexture(); |
| let externalTexture24 = device0.importExternalTexture({source: videoFrame0, colorSpace: 'display-p3'}); |
| try { |
| computePassEncoder203.setBindGroup(3, bindGroup67); |
| } catch {} |
| try { |
| renderPassEncoder34.setBindGroup(0, bindGroup159, new Uint32Array(2782), 323, 0); |
| } catch {} |
| try { |
| renderPassEncoder54.executeBundles([renderBundle4]); |
| } catch {} |
| try { |
| renderPassEncoder9.setViewport(35.513284790236035, 0.8669306266239848, 18.55667803388992, 0.07239025981986291, 0.7443917567088355, 0.9682132869699585); |
| } catch {} |
| try { |
| renderPassEncoder83.setPipeline(pipeline1); |
| } catch {} |
| let arrayBuffer20 = buffer74.getMappedRange(208, 24); |
| try { |
| device0.queue.writeTexture({ |
| texture: texture30, |
| mipLevel: 0, |
| origin: {x: 75, y: 121, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(5).fill(28), /* required buffer size: 5 */ |
| {offset: 5, bytesPerRow: 307}, {width: 36, height: 30, depthOrArrayLayers: 0}); |
| } catch {} |
| let videoFrame39 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'yCgCo', primaries: 'smpteRp431', transfer: 'log'} }); |
| let bindGroupLayout33 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 36, visibility: GPUShaderStage.COMPUTE, buffer: { type: 'storage', hasDynamicOffset: false }}, |
| ], |
| }); |
| try { |
| computePassEncoder114.setBindGroup(3, bindGroup138); |
| } catch {} |
| try { |
| renderPassEncoder34.setBindGroup(2, bindGroup95, new Uint32Array(437), 182, 0); |
| } catch {} |
| try { |
| renderPassEncoder5.setViewport(66.2359971509041, 0.6376822037175481, 12.103738014515004, 0.031012009184995352, 0.4781793680250941, 0.9978637524479301); |
| } catch {} |
| try { |
| renderPassEncoder97.setVertexBuffer(1, buffer24, 392, 593); |
| } catch {} |
| let buffer177 = device0.createBuffer({ |
| size: 21317, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM, |
| }); |
| let texture251 = device0.createTexture({size: [70, 72, 1], dimension: '2d', format: 'depth24plus', usage: GPUTextureUsage.COPY_DST}); |
| let textureView249 = texture6.createView({dimension: '2d-array', baseArrayLayer: 0}); |
| try { |
| renderPassEncoder77.beginOcclusionQuery(769); |
| } catch {} |
| try { |
| renderPassEncoder77.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder62.executeBundles([renderBundle4]); |
| } catch {} |
| try { |
| renderPassEncoder34.setVertexBuffer(7, buffer10); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer46, 1064, new Int16Array(12), 1, 0); |
| } catch {} |
| try { |
| if (!arrayBuffer6.detached) { new Uint8Array(arrayBuffer6).fill(0x55); }; |
| } catch {} |
| let buffer178 = device0.createBuffer({ |
| size: 15114, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| try { |
| computePassEncoder177.setBindGroup(2, bindGroup58); |
| } catch {} |
| try { |
| computePassEncoder139.setBindGroup(3, bindGroup104, new Uint32Array(2242), 225, 0); |
| } catch {} |
| try { |
| computePassEncoder167.end(); |
| } catch {} |
| try { |
| renderPassEncoder26.setBindGroup(0, bindGroup91); |
| } catch {} |
| try { |
| renderPassEncoder64.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder89.setVertexBuffer(1, buffer103, 84); |
| } catch {} |
| try { |
| commandEncoder44.copyBufferToTexture({ |
| /* bytesInLastRow: 36 widthInBlocks: 36 aspectSpecificFormat.texelBlockSize: 1 */ |
| /* end: 1076 */ |
| offset: 1076, |
| buffer: buffer106, |
| }, { |
| texture: texture27, |
| mipLevel: 3, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'stencil-only', |
| }, {width: 36, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await promise22; |
| } catch {} |
| let texture252 = gpuCanvasContext3.getCurrentTexture(); |
| let renderPassEncoder100 = commandEncoder44.beginRenderPass({colorAttachments: [{view: textureView99, depthSlice: 6, loadOp: 'clear', storeOp: 'store'}]}); |
| try { |
| computePassEncoder201.setBindGroup(2, bindGroup44, new Uint32Array(373), 8, 0); |
| } catch {} |
| try { |
| if (!arrayBuffer7.detached) { new Uint8Array(arrayBuffer7).fill(0x55); }; |
| } catch {} |
| let textureView250 = texture24.createView({}); |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer21, 'uint32', 1_208, 580); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| try { |
| globalThis.someLabel = bindGroup153.label; |
| } catch {} |
| let externalTexture25 = device0.importExternalTexture({source: videoFrame13}); |
| try { |
| renderPassEncoder92.setBindGroup(2, bindGroup29, new Uint32Array(1535), 43, 0); |
| } catch {} |
| try { |
| renderPassEncoder75.setIndexBuffer(buffer115, 'uint16', 20, 117); |
| } catch {} |
| let bindGroup164 = device0.createBindGroup({ |
| layout: bindGroupLayout18, |
| entries: [{binding: 204, resource: externalTexture22}, {binding: 116, resource: sampler130}], |
| }); |
| let buffer179 = device0.createBuffer({ |
| label: '\ua5f0\u05b7\u0640\u046c\u45ca\u6d20\u0d7b\ud510\u5a95\u{1fa1d}\u0a4d', |
| size: 2133, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM, |
| }); |
| let texture253 = device0.createTexture({ |
| label: '\u2f35\ud327\udfb5\u0707\u5c28\u0ad9\u{1f87f}\u0b9a\ufaf3\uc826\u{1f78f}', |
| size: [48], |
| dimension: '1d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler160 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'mirror-repeat', mipmapFilter: 'nearest', lodMaxClamp: 35.15}); |
| try { |
| computePassEncoder150.setBindGroup(2, bindGroup127); |
| } catch {} |
| try { |
| renderPassEncoder21.setBlendConstant({ r: -297.6, g: 364.4, b: 876.3, a: -512.9, }); |
| } catch {} |
| try { |
| renderPassEncoder82.setViewport(504.8936500482476, 341.2603891722671, 36.30048699089683, 28.107171726931153, 0.7016050800453578, 0.9042489290188462); |
| } catch {} |
| try { |
| renderPassEncoder69.setIndexBuffer(buffer1, 'uint32', 696, 133); |
| } catch {} |
| try { |
| buffer111.unmap(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 36, height: 1, depthOrArrayLayers: 177} |
| */ |
| { |
| source: imageData22, |
| origin: { x: 0, y: 3 }, |
| flipY: false, |
| }, { |
| texture: texture216, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 44}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture254 = device0.createTexture({ |
| size: [192, 1, 1], |
| sampleCount: 4, |
| format: 'depth24plus', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| renderPassEncoder30.setVertexBuffer(1, buffer12, 0, 24); |
| } catch {} |
| try { |
| renderPassEncoder95.setBindGroup(0, bindGroup9, new Uint32Array(942), 29, 0); |
| } catch {} |
| try { |
| renderPassEncoder71.setVertexBuffer(5, buffer76); |
| } catch {} |
| try { |
| await buffer142.mapAsync(GPUMapMode.WRITE, 7744, 4308); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture84, |
| mipLevel: 1, |
| origin: {x: 3, y: 1, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(761).fill(123), /* required buffer size: 761 */ |
| {offset: 761}, {width: 5, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup165 = device0.createBindGroup({layout: bindGroupLayout20, entries: [{binding: 152, resource: textureView13}]}); |
| let textureView251 = texture164.createView({}); |
| try { |
| computePassEncoder153.setBindGroup(2, bindGroup164); |
| } catch {} |
| try { |
| computePassEncoder189.end(); |
| } catch {} |
| try { |
| renderPassEncoder64.setBindGroup(3, bindGroup76, new Uint32Array(1394), 43, 0); |
| } catch {} |
| try { |
| renderPassEncoder52.executeBundles([renderBundle10]); |
| } catch {} |
| try { |
| await buffer136.mapAsync(GPUMapMode.WRITE, 0, 48); |
| } catch {} |
| try { |
| commandEncoder234.copyTextureToBuffer({ |
| texture: texture47, |
| mipLevel: 0, |
| origin: {x: 47, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 316 widthInBlocks: 79 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 480 */ |
| offset: 480, |
| bytesPerRow: 2560, |
| buffer: buffer59, |
| }, {width: 79, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder234.clearBuffer(buffer38, 7064, 256); |
| } catch {} |
| try { |
| renderPassEncoder70.insertDebugMarker('\ucb22'); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer150, 1540, new Float32Array(3039), 382, 80); |
| } catch {} |
| let shaderModule19 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| requires packed_4x8_integer_dot_product; |
| |
| diagnostic(info, xyz); |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| @group(0) @binding(11) var<storage, read_write> buffer180: array<array<array<f16, 14>, 4>>; |
| |
| struct T0 { |
| @size(112) f0: array<i32>, |
| } |
| |
| struct S12 { |
| @location(14) @interpolate(linear) f0: vec2f, |
| @location(15) @interpolate(perspective) f1: vec2h, |
| @location(0) @interpolate(flat) f2: vec4i, |
| } |
| |
| struct VertexOutput18 { |
| @invariant @builtin(position) f50: vec4f, |
| } |
| |
| struct S13 { |
| @builtin(workgroup_id) @size(16) f0: vec3u, |
| @builtin(global_invocation_id) @size(16) f1: vec3u, |
| } |
| |
| struct FragmentOutput16 { |
| @location(1) @interpolate(flat, centroid) f0: vec4u, |
| @location(0) f1: vec4f, |
| } |
| |
| fn fn0() -> mat2x2h { |
| var out: mat2x2h; |
| let vf408: vec4h = exp2(vec4h(unconst_f16(204.3), unconst_f16(420.8), unconst_f16(-3889.9), unconst_f16(3471.8))); |
| var vf409: vec4i = firstTrailingBit(vec4i(unconst_i32(50), unconst_i32(108), unconst_i32(-64), unconst_i32(287))); |
| var vf410: f16 = vf408[u32(unconst_u32(249))]; |
| vf409 += vec4i(round(vec2f(unconst_f32(0.01007), unconst_f32(0.05177))).grrr); |
| let vf411: vec4h = exp2(vec4h(unconst_f16(196.3), unconst_f16(1180.2), unconst_f16(20432.1), unconst_f16(6595.0))); |
| let vf412: f16 = step(f16(unconst_f16(14272.0)), f16(unconst_f16(5353.9))); |
| var vf413: f16 = step(f16(unconst_f16(6395.3)), f16(unconst_f16(2255.0))); |
| out += mat2x2h(vec2h(firstTrailingBit(vec4i(unconst_i32(544), unconst_i32(74), unconst_i32(61), unconst_i32(17))).br), vec2h(firstTrailingBit(vec4i(unconst_i32(544), unconst_i32(74), unconst_i32(61), unconst_i32(17))).gg)); |
| var vf414: f16 = step(f16(unconst_f16(46799.5)), f16(unconst_f16(6510.5))); |
| let vf415: vec2f = round(vec2f(unconst_f32(0.2999), unconst_f32(0.02953))); |
| var vf416: f16 = vf408[u32(unconst_u32(431))]; |
| vf416 *= vf408[3]; |
| return out; |
| } |
| |
| fn fn1() -> array<vec4h, 1> { |
| var out: array<vec4h, 1>; |
| fn0(); |
| var vf417 = fn0(); |
| out[u32(unconst_u32(150))] = vec4h(f16(pack2x16snorm(vec2f(unconst_f32(0.1250), unconst_f32(0.2256))))); |
| var vf418: vec2i = abs(vec2i(unconst_i32(-187), unconst_i32(53))); |
| let vf419: vec3h = min(vec3h(unconst_f16(2819.7), unconst_f16(8167.1), unconst_f16(30037.5)), vec3h(unconst_f16(8988.8), unconst_f16(-9899.9), unconst_f16(8449.6))); |
| let vf420: f32 = quantizeToF16(bitcast<f32>(pack2x16unorm(vec2f(unconst_f32(0.07619), unconst_f32(0.1557))))); |
| vf418 |= bitcast<vec2i>(step(vec3f(unconst_f32(-0.05256), unconst_f32(0.3524), unconst_f32(0.2594)), vec3f(unconst_f32(0.1125), unconst_f32(0.06023), unconst_f32(0.01833))).bb); |
| let ptr148: ptr<function, mat2x2h> = &vf417; |
| var vf421 = fn0(); |
| fn0(); |
| vf421 = mat2x2h(vec2h(tan(tan(vec3f(unconst_f32(0.06554), unconst_f32(0.5243), unconst_f32(0.02118)))).rb), vec2h(tan(tan(vec3f(unconst_f32(0.06554), unconst_f32(0.5243), unconst_f32(0.02118)))).yy)); |
| out[u32(unconst_u32(315))] = vec4h(vf417[u32(unconst_u32(193))][u32(unconst_u32(154))]); |
| var vf422: vec4h = mix(vec4h(step(vec3f(unconst_f32(-0.2371), unconst_f32(0.2271), unconst_f32(0.01627)), vec3f(unconst_f32(0.6099), unconst_f32(0.2146), unconst_f32(0.3600))).bbbg), vec4h(unconst_f16(-2520.6), unconst_f16(3946.9), unconst_f16(11250.8), unconst_f16(19439.6)), vec4h(unconst_f16(14658.1), unconst_f16(-2442.7), unconst_f16(12680.1), unconst_f16(11476.2))); |
| vf422 += vf421[u32(unconst_u32(111))].grrg; |
| out[u32(unconst_u32(72))] = vec4h(f16(degrees(f32(unconst_f32(0.1739))))); |
| var vf423: vec3h = vf419; |
| let ptr149: ptr<function, vec2i> = &vf418; |
| vf418 -= (*ptr149); |
| var vf424 = fn0(); |
| vf423 += vec3h(step(vec3f(unconst_f32(0.1186), unconst_f32(0.07502), unconst_f32(0.3917)), vec3f(unconst_f32(0.02272), unconst_f32(-0.08165), unconst_f32(0.00164)))); |
| return out; |
| } |
| |
| fn fn2() -> VertexOutput18 { |
| var out: VertexOutput18; |
| out = VertexOutput18(unpack2x16unorm(u32(unconst_u32(35))).ggrg); |
| out = VertexOutput18(vec4f(f32(distance(vec3h(unconst_f16(60000.0), unconst_f16(-19607.9), unconst_f16(4518.4)), vec3h(unconst_f16(17382.0), unconst_f16(9242.0), unconst_f16(4163.1)))))); |
| let vf425: u32 = pack4xI8(unpack4xI8(dot4U8Packed(u32(unconst_u32(118)), u32(unconst_u32(23))))); |
| var vf426 = fn0(); |
| var vf427 = fn0(); |
| vf427 -= vf426; |
| let vf428: vec2f = unpack2x16unorm(u32(unconst_u32(98))); |
| fn0(); |
| let vf429: u32 = vf425; |
| vf427 = mat2x2h(f16(dot4U8Packed(u32(unconst_u32(30)), u32(unconst_u32(39)))), f16(dot4U8Packed(u32(unconst_u32(30)), u32(unconst_u32(39)))), f16(dot4U8Packed(u32(unconst_u32(30)), u32(unconst_u32(39)))), f16(dot4U8Packed(u32(unconst_u32(30)), u32(unconst_u32(39))))); |
| var vf430 = fn0(); |
| return out; |
| } |
| |
| var<workgroup> vw69: u32; |
| |
| var<workgroup> vw70: S12; |
| |
| var<workgroup> vw71: atomic<u32>; |
| |
| var<workgroup> vw72: mat2x2h; |
| |
| @vertex |
| fn vertex19(@location(10) @interpolate(flat) a0: i32, @location(1) @interpolate(flat) a1: i32, @location(3) @interpolate(flat) a2: vec2f, @location(5) a3: vec4u, @location(9) a4: vec4u, a5: S12, @location(4) a6: vec4f, @location(13) @interpolate(flat, sample) a7: f16, @location(11) a8: vec2i, @location(6) @interpolate(flat, centroid) a9: vec4h) -> VertexOutput18 { |
| var out: VertexOutput18; |
| out = VertexOutput18(vec4f(a5.f1.grgr)); |
| out = VertexOutput18(vec4f(f32(a1))); |
| out.f50 -= vec4f(tan(vec2h(unconst_f16(2801.7), unconst_f16(1605.4))).yxyy); |
| out = VertexOutput18(vec4f(a5.f1.grrr)); |
| var vf431 = fn1(); |
| out.f50 = vec4f(vf431[u32(unconst_u32(116))]); |
| let vf432: vec4f = atan(vec4f(unconst_f32(0.01356), unconst_f32(0.6379), unconst_f32(1.000), unconst_f32(0.01560))); |
| vf431[u32(unconst_u32(9))] += vf431[0]; |
| var vf433: u32 = a3[u32(unconst_u32(205))]; |
| return out; |
| } |
| |
| @fragment |
| fn fragment18() -> FragmentOutput16 { |
| var out: FragmentOutput16; |
| let vf434: vec4i = unpack4xI8(u32(acosh(vec2f(unconst_f32(0.04638), unconst_f32(0.1552))).g)); |
| var vf435 = fn2(); |
| let ptr150: ptr<function, vec4f> = &vf435.f50; |
| fn2(); |
| out = FragmentOutput16(vec4u(vf435.f50), vf435.f50); |
| out.f1 = vf435.f50; |
| var vf436: f32 = determinant(mat3x3f()); |
| let vf437: vec4i = vf434; |
| out.f0 = vec4u(sign(vec2f(unconst_f32(0.04442), unconst_f32(0.3909))).xxyx); |
| let vf438: f32 = (*ptr150)[u32(unconst_u32(35))]; |
| fn2(); |
| var vf439 = fn2(); |
| fn2(); |
| vf439 = vf435; |
| out.f0 ^= vec4u((*ptr150)); |
| vf436 = vf439.f50[u32(unconst_u32(7))]; |
| out.f1 += (*ptr150); |
| vf436 = vec4f(tan(vec4h(unconst_f16(646.2), unconst_f16(2769.0), unconst_f16(10488.8), unconst_f16(13780.8)))).y; |
| var vf440: vec2f = acosh(vec2f(unconst_f32(-0.1476), unconst_f32(0.1166))); |
| out.f0 = unpack4xU8(bitcast<u32>(vf440[bitcast<u32>(vf437[0])])); |
| var vf441: vec4f = fract(vec4f(unconst_f32(0.1744), unconst_f32(0.08771), unconst_f32(0.1690), unconst_f32(0.03171))); |
| return out; |
| } |
| |
| @compute @workgroup_size(1, 1, 1) |
| fn compute19(@builtin(local_invocation_index) a0: u32, a1: S13) { |
| vw69 = u32(buffer180[u32((*&buffer180)[u32(unconst_u32(181))][3][13])][3][13]); |
| atomicMin(&vw71, u32(unconst_u32(73))); |
| fn2(); |
| let vf442: vec4f = trunc(vec4f(unconst_f32(0.04450), unconst_f32(0.2672), unconst_f32(0.04728), unconst_f32(0.05413))); |
| var vf443 = fn2(); |
| fn2(); |
| let ptr151: ptr<storage, f16, read_write> = &(*&buffer180)[u32(unconst_u32(35))][u32(unconst_u32(62))][13]; |
| let ptr152: ptr<storage, f16, read_write> = &(*&buffer180)[arrayLength(&(*&buffer180))][u32(unconst_u32(155))][13]; |
| vw70.f2 = (*&vw70).f2; |
| atomicStore(&vw71, bitcast<vec4u>(vf442).g); |
| var vf444 = fn0(); |
| fn0(); |
| let vf445: f32 = vf442[u32(unconst_u32(136))]; |
| var vf446: S13 = a1; |
| buffer180[u32(unconst_u32(118))][u32(unconst_u32(8))][13] += buffer180[arrayLength(&buffer180)][3][13]; |
| vf446 = S13(vec3u(u32(buffer180[u32(unconst_u32(228))][3][13])), vec3u(u32(buffer180[u32(unconst_u32(228))][3][13]))); |
| fn2(); |
| var vf447 = fn0(); |
| vf446.f1 <<= vec3u(vf447[unconst_i32(1)].grg); |
| fn0(); |
| let vf448: u32 = vf446.f1[u32(unconst_u32(165))]; |
| fn2(); |
| }`, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| let computePassEncoder219 = commandEncoder234.beginComputePass({label: '\u{1f781}\u09cc'}); |
| let sampler161 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeW: 'repeat', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 58.92, |
| lodMaxClamp: 75.21, |
| }); |
| try { |
| computePassEncoder129.setBindGroup(1, bindGroup96); |
| } catch {} |
| try { |
| computePassEncoder185.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder97.setBlendConstant({ r: -424.8, g: -75.53, b: -392.2, a: 98.11, }); |
| } catch {} |
| try { |
| renderPassEncoder49.setBindGroup(3, bindGroup90); |
| } catch {} |
| try { |
| renderPassEncoder55.executeBundles([renderBundle6]); |
| } catch {} |
| let pipeline7 = await device0.createComputePipelineAsync({layout: pipelineLayout12, compute: {module: shaderModule19, constants: {}}}); |
| let texture255 = device0.createTexture({ |
| size: {width: 192, height: 1, depthOrArrayLayers: 262}, |
| mipLevelCount: 3, |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder178.setBindGroup(2, bindGroup148); |
| } catch {} |
| try { |
| computePassEncoder219.setPipeline(pipeline3); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let textureView252 = texture181.createView({label: '\u{1ff5e}\u{1f669}\u14f2\uc349\u09dc\udfaf\ud610\ud99d\u{1faf6}\ub2d1'}); |
| let externalTexture26 = device0.importExternalTexture({source: videoFrame15}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder85); computePassEncoder85.dispatchWorkgroupsIndirect(buffer72, 3_196); }; |
| } catch {} |
| try { |
| renderPassEncoder30.setIndexBuffer(buffer16, 'uint16', 480, 1_180); |
| } catch {} |
| try { |
| renderPassEncoder94.setVertexBuffer(4, buffer178, 1_392, 333); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| globalThis.someLabel = externalTexture19.label; |
| } catch {} |
| try { |
| renderPassEncoder50.setBindGroup(0, bindGroup17); |
| } catch {} |
| try { |
| renderPassEncoder39.setIndexBuffer(buffer23, 'uint32', 456, 2_109); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'display-p3', |
| }); |
| } catch {} |
| let videoFrame40 = videoFrame24.clone(); |
| let buffer181 = device0.createBuffer({ |
| size: 26396, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT, |
| mappedAtCreation: false, |
| }); |
| let texture256 = device0.createTexture({ |
| size: {width: 192}, |
| dimension: '1d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView253 = texture222.createView({}); |
| let sampler162 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 49.23, |
| lodMaxClamp: 77.29, |
| compare: 'greater', |
| maxAnisotropy: 20, |
| }); |
| try { |
| computePassEncoder139.setBindGroup(0, bindGroup51); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder7); computePassEncoder7.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| renderPassEncoder21.executeBundles([renderBundle0]); |
| } catch {} |
| try { |
| buffer173.unmap(); |
| } catch {} |
| let offscreenCanvas4 = new OffscreenCanvas(70, 13); |
| try { |
| computePassEncoder149.setBindGroup(3, bindGroup112, [1280]); |
| } catch {} |
| try { |
| renderPassEncoder88.setBindGroup(3, bindGroup49, new Uint32Array(2232), 50, 0); |
| } catch {} |
| try { |
| renderPassEncoder23.setIndexBuffer(buffer27, 'uint16', 118, 709); |
| } catch {} |
| try { |
| renderPassEncoder6.setVertexBuffer(3, buffer64, 576, 895); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let buffer182 = device0.createBuffer({ |
| label: '\ub18e\u0327\u5318\u{1fd9c}\u{1f730}\u{1f766}\ubbc7\ub933', |
| size: 7857, |
| usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| try { |
| computePassEncoder27.setBindGroup(0, bindGroup94); |
| } catch {} |
| try { |
| computePassEncoder141.end(); |
| } catch {} |
| try { |
| renderPassEncoder95.setBindGroup(1, bindGroup143); |
| } catch {} |
| try { |
| renderPassEncoder17.setViewport(68.38341273882449, 0.1419970438928151, 5.068120371546142, 0.7550093713357119, 0.8447243180331617, 0.8564782061632051); |
| } catch {} |
| try { |
| commandEncoder181.clearBuffer(buffer122); |
| } catch {} |
| try { |
| gpuCanvasContext3.unconfigure(); |
| } catch {} |
| document.body.prepend(img3); |
| await gc(); |
| let bindGroup166 = device0.createBindGroup({layout: bindGroupLayout26, entries: [{binding: 49, resource: {buffer: buffer99, offset: 4608}}]}); |
| let computePassEncoder220 = commandEncoder181.beginComputePass({label: '\u966c\u5085\u90e9\u{1fe29}\u00ab\u8d97\u0c78\u2f5e'}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder177); computePassEncoder177.dispatchWorkgroupsIndirect(buffer54, 1_612); }; |
| } catch {} |
| try { |
| computePassEncoder85.end(); |
| } catch {} |
| try { |
| computePassEncoder220.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderPassEncoder6.executeBundles([renderBundle16, renderBundle5, renderBundle3, renderBundle3, renderBundle3, renderBundle16, renderBundle0, renderBundle0]); |
| } catch {} |
| try { |
| renderPassEncoder93.setIndexBuffer(buffer77, 'uint32', 1_904, 155); |
| } catch {} |
| try { |
| renderPassEncoder33.setVertexBuffer(1, buffer62, 0, 15_315); |
| } catch {} |
| try { |
| buffer23.unmap(); |
| } catch {} |
| try { |
| commandEncoder109.copyTextureToTexture({ |
| texture: texture181, |
| mipLevel: 0, |
| origin: {x: 4, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture247, |
| mipLevel: 0, |
| origin: {x: 22, y: 0, z: 2}, |
| aspect: 'all', |
| }, |
| {width: 25, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext4.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| } catch {} |
| let renderPassEncoder101 = commandEncoder109.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView197, |
| clearValue: { r: -859.8, g: 673.7, b: -735.8, a: 529.1, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| occlusionQuerySet: querySet8, |
| }); |
| try { |
| computePassEncoder19.setBindGroup(1, bindGroup151, [0]); |
| } catch {} |
| try { |
| computePassEncoder82.end(); |
| } catch {} |
| try { |
| renderPassEncoder14.setBindGroup(1, bindGroup41); |
| } catch {} |
| try { |
| renderPassEncoder40.setBindGroup(0, bindGroup112, new Uint32Array(279), 76, 1); |
| } catch {} |
| try { |
| renderPassEncoder73.setIndexBuffer(buffer175, 'uint16', 468, 4_354); |
| } catch {} |
| try { |
| commandEncoder110.copyBufferToTexture({ |
| /* bytesInLastRow: 48 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 16 */ |
| /* end: 1840 */ |
| offset: 1840, |
| bytesPerRow: 18176, |
| buffer: buffer43, |
| }, { |
| texture: texture174, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 1}, |
| aspect: 'all', |
| }, {width: 3, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer96, 1164, new Float32Array(10896), 1350, 352); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let bindGroupLayout34 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 122, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| sampler: { type: 'non-filtering' }, |
| }, |
| { |
| binding: 259, |
| visibility: GPUShaderStage.COMPUTE, |
| texture: { viewDimension: '2d', sampleType: 'depth', multisampled: false }, |
| }, |
| ], |
| }); |
| let bindGroup167 = device0.createBindGroup({ |
| layout: bindGroupLayout0, |
| entries: [{binding: 103, resource: textureView7}, {binding: 176, resource: textureView0}], |
| }); |
| let computePassEncoder221 = commandEncoder110.beginComputePass({}); |
| try { |
| computePassEncoder48.end(); |
| } catch {} |
| try { |
| computePassEncoder221.setPipeline(pipeline4); |
| } catch {} |
| try { |
| commandEncoder7.copyBufferToTexture({ |
| /* bytesInLastRow: 528 widthInBlocks: 66 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 600 */ |
| offset: 600, |
| bytesPerRow: 5376, |
| buffer: buffer160, |
| }, { |
| texture: texture60, |
| mipLevel: 1, |
| origin: {x: 7, y: 16, z: 0}, |
| aspect: 'all', |
| }, {width: 66, height: 13, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder7.copyTextureToTexture({ |
| texture: texture241, |
| mipLevel: 0, |
| origin: {x: 7, y: 6, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture20, |
| mipLevel: 0, |
| origin: {x: 3, y: 3, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer22, 104, new DataView(new ArrayBuffer(6171)), 2560, 136); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let videoFrame41 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420A', timestamp: 0, colorSpace: {fullRange: false, matrix: 'unspecified', primaries: 'smpteSt4281', transfer: 'gamma28curve'} }); |
| let bindGroup168 = device0.createBindGroup({ |
| label: '\u{1f7e7}\u1b46\u4113\ua206\u05ee\u0a1a\u0d9b\u{1f66b}', |
| layout: bindGroupLayout29, |
| entries: [{binding: 131, resource: {buffer: buffer26, offset: 256, size: 849}}], |
| }); |
| let computePassEncoder222 = commandEncoder7.beginComputePass({}); |
| try { |
| computePassEncoder222.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder34.setBindGroup(0, bindGroup103, new Uint32Array(2058), 152, 0); |
| } catch {} |
| try { |
| renderPassEncoder99.executeBundles([renderBundle17, renderBundle16]); |
| } catch {} |
| try { |
| renderPassEncoder84.setViewport(13.255090701590248, 0.7881194095785887, 28.11667379440744, 0.13277858363960596, 0.5914100302493642, 0.593427110482975); |
| } catch {} |
| let buffer183 = device0.createBuffer({size: 4489, usage: GPUBufferUsage.MAP_READ}); |
| try { |
| renderPassEncoder24.setIndexBuffer(buffer132, 'uint32', 288, 815); |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let imageData33 = new ImageData(20, 132); |
| let buffer184 = device0.createBuffer({size: 29388, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX}); |
| try { |
| { clearResourceUsages(device0, computePassEncoder27); computePassEncoder27.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| renderPassEncoder69.executeBundles([renderBundle6, renderBundle6, renderBundle22, renderBundle6]); |
| } catch {} |
| try { |
| renderPassEncoder18.setVertexBuffer(5, buffer145, 0, 557); |
| } catch {} |
| try { |
| buffer132.unmap(); |
| } catch {} |
| try { |
| computePassEncoder177.pushDebugGroup('\u{1f736}'); |
| } catch {} |
| try { |
| computePassEncoder177.popDebugGroup(); |
| } catch {} |
| let shaderModule20 = device0.createShaderModule({ |
| code: ` |
| enable f16; |
| |
| requires pointer_composite_access; |
| |
| diagnostic(info, xyz); |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| @group(0) @binding(11) var<storage, read_write> buffer185: T0; |
| |
| struct T0 { |
| @size(112) f0: array<atomic<i32>>, |
| } |
| |
| struct VertexOutput19 { |
| @location(7) f51: vec2i, |
| @location(14) f52: f32, |
| @location(12) f53: i32, |
| @location(15) f54: vec2u, |
| @location(6) f55: vec4f, |
| @location(13) @interpolate(flat) f56: i32, |
| @builtin(position) f57: vec4f, |
| @location(11) f58: vec4h, |
| @location(3) f59: u32, |
| @location(8) f60: f32, |
| } |
| |
| struct FragmentOutput17 { |
| @location(5) @interpolate(flat, centroid) f0: vec4i, |
| @location(0) f1: vec4f, |
| @builtin(sample_mask) f2: u32, |
| } |
| |
| alias vec3b = vec3<bool>; |
| |
| fn fn0(a0: vec4i) -> array<vec4u, 12> { |
| var out: array<vec4u, 12>; |
| let vf449: i32 = a0[u32(unconst_u32(42))]; |
| vp16[u32(unconst_u32(127))] ^= vp16[0]; |
| out[u32(unconst_u32(89))] ^= max(vec3u(unconst_u32(51), unconst_u32(24), unconst_u32(172)), vec3u(bitcast<u32>(a0[u32(unconst_u32(23))]))).gbbg; |
| let vf450: vec2f = normalize(vec2f(unconst_f32(0.7097), unconst_f32(-0.9041))); |
| out[11] = vec4u(vf450.ggrr); |
| out[u32(unconst_u32(197))] = bitcast<vec4u>(a0); |
| var vf451: vec3u = firstTrailingBit(vec3u(unconst_u32(200), unconst_u32(249), unconst_u32(363))); |
| out[u32(unconst_u32(21))] *= vec4u(u32(vf449)); |
| vf451 >>= vec3u(vf451[u32(unconst_u32(106))]); |
| return out; |
| } |
| |
| var<private> vp16: array<vec4u, 1> = array(vec4u(280, 148, 105, 62)); |
| |
| @vertex |
| fn vertex20(@location(15) @interpolate(linear, centroid) a0: f32, @location(1) a1: f16, @location(5) @interpolate(flat) a2: vec2i) -> VertexOutput19 { |
| var out: VertexOutput19; |
| var vf452 = fn0(vec4i(i32(pack4xU8Clamp(vp16[0])))); |
| var vf453: u32 = vp16[0][u32(unconst_u32(102))]; |
| var vf454 = fn0(vec4i(normalize(vec2h(unconst_f16(5419.2), unconst_f16(14101.7))).xxxx)); |
| var vf455: f32 = length(f32(unconst_f32(0.1209))); |
| fn0(vec4i(unconst_i32(321), unconst_i32(-94), unconst_i32(71), unconst_i32(88))); |
| out.f60 = a0; |
| vp16[u32(unconst_u32(222))] *= unpack4xU8(pack4xU8Clamp(vec4u(unconst_u32(108), unconst_u32(77), unconst_u32(166), unconst_u32(144)))); |
| return out; |
| } |
| |
| @fragment |
| fn fragment19() -> FragmentOutput17 { |
| var out: FragmentOutput17; |
| out.f0 |= vec4i(countLeadingZeros(vec4u(unconst_u32(51), unconst_u32(174), unconst_u32(459), unconst_u32(322)))); |
| fn0(bitcast<vec4i>(vp16[0])); |
| out.f2 <<= u32(refract(vec4f(unconst_f32(0.04771), unconst_f32(-0.4773), unconst_f32(0.3092), unconst_f32(0.02865)), vec4f(asinh(f32(unconst_f32(0.1409)))), f32(unconst_f32(0.3432)))[2]); |
| out = FragmentOutput17(vec4i(countLeadingZeros(vec4u(unconst_u32(190), unconst_u32(123), unconst_u32(213), unconst_u32(32)))), vec4f(countLeadingZeros(vec4u(unconst_u32(190), unconst_u32(123), unconst_u32(213), unconst_u32(32)))), countLeadingZeros(vec4u(unconst_u32(190), unconst_u32(123), unconst_u32(213), unconst_u32(32)))[1]); |
| var vf456 = fn0(vec4i(vp16[u32(unconst_u32(106))])); |
| vf456[u32(unconst_u32(18))] &= vf456[u32(unconst_u32(4))]; |
| var vf457: vec4h = normalize(vec4h(unconst_f16(6665.3), unconst_f16(473.3), unconst_f16(169.4), unconst_f16(5200.2))); |
| let ptr153: ptr<private, array<vec4u, 1>> = &vp16; |
| let ptr154: ptr<function, vec4u> = &vf456[11]; |
| var vf458 = fn0(vec4i(i32((*ptr153)[0][u32(unconst_u32(52))]))); |
| fn0(vec4i(unconst_i32(49), unconst_i32(97), unconst_i32(-172), unconst_i32(20))); |
| out = FragmentOutput17(vec4i(bitcast<i32>(acos(f32(unconst_f32(0.09525))))), vec4f(acos(f32(unconst_f32(0.09525)))), u32(acos(f32(unconst_f32(0.09525))))); |
| fn0(vec4i(i32((*ptr153)[0][u32(unconst_u32(283))]))); |
| fn0(vec4i(i32(vf458[u32(unconst_u32(83))][u32(unconst_u32(10))]))); |
| var vf459: f32 = acos(f32(unconst_f32(0.1370))); |
| out = FragmentOutput17(bitcast<vec4i>(vf458[11]), bitcast<vec4f>(vf458[11]), pack4xU8(vf458[11])); |
| let ptr155: ptr<function, f32> = &vf459; |
| fn0(vec4i(unconst_i32(-185), unconst_i32(364), unconst_i32(159), unconst_i32(366))); |
| var vf460: u32 = (*ptr153)[0][u32(unconst_u32(50))]; |
| let ptr156: ptr<function, vec4u> = &vf458[u32(unconst_u32(284))]; |
| out.f1 += bitcast<vec4f>((*ptr153)[u32(unconst_u32(195))]); |
| vf459 = bitcast<f32>((*ptr156)[u32(unconst_u32(110))]); |
| out.f0 = bitcast<vec4i>((*ptr153)[0]); |
| var vf461 = fn0(vec4i(unconst_i32(129), unconst_i32(83), unconst_i32(278), unconst_i32(37))); |
| return out; |
| }`, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| let externalTexture27 = device0.importExternalTexture({source: videoFrame0, colorSpace: 'srgb'}); |
| try { |
| computePassEncoder56.setBindGroup(1, bindGroup36); |
| } catch {} |
| try { |
| computePassEncoder133.setBindGroup(3, bindGroup86, new Uint32Array(1565), 15, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder7); computePassEncoder7.dispatchWorkgroups(3); }; |
| } catch {} |
| document.body.prepend(canvas2); |
| let imageData34 = new ImageData(52, 12); |
| try { |
| renderPassEncoder101.setBindGroup(2, bindGroup106); |
| } catch {} |
| try { |
| renderPassEncoder71.setBindGroup(3, bindGroup50, new Uint32Array(372), 29, 0); |
| } catch {} |
| let texture257 = device0.createTexture({ |
| size: [280, 291, 18], |
| dimension: '3d', |
| format: 'rg11b10ufloat', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView254 = texture247.createView({label: '\ufe01\u1429\u64ea', mipLevelCount: 1}); |
| try { |
| computePassEncoder86.setBindGroup(1, bindGroup27, new Uint32Array(1254), 29, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder177); computePassEncoder177.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder7); computePassEncoder7.dispatchWorkgroupsIndirect(buffer82, 100); }; |
| } catch {} |
| try { |
| renderPassEncoder73.setIndexBuffer(buffer179, 'uint32', 564, 278); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| let texture258 = device0.createTexture({ |
| size: [147, 1, 35], |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder9.setBindGroup(2, bindGroup152, new Uint32Array(333), 3, 0); |
| } catch {} |
| try { |
| renderPassEncoder6.setVertexBuffer(1, buffer159, 0); |
| } catch {} |
| let texture259 = device0.createTexture({ |
| size: [140, 145, 1], |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView255 = texture37.createView({}); |
| try { |
| computePassEncoder51.setBindGroup(1, bindGroup11); |
| } catch {} |
| try { |
| renderPassEncoder0.setVertexBuffer(7, buffer91, 0, 1_583); |
| } catch {} |
| let gpuCanvasContext7 = offscreenCanvas4.getContext('webgpu'); |
| let buffer186 = device0.createBuffer({size: 30729, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC}); |
| let textureView256 = texture56.createView({mipLevelCount: 1, baseArrayLayer: 7, arrayLayerCount: 7}); |
| try { |
| computePassEncoder139.setBindGroup(2, bindGroup91, []); |
| } catch {} |
| try { |
| renderPassEncoder97.setBindGroup(0, bindGroup160); |
| } catch {} |
| try { |
| renderPassEncoder20.setIndexBuffer(buffer91, 'uint32', 3_556, 273); |
| } catch {} |
| try { |
| renderPassEncoder45.setVertexBuffer(4, buffer139, 0, 2_125); |
| } catch {} |
| try { |
| buffer45.unmap(); |
| } catch {} |
| let promise23 = device0.queue.onSubmittedWorkDone(); |
| let imageData35 = new ImageData(8, 96); |
| let sampler163 = device0.createSampler({ |
| label: '\u0ed2\u3990\ub80e\u{1fb7d}\u190f\u328d\u0b1a\u{1fee0}\u{1f6fb}\u7342', |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 75.89, |
| lodMaxClamp: 93.70, |
| maxAnisotropy: 5, |
| }); |
| try { |
| computePassEncoder64.setBindGroup(0, bindGroup60, new Uint32Array(149), 123, 0); |
| } catch {} |
| try { |
| renderPassEncoder60.setIndexBuffer(buffer131, 'uint32', 40, 3_225); |
| } catch {} |
| document.body.prepend(canvas0); |
| let videoFrame42 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'NV12', timestamp: 0, colorSpace: {fullRange: false, matrix: 'smpte170m', primaries: 'bt2020', transfer: 'hlg'} }); |
| let videoFrame43 = new VideoFrame(videoFrame8, {timestamp: 0}); |
| try { |
| commandEncoder20.label = '\u{1f6c9}\u7753\u767b\u{1ff58}\u2f39'; |
| } catch {} |
| let texture260 = device0.createTexture({ |
| size: {width: 96, height: 1, depthOrArrayLayers: 131}, |
| mipLevelCount: 2, |
| sampleCount: 1, |
| dimension: '3d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder16.setBindGroup(0, bindGroup54); |
| } catch {} |
| try { |
| renderPassEncoder35.setBindGroup(2, bindGroup144, []); |
| } catch {} |
| let texture261 = device0.createTexture({ |
| label: '\u3d75\u0e4a\u5872\u8574\u39d3\u7d9b\ue02b\u1678\u0eef', |
| size: {width: 147, height: 1, depthOrArrayLayers: 29}, |
| dimension: '3d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder200.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder41.setVertexBuffer(4, buffer184, 0, 2_421); |
| } catch {} |
| try { |
| await promise23; |
| } catch {} |
| let texture262 = device0.createTexture({ |
| size: [110, 10, 78], |
| dimension: '3d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let sampler164 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 88.95, |
| lodMaxClamp: 89.92, |
| maxAnisotropy: 2, |
| }); |
| try { |
| renderPassEncoder30.beginOcclusionQuery(7); |
| } catch {} |
| try { |
| renderPassEncoder78.setScissorRect(9, 0, 23, 0); |
| } catch {} |
| let textureView257 = texture70.createView({}); |
| let sampler165 = device0.createSampler({ |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 97.23, |
| lodMaxClamp: 98.13, |
| maxAnisotropy: 18, |
| }); |
| try { |
| computePassEncoder153.setBindGroup(3, bindGroup82); |
| } catch {} |
| try { |
| renderPassEncoder61.beginOcclusionQuery(3); |
| } catch {} |
| try { |
| renderPassEncoder82.setIndexBuffer(buffer50, 'uint16', 222, 502); |
| } catch {} |
| let bindGroup169 = device0.createBindGroup({ |
| layout: bindGroupLayout21, |
| entries: [ |
| {binding: 190, resource: textureView168}, |
| {binding: 125, resource: externalTexture11}, |
| {binding: 606, resource: sampler112}, |
| {binding: 222, resource: {buffer: buffer49, offset: 0}}, |
| ], |
| }); |
| let buffer187 = device0.createBuffer({ |
| size: 14387, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let querySet32 = device0.createQuerySet({type: 'occlusion', count: 836}); |
| let textureView258 = texture249.createView({dimension: '2d', aspect: 'all', baseArrayLayer: 1}); |
| try { |
| renderPassEncoder61.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder38.setBlendConstant({ r: 448.7, g: -554.3, b: 132.8, a: 92.53, }); |
| } catch {} |
| let bindGroup170 = device0.createBindGroup({ |
| layout: bindGroupLayout29, |
| entries: [{binding: 131, resource: {buffer: buffer70, offset: 0, size: 5966}}], |
| }); |
| let buffer188 = device0.createBuffer({ |
| size: 18387, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM, |
| }); |
| try { |
| computePassEncoder213.setBindGroup(0, bindGroup79, new Uint32Array(1042), 33, 0); |
| } catch {} |
| let promise24 = device0.queue.onSubmittedWorkDone(); |
| let buffer189 = device0.createBuffer({ |
| size: 8820, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let textureView259 = texture28.createView({dimension: '2d-array', aspect: 'all'}); |
| try { |
| renderPassEncoder61.setBindGroup(1, bindGroup36); |
| } catch {} |
| try { |
| renderPassEncoder68.executeBundles([renderBundle4, renderBundle21, renderBundle19]); |
| } catch {} |
| try { |
| renderPassEncoder97.setBlendConstant({ r: 882.4, g: 437.8, b: 338.7, a: -213.7, }); |
| } catch {} |
| try { |
| renderPassEncoder39.setIndexBuffer(buffer85, 'uint32', 8_076, 3_397); |
| } catch {} |
| let texture263 = device0.createTexture({ |
| size: {width: 560, height: 582, depthOrArrayLayers: 1}, |
| mipLevelCount: 3, |
| format: 'rgba32float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| computePassEncoder58.setBindGroup(1, bindGroup157); |
| } catch {} |
| try { |
| renderPassEncoder95.setBindGroup(0, bindGroup89, new Uint32Array(253), 68, 0); |
| } catch {} |
| try { |
| await promise24; |
| } catch {} |
| let buffer190 = device0.createBuffer({size: 1397, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE, mappedAtCreation: false}); |
| let texture264 = device0.createTexture({ |
| label: '\u0aeb\u{1fc98}\ud5a7\u317b\u8307\uf7cf\u2b52\u{1fe5a}', |
| size: {width: 55, height: 5, depthOrArrayLayers: 22}, |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView260 = texture198.createView({format: 'rgba16uint', mipLevelCount: 1}); |
| try { |
| computePassEncoder146.setBindGroup(0, bindGroup43, new Uint32Array(1133), 20, 0); |
| } catch {} |
| try { |
| renderPassEncoder67.setVertexBuffer(7, buffer158, 0); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer97, 464, new DataView(new ArrayBuffer(25999)), 3773, 356); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture234, |
| mipLevel: 2, |
| origin: {x: 9, y: 20, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(21_128).fill(2), /* required buffer size: 21_128 */ |
| {offset: 494, bytesPerRow: 150, rowsPerImage: 86}, {width: 21, height: 52, depthOrArrayLayers: 2}); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| renderPassEncoder14.executeBundles([renderBundle1, renderBundle1, renderBundle10]); |
| } catch {} |
| document.body.append(img3); |
| let buffer191 = device0.createBuffer({ |
| size: 5776, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, |
| }); |
| let sampler166 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 76.47, |
| lodMaxClamp: 97.81, |
| maxAnisotropy: 2, |
| }); |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 96, height: 1, depthOrArrayLayers: 131} |
| */ |
| { |
| source: videoFrame32, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture18, |
| mipLevel: 0, |
| origin: {x: 5, y: 0, z: 3}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture265 = device0.createTexture({ |
| size: [36, 1, 5], |
| mipLevelCount: 3, |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder43.setBindGroup(0, bindGroup37, []); |
| } catch {} |
| try { |
| computePassEncoder27.end(); |
| } catch {} |
| try { |
| renderPassEncoder73.setBindGroup(0, bindGroup53); |
| } catch {} |
| try { |
| renderPassEncoder33.setVertexBuffer(2, buffer62, 0); |
| } catch {} |
| try { |
| commandEncoder35.copyTextureToBuffer({ |
| texture: texture144, |
| mipLevel: 0, |
| origin: {x: 38, y: 0, z: 0}, |
| aspect: 'all', |
| }, { |
| /* bytesInLastRow: 20 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 2796 */ |
| offset: 2796, |
| buffer: buffer23, |
| }, {width: 5, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| commandEncoder35.insertDebugMarker('\uaad0'); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| colorSpace: 'srgb', |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let buffer192 = device0.createBuffer({ |
| size: 10712, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| let renderPassEncoder102 = commandEncoder35.beginRenderPass({ |
| label: '\u{1fefc}\u0f4d\u{1f986}', |
| colorAttachments: [{ |
| view: textureView260, |
| depthSlice: 789, |
| clearValue: { r: -150.2, g: 736.4, b: -290.5, a: -622.7, }, |
| loadOp: 'clear', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| computePassEncoder87.setBindGroup(3, bindGroup111); |
| } catch {} |
| try { |
| renderPassEncoder30.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder73.executeBundles([renderBundle6]); |
| } catch {} |
| try { |
| renderPassEncoder52.setBlendConstant({ r: 410.1, g: -61.50, b: 231.1, a: -178.4, }); |
| } catch {} |
| try { |
| gpuCanvasContext7.unconfigure(); |
| } catch {} |
| let texture266 = device0.createTexture({ |
| size: [140, 145, 1], |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder30.setBindGroup(2, bindGroup140); |
| } catch {} |
| try { |
| renderPassEncoder25.setScissorRect(44, 0, 13, 0); |
| } catch {} |
| let promise25 = shaderModule18.getCompilationInfo(); |
| let arrayBuffer21 = buffer136.getMappedRange(0, 16); |
| let buffer193 = device0.createBuffer({ |
| size: 14051, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let renderBundleEncoder24 = device0.createRenderBundleEncoder({colorFormats: ['rgba16uint']}); |
| let renderBundle24 = renderBundleEncoder24.finish({label: '\u{1fbdf}\uea90\uc7b6\u0f65\u{1fff7}\u26bf\u087a\uae65\uc350'}); |
| let sampler167 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 14.24, |
| maxAnisotropy: 6, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder7); computePassEncoder7.dispatchWorkgroupsIndirect(buffer54, 340); }; |
| } catch {} |
| try { |
| renderPassEncoder83.setBindGroup(0, bindGroup163, new Uint32Array(132), 45, 0); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 147, height: 1, depthOrArrayLayers: 9} |
| */ |
| { |
| source: imageData23, |
| origin: { x: 8, y: 2 }, |
| flipY: true, |
| }, { |
| texture: texture110, |
| mipLevel: 1, |
| origin: {x: 95, y: 0, z: 5}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 5, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext5.unconfigure(); |
| } catch {} |
| let bindGroupLayout35 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 113, |
| visibility: GPUShaderStage.FRAGMENT, |
| buffer: { type: 'uniform', hasDynamicOffset: false }, |
| }, |
| ], |
| }); |
| let bindGroup171 = device0.createBindGroup({ |
| layout: bindGroupLayout16, |
| entries: [{binding: 0, resource: {buffer: buffer187, offset: 512, size: 2588}}], |
| }); |
| let sampler168 = device0.createSampler({ |
| label: '\u{1fa7b}\u{1f95b}', |
| addressModeU: 'mirror-repeat', |
| addressModeW: 'repeat', |
| lodMaxClamp: 81.77, |
| compare: 'less-equal', |
| }); |
| try { |
| renderPassEncoder99.setIndexBuffer(buffer157, 'uint16', 756, 794); |
| } catch {} |
| let renderBundleEncoder25 = device0.createRenderBundleEncoder({ |
| label: '\u3cb8\u032a\u{1f84c}\u01f1\u235a\u9104\u0c1e\u0018\u{1ff9c}\u7158', |
| colorFormats: ['rgba32float'], |
| }); |
| try { |
| computePassEncoder222.setBindGroup(0, bindGroup141); |
| } catch {} |
| try { |
| computePassEncoder171.setBindGroup(1, bindGroup14, new Uint32Array(484), 76, 0); |
| } catch {} |
| try { |
| renderPassEncoder60.executeBundles([renderBundle7]); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| document.body.append(canvas4); |
| let canvas5 = document.createElement('canvas'); |
| let bindGroup172 = device0.createBindGroup({ |
| label: '\u1caf\u094b\u{1ffcb}\u0b13\u1cfd', |
| layout: bindGroupLayout23, |
| entries: [{binding: 63, resource: textureView229}, {binding: 28, resource: textureView174}], |
| }); |
| let pipelineLayout13 = device0.createPipelineLayout({bindGroupLayouts: []}); |
| try { |
| computePassEncoder120.end(); |
| } catch {} |
| try { |
| renderPassEncoder45.setIndexBuffer(buffer113, 'uint16', 2_068, 3_529); |
| } catch {} |
| try { |
| renderBundleEncoder25.setBindGroup(0, bindGroup65, new Uint32Array(3443), 219, 0); |
| } catch {} |
| try { |
| buffer150.unmap(); |
| } catch {} |
| try { |
| commandEncoder162.clearBuffer(buffer80, 3340, 4800); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 295, height: 1, depthOrArrayLayers: 19} |
| */ |
| { |
| source: videoFrame13, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture110, |
| mipLevel: 0, |
| origin: {x: 100, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup173 = device0.createBindGroup({ |
| label: '\u03f7\ud50a\uaa8c\u3dd6\uba22', |
| layout: bindGroupLayout33, |
| entries: [{binding: 36, resource: {buffer: buffer127, offset: 0}}], |
| }); |
| let computePassEncoder223 = commandEncoder162.beginComputePass(); |
| let renderBundle25 = renderBundleEncoder25.finish({label: '\u0822\u11c8\uba79\u3839\u021f\u3919\u04f0\u{1f68e}\u2f8e'}); |
| try { |
| buffer42.unmap(); |
| } catch {} |
| let videoFrame44 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'RGBA', timestamp: 0, colorSpace: {fullRange: true, matrix: 'bt709', primaries: 'unspecified', transfer: 'smpte170m'} }); |
| try { |
| globalThis.someLabel = externalTexture22.label; |
| } catch {} |
| try { |
| computePassEncoder223.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder46.setBindGroup(1, bindGroup162); |
| } catch {} |
| try { |
| renderPassEncoder44.setBindGroup(0, bindGroup82, new Uint32Array(4104), 616, 0); |
| } catch {} |
| let bindGroup174 = device0.createBindGroup({ |
| layout: bindGroupLayout18, |
| entries: [{binding: 116, resource: sampler59}, {binding: 204, resource: externalTexture24}], |
| }); |
| let buffer194 = device0.createBuffer({ |
| size: 6875, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder16); computePassEncoder16.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| computePassEncoder16.end(); |
| } catch {} |
| try { |
| renderPassEncoder62.setBindGroup(1, bindGroup91, new Uint32Array(2617), 22, 0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture265, |
| mipLevel: 1, |
| origin: {x: 1, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(62).fill(218), /* required buffer size: 62 */ |
| {offset: 62}, {width: 6, height: 0, depthOrArrayLayers: 1}); |
| } catch {} |
| let gpuCanvasContext8 = canvas5.getContext('webgpu'); |
| document.body.append(canvas0); |
| let buffer195 = device0.createBuffer({ |
| label: '\u4683\u9fa7\u0cf4\u{1facb}\u0ae1\u3ccb\u{1f92a}\u385f\ue2d5', |
| size: 819, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX, |
| mappedAtCreation: false, |
| }); |
| let texture267 = device0.createTexture({size: [384, 1, 24], format: 'depth24plus', usage: GPUTextureUsage.TEXTURE_BINDING}); |
| let renderPassEncoder103 = commandEncoder20.beginRenderPass({colorAttachments: [{view: textureView38, loadOp: 'load', storeOp: 'discard'}]}); |
| let renderBundleEncoder26 = device0.createRenderBundleEncoder({ |
| label: '\u1f6f\u0744\u06b8\u0451\u{1ffca}\u1524\ua0d2\u119f\u4b45\uf124\u6849', |
| colorFormats: ['rgba16sint'], |
| depthReadOnly: true, |
| }); |
| let renderBundle26 = renderBundleEncoder26.finish({}); |
| let sampler169 = device0.createSampler({addressModeV: 'mirror-repeat', addressModeW: 'repeat', lodMinClamp: 64.14, lodMaxClamp: 69.98}); |
| try { |
| renderPassEncoder31.setIndexBuffer(buffer95, 'uint32', 228, 1_212); |
| } catch {} |
| let sampler170 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 53.52, |
| lodMaxClamp: 75.53, |
| compare: 'never', |
| maxAnisotropy: 7, |
| }); |
| try { |
| renderPassEncoder55.setVertexBuffer(4, buffer64); |
| } catch {} |
| let buffer196 = device0.createBuffer({size: 47097, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX}); |
| let renderBundleEncoder27 = device0.createRenderBundleEncoder({ |
| label: '\u01a2\uf833\u0454\u5e3f\u3103\u0ced\ue9d8\u793b\u{1fddb}\u{1f631}', |
| colorFormats: ['rgb10a2unorm'], |
| depthStencilFormat: 'depth24plus', |
| stencilReadOnly: true, |
| }); |
| let sampler171 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'nearest', |
| lodMinClamp: 24.13, |
| lodMaxClamp: 74.78, |
| }); |
| try { |
| renderBundleEncoder27.setBindGroup(0, bindGroup126, new Uint32Array(4416), 470, 0); |
| } catch {} |
| try { |
| renderBundleEncoder27.setVertexBuffer(4, buffer98); |
| } catch {} |
| let canvas6 = document.createElement('canvas'); |
| try { |
| renderPassEncoder56.setIndexBuffer(buffer187, 'uint16', 3_978, 2_650); |
| } catch {} |
| try { |
| renderPassEncoder68.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderBundleEncoder27.setIndexBuffer(buffer105, 'uint16', 364, 718); |
| } catch {} |
| let promise26 = device0.queue.onSubmittedWorkDone(); |
| let offscreenCanvas5 = new OffscreenCanvas(12, 278); |
| let bindGroupLayout36 = device0.createBindGroupLayout({ |
| entries: [ |
| {binding: 23, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}}, |
| { |
| binding: 5, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: 'cube-array', sampleType: 'uint', multisampled: false }, |
| }, |
| ], |
| }); |
| let textureView261 = texture182.createView({aspect: 'depth-only', baseArrayLayer: 6, arrayLayerCount: 1}); |
| let externalTexture28 = device0.importExternalTexture({source: videoFrame25}); |
| try { |
| computePassEncoder185.setBindGroup(2, bindGroup28, new Uint32Array(4202), 1_050, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder213); computePassEncoder213.dispatchWorkgroupsIndirect(buffer129, 356); }; |
| } catch {} |
| try { |
| renderPassEncoder92.setIndexBuffer(buffer10, 'uint16', 4_780, 426); |
| } catch {} |
| try { |
| renderBundleEncoder27.setBindGroup(0, bindGroup1, new Uint32Array(1551), 101, 0); |
| } catch {} |
| let textureView262 = texture48.createView({mipLevelCount: 1, baseArrayLayer: 0}); |
| try { |
| computePassEncoder183.setBindGroup(1, bindGroup13, new Uint32Array(4954), 521, 0); |
| } catch {} |
| try { |
| renderBundleEncoder27.setBindGroup(0, bindGroup148); |
| } catch {} |
| try { |
| renderBundleEncoder27.setBindGroup(3, bindGroup53, new Uint32Array(796), 179, 0); |
| } catch {} |
| let bindGroup175 = device0.createBindGroup({ |
| label: '\u8611\u3994\u0644\u29c8\u7562\u0954\u{1f6a8}\uecaa\u{1f685}\u0afe', |
| layout: bindGroupLayout31, |
| entries: [{binding: 362, resource: textureView64}], |
| }); |
| let renderBundle27 = renderBundleEncoder27.finish({}); |
| try { |
| computePassEncoder165.setBindGroup(2, bindGroup148, new Uint32Array(121), 12, 0); |
| } catch {} |
| try { |
| renderPassEncoder47.setBindGroup(0, bindGroup90, new Uint32Array(6026), 1_563, 0); |
| } catch {} |
| try { |
| renderPassEncoder70.executeBundles([renderBundle17]); |
| } catch {} |
| try { |
| device0.addEventListener('uncapturederror', e => { console.log('device0.uncapturederror'); console.log(e); e.label = device0.label; }); |
| } catch {} |
| try { |
| gpuCanvasContext6.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING, |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let sampler172 = device0.createSampler({ |
| label: '\u198c\u{1fdf2}\u44a8\u{1f963}\u{1fc9c}\u{1fba3}', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'clamp-to-edge', |
| lodMinClamp: 22.97, |
| lodMaxClamp: 35.15, |
| }); |
| try { |
| computePassEncoder207.setBindGroup(1, bindGroup50, new Uint32Array(1290), 56, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder213); computePassEncoder213.dispatchWorkgroupsIndirect(buffer179, 144); }; |
| } catch {} |
| try { |
| renderPassEncoder86.setBindGroup(2, bindGroup90, new Uint32Array(77), 22, 0); |
| } catch {} |
| try { |
| renderPassEncoder14.setIndexBuffer(buffer71, 'uint16', 726, 5_404); |
| } catch {} |
| try { |
| renderPassEncoder67.setVertexBuffer(7, buffer111, 0, 76); |
| } catch {} |
| let textureView263 = texture154.createView({}); |
| try { |
| computePassEncoder177.setBindGroup(1, bindGroup124, new Uint32Array(238), 8, 0); |
| } catch {} |
| try { |
| computePassEncoder219.setPipeline(pipeline5); |
| } catch {} |
| try { |
| renderPassEncoder34.setBindGroup(1, bindGroup10, new Uint32Array(1255), 25, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 96, height: 1, depthOrArrayLayers: 131} |
| */ |
| { |
| source: videoFrame23, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture18, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 16}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer197 = device0.createBuffer({size: 24432, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX}); |
| let renderBundleEncoder28 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2uint'], sampleCount: 1}); |
| let renderBundle28 = renderBundleEncoder28.finish({label: '\u1e17\u7d27\u3801\ue528\u00c8\u{1faf8}\u0c68\u03c0\u08e7\uf8a9'}); |
| try { |
| computePassEncoder195.setBindGroup(3, bindGroup62, new Uint32Array(1586), 87, 0); |
| } catch {} |
| try { |
| renderPassEncoder70.setBindGroup(1, bindGroup57, []); |
| } catch {} |
| try { |
| renderPassEncoder0.executeBundles([renderBundle5]); |
| } catch {} |
| try { |
| gpuCanvasContext6.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: ['rgba8unorm', 'rgba8unorm-srgb'], |
| colorSpace: 'srgb', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let buffer198 = device0.createBuffer({ |
| label: '\u3c29\u0a1d\uac10\u216b\u6f27\u09bd\u{1f79a}\u00ea\u46d3\uf470\u4644', |
| size: 1740, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| try { |
| computePassEncoder170.setBindGroup(2, bindGroup135); |
| } catch {} |
| let gpuCanvasContext9 = canvas6.getContext('webgpu'); |
| try { |
| textureView224.label = '\u289d\uc224\u6aee\u0f08\u0c12\u0b56\ud4e8\u{1f6ff}'; |
| } catch {} |
| try { |
| computePassEncoder173.setBindGroup(2, bindGroup52); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder43); computePassEncoder43.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| renderPassEncoder26.setBindGroup(0, bindGroup9, []); |
| } catch {} |
| try { |
| renderPassEncoder15.setBindGroup(0, bindGroup69, new Uint32Array(3290), 140, 0); |
| } catch {} |
| try { |
| renderPassEncoder14.executeBundles([renderBundle15, renderBundle15]); |
| } catch {} |
| try { |
| renderPassEncoder8.setIndexBuffer(buffer30, 'uint16', 16, 8); |
| } catch {} |
| try { |
| buffer59.unmap(); |
| } catch {} |
| let textureView264 = texture22.createView({}); |
| let sampler173 = device0.createSampler({ |
| label: '\u0135\u{1fabe}', |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| lodMinClamp: 45.32, |
| lodMaxClamp: 63.13, |
| }); |
| try { |
| renderPassEncoder100.executeBundles([renderBundle22, renderBundle24, renderBundle6, renderBundle22]); |
| } catch {} |
| try { |
| device0.lost.then(r => { console.log('device0 lost!'); console.log(r.message, r.reason); }); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let bindGroup176 = device0.createBindGroup({ |
| label: '\u{1fe9e}\u{1fe65}\u{1f906}', |
| layout: bindGroupLayout30, |
| entries: [ |
| {binding: 566, resource: externalTexture26}, |
| {binding: 577, resource: textureView197}, |
| {binding: 86, resource: {buffer: buffer198, offset: 0}}, |
| {binding: 517, resource: textureView232}, |
| ], |
| }); |
| let buffer199 = device0.createBuffer({size: 39574, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE}); |
| let querySet33 = device0.createQuerySet({type: 'occlusion', count: 93}); |
| let bindGroupLayout37 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 29, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: 'cube-array', sampleType: 'float', multisampled: false }, |
| }, |
| ], |
| }); |
| let bindGroup177 = device0.createBindGroup({ |
| label: '\u{1fe82}\u{1f8fd}\u0718\u38a2\ua0e2', |
| layout: bindGroupLayout4, |
| entries: [{binding: 511, resource: {buffer: buffer84, offset: 1024, size: 2580}}], |
| }); |
| let texture268 = device0.createTexture({ |
| size: [36, 1, 1], |
| mipLevelCount: 2, |
| format: 'rgba8snorm', |
| usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture269 = device0.createTexture({ |
| size: {width: 36, height: 1, depthOrArrayLayers: 22}, |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_SRC, |
| }); |
| try { |
| computePassEncoder164.setBindGroup(0, bindGroup108, new Uint32Array(1147), 98, 0); |
| } catch {} |
| let texture270 = device0.createTexture({ |
| label: '\ud20f\uda5c\ufd0e\ub845\u5af6\u0515\ub9b4\u0ad2\u01b1\ue322', |
| size: {width: 96, height: 1, depthOrArrayLayers: 78}, |
| format: 'rgba8unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let sampler174 = device0.createSampler({ |
| label: '\ufb91\u{1fbca}\uab5f\u5a30\u{1f730}\u6c84\u64e7', |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 68.62, |
| lodMaxClamp: 86.03, |
| maxAnisotropy: 4, |
| }); |
| try { |
| computePassEncoder74.setBindGroup(3, bindGroup65, new Uint32Array(516), 224, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder7); computePassEncoder7.dispatchWorkgroupsIndirect(buffer184, 7_676); }; |
| } catch {} |
| try { |
| renderPassEncoder35.executeBundles([renderBundle3, renderBundle3, renderBundle7]); |
| } catch {} |
| try { |
| renderPassEncoder69.setVertexBuffer(2, buffer72, 0); |
| } catch {} |
| let arrayBuffer22 = buffer5.getMappedRange(360, 12); |
| try { |
| device0.queue.writeTexture({ |
| texture: texture218, |
| mipLevel: 0, |
| origin: {x: 10, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(244).fill(10), /* required buffer size: 244 */ |
| {offset: 244, bytesPerRow: 179}, {width: 0, height: 4, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup178 = device0.createBindGroup({ |
| layout: bindGroupLayout21, |
| entries: [ |
| {binding: 606, resource: sampler83}, |
| {binding: 222, resource: {buffer: buffer119, offset: 0, size: 5139}}, |
| {binding: 190, resource: textureView168}, |
| {binding: 125, resource: externalTexture19}, |
| ], |
| }); |
| let texture271 = device0.createTexture({ |
| size: {width: 110, height: 10, depthOrArrayLayers: 63}, |
| mipLevelCount: 1, |
| format: 'r8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder7.setBindGroup(1, bindGroup5); |
| } catch {} |
| try { |
| renderPassEncoder39.setIndexBuffer(buffer20, 'uint32', 32, 0); |
| } catch {} |
| try { |
| gpuCanvasContext5.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let bindGroup179 = device0.createBindGroup({ |
| label: '\u0962\u3206\ubf66\u9cda\u3ff6\u1098\ud38e\u49a6\u77c7\u0ce4\u5f70', |
| layout: bindGroupLayout15, |
| entries: [{binding: 44, resource: externalTexture12}], |
| }); |
| let texture272 = device0.createTexture({ |
| size: [96, 1, 1], |
| sampleCount: 1, |
| format: 'rg11b10ufloat', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderBundleEncoder29 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2unorm'], depthStencilFormat: 'depth24plus', depthReadOnly: true}); |
| let sampler175 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 32.36, |
| lodMaxClamp: 36.56, |
| }); |
| try { |
| computePassEncoder159.setBindGroup(3, bindGroup127, new Uint32Array(105), 27, 0); |
| } catch {} |
| try { |
| renderPassEncoder59.setBindGroup(2, bindGroup162, new Uint32Array(4522), 493, 0); |
| } catch {} |
| try { |
| renderPassEncoder12.executeBundles([renderBundle0, renderBundle0, renderBundle16, renderBundle0, renderBundle0, renderBundle11]); |
| } catch {} |
| try { |
| renderPassEncoder45.setIndexBuffer(buffer198, 'uint16', 118, 95); |
| } catch {} |
| try { |
| renderPassEncoder93.setVertexBuffer(5, buffer65); |
| } catch {} |
| try { |
| renderBundleEncoder29.setVertexBuffer(5, buffer156, 0, 842); |
| } catch {} |
| let buffer200 = device0.createBuffer({size: 38134, usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM}); |
| let texture273 = device0.createTexture({ |
| size: [220, 20, 71], |
| mipLevelCount: 6, |
| format: 'astc-5x4-unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderBundle29 = renderBundleEncoder29.finish({}); |
| let sampler176 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| lodMinClamp: 63.13, |
| lodMaxClamp: 71.78, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder151); computePassEncoder151.dispatchWorkgroupsIndirect(buffer87, 368); }; |
| } catch {} |
| try { |
| computePassEncoder192.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder16.setBindGroup(1, bindGroup49, new Uint32Array(1768), 436, 0); |
| } catch {} |
| try { |
| renderPassEncoder53.setVertexBuffer(1, buffer195, 0); |
| } catch {} |
| let arrayBuffer23 = buffer35.getMappedRange(272, 4); |
| let gpuCanvasContext10 = offscreenCanvas5.getContext('webgpu'); |
| try { |
| adapter0.label = '\u2e3b\u{1fa2c}\udce5\ua6da\uf176'; |
| } catch {} |
| let bindGroup180 = device0.createBindGroup({layout: bindGroupLayout15, entries: [{binding: 44, resource: externalTexture13}]}); |
| let texture274 = device0.createTexture({ |
| label: '\u{1fce0}\u2909\u68e5\u2cb4\u0cef\u04c4\u{1ff04}\uf2f8\u0df7', |
| size: {width: 440, height: 40, depthOrArrayLayers: 4}, |
| mipLevelCount: 2, |
| sampleCount: 1, |
| format: 'astc-8x5-unorm-srgb', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture275 = device0.createTexture({ |
| label: '\u{1f782}\u{1fa45}\u0c38\ua182\u{1f741}', |
| size: {width: 147, height: 1, depthOrArrayLayers: 26}, |
| mipLevelCount: 3, |
| dimension: '2d', |
| format: 'depth24plus', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| let textureView265 = texture165.createView({mipLevelCount: 1}); |
| try { |
| renderPassEncoder54.executeBundles([renderBundle28]); |
| } catch {} |
| try { |
| device0.pushErrorScope('out-of-memory'); |
| } catch {} |
| await gc(); |
| let imageData36 = new ImageData(104, 24); |
| let texture276 = device0.createTexture({ |
| size: [48, 1, 1], |
| mipLevelCount: 2, |
| sampleCount: 1, |
| format: 'r8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder44.setBindGroup(2, bindGroup126); |
| } catch {} |
| try { |
| renderPassEncoder78.setBindGroup(1, bindGroup118, new Uint32Array(763), 1, 0); |
| } catch {} |
| let texture277 = device0.createTexture({ |
| size: {width: 64, height: 64, depthOrArrayLayers: 22}, |
| sampleCount: 1, |
| format: 'r8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let renderBundleEncoder30 = device0.createRenderBundleEncoder({colorFormats: ['rgba16sint'], stencilReadOnly: true}); |
| try { |
| buffer112.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext9.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| colorSpace: 'display-p3', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let videoFrame45 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420', timestamp: 0, colorSpace: {fullRange: false, matrix: 'bt2020-cl', primaries: 'bt470bg', transfer: 'bt1361ExtendedColourGamut'} }); |
| let buffer201 = device0.createBuffer({size: 2087, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX}); |
| let textureView266 = texture277.createView({label: '\u3fb9\u{1f6f3}\u0b49\u{1fb14}', dimension: 'cube-array', arrayLayerCount: 6}); |
| let texture278 = device0.createTexture({ |
| size: [560], |
| mipLevelCount: 1, |
| dimension: '1d', |
| format: 'rgba32float', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder81.setBindGroup(0, bindGroup19); |
| } catch {} |
| try { |
| computePassEncoder7.setBindGroup(3, bindGroup5, new Uint32Array(1543), 938, 0); |
| } catch {} |
| try { |
| renderPassEncoder31.setBindGroup(3, bindGroup162); |
| } catch {} |
| try { |
| renderPassEncoder26.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder79.setVertexBuffer(3, buffer24); |
| } catch {} |
| try { |
| renderBundleEncoder30.setBindGroup(2, bindGroup106); |
| } catch {} |
| try { |
| renderBundleEncoder30.setBindGroup(0, bindGroup99, new Uint32Array(1914), 1_914, 0); |
| } catch {} |
| try { |
| renderBundleEncoder30.setVertexBuffer(7, buffer151); |
| } catch {} |
| document.body.append(canvas4); |
| let imageBitmap5 = await createImageBitmap(imageData28); |
| let texture279 = device0.createTexture({ |
| size: [192, 1, 262], |
| dimension: '3d', |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| let renderBundle30 = renderBundleEncoder30.finish({label: '\ue3dd\u{1ffa4}\u{1fa93}\u05fb'}); |
| try { |
| renderPassEncoder96.setBindGroup(2, bindGroup172, new Uint32Array(1463), 171, 0); |
| } catch {} |
| try { |
| renderPassEncoder47.beginOcclusionQuery(89); |
| } catch {} |
| try { |
| renderPassEncoder59.setIndexBuffer(buffer112, 'uint16', 314, 3_031); |
| } catch {} |
| try { |
| renderPassEncoder7.setVertexBuffer(0, buffer43); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer93, 596, new DataView(new ArrayBuffer(24696)), 4086, 92); |
| } catch {} |
| let textureView267 = texture32.createView({dimension: '2d-array'}); |
| let sampler177 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 92.67, |
| lodMaxClamp: 97.32, |
| }); |
| try { |
| renderPassEncoder47.endOcclusionQuery(); |
| } catch {} |
| let promise27 = shaderModule9.getCompilationInfo(); |
| let canvas7 = document.createElement('canvas'); |
| try { |
| computePassEncoder197.setBindGroup(3, bindGroup140); |
| } catch {} |
| try { |
| computePassEncoder119.setBindGroup(0, bindGroup39, new Uint32Array(739), 163, 0); |
| } catch {} |
| try { |
| computePassEncoder43.end(); |
| } catch {} |
| try { |
| renderPassEncoder51.setBlendConstant({ r: -679.4, g: -33.58, b: -940.9, a: 415.0, }); |
| } catch {} |
| try { |
| renderPassEncoder13.setViewport(34.321888928785384, 0.9324577415569325, 45.609799181336356, 0.033423630141037594, 0.3542933338189449, 0.6087211310512131); |
| } catch {} |
| try { |
| commandEncoder61.copyBufferToTexture({ |
| /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 8 */ |
| /* end: 3112 */ |
| offset: 3112, |
| buffer: buffer174, |
| }, { |
| texture: texture159, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture126, |
| mipLevel: 0, |
| origin: {x: 7, y: 0, z: 5}, |
| aspect: 'all', |
| }, new Uint8Array(57_654).fill(96), /* required buffer size: 57_654 */ |
| {offset: 54, bytesPerRow: 384, rowsPerImage: 25}, {width: 89, height: 0, depthOrArrayLayers: 7}); |
| } catch {} |
| let bindGroup181 = device0.createBindGroup({ |
| layout: bindGroupLayout30, |
| entries: [ |
| {binding: 566, resource: externalTexture20}, |
| {binding: 86, resource: {buffer: buffer128, offset: 2048}}, |
| {binding: 517, resource: textureView233}, |
| {binding: 577, resource: textureView210}, |
| ], |
| }); |
| let buffer202 = device0.createBuffer({ |
| size: 1570, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM, |
| }); |
| let renderPassEncoder104 = commandEncoder61.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView147, |
| clearValue: { r: 580.4, g: 34.99, b: 903.9, a: 168.2, }, |
| loadOp: 'clear', |
| storeOp: 'discard', |
| }], |
| }); |
| let sampler178 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeW: 'clamp-to-edge', |
| mipmapFilter: 'nearest', |
| lodMaxClamp: 46.92, |
| }); |
| try { |
| computePassEncoder106.setBindGroup(0, bindGroup16); |
| } catch {} |
| try { |
| renderPassEncoder74.setPipeline(pipeline1); |
| } catch {} |
| try { |
| renderPassEncoder61.setVertexBuffer(4, buffer170); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let gpuCanvasContext11 = canvas7.getContext('webgpu'); |
| let texture280 = device0.createTexture({ |
| size: {width: 55, height: 5, depthOrArrayLayers: 14}, |
| mipLevelCount: 2, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView268 = texture63.createView({dimension: '2d-array'}); |
| let renderBundleEncoder31 = device0.createRenderBundleEncoder({colorFormats: ['rgb10a2uint'], sampleCount: 4, depthReadOnly: true}); |
| let renderBundle31 = renderBundleEncoder31.finish({label: '\uf806\u{1fe33}'}); |
| try { |
| computePassEncoder95.setBindGroup(1, bindGroup65); |
| } catch {} |
| try { |
| buffer2.unmap(); |
| } catch {} |
| try { |
| await buffer162.mapAsync(GPUMapMode.READ, 0, 160); |
| } catch {} |
| let offscreenCanvas6 = new OffscreenCanvas(185, 8); |
| let textureView269 = texture12.createView({dimension: '2d-array'}); |
| try { |
| computePassEncoder99.setBindGroup(0, bindGroup28); |
| } catch {} |
| try { |
| await buffer97.mapAsync(GPUMapMode.READ, 0, 396); |
| } catch {} |
| let imageBitmap6 = await createImageBitmap(imageBitmap1); |
| let sampler179 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 58.08, |
| lodMaxClamp: 74.06, |
| maxAnisotropy: 2, |
| }); |
| try { |
| computePassEncoder129.setBindGroup(3, bindGroup171); |
| } catch {} |
| try { |
| renderPassEncoder61.beginOcclusionQuery(2); |
| } catch {} |
| try { |
| renderPassEncoder28.setVertexBuffer(4, buffer95, 3_048); |
| } catch {} |
| let gpuCanvasContext12 = offscreenCanvas6.getContext('webgpu'); |
| document.body.prepend(img1); |
| let texture281 = device0.createTexture({ |
| size: {width: 96, height: 1, depthOrArrayLayers: 131}, |
| dimension: '3d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| }); |
| try { |
| computePassEncoder182.setBindGroup(2, bindGroup160); |
| } catch {} |
| try { |
| renderPassEncoder100.executeBundles([renderBundle24, renderBundle24, renderBundle6]); |
| } catch {} |
| try { |
| renderPassEncoder68.setIndexBuffer(buffer82, 'uint32', 352, 24); |
| } catch {} |
| try { |
| device0.pushErrorScope('internal'); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture216, |
| mipLevel: 0, |
| origin: {x: 1, y: 0, z: 26}, |
| aspect: 'all', |
| }, new Uint8Array(26_284).fill(214), /* required buffer size: 26_284 */ |
| {offset: 76, bytesPerRow: 39, rowsPerImage: 6}, {width: 2, height: 0, depthOrArrayLayers: 113}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 73, height: 1, depthOrArrayLayers: 32} |
| */ |
| { |
| source: imageData7, |
| origin: { x: 2, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture138, |
| mipLevel: 0, |
| origin: {x: 5, y: 0, z: 2}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 23, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| requestAnimationFrame(startTime => globalThis.startTime=startTime); |
| let videoFrame46 = videoFrame28.clone(); |
| try { |
| computePassEncoder140.setBindGroup(3, bindGroup119, new Uint32Array(841), 120, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder106); computePassEncoder106.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| computePassEncoder7.end(); |
| } catch {} |
| try { |
| computePassEncoder87.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder0.end(); |
| } catch {} |
| try { |
| renderPassEncoder61.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder6.executeBundles([renderBundle7, renderBundle7, renderBundle11]); |
| } catch {} |
| try { |
| renderPassEncoder95.setScissorRect(81, 25, 31, 68); |
| } catch {} |
| try { |
| renderPassEncoder77.setVertexBuffer(4, buffer6); |
| } catch {} |
| let bindGroupLayout38 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 769, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, |
| externalTexture: {}, |
| }, |
| ], |
| }); |
| let buffer203 = device0.createBuffer({ |
| size: 2384, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let textureView270 = texture277.createView({dimension: 'cube-array', arrayLayerCount: 6}); |
| let texture282 = device0.createTexture({ |
| size: {width: 96, height: 1, depthOrArrayLayers: 3}, |
| format: 'depth24plus', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| viewFormats: [], |
| }); |
| let computePassEncoder224 = commandEncoder0.beginComputePass({}); |
| let sampler180 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 7.550, |
| lodMaxClamp: 33.21, |
| maxAnisotropy: 4, |
| }); |
| try { |
| computePassEncoder224.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder67.setBindGroup(1, bindGroup106, []); |
| } catch {} |
| try { |
| renderPassEncoder102.setIndexBuffer(buffer59, 'uint16', 96, 382); |
| } catch {} |
| try { |
| renderPassEncoder32.setVertexBuffer(1, buffer148, 128); |
| } catch {} |
| try { |
| commandEncoder12.copyBufferToTexture({ |
| /* bytesInLastRow: 144 widthInBlocks: 36 aspectSpecificFormat.texelBlockSize: 4 */ |
| /* end: 292 */ |
| offset: 292, |
| bytesPerRow: 1536, |
| buffer: buffer45, |
| }, { |
| texture: texture191, |
| mipLevel: 2, |
| origin: {x: 27, y: 12, z: 0}, |
| aspect: 'all', |
| }, {width: 36, height: 8, depthOrArrayLayers: 0}); |
| } catch {} |
| let computePassEncoder225 = commandEncoder12.beginComputePass({label: '\ub6d0\u00ee\ub4bf\ud664\uadaf\u5148\u5734\u{1fd03}\u{1fae0}'}); |
| try { |
| computePassEncoder197.setBindGroup(1, bindGroup39, new Uint32Array(3261), 1_337, 0); |
| } catch {} |
| try { |
| renderPassEncoder51.setIndexBuffer(buffer198, 'uint16', 380, 210); |
| } catch {} |
| try { |
| renderPassEncoder96.setVertexBuffer(2, buffer109, 112, 855); |
| } catch {} |
| let bindGroup182 = device0.createBindGroup({ |
| layout: bindGroupLayout3, |
| entries: [{binding: 58, resource: {buffer: buffer99, offset: 4096}}, {binding: 225, resource: textureView13}], |
| }); |
| let textureView271 = texture93.createView({baseArrayLayer: 0}); |
| try { |
| computePassEncoder76.setBindGroup(3, bindGroup170, new Uint32Array(477), 26, 0); |
| } catch {} |
| try { |
| renderPassEncoder83.setVertexBuffer(7, buffer6, 0, 262); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture80, |
| mipLevel: 0, |
| origin: {x: 0, y: 8, z: 10}, |
| aspect: 'all', |
| }, new Uint8Array(351).fill(39), /* required buffer size: 351 */ |
| {offset: 351}, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let textureView272 = texture15.createView({aspect: 'all'}); |
| let sampler181 = device0.createSampler({ |
| label: '\u098f\u8bb2\u{1fbbf}\u{1f85d}\u01f0\u6562\ubb9e', |
| addressModeU: 'repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 84.66, |
| lodMaxClamp: 87.25, |
| maxAnisotropy: 7, |
| }); |
| try { |
| computePassEncoder221.setBindGroup(2, bindGroup96, []); |
| } catch {} |
| try { |
| computePassEncoder225.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder82.setBindGroup(2, bindGroup88); |
| } catch {} |
| try { |
| renderPassEncoder71.beginOcclusionQuery(89); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer187, 2688, new Float32Array(14606), 4603, 680); |
| } catch {} |
| try { |
| gpuCanvasContext3.unconfigure(); |
| } catch {} |
| let buffer204 = device0.createBuffer({size: 15479, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE}); |
| let querySet34 = device0.createQuerySet({type: 'occlusion', count: 97}); |
| let textureView273 = texture276.createView({dimension: '2d-array', mipLevelCount: 1}); |
| try { |
| renderPassEncoder76.setIndexBuffer(buffer157, 'uint16', 316, 177); |
| } catch {} |
| let offscreenCanvas7 = new OffscreenCanvas(9, 33); |
| let buffer205 = device0.createBuffer({ |
| size: 6127, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| try { |
| computePassEncoder139.setBindGroup(3, bindGroup61, new Uint32Array(372), 14, 0); |
| } catch {} |
| try { |
| renderPassEncoder49.setBindGroup(1, bindGroup116, new Uint32Array(5339), 631, 0); |
| } catch {} |
| try { |
| device0.lost.then(({reason, message}) => { console.log('device0 lost!'); console.log(message, reason); }); |
| } catch {} |
| try { |
| renderPassEncoder98.pushDebugGroup('\u3d00'); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 560, height: 582, depthOrArrayLayers: 1} |
| */ |
| { |
| source: imageData22, |
| origin: { x: 5, y: 2 }, |
| flipY: true, |
| }, { |
| texture: texture191, |
| mipLevel: 0, |
| origin: {x: 81, y: 2, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 12, depthOrArrayLayers: 0}); |
| } catch {} |
| let gpuCanvasContext13 = offscreenCanvas7.getContext('webgpu'); |
| try { |
| await promise25; |
| } catch {} |
| let img5 = await imageWithData(3, 5, '#10101010', '#20202020'); |
| let bindGroup183 = device0.createBindGroup({ |
| layout: bindGroupLayout0, |
| entries: [{binding: 176, resource: textureView158}, {binding: 103, resource: textureView3}], |
| }); |
| let renderBundleEncoder32 = device0.createRenderBundleEncoder({label: '\ud69b\u450b\u04e7\u0e9f', colorFormats: ['rgba16uint'], stencilReadOnly: true}); |
| let renderBundle32 = renderBundleEncoder32.finish({}); |
| try { |
| computePassEncoder180.setBindGroup(1, bindGroup70); |
| } catch {} |
| try { |
| renderPassEncoder12.setBindGroup(3, bindGroup172, new Uint32Array(2348), 5, 0); |
| } catch {} |
| try { |
| renderPassEncoder71.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder98.popDebugGroup(); |
| } catch {} |
| let bindGroupLayout39 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 164, |
| visibility: GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d-array', sampleType: 'uint', multisampled: false }, |
| }, |
| ], |
| }); |
| let buffer206 = device0.createBuffer({ |
| size: 18865, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX, |
| }); |
| let textureView274 = texture219.createView({}); |
| let texture283 = device0.createTexture({ |
| size: {width: 220, height: 20, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'depth24plus', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView275 = texture124.createView({}); |
| let sampler182 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'mirror-repeat', |
| lodMinClamp: 81.34, |
| lodMaxClamp: 83.95, |
| }); |
| try { |
| computePassEncoder81.setBindGroup(1, bindGroup162, []); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder222); computePassEncoder222.dispatchWorkgroupsIndirect(buffer70, 5_440); }; |
| } catch {} |
| try { |
| computePassEncoder151.end(); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer6, 48, new BigUint64Array(10074), 679, 28); |
| } catch {} |
| let bindGroup184 = device0.createBindGroup({ |
| layout: bindGroupLayout30, |
| entries: [ |
| {binding: 566, resource: externalTexture22}, |
| {binding: 577, resource: textureView197}, |
| {binding: 86, resource: {buffer: buffer85, offset: 256, size: 2320}}, |
| {binding: 517, resource: textureView232}, |
| ], |
| }); |
| let buffer207 = device0.createBuffer({size: 14611, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE}); |
| let textureView276 = texture164.createView({}); |
| let computePassEncoder226 = commandEncoder189.beginComputePass({}); |
| try { |
| computePassEncoder103.setBindGroup(3, bindGroup5); |
| } catch {} |
| try { |
| computePassEncoder213.end(); |
| } catch {} |
| try { |
| renderPassEncoder88.setVertexBuffer(2, buffer67, 0); |
| } catch {} |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| let computePassEncoder227 = commandEncoder83.beginComputePass({}); |
| try { |
| renderPassEncoder47.setBindGroup(2, bindGroup26, new Uint32Array(874), 166, 0); |
| } catch {} |
| try { |
| renderPassEncoder64.setVertexBuffer(5, buffer98, 304, 722); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let bindGroup185 = device0.createBindGroup({ |
| layout: bindGroupLayout17, |
| entries: [{binding: 78, resource: sampler101}, {binding: 113, resource: textureView109}], |
| }); |
| let buffer208 = device0.createBuffer({ |
| size: 4861, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let textureView277 = texture247.createView({}); |
| try { |
| computePassEncoder49.setBindGroup(1, bindGroup113, new Uint32Array(490), 73, 0); |
| } catch {} |
| try { |
| renderPassEncoder65.setViewport(1.1399012560514805, 0.4273462549858461, 36.86398102250775, 0.2979116630516998, 0.11785049518388468, 0.7154620367500557); |
| } catch {} |
| try { |
| renderPassEncoder83.setPipeline(pipeline1); |
| } catch {} |
| try { |
| globalThis.someLabel = texture42.label; |
| } catch {} |
| let bindGroup186 = device0.createBindGroup({ |
| label: '\u04e0\u{1fb91}\u92cf\u0dbe\u{1f728}\u0a7e\u0e81\u{1fdb7}\u2fe6\u{1f83f}\u{1fa9d}', |
| layout: bindGroupLayout16, |
| entries: [{binding: 0, resource: {buffer: buffer200, offset: 0, size: 3676}}], |
| }); |
| try { |
| computePassEncoder202.setBindGroup(0, bindGroup95, new Uint32Array(626), 101, 0); |
| } catch {} |
| try { |
| renderPassEncoder101.setBindGroup(0, bindGroup142); |
| } catch {} |
| try { |
| buffer87.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext5.unconfigure(); |
| } catch {} |
| let textureView278 = texture202.createView({}); |
| try { |
| computePassEncoder217.setBindGroup(2, bindGroup89, new Uint32Array(1476), 106, 0); |
| } catch {} |
| try { |
| renderPassEncoder65.setBindGroup(0, bindGroup114); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture95, |
| mipLevel: 0, |
| origin: {x: 7, y: 0, z: 4}, |
| aspect: 'all', |
| }, new Uint8Array(22_806).fill(90), /* required buffer size: 22_806 */ |
| {offset: 82, bytesPerRow: 26, rowsPerImage: 46}, {width: 0, height: 0, depthOrArrayLayers: 20}); |
| } catch {} |
| try { |
| await promise27; |
| } catch {} |
| let imageData37 = new ImageData(32, 16); |
| let sampler183 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 32.20, |
| lodMaxClamp: 46.71, |
| }); |
| try { |
| computePassEncoder90.setBindGroup(2, bindGroup150, new Uint32Array(296), 90, 0); |
| } catch {} |
| try { |
| renderPassEncoder55.setBindGroup(1, bindGroup158, new Uint32Array(445), 86, 0); |
| } catch {} |
| try { |
| renderPassEncoder50.executeBundles([renderBundle0, renderBundle26]); |
| } catch {} |
| try { |
| renderPassEncoder76.setIndexBuffer(buffer192, 'uint16', 92, 864); |
| } catch {} |
| try { |
| gpuCanvasContext9.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer81, 1284, new DataView(new ArrayBuffer(20431)), 5781, 1208); |
| } catch {} |
| try { |
| renderPassEncoder30.setBindGroup(0, bindGroup84, new Uint32Array(135), 8, 0); |
| } catch {} |
| try { |
| renderPassEncoder15.setScissorRect(5, 2, 3, 15); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer6, 80, new Float32Array(32394), 526, 80); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture49, |
| mipLevel: 0, |
| origin: {x: 47, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(174).fill(13), /* required buffer size: 174 */ |
| {offset: 174}, {width: 23, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| externalTexture14.label = '\u8ddd\udf8a\u3503'; |
| } catch {} |
| let textureView279 = texture84.createView({format: 'rgb10a2uint', mipLevelCount: 1, baseArrayLayer: 0}); |
| try { |
| renderPassEncoder96.setIndexBuffer(buffer201, 'uint16', 224, 237); |
| } catch {} |
| try { |
| if (!arrayBuffer22.detached) { new Uint8Array(arrayBuffer22).fill(0x55); }; |
| } catch {} |
| let buffer209 = device0.createBuffer({ |
| size: 11749, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, |
| }); |
| let texture284 = device0.createTexture({ |
| label: '\u0b98\ufcab\ub8cc\u6a6e\uef75\u422d\uf033\ub20d\u91f9\u0082', |
| size: {width: 220}, |
| dimension: '1d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView280 = texture130.createView({label: '\u4fd8\u0a72\u0afc\u7080', dimension: '2d', mipLevelCount: 1, baseArrayLayer: 2}); |
| let renderBundleEncoder33 = device0.createRenderBundleEncoder({colorFormats: ['rgba16sint'], depthReadOnly: true, stencilReadOnly: true}); |
| let sampler184 = device0.createSampler({ |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 7.902, |
| lodMaxClamp: 29.62, |
| }); |
| try { |
| computePassEncoder177.end(); |
| } catch {} |
| try { |
| computePassEncoder227.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderPassEncoder96.setBindGroup(2, bindGroup139); |
| } catch {} |
| try { |
| renderPassEncoder84.end(); |
| } catch {} |
| try { |
| renderPassEncoder99.setVertexBuffer(4, buffer51, 652, 285); |
| } catch {} |
| try { |
| commandEncoder229.clearBuffer(buffer49); |
| } catch {} |
| let bindGroup187 = device0.createBindGroup({ |
| layout: bindGroupLayout32, |
| entries: [ |
| {binding: 157, resource: textureView57}, |
| {binding: 143, resource: textureView258}, |
| {binding: 193, resource: textureView22}, |
| {binding: 911, resource: textureView239}, |
| {binding: 178, resource: textureView246}, |
| {binding: 18, resource: textureView57}, |
| ], |
| }); |
| let computePassEncoder228 = commandEncoder220.beginComputePass({}); |
| let renderBundle33 = renderBundleEncoder33.finish({label: '\u0b30\ufcab\u0d5e\ued34\u2314\u{1fc81}'}); |
| try { |
| computePassEncoder222.end(); |
| } catch {} |
| try { |
| renderPassEncoder24.executeBundles([renderBundle1, renderBundle1]); |
| } catch {} |
| try { |
| device0.pushErrorScope('out-of-memory'); |
| } catch {} |
| let renderPassEncoder105 = commandEncoder7.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView197, |
| clearValue: { r: 110.3, g: 655.7, b: 200.9, a: -660.6, }, |
| loadOp: 'load', |
| storeOp: 'store', |
| }], |
| }); |
| try { |
| computePassEncoder54.setBindGroup(0, bindGroup25, new Uint32Array(597), 13, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder106); computePassEncoder106.dispatchWorkgroups(1); }; |
| } catch {} |
| try { |
| renderPassEncoder45.setBindGroup(0, bindGroup40); |
| } catch {} |
| let texture285 = device0.createTexture({ |
| size: [110, 10, 43], |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let texture286 = gpuCanvasContext4.getCurrentTexture(); |
| let computePassEncoder229 = commandEncoder229.beginComputePass(); |
| let sampler185 = device0.createSampler({addressModeV: 'repeat', addressModeW: 'repeat', lodMinClamp: 46.24, lodMaxClamp: 49.65}); |
| try { |
| computePassEncoder76.setBindGroup(2, bindGroup43); |
| } catch {} |
| try { |
| computePassEncoder122.setBindGroup(2, bindGroup138, new Uint32Array(424), 111, 0); |
| } catch {} |
| try { |
| renderPassEncoder78.setBindGroup(1, bindGroup103, new Uint32Array(44), 5, 0); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture216, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 7}, |
| aspect: 'all', |
| }, new Uint8Array(576_586).fill(12), /* required buffer size: 576_586 */ |
| {offset: 269, bytesPerRow: 119, rowsPerImage: 167}, {width: 0, height: 0, depthOrArrayLayers: 30}); |
| } catch {} |
| canvas5.height = 2759; |
| let textureView281 = texture110.createView({mipLevelCount: 1, baseArrayLayer: 0}); |
| try { |
| computePassEncoder106.end(); |
| } catch {} |
| try { |
| computePassEncoder226.setPipeline(pipeline6); |
| } catch {} |
| try { |
| renderPassEncoder74.setStencilReference(85); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 192, height: 1, depthOrArrayLayers: 262} |
| */ |
| { |
| source: imageData9, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture279, |
| mipLevel: 0, |
| origin: {x: 4, y: 0, z: 25}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext5.unconfigure(); |
| } catch {} |
| let computePassEncoder230 = commandEncoder146.beginComputePass({}); |
| try { |
| computePassEncoder158.setBindGroup(2, bindGroup56, []); |
| } catch {} |
| try { |
| computePassEncoder76.setBindGroup(0, bindGroup74, new Uint32Array(232), 21, 0); |
| } catch {} |
| try { |
| computePassEncoder230.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder50.setIndexBuffer(buffer13, 'uint16', 510, 76); |
| } catch {} |
| try { |
| renderPassEncoder104.setPipeline(pipeline1); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| try { |
| if (!arrayBuffer23.detached) { new Uint8Array(arrayBuffer23).fill(0x55); }; |
| } catch {} |
| let pipelineLayout14 = device0.createPipelineLayout({bindGroupLayouts: []}); |
| let querySet35 = device0.createQuerySet({type: 'occlusion', count: 465}); |
| try { |
| computePassEncoder146.setBindGroup(0, bindGroup143); |
| } catch {} |
| try { |
| computePassEncoder228.setPipeline(pipeline2); |
| } catch {} |
| try { |
| renderPassEncoder100.setVertexBuffer(0, buffer83, 3_684, 4_234); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| try { |
| if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55); }; |
| } catch {} |
| let texture287 = device0.createTexture({ |
| size: [280], |
| dimension: '1d', |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView282 = texture138.createView({label: '\u9f85\ueb7f\u72c8\u641a', baseArrayLayer: 4, arrayLayerCount: 3}); |
| let sampler186 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'nearest', |
| lodMinClamp: 46.12, |
| lodMaxClamp: 97.66, |
| }); |
| try { |
| renderPassEncoder20.setBindGroup(1, bindGroup43); |
| } catch {} |
| try { |
| renderPassEncoder54.beginOcclusionQuery(25); |
| } catch {} |
| try { |
| renderPassEncoder54.endOcclusionQuery(); |
| } catch {} |
| try { |
| await promise26; |
| } catch {} |
| try { |
| renderPassEncoder59.setBindGroup(0, bindGroup33, new Uint32Array(1065), 208, 0); |
| } catch {} |
| try { |
| renderPassEncoder56.setIndexBuffer(buffer42, 'uint16', 270, 193); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| let bindGroup188 = device0.createBindGroup({ |
| layout: bindGroupLayout22, |
| entries: [ |
| {binding: 337, resource: textureView35}, |
| {binding: 178, resource: textureView108}, |
| {binding: 298, resource: {buffer: buffer50, offset: 256, size: 328}}, |
| {binding: 44, resource: {buffer: buffer132, offset: 0, size: 488}}, |
| {binding: 75, resource: externalTexture9}, |
| {binding: 244, resource: externalTexture1}, |
| {binding: 132, resource: {buffer: buffer128, offset: 2816, size: 212}}, |
| {binding: 31, resource: textureView184}, |
| {binding: 265, resource: sampler131}, |
| {binding: 304, resource: textureView180}, |
| {binding: 29, resource: sampler51}, |
| {binding: 4, resource: {buffer: buffer175, offset: 512, size: 443}}, |
| {binding: 159, resource: {buffer: buffer100, offset: 256, size: 20}}, |
| ], |
| }); |
| let renderBundleEncoder34 = device0.createRenderBundleEncoder({ |
| label: '\u0b9f\u1d92\uc467\u0cc6\u0658\u9bbe\u0b80\u0b5e', |
| colorFormats: ['rgba16sint'], |
| depthReadOnly: true, |
| stencilReadOnly: true, |
| }); |
| try { |
| computePassEncoder109.setBindGroup(1, bindGroup117, new Uint32Array(423), 6, 0); |
| } catch {} |
| try { |
| computePassEncoder229.setPipeline(pipeline7); |
| } catch {} |
| try { |
| renderPassEncoder69.setBindGroup(3, bindGroup4); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| let pipelineLayout15 = device0.createPipelineLayout({label: '\u0da6\ub4b5\u8c77\u0ffe\u{1f6ee}\ud668', bindGroupLayouts: []}); |
| let querySet36 = device0.createQuerySet({type: 'occlusion', count: 199}); |
| let renderBundle34 = renderBundleEncoder34.finish({}); |
| try { |
| computePassEncoder225.setBindGroup(1, bindGroup75); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder76); computePassEncoder76.dispatchWorkgroups(1, 1); }; |
| } catch {} |
| try { |
| renderPassEncoder105.setIndexBuffer(buffer126, 'uint16', 2_416, 6); |
| } catch {} |
| try { |
| renderPassEncoder74.setVertexBuffer(3, buffer192); |
| } catch {} |
| try { |
| device0.queue.submit([]); |
| } catch {} |
| let promise28 = device0.createRenderPipelineAsync({ |
| layout: pipelineLayout8, |
| fragment: { |
| module: shaderModule13, |
| entryPoint: 'fragment9', |
| targets: [{format: 'rgba16uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN}], |
| }, |
| vertex: { |
| module: shaderModule18, |
| constants: {override12: 0}, |
| buffers: [ |
| { |
| arrayStride: 64, |
| stepMode: 'instance', |
| attributes: [ |
| {format: 'sint32x3', offset: 0, shaderLocation: 13}, |
| {format: 'uint16x2', offset: 36, shaderLocation: 12}, |
| {format: 'float32', offset: 8, shaderLocation: 1}, |
| {format: 'float32x3', offset: 8, shaderLocation: 14}, |
| {format: 'sint32x2', offset: 24, shaderLocation: 15}, |
| {format: 'sint32x2', offset: 0, shaderLocation: 11}, |
| {format: 'sint32x3', offset: 4, shaderLocation: 6}, |
| ], |
| }, |
| { |
| arrayStride: 52, |
| stepMode: 'instance', |
| attributes: [{format: 'unorm16x4', offset: 0, shaderLocation: 2}], |
| }, |
| ], |
| }, |
| }); |
| document.body.append(img0); |
| let buffer210 = device0.createBuffer({ |
| size: 9782, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, |
| }); |
| let texture288 = device0.createTexture({ |
| label: '\u96c1\u3df0\u5a3d\u014d', |
| size: [295], |
| dimension: '1d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder20.setStencilReference(522); |
| } catch {} |
| try { |
| renderPassEncoder94.setVertexBuffer(3, buffer115, 0, 54); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture113, |
| mipLevel: 0, |
| origin: {x: 10, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(158).fill(33), /* required buffer size: 158 */ |
| {offset: 158, bytesPerRow: 214}, {width: 38, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let imageData38 = new ImageData(8, 116); |
| let pipelineLayout16 = device0.createPipelineLayout({bindGroupLayouts: []}); |
| let sampler187 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| lodMinClamp: 99.12, |
| lodMaxClamp: 99.53, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder76); computePassEncoder76.dispatchWorkgroupsIndirect(buffer210, 560); }; |
| } catch {} |
| try { |
| renderPassEncoder55.setIndexBuffer(buffer52, 'uint32', 236, 224); |
| } catch {} |
| try { |
| renderPassEncoder42.setPipeline(pipeline1); |
| } catch {} |
| try { |
| buffer3.unmap(); |
| } catch {} |
| let texture289 = device0.createTexture({size: [96, 1, 37], format: 'rgb10a2unorm', usage: GPUTextureUsage.TEXTURE_BINDING}); |
| let textureView283 = texture273.createView({dimension: '2d', baseMipLevel: 3, mipLevelCount: 1, baseArrayLayer: 16}); |
| try { |
| computePassEncoder62.setBindGroup(3, bindGroup86); |
| } catch {} |
| try { |
| computePassEncoder98.setBindGroup(0, bindGroup121, new Uint32Array(605), 106, 0); |
| } catch {} |
| try { |
| renderPassEncoder101.setIndexBuffer(buffer26, 'uint16', 546, 174); |
| } catch {} |
| try { |
| renderPassEncoder52.setPipeline(pipeline1); |
| } catch {} |
| try { |
| gpuCanvasContext8.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let pipeline8 = await device0.createComputePipelineAsync({layout: pipelineLayout12, compute: {module: shaderModule19}}); |
| let texture290 = device0.createTexture({ |
| size: [36, 1, 1], |
| mipLevelCount: 4, |
| dimension: '2d', |
| format: 'depth24plus', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| computePassEncoder96.setBindGroup(1, bindGroup142, new Uint32Array(315), 42, 0); |
| } catch {} |
| await gc(); |
| let buffer211 = device0.createBuffer({size: 1852, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE}); |
| let texture291 = device0.createTexture({ |
| size: [560, 582, 1], |
| mipLevelCount: 2, |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC, |
| }); |
| let sampler188 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'nearest', |
| lodMinClamp: 26.26, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder76); computePassEncoder76.dispatchWorkgroups(3, 1); }; |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder76); computePassEncoder76.dispatchWorkgroupsIndirect(buffer206, 1_692); }; |
| } catch {} |
| try { |
| computePassEncoder149.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder78.setBindGroup(1, bindGroup23, new Uint32Array(413), 7, 0); |
| } catch {} |
| try { |
| renderPassEncoder20.executeBundles([renderBundle4, renderBundle15, renderBundle10, renderBundle28, renderBundle10, renderBundle21, renderBundle15]); |
| } catch {} |
| try { |
| renderPassEncoder20.pushDebugGroup('\ubfd6'); |
| } catch {} |
| try { |
| renderPassEncoder20.popDebugGroup(); |
| } catch {} |
| let textureView284 = texture131.createView({label: '\u{1fb29}\u0d36\u7a83\uc302', aspect: 'all', mipLevelCount: 1}); |
| try { |
| computePassEncoder165.setBindGroup(1, bindGroup127, new Uint32Array(1823), 315, 0); |
| } catch {} |
| try { |
| renderPassEncoder52.beginOcclusionQuery(126); |
| } catch {} |
| let texture292 = device0.createTexture({ |
| size: {width: 440, height: 40, depthOrArrayLayers: 1}, |
| dimension: '2d', |
| format: 'rgba32float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler189 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| mipmapFilter: 'linear', |
| lodMinClamp: 95.44, |
| lodMaxClamp: 97.65, |
| }); |
| try { |
| computePassEncoder76.end(); |
| } catch {} |
| try { |
| renderPassEncoder16.setIndexBuffer(buffer21, 'uint32', 1_576, 379); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer146, 236, new BigUint64Array(16551), 2378, 4); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 73, height: 1, depthOrArrayLayers: 32} |
| */ |
| { |
| source: imageData8, |
| origin: { x: 2, y: 7 }, |
| flipY: false, |
| }, { |
| texture: texture138, |
| mipLevel: 0, |
| origin: {x: 10, y: 0, z: 4}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| gpuCanvasContext4.unconfigure(); |
| } catch {} |
| let buffer212 = device0.createBuffer({ |
| label: '\u{1f873}\u0495\u0a3f', |
| size: 19863, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX, |
| }); |
| let commandBuffer16 = commandEncoder102.finish(); |
| let sampler190 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 39.99, |
| lodMaxClamp: 98.24, |
| compare: 'less-equal', |
| }); |
| try { |
| gpuCanvasContext1.configure({ |
| device: device0, |
| format: 'bgra8unorm', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture134, |
| mipLevel: 1, |
| origin: {x: 40, y: 0, z: 10}, |
| aspect: 'all', |
| }, new Uint8Array(103).fill(176), /* required buffer size: 103 */ |
| {offset: 103, bytesPerRow: 14, rowsPerImage: 0}, {width: 0, height: 0, depthOrArrayLayers: 4}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 36, height: 1, depthOrArrayLayers: 20} |
| */ |
| { |
| source: imageData0, |
| origin: { x: 3, y: 1 }, |
| flipY: true, |
| }, { |
| texture: texture174, |
| mipLevel: 0, |
| origin: {x: 22, y: 0, z: 2}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 4, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let buffer213 = device0.createBuffer({ |
| size: 5424, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX, |
| }); |
| let commandEncoder272 = device0.createCommandEncoder({label: '\u{1ff36}\u{1f75f}'}); |
| let texture293 = device0.createTexture({ |
| size: [280, 291, 1], |
| mipLevelCount: 4, |
| format: 'depth24plus', |
| usage: GPUTextureUsage.COPY_SRC, |
| viewFormats: [], |
| }); |
| try { |
| renderPassEncoder5.setBindGroup(2, bindGroup90, new Uint32Array(3428), 7, 0); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 70, height: 72, depthOrArrayLayers: 25} |
| */ |
| { |
| source: imageData35, |
| origin: { x: 2, y: 2 }, |
| flipY: false, |
| }, { |
| texture: texture194, |
| mipLevel: 0, |
| origin: {x: 13, y: 1, z: 6}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: true, |
| }, {width: 0, height: 19, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| globalThis.someLabel = sampler115.label; |
| } catch {} |
| let buffer214 = device0.createBuffer({ |
| size: 2476, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let computePassEncoder231 = commandEncoder272.beginComputePass({}); |
| let sampler191 = device0.createSampler({ |
| label: '\u{1fbae}\u0d5f\u2ddd\u0eb3\u0a45\u01bf\u0f5b\u895f\u04e0\u8614\u0330', |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| addressModeW: 'repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 78.62, |
| lodMaxClamp: 78.69, |
| maxAnisotropy: 9, |
| }); |
| try { |
| computePassEncoder231.setPipeline(pipeline0); |
| } catch {} |
| document.body.append(canvas2); |
| let bindGroup189 = device0.createBindGroup({ |
| layout: bindGroupLayout8, |
| entries: [{binding: 27, resource: {buffer: buffer23, offset: 256, size: 7806}}], |
| }); |
| let texture294 = device0.createTexture({ |
| label: '\u033d\u06e0\u03c4\u258f\u{1f93a}\u7278\u7882', |
| size: {width: 560, height: 582, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'rgb10a2unorm', |
| usage: GPUTextureUsage.COPY_DST, |
| }); |
| try { |
| computePassEncoder88.setBindGroup(1, bindGroup171); |
| } catch {} |
| try { |
| computePassEncoder206.setBindGroup(3, bindGroup86, new Uint32Array(934), 169, 0); |
| } catch {} |
| try { |
| renderPassEncoder102.setBindGroup(0, bindGroup57); |
| } catch {} |
| try { |
| renderPassEncoder88.setBindGroup(2, bindGroup35, new Uint32Array(618), 218, 0); |
| } catch {} |
| try { |
| renderPassEncoder52.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder20.setVertexBuffer(0, buffer72, 0, 1_226); |
| } catch {} |
| try { |
| device0.queue.submit([commandBuffer16]); |
| } catch {} |
| try { |
| computePassEncoder63.setBindGroup(1, bindGroup139); |
| } catch {} |
| try { |
| computePassEncoder184.setBindGroup(0, bindGroup47, new Uint32Array(150), 2, 0); |
| } catch {} |
| let renderBundleEncoder35 = device0.createRenderBundleEncoder({colorFormats: ['rgba32float'], stencilReadOnly: false}); |
| try { |
| computePassEncoder80.setBindGroup(3, bindGroup116, new Uint32Array(1170), 518, 0); |
| } catch {} |
| try { |
| renderPassEncoder17.setVertexBuffer(2, buffer115, 92, 26); |
| } catch {} |
| try { |
| renderBundleEncoder35.setBindGroup(0, bindGroup183, new Uint32Array(3901), 139, 0); |
| } catch {} |
| let buffer215 = device0.createBuffer({size: 13435, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ}); |
| let texture295 = device0.createTexture({size: [110], mipLevelCount: 1, dimension: '1d', format: 'rgba16sint', usage: GPUTextureUsage.COPY_SRC}); |
| let textureView285 = texture93.createView({label: '\u6b7a\uaacc\ub517', dimension: '2d-array'}); |
| try { |
| computePassEncoder87.setBindGroup(1, bindGroup30); |
| } catch {} |
| try { |
| computePassEncoder217.setBindGroup(1, bindGroup58, new Uint32Array(5361), 386, 0); |
| } catch {} |
| try { |
| renderPassEncoder65.setBlendConstant({ r: 281.9, g: 703.5, b: 700.5, a: -766.5, }); |
| } catch {} |
| try { |
| renderPassEncoder12.setIndexBuffer(buffer105, 'uint16', 250, 268); |
| } catch {} |
| try { |
| renderPassEncoder103.setVertexBuffer(0, buffer140, 5_856, 229); |
| } catch {} |
| try { |
| renderBundleEncoder35.setBindGroup(3, bindGroup73, new Uint32Array(150), 30, 0); |
| } catch {} |
| document.body.prepend(canvas7); |
| let bindGroup190 = device0.createBindGroup({ |
| layout: bindGroupLayout18, |
| entries: [{binding: 116, resource: sampler100}, {binding: 204, resource: externalTexture3}], |
| }); |
| let texture296 = device0.createTexture({ |
| size: {width: 110}, |
| sampleCount: 1, |
| dimension: '1d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| try { |
| computePassEncoder119.setBindGroup(1, bindGroup145, new Uint32Array(36), 3, 0); |
| } catch {} |
| try { |
| renderPassEncoder15.setBindGroup(3, bindGroup14, new Uint32Array(1179), 53, 0); |
| } catch {} |
| try { |
| renderBundleEncoder35.setBindGroup(0, bindGroup93); |
| } catch {} |
| let arrayBuffer24 = buffer74.getMappedRange(232, 20); |
| try { |
| device0.queue.writeTexture({ |
| texture: texture36, |
| mipLevel: 0, |
| origin: {x: 5, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(193).fill(221), /* required buffer size: 193 */ |
| {offset: 193}, {width: 10, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let promise29 = device0.queue.onSubmittedWorkDone(); |
| document.body.append(img1); |
| await gc(); |
| try { |
| computePassEncoder52.setBindGroup(2, bindGroup91); |
| } catch {} |
| try { |
| computePassEncoder202.setBindGroup(0, bindGroup8, new Uint32Array(1964), 266, 0); |
| } catch {} |
| try { |
| { clearResourceUsages(device0, computePassEncoder202); computePassEncoder202.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| renderPassEncoder51.setIndexBuffer(buffer139, 'uint32', 1_476, 2_719); |
| } catch {} |
| try { |
| gpuCanvasContext4.unconfigure(); |
| } catch {} |
| let bindGroupLayout40 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 423, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| texture: { viewDimension: '2d', sampleType: 'uint', multisampled: false }, |
| }, |
| { |
| binding: 311, |
| visibility: GPUShaderStage.VERTEX, |
| texture: { viewDimension: '1d', sampleType: 'uint', multisampled: false }, |
| }, |
| { |
| binding: 166, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, |
| buffer: { type: 'storage', hasDynamicOffset: false }, |
| }, |
| { |
| binding: 113, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: false }, |
| }, |
| { |
| binding: 283, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| texture: { viewDimension: '2d', sampleType: 'float', multisampled: false }, |
| }, |
| ], |
| }); |
| let textureView286 = texture157.createView({}); |
| try { |
| renderPassEncoder63.setBindGroup(0, bindGroup76); |
| } catch {} |
| try { |
| renderPassEncoder85.setVertexBuffer(2, buffer196, 0, 7_941); |
| } catch {} |
| try { |
| renderBundleEncoder35.setVertexBuffer(2, buffer2, 936, 12); |
| } catch {} |
| try { |
| textureView34.label = '\u7931\u{1fb93}\u0f51'; |
| } catch {} |
| let texture297 = device0.createTexture({ |
| size: [220, 20, 1], |
| format: 'depth24plus', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT, |
| }); |
| try { |
| renderPassEncoder45.beginOcclusionQuery(2); |
| } catch {} |
| try { |
| renderPassEncoder35.setVertexBuffer(1, buffer173, 0, 23); |
| } catch {} |
| let renderBundle35 = renderBundleEncoder35.finish({}); |
| let sampler192 = device0.createSampler({ |
| addressModeV: 'repeat', |
| addressModeW: 'repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| mipmapFilter: 'nearest', |
| lodMaxClamp: 17.11, |
| }); |
| try { |
| { clearResourceUsages(device0, computePassEncoder202); computePassEncoder202.dispatchWorkgroups(2); }; |
| } catch {} |
| try { |
| renderPassEncoder45.endOcclusionQuery(); |
| } catch {} |
| try { |
| renderPassEncoder16.setIndexBuffer(buffer21, 'uint16', 1_644, 1_122); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture63, |
| mipLevel: 0, |
| origin: {x: 5, y: 2, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(20).fill(47), /* required buffer size: 20 */ |
| {offset: 20, bytesPerRow: 143}, {width: 8, height: 1, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| computePassEncoder84.setBindGroup(0, bindGroup12, new Uint32Array(5605), 3_806, 0); |
| } catch {} |
| try { |
| computePassEncoder202.end(); |
| } catch {} |
| try { |
| renderPassEncoder47.setVertexBuffer(2, buffer205, 364, 755); |
| } catch {} |
| let bindGroup191 = device0.createBindGroup({ |
| layout: bindGroupLayout7, |
| entries: [ |
| {binding: 53, resource: externalTexture13}, |
| {binding: 54, resource: {buffer: buffer106, offset: 0, size: 1128}}, |
| ], |
| }); |
| let textureView287 = texture92.createView({label: '\ua74c\ub02b', dimension: '2d-array'}); |
| let externalTexture29 = device0.importExternalTexture({source: videoFrame31}); |
| try { |
| computePassEncoder148.setBindGroup(0, bindGroup126, new Uint32Array(218), 3, 0); |
| } catch {} |
| try { |
| renderPassEncoder86.executeBundles([renderBundle32]); |
| } catch {} |
| try { |
| commandEncoder248.copyTextureToTexture({ |
| texture: texture179, |
| mipLevel: 0, |
| origin: {x: 114, y: 5, z: 0}, |
| aspect: 'all', |
| }, |
| { |
| texture: texture95, |
| mipLevel: 1, |
| origin: {x: 2, y: 0, z: 0}, |
| aspect: 'all', |
| }, |
| {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await promise29; |
| } catch {} |
| let texture298 = device0.createTexture({ |
| label: '\u0fee\ufe03\u38bc\uc35a\u314a\u09e3', |
| size: [70], |
| dimension: '1d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let sampler193 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 14.89, |
| lodMaxClamp: 72.93, |
| maxAnisotropy: 9, |
| }); |
| try { |
| renderPassEncoder77.beginOcclusionQuery(236); |
| } catch {} |
| try { |
| renderPassEncoder77.endOcclusionQuery(); |
| } catch {} |
| try { |
| commandEncoder248.clearBuffer(buffer112, 3568, 2884); |
| } catch {} |
| let texture299 = device0.createTexture({ |
| label: '\u0f0a\u02fb\u9882\u{1ff5b}\ucf2c\u6cd1\u04aa\u{1f803}\u0e8c', |
| size: {width: 220, height: 20, depthOrArrayLayers: 34}, |
| mipLevelCount: 1, |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let renderPassEncoder106 = commandEncoder248.beginRenderPass({ |
| colorAttachments: [{ |
| view: textureView173, |
| depthSlice: 34, |
| clearValue: { r: -749.8, g: -980.5, b: -216.7, a: -305.7, }, |
| loadOp: 'load', |
| storeOp: 'discard', |
| }], |
| maxDrawCount: 11643662, |
| }); |
| try { |
| computePassEncoder139.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder94.executeBundles([renderBundle35]); |
| } catch {} |
| try { |
| renderPassEncoder68.setIndexBuffer(buffer15, 'uint32', 508, 270); |
| } catch {} |
| try { |
| gpuCanvasContext5.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| document.body.append(img4); |
| let texture300 = device0.createTexture({ |
| size: {width: 560, height: 582, depthOrArrayLayers: 1}, |
| mipLevelCount: 2, |
| format: 'depth24plus', |
| usage: GPUTextureUsage.COPY_SRC, |
| }); |
| try { |
| computePassEncoder122.setBindGroup(3, bindGroup81); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 36, height: 1, depthOrArrayLayers: 20} |
| */ |
| { |
| source: videoFrame8, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture174, |
| mipLevel: 0, |
| origin: {x: 5, y: 0, z: 3}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| await gc(); |
| let bindGroupLayout41 = device0.createBindGroupLayout({ |
| entries: [ |
| { |
| binding: 230, |
| visibility: GPUShaderStage.COMPUTE, |
| storageTexture: { format: 'rgba16uint', access: 'write-only', viewDimension: '2d' }, |
| }, |
| { |
| binding: 53, |
| visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX, |
| sampler: { type: 'filtering' }, |
| }, |
| { |
| binding: 355, |
| visibility: GPUShaderStage.FRAGMENT, |
| storageTexture: { format: 'rg32uint', access: 'write-only', viewDimension: '3d' }, |
| }, |
| ], |
| }); |
| let texture301 = device0.createTexture({ |
| label: '\ucab8\u63d9\u0f61\udd04\u{1f728}\u3e74\u9ca5\ub734\ub09f', |
| size: [140, 145, 1], |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder194.setBindGroup(2, bindGroup8, new Uint32Array(855), 155, 0); |
| } catch {} |
| let buffer216 = device0.createBuffer({ |
| size: 10009, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let texture302 = device0.createTexture({ |
| size: [220, 20, 1], |
| format: 'rgba16uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| try { |
| computePassEncoder196.setBindGroup(3, bindGroup128); |
| } catch {} |
| try { |
| renderPassEncoder85.executeBundles([renderBundle22, renderBundle22, renderBundle24, renderBundle24, renderBundle6, renderBundle32]); |
| } catch {} |
| try { |
| renderPassEncoder79.setIndexBuffer(buffer203, 'uint32', 636, 548); |
| } catch {} |
| try { |
| renderPassEncoder10.setVertexBuffer(2, buffer28, 0, 314); |
| } catch {} |
| try { |
| gpuCanvasContext8.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| } catch {} |
| let textureView288 = texture302.createView({baseArrayLayer: 0}); |
| let textureView289 = texture265.createView({mipLevelCount: 1, arrayLayerCount: 1}); |
| let sampler194 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'mirror-repeat', |
| mipmapFilter: 'nearest', |
| lodMinClamp: 54.01, |
| lodMaxClamp: 86.44, |
| }); |
| try { |
| renderPassEncoder24.setBindGroup(0, bindGroup23); |
| } catch {} |
| try { |
| renderPassEncoder22.setVertexBuffer(2, buffer87, 0); |
| } catch {} |
| try { |
| gpuCanvasContext2.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| alphaMode: 'opaque', |
| }); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 36, height: 1, depthOrArrayLayers: 20} |
| */ |
| { |
| source: videoFrame31, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture174, |
| mipLevel: 0, |
| origin: {x: 4, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture303 = device0.createTexture({ |
| size: [140, 145, 229], |
| dimension: '3d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let texture304 = device0.createTexture({ |
| size: {width: 140}, |
| dimension: '1d', |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView290 = texture90.createView({dimension: '3d', mipLevelCount: 1}); |
| try { |
| computePassEncoder171.setBindGroup(2, bindGroup111, []); |
| } catch {} |
| try { |
| renderPassEncoder42.pushDebugGroup('\u0c2f'); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 64, height: 64, depthOrArrayLayers: 22} |
| */ |
| { |
| source: imageData12, |
| origin: { x: 3, y: 1 }, |
| flipY: true, |
| }, { |
| texture: texture277, |
| mipLevel: 0, |
| origin: {x: 3, y: 3, z: 5}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let texture305 = device0.createTexture({ |
| label: '\u05eb\u5785\u04e9\u1a01', |
| size: [36, 1, 54], |
| dimension: '3d', |
| format: 'rg32uint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView291 = texture169.createView({}); |
| try { |
| computePassEncoder193.setBindGroup(0, bindGroup126); |
| } catch {} |
| try { |
| computePassEncoder209.setPipeline(pipeline3); |
| } catch {} |
| try { |
| renderPassEncoder24.setIndexBuffer(buffer16, 'uint16', 5_084, 125); |
| } catch {} |
| try { |
| renderPassEncoder24.setVertexBuffer(6, buffer160); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture126, |
| mipLevel: 1, |
| origin: {x: 6, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(779).fill(104), /* required buffer size: 779 */ |
| {offset: 140, bytesPerRow: 71, rowsPerImage: 9}, {width: 5, height: 0, depthOrArrayLayers: 2}); |
| } catch {} |
| let textureView292 = texture303.createView({dimension: '3d', format: 'rg32uint', baseArrayLayer: 0}); |
| let textureView293 = texture26.createView({dimension: '2d-array', baseMipLevel: 0, baseArrayLayer: 0}); |
| try { |
| computePassEncoder214.setBindGroup(2, bindGroup184); |
| } catch {} |
| try { |
| computePassEncoder52.setBindGroup(3, bindGroup124, new Uint32Array(278), 7, 0); |
| } catch {} |
| try { |
| renderPassEncoder67.setBindGroup(0, bindGroup95); |
| } catch {} |
| try { |
| renderPassEncoder69.setBindGroup(1, bindGroup140, new Uint32Array(1719), 257, 0); |
| } catch {} |
| try { |
| renderPassEncoder106.executeBundles([renderBundle21]); |
| } catch {} |
| try { |
| renderPassEncoder103.setVertexBuffer(4, buffer83, 12_404); |
| } catch {} |
| try { |
| await buffer29.mapAsync(GPUMapMode.WRITE); |
| } catch {} |
| let texture306 = device0.createTexture({ |
| size: [280, 291, 1], |
| mipLevelCount: 2, |
| format: 'rgba16sint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView294 = texture255.createView({baseMipLevel: 0, mipLevelCount: 1}); |
| let externalTexture30 = device0.importExternalTexture({source: videoFrame2}); |
| try { |
| computePassEncoder119.setBindGroup(1, bindGroup60); |
| } catch {} |
| try { |
| computePassEncoder179.setBindGroup(1, bindGroup40, new Uint32Array(3642), 201, 0); |
| } catch {} |
| try { |
| renderPassEncoder90.setBindGroup(2, bindGroup151, [0]); |
| } catch {} |
| try { |
| renderPassEncoder17.setBindGroup(0, bindGroup128, new Uint32Array(1173), 261, 0); |
| } catch {} |
| try { |
| renderPassEncoder91.setIndexBuffer(buffer16, 'uint32', 772, 1_078); |
| } catch {} |
| try { |
| renderPassEncoder31.setVertexBuffer(4, buffer56, 4_536, 1_404); |
| } catch {} |
| try { |
| computePassEncoder150.setPipeline(pipeline4); |
| } catch {} |
| try { |
| renderPassEncoder74.setBindGroup(1, bindGroup189, new Uint32Array(930), 256, 0); |
| } catch {} |
| try { |
| renderPassEncoder13.executeBundles([renderBundle5]); |
| } catch {} |
| try { |
| renderPassEncoder36.setIndexBuffer(buffer189, 'uint16', 174, 3_716); |
| } catch {} |
| try { |
| renderPassEncoder78.setVertexBuffer(0, buffer208, 0); |
| } catch {} |
| try { |
| await shaderModule10.getCompilationInfo(); |
| } catch {} |
| document.body.prepend(canvas2); |
| let textureView295 = texture74.createView({mipLevelCount: 1, baseArrayLayer: 2, arrayLayerCount: 1}); |
| try { |
| renderPassEncoder104.setBindGroup(2, bindGroup43); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer149, 1824, new Int16Array(391), 1, 84); |
| } catch {} |
| let textureView296 = texture3.createView({}); |
| let sampler195 = device0.createSampler({ |
| addressModeU: 'repeat', |
| addressModeV: 'mirror-repeat', |
| magFilter: 'linear', |
| minFilter: 'linear', |
| mipmapFilter: 'linear', |
| lodMinClamp: 24.64, |
| lodMaxClamp: 60.00, |
| maxAnisotropy: 9, |
| }); |
| try { |
| computePassEncoder109.setBindGroup(2, bindGroup173); |
| } catch {} |
| try { |
| renderPassEncoder9.setBindGroup(1, bindGroup70); |
| } catch {} |
| try { |
| renderPassEncoder12.setBindGroup(3, bindGroup184, new Uint32Array(744), 61, 0); |
| } catch {} |
| try { |
| renderPassEncoder42.popDebugGroup(); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 36, height: 1, depthOrArrayLayers: 177} |
| */ |
| { |
| source: offscreenCanvas7, |
| origin: { x: 2, y: 9 }, |
| flipY: false, |
| }, { |
| texture: texture216, |
| mipLevel: 0, |
| origin: {x: 5, y: 0, z: 3}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 1, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup192 = device0.createBindGroup({ |
| label: '\u01f3\ubf5d\u0f80\u131e\u278d\u8169', |
| layout: bindGroupLayout17, |
| entries: [{binding: 78, resource: sampler128}, {binding: 113, resource: textureView107}], |
| }); |
| let textureView297 = texture73.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 18}); |
| let renderBundleEncoder36 = device0.createRenderBundleEncoder({colorFormats: ['rgba32float'], depthReadOnly: true, stencilReadOnly: true}); |
| let renderBundle36 = renderBundleEncoder36.finish({}); |
| try { |
| buffer108.unmap(); |
| } catch {} |
| try { |
| computePassEncoder163.insertDebugMarker('\u{1fcb1}'); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture6, |
| mipLevel: 0, |
| origin: {x: 24, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(251).fill(217), /* required buffer size: 251 */ |
| {offset: 251}, {width: 14, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| if (!arrayBuffer19.detached) { new Uint8Array(arrayBuffer19).fill(0x55); }; |
| } catch {} |
| await gc(); |
| let imageBitmap7 = await createImageBitmap(imageData23); |
| let pipelineLayout17 = device0.createPipelineLayout({bindGroupLayouts: []}); |
| let textureView298 = texture222.createView({}); |
| let sampler196 = device0.createSampler({ |
| addressModeU: 'clamp-to-edge', |
| addressModeV: 'repeat', |
| addressModeW: 'clamp-to-edge', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| mipmapFilter: 'linear', |
| lodMinClamp: 99.09, |
| lodMaxClamp: 99.14, |
| compare: 'less', |
| }); |
| try { |
| computePassEncoder89.setBindGroup(3, bindGroup138, new Uint32Array(1475), 381, 0); |
| } catch {} |
| try { |
| renderPassEncoder74.setStencilReference(226); |
| } catch {} |
| document.body.prepend(canvas1); |
| let textureView299 = texture182.createView({dimension: 'cube-array', baseArrayLayer: 4, arrayLayerCount: 6}); |
| try { |
| renderPassEncoder65.setIndexBuffer(buffer173, 'uint32', 324, 122); |
| } catch {} |
| try { |
| renderPassEncoder62.setVertexBuffer(4, buffer59, 804); |
| } catch {} |
| try { |
| buffer188.unmap(); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture81, |
| mipLevel: 3, |
| origin: {x: 5, y: 0, z: 0}, |
| aspect: 'all', |
| }, new Uint8Array(464).fill(69), /* required buffer size: 464 */ |
| {offset: 464}, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 48, height: 1, depthOrArrayLayers: 1} |
| */ |
| { |
| source: canvas5, |
| origin: { x: 7, y: 338 }, |
| flipY: true, |
| }, { |
| texture: texture276, |
| mipLevel: 0, |
| origin: {x: 0, y: 0, z: 0}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 6, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let bindGroup193 = device0.createBindGroup({layout: bindGroupLayout37, entries: [{binding: 29, resource: textureView266}]}); |
| let textureView300 = texture105.createView({}); |
| let texture307 = gpuCanvasContext9.getCurrentTexture(); |
| let textureView301 = texture161.createView({dimension: '2d-array', mipLevelCount: 1}); |
| try { |
| renderPassEncoder18.setIndexBuffer(buffer128, 'uint16', 722, 905); |
| } catch {} |
| try { |
| navigator.gpu.getPreferredCanvasFormat(); |
| } catch {} |
| let bindGroup194 = device0.createBindGroup({ |
| layout: bindGroupLayout4, |
| entries: [{binding: 511, resource: {buffer: buffer37, offset: 256, size: 204}}], |
| }); |
| let querySet37 = device0.createQuerySet({type: 'occlusion', count: 734}); |
| try { |
| renderPassEncoder5.setIndexBuffer(buffer10, 'uint32', 2_160, 1_932); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 96, height: 1, depthOrArrayLayers: 78} |
| */ |
| { |
| source: videoFrame31, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture270, |
| mipLevel: 0, |
| origin: {x: 6, y: 0, z: 4}, |
| aspect: 'all', |
| colorSpace: 'display-p3', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| globalThis.someLabel = querySet6.label; |
| } catch {} |
| let externalTexture31 = device0.importExternalTexture({label: '\ubf74\u{1ff38}\u50fa\u0718\u0a9d', source: videoFrame3, colorSpace: 'srgb'}); |
| try { |
| computePassEncoder163.setBindGroup(1, bindGroup121, new Uint32Array(703), 23, 0); |
| } catch {} |
| try { |
| renderPassEncoder85.setVertexBuffer(2, buffer184); |
| } catch {} |
| try { |
| device0.pushErrorScope('validation'); |
| } catch {} |
| try { |
| buffer107.unmap(); |
| } catch {} |
| let bindGroup195 = device0.createBindGroup({ |
| layout: bindGroupLayout2, |
| entries: [ |
| {binding: 42, resource: externalTexture6}, |
| {binding: 35, resource: textureView118}, |
| {binding: 94, resource: textureView261}, |
| {binding: 243, resource: textureView57}, |
| {binding: 421, resource: {buffer: buffer37, offset: 512, size: 776}}, |
| {binding: 398, resource: textureView222}, |
| {binding: 567, resource: textureView140}, |
| {binding: 132, resource: textureView48}, |
| {binding: 999, resource: textureView166}, |
| ], |
| }); |
| let textureView302 = texture303.createView({baseMipLevel: 0}); |
| let textureView303 = texture72.createView({}); |
| try { |
| computePassEncoder99.setBindGroup(0, bindGroup131, []); |
| } catch {} |
| try { |
| renderPassEncoder39.setBindGroup(2, bindGroup86); |
| } catch {} |
| try { |
| renderPassEncoder39.executeBundles([renderBundle26]); |
| } catch {} |
| document.body.append(canvas0); |
| let buffer217 = device0.createBuffer({ |
| size: 87, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| try { |
| renderPassEncoder65.setBindGroup(2, bindGroup167); |
| } catch {} |
| try { |
| renderPassEncoder26.setBindGroup(2, bindGroup150, new Uint32Array(3848), 448, 0); |
| } catch {} |
| try { |
| renderPassEncoder53.setIndexBuffer(buffer209, 'uint32', 2_916, 159); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer109, 656, new Float32Array(10707), 486, 60); |
| } catch {} |
| try { |
| globalThis.someLabel = bindGroup7.label; |
| } catch {} |
| let buffer218 = device0.createBuffer({ |
| label: '\u{1fab4}\u5cd3\u117f\u8261\u9464\u{1fff2}\u11b9\u{1f865}\u{1f860}\u7904\u{1f64a}', |
| size: 2033, |
| usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM, |
| }); |
| let texture308 = device0.createTexture({ |
| size: [96, 1, 58], |
| format: 'depth24plus', |
| usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING, |
| viewFormats: [], |
| }); |
| let sampler197 = device0.createSampler({ |
| label: '\u07b2\u0e33\u{1fb62}\u{1fb9f}\u0add\u9a00\u308d\u{1fcf5}\ua9e2', |
| addressModeV: 'clamp-to-edge', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'nearest', |
| lodMinClamp: 85.25, |
| lodMaxClamp: 96.62, |
| }); |
| try { |
| renderPassEncoder16.setBindGroup(0, bindGroup40); |
| } catch {} |
| try { |
| renderPassEncoder54.executeBundles([renderBundle19]); |
| } catch {} |
| try { |
| renderPassEncoder14.setPipeline(pipeline1); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 73, height: 1, depthOrArrayLayers: 54} |
| */ |
| { |
| source: videoFrame22, |
| origin: { x: 0, y: 0 }, |
| flipY: false, |
| }, { |
| texture: texture5, |
| mipLevel: 0, |
| origin: {x: 12, y: 0, z: 1}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let videoFrame47 = new VideoFrame(new ArrayBuffer(16), { codedWidth: 2, codedHeight: 2, format: 'I420', timestamp: 0, colorSpace: {fullRange: false, matrix: 'fcc', primaries: 'smpteRp431', transfer: 'bt1361ExtendedColourGamut'} }); |
| let buffer219 = device0.createBuffer({ |
| size: 20697, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE, |
| }); |
| let textureView304 = texture219.createView({dimension: '2d-array', aspect: 'all', mipLevelCount: 1}); |
| let promise30 = device0.queue.onSubmittedWorkDone(); |
| try { |
| if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55); }; |
| } catch {} |
| let bindGroup196 = device0.createBindGroup({layout: bindGroupLayout24, entries: [{binding: 52, resource: sampler139}]}); |
| let buffer220 = device0.createBuffer({ |
| label: '\ud521\u{1fc3e}', |
| size: 5582, |
| usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| try { |
| computePassEncoder139.setBindGroup(1, bindGroup105, new Uint32Array(441), 83, 0); |
| } catch {} |
| try { |
| renderPassEncoder38.executeBundles([renderBundle22, renderBundle32]); |
| } catch {} |
| try { |
| await device0.queue.onSubmittedWorkDone(); |
| } catch {} |
| let bindGroupLayout42 = device0.createBindGroupLayout({ |
| label: '\u3fcb\u{1ffe9}\uce4a\u027a\u61e2\u{1f9cb}', |
| entries: [{binding: 224, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'filtering' }}], |
| }); |
| let bindGroup197 = device0.createBindGroup({ |
| layout: bindGroupLayout19, |
| entries: [{binding: 361, resource: {buffer: buffer120, offset: 256, size: 828}}], |
| }); |
| let texture309 = device0.createTexture({ |
| size: {width: 70, height: 72, depthOrArrayLayers: 1}, |
| mipLevelCount: 1, |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_SRC, |
| }); |
| let sampler198 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| mipmapFilter: 'linear', |
| lodMinClamp: 85.38, |
| lodMaxClamp: 96.55, |
| }); |
| try { |
| computePassEncoder19.setBindGroup(1, bindGroup20); |
| } catch {} |
| try { |
| renderPassEncoder97.setBindGroup(1, bindGroup19, new Uint32Array(134), 9, 0); |
| } catch {} |
| try { |
| gpuCanvasContext11.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| colorSpace: 'display-p3', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device0.queue.writeBuffer(buffer114, 920, new Float32Array(55108), 19132, 0); |
| } catch {} |
| let buffer221 = device0.createBuffer({size: 50418, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX}); |
| let querySet38 = device0.createQuerySet({type: 'occlusion', count: 530}); |
| let sampler199 = device0.createSampler({ |
| addressModeU: 'mirror-repeat', |
| addressModeV: 'repeat', |
| addressModeW: 'mirror-repeat', |
| magFilter: 'nearest', |
| minFilter: 'nearest', |
| lodMinClamp: 84.71, |
| lodMaxClamp: 89.72, |
| }); |
| try { |
| computePassEncoder146.setBindGroup(0, bindGroup61, new Uint32Array(3208), 668, 0); |
| } catch {} |
| try { |
| renderPassEncoder15.setIndexBuffer(buffer161, 'uint16', 872, 1_530); |
| } catch {} |
| let bindGroup198 = device0.createBindGroup({ |
| label: '\u03ce\u5d1c\u0305\ua0f4\u0287\ubb76\u7152\u736e\u{1fa57}', |
| layout: bindGroupLayout36, |
| entries: [{binding: 5, resource: textureView170}, {binding: 23, resource: externalTexture26}], |
| }); |
| let textureView305 = texture72.createView({label: '\ue490\u0d5f\u0d8b\u51d2\u{1fa5a}', baseArrayLayer: 0}); |
| let renderBundleEncoder37 = device0.createRenderBundleEncoder({colorFormats: ['rgba16sint']}); |
| let renderBundle37 = renderBundleEncoder37.finish({}); |
| try { |
| computePassEncoder188.setBindGroup(3, bindGroup26, new Uint32Array(2683), 1_449, 0); |
| } catch {} |
| try { |
| renderPassEncoder71.setIndexBuffer(buffer216, 'uint16', 3_608, 507); |
| } catch {} |
| try { |
| device0.queue.writeTexture({ |
| texture: texture247, |
| mipLevel: 0, |
| origin: {x: 12, y: 0, z: 73}, |
| aspect: 'all', |
| }, new Uint8Array(1_454_151).fill(191), /* required buffer size: 1_454_151 */ |
| {offset: 174, bytesPerRow: 1029, rowsPerImage: 157}, {width: 121, height: 0, depthOrArrayLayers: 10}); |
| } catch {} |
| let buffer222 = device0.createBuffer({ |
| size: 1922, |
| usage: GPUBufferUsage.INDEX | GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX, |
| }); |
| let texture310 = device0.createTexture({size: [220], dimension: '1d', format: 'rgb10a2unorm', usage: GPUTextureUsage.TEXTURE_BINDING}); |
| let textureView306 = texture124.createView({}); |
| try { |
| renderPassEncoder86.setVertexBuffer(4, buffer210, 0); |
| } catch {} |
| let promise31 = device0.queue.onSubmittedWorkDone(); |
| try { |
| await promise30; |
| } catch {} |
| let texture311 = device0.createTexture({ |
| size: {width: 96}, |
| dimension: '1d', |
| format: 'rgb10a2uint', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING, |
| }); |
| let textureView307 = texture202.createView({baseArrayLayer: 0}); |
| let externalTexture32 = device0.importExternalTexture({source: videoFrame9}); |
| try { |
| buffer162.unmap(); |
| } catch {} |
| try { |
| gpuCanvasContext5.configure({ |
| device: device0, |
| format: 'rgba8unorm', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING, |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| computePassEncoder211.setBindGroup(2, bindGroup142); |
| } catch {} |
| try { |
| renderPassEncoder24.setPipeline(pipeline1); |
| } catch {} |
| try { |
| gpuCanvasContext12.configure({ |
| device: device0, |
| format: 'rgba16float', |
| usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING, |
| colorSpace: 'srgb', |
| alphaMode: 'premultiplied', |
| }); |
| } catch {} |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 140, height: 145, depthOrArrayLayers: 239} |
| */ |
| { |
| source: videoFrame12, |
| origin: { x: 0, y: 0 }, |
| flipY: true, |
| }, { |
| texture: texture137, |
| mipLevel: 1, |
| origin: {x: 11, y: 2, z: 89}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: false, |
| }, {width: 0, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| try { |
| await promise31; |
| } catch {} |
| let texture312 = device0.createTexture({ |
| size: {width: 36, height: 1, depthOrArrayLayers: 1}, |
| format: 'r32sint', |
| usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING, |
| viewFormats: [], |
| }); |
| let textureView308 = texture278.createView({label: '\u0839\u022b', dimension: '1d'}); |
| try { |
| renderPassEncoder54.executeBundles([renderBundle19]); |
| } catch {} |
| try { |
| renderPassEncoder65.setIndexBuffer(buffer52, 'uint16', 12, 28); |
| } catch {} |
| try { |
| renderPassEncoder52.setPipeline(pipeline1); |
| } catch {} |
| let promise32 = device0.queue.onSubmittedWorkDone(); |
| try { |
| device0.queue.copyExternalImageToTexture(/* |
| {width: 36, height: 1, depthOrArrayLayers: 177} |
| */ |
| { |
| source: imageData1, |
| origin: { x: 5, y: 2 }, |
| flipY: false, |
| }, { |
| texture: texture216, |
| mipLevel: 0, |
| origin: {x: 2, y: 0, z: 60}, |
| aspect: 'all', |
| colorSpace: 'srgb', |
| premultipliedAlpha: true, |
| }, {width: 2, height: 0, depthOrArrayLayers: 0}); |
| } catch {} |
| let textureView309 = texture215.createView({format: 'depth24plus', baseArrayLayer: 23, arrayLayerCount: 2}); |
| try { |
| renderPassEncoder33.setBindGroup(2, bindGroup145, new Uint32Array(250), 20, 0); |
| } catch {} |
| try { |
| renderPassEncoder103.executeBundles([renderBundle10]); |
| } catch {} |
| try { |
| renderPassEncoder15.setPipeline(pipeline1); |
| } catch {} |
| await gc(); |
| let shaderModule21 = device0.createShaderModule({ |
| label: '\u0831\ua3ee\u08f1', |
| code: ` |
| enable f16; |
| |
| enable f16; |
| |
| requires unrestricted_pointer_parameters; |
| |
| diagnostic(info, xyz); |
| |
| fn unconst_bool(v: bool) -> bool { return v; } |
| |
| fn unconst_f16(v: f16) -> f16 { return v; } |
| |
| fn unconst_f32(v: f32) -> f32 { return v; } |
| |
| fn unconst_i32(v: i32) -> i32 { return v; } |
| |
| fn unconst_u32(v: u32) -> u32 { return v; } |
| |
| @group(0) @binding(11) var<storage, read_write> buffer223: array<f16, 56>; |
| |
| struct T0 { |
| @align(16) @size(112) f0: array<atomic<i32>>, |
| } |
| |
| struct VertexOutput20 { |
| @builtin(position) f61: vec4f, |
| } |
| |
| struct FragmentOutput18 { |
| @location(0) f0: vec4f, |
| @builtin(frag_depth) f1: f32, |
| } |
| |
| @id(29639) override override13 = false; |
| |
| @id(25765) override override14: f32; |
| |
| override override15: f16; |
| |
| var<workgroup> vw73: array<f16, 1>; |
| |
| var<workgroup> vw74: atomic<i32>; |
| |
| var<workgroup> vw75: f16; |
| |
| var<workgroup> vw76: vec4h; |
| |
| @vertex |
| fn vertex21(@location(2) a0: vec4h, @location(7) @interpolate(flat) a1: vec2h, @location(13) @interpolate(flat) a2: i32) -> VertexOutput20 { |
| var out: VertexOutput20; |
| var vf462: vec4h = sign(vec4h(unconst_f16(11379.5), unconst_f16(17835.9), unconst_f16(4188.1), unconst_f16(8942.6))); |
| var vf463: f16 = a0[u32(unconst_u32(21))]; |
| return out; |
| } |
| |
| @fragment |
| fn fragment20() -> FragmentOutput18 { |
| var out: FragmentOutput18; |
| let vf464: vec4f = unpack4x8snorm(u32(unconst_u32(50))); |
| out = FragmentOutput18(unpack4x8snorm(u32(unconst_u32(48))), unpack4x8snorm(u32(unconst_u32(48)))[2]); |
| let vf465: vec3i = max(vec3i(unconst_i32(85), unconst_i32(84), unconst_i32(54)), vec3i(unconst_i32(98), unconst_i32(209), unconst_i32(574))); |
| let vf466: bool = override13; |
| out.f1 = floor(saturate(vec2f(unconst_f32(0.3343), unconst_f32(0.1209))).xyy)[2]; |
| let vf467: u32 = pack4x8unorm(vec4f(unconst_f32(0.03253), unconst_f32(-0.07423), unconst_f32(0.1958), unconst_f32(0.06364))); |
| let vf468: f32 = override14; |
| let vf469: bool = override13; |
| let vf470: i32 = vf465[u32(unconst_u32(341))]; |
| out.f1 = saturate(vec2f(unconst_f32(0.02105), unconst_f32(0.5568)))[1]; |
| let vf471: vec3i = max(vec3i(firstTrailingBit(i32(unconst_i32(48)))), vec3i(unconst_i32(171), unconst_i32(58), unconst_i32(-56))); |
| return out; |
| _ = override14; |
| _ = override13; |
| } |
| |
| @compute @workgroup_size(1, 1, 1) |
| fn compute20() { |
| let vf472: f32 = override14; |
| buffer223[u32(unconst_u32(31))] += buffer223[55]; |
| let ptr157: ptr<workgroup, atomic<i32>> = &vw74; |
| var vf473: bool = override13; |
| vf473 = bool(buffer223[u32(unconst_u32(145))]); |
| vw76 = vec4h(vw73[u32(unconst_u32(364))]); |
| let ptr158: ptr<workgroup, atomic<i32>> = &(*&vw74); |
| buffer223[u32(unconst_u32(257))] -= f16(atomicExchange(&(*ptr158), i32(unconst_i32(435)))); |
| buffer223[u32(unconst_u32(256))] = f16(atomicLoad(&(*&vw74))); |
| vw73[u32(unconst_u32(153))] = (*&buffer223)[55]; |
| let vf474: f16 = vw76[u32(unconst_u32(301))]; |
| let ptr159: ptr<storage, array<f16, 56>, read_write> = &(*&buffer223); |
| let vf475: i32 = atomicLoad(&(*&vw74)); |
| _ = override13; |
| _ = override14; |
| }`, |
| sourceMap: {}, |
| hints: {}, |
| }); |
| try { |
| computePassEncoder171.setBindGroup(0, bindGroup72); |
| } catch {} |
| try { |
| computePassEncoder74.setPipeline(pipeline0); |
| } catch {} |
| try { |
| renderPassEncoder65.setBindGroup(1, bindGroup160); |
| } catch {} |
| try { |
| renderPassEncoder4.setVertexBuffer(1, buffer83, 1_160, 14_110); |
| } catch {} |
| videoFrame0.close(); |
| videoFrame1.close(); |
| videoFrame2.close(); |
| videoFrame3.close(); |
| videoFrame4.close(); |
| videoFrame6.close(); |
| videoFrame7.close(); |
| videoFrame8.close(); |
| videoFrame9.close(); |
| videoFrame10.close(); |
| videoFrame11.close(); |
| videoFrame12.close(); |
| videoFrame13.close(); |
| videoFrame14.close(); |
| videoFrame15.close(); |
| videoFrame16.close(); |
| videoFrame18.close(); |
| videoFrame19.close(); |
| videoFrame21.close(); |
| videoFrame22.close(); |
| videoFrame23.close(); |
| videoFrame24.close(); |
| videoFrame25.close(); |
| videoFrame26.close(); |
| videoFrame27.close(); |
| videoFrame28.close(); |
| videoFrame29.close(); |
| videoFrame30.close(); |
| videoFrame31.close(); |
| videoFrame32.close(); |
| videoFrame33.close(); |
| videoFrame34.close(); |
| videoFrame37.close(); |
| videoFrame38.close(); |
| videoFrame39.close(); |
| videoFrame41.close(); |
| videoFrame42.close(); |
| videoFrame43.close(); |
| videoFrame44.close(); |
| videoFrame47.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; } |
| } |
| debug('Pass') |
| } 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); |
| |
| } |
| } |
| globalThis.testRunner?.dumpAsText(); |
| globalThis.testRunner?.notifyDone(); |
| }; |
| </script> |
