Simplify more code

Author: iwoplaza

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

@@ -1,5 +1,5 @@
-import { convertRgbToY } from '@typegpu/color';
 import { accessViewportSize } from '@typegpu/common';
+import { convertRgbToY } from '@typegpu/color';
 import tgpu, { type TgpuRoot } from 'typegpu';
 import * as d from 'typegpu/data';
 import * as std from 'typegpu/std';
@@ -66,62 +66,58 @@ const ioLayout = tgpu.bindGroupLayout({
 const { weights, biases } = layerLayout.bound;
 
 const sampleGlobal = tgpu['~unstable'].derived(() => {
-  return tgpu
-    .fn([d.i32, d.i32, d.ptrFn(d.arrayOf(d.vec4f, inChannelsQuarter.value))])(
-      (x, y, result) => {
-        const canvasSize = accessViewportSize.value;
-        const coord = d.vec2u(
-          d.u32(std.max(0, std.min(x, d.i32(canvasSize.x) - 1))),
-          d.u32(std.max(0, std.min(y, d.i32(canvasSize.y) - 1))),
-        );
-
-        if (inputFromGBufferSlot.$) {
-          const blurred = std.textureLoad(ioLayout.$.blurred_tex, coord, 0);
-
-          const aux = std.textureLoad(ioLayout.$.aux_tex, coord, 0);
-
-          result[0] = d.vec4f(
-            convertRgbToY(blurred.xyz),
-            aux.z, // albedo luminance
-            aux.x, // normal.x
-            aux.y, // normal.y
-          );
-          result[1] = d.vec4f(
-            aux.w, // emission luminance
-            0, // zero padding
-            0, // zero padding
-            0, // zero padding
-          );
-        } else {
-          for (let i = d.u32(0); i < inChannelsQuarter.value; i++) {
-            const index =
-              (coord.y * d.u32(canvasSize.x) + coord.x) *
-                inChannelsQuarter.value +
-              i;
-
-            result[i] = ioLayout.$.input_buffer[index];
-          }
-        }
-      },
-    )
-    .$name('sample_global');
+  return tgpu.fn([
+    d.i32,
+    d.i32,
+    d.ptrFn(d.arrayOf(d.vec4f, inChannelsQuarter.$)),
+  ])((x, y, result) => {
+    const canvasSize = accessViewportSize.$;
+    const coord = d.vec2u(
+      d.u32(std.max(0, std.min(x, d.i32(canvasSize.x) - 1))),
+      d.u32(std.max(0, std.min(y, d.i32(canvasSize.y) - 1))),
+    );
+
+    if (inputFromGBufferSlot.$) {
+      const blurred = std.textureLoad(ioLayout.$.blurred_tex, coord, 0);
+
+      const aux = std.textureLoad(ioLayout.$.aux_tex, coord, 0);
+
+      result[0] = d.vec4f(
+        convertRgbToY(blurred.xyz),
+        aux.z, // albedo luminance
+        aux.x, // normal.x
+        aux.y, // normal.y
+      );
+      result[1] = d.vec4f(
+        aux.w, // emission luminance
+        0, // zero padding
+        0, // zero padding
+        0, // zero padding
+      );
+    } else {
+      for (let i = d.u32(0); i < inChannelsQuarter.$; i++) {
+        const index =
+          (coord.y * d.u32(canvasSize.x) + coord.x) * inChannelsQuarter.$ + i;
+
+        result[i] = ioLayout.$.input_buffer[index];
+      }
+    }
+  });
 });
 
 const f32Array = (n: number) => d.arrayOf(d.f32, n);
 
 const applyReLU = tgpu['~unstable'].derived(() => {
-  const outChannels = outChannelsSlot.value;
+  const outChannels = outChannelsSlot.$;
 
-  return tgpu['~unstable']
-    .fn([d.ptrFn(f32Array(outChannels))])((result) => {
-      for (let i = 0; i < outChannels; i++) {
-        result[i] = std.max(0, result[i]);
-      }
-    })
-    .$name('apply_relu');
+  return tgpu.fn([d.ptrFn(f32Array(outChannels))])((result) => {
+    for (let i = 0; i < outChannels; i++) {
+      result[i] = std.max(0, result[i]);
+    }
+  });
 });
 
-const readKernel = tgpu.fn([d.u32], d.vec4f)((idx) => weights.value[idx]);
+const readKernel = tgpu.fn([d.u32], d.vec4f)((idx) => weights.$[idx]);
 
 const menderConvolveFn = convolveFn({
   sampleFiller: sampleGlobal,
@@ -168,27 +164,24 @@ const entryComputeFn = tgpu['~unstable'].computeFn({
 export const MenderStep = ({ root, gBuffer, targetTexture }: Options) => {
   // Resource locators
 
-  const viewportSizeBuffer = root.createBuffer(d.vec2f).$usage('uniform');
+  const viewportSizeUniform = root.createUniform(d.vec2f);
 
   // Textures
 
   const firstWorkBuffer = root
     .createBuffer(
       d.arrayOf(d.f32, gBuffer.size[0] * gBuffer.size[1] * FIRST_DEPTH),
     )
-    .$name('First Work Buffer')
     .$usage('storage');
 
   const secondWorkBuffer = root
     .createBuffer(
       d.arrayOf(d.f32, gBuffer.size[0] * gBuffer.size[1] * SECOND_DEPTH),
     )
-    .$name('Second Work Buffer')
     .$usage('storage');
 
   const mendedResultBuffer = root
     .createBuffer(d.arrayOf(d.f32, gBuffer.size[0] * gBuffer.size[1]))
-    .$name('Mender Result Buffer')
     .$usage('storage');
 
   //
@@ -217,7 +210,7 @@ export const MenderStep = ({ root, gBuffer, targetTexture }: Options) => {
         .with(outChannelsSlot, options.outChannels)
         .with(reluSlot, options.relu)
         .with(inputFromGBufferSlot, options.inputFromGBuffer)
-        .with(accessViewportSize, viewportSizeBuffer.as('uniform'))
+        .with(accessViewportSize, viewportSizeUniform)
         // ---
         .withCompute(entryComputeFn)
         .createPipeline()
@@ -281,7 +274,7 @@ export const MenderStep = ({ root, gBuffer, targetTexture }: Options) => {
   // ---
 
   const combinationPipeline = root['~unstable']
-    .with(accessViewportSize, viewportSizeBuffer.as('uniform'))
+    .with(accessViewportSize, viewportSizeUniform)
     .withVertex(fullScreenQuadVertexFn, {})
     .withFragment(combinationEntryFn, { format: 'rgba8unorm' })
     .createPipeline();
@@ -291,7 +284,7 @@ export const MenderStep = ({ root, gBuffer, targetTexture }: Options) => {
     mendedBuffer: mendedResultBuffer,
   });
 
-  viewportSizeBuffer.write(d.vec2f(...gBuffer.size));
+  viewportSizeUniform.write(d.vec2f(...gBuffer.size));
 
   return {
     perform() {

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

@@ -1,29 +1,21 @@
+import * as d from 'typegpu/data';
 import tgpu, { type Eventual, type TgpuFn } from 'typegpu';
-import {
-  arrayOf,
-  f32,
-  type I32,
-  type Ptr,
-  ptrFn,
-  type U32,
-  vec2u,
-  type Vec4f,
-  type WgslArray,
-} from 'typegpu/data';
 
 export type SampleFiller = TgpuFn<
-  (x: I32, y: I32, outSamplerPtr: Ptr<'function', WgslArray<Vec4f>>) => void
+  (
+    x: d.I32,
+    y: d.I32,
+    outSamplerPtr: d.Ptr<'function', d.WgslArray<d.Vec4f>, 'read-write'>,
+  ) => d.Void
 >;
-export type KernelReader = TgpuFn<(idx: U32) => Vec4f>;
+export type KernelReader = TgpuFn<(idx: d.U32) => d.Vec4f>;
 
-/**
- * Has to be divisible by 4
- */
-export const inChannelsSlot = tgpu.slot<number>().$name('in_channels');
-export const outChannelsSlot = tgpu.slot<number>().$name('out_channels');
-export const kernelRadiusSlot = tgpu.slot<number>().$name('kernel_radius');
-const sampleFillerSlot = tgpu.slot<SampleFiller>().$name('sample_filler');
-const kernelReaderSlot = tgpu.slot<KernelReader>().$name('kernel_reader');
+/** 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) {
@@ -34,7 +26,7 @@ export const inChannelsQuarter = tgpu['~unstable'].derived(() => {
 
 const _convolveFn = tgpu['~unstable'].derived(() => {
   return tgpu
-    .fn([vec2u, ptrFn(arrayOf(f32, outChannelsSlot.value))])(
+    .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>();