SharpDX：利用C#构建高性能图形应用程序的强大工具库

using SharpDX; 
using SharpDX.Direct3D11;

using System;
using System.Drawing;
using System.Windows.Forms;
using SharpDX;
using SharpDX.Direct2D1;
using SharpDX.DXGI;
using SharpDX.Mathematics.Interop;
using AlphaMode = SharpDX.Direct2D1.AlphaMode;
using Factory = SharpDX.Direct2D1.Factory;

namespace SineAndCosineExample
{
    public partial class MainForm : Form
    {
        private Factory factory;
        private WindowRenderTarget renderTarget;
        private SolidColorBrush sineBrush;
        private SolidColorBrush cosineBrush;
        private SolidColorBrush axisBrush;
        private RawVector2 origin;
        private float amplitude;
        private float frequency;

        public MainForm()
        {
            InitializeComponent();
            InitializeGraphics();
        }

        private void InitializeGraphics()
        {
            factory = new Factory();
            var renderTargetProperties = new RenderTargetProperties
            {
                DpiX = 96,
                DpiY = 96,
                MinLevel = FeatureLevel.Level_DEFAULT,
                Type = RenderTargetType.Hardware,
                Usage = RenderTargetUsage.None,
                PixelFormat = new PixelFormat(SharpDX.DXGI.Format.B8G8R8A8_UNorm, AlphaMode.Premultiplied),
            };
            var hwndRenderTargetProperties = new HwndRenderTargetProperties
            {
                Hwnd = Handle,
                PixelSize = new Size2(ClientSize.Width, ClientSize.Height),
                PresentOptions = PresentOptions.Immediately
            };
            renderTarget = new WindowRenderTarget(factory, renderTargetProperties, hwndRenderTargetProperties);
            sineBrush = new SolidColorBrush(renderTarget, Color.Blue.ToColor4());
            cosineBrush = new SolidColorBrush(renderTarget, Color.Red.ToColor4());
            axisBrush = new SolidColorBrush(renderTarget, Color.Black.ToColor4());

            origin = new RawVector2(ClientSize.Width / 2, ClientSize.Height / 2);
            amplitude = ClientSize.Height / 4;
            frequency = 0.5f;
        }

        protected override void OnPaint(PaintEventArgs e)
        {
            base.OnPaint(e);

            renderTarget.BeginDraw();
            renderTarget.Clear(Color.White.ToColor4());

            // 绘制坐标轴
            renderTarget.DrawLine(new RawVector2(0, origin.Y), new RawVector2(ClientSize.Width, origin.Y), axisBrush);
            renderTarget.DrawLine(new RawVector2(origin.X, 0), new RawVector2(origin.X, ClientSize.Height), axisBrush);

            var sinePathGeometry = new PathGeometry(factory);
            var cosinePathGeometry = new PathGeometry(factory);

            using (var sineGeometrySink = sinePathGeometry.Open())
            using (var cosineGeometrySink = cosinePathGeometry.Open())
            {
                var radians = 0f;
                var step = 0.1f;

                sineGeometrySink.BeginFigure(CalculateSinePoint(radians), FigureBegin.Filled);
                cosineGeometrySink.BeginFigure(CalculateCosinePoint(radians), FigureBegin.Filled);

                while (radians < MathF.PI * 5)
                {
                    radians += step;

                    sineGeometrySink.AddLine(CalculateSinePoint(radians));
                    cosineGeometrySink.AddLine(CalculateCosinePoint(radians));
                }

                sineGeometrySink.EndFigure(FigureEnd.Open);
                sineGeometrySink.Close();
                cosineGeometrySink.EndFigure(FigureEnd.Open);
                cosineGeometrySink.Close();
            }

            renderTarget.DrawGeometry(sinePathGeometry, sineBrush);
            renderTarget.DrawGeometry(cosinePathGeometry, cosineBrush);

            renderTarget.EndDraw();

            axisBrush.Dispose();
            sinePathGeometry.Dispose();
            cosinePathGeometry.Dispose();
        }

        private RawVector2 CalculateSinePoint(float radians)
        {
            var x =  radians * frequency * 100;
            var y = origin.Y + MathF.Sin(radians) * amplitude;
            return new RawVector2(x, y);
        }

        private RawVector2 CalculateCosinePoint(float radians)
        {
            var x =  radians * frequency * 100;
            var y = origin.Y + MathF.Cos(radians) * amplitude;
            return new RawVector2(x, y);
        }

        protected override void OnClosed(EventArgs e)
        {
            base.OnClosed(e);

            sineBrush.Dispose();
            cosineBrush.Dispose();
            axisBrush.Dispose();
            renderTarget.Dispose();
            factory.Dispose();
        }

       
    }
}

public static class ColorExtension
    {
        public static RawColor4 ToColor4(this Color color)
        {
            return new RawColor4(color.R / 255f, color.G / 255f, color.B / 255f, color.A / 255f);
        }
    }