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

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

@@ -0,0 +1,262 @@
+import{S as e}from"./index-B2zBEWsq.js";import{c as n,a as f}from"./clipPlaneFragment-BXRtt4jj.js";import{b as t,a as o,c as s}from"./bumpFragment-CWULheF1.js";import{s as l,r as d}from"./reflectionFunction-DBlr3oDs.js";import{h as c}from"./helperFunctions-Cugfp1Fz.js";import{p as m,a as v}from"./pbrIBLFunctions-b1zdpzOP.js";import{s as u}from"./sceneUboDeclaration-BzFIc4mb.js";import{p as S}from"./pbrBRDFFunctions-B_ppOzPO.js";import{o as p,a as E,b as R,c as T,d as I}from"./openpbrTransmissionLayerData-Ba_ly4LE.js";const r="geometryPixelShader",a=`#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
+}
+`;e.ShadersStoreWGSL[r]||(e.ShadersStoreWGSL[r]=a);const A=[n,t,l,o,c,m,u,S,p,v,d,E,R,f,s,T,I];for(const i of A)e.IncludesShadersStoreWGSL[i.name]||(e.IncludesShadersStoreWGSL[i.name]=i.shader);const P={name:r,shader:a};export{P as geometryPixelShaderWGSL};

python_cad_tools/_viewer_static/assets/geometry.vertex-BXGMTA_J.js

@@ -0,0 +1,212 @@
+import{S as e}from"./index-B2zBEWsq.js";import{b as n,a as f,m as o,c as v,i as a,d as s,e as d,f as u,g as c,h as l}from"./bakedVertexAnimation-Cd_pRdrn.js";import{s as m}from"./sceneUboDeclaration-BzFIc4mb.js";import{c as p,a as x}from"./clipPlaneVertex-B_VhD1oQ.js";import{h as U}from"./harmonicsFunctions-DzJcvNWG.js";import{b as E}from"./bumpVertex-DqzFZayE.js";const r="geometryVertexShader",t=`#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
+}
+`;e.ShadersStoreWGSL[r]||(e.ShadersStoreWGSL[r]=t);const I=[n,f,o,v,a,m,p,U,s,d,u,c,l,x,E];for(const i of I)e.IncludesShadersStoreWGSL[i.name]||(e.IncludesShadersStoreWGSL[i.name]=i.shader);const T={name:r,shader:t};export{T as geometryVertexShaderWGSL};

python_cad_tools/_viewer_static/assets/geometry.vertex-Bm9Wg3Gi.js

@@ -0,0 +1,214 @@
+import{S as e,aB as f,aC as c,aD as v,aE as s,aF as l,s as u,l as m,aG as U,aH as E,aI as p,aJ as V,aK as S,aL as I,q as h,aM as N}from"./index-B2zBEWsq.js";const n="geometryVertexDeclaration",t="uniform mat4 viewProjection;uniform mat4 view;";e.IncludesShadersStore[n]||(e.IncludesShadersStore[n]=t);const _={name:n,shader:t},r="geometryUboDeclaration",o=`#include<sceneUboDeclaration>
+`;e.IncludesShadersStore[r]||(e.IncludesShadersStore[r]=o);const x={name:r,shader:o},a="geometryVertexShader",d=`precision highp float;
+#include<bonesDeclaration>
+#include<bakedVertexAnimationDeclaration>
+#include<morphTargetsVertexGlobalDeclaration>
+#include<morphTargetsVertexDeclaration>[0..maxSimultaneousMorphTargets]
+#include<instancesDeclaration>
+#include<__decl__geometryVertex>
+#include<clipPlaneVertexDeclaration>
+#ifdef IRRADIANCE
+#ifdef REFLECTION
+uniform mat4 reflectionMatrix;uniform vec2 vReflectionInfos;uniform vec3 vReflectionColor;
+#ifdef USESPHERICALFROMREFLECTIONMAP
+varying vec3 vEnvironmentIrradiance;
+#ifdef SPHERICAL_HARMONICS
+uniform vec3 vSphericalL00;uniform vec3 vSphericalL1_1;uniform vec3 vSphericalL10;uniform vec3 vSphericalL11;uniform vec3 vSphericalL2_2;uniform vec3 vSphericalL2_1;uniform vec3 vSphericalL20;uniform vec3 vSphericalL21;uniform vec3 vSphericalL22;
+#else
+uniform vec3 vSphericalX;uniform vec3 vSphericalY;uniform vec3 vSphericalZ;uniform vec3 vSphericalXX_ZZ;uniform vec3 vSphericalYY_ZZ;uniform vec3 vSphericalZZ;uniform vec3 vSphericalXY;uniform vec3 vSphericalYZ;uniform vec3 vSphericalZX;
+#endif
+#include<harmonicsFunctions>
+#endif
+#endif
+#endif
+attribute vec3 position;
+#ifdef HAS_NORMAL_ATTRIBUTE
+attribute vec3 normal;
+#endif
+#ifdef NEED_UV
+varying vec2 vUV;
+#ifdef ALPHATEST
+uniform mat4 diffuseMatrix;
+#endif
+#ifdef BUMP
+uniform mat4 bumpMatrix;varying vec2 vBumpUV;
+#endif
+#ifdef REFLECTIVITY
+uniform mat4 reflectivityMatrix;uniform mat4 albedoMatrix;varying vec2 vReflectivityUV;varying vec2 vAlbedoUV;
+#endif
+#ifdef METALLIC_TEXTURE
+varying vec2 vMetallicUV;uniform mat4 metallicMatrix;
+#endif
+#ifdef ROUGHNESS_TEXTURE
+varying vec2 vRoughnessUV;uniform mat4 roughnessMatrix;
+#endif
+#ifdef SUBSURFACE_WEIGHT
+varying vec2 vSubsurfaceWeightUV;uniform mat4 subsurfaceWeightMatrix;
+#endif
+#ifdef TRANSMISSION_WEIGHT
+varying vec2 vTransmissionWeightUV;uniform mat4 transmissionWeightMatrix;
+#endif
+#ifdef UV1
+attribute vec2 uv;
+#endif
+#ifdef UV2
+attribute vec2 uv2;
+#endif
+#endif
+#ifdef BUMP
+varying mat4 vWorldView;
+#endif
+#ifdef BUMP
+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)
+uniform mat4 previousViewProjection;varying vec4 vCurrentPosition;varying vec4 vPreviousPosition;
+#endif
+#define CUSTOM_VERTEX_DEFINITIONS
+void main(void)
+{vec3 positionUpdated=position;
+#ifdef HAS_NORMAL_ATTRIBUTE
+vec3 normalUpdated=normal;
+#else
+vec3 normalUpdated=vec3(0.0,0.0,0.0);
+#endif
+#ifdef UV1
+vec2 uvUpdated=uv;
+#endif
+#ifdef UV2
+vec2 uv2Updated=uv2;
+#endif
+#include<morphTargetsVertexGlobal>
+#include<morphTargetsVertex>[0..maxSimultaneousMorphTargets]
+#include<instancesVertex>
+#if (defined(VELOCITY) || defined(VELOCITY_LINEAR)) && !defined(BONES_VELOCITY_ENABLED)
+vCurrentPosition=viewProjection*finalWorld*vec4(positionUpdated,1.0);vPreviousPosition=previousViewProjection*finalPreviousWorld*vec4(positionUpdated,1.0);
+#endif
+#include<bonesVertex>
+#include<bakedVertexAnimation>
+vec4 worldPos=vec4(finalWorld*vec4(positionUpdated,1.0));
+#ifdef BUMP
+vWorldView=view*finalWorld;mat3 normalWorld=mat3(finalWorld);vNormalW=normalize(normalWorld*normalUpdated);
+#else
+#ifdef NORMAL_WORLDSPACE
+vNormalV=normalize(vec3(finalWorld*vec4(normalUpdated,0.0)));
+#else
+vNormalV=normalize(vec3((view*finalWorld)*vec4(normalUpdated,0.0)));
+#endif
+#endif
+vViewPos=view*worldPos;
+#if (defined(VELOCITY) || defined(VELOCITY_LINEAR)) && defined(BONES_VELOCITY_ENABLED)
+vCurrentPosition=viewProjection*finalWorld*vec4(positionUpdated,1.0);
+#if NUM_BONE_INFLUENCERS>0
+mat4 previousInfluence;previousInfluence=mPreviousBones[int(matricesIndices[0])]*matricesWeights[0];
+#if NUM_BONE_INFLUENCERS>1
+previousInfluence+=mPreviousBones[int(matricesIndices[1])]*matricesWeights[1];
+#endif
+#if NUM_BONE_INFLUENCERS>2
+previousInfluence+=mPreviousBones[int(matricesIndices[2])]*matricesWeights[2];
+#endif
+#if NUM_BONE_INFLUENCERS>3
+previousInfluence+=mPreviousBones[int(matricesIndices[3])]*matricesWeights[3];
+#endif
+#if NUM_BONE_INFLUENCERS>4
+previousInfluence+=mPreviousBones[int(matricesIndicesExtra[0])]*matricesWeightsExtra[0];
+#endif
+#if NUM_BONE_INFLUENCERS>5
+previousInfluence+=mPreviousBones[int(matricesIndicesExtra[1])]*matricesWeightsExtra[1];
+#endif
+#if NUM_BONE_INFLUENCERS>6
+previousInfluence+=mPreviousBones[int(matricesIndicesExtra[2])]*matricesWeightsExtra[2];
+#endif
+#if NUM_BONE_INFLUENCERS>7
+previousInfluence+=mPreviousBones[int(matricesIndicesExtra[3])]*matricesWeightsExtra[3];
+#endif
+vPreviousPosition=previousViewProjection*finalPreviousWorld*previousInfluence*vec4(positionUpdated,1.0);
+#else
+vPreviousPosition=previousViewProjection*finalPreviousWorld*vec4(positionUpdated,1.0);
+#endif
+#endif
+#if defined(POSITION) || defined(BUMP) || defined(IRRADIANCE)
+vPositionW=worldPos.xyz/worldPos.w;
+#endif
+gl_Position=viewProjection*finalWorld*vec4(positionUpdated,1.0);
+#include<clipPlaneVertex>
+#ifdef NEED_UV
+#ifdef UV1
+#if defined(ALPHATEST) && defined(ALPHATEST_UV1)
+vUV=vec2(diffuseMatrix*vec4(uvUpdated,1.0,0.0));
+#else
+vUV=uvUpdated;
+#endif
+#ifdef BUMP_UV1
+vBumpUV=vec2(bumpMatrix*vec4(uvUpdated,1.0,0.0));
+#endif
+#ifdef REFLECTIVITY_UV1
+vReflectivityUV=vec2(reflectivityMatrix*vec4(uvUpdated,1.0,0.0));
+#else
+#ifdef METALLIC_UV1
+vMetallicUV=vec2(metallicMatrix*vec4(uvUpdated,1.0,0.0));
+#endif
+#ifdef ROUGHNESS_UV1
+vRoughnessUV=vec2(roughnessMatrix*vec4(uvUpdated,1.0,0.0));
+#endif
+#endif
+#ifdef ALBEDO_UV1
+vAlbedoUV=vec2(albedoMatrix*vec4(uvUpdated,1.0,0.0));
+#endif
+#ifdef SUBSURFACE_COLOR_UV1
+vSubsurfaceColorUV=vec2(subsurfaceColorMatrix*vec4(uvUpdated,1.0,0.0));
+#endif
+#ifdef SUBSURFACE_WEIGHT_UV1
+vSubsurfaceWeightUV=vec2(subsurfaceWeightMatrix*vec4(uvUpdated,1.0,0.0));
+#endif
+#endif
+#ifdef UV2
+#if defined(ALPHATEST) && defined(ALPHATEST_UV2)
+vUV=vec2(diffuseMatrix*vec4(uv2Updated,1.0,0.0));
+#else
+vUV=uv2Updated;
+#endif
+#ifdef BUMP_UV2
+vBumpUV=vec2(bumpMatrix*vec4(uv2Updated,1.0,0.0));
+#endif
+#ifdef REFLECTIVITY_UV2
+vReflectivityUV=vec2(reflectivityMatrix*vec4(uv2Updated,1.0,0.0));
+#else
+#ifdef METALLIC_UV2
+vMetallicUV=vec2(metallicMatrix*vec4(uv2Updated,1.0,0.0));
+#endif
+#ifdef ROUGHNESS_UV2
+vRoughnessUV=vec2(roughnessMatrix*vec4(uv2Updated,1.0,0.0));
+#endif
+#endif
+#ifdef ALBEDO_UV2
+vAlbedoUV=vec2(albedoMatrix*vec4(uv2Updated,1.0,0.0));
+#endif
+#ifdef SUBSURFACE_COLOR_UV2
+vSubsurfaceColorUV=vec2(subsurfaceColorMatrix*vec4(uv2Updated,1.0,0.0));
+#endif
+#ifdef SUBSURFACE_WEIGHT_UV2
+vSubsurfaceWeightUV=vec2(subsurfaceWeightMatrix*vec4(uv2Updated,1.0,0.0));
+#endif
+#endif
+#endif
+#include<bumpVertex>
+#ifdef IRRADIANCE
+#ifdef REFLECTION
+#ifdef USESPHERICALFROMREFLECTIONMAP
+vec3 reflectionVector=vec3(reflectionMatrix*vec4(normalUpdated,0.0)).xyz;
+#ifdef REFLECTIONMAP_OPPOSITEZ
+reflectionVector.z*=-1.0;
+#endif
+vEnvironmentIrradiance=computeEnvironmentIrradiance(reflectionVector)*vReflectionInfos.x;
+#endif
+#endif
+#endif
+}
+`;e.ShadersStore[a]||(e.ShadersStore[a]=d);const P=[f,c,v,s,l,_,u,x,m,U,E,p,V,S,I,h,N];for(const i of P)e.IncludesShadersStore[i.name]||(e.IncludesShadersStore[i.name]=i.shader);const M={name:a,shader:d};export{M as geometryVertexShader};

python_cad_tools/_viewer_static/assets/glowBlurPostProcess.fragment-BJSwKIJD.js

@@ -0,0 +1,7 @@
+import{S as r}from"./index-B2zBEWsq.js";const e="glowBlurPostProcessPixelShader",t=`varying vUV: vec2f;var textureSamplerSampler: sampler;var textureSampler: texture_2d<f32>;uniform screenSize: vec2f;uniform direction: vec2f;uniform blurWidth: f32;fn getLuminance(color: vec3f)->f32
+{return dot(color, vec3f(0.2126,0.7152,0.0722));}
+#define CUSTOM_FRAGMENT_DEFINITIONS
+@fragment
+fn main(input: FragmentInputs)->FragmentOutputs {var weights: array<f32 ,7>;weights[0]=0.05;weights[1]=0.1;weights[2]=0.2;weights[3]=0.3;weights[4]=0.2;weights[5]=0.1;weights[6]=0.05;var texelSize: vec2f= vec2f(1.0/uniforms.screenSize.x,1.0/uniforms.screenSize.y);var texelStep: vec2f=texelSize*uniforms.direction*uniforms.blurWidth;var start: vec2f=input.vUV-3.0*texelStep;var baseColor: vec4f= vec4f(0.,0.,0.,0.);var texelOffset: vec2f= vec2f(0.,0.);for (var i: i32=0; i<7; i++)
+{var texel: vec4f=textureSample(textureSampler,textureSamplerSampler,start+texelOffset);baseColor=vec4f(baseColor.rgb,baseColor.a+texel.a*weights[i]);var luminance: f32=getLuminance(baseColor.rgb);var luminanceTexel: f32=getLuminance(texel.rgb);var choice: f32=step(luminanceTexel,luminance);baseColor=vec4f(choice*baseColor.rgb+(1.0-choice)*texel.rgb,baseColor.a);texelOffset+=texelStep;}
+fragmentOutputs.color=baseColor;}`;r.ShadersStoreWGSL[e]||(r.ShadersStoreWGSL[e]=t);const o={name:e,shader:t};export{o as glowBlurPostProcessPixelShaderWGSL};