public D3D11Renderer(ObservableVideoTrack videoTrack, RendererOptions options) : base(videoTrack, options) { // _factoryDWrite = new DWrite.Factory(DWrite.FactoryType.Shared); var device2D = new D2D1.Device(DeviceDXGI, new D2D1.CreationProperties { DebugLevel = D2D1.DebugLevel.Warning, ThreadingMode = D2D1.ThreadingMode.MultiThreaded, Options = D2D1.DeviceContextOptions.None }); _context2D = new D2D1.DeviceContext(device2D, D2D1.DeviceContextOptions.None); // Load the background image using (var factoryWic = new WIC.ImagingFactory2()) using (var decoder = new WIC.JpegBitmapDecoder(factoryWic)) using (var inputStream = new WIC.WICStream(factoryWic, "background-small.jpg", NativeFileAccess.Read)) using (var formatConverter = new WIC.FormatConverter(factoryWic)) using (var bitmapScaler = new WIC.BitmapScaler(factoryWic)) { decoder.Initialize(inputStream, WIC.DecodeOptions.CacheOnLoad); formatConverter.Initialize(decoder.GetFrame(0), WIC.PixelFormat.Format32bppPBGRA); bitmapScaler.Initialize(formatConverter, VideoFrameWidth, VideoFrameHeight, WIC.BitmapInterpolationMode.Fant); _backgroundBitmap = D2D1.Bitmap1.FromWicBitmap(_context2D, bitmapScaler); } // Create render target _ballEllipse = new D2D1.Ellipse { RadiusX = VideoFrameWidth / 20f, RadiusY = VideoFrameWidth / 20f }; _ballBrush = new D2D1.SolidColorBrush(_context2D, new RawColor4(1f, 1f, 0f, 1f)); }
public WorldObject(string name, bool ignoreCollisions, Vector2 position, string spriteName, RendererOptions renderOptions = null) : base(name, ignoreCollisions, position, spriteName, renderOptions) { if (AllObjects == null) AllObjects = new List<WorldObject>(); AllObjects.Add(this); }
public static void DrawText(this IImageProcessingContext context, TextGraphicsOptions op, string?text, Font font, Color color, Rectangle bounds) { if (string.IsNullOrEmpty(text)) { return; } op.WrapTextWidth = bounds.Width; RendererOptions rOp = new RendererOptions(font); rOp.WrappingWidth = bounds.Width; bool fits = false; while (!fits) { SizeF size = TextMeasurer.Measure(text, rOp); fits = size.Height <= bounds.Height && size.Width <= bounds.Width; if (!fits) { text = text.Truncate(text.Length - 5); } } context.DrawText(op, text, font, color, new Point(bounds.X, bounds.Y)); }
public (int, RectangleF) GetAdjustedFont(string graphicString, float containerWidth, float containerHeight, int maxFontSize, int minFontSize) { var sizeRect = new RectangleF(); for (int adjustedSize = maxFontSize; adjustedSize >= minFontSize; adjustedSize--) { var testFont = new Font(_dummyFont, adjustedSize); var renderOptions = new RendererOptions(testFont) { WrappingWidth = containerWidth }; // Test the string with the new size sizeRect = TextMeasurer.MeasureBounds(graphicString, renderOptions); float volume = sizeRect.Height * sizeRect.Width; if (volume < containerWidth * containerHeight) { // Good font, return it return(adjustedSize, sizeRect); } } return(minFontSize, sizeRect); }
private static Image <T> RenderImage <T>(this FontAtlas fa, T color) where T : struct, IPixel <T> { // TODO we need the extra pixels here because ImageSharp renders out of bounds and crashes. var img = new Image <T>(Configuration.Default, fa.Width + 2, fa.Height); var tgo = new TextGraphicsOptions(true); tgo.AntialiasSubpixelDepth = 8; for (var i = 0; i < fa.MapCount; i++) { var gm = fa[i]; var font = gm.Font; foreach (var gd in gm) { // TODO lower level control to render single character? This API sucks balls for FA layout + rendering var charStr = char.ConvertFromUtf32(gd.Character); var pos = (Vector2)gd.Bounds.TopLeft; var ro = new RendererOptions(font); TextMeasurer.TryMeasureCharacterBounds(charStr.AsSpan(), ro, out var cbs); var cb = cbs[0]; img.Mutate(c => c.DrawText(tgo, charStr, font, color, pos - (Vector2)cb.Bounds.Location)); } } return(img); }
public static Stream Render(string text, Image <Rgba32> image) { var words = text.Split(' '); var font = Arial.CreateFont(2, FontStyle.Regular); var canvasPoint = new PointF(image.Width * 0.125F, image.Height * 0.70F); var canvasSize = new SizeF(image.Width * 0.75F, image.Height * 0.3F); font = GetLargestFont(canvasSize, font, text); var render = new RendererOptions(font); foreach (var line in SplitTextForMaxWidth(canvasSize.Width, font, text)) { var textSize = TextMeasurer.Measure(line, render); var point = new PointF(canvasPoint.X + (canvasSize.Width - textSize.Width) / 2, canvasPoint.Y); image.Mutate(cl => cl.DrawText(line, font, Brushes.Solid(Color.WhiteSmoke), Pens.Solid(Color.Black, 1), point)); canvasPoint.Y += textSize.Height; } var str = new MemoryStream(); image.SaveAsJpeg(str); str.Seek(0, SeekOrigin.Begin); return(str); }
private static IEnumerable <string> SplitTextForMaxWidth(float width, Font font, string input) { var render = new RendererOptions(font); var words = input.Replace("\n", " ").Split(' '); string currentLine = null; foreach (var word in words) { if (currentLine == null) { currentLine = ""; } if (GetWidth(currentLine + word + " ") > width) { yield return(currentLine.Trim()); currentLine = word; } else { currentLine += " " + word; } } if (currentLine != null) { yield return(currentLine); } float GetWidth(string line) { return(TextMeasurer.Measure(line, render).Width); } }
public void ContructorTest_FontWithXandYDpisWithOrigin_WithFallbackFonts() { Font font = FakeFont.CreateFont("ABC"); FontFamily[] fontFamilys = new[] { FakeFont.CreateFont("DEF").Family, FakeFont.CreateFont("GHI").Family }; var origin = new Vector2(123, 345); float dpix = 123; float dpiy = 456; var options = new RendererOptions(font, dpix, dpiy, origin) { FallbackFontFamilies = fontFamilys }; Assert.Equal(dpix, options.DpiX); Assert.Equal(dpiy, options.DpiY); Assert.Equal(fontFamilys, options.FallbackFontFamilies); Assert.Equal(font, options.Font); Assert.Equal(origin, options.Origin); VerifyPropertyDefault(options); }
public OpenXmlSize MeasureText(IOpenXmlTextStyle defaultTextStyle, IOpenXmlTheme theme, OpenXmlUnit?width) { // TODO: subtract border // TODO: measure each pararaph individually int level = 1; IOpenXmlParagraphTextStyle defaultParagraphTextStyle = defaultTextStyle.GetParagraphTextStyle(level); string text = this.GetText(); string typeface = theme.ResolveFontTypeface(this.GetFont() ?? defaultParagraphTextStyle.LatinTypeface); double fontSize = this.GetFontSize() ?? defaultParagraphTextStyle.Size ?? 9.0; double kerning = this.GetKerning() ?? defaultParagraphTextStyle.Kerning ?? 0.0; OpenXmlMargin margin = this.GetTextMargin(); Font font = SystemFonts.Find(typeface).CreateFont((float)fontSize); RendererOptions options = new RendererOptions(font, 72) { WrappingWidth = width.HasValue ? (float)(width.Value - margin.Left - margin.Right).AsPoints() : -1.0f, ApplyKerning = kerning != 0.0, LineSpacing = 1 / 1.2f }; FontRectangle rect = TextMeasurer.Measure(text, options); OpenXmlSize result = new OpenXmlSize( width.HasValue ? width.Value : (OpenXmlUnit.Points(rect.Width) + margin.Left + margin.Right), OpenXmlUnit.Points(rect.Height * 1.2) + margin.Top + margin.Bottom ); return(result); }
public static void RenderTextProcessor(FontFamily fontFamily, string text, float pointSize = 12, IEnumerable <FontFamily> fallbackFonts = null) { var textOptions = new TextGraphicsOptionsCopy { ApplyKerning = true, DpiX = 96, DpiY = 96, RenderColorFonts = true, }; if (fallbackFonts != null) { textOptions.FallbackFonts.AddRange(fallbackFonts); } var font = new Font(fontFamily, pointSize); var renderOptions = new RendererOptions(font, textOptions.DpiX, textOptions.DpiY) { ApplyKerning = true, ColorFontSupport = ColorFontSupport.MicrosoftColrFormat, FallbackFontFamilies = textOptions.FallbackFonts?.ToArray() }; var textSize = TextMeasurer.Measure(text, renderOptions); using (var img = new Image <Rgba32>((int)Math.Ceiling(textSize.Width) + 20, (int)Math.Ceiling(textSize.Height) + 20)) { img.Mutate(x => x.Fill(Color.White).ApplyProcessor(new DrawTextProcessorCopy(textOptions, text, font, new SolidBrushCopy(Color.Black), null, new PointF(5, 5)))); string fullPath = CreatePath(font.Name, text + ".caching.png"); Directory.CreateDirectory(System.IO.Path.GetDirectoryName(fullPath)); img.Save(fullPath); } }
/// <summary> /// Draws the text using the default resolution of <value>72dpi</value> onto the the image filled via the brush then outlined via the pen. /// </summary> /// <typeparam name="TPixel">The type of the color.</typeparam> /// <param name="source">The image this method extends.</param> /// <param name="text">The text.</param> /// <param name="font">The font.</param> /// <param name="brush">The brush.</param> /// <param name="pen">The pen.</param> /// <param name="location">The location.</param> /// <param name="options">The options.</param> /// <returns> /// The <see cref="Image{TPixel}" />. /// </returns> public static IImageProcessingContext <TPixel> DrawText <TPixel>(this IImageProcessingContext <TPixel> source, string text, Font font, IBrush <TPixel> brush, IPen <TPixel> pen, PointF location, TextGraphicsOptions options) where TPixel : struct, IPixel <TPixel> { float dpiX = DefaultTextDpi; float dpiY = DefaultTextDpi; var style = new RendererOptions(font, dpiX, dpiY, location) { ApplyKerning = options.ApplyKerning, TabWidth = options.TabWidth, WrappingWidth = options.WrapTextWidth, HorizontalAlignment = options.HorizontalAlignment, VerticalAlignment = options.VerticalAlignment }; IPathCollection glyphs = TextBuilder.GenerateGlyphs(text, style); var pathOptions = (GraphicsOptions)options; if (brush != null) { source.Fill(brush, glyphs, pathOptions); } if (pen != null) { source.Draw(pen, glyphs, pathOptions); } return(source); }
protected override void BeforeImageApply() { base.BeforeImageApply(); // do everything at the image level as we are delegating the processing down to other processors var style = new RendererOptions(this.Font, this.Options.DpiX, this.Options.DpiY, this.Location) { ApplyKerning = this.Options.ApplyKerning, TabWidth = this.Options.TabWidth, WrappingWidth = this.Options.WrapTextWidth, HorizontalAlignment = this.Options.HorizontalAlignment, VerticalAlignment = this.Options.VerticalAlignment, FallbackFontFamilies = this.Options.FallbackFonts, ColorFontSupport = this.definition.Options.RenderColorFonts ? ColorFontSupport.MicrosoftColrFormat : ColorFontSupport.None, }; // (this.definition.Options.RenderColorFonts) //{ this.textRenderer = new ColorCachingGlyphRenderer(this.Configuration.MemoryAllocator, this.Text.Length, this.Pen, this.Brush != null); // } // else // { // this.textRenderer = new CachingGlyphRenderer(this.Configuration.MemoryAllocator, this.Text.Length, this.Pen, this.Brush != null); // } this.textRenderer.Options = (GraphicsOptions)this.Options; var renderer = new TextRenderer(this.textRenderer); renderer.RenderText(this.Text, style); }
static void Main(string[] args) { var src_path = args[0]; var scr_path_1080p = args[1]; var slug = args[2]; var episode_no = args[3]; var subject = args[4]; System.IO.Directory.CreateDirectory(OUTPUT_DIR); var text = "Episode #" + episode_no + " " + '\u00B7' + " " + subject; // create standard cover var font = SystemFonts.CreateFont("Consolas", 100, FontStyle.Regular); var rendererOptions = new RendererOptions(font); var image = Image.Load(src_path); image.Mutate(ctx => ctx.DrawText(text, font, Rgba32.Black, new PointF(100, 2700))); image.Save(OUTPUT_DIR + "/" + slug + ".png"); // create 1080p cover var font_1080p = SystemFonts.CreateFont("Consolas", 50, FontStyle.Regular); var rendererOptions_1080p = new RendererOptions(font_1080p); var image_1080p = Image.Load(scr_path_1080p); image_1080p.Mutate(ctx => ctx.DrawText(text, font_1080p, Rgba32.Black, new PointF(350, 970))); image_1080p.Save(OUTPUT_DIR + "/" + slug + "_1080p.png"); }
public static RectangleF MeasureText(string text, Font fnt) { RendererOptions rendererOptions = new RendererOptions(fnt); IPathCollection paths = TextBuilder.GenerateGlyphs(text, rendererOptions); return(paths.Bounds); }
private static void ProcessTapes(IReadOnlyList <ColorTape> colorTapes, string name, Font font) { Image <Rgb24> img = new Image <Rgb24>(1920, 1080); RendererOptions ro = new RendererOptions(font); img.Mutate(x => { PointF pos = new PointF(0, 0); foreach (var tape in colorTapes) { string[] lines = tape.Chunk.Split('\n'); for (int i = 0; i < lines.Length; i++) { string text = lines[i]; var textSize = TextMeasurer.Measure(text, ro); x.DrawText(text, font, Cc2rgb(tape.ForeColor), pos); pos.X += textSize.Width; if (i < lines.Length - 1) { pos.X = 0; pos.Y += textSize.Height; } } } x.Contrast(2); }); img.SaveAsPng(RESULT_PATH + name); }
public void VerticalAlignmentTests( VerticalAlignment vertical, HorizontalAlignment horizental, float top, float left) { string text = "hello world\nhello"; Font font = CreateFont(text); int scaleFactor = 72 * font.EmSize; // 72 * emSize means 1 point = 1px var span = new RendererOptions(font, scaleFactor) { HorizontalAlignment = horizental, VerticalAlignment = vertical }; IReadOnlyList <GlyphLayout> glyphsToRender = new TextLayout().GenerateLayout(text.AsSpan(), span); IFontInstance fontInst = span.Font.Instance; float lineHeight = (fontInst.LineHeight * span.Font.Size) / (fontInst.EmSize * 72); lineHeight *= scaleFactor; FontRectangle bound = TextMeasurer.GetBounds(glyphsToRender, new Vector2(span.DpiX, span.DpiY)); Assert.Equal(310, bound.Width, 3); Assert.Equal(40, bound.Height, 3); Assert.Equal(left, bound.Left, 3); Assert.Equal(top, bound.Top, 3); }
/// <summary> /// Measures the placement of each character in a rendered string of text. /// </summary> public static GlyphMetric[] MeasureCharacters(string text, Font font, PointF location) { var rendererOptions = new RendererOptions(font, location); TextMeasurer.TryMeasureCharacterBounds(text, rendererOptions, out var characterBounds); //font.Instance. return(characterBounds); }
private static void VerifyPropertyDefault(RendererOptions options) { Assert.Equal(4, options.TabWidth); Assert.True(options.ApplyKerning); Assert.Equal(-1, options.WrappingWidth); Assert.Equal(HorizontalAlignment.Left, options.HorizontalAlignment); Assert.Equal(VerticalAlignment.Top, options.VerticalAlignment); }
public static string TruncateSubject(string subject, int maxWidth, RendererOptions rendererOptions) { var fontRectangle = TextMeasurer.Measure(subject, rendererOptions); if (fontRectangle.Width > maxWidth) { do { subject = subject[0..^ 1];
private static void DrawText(string text) { var fam = SixLabors.Fonts.SystemFonts.Find("Arial"); var font = new Font(fam, 30); var style = new RendererOptions(font, 72); var glyphs = SixLabors.Shapes.TextBuilder.GenerateGlyphs(text, style); glyphs.SaveImage("Text", text + ".png"); }
/// <summary> /// Generates the shapes corresponding the glyphs described by the font and with the settings withing the FontSpan /// </summary> /// <param name="text">The text to generate glyphs for</param> /// <param name="location">The location</param> /// <param name="style">The style and settings to use while rendering the glyphs</param> /// <returns>The <see cref="IPathCollection"/></returns> public static IPathCollection GenerateGlyphs(string text, PointF location, RendererOptions style) { var glyphBuilder = new GlyphBuilder(location); var renderer = new TextRenderer(glyphBuilder); renderer.RenderText(text, style); return(glyphBuilder.Paths); }
/// <summary> /// Generates the shapes corresponding the glyphs described by the font and with the setting in within the FontSpan along the described path. /// </summary> /// <param name="text">The text to generate glyphs for</param> /// <param name="path">The path to draw the text in relation to</param> /// <param name="style">The style and settings to use while rendering the glyphs</param> /// <returns></returns> public static IPathCollection GenerateGlyphs(string text, IPath path, RendererOptions style) { var glyphBuilder = new PathGlyphBuilder(path); var renderer = new TextRenderer(glyphBuilder); renderer.RenderText(text, style); return(glyphBuilder.Paths); }
public void DrawProgressBar(int percentage, int width, FontSize fontSize = FontSize.Medium, int borderThickness = 2, int cornerRadius = 16, int padding = 4) { // Clamp percentage to the [0;100] range var percents = percentage < 0 ? 0 : (percentage > 100 ? 100 : percentage); var text = $"{percents}%"; var font = fonts[fontSize]; #if IMAGESHARP_V2 var options = new TextOptions(font); #else var options = new RendererOptions(font); #endif // In order for the text to feel correctly vertically centered, we measure a string with characters // that go below (like g or j) and others that go up (like t or f). We say this should be the text height. var textHeight = TextMeasurer.Measure("gf", options).Height; var textWidth = TextMeasurer.Measure(text, options).Width; var textSizeWithPadding = new SizeF(textWidth + padding, textHeight + padding); var rectangleSize = new SizeF( width >= textSizeWithPadding.Width ? width : textSizeWithPadding.Width, textSizeWithPadding.Height); var color = palette[percents]; var borderRectangle = Align(rectangleSize, HorizontalAlignment.Center, VerticalAlignment.Center, 0); if (cornerRadius <= 0) // No rounded corners { var valueWidth = borderRectangle.Width * (percents / 100f); var valueRectangle = new RectangularPolygon( borderRectangle.Left, borderRectangle.Top, valueWidth, borderRectangle.Height); _ = Context.Fill(color.WithAlpha(0.33f), valueRectangle); _ = Context.Draw(Pens.Solid(color, borderThickness), borderRectangle); } else { var invertedValueWidth = borderRectangle.Width * (1f - percents / 100f); var invertedValueRectangle = new RectangularPolygon( borderRectangle.Right - invertedValueWidth, borderRectangle.Top, invertedValueWidth, borderRectangle.Height); var contour = borderRectangle.ToRoundedRectangle(cornerRadius); var clippedValueRectangle = contour.Clip(invertedValueRectangle); _ = Context.Fill(color.WithAlpha(0.33f), clippedValueRectangle); _ = Context.Draw(Pens.Solid(color, borderThickness), contour); } // Draw the text var alignedText = Align(textWidth, textHeight, HorizontalAlignment.Center, VerticalAlignment.Center, 0); _ = Context.DrawText(text, font, Color.White, new PointF(alignedText.X, alignedText.Y)); }
public static void RenderText(RendererOptions font, string text) { GlyphBuilder builder = new GlyphBuilder(); TextRenderer renderer = new TextRenderer(builder); Primitives.SizeF size = TextMeasurer.Measure(text, font); renderer.RenderText(text, font); builder.Paths .SaveImage((int)size.Width + 20, (int)size.Height + 20, font.Font.Name, text + ".png"); }
public override void VisitTextElement(SvgTextElement element) { base.VisitTextElement(element); var fonts = SystemFonts.Collection; FontFamily family = null; foreach (var f in element.Style.FontFamily.Value) { var fontName = f; if (fontName.Equals("sans-serif")) { fontName = DefaultSansSerifFont; } else if (fontName.Equals("serif")) { fontName = DefaultSerifFont; } if (fonts.TryFind(fontName, out family)) { break; } } if (ReferenceEquals(family, null)) //FontFamily overrides == operator and can't handle 'null' value on the left. { family = fonts.Find(DefaultFont); } var fontSize = element.Style.FontSize.Value.Value; var origin = new PointF(element.X?.Value ?? 0, element.Y?.Value ?? 0); var font = family.CreateFont(fontSize); var visitor = new SvgTextSpanTextVisitor(); element.Accept(visitor); var text = visitor.Text; // offset by the ascender to account for fonts render origin of top left var ascender = ((font.Ascender * font.Size) / (font.EmSize * 72)) * 72; var render = new RendererOptions(font, 72, origin - new PointF(0, ascender)) { HorizontalAlignment = element.Style.TextAnchor.Value.AsHorizontalAlignment() }; var glyphs = TextBuilder.GenerateGlyphs(text, render); foreach (var p in glyphs) { this.RenderShapeToCanvas(element, p); } }
public void ContructorTest_FontOnly() { var font = FakeFont.CreateFont("ABC"); var options = new RendererOptions(font); Assert.Equal(72, options.DpiX); Assert.Equal(72, options.DpiY); Assert.Empty(options.FallbackFontFamilies); Assert.Equal(font, options.Font); Assert.Equal(Vector2.Zero, options.Origin); VerifyPropertyDefault(options); }
public static Image <Rgba32> RenderImage(RendererOptions font, string text, Rgba32 backColour, Rgba32 textColour) { var builder = new GlyphBuilder(); var renderer = new TextRenderer(builder); var size = TextMeasurer.Measure(text, font); renderer.RenderText(text, font); builder.Paths .SaveImage((int)size.Width, (int)size.Height, out var ret, backColour, textColour); return(ret); }
public static void RenderText(RendererOptions font, string text) { var builder = new GlyphBuilder(); var renderer = new TextRenderer(builder); FontRectangle size = TextMeasurer.Measure(text, font); font.ColorFontSupport = ColorFontSupport.MicrosoftColrFormat; renderer.RenderText(text, font); builder.Paths .SaveImage(builder.PathColors, (int)size.Width + 20, (int)size.Height + 20, font.Font.Name, text + ".png"); }
public void ContructorTest_FontWithSingleDpi() { var font = FakeFont.CreateFont("ABC"); float dpi = 123; var options = new RendererOptions(font, dpi); Assert.Equal(dpi, options.DpiX); Assert.Equal(dpi, options.DpiY); Assert.Empty(options.FallbackFontFamilies); Assert.Equal(font, options.Font); Assert.Equal(Vector2.Zero, options.Origin); VerifyPropertyDefault(options); }
public void ContructorTest_FontWithOrigin() { Font font = FakeFont.CreateFont("ABC"); var origin = new Vector2(123, 345); var options = new RendererOptions(font, origin); Assert.Equal(72, options.DpiX); Assert.Equal(72, options.DpiY); Assert.Empty(options.FallbackFontFamilies); Assert.Equal(font, options.Font); Assert.Equal(origin, options.Origin); VerifyPropertyDefault(options); }
public MemoryStream SpoilerTxt(string spoil) { var fill = Brushes.Solid <Rgba32>(Rgba32.Black); var brush = Brushes.Solid <Rgba32>(Rgba32.White); RendererOptions op = new RendererOptions(_Spoiltxt); var text = WordWrap(spoil, 120); var tsize = TextMeasurer.MeasureBounds(text, op); int[] size = { Convert.ToInt32(tsize.Width) + 20, Convert.ToInt32(tsize.Height) + 20 }; var img2 = new Image <Rgba32>(size[0], size[1]); img2.DrawText(text, _Spoiltxt, brush, new PointF(0, 0), new TextGraphicsOptions(true)); img2.BackgroundColor(Rgba32.Black); var img1 = new Image <Rgba32>(img2.Width, img2.Height); _Spoil = _fonts.Find("Whitney-Bold").CreateFont(img2.Width * 0.064f); var rect = new Rectangle(0, 0, img2.Width, img2.Height); img1.BackgroundColor(Rgba32.Black, rect); img1.DrawText("Spoiler Warning" + "\r\n" + "(Mouse over to view)", _Spoil, brush, new PointF(0, 0), new TextGraphicsOptions(true) { WrapTextWidth = img1.Width - 20 }); MagickImage f1 = new MagickImage(img1.ToStream()); MagickImage f2 = new MagickImage(img2.ToStream()); MagickImage[] frames = { f1, f2 }; MemoryStream ms = new MemoryStream(); using (MagickImageCollection gif = new MagickImageCollection()) { gif.Add(f1); gif.Add(f2); for (int i = 0; i < gif.Count; i++) { gif[i].AnimationDelay = 50; gif[i].AnimationIterations = 1; } QuantizeSettings settings = new QuantizeSettings { Colors = 256, DitherMethod = DitherMethod.No }; gif.Quantize(settings); gif.Optimize(); gif.Write(ms, MagickFormat.Gif); ms.Position = 0; } return(ms); }
public TextObject(Vector2 position, string text, float scale = 1, RendererOptions options = null) : base("TextObject", true, position, "none", options == null? new RendererOptions(Color.Black) : options) { Text = text; Scale = scale; }
public GameObject(string name, bool ignoreCollisions, Vector2 position, string spriteName, RendererOptions rendererOptions = null) { transform = new Transform(this); renderer = new Renderer(this); int cols = 1; int rows = 1; int index = 0; if (rendererOptions != null) { renderer.BlendColor = rendererOptions.color; cols = rendererOptions.cols; rows = rendererOptions.rows; index = rendererOptions.index; } renderer.SetTexture(spriteName, cols, rows); renderer.ImageIndex = index; this.IgnoreCollisions = ignoreCollisions; transform.Position = position; if (AllObjects == null) AllObjects = new List<GameObject>(); if (NewObjects == null) NewObjects = new List<GameObject>(); NewObjects.Add(this); this.spriteName = spriteName; this.Name = name; }