@vived/component-abb-6700 1.0.0

package/dist/openpbrTransmissionLayerData-CfDVObj5.js

@@ -0,0 +1,352 @@
+import { b0 as e } from "./index-CS3Icp_r.js";
+const r = "openpbrDielectricReflectance", a = `struct ReflectanceParams
+{F0: f32,
+F90: f32,
+coloredF0: vec3f,
+coloredF90: vec3f,};
+#define pbr_inline
+fn dielectricReflectance(
+insideIOR: f32,outsideIOR: f32,specularColor: vec3f,specularWeight: f32
+)->ReflectanceParams
+{var outParams: ReflectanceParams;let dielectricF0=pow((insideIOR-outsideIOR)/(insideIOR+outsideIOR),2.0);
+#if DIELECTRIC_SPECULAR_MODEL==DIELECTRIC_SPECULAR_MODEL_GLTF
+let maxF0=max(specularColor.r,max(specularColor.g,specularColor.b));outParams.F0=dielectricF0*maxF0*specularWeight;
+#else
+outParams.F0=dielectricF0*specularWeight;
+#endif
+let f90Scale=clamp(2.0f*abs(insideIOR-outsideIOR),0.0f,1.0f);outParams.F90=f90Scale*specularWeight;outParams.coloredF0=vec3f(dielectricF0*specularWeight)*specularColor.rgb;
+#if (DIELECTRIC_SPECULAR_MODEL==DIELECTRIC_SPECULAR_MODEL_OPENPBR)
+let dielectricColorF90: vec3f=specularColor.rgb*vec3f(f90Scale)*specularWeight;
+#else
+let dielectricColorF90: vec3f=vec3f(f90Scale)*specularWeight;
+#endif
+outParams.coloredF90=dielectricColorF90;return outParams;}
+`;
+e.IncludesShadersStoreWGSL[r] || (e.IncludesShadersStoreWGSL[r] = a);
+const n = "openpbrGeometryInfo", t = `struct geometryInfoOutParams
+{NdotV: f32,
+NdotVUnclamped: f32,
+environmentBrdf: vec3f,
+horizonOcclusion: f32};struct geometryInfoAnisoOutParams
+{NdotV: f32,
+NdotVUnclamped: f32,
+environmentBrdf: vec3f,
+horizonOcclusion: f32,
+anisotropy: f32,
+anisotropicTangent: vec3f,
+anisotropicBitangent: vec3f,
+TBN: mat3x3<f32>};fn geometryInfo(
+normalW: vec3f,viewDirectionW: vec3f,roughness: f32,geometricNormalW: vec3f
+)->geometryInfoOutParams
+{var outParams: geometryInfoOutParams;outParams.NdotVUnclamped=dot(normalW,viewDirectionW);outParams.NdotV=absEps(outParams.NdotVUnclamped);
+#if defined(ENVIRONMENTBRDF)
+outParams.environmentBrdf=getBRDFLookup(outParams.NdotV,roughness);
+#else
+outParams.environmentBrdf=vec3f(0.0);
+#endif
+outParams.horizonOcclusion=1.0f;
+#if defined(ENVIRONMENTBRDF) && !defined(REFLECTIONMAP_SKYBOX)
+#ifdef HORIZONOCCLUSION
+#if defined(GEOMETRY_NORMAL) || defined(GEOMETRY_COAT_NORMAL)
+#ifdef REFLECTIONMAP_3D
+outParams.horizonOcclusion=environmentHorizonOcclusion(-viewDirectionW,normalW,geometricNormalW);
+#endif
+#endif
+#endif
+#endif
+return outParams;}
+fn geometryInfoAniso(
+normalW: vec3f,viewDirectionW: vec3f,roughness: f32,geometricNormalW: vec3f
+,vAnisotropy: vec3f,TBN: mat3x3<f32>
+)->geometryInfoAnisoOutParams
+{let geoInfo: geometryInfoOutParams=geometryInfo(normalW,viewDirectionW,roughness,geometricNormalW);var outParams: geometryInfoAnisoOutParams;outParams.NdotV=geoInfo.NdotV;outParams.NdotVUnclamped=geoInfo.NdotVUnclamped;outParams.environmentBrdf=geoInfo.environmentBrdf;outParams.horizonOcclusion=geoInfo.horizonOcclusion;outParams.anisotropy=vAnisotropy.b;let anisotropyDirection: vec3f=vec3f(vAnisotropy.xy,0.);let anisoTBN: mat3x3<f32>=mat3x3<f32>(normalize(TBN[0]),normalize(TBN[1]),normalize(TBN[2]));outParams.anisotropicTangent=normalize(anisoTBN*anisotropyDirection);outParams.anisotropicBitangent=normalize(cross(anisoTBN[2],outParams.anisotropicTangent));outParams.TBN=TBN;return outParams;}
+`;
+e.IncludesShadersStoreWGSL[n] || (e.IncludesShadersStoreWGSL[n] = t);
+const i = "openpbrIblFunctions", c = `#ifdef REFLECTION
+fn sampleIrradiance(
+surfaceNormal: vec3f
+#if defined(NORMAL) && defined(USESPHERICALINVERTEX)
+,vEnvironmentIrradianceSH: vec3f
+#endif
+#if (defined(USESPHERICALFROMREFLECTIONMAP) && (!defined(NORMAL) || !defined(USESPHERICALINVERTEX))) || (defined(USEIRRADIANCEMAP) && defined(REFLECTIONMAP_3D))
+,iblMatrix: mat4x4f
+#endif
+#ifdef USEIRRADIANCEMAP
+#ifdef REFLECTIONMAP_3D
+,irradianceSampler: texture_cube<f32>
+,irradianceSamplerSampler: sampler
+#else
+,irradianceSampler: texture_2d<f32>
+,irradianceSamplerSampler: sampler
+#endif
+#ifdef USE_IRRADIANCE_DOMINANT_DIRECTION
+,reflectionDominantDirection: vec3f
+#endif
+#endif
+#ifdef REALTIME_FILTERING
+,reflectionFilteringInfo: vec2f
+#ifdef IBL_CDF_FILTERING
+,icdfSampler: texture_2d<f32>
+,icdfSamplerSampler: sampler
+#endif
+#endif
+,reflectionInfos: vec2f
+,viewDirectionW: vec3f
+,diffuseRoughness: f32
+,surfaceAlbedo: vec3f
+)->vec3f {var environmentIrradiance=vec3f(0.,0.,0.);
+#if (defined(USESPHERICALFROMREFLECTIONMAP) && (!defined(NORMAL) || !defined(USESPHERICALINVERTEX))) || (defined(USEIRRADIANCEMAP) && defined(REFLECTIONMAP_3D))
+var irradianceVector=(iblMatrix*vec4f(surfaceNormal,0.0f)).xyz;var irradianceView=(iblMatrix*vec4f(viewDirectionW,0.0f)).xyz;
+#if !defined(USE_IRRADIANCE_DOMINANT_DIRECTION) && !defined(REALTIME_FILTERING)
+#if BASE_DIFFUSE_MODEL != BRDF_DIFFUSE_MODEL_LAMBERT && BASE_DIFFUSE_MODEL != BRDF_DIFFUSE_MODEL_LEGACY
+{let NdotV=max(dot(surfaceNormal,viewDirectionW),0.0f);irradianceVector=mix(irradianceVector,irradianceView,(0.5f*(1.0f-NdotV))*diffuseRoughness);}
+#endif
+#endif
+#ifdef REFLECTIONMAP_OPPOSITEZ
+irradianceVector.z*=-1.0;irradianceView.z*=-1.0;
+#endif
+#ifdef INVERTCUBICMAP
+irradianceVector.y*=-1.0;irradianceView.y*=-1.0;
+#endif
+#endif
+#ifdef USESPHERICALFROMREFLECTIONMAP
+#if defined(NORMAL) && defined(USESPHERICALINVERTEX)
+environmentIrradiance=vEnvironmentIrradianceSH;
+#else
+#if defined(REALTIME_FILTERING)
+environmentIrradiance=irradiance(reflectionSampler,reflectionSamplerSampler,irradianceVector,reflectionFilteringInfo,diffuseRoughness,surfaceAlbedo,irradianceView
+#ifdef IBL_CDF_FILTERING
+,icdfSampler
+,icdfSamplerSampler
+#endif
+);
+#else
+environmentIrradiance=computeEnvironmentIrradiance(irradianceVector);
+#endif
+#endif
+#elif defined(USEIRRADIANCEMAP)
+#ifdef REFLECTIONMAP_3D
+let environmentIrradianceFromTexture: vec4f=textureSample(irradianceSampler,irradianceSamplerSampler,irradianceVector);
+#else
+let environmentIrradianceFromTexture: vec4f=textureSample(irradianceSampler,irradianceSamplerSampler,reflectionCoords);
+#endif
+environmentIrradiance=environmentIrradianceFromTexture.rgb;
+#ifdef RGBDREFLECTION
+environmentIrradiance.rgb=fromRGBD(environmentIrradianceFromTexture);
+#endif
+#ifdef GAMMAREFLECTION
+environmentIrradiance.rgb=toLinearSpaceVec3(environmentIrradiance.rgb);
+#endif
+#ifdef USE_IRRADIANCE_DOMINANT_DIRECTION
+let Ls: vec3f=normalize(reflectionDominantDirection);let NoL: f32=dot(irradianceVector,Ls);let NoV: f32=dot(irradianceVector,irradianceView);var diffuseRoughnessTerm=vec3f(1.0f);
+#if BASE_DIFFUSE_MODEL==BRDF_DIFFUSE_MODEL_EON
+let LoV: f32=dot (Ls,irradianceView);let mag: f32=length(reflectionDominantDirection)*2.0f;let clampedAlbedo: vec3f=clamp(surfaceAlbedo,vec3f(0.1f),vec3f(1.0f));diffuseRoughnessTerm=diffuseBRDF_EON(clampedAlbedo,diffuseRoughness,NoL,NoV,LoV)*PI;diffuseRoughnessTerm=diffuseRoughnessTerm/clampedAlbedo;diffuseRoughnessTerm=mix(vec3f(1.0f),diffuseRoughnessTerm,sqrt(clamp(mag*NoV,0.0f,1.0f)));
+#elif BASE_DIFFUSE_MODEL==BRDF_DIFFUSE_MODEL_BURLEY
+let H: vec3f=(irradianceView+Ls)*0.5f;let VoH: f32=dot(irradianceView,H);diffuseRoughnessTerm=vec3f(diffuseBRDF_Burley(NoL,NoV,VoH,diffuseRoughness)*PI);
+#endif
+environmentIrradiance=environmentIrradiance.rgb*diffuseRoughnessTerm;
+#endif
+#endif
+environmentIrradiance*=reflectionInfos.x;return environmentIrradiance;}
+#ifdef REFLECTIONMAP_3D
+fn createReflectionCoords(vPositionW: vec3f,normalW: vec3f)->vec3f
+#else
+fn createReflectionCoords(vPositionW: vec3f,normalW: vec3f)->vec2f
+#endif
+{var reflectionVector: vec3f=computeReflectionCoords(vec4f(vPositionW,1.0f),normalW);
+#ifdef REFLECTIONMAP_OPPOSITEZ
+reflectionVector.z*=-1.0;
+#endif
+#ifdef REFLECTIONMAP_3D
+var reflectionCoords: vec3f=reflectionVector;
+#else
+var reflectionCoords: vec2f=reflectionVector.xy;
+#ifdef REFLECTIONMAP_PROJECTION
+reflectionCoords/=reflectionVector.z;
+#endif
+reflectionCoords.y=1.0f-reflectionCoords.y;
+#endif
+return reflectionCoords;}
+fn sampleRadiance(
+alphaG: f32
+,reflectionMicrosurfaceInfos: vec3f
+,reflectionInfos: vec2f
+,geoInfo: geometryInfoOutParams
+#ifdef REFLECTIONMAP_3D
+,reflectionSampler: texture_cube<f32>
+,reflectionSamplerSampler: sampler
+,reflectionCoords: vec3f
+#else
+,reflectionSampler: texture_2d<f32>
+,reflectionSamplerSampler: sampler
+,reflectionCoords: vec2f
+#endif
+#ifdef REALTIME_FILTERING
+,reflectionFilteringInfo: vec2f
+#endif
+)->vec3f {var environmentRadiance: vec4f=vec4f(0.f,0.f,0.f,0.f);
+#if defined(LODINREFLECTIONALPHA) && !defined(REFLECTIONMAP_SKYBOX)
+var reflectionLOD: f32=getLodFromAlphaG(reflectionMicrosurfaceInfos.x,alphaG,geoInfo.NdotVUnclamped);
+#elif defined(LINEARSPECULARREFLECTION)
+var reflectionLOD: f32=getLinearLodFromRoughness(reflectionMicrosurfaceInfos.x,roughness);
+#else
+var reflectionLOD: f32=getLodFromAlphaG(reflectionMicrosurfaceInfos.x,alphaG);
+#endif
+reflectionLOD=reflectionLOD*reflectionMicrosurfaceInfos.y+reflectionMicrosurfaceInfos.z;
+#ifdef REALTIME_FILTERING
+environmentRadiance=vec4f(radiance(alphaG,reflectionSampler,reflectionSamplerSampler,reflectionCoords,reflectionFilteringInfo),1.0f);
+#else
+environmentRadiance=textureSampleLevel(reflectionSampler,reflectionSamplerSampler,reflectionCoords,reflectionLOD);
+#endif
+#ifdef RGBDREFLECTION
+environmentRadiance.rgb=fromRGBD(environmentRadiance);
+#endif
+#ifdef GAMMAREFLECTION
+environmentRadiance.rgb=toLinearSpaceVec3(environmentRadiance.rgb);
+#endif
+environmentRadiance=vec4f(environmentRadiance.rgb*reflectionInfos.x,environmentRadiance.a);return environmentRadiance.rgb;}
+#if defined(ANISOTROPIC)
+fn sampleRadianceAnisotropic(
+alphaG: f32
+,reflectionMicrosurfaceInfos: vec3f
+,reflectionInfos: vec2f
+,geoInfo: geometryInfoAnisoOutParams
+,normalW: vec3f
+,viewDirectionW: vec3f
+,positionW: vec3f
+,noise: vec3f
+,isRefraction: bool
+,ior: f32
+#ifdef REFLECTIONMAP_3D
+,reflectionSampler: texture_cube<f32>
+,reflectionSamplerSampler: sampler
+#else
+,reflectionSampler: texture_2d<f32>
+,reflectionSamplerSampler: sampler
+#endif
+#ifdef REALTIME_FILTERING
+,reflectionFilteringInfo: vec2f
+#endif
+)->vec3f {var environmentRadiance: vec4f=vec4f(0.f,0.f,0.f,0.f);let alphaT=alphaG*sqrt(2.0f/(1.0f+(1.0f-geoInfo.anisotropy)*(1.0f-geoInfo.anisotropy)));let alphaB=(1.0f-geoInfo.anisotropy)*alphaT;let modifiedAlphaG=alphaB;
+#if defined(LODINREFLECTIONALPHA) && !defined(REFLECTIONMAP_SKYBOX)
+var reflectionLOD: f32=getLodFromAlphaG(reflectionMicrosurfaceInfos.x,modifiedAlphaG,geoInfo.NdotVUnclamped);
+#elif defined(LINEARSPECULARREFLECTION)
+var reflectionLOD: f32=getLinearLodFromRoughness(reflectionMicrosurfaceInfos.x,roughness);
+#else
+var reflectionLOD: f32=getLodFromAlphaG(reflectionMicrosurfaceInfos.x,modifiedAlphaG);
+#endif
+reflectionLOD=reflectionLOD*reflectionMicrosurfaceInfos.y+reflectionMicrosurfaceInfos.z;
+#ifdef REALTIME_FILTERING
+var view=(uniforms.reflectionMatrix*vec4f(viewDirectionW,0.0f)).xyz;var tangent=(uniforms.reflectionMatrix*vec4f(geoInfo.anisotropicTangent,0.0f)).xyz;var bitangent=(uniforms.reflectionMatrix*vec4f(geoInfo.anisotropicBitangent,0.0f)).xyz;var normal=(uniforms.reflectionMatrix*vec4f(normalW,0.0f)).xyz;
+#ifdef REFLECTIONMAP_OPPOSITEZ
+view.z*=-1.0f;tangent.z*=-1.0f;bitangent.z*=-1.0f;normal.z*=-1.0f;
+#endif
+environmentRadiance =
+vec4f(radianceAnisotropic(alphaT,alphaB,reflectionSampler,reflectionSamplerSampler,
+view,tangent,
+bitangent,normal,
+reflectionFilteringInfo,noise.xy,isRefraction,ior),
+1.0f);
+#else
+const samples: i32=16;var radianceSample=vec4f(0.0);var accumulatedRadiance=vec3f(0.0);var reflectionCoords=vec3f(0.0);var sample_weight=0.0f;var total_weight=0.0f;let step=1.0f/f32(max(samples-1,1));for (var i: i32=0; i<samples; i++) {var t: f32=mix(-1.0,1.0,f32(i)*step);t+=step*2.0*noise.x;sample_weight=max(1.0-abs(t),0.001);sample_weight*=sample_weight;t*=min(4.0*alphaT*geoInfo.anisotropy,1.0);var bentNormal: vec3f;if (t<0.0) {let blend: f32=t+1.0;bentNormal=normalize(mix(-geoInfo.anisotropicTangent,normalW,blend));} else if (t>0.0) {let blend: f32=t;bentNormal=normalize(mix(normalW,geoInfo.anisotropicTangent,blend));} else {bentNormal=normalW;}
+if (isRefraction) {reflectionCoords=double_refract(-viewDirectionW,bentNormal,ior);} else {reflectionCoords=reflect(-viewDirectionW,bentNormal);}
+reflectionCoords=(uniforms.reflectionMatrix*vec4f(reflectionCoords,0.f)).xyz;
+#ifdef REFLECTIONMAP_OPPOSITEZ
+reflectionCoords.z*=-1.0f;
+#endif
+radianceSample=textureSampleLevel(reflectionSampler,reflectionSamplerSampler,reflectionCoords,reflectionLOD);
+#ifdef RGBDREFLECTION
+accumulatedRadiance+=vec3f(sample_weight)*fromRGBD(radianceSample);
+#elif defined(GAMMAREFLECTION)
+accumulatedRadiance+=vec3f(sample_weight)*toLinearSpaceVec3(radianceSample.rgb);
+#else
+accumulatedRadiance+=vec3f(sample_weight)*radianceSample.rgb;
+#endif
+total_weight+=sample_weight;}
+environmentRadiance=vec4f(accumulatedRadiance/vec3f(total_weight),1.0f);
+#endif
+environmentRadiance=vec4f(environmentRadiance.rgb*reflectionInfos.xxx,environmentRadiance.a);return environmentRadiance.rgb;}
+#endif
+#endif
+#ifdef ENVIRONMENTBRDF
+fn computeDielectricIblFresnel(reflectance: ReflectanceParams,environmentBrdf: vec3f)->f32
+{let dielectricIblFresnel: f32=getReflectanceFromBRDFWithEnvLookup(vec3f(reflectance.F0),vec3f(reflectance.F90),environmentBrdf).r;let dielectricECF: f32=1.0+reflectance.F0*(1.0/environmentBrdf.y-1.0);return clamp(dielectricIblFresnel*dielectricECF,0.0,1.0);}
+fn computeConductorIblFresnel(reflectance: ReflectanceParams,environmentBrdf: vec3f)->vec3f
+{
+#if (CONDUCTOR_SPECULAR_MODEL==CONDUCTOR_SPECULAR_MODEL_OPENPBR)
+let openPBRBrdf: vec3f=vec3f(environmentBrdf.xy,environmentBrdf.z/BRDF_Z_SCALE);let b: vec3f =getF82B(reflectance.coloredF0,reflectance.coloredF90);let E_F82: vec3f=getF82DirectionalAlbedo(reflectance.coloredF0,vec3f(1.0),b,openPBRBrdf);let F_avg: vec3f=getF82AverageFresnel(reflectance.coloredF0,b);let ECF: vec3f =vec3f(1.0)+F_avg*(vec3f(1.0)/openPBRBrdf.y-vec3f(1.0));return clamp(E_F82*ECF,vec3f(0.0),vec3f(1.0));
+#else
+return getReflectanceFromBRDFLookup(reflectance.coloredF0,reflectance.coloredF90,environmentBrdf);
+#endif
+}
+#endif
+`;
+e.IncludesShadersStoreWGSL[i] || (e.IncludesShadersStoreWGSL[i] = c);
+const o = "openpbrSubsurfaceLayerData", s = `var subsurface_weight: f32=uniforms.vSubsurfaceWeight;var subsurface_color: vec3f=uniforms.vSubsurfaceColor.rgb;var subsurface_radius: f32=uniforms.vSubsurfaceRadius;var subsurface_radius_scale: vec3f=uniforms.vSubsurfaceRadiusScale;var subsurface_scatter_anisotropy: f32=clamp(uniforms.vSubsurfaceScatterAnisotropy,-0.9999f,0.9999f);
+#ifdef SUBSURFACE_WEIGHT
+let subsurfaceWeightFromTexture: vec4f=TEXRD(subsurfaceWeightSampler,subsurfaceWeightSamplerSampler,fragmentInputs.vSubsurfaceWeightUV+uvOffset);
+#endif
+#ifdef SUBSURFACE_COLOR
+let subsurfaceColorFromTexture: vec4f=TEXRD(subsurfaceColorSampler,subsurfaceColorSamplerSampler,fragmentInputs.vSubsurfaceColorUV+uvOffset);
+#endif
+#ifdef SUBSURFACE_RADIUS_SCALE
+let subsurfaceRadiusScaleFromTexture: vec4f=TEXRD(subsurfaceRadiusScaleSampler,subsurfaceRadiusScaleSamplerSampler,fragmentInputs.vSubsurfaceRadiusScaleUV+uvOffset);
+#endif
+#ifdef SUBSURFACE_WEIGHT
+#ifdef SUBSURFACE_WEIGHT_FROM_TEXTURE_ALPHA
+subsurface_weight*=subsurfaceWeightFromTexture.a;
+#else
+subsurface_weight*=subsurfaceWeightFromTexture.r;
+#endif
+#endif
+#ifdef SUBSURFACE_COLOR
+#ifdef SUBSURFACE_COLOR_GAMMA
+subsurface_color*=toLinearSpaceVec3(subsurfaceColorFromTexture.rgb);
+#else
+subsurface_color*=subsurfaceColorFromTexture.rgb;
+#endif
+subsurface_color*=uniforms.vSubsurfaceColorInfos.y;
+#endif
+#ifdef SUBSURFACE_RADIUS_SCALE
+subsurface_radius_scale*=subsurfaceRadiusScaleFromTexture.rgb;
+#endif
+`;
+e.IncludesShadersStoreWGSL[o] || (e.IncludesShadersStoreWGSL[o] = s);
+const f = "openpbrTransmissionLayerData", l = `var transmission_weight: f32=uniforms.vTransmissionWeight;var transmission_color: vec3f=uniforms.vTransmissionColor.rgb;var transmission_depth: f32=uniforms.vTransmissionDepth;var transmission_scatter: vec3f=uniforms.vTransmissionScatter.rgb;var transmission_scatter_anisotropy: f32=clamp(uniforms.vTransmissionScatterAnisotropy,-0.9999f,0.9999f);var transmission_dispersion_scale: f32=uniforms.vTransmissionDispersionScale;var transmission_dispersion_abbe_number: f32=uniforms.vTransmissionDispersionAbbeNumber;
+#ifdef TRANSMISSION_WEIGHT
+let transmissionWeightFromTexture: vec4f=TEXRD(transmissionWeightSampler,transmissionWeightSamplerSampler,fragmentInputs.vTransmissionWeightUV+uvOffset);
+#endif
+#ifdef TRANSMISSION_COLOR
+let transmissionColorFromTexture: vec4f=TEXRD(transmissionColorSampler,transmissionColorSamplerSampler,fragmentInputs.vTransmissionColorUV+uvOffset);
+#endif
+#ifdef TRANSMISSION_DEPTH
+let transmissionDepthFromTexture: vec4f=TEXRD(transmissionDepthSampler,transmissionDepthSamplerSampler,fragmentInputs.vTransmissionDepthUV+uvOffset);
+#endif
+#ifdef TRANSMISSION_SCATTER
+let transmissionScatterFromTexture: vec4f=TEXRD(transmissionScatterSampler,transmissionScatterSamplerSampler,fragmentInputs.vTransmissionScatterUV+uvOffset);
+#endif
+#ifdef TRANSMISSION_DISPERSION_SCALE
+let transmissionDispersionScaleFromTexture: vec4f=TEXRD(transmissionDispersionScaleSampler,transmissionDispersionScaleSamplerSampler,fragmentInputs.vTransmissionDispersionScaleUV+uvOffset);
+#endif
+#ifdef TRANSMISSION_WEIGHT
+transmission_weight*=transmissionWeightFromTexture.r;
+#endif
+#ifdef TRANSMISSION_COLOR
+#ifdef TRANSMISSION_COLOR_GAMMA
+transmission_color*=toLinearSpaceVec3(transmissionColorFromTexture.rgb);
+#else
+transmission_color*=transmissionColorFromTexture.rgb;
+#endif
+transmission_color*=uniforms.vTransmissionColorInfos.y;
+#endif
+#ifdef TRANSMISSION_DEPTH
+transmission_depth*=transmissionDepthFromTexture.r;
+#endif
+#ifdef TRANSMISSION_SCATTER
+transmission_scatter*=transmissionScatterFromTexture.rgb;
+#endif
+#ifdef TRANSMISSION_DISPERSION_SCALE
+transmission_dispersion_scale*=transmissionDispersionScaleFromTexture.r;
+#endif
+`;
+e.IncludesShadersStoreWGSL[f] || (e.IncludesShadersStoreWGSL[f] = l);

package/dist/openpbrUboDeclaration-CA2pvSbt.js

@@ -0,0 +1,9 @@
+import { b0 as o } from "./index-CS3Icp_r.js";
+import "./sceneUboDeclaration-JByfVKik.js";
+import "./logDepthDeclaration-Bwm-3KyB.js";
+const f = "openpbrUboDeclaration", i = `uniform vTangentSpaceParams: vec2f;uniform vLightingIntensity: vec4f;uniform pointSize: f32;uniform vDebugMode: vec2f;uniform renderTargetSize: vec2f;uniform cameraInfo: vec4f;uniform vTextureRepetitionHexTilingParams: vec4f;uniform backgroundRefractionMatrix: mat4x4f;uniform vBackgroundRefractionInfos: vec3f;uniform vReflectionInfos: vec2f;uniform reflectionMatrix: mat4x4f;uniform vReflectionMicrosurfaceInfos: vec3f;uniform vReflectionPosition: vec3f;uniform vReflectionSize: vec3f;uniform vReflectionFilteringInfo: vec2f;uniform vReflectionDominantDirection: vec3f;uniform vReflectionColor: vec3f;uniform vSphericalL00: vec3f;uniform vSphericalL1_1: vec3f;uniform vSphericalL10: vec3f;uniform vSphericalL11: vec3f;uniform vSphericalL2_2: vec3f;uniform vSphericalL2_1: vec3f;uniform vSphericalL20: vec3f;uniform vSphericalL21: vec3f;uniform vSphericalL22: vec3f;uniform vSphericalX: vec3f;uniform vSphericalY: vec3f;uniform vSphericalZ: vec3f;uniform vSphericalXX_ZZ: vec3f;uniform vSphericalYY_ZZ: vec3f;uniform vSphericalZZ: vec3f;uniform vSphericalXY: vec3f;uniform vSphericalYZ: vec3f;uniform vSphericalZX: vec3f;uniform vBaseWeight: f32;uniform vBaseColor: vec4f;uniform vBaseDiffuseRoughness: f32;uniform vReflectanceInfo: vec4f;uniform vSpecularColor: vec4f;uniform vSpecularAnisotropy: vec3f;uniform vTransmissionWeight : f32;uniform vTransmissionColor : vec3f;uniform vTransmissionDepth : f32;uniform vTransmissionScatter : vec3f;uniform vTransmissionScatterAnisotropy : f32;uniform vTransmissionDispersionScale : f32;uniform vTransmissionDispersionAbbeNumber : f32;uniform vSubsurfaceWeight: f32;uniform vSubsurfaceColor: vec3f;uniform vSubsurfaceRadius: f32;uniform vSubsurfaceRadiusScale: vec3f;uniform vSubsurfaceScatterAnisotropy: f32;uniform vCoatWeight: f32;uniform vCoatColor: vec3f;uniform vCoatRoughness: f32;uniform vCoatRoughnessAnisotropy: f32;uniform vCoatIor: f32;uniform vCoatDarkening : f32;uniform vFuzzWeight: f32;uniform vFuzzColor: vec3f;uniform vFuzzRoughness: f32;uniform vGeometryThinWalled: f32;uniform vGeometryCoatTangent: vec2f;uniform vGeometryThickness: f32;uniform vEmissionColor: vec3f;uniform vThinFilmWeight: f32;uniform vThinFilmThickness: vec2f;uniform vThinFilmIor: f32;uniform vBaseWeightInfos: vec2f;uniform baseWeightMatrix: mat4x4f;uniform vBaseColorInfos: vec2f;uniform baseColorMatrix: mat4x4f;uniform vBaseDiffuseRoughnessInfos: vec2f;uniform baseDiffuseRoughnessMatrix: mat4x4f;uniform vBaseMetalnessInfos: vec2f;uniform baseMetalnessMatrix: mat4x4f;uniform vSpecularWeightInfos: vec2f;uniform specularWeightMatrix: mat4x4f;uniform vSpecularColorInfos: vec2f;uniform specularColorMatrix: mat4x4f;uniform vSpecularRoughnessInfos: vec2f;uniform specularRoughnessMatrix: mat4x4f;uniform vSpecularRoughnessAnisotropyInfos: vec2f;uniform specularRoughnessAnisotropyMatrix: mat4x4f;uniform vTransmissionWeightInfos : vec2f;uniform transmissionWeightMatrix : mat4x4f;uniform vTransmissionColorInfos : vec2f;uniform transmissionColorMatrix : mat4x4f;uniform vTransmissionDepthInfos : vec2f;uniform transmissionDepthMatrix : mat4x4f;uniform vTransmissionScatterInfos : vec2f;uniform transmissionScatterMatrix : mat4x4f;uniform vTransmissionDispersionScaleInfos : vec2f;uniform transmissionDispersionScaleMatrix : mat4x4f;uniform vSubsurfaceWeightInfos: vec2f;uniform subsurfaceWeightMatrix: mat4x4f;uniform vSubsurfaceColorInfos: vec2f;uniform subsurfaceColorMatrix: mat4x4f;uniform vSubsurfaceRadiusScaleInfos: vec2f;uniform subsurfaceRadiusScaleMatrix: mat4x4f;uniform vCoatWeightInfos: vec2f;uniform coatWeightMatrix: mat4x4f;uniform vCoatColorInfos: vec2f;uniform coatColorMatrix: mat4x4f;uniform vCoatRoughnessInfos: vec2f;uniform coatRoughnessMatrix: mat4x4f;uniform vCoatRoughnessAnisotropyInfos: vec2f;uniform coatRoughnessAnisotropyMatrix: mat4x4f;uniform vCoatDarkeningInfos : vec2f;uniform coatDarkeningMatrix : mat4x4f;uniform vFuzzWeightInfos: vec2f;uniform fuzzWeightMatrix: mat4x4f;uniform vFuzzColorInfos: vec2f;uniform fuzzColorMatrix: mat4x4f;uniform vFuzzRoughnessInfos: vec2f;uniform fuzzRoughnessMatrix: mat4x4f;uniform vGeometryNormalInfos: vec2f;uniform geometryNormalMatrix: mat4x4f;uniform vGeometryTangentInfos: vec2f;uniform geometryTangentMatrix: mat4x4f;uniform vGeometryCoatNormalInfos: vec2f;uniform geometryCoatNormalMatrix: mat4x4f;uniform vGeometryCoatTangentInfos: vec2f;uniform geometryCoatTangentMatrix: mat4x4f;uniform vGeometryOpacityInfos: vec2f;uniform geometryOpacityMatrix: mat4x4f;uniform vGeometryThicknessInfos: vec2f;uniform geometryThicknessMatrix: mat4x4f;uniform vEmissionColorInfos: vec2f;uniform emissionColorMatrix: mat4x4f;uniform vThinFilmWeightInfos: vec2f;uniform thinFilmWeightMatrix: mat4x4f;uniform vThinFilmThicknessInfos: vec2f;uniform thinFilmThicknessMatrix: mat4x4f;uniform vAmbientOcclusionInfos: vec2f;uniform ambientOcclusionMatrix: mat4x4f;
+#define ADDITIONAL_UBO_DECLARATION
+#include<sceneUboDeclaration>
+#include<meshUboDeclaration>
+`;
+o.IncludesShadersStoreWGSL[f] || (o.IncludesShadersStoreWGSL[f] = i);

package/dist/openpbrUboDeclaration-xU8VOaib.js

@@ -0,0 +1,10 @@
+import { b0 as e } from "./index-CS3Icp_r.js";
+import "./sceneUboDeclaration-B6oxsfcj.js";
+import "./logDepthDeclaration-gUfeSnXX.js";
+const a = "openpbrUboDeclaration", o = `layout(std140,column_major) uniform;uniform Material {vec2 vTangentSpaceParams;vec4 vLightingIntensity;float pointSize;vec2 vDebugMode;vec2 renderTargetSize;vec4 cameraInfo;vec4 vTextureRepetitionHexTilingParams;mat4 backgroundRefractionMatrix;vec3 vBackgroundRefractionInfos;vec2 vReflectionInfos;mat4 reflectionMatrix;vec3 vReflectionMicrosurfaceInfos;vec3 vReflectionPosition;vec3 vReflectionSize;vec2 vReflectionFilteringInfo;vec3 vReflectionDominantDirection;vec3 vReflectionColor;vec3 vSphericalL00;vec3 vSphericalL1_1;vec3 vSphericalL10;vec3 vSphericalL11;vec3 vSphericalL2_2;vec3 vSphericalL2_1;vec3 vSphericalL20;vec3 vSphericalL21;vec3 vSphericalL22;vec3 vSphericalX;vec3 vSphericalY;vec3 vSphericalZ;vec3 vSphericalXX_ZZ;vec3 vSphericalYY_ZZ;vec3 vSphericalZZ;vec3 vSphericalXY;vec3 vSphericalYZ;vec3 vSphericalZX;float vBaseWeight;vec4 vBaseColor;float vBaseDiffuseRoughness;vec4 vReflectanceInfo;vec4 vSpecularColor;vec3 vSpecularAnisotropy;float vTransmissionWeight;vec3 vTransmissionColor;float vTransmissionDepth;vec3 vTransmissionScatter;float vTransmissionScatterAnisotropy;float vTransmissionDispersionScale;float vTransmissionDispersionAbbeNumber;float vSubsurfaceWeight;vec3 vSubsurfaceColor;float vSubsurfaceRadius;vec3 vSubsurfaceRadiusScale;float vSubsurfaceScatterAnisotropy;float vCoatWeight;vec3 vCoatColor;float vCoatRoughness;float vCoatRoughnessAnisotropy;float vCoatIor;float vCoatDarkening;float vFuzzWeight;vec3 vFuzzColor;float vFuzzRoughness;float vGeometryThinWalled;vec2 vGeometryCoatTangent;float vGeometryThickness;vec3 vEmissionColor;float vThinFilmWeight;vec2 vThinFilmThickness;float vThinFilmIor;vec2 vBaseWeightInfos;mat4 baseWeightMatrix;vec2 vBaseColorInfos;mat4 baseColorMatrix;vec2 vBaseDiffuseRoughnessInfos;mat4 baseDiffuseRoughnessMatrix;vec2 vBaseMetalnessInfos;mat4 baseMetalnessMatrix;vec2 vSpecularWeightInfos;mat4 specularWeightMatrix;vec2 vSpecularColorInfos;mat4 specularColorMatrix;vec2 vSpecularRoughnessInfos;mat4 specularRoughnessMatrix;vec2 vSpecularRoughnessAnisotropyInfos;mat4 specularRoughnessAnisotropyMatrix;vec2 vTransmissionWeightInfos;mat4 transmissionWeightMatrix;vec2 vTransmissionColorInfos;mat4 transmissionColorMatrix;vec2 vTransmissionDepthInfos;mat4 transmissionDepthMatrix;vec2 vTransmissionScatterInfos;mat4 transmissionScatterMatrix;vec2 vTransmissionDispersionScaleInfos;mat4 transmissionDispersionScaleMatrix;vec2 vSubsurfaceWeightInfos;mat4 subsurfaceWeightMatrix;vec2 vSubsurfaceColorInfos;mat4 subsurfaceColorMatrix;vec2 vSubsurfaceRadiusScaleInfos;mat4 subsurfaceRadiusScaleMatrix;vec2 vCoatWeightInfos;mat4 coatWeightMatrix;vec2 vCoatColorInfos;mat4 coatColorMatrix;vec2 vCoatRoughnessInfos;mat4 coatRoughnessMatrix;vec2 vCoatRoughnessAnisotropyInfos;mat4 coatRoughnessAnisotropyMatrix;vec2 vCoatDarkeningInfos;mat4 coatDarkeningMatrix;vec2 vFuzzWeightInfos;mat4 fuzzWeightMatrix;vec2 vFuzzColorInfos;mat4 fuzzColorMatrix;vec2 vFuzzRoughnessInfos;mat4 fuzzRoughnessMatrix;vec2 vGeometryNormalInfos;mat4 geometryNormalMatrix;vec2 vGeometryTangentInfos;mat4 geometryTangentMatrix;vec2 vGeometryCoatNormalInfos;mat4 geometryCoatNormalMatrix;vec2 vGeometryCoatTangentInfos;mat4 geometryCoatTangentMatrix;vec2 vGeometryOpacityInfos;mat4 geometryOpacityMatrix;vec2 vGeometryThicknessInfos;mat4 geometryThicknessMatrix;vec2 vEmissionColorInfos;mat4 emissionColorMatrix;vec2 vThinFilmWeightInfos;mat4 thinFilmWeightMatrix;vec2 vThinFilmThicknessInfos;mat4 thinFilmThicknessMatrix;vec2 vAmbientOcclusionInfos;mat4 ambientOcclusionMatrix;
+#define ADDITIONAL_UBO_DECLARATION
+};
+#include<sceneUboDeclaration>
+#include<meshUboDeclaration>
+`;
+e.IncludesShadersStore[a] || (e.IncludesShadersStore[a] = o);

package/dist/pass.fragment-1mMP54bb.js

@@ -0,0 +1,10 @@
+import { b0 as r } from "./index-CS3Icp_r.js";
+const e = "passPixelShader", t = `varying vUV: vec2f;var textureSamplerSampler: sampler;var textureSampler: texture_2d<f32>;
+#define CUSTOM_FRAGMENT_DEFINITIONS
+@fragment
+fn main(input: FragmentInputs)->FragmentOutputs {fragmentOutputs.color=textureSample(textureSampler,textureSamplerSampler,input.vUV);}`;
+r.ShadersStoreWGSL[e] || (r.ShadersStoreWGSL[e] = t);
+const S = { name: e, shader: t };
+export {
+  S as passPixelShaderWGSL
+};

package/dist/pass.fragment-DzaUp_jk.js

@@ -0,0 +1,10 @@
+import { b0 as r } from "./index-CS3Icp_r.js";
+const e = "passPixelShader", a = `varying vec2 vUV;uniform sampler2D textureSampler;
+#define CUSTOM_FRAGMENT_DEFINITIONS
+void main(void) 
+{gl_FragColor=texture2D(textureSampler,vUV);}`;
+r.ShadersStore[e] || (r.ShadersStore[e] = a);
+const t = { name: e, shader: a };
+export {
+  t as passPixelShader
+};

package/dist/passCube.fragment-CQaXS7g3.js

@@ -0,0 +1,29 @@
+import { b0 as r } from "./index-CS3Icp_r.js";
+const e = "passCubePixelShader", t = `varying vec2 vUV;uniform samplerCube textureSampler;
+#define CUSTOM_FRAGMENT_DEFINITIONS
+void main(void) 
+{vec2 uv=vUV*2.0-1.0;
+#ifdef POSITIVEX
+gl_FragColor=textureCube(textureSampler,vec3(1.001,uv.y,uv.x));
+#endif
+#ifdef NEGATIVEX
+gl_FragColor=textureCube(textureSampler,vec3(-1.001,uv.y,uv.x));
+#endif
+#ifdef POSITIVEY
+gl_FragColor=textureCube(textureSampler,vec3(uv.y,1.001,uv.x));
+#endif
+#ifdef NEGATIVEY
+gl_FragColor=textureCube(textureSampler,vec3(uv.y,-1.001,uv.x));
+#endif
+#ifdef POSITIVEZ
+gl_FragColor=textureCube(textureSampler,vec3(uv,1.001));
+#endif
+#ifdef NEGATIVEZ
+gl_FragColor=textureCube(textureSampler,vec3(uv,-1.001));
+#endif
+}`;
+r.ShadersStore[e] || (r.ShadersStore[e] = t);
+const a = { name: e, shader: t };
+export {
+  a as passCubePixelShader
+};

package/dist/passCube.fragment-QJGPwAXI.js

@@ -0,0 +1,29 @@
+import { b0 as t } from "./index-CS3Icp_r.js";
+const e = "passCubePixelShader", r = `varying vUV: vec2f;var textureSamplerSampler: sampler;var textureSampler: texture_cube<f32>;
+#define CUSTOM_FRAGMENT_DEFINITIONS
+@fragment
+fn main(input: FragmentInputs)->FragmentOutputs {var uv: vec2f=input.vUV*2.0-1.0;
+#ifdef POSITIVEX
+fragmentOutputs.color=textureSample(textureSampler,textureSamplerSampler,vec3f(1.001,uv.y,uv.x));
+#endif
+#ifdef NEGATIVEX
+fragmentOutputs.color=textureSample(textureSampler,textureSamplerSampler,vec3f(-1.001,uv.y,uv.x));
+#endif
+#ifdef POSITIVEY
+fragmentOutputs.color=textureSample(textureSampler,textureSamplerSampler,vec3f(uv.y,1.001,uv.x));
+#endif
+#ifdef NEGATIVEY
+fragmentOutputs.color=textureSample(textureSampler,textureSamplerSampler,vec3f(uv.y,-1.001,uv.x));
+#endif
+#ifdef POSITIVEZ
+fragmentOutputs.color=textureSample(textureSampler,textureSamplerSampler,vec3f(uv,1.001));
+#endif
+#ifdef NEGATIVEZ
+fragmentOutputs.color=textureSample(textureSampler,textureSamplerSampler,vec3f(uv,-1.001));
+#endif
+}`;
+t.ShadersStoreWGSL[e] || (t.ShadersStoreWGSL[e] = r);
+const u = { name: e, shader: r };
+export {
+  u as passCubePixelShaderWGSL
+};