meshwriter-cudu 3.0.2 → 3.0.3

package/dist/src/fogPlugin.d.ts

@@ -1,6 +1,6 @@
 /**
- * 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.
  */
 export class TextFogPlugin extends MaterialPluginBase {
     /**
@@ -14,19 +14,45 @@ export class TextFogPlugin extends MaterialPluginBase {
      * @param {import('@babylonjs/core/Meshes/mesh').Mesh} mesh
      */
     prepareDefines(defines: object, scene: import("@babylonjs/core/scene").Scene, mesh: import("@babylonjs/core/Meshes/mesh").Mesh): void;
+    /**
+     * Define our own fog uniforms since material.fogEnabled = false
+     * means Babylon's built-in fog uniforms won't be available
+     */
     getUniforms(): {
-        ubo: any[];
+        ubo: {
+            name: string;
+            size: number;
+            type: string;
+        }[];
+        vertex: string;
+        fragment: string;
     };
+    /**
+     * 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: import("@babylonjs/core/Materials/uniformBuffer").UniformBuffer, scene: import("@babylonjs/core/scene").Scene, engine: import("@babylonjs/core/Engines/engine").Engine, subMesh: import("@babylonjs/core/Meshes/subMesh").SubMesh): void;
     /**
      * Clean up the plugin
      */
     dispose(): void;
     /**
-     * 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: string): {
+        CUSTOM_VERTEX_DEFINITIONS: string;
+        CUSTOM_VERTEX_MAIN_END: string;
+        CUSTOM_FRAGMENT_DEFINITIONS?: undefined;
+        CUSTOM_FRAGMENT_BEFORE_FRAGCOLOR?: undefined;
+    } | {
+        CUSTOM_FRAGMENT_DEFINITIONS: string;
         CUSTOM_FRAGMENT_BEFORE_FRAGCOLOR: string;
+        CUSTOM_VERTEX_DEFINITIONS?: undefined;
+        CUSTOM_VERTEX_MAIN_END?: undefined;
     };
 }
 import { MaterialPluginBase } from './babylonImports.js';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "meshwriter-cudu",
-    "version": "3.0.2",
+    "version": "3.0.3",
     "description": "Modern 3D text rendering for Babylon.js with variable font weights and accessibility features",
     "type": "module",
     "main": "./dist/meshwriter.cjs.js",

package/src/fogPlugin.js

@@ -1,16 +1,19 @@
 /**
- * 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).
  */
 
 import { MaterialPluginBase } from './babylonImports.js';
 
 /**
- * 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.
  */
 export class TextFogPlugin extends MaterialPluginBase {
     /**
@@ -31,6 +34,7 @@ export 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;
     }
 
@@ -38,10 +42,45 @@ export 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
+        );
     }
 
     /**
@@ -52,47 +91,69 @@ export 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);
+                    color.rgb = mix(textFogColor, color.rgb, textFogFactor);
                     #endif
-                    #endif
-                `,
+                `
             };
         }
+
         return null;
     }
 }

package/src/material.js

@@ -61,15 +61,17 @@ export function makeMaterial(scene, letters, emissive, ambient, specular, diffus
     // 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;
@@ -95,7 +97,8 @@ export function makeFaceMaterial(scene, letters, emissive, opac, fogEnabled = tr
     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);
     }