@vived/component-abb-6700 1.0.0

package/dist/bumpFragment-Dd-ojPA1.js

@@ -0,0 +1,134 @@
+import { b0 as a } from "./index-CS3Icp_r.js";
+import "./clipPlaneFragment-DJwQynjA.js";
+const e = "bumpFragmentMainFunctions", f = `#ifndef TEXRD_DEFINED
+fn TEXRD(t: texture_2d<f32>,ts: sampler,uv: vec2f)->vec4f {return textureSample(t,ts,uv);}
+#define TEXRD_DEFINED
+#endif
+#if defined(BUMP) || defined(CLEARCOAT_BUMP) || defined(ANISOTROPIC) || defined(DETAIL)
+#if defined(TANGENT) && defined(NORMAL) 
+varying vTBN0: vec3f;varying vTBN1: vec3f;varying vTBN2: vec3f;
+#endif
+#ifdef OBJECTSPACE_NORMALMAP
+uniform normalMatrix: mat4x4f;fn toNormalMatrix(m: mat4x4f)->mat4x4f
+{var a00=m[0][0];var a01=m[0][1];var a02=m[0][2];var a03=m[0][3];var a10=m[1][0];var a11=m[1][1];var a12=m[1][2];var a13=m[1][3];var a20=m[2][0]; 
+var a21=m[2][1];var a22=m[2][2];var a23=m[2][3];var a30=m[3][0]; 
+var a31=m[3][1];var a32=m[3][2];var a33=m[3][3];var b00=a00*a11-a01*a10;var b01=a00*a12-a02*a10;var b02=a00*a13-a03*a10;var b03=a01*a12-a02*a11;var b04=a01*a13-a03*a11;var b05=a02*a13-a03*a12;var b06=a20*a31-a21*a30;var b07=a20*a32-a22*a30;var b08=a20*a33-a23*a30;var b09=a21*a32-a22*a31;var b10=a21*a33-a23*a31;var b11=a22*a33-a23*a32;var det=b00*b11-b01*b10+b02*b09+b03*b08-b04*b07+b05*b06;var mi=mat4x4<f32>(
+(a11*b11-a12*b10+a13*b09)/det,
+(a02*b10-a01*b11-a03*b09)/det,
+(a31*b05-a32*b04+a33*b03)/det,
+(a22*b04-a21*b05-a23*b03)/det,
+(a12*b08-a10*b11-a13*b07)/det,
+(a00*b11-a02*b08+a03*b07)/det,
+(a32*b02-a30*b05-a33*b01)/det,
+(a20*b05-a22*b02+a23*b01)/det,
+(a10*b10-a11*b08+a13*b06)/det,
+(a01*b08-a00*b10-a03*b06)/det,
+(a30*b04-a31*b02+a33*b00)/det,
+(a21*b02-a20*b04-a23*b00)/det,
+(a11*b07-a10*b09-a12*b06)/det,
+(a00*b09-a01*b07+a02*b06)/det,
+(a31*b01-a30*b03-a32*b00)/det,
+(a20*b03-a21*b01+a22*b00)/det);return mat4x4<f32>(mi[0][0],mi[1][0],mi[2][0],mi[3][0],
+mi[0][1],mi[1][1],mi[2][1],mi[3][1],
+mi[0][2],mi[1][2],mi[2][2],mi[3][2],
+mi[0][3],mi[1][3],mi[2][3],mi[3][3]);}
+#endif
+fn perturbNormalBase(cotangentFrame: mat3x3f,normal: vec3f,scale: f32)->vec3f
+{var output=normal;
+#ifdef NORMALXYSCALE
+output=normalize(output* vec3f(scale,scale,1.0));
+#endif
+return normalize(cotangentFrame*output);}
+fn perturbNormal(cotangentFrame: mat3x3f,textureSample: vec3f,scale: f32)->vec3f
+{return perturbNormalBase(cotangentFrame,textureSample*2.0-1.0,scale);}
+fn cotangent_frame(normal: vec3f,p: vec3f,uv: vec2f,tangentSpaceParams: vec2f)->mat3x3f
+{var dp1: vec3f=dpdx(p);var dp2: vec3f=dpdy(p);var duv1: vec2f=dpdx(uv);var duv2: vec2f=dpdy(uv);var dp2perp: vec3f=cross(dp2,normal);var dp1perp: vec3f=cross(normal,dp1);var tangent: vec3f=dp2perp*duv1.x+dp1perp*duv2.x;var bitangent: vec3f=dp2perp*duv1.y+dp1perp*duv2.y;tangent*=tangentSpaceParams.x;bitangent*=tangentSpaceParams.y;var det: f32=max(dot(tangent,tangent),dot(bitangent,bitangent));var invmax: f32=select(inverseSqrt(det),0.0,det==0.0);return mat3x3f(tangent*invmax,bitangent*invmax,normal);}
+#endif
+`;
+a.IncludesShadersStoreWGSL[e] || (a.IncludesShadersStoreWGSL[e] = f);
+const r = "bumpFragmentFunctions", m = `#if defined(BUMP)
+#include<samplerFragmentDeclaration>(_DEFINENAME_,BUMP,_VARYINGNAME_,Bump,_SAMPLERNAME_,bump)
+#endif
+#if defined(DETAIL)
+#include<samplerFragmentDeclaration>(_DEFINENAME_,DETAIL,_VARYINGNAME_,Detail,_SAMPLERNAME_,detail)
+#endif
+#if defined(BUMP) && defined(PARALLAX)
+const minSamples: f32=4.;const maxSamples: f32=15.;const iMaxSamples: i32=15;fn parallaxOcclusion(vViewDirCoT: vec3f,vNormalCoT: vec3f,texCoord: vec2f,parallaxScale: f32)->vec2f {var parallaxLimit: f32=length(vViewDirCoT.xy)/vViewDirCoT.z;parallaxLimit*=parallaxScale;var vOffsetDir: vec2f=normalize(vViewDirCoT.xy);var vMaxOffset: vec2f=vOffsetDir*parallaxLimit;var numSamples: f32=maxSamples+(dot(vViewDirCoT,vNormalCoT)*(minSamples-maxSamples));var stepSize: f32=1.0/numSamples;var currRayHeight: f32=1.0;var vCurrOffset: vec2f= vec2f(0,0);var vLastOffset: vec2f= vec2f(0,0);var lastSampledHeight: f32=1.0;var currSampledHeight: f32=1.0;var keepWorking: bool=true;for (var i: i32=0; i<iMaxSamples; i++)
+{currSampledHeight=textureSample(bumpSampler,bumpSamplerSampler,texCoord+vCurrOffset).w;if (!keepWorking)
+{}
+else if (currSampledHeight>currRayHeight)
+{var delta1: f32=currSampledHeight-currRayHeight;var delta2: f32=(currRayHeight+stepSize)-lastSampledHeight;var ratio: f32=delta1/(delta1+delta2);vCurrOffset=(ratio)* vLastOffset+(1.0-ratio)*vCurrOffset;keepWorking=false;}
+else
+{currRayHeight-=stepSize;vLastOffset=vCurrOffset;
+#ifdef PARALLAX_RHS
+vCurrOffset-=stepSize*vMaxOffset;
+#else
+vCurrOffset+=stepSize*vMaxOffset;
+#endif
+lastSampledHeight=currSampledHeight;}}
+return vCurrOffset;}
+fn parallaxOffset(viewDir: vec3f,heightScale: f32)->vec2f
+{var height: f32=textureSample(bumpSampler,bumpSamplerSampler,fragmentInputs.vBumpUV).w;var texCoordOffset: vec2f=heightScale*viewDir.xy*height;
+#ifdef PARALLAX_RHS
+return texCoordOffset;
+#else
+return -texCoordOffset;
+#endif
+}
+#endif
+`;
+a.IncludesShadersStoreWGSL[r] || (a.IncludesShadersStoreWGSL[r] = m);
+const t = "bumpFragment", n = `var uvOffset: vec2f= vec2f(0.0,0.0);
+#if defined(BUMP) || defined(PARALLAX) || defined(DETAIL)
+#ifdef NORMALXYSCALE
+var normalScale: f32=1.0;
+#elif defined(BUMP)
+var normalScale: f32=uniforms.vBumpInfos.y;
+#else
+var normalScale: f32=1.0;
+#endif
+#if defined(TANGENT) && defined(NORMAL)
+var TBN: mat3x3f=mat3x3<f32>(input.vTBN0,input.vTBN1,input.vTBN2); 
+#elif defined(BUMP)
+var TBNUV: vec2f=select(-fragmentInputs.vBumpUV,fragmentInputs.vBumpUV,fragmentInputs.frontFacing);var TBN: mat3x3f=cotangent_frame(normalW*normalScale,input.vPositionW,TBNUV,uniforms.vTangentSpaceParams);
+#else
+var TBNUV: vec2f=select(-fragmentInputs.vDetailUV,fragmentInputs.vDetailUV,fragmentInputs.frontFacing);var TBN: mat3x3f=cotangent_frame(normalW*normalScale,input.vPositionW,TBNUV, vec2f(1.,1.));
+#endif
+#elif defined(ANISOTROPIC)
+#if defined(TANGENT) && defined(NORMAL)
+var TBN: mat3x3f=mat3x3<f32>(input.vTBN0,input.vTBN1,input.vTBN2); 
+#else
+var TBNUV: vec2f=select( -fragmentInputs.vMainUV1,fragmentInputs.vMainUV1,fragmentInputs.frontFacing);var TBN: mat3x3f=cotangent_frame(normalW,input.vPositionW,TBNUV, vec2f(1.,1.));
+#endif
+#endif
+#ifdef PARALLAX
+var invTBN: mat3x3f=transposeMat3(TBN);
+#ifdef PARALLAXOCCLUSION
+uvOffset=parallaxOcclusion(invTBN*-viewDirectionW,invTBN*normalW,fragmentInputs.vBumpUV,uniforms.vBumpInfos.z);
+#else
+uvOffset=parallaxOffset(invTBN*viewDirectionW,uniforms.vBumpInfos.z);
+#endif
+#endif
+#ifdef DETAIL
+var detailColor: vec4f=textureSample(detailSampler,detailSamplerSampler,fragmentInputs.vDetailUV+uvOffset);var detailNormalRG: vec2f=detailColor.wy*2.0-1.0;var detailNormalB: f32=sqrt(1.-saturate(dot(detailNormalRG,detailNormalRG)));var detailNormal: vec3f= vec3f(detailNormalRG,detailNormalB);
+#endif
+#ifdef BUMP
+#ifdef OBJECTSPACE_NORMALMAP
+#define CUSTOM_FRAGMENT_BUMP_FRAGMENT
+normalW=normalize(TEXRD(bumpSampler,bumpSamplerSampler,fragmentInputs.vBumpUV).xyz *2.0-1.0);normalW=normalize(mat3x3f(uniforms.normalMatrix[0].xyz,uniforms.normalMatrix[1].xyz,uniforms.normalMatrix[2].xyz)*normalW);
+#elif !defined(DETAIL)
+normalW=perturbNormal(TBN,TEXRD(bumpSampler,bumpSamplerSampler,fragmentInputs.vBumpUV+uvOffset).xyz,uniforms.vBumpInfos.y);
+#else
+var bumpNormal: vec3f=TEXRD(bumpSampler,bumpSamplerSampler,fragmentInputs.vBumpUV+uvOffset).xyz*2.0-1.0;
+#if DETAIL_NORMALBLENDMETHOD==0 
+detailNormal=vec3f(detailNormal.xy*uniforms.vDetailInfos.z,detailNormal.z);var blendedNormal: vec3f=normalize( vec3f(bumpNormal.xy+detailNormal.xy,bumpNormal.z*detailNormal.z));
+#elif DETAIL_NORMALBLENDMETHOD==1 
+detailNormal=vec3f(detailNormal.xy*uniforms.vDetailInfos.z,detailNormal.z);bumpNormal+= vec3f(0.0,0.0,1.0);detailNormal*= vec3f(-1.0,-1.0,1.0);var blendedNormal: vec3f=bumpNormal*dot(bumpNormal,detailNormal)/bumpNormal.z-detailNormal;
+#endif
+normalW=perturbNormalBase(TBN,blendedNormal,uniforms.vBumpInfos.y);
+#endif
+#elif defined(DETAIL)
+detailNormal=vec3f(detailNormal.xy*uniforms.vDetailInfos.z,detailNormal.z);normalW=perturbNormalBase(TBN,detailNormal,uniforms.vDetailInfos.z);
+#endif
+`;
+a.IncludesShadersStoreWGSL[t] || (a.IncludesShadersStoreWGSL[t] = n);

package/dist/bumpFragment-KE1_PuMl.js

@@ -0,0 +1,287 @@
+import { b0 as e } from "./index-CS3Icp_r.js";
+const a = "samplerFragmentDeclaration", d = `#ifdef _DEFINENAME_
+#if _DEFINENAME_DIRECTUV==1
+#define v_VARYINGNAME_UV vMainUV1
+#elif _DEFINENAME_DIRECTUV==2
+#define v_VARYINGNAME_UV vMainUV2
+#elif _DEFINENAME_DIRECTUV==3
+#define v_VARYINGNAME_UV vMainUV3
+#elif _DEFINENAME_DIRECTUV==4
+#define v_VARYINGNAME_UV vMainUV4
+#elif _DEFINENAME_DIRECTUV==5
+#define v_VARYINGNAME_UV vMainUV5
+#elif _DEFINENAME_DIRECTUV==6
+#define v_VARYINGNAME_UV vMainUV6
+#else
+varying vec2 v_VARYINGNAME_UV;
+#endif
+uniform sampler2D _SAMPLERNAME_Sampler;
+#endif
+`;
+e.IncludesShadersStore[a] || (e.IncludesShadersStore[a] = d);
+const r = "reflectionFunction", f = `vec3 computeFixedEquirectangularCoords(vec4 worldPos,vec3 worldNormal,vec3 direction)
+{float lon=atan(direction.z,direction.x);float lat=acos(direction.y);vec2 sphereCoords=vec2(lon,lat)*RECIPROCAL_PI2*2.0;float s=sphereCoords.x*0.5+0.5;float t=sphereCoords.y;return vec3(s,t,0); }
+vec3 computeMirroredFixedEquirectangularCoords(vec4 worldPos,vec3 worldNormal,vec3 direction)
+{float lon=atan(direction.z,direction.x);float lat=acos(direction.y);vec2 sphereCoords=vec2(lon,lat)*RECIPROCAL_PI2*2.0;float s=sphereCoords.x*0.5+0.5;float t=sphereCoords.y;return vec3(1.0-s,t,0); }
+vec3 computeEquirectangularCoords(vec4 worldPos,vec3 worldNormal,vec3 eyePosition,mat4 reflectionMatrix)
+{vec3 cameraToVertex=normalize(worldPos.xyz-eyePosition);vec3 r=normalize(reflect(cameraToVertex,worldNormal));r=vec3(reflectionMatrix*vec4(r,0));float lon=atan(r.z,r.x);float lat=acos(r.y);vec2 sphereCoords=vec2(lon,lat)*RECIPROCAL_PI2*2.0;float s=sphereCoords.x*0.5+0.5;float t=sphereCoords.y;return vec3(s,t,0);}
+vec3 computeSphericalCoords(vec4 worldPos,vec3 worldNormal,mat4 view,mat4 reflectionMatrix)
+{vec3 viewDir=normalize(vec3(view*worldPos));vec3 viewNormal=normalize(vec3(view*vec4(worldNormal,0.0)));vec3 r=reflect(viewDir,viewNormal);r=vec3(reflectionMatrix*vec4(r,0));r.z=r.z-1.0;float m=2.0*length(r);return vec3(r.x/m+0.5,1.0-r.y/m-0.5,0);}
+vec3 computePlanarCoords(vec4 worldPos,vec3 worldNormal,vec3 eyePosition,mat4 reflectionMatrix)
+{vec3 viewDir=worldPos.xyz-eyePosition;vec3 coords=normalize(reflect(viewDir,worldNormal));return vec3(reflectionMatrix*vec4(coords,1));}
+vec3 computeCubicCoords(vec4 worldPos,vec3 worldNormal,vec3 eyePosition,mat4 reflectionMatrix)
+{vec3 viewDir=normalize(worldPos.xyz-eyePosition);vec3 coords=reflect(viewDir,worldNormal);coords=vec3(reflectionMatrix*vec4(coords,0));
+#ifdef INVERTCUBICMAP
+coords.y*=-1.0;
+#endif
+return coords;}
+vec3 computeCubicLocalCoords(vec4 worldPos,vec3 worldNormal,vec3 eyePosition,mat4 reflectionMatrix,vec3 reflectionSize,vec3 reflectionPosition)
+{vec3 viewDir=normalize(worldPos.xyz-eyePosition);vec3 coords=reflect(viewDir,worldNormal);coords=parallaxCorrectNormal(worldPos.xyz,coords,reflectionSize,reflectionPosition);coords=vec3(reflectionMatrix*vec4(coords,0));
+#ifdef INVERTCUBICMAP
+coords.y*=-1.0;
+#endif
+return coords;}
+vec3 computeProjectionCoords(vec4 worldPos,mat4 view,mat4 reflectionMatrix)
+{return vec3(reflectionMatrix*(view*worldPos));}
+vec3 computeSkyBoxCoords(vec3 positionW,mat4 reflectionMatrix)
+{return vec3(reflectionMatrix*vec4(positionW,1.));}
+#ifdef REFLECTION
+vec3 computeReflectionCoords(vec4 worldPos,vec3 worldNormal)
+{
+#ifdef REFLECTIONMAP_MIRROREDEQUIRECTANGULAR_FIXED
+vec3 direction=normalize(vDirectionW);return computeMirroredFixedEquirectangularCoords(worldPos,worldNormal,direction);
+#endif
+#ifdef REFLECTIONMAP_EQUIRECTANGULAR_FIXED
+vec3 direction=normalize(vDirectionW);return computeFixedEquirectangularCoords(worldPos,worldNormal,direction);
+#endif
+#ifdef REFLECTIONMAP_EQUIRECTANGULAR
+return computeEquirectangularCoords(worldPos,worldNormal,vEyePosition.xyz,reflectionMatrix);
+#endif
+#ifdef REFLECTIONMAP_SPHERICAL
+return computeSphericalCoords(worldPos,worldNormal,view,reflectionMatrix);
+#endif
+#ifdef REFLECTIONMAP_PLANAR
+return computePlanarCoords(worldPos,worldNormal,vEyePosition.xyz,reflectionMatrix);
+#endif
+#ifdef REFLECTIONMAP_CUBIC
+#ifdef USE_LOCAL_REFLECTIONMAP_CUBIC
+return computeCubicLocalCoords(worldPos,worldNormal,vEyePosition.xyz,reflectionMatrix,vReflectionSize,vReflectionPosition);
+#else
+return computeCubicCoords(worldPos,worldNormal,vEyePosition.xyz,reflectionMatrix);
+#endif
+#endif
+#ifdef REFLECTIONMAP_PROJECTION
+return computeProjectionCoords(worldPos,view,reflectionMatrix);
+#endif
+#ifdef REFLECTIONMAP_SKYBOX
+return computeSkyBoxCoords(vPositionUVW,reflectionMatrix);
+#endif
+#ifdef REFLECTIONMAP_EXPLICIT
+return vec3(0,0,0);
+#endif
+}
+#endif
+`;
+e.IncludesShadersStore[r] || (e.IncludesShadersStore[r] = f);
+const i = "bumpFragmentMainFunctions", c = `#ifndef TEXRD_DEFINED
+#define TEXRD(s,uv) texture2D(s,uv)
+#define TEXRD_DEFINED
+#endif
+#if defined(BUMP) || defined(CLEARCOAT_BUMP) || defined(ANISOTROPIC) || defined(DETAIL)
+#if defined(TANGENT) && defined(NORMAL) 
+varying mat3 vTBN;
+#endif
+#ifdef OBJECTSPACE_NORMALMAP
+uniform mat4 normalMatrix;
+#if defined(WEBGL2) || defined(WEBGPU)
+mat4 toNormalMatrix(mat4 wMatrix)
+{mat4 ret=inverse(wMatrix);ret=transpose(ret);ret[0][3]=0.;ret[1][3]=0.;ret[2][3]=0.;ret[3]=vec4(0.,0.,0.,1.);return ret;}
+#else
+mat4 toNormalMatrix(mat4 m)
+{float
+a00=m[0][0],a01=m[0][1],a02=m[0][2],a03=m[0][3],
+a10=m[1][0],a11=m[1][1],a12=m[1][2],a13=m[1][3],
+a20=m[2][0],a21=m[2][1],a22=m[2][2],a23=m[2][3],
+a30=m[3][0],a31=m[3][1],a32=m[3][2],a33=m[3][3],
+b00=a00*a11-a01*a10,
+b01=a00*a12-a02*a10,
+b02=a00*a13-a03*a10,
+b03=a01*a12-a02*a11,
+b04=a01*a13-a03*a11,
+b05=a02*a13-a03*a12,
+b06=a20*a31-a21*a30,
+b07=a20*a32-a22*a30,
+b08=a20*a33-a23*a30,
+b09=a21*a32-a22*a31,
+b10=a21*a33-a23*a31,
+b11=a22*a33-a23*a32,
+det=b00*b11-b01*b10+b02*b09+b03*b08-b04*b07+b05*b06;mat4 mi=mat4(
+a11*b11-a12*b10+a13*b09,
+a02*b10-a01*b11-a03*b09,
+a31*b05-a32*b04+a33*b03,
+a22*b04-a21*b05-a23*b03,
+a12*b08-a10*b11-a13*b07,
+a00*b11-a02*b08+a03*b07,
+a32*b02-a30*b05-a33*b01,
+a20*b05-a22*b02+a23*b01,
+a10*b10-a11*b08+a13*b06,
+a01*b08-a00*b10-a03*b06,
+a30*b04-a31*b02+a33*b00,
+a21*b02-a20*b04-a23*b00,
+a11*b07-a10*b09-a12*b06,
+a00*b09-a01*b07+a02*b06,
+a31*b01-a30*b03-a32*b00,
+a20*b03-a21*b01+a22*b00)/det;return mat4(mi[0][0],mi[1][0],mi[2][0],mi[3][0],
+mi[0][1],mi[1][1],mi[2][1],mi[3][1],
+mi[0][2],mi[1][2],mi[2][2],mi[3][2],
+mi[0][3],mi[1][3],mi[2][3],mi[3][3]);}
+#endif
+#endif
+vec3 perturbNormalBase(mat3 cotangentFrame,vec3 normal,float scale)
+{
+#ifdef NORMALXYSCALE
+normal=normalize(normal*vec3(scale,scale,1.0));
+#endif
+return normalize(cotangentFrame*normal);}
+vec3 perturbNormal(mat3 cotangentFrame,vec3 textureSample,float scale)
+{return perturbNormalBase(cotangentFrame,textureSample*2.0-1.0,scale);}
+mat3 cotangent_frame(vec3 normal,vec3 p,vec2 uv,vec2 tangentSpaceParams)
+{vec3 dp1=dFdx(p);vec3 dp2=dFdy(p);vec2 duv1=dFdx(uv);vec2 duv2=dFdy(uv);vec3 dp2perp=cross(dp2,normal);vec3 dp1perp=cross(normal,dp1);vec3 tangent=dp2perp*duv1.x+dp1perp*duv2.x;vec3 bitangent=dp2perp*duv1.y+dp1perp*duv2.y;tangent*=tangentSpaceParams.x;bitangent*=tangentSpaceParams.y;float det=max(dot(tangent,tangent),dot(bitangent,bitangent));float invmax=det==0.0 ? 0.0 : inversesqrt(det);return mat3(tangent*invmax,bitangent*invmax,normal);}
+#endif
+`;
+e.IncludesShadersStore[i] || (e.IncludesShadersStore[i] = c);
+const o = "bumpFragmentFunctions", m = `#if defined(BUMP)
+#include<samplerFragmentDeclaration>(_DEFINENAME_,BUMP,_VARYINGNAME_,Bump,_SAMPLERNAME_,bump)
+#endif
+#if defined(DETAIL)
+#include<samplerFragmentDeclaration>(_DEFINENAME_,DETAIL,_VARYINGNAME_,Detail,_SAMPLERNAME_,detail)
+#endif
+#if defined(BUMP) && defined(PARALLAX)
+const float minSamples=4.;const float maxSamples=15.;const int iMaxSamples=15;vec2 parallaxOcclusion(vec3 vViewDirCoT,vec3 vNormalCoT,vec2 texCoord,float parallaxScale) {float parallaxLimit=length(vViewDirCoT.xy)/vViewDirCoT.z;parallaxLimit*=parallaxScale;vec2 vOffsetDir=normalize(vViewDirCoT.xy);vec2 vMaxOffset=vOffsetDir*parallaxLimit;float numSamples=maxSamples+(dot(vViewDirCoT,vNormalCoT)*(minSamples-maxSamples));float stepSize=1.0/numSamples;float currRayHeight=1.0;vec2 vCurrOffset=vec2(0,0);vec2 vLastOffset=vec2(0,0);float lastSampledHeight=1.0;float currSampledHeight=1.0;bool keepWorking=true;for (int i=0; i<iMaxSamples; i++)
+{currSampledHeight=texture2D(bumpSampler,texCoord+vCurrOffset).w;if (!keepWorking)
+{}
+else if (currSampledHeight>currRayHeight)
+{float delta1=currSampledHeight-currRayHeight;float delta2=(currRayHeight+stepSize)-lastSampledHeight;float ratio=delta1/(delta1+delta2);vCurrOffset=(ratio)* vLastOffset+(1.0-ratio)*vCurrOffset;keepWorking=false;}
+else
+{currRayHeight-=stepSize;vLastOffset=vCurrOffset;
+#ifdef PARALLAX_RHS
+vCurrOffset-=stepSize*vMaxOffset;
+#else
+vCurrOffset+=stepSize*vMaxOffset;
+#endif
+lastSampledHeight=currSampledHeight;}}
+return vCurrOffset;}
+vec2 parallaxOffset(vec3 viewDir,float heightScale)
+{float height=texture2D(bumpSampler,vBumpUV).w;vec2 texCoordOffset=heightScale*viewDir.xy*height;
+#ifdef PARALLAX_RHS
+return texCoordOffset;
+#else
+return -texCoordOffset;
+#endif
+}
+#endif
+`;
+e.IncludesShadersStore[o] || (e.IncludesShadersStore[o] = m);
+const t = "clipPlaneFragmentDeclaration", s = `#ifdef CLIPPLANE
+varying float fClipDistance;
+#endif
+#ifdef CLIPPLANE2
+varying float fClipDistance2;
+#endif
+#ifdef CLIPPLANE3
+varying float fClipDistance3;
+#endif
+#ifdef CLIPPLANE4
+varying float fClipDistance4;
+#endif
+#ifdef CLIPPLANE5
+varying float fClipDistance5;
+#endif
+#ifdef CLIPPLANE6
+varying float fClipDistance6;
+#endif
+`;
+e.IncludesShadersStore[t] || (e.IncludesShadersStore[t] = s);
+const l = "clipPlaneFragment", v = `#if defined(CLIPPLANE) || defined(CLIPPLANE2) || defined(CLIPPLANE3) || defined(CLIPPLANE4) || defined(CLIPPLANE5) || defined(CLIPPLANE6)
+if (false) {}
+#endif
+#ifdef CLIPPLANE
+else if (fClipDistance>0.0)
+{discard;}
+#endif
+#ifdef CLIPPLANE2
+else if (fClipDistance2>0.0)
+{discard;}
+#endif
+#ifdef CLIPPLANE3
+else if (fClipDistance3>0.0)
+{discard;}
+#endif
+#ifdef CLIPPLANE4
+else if (fClipDistance4>0.0)
+{discard;}
+#endif
+#ifdef CLIPPLANE5
+else if (fClipDistance5>0.0)
+{discard;}
+#endif
+#ifdef CLIPPLANE6
+else if (fClipDistance6>0.0)
+{discard;}
+#endif
+`;
+e.IncludesShadersStore[l] || (e.IncludesShadersStore[l] = v);
+const n = "bumpFragment", N = `vec2 uvOffset=vec2(0.0,0.0);
+#if defined(BUMP) || defined(PARALLAX) || defined(DETAIL)
+#ifdef NORMALXYSCALE
+float normalScale=1.0;
+#elif defined(BUMP)
+float normalScale=vBumpInfos.y;
+#else
+float normalScale=1.0;
+#endif
+#if defined(TANGENT) && defined(NORMAL)
+mat3 TBN=vTBN;
+#elif defined(BUMP)
+vec2 TBNUV=gl_FrontFacing ? vBumpUV : -vBumpUV;mat3 TBN=cotangent_frame(normalW*normalScale,vPositionW,TBNUV,vTangentSpaceParams);
+#else
+vec2 TBNUV=gl_FrontFacing ? vDetailUV : -vDetailUV;mat3 TBN=cotangent_frame(normalW*normalScale,vPositionW,TBNUV,vec2(1.,1.));
+#endif
+#elif defined(ANISOTROPIC)
+#if defined(TANGENT) && defined(NORMAL)
+mat3 TBN=vTBN;
+#else
+vec2 TBNUV=gl_FrontFacing ? vMainUV1 : -vMainUV1;mat3 TBN=cotangent_frame(normalW,vPositionW,TBNUV,vec2(1.,1.));
+#endif
+#endif
+#ifdef PARALLAX
+mat3 invTBN=transposeMat3(TBN);
+#ifdef PARALLAXOCCLUSION
+uvOffset=parallaxOcclusion(invTBN*-viewDirectionW,invTBN*normalW,vBumpUV,vBumpInfos.z);
+#else
+uvOffset=parallaxOffset(invTBN*viewDirectionW,vBumpInfos.z);
+#endif
+#endif
+#ifdef DETAIL
+vec4 detailColor=texture2D(detailSampler,vDetailUV+uvOffset);vec2 detailNormalRG=detailColor.wy*2.0-1.0;float detailNormalB=sqrt(1.-saturate(dot(detailNormalRG,detailNormalRG)));vec3 detailNormal=vec3(detailNormalRG,detailNormalB);
+#endif
+#ifdef BUMP
+#ifdef OBJECTSPACE_NORMALMAP
+#define CUSTOM_FRAGMENT_BUMP_FRAGMENT
+normalW=normalize(TEXRD(bumpSampler,vBumpUV).xyz *2.0-1.0);normalW=normalize(mat3(normalMatrix)*normalW);
+#elif !defined(DETAIL)
+normalW=perturbNormal(TBN,TEXRD(bumpSampler,vBumpUV+uvOffset).xyz,vBumpInfos.y);
+#else
+vec3 bumpNormal=TEXRD(bumpSampler,vBumpUV+uvOffset).xyz*2.0-1.0;
+#if DETAIL_NORMALBLENDMETHOD==0 
+detailNormal.xy*=vDetailInfos.z;vec3 blendedNormal=normalize(vec3(bumpNormal.xy+detailNormal.xy,bumpNormal.z*detailNormal.z));
+#elif DETAIL_NORMALBLENDMETHOD==1 
+detailNormal.xy*=vDetailInfos.z;bumpNormal+=vec3(0.0,0.0,1.0);detailNormal*=vec3(-1.0,-1.0,1.0);vec3 blendedNormal=bumpNormal*dot(bumpNormal,detailNormal)/bumpNormal.z-detailNormal;
+#endif
+normalW=perturbNormalBase(TBN,blendedNormal,vBumpInfos.y);
+#endif
+#elif defined(DETAIL)
+detailNormal.xy*=vDetailInfos.z;normalW=perturbNormalBase(TBN,detailNormal,vDetailInfos.z);
+#endif
+`;
+e.IncludesShadersStore[n] || (e.IncludesShadersStore[n] = N);

package/dist/bumpVertex-BcdvVFVx.js

@@ -0,0 +1,8 @@
+import { b0 as e } from "./index-CS3Icp_r.js";
+const t = "bumpVertex", n = `#if defined(BUMP) || defined(PARALLAX) || defined(CLEARCOAT_BUMP) || defined(ANISOTROPIC)
+#if defined(TANGENT) && defined(NORMAL)
+var tbnNormal: vec3f=normalize(normalUpdated);var tbnTangent: vec3f=normalize(tangentUpdated.xyz);var tbnBitangent: vec3f=cross(tbnNormal,tbnTangent)*tangentUpdated.w;var matTemp= mat3x3f(finalWorld[0].xyz,finalWorld[1].xyz,finalWorld[2].xyz)* mat3x3f(tbnTangent,tbnBitangent,tbnNormal);vertexOutputs.vTBN0=matTemp[0];vertexOutputs.vTBN1=matTemp[1];vertexOutputs.vTBN2=matTemp[2];
+#endif
+#endif
+`;
+e.IncludesShadersStoreWGSL[t] || (e.IncludesShadersStoreWGSL[t] = n);

package/dist/bumpVertexDeclaration-B5Uvs-RS.js

@@ -0,0 +1,8 @@
+import { b0 as e } from "./index-CS3Icp_r.js";
+const d = "bumpVertexDeclaration", n = `#if defined(BUMP) || defined(PARALLAX) || defined(CLEARCOAT_BUMP) || defined(ANISOTROPIC)
+#if defined(TANGENT) && defined(NORMAL) 
+varying mat3 vTBN;
+#endif
+#endif
+`;
+e.IncludesShadersStore[d] || (e.IncludesShadersStore[d] = n);

package/dist/bumpVertexDeclaration-ixSg-yGI.js

@@ -0,0 +1,8 @@
+import { b0 as e } from "./index-CS3Icp_r.js";
+const d = "bumpVertexDeclaration", n = `#if defined(BUMP) || defined(PARALLAX) || defined(CLEARCOAT_BUMP) || defined(ANISOTROPIC)
+#if defined(TANGENT) && defined(NORMAL) 
+varying vTBN0: vec3f;varying vTBN1: vec3f;varying vTBN2: vec3f;
+#endif
+#endif
+`;
+e.IncludesShadersStoreWGSL[d] || (e.IncludesShadersStoreWGSL[d] = n);

package/dist/clipPlaneFragment-DJwQynjA.js

@@ -0,0 +1,136 @@
+import { b0 as e } from "./index-CS3Icp_r.js";
+const r = "samplerFragmentDeclaration", n = `#ifdef _DEFINENAME_
+#if _DEFINENAME_DIRECTUV==1
+#define v_VARYINGNAME_UV vMainUV1
+#elif _DEFINENAME_DIRECTUV==2
+#define v_VARYINGNAME_UV vMainUV2
+#elif _DEFINENAME_DIRECTUV==3
+#define v_VARYINGNAME_UV vMainUV3
+#elif _DEFINENAME_DIRECTUV==4
+#define v_VARYINGNAME_UV vMainUV4
+#elif _DEFINENAME_DIRECTUV==5
+#define v_VARYINGNAME_UV vMainUV5
+#elif _DEFINENAME_DIRECTUV==6
+#define v_VARYINGNAME_UV vMainUV6
+#else
+varying v_VARYINGNAME_UV: vec2f;
+#endif
+var _SAMPLERNAME_SamplerSampler: sampler;var _SAMPLERNAME_Sampler: texture_2d<f32>;
+#endif
+`;
+e.IncludesShadersStoreWGSL[r] || (e.IncludesShadersStoreWGSL[r] = n);
+const o = "reflectionFunction", t = `fn computeFixedEquirectangularCoords(worldPos: vec4f,worldNormal: vec3f,direction: vec3f)->vec3f
+{var lon: f32=atan2(direction.z,direction.x);var lat: f32=acos(direction.y);var sphereCoords: vec2f= vec2f(lon,lat)*RECIPROCAL_PI2*2.0;var s: f32=sphereCoords.x*0.5+0.5;var t: f32=sphereCoords.y;return vec3f(s,t,0); }
+fn computeMirroredFixedEquirectangularCoords(worldPos: vec4f,worldNormal: vec3f,direction: vec3f)->vec3f
+{var lon: f32=atan2(direction.z,direction.x);var lat: f32=acos(direction.y);var sphereCoords: vec2f= vec2f(lon,lat)*RECIPROCAL_PI2*2.0;var s: f32=sphereCoords.x*0.5+0.5;var t: f32=sphereCoords.y;return vec3f(1.0-s,t,0); }
+fn computeEquirectangularCoords(worldPos: vec4f,worldNormal: vec3f,eyePosition: vec3f,reflectionMatrix: mat4x4f)->vec3f
+{var cameraToVertex: vec3f=normalize(worldPos.xyz-eyePosition);var r: vec3f=normalize(reflect(cameraToVertex,worldNormal));r= (reflectionMatrix* vec4f(r,0)).xyz;var lon: f32=atan2(r.z,r.x);var lat: f32=acos(r.y);var sphereCoords: vec2f= vec2f(lon,lat)*RECIPROCAL_PI2*2.0;var s: f32=sphereCoords.x*0.5+0.5;var t: f32=sphereCoords.y;return vec3f(s,t,0);}
+fn computeSphericalCoords(worldPos: vec4f,worldNormal: vec3f,view: mat4x4f,reflectionMatrix: mat4x4f)->vec3f
+{var viewDir: vec3f=normalize((view*worldPos).xyz);var viewNormal: vec3f=normalize((view* vec4f(worldNormal,0.0)).xyz);var r: vec3f=reflect(viewDir,viewNormal);r= (reflectionMatrix* vec4f(r,0)).xyz;r.z=r.z-1.0;var m: f32=2.0*length(r);return vec3f(r.x/m+0.5,1.0-r.y/m-0.5,0);}
+fn computePlanarCoords(worldPos: vec4f,worldNormal: vec3f,eyePosition: vec3f,reflectionMatrix: mat4x4f)->vec3f
+{var viewDir: vec3f=worldPos.xyz-eyePosition;var coords: vec3f=normalize(reflect(viewDir,worldNormal));return (reflectionMatrix* vec4f(coords,1)).xyz;}
+fn computeCubicCoords(worldPos: vec4f,worldNormal: vec3f,eyePosition: vec3f,reflectionMatrix: mat4x4f)->vec3f
+{var viewDir: vec3f=normalize(worldPos.xyz-eyePosition);var coords: vec3f=reflect(viewDir,worldNormal);coords= (reflectionMatrix* vec4f(coords,0)).xyz;
+#ifdef INVERTCUBICMAP
+coords.y*=-1.0;
+#endif
+return coords;}
+fn computeCubicLocalCoords(worldPos: vec4f,worldNormal: vec3f,eyePosition: vec3f,reflectionMatrix: mat4x4f,reflectionSize: vec3f,reflectionPosition: vec3f)->vec3f
+{var viewDir: vec3f=normalize(worldPos.xyz-eyePosition);var coords: vec3f=reflect(viewDir,worldNormal);coords=parallaxCorrectNormal(worldPos.xyz,coords,reflectionSize,reflectionPosition);coords=(reflectionMatrix* vec4f(coords,0)).xyz;
+#ifdef INVERTCUBICMAP
+coords.y*=-1.0;
+#endif
+return coords;}
+fn computeProjectionCoords(worldPos: vec4f,view: mat4x4f,reflectionMatrix: mat4x4f)->vec3f
+{return (reflectionMatrix*(view*worldPos)).xyz;}
+fn computeSkyBoxCoords(positionW: vec3f,reflectionMatrix: mat4x4f)->vec3f
+{return (reflectionMatrix* vec4f(positionW,1.)).xyz;}
+#ifdef REFLECTION
+fn computeReflectionCoords(worldPos: vec4f,worldNormal: vec3f)->vec3f
+{
+#ifdef REFLECTIONMAP_MIRROREDEQUIRECTANGULAR_FIXED
+var direction: vec3f=normalize(fragmentInputs.vDirectionW);return computeMirroredFixedEquirectangularCoords(worldPos,worldNormal,direction);
+#endif
+#ifdef REFLECTIONMAP_EQUIRECTANGULAR_FIXED
+var direction: vec3f=normalize(fragmentInputs.vDirectionW);return computeFixedEquirectangularCoords(worldPos,worldNormal,direction);
+#endif
+#ifdef REFLECTIONMAP_EQUIRECTANGULAR
+return computeEquirectangularCoords(worldPos,worldNormal,scene.vEyePosition.xyz,uniforms.reflectionMatrix);
+#endif
+#ifdef REFLECTIONMAP_SPHERICAL
+return computeSphericalCoords(worldPos,worldNormal,scene.view,uniforms.reflectionMatrix);
+#endif
+#ifdef REFLECTIONMAP_PLANAR
+return computePlanarCoords(worldPos,worldNormal,scene.vEyePosition.xyz,uniforms.reflectionMatrix);
+#endif
+#ifdef REFLECTIONMAP_CUBIC
+#ifdef USE_LOCAL_REFLECTIONMAP_CUBIC
+return computeCubicLocalCoords(worldPos,worldNormal,scene.vEyePosition.xyz,uniforms.reflectionMatrix,uniforms.vReflectionSize,uniforms.vReflectionPosition);
+#else
+return computeCubicCoords(worldPos,worldNormal,scene.vEyePosition.xyz,uniforms.reflectionMatrix);
+#endif
+#endif
+#ifdef REFLECTIONMAP_PROJECTION
+return computeProjectionCoords(worldPos,scene.view,uniforms.reflectionMatrix);
+#endif
+#ifndef REFLECTIONMAP_CUBIC
+#ifdef REFLECTIONMAP_SKYBOX
+return computeSkyBoxCoords(fragmentInputs.vPositionUVW,uniforms.reflectionMatrix);
+#endif
+#endif
+#ifdef REFLECTIONMAP_EXPLICIT
+return vec3f(0,0,0);
+#endif
+}
+#endif
+`;
+e.IncludesShadersStoreWGSL[o] || (e.IncludesShadersStoreWGSL[o] = t);
+const i = "clipPlaneFragmentDeclaration", c = `#ifdef CLIPPLANE
+varying fClipDistance: f32;
+#endif
+#ifdef CLIPPLANE2
+varying fClipDistance2: f32;
+#endif
+#ifdef CLIPPLANE3
+varying fClipDistance3: f32;
+#endif
+#ifdef CLIPPLANE4
+varying fClipDistance4: f32;
+#endif
+#ifdef CLIPPLANE5
+varying fClipDistance5: f32;
+#endif
+#ifdef CLIPPLANE6
+varying fClipDistance6: f32;
+#endif
+`;
+e.IncludesShadersStoreWGSL[i] || (e.IncludesShadersStoreWGSL[i] = c);
+const f = "clipPlaneFragment", d = `#if defined(CLIPPLANE) || defined(CLIPPLANE2) || defined(CLIPPLANE3) || defined(CLIPPLANE4) || defined(CLIPPLANE5) || defined(CLIPPLANE6)
+if (false) {}
+#endif
+#ifdef CLIPPLANE
+else if (fragmentInputs.fClipDistance>0.0)
+{discard;}
+#endif
+#ifdef CLIPPLANE2
+else if (fragmentInputs.fClipDistance2>0.0)
+{discard;}
+#endif
+#ifdef CLIPPLANE3
+else if (fragmentInputs.fClipDistance3>0.0)
+{discard;}
+#endif
+#ifdef CLIPPLANE4
+else if (fragmentInputs.fClipDistance4>0.0)
+{discard;}
+#endif
+#ifdef CLIPPLANE5
+else if (fragmentInputs.fClipDistance5>0.0)
+{discard;}
+#endif
+#ifdef CLIPPLANE6
+else if (fragmentInputs.fClipDistance6>0.0)
+{discard;}
+#endif
+`;
+e.IncludesShadersStoreWGSL[f] || (e.IncludesShadersStoreWGSL[f] = d);