algorytm rysowania trójkąta ?

typedef unsigned char uchar;

    std::vector<uchar> ImgRaw;
    int ImgW = 640;
    int ImgH = 480;

// Rysowanie połowy trójkąta
void MainWindow::DrawHalfTriangle(int X0, int Y0, int X1, int X2, int Y_, uchar R0, uchar G0, uchar B0)
{
    int DrawX0 = X0;
    int DrawY0 = Y0;
    int DrawX1 = X1;
    int DrawX2 = X2;
    int DrawY_ = Y_;

    int X, Y, YI1, YI2, XI1, XI2;
    double DX1, DX2, DZ1, DZ2, DY, DYX, A1, A2, A1Z, A2Z;

    if (DrawX1 > DrawX2)
    {
        X = DrawX1;
        DrawX1 = DrawX2;
        DrawX2 = X;
    }

    DX1 = DrawX1 - DrawX0;
    DX2 = DrawX2 - DrawX0;
    DY = DrawY0 - DrawY_;
    A1 = DX1 / DY;
    A2 = DX2 / DY;
    A1Z = DZ1 / DY;
    A2Z = DZ2 / DY;

    if (DrawY_ < DrawY0)
    {
        YI1 = DrawY_;
        YI2 = DrawY0;
    }
    else
    {
        YI1 = DrawY0;
        YI2 = DrawY_;
    }

    for (Y = YI1; Y <= YI2; Y++)
    {
        DYX = (DrawY_ - Y);
        XI1 = round(DYX * A1) + DrawX1;
        XI2 = round(DYX * A2) + DrawX2;
        for (X = XI1; X <= XI2; X++)
        {
            int Pos = (Y * ImgW) + X;
            int Pos4X = Pos << 2;
            ImgRaw[Pos4X + 0] = R0;
            ImgRaw[Pos4X + 1] = G0;
            ImgRaw[Pos4X + 2] = B0;
        }
    }
}

// Rysowanie trójkąta z wykorzystaniem funkcji rysujących połowę
void MainWindow::DrawTriangle(int X1, int Y1, int X2, int Y2, int X3, int Y3, uchar R0, uchar G0, uchar B0)
{
    int XMin;
    int XMax;
    int YMin;
    int YMax;

    double F1, F2, F3, F4;

    int P0X_;
    int P0X__;
    int P0Y_;
    int P1X_;
    int P1Y_;
    int P2X_;
    int P2Y_;

    XMin = X1;
    XMax = X1;
    if (XMin > X2) { XMin = X2; }
    if (XMax < X2) { XMax = X2; }
    if (XMin > X3) { XMin = X3; }
    if (XMax < X3) { XMax = X3; }

    YMin = Y1;
    YMax = Y1;
    if (YMin > Y2) { YMin = Y2; }
    if (YMax < Y2) { YMax = Y2; }
    if (YMin > Y3) { YMin = Y3; }
    if (YMax < Y3) { YMax = Y3; }

    P0Y_ = YMin;

    if ((Y1 > YMin) && (Y1 < YMax))
    {
        P0X_ = X1; P0Y_ = Y1;
        if (Y2 == YMin)
        {
            P1X_ = X2; P1Y_ = Y2;
            P2X_ = X3; P2Y_ = Y3;
        }
        else
        {
            P1X_ = X3; P1Y_ = Y3;
            P2X_ = X2; P2Y_ = Y2;
        }
    }
    else
    {
        if ((Y2 > YMin) && (Y2 < YMax))
        {
            P0X_ = X2; P0Y_ = Y2;
            if (Y3 == YMin)
            {
                P1X_ = X3; P1Y_ = Y3;
                P2X_ = X1; P2Y_ = Y1;
            }
            else
            {
                P1X_ = X1; P1Y_ = Y1;
                P2X_ = X3; P2Y_ = Y3;
            }
        }
        else
        {
            if ((Y3 > YMin) && (Y3 < YMax))
            {
                P0X_ = X3; P0Y_ = Y3;
                if (Y1 == YMin)
                {
                    P1X_ = X1; P1Y_ = Y1;
                    P2X_ = X2; P2Y_ = Y2;
                }
                else
                {
                    P1X_ = X2; P1Y_ = Y2;
                    P2X_ = X1; P2Y_ = Y1;
                }
            }
        }
    }



    if ((P0Y_ > YMin) && (P0Y_ < YMax))
    {
        F1 = P0Y_ - P1Y_;
        F2 = P2Y_ - P1Y_;

        F3 = P2X_ - P1X_;
        F4 = F3 * (F1 / F2);

        P0X__ = P1X_ + F4;

        DrawHalfTriangle(P1X_, P1Y_, P0X_, P0X__, P0Y_, R0, G0, B0);
        DrawHalfTriangle(P2X_, P2Y_, P0X_, P0X__, P0Y_, R0, G0, B0);
    }
    else
    {
        if (Y1 == Y2)
        {
            DrawHalfTriangle(X3, Y3, X1, X2, Y1, R0, G0, B0);
        }
        if (Y2 == Y3)
        {
            DrawHalfTriangle(X1, Y1, X2, X3, Y2, R0, G0, B0);
        }
        if (Y3 == Y1)
        {
            DrawHalfTriangle(X2, Y2, X3, X1, Y3, R0, G0, B0);
        }
    }
}


// Przykładowa funkcja w programie
void MainWindow::on_pushButton_clicked()
{

    // Przygotowanie tablicy "unsigned char" symulującej bitmapę
    ImgW = 40;
    ImgH = 40;
    ImgRaw.clear();
    for (int i = 0; i < (ImgW * ImgH * 4); i++)
    {
        ImgRaw.push_back(0);
    }


    // Rysowanie przykładowych trójkątow
    DrawTriangle(5, 5, 18, 7, 10, 30, 1, 1, 1);
    DrawTriangle(20, 37, 17, 28, 38, 26, 2, 2, 2);


    // Wypisanie tablicy symulującej bitmapę
    int ptr = 0;
    for (int y = 0; y < ImgH; y++)
    {
        for (int x = 0; x < ImgW; x++)
        {
            switch (ImgRaw[ptr])
            {
                case 0: std::cout << "."; break;
                case 1: std::cout << "#"; break;
                case 2: std::cout << "@"; break;
            }
            ptr += 4;
        }
        std::cout << std::endl;
    }
}

            int Pos = (Y * ImgW) + X;
            int Pos4X = Pos << 2;
            ImgRaw[Pos4X + 0] = R0;
            ImgRaw[Pos4X + 1] = G0;
            ImgRaw[Pos4X + 2] = B0;

void fillTriangle(int x1, int y1, int x2, int y2, int x3, int y3) {
    // Find the bounding box of the triangle
    int minY = min({y1, y2, y3});
    int maxY = max({y1, y2, y3});

    // Loop through each scanline from minY to maxY
    for (int y = minY; y <= maxY; ++y) {
        // Find the intersections of the scanline with the triangle edges
        int x_intersection1 = -1, x_intersection2 = -1;

        // Check if the scanline intersects with the edge (x1, y1) to (x2, y2)
        if ((y1 <= y && y2 > y) || (y2 <= y && y1 > y)) {
            x_intersection1 = x1 + (y - y1) * (x2 - x1) / (y2 - y1);
        }

        // Check if the scanline intersects with the edge (x2, y2) to (x3, y3)
        if ((y2 <= y && y3 > y) || (y3 <= y && y2 > y)) {
            x_intersection2 = x2 + (y - y2) * (x3 - x2) / (y3 - y2);
        }

        // Check if the scanline intersects with the edge (x3, y3) to (x1, y1)
        if ((y3 <= y && y1 > y) || (y1 <= y && y3 > y)) {
            x_intersection1 = x3 + (y - y3) * (x1 - x3) / (y1 - y3);
        }

        // Ensure the intersection points are ordered from left to right
        if (x_intersection1 > x_intersection2)
            swap(x_intersection1, x_intersection2);

        // Fill the pixels between the two intersections
        for (int x = x_intersection1; x <= x_intersection2; ++x) {
            putPixel(x, y);
        }
    }
}

void swap(int &a, int &b)
{
	int c=a;
	a=b;
	b=c;
}

int Min(int a,int b,int c)
{
	if(a<b && a<c)
		return a;
	if(b<a && b<c)
		return b;
	if(c<a && c<b)
		return c;
}

int Max(int a,int b,int c)
{
	if(a>b && a>c)
		return a;
	if(b>a && b>c)
		return b;
	if(c>a && c>b)
		return c;
}

std::max(std::max(a, b), c);

int a;

int minY = Min(y1, Min(y2, y3));
int maxY = Max(y1, Max(y2, y3));

#include <windows.h>

struct Point {
    int x, y;
};

// Swap two points
void Swap(Point& a, Point& b) {
    Point temp = a;
    a = b;
    b = temp;
}

// Sort vertices by y-coordinate
void SortVertices(Point& p1, Point& p2, Point& p3) {
    if (p1.y > p2.y) Swap(p1, p2);
    if (p1.y > p3.y) Swap(p1, p3);
    if (p2.y > p3.y) Swap(p2, p3);
}

// Draw horizontal line
void DrawSpan(HDC hdc, int x1, int x2, int y, COLORREF color) {
    if (x1 > x2) Swap(*(Point*)&x1, *(Point*)&x2);
    for (int x = x1; x <= x2; ++x) {
        SetPixel(hdc, x, y, color);
    }
}

// Scanline fill algorithm
void FillTriangle(HDC hdc, Point p1, Point p2, Point p3, COLORREF color) {
    SortVertices(p1, p2, p3);

    int totalHeight = p3.y - p1.y;
    if (totalHeight == 0) return; // Avoid division by zero

    // Compute slopes
    for (int i = 0; i < totalHeight; i++) {
        bool secondHalf = (i > (p2.y - p1.y)) || (p1.y == p2.y);
        int segmentHeight = secondHalf ? (p3.y - p2.y) : (p2.y - p1.y);
        float alpha = (float)i / totalHeight;
        float beta = (float)(i - (secondHalf ? (p2.y - p1.y) : 0)) / segmentHeight;

        Point A = { p1.x + (int)((p3.x - p1.x) * alpha), p1.y + i };
        Point B = secondHalf
            ? Point{ p2.x + (int)((p3.x - p2.x) * beta), p2.y + (i - (p2.y - p1.y)) }
            : Point{ p1.x + (int)((p2.x - p1.x) * beta), p1.y + i };

        DrawSpan(hdc, A.x, B.x, p1.y + i, color);
    }
}

// Example usage in a WinAPI window procedure
LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp) {
    switch (msg) {
        case WM_PAINT: {
            PAINTSTRUCT ps;
            HDC hdc = BeginPaint(hwnd, &ps);

            Point p1 = {50, 250}, p2 = {350, 250}, p3 = {200, 50};
            FillTriangle(hdc, p1, p2, p3, RGB(255, 0, 0));

            EndPaint(hwnd, &ps);
            break;
        }
        case WM_DESTROY:
            PostQuitMessage(0);
            break;
        default:
            return DefWindowProc(hwnd, msg, wp, lp);
    }
    return 0;
}

// WinAPI boilerplate
int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrev, LPSTR lpCmd, int nCmdShow) {
    WNDCLASS wc = { CS_HREDRAW | CS_VREDRAW, WndProc, 0, 0, hInst, NULL, LoadCursor(NULL, IDC_ARROW),
                    (HBRUSH)(COLOR_WINDOW + 1), NULL, TEXT("TriangleWin") };
    RegisterClass(&wc);
    HWND hwnd = CreateWindow(TEXT("TriangleWin"), TEXT("WinAPI Triangle"), WS_OVERLAPPEDWINDOW,
                             CW_USEDEFAULT, CW_USEDEFAULT, 400, 400, NULL, NULL, hInst, NULL);
    ShowWindow(hwnd, nCmdShow);
    UpdateWindow(hwnd);

    MSG msg;
    while (GetMessage(&msg, NULL, 0, 0)) {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
    return msg.wParam;
}

struct Point {
    int x, y;
};

void Swap(Point& a, Point& b) {
    Point temp = a;
    a = b;
    b = temp;
}

void SortVertices(Point& p1, Point& p2, Point& p3) {
    if (p1.y > p2.y) Swap(p1, p2);
    if (p1.y > p3.y) Swap(p1, p3);
    if (p2.y > p3.y) Swap(p2, p3);
}

void DrawSpan(HDC hdc, int x1, int x2, int y, COLORREF color) {
    if (x1 > x2) Swap(*(Point*)&x1, *(Point*)&x2);
    for (int x = x1; x <= x2; ++x) {
        SetPixel(hdc, x, y, color);
    }
}

void FillTriangle(HDC hdc, Point p1, Point p2, Point p3, COLORREF color) {
    SortVertices(p1, p2, p3);

    int totalHeight = p3.y - p1.y;
    if (totalHeight == 0) return;

    for (int i = 0; i < totalHeight; i++) {
        bool secondHalf = (i > (p2.y - p1.y)) || (p1.y == p2.y);
        int segmentHeight = secondHalf ? (p3.y - p2.y) : (p2.y - p1.y);
        float alpha = (float)i / totalHeight;
        float beta = (float)(i - (secondHalf ? (p2.y - p1.y) : 0)) / segmentHeight;

        Point A = { p1.x + (int)((p3.x - p1.x) * alpha), p1.y + i };
        Point B = secondHalf
            ? Point{ p2.x + (int)((p3.x - p2.x) * beta), p2.y + (i - (p2.y - p1.y)) }
            : Point{ p1.x + (int)((p2.x - p1.x) * beta), p1.y + i };

        DrawSpan(hdc, A.x, B.x, p1.y + i, color);
    }
}

LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp) {
    switch (msg) {
        case WM_PAINT: {
            PAINTSTRUCT ps;
            HDC hdc = BeginPaint(hwnd, &ps);

            Point p1 = {100, 50}, p2 = {50, 150}, p3 = {150, 150};
            FillTriangle(hdc, p1, p2, p3, RGB(255, 0, 0));

            EndPaint(hwnd, &ps);
            break;
        }
        case WM_DESTROY:
            PostQuitMessage(0);
            break;
        default:
            return DefWindowProc(hwnd, msg, wp, lp);
    }
    return 0;
}

int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrev, LPSTR lpCmd, int nCmdShow) {
    WNDCLASS wc = { CS_HREDRAW | CS_VREDRAW, WndProc, 0, 0, hInst, NULL, LoadCursor(NULL, IDC_ARROW),
                    (HBRUSH)(COLOR_WINDOW + 1), NULL, TEXT("TriangleWin") };
    RegisterClass(&wc);
    HWND hwnd = CreateWindow(TEXT("TriangleWin"), TEXT("WinAPI Triangle"), WS_OVERLAPPEDWINDOW,
                             CW_USEDEFAULT, CW_USEDEFAULT, 400, 400, NULL, NULL, hInst, NULL);
    ShowWindow(hwnd, nCmdShow);
    UpdateWindow(hwnd);

    MSG msg;
    while (GetMessage(&msg, NULL, 0, 0)) {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
    return msg.wParam;
}

 Point B = secondHalf
            ? Point{ p2.x + (int)((p3.x - p2.x) * beta), p2.y + (i - (p2.y - p1.y)) }
            : Point{ p1.x + (int)((p2.x - p1.x) * beta), p1.y + i };

error C2143: syntax error : missing ',' before '{'
C:\projekty\konsola\konsola.cpp(660) : error C2143: syntax error : missing ';' before '{'
C:\projekty\konsola\konsola.cpp(660) : error C2143: syntax error : missing ';' before '}'
C:\projekty\konsola\konsola.cpp(661) : error C2143: syntax error : missing ';' before ':'
C:\projekty\konsola\konsola.cpp(661) : error C2143: syntax error : missing ';' before '{'
C:\projekty\konsola\konsola.cpp(661) : error C2143: syntax error : missing ';' before '}'

Point B = secondHalf
            ? Point{ p2.x + (int)((p3.x - p2.x) * beta), p2.y + (i - (p2.y - p1.y)) }
            : Point{ p1.x + (int)((p2.x - p1.x) * beta), p1.y + i };

Point B;
if (secondHalf) {
  B.x = p2.x + (int)((p3.x - p2.x) * beta);
  B.y = p2.y + (i - (p2.y - p1.y));
} else {
  B.x = p1.x + (int)((p2.x - p1.x) * beta);
  B.y = p1.y + i;
}