Exemplo n.º 1
0
        public override void Render(IVertexSource vertexSource, int pathIndexToRender, IColorType colorIn)
        {
            PreRender();

            if (DoEdgeAntiAliasing)
            {
                DrawAAShape(vertexSource, colorIn);
            }
            else
            {
                vertexSource.rewind(pathIndexToRender);

                Affine transform = GetTransform();
                if (!transform.is_identity())
                {
                    vertexSource = new VertexSourceApplyTransform(vertexSource, transform);
                }

                RGBA_Bytes colorBytes = colorIn.GetAsRGBA_Bytes();
                GL.Color4(colorBytes.red, colorBytes.green, colorBytes.blue, colorBytes.alpha);

                renderNowTesselator.Clear();
                VertexSourceToTesselator.SendShapeToTesselator(renderNowTesselator, vertexSource);
            }

            PopOrthoProjection();
        }
Exemplo n.º 2
0
        public void TextWidgetVisibleTest()
        {
            GuiWidget      rectangleWidget = new GuiWidget(100, 50);
            TextEditWidget itemToAdd       = new TextEditWidget("test Item", 10, 10);

            rectangleWidget.AddChild(itemToAdd);
            rectangleWidget.DoubleBuffer = true;
            rectangleWidget.BackBuffer.NewGraphics2D().Clear(RGBA_Bytes.White);
            rectangleWidget.OnDraw(rectangleWidget.BackBuffer.NewGraphics2D());

            ImageBuffer textOnly = new ImageBuffer(75, 20, 32, new BlenderBGRA());

            textOnly.NewGraphics2D().Clear(RGBA_Bytes.White);

#if true
            TypeFacePrinter stringPrinter = new TypeFacePrinter("test Item", 12);
            IVertexSource   offsetText    = new VertexSourceApplyTransform(stringPrinter, Affine.NewTranslation(1, -stringPrinter.LocalBounds.Bottom));
            textOnly.NewGraphics2D().Render(offsetText, RGBA_Bytes.Black);
#else
            textOnly.NewGraphics2D().DrawString("test Item", 1, 1);
#endif

            if (saveImagesForDebug)
            {
                ImageTgaIO.Save(rectangleWidget.BackBuffer, "-rectangleWidget.tga");
                //ImageTgaIO.Save(itemToAdd.Children[0].BackBuffer, "-internalTextWidget.tga");
                ImageTgaIO.Save(textOnly, "-textOnly.tga");
            }

            Assert.IsTrue(rectangleWidget.BackBuffer.FindLeastSquaresMatch(textOnly, 1), "TextWidgets need to be drawing.");
            rectangleWidget.Close();
        }
Exemplo n.º 3
0
        public override void OnDraw(Graphics2D graphics2D)
        {
            byte alpha = (byte)(alphaSlider.Value * 255);

            foreach (var shape in lionShape.Shapes)
            {
                shape.Color = new Color(shape.Color, alpha);
            }

            Affine transform = Affine.NewIdentity();

            transform *= Affine.NewTranslation(-lionShape.Center.X, -lionShape.Center.Y);
            transform *= Affine.NewScaling(lionScale, lionScale);
            transform *= Affine.NewRotation(angle + Math.PI);
            transform *= Affine.NewSkewing(skewX / 1000.0, skewY / 1000.0);
            transform *= Affine.NewTranslation(Width / 2, Height / 2);

            // This code renders the lion:
            foreach (var shape in lionShape.Shapes)
            {
                VertexSourceApplyTransform transformedPathStorage = new VertexSourceApplyTransform(shape.VertexStorage, transform);
                graphics2D.Render(transformedPathStorage, shape.Color);
            }

            graphics2D.DrawString("test", 40, 40, 50);

            base.OnDraw(graphics2D);
        }
Exemplo n.º 4
0
        public override void OnDraw(Graphics2D graphics2D)
        {
            byte alpha = (byte)(alphaSlider.Value * 255);

            for (int i = 0; i < lionShape.NumPaths; i++)
            {
                lionShape.Colors[i].Alpha0To255 = alpha;
            }

            Affine transform = Affine.NewIdentity();

            transform *= Affine.NewTranslation(-lionShape.Center.X, -lionShape.Center.Y);
            transform *= Affine.NewScaling(lionScale, lionScale);
            transform *= Affine.NewRotation(angle + Math.PI);
            transform *= Affine.NewSkewing(skewX / 1000.0, skewY / 1000.0);
            transform *= Affine.NewTranslation(Width / 2, Height / 2);

            // This code renders the lion:
            VertexSourceApplyTransform transformedPathStorage = new VertexSourceApplyTransform(lionShape.Path, transform);

            graphics2D.Render(transformedPathStorage, lionShape.Colors, lionShape.PathIndex, lionShape.NumPaths);

            graphics2D.DrawString("test", 40, 40, 50);

            base.OnDraw(graphics2D);
        }
Exemplo n.º 5
0
        public override void Render(Graphics2D graphics2D, GCodeRenderInfo renderInfo)
        {
            if ((renderInfo.CurrentRenderType & RenderType.Moves) == RenderType.Moves)
            {
                double     movementLineWidth = 0.35 * renderInfo.LayerScale;
                RGBA_Bytes movementColor     = new RGBA_Bytes(10, 190, 15);

                PathStorage pathStorage = new PathStorage();
                VertexSourceApplyTransform transformedPathStorage = new VertexSourceApplyTransform(pathStorage, renderInfo.Transform);
                Stroke stroke = new Stroke(transformedPathStorage, movementLineWidth);

                stroke.line_cap(LineCap.Round);
                stroke.line_join(LineJoin.Round);

                Vector3Float start = this.GetStart(renderInfo);
                Vector3Float end   = this.GetEnd(renderInfo);

                pathStorage.Add(start.x, start.y, ShapePath.FlagsAndCommand.CommandMoveTo);
                if (end.x != start.x || end.y != start.y)
                {
                    pathStorage.Add(end.x, end.y, ShapePath.FlagsAndCommand.CommandLineTo);
                }
                else
                {
                    pathStorage.Add(end.x + .01, end.y, ShapePath.FlagsAndCommand.CommandLineTo);
                }
                graphics2D.Render(stroke, 0, movementColor);
            }
        }
Exemplo n.º 6
0
        public static void DrawMeasureLine(this Graphics2D graphics2D, Vector2 lineStart, Vector2 lineEnd, LineArrows arrows, ThemeConfig theme)
        {
            graphics2D.Line(lineStart, lineEnd, theme.TextColor);

            Vector2 direction = lineEnd - lineStart;

            if (direction.LengthSquared > 0 &&
                (arrows.HasFlag(LineArrows.Start) || arrows.HasFlag(LineArrows.End)))
            {
                var arrow = new VertexStorage();
                arrow.MoveTo(-3, -5);
                arrow.LineTo(0, 0);
                arrow.LineTo(3, -5);

                if (arrows.HasFlag(LineArrows.End))
                {
                    double        rotation        = Math.Atan2(direction.Y, direction.X);
                    IVertexSource correctRotation = new VertexSourceApplyTransform(arrow, Affine.NewRotation(rotation - MathHelper.Tau / 4));
                    IVertexSource inPosition      = new VertexSourceApplyTransform(correctRotation, Affine.NewTranslation(lineEnd));
                    graphics2D.Render(inPosition, theme.TextColor);
                }

                if (arrows.HasFlag(LineArrows.Start))
                {
                    double        rotation        = Math.Atan2(direction.Y, direction.X) + MathHelper.Tau / 2;
                    IVertexSource correctRotation = new VertexSourceApplyTransform(arrow, Affine.NewRotation(rotation - MathHelper.Tau / 4));
                    IVertexSource inPosition      = new VertexSourceApplyTransform(correctRotation, Affine.NewTranslation(lineStart));
                    graphics2D.Render(inPosition, theme.TextColor);
                }
            }
        }
Exemplo n.º 7
0
    void Update()
    {
        // update animation counter
        x += Time.deltaTime;
        while (x > 1.0f)
        {
            x -= 1.0f;
        }

        // clear background with white
        Graphics2D g = buffer.NewGraphics2D();

        g.Clear(RGBA_Bytes.White);

        // draw some lines
        float w = buffer.Width * x;

        for (int i = 0; i < 10; i++)
        {
            g.Line(x1: 0, y1: buffer.Height * i / 10,
                   x2: w - w * i / 10, y2: 0,
                   color: RGBA_Bytes.Black, strokeWidth: 3);
        }

        // draw some text
        TypeFacePrinter textPrinter    = new TypeFacePrinter("Hello World!", 30, justification: Justification.Center);
        IVertexSource   translatedText = new VertexSourceApplyTransform(textPrinter, Affine.NewTranslation(buffer.Width / 2, 5));

        g.Render(translatedText, RGBA_Bytes.Blue);

        // update texture data
        byte[] pixels = buffer.GetBuffer();
        texture.LoadRawTextureData(pixels);
        texture.Apply();
    }
Exemplo n.º 8
0
        private void _InternalRender(IVertexSource vertexSource, RGBA_Bytes color)
        {
            if (_clipBuffer != null)
            {
                // DEBUG_saveImageBuffer(_clipBuffer);
                // DEBUG_saveImageBuffer(this.imb);

                IAlphaMask         alphaMask              = new AlphaMaskByteClipped(_clipBuffer, 1, 0);
                AlphaMaskAdaptor   imageAlphaMaskAdaptor  = new AlphaMaskAdaptor(aggGc.DestImage, alphaMask);
                ImageClippingProxy alphaMaskClippingProxy = new ImageClippingProxy(imageAlphaMaskAdaptor);

                var scanlineRenderer = new ScanlineRenderer();
                var rasterizer       = new ScanlineRasterizer();
                var scanlineCache    = new ScanlineCachePacked8();


                VertexSourceApplyTransform trans = new VertexSourceApplyTransform(vertexSource, aggGc.GetTransform());
                rasterizer.add_path(trans);

                scanlineRenderer.render_scanlines_aa_solid(alphaMaskClippingProxy, rasterizer, scanlineCache, color);
                aggGc.DestImage.MarkImageChanged();
            }
            else
            {
                aggGc.Render(vertexSource, color);
            }
        }
Exemplo n.º 9
0
            public DockingTabButton(string tabTitle, ThemeConfig theme)
            {
                this.grayBorder       = theme.GetBorderColor(theme.IsDarkTheme ? 45 : 55);
                this.theme            = theme;
                this.HAnchor          = HAnchor.Fit;
                this.VAnchor          = VAnchor.Fit | VAnchor.Center;
                this.AlignToRightEdge = true;
                this.MakeScrollable   = false;
                this.Border           = new BorderDouble(right: 6);
                this.BorderColor      = grayBorder;
                this.Margin           = new BorderDouble(2, 8, 0, 0);
                this.HoverColor       = Color.Transparent;

                var printer      = new TypeFacePrinter(tabTitle, theme.DefaultFontSize * GuiWidget.DeviceScale);
                var rotatedLabel = new VertexSourceApplyTransform(
                    printer,
                    Affine.NewRotation(MathHelper.DegreesToRadians(-90)));

                var textBounds = rotatedLabel.GetBounds();
                var bounds     = new RectangleDouble(printer.TypeFaceStyle.DescentInPixels, textBounds.Bottom, printer.TypeFaceStyle.AscentInPixels, textBounds.Top);

                rotatedLabel.Transform = ((Affine)rotatedLabel.Transform)
                                         * Affine.NewTranslation(new Vector2(-printer.TypeFaceStyle.DescentInPixels, -bounds.Bottom));

                this.AddChild(buttonView = new GuiWidget(bounds.Width, bounds.Height)
                {
                    DoubleBuffer = true,
                    Margin       = new BorderDouble(3, 1),
                    Selectable   = false
                });
                buttonView.AfterDraw += (s, e) =>
                {
                    e.Graphics2D.Render(rotatedLabel, theme.TextColor);
                };
            }
Exemplo n.º 10
0
        private void MeshViewerToDrawWith_Draw(GuiWidget drawingWidget, DrawEventArgs drawEvent)
        {
            if (Visible)
            {
                if (drawEvent != null)
                {
                    // draw the line that is on the ground
                    double yGround = (int)(startLineGroundPos.y + .5) + .5;
                    drawEvent.graphics2D.Line(startLineGroundPos.x, yGround, startLineGroundPos.x + HorizontalLineLength - 5, yGround, RGBA_Bytes.Black);
                    // and the line that is at the base of the selection
                    double ySelection = (int)(startLineSelectionPos.y + .5) + .5;
                    drawEvent.graphics2D.Line(startLineSelectionPos.x, ySelection, startLineSelectionPos.x + HorizontalLineLength - 5, ySelection, RGBA_Bytes.Black);

                    // draw the verticle line that shows the measurment
                    Vector2 pointerBottom = new Vector2(startLineGroundPos.x + HorizontalLineLength / 2, yGround);
                    Vector2 pointerTop    = new Vector2(startLineSelectionPos.x + HorizontalLineLength / 2, ySelection);
                    drawEvent.graphics2D.Line(pointerBottom, pointerTop, RGBA_Bytes.Black);

                    Vector2 direction = pointerTop - pointerBottom;
                    if (direction.LengthSquared > 0)
                    {
                        PathStorage arrow = new PathStorage();
                        arrow.MoveTo(-3, -5);
                        arrow.LineTo(0, 0);
                        arrow.LineTo(3, -5);
                        double        rotation        = Math.Atan2(direction.y, direction.x);
                        IVertexSource correctRotation = new VertexSourceApplyTransform(arrow, Affine.NewRotation(rotation - MathHelper.Tau / 4));
                        IVertexSource inPosition      = new VertexSourceApplyTransform(correctRotation, Affine.NewTranslation(pointerTop));
                        drawEvent.graphics2D.Render(inPosition, RGBA_Bytes.Black);
                    }
                }
            }
        }
Exemplo n.º 11
0
        private void DrawSnappingMarks(DrawGlContentEventArgs drawEventArgs, double mouseAngle, double alphaValue, Matrix4X4 rotationCenterTransform, double distanceFromCenter, int numSnapPoints, int markToSnapTo)
        {
            var graphics2DOpenGL = new Graphics2DOpenGL(GuiWidget.DeviceScale);

            double snappingRadians = MathHelper.Tau / numSnapPoints;

            for (int i = 0; i < numSnapPoints; i++)
            {
                double startAngle = i * snappingRadians + mouseAngle;

                var snapShape = new VertexStorage();
                var scale     = GuiWidget.DeviceScale;
                snapShape.MoveTo(-10 * scale, 0);
                snapShape.LineTo(5 * scale, 7 * scale);
                snapShape.LineTo(5 * scale, -7 * scale);
                snapShape.ClosePolygon();

                var transformed = new VertexSourceApplyTransform(snapShape, Affine.NewTranslation(distanceFromCenter, 0) * Affine.NewRotation(startAngle));
                // new Ellipse(startPosition.x, startPosition.y, dotRadius, dotRadius);

                var color = theme.TextColor;
                if (i == markToSnapTo)
                {
                    color = theme.PrimaryAccentColor;
                }

                graphics2DOpenGL.RenderTransformedPath(rotationCenterTransform, transformed, new Color(color, (int)(254 * alphaValue)), drawEventArgs.ZBuffered);
            }
        }
Exemplo n.º 12
0
        public void GenerateBase(Polygons polygonShape, double bottomWithoutBase)
        {
            if (polygonShape != null &&
                polygonShape.Select(p => p.Count).Sum() > 3)
            {
                Polygons polysToOffset = new Polygons();

                switch (BaseType)
                {
                case BaseTypes.Rectangle:
                    polysToOffset.Add(GetBoundingPolygon(polygonShape));
                    break;

                case BaseTypes.Circle:
                    polysToOffset.Add(GetBoundingCircle(polygonShape));
                    break;

                case BaseTypes.Outline:
                    PolyTree polyTreeForBase = GetPolyTree(polygonShape);
                    foreach (PolyNode polyToOffset in polyTreeForBase.Childs)
                    {
                        polysToOffset.Add(polyToOffset.Contour);
                    }
                    break;
                }

                if (polysToOffset.Count > 0)
                {
                    Polygons basePolygons;

                    if (BaseType == BaseTypes.Outline &&
                        InfillAmount > 0)
                    {
                        basePolygons = Offset(polysToOffset, (BaseSize + InfillAmount) * scalingForClipper);
                        basePolygons = Offset(basePolygons, -InfillAmount * scalingForClipper);
                    }
                    else
                    {
                        basePolygons = Offset(polysToOffset, BaseSize * scalingForClipper);
                    }

                    basePolygons = ClipperLib.Clipper.CleanPolygons(basePolygons, 10);

                    VertexStorage rawVectorShape = basePolygons.PolygonToPathStorage();
                    var           vectorShape    = new VertexSourceApplyTransform(rawVectorShape, Affine.NewScaling(1.0 / scalingForClipper));

                    var baseObject = new Object3D()
                    {
                        Mesh = VertexSourceToMesh.Extrude(vectorShape, zHeight: ExtrusionHeight)
                    };
                    Children.Add(baseObject);
                    baseObject.Mesh.Translate(new Vector3(0, 0, -ExtrusionHeight + bottomWithoutBase));
                }
                else
                {
                    // clear the mesh
                    Mesh = null;
                }
            }
        }
Exemplo n.º 13
0
        public override void Render(IVertexSource vertexSource, int pathIndexToRender, IColorType colorIn)
        {
            PushOrthoProjection();

            GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);
            GL.Enable(EnableCap.Blend);

            vertexSource.rewind(pathIndexToRender);

            RGBA_Bytes colorBytes = colorIn.GetAsRGBA_Bytes();

            GL.Color4(colorBytes.red, colorBytes.green, colorBytes.blue, colorBytes.alpha);

            Affine transform = GetTransform();

            if (!transform.is_identity())
            {
                vertexSource = new VertexSourceApplyTransform(vertexSource, transform);
            }

            if (DoEdgeAntiAliasing)
            {
                DrawAAShape(vertexSource);
            }
            else
            {
                renderNowTesselator.Clear();
                Graphics2DOpenGL.SendShapeToTesselator(renderNowTesselator, vertexSource);
            }

            PopOrthoProjection();
        }
Exemplo n.º 14
0
        public override void Render(Graphics2D graphics2D, GCodeRenderInfo renderInfo)
        {
            if ((renderInfo.CurrentRenderType & RenderType.Extrusions) == RenderType.Extrusions)
            {
                double extrusionLineWidths = GetRadius(renderInfo.CurrentRenderType) * 2 * renderInfo.LayerScale;

                RGBA_Bytes extrusionColor = RGBA_Bytes.Black;
                if (extruderIndex > 0)
                {
                    extrusionColor = MeshViewerWidget.GetMaterialColor(extruderIndex + 1);
                }
                if ((renderInfo.CurrentRenderType & RenderType.SpeedColors) == RenderType.SpeedColors)
                {
                    extrusionColor = color;
                }

                PathStorage pathStorage = new PathStorage();
                VertexSourceApplyTransform transformedPathStorage = new VertexSourceApplyTransform(pathStorage, renderInfo.Transform);
                Stroke stroke = new Stroke(transformedPathStorage, extrusionLineWidths);

                stroke.line_cap(LineCap.Round);
                stroke.line_join(LineJoin.Round);

                Vector3Float start = this.GetStart(renderInfo);
                Vector3Float end   = this.GetEnd(renderInfo);

                pathStorage.Add(start.x, start.y, ShapePath.FlagsAndCommand.CommandMoveTo);
                pathStorage.Add(end.x, end.y, ShapePath.FlagsAndCommand.CommandLineTo);

                graphics2D.Render(stroke, 0, extrusionColor);
            }
        }
Exemplo n.º 15
0
        public static void DrawMeasureLine(Graphics2D graphics2D, Vector2 lineStart, Vector2 lineEnd, RGBA_Bytes color, LineArrows arrows)
        {
            graphics2D.Line(lineStart, lineEnd, RGBA_Bytes.Black);

            Vector2 direction = lineEnd - lineStart;

            if (direction.LengthSquared > 0 &&
                (arrows.HasFlag(LineArrows.Start) || arrows.HasFlag(LineArrows.End)))
            {
                PathStorage arrow = new PathStorage();
                arrow.MoveTo(-3, -5);
                arrow.LineTo(0, 0);
                arrow.LineTo(3, -5);
                if (arrows.HasFlag(LineArrows.End))
                {
                    double        rotation        = Math.Atan2(direction.y, direction.x);
                    IVertexSource correctRotation = new VertexSourceApplyTransform(arrow, Affine.NewRotation(rotation - MathHelper.Tau / 4));
                    IVertexSource inPosition      = new VertexSourceApplyTransform(correctRotation, Affine.NewTranslation(lineEnd));
                    graphics2D.Render(inPosition, RGBA_Bytes.Black);
                }
                if (arrows.HasFlag(LineArrows.Start))
                {
                    double        rotation        = Math.Atan2(direction.y, direction.x) + MathHelper.Tau / 2;
                    IVertexSource correctRotation = new VertexSourceApplyTransform(arrow, Affine.NewRotation(rotation - MathHelper.Tau / 4));
                    IVertexSource inPosition      = new VertexSourceApplyTransform(correctRotation, Affine.NewTranslation(lineStart));
                    graphics2D.Render(inPosition, RGBA_Bytes.Black);
                }
            }
        }
Exemplo n.º 16
0
        private static Affine GetCenteringTransformVisualCenter(IVertexSource vertexSource, double goalRadius)
        {
            var outsidePolygons = new List <List <IntPoint> >();
            // remove all holes from the polygons so we only center the major outlines
            var polygons = vertexSource.CreatePolygons();

            foreach (var polygon in polygons)
            {
                if (polygon.GetWindingDirection() == 1)
                {
                    outsidePolygons.Add(polygon);
                }
            }

            IVertexSource outsideSource = outsidePolygons.CreateVertexStorage();

            Vector2 center = outsideSource.GetWeightedCenter();

            outsideSource = new VertexSourceApplyTransform(outsideSource, Affine.NewTranslation(-center));

            double radius = MaxXyDistFromCenter(outsideSource);

            double scale    = goalRadius / radius;
            var    scalling = Affine.NewScaling(scale);

            var centering = Affine.NewTranslation(-center);

            return(centering * scalling);
        }
Exemplo n.º 17
0
        public IVertexSource GetGlyphForCharacter(char character)
        {
            // scale it to the correct size.
            IVertexSource sourceGlyph = TypeFace.GetGlyphForCharacter(character);

            if (sourceGlyph != null)
            {
                if (DoUnderline)
                {
                    sourceGlyph = new GlyphWithUnderline(sourceGlyph, TypeFace.GetAdvanceForCharacter(character), TypeFace.Underline_position, TypeFace.Underline_thickness);
                }
                Affine glyphTransform = Affine.NewIdentity();
                glyphTransform *= Affine.NewScaling(currentEmScaling);
                IVertexSource characterGlyph = new VertexSourceApplyTransform(sourceGlyph, glyphTransform);

                if (FlatenCurves)
                {
                    characterGlyph = new FlattenCurves(characterGlyph);
                }

                return(characterGlyph);
            }

            return(null);
        }
Exemplo n.º 18
0
        private void DrawSnappingMarks(DrawGlContentEventArgs drawEventArgs, double mouseAngle, double alphaValue, Matrix4X4 rotationCenterTransform, double distanceFromCenter, double dotRadius, int numSnapPoints, int markToSnapTo)
        {
            var graphics2DOpenGL = new Graphics2DOpenGL();

            double snappingRadians = MathHelper.Tau / numSnapPoints;
            var    clippingFrustum = GLHelper.GetClippingFrustum(InteractionContext.World);

            for (int i = 0; i < numSnapPoints; i++)
            {
                double startAngle = i * snappingRadians + mouseAngle;

                VertexStorage snapShape = new VertexStorage();
                snapShape.MoveTo(-10, 0);
                snapShape.LineTo(5, 7);
                snapShape.LineTo(5, -7);
                snapShape.ClosePolygon();

                var transformed = new VertexSourceApplyTransform(snapShape, Affine.NewTranslation(distanceFromCenter, 0) * Affine.NewRotation(startAngle));
                // new Ellipse(startPosition.x, startPosition.y, dotRadius, dotRadius);

                var color = Color.Black;
                if (i == markToSnapTo)
                {
                    color = Color.Red;
                }

                graphics2DOpenGL.RenderTransformedPath(rotationCenterTransform, transformed, new Color(color, (int)(254 * alphaValue)), drawEventArgs.ZBuffered);
            }
        }
Exemplo n.º 19
0
        public override void OnDraw(Graphics2D graphics2D)
        {
            ImageBuffer widgetsSubImage = ImageBuffer.NewSubImageReference(graphics2D.DestImage, graphics2D.GetClippingRect());

            int width  = (int)widgetsSubImage.Width;
            int height = (int)widgetsSubImage.Height;

            ImageBuffer clippedSubImage = new ImageBuffer();

            clippedSubImage.Attach(widgetsSubImage, new BlenderBGRA());
            ImageClippingProxy imageClippingProxy = new ImageClippingProxy(clippedSubImage);

            imageClippingProxy.clear(new ColorF(1, 1, 1));

            Affine transform = Affine.NewIdentity();

            transform *= Affine.NewTranslation(-lionShape.Center.X, -lionShape.Center.Y);
            transform *= Affine.NewScaling(lionScale, lionScale);
            transform *= Affine.NewRotation(angle + Math.PI);
            transform *= Affine.NewSkewing(skewX / 1000.0, skewY / 1000.0);
            transform *= Affine.NewTranslation(width / 2, height / 2);

            if (renderAsScanlineCheckBox.Checked)
            {
                rasterizer.SetVectorClipBox(0, 0, width, height);

                foreach (var shape in lionShape.Shapes)
                {
                    Stroke stroke = new Stroke(shape.VertexStorage);
                    stroke.Width    = widthSlider.Value;
                    stroke.LineJoin = LineJoin.Round;
                    VertexSourceApplyTransform trans            = new VertexSourceApplyTransform(stroke, transform);
                    ScanlineRenderer           scanlineRenderer = new ScanlineRenderer();
                    rasterizer.add_path(trans);
                    scanlineRenderer.RenderSolid(imageClippingProxy, rasterizer, scanlineCache, shape.Color);
                }
            }
            else
            {
                double w = widthSlider.Value * transform.GetScale();

                LineProfileAnitAlias  lineProfile     = new LineProfileAnitAlias(w, new gamma_none());
                OutlineRenderer       outlineRenderer = new OutlineRenderer(imageClippingProxy, lineProfile);
                rasterizer_outline_aa rasterizer      = new rasterizer_outline_aa(outlineRenderer);

                rasterizer.line_join(renderAccurateJoinsCheckBox.Checked ?
                                     rasterizer_outline_aa.outline_aa_join_e.outline_miter_accurate_join
                                        : rasterizer_outline_aa.outline_aa_join_e.outline_round_join);
                rasterizer.round_cap(true);

                foreach (var shape in lionShape.Shapes)
                {
                    VertexSourceApplyTransform trans = new VertexSourceApplyTransform(shape.VertexStorage, transform);
                    rasterizer.RenderAllPaths(trans, new Color[] { shape.Color }, new int[] { 0 }, 1);
                }
            }

            base.OnDraw(graphics2D);
        }
Exemplo n.º 20
0
        public override void Render(Graphics2D graphics2D, GCodeRenderInfo renderInfo)
        {
            if (renderInfo.CurrentRenderType.HasFlag(RenderType.Extrusions))
            {
                double extrusionLineWidths = GetExtrusionWidth(renderInfo.CurrentRenderType) * 2 * renderInfo.LayerScale;

                Color extrusionColor = Color.Black;

                if (renderInfo.CurrentRenderType.HasFlag(RenderType.SpeedColors))
                {
                    extrusionColor = color;
                }
                else if (renderInfo.CurrentRenderType.HasFlag(RenderType.GrayColors))
                {
                    extrusionColor = Color.Gray;
                }
                else
                {
                    extrusionColor = renderInfo.GetMaterialColor(extruderIndex);
                }

                if (renderInfo.CurrentRenderType.HasFlag(RenderType.TransparentExtrusion))
                {
                    extrusionColor = new Color(extrusionColor, 200);
                }

                // render the part using opengl
                Graphics2DOpenGL graphics2DGl = graphics2D as Graphics2DOpenGL;
                if (graphics2DGl != null)
                {
                    Vector3Float startF = this.GetStart(renderInfo);
                    Vector3Float endF   = this.GetEnd(renderInfo);
                    Vector2      start  = new Vector2(startF.x, startF.y);
                    renderInfo.Transform.transform(ref start);

                    Vector2 end = new Vector2(endF.x, endF.y);
                    renderInfo.Transform.transform(ref end);

                    graphics2DGl.DrawAALineRounded(start, end, extrusionLineWidths / 2, extrusionColor);
                }
                else
                {
                    VertexStorage pathStorage = new VertexStorage();
                    VertexSourceApplyTransform transformedPathStorage = new VertexSourceApplyTransform(pathStorage, renderInfo.Transform);
                    Stroke stroke = new Stroke(transformedPathStorage, extrusionLineWidths / 2);

                    stroke.line_cap(LineCap.Round);
                    stroke.line_join(LineJoin.Round);

                    Vector3Float start = this.GetStart(renderInfo);
                    Vector3Float end   = this.GetEnd(renderInfo);

                    pathStorage.Add(start.x, start.y, ShapePath.FlagsAndCommand.MoveTo);
                    pathStorage.Add(end.x, end.y, ShapePath.FlagsAndCommand.LineTo);

                    graphics2D.Render(stroke, 0, extrusionColor);
                }
            }
        }
Exemplo n.º 21
0
        public override Task Rebuild()
        {
            this.DebugDepth("Rebuild");

            var rebuildLock = RebuildLock();

            return(Task.Run(() =>
            {
                using (new CenterAndHeightMaintainer(this))
                {
                    bool valuesChanged = false;
                    var height = Height.ClampIfNotCalculated(this, .01, 1000000, ref valuesChanged);
                    var nameToWrite = NameToWrite.Value(this);
                    if (string.IsNullOrWhiteSpace(nameToWrite))
                    {
                        Mesh = PlatonicSolids.CreateCube(20, 10, height);
                    }
                    else
                    {
                        Mesh = null;
                        this.Children.Modify(list =>
                        {
                            list.Clear();

                            var offest = 0.0;
                            double pointsToMm = 0.352778;

                            foreach (var letter in nameToWrite.ToCharArray())
                            {
                                var style = new StyledTypeFace(ApplicationController.GetTypeFace(this.Font), PointSize.Value(this));
                                var letterPrinter = new TypeFacePrinter(letter.ToString(), style)
                                {
                                    ResolutionScale = 10
                                };
                                var scaledLetterPrinter = new VertexSourceApplyTransform(letterPrinter, Affine.NewScaling(pointsToMm));

                                list.Add(new Object3D()
                                {
                                    Mesh = VertexSourceToMesh.Extrude(scaledLetterPrinter, this.Height.Value(this)),
                                    Matrix = Matrix4X4.CreateTranslation(offest, 0, 0),
                                    Name = letter.ToString()
                                });

                                offest += letterPrinter.GetSize(letter.ToString()).X *pointsToMm;
                            }
                        });
                    }
                }

                UiThread.RunOnIdle(() =>
                {
                    rebuildLock.Dispose();
                    Invalidate(InvalidateType.DisplayValues);
                    Parent?.Invalidate(new InvalidateArgs(this, InvalidateType.Children));
                });
            }));
        }
        private Matrix4X4 GetCenteringTransformVisualCenter(IEnumerable <IObject3D> items, double goalRadius)
        {
            IEnumerable <(Vector2, Vector2, Vector2)> GetPolygons()
            {
                foreach (var item in items)
                {
                    foreach (var meshItem in item.VisibleMeshes())
                    {
                        var worldMatrix = meshItem.WorldMatrix(this);
                        var faces       = meshItem.Mesh.Faces;
                        var vertices    = meshItem.Mesh.Vertices;
                        foreach (var face in faces)
                        {
                            if (face.normal.TransformNormal(worldMatrix).Z > 0)
                            {
                                yield return(
                                    new Vector2(vertices[face.v0].Transform(worldMatrix)),
                                    new Vector2(vertices[face.v1].Transform(worldMatrix)),
                                    new Vector2(vertices[face.v2].Transform(worldMatrix))
                                    );
                            }
                        }
                    }
                }
            }

            var outsidePolygons = new List <List <IntPoint> >();

            var projection = new Polygons();

            // remove all holes from the polygons so we only center the major outlines
            var polygons = OrthographicZProjection.GetClipperPolygons(GetPolygons());

            foreach (var polygon in polygons)
            {
                if (polygon.GetWindingDirection() == 1)
                {
                    outsidePolygons.Add(polygon);
                }
            }

            IVertexSource outsideSource = outsidePolygons.CreateVertexStorage();

            Vector2 center = outsideSource.GetWeightedCenter();

            outsideSource = new VertexSourceApplyTransform(outsideSource, Affine.NewTranslation(-center));

            double radius = MaxXyDistFromCenter(outsideSource);

            double scale    = goalRadius / radius;
            var    scalling = Matrix4X4.CreateScale(scale, scale, 1);

            var centering = Matrix4X4.CreateTranslation(-center.X, -center.Y, 0);

            return(centering * scalling);
        }
Exemplo n.º 23
0
        protected override void DoDraw(Graphics2D destRenderer)
        {
            Affine Final = Affine.NewIdentity();

            Final *= Affine.NewRotation(m_Rotation);
            Final *= Affine.NewTranslation(m_Position.X, m_Position.Y);
            var TransformedShip = new VertexSourceApplyTransform(ellipseShape, Final);

            destRenderer.Render(TransformedShip, new Color(.9, .4, .2, 1));
        }
Exemplo n.º 24
0
        public override Task Rebuild()
        {
            this.DebugDepth("Rebuild");

            var rebuildLock = RebuildLock();

            return(ApplicationController.Instance.Tasks.Execute(
                       "Generating Text Meshes".Localize(),
                       null,
                       (reporter, cancellationToken) =>
            {
                using (new CenterAndHeightMaintainer(this))
                {
                    if (string.IsNullOrWhiteSpace(NameToWrite))
                    {
                        Mesh = PlatonicSolids.CreateCube(20, 10, Height);
                    }
                    else
                    {
                        Mesh = null;
                        this.Children.Modify(list =>
                        {
                            list.Clear();

                            var offest = 0.0;
                            double pointsToMm = 0.352778;

                            foreach (var letter in this.NameToWrite.ToCharArray())
                            {
                                var letterPrinter = new TypeFacePrinter(letter.ToString(), new StyledTypeFace(ApplicationController.GetTypeFace(this.Font), this.PointSize))
                                {
                                    ResolutionScale = 10
                                };
                                var scaledLetterPrinter = new VertexSourceApplyTransform(letterPrinter, Affine.NewScaling(pointsToMm));

                                list.Add(new Object3D()
                                {
                                    Mesh = VertexSourceToMesh.Extrude(scaledLetterPrinter, this.Height),
                                    Matrix = Matrix4X4.CreateTranslation(offest, 0, 0),
                                    Name = letter.ToString()
                                });

                                offest += letterPrinter.GetSize(letter.ToString()).X *pointsToMm;
                            }
                        });
                    }
                }

                rebuildLock.Dispose();
                Parent?.Invalidate(new InvalidateArgs(this, InvalidateType.Children));
                return Task.CompletedTask;
            }));
        }
Exemplo n.º 25
0
        public override void Render(Graphics2D graphics2D, GCodeRenderInfo renderInfo, bool highlightFeature = false)
        {
            if ((renderInfo.CurrentRenderType & RenderType.Moves) == RenderType.Moves)
            {
                double movementLineWidth = 0.2 * renderInfo.LayerScale;
                Color  movementColor     = (highlightFeature) ? RenderFeatureBase.HighlightColor : new Color(10, 190, 15);

                if (graphics2D is Graphics2DOpenGL graphics2DGl)
                {
                    // render using opengl
                    var startPoint = new Vector2(start.X, start.Y);
                    renderInfo.Transform.transform(ref startPoint);

                    var endPoint = new Vector2(end.X, end.Y);
                    renderInfo.Transform.transform(ref endPoint);

                    if (retractionTravel)
                    {
                        movementColor = GCodeRenderer.RetractionColor;
                    }

                    if (renderInfo.CurrentRenderType.HasFlag(RenderType.TransparentExtrusion))
                    {
                        movementColor = movementColor.WithAlpha(120);
                    }

                    graphics2DGl.DrawAALineRounded(startPoint, endPoint, movementLineWidth, movementColor);
                }
                else
                {
                    // render using agg
                    var pathStorage            = new VertexStorage();
                    var transformedPathStorage = new VertexSourceApplyTransform(pathStorage, renderInfo.Transform);
                    var stroke = new Stroke(transformedPathStorage, movementLineWidth)
                    {
                        LineCap  = LineCap.Round,
                        LineJoin = LineJoin.Round
                    };

                    pathStorage.Add(start.X, start.Y, ShapePath.FlagsAndCommand.MoveTo);
                    if (end.X != start.X || end.Y != start.Y)
                    {
                        pathStorage.Add(end.X, end.Y, ShapePath.FlagsAndCommand.LineTo);
                    }
                    else
                    {
                        pathStorage.Add(end.X + .01, end.Y, ShapePath.FlagsAndCommand.LineTo);
                    }

                    graphics2D.Render(stroke, movementColor);
                }
            }
        }
        public override void Render(Graphics2D graphics2D, GCodeRenderInfo renderInfo)
        {
            if ((renderInfo.CurrentRenderType & RenderType.Moves) == RenderType.Moves)
            {
                double movementLineWidth = 0.35 * renderInfo.LayerScale;
                Color  movementColor     = new Color(10, 190, 15);

                // render the part using opengl
                Graphics2DOpenGL graphics2DGl = graphics2D as Graphics2DOpenGL;
                if (graphics2DGl != null)
                {
                    Vector3Float startF = this.GetStart(renderInfo);
                    Vector3Float endF   = this.GetEnd(renderInfo);
                    Vector2      start  = new Vector2(startF.x, startF.y);
                    renderInfo.Transform.transform(ref start);

                    Vector2 end = new Vector2(endF.x, endF.y);
                    renderInfo.Transform.transform(ref end);

                    if (renderInfo.CurrentRenderType.HasFlag(RenderType.TransparentExtrusion))
                    {
                        movementColor = new Color(movementColor, 200);
                    }

                    graphics2DGl.DrawAALineRounded(start, end, movementLineWidth, movementColor);
                }
                else
                {
                    VertexStorage pathStorage = new VertexStorage();
                    VertexSourceApplyTransform transformedPathStorage = new VertexSourceApplyTransform(pathStorage, renderInfo.Transform);
                    Stroke stroke = new Stroke(transformedPathStorage, movementLineWidth);

                    stroke.line_cap(LineCap.Round);
                    stroke.line_join(LineJoin.Round);

                    Vector3Float start = this.GetStart(renderInfo);
                    Vector3Float end   = this.GetEnd(renderInfo);

                    pathStorage.Add(start.x, start.y, ShapePath.FlagsAndCommand.MoveTo);
                    if (end.x != start.x || end.y != start.y)
                    {
                        pathStorage.Add(end.x, end.y, ShapePath.FlagsAndCommand.LineTo);
                    }
                    else
                    {
                        pathStorage.Add(end.x + .01, end.y, ShapePath.FlagsAndCommand.LineTo);
                    }

                    graphics2D.Render(stroke, movementColor);
                }
            }
        }
Exemplo n.º 27
0
        private void DrawImage(ISpanGenerator spanImageFilter, Affine destRectTransform)
        {
            if (destImageByte.OriginOffset.X != 0 || destImageByte.OriginOffset.Y != 0)
            {
                destRectTransform *= Affine.NewTranslation(-destImageByte.OriginOffset.X, -destImageByte.OriginOffset.Y);
            }

            var transformedRect = new VertexSourceApplyTransform(drawImageRectPath, destRectTransform);

            Rasterizer.add_path(transformedRect);
            {
                var destImageWithClipping = new ImageClippingProxy(destImageByte);
                scanlineRenderer.GenerateAndRender(Rasterizer, drawImageScanlineCache, destImageWithClipping, destImageSpanAllocatorCache, spanImageFilter);
            }
        }
Exemplo n.º 28
0
        public void DrawString(string text, Font font, Brush brush, float x, float y)
        {
            // TODO: handle different brushes
            // TODO: emulate GDI "bordering" of text?
            SolidBrush colorBrush = brush as SolidBrush;
            var        s1         = new TypeFacePrinter(text, font.SizeInPoints, new MatterHackers.VectorMath.Vector2(0, 0), Justification.Left, Baseline.BoundsTop);
            var        s2         = new VertexSourceApplyTransform(s1, Affine.NewScaling(1, -1));

            if (x != 0.0f || y != 0.0f)
            {
                s2 = new VertexSourceApplyTransform(s2, Affine.NewTranslation(x, y));
            }

            _InternalRender(s2, new RGBA_Bytes((uint)colorBrush.Color.ToArgb()));
        }
Exemplo n.º 29
0
        public void CompareToLionTGA()
        {
            LionShape   lionShape     = new LionShape();
            ImageBuffer renderedImage = new ImageBuffer(512, 400, 24, new BlenderBGR());
            byte        alpha         = (byte)(.1 * 255);

            for (int i = 0; i < lionShape.NumPaths; i++)
            {
                lionShape.Colors[i].Alpha0To255 = alpha;
            }

            Affine transform = Affine.NewIdentity();

            transform *= Affine.NewTranslation(-lionShape.Center.x, -lionShape.Center.y);
            transform *= Affine.NewTranslation(renderedImage.Width / 2, renderedImage.Height / 2);

            // This code renders the lion:
            VertexSourceApplyTransform transformedPathStorage = new VertexSourceApplyTransform(lionShape.Path, transform);
            Graphics2D renderer = renderedImage.NewGraphics2D();

            renderer.Clear(new RGBA_Floats(1.0, 1.0, 1.0, 1.0));
            renderer.Render(transformedPathStorage, lionShape.Colors, lionShape.PathIndex, lionShape.NumPaths);

            ImageTgaIO.Save(renderedImage, "TestOutput.tga");

            Stream      imageStream = File.Open("LionRenderMaster.tga", FileMode.Open);
            ImageBuffer masterImage = new ImageBuffer();

            ImageTgaIO.LoadImageData(masterImage, imageStream, 24);

            bool sameWidth  = masterImage.Width == renderedImage.Width;
            bool sameHeight = masterImage.Height == renderedImage.Height;

            Assert.IsTrue(sameWidth && sameHeight);
            Assert.IsTrue(masterImage.BitDepth == renderedImage.BitDepth);
            int unused;

            byte[] masterBuffer   = masterImage.GetBuffer(out unused);
            byte[] renderedBuffer = renderedImage.GetBuffer(out unused);
            Assert.IsTrue(masterBuffer.Length == renderedBuffer.Length);
            for (int i = 0; i < masterBuffer.Length; i++)
            {
                if (masterBuffer[i] != renderedBuffer[i])
                {
                    Assert.IsTrue(false);
                }
            }
        }
Exemplo n.º 30
0
        public void DrawString(string text, Font font, TypeFace typeFace, Brush brush, float x, float y,
                               Justification justification = Justification.Left, Baseline baseline = Baseline.BoundsTop)
        {
            SolidBrush colorBrush = brush as SolidBrush;
            //var s1 = new TypeFacePrinter (text, font.SizeInPoints, new MatterHackers.VectorMath.Vector2 (0, 0), Justification.Left, Baseline.BoundsTop);
            var s1 = new TypeFacePrinter(text,
                                         new StyledTypeFace(typeFace, font.SizeInPoints, font.Underline),
                                         new MatterHackers.VectorMath.Vector2(0, 0), justification, baseline);
            var s2 = new VertexSourceApplyTransform(s1, Affine.NewScaling(1, -1));

            if (x != 0.0f || y != 0.0f)
            {
                s2 = new VertexSourceApplyTransform(s2, Affine.NewTranslation(x, y));
            }

            _InternalRender(s2, new RGBA_Bytes((uint)colorBrush.Color.ToArgb()));
        }