etro 0.7.0 → 0.8.2

package/dist/effect/gaussian-blur.d.ts

@@ -0,0 +1,60 @@
+import { Stack } from './stack';
+import { Shader } from './shader';
+import { Movie } from '../movie';
+import { Visual } from '../layer';
+export interface GaussianBlurOptions {
+    radius: number;
+}
+/**
+ * Applies a Gaussian blur
+ */
+export declare class GaussianBlur extends Stack {
+    constructor(options: GaussianBlurOptions);
+}
+/**
+ * Shared class for both horizontal and vertical gaussian blur classes.
+ */
+declare class GaussianBlurComponent extends Shader {
+    radius: number;
+    shape: HTMLCanvasElement;
+    private _radiusCache;
+    /**
+     * @param src - fragment source code (specific to which component -
+     * horizontal or vertical)
+     * @param radius - only integers are currently supported
+     */
+    constructor(options: {
+        fragmentSource: string;
+        radius: number;
+    });
+    apply(target: Movie | Visual, reltime: number): void;
+    /**
+     * Render Gaussian kernel to a canvas for use in shader.
+     * @param kernel
+     * @private
+     *
+     * @return
+     */
+    private static _render1DKernel;
+    private static _gen1DKernel;
+    private static _genPascalRow;
+}
+/**
+ * Horizontal component of gaussian blur
+ */
+export declare class GaussianBlurHorizontal extends GaussianBlurComponent {
+    /**
+     * @param radius
+     */
+    constructor(options: GaussianBlurOptions);
+}
+/**
+ * Vertical component of gaussian blur
+ */
+export declare class GaussianBlurVertical extends GaussianBlurComponent {
+    /**
+     * @param radius
+     */
+    constructor(options: GaussianBlurOptions);
+}
+export {};

package/dist/effect/grayscale.d.ts

@@ -0,0 +1,7 @@
+import { Shader } from './shader';
+/**
+ * Converts the target to a grayscale image
+ */
+export declare class Grayscale extends Shader {
+    constructor();
+}

package/dist/effect/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @module effect
+ */
+export * from './base';
+export * from './brightness';
+export * from './channels';
+export * from './chroma-key';
+export * from './contrast';
+export * from './elliptical-mask';
+export * from './gaussian-blur';
+export * from './grayscale';
+export * from './pixelate';
+export * from './shader';
+export * from './stack';
+export * from './transform';

package/dist/effect/pixelate.d.ts

@@ -0,0 +1,18 @@
+import { Visual } from '../layer';
+import { Movie } from '../movie';
+import { Dynamic } from '../util';
+import { Shader } from './shader';
+export interface PixelateOptions {
+    pixelSize?: Dynamic<number>;
+}
+/**
+ * Breaks the target up into squares of `pixelSize` by `pixelSize`
+ */
+export declare class Pixelate extends Shader {
+    pixelSize: Dynamic<number>;
+    /**
+     * @param pixelSize
+     */
+    constructor(options?: PixelateOptions);
+    apply(target: Movie | Visual, reltime: number): void;
+}

package/dist/effect/shader.d.ts

@@ -0,0 +1,99 @@
+import { Visual } from '../layer/index';
+import { Movie } from '../movie';
+import { Base } from './base';
+export interface UniformOptions {
+    type?: string;
+    defaultFloatComponent?: number;
+}
+export interface TextureOptions {
+    createUniform?: boolean;
+    target?: any;
+    level?: number;
+    internalFormat?: any;
+    srcFormat?: any;
+    srcType?: any;
+    wrapS?: any;
+    wrapT?: any;
+    minFilter?: any;
+    magFilter?: any;
+}
+export interface ShaderOptions {
+    fragmentSource?: string;
+    uniforms?: Record<string, (UniformOptions | string)>;
+    textures?: Record<string, TextureOptions>;
+    sourceTextureOptions?: TextureOptions;
+}
+/**
+ * A hardware-accelerated pixel mapping using WebGL
+ */
+export declare class Shader extends Base {
+    /**
+     * WebGL texture units consumed by {@link Shader}
+     */
+    static INTERNAL_TEXTURE_UNITS: number;
+    private static _DEFAULT_TEXTURE_OPTIONS;
+    private static _VERTEX_SOURCE;
+    private static _IDENTITY_FRAGMENT_SOURCE;
+    private _program;
+    private _buffers;
+    private _canvas;
+    private _gl;
+    private _uniformLocations;
+    private _attribLocations;
+    private _userUniforms;
+    private _userTextures;
+    private _sourceTextureOptions;
+    private _inputTexture;
+    /**
+     * @param fragmentSrc
+     * @param [userUniforms={}] - object mapping uniform id to an
+     * options object or a string (if you only need to provide the uniforms'
+     * type)
+     * @param [userTextures=[]]
+     * @param [sourceTextureOptions={}]
+     */
+    constructor(options?: ShaderOptions);
+    private _initGl;
+    private _initTextures;
+    private _initAttribs;
+    private _initUniforms;
+    apply(target: Movie | Visual, reltime: number): void;
+    private _checkDimensions;
+    private _refreshGl;
+    private _enablePositionAttrib;
+    private _enableTexCoordAttrib;
+    private _prepareTextures;
+    private _prepareUniforms;
+    private _draw;
+    /**
+     * Converts a value of a standard type for javascript to a standard type for
+     * GLSL
+     * @param value - the raw value to prepare
+     * @param outputType - the WebGL type of |value|; example:
+     * <code>1f</code> for a float
+     * @param reltime - current time, relative to the target
+     * @param [options] - Optional config
+     */
+    private _prepareValue;
+    private static _initRectBuffers;
+    /**
+     * Creates the quad covering the screen
+     */
+    private static _initBuffer;
+    /**
+     * Creates a webgl texture from the source.
+     * @param [options] - optional WebGL config for texture
+     * @param [options.target=gl.TEXTURE_2D]
+     * @param [options.level=0]
+     * @param [options.internalFormat=gl.RGBA]
+     * @param [options.srcFormat=gl.RGBA]
+     * @param [options.srcType=gl.UNSIGNED_BYTE]
+     * @param [options.wrapS=gl.CLAMP_TO_EDGE]
+     * @param [options.wrapT=gl.CLAMP_TO_EDGE]
+     * @param [options.minFilter=gl.LINEAR]
+     * @param [options.magFilter=gl.LINEAR]
+     */
+    private static _loadTexture;
+    private static _initShaderProgram;
+    private static _loadShader;
+}

package/dist/effect/stack.d.ts

@@ -0,0 +1,23 @@
+import { Movie } from '../movie';
+import { Base } from './base';
+import { Visual } from '../layer';
+export interface StackOptions {
+    effects: Base[];
+}
+/**
+ * A sequence of effects to apply, treated as one effect. This can be useful
+ * for defining reused effect sequences as one effect.
+ */
+export declare class Stack extends Base {
+    readonly effects: Base[];
+    private _effectsBack;
+    constructor(options: StackOptions);
+    attach(movie: Movie): void;
+    detach(): void;
+    apply(target: Movie | Visual, reltime: number): void;
+    /**
+     * Convenience method for chaining
+     * @param effect - the effect to append
+     */
+    addEffect(effect: Base): Stack;
+}

package/dist/effect/transform.d.ts

@@ -0,0 +1,73 @@
+import { Visual } from '../layer/index';
+import { Movie } from '../movie';
+import { Dynamic } from '../util';
+import { Base } from './base';
+export interface TransformOptions {
+    matrix: Dynamic<Transform.Matrix>;
+}
+/**
+ * Transforms a layer or movie using a transformation matrix. Use {@link
+ * Transform.Matrix} to either A) calculate those values based on a series of
+ * translations, scalings and rotations) or B) input the matrix values
+ * directly, using the optional argument in the constructor.
+ */
+declare class Transform extends Base {
+    /** Matrix that determines how to transform the target */
+    matrix: Dynamic<Transform.Matrix>;
+    private _tmpMatrix;
+    private _tmpCanvas;
+    private _tmpCtx;
+    /**
+     * @param matrix - matrix that determines how to transform the target
+     */
+    constructor(options: TransformOptions);
+    apply(target: Movie | Visual, reltime: number): void;
+}
+declare namespace Transform {
+    /**
+     * @class
+     * A 3x3 matrix for storing 2d transformations
+     */
+    class Matrix {
+        /**
+         * The identity matrix
+         */
+        static IDENTITY: Matrix;
+        private static _TMP_MATRIX;
+        data: number[];
+        constructor(data?: number[]);
+        identity(): Matrix;
+        /**
+         * @param x
+         * @param y
+         * @param [val]
+         */
+        cell(x: number, y: number, val?: number): number;
+        get a(): number;
+        get b(): number;
+        get c(): number;
+        get d(): number;
+        get e(): number;
+        get f(): number;
+        /**
+         * Combines <code>this</code> with another matrix <code>other</code>
+         * @param other
+         */
+        multiply(other: Matrix): Matrix;
+        /**
+         * @param x
+         * @param y
+         */
+        translate(x: number, y: number): Matrix;
+        /**
+         * @param x
+         * @param y
+         */
+        scale(x: number, y: number): Matrix;
+        /**
+         * @param a - the angle or rotation in radians
+         */
+        rotate(a: number): Matrix;
+    }
+}
+export { Transform };