@sparkjsdev/spark 0.1.0

package/dist/types/dyno/logic.d.ts

@@ -0,0 +1,103 @@
+import { BinaryOp, TrinaryOp, UnaryOp } from './base';
+import { AllIntTypes, BoolTypes, IntTypes, ScalarTypes, SimpleTypes, UintTypes, ValueTypes } from './types';
+import { DynoVal } from './value';
+export declare const and: <T extends "bool" | AllIntTypes>(a: DynoVal<T>, b: DynoVal<T>) => DynoVal<T>;
+export declare const or: <T extends "bool" | AllIntTypes>(a: DynoVal<T>, b: DynoVal<T>) => DynoVal<T>;
+export declare const xor: <T extends "bool" | AllIntTypes>(a: DynoVal<T>, b: DynoVal<T>) => DynoVal<T>;
+export declare const not: <T extends BoolTypes | AllIntTypes>(a: DynoVal<T>) => DynoVal<T>;
+export declare const lessThan: <T extends ValueTypes>(a: DynoVal<T>, b: DynoVal<T>) => DynoVal<CompareOutput<T>>;
+export declare const lessThanEqual: <T extends ValueTypes>(a: DynoVal<T>, b: DynoVal<T>) => DynoVal<CompareOutput<T>>;
+export declare const greaterThan: <T extends ValueTypes>(a: DynoVal<T>, b: DynoVal<T>) => DynoVal<CompareOutput<T>>;
+export declare const greaterThanEqual: <T extends ValueTypes>(a: DynoVal<T>, b: DynoVal<T>) => DynoVal<CompareOutput<T>>;
+export declare const equal: <T extends ValueTypes | BoolTypes>(a: DynoVal<T>, b: DynoVal<T>) => DynoVal<EqualOutput<T>>;
+export declare const notEqual: <T extends ValueTypes | BoolTypes>(a: DynoVal<T>, b: DynoVal<T>) => DynoVal<NotEqualOutput<T>>;
+export declare const any: <T extends "bvec2" | "bvec3" | "bvec4">(a: DynoVal<T>) => DynoVal<"bool">;
+export declare const all: <T extends "bvec2" | "bvec3" | "bvec4">(a: DynoVal<T>) => DynoVal<"bool">;
+export declare const select: <T extends SimpleTypes>(cond: DynoVal<"bool">, t: DynoVal<T>, f: DynoVal<T>) => DynoVal<T>;
+export declare const compXor: <T extends BoolTypes | AllIntTypes>(a: DynoVal<T>) => DynoVal<CompXorOutput<T>>;
+export declare class And<T extends "bool" | AllIntTypes> extends BinaryOp<T, T, T, "and"> {
+    constructor({ a, b }: {
+        a: DynoVal<T>;
+        b: DynoVal<T>;
+    });
+}
+export declare class Or<T extends "bool" | AllIntTypes> extends BinaryOp<T, T, T, "or"> {
+    constructor({ a, b }: {
+        a: DynoVal<T>;
+        b: DynoVal<T>;
+    });
+}
+export declare class Xor<T extends "bool" | AllIntTypes> extends BinaryOp<T, T, T, "xor"> {
+    constructor({ a, b }: {
+        a: DynoVal<T>;
+        b: DynoVal<T>;
+    });
+}
+export declare class Not<T extends BoolTypes | AllIntTypes> extends UnaryOp<T, T, "not"> {
+    constructor({ a }: {
+        a: DynoVal<T>;
+    });
+}
+export declare class LessThan<T extends ValueTypes> extends BinaryOp<T, T, CompareOutput<T>, "lessThan"> {
+    constructor({ a, b }: {
+        a: DynoVal<T>;
+        b: DynoVal<T>;
+    });
+}
+export declare class LessThanEqual<T extends ValueTypes> extends BinaryOp<T, T, CompareOutput<T>, "lessThanEqual"> {
+    constructor({ a, b }: {
+        a: DynoVal<T>;
+        b: DynoVal<T>;
+    });
+}
+export declare class GreaterThan<T extends ValueTypes> extends BinaryOp<T, T, CompareOutput<T>, "greaterThan"> {
+    constructor({ a, b }: {
+        a: DynoVal<T>;
+        b: DynoVal<T>;
+    });
+}
+export declare class GreaterThanEqual<T extends ValueTypes> extends BinaryOp<T, T, CompareOutput<T>, "greaterThanEqual"> {
+    constructor({ a, b }: {
+        a: DynoVal<T>;
+        b: DynoVal<T>;
+    });
+}
+export declare class Equal<T extends ValueTypes | BoolTypes> extends BinaryOp<T, T, EqualOutput<T>, "equal"> {
+    constructor({ a, b }: {
+        a: DynoVal<T>;
+        b: DynoVal<T>;
+    });
+}
+export declare class NotEqual<T extends ValueTypes | BoolTypes> extends BinaryOp<T, T, NotEqualOutput<T>, "notEqual"> {
+    constructor({ a, b }: {
+        a: DynoVal<T>;
+        b: DynoVal<T>;
+    });
+}
+export declare class Any<T extends BoolTypes> extends UnaryOp<T, "bool", "any"> {
+    constructor({ a }: {
+        a: DynoVal<T>;
+    });
+}
+export declare class All<T extends BoolTypes> extends UnaryOp<T, "bool", "all"> {
+    constructor({ a }: {
+        a: DynoVal<T>;
+    });
+}
+export declare class Select<T extends SimpleTypes> extends TrinaryOp<"bool", T, T, T, "select"> {
+    constructor({ cond, t, f, }: {
+        cond: DynoVal<"bool">;
+        t: DynoVal<T>;
+        f: DynoVal<T>;
+    });
+}
+type CompareOutput<T extends ValueTypes> = T extends ScalarTypes ? "bool" : T extends "ivec2" | "uvec2" | "vec2" ? "bvec2" : T extends "ivec3" | "uvec3" | "vec3" ? "bvec3" : T extends "ivec4" | "uvec4" | "vec4" ? "bvec4" : never;
+type EqualOutput<A extends ValueTypes | BoolTypes> = A extends ScalarTypes ? "bool" : A extends BoolTypes ? A : A extends "ivec2" | "uvec2" | "vec2" ? "bvec2" : A extends "ivec3" | "uvec3" | "vec3" ? "bvec3" : A extends "ivec4" | "uvec4" | "vec4" ? "bvec4" : never;
+type NotEqualOutput<A extends ValueTypes | BoolTypes> = EqualOutput<A>;
+type CompXorOutput<A extends BoolTypes | AllIntTypes> = A extends BoolTypes ? "bool" : A extends IntTypes ? "int" : A extends UintTypes ? "uint" : never;
+export declare class CompXor<T extends BoolTypes | AllIntTypes> extends UnaryOp<T, CompXorOutput<T>, "compXor"> {
+    constructor({ a }: {
+        a: DynoVal<T>;
+    });
+}
+export {};

package/dist/types/dyno/math.d.ts

@@ -0,0 +1,214 @@
+import { BinaryOp, Dyno, TrinaryOp, UnaryOp } from './base';
+import { AddOutput, ClampOutput, DivOutput, IModOutput, IsInfOutput, IsNanOutput, MaxOutput, MinOutput, MixOutput, ModOutput, MulOutput, SmoothstepOutput, StepOutput, SubOutput } from './mathTypes';
+import { AllIntTypes, AllSignedTypes, AllValueTypes, BoolTypes, FloatTypes, SignedTypes, ValueTypes } from './types';
+import { DynoVal } from './value';
+export declare const add: <A extends AllValueTypes, B extends AllValueTypes>(a: DynoVal<A>, b: DynoVal<B>) => DynoVal<AddOutput<A, B>>;
+export declare const sub: <A extends AllValueTypes, B extends AllValueTypes>(a: DynoVal<A>, b: DynoVal<B>) => DynoVal<SubOutput<A, B>>;
+export declare const mul: <A extends AllValueTypes, B extends AllValueTypes>(a: DynoVal<A>, b: DynoVal<B>) => DynoVal<MulOutput<A, B>>;
+export declare const div: <A extends AllValueTypes, B extends AllValueTypes>(a: DynoVal<A>, b: DynoVal<B>) => DynoVal<DivOutput<A, B>>;
+export declare const imod: <A extends AllIntTypes, B extends AllIntTypes>(a: DynoVal<A>, b: DynoVal<B>) => DynoVal<IModOutput<A, B>>;
+export declare const mod: <A extends FloatTypes, B extends FloatTypes>(a: DynoVal<A>, b: DynoVal<B>) => DynoVal<ModOutput<A, B>>;
+export declare const modf: <A extends FloatTypes>(a: DynoVal<A>) => {
+    fract: DynoVal<A>;
+    integer: DynoVal<A>;
+};
+export declare const neg: <A extends AllSignedTypes>(a: DynoVal<A>) => DynoVal<A>;
+export declare const abs: <A extends SignedTypes>(a: DynoVal<A>) => DynoVal<A>;
+export declare const sign: <A extends SignedTypes>(a: DynoVal<A>) => DynoVal<A>;
+export declare const floor: <A extends FloatTypes>(a: DynoVal<A>) => DynoVal<A>;
+export declare const ceil: <A extends FloatTypes>(a: DynoVal<A>) => DynoVal<A>;
+export declare const trunc: <A extends FloatTypes>(a: DynoVal<A>) => DynoVal<A>;
+export declare const round: <A extends FloatTypes>(a: DynoVal<A>) => DynoVal<A>;
+export declare const fract: <A extends FloatTypes>(a: DynoVal<A>) => DynoVal<A>;
+export declare const pow: <A extends FloatTypes>(a: DynoVal<A>, b: DynoVal<A>) => DynoVal<A>;
+export declare const exp: <A extends FloatTypes>(a: DynoVal<A>) => DynoVal<A>;
+export declare const exp2: <A extends FloatTypes>(a: DynoVal<A>) => DynoVal<A>;
+export declare const log: <A extends FloatTypes>(a: DynoVal<A>) => DynoVal<A>;
+export declare const log2: <A extends FloatTypes>(a: DynoVal<A>) => DynoVal<A>;
+export declare const sqr: <A extends ValueTypes>(a: DynoVal<A>) => DynoVal<A>;
+export declare const sqrt: <A extends FloatTypes>(a: DynoVal<A>) => DynoVal<A>;
+export declare const inversesqrt: <A extends FloatTypes>(a: DynoVal<A>) => DynoVal<A>;
+export declare const min: <A extends ValueTypes, B extends ValueTypes>(a: DynoVal<A>, b: DynoVal<B>) => DynoVal<MinOutput<A, B>>;
+export declare const max: <A extends ValueTypes, B extends ValueTypes>(a: DynoVal<A>, b: DynoVal<B>) => DynoVal<MaxOutput<A, B>>;
+export declare const clamp: <A extends ValueTypes, MinMax extends ValueTypes>(a: DynoVal<A>, min: DynoVal<MinMax>, max: DynoVal<MinMax>) => DynoVal<ClampOutput<A, MinMax>>;
+export declare const mix: <A extends FloatTypes, T extends FloatTypes | BoolTypes>(a: DynoVal<A>, b: DynoVal<A>, t: DynoVal<T>) => DynoVal<MixOutput<A, T>>;
+export declare const step: <A extends FloatTypes, B extends FloatTypes>(edge: DynoVal<A>, x: DynoVal<B>) => DynoVal<StepOutput<A, B>>;
+export declare const smoothstep: <X extends FloatTypes, Edge extends X | "float">(edge0: DynoVal<Edge>, edge1: DynoVal<Edge>, x: DynoVal<X>) => DynoVal<SmoothstepOutput<Edge, Edge, X>>;
+export declare const isNan: <A extends FloatTypes>(a: DynoVal<A>) => DynoVal<IsNanOutput<A>>;
+export declare const isInf: <A extends FloatTypes>(a: DynoVal<A>) => DynoVal<IsInfOutput<A>>;
+export declare class Add<A extends AllValueTypes, B extends AllValueTypes> extends BinaryOp<A, B, AddOutput<A, B>, "sum"> {
+    constructor({ a, b }: {
+        a: DynoVal<A>;
+        b: DynoVal<B>;
+    });
+}
+export declare class Sub<A extends AllValueTypes, B extends AllValueTypes> extends BinaryOp<A, B, SubOutput<A, B>, "difference"> {
+    constructor({ a, b }: {
+        a: DynoVal<A>;
+        b: DynoVal<B>;
+    });
+}
+export declare class Mul<A extends AllValueTypes, B extends AllValueTypes> extends BinaryOp<A, B, MulOutput<A, B>, "product"> {
+    constructor({ a, b }: {
+        a: DynoVal<A>;
+        b: DynoVal<B>;
+    });
+}
+export declare class Div<A extends AllValueTypes, B extends AllValueTypes> extends BinaryOp<A, B, DivOutput<A, B>, "quotient"> {
+    constructor({ a, b }: {
+        a: DynoVal<A>;
+        b: DynoVal<B>;
+    });
+}
+export declare class IMod<A extends AllIntTypes, B extends AllIntTypes> extends BinaryOp<A, B, IModOutput<A, B>, "remainder"> {
+    constructor({ a, b }: {
+        a: DynoVal<A>;
+        b: DynoVal<B>;
+    });
+}
+export declare class Mod<A extends FloatTypes, B extends FloatTypes> extends BinaryOp<A, B, ModOutput<A, B>, "remainder"> {
+    constructor({ a, b }: {
+        a: DynoVal<A>;
+        b: DynoVal<B>;
+    });
+}
+export declare class Modf<A extends FloatTypes> extends Dyno<{
+    a: A;
+}, {
+    fract: A;
+    integer: A;
+}> {
+    constructor({ a }: {
+        a: DynoVal<A>;
+    });
+}
+export declare class Neg<A extends AllSignedTypes> extends UnaryOp<A, A, "neg"> {
+    constructor({ a }: {
+        a: DynoVal<A>;
+    });
+}
+export declare class Abs<A extends SignedTypes> extends UnaryOp<A, A, "abs"> {
+    constructor({ a }: {
+        a: DynoVal<A>;
+    });
+}
+export declare class Sign<A extends SignedTypes> extends UnaryOp<A, A, "sign"> {
+    constructor({ a }: {
+        a: DynoVal<A>;
+    });
+}
+export declare class Floor<A extends FloatTypes> extends UnaryOp<A, A, "floor"> {
+    constructor({ a }: {
+        a: DynoVal<A>;
+    });
+}
+export declare class Ceil<A extends FloatTypes> extends UnaryOp<A, A, "ceil"> {
+    constructor({ a }: {
+        a: DynoVal<A>;
+    });
+}
+export declare class Trunc<A extends FloatTypes> extends UnaryOp<A, A, "trunc"> {
+    constructor({ a }: {
+        a: DynoVal<A>;
+    });
+}
+export declare class Round<A extends FloatTypes> extends UnaryOp<A, A, "round"> {
+    constructor({ a }: {
+        a: DynoVal<A>;
+    });
+}
+export declare class Fract<A extends FloatTypes> extends UnaryOp<A, A, "fract"> {
+    constructor({ a }: {
+        a: DynoVal<A>;
+    });
+}
+export declare class Pow<A extends FloatTypes> extends BinaryOp<A, A, A, "power"> {
+    constructor({ a, b }: {
+        a: DynoVal<A>;
+        b: DynoVal<A>;
+    });
+}
+export declare class Exp<A extends FloatTypes> extends UnaryOp<A, A, "exp"> {
+    constructor({ a }: {
+        a: DynoVal<A>;
+    });
+}
+export declare class Exp2<A extends FloatTypes> extends UnaryOp<A, A, "exp2"> {
+    constructor({ a }: {
+        a: DynoVal<A>;
+    });
+}
+export declare class Log<A extends FloatTypes> extends UnaryOp<A, A, "log"> {
+    constructor({ a }: {
+        a: DynoVal<A>;
+    });
+}
+export declare class Log2<A extends FloatTypes> extends UnaryOp<A, A, "log2"> {
+    constructor({ a }: {
+        a: DynoVal<A>;
+    });
+}
+export declare class Sqr<A extends ValueTypes> extends UnaryOp<A, A, "sqr"> {
+    constructor({ a }: {
+        a: DynoVal<A>;
+    });
+}
+export declare class Sqrt<A extends FloatTypes> extends UnaryOp<A, A, "sqrt"> {
+    constructor({ a }: {
+        a: DynoVal<A>;
+    });
+}
+export declare class InverseSqrt<A extends FloatTypes> extends UnaryOp<A, A, "inversesqrt"> {
+    constructor({ a }: {
+        a: DynoVal<A>;
+    });
+}
+export declare class Min<A extends ValueTypes, B extends ValueTypes> extends BinaryOp<A, B, MinOutput<A, B>, "min"> {
+    constructor({ a, b }: {
+        a: DynoVal<A>;
+        b: DynoVal<B>;
+    });
+}
+export declare class Max<A extends ValueTypes, B extends ValueTypes> extends BinaryOp<A, B, MaxOutput<A, B>, "max"> {
+    constructor({ a, b }: {
+        a: DynoVal<A>;
+        b: DynoVal<B>;
+    });
+}
+export declare class Clamp<A extends ValueTypes, MinMax extends ValueTypes> extends TrinaryOp<A, MinMax, MinMax, ClampOutput<A, MinMax>, "clamp"> {
+    constructor({ a, min, max, }: {
+        a: DynoVal<A>;
+        min: DynoVal<MinMax>;
+        max: DynoVal<MinMax>;
+    });
+}
+export declare class Mix<A extends FloatTypes, T extends FloatTypes | BoolTypes> extends TrinaryOp<A, A, T, MixOutput<A, T>, "mix"> {
+    constructor({ a, b, t }: {
+        a: DynoVal<A>;
+        b: DynoVal<A>;
+        t: DynoVal<T>;
+    });
+}
+export declare class Step<Edge extends FloatTypes, X extends FloatTypes> extends BinaryOp<Edge, X, StepOutput<Edge, X>, "step"> {
+    constructor({ edge, x }: {
+        edge: DynoVal<Edge>;
+        x: DynoVal<X>;
+    });
+}
+export declare class Smoothstep<X extends FloatTypes, Edge extends X | "float"> extends TrinaryOp<Edge, Edge, X, SmoothstepOutput<Edge, Edge, X>, "smoothstep"> {
+    constructor({ edge0, edge1, x, }: {
+        edge0: DynoVal<Edge>;
+        edge1: DynoVal<Edge>;
+        x: DynoVal<X>;
+    });
+}
+export declare class IsNan<A extends FloatTypes> extends UnaryOp<A, IsNanOutput<A>, "isNan"> {
+    constructor({ a }: {
+        a: DynoVal<A>;
+    });
+}
+export declare class IsInf<A extends FloatTypes> extends UnaryOp<A, IsInfOutput<A>, "isInf"> {
+    constructor({ a }: {
+        a: DynoVal<A>;
+    });
+}

package/dist/types/dyno/mathTypes.d.ts

@@ -0,0 +1,47 @@
+import { AllFloatTypes, AllIntTypes, AllSignedTypes, AllValueTypes, BaseType, BoolTypes, FloatTypes, IntTypes, SignedTypes, UintTypes, ValueTypes } from './types';
+export type AddOutput<A extends AllValueTypes, B extends AllValueTypes> = BaseType & (A extends B ? A : A extends "int" ? B extends IntTypes ? B : never : B extends "int" ? A extends IntTypes ? A : never : A extends "uint" ? B extends UintTypes ? B : never : B extends "uint" ? A extends UintTypes ? A : never : A extends "float" ? B extends AllFloatTypes ? B : never : B extends "float" ? A extends AllFloatTypes ? A : never : never);
+export type SubOutput<A extends AllValueTypes, B extends AllValueTypes> = AddOutput<A, B>;
+export type MulOutput<A extends AllValueTypes, B extends AllValueTypes> = BaseType & (A extends "int" ? B extends IntTypes ? B : never : B extends "int" ? A extends IntTypes ? A : never : A extends "uint" ? B extends UintTypes ? B : never : B extends "uint" ? A extends UintTypes ? A : never : A extends "float" ? B extends AllFloatTypes ? B : never : B extends "float" ? A extends AllFloatTypes ? A : never : A extends IntTypes ? B extends A ? A : never : B extends IntTypes ? A extends B ? A : never : A extends UintTypes ? B extends A ? A : never : B extends UintTypes ? A extends B ? A : never : A extends "vec2" ? B extends "vec2" | "mat2" | "mat2x2" ? "vec2" : B extends "mat3x2" ? "vec3" : B extends "mat4x2" ? "vec4" : never : A extends "vec3" ? B extends "mat2x3" ? "vec2" : B extends "vec3" | "mat3" | "mat3x3" ? "vec3" : B extends "mat4x3" ? "vec4" : never : A extends "vec4" ? B extends "mat2x4" ? "vec2" : B extends "mat3x4" ? "vec3" : B extends "vec4" | "mat4" | "mat4x4" ? "vec4" : never : B extends "vec2" ? A extends "mat2" | "mat2x2" ? "vec2" : A extends "mat2x3" ? "vec3" : A extends "mat2x4" ? "vec4" : never : B extends "vec3" ? A extends "mat3x2" ? "vec2" : A extends "mat3" | "mat3x3" ? "vec3" : A extends "mat3x4" ? "vec4" : never : B extends "vec4" ? A extends "mat4x2" ? "vec2" : A extends "mat4x3" ? "vec3" : A extends "mat4" | "mat4x4" ? "vec4" : never : A extends "mat2" | "mat2x2" ? B extends "mat2" | "mat2x2" ? "mat2" : B extends "mat3x2" ? "mat3x2" : B extends "mat4x2" ? "mat4x2" : never : A extends "mat2x3" ? B extends "mat2" | "mat2x2" ? "mat2x3" : B extends "mat3x2" ? "mat3" : B extends "mat4x2" ? "mat4x3" : never : A extends "mat2x4" ? B extends "mat2" | "mat2x2" ? "mat2x4" : B extends "mat3x2" ? "mat3x4" : B extends "mat4x2" ? "mat4" : never : A extends "mat3x2" ? B extends "mat2x3" ? "mat2" : B extends "mat3" | "mat3x3" ? "mat3x2" : B extends "mat4x3" ? "mat4x2" : never : A extends "mat3" | "mat3x3" ? B extends "mat2x3" ? "mat2x3" : B extends "mat3" | "mat3x3" ? "mat3" : B extends "mat4x3" ? "mat4x3" : never : A extends "mat3x4" ? B extends "mat2x3" ? "mat2x4" : B extends "mat3" | "mat3x3" ? "mat3x4" : B extends "mat4x3" ? "mat4" : never : A extends "mat4x2" ? B extends "mat2x4" ? "mat2" : B extends "mat3x4" ? "mat3x2" : B extends "mat4" | "mat4x4" ? "mat4x2" : never : A extends "mat4x3" ? B extends "mat2x4" ? "mat2x3" : B extends "mat3x4" ? "mat3" : B extends "mat4" | "mat4x4" ? "mat4x3" : never : A extends "mat4" | "mat4x4" ? B extends "mat2x4" ? "mat2x4" : B extends "mat3x4" ? "mat3x4" : B extends "mat4" | "mat4x4" ? "mat4" : never : never);
+export type DivOutput<A extends AllValueTypes, B extends AllValueTypes> = AddOutput<A, B>;
+export type IModOutput<A extends AllIntTypes, B extends AllIntTypes> = BaseType & (A extends B ? A : A extends "int" ? B extends IntTypes ? B : never : B extends "int" ? A extends IntTypes ? A : never : A extends "uint" ? B extends UintTypes ? B : never : B extends "uint" ? A extends UintTypes ? A : never : never);
+export type ModOutput<A extends FloatTypes, B extends FloatTypes> = BaseType & (A extends B ? A : B extends "float" ? A : never);
+export type PowOutput<A extends FloatTypes, B extends FloatTypes> = BaseType & (A extends B ? A : never);
+export type MinOutput<A extends ValueTypes, B extends ValueTypes> = BaseType & (A extends B ? A : B extends "float" ? A extends FloatTypes ? A : never : B extends "int" ? A extends IntTypes ? A : never : B extends "uint" ? A extends UintTypes ? A : never : never);
+export type MaxOutput<A extends ValueTypes, B extends ValueTypes> = MinOutput<A, B>;
+export type ClampOutput<A extends ValueTypes, B extends ValueTypes> = BaseType & (B extends "float" ? A extends FloatTypes ? A : never : B extends "int" ? A extends IntTypes ? A : never : B extends "uint" ? A extends UintTypes ? A : never : never);
+export type MixOutput<A extends FloatTypes, T extends FloatTypes | BoolTypes> = BaseType & (T extends A ? A : T extends "float" ? A : T extends "bool" ? A extends "float" ? A : never : T extends "bvec2" ? A extends "vec2" ? A : never : T extends "bvec3" ? A extends "vec3" ? A : never : T extends "bvec4" ? A extends "vec4" ? A : never : never);
+export type StepOutput<A extends FloatTypes, B extends FloatTypes> = BaseType & (A extends B ? B : A extends "float" ? B : never);
+export type SmoothstepOutput<A extends FloatTypes, B extends FloatTypes, C extends FloatTypes> = BaseType & (A extends B ? (A extends C ? C : A extends "float" ? C : never) : never);
+export type IsNanOutput<A extends FloatTypes> = BaseType & (A extends "float" ? "bool" : A extends "vec2" ? "bvec2" : A extends "vec3" ? "bvec3" : A extends "vec4" ? "bvec4" : never);
+export type IsInfOutput<A extends FloatTypes> = IsNanOutput<A>;
+export declare function addOutputType<A extends AllValueTypes, B extends AllValueTypes>(a: A, b: B, operation?: string): AddOutput<A, B>;
+export declare function subOutputType<A extends AllValueTypes, B extends AllValueTypes>(a: A, b: B): SubOutput<A, B>;
+export declare function mulOutputType<A extends AllValueTypes, B extends AllValueTypes>(a: A, b: B): MulOutput<A, B>;
+export declare function divOutputType<A extends AllValueTypes, B extends AllValueTypes>(a: A, b: B): DivOutput<A, B>;
+export declare function imodOutputType<A extends AllIntTypes, B extends AllIntTypes>(a: A, b: B): IModOutput<A, B>;
+export declare function modOutputType<A extends FloatTypes, B extends FloatTypes>(a: A, b: B): ModOutput<A, B>;
+export declare function modfOutputType<A extends FloatTypes>(a: A): A;
+export declare function negOutputType<A extends AllSignedTypes>(a: A): A;
+export declare function absOutputType<A extends SignedTypes>(a: A): A;
+export declare function signOutputType<A extends SignedTypes>(a: A): A;
+export declare function floorOutputType<A extends FloatTypes>(a: A): A;
+export declare function ceilOutputType<A extends FloatTypes>(a: A): A;
+export declare function truncOutputType<A extends FloatTypes>(a: A): A;
+export declare function roundOutputType<A extends FloatTypes>(a: A): A;
+export declare function fractOutputType<A extends FloatTypes>(a: A): A;
+export declare function powOutputType<A extends FloatTypes>(a: A): A;
+export declare function expOutputType<A extends FloatTypes>(a: A): A;
+export declare function exp2OutputType<A extends FloatTypes>(a: A): A;
+export declare function logOutputType<A extends FloatTypes>(a: A): A;
+export declare function log2OutputType<A extends FloatTypes>(a: A): A;
+export declare function sqrOutputType<A extends ValueTypes>(a: A): A;
+export declare function sqrtOutputType<A extends FloatTypes>(a: A): A;
+export declare function inversesqrtOutputType<A extends FloatTypes>(a: A): A;
+export declare function minOutputType<A extends ValueTypes, B extends ValueTypes>(a: A, b: B, operation?: string): MinOutput<A, B>;
+export declare function maxOutputType<A extends ValueTypes, B extends ValueTypes>(a: A, b: B): MaxOutput<A, B>;
+export declare function clampOutputType<A extends ValueTypes, B extends ValueTypes>(a: A, b: B, _c: B): ClampOutput<A, B>;
+export declare function mixOutputType<A extends FloatTypes, C extends FloatTypes | BoolTypes>(a: A, b: A, c: C): MixOutput<A, C>;
+export declare function stepOutputType<A extends FloatTypes, B extends FloatTypes>(a: A, b: B): StepOutput<A, B>;
+export declare function smoothstepOutputType<A extends FloatTypes, B extends FloatTypes, C extends FloatTypes>(a: A, b: B, c: C): SmoothstepOutput<A, B, C>;
+export declare function isNanOutputType<A extends FloatTypes>(a: A, operation?: string): IsNanOutput<A>;
+export declare function isInfOutputType<A extends FloatTypes>(a: A): IsInfOutput<A>;

package/dist/types/dyno/output.d.ts

@@ -0,0 +1,25 @@
+import { Dyno } from './base';
+import { Gsplat } from './splats';
+import { DynoVal, DynoValue, HasDynoOut } from './value';
+export declare const outputPackedSplat: (gsplat: DynoVal<typeof Gsplat>) => OutputPackedSplat;
+export declare const outputRgba8: (rgba8: DynoVal<"vec4">) => OutputRgba8;
+export declare class OutputPackedSplat extends Dyno<{
+    gsplat: typeof Gsplat;
+}, {
+    output: "uvec4";
+}> implements HasDynoOut<"uvec4"> {
+    constructor({ gsplat }: {
+        gsplat?: DynoVal<typeof Gsplat>;
+    });
+    dynoOut(): DynoValue<"uvec4">;
+}
+export declare class OutputRgba8 extends Dyno<{
+    rgba8: "vec4";
+}, {
+    rgba8: "vec4";
+}> implements HasDynoOut<"vec4"> {
+    constructor({ rgba8 }: {
+        rgba8?: DynoVal<"vec4">;
+    });
+    dynoOut(): DynoValue<"vec4">;
+}

package/dist/types/dyno/program.d.ts

@@ -0,0 +1,30 @@
+import { Dyno, IOTypes } from './base';
+import * as THREE from "three";
+export declare class DynoProgram {
+    graph: Dyno<IOTypes, IOTypes>;
+    template: DynoProgramTemplate;
+    inputs: Record<string, string>;
+    outputs: Record<string, string>;
+    shader: string;
+    uniforms: Record<string, THREE.IUniform>;
+    updaters: (() => void)[];
+    constructor({ graph, inputs, outputs, template, }: {
+        graph: Dyno<IOTypes, IOTypes>;
+        inputs?: Record<string, string>;
+        outputs?: Record<string, string>;
+        template: DynoProgramTemplate;
+    });
+    prepareMaterial(): THREE.RawShaderMaterial;
+    update(): void;
+}
+export declare class DynoProgramTemplate {
+    before: string;
+    between: string;
+    after: string;
+    indent: string;
+    constructor(template: string);
+    generate({ globals, statements, }: {
+        globals: Set<string>;
+        statements: string[];
+    }): string;
+}

package/dist/types/dyno/splats.d.ts

@@ -0,0 +1,156 @@
+import { Dyno, UnaryOp } from './base';
+import { DynoVal, DynoValue, HasDynoOut } from './value';
+export declare const Gsplat: {
+    type: "Gsplat";
+};
+export declare const TPackedSplats: {
+    type: "PackedSplats";
+};
+export declare const numPackedSplats: (packedSplats: DynoVal<typeof TPackedSplats>) => DynoVal<"int">;
+export declare const readPackedSplat: (packedSplats: DynoVal<typeof TPackedSplats>, index: DynoVal<"int">) => DynoVal<typeof Gsplat>;
+export declare const readPackedSplatRange: (packedSplats: DynoVal<typeof TPackedSplats>, index: DynoVal<"int">, base: DynoVal<"int">, count: DynoVal<"int">) => DynoVal<typeof Gsplat>;
+export declare const splitGsplat: (gsplat: DynoVal<typeof Gsplat>) => SplitGsplat;
+export declare const combineGsplat: ({ gsplat, flags, index, center, scales, quaternion, rgba, rgb, opacity, x, y, z, r, g, b, }: {
+    gsplat?: DynoVal<typeof Gsplat>;
+    flags?: DynoVal<"uint">;
+    index?: DynoVal<"int">;
+    center?: DynoVal<"vec3">;
+    scales?: DynoVal<"vec3">;
+    quaternion?: DynoVal<"vec4">;
+    rgba?: DynoVal<"vec4">;
+    rgb?: DynoVal<"vec3">;
+    opacity?: DynoVal<"float">;
+    x?: DynoVal<"float">;
+    y?: DynoVal<"float">;
+    z?: DynoVal<"float">;
+    r?: DynoVal<"float">;
+    g?: DynoVal<"float">;
+    b?: DynoVal<"float">;
+}) => DynoVal<typeof Gsplat>;
+export declare const gsplatNormal: (gsplat: DynoVal<typeof Gsplat>) => DynoVal<"vec3">;
+export declare const transformGsplat: (gsplat: DynoVal<typeof Gsplat>, { scale, rotate, translate, recolor, }: {
+    scale?: DynoVal<"float">;
+    rotate?: DynoVal<"vec4">;
+    translate?: DynoVal<"vec3">;
+    recolor?: DynoVal<"vec4">;
+}) => DynoVal<typeof Gsplat>;
+export declare const defineGsplat: string;
+export declare const definePackedSplats: string;
+export declare class NumPackedSplats extends UnaryOp<typeof TPackedSplats, "int", "numSplats"> {
+    constructor({ packedSplats, }: {
+        packedSplats: DynoVal<typeof TPackedSplats>;
+    });
+}
+export declare class ReadPackedSplat extends Dyno<{
+    packedSplats: typeof TPackedSplats;
+    index: "int";
+}, {
+    gsplat: typeof Gsplat;
+}> implements HasDynoOut<typeof Gsplat> {
+    constructor({ packedSplats, index, }: {
+        packedSplats?: DynoVal<typeof TPackedSplats>;
+        index?: DynoVal<"int">;
+    });
+    dynoOut(): DynoValue<typeof Gsplat>;
+}
+export declare class ReadPackedSplatRange extends Dyno<{
+    packedSplats: typeof TPackedSplats;
+    index: "int";
+    base: "int";
+    count: "int";
+}, {
+    gsplat: typeof Gsplat;
+}> implements HasDynoOut<typeof Gsplat> {
+    constructor({ packedSplats, index, base, count, }: {
+        packedSplats?: DynoVal<typeof TPackedSplats>;
+        index?: DynoVal<"int">;
+        base?: DynoVal<"int">;
+        count?: DynoVal<"int">;
+    });
+    dynoOut(): DynoValue<typeof Gsplat>;
+}
+export declare class SplitGsplat extends Dyno<{
+    gsplat: typeof Gsplat;
+}, {
+    flags: "uint";
+    active: "bool";
+    index: "int";
+    center: "vec3";
+    scales: "vec3";
+    quaternion: "vec4";
+    rgba: "vec4";
+    rgb: "vec3";
+    opacity: "float";
+    x: "float";
+    y: "float";
+    z: "float";
+    r: "float";
+    g: "float";
+    b: "float";
+}> {
+    constructor({ gsplat }: {
+        gsplat?: DynoVal<typeof Gsplat>;
+    });
+}
+export declare class CombineGsplat extends Dyno<{
+    gsplat: typeof Gsplat;
+    flags: "uint";
+    index: "int";
+    center: "vec3";
+    scales: "vec3";
+    quaternion: "vec4";
+    rgba: "vec4";
+    rgb: "vec3";
+    opacity: "float";
+    x: "float";
+    y: "float";
+    z: "float";
+    r: "float";
+    g: "float";
+    b: "float";
+}, {
+    gsplat: typeof Gsplat;
+}> implements HasDynoOut<typeof Gsplat> {
+    constructor({ gsplat, flags, index, center, scales, quaternion, rgba, rgb, opacity, x, y, z, r, g, b, }: {
+        gsplat?: DynoVal<typeof Gsplat>;
+        flags?: DynoVal<"uint">;
+        index?: DynoVal<"int">;
+        center?: DynoVal<"vec3">;
+        scales?: DynoVal<"vec3">;
+        quaternion?: DynoVal<"vec4">;
+        rgba?: DynoVal<"vec4">;
+        rgb?: DynoVal<"vec3">;
+        opacity?: DynoVal<"float">;
+        x?: DynoVal<"float">;
+        y?: DynoVal<"float">;
+        z?: DynoVal<"float">;
+        r?: DynoVal<"float">;
+        g?: DynoVal<"float">;
+        b?: DynoVal<"float">;
+    });
+    dynoOut(): DynoValue<typeof Gsplat>;
+}
+export declare const defineGsplatNormal: string;
+export declare class GsplatNormal extends UnaryOp<typeof Gsplat, "vec3", "normal"> {
+    constructor({ gsplat }: {
+        gsplat: DynoVal<typeof Gsplat>;
+    });
+}
+export declare class TransformGsplat extends Dyno<{
+    gsplat: typeof Gsplat;
+    scale: "float";
+    rotate: "vec4";
+    translate: "vec3";
+    recolor: "vec4";
+}, {
+    gsplat: typeof Gsplat;
+}> implements HasDynoOut<typeof Gsplat> {
+    constructor({ gsplat, scale, rotate, translate, recolor, }: {
+        gsplat?: DynoVal<typeof Gsplat>;
+        scale?: DynoVal<"float">;
+        rotate?: DynoVal<"vec4">;
+        translate?: DynoVal<"vec3">;
+        recolor?: DynoVal<"vec4">;
+    });
+    dynoOut(): DynoValue<typeof Gsplat>;
+}

package/dist/types/dyno/texture.d.ts

@@ -0,0 +1,50 @@
+import { Dyno } from './base';
+import { AllSamplerTypes, IsamplerTypes, NormalSamplerTypes, Sampler2DArrayTypes, Sampler2DTypes, Sampler3DTypes, SamplerCubeTypes, SamplerShadowTypes, SamplerTypes, UsamplerTypes } from './types';
+import { DynoVal, DynoValue, HasDynoOut } from './value';
+export declare const textureSize: <T extends AllSamplerTypes>(texture: DynoVal<T>, lod?: DynoVal<"int">) => DynoVal<TextureSizeType<T>>;
+export declare const texture: <T extends AllSamplerTypes>(texture: DynoVal<T>, coord: DynoVal<TextureCoordType<T>>, bias?: DynoVal<"float">) => DynoVal<TextureReturnType<T>>;
+export declare const texelFetch: <T extends NormalSamplerTypes>(texture: DynoVal<T>, coord: DynoVal<TextureSizeType<T>>, lod?: DynoVal<"int">) => DynoVal<TextureReturnType<T>>;
+export declare class TextureSize<T extends AllSamplerTypes> extends Dyno<{
+    texture: T;
+    lod: "int";
+}, {
+    size: TextureSizeType<T>;
+}> implements HasDynoOut<TextureSizeType<T>> {
+    constructor({ texture, lod }: {
+        texture: DynoVal<T>;
+        lod?: DynoVal<"int">;
+    });
+    dynoOut(): DynoValue<TextureSizeType<T>>;
+}
+export declare class Texture<T extends AllSamplerTypes> extends Dyno<{
+    texture: T;
+    coord: TextureCoordType<T>;
+    bias: "float";
+}, {
+    sample: TextureReturnType<T>;
+}> implements HasDynoOut<TextureReturnType<T>> {
+    constructor({ texture, coord, bias, }: {
+        texture: DynoVal<T>;
+        coord: DynoVal<TextureCoordType<T>>;
+        bias?: DynoVal<"float">;
+    });
+    dynoOut(): DynoValue<TextureReturnType<T>>;
+}
+export declare class TexelFetch<T extends NormalSamplerTypes> extends Dyno<{
+    texture: T;
+    coord: TextureSizeType<T>;
+    lod: "int";
+}, {
+    texel: TextureReturnType<T>;
+}> implements HasDynoOut<TextureReturnType<T>> {
+    constructor({ texture, coord, lod, }: {
+        texture: DynoVal<T>;
+        coord: DynoVal<TextureSizeType<T>>;
+        lod?: DynoVal<"int">;
+    });
+    dynoOut(): DynoValue<TextureReturnType<T>>;
+}
+type TextureSizeType<T extends AllSamplerTypes> = T extends Sampler2DTypes | SamplerCubeTypes ? "ivec2" : T extends Sampler3DTypes | Sampler2DArrayTypes ? "ivec3" : never;
+type TextureCoordType<T extends AllSamplerTypes> = T extends Sampler2DTypes ? "vec2" : T extends Sampler3DTypes | Sampler2DArrayTypes | SamplerCubeTypes | Sampler2DArrayTypes ? "vec3" : T extends "samperCubeShadow" | "sampler2DArrayShadow" ? "vec4" : never;
+type TextureReturnType<T extends AllSamplerTypes> = T extends SamplerTypes ? "vec4" : T extends UsamplerTypes ? "uvec4" : T extends IsamplerTypes ? "ivec4" : T extends SamplerShadowTypes ? "float" : never;
+export {};