Am I using double buffering?

Question

I am building a Windows MFC application. During some animations where objects collide at high speeds, my physics engine behaves unpredictably. I believe it has something to do with me dropping frames somehow. I was told that I'm not using double buffering. I thought I was, but I am still fairly new to this. Here is how I draw to the screen in OnPaint:

#include "pch.h"
#include "framework.h"
#include "ChildView.h"
#include "DoubleBufferDC.h"

void CChildView::OnPaint()
{
    CPaintDC paintDC(this);     // device context for painting
    CDoubleBufferDC dc(&paintDC); // device context for painting
    Graphics graphics(dc.m_hDC);    // Create GDI+ graphics context
    mGame.OnDraw(&graphics);

    if (mFirstDraw)
    {
        mFirstDraw = false;
        SetTimer(1, FrameDuration, nullptr);

        /*
         * Initialize the elapsed time system
         */
        LARGE_INTEGER time, freq;
        QueryPerformanceCounter(&time);
        QueryPerformanceFrequency(&freq);

        mLastTime = time.QuadPart;
        mTimeFreq = double(freq.QuadPart);
    }

    /*
     * Compute the elapsed time since the last draw
     */
    LARGE_INTEGER time;
    QueryPerformanceCounter(&time);
    long long diff = time.QuadPart - mLastTime;
    double elapsed = double(diff) / mTimeFreq;
    mLastTime = time.QuadPart;

    mGame.Update(elapsed);
}

void CChildView::OnTimer(UINT_PTR nIDEvent)
{
    // TODO: Add your message handler code here and/or call default
    RedrawWindow(NULL, NULL, RDW_UPDATENOW);
    Invalidate();
    CWnd::OnTimer(nIDEvent);
}

When I create the Graphics object from the CDoubleBufferDC object, is this not creating a back buffer? I then pass this Graphics object to OnDraw where it is drawn on. If it is creating a back buffer, I'm confused about where the front buffer is created and when it is drawn on the screen.

Here are my current thoughts on how I think this works:

1. The CPaintDC object is the front buffer
2. The CDoubleBufferDC object is the back buffer
3. A graphics object is created from the CDoubleBufferDC object which I draw the current state of the game on

If this is the case, when is the front buffer ever replaced with the new buffer created in the back? Can someone help me understand, and use double buffering if I'm not already?

Answer 1

To answer your actual question, what is probably happening is that your CDoubleBufferDC() class has a destructor that swaps out the DC's - this is a common idiom (IIRC in 'modern' MFC versions CMemDC does that too). So yes I think you are using double buffering here, even if accidentally. You can do the drawing in GDI(+) for simple games, if this whole thing is a learning exercise, this way is much easier to understand than using DirectX.

However, you do need to decouple your collision detection from your drawing routines, so that any dropped frames don't mess up your timing (that is, if you're things so complex that they take that much time - in which case, you probably shouldn't be using GDI...). In other words, if your collision detection assumes that each OnDraw() call completes in less than 1/framerate seconds but that doesn't always happen, you'll run into problems at some point. There are many articles online about how to structure your game loop; I don't have enough information to link you to a specific one. Also it won't be easy to find one using the technology you're using, in 2020... But I do think that using a simple OnPaint()/GDI one is great for learning, as it will hide much of the complexity you need for more modern approaches.