@babylonjs/procedural-textures 5.0.0-beta.9 → 5.0.0-rc.10

package/normalMap/normalMapProceduralTexture.d.ts

@@ -1,28 +1,28 @@
-import { Texture } from "@babylonjs/core/Materials/Textures/texture";
-import { ProceduralTexture } from "@babylonjs/core/Materials/Textures/Procedurals/proceduralTexture";
-import { Scene } from "@babylonjs/core/scene";
-import { Nullable } from "@babylonjs/core/types";
-import "./normalMapProceduralTexture.fragment";
-export declare class NormalMapProceduralTexture extends ProceduralTexture {
-    private _baseTexture;
-    constructor(name: string, size: number, scene?: Nullable<Scene>, fallbackTexture?: Texture, generateMipMaps?: boolean);
-    updateShaderUniforms(): void;
-    render(useCameraPostProcess?: boolean): void;
-    resize(size: any, generateMipMaps: any): void;
-    isReady(): boolean;
-    get baseTexture(): Texture;
-    set baseTexture(texture: Texture);
-    /**
-     * Serializes this normal map procedural texture
-     * @returns a serialized normal map procedural texture object
-     */
-    serialize(): any;
-    /**
-     * Creates a Normal Map Procedural Texture from parsed normal map procedural texture data
-     * @param parsedTexture defines parsed texture data
-     * @param scene defines the current scene
-     * @param rootUrl defines the root URL containing normal map procedural texture information
-     * @returns a parsed Normal Map Procedural Texture
-     */
-    static Parse(parsedTexture: any, scene: Scene, rootUrl: string): NormalMapProceduralTexture;
-}
+import type { Texture } from "@babylonjs/core/Materials/Textures/texture.js";
+import { ProceduralTexture } from "@babylonjs/core/Materials/Textures/Procedurals/proceduralTexture.js";
+import type { Scene } from "@babylonjs/core/scene.js";
+import type { Nullable } from "@babylonjs/core/types.js";
+import "./normalMapProceduralTexture.fragment";
+export declare class NormalMapProceduralTexture extends ProceduralTexture {
+    private _baseTexture;
+    constructor(name: string, size: number, scene?: Nullable<Scene>, fallbackTexture?: Texture, generateMipMaps?: boolean);
+    updateShaderUniforms(): void;
+    render(useCameraPostProcess?: boolean): void;
+    resize(size: any, generateMipMaps: any): void;
+    isReady(): boolean;
+    get baseTexture(): Texture;
+    set baseTexture(texture: Texture);
+    /**
+     * Serializes this normal map procedural texture
+     * @returns a serialized normal map procedural texture object
+     */
+    serialize(): any;
+    /**
+     * Creates a Normal Map Procedural Texture from parsed normal map procedural texture data
+     * @param parsedTexture defines parsed texture data
+     * @param scene defines the current scene
+     * @param rootUrl defines the root URL containing normal map procedural texture information
+     * @returns a parsed Normal Map Procedural Texture
+     */
+    static Parse(parsedTexture: any, scene: Scene, rootUrl: string): NormalMapProceduralTexture;
+}

package/normalMap/normalMapProceduralTexture.fragment.d.ts

@@ -1,5 +1,5 @@
-/** @hidden */
-export declare var normalMapProceduralTexturePixelShader: {
-    name: string;
-    shader: string;
-};
+/** @hidden */
+export declare const normalMapProceduralTexturePixelShader: {
+    name: string;
+    shader: string;
+};

package/normalMap/normalMapProceduralTexture.fragment.js

@@ -1,7 +1,9 @@
-import { ShaderStore } from "@babylonjs/core/Engines/shaderStore.js";
-var name = 'normalMapProceduralTexturePixelShader';
-var shader = "precision highp float;\n\nuniform sampler2D baseSampler;\nuniform float size;\n\nvarying vec2 vUV;\n\nconst vec3 LUMA_COEFFICIENT=vec3(0.2126,0.7152,0.0722);\nfloat lumaAtCoord(vec2 coord)\n{\nvec3 pixel=texture2D(baseSampler,coord).rgb;\nfloat luma=dot(pixel,LUMA_COEFFICIENT);\nreturn luma;\n}\nvoid main()\n{\nfloat lumaU0=lumaAtCoord(vUV+vec2(-1.0,0.0)/size);\nfloat lumaU1=lumaAtCoord(vUV+vec2( 1.0,0.0)/size);\nfloat lumaV0=lumaAtCoord(vUV+vec2( 0.0,-1.0)/size);\nfloat lumaV1=lumaAtCoord(vUV+vec2( 0.0,1.0)/size);\nvec2 slope=(vec2(lumaU0-lumaU1,lumaV0-lumaV1)+1.0)*0.5;\ngl_FragColor=vec4(slope,1.0,1.0);\n}\n";
-ShaderStore.ShadersStore[name] = shader;
-/** @hidden */
-export var normalMapProceduralTexturePixelShader = { name: name, shader: shader };
+// Do not edit.
+import { ShaderStore } from "@babylonjs/core/Engines/shaderStore.js";
+var name = "normalMapProceduralTexturePixelShader";
+var shader = "precision highp float;uniform sampler2D baseSampler;uniform float size;varying vec2 vUV;const vec3 LUMA_COEFFICIENT=vec3(0.2126,0.7152,0.0722);float lumaAtCoord(vec2 coord)\n{vec3 pixel=texture2D(baseSampler,coord).rgb;float luma=dot(pixel,LUMA_COEFFICIENT);return luma;}\nvoid main()\n{float lumaU0=lumaAtCoord(vUV+vec2(-1.0, 0.0)/size);float lumaU1=lumaAtCoord(vUV+vec2( 1.0, 0.0)/size);float lumaV0=lumaAtCoord(vUV+vec2( 0.0,-1.0)/size);float lumaV1=lumaAtCoord(vUV+vec2( 0.0, 1.0)/size);vec2 slope=(vec2(lumaU0-lumaU1,lumaV0-lumaV1)+1.0)*0.5;gl_FragColor=vec4(slope,1.0,1.0);}\n";
+// Sideeffect
+ShaderStore.ShadersStore[name] = shader;
+/** @hidden */
+export var normalMapProceduralTexturePixelShader = { name: name, shader: shader };
 //# sourceMappingURL=normalMapProceduralTexture.fragment.js.map

package/normalMap/normalMapProceduralTexture.fragment.js.map

@@ -1 +1 @@
-{"version":3,"file":"normalMapProceduralTexture.fragment.js","sourceRoot":"","sources":["../../../sourceES6/proceduralTexturesLibrary/src/normalMap/normalMapProceduralTexture.fragment.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,qCAAqC,CAAC;AAElE,IAAI,IAAI,GAAG,uCAAuC,CAAC;AACnD,IAAI,MAAM,GAAG,2mBAuBZ,CAAC;AAEF,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,cAAc;AACd,MAAM,CAAC,IAAI,qCAAqC,GAAG,EAAE,IAAI,MAAA,EAAE,MAAM,QAAA,EAAE,CAAC","sourcesContent":["import { ShaderStore } from \"@babylonjs/core/Engines/shaderStore\";\n\nlet name = 'normalMapProceduralTexturePixelShader';\nlet shader = `precision highp float;\n\nuniform sampler2D baseSampler;\nuniform float size;\n\nvarying vec2 vUV;\n\nconst vec3 LUMA_COEFFICIENT=vec3(0.2126,0.7152,0.0722);\nfloat lumaAtCoord(vec2 coord)\n{\nvec3 pixel=texture2D(baseSampler,coord).rgb;\nfloat luma=dot(pixel,LUMA_COEFFICIENT);\nreturn luma;\n}\nvoid main()\n{\nfloat lumaU0=lumaAtCoord(vUV+vec2(-1.0,0.0)/size);\nfloat lumaU1=lumaAtCoord(vUV+vec2( 1.0,0.0)/size);\nfloat lumaV0=lumaAtCoord(vUV+vec2( 0.0,-1.0)/size);\nfloat lumaV1=lumaAtCoord(vUV+vec2( 0.0,1.0)/size);\nvec2 slope=(vec2(lumaU0-lumaU1,lumaV0-lumaV1)+1.0)*0.5;\ngl_FragColor=vec4(slope,1.0,1.0);\n}\n`;\n\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport var normalMapProceduralTexturePixelShader = { name, shader };\n"]}
+{"version":3,"file":"normalMapProceduralTexture.fragment.js","sourceRoot":"","sources":["../../../../../lts/proceduralTextures/generated/normalMap/normalMapProceduralTexture.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,+CAAiC;AAEvD,IAAM,IAAI,GAAG,uCAAuC,CAAC;AACrD,IAAM,MAAM,GAAG,wkBAId,CAAC;AACF,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,cAAc;AACd,MAAM,CAAC,IAAM,qCAAqC,GAAG,EAAE,IAAI,MAAA,EAAE,MAAM,QAAA,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"core/Engines/shaderStore\";\n\nconst name = \"normalMapProceduralTexturePixelShader\";\nconst shader = `precision highp float;uniform sampler2D baseSampler;uniform float size;varying vec2 vUV;const vec3 LUMA_COEFFICIENT=vec3(0.2126,0.7152,0.0722);float lumaAtCoord(vec2 coord)\n{vec3 pixel=texture2D(baseSampler,coord).rgb;float luma=dot(pixel,LUMA_COEFFICIENT);return luma;}\nvoid main()\n{float lumaU0=lumaAtCoord(vUV+vec2(-1.0, 0.0)/size);float lumaU1=lumaAtCoord(vUV+vec2( 1.0, 0.0)/size);float lumaV0=lumaAtCoord(vUV+vec2( 0.0,-1.0)/size);float lumaV1=lumaAtCoord(vUV+vec2( 0.0, 1.0)/size);vec2 slope=(vec2(lumaU0-lumaU1,lumaV0-lumaV1)+1.0)*0.5;gl_FragColor=vec4(slope,1.0,1.0);}\n`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport const normalMapProceduralTexturePixelShader = { name, shader };\n"]}

package/normalMap/normalMapProceduralTexture.js

@@ -1,70 +1,70 @@
-import { __decorate, __extends } from "tslib";
-import { serializeAsTexture, SerializationHelper } from "@babylonjs/core/Misc/decorators.js";
-import { ProceduralTexture } from "@babylonjs/core/Materials/Textures/Procedurals/proceduralTexture.js";
-import { RegisterClass } from '@babylonjs/core/Misc/typeStore.js';
-import "./normalMapProceduralTexture.fragment.js";
-var NormalMapProceduralTexture = /** @class */ (function (_super) {
-    __extends(NormalMapProceduralTexture, _super);
-    function NormalMapProceduralTexture(name, size, scene, fallbackTexture, generateMipMaps) {
-        if (scene === void 0) { scene = null; }
-        var _this = _super.call(this, name, size, "normalMapProceduralTexture", scene, fallbackTexture, generateMipMaps) || this;
-        _this.updateShaderUniforms();
-        return _this;
-    }
-    NormalMapProceduralTexture.prototype.updateShaderUniforms = function () {
-        this.setTexture("baseSampler", this._baseTexture);
-        this.setFloat("size", this.getRenderSize());
-    };
-    NormalMapProceduralTexture.prototype.render = function (useCameraPostProcess) {
-        _super.prototype.render.call(this, useCameraPostProcess);
-    };
-    NormalMapProceduralTexture.prototype.resize = function (size, generateMipMaps) {
-        _super.prototype.resize.call(this, size, generateMipMaps);
-        // We need to update the "size" uniform
-        this.updateShaderUniforms();
-    };
-    NormalMapProceduralTexture.prototype.isReady = function () {
-        if (!this._baseTexture || !this._baseTexture.isReady()) {
-            return false;
-        }
-        return _super.prototype.isReady.call(this);
-    };
-    Object.defineProperty(NormalMapProceduralTexture.prototype, "baseTexture", {
-        get: function () {
-            return this._baseTexture;
-        },
-        set: function (texture) {
-            this._baseTexture = texture;
-            this.updateShaderUniforms();
-        },
-        enumerable: false,
-        configurable: true
-    });
-    /**
-     * Serializes this normal map procedural texture
-     * @returns a serialized normal map procedural texture object
-     */
-    NormalMapProceduralTexture.prototype.serialize = function () {
-        var serializationObject = SerializationHelper.Serialize(this, _super.prototype.serialize.call(this));
-        serializationObject.customType = "BABYLON.NormalMapProceduralTexture";
-        return serializationObject;
-    };
-    /**
-     * Creates a Normal Map Procedural Texture from parsed normal map procedural texture data
-     * @param parsedTexture defines parsed texture data
-     * @param scene defines the current scene
-     * @param rootUrl defines the root URL containing normal map procedural texture information
-     * @returns a parsed Normal Map Procedural Texture
-     */
-    NormalMapProceduralTexture.Parse = function (parsedTexture, scene, rootUrl) {
-        var texture = SerializationHelper.Parse(function () { return new NormalMapProceduralTexture(parsedTexture.name, parsedTexture._size, scene, undefined, parsedTexture._generateMipMaps); }, parsedTexture, scene, rootUrl);
-        return texture;
-    };
-    __decorate([
-        serializeAsTexture()
-    ], NormalMapProceduralTexture.prototype, "baseTexture", null);
-    return NormalMapProceduralTexture;
-}(ProceduralTexture));
-export { NormalMapProceduralTexture };
-RegisterClass("BABYLON.NormalMapProceduralTexture", NormalMapProceduralTexture);
+import { __decorate, __extends } from "tslib";
+import { serializeAsTexture, SerializationHelper } from "@babylonjs/core/Misc/decorators.js";
+import { ProceduralTexture } from "@babylonjs/core/Materials/Textures/Procedurals/proceduralTexture.js";
+import { RegisterClass } from "@babylonjs/core/Misc/typeStore.js";
+import "./normalMapProceduralTexture.fragment";
+var NormalMapProceduralTexture = /** @class */ (function (_super) {
+    __extends(NormalMapProceduralTexture, _super);
+    function NormalMapProceduralTexture(name, size, scene, fallbackTexture, generateMipMaps) {
+        if (scene === void 0) { scene = null; }
+        var _this = _super.call(this, name, size, "normalMapProceduralTexture", scene, fallbackTexture, generateMipMaps) || this;
+        _this.updateShaderUniforms();
+        return _this;
+    }
+    NormalMapProceduralTexture.prototype.updateShaderUniforms = function () {
+        this.setTexture("baseSampler", this._baseTexture);
+        this.setFloat("size", this.getRenderSize());
+    };
+    NormalMapProceduralTexture.prototype.render = function (useCameraPostProcess) {
+        _super.prototype.render.call(this, useCameraPostProcess);
+    };
+    NormalMapProceduralTexture.prototype.resize = function (size, generateMipMaps) {
+        _super.prototype.resize.call(this, size, generateMipMaps);
+        // We need to update the "size" uniform
+        this.updateShaderUniforms();
+    };
+    NormalMapProceduralTexture.prototype.isReady = function () {
+        if (!this._baseTexture || !this._baseTexture.isReady()) {
+            return false;
+        }
+        return _super.prototype.isReady.call(this);
+    };
+    Object.defineProperty(NormalMapProceduralTexture.prototype, "baseTexture", {
+        get: function () {
+            return this._baseTexture;
+        },
+        set: function (texture) {
+            this._baseTexture = texture;
+            this.updateShaderUniforms();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Serializes this normal map procedural texture
+     * @returns a serialized normal map procedural texture object
+     */
+    NormalMapProceduralTexture.prototype.serialize = function () {
+        var serializationObject = SerializationHelper.Serialize(this, _super.prototype.serialize.call(this));
+        serializationObject.customType = "BABYLON.NormalMapProceduralTexture";
+        return serializationObject;
+    };
+    /**
+     * Creates a Normal Map Procedural Texture from parsed normal map procedural texture data
+     * @param parsedTexture defines parsed texture data
+     * @param scene defines the current scene
+     * @param rootUrl defines the root URL containing normal map procedural texture information
+     * @returns a parsed Normal Map Procedural Texture
+     */
+    NormalMapProceduralTexture.Parse = function (parsedTexture, scene, rootUrl) {
+        var texture = SerializationHelper.Parse(function () { return new NormalMapProceduralTexture(parsedTexture.name, parsedTexture._size, scene, undefined, parsedTexture._generateMipMaps); }, parsedTexture, scene, rootUrl);
+        return texture;
+    };
+    __decorate([
+        serializeAsTexture()
+    ], NormalMapProceduralTexture.prototype, "baseTexture", null);
+    return NormalMapProceduralTexture;
+}(ProceduralTexture));
+export { NormalMapProceduralTexture };
+RegisterClass("BABYLON.NormalMapProceduralTexture", NormalMapProceduralTexture);
 //# sourceMappingURL=normalMapProceduralTexture.js.map

package/normalMap/normalMapProceduralTexture.js.map

@@ -1 +1 @@
-{"version":3,"file":"normalMapProceduralTexture.js","sourceRoot":"","sources":["../../../sourceES6/proceduralTexturesLibrary/src/normalMap/normalMapProceduralTexture.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AAE1F,OAAO,EAAE,iBAAiB,EAAE,MAAM,kEAAkE,CAAC;AAErG,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAE/D,OAAO,uCAAuC,CAAC;AAE/C;IAAgD,8CAAiB;IAG7D,oCAAY,IAAY,EAAE,IAAY,EAAE,KAA6B,EAAE,eAAyB,EAAE,eAAyB;QAAnF,sBAAA,EAAA,YAA6B;QAArE,YACI,kBAAM,IAAI,EAAE,IAAI,EAAE,4BAA4B,EAAE,KAAK,EAAE,eAAe,EAAE,eAAe,CAAC,SAE3F;QADG,KAAI,CAAC,oBAAoB,EAAE,CAAC;;IAChC,CAAC;IAEM,yDAAoB,GAA3B;QACI,IAAI,CAAC,UAAU,CAAC,aAAa,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC;QAClD,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC,aAAa,EAAY,CAAC,CAAC;IAC1D,CAAC;IAEM,2CAAM,GAAb,UAAc,oBAA8B;QACxC,iBAAM,MAAM,YAAC,oBAAoB,CAAC,CAAC;IACvC,CAAC;IAEM,2CAAM,GAAb,UAAc,IAAS,EAAE,eAAoB;QACzC,iBAAM,MAAM,YAAC,IAAI,EAAE,eAAe,CAAC,CAAC;QAEpC,uCAAuC;QACvC,IAAI,CAAC,oBAAoB,EAAE,CAAC;IAChC,CAAC;IAEM,4CAAO,GAAd;QACI,IAAI,CAAC,IAAI,CAAC,YAAY,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,EAAE;YACpD,OAAO,KAAK,CAAC;SAChB;QAED,OAAO,iBAAM,OAAO,WAAE,CAAC;IAC3B,CAAC;IAGD,sBAAW,mDAAW;aAAtB;YACI,OAAO,IAAI,CAAC,YAAY,CAAC;QAC7B,CAAC;aAED,UAAuB,OAAgB;YACnC,IAAI,CAAC,YAAY,GAAG,OAAO,CAAC;YAC5B,IAAI,CAAC,oBAAoB,EAAE,CAAC;QAChC,CAAC;;;OALA;IAOD;;;OAGG;IACI,8CAAS,GAAhB;QACI,IAAI,mBAAmB,GAAG,mBAAmB,CAAC,SAAS,CAAC,IAAI,EAAE,iBAAM,SAAS,WAAE,CAAC,CAAC;QACjF,mBAAmB,CAAC,UAAU,GAAG,oCAAoC,CAAC;QAEtE,OAAO,mBAAmB,CAAC;IAC/B,CAAC;IAED;;;;;;OAMG;IACW,gCAAK,GAAnB,UAAoB,aAAkB,EAAE,KAAY,EAAE,OAAe;QACjE,IAAI,OAAO,GAAG,mBAAmB,CAAC,KAAK,CAAC,cAAM,OAAA,IAAI,0BAA0B,CAAC,aAAa,CAAC,IAAI,EAAE,aAAa,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,aAAa,CAAC,gBAAgB,CAAC,EAAzH,CAAyH,EAAE,aAAa,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;QAExM,OAAO,OAAO,CAAC;IACnB,CAAC;IA/BD;QADC,kBAAkB,EAAE;iEAGpB;IA8BL,iCAAC;CAAA,AAjED,CAAgD,iBAAiB,GAiEhE;SAjEY,0BAA0B;AAmEvC,aAAa,CAAC,oCAAoC,EAAE,0BAA0B,CAAC,CAAC","sourcesContent":["import { serializeAsTexture, SerializationHelper } from \"@babylonjs/core/Misc/decorators\";\nimport { Texture } from \"@babylonjs/core/Materials/Textures/texture\";\nimport { ProceduralTexture } from \"@babylonjs/core/Materials/Textures/Procedurals/proceduralTexture\";\nimport { Scene } from \"@babylonjs/core/scene\";\nimport { RegisterClass } from '@babylonjs/core/Misc/typeStore';\nimport { Nullable } from \"@babylonjs/core/types\";\nimport \"./normalMapProceduralTexture.fragment\";\n\nexport class NormalMapProceduralTexture extends ProceduralTexture {\n    private _baseTexture: Texture;\n\n    constructor(name: string, size: number, scene: Nullable<Scene> = null, fallbackTexture?: Texture, generateMipMaps?: boolean) {\n        super(name, size, \"normalMapProceduralTexture\", scene, fallbackTexture, generateMipMaps);\n        this.updateShaderUniforms();\n    }\n\n    public updateShaderUniforms() {\n        this.setTexture(\"baseSampler\", this._baseTexture);\n        this.setFloat(\"size\", this.getRenderSize() as number);\n    }\n\n    public render(useCameraPostProcess?: boolean) {\n        super.render(useCameraPostProcess);\n    }\n\n    public resize(size: any, generateMipMaps: any): void {\n        super.resize(size, generateMipMaps);\n\n        // We need to update the \"size\" uniform\n        this.updateShaderUniforms();\n    }\n\n    public isReady(): boolean {\n        if (!this._baseTexture || !this._baseTexture.isReady()) {\n            return false;\n        }\n\n        return super.isReady();\n    }\n\n    @serializeAsTexture()\n    public get baseTexture(): Texture {\n        return this._baseTexture;\n    }\n\n    public set baseTexture(texture: Texture) {\n        this._baseTexture = texture;\n        this.updateShaderUniforms();\n    }\n\n    /**\n     * Serializes this normal map procedural texture\n     * @returns a serialized normal map procedural texture object\n     */\n    public serialize(): any {\n        var serializationObject = SerializationHelper.Serialize(this, super.serialize());\n        serializationObject.customType = \"BABYLON.NormalMapProceduralTexture\";\n\n        return serializationObject;\n    }\n\n    /**\n     * Creates a Normal Map Procedural Texture from parsed normal map procedural texture data\n     * @param parsedTexture defines parsed texture data\n     * @param scene defines the current scene\n     * @param rootUrl defines the root URL containing normal map procedural texture information\n     * @returns a parsed Normal Map Procedural Texture\n     */\n    public static Parse(parsedTexture: any, scene: Scene, rootUrl: string): NormalMapProceduralTexture {\n        var texture = SerializationHelper.Parse(() => new NormalMapProceduralTexture(parsedTexture.name, parsedTexture._size, scene, undefined, parsedTexture._generateMipMaps), parsedTexture, scene, rootUrl);\n\n        return texture;\n    }\n}\n\nRegisterClass(\"BABYLON.NormalMapProceduralTexture\", NormalMapProceduralTexture);"]}
+{"version":3,"file":"normalMapProceduralTexture.js","sourceRoot":"","sources":["../../../../../lts/proceduralTextures/generated/normalMap/normalMapProceduralTexture.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,2CAA6B;AAE/E,OAAO,EAAE,iBAAiB,EAAE,4EAA8D;AAE1F,OAAO,EAAE,aAAa,EAAE,0CAA4B;AAEpD,OAAO,uCAAuC,CAAC;AAE/C;IAAgD,8CAAiB;IAG7D,oCAAY,IAAY,EAAE,IAAY,EAAE,KAA6B,EAAE,eAAyB,EAAE,eAAyB;QAAnF,sBAAA,EAAA,YAA6B;QAArE,YACI,kBAAM,IAAI,EAAE,IAAI,EAAE,4BAA4B,EAAE,KAAK,EAAE,eAAe,EAAE,eAAe,CAAC,SAE3F;QADG,KAAI,CAAC,oBAAoB,EAAE,CAAC;;IAChC,CAAC;IAEM,yDAAoB,GAA3B;QACI,IAAI,CAAC,UAAU,CAAC,aAAa,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC;QAClD,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC,aAAa,EAAY,CAAC,CAAC;IAC1D,CAAC;IAEM,2CAAM,GAAb,UAAc,oBAA8B;QACxC,iBAAM,MAAM,YAAC,oBAAoB,CAAC,CAAC;IACvC,CAAC;IAEM,2CAAM,GAAb,UAAc,IAAS,EAAE,eAAoB;QACzC,iBAAM,MAAM,YAAC,IAAI,EAAE,eAAe,CAAC,CAAC;QAEpC,uCAAuC;QACvC,IAAI,CAAC,oBAAoB,EAAE,CAAC;IAChC,CAAC;IAEM,4CAAO,GAAd;QACI,IAAI,CAAC,IAAI,CAAC,YAAY,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,EAAE;YACpD,OAAO,KAAK,CAAC;SAChB;QAED,OAAO,iBAAM,OAAO,WAAE,CAAC;IAC3B,CAAC;IAGD,sBAAW,mDAAW;aAAtB;YACI,OAAO,IAAI,CAAC,YAAY,CAAC;QAC7B,CAAC;aAED,UAAuB,OAAgB;YACnC,IAAI,CAAC,YAAY,GAAG,OAAO,CAAC;YAC5B,IAAI,CAAC,oBAAoB,EAAE,CAAC;QAChC,CAAC;;;OALA;IAOD;;;OAGG;IACI,8CAAS,GAAhB;QACI,IAAM,mBAAmB,GAAG,mBAAmB,CAAC,SAAS,CAAC,IAAI,EAAE,iBAAM,SAAS,WAAE,CAAC,CAAC;QACnF,mBAAmB,CAAC,UAAU,GAAG,oCAAoC,CAAC;QAEtE,OAAO,mBAAmB,CAAC;IAC/B,CAAC;IAED;;;;;;OAMG;IACW,gCAAK,GAAnB,UAAoB,aAAkB,EAAE,KAAY,EAAE,OAAe;QACjE,IAAM,OAAO,GAAG,mBAAmB,CAAC,KAAK,CACrC,cAAM,OAAA,IAAI,0BAA0B,CAAC,aAAa,CAAC,IAAI,EAAE,aAAa,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,aAAa,CAAC,gBAAgB,CAAC,EAAzH,CAAyH,EAC/H,aAAa,EACb,KAAK,EACL,OAAO,CACV,CAAC;QAEF,OAAO,OAAO,CAAC;IACnB,CAAC;IApCD;QADC,kBAAkB,EAAE;iEAGpB;IAmCL,iCAAC;CAAA,AAtED,CAAgD,iBAAiB,GAsEhE;SAtEY,0BAA0B;AAwEvC,aAAa,CAAC,oCAAoC,EAAE,0BAA0B,CAAC,CAAC","sourcesContent":["import { serializeAsTexture, SerializationHelper } from \"core/Misc/decorators\";\r\nimport type { Texture } from \"core/Materials/Textures/texture\";\r\nimport { ProceduralTexture } from \"core/Materials/Textures/Procedurals/proceduralTexture\";\r\nimport type { Scene } from \"core/scene\";\r\nimport { RegisterClass } from \"core/Misc/typeStore\";\r\nimport type { Nullable } from \"core/types\";\r\nimport \"./normalMapProceduralTexture.fragment\";\r\n\r\nexport class NormalMapProceduralTexture extends ProceduralTexture {\r\n    private _baseTexture: Texture;\r\n\r\n    constructor(name: string, size: number, scene: Nullable<Scene> = null, fallbackTexture?: Texture, generateMipMaps?: boolean) {\r\n        super(name, size, \"normalMapProceduralTexture\", scene, fallbackTexture, generateMipMaps);\r\n        this.updateShaderUniforms();\r\n    }\r\n\r\n    public updateShaderUniforms() {\r\n        this.setTexture(\"baseSampler\", this._baseTexture);\r\n        this.setFloat(\"size\", this.getRenderSize() as number);\r\n    }\r\n\r\n    public render(useCameraPostProcess?: boolean) {\r\n        super.render(useCameraPostProcess);\r\n    }\r\n\r\n    public resize(size: any, generateMipMaps: any): void {\r\n        super.resize(size, generateMipMaps);\r\n\r\n        // We need to update the \"size\" uniform\r\n        this.updateShaderUniforms();\r\n    }\r\n\r\n    public isReady(): boolean {\r\n        if (!this._baseTexture || !this._baseTexture.isReady()) {\r\n            return false;\r\n        }\r\n\r\n        return super.isReady();\r\n    }\r\n\r\n    @serializeAsTexture()\r\n    public get baseTexture(): Texture {\r\n        return this._baseTexture;\r\n    }\r\n\r\n    public set baseTexture(texture: Texture) {\r\n        this._baseTexture = texture;\r\n        this.updateShaderUniforms();\r\n    }\r\n\r\n    /**\r\n     * Serializes this normal map procedural texture\r\n     * @returns a serialized normal map procedural texture object\r\n     */\r\n    public serialize(): any {\r\n        const serializationObject = SerializationHelper.Serialize(this, super.serialize());\r\n        serializationObject.customType = \"BABYLON.NormalMapProceduralTexture\";\r\n\r\n        return serializationObject;\r\n    }\r\n\r\n    /**\r\n     * Creates a Normal Map Procedural Texture from parsed normal map procedural texture data\r\n     * @param parsedTexture defines parsed texture data\r\n     * @param scene defines the current scene\r\n     * @param rootUrl defines the root URL containing normal map procedural texture information\r\n     * @returns a parsed Normal Map Procedural Texture\r\n     */\r\n    public static Parse(parsedTexture: any, scene: Scene, rootUrl: string): NormalMapProceduralTexture {\r\n        const texture = SerializationHelper.Parse(\r\n            () => new NormalMapProceduralTexture(parsedTexture.name, parsedTexture._size, scene, undefined, parsedTexture._generateMipMaps),\r\n            parsedTexture,\r\n            scene,\r\n            rootUrl\r\n        );\r\n\r\n        return texture;\r\n    }\r\n}\r\n\r\nRegisterClass(\"BABYLON.NormalMapProceduralTexture\", NormalMapProceduralTexture);\r\n"]}

package/package.json

@@ -1,161 +1,31 @@
 {
-    "author": {
-        "name": "David CATUHE"
-    },
     "name": "@babylonjs/procedural-textures",
-    "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.9",
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/BabylonJS/Babylon.js.git"
-    },
+    "version": "5.0.0-rc.10",
     "main": "index.js",
+    "module": "index.js",
+    "types": "index.d.ts",
     "files": [
-        "brick/brickProceduralTexture.d.ts",
-        "brick/brickProceduralTexture.fragment.d.ts",
-        "brick/brickProceduralTexture.fragment.js",
-        "brick/brickProceduralTexture.fragment.js.map",
-        "brick/brickProceduralTexture.js",
-        "brick/brickProceduralTexture.js.map",
-        "brick/index.d.ts",
-        "brick/index.js",
-        "brick/index.js.map",
-        "cloud/cloudProceduralTexture.d.ts",
-        "cloud/cloudProceduralTexture.fragment.d.ts",
-        "cloud/cloudProceduralTexture.fragment.js",
-        "cloud/cloudProceduralTexture.fragment.js.map",
-        "cloud/cloudProceduralTexture.js",
-        "cloud/cloudProceduralTexture.js.map",
-        "cloud/index.d.ts",
-        "cloud/index.js",
-        "cloud/index.js.map",
-        "fire/fireProceduralTexture.d.ts",
-        "fire/fireProceduralTexture.fragment.d.ts",
-        "fire/fireProceduralTexture.fragment.js",
-        "fire/fireProceduralTexture.fragment.js.map",
-        "fire/fireProceduralTexture.js",
-        "fire/fireProceduralTexture.js.map",
-        "fire/index.d.ts",
-        "fire/index.js",
-        "fire/index.js.map",
-        "grass/grassProceduralTexture.d.ts",
-        "grass/grassProceduralTexture.fragment.d.ts",
-        "grass/grassProceduralTexture.fragment.js",
-        "grass/grassProceduralTexture.fragment.js.map",
-        "grass/grassProceduralTexture.js",
-        "grass/grassProceduralTexture.js.map",
-        "grass/index.d.ts",
-        "grass/index.js",
-        "grass/index.js.map",
-        "index.d.ts",
-        "index.js",
-        "index.js.map",
-        "legacy/legacy-brick.d.ts",
-        "legacy/legacy-brick.js",
-        "legacy/legacy-brick.js.map",
-        "legacy/legacy-cloud.d.ts",
-        "legacy/legacy-cloud.js",
-        "legacy/legacy-cloud.js.map",
-        "legacy/legacy-fire.d.ts",
-        "legacy/legacy-fire.js",
-        "legacy/legacy-fire.js.map",
-        "legacy/legacy-grass.d.ts",
-        "legacy/legacy-grass.js",
-        "legacy/legacy-grass.js.map",
-        "legacy/legacy-marble.d.ts",
-        "legacy/legacy-marble.js",
-        "legacy/legacy-marble.js.map",
-        "legacy/legacy-normalMap.d.ts",
-        "legacy/legacy-normalMap.js",
-        "legacy/legacy-normalMap.js.map",
-        "legacy/legacy-perlinNoise.d.ts",
-        "legacy/legacy-perlinNoise.js",
-        "legacy/legacy-perlinNoise.js.map",
-        "legacy/legacy-road.d.ts",
-        "legacy/legacy-road.js",
-        "legacy/legacy-road.js.map",
-        "legacy/legacy-starfield.d.ts",
-        "legacy/legacy-starfield.js",
-        "legacy/legacy-starfield.js.map",
-        "legacy/legacy-wood.d.ts",
-        "legacy/legacy-wood.js",
-        "legacy/legacy-wood.js.map",
-        "legacy/legacy.d.ts",
-        "legacy/legacy.js",
-        "legacy/legacy.js.map",
-        "marble/index.d.ts",
-        "marble/index.js",
-        "marble/index.js.map",
-        "marble/marbleProceduralTexture.d.ts",
-        "marble/marbleProceduralTexture.fragment.d.ts",
-        "marble/marbleProceduralTexture.fragment.js",
-        "marble/marbleProceduralTexture.fragment.js.map",
-        "marble/marbleProceduralTexture.js",
-        "marble/marbleProceduralTexture.js.map",
-        "normalMap/index.d.ts",
-        "normalMap/index.js",
-        "normalMap/index.js.map",
-        "normalMap/normalMapProceduralTexture.d.ts",
-        "normalMap/normalMapProceduralTexture.fragment.d.ts",
-        "normalMap/normalMapProceduralTexture.fragment.js",
-        "normalMap/normalMapProceduralTexture.fragment.js.map",
-        "normalMap/normalMapProceduralTexture.js",
-        "normalMap/normalMapProceduralTexture.js.map",
-        "perlinNoise/index.d.ts",
-        "perlinNoise/index.js",
-        "perlinNoise/index.js.map",
-        "perlinNoise/perlinNoiseProceduralTexture.d.ts",
-        "perlinNoise/perlinNoiseProceduralTexture.fragment.d.ts",
-        "perlinNoise/perlinNoiseProceduralTexture.fragment.js",
-        "perlinNoise/perlinNoiseProceduralTexture.fragment.js.map",
-        "perlinNoise/perlinNoiseProceduralTexture.js",
-        "perlinNoise/perlinNoiseProceduralTexture.js.map",
-        "readme.md",
-        "road/index.d.ts",
-        "road/index.js",
-        "road/index.js.map",
-        "road/roadProceduralTexture.d.ts",
-        "road/roadProceduralTexture.fragment.d.ts",
-        "road/roadProceduralTexture.fragment.js",
-        "road/roadProceduralTexture.fragment.js.map",
-        "road/roadProceduralTexture.js",
-        "road/roadProceduralTexture.js.map",
-        "starfield/index.d.ts",
-        "starfield/index.js",
-        "starfield/index.js.map",
-        "starfield/starfieldProceduralTexture.d.ts",
-        "starfield/starfieldProceduralTexture.fragment.d.ts",
-        "starfield/starfieldProceduralTexture.fragment.js",
-        "starfield/starfieldProceduralTexture.fragment.js.map",
-        "starfield/starfieldProceduralTexture.js",
-        "starfield/starfieldProceduralTexture.js.map",
-        "wood/index.d.ts",
-        "wood/index.js",
-        "wood/index.js.map",
-        "wood/woodProceduralTexture.d.ts",
-        "wood/woodProceduralTexture.fragment.d.ts",
-        "wood/woodProceduralTexture.fragment.js",
-        "wood/woodProceduralTexture.fragment.js.map",
-        "wood/woodProceduralTexture.js",
-        "wood/woodProceduralTexture.js.map"
+        "**/*.js",
+        "**/*.d.ts",
+        "**/*.map",
+        "readme.md"
     ],
-    "typings": "index.d.ts",
-    "keywords": [
-        "3D",
-        "javascript",
-        "html5",
-        "webgl",
-        "procedural textures"
-    ],
-    "license": "Apache-2.0",
+    "scripts": {
+        "build": "npm run clean && npm run compile",
+        "clean": "rimraf dist && rimraf *.tsbuildinfo && rimraf \"./**/*.!(md|json|build.json)\"",
+        "compile": "tsc -b tsconfig.build.json",
+        "postcompile": "build-tools -c add-js-to-es6 --path ./dist/**/*.js",
+        "prepublishOnly": "build-tools -c prepare-es6-build"
+    },
     "dependencies": {
-        "@babylonjs/core": "5.0.0-beta.9",
+        "@babylonjs/core": "^5.0.0-rc.10",
         "tslib": "^2.3.1"
     },
-    "engines": {
-        "node": "*"
+    "devDependencies": {
+        "@dev/build-tools": "^1.0.0",
+        "@lts/procedural-textures": "^1.0.0",
+        "rimraf": "^3.0.2",
+        "typescript": "^4.4.4"
     },
-    "module": "index.js",
-    "esnext": "index.js",
-    "type": "module"
-}
+    "sideEffects": true
+}

package/perlinNoise/index.d.ts

@@ -1 +1 @@
-export * from "./perlinNoiseProceduralTexture";
+export * from "./perlinNoiseProceduralTexture";

package/perlinNoise/index.js

@@ -1,2 +1,2 @@
-export * from "./perlinNoiseProceduralTexture.js";
+export * from "./perlinNoiseProceduralTexture";
 //# sourceMappingURL=index.js.map

package/perlinNoise/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../sourceES6/proceduralTexturesLibrary/src/perlinNoise/index.ts"],"names":[],"mappings":"AAAA,cAAc,gCAAgC,CAAC","sourcesContent":["export * from \"./perlinNoiseProceduralTexture\";"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../lts/proceduralTextures/generated/perlinNoise/index.ts"],"names":[],"mappings":"AAAA,cAAc,gCAAgC,CAAC","sourcesContent":["export * from \"./perlinNoiseProceduralTexture\";\r\n"]}

package/perlinNoise/perlinNoiseProceduralTexture.d.ts

@@ -1,28 +1,28 @@
-import { Texture } from "@babylonjs/core/Materials/Textures/texture";
-import { ProceduralTexture } from "@babylonjs/core/Materials/Textures/Procedurals/proceduralTexture";
-import { Scene } from "@babylonjs/core/scene";
-import { Nullable } from "@babylonjs/core/types";
-import "./perlinNoiseProceduralTexture.fragment";
-export declare class PerlinNoiseProceduralTexture extends ProceduralTexture {
-    time: number;
-    timeScale: number;
-    translationSpeed: number;
-    private _currentTranslation;
-    constructor(name: string, size: number, scene?: Nullable<Scene>, fallbackTexture?: Texture, generateMipMaps?: boolean);
-    updateShaderUniforms(): void;
-    render(useCameraPostProcess?: boolean): void;
-    resize(size: any, generateMipMaps: any): void;
-    /**
-     * Serializes this perlin noise procedural texture
-     * @returns a serialized perlin noise procedural texture object
-     */
-    serialize(): any;
-    /**
-     * Creates a Perlin Noise Procedural Texture from parsed perlin noise procedural texture data
-     * @param parsedTexture defines parsed texture data
-     * @param scene defines the current scene
-     * @param rootUrl defines the root URL containing perlin noise procedural texture information
-     * @returns a parsed Perlin Noise Procedural Texture
-     */
-    static Parse(parsedTexture: any, scene: Scene, rootUrl: string): PerlinNoiseProceduralTexture;
-}
+import type { Texture } from "@babylonjs/core/Materials/Textures/texture.js";
+import { ProceduralTexture } from "@babylonjs/core/Materials/Textures/Procedurals/proceduralTexture.js";
+import type { Scene } from "@babylonjs/core/scene.js";
+import type { Nullable } from "@babylonjs/core/types.js";
+import "./perlinNoiseProceduralTexture.fragment";
+export declare class PerlinNoiseProceduralTexture extends ProceduralTexture {
+    time: number;
+    timeScale: number;
+    translationSpeed: number;
+    private _currentTranslation;
+    constructor(name: string, size: number, scene?: Nullable<Scene>, fallbackTexture?: Texture, generateMipMaps?: boolean);
+    updateShaderUniforms(): void;
+    render(useCameraPostProcess?: boolean): void;
+    resize(size: any, generateMipMaps: any): void;
+    /**
+     * Serializes this perlin noise procedural texture
+     * @returns a serialized perlin noise procedural texture object
+     */
+    serialize(): any;
+    /**
+     * Creates a Perlin Noise Procedural Texture from parsed perlin noise procedural texture data
+     * @param parsedTexture defines parsed texture data
+     * @param scene defines the current scene
+     * @param rootUrl defines the root URL containing perlin noise procedural texture information
+     * @returns a parsed Perlin Noise Procedural Texture
+     */
+    static Parse(parsedTexture: any, scene: Scene, rootUrl: string): PerlinNoiseProceduralTexture;
+}

package/perlinNoise/perlinNoiseProceduralTexture.fragment.d.ts

@@ -1,5 +1,5 @@
-/** @hidden */
-export declare var perlinNoiseProceduralTexturePixelShader: {
-    name: string;
-    shader: string;
-};
+/** @hidden */
+export declare const perlinNoiseProceduralTexturePixelShader: {
+    name: string;
+    shader: string;
+};

package/perlinNoise/perlinNoiseProceduralTexture.fragment.js

@@ -1,7 +1,9 @@
-import { ShaderStore } from "@babylonjs/core/Engines/shaderStore.js";
-var name = 'perlinNoiseProceduralTexturePixelShader';
-var shader = "\nprecision highp float;\n\nuniform float size;\nuniform float time;\nuniform float translationSpeed;\n\nvarying vec2 vUV;\n\nfloat r(float n)\n{\nreturn fract(cos(n*89.42)*343.42);\n}\nvec2 r(vec2 n)\n{\nreturn vec2(r(n.x*23.62-300.0+n.y*34.35),r(n.x*45.13+256.0+n.y*38.89));\n}\nfloat worley(vec2 n,float s)\n{\nfloat dis=1.0;\nfor(int x=-1; x<=1; x++)\n{\nfor(int y=-1; y<=1; y++)\n{\nvec2 p=floor(n/s)+vec2(x,y);\nfloat d=length(r(p)+vec2(x,y)-fract(n/s));\nif (dis>d)\ndis=d;\n}\n}\nreturn 1.0-dis;\n}\nvec3 hash33(vec3 p3)\n{\np3=fract(p3*vec3(0.1031,0.11369,0.13787));\np3+=dot(p3,p3.yxz+19.19);\nreturn -1.0+2.0*fract(vec3((p3.x+p3.y)*p3.z,(p3.x+p3.z)*p3.y,(p3.y+p3.z)*p3.x));\n}\nfloat perlinNoise(vec3 p)\n{\nvec3 pi=floor(p);\nvec3 pf=p-pi;\nvec3 w=pf*pf*(3.0-2.0*pf);\nreturn mix(\nmix(\nmix(\ndot(pf-vec3(0,0,0),hash33(pi+vec3(0,0,0))),\ndot(pf-vec3(1,0,0),hash33(pi+vec3(1,0,0))),\nw.x\n),\nmix(\ndot(pf-vec3(0,0,1),hash33(pi+vec3(0,0,1))),\ndot(pf-vec3(1,0,1),hash33(pi+vec3(1,0,1))),\nw.x\n),\nw.z\n),\nmix(\nmix(\ndot(pf-vec3(0,1,0),hash33(pi+vec3(0,1,0))),\ndot(pf-vec3(1,1,0),hash33(pi+vec3(1,1,0))),\nw.x\n),\nmix(\ndot(pf-vec3(0,1,1),hash33(pi+vec3(0,1,1))),\ndot(pf-vec3(1,1,1),hash33(pi+vec3(1,1,1))),\nw.x\n),\nw.z\n),\nw.y\n);\n}\n\n#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void)\n{\nvec2 uv=gl_FragCoord.xy+translationSpeed;\nfloat dis=(\n1.0+perlinNoise(vec3(uv/vec2(size,size),time*0.05)*8.0))\n*(1.0+(worley(uv,32.0)+ 0.5*worley(2.0*uv,32.0)+0.25*worley(4.0*uv,32.0))\n);\ngl_FragColor=vec4(vec3(dis/4.0),1.0);\n}\n";
-ShaderStore.ShadersStore[name] = shader;
-/** @hidden */
-export var perlinNoiseProceduralTexturePixelShader = { name: name, shader: shader };
+// Do not edit.
+import { ShaderStore } from "@babylonjs/core/Engines/shaderStore.js";
+var name = "perlinNoiseProceduralTexturePixelShader";
+var shader = "precision highp float;uniform float size;uniform float time;uniform float translationSpeed;varying vec2 vUV;float r(float n)\n{return fract(cos(n*89.42)*343.42);}\nvec2 r(vec2 n)\n{return vec2(r(n.x*23.62-300.0+n.y*34.35),r(n.x*45.13+256.0+n.y*38.89)); }\nfloat worley(vec2 n,float s)\n{float dis=1.0;for(int x=-1; x<=1; x++)\n{for(int y=-1; y<=1; y++)\n{vec2 p=floor(n/s)+vec2(x,y);float d=length(r(p)+vec2(x,y)-fract(n/s));if (dis>d)\ndis=d;}}\nreturn 1.0-dis;}\nvec3 hash33(vec3 p3)\n{p3=fract(p3*vec3(0.1031,0.11369,0.13787));p3+=dot(p3,p3.yxz+19.19);return -1.0+2.0*fract(vec3((p3.x+p3.y)*p3.z,(p3.x+p3.z)*p3.y,(p3.y+p3.z)*p3.x));}\nfloat perlinNoise(vec3 p)\n{vec3 pi=floor(p);vec3 pf=p-pi;vec3 w=pf*pf*(3.0-2.0*pf);return mix(\nmix(\nmix(\ndot(pf-vec3(0,0,0),hash33(pi+vec3(0,0,0))),\ndot(pf-vec3(1,0,0),hash33(pi+vec3(1,0,0))),w.x\n),mix(\ndot(pf-vec3(0,0,1),hash33(pi+vec3(0,0,1))),\ndot(pf-vec3(1,0,1),hash33(pi+vec3(1,0,1))),w.x\n),w.z\n),mix(\nmix(\ndot(pf-vec3(0,1,0),hash33(pi+vec3(0,1,0))),\ndot(pf-vec3(1,1,0),hash33(pi+vec3(1,1,0))),w.x\n),mix(\ndot(pf-vec3(0,1,1),hash33(pi+vec3(0,1,1))),\ndot(pf-vec3(1,1,1),hash33(pi+vec3(1,1,1))),w.x\n),w.z\n),w.y\n);}\n#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void)\n{vec2 uv=gl_FragCoord.xy+translationSpeed;float dis=(\n1.0+perlinNoise(vec3(uv/vec2(size,size),time*0.05)*8.0))\n* (1.0+(worley(uv,32.0)+ 0.5*worley(2.0*uv,32.0)+0.25*worley(4.0*uv,32.0))\n);gl_FragColor=vec4(vec3(dis/4.0),1.0);}\n";
+// Sideeffect
+ShaderStore.ShadersStore[name] = shader;
+/** @hidden */
+export var perlinNoiseProceduralTexturePixelShader = { name: name, shader: shader };
 //# sourceMappingURL=perlinNoiseProceduralTexture.fragment.js.map

package/perlinNoise/perlinNoiseProceduralTexture.fragment.js.map

@@ -1 +1 @@
-{"version":3,"file":"perlinNoiseProceduralTexture.fragment.js","sourceRoot":"","sources":["../../../sourceES6/proceduralTexturesLibrary/src/perlinNoise/perlinNoiseProceduralTexture.fragment.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,qCAAqC,CAAC;AAElE,IAAI,IAAI,GAAG,yCAAyC,CAAC;AACrD,IAAI,MAAM,GAAG,ghDAoFZ,CAAC;AAEF,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,cAAc;AACd,MAAM,CAAC,IAAI,uCAAuC,GAAG,EAAE,IAAI,MAAA,EAAE,MAAM,QAAA,EAAE,CAAC","sourcesContent":["import { ShaderStore } from \"@babylonjs/core/Engines/shaderStore\";\n\nlet name = 'perlinNoiseProceduralTexturePixelShader';\nlet shader = `\nprecision highp float;\n\nuniform float size;\nuniform float time;\nuniform float translationSpeed;\n\nvarying vec2 vUV;\n\nfloat r(float n)\n{\nreturn fract(cos(n*89.42)*343.42);\n}\nvec2 r(vec2 n)\n{\nreturn vec2(r(n.x*23.62-300.0+n.y*34.35),r(n.x*45.13+256.0+n.y*38.89));\n}\nfloat worley(vec2 n,float s)\n{\nfloat dis=1.0;\nfor(int x=-1; x<=1; x++)\n{\nfor(int y=-1; y<=1; y++)\n{\nvec2 p=floor(n/s)+vec2(x,y);\nfloat d=length(r(p)+vec2(x,y)-fract(n/s));\nif (dis>d)\ndis=d;\n}\n}\nreturn 1.0-dis;\n}\nvec3 hash33(vec3 p3)\n{\np3=fract(p3*vec3(0.1031,0.11369,0.13787));\np3+=dot(p3,p3.yxz+19.19);\nreturn -1.0+2.0*fract(vec3((p3.x+p3.y)*p3.z,(p3.x+p3.z)*p3.y,(p3.y+p3.z)*p3.x));\n}\nfloat perlinNoise(vec3 p)\n{\nvec3 pi=floor(p);\nvec3 pf=p-pi;\nvec3 w=pf*pf*(3.0-2.0*pf);\nreturn mix(\nmix(\nmix(\ndot(pf-vec3(0,0,0),hash33(pi+vec3(0,0,0))),\ndot(pf-vec3(1,0,0),hash33(pi+vec3(1,0,0))),\nw.x\n),\nmix(\ndot(pf-vec3(0,0,1),hash33(pi+vec3(0,0,1))),\ndot(pf-vec3(1,0,1),hash33(pi+vec3(1,0,1))),\nw.x\n),\nw.z\n),\nmix(\nmix(\ndot(pf-vec3(0,1,0),hash33(pi+vec3(0,1,0))),\ndot(pf-vec3(1,1,0),hash33(pi+vec3(1,1,0))),\nw.x\n),\nmix(\ndot(pf-vec3(0,1,1),hash33(pi+vec3(0,1,1))),\ndot(pf-vec3(1,1,1),hash33(pi+vec3(1,1,1))),\nw.x\n),\nw.z\n),\nw.y\n);\n}\n\n#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void)\n{\nvec2 uv=gl_FragCoord.xy+translationSpeed;\nfloat dis=(\n1.0+perlinNoise(vec3(uv/vec2(size,size),time*0.05)*8.0))\n*(1.0+(worley(uv,32.0)+ 0.5*worley(2.0*uv,32.0)+0.25*worley(4.0*uv,32.0))\n);\ngl_FragColor=vec4(vec3(dis/4.0),1.0);\n}\n`;\n\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport var perlinNoiseProceduralTexturePixelShader = { name, shader };\n"]}
+{"version":3,"file":"perlinNoiseProceduralTexture.fragment.js","sourceRoot":"","sources":["../../../../../lts/proceduralTextures/generated/perlinNoise/perlinNoiseProceduralTexture.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,+CAAiC;AAEvD,IAAM,IAAI,GAAG,yCAAyC,CAAC;AACvD,IAAM,MAAM,GAAG,s7CAsCd,CAAC;AACF,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,cAAc;AACd,MAAM,CAAC,IAAM,uCAAuC,GAAG,EAAE,IAAI,MAAA,EAAE,MAAM,QAAA,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"core/Engines/shaderStore\";\n\nconst name = \"perlinNoiseProceduralTexturePixelShader\";\nconst shader = `precision highp float;uniform float size;uniform float time;uniform float translationSpeed;varying vec2 vUV;float r(float n)\n{return fract(cos(n*89.42)*343.42);}\nvec2 r(vec2 n)\n{return vec2(r(n.x*23.62-300.0+n.y*34.35),r(n.x*45.13+256.0+n.y*38.89)); }\nfloat worley(vec2 n,float s)\n{float dis=1.0;for(int x=-1; x<=1; x++)\n{for(int y=-1; y<=1; y++)\n{vec2 p=floor(n/s)+vec2(x,y);float d=length(r(p)+vec2(x,y)-fract(n/s));if (dis>d)\ndis=d;}}\nreturn 1.0-dis;}\nvec3 hash33(vec3 p3)\n{p3=fract(p3*vec3(0.1031,0.11369,0.13787));p3+=dot(p3,p3.yxz+19.19);return -1.0+2.0*fract(vec3((p3.x+p3.y)*p3.z,(p3.x+p3.z)*p3.y,(p3.y+p3.z)*p3.x));}\nfloat perlinNoise(vec3 p)\n{vec3 pi=floor(p);vec3 pf=p-pi;vec3 w=pf*pf*(3.0-2.0*pf);return mix(\nmix(\nmix(\ndot(pf-vec3(0,0,0),hash33(pi+vec3(0,0,0))),\ndot(pf-vec3(1,0,0),hash33(pi+vec3(1,0,0))),w.x\n),mix(\ndot(pf-vec3(0,0,1),hash33(pi+vec3(0,0,1))),\ndot(pf-vec3(1,0,1),hash33(pi+vec3(1,0,1))),w.x\n),w.z\n),mix(\nmix(\ndot(pf-vec3(0,1,0),hash33(pi+vec3(0,1,0))),\ndot(pf-vec3(1,1,0),hash33(pi+vec3(1,1,0))),w.x\n),mix(\ndot(pf-vec3(0,1,1),hash33(pi+vec3(0,1,1))),\ndot(pf-vec3(1,1,1),hash33(pi+vec3(1,1,1))),w.x\n),w.z\n),w.y\n);}\n#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void)\n{vec2 uv=gl_FragCoord.xy+translationSpeed;float dis=(\n1.0+perlinNoise(vec3(uv/vec2(size,size),time*0.05)*8.0))\n* (1.0+(worley(uv,32.0)+ 0.5*worley(2.0*uv,32.0)+0.25*worley(4.0*uv,32.0))\n);gl_FragColor=vec4(vec3(dis/4.0),1.0);}\n`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport const perlinNoiseProceduralTexturePixelShader = { name, shader };\n"]}