How to Draw on the C++ Window Frame
In this tutorial, you'll learn how to move an object in C++ across a window frame. This is one of the
fundamental ideas in C++ graphics programming, useful for creating animations, simple games, or visual simulations.
We'll will draw a circle - our body - using the Ellipse method with a HDC context.
Why Learn to Move Objects in C++?
Being able to animate an object across a window in C++ is an important step toward understanding how graphics work.
Whether you're moving a shape, an image, or a sprite, the process involves:
- Updating the object's position using coordinates.
- Redrawing the object in its new position.
- Refreshing the window frame.
This cycle creates the illusion of smooth motion.
Animating a Circle Across the C++ Canvas
To make the circle appear to move across the canvas, i.e., animate the circle, we'll
simply draw the circle repeatedly, changing its position progressively as well as clearing the previous image.
Create 2 new class files;
Call them Facet and MovingBody.
Type out the adjoining C++ code for animating an image body across the window frame.
Note: The C++ code module for our Dymetric Class was too big
to be squeezed in with the others.
It is simply included as a link of its own.
How the C++ Animation Code Works
- The `circle()` function draws the object.
- `x += 5;` updates the position, making the object move horizontally.
- The `while` loop keeps redrawing the object until a key is pressed.
- `if (x > getmaxx()) x = 0;` ensures the object resets when it reaches the window's edge.
This example shows the basics of object motion in C++ graphics.
Tips for Smooth Object Animation in C++
- Use a timer or delay to control speed and frame rate.
- Handle boundary detection so the object doesn't disappear.
- For more advanced projects, explore libraries like SFML or SDL for smoother graphics.
Frequently Asked Questions About Moving Objects in C++
1. How do you move an object in C++?
In C++, an object is moved across a window by updating its coordinates inside a loop,
redrawing it in the new position, and refreshing the window. This process creates the effect of motion.
2. What is the simplest way to move an object across a window in C++?
The simplest method is to use a while
loop with a delay. Inside the loop, clear the window,
draw the object, update its position (e.g., increment the x-coordinate), and repeat.
3. Which graphics libraries can I use to move objects in C++?
For beginners, the old BGI graphics library works for simple demos. For modern applications, libraries like SFML,
SDL, or OpenGL are recommended for smoother animations and better performance.
4. How do I prevent an object from going outside the window?
You can use boundary detection. Before updating the object’s position,
check if its coordinates exceed the window size. If it does, either reset its position or reverse its direction.
5. Can I animate multiple objects at once in C++?
Yes. You can animate multiple objects by tracking separate coordinates for each one,
updating them inside the same loop, and redrawing all objects frame by frame.
What You've Learnt on C++ Window Frame and Animation
In this tutorial, we've shown how to move an object in C++ across a window frame.
This technique is often used in C++ graphics programming and simple animation projects.
For example, to move a body across a window frame in C++, you update the object's coordinates inside
the event loop and redraw the frame. By applying these steps, you can easily move an object across a window in C++.
This concept extends to creating animations, games, and simulations where object motion is essential.
Key Takeaway on C++ Window Frame and Animation
By following this guide, you now know how to move an object across a window in C++.
This technique is the foundation of creating animations, interactive programs, and games.
So! C++ Fun Practice Exercise - Animate Circle
As a fun practice exercise, try experimenting with shapes, speeds, and directions
to deepen your understanding of object movement in C++ graphics.
Dymetric C++ Window Code Stub
Canvas Frame and Button Controls - Header file
#pragma once
class Facet
{
public:
Facet(HWND, int, int);
virtual ~Facet();
bool decorateButton(WPARAM, LPARAM);
bool actionPerformed(HWND, WPARAM, LPARAM);
void informPaint();
};
Canvas Frame and Button Controls - Class file
#include "stdafx.h"
#include "Facet.h"
#include "MovingBody.h"
MovingBody* traction;
Facet::Facet(HWND hWnd, int window_width, int window_height)
{
traction = new MovingBody(hWnd, window_width, window_height);
}
bool Facet::decorateButton(WPARAM wParam, LPARAM lParam) {
if (wParam == 12321)
{
LPDRAWITEMSTRUCT lpDIS = (LPDRAWITEMSTRUCT)lParam;
SetDCBrushColor(lpDIS->hDC, RGB(255, 192, 203));
SelectObject(lpDIS->hDC, GetStockObject(DC_BRUSH));
RECT rect = { 0 };
rect.left = lpDIS->rcItem.left;
rect.right = lpDIS->rcItem.right;
rect.top = lpDIS->rcItem.top;
rect.bottom = lpDIS->rcItem.bottom;
RoundRect(lpDIS->hDC, rect.left, rect.top, rect.right, rect.bottom, 50, 50);
DrawText(lpDIS->hDC, TEXT("GLIDE"), -1, &rect, DT_SINGLELINE | DT_CENTER | DT_VCENTER);
return TRUE;
}
return FALSE;
}
void Facet::informPaint() {
traction->paint();
}
bool Facet::actionPerformed(HWND hWnd, WPARAM wParam, LPARAM lParam)
{
switch (LOWORD(wParam))
{
case 12321:
traction->doGlide();
return TRUE;
default:
return FALSE;
}
}
Facet::~Facet()
{
delete traction;
}
C++ Animation Code for Moving Body Header File
#pragma once
class MovingBody
{
public:
MovingBody(HWND, int, int);
virtual ~MovingBody();
void paint();
void doGlide();
protected:
HWND hWindow;
HDC hdc;
int window_width;
int window_height;
COLORREF ball_colour;
int x;
int y;
HPEN background_pen;
HBRUSH background_brush;
HPEN ball_pen;
HBRUSH ball_brush;
};
C++ Animation Code for Moving Body Class File
#include "stdafx.h"
#include "MovingBody.h"
#define aWIDTH 80
#define aHEIGHT 80
MovingBody::MovingBody(HWND hWnd, int window_width, int window_height)
{
hWindow = hWnd;
this->window_width = window_width;
this->window_height = window_height;
ball_colour = RGB(255, 0, 0);
x = 10;
y = 110;
background_pen = CreatePen(PS_SOLID, 1, RGB(192, 192, 192));
background_brush = CreateSolidBrush(RGB(192, 192, 192));
ball_pen = CreatePen(PS_SOLID, 1, RGB(0, 0, 0));
ball_brush = CreateSolidBrush(ball_colour);
hdc = GetDC(hWindow);
}
void MovingBody::paint() {
SelectObject(hdc, background_pen);
SelectObject(hdc, background_brush);
Ellipse(hdc, x - 10, y, x - 10 + aWIDTH, y + aHEIGHT);
SelectObject(hdc, ball_pen);
SelectObject(hdc, ball_brush);
Ellipse(hdc, x, y, x + aWIDTH, y + aHEIGHT);
}
void MovingBody::doGlide() {
while (x + aWIDTH <= window_width) {
paint();
x += 10;
Sleep(50);
}
}
MovingBody::~MovingBody()
{
DeleteObject(background_pen);
DeleteObject(background_brush);
DeleteObject(ball_pen);
DeleteObject(ball_brush);
ReleaseDC(hWindow, hdc);
}