meshwriter-cudu 3.0.0 → 3.0.3

package/dist/meshwriter.esm.js

@@ -516,17 +516,20 @@ function getCSGLib() {
 }
 
 /**
- * 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 {
     /**
@@ -547,6 +550,7 @@ class TextFogPlugin extends MaterialPluginBase {
      */
     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;
     }
 
@@ -554,10 +558,45 @@ class TextFogPlugin extends MaterialPluginBase {
         return 'TextFogPlugin';
     }
 
+    /**
+     * Define our own fog uniforms since material.fogEnabled = false
+     * means Babylon's built-in fog uniforms won't be available
+     */
     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: ''
+        };
+    }
+
+    /**
+     * 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
+        );
     }
 
     /**
@@ -568,47 +607,69 @@ class TextFogPlugin extends MaterialPluginBase {
     }
 
     /**
-     * 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 uniforms and varying in fragment shader
+                'CUSTOM_FRAGMENT_DEFINITIONS': `
+                    #ifdef MESHWRITER_TEXT_FOG
+                    uniform vec4 textFogInfos;
+                    uniform vec3 textFogColor;
+                    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);
-                    #endif
+                    color.rgb = mix(textFogColor, color.rgb, textFogFactor);
                     #endif
-                `,
+                `
             };
         }
+
         return null;
     }
 }
@@ -673,15 +734,17 @@ function makeMaterial(scene, letters, emissive, ambient, specular, diffuse, opac
     // 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;
@@ -707,7 +770,8 @@ function makeFaceMaterial(scene, letters, emissive, opac, fogEnabled = true) {
     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);
     }