feat: makeDereferencable

packages/typegpu/src/tgsl/makeDereferencable.ts

@@ -0,0 +1,49 @@
+import { snip, type Origin } from '../data/snippet.ts';
+import type { BaseData } from '../data/wgslTypes.ts';
+import { $gpuValueOf, $internal, $ownSnippet, $resolve } from '../shared/symbols.ts';
+import { valueProxyHandler } from '../core/valueProxyUtils.ts';
+import type { SelfResolvable } from '../types.ts';
+import { inCodegenMode } from '../execMode.ts';
+
+export function makeDereferencable<T extends SelfResolvable>(
+  value: T,
+  options: makeDereferencable.Options<T>,
+): T {
+  Object.defineProperty(value, $gpuValueOf, {
+    get() {
+      const [dataType, origin] = options.getDataTypeAndOrigin.apply(this);
+
+      return new Proxy(
+        {
+          [$internal]: true,
+          get [$ownSnippet]() {
+            return snip(this, dataType, origin);
+          },
+          [$resolve]: (ctx) => ctx.resolve(this),
+          toString: () => `${this.toString()}.$`,
+        },
+        valueProxyHandler,
+      );
+    },
+  });
+
+  Object.defineProperty(value, '$', {
+    get() {
+      if (inCodegenMode()) {
+        return this[$gpuValueOf];
+      }
+      // TODO: Add proper error message
+      throw new Error(
+        'Cannot read WebGL uniform outside of shader code. Use `.write()` to update it.',
+      );
+    },
+  });
+
+  return value;
+}
+
+export namespace makeDereferencable {
+  export interface Options<T> {
+    getDataTypeAndOrigin(this: T): [dataType: BaseData, origin: Origin];
+  }
+}

packages/typegpu/src/tgsl/makeResolvable.ts

@@ -0,0 +1,52 @@
+import { snip, type Origin, type ResolvedSnippet } from '../data/snippet.ts';
+import { type BaseData } from '../data/wgslTypes.ts';
+import { $internal, $resolve, isMarkedInternal } from '../shared/symbols.ts';
+import type { ResolutionCtx, SelfResolvable } from '../types.ts';
+
+/**
+ *
+ * @param value
+ * @param options
+ * @returns
+ */
+export function makeResolvable<T>(
+  value: T,
+  options: makeResolvable.Options<T>,
+): T & SelfResolvable {
+  if (!isMarkedInternal(value)) {
+    Object.defineProperty(value, $internal, {
+      value: true,
+    });
+  }
+
+  Object.defineProperty(value, 'toString', {
+    value() {
+      return options.asString.apply(this);
+    },
+  });
+
+  Object.defineProperty(value, $resolve, {
+    value(ctx: ResolutionCtx): ResolvedSnippet {
+      const protoSnippet = options.resolve.apply(this, [ctx]);
+
+      return snip(protoSnippet.value, protoSnippet.dataType, protoSnippet.origin);
+    },
+  });
+
+  return value as T & SelfResolvable;
+}
+
+interface ProtoSnippet {
+  value: string;
+  dataType: BaseData;
+  origin: Origin;
+}
+
+export namespace makeResolvable {
+  export interface Options<T> {
+    resolve(this: T, ctx: ResolutionCtx): ProtoSnippet;
+    asString(this: T): string;
+  }
+
+  export type Resolvable = SelfResolvable;
+}

packages/typegpu/src/tgsl/shaderGenerator_members.ts

@@ -6,6 +6,8 @@ import type { Snippet } from '../data/snippet.ts';
 
 export { UnknownData } from '../data/dataTypes.ts';
 export { getName } from '../shared/meta.ts';
+export { makeDereferencable } from './makeDereferencable.ts';
+export { makeResolvable } from './makeResolvable.ts';
 
 // types
 export type { ResolutionCtx, FunctionArgument, TgpuShaderStage } from '../types.ts';