python-cad-tools 0.1.0rc1__py3-none-any.whl

python_cad_tools/_viewer_static/assets/gaussianSplatting.vertex-D92z5jYn.js

@@ -0,0 +1,86 @@
+import{S as e,s as t,m as r,l as n,n as l,o as s,p as f,q as c,r as p,t as d}from"./index-B2zBEWsq.js";import{g as S,a as u,b as m}from"./gaussianSplatting-Cfigjb15.js";const a="gaussianSplattingVertexShader",i=`#include<__decl__gaussianSplattingVertex>
+#ifdef LOGARITHMICDEPTH
+#extension GL_EXT_frag_depth : enable
+#endif
+#include<clipPlaneVertexDeclaration>
+#include<fogVertexDeclaration>
+#include<logDepthDeclaration>
+#include<helperFunctions>
+uniform vec2 invViewport;uniform vec2 dataTextureSize;uniform vec2 focal;uniform float kernelSize;uniform float minPixelSize;uniform vec3 eyePosition;uniform float alpha;
+#if IS_COMPOUND
+uniform mat4 partWorld[MAX_PART_COUNT];uniform float partVisibility[MAX_PART_COUNT];
+#endif
+uniform sampler2D covariancesATexture;uniform sampler2D covariancesBTexture;uniform sampler2D centersTexture;uniform sampler2D colorsTexture;
+#ifdef USE_SOG
+uniform sampler2D sogQuatsTexture;uniform vec3 sogMeansMin;uniform vec3 sogMeansMax;
+#ifdef USE_SOG_V2
+uniform sampler2D sogCodebookTexture; 
+#else
+uniform vec3 sogScalesMin;uniform vec3 sogScalesMax;uniform vec4 sogSh0Min;uniform vec4 sogSh0Max;uniform float sogShnMin;uniform float sogShnMax;
+#endif
+#if SH_DEGREE>0
+uniform sampler2D sogShNCentroidsTexture;uniform sampler2D sogShNLabelsTexture;uniform float sogShCoeffCount;
+#endif
+#endif
+#if SH_DEGREE>0 && !defined(USE_SOG)
+uniform highp usampler2D shTexture0;
+#endif
+#if SH_DEGREE>1 && !defined(USE_SOG)
+uniform highp usampler2D shTexture1;
+#endif
+#if SH_DEGREE>2 && !defined(USE_SOG)
+uniform highp usampler2D shTexture2;
+#endif
+#if SH_DEGREE>3 && !defined(USE_SOG)
+uniform highp usampler2D shTexture3;uniform highp usampler2D shTexture4;
+#endif
+#if IS_COMPOUND
+uniform sampler2D partIndicesTexture;
+#endif
+varying vec4 vColor;varying vec2 vPosition;
+#define CUSTOM_VERTEX_DEFINITIONS
+#include<gaussianSplatting>
+void main () {
+#define CUSTOM_VERTEX_MAIN_BEGIN
+float splatIndex=getSplatIndex(int(position.z+0.5));Splat splat=readSplat(splatIndex);vec3 covA=splat.covA.xyz;vec3 covB=vec3(splat.covA.w,splat.covB.xy);
+#if IS_COMPOUND
+mat4 splatWorld=getPartWorld(splat.partIndex);
+#else
+mat4 splatWorld=world;
+#endif
+vec4 worldPos=splatWorld*vec4(splat.center.xyz,1.0);vColor=splat.color;vPosition=position.xy;
+#if SH_DEGREE>0
+mat3 worldRot=mat3(splatWorld);mat3 normWorldRot=inverseMat3(worldRot);vec3 eyeToSplatLocalSpace=normalize(normWorldRot*(worldPos.xyz-eyePosition));
+#if defined(GS_DBG_ENABLED) && IS_COMPOUND
+{vec4 _row3=texelFetch(dbgPartData,ivec2(int(splat.partIndex),3),0);
+#if SH_DEGREE>3
+float _so4=texelFetch(dbgPartData,ivec2(int(splat.partIndex),4),0).x;
+#else
+float _so4=1.0;
+#endif
+vColor.xyz=_row3.x*splat.color.xyz+computeSHWeighted(splat,eyeToSplatLocalSpace,_row3.y,_row3.z,_row3.w,_so4);}
+#elif defined(GS_DBG_ENABLED) && GS_DBG_SH_DC==0
+vColor.xyz=computeSH(splat,eyeToSplatLocalSpace);
+#else
+vColor.xyz=splat.color.xyz+computeSH(splat,eyeToSplatLocalSpace);
+#endif
+#else
+#if defined(GS_DBG_ENABLED) && IS_COMPOUND
+{float _shDc=texelFetch(dbgPartData,ivec2(int(splat.partIndex),3),0).x;vColor.xyz=_shDc*splat.color.xyz;}
+#elif defined(GS_DBG_ENABLED) && GS_DBG_SH_DC==0
+vColor.xyz=vec3(0.0);
+#endif
+#endif
+vColor.w*=alpha;
+#if IS_COMPOUND
+vColor.w*=partVisibility[splat.partIndex];
+#endif
+vec2 scale=vec2(1.,1.);
+#define CUSTOM_VERTEX_UPDATE
+gl_Position=gaussianSplatting(position.xy,worldPos.xyz,scale,covA,covB,splatWorld,view,projection);
+#include<clipPlaneVertex>
+#include<fogVertex>
+#include<logDepthVertex>
+#define CUSTOM_VERTEX_MAIN_END
+}
+`;e.ShadersStore[a]||(e.ShadersStore[a]=i);const _=[S,t,r,u,n,l,s,f,m,c,p,d];for(const o of _)e.IncludesShadersStore[o.name]||(e.IncludesShadersStore[o.name]=o.shader);const g={name:a,shader:i};export{g as gaussianSplattingVertexShader};

python_cad_tools/_viewer_static/assets/gaussianSplatting.vertex-DSWfFnKQ.js

@@ -0,0 +1,86 @@
+import{S as e}from"./index-B2zBEWsq.js";import{s as a}from"./sceneUboDeclaration-BzFIc4mb.js";import{m as i}from"./meshUboDeclaration-BnX046aQ.js";import{h as n}from"./helperFunctions-Cugfp1Fz.js";import{c as s,a as l}from"./clipPlaneVertex-B_VhD1oQ.js";import{f,a as u,l as p}from"./logDepthVertex-UKrhEIvg.js";import{l as c}from"./logDepthDeclaration-BR8XRz9F.js";import{g as d}from"./gaussianSplatting-DIn8R8oF.js";const r="gaussianSplattingVertexShader",o=`#include<sceneUboDeclaration>
+#include<meshUboDeclaration>
+#include<helperFunctions>
+#include<clipPlaneVertexDeclaration>
+#include<fogVertexDeclaration>
+#include<logDepthDeclaration>
+attribute splatIndex0: vec4f;attribute splatIndex1: vec4f;attribute splatIndex2: vec4f;attribute splatIndex3: vec4f;attribute position: vec3f;uniform invViewport: vec2f;uniform dataTextureSize: vec2f;uniform focal: vec2f;uniform kernelSize: f32;uniform minPixelSize: f32;uniform eyePosition: vec3f;uniform alpha: f32;
+#if IS_COMPOUND
+uniform partWorld: array<mat4x4<f32>,MAX_PART_COUNT>;uniform partVisibility: array<f32,MAX_PART_COUNT>;
+#endif
+var covariancesATexture: texture_2d<f32>;var covariancesBTexture: texture_2d<f32>;var centersTexture: texture_2d<f32>;var colorsTexture: texture_2d<f32>;
+#ifdef USE_SOG
+var sogQuatsTexture: texture_2d<f32>;uniform sogMeansMin: vec3f;uniform sogMeansMax: vec3f;
+#ifdef USE_SOG_V2
+var sogCodebookTexture: texture_2d<f32>;
+#else
+uniform sogScalesMin: vec3f;uniform sogScalesMax: vec3f;uniform sogSh0Min: vec4f;uniform sogSh0Max: vec4f;uniform sogShnMin: f32;uniform sogShnMax: f32;
+#endif
+#if SH_DEGREE>0
+var sogShNCentroidsTexture: texture_2d<f32>;var sogShNLabelsTexture: texture_2d<f32>;uniform sogShCoeffCount: f32;
+#endif
+#endif
+#if SH_DEGREE>0 && !defined(USE_SOG)
+var shTexture0: texture_2d<u32>;
+#endif
+#if SH_DEGREE>1 && !defined(USE_SOG)
+var shTexture1: texture_2d<u32>;
+#endif
+#if SH_DEGREE>2 && !defined(USE_SOG)
+var shTexture2: texture_2d<u32>;
+#endif
+#if SH_DEGREE>3 && !defined(USE_SOG)
+var shTexture3: texture_2d<u32>;var shTexture4: texture_2d<u32>;
+#endif
+#if IS_COMPOUND
+var partIndicesTexture: texture_2d<f32>;
+#endif
+varying vColor: vec4f;varying vPosition: vec2f;
+#define CUSTOM_VERTEX_DEFINITIONS
+#include<gaussianSplatting>
+@vertex
+fn main(input : VertexInputs)->FragmentInputs {
+#define CUSTOM_VERTEX_MAIN_BEGIN
+let splatIndex: f32=getSplatIndex(i32(vertexInputs.position.z+0.5),vertexInputs.splatIndex0,vertexInputs.splatIndex1,vertexInputs.splatIndex2,vertexInputs.splatIndex3);var splat: Splat=readSplat(splatIndex,uniforms.dataTextureSize);var covA: vec3f=splat.covA.xyz;var covB: vec3f=vec3f(splat.covA.w,splat.covB.xy);
+#if IS_COMPOUND
+let splatWorld: mat4x4f=getPartWorld(splat.partIndex);
+#else
+let splatWorld: mat4x4f=mesh.world;
+#endif
+let worldPos: vec4f=splatWorld*vec4f(splat.center.xyz,1.0);vertexOutputs.vPosition=vertexInputs.position.xy;
+#if SH_DEGREE>0
+let worldRot: mat3x3f= mat3x3f(splatWorld[0].xyz,splatWorld[1].xyz,splatWorld[2].xyz);let normWorldRot: mat3x3f=inverseMat3(worldRot);var eyeToSplatLocalSpace: vec3f=normalize(normWorldRot*(worldPos.xyz-uniforms.eyePosition.xyz));
+#if defined(GS_DBG_ENABLED) && IS_COMPOUND
+{let _row3=textureLoad(dbgPartData,vec2i(i32(splat.partIndex),3),0);
+#if SH_DEGREE>3
+let _so4=textureLoad(dbgPartData,vec2i(i32(splat.partIndex),4),0).x;
+#else
+let _so4: f32=1.0;
+#endif
+vertexOutputs.vColor=vec4f(_row3.x*splat.color.xyz+computeSHWeighted(splat,eyeToSplatLocalSpace,_row3.y,_row3.z,_row3.w,_so4),splat.color.w*uniforms.alpha);}
+#elif defined(GS_DBG_ENABLED) && GS_DBG_SH_DC==0
+vertexOutputs.vColor=vec4f(computeSH(splat,eyeToSplatLocalSpace),splat.color.w*uniforms.alpha);
+#else
+vertexOutputs.vColor=vec4f(splat.color.xyz+computeSH(splat,eyeToSplatLocalSpace),splat.color.w*uniforms.alpha);
+#endif
+#else
+#if defined(GS_DBG_ENABLED) && IS_COMPOUND
+{let _shDc=textureLoad(dbgPartData,vec2i(i32(splat.partIndex),3),0).x;vertexOutputs.vColor=vec4f(_shDc*splat.color.xyz,splat.color.w*uniforms.alpha);}
+#elif defined(GS_DBG_ENABLED) && GS_DBG_SH_DC==0
+vertexOutputs.vColor=vec4f(0.0,0.0,0.0,splat.color.w*uniforms.alpha);
+#else
+vertexOutputs.vColor=vec4f(splat.color.xyz,splat.color.w*uniforms.alpha);
+#endif
+#endif
+#if IS_COMPOUND
+vertexOutputs.vColor.w*=uniforms.partVisibility[splat.partIndex];
+#endif
+var scale: vec2f=vec2f(1.,1.);
+#define CUSTOM_VERTEX_UPDATE
+vertexOutputs.position=gaussianSplatting(vertexInputs.position.xy,worldPos.xyz,scale,covA,covB,splatWorld,scene.view,scene.projection,uniforms.focal,uniforms.invViewport,uniforms.kernelSize,uniforms.minPixelSize);
+#include<clipPlaneVertex>
+#include<fogVertex>
+#include<logDepthVertex>
+#define CUSTOM_VERTEX_MAIN_END
+}
+`;e.ShadersStoreWGSL[r]||(e.ShadersStoreWGSL[r]=o);const x=[a,i,n,s,f,c,d,l,u,p];for(const t of x)e.IncludesShadersStoreWGSL[t.name]||(e.IncludesShadersStoreWGSL[t.name]=t.shader);const G={name:r,shader:o};export{G as gaussianSplattingVertexShaderWGSL};

python_cad_tools/_viewer_static/assets/gaussianSplattingVoxel.fragment-DBQE2gDk.js

@@ -0,0 +1,12 @@
+import{S as o}from"./index-B2zBEWsq.js";const e="gaussianSplattingVoxelPixelShader",t=`var voxel_storage: texture_storage_3d<r8unorm,write>;varying vNormalizedPosition: vec3f;varying vNormalizedCenterPosition: vec3f;varying vAlpha: f32;varying vPatchPosition: vec2f;fn gsVoxelPrngCanonical1d(co: f32)->f32 {return fract(sin(co*91.3458)*47453.5453);}
+fn gsVoxelPrngCanonical2d(co: vec2f)->f32 {return fract(sin(dot(co,vec2f(12.9898,78.233)))*43758.5453);}
+fn gsVoxelPrngCanonical3d(co: vec3f)->f32 {return gsVoxelPrngCanonical2d(vec2f(co.x,co.y)+gsVoxelPrngCanonical1d(co.z));}
+@fragment
+fn main(input: FragmentInputs)->FragmentOutputs {let normPos: vec3f=input.vNormalizedPosition;let stepSize: f32=1.0/f32(textureDimensions(voxel_storage).x);let diff: vec3f=abs(input.vNormalizedCenterPosition-normPos);let distToCenter: f32=max(max(diff.x,diff.y),diff.z);let gaussian: f32=exp(-dot(input.vPatchPosition,input.vPatchPosition));let shadowingOpacity: f32=clamp(
+select(gaussian,1.0,distToCenter<stepSize)*input.vAlpha,
+0.0,1.0
+);if (shadowingOpacity<1.0 && shadowingOpacity<gsVoxelPrngCanonical3d(normPos/stepSize)) {discard;}
+let size: vec3f=vec3f(textureDimensions(voxel_storage));textureStore(voxel_storage,
+vec3<i32>(i32(normPos.x*size.x),i32(normPos.y*size.y),i32(normPos.z*size.z)),
+vec4f(1.0,1.0,1.0,1.0));fragmentOutputs.color=vec4f(0.0,0.0,0.0,0.0);}
+`;o.ShadersStoreWGSL[e]||(o.ShadersStoreWGSL[e]=t);const i={name:e,shader:t};export{i as gaussianSplattingVoxelPixelShaderWGSL};

python_cad_tools/_viewer_static/assets/gaussianSplattingVoxel.fragment-qwx5ntqJ.js

@@ -0,0 +1,17 @@
+import{S as e}from"./index-B2zBEWsq.js";const a="gaussianSplattingVoxelPixelShader",n=`precision highp float;layout(location=0) out highp float glFragData[MAX_DRAW_BUFFERS];varying vec3 vNormalizedPosition;varying vec3 vNormalizedCenterPosition;varying float vAlpha;varying vec2 vPatchPosition;uniform float nearPlane;uniform float farPlane;uniform float stepSize;float max3(vec3 v) { return max(max(v.x,v.y),v.z); }
+float prngCanonical1d(float co)
+{return fract(sin(co*91.3458)*47453.5453);}
+float prngCanonical2d(vec2 co)
+{return fract(sin(dot(vec2(co.x,co.y),vec2(12.9898,78.233)))*43758.5453);}
+float prngCanonical3d(vec3 co)
+{return prngCanonical2d(vec2(co.x,co.y)+prngCanonical1d(co.z));}
+void main(void) {vec3 normPos=vNormalizedPosition.xyz;if (normPos.z<nearPlane || normPos.z>farPlane) {discard;}
+float distToCenter=max3(abs(vNormalizedCenterPosition-normPos));float shadowingOpacity=clamp((distToCenter<stepSize ? 1.0 : exp(-dot(vPatchPosition,vPatchPosition)))*vAlpha,0.0,1.0);if (shadowingOpacity<1.0 && shadowingOpacity<prngCanonical3d(normPos/stepSize)) {discard;}
+glFragData[0]=normPos.z<nearPlane+stepSize ? 1.0 : 0.0;glFragData[1]=normPos.z>=nearPlane+stepSize && normPos.z<nearPlane+2.0*stepSize ? 1.0 : 0.0;glFragData[2]=normPos.z>=nearPlane+2.0*stepSize && normPos.z<nearPlane+3.0*stepSize ? 1.0 : 0.0;glFragData[3]=normPos.z>=nearPlane+3.0*stepSize && normPos.z<nearPlane+4.0*stepSize ? 1.0 : 0.0;
+#if MAX_DRAW_BUFFERS>4
+glFragData[4]=normPos.z>=nearPlane+4.0*stepSize && normPos.z<nearPlane+5.0*stepSize ? 1.0 : 0.0;glFragData[5]=normPos.z>=nearPlane+5.0*stepSize && normPos.z<nearPlane+6.0*stepSize ? 1.0 : 0.0;
+#if MAX_DRAW_BUFFERS>6
+glFragData[6]=normPos.z>=nearPlane+6.0*stepSize && normPos.z<nearPlane+7.0*stepSize ? 1.0 : 0.0;glFragData[7]=normPos.z>=nearPlane+7.0*stepSize && normPos.z<nearPlane+8.0*stepSize ? 1.0 : 0.0;
+#endif
+#endif
+}`;e.ShadersStore[a]||(e.ShadersStore[a]=n);const r={name:a,shader:n};export{r as gaussianSplattingVoxelPixelShader};

python_cad_tools/_viewer_static/assets/gaussianSplattingVoxel.vertex-CP2kd3jU.js

@@ -0,0 +1,30 @@
+import{S as t}from"./index-B2zBEWsq.js";import{s as i}from"./sceneUboDeclaration-BzFIc4mb.js";import{m as o}from"./meshUboDeclaration-BnX046aQ.js";import{g as s}from"./gaussianSplatting-DIn8R8oF.js";const r="gaussianSplattingVoxelVertexShader",a=`#include<sceneUboDeclaration>
+#include<meshUboDeclaration>
+attribute splatIndex0: vec4f;attribute splatIndex1: vec4f;attribute splatIndex2: vec4f;attribute splatIndex3: vec4f;attribute position: vec3f;uniform dataTextureSize: vec2f;uniform alpha: f32;uniform invWorldScale: mat4x4f;uniform viewMatrix: mat4x4f;
+#if IS_COMPOUND
+uniform partWorld: array<mat4x4<f32>,MAX_PART_COUNT>;uniform partVisibility: array<f32,MAX_PART_COUNT>;
+#endif
+var rotationsATexture: texture_2d<f32>;var rotationsBTexture: texture_2d<f32>;var rotationScaleTexture: texture_2d<f32>;var centersTexture: texture_2d<f32>;var colorsTexture: texture_2d<f32>;
+#if IS_COMPOUND
+var partIndicesTexture: texture_2d<f32>;
+#endif
+varying vNormalizedPosition: vec3f;varying vNormalizedCenterPosition: vec3f;varying vAlpha: f32;varying vPatchPosition: vec2f;
+#include<gaussianSplatting>
+@vertex
+fn main(input: VertexInputs)->FragmentInputs {let splatIndex: f32=getSplatIndex(
+i32(vertexInputs.position.z+0.5),
+vertexInputs.splatIndex0,vertexInputs.splatIndex1,
+vertexInputs.splatIndex2,vertexInputs.splatIndex3
+);var splat: Splat=readSplat(splatIndex,uniforms.dataTextureSize);
+#if IS_COMPOUND
+if (uniforms.partVisibility[splat.partIndex]==0.0) {vertexOutputs.position=vec4f(2.0,2.0,2.0,1.0);return vertexOutputs;}
+let splatWorld: mat4x4f=getPartWorld(splat.partIndex);
+#else
+let splatWorld: mat4x4f=mesh.world;
+#endif
+let quadPos: vec2f=vertexInputs.position.xy;let worldPos: vec4f=computeVoxelSplatWorldPos(splat.rotationA,splat.rotationB,splat.rotationScale,splat.center.xyz,splatWorld,uniforms.viewMatrix,uniforms.invWorldScale,quadPos);vertexOutputs.vNormalizedPosition=(uniforms.invWorldScale*worldPos).xyz*0.5+0.5;let clipPos: vec4f=uniforms.viewMatrix*uniforms.invWorldScale*worldPos;vertexOutputs.position=vec4f(clipPos.x,clipPos.y,clipPos.z*0.5+0.5,1.0);vertexOutputs.vNormalizedCenterPosition=(uniforms.invWorldScale*splatWorld*vec4f(splat.center.xyz,1.0)).xyz*0.5+0.5;vertexOutputs.vAlpha=splat.color.w*uniforms.alpha;
+#if IS_COMPOUND
+vertexOutputs.vAlpha*=uniforms.partVisibility[splat.partIndex];
+#endif
+vertexOutputs.vPatchPosition=quadPos;}
+`;t.ShadersStoreWGSL[r]||(t.ShadersStoreWGSL[r]=a);const n=[i,o,s];for(const e of n)t.IncludesShadersStoreWGSL[e.name]||(t.IncludesShadersStoreWGSL[e.name]=e.shader);const f={name:r,shader:a};export{f as gaussianSplattingVoxelVertexShaderWGSL};

python_cad_tools/_viewer_static/assets/gaussianSplattingVoxel.vertex-Dr-fEg_W.js

@@ -0,0 +1,19 @@
+import{S as a,s as o,m as r}from"./index-B2zBEWsq.js";import{g as n,a as l,b as s}from"./gaussianSplatting-Cfigjb15.js";const e="gaussianSplattingVoxelVertexShader",i=`#include<__decl__gaussianSplattingVertex>
+uniform vec2 dataTextureSize;uniform float alpha;uniform mat4 invWorldScale;uniform mat4 viewMatrix;uniform sampler2D rotationsATexture;uniform sampler2D rotationsBTexture;uniform sampler2D rotationScaleTexture;uniform sampler2D centersTexture;uniform sampler2D colorsTexture;
+#if IS_COMPOUND
+uniform mat4 partWorld[MAX_PART_COUNT];uniform float partVisibility[MAX_PART_COUNT];uniform sampler2D partIndicesTexture;
+#endif
+varying vec3 vNormalizedPosition;varying vec3 vNormalizedCenterPosition;varying float vAlpha;varying vec2 vPatchPosition;
+#include<gaussianSplatting>
+void main(void) {float splatIndex=getSplatIndex(int(position.z+0.5));Splat splat=readSplat(splatIndex);
+#if IS_COMPOUND
+if (partVisibility[splat.partIndex]==0.0) {gl_Position=vec4(2.0,2.0,2.0,1.0);return;}
+mat4 splatWorld=getPartWorld(splat.partIndex);
+#else
+mat4 splatWorld=world;
+#endif
+vec4 worldPos=computeVoxelSplatWorldPos(splat.rotationA,splat.rotationB,splat.rotationScale,splat.center.xyz,splatWorld,viewMatrix,invWorldScale,position.xy);gl_Position=viewMatrix*invWorldScale*worldPos;vNormalizedPosition=gl_Position.xyz*0.5+0.5;vec4 viewCenterPos=viewMatrix*invWorldScale*splatWorld*vec4(splat.center.xyz,1.0);vNormalizedCenterPosition=viewCenterPos.xyz*0.5+0.5;vAlpha=splat.color.w*alpha;
+#if IS_COMPOUND
+vAlpha*=partVisibility[splat.partIndex];
+#endif
+vPatchPosition=position.xy;}`;a.ShadersStore[e]||(a.ShadersStore[e]=i);const p=[n,o,r,l,s];for(const t of p)a.IncludesShadersStore[t.name]||(a.IncludesShadersStore[t.name]=t.shader);const m={name:e,shader:i};export{m as gaussianSplattingVoxelVertexShader};

python_cad_tools/_viewer_static/assets/geometry.fragment-CsJIm2H0.js

@@ -0,0 +1,242 @@
+import{S as e,ah as o,am as t,an as d,ao as l,p as c,ap as s,s as E,aq as v,ar as m,as as u,al as S,at as I}from"./index-B2zBEWsq.js";import{s as R,o as T,a as A,b as p,c as D,d as _}from"./openpbrTransmissionLayerData-BDa9qEoN.js";const n="mrtFragmentDeclaration",a=`#if defined(WEBGL2) || defined(WEBGPU) || defined(NATIVE)
+layout(location=0) out vec4 glFragData[{X}];
+#endif
+`;e.IncludesShadersStore[n]||(e.IncludesShadersStore[n]=a);const g={name:n,shader:a},r="geometryPixelShader",f=`#extension GL_EXT_draw_buffers : require
+#if defined(BUMP) || !defined(NORMAL)
+#extension GL_OES_standard_derivatives : enable
+#endif
+precision highp float;
+#ifdef BUMP
+varying mat4 vWorldView;varying vec3 vNormalW;
+#else
+varying vec3 vNormalV;
+#endif
+varying vec4 vViewPos;
+#if defined(POSITION) || defined(BUMP) || defined(IRRADIANCE)
+varying vec3 vPositionW;
+#endif
+#if defined(VELOCITY) || defined(VELOCITY_LINEAR)
+varying vec4 vCurrentPosition;varying vec4 vPreviousPosition;
+#endif
+#ifdef NEED_UV
+varying vec2 vUV;
+#endif
+#ifdef BUMP
+uniform vec3 vBumpInfos;uniform vec2 vTangentSpaceParams;
+#endif
+#if defined(REFLECTIVITY)
+#if defined(ORMTEXTURE) || defined(SPECULARGLOSSINESSTEXTURE) || defined(REFLECTIVITYTEXTURE)
+uniform sampler2D reflectivitySampler;varying vec2 vReflectivityUV;
+#else
+#ifdef METALLIC_TEXTURE
+uniform sampler2D metallicSampler;varying vec2 vMetallicUV;
+#endif
+#ifdef ROUGHNESS_TEXTURE
+uniform sampler2D roughnessSampler;varying vec2 vRoughnessUV;
+#endif
+#endif
+#ifdef ALBEDOTEXTURE
+varying vec2 vAlbedoUV;uniform sampler2D albedoSampler;
+#endif
+#ifdef REFLECTIVITYCOLOR
+uniform vec3 reflectivityColor;
+#endif
+#ifdef ALBEDOCOLOR
+uniform vec3 albedoColor;
+#endif
+#ifdef METALLIC
+uniform float metallic;
+#endif
+#if defined(ROUGHNESS) || defined(GLOSSINESS)
+uniform float glossiness;
+#endif
+#endif
+#if defined(ALPHATEST) && defined(NEED_UV)
+uniform sampler2D diffuseSampler;
+#endif
+#include<clipPlaneFragmentDeclaration>
+#include<mrtFragmentDeclaration>[SCENE_MRT_COUNT]
+#include<bumpFragmentMainFunctions>
+#include<bumpFragmentFunctions>
+#include<helperFunctions>
+#ifdef IRRADIANCE
+#include<pbrFragmentReflectionDeclaration>
+#ifdef REFLECTION
+#ifdef USEIRRADIANCEMAP
+#include<__decl__sceneFragment>
+uniform mat4 reflectionMatrix;uniform vec2 vReflectionInfos;uniform vec3 vReflectionDominantDirection;
+#include<pbrBRDFFunctions>
+#include<openpbrDielectricReflectance>
+#include<pbrIBLFunctions>
+#include<reflectionFunction>
+#include<openpbrGeometryInfo>
+#include<openpbrIblFunctions>
+#elif defined(USESPHERICALFROMREFLECTIONMAP)
+varying vec3 vEnvironmentIrradiance;
+#endif
+#ifdef IBL_SHADOW_TEXTURE
+uniform sampler2D iblShadowSampler;uniform vec2 shadowTextureSize;
+#endif
+#ifdef IRRADIANCE_SCATTER_MASK
+uniform float vSubsurfaceWeight;
+#include<samplerFragmentDeclaration>(_DEFINENAME_,SUBSURFACE_WEIGHT,_VARYINGNAME_,SubsurfaceWeight,_SAMPLERNAME_,subsurfaceWeight)
+uniform float vSubsurfaceScatterAnisotropy;uniform float vTransmissionWeight;
+#include<samplerFragmentDeclaration>(_DEFINENAME_,TRANSMISSION_WEIGHT,_VARYINGNAME_,TransmissionWeight,_SAMPLERNAME_,transmissionWeight)
+uniform float vTransmissionScatterAnisotropy;
+#endif
+#endif
+#endif
+void main() {
+#include<clipPlaneFragment>
+#ifdef ALPHATEST
+if (texture2D(diffuseSampler,vUV).a<0.4)
+discard;
+#endif
+vec3 normalOutput;
+#ifdef BUMP
+vec3 normalW=normalize(vNormalW);
+#include<bumpFragment>
+#ifdef NORMAL_WORLDSPACE
+normalOutput=normalW;
+#else
+normalOutput=normalize(vec3(vWorldView*vec4(normalW,0.0)));
+#endif
+#elif defined(HAS_NORMAL_ATTRIBUTE)
+normalOutput=normalize(vNormalV);
+#elif defined(POSITION)
+normalOutput=normalize(-cross(dFdx(vPositionW),dFdy(vPositionW)));
+#endif
+#ifdef ENCODE_NORMAL
+normalOutput=normalOutput*0.5+0.5;
+#endif
+#ifdef DEPTH
+gl_FragData[DEPTH_INDEX]=vec4(vViewPos.z/vViewPos.w,0.0,0.0,1.0);
+#endif
+#ifdef NORMAL
+gl_FragData[NORMAL_INDEX]=vec4(normalOutput,1.0);
+#endif
+#ifdef SCREENSPACE_DEPTH
+gl_FragData[SCREENSPACE_DEPTH_INDEX]=vec4(gl_FragCoord.z,0.0,0.0,1.0);
+#endif
+#ifdef POSITION
+gl_FragData[POSITION_INDEX]=vec4(vPositionW,1.0);
+#endif
+#ifdef VELOCITY
+vec2 a=(vCurrentPosition.xy/vCurrentPosition.w)*0.5+0.5;vec2 b=(vPreviousPosition.xy/vPreviousPosition.w)*0.5+0.5;vec2 velocity=abs(a-b);velocity=vec2(pow(velocity.x,1.0/3.0),pow(velocity.y,1.0/3.0))*sign(a-b)*0.5+0.5;gl_FragData[VELOCITY_INDEX]=vec4(velocity,0.0,1.0);
+#endif
+#ifdef VELOCITY_LINEAR
+vec2 velocity=vec2(0.5)*((vPreviousPosition.xy/vPreviousPosition.w) -
+(vCurrentPosition.xy/vCurrentPosition.w));gl_FragData[VELOCITY_LINEAR_INDEX]=vec4(velocity,0.0,1.0);
+#endif
+#ifdef REFLECTIVITY
+vec4 reflectivity=vec4(0.0,0.0,0.0,1.0);
+#ifdef METALLICWORKFLOW
+float metal=1.0;float roughness=1.0;
+#ifdef ORMTEXTURE
+metal*=texture2D(reflectivitySampler,vReflectivityUV).b;roughness*=texture2D(reflectivitySampler,vReflectivityUV).g;
+#else
+#ifdef METALLIC_TEXTURE
+metal*=texture2D(metallicSampler,vMetallicUV).r;
+#endif
+#ifdef ROUGHNESS_TEXTURE
+roughness*=texture2D(roughnessSampler,vRoughnessUV).r;
+#endif
+#endif
+#ifdef METALLIC
+metal*=metallic;
+#endif
+#ifdef ROUGHNESS
+roughness*=(1.0-glossiness); 
+#endif
+reflectivity.a-=roughness;vec3 color=vec3(1.0);
+#ifdef ALBEDOTEXTURE
+color=texture2D(albedoSampler,vAlbedoUV).rgb;
+#ifdef GAMMAALBEDO
+color=toLinearSpace(color);
+#endif
+#endif
+#ifdef ALBEDOCOLOR
+color*=albedoColor.xyz;
+#endif
+reflectivity.rgb=mix(vec3(0.04),color,metal);
+#else
+#if defined(SPECULARGLOSSINESSTEXTURE) || defined(REFLECTIVITYTEXTURE)
+reflectivity=texture2D(reflectivitySampler,vReflectivityUV);
+#ifdef GAMMAREFLECTIVITYTEXTURE
+reflectivity.rgb=toLinearSpace(reflectivity.rgb);
+#endif
+#else 
+#ifdef REFLECTIVITYCOLOR
+reflectivity.rgb=toLinearSpace(reflectivityColor.xyz);reflectivity.a=1.0;
+#endif
+#endif
+#ifdef GLOSSINESSS
+reflectivity.a*=glossiness; 
+#endif
+#endif
+gl_FragData[REFLECTIVITY_INDEX]=reflectivity;
+#endif
+#ifdef IRRADIANCE
+vec3 irradiance=vec3(0.0);float irradiance_alpha=1.0;
+#ifdef REFLECTION
+#ifdef IRRADIANCE_SCATTER_MASK
+#ifndef BUMP
+vec2 uvOffset=vec2(0.0);
+#endif
+vec3 vSubsurfaceColor=vec3(1.0);float vSubsurfaceRadius=0.0;vec3 vSubsurfaceRadiusScale=vec3(1.0);
+#include<openpbrSubsurfaceLayerData>
+float vTransmissionDepth=1.0;vec3 vTransmissionColor=vec3(1.0);vec3 vTransmissionScatter=vec3(0.0);float vTransmissionDispersionScale=0.0;float vTransmissionDispersionAbbeNumber=0.0;
+#include<openpbrTransmissionLayerData>
+#endif
+#ifdef IBL_SHADOW_TEXTURE
+#ifdef COLORED_IBL_SHADOWS
+vec3 iblShadowValue=texture(iblShadowSampler,gl_FragCoord.xy/shadowTextureSize).rgb;
+#else
+vec3 iblShadowValue=vec3(texture(iblShadowSampler,gl_FragCoord.xy/shadowTextureSize).r);
+#endif
+#endif
+#if defined(USEIRRADIANCEMAP)
+#ifdef IRRADIANCE_SCATTER_MASK
+float bendAmount=subsurface_weight*-min(subsurface_scatter_anisotropy,0.0);bendAmount=mix(bendAmount,-min(transmission_scatter_anisotropy,0.0),transmission_weight);vec3 viewVector=normalize(vEyePosition.xyz-vPositionW.xyz);vec3 bentNormal=mix(normalOutput,viewVector,bendAmount*dot(normalOutput,viewVector));
+#else
+vec3 bentNormal=normalOutput;
+#endif
+irradiance=sampleIrradiance(
+bentNormal
+#if defined(NORMAL) && defined(USESPHERICALINVERTEX)
+,vEnvironmentIrradiance
+#endif
+#if (defined(USESPHERICALFROMREFLECTIONMAP) && (!defined(NORMAL) || !defined(USESPHERICALINVERTEX))) || (defined(USEIRRADIANCEMAP) && defined(REFLECTIONMAP_3D))
+,reflectionMatrix
+#endif
+#ifdef USEIRRADIANCEMAP
+,irradianceSampler
+#ifdef USE_IRRADIANCE_DOMINANT_DIRECTION
+,vReflectionDominantDirection
+#endif
+#endif
+#ifdef REALTIME_FILTERING
+,vReflectionFilteringInfo
+#ifdef IBL_CDF_FILTERING
+,icdfSampler
+#endif
+#endif
+,vReflectionInfos
+,vViewPos.xyz
+,1.0
+,vec3(1.0)
+);
+#elif defined(USESPHERICALFROMREFLECTIONMAP)
+irradiance=vEnvironmentIrradiance;
+#endif
+#ifdef IBL_SHADOW_TEXTURE
+irradiance*=iblShadowValue;
+#endif
+#ifdef IRRADIANCE_SCATTER_MASK
+irradiance_alpha=min(subsurface_weight+transmission_weight,1.0);
+#endif
+#endif
+gl_FragData[IRRADIANCE_INDEX]=vec4(irradiance,irradiance_alpha);
+#endif
+}
+`;e.ShadersStore[r]||(e.ShadersStore[r]=f);const L=[o,g,t,d,l,c,s,R,E,v,T,m,u,A,p,S,I,D,_];for(const i of L)e.IncludesShadersStore[i.name]||(e.IncludesShadersStore[i.name]=i.shader);const C={name:r,shader:f};export{C as geometryPixelShader};