Thanks again for the pointer. After looking a little more, in the first Code Sample you pointed me to, it appears what's going on is that the code is wrapping an encoder around a bitmap that is already getting properly drawn by D2D and pushing that out to
a file. My situation is a little different, as I need to create a separate bitmap offscreen, use it as a D2D target, and then blip its pixels into a texture. The sticking point is that I can't get D2D to render onto my offscreen bitmaps.
After another day of banging my head against the wall, I've made little progress. I've come up with some approaches; Neither crash, and both create usable texture objects, but no D2D drawing occurs. (So I wind up with black in the 1st attempt, and random
pixels in the 2nd). I'm no DX expert, and I expect I'm missing some fundamental concept about what actually causes D2D to do a drawing cycle. Does anybody have any ideas? Thanks for your time :)
//_target is a bunch of information about the current ->D3D11<- target in which the texture will finally be used.
public Object AllocateTexture(DrawingSize drawingSize, DXDelegates.RenderD2DDelegate renderDelegate)
{
var pitch = drawingSize.Width * 4;
var size = pitch * drawingSize.Height;
var bufferArray = new Byte[size];
var dataStream = SharpDX.DataStream.Create(bufferArray, true, true);
var dataRectangle = new SharpDX.DataRectangle(dataStream.DataPointer, pitch);
var wicBitmap = new SharpDX.WIC.Bitmap(_target.DeviceManager.WICFactory,
drawingSize.Width,
drawingSize.Height,
SharpDX.WIC.PixelFormat.Format32bppPRGBA,
dataRectangle);
var properties = new RenderTargetProperties();
properties.DpiX = _target.DeviceManager.Dpi;
properties.DpiY = _target.DeviceManager.Dpi;
properties.PixelFormat = new SharpDX.Direct2D1.PixelFormat(SharpDX.DXGI.Format.R8G8B8A8_UNorm, SharpDX.Direct2D1.AlphaMode.Premultiplied);
properties.Type = RenderTargetType.Default;
var wicRenderTarget = new WicRenderTarget(_target.DeviceManager.FactoryDirect2D, wicBitmap, properties);
renderDelegate.Invoke(wicRenderTarget, _target.DeviceManager);
dataStream.Seek(0, SeekOrigin.Begin);
return TextureLoader.CreateTexture2DFromBitmap(_d3dDevice, drawingSize.Width, drawingSize.Height, dataStream);
}
public Object AllocateTexture2(DrawingSize drawingSize, DXDelegates.RenderD2DDelegate renderDelegate)
{
var pitch = drawingSize.Width * 4;
var size = pitch * drawingSize.Height;
var localD2DContext = ToDispose(new SharpDX.Direct2D1.DeviceContext(_target.DeviceManager.DeviceDirect2D, SharpDX.Direct2D1.DeviceContextOptions.EnableMultithreadedOptimizations));
//Copy the bitmap properties out of the current target as much as possible.
var bitmapProperties = new BitmapProperties1();
bitmapProperties.DpiX = _target.DeviceManager.Dpi;
bitmapProperties.DpiY = _target.DeviceManager.Dpi;
bitmapProperties.PixelFormat = new SharpDX.Direct2D1.PixelFormat(SharpDX.DXGI.Format.R8G8B8A8_UNorm, SharpDX.Direct2D1.AlphaMode.Premultiplied);
bitmapProperties.BitmapOptions = BitmapOptions.Target | BitmapOptions.CannotDraw;
//Allocate a buffer and wrap a Surface-Compatible bitmap aroun it.
var backingBuffer = new DataStream(size, true, true);
var renderTargetBitmap = new Bitmap1(localD2DContext, drawingSize, backingBuffer, pitch, bitmapProperties);
localD2DContext.Target = renderTargetBitmap;
//Scribble in the buffer so we can see what is and isn't working.
var rand = new Random();
var randBuffer = new byte[size];
for (int i = 0; i < randBuffer.Length; i++)
randBuffer[i] = (byte)rand.Next(0, 255);
backingBuffer.Write(randBuffer, 0, size);
backingBuffer.Seek(0, SeekOrigin.Begin);
//Create a render target
//This is unneccesary, perhaps?
RenderTargetProperties properties = new RenderTargetProperties();
properties.DpiX = bitmapProperties.DpiX;
properties.DpiY = bitmapProperties.DpiY;
properties.PixelFormat = bitmapProperties.PixelFormat;
properties.Type = RenderTargetType.Default;
RenderTarget bitmapRenderTarget = new RenderTarget(_target.DeviceManager.FactoryDirect2D, renderTargetBitmap.Surface, properties);
//All the actual D2D drawing happens in the delegate.
renderDelegate.Invoke(bitmapRenderTarget, _target.DeviceManager);
//Blit the buffer into a texture.
var texture2D = TextureLoader.CreateTexture2DFromBitmap(_d3dDevice, drawingSize.Width, drawingSize.Height, backingBuffer);
return new ShaderResourceView(_d3dDevice, texture2D);
}
//TextureLoader method
public static SharpDX.Direct3D11.Texture2D CreateTexture2DFromBitmap(SharpDX.Direct3D11.Device device, int width, int height, SharpDX.DataStream dataStream)
{
return new SharpDX.Direct3D11.Texture2D(device,
standardTexture2D(width, height),
new SharpDX.DataRectangle(dataStream.DataPointer, width * 4));
}
//D2D drawing delegate
DXDelegates.RenderD2DDelegate renderDelegate = delegate(RenderTarget target, DeviceManager deviceManager)
{
target.BeginDraw();
var textFormat = new TextFormat(deviceManager.FactoryDirectWrite, "Calibri", 96 * drawingSize.Width / 1920) { TextAlignment = TextAlignment.Center, ParagraphAlignment = ParagraphAlignment.Center };
var blueBrush = new SolidColorBrush(target, Colors.SteelBlue);
var whiteBrush = new SolidColorBrush(target, Colors.White);
var rr = new RoundedRect();
rr.RadiusX = 20;
rr.RadiusY = 10;
rr.Rect = new RectangleF(30f, 30f, 200f, 200f);
target.Clear(Colors.Salmon);
target.DrawRoundedRectangle(rr, whiteBrush);
target.DrawText("Hello Label!", textFormat, new RectangleF(-drawingSize.Width / 2.0f, -drawingSize.Height / 2.0f, drawingSize.Width / 2.0f, drawingSize.Height / 2.0f), blueBrush);
target.Flush();
target.EndDraw();
};
