Add Shader Watch First Step

Tools/Gulp/tasks/gulpTasks-libraries.js

@@ -5,10 +5,10 @@ var webpackStream = require("webpack-stream");
 var dtsBundle = require('dts-bundle');
 var merge2 = require("merge2");
 var path = require("path");
-var processShaders = require("../helpers/gulp-processShaders");
-var uncommentShaders = require('../helpers/gulp-removeShaderComments');
 
 // Gulp Helpers
+var processShaders = require("../helpers/gulp-processShaders");
+var uncommentShaders = require('../helpers/gulp-removeShaderComments');
 var processDeclaration = require('../helpers/gulp-processTypescriptDeclaration');
 var rmDir = require("../helpers/gulp-rmDir");
 

Tools/Gulp/tasks/gulpTasks-watch.js

@@ -2,7 +2,8 @@
 var gulp = require("gulp");
 var webpack = require('webpack');
 var webpackStream = require("webpack-stream");
-var debug = require("gulp-debug");
+var processShaders = require("../helpers/gulp-processShaders");
+var uncommentShaders = require('../helpers/gulp-removeShaderComments');
 
 // Read the full config.
 var config = require("../config.json");
@@ -27,14 +28,15 @@ gulp.task("watch", gulp.series("srcTscWatch", function startWatch() {
     var tasks = [];
 
     config.modules.map(function(module) {
-        if (config[module].build && config[module].build.webpack) {
+        var settings = config[module].build;
+        if (settings && settings.webpack) {
             for (var index = 0; index < config[module].libraries.length; index++) {
                 var library = config[module].libraries[index];
                 if (library.preventLoadLibrary) { 
                     continue;
                 }
 
-                let wpconfig = require(config[module].build.webpack);
+                let wpconfig = require(settings.webpack);
                 // watch on.
                 wpconfig.watch = true;
                 // dev mode and absolute path sourcemaps for debugging
@@ -42,8 +44,22 @@ gulp.task("watch", gulp.series("srcTscWatch", function startWatch() {
                 wpconfig.output.devtoolModuleFilenameTemplate = "[absolute-resource-path]";
                 //config.stats = "minimal";
 
-                var outputDirectory = config.build.tempDirectory + config[module].build.distOutputDirectory;
+                var outputDirectory = config.build.tempDirectory + settings.distOutputDirectory;
                 tasks.push(webpackStream(wpconfig, webpack).pipe(gulp.dest(outputDirectory)))
+
+                tasks.push(gulp.src(settings.srcDirectory + "**/*.fx")
+                    .pipe(uncommentShaders())
+                    .pipe(processShaders())
+                );
+
+                tasks.push(
+                    gulp.watch(settings.srcDirectory + "**/*.fx", { interval: 1000 }, function() {
+                        console.log(library.output + ": Shaders.");
+                        gulp.src(settings.srcDirectory + "**/*.fx")
+                            .pipe(uncommentShaders())
+                            .pipe(processShaders());
+                    })
+                );
             }
         }
     });

gui/src/3D/materials/shaders/fluent.fragment.fx.ts

@@ -0,0 +1,61 @@
+import { Effect } from "babylonjs";
+
+let name = 'fluentPixelShader';
+let shader = `precision highp float;
+varying vec2 vUV;
+uniform vec4 albedoColor;
+#ifdef INNERGLOW
+uniform vec4 innerGlowColor;
+#endif
+#ifdef BORDER
+varying vec2 scaleInfo;
+uniform float edgeSmoothingValue;
+uniform float borderMinValue;
+#endif
+#ifdef HOVERLIGHT
+varying vec3 worldPosition;
+uniform vec3 hoverPosition;
+uniform vec4 hoverColor;
+uniform float hoverRadius;
+#endif
+#ifdef TEXTURE
+uniform sampler2D albedoSampler;
+#endif
+void main(void) {
+vec3 albedo=albedoColor.rgb;
+float alpha=albedoColor.a;
+#ifdef TEXTURE
+albedo=texture2D(albedoSampler,vUV).rgb;
+#endif
+#ifdef HOVERLIGHT
+float pointToHover=(1.0-clamp(length(hoverPosition-worldPosition)/hoverRadius,0.,1.))*hoverColor.a;
+albedo=clamp(albedo+hoverColor.rgb*pointToHover,0.,1.);
+#else
+float pointToHover=1.0;
+#endif
+#ifdef BORDER 
+float borderPower=10.0;
+float inverseBorderPower=1.0/borderPower;
+vec3 borderColor=albedo*borderPower;
+vec2 distanceToEdge;
+distanceToEdge.x=abs(vUV.x-0.5)*2.0;
+distanceToEdge.y=abs(vUV.y-0.5)*2.0;
+float borderValue=max(smoothstep(scaleInfo.x-edgeSmoothingValue,scaleInfo.x+edgeSmoothingValue,distanceToEdge.x),
+smoothstep(scaleInfo.y-edgeSmoothingValue,scaleInfo.y+edgeSmoothingValue,distanceToEdge.y));
+borderColor=borderColor*borderValue*max(borderMinValue*inverseBorderPower,pointToHover); 
+albedo+=borderColor;
+alpha=max(alpha,borderValue);
+#endif
+#ifdef INNERGLOW
+
+vec2 uvGlow=(vUV-vec2(0.5,0.5))*(innerGlowColor.a*2.0);
+uvGlow=uvGlow*uvGlow;
+uvGlow=uvGlow*uvGlow;
+albedo+=mix(vec3(0.0,0.0,0.0),innerGlowColor.rgb,uvGlow.x+uvGlow.y); 
+#endif
+gl_FragColor=vec4(albedo,alpha);
+}`;
+
+Effect.ShadersStore[name] = shader;
+
+export { shader, name };

gui/src/3D/materials/shaders/fluent.vertex.fx.ts

@@ -0,0 +1,78 @@
+import { Effect } from "babylonjs";
+
+let name = 'fluentVertexShader';
+let shader = `precision highp float;
+
+attribute vec3 position;
+attribute vec3 normal;
+attribute vec2 uv;
+
+uniform mat4 world;
+uniform mat4 viewProjection;
+varying vec2 vUV;
+#ifdef BORDER
+varying vec2 scaleInfo;
+uniform float borderWidth;
+uniform vec3 scaleFactor;
+#endif
+#ifdef HOVERLIGHT
+varying vec3 worldPosition;
+#endif
+void main(void) {
+vUV=uv;
+#ifdef BORDER
+vec3 scale=scaleFactor;
+float minScale=min(min(scale.x,scale.y),scale.z);
+float maxScale=max(max(scale.x,scale.y),scale.z);
+float minOverMiddleScale=minScale/(scale.x+scale.y+scale.z-minScale-maxScale);
+float areaYZ=scale.y*scale.z;
+float areaXZ=scale.x*scale.z;
+float areaXY=scale.x*scale.y;
+float scaledBorderWidth=borderWidth; 
+if (abs(normal.x) == 1.0) 
+{
+scale.x=scale.y;
+scale.y=scale.z;
+if (areaYZ>areaXZ && areaYZ>areaXY)
+{
+scaledBorderWidth*=minOverMiddleScale;
+}
+}
+else if (abs(normal.y) == 1.0) 
+{
+scale.x=scale.z;
+if (areaXZ>areaXY && areaXZ>areaYZ)
+{
+scaledBorderWidth*=minOverMiddleScale;
+}
+}
+else 
+{
+if (areaXY>areaYZ && areaXY>areaXZ)
+{
+scaledBorderWidth*=minOverMiddleScale;
+}
+}
+float scaleRatio=min(scale.x,scale.y)/max(scale.x,scale.y);
+if (scale.x>scale.y)
+{
+scaleInfo.x=1.0-(scaledBorderWidth*scaleRatio);
+scaleInfo.y=1.0-scaledBorderWidth;
+}
+else
+{
+scaleInfo.x=1.0-scaledBorderWidth;
+scaleInfo.y=1.0-(scaledBorderWidth*scaleRatio);
+} 
+#endif 
+vec4 worldPos=world*vec4(position,1.0);
+#ifdef HOVERLIGHT
+worldPosition=worldPos.xyz;
+#endif
+gl_Position=viewProjection*worldPos;
+}
+`;
+
+Effect.ShadersStore[name] = shader;
+
+export { shader, name };

materialsLibrary/src/cell/cell.fragment.fx.ts

@@ -0,0 +1,123 @@
+import { Effect } from "babylonjs";
+
+let name = 'cellPixelShader';
+let shader = `precision highp float;
+
+uniform vec3 vEyePosition;
+uniform vec4 vDiffuseColor;
+
+varying vec3 vPositionW;
+#ifdef NORMAL
+varying vec3 vNormalW;
+#endif
+#ifdef VERTEXCOLOR
+varying vec4 vColor;
+#endif
+
+#include<helperFunctions>
+
+#include<__decl__lightFragment>[0..maxSimultaneousLights]
+#include<lightsFragmentFunctions>
+#include<shadowsFragmentFunctions>
+
+#ifdef DIFFUSE
+varying vec2 vDiffuseUV;
+uniform sampler2D diffuseSampler;
+uniform vec2 vDiffuseInfos;
+#endif
+#include<clipPlaneFragmentDeclaration>
+
+#include<fogFragmentDeclaration>
+
+vec3 computeCustomDiffuseLighting(lightingInfo info,vec3 diffuseBase,float shadow)
+{
+diffuseBase=info.diffuse*shadow;
+#ifdef CELLBASIC
+float level=1.0;
+if (info.ndl<0.5)
+level=0.5;
+diffuseBase.rgb*vec3(level,level,level);
+#else
+float ToonThresholds[4];
+ToonThresholds[0]=0.95;
+ToonThresholds[1]=0.5;
+ToonThresholds[2]=0.2;
+ToonThresholds[3]=0.03;
+float ToonBrightnessLevels[5];
+ToonBrightnessLevels[0]=1.0;
+ToonBrightnessLevels[1]=0.8;
+ToonBrightnessLevels[2]=0.6;
+ToonBrightnessLevels[3]=0.35;
+ToonBrightnessLevels[4]=0.2;
+if (info.ndl>ToonThresholds[0])
+{
+diffuseBase.rgb*=ToonBrightnessLevels[0];
+}
+else if (info.ndl>ToonThresholds[1])
+{
+diffuseBase.rgb*=ToonBrightnessLevels[1];
+}
+else if (info.ndl>ToonThresholds[2])
+{
+diffuseBase.rgb*=ToonBrightnessLevels[2];
+}
+else if (info.ndl>ToonThresholds[3])
+{
+diffuseBase.rgb*=ToonBrightnessLevels[3];
+}
+else
+{
+diffuseBase.rgb*=ToonBrightnessLevels[4];
+}
+#endif
+return max(diffuseBase,vec3(0.2));
+}
+void main(void)
+{
+#include<clipPlaneFragment>
+vec3 viewDirectionW=normalize(vEyePosition-vPositionW);
+
+vec4 baseColor=vec4(1.,1.,1.,1.);
+vec3 diffuseColor=vDiffuseColor.rgb;
+
+float alpha=vDiffuseColor.a;
+#ifdef DIFFUSE
+baseColor=texture2D(diffuseSampler,vDiffuseUV);
+#ifdef ALPHATEST
+if (baseColor.a<0.4)
+discard;
+#endif
+#include<depthPrePass>
+baseColor.rgb*=vDiffuseInfos.y;
+#endif
+#ifdef VERTEXCOLOR
+baseColor.rgb*=vColor.rgb;
+#endif
+
+#ifdef NORMAL
+vec3 normalW=normalize(vNormalW);
+#else
+vec3 normalW=vec3(1.0,1.0,1.0);
+#endif
+
+lightingInfo info;
+vec3 diffuseBase=vec3(0.,0.,0.);
+float shadow=1.;
+float glossiness=0.;
+#ifdef SPECULARTERM
+vec3 specularBase=vec3(0.,0.,0.);
+#endif 
+#include<lightFragment>[0..maxSimultaneousLights]
+#ifdef VERTEXALPHA
+alpha*=vColor.a;
+#endif
+vec3 finalDiffuse=clamp(diffuseBase*diffuseColor,0.0,1.0)*baseColor.rgb;
+
+vec4 color=vec4(finalDiffuse,alpha);
+#include<fogFragment>
+gl_FragColor=color;
+}`;
+
+Effect.ShadersStore[name] = shader;
+
+export { shader, name };

materialsLibrary/src/cell/cell.vertex.fx.ts

@@ -0,0 +1,87 @@
+import { Effect } from "babylonjs";
+
+let name = 'cellVertexShader';
+let shader = `precision highp float;
+
+attribute vec3 position;
+#ifdef NORMAL
+attribute vec3 normal;
+#endif
+#ifdef UV1
+attribute vec2 uv;
+#endif
+#ifdef UV2
+attribute vec2 uv2;
+#endif
+#ifdef VERTEXCOLOR
+attribute vec4 color;
+#endif
+#include<bonesDeclaration>
+
+#include<instancesDeclaration>
+uniform mat4 view;
+uniform mat4 viewProjection;
+#ifdef DIFFUSE
+varying vec2 vDiffuseUV;
+uniform mat4 diffuseMatrix;
+uniform vec2 vDiffuseInfos;
+#endif
+#ifdef POINTSIZE
+uniform float pointSize;
+#endif
+
+varying vec3 vPositionW;
+#ifdef NORMAL
+varying vec3 vNormalW;
+#endif
+#ifdef VERTEXCOLOR
+varying vec4 vColor;
+#endif
+#include<clipPlaneVertexDeclaration>
+#include<fogVertexDeclaration>
+#include<__decl__lightFragment>[0..maxSimultaneousLights]
+void main(void) {
+#include<instancesVertex>
+#include<bonesVertex>
+gl_Position=viewProjection*finalWorld*vec4(position,1.0);
+vec4 worldPos=finalWorld*vec4(position,1.0);
+vPositionW=vec3(worldPos);
+#ifdef NORMAL
+vNormalW=normalize(vec3(finalWorld*vec4(normal,0.0)));
+#endif
+
+#ifndef UV1
+vec2 uv=vec2(0.,0.);
+#endif
+#ifndef UV2
+vec2 uv2=vec2(0.,0.);
+#endif
+#ifdef DIFFUSE
+if (vDiffuseInfos.x == 0.)
+{
+vDiffuseUV=vec2(diffuseMatrix*vec4(uv,1.0,0.0));
+}
+else
+{
+vDiffuseUV=vec2(diffuseMatrix*vec4(uv2,1.0,0.0));
+}
+#endif
+
+#include<clipPlaneVertex>
+
+#include<fogVertex>
+#include<shadowsVertex>[0..maxSimultaneousLights]
+
+#ifdef VERTEXCOLOR
+vColor=color;
+#endif
+
+#ifdef POINTSIZE
+gl_PointSize=pointSize;
+#endif
+}
+`;
+
+Effect.ShadersStore[name] = shader;
+
+export { shader, name };

materialsLibrary/src/fire/fire.fragment.fx.ts

@@ -0,0 +1,78 @@
+import { Effect } from "babylonjs";
+
+let name = 'firePixelShader';
+let shader = `precision highp float;
+
+uniform vec3 vEyePosition;
+
+varying vec3 vPositionW;
+#ifdef VERTEXCOLOR
+varying vec4 vColor;
+#endif
+
+#ifdef DIFFUSE
+varying vec2 vDiffuseUV;
+uniform sampler2D diffuseSampler;
+uniform vec2 vDiffuseInfos;
+#endif
+
+uniform sampler2D distortionSampler;
+uniform sampler2D opacitySampler;
+#ifdef DIFFUSE
+varying vec2 vDistortionCoords1;
+varying vec2 vDistortionCoords2;
+varying vec2 vDistortionCoords3;
+#endif
+#include<clipPlaneFragmentDeclaration>
+
+#include<fogFragmentDeclaration>
+vec4 bx2(vec4 x)
+{
+return vec4(2.0)*x-vec4(1.0);
+}
+void main(void) {
+
+#include<clipPlaneFragment>
+vec3 viewDirectionW=normalize(vEyePosition-vPositionW);
+
+vec4 baseColor=vec4(1.,1.,1.,1.);
+
+float alpha=1.0;
+#ifdef DIFFUSE
+
+const float distortionAmount0=0.092;
+const float distortionAmount1=0.092;
+const float distortionAmount2=0.092;
+vec2 heightAttenuation=vec2(0.3,0.39);
+vec4 noise0=texture2D(distortionSampler,vDistortionCoords1);
+vec4 noise1=texture2D(distortionSampler,vDistortionCoords2);
+vec4 noise2=texture2D(distortionSampler,vDistortionCoords3);
+vec4 noiseSum=bx2(noise0)*distortionAmount0+bx2(noise1)*distortionAmount1+bx2(noise2)*distortionAmount2;
+vec4 perturbedBaseCoords=vec4(vDiffuseUV,0.0,1.0)+noiseSum*(vDiffuseUV.y*heightAttenuation.x+heightAttenuation.y);
+vec4 opacityColor=texture2D(opacitySampler,perturbedBaseCoords.xy);
+#ifdef ALPHATEST
+if (opacityColor.r<0.1)
+discard;
+#endif
+#include<depthPrePass>
+baseColor=texture2D(diffuseSampler,perturbedBaseCoords.xy)*2.0;
+baseColor*=opacityColor;
+baseColor.rgb*=vDiffuseInfos.y;
+#endif
+#ifdef VERTEXCOLOR
+baseColor.rgb*=vColor.rgb;
+#endif
+
+vec3 diffuseBase=vec3(1.0,1.0,1.0);
+#ifdef VERTEXALPHA
+alpha*=vColor.a;
+#endif
+
+vec4 color=vec4(baseColor.rgb,alpha);
+#include<fogFragment>
+gl_FragColor=color;
+}`;
+
+Effect.ShadersStore[name] = shader;
+
+export { shader, name };

materialsLibrary/src/fire/fire.vertex.fx.ts

@@ -0,0 +1,80 @@
+import { Effect } from "babylonjs";
+
+let name = 'fireVertexShader';
+let shader = `precision highp float;
+
+attribute vec3 position;
+#ifdef UV1
+attribute vec2 uv;
+#endif
+#ifdef UV2
+attribute vec2 uv2;
+#endif
+#ifdef VERTEXCOLOR
+attribute vec4 color;
+#endif
+#include<bonesDeclaration>
+
+#include<instancesDeclaration>
+uniform mat4 view;
+uniform mat4 viewProjection;
+#ifdef DIFFUSE
+varying vec2 vDiffuseUV;
+#endif
+#ifdef POINTSIZE
+uniform float pointSize;
+#endif
+
+varying vec3 vPositionW;
+#ifdef VERTEXCOLOR
+varying vec4 vColor;
+#endif
+#include<clipPlaneVertexDeclaration>
+#include<fogVertexDeclaration>
+
+uniform float time;
+uniform float speed;
+#ifdef DIFFUSE
+varying vec2 vDistortionCoords1;
+varying vec2 vDistortionCoords2;
+varying vec2 vDistortionCoords3;
+#endif
+void main(void) {
+#include<instancesVertex>
+#include<bonesVertex>
+gl_Position=viewProjection*finalWorld*vec4(position,1.0);
+vec4 worldPos=finalWorld*vec4(position,1.0);
+vPositionW=vec3(worldPos);
+
+#ifdef DIFFUSE
+vDiffuseUV=uv;
+vDiffuseUV.y-=0.2;
+#endif
+
+#include<clipPlaneVertex>
+
+#include<fogVertex>
+
+#ifdef VERTEXCOLOR
+vColor=color;
+#endif
+
+#ifdef POINTSIZE
+gl_PointSize=pointSize;
+#endif
+#ifdef DIFFUSE
+
+vec3 layerSpeed=vec3(-0.2,-0.52,-0.1)*speed;
+vDistortionCoords1.x=uv.x;
+vDistortionCoords1.y=uv.y+layerSpeed.x*time/1000.0;
+vDistortionCoords2.x=uv.x;
+vDistortionCoords2.y=uv.y+layerSpeed.y*time/1000.0;
+vDistortionCoords3.x=uv.x;
+vDistortionCoords3.y=uv.y+layerSpeed.z*time/1000.0;
+#endif
+}
+`;
+
+Effect.ShadersStore[name] = shader;
+
+export { shader, name };

materialsLibrary/src/fur/fur.fragment.fx.ts

@@ -0,0 +1,106 @@
+import { Effect } from "babylonjs";
+
+let name = 'furPixelShader';
+let shader = `precision highp float;
+
+uniform vec3 vEyePosition;
+uniform vec4 vDiffuseColor;
+
+uniform vec4 furColor;
+uniform float furLength;
+varying vec3 vPositionW;
+varying float vfur_length;
+#ifdef NORMAL
+varying vec3 vNormalW;
+#endif
+#ifdef VERTEXCOLOR
+varying vec4 vColor;
+#endif
+
+#include<helperFunctions>
+
+#include<__decl__lightFragment>[0..maxSimultaneousLights]
+
+#ifdef DIFFUSE
+varying vec2 vDiffuseUV;
+uniform sampler2D diffuseSampler;
+uniform vec2 vDiffuseInfos;
+#endif
+
+#ifdef HIGHLEVEL
+uniform float furOffset;
+uniform float furOcclusion;
+uniform sampler2D furTexture;
+varying vec2 vFurUV;
+#endif
+#include<lightsFragmentFunctions>
+#include<shadowsFragmentFunctions>
+#include<fogFragmentDeclaration>
+#include<clipPlaneFragmentDeclaration>
+float Rand(vec3 rv) {
+float x=dot(rv,vec3(12.9898,78.233,24.65487));
+return fract(sin(x)*43758.5453);
+}
+void main(void) {
+
+#include<clipPlaneFragment>
+vec3 viewDirectionW=normalize(vEyePosition-vPositionW);
+
+vec4 baseColor=furColor;
+vec3 diffuseColor=vDiffuseColor.rgb;
+
+float alpha=vDiffuseColor.a;
+#ifdef DIFFUSE
+baseColor*=texture2D(diffuseSampler,vDiffuseUV);
+#ifdef ALPHATEST
+if (baseColor.a<0.4)
+discard;
+#endif
+#include<depthPrePass>
+baseColor.rgb*=vDiffuseInfos.y;
+#endif
+#ifdef VERTEXCOLOR
+baseColor.rgb*=vColor.rgb;
+#endif
+
+#ifdef NORMAL
+vec3 normalW=normalize(vNormalW);
+#else
+vec3 normalW=vec3(1.0,1.0,1.0);
+#endif
+#ifdef HIGHLEVEL
+
+vec4 furTextureColor=texture2D(furTexture,vec2(vFurUV.x,vFurUV.y));
+if (furTextureColor.a<=0.0 || furTextureColor.g<furOffset) {
+discard;
+}
+float occlusion=mix(0.0,furTextureColor.b*1.2,furOffset);
+baseColor=vec4(baseColor.xyz*max(occlusion,furOcclusion),1.1-furOffset);
+#endif
+
+vec3 diffuseBase=vec3(0.,0.,0.);
+lightingInfo info;
+float shadow=1.;
+float glossiness=0.;
+#ifdef SPECULARTERM
+vec3 specularBase=vec3(0.,0.,0.);
+#endif
+#include<lightFragment>[0..maxSimultaneousLights]
+#ifdef VERTEXALPHA
+alpha*=vColor.a;
+#endif
+vec3 finalDiffuse=clamp(diffuseBase.rgb*baseColor.rgb,0.0,1.0);
+
+#ifdef HIGHLEVEL
+vec4 color=vec4(finalDiffuse,alpha);
+#else
+float r=vfur_length/furLength*0.5;
+vec4 color=vec4(finalDiffuse*(0.5+r),alpha);
+#endif
+#include<fogFragment>
+gl_FragColor=color;
+}`;
+
+Effect.ShadersStore[name] = shader;
+
+export { shader, name };

materialsLibrary/src/fur/fur.vertex.fx.ts

@@ -0,0 +1,147 @@
+import { Effect } from "babylonjs";
+
+let name = 'furVertexShader';
+let shader = `precision highp float;
+
+attribute vec3 position;
+attribute vec3 normal;
+#ifdef UV1
+attribute vec2 uv;
+#endif
+#ifdef UV2
+attribute vec2 uv2;
+#endif
+#ifdef VERTEXCOLOR
+attribute vec4 color;
+#endif
+#include<bonesDeclaration>
+
+uniform float furLength;
+uniform float furAngle;
+#ifdef HIGHLEVEL
+uniform float furOffset;
+uniform vec3 furGravity;
+uniform float furTime;
+uniform float furSpacing;
+uniform float furDensity;
+#endif
+#ifdef HEIGHTMAP
+uniform sampler2D heightTexture;
+#endif
+#ifdef HIGHLEVEL
+varying vec2 vFurUV;
+#endif
+#include<instancesDeclaration>
+uniform mat4 view;
+uniform mat4 viewProjection;
+#ifdef DIFFUSE
+varying vec2 vDiffuseUV;
+uniform mat4 diffuseMatrix;
+uniform vec2 vDiffuseInfos;
+#endif
+#ifdef POINTSIZE
+uniform float pointSize;
+#endif
+
+varying vec3 vPositionW;
+#ifdef NORMAL
+varying vec3 vNormalW;
+#endif
+varying float vfur_length;
+#ifdef VERTEXCOLOR
+varying vec4 vColor;
+#endif
+#include<clipPlaneVertexDeclaration>
+#include<fogVertexDeclaration>
+#include<__decl__lightFragment>[0..maxSimultaneousLights]
+float Rand(vec3 rv) {
+float x=dot(rv,vec3(12.9898,78.233,24.65487));
+return fract(sin(x)*43758.5453);
+}
+void main(void) {
+#include<instancesVertex>
+#include<bonesVertex>
+
+float r=Rand(position);
+#ifdef HEIGHTMAP
+#if __VERSION__>100
+vfur_length=furLength*texture(heightTexture,uv).x;
+#else
+vfur_length=furLength*texture2D(heightTexture,uv).r;
+#endif
+#else 
+vfur_length=(furLength*r);
+#endif
+vec3 tangent1=vec3(normal.y,-normal.x,0);
+vec3 tangent2=vec3(-normal.z,0,normal.x);
+r=Rand(tangent1*r);
+float J=(2.0+4.0*r);
+r=Rand(tangent2*r);
+float K=(2.0+2.0*r);
+tangent1=tangent1*J+tangent2*K;
+tangent1=normalize(tangent1);
+vec3 newPosition=position+normal*vfur_length*cos(furAngle)+tangent1*vfur_length*sin(furAngle);
+#ifdef HIGHLEVEL
+
+vec3 forceDirection=vec3(0.0,0.0,0.0);
+forceDirection.x=sin(furTime+position.x*0.05)*0.2;
+forceDirection.y=cos(furTime*0.7+position.y*0.04)*0.2;
+forceDirection.z=sin(furTime*0.7+position.z*0.04)*0.2;
+vec3 displacement=vec3(0.0,0.0,0.0);
+displacement=furGravity+forceDirection;
+float displacementFactor=pow(furOffset,3.0);
+vec3 aNormal=normal;
+aNormal.xyz+=displacement*displacementFactor;
+newPosition=vec3(newPosition.x,newPosition.y,newPosition.z)+(normalize(aNormal)*furOffset*furSpacing);
+#endif
+#ifdef NORMAL
+vNormalW=normalize(vec3(finalWorld*vec4(normal,0.0)));
+#endif
+
+gl_Position=viewProjection*finalWorld*vec4(newPosition,1.0);
+vec4 worldPos=finalWorld*vec4(newPosition,1.0);
+vPositionW=vec3(worldPos);
+
+#ifndef UV1
+vec2 uv=vec2(0.,0.);
+#endif
+#ifndef UV2
+vec2 uv2=vec2(0.,0.);
+#endif
+#ifdef DIFFUSE
+if (vDiffuseInfos.x == 0.)
+{
+vDiffuseUV=vec2(diffuseMatrix*vec4(uv,1.0,0.0));
+}
+else
+{
+vDiffuseUV=vec2(diffuseMatrix*vec4(uv2,1.0,0.0));
+}
+#ifdef HIGHLEVEL
+vFurUV=vDiffuseUV*furDensity;
+#endif
+#else
+#ifdef HIGHLEVEL
+vFurUV=uv*furDensity;
+#endif
+#endif
+
+#include<clipPlaneVertex>
+
+#include<fogVertex>
+
+#include<shadowsVertex>[0..maxSimultaneousLights]
+
+#ifdef VERTEXCOLOR
+vColor=color;
+#endif
+
+#ifdef POINTSIZE
+gl_PointSize=pointSize;
+#endif
+}
+`;
+
+Effect.ShadersStore[name] = shader;
+
+export { shader, name };

materialsLibrary/src/gradient/gradient.fragment.fx.ts

@@ -0,0 +1,87 @@
+import { Effect } from "babylonjs";
+
+let name = 'gradientPixelShader';
+let shader = `precision highp float;
+
+uniform vec3 vEyePosition;
+uniform vec4 vDiffuseColor;
+
+uniform vec4 topColor;
+uniform vec4 bottomColor;
+uniform float offset;
+uniform float scale;
+uniform float smoothness;
+
+varying vec3 vPositionW;
+varying vec3 vPosition;
+#ifdef NORMAL
+varying vec3 vNormalW;
+#endif
+#ifdef VERTEXCOLOR
+varying vec4 vColor;
+#endif
+
+#include<helperFunctions>
+
+#include<__decl__lightFragment>[0]
+#include<__decl__lightFragment>[1]
+#include<__decl__lightFragment>[2]
+#include<__decl__lightFragment>[3]
+#include<lightsFragmentFunctions>
+#include<shadowsFragmentFunctions>
+
+#ifdef DIFFUSE
+varying vec2 vDiffuseUV;
+uniform sampler2D diffuseSampler;
+uniform vec2 vDiffuseInfos;
+#endif
+#include<clipPlaneFragmentDeclaration>
+
+#include<fogFragmentDeclaration>
+void main(void) {
+#include<clipPlaneFragment>
+vec3 viewDirectionW=normalize(vEyePosition-vPositionW);
+float h=vPosition.y*scale+offset;
+float mysmoothness=clamp(smoothness,0.01,max(smoothness,10.));
+vec4 baseColor=mix(bottomColor,topColor,max(pow(max(h,0.0),mysmoothness),0.0));
+
+vec3 diffuseColor=baseColor.rgb;
+
+float alpha=baseColor.a;
+#ifdef ALPHATEST
+if (baseColor.a<0.4)
+discard;
+#endif
+#include<depthPrePass>
+#ifdef VERTEXCOLOR
+baseColor.rgb*=vColor.rgb;
+#endif
+
+#ifdef NORMAL
+vec3 normalW=normalize(vNormalW);
+#else
+vec3 normalW=vec3(1.0,1.0,1.0);
+#endif
+
+vec3 diffuseBase=vec3(0.,0.,0.);
+lightingInfo info;
+float shadow=1.;
+float glossiness=0.;
+#include<lightFragment>[0]
+#include<lightFragment>[1]
+#include<lightFragment>[2]
+#include<lightFragment>[3]
+#ifdef VERTEXALPHA
+alpha*=vColor.a;
+#endif
+vec3 finalDiffuse=clamp(diffuseBase*diffuseColor,0.0,1.0)*baseColor.rgb;
+
+vec4 color=vec4(finalDiffuse,alpha);
+#include<fogFragment>
+gl_FragColor=color;
+}
+`;
+
+Effect.ShadersStore[name] = shader;
+
+export { shader, name };

materialsLibrary/src/gradient/gradient.vertex.fx.ts

@@ -0,0 +1,89 @@
+import { Effect } from "babylonjs";
+
+let name = 'gradientVertexShader';
+let shader = `precision highp float;
+
+attribute vec3 position;
+#ifdef NORMAL
+attribute vec3 normal;
+#endif
+#ifdef UV1
+attribute vec2 uv;
+#endif
+#ifdef UV2
+attribute vec2 uv2;
+#endif
+#ifdef VERTEXCOLOR
+attribute vec4 color;
+#endif
+#include<bonesDeclaration>
+
+#include<instancesDeclaration>
+uniform mat4 view;
+uniform mat4 viewProjection;
+#ifdef DIFFUSE
+varying vec2 vDiffuseUV;
+uniform mat4 diffuseMatrix;
+uniform vec2 vDiffuseInfos;
+#endif
+#ifdef POINTSIZE
+uniform float pointSize;
+#endif
+
+varying vec3 vPositionW;
+varying vec3 vPosition;
+#ifdef NORMAL
+varying vec3 vNormalW;
+#endif
+#ifdef VERTEXCOLOR
+varying vec4 vColor;
+#endif
+#include<clipPlaneVertexDeclaration>
+#include<fogVertexDeclaration>
+#include<__decl__lightFragment>[0..maxSimultaneousLights]
+void main(void) {
+#include<instancesVertex>
+#include<bonesVertex> 
+gl_Position=viewProjection*finalWorld*vec4(position,1.0);
+vec4 worldPos=finalWorld*vec4(position,1.0);
+vPositionW=vec3(worldPos);
+vPosition=position;
+#ifdef NORMAL
+vNormalW=normalize(vec3(finalWorld*vec4(normal,0.0)));
+#endif
+
+#ifndef UV1
+vec2 uv=vec2(0.,0.);
+#endif
+#ifndef UV2
+vec2 uv2=vec2(0.,0.);
+#endif
+#ifdef DIFFUSE
+if (vDiffuseInfos.x == 0.)
+{
+vDiffuseUV=vec2(diffuseMatrix*vec4(uv,1.0,0.0));
+}
+else
+{
+vDiffuseUV=vec2(diffuseMatrix*vec4(uv2,1.0,0.0));
+}
+#endif
+
+#include<clipPlaneVertex>
+
+#include<fogVertex>
+#include<shadowsVertex>[0..maxSimultaneousLights]
+
+#ifdef VERTEXCOLOR
+vColor=color;
+#endif
+
+#ifdef POINTSIZE
+gl_PointSize=pointSize;
+#endif
+}
+`;
+
+Effect.ShadersStore[name] = shader;
+
+export { shader, name };

materialsLibrary/src/grid/grid.fragment.fx.ts

@@ -0,0 +1,92 @@
+import { Effect } from "babylonjs";
+
+let name = 'gridPixelShader';
+let shader = `#extension GL_OES_standard_derivatives : enable
+#define SQRT2 1.41421356
+#define PI 3.14159
+precision highp float;
+uniform vec3 mainColor;
+uniform vec3 lineColor;
+uniform vec4 gridControl;
+uniform vec3 gridOffset;
+
+#ifdef TRANSPARENT
+varying vec4 vCameraSpacePosition;
+#endif
+varying vec3 vPosition;
+varying vec3 vNormal;
+#include<fogFragmentDeclaration>
+float getVisibility(float position) {
+
+float majorGridFrequency=gridControl.y;
+if (floor(position+0.5) == floor(position/majorGridFrequency+0.5)*majorGridFrequency)
+{
+return 1.0;
+} 
+return gridControl.z;
+}
+float getAnisotropicAttenuation(float differentialLength) {
+const float maxNumberOfLines=10.0;
+return clamp(1.0/(differentialLength+1.0)-1.0/maxNumberOfLines,0.0,1.0);
+}
+float isPointOnLine(float position,float differentialLength) {
+float fractionPartOfPosition=position-floor(position+0.5); 
+fractionPartOfPosition/=differentialLength; 
+fractionPartOfPosition=clamp(fractionPartOfPosition,-1.,1.);
+float result=0.5+0.5*cos(fractionPartOfPosition*PI); 
+return result; 
+}
+float contributionOnAxis(float position) {
+float differentialLength=length(vec2(dFdx(position),dFdy(position)));
+differentialLength*=SQRT2; 
+
+float result=isPointOnLine(position,differentialLength);
+
+float visibility=getVisibility(position);
+result*=visibility;
+
+float anisotropicAttenuation=getAnisotropicAttenuation(differentialLength);
+result*=anisotropicAttenuation;
+return result;
+}
+float normalImpactOnAxis(float x) {
+float normalImpact=clamp(1.0-3.0*abs(x*x*x),0.0,1.0);
+return normalImpact;
+}
+void main(void) {
+
+float gridRatio=gridControl.x;
+vec3 gridPos=(vPosition+gridOffset)/gridRatio;
+
+float x=contributionOnAxis(gridPos.x);
+float y=contributionOnAxis(gridPos.y);
+float z=contributionOnAxis(gridPos.z);
+
+vec3 normal=normalize(vNormal);
+x*=normalImpactOnAxis(normal.x);
+y*=normalImpactOnAxis(normal.y);
+z*=normalImpactOnAxis(normal.z);
+
+float grid=clamp(x+y+z,0.,1.);
+
+vec3 color=mix(mainColor,lineColor,grid);
+#ifdef FOG
+#include<fogFragment>
+#endif
+#ifdef TRANSPARENT
+float distanceToFragment=length(vCameraSpacePosition.xyz);
+float cameraPassThrough=clamp(distanceToFragment-0.25,0.0,1.0);
+float opacity=clamp(grid,0.08,cameraPassThrough*gridControl.w*grid);
+gl_FragColor=vec4(color.rgb,opacity);
+#ifdef PREMULTIPLYALPHA
+gl_FragColor.rgb*=opacity;
+#endif
+#else
+
+gl_FragColor=vec4(color.rgb,1.0);
+#endif
+}`;
+
+Effect.ShadersStore[name] = shader;
+
+export { shader, name };

materialsLibrary/src/grid/grid.vertex.fx.ts

@@ -0,0 +1,36 @@
+import { Effect } from "babylonjs";
+
+let name = 'gridVertexShader';
+let shader = `precision highp float;
+
+attribute vec3 position;
+attribute vec3 normal;
+
+uniform mat4 projection;
+uniform mat4 world;
+uniform mat4 view;
+uniform mat4 worldView;
+
+#ifdef TRANSPARENT
+varying vec4 vCameraSpacePosition;
+#endif
+varying vec3 vPosition;
+varying vec3 vNormal;
+#include<fogVertexDeclaration>
+void main(void) {
+#ifdef FOG
+vec4 worldPos=world*vec4(position,1.0);
+#endif
+#include<fogVertex>
+vec4 cameraSpacePosition=worldView*vec4(position,1.0);
+gl_Position=projection*cameraSpacePosition;
+#ifdef TRANSPARENT
+vCameraSpacePosition=cameraSpacePosition;
+#endif
+vPosition=position;
+vNormal=normal;
+}`;
+
+Effect.ShadersStore[name] = shader;
+
+export { shader, name };

materialsLibrary/src/lava/lava.fragment.fx.ts

@@ -0,0 +1,116 @@
+import { Effect } from "babylonjs";
+
+let name = 'lavaPixelShader';
+let shader = `precision highp float;
+
+uniform vec3 vEyePosition;
+uniform vec4 vDiffuseColor;
+
+varying vec3 vPositionW;
+
+uniform float time;
+uniform float speed;
+uniform float movingSpeed;
+uniform vec3 fogColor;
+uniform sampler2D noiseTexture;
+uniform float fogDensity;
+
+varying float noise;
+#ifdef NORMAL
+varying vec3 vNormalW;
+#endif
+#ifdef VERTEXCOLOR
+varying vec4 vColor;
+#endif
+
+#include<helperFunctions>
+
+#include<__decl__lightFragment>[0]
+#include<__decl__lightFragment>[1]
+#include<__decl__lightFragment>[2]
+#include<__decl__lightFragment>[3]
+#include<lightsFragmentFunctions>
+#include<shadowsFragmentFunctions>
+
+#ifdef DIFFUSE
+varying vec2 vDiffuseUV;
+uniform sampler2D diffuseSampler;
+uniform vec2 vDiffuseInfos;
+#endif
+#include<clipPlaneFragmentDeclaration>
+
+#include<fogFragmentDeclaration>
+float random( vec3 scale,float seed ){
+return fract( sin( dot( gl_FragCoord.xyz+seed,scale ) )*43758.5453+seed ) ;
+}
+void main(void) {
+#include<clipPlaneFragment>
+vec3 viewDirectionW=normalize(vEyePosition-vPositionW);
+
+vec4 baseColor=vec4(1.,1.,1.,1.);
+vec3 diffuseColor=vDiffuseColor.rgb;
+
+float alpha=vDiffuseColor.a;
+#ifdef DIFFUSE
+
+vec4 noiseTex=texture2D( noiseTexture,vDiffuseUV );
+vec2 T1=vDiffuseUV+vec2( 1.5,-1.5 )*time*0.02;
+vec2 T2=vDiffuseUV+vec2( -0.5,2.0 )*time*0.01*speed;
+T1.x+=noiseTex.x*2.0;
+T1.y+=noiseTex.y*2.0;
+T2.x-=noiseTex.y*0.2+time*0.001*movingSpeed;
+T2.y+=noiseTex.z*0.2+time*0.002*movingSpeed;
+float p=texture2D( noiseTexture,T1*3.0 ).a;
+vec4 lavaColor=texture2D( diffuseSampler,T2*4.0);
+vec4 temp=lavaColor*( vec4( p,p,p,p )*2. )+( lavaColor*lavaColor-0.1 );
+baseColor=temp;
+float depth=gl_FragCoord.z*4.0;
+const float LOG2=1.442695;
+float fogFactor=exp2(-fogDensity*fogDensity*depth*depth*LOG2 );
+fogFactor=1.0-clamp( fogFactor,0.0,1.0 );
+baseColor=mix( baseColor,vec4( fogColor,baseColor.w ),fogFactor );
+diffuseColor=baseColor.rgb;
+
+
+#ifdef ALPHATEST
+if (baseColor.a<0.4)
+discard;
+#endif
+#include<depthPrePass>
+baseColor.rgb*=vDiffuseInfos.y;
+#endif
+#ifdef VERTEXCOLOR
+baseColor.rgb*=vColor.rgb;
+#endif
+
+#ifdef NORMAL
+vec3 normalW=normalize(vNormalW);
+#else
+vec3 normalW=vec3(1.0,1.0,1.0);
+#endif
+#ifdef UNLIT
+vec3 diffuseBase=vec3(1.,1.,1.);
+#else
+
+vec3 diffuseBase=vec3(0.,0.,0.);
+lightingInfo info;
+float shadow=1.;
+float glossiness=0.;
+#include<lightFragment>[0]
+#include<lightFragment>[1]
+#include<lightFragment>[2]
+#include<lightFragment>[3]
+#endif
+#ifdef VERTEXALPHA
+alpha*=vColor.a;
+#endif
+vec3 finalDiffuse=clamp(diffuseBase*diffuseColor,0.0,1.0)*baseColor.rgb;
+
+vec4 color=vec4(finalDiffuse,alpha);
+#include<fogFragment>
+gl_FragColor=color;
+}`;
+
+Effect.ShadersStore[name] = shader;
+
+export { shader, name };

materialsLibrary/src/lava/lava.vertex.fx.ts

@@ -0,0 +1,193 @@
+import { Effect } from "babylonjs";
+
+let name = 'lavaVertexShader';
+let shader = `precision highp float;
+
+uniform float time;
+uniform float lowFrequencySpeed;
+
+varying float noise;
+
+attribute vec3 position;
+#ifdef NORMAL
+attribute vec3 normal;
+#endif
+#ifdef UV1
+attribute vec2 uv;
+#endif
+#ifdef UV2
+attribute vec2 uv2;
+#endif
+#ifdef VERTEXCOLOR
+attribute vec4 color;
+#endif
+#include<bonesDeclaration>
+
+#include<instancesDeclaration>
+uniform mat4 view;
+uniform mat4 viewProjection;
+#ifdef DIFFUSE
+varying vec2 vDiffuseUV;
+uniform mat4 diffuseMatrix;
+uniform vec2 vDiffuseInfos;
+#endif
+#ifdef POINTSIZE
+uniform float pointSize;
+#endif
+
+varying vec3 vPositionW;
+#ifdef NORMAL
+varying vec3 vNormalW;
+#endif
+#ifdef VERTEXCOLOR
+varying vec4 vColor;
+#endif
+#include<clipPlaneVertexDeclaration>
+#include<fogVertexDeclaration>
+#include<__decl__lightFragment>[0..maxSimultaneousLights]
+
+
+
+vec3 mod289(vec3 x)
+{
+return x-floor(x*(1.0/289.0))*289.0;
+}
+vec4 mod289(vec4 x)
+{
+return x-floor(x*(1.0/289.0))*289.0;
+}
+vec4 permute(vec4 x)
+{
+return mod289(((x*34.0)+1.0)*x);
+}
+vec4 taylorInvSqrt(vec4 r)
+{
+return 1.79284291400159-0.85373472095314*r;
+}
+vec3 fade(vec3 t) {
+return t*t*t*(t*(t*6.0-15.0)+10.0);
+}
+
+float pnoise(vec3 P,vec3 rep)
+{
+vec3 Pi0=mod(floor(P),rep); 
+vec3 Pi1=mod(Pi0+vec3(1.0),rep); 
+Pi0=mod289(Pi0);
+Pi1=mod289(Pi1);
+vec3 Pf0=fract(P); 
+vec3 Pf1=Pf0-vec3(1.0); 
+vec4 ix=vec4(Pi0.x,Pi1.x,Pi0.x,Pi1.x);
+vec4 iy=vec4(Pi0.yy,Pi1.yy);
+vec4 iz0=Pi0.zzzz;
+vec4 iz1=Pi1.zzzz;
+vec4 ixy=permute(permute(ix)+iy);
+vec4 ixy0=permute(ixy+iz0);
+vec4 ixy1=permute(ixy+iz1);
+vec4 gx0=ixy0*(1.0/7.0);
+vec4 gy0=fract(floor(gx0)*(1.0/7.0))-0.5;
+gx0=fract(gx0);
+vec4 gz0=vec4(0.5)-abs(gx0)-abs(gy0);
+vec4 sz0=step(gz0,vec4(0.0));
+gx0-=sz0*(step(0.0,gx0)-0.5);
+gy0-=sz0*(step(0.0,gy0)-0.5);
+vec4 gx1=ixy1*(1.0/7.0);
+vec4 gy1=fract(floor(gx1)*(1.0/7.0))-0.5;
+gx1=fract(gx1);
+vec4 gz1=vec4(0.5)-abs(gx1)-abs(gy1);
+vec4 sz1=step(gz1,vec4(0.0));
+gx1-=sz1*(step(0.0,gx1)-0.5);
+gy1-=sz1*(step(0.0,gy1)-0.5);
+vec3 g000=vec3(gx0.x,gy0.x,gz0.x);
+vec3 g100=vec3(gx0.y,gy0.y,gz0.y);
+vec3 g010=vec3(gx0.z,gy0.z,gz0.z);
+vec3 g110=vec3(gx0.w,gy0.w,gz0.w);
+vec3 g001=vec3(gx1.x,gy1.x,gz1.x);
+vec3 g101=vec3(gx1.y,gy1.y,gz1.y);
+vec3 g011=vec3(gx1.z,gy1.z,gz1.z);
+vec3 g111=vec3(gx1.w,gy1.w,gz1.w);
+vec4 norm0=taylorInvSqrt(vec4(dot(g000,g000),dot(g010,g010),dot(g100,g100),dot(g110,g110)));
+g000*=norm0.x;
+g010*=norm0.y;
+g100*=norm0.z;
+g110*=norm0.w;
+vec4 norm1=taylorInvSqrt(vec4(dot(g001,g001),dot(g011,g011),dot(g101,g101),dot(g111,g111)));
+g001*=norm1.x;
+g011*=norm1.y;
+g101*=norm1.z;
+g111*=norm1.w;
+float n000=dot(g000,Pf0);
+float n100=dot(g100,vec3(Pf1.x,Pf0.yz));
+float n010=dot(g010,vec3(Pf0.x,Pf1.y,Pf0.z));
+float n110=dot(g110,vec3(Pf1.xy,Pf0.z));
+float n001=dot(g001,vec3(Pf0.xy,Pf1.z));
+float n101=dot(g101,vec3(Pf1.x,Pf0.y,Pf1.z));
+float n011=dot(g011,vec3(Pf0.x,Pf1.yz));
+float n111=dot(g111,Pf1);
+vec3 fade_xyz=fade(Pf0);
+vec4 n_z=mix(vec4(n000,n100,n010,n110),vec4(n001,n101,n011,n111),fade_xyz.z);
+vec2 n_yz=mix(n_z.xy,n_z.zw,fade_xyz.y);
+float n_xyz=mix(n_yz.x,n_yz.y,fade_xyz.x);
+return 2.2*n_xyz;
+}
+
+float turbulence( vec3 p ) {
+float w=100.0;
+float t=-.5;
+for (float f=1.0 ; f<=10.0 ; f++ ){
+float power=pow( 2.0,f );
+t+=abs( pnoise( vec3( power*p ),vec3( 10.0,10.0,10.0 ) )/power );
+}
+return t;
+}
+void main(void) {
+#include<instancesVertex>
+#include<bonesVertex>
+#ifdef NORMAL
+
+noise=10.0*-.10*turbulence( .5*normal+time*1.15 );
+
+float b=lowFrequencySpeed*5.0*pnoise( 0.05*position +vec3(time*1.025),vec3( 100.0 ) );
+
+float displacement =-1.5*noise+b;
+
+vec3 newPosition=position+normal*displacement;
+gl_Position=viewProjection*finalWorld*vec4( newPosition,1.0 );
+vec4 worldPos=finalWorld*vec4(newPosition,1.0);
+vPositionW=vec3(worldPos);
+vNormalW=normalize(vec3(finalWorld*vec4(normal,0.0)));
+#endif
+
+#ifndef UV1
+vec2 uv=vec2(0.,0.);
+#endif
+#ifndef UV2
+vec2 uv2=vec2(0.,0.);
+#endif
+#ifdef DIFFUSE
+if (vDiffuseInfos.x == 0.)
+{
+vDiffuseUV=vec2(diffuseMatrix*vec4(uv,1.0,0.0));
+}
+else
+{
+vDiffuseUV=vec2(diffuseMatrix*vec4(uv2,1.0,0.0));
+}
+#endif
+
+#include<clipPlaneVertex>
+
+#include<fogVertex>
+#include<shadowsVertex>[0..maxSimultaneousLights]
+
+#ifdef VERTEXCOLOR
+vColor=color;
+#endif
+
+#ifdef POINTSIZE
+gl_PointSize=pointSize;
+#endif
+}`;
+
+Effect.ShadersStore[name] = shader;
+
+export { shader, name };

materialsLibrary/src/mix/mix.fragment.fx.ts

@@ -0,0 +1,134 @@
+import { Effect } from "babylonjs";
+
+let name = 'mixPixelShader';
+let shader = `precision highp float;
+
+uniform vec3 vEyePosition;
+uniform vec4 vDiffuseColor;
+#ifdef SPECULARTERM
+uniform vec4 vSpecularColor;
+#endif
+
+varying vec3 vPositionW;
+#ifdef NORMAL
+varying vec3 vNormalW;
+#endif
+#ifdef VERTEXCOLOR
+varying vec4 vColor;
+#endif
+
+#include<helperFunctions>
+
+#include<__decl__lightFragment>[0..maxSimultaneousLights]
+
+#ifdef DIFFUSE
+varying vec2 vTextureUV;
+uniform sampler2D mixMap1Sampler;
+uniform vec2 vTextureInfos;
+#ifdef MIXMAP2
+uniform sampler2D mixMap2Sampler;
+#endif
+uniform sampler2D diffuse1Sampler;
+uniform sampler2D diffuse2Sampler;
+uniform sampler2D diffuse3Sampler;
+uniform sampler2D diffuse4Sampler;
+uniform vec2 diffuse1Infos;
+uniform vec2 diffuse2Infos;
+uniform vec2 diffuse3Infos;
+uniform vec2 diffuse4Infos;
+#ifdef MIXMAP2
+uniform sampler2D diffuse5Sampler;
+uniform sampler2D diffuse6Sampler;
+uniform sampler2D diffuse7Sampler;
+uniform sampler2D diffuse8Sampler;
+uniform vec2 diffuse5Infos;
+uniform vec2 diffuse6Infos;
+uniform vec2 diffuse7Infos;
+uniform vec2 diffuse8Infos;
+#endif
+#endif
+
+#include<lightsFragmentFunctions>
+#include<shadowsFragmentFunctions>
+#include<clipPlaneFragmentDeclaration>
+
+#include<fogFragmentDeclaration>
+void main(void) {
+
+#include<clipPlaneFragment>
+vec3 viewDirectionW=normalize(vEyePosition-vPositionW);
+
+vec4 finalMixColor=vec4(1.,1.,1.,1.);
+vec3 diffuseColor=vDiffuseColor.rgb;
+#ifdef MIXMAP2
+vec4 mixColor2=vec4(1.,1.,1.,1.);
+#endif
+#ifdef SPECULARTERM
+float glossiness=vSpecularColor.a;
+vec3 specularColor=vSpecularColor.rgb;
+#else
+float glossiness=0.;
+#endif
+
+float alpha=vDiffuseColor.a;
+
+#ifdef NORMAL
+vec3 normalW=normalize(vNormalW);
+#else
+vec3 normalW=vec3(1.0,1.0,1.0);
+#endif
+#ifdef DIFFUSE
+vec4 mixColor=texture2D(mixMap1Sampler,vTextureUV);
+#include<depthPrePass>
+mixColor.rgb*=vTextureInfos.y;
+vec4 diffuse1Color=texture2D(diffuse1Sampler,vTextureUV*diffuse1Infos);
+vec4 diffuse2Color=texture2D(diffuse2Sampler,vTextureUV*diffuse2Infos);
+vec4 diffuse3Color=texture2D(diffuse3Sampler,vTextureUV*diffuse3Infos);
+vec4 diffuse4Color=texture2D(diffuse4Sampler,vTextureUV*diffuse4Infos);
+diffuse1Color.rgb*=mixColor.r;
+diffuse2Color.rgb=mix(diffuse1Color.rgb,diffuse2Color.rgb,mixColor.g);
+diffuse3Color.rgb=mix(diffuse2Color.rgb,diffuse3Color.rgb,mixColor.b);
+finalMixColor.rgb=mix(diffuse3Color.rgb,diffuse4Color.rgb,1.0-mixColor.a);
+#ifdef MIXMAP2
+mixColor=texture2D(mixMap2Sampler,vTextureUV);
+mixColor.rgb*=vTextureInfos.y;
+vec4 diffuse5Color=texture2D(diffuse5Sampler,vTextureUV*diffuse5Infos);
+vec4 diffuse6Color=texture2D(diffuse6Sampler,vTextureUV*diffuse6Infos);
+vec4 diffuse7Color=texture2D(diffuse7Sampler,vTextureUV*diffuse7Infos);
+vec4 diffuse8Color=texture2D(diffuse8Sampler,vTextureUV*diffuse8Infos);
+diffuse5Color.rgb=mix(finalMixColor.rgb,diffuse5Color.rgb,mixColor.r);
+diffuse6Color.rgb=mix(diffuse5Color.rgb,diffuse6Color.rgb,mixColor.g);
+diffuse7Color.rgb=mix(diffuse6Color.rgb,diffuse7Color.rgb,mixColor.b);
+finalMixColor.rgb=mix(diffuse7Color.rgb,diffuse8Color.rgb,1.0-mixColor.a);
+#endif
+#endif
+#ifdef VERTEXCOLOR
+finalMixColor.rgb*=vColor.rgb;
+#endif
+
+vec3 diffuseBase=vec3(0.,0.,0.);
+lightingInfo info;
+float shadow=1.;
+#ifdef SPECULARTERM
+vec3 specularBase=vec3(0.,0.,0.);
+#endif
+#include<lightFragment>[0..maxSimultaneousLights]
+#ifdef VERTEXALPHA
+alpha*=vColor.a;
+#endif
+#ifdef SPECULARTERM
+vec3 finalSpecular=specularBase*specularColor;
+#else
+vec3 finalSpecular=vec3(0.0);
+#endif
+vec3 finalDiffuse=clamp(diffuseBase*diffuseColor*finalMixColor.rgb,0.0,1.0);
+
+vec4 color=vec4(finalDiffuse+finalSpecular,alpha);
+#include<fogFragment>
+gl_FragColor=color;
+}
+`;
+
+Effect.ShadersStore[name] = shader;
+
+export { shader, name };

materialsLibrary/src/mix/mix.vertex.fx.ts

@@ -0,0 +1,88 @@
+import { Effect } from "babylonjs";
+
+let name = 'mixVertexShader';
+let shader = `precision highp float;
+
+attribute vec3 position;
+#ifdef NORMAL
+attribute vec3 normal;
+#endif
+#ifdef UV1
+attribute vec2 uv;
+#endif
+#ifdef UV2
+attribute vec2 uv2;
+#endif
+#ifdef VERTEXCOLOR
+attribute vec4 color;
+#endif
+#include<bonesDeclaration>
+
+#include<instancesDeclaration>
+uniform mat4 view;
+uniform mat4 viewProjection;
+#ifdef DIFFUSE
+varying vec2 vTextureUV;
+uniform mat4 textureMatrix;
+uniform vec2 vTextureInfos;
+#endif
+#ifdef POINTSIZE
+uniform float pointSize;
+#endif
+
+varying vec3 vPositionW;
+#ifdef NORMAL
+varying vec3 vNormalW;
+#endif
+#ifdef VERTEXCOLOR
+varying vec4 vColor;
+#endif
+#include<clipPlaneVertexDeclaration>
+#include<fogVertexDeclaration>
+#include<__decl__lightFragment>[0..maxSimultaneousLights]
+void main(void) {
+#include<instancesVertex>
+#include<bonesVertex>
+gl_Position=viewProjection*finalWorld*vec4(position,1.0);
+vec4 worldPos=finalWorld*vec4(position,1.0);
+vPositionW=vec3(worldPos);
+#ifdef NORMAL
+vNormalW=normalize(vec3(finalWorld*vec4(normal,0.0)));
+#endif
+
+#ifndef UV1
+vec2 uv=vec2(0.,0.);
+#endif
+#ifndef UV2
+vec2 uv2=vec2(0.,0.);
+#endif
+#ifdef DIFFUSE
+if (vTextureInfos.x == 0.)
+{
+vTextureUV=vec2(textureMatrix*vec4(uv,1.0,0.0));
+}
+else
+{
+vTextureUV=vec2(textureMatrix*vec4(uv2,1.0,0.0));
+}
+#endif
+
+#include<clipPlaneVertex>
+
+#include<fogVertex>
+
+#include<shadowsVertex>[0..maxSimultaneousLights]
+
+#ifdef VERTEXCOLOR
+vColor=color;
+#endif
+
+#ifdef POINTSIZE
+gl_PointSize=pointSize;
+#endif
+}
+`;
+
+Effect.ShadersStore[name] = shader;
+
+export { shader, name };

materialsLibrary/src/normal/normal.fragment.fx.ts

@@ -0,0 +1,84 @@
+import { Effect } from "babylonjs";
+
+let name = 'normalPixelShader';
+let shader = `precision highp float;
+
+uniform vec3 vEyePosition;
+uniform vec4 vDiffuseColor;
+
+varying vec3 vPositionW;
+#ifdef NORMAL
+varying vec3 vNormalW;
+#endif
+#ifdef VERTEXCOLOR
+varying vec4 vColor;
+#endif
+
+#include<helperFunctions>
+
+#include<__decl__lightFragment>[0]
+#include<__decl__lightFragment>[1]
+#include<__decl__lightFragment>[2]
+#include<__decl__lightFragment>[3]
+#include<lightsFragmentFunctions>
+#include<shadowsFragmentFunctions>
+
+#ifdef DIFFUSE
+varying vec2 vDiffuseUV;
+uniform sampler2D diffuseSampler;
+uniform vec2 vDiffuseInfos;
+#endif
+#include<clipPlaneFragmentDeclaration>
+
+#include<fogFragmentDeclaration>
+void main(void) {
+#include<clipPlaneFragment>
+vec3 viewDirectionW=normalize(vEyePosition-vPositionW);
+
+vec4 baseColor=vec4(1.,1.,1.,1.);
+vec3 diffuseColor=vDiffuseColor.rgb;
+
+float alpha=vDiffuseColor.a;
+#ifdef DIFFUSE
+baseColor=texture2D(diffuseSampler,vDiffuseUV);
+#ifdef ALPHATEST
+if (baseColor.a<0.4)
+discard;
+#endif
+#include<depthPrePass>
+baseColor.rgb*=vDiffuseInfos.y;
+#endif
+#ifdef NORMAL
+baseColor=mix(baseColor,vec4(vNormalW,1.0),0.5);
+#endif
+#ifdef VERTEXCOLOR
+baseColor.rgb*=vColor.rgb;
+#endif
+
+#ifdef NORMAL
+vec3 normalW=normalize(vNormalW);
+#else
+vec3 normalW=vec3(1.0,1.0,1.0);
+#endif
+
+vec3 diffuseBase=vec3(0.,0.,0.);
+lightingInfo info;
+float shadow=1.;
+float glossiness=0.;
+#include<lightFragment>[0]
+#include<lightFragment>[1]
+#include<lightFragment>[2]
+#include<lightFragment>[3]
+#ifdef VERTEXALPHA
+alpha*=vColor.a;
+#endif
+vec3 finalDiffuse=clamp(diffuseBase*diffuseColor,0.0,1.0)*baseColor.rgb;
+
+vec4 color=vec4(finalDiffuse,alpha);
+#include<fogFragment>
+gl_FragColor=color;
+}`;
+
+Effect.ShadersStore[name] = shader;
+
+export { shader, name };

materialsLibrary/src/normal/normal.vertex.fx.ts

@@ -0,0 +1,87 @@
+import { Effect } from "babylonjs";
+
+let name = 'normalVertexShader';
+let shader = `precision highp float;
+
+attribute vec3 position;
+#ifdef NORMAL
+attribute vec3 normal;
+#endif
+#ifdef UV1
+attribute vec2 uv;
+#endif
+#ifdef UV2
+attribute vec2 uv2;
+#endif
+#ifdef VERTEXCOLOR
+attribute vec4 color;
+#endif
+#include<bonesDeclaration>
+
+#include<instancesDeclaration>
+uniform mat4 view;
+uniform mat4 viewProjection;
+#ifdef DIFFUSE
+varying vec2 vDiffuseUV;
+uniform mat4 diffuseMatrix;
+uniform vec2 vDiffuseInfos;
+#endif
+#ifdef POINTSIZE
+uniform float pointSize;
+#endif
+
+varying vec3 vPositionW;
+#ifdef NORMAL
+varying vec3 vNormalW;
+#endif
+#ifdef VERTEXCOLOR
+varying vec4 vColor;
+#endif
+#include<clipPlaneVertexDeclaration>
+#include<fogVertexDeclaration>
+#include<__decl__lightFragment>[0..maxSimultaneousLights]
+void main(void) {
+#include<instancesVertex>
+#include<bonesVertex>
+gl_Position=viewProjection*finalWorld*vec4(position,1.0);
+vec4 worldPos=finalWorld*vec4(position,1.0);
+vPositionW=vec3(worldPos);
+#ifdef NORMAL
+vNormalW=normalize(vec3(finalWorld*vec4(normal,0.0)));
+#endif
+
+#ifndef UV1
+vec2 uv=vec2(0.,0.);
+#endif
+#ifndef UV2
+vec2 uv2=vec2(0.,0.);
+#endif
+#ifdef DIFFUSE
+if (vDiffuseInfos.x == 0.)
+{
+vDiffuseUV=vec2(diffuseMatrix*vec4(uv,1.0,0.0));
+}
+else
+{
+vDiffuseUV=vec2(diffuseMatrix*vec4(uv2,1.0,0.0));
+}
+#endif
+
+#include<clipPlaneVertex>
+
+#include<fogVertex>
+#include<shadowsVertex>[0..maxSimultaneousLights]
+
+#ifdef VERTEXCOLOR
+vColor=color;
+#endif
+
+#ifdef POINTSIZE
+gl_PointSize=pointSize;
+#endif
+}
+`;
+
+Effect.ShadersStore[name] = shader;
+
+export { shader, name };

materialsLibrary/src/shadowOnly/shadowOnly.fragment.fx.ts

@@ -0,0 +1,46 @@
+import { Effect } from "babylonjs";
+
+let name = 'shadowOnlyPixelShader';
+let shader = `precision highp float;
+
+uniform vec3 vEyePosition;
+uniform float alpha;
+uniform vec3 shadowColor;
+
+varying vec3 vPositionW;
+#ifdef NORMAL
+varying vec3 vNormalW;
+#endif
+
+#include<helperFunctions>
+
+#include<__decl__lightFragment>[0..maxSimultaneousLights]
+#include<lightsFragmentFunctions>
+#include<shadowsFragmentFunctions>
+#include<clipPlaneFragmentDeclaration>
+
+#include<fogFragmentDeclaration>
+void main(void) {
+#include<clipPlaneFragment>
+vec3 viewDirectionW=normalize(vEyePosition-vPositionW);
+
+#ifdef NORMAL
+vec3 normalW=normalize(vNormalW);
+#else
+vec3 normalW=vec3(1.0,1.0,1.0);
+#endif
+
+vec3 diffuseBase=vec3(0.,0.,0.);
+lightingInfo info;
+float shadow=1.;
+float glossiness=0.;
+#include<lightFragment>[0..1]
+
+vec4 color=vec4(shadowColor,(1.0-clamp(shadow,0.,1.))*alpha);
+#include<fogFragment>
+gl_FragColor=color;
+}`;
+
+Effect.ShadersStore[name] = shader;
+
+export { shader, name };

materialsLibrary/src/shadowOnly/shadowOnly.vertex.fx.ts

@@ -0,0 +1,52 @@
+import { Effect } from "babylonjs";
+
+let name = 'shadowOnlyVertexShader';
+let shader = `precision highp float;
+
+attribute vec3 position;
+#ifdef NORMAL
+attribute vec3 normal;
+#endif
+#include<bonesDeclaration>
+
+#include<instancesDeclaration>
+uniform mat4 view;
+uniform mat4 viewProjection;
+#ifdef POINTSIZE
+uniform float pointSize;
+#endif
+
+varying vec3 vPositionW;
+#ifdef NORMAL
+varying vec3 vNormalW;
+#endif
+#ifdef VERTEXCOLOR
+varying vec4 vColor;
+#endif
+#include<clipPlaneVertexDeclaration>
+#include<fogVertexDeclaration>
+#include<__decl__lightFragment>[0..maxSimultaneousLights]
+void main(void) {
+#include<instancesVertex>
+#include<bonesVertex>
+gl_Position=viewProjection*finalWorld*vec4(position,1.0);
+vec4 worldPos=finalWorld*vec4(position,1.0);
+vPositionW=vec3(worldPos);
+#ifdef NORMAL
+vNormalW=normalize(vec3(finalWorld*vec4(normal,0.0)));
+#endif
+
+#include<clipPlaneVertex>
+
+#include<fogVertex>
+#include<shadowsVertex>[0..maxSimultaneousLights]
+
+#ifdef POINTSIZE
+gl_PointSize=pointSize;
+#endif
+}
+`;
+
+Effect.ShadersStore[name] = shader;
+
+export { shader, name };

materialsLibrary/src/simple/simple.fragment.fx.ts

@@ -0,0 +1,78 @@
+import { Effect } from "babylonjs";
+
+let name = 'simplePixelShader';
+let shader = `precision highp float;
+
+uniform vec3 vEyePosition;
+uniform vec4 vDiffuseColor;
+
+varying vec3 vPositionW;
+#ifdef NORMAL
+varying vec3 vNormalW;
+#endif
+#ifdef VERTEXCOLOR
+varying vec4 vColor;
+#endif
+
+#include<helperFunctions>
+
+#include<__decl__lightFragment>[0..maxSimultaneousLights]
+#include<lightsFragmentFunctions>
+#include<shadowsFragmentFunctions>
+
+#ifdef DIFFUSE
+varying vec2 vDiffuseUV;
+uniform sampler2D diffuseSampler;
+uniform vec2 vDiffuseInfos;
+#endif
+#include<clipPlaneFragmentDeclaration>
+
+#include<fogFragmentDeclaration>
+void main(void) {
+#include<clipPlaneFragment>
+vec3 viewDirectionW=normalize(vEyePosition-vPositionW);
+
+vec4 baseColor=vec4(1.,1.,1.,1.);
+vec3 diffuseColor=vDiffuseColor.rgb;
+
+float alpha=vDiffuseColor.a;
+#ifdef DIFFUSE
+baseColor=texture2D(diffuseSampler,vDiffuseUV);
+#ifdef ALPHATEST
+if (baseColor.a<0.4)
+discard;
+#endif
+#include<depthPrePass>
+baseColor.rgb*=vDiffuseInfos.y;
+#endif
+#ifdef VERTEXCOLOR
+baseColor.rgb*=vColor.rgb;
+#endif
+
+#ifdef NORMAL
+vec3 normalW=normalize(vNormalW);
+#else
+vec3 normalW=vec3(1.0,1.0,1.0);
+#endif
+
+vec3 diffuseBase=vec3(0.,0.,0.);
+lightingInfo info;
+float shadow=1.;
+float glossiness=0.;
+#ifdef SPECULARTERM
+vec3 specularBase=vec3(0.,0.,0.);
+#endif 
+#include<lightFragment>[0..maxSimultaneousLights]
+#ifdef VERTEXALPHA
+alpha*=vColor.a;
+#endif
+vec3 finalDiffuse=clamp(diffuseBase*diffuseColor,0.0,1.0)*baseColor.rgb;
+
+vec4 color=vec4(finalDiffuse,alpha);
+#include<fogFragment>
+gl_FragColor=color;
+}`;
+
+Effect.ShadersStore[name] = shader;
+
+export { shader, name };

materialsLibrary/src/simple/simple.vertex.fx.ts

@@ -0,0 +1,87 @@
+import { Effect } from "babylonjs";
+
+let name = 'simpleVertexShader';
+let shader = `precision highp float;
+
+attribute vec3 position;
+#ifdef NORMAL
+attribute vec3 normal;
+#endif
+#ifdef UV1
+attribute vec2 uv;
+#endif
+#ifdef UV2
+attribute vec2 uv2;
+#endif
+#ifdef VERTEXCOLOR
+attribute vec4 color;
+#endif
+#include<bonesDeclaration>
+
+#include<instancesDeclaration>
+uniform mat4 view;
+uniform mat4 viewProjection;
+#ifdef DIFFUSE
+varying vec2 vDiffuseUV;
+uniform mat4 diffuseMatrix;
+uniform vec2 vDiffuseInfos;
+#endif
+#ifdef POINTSIZE
+uniform float pointSize;
+#endif
+
+varying vec3 vPositionW;
+#ifdef NORMAL
+varying vec3 vNormalW;
+#endif
+#ifdef VERTEXCOLOR
+varying vec4 vColor;
+#endif
+#include<clipPlaneVertexDeclaration>
+#include<fogVertexDeclaration>
+#include<__decl__lightFragment>[0..maxSimultaneousLights]
+void main(void) {
+#include<instancesVertex>
+#include<bonesVertex>
+gl_Position=viewProjection*finalWorld*vec4(position,1.0);
+vec4 worldPos=finalWorld*vec4(position,1.0);
+vPositionW=vec3(worldPos);
+#ifdef NORMAL
+vNormalW=normalize(vec3(finalWorld*vec4(normal,0.0)));
+#endif
+
+#ifndef UV1
+vec2 uv=vec2(0.,0.);
+#endif
+#ifndef UV2
+vec2 uv2=vec2(0.,0.);
+#endif
+#ifdef DIFFUSE
+if (vDiffuseInfos.x == 0.)
+{
+vDiffuseUV=vec2(diffuseMatrix*vec4(uv,1.0,0.0));
+}
+else
+{
+vDiffuseUV=vec2(diffuseMatrix*vec4(uv2,1.0,0.0));
+}
+#endif
+
+#include<clipPlaneVertex>
+
+#include<fogVertex>
+#include<shadowsVertex>[0..maxSimultaneousLights]
+
+#ifdef VERTEXCOLOR
+vColor=color;
+#endif
+
+#ifdef POINTSIZE
+gl_PointSize=pointSize;
+#endif
+}
+`;
+
+Effect.ShadersStore[name] = shader;
+
+export { shader, name };

materialsLibrary/src/sky/sky.fragment.fx.ts

@@ -0,0 +1,133 @@
+import { Effect } from "babylonjs";
+
+let name = 'skyPixelShader';
+let shader = `precision highp float;
+
+varying vec3 vPositionW;
+#ifdef VERTEXCOLOR
+varying vec4 vColor;
+#endif
+#include<clipPlaneFragmentDeclaration>
+
+uniform vec3 cameraPosition;
+uniform float luminance;
+uniform float turbidity;
+uniform float rayleigh;
+uniform float mieCoefficient;
+uniform float mieDirectionalG;
+uniform vec3 sunPosition;
+
+#include<fogFragmentDeclaration>
+
+const float e=2.71828182845904523536028747135266249775724709369995957;
+const float pi=3.141592653589793238462643383279502884197169;
+const float n=1.0003;
+const float N=2.545E25;
+const float pn=0.035;
+const vec3 lambda=vec3(680E-9,550E-9,450E-9);
+const vec3 K=vec3(0.686,0.678,0.666);
+const float v=4.0;
+const float rayleighZenithLength=8.4E3;
+const float mieZenithLength=1.25E3;
+const vec3 up=vec3(0.0,1.0,0.0);
+const float EE=1000.0;
+const float sunAngularDiameterCos=0.999956676946448443553574619906976478926848692873900859324;
+const float cutoffAngle=pi/1.95;
+const float steepness=1.5;
+vec3 totalRayleigh(vec3 lambda)
+{
+return (8.0*pow(pi,3.0)*pow(pow(n,2.0)-1.0,2.0)*(6.0+3.0*pn))/(3.0*N*pow(lambda,vec3(4.0))*(6.0-7.0*pn));
+}
+vec3 simplifiedRayleigh()
+{
+return 0.0005/vec3(94,40,18);
+}
+float rayleighPhase(float cosTheta)
+{ 
+return (3.0/(16.0*pi))*(1.0+pow(cosTheta,2.0));
+}
+vec3 totalMie(vec3 lambda,vec3 K,float T)
+{
+float c=(0.2*T )*10E-18;
+return 0.434*c*pi*pow((2.0*pi)/lambda,vec3(v-2.0))*K;
+}
+float hgPhase(float cosTheta,float g)
+{
+return (1.0/(4.0*pi))*((1.0-pow(g,2.0))/pow(1.0-2.0*g*cosTheta+pow(g,2.0),1.5));
+}
+float sunIntensity(float zenithAngleCos)
+{
+return EE*max(0.0,1.0-exp((-(cutoffAngle-acos(zenithAngleCos))/steepness)));
+}
+float A=0.15;
+float B=0.50;
+float C=0.10;
+float D=0.20;
+float EEE=0.02;
+float F=0.30;
+float W=1000.0;
+vec3 Uncharted2Tonemap(vec3 x)
+{
+return ((x*(A*x+C*B)+D*EEE)/(x*(A*x+B)+D*F))-EEE/F;
+}
+void main(void) {
+
+#include<clipPlaneFragment>
+
+float sunfade=1.0-clamp(1.0-exp((sunPosition.y/450000.0)),0.0,1.0);
+float rayleighCoefficient=rayleigh-(1.0*(1.0-sunfade));
+vec3 sunDirection=normalize(sunPosition);
+float sunE=sunIntensity(dot(sunDirection,up));
+vec3 betaR=simplifiedRayleigh()*rayleighCoefficient;
+vec3 betaM=totalMie(lambda,K,turbidity)*mieCoefficient;
+float zenithAngle=acos(max(0.0,dot(up,normalize(vPositionW-cameraPosition))));
+float sR=rayleighZenithLength/(cos(zenithAngle)+0.15*pow(93.885-((zenithAngle*180.0)/pi),-1.253));
+float sM=mieZenithLength/(cos(zenithAngle)+0.15*pow(93.885-((zenithAngle*180.0)/pi),-1.253));
+vec3 Fex=exp(-(betaR*sR+betaM*sM));
+float cosTheta=dot(normalize(vPositionW-cameraPosition),sunDirection);
+float rPhase=rayleighPhase(cosTheta*0.5+0.5);
+vec3 betaRTheta=betaR*rPhase;
+float mPhase=hgPhase(cosTheta,mieDirectionalG);
+vec3 betaMTheta=betaM*mPhase;
+vec3 Lin=pow(sunE*((betaRTheta+betaMTheta)/(betaR+betaM))*(1.0-Fex),vec3(1.5));
+Lin*=mix(vec3(1.0),pow(sunE*((betaRTheta+betaMTheta)/(betaR+betaM))*Fex,vec3(1.0/2.0)),clamp(pow(1.0-dot(up,sunDirection),5.0),0.0,1.0));
+vec3 direction=normalize(vPositionW-cameraPosition);
+float theta=acos(direction.y);
+float phi=atan(direction.z,direction.x);
+vec2 uv=vec2(phi,theta)/vec2(2.0*pi,pi)+vec2(0.5,0.0);
+vec3 L0=vec3(0.1)*Fex;
+float sundisk=smoothstep(sunAngularDiameterCos,sunAngularDiameterCos+0.00002,cosTheta);
+L0+=(sunE*19000.0*Fex)*sundisk;
+vec3 whiteScale=1.0/Uncharted2Tonemap(vec3(W));
+vec3 texColor=(Lin+L0); 
+texColor*=0.04 ;
+texColor+=vec3(0.0,0.001,0.0025)*0.3;
+float g_fMaxLuminance=1.0;
+float fLumScaled=0.1/luminance; 
+float fLumCompressed=(fLumScaled*(1.0+(fLumScaled/(g_fMaxLuminance*g_fMaxLuminance))))/(1.0+fLumScaled); 
+float ExposureBias=fLumCompressed;
+vec3 curr=Uncharted2Tonemap((log2(2.0/pow(luminance,4.0)))*texColor);
+
+
+
+vec3 retColor=curr*whiteScale;
+
+
+float alpha=1.0;
+#ifdef VERTEXCOLOR
+retColor.rgb*=vColor.rgb;
+#endif
+#ifdef VERTEXALPHA
+alpha*=vColor.a;
+#endif
+
+vec4 color=clamp(vec4(retColor.rgb,alpha),0.0,1.0);
+
+#include<fogFragment>
+gl_FragColor=color;
+}
+`;
+
+Effect.ShadersStore[name] = shader;
+
+export { shader, name };

materialsLibrary/src/sky/sky.vertex.fx.ts

@@ -0,0 +1,45 @@
+import { Effect } from "babylonjs";
+
+let name = 'skyVertexShader';
+let shader = `precision highp float;
+
+attribute vec3 position;
+#ifdef VERTEXCOLOR
+attribute vec4 color;
+#endif
+
+uniform mat4 world;
+uniform mat4 view;
+uniform mat4 viewProjection;
+#ifdef POINTSIZE
+uniform float pointSize;
+#endif
+
+varying vec3 vPositionW;
+#ifdef VERTEXCOLOR
+varying vec4 vColor;
+#endif
+#include<clipPlaneVertexDeclaration>
+#include<fogVertexDeclaration>
+void main(void) {
+gl_Position=viewProjection*world*vec4(position,1.0);
+vec4 worldPos=world*vec4(position,1.0);
+vPositionW=vec3(worldPos);
+
+#include<clipPlaneVertex>
+
+#include<fogVertex>
+
+#ifdef VERTEXCOLOR
+vColor=color;
+#endif
+
+#ifdef POINTSIZE
+gl_PointSize=pointSize;
+#endif
+}
+`;
+
+Effect.ShadersStore[name] = shader;
+
+export { shader, name };

materialsLibrary/src/terrain/terrain.fragment.fx.ts

@@ -0,0 +1,147 @@
+import { Effect } from "babylonjs";
+
+let name = 'terrainPixelShader';
+let shader = `precision highp float;
+
+uniform vec3 vEyePosition;
+uniform vec4 vDiffuseColor;
+#ifdef SPECULARTERM
+uniform vec4 vSpecularColor;
+#endif
+
+varying vec3 vPositionW;
+#ifdef NORMAL
+varying vec3 vNormalW;
+#endif
+#ifdef VERTEXCOLOR
+varying vec4 vColor;
+#endif
+
+#include<helperFunctions>
+
+#include<__decl__lightFragment>[0..maxSimultaneousLights]
+
+#ifdef DIFFUSE
+varying vec2 vTextureUV;
+uniform sampler2D textureSampler;
+uniform vec2 vTextureInfos;
+uniform sampler2D diffuse1Sampler;
+uniform sampler2D diffuse2Sampler;
+uniform sampler2D diffuse3Sampler;
+uniform vec2 diffuse1Infos;
+uniform vec2 diffuse2Infos;
+uniform vec2 diffuse3Infos;
+#endif
+#ifdef BUMP
+uniform sampler2D bump1Sampler;
+uniform sampler2D bump2Sampler;
+uniform sampler2D bump3Sampler;
+#endif
+
+#include<lightsFragmentFunctions>
+#include<shadowsFragmentFunctions>
+#include<clipPlaneFragmentDeclaration>
+
+#include<fogFragmentDeclaration>
+
+#ifdef BUMP
+#extension GL_OES_standard_derivatives : enable
+
+mat3 cotangent_frame(vec3 normal,vec3 p,vec2 uv)
+{
+
+vec3 dp1=dFdx(p);
+vec3 dp2=dFdy(p);
+vec2 duv1=dFdx(uv);
+vec2 duv2=dFdy(uv);
+
+vec3 dp2perp=cross(dp2,normal);
+vec3 dp1perp=cross(normal,dp1);
+vec3 tangent=dp2perp*duv1.x+dp1perp*duv2.x;
+vec3 binormal=dp2perp*duv1.y+dp1perp*duv2.y;
+
+float invmax=inversesqrt(max(dot(tangent,tangent),dot(binormal,binormal)));
+return mat3(tangent*invmax,binormal*invmax,normal);
+}
+vec3 perturbNormal(vec3 viewDir,vec3 mixColor)
+{ 
+vec3 bump1Color=texture2D(bump1Sampler,vTextureUV*diffuse1Infos).xyz;
+vec3 bump2Color=texture2D(bump2Sampler,vTextureUV*diffuse2Infos).xyz;
+vec3 bump3Color=texture2D(bump3Sampler,vTextureUV*diffuse3Infos).xyz;
+bump1Color.rgb*=mixColor.r;
+bump2Color.rgb=mix(bump1Color.rgb,bump2Color.rgb,mixColor.g);
+vec3 map=mix(bump2Color.rgb,bump3Color.rgb,mixColor.b);
+map=map*255./127.-128./127.;
+mat3 TBN=cotangent_frame(vNormalW*vTextureInfos.y,-viewDir,vTextureUV);
+return normalize(TBN*map);
+}
+#endif
+void main(void) {
+
+#include<clipPlaneFragment>
+vec3 viewDirectionW=normalize(vEyePosition-vPositionW);
+
+vec4 baseColor=vec4(1.,1.,1.,1.);
+vec3 diffuseColor=vDiffuseColor.rgb;
+#ifdef SPECULARTERM
+float glossiness=vSpecularColor.a;
+vec3 specularColor=vSpecularColor.rgb;
+#else
+float glossiness=0.;
+#endif
+
+float alpha=vDiffuseColor.a;
+
+#ifdef NORMAL
+vec3 normalW=normalize(vNormalW);
+#else
+vec3 normalW=vec3(1.0,1.0,1.0);
+#endif
+#ifdef DIFFUSE
+baseColor=texture2D(textureSampler,vTextureUV);
+#if defined(BUMP) && defined(DIFFUSE)
+normalW=perturbNormal(viewDirectionW,baseColor.rgb);
+#endif
+#ifdef ALPHATEST
+if (baseColor.a<0.4)
+discard;
+#endif
+#include<depthPrePass>
+baseColor.rgb*=vTextureInfos.y;
+vec4 diffuse1Color=texture2D(diffuse1Sampler,vTextureUV*diffuse1Infos);
+vec4 diffuse2Color=texture2D(diffuse2Sampler,vTextureUV*diffuse2Infos);
+vec4 diffuse3Color=texture2D(diffuse3Sampler,vTextureUV*diffuse3Infos);
+diffuse1Color.rgb*=baseColor.r;
+diffuse2Color.rgb=mix(diffuse1Color.rgb,diffuse2Color.rgb,baseColor.g);
+baseColor.rgb=mix(diffuse2Color.rgb,diffuse3Color.rgb,baseColor.b);
+#endif
+#ifdef VERTEXCOLOR
+baseColor.rgb*=vColor.rgb;
+#endif
+
+vec3 diffuseBase=vec3(0.,0.,0.);
+lightingInfo info;
+float shadow=1.;
+#ifdef SPECULARTERM
+vec3 specularBase=vec3(0.,0.,0.);
+#endif
+#include<lightFragment>[0..maxSimultaneousLights]
+#ifdef VERTEXALPHA
+alpha*=vColor.a;
+#endif
+#ifdef SPECULARTERM
+vec3 finalSpecular=specularBase*specularColor;
+#else
+vec3 finalSpecular=vec3(0.0);
+#endif
+vec3 finalDiffuse=clamp(diffuseBase*diffuseColor*baseColor.rgb,0.0,1.0);
+
+vec4 color=vec4(finalDiffuse+finalSpecular,alpha);
+#include<fogFragment>
+gl_FragColor=color;
+}
+`;
+
+Effect.ShadersStore[name] = shader;
+
+export { shader, name };

materialsLibrary/src/terrain/terrain.vertex.fx.ts

@@ -0,0 +1,88 @@
+import { Effect } from "babylonjs";
+
+let name = 'terrainVertexShader';
+let shader = `precision highp float;
+
+attribute vec3 position;
+#ifdef NORMAL
+attribute vec3 normal;
+#endif
+#ifdef UV1
+attribute vec2 uv;
+#endif
+#ifdef UV2
+attribute vec2 uv2;
+#endif
+#ifdef VERTEXCOLOR
+attribute vec4 color;
+#endif
+#include<bonesDeclaration>
+
+#include<instancesDeclaration>
+uniform mat4 view;
+uniform mat4 viewProjection;
+#ifdef DIFFUSE
+varying vec2 vTextureUV;
+uniform mat4 textureMatrix;
+uniform vec2 vTextureInfos;
+#endif
+#ifdef POINTSIZE
+uniform float pointSize;
+#endif
+
+varying vec3 vPositionW;
+#ifdef NORMAL
+varying vec3 vNormalW;
+#endif
+#ifdef VERTEXCOLOR
+varying vec4 vColor;
+#endif
+#include<clipPlaneVertexDeclaration>
+#include<fogVertexDeclaration>
+#include<__decl__lightFragment>[0..maxSimultaneousLights]
+void main(void) {
+#include<instancesVertex>
+#include<bonesVertex>
+gl_Position=viewProjection*finalWorld*vec4(position,1.0);
+vec4 worldPos=finalWorld*vec4(position,1.0);
+vPositionW=vec3(worldPos);
+#ifdef NORMAL
+vNormalW=normalize(vec3(finalWorld*vec4(normal,0.0)));
+#endif
+
+#ifndef UV1
+vec2 uv=vec2(0.,0.);
+#endif
+#ifndef UV2
+vec2 uv2=vec2(0.,0.);
+#endif
+#ifdef DIFFUSE
+if (vTextureInfos.x == 0.)
+{
+vTextureUV=vec2(textureMatrix*vec4(uv,1.0,0.0));
+}
+else
+{
+vTextureUV=vec2(textureMatrix*vec4(uv2,1.0,0.0));
+}
+#endif
+
+#include<clipPlaneVertex>
+
+#include<fogVertex>
+
+#include<shadowsVertex>[0..maxSimultaneousLights]
+
+#ifdef VERTEXCOLOR
+vColor=color;
+#endif
+
+#ifdef POINTSIZE
+gl_PointSize=pointSize;
+#endif
+}
+`;
+
+Effect.ShadersStore[name] = shader;
+
+export { shader, name };

materialsLibrary/src/triPlanar/triplanar.fragment.fx.ts

@@ -0,0 +1,125 @@
+import { Effect } from "babylonjs";
+
+let name = 'triplanarPixelShader';
+let shader = `precision highp float;
+
+uniform vec3 vEyePosition;
+uniform vec4 vDiffuseColor;
+#ifdef SPECULARTERM
+uniform vec4 vSpecularColor;
+#endif
+
+varying vec3 vPositionW;
+#ifdef VERTEXCOLOR
+varying vec4 vColor;
+#endif
+
+#include<helperFunctions>
+
+#include<__decl__lightFragment>[0..maxSimultaneousLights]
+
+#ifdef DIFFUSEX
+varying vec2 vTextureUVX;
+uniform sampler2D diffuseSamplerX;
+#ifdef BUMPX
+uniform sampler2D normalSamplerX;
+#endif
+#endif
+#ifdef DIFFUSEY
+varying vec2 vTextureUVY;
+uniform sampler2D diffuseSamplerY;
+#ifdef BUMPY
+uniform sampler2D normalSamplerY;
+#endif
+#endif
+#ifdef DIFFUSEZ
+varying vec2 vTextureUVZ;
+uniform sampler2D diffuseSamplerZ;
+#ifdef BUMPZ
+uniform sampler2D normalSamplerZ;
+#endif
+#endif
+#ifdef NORMAL
+varying mat3 tangentSpace;
+#endif
+#include<lightsFragmentFunctions>
+#include<shadowsFragmentFunctions>
+#include<clipPlaneFragmentDeclaration>
+#include<fogFragmentDeclaration>
+void main(void) {
+
+#include<clipPlaneFragment>
+vec3 viewDirectionW=normalize(vEyePosition-vPositionW);
+
+vec4 baseColor=vec4(0.,0.,0.,1.);
+vec3 diffuseColor=vDiffuseColor.rgb;
+
+float alpha=vDiffuseColor.a;
+
+#ifdef NORMAL
+vec3 normalW=tangentSpace[2];
+#else
+vec3 normalW=vec3(1.0,1.0,1.0);
+#endif
+vec4 baseNormal=vec4(0.0,0.0,0.0,1.0);
+normalW*=normalW;
+#ifdef DIFFUSEX
+baseColor+=texture2D(diffuseSamplerX,vTextureUVX)*normalW.x;
+#ifdef BUMPX
+baseNormal+=texture2D(normalSamplerX,vTextureUVX)*normalW.x;
+#endif
+#endif
+#ifdef DIFFUSEY
+baseColor+=texture2D(diffuseSamplerY,vTextureUVY)*normalW.y;
+#ifdef BUMPY
+baseNormal+=texture2D(normalSamplerY,vTextureUVY)*normalW.y;
+#endif
+#endif
+#ifdef DIFFUSEZ
+baseColor+=texture2D(diffuseSamplerZ,vTextureUVZ)*normalW.z;
+#ifdef BUMPZ
+baseNormal+=texture2D(normalSamplerZ,vTextureUVZ)*normalW.z;
+#endif
+#endif
+#ifdef NORMAL
+normalW=normalize((2.0*baseNormal.xyz-1.0)*tangentSpace);
+#endif
+#ifdef ALPHATEST
+if (baseColor.a<0.4)
+discard;
+#endif
+#include<depthPrePass>
+#ifdef VERTEXCOLOR
+baseColor.rgb*=vColor.rgb;
+#endif
+
+vec3 diffuseBase=vec3(0.,0.,0.);
+lightingInfo info;
+float shadow=1.;
+#ifdef SPECULARTERM
+float glossiness=vSpecularColor.a;
+vec3 specularBase=vec3(0.,0.,0.);
+vec3 specularColor=vSpecularColor.rgb;
+#else
+float glossiness=0.;
+#endif
+#include<lightFragment>[0..maxSimultaneousLights]
+#ifdef VERTEXALPHA
+alpha*=vColor.a;
+#endif
+#ifdef SPECULARTERM
+vec3 finalSpecular=specularBase*specularColor;
+#else
+vec3 finalSpecular=vec3(0.0);
+#endif
+vec3 finalDiffuse=clamp(diffuseBase*diffuseColor,0.0,1.0)*baseColor.rgb;
+
+vec4 color=vec4(finalDiffuse+finalSpecular,alpha);
+#include<fogFragment>
+gl_FragColor=color;
+}
+`;
+
+Effect.ShadersStore[name] = shader;
+
+export { shader, name };

materialsLibrary/src/triPlanar/triplanar.vertex.fx.ts

@@ -0,0 +1,96 @@
+import { Effect } from "babylonjs";
+
+let name = 'triplanarVertexShader';
+let shader = `precision highp float;
+
+attribute vec3 position;
+#ifdef NORMAL
+attribute vec3 normal;
+#endif
+#ifdef VERTEXCOLOR
+attribute vec4 color;
+#endif
+#include<bonesDeclaration>
+
+#include<instancesDeclaration>
+uniform mat4 view;
+uniform mat4 viewProjection;
+#ifdef DIFFUSEX
+varying vec2 vTextureUVX;
+#endif
+#ifdef DIFFUSEY
+varying vec2 vTextureUVY;
+#endif
+#ifdef DIFFUSEZ
+varying vec2 vTextureUVZ;
+#endif
+uniform float tileSize;
+#ifdef POINTSIZE
+uniform float pointSize;
+#endif
+
+varying vec3 vPositionW;
+#ifdef NORMAL
+varying mat3 tangentSpace;
+#endif
+#ifdef VERTEXCOLOR
+varying vec4 vColor;
+#endif
+#include<clipPlaneVertexDeclaration>
+#include<fogVertexDeclaration>
+#include<__decl__lightFragment>[0..maxSimultaneousLights]
+void main(void)
+{
+#include<instancesVertex>
+#include<bonesVertex>
+gl_Position=viewProjection*finalWorld*vec4(position,1.0);
+vec4 worldPos=finalWorld*vec4(position,1.0);
+vPositionW=vec3(worldPos);
+#ifdef DIFFUSEX
+vTextureUVX=worldPos.zy/tileSize;
+#endif
+#ifdef DIFFUSEY
+vTextureUVY=worldPos.xz/tileSize;
+#endif
+#ifdef DIFFUSEZ
+vTextureUVZ=worldPos.xy/tileSize;
+#endif
+#ifdef NORMAL
+
+vec3 xtan=vec3(0,0,1);
+vec3 xbin=vec3(0,1,0);
+vec3 ytan=vec3(1,0,0);
+vec3 ybin=vec3(0,0,1);
+vec3 ztan=vec3(1,0,0);
+vec3 zbin=vec3(0,1,0);
+vec3 normalizedNormal=normalize(normal);
+normalizedNormal*=normalizedNormal;
+vec3 worldBinormal=normalize(xbin*normalizedNormal.x+ybin*normalizedNormal.y+zbin*normalizedNormal.z);
+vec3 worldTangent=normalize(xtan*normalizedNormal.x+ytan*normalizedNormal.y+ztan*normalizedNormal.z);
+worldTangent=(world*vec4(worldTangent,1.0)).xyz;
+worldBinormal=(world*vec4(worldBinormal,1.0)).xyz;
+vec3 worldNormal=normalize(cross(worldTangent,worldBinormal));
+tangentSpace[0]=worldTangent;
+tangentSpace[1]=worldBinormal;
+tangentSpace[2]=worldNormal;
+#endif
+
+#include<clipPlaneVertex>
+
+#include<fogVertex>
+
+#include<shadowsVertex>[0..maxSimultaneousLights]
+
+#ifdef VERTEXCOLOR
+vColor=color;
+#endif
+
+#ifdef POINTSIZE
+gl_PointSize=pointSize;
+#endif
+}
+`;
+
+Effect.ShadersStore[name] = shader;
+
+export { shader, name };

materialsLibrary/src/water/water.fragment.fx.ts

@@ -0,0 +1,181 @@
+import { Effect } from "babylonjs";
+
+let name = 'waterPixelShader';
+let shader = `#ifdef LOGARITHMICDEPTH
+#extension GL_EXT_frag_depth : enable
+#endif
+precision highp float;
+
+uniform vec3 vEyePosition;
+uniform vec4 vDiffuseColor;
+#ifdef SPECULARTERM
+uniform vec4 vSpecularColor;
+#endif
+
+varying vec3 vPositionW;
+#ifdef NORMAL
+varying vec3 vNormalW;
+#endif
+#ifdef VERTEXCOLOR
+varying vec4 vColor;
+#endif
+
+#include<helperFunctions>
+
+#include<__decl__lightFragment>[0..maxSimultaneousLights]
+#include<lightsFragmentFunctions>
+#include<shadowsFragmentFunctions>
+
+#ifdef BUMP
+varying vec2 vNormalUV;
+varying vec2 vNormalUV2;
+uniform sampler2D normalSampler;
+uniform vec2 vNormalInfos;
+#endif
+uniform sampler2D refractionSampler;
+uniform sampler2D reflectionSampler;
+
+const float LOG2=1.442695;
+uniform vec3 cameraPosition;
+uniform vec4 waterColor;
+uniform float colorBlendFactor;
+uniform vec4 waterColor2;
+uniform float colorBlendFactor2;
+uniform float bumpHeight;
+uniform float time;
+
+varying vec3 vRefractionMapTexCoord;
+varying vec3 vReflectionMapTexCoord;
+varying vec3 vPosition;
+#include<clipPlaneFragmentDeclaration>
+#include<logDepthDeclaration>
+
+#include<fogFragmentDeclaration>
+void main(void) {
+
+#include<clipPlaneFragment>
+vec3 viewDirectionW=normalize(vEyePosition-vPositionW);
+
+vec4 baseColor=vec4(1.,1.,1.,1.);
+vec3 diffuseColor=vDiffuseColor.rgb;
+
+float alpha=vDiffuseColor.a;
+#ifdef BUMP
+#ifdef BUMPSUPERIMPOSE
+baseColor=0.6*texture2D(normalSampler,vNormalUV)+0.4*texture2D(normalSampler,vec2(vNormalUV2.x,vNormalUV2.y));
+#else
+baseColor=texture2D(normalSampler,vNormalUV);
+#endif
+vec3 bumpColor=baseColor.rgb;
+#ifdef ALPHATEST
+if (baseColor.a<0.4)
+discard;
+#endif
+baseColor.rgb*=vNormalInfos.y;
+#else
+vec3 bumpColor=vec3(1.0);
+#endif
+#ifdef VERTEXCOLOR
+baseColor.rgb*=vColor.rgb;
+#endif
+
+#ifdef NORMAL
+vec2 perturbation=bumpHeight*(baseColor.rg-0.5);
+#ifdef BUMPAFFECTSREFLECTION
+vec3 normalW=normalize(vNormalW+vec3(perturbation.x*8.0,0.0,perturbation.y*8.0));
+if (normalW.y<0.0) {
+normalW.y=-normalW.y;
+}
+#else
+vec3 normalW=normalize(vNormalW);
+#endif
+#else
+vec3 normalW=vec3(1.0,1.0,1.0);
+vec2 perturbation=bumpHeight*(vec2(1.0,1.0)-0.5);
+#endif
+#ifdef FRESNELSEPARATE
+#ifdef REFLECTION
+
+vec3 eyeVector=normalize(vEyePosition-vPosition);
+vec2 projectedRefractionTexCoords=clamp(vRefractionMapTexCoord.xy/vRefractionMapTexCoord.z+perturbation*0.5,0.0,1.0);
+vec4 refractiveColor=texture2D(refractionSampler,projectedRefractionTexCoords);
+vec2 projectedReflectionTexCoords=clamp(vec2(
+vReflectionMapTexCoord.x/vReflectionMapTexCoord.z+perturbation.x*0.3,
+vReflectionMapTexCoord.y/vReflectionMapTexCoord.z+perturbation.y
+),0.0,1.0);
+vec4 reflectiveColor=texture2D(reflectionSampler,projectedReflectionTexCoords);
+vec3 upVector=vec3(0.0,1.0,0.0);
+float fresnelTerm=clamp(abs(pow(dot(eyeVector,upVector),3.0)),0.05,0.65);
+float IfresnelTerm=1.0-fresnelTerm;
+refractiveColor=colorBlendFactor*waterColor+(1.0-colorBlendFactor)*refractiveColor;
+reflectiveColor=IfresnelTerm*colorBlendFactor2*waterColor+(1.0-colorBlendFactor2*IfresnelTerm)*reflectiveColor;
+vec4 combinedColor=refractiveColor*fresnelTerm+reflectiveColor*IfresnelTerm;
+baseColor=combinedColor;
+#endif
+
+vec3 diffuseBase=vec3(0.,0.,0.);
+lightingInfo info;
+float shadow=1.;
+#ifdef SPECULARTERM
+float glossiness=vSpecularColor.a;
+vec3 specularBase=vec3(0.,0.,0.);
+vec3 specularColor=vSpecularColor.rgb;
+#else
+float glossiness=0.;
+#endif
+#include<lightFragment>[0..maxSimultaneousLights]
+vec3 finalDiffuse=clamp(baseColor.rgb,0.0,1.0);
+#ifdef VERTEXALPHA
+alpha*=vColor.a;
+#endif
+#ifdef SPECULARTERM
+vec3 finalSpecular=specularBase*specularColor;
+#else
+vec3 finalSpecular=vec3(0.0);
+#endif
+#else 
+#ifdef REFLECTION
+
+vec3 eyeVector=normalize(vEyePosition-vPosition);
+vec2 projectedRefractionTexCoords=clamp(vRefractionMapTexCoord.xy/vRefractionMapTexCoord.z+perturbation,0.0,1.0);
+vec4 refractiveColor=texture2D(refractionSampler,projectedRefractionTexCoords);
+vec2 projectedReflectionTexCoords=clamp(vReflectionMapTexCoord.xy/vReflectionMapTexCoord.z+perturbation,0.0,1.0);
+vec4 reflectiveColor=texture2D(reflectionSampler,projectedReflectionTexCoords);
+vec3 upVector=vec3(0.0,1.0,0.0);
+float fresnelTerm=max(dot(eyeVector,upVector),0.0);
+vec4 combinedColor=refractiveColor*fresnelTerm+reflectiveColor*(1.0-fresnelTerm);
+baseColor=colorBlendFactor*waterColor+(1.0-colorBlendFactor)*combinedColor;
+#endif
+
+vec3 diffuseBase=vec3(0.,0.,0.);
+lightingInfo info;
+float shadow=1.;
+#ifdef SPECULARTERM
+float glossiness=vSpecularColor.a;
+vec3 specularBase=vec3(0.,0.,0.);
+vec3 specularColor=vSpecularColor.rgb;
+#else
+float glossiness=0.;
+#endif
+#include<lightFragment>[0..maxSimultaneousLights]
+vec3 finalDiffuse=clamp(baseColor.rgb,0.0,1.0);
+#ifdef VERTEXALPHA
+alpha*=vColor.a;
+#endif
+#ifdef SPECULARTERM
+vec3 finalSpecular=specularBase*specularColor;
+#else
+vec3 finalSpecular=vec3(0.0);
+#endif
+#endif
+
+vec4 color=vec4(finalDiffuse+finalSpecular,alpha);
+#include<logDepthFragment>
+#include<fogFragment>
+gl_FragColor=color;
+}
+`;
+
+Effect.ShadersStore[name] = shader;
+
+export { shader, name };

materialsLibrary/src/water/water.vertex.fx.ts

@@ -0,0 +1,127 @@
+import { Effect } from "babylonjs";
+
+let name = 'waterVertexShader';
+let shader = `precision highp float;
+
+attribute vec3 position;
+#ifdef NORMAL
+attribute vec3 normal;
+#endif
+#ifdef UV1
+attribute vec2 uv;
+#endif
+#ifdef UV2
+attribute vec2 uv2;
+#endif
+#ifdef VERTEXCOLOR
+attribute vec4 color;
+#endif
+#include<bonesDeclaration>
+
+#include<instancesDeclaration>
+uniform mat4 view;
+uniform mat4 viewProjection;
+#ifdef BUMP
+varying vec2 vNormalUV;
+#ifdef BUMPSUPERIMPOSE
+varying vec2 vNormalUV2;
+#endif
+uniform mat4 normalMatrix;
+uniform vec2 vNormalInfos;
+#endif
+#ifdef POINTSIZE
+uniform float pointSize;
+#endif
+
+varying vec3 vPositionW;
+#ifdef NORMAL
+varying vec3 vNormalW;
+#endif
+#ifdef VERTEXCOLOR
+varying vec4 vColor;
+#endif
+#include<clipPlaneVertexDeclaration>
+#include<fogVertexDeclaration>
+#include<__decl__lightFragment>[0..maxSimultaneousLights]
+#include<logDepthDeclaration>
+
+uniform mat4 worldReflectionViewProjection;
+uniform vec2 windDirection;
+uniform float waveLength;
+uniform float time;
+uniform float windForce;
+uniform float waveHeight;
+uniform float waveSpeed;
+
+varying vec3 vPosition;
+varying vec3 vRefractionMapTexCoord;
+varying vec3 vReflectionMapTexCoord;
+void main(void) {
+#include<instancesVertex>
+#include<bonesVertex>
+vec4 worldPos=finalWorld*vec4(position,1.0);
+vPositionW=vec3(worldPos);
+#ifdef NORMAL
+vNormalW=normalize(vec3(finalWorld*vec4(normal,0.0)));
+#endif
+
+#ifndef UV1
+vec2 uv=vec2(0.,0.);
+#endif
+#ifndef UV2
+vec2 uv2=vec2(0.,0.);
+#endif
+#ifdef BUMP
+if (vNormalInfos.x == 0.)
+{
+vNormalUV=vec2(normalMatrix*vec4((uv*1.0)/waveLength+time*windForce*windDirection,1.0,0.0));
+#ifdef BUMPSUPERIMPOSE
+vNormalUV2=vec2(normalMatrix*vec4((uv*0.721)/waveLength+time*1.2*windForce*windDirection,1.0,0.0));
+#endif
+}
+else
+{
+vNormalUV=vec2(normalMatrix*vec4((uv2*1.0)/waveLength+time*windForce*windDirection ,1.0,0.0));
+#ifdef BUMPSUPERIMPOSE
+vNormalUV2=vec2(normalMatrix*vec4((uv2*0.721)/waveLength+time*1.2*windForce*windDirection ,1.0,0.0));
+#endif
+}
+#endif
+
+#include<clipPlaneVertex>
+
+#include<fogVertex>
+
+#include<shadowsVertex>[0..maxSimultaneousLights]
+
+#ifdef VERTEXCOLOR
+vColor=color;
+#endif
+
+#ifdef POINTSIZE
+gl_PointSize=pointSize;
+#endif
+vec3 p=position;
+float newY=(sin(((p.x/0.05)+time*waveSpeed))*waveHeight*windDirection.x*5.0)
++(cos(((p.z/0.05)+time*waveSpeed))*waveHeight*windDirection.y*5.0);
+p.y+=abs(newY);
+gl_Position=viewProjection*finalWorld*vec4(p,1.0);
+#ifdef REFLECTION
+worldPos=viewProjection*finalWorld*vec4(p,1.0);
+
+vPosition=position;
+vRefractionMapTexCoord.x=0.5*(worldPos.w+worldPos.x);
+vRefractionMapTexCoord.y=0.5*(worldPos.w+worldPos.y);
+vRefractionMapTexCoord.z=worldPos.w;
+worldPos=worldReflectionViewProjection*vec4(position,1.0);
+vReflectionMapTexCoord.x=0.5*(worldPos.w+worldPos.x);
+vReflectionMapTexCoord.y=0.5*(worldPos.w+worldPos.y);
+vReflectionMapTexCoord.z=worldPos.w;
+#endif
+#include<logDepthVertex>
+}
+`;
+
+Effect.ShadersStore[name] = shader;
+
+export { shader, name };

postProcessLibrary/src/asciiArt/asciiart.fragment.fx.ts

@@ -0,0 +1,45 @@
+import { Effect } from "babylonjs";
+
+let name = 'asciiartPixelShader';
+let shader = `
+varying vec2 vUV;
+uniform sampler2D textureSampler;
+uniform sampler2D asciiArtFont;
+
+uniform vec4 asciiArtFontInfos;
+uniform vec4 asciiArtOptions;
+
+float getLuminance(vec3 color)
+{
+return clamp(dot(color,vec3(0.2126,0.7152,0.0722)),0.,1.);
+}
+
+void main(void) 
+{
+float caracterSize=asciiArtFontInfos.x;
+float numChar=asciiArtFontInfos.y-1.0;
+float fontx=asciiArtFontInfos.z;
+float fonty=asciiArtFontInfos.w;
+float screenx=asciiArtOptions.x;
+float screeny=asciiArtOptions.y;
+float tileX=float(floor((gl_FragCoord.x)/caracterSize))*caracterSize/screenx;
+float tileY=float(floor((gl_FragCoord.y)/caracterSize))*caracterSize/screeny;
+vec2 tileUV=vec2(tileX,tileY);
+vec4 tileColor=texture2D(textureSampler,tileUV);
+vec4 baseColor=texture2D(textureSampler,vUV);
+float tileLuminance=getLuminance(tileColor.rgb);
+float offsetx=(float(floor(tileLuminance*numChar)))*caracterSize/fontx;
+float offsety=0.0;
+float x=float(mod(gl_FragCoord.x,caracterSize))/fontx;
+float y=float(mod(gl_FragCoord.y,caracterSize))/fonty;
+vec4 finalColor=texture2D(asciiArtFont,vec2(offsetx+x,offsety+(caracterSize/fonty-y)));
+finalColor.rgb*=tileColor.rgb;
+finalColor.a=1.0;
+finalColor=mix(finalColor,tileColor,asciiArtOptions.w);
+finalColor=mix(finalColor,baseColor,asciiArtOptions.z);
+gl_FragColor=finalColor;
+}`;
+
+Effect.ShadersStore[name] = shader;
+
+export { shader, name };

postProcessLibrary/src/digitalRain/digitalrain.fragment.fx.ts

@@ -0,0 +1,53 @@
+import { Effect } from "babylonjs";
+
+let name = 'digitalrainPixelShader';
+let shader = `
+varying vec2 vUV;
+uniform sampler2D textureSampler;
+uniform sampler2D digitalRainFont;
+
+uniform vec4 digitalRainFontInfos;
+uniform vec4 digitalRainOptions;
+uniform mat4 matrixSpeed;
+uniform float cosTimeZeroOne;
+
+float getLuminance(vec3 color)
+{
+return clamp(dot(color,vec3(0.2126,0.7152,0.0722)),0.,1.);
+}
+
+void main(void) 
+{
+float caracterSize=digitalRainFontInfos.x;
+float numChar=digitalRainFontInfos.y-1.0;
+float fontx=digitalRainFontInfos.z;
+float fonty=digitalRainFontInfos.w;
+float screenx=digitalRainOptions.x;
+float screeny=digitalRainOptions.y;
+float ratio=screeny/fonty;
+float columnx=float(floor((gl_FragCoord.x)/caracterSize));
+float tileX=float(floor((gl_FragCoord.x)/caracterSize))*caracterSize/screenx;
+float tileY=float(floor((gl_FragCoord.y)/caracterSize))*caracterSize/screeny;
+vec2 tileUV=vec2(tileX,tileY);
+vec4 tileColor=texture2D(textureSampler,tileUV);
+vec4 baseColor=texture2D(textureSampler,vUV);
+float tileLuminance=getLuminance(tileColor.rgb);
+int st=int(mod(columnx,4.0));
+float speed=cosTimeZeroOne*(sin(tileX*314.5)*0.5+0.6); 
+float x=float(mod(gl_FragCoord.x,caracterSize))/fontx;
+float y=float(mod(speed+gl_FragCoord.y/screeny,1.0));
+y*=ratio;
+vec4 finalColor=texture2D(digitalRainFont,vec2(x,1.0-y));
+vec3 high=finalColor.rgb*(vec3(1.2,1.2,1.2)*pow(1.0-y,30.0));
+finalColor.rgb*=vec3(pow(tileLuminance,5.0),pow(tileLuminance,1.5),pow(tileLuminance,3.0));
+finalColor.rgb+=high;
+finalColor.rgb=clamp(finalColor.rgb,0.,1.);
+finalColor.a=1.0;
+finalColor=mix(finalColor,tileColor,digitalRainOptions.w);
+finalColor=mix(finalColor,baseColor,digitalRainOptions.z);
+gl_FragColor=finalColor;
+}`;
+
+Effect.ShadersStore[name] = shader;
+
+export { shader, name };

proceduralTexturesLibrary/src/brick/brickProceduralTexture.fragment.fx.ts

@@ -0,0 +1,64 @@
+import { Effect } from "babylonjs";
+
+let name = 'brickProceduralTexturePixelShader';
+let shader = `precision highp float;
+varying vec2 vPosition;
+varying vec2 vUV;
+uniform float numberOfBricksHeight;
+uniform float numberOfBricksWidth;
+uniform vec3 brickColor;
+uniform vec3 jointColor;
+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;
+}
+float roundF(float number){
+return sign(number)*floor(abs(number)+0.5);
+}
+void main(void)
+{
+float brickW=1.0/numberOfBricksWidth;
+float brickH=1.0/numberOfBricksHeight;
+float jointWPercentage=0.01;
+float jointHPercentage=0.05;
+vec3 color=brickColor;
+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 brickColorSwitch=mod(floor(yi)+floor(xi),3.0);
+if (brickColorSwitch == 0.0)
+color=mix(color,vec3(0.33,0.33,0.33),0.3);
+else if (brickColorSwitch == 2.0)
+color=mix(color,vec3(0.11,0.11,0.11),0.3);
+}
+gl_FragColor=vec4(color,1.0);
+}`;
+
+Effect.ShadersStore[name] = shader;
+
+export { shader, name };

proceduralTexturesLibrary/src/cloud/cloudProceduralTexture.fragment.fx.ts

@@ -0,0 +1,34 @@
+import { Effect } from "babylonjs";
+
+let name = 'cloudProceduralTexturePixelShader';
+let shader = `precision highp float;
+varying vec2 vUV;
+uniform vec4 skyColor;
+uniform vec4 cloudColor;
+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;
+}
+void main() {
+vec2 p=vUV*12.0;
+vec4 c=mix(skyColor,cloudColor,fbm(p));
+gl_FragColor=c;
+}
+`;
+
+Effect.ShadersStore[name] = shader;
+
+export { shader, name };

proceduralTexturesLibrary/src/fire/fireProceduralTexture.fragment.fx.ts

@@ -0,0 +1,45 @@
+import { Effect } from "babylonjs";
+
+let name = 'fireProceduralTexturePixelShader';
+let shader = `precision highp float;
+uniform float time;
+uniform vec3 c1;
+uniform vec3 c2;
+uniform vec3 c3;
+uniform vec3 c4;
+uniform vec3 c5;
+uniform vec3 c6;
+uniform vec2 speed;
+uniform float shift;
+uniform float alphaThreshold;
+varying vec2 vUV;
+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;
+}
+void main() {
+vec2 p=vUV*8.0;
+float q=fbm(p-time*0.1);
+vec2 r=vec2(fbm(p+q+time*speed.x-p.x-p.y),fbm(p+q-time*speed.y));
+vec3 c=mix(c1,c2,fbm(p+r))+mix(c3,c4,r.x)-mix(c5,c6,r.y);
+vec3 color=c*cos(shift*vUV.y);
+float luminance=dot(color.rgb,vec3(0.3,0.59,0.11));
+gl_FragColor=vec4(color,luminance*alphaThreshold+(1.0-alphaThreshold));
+}`;
+
+Effect.ShadersStore[name] = shader;
+
+export { shader, name };

proceduralTexturesLibrary/src/grass/grassProceduralTexture.fragment.fx.ts

@@ -0,0 +1,38 @@
+import { Effect } from "babylonjs";
+
+let name = 'grassProceduralTexturePixelShader';
+let shader = `precision highp float;
+varying vec2 vPosition;
+varying vec2 vUV;
+uniform vec3 herb1Color;
+uniform vec3 herb2Color;
+uniform vec3 herb3Color;
+uniform vec3 groundColor;
+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;
+}
+void main(void) {
+vec3 color=mix(groundColor,herb1Color,rand(gl_FragCoord.xy*4.0));
+color=mix(color,herb2Color,rand(gl_FragCoord.xy*8.0));
+color=mix(color,herb3Color,rand(gl_FragCoord.xy));
+color=mix(color,herb1Color,fbm(gl_FragCoord.xy*16.0));
+gl_FragColor=vec4(color,1.0);
+}`;
+
+Effect.ShadersStore[name] = shader;
+
+export { shader, name };

proceduralTexturesLibrary/src/marble/marbleProceduralTexture.fragment.fx.ts

@@ -0,0 +1,79 @@
+import { Effect } from "babylonjs";
+
+let name = 'marbleProceduralTexturePixelShader';
+let 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);
+}`;
+
+Effect.ShadersStore[name] = shader;
+
+export { shader, name };

proceduralTexturesLibrary/src/normalMap/normalMapProceduralTexture.fragment.fx.ts

@@ -0,0 +1,31 @@
+import { Effect } from "babylonjs";
+
+let name = 'normalMapProceduralTexturePixelShader';
+let 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);
+}
+`;
+
+Effect.ShadersStore[name] = shader;
+
+export { shader, name };

proceduralTexturesLibrary/src/perlinNoise/perlinNoiseProceduralTexture.fragment.fx.ts

@@ -0,0 +1,91 @@
+import { Effect } from "babylonjs";
+
+let name = 'perlinNoiseProceduralTexturePixelShader';
+let 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
+);
+}
+
+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);
+}
+`;
+
+Effect.ShadersStore[name] = shader;
+
+export { shader, name };

proceduralTexturesLibrary/src/road/roadProceduralTexture.fragment.fx.ts

@@ -0,0 +1,32 @@
+import { Effect } from "babylonjs";
+
+let name = 'roadProceduralTexturePixelShader';
+let 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;
+}
+void main(void) {
+float ratioy=mod(gl_FragCoord.y*100.0 ,fbm(vUV*2.0));
+vec3 color=roadColor*ratioy;
+gl_FragColor=vec4(color,1.0);
+}`;
+
+Effect.ShadersStore[name] = shader;
+
+export { shader, name };

proceduralTexturesLibrary/src/starfield/starfieldProceduralTexture.fragment.fx.ts

@@ -0,0 +1,61 @@
+import { Effect } from "babylonjs";
+
+let name = 'starfieldProceduralTexturePixelShader';
+let shader = `precision highp float;
+
+#define volsteps 20
+#define iterations 15
+varying vec2 vPosition;
+varying vec2 vUV;
+uniform float time;
+uniform float alpha;
+uniform float beta;
+uniform float zoom;
+uniform float formuparam;
+uniform float stepsize;
+uniform float tile;
+uniform float brightness;
+uniform float darkmatter;
+uniform float distfading;
+uniform float saturation;
+void main()
+{
+vec3 dir=vec3(vUV*zoom,1.);
+float localTime=time*0.0001;
+
+mat2 rot1=mat2(cos(alpha),sin(alpha),-sin(alpha),cos(alpha));
+mat2 rot2=mat2(cos(beta),sin(beta),-sin(beta),cos(beta));
+dir.xz*=rot1;
+dir.xy*=rot2;
+vec3 from=vec3(1.,.5,0.5);
+from+=vec3(-2.,localTime*2.,localTime);
+from.xz*=rot1;
+from.xy*=rot2;
+
+float s=0.1,fade=1.;
+vec3 v=vec3(0.);
+for (int r=0; r<volsteps; r++) {
+vec3 p=from+s*dir*.5;
+p=abs(vec3(tile)-mod(p,vec3(tile*2.))); 
+float pa,a=pa=0.;
+for (int i=0; i<iterations; i++) {
+p=abs(p)/dot(p,p)-formuparam; 
+a+=abs(length(p)-pa); 
+pa=length(p);
+}
+float dm=max(0.,darkmatter-a*a*.001); 
+a*=a*a; 
+if (r>6) fade*=1.-dm; 
+
+v+=fade;
+v+=vec3(s,s*s,s*s*s*s)*a*brightness*fade; 
+fade*=distfading; 
+s+=stepsize;
+}
+v=mix(vec3(length(v)),v,saturation); 
+gl_FragColor=vec4(v*.01,1.);
+}`;
+
+Effect.ShadersStore[name] = shader;
+
+export { shader, name };

proceduralTexturesLibrary/src/wood/woodProceduralTexture.fragment.fx.ts

@@ -0,0 +1,34 @@
+import { Effect } from "babylonjs";
+
+let name = 'woodProceduralTexturePixelShader';
+let shader = `precision highp float;
+varying vec2 vPosition;
+varying vec2 vUV;
+uniform float ampScale;
+uniform vec3 woodColor;
+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;
+}
+void main(void) {
+float ratioy=mod(vUV.x*ampScale,2.0+fbm(vUV*0.8));
+vec3 wood=woodColor*ratioy;
+gl_FragColor=vec4(wood,1.0);
+}`;
+
+Effect.ShadersStore[name] = shader;
+
+export { shader, name };

serializers/src/glTF/2.0/shaders/textureTransform.fragment.fx.ts

@@ -0,0 +1,15 @@
+import { Effect } from "babylonjs";
+
+let name = 'textureTransformPixelShader';
+let shader = `precision highp float;
+varying vec2 vUV;
+uniform sampler2D textureSampler;
+uniform mat4 textureTransformMat;
+void main(void) {
+vec2 uvTransformed=(textureTransformMat*vec4(vUV.xy,1,1)).xy;
+gl_FragColor=texture2D(textureSampler,uvTransformed);
+}`;
+
+Effect.ShadersStore[name] = shader;
+
+export { shader, name };