OpenGLDrawing.cpp

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "OpenGLDrawing.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1* Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) {}
//---------------------------------------------------------------------------
bool __fastcall TForm1::Setup_OpenGL()
{
    hdc = GetDC(Handle);

    // SETUP PixelFormatDescriptor
    PIXELFORMATDESCRIPTOR pfd = {
        sizeof(PIXELFORMATDESCRIPTOR),
        1,
        PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER,
        PFD_TYPE_RGBA,
        24,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        0,
        32,
        0,
        0,
        PFD_MAIN_PLANE,
        0,
        0,
        0,
    };
    this->PixelFormat = ChoosePixelFormat(this->hdc, &pfd);
    SetPixelFormat(hdc, PixelFormat, &pfd);

    // CREATE CONTEXT
    hrc = wglCreateContext(hdc);
    if (hrc == NULL) {
        ShowMessage("hrc is NULL");
        return false;
    }
    if (wglMakeCurrent(hdc, hrc) == false) {
        ShowMessage("Could not MakeCurrent");
        return false;
    }

    W = ClientWidth;
    H = ClientHeight;

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(-1, 1, -1, 1, -1, 1); // Orthographic projection
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);

    return true;
}

void __fastcall TForm1::FormMouseDown(
    TObject* Sender, TMouseButton Button, TShiftState Shift, int X, int Y)
{
    //DrawingPoint currentClickPoint = { 2.0 * X / W - 1.0, 1.0 - 2.0 * Y / H };
    DrawingPoint currentClickPoint = { (double)X, (double)Y };
    if (Button == mbLeft) {
        //add new line/arc depending on current mode
        if (isFirstPoint) {
            if (currentMode != DrawingMode::FinishedMode) {
                isFirstPoint = false;
                this->lastPoint = currentClickPoint;
            }

        } else {
            if (currentMode == DrawingMode::LineMode) {
                auto line = std::make_unique<LineSegment>();
                line->isProjection = false;
				line->startPoint = lastPoint;
				line->endPoint = currentClickPoint;
				segments.push_back(std::move(line));

				lastPoint = currentClickPoint;
            } else if (currentMode == DrawingMode::ArcMode) {
                auto arc = std::make_unique<ArcSegment>();
                arc->isProjection = false;

                arc->startPoint = lastPoint;
                arc->endPoint = currentClickPoint;

                DrawingPoint A = { static_cast<double>(
                                       segments.back()->startPoint.x),
                    static_cast<double>(segments.back()->startPoint.y) };

                DrawingPoint B = { static_cast<double>(
                                       segments.back()->endPoint.x),
                    static_cast<double>(segments.back()->endPoint.y) };

                DrawingPoint C = { currentClickPoint.x, currentClickPoint.y };

                DrawingPoint AB = { B.x - A.x, B.y - A.y };
                DrawingPoint BC = { C.x - B.x, C.y - B.y };

                double dot_product = AB.x * BC.x + AB.y * BC.y;

                double magnitudeAB = sqrt(AB.x * AB.x + AB.y * AB.y);
                double magnitudeBC = sqrt(BC.x * BC.x + BC.y * BC.y);

                double cosTheta = dot_product / (magnitudeAB * magnitudeBC);

                double angleRadians = acos(cosTheta);

                arc->radius = sqrt(magnitudeBC * magnitudeBC /
                                   (2 - 2 * cos(2 * angleRadians)));

                double q = sqrt(pow((currentClickPoint.x - lastPoint.x), 2) +
                                pow((currentClickPoint.y - lastPoint.y), 2));

                double y3 = (lastPoint.y + currentClickPoint.y) / 2;

                double x3 = (lastPoint.x + currentClickPoint.x) / 2;

                double basex = sqrt(pow(arc->radius, 2) - pow((q / 2), 2)) *
                               (lastPoint.y - currentClickPoint.y) /
                               q; //calculate once
                double basey = sqrt(pow(arc->radius, 2) - pow((q / 2), 2)) *
                               (currentClickPoint.x - lastPoint.x) /
                               q; //calculate once

                double centerx1 = x3 + basex; //center x of circle 1
                double centery1 = y3 + basey; //center y of circle 1

                double centerx2 = x3 - basex; //center x of circle 2
                double centery2 = y3 - basey; //center y of circle 2

                //found online, works like a charm
                double magicProduct =
                    (lastPoint.x - segments.back()->startPoint.x) *
                        (currentClickPoint.y - segments.back()->startPoint.y) -
                    (lastPoint.y - segments.back()->startPoint.y) *
                        (currentClickPoint.x - segments.back()->startPoint.x);

                if (magicProduct < 0) {
                    arc->centerPoint.x = centerx2;
                    arc->centerPoint.y = centery2;

                } else if (magicProduct > 0) {
                    arc->centerPoint.x = centerx1;
                    arc->centerPoint.y = centery1;
                }

                // Calculate start angle
                arc->startAngle = atan2(lastPoint.y - arc->centerPoint.y,
                    lastPoint.x - arc->centerPoint.x);
                arc->endAngle = atan2(currentClickPoint.y - arc->centerPoint.y,
					currentClickPoint.x - arc->centerPoint.x);

                // Normalize angles to be in the range [0, 2*pi]
                if (arc->startAngle < 0)
                    arc->startAngle += 2 * M_PI;
                if (arc->endAngle < 0)
                    arc->endAngle += 2 * M_PI;

                // Ensure startAngle is always less than endAngle to avoid inverted arcs
                if (arc->startAngle > arc->endAngle) {
                    // This ensures a counter-clockwise direction (if that’s desired)
                    arc->endAngle += 2 * M_PI;
                }

                if (arc->endAngle - arc->startAngle > M_PI) {
                    // Ensure the arc is drawn counter-clockwise (or handle accordingly)
                    arc->startAngle += 2 * M_PI;
				}

				segments.push_back(std::move(arc));

				lastPoint = currentClickPoint;
            }
        }
    } else if (Button == mbRight) {
        PopupMenu1->Popup(Mouse->CursorPos.X, Mouse->CursorPos.Y);
    }
}
//---------------------------------------------------------------------------

void __fastcall TForm1::LineModeButtonClick(TObject* Sender)
{
    ToggleLineModeButton();
}
//---------------------------------------------------------------------------

void __fastcall TForm1::ArcModeButtonClick(TObject* Sender)
{
    if (currentMode == DrawingMode::LineMode) {
        currentMode = DrawingMode::ArcMode;

        LineModeButton->Checked = false;
        ArcModeButton->Checked = true;
    }
}
//---------------------------------------------------------------------------

void __fastcall TForm1::UndoButtonClick(TObject* Sender)
{
    if (!segments.empty()) {
        if (segments.size() > 1)
        { //whenever there already at least 2 lines drawn
            segments.pop_back();
            lastPoint = segments.back()->endPoint;
        } else if (segments.size() == 1) { //if there is just 1 line drawn
            lastPoint = segments.back()->startPoint;
            segments.pop_back();
        }

        //handle undo for when only single point is visible
    } else if (!isFirstPoint) {
        isFirstPoint = true;
    }
}
//---------------------------------------------------------------------------

void __fastcall TForm1::IdleLoop(TObject*, bool &done)
{
    done = false;

    CanArcBeDrawn();

    Draw_Segments();
}

void __fastcall TForm1::CanArcBeDrawn()
{
    if (segments.size() >= 1 && currentMode != DrawingMode::FinishedMode) {
        ArcModeButton->Enabled = true;
    } else {
        ArcModeButton->Enabled = false;
        ToggleLineModeButton();
    }
}

void __fastcall TForm1::ToggleLineModeButton()
{
    if (currentMode == DrawingMode::ArcMode) {
        currentMode = DrawingMode::LineMode;

        ArcModeButton->Checked = false;
        LineModeButton->Checked = true;
    }
}

//---------------------------------------------------------------------------

void __fastcall TForm1::FormCreate(TObject* Sender)
{
    currentMode = DrawingMode::LineMode;
    isFirstPoint = true;
    //disable arc button, set a flag
    ArcModeButton->Enabled = false;
    isLineSegmentDrawn = false;

    ContinueDrawingButton->Enabled = false;

    if (Setup_OpenGL()) {
        // SET LOOP TO APP IDLE EVENT
        Application->OnIdle = IdleLoop;
    }
}
//---------------------------------------------------------------------------

void __fastcall TForm1::FormMouseMove(
    TObject* Sender, TShiftState Shift, int X, int Y)

{
    if (!isFirstPoint) {
        DrawingPoint hoverPoint = { (double)X, (double)Y };
        projectedSegment.clear();

        if (currentMode == DrawingMode::LineMode) {
            auto line = std::make_unique<LineSegment>();
            line->isProjection = true;
            line->startPoint = lastPoint;
            line->endPoint = hoverPoint;
            projectedSegment.push_back(std::move(line));

        } else if (currentMode == DrawingMode::ArcMode) {
            auto arc = std::make_unique<ArcSegment>();

            arc->isProjection = true;

            arc->startPoint = lastPoint;
            arc->endPoint = hoverPoint;

            DrawingPoint A = { static_cast<double>(
                                   segments.back()->startPoint.x),
                static_cast<double>(segments.back()->startPoint.y) };

            DrawingPoint B = { static_cast<double>(segments.back()->endPoint.x),
                static_cast<double>(segments.back()->endPoint.y) };

            DrawingPoint C = { hoverPoint.x, hoverPoint.y };

            DrawingPoint AB = { B.x - A.x, B.y - A.y };
            DrawingPoint BC = { C.x - B.x, C.y - B.y };

            double dot_product = AB.x * BC.x + AB.y * BC.y;

            double magnitudeAB = sqrt(AB.x * AB.x + AB.y * AB.y);
            double magnitudeBC = sqrt(BC.x * BC.x + BC.y * BC.y);

            double cosTheta = dot_product / (magnitudeAB * magnitudeBC);

            double angleRadians = acos(cosTheta);

            // Convert the angle from radians to degrees
            int angleDegrees = angleRadians * (180.0 / M_PI);

            arc->radius = sqrt(
                magnitudeBC * magnitudeBC / (2 - 2 * cos(2 * angleRadians)));

            //found online, works
            double q = sqrt(pow((hoverPoint.x - lastPoint.x), 2) +
                            pow((hoverPoint.y - lastPoint.y), 2));

            double y3 = (lastPoint.y + hoverPoint.y) / 2;

            double x3 = (lastPoint.x + hoverPoint.x) / 2;

            double basex = sqrt(pow(arc->radius, 2) - pow((q / 2), 2)) *
                           (lastPoint.y - hoverPoint.y) / q; //calculate once
            double basey = sqrt(pow(arc->radius, 2) - pow((q / 2), 2)) *
                           (hoverPoint.x - lastPoint.x) / q; //calculate once

            double centerx1 = x3 + basex; //center x of circle 1
            double centery1 = y3 + basey; //center y of circle 1

            double centerx2 = x3 - basex; //center x of circle 2
            double centery2 = y3 - basey; //center y of circle 2

            //found online
            double magicProduct =
                (lastPoint.x - segments.back()->startPoint.x) *
                    (hoverPoint.y - segments.back()->startPoint.y) -
                (lastPoint.y - segments.back()->startPoint.y) *
                    (hoverPoint.x - segments.back()->startPoint.x);

            if (magicProduct < 0) {
                arc->centerPoint.x = centerx2;
                arc->centerPoint.y = centery2;

            } else if (magicProduct > 0) {
                arc->centerPoint.x = centerx1;
                arc->centerPoint.y = centery1;
            }

            // Calculate start angle
            arc->startAngle = atan2(lastPoint.y - arc->centerPoint.y,
                lastPoint.x - arc->centerPoint.x);
            arc->endAngle = atan2(hoverPoint.y - arc->centerPoint.y,
                hoverPoint.x - arc->centerPoint.x);

            // Normalize angles to be in the range [0, 2*pi]
            if (arc->startAngle < 0)
                arc->startAngle += 2 * M_PI;
            if (arc->endAngle < 0)
                arc->endAngle += 2 * M_PI;

            // Ensure startAngle is always less than endAngle to avoid inverted arcs
            if (arc->startAngle > arc->endAngle) {
                // This ensures a counter-clockwise direction (if that’s desired)
                arc->endAngle += 2 * M_PI;
            }

            if (arc->endAngle - arc->startAngle > M_PI) {
                // Ensure the arc is drawn counter-clockwise (or handle accordingly)
                arc->startAngle += 2 * M_PI;
            }

            projectedSegment.push_back(std::move(arc));
        }
    } else {
        projectedSegment.clear();
    }
}
//---------------------------------------------------------------------------

void __fastcall TForm1::FormPaint(TObject* Sender)
{
    Draw_Segments();
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Draw_Segments()
{
    glClearColor(1.0f, 1.0f, 1.0f, 1.0f);

    glClear(GL_COLOR_BUFFER_BIT);

    if (!segments.empty()) {
        for (const auto &segment : segments) {
            segment->DrawSegment();
        }
    }
    if (!projectedSegment.empty()) {
        for (const auto &segment : projectedSegment) {
            segment->DrawSegment();
        }
    }
    glFlush();
    SwapBuffers(hdc);
}

//---------------------------------------------------------------------------

void LineSegment::DrawSegment()
{
    //colour blind safe colours for distinguishing between already drawn and projected
    if (isProjection) {
        glColor3f(0.8f, 0.0f, 0.0f);
    } else {
        glColor3f(0.0f, 0.0f, 0.8f);
    }

    glBegin(GL_LINES);
    //conversion from vcl coordinates to opengl coordinates
    glVertex2d(2.0 * startPoint.x / W - 1.0, 1.0 - 2.0 * startPoint.y / H);
    glVertex2d(2.0 * endPoint.x / W - 1.0, 1.0 - 2.0 * endPoint.y / H);
    glEnd();
}

void ArcSegment::DrawSegment()
{
    //colour blind safe colours for distinguishing between already drawn and projected
    if (isProjection) {
        glColor3f(0.8f, 0.0f, 0.0f);
    } else {
        glColor3f(0.0f, 0.0f, 0.8f);
    }
    int CIRCLE_SEGMENTS = 360;
    glBegin(GL_LINE_STRIP);

    for (int i = 0; i <= CIRCLE_SEGMENTS; ++i) {
        float angle =
            startAngle + (endAngle - startAngle) * i / CIRCLE_SEGMENTS;
        float x = centerPoint.x + radius * cos(angle);
        float y = centerPoint.y + radius * sin(angle);

        //conversion from vcl coordinates to opengl coordinates
        glVertex2f(2.0 * x / W - 1.0, 1.0 - 2.0 * y / H);
    }
    glEnd();
}

void __fastcall TForm1::FinishDrawingButtonClick(TObject* Sender)
{
    currentMode = DrawingMode::FinishedMode;
    FinishDrawingButton->Enabled = false;
    ArcModeButton->Enabled = false;
    LineModeButton->Enabled = false;
    UndoButton->Enabled = false;
    ContinueDrawingButton->Enabled = true;
}
//---------------------------------------------------------------------------

void __fastcall TForm1::ContinueDrawingButtonClick(TObject* Sender)
{
    ContinueDrawingButton->Enabled = false;
    currentMode = DrawingMode::ArcMode;
    ArcModeButton->Enabled = true;
    LineModeButton->Enabled = true;
    UndoButton->Enabled = true;
    ToggleLineModeButton();
    FinishDrawingButton->Enabled = true;
}
//---------------------------------------------------------------------------