@vived/component-abb-6700 1.0.0

package/dist/geometry.fragment-Bsis3UG2.js

@@ -0,0 +1,275 @@
+import { b0 as i } from "./index-CS3Icp_r.js";
+import "./clipPlaneFragment-DJwQynjA.js";
+import "./bumpFragment-Dd-ojPA1.js";
+import "./helperFunctions-Bt7Zfkrp.js";
+import "./pbrIBLFunctions-B0bVAXCF.js";
+import "./sceneUboDeclaration-JByfVKik.js";
+import "./pbrBRDFFunctions-EugoWm6O.js";
+import "./openpbrTransmissionLayerData-CfDVObj5.js";
+const e = "geometryPixelShader", r = `#ifdef BUMP
+varying vWorldView0: vec4f;varying vWorldView1: vec4f;varying vWorldView2: vec4f;varying vWorldView3: vec4f;varying vNormalW: vec3f;
+#else
+varying vNormalV: vec3f;
+#endif
+varying vViewPos: vec4f;
+#if defined(POSITION) || defined(BUMP) || defined(IRRADIANCE)
+varying vPositionW: vec3f;
+#endif
+#if defined(VELOCITY) || defined(VELOCITY_LINEAR)
+varying vCurrentPosition: vec4f;varying vPreviousPosition: vec4f;
+#endif
+#ifdef NEED_UV
+varying vUV: vec2f;
+#endif
+#ifdef BUMP
+uniform vBumpInfos: vec3f;uniform vTangentSpaceParams: vec2f;
+#endif
+#if defined(REFLECTIVITY)
+#if defined(ORMTEXTURE) || defined(SPECULARGLOSSINESSTEXTURE) || defined(REFLECTIVITYTEXTURE)
+var reflectivitySamplerSampler: sampler;var reflectivitySampler: texture_2d<f32>;varying vReflectivityUV: vec2f;
+#else
+#ifdef METALLIC_TEXTURE
+var metallicSamplerSampler: sampler;var metallicSampler: texture_2d<f32>;varying vMetallicUV: vec2f;
+#endif
+#ifdef ROUGHNESS_TEXTURE
+var roughnessSamplerSampler: sampler;var roughnessSampler: texture_2d<f32>;varying vRoughnessUV: vec2f;
+#endif
+#endif
+#ifdef ALBEDOTEXTURE
+varying vAlbedoUV: vec2f;var albedoSamplerSampler: sampler;var albedoSampler: texture_2d<f32>;
+#endif
+#ifdef REFLECTIVITYCOLOR
+uniform reflectivityColor: vec3f;
+#endif
+#ifdef ALBEDOCOLOR
+uniform albedoColor: vec3f;
+#endif
+#ifdef METALLIC
+uniform metallic: f32;
+#endif
+#if defined(ROUGHNESS) || defined(GLOSSINESS)
+uniform glossiness: f32;
+#endif
+#endif
+#if defined(ALPHATEST) && defined(NEED_UV)
+var diffuseSamplerSampler: sampler;var diffuseSampler: texture_2d<f32>;
+#endif
+#include<clipPlaneFragmentDeclaration>
+#include<bumpFragmentMainFunctions>
+#include<bumpFragmentFunctions>
+#include<helperFunctions>
+#ifdef IRRADIANCE
+#include<pbrFragmentReflectionDeclaration>
+#ifdef REFLECTION
+#ifdef USEIRRADIANCEMAP
+#include<sceneUboDeclaration>
+uniform reflectionMatrix: mat4x4f;uniform vReflectionInfos: vec2f;uniform vReflectionDominantDirection: vec3f;
+#include<pbrBRDFFunctions>
+#include<openpbrDielectricReflectance>
+#include<pbrIBLFunctions>
+#include<reflectionFunction>
+#include<openpbrGeometryInfo>
+#include<openpbrIblFunctions>
+#elif defined(USESPHERICALFROMREFLECTIONMAP)
+varying vEnvironmentIrradiance: vec3f;
+#endif
+#ifdef IBL_SHADOW_TEXTURE
+var iblShadowSampler: texture_2d<f32>;var iblShadowSamplerSampler: sampler;uniform shadowTextureSize: vec2f;
+#endif
+#ifdef IRRADIANCE_SCATTER_MASK
+uniform vSubsurfaceWeight: f32;
+#include<samplerFragmentDeclaration>(_DEFINENAME_,SUBSURFACE_WEIGHT,_VARYINGNAME_,SubsurfaceWeight,_SAMPLERNAME_,subsurfaceWeight)
+uniform vSubsurfaceScatterAnisotropy: f32;uniform vTransmissionWeight: f32;
+#include<samplerFragmentDeclaration>(_DEFINENAME_,TRANSMISSION_WEIGHT,_VARYINGNAME_,TransmissionWeight,_SAMPLERNAME_,transmissionWeight)
+uniform vTransmissionScatterAnisotropy: f32;
+#endif
+#endif
+#endif
+@fragment
+fn main(input: FragmentInputs)->FragmentOutputs {
+#include<clipPlaneFragment>
+#ifdef ALPHATEST
+if (textureSample(diffuseSampler,diffuseSamplerSampler,input.vUV).a<0.4) {discard;}
+#endif
+var normalOutput: vec3f;
+#ifdef BUMP
+var normalW: vec3f=normalize(input.vNormalW);
+#include<bumpFragment>
+#ifdef NORMAL_WORLDSPACE
+normalOutput=normalW;
+#else
+normalOutput=normalize( (mat4x4f(input.vWorldView0,input.vWorldView1,input.vWorldView2,input.vWorldView3)* vec4f(normalW,0.0)).xyz);
+#endif
+#elif defined(HAS_NORMAL_ATTRIBUTE)
+normalOutput=normalize(input.vNormalV);
+#elif defined(POSITION)
+normalOutput=normalize(-cross(dpdx(input.vPositionW),dpdy(input.vPositionW)));
+#endif
+#ifdef ENCODE_NORMAL
+normalOutput=normalOutput*0.5+0.5;
+#endif
+var fragData: array<vec4<f32>,SCENE_MRT_COUNT>;
+#ifdef DEPTH
+fragData[DEPTH_INDEX]=vec4f(input.vViewPos.z/input.vViewPos.w,0.0,0.0,1.0);
+#endif
+#ifdef NORMAL
+fragData[NORMAL_INDEX]=vec4f(normalOutput,1.0);
+#endif
+#ifdef SCREENSPACE_DEPTH
+fragData[SCREENSPACE_DEPTH_INDEX]=vec4f(fragmentInputs.position.z,0.0,0.0,1.0);
+#endif
+#ifdef POSITION
+fragData[POSITION_INDEX]= vec4f(input.vPositionW,1.0);
+#endif
+#ifdef VELOCITY
+var a: vec2f=(input.vCurrentPosition.xy/input.vCurrentPosition.w)*0.5+0.5;var b: vec2f=(input.vPreviousPosition.xy/input.vPreviousPosition.w)*0.5+0.5;var velocity: vec2f=abs(a-b);velocity= vec2f(pow(velocity.x,1.0/3.0),pow(velocity.y,1.0/3.0))*sign(a-b)*0.5+0.5;fragData[VELOCITY_INDEX]= vec4f(velocity,0.0,1.0);
+#endif
+#ifdef VELOCITY_LINEAR
+var velocity : vec2f=vec2f(0.5)*((input.vPreviousPosition.xy /
+input.vPreviousPosition.w) -
+(input.vCurrentPosition.xy /
+input.vCurrentPosition.w));fragData[VELOCITY_LINEAR_INDEX]=vec4f(velocity,0.0,1.0);
+#endif
+#ifdef REFLECTIVITY
+var reflectivity: vec4f= vec4f(0.0,0.0,0.0,1.0);
+#ifdef METALLICWORKFLOW
+var metal: f32=1.0;var roughness: f32=1.0;
+#ifdef ORMTEXTURE
+metal*=textureSample(reflectivitySampler,reflectivitySamplerSampler,input.vReflectivityUV).b;roughness*=textureSample(reflectivitySampler,reflectivitySamplerSampler,input.vReflectivityUV).g;
+#else
+#ifdef METALLIC_TEXTURE
+metal*=textureSample(metallicSampler,metallicSamplerSampler,input.vMetallicUV).r;
+#endif
+#ifdef ROUGHNESS_TEXTURE
+roughness*=textureSample(roughnessSampler,roughnessSamplerSampler,input.vRoughnessUV).r;
+#endif
+#endif
+#ifdef METALLIC
+metal*=uniforms.metallic;
+#endif
+#ifdef ROUGHNESS
+roughness*=(1.0-uniforms.glossiness); 
+#endif
+reflectivity=vec4f(reflectivity.rgb,reflectivity.a-roughness);var color: vec3f= vec3f(1.0);
+#ifdef ALBEDOTEXTURE
+color=textureSample(albedoSampler,albedoSamplerSampler,input.vAlbedoUV).rgb;
+#ifdef GAMMAALBEDO
+color=toLinearSpaceVec4(color);
+#endif
+#endif
+#ifdef ALBEDOCOLOR
+color*=uniforms.albedoColor.xyz;
+#endif
+reflectivity=vec4f(mix( vec3f(0.04),color,metal),reflectivity.a);
+#else
+#if defined(SPECULARGLOSSINESSTEXTURE) || defined(REFLECTIVITYTEXTURE)
+reflectivity=textureSample(reflectivitySampler,reflectivitySamplerSampler,input.vReflectivityUV);
+#ifdef GAMMAREFLECTIVITYTEXTURE
+reflectivity=vec4f(toLinearSpaceVec3(reflectivity.rgb),reflectivity.a);
+#endif
+#else 
+#ifdef REFLECTIVITYCOLOR
+reflectivity=vec4f(toLinearSpaceVec3(uniforms.reflectivityColor.xyz),1.0);
+#endif
+#endif
+#ifdef GLOSSINESSS
+reflectivity=vec4f(reflectivity.rgb,reflectivity.a*glossiness); 
+#endif
+#endif
+fragData[REFLECTIVITY_INDEX]=reflectivity;
+#endif
+#ifdef IRRADIANCE
+var irradiance: vec3f=vec3f(0.0);var irradiance_alpha: f32=1.0;
+#ifdef REFLECTION
+#ifdef IRRADIANCE_SCATTER_MASK
+#ifndef BUMP
+let uvOffset: vec2f=vec2f(0.0);
+#endif
+var vSubsurfaceColor: vec3f=vec3f(1.0);var vSubsurfaceRadius: f32=0.0;var vSubsurfaceRadiusScale: vec3f=vec3f(1.0);
+#include<openpbrSubsurfaceLayerData>(uniforms.vSubsurfaceColor,vSubsurfaceColor,uniforms.vSubsurfaceRadius,vSubsurfaceRadius,uniforms.vSubsurfaceRadiusScale,vSubsurfaceRadiusScale)
+var vTransmissionDepth: f32=1.0;var vTransmissionColor: vec3f=vec3f(1.0);var vTransmissionScatter: vec3f=vec3f(0.0);var vTransmissionDispersionScale: f32=0.0;var vTransmissionDispersionAbbeNumber: f32=0.0;
+#include<openpbrTransmissionLayerData>(uniforms.vTransmissionDispersionScale,vTransmissionDispersionScale,uniforms.vTransmissionDispersionAbbeNumber,vTransmissionDispersionAbbeNumber,uniforms.vTransmissionColor,vTransmissionColor,uniforms.vTransmissionDepth,vTransmissionDepth,uniforms.vTransmissionScatter\\.,vTransmissionScatter.)
+#endif
+#ifdef IBL_SHADOW_TEXTURE
+#ifdef COLORED_IBL_SHADOWS
+let iblShadowValue: vec3f=textureSample(iblShadowSampler,iblShadowSamplerSampler,fragmentInputs.position.xy/uniforms.shadowTextureSize).rgb;
+#else
+let iblShadowValue: vec3f=vec3f(textureSample(iblShadowSampler,iblShadowSamplerSampler,fragmentInputs.position.xy/uniforms.shadowTextureSize).r);
+#endif
+#endif
+#if defined(USEIRRADIANCEMAP)
+#ifdef IRRADIANCE_SCATTER_MASK
+let bendAmount: f32=subsurface_weight*-min(subsurface_scatter_anisotropy,0.0);let mixedBendAmount: f32=mix(bendAmount,-min(transmission_scatter_anisotropy,0.0),transmission_weight);let viewVector: vec3f=normalize(scene.vEyePosition.xyz-input.vPositionW);let bentNormal: vec3f=mix(normalOutput,viewVector,mixedBendAmount*dot(normalOutput,viewVector));
+#else
+let bentNormal: vec3f=normalOutput;
+#endif
+irradiance=sampleIrradiance(
+bentNormal
+#if defined(NORMAL) && defined(USESPHERICALINVERTEX)
+,input.vEnvironmentIrradiance
+#endif
+#if (defined(USESPHERICALFROMREFLECTIONMAP) && (!defined(NORMAL) || !defined(USESPHERICALINVERTEX))) || (defined(USEIRRADIANCEMAP) && defined(REFLECTIONMAP_3D))
+,uniforms.reflectionMatrix
+#endif
+#ifdef USEIRRADIANCEMAP
+,irradianceSampler
+,irradianceSamplerSampler
+#ifdef USE_IRRADIANCE_DOMINANT_DIRECTION
+,uniforms.vReflectionDominantDirection
+#endif
+#endif
+#ifdef REALTIME_FILTERING
+,uniforms.vReflectionFilteringInfo
+#ifdef IBL_CDF_FILTERING
+,icdfSampler
+,icdfSamplerSampler
+#endif
+#endif
+,uniforms.vReflectionInfos
+,input.vViewPos.xyz
+,1.0
+,vec3f(1.0)
+);
+#elif defined(USESPHERICALFROMREFLECTIONMAP)
+irradiance=input.vEnvironmentIrradiance;
+#endif
+#ifdef IBL_SHADOW_TEXTURE
+irradiance*=iblShadowValue;
+#endif
+#ifdef IRRADIANCE_SCATTER_MASK
+irradiance_alpha=min(subsurface_weight+transmission_weight,1.0);
+#endif
+#endif
+fragData[IRRADIANCE_INDEX]=vec4f(irradiance,irradiance_alpha);
+#endif
+#if SCENE_MRT_COUNT>0
+fragmentOutputs.fragData0=fragData[0];
+#endif
+#if SCENE_MRT_COUNT>1
+fragmentOutputs.fragData1=fragData[1];
+#endif
+#if SCENE_MRT_COUNT>2
+fragmentOutputs.fragData2=fragData[2];
+#endif
+#if SCENE_MRT_COUNT>3
+fragmentOutputs.fragData3=fragData[3];
+#endif
+#if SCENE_MRT_COUNT>4
+fragmentOutputs.fragData4=fragData[4];
+#endif
+#if SCENE_MRT_COUNT>5
+fragmentOutputs.fragData5=fragData[5];
+#endif
+#if SCENE_MRT_COUNT>6
+fragmentOutputs.fragData6=fragData[6];
+#endif
+#if SCENE_MRT_COUNT>7
+fragmentOutputs.fragData7=fragData[7];
+#endif
+}
+`;
+i.ShadersStoreWGSL[e] || (i.ShadersStoreWGSL[e] = r);
+const v = { name: e, shader: r };
+export {
+  v as geometryPixelShaderWGSL
+};

package/dist/geometry.vertex-DskQ5b8j.js

@@ -0,0 +1,222 @@
+import { b0 as i } from "./index-CS3Icp_r.js";
+import "./clipPlaneVertex-D4Wk50XG.js";
+import "./sceneUboDeclaration-JByfVKik.js";
+import "./harmonicsFunctions-PEz6APC7.js";
+import "./bumpVertex-BcdvVFVx.js";
+const e = "geometryVertexShader", r = `#include<bonesDeclaration>
+#include<bakedVertexAnimationDeclaration>
+#include<morphTargetsVertexGlobalDeclaration>
+#include<morphTargetsVertexDeclaration>[0..maxSimultaneousMorphTargets]
+#include<instancesDeclaration>
+#include<sceneUboDeclaration>
+#include<clipPlaneVertexDeclaration>
+#ifdef IRRADIANCE
+#ifdef REFLECTION
+uniform reflectionMatrix: mat4x4f;uniform vReflectionInfos: vec2f;uniform vReflectionColor: vec3f;
+#ifdef USESPHERICALFROMREFLECTIONMAP
+varying vEnvironmentIrradiance: vec3f;
+#ifdef SPHERICAL_HARMONICS
+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;
+#else
+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;
+#endif
+#include<harmonicsFunctions>
+#endif
+#endif
+#endif
+attribute position : vec3<f32>;
+#ifdef HAS_NORMAL_ATTRIBUTE
+attribute normal: vec3f;
+#endif
+#ifdef NEED_UV
+varying vUV: vec2f;
+#ifdef ALPHATEST
+uniform diffuseMatrix: mat4x4f;
+#endif
+#ifdef BUMP
+uniform bumpMatrix: mat4x4f;varying vBumpUV: vec2f;
+#endif
+#ifdef REFLECTIVITY
+uniform reflectivityMatrix: mat4x4f;uniform albedoMatrix: mat4x4f;varying vReflectivityUV: vec2f;varying vAlbedoUV: vec2f;
+#endif
+#ifdef METALLIC_TEXTURE
+varying vMetallicUV: vec2f;uniform metallicMatrix: mat4x4f;
+#endif
+#ifdef ROUGHNESS_TEXTURE
+varying vRoughnessUV: vec2f;uniform roughnessMatrix: mat4x4f;
+#endif
+#ifdef SUBSURFACE_WEIGHT
+varying vSubsurfaceWeightUV: vec2f;uniform subsurfaceWeightMatrix: mat4x4f;
+#endif
+#ifdef TRANSMISSION_WEIGHT
+varying vTransmissionWeightUV: vec2f;uniform transmissionWeightMatrix: mat4x4f;
+#endif
+#ifdef UV1
+attribute uv: vec2f;
+#endif
+#ifdef UV2
+attribute uv2: vec2f;
+#endif
+#endif
+#ifdef BUMP
+varying vWorldView0: vec4f;varying vWorldView1: vec4f;varying vWorldView2: vec4f;varying vWorldView3: vec4f;
+#endif
+#ifdef BUMP
+varying vNormalW: vec3f;
+#else
+varying vNormalV: vec3f;
+#endif
+varying vViewPos: vec4f;
+#if defined(POSITION) || defined(BUMP) || defined(IRRADIANCE)
+varying vPositionW: vec3f;
+#endif
+#if defined(VELOCITY) || defined(VELOCITY_LINEAR)
+uniform previousViewProjection: mat4x4f;varying vCurrentPosition: vec4f;varying vPreviousPosition: vec4f;
+#endif
+#define CUSTOM_VERTEX_DEFINITIONS
+@vertex
+fn main(input : VertexInputs)->FragmentInputs {var positionUpdated: vec3f=vertexInputs.position;
+#ifdef HAS_NORMAL_ATTRIBUTE
+var normalUpdated: vec3f=vertexInputs.normal;
+#else
+var normalUpdated: vec3f=vec3f(0.0,0.0,0.0);
+#endif
+#ifdef UV1
+var uvUpdated: vec2f=vertexInputs.uv;
+#endif
+#ifdef UV2
+var uv2Updated: vec2f=vertexInputs.uv2;
+#endif
+#include<morphTargetsVertexGlobal>
+#include<morphTargetsVertex>[0..maxSimultaneousMorphTargets]
+#include<instancesVertex>
+#if (defined(VELOCITY) || defined(VELOCITY_LINEAR)) && !defined(BONES_VELOCITY_ENABLED)
+vCurrentPosition=scene.viewProjection*finalWorld*vec4f(positionUpdated,1.0);vPreviousPosition=uniforms.previousViewProjection*finalPreviousWorld* vec4f(positionUpdated,1.0);
+#endif
+#include<bonesVertex>
+#include<bakedVertexAnimation>
+var worldPos: vec4f= vec4f(finalWorld* vec4f(positionUpdated,1.0));
+#ifdef BUMP
+let vWorldView=scene.view*finalWorld;vertexOutputs.vWorldView0=vWorldView[0];vertexOutputs.vWorldView1=vWorldView[1];vertexOutputs.vWorldView2=vWorldView[2];vertexOutputs.vWorldView3=vWorldView[3];let normalWorld: mat3x3f= mat3x3f(finalWorld[0].xyz,finalWorld[1].xyz,finalWorld[2].xyz);vertexOutputs.vNormalW=normalize(normalWorld*normalUpdated);
+#else
+#ifdef NORMAL_WORLDSPACE
+vertexOutputs.vNormalV=normalize((finalWorld* vec4f(normalUpdated,0.0)).xyz);
+#else
+vertexOutputs.vNormalV=normalize(((scene.view*finalWorld)* vec4f(normalUpdated,0.0)).xyz);
+#endif
+#endif
+vertexOutputs.vViewPos=scene.view*worldPos;
+#if (defined(VELOCITY) || defined(VELOCITY_LINEAR)) && defined(BONES_VELOCITY_ENABLED)
+vertexOutputs.vCurrentPosition=scene.viewProjection*finalWorld* vec4f(positionUpdated,1.0);
+#if NUM_BONE_INFLUENCERS>0
+var previousInfluence: mat4x4f;previousInfluence=uniforms.mPreviousBones[ i32(vertexInputs.matricesIndices[0])]*vertexInputs.matricesWeights[0];
+#if NUM_BONE_INFLUENCERS>1
+previousInfluence+=uniforms.mPreviousBones[ i32(vertexInputs.matricesIndices[1])]*vertexInputs.matricesWeights[1];
+#endif
+#if NUM_BONE_INFLUENCERS>2
+previousInfluence+=uniforms.mPreviousBones[ i32(vertexInputs.matricesIndices[2])]*vertexInputs.matricesWeights[2];
+#endif
+#if NUM_BONE_INFLUENCERS>3
+previousInfluence+=uniforms.mPreviousBones[ i32(vertexInputs.matricesIndices[3])]*vertexInputs.matricesWeights[3];
+#endif
+#if NUM_BONE_INFLUENCERS>4
+previousInfluence+=uniforms.mPreviousBones[ i32(vertexInputs.matricesIndicesExtra[0])]*vertexInputs.matricesWeightsExtra[0];
+#endif
+#if NUM_BONE_INFLUENCERS>5
+previousInfluence+=uniforms.mPreviousBones[ i32(vertexInputs.matricesIndicesExtra[1])]*vertexInputs.matricesWeightsExtra[1];
+#endif
+#if NUM_BONE_INFLUENCERS>6
+previousInfluence+=uniforms.mPreviousBones[ i32(vertexInputs.matricesIndicesExtra[2])]*vertexInputs.matricesWeightsExtra[2];
+#endif
+#if NUM_BONE_INFLUENCERS>7
+previousInfluence+=uniforms.mPreviousBones[ i32(vertexInputs.matricesIndicesExtra[3])]*vertexInputs.matricesWeightsExtra[3];
+#endif
+vertexOutputs.vPreviousPosition=uniforms.previousViewProjection*finalPreviousWorld*previousInfluence* vec4f(positionUpdated,1.0);
+#else
+vertexOutputs.vPreviousPosition=uniforms.previousViewProjection*finalPreviousWorld* vec4f(positionUpdated,1.0);
+#endif
+#endif
+#if defined(POSITION) || defined(BUMP) || defined(IRRADIANCE)
+vertexOutputs.vPositionW=worldPos.xyz/worldPos.w;
+#endif
+vertexOutputs.position=scene.viewProjection*finalWorld* vec4f(positionUpdated,1.0);
+#include<clipPlaneVertex>
+#ifdef NEED_UV
+#ifdef UV1
+#if defined(ALPHATEST) && defined(ALPHATEST_UV1)
+vertexOutputs.vUV=(uniforms.diffuseMatrix* vec4f(uvUpdated,1.0,0.0)).xy;
+#else
+vertexOutputs.vUV=uvUpdated;
+#endif
+#ifdef BUMP_UV1
+vertexOutputs.vBumpUV=(uniforms.bumpMatrix* vec4f(uvUpdated,1.0,0.0)).xy;
+#endif
+#ifdef REFLECTIVITY_UV1
+vertexOutputs.vReflectivityUV=(uniforms.reflectivityMatrix* vec4f(uvUpdated,1.0,0.0)).xy;
+#else
+#ifdef METALLIC_UV1
+vertexOutputs.vMetallicUV=(uniforms.metallicMatrix* vec4f(uvUpdated,1.0,0.0)).xy;
+#endif
+#ifdef ROUGHNESS_UV1
+vertexOutputs.vRoughnessUV=(uniforms.roughnessMatrix* vec4f(uvUpdated,1.0,0.0)).xy;
+#endif
+#endif
+#ifdef ALBEDO_UV1
+vertexOutputs.vAlbedoUV=(uniforms.albedoMatrix* vec4f(uvUpdated,1.0,0.0)).xy;
+#endif
+#ifdef SUBSURFACE_WEIGHT_UV1
+vertexOutputs.vSubsurfaceWeightUV=(uniforms.subsurfaceWeightMatrix* vec4f(uvUpdated,1.0,0.0)).xy;
+#endif
+#ifdef TRANSMISSION_WEIGHT_UV1
+vertexOutputs.vTransmissionWeightUV=(uniforms.transmissionWeightMatrix* vec4f(uvUpdated,1.0,0.0)).xy;
+#endif
+#endif
+#ifdef UV2
+#if defined(ALPHATEST) && defined(ALPHATEST_UV2)
+vertexOutputs.vUV=(uniforms.diffuseMatrix* vec4f(uv2Updated,1.0,0.0)).xy;
+#else
+vertexOutputs.vUV=uv2Updated;
+#endif
+#ifdef BUMP_UV2
+vertexOutputs.vBumpUV=(uniforms.bumpMatrix* vec4f(uv2Updated,1.0,0.0)).xy;
+#endif
+#ifdef REFLECTIVITY_UV2
+vertexOutputs.vReflectivityUV=(uniforms.reflectivityMatrix* vec4f(uv2Updated,1.0,0.0)).xy;
+#else
+#ifdef METALLIC_UV2
+vertexOutputs.vMetallicUV=(uniforms.metallicMatrix* vec4f(uv2Updated,1.0,0.0)).xy;
+#endif
+#ifdef ROUGHNESS_UV2
+vertexOutputs.vRoughnessUV=(uniforms.roughnessMatrix* vec4f(uv2Updated,1.0,0.0)).xy;
+#endif
+#endif
+#ifdef ALBEDO_UV2
+vertexOutputs.vAlbedoUV=(uniforms.albedoMatrix* vec4f(uv2Updated,1.0,0.0)).xy;
+#endif
+#ifdef SUBSURFACE_WEIGHT_UV2
+vertexOutputs.vSubsurfaceWeightUV=(uniforms.subsurfaceWeightMatrix* vec4f(uv2Updated,1.0,0.0)).xy;
+#endif
+#ifdef TRANSMISSION_WEIGHT_UV2
+vertexOutputs.vTransmissionWeightUV=(uniforms.transmissionWeightMatrix* vec4f(uv2Updated,1.0,0.0)).xy;
+#endif
+#endif
+#endif
+#include<bumpVertex>
+#ifdef IRRADIANCE
+#ifdef REFLECTION
+#ifdef USESPHERICALFROMREFLECTIONMAP
+var reflectionVector: vec3f=(uniforms.reflectionMatrix*vec4f(normalUpdated,0.0)).xyz;
+#ifdef REFLECTIONMAP_OPPOSITEZ
+reflectionVector.z*=-1.0f;
+#endif
+vertexOutputs.vEnvironmentIrradiance=computeEnvironmentIrradiance(reflectionVector)*uniforms.vReflectionInfos.x;
+#endif
+#endif
+#endif
+}
+`;
+i.ShadersStoreWGSL[e] || (i.ShadersStoreWGSL[e] = r);
+const d = { name: e, shader: r };
+export {
+  d as geometryVertexShaderWGSL
+};

package/dist/harmonicsFunctions-CtNrRfir.js

@@ -0,0 +1,193 @@
+import { b0 as e } from "./index-CS3Icp_r.js";
+const t = "pbrBRDFFunctions", a = `#define FRESNEL_MAXIMUM_ON_ROUGH 0.25
+#define BRDF_DIFFUSE_MODEL_EON 0
+#define BRDF_DIFFUSE_MODEL_BURLEY 1
+#define BRDF_DIFFUSE_MODEL_LAMBERT 2
+#define BRDF_DIFFUSE_MODEL_LEGACY 3
+#define DIELECTRIC_SPECULAR_MODEL_GLTF 0
+#define DIELECTRIC_SPECULAR_MODEL_OPENPBR 1
+#define CONDUCTOR_SPECULAR_MODEL_GLTF 0
+#define CONDUCTOR_SPECULAR_MODEL_OPENPBR 1
+#if !defined(PBR_VERTEX_SHADER) && !defined(OPENPBR_VERTEX_SHADER)
+#ifdef MS_BRDF_ENERGY_CONSERVATION
+vec3 getEnergyConservationFactor(const vec3 specularEnvironmentR0,const vec3 environmentBrdf) {return 1.0+specularEnvironmentR0*(1.0/environmentBrdf.y-1.0);}
+#endif
+#if CONDUCTOR_SPECULAR_MODEL==CONDUCTOR_SPECULAR_MODEL_OPENPBR
+#define F82_COS_THETA_MAX 0.142857143
+#define F82_ONE_MINUS_CTM_POW5 0.462664366 
+#define F82_ONE_MINUS_CTM_POW6 0.396569457 
+#define F82_B_DENOMINATOR_RECIP 17.6512785 
+#define BRDF_Z_SCALE 16.0
+vec3 getF82Specular(float NdotV,vec3 F0,vec3 edgeTint,float roughness) {vec3 white_minus_F0=vec3(1.0)-F0;vec3 b=(F0+white_minus_F0*F82_ONE_MINUS_CTM_POW5)*(vec3(1.0)-edgeTint)*F82_B_DENOMINATOR_RECIP;float cos_theta=max(roughness,NdotV);float one_minus_cos_theta=1.0-cos_theta;vec3 offset_from_F0=(white_minus_F0-b*cos_theta*one_minus_cos_theta)*pow(one_minus_cos_theta,5.0);return clamp(F0+offset_from_F0,0.0,1.0);}
+vec3 getF82B(vec3 F0,vec3 edgeTint) {return (F0+(vec3(1.0)-F0)*F82_ONE_MINUS_CTM_POW5)*(vec3(1.0)-edgeTint)*F82_B_DENOMINATOR_RECIP;}
+vec3 getF82DirectionalAlbedo(vec3 F0,vec3 F90,vec3 b,vec3 environmentBrdf) {return (F90-F0)*environmentBrdf.x+F0*environmentBrdf.y-b*environmentBrdf.z;}
+vec3 getF82AverageFresnel(vec3 F0,vec3 b) {return F0+(vec3(1.0)-F0)/21.0-b/126.0;}
+#endif
+#ifdef FUZZENVIRONMENTBRDF
+vec3 getFuzzBRDFLookup(float NdotV,float perceptualRoughness) {vec2 UV=vec2(perceptualRoughness,NdotV);vec4 brdfLookup=texture2D(environmentFuzzBrdfSampler,UV);const vec2 RiRange=vec2(0.0,0.75);const vec2 ARange =vec2(0.005,0.88);const vec2 BRange =vec2(-0.18,0.002);brdfLookup.r=mix(ARange.x, ARange.y, brdfLookup.r);brdfLookup.g=mix(BRange.x, BRange.y, brdfLookup.g);brdfLookup.b=mix(RiRange.x,RiRange.y,brdfLookup.b);return brdfLookup.rgb;}
+#endif
+#ifdef ENVIRONMENTBRDF
+vec3 getBRDFLookup(float NdotV,float perceptualRoughness) {vec2 UV=vec2(NdotV,perceptualRoughness);vec4 brdfLookup=texture2D(environmentBrdfSampler,UV);
+#ifdef ENVIRONMENTBRDF_RGBD
+brdfLookup.rgb=fromRGBD(brdfLookup.rgba);
+#endif
+return brdfLookup.rgb;}
+vec3 getReflectanceFromBRDFLookup(const vec3 specularEnvironmentR0,const vec3 specularEnvironmentR90,const vec3 environmentBrdf) {
+#ifdef BRDF_V_HEIGHT_CORRELATED
+vec3 reflectance=(specularEnvironmentR90-specularEnvironmentR0)*environmentBrdf.x+specularEnvironmentR0*environmentBrdf.y;
+#else
+vec3 reflectance=specularEnvironmentR0*environmentBrdf.x+specularEnvironmentR90*environmentBrdf.y;
+#endif
+return reflectance;}
+vec3 getReflectanceFromBRDFLookup(const vec3 specularEnvironmentR0,const vec3 environmentBrdf) {
+#ifdef BRDF_V_HEIGHT_CORRELATED
+vec3 reflectance=mix(environmentBrdf.xxx,environmentBrdf.yyy,specularEnvironmentR0);
+#else
+vec3 reflectance=specularEnvironmentR0*environmentBrdf.x+environmentBrdf.y;
+#endif
+return reflectance;}
+#endif
+/* NOT USED
+#if defined(SHEEN) && defined(SHEEN_SOFTER)
+float getBRDFLookupCharlieSheen(float NdotV,float perceptualRoughness)
+{float c=1.0-NdotV;float c3=c*c*c;return 0.65584461*c3+1.0/(4.16526551+exp(-7.97291361*perceptualRoughness+6.33516894));}
+#endif
+*/
+#if !defined(ENVIRONMENTBRDF) || defined(REFLECTIONMAP_SKYBOX) || defined(ALPHAFRESNEL)
+vec3 getReflectanceFromAnalyticalBRDFLookup_Jones(float VdotN,vec3 reflectance0,vec3 reflectance90,float smoothness)
+{float weight=mix(FRESNEL_MAXIMUM_ON_ROUGH,1.0,smoothness);return reflectance0+weight*(reflectance90-reflectance0)*pow5(saturate(1.0-VdotN));}
+#endif
+#if defined(SHEEN) && defined(ENVIRONMENTBRDF)
+/**
+* The sheen BRDF not containing F can be easily stored in the blue channel of the BRDF texture.
+* The blue channel contains DCharlie*VAshikhmin*NdotL as a lokkup table
+*/
+vec3 getSheenReflectanceFromBRDFLookup(const vec3 reflectance0,const vec3 environmentBrdf) {vec3 sheenEnvironmentReflectance=reflectance0*environmentBrdf.b;return sheenEnvironmentReflectance;}
+#endif
+vec3 fresnelSchlickGGX(float VdotH,vec3 reflectance0,vec3 reflectance90)
+{return reflectance0+(reflectance90-reflectance0)*pow5(1.0-VdotH);}
+float fresnelSchlickGGX(float VdotH,float reflectance0,float reflectance90)
+{return reflectance0+(reflectance90-reflectance0)*pow5(1.0-VdotH);}
+#ifdef CLEARCOAT
+vec3 getR0RemappedForClearCoat(vec3 f0) {
+#ifdef CLEARCOAT_DEFAULTIOR
+#ifdef MOBILE
+return saturate(f0*(f0*0.526868+0.529324)-0.0482256);
+#else
+return saturate(f0*(f0*(0.941892-0.263008*f0)+0.346479)-0.0285998);
+#endif
+#else
+vec3 s=sqrt(f0);vec3 t=(vClearCoatRefractionParams.z+vClearCoatRefractionParams.w*s)/(vClearCoatRefractionParams.w+vClearCoatRefractionParams.z*s);return square(t);
+#endif
+}
+#endif
+#ifdef IRIDESCENCE
+const mat3 XYZ_TO_REC709=mat3(
+3.2404542,-0.9692660, 0.0556434,
+-1.5371385, 1.8760108,-0.2040259,
+-0.4985314, 0.0415560, 1.0572252
+);vec3 getIORTfromAirToSurfaceR0(vec3 f0) {vec3 sqrtF0=sqrt(f0);return (1.+sqrtF0)/(1.-sqrtF0);}
+vec3 getR0fromIORs(vec3 iorT,float iorI) {return square((iorT-vec3(iorI))/(iorT+vec3(iorI)));}
+float getR0fromIORs(float iorT,float iorI) {return square((iorT-iorI)/(iorT+iorI));}
+vec3 evalSensitivity(float opd,vec3 shift) {float phase=2.0*PI*opd*1.0e-9;const vec3 val=vec3(5.4856e-13,4.4201e-13,5.2481e-13);const vec3 pos=vec3(1.6810e+06,1.7953e+06,2.2084e+06);const vec3 var=vec3(4.3278e+09,9.3046e+09,6.6121e+09);vec3 xyz=val*sqrt(2.0*PI*var)*cos(pos*phase+shift)*exp(-square(phase)*var);xyz.x+=9.7470e-14*sqrt(2.0*PI*4.5282e+09)*cos(2.2399e+06*phase+shift[0])*exp(-4.5282e+09*square(phase));xyz/=1.0685e-7;vec3 srgb=XYZ_TO_REC709*xyz;return srgb;}
+vec3 evalIridescence(float outsideIOR,float eta2,float cosTheta1,float thinFilmThickness,vec3 baseF0) {vec3 I=vec3(1.0);float iridescenceIOR=mix(outsideIOR,eta2,smoothstep(0.0,0.03,thinFilmThickness));float sinTheta2Sq=square(outsideIOR/iridescenceIOR)*(1.0-square(cosTheta1));float cosTheta2Sq=1.0-sinTheta2Sq;if (cosTheta2Sq<0.0) {return I;}
+float cosTheta2=sqrt(cosTheta2Sq);float R0=getR0fromIORs(iridescenceIOR,outsideIOR);float R12=fresnelSchlickGGX(cosTheta1,R0,1.);float R21=R12;float T121=1.0-R12;float phi12=0.0;if (iridescenceIOR<outsideIOR) phi12=PI;float phi21=PI-phi12;vec3 baseIOR=getIORTfromAirToSurfaceR0(clamp(baseF0,0.0,0.9999)); 
+vec3 R1=getR0fromIORs(baseIOR,iridescenceIOR);float maxR1=max(R1.r,max(R1.g,R1.b));if (maxR1<1e-6) {return max(vec3(R12),vec3(0.0));}
+vec3 R23=fresnelSchlickGGX(cosTheta2,R1,vec3(1.));vec3 phi23=vec3(0.0);if (baseIOR[0]<iridescenceIOR) phi23[0]=PI;if (baseIOR[1]<iridescenceIOR) phi23[1]=PI;if (baseIOR[2]<iridescenceIOR) phi23[2]=PI;float opd=2.0*iridescenceIOR*thinFilmThickness*cosTheta2;vec3 phi=vec3(phi21)+phi23;vec3 R123=clamp(R12*R23,1e-5,0.9999);vec3 r123=sqrt(R123);vec3 Rs=square(T121)*R23/(vec3(1.0)-R123);vec3 C0=R12+Rs;I=C0;vec3 Cm=Rs-T121;for (int m=1; m<=2; ++m)
+{Cm*=r123;vec3 Sm=2.0*evalSensitivity(float(m)*opd,float(m)*phi);I+=Cm*Sm;}
+return max(I,vec3(0.0));}
+#endif
+float normalDistributionFunction_TrowbridgeReitzGGX(float NdotH,float alphaG)
+{float a2=square(alphaG);float d=NdotH*NdotH*(a2-1.0)+1.0;return a2/(PI*d*d);}
+#ifdef SHEEN
+float normalDistributionFunction_CharlieSheen(float NdotH,float alphaG)
+{float invR=1./alphaG;float cos2h=NdotH*NdotH;float sin2h=1.-cos2h;return (2.+invR)*pow(sin2h,invR*.5)/(2.*PI);}
+#endif
+#ifdef ANISOTROPIC
+float normalDistributionFunction_BurleyGGX_Anisotropic(float NdotH,float TdotH,float BdotH,const vec2 alphaTB) {float a2=alphaTB.x*alphaTB.y;vec3 v=vec3(alphaTB.y*TdotH,alphaTB.x *BdotH,a2*NdotH);float v2=dot(v,v);float w2=a2/v2;return a2*w2*w2*RECIPROCAL_PI;}
+#endif
+#ifdef BRDF_V_HEIGHT_CORRELATED
+float smithVisibility_GGXCorrelated(float NdotL,float NdotV,float alphaG) {
+#ifdef MOBILE
+float GGXV=NdotL*(NdotV*(1.0-alphaG)+alphaG);float GGXL=NdotV*(NdotL*(1.0-alphaG)+alphaG);return 0.5/(GGXV+GGXL);
+#else
+float a2=alphaG*alphaG;float GGXV=NdotL*sqrt(NdotV*(NdotV-a2*NdotV)+a2);float GGXL=NdotV*sqrt(NdotL*(NdotL-a2*NdotL)+a2);return 0.5/(GGXV+GGXL);
+#endif
+}
+#else
+float smithVisibilityG1_TrowbridgeReitzGGXFast(float dot,float alphaG)
+{
+#ifdef MOBILE
+return 1.0/(dot+alphaG+(1.0-alphaG)*dot ));
+#else
+float alphaSquared=alphaG*alphaG;return 1.0/(dot+sqrt(alphaSquared+(1.0-alphaSquared)*dot*dot));
+#endif
+}
+float smithVisibility_TrowbridgeReitzGGXFast(float NdotL,float NdotV,float alphaG)
+{float visibility=smithVisibilityG1_TrowbridgeReitzGGXFast(NdotL,alphaG)*smithVisibilityG1_TrowbridgeReitzGGXFast(NdotV,alphaG);return visibility;}
+#endif
+#ifdef ANISOTROPIC
+float smithVisibility_GGXCorrelated_Anisotropic(float NdotL,float NdotV,float TdotV,float BdotV,float TdotL,float BdotL,const vec2 alphaTB) {float lambdaV=NdotL*length(vec3(alphaTB.x*TdotV,alphaTB.y*BdotV,NdotV));float lambdaL=NdotV*length(vec3(alphaTB.x*TdotL,alphaTB.y*BdotL,NdotL));float v=0.5/(lambdaV+lambdaL);return v;}
+#endif
+#ifdef CLEARCOAT
+float visibility_Kelemen(float VdotH) {return 0.25/(VdotH*VdotH); }
+#endif
+#ifdef SHEEN
+float visibility_Ashikhmin(float NdotL,float NdotV)
+{return 1./(4.*(NdotL+NdotV-NdotL*NdotV));}
+/* NOT USED
+#ifdef SHEEN_SOFTER
+float l(float x,float alphaG)
+{float oneMinusAlphaSq=(1.0-alphaG)*(1.0-alphaG);float a=mix(21.5473,25.3245,oneMinusAlphaSq);float b=mix(3.82987,3.32435,oneMinusAlphaSq);float c=mix(0.19823,0.16801,oneMinusAlphaSq);float d=mix(-1.97760,-1.27393,oneMinusAlphaSq);float e=mix(-4.32054,-4.85967,oneMinusAlphaSq);return a/(1.0+b*pow(x,c))+d*x+e;}
+float lambdaSheen(float cosTheta,float alphaG)
+{return abs(cosTheta)<0.5 ? exp(l(cosTheta,alphaG)) : exp(2.0*l(0.5,alphaG)-l(1.0-cosTheta,alphaG));}
+float visibility_CharlieSheen(float NdotL,float NdotV,float alphaG)
+{float G=1.0/(1.0+lambdaSheen(NdotV,alphaG)+lambdaSheen(NdotL,alphaG));return G/(4.0*NdotV*NdotL);}
+#endif
+*/
+#endif
+float diffuseBRDF_Burley(float NdotL,float NdotV,float VdotH,float roughness) {float diffuseFresnelNV=pow5(saturateEps(1.0-NdotL));float diffuseFresnelNL=pow5(saturateEps(1.0-NdotV));float diffuseFresnel90=0.5+2.0*VdotH*VdotH*roughness;float fresnel =
+(1.0+(diffuseFresnel90-1.0)*diffuseFresnelNL) *
+(1.0+(diffuseFresnel90-1.0)*diffuseFresnelNV);return fresnel/PI;}
+const float constant1_FON=0.5-2.0/(3.0*PI);const float constant2_FON=2.0/3.0-28.0/(15.0*PI);float E_FON_approx(float mu,float roughness)
+{float sigma=roughness; 
+float mucomp=1.0-mu;float mucomp2=mucomp*mucomp;const mat2 Gcoeffs=mat2(0.0571085289,-0.332181442,
+0.491881867,0.0714429953);float GoverPi=dot(Gcoeffs*vec2(mucomp,mucomp2),vec2(1.0,mucomp2));return (1.0+sigma*GoverPi)/(1.0+constant1_FON*sigma);}
+vec3 diffuseBRDF_EON(vec3 albedo,float roughness,float NdotL,float NdotV,float LdotV)
+{vec3 rho=albedo;float sigma=roughness; 
+float mu_i=NdotL; 
+float mu_o=NdotV; 
+float s=LdotV-mu_i*mu_o; 
+float sovertF=s>0.0 ? s/max(mu_i,mu_o) : s; 
+float AF=1.0/(1.0+constant1_FON*sigma); 
+vec3 f_ss=(rho*RECIPROCAL_PI)*AF*(1.0+sigma*sovertF); 
+float EFo=E_FON_approx(mu_o,sigma); 
+float EFi=E_FON_approx(mu_i,sigma); 
+float avgEF=AF*(1.0+constant2_FON*sigma); 
+vec3 rho_ms=(rho*rho)*avgEF/(vec3(1.0)-rho*(1.0-avgEF));const float eps=1.0e-7;vec3 f_ms=(rho_ms*RECIPROCAL_PI)*max(eps,1.0-EFo) 
+* max(eps,1.0-EFi)
+/ max(eps,1.0-avgEF);return (f_ss+f_ms);}
+#ifdef SS_TRANSLUCENCY
+vec3 transmittanceBRDF_Burley(const vec3 tintColor,const vec3 diffusionDistance,float thickness) {vec3 S=1./maxEps(diffusionDistance);vec3 temp=exp((-0.333333333*thickness)*S);return tintColor.rgb*0.25*(temp*temp*temp+3.0*temp);}
+float computeWrappedDiffuseNdotL(float NdotL,float w) {float t=1.0+w;float invt2=1.0/square(t);return saturate((NdotL+w)*invt2);}
+#endif
+#endif 
+`;
+e.IncludesShadersStore[t] || (e.IncludesShadersStore[t] = a);
+const o = "harmonicsFunctions", n = `#ifdef USESPHERICALFROMREFLECTIONMAP
+#ifdef SPHERICAL_HARMONICS
+vec3 computeEnvironmentIrradiance(vec3 normal) {return vSphericalL00
++ vSphericalL1_1*(normal.y)
++ vSphericalL10*(normal.z)
++ vSphericalL11*(normal.x)
++ vSphericalL2_2*(normal.y*normal.x)
++ vSphericalL2_1*(normal.y*normal.z)
++ vSphericalL20*((3.0*normal.z*normal.z)-1.0)
++ vSphericalL21*(normal.z*normal.x)
++ vSphericalL22*(normal.x*normal.x-(normal.y*normal.y));}
+#else
+vec3 computeEnvironmentIrradiance(vec3 normal) {float Nx=normal.x;float Ny=normal.y;float Nz=normal.z;vec3 C1=vSphericalZZ.rgb;vec3 Cx=vSphericalX.rgb;vec3 Cy=vSphericalY.rgb;vec3 Cz=vSphericalZ.rgb;vec3 Cxx_zz=vSphericalXX_ZZ.rgb;vec3 Cyy_zz=vSphericalYY_ZZ.rgb;vec3 Cxy=vSphericalXY.rgb;vec3 Cyz=vSphericalYZ.rgb;vec3 Czx=vSphericalZX.rgb;vec3 a1=Cyy_zz*Ny+Cy;vec3 a2=Cyz*Nz+a1;vec3 b1=Czx*Nz+Cx;vec3 b2=Cxy*Ny+b1;vec3 b3=Cxx_zz*Nx+b2;vec3 t1=Cz *Nz+C1;vec3 t2=a2 *Ny+t1;vec3 t3=b3 *Nx+t2;return t3;}
+#endif
+#endif
+`;
+e.IncludesShadersStore[o] || (e.IncludesShadersStore[o] = n);