fix: Allow empty vertex auto-in

Author: iwoplaza

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<{}>;
 }
 
 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<{}>;
 }
 
 export function vertexFn<VertexOut extends VertexOutConstrained>(options: {

packages/typegpu/tests/renderPipeline.test.ts

@@ -6,8 +6,10 @@ import tgpu, {
   common,
   d,
   MissingBindGroupsError,
+  type TgpuFragmentFn,
   type TgpuFragmentFnShell,
   type TgpuRenderPipeline,
+  type TgpuVertexFn,
   type TgpuVertexFnShell,
 } from '../src/index.js';
 import { $internal } from '../src/shared/symbols.ts';
@@ -1591,7 +1593,7 @@ describe('root.createRenderPipeline', () => {
       attribs: { vertexIndex: vertexLayout.attrib },
       vertex: ({ vertexIndex, $vertexIndex }) => {
         'use gpu';
-        return { $position: d.vec4f() };
+        return { $position: d.vec4f(vertexIndex, $vertexIndex, 0, 1) };
       },
       fragment: () => {
         'use gpu';
@@ -1619,7 +1621,7 @@ describe('root.createRenderPipeline', () => {
       },
       fragment: ({ position }) => {
         'use gpu';
-        return d.vec4f();
+        return position;
       },
       targets: { format: 'rgba8unorm' },
     });
@@ -1641,7 +1643,10 @@ describe('root.createRenderPipeline', () => {
       },
       fragment: ({ $frontFacing, frontFacing }) => {
         'use gpu';
-        return d.vec4f();
+        if ($frontFacing && frontFacing === 1) {
+          return d.vec4f(0, 1, 0, 1);
+        }
+        return d.vec4f(1, 0, 0, 1);
       },
       targets: { format: 'rgba8unorm' },
     });
@@ -1774,6 +1779,54 @@ describe('root.createRenderPipeline', () => {
       ]
     `);
   });
+
+  it('accepts entry functions with no attributes or varyings', ({ root }) => {
+    const positions = tgpu.const(d.arrayOf(d.vec2f, 3), [
+      d.vec2f(0, 0),
+      d.vec2f(1, 0),
+      d.vec2f(0, 1),
+    ]);
+    const vertex = ({ $vertexIndex }: TgpuVertexFn.AutoInEmpty) => {
+      'use gpu';
+      return {
+        $position: d.vec4f(positions.$[$vertexIndex]!, 0, 1),
+      } satisfies TgpuVertexFn.AutoOut;
+    };
+
+    const fragment = ({ $position }: TgpuFragmentFn.AutoInEmpty) => {
+      'use gpu';
+      return d.vec4f($position);
+    };
+
+    const pipeline = root.createRenderPipeline({
+      vertex,
+      fragment,
+    });
+
+    expect(tgpu.resolve([pipeline])).toMatchInlineSnapshot(`
+      "const positions: array<vec2f, 3> = array<vec2f, 3>(vec2f(), vec2f(1, 0), vec2f(0, 1));
+
+      struct VertexOut {
+        @builtin(position) position: vec4f,
+      }
+
+      struct VertexIn {
+        @builtin(vertex_index) vertexIndex: u32,
+      }
+
+      @vertex fn vertex(_arg_0: VertexIn) -> VertexOut {
+        return VertexOut(vec4f(positions[_arg_0.vertexIndex], 0f, 1f));
+      }
+
+      struct FragmentIn {
+        @builtin(position) position: vec4f,
+      }
+
+      @fragment fn fragment(_arg_0: FragmentIn) -> @location(0) vec4f {
+        return _arg_0.position;
+      }"
+    `);
+  });
 });
 
 describe('matchUpVaryingLocations', () => {