public void PrepareStringForRenderVx(RenderVxFormattedString renderVx, char[] buffer, int startAt, int len) { glyphPlans.Clear(); _glyphLayout.Layout(_typeface, buffer, startAt, len, glyphPlans); TextPrinterHelper.CopyGlyphPlans(renderVx, glyphPlans, _typeface.CalculateToPixelScaleFromPointSize(font.SizeInPoints)); }
void DrawText(DrawBoard d) { //d.DrawText(_mybuffer, // new Rectangle(0, 0, bWidth, bHeight), // style.ContentHAlign); if (_renderVxFormattedString == null) { _renderVxFormattedString = d.CreateFormattedString(_mybuffer, 0, _mybuffer.Length, DelayFormattedString); } switch (_renderVxFormattedString.State) { case RenderVxFormattedString.VxState.Ready: d.DrawRenderVx(_renderVxFormattedString, 0, 0); break; case RenderVxFormattedString.VxState.NoStrip: { //put this to the update queue system //(TODO: add extension method for this) GlobalRootGraphic.CurrentRootGfx.EnqueueRenderRequest( new RenderBoxes.RenderElementRequest( s_currentRenderE, RenderBoxes.RequestCommand.ProcessFormattedString, _renderVxFormattedString)); } break; } }
public void PrepareStringForRenderVx(RenderVxFormattedString renderVx, char[] text, int startAt, int len) { //1. update some props.. //2. update current type face UpdateGlyphLayoutSettings(); Typeface typeface = _currentTypeface; }
public void DrawText(RenderVxFormattedString renderVxFormattedString, float x, float y) { #if DEBUG dbugCounter.dbugDrawStringCount++; #endif switch (renderVxFormattedString.State) { case RenderVxFormattedString.VxState.Ready: { //int ox = _drawBoard.OriginX; //int oy = _drawBoard.OriginY; //_drawBoard.SetCanvasOrigin((int)point.X, (int)point.Y); _drawBoard.TextBackgroundColorHint = this.CurrentSolidBackgroundColorHint; _drawBoard.DrawRenderVx(renderVxFormattedString, x, y); //_drawBoard.SetCanvasOrigin(ox, oy);//restore } break; case RenderVxFormattedString.VxState.NoStrip: { //put this to the update queue system //(TODO: add extension method for this) //GlobalRootGraphic.CurrentRootGfx.EnqueueRenderRequest( // new RenderBoxes.RenderElementRequest( // s_currentRenderE, // RenderBoxes.RequestCommand.ProcessFormattedString, // renderVxFormattedString)); } break; } }
public override void Draw(Painter p) { //painter.DrawString("hello world!", 100, 100); //painter.DrawString("กิ่น", 100, 100); // string test_str = "อูญูอุบ่ป่กินกิ่นก็โก้"; //string test_str = "ปู่"; //string test_str = "ก็"; string test_str = "abcd"; //string test_str = "A"; //string test_str = "012345"; //string test_str = "กิน"; p.Clear(PixelFarm.Drawing.Color.White); p.FillColor = PixelFarm.Drawing.Color.Red; p.UseSubPixelLcdEffect = true; int n = 50; for (int i = 0; i < n; i++) { // p.DrawString(test_str, i * 10, i * 10); float x_pos = i * 20; float y_pos = i * 20; p.FillRect(x_pos, y_pos, x_pos + 5, y_pos + 5); } p.FillColor = PixelFarm.Drawing.Color.Black; if (_strRenderVx_1 == null) { p.CurrentFont = _font1; _strRenderVx_1 = p.CreateRenderVx(test_str); } if (_strRenderVx_2 == null) { p.CurrentFont = _font2; _strRenderVx_2 = p.CreateRenderVx(test_str); } // for (int i = 0; i < n; i++) { float x_pos = i * 20; float y_pos = i * 20; //p.DrawString("(" + x_pos + "," + y_pos + ")", x_pos, y_pos); if ((i % 2) == 0) { //since draw string may be slow //we can convert it to a 'freezed' visual object (RenderVx) p.CurrentFont = _font1; p.DrawString(_strRenderVx_1, x_pos, y_pos); } else { //since draw string may be slow //we can convert it to a 'freezed' visual object (RenderVx) p.CurrentFont = _font2; p.DrawString(_strRenderVx_2, x_pos, y_pos); } } }
public void Dispose() { if (_renderVxFormattedString != null) { _renderVxFormattedString.Dispose(); _renderVxFormattedString = null; } }
public override void DrawString(RenderVxFormattedString renderVx, double x, double y) { // if (_textPrinter != null) { _textPrinter.DrawString(renderVx, x, y); } }
public void DrawString(RenderVxFormattedString renderVx, double x, double y) { _glsx.LoadTexture1(_glBmp); _glsx.FontFillColor = painter.FontFillColor; DrawingGL.GLRenderVxFormattedString renderVxString1 = (DrawingGL.GLRenderVxFormattedString)renderVx; DrawingGL.VertexBufferObject2 vbo = renderVxString1.GetVbo(); vbo.Bind(); _glsx.DrawGlyphImageWithSubPixelRenderingTechnique4(renderVxString1.VertexCount, (float)x, (float)y); vbo.UnBind(); }
public void DrawString(RenderVxFormattedString renderVx, double x, double y) { float ox = canvasPainter.OriginX; float oy = canvasPainter.OriginY; //1. update some props.. //2. update current type face UpdateTypefaceAndGlyphBuilder(); Typeface typeface = _glyphPathBuilder.Typeface; //3. layout glyphs with selected layout technique //TODO: review this again, we should use pixel? float fontSizePoint = this.FontSizeInPoints; float scale = typeface.CalculateToPixelScaleFromPointSize(fontSizePoint); RenderVxGlyphPlan[] glyphPlans = renderVx.glyphList; int j = glyphPlans.Length; //--------------------------------------------------- //consider use cached glyph, to increase performance hintGlyphCollection.SetCacheInfo(typeface, fontSizePoint, this.HintTechnique); //--------------------------------------------------- for (int i = 0; i < j; ++i) { RenderVxGlyphPlan glyphPlan = glyphPlans[i]; //----------------------------------- //TODO: review here *** //PERFORMANCE revisit here //if we have create a vxs we can cache it for later use? //----------------------------------- VertexStore glyphVxs; if (!hintGlyphCollection.TryGetCacheGlyph(glyphPlan.glyphIndex, out glyphVxs)) { //if not found then create new glyph vxs and cache it _glyphPathBuilder.SetHintTechnique(this.HintTechnique); _glyphPathBuilder.BuildFromGlyphIndex(glyphPlan.glyphIndex, fontSizePoint); //----------------------------------- _tovxs.Reset(); _glyphPathBuilder.ReadShapes(_tovxs); //TODO: review here, //float pxScale = _glyphPathBuilder.GetPixelScale(); glyphVxs = new VertexStore(); _tovxs.WriteOutput(glyphVxs, _vxsPool); // hintGlyphCollection.RegisterCachedGlyph(glyphPlan.glyphIndex, glyphVxs); } canvasPainter.SetOrigin((float)(glyphPlan.x * scale + x), (float)(glyphPlan.y * scale + y)); canvasPainter.Fill(glyphVxs); } //restore prev origin canvasPainter.SetOrigin(ox, oy); }
public void PrepareStringForRenderVx(RenderVxFormattedString renderVx, char[] buffer, int startAt, int len) { var renderVxFormattedString = renderVx as GLRenderVxFormattedString; #if DEBUG if (renderVxFormattedString == null) { throw new NotSupportedException(); } #endif PrepareStringForRenderVx(renderVxFormattedString, buffer, startAt, len); }
//each editable run has it own (dynamic) char buffer void SetNewContent(char[] newbuffer) { #if DEBUG _dbugmybuffer = newbuffer; #else _mybuffer = newbuffer; #endif _content_unparsed = true; _renderVxFormattedString?.Dispose(); //clear old _renderVxFormattedString _renderVxFormattedString = null; }
public void PrepareStringForRenderVx(RenderVxFormattedString renderVx, char[] text, int startAt, int len) { //1. update some props.. //2. update current type face UpdateTypefaceAndGlyphBuilder(); Typeface typeface = _currentTypeface;// _glyphPathBuilder.Typeface; _glyphLayout.Typeface = typeface; _glyphLayout.Layout(text, startAt, len); // //3. scale from design unit to specific font size _outputGlyphPlans.Clear(); _pxScaleEngine.Layout(_glyphLayout.ResultUnscaledGlyphPositions, _outputGlyphPlans); TextPrinterHelper.CopyGlyphPlans(renderVx, _outputGlyphPlans, this._currentFontSizePxScale); }
public void PrepareStringForRenderVx(RenderVxFormattedString renderVx, char[] text, int startAt, int len) { //1. update some props.. //2. update current type face UpdateTypefaceAndGlyphBuilder(); Typeface typeface = _currentTypeface;// _glyphPathBuilder.Typeface; //3. layout glyphs with selected layout technique //TODO: review this again, we should use pixel? float pxscale = typeface.CalculateToPixelScaleFromPointSize(FontSizeInPoints); _outputGlyphPlans.Clear(); _glyphLayout.Layout(typeface, text, startAt, len, _outputGlyphPlans); TextPrinterHelper.CopyGlyphPlans(renderVx, _outputGlyphPlans, pxscale); }
public override void UpdateRunWidth() { //*** var textBufferSpan = new Typography.Text.TextBufferSpan(_mybuffer); //TODO: review here, //1. if mybuffer lenght is not changed,we don't need to alloc new array? _outputUserCharAdvances = new int[_mybuffer.Length]; if (_renderVxFormattedString != null) { _renderVxFormattedString.Dispose(); _renderVxFormattedString = null; } var measureResult = new TextSpanMeasureResult(); measureResult.outputXAdvances = _outputUserCharAdvances; if (_content_unparsed) { //parse the content first if (_lineSegs == null) { _lineSegs = new TextPrinterLineSegmentList <TextPrinterLineSegment>(); } _lineSegs.Clear(); // if (s_wordVistor == null) { s_wordVistor = new TextPrinterWordVisitor(); } s_wordVistor.SetLineSegmentList(_lineSegs); RunStyle.BreakToLineSegments(textBufferSpan, s_wordVistor); s_wordVistor.SetLineSegmentList(null); //BreakToLineSegs(textBufferSpan); } _content_unparsed = false; RunStyle.CalculateUserCharGlyphAdvancePos(textBufferSpan, _lineSegs, ref measureResult); SetSize(measureResult.outputTotalW, measureResult.lineHeight); InvalidateGraphics(); }
public void DrawString(RenderVxFormattedString renderVx, double x, double y) { //TODO: review here float ox = _painter.OriginX; float oy = _painter.OriginY; //1. update some props.. //2. update current type face UpdateGlyphLayoutSettings(); _glyphMeshStore.SetFont(_currentTypeface, this.FontSizeInPoints); _glyphMeshStore.SimulateOblique = this.SimulateSlant; //3. layout glyphs with selected layout technique //TODO: review this again, we should use pixel? float fontSizePoint = this.FontSizeInPoints; float scale = _currentTypeface.CalculateScaleToPixelFromPointSize(fontSizePoint); RenderVxGlyphPlan[] glyphPlans = renderVx.GlyphList; int j = glyphPlans.Length; //--------------------------------------------------- //consider use cached glyph, to increase performance //GlyphPosPixelSnapKind x_snap = this.GlyphPosPixelSnapX; //GlyphPosPixelSnapKind y_snap = this.GlyphPosPixelSnapY; float g_x = 0; float g_y = 0; float baseY = (int)y; for (int i = 0; i < j; ++i) { RenderVxGlyphPlan glyphPlan = glyphPlans[i]; //----------------------------------- //TODO: review here *** //PERFORMANCE revisit here //if we have create a vxs we can cache it for later use? //----------------------------------- VertexStore vxs = _glyphMeshStore.GetGlyphMesh(glyphPlan.glyphIndex); g_x = (float)(glyphPlan.x * scale + x); g_y = (float)glyphPlan.y * scale; _painter.SetOrigin(g_x, g_y); _painter.Fill(vxs); } //restore prev origin _painter.SetOrigin(ox, oy); }
public static void CopyGlyphPlans(RenderVxFormattedString renderVx, GlyphPlanList glyphPlans, float scale) { int n = glyphPlans.Count; //copy var renderVxGlyphPlans = new RenderVxGlyphPlan[n]; for (int i = 0; i < n; ++i) { GlyphPlan glyphPlan = glyphPlans[i]; renderVxGlyphPlans[i] = new RenderVxGlyphPlan( glyphPlan.glyphIndex, glyphPlan.ExactX, glyphPlan.ExactY, glyphPlan.AdvanceX ); } renderVx.glyphList = renderVxGlyphPlans; }
public static void CopyGlyphPlans(RenderVxFormattedString renderVx, List <GlyphPlan> glyphPlans, float scale) { int n = glyphPlans.Count; //copy var renderVxGlyphPlans = new RenderVxGlyphPlan[n]; for (int i = 0; i < n; ++i) { GlyphPlan glyphPlan = glyphPlans[i]; renderVxGlyphPlans[i] = new RenderVxGlyphPlan( glyphPlan.glyphIndex, glyphPlan.x * scale, glyphPlan.y * scale, glyphPlan.advX * scale ); } renderVx.glyphList = renderVxGlyphPlans; }
public override void CustomDrawToThisCanvas(DrawBoard canvas, Rectangle updateArea) { if (this.textBuffer != null) { var prevColor = canvas.CurrentTextColor; canvas.CurrentTextColor = textColor; canvas.CurrentFont = _font; //for faster text drawing //we create a formatted-text //canvas.DrawText(this.textBuffer, this.X, this.Y); if (renderVxFormattedString == null) { renderVxFormattedString = canvas.CreateFormattedString(textBuffer, 0, textBuffer.Length); } canvas.DrawRenderVx(renderVxFormattedString, this.X, this.Y); canvas.CurrentTextColor = prevColor; } }
public static void CopyGlyphPlans(RenderVxFormattedString renderVx, UnscaledGlyphPlanList glyphPlans, float scale) { int n = glyphPlans.Count; //copy var renderVxGlyphPlans = new RenderVxGlyphPlan[n]; float acc_x = 0; float acc_y = 0; float x = 0; float y = 0; float g_x = 0; float g_y = 0; for (int i = 0; i < n; ++i) { UnscaledGlyphPlan glyphPlan = glyphPlans[i]; float ngx = acc_x + (float)Math.Round(glyphPlan.OffsetX * scale); float ngy = acc_y + (float)Math.Round(glyphPlan.OffsetY * scale); //NOTE: // -glyphData.TextureXOffset => restore to original pos // -glyphData.TextureYOffset => restore to original pos //-------------------------- g_x = (float)(x + ngx); //ideal x g_y = (float)(y + ngy); float g_w = (float)Math.Round(glyphPlan.AdvanceX * scale); acc_x += g_w; //g_x = (float)Math.Round(g_x); g_y = (float)Math.Floor(g_y); renderVxGlyphPlans[i] = new RenderVxGlyphPlan( glyphPlan.glyphIndex, g_x, g_y, g_w ); } renderVx.glyphList = renderVxGlyphPlans; }
public void DrawString(RenderVxFormattedString renderVx, double x, double y) { RenderVxGlyphPlan[] glyphPlans = renderVx.glyphList; int n = glyphPlans.Length; EnsureLoadGLBmp(); //PERF: //TODO: review here, can we cache the glbmp for later use //not to create it every time float scaleFromTexture = _finalTextureScale; TextureKind textureKind = _fontAtlas.TextureKind; float g_x = 0; float g_y = 0; int baseY = (int)Math.Round(y); float scale = 1; for (int i = 0; i < n; ++i) { //PERF: //TODO: //render a set of glyph instead of one glyph per time *** RenderVxGlyphPlan glyph = glyphPlans[i]; Typography.Rendering.TextureFontGlyphData glyphData; if (!_fontAtlas.TryGetGlyphDataByCodePoint(glyph.glyphIndex, out glyphData)) { //if no glyph data, we should render a missing glyph *** continue; } //-------------------------------------- //TODO: review precise height in float //-------------------------------------- PixelFarm.Drawing.Rectangle srcRect = ConvToRect(glyphData.Rect); //-------------------------- g_x = (float)(x + (glyph.x * scale - glyphData.TextureXOffset) * scaleFromTexture); //ideal x g_y = (float)((glyph.y * scale - glyphData.TextureYOffset + srcRect.Height) * scaleFromTexture); switch (textureKind) { case TextureKind.Msdf: _glsx.DrawSubImageWithMsdf(_glBmp, ref srcRect, g_x, g_y, scaleFromTexture); break; case TextureKind.StencilGreyScale: //stencil gray scale with fill-color _glsx.DrawGlyphImageWithStecil(_glBmp, ref srcRect, g_x, g_y, scaleFromTexture); break; case TextureKind.Bitmap: _glsx.DrawSubImage(_glBmp, ref srcRect, g_x, g_y, scaleFromTexture); break; case TextureKind.StencilLcdEffect: _glsx.DrawGlyphImageWithSubPixelRenderingTechnique(_glBmp, ref srcRect, g_x, g_y, scaleFromTexture); break; } } }
public void PrepareStringForRenderVx(RenderVxFormattedString renderVx, char[] text, int start, int len) { throw new NotImplementedException(); }
public override void DrawString(RenderVxFormattedString renderVx, double x, double y) { //TODO: review here again _skCanvas.DrawText(renderVx.OriginalString, (float)x, (float)y, _stroke); }
public abstract void DrawString(RenderVxFormattedString renderVx, double x, double y);
public void DrawText(RenderVxFormattedString formattedStr, PointF point, SizeF size) { _drawBoard.GetPainter().DrawString(formattedStr, point.X, point.Y); }
public void DrawString(RenderVxFormattedString renderVx, double x, double y) { DrawString((GLRenderVxFormattedString)renderVx, x, y); }
public void DrawString(RenderVxFormattedString renderVx, double x, double y) { RenderVxGlyphPlan[] glyphPlans = renderVx.glyphList; int n = glyphPlans.Length; EnsureLoadGLBmp(); //PERF: //TODO: review here, can we cache the glbmp for later use //not to create it every time float scaleFromTexture = _finalTextureScale; Typography.Rendering.TextureKind textureKind = simpleFontAtlas.TextureKind; float g_x = 0; float g_y = 0; int baseY = (int)Math.Round(y); float scale = 1; for (int i = 0; i < n; ++i) { //PERF: //TODO: //render a set of glyph instead of one glyph per time *** RenderVxGlyphPlan glyph = glyphPlans[i]; Typography.Rendering.TextureFontGlyphData glyphData; if (!simpleFontAtlas.TryGetGlyphDataByCodePoint(glyph.glyphIndex, out glyphData)) { continue; } //-------------------------------------- //TODO: review precise height in float //-------------------------------------- PixelFarm.Drawing.Rectangle srcRect = ConvToRect(glyphData.Rect); //-------------------------- GlyphPosPixelSnapKind x_snap = this.GlyphPosPixelSnapX; GlyphPosPixelSnapKind y_snap = this.GlyphPosPixelSnapY; switch (x_snap) { default: throw new NotSupportedException(); case GlyphPosPixelSnapKind.Integer: { g_x = (float)(x + (glyph.x * scale - glyphData.TextureXOffset) * scaleFromTexture); //ideal x int floor_x = (int)g_x; //round to int 0,1 if (g_x - floor_x >= (1f / 2f)) { g_x = floor_x + 1; } else { g_x = floor_x; } } break; case GlyphPosPixelSnapKind.Half: { g_x = (float)(x + (glyph.x * scale - glyphData.TextureXOffset) * scaleFromTexture); //ideal x //adjust int floor_x = (int)g_x; //round to int 0, 0.5,1.0 if (g_x - floor_x >= (2f / 3f)) { g_x = floor_x + 1; } else if (g_x - floor_x >= (1f / 3f)) { g_x = floor_x + 0.5f; } else { g_x = floor_x; } } break; case GlyphPosPixelSnapKind.None: g_x = (float)(x + (glyph.x * scale - glyphData.TextureXOffset) * scaleFromTexture); break; } // switch (y_snap) { default: throw new NotSupportedException(); case GlyphPosPixelSnapKind.Integer: //use baseY not y { g_y = (float)((glyph.y * scale - glyphData.TextureYOffset + srcRect.Height) * scaleFromTexture); int floor_y = (int)g_y; //round to int 0,1 if (g_y - floor_y >= (1f / 2f)) { g_y = floor_y + 1; } else { g_y = floor_y; } g_y = baseY + g_y; } break; case GlyphPosPixelSnapKind.Half: //review here //use baseY not y { g_y = (float)((glyph.y * scale - glyphData.TextureYOffset + srcRect.Height) * scaleFromTexture); int floor_y = (int)g_y; //round to int 0, 0.5,1.0 if (g_y - floor_y >= (2f / 3f)) { g_y = floor_y + 1; } else if (g_x - floor_y >= (1f / 3f)) { g_y = floor_y + 0.5f; } else { g_y = floor_y; } g_y = baseY + g_y; } break; case GlyphPosPixelSnapKind.None: //use Y not baseY g_y = (float)(y + (glyph.y * scale - glyphData.TextureYOffset + srcRect.Height) * scaleFromTexture); break; } switch (textureKind) { case Typography.Rendering.TextureKind.Msdf: canvas2d.DrawSubImageWithMsdf(_glBmp, ref srcRect, g_x, g_y, scaleFromTexture); break; case Typography.Rendering.TextureKind.AggGrayScale: canvas2d.DrawSubImage(_glBmp, ref srcRect, g_x, g_y, scaleFromTexture); break; case Typography.Rendering.TextureKind.AggSubPixel: canvas2d.DrawGlyphImageWithSubPixelRenderingTechnique(_glBmp, ref srcRect, g_x, g_y, scaleFromTexture); break; } //----------- //backup //switch (textureKind) //{ // case Typography.Rendering.TextureKind.Msdf: // { // canvas2d.DrawSubImageWithMsdf(_glBmp, // ref srcRect, // (float)(x + (glyph.x - glyphData.TextureXOffset) * scaleFromTexture), // -glyphData.TextureXOffset => restore to original pos // (float)(y + (glyph.y - glyphData.TextureYOffset + srcRect.Height) * scaleFromTexture),// -glyphData.TextureYOffset => restore to original pos // scaleFromTexture); // } // break; // case Typography.Rendering.TextureKind.AggGrayScale: // { // canvas2d.DrawSubImage(_glBmp, // ref srcRect, // (float)(x + (glyph.x - glyphData.TextureXOffset) * scaleFromTexture), // -glyphData.TextureXOffset => restore to original pos // (float)(y + (glyph.y - glyphData.TextureYOffset + srcRect.Height) * scaleFromTexture),// -glyphData.TextureYOffset => restore to original pos // scaleFromTexture); // } // break; // case Typography.Rendering.TextureKind.AggSubPixel: // canvas2d.DrawGlyphImageWithSubPixelRenderingTechnique(_glBmp, // ref srcRect, // (float)(x + (glyph.x - glyphData.TextureXOffset) * scaleFromTexture), // -glyphData.TextureXOffset => restore to original pos // (float)(y + (glyph.y - glyphData.TextureYOffset + srcRect.Height) * scaleFromTexture),// -glyphData.TextureYOffset => restore to original pos // scaleFromTexture); // break; //} } }
public void PrepareStringForRenderVx(RenderVxFormattedString renderVx, char[] text, int startAt, int len) { UpdateGlyphLayoutSettings(); }
public void PrepareStringForRenderVx(RenderVxFormattedString renderVx, char[] buffer, int startAt, int len) { int j = buffer.Length; //create temp buffer span that describe the part of a whole char buffer TextBufferSpan textBufferSpan = new TextBufferSpan(buffer, startAt, len); //ask text service to parse user input char buffer and create a glyph-plan-sequence (list of glyph-plan) //with specific request font GlyphPlanSequence glyphPlanSeq = _textServices.CreateGlyphPlanSeq(ref textBufferSpan, font); float scale = _fontAtlas.TargetTextureScale; int recommendLineSpacing = _fontAtlas.OriginalRecommendLineSpacing; //-------------------------- //TODO: //if (x,y) is left top //we need to adjust y again float x = 0; float y = 0; y -= ((recommendLineSpacing) * scale); renderVx.RecommmendLineSpacing = (int)(recommendLineSpacing * scale); // float scaleFromTexture = _finalTextureScale; TextureKind textureKind = _fontAtlas.TextureKind; //-------------------------- //TODO: review render steps //NOTE: // -glyphData.TextureXOffset => restore to original pos // -glyphData.TextureYOffset => restore to original pos // ideal_x = (float)(x + (glyph.x * scale - glyphData.TextureXOffset) * scaleFromTexture); // ideal_y = (float)(y + (glyph.y * scale - glyphData.TextureYOffset + srcRect.Height) * scaleFromTexture); //-------------------------- float g_x = 0; float g_y = 0; int baseY = (int)Math.Round(y); int n = glyphPlanSeq.len; int endBefore = glyphPlanSeq.startAt + n; //*** _glsx.SetAssociatedTextureInfo(_glBmp); // vboBufferList2.Clear(); indexList2.Clear(); float acc_x = 0; float acc_y = 0; for (int i = glyphPlanSeq.startAt; i < endBefore; ++i) { UnscaledGlyphPlanList glyphPlanList = GlyphPlanSequence.UnsafeGetInteralGlyphPlanList(glyphPlanSeq); UnscaledGlyphPlan glyph = glyphPlanList[i]; Typography.Rendering.TextureFontGlyphData glyphData; if (!_fontAtlas.TryGetGlyphDataByGlyphIndex(glyph.glyphIndex, out glyphData)) { //if no glyph data, we should render a missing glyph *** continue; } //-------------------------------------- //TODO: review precise height in float //-------------------------------------- PixelFarm.Drawing.Rectangle srcRect = ConvToRect(glyphData.Rect); float ngx = acc_x + (float)Math.Round(glyph.OffsetX * scale); float ngy = acc_y + (float)Math.Round(glyph.OffsetY * scale); //NOTE: // -glyphData.TextureXOffset => restore to original pos // -glyphData.TextureYOffset => restore to original pos //-------------------------- g_x = (float)(x + (ngx - glyphData.TextureXOffset) * scaleFromTexture); //ideal x g_y = (float)(y + (ngy - glyphData.TextureYOffset + srcRect.Height) * scaleFromTexture); acc_x += (float)Math.Round(glyph.AdvanceX * scale); //g_x = (float)Math.Round(g_x); g_y = (float)Math.Floor(g_y); switch (textureKind) { case TextureKind.Msdf: _glsx.DrawSubImageWithMsdf(_glBmp, ref srcRect, g_x, g_y, scaleFromTexture); break; case TextureKind.StencilGreyScale: //stencil gray scale with fill-color _glsx.DrawGlyphImageWithStecil(_glBmp, ref srcRect, g_x, g_y, scaleFromTexture); break; case TextureKind.Bitmap: _glsx.DrawSubImage(_glBmp, ref srcRect, g_x, g_y, scaleFromTexture); break; case TextureKind.StencilLcdEffect: _glsx.WriteVboToList( vboBufferList2, indexList2, ref srcRect, g_x, g_y, scaleFromTexture); break; } } //--------- DrawingGL.GLRenderVxFormattedString renderVxFormattedString = (DrawingGL.GLRenderVxFormattedString)renderVx; renderVxFormattedString.IndexArray = indexList2.ToArray(); renderVxFormattedString.VertexCoords = vboBufferList2.ToArray(); renderVxFormattedString.VertexCount = indexList2.Count; }
public override void DrawString(RenderVxFormattedString renderVx, double x, double y) { throw new NotImplementedException(); }
public void PrepareStringForRenderVx(RenderVxFormattedString renderVx, char[] buffer, int startAt, int len) { //TextPrinterHelper.CopyGlyphPlans(renderVx, glyphPlans, _typeface.CalculateScaleToPixelFromPointSize(font.SizeInPoints)); }