How does the console implement double buffering? How to implement double buffering in C

The double buffer on the Internet refers to the program of the graphic mode,You are in character mode,If you want to brush fast,Not with double buffer,But to write the screen directly。

In the process of programming graphics processing, double buffering is a basic technique. We know that if a form is going through complex graphics processing in response to a WM PAINT message, the form will cause flickering due to over-refresh when redrawn. An effective solution to this problem is double-buffering.

Because when the form is refreshed, there is always a process of erasing the original image onerasebkgnd, which uses the background color to fill the drawing area of the form, and then calls the new drawing** to redraw, so that the contrast of the image color is caused by the erase and writing. This contrast becomes more pronounced when WM Paint's response is frequent. So we saw the flickering phenomenon.

Double-buffering, it is natural for us to think that avoiding the filling of background colors is the most straightforward way. But then the form becomes a mess. Because the original image is not removed every time the image is drawn, the image remains are left, so when the window is redrawn, the picture often becomes messy.

So it's not enough to simply prohibit background redrawing. We also had to redraw, but it was fast, so we thought of using the bitblt function. It can support the copying of graphic blocks at a fast speed.

We can first make a graph in memory, and then use this function to copy the finished graph to the foreground while disabling background refresh, so that the flicker is eliminated. The above is the basic idea of double-buffer drawing.

The implemented program is given first, and then explained, again in OnDraw(CDC*PDC):

cdc memdc;Start by defining a display device object.

cbitmap membitmap;Define a bitmap object.

Subsequently, a memory display device that is compatible with the screen display is established.

At this time, you can't draw because there is no place to draw

Let's create a bitmap that is compatible with the screen display, as for the size of the bitmap, you can use the size of the window, or you can define it yourself (for example, if there is a scrollbar, it should be larger than the current window size, and in bitblt you decide which part of the memory to copy to the screen).

nwidth,nheight);

Select the bitmap into the memory display device.

Only the memory display device that has the bitmap selected will have a place to draw on the specified bitmap.

First, use the background color to clear the bitmap, here I used white as the background.

You can also use the colors you should use.

0,nwidth,nheight,rgb(255,255,255));

Drawing.; Copy the diagram from memory to the screen for display.

pdc->

Cleanup after the drawing is complete.

Pick back the poldbit from the front. Remove the membitmap from your device before deleting it.

;Two way soft-closing

It's safe, it lasts longer, and if it breaks down, it won't crash right away.

jPanel has implemented double buffering itself.

If you need to write your own double buffering.

with bufferedimage br=new bufferedimage(w,h,type); Create a sheet of the specified size (usually the size of the window), with the type, buffer**.

graphics2d g2d=;

Draw with G2D.

After that, it is good to copy it to the context of jpanel all at once.

It also depends on the refresh area and refresh rate of your window, and double buffering doesn't solve all the problems, it depends on your control. Remember:1

Refresh the window as little as possible. 2.Refresh the window, keeping the area to a minimum.

PS: GDI+ has nothing to do with double buffering, GDI can also do double buffering, and the drawing efficiency is higher than GDI+.

The double buffer should be placed inside the update method.

The call case is repaint() update(graphics g) -paint(graphics g).

Here's how.

public void update(graphics g)bufferg=;

color c = ;,0, ,x,y,this);

paint(bufferg);

0,0,this);

public void paint(graphics g)

With Swing, it defaults to double cushioning.

Yes, this is AWT's double-buffered method, you have to write your own update method, and swing can call the paint method of the parent class to achieve double-buffering, if you still write, it has no effect.