@onerjs/core 8.56.4 → 9.0.1

package/ShadersWGSL/geometry.fragment.js

@@ -65,12 +65,15 @@ uniform glossiness: f32;
 #endif
 #endif
 #if defined(ALPHATEST) && defined(NEED_UV)
-var diffuseSamplerSampler: sampler;var diffuseSampler: texture_2d<f32>;
+var diffuseSamplerSampler: sampler;var diffuseSampler: texture_2d<f32>;uniform alphaCutOff: f32;
 #endif
 #ifdef OBJECT_ID
 uniform objectId: f32;
 #include<objectIdFunctions>
 #endif
+#ifdef MESH_BLEND_TAG
+uniform meshBlendTag: i32;
+#endif
 #include<clipPlaneFragmentDeclaration>
 #include<bumpFragmentMainFunctions>
 #include<bumpFragmentFunctions>
@@ -106,7 +109,7 @@ uniform vTransmissionScatterAnisotropy: f32;
 fn main(input: FragmentInputs)->FragmentOutputs {
 #include<clipPlaneFragment>
 #ifdef ALPHATEST
-if (textureSample(diffuseSampler,diffuseSamplerSampler,input.vUV).a<0.4) {discard;}
+if (textureSample(diffuseSampler,diffuseSamplerSampler,input.vUV).a<uniforms.alphaCutOff) {discard;}
 #endif
 var normalOutput: vec3f;
 #ifdef BUMP
@@ -263,29 +266,61 @@ irradiance_alpha=min(subsurface_weight+transmission_weight,1.0);
 fragData[IRRADIANCE_INDEX]=vec4f(irradiance,irradiance_alpha);
 #endif
 #if SCENE_MRT_COUNT>0
+#if defined(MESH_BLEND_TAG) && MESH_BLEND_TAG_INDEX==0
+fragmentOutputs.fragData0=vec4u(u32(uniforms.meshBlendTag),0u,0u,0u);
+#else
 fragmentOutputs.fragData0=fragData[0];
 #endif
+#endif
 #if SCENE_MRT_COUNT>1
+#if defined(MESH_BLEND_TAG) && MESH_BLEND_TAG_INDEX==1
+fragmentOutputs.fragData1=vec4u(u32(uniforms.meshBlendTag),0u,0u,0u);
+#else
 fragmentOutputs.fragData1=fragData[1];
 #endif
+#endif
 #if SCENE_MRT_COUNT>2
+#if defined(MESH_BLEND_TAG) && MESH_BLEND_TAG_INDEX==2
+fragmentOutputs.fragData2=vec4u(u32(uniforms.meshBlendTag),0u,0u,0u);
+#else
 fragmentOutputs.fragData2=fragData[2];
 #endif
+#endif
 #if SCENE_MRT_COUNT>3
+#if defined(MESH_BLEND_TAG) && MESH_BLEND_TAG_INDEX==3
+fragmentOutputs.fragData3=vec4u(u32(uniforms.meshBlendTag),0u,0u,0u);
+#else
 fragmentOutputs.fragData3=fragData[3];
 #endif
+#endif
 #if SCENE_MRT_COUNT>4
+#if defined(MESH_BLEND_TAG) && MESH_BLEND_TAG_INDEX==4
+fragmentOutputs.fragData4=vec4u(u32(uniforms.meshBlendTag),0u,0u,0u);
+#else
 fragmentOutputs.fragData4=fragData[4];
 #endif
+#endif
 #if SCENE_MRT_COUNT>5
+#if defined(MESH_BLEND_TAG) && MESH_BLEND_TAG_INDEX==5
+fragmentOutputs.fragData5=vec4u(u32(uniforms.meshBlendTag),0u,0u,0u);
+#else
 fragmentOutputs.fragData5=fragData[5];
 #endif
+#endif
 #if SCENE_MRT_COUNT>6
+#if defined(MESH_BLEND_TAG) && MESH_BLEND_TAG_INDEX==6
+fragmentOutputs.fragData6=vec4u(u32(uniforms.meshBlendTag),0u,0u,0u);
+#else
 fragmentOutputs.fragData6=fragData[6];
 #endif
+#endif
 #if SCENE_MRT_COUNT>7
+#if defined(MESH_BLEND_TAG) && MESH_BLEND_TAG_INDEX==7
+fragmentOutputs.fragData7=vec4u(u32(uniforms.meshBlendTag),0u,0u,0u);
+#else
 fragmentOutputs.fragData7=fragData[7];
 #endif
+#endif
 }
 `;
 // Sideeffect

package/ShadersWGSL/geometry.fragment.js.map

@@ -1 +1 @@
-{"version":3,"file":"geometry.fragment.js","sourceRoot":"","sources":["../../../../dev/core/src/ShadersWGSL/geometry.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAC3E,OAAO,EAAE,gCAAgC,EAAE,MAAM,+CAA+C,CAAC;AACjG,OAAO,EAAE,6BAA6B,EAAE,MAAM,4CAA4C,CAAC;AAC3F,OAAO,EAAE,8BAA8B,EAAE,MAAM,6CAA6C,CAAC;AAC7F,OAAO,EAAE,yBAAyB,EAAE,MAAM,wCAAwC,CAAC;AACnF,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AACvE,OAAO,EAAE,oCAAoC,EAAE,MAAM,mDAAmD,CAAC;AACzG,OAAO,EAAE,uBAAuB,EAAE,MAAM,sCAAsC,CAAC;AAC/E,OAAO,EAAE,oBAAoB,EAAE,MAAM,mCAAmC,CAAC;AACzE,OAAO,EAAE,gCAAgC,EAAE,MAAM,+CAA+C,CAAC;AACjG,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AACvE,OAAO,EAAE,sBAAsB,EAAE,MAAM,qCAAqC,CAAC;AAC7E,OAAO,EAAE,uBAAuB,EAAE,MAAM,sCAAsC,CAAC;AAC/E,OAAO,EAAE,uBAAuB,EAAE,MAAM,sCAAsC,CAAC;AAC/E,OAAO,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAC3E,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AACjE,OAAO,EAAE,8BAA8B,EAAE,MAAM,6CAA6C,CAAC;AAC7F,OAAO,EAAE,gCAAgC,EAAE,MAAM,+CAA+C,CAAC;AAEjG,MAAM,IAAI,GAAG,qBAAqB,CAAC;AACnC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4Qd,CAAC;AACF,aAAa;AACb,IAAI,CAAC,WAAW,CAAC,gBAAgB,CAAC,IAAI,CAAC,EAAE,CAAC;IACtC,WAAW,CAAC,gBAAgB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,CAAC;AACD,MAAM,QAAQ,GAAG,CAAC,qBAAqB,EAAE,gCAAgC,EAAE,6BAA6B,EAAE,8BAA8B,EAAE,yBAAyB,EAAE,mBAAmB,EAAE,oCAAoC,EAAE,uBAAuB,EAAE,oBAAoB,EAAE,gCAAgC,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,uBAAuB,EAAE,uBAAuB,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,8BAA8B,EAAE,gCAAgC,CAAC,CAAC;AAC3f,KAAK,MAAM,GAAG,IAAI,QAAQ,EAAE,CAAC;IACzB,IAAI,CAAC,WAAW,CAAC,wBAAwB,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;QAClD,WAAW,CAAC,wBAAwB,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC;IAChE,CAAC;AACL,CAAC;AAED,gBAAgB;AAChB,MAAM,CAAC,MAAM,uBAAuB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\nimport { objectIdFunctionsWGSL } from \"./ShadersInclude/objectIdFunctions\";\nimport { clipPlaneFragmentDeclarationWGSL } from \"./ShadersInclude/clipPlaneFragmentDeclaration\";\nimport { bumpFragmentMainFunctionsWGSL } from \"./ShadersInclude/bumpFragmentMainFunctions\";\nimport { samplerFragmentDeclarationWGSL } from \"./ShadersInclude/samplerFragmentDeclaration\";\nimport { bumpFragmentFunctionsWGSL } from \"./ShadersInclude/bumpFragmentFunctions\";\nimport { helperFunctionsWGSL } from \"./ShadersInclude/helperFunctions\";\nimport { pbrFragmentReflectionDeclarationWGSL } from \"./ShadersInclude/pbrFragmentReflectionDeclaration\";\nimport { sceneUboDeclarationWGSL } from \"./ShadersInclude/sceneUboDeclaration\";\nimport { pbrBRDFFunctionsWGSL } from \"./ShadersInclude/pbrBRDFFunctions\";\nimport { openpbrDielectricReflectanceWGSL } from \"./ShadersInclude/openpbrDielectricReflectance\";\nimport { pbrIBLFunctionsWGSL } from \"./ShadersInclude/pbrIBLFunctions\";\nimport { reflectionFunctionWGSL } from \"./ShadersInclude/reflectionFunction\";\nimport { openpbrGeometryInfoWGSL } from \"./ShadersInclude/openpbrGeometryInfo\";\nimport { openpbrIblFunctionsWGSL } from \"./ShadersInclude/openpbrIblFunctions\";\nimport { clipPlaneFragmentWGSL } from \"./ShadersInclude/clipPlaneFragment\";\nimport { bumpFragmentWGSL } from \"./ShadersInclude/bumpFragment\";\nimport { openpbrSubsurfaceLayerDataWGSL } from \"./ShadersInclude/openpbrSubsurfaceLayerData\";\nimport { openpbrTransmissionLayerDataWGSL } from \"./ShadersInclude/openpbrTransmissionLayerData\";\n\nconst name = \"geometryPixelShader\";\nconst shader = `#ifdef BUMP\nvarying vWorldView0: vec4f;varying vWorldView1: vec4f;varying vWorldView2: vec4f;varying vWorldView3: vec4f;varying vNormalW: vec3f;\n#else\nvarying vNormalV: vec3f;\n#endif\nvarying vViewPos: vec4f;\n#if defined(POSITION) || defined(BUMP) || defined(IRRADIANCE)\nvarying vPositionW: vec3f;\n#endif\n#if defined(VELOCITY) || defined(VELOCITY_LINEAR)\nvarying vCurrentPosition: vec4f;varying vPreviousPosition: vec4f;\n#endif\n#ifdef NEED_UV\nvarying vUV: vec2f;\n#endif\n#ifdef BUMP\nuniform vBumpInfos: vec3f;uniform vTangentSpaceParams: vec2f;\n#endif\n#if defined(REFLECTIVITY)\n#if defined(ORMTEXTURE) || defined(SPECULARGLOSSINESSTEXTURE) || defined(REFLECTIVITYTEXTURE)\nvar reflectivitySamplerSampler: sampler;var reflectivitySampler: texture_2d<f32>;varying vReflectivityUV: vec2f;\n#else\n#ifdef METALLIC_TEXTURE\nvar metallicSamplerSampler: sampler;var metallicSampler: texture_2d<f32>;varying vMetallicUV: vec2f;\n#endif\n#ifdef ROUGHNESS_TEXTURE\nvar roughnessSamplerSampler: sampler;var roughnessSampler: texture_2d<f32>;varying vRoughnessUV: vec2f;\n#endif\n#endif\n#ifdef ALBEDOTEXTURE\nvarying vAlbedoUV: vec2f;var albedoSamplerSampler: sampler;var albedoSampler: texture_2d<f32>;\n#endif\n#ifdef REFLECTIVITYCOLOR\nuniform reflectivityColor: vec3f;\n#endif\n#ifdef ALBEDOCOLOR\nuniform albedoColor: vec3f;\n#endif\n#ifdef METALLIC\nuniform metallic: f32;\n#endif\n#if defined(ROUGHNESS) || defined(GLOSSINESS)\nuniform glossiness: f32;\n#endif\n#endif\n#if defined(ALPHATEST) && defined(NEED_UV)\nvar diffuseSamplerSampler: sampler;var diffuseSampler: texture_2d<f32>;\n#endif\n#ifdef OBJECT_ID\nuniform objectId: f32;\n#include<objectIdFunctions>\n#endif\n#include<clipPlaneFragmentDeclaration>\n#include<bumpFragmentMainFunctions>\n#include<bumpFragmentFunctions>\n#include<helperFunctions>\n#ifdef IRRADIANCE\n#include<pbrFragmentReflectionDeclaration>\n#ifdef REFLECTION\n#ifdef USEIRRADIANCEMAP\n#include<sceneUboDeclaration>\nuniform reflectionMatrix: mat4x4f;uniform vReflectionInfos: vec2f;uniform vReflectionDominantDirection: vec3f;\n#include<pbrBRDFFunctions>\n#include<openpbrDielectricReflectance>\n#include<pbrIBLFunctions>\n#include<reflectionFunction>\n#include<openpbrGeometryInfo>\n#include<openpbrIblFunctions>\n#elif defined(USESPHERICALFROMREFLECTIONMAP)\nvarying vEnvironmentIrradiance: vec3f;\n#endif\n#ifdef IBL_SHADOW_TEXTURE\nvar iblShadowSampler: texture_2d<f32>;var iblShadowSamplerSampler: sampler;uniform shadowTextureSize: vec2f;\n#endif\n#ifdef IRRADIANCE_SCATTER_MASK\nuniform vSubsurfaceWeight: f32;\n#include<samplerFragmentDeclaration>(_DEFINENAME_,SUBSURFACE_WEIGHT,_VARYINGNAME_,SubsurfaceWeight,_SAMPLERNAME_,subsurfaceWeight)\nuniform vSubsurfaceScatterAnisotropy: f32;uniform vTransmissionWeight: f32;\n#include<samplerFragmentDeclaration>(_DEFINENAME_,TRANSMISSION_WEIGHT,_VARYINGNAME_,TransmissionWeight,_SAMPLERNAME_,transmissionWeight)\nuniform vTransmissionScatterAnisotropy: f32;\n#endif\n#endif\n#endif\n@fragment\nfn main(input: FragmentInputs)->FragmentOutputs {\n#include<clipPlaneFragment>\n#ifdef ALPHATEST\nif (textureSample(diffuseSampler,diffuseSamplerSampler,input.vUV).a<0.4) {discard;}\n#endif\nvar normalOutput: vec3f;\n#ifdef BUMP\nvar normalW: vec3f=normalize(input.vNormalW);\n#include<bumpFragment>\n#ifdef NORMAL_WORLDSPACE\nnormalOutput=normalW;\n#else\nnormalOutput=normalize( (mat4x4f(input.vWorldView0,input.vWorldView1,input.vWorldView2,input.vWorldView3)* vec4f(normalW,0.0)).xyz);\n#endif\n#elif defined(HAS_NORMAL_ATTRIBUTE)\nnormalOutput=normalize(input.vNormalV);\n#elif defined(POSITION)\nnormalOutput=normalize(-cross(dpdx(input.vPositionW),dpdy(input.vPositionW)));\n#endif\n#ifdef ENCODE_NORMAL\nnormalOutput=normalOutput*0.5+0.5;\n#endif\nvar fragData: array<vec4<f32>,SCENE_MRT_COUNT>;\n#ifdef DEPTH\nfragData[DEPTH_INDEX]=vec4f(input.vViewPos.z/input.vViewPos.w,0.0,0.0,1.0);\n#endif\n#ifdef NORMAL\nfragData[NORMAL_INDEX]=vec4f(normalOutput,1.0);\n#endif\n#ifdef SCREENSPACE_DEPTH\nfragData[SCREENSPACE_DEPTH_INDEX]=vec4f(fragmentInputs.position.z,0.0,0.0,1.0);\n#endif\n#ifdef POSITION\nfragData[POSITION_INDEX]= vec4f(input.vPositionW,1.0);\n#endif\n#ifdef OBJECT_ID\nfragData[OBJECT_ID_INDEX]=encodeObjectId(uniforms.objectId);\n#endif\n#ifdef VELOCITY\nvar 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);\n#endif\n#ifdef VELOCITY_LINEAR\nvar velocity : vec2f=vec2f(0.5)*((input.vPreviousPosition.xy /\ninput.vPreviousPosition.w) -\n(input.vCurrentPosition.xy /\ninput.vCurrentPosition.w));fragData[VELOCITY_LINEAR_INDEX]=vec4f(velocity,0.0,1.0);\n#endif\n#ifdef REFLECTIVITY\nvar reflectivity: vec4f= vec4f(0.0,0.0,0.0,1.0);\n#ifdef METALLICWORKFLOW\nvar metal: f32=1.0;var roughness: f32=1.0;\n#ifdef ORMTEXTURE\nmetal*=textureSample(reflectivitySampler,reflectivitySamplerSampler,input.vReflectivityUV).b;roughness*=textureSample(reflectivitySampler,reflectivitySamplerSampler,input.vReflectivityUV).g;\n#else\n#ifdef METALLIC_TEXTURE\nmetal*=textureSample(metallicSampler,metallicSamplerSampler,input.vMetallicUV).r;\n#endif\n#ifdef ROUGHNESS_TEXTURE\nroughness*=textureSample(roughnessSampler,roughnessSamplerSampler,input.vRoughnessUV).r;\n#endif\n#endif\n#ifdef METALLIC\nmetal*=uniforms.metallic;\n#endif\n#ifdef ROUGHNESS\nroughness*=(1.0-uniforms.glossiness); \n#endif\nreflectivity=vec4f(reflectivity.rgb,reflectivity.a-roughness);var color: vec3f= vec3f(1.0);\n#ifdef ALBEDOTEXTURE\ncolor=textureSample(albedoSampler,albedoSamplerSampler,input.vAlbedoUV).rgb;\n#ifdef GAMMAALBEDO\ncolor=toLinearSpaceVec4(color);\n#endif\n#endif\n#ifdef ALBEDOCOLOR\ncolor*=uniforms.albedoColor.xyz;\n#endif\nreflectivity=vec4f(mix( vec3f(0.04),color,metal),reflectivity.a);\n#else\n#if defined(SPECULARGLOSSINESSTEXTURE) || defined(REFLECTIVITYTEXTURE)\nreflectivity=textureSample(reflectivitySampler,reflectivitySamplerSampler,input.vReflectivityUV);\n#ifdef GAMMAREFLECTIVITYTEXTURE\nreflectivity=vec4f(toLinearSpaceVec3(reflectivity.rgb),reflectivity.a);\n#endif\n#else \n#ifdef REFLECTIVITYCOLOR\nreflectivity=vec4f(toLinearSpaceVec3(uniforms.reflectivityColor.xyz),1.0);\n#endif\n#endif\n#ifdef GLOSSINESSS\nreflectivity=vec4f(reflectivity.rgb,reflectivity.a*glossiness); \n#endif\n#endif\nfragData[REFLECTIVITY_INDEX]=reflectivity;\n#endif\n#ifdef IRRADIANCE\nvar irradiance: vec3f=vec3f(0.0);var irradiance_alpha: f32=1.0;\n#ifdef REFLECTION\n#ifdef IRRADIANCE_SCATTER_MASK\n#ifndef BUMP\nlet uvOffset: vec2f=vec2f(0.0);\n#endif\nvar vSubsurfaceColor: vec3f=vec3f(1.0);var vSubsurfaceRadius: f32=0.0;var vSubsurfaceRadiusScale: vec3f=vec3f(1.0);\n#include<openpbrSubsurfaceLayerData>(uniforms.vSubsurfaceColor,vSubsurfaceColor,uniforms.vSubsurfaceRadius,vSubsurfaceRadius,uniforms.vSubsurfaceRadiusScale,vSubsurfaceRadiusScale)\nvar 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;\n#include<openpbrTransmissionLayerData>(uniforms.vTransmissionDispersionScale,vTransmissionDispersionScale,uniforms.vTransmissionDispersionAbbeNumber,vTransmissionDispersionAbbeNumber,uniforms.vTransmissionColor,vTransmissionColor,uniforms.vTransmissionDepth,vTransmissionDepth,uniforms.vTransmissionScatter\\\\.,vTransmissionScatter.)\n#endif\n#ifdef IBL_SHADOW_TEXTURE\n#ifdef COLORED_IBL_SHADOWS\nlet iblShadowValue: vec3f=textureSample(iblShadowSampler,iblShadowSamplerSampler,fragmentInputs.position.xy/uniforms.shadowTextureSize).rgb;\n#else\nlet iblShadowValue: vec3f=vec3f(textureSample(iblShadowSampler,iblShadowSamplerSampler,fragmentInputs.position.xy/uniforms.shadowTextureSize).r);\n#endif\n#endif\n#if defined(USEIRRADIANCEMAP)\n#ifdef IRRADIANCE_SCATTER_MASK\nlet 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));\n#else\nlet bentNormal: vec3f=normalOutput;\n#endif\nirradiance=sampleIrradiance(\nbentNormal\n#if defined(NORMAL) && defined(USESPHERICALINVERTEX)\n,input.vEnvironmentIrradiance\n#endif\n#if (defined(USESPHERICALFROMREFLECTIONMAP) && (!defined(NORMAL) || !defined(USESPHERICALINVERTEX))) || (defined(USEIRRADIANCEMAP) && defined(REFLECTIONMAP_3D))\n,uniforms.reflectionMatrix\n#endif\n#ifdef USEIRRADIANCEMAP\n,irradianceSampler\n,irradianceSamplerSampler\n#ifdef USE_IRRADIANCE_DOMINANT_DIRECTION\n,uniforms.vReflectionDominantDirection\n#endif\n#endif\n#ifdef REALTIME_FILTERING\n,uniforms.vReflectionFilteringInfo\n#ifdef IBL_CDF_FILTERING\n,icdfSampler\n,icdfSamplerSampler\n#endif\n#endif\n,uniforms.vReflectionInfos\n,input.vViewPos.xyz\n,1.0\n,vec3f(1.0)\n);\n#elif defined(USESPHERICALFROMREFLECTIONMAP)\nirradiance=input.vEnvironmentIrradiance;\n#endif\n#ifdef IBL_SHADOW_TEXTURE\nirradiance*=iblShadowValue;\n#endif\n#ifdef IRRADIANCE_SCATTER_MASK\nirradiance_alpha=min(subsurface_weight+transmission_weight,1.0);\n#endif\n#endif\nfragData[IRRADIANCE_INDEX]=vec4f(irradiance,irradiance_alpha);\n#endif\n#if SCENE_MRT_COUNT>0\nfragmentOutputs.fragData0=fragData[0];\n#endif\n#if SCENE_MRT_COUNT>1\nfragmentOutputs.fragData1=fragData[1];\n#endif\n#if SCENE_MRT_COUNT>2\nfragmentOutputs.fragData2=fragData[2];\n#endif\n#if SCENE_MRT_COUNT>3\nfragmentOutputs.fragData3=fragData[3];\n#endif\n#if SCENE_MRT_COUNT>4\nfragmentOutputs.fragData4=fragData[4];\n#endif\n#if SCENE_MRT_COUNT>5\nfragmentOutputs.fragData5=fragData[5];\n#endif\n#if SCENE_MRT_COUNT>6\nfragmentOutputs.fragData6=fragData[6];\n#endif\n#if SCENE_MRT_COUNT>7\nfragmentOutputs.fragData7=fragData[7];\n#endif\n}\n`;\n// Sideeffect\nif (!ShaderStore.ShadersStoreWGSL[name]) {\n    ShaderStore.ShadersStoreWGSL[name] = shader;\n}\nconst includes = [objectIdFunctionsWGSL, clipPlaneFragmentDeclarationWGSL, bumpFragmentMainFunctionsWGSL, samplerFragmentDeclarationWGSL, bumpFragmentFunctionsWGSL, helperFunctionsWGSL, pbrFragmentReflectionDeclarationWGSL, sceneUboDeclarationWGSL, pbrBRDFFunctionsWGSL, openpbrDielectricReflectanceWGSL, pbrIBLFunctionsWGSL, reflectionFunctionWGSL, openpbrGeometryInfoWGSL, openpbrIblFunctionsWGSL, clipPlaneFragmentWGSL, bumpFragmentWGSL, openpbrSubsurfaceLayerDataWGSL, openpbrTransmissionLayerDataWGSL];\nfor (const inc of includes) {\n    if (!ShaderStore.IncludesShadersStoreWGSL[inc.name]) {\n        ShaderStore.IncludesShadersStoreWGSL[inc.name] = inc.shader;\n    }\n}\n\n/** @internal */\nexport const geometryPixelShaderWGSL = { name, shader };\n"]}
+{"version":3,"file":"geometry.fragment.js","sourceRoot":"","sources":["../../../../dev/core/src/ShadersWGSL/geometry.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAC3E,OAAO,EAAE,gCAAgC,EAAE,MAAM,+CAA+C,CAAC;AACjG,OAAO,EAAE,6BAA6B,EAAE,MAAM,4CAA4C,CAAC;AAC3F,OAAO,EAAE,8BAA8B,EAAE,MAAM,6CAA6C,CAAC;AAC7F,OAAO,EAAE,yBAAyB,EAAE,MAAM,wCAAwC,CAAC;AACnF,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AACvE,OAAO,EAAE,oCAAoC,EAAE,MAAM,mDAAmD,CAAC;AACzG,OAAO,EAAE,uBAAuB,EAAE,MAAM,sCAAsC,CAAC;AAC/E,OAAO,EAAE,oBAAoB,EAAE,MAAM,mCAAmC,CAAC;AACzE,OAAO,EAAE,gCAAgC,EAAE,MAAM,+CAA+C,CAAC;AACjG,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AACvE,OAAO,EAAE,sBAAsB,EAAE,MAAM,qCAAqC,CAAC;AAC7E,OAAO,EAAE,uBAAuB,EAAE,MAAM,sCAAsC,CAAC;AAC/E,OAAO,EAAE,uBAAuB,EAAE,MAAM,sCAAsC,CAAC;AAC/E,OAAO,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAC3E,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AACjE,OAAO,EAAE,8BAA8B,EAAE,MAAM,6CAA6C,CAAC;AAC7F,OAAO,EAAE,gCAAgC,EAAE,MAAM,+CAA+C,CAAC;AAEjG,MAAM,IAAI,GAAG,qBAAqB,CAAC;AACnC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+Sd,CAAC;AACF,aAAa;AACb,IAAI,CAAC,WAAW,CAAC,gBAAgB,CAAC,IAAI,CAAC,EAAE,CAAC;IACtC,WAAW,CAAC,gBAAgB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,CAAC;AACD,MAAM,QAAQ,GAAG,CAAC,qBAAqB,EAAE,gCAAgC,EAAE,6BAA6B,EAAE,8BAA8B,EAAE,yBAAyB,EAAE,mBAAmB,EAAE,oCAAoC,EAAE,uBAAuB,EAAE,oBAAoB,EAAE,gCAAgC,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,uBAAuB,EAAE,uBAAuB,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,8BAA8B,EAAE,gCAAgC,CAAC,CAAC;AAC3f,KAAK,MAAM,GAAG,IAAI,QAAQ,EAAE,CAAC;IACzB,IAAI,CAAC,WAAW,CAAC,wBAAwB,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;QAClD,WAAW,CAAC,wBAAwB,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC;IAChE,CAAC;AACL,CAAC;AAED,gBAAgB;AAChB,MAAM,CAAC,MAAM,uBAAuB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\nimport { objectIdFunctionsWGSL } from \"./ShadersInclude/objectIdFunctions\";\nimport { clipPlaneFragmentDeclarationWGSL } from \"./ShadersInclude/clipPlaneFragmentDeclaration\";\nimport { bumpFragmentMainFunctionsWGSL } from \"./ShadersInclude/bumpFragmentMainFunctions\";\nimport { samplerFragmentDeclarationWGSL } from \"./ShadersInclude/samplerFragmentDeclaration\";\nimport { bumpFragmentFunctionsWGSL } from \"./ShadersInclude/bumpFragmentFunctions\";\nimport { helperFunctionsWGSL } from \"./ShadersInclude/helperFunctions\";\nimport { pbrFragmentReflectionDeclarationWGSL } from \"./ShadersInclude/pbrFragmentReflectionDeclaration\";\nimport { sceneUboDeclarationWGSL } from \"./ShadersInclude/sceneUboDeclaration\";\nimport { pbrBRDFFunctionsWGSL } from \"./ShadersInclude/pbrBRDFFunctions\";\nimport { openpbrDielectricReflectanceWGSL } from \"./ShadersInclude/openpbrDielectricReflectance\";\nimport { pbrIBLFunctionsWGSL } from \"./ShadersInclude/pbrIBLFunctions\";\nimport { reflectionFunctionWGSL } from \"./ShadersInclude/reflectionFunction\";\nimport { openpbrGeometryInfoWGSL } from \"./ShadersInclude/openpbrGeometryInfo\";\nimport { openpbrIblFunctionsWGSL } from \"./ShadersInclude/openpbrIblFunctions\";\nimport { clipPlaneFragmentWGSL } from \"./ShadersInclude/clipPlaneFragment\";\nimport { bumpFragmentWGSL } from \"./ShadersInclude/bumpFragment\";\nimport { openpbrSubsurfaceLayerDataWGSL } from \"./ShadersInclude/openpbrSubsurfaceLayerData\";\nimport { openpbrTransmissionLayerDataWGSL } from \"./ShadersInclude/openpbrTransmissionLayerData\";\n\nconst name = \"geometryPixelShader\";\nconst shader = `#ifdef BUMP\nvarying vWorldView0: vec4f;varying vWorldView1: vec4f;varying vWorldView2: vec4f;varying vWorldView3: vec4f;varying vNormalW: vec3f;\n#else\nvarying vNormalV: vec3f;\n#endif\nvarying vViewPos: vec4f;\n#if defined(POSITION) || defined(BUMP) || defined(IRRADIANCE)\nvarying vPositionW: vec3f;\n#endif\n#if defined(VELOCITY) || defined(VELOCITY_LINEAR)\nvarying vCurrentPosition: vec4f;varying vPreviousPosition: vec4f;\n#endif\n#ifdef NEED_UV\nvarying vUV: vec2f;\n#endif\n#ifdef BUMP\nuniform vBumpInfos: vec3f;uniform vTangentSpaceParams: vec2f;\n#endif\n#if defined(REFLECTIVITY)\n#if defined(ORMTEXTURE) || defined(SPECULARGLOSSINESSTEXTURE) || defined(REFLECTIVITYTEXTURE)\nvar reflectivitySamplerSampler: sampler;var reflectivitySampler: texture_2d<f32>;varying vReflectivityUV: vec2f;\n#else\n#ifdef METALLIC_TEXTURE\nvar metallicSamplerSampler: sampler;var metallicSampler: texture_2d<f32>;varying vMetallicUV: vec2f;\n#endif\n#ifdef ROUGHNESS_TEXTURE\nvar roughnessSamplerSampler: sampler;var roughnessSampler: texture_2d<f32>;varying vRoughnessUV: vec2f;\n#endif\n#endif\n#ifdef ALBEDOTEXTURE\nvarying vAlbedoUV: vec2f;var albedoSamplerSampler: sampler;var albedoSampler: texture_2d<f32>;\n#endif\n#ifdef REFLECTIVITYCOLOR\nuniform reflectivityColor: vec3f;\n#endif\n#ifdef ALBEDOCOLOR\nuniform albedoColor: vec3f;\n#endif\n#ifdef METALLIC\nuniform metallic: f32;\n#endif\n#if defined(ROUGHNESS) || defined(GLOSSINESS)\nuniform glossiness: f32;\n#endif\n#endif\n#if defined(ALPHATEST) && defined(NEED_UV)\nvar diffuseSamplerSampler: sampler;var diffuseSampler: texture_2d<f32>;uniform alphaCutOff: f32;\n#endif\n#ifdef OBJECT_ID\nuniform objectId: f32;\n#include<objectIdFunctions>\n#endif\n#ifdef MESH_BLEND_TAG\nuniform meshBlendTag: i32;\n#endif\n#include<clipPlaneFragmentDeclaration>\n#include<bumpFragmentMainFunctions>\n#include<bumpFragmentFunctions>\n#include<helperFunctions>\n#ifdef IRRADIANCE\n#include<pbrFragmentReflectionDeclaration>\n#ifdef REFLECTION\n#ifdef USEIRRADIANCEMAP\n#include<sceneUboDeclaration>\nuniform reflectionMatrix: mat4x4f;uniform vReflectionInfos: vec2f;uniform vReflectionDominantDirection: vec3f;\n#include<pbrBRDFFunctions>\n#include<openpbrDielectricReflectance>\n#include<pbrIBLFunctions>\n#include<reflectionFunction>\n#include<openpbrGeometryInfo>\n#include<openpbrIblFunctions>\n#elif defined(USESPHERICALFROMREFLECTIONMAP)\nvarying vEnvironmentIrradiance: vec3f;\n#endif\n#ifdef IBL_SHADOW_TEXTURE\nvar iblShadowSampler: texture_2d<f32>;var iblShadowSamplerSampler: sampler;uniform shadowTextureSize: vec2f;\n#endif\n#ifdef IRRADIANCE_SCATTER_MASK\nuniform vSubsurfaceWeight: f32;\n#include<samplerFragmentDeclaration>(_DEFINENAME_,SUBSURFACE_WEIGHT,_VARYINGNAME_,SubsurfaceWeight,_SAMPLERNAME_,subsurfaceWeight)\nuniform vSubsurfaceScatterAnisotropy: f32;uniform vTransmissionWeight: f32;\n#include<samplerFragmentDeclaration>(_DEFINENAME_,TRANSMISSION_WEIGHT,_VARYINGNAME_,TransmissionWeight,_SAMPLERNAME_,transmissionWeight)\nuniform vTransmissionScatterAnisotropy: f32;\n#endif\n#endif\n#endif\n@fragment\nfn main(input: FragmentInputs)->FragmentOutputs {\n#include<clipPlaneFragment>\n#ifdef ALPHATEST\nif (textureSample(diffuseSampler,diffuseSamplerSampler,input.vUV).a<uniforms.alphaCutOff) {discard;}\n#endif\nvar normalOutput: vec3f;\n#ifdef BUMP\nvar normalW: vec3f=normalize(input.vNormalW);\n#include<bumpFragment>\n#ifdef NORMAL_WORLDSPACE\nnormalOutput=normalW;\n#else\nnormalOutput=normalize( (mat4x4f(input.vWorldView0,input.vWorldView1,input.vWorldView2,input.vWorldView3)* vec4f(normalW,0.0)).xyz);\n#endif\n#elif defined(HAS_NORMAL_ATTRIBUTE)\nnormalOutput=normalize(input.vNormalV);\n#elif defined(POSITION)\nnormalOutput=normalize(-cross(dpdx(input.vPositionW),dpdy(input.vPositionW)));\n#endif\n#ifdef ENCODE_NORMAL\nnormalOutput=normalOutput*0.5+0.5;\n#endif\nvar fragData: array<vec4<f32>,SCENE_MRT_COUNT>;\n#ifdef DEPTH\nfragData[DEPTH_INDEX]=vec4f(input.vViewPos.z/input.vViewPos.w,0.0,0.0,1.0);\n#endif\n#ifdef NORMAL\nfragData[NORMAL_INDEX]=vec4f(normalOutput,1.0);\n#endif\n#ifdef SCREENSPACE_DEPTH\nfragData[SCREENSPACE_DEPTH_INDEX]=vec4f(fragmentInputs.position.z,0.0,0.0,1.0);\n#endif\n#ifdef POSITION\nfragData[POSITION_INDEX]= vec4f(input.vPositionW,1.0);\n#endif\n#ifdef OBJECT_ID\nfragData[OBJECT_ID_INDEX]=encodeObjectId(uniforms.objectId);\n#endif\n#ifdef VELOCITY\nvar 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);\n#endif\n#ifdef VELOCITY_LINEAR\nvar velocity : vec2f=vec2f(0.5)*((input.vPreviousPosition.xy /\ninput.vPreviousPosition.w) -\n(input.vCurrentPosition.xy /\ninput.vCurrentPosition.w));fragData[VELOCITY_LINEAR_INDEX]=vec4f(velocity,0.0,1.0);\n#endif\n#ifdef REFLECTIVITY\nvar reflectivity: vec4f= vec4f(0.0,0.0,0.0,1.0);\n#ifdef METALLICWORKFLOW\nvar metal: f32=1.0;var roughness: f32=1.0;\n#ifdef ORMTEXTURE\nmetal*=textureSample(reflectivitySampler,reflectivitySamplerSampler,input.vReflectivityUV).b;roughness*=textureSample(reflectivitySampler,reflectivitySamplerSampler,input.vReflectivityUV).g;\n#else\n#ifdef METALLIC_TEXTURE\nmetal*=textureSample(metallicSampler,metallicSamplerSampler,input.vMetallicUV).r;\n#endif\n#ifdef ROUGHNESS_TEXTURE\nroughness*=textureSample(roughnessSampler,roughnessSamplerSampler,input.vRoughnessUV).r;\n#endif\n#endif\n#ifdef METALLIC\nmetal*=uniforms.metallic;\n#endif\n#ifdef ROUGHNESS\nroughness*=(1.0-uniforms.glossiness); \n#endif\nreflectivity=vec4f(reflectivity.rgb,reflectivity.a-roughness);var color: vec3f= vec3f(1.0);\n#ifdef ALBEDOTEXTURE\ncolor=textureSample(albedoSampler,albedoSamplerSampler,input.vAlbedoUV).rgb;\n#ifdef GAMMAALBEDO\ncolor=toLinearSpaceVec4(color);\n#endif\n#endif\n#ifdef ALBEDOCOLOR\ncolor*=uniforms.albedoColor.xyz;\n#endif\nreflectivity=vec4f(mix( vec3f(0.04),color,metal),reflectivity.a);\n#else\n#if defined(SPECULARGLOSSINESSTEXTURE) || defined(REFLECTIVITYTEXTURE)\nreflectivity=textureSample(reflectivitySampler,reflectivitySamplerSampler,input.vReflectivityUV);\n#ifdef GAMMAREFLECTIVITYTEXTURE\nreflectivity=vec4f(toLinearSpaceVec3(reflectivity.rgb),reflectivity.a);\n#endif\n#else \n#ifdef REFLECTIVITYCOLOR\nreflectivity=vec4f(toLinearSpaceVec3(uniforms.reflectivityColor.xyz),1.0);\n#endif\n#endif\n#ifdef GLOSSINESSS\nreflectivity=vec4f(reflectivity.rgb,reflectivity.a*glossiness); \n#endif\n#endif\nfragData[REFLECTIVITY_INDEX]=reflectivity;\n#endif\n#ifdef IRRADIANCE\nvar irradiance: vec3f=vec3f(0.0);var irradiance_alpha: f32=1.0;\n#ifdef REFLECTION\n#ifdef IRRADIANCE_SCATTER_MASK\n#ifndef BUMP\nlet uvOffset: vec2f=vec2f(0.0);\n#endif\nvar vSubsurfaceColor: vec3f=vec3f(1.0);var vSubsurfaceRadius: f32=0.0;var vSubsurfaceRadiusScale: vec3f=vec3f(1.0);\n#include<openpbrSubsurfaceLayerData>(uniforms.vSubsurfaceColor,vSubsurfaceColor,uniforms.vSubsurfaceRadius,vSubsurfaceRadius,uniforms.vSubsurfaceRadiusScale,vSubsurfaceRadiusScale)\nvar 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;\n#include<openpbrTransmissionLayerData>(uniforms.vTransmissionDispersionScale,vTransmissionDispersionScale,uniforms.vTransmissionDispersionAbbeNumber,vTransmissionDispersionAbbeNumber,uniforms.vTransmissionColor,vTransmissionColor,uniforms.vTransmissionDepth,vTransmissionDepth,uniforms.vTransmissionScatter\\\\.,vTransmissionScatter.)\n#endif\n#ifdef IBL_SHADOW_TEXTURE\n#ifdef COLORED_IBL_SHADOWS\nlet iblShadowValue: vec3f=textureSample(iblShadowSampler,iblShadowSamplerSampler,fragmentInputs.position.xy/uniforms.shadowTextureSize).rgb;\n#else\nlet iblShadowValue: vec3f=vec3f(textureSample(iblShadowSampler,iblShadowSamplerSampler,fragmentInputs.position.xy/uniforms.shadowTextureSize).r);\n#endif\n#endif\n#if defined(USEIRRADIANCEMAP)\n#ifdef IRRADIANCE_SCATTER_MASK\nlet 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));\n#else\nlet bentNormal: vec3f=normalOutput;\n#endif\nirradiance=sampleIrradiance(\nbentNormal\n#if defined(NORMAL) && defined(USESPHERICALINVERTEX)\n,input.vEnvironmentIrradiance\n#endif\n#if (defined(USESPHERICALFROMREFLECTIONMAP) && (!defined(NORMAL) || !defined(USESPHERICALINVERTEX))) || (defined(USEIRRADIANCEMAP) && defined(REFLECTIONMAP_3D))\n,uniforms.reflectionMatrix\n#endif\n#ifdef USEIRRADIANCEMAP\n,irradianceSampler\n,irradianceSamplerSampler\n#ifdef USE_IRRADIANCE_DOMINANT_DIRECTION\n,uniforms.vReflectionDominantDirection\n#endif\n#endif\n#ifdef REALTIME_FILTERING\n,uniforms.vReflectionFilteringInfo\n#ifdef IBL_CDF_FILTERING\n,icdfSampler\n,icdfSamplerSampler\n#endif\n#endif\n,uniforms.vReflectionInfos\n,input.vViewPos.xyz\n,1.0\n,vec3f(1.0)\n);\n#elif defined(USESPHERICALFROMREFLECTIONMAP)\nirradiance=input.vEnvironmentIrradiance;\n#endif\n#ifdef IBL_SHADOW_TEXTURE\nirradiance*=iblShadowValue;\n#endif\n#ifdef IRRADIANCE_SCATTER_MASK\nirradiance_alpha=min(subsurface_weight+transmission_weight,1.0);\n#endif\n#endif\nfragData[IRRADIANCE_INDEX]=vec4f(irradiance,irradiance_alpha);\n#endif\n#if SCENE_MRT_COUNT>0\n#if defined(MESH_BLEND_TAG) && MESH_BLEND_TAG_INDEX==0\nfragmentOutputs.fragData0=vec4u(u32(uniforms.meshBlendTag),0u,0u,0u);\n#else\nfragmentOutputs.fragData0=fragData[0];\n#endif\n#endif\n#if SCENE_MRT_COUNT>1\n#if defined(MESH_BLEND_TAG) && MESH_BLEND_TAG_INDEX==1\nfragmentOutputs.fragData1=vec4u(u32(uniforms.meshBlendTag),0u,0u,0u);\n#else\nfragmentOutputs.fragData1=fragData[1];\n#endif\n#endif\n#if SCENE_MRT_COUNT>2\n#if defined(MESH_BLEND_TAG) && MESH_BLEND_TAG_INDEX==2\nfragmentOutputs.fragData2=vec4u(u32(uniforms.meshBlendTag),0u,0u,0u);\n#else\nfragmentOutputs.fragData2=fragData[2];\n#endif\n#endif\n#if SCENE_MRT_COUNT>3\n#if defined(MESH_BLEND_TAG) && MESH_BLEND_TAG_INDEX==3\nfragmentOutputs.fragData3=vec4u(u32(uniforms.meshBlendTag),0u,0u,0u);\n#else\nfragmentOutputs.fragData3=fragData[3];\n#endif\n#endif\n#if SCENE_MRT_COUNT>4\n#if defined(MESH_BLEND_TAG) && MESH_BLEND_TAG_INDEX==4\nfragmentOutputs.fragData4=vec4u(u32(uniforms.meshBlendTag),0u,0u,0u);\n#else\nfragmentOutputs.fragData4=fragData[4];\n#endif\n#endif\n#if SCENE_MRT_COUNT>5\n#if defined(MESH_BLEND_TAG) && MESH_BLEND_TAG_INDEX==5\nfragmentOutputs.fragData5=vec4u(u32(uniforms.meshBlendTag),0u,0u,0u);\n#else\nfragmentOutputs.fragData5=fragData[5];\n#endif\n#endif\n#if SCENE_MRT_COUNT>6\n#if defined(MESH_BLEND_TAG) && MESH_BLEND_TAG_INDEX==6\nfragmentOutputs.fragData6=vec4u(u32(uniforms.meshBlendTag),0u,0u,0u);\n#else\nfragmentOutputs.fragData6=fragData[6];\n#endif\n#endif\n#if SCENE_MRT_COUNT>7\n#if defined(MESH_BLEND_TAG) && MESH_BLEND_TAG_INDEX==7\nfragmentOutputs.fragData7=vec4u(u32(uniforms.meshBlendTag),0u,0u,0u);\n#else\nfragmentOutputs.fragData7=fragData[7];\n#endif\n#endif\n}\n`;\n// Sideeffect\nif (!ShaderStore.ShadersStoreWGSL[name]) {\n    ShaderStore.ShadersStoreWGSL[name] = shader;\n}\nconst includes = [objectIdFunctionsWGSL, clipPlaneFragmentDeclarationWGSL, bumpFragmentMainFunctionsWGSL, samplerFragmentDeclarationWGSL, bumpFragmentFunctionsWGSL, helperFunctionsWGSL, pbrFragmentReflectionDeclarationWGSL, sceneUboDeclarationWGSL, pbrBRDFFunctionsWGSL, openpbrDielectricReflectanceWGSL, pbrIBLFunctionsWGSL, reflectionFunctionWGSL, openpbrGeometryInfoWGSL, openpbrIblFunctionsWGSL, clipPlaneFragmentWGSL, bumpFragmentWGSL, openpbrSubsurfaceLayerDataWGSL, openpbrTransmissionLayerDataWGSL];\nfor (const inc of includes) {\n    if (!ShaderStore.IncludesShadersStoreWGSL[inc.name]) {\n        ShaderStore.IncludesShadersStoreWGSL[inc.name] = inc.shader;\n    }\n}\n\n/** @internal */\nexport const geometryPixelShaderWGSL = { name, shader };\n"]}

package/ShadersWGSL/gpsHiZBuild.compute.d.ts

@@ -0,0 +1,5 @@
+/** @internal */
+export declare const gpsHiZBuildComputeShaderWGSL: {
+    name: string;
+    shader: string;
+};

package/ShadersWGSL/gpsHiZBuild.compute.js

@@ -0,0 +1,16 @@
+// Do not edit.
+import { ShaderStore } from "../Engines/shaderStore.js";
+const name = "gpsHiZBuildComputeShader";
+const shader = `struct GpsHiZParams {src : vec4u,
+dst : vec4u,};@group(0) @binding(0) var<storage,read_write> hiZ : array<f32>;@group(0) @binding(1) var<uniform> params : GpsHiZParams;@compute @workgroup_size(8,8,1)
+fn main(@builtin(global_invocation_id) gid : vec3u) {let dstW=params.dst.y;let dstH=params.dst.z;if (gid.x>=dstW || gid.y>=dstH) {return;}
+let srcW=params.src.y;let srcH=params.src.z;let sx=gid.x*2u;let sy=gid.y*2u;let sxEnd=select(min(sx+1u,srcW-1u),srcW-1u,gid.x==dstW-1u);let syEnd=select(min(sy+1u,srcH-1u),srcH-1u,gid.y==dstH-1u);let base=params.src.x;var m=0.0;for (var y=sy; y<=syEnd; y=y+1u) {let row=base+y*srcW;for (var x=sx; x<=sxEnd; x=x+1u) {m=max(m,hiZ[row+x]);}}
+hiZ[params.dst.x+gid.y*dstW+gid.x]=m;}
+`;
+// Sideeffect
+if (!ShaderStore.ShadersStoreWGSL[name]) {
+    ShaderStore.ShadersStoreWGSL[name] = shader;
+}
+/** @internal */
+export const gpsHiZBuildComputeShaderWGSL = { name, shader };
+//# sourceMappingURL=gpsHiZBuild.compute.js.map

package/ShadersWGSL/gpsHiZBuild.compute.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gpsHiZBuild.compute.js","sourceRoot":"","sources":["../../../../dev/core/src/ShadersWGSL/gpsHiZBuild.compute.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,0BAA0B,CAAC;AACxC,MAAM,MAAM,GAAG;;;;;CAKd,CAAC;AACF,aAAa;AACb,IAAI,CAAC,WAAW,CAAC,gBAAgB,CAAC,IAAI,CAAC,EAAE,CAAC;IACtC,WAAW,CAAC,gBAAgB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,CAAC;AAED,gBAAgB;AAChB,MAAM,CAAC,MAAM,4BAA4B,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\n\nconst name = \"gpsHiZBuildComputeShader\";\nconst shader = `struct GpsHiZParams {src : vec4u,\ndst : vec4u,};@group(0) @binding(0) var<storage,read_write> hiZ : array<f32>;@group(0) @binding(1) var<uniform> params : GpsHiZParams;@compute @workgroup_size(8,8,1)\nfn main(@builtin(global_invocation_id) gid : vec3u) {let dstW=params.dst.y;let dstH=params.dst.z;if (gid.x>=dstW || gid.y>=dstH) {return;}\nlet srcW=params.src.y;let srcH=params.src.z;let sx=gid.x*2u;let sy=gid.y*2u;let sxEnd=select(min(sx+1u,srcW-1u),srcW-1u,gid.x==dstW-1u);let syEnd=select(min(sy+1u,srcH-1u),srcH-1u,gid.y==dstH-1u);let base=params.src.x;var m=0.0;for (var y=sy; y<=syEnd; y=y+1u) {let row=base+y*srcW;for (var x=sx; x<=sxEnd; x=x+1u) {m=max(m,hiZ[row+x]);}}\nhiZ[params.dst.x+gid.y*dstW+gid.x]=m;}\n`;\n// Sideeffect\nif (!ShaderStore.ShadersStoreWGSL[name]) {\n    ShaderStore.ShadersStoreWGSL[name] = shader;\n}\n\n/** @internal */\nexport const gpsHiZBuildComputeShaderWGSL = { name, shader };\n"]}

package/ShadersWGSL/gpsPartition.compute.d.ts

@@ -0,0 +1,5 @@
+/** @internal */
+export declare const gpsPartitionComputeShaderWGSL: {
+    name: string;
+    shader: string;
+};

package/ShadersWGSL/gpsPartition.compute.js

@@ -0,0 +1,27 @@
+// Do not edit.
+import { ShaderStore } from "../Engines/shaderStore.js";
+import { gaussianPointSplattingWGSL } from "./ShadersInclude/gaussianPointSplatting.js";
+const name = "gpsPartitionComputeShader";
+const shader = `#include<gaussianPointSplatting>
+@group(0) @binding(0) var<storage,read> cdf : array<u32>;@group(0) @binding(1) var<storage,read> pointCount : array<u32>;@group(0) @binding(2) var<storage,read_write> partTable : array<u32>;fn gpsFindGaussian(p : u32,count : u32)->u32 {var lo=0u;var hi=count;loop {if (lo+1u>=hi) {break;}
+let mid=(lo+hi)>>1u;if (cdf[mid]<=p) {lo=mid;} else {hi=mid;}}
+return lo;}
+@compute @workgroup_size(256,1,1)
+fn main(@builtin(global_invocation_id) gid : vec3u) {let k=gid.x;if (k>GPS_PARTITION_BUCKETS) {return;}
+let total=pointCount[0];let count=arrayLength(&cdf);if (total==0u || count==0u) {partTable[k]=0u;return;}
+var pk=u32(f32(k)/f32(GPS_PARTITION_BUCKETS)*f32(total));if (pk>total-1u) {pk=total-1u;}
+partTable[k]=gpsFindGaussian(pk,count);}
+`;
+// Sideeffect
+if (!ShaderStore.ShadersStoreWGSL[name]) {
+    ShaderStore.ShadersStoreWGSL[name] = shader;
+}
+const includes = [gaussianPointSplattingWGSL];
+for (const inc of includes) {
+    if (!ShaderStore.IncludesShadersStoreWGSL[inc.name]) {
+        ShaderStore.IncludesShadersStoreWGSL[inc.name] = inc.shader;
+    }
+}
+/** @internal */
+export const gpsPartitionComputeShaderWGSL = { name, shader };
+//# sourceMappingURL=gpsPartition.compute.js.map

package/ShadersWGSL/gpsPartition.compute.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gpsPartition.compute.js","sourceRoot":"","sources":["../../../../dev/core/src/ShadersWGSL/gpsPartition.compute.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,0BAA0B,EAAE,MAAM,yCAAyC,CAAC;AAErF,MAAM,IAAI,GAAG,2BAA2B,CAAC;AACzC,MAAM,MAAM,GAAG;;;;;;;;;CASd,CAAC;AACF,aAAa;AACb,IAAI,CAAC,WAAW,CAAC,gBAAgB,CAAC,IAAI,CAAC,EAAE,CAAC;IACtC,WAAW,CAAC,gBAAgB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,CAAC;AACD,MAAM,QAAQ,GAAG,CAAC,0BAA0B,CAAC,CAAC;AAC9C,KAAK,MAAM,GAAG,IAAI,QAAQ,EAAE,CAAC;IACzB,IAAI,CAAC,WAAW,CAAC,wBAAwB,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;QAClD,WAAW,CAAC,wBAAwB,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC;IAChE,CAAC;AACL,CAAC;AAED,gBAAgB;AAChB,MAAM,CAAC,MAAM,6BAA6B,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\nimport { gaussianPointSplattingWGSL } from \"./ShadersInclude/gaussianPointSplatting\";\n\nconst name = \"gpsPartitionComputeShader\";\nconst shader = `#include<gaussianPointSplatting>\n@group(0) @binding(0) var<storage,read> cdf : array<u32>;@group(0) @binding(1) var<storage,read> pointCount : array<u32>;@group(0) @binding(2) var<storage,read_write> partTable : array<u32>;fn gpsFindGaussian(p : u32,count : u32)->u32 {var lo=0u;var hi=count;loop {if (lo+1u>=hi) {break;}\nlet mid=(lo+hi)>>1u;if (cdf[mid]<=p) {lo=mid;} else {hi=mid;}}\nreturn lo;}\n@compute @workgroup_size(256,1,1)\nfn main(@builtin(global_invocation_id) gid : vec3u) {let k=gid.x;if (k>GPS_PARTITION_BUCKETS) {return;}\nlet total=pointCount[0];let count=arrayLength(&cdf);if (total==0u || count==0u) {partTable[k]=0u;return;}\nvar pk=u32(f32(k)/f32(GPS_PARTITION_BUCKETS)*f32(total));if (pk>total-1u) {pk=total-1u;}\npartTable[k]=gpsFindGaussian(pk,count);}\n`;\n// Sideeffect\nif (!ShaderStore.ShadersStoreWGSL[name]) {\n    ShaderStore.ShadersStoreWGSL[name] = shader;\n}\nconst includes = [gaussianPointSplattingWGSL];\nfor (const inc of includes) {\n    if (!ShaderStore.IncludesShadersStoreWGSL[inc.name]) {\n        ShaderStore.IncludesShadersStoreWGSL[inc.name] = inc.shader;\n    }\n}\n\n/** @internal */\nexport const gpsPartitionComputeShaderWGSL = { name, shader };\n"]}

package/ShadersWGSL/gpsPreprocess.compute.d.ts

@@ -0,0 +1,5 @@
+/** @internal */
+export declare const gpsPreprocessComputeShaderWGSL: {
+    name: string;
+    shader: string;
+};

package/ShadersWGSL/gpsPreprocess.compute.js

@@ -0,0 +1,86 @@
+// Do not edit.
+import { ShaderStore } from "../Engines/shaderStore.js";
+import { gaussianPointSplattingWGSL } from "./ShadersInclude/gaussianPointSplatting.js";
+import { gaussianSplattingSharedWGSL } from "./ShadersInclude/gaussianSplattingShared.js";
+const name = "gpsPreprocessComputeShader";
+const shader = `#include<gaussianPointSplatting>
+#include<gaussianSplattingShared>
+@group(0) @binding(0) var<storage,read> means : array<vec4f>;@group(0) @binding(1) var<storage,read> colorOpacity : array<u32>;@group(0) @binding(2) var<storage,read_write> weights : array<u32>;@group(0) @binding(3) var<storage,read_write> gsData : array<GpsScreen>;@group(0) @binding(4) var<uniform> uniforms : GpsUniforms;@group(0) @binding(5) var<storage,read> cov3d : array<u32>; 
+@group(0) @binding(6) var<storage,read> sh : array<u32>; 
+@group(0) @binding(7) var<storage,read> parts : array<GpsPart>; 
+@group(0) @binding(8) var<storage,read> hiZ : array<f32>; 
+fn gpsHiZLevelOffset(l : u32,baseW : u32,baseH : u32)->u32 {var off=0u;for (var i=0u; i<l; i=i+1u) {off+=max(1u,baseW>>i)*max(1u,baseH>>i);}
+return off;}
+fn gpsHiZOccluded(center : vec2f,footR : f32,viewDepth : f32)->bool {let baseW=u32(uniforms.hiZInfo.x);let baseH=u32(uniforms.hiZInfo.y);let numLevels=u32(uniforms.hiZInfo.z);let minx=i32(floor(center.x-footR));let maxx=i32(ceil(center.x+footR));let miny=i32(floor(center.y-footR));let maxy=i32(ceil(center.y+footR));let d=f32(max(maxx-minx,maxy-miny)+1);var lod=i32(ceil(log2(max(d,1.0)*0.5)));lod=clamp(lod,0,i32(numLevels)-1);let L=u32(lod);let lw=max(1u,baseW>>L);let lh=max(1u,baseH>>L);let tile=1u<<L;let off=gpsHiZLevelOffset(L,baseW,baseH);let tx0=min(u32(max(minx,0))/tile,lw-1u);let tx1=min(u32(max(maxx,0))/tile,lw-1u);let ty0=min(u32(max(miny,0))/tile,lh-1u);let ty1=min(u32(max(maxy,0))/tile,lh-1u);var zMax=0.0;for (var ty=ty0; ty<=ty1; ty=ty+1u) {let row=off+ty*lw;for (var tx=tx0; tx<=tx1; tx=tx+1u) {zMax=max(zMax,hiZ[row+tx]);}}
+return zMax<viewDepth;}
+#if SH_DEGREE>0
+#if SH_DEGREE==1
+const GPS_SH_WORDS : u32=3u; 
+#elif SH_DEGREE==2
+const GPS_SH_WORDS : u32=6u; 
+#elif SH_DEGREE==3
+const GPS_SH_WORDS : u32=12u; 
+#else
+const GPS_SH_WORDS : u32=18u; 
+#endif
+fn gpsShByte(baseWord : u32,s : u32)->f32 {let w=sh[baseWord+(s>>2u)];let b=(w>>(8u*(s & 3u))) & 0xFFu;return f32(b)*(2.0/255.0)-1.0;}
+fn gpsShCoeff(baseWord : u32,j : u32)->vec3f {let s=j*3u;return vec3f(gpsShByte(baseWord,s),gpsShByte(baseWord,s+1u),gpsShByte(baseWord,s+2u));}
+#if SH_DEGREE==1
+const GPS_SH_DIM : u32=3u;
+#elif SH_DEGREE==2
+const GPS_SH_DIM : u32=8u;
+#elif SH_DEGREE==3
+const GPS_SH_DIM : u32=15u;
+#else
+const GPS_SH_DIM : u32=24u;
+#endif
+fn gpsEvalShDelta(g : u32,dir : vec3f,so1 : f32,so2 : f32,so3 : f32,so4 : f32)->vec3f {let base=g*GPS_SH_WORDS;var coeffs : array<vec3<f32>,25>;for (var j=0u; j<GPS_SH_DIM; j=j+1u) {coeffs[1u+j]=gpsShCoeff(base,j);}
+return computeColorFromSHDegree(dir,coeffs,so1,so2,so3,so4);}
+#endif
+@compute @workgroup_size(256,1,1)
+fn main(@builtin(global_invocation_id) gid : vec3u) {let g=gid.y*65535u*256u+gid.x;let count=u32(uniforms.params0.x);if (g>=count) {return;}
+weights[g]=0u;let mean=means[g].xyz;let partIndex=u32(means[g].w);let pdata=parts[partIndex];let partWorld=pdata.world;let near=uniforms.resNearFar.z;let far=uniforms.resNearFar.w;let worldPos=(partWorld*vec4f(mean,1.0)).xyz;let camspace=uniforms.view*vec4f(worldPos,1.0);let clip=uniforms.viewProjection*vec4f(worldPos,1.0);if (clip.w<=0.0) {return;}
+let viewDepth=select(camspace.z,-camspace.z,uniforms.focal.z>0.5);let projectedDepth=(u32(uniforms.misc.w) & 2u) != 0u;if (!projectedDepth && (viewDepth<=near || (far>0.0 && viewDepth>=far))) {return;}
+let ndc=clip.xyz/clip.w;if (ndc.x<-1.3 || ndc.x>1.3 || ndc.y<-1.3 || ndc.y>1.3) {return;}
+let px=(ndc.x*0.5+0.5)*uniforms.pixelMap.x+uniforms.pixelMap.z;let py=(ndc.y*0.5+0.5)*uniforms.pixelMap.y+uniforms.pixelMap.w;let covFactor=bitcast<f32>(cov3d[4u*g+3u]);let p0=unpack2x16float(cov3d[4u*g+0u])*covFactor; 
+let p1=unpack2x16float(cov3d[4u*g+1u])*covFactor; 
+let p2=unpack2x16float(cov3d[4u*g+2u])*covFactor; 
+let covA=vec3f(p0.x,p0.y,p1.x); 
+let covB=vec3f(p1.y,p2.x,p2.y); 
+let isOrtho=uniforms.focal.w>0.5;let modelView=uniforms.view*partWorld;var cov2d : mat3x3f;if ((u32(uniforms.misc.w) & 1u) != 0u) {cov2d=gpsCov2D(covA,covB,modelView,uniforms.projection,clip,uniforms.pixelMap.xy);} else {cov2d=computeCov2D(covA,covB,modelView,camspace.xyz,uniforms.focal.xy,isOrtho);}
+cov2d=cov2d*0.25;let detOrig=cov2d[0][0]*cov2d[1][1]-cov2d[0][1]*cov2d[0][1];let kernelSize=uniforms.params0.y;cov2d[0][0]+=kernelSize;cov2d[1][1]+=kernelSize;let a=cov2d[0][0];let b=cov2d[0][1];let cc=cov2d[1][1];let det=a*cc-b*b;if (det<=0.0) {return;}
+let lambda1=(a+cc)*0.5+length(vec2f((a-cc)*0.5,b));let minPixelSize=uniforms.misc.y;if (minPixelSize>0.0 && 4.0*uniforms.misc.x*sqrt(2.0*lambda1)<minPixelSize) {return;}
+if (uniforms.hiZInfo.w>0.5) {let footR=3.0*sqrt(max(lambda1,0.0)); 
+var nearestDepth=viewDepth;if (projectedDepth) {let low=((vec2f(px,py)-footR-uniforms.pixelMap.zw)/uniforms.pixelMap.xy)*2.0-1.0;let high=((vec2f(px,py)+footR-uniforms.pixelMap.zw)/uniforms.pixelMap.xy)*2.0-1.0;var depths=vec4f(
+gpsProjectedDepth(uniforms.inverseProjection,low,camspace.z).x,
+gpsProjectedDepth(uniforms.inverseProjection,high,camspace.z).x,
+gpsProjectedDepth(uniforms.inverseProjection,vec2f(low.x,high.y),camspace.z).x,
+gpsProjectedDepth(uniforms.inverseProjection,vec2f(high.x,low.y),camspace.z).x);if ((u32(uniforms.misc.w) & 4u) != 0u) {depths=vec4f(1.0)-depths;}
+nearestDepth=min(min(depths.x,depths.y),min(depths.z,depths.w));}
+if (gpsHiZOccluded(vec2f(px,py),footR,nearestDepth)) {return;}}
+let compensation=select(1.0,sqrt(max(0.0,detOrig/det)),uniforms.depthNorm.w>0.5);let invDet=1.0/det;let conic=vec3f(cc*invDet,-b*invDet,a*invDet);let chol0=sqrt(a);let chol1=b/chol0;let chol2=sqrt(max(0.0,cc-chol1*chol1));let rgba=colorOpacity[g];let baseColor=vec3f(f32(rgba & 0xFFu),f32((rgba>>8u) & 0xFFu),f32((rgba>>16u) & 0xFFu))/255.0;let baseOpacity=f32((rgba>>24u) & 0xFFu)/255.0;if (baseOpacity==0.0) {return;}
+if (uniforms.depthNorm.z>0.5) {let clipMin=pdata.dbg0.xyz;let clipMax=vec3f(pdata.dbg0.w,pdata.dbg1.x,pdata.dbg1.y);if (any(worldPos<clipMin) || any(worldPos>clipMax)) {return;}
+if (baseOpacity<pdata.dbg1.z || baseOpacity>pdata.dbg1.w) {return;}
+let det3d=p0.x*(p1.y*p2.y-p2.x*p2.x)-p0.y*(p0.y*p2.y-p2.x*p1.x)+p1.x*(p0.y*p2.x-p1.y*p1.x);let splatSize=pow(abs(det3d),1.0/6.0);if (splatSize<pdata.dbg2.x || splatSize>pdata.dbg2.y) {return;}}
+var color=baseColor*pdata.dbg3.x;var opacity=clamp(baseOpacity*pdata.vis.x*pdata.dbg2.z*compensation,0.0,1.0);let saturate=pdata.dbg2.w>0.5;
+#if SH_DEGREE>0
+{let worldRot=mat3x3f(partWorld[0].xyz,partWorld[1].xyz,partWorld[2].xyz);let dir=normalize(gpsInverseMat3(worldRot)*(worldPos-uniforms.camPosDeg.xyz));color+=gpsEvalShDelta(g,dir,pdata.dbg3.y,pdata.dbg3.z,pdata.dbg3.w,pdata.dbg4.x);}
+#endif
+let lambdaMax=gpsPointIntensity(opacity);var importance : f32;if (saturate) {importance=4.0*GPS_TWO_PI*sqrt(det)*lambdaMax*uniforms.params0.z;} else {importance=GPS_TWO_PI*sqrt(det)*gpsDilog(opacity)*uniforms.params0.z;}
+let res=uniforms.resNearFar.xy;let halfExtent=sqrt(8.0*vec2f(a,cc));let rectMin=clamp(floor(vec2f(px,py)-halfExtent),vec2f(0.0),res);let rectMax=clamp(ceil(vec2f(px,py)+halfExtent),vec2f(0.0),res);let rectSize=rectMax-rectMin;let rectImportance=lambdaMax*rectSize.x*rectSize.y*uniforms.params0.z;let useRect=rectImportance<importance;let chosen=select(importance,rectImportance,useRect);if (chosen<1e-4) {return;}
+let seed=gpsHash2(g,u32(uniforms.params0.w));let numPoints=gpsPoisson(gpsPcg(seed),chosen);if (numPoints==0u) {return;}
+var s : GpsScreen;s.pmConicXY=vec4f(px,py,conic.x,conic.y);s.conicZChol=vec4f(conic.z,chol0,chol1,chol2);s.colorOp=vec4f(color,opacity);let dmin=uniforms.depthNorm.x;let dmax=uniforms.depthNorm.y;let dord=clamp((viewDepth-dmin)/max(dmax-dmin,1e-6),0.0,1.0);let flags=select(0u,GPS_FLAG_SATURATE,saturate) | select(0u,GPS_FLAG_SCREEN_RECT,useRect);let rmin=vec2u(rectMin);let rmax=vec2u(rectMax);let depthKey=select(u32(dord*f32(GPS_DEPTH_MAX_CODE)),bitcast<u32>(camspace.z),projectedDepth);s.depth=vec4u(depthKey,flags,rmin.x | (rmin.y<<16u),rmax.x | (rmax.y<<16u));gsData[g]=s;weights[g]=numPoints;}
+`;
+// Sideeffect
+if (!ShaderStore.ShadersStoreWGSL[name]) {
+    ShaderStore.ShadersStoreWGSL[name] = shader;
+}
+const includes = [gaussianPointSplattingWGSL, gaussianSplattingSharedWGSL];
+for (const inc of includes) {
+    if (!ShaderStore.IncludesShadersStoreWGSL[inc.name]) {
+        ShaderStore.IncludesShadersStoreWGSL[inc.name] = inc.shader;
+    }
+}
+/** @internal */
+export const gpsPreprocessComputeShaderWGSL = { name, shader };
+//# sourceMappingURL=gpsPreprocess.compute.js.map

package/ShadersWGSL/gpsPreprocess.compute.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gpsPreprocess.compute.js","sourceRoot":"","sources":["../../../../dev/core/src/ShadersWGSL/gpsPreprocess.compute.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,0BAA0B,EAAE,MAAM,yCAAyC,CAAC;AACrF,OAAO,EAAE,2BAA2B,EAAE,MAAM,0CAA0C,CAAC;AAEvF,MAAM,IAAI,GAAG,4BAA4B,CAAC;AAC1C,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmEd,CAAC;AACF,aAAa;AACb,IAAI,CAAC,WAAW,CAAC,gBAAgB,CAAC,IAAI,CAAC,EAAE,CAAC;IACtC,WAAW,CAAC,gBAAgB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,CAAC;AACD,MAAM,QAAQ,GAAG,CAAC,0BAA0B,EAAE,2BAA2B,CAAC,CAAC;AAC3E,KAAK,MAAM,GAAG,IAAI,QAAQ,EAAE,CAAC;IACzB,IAAI,CAAC,WAAW,CAAC,wBAAwB,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;QAClD,WAAW,CAAC,wBAAwB,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC;IAChE,CAAC;AACL,CAAC;AAED,gBAAgB;AAChB,MAAM,CAAC,MAAM,8BAA8B,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\nimport { gaussianPointSplattingWGSL } from \"./ShadersInclude/gaussianPointSplatting\";\nimport { gaussianSplattingSharedWGSL } from \"./ShadersInclude/gaussianSplattingShared\";\n\nconst name = \"gpsPreprocessComputeShader\";\nconst shader = `#include<gaussianPointSplatting>\n#include<gaussianSplattingShared>\n@group(0) @binding(0) var<storage,read> means : array<vec4f>;@group(0) @binding(1) var<storage,read> colorOpacity : array<u32>;@group(0) @binding(2) var<storage,read_write> weights : array<u32>;@group(0) @binding(3) var<storage,read_write> gsData : array<GpsScreen>;@group(0) @binding(4) var<uniform> uniforms : GpsUniforms;@group(0) @binding(5) var<storage,read> cov3d : array<u32>; \n@group(0) @binding(6) var<storage,read> sh : array<u32>; \n@group(0) @binding(7) var<storage,read> parts : array<GpsPart>; \n@group(0) @binding(8) var<storage,read> hiZ : array<f32>; \nfn gpsHiZLevelOffset(l : u32,baseW : u32,baseH : u32)->u32 {var off=0u;for (var i=0u; i<l; i=i+1u) {off+=max(1u,baseW>>i)*max(1u,baseH>>i);}\nreturn off;}\nfn gpsHiZOccluded(center : vec2f,footR : f32,viewDepth : f32)->bool {let baseW=u32(uniforms.hiZInfo.x);let baseH=u32(uniforms.hiZInfo.y);let numLevels=u32(uniforms.hiZInfo.z);let minx=i32(floor(center.x-footR));let maxx=i32(ceil(center.x+footR));let miny=i32(floor(center.y-footR));let maxy=i32(ceil(center.y+footR));let d=f32(max(maxx-minx,maxy-miny)+1);var lod=i32(ceil(log2(max(d,1.0)*0.5)));lod=clamp(lod,0,i32(numLevels)-1);let L=u32(lod);let lw=max(1u,baseW>>L);let lh=max(1u,baseH>>L);let tile=1u<<L;let off=gpsHiZLevelOffset(L,baseW,baseH);let tx0=min(u32(max(minx,0))/tile,lw-1u);let tx1=min(u32(max(maxx,0))/tile,lw-1u);let ty0=min(u32(max(miny,0))/tile,lh-1u);let ty1=min(u32(max(maxy,0))/tile,lh-1u);var zMax=0.0;for (var ty=ty0; ty<=ty1; ty=ty+1u) {let row=off+ty*lw;for (var tx=tx0; tx<=tx1; tx=tx+1u) {zMax=max(zMax,hiZ[row+tx]);}}\nreturn zMax<viewDepth;}\n#if SH_DEGREE>0\n#if SH_DEGREE==1\nconst GPS_SH_WORDS : u32=3u; \n#elif SH_DEGREE==2\nconst GPS_SH_WORDS : u32=6u; \n#elif SH_DEGREE==3\nconst GPS_SH_WORDS : u32=12u; \n#else\nconst GPS_SH_WORDS : u32=18u; \n#endif\nfn gpsShByte(baseWord : u32,s : u32)->f32 {let w=sh[baseWord+(s>>2u)];let b=(w>>(8u*(s & 3u))) & 0xFFu;return f32(b)*(2.0/255.0)-1.0;}\nfn gpsShCoeff(baseWord : u32,j : u32)->vec3f {let s=j*3u;return vec3f(gpsShByte(baseWord,s),gpsShByte(baseWord,s+1u),gpsShByte(baseWord,s+2u));}\n#if SH_DEGREE==1\nconst GPS_SH_DIM : u32=3u;\n#elif SH_DEGREE==2\nconst GPS_SH_DIM : u32=8u;\n#elif SH_DEGREE==3\nconst GPS_SH_DIM : u32=15u;\n#else\nconst GPS_SH_DIM : u32=24u;\n#endif\nfn gpsEvalShDelta(g : u32,dir : vec3f,so1 : f32,so2 : f32,so3 : f32,so4 : f32)->vec3f {let base=g*GPS_SH_WORDS;var coeffs : array<vec3<f32>,25>;for (var j=0u; j<GPS_SH_DIM; j=j+1u) {coeffs[1u+j]=gpsShCoeff(base,j);}\nreturn computeColorFromSHDegree(dir,coeffs,so1,so2,so3,so4);}\n#endif\n@compute @workgroup_size(256,1,1)\nfn main(@builtin(global_invocation_id) gid : vec3u) {let g=gid.y*65535u*256u+gid.x;let count=u32(uniforms.params0.x);if (g>=count) {return;}\nweights[g]=0u;let mean=means[g].xyz;let partIndex=u32(means[g].w);let pdata=parts[partIndex];let partWorld=pdata.world;let near=uniforms.resNearFar.z;let far=uniforms.resNearFar.w;let worldPos=(partWorld*vec4f(mean,1.0)).xyz;let camspace=uniforms.view*vec4f(worldPos,1.0);let clip=uniforms.viewProjection*vec4f(worldPos,1.0);if (clip.w<=0.0) {return;}\nlet viewDepth=select(camspace.z,-camspace.z,uniforms.focal.z>0.5);let projectedDepth=(u32(uniforms.misc.w) & 2u) != 0u;if (!projectedDepth && (viewDepth<=near || (far>0.0 && viewDepth>=far))) {return;}\nlet ndc=clip.xyz/clip.w;if (ndc.x<-1.3 || ndc.x>1.3 || ndc.y<-1.3 || ndc.y>1.3) {return;}\nlet px=(ndc.x*0.5+0.5)*uniforms.pixelMap.x+uniforms.pixelMap.z;let py=(ndc.y*0.5+0.5)*uniforms.pixelMap.y+uniforms.pixelMap.w;let covFactor=bitcast<f32>(cov3d[4u*g+3u]);let p0=unpack2x16float(cov3d[4u*g+0u])*covFactor; \nlet p1=unpack2x16float(cov3d[4u*g+1u])*covFactor; \nlet p2=unpack2x16float(cov3d[4u*g+2u])*covFactor; \nlet covA=vec3f(p0.x,p0.y,p1.x); \nlet covB=vec3f(p1.y,p2.x,p2.y); \nlet isOrtho=uniforms.focal.w>0.5;let modelView=uniforms.view*partWorld;var cov2d : mat3x3f;if ((u32(uniforms.misc.w) & 1u) != 0u) {cov2d=gpsCov2D(covA,covB,modelView,uniforms.projection,clip,uniforms.pixelMap.xy);} else {cov2d=computeCov2D(covA,covB,modelView,camspace.xyz,uniforms.focal.xy,isOrtho);}\ncov2d=cov2d*0.25;let detOrig=cov2d[0][0]*cov2d[1][1]-cov2d[0][1]*cov2d[0][1];let kernelSize=uniforms.params0.y;cov2d[0][0]+=kernelSize;cov2d[1][1]+=kernelSize;let a=cov2d[0][0];let b=cov2d[0][1];let cc=cov2d[1][1];let det=a*cc-b*b;if (det<=0.0) {return;}\nlet lambda1=(a+cc)*0.5+length(vec2f((a-cc)*0.5,b));let minPixelSize=uniforms.misc.y;if (minPixelSize>0.0 && 4.0*uniforms.misc.x*sqrt(2.0*lambda1)<minPixelSize) {return;}\nif (uniforms.hiZInfo.w>0.5) {let footR=3.0*sqrt(max(lambda1,0.0)); \nvar nearestDepth=viewDepth;if (projectedDepth) {let low=((vec2f(px,py)-footR-uniforms.pixelMap.zw)/uniforms.pixelMap.xy)*2.0-1.0;let high=((vec2f(px,py)+footR-uniforms.pixelMap.zw)/uniforms.pixelMap.xy)*2.0-1.0;var depths=vec4f(\ngpsProjectedDepth(uniforms.inverseProjection,low,camspace.z).x,\ngpsProjectedDepth(uniforms.inverseProjection,high,camspace.z).x,\ngpsProjectedDepth(uniforms.inverseProjection,vec2f(low.x,high.y),camspace.z).x,\ngpsProjectedDepth(uniforms.inverseProjection,vec2f(high.x,low.y),camspace.z).x);if ((u32(uniforms.misc.w) & 4u) != 0u) {depths=vec4f(1.0)-depths;}\nnearestDepth=min(min(depths.x,depths.y),min(depths.z,depths.w));}\nif (gpsHiZOccluded(vec2f(px,py),footR,nearestDepth)) {return;}}\nlet compensation=select(1.0,sqrt(max(0.0,detOrig/det)),uniforms.depthNorm.w>0.5);let invDet=1.0/det;let conic=vec3f(cc*invDet,-b*invDet,a*invDet);let chol0=sqrt(a);let chol1=b/chol0;let chol2=sqrt(max(0.0,cc-chol1*chol1));let rgba=colorOpacity[g];let baseColor=vec3f(f32(rgba & 0xFFu),f32((rgba>>8u) & 0xFFu),f32((rgba>>16u) & 0xFFu))/255.0;let baseOpacity=f32((rgba>>24u) & 0xFFu)/255.0;if (baseOpacity==0.0) {return;}\nif (uniforms.depthNorm.z>0.5) {let clipMin=pdata.dbg0.xyz;let clipMax=vec3f(pdata.dbg0.w,pdata.dbg1.x,pdata.dbg1.y);if (any(worldPos<clipMin) || any(worldPos>clipMax)) {return;}\nif (baseOpacity<pdata.dbg1.z || baseOpacity>pdata.dbg1.w) {return;}\nlet det3d=p0.x*(p1.y*p2.y-p2.x*p2.x)-p0.y*(p0.y*p2.y-p2.x*p1.x)+p1.x*(p0.y*p2.x-p1.y*p1.x);let splatSize=pow(abs(det3d),1.0/6.0);if (splatSize<pdata.dbg2.x || splatSize>pdata.dbg2.y) {return;}}\nvar color=baseColor*pdata.dbg3.x;var opacity=clamp(baseOpacity*pdata.vis.x*pdata.dbg2.z*compensation,0.0,1.0);let saturate=pdata.dbg2.w>0.5;\n#if SH_DEGREE>0\n{let worldRot=mat3x3f(partWorld[0].xyz,partWorld[1].xyz,partWorld[2].xyz);let dir=normalize(gpsInverseMat3(worldRot)*(worldPos-uniforms.camPosDeg.xyz));color+=gpsEvalShDelta(g,dir,pdata.dbg3.y,pdata.dbg3.z,pdata.dbg3.w,pdata.dbg4.x);}\n#endif\nlet lambdaMax=gpsPointIntensity(opacity);var importance : f32;if (saturate) {importance=4.0*GPS_TWO_PI*sqrt(det)*lambdaMax*uniforms.params0.z;} else {importance=GPS_TWO_PI*sqrt(det)*gpsDilog(opacity)*uniforms.params0.z;}\nlet res=uniforms.resNearFar.xy;let halfExtent=sqrt(8.0*vec2f(a,cc));let rectMin=clamp(floor(vec2f(px,py)-halfExtent),vec2f(0.0),res);let rectMax=clamp(ceil(vec2f(px,py)+halfExtent),vec2f(0.0),res);let rectSize=rectMax-rectMin;let rectImportance=lambdaMax*rectSize.x*rectSize.y*uniforms.params0.z;let useRect=rectImportance<importance;let chosen=select(importance,rectImportance,useRect);if (chosen<1e-4) {return;}\nlet seed=gpsHash2(g,u32(uniforms.params0.w));let numPoints=gpsPoisson(gpsPcg(seed),chosen);if (numPoints==0u) {return;}\nvar s : GpsScreen;s.pmConicXY=vec4f(px,py,conic.x,conic.y);s.conicZChol=vec4f(conic.z,chol0,chol1,chol2);s.colorOp=vec4f(color,opacity);let dmin=uniforms.depthNorm.x;let dmax=uniforms.depthNorm.y;let dord=clamp((viewDepth-dmin)/max(dmax-dmin,1e-6),0.0,1.0);let flags=select(0u,GPS_FLAG_SATURATE,saturate) | select(0u,GPS_FLAG_SCREEN_RECT,useRect);let rmin=vec2u(rectMin);let rmax=vec2u(rectMax);let depthKey=select(u32(dord*f32(GPS_DEPTH_MAX_CODE)),bitcast<u32>(camspace.z),projectedDepth);s.depth=vec4u(depthKey,flags,rmin.x | (rmin.y<<16u),rmax.x | (rmax.y<<16u));gsData[g]=s;weights[g]=numPoints;}\n`;\n// Sideeffect\nif (!ShaderStore.ShadersStoreWGSL[name]) {\n    ShaderStore.ShadersStoreWGSL[name] = shader;\n}\nconst includes = [gaussianPointSplattingWGSL, gaussianSplattingSharedWGSL];\nfor (const inc of includes) {\n    if (!ShaderStore.IncludesShadersStoreWGSL[inc.name]) {\n        ShaderStore.IncludesShadersStoreWGSL[inc.name] = inc.shader;\n    }\n}\n\n/** @internal */\nexport const gpsPreprocessComputeShaderWGSL = { name, shader };\n"]}

package/ShadersWGSL/gpsResolve.compute.d.ts

@@ -0,0 +1,5 @@
+/** @internal */
+export declare const gpsResolveComputeShaderWGSL: {
+    name: string;
+    shader: string;
+};

package/ShadersWGSL/gpsResolve.compute.js

@@ -0,0 +1,41 @@
+// Do not edit.
+import { ShaderStore } from "../Engines/shaderStore.js";
+import { gaussianPointSplattingWGSL } from "./ShadersInclude/gaussianPointSplatting.js";
+const name = "gpsResolveComputeShader";
+const shader = `#include<gaussianPointSplatting>
+struct GpsResolveParams {resolution : vec2f, 
+outResolution : vec2f,
+depthNorm : vec2f, 
+colorMask : vec2f, 
+upsample : vec4f, 
+misc2 : vec4f, 
+projZ : vec4f, 
+inverseProjection : mat4x4f,
+occlusion : vec4f, };@group(0) @binding(0) var<storage,read_write> accumBuffer : array<vec4f>;@group(0) @binding(1) var<uniform> params : GpsResolveParams;@group(0) @binding(2) var<storage,read_write> imageBuffer : array<atomic<u32>>;@group(0) @binding(3) var<storage,read_write> accumDepth : array<f32>;@group(0) @binding(4) var<storage,read_write> hiZ : array<f32>; 
+@group(0) @binding(5) var<storage,read_write> accumCount : array<u32>; 
+const GPS_HIZ_FAR : f32=1e30; 
+@compute @workgroup_size(8,8,1)
+fn main(@builtin(global_invocation_id) gid : vec3u) {let res=vec2u(params.resolution); 
+if (gid.x>=res.x || gid.y>=res.y) {return;}
+let idx=gid.y*res.x+gid.x; 
+let raw=atomicLoad(&imageBuffer[idx]);var hitColor=vec3f(0.0,0.0,0.0);var hit=0.0;var depth=1.0;var occlVz=GPS_HIZ_FAR;var viewZ=0.0;if (raw != GPS_DEPTH_CLEAR) {hitColor=gpsKeyColor(raw,u32(params.colorMask.x))*params.colorMask.y;hit=1.0;let dq=f32(raw>>16u)/f32(GPS_DEPTH_MAX_CODE);let vz=params.depthNorm.x+dq*(params.depthNorm.y-params.depthNorm.x);occlVz=vz+(params.depthNorm.y-params.depthNorm.x)/f32(GPS_DEPTH_MAX_CODE);depth=(params.projZ.x*vz+params.projZ.z)/(params.projZ.y*vz+params.projZ.w);if (params.misc2.w>0.5) {depth=select(vz,1.0-vz,params.misc2.z>0.5);let outputPixel=vec2f(gid.xy)*params.upsample.x+params.upsample.yz+0.5;let ndcXY=outputPixel/params.outResolution*2.0-1.0;let unprojected=params.inverseProjection*vec4f(ndcXY,depth,1.0);viewZ=unprojected.z/unprojected.w;}}
+if (params.occlusion.x>0.5) {hiZ[idx]=occlVz;}
+atomicStore(&imageBuffer[idx],GPS_DEPTH_CLEAR);let n=u32(params.upsample.x);let outRes=vec2u(params.outResolution);let gen=u32(params.upsample.w);let premult=hitColor*hit;if (params.misc2.y>0.5) {for (var dy=0u; dy<n; dy=dy+1u) {for (var dx=0u; dx<n; dx=dx+1u) {let ox2=gid.x*n+dx;let oy2=gid.y*n+dy;if (ox2<outRes.x && oy2<outRes.y) {let oi=oy2*outRes.x+ox2;var outputDepth=depth;var outputHit=hit;if (params.misc2.w>0.5 && hit>0.5) {let ndcXY=(vec2f(f32(ox2),f32(oy2))+0.5)/params.outResolution*2.0-1.0;let projected=gpsProjectedDepth(params.inverseProjection,ndcXY,viewZ);outputDepth=projected.x;outputHit=select(0.0,hit,projected.x>=0.0 && projected.x<=1.0 && projected.y>0.0);}
+accumBuffer[oi]=vec4f(hitColor*outputHit,outputHit);accumCount[oi]=(gen<<16u) | 1u;accumDepth[oi]=select(1.0,outputDepth,outputHit>0.5);}}}
+return;}
+let ox=select(0u,u32(params.upsample.y),n>1u);let oy=select(0u,u32(params.upsample.z),n>1u);let outX=gid.x*n+ox;let outY=gid.y*n+oy;if (outX>=outRes.x || outY>=outRes.y) {return;}
+let outIdx=outY*outRes.x+outX;let packed=accumCount[outIdx];let count=select(0u,packed & 0xFFFFu,(packed>>16u)==gen);let t=select(1.0/(f32(count)+1.0),1.0,count==0u);let prev=accumBuffer[outIdx];let newRgb=mix(prev.rgb,premult,t);let newCov=mix(prev.w,hit,t);accumBuffer[outIdx]=vec4f(newRgb,newCov);accumCount[outIdx]=(gen<<16u) | min(count+1u,u32(params.misc2.x));if (hit>0.5) {accumDepth[outIdx]=depth;} else if (count==0u) {accumDepth[outIdx]=1.0;}}
+`;
+// Sideeffect
+if (!ShaderStore.ShadersStoreWGSL[name]) {
+    ShaderStore.ShadersStoreWGSL[name] = shader;
+}
+const includes = [gaussianPointSplattingWGSL];
+for (const inc of includes) {
+    if (!ShaderStore.IncludesShadersStoreWGSL[inc.name]) {
+        ShaderStore.IncludesShadersStoreWGSL[inc.name] = inc.shader;
+    }
+}
+/** @internal */
+export const gpsResolveComputeShaderWGSL = { name, shader };
+//# sourceMappingURL=gpsResolve.compute.js.map

package/ShadersWGSL/gpsResolve.compute.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gpsResolve.compute.js","sourceRoot":"","sources":["../../../../dev/core/src/ShadersWGSL/gpsResolve.compute.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,0BAA0B,EAAE,MAAM,yCAAyC,CAAC;AAErF,MAAM,IAAI,GAAG,yBAAyB,CAAC;AACvC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;CAuBd,CAAC;AACF,aAAa;AACb,IAAI,CAAC,WAAW,CAAC,gBAAgB,CAAC,IAAI,CAAC,EAAE,CAAC;IACtC,WAAW,CAAC,gBAAgB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,CAAC;AACD,MAAM,QAAQ,GAAG,CAAC,0BAA0B,CAAC,CAAC;AAC9C,KAAK,MAAM,GAAG,IAAI,QAAQ,EAAE,CAAC;IACzB,IAAI,CAAC,WAAW,CAAC,wBAAwB,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;QAClD,WAAW,CAAC,wBAAwB,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC;IAChE,CAAC;AACL,CAAC;AAED,gBAAgB;AAChB,MAAM,CAAC,MAAM,2BAA2B,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\nimport { gaussianPointSplattingWGSL } from \"./ShadersInclude/gaussianPointSplatting\";\n\nconst name = \"gpsResolveComputeShader\";\nconst shader = `#include<gaussianPointSplatting>\nstruct GpsResolveParams {resolution : vec2f, \noutResolution : vec2f,\ndepthNorm : vec2f, \ncolorMask : vec2f, \nupsample : vec4f, \nmisc2 : vec4f, \nprojZ : vec4f, \ninverseProjection : mat4x4f,\nocclusion : vec4f, };@group(0) @binding(0) var<storage,read_write> accumBuffer : array<vec4f>;@group(0) @binding(1) var<uniform> params : GpsResolveParams;@group(0) @binding(2) var<storage,read_write> imageBuffer : array<atomic<u32>>;@group(0) @binding(3) var<storage,read_write> accumDepth : array<f32>;@group(0) @binding(4) var<storage,read_write> hiZ : array<f32>; \n@group(0) @binding(5) var<storage,read_write> accumCount : array<u32>; \nconst GPS_HIZ_FAR : f32=1e30; \n@compute @workgroup_size(8,8,1)\nfn main(@builtin(global_invocation_id) gid : vec3u) {let res=vec2u(params.resolution); \nif (gid.x>=res.x || gid.y>=res.y) {return;}\nlet idx=gid.y*res.x+gid.x; \nlet raw=atomicLoad(&imageBuffer[idx]);var hitColor=vec3f(0.0,0.0,0.0);var hit=0.0;var depth=1.0;var occlVz=GPS_HIZ_FAR;var viewZ=0.0;if (raw != GPS_DEPTH_CLEAR) {hitColor=gpsKeyColor(raw,u32(params.colorMask.x))*params.colorMask.y;hit=1.0;let dq=f32(raw>>16u)/f32(GPS_DEPTH_MAX_CODE);let vz=params.depthNorm.x+dq*(params.depthNorm.y-params.depthNorm.x);occlVz=vz+(params.depthNorm.y-params.depthNorm.x)/f32(GPS_DEPTH_MAX_CODE);depth=(params.projZ.x*vz+params.projZ.z)/(params.projZ.y*vz+params.projZ.w);if (params.misc2.w>0.5) {depth=select(vz,1.0-vz,params.misc2.z>0.5);let outputPixel=vec2f(gid.xy)*params.upsample.x+params.upsample.yz+0.5;let ndcXY=outputPixel/params.outResolution*2.0-1.0;let unprojected=params.inverseProjection*vec4f(ndcXY,depth,1.0);viewZ=unprojected.z/unprojected.w;}}\nif (params.occlusion.x>0.5) {hiZ[idx]=occlVz;}\natomicStore(&imageBuffer[idx],GPS_DEPTH_CLEAR);let n=u32(params.upsample.x);let outRes=vec2u(params.outResolution);let gen=u32(params.upsample.w);let premult=hitColor*hit;if (params.misc2.y>0.5) {for (var dy=0u; dy<n; dy=dy+1u) {for (var dx=0u; dx<n; dx=dx+1u) {let ox2=gid.x*n+dx;let oy2=gid.y*n+dy;if (ox2<outRes.x && oy2<outRes.y) {let oi=oy2*outRes.x+ox2;var outputDepth=depth;var outputHit=hit;if (params.misc2.w>0.5 && hit>0.5) {let ndcXY=(vec2f(f32(ox2),f32(oy2))+0.5)/params.outResolution*2.0-1.0;let projected=gpsProjectedDepth(params.inverseProjection,ndcXY,viewZ);outputDepth=projected.x;outputHit=select(0.0,hit,projected.x>=0.0 && projected.x<=1.0 && projected.y>0.0);}\naccumBuffer[oi]=vec4f(hitColor*outputHit,outputHit);accumCount[oi]=(gen<<16u) | 1u;accumDepth[oi]=select(1.0,outputDepth,outputHit>0.5);}}}\nreturn;}\nlet ox=select(0u,u32(params.upsample.y),n>1u);let oy=select(0u,u32(params.upsample.z),n>1u);let outX=gid.x*n+ox;let outY=gid.y*n+oy;if (outX>=outRes.x || outY>=outRes.y) {return;}\nlet outIdx=outY*outRes.x+outX;let packed=accumCount[outIdx];let count=select(0u,packed & 0xFFFFu,(packed>>16u)==gen);let t=select(1.0/(f32(count)+1.0),1.0,count==0u);let prev=accumBuffer[outIdx];let newRgb=mix(prev.rgb,premult,t);let newCov=mix(prev.w,hit,t);accumBuffer[outIdx]=vec4f(newRgb,newCov);accumCount[outIdx]=(gen<<16u) | min(count+1u,u32(params.misc2.x));if (hit>0.5) {accumDepth[outIdx]=depth;} else if (count==0u) {accumDepth[outIdx]=1.0;}}\n`;\n// Sideeffect\nif (!ShaderStore.ShadersStoreWGSL[name]) {\n    ShaderStore.ShadersStoreWGSL[name] = shader;\n}\nconst includes = [gaussianPointSplattingWGSL];\nfor (const inc of includes) {\n    if (!ShaderStore.IncludesShadersStoreWGSL[inc.name]) {\n        ShaderStore.IncludesShadersStoreWGSL[inc.name] = inc.shader;\n    }\n}\n\n/** @internal */\nexport const gpsResolveComputeShaderWGSL = { name, shader };\n"]}

package/ShadersWGSL/gpsScanAdd.compute.d.ts

@@ -0,0 +1,5 @@
+/** @internal */
+export declare const gpsScanAddComputeShaderWGSL: {
+    name: string;
+    shader: string;
+};

package/ShadersWGSL/gpsScanAdd.compute.js

@@ -0,0 +1,22 @@
+// Do not edit.
+import { ShaderStore } from "../Engines/shaderStore.js";
+import { gaussianPointSplattingScanWGSL } from "./ShadersInclude/gaussianPointSplattingScan.js";
+const name = "gpsScanAddComputeShader";
+const shader = `#include<gaussianPointSplattingScan>
+@group(0) @binding(0) var<storage,read_write> cdf : array<u32>;@group(0) @binding(1) var<storage,read> blockSums : array<u32>;@compute @workgroup_size(256,1,1)
+fn main(@builtin(global_invocation_id) gid : vec3u) {let i=gid.y*65535u*256u+gid.x;if (i>=arrayLength(&cdf)) {return;}
+cdf[i]=gpsSaturatingAdd(cdf[i],blockSums[i/512u]);}
+`;
+// Sideeffect
+if (!ShaderStore.ShadersStoreWGSL[name]) {
+    ShaderStore.ShadersStoreWGSL[name] = shader;
+}
+const includes = [gaussianPointSplattingScanWGSL];
+for (const inc of includes) {
+    if (!ShaderStore.IncludesShadersStoreWGSL[inc.name]) {
+        ShaderStore.IncludesShadersStoreWGSL[inc.name] = inc.shader;
+    }
+}
+/** @internal */
+export const gpsScanAddComputeShaderWGSL = { name, shader };
+//# sourceMappingURL=gpsScanAdd.compute.js.map

package/ShadersWGSL/gpsScanAdd.compute.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gpsScanAdd.compute.js","sourceRoot":"","sources":["../../../../dev/core/src/ShadersWGSL/gpsScanAdd.compute.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,8BAA8B,EAAE,MAAM,6CAA6C,CAAC;AAE7F,MAAM,IAAI,GAAG,yBAAyB,CAAC;AACvC,MAAM,MAAM,GAAG;;;;CAId,CAAC;AACF,aAAa;AACb,IAAI,CAAC,WAAW,CAAC,gBAAgB,CAAC,IAAI,CAAC,EAAE,CAAC;IACtC,WAAW,CAAC,gBAAgB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,CAAC;AACD,MAAM,QAAQ,GAAG,CAAC,8BAA8B,CAAC,CAAC;AAClD,KAAK,MAAM,GAAG,IAAI,QAAQ,EAAE,CAAC;IACzB,IAAI,CAAC,WAAW,CAAC,wBAAwB,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;QAClD,WAAW,CAAC,wBAAwB,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC;IAChE,CAAC;AACL,CAAC;AAED,gBAAgB;AAChB,MAAM,CAAC,MAAM,2BAA2B,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\nimport { gaussianPointSplattingScanWGSL } from \"./ShadersInclude/gaussianPointSplattingScan\";\n\nconst name = \"gpsScanAddComputeShader\";\nconst shader = `#include<gaussianPointSplattingScan>\n@group(0) @binding(0) var<storage,read_write> cdf : array<u32>;@group(0) @binding(1) var<storage,read> blockSums : array<u32>;@compute @workgroup_size(256,1,1)\nfn main(@builtin(global_invocation_id) gid : vec3u) {let i=gid.y*65535u*256u+gid.x;if (i>=arrayLength(&cdf)) {return;}\ncdf[i]=gpsSaturatingAdd(cdf[i],blockSums[i/512u]);}\n`;\n// Sideeffect\nif (!ShaderStore.ShadersStoreWGSL[name]) {\n    ShaderStore.ShadersStoreWGSL[name] = shader;\n}\nconst includes = [gaussianPointSplattingScanWGSL];\nfor (const inc of includes) {\n    if (!ShaderStore.IncludesShadersStoreWGSL[inc.name]) {\n        ShaderStore.IncludesShadersStoreWGSL[inc.name] = inc.shader;\n    }\n}\n\n/** @internal */\nexport const gpsScanAddComputeShaderWGSL = { name, shader };\n"]}

package/ShadersWGSL/gpsScanBlocks.compute.d.ts

@@ -0,0 +1,5 @@
+/** @internal */
+export declare const gpsScanBlocksComputeShaderWGSL: {
+    name: string;
+    shader: string;
+};

package/ShadersWGSL/gpsScanBlocks.compute.js

@@ -0,0 +1,23 @@
+// Do not edit.
+import { ShaderStore } from "../Engines/shaderStore.js";
+import { gaussianPointSplattingScanWGSL } from "./ShadersInclude/gaussianPointSplattingScan.js";
+const name = "gpsScanBlocksComputeShader";
+const shader = `#include<gaussianPointSplattingScan>
+@group(0) @binding(0) var<storage,read> weights : array<u32>;@group(0) @binding(1) var<storage,read_write> cdf : array<u32>;@group(0) @binding(2) var<storage,read_write> blockSums : array<u32>;@compute @workgroup_size(256,1,1)
+fn main(@builtin(local_invocation_id) lid : vec3u,@builtin(workgroup_id) wid : vec3u) {let t=lid.x;let block=wid.y*65535u+wid.x;let base=block*512u;let n=arrayLength(&weights);let i0=base+2u*t;let i1=base+2u*t+1u;gpsScanTemp[2u*t]=select(0u,weights[i0],i0<n);gpsScanTemp[2u*t+1u]=select(0u,weights[i1],i1<n);let total=gpsScanExclusive512(t);if (t==0u) {blockSums[block]=total;}
+if (i0<n) {cdf[i0]=gpsScanTemp[2u*t];}
+if (i1<n) {cdf[i1]=gpsScanTemp[2u*t+1u];}}
+`;
+// Sideeffect
+if (!ShaderStore.ShadersStoreWGSL[name]) {
+    ShaderStore.ShadersStoreWGSL[name] = shader;
+}
+const includes = [gaussianPointSplattingScanWGSL];
+for (const inc of includes) {
+    if (!ShaderStore.IncludesShadersStoreWGSL[inc.name]) {
+        ShaderStore.IncludesShadersStoreWGSL[inc.name] = inc.shader;
+    }
+}
+/** @internal */
+export const gpsScanBlocksComputeShaderWGSL = { name, shader };
+//# sourceMappingURL=gpsScanBlocks.compute.js.map

package/ShadersWGSL/gpsScanBlocks.compute.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gpsScanBlocks.compute.js","sourceRoot":"","sources":["../../../../dev/core/src/ShadersWGSL/gpsScanBlocks.compute.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,8BAA8B,EAAE,MAAM,6CAA6C,CAAC;AAE7F,MAAM,IAAI,GAAG,4BAA4B,CAAC;AAC1C,MAAM,MAAM,GAAG;;;;;CAKd,CAAC;AACF,aAAa;AACb,IAAI,CAAC,WAAW,CAAC,gBAAgB,CAAC,IAAI,CAAC,EAAE,CAAC;IACtC,WAAW,CAAC,gBAAgB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,CAAC;AACD,MAAM,QAAQ,GAAG,CAAC,8BAA8B,CAAC,CAAC;AAClD,KAAK,MAAM,GAAG,IAAI,QAAQ,EAAE,CAAC;IACzB,IAAI,CAAC,WAAW,CAAC,wBAAwB,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;QAClD,WAAW,CAAC,wBAAwB,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC;IAChE,CAAC;AACL,CAAC;AAED,gBAAgB;AAChB,MAAM,CAAC,MAAM,8BAA8B,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\nimport { gaussianPointSplattingScanWGSL } from \"./ShadersInclude/gaussianPointSplattingScan\";\n\nconst name = \"gpsScanBlocksComputeShader\";\nconst shader = `#include<gaussianPointSplattingScan>\n@group(0) @binding(0) var<storage,read> weights : array<u32>;@group(0) @binding(1) var<storage,read_write> cdf : array<u32>;@group(0) @binding(2) var<storage,read_write> blockSums : array<u32>;@compute @workgroup_size(256,1,1)\nfn main(@builtin(local_invocation_id) lid : vec3u,@builtin(workgroup_id) wid : vec3u) {let t=lid.x;let block=wid.y*65535u+wid.x;let base=block*512u;let n=arrayLength(&weights);let i0=base+2u*t;let i1=base+2u*t+1u;gpsScanTemp[2u*t]=select(0u,weights[i0],i0<n);gpsScanTemp[2u*t+1u]=select(0u,weights[i1],i1<n);let total=gpsScanExclusive512(t);if (t==0u) {blockSums[block]=total;}\nif (i0<n) {cdf[i0]=gpsScanTemp[2u*t];}\nif (i1<n) {cdf[i1]=gpsScanTemp[2u*t+1u];}}\n`;\n// Sideeffect\nif (!ShaderStore.ShadersStoreWGSL[name]) {\n    ShaderStore.ShadersStoreWGSL[name] = shader;\n}\nconst includes = [gaussianPointSplattingScanWGSL];\nfor (const inc of includes) {\n    if (!ShaderStore.IncludesShadersStoreWGSL[inc.name]) {\n        ShaderStore.IncludesShadersStoreWGSL[inc.name] = inc.shader;\n    }\n}\n\n/** @internal */\nexport const gpsScanBlocksComputeShaderWGSL = { name, shader };\n"]}

package/ShadersWGSL/gpsScanSums.compute.d.ts

@@ -0,0 +1,5 @@
+/** @internal */
+export declare const gpsScanSumsComputeShaderWGSL: {
+    name: string;
+    shader: string;
+};

package/ShadersWGSL/gpsScanSums.compute.js

@@ -0,0 +1,30 @@
+// Do not edit.
+import { ShaderStore } from "../Engines/shaderStore.js";
+import { gaussianPointSplattingScanWGSL } from "./ShadersInclude/gaussianPointSplattingScan.js";
+const name = "gpsScanSumsComputeShader";
+const shader = `#include<gaussianPointSplattingScan>
+@group(0) @binding(0) var<storage,read_write> blockSums : array<u32>;@group(0) @binding(1) var<storage,read_write> pointCount : array<u32>;@group(0) @binding(2) var<storage,read_write> indirectArgs : array<u32>;var<workgroup> wgCarry : u32;var<workgroup> wgChunkTotal : u32;@compute @workgroup_size(256,1,1)
+fn main(@builtin(local_invocation_id) lid : vec3u) {let t=lid.x;let n=arrayLength(&blockSums);if (t==0u) {wgCarry=0u;}
+workgroupBarrier();var chunk=0u;loop {if (chunk>=n) {break;}
+let i0=chunk+2u*t;let i1=chunk+2u*t+1u;gpsScanTemp[2u*t]=select(0u,blockSums[i0],i0<n);gpsScanTemp[2u*t+1u]=select(0u,blockSums[i1],i1<n);let total=gpsScanExclusive512(t);if (t==0u) {wgChunkTotal=total;}
+workgroupBarrier();if (i0<n) {blockSums[i0]=gpsSaturatingAdd(gpsScanTemp[2u*t],wgCarry);}
+if (i1<n) {blockSums[i1]=gpsSaturatingAdd(gpsScanTemp[2u*t+1u],wgCarry);}
+workgroupBarrier();if (t==0u) {wgCarry=gpsSaturatingAdd(wgCarry,wgChunkTotal);}
+workgroupBarrier();chunk=chunk+512u;}
+if (t==0u) {let totalGroups=wgCarry/256u+select(0u,1u,(wgCarry % 256u) != 0u);let gx=min(totalGroups,65535u);let gy=totalGroups/65535u+select(0u,1u,(totalGroups % 65535u) != 0u);pointCount[0]=wgCarry; 
+pointCount[1]=totalGroups; 
+indirectArgs[0]=gx;indirectArgs[1]=gy;indirectArgs[2]=1u;}}
+`;
+// Sideeffect
+if (!ShaderStore.ShadersStoreWGSL[name]) {
+    ShaderStore.ShadersStoreWGSL[name] = shader;
+}
+const includes = [gaussianPointSplattingScanWGSL];
+for (const inc of includes) {
+    if (!ShaderStore.IncludesShadersStoreWGSL[inc.name]) {
+        ShaderStore.IncludesShadersStoreWGSL[inc.name] = inc.shader;
+    }
+}
+/** @internal */
+export const gpsScanSumsComputeShaderWGSL = { name, shader };
+//# sourceMappingURL=gpsScanSums.compute.js.map

package/ShadersWGSL/gpsScanSums.compute.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gpsScanSums.compute.js","sourceRoot":"","sources":["../../../../dev/core/src/ShadersWGSL/gpsScanSums.compute.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,8BAA8B,EAAE,MAAM,6CAA6C,CAAC;AAE7F,MAAM,IAAI,GAAG,0BAA0B,CAAC;AACxC,MAAM,MAAM,GAAG;;;;;;;;;;;;CAYd,CAAC;AACF,aAAa;AACb,IAAI,CAAC,WAAW,CAAC,gBAAgB,CAAC,IAAI,CAAC,EAAE,CAAC;IACtC,WAAW,CAAC,gBAAgB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,CAAC;AACD,MAAM,QAAQ,GAAG,CAAC,8BAA8B,CAAC,CAAC;AAClD,KAAK,MAAM,GAAG,IAAI,QAAQ,EAAE,CAAC;IACzB,IAAI,CAAC,WAAW,CAAC,wBAAwB,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;QAClD,WAAW,CAAC,wBAAwB,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC;IAChE,CAAC;AACL,CAAC;AAED,gBAAgB;AAChB,MAAM,CAAC,MAAM,4BAA4B,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\nimport { gaussianPointSplattingScanWGSL } from \"./ShadersInclude/gaussianPointSplattingScan\";\n\nconst name = \"gpsScanSumsComputeShader\";\nconst shader = `#include<gaussianPointSplattingScan>\n@group(0) @binding(0) var<storage,read_write> blockSums : array<u32>;@group(0) @binding(1) var<storage,read_write> pointCount : array<u32>;@group(0) @binding(2) var<storage,read_write> indirectArgs : array<u32>;var<workgroup> wgCarry : u32;var<workgroup> wgChunkTotal : u32;@compute @workgroup_size(256,1,1)\nfn main(@builtin(local_invocation_id) lid : vec3u) {let t=lid.x;let n=arrayLength(&blockSums);if (t==0u) {wgCarry=0u;}\nworkgroupBarrier();var chunk=0u;loop {if (chunk>=n) {break;}\nlet i0=chunk+2u*t;let i1=chunk+2u*t+1u;gpsScanTemp[2u*t]=select(0u,blockSums[i0],i0<n);gpsScanTemp[2u*t+1u]=select(0u,blockSums[i1],i1<n);let total=gpsScanExclusive512(t);if (t==0u) {wgChunkTotal=total;}\nworkgroupBarrier();if (i0<n) {blockSums[i0]=gpsSaturatingAdd(gpsScanTemp[2u*t],wgCarry);}\nif (i1<n) {blockSums[i1]=gpsSaturatingAdd(gpsScanTemp[2u*t+1u],wgCarry);}\nworkgroupBarrier();if (t==0u) {wgCarry=gpsSaturatingAdd(wgCarry,wgChunkTotal);}\nworkgroupBarrier();chunk=chunk+512u;}\nif (t==0u) {let totalGroups=wgCarry/256u+select(0u,1u,(wgCarry % 256u) != 0u);let gx=min(totalGroups,65535u);let gy=totalGroups/65535u+select(0u,1u,(totalGroups % 65535u) != 0u);pointCount[0]=wgCarry; \npointCount[1]=totalGroups; \nindirectArgs[0]=gx;indirectArgs[1]=gy;indirectArgs[2]=1u;}}\n`;\n// Sideeffect\nif (!ShaderStore.ShadersStoreWGSL[name]) {\n    ShaderStore.ShadersStoreWGSL[name] = shader;\n}\nconst includes = [gaussianPointSplattingScanWGSL];\nfor (const inc of includes) {\n    if (!ShaderStore.IncludesShadersStoreWGSL[inc.name]) {\n        ShaderStore.IncludesShadersStoreWGSL[inc.name] = inc.shader;\n    }\n}\n\n/** @internal */\nexport const gpsScanSumsComputeShaderWGSL = { name, shader };\n"]}

package/ShadersWGSL/gpsSplat.compute.d.ts

@@ -0,0 +1,5 @@
+/** @internal */
+export declare const gpsSplatComputeShaderWGSL: {
+    name: string;
+    shader: string;
+};

package/ShadersWGSL/gpsSplat.compute.js

@@ -0,0 +1,37 @@
+// Do not edit.
+import { ShaderStore } from "../Engines/shaderStore.js";
+import { gaussianPointSplattingWGSL } from "./ShadersInclude/gaussianPointSplatting.js";
+const name = "gpsSplatComputeShader";
+const shader = `#include<gaussianPointSplatting>
+@group(0) @binding(0) var<storage,read> cdf : array<u32>;@group(0) @binding(1) var<storage,read> gsData : array<GpsScreen>;@group(0) @binding(2) var<storage,read_write> imageBuffer : array<atomic<u32>>;@group(0) @binding(3) var<uniform> uniforms : GpsUniforms;@group(0) @binding(4) var<storage,read> pointCount : array<u32>;@group(0) @binding(5) var<storage,read> partTable : array<u32>; 
+fn gpsFindGaussian(p : u32,loInit : u32,hiInit : u32)->u32 {var lo=loInit;var hi=hiInit;loop {if (lo+1u>=hi) {break;}
+let mid=(lo+hi)>>1u;if (cdf[mid]<=p) {lo=mid;} else {hi=mid;}}
+return lo;}
+@compute @workgroup_size(256,1,1)
+fn main(@builtin(global_invocation_id) gid : vec3u) {let p=gid.y*65535u*256u+gid.x;let total=pointCount[0];if (p>=total) {return;}
+let count=u32(uniforms.params0.x);let bucket=min(u32(max(f32(p)/f32(total)*f32(GPS_PARTITION_BUCKETS),0.0)),GPS_PARTITION_BUCKETS-1u);let loB=select(bucket-1u,0u,bucket==0u);let hiB=min(bucket+2u,GPS_PARTITION_BUCKETS);let g=gpsFindGaussian(p,partTable[loB],min(partTable[hiB]+1u,count));let s=gsData[g];let pixelMean=gpsGetPixelMean(s);let conic=gpsGetConic(s);let chol=gpsGetChol(s);let opacity=s.colorOp.w;let saturate=(s.depth.y & GPS_FLAG_SATURATE) != 0u;var st=gpsHash2(p,u32(uniforms.params0.w));st=gpsPcg(st);let u1=gpsUnit(st);st=gpsPcg(st);let u2=gpsUnit(st);var offset : vec2f;if ((s.depth.y & GPS_FLAG_SCREEN_RECT) != 0u) {let rectMin=vec2f(f32(s.depth.z & 0xFFFFu),f32(s.depth.z>>16u));let rectMax=vec2f(f32(s.depth.w & 0xFFFFu),f32(s.depth.w>>16u));offset=mix(rectMin,rectMax,vec2f(u1,u2))-pixelMean;} else {var z : vec2f;if (saturate) {let r=sqrt(u1)*2.8284271; 
+let ang=GPS_TWO_PI*u2;z=vec2f(r*cos(ang),r*sin(ang));} else {z=gpsCorrectedBoxMuller(u1,u2,opacity);}
+offset=vec2f(chol.x*z.x,chol.y*z.x+chol.z*z.y);}
+let mahalanobis2=conic.x*offset.x*offset.x+2.0*conic.y*offset.x*offset.y+conic.z*offset.y*offset.y;if (mahalanobis2>8.0) {return;}
+let pixel=floor(pixelMean+offset);let x=i32(pixel.x);let y=i32(pixel.y);let res=vec2i(vec2u(uniforms.resNearFar.xy));if (x<0 || y<0 || x>=res.x || y>=res.y) {return;}
+let alpha=select(opacity*exp(-0.5*mahalanobis2),opacity,saturate);if (alpha<0.00392) { 
+return;}
+if ((s.depth.y & GPS_FLAG_SCREEN_RECT) != 0u) {st=gpsPcg(st);if (gpsUnit(st)*gpsPointIntensity(opacity)>=gpsPointIntensity(alpha)) {return;}}
+st=gpsPcg(st);let dr=gpsUnit(st)-0.5;st=gpsPcg(st);let dg=gpsUnit(st)-0.5;st=gpsPcg(st);let db=gpsUnit(st)-0.5;let dithered=s.colorOp.rgb/uniforms.projectedDepth.z+vec3f(dr/31.0,dg/63.0,db/31.0);var depthKey=s.depth.x;if ((u32(uniforms.misc.w) & 2u) != 0u) {let ndcXY=((pixel+0.5-uniforms.pixelMap.zw)/uniforms.pixelMap.xy)*2.0-1.0;let projected=gpsProjectedDepth(uniforms.inverseProjection,ndcXY,bitcast<f32>(s.depth.x));if (!(projected.x>=0.0 && projected.x<=1.0 && projected.y>0.0)) {return;}
+let ordered=select(projected.x,1.0-projected.x,(u32(uniforms.misc.w) & 4u) != 0u);let normalized=clamp((ordered-uniforms.projectedDepth.x)/max(uniforms.projectedDepth.y-uniforms.projectedDepth.x,1e-6),0.0,1.0);depthKey=u32(normalized*f32(GPS_DEPTH_MAX_CODE));}
+let key=gpsPackKey(depthKey,gpsPackRGB565(dithered) ^ u32(uniforms.misc.z));let idx=u32(y)*u32(res.x)+u32(x);if (atomicLoad(&imageBuffer[idx])<=key) {return;}
+atomicMin(&imageBuffer[idx],key);}
+`;
+// Sideeffect
+if (!ShaderStore.ShadersStoreWGSL[name]) {
+    ShaderStore.ShadersStoreWGSL[name] = shader;
+}
+const includes = [gaussianPointSplattingWGSL];
+for (const inc of includes) {
+    if (!ShaderStore.IncludesShadersStoreWGSL[inc.name]) {
+        ShaderStore.IncludesShadersStoreWGSL[inc.name] = inc.shader;
+    }
+}
+/** @internal */
+export const gpsSplatComputeShaderWGSL = { name, shader };
+//# sourceMappingURL=gpsSplat.compute.js.map

package/ShadersWGSL/gpsSplat.compute.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gpsSplat.compute.js","sourceRoot":"","sources":["../../../../dev/core/src/ShadersWGSL/gpsSplat.compute.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,0BAA0B,EAAE,MAAM,yCAAyC,CAAC;AAErF,MAAM,IAAI,GAAG,uBAAuB,CAAC;AACrC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;CAmBd,CAAC;AACF,aAAa;AACb,IAAI,CAAC,WAAW,CAAC,gBAAgB,CAAC,IAAI,CAAC,EAAE,CAAC;IACtC,WAAW,CAAC,gBAAgB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AAChD,CAAC;AACD,MAAM,QAAQ,GAAG,CAAC,0BAA0B,CAAC,CAAC;AAC9C,KAAK,MAAM,GAAG,IAAI,QAAQ,EAAE,CAAC;IACzB,IAAI,CAAC,WAAW,CAAC,wBAAwB,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;QAClD,WAAW,CAAC,wBAAwB,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC;IAChE,CAAC;AACL,CAAC;AAED,gBAAgB;AAChB,MAAM,CAAC,MAAM,yBAAyB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\nimport { gaussianPointSplattingWGSL } from \"./ShadersInclude/gaussianPointSplatting\";\n\nconst name = \"gpsSplatComputeShader\";\nconst shader = `#include<gaussianPointSplatting>\n@group(0) @binding(0) var<storage,read> cdf : array<u32>;@group(0) @binding(1) var<storage,read> gsData : array<GpsScreen>;@group(0) @binding(2) var<storage,read_write> imageBuffer : array<atomic<u32>>;@group(0) @binding(3) var<uniform> uniforms : GpsUniforms;@group(0) @binding(4) var<storage,read> pointCount : array<u32>;@group(0) @binding(5) var<storage,read> partTable : array<u32>; \nfn gpsFindGaussian(p : u32,loInit : u32,hiInit : u32)->u32 {var lo=loInit;var hi=hiInit;loop {if (lo+1u>=hi) {break;}\nlet mid=(lo+hi)>>1u;if (cdf[mid]<=p) {lo=mid;} else {hi=mid;}}\nreturn lo;}\n@compute @workgroup_size(256,1,1)\nfn main(@builtin(global_invocation_id) gid : vec3u) {let p=gid.y*65535u*256u+gid.x;let total=pointCount[0];if (p>=total) {return;}\nlet count=u32(uniforms.params0.x);let bucket=min(u32(max(f32(p)/f32(total)*f32(GPS_PARTITION_BUCKETS),0.0)),GPS_PARTITION_BUCKETS-1u);let loB=select(bucket-1u,0u,bucket==0u);let hiB=min(bucket+2u,GPS_PARTITION_BUCKETS);let g=gpsFindGaussian(p,partTable[loB],min(partTable[hiB]+1u,count));let s=gsData[g];let pixelMean=gpsGetPixelMean(s);let conic=gpsGetConic(s);let chol=gpsGetChol(s);let opacity=s.colorOp.w;let saturate=(s.depth.y & GPS_FLAG_SATURATE) != 0u;var st=gpsHash2(p,u32(uniforms.params0.w));st=gpsPcg(st);let u1=gpsUnit(st);st=gpsPcg(st);let u2=gpsUnit(st);var offset : vec2f;if ((s.depth.y & GPS_FLAG_SCREEN_RECT) != 0u) {let rectMin=vec2f(f32(s.depth.z & 0xFFFFu),f32(s.depth.z>>16u));let rectMax=vec2f(f32(s.depth.w & 0xFFFFu),f32(s.depth.w>>16u));offset=mix(rectMin,rectMax,vec2f(u1,u2))-pixelMean;} else {var z : vec2f;if (saturate) {let r=sqrt(u1)*2.8284271; \nlet ang=GPS_TWO_PI*u2;z=vec2f(r*cos(ang),r*sin(ang));} else {z=gpsCorrectedBoxMuller(u1,u2,opacity);}\noffset=vec2f(chol.x*z.x,chol.y*z.x+chol.z*z.y);}\nlet mahalanobis2=conic.x*offset.x*offset.x+2.0*conic.y*offset.x*offset.y+conic.z*offset.y*offset.y;if (mahalanobis2>8.0) {return;}\nlet pixel=floor(pixelMean+offset);let x=i32(pixel.x);let y=i32(pixel.y);let res=vec2i(vec2u(uniforms.resNearFar.xy));if (x<0 || y<0 || x>=res.x || y>=res.y) {return;}\nlet alpha=select(opacity*exp(-0.5*mahalanobis2),opacity,saturate);if (alpha<0.00392) { \nreturn;}\nif ((s.depth.y & GPS_FLAG_SCREEN_RECT) != 0u) {st=gpsPcg(st);if (gpsUnit(st)*gpsPointIntensity(opacity)>=gpsPointIntensity(alpha)) {return;}}\nst=gpsPcg(st);let dr=gpsUnit(st)-0.5;st=gpsPcg(st);let dg=gpsUnit(st)-0.5;st=gpsPcg(st);let db=gpsUnit(st)-0.5;let dithered=s.colorOp.rgb/uniforms.projectedDepth.z+vec3f(dr/31.0,dg/63.0,db/31.0);var depthKey=s.depth.x;if ((u32(uniforms.misc.w) & 2u) != 0u) {let ndcXY=((pixel+0.5-uniforms.pixelMap.zw)/uniforms.pixelMap.xy)*2.0-1.0;let projected=gpsProjectedDepth(uniforms.inverseProjection,ndcXY,bitcast<f32>(s.depth.x));if (!(projected.x>=0.0 && projected.x<=1.0 && projected.y>0.0)) {return;}\nlet ordered=select(projected.x,1.0-projected.x,(u32(uniforms.misc.w) & 4u) != 0u);let normalized=clamp((ordered-uniforms.projectedDepth.x)/max(uniforms.projectedDepth.y-uniforms.projectedDepth.x,1e-6),0.0,1.0);depthKey=u32(normalized*f32(GPS_DEPTH_MAX_CODE));}\nlet key=gpsPackKey(depthKey,gpsPackRGB565(dithered) ^ u32(uniforms.misc.z));let idx=u32(y)*u32(res.x)+u32(x);if (atomicLoad(&imageBuffer[idx])<=key) {return;}\natomicMin(&imageBuffer[idx],key);}\n`;\n// Sideeffect\nif (!ShaderStore.ShadersStoreWGSL[name]) {\n    ShaderStore.ShadersStoreWGSL[name] = shader;\n}\nconst includes = [gaussianPointSplattingWGSL];\nfor (const inc of includes) {\n    if (!ShaderStore.IncludesShadersStoreWGSL[inc.name]) {\n        ShaderStore.IncludesShadersStoreWGSL[inc.name] = inc.shader;\n    }\n}\n\n/** @internal */\nexport const gpsSplatComputeShaderWGSL = { name, shader };\n"]}