@babylonjs/core 5.24.0 → 5.25.0

package/Shaders/fxaa.fragment.js

@@ -10,6 +10,6 @@ gl_FragColor=texture2D(textureSampler,posM,0.0);
 }`;
 // Sideeffect
 ShaderStore.ShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const fxaaPixelShader = { name, shader };
 //# sourceMappingURL=fxaa.fragment.js.map

package/Shaders/fxaa.fragment.js.map

@@ -1 +1 @@
-{"version":3,"file":"fxaa.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/fxaa.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,iBAAiB,CAAC;AAC/B,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2Mb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,cAAc;AACd,MAAM,CAAC,MAAM,eAAe,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\n\nconst name = \"fxaaPixelShader\";\nconst shader = `uniform sampler2D textureSampler;\runiform vec2 texelSize;\rvarying vec2 vUV;\rvarying vec2 sampleCoordS;\rvarying vec2 sampleCoordE;\rvarying vec2 sampleCoordN;\rvarying vec2 sampleCoordW;\rvarying vec2 sampleCoordNW;\rvarying vec2 sampleCoordSE;\rvarying vec2 sampleCoordNE;\rvarying vec2 sampleCoordSW;\rconst float fxaaQualitySubpix=1.0;\rconst float fxaaQualityEdgeThreshold=0.166;\rconst float fxaaQualityEdgeThresholdMin=0.0833;\rconst vec3 kLumaCoefficients=vec3(0.2126,0.7152,0.0722);\r#define FxaaLuma(rgba) dot(rgba.rgb,kLumaCoefficients)\nvoid main(){\rvec2 posM;\rposM.x=vUV.x;\rposM.y=vUV.y;\rvec4 rgbyM=texture2D(textureSampler,vUV,0.0);\rfloat lumaM=FxaaLuma(rgbyM);\rfloat lumaS=FxaaLuma(texture2D(textureSampler,sampleCoordS,0.0));\rfloat lumaE=FxaaLuma(texture2D(textureSampler,sampleCoordE,0.0));\rfloat lumaN=FxaaLuma(texture2D(textureSampler,sampleCoordN,0.0));\rfloat lumaW=FxaaLuma(texture2D(textureSampler,sampleCoordW,0.0));\rfloat maxSM=max(lumaS,lumaM);\rfloat minSM=min(lumaS,lumaM);\rfloat maxESM=max(lumaE,maxSM);\rfloat minESM=min(lumaE,minSM);\rfloat maxWN=max(lumaN,lumaW);\rfloat minWN=min(lumaN,lumaW);\rfloat rangeMax=max(maxWN,maxESM);\rfloat rangeMin=min(minWN,minESM);\rfloat rangeMaxScaled=rangeMax*fxaaQualityEdgeThreshold;\rfloat range=rangeMax-rangeMin;\rfloat rangeMaxClamped=max(fxaaQualityEdgeThresholdMin,rangeMaxScaled);\r#ifndef MALI\nif(range<rangeMaxClamped) \r{\rgl_FragColor=rgbyM;\rreturn;\r}\r#endif\nfloat lumaNW=FxaaLuma(texture2D(textureSampler,sampleCoordNW,0.0));\rfloat lumaSE=FxaaLuma(texture2D(textureSampler,sampleCoordSE,0.0));\rfloat lumaNE=FxaaLuma(texture2D(textureSampler,sampleCoordNE,0.0));\rfloat lumaSW=FxaaLuma(texture2D(textureSampler,sampleCoordSW,0.0));\rfloat lumaNS=lumaN+lumaS;\rfloat lumaWE=lumaW+lumaE;\rfloat subpixRcpRange=1.0/range;\rfloat subpixNSWE=lumaNS+lumaWE;\rfloat edgeHorz1=(-2.0*lumaM)+lumaNS;\rfloat edgeVert1=(-2.0*lumaM)+lumaWE;\rfloat lumaNESE=lumaNE+lumaSE;\rfloat lumaNWNE=lumaNW+lumaNE;\rfloat edgeHorz2=(-2.0*lumaE)+lumaNESE;\rfloat edgeVert2=(-2.0*lumaN)+lumaNWNE;\rfloat lumaNWSW=lumaNW+lumaSW;\rfloat lumaSWSE=lumaSW+lumaSE;\rfloat edgeHorz4=(abs(edgeHorz1)*2.0)+abs(edgeHorz2);\rfloat edgeVert4=(abs(edgeVert1)*2.0)+abs(edgeVert2);\rfloat edgeHorz3=(-2.0*lumaW)+lumaNWSW;\rfloat edgeVert3=(-2.0*lumaS)+lumaSWSE;\rfloat edgeHorz=abs(edgeHorz3)+edgeHorz4;\rfloat edgeVert=abs(edgeVert3)+edgeVert4;\rfloat subpixNWSWNESE=lumaNWSW+lumaNESE;\rfloat lengthSign=texelSize.x;\rbool horzSpan=edgeHorz>=edgeVert;\rfloat subpixA=subpixNSWE*2.0+subpixNWSWNESE;\rif (!horzSpan)\r{\rlumaN=lumaW;\r}\rif (!horzSpan) \r{\rlumaS=lumaE;\r}\rif (horzSpan) \r{\rlengthSign=texelSize.y;\r}\rfloat subpixB=(subpixA*(1.0/12.0))-lumaM;\rfloat gradientN=lumaN-lumaM;\rfloat gradientS=lumaS-lumaM;\rfloat lumaNN=lumaN+lumaM;\rfloat lumaSS=lumaS+lumaM;\rbool pairN=abs(gradientN)>=abs(gradientS);\rfloat gradient=max(abs(gradientN),abs(gradientS));\rif (pairN)\r{\rlengthSign=-lengthSign;\r}\rfloat subpixC=clamp(abs(subpixB)*subpixRcpRange,0.0,1.0);\rvec2 posB;\rposB.x=posM.x;\rposB.y=posM.y;\rvec2 offNP;\roffNP.x=(!horzSpan) ? 0.0 : texelSize.x;\roffNP.y=(horzSpan) ? 0.0 : texelSize.y;\rif (!horzSpan) \r{\rposB.x+=lengthSign*0.5;\r}\rif (horzSpan)\r{\rposB.y+=lengthSign*0.5;\r}\rvec2 posN;\rposN.x=posB.x-offNP.x*1.5;\rposN.y=posB.y-offNP.y*1.5;\rvec2 posP;\rposP.x=posB.x+offNP.x*1.5;\rposP.y=posB.y+offNP.y*1.5;\rfloat subpixD=((-2.0)*subpixC)+3.0;\rfloat lumaEndN=FxaaLuma(texture2D(textureSampler,posN,0.0));\rfloat subpixE=subpixC*subpixC;\rfloat lumaEndP=FxaaLuma(texture2D(textureSampler,posP,0.0));\rif (!pairN) \r{\rlumaNN=lumaSS;\r}\rfloat gradientScaled=gradient*1.0/4.0;\rfloat lumaMM=lumaM-lumaNN*0.5;\rfloat subpixF=subpixD*subpixE;\rbool lumaMLTZero=lumaMM<0.0;\rlumaEndN-=lumaNN*0.5;\rlumaEndP-=lumaNN*0.5;\rbool doneN=abs(lumaEndN)>=gradientScaled;\rbool doneP=abs(lumaEndP)>=gradientScaled;\rif (!doneN) \r{\rposN.x-=offNP.x*3.0;\r}\rif (!doneN) \r{\rposN.y-=offNP.y*3.0;\r}\rbool doneNP=(!doneN) || (!doneP);\rif (!doneP) \r{\rposP.x+=offNP.x*3.0;\r}\rif (!doneP)\r{\rposP.y+=offNP.y*3.0;\r}\rif (doneNP)\r{\rif (!doneN) lumaEndN=FxaaLuma(texture2D(textureSampler,posN.xy,0.0));\rif (!doneP) lumaEndP=FxaaLuma(texture2D(textureSampler,posP.xy,0.0));\rif (!doneN) lumaEndN=lumaEndN-lumaNN*0.5;\rif (!doneP) lumaEndP=lumaEndP-lumaNN*0.5;\rdoneN=abs(lumaEndN)>=gradientScaled;\rdoneP=abs(lumaEndP)>=gradientScaled;\rif (!doneN) posN.x-=offNP.x*12.0;\rif (!doneN) posN.y-=offNP.y*12.0;\rdoneNP=(!doneN) || (!doneP);\rif (!doneP) posP.x+=offNP.x*12.0;\rif (!doneP) posP.y+=offNP.y*12.0;\r}\rfloat dstN=posM.x-posN.x;\rfloat dstP=posP.x-posM.x;\rif (!horzSpan)\r{\rdstN=posM.y-posN.y;\r}\rif (!horzSpan) \r{\rdstP=posP.y-posM.y;\r}\rbool goodSpanN=(lumaEndN<0.0) != lumaMLTZero;\rfloat spanLength=(dstP+dstN);\rbool goodSpanP=(lumaEndP<0.0) != lumaMLTZero;\rfloat spanLengthRcp=1.0/spanLength;\rbool directionN=dstN<dstP;\rfloat dst=min(dstN,dstP);\rbool goodSpan=directionN ? goodSpanN : goodSpanP;\rfloat subpixG=subpixF*subpixF;\rfloat pixelOffset=(dst*(-spanLengthRcp))+0.5;\rfloat subpixH=subpixG*fxaaQualitySubpix;\rfloat pixelOffsetGood=goodSpan ? pixelOffset : 0.0;\rfloat pixelOffsetSubpix=max(pixelOffsetGood,subpixH);\rif (!horzSpan)\r{\rposM.x+=pixelOffsetSubpix*lengthSign;\r}\rif (horzSpan)\r{\rposM.y+=pixelOffsetSubpix*lengthSign;\r}\r#ifdef MALI\nif(range<rangeMaxClamped) \r{\rgl_FragColor=rgbyM;\r}\relse\r{\rgl_FragColor=texture2D(textureSampler,posM,0.0);\r}\r#else\ngl_FragColor=texture2D(textureSampler,posM,0.0);\r#endif\n}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport const fxaaPixelShader = { name, shader };\n"]}
+{"version":3,"file":"fxaa.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/fxaa.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,iBAAiB,CAAC;AAC/B,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2Mb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,gBAAgB;AAChB,MAAM,CAAC,MAAM,eAAe,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\n\nconst name = \"fxaaPixelShader\";\nconst shader = `uniform sampler2D textureSampler;\runiform vec2 texelSize;\rvarying vec2 vUV;\rvarying vec2 sampleCoordS;\rvarying vec2 sampleCoordE;\rvarying vec2 sampleCoordN;\rvarying vec2 sampleCoordW;\rvarying vec2 sampleCoordNW;\rvarying vec2 sampleCoordSE;\rvarying vec2 sampleCoordNE;\rvarying vec2 sampleCoordSW;\rconst float fxaaQualitySubpix=1.0;\rconst float fxaaQualityEdgeThreshold=0.166;\rconst float fxaaQualityEdgeThresholdMin=0.0833;\rconst vec3 kLumaCoefficients=vec3(0.2126,0.7152,0.0722);\r#define FxaaLuma(rgba) dot(rgba.rgb,kLumaCoefficients)\nvoid main(){\rvec2 posM;\rposM.x=vUV.x;\rposM.y=vUV.y;\rvec4 rgbyM=texture2D(textureSampler,vUV,0.0);\rfloat lumaM=FxaaLuma(rgbyM);\rfloat lumaS=FxaaLuma(texture2D(textureSampler,sampleCoordS,0.0));\rfloat lumaE=FxaaLuma(texture2D(textureSampler,sampleCoordE,0.0));\rfloat lumaN=FxaaLuma(texture2D(textureSampler,sampleCoordN,0.0));\rfloat lumaW=FxaaLuma(texture2D(textureSampler,sampleCoordW,0.0));\rfloat maxSM=max(lumaS,lumaM);\rfloat minSM=min(lumaS,lumaM);\rfloat maxESM=max(lumaE,maxSM);\rfloat minESM=min(lumaE,minSM);\rfloat maxWN=max(lumaN,lumaW);\rfloat minWN=min(lumaN,lumaW);\rfloat rangeMax=max(maxWN,maxESM);\rfloat rangeMin=min(minWN,minESM);\rfloat rangeMaxScaled=rangeMax*fxaaQualityEdgeThreshold;\rfloat range=rangeMax-rangeMin;\rfloat rangeMaxClamped=max(fxaaQualityEdgeThresholdMin,rangeMaxScaled);\r#ifndef MALI\nif(range<rangeMaxClamped) \r{\rgl_FragColor=rgbyM;\rreturn;\r}\r#endif\nfloat lumaNW=FxaaLuma(texture2D(textureSampler,sampleCoordNW,0.0));\rfloat lumaSE=FxaaLuma(texture2D(textureSampler,sampleCoordSE,0.0));\rfloat lumaNE=FxaaLuma(texture2D(textureSampler,sampleCoordNE,0.0));\rfloat lumaSW=FxaaLuma(texture2D(textureSampler,sampleCoordSW,0.0));\rfloat lumaNS=lumaN+lumaS;\rfloat lumaWE=lumaW+lumaE;\rfloat subpixRcpRange=1.0/range;\rfloat subpixNSWE=lumaNS+lumaWE;\rfloat edgeHorz1=(-2.0*lumaM)+lumaNS;\rfloat edgeVert1=(-2.0*lumaM)+lumaWE;\rfloat lumaNESE=lumaNE+lumaSE;\rfloat lumaNWNE=lumaNW+lumaNE;\rfloat edgeHorz2=(-2.0*lumaE)+lumaNESE;\rfloat edgeVert2=(-2.0*lumaN)+lumaNWNE;\rfloat lumaNWSW=lumaNW+lumaSW;\rfloat lumaSWSE=lumaSW+lumaSE;\rfloat edgeHorz4=(abs(edgeHorz1)*2.0)+abs(edgeHorz2);\rfloat edgeVert4=(abs(edgeVert1)*2.0)+abs(edgeVert2);\rfloat edgeHorz3=(-2.0*lumaW)+lumaNWSW;\rfloat edgeVert3=(-2.0*lumaS)+lumaSWSE;\rfloat edgeHorz=abs(edgeHorz3)+edgeHorz4;\rfloat edgeVert=abs(edgeVert3)+edgeVert4;\rfloat subpixNWSWNESE=lumaNWSW+lumaNESE;\rfloat lengthSign=texelSize.x;\rbool horzSpan=edgeHorz>=edgeVert;\rfloat subpixA=subpixNSWE*2.0+subpixNWSWNESE;\rif (!horzSpan)\r{\rlumaN=lumaW;\r}\rif (!horzSpan) \r{\rlumaS=lumaE;\r}\rif (horzSpan) \r{\rlengthSign=texelSize.y;\r}\rfloat subpixB=(subpixA*(1.0/12.0))-lumaM;\rfloat gradientN=lumaN-lumaM;\rfloat gradientS=lumaS-lumaM;\rfloat lumaNN=lumaN+lumaM;\rfloat lumaSS=lumaS+lumaM;\rbool pairN=abs(gradientN)>=abs(gradientS);\rfloat gradient=max(abs(gradientN),abs(gradientS));\rif (pairN)\r{\rlengthSign=-lengthSign;\r}\rfloat subpixC=clamp(abs(subpixB)*subpixRcpRange,0.0,1.0);\rvec2 posB;\rposB.x=posM.x;\rposB.y=posM.y;\rvec2 offNP;\roffNP.x=(!horzSpan) ? 0.0 : texelSize.x;\roffNP.y=(horzSpan) ? 0.0 : texelSize.y;\rif (!horzSpan) \r{\rposB.x+=lengthSign*0.5;\r}\rif (horzSpan)\r{\rposB.y+=lengthSign*0.5;\r}\rvec2 posN;\rposN.x=posB.x-offNP.x*1.5;\rposN.y=posB.y-offNP.y*1.5;\rvec2 posP;\rposP.x=posB.x+offNP.x*1.5;\rposP.y=posB.y+offNP.y*1.5;\rfloat subpixD=((-2.0)*subpixC)+3.0;\rfloat lumaEndN=FxaaLuma(texture2D(textureSampler,posN,0.0));\rfloat subpixE=subpixC*subpixC;\rfloat lumaEndP=FxaaLuma(texture2D(textureSampler,posP,0.0));\rif (!pairN) \r{\rlumaNN=lumaSS;\r}\rfloat gradientScaled=gradient*1.0/4.0;\rfloat lumaMM=lumaM-lumaNN*0.5;\rfloat subpixF=subpixD*subpixE;\rbool lumaMLTZero=lumaMM<0.0;\rlumaEndN-=lumaNN*0.5;\rlumaEndP-=lumaNN*0.5;\rbool doneN=abs(lumaEndN)>=gradientScaled;\rbool doneP=abs(lumaEndP)>=gradientScaled;\rif (!doneN) \r{\rposN.x-=offNP.x*3.0;\r}\rif (!doneN) \r{\rposN.y-=offNP.y*3.0;\r}\rbool doneNP=(!doneN) || (!doneP);\rif (!doneP) \r{\rposP.x+=offNP.x*3.0;\r}\rif (!doneP)\r{\rposP.y+=offNP.y*3.0;\r}\rif (doneNP)\r{\rif (!doneN) lumaEndN=FxaaLuma(texture2D(textureSampler,posN.xy,0.0));\rif (!doneP) lumaEndP=FxaaLuma(texture2D(textureSampler,posP.xy,0.0));\rif (!doneN) lumaEndN=lumaEndN-lumaNN*0.5;\rif (!doneP) lumaEndP=lumaEndP-lumaNN*0.5;\rdoneN=abs(lumaEndN)>=gradientScaled;\rdoneP=abs(lumaEndP)>=gradientScaled;\rif (!doneN) posN.x-=offNP.x*12.0;\rif (!doneN) posN.y-=offNP.y*12.0;\rdoneNP=(!doneN) || (!doneP);\rif (!doneP) posP.x+=offNP.x*12.0;\rif (!doneP) posP.y+=offNP.y*12.0;\r}\rfloat dstN=posM.x-posN.x;\rfloat dstP=posP.x-posM.x;\rif (!horzSpan)\r{\rdstN=posM.y-posN.y;\r}\rif (!horzSpan) \r{\rdstP=posP.y-posM.y;\r}\rbool goodSpanN=(lumaEndN<0.0) != lumaMLTZero;\rfloat spanLength=(dstP+dstN);\rbool goodSpanP=(lumaEndP<0.0) != lumaMLTZero;\rfloat spanLengthRcp=1.0/spanLength;\rbool directionN=dstN<dstP;\rfloat dst=min(dstN,dstP);\rbool goodSpan=directionN ? goodSpanN : goodSpanP;\rfloat subpixG=subpixF*subpixF;\rfloat pixelOffset=(dst*(-spanLengthRcp))+0.5;\rfloat subpixH=subpixG*fxaaQualitySubpix;\rfloat pixelOffsetGood=goodSpan ? pixelOffset : 0.0;\rfloat pixelOffsetSubpix=max(pixelOffsetGood,subpixH);\rif (!horzSpan)\r{\rposM.x+=pixelOffsetSubpix*lengthSign;\r}\rif (horzSpan)\r{\rposM.y+=pixelOffsetSubpix*lengthSign;\r}\r#ifdef MALI\nif(range<rangeMaxClamped) \r{\rgl_FragColor=rgbyM;\r}\relse\r{\rgl_FragColor=texture2D(textureSampler,posM,0.0);\r}\r#else\ngl_FragColor=texture2D(textureSampler,posM,0.0);\r#endif\n}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const fxaaPixelShader = { name, shader };\n"]}

package/Shaders/fxaa.vertex.d.ts

@@ -1,4 +1,4 @@
-/** @hidden */
+/** @internal */
 export declare const fxaaVertexShader: {
     name: string;
     shader: string;

package/Shaders/fxaa.vertex.js

@@ -7,6 +7,6 @@ vUV=(position*madd+madd);
 }`;
 // Sideeffect
 ShaderStore.ShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const fxaaVertexShader = { name, shader };
 //# sourceMappingURL=fxaa.vertex.js.map

package/Shaders/fxaa.vertex.js.map

@@ -1 +1 @@
-{"version":3,"file":"fxaa.vertex.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/fxaa.vertex.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,kBAAkB,CAAC;AAChC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;EA0Bb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,cAAc;AACd,MAAM,CAAC,MAAM,gBAAgB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\n\nconst name = \"fxaaVertexShader\";\nconst shader = `attribute vec2 position;\runiform vec2 texelSize;\rvarying vec2 vUV;\rvarying vec2 sampleCoordS;\rvarying vec2 sampleCoordE;\rvarying vec2 sampleCoordN;\rvarying vec2 sampleCoordW;\rvarying vec2 sampleCoordNW;\rvarying vec2 sampleCoordSE;\rvarying vec2 sampleCoordNE;\rvarying vec2 sampleCoordSW;\rconst vec2 madd=vec2(0.5,0.5);\r#define CUSTOM_VERTEX_DEFINITIONS\nvoid main(void) {\r#define CUSTOM_VERTEX_MAIN_BEGIN\nvUV=(position*madd+madd);\rsampleCoordS=vUV+vec2( 0.0,1.0)*texelSize;\rsampleCoordE=vUV+vec2( 1.0,0.0)*texelSize;\rsampleCoordN=vUV+vec2( 0.0,-1.0)*texelSize;\rsampleCoordW=vUV+vec2(-1.0,0.0)*texelSize;\rsampleCoordNW=vUV+vec2(-1.0,-1.0)*texelSize;\rsampleCoordSE=vUV+vec2( 1.0,1.0)*texelSize;\rsampleCoordNE=vUV+vec2( 1.0,-1.0)*texelSize;\rsampleCoordSW=vUV+vec2(-1.0,1.0)*texelSize;\rgl_Position=vec4(position,0.0,1.0);\r#define CUSTOM_VERTEX_MAIN_END\n}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport const fxaaVertexShader = { name, shader };\n"]}
+{"version":3,"file":"fxaa.vertex.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/fxaa.vertex.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,kBAAkB,CAAC;AAChC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;EA0Bb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,gBAAgB;AAChB,MAAM,CAAC,MAAM,gBAAgB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\n\nconst name = \"fxaaVertexShader\";\nconst shader = `attribute vec2 position;\runiform vec2 texelSize;\rvarying vec2 vUV;\rvarying vec2 sampleCoordS;\rvarying vec2 sampleCoordE;\rvarying vec2 sampleCoordN;\rvarying vec2 sampleCoordW;\rvarying vec2 sampleCoordNW;\rvarying vec2 sampleCoordSE;\rvarying vec2 sampleCoordNE;\rvarying vec2 sampleCoordSW;\rconst vec2 madd=vec2(0.5,0.5);\r#define CUSTOM_VERTEX_DEFINITIONS\nvoid main(void) {\r#define CUSTOM_VERTEX_MAIN_BEGIN\nvUV=(position*madd+madd);\rsampleCoordS=vUV+vec2( 0.0,1.0)*texelSize;\rsampleCoordE=vUV+vec2( 1.0,0.0)*texelSize;\rsampleCoordN=vUV+vec2( 0.0,-1.0)*texelSize;\rsampleCoordW=vUV+vec2(-1.0,0.0)*texelSize;\rsampleCoordNW=vUV+vec2(-1.0,-1.0)*texelSize;\rsampleCoordSE=vUV+vec2( 1.0,1.0)*texelSize;\rsampleCoordNE=vUV+vec2( 1.0,-1.0)*texelSize;\rsampleCoordSW=vUV+vec2(-1.0,1.0)*texelSize;\rgl_Position=vec4(position,0.0,1.0);\r#define CUSTOM_VERTEX_MAIN_END\n}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const fxaaVertexShader = { name, shader };\n"]}

package/Shaders/geometry.fragment.d.ts

@@ -3,7 +3,7 @@ import "./ShadersInclude/bumpFragmentMainFunctions";
 import "./ShadersInclude/bumpFragmentFunctions";
 import "./ShadersInclude/helperFunctions";
 import "./ShadersInclude/bumpFragment";
-/** @hidden */
+/** @internal */
 export declare const geometryPixelShader: {
     name: string;
     shader: string;

package/Shaders/geometry.fragment.js

@@ -22,7 +22,19 @@ varying vec2 vUV;
 #ifdef BUMP
 uniform vec3 vBumpInfos;
 #if defined(REFLECTIVITY)
-varying vec2 vReflectivityUV;
+#if defined(ORMTEXTURE) || defined(SPECULARGLOSSINESSTEXTURE) || defined(REFLECTIVITYTEXTURE)
+uniform sampler2D reflectivitySampler;
+#ifdef ALBEDOTEXTURE
+varying vec2 vAlbedoUV;
+#ifdef REFLECTIVITYCOLOR
+uniform vec3 reflectivityColor;
+#ifdef ALBEDOCOLOR
+uniform vec3 albedoColor;
+#ifdef METALLIC
+uniform float metallic;
+#ifdef ROUGHNESS
+uniform float glossiness;
+#endif
 #ifdef ALPHATEST
 uniform sampler2D diffuseSampler;
 #include<mrtFragmentDeclaration>[RENDER_TARGET_COUNT]
@@ -83,6 +95,6 @@ reflectivity.rgb=toGammaSpace(reflectivity.rgb);
 }
 // Sideeffect
 ShaderStore.ShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const geometryPixelShader = { name, shader };
 //# sourceMappingURL=geometry.fragment.js.map

package/Shaders/geometry.fragment.js.map

@@ -1 +1 @@
-{"version":3,"file":"geometry.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/geometry.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,yCAAyC,CAAC;AACjD,OAAO,4CAA4C,CAAC;AACpD,OAAO,wCAAwC,CAAC;AAChD,OAAO,kCAAkC,CAAC;AAC1C,OAAO,+BAA+B,CAAC;AAEvC,MAAM,IAAI,GAAG,qBAAqB,CAAC;AACnC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwId,CAAC;AACF,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,cAAc;AACd,MAAM,CAAC,MAAM,mBAAmB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\nimport \"./ShadersInclude/mrtFragmentDeclaration\";\nimport \"./ShadersInclude/bumpFragmentMainFunctions\";\nimport \"./ShadersInclude/bumpFragmentFunctions\";\nimport \"./ShadersInclude/helperFunctions\";\nimport \"./ShadersInclude/bumpFragment\";\n\nconst name = \"geometryPixelShader\";\nconst shader = `#extension GL_EXT_draw_buffers : require\n#if defined(BUMP) || !defined(NORMAL)\n#extension GL_OES_standard_derivatives : enable\n#endif\nprecision highp float;\r#ifdef BUMP\nvarying mat4 vWorldView;\rvarying vec3 vNormalW;\r#else\nvarying vec3 vNormalV;\r#endif\nvarying vec4 vViewPos;\r#if defined(POSITION) || defined(BUMP)\nvarying vec3 vPositionW;\r#endif\n#ifdef VELOCITY\nvarying vec4 vCurrentPosition;\rvarying vec4 vPreviousPosition;\r#endif\n#ifdef NEED_UV\nvarying vec2 vUV;\r#endif\n#ifdef BUMP\nuniform vec3 vBumpInfos;\runiform vec2 vTangentSpaceParams;\r#endif\n#if defined(REFLECTIVITY)\nvarying vec2 vReflectivityUV;\rvarying vec2 vAlbedoUV;\runiform sampler2D reflectivitySampler;\runiform sampler2D albedoSampler;\runiform vec3 reflectivityColor;\runiform vec3 albedoColor;\runiform float metallic;\runiform float glossiness;\r#endif\n#ifdef ALPHATEST\nuniform sampler2D diffuseSampler;\r#endif\n#include<mrtFragmentDeclaration>[RENDER_TARGET_COUNT]\n#include<bumpFragmentMainFunctions>\n#include<bumpFragmentFunctions>\n#include<helperFunctions>\nvoid main() {\r#ifdef ALPHATEST\nif (texture2D(diffuseSampler,vUV).a<0.4)\rdiscard;\r#endif\nvec3 normalOutput;\r#ifdef BUMP\nvec3 normalW=normalize(vNormalW);\r#include<bumpFragment>\nnormalOutput=normalize(vec3(vWorldView*vec4(normalW,0.0)));\r#else\nnormalOutput=normalize(vNormalV);\r#endif\n#ifdef PREPASS\n#ifdef PREPASS_DEPTH\ngl_FragData[DEPTH_INDEX]=vec4(vViewPos.z/vViewPos.w,0.0,0.0,1.0);\r#endif\n#ifdef PREPASS_NORMAL\ngl_FragData[NORMAL_INDEX]=vec4(normalOutput,1.0);\r#endif\n#else\ngl_FragData[0]=vec4(vViewPos.z/vViewPos.w,0.0,0.0,1.0);\rgl_FragData[1]=vec4(normalOutput,1.0);\r#endif\n#ifdef POSITION\ngl_FragData[POSITION_INDEX]=vec4(vPositionW,1.0);\r#endif\n#ifdef VELOCITY\nvec2 a=(vCurrentPosition.xy/vCurrentPosition.w)*0.5+0.5;\rvec2 b=(vPreviousPosition.xy/vPreviousPosition.w)*0.5+0.5;\rvec2 velocity=abs(a-b);\rvelocity=vec2(pow(velocity.x,1.0/3.0),pow(velocity.y,1.0/3.0))*sign(a-b)*0.5+0.5;\rgl_FragData[VELOCITY_INDEX]=vec4(velocity,0.0,1.0);\r#endif\n#ifdef REFLECTIVITY\nvec4 reflectivity=vec4(1.0,1.0,1.0,1.0);\r#ifdef METALLICWORKFLOW\nfloat metal=1.0;\rfloat roughness=1.0;\r#ifdef ORMTEXTURE\nmetal*=texture2D(reflectivitySampler,vReflectivityUV).b;\rroughness*=texture2D(reflectivitySampler,vReflectivityUV).g;\r#endif\n#ifdef METALLIC\nmetal*=metallic;\r#endif\n#ifdef ROUGHNESS\nroughness*=(1.0-glossiness); \r#endif\nreflectivity.a-=roughness;\rvec3 color=vec3(1.0);\r#ifdef ALBEDOTEXTURE\ncolor=texture2D(albedoSampler,vAlbedoUV).rgb;\r#ifdef GAMMAALBEDO\ncolor=toLinearSpace(color);\r#endif\n#endif\n#ifdef ALBEDOCOLOR\ncolor*=albedoColor.xyz;\r#endif\nreflectivity.rgb=mix(vec3(0.04),color,metal);\r#else\n#ifdef SPECULARGLOSSINESSTEXTURE\nreflectivity=texture2D(reflectivitySampler,vReflectivityUV);\r#ifdef GAMMAREFLECTIVITYTEXTURE\nreflectivity.rgb=toLinearSpace(reflectivity.rgb);\r#endif\n#ifdef GLOSSINESSS\nreflectivity.a*=glossiness;\r#endif\n#else \n#ifdef REFLECTIVITYTEXTURE\nreflectivity.rbg=texture2D(reflectivitySampler,vReflectivityUV).rbg;\r#ifdef GAMMAREFLECTIVITYTEXTURE\nreflectivity.rgb=toLinearSpace(reflectivity.rgb);\r#endif\n#else\n#ifdef REFLECTIVITYCOLOR\nreflectivity.rgb=reflectivityColor.xyz;\rreflectivity.a=1.0;\r#endif\n#endif \n#ifdef GLOSSINESSS\nreflectivity.a=glossiness; \r#else\nreflectivity.a=1.0; \r#endif\n#endif\n#endif\nreflectivity.rgb=toGammaSpace(reflectivity.rgb); \rgl_FragData[REFLECTIVITY_INDEX]=reflectivity;\r#endif\n}\r`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport const geometryPixelShader = { name, shader };\n"]}
+{"version":3,"file":"geometry.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/geometry.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,yCAAyC,CAAC;AACjD,OAAO,4CAA4C,CAAC;AACpD,OAAO,wCAAwC,CAAC;AAChD,OAAO,kCAAkC,CAAC;AAC1C,OAAO,+BAA+B,CAAC;AAEvC,MAAM,IAAI,GAAG,qBAAqB,CAAC;AACnC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoJd,CAAC;AACF,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,gBAAgB;AAChB,MAAM,CAAC,MAAM,mBAAmB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\nimport \"./ShadersInclude/mrtFragmentDeclaration\";\nimport \"./ShadersInclude/bumpFragmentMainFunctions\";\nimport \"./ShadersInclude/bumpFragmentFunctions\";\nimport \"./ShadersInclude/helperFunctions\";\nimport \"./ShadersInclude/bumpFragment\";\n\nconst name = \"geometryPixelShader\";\nconst shader = `#extension GL_EXT_draw_buffers : require\n#if defined(BUMP) || !defined(NORMAL)\n#extension GL_OES_standard_derivatives : enable\n#endif\nprecision highp float;\r#ifdef BUMP\nvarying mat4 vWorldView;\rvarying vec3 vNormalW;\r#else\nvarying vec3 vNormalV;\r#endif\nvarying vec4 vViewPos;\r#if defined(POSITION) || defined(BUMP)\nvarying vec3 vPositionW;\r#endif\n#ifdef VELOCITY\nvarying vec4 vCurrentPosition;\rvarying vec4 vPreviousPosition;\r#endif\n#ifdef NEED_UV\nvarying vec2 vUV;\r#endif\n#ifdef BUMP\nuniform vec3 vBumpInfos;\runiform vec2 vTangentSpaceParams;\r#endif\n#if defined(REFLECTIVITY)\n#if defined(ORMTEXTURE) || defined(SPECULARGLOSSINESSTEXTURE) || defined(REFLECTIVITYTEXTURE)\nuniform sampler2D reflectivitySampler;\rvarying vec2 vReflectivityUV;\r#endif\n#ifdef ALBEDOTEXTURE\nvarying vec2 vAlbedoUV;\runiform sampler2D albedoSampler;\r#endif\n#ifdef REFLECTIVITYCOLOR\nuniform vec3 reflectivityColor;\r#endif\n#ifdef ALBEDOCOLOR\nuniform vec3 albedoColor;\r#endif\n#ifdef METALLIC\nuniform float metallic;\r#endif\n#ifdef ROUGHNESS\nuniform float glossiness;\r#endif\n#endif\n#ifdef ALPHATEST\nuniform sampler2D diffuseSampler;\r#endif\n#include<mrtFragmentDeclaration>[RENDER_TARGET_COUNT]\n#include<bumpFragmentMainFunctions>\n#include<bumpFragmentFunctions>\n#include<helperFunctions>\nvoid main() {\r#ifdef ALPHATEST\nif (texture2D(diffuseSampler,vUV).a<0.4)\rdiscard;\r#endif\nvec3 normalOutput;\r#ifdef BUMP\nvec3 normalW=normalize(vNormalW);\r#include<bumpFragment>\nnormalOutput=normalize(vec3(vWorldView*vec4(normalW,0.0)));\r#else\nnormalOutput=normalize(vNormalV);\r#endif\n#ifdef PREPASS\n#ifdef PREPASS_DEPTH\ngl_FragData[DEPTH_INDEX]=vec4(vViewPos.z/vViewPos.w,0.0,0.0,1.0);\r#endif\n#ifdef PREPASS_NORMAL\ngl_FragData[NORMAL_INDEX]=vec4(normalOutput,1.0);\r#endif\n#else\ngl_FragData[0]=vec4(vViewPos.z/vViewPos.w,0.0,0.0,1.0);\rgl_FragData[1]=vec4(normalOutput,1.0);\r#endif\n#ifdef POSITION\ngl_FragData[POSITION_INDEX]=vec4(vPositionW,1.0);\r#endif\n#ifdef VELOCITY\nvec2 a=(vCurrentPosition.xy/vCurrentPosition.w)*0.5+0.5;\rvec2 b=(vPreviousPosition.xy/vPreviousPosition.w)*0.5+0.5;\rvec2 velocity=abs(a-b);\rvelocity=vec2(pow(velocity.x,1.0/3.0),pow(velocity.y,1.0/3.0))*sign(a-b)*0.5+0.5;\rgl_FragData[VELOCITY_INDEX]=vec4(velocity,0.0,1.0);\r#endif\n#ifdef REFLECTIVITY\nvec4 reflectivity=vec4(1.0,1.0,1.0,1.0);\r#ifdef METALLICWORKFLOW\nfloat metal=1.0;\rfloat roughness=1.0;\r#ifdef ORMTEXTURE\nmetal*=texture2D(reflectivitySampler,vReflectivityUV).b;\rroughness*=texture2D(reflectivitySampler,vReflectivityUV).g;\r#endif\n#ifdef METALLIC\nmetal*=metallic;\r#endif\n#ifdef ROUGHNESS\nroughness*=(1.0-glossiness); \r#endif\nreflectivity.a-=roughness;\rvec3 color=vec3(1.0);\r#ifdef ALBEDOTEXTURE\ncolor=texture2D(albedoSampler,vAlbedoUV).rgb;\r#ifdef GAMMAALBEDO\ncolor=toLinearSpace(color);\r#endif\n#endif\n#ifdef ALBEDOCOLOR\ncolor*=albedoColor.xyz;\r#endif\nreflectivity.rgb=mix(vec3(0.04),color,metal);\r#else\n#ifdef SPECULARGLOSSINESSTEXTURE\nreflectivity=texture2D(reflectivitySampler,vReflectivityUV);\r#ifdef GAMMAREFLECTIVITYTEXTURE\nreflectivity.rgb=toLinearSpace(reflectivity.rgb);\r#endif\n#ifdef GLOSSINESSS\nreflectivity.a*=glossiness;\r#endif\n#else \n#ifdef REFLECTIVITYTEXTURE\nreflectivity.rbg=texture2D(reflectivitySampler,vReflectivityUV).rbg;\r#ifdef GAMMAREFLECTIVITYTEXTURE\nreflectivity.rgb=toLinearSpace(reflectivity.rgb);\r#endif\n#else\n#ifdef REFLECTIVITYCOLOR\nreflectivity.rgb=reflectivityColor.xyz;\rreflectivity.a=1.0;\r#endif\n#endif \n#ifdef GLOSSINESSS\nreflectivity.a=glossiness; \r#else\nreflectivity.a=1.0; \r#endif\n#endif\n#endif\nreflectivity.rgb=toGammaSpace(reflectivity.rgb); \rgl_FragData[REFLECTIVITY_INDEX]=reflectivity;\r#endif\n}\r`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const geometryPixelShader = { name, shader };\n"]}

package/Shaders/geometry.vertex.d.ts

@@ -11,7 +11,7 @@ import "./ShadersInclude/instancesVertex";
 import "./ShadersInclude/bonesVertex";
 import "./ShadersInclude/bakedVertexAnimation";
 import "./ShadersInclude/bumpVertex";
-/** @hidden */
+/** @internal */
 export declare const geometryVertexShader: {
     name: string;
     shader: string;

package/Shaders/geometry.vertex.js

@@ -103,6 +103,6 @@ vAlbedoUV=vec2(albedoMatrix*vec4(uv2,1.0,0.0));
 }
 // Sideeffect
 ShaderStore.ShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const geometryVertexShader = { name, shader };
 //# sourceMappingURL=geometry.vertex.js.map

package/Shaders/geometry.vertex.js.map

@@ -1 +1 @@
-{"version":3,"file":"geometry.vertex.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/geometry.vertex.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,mCAAmC,CAAC;AAC3C,OAAO,kDAAkD,CAAC;AAC1D,OAAO,sDAAsD,CAAC;AAC9D,OAAO,gDAAgD,CAAC;AACxD,OAAO,uCAAuC,CAAC;AAC/C,OAAO,4CAA4C,CAAC;AACpD,OAAO,yCAAyC,CAAC;AACjD,OAAO,2CAA2C,CAAC;AACnD,OAAO,qCAAqC,CAAC;AAC7C,OAAO,kCAAkC,CAAC;AAC1C,OAAO,8BAA8B,CAAC;AACtC,OAAO,uCAAuC,CAAC;AAC/C,OAAO,6BAA6B,CAAC;AAErC,MAAM,IAAI,GAAG,sBAAsB,CAAC;AACpC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgJd,CAAC;AACF,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,cAAc;AACd,MAAM,CAAC,MAAM,oBAAoB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\nimport \"./ShadersInclude/bonesDeclaration\";\nimport \"./ShadersInclude/bakedVertexAnimationDeclaration\";\nimport \"./ShadersInclude/morphTargetsVertexGlobalDeclaration\";\nimport \"./ShadersInclude/morphTargetsVertexDeclaration\";\nimport \"./ShadersInclude/instancesDeclaration\";\nimport \"./ShadersInclude/geometryVertexDeclaration\";\nimport \"./ShadersInclude/geometryUboDeclaration\";\nimport \"./ShadersInclude/morphTargetsVertexGlobal\";\nimport \"./ShadersInclude/morphTargetsVertex\";\nimport \"./ShadersInclude/instancesVertex\";\nimport \"./ShadersInclude/bonesVertex\";\nimport \"./ShadersInclude/bakedVertexAnimation\";\nimport \"./ShadersInclude/bumpVertex\";\n\nconst name = \"geometryVertexShader\";\nconst shader = `precision highp float;\r#include<bonesDeclaration>\n#include<bakedVertexAnimationDeclaration>\n#include<morphTargetsVertexGlobalDeclaration>\n#include<morphTargetsVertexDeclaration>[0..maxSimultaneousMorphTargets]\n#include<instancesDeclaration>\n#include<__decl__geometryVertex>\nattribute vec3 position;\rattribute vec3 normal;\r#ifdef NEED_UV\nvarying vec2 vUV;\r#ifdef ALPHATEST\nuniform mat4 diffuseMatrix;\r#endif\n#ifdef BUMP\nuniform mat4 bumpMatrix;\rvarying vec2 vBumpUV;\r#endif\n#ifdef REFLECTIVITY\nuniform mat4 reflectivityMatrix;\runiform mat4 albedoMatrix;\rvarying vec2 vReflectivityUV;\rvarying vec2 vAlbedoUV;\r#endif\n#ifdef UV1\nattribute vec2 uv;\r#endif\n#ifdef UV2\nattribute vec2 uv2;\r#endif\n#endif\n#ifdef BUMP\nvarying mat4 vWorldView;\r#endif\n#ifdef BUMP\nvarying vec3 vNormalW;\r#else\nvarying vec3 vNormalV;\r#endif\nvarying vec4 vViewPos;\r#if defined(POSITION) || defined(BUMP)\nvarying vec3 vPositionW;\r#endif\n#ifdef VELOCITY\nuniform mat4 previousViewProjection;\rvarying vec4 vCurrentPosition;\rvarying vec4 vPreviousPosition;\r#endif\n#define CUSTOM_VERTEX_DEFINITIONS\nvoid main(void)\r{\rvec3 positionUpdated=position;\rvec3 normalUpdated=normal;\r#ifdef UV1\nvec2 uvUpdated=uv;\r#endif\n#include<morphTargetsVertexGlobal>\n#include<morphTargetsVertex>[0..maxSimultaneousMorphTargets]\n#include<instancesVertex>\n#if defined(VELOCITY) && !defined(BONES_VELOCITY_ENABLED)\nvCurrentPosition=viewProjection*finalWorld*vec4(positionUpdated,1.0);\rvPreviousPosition=previousViewProjection*finalPreviousWorld*vec4(positionUpdated,1.0);\r#endif\n#include<bonesVertex>\n#include<bakedVertexAnimation>\nvec4 pos=vec4(finalWorld*vec4(positionUpdated,1.0));\r#ifdef BUMP\nvWorldView=view*finalWorld;\rvNormalW=normalUpdated;\r#else\nvNormalV=normalize(vec3((view*finalWorld)*vec4(normalUpdated,0.0)));\r#endif\nvViewPos=view*pos;\r#if defined(VELOCITY) && defined(BONES_VELOCITY_ENABLED)\nvCurrentPosition=viewProjection*finalWorld*vec4(positionUpdated,1.0);\r#if NUM_BONE_INFLUENCERS>0\nmat4 previousInfluence;\rpreviousInfluence=mPreviousBones[int(matricesIndices[0])]*matricesWeights[0];\r#if NUM_BONE_INFLUENCERS>1\npreviousInfluence+=mPreviousBones[int(matricesIndices[1])]*matricesWeights[1];\r#endif\n#if NUM_BONE_INFLUENCERS>2\npreviousInfluence+=mPreviousBones[int(matricesIndices[2])]*matricesWeights[2];\r#endif\n#if NUM_BONE_INFLUENCERS>3\npreviousInfluence+=mPreviousBones[int(matricesIndices[3])]*matricesWeights[3];\r#endif\n#if NUM_BONE_INFLUENCERS>4\npreviousInfluence+=mPreviousBones[int(matricesIndicesExtra[0])]*matricesWeightsExtra[0];\r#endif\n#if NUM_BONE_INFLUENCERS>5\npreviousInfluence+=mPreviousBones[int(matricesIndicesExtra[1])]*matricesWeightsExtra[1];\r#endif\n#if NUM_BONE_INFLUENCERS>6\npreviousInfluence+=mPreviousBones[int(matricesIndicesExtra[2])]*matricesWeightsExtra[2];\r#endif\n#if NUM_BONE_INFLUENCERS>7\npreviousInfluence+=mPreviousBones[int(matricesIndicesExtra[3])]*matricesWeightsExtra[3];\r#endif\nvPreviousPosition=previousViewProjection*finalPreviousWorld*previousInfluence*vec4(positionUpdated,1.0);\r#else\nvPreviousPosition=previousViewProjection*finalPreviousWorld*vec4(positionUpdated,1.0);\r#endif\n#endif\n#if defined(POSITION) || defined(BUMP)\nvPositionW=pos.xyz/pos.w;\r#endif\ngl_Position=viewProjection*finalWorld*vec4(positionUpdated,1.0);\r#ifdef NEED_UV\n#ifdef UV1\n#if defined(ALPHATEST) && defined(ALPHATEST_UV1)\nvUV=vec2(diffuseMatrix*vec4(uvUpdated,1.0,0.0));\r#else\nvUV=uv;\r#endif\n#ifdef BUMP_UV1\nvBumpUV=vec2(bumpMatrix*vec4(uvUpdated,1.0,0.0));\r#endif\n#ifdef REFLECTIVITY_UV1\nvReflectivityUV=vec2(reflectivityMatrix*vec4(uvUpdated,1.0,0.0));\r#endif\n#ifdef ALBEDO_UV1\nvAlbedoUV=vec2(albedoMatrix*vec4(uvUpdated,1.0,0.0));\r#endif\n#endif\n#ifdef UV2\n#if defined(ALPHATEST) && defined(ALPHATEST_UV2)\nvUV=vec2(diffuseMatrix*vec4(uv2,1.0,0.0));\r#else\nvUV=uv2;\r#endif\n#ifdef BUMP_UV2\nvBumpUV=vec2(bumpMatrix*vec4(uv2,1.0,0.0));\r#endif\n#ifdef REFLECTIVITY_UV2\nvReflectivityUV=vec2(reflectivityMatrix*vec4(uv2,1.0,0.0));\r#endif\n#ifdef ALBEDO_UV2\nvAlbedoUV=vec2(albedoMatrix*vec4(uv2,1.0,0.0));\r#endif\n#endif\n#endif\n#include<bumpVertex>\n}\r`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport const geometryVertexShader = { name, shader };\n"]}
+{"version":3,"file":"geometry.vertex.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/geometry.vertex.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,mCAAmC,CAAC;AAC3C,OAAO,kDAAkD,CAAC;AAC1D,OAAO,sDAAsD,CAAC;AAC9D,OAAO,gDAAgD,CAAC;AACxD,OAAO,uCAAuC,CAAC;AAC/C,OAAO,4CAA4C,CAAC;AACpD,OAAO,yCAAyC,CAAC;AACjD,OAAO,2CAA2C,CAAC;AACnD,OAAO,qCAAqC,CAAC;AAC7C,OAAO,kCAAkC,CAAC;AAC1C,OAAO,8BAA8B,CAAC;AACtC,OAAO,uCAAuC,CAAC;AAC/C,OAAO,6BAA6B,CAAC;AAErC,MAAM,IAAI,GAAG,sBAAsB,CAAC;AACpC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgJd,CAAC;AACF,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,gBAAgB;AAChB,MAAM,CAAC,MAAM,oBAAoB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\nimport \"./ShadersInclude/bonesDeclaration\";\nimport \"./ShadersInclude/bakedVertexAnimationDeclaration\";\nimport \"./ShadersInclude/morphTargetsVertexGlobalDeclaration\";\nimport \"./ShadersInclude/morphTargetsVertexDeclaration\";\nimport \"./ShadersInclude/instancesDeclaration\";\nimport \"./ShadersInclude/geometryVertexDeclaration\";\nimport \"./ShadersInclude/geometryUboDeclaration\";\nimport \"./ShadersInclude/morphTargetsVertexGlobal\";\nimport \"./ShadersInclude/morphTargetsVertex\";\nimport \"./ShadersInclude/instancesVertex\";\nimport \"./ShadersInclude/bonesVertex\";\nimport \"./ShadersInclude/bakedVertexAnimation\";\nimport \"./ShadersInclude/bumpVertex\";\n\nconst name = \"geometryVertexShader\";\nconst shader = `precision highp float;\r#include<bonesDeclaration>\n#include<bakedVertexAnimationDeclaration>\n#include<morphTargetsVertexGlobalDeclaration>\n#include<morphTargetsVertexDeclaration>[0..maxSimultaneousMorphTargets]\n#include<instancesDeclaration>\n#include<__decl__geometryVertex>\nattribute vec3 position;\rattribute vec3 normal;\r#ifdef NEED_UV\nvarying vec2 vUV;\r#ifdef ALPHATEST\nuniform mat4 diffuseMatrix;\r#endif\n#ifdef BUMP\nuniform mat4 bumpMatrix;\rvarying vec2 vBumpUV;\r#endif\n#ifdef REFLECTIVITY\nuniform mat4 reflectivityMatrix;\runiform mat4 albedoMatrix;\rvarying vec2 vReflectivityUV;\rvarying vec2 vAlbedoUV;\r#endif\n#ifdef UV1\nattribute vec2 uv;\r#endif\n#ifdef UV2\nattribute vec2 uv2;\r#endif\n#endif\n#ifdef BUMP\nvarying mat4 vWorldView;\r#endif\n#ifdef BUMP\nvarying vec3 vNormalW;\r#else\nvarying vec3 vNormalV;\r#endif\nvarying vec4 vViewPos;\r#if defined(POSITION) || defined(BUMP)\nvarying vec3 vPositionW;\r#endif\n#ifdef VELOCITY\nuniform mat4 previousViewProjection;\rvarying vec4 vCurrentPosition;\rvarying vec4 vPreviousPosition;\r#endif\n#define CUSTOM_VERTEX_DEFINITIONS\nvoid main(void)\r{\rvec3 positionUpdated=position;\rvec3 normalUpdated=normal;\r#ifdef UV1\nvec2 uvUpdated=uv;\r#endif\n#include<morphTargetsVertexGlobal>\n#include<morphTargetsVertex>[0..maxSimultaneousMorphTargets]\n#include<instancesVertex>\n#if defined(VELOCITY) && !defined(BONES_VELOCITY_ENABLED)\nvCurrentPosition=viewProjection*finalWorld*vec4(positionUpdated,1.0);\rvPreviousPosition=previousViewProjection*finalPreviousWorld*vec4(positionUpdated,1.0);\r#endif\n#include<bonesVertex>\n#include<bakedVertexAnimation>\nvec4 pos=vec4(finalWorld*vec4(positionUpdated,1.0));\r#ifdef BUMP\nvWorldView=view*finalWorld;\rvNormalW=normalUpdated;\r#else\nvNormalV=normalize(vec3((view*finalWorld)*vec4(normalUpdated,0.0)));\r#endif\nvViewPos=view*pos;\r#if defined(VELOCITY) && defined(BONES_VELOCITY_ENABLED)\nvCurrentPosition=viewProjection*finalWorld*vec4(positionUpdated,1.0);\r#if NUM_BONE_INFLUENCERS>0\nmat4 previousInfluence;\rpreviousInfluence=mPreviousBones[int(matricesIndices[0])]*matricesWeights[0];\r#if NUM_BONE_INFLUENCERS>1\npreviousInfluence+=mPreviousBones[int(matricesIndices[1])]*matricesWeights[1];\r#endif\n#if NUM_BONE_INFLUENCERS>2\npreviousInfluence+=mPreviousBones[int(matricesIndices[2])]*matricesWeights[2];\r#endif\n#if NUM_BONE_INFLUENCERS>3\npreviousInfluence+=mPreviousBones[int(matricesIndices[3])]*matricesWeights[3];\r#endif\n#if NUM_BONE_INFLUENCERS>4\npreviousInfluence+=mPreviousBones[int(matricesIndicesExtra[0])]*matricesWeightsExtra[0];\r#endif\n#if NUM_BONE_INFLUENCERS>5\npreviousInfluence+=mPreviousBones[int(matricesIndicesExtra[1])]*matricesWeightsExtra[1];\r#endif\n#if NUM_BONE_INFLUENCERS>6\npreviousInfluence+=mPreviousBones[int(matricesIndicesExtra[2])]*matricesWeightsExtra[2];\r#endif\n#if NUM_BONE_INFLUENCERS>7\npreviousInfluence+=mPreviousBones[int(matricesIndicesExtra[3])]*matricesWeightsExtra[3];\r#endif\nvPreviousPosition=previousViewProjection*finalPreviousWorld*previousInfluence*vec4(positionUpdated,1.0);\r#else\nvPreviousPosition=previousViewProjection*finalPreviousWorld*vec4(positionUpdated,1.0);\r#endif\n#endif\n#if defined(POSITION) || defined(BUMP)\nvPositionW=pos.xyz/pos.w;\r#endif\ngl_Position=viewProjection*finalWorld*vec4(positionUpdated,1.0);\r#ifdef NEED_UV\n#ifdef UV1\n#if defined(ALPHATEST) && defined(ALPHATEST_UV1)\nvUV=vec2(diffuseMatrix*vec4(uvUpdated,1.0,0.0));\r#else\nvUV=uv;\r#endif\n#ifdef BUMP_UV1\nvBumpUV=vec2(bumpMatrix*vec4(uvUpdated,1.0,0.0));\r#endif\n#ifdef REFLECTIVITY_UV1\nvReflectivityUV=vec2(reflectivityMatrix*vec4(uvUpdated,1.0,0.0));\r#endif\n#ifdef ALBEDO_UV1\nvAlbedoUV=vec2(albedoMatrix*vec4(uvUpdated,1.0,0.0));\r#endif\n#endif\n#ifdef UV2\n#if defined(ALPHATEST) && defined(ALPHATEST_UV2)\nvUV=vec2(diffuseMatrix*vec4(uv2,1.0,0.0));\r#else\nvUV=uv2;\r#endif\n#ifdef BUMP_UV2\nvBumpUV=vec2(bumpMatrix*vec4(uv2,1.0,0.0));\r#endif\n#ifdef REFLECTIVITY_UV2\nvReflectivityUV=vec2(reflectivityMatrix*vec4(uv2,1.0,0.0));\r#endif\n#ifdef ALBEDO_UV2\nvAlbedoUV=vec2(albedoMatrix*vec4(uv2,1.0,0.0));\r#endif\n#endif\n#endif\n#include<bumpVertex>\n}\r`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const geometryVertexShader = { name, shader };\n"]}

package/Shaders/glowBlurPostProcess.fragment.d.ts

@@ -1,4 +1,4 @@
-/** @hidden */
+/** @internal */
 export declare const glowBlurPostProcessPixelShader: {
     name: string;
     shader: string;

package/Shaders/glowBlurPostProcess.fragment.js

@@ -5,6 +5,6 @@ const shader = `varying vec2 vUV;
 void main(void)
 // Sideeffect
 ShaderStore.ShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const glowBlurPostProcessPixelShader = { name, shader };
 //# sourceMappingURL=glowBlurPostProcess.fragment.js.map

package/Shaders/glowBlurPostProcess.fragment.js.map

@@ -1 +1 @@
-{"version":3,"file":"glowBlurPostProcess.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/glowBlurPostProcess.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,gCAAgC,CAAC;AAC9C,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoCb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,cAAc;AACd,MAAM,CAAC,MAAM,8BAA8B,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\n\nconst name = \"glowBlurPostProcessPixelShader\";\nconst shader = `varying vec2 vUV;\runiform sampler2D textureSampler;\runiform vec2 screenSize;\runiform vec2 direction;\runiform float blurWidth;\rfloat getLuminance(vec3 color)\r{\rreturn dot(color,vec3(0.2126,0.7152,0.0722));\r}\r#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void)\r{\rfloat weights[7];\rweights[0]=0.05;\rweights[1]=0.1;\rweights[2]=0.2;\rweights[3]=0.3;\rweights[4]=0.2;\rweights[5]=0.1;\rweights[6]=0.05;\rvec2 texelSize=vec2(1.0/screenSize.x,1.0/screenSize.y);\rvec2 texelStep=texelSize*direction*blurWidth;\rvec2 start=vUV-3.0*texelStep;\rvec4 baseColor=vec4(0.,0.,0.,0.);\rvec2 texelOffset=vec2(0.,0.);\rfor (int i=0; i<7; i++)\r{\rvec4 texel=texture2D(textureSampler,start+texelOffset);\rbaseColor.a+=texel.a*weights[i];\rfloat luminance=getLuminance(baseColor.rgb);\rfloat luminanceTexel=getLuminance(texel.rgb);\rfloat choice=step(luminanceTexel,luminance);\rbaseColor.rgb=choice*baseColor.rgb+(1.0-choice)*texel.rgb;\rtexelOffset+=texelStep;\r}\rgl_FragColor=baseColor;\r}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport const glowBlurPostProcessPixelShader = { name, shader };\n"]}
+{"version":3,"file":"glowBlurPostProcess.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/glowBlurPostProcess.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,gCAAgC,CAAC;AAC9C,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoCb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,gBAAgB;AAChB,MAAM,CAAC,MAAM,8BAA8B,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\n\nconst name = \"glowBlurPostProcessPixelShader\";\nconst shader = `varying vec2 vUV;\runiform sampler2D textureSampler;\runiform vec2 screenSize;\runiform vec2 direction;\runiform float blurWidth;\rfloat getLuminance(vec3 color)\r{\rreturn dot(color,vec3(0.2126,0.7152,0.0722));\r}\r#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void)\r{\rfloat weights[7];\rweights[0]=0.05;\rweights[1]=0.1;\rweights[2]=0.2;\rweights[3]=0.3;\rweights[4]=0.2;\rweights[5]=0.1;\rweights[6]=0.05;\rvec2 texelSize=vec2(1.0/screenSize.x,1.0/screenSize.y);\rvec2 texelStep=texelSize*direction*blurWidth;\rvec2 start=vUV-3.0*texelStep;\rvec4 baseColor=vec4(0.,0.,0.,0.);\rvec2 texelOffset=vec2(0.,0.);\rfor (int i=0; i<7; i++)\r{\rvec4 texel=texture2D(textureSampler,start+texelOffset);\rbaseColor.a+=texel.a*weights[i];\rfloat luminance=getLuminance(baseColor.rgb);\rfloat luminanceTexel=getLuminance(texel.rgb);\rfloat choice=step(luminanceTexel,luminance);\rbaseColor.rgb=choice*baseColor.rgb+(1.0-choice)*texel.rgb;\rtexelOffset+=texelStep;\r}\rgl_FragColor=baseColor;\r}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const glowBlurPostProcessPixelShader = { name, shader };\n"]}

package/Shaders/glowMapGeneration.fragment.d.ts

@@ -1,7 +1,7 @@
 import "./ShadersInclude/helperFunctions";
 import "./ShadersInclude/clipPlaneFragmentDeclaration";
 import "./ShadersInclude/clipPlaneFragment";
-/** @hidden */
+/** @internal */
 export declare const glowMapGenerationPixelShader: {
     name: string;
     shader: string;

package/Shaders/glowMapGeneration.fragment.js

@@ -45,6 +45,6 @@ gl_FragColor.a=glowColor.a;
 }`;
 // Sideeffect
 ShaderStore.ShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const glowMapGenerationPixelShader = { name, shader };
 //# sourceMappingURL=glowMapGeneration.fragment.js.map

package/Shaders/glowMapGeneration.fragment.js.map

@@ -1 +1 @@
-{"version":3,"file":"glowMapGeneration.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/glowMapGeneration.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,kCAAkC,CAAC;AAC1C,OAAO,+CAA+C,CAAC;AACvD,OAAO,oCAAoC,CAAC;AAE5C,MAAM,IAAI,GAAG,8BAA8B,CAAC;AAC5C,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkEb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,cAAc;AACd,MAAM,CAAC,MAAM,4BAA4B,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\nimport \"./ShadersInclude/helperFunctions\";\nimport \"./ShadersInclude/clipPlaneFragmentDeclaration\";\nimport \"./ShadersInclude/clipPlaneFragment\";\n\nconst name = \"glowMapGenerationPixelShader\";\nconst shader = `#if defined(DIFFUSE_ISLINEAR) || defined(EMISSIVE_ISLINEAR)\n#include<helperFunctions>\n#endif\n#ifdef DIFFUSE\nvarying vec2 vUVDiffuse;\runiform sampler2D diffuseSampler;\r#endif\n#ifdef OPACITY\nvarying vec2 vUVOpacity;\runiform sampler2D opacitySampler;\runiform float opacityIntensity;\r#endif\n#ifdef EMISSIVE\nvarying vec2 vUVEmissive;\runiform sampler2D emissiveSampler;\r#endif\n#ifdef VERTEXALPHA\nvarying vec4 vColor;\r#endif\nuniform vec4 glowColor;\r#include<clipPlaneFragmentDeclaration>\n#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void)\r{\r#include<clipPlaneFragment>\nvec4 finalColor=glowColor;\r#ifdef DIFFUSE\nvec4 albedoTexture=texture2D(diffuseSampler,vUVDiffuse);\r#ifdef DIFFUSE_ISLINEAR\nalbedoTexture=toGammaSpace(albedoTexture);\r#endif\n#ifdef GLOW\nfinalColor.a*=albedoTexture.a;\r#endif\n#ifdef HIGHLIGHT\nfinalColor.a=albedoTexture.a;\r#endif\n#endif\n#ifdef OPACITY\nvec4 opacityMap=texture2D(opacitySampler,vUVOpacity);\r#ifdef OPACITYRGB\nfinalColor.a*=getLuminance(opacityMap.rgb);\r#else\nfinalColor.a*=opacityMap.a;\r#endif\nfinalColor.a*=opacityIntensity;\r#endif\n#ifdef VERTEXALPHA\nfinalColor.a*=vColor.a;\r#endif\n#ifdef ALPHATEST\nif (finalColor.a<ALPHATESTVALUE)\rdiscard;\r#endif\n#ifdef EMISSIVE\nvec4 emissive=texture2D(emissiveSampler,vUVEmissive);\r#ifdef EMISSIVE_ISLINEAR\nemissive=toGammaSpace(emissive);\r#endif\ngl_FragColor=emissive*finalColor;\r#else\ngl_FragColor=finalColor;\r#endif\n#ifdef HIGHLIGHT\ngl_FragColor.a=glowColor.a;\r#endif\n}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport const glowMapGenerationPixelShader = { name, shader };\n"]}
+{"version":3,"file":"glowMapGeneration.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/glowMapGeneration.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,kCAAkC,CAAC;AAC1C,OAAO,+CAA+C,CAAC;AACvD,OAAO,oCAAoC,CAAC;AAE5C,MAAM,IAAI,GAAG,8BAA8B,CAAC;AAC5C,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkEb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,gBAAgB;AAChB,MAAM,CAAC,MAAM,4BAA4B,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\nimport \"./ShadersInclude/helperFunctions\";\nimport \"./ShadersInclude/clipPlaneFragmentDeclaration\";\nimport \"./ShadersInclude/clipPlaneFragment\";\n\nconst name = \"glowMapGenerationPixelShader\";\nconst shader = `#if defined(DIFFUSE_ISLINEAR) || defined(EMISSIVE_ISLINEAR)\n#include<helperFunctions>\n#endif\n#ifdef DIFFUSE\nvarying vec2 vUVDiffuse;\runiform sampler2D diffuseSampler;\r#endif\n#ifdef OPACITY\nvarying vec2 vUVOpacity;\runiform sampler2D opacitySampler;\runiform float opacityIntensity;\r#endif\n#ifdef EMISSIVE\nvarying vec2 vUVEmissive;\runiform sampler2D emissiveSampler;\r#endif\n#ifdef VERTEXALPHA\nvarying vec4 vColor;\r#endif\nuniform vec4 glowColor;\r#include<clipPlaneFragmentDeclaration>\n#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void)\r{\r#include<clipPlaneFragment>\nvec4 finalColor=glowColor;\r#ifdef DIFFUSE\nvec4 albedoTexture=texture2D(diffuseSampler,vUVDiffuse);\r#ifdef DIFFUSE_ISLINEAR\nalbedoTexture=toGammaSpace(albedoTexture);\r#endif\n#ifdef GLOW\nfinalColor.a*=albedoTexture.a;\r#endif\n#ifdef HIGHLIGHT\nfinalColor.a=albedoTexture.a;\r#endif\n#endif\n#ifdef OPACITY\nvec4 opacityMap=texture2D(opacitySampler,vUVOpacity);\r#ifdef OPACITYRGB\nfinalColor.a*=getLuminance(opacityMap.rgb);\r#else\nfinalColor.a*=opacityMap.a;\r#endif\nfinalColor.a*=opacityIntensity;\r#endif\n#ifdef VERTEXALPHA\nfinalColor.a*=vColor.a;\r#endif\n#ifdef ALPHATEST\nif (finalColor.a<ALPHATESTVALUE)\rdiscard;\r#endif\n#ifdef EMISSIVE\nvec4 emissive=texture2D(emissiveSampler,vUVEmissive);\r#ifdef EMISSIVE_ISLINEAR\nemissive=toGammaSpace(emissive);\r#endif\ngl_FragColor=emissive*finalColor;\r#else\ngl_FragColor=finalColor;\r#endif\n#ifdef HIGHLIGHT\ngl_FragColor.a=glowColor.a;\r#endif\n}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const glowMapGenerationPixelShader = { name, shader };\n"]}

package/Shaders/glowMapGeneration.vertex.d.ts

@@ -10,7 +10,7 @@ import "./ShadersInclude/instancesVertex";
 import "./ShadersInclude/bonesVertex";
 import "./ShadersInclude/bakedVertexAnimation";
 import "./ShadersInclude/clipPlaneVertex";
-/** @hidden */
+/** @internal */
 export declare const glowMapGenerationVertexShader: {
     name: string;
     shader: string;

package/Shaders/glowMapGeneration.vertex.js

@@ -66,6 +66,6 @@ vColor=color;
 }`;
 // Sideeffect
 ShaderStore.ShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const glowMapGenerationVertexShader = { name, shader };
 //# sourceMappingURL=glowMapGeneration.vertex.js.map

package/Shaders/glowMapGeneration.vertex.js.map

@@ -1 +1 @@
-{"version":3,"file":"glowMapGeneration.vertex.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/glowMapGeneration.vertex.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,mCAAmC,CAAC;AAC3C,OAAO,kDAAkD,CAAC;AAC1D,OAAO,sDAAsD,CAAC;AAC9D,OAAO,gDAAgD,CAAC;AACxD,OAAO,6CAA6C,CAAC;AACrD,OAAO,uCAAuC,CAAC;AAC/C,OAAO,2CAA2C,CAAC;AACnD,OAAO,qCAAqC,CAAC;AAC7C,OAAO,kCAAkC,CAAC;AAC1C,OAAO,8BAA8B,CAAC;AACtC,OAAO,uCAAuC,CAAC;AAC/C,OAAO,kCAAkC,CAAC;AAE1C,MAAM,IAAI,GAAG,+BAA+B,CAAC;AAC7C,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+Eb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,cAAc;AACd,MAAM,CAAC,MAAM,6BAA6B,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\nimport \"./ShadersInclude/bonesDeclaration\";\nimport \"./ShadersInclude/bakedVertexAnimationDeclaration\";\nimport \"./ShadersInclude/morphTargetsVertexGlobalDeclaration\";\nimport \"./ShadersInclude/morphTargetsVertexDeclaration\";\nimport \"./ShadersInclude/clipPlaneVertexDeclaration\";\nimport \"./ShadersInclude/instancesDeclaration\";\nimport \"./ShadersInclude/morphTargetsVertexGlobal\";\nimport \"./ShadersInclude/morphTargetsVertex\";\nimport \"./ShadersInclude/instancesVertex\";\nimport \"./ShadersInclude/bonesVertex\";\nimport \"./ShadersInclude/bakedVertexAnimation\";\nimport \"./ShadersInclude/clipPlaneVertex\";\n\nconst name = \"glowMapGenerationVertexShader\";\nconst shader = `attribute vec3 position;\r#include<bonesDeclaration>\n#include<bakedVertexAnimationDeclaration>\n#include<morphTargetsVertexGlobalDeclaration>\n#include<morphTargetsVertexDeclaration>[0..maxSimultaneousMorphTargets]\n#include<clipPlaneVertexDeclaration>\n#include<instancesDeclaration>\nuniform mat4 viewProjection;\rvarying vec4 vPosition;\r#ifdef UV1\nattribute vec2 uv;\r#endif\n#ifdef UV2\nattribute vec2 uv2;\r#endif\n#ifdef DIFFUSE\nvarying vec2 vUVDiffuse;\runiform mat4 diffuseMatrix;\r#endif\n#ifdef OPACITY\nvarying vec2 vUVOpacity;\runiform mat4 opacityMatrix;\r#endif\n#ifdef EMISSIVE\nvarying vec2 vUVEmissive;\runiform mat4 emissiveMatrix;\r#endif\n#ifdef VERTEXALPHA\nattribute vec4 color;\rvarying vec4 vColor;\r#endif\n#define CUSTOM_VERTEX_DEFINITIONS\nvoid main(void)\r{\rvec3 positionUpdated=position;\r#ifdef UV1\nvec2 uvUpdated=uv;\r#endif\n#include<morphTargetsVertexGlobal>\n#include<morphTargetsVertex>[0..maxSimultaneousMorphTargets]\n#include<instancesVertex>\n#include<bonesVertex>\n#include<bakedVertexAnimation>\nvec4 worldPos=finalWorld*vec4(positionUpdated,1.0);\r#ifdef CUBEMAP\nvPosition=worldPos;\rgl_Position=viewProjection*finalWorld*vec4(position,1.0);\r#else\nvPosition=viewProjection*worldPos;\rgl_Position=vPosition;\r#endif\n#ifdef DIFFUSE\n#ifdef DIFFUSEUV1\nvUVDiffuse=vec2(diffuseMatrix*vec4(uvUpdated,1.0,0.0));\r#endif\n#ifdef DIFFUSEUV2\nvUVDiffuse=vec2(diffuseMatrix*vec4(uv2,1.0,0.0));\r#endif\n#endif\n#ifdef OPACITY\n#ifdef OPACITYUV1\nvUVOpacity=vec2(opacityMatrix*vec4(uvUpdated,1.0,0.0));\r#endif\n#ifdef OPACITYUV2\nvUVOpacity=vec2(opacityMatrix*vec4(uv2,1.0,0.0));\r#endif\n#endif\n#ifdef EMISSIVE\n#ifdef EMISSIVEUV1\nvUVEmissive=vec2(emissiveMatrix*vec4(uvUpdated,1.0,0.0));\r#endif\n#ifdef EMISSIVEUV2\nvUVEmissive=vec2(emissiveMatrix*vec4(uv2,1.0,0.0));\r#endif\n#endif\n#ifdef VERTEXALPHA\nvColor=color;\r#endif\n#include<clipPlaneVertex>\n}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport const glowMapGenerationVertexShader = { name, shader };\n"]}
+{"version":3,"file":"glowMapGeneration.vertex.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/glowMapGeneration.vertex.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,mCAAmC,CAAC;AAC3C,OAAO,kDAAkD,CAAC;AAC1D,OAAO,sDAAsD,CAAC;AAC9D,OAAO,gDAAgD,CAAC;AACxD,OAAO,6CAA6C,CAAC;AACrD,OAAO,uCAAuC,CAAC;AAC/C,OAAO,2CAA2C,CAAC;AACnD,OAAO,qCAAqC,CAAC;AAC7C,OAAO,kCAAkC,CAAC;AAC1C,OAAO,8BAA8B,CAAC;AACtC,OAAO,uCAAuC,CAAC;AAC/C,OAAO,kCAAkC,CAAC;AAE1C,MAAM,IAAI,GAAG,+BAA+B,CAAC;AAC7C,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+Eb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,gBAAgB;AAChB,MAAM,CAAC,MAAM,6BAA6B,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\nimport \"./ShadersInclude/bonesDeclaration\";\nimport \"./ShadersInclude/bakedVertexAnimationDeclaration\";\nimport \"./ShadersInclude/morphTargetsVertexGlobalDeclaration\";\nimport \"./ShadersInclude/morphTargetsVertexDeclaration\";\nimport \"./ShadersInclude/clipPlaneVertexDeclaration\";\nimport \"./ShadersInclude/instancesDeclaration\";\nimport \"./ShadersInclude/morphTargetsVertexGlobal\";\nimport \"./ShadersInclude/morphTargetsVertex\";\nimport \"./ShadersInclude/instancesVertex\";\nimport \"./ShadersInclude/bonesVertex\";\nimport \"./ShadersInclude/bakedVertexAnimation\";\nimport \"./ShadersInclude/clipPlaneVertex\";\n\nconst name = \"glowMapGenerationVertexShader\";\nconst shader = `attribute vec3 position;\r#include<bonesDeclaration>\n#include<bakedVertexAnimationDeclaration>\n#include<morphTargetsVertexGlobalDeclaration>\n#include<morphTargetsVertexDeclaration>[0..maxSimultaneousMorphTargets]\n#include<clipPlaneVertexDeclaration>\n#include<instancesDeclaration>\nuniform mat4 viewProjection;\rvarying vec4 vPosition;\r#ifdef UV1\nattribute vec2 uv;\r#endif\n#ifdef UV2\nattribute vec2 uv2;\r#endif\n#ifdef DIFFUSE\nvarying vec2 vUVDiffuse;\runiform mat4 diffuseMatrix;\r#endif\n#ifdef OPACITY\nvarying vec2 vUVOpacity;\runiform mat4 opacityMatrix;\r#endif\n#ifdef EMISSIVE\nvarying vec2 vUVEmissive;\runiform mat4 emissiveMatrix;\r#endif\n#ifdef VERTEXALPHA\nattribute vec4 color;\rvarying vec4 vColor;\r#endif\n#define CUSTOM_VERTEX_DEFINITIONS\nvoid main(void)\r{\rvec3 positionUpdated=position;\r#ifdef UV1\nvec2 uvUpdated=uv;\r#endif\n#include<morphTargetsVertexGlobal>\n#include<morphTargetsVertex>[0..maxSimultaneousMorphTargets]\n#include<instancesVertex>\n#include<bonesVertex>\n#include<bakedVertexAnimation>\nvec4 worldPos=finalWorld*vec4(positionUpdated,1.0);\r#ifdef CUBEMAP\nvPosition=worldPos;\rgl_Position=viewProjection*finalWorld*vec4(position,1.0);\r#else\nvPosition=viewProjection*worldPos;\rgl_Position=vPosition;\r#endif\n#ifdef DIFFUSE\n#ifdef DIFFUSEUV1\nvUVDiffuse=vec2(diffuseMatrix*vec4(uvUpdated,1.0,0.0));\r#endif\n#ifdef DIFFUSEUV2\nvUVDiffuse=vec2(diffuseMatrix*vec4(uv2,1.0,0.0));\r#endif\n#endif\n#ifdef OPACITY\n#ifdef OPACITYUV1\nvUVOpacity=vec2(opacityMatrix*vec4(uvUpdated,1.0,0.0));\r#endif\n#ifdef OPACITYUV2\nvUVOpacity=vec2(opacityMatrix*vec4(uv2,1.0,0.0));\r#endif\n#endif\n#ifdef EMISSIVE\n#ifdef EMISSIVEUV1\nvUVEmissive=vec2(emissiveMatrix*vec4(uvUpdated,1.0,0.0));\r#endif\n#ifdef EMISSIVEUV2\nvUVEmissive=vec2(emissiveMatrix*vec4(uv2,1.0,0.0));\r#endif\n#endif\n#ifdef VERTEXALPHA\nvColor=color;\r#endif\n#include<clipPlaneVertex>\n}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const glowMapGenerationVertexShader = { name, shader };\n"]}

package/Shaders/glowMapMerge.fragment.d.ts

@@ -1,4 +1,4 @@
-/** @hidden */
+/** @internal */
 export declare const glowMapMergePixelShader: {
     name: string;
     shader: string;

package/Shaders/glowMapMerge.fragment.js

@@ -16,6 +16,6 @@ gl_FragColor=baseColor;
 }`;
 // Sideeffect
 ShaderStore.ShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const glowMapMergePixelShader = { name, shader };
 //# sourceMappingURL=glowMapMerge.fragment.js.map

package/Shaders/glowMapMerge.fragment.js.map

@@ -1 +1 @@
-{"version":3,"file":"glowMapMerge.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/glowMapMerge.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,yBAAyB,CAAC;AACvC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;EA0Bb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,cAAc;AACd,MAAM,CAAC,MAAM,uBAAuB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\n\nconst name = \"glowMapMergePixelShader\";\nconst shader = `varying vec2 vUV;\runiform sampler2D textureSampler;\r#ifdef EMISSIVE\nuniform sampler2D textureSampler2;\r#endif\nuniform float offset;\r#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void) {\r#define CUSTOM_FRAGMENT_MAIN_BEGIN\nvec4 baseColor=texture2D(textureSampler,vUV);\r#ifdef EMISSIVE\nbaseColor+=texture2D(textureSampler2,vUV);\rbaseColor*=offset;\r#else\nbaseColor.a=abs(offset-baseColor.a);\r#ifdef STROKE\nfloat alpha=smoothstep(.0,.1,baseColor.a);\rbaseColor.a=alpha;\rbaseColor.rgb=baseColor.rgb*alpha;\r#endif\n#endif\n#if LDR\nbaseColor=clamp(baseColor,0.,1.0);\r#endif\ngl_FragColor=baseColor;\r#define CUSTOM_FRAGMENT_MAIN_END\n}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport const glowMapMergePixelShader = { name, shader };\n"]}
+{"version":3,"file":"glowMapMerge.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/glowMapMerge.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,yBAAyB,CAAC;AACvC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;EA0Bb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,gBAAgB;AAChB,MAAM,CAAC,MAAM,uBAAuB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\n\nconst name = \"glowMapMergePixelShader\";\nconst shader = `varying vec2 vUV;\runiform sampler2D textureSampler;\r#ifdef EMISSIVE\nuniform sampler2D textureSampler2;\r#endif\nuniform float offset;\r#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void) {\r#define CUSTOM_FRAGMENT_MAIN_BEGIN\nvec4 baseColor=texture2D(textureSampler,vUV);\r#ifdef EMISSIVE\nbaseColor+=texture2D(textureSampler2,vUV);\rbaseColor*=offset;\r#else\nbaseColor.a=abs(offset-baseColor.a);\r#ifdef STROKE\nfloat alpha=smoothstep(.0,.1,baseColor.a);\rbaseColor.a=alpha;\rbaseColor.rgb=baseColor.rgb*alpha;\r#endif\n#endif\n#if LDR\nbaseColor=clamp(baseColor,0.,1.0);\r#endif\ngl_FragColor=baseColor;\r#define CUSTOM_FRAGMENT_MAIN_END\n}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const glowMapMergePixelShader = { name, shader };\n"]}

package/Shaders/glowMapMerge.vertex.d.ts

@@ -1,4 +1,4 @@
-/** @hidden */
+/** @internal */
 export declare const glowMapMergeVertexShader: {
     name: string;
     shader: string;

package/Shaders/glowMapMerge.vertex.js

@@ -7,6 +7,6 @@ vUV=position*madd+madd;
 }`;
 // Sideeffect
 ShaderStore.ShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const glowMapMergeVertexShader = { name, shader };
 //# sourceMappingURL=glowMapMerge.vertex.js.map

package/Shaders/glowMapMerge.vertex.js.map

@@ -1 +1 @@
-{"version":3,"file":"glowMapMerge.vertex.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/glowMapMerge.vertex.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,0BAA0B,CAAC;AACxC,MAAM,MAAM,GAAG;;;;;;;;;EASb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,cAAc;AACd,MAAM,CAAC,MAAM,wBAAwB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\n\nconst name = \"glowMapMergeVertexShader\";\nconst shader = `attribute vec2 position;\rvarying vec2 vUV;\rconst vec2 madd=vec2(0.5,0.5);\r#define CUSTOM_VERTEX_DEFINITIONS\nvoid main(void) {\r#define CUSTOM_VERTEX_MAIN_BEGIN\nvUV=position*madd+madd;\rgl_Position=vec4(position,0.0,1.0);\r#define CUSTOM_VERTEX_MAIN_END\n}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport const glowMapMergeVertexShader = { name, shader };\n"]}
+{"version":3,"file":"glowMapMerge.vertex.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/glowMapMerge.vertex.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,0BAA0B,CAAC;AACxC,MAAM,MAAM,GAAG;;;;;;;;;EASb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,gBAAgB;AAChB,MAAM,CAAC,MAAM,wBAAwB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\n\nconst name = \"glowMapMergeVertexShader\";\nconst shader = `attribute vec2 position;\rvarying vec2 vUV;\rconst vec2 madd=vec2(0.5,0.5);\r#define CUSTOM_VERTEX_DEFINITIONS\nvoid main(void) {\r#define CUSTOM_VERTEX_MAIN_BEGIN\nvUV=position*madd+madd;\rgl_Position=vec4(position,0.0,1.0);\r#define CUSTOM_VERTEX_MAIN_END\n}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const glowMapMergeVertexShader = { name, shader };\n"]}

package/Shaders/gpuRenderParticles.fragment.d.ts

@@ -3,7 +3,7 @@ import "./ShadersInclude/imageProcessingDeclaration";
 import "./ShadersInclude/helperFunctions";
 import "./ShadersInclude/imageProcessingFunctions";
 import "./ShadersInclude/clipPlaneFragment";
-/** @hidden */
+/** @internal */
 export declare const gpuRenderParticlesPixelShader: {
     name: string;
     shader: string;

package/Shaders/gpuRenderParticles.fragment.js

@@ -21,6 +21,6 @@ gl_FragColor.rgb=toLinearSpace(gl_FragColor.rgb);
 }
 // Sideeffect
 ShaderStore.ShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const gpuRenderParticlesPixelShader = { name, shader };
 //# sourceMappingURL=gpuRenderParticles.fragment.js.map

package/Shaders/gpuRenderParticles.fragment.js.map

@@ -1 +1 @@
-{"version":3,"file":"gpuRenderParticles.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/gpuRenderParticles.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,gDAAgD,CAAC;AACxD,OAAO,6CAA6C,CAAC;AACrD,OAAO,kCAAkC,CAAC;AAC1C,OAAO,2CAA2C,CAAC;AACnD,OAAO,oCAAoC,CAAC;AAE5C,MAAM,IAAI,GAAG,+BAA+B,CAAC;AAC7C,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;CAyBd,CAAC;AACF,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,cAAc;AACd,MAAM,CAAC,MAAM,6BAA6B,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\nimport \"./ShadersInclude/clipPlaneFragmentDeclaration2\";\nimport \"./ShadersInclude/imageProcessingDeclaration\";\nimport \"./ShadersInclude/helperFunctions\";\nimport \"./ShadersInclude/imageProcessingFunctions\";\nimport \"./ShadersInclude/clipPlaneFragment\";\n\nconst name = \"gpuRenderParticlesPixelShader\";\nconst shader = `precision highp float;\runiform sampler2D diffuseSampler;\rvarying vec2 vUV;\rvarying vec4 vColor;\r#include<clipPlaneFragmentDeclaration2> \n#include<imageProcessingDeclaration>\n#include<helperFunctions>\n#include<imageProcessingFunctions>\nvoid main() {\r#include<clipPlaneFragment> \nvec4 textureColor=texture2D(diffuseSampler,vUV);\rgl_FragColor=textureColor*vColor;\r#ifdef BLENDMULTIPLYMODE\nfloat alpha=vColor.a*textureColor.a;\rgl_FragColor.rgb=gl_FragColor.rgb*alpha+vec3(1.0)*(1.0-alpha);\r#endif \n#ifdef IMAGEPROCESSINGPOSTPROCESS\ngl_FragColor.rgb=toLinearSpace(gl_FragColor.rgb);\r#else\n#ifdef IMAGEPROCESSING\ngl_FragColor.rgb=toLinearSpace(gl_FragColor.rgb);\rgl_FragColor=applyImageProcessing(gl_FragColor);\r#endif\n#endif\n}\r`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport const gpuRenderParticlesPixelShader = { name, shader };\n"]}
+{"version":3,"file":"gpuRenderParticles.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/gpuRenderParticles.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,gDAAgD,CAAC;AACxD,OAAO,6CAA6C,CAAC;AACrD,OAAO,kCAAkC,CAAC;AAC1C,OAAO,2CAA2C,CAAC;AACnD,OAAO,oCAAoC,CAAC;AAE5C,MAAM,IAAI,GAAG,+BAA+B,CAAC;AAC7C,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;CAyBd,CAAC;AACF,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,gBAAgB;AAChB,MAAM,CAAC,MAAM,6BAA6B,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\nimport \"./ShadersInclude/clipPlaneFragmentDeclaration2\";\nimport \"./ShadersInclude/imageProcessingDeclaration\";\nimport \"./ShadersInclude/helperFunctions\";\nimport \"./ShadersInclude/imageProcessingFunctions\";\nimport \"./ShadersInclude/clipPlaneFragment\";\n\nconst name = \"gpuRenderParticlesPixelShader\";\nconst shader = `precision highp float;\runiform sampler2D diffuseSampler;\rvarying vec2 vUV;\rvarying vec4 vColor;\r#include<clipPlaneFragmentDeclaration2> \n#include<imageProcessingDeclaration>\n#include<helperFunctions>\n#include<imageProcessingFunctions>\nvoid main() {\r#include<clipPlaneFragment> \nvec4 textureColor=texture2D(diffuseSampler,vUV);\rgl_FragColor=textureColor*vColor;\r#ifdef BLENDMULTIPLYMODE\nfloat alpha=vColor.a*textureColor.a;\rgl_FragColor.rgb=gl_FragColor.rgb*alpha+vec3(1.0)*(1.0-alpha);\r#endif \n#ifdef IMAGEPROCESSINGPOSTPROCESS\ngl_FragColor.rgb=toLinearSpace(gl_FragColor.rgb);\r#else\n#ifdef IMAGEPROCESSING\ngl_FragColor.rgb=toLinearSpace(gl_FragColor.rgb);\rgl_FragColor=applyImageProcessing(gl_FragColor);\r#endif\n#endif\n}\r`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const gpuRenderParticlesPixelShader = { name, shader };\n"]}

package/Shaders/gpuRenderParticles.vertex.d.ts

@@ -1,6 +1,6 @@
 import "./ShadersInclude/clipPlaneVertexDeclaration2";
 import "./ShadersInclude/clipPlaneVertex";
-/** @hidden */
+/** @internal */
 export declare const gpuRenderParticlesVertexShader: {
     name: string;
     shader: string;

package/Shaders/gpuRenderParticles.vertex.js

@@ -51,6 +51,6 @@ vec4 worldPos=vec4(vPositionW,1.0);
 }`;
 // Sideeffect
 ShaderStore.ShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const gpuRenderParticlesVertexShader = { name, shader };
 //# sourceMappingURL=gpuRenderParticles.vertex.js.map

package/Shaders/gpuRenderParticles.vertex.js.map

@@ -1 +1 @@
-{"version":3,"file":"gpuRenderParticles.vertex.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/gpuRenderParticles.vertex.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,8CAA8C,CAAC;AACtD,OAAO,kCAAkC,CAAC;AAE1C,MAAM,IAAI,GAAG,gCAAgC,CAAC;AAC9C,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsIb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,cAAc;AACd,MAAM,CAAC,MAAM,8BAA8B,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\nimport \"./ShadersInclude/clipPlaneVertexDeclaration2\";\nimport \"./ShadersInclude/clipPlaneVertex\";\n\nconst name = \"gpuRenderParticlesVertexShader\";\nconst shader = `precision highp float;\runiform mat4 view;\runiform mat4 projection;\runiform vec2 translationPivot;\runiform vec3 worldOffset;\r#ifdef LOCAL\nuniform mat4 emitterWM;\r#endif\nattribute vec3 position;\rattribute float age;\rattribute float life;\rattribute vec3 size;\r#ifndef BILLBOARD\nattribute vec3 initialDirection;\r#endif\n#ifdef BILLBOARDSTRETCHED\nattribute vec3 direction;\r#endif\nattribute float angle;\r#ifdef ANIMATESHEET\nattribute float cellIndex;\r#endif\nattribute vec2 offset;\rattribute vec2 uv;\rvarying vec2 vUV;\rvarying vec4 vColor;\rvarying vec3 vPositionW;\r#if defined(BILLBOARD) && !defined(BILLBOARDY) && !defined(BILLBOARDSTRETCHED)\nuniform mat4 invView;\r#endif\n#include<clipPlaneVertexDeclaration2>\n#ifdef COLORGRADIENTS\nuniform sampler2D colorGradientSampler;\r#else\nuniform vec4 colorDead;\rattribute vec4 color;\r#endif\n#ifdef ANIMATESHEET\nuniform vec3 sheetInfos;\r#endif\n#ifdef BILLBOARD\nuniform vec3 eyePosition;\r#endif\nvec3 rotate(vec3 yaxis,vec3 rotatedCorner) {\rvec3 xaxis=normalize(cross(vec3(0.,1.0,0.),yaxis));\rvec3 zaxis=normalize(cross(yaxis,xaxis));\rvec3 row0=vec3(xaxis.x,xaxis.y,xaxis.z);\rvec3 row1=vec3(yaxis.x,yaxis.y,yaxis.z);\rvec3 row2=vec3(zaxis.x,zaxis.y,zaxis.z);\rmat3 rotMatrix= mat3(row0,row1,row2);\rvec3 alignedCorner=rotMatrix*rotatedCorner;\r#ifdef LOCAL\nreturn ((emitterWM*vec4(position,1.0)).xyz+worldOffset)+alignedCorner;\r#else\nreturn (position+worldOffset)+alignedCorner;\r#endif\n}\r#ifdef BILLBOARDSTRETCHED\nvec3 rotateAlign(vec3 toCamera,vec3 rotatedCorner) {\rvec3 normalizedToCamera=normalize(toCamera);\rvec3 normalizedCrossDirToCamera=normalize(cross(normalize(direction),normalizedToCamera));\rvec3 crossProduct=normalize(cross(normalizedToCamera,normalizedCrossDirToCamera));\rvec3 row0=vec3(normalizedCrossDirToCamera.x,normalizedCrossDirToCamera.y,normalizedCrossDirToCamera.z);\rvec3 row1=vec3(crossProduct.x,crossProduct.y,crossProduct.z);\rvec3 row2=vec3(normalizedToCamera.x,normalizedToCamera.y,normalizedToCamera.z);\rmat3 rotMatrix= mat3(row0,row1,row2);\rvec3 alignedCorner=rotMatrix*rotatedCorner;\r#ifdef LOCAL\nreturn ((emitterWM*vec4(position,1.0)).xyz+worldOffset)+alignedCorner;\r#else\nreturn (position+worldOffset)+alignedCorner;\r#endif\n}\r#endif\nvoid main() {\r#ifdef ANIMATESHEET\nfloat rowOffset=floor(cellIndex/sheetInfos.z);\rfloat columnOffset=cellIndex-rowOffset*sheetInfos.z;\rvec2 uvScale=sheetInfos.xy;\rvec2 uvOffset=vec2(uv.x ,1.0-uv.y);\rvUV=(uvOffset+vec2(columnOffset,rowOffset))*uvScale;\r#else\nvUV=uv;\r#endif\nfloat ratio=age/life;\r#ifdef COLORGRADIENTS\nvColor=texture2D(colorGradientSampler,vec2(ratio,0));\r#else\nvColor=color*vec4(1.0-ratio)+colorDead*vec4(ratio);\r#endif\nvec2 cornerPos=(offset-translationPivot)*size.yz*size.x+translationPivot;\r#ifdef BILLBOARD\nvec4 rotatedCorner;\rrotatedCorner.w=0.;\r#ifdef BILLBOARDY\nrotatedCorner.x=cornerPos.x*cos(angle)-cornerPos.y*sin(angle);\rrotatedCorner.z=cornerPos.x*sin(angle)+cornerPos.y*cos(angle);\rrotatedCorner.y=0.;\rvec3 yaxis=(position+worldOffset)-eyePosition;\ryaxis.y=0.;\rvPositionW=rotate(normalize(yaxis),rotatedCorner.xyz);\rvec4 viewPosition=(view*vec4(vPositionW,1.0));\r#elif defined(BILLBOARDSTRETCHED)\nrotatedCorner.x=cornerPos.x*cos(angle)-cornerPos.y*sin(angle);\rrotatedCorner.y=cornerPos.x*sin(angle)+cornerPos.y*cos(angle);\rrotatedCorner.z=0.;\rvec3 toCamera=(position+worldOffset)-eyePosition;\rvPositionW=rotateAlign(toCamera,rotatedCorner.xyz);\rvec4 viewPosition=(view*vec4(vPositionW,1.0));\r#else\nrotatedCorner.x=cornerPos.x*cos(angle)-cornerPos.y*sin(angle);\rrotatedCorner.y=cornerPos.x*sin(angle)+cornerPos.y*cos(angle);\rrotatedCorner.z=0.;\r#ifdef LOCAL\nvec4 viewPosition=view*vec4(((emitterWM*vec4(position,1.0)).xyz+worldOffset),1.0)+rotatedCorner;\r#else\nvec4 viewPosition=view*vec4((position+worldOffset),1.0)+rotatedCorner;\r#endif\nvPositionW=(invView*viewPosition).xyz;\r#endif\n#else\nvec3 rotatedCorner;\rrotatedCorner.x=cornerPos.x*cos(angle)-cornerPos.y*sin(angle);\rrotatedCorner.y=0.;\rrotatedCorner.z=cornerPos.x*sin(angle)+cornerPos.y*cos(angle);\rvec3 yaxis=normalize(initialDirection);\rvPositionW=rotate(yaxis,rotatedCorner);\rvec4 viewPosition=view*vec4(vPositionW,1.0);\r#endif\ngl_Position=projection*viewPosition;\r#if defined(CLIPPLANE) || defined(CLIPPLANE2) || defined(CLIPPLANE3) || defined(CLIPPLANE4) || defined(CLIPPLANE5) || defined(CLIPPLANE6)\nvec4 worldPos=vec4(vPositionW,1.0);\r#endif\n#include<clipPlaneVertex>\n}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport const gpuRenderParticlesVertexShader = { name, shader };\n"]}
+{"version":3,"file":"gpuRenderParticles.vertex.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/gpuRenderParticles.vertex.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,8CAA8C,CAAC;AACtD,OAAO,kCAAkC,CAAC;AAE1C,MAAM,IAAI,GAAG,gCAAgC,CAAC;AAC9C,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsIb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,gBAAgB;AAChB,MAAM,CAAC,MAAM,8BAA8B,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\nimport \"./ShadersInclude/clipPlaneVertexDeclaration2\";\nimport \"./ShadersInclude/clipPlaneVertex\";\n\nconst name = \"gpuRenderParticlesVertexShader\";\nconst shader = `precision highp float;\runiform mat4 view;\runiform mat4 projection;\runiform vec2 translationPivot;\runiform vec3 worldOffset;\r#ifdef LOCAL\nuniform mat4 emitterWM;\r#endif\nattribute vec3 position;\rattribute float age;\rattribute float life;\rattribute vec3 size;\r#ifndef BILLBOARD\nattribute vec3 initialDirection;\r#endif\n#ifdef BILLBOARDSTRETCHED\nattribute vec3 direction;\r#endif\nattribute float angle;\r#ifdef ANIMATESHEET\nattribute float cellIndex;\r#endif\nattribute vec2 offset;\rattribute vec2 uv;\rvarying vec2 vUV;\rvarying vec4 vColor;\rvarying vec3 vPositionW;\r#if defined(BILLBOARD) && !defined(BILLBOARDY) && !defined(BILLBOARDSTRETCHED)\nuniform mat4 invView;\r#endif\n#include<clipPlaneVertexDeclaration2>\n#ifdef COLORGRADIENTS\nuniform sampler2D colorGradientSampler;\r#else\nuniform vec4 colorDead;\rattribute vec4 color;\r#endif\n#ifdef ANIMATESHEET\nuniform vec3 sheetInfos;\r#endif\n#ifdef BILLBOARD\nuniform vec3 eyePosition;\r#endif\nvec3 rotate(vec3 yaxis,vec3 rotatedCorner) {\rvec3 xaxis=normalize(cross(vec3(0.,1.0,0.),yaxis));\rvec3 zaxis=normalize(cross(yaxis,xaxis));\rvec3 row0=vec3(xaxis.x,xaxis.y,xaxis.z);\rvec3 row1=vec3(yaxis.x,yaxis.y,yaxis.z);\rvec3 row2=vec3(zaxis.x,zaxis.y,zaxis.z);\rmat3 rotMatrix= mat3(row0,row1,row2);\rvec3 alignedCorner=rotMatrix*rotatedCorner;\r#ifdef LOCAL\nreturn ((emitterWM*vec4(position,1.0)).xyz+worldOffset)+alignedCorner;\r#else\nreturn (position+worldOffset)+alignedCorner;\r#endif\n}\r#ifdef BILLBOARDSTRETCHED\nvec3 rotateAlign(vec3 toCamera,vec3 rotatedCorner) {\rvec3 normalizedToCamera=normalize(toCamera);\rvec3 normalizedCrossDirToCamera=normalize(cross(normalize(direction),normalizedToCamera));\rvec3 crossProduct=normalize(cross(normalizedToCamera,normalizedCrossDirToCamera));\rvec3 row0=vec3(normalizedCrossDirToCamera.x,normalizedCrossDirToCamera.y,normalizedCrossDirToCamera.z);\rvec3 row1=vec3(crossProduct.x,crossProduct.y,crossProduct.z);\rvec3 row2=vec3(normalizedToCamera.x,normalizedToCamera.y,normalizedToCamera.z);\rmat3 rotMatrix= mat3(row0,row1,row2);\rvec3 alignedCorner=rotMatrix*rotatedCorner;\r#ifdef LOCAL\nreturn ((emitterWM*vec4(position,1.0)).xyz+worldOffset)+alignedCorner;\r#else\nreturn (position+worldOffset)+alignedCorner;\r#endif\n}\r#endif\nvoid main() {\r#ifdef ANIMATESHEET\nfloat rowOffset=floor(cellIndex/sheetInfos.z);\rfloat columnOffset=cellIndex-rowOffset*sheetInfos.z;\rvec2 uvScale=sheetInfos.xy;\rvec2 uvOffset=vec2(uv.x ,1.0-uv.y);\rvUV=(uvOffset+vec2(columnOffset,rowOffset))*uvScale;\r#else\nvUV=uv;\r#endif\nfloat ratio=age/life;\r#ifdef COLORGRADIENTS\nvColor=texture2D(colorGradientSampler,vec2(ratio,0));\r#else\nvColor=color*vec4(1.0-ratio)+colorDead*vec4(ratio);\r#endif\nvec2 cornerPos=(offset-translationPivot)*size.yz*size.x+translationPivot;\r#ifdef BILLBOARD\nvec4 rotatedCorner;\rrotatedCorner.w=0.;\r#ifdef BILLBOARDY\nrotatedCorner.x=cornerPos.x*cos(angle)-cornerPos.y*sin(angle);\rrotatedCorner.z=cornerPos.x*sin(angle)+cornerPos.y*cos(angle);\rrotatedCorner.y=0.;\rvec3 yaxis=(position+worldOffset)-eyePosition;\ryaxis.y=0.;\rvPositionW=rotate(normalize(yaxis),rotatedCorner.xyz);\rvec4 viewPosition=(view*vec4(vPositionW,1.0));\r#elif defined(BILLBOARDSTRETCHED)\nrotatedCorner.x=cornerPos.x*cos(angle)-cornerPos.y*sin(angle);\rrotatedCorner.y=cornerPos.x*sin(angle)+cornerPos.y*cos(angle);\rrotatedCorner.z=0.;\rvec3 toCamera=(position+worldOffset)-eyePosition;\rvPositionW=rotateAlign(toCamera,rotatedCorner.xyz);\rvec4 viewPosition=(view*vec4(vPositionW,1.0));\r#else\nrotatedCorner.x=cornerPos.x*cos(angle)-cornerPos.y*sin(angle);\rrotatedCorner.y=cornerPos.x*sin(angle)+cornerPos.y*cos(angle);\rrotatedCorner.z=0.;\r#ifdef LOCAL\nvec4 viewPosition=view*vec4(((emitterWM*vec4(position,1.0)).xyz+worldOffset),1.0)+rotatedCorner;\r#else\nvec4 viewPosition=view*vec4((position+worldOffset),1.0)+rotatedCorner;\r#endif\nvPositionW=(invView*viewPosition).xyz;\r#endif\n#else\nvec3 rotatedCorner;\rrotatedCorner.x=cornerPos.x*cos(angle)-cornerPos.y*sin(angle);\rrotatedCorner.y=0.;\rrotatedCorner.z=cornerPos.x*sin(angle)+cornerPos.y*cos(angle);\rvec3 yaxis=normalize(initialDirection);\rvPositionW=rotate(yaxis,rotatedCorner);\rvec4 viewPosition=view*vec4(vPositionW,1.0);\r#endif\ngl_Position=projection*viewPosition;\r#if defined(CLIPPLANE) || defined(CLIPPLANE2) || defined(CLIPPLANE3) || defined(CLIPPLANE4) || defined(CLIPPLANE5) || defined(CLIPPLANE6)\nvec4 worldPos=vec4(vPositionW,1.0);\r#endif\n#include<clipPlaneVertex>\n}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const gpuRenderParticlesVertexShader = { name, shader };\n"]}

package/Shaders/gpuUpdateParticles.fragment.d.ts

@@ -1,4 +1,4 @@
-/** @hidden */
+/** @internal */
 export declare const gpuUpdateParticlesPixelShader: {
     name: string;
     shader: string;

package/Shaders/gpuUpdateParticles.fragment.js

@@ -5,6 +5,6 @@ const shader = `#version 300 es
 void main() {
 // Sideeffect
 ShaderStore.ShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const gpuUpdateParticlesPixelShader = { name, shader };
 //# sourceMappingURL=gpuUpdateParticles.fragment.js.map

package/Shaders/gpuUpdateParticles.fragment.js.map

@@ -1 +1 @@
-{"version":3,"file":"gpuUpdateParticles.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/gpuUpdateParticles.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,+BAA+B,CAAC;AAC7C,MAAM,MAAM,GAAG;;;;CAId,CAAC;AACF,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,cAAc;AACd,MAAM,CAAC,MAAM,6BAA6B,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\n\nconst name = \"gpuUpdateParticlesPixelShader\";\nconst shader = `#version 300 es\nvoid main() {\rdiscard;\r}\r`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport const gpuUpdateParticlesPixelShader = { name, shader };\n"]}
+{"version":3,"file":"gpuUpdateParticles.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/gpuUpdateParticles.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,+BAA+B,CAAC;AAC7C,MAAM,MAAM,GAAG;;;;CAId,CAAC;AACF,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,gBAAgB;AAChB,MAAM,CAAC,MAAM,6BAA6B,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\n\nconst name = \"gpuUpdateParticlesPixelShader\";\nconst shader = `#version 300 es\nvoid main() {\rdiscard;\r}\r`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const gpuUpdateParticlesPixelShader = { name, shader };\n"]}

package/Shaders/gpuUpdateParticles.vertex.d.ts

@@ -1,4 +1,4 @@
-/** @hidden */
+/** @internal */
 export declare const gpuUpdateParticlesVertexShader: {
     name: string;
     shader: string;

package/Shaders/gpuUpdateParticles.vertex.js

@@ -146,6 +146,6 @@ float ratio=0.;
 }
 // Sideeffect
 ShaderStore.ShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const gpuUpdateParticlesVertexShader = { name, shader };
 //# sourceMappingURL=gpuUpdateParticles.vertex.js.map

package/Shaders/gpuUpdateParticles.vertex.js.map

@@ -1 +1 @@
-{"version":3,"file":"gpuUpdateParticles.vertex.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/gpuUpdateParticles.vertex.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,gCAAgC,CAAC;AAC9C,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4Wb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,cAAc;AACd,MAAM,CAAC,MAAM,8BAA8B,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\n\nconst name = \"gpuUpdateParticlesVertexShader\";\nconst shader = `#version 300 es\n#define PI 3.14159\nuniform float currentCount;\runiform float timeDelta;\runiform float stopFactor;\r#ifndef LOCAL\nuniform mat4 emitterWM;\r#endif\nuniform vec2 lifeTime;\runiform vec2 emitPower;\runiform vec2 sizeRange;\runiform vec4 scaleRange;\r#ifndef COLORGRADIENTS\nuniform vec4 color1;\runiform vec4 color2;\r#endif\nuniform vec3 gravity;\runiform sampler2D randomSampler;\runiform sampler2D randomSampler2;\runiform vec4 angleRange;\r#ifdef BOXEMITTER\nuniform vec3 direction1;\runiform vec3 direction2;\runiform vec3 minEmitBox;\runiform vec3 maxEmitBox;\r#endif\n#ifdef POINTEMITTER\nuniform vec3 direction1;\runiform vec3 direction2;\r#endif\n#ifdef HEMISPHERICEMITTER\nuniform float radius;\runiform float radiusRange;\runiform float directionRandomizer;\r#endif\n#ifdef SPHEREEMITTER\nuniform float radius;\runiform float radiusRange;\r#ifdef DIRECTEDSPHEREEMITTER\nuniform vec3 direction1;\runiform vec3 direction2;\r#else\nuniform float directionRandomizer;\r#endif\n#endif\n#ifdef CYLINDEREMITTER\nuniform float radius;\runiform float height;\runiform float radiusRange;\r#ifdef DIRECTEDCYLINDEREMITTER\nuniform vec3 direction1;\runiform vec3 direction2;\r#else\nuniform float directionRandomizer;\r#endif\n#endif\n#ifdef CONEEMITTER\nuniform vec2 radius;\runiform float coneAngle;\runiform vec2 height;\runiform float directionRandomizer;\r#endif\nin vec3 position;\r#ifdef CUSTOMEMITTER\nin vec3 initialPosition;\r#endif\nin float age;\rin float life;\rin vec4 seed;\rin vec3 size;\r#ifndef COLORGRADIENTS\nin vec4 color;\r#endif\nin vec3 direction;\r#ifndef BILLBOARD\nin vec3 initialDirection;\r#endif\n#ifdef ANGULARSPEEDGRADIENTS\nin float angle;\r#else\nin vec2 angle;\r#endif\n#ifdef ANIMATESHEET\nin float cellIndex;\r#ifdef ANIMATESHEETRANDOMSTART\nin float cellStartOffset;\r#endif\n#endif\n#ifdef NOISE\nin vec3 noiseCoordinates1;\rin vec3 noiseCoordinates2;\r#endif\nout vec3 outPosition;\r#ifdef CUSTOMEMITTER\nout vec3 outInitialPosition;\r#endif\nout float outAge;\rout float outLife;\rout vec4 outSeed;\rout vec3 outSize;\r#ifndef COLORGRADIENTS\nout vec4 outColor;\r#endif\nout vec3 outDirection;\r#ifndef BILLBOARD\nout vec3 outInitialDirection;\r#endif\n#ifdef ANGULARSPEEDGRADIENTS\nout float outAngle;\r#else\nout vec2 outAngle;\r#endif\n#ifdef ANIMATESHEET\nout float outCellIndex;\r#ifdef ANIMATESHEETRANDOMSTART\nout float outCellStartOffset;\r#endif\n#endif\n#ifdef NOISE\nout vec3 outNoiseCoordinates1;\rout vec3 outNoiseCoordinates2;\r#endif\n#ifdef SIZEGRADIENTS\nuniform sampler2D sizeGradientSampler;\r#endif \n#ifdef ANGULARSPEEDGRADIENTS\nuniform sampler2D angularSpeedGradientSampler;\r#endif \n#ifdef VELOCITYGRADIENTS\nuniform sampler2D velocityGradientSampler;\r#endif\n#ifdef LIMITVELOCITYGRADIENTS\nuniform sampler2D limitVelocityGradientSampler;\runiform float limitVelocityDamping;\r#endif\n#ifdef DRAGGRADIENTS\nuniform sampler2D dragGradientSampler;\r#endif\n#ifdef NOISE\nuniform vec3 noiseStrength;\runiform sampler2D noiseSampler;\r#endif\n#ifdef ANIMATESHEET\nuniform vec4 cellInfos;\r#endif\nvec3 getRandomVec3(float offset) {\rreturn texture(randomSampler2,vec2(float(gl_VertexID)*offset/currentCount,0)).rgb;\r}\rvec4 getRandomVec4(float offset) {\rreturn texture(randomSampler,vec2(float(gl_VertexID)*offset/currentCount,0));\r}\rvoid main() {\rfloat newAge=age+timeDelta; \rif (newAge>=life && stopFactor != 0.) {\rvec3 newPosition;\rvec3 newDirection;\rvec4 randoms=getRandomVec4(seed.x);\routLife=lifeTime.x+(lifeTime.y-lifeTime.x)*randoms.r;\routAge=newAge-life;\routSeed=seed;\r#ifdef SIZEGRADIENTS \noutSize.x=texture(sizeGradientSampler,vec2(0,0)).r;\r#else\noutSize.x=sizeRange.x+(sizeRange.y-sizeRange.x)*randoms.g;\r#endif\noutSize.y=scaleRange.x+(scaleRange.y-scaleRange.x)*randoms.b;\routSize.z=scaleRange.z+(scaleRange.w-scaleRange.z)*randoms.a; \r#ifndef COLORGRADIENTS\noutColor=color1+(color2-color1)*randoms.b;\r#endif\n#ifndef ANGULARSPEEDGRADIENTS \noutAngle.y=angleRange.x+(angleRange.y-angleRange.x)*randoms.a;\routAngle.x=angleRange.z+(angleRange.w-angleRange.z)*randoms.r;\r#else\noutAngle=angleRange.z+(angleRange.w-angleRange.z)*randoms.r;\r#endif \n#ifdef POINTEMITTER\nvec3 randoms2=getRandomVec3(seed.y);\rvec3 randoms3=getRandomVec3(seed.z);\rnewPosition=vec3(0,0,0);\rnewDirection=direction1+(direction2-direction1)*randoms3;\r#elif defined(BOXEMITTER)\nvec3 randoms2=getRandomVec3(seed.y);\rvec3 randoms3=getRandomVec3(seed.z);\rnewPosition=minEmitBox+(maxEmitBox-minEmitBox)*randoms2;\rnewDirection=direction1+(direction2-direction1)*randoms3; \r#elif defined(HEMISPHERICEMITTER)\nvec3 randoms2=getRandomVec3(seed.y);\rvec3 randoms3=getRandomVec3(seed.z);\rfloat phi=2.0*PI*randoms2.x;\rfloat theta=acos(2.0*randoms2.y-1.0);\rfloat randX=cos(phi)*sin(theta);\rfloat randY=cos(theta);\rfloat randZ=sin(phi)*sin(theta);\rnewPosition=(radius-(radius*radiusRange*randoms2.z))*vec3(randX,abs(randY),randZ);\rnewDirection=newPosition+directionRandomizer*randoms3; \r#elif defined(SPHEREEMITTER)\nvec3 randoms2=getRandomVec3(seed.y);\rvec3 randoms3=getRandomVec3(seed.z);\rfloat phi=2.0*PI*randoms2.x;\rfloat theta=acos(2.0*randoms2.y-1.0);\rfloat randX=cos(phi)*sin(theta);\rfloat randY=cos(theta);\rfloat randZ=sin(phi)*sin(theta);\rnewPosition=(radius-(radius*radiusRange*randoms2.z))*vec3(randX,randY,randZ);\r#ifdef DIRECTEDSPHEREEMITTER\nnewDirection=normalize(direction1+(direction2-direction1)*randoms3);\r#else\nnewDirection=normalize(newPosition+directionRandomizer*randoms3);\r#endif\n#elif defined(CYLINDEREMITTER)\nvec3 randoms2=getRandomVec3(seed.y);\rvec3 randoms3=getRandomVec3(seed.z);\rfloat yPos=(randoms2.x-0.5)*height;\rfloat angle=randoms2.y*PI*2.;\rfloat inverseRadiusRangeSquared=((1.-radiusRange)*(1.-radiusRange));\rfloat positionRadius=radius*sqrt(inverseRadiusRangeSquared+(randoms2.z*(1.-inverseRadiusRangeSquared)));\rfloat xPos=positionRadius*cos(angle);\rfloat zPos=positionRadius*sin(angle);\rnewPosition=vec3(xPos,yPos,zPos);\r#ifdef DIRECTEDCYLINDEREMITTER\nnewDirection=direction1+(direction2-direction1)*randoms3;\r#else\nangle=angle+((randoms3.x-0.5)*PI)*directionRandomizer;\rnewDirection=vec3(cos(angle),(randoms3.y-0.5)*directionRandomizer,sin(angle));\rnewDirection=normalize(newDirection);\r#endif\n#elif defined(CONEEMITTER)\nvec3 randoms2=getRandomVec3(seed.y);\rfloat s=2.0*PI*randoms2.x;\r#ifdef CONEEMITTERSPAWNPOINT\nfloat h=0.0001;\r#else\nfloat h=randoms2.y*height.y;\rh=1.-h*h; \r#endif\nfloat lRadius=radius.x-radius.x*randoms2.z*radius.y;\rlRadius=lRadius*h;\rfloat randX=lRadius*sin(s);\rfloat randZ=lRadius*cos(s);\rfloat randY=h *height.x;\rnewPosition=vec3(randX,randY,randZ); \rif (abs(cos(coneAngle))==1.0) {\rnewDirection=vec3(0.,1.0,0.);\r} else {\rvec3 randoms3=getRandomVec3(seed.z);\rnewDirection=normalize(newPosition+directionRandomizer*randoms3); \r}\r#elif defined(CUSTOMEMITTER)\nnewPosition=initialPosition;\routInitialPosition=initialPosition;\r#else \nnewPosition=vec3(0.,0.,0.);\rnewDirection=2.0*(getRandomVec3(seed.w)-vec3(0.5,0.5,0.5));\r#endif\nfloat power=emitPower.x+(emitPower.y-emitPower.x)*randoms.a;\r#ifdef LOCAL\noutPosition=newPosition;\r#else\noutPosition=(emitterWM*vec4(newPosition,1.)).xyz;\r#endif\n#ifdef CUSTOMEMITTER\noutDirection=direction;\r#ifndef BILLBOARD \noutInitialDirection=direction;\r#endif\n#else\n#ifdef LOCAL\nvec3 initial=newDirection;\r#else \nvec3 initial=(emitterWM*vec4(newDirection,0.)).xyz;\r#endif\noutDirection=initial*power;\r#ifndef BILLBOARD \noutInitialDirection=initial;\r#endif\n#endif\n#ifdef ANIMATESHEET \noutCellIndex=cellInfos.x;\r#ifdef ANIMATESHEETRANDOMSTART\noutCellStartOffset=randoms.a*outLife;\r#endif \n#endif\n#ifdef NOISE\noutNoiseCoordinates1=noiseCoordinates1;\routNoiseCoordinates2=noiseCoordinates2;\r#endif\n} else {\rfloat directionScale=timeDelta;\routAge=newAge;\rfloat ageGradient=newAge/life;\r#ifdef VELOCITYGRADIENTS\ndirectionScale*=texture(velocityGradientSampler,vec2(ageGradient,0)).r;\r#endif\n#ifdef DRAGGRADIENTS\ndirectionScale*=1.0-texture(dragGradientSampler,vec2(ageGradient,0)).r;\r#endif\n#if defined(CUSTOMEMITTER)\noutPosition=position+(direction-position)*ageGradient; \routInitialPosition=initialPosition;\r#else\noutPosition=position+direction*directionScale;\r#endif\noutLife=life;\routSeed=seed;\r#ifndef COLORGRADIENTS \noutColor=color;\r#endif\n#ifdef SIZEGRADIENTS\noutSize.x=texture(sizeGradientSampler,vec2(ageGradient,0)).r;\routSize.yz=size.yz;\r#else\noutSize=size;\r#endif \n#ifndef BILLBOARD \noutInitialDirection=initialDirection;\r#endif\n#ifdef CUSTOMEMITTER\noutDirection=direction;\r#else\nvec3 updatedDirection=direction+gravity*timeDelta;\r#ifdef LIMITVELOCITYGRADIENTS\nfloat limitVelocity=texture(limitVelocityGradientSampler,vec2(ageGradient,0)).r;\rfloat currentVelocity=length(updatedDirection);\rif (currentVelocity>limitVelocity) {\rupdatedDirection=updatedDirection*limitVelocityDamping;\r}\r#endif\noutDirection=updatedDirection;\r#ifdef NOISE\nfloat fetchedR=texture(noiseSampler,vec2(noiseCoordinates1.x,noiseCoordinates1.y)*vec2(0.5)+vec2(0.5)).r;\rfloat fetchedG=texture(noiseSampler,vec2(noiseCoordinates1.z,noiseCoordinates2.x)*vec2(0.5)+vec2(0.5)).r;\rfloat fetchedB=texture(noiseSampler,vec2(noiseCoordinates2.y,noiseCoordinates2.z)*vec2(0.5)+vec2(0.5)).r;\rvec3 force=vec3(2.*fetchedR-1.,2.*fetchedG-1.,2.*fetchedB-1.)*noiseStrength;\routDirection=outDirection+force*timeDelta;\routNoiseCoordinates1=noiseCoordinates1;\routNoiseCoordinates2=noiseCoordinates2;\r#endif \n#endif \n#ifdef ANGULARSPEEDGRADIENTS\nfloat angularSpeed=texture(angularSpeedGradientSampler,vec2(ageGradient,0)).r;\routAngle=angle+angularSpeed*timeDelta;\r#else\noutAngle=vec2(angle.x+angle.y*timeDelta,angle.y);\r#endif\n#ifdef ANIMATESHEET \nfloat offsetAge=outAge;\rfloat dist=cellInfos.y-cellInfos.x;\r#ifdef ANIMATESHEETRANDOMSTART\noutCellStartOffset=cellStartOffset;\roffsetAge+=cellStartOffset;\r#else\nfloat cellStartOffset=0.;\r#endif \nfloat ratio=0.;\rif (cellInfos.w==1.0) {\rratio=clamp(mod(cellStartOffset+cellInfos.z*offsetAge,life)/life,0.,1.0);\r}\relse {\rratio=clamp(cellStartOffset+cellInfos.z*offsetAge/life,0.,1.0);\r}\routCellIndex=float(int(cellInfos.x+ratio*dist));\r#endif\n}\r}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport const gpuUpdateParticlesVertexShader = { name, shader };\n"]}
+{"version":3,"file":"gpuUpdateParticles.vertex.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/gpuUpdateParticles.vertex.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,gCAAgC,CAAC;AAC9C,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4Wb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,gBAAgB;AAChB,MAAM,CAAC,MAAM,8BAA8B,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\n\nconst name = \"gpuUpdateParticlesVertexShader\";\nconst shader = `#version 300 es\n#define PI 3.14159\nuniform float currentCount;\runiform float timeDelta;\runiform float stopFactor;\r#ifndef LOCAL\nuniform mat4 emitterWM;\r#endif\nuniform vec2 lifeTime;\runiform vec2 emitPower;\runiform vec2 sizeRange;\runiform vec4 scaleRange;\r#ifndef COLORGRADIENTS\nuniform vec4 color1;\runiform vec4 color2;\r#endif\nuniform vec3 gravity;\runiform sampler2D randomSampler;\runiform sampler2D randomSampler2;\runiform vec4 angleRange;\r#ifdef BOXEMITTER\nuniform vec3 direction1;\runiform vec3 direction2;\runiform vec3 minEmitBox;\runiform vec3 maxEmitBox;\r#endif\n#ifdef POINTEMITTER\nuniform vec3 direction1;\runiform vec3 direction2;\r#endif\n#ifdef HEMISPHERICEMITTER\nuniform float radius;\runiform float radiusRange;\runiform float directionRandomizer;\r#endif\n#ifdef SPHEREEMITTER\nuniform float radius;\runiform float radiusRange;\r#ifdef DIRECTEDSPHEREEMITTER\nuniform vec3 direction1;\runiform vec3 direction2;\r#else\nuniform float directionRandomizer;\r#endif\n#endif\n#ifdef CYLINDEREMITTER\nuniform float radius;\runiform float height;\runiform float radiusRange;\r#ifdef DIRECTEDCYLINDEREMITTER\nuniform vec3 direction1;\runiform vec3 direction2;\r#else\nuniform float directionRandomizer;\r#endif\n#endif\n#ifdef CONEEMITTER\nuniform vec2 radius;\runiform float coneAngle;\runiform vec2 height;\runiform float directionRandomizer;\r#endif\nin vec3 position;\r#ifdef CUSTOMEMITTER\nin vec3 initialPosition;\r#endif\nin float age;\rin float life;\rin vec4 seed;\rin vec3 size;\r#ifndef COLORGRADIENTS\nin vec4 color;\r#endif\nin vec3 direction;\r#ifndef BILLBOARD\nin vec3 initialDirection;\r#endif\n#ifdef ANGULARSPEEDGRADIENTS\nin float angle;\r#else\nin vec2 angle;\r#endif\n#ifdef ANIMATESHEET\nin float cellIndex;\r#ifdef ANIMATESHEETRANDOMSTART\nin float cellStartOffset;\r#endif\n#endif\n#ifdef NOISE\nin vec3 noiseCoordinates1;\rin vec3 noiseCoordinates2;\r#endif\nout vec3 outPosition;\r#ifdef CUSTOMEMITTER\nout vec3 outInitialPosition;\r#endif\nout float outAge;\rout float outLife;\rout vec4 outSeed;\rout vec3 outSize;\r#ifndef COLORGRADIENTS\nout vec4 outColor;\r#endif\nout vec3 outDirection;\r#ifndef BILLBOARD\nout vec3 outInitialDirection;\r#endif\n#ifdef ANGULARSPEEDGRADIENTS\nout float outAngle;\r#else\nout vec2 outAngle;\r#endif\n#ifdef ANIMATESHEET\nout float outCellIndex;\r#ifdef ANIMATESHEETRANDOMSTART\nout float outCellStartOffset;\r#endif\n#endif\n#ifdef NOISE\nout vec3 outNoiseCoordinates1;\rout vec3 outNoiseCoordinates2;\r#endif\n#ifdef SIZEGRADIENTS\nuniform sampler2D sizeGradientSampler;\r#endif \n#ifdef ANGULARSPEEDGRADIENTS\nuniform sampler2D angularSpeedGradientSampler;\r#endif \n#ifdef VELOCITYGRADIENTS\nuniform sampler2D velocityGradientSampler;\r#endif\n#ifdef LIMITVELOCITYGRADIENTS\nuniform sampler2D limitVelocityGradientSampler;\runiform float limitVelocityDamping;\r#endif\n#ifdef DRAGGRADIENTS\nuniform sampler2D dragGradientSampler;\r#endif\n#ifdef NOISE\nuniform vec3 noiseStrength;\runiform sampler2D noiseSampler;\r#endif\n#ifdef ANIMATESHEET\nuniform vec4 cellInfos;\r#endif\nvec3 getRandomVec3(float offset) {\rreturn texture(randomSampler2,vec2(float(gl_VertexID)*offset/currentCount,0)).rgb;\r}\rvec4 getRandomVec4(float offset) {\rreturn texture(randomSampler,vec2(float(gl_VertexID)*offset/currentCount,0));\r}\rvoid main() {\rfloat newAge=age+timeDelta; \rif (newAge>=life && stopFactor != 0.) {\rvec3 newPosition;\rvec3 newDirection;\rvec4 randoms=getRandomVec4(seed.x);\routLife=lifeTime.x+(lifeTime.y-lifeTime.x)*randoms.r;\routAge=newAge-life;\routSeed=seed;\r#ifdef SIZEGRADIENTS \noutSize.x=texture(sizeGradientSampler,vec2(0,0)).r;\r#else\noutSize.x=sizeRange.x+(sizeRange.y-sizeRange.x)*randoms.g;\r#endif\noutSize.y=scaleRange.x+(scaleRange.y-scaleRange.x)*randoms.b;\routSize.z=scaleRange.z+(scaleRange.w-scaleRange.z)*randoms.a; \r#ifndef COLORGRADIENTS\noutColor=color1+(color2-color1)*randoms.b;\r#endif\n#ifndef ANGULARSPEEDGRADIENTS \noutAngle.y=angleRange.x+(angleRange.y-angleRange.x)*randoms.a;\routAngle.x=angleRange.z+(angleRange.w-angleRange.z)*randoms.r;\r#else\noutAngle=angleRange.z+(angleRange.w-angleRange.z)*randoms.r;\r#endif \n#ifdef POINTEMITTER\nvec3 randoms2=getRandomVec3(seed.y);\rvec3 randoms3=getRandomVec3(seed.z);\rnewPosition=vec3(0,0,0);\rnewDirection=direction1+(direction2-direction1)*randoms3;\r#elif defined(BOXEMITTER)\nvec3 randoms2=getRandomVec3(seed.y);\rvec3 randoms3=getRandomVec3(seed.z);\rnewPosition=minEmitBox+(maxEmitBox-minEmitBox)*randoms2;\rnewDirection=direction1+(direction2-direction1)*randoms3; \r#elif defined(HEMISPHERICEMITTER)\nvec3 randoms2=getRandomVec3(seed.y);\rvec3 randoms3=getRandomVec3(seed.z);\rfloat phi=2.0*PI*randoms2.x;\rfloat theta=acos(2.0*randoms2.y-1.0);\rfloat randX=cos(phi)*sin(theta);\rfloat randY=cos(theta);\rfloat randZ=sin(phi)*sin(theta);\rnewPosition=(radius-(radius*radiusRange*randoms2.z))*vec3(randX,abs(randY),randZ);\rnewDirection=newPosition+directionRandomizer*randoms3; \r#elif defined(SPHEREEMITTER)\nvec3 randoms2=getRandomVec3(seed.y);\rvec3 randoms3=getRandomVec3(seed.z);\rfloat phi=2.0*PI*randoms2.x;\rfloat theta=acos(2.0*randoms2.y-1.0);\rfloat randX=cos(phi)*sin(theta);\rfloat randY=cos(theta);\rfloat randZ=sin(phi)*sin(theta);\rnewPosition=(radius-(radius*radiusRange*randoms2.z))*vec3(randX,randY,randZ);\r#ifdef DIRECTEDSPHEREEMITTER\nnewDirection=normalize(direction1+(direction2-direction1)*randoms3);\r#else\nnewDirection=normalize(newPosition+directionRandomizer*randoms3);\r#endif\n#elif defined(CYLINDEREMITTER)\nvec3 randoms2=getRandomVec3(seed.y);\rvec3 randoms3=getRandomVec3(seed.z);\rfloat yPos=(randoms2.x-0.5)*height;\rfloat angle=randoms2.y*PI*2.;\rfloat inverseRadiusRangeSquared=((1.-radiusRange)*(1.-radiusRange));\rfloat positionRadius=radius*sqrt(inverseRadiusRangeSquared+(randoms2.z*(1.-inverseRadiusRangeSquared)));\rfloat xPos=positionRadius*cos(angle);\rfloat zPos=positionRadius*sin(angle);\rnewPosition=vec3(xPos,yPos,zPos);\r#ifdef DIRECTEDCYLINDEREMITTER\nnewDirection=direction1+(direction2-direction1)*randoms3;\r#else\nangle=angle+((randoms3.x-0.5)*PI)*directionRandomizer;\rnewDirection=vec3(cos(angle),(randoms3.y-0.5)*directionRandomizer,sin(angle));\rnewDirection=normalize(newDirection);\r#endif\n#elif defined(CONEEMITTER)\nvec3 randoms2=getRandomVec3(seed.y);\rfloat s=2.0*PI*randoms2.x;\r#ifdef CONEEMITTERSPAWNPOINT\nfloat h=0.0001;\r#else\nfloat h=randoms2.y*height.y;\rh=1.-h*h; \r#endif\nfloat lRadius=radius.x-radius.x*randoms2.z*radius.y;\rlRadius=lRadius*h;\rfloat randX=lRadius*sin(s);\rfloat randZ=lRadius*cos(s);\rfloat randY=h *height.x;\rnewPosition=vec3(randX,randY,randZ); \rif (abs(cos(coneAngle))==1.0) {\rnewDirection=vec3(0.,1.0,0.);\r} else {\rvec3 randoms3=getRandomVec3(seed.z);\rnewDirection=normalize(newPosition+directionRandomizer*randoms3); \r}\r#elif defined(CUSTOMEMITTER)\nnewPosition=initialPosition;\routInitialPosition=initialPosition;\r#else \nnewPosition=vec3(0.,0.,0.);\rnewDirection=2.0*(getRandomVec3(seed.w)-vec3(0.5,0.5,0.5));\r#endif\nfloat power=emitPower.x+(emitPower.y-emitPower.x)*randoms.a;\r#ifdef LOCAL\noutPosition=newPosition;\r#else\noutPosition=(emitterWM*vec4(newPosition,1.)).xyz;\r#endif\n#ifdef CUSTOMEMITTER\noutDirection=direction;\r#ifndef BILLBOARD \noutInitialDirection=direction;\r#endif\n#else\n#ifdef LOCAL\nvec3 initial=newDirection;\r#else \nvec3 initial=(emitterWM*vec4(newDirection,0.)).xyz;\r#endif\noutDirection=initial*power;\r#ifndef BILLBOARD \noutInitialDirection=initial;\r#endif\n#endif\n#ifdef ANIMATESHEET \noutCellIndex=cellInfos.x;\r#ifdef ANIMATESHEETRANDOMSTART\noutCellStartOffset=randoms.a*outLife;\r#endif \n#endif\n#ifdef NOISE\noutNoiseCoordinates1=noiseCoordinates1;\routNoiseCoordinates2=noiseCoordinates2;\r#endif\n} else {\rfloat directionScale=timeDelta;\routAge=newAge;\rfloat ageGradient=newAge/life;\r#ifdef VELOCITYGRADIENTS\ndirectionScale*=texture(velocityGradientSampler,vec2(ageGradient,0)).r;\r#endif\n#ifdef DRAGGRADIENTS\ndirectionScale*=1.0-texture(dragGradientSampler,vec2(ageGradient,0)).r;\r#endif\n#if defined(CUSTOMEMITTER)\noutPosition=position+(direction-position)*ageGradient; \routInitialPosition=initialPosition;\r#else\noutPosition=position+direction*directionScale;\r#endif\noutLife=life;\routSeed=seed;\r#ifndef COLORGRADIENTS \noutColor=color;\r#endif\n#ifdef SIZEGRADIENTS\noutSize.x=texture(sizeGradientSampler,vec2(ageGradient,0)).r;\routSize.yz=size.yz;\r#else\noutSize=size;\r#endif \n#ifndef BILLBOARD \noutInitialDirection=initialDirection;\r#endif\n#ifdef CUSTOMEMITTER\noutDirection=direction;\r#else\nvec3 updatedDirection=direction+gravity*timeDelta;\r#ifdef LIMITVELOCITYGRADIENTS\nfloat limitVelocity=texture(limitVelocityGradientSampler,vec2(ageGradient,0)).r;\rfloat currentVelocity=length(updatedDirection);\rif (currentVelocity>limitVelocity) {\rupdatedDirection=updatedDirection*limitVelocityDamping;\r}\r#endif\noutDirection=updatedDirection;\r#ifdef NOISE\nfloat fetchedR=texture(noiseSampler,vec2(noiseCoordinates1.x,noiseCoordinates1.y)*vec2(0.5)+vec2(0.5)).r;\rfloat fetchedG=texture(noiseSampler,vec2(noiseCoordinates1.z,noiseCoordinates2.x)*vec2(0.5)+vec2(0.5)).r;\rfloat fetchedB=texture(noiseSampler,vec2(noiseCoordinates2.y,noiseCoordinates2.z)*vec2(0.5)+vec2(0.5)).r;\rvec3 force=vec3(2.*fetchedR-1.,2.*fetchedG-1.,2.*fetchedB-1.)*noiseStrength;\routDirection=outDirection+force*timeDelta;\routNoiseCoordinates1=noiseCoordinates1;\routNoiseCoordinates2=noiseCoordinates2;\r#endif \n#endif \n#ifdef ANGULARSPEEDGRADIENTS\nfloat angularSpeed=texture(angularSpeedGradientSampler,vec2(ageGradient,0)).r;\routAngle=angle+angularSpeed*timeDelta;\r#else\noutAngle=vec2(angle.x+angle.y*timeDelta,angle.y);\r#endif\n#ifdef ANIMATESHEET \nfloat offsetAge=outAge;\rfloat dist=cellInfos.y-cellInfos.x;\r#ifdef ANIMATESHEETRANDOMSTART\noutCellStartOffset=cellStartOffset;\roffsetAge+=cellStartOffset;\r#else\nfloat cellStartOffset=0.;\r#endif \nfloat ratio=0.;\rif (cellInfos.w==1.0) {\rratio=clamp(mod(cellStartOffset+cellInfos.z*offsetAge,life)/life,0.,1.0);\r}\relse {\rratio=clamp(cellStartOffset+cellInfos.z*offsetAge/life,0.,1.0);\r}\routCellIndex=float(int(cellInfos.x+ratio*dist));\r#endif\n}\r}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const gpuUpdateParticlesVertexShader = { name, shader };\n"]}

package/Shaders/grain.fragment.d.ts

@@ -1,5 +1,5 @@
 import "./ShadersInclude/helperFunctions";
-/** @hidden */
+/** @internal */
 export declare const grainPixelShader: {
     name: string;
     shader: string;

package/Shaders/grain.fragment.js

@@ -7,6 +7,6 @@ uniform sampler2D textureSampler;
 void main(void)
 // Sideeffect
 ShaderStore.ShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const grainPixelShader = { name, shader };
 //# sourceMappingURL=grain.fragment.js.map

package/Shaders/grain.fragment.js.map

@@ -1 +1 @@
-{"version":3,"file":"grain.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/grain.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,kCAAkC,CAAC;AAE1C,MAAM,IAAI,GAAG,kBAAkB,CAAC;AAChC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;EAeb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,cAAc;AACd,MAAM,CAAC,MAAM,gBAAgB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\nimport \"./ShadersInclude/helperFunctions\";\n\nconst name = \"grainPixelShader\";\nconst shader = `#include<helperFunctions>\nuniform sampler2D textureSampler; \runiform float intensity;\runiform float animatedSeed;\rvarying vec2 vUV;\r#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void)\r{\rgl_FragColor=texture2D(textureSampler,vUV);\rvec2 seed=vUV*(animatedSeed);\rfloat grain=dither(seed,intensity);\rfloat lum=getLuminance(gl_FragColor.rgb);\rfloat grainAmount=(cos(-PI+(lum*PI*2.))+1.)/2.;\rgl_FragColor.rgb+=grain*grainAmount;\rgl_FragColor.rgb=max(gl_FragColor.rgb,0.0);\r}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport const grainPixelShader = { name, shader };\n"]}
+{"version":3,"file":"grain.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/grain.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,kCAAkC,CAAC;AAE1C,MAAM,IAAI,GAAG,kBAAkB,CAAC;AAChC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;EAeb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,gBAAgB;AAChB,MAAM,CAAC,MAAM,gBAAgB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\nimport \"./ShadersInclude/helperFunctions\";\n\nconst name = \"grainPixelShader\";\nconst shader = `#include<helperFunctions>\nuniform sampler2D textureSampler; \runiform float intensity;\runiform float animatedSeed;\rvarying vec2 vUV;\r#define CUSTOM_FRAGMENT_DEFINITIONS\nvoid main(void)\r{\rgl_FragColor=texture2D(textureSampler,vUV);\rvec2 seed=vUV*(animatedSeed);\rfloat grain=dither(seed,intensity);\rfloat lum=getLuminance(gl_FragColor.rgb);\rfloat grainAmount=(cos(-PI+(lum*PI*2.))+1.)/2.;\rgl_FragColor.rgb+=grain*grainAmount;\rgl_FragColor.rgb=max(gl_FragColor.rgb,0.0);\r}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const grainPixelShader = { name, shader };\n"]}

package/Shaders/hdrFiltering.fragment.d.ts

@@ -2,7 +2,7 @@ import "./ShadersInclude/helperFunctions";
 import "./ShadersInclude/importanceSampling";
 import "./ShadersInclude/pbrBRDFFunctions";
 import "./ShadersInclude/hdrFilteringFunctions";
-/** @hidden */
+/** @internal */
 export declare const hdrFilteringPixelShader: {
     name: string;
     shader: string;

package/Shaders/hdrFiltering.fragment.js

@@ -12,6 +12,6 @@ const shader = `#include<helperFunctions>
 uniform float alphaG;
 // Sideeffect
 ShaderStore.ShadersStore[name] = shader;
-/** @hidden */
+/** @internal */
 export const hdrFilteringPixelShader = { name, shader };
 //# sourceMappingURL=hdrFiltering.fragment.js.map

package/Shaders/hdrFiltering.fragment.js.map

@@ -1 +1 @@
-{"version":3,"file":"hdrFiltering.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/hdrFiltering.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,kCAAkC,CAAC;AAC1C,OAAO,qCAAqC,CAAC;AAC7C,OAAO,mCAAmC,CAAC;AAC3C,OAAO,wCAAwC,CAAC;AAEhD,MAAM,IAAI,GAAG,yBAAyB,CAAC;AACvC,MAAM,MAAM,GAAG;;;;;;;;;;;;EAYb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,cAAc;AACd,MAAM,CAAC,MAAM,uBAAuB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\nimport \"./ShadersInclude/helperFunctions\";\nimport \"./ShadersInclude/importanceSampling\";\nimport \"./ShadersInclude/pbrBRDFFunctions\";\nimport \"./ShadersInclude/hdrFilteringFunctions\";\n\nconst name = \"hdrFilteringPixelShader\";\nconst shader = `#include<helperFunctions>\n#include<importanceSampling>\n#include<pbrBRDFFunctions>\n#include<hdrFilteringFunctions>\nuniform float alphaG;\runiform samplerCube inputTexture;\runiform vec2 vFilteringInfo;\runiform float hdrScale;\rvarying vec3 direction;\rvoid main() {\rvec3 color=radiance(alphaG,inputTexture,direction,vFilteringInfo);\rgl_FragColor=vec4(color*hdrScale,1.0);\r}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @hidden */\nexport const hdrFilteringPixelShader = { name, shader };\n"]}
+{"version":3,"file":"hdrFiltering.fragment.js","sourceRoot":"","sources":["../../../../../lts/core/generated/Shaders/hdrFiltering.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,kCAAkC,CAAC;AAC1C,OAAO,qCAAqC,CAAC;AAC7C,OAAO,mCAAmC,CAAC;AAC3C,OAAO,wCAAwC,CAAC;AAEhD,MAAM,IAAI,GAAG,yBAAyB,CAAC;AACvC,MAAM,MAAM,GAAG;;;;;;;;;;;;EAYb,CAAC;AACH,aAAa;AACb,WAAW,CAAC,YAAY,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxC,gBAAgB;AAChB,MAAM,CAAC,MAAM,uBAAuB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\nimport \"./ShadersInclude/helperFunctions\";\nimport \"./ShadersInclude/importanceSampling\";\nimport \"./ShadersInclude/pbrBRDFFunctions\";\nimport \"./ShadersInclude/hdrFilteringFunctions\";\n\nconst name = \"hdrFilteringPixelShader\";\nconst shader = `#include<helperFunctions>\n#include<importanceSampling>\n#include<pbrBRDFFunctions>\n#include<hdrFilteringFunctions>\nuniform float alphaG;\runiform samplerCube inputTexture;\runiform vec2 vFilteringInfo;\runiform float hdrScale;\rvarying vec3 direction;\rvoid main() {\rvec3 color=radiance(alphaG,inputTexture,direction,vFilteringInfo);\rgl_FragColor=vec4(color*hdrScale,1.0);\r}`;\n// Sideeffect\nShaderStore.ShadersStore[name] = shader;\n/** @internal */\nexport const hdrFilteringPixelShader = { name, shader };\n"]}

package/Shaders/hdrFiltering.vertex.d.ts

@@ -1,4 +1,4 @@
-/** @hidden */
+/** @internal */
 export declare const hdrFilteringVertexShader: {
     name: string;
     shader: string;