使用SharpDX在Bitmap上绘制倾斜效果过慢，问题出在哪里？

Hey NickD, moving from GDI+ to Direct2D for GPU-accelerated rendering should definitely give you a performance boost with 5-6k bitmaps per frame—so the slowdown you're seeing is almost certainly tied to how you're leveraging Direct2D's GPU pipeline. Let's break down the most likely culprits:

1. You're Re-Uploading Bitmaps to the GPU Every Frame #

GDI+ works directly with CPU-side bitmaps, so there's no data transfer overhead. But Direct2D relies on GPU-resident textures to render quickly. If you're creating a new SharpDX.Direct2D1.Bitmap from your CPU bitmap every frame, you're paying the cost of copying pixel data from CPU to GPU memory every single time—and that's a massive bottleneck.

Fix: Preload all your bitmaps into Direct2D Bitmap objects once during initialization, then reuse these GPU-resident resources every frame. Only reupload a bitmap if its pixel data actually changes.

2. Frequent State Switches Are Killing GPU Efficiency #

GPUs hate frequent state changes (like updating transformation matrices, switching between different bitmaps, or changing render states). GDI+ handles state switches on the CPU with relatively low overhead, but every state change in Direct2D forces the GPU to flush its current work and reconfigure—this adds up fast with 5k+ draw calls.

Fix:

• Batch your draw calls: Group bitmaps that use the same skew transformation together, so you set the matrix once and draw all matching bitmaps in sequence.
• Minimize bitmap switches: If multiple bitmaps share the same texture atlas (if applicable), draw all instances from one atlas before switching to another.

3. You're Using a CPU-Based Render Target #

If your Direct2D render target is a DCRenderTarget (which ties to a GDI device context), you're not actually using GPU acceleration—it's running on the CPU, just like GDI+ (but with extra Direct2D overhead).

Fix: Use a hardware-accelerated render target like HwndRenderTarget or a DxgiSurfaceRenderTarget (linked to a DXGI swap chain). When creating it, ensure:

• The RenderTargetProperties have Usage set to RenderTargetUsage.None (no CPU readback, which disables hardware acceleration)
• The PixelFormat uses a GPU-friendly format like DXGI_FORMAT_B8G8R8A8_UNORM

4. You're Creating/Destroying Resources Every Frame #

Direct2D objects (bitmaps, brushes, transformation matrices) are heavyweight compared to their GDI+ counterparts. If you're creating new matrices, brushes, or even temporary bitmap objects every frame, you're incurring expensive memory allocation and GPU resource setup costs.

Fix: Cache all reusable resources (precompute your skew matrices, keep a pool of brushes, etc.) during initialization. Only create new resources when absolutely necessary.

5. Debug Layer Is Enabled #

If you're running with Direct2D's debug layer turned on (common during development), it adds extensive validation checks that slow down rendering significantly. This is meant for debugging, not performance testing.

Fix: When creating your SharpDX.Direct2D1.Factory, set DebugLevel to DebugLevel.None in release builds (and even in debug builds if you're profiling performance).

How to Diagnose the Exact Bottleneck #

To confirm which issue is hitting you, use Windows Performance Analyzer (WPA):

• Capture a trace while your app is running, then look for high CPU time in functions like ID2D1Bitmap::CopyFromMemory (indicating upload overhead) or frequent ID2D1RenderTarget::SetTransform calls (state switches).
• Check GPU utilization—if it's low, the bottleneck is on the CPU (data transfer/state management); if it's high, you might need to optimize draw call batching.

Direct2D is absolutely capable of rendering 5-6k skewed bitmaps in way less than 80ms once you fix these pipeline inefficiencies—focus on minimizing data transfer and state changes, and you'll see a huge improvement.

内容的提问来源于stack exchange，提问作者NickD