import { GLSLSource } from "./glsl/source"
import Gydra from "./gydra"
import Output from "./output"
import Source from "./source"
import Shader, { Precision } from "./shader/shader"
import Synth from "./synth"
import Texture from "./texture"
import Model from './3d/model'
import { GLSLFunction, GLSLUtility } from "./glsl"
import Audio from "./audio"
import type Easings from "./easings"
import { DefinesName } from "./glsl/utilities/defines"

import type { AnnulusOptions } from "primitive-geometry/types/src/annulus"
import type { BoxOptions } from "primitive-geometry/types/src/box"
import type { CapsuleOptions } from "primitive-geometry/types/src/capsule"
import type { CircleOptions } from "primitive-geometry/types/src/circle"
import type { ConeOptions } from "primitive-geometry/types/src/cone"
import type { CubeOptions } from "primitive-geometry/types/src/cube"
import type { CylinderOptions } from "primitive-geometry/types/src/cylinder"
import type { DiscOptions } from "primitive-geometry/types/src/disc"
import type { EllipseOptions } from "primitive-geometry/types/src/ellipse"
import type { EllipsoidOptions } from "primitive-geometry/types/src/ellipsoid"
import type { IcosahedronOptions } from "primitive-geometry/types/src/icosahedron"
import type { IcosphereOptions } from "primitive-geometry/types/src/icosphere"
import type { PlaneOptions } from "primitive-geometry/types/src/plane"
import type { QuadOptions } from "primitive-geometry/types/src/quad"
import type { ReuleuxOptions } from "primitive-geometry/types/src/reuleux"
import type { RoundedCubeOptions } from "primitive-geometry/types/src/rounded-cube"
import type { RoundedCubeOptions as RoundedRectangleOptions } from "primitive-geometry/types/src/rounded-rectangle"
import type { SphereOptions } from "primitive-geometry/types/src/sphere"
import type { SquircleOptions } from "primitive-geometry/types/src/squircle"
import type { StadiumOptions } from "primitive-geometry/types/src/stadium"
import type { SuperellipseOptions } from "primitive-geometry/types/src/superellipse"
import type { TetrahedronOptions } from "primitive-geometry/types/src/tetrahedron"
import type { TorusOptions } from "primitive-geometry/types/src/torus"
type PolygonProps = {
	sides: number
	sx?: number // scaleY
	sy?: number // scaleX
	s?: number // scale
	a?: number // startAngle
}

type GydraNumber = number[] | (() => number) | number

declare global {

	interface Array<T> {
		_speed: number
		_smooth: number
		_ease: () => number
		_offset: number

		fast(speed: number): T[][]
		smooth(smooth: number): T[][]
		ease(ease: keyof typeof Easings): T[][]
		offset(offset: number): T[][]
		fit(low: number, high: number): T[][]
	}
	
	interface Window {
		Gydra: typeof Gydra
	}

	var o0: Output
	var o1: Output
	var o2: Output
	var o3: Output

	var s0: Source
	var s1: Source
	var s2: Source
	var s3: Source

	var a: Audio

	/////////// synth

	var synth: Synth

	var width: number
	var height: number
	var ratio: number

	var time: number
	var deltaTime: number
	var mouseX: number
	var mouseY: number

	var speed: number 
	var bpm: number
	var precision: Precision
	var update: () => void
	function setFunction(fn: GLSLFunction): void

	function render(out: (Output | Texture) | (Output | Texture)[]): Synth;
    function hush(): void;
    function loadScript(url: string, module?: boolean): Promise<void>;

	function shader(): Shader;
	function include(...requires: (GLSLUtility | GLSLFunction | DefinesName)[]): string;
	
	////////////

	interface Array<T> {
		_speed: number
		_smooth: number
		_ease: () => number
		_offset: number

		fast(speed: number): T
		smooth(smooth: number): T
		ease(ease: keyof typeof Easings): T
		offset(offset: number): T
		fit(low: number, high: number): T
	}

	////////////

    class DynamicGLSLSource extends GLSLSource {
		
        /**
         * src
         * 
		 * @param {GLSLSource | Texture | Output | Shader} _tex 
         */
        src(_tex?: GLSLSource | Texture | Output | Shader): DynamicGLSLSource;
   

        /**
         * noise
         * 
		 * @param {GydraNumber} [scale=10] 
		 * @param {GydraNumber} [speed=0.1] 
		 * @param {number[]} [offset=[0,0,0]] 
         */
        noise(scale?: GydraNumber, speed?: GydraNumber, offset?: number[]): DynamicGLSLSource;
   

        /**
         * osc
         * 
		 * @param {GydraNumber} [frequency=60] 
		 * @param {GydraNumber} [sync=0.1] 
		 * @param {GydraNumber} offset 
         */
        osc(frequency?: GydraNumber, sync?: GydraNumber, offset?: GydraNumber): DynamicGLSLSource;
   

        /**
         * shape
         * 
		 * @param {GydraNumber} [sides=3] 
		 * @param {GydraNumber} [radius=0.3] 
		 * @param {GydraNumber} [smoothing=0.005] 
         */
        shape(sides?: GydraNumber, radius?: GydraNumber, smoothing?: GydraNumber): DynamicGLSLSource;
   

        /**
         * gradient
         * 
		 * @param {GydraNumber} speed 
         */
        gradient(speed?: GydraNumber): DynamicGLSLSource;
   

        /**
         * voronoi
         * 
		 * @param {GydraNumber} [scale=5] 
		 * @param {GydraNumber} [speed=0.3] 
		 * @param {GydraNumber} [blending=0.3] 
         */
        voronoi(scale?: GydraNumber, speed?: GydraNumber, blending?: GydraNumber): DynamicGLSLSource;
   

        /**
         * solid
         * 
		 * @param {GydraNumber} r 
		 * @param {GydraNumber} g 
		 * @param {GydraNumber} b 
		 * @param {GydraNumber} [a=1] 
         */
        solid(r?: GydraNumber, g?: GydraNumber, b?: GydraNumber, a?: GydraNumber): DynamicGLSLSource;
   

        /**
         * st
         * *
         */
        st(): DynamicGLSLSource;
   

        /**
         * textureCube
         * 
		 * @param {GLSLSource | Texture | Output | Shader} _tex 
         */
        textureCube(_tex?: GLSLSource | Texture | Output | Shader): DynamicGLSLSource;
   

        /**
         * sobel
         * 
		 * @param {GLSLSource | Texture | Output | Shader} _tex 
		 * @param {GydraNumber} [spread=2] 
		 * @param {GydraNumber} [gain=0.5] 
		 * @param {GydraNumber} [slopeness=1] 
		 * @param {GydraNumber} [octaveFactor=1] 
         */
        sobel(_tex?: GLSLSource | Texture | Output | Shader, spread?: GydraNumber, gain?: GydraNumber, slopeness?: GydraNumber, octaveFactor?: GydraNumber): DynamicGLSLSource;
   

        /**
         * 
		 *			usage: convolution(<out or source>, <kernel_name> , <spread>)
		 *			default: convolution(NaN, 'normal', 1)
		 *			example: convolution(o0, 'normal', 1)
		 *
		 *			kernels: normal, gaussian_blur, gaussian_blur_2, gaussian_blur_3, unsharpen, sharpness, sharpen, edge_detect, edge_detect_2, edge_detect_3, edge_detect_4, edge_detect_5, edge_detect_6, sobel_horizontal, sobel_vertical, prev_it_horizontal, prev_it_vertical, box_blur, triangle_blur, emboss 
		 *		
         * 
		 * @param {GLSLSource | Texture | Output | Shader} _tex 
		 * @param {number[]} [kernel=[0,0,0,0,1,0,0,0,0]] 
		 * @param {GydraNumber} [spread=1] 
         */
        convolution(_tex?: GLSLSource | Texture | Output | Shader, kernel?: number[], spread?: GydraNumber): DynamicGLSLSource;
   

        /**
         * ascii
         * 
		 * @param {GLSLSource | Texture | Output | Shader} asciiTexture 
		 * @param {number[]} [charLen=[1,1]] - [row, cols] of asciiTexture
		 * @param {GydraNumber} [pixelateX=20] 
		 * @param {GydraNumber} [pixelateY=20] 
		 * @param {GydraNumber} [multiplier=1] 
         */
        ascii(asciiTexture?: GLSLSource | Texture | Output | Shader, charLen?: number[], pixelateX?: GydraNumber, pixelateY?: GydraNumber, multiplier?: GydraNumber): DynamicGLSLSource;
   

        /**
         * bloom
         * 
		 * @param {GydraNumber} [intensity=2] 
		 * @param {GydraNumber} [spread=1] 
		 * @param {GydraNumber} [threshold=0.5] 
         */
        bloom(intensity?: GydraNumber, spread?: GydraNumber, threshold?: GydraNumber): DynamicGLSLSource;
   

        /**
         * grid
         * 
		 * @param {number[]} [scale=[10,10]] 
		 * @param {number[]} [threshold=[0.1,0.1]] 
         */
        grid(scale?: number[], threshold?: number[]): DynamicGLSLSource;
   

        /**
         * 
		 *			usage: opticalFlow(<currentTex>, <prevTex>, <offset>, <lambda>, <speed>)
		 *			default: opticalFlow(NaN, NaN, 0.001, 0.1, 0.2)
		 *			example: opticalFlow(o0, o1, 0.001, 0.1, 0.2)
		 *			example:
		 *				await s0.initCam()
		 *				src(s0).out(o0)
		 *
		 *				opticalFlow(o0, o1).out(o2)
		 *				src(o0).out(o1)
		 *				render(o2)
		 *		
         * 
		 * @param {GLSLSource | Texture | Output | Shader} currentTex 
		 * @param {GLSLSource | Texture | Output | Shader} prevTex 
		 * @param {GydraNumber} [offset=0.001] 
		 * @param {GydraNumber} [lambda=0.1] 
		 * @param {GydraNumber} [speed=0.2] 
         */
        opticalFlow(currentTex?: GLSLSource | Texture | Output | Shader, prevTex?: GLSLSource | Texture | Output | Shader, offset?: GydraNumber, lambda?: GydraNumber, speed?: GydraNumber): DynamicGLSLSource;
   

        /**
         * 
		 *			usage: dither(<source>, <bayerTexture>, <paletteLUT>, <blendFactor>, <ditherScale>, <bayerScale>)
		 *			default: dither(NaN, NaN, NaN, 0, 4, 4)
		 *			example: dither(o0, bayerTex, paletteTex, 0.5, 4, 4)
		 *			example:
		 *				await s0.initCam()
		 *				src(s0).out()
		 *
		 *				b = bayerTexture()
		 *				p = texture({ width: 10, height: 1, filter: 'nearest' })
		 *				noise(2, 0, 0).draw(p)
		 *
		 *				dither(o0, b, p, 0, 2, 10).out(o1)
		 *				render(o1)
		 *		
         * 
		 * @param {GLSLSource | Texture | Output | Shader} _tex 
		 * @param {GLSLSource | Texture | Output | Shader} bayerTexture 
		 * @param {GLSLSource | Texture | Output | Shader} paletteLUT 
		 * @param {GydraNumber} blendFactor 
		 * @param {GydraNumber} [ditherScale=4] 
		 * @param {GydraNumber} [bayerScale=4] 
         */
        dither(_tex?: GLSLSource | Texture | Output | Shader, bayerTexture?: GLSLSource | Texture | Output | Shader, paletteLUT?: GLSLSource | Texture | Output | Shader, blendFactor?: GydraNumber, ditherScale?: GydraNumber, bayerScale?: GydraNumber): DynamicGLSLSource;
   

        /**
         * pbr
         * *
         */
        pbr(): DynamicGLSLSource;
   

        /**
         * _flat
         * *
         */
        _flat(): DynamicGLSLSource;
   
        
        /**
         * color
         * 
		 * @param {GydraNumber} [r=1] 
		 * @param {GydraNumber} [g=1] 
		 * @param {GydraNumber} [b=1] 
		 * @param {GydraNumber} [a=1] 
         */
        color(r?: GydraNumber, g?: GydraNumber, b?: GydraNumber, a?: GydraNumber): DynamicGLSLSource;
   

        /**
         * posterize
         * 
		 * @param {GydraNumber} [bins=3] 
		 * @param {GydraNumber} [gamma=0.6] 
         */
        posterize(bins?: GydraNumber, gamma?: GydraNumber): DynamicGLSLSource;
   

        /**
         * shift
         * 
		 * @param {GydraNumber} [r=0.5] 
		 * @param {GydraNumber} g 
		 * @param {GydraNumber} b 
		 * @param {GydraNumber} a 
         */
        shift(r?: GydraNumber, g?: GydraNumber, b?: GydraNumber, a?: GydraNumber): DynamicGLSLSource;
   

        /**
         * invert
         * 
		 * @param {GydraNumber} [amount=1] 
         */
        invert(amount?: GydraNumber): DynamicGLSLSource;
   

        /**
         * contrast
         * 
		 * @param {GydraNumber} [amount=1.6] 
         */
        contrast(amount?: GydraNumber): DynamicGLSLSource;
   

        /**
         * brightness
         * 
		 * @param {GydraNumber} [amount=0.4] 
         */
        brightness(amount?: GydraNumber): DynamicGLSLSource;
   

        /**
         * luma
         * 
		 * @param {GydraNumber} [threshold=0.5] 
		 * @param {GydraNumber} [tolerance=0.1] 
         */
        luma(threshold?: GydraNumber, tolerance?: GydraNumber): DynamicGLSLSource;
   

        /**
         * thresh
         * 
		 * @param {GydraNumber} [threshold=0.5] 
		 * @param {GydraNumber} [tolerance=0.04] 
         */
        thresh(threshold?: GydraNumber, tolerance?: GydraNumber): DynamicGLSLSource;
   

        /**
         * saturate
         * 
		 * @param {GydraNumber} [amount=2] 
         */
        saturate(amount?: GydraNumber): DynamicGLSLSource;
   

        /**
         * hue
         * 
		 * @param {GydraNumber} [hue=0.4] 
         */
        hue(hue?: GydraNumber): DynamicGLSLSource;
   

        /**
         * colorama
         * 
		 * @param {GydraNumber} [amount=0.005] 
         */
        colorama(amount?: GydraNumber): DynamicGLSLSource;
   

        /**
         * sum
         * 
		 * @param {GydraNumber} [scale=1] 
         */
        sum(scale?: GydraNumber): DynamicGLSLSource;
   

        /**
         * r
         * 
		 * @param {GydraNumber} [scale=1] 
		 * @param {GydraNumber} offset 
         */
        r(scale?: GydraNumber, offset?: GydraNumber): DynamicGLSLSource;
   

        /**
         * g
         * 
		 * @param {GydraNumber} [scale=1] 
		 * @param {GydraNumber} offset 
         */
        g(scale?: GydraNumber, offset?: GydraNumber): DynamicGLSLSource;
   

        /**
         * b
         * 
		 * @param {GydraNumber} [scale=1] 
		 * @param {GydraNumber} offset 
         */
        b(scale?: GydraNumber, offset?: GydraNumber): DynamicGLSLSource;
   

        /**
         * a
         * 
		 * @param {GydraNumber} [scale=1] 
		 * @param {GydraNumber} offset 
         */
        a(scale?: GydraNumber, offset?: GydraNumber): DynamicGLSLSource;
   

        /**
         * scroll
         * 
		 * @param {GydraNumber} [scrollX=0.5] 
		 * @param {GydraNumber} [scrollY=0.5] 
		 * @param {GydraNumber} speedX 
		 * @param {GydraNumber} speedY 
         */
        scroll(scrollX?: GydraNumber, scrollY?: GydraNumber, speedX?: GydraNumber, speedY?: GydraNumber): DynamicGLSLSource;
   

        /**
         * scrollY
         * 
		 * @param {GydraNumber} [scrollY=0.5] 
		 * @param {GydraNumber} speed 
         */
        scrollY(scrollY?: GydraNumber, speed?: GydraNumber): DynamicGLSLSource;
   

        /**
         * scrollX
         * 
		 * @param {GydraNumber} [scrollX=0.5] 
		 * @param {GydraNumber} speed 
         */
        scrollX(scrollX?: GydraNumber, speed?: GydraNumber): DynamicGLSLSource;
   

        /**
         * repeat
         * 
		 * @param {GydraNumber} [repeatX=3] 
		 * @param {GydraNumber} [repeatY=3] 
		 * @param {GydraNumber} [repeatZ=3] 
		 * @param {GydraNumber} offsetX 
		 * @param {GydraNumber} offsetY 
		 * @param {GydraNumber} offsetZ 
         */
        repeat(repeatX?: GydraNumber, repeatY?: GydraNumber, repeatZ?: GydraNumber, offsetX?: GydraNumber, offsetY?: GydraNumber, offsetZ?: GydraNumber): DynamicGLSLSource;
   

        /**
         * repeatX
         * 
		 * @param {GydraNumber} [reps=3] 
		 * @param {GydraNumber} offset 
         */
        repeatX(reps?: GydraNumber, offset?: GydraNumber): DynamicGLSLSource;
   

        /**
         * repeatY
         * 
		 * @param {GydraNumber} [reps=3] 
		 * @param {GydraNumber} offset 
         */
        repeatY(reps?: GydraNumber, offset?: GydraNumber): DynamicGLSLSource;
   

        /**
         * rotate
         * 
		 * @param {GydraNumber} [angle=10] 
		 * @param {GydraNumber} speed 
         */
        rotate(angle?: GydraNumber, speed?: GydraNumber): DynamicGLSLSource;
   

        /**
         * scale
         * 
		 * @param {GydraNumber} [amount=1.5] 
		 * @param {GydraNumber} [xMult=1] 
		 * @param {GydraNumber} [yMult=1] 
		 * @param {GydraNumber} [zMult=1] 
		 * @param {GydraNumber} [offsetX=0.5] 
		 * @param {GydraNumber} [offsetY=0.5] 
		 * @param {GydraNumber} [offsetZ=0.5] 
         */
        scale(amount?: GydraNumber, xMult?: GydraNumber, yMult?: GydraNumber, zMult?: GydraNumber, offsetX?: GydraNumber, offsetY?: GydraNumber, offsetZ?: GydraNumber): DynamicGLSLSource;
   

        /**
         * pixelate
         * 
		 * @param {GydraNumber} [pixelX=20] 
		 * @param {GydraNumber} [pixelY=20] 
		 * @param {GydraNumber} [pixelZ=20] 
         */
        pixelate(pixelX?: GydraNumber, pixelY?: GydraNumber, pixelZ?: GydraNumber): DynamicGLSLSource;
   

        /**
         * kaleid
         * 
		 * @param {GydraNumber} [nSides=4] 
         */
        kaleid(nSides?: GydraNumber): DynamicGLSLSource;
   

        /**
         * modulateRepeat
         * 
		 * @param {GLSLSource | Texture | Output | Shader} c0 - to combine
		 * @param {GydraNumber} [repeatX=3] 
		 * @param {GydraNumber} [repeatY=3] 
		 * @param {GydraNumber} [offsetX=0.5] 
		 * @param {GydraNumber} [offsetY=0.5] 
         */
        modulateRepeat(c0: GLSLSource | Texture | Output | Shader, repeatX?: GydraNumber, repeatY?: GydraNumber, offsetX?: GydraNumber, offsetY?: GydraNumber): DynamicGLSLSource;
   

        /**
         * modulateRepeatX
         * 
		 * @param {GLSLSource | Texture | Output | Shader} c0 - to combine
		 * @param {GydraNumber} [reps=3] 
		 * @param {GydraNumber} [offset=0.5] 
         */
        modulateRepeatX(c0: GLSLSource | Texture | Output | Shader, reps?: GydraNumber, offset?: GydraNumber): DynamicGLSLSource;
   

        /**
         * modulateRepeatY
         * 
		 * @param {GLSLSource | Texture | Output | Shader} c0 - to combine
		 * @param {GydraNumber} [reps=3] 
		 * @param {GydraNumber} [offset=0.5] 
         */
        modulateRepeatY(c0: GLSLSource | Texture | Output | Shader, reps?: GydraNumber, offset?: GydraNumber): DynamicGLSLSource;
   

        /**
         * modulateKaleid
         * 
		 * @param {GLSLSource | Texture | Output | Shader} c0 - to combine
		 * @param {GydraNumber} [nSides=4] 
         */
        modulateKaleid(c0: GLSLSource | Texture | Output | Shader, nSides?: GydraNumber): DynamicGLSLSource;
   

        /**
         * modulateScrollX
         * 
		 * @param {GLSLSource | Texture | Output | Shader} c0 - to combine
		 * @param {GydraNumber} [scrollX=0.5] 
		 * @param {GydraNumber} speed 
         */
        modulateScrollX(c0: GLSLSource | Texture | Output | Shader, scrollX?: GydraNumber, speed?: GydraNumber): DynamicGLSLSource;
   

        /**
         * modulateScrollY
         * 
		 * @param {GLSLSource | Texture | Output | Shader} c0 - to combine
		 * @param {GydraNumber} [scrollY=0.5] 
		 * @param {GydraNumber} speed 
         */
        modulateScrollY(c0: GLSLSource | Texture | Output | Shader, scrollY?: GydraNumber, speed?: GydraNumber): DynamicGLSLSource;
   

        /**
         * modulate
         * 
		 * @param {GLSLSource | Texture | Output | Shader} c0 - to combine
		 * @param {GydraNumber} [amountX=0.1] 
		 * @param {GydraNumber} [amountY=0.1] 
		 * @param {GydraNumber} [amountZ=0.1] 
         */
        modulate(c0: GLSLSource | Texture | Output | Shader, amountX?: GydraNumber, amountY?: GydraNumber, amountZ?: GydraNumber): DynamicGLSLSource;
   

        /**
         * modulateScale
         * 
		 * @param {GLSLSource | Texture | Output | Shader} c0 - to combine
		 * @param {GydraNumber} [multiple=1] 
		 * @param {GydraNumber} [offset=1] 
         */
        modulateScale(c0: GLSLSource | Texture | Output | Shader, multiple?: GydraNumber, offset?: GydraNumber): DynamicGLSLSource;
   

        /**
         * modulatePixelate
         * 
		 * @param {GLSLSource | Texture | Output | Shader} c0 - to combine
		 * @param {GydraNumber} [multiple=10] 
		 * @param {GydraNumber} [offset=3] 
         */
        modulatePixelate(c0: GLSLSource | Texture | Output | Shader, multiple?: GydraNumber, offset?: GydraNumber): DynamicGLSLSource;
   

        /**
         * modulateRotate
         * 
		 * @param {GLSLSource | Texture | Output | Shader} c0 - to combine
		 * @param {GydraNumber} [multiple=1] 
		 * @param {GydraNumber} offset 
         */
        modulateRotate(c0: GLSLSource | Texture | Output | Shader, multiple?: GydraNumber, offset?: GydraNumber): DynamicGLSLSource;
   

        /**
         * modulateHue
         * 
		 * @param {GLSLSource | Texture | Output | Shader} c0 - to combine
		 * @param {GydraNumber} [amount=1] 
         */
        modulateHue(c0: GLSLSource | Texture | Output | Shader, amount?: GydraNumber): DynamicGLSLSource;
   

        /**
         * mask
         * 
		 * @param {GLSLSource | Texture | Output | Shader} c0 - to combine
         */
        mask(c0: GLSLSource | Texture | Output | Shader): DynamicGLSLSource;
   

        /**
         * add
         * 
		 * @param {GLSLSource | Texture | Output | Shader} c0 - to combine
		 * @param {GydraNumber} [amount=1] 
         */
        add(c0: GLSLSource | Texture | Output | Shader, amount?: GydraNumber): DynamicGLSLSource;
   

        /**
         * sub
         * 
		 * @param {GLSLSource | Texture | Output | Shader} c0 - to combine
		 * @param {GydraNumber} [amount=1] 
         */
        sub(c0: GLSLSource | Texture | Output | Shader, amount?: GydraNumber): DynamicGLSLSource;
   

        /**
         * layer
         * 
		 * @param {GLSLSource | Texture | Output | Shader} c0 - to combine
         */
        layer(c0: GLSLSource | Texture | Output | Shader): DynamicGLSLSource;
   

        /**
         * blend
         * 
		 * @param {GLSLSource | Texture | Output | Shader} c0 - to combine
		 * @param {GydraNumber} [amount=0.5] 
         */
        blend(c0: GLSLSource | Texture | Output | Shader, amount?: GydraNumber): DynamicGLSLSource;
   

        /**
         * mult
         * 
		 * @param {GLSLSource | Texture | Output | Shader} c0 - to combine
		 * @param {GydraNumber} [amount=1] 
         */
        mult(c0: GLSLSource | Texture | Output | Shader, amount?: GydraNumber): DynamicGLSLSource;
   

        /**
         * diff
         * 
		 * @param {GLSLSource | Texture | Output | Shader} c0 - to combine
         */
        diff(c0: GLSLSource | Texture | Output | Shader): DynamicGLSLSource;
   

        /**
         * glslColor
         * 
		 * @param {string} code - raw code of type color
         */
        glslColor(code: string): DynamicGLSLSource;
   

        /**
         * glslCoord
         * 
		 * @param {string} code - raw code of type coord
         */
        glslCoord(code: string): DynamicGLSLSource;
   

        /**
         * glslCombine
         * 
		 * @param {string} code - raw code of type combine
         */
        glslCombine(code: string): DynamicGLSLSource;
   

        /**
         * glslCombineCoord
         * 
		 * @param {string} code - raw code of type combineCoord
         */
        glslCombineCoord(code: string): DynamicGLSLSource;
   

        /**
         * translate
         * 
		 * @param {number[]} [translate=[0.5,0.5,0.5]] 
		 * @param {number[]} [speed=[0,0,0]] 
         */
        translate(translate?: number[], speed?: number[]): DynamicGLSLSource;
   

        /**
         * translateY
         * 
		 * @param {GydraNumber} [translateY=0.5] 
		 * @param {GydraNumber} speed 
         */
        translateY(translateY?: GydraNumber, speed?: GydraNumber): DynamicGLSLSource;
   

        /**
         * translateX
         * 
		 * @param {GydraNumber} [translateX=0.5] 
		 * @param {GydraNumber} speed 
         */
        translateX(translateX?: GydraNumber, speed?: GydraNumber): DynamicGLSLSource;
   

        /**
         * translateZ
         * 
		 * @param {GydraNumber} [translateZ=0.5] 
		 * @param {GydraNumber} speed 
         */
        translateZ(translateZ?: GydraNumber, speed?: GydraNumber): DynamicGLSLSource;
   

        /**
         * rotateX
         * 
		 * @param {GydraNumber} [angle=10] 
		 * @param {GydraNumber} speed 
         */
        rotateX(angle?: GydraNumber, speed?: GydraNumber): DynamicGLSLSource;
   

        /**
         * rotateY
         * 
		 * @param {GydraNumber} [angle=10] 
		 * @param {GydraNumber} speed 
         */
        rotateY(angle?: GydraNumber, speed?: GydraNumber): DynamicGLSLSource;
   

        /**
         * rotateZ
         * 
		 * @param {GydraNumber} [angle=10] 
		 * @param {GydraNumber} speed 
         */
        rotateZ(angle?: GydraNumber, speed?: GydraNumber): DynamicGLSLSource;
   

        /**
         * ripple
         * 
		 * @param {GydraNumber} [amount=1] 
		 * @param {GydraNumber} [speed=1] 
		 * @param {GydraNumber} phase 
		 * @param {GydraNumber} [f=0.05] 
		 * @param {GydraNumber} [k=1] 
         */
        ripple(amount?: GydraNumber, speed?: GydraNumber, phase?: GydraNumber, f?: GydraNumber, k?: GydraNumber): DynamicGLSLSource;
   

        /**
         * glitch
         * 
		 * @param {GydraNumber} [amount=1] 
		 * @param {GydraNumber} [offset=0.1] 
		 * @param {GydraNumber} [gap=0.05] 
		 * @param {GydraNumber} [gapOffset=0.5] 
         */
        glitch(amount?: GydraNumber, offset?: GydraNumber, gap?: GydraNumber, gapOffset?: GydraNumber): DynamicGLSLSource;
   

        /**
         * polar
         * 
		 * @param {GydraNumber} [reps=1] 
         */
        polar(reps?: GydraNumber): DynamicGLSLSource;
   

        /**
         * mirrorX
         * 
		 * @param {GydraNumber} pos 
		 * @param {GydraNumber} [coverage=1] 
		 * @param {GydraNumber} invert 
         */
        mirrorX(pos?: GydraNumber, coverage?: GydraNumber, invert?: GydraNumber): DynamicGLSLSource;
   

        /**
         * mirrorY
         * 
		 * @param {GydraNumber} pos 
		 * @param {GydraNumber} [coverage=1] 
		 * @param {GydraNumber} invert 
         */
        mirrorY(pos?: GydraNumber, coverage?: GydraNumber, invert?: GydraNumber): DynamicGLSLSource;
   

        /**
         * inversion
         * 
		 * @param {GydraNumber} [amount=1] 
         */
        inversion(amount?: GydraNumber): DynamicGLSLSource;
   

        /**
         * boost
         * 
		 * @param {number[]} [refColor=[0,0,0]] 
		 * @param {GydraNumber} [amount=32] 
         */
        boost(refColor?: number[], amount?: GydraNumber): DynamicGLSLSource;
   

        /**
         * isolate
         * 
		 * @param {number[]} [toIsolate=[0,0,0]] 
		 * @param {GydraNumber} [threshold=0.1] 
         */
        isolate(toIsolate?: number[], threshold?: GydraNumber): DynamicGLSLSource;
   

        /**
         * clear
         * 
		 * @param {number[]} [toClear=[0,0,0]] 
		 * @param {GydraNumber} [threshold=0.1] 
         */
        clear(toClear?: number[], threshold?: GydraNumber): DynamicGLSLSource;
   

        /**
         * alpha
         * 
		 * @param {GydraNumber} [amount=1] 
         */
        alpha(amount?: GydraNumber): DynamicGLSLSource;
   

        /**
         * add2
         * 
		 * @param {GLSLSource | Texture | Output | Shader} c0 - to combine
		 * @param {GydraNumber} [amount=1] 
         */
        add2(c0: GLSLSource | Texture | Output | Shader, amount?: GydraNumber): DynamicGLSLSource;
   

        /**
         * average
         * 
		 * @param {GLSLSource | Texture | Output | Shader} c0 - to combine
		 * @param {GydraNumber} [amount=1] 
         */
        average(c0: GLSLSource | Texture | Output | Shader, amount?: GydraNumber): DynamicGLSLSource;
   

        /**
         * colorBurn
         * 
		 * @param {GLSLSource | Texture | Output | Shader} c0 - to combine
		 * @param {GydraNumber} [amount=1] 
         */
        colorBurn(c0: GLSLSource | Texture | Output | Shader, amount?: GydraNumber): DynamicGLSLSource;
   

        /**
         * colorDodge
         * 
		 * @param {GLSLSource | Texture | Output | Shader} c0 - to combine
		 * @param {GydraNumber} [amount=1] 
         */
        colorDodge(c0: GLSLSource | Texture | Output | Shader, amount?: GydraNumber): DynamicGLSLSource;
   

        /**
         * darken
         * 
		 * @param {GLSLSource | Texture | Output | Shader} c0 - to combine
		 * @param {GydraNumber} [amount=1] 
         */
        darken(c0: GLSLSource | Texture | Output | Shader, amount?: GydraNumber): DynamicGLSLSource;
   

        /**
         * difference
         * 
		 * @param {GLSLSource | Texture | Output | Shader} c0 - to combine
		 * @param {GydraNumber} [amount=1] 
         */
        difference(c0: GLSLSource | Texture | Output | Shader, amount?: GydraNumber): DynamicGLSLSource;
   

        /**
         * divide
         * 
		 * @param {GLSLSource | Texture | Output | Shader} c0 - to combine
		 * @param {GydraNumber} [amount=1] 
         */
        divide(c0: GLSLSource | Texture | Output | Shader, amount?: GydraNumber): DynamicGLSLSource;
   

        /**
         * exclusion
         * 
		 * @param {GLSLSource | Texture | Output | Shader} c0 - to combine
		 * @param {GydraNumber} [amount=1] 
         */
        exclusion(c0: GLSLSource | Texture | Output | Shader, amount?: GydraNumber): DynamicGLSLSource;
   

        /**
         * glow
         * 
		 * @param {GLSLSource | Texture | Output | Shader} c0 - to combine
		 * @param {GydraNumber} [amount=1] 
         */
        glow(c0: GLSLSource | Texture | Output | Shader, amount?: GydraNumber): DynamicGLSLSource;
   

        /**
         * hardLight
         * 
		 * @param {GLSLSource | Texture | Output | Shader} c0 - to combine
		 * @param {GydraNumber} [amount=1] 
         */
        hardLight(c0: GLSLSource | Texture | Output | Shader, amount?: GydraNumber): DynamicGLSLSource;
   

        /**
         * hardMix
         * 
		 * @param {GLSLSource | Texture | Output | Shader} c0 - to combine
		 * @param {GydraNumber} [amount=1] 
         */
        hardMix(c0: GLSLSource | Texture | Output | Shader, amount?: GydraNumber): DynamicGLSLSource;
   

        /**
         * lighten
         * 
		 * @param {GLSLSource | Texture | Output | Shader} c0 - to combine
		 * @param {GydraNumber} [amount=1] 
         */
        lighten(c0: GLSLSource | Texture | Output | Shader, amount?: GydraNumber): DynamicGLSLSource;
   

        /**
         * linearBurn
         * 
		 * @param {GLSLSource | Texture | Output | Shader} c0 - to combine
		 * @param {GydraNumber} [amount=1] 
         */
        linearBurn(c0: GLSLSource | Texture | Output | Shader, amount?: GydraNumber): DynamicGLSLSource;
   

        /**
         * linearDodge
         * 
		 * @param {GLSLSource | Texture | Output | Shader} c0 - to combine
		 * @param {GydraNumber} [amount=1] 
         */
        linearDodge(c0: GLSLSource | Texture | Output | Shader, amount?: GydraNumber): DynamicGLSLSource;
   

        /**
         * linearLight
         * 
		 * @param {GLSLSource | Texture | Output | Shader} c0 - to combine
		 * @param {GydraNumber} [amount=1] 
         */
        linearLight(c0: GLSLSource | Texture | Output | Shader, amount?: GydraNumber): DynamicGLSLSource;
   

        /**
         * multiply
         * 
		 * @param {GLSLSource | Texture | Output | Shader} c0 - to combine
		 * @param {GydraNumber} [amount=1] 
         */
        multiply(c0: GLSLSource | Texture | Output | Shader, amount?: GydraNumber): DynamicGLSLSource;
   

        /**
         * negation
         * 
		 * @param {GLSLSource | Texture | Output | Shader} c0 - to combine
		 * @param {GydraNumber} [amount=1] 
         */
        negation(c0: GLSLSource | Texture | Output | Shader, amount?: GydraNumber): DynamicGLSLSource;
   

        /**
         * overlay
         * 
		 * @param {GLSLSource | Texture | Output | Shader} c0 - to combine
		 * @param {GydraNumber} [amount=1] 
         */
        overlay(c0: GLSLSource | Texture | Output | Shader, amount?: GydraNumber): DynamicGLSLSource;
   

        /**
         * phoenix
         * 
		 * @param {GLSLSource | Texture | Output | Shader} c0 - to combine
		 * @param {GydraNumber} [amount=1] 
         */
        phoenix(c0: GLSLSource | Texture | Output | Shader, amount?: GydraNumber): DynamicGLSLSource;
   

        /**
         * pinLight
         * 
		 * @param {GLSLSource | Texture | Output | Shader} c0 - to combine
		 * @param {GydraNumber} [amount=1] 
         */
        pinLight(c0: GLSLSource | Texture | Output | Shader, amount?: GydraNumber): DynamicGLSLSource;
   

        /**
         * reflect
         * 
		 * @param {GLSLSource | Texture | Output | Shader} c0 - to combine
		 * @param {GydraNumber} [amount=1] 
         */
        reflect(c0: GLSLSource | Texture | Output | Shader, amount?: GydraNumber): DynamicGLSLSource;
   

        /**
         * screen
         * 
		 * @param {GLSLSource | Texture | Output | Shader} c0 - to combine
		 * @param {GydraNumber} [amount=1] 
         */
        screen(c0: GLSLSource | Texture | Output | Shader, amount?: GydraNumber): DynamicGLSLSource;
   

        /**
         * softLight
         * 
		 * @param {GLSLSource | Texture | Output | Shader} c0 - to combine
		 * @param {GydraNumber} [amount=1] 
         */
        softLight(c0: GLSLSource | Texture | Output | Shader, amount?: GydraNumber): DynamicGLSLSource;
   

        /**
         * subtract
         * 
		 * @param {GLSLSource | Texture | Output | Shader} c0 - to combine
		 * @param {GydraNumber} [amount=1] 
         */
        subtract(c0: GLSLSource | Texture | Output | Shader, amount?: GydraNumber): DynamicGLSLSource;
   

        /**
         * vividLight
         * 
		 * @param {GLSLSource | Texture | Output | Shader} c0 - to combine
		 * @param {GydraNumber} [amount=1] 
         */
        vividLight(c0: GLSLSource | Texture | Output | Shader, amount?: GydraNumber): DynamicGLSLSource;
   
    }   


    
        /**
         * src
         * 
		 * @param {GLSLSource | Texture | Output | Shader} _tex 
         */
        function src(_tex?: GLSLSource | Texture | Output | Shader): DynamicGLSLSource;
   

        /**
         * noise
         * 
		 * @param {GydraNumber} [scale=10] 
		 * @param {GydraNumber} [speed=0.1] 
		 * @param {number[]} [offset=[0,0,0]] 
         */
        function noise(scale?: GydraNumber, speed?: GydraNumber, offset?: number[]): DynamicGLSLSource;
   

        /**
         * osc
         * 
		 * @param {GydraNumber} [frequency=60] 
		 * @param {GydraNumber} [sync=0.1] 
		 * @param {GydraNumber} offset 
         */
        function osc(frequency?: GydraNumber, sync?: GydraNumber, offset?: GydraNumber): DynamicGLSLSource;
   

        /**
         * shape
         * 
		 * @param {GydraNumber} [sides=3] 
		 * @param {GydraNumber} [radius=0.3] 
		 * @param {GydraNumber} [smoothing=0.005] 
         */
        function shape(sides?: GydraNumber, radius?: GydraNumber, smoothing?: GydraNumber): DynamicGLSLSource;
   

        /**
         * gradient
         * 
		 * @param {GydraNumber} speed 
         */
        function gradient(speed?: GydraNumber): DynamicGLSLSource;
   

        /**
         * voronoi
         * 
		 * @param {GydraNumber} [scale=5] 
		 * @param {GydraNumber} [speed=0.3] 
		 * @param {GydraNumber} [blending=0.3] 
         */
        function voronoi(scale?: GydraNumber, speed?: GydraNumber, blending?: GydraNumber): DynamicGLSLSource;
   

        /**
         * solid
         * 
		 * @param {GydraNumber} r 
		 * @param {GydraNumber} g 
		 * @param {GydraNumber} b 
		 * @param {GydraNumber} [a=1] 
         */
        function solid(r?: GydraNumber, g?: GydraNumber, b?: GydraNumber, a?: GydraNumber): DynamicGLSLSource;
   

        /**
         * glsl
         * 
		 * @param {string} code - raw code of type src
         */
        function glsl(code: string): DynamicGLSLSource;
   

        /**
         * st
         * *
         */
        function st(): DynamicGLSLSource;
   

        /**
         * textureCube
         * 
		 * @param {GLSLSource | Texture | Output | Shader} _tex 
         */
        function textureCube(_tex?: GLSLSource | Texture | Output | Shader): DynamicGLSLSource;
   

        /**
         * sobel
         * 
		 * @param {GLSLSource | Texture | Output | Shader} _tex 
		 * @param {GydraNumber} [spread=2] 
		 * @param {GydraNumber} [gain=0.5] 
		 * @param {GydraNumber} [slopeness=1] 
		 * @param {GydraNumber} [octaveFactor=1] 
         */
        function sobel(_tex?: GLSLSource | Texture | Output | Shader, spread?: GydraNumber, gain?: GydraNumber, slopeness?: GydraNumber, octaveFactor?: GydraNumber): DynamicGLSLSource;
   

        /**
         * 
	 *			usage: convolution(<out or source>, <kernel_name> , <spread>)
	 *			default: convolution(NaN, 'normal', 1)
	 *			example: convolution(o0, 'normal', 1)
	 *
	 *			kernels: normal, gaussian_blur, gaussian_blur_2, gaussian_blur_3, unsharpen, sharpness, sharpen, edge_detect, edge_detect_2, edge_detect_3, edge_detect_4, edge_detect_5, edge_detect_6, sobel_horizontal, sobel_vertical, prev_it_horizontal, prev_it_vertical, box_blur, triangle_blur, emboss 
	 *		
         * 
		 * @param {GLSLSource | Texture | Output | Shader} _tex 
		 * @param {number[]} [kernel=[0,0,0,0,1,0,0,0,0]] 
		 * @param {GydraNumber} [spread=1] 
         */
        function convolution(_tex?: GLSLSource | Texture | Output | Shader, kernel?: number[], spread?: GydraNumber): DynamicGLSLSource;
   

        /**
         * ascii
         * 
		 * @param {GLSLSource | Texture | Output | Shader} source 
		 * @param {GLSLSource | Texture | Output | Shader} asciiTexture 
		 * @param {number[]} [charLen=[1,1]] - [row, cols] of asciiTexture
		 * @param {GydraNumber} [pixelateX=20] 
		 * @param {GydraNumber} [pixelateY=20] 
		 * @param {GydraNumber} [multiplier=1] 
         */
        function ascii(source?: GLSLSource | Texture | Output | Shader, asciiTexture?: GLSLSource | Texture | Output | Shader, charLen?: number[], pixelateX?: GydraNumber, pixelateY?: GydraNumber, multiplier?: GydraNumber): DynamicGLSLSource;
   

        /**
         * bloom
         * 
		 * @param {GLSLSource | Texture | Output | Shader} source 
		 * @param {GydraNumber} [intensity=2] 
		 * @param {GydraNumber} [spread=1] 
		 * @param {GydraNumber} [threshold=0.5] 
         */
        function bloom(source?: GLSLSource | Texture | Output | Shader, intensity?: GydraNumber, spread?: GydraNumber, threshold?: GydraNumber): DynamicGLSLSource;
   

        /**
         * grid
         * 
		 * @param {number[]} [scale=[10,10]] 
		 * @param {number[]} [threshold=[0.1,0.1]] 
         */
        function grid(scale?: number[], threshold?: number[]): DynamicGLSLSource;
   

        /**
         * 
	 *			usage: opticalFlow(<currentTex>, <prevTex>, <offset>, <lambda>, <speed>)
	 *			default: opticalFlow(NaN, NaN, 0.001, 0.1, 0.2)
	 *			example: opticalFlow(o0, o1, 0.001, 0.1, 0.2)
	 *			example:
	 *				await s0.initCam()
	 *				src(s0).out(o0)
	 *
	 *				opticalFlow(o0, o1).out(o2)
	 *				src(o0).out(o1)
	 *				render(o2)
	 *		
         * 
		 * @param {GLSLSource | Texture | Output | Shader} currentTex 
		 * @param {GLSLSource | Texture | Output | Shader} prevTex 
		 * @param {GydraNumber} [offset=0.001] 
		 * @param {GydraNumber} [lambda=0.1] 
		 * @param {GydraNumber} [speed=0.2] 
         */
        function opticalFlow(currentTex?: GLSLSource | Texture | Output | Shader, prevTex?: GLSLSource | Texture | Output | Shader, offset?: GydraNumber, lambda?: GydraNumber, speed?: GydraNumber): DynamicGLSLSource;
   

        /**
         * 
	 *			usage: dither(<source>, <bayerTexture>, <paletteLUT>, <blendFactor>, <ditherScale>, <bayerScale>)
	 *			default: dither(NaN, NaN, NaN, 0, 4, 4)
	 *			example: dither(o0, bayerTex, paletteTex, 0.5, 4, 4)
	 *			example:
	 *				await s0.initCam()
	 *				src(s0).out()
	 *
	 *				b = bayerTexture()
	 *				p = texture({ width: 10, height: 1, filter: 'nearest' })
	 *				noise(2, 0, 0).draw(p)
	 *
	 *				dither(o0, b, p, 0, 2, 10).out(o1)
	 *				render(o1)
	 *		
         * 
		 * @param {GLSLSource | Texture | Output | Shader} _tex 
		 * @param {GLSLSource | Texture | Output | Shader} bayerTexture 
		 * @param {GLSLSource | Texture | Output | Shader} paletteLUT 
		 * @param {GydraNumber} blendFactor 
		 * @param {GydraNumber} [ditherScale=4] 
		 * @param {GydraNumber} [bayerScale=4] 
         */
        function dither(_tex?: GLSLSource | Texture | Output | Shader, bayerTexture?: GLSLSource | Texture | Output | Shader, paletteLUT?: GLSLSource | Texture | Output | Shader, blendFactor?: GydraNumber, ditherScale?: GydraNumber, bayerScale?: GydraNumber): DynamicGLSLSource;
   

        /**
         * pbr
         * *
         */
        function pbr(): DynamicGLSLSource;
   

        /**
         * _flat
         * *
         */
        function _flat(): DynamicGLSLSource;
   

	/// 3d
	
	function box(props?: BoxOptions): Model;
	function circle(props?: CircleOptions): Model;
	function quad(props?: QuadOptions): Model;
	function plane(props?: PlaneOptions): Model;
	function roundedRectangle(props?: RoundedRectangleOptions): Model;
	function stadium(props?: StadiumOptions): Model;
	function ellipse(props?: EllipseOptions): Model;
	function disc(props?: DiscOptions): Model;
	function superellipse(props?: SuperellipseOptions): Model;
	function squircle(props?: SquircleOptions): Model;
	function annulus(props?: AnnulusOptions): Model;
	function reuleux(props?: ReuleuxOptions): Model;
	function cube(props?: CubeOptions): Model;
	function roundedCube(props?: RoundedCubeOptions): Model;
	function sphere(props?: SphereOptions): Model;
	function icosphere(props?: IcosphereOptions): Model;
	function ellipsoid(props?: EllipsoidOptions): Model;
	function cylinder(props?: CylinderOptions): Model;
	function cone(props?: ConeOptions): Model;
	function capsule(props?: CapsuleOptions): Model;
	function torus(props?: TorusOptions): Model;
	function tetrahedron(props?: TetrahedronOptions): Model;
	function icosahedron(props?: IcosahedronOptions): Model;
	function poly(props?: PolygonProps): Model;
	function polygon(props?: PolygonProps): Model;
	function triangle(props?: { s: number; sx: number; sy: number }): Model;
	function rect(props?: { s: number; sx: number; sy: number }): Model;
	function line(props?: { s: number; sx: number; sy: number }): Model;
}