Merge branch 'main' into impr/operator-!

Author: cieplypolar

packages/typegpu/src/core/function/autoIO.ts

@@ -7,7 +7,7 @@ import type { BaseData, v4f } from '../../data/wgslTypes.ts';
 import { getName, setName } from '../../shared/meta.ts';
 import type { InferGPU, InferGPURecord, InferRecord } from '../../shared/repr.ts';
 import { $internal, $resolve } from '../../shared/symbols.ts';
-import type { Assume } from '../../shared/utilityTypes.ts';
+import type { Assume, RemoveIndexSignature } from '../../shared/utilityTypes.ts';
 import type { TgpuVertexAttrib } from '../../shared/vertexFormat.ts';
 import type { ResolutionCtx, SelfResolvable } from '../../types.ts';
 import { shaderStageSlot } from '../slot/internalSlots.ts';
@@ -21,7 +21,8 @@ const builtinVertexIn = {
   $instanceIndex: builtin.instanceIndex,
 } as const;
 
-export type AutoVertexIn<T extends AnyAutoCustoms> = T & InferRecord<typeof builtinVertexIn>;
+export type AutoVertexIn<T extends AnyAutoCustoms> = RemoveIndexSignature<T> &
+  InferRecord<typeof builtinVertexIn>;
 
 export type _AutoVertexIn<T> = AutoVertexIn<{
   [Key in keyof T]: T[Key] extends TgpuVertexAttrib
@@ -47,7 +48,8 @@ const builtinFragmentIn = {
   $subgroupSize: builtin.subgroupSize,
 } as const;
 
-export type AutoFragmentIn<T extends AnyAutoCustoms> = T & InferRecord<typeof builtinFragmentIn>;
+export type AutoFragmentIn<T extends AnyAutoCustoms> = RemoveIndexSignature<T> &
+  InferRecord<typeof builtinFragmentIn>;
 
 const builtinFragmentOut = {
   $fragDepth: builtin.fragDepth,

packages/typegpu/src/core/function/fnTypes.ts

@@ -23,7 +23,7 @@ import type {
   Vec4u,
   Void,
 } from '../../data/wgslTypes.ts';
-import type { Infer } from '../../shared/repr.ts';
+import type { InferGPU } from '../../shared/repr.ts';
 
 export type AnyFn = (...args: never[]) => unknown;
 
@@ -41,7 +41,7 @@ export type TranspilationResult = {
 };
 
 export type InferArgs<T extends unknown[]> = {
-  [Idx in keyof T]: Infer<T[Idx]>;
+  [Idx in keyof T]: InferGPU<T[Idx]>;
 };
 
 type InheritTupleValues<T, From> = {
@@ -65,7 +65,7 @@ export type InheritArgNames<T extends AnyFn, From extends AnyFn> = {
 
 export type InferImplSchema<ImplSchema extends AnyFn> = (
   ...args: InferArgs<Parameters<ImplSchema>>
-) => Infer<ReturnType<ImplSchema>>;
+) => InferGPU<ReturnType<ImplSchema>>;
 
 export type Implementation<ImplSchema extends AnyFn = AnyFn> = string | InferImplSchema<ImplSchema>;
 
@@ -101,9 +101,9 @@ export type IOLayout<TElementType extends IOData = IOData> =
   | Void;
 
 export type InferIO<T> = T extends { type: string }
-  ? Infer<T>
+  ? InferGPU<T>
   : T extends Record<string, unknown>
-    ? { [K in keyof T]: Infer<T[K]> }
+    ? { [K in keyof T]: InferGPU<T[K]> }
     : T;
 
 export interface PositionalArgInfo {

packages/typegpu/src/core/function/tgpuFn.ts

@@ -6,7 +6,7 @@ import { provideInsideTgpuFn } from '../../execMode.ts';
 import type { TgpuNamable } from '../../shared/meta.ts';
 import { getName, setName } from '../../shared/meta.ts';
 import { isMarkedInternal } from '../../shared/symbols.ts';
-import type { Infer } from '../../shared/repr.ts';
+import type { InferGPU } from '../../shared/repr.ts';
 import { $getNameForward, $internal, $providing, $resolve } from '../../shared/symbols.ts';
 import type { Prettify } from '../../shared/utilityTypes.ts';
 import type { DualFn, ResolutionCtx, SelfResolvable } from '../../types.ts';
@@ -56,7 +56,7 @@ export type TgpuFnShell<Args extends BaseData[], Return extends BaseData> = Tgpu
   Args,
   Return
 > &
-  (<T extends (...args: InferArgs<Args>) => Infer<Return>>(
+  (<T extends (...args: InferArgs<Args>) => InferGPU<Return>>(
     implementation: T,
   ) => TgpuFn<Prettify<InheritArgNames<(...args: Args) => Return, T>>['result']>) &
   ((implementation: string) => TgpuFn<(...args: Args) => Return>) &

packages/typegpu/src/core/function/tgpuFragmentFn.ts

@@ -121,6 +121,8 @@ export declare namespace TgpuFragmentFn {
   type Out = Record<string, BaseData> | BaseData;
   type AutoIn<T extends AnyAutoCustoms> = AutoFragmentIn<T>;
   type AutoOut<T extends AnyAutoCustoms = AnyAutoCustoms> = AutoFragmentOut<T>;
+
+  type AutoInEmpty = AutoFragmentIn<Record<string, never>>;
 }
 
 export function fragmentFn<FragmentOut extends FragmentOutConstrained>(options: {

packages/typegpu/src/core/function/tgpuVertexFn.ts

@@ -86,6 +86,8 @@ export declare namespace TgpuVertexFn {
   type Out = Record<string, BaseData>;
   type AutoIn<T> = _AutoVertexIn<T>;
   type AutoOut<T extends AnyAutoCustoms = AnyAutoCustoms> = AutoVertexOut<T>;
+
+  type AutoInEmpty = _AutoVertexIn<Record<string, never>>;
 }
 
 export function vertexFn<VertexOut extends VertexOutConstrained>(options: {

packages/typegpu/src/core/pipeline/computePipeline.ts

@@ -220,7 +220,21 @@ class TgpuComputePipelineImpl implements TgpuComputePipeline {
   }
 
   withPerformanceCallback(callback: (start: bigint, end: bigint) => void | Promise<void>): this {
-    const newPriors = createWithPerformanceCallback(this.#priors, callback, this.#core.root);
+    if (this.#priors.timestampWrites) {
+      return new TgpuComputePipelineImpl(this.#core, {
+        ...this.#priors,
+        performanceCallback: callback,
+      }) as this;
+    }
+
+    const querySet = this.#core.performanceCallbackQuerySet;
+    if (!querySet) {
+      console.warn(
+        'Performance callback cannot be used because the timestamp-query feature is not enabled on the root.',
+      );
+      return this;
+    }
+    const newPriors = createWithPerformanceCallback(this.#priors, callback, querySet);
     return new TgpuComputePipelineImpl(this.#core, newPriors) as this;
   }
 
@@ -353,6 +367,7 @@ class ComputePipelineCore implements SelfResolvable {
 
   #slotBindings: [TgpuSlot<unknown>, unknown][];
   #descriptor: TgpuComputePipeline.Descriptor;
+  #performanceCallbackQuerySet: TgpuQuerySet<'timestamp'> | undefined;
 
   constructor(
     root: ExperimentalTgpuRoot,
@@ -375,6 +390,13 @@ class ComputePipelineCore implements SelfResolvable {
     return 'computePipelineCore';
   }
 
+  get performanceCallbackQuerySet() {
+    if (!this.root.enabledFeatures.has('timestamp-query')) {
+      return undefined;
+    }
+    return (this.#performanceCallbackQuerySet ??= this.root.createQuerySet('timestamp', 2));
+  }
+
   public unwrap(): Memo {
     if (this._memo === undefined) {
       const device = this.root.device;

packages/typegpu/src/core/pipeline/renderPipeline.ts

@@ -550,11 +550,22 @@ class TgpuRenderPipelineImpl implements TgpuRenderPipeline {
 
   withPerformanceCallback(callback: (start: bigint, end: bigint) => void | Promise<void>): this {
     const internals = this[$internal];
-    const newPriors = createWithPerformanceCallback(
-      internals.priors,
-      callback,
-      internals.core.options.root,
-    );
+
+    if (internals.priors.timestampWrites) {
+      return new TgpuRenderPipelineImpl(internals.core, {
+        ...internals.priors,
+        performanceCallback: callback,
+      }) as this;
+    }
+
+    const querySet = internals.core.performanceCallbackQuerySet;
+    if (!querySet) {
+      console.warn(
+        'Performance callback cannot be used because the timestamp-query feature is not enabled on the root.',
+      );
+      return this;
+    }
+    const newPriors = createWithPerformanceCallback(internals.priors, callback, querySet);
     return new TgpuRenderPipelineImpl(internals.core, newPriors) as this;
   }
 
@@ -955,6 +966,7 @@ class RenderPipelineCore implements SelfResolvable {
 
   #latestAutoVertexIn: TgpuVertexFn.In | undefined;
   #latestAutoFragmentOut: BaseData | undefined;
+  #performanceCallbackQuerySet: TgpuQuerySet<'timestamp'> | undefined;
 
   constructor(options: RenderPipelineCoreOptions) {
     this.options = options;
@@ -1011,6 +1023,13 @@ class RenderPipelineCore implements SelfResolvable {
     return 'renderPipelineCore';
   }
 
+  get performanceCallbackQuerySet() {
+    if (!this.options.root.enabledFeatures.has('timestamp-query')) {
+      return undefined;
+    }
+    return (this.#performanceCallbackQuerySet ??= this.options.root.createQuerySet('timestamp', 2));
+  }
+
   public unwrap(): Memo {
     if (this._memo !== undefined) {
       return this._memo;

packages/typegpu/src/core/pipeline/timeable.ts

@@ -19,27 +19,19 @@ export type TimestampWritesPriors = {
     endOfPassWriteIndex?: number;
   };
   readonly performanceCallback?: (start: bigint, end: bigint) => void | Promise<void>;
-  readonly hasAutoQuerySet?: boolean;
 };
 
 export function createWithPerformanceCallback<T extends TimestampWritesPriors>(
   currentPriors: T,
   callback: (start: bigint, end: bigint) => void | Promise<void>,
-  root: ExperimentalTgpuRoot,
+  querySet: TgpuQuerySet<'timestamp'>,
 ): T {
-  if (!root.enabledFeatures.has('timestamp-query')) {
-    throw new Error(
-      'Performance callback requires the "timestamp-query" feature to be enabled on GPU device.',
-    );
-  }
-
   if (!currentPriors.timestampWrites) {
     return {
       ...currentPriors,
       performanceCallback: callback,
-      hasAutoQuerySet: true,
       timestampWrites: {
-        querySet: root.createQuerySet('timestamp', 2),
+        querySet,
         beginningOfPassWriteIndex: 0,
         endOfPassWriteIndex: 1,
       },
@@ -67,10 +59,6 @@ export function createWithTimestampWrites<T extends TimestampWritesPriors>(
     );
   }
 
-  if (currentPriors.hasAutoQuerySet && currentPriors.timestampWrites) {
-    currentPriors.timestampWrites.querySet.destroy();
-  }
-
   const timestampWrites: TimestampWritesPriors['timestampWrites'] = {
     querySet: options.querySet,
   };
@@ -84,7 +72,6 @@ export function createWithTimestampWrites<T extends TimestampWritesPriors>(
 
   return {
     ...currentPriors,
-    hasAutoQuerySet: false,
     timestampWrites,
   };
 }

packages/typegpu/src/shared/utilityTypes.ts

@@ -56,7 +56,7 @@ export type Mutable<T> = {
 };
 
 /**
- * Source: https://code.lol/post/programming/higher-kinded-types/
+ * Source: https://code.lol/post/programming/higher-kinded-types
  */
 export type Assume<T, U> = T extends U ? T : U;
 
@@ -74,3 +74,16 @@ export type TypedArray =
 export function assertExhaustive(x: never, location: string): never {
   throw new Error(`Failed to handle ${x} at ${location}`);
 }
+
+/**
+ * Source: https://futurestud.io/tutorials/typescript-how-to-remove-index-signature-from-a-type
+ */
+export type RemoveIndexSignature<T> = {
+  [K in keyof T as string extends K
+    ? never
+    : number extends K
+      ? never
+      : symbol extends K
+        ? never
+        : K]: T[K];
+};

packages/typegpu/tests/computePipeline.test.ts

@@ -141,23 +141,24 @@ describe('TgpuComputePipeline', () => {
       expect(pipeline[$internal].priors.performanceCallback).not.toBe(callback1);
     });
 
-    it('should throw error if timestamp-query feature is not enabled', ({ root, device }) => {
-      const originalFeatures = device.features;
-      //@ts-expect-error
+    it('should warn if timestamp-query feature is not enabled', ({ root, device }) => {
+      // @ts-expect-error
       device.features = new Set();
+      using consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
 
       const entryFn = tgpu.computeFn({ workgroupSize: [1] })(() => {});
 
       const callback = vi.fn();
 
       expect(() => {
-        root.createComputePipeline({ compute: entryFn }).withPerformanceCallback(callback);
-      }).toThrow(
-        'Performance callback requires the "timestamp-query" feature to be enabled on GPU device.',
+        const before = root.createComputePipeline({ compute: entryFn });
+        const after = before.withPerformanceCallback(callback);
+        // no-op
+        expect(after).toBe(before);
+      }).not.toThrow();
+      expect(consoleWarnSpy).toHaveBeenCalledWith(
+        'Performance callback cannot be used because the timestamp-query feature is not enabled on the root.',
       );
-
-      //@ts-expect-error
-      device.features = originalFeatures;
     });
   });
 
@@ -331,6 +332,7 @@ describe('TgpuComputePipeline', () => {
   describe('Combined Performance callback and Timestamp Writes', () => {
     it('should work with both performance callback and custom timestamp writes', ({
       root,
+      device,
       commandEncoder,
     }) => {
       const entryFn = tgpu.computeFn({ workgroupSize: [1] })(() => {});
@@ -371,6 +373,12 @@ describe('TgpuComputePipeline', () => {
         querySet[$internal].resolveBuffer,
         0,
       );
+
+      expect(device.mock.createQuerySet).toHaveBeenCalledTimes(1);
+      expect(device.mock.createQuerySet).toHaveBeenCalledWith({
+        type: 'timestamp',
+        count: 10,
+      });
     });
 
     it('should prioritize custom timestamp writes over automatic ones', ({
@@ -394,8 +402,6 @@ describe('TgpuComputePipeline', () => {
         endOfPassWriteIndex: 5,
       });
 
-      expect((autoQuerySet as TgpuQuerySet<'timestamp'>).destroyed).toBe(true);
-
       const priors = pipeline[$internal].priors;
       expect(priors.performanceCallback).toBe(callback);
       expect(priors.timestampWrites?.querySet).toBe(querySet);