@fps-games/editor-deployment 0.2.3-beta.3

package/public/assets/default.vertex-DyPOsib0.js

@@ -0,0 +1,181 @@
+import{fp as e}from"./standardMaterial-CgDYhl-K.js";import"./defaultUboDeclaration-ChgZa3Dv.js";import"./bumpVertex-CzYtMFbI.js";import"./clipPlaneVertex-B8PIfZU_.js";import"./instancesDeclaration-DpE3Y0C1.js";import"./mainUVVaryingDeclaration-D1LMmumw.js";import"./vertexColorMixing-31u6kp3A.js";import"./morphTargetsVertex-DHRA_mKb.js";import"./logDepthDeclaration-_-FceU2g.js";import"./logDepthVertex-jWY57236.js";import"./meshUboDeclaration-B5FWJmqY.js";const t="lightVxFragmentDeclaration",r=`#ifdef LIGHT{X}
+uniform vLightData{X}: vec4f;uniform vLightDiffuse{X}: vec4f;
+#ifdef SPECULARTERM
+uniform vLightSpecular{X}: vec4f;
+#else
+var vLightSpecular{X}: vec4f= vec4f(0.);
+#endif
+#ifdef SHADOW{X}
+#ifdef SHADOWCSM{X}
+uniform lightMatrix{X}: mat4x4f[SHADOWCSMNUM_CASCADES{X}];varying var vPositionFromLight{X}: vec4f[SHADOWCSMNUM_CASCADES{X}];varying var vDepthMetric{X}: f32[SHADOWCSMNUM_CASCADES{X}];varying var vPositionFromCamera{X}: vec4f;
+#elif defined(SHADOWCUBE{X})
+#else
+varying var vPositionFromLight{X}: vec4f;varying var vDepthMetric{X}: f32;uniform lightMatrix{X}: mat4x4f;
+#endif
+uniform shadowsInfo{X}: vec4f;uniform depthValues{X}: vec2f;
+#endif
+#ifdef SPOTLIGHT{X}
+uniform vLightDirection{X}: vec4f;uniform vLightFalloff{X}: vec4f;
+#elif defined(POINTLIGHT{X})
+uniform vLightFalloff{X}: vec4f;
+#elif defined(HEMILIGHT{X})
+uniform vLightGround{X}: vec3f;
+#endif
+#if defined(AREALIGHT{X}) && defined(AREALIGHTUSED) && defined(AREALIGHTSUPPORTED)
+uniform vLightWidth{X}: vec4f;uniform vLightHeight{X}: vec4f;
+#endif
+#endif
+`;e.IncludesShadersStoreWGSL[t]||(e.IncludesShadersStoreWGSL[t]=r);const i="defaultVertexShader",n=`#include<defaultUboDeclaration>
+#define CUSTOM_VERTEX_BEGIN
+attribute position: vec3f;
+#ifdef NORMAL
+attribute normal: vec3f;
+#endif
+#ifdef TANGENT
+attribute tangent: vec4f;
+#endif
+#ifdef UV1
+attribute uv: vec2f;
+#endif
+#include<uvAttributeDeclaration>[2..7]
+#ifdef VERTEXCOLOR
+attribute color: vec4f;
+#endif
+#include<helperFunctions>
+#include<bonesDeclaration>
+#include<bakedVertexAnimationDeclaration>
+#include<instancesDeclaration>
+#include<prePassVertexDeclaration>
+#include<mainUVVaryingDeclaration>[1..7]
+#include<samplerVertexDeclaration>(_DEFINENAME_,DIFFUSE,_VARYINGNAME_,Diffuse)
+#include<samplerVertexDeclaration>(_DEFINENAME_,DETAIL,_VARYINGNAME_,Detail)
+#include<samplerVertexDeclaration>(_DEFINENAME_,AMBIENT,_VARYINGNAME_,Ambient)
+#include<samplerVertexDeclaration>(_DEFINENAME_,OPACITY,_VARYINGNAME_,Opacity)
+#include<samplerVertexDeclaration>(_DEFINENAME_,EMISSIVE,_VARYINGNAME_,Emissive)
+#include<samplerVertexDeclaration>(_DEFINENAME_,LIGHTMAP,_VARYINGNAME_,Lightmap)
+#if defined(SPECULARTERM)
+#include<samplerVertexDeclaration>(_DEFINENAME_,SPECULAR,_VARYINGNAME_,Specular)
+#endif
+#include<samplerVertexDeclaration>(_DEFINENAME_,BUMP,_VARYINGNAME_,Bump)
+#include<samplerVertexDeclaration>(_DEFINENAME_,DECAL,_VARYINGNAME_,Decal)
+varying vPositionW: vec3f;
+#ifdef NORMAL
+varying vNormalW: vec3f;
+#endif
+#if defined(VERTEXCOLOR) || defined(INSTANCESCOLOR) && defined(INSTANCES)
+varying vColor: vec4f;
+#endif
+#include<bumpVertexDeclaration>
+#include<clipPlaneVertexDeclaration>
+#include<fogVertexDeclaration>
+#include<__decl__lightVxFragment>[0..maxSimultaneousLights]
+#include<morphTargetsVertexGlobalDeclaration>
+#include<morphTargetsVertexDeclaration>[0..maxSimultaneousMorphTargets]
+#ifdef REFLECTIONMAP_SKYBOX
+varying vPositionUVW: vec3f;
+#endif
+#if defined(REFLECTIONMAP_EQUIRECTANGULAR_FIXED) || defined(REFLECTIONMAP_MIRROREDEQUIRECTANGULAR_FIXED)
+varying vDirectionW: vec3f;
+#endif
+#if defined(CLUSTLIGHT_BATCH) && CLUSTLIGHT_BATCH>0
+varying vViewDepth: f32;
+#endif
+#include<logDepthDeclaration>
+#define CUSTOM_VERTEX_DEFINITIONS
+@vertex
+fn main(input : VertexInputs)->FragmentInputs {
+#define CUSTOM_VERTEX_MAIN_BEGIN
+var positionUpdated: vec3f=vertexInputs.position;
+#ifdef NORMAL
+var normalUpdated: vec3f=vertexInputs.normal;
+#endif
+#ifdef TANGENT
+var tangentUpdated: vec4f=vertexInputs.tangent;
+#endif
+#ifdef UV1
+var uvUpdated: vec2f=vertexInputs.uv;
+#endif
+#ifdef UV2
+var uv2Updated: vec2f=vertexInputs.uv2;
+#endif
+#ifdef VERTEXCOLOR
+var colorUpdated: vec4f=vertexInputs.color;
+#endif
+#include<morphTargetsVertexGlobal>
+#include<morphTargetsVertex>[0..maxSimultaneousMorphTargets]
+#ifdef REFLECTIONMAP_SKYBOX
+vertexOutputs.vPositionUVW=positionUpdated;
+#endif
+#define CUSTOM_VERTEX_UPDATE_POSITION
+#define CUSTOM_VERTEX_UPDATE_NORMAL
+#include<instancesVertex>
+#if defined(PREPASS) && ((defined(PREPASS_VELOCITY) || defined(PREPASS_VELOCITY_LINEAR)) && !defined(BONES_VELOCITY_ENABLED)
+vertexOutputs.vCurrentPosition=scene.viewProjection*finalWorld*vec4f(positionUpdated,1.0);vertexOutputs.vPreviousPosition=uniforms.previousViewProjection*finalPreviousWorld*vec4f(positionUpdated,1.0);
+#endif
+#include<bonesVertex>
+#include<bakedVertexAnimation>
+var worldPos: vec4f=finalWorld*vec4f(positionUpdated,1.0);
+#ifdef NORMAL
+var normalWorld: mat3x3f= mat3x3f(finalWorld[0].xyz,finalWorld[1].xyz,finalWorld[2].xyz);
+#if defined(INSTANCES) && defined(THIN_INSTANCES)
+vertexOutputs.vNormalW=normalUpdated/ vec3f(dot(normalWorld[0],normalWorld[0]),dot(normalWorld[1],normalWorld[1]),dot(normalWorld[2],normalWorld[2]));vertexOutputs.vNormalW=normalize(normalWorld*vertexOutputs.vNormalW);
+#else
+#ifdef NONUNIFORMSCALING
+normalWorld=transposeMat3(inverseMat3(normalWorld));
+#endif
+vertexOutputs.vNormalW=normalize(normalWorld*normalUpdated);
+#endif
+#endif
+#define CUSTOM_VERTEX_UPDATE_WORLDPOS
+#ifdef MULTIVIEW
+if (gl_ViewID_OVR==0u) {vertexOutputs.position=scene.viewProjection*worldPos;} else {vertexOutputs.position=scene.viewProjectionR*worldPos;}
+#else
+vertexOutputs.position=scene.viewProjection*worldPos;
+#endif
+vertexOutputs.vPositionW= worldPos.xyz;
+#ifdef PREPASS
+#include<prePassVertex>
+#endif
+#if defined(REFLECTIONMAP_EQUIRECTANGULAR_FIXED) || defined(REFLECTIONMAP_MIRROREDEQUIRECTANGULAR_FIXED)
+vertexOutputs.vDirectionW=normalize((finalWorld* vec4f(positionUpdated,0.0)).xyz);
+#endif
+#if defined(CLUSTLIGHT_BATCH) && CLUSTLIGHT_BATCH>0
+#ifdef RIGHT_HANDED
+vertexOutputs.vViewDepth=-(scene.view*worldPos).z;
+#else
+vertexOutputs.vViewDepth=(scene.view*worldPos).z;
+#endif
+#endif
+#ifndef UV1
+var uvUpdated: vec2f=vec2f(0.,0.);
+#endif
+#ifdef MAINUV1
+vertexOutputs.vMainUV1=uvUpdated;
+#endif
+#ifndef UV2
+var uv2Updated: vec2f=vec2f(0.,0.);
+#endif
+#ifdef MAINUV2
+vertexOutputs.vMainUV2=uv2Updated;
+#endif
+#include<uvVariableDeclaration>[3..7]
+#include<samplerVertexImplementation>(_DEFINENAME_,DIFFUSE,_VARYINGNAME_,Diffuse,_MATRIXNAME_,diffuse,_INFONAME_,DiffuseInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,DETAIL,_VARYINGNAME_,Detail,_MATRIXNAME_,detail,_INFONAME_,DetailInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,AMBIENT,_VARYINGNAME_,Ambient,_MATRIXNAME_,ambient,_INFONAME_,AmbientInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,OPACITY,_VARYINGNAME_,Opacity,_MATRIXNAME_,opacity,_INFONAME_,OpacityInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,EMISSIVE,_VARYINGNAME_,Emissive,_MATRIXNAME_,emissive,_INFONAME_,EmissiveInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,LIGHTMAP,_VARYINGNAME_,Lightmap,_MATRIXNAME_,lightmap,_INFONAME_,LightmapInfos.x)
+#if defined(SPECULARTERM)
+#include<samplerVertexImplementation>(_DEFINENAME_,SPECULAR,_VARYINGNAME_,Specular,_MATRIXNAME_,specular,_INFONAME_,SpecularInfos.x)
+#endif
+#include<samplerVertexImplementation>(_DEFINENAME_,BUMP,_VARYINGNAME_,Bump,_MATRIXNAME_,bump,_INFONAME_,BumpInfos.x)
+#include<samplerVertexImplementation>(_DEFINENAME_,DECAL,_VARYINGNAME_,Decal,_MATRIXNAME_,decal,_INFONAME_,DecalInfos.x)
+#include<bumpVertex>
+#include<clipPlaneVertex>
+#include<fogVertex>
+#include<shadowsVertex>[0..maxSimultaneousLights]
+#include<vertexColorMixing>
+#include<logDepthVertex>
+#define CUSTOM_VERTEX_MAIN_END
+}
+`;e.ShadersStoreWGSL[i]||(e.ShadersStoreWGSL[i]=n);const s={name:i,shader:n};export{s as defaultVertexShaderWGSL};

package/public/assets/defaultUboDeclaration-ChgZa3Dv.js

@@ -0,0 +1,5 @@
+import{fp as f}from"./standardMaterial-CgDYhl-K.js";import"./meshUboDeclaration-B5FWJmqY.js";const o="defaultUboDeclaration",i=`uniform diffuseLeftColor: vec4f;uniform diffuseRightColor: vec4f;uniform opacityParts: vec4f;uniform reflectionLeftColor: vec4f;uniform reflectionRightColor: vec4f;uniform refractionLeftColor: vec4f;uniform refractionRightColor: vec4f;uniform emissiveLeftColor: vec4f;uniform emissiveRightColor: vec4f;uniform vDiffuseInfos: vec2f;uniform vAmbientInfos: vec2f;uniform vOpacityInfos: vec2f;uniform vEmissiveInfos: vec2f;uniform vLightmapInfos: vec2f;uniform vSpecularInfos: vec2f;uniform vBumpInfos: vec3f;uniform diffuseMatrix: mat4x4f;uniform ambientMatrix: mat4x4f;uniform opacityMatrix: mat4x4f;uniform emissiveMatrix: mat4x4f;uniform lightmapMatrix: mat4x4f;uniform specularMatrix: mat4x4f;uniform bumpMatrix: mat4x4f;uniform vTangentSpaceParams: vec2f;uniform pointSize: f32;uniform alphaCutOff: f32;uniform refractionMatrix: mat4x4f;uniform vRefractionInfos: vec4f;uniform vRefractionPosition: vec3f;uniform vRefractionSize: vec3f;uniform vSpecularColor: vec4f;uniform vEmissiveColor: vec3f;uniform vDiffuseColor: vec4f;uniform vAmbientColor: vec3f;uniform cameraInfo: vec4f;uniform vReflectionInfos: vec2f;uniform reflectionMatrix: mat4x4f;uniform vReflectionPosition: vec3f;uniform vReflectionSize: vec3f;
+#define ADDITIONAL_UBO_DECLARATION
+#include<sceneUboDeclaration>
+#include<meshUboDeclaration>
+`;f.IncludesShadersStoreWGSL[o]||(f.IncludesShadersStoreWGSL[o]=i);

package/public/assets/defaultUboDeclaration-Dzd2ch6X.js

@@ -0,0 +1,7 @@
+import{fp as e}from"./standardMaterial-CgDYhl-K.js";import"./meshUboDeclaration-DthvNL2q.js";const o="defaultUboDeclaration",i=`layout(std140,column_major) uniform;uniform Material
+{vec4 diffuseLeftColor;vec4 diffuseRightColor;vec4 opacityParts;vec4 reflectionLeftColor;vec4 reflectionRightColor;vec4 refractionLeftColor;vec4 refractionRightColor;vec4 emissiveLeftColor;vec4 emissiveRightColor;vec2 vDiffuseInfos;vec2 vAmbientInfos;vec2 vOpacityInfos;vec2 vEmissiveInfos;vec2 vLightmapInfos;vec2 vSpecularInfos;vec3 vBumpInfos;mat4 diffuseMatrix;mat4 ambientMatrix;mat4 opacityMatrix;mat4 emissiveMatrix;mat4 lightmapMatrix;mat4 specularMatrix;mat4 bumpMatrix;vec2 vTangentSpaceParams;float pointSize;float alphaCutOff;mat4 refractionMatrix;vec4 vRefractionInfos;vec3 vRefractionPosition;vec3 vRefractionSize;vec4 vSpecularColor;vec3 vEmissiveColor;vec4 vDiffuseColor;vec3 vAmbientColor;vec4 cameraInfo;vec2 vReflectionInfos;mat4 reflectionMatrix;vec3 vReflectionPosition;vec3 vReflectionSize;
+#define ADDITIONAL_UBO_DECLARATION
+};
+#include<sceneUboDeclaration>
+#include<meshUboDeclaration>
+`;e.IncludesShadersStore[o]||(e.IncludesShadersStore[o]=i);

package/public/assets/depth.fragment-B9FDfPgW.js

@@ -0,0 +1,40 @@
+import{fp as i}from"./standardMaterial-CgDYhl-K.js";import"./clipPlaneFragment-Da_1RMjt.js";const e="depthPixelShader",t=`#ifdef ALPHATEST
+varying vUV: vec2f;var diffuseSamplerSampler: sampler;var diffuseSampler: texture_2d<f32>;
+#endif
+#include<clipPlaneFragmentDeclaration>
+varying vDepthMetric: f32;
+#ifdef PACKED
+#include<packingFunctions>
+#endif
+#ifdef STORE_CAMERASPACE_Z
+varying vViewPos: vec4f;
+#endif
+#define CUSTOM_FRAGMENT_DEFINITIONS
+@fragment
+fn main(input: FragmentInputs)->FragmentOutputs {
+#include<clipPlaneFragment>
+#ifdef ALPHATEST
+if (textureSample(diffuseSampler,diffuseSamplerSampler,input.vUV).a<0.4) {discard;}
+#endif
+#ifdef STORE_CAMERASPACE_Z
+#ifdef PACKED
+fragmentOutputs.color=pack(input.vViewPos.z);
+#else
+fragmentOutputs.color= vec4f(input.vViewPos.z,0.0,0.0,1.0);
+#endif
+#else
+#ifdef NONLINEARDEPTH
+#ifdef PACKED
+fragmentOutputs.color=pack(input.position.z);
+#else
+fragmentOutputs.color= vec4f(input.position.z,0.0,0.0,0.0);
+#endif
+#else
+#ifdef PACKED
+fragmentOutputs.color=pack(input.vDepthMetric);
+#else
+fragmentOutputs.color= vec4f(input.vDepthMetric,0.0,0.0,1.0);
+#endif
+#endif
+#endif
+}`;i.ShadersStoreWGSL[e]||(i.ShadersStoreWGSL[e]=t);const r={name:e,shader:t};export{r as depthPixelShaderWGSL};

package/public/assets/depth.fragment-B9FDfPgW.js.br

@@ -0,0 +1,2 @@
+� ��X�9���w���k��I����Qq�����_S?ӕڋ[dQ$�:(�8�=dS}�Q/����K=�ik
+�
���l�wz�����2-������Uq��D�5v���1J�PZ�1��Ye��c��Џ����OB�\��
f[dFh�/��S]��g7'����'�:��C�����A�FA`t��1nnթH���^�1cuFO�e�l_PV?A��M^&�e]�V�(��R7�Oѹ�2���;3#l�0�.3��!�G,����2��v;T����A=�4NB`{�

package/public/assets/depth.vertex-DXkbiW3p.js

@@ -0,0 +1,57 @@
+import{fp as t}from"./standardMaterial-CgDYhl-K.js";import"./clipPlaneVertex-B8PIfZU_.js";import"./morphTargetsVertex-DHRA_mKb.js";import"./instancesDeclaration-DpE3Y0C1.js";const e="depthVertexShader",i=`attribute position: vec3f;
+#include<bonesDeclaration>
+#include<bakedVertexAnimationDeclaration>
+#include<morphTargetsVertexGlobalDeclaration>
+#include<morphTargetsVertexDeclaration>[0..maxSimultaneousMorphTargets]
+#include<clipPlaneVertexDeclaration>
+#include<instancesDeclaration>
+uniform viewProjection: mat4x4f;uniform depthValues: vec2f;
+#if defined(ALPHATEST) || defined(NEED_UV)
+varying vUV: vec2f;uniform diffuseMatrix: mat4x4f;
+#ifdef UV1
+attribute uv: vec2f;
+#endif
+#ifdef UV2
+attribute uv2: vec2f;
+#endif
+#endif
+#ifdef STORE_CAMERASPACE_Z
+uniform view: mat4x4f;varying vViewPos: vec4f;
+#endif
+varying vDepthMetric: f32;
+#define CUSTOM_VERTEX_DEFINITIONS
+@vertex
+fn main(input : VertexInputs)->FragmentInputs {var positionUpdated: vec3f=vertexInputs.position;
+#ifdef UV1
+var uvUpdated: vec2f=vertexInputs.uv;
+#endif
+#ifdef UV2
+var uv2Updated: vec2f=vertexInputs.uv2;
+#endif
+#include<morphTargetsVertexGlobal>
+#include<morphTargetsVertex>[0..maxSimultaneousMorphTargets]
+#include<instancesVertex>
+#include<bonesVertex>
+#include<bakedVertexAnimation>
+var worldPos: vec4f=finalWorld* vec4f(positionUpdated,1.0);
+#include<clipPlaneVertex>
+vertexOutputs.position=uniforms.viewProjection*worldPos;
+#ifdef STORE_CAMERASPACE_Z
+vertexOutputs.vViewPos=uniforms.view*worldPos;
+#else
+#ifdef USE_REVERSE_DEPTHBUFFER
+vertexOutputs.vDepthMetric=((-vertexOutputs.position.z+uniforms.depthValues.x)/(uniforms.depthValues.y));
+#else
+vertexOutputs.vDepthMetric=((vertexOutputs.position.z+uniforms.depthValues.x)/(uniforms.depthValues.y));
+#endif
+#endif
+#if defined(ALPHATEST) || defined(BASIC_RENDER)
+#ifdef UV1
+vertexOutputs.vUV= (uniforms.diffuseMatrix* vec4f(uvUpdated,1.0,0.0)).xy;
+#endif
+#ifdef UV2
+vertexOutputs.vUV= (uniforms.diffuseMatrix* vec4f(uv2Updated,1.0,0.0)).xy;
+#endif
+#endif
+}
+`;t.ShadersStoreWGSL[e]||(t.ShadersStoreWGSL[e]=i);const o={name:e,shader:i};export{o as depthVertexShaderWGSL};

package/public/assets/depthBoxBlur.fragment-BlgJGCM0.js

@@ -0,0 +1,6 @@
+import{fp as r}from"./standardMaterial-CgDYhl-K.js";const e="depthBoxBlurPixelShader",o=`varying vec2 vUV;uniform sampler2D textureSampler;uniform vec2 screenSize;
+#define CUSTOM_FRAGMENT_DEFINITIONS
+void main(void)
+{vec4 colorDepth=vec4(0.0);for (int x=-OFFSET; x<=OFFSET; x++)
+for (int y=-OFFSET; y<=OFFSET; y++)
+colorDepth+=texture2D(textureSampler,vUV+vec2(x,y)/screenSize);gl_FragColor=(colorDepth/float((OFFSET*2+1)*(OFFSET*2+1)));}`;r.ShadersStore[e]||(r.ShadersStore[e]=o);const S={name:e,shader:o};export{S as depthBoxBlurPixelShader};

package/public/assets/depthBoxBlur.fragment-DUm61npj.js

@@ -0,0 +1,5 @@
+import{fp as r}from"./standardMaterial-CgDYhl-K.js";const e="depthBoxBlurPixelShader",t=`varying vUV: vec2f;var textureSamplerSampler: sampler;var textureSampler: texture_2d<f32>;uniform screenSize: vec2f;
+#define CUSTOM_FRAGMENT_DEFINITIONS
+@fragment
+fn main(input: FragmentInputs)->FragmentOutputs {var colorDepth: vec4f=vec4f(0.0);for (var x: i32=-OFFSET; x<=OFFSET; x++) {for (var y: i32=-OFFSET; y<=OFFSET; y++) {colorDepth+=textureSample(textureSampler,textureSamplerSampler,input.vUV+ vec2f(f32(x),f32(y))/uniforms.screenSize);}}
+fragmentOutputs.color=(colorDepth/ f32((OFFSET*2+1)*(OFFSET*2+1)));}`;r.ShadersStoreWGSL[e]||(r.ShadersStoreWGSL[e]=t);const a={name:e,shader:t};export{a as depthBoxBlurPixelShaderWGSL};

package/public/assets/depthOfFieldMerge.fragment-25hKWM62.js

@@ -0,0 +1,21 @@
+import{fp as r}from"./standardMaterial-CgDYhl-K.js";const e="depthOfFieldMergePixelShader",l=`varying vUV: vec2f;var textureSamplerSampler: sampler;var textureSampler: texture_2d<f32>;var circleOfConfusionSamplerSampler: sampler;var circleOfConfusionSampler: texture_2d<f32>;var blurStep0Sampler: sampler;var blurStep0: texture_2d<f32>;
+#if BLUR_LEVEL>0
+var blurStep1Sampler: sampler;var blurStep1: texture_2d<f32>;
+#endif
+#if BLUR_LEVEL>1
+var blurStep2Sampler: sampler;var blurStep2: texture_2d<f32>;
+#endif
+#define CUSTOM_FRAGMENT_DEFINITIONS
+@fragment
+fn main(input: FragmentInputs)->FragmentOutputs {var coc: f32=textureSampleLevel(circleOfConfusionSampler,circleOfConfusionSamplerSampler,input.vUV,0.0).r;
+#if BLUR_LEVEL==0
+var original: vec4f=textureSampleLevel(textureSampler,textureSamplerSampler,input.vUV,0.0);var blurred0: vec4f=textureSampleLevel(blurStep0,blurStep0Sampler,input.vUV,0.0);fragmentOutputs.color=mix(original,blurred0,coc);
+#endif
+#if BLUR_LEVEL==1
+if(coc<0.5){var original: vec4f=textureSampleLevel(textureSampler,textureSamplerSampler,input.vUV,0.0);var blurred1: vec4f=textureSampleLevel(blurStep1,blurStep1Sampler,input.vUV,0.0);fragmentOutputs.color=mix(original,blurred1,coc/0.5);}else{var blurred0: vec4f=textureSampleLevel(blurStep0,blurStep0Sampler,input.vUV,0.0);var blurred1: vec4f=textureSampleLevel(blurStep1,blurStep1Sampler,input.vUV,0.0);fragmentOutputs.color=mix(blurred1,blurred0,(coc-0.5)/0.5);}
+#endif
+#if BLUR_LEVEL==2
+if(coc<0.33){var original: vec4f=textureSampleLevel(textureSampler,textureSamplerSampler,input.vUV,0.0);var blurred2: vec4f=textureSampleLevel(blurStep2,blurStep2Sampler,input.vUV,0.0);fragmentOutputs.color=mix(original,blurred2,coc/0.33);}else if(coc<0.66){var blurred1: vec4f=textureSampleLevel(blurStep1,blurStep1Sampler,input.vUV,0.0);var blurred2: vec4f=textureSampleLevel(blurStep2,blurStep2Sampler,input.vUV,0.0);fragmentOutputs.color=mix(blurred2,blurred1,(coc-0.33)/0.33);}else{var blurred0: vec4f=textureSampleLevel(blurStep0,blurStep0Sampler,input.vUV,0.0);var blurred1: vec4f=textureSampleLevel(blurStep1,blurStep1Sampler,input.vUV,0.0);fragmentOutputs.color=mix(blurred1,blurred0,(coc-0.66)/0.34);}
+#endif
+}
+`;r.ShadersStoreWGSL[e]||(r.ShadersStoreWGSL[e]=l);const u={name:e,shader:l};export{u as depthOfFieldMergePixelShaderWGSL};

package/public/assets/depthOfFieldMerge.fragment-_d6h2qdf.js

@@ -0,0 +1,26 @@
+import{fp as r}from"./standardMaterial-CgDYhl-K.js";const e="depthOfFieldMergePixelShader",l=`#if defined(WEBGL2) || defined(WEBGPU) || defined(NATIVE)
+#define TEXTUREFUNC(s,c,lod) texture2DLodEXT(s,c,lod)
+#else
+#define TEXTUREFUNC(s,c,bias) texture2D(s,c,bias)
+#endif
+uniform sampler2D textureSampler;varying vec2 vUV;uniform sampler2D circleOfConfusionSampler;uniform sampler2D blurStep0;
+#if BLUR_LEVEL>0
+uniform sampler2D blurStep1;
+#endif
+#if BLUR_LEVEL>1
+uniform sampler2D blurStep2;
+#endif
+#define CUSTOM_FRAGMENT_DEFINITIONS
+void main(void)
+{float coc=TEXTUREFUNC(circleOfConfusionSampler,vUV,0.0).r;
+#if BLUR_LEVEL==0
+vec4 original=TEXTUREFUNC(textureSampler,vUV,0.0);vec4 blurred0=TEXTUREFUNC(blurStep0,vUV,0.0);gl_FragColor=mix(original,blurred0,coc);
+#endif
+#if BLUR_LEVEL==1
+if(coc<0.5){vec4 original=TEXTUREFUNC(textureSampler,vUV,0.0);vec4 blurred1=TEXTUREFUNC(blurStep1,vUV,0.0);gl_FragColor=mix(original,blurred1,coc/0.5);}else{vec4 blurred0=TEXTUREFUNC(blurStep0,vUV,0.0);vec4 blurred1=TEXTUREFUNC(blurStep1,vUV,0.0);gl_FragColor=mix(blurred1,blurred0,(coc-0.5)/0.5);}
+#endif
+#if BLUR_LEVEL==2
+if(coc<0.33){vec4 original=TEXTUREFUNC(textureSampler,vUV,0.0);vec4 blurred2=TEXTUREFUNC(blurStep2,vUV,0.0);gl_FragColor=mix(original,blurred2,coc/0.33);}else if(coc<0.66){vec4 blurred1=TEXTUREFUNC(blurStep1,vUV,0.0);vec4 blurred2=TEXTUREFUNC(blurStep2,vUV,0.0);gl_FragColor=mix(blurred2,blurred1,(coc-0.33)/0.33);}else{vec4 blurred0=TEXTUREFUNC(blurStep0,vUV,0.0);vec4 blurred1=TEXTUREFUNC(blurStep1,vUV,0.0);gl_FragColor=mix(blurred1,blurred0,(coc-0.66)/0.34);}
+#endif
+}
+`;r.ShadersStore[e]||(r.ShadersStore[e]=l);const o={name:e,shader:l};export{o as depthOfFieldMergePixelShader};

package/public/assets/easing-BkcTAuOI.js

@@ -0,0 +1 @@
+import{r as I}from"./standardMaterial-CgDYhl-K.js";class e{constructor(){this._easingMode=e.EASINGMODE_EASEIN}setEasingMode(s){const t=Math.min(Math.max(s,0),2);this._easingMode=t}getEasingMode(){return this._easingMode}easeInCore(s){throw new Error("You must implement this method")}ease(s){switch(this._easingMode){case e.EASINGMODE_EASEIN:return this.easeInCore(s);case e.EASINGMODE_EASEOUT:return 1-this.easeInCore(1-s)}return s>=.5?(1-this.easeInCore((1-s)*2))*.5+.5:this.easeInCore(s*2)*.5}}e.EASINGMODE_EASEIN=0;e.EASINGMODE_EASEOUT=1;e.EASINGMODE_EASEINOUT=2;class S extends e{easeInCore(s){return s=Math.max(0,Math.min(1,s)),1-Math.sqrt(1-s*s)}}class w extends e{constructor(s=1){super(),this.amplitude=s}easeInCore(s){const t=Math.max(0,this.amplitude);return Math.pow(s,3)-s*t*Math.sin(3.141592653589793*s)}}class A extends e{constructor(s=3,t=2){super(),this.bounces=s,this.bounciness=t}easeInCore(s){const t=Math.max(0,this.bounces);let n=this.bounciness;n<=1&&(n=1.001);const a=Math.pow(n,t),c=1-n,h=(1-a)/c+a*.5,m=s*h,x=Math.log(-m*(1-n)+1)/Math.log(n),u=Math.floor(x),p=u+1,i=(1-Math.pow(n,u))/(c*h),l=(1-Math.pow(n,p))/(c*h),E=(i+l)*.5,M=s-E,r=E-i;return-Math.pow(1/n,t-u)/(r*r)*(M-r)*(M+r)}}class N extends e{easeInCore(s){return s*s*s}}class O extends e{constructor(s=3,t=3){super(),this.oscillations=s,this.springiness=t}easeInCore(s){let t;const n=Math.max(0,this.oscillations),a=Math.max(0,this.springiness);return a==0?t=s:t=(Math.exp(a*s)-1)/(Math.exp(a)-1),t*Math.sin((6.283185307179586*n+1.5707963267948966)*s)}}class b extends e{constructor(s=2){super(),this.exponent=s}easeInCore(s){return this.exponent<=0?s:(Math.exp(this.exponent*s)-1)/(Math.exp(this.exponent)-1)}}class f extends e{constructor(s=2){super(),this.power=s}easeInCore(s){const t=Math.max(0,this.power);return Math.pow(s,t)}}class _ extends e{easeInCore(s){return s*s}}class y extends e{easeInCore(s){return s*s*s*s}}class D extends e{easeInCore(s){return s*s*s*s*s}}class G extends e{easeInCore(s){return 1-Math.sin(1.5707963267948966*(1-s))}}class B extends e{constructor(s=0,t=0,n=1,a=1){super(),this.x1=s,this.y1=t,this.x2=n,this.y2=a}easeInCore(s){return I.Interpolate(s,this.x1,this.y1,this.x2,this.y2)}}export{w as B,S as C,e as E,f as P,_ as Q,G as S,B as a,A as b,N as c,O as d,b as e,y as f,D as g};