@xeokit/xeokit-sdk 2.6.85-renderers-refactor-v2 → 2.6.86

package/src/viewer/scene/model/layer/programs/ColorProgram.js

@@ -1,35 +0,0 @@
-export const ColorProgram = function(programVariables, geometry, logarithmicDepthBufferEnabled, lightSetup, sao, primitive) {
-    const vColor = programVariables.createVarying("vec4", "vColor", () => {
-        const attributes = geometry.attributes;
-        const color = (primitive === "points") ? `vec4(${attributes.color}.rgb, 1.0)` : `${attributes.color}`;
-        if (lightSetup) {
-            const lightComponents = [
-                lightSetup.getAmbientColor()
-            ].concat(
-                lightSetup.directionalLights.map(
-                    light => `max(dot(${attributes.normal.view}, ${light.getDirection(geometry.viewMatrix, attributes.position.view)}), 0.0) * ${light.getColor()}`));
-            return `vec4(${lightComponents.join(" + ")}, 1) * ${color}`;
-        } else {
-            return color;
-        }
-    });
-    const outColor = programVariables.createOutput("vec4", "outColor");
-    return {
-        programName: "Color",
-        getHash: () => [lightSetup ? lightSetup.getHash() : "-", sao ? "sao" : "nosao"],
-        cleanerEdges: true,
-        getLogDepth: logarithmicDepthBufferEnabled && (vFragDepth => ((primitive !== "points") && (primitive !== "lines")) ? `${vFragDepth} + length(vec2(dFdx(${vFragDepth}), dFdy(${vFragDepth})))` : vFragDepth),
-        renderPassFlag: 0,  // COLOR_OPAQUE | COLOR_TRANSPARENT
-        appendFragmentOutputs: (src, getGammaOutputExpression, gl_FragCoord, sliceColorOr) => {
-            if ((primitive === "points") || (primitive === "lines")) {
-                src.push(`${outColor} = ${vColor};`);
-            } else {
-                src.push(`vec4 fragColor = ${sliceColorOr(vColor)};`);
-                src.push(`${outColor} = ${(sao ? (`vec4(fragColor.rgb * ${sao.getAmbient(gl_FragCoord)}, fragColor.a)`) : "fragColor")};`);
-            }
-        },
-
-        filterIntensityRange: true,
-        incrementDrawState: true
-    };
-};

package/src/viewer/scene/model/layer/programs/ColorTextureProgram.js

@@ -1,46 +0,0 @@
-import {LinearEncoding, sRGBEncoding} from "../../../constants/constants.js";
-import {setupTexture} from "../../../webgl/WebGLRenderer.js";
-
-export const ColorTextureProgram = function(programVariables, geometry, scene, lightSetup, sao, useAlphaCutoff, gammaOutput) {
-    const colorTexture = setupTexture(programVariables, "sampler2D", "uColorMap", sRGBEncoding, (set, state) => {
-        const texture = state.layerTextureSet.colorTexture;
-        texture && set(texture.texture);
-    });
-    const materialAlphaCutoff = useAlphaCutoff && programVariables.createUniform("float", "materialAlphaCutoff", (set, state) => set(state.layerTextureSet.alphaCutoff));
-
-    const attributes = geometry.attributes;
-    const vViewPosition = programVariables.createVarying("vec3", "vViewPosition", () => `${attributes.position.view}.xyz`);
-    const vUV           = programVariables.createVarying("vec2", "vUV",           () => attributes.uv);
-    const vColor        = programVariables.createVarying("vec4", "vColor",        () => attributes.color);
-
-    const outColor = programVariables.createOutput("vec4", "outColor");
-
-    return {
-        programName: "ColorTexture",
-        getHash: () => [lightSetup.getHash(), sao ? "sao" : "nosao", !!gammaOutput, useAlphaCutoff ? "alphaCutoffYes" : "alphaCutoffNo"],
-        getLogDepth: scene.logarithmicDepthBufferEnabled && (vFragDepth => vFragDepth),
-        renderPassFlag: 0,      // COLOR_OPAQUE | COLOR_TRANSPARENT
-        appendFragmentOutputs: (src, getGammaOutputExpression, gl_FragCoord, sliceColorOr) => {
-            src.push(`vec3 viewNormal = normalize(cross(dFdx(${vViewPosition}), dFdy(${vViewPosition})));`);
-            src.push("vec3 reflectedColor = vec3(0.0, 0.0, 0.0);");
-            lightSetup.directionalLights.forEach(light => {
-                src.push(`reflectedColor += max(dot(viewNormal, ${light.getDirection(geometry.viewMatrix, vViewPosition)}), 0.0) * ${light.getColor()};`);
-            });
-
-            src.push(`vec4 color = vec4(${lightSetup.getAmbientColor()} + reflectedColor, 1) * ${sliceColorOr(vColor)};`);
-
-            src.push(`vec4 sampleColor = ${colorTexture(vUV)};`);
-
-            if (materialAlphaCutoff) {
-                src.push(`if (sampleColor.a < ${materialAlphaCutoff}) { discard; }`);
-            }
-
-            src.push("vec4 colorTexel = color * sampleColor;");
-            src.push(`${outColor} = vec4(colorTexel.rgb${(sao ? (" * " + sao.getAmbient(gl_FragCoord)) : "")}, color.a);`);
-
-            getGammaOutputExpression && src.push(`${outColor} = ${getGammaOutputExpression(outColor)};`);
-        },
-
-        incrementDrawState: true
-    };
-};

package/src/viewer/scene/model/layer/programs/DepthProgram.js

@@ -1,11 +0,0 @@
-export const DepthProgram = function(programVariables, geometry, logarithmicDepthBufferEnabled) {
-    const vHighPrecisionZW = programVariables.createVarying("highp vec2", "vHighPrecisionZW", () => `${geometry.attributes.position.clip}.zw`);
-    const outColor = programVariables.createOutput("vec4", "outColor");
-    return {
-        programName: "Depth",
-        getLogDepth: logarithmicDepthBufferEnabled && (vFragDepth => vFragDepth),
-        renderPassFlag: 0,  // COLOR_OPAQUE | COLOR_TRANSPARENT
-        // isn't it the same as vec4(vec3(1.0 - gl_FragCoord.z), 1.0) ?
-        appendFragmentOutputs: (src) => src.push(`${outColor} = vec4(vec3((1.0 - ${vHighPrecisionZW}[0] / ${vHighPrecisionZW}[1]) / 2.0), 1.0);`)
-    };
-};

package/src/viewer/scene/model/layer/programs/EdgesProgram.js

@@ -1,12 +0,0 @@
-export const EdgesProgram = function(programVariables, geometry, logarithmicDepthBufferEnabled, colorUniform) {
-    const edgeColorUniform = colorUniform && programVariables.createUniform("vec4", "edgeColor", (set, state) => set(state.legacyFrameCtx.programColor));
-    const color = geometry.attributes.color;
-    const vColor = (!colorUniform) && programVariables.createVarying("vec4", "vColor", () => `vec4(${color}.rgb * 0.5, ${color}.a)`);
-    const outColor = programVariables.createOutput("vec4", "outColor");
-    return {
-        programName: colorUniform ? "Edges" : "EdgesColor",
-        getLogDepth: logarithmicDepthBufferEnabled && (vFragDepth => vFragDepth),
-        renderPassFlag: 2,  // EDGES_COLOR_OPAQUE | EDGES_COLOR_TRANSPARENT | EDGES_HIGHLIGHTED | EDGES_XRAYED | EDGES_SELECTED
-        appendFragmentOutputs: (src) => src.push(`${outColor} = ${edgeColorUniform || vColor};`)
-    };
-};

package/src/viewer/scene/model/layer/programs/FlatColorProgram.js

@@ -1,24 +0,0 @@
-export const FlatColorProgram = function(programVariables, geometry, logarithmicDepthBufferEnabled, lightSetup, sao) {
-    const attributes = geometry.attributes;
-    const vViewPosition = programVariables.createVarying("vec3", "vViewPosition", () => `${attributes.position.view}.xyz`);
-    const vColor = programVariables.createVarying("vec4", "vColor", () => attributes.color);
-    const outColor = programVariables.createOutput("vec4", "outColor");
-    return {
-        programName: "FlatColor",
-        getHash: () => [lightSetup.getHash(), sao ? "sao" : "nosao"],
-        cleanerEdges: true,
-        getLogDepth: logarithmicDepthBufferEnabled && (vFragDepth => vFragDepth),
-        renderPassFlag: 0,      // COLOR_OPAQUE | COLOR_TRANSPARENT
-        appendFragmentOutputs: (src, getGammaOutputExpression, gl_FragCoord, sliceColorOr) => {
-            src.push(`vec3 viewNormal = normalize(cross(dFdx(${vViewPosition}), dFdy(${vViewPosition})));`);
-            const lightComponents = [
-                lightSetup.getAmbientColor()
-            ].concat(
-                lightSetup.directionalLights.map(
-                    light => `max(dot(viewNormal, ${light.getDirection(geometry.viewMatrix, vViewPosition)}), 0.0) * ${light.getColor()}`));
-
-            src.push(`vec4 fragColor = vec4(${lightComponents.join(" + ")}, 1) * ${sliceColorOr(vColor)};`);
-            src.push(`${outColor} = ${sao ? `vec4(fragColor.rgb * ${sao.getAmbient(gl_FragCoord)}, fragColor.a)` : "fragColor"};`);
-        }
-    };
-};

package/src/viewer/scene/model/layer/programs/OcclusionProgram.js

@@ -1,12 +0,0 @@
-export const OcclusionProgram = function(programVariables, logarithmicDepthBufferEnabled) {
-    const outColor = programVariables.createOutput("vec4", "outColor");
-    return {
-        programName: "Occlusion",
-        // Logarithmic depth buffer involves an accuracy tradeoff, sacrificing
-        // accuracy at close range to improve accuracy at long range. This can
-        // mess up accuracy for occlusion tests, so we'll disable for now.
-        getLogDepth: false && logarithmicDepthBufferEnabled && (vFragDepth => vFragDepth),
-        renderPassFlag: 0,  // COLOR_OPAQUE // Only opaque objects can be occluders
-        appendFragmentOutputs: (src) => src.push(`${outColor} = vec4(0.0, 0.0, 1.0, 1.0);`) // Occluders are blue
-    };
-};

package/src/viewer/scene/model/layer/programs/PBRProgram.js

@@ -1,180 +0,0 @@
-import {LinearEncoding, sRGBEncoding} from "../../../constants/constants.js";
-import {setupTexture} from "../../../webgl/WebGLRenderer.js";
-
-export const PBRProgram = function(programVariables, geometry, scene, lightSetup, sao) {
-    const setup2dTexture = (name, isSrgb, getTexture) => {
-        return setupTexture(programVariables, "sampler2D", name, isSrgb ? sRGBEncoding : LinearEncoding, (set, state) => {
-            const texture = getTexture(state.layerTextureSet);
-            texture && set(texture.texture);
-        });
-    };
-
-    const attributes = geometry.attributes;
-    const getIrradiance = lightSetup.getIrradiance;
-
-    const colorMap         = setup2dTexture("uColorMap",         true,  textureSet => textureSet.colorTexture);
-    const metallicRoughMap = setup2dTexture("uMetallicRoughMap", false, textureSet => textureSet.metallicRoughnessTexture);
-    const emissiveMap      = setup2dTexture("uEmissiveMap",      true,  textureSet => textureSet.emissiveTexture);
-    const normalMap        = setup2dTexture("uNormalMap",        false, textureSet => textureSet.normalsTexture);
-    const aOMap            = setup2dTexture("uAOMap",            false, textureSet => textureSet.occlusionTexture);
-
-    const vViewPosition      = programVariables.createVarying("vec3", "vViewPosition",      () => `${attributes.position.view}.xyz`);
-    const vViewNormal        = programVariables.createVarying("vec3", "vViewNormal",        () => attributes.normal.view);
-    const vColor             = programVariables.createVarying("vec4", "vColor",             () => attributes.color);
-    const vUV                = programVariables.createVarying("vec2", "vUV",                () => attributes.uv);
-    const vMetallicRoughness = programVariables.createVarying("vec2", "vMetallicRoughness", () => attributes.metallicRoughness);
-    const vWorldNormal       = programVariables.createVarying("vec3", "vWorldNormal",       () => `${attributes.normal.world}.xyz`);
-
-    const outColor = programVariables.createOutput("vec4", "outColor");
-
-    const saturate = programVariables.createFragmentDefinition(
-        "saturate",
-        (name, src) => src.push(`float ${name}(const in float a) { return clamp(a, 0.0, 1.0); }`));
-
-    const BRDF_Specular_GGX = programVariables.createFragmentDefinition(
-        "BRDF_Specular_GGX",
-        (name, src) => {
-            src.push("vec3 F_Schlick(const in vec3 specularColor, const in float dotLH) {");
-            src.push("   float fresnel = exp2( ( -5.55473 * dotLH - 6.98316 ) * dotLH );");
-            src.push("   return ( 1.0 - specularColor ) * fresnel + specularColor;");
-            src.push("}");
-
-            src.push("float G_GGX_Smith(const in float alpha, const in float dotNL, const in float dotNV) {");
-            src.push("   float a2 = ( alpha * alpha );");
-            src.push("   float gl = dotNL + sqrt( a2 + ( 1.0 - a2 ) * ( dotNL * dotNL ) );");
-            src.push("   float gv = dotNV + sqrt( a2 + ( 1.0 - a2 ) * ( dotNV * dotNV ) );");
-            src.push("   return 1.0 / ( gl * gv );");
-            src.push("}");
-
-            src.push("float G_GGX_SmithCorrelated(const in float alpha, const in float dotNL, const in float dotNV) {");
-            src.push("   float a2 = ( alpha * alpha );");
-            src.push("   float gv = dotNL * sqrt( a2 + ( 1.0 - a2 ) * ( dotNV * dotNV ) );");
-            src.push("   float gl = dotNV * sqrt( a2 + ( 1.0 - a2 ) * ( dotNL * dotNL ) );");
-            src.push("   return 0.5 / max( gv + gl, 1e-6 );");
-            src.push("}");
-
-            src.push("float D_GGX(const in float alpha, const in float dotNH) {");
-            src.push("   float a2 = ( alpha * alpha );");
-            src.push("   float denom = ( dotNH * dotNH) * ( a2 - 1.0 ) + 1.0;");
-            src.push("   return 0.31830988618 * a2 / ( denom * denom);"); // 1/PI
-            src.push("}");
-
-            src.push(`vec3 ${name}(const in vec3 incidentLightDirection, const in vec3 viewNormal, const in vec3 viewEyeDir, const in vec3 specularColor, const in float roughness) {`);
-            src.push("   float alpha = ( roughness * roughness );");
-            src.push("   vec3 halfDir = normalize( incidentLightDirection + viewEyeDir );");
-            src.push(`   float dotNL = ${saturate}( dot( viewNormal, incidentLightDirection ) );`);
-            src.push(`   float dotNV = ${saturate}( dot( viewNormal, viewEyeDir ) );`);
-            src.push(`   float dotNH = ${saturate}( dot( viewNormal, halfDir ) );`);
-            src.push(`   float dotLH = ${saturate}( dot( incidentLightDirection, halfDir ) );`);
-            src.push("   vec3  F = F_Schlick( specularColor, dotLH );");
-            src.push("   float G = G_GGX_SmithCorrelated( alpha, dotNL, dotNV );");
-            src.push("   float D = D_GGX( alpha, dotNH );");
-            src.push("   return F * (G * D);");
-            src.push("}");
-        });
-
-    const BRDF_Specular_GGX_Environment = programVariables.createFragmentDefinition(
-        "BRDF_Specular_GGX_Environment",
-        (name, src) => {
-            src.push(`vec3 ${name}(const in vec3 viewNormal, const in vec3 viewEyeDir, const in vec3 specularColor, const in float roughness) {`);
-            src.push(`   float dotNV = ${saturate}(dot(viewNormal, viewEyeDir));`);
-            src.push("   const vec4 c0 = vec4( -1, -0.0275, -0.572,  0.022);");
-            src.push("   const vec4 c1 = vec4(  1,  0.0425,   1.04, -0.04);");
-            src.push("   vec4 r = roughness * c0 + c1;");
-            src.push("   float a004 = min(r.x * r.x, exp2(-9.28 * dotNV)) * r.x + r.y;");
-            src.push("   vec2 AB    = vec2(-1.04, 1.04) * a004 + r.zw;");
-            src.push("   return specularColor * AB.x + AB.y;");
-            src.push("}");
-        });
-
-    const perturbNormal2Arb = programVariables.createFragmentDefinition(
-        "perturbNormal2Arb",
-        (name, src) => {
-            src.push(`vec3 ${name}( vec3 eye_pos, vec3 surf_norm, vec2 uv, vec4 texel ) {`);
-            src.push("      if (texel.r == 0.0 && texel.g == 0.0 && texel.b == 0.0) {");
-            src.push("             return surf_norm;");
-            src.push("      }");
-            src.push("      vec3 q0 = vec3( dFdx( eye_pos.x ), dFdx( eye_pos.y ), dFdx( eye_pos.z ) );");
-            src.push("      vec3 q1 = vec3( dFdy( eye_pos.x ), dFdy( eye_pos.y ), dFdy( eye_pos.z ) );");
-            src.push("      vec2 st0 = dFdx( uv.st );");
-            src.push("      vec2 st1 = dFdy( uv.st );");
-            src.push("      vec3 S = normalize( q0 * st1.t - q1 * st0.t );");
-            src.push("      vec3 T = normalize( -q0 * st1.s + q1 * st0.s );");
-            src.push("      vec3 N = normalize( surf_norm );");
-            src.push("      vec3 mapN = texel.xyz * 2.0 - 1.0;");
-            src.push("      mat3 tsn = mat3( S, T, N );");
-            //     src.push("      mapN *= 3.0;");
-            src.push("      return normalize( tsn * mapN );");
-            src.push("}");
-        });
-
-    return {
-        programName: "PBR",
-        getHash: () => [lightSetup.getHash(), sao ? "sao" : "nosao", !!scene.gammaOutput],
-        getLogDepth: scene.logarithmicDepthBufferEnabled && (vFragDepth => vFragDepth),
-        renderPassFlag: 0,      // COLOR_OPAQUE | COLOR_TRANSPARENT
-        clippingCaps: scene._sectionPlanesState.clippingCaps && outColor,
-        incrementDrawState: true,
-        appendFragmentOutputs: (src, getGammaOutputExpression, gl_FragCoord) => {
-            src.push("const float PI = 3.14159265359;");
-            src.push("vec3 reflDiff = vec3(0.0);");
-            src.push("vec3 reflSpec = vec3(0.0);");
-
-            src.push(`vec3 rgb = ${vColor}.rgb;`);
-            src.push(`float opacity = ${vColor}.a;`);
-
-            src.push("vec3  baseColor  = rgb;");
-            src.push("float specularF0 = 1.0;");
-            src.push(`float metallic   = float(${vMetallicRoughness}.r) / 255.0;`);
-            src.push(`float roughness  = float(${vMetallicRoughness}.g) / 255.0;`);
-            src.push("float dielectricSpecular = 0.16 * specularF0 * specularF0;");
-
-            src.push(`vec4 colorTexel = ${colorMap(vUV)};`);
-            src.push("baseColor *= colorTexel.rgb;");
-            // src.push("opacity *=/= colorTexel.a;"); // batching had "*=", instancing had "="
-
-            src.push(`vec3 metalRoughTexel = ${metallicRoughMap(vUV)}.rgb;`);
-            src.push("metallic *= metalRoughTexel.b;");
-            src.push("roughness *= metalRoughTexel.g;");
-
-            src.push("vec3 diffuseColor       = baseColor * (1.0 - dielectricSpecular) * (1.0 - metallic);");
-            src.push("float specularRoughness = clamp(roughness, 0.04, 1.0);");
-            src.push("vec3 specularColor      = mix(vec3(dielectricSpecular), baseColor, metallic);");
-
-            src.push(`vec3 viewNormal = -${perturbNormal2Arb}(${vViewPosition}, normalize(${vViewNormal}), ${vUV}, ${normalMap(vUV)});`);
-            src.push(`vec3 viewEyeDir = normalize(${vViewPosition});`);
-
-            getIrradiance && src.push(`reflDiff += ${getIrradiance(`normalize(${vWorldNormal})`)};`);
-
-            if (lightSetup.getReflection) {
-                const reflectVec = `reflect(viewEyeDir, viewNormal)`;
-                const viewReflectVec = `normalize((vec4(${reflectVec}, 0.0) * ${geometry.viewMatrix}).xyz)`;
-                const maxMIPLevel = "8.0";
-                const blinnExpFromRoughness = `(2.0 / pow(specularRoughness + 0.0001, 2.0) - 2.0)`;
-                const desiredMIPLevel = `${maxMIPLevel} - 0.79248 - 0.5 * log2(pow(${blinnExpFromRoughness}, 2.0) + 1.0)`;
-                const specularMIPLevel = `0.5 * clamp(${desiredMIPLevel}, 0.0, ${maxMIPLevel})`; // TODO: a random factor - fix this
-                const radiance = lightSetup.getReflection(viewReflectVec, specularMIPLevel);
-                const specularBRDFContrib = `${BRDF_Specular_GGX_Environment}(viewNormal, viewEyeDir, specularColor, specularRoughness)`;
-                src.push(`reflSpec += ${radiance} * ${specularBRDFContrib};`);
-            }
-
-            lightSetup.directionalLights.forEach((light, i) => {
-                src.push(`vec3 lightDirection${i} = -${light.getDirection(geometry.viewMatrix, vViewPosition)};`); // This "-" might be wrong, but it used to be like that
-                const dotNL = `${saturate}(dot(viewNormal, lightDirection${i}))`;
-                src.push(`vec3 irradiance${i} = ${dotNL} * ${light.getColor()};`);
-                src.push(`reflDiff += irradiance${i};`);
-                src.push(`reflSpec += irradiance${i} * PI * ${BRDF_Specular_GGX}(lightDirection${i}, viewNormal, viewEyeDir, specularColor, specularRoughness);`);
-            });
-
-            src.push(`vec3 emissiveColor = ${emissiveMap(vUV)}.rgb;`); // TODO: correct gamma function
-            src.push(`float aoFactor = ${aOMap(vUV)}.r;`);
-
-            const ambient = `${lightSetup.getAmbientColor()} * baseColor * opacity * rgb`;
-            src.push(`vec3 outgoingLight = emissiveColor + reflDiff * diffuseColor + reflSpec + ${ambient};`);
-
-            src.push(`${outColor} = vec4(outgoingLight * aoFactor${sao ? ` * ${sao.getAmbient(gl_FragCoord)}` : ""}, opacity);`);
-
-            getGammaOutputExpression && src.push(`${outColor} = ${getGammaOutputExpression(outColor)};`);
-        }
-    };
-};

package/src/viewer/scene/model/layer/programs/PickDepthProgram.js

@@ -1,30 +0,0 @@
-export const PickDepthProgram = function(programVariables, geometry, logarithmicDepthBufferEnabled) {
-    const far  = programVariables.createUniform("float", "far",  (set, state) => set(state.legacyFrameCtx.viewParams.far));
-    const near = programVariables.createUniform("float", "near", (set, state) => set(state.legacyFrameCtx.viewParams.near));
-    const vViewPosition = programVariables.createVarying("vec3", "vViewPosition", () => `${geometry.attributes.position.view}.xyz`);
-    const outPackedDepth = programVariables.createOutput("vec4", "outPackedDepth");
-    const packDepth = programVariables.createFragmentDefinition(
-        "packDepth",
-        (name, src) => {
-            src.push(`vec4 ${name}(const in float depth) {`);
-            src.push("  const vec4 bitShift = vec4(256.0*256.0*256.0, 256.0*256.0, 256.0, 1.0);");
-            src.push("  const vec4 bitMask  = vec4(0.0, 1.0/256.0, 1.0/256.0, 1.0/256.0);");
-            src.push("  vec4 res = fract(depth * bitShift);");
-            src.push("  res -= res.xxyz * bitMask;");
-            src.push("  return res;");
-            src.push("}");
-        });
-
-    return {
-        programName: "PickDepth",
-        getLogDepth: logarithmicDepthBufferEnabled && (vFragDepth => vFragDepth),
-        renderPassFlag: 3,  // PICK
-        incPointSizeBy10: true,
-        appendFragmentOutputs: (src) => {
-            src.push(`float zNormalizedDepth = abs((${near} + ${vViewPosition}.z) / (${far} - ${near}));`);
-            // isn't zNormalizedDepth the same as gl_FragDepth or gl_FragCoord.z?
-            src.push(`${outPackedDepth} = ${packDepth}(zNormalizedDepth);`); // Must be linear depth
-            // try: src.push("    outPackedDepth = vec4(zNormalizedDepth, fract(zNormalizedDepth * vec3(256.0, 256.0*256.0, 256.0*256.0*256.0)));");
-        }
-    };
-};

package/src/viewer/scene/model/layer/programs/PickMeshProgram.js

@@ -1,12 +0,0 @@
-export const PickMeshProgram = function(programVariables, geometry, logarithmicDepthBufferEnabled) {
-    const vPickColor = programVariables.createVarying("vec4", "vPickColor", () => `${geometry.attributes.pickColor} / 255.0`);
-    const outPickColor = programVariables.createOutput("vec4", "outPickColor");
-    return {
-        programName: "PickMesh",
-        getLogDepth: logarithmicDepthBufferEnabled && (vFragDepth => vFragDepth),
-        renderPassFlag: 3,  // PICK
-        incPointSizeBy10: true,
-        dontCullOnAlphaZero: true, // should be false?
-        appendFragmentOutputs: (src) => src.push(`${outPickColor} = ${vPickColor};`)
-    };
-};

package/src/viewer/scene/model/layer/programs/PickNormalsProgram.js

@@ -1,18 +0,0 @@
-import {math} from "../../../math/math.js";
-
-export const PickNormalsProgram = function(programVariables, geometry, logarithmicDepthBufferEnabled, isFlat) {
-    const vWorldPosition = programVariables.createVarying("vec3", "vWorldPosition", () => `${geometry.attributes.position.world}.xyz`);
-    const vWorldNormal = programVariables.createVarying("vec3", "vWorldNormal", () => geometry.attributes.normal.world);
-    const outNormal = programVariables.createOutput("highp ivec4", "outNormal");
-    return {
-        programName: isFlat ? "PickNormalsFlat" : "PickNormals",
-        getLogDepth: logarithmicDepthBufferEnabled && (vFragDepth => vFragDepth),
-        renderPassFlag: 3,  // PICK
-        appendFragmentOutputs: (src) => {
-            const worldNormal = (isFlat
-                                 ? `normalize(cross(dFdx(${vWorldPosition}), dFdy(${vWorldPosition})))`
-                                 : vWorldNormal);
-            src.push(`${outNormal} = ivec4(${worldNormal} * float(${math.MAX_INT}), 1.0);`);
-        }
-    };
-};

package/src/viewer/scene/model/layer/programs/ShadowProgram.js

@@ -1,23 +0,0 @@
-export const ShadowProgram = function(programVariables, logarithmicDepthBufferEnabled) {
-    // VBOBatchingPointsShadowRenderer has been implemented by 14e973df6268369b00baef60e468939e062ac320,
-    // but never used (and probably not maintained), as opposed to VBOInstancingPointsShadowRenderer in the same commit
-    const outColor = programVariables.createOutput("vec4", "outColor");
-    const encodeFloat = programVariables.createFragmentDefinition(
-        "encodeFloat",
-        (name, src) => {
-            src.push(`vec4 ${name}(const in float v) {`);
-            src.push("  const vec4 bitShift = vec4(256 * 256 * 256, 256 * 256, 256, 1.0);");
-            src.push("  const vec4 bitMask = vec4(0, 1.0 / 256.0, 1.0 / 256.0, 1.0 / 256.0);");
-            src.push("  vec4 comp = fract(v * bitShift);");
-            src.push("  comp -= comp.xxyz * bitMask;");
-            src.push("  return comp;");
-            src.push("}");
-        });
-    return {
-        programName: "Shadow",
-        getLogDepth: logarithmicDepthBufferEnabled && (vFragDepth => vFragDepth),
-        renderPassFlag: 0,
-        isShadowProgram: true,
-        appendFragmentOutputs: (src, getGammaOutputExpression, gl_FragCoord) => src.push(`${outColor} = ${encodeFloat}(${gl_FragCoord}.z);`)
-    };
-};

package/src/viewer/scene/model/layer/programs/SilhouetteProgram.js

@@ -1,15 +0,0 @@
-export const SilhouetteProgram = function(programVariables, geometry, logarithmicDepthBufferEnabled, isPointsOrLines) {
-    const silhouetteColor = programVariables.createUniform("vec4", "silhouetteColor", (set, state) => set(state.legacyFrameCtx.programColor));
-    const vAlpha = programVariables.createVarying("float", "vAlpha", () => `${geometry.attributes.color}.a`);
-    const outColor = programVariables.createOutput("vec4", "outColor");
-    return {
-        programName: "Silhouette",
-        getLogDepth: logarithmicDepthBufferEnabled && (vFragDepth => vFragDepth),
-        renderPassFlag: 1,  // SILHOUETTE_HIGHLIGHTED | SILHOUETTE_SELECTED | SILHOUETTE_XRAYED
-        appendFragmentOutputs: (src, getGammaOutputExpression, gl_FragCoord, sliceColorOr) => {
-            src.push(`${outColor} = ${isPointsOrLines
-                                      ? silhouetteColor
-                                      : sliceColorOr(`vec4(${silhouetteColor}.rgb, min(${silhouetteColor}.a, ${vAlpha}))`)};`);
-        }
-    };
-};

package/src/viewer/scene/model/layer/programs/SnapProgram.js

@@ -1,28 +0,0 @@
-import {math} from "../../../math/math.js";
-
-export const SnapProgram = function(programVariables, geometry, isSnapInit, isPoints) {
-    const layerNumber      = programVariables.createUniform("int",  "layerNumber",      (set, state) => set(state.legacyFrameCtx.snapPickLayerParams.length));
-    const coordinateScaler = programVariables.createUniform("vec3", "coordinateScaler", (set, state) => set(state.legacyFrameCtx.snapPickCoordinateScale));
-
-    const vWorldPosition = programVariables.createVarying("vec3", "vWorldPosition", () => `${geometry.attributes.position.world}.xyz`);
-    const vPickColor = programVariables.createVarying("vec4", "vPickColor", () => geometry.attributes.pickColor, "flat");
-
-    const outCoords    = programVariables.createOutput("highp ivec4", "outCoords", 0);
-    const outNormal    = programVariables.createOutput("highp ivec4", "outNormal", 1);
-    const outPickColor = programVariables.createOutput("lowp uvec4", "outPickColor", 2);
-
-    return {
-        programName: isSnapInit ? "SnapInit" : "Snap",
-        // Improves occlusion accuracy at distance
-        getLogDepth: true && (vFragDepth => (isSnapInit ? `${vFragDepth} + length(vec2(dFdx(${vFragDepth}), dFdy(${vFragDepth})))` : vFragDepth)),
-        renderPassFlag: 3,  // PICK
-        dontCullOnAlphaZero: !isSnapInit,
-        appendFragmentOutputs: (src) => {
-            src.push(`${outCoords} = ivec4(${vWorldPosition} * ${coordinateScaler}.xyz, ${isSnapInit ? "-" : ""}${layerNumber});`);
-            if (isSnapInit) {
-                src.push(`${outNormal} = ${isPoints ? "ivec4(1.0)" : `ivec4(normalize(cross(dFdx(${vWorldPosition}), dFdy(${vWorldPosition}))) * float(${math.MAX_INT}), 1.0)`};`);
-                src.push(`${outPickColor} = uvec4(${vPickColor});`);
-            }
-        }
-    };
-};