@combeenation/3d-viewer 0.0.1-types

package/dist/types/node_modules/@babylonjs/materials/terrain/terrain.fragment.d.ts

@@ -0,0 +1,7 @@
+export namespace terrainPixelShader {
+    export { name };
+    export { shader };
+}
+declare const name: "terrainPixelShader";
+declare const shader: "precision highp float;\nuniform vec4 vEyePosition;\nuniform vec4 vDiffuseColor;\n#ifdef SPECULARTERM\nuniform vec4 vSpecularColor;\n#endif\nvarying vec3 vPositionW;\n#ifdef NORMAL\nvarying vec3 vNormalW;\n#endif\n#if defined(VERTEXCOLOR) || defined(INSTANCESCOLOR) && defined(INSTANCES)\nvarying vec4 vColor;\n#endif\n#include<helperFunctions>\n#include<__decl__lightFragment>[0..maxSimultaneousLights]\n#ifdef DIFFUSE\nvarying vec2 vTextureUV;\nuniform sampler2D textureSampler;\nuniform vec2 vTextureInfos;\nuniform sampler2D diffuse1Sampler;\nuniform sampler2D diffuse2Sampler;\nuniform sampler2D diffuse3Sampler;\nuniform vec2 diffuse1Infos;\nuniform vec2 diffuse2Infos;\nuniform vec2 diffuse3Infos;\n#endif\n#ifdef BUMP\nuniform sampler2D bump1Sampler;\nuniform sampler2D bump2Sampler;\nuniform sampler2D bump3Sampler;\n#endif\n#include<lightsFragmentFunctions>\n#include<shadowsFragmentFunctions>\n#include<clipPlaneFragmentDeclaration>\n#include<fogFragmentDeclaration>\n#ifdef BUMP\n#extension GL_OES_standard_derivatives : enable\nmat3 cotangent_frame(vec3 normal,vec3 p,vec2 uv)\n{\nvec3 dp1=dFdx(p);\nvec3 dp2=dFdy(p);\nvec2 duv1=dFdx(uv);\nvec2 duv2=dFdy(uv);\nvec3 dp2perp=cross(dp2,normal);\nvec3 dp1perp=cross(normal,dp1);\nvec3 tangent=dp2perp*duv1.x+dp1perp*duv2.x;\nvec3 binormal=dp2perp*duv1.y+dp1perp*duv2.y;\nfloat invmax=inversesqrt(max(dot(tangent,tangent),dot(binormal,binormal)));\nreturn mat3(tangent*invmax,binormal*invmax,normal);\n}\nvec3 perturbNormal(vec3 viewDir,vec3 mixColor)\n{\nvec3 bump1Color=texture2D(bump1Sampler,vTextureUV*diffuse1Infos).xyz;\nvec3 bump2Color=texture2D(bump2Sampler,vTextureUV*diffuse2Infos).xyz;\nvec3 bump3Color=texture2D(bump3Sampler,vTextureUV*diffuse3Infos).xyz;\nbump1Color.rgb*=mixColor.r;\nbump2Color.rgb=mix(bump1Color.rgb,bump2Color.rgb,mixColor.g);\nvec3 map=mix(bump2Color.rgb,bump3Color.rgb,mixColor.b);\nmap=map*255./127.-128./127.;\nmat3 TBN=cotangent_frame(vNormalW*vTextureInfos.y,-viewDir,vTextureUV);\nreturn normalize(TBN*map);\n}\n#endif\n#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void) {\n#define CUSTOM_FRAGMENT_MAIN_BEGIN\n#include<clipPlaneFragment>\nvec3 viewDirectionW=normalize(vEyePosition.xyz-vPositionW);\nvec4 baseColor=vec4(1.,1.,1.,1.);\nvec3 diffuseColor=vDiffuseColor.rgb;\n#ifdef SPECULARTERM\nfloat glossiness=vSpecularColor.a;\nvec3 specularColor=vSpecularColor.rgb;\n#else\nfloat glossiness=0.;\n#endif\nfloat alpha=vDiffuseColor.a;\n#ifdef NORMAL\nvec3 normalW=normalize(vNormalW);\n#else\nvec3 normalW=vec3(1.0,1.0,1.0);\n#endif\n#ifdef DIFFUSE\nbaseColor=texture2D(textureSampler,vTextureUV);\n#if defined(BUMP) && defined(DIFFUSE)\nnormalW=perturbNormal(viewDirectionW,baseColor.rgb);\n#endif\n#ifdef ALPHATEST\nif (baseColor.a<0.4)\ndiscard;\n#endif\n#include<depthPrePass>\nbaseColor.rgb*=vTextureInfos.y;\nvec4 diffuse1Color=texture2D(diffuse1Sampler,vTextureUV*diffuse1Infos);\nvec4 diffuse2Color=texture2D(diffuse2Sampler,vTextureUV*diffuse2Infos);\nvec4 diffuse3Color=texture2D(diffuse3Sampler,vTextureUV*diffuse3Infos);\ndiffuse1Color.rgb*=baseColor.r;\ndiffuse2Color.rgb=mix(diffuse1Color.rgb,diffuse2Color.rgb,baseColor.g);\nbaseColor.rgb=mix(diffuse2Color.rgb,diffuse3Color.rgb,baseColor.b);\n#endif\n#if defined(VERTEXCOLOR) || defined(INSTANCESCOLOR) && defined(INSTANCES)\nbaseColor.rgb*=vColor.rgb;\n#endif\nvec3 diffuseBase=vec3(0.,0.,0.);\nlightingInfo info;\nfloat shadow=1.;\n#ifdef SPECULARTERM\nvec3 specularBase=vec3(0.,0.,0.);\n#endif\n#include<lightFragment>[0..maxSimultaneousLights]\n#if defined(VERTEXALPHA) || defined(INSTANCESCOLOR) && defined(INSTANCES)\nalpha*=vColor.a;\n#endif\n#ifdef SPECULARTERM\nvec3 finalSpecular=specularBase*specularColor;\n#else\nvec3 finalSpecular=vec3(0.0);\n#endif\nvec3 finalDiffuse=clamp(diffuseBase*diffuseColor*baseColor.rgb,0.0,1.0);\nvec4 color=vec4(finalDiffuse+finalSpecular,alpha);\n#include<fogFragment>\ngl_FragColor=color;\n#include<imageProcessingCompatibility>\n#define CUSTOM_FRAGMENT_MAIN_END\n}\n";
+export {};

package/dist/types/node_modules/@babylonjs/materials/terrain/terrain.vertex.d.ts

@@ -0,0 +1,7 @@
+export namespace terrainVertexShader {
+    export { name };
+    export { shader };
+}
+declare const name: "terrainVertexShader";
+declare const shader: "precision highp float;attribute vec3 position;\n#ifdef NORMAL\nattribute vec3 normal;\n#endif\n#ifdef UV1\nattribute vec2 uv;\n#endif\n#ifdef UV2\nattribute vec2 uv2;\n#endif\n#ifdef VERTEXCOLOR\nattribute vec4 color;\n#endif\n#include<bonesDeclaration>\n#include<bakedVertexAnimationDeclaration>\n#include<instancesDeclaration>\nuniform mat4 view;uniform mat4 viewProjection;\n#ifdef DIFFUSE\nvarying vec2 vTextureUV;uniform mat4 textureMatrix;uniform vec2 vTextureInfos;\n#endif\n#ifdef POINTSIZE\nuniform float pointSize;\n#endif\nvarying vec3 vPositionW;\n#ifdef NORMAL\nvarying vec3 vNormalW;\n#endif\n#if defined(VERTEXCOLOR) || defined(INSTANCESCOLOR) && defined(INSTANCES)\nvarying vec4 vColor;\n#endif\n#include<clipPlaneVertexDeclaration>\n#include<fogVertexDeclaration>\n#include<__decl__lightFragment>[0..maxSimultaneousLights]\n#define CUSTOM_VERTEX_DEFINITIONS\nvoid main(void) {\n#define CUSTOM_VERTEX_MAIN_BEGIN\n#include<instancesVertex>\n#include<bonesVertex>\n#include<bakedVertexAnimation>\nvec4 worldPos=finalWorld*vec4(position,1.0);gl_Position=viewProjection*worldPos;vPositionW=vec3(worldPos);\n#ifdef NORMAL\nvNormalW=normalize(vec3(finalWorld*vec4(normal,0.0)));\n#endif\n#ifndef UV1\nvec2 uv=vec2(0.,0.);\n#endif\n#ifndef UV2\nvec2 uv2=vec2(0.,0.);\n#endif\n#ifdef DIFFUSE\nif (vTextureInfos.x==0.)\n{vTextureUV=vec2(textureMatrix*vec4(uv,1.0,0.0));}\nelse\n{vTextureUV=vec2(textureMatrix*vec4(uv2,1.0,0.0));}\n#endif\n#include<clipPlaneVertex>\n#include<fogVertex>\n#include<shadowsVertex>[0..maxSimultaneousLights]\n#include<vertexColorMixing>\n#if defined(POINTSIZE) && !defined(WEBGPU)\ngl_PointSize=pointSize;\n#endif\n#define CUSTOM_VERTEX_MAIN_END\n}\n";
+export {};

package/dist/types/node_modules/@babylonjs/materials/terrain/terrainMaterial.d.ts

@@ -0,0 +1,18 @@
+export class TerrainMaterial extends PushMaterial {
+    static Parse(source: any, scene: any, rootUrl: any): TerrainMaterial;
+    constructor(name: any, scene: any);
+    diffuseColor: Color3;
+    specularColor: Color3;
+    specularPower: number;
+    _disableLighting: boolean;
+    _maxSimultaneousLights: number;
+    getAlphaTestTexture(): null;
+    isReadyForSubMesh(mesh: any, subMesh: any, useInstances: any): boolean;
+    bindForSubMesh(world: any, mesh: any, subMesh: any): void;
+    getAnimatables(): any[];
+    hasTexture(texture: any): boolean;
+    dispose(forceDisposeEffect: any): void;
+    clone(name: any): TerrainMaterial;
+}
+import { PushMaterial } from "@babylonjs/core/Materials/pushMaterial.js";
+import { Color3 } from "@babylonjs/core/Maths/math.color.js";

package/dist/types/node_modules/@babylonjs/materials/triPlanar/index.d.ts

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

package/dist/types/node_modules/@babylonjs/materials/triPlanar/triPlanarMaterial.d.ts

@@ -0,0 +1,19 @@
+export class TriPlanarMaterial extends PushMaterial {
+    static Parse(source: any, scene: any, rootUrl: any): TriPlanarMaterial;
+    constructor(name: any, scene: any);
+    tileSize: number;
+    diffuseColor: Color3;
+    specularColor: Color3;
+    specularPower: number;
+    _disableLighting: boolean;
+    _maxSimultaneousLights: number;
+    getAlphaTestTexture(): null;
+    isReadyForSubMesh(mesh: any, subMesh: any, useInstances: any): boolean;
+    bindForSubMesh(world: any, mesh: any, subMesh: any): void;
+    getAnimatables(): any[];
+    hasTexture(texture: any): boolean;
+    dispose(forceDisposeEffect: any): void;
+    clone(name: any): TriPlanarMaterial;
+}
+import { PushMaterial } from "@babylonjs/core/Materials/pushMaterial.js";
+import { Color3 } from "@babylonjs/core/Maths/math.color.js";

package/dist/types/node_modules/@babylonjs/materials/triPlanar/triplanar.fragment.d.ts

@@ -0,0 +1,7 @@
+export namespace triplanarPixelShader {
+    export { name };
+    export { shader };
+}
+declare const name: "triplanarPixelShader";
+declare const shader: "precision highp float;\nuniform vec4 vEyePosition;\nuniform vec4 vDiffuseColor;\n#ifdef SPECULARTERM\nuniform vec4 vSpecularColor;\n#endif\nvarying vec3 vPositionW;\n#if defined(VERTEXCOLOR) || defined(INSTANCESCOLOR) && defined(INSTANCES)\nvarying vec4 vColor;\n#endif\n#include<helperFunctions>\n#include<__decl__lightFragment>[0..maxSimultaneousLights]\n#ifdef DIFFUSEX\nvarying vec2 vTextureUVX;\nuniform sampler2D diffuseSamplerX;\n#ifdef BUMPX\nuniform sampler2D normalSamplerX;\n#endif\n#endif\n#ifdef DIFFUSEY\nvarying vec2 vTextureUVY;\nuniform sampler2D diffuseSamplerY;\n#ifdef BUMPY\nuniform sampler2D normalSamplerY;\n#endif\n#endif\n#ifdef DIFFUSEZ\nvarying vec2 vTextureUVZ;\nuniform sampler2D diffuseSamplerZ;\n#ifdef BUMPZ\nuniform sampler2D normalSamplerZ;\n#endif\n#endif\n#ifdef NORMAL\nvarying mat3 tangentSpace;\n#endif\n#include<lightsFragmentFunctions>\n#include<shadowsFragmentFunctions>\n#include<clipPlaneFragmentDeclaration>\n#include<fogFragmentDeclaration>\n#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void) {\n#define CUSTOM_FRAGMENT_MAIN_BEGIN\n#include<clipPlaneFragment>\nvec3 viewDirectionW=normalize(vEyePosition.xyz-vPositionW);\nvec4 baseColor=vec4(0.,0.,0.,1.);\nvec3 diffuseColor=vDiffuseColor.rgb;\nfloat alpha=vDiffuseColor.a;\n#ifdef NORMAL\nvec3 normalW=tangentSpace[2];\n#else\nvec3 normalW=vec3(1.0,1.0,1.0);\n#endif\nvec4 baseNormal=vec4(0.0,0.0,0.0,1.0);\nnormalW*=normalW;\n#ifdef DIFFUSEX\nbaseColor+=texture2D(diffuseSamplerX,vTextureUVX)*normalW.x;\n#ifdef BUMPX\nbaseNormal+=texture2D(normalSamplerX,vTextureUVX)*normalW.x;\n#endif\n#endif\n#ifdef DIFFUSEY\nbaseColor+=texture2D(diffuseSamplerY,vTextureUVY)*normalW.y;\n#ifdef BUMPY\nbaseNormal+=texture2D(normalSamplerY,vTextureUVY)*normalW.y;\n#endif\n#endif\n#ifdef DIFFUSEZ\nbaseColor+=texture2D(diffuseSamplerZ,vTextureUVZ)*normalW.z;\n#ifdef BUMPZ\nbaseNormal+=texture2D(normalSamplerZ,vTextureUVZ)*normalW.z;\n#endif\n#endif\n#ifdef NORMAL\nnormalW=normalize((2.0*baseNormal.xyz-1.0)*tangentSpace);\n#endif\n#ifdef ALPHATEST\nif (baseColor.a<0.4)\ndiscard;\n#endif\n#include<depthPrePass>\n#if defined(VERTEXCOLOR) || defined(INSTANCESCOLOR) && defined(INSTANCES)\nbaseColor.rgb*=vColor.rgb;\n#endif\nvec3 diffuseBase=vec3(0.,0.,0.);\nlightingInfo info;\nfloat shadow=1.;\n#ifdef SPECULARTERM\nfloat glossiness=vSpecularColor.a;\nvec3 specularBase=vec3(0.,0.,0.);\nvec3 specularColor=vSpecularColor.rgb;\n#else\nfloat glossiness=0.;\n#endif\n#include<lightFragment>[0..maxSimultaneousLights]\n#if defined(VERTEXALPHA) || defined(INSTANCESCOLOR) && defined(INSTANCES)\nalpha*=vColor.a;\n#endif\n#ifdef SPECULARTERM\nvec3 finalSpecular=specularBase*specularColor;\n#else\nvec3 finalSpecular=vec3(0.0);\n#endif\nvec3 finalDiffuse=clamp(diffuseBase*diffuseColor,0.0,1.0)*baseColor.rgb;\nvec4 color=vec4(finalDiffuse+finalSpecular,alpha);\n#include<fogFragment>\ngl_FragColor=color;\n#include<imageProcessingCompatibility>\n#define CUSTOM_FRAGMENT_MAIN_END\n}\n";
+export {};

package/dist/types/node_modules/@babylonjs/materials/triPlanar/triplanar.vertex.d.ts

@@ -0,0 +1,7 @@
+export namespace triplanarVertexShader {
+    export { name };
+    export { shader };
+}
+declare const name: "triplanarVertexShader";
+declare const shader: "precision highp float;\nattribute vec3 position;\n#ifdef NORMAL\nattribute vec3 normal;\n#endif\n#ifdef VERTEXCOLOR\nattribute vec4 color;\n#endif\n#include<bonesDeclaration>\n#include<bakedVertexAnimationDeclaration>\n#include<instancesDeclaration>\nuniform mat4 view;\nuniform mat4 viewProjection;\n#ifdef DIFFUSEX\nvarying vec2 vTextureUVX;\n#endif\n#ifdef DIFFUSEY\nvarying vec2 vTextureUVY;\n#endif\n#ifdef DIFFUSEZ\nvarying vec2 vTextureUVZ;\n#endif\nuniform float tileSize;\n#ifdef POINTSIZE\nuniform float pointSize;\n#endif\nvarying vec3 vPositionW;\n#ifdef NORMAL\nvarying mat3 tangentSpace;\n#endif\n#if defined(VERTEXCOLOR) || defined(INSTANCESCOLOR) && defined(INSTANCES)\nvarying vec4 vColor;\n#endif\n#include<clipPlaneVertexDeclaration>\n#include<fogVertexDeclaration>\n#include<__decl__lightFragment>[0..maxSimultaneousLights]\n#define CUSTOM_VERTEX_DEFINITIONS\nvoid main(void)\n{\n#define CUSTOM_VERTEX_MAIN_BEGIN\n#include<instancesVertex>\n#include<bonesVertex>\n#include<bakedVertexAnimation>\nvec4 worldPos=finalWorld*vec4(position,1.0);\ngl_Position=viewProjection*worldPos;\nvPositionW=vec3(worldPos);\n#ifdef DIFFUSEX\nvTextureUVX=worldPos.zy/tileSize;\n#endif\n#ifdef DIFFUSEY\nvTextureUVY=worldPos.xz/tileSize;\n#endif\n#ifdef DIFFUSEZ\nvTextureUVZ=worldPos.xy/tileSize;\n#endif\n#ifdef NORMAL\nvec3 xtan=vec3(0,0,1);\nvec3 xbin=vec3(0,1,0);\nvec3 ytan=vec3(1,0,0);\nvec3 ybin=vec3(0,0,1);\nvec3 ztan=vec3(1,0,0);\nvec3 zbin=vec3(0,1,0);\nvec3 normalizedNormal=normalize(normal);\nnormalizedNormal*=normalizedNormal;\nvec3 worldBinormal=normalize(xbin*normalizedNormal.x+ybin*normalizedNormal.y+zbin*normalizedNormal.z);\nvec3 worldTangent=normalize(xtan*normalizedNormal.x+ytan*normalizedNormal.y+ztan*normalizedNormal.z);\nworldTangent=(world*vec4(worldTangent,0.0)).xyz;\nworldBinormal=(world*vec4(worldBinormal,0.0)).xyz;\nvec3 worldNormal=(world*vec4(normalize(normal),0.0)).xyz;\ntangentSpace[0]=worldTangent;\ntangentSpace[1]=worldBinormal;\ntangentSpace[2]=worldNormal;\n#endif\n#include<clipPlaneVertex>\n#include<fogVertex>\n#include<shadowsVertex>[0..maxSimultaneousLights]\n#include<vertexColorMixing>\n#if defined(POINTSIZE) && !defined(WEBGPU)\ngl_PointSize=pointSize;\n#endif\n#define CUSTOM_VERTEX_MAIN_END\n}\n";
+export {};

package/dist/types/node_modules/@babylonjs/materials/water/index.d.ts

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

package/dist/types/node_modules/@babylonjs/materials/water/water.fragment.d.ts

@@ -0,0 +1,7 @@
+export namespace waterPixelShader {
+    export { name };
+    export { shader };
+}
+declare const name: "waterPixelShader";
+declare const shader: "#ifdef LOGARITHMICDEPTH\n#extension GL_EXT_frag_depth : enable\n#endif\nprecision highp float;\nuniform vec4 vEyePosition;\nuniform vec4 vDiffuseColor;\n#ifdef SPECULARTERM\nuniform vec4 vSpecularColor;\n#endif\nvarying vec3 vPositionW;\n#ifdef NORMAL\nvarying vec3 vNormalW;\n#endif\n#if defined(VERTEXCOLOR) || defined(INSTANCESCOLOR) && defined(INSTANCES)\nvarying vec4 vColor;\n#endif\n#include<helperFunctions>\n#include<imageProcessingDeclaration>\n#include<imageProcessingFunctions>\n#include<__decl__lightFragment>[0..maxSimultaneousLights]\n#include<lightsFragmentFunctions>\n#include<shadowsFragmentFunctions>\n#ifdef BUMP\nvarying vec2 vNormalUV;\n#ifdef BUMPSUPERIMPOSE\nvarying vec2 vNormalUV2;\n#endif\nuniform sampler2D normalSampler;\nuniform vec2 vNormalInfos;\n#endif\nuniform sampler2D refractionSampler;\nuniform sampler2D reflectionSampler;\nconst float LOG2=1.442695;\nuniform vec3 cameraPosition;\nuniform vec4 waterColor;\nuniform float colorBlendFactor;\nuniform vec4 waterColor2;\nuniform float colorBlendFactor2;\nuniform float bumpHeight;\nuniform float time;\nvarying vec3 vRefractionMapTexCoord;\nvarying vec3 vReflectionMapTexCoord;\nvarying vec3 vPosition;\n#include<clipPlaneFragmentDeclaration>\n#include<logDepthDeclaration>\n#include<fogFragmentDeclaration>\n#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void) {\n#define CUSTOM_FRAGMENT_MAIN_BEGIN\n#include<clipPlaneFragment>\nvec3 viewDirectionW=normalize(vEyePosition.xyz-vPositionW);\nvec4 baseColor=vec4(1.,1.,1.,1.);\nvec3 diffuseColor=vDiffuseColor.rgb;\nfloat alpha=vDiffuseColor.a;\n#ifdef BUMP\n#ifdef BUMPSUPERIMPOSE\nbaseColor=0.6*texture2D(normalSampler,vNormalUV)+0.4*texture2D(normalSampler,vec2(vNormalUV2.x,vNormalUV2.y));\n#else\nbaseColor=texture2D(normalSampler,vNormalUV);\n#endif\nvec3 bumpColor=baseColor.rgb;\n#ifdef ALPHATEST\nif (baseColor.a<0.4)\ndiscard;\n#endif\nbaseColor.rgb*=vNormalInfos.y;\n#else\nvec3 bumpColor=vec3(1.0);\n#endif\n#if defined(VERTEXCOLOR) || defined(INSTANCESCOLOR) && defined(INSTANCES)\nbaseColor.rgb*=vColor.rgb;\n#endif\n#ifdef NORMAL\nvec2 perturbation=bumpHeight*(baseColor.rg-0.5);\n#ifdef BUMPAFFECTSREFLECTION\nvec3 normalW=normalize(vNormalW+vec3(perturbation.x*8.0,0.0,perturbation.y*8.0));\nif (normalW.y<0.0) {\nnormalW.y=-normalW.y;\n}\n#else\nvec3 normalW=normalize(vNormalW);\n#endif\n#else\nvec3 normalW=vec3(1.0,1.0,1.0);\nvec2 perturbation=bumpHeight*(vec2(1.0,1.0)-0.5);\n#endif\n#ifdef FRESNELSEPARATE\n#ifdef REFLECTION\nvec2 projectedRefractionTexCoords=clamp(vRefractionMapTexCoord.xy/vRefractionMapTexCoord.z+perturbation*0.5,0.0,1.0);\nvec4 refractiveColor=texture2D(refractionSampler,projectedRefractionTexCoords);\n#ifdef IS_REFRACTION_LINEAR\nrefractiveColor.rgb=toGammaSpace(refractiveColor.rgb);\n#endif\nvec2 projectedReflectionTexCoords=clamp(vec2(\nvReflectionMapTexCoord.x/vReflectionMapTexCoord.z+perturbation.x*0.3,\nvReflectionMapTexCoord.y/vReflectionMapTexCoord.z+perturbation.y\n),0.0,1.0);\nvec4 reflectiveColor=texture2D(reflectionSampler,projectedReflectionTexCoords);\n#ifdef IS_REFLECTION_LINEAR\nreflectiveColor.rgb=toGammaSpace(reflectiveColor.rgb);\n#endif\nvec3 upVector=vec3(0.0,1.0,0.0);\nfloat fresnelTerm=clamp(abs(pow(dot(viewDirectionW,upVector),3.0)),0.05,0.65);\nfloat IfresnelTerm=1.0-fresnelTerm;\nrefractiveColor=colorBlendFactor*waterColor+(1.0-colorBlendFactor)*refractiveColor;\nreflectiveColor=IfresnelTerm*colorBlendFactor2*waterColor+(1.0-colorBlendFactor2*IfresnelTerm)*reflectiveColor;\nvec4 combinedColor=refractiveColor*fresnelTerm+reflectiveColor*IfresnelTerm;\nbaseColor=combinedColor;\n#endif\nvec3 diffuseBase=vec3(0.,0.,0.);\nlightingInfo info;\nfloat shadow=1.;\n#ifdef SPECULARTERM\nfloat glossiness=vSpecularColor.a;\nvec3 specularBase=vec3(0.,0.,0.);\nvec3 specularColor=vSpecularColor.rgb;\n#else\nfloat glossiness=0.;\n#endif\n#include<lightFragment>[0..maxSimultaneousLights]\nvec3 finalDiffuse=clamp(baseColor.rgb,0.0,1.0);\n#if defined(VERTEXALPHA) || defined(INSTANCESCOLOR) && defined(INSTANCES)\nalpha*=vColor.a;\n#endif\n#ifdef SPECULARTERM\nvec3 finalSpecular=specularBase*specularColor;\n#else\nvec3 finalSpecular=vec3(0.0);\n#endif\n#else \n#ifdef REFLECTION\nvec2 projectedRefractionTexCoords=clamp(vRefractionMapTexCoord.xy/vRefractionMapTexCoord.z+perturbation,0.0,1.0);\nvec4 refractiveColor=texture2D(refractionSampler,projectedRefractionTexCoords);\n#ifdef IS_REFRACTION_LINEAR\nrefractiveColor.rgb=toGammaSpace(refractiveColor.rgb);\n#endif\nvec2 projectedReflectionTexCoords=clamp(vReflectionMapTexCoord.xy/vReflectionMapTexCoord.z+perturbation,0.0,1.0);\nvec4 reflectiveColor=texture2D(reflectionSampler,projectedReflectionTexCoords);\n#ifdef IS_REFLECTION_LINEAR\nreflectiveColor.rgb=toGammaSpace(reflectiveColor.rgb);\n#endif\nvec3 upVector=vec3(0.0,1.0,0.0);\nfloat fresnelTerm=max(dot(viewDirectionW,upVector),0.0);\nvec4 combinedColor=refractiveColor*fresnelTerm+reflectiveColor*(1.0-fresnelTerm);\nbaseColor=colorBlendFactor*waterColor+(1.0-colorBlendFactor)*combinedColor;\n#endif\nvec3 diffuseBase=vec3(0.,0.,0.);\nlightingInfo info;\nfloat shadow=1.;\n#ifdef SPECULARTERM\nfloat glossiness=vSpecularColor.a;\nvec3 specularBase=vec3(0.,0.,0.);\nvec3 specularColor=vSpecularColor.rgb;\n#else\nfloat glossiness=0.;\n#endif\n#include<lightFragment>[0..maxSimultaneousLights]\nvec3 finalDiffuse=clamp(baseColor.rgb,0.0,1.0);\n#if defined(VERTEXALPHA) || defined(INSTANCESCOLOR) && defined(INSTANCES)\nalpha*=vColor.a;\n#endif\n#ifdef SPECULARTERM\nvec3 finalSpecular=specularBase*specularColor;\n#else\nvec3 finalSpecular=vec3(0.0);\n#endif\n#endif\nvec4 color=vec4(finalDiffuse+finalSpecular,alpha);\n#include<logDepthFragment>\n#include<fogFragment>\n#ifdef IMAGEPROCESSINGPOSTPROCESS\ncolor.rgb=toLinearSpace(color.rgb);\n#elif defined(IMAGEPROCESSING)\ncolor.rgb=toLinearSpace(color.rgb);\ncolor=applyImageProcessing(color);\n#endif\ngl_FragColor=color;\n#define CUSTOM_FRAGMENT_MAIN_END\n}\n";
+export {};

package/dist/types/node_modules/@babylonjs/materials/water/water.vertex.d.ts

@@ -0,0 +1,7 @@
+export namespace waterVertexShader {
+    export { name };
+    export { shader };
+}
+declare const name: "waterVertexShader";
+declare const shader: "precision highp float;\nattribute vec3 position;\n#ifdef NORMAL\nattribute vec3 normal;\n#endif\n#ifdef UV1\nattribute vec2 uv;\n#endif\n#ifdef UV2\nattribute vec2 uv2;\n#endif\n#ifdef VERTEXCOLOR\nattribute vec4 color;\n#endif\n#include<bonesDeclaration>\n#include<bakedVertexAnimationDeclaration>\n#include<instancesDeclaration>\nuniform mat4 view;\nuniform mat4 viewProjection;\n#ifdef BUMP\nvarying vec2 vNormalUV;\n#ifdef BUMPSUPERIMPOSE\nvarying vec2 vNormalUV2;\n#endif\nuniform mat4 normalMatrix;\nuniform vec2 vNormalInfos;\n#endif\n#ifdef POINTSIZE\nuniform float pointSize;\n#endif\nvarying vec3 vPositionW;\n#ifdef NORMAL\nvarying vec3 vNormalW;\n#endif\n#if defined(VERTEXCOLOR) || defined(INSTANCESCOLOR) && defined(INSTANCES)\nvarying vec4 vColor;\n#endif\n#include<clipPlaneVertexDeclaration>\n#include<fogVertexDeclaration>\n#include<__decl__lightFragment>[0..maxSimultaneousLights]\n#include<logDepthDeclaration>\nuniform mat4 worldReflectionViewProjection;\nuniform vec2 windDirection;\nuniform float waveLength;\nuniform float time;\nuniform float windForce;\nuniform float waveHeight;\nuniform float waveSpeed;\nuniform float waveCount;\nvarying vec3 vPosition;\nvarying vec3 vRefractionMapTexCoord;\nvarying vec3 vReflectionMapTexCoord;\n#define CUSTOM_VERTEX_DEFINITIONS\nvoid main(void) {\n#define CUSTOM_VERTEX_MAIN_BEGIN\n#include<instancesVertex>\n#include<bonesVertex>\n#include<bakedVertexAnimation>\nvec4 worldPos=finalWorld*vec4(position,1.0);\nvPositionW=vec3(worldPos);\n#ifdef NORMAL\nvNormalW=normalize(vec3(finalWorld*vec4(normal,0.0)));\n#endif\n#ifndef UV1\nvec2 uv=vec2(0.,0.);\n#endif\n#ifndef UV2\nvec2 uv2=vec2(0.,0.);\n#endif\n#ifdef BUMP\nif (vNormalInfos.x==0.)\n{\nvNormalUV=vec2(normalMatrix*vec4((uv*1.0)/waveLength+time*windForce*windDirection,1.0,0.0));\n#ifdef BUMPSUPERIMPOSE\nvNormalUV2=vec2(normalMatrix*vec4((uv*0.721)/waveLength+time*1.2*windForce*windDirection,1.0,0.0));\n#endif\n}\nelse\n{\nvNormalUV=vec2(normalMatrix*vec4((uv2*1.0)/waveLength+time*windForce*windDirection ,1.0,0.0));\n#ifdef BUMPSUPERIMPOSE\nvNormalUV2=vec2(normalMatrix*vec4((uv2*0.721)/waveLength+time*1.2*windForce*windDirection ,1.0,0.0));\n#endif\n}\n#endif\n#include<clipPlaneVertex>\n#include<fogVertex>\n#include<shadowsVertex>[0..maxSimultaneousLights]\n#include<vertexColorMixing>\n#if defined(POINTSIZE) && !defined(WEBGPU)\ngl_PointSize=pointSize;\n#endif\nfloat finalWaveCount=1.0/(waveCount*0.5);\nvec3 p=position;\nfloat newY=(sin(((p.x/finalWaveCount)+time*waveSpeed))*waveHeight*windDirection.x*5.0)\n+ (cos(((p.z/finalWaveCount)+ time*waveSpeed))*waveHeight*windDirection.y*5.0);\np.y+=abs(newY);\ngl_Position=viewProjection*finalWorld*vec4(p,1.0);\n#ifdef REFLECTION\nworldPos=viewProjection*finalWorld*vec4(p,1.0);\nvPosition=position;\nvRefractionMapTexCoord.x=0.5*(worldPos.w+worldPos.x);\nvRefractionMapTexCoord.y=0.5*(worldPos.w+worldPos.y);\nvRefractionMapTexCoord.z=worldPos.w;\nworldPos=worldReflectionViewProjection*vec4(position,1.0);\nvReflectionMapTexCoord.x=0.5*(worldPos.w+worldPos.x);\nvReflectionMapTexCoord.y=0.5*(worldPos.w+worldPos.y);\nvReflectionMapTexCoord.z=worldPos.w;\n#endif\n#include<logDepthVertex>\n#define CUSTOM_VERTEX_MAIN_END\n}\n";
+export {};

package/dist/types/node_modules/@babylonjs/materials/water/waterMaterial.d.ts

@@ -0,0 +1,113 @@
+export class WaterMaterial extends PushMaterial {
+    static Parse(source: any, scene: any, rootUrl: any): WaterMaterial;
+    static CreateDefaultMesh(name: any, scene: any): import("@babylonjs/core").GroundMesh;
+    /**
+     * Constructor
+     * @param name
+     * @param scene
+     * @param renderTargetSize
+     */
+    constructor(name: any, scene: any, renderTargetSize?: Vector2);
+    renderTargetSize: Vector2;
+    diffuseColor: Color3;
+    specularColor: Color3;
+    specularPower: number;
+    _disableLighting: boolean;
+    _maxSimultaneousLights: number;
+    /**
+     * Defines the wind force.
+     */
+    windForce: number;
+    /**
+     * Defines the direction of the wind in the plane (X, Z).
+     */
+    windDirection: Vector2;
+    /**
+     * Defines the height of the waves.
+     */
+    waveHeight: number;
+    /**
+     * Defines the bump height related to the bump map.
+     */
+    bumpHeight: number;
+    /**
+     * Defines wether or not: to add a smaller moving bump to less steady waves.
+     */
+    _bumpSuperimpose: boolean;
+    /**
+     * Defines wether or not color refraction and reflection differently with .waterColor2 and .colorBlendFactor2. Non-linear (physically correct) fresnel.
+     */
+    _fresnelSeparate: boolean;
+    /**
+     * Defines wether or not bump Wwves modify the reflection.
+     */
+    _bumpAffectsReflection: boolean;
+    /**
+     * Defines the water color blended with the refraction (near).
+     */
+    waterColor: Color3;
+    /**
+     * Defines the blend factor related to the water color.
+     */
+    colorBlendFactor: number;
+    /**
+     * Defines the water color blended with the reflection (far).
+     */
+    waterColor2: Color3;
+    /**
+     * Defines the blend factor related to the water color (reflection, far).
+     */
+    colorBlendFactor2: number;
+    /**
+     * Defines the maximum length of a wave.
+     */
+    waveLength: number;
+    /**
+     * Defines the waves speed.
+     */
+    waveSpeed: number;
+    /**
+     * Defines the number of times waves are repeated. This is typically used to adjust waves count according to the ground's size where the material is applied on.
+     */
+    waveCount: number;
+    /**
+     * Sets or gets whether or not automatic clipping should be enabled or not. Setting to true will save performances and
+     * will avoid calculating useless pixels in the pixel shader of the water material.
+     */
+    disableClipPlane: boolean;
+    _renderTargets: SmartArray<any>;
+    _mesh: any;
+    _reflectionTransform: Matrix;
+    _lastTime: number;
+    _lastDeltaTime: number;
+    getRenderTargetTextures: () => SmartArray<any>;
+    _imageProcessingConfiguration: ImageProcessingConfiguration;
+    _imageProcessingObserver: import("@babylonjs/core").Nullable<import("@babylonjs/core").Observer<ImageProcessingConfiguration>> | undefined;
+    set useLogarithmicDepth(arg: any);
+    get useLogarithmicDepth(): any;
+    _useLogarithmicDepth: any;
+    get refractionTexture(): RenderTargetTexture | undefined;
+    get reflectionTexture(): RenderTargetTexture | undefined;
+    addToRenderList(node: any): void;
+    enableRenderTargets(enable: any): void;
+    getRenderList(): import("@babylonjs/core").Nullable<import("@babylonjs/core").AbstractMesh[]>;
+    get renderTargetsEnabled(): boolean;
+    getAlphaTestTexture(): null;
+    isReadyForSubMesh(mesh: any, subMesh: any, useInstances: any): boolean;
+    _waitingRenderList: any;
+    bindForSubMesh(world: any, mesh: any, subMesh: any): void;
+    _createRenderTargets(scene: any, renderTargetSize: any): void;
+    _refractionRTT: RenderTargetTexture | undefined;
+    _reflectionRTT: RenderTargetTexture | undefined;
+    getAnimatables(): any[];
+    hasTexture(texture: any): boolean;
+    dispose(forceDisposeEffect: any): void;
+    clone(name: any): WaterMaterial;
+}
+import { PushMaterial } from "@babylonjs/core/Materials/pushMaterial.js";
+import { Vector2 } from "@babylonjs/core/Maths/math.vector.js";
+import { Color3 } from "@babylonjs/core/Maths/math.color.js";
+import { SmartArray } from "@babylonjs/core/Misc/smartArray.js";
+import { Matrix } from "@babylonjs/core/Maths/math.vector.js";
+import { ImageProcessingConfiguration } from "@babylonjs/core/Materials/imageProcessingConfiguration.js";
+import { RenderTargetTexture } from "@babylonjs/core/Materials/Textures/renderTargetTexture.js";

package/dist/types/node_modules/@babylonjs/post-processes/asciiArt/asciiArtPostProcess.d.ts

@@ -0,0 +1,80 @@
+/**
+ * AsciiArtFontTexture is the helper class used to easily create your ascii art font texture.
+ *
+ * It basically takes care rendering the font front the given font size to a texture.
+ * This is used later on in the postprocess.
+ */
+export class AsciiArtFontTexture extends BaseTexture {
+    /**
+     * Parses a json object representing the texture and returns an instance of it.
+     * @param source the source JSON representation
+     * @param scene the scene to create the texture for
+     * @returns the parsed texture
+     */
+    static Parse(source: any, scene: any): AsciiArtFontTexture;
+    /**
+     * Create a new instance of the Ascii Art FontTexture class
+     * @param name the name of the texture
+     * @param font the font to use, use the W3C CSS notation
+     * @param text the caracter set to use in the rendering.
+     * @param scene the scene that owns the texture
+     */
+    constructor(name: any, font: any, text: any, scene?: null);
+    name: any;
+    _charSize: number | undefined;
+    _texture: any;
+    /**
+     * Gets the size of one char in the texture (each char fits in size * size space in the texture).
+     */
+    get charSize(): number | undefined;
+    /**
+     * Gets the max char width of a font.
+     * @param font the font to use, use the W3C CSS notation
+     * @returns the max char width
+     */
+    _getFontWidth(font: any): number;
+    /**
+     * Gets the max char height of a font.
+     * @param font the font to use, use the W3C CSS notation
+     * @returns the max char height
+     */
+    _getFontHeight(font: any): {
+        height: number;
+        offset: number;
+    };
+    /**
+     * Clones the current AsciiArtTexture.
+     * @returns the clone of the texture.
+     */
+    clone(): AsciiArtFontTexture;
+}
+/**
+ * AsciiArtPostProcess helps rendering everithing in Ascii Art.
+ *
+ * Simmply add it to your scene and let the nerd that lives in you have fun.
+ * Example usage: var pp = new AsciiArtPostProcess("myAscii", "20px Monospace", camera);
+ */
+export class AsciiArtPostProcess extends PostProcess {
+    /**
+     * Instantiates a new Ascii Art Post Process.
+     * @param name the name to give to the postprocess
+     * @camera the camera to apply the post process to.
+     * @param camera
+     * @param options can either be the font name or an option object following the IAsciiArtPostProcessOptions format
+     */
+    constructor(name: any, camera: any, options: any);
+    /**
+     * This defines the amount you want to mix the "tile" or caracter space colored in the ascii art.
+     * This number is defined between 0 and 1;
+     */
+    mixToTile: any;
+    /**
+     * This defines the amount you want to mix the normal rendering pass in the ascii art.
+     * This number is defined between 0 and 1;
+     */
+    mixToNormal: any;
+    _asciiArtFontTexture: AsciiArtFontTexture;
+    onApply: (effect: any) => void;
+}
+import { BaseTexture } from "@babylonjs/core/Materials/Textures/baseTexture.js";
+import { PostProcess } from "@babylonjs/core/PostProcesses/postProcess.js";

package/dist/types/node_modules/@babylonjs/post-processes/asciiArt/asciiart.fragment.d.ts

@@ -0,0 +1,7 @@
+export namespace asciiartPixelShader {
+    export { name };
+    export { shader };
+}
+declare const name: "asciiartPixelShader";
+declare const shader: "varying vec2 vUV;uniform sampler2D textureSampler;uniform sampler2D asciiArtFont;uniform vec4 asciiArtFontInfos;uniform vec4 asciiArtOptions;float getLuminance(vec3 color)\n{return clamp(dot(color,vec3(0.2126,0.7152,0.0722)),0.,1.);}\n#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void) \n{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;}";
+export {};

package/dist/types/node_modules/@babylonjs/post-processes/asciiArt/index.d.ts

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

package/dist/types/node_modules/@babylonjs/post-processes/digitalRain/digitalRainPostProcess.d.ts

@@ -0,0 +1,84 @@
+/**
+ * DigitalRainFontTexture is the helper class used to easily create your digital rain font texture.
+ *
+ * It basically takes care rendering the font front the given font size to a texture.
+ * This is used later on in the postprocess.
+ */
+export class DigitalRainFontTexture extends BaseTexture {
+    /**
+     * Parses a json object representing the texture and returns an instance of it.
+     * @param source the source JSON representation
+     * @param scene the scene to create the texture for
+     * @returns the parsed texture
+     */
+    static Parse(source: any, scene: any): DigitalRainFontTexture;
+    /**
+     * Create a new instance of the Digital Rain FontTexture class
+     * @param name the name of the texture
+     * @param font the font to use, use the W3C CSS notation
+     * @param text the caracter set to use in the rendering.
+     * @param scene the scene that owns the texture
+     */
+    constructor(name: any, font: any, text: any, scene?: null);
+    name: any;
+    _charSize: number | undefined;
+    _texture: any;
+    /**
+     * Gets the size of one char in the texture (each char fits in size * size space in the texture).
+     */
+    get charSize(): number | undefined;
+    /**
+     * Gets the max char width of a font.
+     * @param font the font to use, use the W3C CSS notation
+     * @returns the max char width
+     */
+    _getFontWidth(font: any): number;
+    /**
+     * Gets the max char height of a font.
+     * @param font the font to use, use the W3C CSS notation
+     * @returns the max char height
+     */
+    _getFontHeight(font: any): {
+        height: number;
+        offset: number;
+    };
+    /**
+     * Clones the current DigitalRainFontTexture.
+     * @returns the clone of the texture.
+     */
+    clone(): DigitalRainFontTexture;
+}
+/**
+ * DigitalRainPostProcess helps rendering everithing in digital rain.
+ *
+ * Simmply add it to your scene and let the nerd that lives in you have fun.
+ * Example usage: var pp = new DigitalRainPostProcess("digitalRain", "20px Monospace", camera);
+ */
+export class DigitalRainPostProcess extends PostProcess {
+    /**
+     * Instantiates a new Digital Rain Post Process.
+     * @param name the name to give to the postprocess
+     * @camera the camera to apply the post process to.
+     * @param camera
+     * @param options can either be the font name or an option object following the IDigitalRainPostProcessOptions format
+     */
+    constructor(name: any, camera: any, options: any);
+    /**
+     * This defines the amount you want to mix the "tile" or caracter space colored in the digital rain.
+     * This number is defined between 0 and 1;
+     */
+    mixToTile: any;
+    /**
+     * This defines the amount you want to mix the normal rendering pass in the digital rain.
+     * This number is defined between 0 and 1;
+     */
+    mixToNormal: any;
+    /**
+     * Speed of the effect
+     */
+    speed: number;
+    _digitalRainFontTexture: DigitalRainFontTexture;
+    onApply: (effect: any) => void;
+}
+import { BaseTexture } from "@babylonjs/core/Materials/Textures/baseTexture.js";
+import { PostProcess } from "@babylonjs/core/PostProcesses/postProcess.js";

package/dist/types/node_modules/@babylonjs/post-processes/digitalRain/digitalrain.fragment.d.ts

@@ -0,0 +1,7 @@
+export namespace digitalrainPixelShader {
+    export { name };
+    export { shader };
+}
+declare const name: "digitalrainPixelShader";
+declare const 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)\n{return clamp(dot(color,vec3(0.2126,0.7152,0.0722)),0.,1.);}\n#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void) \n{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); \nfloat 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;}";
+export {};

package/dist/types/node_modules/@babylonjs/post-processes/digitalRain/index.d.ts

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

package/dist/types/node_modules/@babylonjs/post-processes/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./asciiArt/index.js";
+export * from "./digitalRain/index.js";

package/dist/types/node_modules/@babylonjs/post-processes/legacy/legacy-asciiArt.d.ts

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

package/dist/types/node_modules/@babylonjs/post-processes/legacy/legacy-digitalRain.d.ts

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

package/dist/types/node_modules/@babylonjs/post-processes/legacy/legacy.d.ts

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

package/dist/types/node_modules/@babylonjs/procedural-textures/brick/brickProceduralTexture.d.ts

@@ -0,0 +1,26 @@
+export class BrickProceduralTexture extends ProceduralTexture {
+    /**
+     * Creates a Brick Procedural Texture from parsed brick procedural texture data
+     * @param parsedTexture defines parsed texture data
+     * @param scene defines the current scene
+     * @param rootUrl defines the root URL containing brick procedural texture information
+     * @returns a parsed Brick Procedural Texture
+     */
+    static Parse(parsedTexture: any, scene: any, rootUrl: any): BrickProceduralTexture;
+    constructor(name: any, size: any, scene: null | undefined, fallbackTexture: any, generateMipMaps: any);
+    _numberOfBricksHeight: number;
+    _numberOfBricksWidth: number;
+    _jointColor: Color3;
+    _brickColor: Color3;
+    updateShaderUniforms(): void;
+    set numberOfBricksHeight(arg: number);
+    get numberOfBricksHeight(): number;
+    set numberOfBricksWidth(arg: number);
+    get numberOfBricksWidth(): number;
+    set jointColor(arg: Color3);
+    get jointColor(): Color3;
+    set brickColor(arg: Color3);
+    get brickColor(): Color3;
+}
+import { ProceduralTexture } from "@babylonjs/core/Materials/Textures/Procedurals/proceduralTexture.js";
+import { Color3 } from "@babylonjs/core/Maths/math.color.js";

package/dist/types/node_modules/@babylonjs/procedural-textures/brick/brickProceduralTexture.fragment.d.ts

@@ -0,0 +1,7 @@
+export namespace brickProceduralTexturePixelShader {
+    export { name };
+    export { shader };
+}
+declare const name: "brickProceduralTexturePixelShader";
+declare const 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);}\nfloat noise(vec2 n) {const vec2 d=vec2(0.0,1.0);vec2 b=floor(n),f=smoothstep(vec2(0.0),vec2(1.0),fract(n));return mix(mix(rand(b),rand(b+d.yx),f.x),mix(rand(b+d.xy),rand(b+d.yy),f.x),f.y);}\nfloat 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;}\nreturn total;}\nfloat roundF(float number){return sign(number)*floor(abs(number)+0.5);}\n#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void)\n{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;}\nfloat nxi=roundF(xi);vec2 brickvUV=vec2((xi-floor(xi))/brickH,(yi-floor(yi))/ brickW);if (yi<nyi+jointHPercentage && yi>nyi-jointHPercentage){color=mix(jointColor,vec3(0.37,0.25,0.25),(yi-nyi)/jointHPercentage+0.2);}\nelse if (xi<nxi+jointWPercentage && xi>nxi-jointWPercentage){color=mix(jointColor,vec3(0.44,0.44,0.44),(xi-nxi)/jointWPercentage+0.2);}\nelse {float brickColorSwitch=mod(floor(yi)+floor(xi),3.0);if (brickColorSwitch==0.0)\ncolor=mix(color,vec3(0.33,0.33,0.33),0.3);else if (brickColorSwitch==2.0)\ncolor=mix(color,vec3(0.11,0.11,0.11),0.3);}\ngl_FragColor=vec4(color,1.0);}";
+export {};

package/dist/types/node_modules/@babylonjs/procedural-textures/brick/index.d.ts

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

package/dist/types/node_modules/@babylonjs/procedural-textures/cloud/cloudProceduralTexture.d.ts

@@ -0,0 +1,26 @@
+export class CloudProceduralTexture extends ProceduralTexture {
+    /**
+     * Creates a Cloud Procedural Texture from parsed cloud procedural texture data
+     * @param parsedTexture defines parsed texture data
+     * @param scene defines the current scene
+     * @param rootUrl defines the root URL containing cloud procedural texture information
+     * @returns a parsed Cloud Procedural Texture
+     */
+    static Parse(parsedTexture: any, scene: any, rootUrl: any): CloudProceduralTexture;
+    constructor(name: any, size: any, scene: null | undefined, fallbackTexture: any, generateMipMaps: any);
+    _skyColor: Color4;
+    _cloudColor: Color4;
+    _amplitude: number;
+    _numOctaves: number;
+    updateShaderUniforms(): void;
+    set skyColor(arg: Color4);
+    get skyColor(): Color4;
+    set cloudColor(arg: Color4);
+    get cloudColor(): Color4;
+    set amplitude(arg: number);
+    get amplitude(): number;
+    set numOctaves(arg: number);
+    get numOctaves(): number;
+}
+import { ProceduralTexture } from "@babylonjs/core/Materials/Textures/Procedurals/proceduralTexture.js";
+import { Color4 } from "@babylonjs/core/Maths/math.color.js";

package/dist/types/node_modules/@babylonjs/procedural-textures/cloud/cloudProceduralTexture.fragment.d.ts

@@ -0,0 +1,7 @@
+export namespace cloudProceduralTexturePixelShader {
+    export { name };
+    export { shader };
+}
+declare const name: "cloudProceduralTexturePixelShader";
+declare const shader: "precision highp float;varying vec2 vUV;uniform vec4 skyColor;uniform vec4 cloudColor;uniform float amplitude;uniform int numOctaves;float rand(vec2 n) {return fract(cos(dot(n,vec2(12.9898,4.1414)))*43758.5453);}\nfloat noise(vec2 n) {const vec2 d=vec2(0.0,1.0);vec2 b=floor(n),f=smoothstep(vec2(0.0),vec2(1.0),fract(n));return mix(mix(rand(b),rand(b+d.yx),f.x),mix(rand(b+d.xy),rand(b+d.yy),f.x),f.y);}\nfloat fbm(vec2 n) {float total=0.0,ampl=amplitude;\n#ifdef WEBGL2\nfor (int i=0; i<numOctaves; i++) {\n#else\nfor (int i=0; i<4; i++) {\n#endif\ntotal+=noise(n)*ampl;n+=n;ampl*=0.5;}\nreturn total;}\nvoid main() {vec2 p=vUV*12.0;vec4 c=mix(skyColor,cloudColor,fbm(p));gl_FragColor=c;}\n";
+export {};

package/dist/types/node_modules/@babylonjs/procedural-textures/cloud/index.d.ts

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

package/dist/types/node_modules/@babylonjs/procedural-textures/fire/fireProceduralTexture.d.ts

@@ -0,0 +1,35 @@
+export class FireProceduralTexture extends ProceduralTexture {
+    static get PurpleFireColors(): Color3[];
+    static get GreenFireColors(): Color3[];
+    static get RedFireColors(): Color3[];
+    static get BlueFireColors(): Color3[];
+    /**
+     * Creates a Fire Procedural Texture from parsed fire procedural texture data
+     * @param parsedTexture defines parsed texture data
+     * @param scene defines the current scene
+     * @param rootUrl defines the root URL containing fire procedural texture information
+     * @returns a parsed Fire Procedural Texture
+     */
+    static Parse(parsedTexture: any, scene: any, rootUrl: any): FireProceduralTexture;
+    constructor(name: any, size: any, scene: null | undefined, fallbackTexture: any, generateMipMaps: any);
+    _time: number;
+    _speed: Vector2;
+    _autoGenerateTime: boolean;
+    _alphaThreshold: number;
+    _fireColors: Color3[];
+    updateShaderUniforms(): void;
+    render(useCameraPostProcess: any): void;
+    set autoGenerateTime(arg: boolean);
+    get autoGenerateTime(): boolean;
+    set fireColors(arg: Color3[]);
+    get fireColors(): Color3[];
+    set time(arg: number);
+    get time(): number;
+    set speed(arg: Vector2);
+    get speed(): Vector2;
+    set alphaThreshold(arg: number);
+    get alphaThreshold(): number;
+}
+import { ProceduralTexture } from "@babylonjs/core/Materials/Textures/Procedurals/proceduralTexture.js";
+import { Vector2 } from "@babylonjs/core/Maths/math.vector.js";
+import { Color3 } from "@babylonjs/core/Maths/math.color.js";

package/dist/types/node_modules/@babylonjs/procedural-textures/fire/fireProceduralTexture.fragment.d.ts

@@ -0,0 +1,7 @@
+export namespace fireProceduralTexturePixelShader {
+    export { name };
+    export { shader };
+}
+declare const name: "fireProceduralTexturePixelShader";
+declare const 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);}\nfloat noise(vec2 n) {const vec2 d=vec2(0.0,1.0);vec2 b=floor(n),f=smoothstep(vec2(0.0),vec2(1.0),fract(n));return mix(mix(rand(b),rand(b+d.yx),f.x),mix(rand(b+d.xy),rand(b+d.yy),f.x),f.y);}\nfloat 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;}\nreturn total;}\nvoid 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));}";
+export {};

package/dist/types/node_modules/@babylonjs/procedural-textures/fire/index.d.ts

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

package/dist/types/node_modules/@babylonjs/procedural-textures/grass/grassProceduralTexture.d.ts

@@ -0,0 +1,20 @@
+export class GrassProceduralTexture extends ProceduralTexture {
+    /**
+     * Creates a Grass Procedural Texture from parsed grass procedural texture data
+     * @param parsedTexture defines parsed texture data
+     * @param scene defines the current scene
+     * @param rootUrl defines the root URL containing grass procedural texture information
+     * @returns a parsed Grass Procedural Texture
+     */
+    static Parse(parsedTexture: any, scene: any, rootUrl: any): GrassProceduralTexture;
+    constructor(name: any, size: any, scene: null | undefined, fallbackTexture: any, generateMipMaps: any);
+    _groundColor: Color3;
+    _grassColors: Color3[];
+    updateShaderUniforms(): void;
+    set grassColors(arg: Color3[]);
+    get grassColors(): Color3[];
+    set groundColor(arg: Color3);
+    get groundColor(): Color3;
+}
+import { ProceduralTexture } from "@babylonjs/core/Materials/Textures/Procedurals/proceduralTexture.js";
+import { Color3 } from "@babylonjs/core/Maths/math.color.js";

package/dist/types/node_modules/@babylonjs/procedural-textures/grass/grassProceduralTexture.fragment.d.ts

@@ -0,0 +1,7 @@
+export namespace grassProceduralTexturePixelShader {
+    export { name };
+    export { shader };
+}
+declare const name: "grassProceduralTexturePixelShader";
+declare const 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);}\nfloat noise(vec2 n) {const vec2 d=vec2(0.0,1.0);vec2 b=floor(n),f=smoothstep(vec2(0.0),vec2(1.0),fract(n));return mix(mix(rand(b),rand(b+d.yx),f.x),mix(rand(b+d.xy),rand(b+d.yy),f.x),f.y);}\nfloat 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;}\nreturn total;}\n#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void) {\n#define CUSTOM_FRAGMENT_MAIN_BEGIN\nvec3 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);\n#define CUSTOM_FRAGMENT_MAIN_END\n}";
+export {};

package/dist/types/node_modules/@babylonjs/procedural-textures/grass/index.d.ts

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