public SharpDXDrawing(SharpDXDevice device) : base(device) { this.device = device; solidColorBrush = new SolidColorBrush(device.RenderTarget, Colors.Black); device.RenderTarget.Transform = Matrix3x2.Identity; }
protected override void OnLoad(EventArgs e) { base.OnLoad(e); // Direct2D var renderTargetProperties = new RenderTargetProperties() { PixelFormat = new PixelFormat(SharpDX.DXGI.Format.B8G8R8A8_UNorm, AlphaMode.Ignore) }; var hwndRenderTargetProperties = new HwndRenderTargetProperties() { Hwnd = this.Handle, PixelSize = new Size2(bounds.Width, bounds.Height), PresentOptions = PresentOptions.Immediately, }; renderTarget = new WindowRenderTarget(factory, renderTargetProperties, hwndRenderTargetProperties); var bitmapProperties = new BitmapProperties() { PixelFormat = new PixelFormat(SharpDX.DXGI.Format.B8G8R8A8_UNorm, AlphaMode.Ignore) }; bitmap = new SharpDX.Direct2D1.Bitmap(renderTarget, new Size2(bounds.Width, bounds.Height), bitmapProperties); textFormat = new TextFormat(directWriteFacrtory, "Arial", FontWeight.Normal, SharpDX.DirectWrite.FontStyle.Normal, 96.0f); textFormat.ParagraphAlignment = ParagraphAlignment.Center; textFormat.TextAlignment = TextAlignment.Center; solidColorBrush = new SolidColorBrush(renderTarget, Color4.White); }
void disposeBrush() { if (_brush_ == null) return; _brush_.Dispose(); _brush_ = null; }
public LineMarker(D2D.RenderTarget render, D2D.SolidColorBrush brush, D2D.StrokeStyle stroke, float thickness) { this.brush = brush; this.stroke = stroke; this.thickness = thickness; this.render = render; }
/// <summary> /// Gets the brush for the given device. /// </summary> /// <param name="engineDevice">The device for which to get the brush.</param> internal override D2D.Brush GetBrush(EngineDevice engineDevice) { // Check for disposed state if (base.IsDisposed) { throw new ObjectDisposedException(this.GetType().Name); } D2D.SolidColorBrush result = m_loadedBrushes[engineDevice.DeviceIndex]; if (result == null) { // Load the brush result = new D2D.SolidColorBrush( engineDevice.FakeRenderTarget2D, m_singleColor.ToDXColor(), new D2D.BrushProperties() { Opacity = m_opacity, Transform = Matrix3x2.Identity.ToDXMatrix() }); m_loadedBrushes[engineDevice.DeviceIndex] = result; } return(result); }
/// <summary> /// Called when [render]. /// </summary> /// <param name="context">The context.</param> protected override void OnRender(RenderContext2D context) { if (background == null) { Background = new D2D.SolidColorBrush(context.DeviceContext, new Color4(0.8f, 0.8f, 0.8f, 0.6f)); } if (foreground == null) { Foreground = new D2D.SolidColorBrush(context.DeviceContext, Color.Blue); } var str = statistics.GetDetailString(); if (str != previousStr) { previousStr = str; RemoveAndDispose(ref textLayout); textLayout = Collect(new TextLayout(factory, str, format, float.MaxValue, float.MaxValue)); } var metrices = textLayout.Metrics; renderBound.Width = Math.Max(metrices.Width, renderBound.Width); renderBound.Height = metrices.Height; context.DeviceContext.Transform = Matrix3x2.Translation((float)context.ActualWidth - renderBound.Width, 0); context.DeviceContext.FillRectangle(renderBound, background); context.DeviceContext.DrawTextLayout(Vector2.Zero, textLayout, foreground); }
protected override void OnRender(ChartControl chartControl, ChartScale chartScale) { SharpDX.Vector2 startPoint; SharpDX.Vector2 endPoint; float start = ChartPanel.X; float halfHeight = ChartPanel.H / 2; Print("Start Point " + start + " height " + ChartPanel.H + " half height " + halfHeight); if (!IsInHitTest) { SharpDX.Direct2D1.Brush areaBrushDx; areaBrushDx = areaBrush.ToDxBrush(RenderTarget); SharpDX.Direct2D1.SolidColorBrush customDXBrush = new SharpDX.Direct2D1.SolidColorBrush(RenderTarget, SharpDX.Color.DodgerBlue); for (int index = 0; index < 5; index++) { int spacer = index * 20; startPoint = new SharpDX.Vector2(start, halfHeight + spacer); endPoint = new SharpDX.Vector2(ChartPanel.X + ChartPanel.W, halfHeight + spacer); drawRow(startPoint: startPoint, endPoint: endPoint, areaBrushDx: areaBrushDx); } areaBrushDx.Dispose(); } }
private void CursorData(float x, float y) { if (canvasparam.showcursordata == ShowCursorData.Hide) { return; } string value = "时间:"; float time = 0F; if (dlList.Count > 0) { var c = listAxisParam.Find(t => t.Attributes == "Time"); time = (x - canvasparam.OriginX) < 0 ? 0 : (x - canvasparam.OriginX) / (dlList[0].Hlength / (c.MaxScale - c.MinScale)); } value += time.ToString("f2") + "\r\n"; for (int i = 0; i < dlList.Count; i++) { value += dlList[i].Caption + ":" + dlList[i].GetLineData(x, y) + "\r\n"; } var brush = new SharpDX.Direct2D1.SolidColorBrush(_renderTarget, new RawColor4(0, 0, 1, 1)); RawVector2 pointS = new RawVector2(x, canvasparam.OriginY); RawVector2 pointE = new RawVector2(x, canvasparam.OriginY - canvasparam.VerticalLength); _renderTarget.DrawLine(pointS, pointE, brush); _renderTarget.DrawText(value, new TextFormat(dwfactory, "Arial", 12), new RawRectangleF(x, y, x + 100, y + 100), brush); }
public static void WatermarkText(Stream imageStream, Stream outputStream, string watermark, string font = "Times New Roman", float fontSize = 30.0f, int colorARGB = TransparentWhite) { using (var wic = new WIC.ImagingFactory2()) using (var d2d = new D2D.Factory()) using (var image = CreateWicImage(wic, imageStream)) using (var wicBitmap = new WIC.Bitmap(wic, image.Size.Width, image.Size.Height, WIC.PixelFormat.Format32bppPBGRA, WIC.BitmapCreateCacheOption.CacheOnDemand)) using (var target = new D2D.WicRenderTarget(d2d, wicBitmap, new D2D.RenderTargetProperties())) using (var bmpPicture = D2D.Bitmap.FromWicBitmap(target, image)) using (var dwriteFactory = new DWrite.Factory()) using (var brush = new D2D.SolidColorBrush(target, new Color(colorARGB))) { target.BeginDraw(); { target.DrawBitmap(bmpPicture, new RectangleF(0, 0, target.Size.Width, target.Size.Height), 1.0f, D2D.BitmapInterpolationMode.Linear); target.DrawRectangle(new RectangleF(0, 0, target.Size.Width, target.Size.Height), brush); var textFormat = new DWrite.TextFormat(dwriteFactory, font, DWrite.FontWeight.Bold, DWrite.FontStyle.Normal, fontSize) { ParagraphAlignment = DWrite.ParagraphAlignment.Far, TextAlignment = DWrite.TextAlignment.Trailing, }; target.DrawText(watermark, textFormat, new RectangleF(0, 0, target.Size.Width, target.Size.Height), brush); } target.EndDraw(); SaveD2DBitmap(wic, wicBitmap, outputStream); } }
public DrawingContext(Direct2D.RenderTarget g) { this.D2DTarget = g; StrokeBrush = new Direct2D.SolidColorBrush(g, Color.Black); SolidBrush = new Direct2D.SolidColorBrush(g, Color.White); MarkerBrush = new Direct2D.SolidColorBrush(g, Color.White); }
public InfoText(SharpDX.Direct3D11.Device device, int width, int height) { _immediateContext = device.ImmediateContext; _rect.Size = new Size2F(width, height); _bitmapSize = width * height * 4; IsEnabled = true; using (var factoryWic = new SharpDX.WIC.ImagingFactory()) { _wicBitmap = new SharpDX.WIC.Bitmap(factoryWic, width, height, _pixelFormat, SharpDX.WIC.BitmapCreateCacheOption.CacheOnLoad); } var renderTargetProperties = new RenderTargetProperties(RenderTargetType.Default, new SharpDX.Direct2D1.PixelFormat(SharpDX.DXGI.Format.R8G8B8A8_UNorm, SharpDX.Direct2D1.AlphaMode.Premultiplied), 0, 0, RenderTargetUsage.None, SharpDX.Direct2D1.FeatureLevel.Level_DEFAULT); using (var factory2D = new SharpDX.Direct2D1.Factory()) { _wicRenderTarget = new WicRenderTarget(factory2D, _wicBitmap, renderTargetProperties); _wicRenderTarget.TextAntialiasMode = TextAntialiasMode.Default; } using (var factoryDWrite = new SharpDX.DirectWrite.Factory(SharpDX.DirectWrite.FactoryType.Shared)) { _textFormat = new TextFormat(factoryDWrite, "Tahoma", 20); } Color4 color = new Color4(1, 1, 1, 1); _sceneColorBrush = new SolidColorBrush(_wicRenderTarget, color); _clearColor = color; _clearColor.Alpha = 0; _renderTexture = new Texture2D(device, new Texture2DDescription() { ArraySize = 1, BindFlags = BindFlags.ShaderResource, CpuAccessFlags = CpuAccessFlags.Write, Format = Format.R8G8B8A8_UNorm, Height = height, Width = width, MipLevels = 1, OptionFlags = ResourceOptionFlags.None, SampleDescription = new SampleDescription(1, 0), Usage = ResourceUsage.Dynamic }); OverlayBufferRes = new ShaderResourceView(device, _renderTexture, new ShaderResourceViewDescription() { Format = _renderTexture.Description.Format, Dimension = ShaderResourceViewDimension.Texture2D, Texture2D = new ShaderResourceViewDescription.Texture2DResource() { MipLevels = 1, MostDetailedMip = 0 } }); }
//public static Brush TEXT_BRUSH; public static void Initialize(RenderTarget g) { SCBRUSH_RED = new SolidColorBrush(g, Color.Red); SCBRUSH_BLACK = new SolidColorBrush(g, Color.Black); WRITE_FACTORY = new SharpDX.DirectWrite.Factory(); TEXT_FORMAT = new TextFormat(WRITE_FACTORY, "Arial", 14); //TEXT_BRUSH = new SolidColorBrush(g, Color.Red); }
void TextWriter_ChangeRenderTarget(RenderTarget newRenderTarget) { //throw new NotImplementedException(); renderTarget = device.renderTarget; brush = new SharpDX.Direct2D1.SolidColorBrush(renderTarget, xPFT.DrawingBase.Convertor.ColorConvertor(curentColor, opacity)); SharpDX.DirectWrite.Factory factory = new SharpDX.DirectWrite.Factory(); textFormat = new SharpDX.DirectWrite.TextFormat(factory, FontName, FontSize); }
public void DrawMarkerEffect(MyTextLayout layout, HilightType type, int start, int length, double x, double y, bool isBold, Color4?effectColor = null) { if (type == HilightType.None) { return; } float thickness = isBold ? BoldThickness : NormalThickness; Color4 color; if (effectColor != null) { color = (Color4)effectColor; } else if (type == HilightType.Select) { color = this.Hilight; } else { color = this.Foreground; } IMarkerEffecter effecter = null; D2D.SolidColorBrush brush = this._factory.GetSolidColorBrush(color); if (type == HilightType.Squiggle) { effecter = new D2DSquilleLineMarker(this.render, brush, this._factory.GetStroke(HilightType.Squiggle), thickness); } else if (type == HilightType.Select) { effecter = new HilightMarker(this.render, brush); } else if (type == HilightType.None) { effecter = null; } else { effecter = new LineMarker(this.render, brush, this._factory.GetStroke(type), thickness); } if (effecter != null) { bool isUnderline = type != HilightType.Select; DW.HitTestMetrics[] metrics = layout.HitTestTextRange(start, length, (float)x, (float)y); foreach (DW.HitTestMetrics metric in metrics) { float offset = isUnderline ? metric.Height : 0; effecter.Draw(metric.Left, metric.Top + offset, metric.Width, metric.Height); } } }
private void DrawDataLine(RawVector2[] pfdata) { var brush = new SharpDX.Direct2D1.SolidColorBrush(cp._renderTarget, color); for (int i = 0; i < pfdata.Length - 1; i++) { cp._renderTarget.DrawLine(pfdata[i], pfdata[i + 1], brush, lineWith); } }
public SolidColorBrush(D2D.RenderTarget target, Color color) { if (target != null) { d2dBrush = new D2D.SolidColorBrush(target, color.ToD2D()); } else throw new ArgumentNullException(); }
internal void InitializeResources(RenderTarget d2dRenderTarget) { if (!initialized) { Fill = new SolidColorBrush(d2dRenderTarget, Colors.Green); Stroke = new SolidColorBrush(d2dRenderTarget, Colors.Azure); initialized = true; texture = MainGame.LoadFromFile(d2dRenderTarget, @"C:\git\KinectLight\resources\Logo_EDGE_40.bmp"); } }
/// <summary> /// Draws the outline of a rectangle. /// </summary> /// <param name="pen">The pen.</param> /// <param name="rect">The rectangle bounds.</param> public void DrawRectange(Pen pen, Rect rect) { using (SharpDX.Direct2D1.SolidColorBrush brush = this.Convert(pen.Brush)) { this.renderTarget.DrawRectangle( this.Convert(rect), brush, (float)pen.Thickness); } }
/// <summary> /// Draws a line. /// </summary> /// <param name="pen">The stroke pen.</param> /// <param name="p1">The first point of the line.</param> /// <param name="p1">The second point of the line.</param> public void DrawLine(Pen pen, Perspex.Point p1, Perspex.Point p2) { if (pen != null) { using (SharpDX.Direct2D1.SolidColorBrush d2dBrush = this.Convert(pen.Brush)) { this.renderTarget.DrawLine(p1.ToSharpDX(), p2.ToSharpDX(), d2dBrush); } } }
public SolidColorBrush(D2D.RenderTarget target, Color color) { if (target != null) { d2dBrush = new D2D.SolidColorBrush(target, color.ToD2D()); } else { throw new ArgumentNullException(); } }
public void Create3dObjects() { //Create RenderWindow RenderWindowInstance = new ModelRenderWindow(); FormInstance = RenderWindowInstance.CreateWindow(1080,1240,FormStartPosition.CenterScreen); //Create SwapChain SwapChainCreator = new ModelSwapChainDesc(); SwapChainD = SwapChainCreator.CreateSwapChain(2, Usage.RenderTargetOutput, FormInstance.Handle, true, 0, 0, new Rational(60, 1), Format.R8G8B8A8_UNorm, 1,0,SwapChainFlags.AllowModeSwitch, SwapEffect.Discard); //Create Device Device.CreateWithSwapChain(DriverType.Hardware, DeviceCreationFlags.BgraSupport, SwapChainD, out GraphicsDevice, out NewSwapChain); //Create Back buffer BackBuffer = Surface.FromSwapChain(NewSwapChain, 0); //Create Factory FactoryD2D FactoryInstance = new FactoryD2D(); //Create RenderTarget RenderTargetInstance = new ModelRenderTarget(); RenderTarget = RenderTargetInstance.CreateRenderTarget(SharpDX.Direct2D1.FeatureLevel.Level_DEFAULT, new PixelFormat(Format.Unknown, SharpDX.Direct2D1.AlphaMode.Ignore), RenderTargetType.Default, RenderTargetUsage.None, BackBuffer, FactoryInstance); RenderLoop.Run(FormInstance, () => { RenderTarget.BeginDraw(); RenderTarget.Transform = Matrix3x2.Identity; RenderTarget.Clear(Color.White); using (var brush = new SolidColorBrush(RenderTarget, Color.Red)) { //for (int x = 0; x < RenderTarget.Size.Width; x += 10) // RenderTarget.DrawLine(new Vector2(x, 0), new Vector2(x, RenderTarget.Size.Height), brush, 0.5f); //for (int y = 0; y < RenderTarget.Size.Height; y += 10) // RenderTarget.DrawLine(new Vector2(0, y), new Vector2(RenderTarget.Size.Width, y), brush, 0.5f); RenderTarget.DrawLine(new Vector2(300, 10), new Vector2(300, 300), brush,1.5f); // RenderTarget.FillRectangle(new RectangleF(RenderTarget.Size.Width / 2 - 50, RenderTarget.Size.Height / 2 - 50, 100, 100), brush); } // RenderTarget.DrawRectangle( // new RectangleF(RenderTarget.Size.Width / 2 - 100, RenderTarget.Size.Height / 2 - 100, 200, 200), // new SolidColorBrush(RenderTarget, Color.CornflowerBlue)); RenderTarget.EndDraw(); NewSwapChain.Present(0, PresentFlags.None); }); RenderTarget.Dispose(); NewSwapChain.Dispose(); GraphicsDevice.Dispose(); }
/* CONSTRUCTOR METHOD */ /// <summary> /// Constructs a 2D block of text that can displayed in a 3D rendering window. /// </summary> /// <param name="window">A reference to a Direct3D-capable rendering window.</param> public TextDX(Window3D window) : base(window) { ColorBrush = Tag(new SolidColorBrush(RenderTarget, Color4.Black)); Font = "Calibri"; Size = 16f; Style = FontStyle.Normal; Text = string.Empty; UpdateSettings = true; Weight = FontWeight.Normal; }
public SharpDXDrawing(SharpDXDevice device, Window window) : base(device) { this.device = device; brush = new SolidColorBrush(device.RenderTarget, new Color4(lastColor.PackedRgba)); device.RenderTarget.Transform = Matrix3x2.Identity; drawShader = new SharpDXDrawShader(device); Reset(window.ViewportPixelSize); window.ViewportSizeChanged += Reset; device.Context.OutputMerger.BlendState = device.GetAlphaBlendStateLazy(); }
private void InitFont() { var directWriteFactory = new SharpDX.DirectWrite.Factory(); _directWriteTextFormat = new SharpDX.DirectWrite.TextFormat(directWriteFactory, _fontName, _fontSize) { TextAlignment = SharpDX.DirectWrite.TextAlignment.Leading, ParagraphAlignment = SharpDX.DirectWrite.ParagraphAlignment.Near }; _directWriteFontColor = new SharpDX.Direct2D1.SolidColorBrush(_direct2DRenderTarget, _fontColor); directWriteFactory.Dispose(); }
public void InitializeDevice(IntPtr windowHandle) { D3Device = DirectXTools.CreateD3Device(); { RenderTarget = DirectXTools.CreateRenderTarget(Direct2DFactory, D3Device); _solidBrush = new Direct2D1.SolidColorBrush(RenderTarget, Color.Black); SwapChain = DirectXTools.CreateSwapChainForHwnd(D3Device, windowHandle); DirectXTools.CreateDeviceSwapChainBitmap(SwapChain, RenderTarget); Bitmaps.SetRenderTarget(RenderTarget); TextLayouts.SetRenderTarget(RenderTarget); } }
public void InitializeDevice(ComObject coreWindow) { D3Device = DirectXTools.CreateD3Device(); { RenderTarget = DirectXTools.CreateRenderTarget(Direct2DFactory, D3Device); _solidBrush = new Direct2D1.SolidColorBrush(RenderTarget, Color.Black); SwapChain = DirectXTools.CreateSwapChainForCoreWindow(D3Device, coreWindow); DirectXTools.CreateDeviceSwapChainBitmap(SwapChain, RenderTarget); Bitmaps.SetRenderTarget(RenderTarget); TextLayouts.SetRenderTarget(RenderTarget); } }
/* CONSTRUCTOR & DESTRUCTOR METHODS */ /// <summary> /// Constructs a generic 2D rectangular panel that will be displayed as a flat, image-like rendering in the 3D rendering window. /// </summary> /// <param name="window">A reference to a Direct3D-capable rendering window in which this entity will be displayed.</param> protected Panel(Window3D window) : base(window) { BackgroundBrush = Tag(new SolidColorBrush(RenderTarget, Color.SlateGray)); BorderBrush = Tag(new SolidColorBrush(RenderTarget, Color.SlateGray)); Rectangle = new RoundedRectangle() { RadiusX = 0f, RadiusY = 0f, Rect = new RectangleF(0, 0, 100, 100), }; }
private void Update(bool forceUpdate = false) { if (isUpdated || forceUpdate) { isUpdated = false; strokeBrush?.Dispose(); strokeBrush = new d2.SolidColorBrush(Renderer.Device, _stroke.ToColor4()); strokeStyle?.Dispose(); strokeStyle = new d2.StrokeStyle(Renderer.Factory, _strokeStyleProp); } }
/// <summary> /// Get brush using specified color. /// </summary> /// <param name="dc">Device context.</param> /// <param name="color">Color in int.</param> /// <returns>Created or cached brush.</returns> public D2D.SolidColorBrush GetBrush(D2D.DeviceContext dc, int color) { if (this.brushCache.TryGetValue(color, out var brush)) { return(brush); } else { var newBrush = new D2D.SolidColorBrush(dc, Helpers.GetColor(color)); this.brushCache.Add(color, newBrush); return(newBrush); } }
/// <summary> /// Draws a filled rectangle. /// </summary> /// <param name="brush">The brush.</param> /// <param name="rect">The rectangle bounds.</param> public void FillRectange(Perspex.Media.Brush brush, Rect rect) { using (SharpDX.Direct2D1.SolidColorBrush b = this.Convert(brush)) { this.renderTarget.FillRectangle( new RectangleF( (float)rect.X, (float)rect.Y, (float)rect.Width, (float)rect.Height), b); } }
private SolidColorBrush(Color pColor, IGraphicsAdapter pTarget) { if (pTarget.Method == RenderMethods.DirectX) { var dx = (DirectXAdapter)pTarget; _brush = new SharpDX.Direct2D1.SolidColorBrush(dx.Context, new SharpDX.Color4(pColor.R / 255f, pColor.G / 255f, pColor.B / 255f, pColor.A / 255f)); _brush.Opacity = pColor.A / 255f; } else { throw new NotImplementedException(); } }
private void Update(bool updateForce = false) { if (isUpdated || updateForce) { isUpdated = false; tFormat?.Dispose(); tFormat = CreateTextFormat(this.Font); foregroundBrush?.Dispose(); foregroundBrush = new d2.SolidColorBrush(Renderer.Device, Foreground.ToColor4()); } }
public void InitializeDeviceGdiCompatible(IntPtr windowHandle, int width, int height) { using (var d3device = DirectXTools.CreateD3Device()) { RenderTarget = DirectXTools.CreateRenderTarget(Direct2DFactory, d3device); _solidBrush = new Direct2D1.SolidColorBrush(RenderTarget, Color.Black); SwapChain = DirectXTools.CreateSwapChainForHwnd(d3device, windowHandle); //DirectXTools.CreateDeviceSwapChainBitmap(SwapChain, RenderTarget); DirectXTools.CreateDeviceContextCPUBitmap(RenderTarget, width, height); Bitmaps.SetRenderTarget(RenderTarget); TextLayouts.SetRenderTarget(RenderTarget); } }
public Clock(Size clientSize) { ClientSize = clientSize; g_center = new PointF(ClientSize.Width / 2f, ClientSize.Height / 2f); // Create brushes blueBrush1 = new D2D.SolidColorBrush(RenderForm.RenderTarget, new Mathe.RawColor4(0.3f, 0.4f, 0.9f, 1)); blueBrush2 = new D2D.SolidColorBrush(RenderForm.RenderTarget, new Mathe.RawColor4(0.45f, 0.6f, 0.95f, 1)); blueBrush3 = new D2D.SolidColorBrush(RenderForm.RenderTarget, new Mathe.RawColor4(0.6f, 0.8f, 1f, 1)); whiteBrush = new D2D.SolidColorBrush(RenderForm.RenderTarget, new Mathe.RawColor4(1f, 1f, 1f, 0.5f)); redBrush = new D2D.SolidColorBrush(RenderForm.RenderTarget, new Mathe.RawColor4(0.99f, 0.16f, 0.3f, 0.7f)); // Create ellipses ellipseCentre = new D2D.Ellipse(new Mathe.RawVector2(g_center.X, g_center.Y), 120, 120); // Create text formats textFormat = new DW.TextFormat(RenderForm.FactoryWrite, "Berlin Sans FB", 36); strokeProperties = new D2D.StrokeStyleProperties { StartCap = D2D.CapStyle.Round, EndCap = D2D.CapStyle.Triangle }; strokeStyle = new D2D.StrokeStyle(RenderForm.Factory, strokeProperties); strokeProperties2 = new D2D.StrokeStyleProperties { StartCap = D2D.CapStyle.Round, EndCap = D2D.CapStyle.Round, DashStyle = D2D.DashStyle.Dash }; strokeStyle2 = new D2D.StrokeStyle(RenderForm.Factory, strokeProperties2); int len = 110; for (int i = 0; i < 60; i++) { int r = i % 5 == 0 ? 10 : 5; float deg, rad; deg = (i / 60f * 360 - 90); rad = deg / 180 * (float)Math.PI; lim[i] = new PointF(g_center.X + (float)Math.Cos(rad) * (len - r), g_center.Y + (float)Math.Sin(rad) * (len - r)); lim2[i] = new PointF(g_center.X + (float)Math.Cos(rad) * (len), g_center.Y + (float)Math.Sin(rad) * (len)); } sw = new Stopwatch(); sw.Start(); }
private void ResetBurshes(RenderContainer renderContainer) { _selectedColorBrush?.Dispose(); _spacingColorBrush?.Dispose(); _notMappedColorBrush?.Dispose(); _gridColorBrush?.Dispose(); RenderTarget target2D = renderContainer.BackBuffer.Target2D; _selectedColorBrush = new SolidColorBrush(target2D, SelectedColor.ToColor4(), null); _spacingColorBrush = new SolidColorBrush(target2D, SpacingColor.ToColor4(), null); _notMappedColorBrush = new SolidColorBrush(target2D, NotMappedColor.ToColor4(), null); _gridColorBrush = new SolidColorBrush(target2D, GridColor.ToColor4(), null); }
private static void Main() { var wicFactory = new ImagingFactory(); var d2dFactory = new SharpDX.Direct2D1.Factory(); string filename = "output.jpg"; const int width = 512; const int height = 512; var rectangleGeometry = new RoundedRectangleGeometry(d2dFactory, new RoundedRectangle() { RadiusX = 32, RadiusY = 32, Rect = new RectangleF(128, 128, width - 128, height-128) }); var wicBitmap = new Bitmap(wicFactory, width, height, SharpDX.WIC.PixelFormat.Format32bppBGR, BitmapCreateCacheOption.CacheOnLoad); var renderTargetProperties = new RenderTargetProperties(RenderTargetType.Default, new PixelFormat(Format.Unknown, AlphaMode.Unknown), 0, 0, RenderTargetUsage.None, FeatureLevel.Level_DEFAULT); var d2dRenderTarget = new WicRenderTarget(d2dFactory, wicBitmap, renderTargetProperties); var solidColorBrush = new SolidColorBrush(d2dRenderTarget, Color.White); d2dRenderTarget.BeginDraw(); d2dRenderTarget.Clear(Color.Black); d2dRenderTarget.FillGeometry(rectangleGeometry, solidColorBrush, null); d2dRenderTarget.EndDraw(); if (File.Exists(filename)) File.Delete(filename); var stream = new WICStream(wicFactory, filename, NativeFileAccess.Write); // Initialize a Jpeg encoder with this stream var encoder = new JpegBitmapEncoder(wicFactory); encoder.Initialize(stream); // Create a Frame encoder var bitmapFrameEncode = new BitmapFrameEncode(encoder); bitmapFrameEncode.Initialize(); bitmapFrameEncode.SetSize(width, height); var pixelFormatGuid = SharpDX.WIC.PixelFormat.FormatDontCare; bitmapFrameEncode.SetPixelFormat(ref pixelFormatGuid); bitmapFrameEncode.WriteSource(wicBitmap); bitmapFrameEncode.Commit(); encoder.Commit(); bitmapFrameEncode.Dispose(); encoder.Dispose(); stream.Dispose(); System.Diagnostics.Process.Start(Path.GetFullPath(Path.Combine(Environment.CurrentDirectory,filename))); }
protected override void Initialize(DemoConfiguration demoConfiguration) { base.Initialize(demoConfiguration); Factory2D = new SharpDX.Direct2D1.Factory(); using (var surface = BackBuffer.QueryInterface<Surface>()) { RenderTarget2D = new RenderTarget(Factory2D, surface, new RenderTargetProperties(new PixelFormat(Format.Unknown, AlphaMode.Premultiplied))); } RenderTarget2D.AntialiasMode = AntialiasMode.PerPrimitive; FactoryDWrite = new SharpDX.DirectWrite.Factory(); SceneColorBrush = new SolidColorBrush(RenderTarget2D, Color.White); }
/// <summary> /// Draws text. /// </summary> /// <param name="foreground">The foreground brush.</param> /// <param name="rect">The output rectangle.</param> /// <param name="text">The text.</param> public void DrawText(Perspex.Media.Brush foreground, Rect rect, FormattedText text) { if (!string.IsNullOrEmpty(text.Text)) { using (SharpDX.Direct2D1.SolidColorBrush brush = this.Convert(foreground)) using (SharpDX.DirectWrite.TextFormat format = TextService.GetTextFormat(this.directWriteFactory, text)) { this.renderTarget.DrawText( text.Text, format, this.Convert(rect), brush); } } }
private void InitializeDevices() { try { SwapChainDescription = new DXGI.SwapChainDescription(); SwapChainDescription.BufferCount = 2; SwapChainDescription.SampleDescription = new DXGI.SampleDescription(1, 0); SwapChainDescription.SwapEffect = DXGI.SwapEffect.Discard; SwapChainDescription.Usage = DXGI.Usage.BackBuffer | DXGI.Usage.RenderTargetOutput; SwapChainDescription.IsWindowed = true; SwapChainDescription.ModeDescription = new DXGI.ModeDescription(GameWindow.Current.WindowParameters.Width, GameWindow.Current.WindowParameters.Height, new DXGI.Rational(60, 1), DXGI.Format.B8G8R8A8_UNorm); SwapChainDescription.OutputHandle = GameWindowHandle; D3D11.Device.CreateWithSwapChain(DriverType.Hardware, D3D11.DeviceCreationFlags.BgraSupport, featureLevels, SwapChainDescription, out D3DDefaultDevice, out SwapChain); DXGI.Factory factory = SwapChain.GetParent <DXGI.Factory>(); factory.MakeWindowAssociation(GameWindowHandle, DXGI.WindowAssociationFlags.IgnoreAll); D3DDevice = D3DDefaultDevice.QueryInterface <D3D11.Device1>(); Backbuffer = D3D11.Texture2D.FromSwapChain <D3D11.Texture2D>(SwapChain, 0); RenderTargetView = new D3D11.RenderTargetView(D3DDevice, Backbuffer); D3DDevice.ImmediateContext.Rasterizer.SetViewport(0, 0, GameWindow.Current.WindowParameters.Width, GameWindow.Current.WindowParameters.Height); D3DDevice.ImmediateContext.OutputMerger.SetTargets(RenderTargetView); DXGIDevice = D3DDevice.QueryInterface <DXGI.Device>(); D2DFactory = new D2D1.Factory1(D2D1.FactoryType.MultiThreaded); D2DDevice = new D2D1.Device(D2DFactory, DXGIDevice); D2DDeviceContext = new D2D1.DeviceContext(D2DDevice, D2D1.DeviceContextOptions.None); RenderTargetSurface = Backbuffer.QueryInterface <DXGI.Surface>(); RenderTarget = new D2D1.RenderTarget(D2DFactory, RenderTargetSurface, new D2D1.RenderTargetProperties(new D2D1.PixelFormat(DXGI.Format.Unknown, D2D1.AlphaMode.Premultiplied))); RenderTarget.AntialiasMode = D2D1.AntialiasMode.PerPrimitive; // Initialize debug drawings brushes DrawingBoundsBrush = new D2D1.SolidColorBrush(RenderTarget, new SharpDX.Color(1f, 1f, 0f)); CollisionBoxesBrush = new D2D1.SolidColorBrush(RenderTarget, new SharpDX.Color(1f, 0f, 0f)); RenderFrame = new RenderFrame(RenderTarget); Clock = Stopwatch.StartNew(); } catch (Exception ex) { throw new DeviceInitializationException("Unable to initialize DirectX device!", ex); } }
private void InitializeDirectXResources() { var clientSize = ClientSize; var backBufferDesc = new DXGI.ModeDescription(clientSize.Width, clientSize.Height, new DXGI.Rational(60, 1), DXGI.Format.R8G8B8A8_UNorm); var swapChainDesc = new DXGI.SwapChainDescription() { ModeDescription = backBufferDesc, SampleDescription = new DXGI.SampleDescription(1, 0), Usage = DXGI.Usage.RenderTargetOutput, BufferCount = 1, OutputHandle = Handle, SwapEffect = DXGI.SwapEffect.Discard, IsWindowed = false }; D3D11.Device.CreateWithSwapChain(D3D.DriverType.Hardware, D3D11.DeviceCreationFlags.BgraSupport, new[] { D3D.FeatureLevel.Level_10_0 }, swapChainDesc, out _d3DDevice, out var swapChain); _d3DDeviceContext = _d3DDevice.ImmediateContext; _swapChain = new DXGI.SwapChain1(swapChain.NativePointer); _d2DFactory = new D2D1.Factory(); using (var backBuffer = _swapChain.GetBackBuffer <D3D11.Texture2D>(0)) { _renderTargetView = new D3D11.RenderTargetView(_d3DDevice, backBuffer); _renderTarget = new D2D1.RenderTarget(_d2DFactory, backBuffer.QueryInterface <DXGI.Surface>(), new D2D1.RenderTargetProperties(new D2D1.PixelFormat(DXGI.Format.Unknown, D2D1.AlphaMode.Premultiplied))) { TextAntialiasMode = D2D1.TextAntialiasMode.Cleartype }; } _solidColorBrush = new D2D1.SolidColorBrush(_renderTarget, Color.White); _dwFactory = new DW.Factory(DW.FactoryType.Shared); _textFormat = new DW.TextFormat(_dwFactory, "Arial", DW.FontWeight.Bold, DW.FontStyle.Normal, DW.FontStretch.Normal, 84 * (float)GraphicsUtils.Scale) { TextAlignment = DW.TextAlignment.Center, ParagraphAlignment = DW.ParagraphAlignment.Center }; _bitmap = _paradigm.Config.Gui.UseBitmap ? Properties.Resources.Einstein.ToD2D1Bitmap(_renderTarget) : null; }
/// <summary> /// 描画 /// </summary> public void Paint() { render.BeginDraw(); render.Clear(background); //Value2Map(); var fontFactory = new SharpDX.DirectWrite.Factory(); var textFormat = new TextFormat(fontFactory, "メイリオ", 24.0f); textFormat.TextAlignment = TextAlignment.Center; var textBrush = new SharpDX.Direct2D1.SolidColorBrush(render, new RawColor4(1f, 1f, 1f, 1f)); render.DrawText("ここにカルノー図が表示されます", textFormat, new RawRectangleF(10, (this.height / 2) - 12, target.Width - 10, target.Height - 10), textBrush, DrawTextOptions.None); render.EndDraw(); }
public void InitializeDevice(int width, int height, object swapChainPanel) { var nativePanel = ComObject.As <DXGI.ISwapChainPanelNative>(swapChainPanel); Debug.Assert(nativePanel != null, $"{nameof(swapChainPanel)} should not be null."); D3Device = DirectXTools.CreateD3Device(); { RenderTarget = DirectXTools.CreateRenderTarget(Direct2DFactory, D3Device); _solidBrush = new Direct2D1.SolidColorBrush(RenderTarget, Color.Black); SwapChain = DirectXTools.CreateSwapChain(width, height, D3Device); nativePanel.SwapChain = SwapChain; DirectXTools.CreateDeviceSwapChainBitmap(SwapChain, RenderTarget); Bitmaps.SetRenderTarget(RenderTarget); TextLayouts.SetRenderTarget(RenderTarget); } }
public override void Draw() { calculate(); var strokeStyleProperties = new SharpDX.Direct2D1.StrokeStyleProperties(); strokeStyleProperties.DashStyle = SharpDX.Direct2D1.DashStyle.Custom; float[] dashes = { 10, 5 }; //strokeStyleProperties.DashCap = SharpDX.Direct2D1.CapStyle.Square; //strokeStyleProperties.DashOffset = 0.2F; var strokeStyle = new StrokeStyle(cp.factory, strokeStyleProperties, dashes); var brush = new SharpDX.Direct2D1.SolidColorBrush(cp._renderTarget, new RawColor4(0.439F, 0.501F, 0.564F, 1)); for (int i = 0; i < ScaleCount; i++) { cp._renderTarget.DrawLine(listpointS[i], listpointE[i], brush, 0.5F, strokeStyle); } }
protected override void Initialize(DemoConfiguration demoConfiguration) { Factory2D = new SharpDX.Direct2D1.Factory(); FactoryDWrite = new SharpDX.DirectWrite.Factory(); HwndRenderTargetProperties properties = new HwndRenderTargetProperties(); properties.Hwnd = DisplayHandle; properties.PixelSize = new SharpDX.DrawingSize(demoConfiguration.Width, demoConfiguration.Height); properties.PresentOptions = PresentOptions.None; RenderTarget2D = new WindowRenderTarget(Factory2D, new RenderTargetProperties(new PixelFormat(Format.Unknown, AlphaMode.Premultiplied)), properties); RenderTarget2D.AntialiasMode = AntialiasMode.PerPrimitive; SceneColorBrush = new SolidColorBrush(RenderTarget2D, Color.White); }
private void InitializeGraphics() { factory = new Factory(FactoryType.SingleThreaded, DebugLevel.None); renderTargetProperties = new RenderTargetProperties(new PixelFormat(SharpDX.DXGI.Format.B8G8R8A8_UNorm, AlphaMode.Premultiplied)); hwndRenderTargetProperties = new HwndRenderTargetProperties(); hwndRenderTargetProperties.Hwnd = this.Handle; hwndRenderTargetProperties.PixelSize = new SharpDX.Size2(Width, Height); hwndRenderTargetProperties.PresentOptions = PresentOptions.None; windowRenderTarget = new WindowRenderTarget(factory, renderTargetProperties, hwndRenderTargetProperties); backgroundColor = new RawColor4(BackColor.R, BackColor.G, BackColor.B, BackColor.A); borderColor = new SolidColorBrush(windowRenderTarget, new RawColor4(0.5f, 0.5f, 0.5f, 1)); wayColor = new SolidColorBrush(windowRenderTarget, new RawColor4(0, 0, 1, 0.3f)); currentPositionColor = new SolidColorBrush(windowRenderTarget, new RawColor4(0, 0, 1, 1)); graphicsInitialized = true; }
public Result DrawGlyphRun(object clientDrawingContext, float baselineOriginX, float baselineOriginY, MeasuringMode measuringMode, GlyphRun glyphRun, GlyphRunDescription glyphRunDescription, ComObject clientDrawingEffect) { var pathGeometry = new PathGeometry(_d2DFactory); var geometrySink = pathGeometry.Open(); var fontFace = glyphRun.FontFace; if (glyphRun.Indices.Length > 0) fontFace.GetGlyphRunOutline(glyphRun.FontSize, glyphRun.Indices, glyphRun.Advances, glyphRun.Offsets, glyphRun.IsSideways, glyphRun.BidiLevel % 2 != 0, geometrySink); geometrySink.Close(); geometrySink.Dispose(); fontFace.Dispose(); var matrix = new Matrix3x2() { M11 = 1, M12 = 0, M21 = 0, M22 = 1, M31 = baselineOriginX, M32 = baselineOriginY }; var transformedGeometry = new TransformedGeometry(_d2DFactory, pathGeometry, matrix); var brushColor = (Color4)Color.Black; if (clientDrawingEffect != null && clientDrawingEffect is ColorDrawingEffect) brushColor = (clientDrawingEffect as ColorDrawingEffect).Color; var brush = new SolidColorBrush(_renderTarget, brushColor); _renderTarget.DrawGeometry(transformedGeometry, brush); _renderTarget.FillGeometry(transformedGeometry, brush); pathGeometry.Dispose(); transformedGeometry.Dispose(); brush.Dispose(); return SharpDX.Result.Ok; }
/// <summary> /// Gets a brush for the specified render target and color. /// </summary> /// <param name="renderTarget">The render target.</param> /// <param name="color">The color.</param> /// <returns>The brush (either from the cache or newly created).</returns> /// <remarks> /// Brushes are cached because their creation is expensive. /// </remarks> private Brush GetBrush(RenderTarget renderTarget, Color color) { Brush brush; lock (this.brushes) { if (!this.brushes.TryGetValue(color, out brush)) { brush = new SolidColorBrush(renderTarget, color); this.brushes[color] = brush; } } return brush; }
/// <summary> /// Initializes a new DirectXPen class. /// </summary> public DirectXPen() { _colorBrush = new SolidColorBrush(DirectXHelper.RenderTarget, SharpDX.Color.Black); Color = Color.Black; Width = 1; }
/// <summary> /// Initializes a new DirectXPen class. /// </summary> /// <param name="color">The Color.</param> /// <param name="width">The Width.</param> public DirectXPen(Color color, float width) { _colorBrush = new SolidColorBrush(DirectXHelper.RenderTarget, DirectXHelper.ConvertColor(color)); Width = width; }
public virtual void Update(DeviceContext context, TargetBase target, DeviceManager deviceManager, Point screenSize, float dt, float elapsedTime) { context.DrawRectangle(screenSize.ApplyTo(GamesParams.Margin0.ToRectangleWith(GamesParams.Margin1)), GamesParams.ObstaclesColor, 2); _gameTime += dt; if (!_gameManager.IsTraining) { const float u = 1.00f; if (_gameTime < u && !AfterStartFreeze) { var op = 1 - _gameTime / u; var hideBrush = new SolidColorBrush(deviceManager.ContextDirect2D, Colors.White, new BrushProperties { Opacity = op }); context.FillRectangle(screenSize.ApplyTo(new RectangleF(0, 0, 1, 1)), hideBrush); } else { AfterStartFreeze = true; } if (_gameTime > _gameMaxTime - u) { var op = 1 - (_gameMaxTime - _gameTime) / u; var hideBrush = new SolidColorBrush(deviceManager.ContextDirect2D, Colors.White, new BrushProperties { Opacity = op }); context.FillRectangle(screenSize.ApplyTo(new RectangleF(0, 0, 1, 1)), hideBrush); } float bar; bar = _gameManager.IsTraining ? 1 : _gameTime / _gameMaxTime; _gameManager.Page.SetTimeRectangleWidth(bar); _gameManager.RedrawPointsAndLifes(); if (_gameTime > _gameMaxTime) _gameManager.Win(100); } }
/// <summary> /// Now that we have a CoreWindow object, the DirectX device/context can be created. /// </summary> /// <param name="entryPoint"></param> public void Load(string entryPoint) { // Get the default hardware device and enable debugging. Don't care about the available feature level. // DeviceCreationFlags.BgraSupport must be enabled to allow Direct2D interop. SharpDX.Direct3D11.Device defaultDevice = new SharpDX.Direct3D11.Device(DriverType.Hardware, DeviceCreationFlags.Debug | DeviceCreationFlags.BgraSupport); // Query the default device for the supported device and context interfaces. device = defaultDevice.QueryInterface<SharpDX.Direct3D11.Device1>(); d3dContext = device.ImmediateContext.QueryInterface<SharpDX.Direct3D11.DeviceContext1>(); // Query for the adapter and more advanced DXGI objects. SharpDX.DXGI.Device2 dxgiDevice2 = device.QueryInterface<SharpDX.DXGI.Device2>(); SharpDX.DXGI.Adapter dxgiAdapter = dxgiDevice2.Adapter; SharpDX.DXGI.Factory2 dxgiFactory2 = dxgiAdapter.GetParent<SharpDX.DXGI.Factory2>(); // Description for our swap chain settings. SwapChainDescription1 description = new SwapChainDescription1() { // 0 means to use automatic buffer sizing. Width = 0, Height = 0, // 32 bit RGBA color. Format = Format.B8G8R8A8_UNorm, // No stereo (3D) display. Stereo = false, // No multisampling. SampleDescription = new SampleDescription(1, 0), // Use the swap chain as a render target. Usage = Usage.RenderTargetOutput, // Enable double buffering to prevent flickering. BufferCount = 2, // No scaling. Scaling = Scaling.None, // Flip between both buffers. SwapEffect = SwapEffect.FlipSequential, }; // Generate a swap chain for our window based on the specified description. swapChain = dxgiFactory2.CreateSwapChainForCoreWindow(device, new ComObject(window), ref description, null); // Get the default Direct2D device and create a context. SharpDX.Direct2D1.Device d2dDevice = new SharpDX.Direct2D1.Device(dxgiDevice2); d2dContext = new SharpDX.Direct2D1.DeviceContext(d2dDevice, SharpDX.Direct2D1.DeviceContextOptions.None); // Specify the properties for the bitmap that we will use as the target of our Direct2D operations. // We want a 32-bit BGRA surface with premultiplied alpha. BitmapProperties1 properties = new BitmapProperties1(new PixelFormat(SharpDX.DXGI.Format.B8G8R8A8_UNorm, SharpDX.Direct2D1.AlphaMode.Premultiplied), DisplayProperties.LogicalDpi, DisplayProperties.LogicalDpi, BitmapOptions.Target | BitmapOptions.CannotDraw); // Get the default surface as a backbuffer and create the Bitmap1 that will hold the Direct2D drawing target. Surface backBuffer = swapChain.GetBackBuffer<Surface>(0); d2dTarget = new Bitmap1(d2dContext, backBuffer, properties); // Create a solid color brush. solidBrush = new SolidColorBrush(d2dContext, Color.Coral); // Create a linear gradient brush. // Note that the StartPoint and EndPoint values are set as absolute coordinates of the surface you are drawing to, // NOT the geometry we will apply the brush. linearGradientBrush = new LinearGradientBrush(d2dContext, new LinearGradientBrushProperties() { StartPoint = new Vector2(50, 0), EndPoint = new Vector2(450, 0), }, new GradientStopCollection(d2dContext, new GradientStop[] { new GradientStop() { Color = Color.Blue, Position = 0, }, new GradientStop() { Color = Color.Green, Position = 1, } })); // Create a radial gradient brush. // The center is specified in absolute coordinates, too. radialGradientBrush = new RadialGradientBrush(d2dContext, new RadialGradientBrushProperties() { Center = new Vector2(250, 525), RadiusX = 100, RadiusY = 100, }, new GradientStopCollection(d2dContext, new GradientStop[] { new GradientStop() { Color = Color.Yellow, Position = 0, }, new GradientStop() { Color = Color.Red, Position = 1, } })); }
internal static Brush ToSharpDXBrush(RenderTarget rt, System.Drawing.Brush brush) { if (brush is System.Drawing.SolidBrush) { var res = new SolidColorBrush(rt, ToSharpDXColor(((System.Drawing.SolidBrush) brush).Color)); //res.Opacity = ToPortion(((SolidBrush) brush).Color.A); return res; } if (brush is System.Drawing.TextureBrush) { var tb = (TextureBrush) brush; var sharpDXBitmap = Converter.ToSharpDXBitmap(rt, tb.Image as System.Drawing.Bitmap, 1f); return new SharpDX.Direct2D1.BitmapBrush(rt, sharpDXBitmap); } throw new NotSupportedException(); }
/// <summary> /// 使用 SharpDX 繪製橢圓形(有填滿顏色) /// </summary> /// <param name="p1x">中心點 X 座標值</param> /// <param name="p1y">中心點 Y 座標值</param> /// <param name="p2x">橢圓的水平尺寸</param> /// <param name="p2y">橢圓的垂直尺寸</param> /// <param name="brush">XMAL中用到的顏色列舉值</param> public void DrawFillEllipse(float p1x, float p1y, float p2x, float p2y, SolidColorBrush brush) { Ellipse Ellipse = new SharpDX.Direct2D1.Ellipse(new Vector2(p1x, p1y), p2x, p2y); d2dContext.FillEllipse(Ellipse, brush); }
public void DrawGeometry(Geometry geometry, SolidColorBrush brush, int width) { d2dContext.DrawGeometry(geometry, brush, width); }
private void CreateBitmap(int width, int height) { if (_bitmap == null || (_bitmap.Size.Width < width || _bitmap.Size.Height < height)) { //RenderTargetProperties rtp = new RenderTargetProperties(RenderTargetType.Default, // new SharpDX.Direct2D1.PixelFormat(SharpDX.DXGI.Format.R8G8B8A8_UNorm, AlphaMode.Premultiplied), // Factory2D.DesktopDpi.Width, // Factory2D.DesktopDpi.Height, // RenderTargetUsage.None, // FeatureLevel.Level_DEFAULT); try { var pixelFormat = SharpDX.WIC.PixelFormat.Format32bppPRGBA; _bitmap = new SharpDX.WIC.Bitmap(FactoryImaging, width, height, pixelFormat, BitmapCreateCacheOption.CacheOnLoad); _renderTarget = new WicRenderTarget(Factory2D, _bitmap, new RenderTargetProperties()); //_renderTarget = new WicRenderTarget(Factory2D, _bitmap, rtpGDI); if (_brush == null) { _brush = new SolidColorBrush(_renderTarget, new Color4(new Color3(1, 1, 1), 1.0f)); } } catch (Exception exc) { var ss = exc.Message; } } }
/// <summary> /// 使用 SharpDX 繪製線段 /// </summary> /// <param name="p1x">起始點 X 座標值</param> /// <param name="p1y">起始點 Y 座標值</param> /// <param name="p2x">結束點 X 座標值</param> /// <param name="p2y">結束點 Y 座標值</param> /// <param name="brush">XMAL中用到的顏色列舉值</param> /// <param name="width">線條寬度</param> public void DrawLine(int p1x, int p1y, int p2x, int p2y, SolidColorBrush brush, int width) { d2dContext.DrawLine(new Vector2(p1x, p1y), new Vector2(p2x, p2y), brush, width); }
public void InitializeGlobalResources(RenderTarget target) { if (!resourcesInitialized) { SceneColorBrush = new SolidColorBrush(target, Colors.Black); resourcesInitialized = true; } }
/// <summary> /// Inits the direct2D and direct write. /// </summary> private void InitDirect2DAndDirectWrite() { Factory2D = new SharpDX.Direct2D1.Factory(); FactoryDWrite = new SharpDX.DirectWrite.Factory(); var properties = new HwndRenderTargetProperties(); properties.Hwnd = renderControl.Handle; properties.PixelSize = renderControl.ClientSize; properties.PresentOptions = PresentOptions.None; RenderTarget2D = new WindowRenderTarget(Factory2D, new RenderTargetProperties(new PixelFormat(Format.Unknown, AlphaMode.Premultiplied)), properties); RenderTarget2D.AntialiasMode = AntialiasMode.PerPrimitive; RenderTarget2D.TextAntialiasMode = TextAntialiasMode.Cleartype; SceneColorBrush = new SolidColorBrush(RenderTarget2D, new Color4(1, 0, 0, 0)); }