typegpu/std/operators.d.ts

A thin layer between JS and WebGPU/WGSL that improves development experience and allows for faster iteration.

import { type AnyIntegerVecInstance, type AnyMatInstance, type AnyNumericVecInstance, type mBaseForVec, type vBaseForMat, type vecIToVecU } from '../data/wgslTypes.ts';
type NumVec = AnyNumericVecInstance;
type Mat = AnyMatInstance;
declare function cpuAdd(lhs: number, rhs: number): number;
declare function cpuAdd<T extends NumVec>(lhs: number, rhs: T): T;
declare function cpuAdd<T extends NumVec>(lhs: T, rhs: number): T;
declare function cpuAdd<T extends NumVec | Mat>(lhs: T, rhs: T): T;
declare function cpuAdd<Lhs extends number | NumVec | Mat, Rhs extends Lhs extends number ? number | NumVec : Lhs extends NumVec ? number | Lhs : Lhs extends Mat ? Lhs : never>(lhs: Lhs, rhs: Rhs): Lhs | Rhs;
export declare const add: import("../types.ts").DualFn<typeof cpuAdd>;
declare function cpuSub(lhs: number, rhs: number): number;
declare function cpuSub<T extends NumVec>(lhs: number, rhs: T): T;
declare function cpuSub<T extends NumVec>(lhs: T, rhs: number): T;
declare function cpuSub<T extends NumVec | Mat>(lhs: T, rhs: T): T;
declare function cpuSub<Lhs extends number | NumVec | Mat, Rhs extends Lhs extends number ? number | NumVec : Lhs extends NumVec ? number | Lhs : Lhs extends Mat ? Lhs : never>(lhs: Lhs, rhs: Rhs): Lhs | Rhs;
export declare const sub: import("../types.ts").DualFn<typeof cpuSub>;
declare function cpuMul(lhs: number, rhs: number): number;
declare function cpuMul<MV extends NumVec | Mat>(lhs: number, rhs: MV): MV;
declare function cpuMul<MV extends NumVec | Mat>(lhs: MV, rhs: number): MV;
declare function cpuMul<V extends NumVec>(lhs: V, rhs: V): V;
declare function cpuMul<M extends Mat, V extends vBaseForMat<M>>(lhs: V, rhs: M): V;
declare function cpuMul<M extends Mat, V extends vBaseForMat<M>>(lhs: M, rhs: V): V;
declare function cpuMul<M extends Mat>(lhs: M, rhs: M): M;
declare function cpuMul<Lhs extends number | NumVec | Mat, Rhs extends Lhs extends number ? number | NumVec | Mat : Lhs extends NumVec ? number | Lhs | mBaseForVec<Lhs> : Lhs extends Mat ? number | vBaseForMat<Lhs> | Lhs : never>(lhs: Lhs, rhs: Rhs): Lhs | Rhs;
export declare const mul: import("../types.ts").DualFn<typeof cpuMul>;
declare function cpuDiv(lhs: number, rhs: number): number;
declare function cpuDiv<T extends NumVec>(lhs: T, rhs: T): T;
declare function cpuDiv<T extends NumVec>(lhs: number, rhs: T): T;
declare function cpuDiv<T extends NumVec>(lhs: T, rhs: number): T;
export declare const div: import("../types.ts").DualFn<typeof cpuDiv>;
type ModOverload = {
    (a: number, b: number): number;
    <T extends NumVec>(a: T, b: T): T;
    <T extends NumVec>(a: number, b: T): T;
    <T extends NumVec>(a: T, b: number): T;
};
/**
 * @privateRemarks
 * Both JS and WGSL implementations use truncated definition of modulo
 */
export declare const mod: import("../types.ts").DualFn<ModOverload>;
declare function cpuNeg(value: number): number;
declare function cpuNeg<T extends NumVec>(value: T): T;
export declare const neg: import("../types.ts").DualFn<typeof cpuNeg>;
declare function cpuBitShiftLeft<T extends AnyIntegerVecInstance>(lhs: T, rhs: number | vecIToVecU<T>): T;
export declare const bitShiftLeft: import("../types.ts").DualFn<typeof cpuBitShiftLeft>;
declare function cpuBitShiftRight<T extends AnyIntegerVecInstance>(lhs: T, rhs: number | vecIToVecU<T>): T;
export declare const bitShiftRight: import("../types.ts").DualFn<typeof cpuBitShiftRight>;
export {};