public static D2D.Bitmap LoadD2DBitmapFromBytes(this D2D.RenderTarget renderTarget, byte[] data) { using var stream = new MemoryStream(data); stream.Seek(0, SeekOrigin.Begin); // Loads from file using System.Drawing.Image using var bitmap = (Drawing2.Bitmap)Image.FromStream(stream); var sourceArea = new Drawing2.Rectangle(0, 0, bitmap.Width, bitmap.Height); var bitmapProperties = new D2D.BitmapProperties(new D2D.PixelFormat(DXGI.Format.R8G8B8A8_Typeless, D2D.AlphaMode.Premultiplied)); var size = new Drawing2.Size(bitmap.Width, bitmap.Height); // Transform pixels from BGRA to RGBA int stride = bitmap.Width * sizeof(int); using var tempStream = new DataStream(bitmap.Height * stride, true, true); // Lock System.Drawing.Bitmap var bitmapData = bitmap.LockBits(sourceArea, ImageLockMode.ReadOnly, Drawing2.Imaging.PixelFormat.Format32bppPArgb); // Convert all pixels for (int y = 0; y < bitmap.Height; y++) { int offset = bitmapData.Stride * y; for (int x = 0; x < bitmap.Width; x++) { // Not optimized byte B = Marshal.ReadByte(bitmapData.Scan0, offset++); byte G = Marshal.ReadByte(bitmapData.Scan0, offset++); byte R = Marshal.ReadByte(bitmapData.Scan0, offset++); byte A = Marshal.ReadByte(bitmapData.Scan0, offset++); int rgba = R | (G << 8) | (B << 16) | (A << 24); tempStream.Write(rgba); } } bitmap.UnlockBits(bitmapData); tempStream.Position = 0; return(new D2D.Bitmap(renderTarget, new Size2(size.Width, size.Height), tempStream, stride, bitmapProperties)); }
private static Direct2D.Bitmap LoadFromFile(string filename, Direct2D.RenderTarget Direct2DTarget) { var factory = new WIC.ImagingFactory(); // Decode image var decoder = new WIC.BitmapDecoder(factory, filename, WIC.DecodeOptions.CacheOnLoad); var frameDecode = decoder.GetFrame(0); var source = new WIC.BitmapSource(frameDecode.NativePointer); var fc = new WIC.FormatConverter(factory); fc.Initialize( source, SharpDX.WIC.PixelFormat.Format32bppPBGRA, SharpDX.WIC.BitmapDitherType.None, null, 0.0f, SharpDX.WIC.BitmapPaletteType.Custom ); double dpX = 96.0f; double dpY = 96.0f; fc.GetResolution(out dpX, out dpY); Direct2D.BitmapProperties props = new Direct2D.BitmapProperties( new SharpDX.Direct2D1.PixelFormat(SharpDX.DXGI.Format.B8G8R8A8_UNorm, SharpDX.Direct2D1.AlphaMode.Premultiplied)); WIC.Bitmap bmp = new WIC.Bitmap(factory, fc, WIC.BitmapCreateCacheOption.CacheOnLoad); // Формируем изображения var Direct2DBitmap = SharpDX.Direct2D1.Bitmap.FromWicBitmap(Direct2DTarget, fc, props); // Cleanup factory.Dispose(); decoder.Dispose(); source.Dispose(); fc.Dispose(); return(Direct2DBitmap); }
public BitmapImage(int width, int height, BitmapProperties properties) { mWidth = width; mHeight = height; mProperties = properties; mData = new DataStream(width * height * 4, true, true); }
private SharpDX.Direct2D1.Bitmap SDXBitmapFromSysBitmap(WindowRenderTarget device, System.Drawing.Bitmap bitmap) { var sourceArea = new System.Drawing.Rectangle(0, 0, bitmap.Width, bitmap.Height); var bitmapProperties = new BitmapProperties(new PixelFormat(SharpDX.DXGI.Format.R8G8B8A8_UNorm, AlphaMode.Premultiplied)); var size = new Size2(bitmap.Width, bitmap.Height); // Transform pixels from BGRA to RGBA int stride = bitmap.Width * sizeof(int); using (var tempStream = new DataStream(bitmap.Height * stride, true, true)) { // Lock System.Drawing.Bitmap var bitmapData = bitmap.LockBits(sourceArea, System.Drawing.Imaging.ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppPArgb); // Convert all pixels for (int y = 0; y < bitmap.Height; y++) { int offset = bitmapData.Stride * y; for (int x = 0; x < bitmap.Width; x++) { // Not optimized byte B = Marshal.ReadByte(bitmapData.Scan0, offset++); byte G = Marshal.ReadByte(bitmapData.Scan0, offset++); byte R = Marshal.ReadByte(bitmapData.Scan0, offset++); byte A = Marshal.ReadByte(bitmapData.Scan0, offset++); int rgba = R | (G << 8) | (B << 16) | (A << 24); tempStream.Write(rgba); } } bitmap.UnlockBits(bitmapData); tempStream.Position = 0; return new SharpDX.Direct2D1.Bitmap(device, size, tempStream, stride, bitmapProperties); } }
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); }
public static D2D.Bitmap LoadBitmap(D2D.RenderTarget renderTarget, string imagePath) { FileInfo fi = new FileInfo(imagePath); if (!fi.Exists) { var ext = fi.Extension; string newExt = ""; if (ext == ".jpg") { newExt = ".png"; } else if (ext == ".png") { newExt = ".jpg"; } string newName = fi.FullName.Remove(fi.FullName.Length - 4, 4); imagePath = newName + newExt; } D2D.Bitmap bmp; if (Cached.ContainsKey(imagePath)) { bmp = Cached[imagePath]; if (bmp.IsDisposed) { Cached.TryRemove(imagePath, out _); } else { return(bmp); } } WIC.ImagingFactory imagingFactory = new WIC.ImagingFactory(); DXIO.NativeFileStream fileStream = new DXIO.NativeFileStream(imagePath, DXIO.NativeFileMode.Open, DXIO.NativeFileAccess.Read); WIC.BitmapDecoder bitmapDecoder = new WIC.BitmapDecoder(imagingFactory, fileStream, WIC.DecodeOptions.CacheOnDemand); WIC.BitmapFrameDecode frame = bitmapDecoder.GetFrame(0); WIC.FormatConverter converter = new WIC.FormatConverter(imagingFactory); converter.Initialize(frame, WIC.PixelFormat.Format32bppPRGBA); var bitmapProperties = new D2D.BitmapProperties(new D2D.PixelFormat(Format.R8G8B8A8_UNorm, D2D.AlphaMode.Premultiplied)); //Size2 size = new Size2(frame.Size.Width, frame.Size.Height); bmp = D2D.Bitmap.FromWicBitmap(renderTarget, converter, bitmapProperties); if (!Cached.ContainsKey(imagePath)) { Cached.TryAdd(imagePath, bmp); //LogUtil.LogInfo("Created cache."); } return(bmp); }
/// <summary> /// Initializes a new DirectXTexture class. /// </summary> /// <param name="bmp">The Bitmap.</param> internal DirectXTexture(System.Drawing.Bitmap bmp) { RawBitmap = (System.Drawing.Bitmap) bmp.Clone(); _width = bmp.Width; _height = bmp.Height; var sourceArea = new Rectangle(0, 0, bmp.Width, bmp.Height); var bitmapProperties = new BitmapProperties( new PixelFormat(Format.R8G8B8A8_UNorm, AlphaMode.Premultiplied), 96, 96); var size = new Size2(bmp.Width, bmp.Height); int stride = bmp.Width*sizeof (int); using (var tempStream = new DataStream(bmp.Height*stride, true, true)) { BitmapData bitmapData = bmp.LockBits(sourceArea, ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppPArgb); for (int y = 0; y < bmp.Height; y++) { int offset = bitmapData.Stride*y; for (int x = 0; x < bmp.Width; x++) { byte b = Marshal.ReadByte(bitmapData.Scan0, offset++); byte g = Marshal.ReadByte(bitmapData.Scan0, offset++); byte r = Marshal.ReadByte(bitmapData.Scan0, offset++); byte a = Marshal.ReadByte(bitmapData.Scan0, offset++); int rgba = r | (g << 8) | (b << 16) | (a << 24); tempStream.Write(rgba); } } bmp.UnlockBits(bitmapData); tempStream.Position = 0; _bmp = new Bitmap(DirectXHelper.RenderTarget, size, tempStream, stride, bitmapProperties); } }
private void CreateResources() { this.backBuffer = D3D11.Texture2D.FromSwapChain <D3D11.Texture2D>(this.swapChain, 0); this.backBuffer.DebugName = "BackBuffer"; using (var surface = this.backBuffer.QueryInterface <DXGI.Surface>()) { var properties = new D2D.BitmapProperties( new D2D.PixelFormat(DXGI.Format.B8G8R8A8_UNorm, D2D.AlphaMode.Premultiplied), this.factory2d.DesktopDpi.Width, this.factory2d.DesktopDpi.Height); this.backBitmap = new D2D.Bitmap(this.deviceContext2D, surface, properties); if (this.renderBitmap != null) { this.backBitmap.CopyFromBitmap(this.renderBitmap); } } if (this.renderBitmap != null) { this.renderBitmap.Dispose(); this.renderBuffer.Dispose(); } var p = new D2D.BitmapProperties1( new D2D.PixelFormat(DXGI.Format.B8G8R8A8_UNorm, D2D.AlphaMode.Premultiplied), this.factory2d.DesktopDpi.Width, this.factory2d.DesktopDpi.Height, D2D.BitmapOptions.Target); var pixelSize = Helpers.GetPixelSize(this.backBitmap.Size, this.factory2d.DesktopDpi); var desc = new D3D11.Texture2DDescription() { ArraySize = 1, BindFlags = D3D11.BindFlags.RenderTarget | D3D11.BindFlags.ShaderResource, CpuAccessFlags = D3D11.CpuAccessFlags.None, Format = DXGI.Format.B8G8R8A8_UNorm, MipLevels = 1, OptionFlags = D3D11.ResourceOptionFlags.Shared, Usage = D3D11.ResourceUsage.Default, SampleDescription = new DXGI.SampleDescription(1, 0), Width = pixelSize.Width, Height = pixelSize.Height, }; this.renderBuffer = new D3D11.Texture2D(this.device, desc); using (var surface = this.renderBuffer.QueryInterface <DXGI.Surface>()) { this.renderBitmap = new D2D.Bitmap1(this.deviceContext2D, surface, p); } this.renderBitmap.CopyFromBitmap(this.backBitmap); }
public void ConstructRenderAndResource(double width, double height) { float dpiX, dpiY; this.GetDpi(out dpiX, out dpiY); D2D.RenderTargetProperties prop = new D2D.RenderTargetProperties( D2D.RenderTargetType.Default, new D2D.PixelFormat(DXGI.Format.B8G8R8A8_UNorm, D2D.AlphaMode.Premultiplied), dpiX, dpiY, D2D.RenderTargetUsage.None, D2D.FeatureLevel.Level_DEFAULT); D3D11.Texture2DDescription desc = new D3D11.Texture2DDescription(); desc.Width = (int)width; desc.Height = (int)height; desc.MipLevels = 1; desc.ArraySize = 1; desc.Format = DXGI.Format.B8G8R8A8_UNorm; desc.SampleDescription = new DXGI.SampleDescription(1, 0); desc.Usage = D3D11.ResourceUsage.Default; desc.BindFlags = D3D11.BindFlags.RenderTarget | D3D11.BindFlags.ShaderResource; desc.CpuAccessFlags = D3D11.CpuAccessFlags.None; desc.OptionFlags = D3D11.ResourceOptionFlags.Shared; this.d3d11Texture = new D3D11.Texture2D(this.device, desc); this.surface = this.d3d11Texture.QueryInterface <DXGI.Surface>(); DXGI.Resource resource = this.d3d11Texture.QueryInterface <DXGI.Resource>(); IntPtr handel = resource.SharedHandle; D3D9.Texture texture = new D3D9.Texture( this.device9, this.d3d11Texture.Description.Width, this.d3d11Texture.Description.Height, 1, D3D9.Usage.RenderTarget, D3D9.Format.A8R8G8B8, D3D9.Pool.Default, ref handel); this.surface9 = texture.GetSurfaceLevel(0); resource.Dispose(); texture.Dispose(); D2D.BitmapProperties bmpProp = new D2D.BitmapProperties(); bmpProp.DpiX = dpiX; bmpProp.DpiY = dpiY; bmpProp.PixelFormat = new D2D.PixelFormat(DXGI.Format.B8G8R8A8_UNorm, D2D.AlphaMode.Premultiplied); this.bmpd2d = new D2D.Bitmap(this.render, this.surface, bmpProp); this.cachedBitMap = new D2D.Bitmap(this.render, new Size2((int)width, (int)height), bmpProp); this.hasCache = false; this.render.Target = this.bmpd2d; this.renderSize = new Size(width, height); }
public void ConstructRenderAndResource(double width, double height) { float dpiX, dpiY; this.GetDpi(out dpiX, out dpiY); var desc = new DXGI.SwapChainDescription() { BufferCount = 1, ModeDescription = new DXGI.ModeDescription((int)width, (int)height, new DXGI.Rational(60, 1), DXGI.Format.B8G8R8A8_UNorm), IsWindowed = true, OutputHandle = TextBox.Handle, SampleDescription = new DXGI.SampleDescription(1, 0), SwapEffect = DXGI.SwapEffect.Discard, Usage = DXGI.Usage.RenderTargetOutput }; this.swapchain = new DXGI.SwapChain(factory_dxgi, device, desc); this.device2d = new D2D.Device1(this._factory.D2DFactory, device_dxgi); this.render = new D2D.DeviceContext1(this.device2d, D2D.DeviceContextOptions.None); D2D.BitmapProperties bmpProp = new D2D.BitmapProperties(); bmpProp.DpiX = dpiX; bmpProp.DpiY = dpiY; bmpProp.PixelFormat = new D2D.PixelFormat(DXGI.Format.B8G8R8A8_UNorm, D2D.AlphaMode.Premultiplied); this.bmp_d2d = new D2D.Bitmap(this.render, DXGI.Surface.FromSwapChain(swapchain, 0), bmpProp); this.cachedBitMap = new D2D.Bitmap(this.render, new SharpDX.Size2((int)width, (int)height), bmpProp); this.hasCache = false; this.render.Target = this.bmp_d2d; this.textRender = new CustomTextRenderer(this._factory, this.Foreground); this.renderSize = new Size(width, height); //デフォルト値を反映させる this.Foreground = ToColor4(this.TextBox.Foreground); this.Background = ToColor4(this.TextBox.Background); this.ControlChar = ToColor4(this.TextBox.ControlChar); this.Url = ToColor4(this.TextBox.Url); this.Keyword1 = ToColor4(this.TextBox.Keyword1); this.Keyword2 = ToColor4(this.TextBox.Keyword2); this.Literal = ToColor4(this.TextBox.Literal); this.Comment = ToColor4(this.TextBox.Comment); this.Hilight = ToColor4(this.TextBox.Hilight); this.LineMarker = ToColor4(this.TextBox.LineMarker); this.InsertCaret = ToColor4(this.TextBox.InsertCaret); this.OverwriteCaret = ToColor4(this.TextBox.OverwriteCaret); this.UpdateArea = ToColor4(this.TextBox.UpdateArea); this.HilightForeground = ToColor4(this.TextBox.HilightForeground); }
public SharpDX.Direct2D1.Bitmap GetD2DBitmap(SharpDX.Direct2D1.DeviceContext dc, ImagingFactory factory) { using (var fc = new FormatConverter(factory)) { fc.Initialize(WICBitmapSource, SharpDX.WIC.PixelFormat.Format32bppPBGRA, SharpDX.WIC.BitmapDitherType.None, null, 0.0f, SharpDX.WIC.BitmapPaletteType.Custom); var bmpProps = new SharpDX.Direct2D1.BitmapProperties(dc.PixelFormat, dc.Factory.DesktopDpi.Width, dc.Factory.DesktopDpi.Height); return(SharpDX.Direct2D1.Bitmap1.FromWicBitmap(dc, fc, bmpProps)); } }
public static D2D.Bitmap LoadBitmap(this D2D.RenderTarget renderTarget, string imagePath) { lock (LockObj) { Sw.Start(); D2D.Bitmap bmp; if (Cached.ContainsKey(imagePath)) { Cached[imagePath].Time = DateTime.Now; bmp = Cached[imagePath].Bitmap; Sw.Stop(); LogUtil.LogInfo($"Cache: {Sw.ElapsedMilliseconds}ms."); } else { WIC.ImagingFactory imagingFactory = new WIC.ImagingFactory(); DXIO.NativeFileStream fileStream = new DXIO.NativeFileStream(imagePath, DXIO.NativeFileMode.Open, DXIO.NativeFileAccess.Read); WIC.BitmapDecoder bitmapDecoder = new WIC.BitmapDecoder(imagingFactory, fileStream, WIC.DecodeOptions.CacheOnDemand); WIC.BitmapFrameDecode frame = bitmapDecoder.GetFrame(0); WIC.FormatConverter converter = new WIC.FormatConverter(imagingFactory); converter.Initialize(frame, WIC.PixelFormat.Format32bppPRGBA); var bitmapProperties = new D2D.BitmapProperties(new D2D.PixelFormat(Format.R8G8B8A8_UNorm, D2D.AlphaMode.Premultiplied)); //Size2 size = new Size2(frame.Size.Width, frame.Size.Height); bmp = D2D.Bitmap.FromWicBitmap(renderTarget, converter, bitmapProperties); Sw.Stop(); LogUtil.LogInfo($"Load: {Sw.ElapsedMilliseconds}ms."); } if (!Cached.ContainsKey(imagePath) && Sw.ElapsedMilliseconds > 50) { Cached.TryAdd(imagePath, new CacheInfo(DateTime.Now, bmp)); LogUtil.LogInfo("Created cache."); if (Cached.Count > 50) { Cached.TryRemove(Cached.OrderByDescending(c => c.Value.Time).First().Key, out _); LogUtil.LogInfo("Removed unused cache."); } } Sw.Reset(); return(bmp); } }
/// <summary> /// Copy a rect of bitmap into a new one. /// </summary> /// <param name="renderTarget">The render target, e.g. device context.</param> /// <param name="bitmap">Original bitmap.</param> /// <param name="rect">The area to be copied.</param> /// <param name="dpi">Dpi.</param> /// <returns>The new copied bitmap.</returns> public static D2D.Bitmap CopyBitmap(D2D.RenderTarget renderTarget, D2D.Bitmap bitmap, RawRectangleF rect, Size2F dpi) { var bitmapProperties = new D2D.BitmapProperties( bitmap.PixelFormat, dpi.Width, dpi.Height); var pixelRect = GetRawRectangle(rect, dpi); var pixelSize = new Size2(pixelRect.Right - pixelRect.Left, pixelRect.Bottom - pixelRect.Top); var newBitmap = new D2D.Bitmap(renderTarget, pixelSize, bitmapProperties); newBitmap.CopyFromBitmap(bitmap, new RawPoint(0, 0), pixelRect); return(newBitmap); }
public static D2D.Bitmap LoadBitmap(this D2D.RenderTarget renderTarget, GdiP.Bitmap bitmap) { lock (LockObj) { Sw.Restart(); try { var sourceArea = new GdiP.Rectangle(0, 0, bitmap.Width, bitmap.Height); var bitmapProperties = new D2D.BitmapProperties(new D2D.PixelFormat(Format.R8G8B8A8_UNorm, D2D.AlphaMode.Premultiplied)); Size2 size = new Size2(bitmap.Width, bitmap.Height); // Transform pixels from BGRA to RGBA int stride = bitmap.Width * sizeof(int); using (var tempStream = new DataStream(bitmap.Height * stride, true, true)) { // Lock System.Drawing.Bitmap var bitmapData = bitmap.LockBits(sourceArea, GdiPimaging.ImageLockMode.ReadOnly, GdiPimaging.PixelFormat.Format32bppPArgb); // Convert all pixels for (int y = 0; y < bitmap.Height; y++) { int offset = bitmapData.Stride * y; for (int x = 0; x < bitmap.Width; x++) { // Not optimized byte b = Marshal.ReadByte(bitmapData.Scan0, offset++); byte g = Marshal.ReadByte(bitmapData.Scan0, offset++); byte r = Marshal.ReadByte(bitmapData.Scan0, offset++); byte a = Marshal.ReadByte(bitmapData.Scan0, offset++); int rgba = r | (g << 8) | (b << 16) | (a << 24); tempStream.Write(rgba); } } bitmap.UnlockBits(bitmapData); tempStream.Position = 0; return(new D2D.Bitmap(renderTarget, size, tempStream, stride, bitmapProperties)); } } finally { Sw.Stop(); //LogUtil.LogInfo($"[FromGdi] Load: {Sw.ElapsedMilliseconds}ms."); } } }
public void UpdateMap(string mapName) { mWdlFile = new IO.Files.Terrain.WdlFile(); try { mWdlFile.Load(mapName); if(mWdlFile.HasEntries == false) { UpdateMapNoWdl(mapName); return; } } catch(Exception) { UpdateMapNoWdl(mapName); return; } if (mImage != null) mImage.Dispose(); var textureData = new uint[Width * Height]; for(var i = 0; i < 64; ++i) { for(var j = 0; j < 64; ++j) { if (mWdlFile.HasEntry(j, i) == false) continue; var entry = mWdlFile.GetEntry(j, i); LoadEntry(entry, textureData, ref i, ref j); } } var bmpProps = new BitmapProperties(new PixelFormat(SharpDX.DXGI.Format.B8G8R8A8_UNorm, AlphaMode.Ignore)); using (var dataStream = new DataStream(Width * Height * 4, true, true)) { dataStream.WriteRange(textureData); dataStream.Position = 0; mImage = new Bitmap(InterfaceManager.Instance.Surface.RenderTarget, new Size2(Width, Height), new DataPointer(dataStream.DataPointer, Width * Height * 4), Width * 4, bmpProps); } }
public static D2D.Bitmap LoadD2DBitmapFromFile(this D2D.RenderTarget renderTarget, string file, float scaleX = 1, float scaleY = 1) { try { using (var bitmap = (Bitmap)Image.FromFile(file)) { var g = Graphics.FromImage(bitmap); g.ScaleTransform(scaleX, scaleY); g.Flush(); g.Save(); g.Dispose(); var sourceArea = new System.Drawing.Rectangle(0, 0, bitmap.Width, bitmap.Height); var bitmapProperties = new D2D.BitmapProperties(new D2D.PixelFormat(DXGI.Format.R8G8B8A8_UNorm, D2D.AlphaMode.Premultiplied)); var size = new Size2(bitmap.Width, bitmap.Height); // Transform pixels from BGRA to RGBA int stride = bitmap.Width * sizeof(int); using (var tempStream = new DataStream(bitmap.Height * stride, true, true)) { // Lock System.Drawing.Bitmap var bitmapData = bitmap.LockBits(sourceArea, ImageLockMode.ReadOnly, Drawing2.Imaging.PixelFormat.Format32bppPArgb); // Convert all pixels for (int y = 0; y < bitmap.Height; y++) { int offset = bitmapData.Stride * y; for (int x = 0; x < bitmap.Width; x++) { // Not optimized byte B = Marshal.ReadByte(bitmapData.Scan0, offset++); byte G = Marshal.ReadByte(bitmapData.Scan0, offset++); byte R = Marshal.ReadByte(bitmapData.Scan0, offset++); byte A = Marshal.ReadByte(bitmapData.Scan0, offset++); int rgba = R | (G << 8) | (B << 16) | (A << 24); tempStream.Write(rgba); } } bitmap.UnlockBits(bitmapData); tempStream.Position = 0; return(new D2D.Bitmap(renderTarget, size, tempStream, stride, bitmapProperties)); } } } catch (SharpDXException) { throw; } }
/// <summary> /// 从指定的路径中加载bitmap /// </summary> /// <param name="file">路径</param> /// <returns>TextureId</returns> public int LoadBitmapFromFile(string file) { var fileName = Path.GetFileName(file); Debug.Assert(fileName != null, "fileName != null"); if (bitmapNameDictionary.ContainsKey(fileName)) { return bitmapNameDictionary[fileName]; } // Loads from file using System.Drawing.Image using (var bitmap = (System.Drawing.Bitmap)Image.FromFile(file)) { var sourceArea = new Rectangle(0, 0, bitmap.Width, bitmap.Height); var bitmapProperties = new BitmapProperties(new PixelFormat(Format.R8G8B8A8_UNorm, AlphaMode.Premultiplied)); var size = new Size(bitmap.Width, bitmap.Height); // Transform pixels from BGRA to RGBA var stride = bitmap.Width * sizeof(int); using (var tempStream = new DataStream(bitmap.Height * stride, true, true)) { // Lock System.Drawing.Bitmap var bitmapData = bitmap.LockBits(sourceArea, ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppPArgb); // Convert all pixels for (var y = 0; y < bitmap.Height; y++) { var offset = bitmapData.Stride * y; for (var x = 0; x < bitmap.Width; x++) { // Not optimized var b = Marshal.ReadByte(bitmapData.Scan0, offset++); var g = Marshal.ReadByte(bitmapData.Scan0, offset++); var r = Marshal.ReadByte(bitmapData.Scan0, offset++); var a = Marshal.ReadByte(bitmapData.Scan0, offset++); var rgba = r | (g << 8) | (b << 16) | (a << 24); tempStream.Write(rgba); } } bitmap.UnlockBits(bitmapData); tempStream.Position = 0; bitmapList.Add(new Bitmap(renderTarget, new Size2(size.Width, size.Height), tempStream, stride, bitmapProperties)); bitmapNameDictionary.Add(fileName, index); return index++; } } }
private static Bitmap BitmapToImage(RenderTarget renderTarget, System.Drawing.Bitmap bitmap) { var sourceArea = new System.Drawing.Rectangle(0, 0, bitmap.Width, bitmap.Height); var bitmapProperties = new SharpDX.Direct2D1.BitmapProperties( new SharpDX.Direct2D1.PixelFormat(Format.R8G8B8A8_UNorm, SharpDX.Direct2D1.AlphaMode.Premultiplied)); var size = new Size2(bitmap.Width, bitmap.Height); // Transform pixels from BGRA to RGBA var stride = bitmap.Width * sizeof(int); using (var tempStream = new DataStream(bitmap.Height * stride, true, true)) { // Lock System.Drawing.Bitmap var bitmapData = bitmap.LockBits(sourceArea, ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppPArgb); // ReSharper disable TooWideLocalVariableScope int r, g, b, a, rgba, offset; IntPtr zerothPixel; // ReSharper restore TooWideLocalVariableScope // Convert all pixels for (var y = 0; y < bitmap.Height; y++) { offset = bitmapData.Stride * y; for (var x = 0; x < bitmap.Width; x++) { zerothPixel = bitmapData.Scan0; b = Marshal.ReadByte(zerothPixel, offset++); g = Marshal.ReadByte(zerothPixel, offset++); r = Marshal.ReadByte(zerothPixel, offset++); a = Marshal.ReadByte(zerothPixel, offset++); rgba = r | (g << 8) | (b << 16) | (a << 24); tempStream.Write(rgba); } } bitmap.UnlockBits(bitmapData); tempStream.Position = 0; return(new Bitmap(renderTarget, size, tempStream, stride, bitmapProperties)); } }
//--------------------------------------------------------------------------------------------------------- /// <summary> /// Загрузка рисунка из ресурса /// </summary> /// <param name="resource_name">Имя ресурса</param> /// <returns>Рисунок Direct2D</returns> //--------------------------------------------------------------------------------------------------------- public static Direct2D.Bitmap LoadFromResource(String resource_name) { Object image = null; // Properties.Resources.ResourceManager.GetObject(resource_name); System.Drawing.Bitmap bitmap = (System.Drawing.Bitmap)image; System.Drawing.Imaging.BitmapData lock_data = bitmap.LockBits(new System.Drawing.Rectangle(0, 0, bitmap.Width, bitmap.Height), System.Drawing.Imaging.ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppPArgb); Direct2D.BitmapProperties bp = new Direct2D.BitmapProperties(); bp.DpiX = 96; bp.DpiY = 96; bp.PixelFormat = new Direct2D.PixelFormat(DXGI.Format.B8G8R8A8_UNorm, Direct2D.AlphaMode.Premultiplied); Direct2D.Bitmap bitmap_d2d = new Direct2D.Bitmap(D2DRenderTarget, new Size2(bitmap.Width, bitmap.Height), bp); bitmap_d2d.CopyFromMemory(lock_data.Scan0, lock_data.Stride); bitmap.UnlockBits(lock_data); return(bitmap_d2d); }
public D2D1.Bitmap ConvertToSharpDXBitmap(D2D1.DeviceContext context, System.Drawing.Bitmap bmp) { D2D1.Bitmap Image = null; try { BitmapData bmpData = bmp.LockBits(new System.Drawing.Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.WriteOnly, bmp.PixelFormat); dataStream = new DataStream(bmpData.Scan0, bmpData.Stride * bmpData.Height, true, false); D2D1.BitmapProperties d2dBitmapProperties = new D2D1.BitmapProperties(); d2dBitmapProperties.PixelFormat = D2PixelFormat; Image = new D2D1.Bitmap(context, new Size2(bmpData.Width, bmpData.Height), dataStream, bmpData.Stride, d2dBitmapProperties); dataStream.Dispose(); bmp.UnlockBits(bmpData); bmp.Dispose(); } catch (Exception ex) { Logger.LogFile(ex.Message, "", "ConvertToSlimDXBitmap", ex.LineNumber(), "GraphicUtilDX"); } return(Image); }
public static d2d.Bitmap LoadBitmap(d2d.RenderTarget renderTarget, gdi.Bitmap gdiBmp) { d2d.Bitmap result = null; //Lock the gdi resource BitmapData drawingBitmapData = gdiBmp.LockBits( new gdi.Rectangle(0, 0, gdiBmp.Width, gdiBmp.Height), ImageLockMode.ReadOnly, gdi.Imaging.PixelFormat.Format32bppPArgb); try { //Prepare loading the image from gdi resource DataStream dataStream = new DataStream( drawingBitmapData.Scan0, drawingBitmapData.Stride * drawingBitmapData.Height, true, false); d2d.BitmapProperties properties = new d2d.BitmapProperties(); properties.PixelFormat = new SharpDX.Direct2D1.PixelFormat( SharpDX.DXGI.Format.B8G8R8A8_UNorm, d2d.AlphaMode.Premultiplied); //Load the image from the gdi resource result = new d2d.Bitmap( renderTarget, new Size2(gdiBmp.Width, gdiBmp.Height), dataStream, drawingBitmapData.Stride, properties); //Unlock the gdi resource gdiBmp.UnlockBits(drawingBitmapData); } catch (Exception e) { gdiBmp.UnlockBits(drawingBitmapData); throw e; } return(result); }
/// <summary> /// Loads a Direct2D Bitmap from a file using System.Drawing.Image.FromFile(...) /// </summary> /// <param name="renderTarget">The render target.</param> /// <param name="file">The file.</param> /// <returns>A D2D1 Bitmap</returns> public static Bitmap LoadFromFile(RenderTarget renderTarget, string file) { // Loads from file using System.Drawing.Image using (var bitmap = (System.Drawing.Bitmap)System.Drawing.Image.FromFile(file)) { var sourceArea = new System.Drawing.Rectangle(0, 0, bitmap.Width, bitmap.Height); var bitmapProperties = new BitmapProperties(new PixelFormat(Format.R8G8B8A8_UNorm, AlphaMode.Premultiplied)); var size = new Size2(bitmap.Width, bitmap.Height); // Transform pixels from BGRA to RGBA int stride = bitmap.Width * sizeof(int); using (var tempStream = new DataStream(bitmap.Height * stride, true, true)) { // Lock System.Drawing.Bitmap var bitmapData = bitmap.LockBits(sourceArea, ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppPArgb); // Convert all pixels for (int y = 0; y < bitmap.Height; y++) { int offset = bitmapData.Stride*y; for (int x = 0; x < bitmap.Width; x++) { // Not optimized byte B = Marshal.ReadByte(bitmapData.Scan0, offset++); byte G = Marshal.ReadByte(bitmapData.Scan0, offset++); byte R = Marshal.ReadByte(bitmapData.Scan0, offset++); byte A = Marshal.ReadByte(bitmapData.Scan0, offset++); int rgba = R | (G << 8) | (B << 16) | (A << 24); tempStream.Write(rgba); } } bitmap.UnlockBits(bitmapData); tempStream.Position = 0; return new Bitmap(renderTarget, size, tempStream, stride, bitmapProperties); } } }
/// <summary> /// Initializes a new instance of the <see cref="LogoControl"/> class. /// </summary> /// <param name="parent">The parent control.</param> public LogoControl(IElement parent) : base(parent) { var image = Properties.Resources.neovim_logo_flat; var size = new Rectangle(0, 0, image.Width, image.Height); var bitmapProperties = new D2D.BitmapProperties() { DpiX = this.Factory.DesktopDpi.Width, DpiY = this.Factory.DesktopDpi.Height, PixelFormat = new D2D.PixelFormat(SharpDX.DXGI.Format.B8G8R8A8_UNorm, D2D.AlphaMode.Premultiplied), }; var bitmapData = image.LockBits(size, ImageLockMode.ReadOnly, PixelFormat.Format32bppPArgb); this.bitmap = new D2D.Bitmap( this.DeviceContext, new Size2(image.Width, image.Height), new DataPointer(bitmapData.Scan0, bitmapData.Stride * bitmapData.Height), bitmapData.Stride, bitmapProperties); image.UnlockBits(bitmapData); this.ratio = (float)image.Width / image.Height; }
public override void initContent(SurfaceImageSourceTarget target, DrawingSize pixelSize) { this.drawingSize = pixelSize; this.size = new DrawingSize((int) (pixelSize.Width/scaling), (int) (pixelSize.Height/scaling)); context = target.DeviceManager.ContextDirect2D; Mandelbrot engine = new BasicMandelbrot(iters); view = new TrajectoryMandelbrotView(engine, trajectory, size.Width, size.Height); data = new int[size.Width * size.Height]; PixelFormat format = new PixelFormat(Format.B8G8R8A8_UNorm, SharpDX.Direct2D1.AlphaMode.Ignore); BitmapProperties props = new BitmapProperties(format); buf = Bitmap.New<int>(context, size, data, props); }
private void UpdateMapNoWdl(string continent) { var wdtPath = string.Format(@"World\Map\{0}\{0}.wdt", continent); var hasWdt = FileManager.Instance.Provider.Exists(wdtPath); if(hasWdt == false) { UpdateMapFallback(continent); return; } using(var strm = FileManager.Instance.Provider.OpenFile(wdtPath)) { var reader = new BinaryReader(strm); var hasWdtData = false; while (true) { try { var id = reader.ReadUInt32(); var size = reader.ReadInt32(); if (id == 0x4D41494E) { var adtFlags = reader.ReadArray<ulong>(size / 8); var textureData = new uint[Width * Height]; for(var i = 0; i < 64; ++i) { for(var j = 0; j < 64; ++j) { var idx = i * 64 + j; var exists = (adtFlags[idx] & 1) != 0; if(exists) { hasWdtData = true; for(var k = 0; k < 17; ++k) { for(var l = 0; l < 17; ++l) textureData[(i * 17 + k) * (64 * 17) + j * 17 + l] = 0xFFFFFFFF; } } } } var bmpProps = new BitmapProperties(new PixelFormat(SharpDX.DXGI.Format.B8G8R8A8_UNorm, AlphaMode.Ignore)); using (var dataStream = new DataStream(Width * Height * 4, true, true)) { dataStream.WriteRange(textureData); dataStream.Position = 0; mImage = new Bitmap(InterfaceManager.Instance.Surface.RenderTarget, new Size2(Width, Height), new DataPointer(dataStream.DataPointer, Width * Height * 4), Width * 4, bmpProps); } break; } reader.ReadBytes(size); } catch (Exception) { UpdateMapFallback(continent); return; } } if (hasWdtData == false) UpdateMapFallback(continent); } }
/* CONSTRUCTOR & DESTRUCTOR METHODS */ /// <summary> /// Constructs a renderable 2D image from a stored image file. /// </summary> /// <param name="window">A reference to a Direct3D-capable rendering window.</param> /// <param name="fileName">An absolute or relative image file path.</param> public ImageDX(Window3D window, string fileName) : base(window) { using (SystemBitmap image = (SystemBitmap)SystemBitmap.FromFile(fileName)) { Height = image.Height; Width = image.Width; var szImage = new System.Drawing.Rectangle(0, 0, image.Width, image.Height); int byteSize = image.Height * image.Width * sizeof(int); using (DataStream bmpStream = new DataStream(byteSize, true, true)) { var sysPixelFormat = System.Drawing.Imaging.PixelFormat.Format32bppPArgb; BitmapData bmpData = image.LockBits(szImage, ImageLockMode.ReadWrite, sysPixelFormat); for (int y = 0; y < image.Height; y++) { int offset = y * bmpData.Stride; for (int x = 0; x < image.Width; x++) { // System bitmaps store pixel values as BGRA byte arrays byte b = Marshal.ReadByte(bmpData.Scan0, offset++); byte g = Marshal.ReadByte(bmpData.Scan0, offset++); byte r = Marshal.ReadByte(bmpData.Scan0, offset++); byte a = Marshal.ReadByte(bmpData.Scan0, offset++); // Convert BGRA to RGBA (stored as a 32 bit = 4 byte integer) int rgba = r | (g << 8) | (b << 16) | (a << 24); // Write the RGBA value to the data buffer bmpStream.Write(rgba); } } image.UnlockBits(bmpData); bmpStream.Position = 0; BitmapProperties bmpProps = new BitmapProperties(RenderTarget.PixelFormat); Bitmap = new Bitmap(RenderTarget, new Size2(image.Width, image.Height), bmpStream, bmpData.Stride, bmpProps); Crop = new RectangleF(0, 0, Width, Height); } } }
private unsafe void DrawCursor(SharpDX.Direct2D1.RenderTarget renderTarger, CursorInfo cursor) { var position = cursor.Position; var shapeBuff = cursor.PtrShapeBuffer; var shapeInfo = cursor.ShapeInfo; int width = shapeInfo.Width; int height = shapeInfo.Height; int pitch = shapeInfo.Pitch; int left = position.X; int top = position.Y; int right = position.X + width; int bottom = position.Y + height; //logger.Debug(left + " " + top + " " + right + " " + bottom); if (cursor.ShapeInfo.Type == (int)ShapeType.DXGI_OUTDUPL_POINTER_SHAPE_TYPE_COLOR) { var data = new DataPointer(shapeBuff, height * pitch); var prop = new Direct2D.BitmapProperties(new Direct2D.PixelFormat(Format.B8G8R8A8_UNorm, Direct2D.AlphaMode.Premultiplied)); var size = new Size2(width, height); var cursorBits = new Direct2D.Bitmap(renderTarger, size, data, pitch, prop); try { var cursorRect = new RawRectangleF(left, top, right, bottom); renderTarger.DrawBitmap(cursorBits, cursorRect, 1.0f, Direct2D.BitmapInterpolationMode.Linear); } finally { cursorBits?.Dispose(); } } else if (cursor.ShapeInfo.Type == (int)ShapeType.DXGI_OUTDUPL_POINTER_SHAPE_TYPE_MONOCHROME) { height = height / 2; left = position.X; top = position.Y; right = position.X + width; bottom = position.Y + height; pitch = width * 4; Texture2D desktopRegionTex = null; try { desktopRegionTex = new Texture2D(device, new Texture2DDescription { CpuAccessFlags = CpuAccessFlags.Read, BindFlags = BindFlags.None, Format = Format.B8G8R8A8_UNorm, Width = width, Height = height, MipLevels = 1, ArraySize = 1, SampleDescription = { Count = 1, Quality = 0 }, Usage = ResourceUsage.Staging, OptionFlags = ResourceOptionFlags.None, }); var region = new ResourceRegion(left, top, 0, right, bottom, 1); var immediateContext = device.ImmediateContext; immediateContext.CopySubresourceRegion(screenTexture, 0, region, desktopRegionTex, 0); var dataBox = immediateContext.MapSubresource(desktopRegionTex, 0, MapMode.Read, MapFlags.None); try { var desktopBuffer = new byte[width * height * 4]; Marshal.Copy(dataBox.DataPointer, desktopBuffer, 0, desktopBuffer.Length); var shapeBufferLenght = width * height * 4; var shapeBuffer = new byte[shapeBufferLenght]; var maskBufferLenght = width * height / 8; var andMaskBuffer = new byte[maskBufferLenght]; Marshal.Copy(shapeBuff, andMaskBuffer, 0, andMaskBuffer.Length); var xorMaskBuffer = new byte[maskBufferLenght]; Marshal.Copy(shapeBuff + andMaskBuffer.Length, xorMaskBuffer, 0, xorMaskBuffer.Length); for (var row = 0; row < height; ++row) { byte mask = 0x80; for (var col = 0; col < width; ++col) { var maskIndex = row * width / 8 + col / 8; var andMask = ((andMaskBuffer[maskIndex] & mask) == mask) ? 0xFF : 0; var xorMask = ((xorMaskBuffer[maskIndex] & mask) == mask) ? 0xFF : 0; int pos = row * width * 4 + col * 4; for (int i = 0; i < 3; i++) {// RGB shapeBuffer[pos] = (byte)((desktopBuffer[pos] & andMask) ^ xorMask); pos++; } // Alpha shapeBuffer[pos] = (byte)((desktopBuffer[pos] & 0xFF) ^ 0); if (mask == 0x01) { mask = 0x80; } else { mask = (byte)(mask >> 1); } } } Direct2D.Bitmap cursorBits = null; try { fixed(byte *ptr = shapeBuffer) { var data = new DataPointer(ptr, height * pitch); var prop = new Direct2D.BitmapProperties(new Direct2D.PixelFormat(Format.B8G8R8A8_UNorm, Direct2D.AlphaMode.Premultiplied)); var size = new Size2(width, height); cursorBits = new Direct2D.Bitmap(renderTarger, size, data, pitch, prop); }; var shapeRect = new RawRectangleF(left, top, right, bottom); renderTarger.DrawBitmap(cursorBits, shapeRect, 1.0f, Direct2D.BitmapInterpolationMode.Linear); } finally { cursorBits?.Dispose(); } } finally { immediateContext.UnmapSubresource(desktopRegionTex, 0); } } finally { desktopRegionTex?.Dispose(); } } else if (cursor.ShapeInfo.Type == (int)ShapeType.DXGI_OUTDUPL_POINTER_SHAPE_TYPE_COLOR) { logger.Warn("Not supported cursor type " + ShapeType.DXGI_OUTDUPL_POINTER_SHAPE_TYPE_COLOR); } }
public void UpdateInternalImage(Matrix.FxMatrixF mat, ColorMap map, bool useInvMap = false) { // link the extran matrix with the internal internalMatrix = mat; // check if we need to create a new internal buffer if (mat.Width != Width || mat.Height != Height) { lock (this) { // set the properties of the image BitmapProperties bitmapProps = new BitmapProperties(); bitmapProps.PixelFormat = new SharpDX.Direct2D1.PixelFormat(SharpDX.DXGI.Format.B8G8R8A8_UNorm, AlphaMode.Premultiplied); // set the size of the image Width = mat.Width; Height = mat.Height; if (mImageBitmap != null) { mImageBitmap.Dispose(); } // make the bitmap for Direct2D1 mImageBitmap = new SharpDX.Direct2D1.Bitmap(this.Parent.RenderVariables.renderTarget, new Size2(Width, Height), bitmapProps); } } unsafe { try { int size = Width * Height; fixed (byte* dst = internalImage) { fixed (float* src = mat.Data) { byte* pDst = dst; float* pSrc = src; if (useInvMap) { #if false float* pSrcEnd = pSrc + mat.Size; for (; pSrc < pSrcEnd; pSrc++) { byte id = (byte)(255 - *(pSrc) * 255); *(pDst++) = map[id, 2]; *(pDst++) = map[id, 1]; *(pDst++) = map[id, 0]; *(pDst++) = 255; } #else int step = size / 8; Parallel.For(0, 8, (s) => { int end = (s + 1) * step; for (int i = s * step; i < end; i++) { byte id = (byte)(255 - *(pSrc + i) * 255); int i4 = i * 4; *(pDst + i4) = map[id, 2]; *(pDst + i4 + 1) = map[id, 1]; *(pDst + i4 + 2) = map[id, 0]; *(pDst + i4 + 3) = 255; } }); #endif } else { #if false float* pSrcEnd = pSrc + mat.Size; for(; pSrc < pSrcEnd; pSrc++) { byte id = (byte)(*(pSrc) * 255); *(pDst++) = map[id, 2]; *(pDst++) = map[id, 1]; *(pDst++) = map[id, 0]; *(pDst++) = 255; } #else int step = size / 8; Parallel.For(0, 8, (s) => { int end = (s + 1) * step; for (int i = s * step; i < end; i++) { byte id = (byte)(*(pSrc + i) * 255); int i4 = i * 4; *(pDst + i4) = map[id, 2]; *(pDst + i4 + 1) = map[id, 1]; *(pDst + i4 + 2) = map[id, 0]; *(pDst + i4 + 3) = 255; } }); #endif } } } // write to the specific bitmap not create a new one mImageBitmap.CopyFromMemory(internalImage, Width * 4); } catch (Exception ex) { Console.WriteLine(ex.Message); } } }
/// <summary> /// Constructs a renderable 2D image from a color structure array. /// </summary> /// <param name="window">A reference to the Direct3D-capable window in which this texture will be rendered.</param> /// <param name="image">An array of size [HEIGHT, WIDTH] where each element represents a color formatted from RGBA bytes.</param> public ImageDX(Window3D window, Color[,] image) : base(window) { Height = image.GetLength(0); Width = image.GetLength(1); int byteSize = (int)Height * (int)Width * sizeof(int); using (DataStream bmpStream = new DataStream(byteSize, true, true)) { foreach (Color color in image) { bmpStream.Write((int)color); } bmpStream.Position = 0; BitmapProperties bmpProps = new BitmapProperties(RenderTarget.PixelFormat); int stride = (int)Width * sizeof(int); Bitmap = new Bitmap(RenderTarget, new Size2((int)Width, (int)Height), bmpStream, stride, bmpProps); Crop = new RectangleF(0, 0, Width, Height); } }
/// <summary> /// Converts a <see cref="System.Drawing.Bitmap"/> object into a <see cref="SharpDX.Direct2D1.Bitmap"/> object for rendering. /// </summary> /// <param name="renderTarget">The <see cref="SharpDX.Direct2D1.RenderTarget"/> object that images are drawn on.</param> /// <param name="bmp">The .NET native bitmap image.</param> /// <returns>A <see cref="SharpDX.Direct2D1.Bitmap"/> containing the image data retrieved from the <see cref="System.Drawing.Bitmap"/> object.</returns> public static Bitmap FromSysBMP(RenderTarget renderTarget, SystemBitmap bmp) { var imageArea = new System.Drawing.Rectangle(0, 0, bmp.Width, bmp.Height); var bmpProps = new BitmapProperties(new SharpDX.Direct2D1.PixelFormat(Format.R8G8B8A8_UNorm, AlphaMode.Premultiplied)); // Unmanaged buffer needs proper disposal using (var dataStream = new DataStream(bmp.ByteSize(), true, true)) { var bmpData = bmp.LockBits(imageArea, ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppPArgb); for (int y = 0; y < bmp.Height; y++) { int offset = y * bmpData.Stride; for (int x = 0; x < bmp.Width; x++) { // System bitmaps store pixel values as BGRA byte arrays byte b = Marshal.ReadByte(bmpData.Scan0, offset++); byte g = Marshal.ReadByte(bmpData.Scan0, offset++); byte r = Marshal.ReadByte(bmpData.Scan0, offset++); byte a = Marshal.ReadByte(bmpData.Scan0, offset++); // Convert BGRA to RGBA (stored as a 32 bit = 4 byte integer) int rgba = r | (g << 8) | (b << 16) | (a << 24); // Write the RGBA value to the data buffer dataStream.Write(rgba); } } // Release the lock on the bitmap & reset the buffer position pointer bmp.UnlockBits(bmpData); dataStream.Position = 0; return new Bitmap(renderTarget, new Size2(bmp.Width, bmp.Height), dataStream, bmpData.Stride, bmpProps); } }
TextureAsset IAssetManager.LoadTexture(string file) { Bitmap result = null; if (_bitmapResources.TryGetValue(file, out result) && !result.IsDisposed) return new TextureAsset(result); Stream stream; if (File.Exists(RootDirectory + file)) stream = File.OpenRead(RootDirectory + file); else if (File.Exists(file)) stream = File.OpenRead(file); else { stream = (from assembly in AppDomain.CurrentDomain.GetAssemblies() from name in assembly.GetManifestResourceNames() where String.Compare(file, name, true) != 0 select assembly.GetManifestResourceStream(name)).FirstOrDefault(); } if (stream == null) { Console.Error.WriteLine("Failed to load bitmap asset: {0}", file); // TODO: Have some sort of placeholder texture to feed back, even a single pixel return null; } try { using (var newBitmap = new System.Drawing.Bitmap(stream)) { var sourceArea = new System.Drawing.Rectangle(0, 0, newBitmap.Width, newBitmap.Height); var bitmapProperties = new BitmapProperties(new PixelFormat(Format.R8G8B8A8_UNorm, AlphaMode.Premultiplied)); var size = new DrawingSize(newBitmap.Width, newBitmap.Height); // Transform pixels from BGRA to RGBA int stride = newBitmap.Width * sizeof(int); using (var tempStream = new DataStream(newBitmap.Height * stride, true, true)) { // Lock System.Drawing.Bitmap var bitmapData = newBitmap.LockBits(sourceArea, System.Drawing.Imaging.ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppPArgb); // Convert all pixels for (int y = 0; y < newBitmap.Height; y++) { int offset = bitmapData.Stride * y; for (int x = 0; x < newBitmap.Width; x++) { // Not optimized byte B = Marshal.ReadByte(bitmapData.Scan0, offset++); byte G = Marshal.ReadByte(bitmapData.Scan0, offset++); byte R = Marshal.ReadByte(bitmapData.Scan0, offset++); byte A = Marshal.ReadByte(bitmapData.Scan0, offset++); int rgba = R | (G << 8) | (B << 16) | (A << 24); tempStream.Write(rgba); } } newBitmap.UnlockBits(bitmapData); tempStream.Position = 0; try { result = new Bitmap(_renderTarget2D, size, tempStream, stride, bitmapProperties); } catch (NullReferenceException) { throw new AssetLoadException("Graphics device uninitialized"); } } } } catch (ArgumentException) { Console.Error.WriteLine("Invalid data stream while loading bitmap data"); } finally { stream.Dispose(); } _bitmapResources.AddOrUpdate(file, result, (key, oldValue) => { if (!oldValue.IsDisposed) oldValue.Dispose(); return result; }); return new TextureAsset(result); }
internal static Bitmap ToSharpDXBitmap(RenderTarget rt, System.Drawing.Bitmap image, float symbolScale) { if (image == null) throw new ArgumentNullException("image"); if (image.PixelFormat != GdiPixelFormat.Format32bppPArgb) return null; var imageData = image.LockBits(new System.Drawing.Rectangle(0, 0, image.Width, image.Height), System.Drawing.Imaging.ImageLockMode.ReadOnly, image.PixelFormat); var dataStream = new DataStream(imageData.Scan0, imageData.Stride*imageData.Height, true, false); var properties = new BitmapProperties { PixelFormat = new SharpDX.Direct2D1.PixelFormat { Format = SharpDX.DXGI.Format.B8G8R8A8_UNorm, AlphaMode = AlphaMode.Premultiplied } }; // ToDo apply scaling here! //var scaler = new BitmapScaler(rt.Factory.NativePointer); //scaler. //Load the image from the gdi resource var result = new Bitmap(rt, new Size2(image.Width, image.Height), dataStream, imageData.Stride, properties); image.UnlockBits(imageData); return result; }
public override void Load(CanvasRenderArguments args) { // set the properties of the image BitmapProperties bitmapProps = new BitmapProperties(); bitmapProps.PixelFormat = new SharpDX.Direct2D1.PixelFormat(SharpDX.DXGI.Format.B8G8R8A8_UNorm, AlphaMode.Premultiplied); if (mImageBitmap == null) { // make the bitmap for Direct2D1 mImageBitmap = new SharpDX.Direct2D1.Bitmap(args.renderTarget, new Size2(Width, Height), bitmapProps); } // write to the specific bitmap not create a new one mImageBitmap.CopyFromMemory(internalImage, Pitch); }
private void UpdateMapFallback(string continent) { var textureData = new uint[Width * Height]; for (var i = 0; i < 64; ++i) { for (var j = 0; j < 64; ++j) { var exists = FileManager.Instance.Provider.Exists(string.Format(@"World\Maps\{0}\{0}_{1}_{2}.adt", continent, j, i)); if (exists) { for (var k = 0; k < 17; ++k) { for (var l = 0; l < 17; ++l) textureData[(i * 17 + k) * (64 * 17) + j * 17 + l] = 0xFFFFFFFF; } } } } var bmpProps = new BitmapProperties(new PixelFormat(SharpDX.DXGI.Format.B8G8R8A8_UNorm, AlphaMode.Ignore)); using (var dataStream = new DataStream(Width * Height * 4, true, true)) { dataStream.WriteRange(textureData); dataStream.Position = 0; mImage = new Bitmap(InterfaceManager.Instance.Surface.RenderTarget, new Size2(Width, Height), new DataPointer(dataStream.DataPointer, Width * Height * 4), Width * 4, bmpProps); } }
private static Bitmap CreateBitmap(RenderTarget renderTarget, string key, Size2 size, Color4 color, Func<int, int, bool> pred) { if (!ImageCash.ContainsKey(key)) { var imageInt = new int[size.Width * size.Height]; // Convert all pixels for (int y = 0; y < size.Height; y++) { for (int x = 0; x < size.Width; x++) { var rgba = pred(y, x) ? FromColor4(color) : 0; imageInt[size.Width * y + x] = rgba; } } ImageCash.Add(key, imageInt); } int stride = size.Width * sizeof(int); using (var tempStream = new DataStream(stride * size.Height, true, true)) { var bitmapProperties = new BitmapProperties(new PixelFormat(Format.R8G8B8A8_UNorm, SharpDX.Direct2D1.AlphaMode.Premultiplied)); var cash = ImageCash[key]; foreach (int t in cash) { tempStream.Write(t); } tempStream.Position = 0; return new Bitmap(renderTarget, size, tempStream, stride, bitmapProperties); } }
/// <summary> /// System.Drawing.ImageからSharpDX.Direct2D1.Bitmapを作成する /// </summary> /// <param name="renderTarget"></param> /// <param name="bitmap"></param> /// <returns></returns> public static Bitmap LoadFromImage(RenderTarget renderTarget, string key, System.Drawing.Bitmap bitmap) { if (!ImageCash.ContainsKey(key)) { var sourceArea = new System.Drawing.Rectangle(0, 0, bitmap.Width, bitmap.Height); var imageint = new int[bitmap.Width * bitmap.Height]; // Lock System.Drawing.Bitmap var bitmapData = bitmap.LockBits(sourceArea, ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppPArgb); // Convert all pixels for (int y = 0; y < bitmap.Height; y++) { int offset = bitmapData.Stride * y; for (int x = 0; x < bitmap.Width; x++) { // Not optimized byte B = Marshal.ReadByte(bitmapData.Scan0, offset++); byte G = Marshal.ReadByte(bitmapData.Scan0, offset++); byte R = Marshal.ReadByte(bitmapData.Scan0, offset++); byte A = Marshal.ReadByte(bitmapData.Scan0, offset++); int rgba = R | (G << 8) | (B << 16) | (A << 24); imageint[bitmap.Width * y + x] = rgba; } } bitmap.UnlockBits(bitmapData); ImageCash.Add(key, imageint); } // Transform pixels from BGRA to RGBA int stride = bitmap.Width * sizeof(int); using (var tempStream = new DataStream(bitmap.Height * stride, true, true)) { var bitmapProperties = new BitmapProperties(new PixelFormat(Format.R8G8B8A8_UNorm, SharpDX.Direct2D1.AlphaMode.Premultiplied)); var size = new Size2(bitmap.Width, bitmap.Height); var cash = ImageCash[key]; foreach (var rgba in cash) { tempStream.Write(rgba); } tempStream.Position = 0; return new Bitmap(renderTarget, size, tempStream, stride, bitmapProperties); } }
private static void ConfigureBitmap(out BitmapProperties description) { description.DpiX = 96.0f; description.DpiY = 96.0f; description.PixelFormat = PixelFormat; }
/// <summary> /// Run our application until the user quits. /// </summary> public void Run() { // Make window active and hide mouse cursor. window.PointerCursor = null; window.Activate(); // Infinite loop to prevent the application from exiting. while (true) { // Dispatch all pending events in the queue. window.Dispatcher.ProcessEvents(CoreProcessEventsOption.ProcessAllIfPresent); // Quit if the users presses Escape key. if (window.GetAsyncKeyState(VirtualKey.Escape) == CoreVirtualKeyStates.Down) { return; } int WIDTH = 1280; int HEIGHT = 800; Mandelbrot engine = new BasicMandelbrot(64); MandelbrotView view = new StaticMandelbrotView(engine, -.875f, 0f, 3f, WIDTH, HEIGHT); // Set the Direct2D drawing target. d2dContext.Target = d2dTarget; int[] data = new int[WIDTH * HEIGHT]; for (int y = 0; y < HEIGHT; y++) { for (int x = 0; x < WIDTH; x++) { float val = view.pixelAt(x, y); int intVal = (int)(255 * val); data[y * WIDTH + x] = 0 | intVal << 16 | intVal << 8 | intVal; } } DrawingSize size = new DrawingSize(WIDTH, HEIGHT); PixelFormat format = new PixelFormat(Format.B8G8R8A8_UNorm, SharpDX.Direct2D1.AlphaMode.Ignore); BitmapProperties props = new BitmapProperties(format); RenderTarget target = d2dContext; Bitmap buf = Bitmap.New<int>(target, size, data, props); // Clear the target and draw some geometry with the brushes we created. Note that rectangles are // created specifying (start-x, start-y, end-x, end-y) coordinates; in XNA we used // (start-x, start-y, width, height). d2dContext.BeginDraw(); d2dContext.DrawBitmap(buf, 1, BitmapInterpolationMode.Linear); d2dContext.EndDraw(); // Present the current buffer to the screen. swapChain.Present(1, PresentFlags.None); } }