@onerjs/procedural-textures 8.25.0

package/marble/marbleProceduralTexture.fragment.js

@@ -0,0 +1,28 @@
+// Do not edit.
+import { ShaderStore } from "@onerjs/core/Engines/shaderStore.js";
+const name = "marbleProceduralTexturePixelShader";
+const shader = `precision highp float;varying vec2 vPosition;varying vec2 vUV;uniform float numberOfTilesHeight;uniform float numberOfTilesWidth;uniform float amplitude;uniform vec3 marbleColor;uniform vec3 jointColor;const vec3 tileSize=vec3(1.1,1.0,1.1);const vec3 tilePct=vec3(0.98,1.0,0.98);float rand(vec2 n) {return fract(cos(dot(n,vec2(12.9898,4.1414)))*43758.5453);}
+float noise(vec2 n) {const vec2 d=vec2(0.0,1.0);vec2 b=floor(n),f=smoothstep(vec2(0.0),vec2(1.0),fract(n));return mix(mix(rand(b),rand(b+d.yx),f.x),mix(rand(b+d.xy),rand(b+d.yy),f.x),f.y);}
+float turbulence(vec2 P)
+{float val=0.0;float freq=1.0;for (int i=0; i<4; i++)
+{val+=abs(noise(P*freq)/freq);freq*=2.07;}
+return val;}
+float roundF(float number){return sign(number)*floor(abs(number)+0.5);}
+vec3 marble_color(float x)
+{vec3 col;x=0.5*(x+1.);x=sqrt(x); 
+x=sqrt(x);x=sqrt(x);col=vec3(.2+.75*x); 
+col.b*=0.95; 
+return col;}
+void main()
+{float brickW=1.0/numberOfTilesWidth;float brickH=1.0/numberOfTilesHeight;float jointWPercentage=0.01;float jointHPercentage=0.01;vec3 color=marbleColor;float yi=vUV.y/brickH;float nyi=roundF(yi);float xi=vUV.x/brickW;if (mod(floor(yi),2.0)==0.0){xi=xi-0.5;}
+float nxi=roundF(xi);vec2 brickvUV=vec2((xi-floor(xi))/brickH,(yi-floor(yi))/brickW);if (yi<nyi+jointHPercentage && yi>nyi-jointHPercentage){color=mix(jointColor,vec3(0.37,0.25,0.25),(yi-nyi)/jointHPercentage+0.2);}
+else if (xi<nxi+jointWPercentage && xi>nxi-jointWPercentage){color=mix(jointColor,vec3(0.44,0.44,0.44),(xi-nxi)/jointWPercentage+0.2);}
+else {float t=6.28*brickvUV.x/(tileSize.x+noise(vec2(vUV)*6.0));t+=amplitude*turbulence(brickvUV.xy);t=sin(t);color=marble_color(t);}
+gl_FragColor=vec4(color,0.0);}`;
+// Sideeffect
+if (!ShaderStore.ShadersStore[name]) {
+    ShaderStore.ShadersStore[name] = shader;
+}
+/** @internal */
+export const marbleProceduralTexturePixelShader = { name, shader };
+//# sourceMappingURL=marbleProceduralTexture.fragment.js.map

package/marble/marbleProceduralTexture.fragment.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"marbleProceduralTexture.fragment.js","sourceRoot":"","sources":["../../../../dev/proceduralTextures/src/marble/marbleProceduralTexture.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,4CAAiC;AAEvD,MAAM,IAAI,GAAG,oCAAoC,CAAC;AAClD,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;+BAiBgB,CAAC;AAChC,aAAa;AACb,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,EAAE,CAAC;IAClC,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAC5C,CAAC;AACD,gBAAgB;AAChB,MAAM,CAAC,MAAM,kCAAkC,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"core/Engines/shaderStore\";\n\nconst name = \"marbleProceduralTexturePixelShader\";\nconst shader = `precision highp float;varying vec2 vPosition;varying vec2 vUV;uniform float numberOfTilesHeight;uniform float numberOfTilesWidth;uniform float amplitude;uniform vec3 marbleColor;uniform vec3 jointColor;const vec3 tileSize=vec3(1.1,1.0,1.1);const vec3 tilePct=vec3(0.98,1.0,0.98);float rand(vec2 n) {return fract(cos(dot(n,vec2(12.9898,4.1414)))*43758.5453);}\nfloat noise(vec2 n) {const vec2 d=vec2(0.0,1.0);vec2 b=floor(n),f=smoothstep(vec2(0.0),vec2(1.0),fract(n));return mix(mix(rand(b),rand(b+d.yx),f.x),mix(rand(b+d.xy),rand(b+d.yy),f.x),f.y);}\nfloat turbulence(vec2 P)\n{float val=0.0;float freq=1.0;for (int i=0; i<4; i++)\n{val+=abs(noise(P*freq)/freq);freq*=2.07;}\nreturn val;}\nfloat roundF(float number){return sign(number)*floor(abs(number)+0.5);}\nvec3 marble_color(float x)\n{vec3 col;x=0.5*(x+1.);x=sqrt(x); \nx=sqrt(x);x=sqrt(x);col=vec3(.2+.75*x); \ncol.b*=0.95; \nreturn col;}\nvoid main()\n{float brickW=1.0/numberOfTilesWidth;float brickH=1.0/numberOfTilesHeight;float jointWPercentage=0.01;float jointHPercentage=0.01;vec3 color=marbleColor;float yi=vUV.y/brickH;float nyi=roundF(yi);float xi=vUV.x/brickW;if (mod(floor(yi),2.0)==0.0){xi=xi-0.5;}\nfloat nxi=roundF(xi);vec2 brickvUV=vec2((xi-floor(xi))/brickH,(yi-floor(yi))/brickW);if (yi<nyi+jointHPercentage && yi>nyi-jointHPercentage){color=mix(jointColor,vec3(0.37,0.25,0.25),(yi-nyi)/jointHPercentage+0.2);}\nelse if (xi<nxi+jointWPercentage && xi>nxi-jointWPercentage){color=mix(jointColor,vec3(0.44,0.44,0.44),(xi-nxi)/jointWPercentage+0.2);}\nelse {float t=6.28*brickvUV.x/(tileSize.x+noise(vec2(vUV)*6.0));t+=amplitude*turbulence(brickvUV.xy);t=sin(t);color=marble_color(t);}\ngl_FragColor=vec4(color,0.0);}`;\n// Sideeffect\nif (!ShaderStore.ShadersStore[name]) {\n    ShaderStore.ShadersStore[name] = shader;\n}\n/** @internal */\nexport const marbleProceduralTexturePixelShader = { name, shader };\n"]}

package/marble/marbleProceduralTexture.js

@@ -0,0 +1,85 @@
+import { __decorate } from "@onerjs/core/tslib.es6.js";
+import { serialize } from "@onerjs/core/Misc/decorators.js";
+import { SerializationHelper } from "@onerjs/core/Misc/decorators.serialization.js";
+import { Color3 } from "@onerjs/core/Maths/math.color.js";
+import { ProceduralTexture } from "@onerjs/core/Materials/Textures/Procedurals/proceduralTexture.js";
+import { RegisterClass } from "@onerjs/core/Misc/typeStore.js";
+import "./marbleProceduralTexture.fragment.js";
+export class MarbleProceduralTexture extends ProceduralTexture {
+    constructor(name, size, scene = null, fallbackTexture, generateMipMaps) {
+        super(name, size, "marbleProceduralTexture", scene, fallbackTexture, generateMipMaps);
+        this._numberOfTilesHeight = 3;
+        this._numberOfTilesWidth = 3;
+        this._amplitude = 9.0;
+        this._jointColor = new Color3(0.72, 0.72, 0.72);
+        this.updateShaderUniforms();
+    }
+    updateShaderUniforms() {
+        this.setFloat("numberOfTilesHeight", this._numberOfTilesHeight);
+        this.setFloat("numberOfTilesWidth", this._numberOfTilesWidth);
+        this.setFloat("amplitude", this._amplitude);
+        this.setColor3("jointColor", this._jointColor);
+    }
+    get numberOfTilesHeight() {
+        return this._numberOfTilesHeight;
+    }
+    set numberOfTilesHeight(value) {
+        this._numberOfTilesHeight = value;
+        this.updateShaderUniforms();
+    }
+    get amplitude() {
+        return this._amplitude;
+    }
+    set amplitude(value) {
+        this._amplitude = value;
+        this.updateShaderUniforms();
+    }
+    get numberOfTilesWidth() {
+        return this._numberOfTilesWidth;
+    }
+    set numberOfTilesWidth(value) {
+        this._numberOfTilesWidth = value;
+        this.updateShaderUniforms();
+    }
+    get jointColor() {
+        return this._jointColor;
+    }
+    set jointColor(value) {
+        this._jointColor = value;
+        this.updateShaderUniforms();
+    }
+    /**
+     * Serializes this marble procedural texture
+     * @returns a serialized marble procedural texture object
+     */
+    serialize() {
+        const serializationObject = SerializationHelper.Serialize(this, super.serialize());
+        serializationObject.customType = "BABYLON.MarbleProceduralTexture";
+        return serializationObject;
+    }
+    /**
+     * Creates a Marble Procedural Texture from parsed marble procedural texture data
+     * @param parsedTexture defines parsed texture data
+     * @param scene defines the current scene
+     * @param rootUrl defines the root URL containing marble procedural texture information
+     * @returns a parsed Marble Procedural Texture
+     */
+    static Parse(parsedTexture, scene, rootUrl) {
+        const texture = SerializationHelper.Parse(() => new MarbleProceduralTexture(parsedTexture.name, parsedTexture._size, scene, undefined, parsedTexture._generateMipMaps), parsedTexture, scene, rootUrl);
+        return texture;
+    }
+}
+__decorate([
+    serialize()
+], MarbleProceduralTexture.prototype, "numberOfTilesHeight", null);
+__decorate([
+    serialize()
+], MarbleProceduralTexture.prototype, "amplitude", null);
+__decorate([
+    serialize()
+], MarbleProceduralTexture.prototype, "numberOfTilesWidth", null);
+__decorate([
+    serialize()
+], MarbleProceduralTexture.prototype, "jointColor", null);
+RegisterClass("BABYLON.MarbleProceduralTexture", MarbleProceduralTexture);
+//# sourceMappingURL=marbleProceduralTexture.js.map

package/marble/marbleProceduralTexture.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"marbleProceduralTexture.js","sourceRoot":"","sources":["../../../../dev/proceduralTextures/src/marble/marbleProceduralTexture.ts"],"names":[],"mappings":"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","sourcesContent":["import { serialize } from \"core/Misc/decorators\";\r\nimport { SerializationHelper } from \"core/Misc/decorators.serialization\";\r\nimport { Color3 } from \"core/Maths/math.color\";\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\n\r\nimport \"./marbleProceduralTexture.fragment\";\r\n\r\nexport class MarbleProceduralTexture extends ProceduralTexture {\r\n    private _numberOfTilesHeight: number = 3;\r\n    private _numberOfTilesWidth: number = 3;\r\n    private _amplitude: number = 9.0;\r\n    private _jointColor = new Color3(0.72, 0.72, 0.72);\r\n\r\n    constructor(name: string, size: number, scene: Nullable<Scene> = null, fallbackTexture?: Texture, generateMipMaps?: boolean) {\r\n        super(name, size, \"marbleProceduralTexture\", scene, fallbackTexture, generateMipMaps);\r\n        this.updateShaderUniforms();\r\n    }\r\n\r\n    public updateShaderUniforms() {\r\n        this.setFloat(\"numberOfTilesHeight\", this._numberOfTilesHeight);\r\n        this.setFloat(\"numberOfTilesWidth\", this._numberOfTilesWidth);\r\n        this.setFloat(\"amplitude\", this._amplitude);\r\n        this.setColor3(\"jointColor\", this._jointColor);\r\n    }\r\n\r\n    @serialize()\r\n    public get numberOfTilesHeight(): number {\r\n        return this._numberOfTilesHeight;\r\n    }\r\n\r\n    public set numberOfTilesHeight(value: number) {\r\n        this._numberOfTilesHeight = value;\r\n        this.updateShaderUniforms();\r\n    }\r\n\r\n    @serialize()\r\n    public get amplitude(): number {\r\n        return this._amplitude;\r\n    }\r\n\r\n    public set amplitude(value: number) {\r\n        this._amplitude = value;\r\n        this.updateShaderUniforms();\r\n    }\r\n\r\n    @serialize()\r\n    public get numberOfTilesWidth(): number {\r\n        return this._numberOfTilesWidth;\r\n    }\r\n\r\n    public set numberOfTilesWidth(value: number) {\r\n        this._numberOfTilesWidth = value;\r\n        this.updateShaderUniforms();\r\n    }\r\n\r\n    @serialize()\r\n    public get jointColor(): Color3 {\r\n        return this._jointColor;\r\n    }\r\n\r\n    public set jointColor(value: Color3) {\r\n        this._jointColor = value;\r\n        this.updateShaderUniforms();\r\n    }\r\n\r\n    /**\r\n     * Serializes this marble procedural texture\r\n     * @returns a serialized marble procedural texture object\r\n     */\r\n    public override serialize(): any {\r\n        const serializationObject = SerializationHelper.Serialize(this, super.serialize());\r\n        serializationObject.customType = \"BABYLON.MarbleProceduralTexture\";\r\n\r\n        return serializationObject;\r\n    }\r\n\r\n    /**\r\n     * Creates a Marble Procedural Texture from parsed marble 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 marble procedural texture information\r\n     * @returns a parsed Marble Procedural Texture\r\n     */\r\n    public static override Parse(parsedTexture: any, scene: Scene, rootUrl: string): MarbleProceduralTexture {\r\n        const texture = SerializationHelper.Parse(\r\n            () => new MarbleProceduralTexture(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.MarbleProceduralTexture\", MarbleProceduralTexture);\r\n"]}

package/normalMap/index.d.ts

@@ -0,0 +1 @@
+export * from "./normalMapProceduralTexture.js";

package/normalMap/index.js

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

package/normalMap/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../dev/proceduralTextures/src/normalMap/index.ts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAC","sourcesContent":["export * from \"./normalMapProceduralTexture\";\r\n"]}

package/normalMap/normalMapProceduralTexture.d.ts

@@ -0,0 +1,28 @@
+import type { Texture } from "@onerjs/core/Materials/Textures/texture.js";
+import { ProceduralTexture } from "@onerjs/core/Materials/Textures/Procedurals/proceduralTexture.js";
+import type { Scene } from "@onerjs/core/scene.js";
+import type { Nullable } from "@onerjs/core/types.js";
+import "./normalMapProceduralTexture.fragment.js";
+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

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

package/normalMap/normalMapProceduralTexture.fragment.js

@@ -0,0 +1,15 @@
+// Do not edit.
+import { ShaderStore } from "@onerjs/core/Engines/shaderStore.js";
+const name = "normalMapProceduralTexturePixelShader";
+const 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)
+{vec3 pixel=texture2D(baseSampler,coord).rgb;float luma=dot(pixel,LUMA_COEFFICIENT);return luma;}
+void main()
+{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);}
+`;
+// Sideeffect
+if (!ShaderStore.ShadersStore[name]) {
+    ShaderStore.ShadersStore[name] = shader;
+}
+/** @internal */
+export const normalMapProceduralTexturePixelShader = { name, shader };
+//# sourceMappingURL=normalMapProceduralTexture.fragment.js.map

package/normalMap/normalMapProceduralTexture.fragment.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalMapProceduralTexture.fragment.js","sourceRoot":"","sources":["../../../../dev/proceduralTextures/src/normalMap/normalMapProceduralTexture.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,4CAAiC;AAEvD,MAAM,IAAI,GAAG,uCAAuC,CAAC;AACrD,MAAM,MAAM,GAAG;;;;CAId,CAAC;AACF,aAAa;AACb,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,EAAE,CAAC;IAClC,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAC5C,CAAC;AACD,gBAAgB;AAChB,MAAM,CAAC,MAAM,qCAAqC,GAAG,EAAE,IAAI,EAAE,MAAM,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\nif (!ShaderStore.ShadersStore[name]) {\n    ShaderStore.ShadersStore[name] = shader;\n}\n/** @internal */\nexport const normalMapProceduralTexturePixelShader = { name, shader };\n"]}

package/normalMap/normalMapProceduralTexture.js

@@ -0,0 +1,62 @@
+import { __decorate } from "@onerjs/core/tslib.es6.js";
+import { serializeAsTexture } from "@onerjs/core/Misc/decorators.js";
+import { SerializationHelper } from "@onerjs/core/Misc/decorators.serialization.js";
+import { ProceduralTexture } from "@onerjs/core/Materials/Textures/Procedurals/proceduralTexture.js";
+import { RegisterClass } from "@onerjs/core/Misc/typeStore.js";
+import "./normalMapProceduralTexture.fragment.js";
+export class NormalMapProceduralTexture extends ProceduralTexture {
+    constructor(name, size, scene = null, fallbackTexture, generateMipMaps) {
+        super(name, size, "normalMapProceduralTexture", scene, fallbackTexture, generateMipMaps);
+        this.updateShaderUniforms();
+    }
+    updateShaderUniforms() {
+        this.setTexture("baseSampler", this._baseTexture);
+        this.setFloat("size", this.getRenderSize());
+    }
+    render(useCameraPostProcess) {
+        super.render(useCameraPostProcess);
+    }
+    resize(size, generateMipMaps) {
+        super.resize(size, generateMipMaps);
+        // We need to update the "size" uniform
+        this.updateShaderUniforms();
+    }
+    isReady() {
+        if (!this._baseTexture || !this._baseTexture.isReady()) {
+            return false;
+        }
+        return super.isReady();
+    }
+    get baseTexture() {
+        return this._baseTexture;
+    }
+    set baseTexture(texture) {
+        this._baseTexture = texture;
+        this.updateShaderUniforms();
+    }
+    /**
+     * Serializes this normal map procedural texture
+     * @returns a serialized normal map procedural texture object
+     */
+    serialize() {
+        const serializationObject = SerializationHelper.Serialize(this, super.serialize());
+        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
+     */
+    static Parse(parsedTexture, scene, rootUrl) {
+        const texture = SerializationHelper.Parse(() => new NormalMapProceduralTexture(parsedTexture.name, parsedTexture._size, scene, undefined, parsedTexture._generateMipMaps), parsedTexture, scene, rootUrl);
+        return texture;
+    }
+}
+__decorate([
+    serializeAsTexture()
+], NormalMapProceduralTexture.prototype, "baseTexture", null);
+RegisterClass("BABYLON.NormalMapProceduralTexture", NormalMapProceduralTexture);
+//# sourceMappingURL=normalMapProceduralTexture.js.map

package/normalMap/normalMapProceduralTexture.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalMapProceduralTexture.js","sourceRoot":"","sources":["../../../../dev/proceduralTextures/src/normalMap/normalMapProceduralTexture.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,kBAAkB,EAAE,wCAA6B;AAC1D,OAAO,EAAE,mBAAmB,EAAE,sDAA2C;AAEzE,OAAO,EAAE,iBAAiB,EAAE,yEAA8D;AAE1F,OAAO,EAAE,aAAa,EAAE,uCAA4B;AAEpD,OAAO,uCAAuC,CAAC;AAE/C,MAAM,OAAO,0BAA2B,SAAQ,iBAAiB;IAG7D,YAAY,IAAY,EAAE,IAAY,EAAE,QAAyB,IAAI,EAAE,eAAyB,EAAE,eAAyB;QACvH,KAAK,CAAC,IAAI,EAAE,IAAI,EAAE,4BAA4B,EAAE,KAAK,EAAE,eAAe,EAAE,eAAe,CAAC,CAAC;QACzF,IAAI,CAAC,oBAAoB,EAAE,CAAC;IAChC,CAAC;IAEM,oBAAoB;QACvB,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;IAEe,MAAM,CAAC,oBAA8B;QACjD,KAAK,CAAC,MAAM,CAAC,oBAAoB,CAAC,CAAC;IACvC,CAAC;IAEe,MAAM,CAAC,IAAS,EAAE,eAAoB;QAClD,KAAK,CAAC,MAAM,CAAC,IAAI,EAAE,eAAe,CAAC,CAAC;QAEpC,uCAAuC;QACvC,IAAI,CAAC,oBAAoB,EAAE,CAAC;IAChC,CAAC;IAEe,OAAO;QACnB,IAAI,CAAC,IAAI,CAAC,YAAY,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,EAAE,CAAC;YACrD,OAAO,KAAK,CAAC;QACjB,CAAC;QAED,OAAO,KAAK,CAAC,OAAO,EAAE,CAAC;IAC3B,CAAC;IAGD,IAAW,WAAW;QAClB,OAAO,IAAI,CAAC,YAAY,CAAC;IAC7B,CAAC;IAED,IAAW,WAAW,CAAC,OAAgB;QACnC,IAAI,CAAC,YAAY,GAAG,OAAO,CAAC;QAC5B,IAAI,CAAC,oBAAoB,EAAE,CAAC;IAChC,CAAC;IAED;;;OAGG;IACa,SAAS;QACrB,MAAM,mBAAmB,GAAG,mBAAmB,CAAC,SAAS,CAAC,IAAI,EAAE,KAAK,CAAC,SAAS,EAAE,CAAC,CAAC;QACnF,mBAAmB,CAAC,UAAU,GAAG,oCAAoC,CAAC;QAEtE,OAAO,mBAAmB,CAAC;IAC/B,CAAC;IAED;;;;;;OAMG;IACI,MAAM,CAAU,KAAK,CAAC,aAAkB,EAAE,KAAY,EAAE,OAAe;QAC1E,MAAM,OAAO,GAAG,mBAAmB,CAAC,KAAK,CACrC,GAAG,EAAE,CAAC,IAAI,0BAA0B,CAAC,aAAa,CAAC,IAAI,EAAE,aAAa,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,aAAa,CAAC,gBAAgB,CAAC,EAC/H,aAAa,EACb,KAAK,EACL,OAAO,CACV,CAAC;QAEF,OAAO,OAAO,CAAC;IACnB,CAAC;CACJ;AArCG;IADC,kBAAkB,EAAE;6DAGpB;AAqCL,aAAa,CAAC,oCAAoC,EAAE,0BAA0B,CAAC,CAAC","sourcesContent":["import { serializeAsTexture } from \"core/Misc/decorators\";\r\nimport { SerializationHelper } from \"core/Misc/decorators.serialization\";\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 override render(useCameraPostProcess?: boolean) {\r\n        super.render(useCameraPostProcess);\r\n    }\r\n\r\n    public override 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 override 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 override 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 override 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

@@ -0,0 +1,47 @@
+{
+    "name": "@onerjs/procedural-textures",
+    "version": "8.25.0",
+    "main": "index.js",
+    "module": "index.js",
+    "types": "index.d.ts",
+    "files": [
+        "**/*.js",
+        "**/*.d.ts",
+        "**/*.map",
+        "readme.md",
+        "license.md"
+    ],
+    "scripts": {
+        "build": "npm run clean && npm run compile",
+        "clean": "rimraf dist && rimraf *.tsbuildinfo -g && rimraf \"./**/*.!(md|json|build.json|lts.json)\" -g",
+        "compile": "tsc -b tsconfig.build.json && tsc -b tsconfig.lts.json",
+        "postcompile": "build-tools -c add-js-to-es6"
+    },
+    "devDependencies": {
+        "@onerjs/core": "^8.25.0",
+        "@dev/build-tools": "^1.0.0",
+        "@lts/procedural-textures": "^1.0.0"
+    },
+    "peerDependencies": {
+        "@onerjs/core": "^8.0.0"
+    },
+    "keywords": [
+        "3D",
+        "javascript",
+        "html5",
+        "webgl",
+        "babylon.js"
+    ],
+    "license": "Apache-2.0",
+    "esnext": "index.js",
+    "type": "module",
+    "sideEffects": true,
+    "homepage": "https://www.babylonjs.com",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/BabylonJS/Babylon.js.git"
+    },
+    "bugs": {
+        "url": "https://github.com/BabylonJS/Babylon.js/issues"
+    }
+}

package/perlinNoise/index.d.ts

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

package/perlinNoise/index.js

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

package/perlinNoise/index.js.map

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

package/perlinNoise/perlinNoiseProceduralTexture.d.ts

@@ -0,0 +1,28 @@
+import type { Texture } from "@onerjs/core/Materials/Textures/texture.js";
+import { ProceduralTexture } from "@onerjs/core/Materials/Textures/Procedurals/proceduralTexture.js";
+import type { Scene } from "@onerjs/core/scene.js";
+import type { Nullable } from "@onerjs/core/types.js";
+import "./perlinNoiseProceduralTexture.fragment.js";
+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

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

package/perlinNoise/perlinNoiseProceduralTexture.fragment.js

@@ -0,0 +1,59 @@
+// Do not edit.
+import { ShaderStore } from "@onerjs/core/Engines/shaderStore.js";
+const name = "perlinNoiseProceduralTexturePixelShader";
+const shader = `precision highp float;uniform float size;uniform float time;uniform float translationSpeed;varying vec2 vUV;float r(float n)
+{return fract(cos(n*89.42)*343.42);}
+vec2 r(vec2 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)); }
+float worley(vec2 n,float s)
+{float dis=1.0;for(int x=-1; x<=1; x++)
+{for(int y=-1; y<=1; y++)
+{vec2 p=floor(n/s)+vec2(x,y);float d=length(r(p)+vec2(x,y)-fract(n/s));if (dis>d)
+dis=d;}}
+return 1.0-dis;}
+vec3 hash33(vec3 p3)
+{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));}
+float perlinNoise(vec3 p)
+{vec3 pi=floor(p);vec3 pf=p-pi;vec3 w=pf*pf*(3.0-2.0*pf);return mix(
+mix(
+mix(
+dot(pf-vec3(0,0,0),hash33(pi+vec3(0,0,0))),
+dot(pf-vec3(1,0,0),hash33(pi+vec3(1,0,0))),
+w.x
+),
+mix(
+dot(pf-vec3(0,0,1),hash33(pi+vec3(0,0,1))),
+dot(pf-vec3(1,0,1),hash33(pi+vec3(1,0,1))),
+w.x
+),
+w.z
+),
+mix(
+mix(
+dot(pf-vec3(0,1,0),hash33(pi+vec3(0,1,0))),
+dot(pf-vec3(1,1,0),hash33(pi+vec3(1,1,0))),
+w.x
+),
+mix(
+dot(pf-vec3(0,1,1),hash33(pi+vec3(0,1,1))),
+dot(pf-vec3(1,1,1),hash33(pi+vec3(1,1,1))),
+w.x
+),
+w.z
+),
+w.y
+);}
+#define CUSTOM_FRAGMENT_DEFINITIONS
+void main(void)
+{vec2 uv=gl_FragCoord.xy+translationSpeed;float dis=(
+1.0+perlinNoise(vec3(uv/vec2(size,size),time*0.05)*8.0))
+* (1.0+(worley(uv,32.0)+ 0.5*worley(2.0*uv,32.0)+0.25*worley(4.0*uv,32.0))
+);gl_FragColor=vec4(vec3(dis/4.0),1.0);}
+`;
+// Sideeffect
+if (!ShaderStore.ShadersStore[name]) {
+    ShaderStore.ShadersStore[name] = shader;
+}
+/** @internal */
+export const perlinNoiseProceduralTexturePixelShader = { name, shader };
+//# sourceMappingURL=perlinNoiseProceduralTexture.fragment.js.map

package/perlinNoise/perlinNoiseProceduralTexture.fragment.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"perlinNoiseProceduralTexture.fragment.js","sourceRoot":"","sources":["../../../../dev/proceduralTextures/src/perlinNoise/perlinNoiseProceduralTexture.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,4CAAiC;AAEvD,MAAM,IAAI,GAAG,yCAAyC,CAAC;AACvD,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgDd,CAAC;AACF,aAAa;AACb,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,EAAE,CAAC;IAClC,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAC5C,CAAC;AACD,gBAAgB;AAChB,MAAM,CAAC,MAAM,uCAAuC,GAAG,EAAE,IAAI,EAAE,MAAM,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))),\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#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\nif (!ShaderStore.ShadersStore[name]) {\n    ShaderStore.ShadersStore[name] = shader;\n}\n/** @internal */\nexport const perlinNoiseProceduralTexturePixelShader = { name, shader };\n"]}

package/perlinNoise/perlinNoiseProceduralTexture.js

@@ -0,0 +1,66 @@
+import { __decorate } from "@onerjs/core/tslib.es6.js";
+import { serialize } from "@onerjs/core/Misc/decorators.js";
+import { SerializationHelper } from "@onerjs/core/Misc/decorators.serialization.js";
+import { ProceduralTexture } from "@onerjs/core/Materials/Textures/Procedurals/proceduralTexture.js";
+import { RegisterClass } from "@onerjs/core/Misc/typeStore.js";
+import "./perlinNoiseProceduralTexture.fragment.js";
+export class PerlinNoiseProceduralTexture extends ProceduralTexture {
+    constructor(name, size, scene = null, fallbackTexture, generateMipMaps) {
+        super(name, size, "perlinNoiseProceduralTexture", scene, fallbackTexture, generateMipMaps);
+        this.time = 0.0;
+        this.timeScale = 1.0;
+        this.translationSpeed = 1.0;
+        this._currentTranslation = 0;
+        this.updateShaderUniforms();
+    }
+    updateShaderUniforms() {
+        this.setFloat("size", this.getRenderSize());
+        const scene = this.getScene();
+        if (!scene) {
+            return;
+        }
+        const deltaTime = scene.getEngine().getDeltaTime();
+        this.time += deltaTime;
+        this.setFloat("time", (this.time * this.timeScale) / 1000);
+        this._currentTranslation += (deltaTime * this.translationSpeed) / 1000.0;
+        this.setFloat("translationSpeed", this._currentTranslation);
+    }
+    render(useCameraPostProcess) {
+        this.updateShaderUniforms();
+        super.render(useCameraPostProcess);
+    }
+    resize(size, generateMipMaps) {
+        super.resize(size, generateMipMaps);
+    }
+    /**
+     * Serializes this perlin noise procedural texture
+     * @returns a serialized perlin noise procedural texture object
+     */
+    serialize() {
+        const serializationObject = SerializationHelper.Serialize(this, super.serialize());
+        serializationObject.customType = "BABYLON.PerlinNoiseProceduralTexture";
+        return serializationObject;
+    }
+    /**
+     * 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, scene, rootUrl) {
+        const texture = SerializationHelper.Parse(() => new PerlinNoiseProceduralTexture(parsedTexture.name, parsedTexture._size, scene, undefined, parsedTexture._generateMipMaps), parsedTexture, scene, rootUrl);
+        return texture;
+    }
+}
+__decorate([
+    serialize()
+], PerlinNoiseProceduralTexture.prototype, "time", void 0);
+__decorate([
+    serialize()
+], PerlinNoiseProceduralTexture.prototype, "timeScale", void 0);
+__decorate([
+    serialize()
+], PerlinNoiseProceduralTexture.prototype, "translationSpeed", void 0);
+RegisterClass("BABYLON.PerlinNoiseProceduralTexture", PerlinNoiseProceduralTexture);
+//# sourceMappingURL=perlinNoiseProceduralTexture.js.map

package/perlinNoise/perlinNoiseProceduralTexture.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"perlinNoiseProceduralTexture.js","sourceRoot":"","sources":["../../../../dev/proceduralTextures/src/perlinNoise/perlinNoiseProceduralTexture.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,SAAS,EAAE,wCAA6B;AACjD,OAAO,EAAE,mBAAmB,EAAE,sDAA2C;AAEzE,OAAO,EAAE,iBAAiB,EAAE,yEAA8D;AAE1F,OAAO,EAAE,aAAa,EAAE,uCAA4B;AAEpD,OAAO,yCAAyC,CAAC;AAEjD,MAAM,OAAO,4BAA6B,SAAQ,iBAAiB;IAY/D,YAAY,IAAY,EAAE,IAAY,EAAE,QAAyB,IAAI,EAAE,eAAyB,EAAE,eAAyB;QACvH,KAAK,CAAC,IAAI,EAAE,IAAI,EAAE,8BAA8B,EAAE,KAAK,EAAE,eAAe,EAAE,eAAe,CAAC,CAAC;QAXxF,SAAI,GAAW,GAAG,CAAC;QAGnB,cAAS,GAAW,GAAG,CAAC;QAGxB,qBAAgB,GAAW,GAAG,CAAC;QAE9B,wBAAmB,GAAW,CAAC,CAAC;QAIpC,IAAI,CAAC,oBAAoB,EAAE,CAAC;IAChC,CAAC;IAEM,oBAAoB;QACvB,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC,aAAa,EAAY,CAAC,CAAC;QAEtD,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;QAE9B,IAAI,CAAC,KAAK,EAAE,CAAC;YACT,OAAO;QACX,CAAC;QACD,MAAM,SAAS,GAAG,KAAK,CAAC,SAAS,EAAE,CAAC,YAAY,EAAE,CAAC;QAEnD,IAAI,CAAC,IAAI,IAAI,SAAS,CAAC;QACvB,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,IAAI,CAAC,CAAC;QAE3D,IAAI,CAAC,mBAAmB,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,gBAAgB,CAAC,GAAG,MAAM,CAAC;QACzE,IAAI,CAAC,QAAQ,CAAC,kBAAkB,EAAE,IAAI,CAAC,mBAAmB,CAAC,CAAC;IAChE,CAAC;IAEe,MAAM,CAAC,oBAA8B;QACjD,IAAI,CAAC,oBAAoB,EAAE,CAAC;QAC5B,KAAK,CAAC,MAAM,CAAC,oBAAoB,CAAC,CAAC;IACvC,CAAC;IAEe,MAAM,CAAC,IAAS,EAAE,eAAoB;QAClD,KAAK,CAAC,MAAM,CAAC,IAAI,EAAE,eAAe,CAAC,CAAC;IACxC,CAAC;IAED;;;OAGG;IACa,SAAS;QACrB,MAAM,mBAAmB,GAAG,mBAAmB,CAAC,SAAS,CAAC,IAAI,EAAE,KAAK,CAAC,SAAS,EAAE,CAAC,CAAC;QACnF,mBAAmB,CAAC,UAAU,GAAG,sCAAsC,CAAC;QAExE,OAAO,mBAAmB,CAAC;IAC/B,CAAC;IAED;;;;;;OAMG;IACI,MAAM,CAAU,KAAK,CAAC,aAAkB,EAAE,KAAY,EAAE,OAAe;QAC1E,MAAM,OAAO,GAAG,mBAAmB,CAAC,KAAK,CACrC,GAAG,EAAE,CAAC,IAAI,4BAA4B,CAAC,aAAa,CAAC,IAAI,EAAE,aAAa,CAAC,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,aAAa,CAAC,gBAAgB,CAAC,EACjI,aAAa,EACb,KAAK,EACL,OAAO,CACV,CAAC;QAEF,OAAO,OAAO,CAAC;IACnB,CAAC;CACJ;AArEU;IADN,SAAS,EAAE;0DACc;AAGnB;IADN,SAAS,EAAE;+DACmB;AAGxB;IADN,SAAS,EAAE;sEAC0B;AAiE1C,aAAa,CAAC,sCAAsC,EAAE,4BAA4B,CAAC,CAAC","sourcesContent":["import { serialize } from \"core/Misc/decorators\";\r\nimport { SerializationHelper } from \"core/Misc/decorators.serialization\";\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 \"./perlinNoiseProceduralTexture.fragment\";\r\n\r\nexport class PerlinNoiseProceduralTexture extends ProceduralTexture {\r\n    @serialize()\r\n    public time: number = 0.0;\r\n\r\n    @serialize()\r\n    public timeScale: number = 1.0;\r\n\r\n    @serialize()\r\n    public translationSpeed: number = 1.0;\r\n\r\n    private _currentTranslation: number = 0;\r\n\r\n    constructor(name: string, size: number, scene: Nullable<Scene> = null, fallbackTexture?: Texture, generateMipMaps?: boolean) {\r\n        super(name, size, \"perlinNoiseProceduralTexture\", scene, fallbackTexture, generateMipMaps);\r\n        this.updateShaderUniforms();\r\n    }\r\n\r\n    public updateShaderUniforms() {\r\n        this.setFloat(\"size\", this.getRenderSize() as number);\r\n\r\n        const scene = this.getScene();\r\n\r\n        if (!scene) {\r\n            return;\r\n        }\r\n        const deltaTime = scene.getEngine().getDeltaTime();\r\n\r\n        this.time += deltaTime;\r\n        this.setFloat(\"time\", (this.time * this.timeScale) / 1000);\r\n\r\n        this._currentTranslation += (deltaTime * this.translationSpeed) / 1000.0;\r\n        this.setFloat(\"translationSpeed\", this._currentTranslation);\r\n    }\r\n\r\n    public override render(useCameraPostProcess?: boolean) {\r\n        this.updateShaderUniforms();\r\n        super.render(useCameraPostProcess);\r\n    }\r\n\r\n    public override resize(size: any, generateMipMaps: any): void {\r\n        super.resize(size, generateMipMaps);\r\n    }\r\n\r\n    /**\r\n     * Serializes this perlin noise procedural texture\r\n     * @returns a serialized perlin noise procedural texture object\r\n     */\r\n    public override serialize(): any {\r\n        const serializationObject = SerializationHelper.Serialize(this, super.serialize());\r\n        serializationObject.customType = \"BABYLON.PerlinNoiseProceduralTexture\";\r\n\r\n        return serializationObject;\r\n    }\r\n\r\n    /**\r\n     * Creates a Perlin Noise Procedural Texture from parsed perlin noise 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 perlin noise procedural texture information\r\n     * @returns a parsed Perlin Noise Procedural Texture\r\n     */\r\n    public static override Parse(parsedTexture: any, scene: Scene, rootUrl: string): PerlinNoiseProceduralTexture {\r\n        const texture = SerializationHelper.Parse(\r\n            () => new PerlinNoiseProceduralTexture(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.PerlinNoiseProceduralTexture\", PerlinNoiseProceduralTexture);\r\n"]}

package/readme.md

@@ -0,0 +1,34 @@
+Babylon.js Procedural Textures Library
+=====================
+
+For usage documentation please visit https://doc.babylonjs.com/extensions and choose "procedural textures library".
+
+# Installation instructions
+
+To install using npm :
+
+```
+npm install --save @babylonjs/core @babylonjs/procedural-textures
+```
+
+# How to use
+
+Afterwards it can be imported to your project using:
+
+```
+import { StandardMaterial } from '@babylonjs/core/Materials/standardMaterial';
+import { FireProceduralTexture } from '@babylonjs/procedural-textures/fireProceduralTexture';
+```
+
+And used as usual:
+
+```
+// Some awesome code
+var fireMaterial = new StandardMaterial("fontainSculptur2", scene);
+var fireTexture = new FireProceduralTexture("fire", 256, scene);
+fireMaterial.diffuseTexture = fireTexture;
+fireMaterial.opacityTexture = fireTexture;
+// Some more awesome code
+```
+
+For more information you can have a look at our [ES6 dedicated documentation](https://doc.babylonjs.com/features/es6_support).

package/road/index.d.ts

@@ -0,0 +1 @@
+export * from "./roadProceduralTexture.js";

package/road/index.js

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

package/road/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../dev/proceduralTextures/src/road/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC","sourcesContent":["export * from \"./roadProceduralTexture\";\r\n"]}

package/road/roadProceduralTexture.d.ts

@@ -0,0 +1,26 @@
+import { Color3 } from "@onerjs/core/Maths/math.color.js";
+import type { Texture } from "@onerjs/core/Materials/Textures/texture.js";
+import { ProceduralTexture } from "@onerjs/core/Materials/Textures/Procedurals/proceduralTexture.js";
+import type { Scene } from "@onerjs/core/scene.js";
+import type { Nullable } from "@onerjs/core/types.js";
+import "./roadProceduralTexture.fragment.js";
+export declare class RoadProceduralTexture extends ProceduralTexture {
+    private _roadColor;
+    constructor(name: string, size: number, scene?: Nullable<Scene>, fallbackTexture?: Texture, generateMipMaps?: boolean);
+    updateShaderUniforms(): void;
+    get roadColor(): Color3;
+    set roadColor(value: Color3);
+    /**
+     * Serializes this road procedural texture
+     * @returns a serialized road procedural texture object
+     */
+    serialize(): any;
+    /**
+     * Creates a Road Procedural Texture from parsed road procedural texture data
+     * @param parsedTexture defines parsed texture data
+     * @param scene defines the current scene
+     * @param rootUrl defines the root URL containing road procedural texture information
+     * @returns a parsed Road Procedural Texture
+     */
+    static Parse(parsedTexture: any, scene: Scene, rootUrl: string): RoadProceduralTexture;
+}

package/road/roadProceduralTexture.fragment.d.ts

@@ -0,0 +1,5 @@
+/** @internal */
+export declare const roadProceduralTexturePixelShader: {
+    name: string;
+    shader: string;
+};

package/road/roadProceduralTexture.fragment.js

@@ -0,0 +1,21 @@
+// Do not edit.
+import { ShaderStore } from "@onerjs/core/Engines/shaderStore.js";
+const name = "roadProceduralTexturePixelShader";
+const shader = `precision highp float;varying vec2 vUV; 
+uniform vec3 roadColor;float rand(vec2 n) {return fract(cos(dot(n,vec2(12.9898,4.1414)))*43758.5453);}
+float noise(vec2 n) {const vec2 d=vec2(0.0,1.0);vec2 b=floor(n),f=smoothstep(vec2(0.0),vec2(1.0),fract(n));return mix(mix(rand(b),rand(b+d.yx),f.x),mix(rand(b+d.xy),rand(b+d.yy),f.x),f.y);}
+float fbm(vec2 n) {float total=0.0,amplitude=1.0;for (int i=0; i<4; i++) {total+=noise(n)*amplitude;n+=n;amplitude*=0.5;}
+return total;}
+#define CUSTOM_FRAGMENT_DEFINITIONS
+void main(void) {
+#define CUSTOM_FRAGMENT_MAIN_BEGIN
+float ratioy=mod(gl_FragCoord.y*100.0 ,fbm(vUV*2.0));vec3 color=roadColor*ratioy;gl_FragColor=vec4(color,1.0);
+#define CUSTOM_FRAGMENT_MAIN_END
+}`;
+// Sideeffect
+if (!ShaderStore.ShadersStore[name]) {
+    ShaderStore.ShadersStore[name] = shader;
+}
+/** @internal */
+export const roadProceduralTexturePixelShader = { name, shader };
+//# sourceMappingURL=roadProceduralTexture.fragment.js.map