typegpu 0.11.9 → 0.12.0

package/std/bitcast.d.ts

@@ -1,10 +1,193 @@
-import { DualFn } from "../types.js";
-import { v2f, v2i, v2u, v3f, v3i, v3u, v4f, v4i, v4u } from "../data/wgslTypes.js";
-
-//#region src/std/bitcast.d.ts
-type BitcastU32toF32Overload = ((value: number) => number) & ((value: v2u) => v2f) & ((value: v3u) => v3f) & ((value: v4u) => v4f);
-declare const bitcastU32toF32: DualFn<BitcastU32toF32Overload>;
-type BitcastU32toI32Overload = ((value: number) => number) & ((value: v2u) => v2i) & ((value: v3u) => v3i) & ((value: v4u) => v4i);
-declare const bitcastU32toI32: DualFn<BitcastU32toI32Overload>;
-//#endregion
-export { bitcastU32toF32, bitcastU32toI32 };
+import type { AnyWgslData, v2f, v2i, v2u, v3f, v3i, v3u, v4f, v4i, v4u } from '../data/wgslTypes.ts';
+type BitcastU32toF32Overload = <T extends number | v2u | v3u | v4u>(value: T) => T extends v2u ? v2f : T extends v3u ? v3f : T extends v4u ? v4f : number;
+/**
+ * @deprecated Use 'std.bitcast' instead.
+ */
+export declare const bitcastU32toF32: import("../types.ts").DualFn<BitcastU32toF32Overload>;
+type BitcastU32toI32Overload = <T extends number | v2u | v3u | v4u>(value: T) => T extends v2u ? v2i : T extends v3u ? v3i : T extends v4u ? v4i : number;
+/**
+ * @deprecated Use 'std.bitcast' instead.
+ */
+export declare const bitcastU32toI32: import("../types.ts").DualFn<BitcastU32toI32Overload>;
+type BitcastF32toU32Overload = <T extends number | v2f | v3f | v4f>(value: T) => T extends v2f ? v2u : T extends v3f ? v3u : T extends v4f ? v4u : number;
+/**
+ * @deprecated Use 'std.bitcast' instead.
+ */
+export declare const bitcastF32toU32: import("../types.ts").DualFn<BitcastF32toU32Overload>;
+declare const casts: {
+    readonly f16: {
+        readonly f16: (value: number) => number;
+    };
+    readonly f32: {
+        readonly f32: (value: number) => number;
+        readonly i32: (value: number) => number;
+        readonly u32: (value: number) => number;
+        readonly vec2h: (value: number) => import("../data/wgslTypes.ts").v2h;
+    };
+    readonly i32: {
+        readonly f32: (value: number) => number;
+        readonly i32: (value: number) => number;
+        readonly u32: (value: number) => number;
+        readonly vec2h: (value: number) => import("../data/wgslTypes.ts").v2h;
+    };
+    readonly u32: {
+        readonly f32: (value: number) => number;
+        readonly i32: (value: number) => number;
+        readonly u32: (value: number) => number;
+        readonly vec2h: (value: number) => import("../data/wgslTypes.ts").v2h;
+    };
+    readonly vec2h: {
+        readonly f32: (value: import("../data/wgslTypes.ts").v2h) => number;
+        readonly i32: (value: import("../data/wgslTypes.ts").v2h) => number;
+        readonly u32: (value: import("../data/wgslTypes.ts").v2h) => number;
+        readonly vec2h: (value: import("../data/wgslTypes.ts").v2h) => import("../data/wgslTypes.ts").v2h;
+    };
+    readonly vec3h: {
+        readonly vec3h: (value: import("../data/wgslTypes.ts").v3h) => import("../data/wgslTypes.ts").v3h;
+    };
+    readonly vec2f: {
+        readonly vec2f: (value: v2f) => v2f;
+        readonly vec2i: (value: v2f) => v2i;
+        readonly vec2u: (value: v2f) => v2u;
+        readonly vec4h: (value: v2f) => import("../data/wgslTypes.ts").v4h;
+    };
+    readonly vec2i: {
+        readonly vec2f: (value: v2i) => v2f;
+        readonly vec2i: (value: v2i) => v2i;
+        readonly vec2u: (value: v2i) => v2u;
+        readonly vec4h: (value: v2i) => import("../data/wgslTypes.ts").v4h;
+    };
+    readonly vec2u: {
+        readonly vec2f: (value: v2u) => v2f;
+        readonly vec2i: (value: v2u) => v2i;
+        readonly vec2u: (value: v2u) => v2u;
+        readonly vec4h: (value: v2u) => import("../data/wgslTypes.ts").v4h;
+    };
+    readonly vec4h: {
+        readonly vec2f: (value: import("../data/wgslTypes.ts").v4h) => v2f;
+        readonly vec2i: (value: import("../data/wgslTypes.ts").v4h) => v2i;
+        readonly vec2u: (value: import("../data/wgslTypes.ts").v4h) => v2u;
+        readonly vec4h: (value: import("../data/wgslTypes.ts").v4h) => import("../data/wgslTypes.ts").v4h;
+    };
+    readonly vec3f: {
+        readonly vec3f: (value: v3f) => v3f;
+        readonly vec3i: (value: v3f) => v3i;
+        readonly vec3u: (value: v3f) => v3u;
+    };
+    readonly vec3i: {
+        readonly vec3f: (value: v3i) => v3f;
+        readonly vec3i: (value: v3i) => v3i;
+        readonly vec3u: (value: v3i) => v3u;
+    };
+    readonly vec3u: {
+        readonly vec3f: (value: v3u) => v3f;
+        readonly vec3i: (value: v3u) => v3i;
+        readonly vec3u: (value: v3u) => v3u;
+    };
+    readonly vec4f: {
+        readonly vec4f: (value: v4f) => v4f;
+        readonly vec4i: (value: v4f) => v4i;
+        readonly vec4u: (value: v4f) => v4u;
+    };
+    readonly vec4i: {
+        readonly vec4f: (value: v4i) => v4f;
+        readonly vec4i: (value: v4i) => v4i;
+        readonly vec4u: (value: v4i) => v4u;
+    };
+    readonly vec4u: {
+        readonly vec4f: (value: v4u) => v4f;
+        readonly vec4i: (value: v4u) => v4i;
+        readonly vec4u: (value: v4u) => v4u;
+    };
+};
+type SchemaFor<Type extends string> = Extract<AnyWgslData, {
+    type: Type;
+}>;
+declare function getBitcast<FromType extends keyof typeof casts, ToType extends keyof (typeof casts)[FromType] & string>(from: SchemaFor<FromType>, to: SchemaFor<ToType>): {
+    readonly f16: {
+        readonly f16: (value: number) => number;
+    };
+    readonly f32: {
+        readonly f32: (value: number) => number;
+        readonly i32: (value: number) => number;
+        readonly u32: (value: number) => number;
+        readonly vec2h: (value: number) => import("../data/wgslTypes.ts").v2h;
+    };
+    readonly i32: {
+        readonly f32: (value: number) => number;
+        readonly i32: (value: number) => number;
+        readonly u32: (value: number) => number;
+        readonly vec2h: (value: number) => import("../data/wgslTypes.ts").v2h;
+    };
+    readonly u32: {
+        readonly f32: (value: number) => number;
+        readonly i32: (value: number) => number;
+        readonly u32: (value: number) => number;
+        readonly vec2h: (value: number) => import("../data/wgslTypes.ts").v2h;
+    };
+    readonly vec2h: {
+        readonly f32: (value: import("../data/wgslTypes.ts").v2h) => number;
+        readonly i32: (value: import("../data/wgslTypes.ts").v2h) => number;
+        readonly u32: (value: import("../data/wgslTypes.ts").v2h) => number;
+        readonly vec2h: (value: import("../data/wgslTypes.ts").v2h) => import("../data/wgslTypes.ts").v2h;
+    };
+    readonly vec3h: {
+        readonly vec3h: (value: import("../data/wgslTypes.ts").v3h) => import("../data/wgslTypes.ts").v3h;
+    };
+    readonly vec2f: {
+        readonly vec2f: (value: v2f) => v2f;
+        readonly vec2i: (value: v2f) => v2i;
+        readonly vec2u: (value: v2f) => v2u;
+        readonly vec4h: (value: v2f) => import("../data/wgslTypes.ts").v4h;
+    };
+    readonly vec2i: {
+        readonly vec2f: (value: v2i) => v2f;
+        readonly vec2i: (value: v2i) => v2i;
+        readonly vec2u: (value: v2i) => v2u;
+        readonly vec4h: (value: v2i) => import("../data/wgslTypes.ts").v4h;
+    };
+    readonly vec2u: {
+        readonly vec2f: (value: v2u) => v2f;
+        readonly vec2i: (value: v2u) => v2i;
+        readonly vec2u: (value: v2u) => v2u;
+        readonly vec4h: (value: v2u) => import("../data/wgslTypes.ts").v4h;
+    };
+    readonly vec4h: {
+        readonly vec2f: (value: import("../data/wgslTypes.ts").v4h) => v2f;
+        readonly vec2i: (value: import("../data/wgslTypes.ts").v4h) => v2i;
+        readonly vec2u: (value: import("../data/wgslTypes.ts").v4h) => v2u;
+        readonly vec4h: (value: import("../data/wgslTypes.ts").v4h) => import("../data/wgslTypes.ts").v4h;
+    };
+    readonly vec3f: {
+        readonly vec3f: (value: v3f) => v3f;
+        readonly vec3i: (value: v3f) => v3i;
+        readonly vec3u: (value: v3f) => v3u;
+    };
+    readonly vec3i: {
+        readonly vec3f: (value: v3i) => v3f;
+        readonly vec3i: (value: v3i) => v3i;
+        readonly vec3u: (value: v3i) => v3u;
+    };
+    readonly vec3u: {
+        readonly vec3f: (value: v3u) => v3f;
+        readonly vec3i: (value: v3u) => v3i;
+        readonly vec3u: (value: v3u) => v3u;
+    };
+    readonly vec4f: {
+        readonly vec4f: (value: v4f) => v4f;
+        readonly vec4i: (value: v4f) => v4i;
+        readonly vec4u: (value: v4f) => v4u;
+    };
+    readonly vec4i: {
+        readonly vec4f: (value: v4i) => v4f;
+        readonly vec4i: (value: v4i) => v4i;
+        readonly vec4u: (value: v4i) => v4u;
+    };
+    readonly vec4u: {
+        readonly vec4f: (value: v4u) => v4f;
+        readonly vec4i: (value: v4u) => v4i;
+        readonly vec4u: (value: v4u) => v4u;
+    };
+}[FromType][(ToType & "bool") | (ToType & "f32") | (ToType & "f16") | (ToType & "i32") | (ToType & "u32") | (ToType & "u16") | (ToType & "vec2f") | (ToType & "vec2h") | (ToType & "vec2i") | (ToType & "vec2u") | (ToType & "vec2<bool>") | (ToType & "vec3f") | (ToType & "vec3h") | (ToType & "vec3i") | (ToType & "vec3u") | (ToType & "vec3<bool>") | (ToType & "vec4f") | (ToType & "vec4h") | (ToType & "vec4i") | (ToType & "vec4u") | (ToType & "vec4<bool>") | (ToType & "mat2x2f") | (ToType & "mat3x3f") | (ToType & "mat4x4f") | (ToType & "struct") | (ToType & "array") | (ToType & "ptr") | (ToType & "atomic") | (ToType & "decorated") | (ToType & "abstractInt") | (ToType & "abstractFloat") | (ToType & "void") | (ToType & ("texture_1d" | "texture_2d" | "texture_multisampled_2d" | "texture_depth_2d" | "texture_depth_multisampled_2d" | "texture_2d_array" | "texture_depth_2d_array" | "texture_cube" | "texture_depth_cube" | "texture_cube_array" | "texture_depth_cube_array" | "texture_3d")) | (ToType & ("texture_storage_1d" | "texture_storage_2d" | "texture_storage_2d_array" | "texture_storage_3d")) | (ToType & "texture_external") | (ToType & "sampler") | (ToType & "sampler_comparison")];
+export declare const bitcast: import("../indexNamedExports.ts").TgpuComptime<typeof getBitcast>;
+export {};

package/std/bitcast.js

@@ -1,43 +1,313 @@
-import { isVec } from "../data/wgslTypes.js";
-import { stitch } from "../core/resolve/stitch.js";
-import { unify } from "../tgsl/conversion.js";
-import { f32, i32, u32 } from "../data/numeric.js";
-import { vec2f, vec2i, vec3f, vec3i, vec4f, vec4i } from "../data/vector.js";
 import { dualImpl } from "../core/function/dualImpl.js";
-import { bitcastU32toF32Impl, bitcastU32toI32Impl } from "../data/numberOps.js";
+import { bitcastF32toU32Impl, bitcastU32toF32Impl, bitcastU32toI32Impl, } from "../data/numberOps.js";
+import { f16, f32, fromHalfBits, i32, toHalfBits, u32 } from "../data/numeric.js";
+import { isVec } from "../data/wgslTypes.js";
+import { vec2f, vec2h, vec2i, vec2u, vec3f, vec3h, vec3i, vec3u, vec4f, vec4h, vec4i, vec4u, } from "../data/vector.js";
 import { VectorOps } from "../data/vectorOps.js";
-
-//#region src/std/bitcast.ts
-const bitcastU32toF32 = dualImpl({
-	name: "bitcastU32toF32",
-	normalImpl: ((value) => {
-		if (typeof value === "number") return bitcastU32toF32Impl(value);
-		return VectorOps.bitcastU32toF32[value.kind](value);
-	}),
-	codegenImpl: (_ctx, [n]) => stitch`bitcast<f32>(${n})`,
-	signature: (...arg) => {
-		const uargs = unify(arg, [u32]) ?? arg;
-		return {
-			argTypes: uargs,
-			returnType: isVec(uargs[0]) ? uargs[0].type === "vec2u" ? vec2f : uargs[0].type === "vec3u" ? vec3f : vec4f : f32
-		};
-	}
+import { unifyStrict } from "../tgsl/conversion.js";
+import { SignatureNotSupportedError } from "../errors.js";
+import { getName } from "../shared/meta.js";
+import { comptime } from "../core/function/comptime.js";
+import { coerceToSnippet } from "../tgsl/generationHelpers.js";
+const u32AllowedSchemas = [u32, vec2u, vec3u, vec4u];
+// TODO(#2731): Remove deprecated bitcasts. Remember about cpu implementations.
+/**
+ * @deprecated Use 'std.bitcast' instead.
+ */
+export const bitcastU32toF32 = dualImpl({
+    name: 'bitcastU32toF32',
+    normalImpl: ((value) => {
+        if (typeof value === 'number') {
+            return bitcastU32toF32Impl(value);
+        }
+        return VectorOps.bitcastU32toF32[value.kind](value);
+    }),
+    codegenImpl: (ctx, [n], returnType) => {
+        return ctx.gen.emitCall('bitcast', [coerceToSnippet(returnType)], [n]);
+    },
+    signature: (...arg) => {
+        const uargs = unifyStrict(arg, u32AllowedSchemas);
+        if (!uargs) {
+            throw new SignatureNotSupportedError(arg, u32AllowedSchemas);
+        }
+        return {
+            argTypes: uargs,
+            returnType: isVec(uargs[0])
+                ? uargs[0].type === 'vec2u'
+                    ? vec2f
+                    : uargs[0].type === 'vec3u'
+                        ? vec3f
+                        : vec4f
+                : f32,
+        };
+    },
+    sideEffects: false,
+});
+/**
+ * @deprecated Use 'std.bitcast' instead.
+ */
+export const bitcastU32toI32 = dualImpl({
+    name: 'bitcastU32toI32',
+    normalImpl: ((value) => {
+        if (typeof value === 'number') {
+            return bitcastU32toI32Impl(value);
+        }
+        return VectorOps.bitcastU32toI32[value.kind](value);
+    }),
+    codegenImpl: (ctx, [n], returnType) => {
+        return ctx.gen.emitCall('bitcast', [coerceToSnippet(returnType)], [n]);
+    },
+    signature: (...arg) => {
+        const uargs = unifyStrict(arg, u32AllowedSchemas);
+        if (!uargs) {
+            throw new SignatureNotSupportedError(arg, u32AllowedSchemas);
+        }
+        return {
+            argTypes: uargs,
+            returnType: isVec(uargs[0])
+                ? uargs[0].type === 'vec2u'
+                    ? vec2i
+                    : uargs[0].type === 'vec3u'
+                        ? vec3i
+                        : vec4i
+                : i32,
+        };
+    },
+    sideEffects: false,
 });
-const bitcastU32toI32 = dualImpl({
-	name: "bitcastU32toI32",
-	normalImpl: ((value) => {
-		if (typeof value === "number") return bitcastU32toI32Impl(value);
-		return VectorOps.bitcastU32toI32[value.kind](value);
-	}),
-	codegenImpl: (_ctx, [n]) => stitch`bitcast<i32>(${n})`,
-	signature: (...arg) => {
-		const uargs = unify(arg, [u32]) ?? arg;
-		return {
-			argTypes: uargs,
-			returnType: isVec(uargs[0]) ? uargs[0].type === "vec2u" ? vec2i : uargs[0].type === "vec3u" ? vec3i : vec4i : i32
-		};
-	}
+const f32AllowedSchemas = [f32, vec2f, vec3f, vec4f];
+/**
+ * @deprecated Use 'std.bitcast' instead.
+ */
+export const bitcastF32toU32 = dualImpl({
+    name: 'bitcastF32toU32',
+    normalImpl: ((value) => {
+        if (typeof value === 'number') {
+            return bitcastF32toU32Impl(value);
+        }
+        return VectorOps.bitcastF32toU32[value.kind](value);
+    }),
+    codegenImpl: (ctx, [n], returnType) => {
+        return ctx.gen.emitCall('bitcast', [coerceToSnippet(returnType)], [n]);
+    },
+    signature: (...arg) => {
+        const uargs = unifyStrict(arg, f32AllowedSchemas);
+        if (!uargs) {
+            throw new SignatureNotSupportedError(arg, f32AllowedSchemas);
+        }
+        return {
+            argTypes: uargs,
+            returnType: isVec(uargs[0])
+                ? uargs[0].type === 'vec2f'
+                    ? vec2u
+                    : uargs[0].type === 'vec3f'
+                        ? vec3u
+                        : vec4u
+                : u32,
+        };
+    },
+    sideEffects: false,
 });
-
-//#endregion
-export { bitcastU32toF32, bitcastU32toI32 };
+const bitcastAllowedSchemas = [
+    /* 2 bytes */
+    f16,
+    /* 4 bytes */
+    f32,
+    i32,
+    u32,
+    vec2h,
+    /* 6 bytes */
+    vec3h,
+    /* 8 bytes */
+    vec2f,
+    vec2i,
+    vec2u,
+    vec4h,
+    /* 12 bytes */
+    vec3f,
+    vec3i,
+    vec3u,
+    /* 16 bytes */
+    vec4f,
+    vec4i,
+    vec4u,
+];
+const buffer = new ArrayBuffer(16);
+const bufViews = {
+    f32: new Float32Array(buffer),
+    u32: new Uint32Array(buffer),
+    i32: new Int32Array(buffer),
+    u16: new Uint16Array(buffer),
+};
+function writeToBuffer(item, target) {
+    if (typeof item === 'number') {
+        target[0] = item;
+    }
+    else {
+        for (let i = 0; i < item.length; i++) {
+            target[i] = item[i];
+        }
+    }
+}
+function writeFloat16ToBuffer(item, target) {
+    if (typeof item === 'number') {
+        target[0] = toHalfBits(item);
+    }
+    else {
+        for (let i = 0; i < item.length; i++) {
+            target[i] = toHalfBits(item[i]);
+        }
+    }
+}
+function readFromBuffer(buf, schema) {
+    const length = 'componentCount' in schema ? schema.componentCount : 1;
+    const items = [];
+    for (let i = 0; i < length; i++) {
+        items.push(buf[i]);
+    }
+    return schema(...items);
+}
+function readFloat16FromBuffer(buf, schema) {
+    const length = 'componentCount' in schema ? schema.componentCount : 1;
+    const items = [];
+    for (let i = 0; i < length; i++) {
+        items.push(fromHalfBits(buf[i]));
+    }
+    return schema(...items);
+}
+const getCpuBitcast = (inType, outType) => {
+    const writeToPrimitive = 'primitive' in inType ? inType.primitive : inType;
+    const readFromPrimitive = 'primitive' in outType ? outType.primitive : outType;
+    return (value) => {
+        if (writeToPrimitive.type === 'f16') {
+            writeFloat16ToBuffer(value, bufViews['u16']);
+        }
+        else {
+            writeToBuffer(value, bufViews[writeToPrimitive.type]);
+        }
+        if (readFromPrimitive.type === 'f16') {
+            return readFloat16FromBuffer(bufViews['u16'], outType);
+        }
+        return readFromBuffer(bufViews[readFromPrimitive.type], outType);
+    };
+};
+function bitcastFor(inType, outType) {
+    return dualImpl({
+        name: 'bitcast',
+        normalImpl: getCpuBitcast(inType, outType),
+        codegenImpl: (ctx, [n]) => ctx.gen.emitCall('bitcast', [coerceToSnippet(outType)], [n]),
+        signature: (arg) => {
+            const uarg = unifyStrict([arg], [inType]);
+            if (!uarg) {
+                throw new SignatureNotSupportedError([arg], [inType]);
+            }
+            return {
+                argTypes: uarg,
+                returnType: outType,
+            };
+        },
+        sideEffects: false,
+    });
+}
+const casts = {
+    /* 2 bytes */
+    f16: {
+        f16: bitcastFor(f16, f16),
+    },
+    /* 4 bytes */
+    f32: {
+        f32: bitcastFor(f32, f32),
+        i32: bitcastFor(f32, i32),
+        u32: bitcastFor(f32, u32),
+        vec2h: bitcastFor(f32, vec2h),
+    },
+    i32: {
+        f32: bitcastFor(i32, f32),
+        i32: bitcastFor(i32, i32),
+        u32: bitcastFor(i32, u32),
+        vec2h: bitcastFor(i32, vec2h),
+    },
+    u32: {
+        f32: bitcastFor(u32, f32),
+        i32: bitcastFor(u32, i32),
+        u32: bitcastFor(u32, u32),
+        vec2h: bitcastFor(u32, vec2h),
+    },
+    vec2h: {
+        f32: bitcastFor(vec2h, f32),
+        i32: bitcastFor(vec2h, i32),
+        u32: bitcastFor(vec2h, u32),
+        vec2h: bitcastFor(vec2h, vec2h),
+    },
+    /* 6 bytes */
+    vec3h: {
+        vec3h: bitcastFor(vec3h, vec3h),
+    },
+    /* 8 bytes */
+    vec2f: {
+        vec2f: bitcastFor(vec2f, vec2f),
+        vec2i: bitcastFor(vec2f, vec2i),
+        vec2u: bitcastFor(vec2f, vec2u),
+        vec4h: bitcastFor(vec2f, vec4h),
+    },
+    vec2i: {
+        vec2f: bitcastFor(vec2i, vec2f),
+        vec2i: bitcastFor(vec2i, vec2i),
+        vec2u: bitcastFor(vec2i, vec2u),
+        vec4h: bitcastFor(vec2i, vec4h),
+    },
+    vec2u: {
+        vec2f: bitcastFor(vec2u, vec2f),
+        vec2i: bitcastFor(vec2u, vec2i),
+        vec2u: bitcastFor(vec2u, vec2u),
+        vec4h: bitcastFor(vec2u, vec4h),
+    },
+    vec4h: {
+        vec2f: bitcastFor(vec4h, vec2f),
+        vec2i: bitcastFor(vec4h, vec2i),
+        vec2u: bitcastFor(vec4h, vec2u),
+        vec4h: bitcastFor(vec4h, vec4h),
+    },
+    /* 12 bytes */
+    vec3f: {
+        vec3f: bitcastFor(vec3f, vec3f),
+        vec3i: bitcastFor(vec3f, vec3i),
+        vec3u: bitcastFor(vec3f, vec3u),
+    },
+    vec3i: {
+        vec3f: bitcastFor(vec3i, vec3f),
+        vec3i: bitcastFor(vec3i, vec3i),
+        vec3u: bitcastFor(vec3i, vec3u),
+    },
+    vec3u: {
+        vec3f: bitcastFor(vec3u, vec3f),
+        vec3i: bitcastFor(vec3u, vec3i),
+        vec3u: bitcastFor(vec3u, vec3u),
+    },
+    /* 16 bytes */
+    vec4f: {
+        vec4f: bitcastFor(vec4f, vec4f),
+        vec4i: bitcastFor(vec4f, vec4i),
+        vec4u: bitcastFor(vec4f, vec4u),
+    },
+    vec4i: {
+        vec4f: bitcastFor(vec4i, vec4f),
+        vec4i: bitcastFor(vec4i, vec4i),
+        vec4u: bitcastFor(vec4i, vec4u),
+    },
+    vec4u: {
+        vec4f: bitcastFor(vec4u, vec4f),
+        vec4i: bitcastFor(vec4u, vec4i),
+        vec4u: bitcastFor(vec4u, vec4u),
+    },
+};
+function getBitcast(from, to) {
+    if ('type' in from && from.type in casts) {
+        const intermediate = casts[from.type];
+        if ('type' in to && to.type in intermediate) {
+            return intermediate[to.type];
+        }
+    }
+    throw new Error(`Incorrect bitcast from ${getName(from)} to ${getName(to)}.`);
+}
+export const bitcast = comptime(getBitcast);