Visual Studio C++ How do I stop images from being scaled wrong when I maximize window D3D11 and D2D1

Question

So I'm trying to iron out kinks of how I'm rendering images with direct stuff. Right now it works as a DXGISwapchain with D3D11 and I make a ID2D1RenderTarget which I draw to using bitmaps. My issue is when I hit the maximize button on the window my images are off, or at least the ones using data from the window grabbed with GetClientRect (the others seem... close enough but probably still off and I want to be able to use the client space to scale and draw things later as well). I have a D2D1::RectF set with the top left at 0.0f and the bottom right as the window's height and width grabbed via GetClientRect (along with a few others just for additional fooling around). Looked around and it seems like I need to call recreate the ID2D1RenderTarget and/or resize the buffers. Calling a function to recreate the ID2D1RenderTarget before making objects which contain the bitmaps and the functions which draw them did not help with the issue at all. I tried resizing the buffers but I keep getting errors, first set were regarding parameters, but before fixing that I realized I needed to release the objects, but now my it seems since I have made the objects with ComPtr it seems how it deals with deleting them is having issues. client.h is calling an exception: "Access violation executing location " with the unsigned long InternalRelease() function. This occurs with the function to adjust the buffers and target. So right now I'm lost as to what to do in order to get the desired effect. Only other things to note is the ID3D11RenderTargetView I made is used to clear to a color since for I had errors with calling Clear(D2D1::ColorF(D2D1::ColorF::White)); on my ID2D1RenderTarget. I don't care if the solution to this resizes the ID3D11RenderTargetView unless it will improve speed for the program or prevent some sort of unforeseen issue elsewhere since I don't intend to use it aside for that. If I could call clear on the ID2D1RenderTarget and no longer need the ID311RenderTargetView and keep the swapchain while resolving the issue that would work too. Also I intend to work out fullscreen mode next so a method that works with that would also be very much desired. I'm also open to take any other advice here, while it's not polished and just in a form to get things working first, I probably will miss things even when tidying up. Anyway here's the code:

Here's the Graphics class where I make the swapchain, buffers and rendertargets and such and the function in which I try and reset the buffers. Side note I followed some tutorials on my way here to get me to understand enough of the direct stuff to get here and get to the point where I'm looking into to stuff on Microsoft and understanding it somewhat to solve problems I have. Anyway one of them went through making some exceptions and that is what stuff like Graphic_Throw_Failure() are for. (though I did it wrong or the errors are doing something and I can't see the pop up window half the time, sometimes it stops in the exception code but I can still read the message)

//not in the cpp file but just how some variables exist for clarity.
private:
    
    Microsoft::WRL::ComPtr<ID3D11Device> pDevice = nullptr;
    Microsoft::WRL::ComPtr < IDXGISwapChain> pSwapChain = nullptr;
    Microsoft::WRL::ComPtr < ID3D11DeviceContext> pContext = nullptr;
    Microsoft::WRL::ComPtr < ID3D11RenderTargetView> pRTarget = nullptr;
    ID2D1RenderTarget* p2dRenderTarget = nullptr;
    ID2D1Factory* p2DFactory = nullptr;
    

Graphics::Graphics(HWND hwnd) {
    
    DXGI_SWAP_CHAIN_DESC swapchainDesc = {};
    ZeroMemory(&swapchainDesc, sizeof(DXGI_SWAP_CHAIN_DESC));
    swapchainDesc.Windowed = true;
    swapchainDesc.BufferCount = 1;
    swapchainDesc.BufferDesc.Height = 0;
    swapchainDesc.BufferDesc.Width = 0;
    swapchainDesc.BufferDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;
    swapchainDesc.SampleDesc.Count = 1;
    swapchainDesc.SampleDesc.Quality = 0;
    swapchainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
    swapchainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
    swapchainDesc.BufferDesc.RefreshRate.Numerator = 1;
    swapchainDesc.BufferDesc.RefreshRate.Denominator = 60;
    swapchainDesc.OutputWindow = hwnd;
    HRESULT hre;
    Graphic_Throw_Failure(D3D11CreateDeviceAndSwapChain(
        nullptr,
        D3D_DRIVER_TYPE_HARDWARE,
        nullptr,
        D3D11_CREATE_DEVICE_BGRA_SUPPORT,
        levels,
        4,
        D3D11_SDK_VERSION,
        &swapchainDesc,
        &pSwapChain,
        &pDevice,
        nullptr,
        &pContext
    ));

  
   
    
   //3Dbuffer setup
    wrl::ComPtr<ID3D11Resource> p3dbuffer = nullptr;
    Graphic_Throw_Failure(pSwapChain->GetBuffer(0, __uuidof(ID3D11Resource), &p3dbuffer));
    Graphic_Throw_Failure(pDevice->CreateRenderTargetView(p3dbuffer.Get(), nullptr, &pRTarget));

    //2D buffer Setup
    

    IDXGISurface* pBackBuffer = nullptr;
    Graphic_Throw_Failure(pSwapChain->GetBuffer(0,IID_PPV_ARGS(&pBackBuffer)));

    //makes 2d Factory
    Graphic_Throw_Failure(D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, &p2DFactory));
    
    //sets up DXGI buffer for 2d
    FLOAT dpi;
    dpi = GetDpiForWindow(hwnd);
    //p2DFactory->GetDesktopDpi(&dpiX, &dpiY);

    D2D1_RENDER_TARGET_PROPERTIES p2dRTprops =
        D2D1::RenderTargetProperties(
            D2D1_RENDER_TARGET_TYPE_DEFAULT,
            D2D1::PixelFormat(DXGI_FORMAT_UNKNOWN, D2D1_ALPHA_MODE_PREMULTIPLIED),
            dpi,
            dpi
        );
        

    Graphic_Throw_Failure(p2DFactory->CreateDxgiSurfaceRenderTarget(
        pBackBuffer, &p2dRTprops, &p2dRenderTarget

    ));

    

    if(pBackBuffer!=nullptr)
    pBackBuffer->Release();
}



//the adjusting function I failed to make. could also be missing somethings I need to clear before
//calling ResizeBuffers


void Graphics::adjustRenderTargets(HWND hwnd) {
  HRESULT hre;


    pContext->ClearState();
    p2dRenderTarget->Release();
    pRTarget->Release();

    //3Dbuffer setup
    wrl::ComPtr<ID3D11Resource> p3dbuffer = nullptr;
    Graphic_Throw_Failure(pSwapChain->GetBuffer(0, __uuidof(ID3D11Resource), &p3dbuffer));
    Graphic_Throw_Failure(pDevice->CreateRenderTargetView(p3dbuffer.Get(), nullptr, &pRTarget));

    //2D buffer Setup


    IDXGISurface* pBackBuffer = nullptr;
    Graphic_Throw_Failure(pSwapChain->GetBuffer(0, IID_PPV_ARGS(&pBackBuffer)));

    //makes 2d Factory
    Graphic_Throw_Failure(D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, &p2DFactory));

    //sets up DXGI buffer for 2d
    FLOAT dpi;
    dpi = GetDpiForWindow(hwnd);
    //p2DFactory->GetDesktopDpi(&dpiX, &dpiY);

    D2D1_RENDER_TARGET_PROPERTIES p2dRTprops =
        D2D1::RenderTargetProperties(
            D2D1_RENDER_TARGET_TYPE_DEFAULT,
            D2D1::PixelFormat(DXGI_FORMAT_UNKNOWN, D2D1_ALPHA_MODE_PREMULTIPLIED),
            dpi,
            dpi
        );


    Graphic_Throw_Failure(p2DFactory->CreateDxgiSurfaceRenderTarget(
        pBackBuffer, &p2dRTprops, &p2dRenderTarget

    ));



    if (pBackBuffer != nullptr)
        pBackBuffer->Release();
    
};
//and the destructor in case there is something still wrong there though 
//currently not giving me issues since I set the objects in it to nullptr after releasing it. 
//didn't work for the ComPtr.

  Graphics::~Graphics() {
        if (p2DFactory != nullptr) {
            p2DFactory->Release();
        }

        if (p2dRenderTarget != nullptr) {
            p2dRenderTarget->Release();
        }
    }

This is the class which holds the bitmaps and deals with them and drawing them. Once again I made some exceptions for this class

//some variables in the header file
ID2D1Bitmap* Bittmap=nullptr;
     Graphics* GFX;

Sprites::Sprites(const wchar_t* filename, Graphics* gfx) {
    
    HRESULT hre;
    GFX = gfx;


    //makes WIC Factory
    
    IWICImagingFactory* WICfactory = NULL;
    Sprite_Throw_Failure(CoCreateInstance(
        CLSID_WICImagingFactory,
        NULL,
        CLSCTX_INPROC_SERVER,
        IID_IWICImagingFactory,
        (LPVOID*)&WICfactory
    ));

    //Makes the Decoder

    IWICBitmapDecoder* WICdecode = NULL;
    Sprite_Throw_Failure(WICfactory->CreateDecoderFromFilename(
        filename,
        NULL,
        GENERIC_READ,
        WICDecodeMetadataCacheOnLoad,
        &WICdecode
    ));
    
    //Read the frame (should be only one so read the image)
    IWICBitmapFrameDecode* WICframe = NULL;
    Sprite_Throw_Failure(WICdecode->GetFrame(0, &WICframe));

    //Format converter
    IWICFormatConverter* WICconverter = NULL;
    Sprite_Throw_Failure(WICfactory->CreateFormatConverter(&WICconverter));

    //makes the converter set up to create a 32bpp BGRA bitmap
    Sprite_Throw_Failure(WICconverter->Initialize(
        WICframe,
        GUID_WICPixelFormat32bppPBGRA,
        WICBitmapDitherTypeNone,
        NULL,
        0.0,
        WICBitmapPaletteTypeCustom
    ));

    //makes the bitmap
    
    Sprite_Throw_Failure(GFX->Get2DRenderTarget()->CreateBitmapFromWicBitmap(
    WICconverter,
    NULL,
    &Bittmap
    ));

    if (WICfactory) WICfactory->Release();
    if (WICdecode) WICdecode->Release();
    if (WICconverter)WICconverter->Release();
    if (WICframe)WICframe->Release();

}
//draws the sprites
void Sprites::Draw(D2D1_RECT_F location) {
    HRESULT hre;
    GFX->Get2DRenderTarget()->BeginDraw();
    GFX->Get2DRenderTarget()->DrawBitmap(
        Bittmap,
        location, //destination rect
        1.0f, //opacity
        D2D1_BITMAP_INTERPOLATION_MODE::D2D1_BITMAP_INTERPOLATION_MODE_NEAREST_NEIGHBOR,
        D2D1::RectF(
            1980.0f, 2850.0f, 3000.0f, 
            3600.0f) //source rect
        );
    

    Sprite_Throw_Failure(GFX->Get2DRenderTarget()-> EndDraw());
}


Sprites::~Sprites() {
    //bitmapsheet.clear();
    if (Bittmap != nullptr) {
        Bittmap->Release();
    }



}

This is the class which the main loop is handled wnd is the windowclass I made which makes and manages the window. I use it here to get the graphics object the window uses which has all the direct stuff. here are some variables that appear, forgive the name bob.

//in header file
private:
    Window wnd;

//in cpp file
Sprites* testsprite;
Sprites* testsprite2;
D2D1_RECT_F bob;

within the function that calls over and over for the duration of the program at the part where I render:

//inefficient constant adjusting of rendering just so I can quickly assess 
//the change and make sure it works so when I implement how I intend the windows to be scaled it 
//will already be done
  wnd.GFX().adjustRenderTargets(wnd.getwindowhandle());

//clearing the ID3D11RenderTargetView to a color
  wnd.GFX().ClearBuffer(0.3f, 0.5f, 1.0f);
//drawing calls



       
        const wchar_t* filename = L"\environmentsketches 02.png";

        //this creates a Sprites object getGraphix returns the a pointer to the graphics object
        //only really used to get the ID2D1RenderTarget but I may use it for other things, will
        //remove later if not needed and just pass the render target unless issues arise.
        testsprite = new Sprites(filename, wnd.GFX().getGraphix());

      
        bob = D2D1::RectF(
            0.0f, 0.0f, wnd.getwindowWidth(),
            wnd.getwindowHeight());
         //This draws the bitmap of a predetermined portion of the image but uses bob to
         // to determine where to draw the bitmap  
        testsprite->Draw(bob);

        bob = D2D1::RectF(
            0.0f, 0.0f, wnd.getwindowWidth()/(16.0f/9.0f),
            wnd.getwindowHeight());

       testsprite->Draw(bob);


        filename= L"\envrioment sketch march 1.png";
        bob = D2D1::RectF(
            100.0f, 100.0f, 600.f,
            300.f);
        
        testsprite2 = new Sprites(filename, wnd.GFX().getGraphix());
        testsprite2->Draw(bob);

        //EndFrame just calls present on the IDXGISwapChain
        wnd.GFX().EndFrame();
        testsprite->~Sprites();
        testsprite2->~Sprites();

If you read through this thank you and thank you for any advice you have to offer.

Answer 1

Don't code late or tired. So first thing I realized is one when posting the code here I forgot to include the call for SwapChain->ResizeBuffers(0,width,height, DXGI_FORMAT_UNKNOWN, 0)) which is where the mistake was. I changed my pointers from smart to regular to manage their release manually for this, but the issue was more so that the last parameter wasn't 0, it was D3D11_CREATE_DEVICE_BGRA_SUPPORT instead of a proper swapchain flag and was reading as another (I believe DXGI_SWAP_CHAIN_FLAG_DISPLAY_ONLY) which I couldn't use because of how I made my swapchain resulting in an error and it just not running.

In all the solution to my problem was to release my render targets (I already released by buffers after I made the targets), resize the buffers and then remake the ID2D1RenderTarget. Just don't put a wrong flag in, (or make sure the call is in when posting it for feedback to the mistake might be caught by others.)