babylonjs-post-process 5.0.0-beta.8 → 5.0.0-beta.8-snapshot

package/dist/babylonjs.postProcess.module.d.ts

@@ -0,0 +1,286 @@
+
+declare module "babylonjs-post-process/asciiArt/asciiart.fragment" {
+/** @hidden */
+export declare const asciiartPixelShader: {
+    name: string;
+    shader: string;
+};
+
+}
+declare module "babylonjs-post-process/asciiArt/asciiArtPostProcess" {
+import { Nullable } from "babylonjs/types";
+import { Camera } from "babylonjs/Cameras/camera";
+import { BaseTexture } from "babylonjs/Materials/Textures/baseTexture";
+import { PostProcess } from "babylonjs/PostProcesses/postProcess";
+import { Scene } from "babylonjs/scene";
+import "babylonjs/Engines/Extensions/engine.dynamicTexture";
+import "babylonjs-post-process/asciiArt/asciiart.fragment";
+/**
+ * AsciiArtFontTexture is the helper class used to easily create your ascii art font texture.
+ *
+ * It basically takes care rendering the font front the given font size to a texture.
+ * This is used later on in the postprocess.
+ */
+export declare class AsciiArtFontTexture extends BaseTexture {
+    private _font;
+    private _text;
+    private _charSize;
+    /**
+     * Gets the size of one char in the texture (each char fits in size * size space in the texture).
+     */
+    get charSize(): number;
+    /**
+     * Create a new instance of the Ascii Art FontTexture class
+     * @param name the name of the texture
+     * @param font the font to use, use the W3C CSS notation
+     * @param text the caracter set to use in the rendering.
+     * @param scene the scene that owns the texture
+     */
+    constructor(name: string, font: string, text: string, scene?: Nullable<Scene>);
+    /**
+     * Gets the max char width of a font.
+     * @param font the font to use, use the W3C CSS notation
+     * @return the max char width
+     */
+    private getFontWidth;
+    /**
+     * Gets the max char height of a font.
+     * @param font the font to use, use the W3C CSS notation
+     * @return the max char height
+     */
+    private getFontHeight;
+    /**
+     * Clones the current AsciiArtTexture.
+     * @return the clone of the texture.
+     */
+    clone(): AsciiArtFontTexture;
+    /**
+     * Parses a json object representing the texture and returns an instance of it.
+     * @param source the source JSON representation
+     * @param scene the scene to create the texture for
+     * @return the parsed texture
+     */
+    static Parse(source: any, scene: Scene): AsciiArtFontTexture;
+}
+/**
+ * Option available in the Ascii Art Post Process.
+ */
+export interface IAsciiArtPostProcessOptions {
+    /**
+     * The font to use following the w3c font definition.
+     */
+    font?: string;
+    /**
+     * The character set to use in the postprocess.
+     */
+    characterSet?: string;
+    /**
+     * This defines the amount you want to mix the "tile" or caracter space colored in the ascii art.
+     * This number is defined between 0 and 1;
+     */
+    mixToTile?: number;
+    /**
+     * This defines the amount you want to mix the normal rendering pass in the ascii art.
+     * This number is defined between 0 and 1;
+     */
+    mixToNormal?: number;
+}
+/**
+ * AsciiArtPostProcess helps rendering everithing in Ascii Art.
+ *
+ * Simmply add it to your scene and let the nerd that lives in you have fun.
+ * Example usage: var pp = new AsciiArtPostProcess("myAscii", "20px Monospace", camera);
+ */
+export declare class AsciiArtPostProcess extends PostProcess {
+    /**
+     * The font texture used to render the char in the post process.
+     */
+    private _asciiArtFontTexture;
+    /**
+     * This defines the amount you want to mix the "tile" or caracter space colored in the ascii art.
+     * This number is defined between 0 and 1;
+     */
+    mixToTile: number;
+    /**
+     * This defines the amount you want to mix the normal rendering pass in the ascii art.
+     * This number is defined between 0 and 1;
+     */
+    mixToNormal: number;
+    /**
+     * Instantiates a new Ascii Art Post Process.
+     * @param name the name to give to the postprocess
+     * @camera the camera to apply the post process to.
+     * @param options can either be the font name or an option object following the IAsciiArtPostProcessOptions format
+     */
+    constructor(name: string, camera: Camera, options?: string | IAsciiArtPostProcessOptions);
+}
+
+}
+declare module "babylonjs-post-process/asciiArt/index" {
+export * from "babylonjs-post-process/asciiArt/asciiArtPostProcess";
+
+}
+declare module "babylonjs-post-process/digitalRain/digitalrain.fragment" {
+/** @hidden */
+export declare const digitalrainPixelShader: {
+    name: string;
+    shader: string;
+};
+
+}
+declare module "babylonjs-post-process/digitalRain/digitalRainPostProcess" {
+import { Nullable } from "babylonjs/types";
+import { Camera } from "babylonjs/Cameras/camera";
+import { BaseTexture } from "babylonjs/Materials/Textures/baseTexture";
+import { PostProcess } from "babylonjs/PostProcesses/postProcess";
+import { Scene } from "babylonjs/scene";
+import "babylonjs/Engines/Extensions/engine.dynamicTexture";
+import "babylonjs-post-process/digitalRain/digitalrain.fragment";
+/**
+ * DigitalRainFontTexture is the helper class used to easily create your digital rain font texture.
+ *
+ * It basically takes care rendering the font front the given font size to a texture.
+ * This is used later on in the postprocess.
+ */
+export declare class DigitalRainFontTexture extends BaseTexture {
+    private _font;
+    private _text;
+    private _charSize;
+    /**
+     * Gets the size of one char in the texture (each char fits in size * size space in the texture).
+     */
+    get charSize(): number;
+    /**
+     * Create a new instance of the Digital Rain FontTexture class
+     * @param name the name of the texture
+     * @param font the font to use, use the W3C CSS notation
+     * @param text the caracter set to use in the rendering.
+     * @param scene the scene that owns the texture
+     */
+    constructor(name: string, font: string, text: string, scene?: Nullable<Scene>);
+    /**
+     * Gets the max char width of a font.
+     * @param font the font to use, use the W3C CSS notation
+     * @return the max char width
+     */
+    private getFontWidth;
+    /**
+     * Gets the max char height of a font.
+     * @param font the font to use, use the W3C CSS notation
+     * @return the max char height
+     */
+    private getFontHeight;
+    /**
+     * Clones the current DigitalRainFontTexture.
+     * @return the clone of the texture.
+     */
+    clone(): DigitalRainFontTexture;
+    /**
+     * Parses a json object representing the texture and returns an instance of it.
+     * @param source the source JSON representation
+     * @param scene the scene to create the texture for
+     * @return the parsed texture
+     */
+    static Parse(source: any, scene: Scene): DigitalRainFontTexture;
+}
+/**
+ * Option available in the Digital Rain Post Process.
+ */
+export interface IDigitalRainPostProcessOptions {
+    /**
+     * The font to use following the w3c font definition.
+     */
+    font?: string;
+    /**
+     * This defines the amount you want to mix the "tile" or caracter space colored in the digital rain.
+     * This number is defined between 0 and 1;
+     */
+    mixToTile?: number;
+    /**
+     * This defines the amount you want to mix the normal rendering pass in the digital rain.
+     * This number is defined between 0 and 1;
+     */
+    mixToNormal?: number;
+}
+/**
+ * DigitalRainPostProcess helps rendering everithing in digital rain.
+ *
+ * Simmply add it to your scene and let the nerd that lives in you have fun.
+ * Example usage: var pp = new DigitalRainPostProcess("digitalRain", "20px Monospace", camera);
+ */
+export declare class DigitalRainPostProcess extends PostProcess {
+    /**
+     * The font texture used to render the char in the post process.
+     */
+    private _digitalRainFontTexture;
+    /**
+     * This defines the amount you want to mix the "tile" or caracter space colored in the digital rain.
+     * This number is defined between 0 and 1;
+     */
+    mixToTile: number;
+    /**
+     * This defines the amount you want to mix the normal rendering pass in the digital rain.
+     * This number is defined between 0 and 1;
+     */
+    mixToNormal: number;
+    /**
+     * Speed of the effect
+     */
+    speed: number;
+    /**
+     * Instantiates a new Digital Rain Post Process.
+     * @param name the name to give to the postprocess
+     * @camera the camera to apply the post process to.
+     * @param options can either be the font name or an option object following the IDigitalRainPostProcessOptions format
+     */
+    constructor(name: string, camera: Camera, options?: string | IDigitalRainPostProcessOptions);
+}
+
+}
+declare module "babylonjs-post-process/digitalRain/index" {
+export * from "babylonjs-post-process/digitalRain/digitalRainPostProcess";
+
+}
+declare module "babylonjs-post-process/index" {
+export * from "babylonjs-post-process/asciiArt/index";
+export * from "babylonjs-post-process/digitalRain/index";
+
+}
+declare module "babylonjs-post-process/legacy/legacy-asciiArt" {
+export * from "babylonjs-post-process/asciiArt/index";
+
+}
+declare module "babylonjs-post-process/legacy/legacy-digitalRain" {
+export * from "babylonjs-post-process/digitalRain/index";
+
+}
+declare module "babylonjs-post-process/legacy/legacy" {
+export * from "babylonjs-post-process/index";
+
+}
+
+declare module "babylonjs-post-process" {
+    export * from "babylonjs-post-process/legacy/legacy";
+}
+
+declare module BABYLON {
+        /** @hidden */
    export const asciiartPixelShader: {
        name: string;
        shader: string;
    };
+
+    /**
     * AsciiArtFontTexture is the helper class used to easily create your ascii art font texture.
     *
     * It basically takes care rendering the font front the given font size to a texture.
     * This is used later on in the postprocess.
     */
    export class AsciiArtFontTexture extends BABYLON.BaseTexture {
        private _font;
        private _text;
        private _charSize;
        /**
         * Gets the size of one char in the texture (each char fits in size * size space in the texture).
         */
        get charSize(): number;
        /**
         * Create a new instance of the Ascii Art FontTexture class
         * @param name the name of the texture
         * @param font the font to use, use the W3C CSS notation
         * @param text the caracter set to use in the rendering.
         * @param scene the scene that owns the texture
         */
        constructor(name: string, font: string, text: string, scene?: BABYLON.Nullable<BABYLON.Scene>);
        /**
         * Gets the max char width of a font.
         * @param font the font to use, use the W3C CSS notation
         * @return the max char width
         */
        private getFontWidth;
        /**
         * Gets the max char height of a font.
         * @param font the font to use, use the W3C CSS notation
         * @return the max char height
         */
        private getFontHeight;
        /**
         * Clones the current AsciiArtTexture.
         * @return the clone of the texture.
         */
        clone(): AsciiArtFontTexture;
        /**
         * Parses a json object representing the texture and returns an instance of it.
         * @param source the source JSON representation
         * @param scene the scene to create the texture for
         * @return the parsed texture
         */
        static Parse(source: any, scene: BABYLON.Scene): AsciiArtFontTexture;
    }
    /**
     * Option available in the Ascii Art Post Process.
     */
    export interface IAsciiArtPostProcessOptions {
        /**
         * The font to use following the w3c font definition.
         */
        font?: string;
        /**
         * The character set to use in the postprocess.
         */
        characterSet?: string;
        /**
         * This defines the amount you want to mix the "tile" or caracter space colored in the ascii art.
         * This number is defined between 0 and 1;
         */
        mixToTile?: number;
        /**
         * This defines the amount you want to mix the normal rendering pass in the ascii art.
         * This number is defined between 0 and 1;
         */
        mixToNormal?: number;
    }
    /**
     * AsciiArtPostProcess helps rendering everithing in Ascii Art.
     *
     * Simmply add it to your scene and let the nerd that lives in you have fun.
     * Example usage: var pp = new AsciiArtPostProcess("myAscii", "20px Monospace", camera);
     */
    export class AsciiArtPostProcess extends BABYLON.PostProcess {
        /**
         * The font texture used to render the char in the post process.
         */
        private _asciiArtFontTexture;
        /**
         * This defines the amount you want to mix the "tile" or caracter space colored in the ascii art.
         * This number is defined between 0 and 1;
         */
        mixToTile: number;
        /**
         * This defines the amount you want to mix the normal rendering pass in the ascii art.
         * This number is defined between 0 and 1;
         */
        mixToNormal: number;
        /**
         * Instantiates a new Ascii Art Post Process.
         * @param name the name to give to the postprocess
         * @camera the camera to apply the post process to.
         * @param options can either be the font name or an option object following the IAsciiArtPostProcessOptions format
         */
        constructor(name: string, camera: BABYLON.Camera, options?: string | IAsciiArtPostProcessOptions);
    }
+
+
+
+    /** @hidden */
    export const digitalrainPixelShader: {
        name: string;
        shader: string;
    };
+
+    /**
     * DigitalRainFontTexture is the helper class used to easily create your digital rain font texture.
     *
     * It basically takes care rendering the font front the given font size to a texture.
     * This is used later on in the postprocess.
     */
    export class DigitalRainFontTexture extends BABYLON.BaseTexture {
        private _font;
        private _text;
        private _charSize;
        /**
         * Gets the size of one char in the texture (each char fits in size * size space in the texture).
         */
        get charSize(): number;
        /**
         * Create a new instance of the Digital Rain FontTexture class
         * @param name the name of the texture
         * @param font the font to use, use the W3C CSS notation
         * @param text the caracter set to use in the rendering.
         * @param scene the scene that owns the texture
         */
        constructor(name: string, font: string, text: string, scene?: BABYLON.Nullable<BABYLON.Scene>);
        /**
         * Gets the max char width of a font.
         * @param font the font to use, use the W3C CSS notation
         * @return the max char width
         */
        private getFontWidth;
        /**
         * Gets the max char height of a font.
         * @param font the font to use, use the W3C CSS notation
         * @return the max char height
         */
        private getFontHeight;
        /**
         * Clones the current DigitalRainFontTexture.
         * @return the clone of the texture.
         */
        clone(): DigitalRainFontTexture;
        /**
         * Parses a json object representing the texture and returns an instance of it.
         * @param source the source JSON representation
         * @param scene the scene to create the texture for
         * @return the parsed texture
         */
        static Parse(source: any, scene: BABYLON.Scene): DigitalRainFontTexture;
    }
    /**
     * Option available in the Digital Rain Post Process.
     */
    export interface IDigitalRainPostProcessOptions {
        /**
         * The font to use following the w3c font definition.
         */
        font?: string;
        /**
         * This defines the amount you want to mix the "tile" or caracter space colored in the digital rain.
         * This number is defined between 0 and 1;
         */
        mixToTile?: number;
        /**
         * This defines the amount you want to mix the normal rendering pass in the digital rain.
         * This number is defined between 0 and 1;
         */
        mixToNormal?: number;
    }
    /**
     * DigitalRainPostProcess helps rendering everithing in digital rain.
     *
     * Simmply add it to your scene and let the nerd that lives in you have fun.
     * Example usage: var pp = new DigitalRainPostProcess("digitalRain", "20px Monospace", camera);
     */
    export class DigitalRainPostProcess extends BABYLON.PostProcess {
        /**
         * The font texture used to render the char in the post process.
         */
        private _digitalRainFontTexture;
        /**
         * This defines the amount you want to mix the "tile" or caracter space colored in the digital rain.
         * This number is defined between 0 and 1;
         */
        mixToTile: number;
        /**
         * This defines the amount you want to mix the normal rendering pass in the digital rain.
         * This number is defined between 0 and 1;
         */
        mixToNormal: number;
        /**
         * Speed of the effect
         */
        speed: number;
        /**
         * Instantiates a new Digital Rain Post Process.
         * @param name the name to give to the postprocess
         * @camera the camera to apply the post process to.
         * @param options can either be the font name or an option object following the IDigitalRainPostProcessOptions format
         */
        constructor(name: string, camera: BABYLON.Camera, options?: string | IDigitalRainPostProcessOptions);
    }
+
+
+
+
+
+
+
+
+
+
+}

package/package.json

@@ -1,36 +1,31 @@
 {
-    "author": {
-        "name": "David CATUHE"
-    },
     "name": "babylonjs-post-process",
-    "description": "The Babylon.js materials library is a collection of advanced materials to be used in a Babylon.js scene.",
-    "version": "5.0.0-beta.8",
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/BabylonJS/Babylon.js.git"
-    },
-    "main": "babylonjs.postProcess.min.js",
+    "version": "5.0.0-beta.8-snapshot",
+    "main": "dist/babylonjs.postProcess.min.js",
+    "types": "dist/babylonjs.postProcess.module.d.ts",
     "files": [
-        "babylonjs.postProcess.js",
-        "babylonjs.postProcess.js.map",
-        "babylonjs.postProcess.min.js",
-        "babylonjs.postProcess.module.d.ts",
-        "readme.md",
-        "package.json"
-    ],
-    "typings": "babylonjs.postProcess.module.d.ts",
-    "keywords": [
-        "3D",
-        "javascript",
-        "html5",
-        "webgl",
-        "post process"
+        "dist"
     ],
-    "license": "Apache-2.0",
+    "scripts": {
+        "build": "npm run clean && npm run build:dev && npm run build:prod && npm run build:declaration",
+        "build:dev": "webpack --env development",
+        "build:prod": "webpack --env production",
+        "build:declaration": "build-tools -c pud --config ./config.json",
+        "clean": "rimraf dist"
+    },
     "dependencies": {
-        "babylonjs": "5.0.0-beta.8"
+        "babylonjs": "^5.0.0-beta.8-snapshot"
+    },
+    "devDependencies": {
+        "@dev/build-tools": "^5.0.0-beta.8-snapshot",
+        "@lts/post-processes": "^5.0.0-beta.8-snapshot",
+        "rimraf": "^3.0.2",
+        "source-map-loader": "^3.0.0",
+        "ts-loader": "^9.2.6",
+        "typescript": "^4.4.4",
+        "webpack": "^5.59.1",
+        "webpack-cli": "^4.9.1",
+        "webpack-merge": "^5.8.0"
     },
-    "engines": {
-        "node": "*"
-    }
-}
+    "sideEffects": true
+}