meshwriter-cudu 3.0.2 → 3.0.4

package/dist/meshwriter.umd.js

@@ -468,17 +468,20 @@
     }
 
     /**
-     * TextFogPlugin - MaterialPluginBase that applies fog to emissive color
+     * TextFogPlugin - MaterialPluginBase that applies fog to text materials
      *
-     * Babylon's standard fog only affects diffuse/ambient channels.
-     * This plugin recalculates fog blending for the final color output,
-     * ensuring emissive text fades properly with distance fog.
+     * Since we disable Babylon's built-in fog (material.fogEnabled = false) to avoid
+     * double-fogging of diffuse colors, this plugin handles ALL fog application.
+     * It supplies its own uniforms and varyings to calculate fog distance and blend.
+     *
+     * This ensures text (with emissive colors) fades into fog at the same rate as
+     * terrain (which uses only diffuse colors with standard fog).
      */
 
 
     /**
-     * Plugin that applies scene fog to text materials by modifying
-     * the final fragment color before output.
+     * Plugin that applies scene fog to text materials uniformly.
+     * Handles fog for both diffuse and emissive components in one pass.
      */
     class TextFogPlugin extends materialPluginBase.MaterialPluginBase {
         /**
@@ -499,6 +502,7 @@
          */
         prepareDefines(defines, scene, mesh) {
             // Enable when scene has any fog mode set (1=LINEAR, 2=EXP, 3=EXP2)
+            // This is independent of material.fogEnabled since we handle fog ourselves
             defines['MESHWRITER_TEXT_FOG'] = scene.fogMode !== 0;
         }
 
@@ -506,10 +510,53 @@
             return 'TextFogPlugin';
         }
 
+        /**
+         * Define our own fog uniforms since material.fogEnabled = false
+         * means Babylon's built-in fog uniforms won't be available.
+         *
+         * - ubo: Used when Uniform Buffer Objects are enabled (Safari)
+         * - fragment: Used when UBOs are disabled (Chrome) - provides standalone declarations
+         *
+         * Babylon.js chooses between these based on engine capabilities.
+         */
         getUniforms() {
-            // We use Babylon's built-in fog uniforms (vFogInfos, vFogColor)
-            // which are already available in the standard material
-            return { ubo: [] };
+            return {
+                ubo: [
+                    { name: 'textFogInfos', size: 4, type: 'vec4' },
+                    { name: 'textFogColor', size: 3, type: 'vec3' }
+                ],
+                vertex: '',
+                fragment: `
+                uniform vec4 textFogInfos;
+                uniform vec3 textFogColor;
+            `
+            };
+        }
+
+        /**
+         * Bind fog values from the scene to our custom uniforms
+         * @param {import('@babylonjs/core/Materials/uniformBuffer').UniformBuffer} uniformBuffer
+         * @param {import('@babylonjs/core/scene').Scene} scene
+         * @param {import('@babylonjs/core/Engines/engine').Engine} engine
+         * @param {import('@babylonjs/core/Meshes/subMesh').SubMesh} subMesh
+         */
+        bindForSubMesh(uniformBuffer, scene, engine, subMesh) {
+            if (scene.fogMode === 0) return;
+
+            // textFogInfos: x=fogMode, y=fogStart, z=fogEnd, w=fogDensity
+            uniformBuffer.updateFloat4(
+                'textFogInfos',
+                scene.fogMode,
+                scene.fogStart,
+                scene.fogEnd,
+                scene.fogDensity
+            );
+
+            // textFogColor: RGB color of the fog
+            uniformBuffer.updateColor3(
+                'textFogColor',
+                scene.fogColor
+            );
         }
 
         /**
@@ -520,47 +567,70 @@
         }
 
         /**
-         * Inject shader code to apply fog to emissive color
+         * Inject shader code to calculate fog distance and apply fog blending
          * @param {string} shaderType - 'vertex' or 'fragment'
          */
         getCustomCode(shaderType) {
+            if (shaderType === 'vertex') {
+                return {
+                    // Declare our varying for fog distance
+                    'CUSTOM_VERTEX_DEFINITIONS': `
+                    #ifdef MESHWRITER_TEXT_FOG
+                    varying vec3 textFogDistance;
+                    #endif
+                `,
+                    // Calculate fog distance in view space at end of vertex shader
+                    // finalWorld and positionUpdated are Babylon's built-in variables
+                    'CUSTOM_VERTEX_MAIN_END': `
+                    #ifdef MESHWRITER_TEXT_FOG
+                    vec4 textWorldPos = finalWorld * vec4(positionUpdated, 1.0);
+                    textFogDistance = (view * textWorldPos).xyz;
+                    #endif
+                `
+                };
+            }
+
             if (shaderType === 'fragment') {
                 return {
-                    // This injection point runs just before gl_FragColor is finalized
-                    // At this point, standard fog has been applied to diffuse/ambient
-                    // but emissive contribution bypasses fog, so we re-apply fog
-                    // to the entire output to properly fade text into fog
+                    // Declare varying in fragment shader
+                    // Note: textFogInfos and textFogColor uniforms come from the Material UBO
+                    // (defined in getUniforms). Don't redeclare them here - Safari's strict
+                    // GLSL compiler rejects duplicate declarations.
+                    'CUSTOM_FRAGMENT_DEFINITIONS': `
+                    #ifdef MESHWRITER_TEXT_FOG
+                    varying vec3 textFogDistance;
+                    #endif
+                `,
+                    // Apply fog to the entire fragment color before final output
+                    // This runs just before gl_FragColor is set
                     'CUSTOM_FRAGMENT_BEFORE_FRAGCOLOR': `
                     #ifdef MESHWRITER_TEXT_FOG
-                    #ifdef FOG
-                    // Recalculate fog for the full fragment color including emissive
-                    // vFogInfos: x=fogMode, y=fogStart, z=fogEnd, w=fogDensity
-                    // vFogColor: fog RGB color
-                    // vFogDistance: vec3 distance from camera (set by vertex shader)
+                    // textFogInfos: x=fogMode, y=fogStart, z=fogEnd, w=fogDensity
+                    // Fog modes: 1=LINEAR, 2=EXP, 3=EXP2
 
                     float textFogFactor = 1.0;
-                    float textFogDist = length(vFogDistance);
+                    float textFogDist = length(textFogDistance);
 
-                    if (FOGMODE_LINEAR == vFogInfos.x) {
+                    if (textFogInfos.x == 1.0) {
                         // Linear fog: factor = (end - dist) / (end - start)
-                        textFogFactor = clamp((vFogInfos.z - textFogDist) / (vFogInfos.z - vFogInfos.y), 0.0, 1.0);
-                    } else if (FOGMODE_EXP == vFogInfos.x) {
+                        textFogFactor = clamp((textFogInfos.z - textFogDist) / (textFogInfos.z - textFogInfos.y), 0.0, 1.0);
+                    } else if (textFogInfos.x == 2.0) {
                         // Exponential fog: factor = exp(-dist * density)
-                        textFogFactor = clamp(exp(-textFogDist * vFogInfos.w), 0.0, 1.0);
-                    } else if (FOGMODE_EXP2 == vFogInfos.x) {
+                        textFogFactor = clamp(exp(-textFogDist * textFogInfos.w), 0.0, 1.0);
+                    } else if (textFogInfos.x == 3.0) {
                         // Exponential squared fog: factor = exp(-(dist * density)^2)
-                        float fogDistDensity = textFogDist * vFogInfos.w;
+                        float fogDistDensity = textFogDist * textFogInfos.w;
                         textFogFactor = clamp(exp(-fogDistDensity * fogDistDensity), 0.0, 1.0);
                     }
 
-                    // Blend the entire fragment (including emissive) toward fog color
+                    // Blend the entire fragment (diffuse + emissive) toward fog color
                     // textFogFactor: 1.0 = no fog (full color), 0.0 = full fog
-                    color.rgb = mix(vFogColor, color.rgb, textFogFactor);
+                    color.rgb = mix(textFogColor, color.rgb, textFogFactor);
                     #endif
-                    #endif
-                `,
+                `
                 };
             }
+
             return null;
         }
     }
@@ -625,15 +695,17 @@
         // Emissive-only materials should be self-lit and not affected by fog
         if (emissiveOnly) {
             material.fogEnabled = false;
+        } else if (fogEnabled) {
+            // IMPORTANT: Disable Babylon's built-in fog when using TextFogPlugin.
+            // Built-in fog only affects diffuse/ambient, not emissive.
+            // If we left fogEnabled=true, diffuse would be fogged twice (once by Babylon,
+            // once by the plugin), while emissive would only be fogged once by the plugin.
+            // By disabling built-in fog and handling ALL fog in the plugin, we get uniform
+            // fog application to the entire fragment (matching terrain behavior).
+            material.fogEnabled = false;
+            material._textFogPlugin = new TextFogPlugin(material);
         } else {
-            material.fogEnabled = fogEnabled;
-            // Attach fog plugin to properly blend emissive color with fog
-            // Babylon's standard fog only affects diffuse/ambient, not emissive.
-            // The plugin re-fogs the entire fragment output so emissive fades properly.
-            // (The slight double-fog on diffuse/ambient is negligible since text is primarily emissive)
-            if (fogEnabled) {
-                material._textFogPlugin = new TextFogPlugin(material);
-            }
+            material.fogEnabled = false;
         }
 
         return material;
@@ -659,7 +731,8 @@
         material.disableLighting = true;
         material.alpha = opac;
         material.backFaceCulling = false;
-        material.fogEnabled = fogEnabled;
+        // Disable Babylon's built-in fog - TextFogPlugin handles all fog uniformly
+        material.fogEnabled = false;
         if (fogEnabled) {
             material._textFogPlugin = new TextFogPlugin(material);
         }