@onerjs/core 9.0.0 → 9.0.2

package/ShadersWGSL/ShadersInclude/gaussianPointSplatting.js

@@ -0,0 +1,65 @@
+// Do not edit.
+import { ShaderStore } from "../../Engines/shaderStore.js";
+const name = "gaussianPointSplatting";
+const shader = `const GPS_DEPTH_CLEAR : u32=0xFFFFFFFFu;const GPS_DEPTH_MAX_CODE : u32=65534u;const GPS_TWO_PI : f32=6.2831853071795864;const GPS_U32_TO_UNIT : f32=2.3283064365386963e-10; 
+const GPS_PARTITION_BUCKETS : u32=65536u;struct GpsUniforms {view : mat4x4f,
+viewProjection : mat4x4f,
+resNearFar : vec4f,
+params0 : vec4f, 
+focal : vec4f, 
+camPosDeg : vec4f, 
+depthNorm : vec4f, 
+hiZInfo : vec4f, 
+misc : vec4f, 
+pixelMap : vec4f, 
+projection : mat4x4f,
+inverseProjection : mat4x4f,
+projectedDepth : vec4f,};fn gpsProjectedDepth(inverseProjection : mat4x4f,ndcXY : vec2f,viewZ : f32)->vec2f {let origin=inverseProjection*vec4f(ndcXY,0.0,1.0);let direction=inverseProjection[2];let depth=(viewZ*origin.w-origin.z)/(direction.z-viewZ*direction.w);return vec2f(depth,1.0/(origin.w+depth*direction.w));}
+fn gpsCov2D(covA : vec3f,covB : vec3f,modelView : mat4x4f,projection : mat4x4f,clip : vec4f,pixelScale : vec2f)->mat3x3f {let rowW=vec3f(projection[0].w,projection[1].w,projection[2].w);let rowX=vec3f(projection[0].x,projection[1].x,projection[2].x);let rowY=vec3f(projection[0].y,projection[1].y,projection[2].y);let jx=(rowX-clip.x/clip.w*rowW)*(0.5*pixelScale.x/clip.w);let jy=(rowY-clip.y/clip.w*rowW)*(0.5*pixelScale.y/clip.w);let J=mat3x3f(jx,jy,vec3f(0.0));let T=transpose(mat3x3f(modelView[0].xyz,modelView[1].xyz,modelView[2].xyz))*J;let covariance=mat3x3f(covA.x,covA.y,covA.z,covA.y,covB.x,covB.y,covA.z,covB.y,covB.z);return transpose(T)*covariance*T;}
+struct GpsPart {world : mat4x4f,
+vis : vec4f, 
+dbg0 : vec4f, 
+dbg1 : vec4f, 
+dbg2 : vec4f, 
+dbg3 : vec4f, 
+dbg4 : vec4f, };fn gpsInverseMat3(inMatrix : mat3x3f)->mat3x3f {let a00=inMatrix[0][0]; let a01=inMatrix[0][1]; let a02=inMatrix[0][2];let a10=inMatrix[1][0]; let a11=inMatrix[1][1]; let a12=inMatrix[1][2];let a20=inMatrix[2][0]; let a21=inMatrix[2][1]; let a22=inMatrix[2][2];let b01=a22*a11-a12*a21;let b11=-a22*a10+a12*a20;let b21=a21*a10-a11*a20;let det=a00*b01+a01*b11+a02*b21;return mat3x3f(b01/det,(-a22*a01+a02*a21)/det,(a12*a01-a02*a11)/det,
+b11/det,(a22*a00-a02*a20)/det,(-a12*a00+a02*a10)/det,
+b21/det,(-a21*a00+a01*a20)/det,(a11*a00-a01*a10)/det);}
+struct GpsScreen {pmConicXY : vec4f,
+conicZChol : vec4f,
+colorOp : vec4f, 
+depth : vec4u, };const GPS_FLAG_SATURATE : u32=1u; 
+const GPS_FLAG_SCREEN_RECT : u32=2u;const GPS_MAX_ALPHA : f32=0.999;fn gpsPointIntensity(alpha : f32)->f32 {return -log(1.0-min(alpha,GPS_MAX_ALPHA));}
+fn gpsGetPixelMean(s : GpsScreen)->vec2f { return s.pmConicXY.xy; }
+fn gpsGetConic(s : GpsScreen)->vec3f { return vec3f(s.pmConicXY.z,s.pmConicXY.w,s.conicZChol.x); }
+fn gpsGetChol(s : GpsScreen)->vec3f { return s.conicZChol.yzw; }
+fn gpsPackRGB565(c : vec3f)->u32 {let r=u32(clamp(c.r,0.0,1.0)*31.0+0.5);let g=u32(clamp(c.g,0.0,1.0)*63.0+0.5);let b=u32(clamp(c.b,0.0,1.0)*31.0+0.5);return (r<<11u) | (g<<5u) | b;}
+fn gpsUnpackRGB565(v : u32)->vec3f {return vec3f(
+f32((v>>11u) & 31u)/31.0,
+f32((v>>5u) & 63u)/63.0,
+f32(v & 31u)/31.0
+);}
+fn gpsPackKey(depthKey : u32,colorKey : u32)->u32 {return (depthKey<<16u) | (colorKey & 0xFFFFu);}
+fn gpsKeyColor(key : u32,mask : u32)->vec3f {return gpsUnpackRGB565((key ^ mask) & 0xFFFFu);}
+fn gpsPcg(vIn : u32)->u32 {let state=vIn*747796405u+2891336453u;let word=((state>>((state>>28u)+4u)) ^ state)*277803737u;return (word>>22u) ^ word;}
+fn gpsHash2(a : u32,b : u32)->u32 {return gpsPcg(a ^ gpsPcg(b));}
+fn gpsUnit(state : u32)->f32 {return f32(state)*GPS_U32_TO_UNIT;}
+fn gpsBoxMuller(u1 : f32,u2 : f32)->vec2f {let r=sqrt(-2.0*log(max(1e-7,u1)));let theta=GPS_TWO_PI*u2;return vec2f(r*cos(theta),r*sin(theta));}
+const GPS_LI2_MAX : f32=1.6449340668482264; 
+fn gpsDilog(x : f32)->f32 {var y=-6.09201442e-01;y=y*x+1.79126616e+00;y=y*x+-2.14953223e+00;y=y*x+1.26304372e+00;y=y*x+-4.59069895e-01;y=y*x+-1.87417414e-01;y=y*x+1.99603130e+00;y=y*x+5.99669467e-05;let s=1.0-x;if (s>0.0) {y+=s*log(max(s,1e-37));}
+return y;}
+fn gpsInvDilog(x : f32)->f32 {let t=min(x/GPS_LI2_MAX,1.0);var y=-1.27463503e+01;y=y*t+5.88993459e+01;y=y*t+-1.16025780e+02;y=y*t+1.26945827e+02;y=y*t+-8.43108826e+01;y=y*t+3.48799862e+01;y=y*t+-8.89606235e+00;y=y*t+1.38640936e+00;y=y*t+-7.80640876e-01;y=y*t+1.64841888e+00;y=y*t+-2.82836687e-05;return y;}
+fn gpsCorrectedBoxMuller(u1 : f32,u2 : f32,alpha : f32)->vec2f {var a=(1.0/max(alpha,1e-37))*gpsInvDilog((1.0-u1)*gpsDilog(alpha));a=clamp(a,1e-37,1.0);let r=sqrt(max(-2.0*log(a),0.0));let theta=GPS_TWO_PI*u2;return vec2f(r*cos(theta),r*sin(theta));}
+const GPS_POISSON_SMALL_MEAN : f32=12.0;fn gpsPoisson(seed : u32,lambda : f32)->u32 {let st1=gpsPcg(seed);if (lambda<GPS_POISSON_SMALL_MEAN) {let u=gpsUnit(st1);var p=exp(-lambda);var cdf=p;var k=0u;loop {if (u<cdf || (f32(k)>lambda && p<1e-7)) {break;}
+k=k+1u;p=p*lambda/f32(k);cdf=cdf+p;}
+return k;}
+let st2=gpsPcg(st1);let w=gpsBoxMuller(gpsUnit(st1),gpsUnit(st2)).x;let w2=w*w;let w3=w2*w;let w4=w2*w2;let s=sqrt(lambda);let invS=1.0/s;let invL=1.0/lambda;var kf=lambda+s*w+(w2-1.0)/6.0;kf+=invS*(-(1.0/36.0)*w-(1.0/72.0)*w3);kf+=invL*(-(8.0/405.0)+(7.0/810.0)*w2+(1.0/270.0)*w4);return u32(max(i32(round(kf)),0));}
+fn gpsGaussianValue(conic : vec3f,d : vec2f)->f32 {let power=-0.5*(conic.x*d.x*d.x+conic.z*d.y*d.y)-conic.y*d.x*d.y;return exp(power);}
+`;
+// Sideeffect
+if (!ShaderStore.IncludesShadersStoreWGSL[name]) {
+    ShaderStore.IncludesShadersStoreWGSL[name] = shader;
+}
+/** @internal */
+export const gaussianPointSplattingWGSL = { name, shader };
+//# sourceMappingURL=gaussianPointSplatting.js.map

package/ShadersWGSL/ShadersInclude/gaussianPointSplatting.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gaussianPointSplatting.js","sourceRoot":"","sources":["../../../../../dev/core/src/ShadersWGSL/ShadersInclude/gaussianPointSplatting.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AACxD,MAAM,IAAI,GAAG,wBAAwB,CAAC;AACtC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsDd,CAAC;AACF,aAAa;AACb,IAAI,CAAC,WAAW,CAAC,wBAAwB,CAAC,IAAI,CAAC,EAAE,CAAC;IAC9C,WAAW,CAAC,wBAAwB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxD,CAAC;AACD,gBAAgB;AAChB,MAAM,CAAC,MAAM,0BAA0B,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../../Engines/shaderStore\";\nconst name = \"gaussianPointSplatting\";\nconst shader = `const GPS_DEPTH_CLEAR : u32=0xFFFFFFFFu;const GPS_DEPTH_MAX_CODE : u32=65534u;const GPS_TWO_PI : f32=6.2831853071795864;const GPS_U32_TO_UNIT : f32=2.3283064365386963e-10; \nconst GPS_PARTITION_BUCKETS : u32=65536u;struct GpsUniforms {view : mat4x4f,\nviewProjection : mat4x4f,\nresNearFar : vec4f,\nparams0 : vec4f, \nfocal : vec4f, \ncamPosDeg : vec4f, \ndepthNorm : vec4f, \nhiZInfo : vec4f, \nmisc : vec4f, \npixelMap : vec4f, \nprojection : mat4x4f,\ninverseProjection : mat4x4f,\nprojectedDepth : vec4f,};fn gpsProjectedDepth(inverseProjection : mat4x4f,ndcXY : vec2f,viewZ : f32)->vec2f {let origin=inverseProjection*vec4f(ndcXY,0.0,1.0);let direction=inverseProjection[2];let depth=(viewZ*origin.w-origin.z)/(direction.z-viewZ*direction.w);return vec2f(depth,1.0/(origin.w+depth*direction.w));}\nfn gpsCov2D(covA : vec3f,covB : vec3f,modelView : mat4x4f,projection : mat4x4f,clip : vec4f,pixelScale : vec2f)->mat3x3f {let rowW=vec3f(projection[0].w,projection[1].w,projection[2].w);let rowX=vec3f(projection[0].x,projection[1].x,projection[2].x);let rowY=vec3f(projection[0].y,projection[1].y,projection[2].y);let jx=(rowX-clip.x/clip.w*rowW)*(0.5*pixelScale.x/clip.w);let jy=(rowY-clip.y/clip.w*rowW)*(0.5*pixelScale.y/clip.w);let J=mat3x3f(jx,jy,vec3f(0.0));let T=transpose(mat3x3f(modelView[0].xyz,modelView[1].xyz,modelView[2].xyz))*J;let covariance=mat3x3f(covA.x,covA.y,covA.z,covA.y,covB.x,covB.y,covA.z,covB.y,covB.z);return transpose(T)*covariance*T;}\nstruct GpsPart {world : mat4x4f,\nvis : vec4f, \ndbg0 : vec4f, \ndbg1 : vec4f, \ndbg2 : vec4f, \ndbg3 : vec4f, \ndbg4 : vec4f, };fn gpsInverseMat3(inMatrix : mat3x3f)->mat3x3f {let a00=inMatrix[0][0]; let a01=inMatrix[0][1]; let a02=inMatrix[0][2];let a10=inMatrix[1][0]; let a11=inMatrix[1][1]; let a12=inMatrix[1][2];let a20=inMatrix[2][0]; let a21=inMatrix[2][1]; let a22=inMatrix[2][2];let b01=a22*a11-a12*a21;let b11=-a22*a10+a12*a20;let b21=a21*a10-a11*a20;let det=a00*b01+a01*b11+a02*b21;return mat3x3f(b01/det,(-a22*a01+a02*a21)/det,(a12*a01-a02*a11)/det,\nb11/det,(a22*a00-a02*a20)/det,(-a12*a00+a02*a10)/det,\nb21/det,(-a21*a00+a01*a20)/det,(a11*a00-a01*a10)/det);}\nstruct GpsScreen {pmConicXY : vec4f,\nconicZChol : vec4f,\ncolorOp : vec4f, \ndepth : vec4u, };const GPS_FLAG_SATURATE : u32=1u; \nconst GPS_FLAG_SCREEN_RECT : u32=2u;const GPS_MAX_ALPHA : f32=0.999;fn gpsPointIntensity(alpha : f32)->f32 {return -log(1.0-min(alpha,GPS_MAX_ALPHA));}\nfn gpsGetPixelMean(s : GpsScreen)->vec2f { return s.pmConicXY.xy; }\nfn gpsGetConic(s : GpsScreen)->vec3f { return vec3f(s.pmConicXY.z,s.pmConicXY.w,s.conicZChol.x); }\nfn gpsGetChol(s : GpsScreen)->vec3f { return s.conicZChol.yzw; }\nfn gpsPackRGB565(c : vec3f)->u32 {let r=u32(clamp(c.r,0.0,1.0)*31.0+0.5);let g=u32(clamp(c.g,0.0,1.0)*63.0+0.5);let b=u32(clamp(c.b,0.0,1.0)*31.0+0.5);return (r<<11u) | (g<<5u) | b;}\nfn gpsUnpackRGB565(v : u32)->vec3f {return vec3f(\nf32((v>>11u) & 31u)/31.0,\nf32((v>>5u) & 63u)/63.0,\nf32(v & 31u)/31.0\n);}\nfn gpsPackKey(depthKey : u32,colorKey : u32)->u32 {return (depthKey<<16u) | (colorKey & 0xFFFFu);}\nfn gpsKeyColor(key : u32,mask : u32)->vec3f {return gpsUnpackRGB565((key ^ mask) & 0xFFFFu);}\nfn gpsPcg(vIn : u32)->u32 {let state=vIn*747796405u+2891336453u;let word=((state>>((state>>28u)+4u)) ^ state)*277803737u;return (word>>22u) ^ word;}\nfn gpsHash2(a : u32,b : u32)->u32 {return gpsPcg(a ^ gpsPcg(b));}\nfn gpsUnit(state : u32)->f32 {return f32(state)*GPS_U32_TO_UNIT;}\nfn gpsBoxMuller(u1 : f32,u2 : f32)->vec2f {let r=sqrt(-2.0*log(max(1e-7,u1)));let theta=GPS_TWO_PI*u2;return vec2f(r*cos(theta),r*sin(theta));}\nconst GPS_LI2_MAX : f32=1.6449340668482264; \nfn gpsDilog(x : f32)->f32 {var y=-6.09201442e-01;y=y*x+1.79126616e+00;y=y*x+-2.14953223e+00;y=y*x+1.26304372e+00;y=y*x+-4.59069895e-01;y=y*x+-1.87417414e-01;y=y*x+1.99603130e+00;y=y*x+5.99669467e-05;let s=1.0-x;if (s>0.0) {y+=s*log(max(s,1e-37));}\nreturn y;}\nfn gpsInvDilog(x : f32)->f32 {let t=min(x/GPS_LI2_MAX,1.0);var y=-1.27463503e+01;y=y*t+5.88993459e+01;y=y*t+-1.16025780e+02;y=y*t+1.26945827e+02;y=y*t+-8.43108826e+01;y=y*t+3.48799862e+01;y=y*t+-8.89606235e+00;y=y*t+1.38640936e+00;y=y*t+-7.80640876e-01;y=y*t+1.64841888e+00;y=y*t+-2.82836687e-05;return y;}\nfn gpsCorrectedBoxMuller(u1 : f32,u2 : f32,alpha : f32)->vec2f {var a=(1.0/max(alpha,1e-37))*gpsInvDilog((1.0-u1)*gpsDilog(alpha));a=clamp(a,1e-37,1.0);let r=sqrt(max(-2.0*log(a),0.0));let theta=GPS_TWO_PI*u2;return vec2f(r*cos(theta),r*sin(theta));}\nconst GPS_POISSON_SMALL_MEAN : f32=12.0;fn gpsPoisson(seed : u32,lambda : f32)->u32 {let st1=gpsPcg(seed);if (lambda<GPS_POISSON_SMALL_MEAN) {let u=gpsUnit(st1);var p=exp(-lambda);var cdf=p;var k=0u;loop {if (u<cdf || (f32(k)>lambda && p<1e-7)) {break;}\nk=k+1u;p=p*lambda/f32(k);cdf=cdf+p;}\nreturn k;}\nlet st2=gpsPcg(st1);let w=gpsBoxMuller(gpsUnit(st1),gpsUnit(st2)).x;let w2=w*w;let w3=w2*w;let w4=w2*w2;let s=sqrt(lambda);let invS=1.0/s;let invL=1.0/lambda;var kf=lambda+s*w+(w2-1.0)/6.0;kf+=invS*(-(1.0/36.0)*w-(1.0/72.0)*w3);kf+=invL*(-(8.0/405.0)+(7.0/810.0)*w2+(1.0/270.0)*w4);return u32(max(i32(round(kf)),0));}\nfn gpsGaussianValue(conic : vec3f,d : vec2f)->f32 {let power=-0.5*(conic.x*d.x*d.x+conic.z*d.y*d.y)-conic.y*d.x*d.y;return exp(power);}\n`;\n// Sideeffect\nif (!ShaderStore.IncludesShadersStoreWGSL[name]) {\n    ShaderStore.IncludesShadersStoreWGSL[name] = shader;\n}\n/** @internal */\nexport const gaussianPointSplattingWGSL = { name, shader };\n"]}

package/ShadersWGSL/ShadersInclude/gaussianPointSplattingScan.d.ts

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

package/ShadersWGSL/ShadersInclude/gaussianPointSplattingScan.js

@@ -0,0 +1,17 @@
+// Do not edit.
+import { ShaderStore } from "../../Engines/shaderStore.js";
+const name = "gaussianPointSplattingScan";
+const shader = `const GpsMaxPointCount : u32=0xFFFFFF00u;fn gpsSaturatingAdd(a : u32,b : u32)->u32 {let sum=a+b;return select(GpsMaxPointCount,sum,sum>=a && sum<=GpsMaxPointCount);}
+var<workgroup> gpsScanTemp : array<u32,512>;fn gpsScanExclusive512(t : u32)->u32 {var offset=1u;for (var d=256u; d>0u; d=d>>1u) {workgroupBarrier();if (t<d) {let ai=offset*(2u*t+1u)-1u;let bi=offset*(2u*t+2u)-1u;gpsScanTemp[bi]=gpsSaturatingAdd(gpsScanTemp[bi],gpsScanTemp[ai]);}
+offset=offset<<1u;}
+var total=0u;if (t==0u) {total=gpsScanTemp[511];gpsScanTemp[511]=0u; }
+for (var d=1u; d<512u; d=d<<1u) {offset=offset>>1u;workgroupBarrier();if (t<d) {let ai=offset*(2u*t+1u)-1u;let bi=offset*(2u*t+2u)-1u;let s=gpsScanTemp[ai];gpsScanTemp[ai]=gpsScanTemp[bi];gpsScanTemp[bi]=gpsSaturatingAdd(gpsScanTemp[bi],s);}}
+workgroupBarrier();return total;}
+`;
+// Sideeffect
+if (!ShaderStore.IncludesShadersStoreWGSL[name]) {
+    ShaderStore.IncludesShadersStoreWGSL[name] = shader;
+}
+/** @internal */
+export const gaussianPointSplattingScanWGSL = { name, shader };
+//# sourceMappingURL=gaussianPointSplattingScan.js.map

package/ShadersWGSL/ShadersInclude/gaussianPointSplattingScan.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gaussianPointSplattingScan.js","sourceRoot":"","sources":["../../../../../dev/core/src/ShadersWGSL/ShadersInclude/gaussianPointSplattingScan.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AACxD,MAAM,IAAI,GAAG,4BAA4B,CAAC;AAC1C,MAAM,MAAM,GAAG;;;;;;CAMd,CAAC;AACF,aAAa;AACb,IAAI,CAAC,WAAW,CAAC,wBAAwB,CAAC,IAAI,CAAC,EAAE,CAAC;IAC9C,WAAW,CAAC,wBAAwB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxD,CAAC;AACD,gBAAgB;AAChB,MAAM,CAAC,MAAM,8BAA8B,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../../Engines/shaderStore\";\nconst name = \"gaussianPointSplattingScan\";\nconst shader = `const GpsMaxPointCount : u32=0xFFFFFF00u;fn gpsSaturatingAdd(a : u32,b : u32)->u32 {let sum=a+b;return select(GpsMaxPointCount,sum,sum>=a && sum<=GpsMaxPointCount);}\nvar<workgroup> gpsScanTemp : array<u32,512>;fn gpsScanExclusive512(t : u32)->u32 {var offset=1u;for (var d=256u; d>0u; d=d>>1u) {workgroupBarrier();if (t<d) {let ai=offset*(2u*t+1u)-1u;let bi=offset*(2u*t+2u)-1u;gpsScanTemp[bi]=gpsSaturatingAdd(gpsScanTemp[bi],gpsScanTemp[ai]);}\noffset=offset<<1u;}\nvar total=0u;if (t==0u) {total=gpsScanTemp[511];gpsScanTemp[511]=0u; }\nfor (var d=1u; d<512u; d=d<<1u) {offset=offset>>1u;workgroupBarrier();if (t<d) {let ai=offset*(2u*t+1u)-1u;let bi=offset*(2u*t+2u)-1u;let s=gpsScanTemp[ai];gpsScanTemp[ai]=gpsScanTemp[bi];gpsScanTemp[bi]=gpsSaturatingAdd(gpsScanTemp[bi],s);}}\nworkgroupBarrier();return total;}\n`;\n// Sideeffect\nif (!ShaderStore.IncludesShadersStoreWGSL[name]) {\n    ShaderStore.IncludesShadersStoreWGSL[name] = shader;\n}\n/** @internal */\nexport const gaussianPointSplattingScanWGSL = { name, shader };\n"]}

package/ShadersWGSL/ShadersInclude/gaussianSplatting.d.ts

@@ -1,3 +1,4 @@
+import "./gaussianSplattingShared.js";
 /** @internal */
 export declare const gaussianSplattingWGSL: {
     name: string;

package/ShadersWGSL/ShadersInclude/gaussianSplatting.js

@@ -1,5 +1,6 @@
 // Do not edit.
 import { ShaderStore } from "../../Engines/shaderStore.js";
+import "./gaussianSplattingShared.js";
 const name = "gaussianSplatting";
 const shader = `fn getDataUV(index: f32,dataTextureSize: vec2f)->vec2<f32> {let y: f32=floor(index/dataTextureSize.x);let x: f32=index-y*dataTextureSize.x;return vec2f((x+0.5),(y+0.5));}
 struct Splat {center: vec4f,
@@ -116,66 +117,7 @@ splat.partIndex=u32(textureLoad(partIndicesTexture,splatUVi32,0).r*255.0+0.5);
 splat.rotationA=textureLoad(rotationsATexture,splatUVi32,0);splat.rotationB=textureLoad(rotationsBTexture,splatUVi32,0);splat.rotationScale=textureLoad(rotationScaleTexture,splatUVi32,0);
 #endif
 return splat;}
-fn computeColorFromSHDegree(dir: vec3f,sh: array<vec3<f32>,25>,_so1: f32,_so2: f32,_so3: f32,_so4: f32)->vec3f
-{let SH_C0: f32=0.28209479;let SH_C1: f32=0.48860251;var SH_C2: array<f32,5>=array<f32,5>(
-1.092548430,
--1.09254843,
-0.315391565,
--1.09254843,
-0.546274215
-);var SH_C3: array<f32,7>=array<f32,7>(
--0.59004358,
-2.890611442,
--0.45704579,
-0.373176332,
--0.45704579,
-1.445305721,
--0.59004358
-);var SH_C4: array<f32,9>=array<f32,9>(
-2.5033429418,
--1.7701307698,
-0.9461746958,
--0.6690465436,
-0.1057855469,
--0.6690465436,
-0.4730873479,
--1.7701307698,
-0.6258357354
-);var result: vec3f=/*SH_C0**/sh[0];
-#if SH_DEGREE>0
-let x: f32=dir.x;let y: f32=dir.y;let z: f32=dir.z;result+=_so1*(-SH_C1*y*sh[1]+SH_C1*z*sh[2]-SH_C1*x*sh[3]);
-#if SH_DEGREE>1
-let xx: f32=x*x;let yy: f32=y*y;let zz: f32=z*z;let xy: f32=x*y;let yz: f32=y*z;let xz: f32=x*z;result+=_so2*(
-SH_C2[0]*xy*sh[4] +
-SH_C2[1]*yz*sh[5] +
-SH_C2[2]*(2.0f*zz-xx-yy)*sh[6] +
-SH_C2[3]*xz*sh[7] +
-SH_C2[4]*(xx-yy)*sh[8]);
-#if SH_DEGREE>2
-result+=_so3*(
-SH_C3[0]*y*(3.0f*xx-yy)*sh[9] +
-SH_C3[1]*xy*z*sh[10] +
-SH_C3[2]*y*(4.0f*zz-xx-yy)*sh[11] +
-SH_C3[3]*z*(2.0f*zz-3.0f*xx-3.0f*yy)*sh[12] +
-SH_C3[4]*x*(4.0f*zz-xx-yy)*sh[13] +
-SH_C3[5]*z*(xx-yy)*sh[14] +
-SH_C3[6]*x*(xx-3.0f*yy)*sh[15]);
-#if SH_DEGREE>3
-result+=_so4*(
-SH_C4[0]*x*y*(xx-yy)*sh[16] +
-SH_C4[1]*y*z*(3.0f*xx-yy)*sh[17] +
-SH_C4[2]*x*y*(7.0f*zz-1.0f)*sh[18] +
-SH_C4[3]*y*z*(7.0f*zz-3.0f)*sh[19] +
-SH_C4[4]*(zz*(35.0f*zz-30.0f)+3.0f)*sh[20] +
-SH_C4[5]*x*z*(7.0f*zz-3.0f)*sh[21] +
-SH_C4[6]*(xx-yy)*(7.0f*zz-1.0f)*sh[22] +
-SH_C4[7]*x*z*(xx-3.0f*yy)*sh[23] +
-SH_C4[8]*(xx*(xx-3.0f*yy)-yy*(3.0f*xx-yy))*sh[24]);
-#endif
-#endif
-#endif
-#endif
-return result;}
+#include<gaussianSplattingShared>
 fn decompose(value: u32)->vec4f
 {let components : vec4f=vec4f(
 f32((value ) & 255u),
@@ -253,23 +195,7 @@ invViewport: vec2f,
 kernelSize: f32,
 minPixelSize: f32
 )->vec4f {let modelView=viewMatrix*worldMatrix;let camspace=viewMatrix*vec4f(worldPos,1.0);let pos2d=projectionMatrix*camspace;let bounds=1.2*pos2d.w;if (pos2d.z<0. || pos2d.x<-bounds || pos2d.x>bounds || pos2d.y<-bounds || pos2d.y>bounds) {return vec4f(0.0,0.0,2.0,1.0);}
-let Vrk=mat3x3<f32>(
-covA.x,covA.y,covA.z,
-covA.y,covB.x,covB.y,
-covA.z,covB.y,covB.z
-);let isOrtho=abs(projectionMatrix[3][3]-1.0)<0.001;var J: mat3x3<f32>;if (isOrtho) {J=mat3x3<f32>(
-focal.x,0.0,0.0,
-0.0,focal.y,0.0,
-0.0,0.0,0.0
-);} else {J=mat3x3<f32>(
-focal.x/camspace.z,0.0,-(focal.x*camspace.x)/(camspace.z*camspace.z),
-0.0,focal.y/camspace.z,-(focal.y*camspace.y)/(camspace.z*camspace.z),
-0.0,0.0,0.0
-);}
-let T=transpose(mat3x3<f32>(
-modelView[0].xyz,
-modelView[1].xyz,
-modelView[2].xyz))*J;var cov2d=transpose(T)*Vrk*T;
+let isOrtho=abs(projectionMatrix[3][3]-1.0)<0.001;var cov2d=computeCov2D(covA,covB,modelView,camspace.xyz,focal,isOrtho);
 #if COMPENSATION
 let c00: f32=cov2d[0][0];let c11: f32=cov2d[1][1];let c01: f32=cov2d[0][1];let detOrig: f32=c00*c11-c01*c01;
 #endif
@@ -279,7 +205,9 @@ let c2d: vec3f=vec3f(cov2d[0][0],c01,cov2d[1][1]);let detBlur: f32=c2d.x*c2d.z-c
 #endif
 let mid=(cov2d[0][0]+cov2d[1][1])/2.0;let radius=length(vec2<f32>((cov2d[0][0]-cov2d[1][1])/2.0,cov2d[0][1]));let lambda1=mid+radius;let lambda2=mid-radius;if (lambda2<0.0) {return vec4f(0.0,0.0,2.0,1.0);}
 if (minPixelSize>0.0) {let l1=2.0*min(sqrt(2.0*lambda1),1024.0);let l2=2.0*min(sqrt(2.0*lambda2),1024.0);if (max(l1,l2)<minPixelSize) {return vec4f(0.0,0.0,2.0,1.0);}}
-let diagonalVector=normalize(vec2<f32>(cov2d[0][1],lambda1-cov2d[0][0]));let majorAxis=min(sqrt(2.0*lambda1),1024.0)*diagonalVector;let minorAxis=min(sqrt(2.0*lambda2),1024.0)*vec2<f32>(diagonalVector.y,-diagonalVector.x);let vCenter=vec2<f32>(pos2d.x,pos2d.y);let scaleFactor=select(pos2d.w,1.0,isOrtho);return vec4f(
+let diagonalVector=normalize(vec2<f32>(cov2d[0][1],lambda1-cov2d[0][0]));let majorAxis=min(sqrt(2.0*lambda1),1024.0)*diagonalVector;let minorAxis=min(sqrt(2.0*lambda2),1024.0)*vec2<f32>(diagonalVector.y,-diagonalVector.x);
+#define CUSTOM_GAUSSIAN_SPLAT_PROJECTED_SIZE
+let vCenter=vec2<f32>(pos2d.x,pos2d.y);let scaleFactor=select(pos2d.w,1.0,isOrtho);return vec4f(
 vCenter+((meshPos.x*majorAxis+meshPos.y*minorAxis)*invViewport*scaleFactor)*scale,
 pos2d.z,
 pos2d.w

package/ShadersWGSL/ShadersInclude/gaussianSplatting.js.map

@@ -1 +1 @@
-{"version":3,"file":"gaussianSplatting.js","sourceRoot":"","sources":["../../../../../dev/core/src/ShadersWGSL/ShadersInclude/gaussianSplatting.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AACxD,MAAM,IAAI,GAAG,mBAAmB,CAAC;AACjC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuSd,CAAC;AACF,aAAa;AACb,IAAI,CAAC,WAAW,CAAC,wBAAwB,CAAC,IAAI,CAAC,EAAE,CAAC;IAC9C,WAAW,CAAC,wBAAwB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxD,CAAC;AACD,gBAAgB;AAChB,MAAM,CAAC,MAAM,qBAAqB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../../Engines/shaderStore\";\nconst name = \"gaussianSplatting\";\nconst shader = `fn getDataUV(index: f32,dataTextureSize: vec2f)->vec2<f32> {let y: f32=floor(index/dataTextureSize.x);let x: f32=index-y*dataTextureSize.x;return vec2f((x+0.5),(y+0.5));}\nstruct Splat {center: vec4f,\ncolor: vec4f,\ncovA: vec4f,\ncovB: vec4f,\n#if SH_DEGREE>0\nsh0: vec4<u32>,\n#endif\n#if SH_DEGREE>1\nsh1: vec4<u32>,\n#endif\n#if SH_DEGREE>2\nsh2: vec4<u32>,\n#endif\n#if SH_DEGREE>3\nsh3: vec4<u32>,\nsh4: vec4<u32>,\n#endif\n#if IS_COMPOUND\npartIndex: u32,\n#endif\n#if defined(IS_FOR_VOXELIZATION)\nrotationA: vec4f,\nrotationB: vec4f,\nrotationScale: vec4f,\n#endif\n#ifdef USE_SOG\nsplatIndex: f32,\n#endif\n};fn getSplatIndex(localIndex: i32,splatIndex0: vec4f,splatIndex1: vec4f,splatIndex2: vec4f,splatIndex3: vec4f)->f32 {var splatIndex: f32;switch (localIndex)\n{case 0:\n{splatIndex=splatIndex0.x;break;}\ncase 1:\n{splatIndex=splatIndex0.y;break;}\ncase 2:\n{splatIndex=splatIndex0.z;break;}\ncase 3:\n{splatIndex=splatIndex0.w;break;}\ncase 4:\n{splatIndex=splatIndex1.x;break;}\ncase 5:\n{splatIndex=splatIndex1.y;break;}\ncase 6:\n{splatIndex=splatIndex1.z;break;}\ncase 7:\n{splatIndex=splatIndex1.w;break;}\ncase 8:\n{splatIndex=splatIndex2.x;break;}\ncase 9:\n{splatIndex=splatIndex2.y;break;}\ncase 10:\n{splatIndex=splatIndex2.z;break;}\ncase 11:\n{splatIndex=splatIndex2.w;break;}\ncase 12:\n{splatIndex=splatIndex3.x;break;}\ncase 13:\n{splatIndex=splatIndex3.y;break;}\ncase 14:\n{splatIndex=splatIndex3.z;break;}\ndefault:\n{splatIndex=splatIndex3.w;break;}}\nreturn splatIndex;}\nfn readSplat(splatIndex: f32,dataTextureSize: vec2f)->Splat {var splat: Splat;let splatUV=getDataUV(splatIndex,dataTextureSize);let splatUVi32=vec2<i32>(i32(splatUV.x),i32(splatUV.y));\n#ifdef USE_SOG\nlet mL=textureLoad(centersTexture,splatUVi32,0);let mU=textureLoad(covariancesATexture,splatUVi32,0);let sRaw=textureLoad(covariancesBTexture,splatUVi32,0);let qRaw=textureLoad(sogQuatsTexture,splatUVi32,0);let c0=textureLoad(colorsTexture,splatUVi32,0);let q16=(mU.xyz*256.0+mL.xyz)*(255.0/65535.0);let nPos=mix(uniforms.sogMeansMin,uniforms.sogMeansMax,q16);let center3=sign(nPos)*(exp(abs(nPos))-vec3f(1.0));splat.center=vec4f(center3,1.0);\n#ifdef USE_SOG_V2\nlet sIdx=floor(sRaw.xyz*255.0+0.5);var splatScale: vec3f;splatScale.x=exp(textureLoad(sogCodebookTexture,vec2<i32>(i32(sIdx.x),0),0).r);splatScale.y=exp(textureLoad(sogCodebookTexture,vec2<i32>(i32(sIdx.y),0),0).r);splatScale.z=exp(textureLoad(sogCodebookTexture,vec2<i32>(i32(sIdx.z),0),0).r);\n#else\nlet splatScale=exp(mix(uniforms.sogScalesMin,uniforms.sogScalesMax,sRaw.xyz));\n#endif\nlet invSqrt2: f32=0.70710678118;let qabc=(qRaw.xyz-vec3f(0.5))*2.0*invSqrt2;let qMode=i32(qRaw.w*255.0+0.5)-252;let qd=sqrt(max(0.0,1.0-dot(qabc,qabc)));var quat: vec4f;if (qMode==0) { quat=vec4f(qd,qabc.x,qabc.y,qabc.z); }\nelse if (qMode==1) { quat=vec4f(qabc.x,qd,qabc.y,qabc.z); }\nelse if (qMode==2) { quat=vec4f(qabc.x,qabc.y,qd,qabc.z); }\nelse { quat=vec4f(qabc.x,qabc.y,qabc.z,qd); }\nlet qw=quat.x; let qx=quat.y; let qy=quat.z; let qz=quat.w;let R=mat3x3<f32>(\n1.0-2.0*(qy*qy+qz*qz),2.0*(qx*qy+qw*qz), 2.0*(qx*qz-qw*qy),\n2.0*(qx*qy-qw*qz), 1.0-2.0*(qx*qx+qz*qz),2.0*(qy*qz+qw*qx),\n2.0*(qx*qz+qw*qy), 2.0*(qy*qz-qw*qx), 1.0-2.0*(qx*qx+qy*qy)\n);let S2=mat3x3<f32>(\n4.0*splatScale.x*splatScale.x,0.0,0.0,\n0.0,4.0*splatScale.y*splatScale.y,0.0,\n0.0,0.0,4.0*splatScale.z*splatScale.z\n);let Sigma=R*S2*transpose(R);splat.covA=vec4f(Sigma[0][0],Sigma[0][1],Sigma[0][2],Sigma[1][1]);splat.covB=vec4f(Sigma[1][2],Sigma[2][2],0.0,0.0);let SH_C0_SOG: f32=0.28209479177387814;\n#ifdef USE_SOG_V2\nvar c3: vec3f;c3.x=textureLoad(sogCodebookTexture,vec2<i32>(256+i32(c0.x*255.0+0.5),0),0).r;c3.y=textureLoad(sogCodebookTexture,vec2<i32>(256+i32(c0.y*255.0+0.5),0),0).r;c3.z=textureLoad(sogCodebookTexture,vec2<i32>(256+i32(c0.z*255.0+0.5),0),0).r;let colRgb=vec3f(0.5)+c3*SH_C0_SOG;let colA=c0.w;\n#else\nlet cLerp=mix(uniforms.sogSh0Min,uniforms.sogSh0Max,c0);let colRgb=vec3f(0.5)+cLerp.xyz*SH_C0_SOG;let colA=1.0/(1.0+exp(-cLerp.w));\n#endif\nsplat.color=vec4f(colRgb,colA);splat.splatIndex=splatIndex;\n#else\nsplat.center=textureLoad(centersTexture,splatUVi32,0);splat.color=textureLoad(colorsTexture,splatUVi32,0);\n#if !defined(IS_FOR_VOXELIZATION)\nsplat.covA=textureLoad(covariancesATexture,splatUVi32,0)*splat.center.w;splat.covB=textureLoad(covariancesBTexture,splatUVi32,0)*splat.center.w;\n#endif\n#endif\n#if SH_DEGREE>0 && !defined(USE_SOG)\nsplat.sh0=textureLoad(shTexture0,splatUVi32,0);\n#endif\n#if SH_DEGREE>1 && !defined(USE_SOG)\nsplat.sh1=textureLoad(shTexture1,splatUVi32,0);\n#endif\n#if SH_DEGREE>2 && !defined(USE_SOG)\nsplat.sh2=textureLoad(shTexture2,splatUVi32,0);\n#endif\n#if SH_DEGREE>3 && !defined(USE_SOG)\nsplat.sh3=textureLoad(shTexture3,splatUVi32,0);splat.sh4=textureLoad(shTexture4,splatUVi32,0);\n#endif\n#if IS_COMPOUND\nsplat.partIndex=u32(textureLoad(partIndicesTexture,splatUVi32,0).r*255.0+0.5);\n#endif\n#if defined(IS_FOR_VOXELIZATION)\nsplat.rotationA=textureLoad(rotationsATexture,splatUVi32,0);splat.rotationB=textureLoad(rotationsBTexture,splatUVi32,0);splat.rotationScale=textureLoad(rotationScaleTexture,splatUVi32,0);\n#endif\nreturn splat;}\nfn computeColorFromSHDegree(dir: vec3f,sh: array<vec3<f32>,25>,_so1: f32,_so2: f32,_so3: f32,_so4: f32)->vec3f\n{let SH_C0: f32=0.28209479;let SH_C1: f32=0.48860251;var SH_C2: array<f32,5>=array<f32,5>(\n1.092548430,\n-1.09254843,\n0.315391565,\n-1.09254843,\n0.546274215\n);var SH_C3: array<f32,7>=array<f32,7>(\n-0.59004358,\n2.890611442,\n-0.45704579,\n0.373176332,\n-0.45704579,\n1.445305721,\n-0.59004358\n);var SH_C4: array<f32,9>=array<f32,9>(\n2.5033429418,\n-1.7701307698,\n0.9461746958,\n-0.6690465436,\n0.1057855469,\n-0.6690465436,\n0.4730873479,\n-1.7701307698,\n0.6258357354\n);var result: vec3f=/*SH_C0**/sh[0];\n#if SH_DEGREE>0\nlet x: f32=dir.x;let y: f32=dir.y;let z: f32=dir.z;result+=_so1*(-SH_C1*y*sh[1]+SH_C1*z*sh[2]-SH_C1*x*sh[3]);\n#if SH_DEGREE>1\nlet xx: f32=x*x;let yy: f32=y*y;let zz: f32=z*z;let xy: f32=x*y;let yz: f32=y*z;let xz: f32=x*z;result+=_so2*(\nSH_C2[0]*xy*sh[4] +\nSH_C2[1]*yz*sh[5] +\nSH_C2[2]*(2.0f*zz-xx-yy)*sh[6] +\nSH_C2[3]*xz*sh[7] +\nSH_C2[4]*(xx-yy)*sh[8]);\n#if SH_DEGREE>2\nresult+=_so3*(\nSH_C3[0]*y*(3.0f*xx-yy)*sh[9] +\nSH_C3[1]*xy*z*sh[10] +\nSH_C3[2]*y*(4.0f*zz-xx-yy)*sh[11] +\nSH_C3[3]*z*(2.0f*zz-3.0f*xx-3.0f*yy)*sh[12] +\nSH_C3[4]*x*(4.0f*zz-xx-yy)*sh[13] +\nSH_C3[5]*z*(xx-yy)*sh[14] +\nSH_C3[6]*x*(xx-3.0f*yy)*sh[15]);\n#if SH_DEGREE>3\nresult+=_so4*(\nSH_C4[0]*x*y*(xx-yy)*sh[16] +\nSH_C4[1]*y*z*(3.0f*xx-yy)*sh[17] +\nSH_C4[2]*x*y*(7.0f*zz-1.0f)*sh[18] +\nSH_C4[3]*y*z*(7.0f*zz-3.0f)*sh[19] +\nSH_C4[4]*(zz*(35.0f*zz-30.0f)+3.0f)*sh[20] +\nSH_C4[5]*x*z*(7.0f*zz-3.0f)*sh[21] +\nSH_C4[6]*(xx-yy)*(7.0f*zz-1.0f)*sh[22] +\nSH_C4[7]*x*z*(xx-3.0f*yy)*sh[23] +\nSH_C4[8]*(xx*(xx-3.0f*yy)-yy*(3.0f*xx-yy))*sh[24]);\n#endif\n#endif\n#endif\n#endif\nreturn result;}\nfn decompose(value: u32)->vec4f\n{let components : vec4f=vec4f(\nf32((value ) & 255u),\nf32((value>>u32( 8)) & 255u),\nf32((value>>u32(16)) & 255u),\nf32((value>>u32(24)) & 255u));return components*vec4f(2./255.)-vec4f(1.);}\n#ifdef USE_SOG\nfn computeSH(splat: Splat,dir: vec3f)->vec3f\n{\n#if SH_DEGREE>0\nvar sh: array<vec3<f32>,25>;sh[0]=vec3f(0.,0.,0.);let labelSize=textureDimensions(sogShNLabelsTexture,0);let idx=i32(splat.splatIndex+0.5);let lw=i32(labelSize.x);let lx=idx-(idx/lw)*lw;let ly=idx/lw;let labelRaw=textureLoad(sogShNLabelsTexture,vec2<i32>(lx,ly),0);let n=i32(labelRaw.r*255.0+0.5)+i32(labelRaw.g*255.0+0.5)*256;let coeffs=i32(uniforms.sogShCoeffCount+0.5);let u=(n-(n/64)*64)*coeffs;let v=n/64;for (var k: i32=0; k<24; k=k+1) {if (k>=coeffs) { break; }\nlet centroidRaw=textureLoad(sogShNCentroidsTexture,vec2<i32>(u+k,v),0);var shCoeff: vec3f;\n#ifdef USE_SOG_V2\nlet rIdx=i32(centroidRaw.r*255.0+0.5);let gIdx=i32(centroidRaw.g*255.0+0.5);let bIdx=i32(centroidRaw.b*255.0+0.5);shCoeff.r=textureLoad(sogCodebookTexture,vec2<i32>(512+rIdx,0),0).r;shCoeff.g=textureLoad(sogCodebookTexture,vec2<i32>(512+gIdx,0),0).r;shCoeff.b=textureLoad(sogCodebookTexture,vec2<i32>(512+bIdx,0),0).r;\n#else\nshCoeff=mix(vec3f(uniforms.sogShnMin),vec3f(uniforms.sogShnMax),centroidRaw.rgb);\n#endif\nsh[k+1]=shCoeff;}\nreturn computeColorFromSHDegree(dir,sh,1.,1.,1.,1.);\n#else\nreturn vec3f(0.,0.,0.);\n#endif\n}\n#else\nfn computeSHWeighted(splat: Splat,dir: vec3f,_so1: f32,_so2: f32,_so3: f32,_so4: f32)->vec3f\n{var sh: array<vec3<f32>,25>;sh[0]=vec3f(0.,0.,0.);\n#if SH_DEGREE>0\nlet sh00: vec4f=decompose(splat.sh0.x);let sh01: vec4f=decompose(splat.sh0.y);let sh02: vec4f=decompose(splat.sh0.z);sh[1]=vec3f(sh00.x,sh00.y,sh00.z);sh[2]=vec3f(sh00.w,sh01.x,sh01.y);sh[3]=vec3f(sh01.z,sh01.w,sh02.x);\n#endif\n#if SH_DEGREE>1\nlet sh03: vec4f=decompose(splat.sh0.w);let sh04: vec4f=decompose(splat.sh1.x);let sh05: vec4f=decompose(splat.sh1.y);sh[4]=vec3f(sh02.y,sh02.z,sh02.w);sh[5]=vec3f(sh03.x,sh03.y,sh03.z);sh[6]=vec3f(sh03.w,sh04.x,sh04.y);sh[7]=vec3f(sh04.z,sh04.w,sh05.x);sh[8]=vec3f(sh05.y,sh05.z,sh05.w);\n#endif\n#if SH_DEGREE>2\nlet sh06: vec4f=decompose(splat.sh1.z);let sh07: vec4f=decompose(splat.sh1.w);let sh08: vec4f=decompose(splat.sh2.x);let sh09: vec4f=decompose(splat.sh2.y);let sh10: vec4f=decompose(splat.sh2.z);let sh11: vec4f=decompose(splat.sh2.w);sh[9]=vec3f(sh06.x,sh06.y,sh06.z);sh[10]=vec3f(sh06.w,sh07.x,sh07.y);sh[11]=vec3f(sh07.z,sh07.w,sh08.x);sh[12]=vec3f(sh08.y,sh08.z,sh08.w);sh[13]=vec3f(sh09.x,sh09.y,sh09.z);sh[14]=vec3f(sh09.w,sh10.x,sh10.y);sh[15]=vec3f(sh10.z,sh10.w,sh11.x);\n#endif\n#if SH_DEGREE>3\nlet sh12: vec4f=decompose(splat.sh3.x);let sh13: vec4f=decompose(splat.sh3.y);let sh14: vec4f=decompose(splat.sh3.z);let sh15: vec4f=decompose(splat.sh3.w);let sh16: vec4f=decompose(splat.sh4.x);let sh17: vec4f=decompose(splat.sh4.y);sh[16]=vec3f(sh11.y,sh11.z,sh11.w);sh[17]=vec3f(sh12.x,sh12.y,sh12.z);sh[18]=vec3f(sh12.w,sh13.x,sh13.y);sh[19]=vec3f(sh13.z,sh13.w,sh14.x);sh[20]=vec3f(sh14.y,sh14.z,sh14.w);sh[21]=vec3f(sh15.x,sh15.y,sh15.z);sh[22]=vec3f(sh15.w,sh16.x,sh16.y);sh[23]=vec3f(sh16.z,sh16.w,sh17.x);sh[24]=vec3f(sh17.y,sh17.z,sh17.w);\n#endif\nreturn computeColorFromSHDegree(dir,sh,_so1,_so2,_so3,_so4);}\nfn computeSH(splat: Splat,dir: vec3f)->vec3f\n{\n#if !defined(GS_DBG_ENABLED) || GS_DBG_SH_ORDER1==1\nlet _w1: f32=1.0;\n#else\nlet _w1: f32=0.0;\n#endif\n#if !defined(GS_DBG_ENABLED) || GS_DBG_SH_ORDER2==1\nlet _w2: f32=1.0;\n#else\nlet _w2: f32=0.0;\n#endif\n#if !defined(GS_DBG_ENABLED) || GS_DBG_SH_ORDER3==1\nlet _w3: f32=1.0;\n#else\nlet _w3: f32=0.0;\n#endif\n#if !defined(GS_DBG_ENABLED) || GS_DBG_SH_ORDER4==1\nlet _w4: f32=1.0;\n#else\nlet _w4: f32=0.0;\n#endif\nreturn computeSHWeighted(splat,dir,_w1,_w2,_w3,_w4);}\n#endif\nfn gaussianSplatting(\nmeshPos: vec2<f32>,\nworldPos: vec3<f32>,\nscale: vec2<f32>,\ncovA: vec3<f32>,\ncovB: vec3<f32>,\nworldMatrix: mat4x4<f32>,\nviewMatrix: mat4x4<f32>,\nprojectionMatrix: mat4x4<f32>,\nfocal: vec2f,\ninvViewport: vec2f,\nkernelSize: f32,\nminPixelSize: f32\n)->vec4f {let modelView=viewMatrix*worldMatrix;let camspace=viewMatrix*vec4f(worldPos,1.0);let pos2d=projectionMatrix*camspace;let bounds=1.2*pos2d.w;if (pos2d.z<0. || pos2d.x<-bounds || pos2d.x>bounds || pos2d.y<-bounds || pos2d.y>bounds) {return vec4f(0.0,0.0,2.0,1.0);}\nlet Vrk=mat3x3<f32>(\ncovA.x,covA.y,covA.z,\ncovA.y,covB.x,covB.y,\ncovA.z,covB.y,covB.z\n);let isOrtho=abs(projectionMatrix[3][3]-1.0)<0.001;var J: mat3x3<f32>;if (isOrtho) {J=mat3x3<f32>(\nfocal.x,0.0,0.0,\n0.0,focal.y,0.0,\n0.0,0.0,0.0\n);} else {J=mat3x3<f32>(\nfocal.x/camspace.z,0.0,-(focal.x*camspace.x)/(camspace.z*camspace.z),\n0.0,focal.y/camspace.z,-(focal.y*camspace.y)/(camspace.z*camspace.z),\n0.0,0.0,0.0\n);}\nlet T=transpose(mat3x3<f32>(\nmodelView[0].xyz,\nmodelView[1].xyz,\nmodelView[2].xyz))*J;var cov2d=transpose(T)*Vrk*T;\n#if COMPENSATION\nlet c00: f32=cov2d[0][0];let c11: f32=cov2d[1][1];let c01: f32=cov2d[0][1];let detOrig: f32=c00*c11-c01*c01;\n#endif\ncov2d[0][0]+=kernelSize;cov2d[1][1]+=kernelSize;\n#if COMPENSATION\nlet c2d: vec3f=vec3f(cov2d[0][0],c01,cov2d[1][1]);let detBlur: f32=c2d.x*c2d.z-c2d.y*c2d.y;let compensation: f32=sqrt(max(0.,detOrig/detBlur));vertexOutputs.vColor.w*=compensation;\n#endif\nlet mid=(cov2d[0][0]+cov2d[1][1])/2.0;let radius=length(vec2<f32>((cov2d[0][0]-cov2d[1][1])/2.0,cov2d[0][1]));let lambda1=mid+radius;let lambda2=mid-radius;if (lambda2<0.0) {return vec4f(0.0,0.0,2.0,1.0);}\nif (minPixelSize>0.0) {let l1=2.0*min(sqrt(2.0*lambda1),1024.0);let l2=2.0*min(sqrt(2.0*lambda2),1024.0);if (max(l1,l2)<minPixelSize) {return vec4f(0.0,0.0,2.0,1.0);}}\nlet diagonalVector=normalize(vec2<f32>(cov2d[0][1],lambda1-cov2d[0][0]));let majorAxis=min(sqrt(2.0*lambda1),1024.0)*diagonalVector;let minorAxis=min(sqrt(2.0*lambda2),1024.0)*vec2<f32>(diagonalVector.y,-diagonalVector.x);let vCenter=vec2<f32>(pos2d.x,pos2d.y);let scaleFactor=select(pos2d.w,1.0,isOrtho);return vec4f(\nvCenter+((meshPos.x*majorAxis+meshPos.y*minorAxis)*invViewport*scaleFactor)*scale,\npos2d.z,\npos2d.w\n);}\n#if IS_COMPOUND\nfn getPartWorld(partIndex: u32)->mat4x4<f32> {return uniforms.partWorld[partIndex];}\n#endif\n#if defined(IS_FOR_VOXELIZATION)\nfn computeVoxelSplatWorldPos(rotationA: vec4f,rotationB: vec4f,rotationScale: vec4f,center: vec3f,splatWorld: mat4x4f,viewMatrix: mat4x4f,invWorldScale: mat4x4f,quadPos: vec2f)->vec4f {let splatRotation=mat3x3f(\nrotationA.xyz,\nvec3f(rotationA.w,rotationB.x,rotationB.y),\nvec3f(rotationB.z,rotationB.w,rotationScale.x)\n);let splatScale=rotationScale.yzw;let view3x3=mat3x3f(viewMatrix[0].xyz,viewMatrix[1].xyz,viewMatrix[2].xyz);let invWorldScale3x3=mat3x3f(invWorldScale[0].xyz,invWorldScale[1].xyz,invWorldScale[2].xyz);let splatWorld3x3=mat3x3f(splatWorld[0].xyz,splatWorld[1].xyz,splatWorld[2].xyz);let rotToView=view3x3*invWorldScale3x3*splatWorld3x3*splatRotation;let axisLengthInViewZ=abs(vec3f(rotToView[0][2],rotToView[1][2],rotToView[2][2]));let gaussianSplatCutoffStddev: f32=0.7071067812; \nvar offsetSplatSpace: vec3f;if (axisLengthInViewZ.x>axisLengthInViewZ.y && axisLengthInViewZ.x>axisLengthInViewZ.z) {offsetSplatSpace=vec3f(0.0,quadPos.x,quadPos.y)*splatScale*gaussianSplatCutoffStddev;} else if (axisLengthInViewZ.y>axisLengthInViewZ.z) {offsetSplatSpace=vec3f(quadPos.x,0.0,quadPos.y)*splatScale*gaussianSplatCutoffStddev;} else {offsetSplatSpace=vec3f(quadPos.x,quadPos.y,0.0)*splatScale*gaussianSplatCutoffStddev;}\nlet vertexObjectSpace=center+splatRotation*offsetSplatSpace;return splatWorld*vec4f(vertexObjectSpace,1.0);}\n#endif\n`;\n// Sideeffect\nif (!ShaderStore.IncludesShadersStoreWGSL[name]) {\n    ShaderStore.IncludesShadersStoreWGSL[name] = shader;\n}\n/** @internal */\nexport const gaussianSplattingWGSL = { name, shader };\n"]}
+{"version":3,"file":"gaussianSplatting.js","sourceRoot":"","sources":["../../../../../dev/core/src/ShadersWGSL/ShadersInclude/gaussianSplatting.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AACxD,OAAO,2BAA2B,CAAC;AACnC,MAAM,IAAI,GAAG,mBAAmB,CAAC;AACjC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8Nd,CAAC;AACF,aAAa;AACb,IAAI,CAAC,WAAW,CAAC,wBAAwB,CAAC,IAAI,CAAC,EAAE,CAAC;IAC9C,WAAW,CAAC,wBAAwB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxD,CAAC;AACD,gBAAgB;AAChB,MAAM,CAAC,MAAM,qBAAqB,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../../Engines/shaderStore\";\nimport \"./gaussianSplattingShared\";\nconst name = \"gaussianSplatting\";\nconst shader = `fn getDataUV(index: f32,dataTextureSize: vec2f)->vec2<f32> {let y: f32=floor(index/dataTextureSize.x);let x: f32=index-y*dataTextureSize.x;return vec2f((x+0.5),(y+0.5));}\nstruct Splat {center: vec4f,\ncolor: vec4f,\ncovA: vec4f,\ncovB: vec4f,\n#if SH_DEGREE>0\nsh0: vec4<u32>,\n#endif\n#if SH_DEGREE>1\nsh1: vec4<u32>,\n#endif\n#if SH_DEGREE>2\nsh2: vec4<u32>,\n#endif\n#if SH_DEGREE>3\nsh3: vec4<u32>,\nsh4: vec4<u32>,\n#endif\n#if IS_COMPOUND\npartIndex: u32,\n#endif\n#if defined(IS_FOR_VOXELIZATION)\nrotationA: vec4f,\nrotationB: vec4f,\nrotationScale: vec4f,\n#endif\n#ifdef USE_SOG\nsplatIndex: f32,\n#endif\n};fn getSplatIndex(localIndex: i32,splatIndex0: vec4f,splatIndex1: vec4f,splatIndex2: vec4f,splatIndex3: vec4f)->f32 {var splatIndex: f32;switch (localIndex)\n{case 0:\n{splatIndex=splatIndex0.x;break;}\ncase 1:\n{splatIndex=splatIndex0.y;break;}\ncase 2:\n{splatIndex=splatIndex0.z;break;}\ncase 3:\n{splatIndex=splatIndex0.w;break;}\ncase 4:\n{splatIndex=splatIndex1.x;break;}\ncase 5:\n{splatIndex=splatIndex1.y;break;}\ncase 6:\n{splatIndex=splatIndex1.z;break;}\ncase 7:\n{splatIndex=splatIndex1.w;break;}\ncase 8:\n{splatIndex=splatIndex2.x;break;}\ncase 9:\n{splatIndex=splatIndex2.y;break;}\ncase 10:\n{splatIndex=splatIndex2.z;break;}\ncase 11:\n{splatIndex=splatIndex2.w;break;}\ncase 12:\n{splatIndex=splatIndex3.x;break;}\ncase 13:\n{splatIndex=splatIndex3.y;break;}\ncase 14:\n{splatIndex=splatIndex3.z;break;}\ndefault:\n{splatIndex=splatIndex3.w;break;}}\nreturn splatIndex;}\nfn readSplat(splatIndex: f32,dataTextureSize: vec2f)->Splat {var splat: Splat;let splatUV=getDataUV(splatIndex,dataTextureSize);let splatUVi32=vec2<i32>(i32(splatUV.x),i32(splatUV.y));\n#ifdef USE_SOG\nlet mL=textureLoad(centersTexture,splatUVi32,0);let mU=textureLoad(covariancesATexture,splatUVi32,0);let sRaw=textureLoad(covariancesBTexture,splatUVi32,0);let qRaw=textureLoad(sogQuatsTexture,splatUVi32,0);let c0=textureLoad(colorsTexture,splatUVi32,0);let q16=(mU.xyz*256.0+mL.xyz)*(255.0/65535.0);let nPos=mix(uniforms.sogMeansMin,uniforms.sogMeansMax,q16);let center3=sign(nPos)*(exp(abs(nPos))-vec3f(1.0));splat.center=vec4f(center3,1.0);\n#ifdef USE_SOG_V2\nlet sIdx=floor(sRaw.xyz*255.0+0.5);var splatScale: vec3f;splatScale.x=exp(textureLoad(sogCodebookTexture,vec2<i32>(i32(sIdx.x),0),0).r);splatScale.y=exp(textureLoad(sogCodebookTexture,vec2<i32>(i32(sIdx.y),0),0).r);splatScale.z=exp(textureLoad(sogCodebookTexture,vec2<i32>(i32(sIdx.z),0),0).r);\n#else\nlet splatScale=exp(mix(uniforms.sogScalesMin,uniforms.sogScalesMax,sRaw.xyz));\n#endif\nlet invSqrt2: f32=0.70710678118;let qabc=(qRaw.xyz-vec3f(0.5))*2.0*invSqrt2;let qMode=i32(qRaw.w*255.0+0.5)-252;let qd=sqrt(max(0.0,1.0-dot(qabc,qabc)));var quat: vec4f;if (qMode==0) { quat=vec4f(qd,qabc.x,qabc.y,qabc.z); }\nelse if (qMode==1) { quat=vec4f(qabc.x,qd,qabc.y,qabc.z); }\nelse if (qMode==2) { quat=vec4f(qabc.x,qabc.y,qd,qabc.z); }\nelse { quat=vec4f(qabc.x,qabc.y,qabc.z,qd); }\nlet qw=quat.x; let qx=quat.y; let qy=quat.z; let qz=quat.w;let R=mat3x3<f32>(\n1.0-2.0*(qy*qy+qz*qz),2.0*(qx*qy+qw*qz), 2.0*(qx*qz-qw*qy),\n2.0*(qx*qy-qw*qz), 1.0-2.0*(qx*qx+qz*qz),2.0*(qy*qz+qw*qx),\n2.0*(qx*qz+qw*qy), 2.0*(qy*qz-qw*qx), 1.0-2.0*(qx*qx+qy*qy)\n);let S2=mat3x3<f32>(\n4.0*splatScale.x*splatScale.x,0.0,0.0,\n0.0,4.0*splatScale.y*splatScale.y,0.0,\n0.0,0.0,4.0*splatScale.z*splatScale.z\n);let Sigma=R*S2*transpose(R);splat.covA=vec4f(Sigma[0][0],Sigma[0][1],Sigma[0][2],Sigma[1][1]);splat.covB=vec4f(Sigma[1][2],Sigma[2][2],0.0,0.0);let SH_C0_SOG: f32=0.28209479177387814;\n#ifdef USE_SOG_V2\nvar c3: vec3f;c3.x=textureLoad(sogCodebookTexture,vec2<i32>(256+i32(c0.x*255.0+0.5),0),0).r;c3.y=textureLoad(sogCodebookTexture,vec2<i32>(256+i32(c0.y*255.0+0.5),0),0).r;c3.z=textureLoad(sogCodebookTexture,vec2<i32>(256+i32(c0.z*255.0+0.5),0),0).r;let colRgb=vec3f(0.5)+c3*SH_C0_SOG;let colA=c0.w;\n#else\nlet cLerp=mix(uniforms.sogSh0Min,uniforms.sogSh0Max,c0);let colRgb=vec3f(0.5)+cLerp.xyz*SH_C0_SOG;let colA=1.0/(1.0+exp(-cLerp.w));\n#endif\nsplat.color=vec4f(colRgb,colA);splat.splatIndex=splatIndex;\n#else\nsplat.center=textureLoad(centersTexture,splatUVi32,0);splat.color=textureLoad(colorsTexture,splatUVi32,0);\n#if !defined(IS_FOR_VOXELIZATION)\nsplat.covA=textureLoad(covariancesATexture,splatUVi32,0)*splat.center.w;splat.covB=textureLoad(covariancesBTexture,splatUVi32,0)*splat.center.w;\n#endif\n#endif\n#if SH_DEGREE>0 && !defined(USE_SOG)\nsplat.sh0=textureLoad(shTexture0,splatUVi32,0);\n#endif\n#if SH_DEGREE>1 && !defined(USE_SOG)\nsplat.sh1=textureLoad(shTexture1,splatUVi32,0);\n#endif\n#if SH_DEGREE>2 && !defined(USE_SOG)\nsplat.sh2=textureLoad(shTexture2,splatUVi32,0);\n#endif\n#if SH_DEGREE>3 && !defined(USE_SOG)\nsplat.sh3=textureLoad(shTexture3,splatUVi32,0);splat.sh4=textureLoad(shTexture4,splatUVi32,0);\n#endif\n#if IS_COMPOUND\nsplat.partIndex=u32(textureLoad(partIndicesTexture,splatUVi32,0).r*255.0+0.5);\n#endif\n#if defined(IS_FOR_VOXELIZATION)\nsplat.rotationA=textureLoad(rotationsATexture,splatUVi32,0);splat.rotationB=textureLoad(rotationsBTexture,splatUVi32,0);splat.rotationScale=textureLoad(rotationScaleTexture,splatUVi32,0);\n#endif\nreturn splat;}\n#include<gaussianSplattingShared>\nfn decompose(value: u32)->vec4f\n{let components : vec4f=vec4f(\nf32((value ) & 255u),\nf32((value>>u32( 8)) & 255u),\nf32((value>>u32(16)) & 255u),\nf32((value>>u32(24)) & 255u));return components*vec4f(2./255.)-vec4f(1.);}\n#ifdef USE_SOG\nfn computeSH(splat: Splat,dir: vec3f)->vec3f\n{\n#if SH_DEGREE>0\nvar sh: array<vec3<f32>,25>;sh[0]=vec3f(0.,0.,0.);let labelSize=textureDimensions(sogShNLabelsTexture,0);let idx=i32(splat.splatIndex+0.5);let lw=i32(labelSize.x);let lx=idx-(idx/lw)*lw;let ly=idx/lw;let labelRaw=textureLoad(sogShNLabelsTexture,vec2<i32>(lx,ly),0);let n=i32(labelRaw.r*255.0+0.5)+i32(labelRaw.g*255.0+0.5)*256;let coeffs=i32(uniforms.sogShCoeffCount+0.5);let u=(n-(n/64)*64)*coeffs;let v=n/64;for (var k: i32=0; k<24; k=k+1) {if (k>=coeffs) { break; }\nlet centroidRaw=textureLoad(sogShNCentroidsTexture,vec2<i32>(u+k,v),0);var shCoeff: vec3f;\n#ifdef USE_SOG_V2\nlet rIdx=i32(centroidRaw.r*255.0+0.5);let gIdx=i32(centroidRaw.g*255.0+0.5);let bIdx=i32(centroidRaw.b*255.0+0.5);shCoeff.r=textureLoad(sogCodebookTexture,vec2<i32>(512+rIdx,0),0).r;shCoeff.g=textureLoad(sogCodebookTexture,vec2<i32>(512+gIdx,0),0).r;shCoeff.b=textureLoad(sogCodebookTexture,vec2<i32>(512+bIdx,0),0).r;\n#else\nshCoeff=mix(vec3f(uniforms.sogShnMin),vec3f(uniforms.sogShnMax),centroidRaw.rgb);\n#endif\nsh[k+1]=shCoeff;}\nreturn computeColorFromSHDegree(dir,sh,1.,1.,1.,1.);\n#else\nreturn vec3f(0.,0.,0.);\n#endif\n}\n#else\nfn computeSHWeighted(splat: Splat,dir: vec3f,_so1: f32,_so2: f32,_so3: f32,_so4: f32)->vec3f\n{var sh: array<vec3<f32>,25>;sh[0]=vec3f(0.,0.,0.);\n#if SH_DEGREE>0\nlet sh00: vec4f=decompose(splat.sh0.x);let sh01: vec4f=decompose(splat.sh0.y);let sh02: vec4f=decompose(splat.sh0.z);sh[1]=vec3f(sh00.x,sh00.y,sh00.z);sh[2]=vec3f(sh00.w,sh01.x,sh01.y);sh[3]=vec3f(sh01.z,sh01.w,sh02.x);\n#endif\n#if SH_DEGREE>1\nlet sh03: vec4f=decompose(splat.sh0.w);let sh04: vec4f=decompose(splat.sh1.x);let sh05: vec4f=decompose(splat.sh1.y);sh[4]=vec3f(sh02.y,sh02.z,sh02.w);sh[5]=vec3f(sh03.x,sh03.y,sh03.z);sh[6]=vec3f(sh03.w,sh04.x,sh04.y);sh[7]=vec3f(sh04.z,sh04.w,sh05.x);sh[8]=vec3f(sh05.y,sh05.z,sh05.w);\n#endif\n#if SH_DEGREE>2\nlet sh06: vec4f=decompose(splat.sh1.z);let sh07: vec4f=decompose(splat.sh1.w);let sh08: vec4f=decompose(splat.sh2.x);let sh09: vec4f=decompose(splat.sh2.y);let sh10: vec4f=decompose(splat.sh2.z);let sh11: vec4f=decompose(splat.sh2.w);sh[9]=vec3f(sh06.x,sh06.y,sh06.z);sh[10]=vec3f(sh06.w,sh07.x,sh07.y);sh[11]=vec3f(sh07.z,sh07.w,sh08.x);sh[12]=vec3f(sh08.y,sh08.z,sh08.w);sh[13]=vec3f(sh09.x,sh09.y,sh09.z);sh[14]=vec3f(sh09.w,sh10.x,sh10.y);sh[15]=vec3f(sh10.z,sh10.w,sh11.x);\n#endif\n#if SH_DEGREE>3\nlet sh12: vec4f=decompose(splat.sh3.x);let sh13: vec4f=decompose(splat.sh3.y);let sh14: vec4f=decompose(splat.sh3.z);let sh15: vec4f=decompose(splat.sh3.w);let sh16: vec4f=decompose(splat.sh4.x);let sh17: vec4f=decompose(splat.sh4.y);sh[16]=vec3f(sh11.y,sh11.z,sh11.w);sh[17]=vec3f(sh12.x,sh12.y,sh12.z);sh[18]=vec3f(sh12.w,sh13.x,sh13.y);sh[19]=vec3f(sh13.z,sh13.w,sh14.x);sh[20]=vec3f(sh14.y,sh14.z,sh14.w);sh[21]=vec3f(sh15.x,sh15.y,sh15.z);sh[22]=vec3f(sh15.w,sh16.x,sh16.y);sh[23]=vec3f(sh16.z,sh16.w,sh17.x);sh[24]=vec3f(sh17.y,sh17.z,sh17.w);\n#endif\nreturn computeColorFromSHDegree(dir,sh,_so1,_so2,_so3,_so4);}\nfn computeSH(splat: Splat,dir: vec3f)->vec3f\n{\n#if !defined(GS_DBG_ENABLED) || GS_DBG_SH_ORDER1==1\nlet _w1: f32=1.0;\n#else\nlet _w1: f32=0.0;\n#endif\n#if !defined(GS_DBG_ENABLED) || GS_DBG_SH_ORDER2==1\nlet _w2: f32=1.0;\n#else\nlet _w2: f32=0.0;\n#endif\n#if !defined(GS_DBG_ENABLED) || GS_DBG_SH_ORDER3==1\nlet _w3: f32=1.0;\n#else\nlet _w3: f32=0.0;\n#endif\n#if !defined(GS_DBG_ENABLED) || GS_DBG_SH_ORDER4==1\nlet _w4: f32=1.0;\n#else\nlet _w4: f32=0.0;\n#endif\nreturn computeSHWeighted(splat,dir,_w1,_w2,_w3,_w4);}\n#endif\nfn gaussianSplatting(\nmeshPos: vec2<f32>,\nworldPos: vec3<f32>,\nscale: vec2<f32>,\ncovA: vec3<f32>,\ncovB: vec3<f32>,\nworldMatrix: mat4x4<f32>,\nviewMatrix: mat4x4<f32>,\nprojectionMatrix: mat4x4<f32>,\nfocal: vec2f,\ninvViewport: vec2f,\nkernelSize: f32,\nminPixelSize: f32\n)->vec4f {let modelView=viewMatrix*worldMatrix;let camspace=viewMatrix*vec4f(worldPos,1.0);let pos2d=projectionMatrix*camspace;let bounds=1.2*pos2d.w;if (pos2d.z<0. || pos2d.x<-bounds || pos2d.x>bounds || pos2d.y<-bounds || pos2d.y>bounds) {return vec4f(0.0,0.0,2.0,1.0);}\nlet isOrtho=abs(projectionMatrix[3][3]-1.0)<0.001;var cov2d=computeCov2D(covA,covB,modelView,camspace.xyz,focal,isOrtho);\n#if COMPENSATION\nlet c00: f32=cov2d[0][0];let c11: f32=cov2d[1][1];let c01: f32=cov2d[0][1];let detOrig: f32=c00*c11-c01*c01;\n#endif\ncov2d[0][0]+=kernelSize;cov2d[1][1]+=kernelSize;\n#if COMPENSATION\nlet c2d: vec3f=vec3f(cov2d[0][0],c01,cov2d[1][1]);let detBlur: f32=c2d.x*c2d.z-c2d.y*c2d.y;let compensation: f32=sqrt(max(0.,detOrig/detBlur));vertexOutputs.vColor.w*=compensation;\n#endif\nlet mid=(cov2d[0][0]+cov2d[1][1])/2.0;let radius=length(vec2<f32>((cov2d[0][0]-cov2d[1][1])/2.0,cov2d[0][1]));let lambda1=mid+radius;let lambda2=mid-radius;if (lambda2<0.0) {return vec4f(0.0,0.0,2.0,1.0);}\nif (minPixelSize>0.0) {let l1=2.0*min(sqrt(2.0*lambda1),1024.0);let l2=2.0*min(sqrt(2.0*lambda2),1024.0);if (max(l1,l2)<minPixelSize) {return vec4f(0.0,0.0,2.0,1.0);}}\nlet diagonalVector=normalize(vec2<f32>(cov2d[0][1],lambda1-cov2d[0][0]));let majorAxis=min(sqrt(2.0*lambda1),1024.0)*diagonalVector;let minorAxis=min(sqrt(2.0*lambda2),1024.0)*vec2<f32>(diagonalVector.y,-diagonalVector.x);\n#define CUSTOM_GAUSSIAN_SPLAT_PROJECTED_SIZE\nlet vCenter=vec2<f32>(pos2d.x,pos2d.y);let scaleFactor=select(pos2d.w,1.0,isOrtho);return vec4f(\nvCenter+((meshPos.x*majorAxis+meshPos.y*minorAxis)*invViewport*scaleFactor)*scale,\npos2d.z,\npos2d.w\n);}\n#if IS_COMPOUND\nfn getPartWorld(partIndex: u32)->mat4x4<f32> {return uniforms.partWorld[partIndex];}\n#endif\n#if defined(IS_FOR_VOXELIZATION)\nfn computeVoxelSplatWorldPos(rotationA: vec4f,rotationB: vec4f,rotationScale: vec4f,center: vec3f,splatWorld: mat4x4f,viewMatrix: mat4x4f,invWorldScale: mat4x4f,quadPos: vec2f)->vec4f {let splatRotation=mat3x3f(\nrotationA.xyz,\nvec3f(rotationA.w,rotationB.x,rotationB.y),\nvec3f(rotationB.z,rotationB.w,rotationScale.x)\n);let splatScale=rotationScale.yzw;let view3x3=mat3x3f(viewMatrix[0].xyz,viewMatrix[1].xyz,viewMatrix[2].xyz);let invWorldScale3x3=mat3x3f(invWorldScale[0].xyz,invWorldScale[1].xyz,invWorldScale[2].xyz);let splatWorld3x3=mat3x3f(splatWorld[0].xyz,splatWorld[1].xyz,splatWorld[2].xyz);let rotToView=view3x3*invWorldScale3x3*splatWorld3x3*splatRotation;let axisLengthInViewZ=abs(vec3f(rotToView[0][2],rotToView[1][2],rotToView[2][2]));let gaussianSplatCutoffStddev: f32=0.7071067812; \nvar offsetSplatSpace: vec3f;if (axisLengthInViewZ.x>axisLengthInViewZ.y && axisLengthInViewZ.x>axisLengthInViewZ.z) {offsetSplatSpace=vec3f(0.0,quadPos.x,quadPos.y)*splatScale*gaussianSplatCutoffStddev;} else if (axisLengthInViewZ.y>axisLengthInViewZ.z) {offsetSplatSpace=vec3f(quadPos.x,0.0,quadPos.y)*splatScale*gaussianSplatCutoffStddev;} else {offsetSplatSpace=vec3f(quadPos.x,quadPos.y,0.0)*splatScale*gaussianSplatCutoffStddev;}\nlet vertexObjectSpace=center+splatRotation*offsetSplatSpace;return splatWorld*vec4f(vertexObjectSpace,1.0);}\n#endif\n`;\n// Sideeffect\nif (!ShaderStore.IncludesShadersStoreWGSL[name]) {\n    ShaderStore.IncludesShadersStoreWGSL[name] = shader;\n}\n/** @internal */\nexport const gaussianSplattingWGSL = { name, shader };\n"]}

package/ShadersWGSL/ShadersInclude/gaussianSplattingFragmentDeclaration.js

@@ -7,11 +7,11 @@ const shader = `fn gaussianColor(inColor: vec4f,inPosition: vec2f)->vec4f
 {var A : f32=-dot(inPosition,inPosition);if (A>-4.0)
 {var B: f32=exp(A)*inColor.a;
 #include<logDepthFragment>
-var color: vec3f=inColor.rgb;
+var color: vec4f=vec4f(inColor.rgb,B);
 #ifdef FOG
 #include<fogFragment>
 #endif
-return vec4f(color,B);} else {return vec4f(0.0);}}
+return color;} else {return vec4f(0.0);}}
 `;
 // Sideeffect
 if (!ShaderStore.IncludesShadersStoreWGSL[name]) {

package/ShadersWGSL/ShadersInclude/gaussianSplattingFragmentDeclaration.js.map

@@ -1 +1 @@
-{"version":3,"file":"gaussianSplattingFragmentDeclaration.js","sourceRoot":"","sources":["../../../../../dev/core/src/ShadersWGSL/ShadersInclude/gaussianSplattingFragmentDeclaration.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AACxD,OAAO,oBAAoB,CAAC;AAC5B,OAAO,eAAe,CAAC;AACvB,MAAM,IAAI,GAAG,sCAAsC,CAAC;AACpD,MAAM,MAAM,GAAG;;;;;;;;;CASd,CAAC;AACF,aAAa;AACb,IAAI,CAAC,WAAW,CAAC,wBAAwB,CAAC,IAAI,CAAC,EAAE,CAAC;IAC9C,WAAW,CAAC,wBAAwB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxD,CAAC;AACD,gBAAgB;AAChB,MAAM,CAAC,MAAM,wCAAwC,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../../Engines/shaderStore\";\nimport \"./logDepthFragment\";\nimport \"./fogFragment\";\nconst name = \"gaussianSplattingFragmentDeclaration\";\nconst shader = `fn gaussianColor(inColor: vec4f,inPosition: vec2f)->vec4f\n{var A : f32=-dot(inPosition,inPosition);if (A>-4.0)\n{var B: f32=exp(A)*inColor.a;\n#include<logDepthFragment>\nvar color: vec3f=inColor.rgb;\n#ifdef FOG\n#include<fogFragment>\n#endif\nreturn vec4f(color,B);} else {return vec4f(0.0);}}\n`;\n// Sideeffect\nif (!ShaderStore.IncludesShadersStoreWGSL[name]) {\n    ShaderStore.IncludesShadersStoreWGSL[name] = shader;\n}\n/** @internal */\nexport const gaussianSplattingFragmentDeclarationWGSL = { name, shader };\n"]}
+{"version":3,"file":"gaussianSplattingFragmentDeclaration.js","sourceRoot":"","sources":["../../../../../dev/core/src/ShadersWGSL/ShadersInclude/gaussianSplattingFragmentDeclaration.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AACxD,OAAO,oBAAoB,CAAC;AAC5B,OAAO,eAAe,CAAC;AACvB,MAAM,IAAI,GAAG,sCAAsC,CAAC;AACpD,MAAM,MAAM,GAAG;;;;;;;;;CASd,CAAC;AACF,aAAa;AACb,IAAI,CAAC,WAAW,CAAC,wBAAwB,CAAC,IAAI,CAAC,EAAE,CAAC;IAC9C,WAAW,CAAC,wBAAwB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxD,CAAC;AACD,gBAAgB;AAChB,MAAM,CAAC,MAAM,wCAAwC,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../../Engines/shaderStore\";\nimport \"./logDepthFragment\";\nimport \"./fogFragment\";\nconst name = \"gaussianSplattingFragmentDeclaration\";\nconst shader = `fn gaussianColor(inColor: vec4f,inPosition: vec2f)->vec4f\n{var A : f32=-dot(inPosition,inPosition);if (A>-4.0)\n{var B: f32=exp(A)*inColor.a;\n#include<logDepthFragment>\nvar color: vec4f=vec4f(inColor.rgb,B);\n#ifdef FOG\n#include<fogFragment>\n#endif\nreturn color;} else {return vec4f(0.0);}}\n`;\n// Sideeffect\nif (!ShaderStore.IncludesShadersStoreWGSL[name]) {\n    ShaderStore.IncludesShadersStoreWGSL[name] = shader;\n}\n/** @internal */\nexport const gaussianSplattingFragmentDeclarationWGSL = { name, shader };\n"]}

package/ShadersWGSL/ShadersInclude/gaussianSplattingShared.d.ts

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

package/ShadersWGSL/ShadersInclude/gaussianSplattingShared.js

@@ -0,0 +1,79 @@
+// Do not edit.
+import { ShaderStore } from "../../Engines/shaderStore.js";
+const name = "gaussianSplattingShared";
+const shader = `fn computeCov2D(covA: vec3f,covB: vec3f,modelView: mat4x4f,camspace: vec3f,focal: vec2f,isOrtho: bool)->mat3x3f {let Vrk=mat3x3f(
+covA.x,covA.y,covA.z,
+covA.y,covB.x,covB.y,
+covA.z,covB.y,covB.z);var J: mat3x3f;if (isOrtho) {J=mat3x3f(focal.x,0.0,0.0,0.0,focal.y,0.0,0.0,0.0,0.0);} else {J=mat3x3f(
+focal.x/camspace.z,0.0,-(focal.x*camspace.x)/(camspace.z*camspace.z),
+0.0,focal.y/camspace.z,-(focal.y*camspace.y)/(camspace.z*camspace.z),
+0.0,0.0,0.0);}
+let T=transpose(mat3x3f(modelView[0].xyz,modelView[1].xyz,modelView[2].xyz))*J;return transpose(T)*Vrk*T;}
+fn computeColorFromSHDegree(dir: vec3f,sh: array<vec3<f32>,25>,_so1: f32,_so2: f32,_so3: f32,_so4: f32)->vec3f
+{let SH_C0: f32=0.28209479;let SH_C1: f32=0.48860251;var SH_C2: array<f32,5>=array<f32,5>(
+1.092548430,
+-1.09254843,
+0.315391565,
+-1.09254843,
+0.546274215
+);var SH_C3: array<f32,7>=array<f32,7>(
+-0.59004358,
+2.890611442,
+-0.45704579,
+0.373176332,
+-0.45704579,
+1.445305721,
+-0.59004358
+);var SH_C4: array<f32,9>=array<f32,9>(
+2.5033429418,
+-1.7701307698,
+0.9461746958,
+-0.6690465436,
+0.1057855469,
+-0.6690465436,
+0.4730873479,
+-1.7701307698,
+0.6258357354
+);var result: vec3f=/*SH_C0**/sh[0];
+#if SH_DEGREE>0
+let x: f32=dir.x;let y: f32=dir.y;let z: f32=dir.z;result+=_so1*(-SH_C1*y*sh[1]+SH_C1*z*sh[2]-SH_C1*x*sh[3]);
+#if SH_DEGREE>1
+let xx: f32=x*x;let yy: f32=y*y;let zz: f32=z*z;let xy: f32=x*y;let yz: f32=y*z;let xz: f32=x*z;result+=_so2*(
+SH_C2[0]*xy*sh[4] +
+SH_C2[1]*yz*sh[5] +
+SH_C2[2]*(2.0f*zz-xx-yy)*sh[6] +
+SH_C2[3]*xz*sh[7] +
+SH_C2[4]*(xx-yy)*sh[8]);
+#if SH_DEGREE>2
+result+=_so3*(
+SH_C3[0]*y*(3.0f*xx-yy)*sh[9] +
+SH_C3[1]*xy*z*sh[10] +
+SH_C3[2]*y*(4.0f*zz-xx-yy)*sh[11] +
+SH_C3[3]*z*(2.0f*zz-3.0f*xx-3.0f*yy)*sh[12] +
+SH_C3[4]*x*(4.0f*zz-xx-yy)*sh[13] +
+SH_C3[5]*z*(xx-yy)*sh[14] +
+SH_C3[6]*x*(xx-3.0f*yy)*sh[15]);
+#if SH_DEGREE>3
+result+=_so4*(
+SH_C4[0]*x*y*(xx-yy)*sh[16] +
+SH_C4[1]*y*z*(3.0f*xx-yy)*sh[17] +
+SH_C4[2]*x*y*(7.0f*zz-1.0f)*sh[18] +
+SH_C4[3]*y*z*(7.0f*zz-3.0f)*sh[19] +
+SH_C4[4]*(zz*(35.0f*zz-30.0f)+3.0f)*sh[20] +
+SH_C4[5]*x*z*(7.0f*zz-3.0f)*sh[21] +
+SH_C4[6]*(xx-yy)*(7.0f*zz-1.0f)*sh[22] +
+SH_C4[7]*x*z*(xx-3.0f*yy)*sh[23] +
+SH_C4[8]*(xx*(xx-3.0f*yy)-yy*(3.0f*xx-yy))*sh[24]);
+#endif
+#endif
+#endif
+#endif
+return result;}
+`;
+// Sideeffect
+if (!ShaderStore.IncludesShadersStoreWGSL[name]) {
+    ShaderStore.IncludesShadersStoreWGSL[name] = shader;
+}
+/** @internal */
+export const gaussianSplattingSharedWGSL = { name, shader };
+//# sourceMappingURL=gaussianSplattingShared.js.map

package/ShadersWGSL/ShadersInclude/gaussianSplattingShared.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gaussianSplattingShared.js","sourceRoot":"","sources":["../../../../../dev/core/src/ShadersWGSL/ShadersInclude/gaussianSplattingShared.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AACxD,MAAM,IAAI,GAAG,yBAAyB,CAAC;AACvC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoEd,CAAC;AACF,aAAa;AACb,IAAI,CAAC,WAAW,CAAC,wBAAwB,CAAC,IAAI,CAAC,EAAE,CAAC;IAC9C,WAAW,CAAC,wBAAwB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxD,CAAC;AACD,gBAAgB;AAChB,MAAM,CAAC,MAAM,2BAA2B,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../../Engines/shaderStore\";\nconst name = \"gaussianSplattingShared\";\nconst shader = `fn computeCov2D(covA: vec3f,covB: vec3f,modelView: mat4x4f,camspace: vec3f,focal: vec2f,isOrtho: bool)->mat3x3f {let Vrk=mat3x3f(\ncovA.x,covA.y,covA.z,\ncovA.y,covB.x,covB.y,\ncovA.z,covB.y,covB.z);var J: mat3x3f;if (isOrtho) {J=mat3x3f(focal.x,0.0,0.0,0.0,focal.y,0.0,0.0,0.0,0.0);} else {J=mat3x3f(\nfocal.x/camspace.z,0.0,-(focal.x*camspace.x)/(camspace.z*camspace.z),\n0.0,focal.y/camspace.z,-(focal.y*camspace.y)/(camspace.z*camspace.z),\n0.0,0.0,0.0);}\nlet T=transpose(mat3x3f(modelView[0].xyz,modelView[1].xyz,modelView[2].xyz))*J;return transpose(T)*Vrk*T;}\nfn computeColorFromSHDegree(dir: vec3f,sh: array<vec3<f32>,25>,_so1: f32,_so2: f32,_so3: f32,_so4: f32)->vec3f\n{let SH_C0: f32=0.28209479;let SH_C1: f32=0.48860251;var SH_C2: array<f32,5>=array<f32,5>(\n1.092548430,\n-1.09254843,\n0.315391565,\n-1.09254843,\n0.546274215\n);var SH_C3: array<f32,7>=array<f32,7>(\n-0.59004358,\n2.890611442,\n-0.45704579,\n0.373176332,\n-0.45704579,\n1.445305721,\n-0.59004358\n);var SH_C4: array<f32,9>=array<f32,9>(\n2.5033429418,\n-1.7701307698,\n0.9461746958,\n-0.6690465436,\n0.1057855469,\n-0.6690465436,\n0.4730873479,\n-1.7701307698,\n0.6258357354\n);var result: vec3f=/*SH_C0**/sh[0];\n#if SH_DEGREE>0\nlet x: f32=dir.x;let y: f32=dir.y;let z: f32=dir.z;result+=_so1*(-SH_C1*y*sh[1]+SH_C1*z*sh[2]-SH_C1*x*sh[3]);\n#if SH_DEGREE>1\nlet xx: f32=x*x;let yy: f32=y*y;let zz: f32=z*z;let xy: f32=x*y;let yz: f32=y*z;let xz: f32=x*z;result+=_so2*(\nSH_C2[0]*xy*sh[4] +\nSH_C2[1]*yz*sh[5] +\nSH_C2[2]*(2.0f*zz-xx-yy)*sh[6] +\nSH_C2[3]*xz*sh[7] +\nSH_C2[4]*(xx-yy)*sh[8]);\n#if SH_DEGREE>2\nresult+=_so3*(\nSH_C3[0]*y*(3.0f*xx-yy)*sh[9] +\nSH_C3[1]*xy*z*sh[10] +\nSH_C3[2]*y*(4.0f*zz-xx-yy)*sh[11] +\nSH_C3[3]*z*(2.0f*zz-3.0f*xx-3.0f*yy)*sh[12] +\nSH_C3[4]*x*(4.0f*zz-xx-yy)*sh[13] +\nSH_C3[5]*z*(xx-yy)*sh[14] +\nSH_C3[6]*x*(xx-3.0f*yy)*sh[15]);\n#if SH_DEGREE>3\nresult+=_so4*(\nSH_C4[0]*x*y*(xx-yy)*sh[16] +\nSH_C4[1]*y*z*(3.0f*xx-yy)*sh[17] +\nSH_C4[2]*x*y*(7.0f*zz-1.0f)*sh[18] +\nSH_C4[3]*y*z*(7.0f*zz-3.0f)*sh[19] +\nSH_C4[4]*(zz*(35.0f*zz-30.0f)+3.0f)*sh[20] +\nSH_C4[5]*x*z*(7.0f*zz-3.0f)*sh[21] +\nSH_C4[6]*(xx-yy)*(7.0f*zz-1.0f)*sh[22] +\nSH_C4[7]*x*z*(xx-3.0f*yy)*sh[23] +\nSH_C4[8]*(xx*(xx-3.0f*yy)-yy*(3.0f*xx-yy))*sh[24]);\n#endif\n#endif\n#endif\n#endif\nreturn result;}\n`;\n// Sideeffect\nif (!ShaderStore.IncludesShadersStoreWGSL[name]) {\n    ShaderStore.IncludesShadersStoreWGSL[name] = shader;\n}\n/** @internal */\nexport const gaussianSplattingSharedWGSL = { name, shader };\n"]}

package/ShadersWGSL/ShadersInclude/lightsFragmentFunctions.js

@@ -13,7 +13,15 @@ specular: vec3f,
 ndl: f32,
 #endif
 };fn computeLighting(viewDirectionW: vec3f,vNormal: vec3f,lightData: vec4f,diffuseColor: vec3f,specularColor: vec3f,range: f32,glossiness: f32)->lightingInfo {var result: lightingInfo;var lightVectorW: vec3f;var attenuation: f32=1.0;if (lightData.w==0.)
-{var direction: vec3f=lightData.xyz-fragmentInputs.vPositionW;attenuation=max(0.,1.0-length(direction)/range);lightVectorW=normalize(direction);}
+{var direction: vec3f=lightData.xyz-fragmentInputs.vPositionW;
+#if defined(SKIP_OUT_OF_RANGE_LIGHTING) && !defined(NDOTL)
+if (dot(direction,direction)>=range*range) {result.diffuse=vec3f(0.);
+#ifdef SPECULARTERM
+result.specular=vec3f(0.);
+#endif
+return result;}
+#endif
+attenuation=max(0.,1.0-length(direction)/range);lightVectorW=normalize(direction);}
 else
 {lightVectorW=normalize(-lightData.xyz);}
 var ndl: f32=max(0.,dot(vNormal,lightVectorW));
@@ -36,7 +44,15 @@ result.diffuse=ndl*diffuseColor*attenuation;
 var angleW: vec3f=normalize(viewDirectionW+lightVectorW);var specComp: f32=max(0.,dot(vNormal,angleW));specComp=pow(specComp,max(1.,glossiness));result.specular=specComp*specularColor*attenuation;
 #endif
 return result;}
-fn computeIESSpotLighting(viewDirectionW: vec3f,vNormal: vec3f,lightData: vec4f,lightDirection: vec4f,diffuseColor: vec3f,specularColor: vec3f,range: f32,glossiness: f32,iesLightTexture: texture_2d<f32>,iesLightTextureSampler: sampler)->lightingInfo {var direction: vec3f=lightData.xyz-fragmentInputs.vPositionW;var lightVectorW: vec3f=normalize(direction);var attenuation: f32=max(0.,1.0-length(direction)/range);var dotProduct=dot(lightDirection.xyz,-lightVectorW);var cosAngle: f32=max(0.,dotProduct);if (cosAngle>=lightDirection.w)
+fn computeIESSpotLighting(viewDirectionW: vec3f,vNormal: vec3f,lightData: vec4f,lightDirection: vec4f,diffuseColor: vec3f,specularColor: vec3f,range: f32,glossiness: f32,iesLightTexture: texture_2d<f32>,iesLightTextureSampler: sampler)->lightingInfo {var direction: vec3f=lightData.xyz-fragmentInputs.vPositionW;
+#if defined(SKIP_OUT_OF_RANGE_LIGHTING) && !defined(NDOTL)
+if (dot(direction,direction)>=range*range) {var result: lightingInfo;result.diffuse=vec3f(0.);
+#ifdef SPECULARTERM
+result.specular=vec3f(0.);
+#endif
+return result;}
+#endif
+var lightVectorW: vec3f=normalize(direction);var attenuation: f32=max(0.,1.0-length(direction)/range);var dotProduct=dot(lightDirection.xyz,-lightVectorW);var cosAngle: f32=max(0.,dotProduct);if (cosAngle>=lightDirection.w)
 {attenuation*=getIESAttenuation(dotProduct,iesLightTexture,iesLightTextureSampler);return computeBasicSpotLighting(viewDirectionW,lightVectorW,vNormal,attenuation,diffuseColor,specularColor,glossiness);}
 var result: lightingInfo;result.diffuse=vec3f(0.);
 #ifdef SPECULARTERM
@@ -46,7 +62,15 @@ result.specular=vec3f(0.);
 result.ndl=0.;
 #endif
 return result;}
-fn computeSpotLighting(viewDirectionW: vec3f,vNormal: vec3f ,lightData: vec4f,lightDirection: vec4f,diffuseColor: vec3f,specularColor: vec3f,range: f32,glossiness: f32)->lightingInfo {var direction: vec3f=lightData.xyz-fragmentInputs.vPositionW;var lightVectorW: vec3f=normalize(direction);var attenuation: f32=max(0.,1.0-length(direction)/range);var cosAngle: f32=max(0.,dot(lightDirection.xyz,-lightVectorW));if (cosAngle>=lightDirection.w)
+fn computeSpotLighting(viewDirectionW: vec3f,vNormal: vec3f ,lightData: vec4f,lightDirection: vec4f,diffuseColor: vec3f,specularColor: vec3f,range: f32,glossiness: f32)->lightingInfo {var direction: vec3f=lightData.xyz-fragmentInputs.vPositionW;
+#if defined(SKIP_OUT_OF_RANGE_LIGHTING) && !defined(NDOTL)
+if (dot(direction,direction)>=range*range) {var result: lightingInfo;result.diffuse=vec3f(0.);
+#ifdef SPECULARTERM
+result.specular=vec3f(0.);
+#endif
+return result;}
+#endif
+var lightVectorW: vec3f=normalize(direction);var attenuation: f32=max(0.,1.0-length(direction)/range);var cosAngle: f32=max(0.,dot(lightDirection.xyz,-lightVectorW));if (cosAngle>=lightDirection.w)
 {attenuation*=getAttenuation(cosAngle,lightData.w);return computeBasicSpotLighting(viewDirectionW,lightVectorW,vNormal,attenuation,diffuseColor,specularColor,glossiness);}
 var result: lightingInfo;result.diffuse=vec3f(0.);
 #ifdef SPECULARTERM

package/ShadersWGSL/ShadersInclude/lightsFragmentFunctions.js.map

@@ -1 +1 @@
-{"version":3,"file":"lightsFragmentFunctions.js","sourceRoot":"","sources":["../../../../../dev/core/src/ShadersWGSL/ShadersInclude/lightsFragmentFunctions.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AACxD,OAAO,sBAAsB,CAAC;AAC9B,OAAO,8BAA8B,CAAC;AACtC,OAAO,4BAA4B,CAAC;AACpC,MAAM,IAAI,GAAG,yBAAyB,CAAC;AACvC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiFd,CAAC;AACF,aAAa;AACb,IAAI,CAAC,WAAW,CAAC,wBAAwB,CAAC,IAAI,CAAC,EAAE,CAAC;IAC9C,WAAW,CAAC,wBAAwB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxD,CAAC;AACD,gBAAgB;AAChB,MAAM,CAAC,MAAM,2BAA2B,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../../Engines/shaderStore\";\nimport \"./ltcHelperFunctions\";\nimport \"./clusteredLightingFunctions\";\nimport \"./clusteredLightingCompute\";\nconst name = \"lightsFragmentFunctions\";\nconst shader = `struct lightingInfo\n{diffuse: vec3f,\n#ifdef SPECULARTERM\nspecular: vec3f,\n#endif\n#ifdef NDOTL\nndl: f32,\n#endif\n};fn computeLighting(viewDirectionW: vec3f,vNormal: vec3f,lightData: vec4f,diffuseColor: vec3f,specularColor: vec3f,range: f32,glossiness: f32)->lightingInfo {var result: lightingInfo;var lightVectorW: vec3f;var attenuation: f32=1.0;if (lightData.w==0.)\n{var direction: vec3f=lightData.xyz-fragmentInputs.vPositionW;attenuation=max(0.,1.0-length(direction)/range);lightVectorW=normalize(direction);}\nelse\n{lightVectorW=normalize(-lightData.xyz);}\nvar ndl: f32=max(0.,dot(vNormal,lightVectorW));\n#ifdef NDOTL\nresult.ndl=ndl;\n#endif\nresult.diffuse=ndl*diffuseColor*attenuation;\n#ifdef SPECULARTERM\nvar angleW: vec3f=normalize(viewDirectionW+lightVectorW);var specComp: f32=max(0.,dot(vNormal,angleW));specComp=pow(specComp,max(1.,glossiness));result.specular=specComp*specularColor*attenuation;\n#endif\nreturn result;}\nfn getAttenuation(cosAngle: f32,exponent: f32)->f32 {return max(0.,pow(cosAngle,exponent));}\nfn getIESAttenuation(cosAngle: f32,iesLightTexture: texture_2d<f32>,iesLightTextureSampler: sampler)->f32 {var angle=acos(cosAngle)/PI;return textureSampleLevel(iesLightTexture,iesLightTextureSampler,vec2f(angle,0),0.).r;}\nfn computeBasicSpotLighting(viewDirectionW: vec3f,lightVectorW: vec3f,vNormal: vec3f,attenuation: f32,diffuseColor: vec3f,specularColor: vec3f,glossiness: f32)->lightingInfo {var result: lightingInfo;var ndl: f32=max(0.,dot(vNormal,lightVectorW));\n#ifdef NDOTL\nresult.ndl=ndl;\n#endif\nresult.diffuse=ndl*diffuseColor*attenuation;\n#ifdef SPECULARTERM\nvar angleW: vec3f=normalize(viewDirectionW+lightVectorW);var specComp: f32=max(0.,dot(vNormal,angleW));specComp=pow(specComp,max(1.,glossiness));result.specular=specComp*specularColor*attenuation;\n#endif\nreturn result;}\nfn computeIESSpotLighting(viewDirectionW: vec3f,vNormal: vec3f,lightData: vec4f,lightDirection: vec4f,diffuseColor: vec3f,specularColor: vec3f,range: f32,glossiness: f32,iesLightTexture: texture_2d<f32>,iesLightTextureSampler: sampler)->lightingInfo {var direction: vec3f=lightData.xyz-fragmentInputs.vPositionW;var lightVectorW: vec3f=normalize(direction);var attenuation: f32=max(0.,1.0-length(direction)/range);var dotProduct=dot(lightDirection.xyz,-lightVectorW);var cosAngle: f32=max(0.,dotProduct);if (cosAngle>=lightDirection.w)\n{attenuation*=getIESAttenuation(dotProduct,iesLightTexture,iesLightTextureSampler);return computeBasicSpotLighting(viewDirectionW,lightVectorW,vNormal,attenuation,diffuseColor,specularColor,glossiness);}\nvar result: lightingInfo;result.diffuse=vec3f(0.);\n#ifdef SPECULARTERM\nresult.specular=vec3f(0.);\n#endif\n#ifdef NDOTL\nresult.ndl=0.;\n#endif\nreturn result;}\nfn computeSpotLighting(viewDirectionW: vec3f,vNormal: vec3f ,lightData: vec4f,lightDirection: vec4f,diffuseColor: vec3f,specularColor: vec3f,range: f32,glossiness: f32)->lightingInfo {var direction: vec3f=lightData.xyz-fragmentInputs.vPositionW;var lightVectorW: vec3f=normalize(direction);var attenuation: f32=max(0.,1.0-length(direction)/range);var cosAngle: f32=max(0.,dot(lightDirection.xyz,-lightVectorW));if (cosAngle>=lightDirection.w)\n{attenuation*=getAttenuation(cosAngle,lightData.w);return computeBasicSpotLighting(viewDirectionW,lightVectorW,vNormal,attenuation,diffuseColor,specularColor,glossiness);}\nvar result: lightingInfo;result.diffuse=vec3f(0.);\n#ifdef SPECULARTERM\nresult.specular=vec3f(0.);\n#endif\n#ifdef NDOTL\nresult.ndl=0.;\n#endif\nreturn result;}\nfn computeHemisphericLighting(viewDirectionW: vec3f,vNormal: vec3f,lightData: vec4f,diffuseColor: vec3f,specularColor: vec3f,groundColor: vec3f,glossiness: f32)->lightingInfo {var result: lightingInfo;var ndl: f32=dot(vNormal,lightData.xyz)*0.5+0.5;\n#ifdef NDOTL\nresult.ndl=ndl;\n#endif\nresult.diffuse=mix(groundColor,diffuseColor,ndl);\n#ifdef SPECULARTERM\nvar angleW: vec3f=normalize(viewDirectionW+lightData.xyz);var specComp: f32=max(0.,dot(vNormal,angleW));specComp=pow(specComp,max(1.,glossiness));result.specular=specComp*specularColor;\n#endif\nreturn result;}\nfn computeProjectionTextureDiffuseLighting(projectionLightTexture: texture_2d<f32>,projectionLightSampler: sampler,textureProjectionMatrix: mat4x4f,posW: vec3f)->vec3f {var strq: vec4f=textureProjectionMatrix*vec4f(posW,1.0);strq/=strq.w;var textureColor: vec3f=textureSample(projectionLightTexture,projectionLightSampler,strq.xy).rgb;return textureColor;}\n#if defined(AREALIGHTUSED) && defined(AREALIGHTSUPPORTED)\n#include<ltcHelperFunctions>\nvar areaLightsLTC1SamplerSampler: sampler;var areaLightsLTC1Sampler: texture_2d<f32>;var areaLightsLTC2SamplerSampler: sampler;var areaLightsLTC2Sampler: texture_2d<f32>;fn computeAreaLighting(ltc1: texture_2d<f32>,ltc1Sampler:sampler,ltc2:texture_2d<f32>,ltc2Sampler:sampler,viewDirectionW: vec3f,vNormal:vec3f,vPosition:vec3f,lightPosition:vec3f,halfWidth:vec3f, halfHeight:vec3f,diffuseColor:vec3f,specularColor:vec3f,roughness:f32 )->lightingInfo\n{var result: lightingInfo;var data: areaLightData=computeAreaLightSpecularDiffuseFresnel(ltc1,ltc1Sampler,ltc2,ltc2Sampler,viewDirectionW,vNormal,vPosition,lightPosition,halfWidth,halfHeight,roughness);\n#ifdef SPECULARTERM\nvar fresnel:vec3f=( specularColor*data.Fresnel.x+( vec3f( 1.0 )-specularColor )*data.Fresnel.y );result.specular+=specularColor*fresnel*data.Specular;\n#endif\nresult.diffuse+=diffuseColor*data.Diffuse;return result;}\nfn computeAreaLightingWithTexture(ltc1: texture_2d<f32>,ltc1Sampler:sampler,ltc2:texture_2d<f32>,ltc2Sampler:sampler,emissionTexture: texture_2d<f32>,emissionTextureSampler:sampler,viewDirectionW: vec3f,vNormal:vec3f,vPosition:vec3f,lightPosition:vec3f,halfWidth:vec3f, halfHeight:vec3f,diffuseColor:vec3f,specularColor:vec3f,roughness:f32 )->lightingInfo\n{var result: lightingInfo;var data: areaLightData=computeAreaLightSpecularDiffuseFresnelWithEmission(ltc1,ltc1Sampler,ltc2,ltc2Sampler,emissionTexture,emissionTextureSampler,viewDirectionW,vNormal,vPosition,lightPosition,halfWidth,halfHeight,roughness);\n#ifdef SPECULARTERM\nvar fresnel: vec3f=( specularColor*data.Fresnel.x+( vec3f( 1.0 )-specularColor )*data.Fresnel.y );result.specular+=specularColor*fresnel*data.Specular;\n#endif\nresult.diffuse+=diffuseColor*data.Diffuse;return result;}\n#endif\n#if defined(CLUSTLIGHT_BATCH) && CLUSTLIGHT_BATCH>0\n#include<clusteredLightingFunctions>\n#include<clusteredLightingCompute>[0..maxSimultaneousLights]\n#endif\n`;\n// Sideeffect\nif (!ShaderStore.IncludesShadersStoreWGSL[name]) {\n    ShaderStore.IncludesShadersStoreWGSL[name] = shader;\n}\n/** @internal */\nexport const lightsFragmentFunctionsWGSL = { name, shader };\n"]}
+{"version":3,"file":"lightsFragmentFunctions.js","sourceRoot":"","sources":["../../../../../dev/core/src/ShadersWGSL/ShadersInclude/lightsFragmentFunctions.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AACxD,OAAO,sBAAsB,CAAC;AAC9B,OAAO,8BAA8B,CAAC;AACtC,OAAO,4BAA4B,CAAC;AACpC,MAAM,IAAI,GAAG,yBAAyB,CAAC;AACvC,MAAM,MAAM,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyGd,CAAC;AACF,aAAa;AACb,IAAI,CAAC,WAAW,CAAC,wBAAwB,CAAC,IAAI,CAAC,EAAE,CAAC;IAC9C,WAAW,CAAC,wBAAwB,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC;AACxD,CAAC;AACD,gBAAgB;AAChB,MAAM,CAAC,MAAM,2BAA2B,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../../Engines/shaderStore\";\nimport \"./ltcHelperFunctions\";\nimport \"./clusteredLightingFunctions\";\nimport \"./clusteredLightingCompute\";\nconst name = \"lightsFragmentFunctions\";\nconst shader = `struct lightingInfo\n{diffuse: vec3f,\n#ifdef SPECULARTERM\nspecular: vec3f,\n#endif\n#ifdef NDOTL\nndl: f32,\n#endif\n};fn computeLighting(viewDirectionW: vec3f,vNormal: vec3f,lightData: vec4f,diffuseColor: vec3f,specularColor: vec3f,range: f32,glossiness: f32)->lightingInfo {var result: lightingInfo;var lightVectorW: vec3f;var attenuation: f32=1.0;if (lightData.w==0.)\n{var direction: vec3f=lightData.xyz-fragmentInputs.vPositionW;\n#if defined(SKIP_OUT_OF_RANGE_LIGHTING) && !defined(NDOTL)\nif (dot(direction,direction)>=range*range) {result.diffuse=vec3f(0.);\n#ifdef SPECULARTERM\nresult.specular=vec3f(0.);\n#endif\nreturn result;}\n#endif\nattenuation=max(0.,1.0-length(direction)/range);lightVectorW=normalize(direction);}\nelse\n{lightVectorW=normalize(-lightData.xyz);}\nvar ndl: f32=max(0.,dot(vNormal,lightVectorW));\n#ifdef NDOTL\nresult.ndl=ndl;\n#endif\nresult.diffuse=ndl*diffuseColor*attenuation;\n#ifdef SPECULARTERM\nvar angleW: vec3f=normalize(viewDirectionW+lightVectorW);var specComp: f32=max(0.,dot(vNormal,angleW));specComp=pow(specComp,max(1.,glossiness));result.specular=specComp*specularColor*attenuation;\n#endif\nreturn result;}\nfn getAttenuation(cosAngle: f32,exponent: f32)->f32 {return max(0.,pow(cosAngle,exponent));}\nfn getIESAttenuation(cosAngle: f32,iesLightTexture: texture_2d<f32>,iesLightTextureSampler: sampler)->f32 {var angle=acos(cosAngle)/PI;return textureSampleLevel(iesLightTexture,iesLightTextureSampler,vec2f(angle,0),0.).r;}\nfn computeBasicSpotLighting(viewDirectionW: vec3f,lightVectorW: vec3f,vNormal: vec3f,attenuation: f32,diffuseColor: vec3f,specularColor: vec3f,glossiness: f32)->lightingInfo {var result: lightingInfo;var ndl: f32=max(0.,dot(vNormal,lightVectorW));\n#ifdef NDOTL\nresult.ndl=ndl;\n#endif\nresult.diffuse=ndl*diffuseColor*attenuation;\n#ifdef SPECULARTERM\nvar angleW: vec3f=normalize(viewDirectionW+lightVectorW);var specComp: f32=max(0.,dot(vNormal,angleW));specComp=pow(specComp,max(1.,glossiness));result.specular=specComp*specularColor*attenuation;\n#endif\nreturn result;}\nfn computeIESSpotLighting(viewDirectionW: vec3f,vNormal: vec3f,lightData: vec4f,lightDirection: vec4f,diffuseColor: vec3f,specularColor: vec3f,range: f32,glossiness: f32,iesLightTexture: texture_2d<f32>,iesLightTextureSampler: sampler)->lightingInfo {var direction: vec3f=lightData.xyz-fragmentInputs.vPositionW;\n#if defined(SKIP_OUT_OF_RANGE_LIGHTING) && !defined(NDOTL)\nif (dot(direction,direction)>=range*range) {var result: lightingInfo;result.diffuse=vec3f(0.);\n#ifdef SPECULARTERM\nresult.specular=vec3f(0.);\n#endif\nreturn result;}\n#endif\nvar lightVectorW: vec3f=normalize(direction);var attenuation: f32=max(0.,1.0-length(direction)/range);var dotProduct=dot(lightDirection.xyz,-lightVectorW);var cosAngle: f32=max(0.,dotProduct);if (cosAngle>=lightDirection.w)\n{attenuation*=getIESAttenuation(dotProduct,iesLightTexture,iesLightTextureSampler);return computeBasicSpotLighting(viewDirectionW,lightVectorW,vNormal,attenuation,diffuseColor,specularColor,glossiness);}\nvar result: lightingInfo;result.diffuse=vec3f(0.);\n#ifdef SPECULARTERM\nresult.specular=vec3f(0.);\n#endif\n#ifdef NDOTL\nresult.ndl=0.;\n#endif\nreturn result;}\nfn computeSpotLighting(viewDirectionW: vec3f,vNormal: vec3f ,lightData: vec4f,lightDirection: vec4f,diffuseColor: vec3f,specularColor: vec3f,range: f32,glossiness: f32)->lightingInfo {var direction: vec3f=lightData.xyz-fragmentInputs.vPositionW;\n#if defined(SKIP_OUT_OF_RANGE_LIGHTING) && !defined(NDOTL)\nif (dot(direction,direction)>=range*range) {var result: lightingInfo;result.diffuse=vec3f(0.);\n#ifdef SPECULARTERM\nresult.specular=vec3f(0.);\n#endif\nreturn result;}\n#endif\nvar lightVectorW: vec3f=normalize(direction);var attenuation: f32=max(0.,1.0-length(direction)/range);var cosAngle: f32=max(0.,dot(lightDirection.xyz,-lightVectorW));if (cosAngle>=lightDirection.w)\n{attenuation*=getAttenuation(cosAngle,lightData.w);return computeBasicSpotLighting(viewDirectionW,lightVectorW,vNormal,attenuation,diffuseColor,specularColor,glossiness);}\nvar result: lightingInfo;result.diffuse=vec3f(0.);\n#ifdef SPECULARTERM\nresult.specular=vec3f(0.);\n#endif\n#ifdef NDOTL\nresult.ndl=0.;\n#endif\nreturn result;}\nfn computeHemisphericLighting(viewDirectionW: vec3f,vNormal: vec3f,lightData: vec4f,diffuseColor: vec3f,specularColor: vec3f,groundColor: vec3f,glossiness: f32)->lightingInfo {var result: lightingInfo;var ndl: f32=dot(vNormal,lightData.xyz)*0.5+0.5;\n#ifdef NDOTL\nresult.ndl=ndl;\n#endif\nresult.diffuse=mix(groundColor,diffuseColor,ndl);\n#ifdef SPECULARTERM\nvar angleW: vec3f=normalize(viewDirectionW+lightData.xyz);var specComp: f32=max(0.,dot(vNormal,angleW));specComp=pow(specComp,max(1.,glossiness));result.specular=specComp*specularColor;\n#endif\nreturn result;}\nfn computeProjectionTextureDiffuseLighting(projectionLightTexture: texture_2d<f32>,projectionLightSampler: sampler,textureProjectionMatrix: mat4x4f,posW: vec3f)->vec3f {var strq: vec4f=textureProjectionMatrix*vec4f(posW,1.0);strq/=strq.w;var textureColor: vec3f=textureSample(projectionLightTexture,projectionLightSampler,strq.xy).rgb;return textureColor;}\n#if defined(AREALIGHTUSED) && defined(AREALIGHTSUPPORTED)\n#include<ltcHelperFunctions>\nvar areaLightsLTC1SamplerSampler: sampler;var areaLightsLTC1Sampler: texture_2d<f32>;var areaLightsLTC2SamplerSampler: sampler;var areaLightsLTC2Sampler: texture_2d<f32>;fn computeAreaLighting(ltc1: texture_2d<f32>,ltc1Sampler:sampler,ltc2:texture_2d<f32>,ltc2Sampler:sampler,viewDirectionW: vec3f,vNormal:vec3f,vPosition:vec3f,lightPosition:vec3f,halfWidth:vec3f, halfHeight:vec3f,diffuseColor:vec3f,specularColor:vec3f,roughness:f32 )->lightingInfo\n{var result: lightingInfo;var data: areaLightData=computeAreaLightSpecularDiffuseFresnel(ltc1,ltc1Sampler,ltc2,ltc2Sampler,viewDirectionW,vNormal,vPosition,lightPosition,halfWidth,halfHeight,roughness);\n#ifdef SPECULARTERM\nvar fresnel:vec3f=( specularColor*data.Fresnel.x+( vec3f( 1.0 )-specularColor )*data.Fresnel.y );result.specular+=specularColor*fresnel*data.Specular;\n#endif\nresult.diffuse+=diffuseColor*data.Diffuse;return result;}\nfn computeAreaLightingWithTexture(ltc1: texture_2d<f32>,ltc1Sampler:sampler,ltc2:texture_2d<f32>,ltc2Sampler:sampler,emissionTexture: texture_2d<f32>,emissionTextureSampler:sampler,viewDirectionW: vec3f,vNormal:vec3f,vPosition:vec3f,lightPosition:vec3f,halfWidth:vec3f, halfHeight:vec3f,diffuseColor:vec3f,specularColor:vec3f,roughness:f32 )->lightingInfo\n{var result: lightingInfo;var data: areaLightData=computeAreaLightSpecularDiffuseFresnelWithEmission(ltc1,ltc1Sampler,ltc2,ltc2Sampler,emissionTexture,emissionTextureSampler,viewDirectionW,vNormal,vPosition,lightPosition,halfWidth,halfHeight,roughness);\n#ifdef SPECULARTERM\nvar fresnel: vec3f=( specularColor*data.Fresnel.x+( vec3f( 1.0 )-specularColor )*data.Fresnel.y );result.specular+=specularColor*fresnel*data.Specular;\n#endif\nresult.diffuse+=diffuseColor*data.Diffuse;return result;}\n#endif\n#if defined(CLUSTLIGHT_BATCH) && CLUSTLIGHT_BATCH>0\n#include<clusteredLightingFunctions>\n#include<clusteredLightingCompute>[0..maxSimultaneousLights]\n#endif\n`;\n// Sideeffect\nif (!ShaderStore.IncludesShadersStoreWGSL[name]) {\n    ShaderStore.IncludesShadersStoreWGSL[name] = shader;\n}\n/** @internal */\nexport const lightsFragmentFunctionsWGSL = { name, shader };\n"]}

package/ShadersWGSL/gaussianPointSplattingBlit.fragment.d.ts

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

package/ShadersWGSL/gaussianPointSplattingBlit.fragment.js

@@ -0,0 +1,22 @@
+// Do not edit.
+import { ShaderStore } from "../Engines/shaderStore.js";
+const name = "gaussianPointSplattingBlitPixelShader";
+const shader = `uniform resolution: vec2f;uniform projZ: vec4f;uniform inverseProjection: mat4x4f;uniform useInverseProjection: f32;uniform logarithmicDepthConstant: f32;varying vScreenUv: vec2f;var<storage,read> accumBuffer : array<vec4f>;var<storage,read> accumDepth : array<f32>;
+#define CUSTOM_FRAGMENT_DEFINITIONS
+@fragment
+fn main(input: FragmentInputs)->FragmentOutputs {
+#define CUSTOM_FRAGMENT_MAIN_BEGIN
+let res=uniforms.resolution;let uv=clamp(fragmentInputs.vScreenUv,vec2f(0.0,0.0),vec2f(0.99999,0.99999));let pixel=vec2u(uv*res);let idx=pixel.y*u32(res.x)+pixel.x;let accumulated=accumBuffer[idx];if (accumulated.w<0.0015) {discard;}
+fragmentOutputs.color=vec4f(accumulated.rgb,accumulated.w);var depth=accumDepth[idx];if (uniforms.logarithmicDepthConstant>0.0) {var clipW : f32;if (uniforms.useInverseProjection>0.5) {let ndcXY=(vec2f(pixel)+0.5)/res*2.0-1.0;let unprojected=uniforms.inverseProjection*vec4f(ndcXY,depth,1.0);clipW=1.0/unprojected.w;} else {let vz=(depth*uniforms.projZ.w-uniforms.projZ.z)/(uniforms.projZ.x-depth*uniforms.projZ.y);clipW=uniforms.projZ.y*vz+uniforms.projZ.w;}
+depth=log2(max(0.000001,1.0+clipW))*uniforms.logarithmicDepthConstant*0.5;}
+fragmentOutputs.fragDepth=depth;
+#define CUSTOM_FRAGMENT_MAIN_END
+}
+`;
+// Sideeffect
+if (!ShaderStore.ShadersStoreWGSL[name]) {
+    ShaderStore.ShadersStoreWGSL[name] = shader;
+}
+/** @internal */
+export const gaussianPointSplattingBlitPixelShaderWGSL = { name, shader };
+//# sourceMappingURL=gaussianPointSplattingBlit.fragment.js.map

package/ShadersWGSL/gaussianPointSplattingBlit.fragment.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gaussianPointSplattingBlit.fragment.js","sourceRoot":"","sources":["../../../../dev/core/src/ShadersWGSL/gaussianPointSplattingBlit.fragment.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,uCAAuC,CAAC;AACrD,MAAM,MAAM,GAAG;;;;;;;;;;;CAWd,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,yCAAyC,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\n\nconst name = \"gaussianPointSplattingBlitPixelShader\";\nconst shader = `uniform resolution: vec2f;uniform projZ: vec4f;uniform inverseProjection: mat4x4f;uniform useInverseProjection: f32;uniform logarithmicDepthConstant: f32;varying vScreenUv: vec2f;var<storage,read> accumBuffer : array<vec4f>;var<storage,read> accumDepth : array<f32>;\n#define CUSTOM_FRAGMENT_DEFINITIONS\n@fragment\nfn main(input: FragmentInputs)->FragmentOutputs {\n#define CUSTOM_FRAGMENT_MAIN_BEGIN\nlet res=uniforms.resolution;let uv=clamp(fragmentInputs.vScreenUv,vec2f(0.0,0.0),vec2f(0.99999,0.99999));let pixel=vec2u(uv*res);let idx=pixel.y*u32(res.x)+pixel.x;let accumulated=accumBuffer[idx];if (accumulated.w<0.0015) {discard;}\nfragmentOutputs.color=vec4f(accumulated.rgb,accumulated.w);var depth=accumDepth[idx];if (uniforms.logarithmicDepthConstant>0.0) {var clipW : f32;if (uniforms.useInverseProjection>0.5) {let ndcXY=(vec2f(pixel)+0.5)/res*2.0-1.0;let unprojected=uniforms.inverseProjection*vec4f(ndcXY,depth,1.0);clipW=1.0/unprojected.w;} else {let vz=(depth*uniforms.projZ.w-uniforms.projZ.z)/(uniforms.projZ.x-depth*uniforms.projZ.y);clipW=uniforms.projZ.y*vz+uniforms.projZ.w;}\ndepth=log2(max(0.000001,1.0+clipW))*uniforms.logarithmicDepthConstant*0.5;}\nfragmentOutputs.fragDepth=depth;\n#define CUSTOM_FRAGMENT_MAIN_END\n}\n`;\n// Sideeffect\nif (!ShaderStore.ShadersStoreWGSL[name]) {\n    ShaderStore.ShadersStoreWGSL[name] = shader;\n}\n\n/** @internal */\nexport const gaussianPointSplattingBlitPixelShaderWGSL = { name, shader };\n"]}

package/ShadersWGSL/gaussianPointSplattingBlit.vertex.d.ts

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

package/ShadersWGSL/gaussianPointSplattingBlit.vertex.js

@@ -0,0 +1,19 @@
+// Do not edit.
+import { ShaderStore } from "../Engines/shaderStore.js";
+const name = "gaussianPointSplattingBlitVertexShader";
+const shader = `attribute position: vec3f;varying vScreenUv: vec2f;
+#define CUSTOM_VERTEX_DEFINITIONS
+@vertex
+fn main(input : VertexInputs)->FragmentInputs {
+#define CUSTOM_VERTEX_MAIN_BEGIN
+vertexOutputs.position=vec4f(vertexInputs.position.xy,0.0,1.0);vertexOutputs.vScreenUv=vertexInputs.position.xy*0.5+vec2f(0.5,0.5);
+#define CUSTOM_VERTEX_MAIN_END
+}
+`;
+// Sideeffect
+if (!ShaderStore.ShadersStoreWGSL[name]) {
+    ShaderStore.ShadersStoreWGSL[name] = shader;
+}
+/** @internal */
+export const gaussianPointSplattingBlitVertexShaderWGSL = { name, shader };
+//# sourceMappingURL=gaussianPointSplattingBlit.vertex.js.map

package/ShadersWGSL/gaussianPointSplattingBlit.vertex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gaussianPointSplattingBlit.vertex.js","sourceRoot":"","sources":["../../../../dev/core/src/ShadersWGSL/gaussianPointSplattingBlit.vertex.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErD,MAAM,IAAI,GAAG,wCAAwC,CAAC;AACtD,MAAM,MAAM,GAAG;;;;;;;;CAQd,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,0CAA0C,GAAG,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC","sourcesContent":["// Do not edit.\nimport { ShaderStore } from \"../Engines/shaderStore\";\n\nconst name = \"gaussianPointSplattingBlitVertexShader\";\nconst shader = `attribute position: vec3f;varying vScreenUv: vec2f;\n#define CUSTOM_VERTEX_DEFINITIONS\n@vertex\nfn main(input : VertexInputs)->FragmentInputs {\n#define CUSTOM_VERTEX_MAIN_BEGIN\nvertexOutputs.position=vec4f(vertexInputs.position.xy,0.0,1.0);vertexOutputs.vScreenUv=vertexInputs.position.xy*0.5+vec2f(0.5,0.5);\n#define CUSTOM_VERTEX_MAIN_END\n}\n`;\n// Sideeffect\nif (!ShaderStore.ShadersStoreWGSL[name]) {\n    ShaderStore.ShadersStoreWGSL[name] = shader;\n}\n\n/** @internal */\nexport const gaussianPointSplattingBlitVertexShaderWGSL = { name, shader };\n"]}

package/ShadersWGSL/gaussianPointSplattingDepthBlit.fragment.d.ts

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

package/ShadersWGSL/gaussianPointSplattingDepthBlit.fragment.js

@@ -0,0 +1,21 @@
+// Do not edit.
+import { ShaderStore } from "../Engines/shaderStore.js";
+const name = "gaussianPointSplattingDepthBlitPixelShader";
+const shader = `uniform resolution: vec2f;uniform depthValues: vec2f;uniform projZ: vec4f;uniform inverseProjection: mat4x4f;uniform useInverseProjection: f32;uniform reverseDepth: f32;varying vScreenUv: vec2f;var<storage,read> accumBuffer : array<vec4f>;var<storage,read> accumDepth : array<f32>;
+#define CUSTOM_FRAGMENT_DEFINITIONS
+@fragment
+fn main(input: FragmentInputs)->FragmentOutputs {
+#define CUSTOM_FRAGMENT_MAIN_BEGIN
+let res=uniforms.resolution;let uv=clamp(fragmentInputs.vScreenUv,vec2f(0.0,0.0),vec2f(0.99999,0.99999));let pixel=vec2u(uv*res);let idx=pixel.y*u32(res.x)+pixel.x;if (accumBuffer[idx].w<0.0015) {discard;}
+let ndc=accumDepth[idx];var clipZ : f32;if (uniforms.useInverseProjection>0.5) {let ndcXY=(vec2f(pixel)+0.5)/res*2.0-1.0;let unprojected=uniforms.inverseProjection*vec4f(ndcXY,ndc,1.0);clipZ=ndc/unprojected.w;} else {let denom=uniforms.projZ.x-ndc*uniforms.projZ.y;let vz=(ndc*uniforms.projZ.w-uniforms.projZ.z)/denom;clipZ=uniforms.projZ.x*vz+uniforms.projZ.z;}
+let signedClipZ=select(clipZ,-clipZ,uniforms.reverseDepth>0.5);let metric=(signedClipZ+uniforms.depthValues.x)/uniforms.depthValues.y;fragmentOutputs.color=vec4f(metric,0.0,0.0,1.0);fragmentOutputs.fragDepth=ndc;
+#define CUSTOM_FRAGMENT_MAIN_END
+}
+`;
+// Sideeffect
+if (!ShaderStore.ShadersStoreWGSL[name]) {
+    ShaderStore.ShadersStoreWGSL[name] = shader;
+}
+/** @internal */
+export const gaussianPointSplattingDepthBlitPixelShaderWGSL = { name, shader };
+//# sourceMappingURL=gaussianPointSplattingDepthBlit.fragment.js.map