Compartir a través de


Cómo cargar un mapa de bits desde un recurso (Direct2D)

Como se describe en Cómo cargar un mapa de bits desde un archivo, Direct2D usa el componente de creación de imágenes de Windows (WIC) para cargar mapas de bits. Para cargar un mapa de bits desde un recurso, use objetos WIC para cargar la imagen y convertirlo a un formato compatible con Direct2D; a continuación, use el método CreateBitmapFromWicBitmap para crear un ID2D1Bitmap.

  1. En el archivo de definición de recursos de la aplicación, defina el recurso. En el ejemplo siguiente se define un recurso denominado "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"
    

Este recurso se agregará al archivo de recursos de la aplicación cuando se compila la aplicación.

  1. Cargue la imagen desde el archivo de recursos de la aplicación.

    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;
        }
    
  2. Bloquee el recurso y calcule el tamaño de la imagen.

        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;
    
        }
    
  3. Use el método IWICImagingFactory::CreateStream para crear un objeto 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
                );
        }
    
  4. Use el método IWICImagingFactory::CreateDecoderFromStream para crear un IWICBitmapDecoder.

        if (SUCCEEDED(hr))
        {
            // Create a decoder for the stream.
            hr = pIWICFactory->CreateDecoderFromStream(
                pStream,
                NULL,
                WICDecodeMetadataCacheOnLoad,
                &pDecoder
                );
        }
    
  5. Recupere un marco de la imagen y almacénelo en un objeto IWICBitmapFrameDecode .

        if (SUCCEEDED(hr))
        {
            // Create the initial frame.
            hr = pDecoder->GetFrame(0, &pSource);
        }
    
  6. Para que Direct2D pueda usar la imagen, debe convertirse al formato de píxel 32bppPBGRA. Para convertir el formato de imagen, use el método IWICImagingFactory::CreateFormatConverter para crear un objeto IWICFormatConverter y, a continuación, use el método Initialize del objeto IWICFormatConverter para realizar la conversión.

        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
            );
  1. Por último, use el método CreateBitmapFromWicBitmap para crear un objeto ID2D1Bitmap que un destino de representación pueda dibujar y usar con otros objetos 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;
    }
    

Se ha omitido algún código de este ejemplo.

Cómo cargar un mapa de bits desde un archivo