Wrote more TGSL

Author: iwoplaza

apps/phoure-www/src/lib-phoure/menderStep.ts

@@ -250,18 +250,18 @@ export const MenderStep = ({ root, gBuffer, targetTexture }: Options) => {
       blurred_tex: gBuffer.upscaledView,
       aux_tex: gBuffer.auxView,
       output_buffer: firstWorkBuffer,
-      // biome-ignore lint/suspicious/noExplicitAny: <its fine>
+      // biome-ignore lint/suspicious/noExplicitAny: its fine
       input_buffer: secondWorkBuffer as any, // <- UNUSED
     }),
     root.createBindGroup(ioLayout, {
-      // biome-ignore lint/suspicious/noExplicitAny: <its fine>
+      // biome-ignore lint/suspicious/noExplicitAny: its fine
       input_buffer: firstWorkBuffer as any,
       output_buffer: secondWorkBuffer,
       blurred_tex: gBuffer.upscaledView, // <- UNUSED
       aux_tex: gBuffer.auxView, // <- UNUSED
     }),
     root.createBindGroup(ioLayout, {
-      // biome-ignore lint/suspicious/noExplicitAny: <its fine>
+      // biome-ignore lint/suspicious/noExplicitAny: its fine
       input_buffer: secondWorkBuffer as any,
       output_buffer: mendedResultBuffer,
       blurred_tex: gBuffer.upscaledView, // <- UNUSED

apps/phoure-www/src/lib/GameEngine/convolve.ts

@@ -1,61 +1,66 @@
 import * as d from 'typegpu/data';
 import tgpu, { type Eventual, type TgpuFn } from 'typegpu';
-
-export type SampleFiller = TgpuFn<
-  (
-    x: d.I32,
-    y: d.I32,
-    outSamplerPtr: d.Ptr<'function', d.WgslArray<d.Vec4f>, 'read-write'>,
-  ) => d.Void
->;
-export type KernelReader = TgpuFn<(idx: d.U32) => d.Vec4f>;
+import { dot } from 'typegpu/std';
 
 /** Has to be divisible by 4 */
 export const inChannelsSlot = tgpu.slot<number>();
 export const outChannelsSlot = tgpu.slot<number>();
 export const kernelRadiusSlot = tgpu.slot<number>();
-const sampleFillerSlot = tgpu.slot<SampleFiller>();
-const kernelReaderSlot = tgpu.slot<KernelReader>();
 
 export const inChannelsQuarter = tgpu['~unstable'].derived(() => {
-  if (inChannelsSlot.value % 4 !== 0) {
+  if (inChannelsSlot.$ % 4 !== 0) {
     throw new Error(`'inChannels' has to be divisible by 4`);
   }
-  return inChannelsSlot.value / 4;
+  return inChannelsSlot.$ / 4;
 });
 
+const SampleArray = tgpu['~unstable'].derived(() =>
+  d.arrayOf(d.vec4f, inChannelsQuarter.$),
+);
+
+const ResultArray = tgpu['~unstable'].derived(() =>
+  d.arrayOf(d.f32, outChannelsSlot.$),
+);
+
+export type SampleFiller = TgpuFn<
+  (
+    x: d.I32,
+    y: d.I32,
+    outSamples: d.Ptr<'function', typeof SampleArray.$, 'read-write'>,
+  ) => d.Void
+>;
+export type KernelReader = TgpuFn<(idx: d.U32) => d.Vec4f>;
+
+const fillSampleSlot = tgpu.slot<SampleFiller>();
+const readKernelSlot = tgpu.slot<KernelReader>();
+
 const _convolveFn = tgpu['~unstable'].derived(() => {
-  return tgpu
-    .fn([d.vec2u, d.ptrFn(d.arrayOf(d.f32, outChannelsSlot.value))])(
-      /* wgsl */ `(coord: vec2u, result: ptr<function, array<f32, outChannels>>) {
-        var sample = array<vec4f, inChannelsQuarter>();
+  return tgpu.fn([d.vec2u, d.ptrFn(ResultArray.$)])((coord, outResult) => {
+    const sample = SampleArray.$();
+    const kernelRadius = d.i32(kernelRadiusSlot.$);
+    const kernelRadiusU = d.u32(kernelRadiusSlot.$);
 
-        var coord_idx: u32 = 0;
-        for (var i: i32 = -i32(kernelRadiusSlot); i <= i32(kernelRadiusSlot); i++) {
-          for (var j: i32 = -i32(kernelRadiusSlot); j <= i32(kernelRadiusSlot); j++) {
-            fillSample(i32(coord.x) + i, i32(coord.y) + j, &sample);
+    let coord_idx = d.u32(0);
+    for (let i = -kernelRadius; i <= kernelRadius; i++) {
+      for (let j = -kernelRadius; j <= kernelRadius; j++) {
+        fillSampleSlot.$(d.i32(coord.x) + i, d.i32(coord.y) + j, sample);
 
-            for (var out_c: u32 = 0; out_c < outChannels; out_c++) {
-              var weight_idx = (coord_idx + out_c * (2 * kernelRadiusSlot + 1) * (2 * kernelRadiusSlot + 1)) * inChannelsQuarter;
-              for (var in_c: u32 = 0; in_c < inChannelsQuarter; in_c++) {
-                (*result)[out_c] += dot(sample[in_c], readKernel(weight_idx));
-                weight_idx++;
-              }
-            }
+        for (let out_c = d.u32(0); out_c < outChannelsSlot.$; out_c++) {
+          let weight_idx =
+            (coord_idx +
+              out_c * (2 * kernelRadiusU + 1) * (2 * kernelRadiusU + 1)) *
+            inChannelsQuarter.$;
 
-            coord_idx++;
+          for (let in_c = d.u32(0); in_c < inChannelsQuarter.$; in_c++) {
+            outResult[out_c] += dot(sample[in_c], readKernelSlot.$(weight_idx));
+            weight_idx++;
           }
         }
-      }`,
-    )
-    .$uses({
-      inChannelsQuarter,
-      outChannels: outChannelsSlot,
-      kernelRadiusSlot,
-      fillSample: sampleFillerSlot,
-      readKernel: kernelReaderSlot,
-    })
-    .$name('_convolveFn');
+
+        coord_idx++;
+      }
+    }
+  });
 });
 
 export const convolveFn = ({
@@ -66,5 +71,5 @@ export const convolveFn = ({
   kernelReader: Eventual<KernelReader>;
 }) =>
   _convolveFn
-    .with(sampleFillerSlot, sampleFiller)
-    .with(kernelReaderSlot, kernelReader);
+    .with(fillSampleSlot, sampleFiller)
+    .with(readKernelSlot, kernelReader);

pnpm-lock.yaml

@@ -4,5 +4,5 @@ packages:
 
 # Define a catalog of version ranges.
 catalog:
-  typegpu: ^0.7.0
+  typegpu: https://pkg.pr.new/software-mansion/TypeGPU/typegpu@c81e38bfa323506e5933b26e7e5965450c68217b
   unplugin-typegpu: ^0.2.2