@sparkjsdev/spark 0.1.0

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

@@ -0,0 +1,59 @@
+import { Dyno } from './base';
+import { DynoVal } from './value';
+export declare const transformPos: (position: DynoVal<"vec3">, { scale, scales, rotate, translate, }: {
+    scale?: DynoVal<"float">;
+    scales?: DynoVal<"vec3">;
+    rotate?: DynoVal<"vec4">;
+    translate?: DynoVal<"vec3">;
+}) => DynoVal<"vec3">;
+export declare const transformDir: (dir: DynoVal<"vec3">, { scale, scales, rotate, }: {
+    scale?: DynoVal<"float">;
+    scales?: DynoVal<"vec3">;
+    rotate?: DynoVal<"vec4">;
+}) => DynoVal<"vec3">;
+export declare const transformQuat: (quaternion: DynoVal<"vec4">, { rotate }: {
+    rotate?: DynoVal<"vec4">;
+}) => DynoVal<"vec4">;
+export declare class TransformPosition extends Dyno<{
+    position: "vec3";
+    scale: "float";
+    scales: "vec3";
+    rotate: "vec4";
+    translate: "vec3";
+}, {
+    position: "vec3";
+}> {
+    constructor({ position, scale, scales, rotate, translate, }: {
+        position?: DynoVal<"vec3">;
+        scale?: DynoVal<"float">;
+        scales?: DynoVal<"vec3">;
+        rotate?: DynoVal<"vec4">;
+        translate?: DynoVal<"vec3">;
+    });
+}
+export declare class TransformDir extends Dyno<{
+    dir: "vec3";
+    scale: "float";
+    scales: "vec3";
+    rotate: "vec4";
+}, {
+    dir: "vec3";
+}> {
+    constructor({ dir, scale, scales, rotate, }: {
+        dir?: DynoVal<"vec3">;
+        scale?: DynoVal<"float">;
+        scales?: DynoVal<"vec3">;
+        rotate?: DynoVal<"vec4">;
+    });
+}
+export declare class TransformQuaternion extends Dyno<{
+    quaternion: "vec4";
+    rotate: "vec4";
+}, {
+    quaternion: "vec4";
+}> {
+    constructor({ quaternion, rotate, }: {
+        quaternion?: DynoVal<"vec4">;
+        rotate?: DynoVal<"vec4">;
+    });
+}

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

@@ -0,0 +1,94 @@
+import { BinaryOp, UnaryOp } from './base';
+import { FloatTypes } from './types';
+import { DynoVal } from './value';
+export declare const radians: <A extends FloatTypes>(degrees: DynoVal<A>) => DynoVal<A>;
+export declare const degrees: <A extends FloatTypes>(radians: DynoVal<A>) => DynoVal<A>;
+export declare const sin: <A extends FloatTypes>(radians: DynoVal<A>) => DynoVal<A>;
+export declare const cos: <A extends FloatTypes>(radians: DynoVal<A>) => DynoVal<A>;
+export declare const tan: <A extends FloatTypes>(radians: DynoVal<A>) => DynoVal<A>;
+export declare const asin: <A extends FloatTypes>(sin: DynoVal<A>) => DynoVal<A>;
+export declare const acos: <A extends FloatTypes>(cos: DynoVal<A>) => DynoVal<A>;
+export declare const atan: <A extends FloatTypes>(tan: DynoVal<A>) => DynoVal<A>;
+export declare const atan2: <A extends FloatTypes>(y: DynoVal<A>, x: DynoVal<A>) => DynoVal<A>;
+export declare const sinh: <A extends FloatTypes>(x: DynoVal<A>) => DynoVal<A>;
+export declare const cosh: <A extends FloatTypes>(x: DynoVal<A>) => DynoVal<A>;
+export declare const tanh: <A extends FloatTypes>(x: DynoVal<A>) => DynoVal<A>;
+export declare const asinh: <A extends FloatTypes>(x: DynoVal<A>) => DynoVal<A>;
+export declare const acosh: <A extends FloatTypes>(x: DynoVal<A>) => DynoVal<A>;
+export declare const atanh: <A extends FloatTypes>(x: DynoVal<A>) => DynoVal<A>;
+export declare class Radians<A extends FloatTypes> extends UnaryOp<A, A, "radians"> {
+    constructor({ degrees }: {
+        degrees: DynoVal<A>;
+    });
+}
+export declare class Degrees<A extends FloatTypes> extends UnaryOp<A, A, "degrees"> {
+    constructor({ radians }: {
+        radians: DynoVal<A>;
+    });
+}
+export declare class Sin<A extends FloatTypes> extends UnaryOp<A, A, "sin"> {
+    constructor({ radians }: {
+        radians: DynoVal<A>;
+    });
+}
+export declare class Cos<A extends FloatTypes> extends UnaryOp<A, A, "cos"> {
+    constructor({ radians }: {
+        radians: DynoVal<A>;
+    });
+}
+export declare class Tan<A extends FloatTypes> extends UnaryOp<A, A, "tan"> {
+    constructor({ radians }: {
+        radians: DynoVal<A>;
+    });
+}
+export declare class Asin<A extends FloatTypes> extends UnaryOp<A, A, "asin"> {
+    constructor({ sin }: {
+        sin: DynoVal<A>;
+    });
+}
+export declare class Acos<A extends FloatTypes> extends UnaryOp<A, A, "acos"> {
+    constructor({ cos }: {
+        cos: DynoVal<A>;
+    });
+}
+export declare class Atan<A extends FloatTypes> extends UnaryOp<A, A, "atan"> {
+    constructor({ tan }: {
+        tan: DynoVal<A>;
+    });
+}
+export declare class Atan2<A extends FloatTypes> extends BinaryOp<A, A, A, "atan2"> {
+    constructor({ y, x }: {
+        y: DynoVal<A>;
+        x: DynoVal<A>;
+    });
+}
+export declare class Sinh<A extends FloatTypes> extends UnaryOp<A, A, "sinh"> {
+    constructor({ x }: {
+        x: DynoVal<A>;
+    });
+}
+export declare class Cosh<A extends FloatTypes> extends UnaryOp<A, A, "cosh"> {
+    constructor({ x }: {
+        x: DynoVal<A>;
+    });
+}
+export declare class Tanh<A extends FloatTypes> extends UnaryOp<A, A, "tanh"> {
+    constructor({ x }: {
+        x: DynoVal<A>;
+    });
+}
+export declare class Asinh<A extends FloatTypes> extends UnaryOp<A, A, "asinh"> {
+    constructor({ x }: {
+        x: DynoVal<A>;
+    });
+}
+export declare class Acosh<A extends FloatTypes> extends UnaryOp<A, A, "acosh"> {
+    constructor({ x }: {
+        x: DynoVal<A>;
+    });
+}
+export declare class Atanh<A extends FloatTypes> extends UnaryOp<A, A, "atanh"> {
+    constructor({ x }: {
+        x: DynoVal<A>;
+    });
+}

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

@@ -0,0 +1,62 @@
+import type * as THREE from "three";
+export type BoolTypes = "bool" | "bvec2" | "bvec3" | "bvec4";
+export type IntTypes = "int" | "ivec2" | "ivec3" | "ivec4";
+export type UintTypes = "uint" | "uvec2" | "uvec3" | "uvec4";
+export type AllIntTypes = IntTypes | UintTypes;
+export type FloatTypes = "float" | "vec2" | "vec3" | "vec4";
+export type ScalarTypes = "uint" | "int" | "float";
+export type Vector2Types = "vec2" | "ivec2" | "uvec2";
+export type Vector3Types = "vec3" | "ivec3" | "uvec3";
+export type Vector4Types = "vec4" | "ivec4" | "uvec4";
+export type VectorTypes = Vector2Types | Vector3Types | Vector4Types;
+export type MatFloatTypes = "mat2" | "mat2x2" | "mat2x3" | "mat2x4" | "mat3" | "mat3x2" | "mat3x3" | "mat3x4" | "mat4" | "mat4x2" | "mat4x3" | "mat4x4";
+export type SquareMatTypes = "mat2" | "mat3" | "mat4" | "mat2x2" | "mat3x3" | "mat4x4";
+export type AllFloatTypes = FloatTypes | MatFloatTypes;
+export type SignedTypes = IntTypes | FloatTypes;
+export type AllSignedTypes = SignedTypes | MatFloatTypes;
+export type ValueTypes = FloatTypes | IntTypes | UintTypes;
+export type AllValueTypes = AllFloatTypes | IntTypes | UintTypes;
+export type SimpleTypes = BoolTypes | AllValueTypes;
+export type VectorElementType<A extends VectorTypes> = A extends FloatTypes ? "float" : A extends IntTypes ? "int" : A extends UintTypes ? "uint" : never;
+export type SameSizeVec<T extends ValueTypes> = T extends ScalarTypes ? "float" : T extends "vec2" | "ivec2" | "uvec2" ? "vec2" : T extends "vec3" | "ivec3" | "uvec3" ? "vec3" : T extends "vec4" | "ivec4" | "uvec4" ? "vec4" : never;
+export type SameSizeUvec<T extends ValueTypes> = T extends ScalarTypes ? "uint" : T extends "vec2" | "ivec2" | "uvec2" ? "uvec2" : T extends "vec3" | "ivec3" | "uvec3" ? "uvec3" : T extends "vec4" | "ivec4" | "uvec4" ? "uvec4" : never;
+export type SameSizeIvec<T extends ValueTypes> = T extends ScalarTypes ? "int" : T extends "vec2" | "ivec2" | "uvec2" ? "ivec2" : T extends "vec3" | "ivec3" | "uvec3" ? "ivec3" : T extends "vec4" | "ivec4" | "uvec4" ? "ivec4" : never;
+export type SamplerTypes = "sampler2D" | "sampler2DArray" | "sampler3D" | "samplerCube";
+export type UsamplerTypes = "usampler2D" | "usampler2DArray" | "usampler3D" | "usamplerCube";
+export type IsamplerTypes = "isampler2D" | "isampler2DArray" | "isampler3D" | "isamplerCube";
+export type NormalSamplerTypes = SamplerTypes | UsamplerTypes | IsamplerTypes;
+export type SamplerShadowTypes = "sampler2DShadow" | "sampler2DArrayShadow" | "samplerCubeShadow";
+export type AllSamplerTypes = NormalSamplerTypes | SamplerShadowTypes;
+export type Sampler2DTypes = "sampler2D" | "usampler2D" | "isampler2D" | "sampler2DShadow";
+export type Sampler2DArrayTypes = "sampler2DArray" | "usampler2DArray" | "isampler2DArray" | "sampler2DArrayShadow";
+export type Sampler3DTypes = "sampler3D" | "usampler3D" | "isampler3D";
+export type SamplerCubeTypes = "samplerCube" | "usamplerCube" | "isamplerCube" | "samplerCubeShadow";
+export declare function isBoolType(type: DynoType): boolean;
+export declare function isScalarType(type: DynoType): boolean;
+export declare function isIntType(type: DynoType): boolean;
+export declare function isUintType(type: DynoType): boolean;
+export declare function isFloatType(type: DynoType): boolean;
+export declare function isMatFloatType(type: DynoType): boolean;
+export declare function isAllFloatType(type: DynoType): boolean;
+export declare function isVector2Type(type: DynoType): boolean;
+export declare function isVector3Type(type: DynoType): boolean;
+export declare function isVector4Type(type: DynoType): boolean;
+export declare function isVectorType(type: DynoType): boolean;
+export declare function isMat2(type: DynoType): boolean;
+export declare function isMat3(type: DynoType): boolean;
+export declare function isMat4(type: DynoType): boolean;
+export declare function vectorElementType<A extends VectorTypes>(type: A): VectorElementType<A>;
+export declare function vectorDim<A extends VectorTypes>(type: A): number;
+export declare function sameSizeVec<T extends ValueTypes>(type: T): SameSizeVec<T>;
+export declare function sameSizeUvec<T extends ValueTypes>(type: T): SameSizeUvec<T>;
+export declare function sameSizeIvec<T extends ValueTypes>(type: T): SameSizeIvec<T>;
+export type BaseType = SimpleTypes | AllSamplerTypes;
+export type UserType = {
+    type: string;
+};
+export type DynoType = BaseType | UserType;
+export type DynoJsType<T extends DynoType> = T extends "bool" ? boolean : T extends "uint" ? number : T extends "int" ? number : T extends "float" ? number : T extends "bvec2" ? [boolean, boolean] : T extends "uvec2" ? THREE.Vector2 | [number, number] | Uint32Array : T extends "ivec2" ? THREE.Vector2 | [number, number] | Int32Array : T extends "vec2" ? THREE.Vector2 | [number, number] | Float32Array : T extends "bvec3" ? [boolean, boolean, boolean] : T extends "uvec3" ? THREE.Vector3 | [number, number, number] | Uint32Array : T extends "ivec3" ? THREE.Vector3 | [number, number, number] | Int32Array : T extends "vec3" ? THREE.Vector3 | THREE.Color | [number, number, number] | Float32Array : T extends "bvec4" ? [boolean, boolean, boolean, boolean] : T extends "uvec4" ? THREE.Vector4 | [number, number, number, number] | Uint32Array : T extends "ivec4" ? THREE.Vector4 | [number, number, number, number] | Int32Array : T extends "vec4" ? THREE.Vector4 | THREE.Quaternion | [number, number, number, number] | Float32Array : T extends "mat2" ? THREE.Matrix2 | Float32Array : T extends "mat2x2" ? THREE.Matrix2 | Float32Array : T extends "mat2x3" ? Float32Array : T extends "mat2x4" ? Float32Array : T extends "mat3" ? THREE.Matrix3 | Float32Array : T extends "mat3x2" ? Float32Array : T extends "mat3x3" ? THREE.Matrix3 | Float32Array : T extends "mat3x4" ? Float32Array : T extends "mat4" ? THREE.Matrix4 | Float32Array : T extends "mat4x2" ? Float32Array : T extends "mat4x3" ? Float32Array : T extends "mat4x4" ? THREE.Matrix4 | Float32Array : T extends "usampler2D" ? THREE.Texture : T extends "isampler2D" ? THREE.Texture : T extends "sampler2D" ? THREE.Texture : T extends "sampler2DShadow" ? THREE.Texture : T extends "usampler2DArray" ? THREE.DataArrayTexture : T extends "isampler2DArray" ? THREE.DataArrayTexture : T extends "sampler2DArray" ? THREE.DataArrayTexture : T extends "sampler2DArrayShadow" ? THREE.Texture : T extends "usampler3D" ? THREE.DataArrayTexture : T extends "isampler3D" ? THREE.DataArrayTexture : T extends "sampler3D" ? THREE.DataArrayTexture : T extends "usamplerCube" ? THREE.DataArrayTexture : T extends "isamplerCube" ? THREE.DataArrayTexture : T extends "samplerCube" ? THREE.DataArrayTexture : T extends "samplerCubeShadow" ? THREE.Texture : unknown;
+export declare function typeLiteral(type: DynoType): string;
+export declare function numberAsInt(value: number): string;
+export declare function numberAsUint(value: number): string;
+export declare function numberAsFloat(value: number): string;

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

@@ -0,0 +1,374 @@
+import { Dyno } from './base';
+import { DynoJsType, DynoType } from './types';
+import { DynoValue, HasDynoOut } from './value';
+export declare const uniform: <V extends DynoJsType<DynoType>>(key: string, type: DynoType, value: V) => DynoUniform<DynoType, string, V>;
+export declare const dynoBool: (value?: boolean, key?: string) => DynoBool<string>;
+export declare const dynoUint: (value?: number, key?: string) => DynoUint<string>;
+export declare const dynoInt: (value?: number, key?: string) => DynoInt<string>;
+export declare const dynoFloat: (value?: number, key?: string) => DynoFloat<string>;
+export declare const dynoBvec2: <V extends DynoJsType<"bvec2">>(value: V, key?: string) => DynoBvec2<string, V>;
+export declare const dynoUvec2: <V extends DynoJsType<"uvec2">>(value: V, key?: string) => DynoUvec2<string, V>;
+export declare const dynoIvec2: <V extends DynoJsType<"ivec2">>(value: V, key?: string) => DynoIvec2<string, V>;
+export declare const dynoVec2: <V extends DynoJsType<"vec2">>(value: V, key?: string) => DynoVec2<string, V>;
+export declare const dynoBvec3: <V extends DynoJsType<"bvec3">>(value: V, key?: string) => DynoBvec3<string, V>;
+export declare const dynoUvec3: <V extends DynoJsType<"uvec3">>(value: V, key?: string) => DynoUvec3<V, string>;
+export declare const dynoIvec3: <V extends DynoJsType<"ivec3">>(value: V, key?: string) => DynoIvec3<V, string>;
+export declare const dynoVec3: <V extends DynoJsType<"vec3">>(value: V, key?: string) => DynoVec3<V, string>;
+export declare const dynoBvec4: <V extends DynoJsType<"bvec4">>(value: V, key?: string) => DynoBvec4<string, V>;
+export declare const dynoUvec4: <V extends DynoJsType<"uvec4">>(value: V, key?: string) => DynoUvec4<string, V>;
+export declare const dynoIvec4: <V extends DynoJsType<"ivec4">>(value: V, key?: string) => DynoIvec4<string, V>;
+export declare const dynoVec4: <V extends DynoJsType<"vec4">>(value: V, key?: string) => DynoVec4<V, string>;
+export declare const dynoMat2: <V extends DynoJsType<"mat2">>(value: V, key?: string) => DynoMat2<string, V>;
+export declare const dynoMat2x2: <V extends DynoJsType<"mat2x2">>(value: V, key?: string) => DynoMat2x2<string, V>;
+export declare const dynoMat2x3: <V extends DynoJsType<"mat2x3">>(value: V, key?: string) => DynoMat2x3<string, V>;
+export declare const dynoMat2x4: <V extends DynoJsType<"mat2x4">>(value: V, key?: string) => DynoMat2x4<string, V>;
+export declare const dynoMat3: <V extends DynoJsType<"mat3">>(value: V, key?: string) => DynoMat3<string, V>;
+export declare const dynoMat3x2: <V extends DynoJsType<"mat3x2">>(value: V, key?: string) => DynoMat3x2<string, V>;
+export declare const dynoMat3x3: <V extends DynoJsType<"mat3x3">>(value: V, key?: string) => DynoMat3x3<string, V>;
+export declare const dynoMat3x4: <V extends DynoJsType<"mat3x4">>(value: V, key?: string) => DynoMat3x4<string, V>;
+export declare const dynoMat4: <V extends DynoJsType<"mat4">>(value: V, key?: string) => DynoMat4<string, V>;
+export declare const dynoMat4x2: <V extends DynoJsType<"mat4x2">>(value: V, key?: string) => DynoMat4x2<string, V>;
+export declare const dynoMat4x3: <V extends DynoJsType<"mat4x3">>(value: V, key?: string) => DynoMat4x3<string, V>;
+export declare const dynoMat4x4: <V extends DynoJsType<"mat4x4">>(value: V, key?: string) => DynoMat4x4<string, V>;
+export declare const dynoUsampler2D: <V extends DynoJsType<"usampler2D">>(value: V, key?: string) => DynoUsampler2D<string, V>;
+export declare const dynoIsampler2D: <V extends DynoJsType<"isampler2D">>(value: V, key?: string) => DynoIsampler2D<string, V>;
+export declare const dynoSampler2D: <V extends DynoJsType<"sampler2D">>(value: V, key?: string) => DynoSampler2D<string, V>;
+export declare const dynoUsampler2DArray: <V extends DynoJsType<"usampler2DArray">>(value: V, key?: string) => DynoUsampler2DArray<string, V>;
+export declare const dynoIsampler2DArray: <V extends DynoJsType<"isampler2DArray">>(key: string, value: V) => DynoIsampler2DArray<string, V>;
+export declare const dynoSampler2DArray: <V extends DynoJsType<"sampler2DArray">>(value: V, key?: string) => DynoSampler2DArray<string, V>;
+export declare const dynoUsampler3D: <V extends DynoJsType<"usampler3D">>(value: V, key?: string) => DynoUsampler3D<string, V>;
+export declare const dynoIsampler3D: <V extends DynoJsType<"isampler3D">>(value: V, key?: string) => DynoIsampler3D<string, V>;
+export declare const dynoSampler3D: <V extends DynoJsType<"sampler3D">>(value: V, key?: string) => DynoSampler3D<string, V>;
+export declare const dynoUsamplerCube: <V extends DynoJsType<"usamplerCube">>(value: V, key?: string) => DynoUsamplerCube<string, V>;
+export declare const dynoIsamplerCube: <V extends DynoJsType<"isamplerCube">>(value: V, key?: string) => DynoIsamplerCube<string, V>;
+export declare const dynoSamplerCube: <V extends DynoJsType<"samplerCube">>(value: V, key?: string) => DynoSamplerCube<string, V>;
+export declare const dynoSampler2DShadow: <V extends DynoJsType<"sampler2DShadow">>(value: V, key?: string) => DynoSampler2DShadow<string, V>;
+export declare const dynoSampler2DArrayShadow: <V extends DynoJsType<"sampler2DArrayShadow">>(value: V, key?: string) => DynoSampler2DArrayShadow<string, V>;
+export declare const dynoSamplerCubeShadow: <V extends DynoJsType<"samplerCubeShadow">>(value: V, key?: string) => DynoSamplerCubeShadow<string, V>;
+export declare class DynoUniform<T extends DynoType, K extends string = "value", V extends DynoJsType<T> = DynoJsType<T>> extends Dyno<Record<string, never>, {
+    [key in K]: T;
+}> implements HasDynoOut<T> {
+    type: T;
+    count?: number;
+    outKey: K;
+    value: V;
+    uniform: {
+        value: V;
+        type?: string;
+    };
+    constructor({ key, type, count, value, update, globals, }: {
+        key?: K;
+        type: T;
+        count?: number;
+        value: V;
+        update?: (value: V) => V | undefined;
+        globals?: ({ inputs, outputs, }: {
+            inputs: unknown;
+            outputs: {
+                [key in K]?: string;
+            };
+        }) => string[];
+    });
+    dynoOut(): DynoValue<T>;
+}
+export declare class DynoBool<K extends string> extends DynoUniform<"bool", K, boolean> {
+    constructor({ key, value, update, }: {
+        key?: K;
+        value: boolean;
+        update?: (value: boolean) => boolean | undefined;
+    });
+}
+export declare class DynoUint<K extends string> extends DynoUniform<"uint", K, number> {
+    constructor({ key, value, update, }: {
+        key?: K;
+        value: number;
+        update?: (value: number) => number | undefined;
+    });
+}
+export declare class DynoInt<K extends string> extends DynoUniform<"int", K, number> {
+    constructor({ key, value, update, }: {
+        key?: K;
+        value: number;
+        update?: (value: number) => number | undefined;
+    });
+}
+export declare class DynoFloat<K extends string = "value"> extends DynoUniform<"float", K, number> {
+    constructor({ key, value, update, }: {
+        key?: K;
+        value: number;
+        update?: (value: number) => number | undefined;
+    });
+}
+export declare class DynoBvec2<K extends string, V extends DynoJsType<"bvec2">> extends DynoUniform<"bvec2", K, V> {
+    constructor({ key, value, update, }: {
+        key?: K;
+        value: V;
+        update?: (value: V) => V | undefined;
+    });
+}
+export declare class DynoUvec2<K extends string, V extends DynoJsType<"uvec2">> extends DynoUniform<"uvec2", K, V> {
+    constructor({ key, value, update, }: {
+        key?: K;
+        value: V;
+        update?: (value: V) => V | undefined;
+    });
+}
+export declare class DynoIvec2<K extends string, V extends DynoJsType<"ivec2">> extends DynoUniform<"ivec2", K, V> {
+    constructor({ key, value, update, }: {
+        key?: K;
+        value: V;
+        update?: (value: V) => V | undefined;
+    });
+}
+export declare class DynoVec2<K extends string, V extends DynoJsType<"vec2">> extends DynoUniform<"vec2", K, V> {
+    constructor({ key, value, update, }: {
+        key?: K;
+        value: V;
+        update?: (value: V) => V | undefined;
+    });
+}
+export declare class DynoBvec3<K extends string, V extends DynoJsType<"bvec3">> extends DynoUniform<"bvec3", K, V> {
+    constructor({ key, value, update, }: {
+        key?: K;
+        value: V;
+        update?: (value: V) => V | undefined;
+    });
+}
+export declare class DynoUvec3<V extends DynoJsType<"uvec3">, K extends string = "value"> extends DynoUniform<"uvec3", K, V> {
+    constructor({ key, value, update, }: {
+        key?: K;
+        value: V;
+        update?: (value: V) => V | undefined;
+    });
+}
+export declare class DynoIvec3<V extends DynoJsType<"ivec3">, K extends string = "value"> extends DynoUniform<"ivec3", K, V> {
+    constructor({ key, value, update, }: {
+        key?: K;
+        value: V;
+        update?: (value: V) => V | undefined;
+    });
+}
+export declare class DynoVec3<V extends DynoJsType<"vec3">, K extends string = "value"> extends DynoUniform<"vec3", K, V> {
+    constructor({ key, value, update, }: {
+        key?: K;
+        value: V;
+        update?: (value: V) => V | undefined;
+    });
+}
+export declare class DynoBvec4<K extends string, V extends DynoJsType<"bvec4">> extends DynoUniform<"bvec4", K, V> {
+    constructor({ key, value, update, }: {
+        key?: K;
+        value: V;
+        update?: (value: V) => V | undefined;
+    });
+}
+export declare class DynoUvec4<K extends string, V extends DynoJsType<"uvec4">> extends DynoUniform<"uvec4", K, V> {
+    constructor({ key, value, update, }: {
+        key?: K;
+        value: V;
+        update?: (value: V) => V | undefined;
+    });
+}
+export declare class DynoIvec4<K extends string, V extends DynoJsType<"ivec4">> extends DynoUniform<"ivec4", K, V> {
+    constructor({ key, value, update, }: {
+        key?: K;
+        value: V;
+        update?: (value: V) => V | undefined;
+    });
+}
+export declare class DynoVec4<V extends DynoJsType<"vec4">, K extends string = "value"> extends DynoUniform<"vec4", K, V> {
+    constructor({ key, value, update, }: {
+        key?: K;
+        value: V;
+        update?: (value: V) => V | undefined;
+    });
+}
+export declare class DynoMat2<K extends string, V extends DynoJsType<"mat2">> extends DynoUniform<"mat2", K, V> {
+    constructor({ key, value, update, }: {
+        key?: K;
+        value: V;
+        update?: (value: V) => V | undefined;
+    });
+}
+export declare class DynoMat2x2<K extends string, V extends DynoJsType<"mat2x2">> extends DynoUniform<"mat2x2", K, V> {
+    constructor({ key, value, update, }: {
+        key?: K;
+        value: V;
+        update?: (value: V) => V | undefined;
+    });
+}
+export declare class DynoMat2x3<K extends string, V extends DynoJsType<"mat2x3">> extends DynoUniform<"mat2x3", K, V> {
+    constructor({ key, value, update, }: {
+        key?: K;
+        value: V;
+        update?: (value: V) => V | undefined;
+    });
+}
+export declare class DynoMat2x4<K extends string, V extends DynoJsType<"mat2x4">> extends DynoUniform<"mat2x4", K, V> {
+    constructor({ key, value, update, }: {
+        key?: K;
+        value: V;
+        update?: (value: V) => V | undefined;
+    });
+}
+export declare class DynoMat3<K extends string, V extends DynoJsType<"mat3">> extends DynoUniform<"mat3", K, V> {
+    constructor({ key, value, update, }: {
+        key?: K;
+        value: V;
+        update?: (value: V) => V | undefined;
+    });
+}
+export declare class DynoMat3x2<K extends string, V extends DynoJsType<"mat3x2">> extends DynoUniform<"mat3x2", K, V> {
+    constructor({ key, value, update, }: {
+        key?: K;
+        value: V;
+        update?: (value: V) => V | undefined;
+    });
+}
+export declare class DynoMat3x3<K extends string, V extends DynoJsType<"mat3x3">> extends DynoUniform<"mat3x3", K, V> {
+    constructor({ key, value, update, }: {
+        key?: K;
+        value: V;
+        update?: (value: V) => V | undefined;
+    });
+}
+export declare class DynoMat3x4<K extends string, V extends DynoJsType<"mat3x4">> extends DynoUniform<"mat3x4", K, V> {
+    constructor({ key, value, update, }: {
+        key?: K;
+        value: V;
+        update?: (value: V) => V | undefined;
+    });
+}
+export declare class DynoMat4<K extends string, V extends DynoJsType<"mat4">> extends DynoUniform<"mat4", K, V> {
+    constructor({ key, value, update, }: {
+        key?: K;
+        value: V;
+        update?: (value: V) => V | undefined;
+    });
+}
+export declare class DynoMat4x2<K extends string, V extends DynoJsType<"mat4x2">> extends DynoUniform<"mat4x2", K, V> {
+    constructor({ key, value, update, }: {
+        key?: K;
+        value: V;
+        update?: (value: V) => V | undefined;
+    });
+}
+export declare class DynoMat4x3<K extends string, V extends DynoJsType<"mat4x3">> extends DynoUniform<"mat4x3", K, V> {
+    constructor({ key, value, update, }: {
+        key?: K;
+        value: V;
+        update?: (value: V) => V | undefined;
+    });
+}
+export declare class DynoMat4x4<K extends string, V extends DynoJsType<"mat4x4">> extends DynoUniform<"mat4x4", K, V> {
+    constructor({ key, value, update, }: {
+        key?: K;
+        value: V;
+        update?: (value: V) => V | undefined;
+    });
+}
+export declare class DynoUsampler2D<K extends string, V extends DynoJsType<"usampler2D">> extends DynoUniform<"usampler2D", K, V> {
+    constructor({ key, value, update, }: {
+        key?: K;
+        value: V;
+        update?: (value: V) => V | undefined;
+    });
+}
+export declare class DynoIsampler2D<K extends string, V extends DynoJsType<"isampler2D">> extends DynoUniform<"isampler2D", K, V> {
+    constructor({ key, value, update, }: {
+        key?: K;
+        value: V;
+        update?: (value: V) => V | undefined;
+    });
+}
+export declare class DynoSampler2D<K extends string, V extends DynoJsType<"sampler2D">> extends DynoUniform<"sampler2D", K, V> {
+    constructor({ key, value, update, }: {
+        key?: K;
+        value: V;
+        update?: (value: V) => V | undefined;
+    });
+}
+export declare class DynoUsampler2DArray<K extends string, V extends DynoJsType<"usampler2DArray">> extends DynoUniform<"usampler2DArray", K, V> {
+    constructor({ key, value, update, }: {
+        key?: K;
+        value: V;
+        update?: (value: V) => V | undefined;
+    });
+}
+export declare class DynoIsampler2DArray<K extends string, V extends DynoJsType<"isampler2DArray">> extends DynoUniform<"isampler2DArray", K, V> {
+    constructor({ key, value, update, }: {
+        key?: K;
+        value: V;
+        update?: (value: V) => V | undefined;
+    });
+}
+export declare class DynoSampler2DArray<K extends string, V extends DynoJsType<"sampler2DArray">> extends DynoUniform<"sampler2DArray", K, V> {
+    constructor({ key, value, update, }: {
+        key?: K;
+        value: V;
+        update?: (value: V) => V | undefined;
+    });
+}
+export declare class DynoUsampler3D<K extends string, V extends DynoJsType<"usampler3D">> extends DynoUniform<"usampler3D", K, V> {
+    constructor({ key, value, update, }: {
+        key?: K;
+        value: V;
+        update?: (value: V) => V | undefined;
+    });
+}
+export declare class DynoIsampler3D<K extends string, V extends DynoJsType<"isampler3D">> extends DynoUniform<"isampler3D", K, V> {
+    constructor({ key, value, update, }: {
+        key?: K;
+        value: V;
+        update?: (value: V) => V | undefined;
+    });
+}
+export declare class DynoSampler3D<K extends string, V extends DynoJsType<"sampler3D">> extends DynoUniform<"sampler3D", K, V> {
+    constructor({ key, value, update, }: {
+        key?: K;
+        value: V;
+        update?: (value: V) => V | undefined;
+    });
+}
+export declare class DynoUsamplerCube<K extends string, V extends DynoJsType<"usamplerCube">> extends DynoUniform<"usamplerCube", K, V> {
+    constructor({ key, value, update, }: {
+        key?: K;
+        value: V;
+        update?: (value: V) => V | undefined;
+    });
+}
+export declare class DynoIsamplerCube<K extends string, V extends DynoJsType<"isamplerCube">> extends DynoUniform<"isamplerCube", K, V> {
+    constructor({ key, value, update, }: {
+        key?: K;
+        value: V;
+        update?: (value: V) => V | undefined;
+    });
+}
+export declare class DynoSamplerCube<K extends string, V extends DynoJsType<"samplerCube">> extends DynoUniform<"samplerCube", K, V> {
+    constructor({ key, value, update, }: {
+        key?: K;
+        value: V;
+        update?: (value: V) => V | undefined;
+    });
+}
+export declare class DynoSampler2DShadow<K extends string, V extends DynoJsType<"sampler2DShadow">> extends DynoUniform<"sampler2DShadow", K, V> {
+    constructor({ key, value, update, }: {
+        key?: K;
+        value: V;
+        update?: (value: V) => V | undefined;
+    });
+}
+export declare class DynoSampler2DArrayShadow<K extends string, V extends DynoJsType<"sampler2DArrayShadow">> extends DynoUniform<"sampler2DArrayShadow", K, V> {
+    constructor({ key, value, update, }: {
+        key?: K;
+        value: V;
+        update?: (value: V) => V | undefined;
+    });
+}
+export declare class DynoSamplerCubeShadow<K extends string, V extends DynoJsType<"samplerCubeShadow">> extends DynoUniform<"samplerCubeShadow", K, V> {
+    constructor({ key, value, update, }: {
+        key?: K;
+        value: V;
+        update?: (value: V) => V | undefined;
+    });
+}