Direct2Dで画像を読み込む

#include <Windows.h>

#include <d2d1.h>

#pragma comment(lib, "d2d1")

#include <gdiplus.h>

#pragma comment(lib, "gdiplus.lib")

#include <math.h> // ceil

// WindowsAPIやDirect2Dライブラリとの誤解を防ぐため、個別にusingする。

//using namespace Gdiplus;

ID2D1Factory* g_pD2dFactory;

ID2D1HwndRenderTarget* g_pRenderTarget;

template<class Interface>

inline void SafeRelease(

  Interface **ppInterface

)

{

  if (*ppInterface != NULL)

  {

    (*ppInterface)->Release();

    (*ppInterface) = NULL;

  }

}

void MsgBoxAndExitByError(const wchar_t* msg)

{

  MessageBoxW(0, msg, L"エラーが発生したので終了します。", 0);

  exit(0);

}

void LoadBitmapByGdiplus(ID2D1Bitmap** ppBitmap, UINT* width, UINT* height)

{

  Gdiplus::Bitmap* bmp = Gdiplus::Bitmap::FromFile(L"C:\\img.png");

  if (!(bmp && bmp->GetLastStatus() == Gdiplus::Ok))

  {

    MsgBoxAndExitByError(L"画像ファイルを読み込めませんでした。");

  }

  UINT w = *width = bmp->GetWidth();

  UINT h = *height = bmp->GetHeight();

  // 画像イメージの読み込み

  Gdiplus::Rect rect(0, 0, w, h);

  Gdiplus::BitmapData bmpData;

  bmp->LockBits(&rect, Gdiplus::ImageLockModeRead, PixelFormat32bppARGB, &bmpData);

  int stride = w * 4;

  byte* memory = new byte[stride * h];

  for (UINT y = 0; y < h; ++y)

    memcpy(memory + y * stride, (byte*)bmpData.Scan0 + y * bmpData.Stride, stride);

  bmp->UnlockBits(&bmpData);

  delete bmp;

  g_pRenderTarget->CreateBitmap(

    D2D1::SizeU(w, h),

    memory, stride,

    D2D1::BitmapProperties(D2D1::PixelFormat(DXGI_FORMAT_B8G8R8A8_UNORM, D2D1_ALPHA_MODE_IGNORE)),

    ppBitmap);

  delete[] memory;

  memory = 0;

}

LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)

{

  UINT width, height;

  static ID2D1Bitmap* s_pBitmap;

  static UINT s_pBitmapWidth;

  static UINT s_pBitmapHeight;

  HRESULT hr;

  switch (msg)

  {

  case WM_CREATE:

    return 1;

  case WM_SIZE:

    width = LOWORD(lParam);

    height = HIWORD(lParam);

    if (g_pRenderTarget)

    {

      g_pRenderTarget->Resize(D2D1::SizeU(width, height));

    }

    return 0;

    break;

  case WM_PAINT:

    RECT rc;

    if (!g_pRenderTarget)

    {

      GetClientRect(hwnd, &rc);

      D2D1_SIZE_U size = D2D1::SizeU(

        rc.right - rc.left,

        rc.bottom - rc.top

      );

      HRESULT hr = g_pD2dFactory->CreateHwndRenderTarget(

        D2D1::RenderTargetProperties(),

        D2D1::HwndRenderTargetProperties(hwnd, size),

        &g_pRenderTarget

      );

      if (hr == D2DERR_RECREATE_TARGET)

      {

        hr = S_OK;

        SafeRelease(&g_pD2dFactory);

      }

      if (s_pBitmap == NULL)

      {

        LoadBitmapByGdiplus(&s_pBitmap, &s_pBitmapWidth, &s_pBitmapHeight);

      }

    }

    g_pRenderTarget->BeginDraw();

    D2D1_RECT_F rectf = D2D1::RectF(

      0.0f,

      0.0f,

      static_cast<float>(s_pBitmapWidth),

      static_cast<float>(s_pBitmapHeight)

    );

    g_pRenderTarget->DrawBitmap(s_pBitmap, rectf);

    hr = g_pRenderTarget->EndDraw();

    if (hr == D2DERR_RECREATE_TARGET)

    {

      SafeRelease(&g_pRenderTarget);

    }

    ValidateRect(hwnd, NULL);

    return 0;

  case WM_DESTROY:

    SafeRelease(&s_pBitmap);

    PostQuitMessage(0);

    break;

  }

  return DefWindowProc(hwnd, msg, wParam, lParam);

}

#ifndef HINST_THISCOMPONENT 

EXTERN_C IMAGE_DOS_HEADER __ImageBase;

#define HINST_THISCOMPONENT ((HINSTANCE)&__ImageBase) 

#endif

const wchar_t* const kClassName = L"SimpleDirect2DLaodImage";

const wchar_t* const kTitle = kClassName;

int WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int)

{

  HeapSetInformation(NULL, HeapEnableTerminationOnCorruption, NULL, 0);

  if (!SUCCEEDED(CoInitialize(NULL))) return 0;

  HRESULT hr = D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, &g_pD2dFactory);

  if (!SUCCEEDED(hr))

  {

    MsgBoxAndExitByError(L"Direct2Dファクトリ オブジェクトの作成に失敗しました。");

  }

  unsigned long gdiplusToken;

  Gdiplus::GdiplusStartupInput gdiplusStartupInput;

  if (Gdiplus::GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL) != Gdiplus::Ok)

  {

    MsgBoxAndExitByError(L"GDI+の初期化に失敗しました。");

  }

  WNDCLASSEXW wcex = { sizeof(WNDCLASSEXW) };

  wcex.style = CS_HREDRAW | CS_VREDRAW;

  wcex.lpfnWndProc = WndProc;

  wcex.cbClsExtra = 0;

  wcex.cbWndExtra = sizeof(LONG_PTR);

  wcex.hInstance = HINST_THISCOMPONENT;

  wcex.hbrBackground = NULL;

  wcex.lpszMenuName = NULL;

  wcex.hCursor = LoadCursor(NULL, IDI_APPLICATION);

  wcex.lpszClassName = kClassName;

  RegisterClassExW(&wcex);

  FLOAT dpiX, dpiY;

  g_pD2dFactory->GetDesktopDpi(&dpiX, &dpiY);

  HWND hwnd = CreateWindowW(

    kTitle,

    kClassName,

    WS_OVERLAPPEDWINDOW,

    CW_USEDEFAULT,

    CW_USEDEFAULT,

    static_cast<UINT>(ceil(640.f * dpiX / 96.f)),

    static_cast<UINT>(ceil(480.f * dpiY / 96.f)),

    NULL,

    NULL,

    HINST_THISCOMPONENT,

    0

  );

  if (!hwnd) {

    MsgBoxAndExitByError(L"ウィンドウの作成に失敗しました。");

  }

  ShowWindow(hwnd, SW_SHOWNORMAL);

  UpdateWindow(hwnd);

  MSG msg;

  while (GetMessage(&msg, NULL, 0, 0))

  {

    TranslateMessage(&msg);

    DispatchMessage(&msg);

  }

  SafeRelease(&g_pD2dFactory);

  SafeRelease(&g_pRenderTarget);

  Gdiplus::GdiplusShutdown(gdiplusToken);

  CoUninitialize();

  return 0;

}

void LoadBitmapByGdiplus(ID2D1Bitmap** ppBitmap, UINT* width, UINT* height)

{

 Gdiplus::Bitmap* bmp = Gdiplus::Bitmap::FromFile(L"C:\\img.png");

  if (!(bmp && bmp->GetLastStatus() == Gdiplus::Ok))

  {

    MsgBoxAndExitByError(L"画像ファイルを読み込めませんでした。");

  }

  UINT w = *width = bmp->GetWidth();

  UINT h = *height = bmp->GetHeight();

  Gdiplus::Rect rect(0, 0, w, h);

  Gdiplus::BitmapData bmpData;

  int stride = w * 4;

  for (UINT y = 0; y < h; ++y)

    memcpy(memory + y * stride, (byte*)bmpData.Scan0 + y * bmpData.Stride, stride);

  bmp->UnlockBits(&bmpData);

  delete bmp;

  g_pRenderTarget->CreateBitmap(

    D2D1::SizeU(w, h),

    memory, stride,

    D2D1::BitmapProperties(D2D1::PixelFormat(DXGI_FORMAT_B8G8R8A8_UNORM, D2D1_ALPHA_MODE_IGNORE)),

    ppBitmap);

  delete memory;

  memory = 0;

}