Merge branch 'main' into chore/unplugin-dep-upgrade

iwoplaza · web-flow · commit 2c1948ceaa3a · 2025-07-28T11:59:56.000+02:00
diff --git a/packages/typegpu/src/data/vectorOps.ts b/packages/typegpu/src/data/vectorOps.ts
@@ -746,23 +746,6 @@ export const VectorOps = {
     vec4u: binaryComponentWise4u(divInteger),
   } as Record<VecKind, <T extends vBase>(a: T, b: T) => T>,
 
-  divMixed: {
-    vec2f: (a: wgsl.v2f, b: number) => unary2f((e) => e / b)(a),
-    vec2h: (a: wgsl.v2h, b: number) => unary2h((e) => e / b)(a),
-    vec2i: (a: wgsl.v2i, b: number) => unary2i((e) => divInteger(e, b))(a),
-    vec2u: (a: wgsl.v2u, b: number) => unary2u((e) => divInteger(e, b))(a),
-
-    vec3f: (a: wgsl.v3f, b: number) => unary3f((e) => e / b)(a),
-    vec3h: (a: wgsl.v3h, b: number) => unary3h((e) => e / b)(a),
-    vec3i: (a: wgsl.v3i, b: number) => unary3i((e) => divInteger(e, b))(a),
-    vec3u: (a: wgsl.v3u, b: number) => unary3u((e) => divInteger(e, b))(a),
-
-    vec4f: (a: wgsl.v4f, b: number) => unary4f((e) => e / b)(a),
-    vec4h: (a: wgsl.v4h, b: number) => unary4h((e) => e / b)(a),
-    vec4i: (a: wgsl.v4i, b: number) => unary4i((e) => divInteger(e, b))(a),
-    vec4u: (a: wgsl.v4u, b: number) => unary4u((e) => divInteger(e, b))(a),
-  } as Record<VecKind, <T extends vBase>(lhs: T, rhs: number) => T>,
-
   dot: {
     vec2f: dotVec2,
     vec2h: dotVec2,
diff --git a/packages/typegpu/src/std/numeric.ts b/packages/typegpu/src/std/numeric.ts
@@ -1,5 +1,10 @@
 import { vecTypeToConstructor } from '../data/vector.ts';
-import { type AnyData, snip, type Snippet } from '../data/dataTypes.ts';
+import {
+  type AnyData,
+  snip,
+  type Snippet,
+  type TgpuDualFn,
+} from '../data/dataTypes.ts';
 import { smoothstepScalar } from '../data/numberOps.ts';
 import { f32 } from '../data/numeric.ts';
 import { VectorOps } from '../data/vectorOps.ts';
@@ -195,37 +200,32 @@ export const mul = createDualImpl(
   'mul',
 );
 
-function cpuDiv(lhs: number, rhs: number): number; // default js division
-function cpuDiv<MV extends NumVec>(lhs: number, rhs: MV): MV; // scale
-function cpuDiv<MV extends NumVec>(lhs: MV, rhs: number): MV; // scale
-function cpuDiv<V extends NumVec>(lhs: V, rhs: V): V; // component-wise division
-function cpuDiv<
-  // union overload
-  Lhs extends number | NumVec,
-  Rhs extends (Lhs extends number ? number | NumVec
-    : Lhs extends NumVec ? number | Lhs
-    : never),
->(lhs: Lhs, rhs: Rhs): Lhs | Rhs;
-function cpuDiv(lhs: number | NumVec, rhs: number | NumVec) {
-  if (typeof lhs === 'number' && typeof rhs === 'number') {
-    return (lhs / rhs);
-  }
-  if (typeof lhs === 'number' && isVecInstance(rhs)) {
-    return VectorOps.divMixed[rhs.kind](rhs, lhs);
-  }
-  if (isVecInstance(lhs) && typeof rhs === 'number') {
-    return VectorOps.divMixed[lhs.kind](lhs, rhs);
-  }
-  if (isVecInstance(lhs) && isVecInstance(rhs)) {
-    return VectorOps.div[lhs.kind](lhs, rhs);
-  }
-
-  throw new Error('Div called with invalid arguments.');
-}
+type DivOverload = {
+  (lhs: number, rhs: number): number; // default js division
+  <T extends NumVec | number>(lhs: T, rhs: T): T; // component-wise division
+  <T extends NumVec | number>(lhs: number, rhs: T): T; // mixed division
+  <T extends NumVec | number>(lhs: T, rhs: number): T; // mixed division
+};
 
-export const div = createDualImpl(
+export const div: TgpuDualFn<DivOverload> = createDualImpl(
   // CPU implementation
-  cpuDiv,
+  <T extends NumVec | number>(lhs: T, rhs: T): T => {
+    if (typeof lhs === 'number' && typeof rhs === 'number') {
+      return (lhs / rhs) as T;
+    }
+    if (typeof lhs === 'number' && isVecInstance(rhs)) {
+      const schema = vecTypeToConstructor[rhs.kind];
+      return VectorOps.div[rhs.kind](schema(lhs), rhs) as T;
+    }
+    if (isVecInstance(lhs) && typeof rhs === 'number') {
+      const schema = vecTypeToConstructor[lhs.kind];
+      return VectorOps.div[lhs.kind](lhs, schema(rhs)) as T;
+    }
+    if (isVecInstance(lhs) && isVecInstance(rhs)) {
+      return VectorOps.div[lhs.kind](lhs, rhs) as T;
+    }
+    throw new Error('Div called with invalid arguments.');
+  },
   // GPU implementation
   (lhs, rhs) => {
     if (isSnippetNumeric(lhs) && isSnippetNumeric(rhs)) {
diff --git a/packages/typegpu/tests/std/numeric/div.test.ts b/packages/typegpu/tests/std/numeric/div.test.ts
@@ -29,8 +29,9 @@ describe('div', () => {
     expect(isCloseTo(div(vec3f(1, 2, 3), 3), vec3f(0.333, 0.666, 1))).toBe(
       true,
     );
-    expect(isCloseTo(div(vec4f(1, 2, 3, 4), 4), vec4f(0.25, 0.5, 0.75, 1)))
-      .toBe(true);
+    expect(
+      isCloseTo(div(vec4f(1, 2, 3, 4), 4), vec4f(0.25, 0.5, 0.75, 1)),
+    ).toBe(true);
   });
 
   it('computes quotient of vecNi and a number', () => {
@@ -40,41 +41,35 @@ describe('div', () => {
   });
 
   it('computes quotient of a number and vecNf', () => {
-    expect(isCloseTo(div(2, vec2f(1, 2)), vec2f(0.5, 1))).toBe(true);
-    expect(isCloseTo(div(3, vec3f(1, 2, 3)), vec3f(0.333, 0.666, 1))).toBe(
+    expect(isCloseTo(div(2, vec2f(1, 2)), vec2f(2, 1))).toBe(true);
+    expect(isCloseTo(div(3, vec3f(1, 2, 3)), vec3f(3, 1.5, 1))).toBe(
       true,
     );
-    expect(isCloseTo(div(4, vec4f(1, 2, 3, 4)), vec4f(0.25, 0.5, 0.75, 1)))
-      .toBe(true);
+    expect(
+      isCloseTo(div(4, vec4f(1, 2, 3, 4)), vec4f(4, 2, 1.33, 1)),
+    ).toBe(true);
   });
 
   it('computes quotient of a number and vecNi', () => {
-    expect(div(1, vec2i(1, 2))).toStrictEqual(vec2i(1, 2));
-    expect(div(2, vec3i(1, 2, 3))).toStrictEqual(vec3i(0, 1, 1));
-    expect(div(3, vec4i(5, 6, 7, 8))).toStrictEqual(vec4i(1, 2, 2, 2));
+    expect(div(1, vec2i(1, 2))).toStrictEqual(vec2i(1, 0));
+    expect(div(2, vec3i(1, 2, 3))).toStrictEqual(vec3i(2, 1, 0));
+    expect(div(3, vec4i(5, 6, 7, 8))).toStrictEqual(vec4i());
   });
 
   it('computes quotient of vecNh and vecNh', () => {
-    expect(isCloseTo(div(vec2h(1, 2), vec2h(4)), vec2h(0.25, 0.5))).toBe(
-      true,
-    );
+    expect(isCloseTo(div(vec2h(1, 2), vec2h(4)), vec2h(0.25, 0.5))).toBe(true);
     expect(
       isCloseTo(div(vec3h(1, 2, 3), vec3h(3)), vec3h(0.333, 0.666, 1)),
     ).toBe(true);
     expect(
-      isCloseTo(
-        div(vec4h(1.5, 2, 3, 4), vec4h(2)),
-        vec4h(0.75, 1, 1.5, 2),
-      ),
+      isCloseTo(div(vec4h(1.5, 2, 3, 4), vec4h(2)), vec4h(0.75, 1, 1.5, 2)),
     ).toBe(true);
   });
 
   it('computes quotient of vecNu and vecNu', () => {
     expect(div(vec2u(1, 2), vec2u(2))).toStrictEqual(vec2u(0, 1));
     expect(div(vec3u(5, 6, 7), vec3u(3))).toStrictEqual(vec3u(1, 2, 2));
-    expect(div(vec4u(1, 2, 8, 9), vec4u(4))).toStrictEqual(
-      vec4u(0, 0, 2, 2),
-    );
+    expect(div(vec4u(1, 2, 8, 9), vec4u(4))).toStrictEqual(vec4u(0, 0, 2, 2));
   });
 
   it('handles division by 0', () => {
