Как работать с WriteConsoleOutput?

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <cassert>
#include <windows.h>
 
struct Point
{
    int x;
    int y;
};
 
template <size_t Lines, size_t Chars>
class screen_buffer
{
    void reset_position()
    {
        static COORD crd = {};
        SetConsoleCursorPosition(hStdout_, crd);
    }
 
public:
    enum
    {
        Size = Lines * Chars
    };
 
    screen_buffer()
        : hStdout_(GetStdHandle(STD_OUTPUT_HANDLE))
    {
        clear();
    }
 
    void flush()
    {
        SMALL_RECT srctWriteRect = { 0, 0, Chars - 1, Lines - 1 };
        COORD crd   = { 0, 0 };
        COORD bsize = { Chars, Lines };
 
        CHAR_INFO chInfo[Size];
        for(size_t i = 0; i < Size; ++i)
        {
            chInfo[i].Char.AsciiChar = screen_[i] ? screen_[i] : ' ';
            chInfo[i].Attributes     = 7;
        }
        WriteConsoleOutput(hStdout_, chInfo, bsize, crd, &srctWriteRect);
    }
 
    int printf(char const * format, ...)
    {
        va_list args;
        va_start(args, format);
        const size_t remainLen = Size - screenOff_;
        const int r = std::vsnprintf(&screen_[screenOff_], remainLen, format, args);
        screenOff_ += r;
        va_end(args);
        return r;
    }
    int printf(size_t x, size_t y, char const * format, ...)
    {
        va_list args;
        va_start(args, format);
        char * off = &screen_[x + y * Chars];
        char * beg = &screen_[0];
        const size_t remainLen = Size - std::distance(beg, off);
        const int r = std::vsnprintf(off, remainLen, format, args);
        va_end(args);
        return r;
    }
    int write(char const * data, size_t len)
    {
        const size_t remainLen = Size - screenOff_;
        const size_t count = len > remainLen ? remainLen : len;
        std::memcpy(&screen_[screenOff_], data, count);
        screenOff_ += count;
        return count;
    }
    int write(size_t x, size_t y, char const * data, size_t len)
    {
        char * off = &screen_[x + y * Chars];
        char * beg = &screen_[0];
        const size_t remainLen = Size - std::distance(beg, off);
        const size_t count = len > remainLen ? remainLen : len;
        std::memcpy(off, data, count);
        return count;
    }
    //Bresenham's line algorithm
    void line(Point p0, Point p1)
    {
        const int deltaX = std::abs(p1.x - p0.x);
        const int deltaY = std::abs(p1.y - p0.y);
        const int signX = p0.x < p1.x ? 1 : -1;
        const int signY = p0.y < p1.y ? 1 : -1;
        //
        int error = deltaX - deltaY;
        //
        size_t index = p1.x + p1.y * Chars;
        if(index >= 0 && index < Size)
        {
            screen_[index] = '*';
        }
        while(p0.x != p1.x || p0.y != p1.y)
        {
            index = p0.x + p0.y * Chars;
            if(index >= 0 && index < Size)
            {
                screen_[index] = '*';
            }
            const int error2 = error * 2;
            //
            if(error2 > -deltaY)
            {
                error -= deltaY;
                p0.x += signX;
            }
            if(error2 < deltaX)
            {
                error += deltaX;
                p0.y += signY;
            }
        }
    }
 
    void clear()
    {
        screenOff_ = 0;
        std::memset(screen_, ' ', Size);
    }
 
private:
    HANDLE hStdout_;
    size_t screenOff_;
    char   screen_[Size];
};
 
int main()
{
    screen_buffer<25, 80> conBuf;
 
    const int side = 5;
    const double pi = 3.14;
    // углы
    const double alpha  = 120 * pi / 180;
    const double beta   = 30  * pi / 180;
    const double radius = side * std::sin(alpha) / std::sin(beta);
 
    const size_t numPoints = 6;
    const double angle = 2 * pi / numPoints;
 
    int x = 5;
    int y = 10;
    int phi = 0;
 
    Point points[numPoints];
    do
    {
        for(size_t i = 0; i < numPoints; ++i)
        {
            points[i].x = int(x + radius * std::sin(phi + i * angle));
            points[i].y = int(y + radius * std::cos(phi + i * angle));
        }
        conBuf.clear();
        conBuf.printf(x, y, "^");
        for(size_t i = 0; i < numPoints; ++i)
        {
            conBuf.line(points[i], points[(i + 2) % numPoints]);
        }
        conBuf.flush();
 
        x = (x + 2) % 79; // катимся
 
        Sleep(70);
    }
    while((phi += 4) < 14400);
}