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);
}
private static void DrawSmallRaw(Person person, WIC.ImagingFactory wic, D2D.Factory d2dFactory,
WIC.FormatConverter converter)
{
var whRate = 1.0f * converter.Size.Width / converter.Size.Height;
var smallRawSize = new Vector2(whRate * ImageDefines.SmallRawY, ImageDefines.SmallRawY);
var scale = ImageDefines.SmallRawY / converter.Size.Height;
using (var wicBitmap = new WIC.Bitmap(wic,
(int)smallRawSize.X, (int)smallRawSize.Y,
WIC.PixelFormat.Format32bppPBGRA,
WIC.BitmapCreateCacheOption.CacheOnDemand))
using (var target = new D2D.WicRenderTarget(d2dFactory,
wicBitmap, new D2D.RenderTargetProperties()))
using (var bmp = D2D.Bitmap.FromWicBitmap(target, converter))
using (var bmpBrush = new D2D.BitmapBrush(target, bmp))
{
target.BeginDraw();
target.Transform = Matrix3x2.Scaling(scale, scale);
target.DrawBitmap(bmp, 1.0f, D2D.BitmapInterpolationMode.Linear);
target.EndDraw();
using (var file = File.Create(person.SmallRawImage))
{
WicTools.SaveD2DBitmap(wic, wicBitmap, file);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="BitmapEncoder"/> class.
/// </summary>
/// <param name="factory">The factory.</param>
/// <param name="containerFormatGuid">The container format GUID. List from <see cref="ContainerFormatGuids"/> </param>
/// <param name="stream">A stream to use as the output of this bitmap encoder.</param>
/// <unmanaged>HRESULT IWICImagingFactory::CreateEncoder([In] const GUID& guidContainerFormat,[In, Optional] const GUID* pguidVendor,[Out] IWICBitmapEncoder** ppIEncoder)</unmanaged>
public BitmapEncoder(ImagingFactory factory, Guid containerFormatGuid, System.IO.Stream stream = null)
{
this.factory = factory;
factory.CreateEncoder(containerFormatGuid, null, this);
if (stream != null)
Initialize(stream);
}
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);
}
public ShaderResourceView LoadBitmapShaderResource(System.Drawing.Bitmap btm)
{
ShaderResourceView res = null;
try {
var ms = new MemoryStream();
btm.Save(ms, System.Drawing.Imaging.ImageFormat.Png);
ms.Position = 0;
var factory = new SharpDX.WIC.ImagingFactory();
var bitmapDecoder = new BitmapDecoder(factory, ms, DecodeOptions.CacheOnDemand);
var result = new FormatConverter(factory);
result.Initialize(bitmapDecoder.GetFrame(0), PixelFormat.Format32bppPRGBA, BitmapDitherType.None,
null, 0.0, BitmapPaletteType.Custom);
using (var texture = CreateTexture2DFromBitmap(device, result)) {
var srvDesc = new ShaderResourceViewDescription()
{
Format = texture.Description.Format,
Dimension = SharpDX.Direct3D.ShaderResourceViewDimension.Texture2D,
};
srvDesc.Texture2D.MostDetailedMip = 0;
srvDesc.Texture2D.MipLevels = -1;
res = new ShaderResourceView(device, texture, srvDesc);
device.ImmediateContext.GenerateMips(res);
}
// TextureResource = ShaderResourceView.FromFile(device, fileName);
} catch (Exception ex) {
System.Diagnostics.Trace.WriteLine($"TexturedLoader {ex.Message}");
}
return(res);
}
internal static ColorContext[] GetColorContexts(ColorContextsProvider getColorContexts, ImagingFactory imagingFactory)
{
ColorContext[] colorContexts;
Result result = TryGetColorContexts(getColorContexts, imagingFactory, out colorContexts);
result.CheckError();
return colorContexts;
}
public Direct2DFactories()
{
WICFactory = new WIC.ImagingFactory();
DWFactory = new DW.Factory();
var d3DDevice = new D3D11.Device(
D3D.DriverType.Hardware,
D3D11.DeviceCreationFlags.BgraSupport
#if DEBUG
| D3D11.DeviceCreationFlags.Debug
#endif
,
D3D.FeatureLevel.Level_11_1,
D3D.FeatureLevel.Level_11_0,
D3D.FeatureLevel.Level_10_1,
D3D.FeatureLevel.Level_10_0,
D3D.FeatureLevel.Level_9_3,
D3D.FeatureLevel.Level_9_2,
D3D.FeatureLevel.Level_9_1
);
var dxgiDevice = ComObject.As <SharpDX.DXGI.Device> (d3DDevice.NativePointer);
var d2DDevice = new D2D1.Device(dxgiDevice);
D2DFactory = d2DDevice.Factory;
//_d2DDeviceContext = new D2D1.DeviceContext (d2DDevice, D2D1.DeviceContextOptions.None);
//var dpi = DisplayDpi;
//_d2DDeviceContext.DotsPerInch = new Size2F (dpi, dpi);
}
internal static Result TryGetColorContexts(ColorContextsProvider getColorContexts, ImagingFactory imagingFactory, out ColorContext[] colorContexts)
{
colorContexts = null;
int count;
Result result = getColorContexts(0, null, out count);
if (result.Success)
{
colorContexts = new ColorContext[count];
if (count > 0)
{
// http://msdn.microsoft.com/en-us/library/windows/desktop/ee690135(v=vs.85).aspx
// The ppIColorContexts array must be filled with valid data: each IWICColorContext* in the array must
// have been created using IWICImagingFactory::CreateColorContext.
for (int i = 0; i < count; i++)
colorContexts[i] = new ColorContext(imagingFactory);
int actualCount;
getColorContexts(count, colorContexts, out actualCount);
Debug.Assert(count == actualCount);
}
}
return result;
}
public Direct2DFactories()
{
WICFactory = new WIC.ImagingFactory ();
DWFactory = new DW.Factory ();
var d3DDevice = new D3D11.Device (
D3D.DriverType.Hardware,
D3D11.DeviceCreationFlags.BgraSupport
#if DEBUG
| D3D11.DeviceCreationFlags.Debug
#endif
,
D3D.FeatureLevel.Level_11_1,
D3D.FeatureLevel.Level_11_0,
D3D.FeatureLevel.Level_10_1,
D3D.FeatureLevel.Level_10_0,
D3D.FeatureLevel.Level_9_3,
D3D.FeatureLevel.Level_9_2,
D3D.FeatureLevel.Level_9_1
);
var dxgiDevice = ComObject.As<SharpDX.DXGI.Device> (d3DDevice.NativePointer);
var d2DDevice = new D2D1.Device (dxgiDevice);
D2DFactory = d2DDevice.Factory;
//_d2DDeviceContext = new D2D1.DeviceContext (d2DDevice, D2D1.DeviceContextOptions.None);
//var dpi = DisplayDpi;
//_d2DDeviceContext.DotsPerInch = new Size2F (dpi, dpi);
}
private D2D(Direct2D.Factory d2dFactory, Direct2D.RenderTarget d2dRenderTarget)
{
this.d2dFactory = d2dFactory;
this.d2dRenderTarget = d2dRenderTarget;
this.wicFactory = new WIC.ImagingFactory();
this.dwFactory = new DW.Factory();
}
public static void CreateIndependentResource()
{
d2d1factory = new Direct2D1.Factory();
imageFactory = new WIC.ImagingFactory();
writeFactory = new DirectWrite.Factory();
Ready = true;
}
public static void LoadSource(Stream str, UIImage img)
{
Wic.ImagingFactory fac = ThreadResource.GetWicFactory();
var d = new Wic.BitmapDecoder(fac, str, Wic.DecodeOptions.CacheOnLoad);
if (img.data != null)
{
ClearResource(img);
}
img.data = str;
img.Decoder = d;
var frame = d.GetFrame(0);
img.FrameDecoder = frame;
var fconv = new Wic.FormatConverter(fac);
fconv.Initialize(frame, Wic.PixelFormat.Format32bppPRGBA);
img.Bitmap = fconv;
img.Mapsize.Left = 0;
img.Mapsize.Top = 0;
img.Mapsize.Right = img.Bitmap.Size.Width;
img.Mapsize.Bottom = img.Bitmap.Size.Height;
lock (DX_Core.D2D)
img.d2dmap = D2D1.Bitmap.FromWicBitmap(DX_Core.D2D.d2dContext, img.Bitmap);
}
/// <summary>
/// Initializes instance members of the <see cref="GifRecorder"/> class.
/// </summary>
public GifRecorder()
{
GifRepeatCount = 0;
_imagingFactory = new ImagingFactory();
_frames = new List<BitmapFrame>();
MaxFramePerSecond = 8;
_desktopManager = new DesktopManager();
}
public static void Initialize() {
lock (SyncObject) {
if (!_isInitailized) {
_factory = new ImagingFactory();
_isInitailized = true;
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="WICStream"/> class from a <see cref="IStream"/>.
/// </summary>
/// <param name="factory">The factory.</param>
/// <param name="stream">The stream.</param>
/// <msdn-id>ee719789</msdn-id>
/// <unmanaged>HRESULT IWICStream::InitializeFromIStream([In, Optional] IStream* pIStream)</unmanaged>
/// <unmanaged-short>IWICStream::InitializeFromIStream</unmanaged-short>
public WICStream(ImagingFactory factory, Stream stream)
: base(IntPtr.Zero)
{
factory.CreateStream(this);
streamProxy = new ComStreamProxy(stream);
var istreamPtr = ComStreamShadow.ToIntPtr(streamProxy);
InitializeFromIStream_(istreamPtr);
}
public BitmapImpl(ImagingFactory factory, string fileName)
{
this.factory = factory;
using (BitmapDecoder decoder = new BitmapDecoder(factory, fileName, DecodeOptions.CacheOnDemand))
{
this.WicImpl = new Bitmap(factory, decoder.GetFrame(0), BitmapCreateCacheOption.CacheOnDemand);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="BitmapImpl"/> class.
/// </summary>
/// <param name="factory">The WIC imaging factory to use.</param>
/// <param name="stream">The stream to read the bitmap from.</param>
public BitmapImpl(ImagingFactory factory, Stream stream)
{
_factory = factory;
using (BitmapDecoder decoder = new BitmapDecoder(factory, stream, DecodeOptions.CacheOnLoad))
{
WicImpl = new Bitmap(factory, decoder.GetFrame(0), BitmapCreateCacheOption.CacheOnLoad);
}
}
internal static ColorContext[] TryGetColorContexts(ColorContextsProvider getColorContexts, ImagingFactory imagingFactory)
{
ColorContext[] colorContexts;
Result result = TryGetColorContexts(getColorContexts, imagingFactory, out colorContexts);
if (ResultCode.UnsupportedOperation != result)
result.CheckError();
return colorContexts;
}
public CCLabel_Renderer81()
{
var d2dFactory = CreateD2DFactory();
var newDevice = CreateDevice();
CreateRenderingResources(newDevice, d2dFactory);
FactoryImaging = new SharpDX.WIC.ImagingFactory();
}
public BitmapImpl(ImagingFactory factory, int width, int height)
{
this.factory = factory;
this.WicImpl = new Bitmap(
factory,
width,
height,
PixelFormat.Format32bppPBGRA,
BitmapCreateCacheOption.CacheOnLoad);
}
public CCLabel_Renderer81()
{
var d2dFactory = CreateD2DFactory();
var newDevice = CreateDevice();
CreateRenderingResources(newDevice, d2dFactory);
FactoryImaging = new SharpDX.WIC.ImagingFactory();
}
public static BitmapSource CreateWicBitmap(Stream str)
{
BitmapSource bs = new BitmapSource();
Wic.ImagingFactory fac = ThreadResource.GetWicFactory();
bs.Decoder = new Wic.BitmapDecoder(fac, str, Wic.DecodeOptions.CacheOnLoad);
bs.FrameDecoder = bs.Decoder.GetFrame(0);
bs.Converter = new Wic.FormatConverter(fac);
bs.Converter.Initialize(bs.FrameDecoder, Wic.PixelFormat.Format32bppPRGBA);
return(bs);
}
public PngImageResource(WIC.ImagingFactory imagingFactory, string path)
{
using (var decoder = new WIC.PngBitmapDecoder(imagingFactory))
{
using (var inputStream = new WIC.WICStream(imagingFactory, path, NativeFileAccess.Read))
decoder.Initialize(inputStream, WIC.DecodeOptions.CacheOnLoad);
FormatConverter = new WIC.FormatConverter(imagingFactory);
FormatConverter.Initialize(decoder.GetFrame(0), WIC.PixelFormat.Format32bppPRGBA);
}
}
private static void LoadBitmaps()
{
var fac = new SharpDX.WIC.ImagingFactory();
var target = GraphicsWindow.Instance.RenderTarget2D;
var stream = new NativeFileStream(Application.StartupPath + "\\Images\\Ship 1.png", NativeFileMode.Open, NativeFileAccess.Read);
var decoder = new BitmapDecoder(fac, stream, DecodeOptions.CacheOnDemand);
var frame = decoder.GetFrame(0);
var converter = new FormatConverter(fac);
converter.Initialize(frame, SharpDX.WIC.PixelFormat.Format32bppPRGBA);
BitShip1 = Bitmap1.FromWicBitmap(GraphicsWindow.Instance.RenderTarget2D, converter);
}
public static byte[] LoadImage(string fileName, bool premultiplied, out int width, out int height)
{
WIC.ImagingFactory factory = new WIC.ImagingFactory();
SharpDX.IO.NativeFileStream stream = new SharpDX.IO.NativeFileStream(fileName, SharpDX.IO.NativeFileMode.Open, SharpDX.IO.NativeFileAccess.Read);
WIC.BitmapDecoder decoder = new WIC.BitmapDecoder(factory, stream, WIC.DecodeOptions.CacheOnDemand);
WIC.BitmapFrameDecode frame = decoder.GetFrame(0);
width = frame.Size.Width;
height = frame.Size.Height;
byte[] data = new byte[width * height * 4];
frame.CopyPixels(data, width * 4);
return(data);
}
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);
}
}
public static D2D.Bitmap LoadFromFile(D2D.RenderTarget renderTarget, string filePath)
{
WIC.ImagingFactory imagingFactory = new WIC.ImagingFactory();
DXIO.NativeFileStream fileStream = new DXIO.NativeFileStream(filePath,
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);
return(D2D.Bitmap.FromWicBitmap(RenderForm.RenderTarget, converter));
}
public static WIC.FormatConverter CreateWicImage(WIC.ImagingFactory wic, string filename)
{
using (var decoder = new WIC.JpegBitmapDecoder(wic))
using (var decodeStream = new WIC.WICStream(wic, filename, NativeFileAccess.Read))
{
decoder.Initialize(decodeStream, WIC.DecodeOptions.CacheOnDemand);
using (var decodeFrame = decoder.GetFrame(0))
{
var converter = new WIC.FormatConverter(wic);
converter.Initialize(decodeFrame, WIC.PixelFormat.Format32bppPBGRA);
return(converter);
}
}
}
private static Direct2D1.Bitmap1 CreateD2dBitmap(
WIC.ImagingFactory imagingFactory,
string filename,
Direct2D1.DeviceContext renderTarget)
{
var decoder = new WIC.BitmapDecoder(imagingFactory, filename, WIC.DecodeOptions.CacheOnLoad);
WIC.BitmapFrameDecode frame = decoder.GetFrame(0);
var image = new WIC.FormatConverter(imagingFactory);
image.Initialize(frame, WIC.PixelFormat.Format32bppPBGRA);
return(Direct2D1.Bitmap1.FromWicBitmap(renderTarget, image));
}
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)));
}
private static void DoImageProcessWIC()
{
using (var wic = new WIC.ImagingFactory())
using (var d2dFactory = new D2D.Factory(D2D.FactoryType.MultiThreaded))
{
var db = new LotteryDatabase("state.json");
Parallel.ForEach(db.GetAllPerson(), person =>
{
using (var converter = WicTools.CreateWicImage(wic, person.RawImage))
{
DrawPsd(person, wic, d2dFactory, converter);
//DrawSmallRaw(person, wic, d2dFactory, converter);
}
});
}
}
private void InitializeTextures()
{
// Setup standard sampler
samplerState = new D3D11.SamplerState(d3dDevice, new D3D11.SamplerStateDescription()
{
AddressU = D3D11.TextureAddressMode.Wrap,
AddressV = D3D11.TextureAddressMode.Wrap,
AddressW = D3D11.TextureAddressMode.Wrap,
Filter = D3D11.Filter.MinMagMipLinear
});
imagingFactory = new SharpDX.WIC.ImagingFactory();
// Load textures. For now just one test texture
textureView = LoadTexture("texture.png");
}
public RenderTargetBitmapImpl(
ImagingFactory imagingFactory,
Factory d2dFactory,
int width,
int height)
: base(imagingFactory, width, height)
{
this.target = new WicRenderTarget(
d2dFactory,
this.WicImpl,
new RenderTargetProperties
{
DpiX = 96,
DpiY = 96,
});
}
/// <summary>
/// Releases unmanaged and - optionally - managed resources.
/// </summary>
/// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
private void Dispose(bool disposing)
{
if (_disposed)
{
return;
}
if (disposing)
{
if (Factory != null)
{
Factory.Dispose();
}
}
Factory = null;
_disposed = true;
}
public RenderTargetBitmapImpl(
ImagingFactory imagingFactory,
Factory d2dFactory,
int width,
int height)
: base(imagingFactory, width, height)
{
var props = new RenderTargetProperties
{
DpiX = 96,
DpiY = 96,
};
_target = new WicRenderTarget(
d2dFactory,
WicImpl,
props);
}
public static void SaveD2DBitmap(WIC.ImagingFactory wic, WIC.Bitmap wicBitmap, Stream outputStream)
{
using (var encoder = new WIC.BitmapEncoder(wic, WIC.ContainerFormatGuids.Png))
{
encoder.Initialize(outputStream);
using (var frame = new WIC.BitmapFrameEncode(encoder))
{
frame.Initialize();
frame.SetSize(wicBitmap.Size.Width, wicBitmap.Size.Height);
var pixelFormat = wicBitmap.PixelFormat;
frame.SetPixelFormat(ref pixelFormat);
frame.WriteSource(wicBitmap);
frame.Commit();
encoder.Commit();
}
}
}
//private string CreateFont(string fontName, float fontSize, CCRawList<char> charset)
private Font CreateFont(string fontName, float fontSize)
{
Font _currentFont;
if (Factory2D == null)
{
Factory2D = new SharpDX.Direct2D1.Factory();
FactoryDWrite = new SharpDX.DirectWrite.Factory();
FactoryImaging = new SharpDX.WIC.ImagingFactory();
dpi = Factory2D.DesktopDpi;
dpiScale = dpi.Height / 72f;
}
_currentFontCollection = FactoryDWrite.GetSystemFontCollection(true);
if (_defaultFont == null)
{
_defaultFont = GenericSanSerif();
}
FontFamily fontFamily = GetFontFamily(fontName);
if (!_fontFamilyCache.TryGetValue(fontName, out fontFamily))
{
var ext = Path.GetExtension(fontName);
_currentFont = _defaultFont;
_currentFont = GetFont(fontName, fontSize);
_fontFamilyCache.Add(fontName, _currentFont.FontFamily);
CCLog.Log("{0} not found. Defaulting to {1}.", fontName, _currentFont.FontFamily.FamilyNames.GetString(0));
}
else
{
_currentFont = fontFamily.GetFirstMatchingFont(FontWeight.Regular, FontStretch.Normal, FontStyle.Normal);
}
return(_currentFont);
}
Bitmap1 createD2DBitmap(string filePath, _d2d.DeviceContext deviceContext)
{
var imagingFactory = new _wic.ImagingFactory();
var fileStream = new NativeFileStream(
filePath,
NativeFileMode.Open,
NativeFileAccess.Read);
var bitmapDecoder = new _wic.BitmapDecoder(imagingFactory, fileStream, _wic.DecodeOptions.CacheOnDemand);
var frame = bitmapDecoder.GetFrame(0);
var converter = new _wic.FormatConverter(imagingFactory);
converter.Initialize(frame, SharpDX.WIC.PixelFormat.Format32bppPRGBA);
var newBitmap = SharpDX.Direct2D1.Bitmap1.FromWicBitmap(deviceContext, converter);
return(newBitmap);
}
public Direct2D1RenderTargetBitmap(
Factory d2dFactory,
ImagingFactory wicFactory,
SharpDX.WIC.Bitmap bitmap)
: base(wicFactory, bitmap)
{
double dpiX;
double dpiY;
this.d2dFactory = d2dFactory;
bitmap.GetResolution(out dpiX, out dpiY);
this.target = new WicRenderTarget(
d2dFactory,
bitmap,
new RenderTargetProperties
{
DpiX = (float)dpiX,
DpiY = (float)dpiY,
});
}
private static void DrawPsd(Person person, WIC.ImagingFactory wic, D2D.Factory d2dFactory,
WIC.FormatConverter converter)
{
using (var wicBitmap = new WIC.Bitmap(wic,
(int)ImageDefines.Size, (int)ImageDefines.Size,
WIC.PixelFormat.Format32bppPBGRA,
WIC.BitmapCreateCacheOption.CacheOnDemand))
using (var target = new D2D.WicRenderTarget(d2dFactory,
wicBitmap, new D2D.RenderTargetProperties()))
using (var color = new D2D.SolidColorBrush(target, SexColor[person.Sex]))
using (var bmp = D2D.Bitmap.FromWicBitmap(target, converter))
using (var bmpBrush = new D2D.BitmapBrush(target, bmp))
{
target.BeginDraw();
var offset = (ImageDefines.Size - ImageDefines.RealSize) / 2;
bmpBrush.Transform = Matrix3x2.Scaling(
ImageDefines.RealSize / bmp.Size.Width,
ImageDefines.RealSize / (bmp.Size.Height - 497.0f))
* Matrix3x2.Translation(offset, offset);
target.FillEllipse(new D2D.Ellipse(
new Vector2(ImageDefines.Size / 2.0f, ImageDefines.Size / 2.0f),
ImageDefines.RealSize / 2.0f,
ImageDefines.RealSize / 2.0f),
bmpBrush);
target.DrawEllipse(new D2D.Ellipse(
new Vector2(ImageDefines.Size / 2.0f, ImageDefines.Size / 2.0f),
ImageDefines.RealSize / 2.0f,
ImageDefines.RealSize / 2.0f),
color, ImageDefines.LineWidth);
target.EndDraw();
using (var file = File.Create(person.PsdImage))
{
WicTools.SaveD2DBitmap(wic, wicBitmap, file);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="BitmapDecoder"/> class from a <see cref="IStream"/>.
/// </summary>
/// <param name="factory">The factory.</param>
/// <param name="streamRef">The stream ref.</param>
/// <param name="guidVendorRef">The GUID vendor ref.</param>
/// <param name="metadataOptions">The metadata options.</param>
/// <unmanaged>HRESULT IWICImagingFactory::CreateDecoderFromStream([In, Optional] IStream* pIStream,[In, Optional] const GUID* pguidVendor,[In] WICDecodeOptions metadataOptions,[Out, Fast] IWICBitmapDecoder** ppIDecoder)</unmanaged>
public BitmapDecoder(ImagingFactory factory, IStream streamRef, System.Guid guidVendorRef, SharpDX.WIC.DecodeOptions metadataOptions)
{
factory.CreateDecoderFromStream_(ComStream.ToIntPtr(streamRef), guidVendorRef, metadataOptions, this);
}
//private string CreateFont(string fontName, float fontSize, CCRawList<char> charset)
private Font CreateFont(string fontName, float fontSize)
{
Font _currentFont;
if (Factory2D == null)
{
Factory2D = new SharpDX.Direct2D1.Factory();
FactoryDWrite = new SharpDX.DirectWrite.Factory();
FactoryImaging = new SharpDX.WIC.ImagingFactory();
dpi = Factory2D.DesktopDpi;
dpiScale = dpi.Height / 72f;
}
_currentFontCollection = FactoryDWrite.GetSystemFontCollection(true);
if (_defaultFont == null)
{
_defaultFont = GenericSanSerif();
}
FontFamily fontFamily = GetFontFamily(fontName);
FontCollection fontCollection;
if (!_fontCollectionCache.TryGetValue(fontName, out fontCollection))
{
var ext = Path.GetExtension(fontName);
if (!String.IsNullOrEmpty(ext) && ext.ToLower() == ".ttf")
{
try
{
var fileFontLoader = new FileFontLoader(FactoryDWrite, fontName);
var fileFontCollection = new FontCollection(FactoryDWrite, fileFontLoader, fileFontLoader.Key);
_currentFontCollection = fileFontCollection;
fontFamily = _currentFontCollection.GetFontFamily(0);
var ffn = fontFamily.FamilyNames;
_currentFont = fontFamily.GetFirstMatchingFont(FontWeight.Regular, FontStretch.Normal, FontStyle.Normal);
_fontCollectionCache.Add(fontName, fileFontCollection);
_currentFontCollection = fileFontCollection;
}
catch
{
_currentFont = GetFont(fontName, fontSize);
CCLog.Log("{0} not found. Defaulting to {1}.", fontName, _currentFont.FontFamily.FamilyNames.GetString(0));
}
}
else
{
_currentFont = GetFont(fontName, fontSize);
}
}
else
{
fontFamily = fontCollection.GetFontFamily(0);
_currentFont = fontFamily.GetFirstMatchingFont(FontWeight.Regular, FontStretch.Normal, FontStyle.Normal);
_currentFontCollection = fontCollection;
}
return _currentFont;
}
/// <summary>
/// Initializes a new instance of the <see cref="ColorTransform"/> class.
/// </summary>
/// <param name="factory">The factory.</param>
/// <unmanaged>HRESULT IWICImagingFactory::CreateColorTransformer([Out, Fast] IWICColorTransform** ppIWICColorTransform)</unmanaged>
public ColorTransform(ImagingFactory factory)
: base(IntPtr.Zero)
{
factory.CreateColorTransformer(this);
}
/// <summary>
/// Initializes a new instance of the <see cref="GifBitmapDecoder"/> class.
/// </summary>
/// <param name="factory">The factory.</param>
/// <param name="guidVendorRef">The GUID vendor ref.</param>
public GifBitmapDecoder(ImagingFactory factory, Guid guidVendorRef)
: base(factory, ContainerFormatGuids.Gif, guidVendorRef)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="BmpBitmapDecoder"/> class.
/// </summary>
/// <param name="factory">The factory.</param>
public BmpBitmapDecoder(ImagingFactory factory)
: base(factory, ContainerFormatGuids.Bmp)
{
}
//private string CreateFont(string fontName, float fontSize, CCRawList<char> charset)
private Font CreateFont(string fontName, float fontSize)
{
Font _currentFont;
if (Factory2D == null)
{
Factory2D = new SharpDX.Direct2D1.Factory();
FactoryDWrite = new SharpDX.DirectWrite.Factory();
FactoryImaging = new SharpDX.WIC.ImagingFactory();
dpi = Factory2D.DesktopDpi;
dpiScale = dpi.Height / 72f;
}
_currentFontCollection = FactoryDWrite.GetSystemFontCollection(true);
if (_defaultFont == null)
{
_defaultFont = GenericSanSerif();
}
FontFamily fontFamily = GetFontFamily(fontName);
FontCollection fontCollection;
if (!_fontCollectionCache.TryGetValue(fontName, out fontCollection))
{
var ext = Path.GetExtension(fontName);
if (!String.IsNullOrEmpty(ext) && ext.ToLower() == ".ttf")
{
try
{
var fileFontLoader = new FileFontLoader(FactoryDWrite, fontName);
var fileFontCollection = new FontCollection(FactoryDWrite, fileFontLoader, fileFontLoader.Key);
_currentFontCollection = fileFontCollection;
fontFamily = _currentFontCollection.GetFontFamily(0);
var ffn = fontFamily.FamilyNames;
_currentFont = fontFamily.GetFirstMatchingFont(FontWeight.Regular, FontStretch.Normal, FontStyle.Normal);
_fontCollectionCache.Add(fontName, fileFontCollection);
_currentFontCollection = fileFontCollection;
}
catch
{
_currentFont = GetFont(fontName, fontSize);
CCLog.Log("{0} not found. Defaulting to {1}.", fontName, _currentFont.FontFamily.FamilyNames.GetString(0));
}
}
else
{
_currentFont = GetFont(fontName, fontSize);
}
}
else
{
fontFamily = fontCollection.GetFontFamily(0);
_currentFont = fontFamily.GetFirstMatchingFont(FontWeight.Regular, FontStretch.Normal, FontStyle.Normal);
_currentFontCollection = fontCollection;
}
return(_currentFont);
}
/// <summary>
/// Initializes a new instance of the <see cref="GifBitmapEncoder"/> class.
/// </summary>
/// <param name="factory">The factory.</param>
/// <param name="guidVendorRef">The GUID vendor ref.</param>
/// <param name="stream">The output stream.</param>
public GifBitmapEncoder(ImagingFactory factory, Guid guidVendorRef, WICStream stream = null)
: base(factory, ContainerFormatGuids.Gif, guidVendorRef, stream)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="BitmapDecoder"/> class from a <see cref="IStream"/>.
/// </summary>
/// <param name="factory">The factory.</param>
/// <param name="streamRef">The stream ref.</param>
/// <param name="metadataOptions">The metadata options.</param>
/// <unmanaged>HRESULT IWICImagingFactory::CreateDecoderFromStream([In, Optional] IStream* pIStream,[In, Optional] const GUID* pguidVendor,[In] WICDecodeOptions metadataOptions,[Out, Fast] IWICBitmapDecoder** ppIDecoder)</unmanaged>
public BitmapDecoder(ImagingFactory factory, Stream streamRef, SharpDX.WIC.DecodeOptions metadataOptions)
{
internalWICStream = new WICStream(factory, streamRef);
factory.CreateDecoderFromStream_(ComStream.ToIntPtr(internalWICStream), null, metadataOptions, this);
}
/// <summary>
/// Initializes a new instance of the <see cref="GifBitmapEncoder"/> class.
/// </summary>
/// <param name="factory">The factory.</param>
public GifBitmapEncoder(ImagingFactory factory)
: base(factory, ContainerFormatGuids.Gif)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="BitmapDecoder"/> class.
/// </summary>
/// <param name="factory">The factory.</param>
/// <param name="containerFormatGuid">The container format GUID.</param>
/// <param name="guidVendorRef">The GUID vendor ref.</param>
/// <unmanaged>HRESULT IWICImagingFactory::CreateDecoder([In] const GUID& guidContainerFormat,[In, Optional] const GUID* pguidVendor,[Out, Fast] IWICBitmapDecoder** ppIDecoder)</unmanaged>
public BitmapDecoder(ImagingFactory factory, Guid containerFormatGuid, System.Guid guidVendorRef)
{
factory.CreateDecoder(containerFormatGuid, guidVendorRef, this);
}
/// <summary>
/// Initializes a new instance of the <see cref="BitmapDecoder"/> class from a guid. <see cref="BitmapDecoderGuids"/> for a list of default supported decoder.
/// </summary>
/// <param name="factory">The factory.</param>
/// <param name="containerFormatGuid">The container format GUID.</param>
/// <unmanaged>HRESULT IWICImagingFactory::CreateDecoder([In] const GUID& guidContainerFormat,[In, Optional] const GUID* pguidVendor,[Out, Fast] IWICBitmapDecoder** ppIDecoder)</unmanaged>
public BitmapDecoder(ImagingFactory factory, Guid containerFormatGuid)
{
factory.CreateDecoder(containerFormatGuid, null, this);
}
/// <summary>
/// Initializes a new instance of the <see cref="BitmapDecoder"/> class from a filestream.
/// </summary>
/// <param name="factory">The factory.</param>
/// <param name="fileStream">The filename.</param>
/// <param name="guidVendorRef">The GUID vendor ref.</param>
/// <param name="metadataOptions">The metadata options.</param>
/// <unmanaged>HRESULT IWICImagingFactory::CreateDecoderFromFileHandle([In] unsigned int hFile,[In, Optional] const GUID* pguidVendor,[In] WICDecodeOptions metadataOptions,[Out, Fast] IWICBitmapDecoder** ppIDecoder)</unmanaged>
public BitmapDecoder(ImagingFactory factory, FileStream fileStream, System.Guid guidVendorRef, SharpDX.WIC.DecodeOptions metadataOptions)
{
factory.CreateDecoderFromFileHandle(fileStream.SafeFileHandle.DangerousGetHandle(), guidVendorRef, metadataOptions, this);
}
/// <summary>
/// Initializes a new instance of the <see cref="BitmapDecoder"/> class from a file.
/// </summary>
/// <param name="factory">The factory.</param>
/// <param name="filename">The filename.</param>
/// <param name="guidVendorRef">The GUID vendor ref.</param>
/// <param name="desiredAccess">The desired access.</param>
/// <param name="metadataOptions">The metadata options.</param>
/// <unmanaged>HRESULT IWICImagingFactory::CreateDecoderFromFilename([In] const wchar_t* wzFilename,[In, Optional] const GUID* pguidVendor,[In] unsigned int dwDesiredAccess,[In] WICDecodeOptions metadataOptions,[Out, Fast] IWICBitmapDecoder** ppIDecoder)</unmanaged>
public BitmapDecoder(ImagingFactory factory, string filename, System.Guid? guidVendorRef, NativeFileAccess desiredAccess, SharpDX.WIC.DecodeOptions metadataOptions)
{
factory.CreateDecoderFromFilename(filename, guidVendorRef, (int)desiredAccess, metadataOptions, this);
}
public static void CreateIndependentResource()
{
Factory2D = new Direct2D1.Factory();
imageFactory = new WIC.ImagingFactory();
writeFactory = new DirectWrite.Factory();
}
/// <summary>
/// Initializes a new instance of the <see cref="GifBitmapEncoder"/> class.
/// </summary>
/// <param name="factory">The factory.</param>
/// <param name="stream">The output stream.</param>
public GifBitmapEncoder(ImagingFactory factory, Stream stream = null)
: base(factory, ContainerFormatGuids.Gif, stream)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="BmpBitmapDecoder"/> class.
/// </summary>
/// <param name="factory">The factory.</param>
/// <param name="guidVendorRef">The GUID vendor ref.</param>
public BmpBitmapDecoder(ImagingFactory factory, Guid guidVendorRef)
: base(factory, ContainerFormatGuids.Bmp, guidVendorRef)
{
}
private string CreateFont(string fontName, float fontSize, CCRawList <char> charset)
{
if (Factory2D == null)
{
Factory2D = new SharpDX.Direct2D1.Factory();
FactoryDWrite = new SharpDX.DirectWrite.Factory();
FactoryImaging = new SharpDX.WIC.ImagingFactory();
dpi = Factory2D.DesktopDpi;
dpiScale = dpi.Height / 72f;
}
if (_defaultFont == null)
{
_defaultFont = GenericSanSerif();
//_defaultDIP = ConvertPointSizeToDIP(_defaultFontSizeEm);
}
FontFamily fontFamily = GetFontFamily(fontName);
if (!_fontFamilyCache.TryGetValue(fontName, out fontFamily))
{
var ext = Path.GetExtension(fontName);
_currentFont = _defaultFont;
if (!String.IsNullOrEmpty(ext) && ext.ToLower() == ".ttf")
{
//var appPath = AppDomain.CurrentDomain.BaseDirectory;
//var contentPath = Path.Combine(appPath, CCApplication.SharedApplication.Content.RootDirectory);
//var fontPath = Path.Combine(contentPath, fontName);
//if (File.Exists(fontPath))
//{
// try
//{
//var fontFileReference = new FontCollection(
//_loadedFonts.AddFontFile(fontPath);
// //fontFamily = _loadedFonts.Families[_loadedFonts.Families.Length - 1];
// //_currentFont = new Font(fontFamily, fontSize);
// }
// catch
// {
// _currentFont = _defaultFont;
// }
//}
//else
//{
_currentFont = _defaultFont;
_currentFontSizeEm = fontSize;
_currentDIP = ConvertPointSizeToDIP(fontSize);
//}
}
else
{
_currentFont = GetFont(fontName, fontSize);
_currentFontSizeEm = fontSize;
_currentDIP = ConvertPointSizeToDIP(fontSize);
}
_fontFamilyCache.Add(fontName, _currentFont.FontFamily);
}
else
{
_currentFont = fontFamily.GetFirstMatchingFont(FontWeight.Regular, FontStretch.Normal, FontStyle.Normal);
_currentFontSizeEm = fontSize;
_currentDIP = ConvertPointSizeToDIP(fontSize);
}
fontName = _currentFont.FontFamily.FamilyNames.GetString(0);
textFormat = new TextFormat(FactoryDWrite, fontName, _currentDIP);
GetKerningInfo(charset);
return(_currentFont.ToString());
}
private string CreateFont(string fontName, float fontSize, CCRawList<char> charset)
{
if (Factory2D == null)
{
Factory2D = new SharpDX.Direct2D1.Factory();
FactoryDWrite = new SharpDX.DirectWrite.Factory();
FactoryImaging = new SharpDX.WIC.ImagingFactory();
dpi = Factory2D.DesktopDpi;
dpiScale = dpi.Height / 72f;
}
if (_defaultFont == null)
{
_defaultFont = GenericSanSerif();
//_defaultDIP = ConvertPointSizeToDIP(_defaultFontSizeEm);
}
FontFamily fontFamily = GetFontFamily(fontName);
if (!_fontFamilyCache.TryGetValue(fontName, out fontFamily))
{
var ext = Path.GetExtension(fontName);
_currentFont = _defaultFont;
if (!String.IsNullOrEmpty(ext) && ext.ToLower() == ".ttf")
{
//var appPath = AppDomain.CurrentDomain.BaseDirectory;
//var contentPath = Path.Combine(appPath, CCApplication.SharedApplication.Content.RootDirectory);
//var fontPath = Path.Combine(contentPath, fontName);
//if (File.Exists(fontPath))
//{
// try
//{
//var fontFileReference = new FontCollection(
//_loadedFonts.AddFontFile(fontPath);
// //fontFamily = _loadedFonts.Families[_loadedFonts.Families.Length - 1];
// //_currentFont = new Font(fontFamily, fontSize);
// }
// catch
// {
// _currentFont = _defaultFont;
// }
//}
//else
//{
_currentFont = _defaultFont;
_currentFontSizeEm = fontSize;
_currentDIP = ConvertPointSizeToDIP(fontSize);
//}
}
else
{
_currentFont = GetFont(fontName, fontSize);
_currentFontSizeEm = fontSize;
_currentDIP = ConvertPointSizeToDIP(fontSize);
}
_fontFamilyCache.Add(fontName, _currentFont.FontFamily);
}
else
{
_currentFont = fontFamily.GetFirstMatchingFont(FontWeight.Regular, FontStretch.Normal, FontStyle.Normal);
_currentFontSizeEm = fontSize;
_currentDIP = ConvertPointSizeToDIP(fontSize);
}
fontName = _currentFont.FontFamily.FamilyNames.GetString(0);
textFormat = new TextFormat(FactoryDWrite, fontName, _currentDIP);
GetKerningInfo(charset);
return _currentFont.ToString();
}
public BitmapManager(WIC.ImagingFactory imagingFactory)
{
_imagingFactory = imagingFactory;
}
static Tools()
{
_factory = new SharpDX.WIC.ImagingFactory();
}
