Come caricare una bitmap da una risorsa (Direct2D)

Come descritto in Come caricare una bitmap da un file, Direct2D usa windows Imaging Component (WIC) per caricare le bitmap. Per caricare una bitmap da una risorsa, usare oggetti WIC per caricare l'immagine e convertirla in un formato compatibile con Direct2D; usare quindi il metodo CreateBitmapFromWicBitmap per creare un ID2D1Bitmap.

1. Nel file di definizione delle risorse dell'applicazione definire la risorsa. L'esempio seguente definisce una risorsa denominata "SampleImage".

   // THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
   // ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
   // THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
   // PARTICULAR PURPOSE.
   //
   // Copyright (c) Microsoft Corporation. All rights reserved
   #include "windows.h"
   
   SampleImage Image "sampleImage.jpg"
   

Questa risorsa verrà aggiunta al file di risorse dell'applicazione al momento della compilazione dell'applicazione.

2. Caricare l'immagine dal file di risorse dell'applicazione.

   HRESULT DemoApp::LoadResourceBitmap(
       ID2D1RenderTarget *pRenderTarget,
       IWICImagingFactory *pIWICFactory,
       PCWSTR resourceName,
       PCWSTR resourceType,
       UINT destinationWidth,
       UINT destinationHeight,
       ID2D1Bitmap **ppBitmap
       )
   {
       IWICBitmapDecoder *pDecoder = NULL;
       IWICBitmapFrameDecode *pSource = NULL;
       IWICStream *pStream = NULL;
       IWICFormatConverter *pConverter = NULL;
       IWICBitmapScaler *pScaler = NULL;
   
       HRSRC imageResHandle = NULL;
       HGLOBAL imageResDataHandle = NULL;
       void *pImageFile = NULL;
       DWORD imageFileSize = 0;
   
       // Locate the resource.
       imageResHandle = FindResourceW(HINST_THISCOMPONENT, resourceName, resourceType);
       HRESULT hr = imageResHandle ? S_OK : E_FAIL;
       if (SUCCEEDED(hr))
       {
           // Load the resource.
           imageResDataHandle = LoadResource(HINST_THISCOMPONENT, imageResHandle);
   
           hr = imageResDataHandle ? S_OK : E_FAIL;
       }
   

3. Bloccare la risorsa e calcolare le dimensioni dell'immagine.

       if (SUCCEEDED(hr))
       {
           // Lock it to get a system memory pointer.
           pImageFile = LockResource(imageResDataHandle);
   
           hr = pImageFile ? S_OK : E_FAIL;
       }
       if (SUCCEEDED(hr))
       {
           // Calculate the size.
           imageFileSize = SizeofResource(HINST_THISCOMPONENT, imageResHandle);
   
           hr = imageFileSize ? S_OK : E_FAIL;
   
       }
   

4. Utilizzare il metodo IWICImagingFactory::CreateStream per creare un oggetto IWICStream .

       if (SUCCEEDED(hr))
       {
             // Create a WIC stream to map onto the memory.
           hr = pIWICFactory->CreateStream(&pStream);
       }
       if (SUCCEEDED(hr))
       {
           // Initialize the stream with the memory pointer and size.
           hr = pStream->InitializeFromMemory(
               reinterpret_cast<BYTE*>(pImageFile),
               imageFileSize
               );
       }
   

5. Utilizzare il metodo IWICImagingFactory::CreateDecoderFromStream per creare un oggetto IWICBitmapDecoder.

       if (SUCCEEDED(hr))
       {
           // Create a decoder for the stream.
           hr = pIWICFactory->CreateDecoderFromStream(
               pStream,
               NULL,
               WICDecodeMetadataCacheOnLoad,
               &pDecoder
               );
       }
   

6. Recuperare un frame dall'immagine e archiviarlo in un oggetto IWICBitmapFrameDecode .

       if (SUCCEEDED(hr))
       {
           // Create the initial frame.
           hr = pDecoder->GetFrame(0, &pSource);
       }
   

7. Prima che Direct2D possa usare l'immagine, deve essere convertita nel formato pixel 32bppPBGRA. Per convertire il formato dell'immagine, utilizzare il metodo IWICImagingFactory::CreateFormatConverter per creare un oggetto IWICFormatConverter, quindi utilizzare il metodo Initialize dell'oggetto IWICFormatConverter per eseguire la conversione.

        if (SUCCEEDED(hr))
        {
            // Convert the image format to 32bppPBGRA
            // (DXGI_FORMAT_B8G8R8A8_UNORM + D2D1_ALPHA_MODE_PREMULTIPLIED).
            hr = pIWICFactory->CreateFormatConverter(&pConverter);
        }

       if (SUCCEEDED(hr))
        {           
        hr = pConverter->Initialize(
            pSource,
            GUID_WICPixelFormat32bppPBGRA,
            WICBitmapDitherTypeNone,
            NULL,
            0.f,
            WICBitmapPaletteTypeMedianCut
            );

8. Infine, usare il metodo CreateBitmapFromWicBitmap per creare un oggetto ID2D1Bitmap che può essere disegnato da una destinazione di rendering e usato con altri oggetti Direct2D.

       if (SUCCEEDED(hr))
       {
           //create a Direct2D bitmap from the WIC bitmap.
           hr = pRenderTarget->CreateBitmapFromWicBitmap(
               pConverter,
               NULL,
               ppBitmap
               );
   
       }
   
       SafeRelease(&pDecoder);
       SafeRelease(&pSource);
       SafeRelease(&pStream);
       SafeRelease(&pConverter);
       SafeRelease(&pScaler);
   
       return hr;
   }
   

Alcuni codici sono stati omessi da questo esempio.

Argomenti correlati

Come caricare una bitmap da un file