fix font texture issue

Runtime/ui/painting/canvas_impl.cs

             
             var matrix = new Matrix3(state.matrix);
             matrix.preTranslate(offset.dx, offset.dy);            
-            var mesh = MeshGenerator.generateMesh(textBlob, scale)?.transform(matrix);
-            if (mesh == null) {
-                return;
-            }
+            var mesh = new TextBlobMesh(textBlob, scale, matrix);
+            // request font texture so text mesh could be generated correctly
+            var style = textBlob.style;
+            var fontSizeToLoad = Mathf.CeilToInt(style.UnityFontSize * scale);
+            var subText = textBlob.text.Substring(textBlob.textOffset, textBlob.textSize);
+            font.RequestCharactersInTexture(subText, fontSizeToLoad, style.UnityFontStyle);
+
-                if (!this._applyClip(mesh.bounds)) {
+                if (!this._applyClip(textBlob.bounds)) {
                     return;
                 }
 
 
             if (paint.maskFilter != null && paint.maskFilter.sigma != 0) {
-                this._drawWithMaskFilter(mesh.bounds, drawMesh, paint, paint.maskFilter);
+                this._drawWithMaskFilter(textBlob.bounds, drawMesh, paint, paint.maskFilter);
                 return;
             }
 
         public void flush(Picture picture) {
             this._reset();
+            
             this._drawPicture(picture, false);
             
             D.assert(this._layers.Count == 1);
                         // clear triangles first in order to bypass validation in SetVertices.
                         cmd.meshObj.SetTriangles((int[]) null, 0, false);
 
-                        cmd.meshObj.SetVertices(cmd.mesh.vertices);
-                        cmd.meshObj.SetTriangles(cmd.mesh.triangles, 0, false);
-                        cmd.meshObj.SetUVs(0, cmd.mesh.uv);
+                        MeshMesh mesh = cmd.mesh;
+                        if (cmd.textMesh != null) {
+                            mesh = cmd.textMesh.resovleMesh();
+                        }
+  
+                        cmd.meshObj.SetVertices(mesh.vertices);
+                        cmd.meshObj.SetTriangles(mesh.triangles, 0, false);
+                        cmd.meshObj.SetUVs(0, mesh.uv);
-                        if (cmd.mesh.matrix == null) {
+                        if (mesh.matrix == null) {
-                            cmd.properties.SetFloatArray(RenderDraw.matId, cmd.mesh.matrix.fMat);
+                            cmd.properties.SetFloatArray(RenderDraw.matId, mesh.matrix.fMat);
                         }
 
                         cmdBuf.DrawMesh(cmd.meshObj, RenderDraw.idMat, cmd.material, 0, cmd.pass, cmd.properties);
         
         internal class RenderDraw {
             public MeshMesh mesh;
+            public TextBlobMesh textMesh;
             public int pass;
             public MaterialPropertyBlock properties;
             public RenderLayer layer;

Runtime/ui/painting/canvas_shader.cs

 
         public static PictureFlusher.RenderDraw texAlpha(PictureFlusher.RenderLayer layer, Paint paint,
             MeshMesh mesh, Texture tex) {
+            return texAlpha(layer, paint, mesh, null, tex);
+        }
+        
+        public static PictureFlusher.RenderDraw texAlpha(PictureFlusher.RenderLayer layer, Paint paint,
+            TextBlobMesh textMesh, Texture tex) {
+            return texAlpha(layer, paint, null, textMesh, tex);
+        }
+        
+        public static PictureFlusher.RenderDraw texAlpha(PictureFlusher.RenderLayer layer, Paint paint,
+            MeshMesh mesh, TextBlobMesh textMesh, Texture tex) {
             Vector4 viewport = layer.viewport;
             Matrix3 ctm = layer.states[layer.states.Count - 1].matrix;
 
 
             return new PictureFlusher.RenderDraw {
                 mesh = mesh,
+                textMesh = textMesh,
                 pass = pass,
                 material = mat,
                 properties = props,

Runtime/ui/painting/tessellation_generator.cs

         }
 
         public void touch(long timeTolive = 5) {
-            this._timeToLive = timeTolive + MeshGenerator.frameCount;
+            this._timeToLive = timeTolive + TextBlobMesh.frameCount;
         }
     }
 

Runtime/ui/painting/txt/mesh_generator.cs

         }
 
         public void touch(long timeTolive = 5) {
-            this._timeToLive = timeTolive + MeshGenerator.frameCount;
+            this._timeToLive = timeTolive + TextBlobMesh.frameCount;
-
-    static class MeshGenerator {
+    
+    class TextBlobMesh {
+        
+        readonly TextBlob textBlob;
+        readonly float scale;
+        readonly Matrix3 _transform;
+        MeshMesh _mesh;
+        bool _resolved;
+        public TextBlobMesh(TextBlob textBlob, float scale, Matrix3 transform) {
+            this.textBlob = textBlob;
+            this.scale = scale;
+            this._transform = transform;
+        }
+        
         public static long frameCount {
             get { return _frameCount; }
         }
             }
         }
 
-        public static MeshMesh generateMesh(TextBlob textBlob, float scale) {
-            var style = textBlob.style;
+        public MeshMesh resovleMesh() {
+            if (this._resolved) {
+                return this._mesh;
+            }
+
+            this._resolved = true;
+            
+            var style = this.textBlob.style;
-            var key = new MeshKey(textBlob.instanceId, scale);
+            var key = new MeshKey(this.textBlob.instanceId, this.scale);
-                return meshInfo.mesh;
+                this._mesh = meshInfo.mesh.transform(this._transform);
+                return this._mesh;
-            var length = textBlob.textSize;
-            var text = textBlob.text;
-            var fontSizeToLoad = Mathf.CeilToInt(style.UnityFontSize * scale);
-            var subText = textBlob.text.Substring(textBlob.textOffset, textBlob.textSize);
-            font.RequestCharactersInTexture(subText, fontSizeToLoad, style.UnityFontStyle);
-
+            var length = this.textBlob.textSize;
+            var text = this.textBlob.text;
+            var fontSizeToLoad = Mathf.CeilToInt(style.UnityFontSize * this.scale);
-                var ch = text[charIndex + textBlob.textOffset];
+                var ch = text[charIndex + this.textBlob.textOffset];
-                var position = textBlob.positions[charIndex];
+                var position = this.textBlob.positions[charIndex];
                 if (LayoutUtils.isWordSpace(ch) || LayoutUtils.isLineEndSpace(ch) || ch == '\t') {
                     continue;
                 }
 
-                var minX = charInfo.minX / scale;
-                var maxX = charInfo.maxX / scale;
-                var minY = charInfo.minY / scale;
-                var maxY = charInfo.maxY / scale;
+                var minX = charInfo.minX / this.scale;
+                var maxX = charInfo.maxX / this.scale;
+                var minY = charInfo.minY / this.scale;
+                var maxY = charInfo.maxY / this.scale;
 
                 var baseIndex = vertices.Count;
 
             MeshMesh mesh = vertices.Count > 0 ? new MeshMesh(null, vertices, triangles, uv) : null;
             _meshes[key] = new MeshInfo(key, mesh, fontInfo.textureVersion);
 
-            return mesh;
+            this._mesh = mesh.transform(this._transform);
+            return this._mesh;
         }
     }
 }

Runtime/widgets/binding.cs

             Window.instance.onLocaleChanged += this.handleLocaleChanged;
             this.widgetInspectorService = new WidgetInspectorService(this);
             this.addPersistentFrameCallback((duration) => {
-                MeshGenerator.tickNextFrame();
+                TextBlobMesh.tickNextFrame();
                 TessellationGenerator.tickNextFrame();
             });
         }