Direct2D

https://learn.microsoft.com/en-us/windows/win32/Direct2D/
Admin
Direct2D is a hardware-accelerated, immediate-mode 2-D graphics API that provides high-performance...
Tokens:336,663
Snippets:3,012
Trust Score:10
Update:1 month ago
Show doc for...
Tokens:
Raw
### Implement WinMain Entry Point

Source: https://learn.microsoft.com/en-us/windows/win32/Direct2D/direct2d-quickstart

Serves as the application entry point, initializes COM, creates the DemoApp instance, and starts the message loop.

```C++
int WINAPI WinMain(
    HINSTANCE /* hInstance */,
    HINSTANCE /* hPrevInstance */,
    LPSTR /* lpCmdLine */,
    int /* nCmdShow */
    )
{
    // Use HeapSetInformation to specify that the process should
    // terminate if the heap manager detects an error in any heap used
    // by the process.
    // The return value is ignored, because we want to continue running in the
    // unlikely event that HeapSetInformation fails.
    HeapSetInformation(NULL, HeapEnableTerminationOnCorruption, NULL, 0);

    if (SUCCEEDED(CoInitialize(NULL)))
    {
        {
            DemoApp app;

            if (SUCCEEDED(app.Initialize()))
            {
                app.RunMessageLoop();
            }
        }
        CoUninitialize();
    }

    return 0;
}
```

--------------------------------

### Defining a Unique Effect GUID

Source: https://learn.microsoft.com/en-us/windows/win32/Direct2D/custom-effects

Example of defining a unique GUID for a custom effect, which is required for registration with Direct2D and subsequent instantiation via ID2D1DeviceContext::CreateEffect.

```C++
// Example GUID used to uniquely identify the effect. It is passed to Direct2D during
// effect registration, and used by the developer to identify the effect for any
// ID2D1DeviceContext::CreateEffect calls in the app. The app should create
// a unique name for the effect, as well as a unique GUID using a generation tool.
DEFINE_GUID(CLSID_SampleEffect, 0x00000000, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00);
```

--------------------------------

### Implement DemoApp::Initialize

Source: https://learn.microsoft.com/en-us/windows/win32/Direct2D/direct2d-quickstart

Initializes device-independent resources, registers the window class, creates the window, and scales it based on DPI.

```C++
HRESULT DemoApp::Initialize()
{
    HRESULT hr;

    // Initialize device-independent resources, such
    // as the Direct2D factory.
    hr = CreateDeviceIndependentResources();

    if (SUCCEEDED(hr))
    {
        // Register the window class.
        WNDCLASSEX wcex = { sizeof(WNDCLASSEX) };
        wcex.style         = CS_HREDRAW | CS_VREDRAW;
        wcex.lpfnWndProc   = DemoApp::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 = L"D2DDemoApp";

        RegisterClassEx(&wcex);

        // In terms of using the correct DPI, to create a window at a specific size
        // like this, the procedure is to first create the window hidden. Then we get
        // the actual DPI from the HWND (which will be assigned by whichever monitor
        // the window is created on). Then we use SetWindowPos to resize it to the
        // correct DPI-scaled size, then we use ShowWindow to show it.

        m_hwnd = CreateWindow(
            L"D2DDemoApp",
            L"Direct2D demo application",
            WS_OVERLAPPEDWINDOW,
            CW_USEDEFAULT,
            CW_USEDEFAULT,
            0,
            0,
            NULL,
            NULL,
            HINST_THISCOMPONENT,
            this);

        if (m_hwnd)
        {
            // Because the SetWindowPos function takes its size in pixels, we
            // obtain the window's DPI, and use it to scale the window size.
            float dpi = GetDpiForWindow(m_hwnd);

            SetWindowPos(
                m_hwnd,
                NULL,
                NULL,
                NULL,
                static_cast<int>(ceil(640.f * dpi / 96.f)),
                static_cast<int>(ceil(480.f * dpi / 96.f)),
                SWP_NOMOVE);
            ShowWindow(m_hwnd, SW_SHOWNORMAL);
            UpdateWindow(m_hwnd);
        }
    }

    return hr;
}
```

--------------------------------

### D2DGetInputCoordinate Displacement Map Example

Source: https://learn.microsoft.com/en-us/windows/win32/Direct2D/d2dgetinputcoordinate

An example demonstrating the use of D2DGetInputCoordinate to retrieve coordinates for a displacement map effect.

```cpp
float2 GetDisplacementOffset(float4 uv0, float4 uv1)  
{  
    // TODO: return the displacement offset 
}  
  
D2D_PS_ENTRY(DisplacementMapBilinear)  
{  
    const float4 coord0 = D2DGetInputCoordinate(0);  
    const float4 coord1 = D2DGetInputCoordinate(1);  
    return D2DSampleInput(0, GetDisplacementOffset(coord0, coord1) * coord0.zw + coord0.xy);  
}
```

--------------------------------

### Implement DemoApp::OnRender

Source: https://learn.microsoft.com/en-us/windows/win32/direct2d/direct2d-quickstart

Initializes the rendering process by checking device resources and setting up the drawing environment.

```C++
HRESULT DemoApp::OnRender()
{
    HRESULT hr = S_OK;

    hr = CreateDeviceResources();
```

```C++
if (SUCCEEDED(hr))
{
```

```C++
m_pRenderTarget->BeginDraw();
m_pRenderTarget->SetTransform(D2D1::Matrix3x2F::Identity());
m_pRenderTarget->Clear(D2D1::ColorF(D2D1::ColorF::White));
```

```C++
D2D1_SIZE_F rtSize = m_pRenderTarget->GetSize();
```

--------------------------------

### Apply Translation Followed by Rotation

Source: https://learn.microsoft.com/en-us/windows/win32/direct2d/how-to-apply-multiple-transforms

This example demonstrates applying a translation first, followed by a rotation. Note that the order of multiplication in SetTransform differs from the previous example.

```cpp
D2D1_RECT_F rectangle = D2D1::Rect(40.0f, 40.0f, 100.0f, 100.0f);

// Draw a rectangle without transforming it.
m_pRenderTarget->DrawRectangle(
    rectangle,
    m_pOriginalShapeBrush,
    1.0f,
    m_pStrokeStyleDash
    );

D2D1_MATRIX_3X2_F translation = D2D1::Matrix3x2F::Translation(20.0f, 10.0f);

m_pRenderTarget->SetTransform(translation);

D2D1_MATRIX_3X2_F rotation = D2D1::Matrix3x2F::Rotation(
    45.0f,
    D2D1::Point2F(70.0f, 70.0f)
    );

// First move 20 pixels to the right along the x-axis and
// 10 pixels downward along the y-axis,
// and then rotate about the center of the original square.
m_pRenderTarget->SetTransform(translation * rotation);

// Draw the rectangle in the transformed space.
m_pRenderTarget->FillRectangle(rectangle, m_pFillBrush);
m_pRenderTarget->DrawRectangle(rectangle, m_pTransformedShapeBrush);
```

--------------------------------

### Using CreateLayer, PushLayer, and PopLayer in C++

Source: https://learn.microsoft.com/en-us/windows/win32/Direct2D/direct2d-layers-overview

This example demonstrates how to create a layer, push it with specific parameters including an opacity brush, perform drawing operations, and pop the layer. Ensure that every PushLayer call has a corresponding PopLayer call to avoid render target errors.

```cpp
// Create a layer.
ID2D1Layer *pLayer = NULL;
hr = pRT->CreateLayer(NULL, &pLayer);

if (SUCCEEDED(hr))
{
    pRT->SetTransform(D2D1::Matrix3x2F::Translation(300, 250));

    // Push the layer with the content bounds.
    pRT->PushLayer(
        D2D1::LayerParameters(
            D2D1::InfiniteRect(),
            NULL,
            D2D1_ANTIALIAS_MODE_PER_PRIMITIVE,
            D2D1::IdentityMatrix(),
            1.0,
            m_pRadialGradientBrush,
            D2D1_LAYER_OPTIONS_NONE),
        pLayer
        );

    pRT->DrawBitmap(m_pBambooBitmap, D2D1::RectF(0, 0, 190, 127));

    pRT->FillRectangle(
        D2D1::RectF(25.f, 25.f, 50.f, 50.f), 
        m_pSolidColorBrush
        );
    pRT->FillRectangle(
        D2D1::RectF(50.f, 50.f, 75.f, 75.f),
        m_pSolidColorBrush
        ); 
    pRT->FillRectangle(
        D2D1::RectF(75.f, 75.f, 100.f, 100.f),
        m_pSolidColorBrush
        );    
 
    pRT->PopLayer();
}
SafeRelease(&pLayer);
```

--------------------------------

### ID2D1Effect::CreateEffect (CLSID_D2D1GammaTransfer)

Source: https://learn.microsoft.com/en-us/windows/win32/direct2d/gamma-transfer

Example of creating and configuring the Gamma Transfer effect in C++.

```APIDOC
## ID2D1Effect::CreateEffect(CLSID_D2D1GammaTransfer)

### Description
Creates an instance of the Gamma Transfer effect to map color intensities of an image using a gamma function.

### Usage
```cpp
ComPtr<ID2D1Effect> gammaTransferEffect;
m_d2dContext->CreateEffect(CLSID_D2D1GammaTransfer, &gammaTransferEffect);

gammaTransferEffect->SetInput(0, bitmap);

// Set exponents for color channels
gammaTransferEffect->SetValue(D2D1_GAMMATRANSFER_PROP_RED_EXPONENT, 0.25f);
gammaTransferEffect->SetValue(D2D1_GAMMATRANSFER_PROP_GREEN_EXPONENT, 0.25f);
gammaTransferEffect->SetValue(D2D1_GAMMATRANSFER_PROP_BLUE_EXPONENT, 0.25f);

m_d2dContext->BeginDraw();
m_d2dContext->DrawImage(gammaTransferEffect.Get());
m_d2dContext->EndDraw();
```

### Mathematical Formula
C' = Amplitude * C^Exponent + Offset

### Notes
- Works on straight and premultiplied alpha images.
- Outputs premultiplied alpha bitmaps.
- Requires dxguid.lib in linker dependencies.
```

--------------------------------

### Open the file picker

Source: https://learn.microsoft.com/en-us/windows/win32/direct2d/load-a-id2d1image-using-the-filepicker

Create a FileOpenPicker object, configure its view mode, start location, and file type filters, then initiate the file selection process.

```cpp
    FileOpenPicker^ openPicker = ref new FileOpenPicker();
    openPicker->ViewMode = PickerViewMode::Thumbnail;
    openPicker->SuggestedStartLocation = PickerLocationId::PicturesLibrary;
    openPicker->FileTypeFilter->Append(".jpg");
    auto pickOperation = openPicker->PickSingleFileAsync();
```

--------------------------------

### ID2D1Effect::CreateEffect (CLSID_D2D1Scale)

Source: https://learn.microsoft.com/en-us/windows/win32/direct2d/high-quality-scale

Example of creating and configuring the scale effect to zoom an image.

```APIDOC
## ID2D1DeviceContext::CreateEffect

### Description
Creates an instance of the scale effect using the CLSID_D2D1Scale identifier.

### Method
C++ Method

### Signature
HRESULT CreateEffect(REFCLSID effectId, ID2D1Effect **effect)

### Parameters
- **effectId** (REFCLSID) - The CLSID of the effect to create (CLSID_D2D1Scale).
- **effect** (ID2D1Effect**) - The resulting effect object.

### Usage Example
```cpp
ComPtr<ID2D1Effect> scaleEffect;
m_d2dContext->CreateEffect(CLSID_D2D1Scale, &scaleEffect);

scaleEffect->SetInput(0, bitmap);

scaleEffect->SetValue(D2D1_SCALE_PROP_CENTER_POINT, D2D1::Vector2F(256.0f, 192.0f));
scaleEffect->SetValue(D2D1_SCALE_PROP_SCALE, D2D1::Vector2F(2.0f, 2.0f));

m_d2dContext->BeginDraw();
m_d2dContext->DrawImage(scaleEffect.Get());
m_d2dContext->EndDraw();
```
```

--------------------------------

### ID2D1Effect::CreateEffect (CLSID_D2D1RgbToHue)

Source: https://learn.microsoft.com/en-us/windows/win32/Direct2D/rgb-to-hue-effect

Example of how to instantiate and configure the RGB-to-hue effect using the Direct2D context.

```APIDOC
## ID2D1Effect::CreateEffect (CLSID_D2D1RgbToHue)

### Description
Instantiates the RGB-to-hue effect to convert input bitmap data into HSL or HSV color spaces.

### Method
ID2D1DeviceContext::CreateEffect

### Parameters
- **effectId** (CLSID) - Required - The CLSID_D2D1RgbToHue identifier.
- **effect** (ID2D1Effect**) - Required - Pointer to the effect object.

### Usage Example
```cpp
ComPtr<ID2D1Effect> rgbToHueEffect;
m_d2dContext->CreateEffect(CLSID_D2D1RgbToHue, &rgbToHueEffect);

rgbToHueEffect->SetInput(0, bitmap);
rgbToHueEffect->SetValue(D2D1_RGBTOHUE_PROP_OUTPUT_COLOR_SPACE, D2D1_RGBTOHUE_OUTPUT_COLOR_SPACE_HUE_SATURATION_VALUE);

m_d2dContext->BeginDraw();
m_d2dContext->DrawImage(rgbToHueEffect.Get());
m_d2dContext->EndDraw();
```
```

--------------------------------

### Create and configure the Highlights and Shadows effect in C++

Source: https://learn.microsoft.com/en-us/windows/win32/direct2d/highlights-and-shadows-effect

This example demonstrates how to instantiate the effect, set its properties, and draw the resulting image using the Direct2D context.

```cpp
ComPtr<ID2D1Effect> highlightsAndShadowsEffect;
m_d2dContext->CreateEffect(CLSID_D2D1HighlightsShadows, &highlightsAndShadowsEffect);

highlightsAndShadowsEffect->SetInput(0, bitmap);
highlightsAndShadowsEffect->SetValue(D2D1_HIGHLIGHTSANDSHADOWS_PROP_HIGHLIGHTS, 0.0f);
highlightsAndShadowsEffect->SetValue(D2D1_HIGHLIGHTSANDSHADOWS_PROP_SHADOWS, 0.5f);
highlightsAndShadowsEffect->SetValue(D2D1_HIGHLIGHTSANDSHADOWS_PROP_CLARITY, 0.2f);
highlightsAndShadowsEffect->SetValue(D2D1_HIGHLIGHTSANDSHADOWS_PROP_INPUT_GAMMA, D2D1_HIGHLIGHTSANDSHADOWS_INPUT_GAMMA_LINEAR);
highlightsAndShadowsEffect->SetValue(D2D1_HIGHLIGHTSANDSHADOWS_PROP_MASK_BLUR_RADIUS, 1.0f);

m_d2dContext->BeginDraw();
m_d2dContext->DrawImage(hueToRgbEffect.Get());
m_d2dContext->EndDraw();
```

--------------------------------

### Implement GetInputCount for ID2D1Transform

Source: https://learn.microsoft.com/en-us/windows/win32/Direct2D/custom-effects

This method returns the number of inputs for the transform. In this example, it returns 1.

```cpp
IFACEMETHODIMP_(UINT32) GetInputCount() const
{
    return 1;
}
```

--------------------------------

### Generating a Bitmap File with Direct2D

Source: https://learn.microsoft.com/en-us/windows/win32/direct2d/server-side-rendering-overview

This example demonstrates the full workflow of creating an IWICBitmap, setting up a Direct2D render target, drawing text and geometry, and encoding the result into a PNG file.

```cpp
// Create an IWICBitmap and RT
static const UINT sc_bitmapWidth = 640;
static const UINT sc_bitmapHeight = 480;
if (SUCCEEDED(hr))
{
    hr = pWICFactory->CreateBitmap(
        sc_bitmapWidth,
        sc_bitmapHeight,
        GUID_WICPixelFormat32bppBGR,
        WICBitmapCacheOnLoad,
        &pWICBitmap
        );
}

// Set the render target type to D2D1_RENDER_TARGET_TYPE_DEFAULT to use software rendering.
if (SUCCEEDED(hr))
{
    hr = pD2DFactory->CreateWicBitmapRenderTarget(
        pWICBitmap,
        D2D1::RenderTargetProperties(),
        &pRT
        );
}

// Create text format and a path geometry representing an hour glass. 
if (SUCCEEDED(hr))
{
    static const WCHAR sc_fontName[] = L"Calibri";
    static const FLOAT sc_fontSize = 50;

    hr = pDWriteFactory->CreateTextFormat(
        sc_fontName,
        NULL,
        DWRITE_FONT_WEIGHT_NORMAL,
        DWRITE_FONT_STYLE_NORMAL,
        DWRITE_FONT_STRETCH_NORMAL,
        sc_fontSize,
        L"", //locale
        &pTextFormat
        );
}
if (SUCCEEDED(hr))
{
    pTextFormat->SetTextAlignment(DWRITE_TEXT_ALIGNMENT_CENTER);
    pTextFormat->SetParagraphAlignment(DWRITE_PARAGRAPH_ALIGNMENT_CENTER);
    hr = pD2DFactory->CreatePathGeometry(&pPathGeometry);
}
if (SUCCEEDED(hr))
{
    hr = pPathGeometry->Open(&pSink);
}
if (SUCCEEDED(hr))
{
    pSink->SetFillMode(D2D1_FILL_MODE_ALTERNATE);

    pSink->BeginFigure(
        D2D1::Point2F(0, 0),
        D2D1_FIGURE_BEGIN_FILLED
        );

    pSink->AddLine(D2D1::Point2F(200, 0));

    pSink->AddBezier(
        D2D1::BezierSegment(
            D2D1::Point2F(150, 50),
            D2D1::Point2F(150, 150),
            D2D1::Point2F(200, 200))
        );

    pSink->AddLine(D2D1::Point2F(0, 200));

    pSink->AddBezier(
        D2D1::BezierSegment(
            D2D1::Point2F(50, 150),
            D2D1::Point2F(50, 50),
            D2D1::Point2F(0, 0))
        );

    pSink->EndFigure(D2D1_FIGURE_END_CLOSED);

    hr = pSink->Close();
}
if (SUCCEEDED(hr))
{
    static const D2D1_GRADIENT_STOP stops[] =
    {
        {   0.f,  { 0.f, 1.f, 1.f, 1.f }  },
        {   1.f,  { 0.f, 0.f, 1.f, 1.f }  },
    };

    hr = pRT->CreateGradientStopCollection(
        stops,
        ARRAYSIZE(stops),
        &pGradientStops
        );
}
if (SUCCEEDED(hr))
{
    hr = pRT->CreateLinearGradientBrush(
        D2D1::LinearGradientBrushProperties(
            D2D1::Point2F(100, 0),
            D2D1::Point2F(100, 200)),
        D2D1::BrushProperties(),
        pGradientStops,
        &pLGBrush
        );
}
if (SUCCEEDED(hr))
{
    hr = pRT->CreateSolidColorBrush(
        D2D1::ColorF(D2D1::ColorF::Black),
        &pBlackBrush
        );
}
if (SUCCEEDED(hr))
{
    // Render into the bitmap.
    pRT->BeginDraw();
    pRT->Clear(D2D1::ColorF(D2D1::ColorF::White));
    D2D1_SIZE_F rtSize = pRT->GetSize();

    // Set the world transform to a 45 degree rotation at the center of the render target
    // and write "Hello, World".
    pRT->SetTransform(
        D2D1::Matrix3x2F::Rotation(
            45,
            D2D1::Point2F(
                rtSize.width / 2,
                rtSize.height / 2))
            );

    static const WCHAR sc_helloWorld[] = L"Hello, World!";
    pRT->DrawText(
        sc_helloWorld,
        ARRAYSIZE(sc_helloWorld) - 1,
        pTextFormat,
        D2D1::RectF(0, 0, rtSize.width, rtSize.height),
        pBlackBrush);

    // Reset back to the identity transform.
    pRT->SetTransform(D2D1::Matrix3x2F::Translation(0, rtSize.height - 200));
    pRT->FillGeometry(pPathGeometry, pLGBrush);
    pRT->SetTransform(D2D1::Matrix3x2F::Translation(rtSize.width - 200, 0));
    pRT->FillGeometry(pPathGeometry, pLGBrush);
    hr = pRT->EndDraw();
}

if (SUCCEEDED(hr))
{
    // Save the image to a file.
    hr = pWICFactory->CreateStream(&pStream);
}

WICPixelFormatGUID format = GUID_WICPixelFormatDontCare;

// Use InitializeFromFilename to write to a file. If there is need to write inside the memory, use InitializeFromMemory. 
if (SUCCEEDED(hr))
{
    static const WCHAR filename[] = L"output.png";
    hr = pStream->InitializeFromFilename(filename, GENERIC_WRITE);
}
if (SUCCEEDED(hr))
{
    hr = pWICFactory->CreateEncoder(GUID_ContainerFormatPng, NULL, &pEncoder);
}
if (SUCCEEDED(hr))
{
    hr = pEncoder->Initialize(pStream, WICBitmapEncoderNoCache);
}
if (SUCCEEDED(hr))
{
    hr = pEncoder->CreateNewFrame(&pFrameEncode, NULL);
}
// Use IWICBitmapFrameEncode to encode the bitmap into the picture format you want.
if (SUCCEEDED(hr))
{
    hr = pFrameEncode->Initialize(NULL);
}
if (SUCCEEDED(hr))
{
    hr = pFrameEncode->SetSize(sc_bitmapWidth, sc_bitmapHeight);
}
if (SUCCEEDED(hr))
{
    hr = pFrameEncode->SetPixelFormat(&format);
}
if (SUCCEEDED(hr))
{
    hr = pFrameEncode->WriteSource(pWICBitmap, NULL);
}
if (SUCCEEDED(hr))
{
    hr = pFrameEncode->Commit();
}
if (SUCCEEDED(hr))
{
    hr = pEncoder->Commit();
}
```

--------------------------------

### Defining a Pixel Shader Entry Point

Source: https://learn.microsoft.com/en-us/windows/win32/Direct2D/d2d-ps-entry

Example showing how to define a pixel shader entry point using D2D_PS_ENTRY, including preprocessor directives and input retrieval.

```hlsl
#define D2D_INPUT_COUNT 1 
#define D2D_INPUT0_SIMPLE 
#include  d2d1effectauthor.hlsli  

D2D_PS_ENTRY(LinkingCompatiblePixelShader) 
{ 
    float4 input = D2DGetInput(0);  

    input.rgb *= input.a; 

    return input; 
}
```

--------------------------------

### Arithmetic composite effect usage

Source: https://learn.microsoft.com/en-us/windows/win32/Direct2D/arithmetic-composite

Example of creating and configuring the Arithmetic composite effect in C++.

```APIDOC
## Arithmetic Composite Effect Usage

### Description
This example demonstrates how to instantiate the `CLSID_D2D1ArithmeticComposite` effect, set its input bitmaps, and configure the coefficients property to perform a weighted sum of pixels.

### Code Example
```cpp
ComPtr<ID2D1Effect> arithmeticCompositeEffect;
m_d2dContext->CreateEffect(CLSID_D2D1ArithmeticComposite, &arithmeticCompositeEffect);

arithmeticCompositeEffect->SetInput(0, bitmap);
arithmeticCompositeEffect->SetInput(1, bitmapTwo);
arithmeticCompositeEffect->SetValue(D2D1_ARITHMETICCOMPOSITE_PROP_COEFFICIENTS, D2D1::Vector4F(0.0f, 0.5f, 0.5f, 0.0f));

m_d2dContext->BeginDraw();
m_d2dContext->DrawImage(arithmeticCompositeEffect.Get());
m_d2dContext->EndDraw();
```
```

--------------------------------

### Create and apply the RGB-to-hue effect in C++

Source: https://learn.microsoft.com/en-us/windows/win32/direct2d/rgb-to-hue-effect

This example demonstrates initializing the effect, setting the input bitmap, configuring the output color space to HSV, and rendering the result within a Direct2D draw cycle.

```cpp
ComPtr<ID2D1Effect> rgbToHueEffect;
m_d2dContext->CreateEffect(CLSID_D2D1RgbToHue, &rgbToHueEffect);

rgbToHueEffect->SetInput(0, bitmap);
rgbToHueEffect->SetValue(D2D1_RGBTOHUE_PROP_OUTPUT_COLOR_SPACE, D2D1_RGBTOHUE_OUTPUT_COLOR_SPACE_HUE_SATURATION_VALUE);

m_d2dContext->BeginDraw();
m_d2dContext->DrawImage(rgbToHueEffect.Get());
m_d2dContext->EndDraw();
```

--------------------------------

### ID2D1Factory::CreateStrokeStyle

Source: https://learn.microsoft.com/en-us/windows/win32/direct2d/id2d1factory-createstrokestyle

Creates an ID2D1StrokeStyle that describes start cap, dash pattern, and other features of a stroke.

```APIDOC
## HRESULT CreateStrokeStyle(const D2D1_STROKE_STYLE_PROPERTIES &strokeStyleProperties, const FLOAT *dashes, UINT dashesCount, ID2D1StrokeStyle **strokeStyle)

### Description
Creates an ID2D1StrokeStyle that describes start cap, dash pattern, and other features of a stroke.

### Parameters
- **strokeStyleProperties** (D2D1_STROKE_STYLE_PROPERTIES &) - The stroke cap, line join, limit, dash offset, and other details of the stroke.
- **dashes** (FLOAT*) - An array of values for the dash pattern if the dash style is set to D2D1_DASH_STYLE_CUSTOM.
- **dashesCount** (UINT) - The number of elements in the dashes array.
- **strokeStyle** (ID2D1StrokeStyle**) - When this method returns, contains the address of the pointer to the new stroke style object.
```

--------------------------------

### Create an ID2D1Factory1

Source: https://learn.microsoft.com/en-us/windows/win32/Direct2D/direct2d-quickstart-with-device-context

Initializes a single-threaded ID2D1Factory1, which serves as the starting point for creating Direct2D resources.

```C++
DX::ThrowIfFailed(
        D2D1CreateFactory(
            D2D1_FACTORY_TYPE_SINGLE_THREADED,
            __uuidof(ID2D1Factory1),
            &options,
            &m_d2dFactory
            )
        );
```

--------------------------------

### Implementing the Tile effect in C++

Source: https://learn.microsoft.com/en-us/windows/win32/direct2d/tile

This example demonstrates how to create the tile effect, set the input bitmap, define the tiling rectangle, and render the result using the Direct2D device context.

```cpp
ComPtr<ID2D1Effect> tileEffect;
m_d2dContext->CreateEffect(CLSID_D2D1Tile, &tileEffect);

tileEffect->SetInput(0, bitmap);

tileEffect->SetValue(D2D1_TILE_PROP_RECT, D2D1::RectF(0.0f, 0.0f, 256.0f, 192.0f));

m_d2dContext->BeginDraw();
m_d2dContext->DrawImage(tileEffect.Get());
m_d2dContext->EndDraw();
```

--------------------------------

### ID2D1Effect::CreateEffect (CLSID_D2D1HueToRgb)

Source: https://learn.microsoft.com/en-us/windows/win32/Direct2D/hue-to-rgb-effect

Example of how to instantiate and use the Hue-to-RGB effect within a Direct2D rendering pipeline.

```APIDOC
## ID2D1Effect::CreateEffect (CLSID_D2D1HueToRgb)

### Description
Instantiates the Hue-to-RGB effect to convert input image data from HSL/HSV to RGB color space.

### Usage
```cpp
ComPtr<ID2D1Effect> hueToRgbEffect;
m_d2dContext->CreateEffect(CLSID_D2D1HueToRgb, &hueToRgbEffect);

hueToRgbEffect->SetInput(0, bitmap);
hueToRgbEffect->SetValue(D2D1_HUETORGB_INPUT_COLOR_SPACE, D2D1_HUETORGB_INPUT_COLOR_SPACE_HUE_SATURATION_LIGHTNESS);

m_d2dContext->BeginDraw();
m_d2dContext->DrawImage(hueToRgbEffect.Get());
m_d2dContext->EndDraw();
```
```

--------------------------------

### Create and apply the Hue-to-RGB effect in C++

Source: https://learn.microsoft.com/en-us/windows/win32/Direct2D/hue-to-rgb-effect

This example demonstrates how to instantiate the effect, set the input bitmap, configure the input color space, and draw the result within a Direct2D draw cycle.

```cpp
ComPtr<ID2D1Effect> hueToRgbEffect;
m_d2dContext->CreateEffect(CLSID_D2D1HueToRgb, &hueToRgbEffect);
 
hueToRgbEffect->SetInput(0, bitmap);
hueToRgbEffect->SetValue(D2D1_HUETORGB_INPUT_COLOR_SPACE, D2D1_HUETORGB_INPUT_COLOR_SPACE_HUE_SATURATION_LIGHTNESS);
 
m_d2dContext->BeginDraw();
m_d2dContext->DrawImage(hueToRgbEffect.Get());
m_d2dContext->EndDraw();
```

--------------------------------

### Create an ID2D1Factory

Source: https://learn.microsoft.com/en-us/windows/win32/direct2d/getting-started-with-direct2d

Initializes a single-threaded Direct2D factory, which serves as the starting point for creating Direct2D resources.

```C++
ID2D1Factory* pD2DFactory = NULL;
HRESULT hr = D2D1CreateFactory(
    D2D1_FACTORY_TYPE_SINGLE_THREADED,
    &pD2DFactory
    );
```

--------------------------------

### Implement DemoApp::OnRender

Source: https://learn.microsoft.com/en-us/windows/win32/Direct2D/direct2d-quickstart

Initializes the rendering process by creating device resources, clearing the render target, and drawing grid lines and rectangles.

```C++
HRESULT DemoApp::OnRender()
{
    HRESULT hr = S_OK;

    hr = CreateDeviceResources();
```

```C++
if (SUCCEEDED(hr))
{
```

```C++
m_pRenderTarget->BeginDraw();
m_pRenderTarget->SetTransform(D2D1::Matrix3x2F::Identity());
m_pRenderTarget->Clear(D2D1::ColorF(D2D1::ColorF::White));
```

```C++
D2D1_SIZE_F rtSize = m_pRenderTarget->GetSize();
```

```C++
// Draw a grid background.
int width = static_cast<int>(rtSize.width);
int height = static_cast<int>(rtSize.height);

for (int x = 0; x < width; x += 10)
{
    m_pRenderTarget->DrawLine(
        D2D1::Point2F(static_cast<FLOAT>(x), 0.0f),
        D2D1::Point2F(static_cast<FLOAT>(x), rtSize.height),
        m_pLightSlateGrayBrush,
        0.5f
        );
}

for (int y = 0; y < height; y += 10)
{
    m_pRenderTarget->DrawLine(
        D2D1::Point2F(0.0f, static_cast<FLOAT>(y)),
        D2D1::Point2F(rtSize.width, static_cast<FLOAT>(y)),
        m_pLightSlateGrayBrush,
        0.5f
        );
}
```

```C++
// Draw two rectangles.
D2D1_RECT_F rectangle1 = D2D1::RectF(
    rtSize.width/2 - 50.0f,
    rtSize.height/2 - 50.0f,
    rtSize.width/2 + 50.0f,
    rtSize.height/2 + 50.0f
    );

D2D1_RECT_F rectangle2 = D2D1::RectF(
    rtSize.width/2 - 100.0f,
    rtSize.height/2 - 100.0f,
    rtSize.width/2 + 100.0f,
    rtSize.height/2 + 100.0f
    );
```

```C++
// Draw a filled rectangle.
m_pRenderTarget->FillRectangle(&rectangle1, m_pLightSlateGrayBrush);
```

--------------------------------

### Create a WIC decoder and get the frame

Source: https://learn.microsoft.com/en-us/windows/win32/direct2d/load-a-id2d1image-using-the-filepicker

Initialize an IWICBitmapDecoder from the stream and extract the first frame of the image.

```cpp
    ComPtr<IWICBitmapDecoder> decoder;
    DX::ThrowIfFailed(
          m_wicFactory->CreateDecoderFromStream(
                    istream.Get(),
                    nullptr,
                    WICDecodeMetadataCacheOnDemand,
                    &decoder
                    )
          );
```

```cpp
    ComPtr<IWICBitmapFrameDecode> frame;
    DX::ThrowIfFailed(
        decoder->GetFrame(0, &frame)
        );
```

--------------------------------

### Create and draw geometry realizations in C++

Source: https://learn.microsoft.com/en-us/windows/win32/direct2d/improving-direct2d-performance

Demonstrates how to compute a flattening tolerance, create a filled geometry realization, and draw it using a device context.

```cpp
    // Compute a flattening tolerance based on the scales at which the realization will be used.
    float flatteningTolerance = D2D1::ComputeFlatteningTolerance(...);

    ComPtr<ID2D1GeometryRealization> geometryRealization;

    // Create realization of the filled interior of the geometry.
    m_d2dDeviceContext1->CreateFilledGeometryRealization(
        geometry.Get(),
        flatteningTolerance,
        &geometryRealization
        );

    // In your app's rendering code, draw the geometry realization with a brush.
    m_d2dDeviceContext1->BeginDraw();
    m_d2dDeviceContext1->DrawGeometryRealization(
        geometryRealization.Get(),
        m_brush.Get()
        );
    m_d2dDeviceContext1->EndDraw();
```
Tokens:
Raw