Add existing to tracked

node_modules/@cesium/engine/Source/Shaders/PrimitiveGaussianSplatVS.glsl

@@ -0,0 +1,196 @@
+//
+// Vertex shader for Gaussian splats.
+
+// The splats are rendered as quads in view space. Splat attributes are loaded from a texture with precomputed 3D covariance.
+
+// Passes local quad coordinates and color to the fragment shader for Gaussian evaluation. 
+//
+// Discards splats outside the view frustum or with negligible screen size.
+//
+#if defined(HAS_SPHERICAL_HARMONICS)
+const uint coefficientCount[3] = uint[3](3u,8u,15u);
+const float SH_C1 = 0.48860251;
+const float SH_C2[5] = float[5](
+         1.092548430,
+        -1.09254843,
+        0.315391565,
+        -1.09254843,
+        0.546274215
+);
+
+const float SH_C3[7] = float[7](
+         -0.59004358,
+        2.890611442,
+        -0.45704579,
+        0.373176332,
+        -0.45704579,
+        1.445305721,
+        -0.59004358
+);
+
+//Retrieve SH coefficient. Currently RG32UI format
+uvec2 loadSHCoeff(uint splatID, int index) {
+    ivec2 shTexSize = textureSize(u_sphericalHarmonicsTexture, 0);
+    uint dims = coefficientCount[uint(u_sphericalHarmonicsDegree)-1u];
+    uint splatsPerRow = uint(shTexSize.x) / dims;
+    uint shIndex = (splatID%splatsPerRow) * dims + uint(index);
+    ivec2 shPosCoord = ivec2(shIndex, splatID / splatsPerRow);
+    return texelFetch(u_sphericalHarmonicsTexture, shPosCoord, 0).rg;
+}
+
+//Unpack RG32UI half float coefficients to vec3
+vec3 halfToVec3(uvec2 packed) {
+    return vec3(unpackHalf2x16(packed.x), unpackHalf2x16(packed.y).x);
+}
+
+vec3 loadAndExpandSHCoeff(uint splatID, int index) {
+    uvec2 coeff = loadSHCoeff(splatID, index);
+    return halfToVec3(coeff);
+}
+
+vec3 evaluateSH(uint splatID, vec3 viewDir) {
+    vec3 result = vec3(0.0);
+    int coeffIndex = 0;
+    float x = viewDir.x, y = viewDir.y, z = viewDir.z;
+
+    if (u_sphericalHarmonicsDegree >= 1.) {
+        vec3 sh1 = loadAndExpandSHCoeff(splatID, coeffIndex++);
+        vec3 sh2 = loadAndExpandSHCoeff(splatID, coeffIndex++);
+        vec3 sh3 = loadAndExpandSHCoeff(splatID, coeffIndex++);
+        result += -SH_C1 * y * sh1 + SH_C1 * z * sh2 - SH_C1 * x * sh3;
+
+        if (u_sphericalHarmonicsDegree >= 2.) {
+            float xx = x * x;
+            float yy = y * y;
+            float zz = z * z;
+            float xy = x * y;
+            float yz = y * z;
+            float xz = x * z;
+
+            vec3 sh4 = loadAndExpandSHCoeff(splatID, coeffIndex++);
+            vec3 sh5 = loadAndExpandSHCoeff(splatID, coeffIndex++);
+            vec3 sh6 = loadAndExpandSHCoeff(splatID, coeffIndex++);
+            vec3 sh7 = loadAndExpandSHCoeff(splatID, coeffIndex++);
+            vec3 sh8 = loadAndExpandSHCoeff(splatID, coeffIndex++);
+            result += SH_C2[0] * xy * sh4 +
+                    SH_C2[1] * yz * sh5 +
+                    SH_C2[2] * (2.0f * zz - xx - yy) * sh6 +
+                    SH_C2[3] * xz * sh7 +
+                    SH_C2[4] * (xx - yy) * sh8;
+
+            if (u_sphericalHarmonicsDegree >= 3.) {
+                vec3 sh9 = loadAndExpandSHCoeff(splatID, coeffIndex++);
+                vec3 sh10 = loadAndExpandSHCoeff(splatID, coeffIndex++);
+                vec3 sh11 = loadAndExpandSHCoeff(splatID, coeffIndex++);
+                vec3 sh12 = loadAndExpandSHCoeff(splatID, coeffIndex++);
+                vec3 sh13 = loadAndExpandSHCoeff(splatID, coeffIndex++);
+                vec3 sh14 = loadAndExpandSHCoeff(splatID, coeffIndex++);
+                vec3 sh15 = loadAndExpandSHCoeff(splatID, coeffIndex++);
+                result += SH_C3[0] * y * (3.0f * xx - yy) * sh9 +
+                        SH_C3[1] * xy * z * sh10 +
+                        SH_C3[2] * y * (4.0f * zz - xx - yy) * sh11 +
+                        SH_C3[3] * z * (2.0f * zz - 3.0f * xx - 3.0f * yy) * sh12 +
+                        SH_C3[4] * x * (4.0f * zz - xx - yy) * sh13 +
+                        SH_C3[5] * z * (xx - yy) * sh14 +
+                        SH_C3[6] * x * (xx - 3.0f * yy) * sh15;
+            }
+        }
+    }
+    return result;
+}
+#endif
+
+// Transforms and projects splat covariance into screen space and extracts the major and minor axes of the Gaussian ellipsoid
+// which is used to calculate the vertex position in clip space.
+vec4 calcCovVectors(vec3 viewPos, mat3 Vrk) {
+    vec4 t = vec4(viewPos, 1.0);
+    vec2 focal = vec2(czm_projection[0][0] * czm_viewport.z, czm_projection[1][1] * czm_viewport.w);
+
+    vec2 J1 = focal / t.z;
+    vec2 J2 = -focal * vec2(t.x, t.y) / (t.z * t.z);
+    mat3 J = mat3(
+        J1.x, 0.0, J2.x,
+        0.0, J1.y, J2.y,
+        0.0, 0.0, 0.0
+    );
+
+    mat3 R = mat3(czm_modelView);
+
+    //transform our covariance into view space
+    //ensures orientation is correct
+    mat3 Vrk_view = R * Vrk * transpose(R);
+    mat3 cov = transpose(J) * Vrk_view * J;
+
+    float diagonal1 = cov[0][0] + .3;
+    float offDiagonal = cov[0][1];
+    float diagonal2 = cov[1][1] + .3;
+
+    float mid = 0.5 * (diagonal1 + diagonal2);
+    float radius = length(vec2((diagonal1 - diagonal2) * 0.5, offDiagonal));
+    float lambda1 = mid + radius;
+    float lambda2 = max(mid - radius, 0.1);
+
+    vec2 diagonalVector = normalize(vec2(offDiagonal, lambda1 - diagonal1));
+
+    return vec4(
+        min(sqrt(2.0 * lambda1), 1024.0) * diagonalVector,
+        min(sqrt(2.0 * lambda2), 1024.0) * vec2(diagonalVector.y, -diagonalVector.x)
+    );
+}
+
+highp vec4 discardVec = vec4(0.0, 0.0, 2.0, 1.0);
+
+void main() {
+    uint texIdx = uint(a_splatIndex);
+    // u_splatRowMask and u_splatRowShift encode the row width of the splat
+    // attribute texture. The texture width is always maximumTextureSize, which
+    // varies by GPU, so these are passed as uniforms rather than constants.
+    //   rowMask  = maximumTextureSize/2 - 1
+    //   rowShift = log2(maximumTextureSize/2)
+    uint rowMask = uint(u_splatRowMask);
+    uint rowShift = uint(u_splatRowShift);
+    ivec2 posCoord = ivec2(int((texIdx & rowMask) << 1), int(texIdx >> rowShift));
+    vec4 splatPosition = vec4( uintBitsToFloat(uvec4(texelFetch(u_splatAttributeTexture, posCoord, 0))) );
+
+    vec4 splatViewPos = czm_modelView * vec4(splatPosition.xyz, 1.0);
+    vec4 clipPosition = czm_projection * splatViewPos;
+
+    float clip = 1.2 * clipPosition.w;
+    if (clipPosition.z < -clip || clipPosition.x < -clip || clipPosition.x > clip ||
+        clipPosition.y < -clip || clipPosition.y > clip) {
+        gl_Position = vec4(0.0, 0.0, 2.0, 1.0);
+        return;
+    }
+
+    ivec2 covCoord = ivec2(int(((texIdx & rowMask) << 1) | 1u), int(texIdx >> rowShift));
+    uvec4 covariance = uvec4(texelFetch(u_splatAttributeTexture, covCoord, 0));
+
+    gl_Position = clipPosition;
+
+    vec2 u1 = unpackHalf2x16(covariance.x) ;
+    vec2 u2 = unpackHalf2x16(covariance.y);
+    vec2 u3 = unpackHalf2x16(covariance.z);
+    mat3 Vrk = mat3(u1.x, u1.y, u2.x, u1.y, u2.y, u3.x, u2.x, u3.x, u3.y);
+
+    vec4 covVectors = calcCovVectors(splatViewPos.xyz, Vrk);
+
+    if (dot(covVectors.xy, covVectors.xy) < 4.0 && dot(covVectors.zw, covVectors.zw) < 4.0) {
+        gl_Position = discardVec;
+        return;
+    }
+
+    vec2 corner = vec2((gl_VertexID << 1) & 2, gl_VertexID & 2) - 1.;
+
+    gl_Position += vec4((corner.x * covVectors.xy + corner.y * covVectors.zw) / czm_viewport.zw * gl_Position.w, 0, 0);
+    gl_Position.z = clamp(gl_Position.z, -abs(gl_Position.w), abs(gl_Position.w));
+
+    v_vertPos = corner ;
+    v_splatColor = vec4(covariance.w & 0xffu, (covariance.w >> 8) & 0xffu, (covariance.w >> 16) & 0xffu, (covariance.w >> 24) & 0xffu) / 255.0;
+#if defined(HAS_SPHERICAL_HARMONICS)
+    vec4 splatWC = czm_inverseView * splatViewPos;
+    vec3 viewDirModel = normalize(u_inverseModelRotation * (splatWC.xyz - u_cameraPositionWC.xyz));
+
+    v_splatColor.rgb += evaluateSH(texIdx, viewDirModel).rgb;
+#endif
+    v_splitDirection = u_splitDirection;
+}