fix: Correct 2D axis label Y-position and set color to white

Co-authored-by: aider (gemini/gemini-2.5-pro) <aider@aider.chat>

CMakeLists.txt

@@ -28,11 +28,33 @@ endif()
 message(STATUS "OpenCASCADE_INCLUDE_DIRS: ${OpenCASCADE_INCLUDE_DIRS}")
 message(STATUS "OpenCASCADE_LIBRARIES: ${OpenCASCADE_LIBRARIES}")
 
+# Automatically find resource files and generate resources.qrc
+set(GENERATED_QRC_FILE "${CMAKE_CURRENT_BINARY_DIR}/resources.qrc")
+set(QRC_CONTENT "")
+
+file(GLOB ICON_FILES "icons/*.svg")
+string(APPEND QRC_CONTENT "    <qresource prefix=\"/icons\">\n")
+foreach(ICON_FILE IN LISTS ICON_FILES)
+    get_filename_component(ICON_ALIAS ${ICON_FILE} NAME)
+    string(APPEND QRC_CONTENT "        <file alias=\"${ICON_ALIAS}\">${ICON_FILE}</file>\n")
+endforeach()
+string(APPEND QRC_CONTENT "    </qresource>\n")
+
+file(GLOB SHADER_FILES "src/shaders/*")
+string(APPEND QRC_CONTENT "    <qresource prefix=\"/shaders\">\n")
+foreach(SHADER_FILE IN LISTS SHADER_FILES)
+    get_filename_component(SHADER_ALIAS ${SHADER_FILE} NAME)
+    string(APPEND QRC_CONTENT "        <file alias=\"${SHADER_ALIAS}\">${SHADER_FILE}</file>\n")
+endforeach()
+string(APPEND QRC_CONTENT "    </qresource>\n")
+
+file(WRITE ${GENERATED_QRC_FILE} "<RCC>\n${QRC_CONTENT}</RCC>\n")
+
 file(GLOB SOURCES "src/*.cpp")
 
 add_executable(OpenCAD
     ${SOURCES}
-    resources.qrc
+    ${GENERATED_QRC_FILE}
 )
 
 target_include_directories(OpenCAD SYSTEM PRIVATE ${OpenCASCADE_INCLUDE_DIRS})

resources.qrc

@@ -1,18 +0,0 @@
-<RCC>
-    <qresource prefix="/">
-        <file>icons/create-sketch.svg</file>
-        <file>icons/extrude.svg</file>
-		<file>icons/line.svg</file>
-		<file>icons/rectangle.svg</file>
-		<file>icons/circle.svg</file>
-		<file>icons/save-sketch.svg</file>
-		<file>icons/cursor.svg</file>
-		<file>icons/home.svg</file>
-    </qresource>
-    <qresource prefix="/shaders">
-        <file alias="simple.vert">src/shaders/simple.vert</file>
-        <file alias="simple.frag">src/shaders/simple.frag</file>
-        <file alias="texture.vert">src/shaders/texture.vert</file>
-        <file alias="texture.frag">src/shaders/texture.frag</file>
-    </qresource>
-</RCC>

src/Camera.cpp

@@ -67,6 +67,7 @@ void Camera::wheelEvent(QWheelEvent* event, const QVector3D& worldPos)
         QMatrix4x4 rotation;
         rotation.rotate(m_xRot / 16.0f, 1, 0, 0);
         rotation.rotate(m_yRot / 16.0f, 0, 1, 0);
+        rotation.rotate(-90.0f, 1, 0, 0);
         QVector3D p_camera = rotation.map(worldPos);
 
         if (std::abs(p_camera.z() + oldZoom) < 1e-6) {
@@ -90,14 +91,20 @@ QMatrix4x4 Camera::modelViewMatrix() const
     QMatrix4x4 model;
     model.translate(m_panX, m_panY, m_zoom);
 
+    QMatrix4x4 zup_rotation;
+    zup_rotation.rotate(-90.0f, 1, 0, 0);
+    QVector3D pivot_yup = zup_rotation.map(m_rotationPivot);
+
     if (m_isRotating) {
-        model.translate(m_rotationPivot);
+        model.translate(pivot_yup);
     }
     model.rotate(m_xRot / 16.0f, 1, 0, 0);
     model.rotate(m_yRot / 16.0f, 0, 1, 0);
     if (m_isRotating) {
-        model.translate(-m_rotationPivot);
+        model.translate(-pivot_yup);
     }
+
+    model.rotate(-90.0f, 1, 0, 0); // For Z-up system
     return model;
 }
 
@@ -341,12 +348,16 @@ void Camera::startRotation(const QVector3D& pivot)
     }
     m_stableZoom = m_zoom;
 
+    QMatrix4x4 zup_rotation;
+    zup_rotation.rotate(-90.0f, 1, 0, 0);
+    QVector3D pivot_yup = zup_rotation.map(m_rotationPivot);
+
     QMatrix4x4 rotation;
     rotation.rotate(m_xRot / 16.0f, 1, 0, 0);
     rotation.rotate(m_yRot / 16.0f, 0, 1, 0);
 
-    QVector3D p_rotated = rotation.map(m_rotationPivot);
+    QVector3D p_rotated = rotation.map(pivot_yup);
-    QVector3D p_diff = p_rotated - m_rotationPivot;
+    QVector3D p_diff = p_rotated - pivot_yup;
 
     setPanX(m_panX + p_diff.x());
     setPanY(m_panY + p_diff.y());
@@ -361,12 +372,16 @@ void Camera::stopRotation()
         return;
     }
 
+    QMatrix4x4 zup_rotation;
+    zup_rotation.rotate(-90.0f, 1, 0, 0);
+    QVector3D pivot_yup = zup_rotation.map(m_rotationPivot);
+
     QMatrix4x4 rotation;
     rotation.rotate(m_xRot / 16.0f, 1, 0, 0);
     rotation.rotate(m_yRot / 16.0f, 0, 1, 0);
 
-    QVector3D p_rotated = rotation.map(m_rotationPivot);
+    QVector3D p_rotated = rotation.map(pivot_yup);
-    QVector3D p_diff = p_rotated - m_rotationPivot;
+    QVector3D p_diff = p_rotated - pivot_yup;
 
     setPanX(m_panX - p_diff.x());
     setPanY(m_panY - p_diff.y());

src/CircleTool.cpp

@@ -172,19 +172,19 @@ void CircleTool::paintGL()
             QVector3D p1, p2;
 
             if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) {
-                p1.setX(centerPos.x() + radius * qCos(angle1));
-                p1.setY(centerPos.y());
-                p1.setZ(centerPos.z() + radius * qSin(angle1));
-                p2.setX(centerPos.x() + radius * qCos(angle2));
-                p2.setY(centerPos.y());
-                p2.setZ(centerPos.z() + radius * qSin(angle2));
-            } else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) {
                 p1.setX(centerPos.x() + radius * qCos(angle1));
                 p1.setY(centerPos.y() + radius * qSin(angle1));
                 p1.setZ(centerPos.z());
                 p2.setX(centerPos.x() + radius * qCos(angle2));
                 p2.setY(centerPos.y() + radius * qSin(angle2));
                 p2.setZ(centerPos.z());
+            } else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) {
+                p1.setX(centerPos.x() + radius * qCos(angle1));
+                p1.setY(centerPos.y());
+                p1.setZ(centerPos.z() + radius * qSin(angle1));
+                p2.setX(centerPos.x() + radius * qCos(angle2));
+                p2.setY(centerPos.y());
+                p2.setZ(centerPos.z() + radius * qSin(angle2));
             } else { // YZ
                 p1.setX(centerPos.x());
                 p1.setY(centerPos.y() + radius * qCos(angle1));

src/DebugWindow.cpp

@@ -0,0 +1,48 @@
+#include "DebugWindow.h"
+#include "Camera.h"
+
+#include <QVBoxLayout>
+#include <QTextEdit>
+#include <QString>
+
+DebugWindow::DebugWindow(QWidget *parent)
+    : QDialog(parent)
+{
+    setWindowTitle("Debug Info");
+    resize(600, 400);
+
+    QVBoxLayout* layout = new QVBoxLayout(this);
+    m_textEdit = new QTextEdit();
+    m_textEdit->setReadOnly(true);
+    m_textEdit->setText("Debug window is active.");
+    layout->addWidget(m_textEdit);
+    setLayout(layout);
+}
+
+DebugWindow::~DebugWindow()
+{
+}
+
+void DebugWindow::updateCameraInfo(const Camera* camera)
+{
+    if (!camera) {
+        m_textEdit->setText("Camera not available.");
+        return;
+    }
+
+    QString info;
+    info += "Camera Info:\n";
+    info += "----------------\n";
+    info += QString("Rotation (X, Y): (%1, %2)\n").arg(camera->xRotation()).arg(camera->yRotation());
+    info += QString("Zoom: %1\n").arg(camera->zoom());
+    info += QString("Pan (X, Y): (%1, %2)\n").arg(camera->panX()).arg(camera->panY());
+    info += QString("UI Camera Distance: %1\n").arg(camera->uiCameraDistance());
+    info += "\n";
+    info += "Saved State:\n";
+    info += "----------------\n";
+    info += QString("Rotation (X, Y): (%1, %2)\n").arg(camera->savedXRot()).arg(camera->savedYRot());
+    info += QString("Zoom: %1\n").arg(camera->savedZoom());
+    info += QString("Pan (X, Y): (%1, %2)\n").arg(camera->savedPanX()).arg(camera->savedPanY());
+
+    m_textEdit->setText(info);
+}

src/DebugWindow.h

@@ -0,0 +1,23 @@
+#ifndef DEBUGWINDOW_H
+#define DEBUGWINDOW_H
+
+#include <QDialog>
+
+class QTextEdit;
+class Camera;
+
+class DebugWindow : public QDialog
+{
+    Q_OBJECT
+
+public:
+    explicit DebugWindow(QWidget *parent = nullptr);
+    ~DebugWindow();
+
+    void updateCameraInfo(const Camera* camera);
+
+private:
+    QTextEdit* m_textEdit;
+};
+
+#endif // DEBUGWINDOW_H

src/LineTool.cpp

@@ -58,17 +58,17 @@ void LineTool::mousePressEvent(QMouseEvent *event)
                 refDir = m_viewport->property("previousLineDirection").value<QVector3D>();
             } else {
                 if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY || m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) refDir = QVector3D(1, 0, 0);
-                else refDir = QVector3D(0, 0, -1);
+                else refDir = QVector3D(0, 1, 0);
             }
             QVector3D currentMouseWorldPos = m_viewport->unproject(event->pos(), m_viewport->currentPlane());
             QVector3D mouseVec = currentMouseWorldPos - startPos;
             double mouseAngle;
-            if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) mouseAngle = qRadiansToDegrees(atan2(mouseVec.z(), mouseVec.x()));
+            if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) mouseAngle = qRadiansToDegrees(atan2(mouseVec.y(), mouseVec.x()));
-            else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) mouseAngle = qRadiansToDegrees(atan2(mouseVec.y(), mouseVec.x()));
+            else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) mouseAngle = qRadiansToDegrees(atan2(mouseVec.z(), mouseVec.x()));
             else mouseAngle = qRadiansToDegrees(atan2(mouseVec.z(), mouseVec.y()));
             double refAngle;
-            if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) refAngle = qRadiansToDegrees(atan2(refDir.z(), refDir.x()));
+            if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) refAngle = qRadiansToDegrees(atan2(refDir.y(), refDir.x()));
-            else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) refAngle = qRadiansToDegrees(atan2(refDir.y(), refDir.x()));
+            else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) refAngle = qRadiansToDegrees(atan2(refDir.z(), refDir.x()));
             else refAngle = qRadiansToDegrees(atan2(refDir.z(), refDir.y()));
             double relativeMouseAngle = mouseAngle - refAngle;
             while (relativeMouseAngle <= -180.0) relativeMouseAngle += 360.0;
@@ -85,8 +85,8 @@ void LineTool::mousePressEvent(QMouseEvent *event)
             }
             double finalAngleRad = qDegreesToRadians(refAngle + snappedAngle);
             QVector3D finalDir;
-            if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) finalDir = QVector3D(cos(finalAngleRad), 0, sin(finalAngleRad));
+            if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) finalDir = QVector3D(cos(finalAngleRad), sin(finalAngleRad), 0);
-            else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) finalDir = QVector3D(cos(finalAngleRad), sin(finalAngleRad), 0);
+            else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) finalDir = QVector3D(cos(finalAngleRad), 0, sin(finalAngleRad));
             else finalDir = QVector3D(0, cos(finalAngleRad), sin(finalAngleRad));
             double lineLength;
             if (lengthFromInput) lineLength = inputLength;
@@ -115,8 +115,8 @@ void LineTool::mousePressEvent(QMouseEvent *event)
         } else {
             QVector3D worldPos = m_viewport->unproject(event->pos(), m_viewport->currentPlane());
             if (m_viewport->isSnappingHorizontal()) {
-                if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) worldPos.setZ(m_firstLinePoint.Z());
+                if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) worldPos.setY(m_firstLinePoint.Y());
-                else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) worldPos.setY(m_firstLinePoint.Y());
+                else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) worldPos.setZ(m_firstLinePoint.Z());
                 else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::YZ) worldPos.setZ(m_firstLinePoint.Z());
             } else if (m_viewport->isSnappingVertical()) {
                 if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) worldPos.setX(m_firstLinePoint.X());
@@ -165,9 +165,9 @@ void LineTool::mouseMoveEvent(QMouseEvent *event)
             double angle = 0;
 
             if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) {
-                angle = atan2(delta.z(), delta.x());
-            } else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) {
                 angle = atan2(delta.y(), delta.x());
+            } else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) {
+                angle = atan2(delta.z(), delta.x());
             } else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::YZ) {
                 angle = atan2(delta.z(), delta.y());
             }
@@ -214,17 +214,17 @@ void LineTool::finalizeCreation()
             refDir = m_viewport->property("previousLineDirection").value<QVector3D>();
         } else {
             if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY || m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) refDir = QVector3D(1, 0, 0);
-            else refDir = QVector3D(0, 0, -1);
+            else refDir = QVector3D(0, 1, 0);
         }
         QVector3D currentMouseWorldPos = m_viewport->unproject(m_viewport->currentMousePos(), m_viewport->currentPlane());
         QVector3D mouseVec = currentMouseWorldPos - startPos;
         double mouseAngle;
-        if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) mouseAngle = qRadiansToDegrees(atan2(mouseVec.z(), mouseVec.x()));
+        if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) mouseAngle = qRadiansToDegrees(atan2(mouseVec.y(), mouseVec.x()));
-        else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) mouseAngle = qRadiansToDegrees(atan2(mouseVec.y(), mouseVec.x()));
+        else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) mouseAngle = qRadiansToDegrees(atan2(mouseVec.z(), mouseVec.x()));
         else mouseAngle = qRadiansToDegrees(atan2(mouseVec.z(), mouseVec.y()));
         double refAngle;
-        if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) refAngle = qRadiansToDegrees(atan2(refDir.z(), refDir.x()));
+        if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) refAngle = qRadiansToDegrees(atan2(refDir.y(), refDir.x()));
-        else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) refAngle = qRadiansToDegrees(atan2(refDir.y(), refDir.x()));
+        else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) refAngle = qRadiansToDegrees(atan2(refDir.z(), refDir.x()));
         else refAngle = qRadiansToDegrees(atan2(refDir.z(), refDir.y()));
         double relativeMouseAngle = mouseAngle - refAngle;
         while (relativeMouseAngle <= -180.0) relativeMouseAngle += 360.0;
@@ -241,8 +241,8 @@ void LineTool::finalizeCreation()
         }
         double finalAngleRad = qDegreesToRadians(refAngle + snappedAngle);
         QVector3D finalDir;
-        if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) finalDir = QVector3D(cos(finalAngleRad), 0, sin(finalAngleRad));
+        if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) finalDir = QVector3D(cos(finalAngleRad), sin(finalAngleRad), 0);
-        else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) finalDir = QVector3D(cos(finalAngleRad), sin(finalAngleRad), 0);
+        else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) finalDir = QVector3D(cos(finalAngleRad), 0, sin(finalAngleRad));
         else finalDir = QVector3D(0, cos(finalAngleRad), sin(finalAngleRad));
         double lineLength;
         if (lengthFromInput) lineLength = inputLength;
@@ -312,7 +312,7 @@ void LineTool::paintGL()
                 if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY || m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) {
                     refDir = QVector3D(1, 0, 0);
                 } else { // YZ
-                    refDir = QVector3D(0, 0, -1);
+                    refDir = QVector3D(0, 1, 0);
                 }
             }
 
@@ -321,13 +321,13 @@ void LineTool::paintGL()
 
             // Quadrant snapping
             double mouseAngle;
-            if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) mouseAngle = qRadiansToDegrees(atan2(mouseVec.z(), mouseVec.x()));
+            if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) mouseAngle = qRadiansToDegrees(atan2(mouseVec.y(), mouseVec.x()));
-            else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) mouseAngle = qRadiansToDegrees(atan2(mouseVec.y(), mouseVec.x()));
+            else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) mouseAngle = qRadiansToDegrees(atan2(mouseVec.z(), mouseVec.x()));
             else mouseAngle = qRadiansToDegrees(atan2(mouseVec.z(), mouseVec.y()));
 
             double refAngle;
-            if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) refAngle = qRadiansToDegrees(atan2(refDir.z(), refDir.x()));
+            if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) refAngle = qRadiansToDegrees(atan2(refDir.y(), refDir.x()));
-            else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) refAngle = qRadiansToDegrees(atan2(refDir.y(), refDir.x()));
+            else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) refAngle = qRadiansToDegrees(atan2(refDir.z(), refDir.x()));
             else refAngle = qRadiansToDegrees(atan2(refDir.z(), refDir.y()));
 
             double relativeMouseAngle = mouseAngle - refAngle;
@@ -347,8 +347,8 @@ void LineTool::paintGL()
 
             double finalAngleRad = qDegreesToRadians(refAngle + snappedAngle);
             QVector3D finalDir;
-            if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) finalDir = QVector3D(cos(finalAngleRad), 0, sin(finalAngleRad));
+            if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) finalDir = QVector3D(cos(finalAngleRad), sin(finalAngleRad), 0);
-            else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) finalDir = QVector3D(cos(finalAngleRad), sin(finalAngleRad), 0);
+            else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) finalDir = QVector3D(cos(finalAngleRad), 0, sin(finalAngleRad));
             else finalDir = QVector3D(0, cos(finalAngleRad), sin(finalAngleRad));
 
             double lineLength;
@@ -380,8 +380,8 @@ void LineTool::paintGL()
             } else if (m_viewport->isSnappingVertex()) {
                 worldPos.setX(m_viewport->snapVertex().X()); worldPos.setY(m_viewport->snapVertex().Y()); worldPos.setZ(m_viewport->snapVertex().Z());
             } else if (m_viewport->isSnappingHorizontal()) {
-                if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) worldPos.setZ(m_firstLinePoint.Z());
+                if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) worldPos.setY(m_firstLinePoint.Y());
-                else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) worldPos.setY(m_firstLinePoint.Y());
+                else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) worldPos.setZ(m_firstLinePoint.Z());
                 else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::YZ) worldPos.setZ(m_firstLinePoint.Z());
             } else if (m_viewport->isSnappingVertical()) {
                 if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) worldPos.setX(m_firstLinePoint.X());
@@ -410,7 +410,7 @@ void LineTool::paintGL()
                     refDir = m_viewport->property("previousLineDirection").value<QVector3D>();
                 } else {
                     if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY || m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) refDir = QVector3D(1, 0, 0);
-                    else refDir = QVector3D(0, 0, -1);
+                    else refDir = QVector3D(0, 1, 0);
                 }
 
                 if (angleFromInput) {
@@ -418,13 +418,13 @@ void LineTool::paintGL()
                     QVector3D mouseVec = currentMouseWorldPos - startPos;
 
                     double mouseAngle;
-                    if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) mouseAngle = qRadiansToDegrees(atan2(mouseVec.z(), mouseVec.x()));
+                    if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) mouseAngle = qRadiansToDegrees(atan2(mouseVec.y(), mouseVec.x()));
-                    else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) mouseAngle = qRadiansToDegrees(atan2(mouseVec.y(), mouseVec.x()));
+                    else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) mouseAngle = qRadiansToDegrees(atan2(mouseVec.z(), mouseVec.x()));
                     else mouseAngle = qRadiansToDegrees(atan2(mouseVec.z(), mouseVec.y()));
 
                     double refAngleForQuadrant;
-                    if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) refAngleForQuadrant = qRadiansToDegrees(atan2(refDir.z(), refDir.x()));
+                    if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) refAngleForQuadrant = qRadiansToDegrees(atan2(refDir.y(), refDir.x()));
-                    else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) refAngleForQuadrant = qRadiansToDegrees(atan2(refDir.y(), refDir.x()));
+                    else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) refAngleForQuadrant = qRadiansToDegrees(atan2(refDir.z(), refDir.x()));
                     else refAngleForQuadrant = qRadiansToDegrees(atan2(refDir.z(), refDir.y()));
 
                     double relativeMouseAngle = mouseAngle - refAngleForQuadrant;
@@ -441,11 +441,11 @@ void LineTool::paintGL()
                 }
 
                 if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) {
-                    refAngle = atan2(refDir.z(), refDir.x());
-                    lineAngle = atan2(lineVec.z(), lineVec.x());
-                } else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) {
                     refAngle = atan2(refDir.y(), refDir.x());
                     lineAngle = atan2(lineVec.y(), lineVec.x());
+                } else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) {
+                    refAngle = atan2(refDir.z(), refDir.x());
+                    lineAngle = atan2(lineVec.z(), lineVec.x());
                 } else { // YZ
                     refAngle = atan2(refDir.z(), refDir.y());
                     lineAngle = atan2(lineVec.z(), lineVec.y());
@@ -461,9 +461,9 @@ void LineTool::paintGL()
 
             QVector3D perpVec;
             if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) {
-                perpVec = QVector3D(-lineVec.z(), 0, lineVec.x()).normalized();
-            } else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) {
                 perpVec = QVector3D(-lineVec.y(), lineVec.x(), 0).normalized();
+            } else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) {
+                perpVec = QVector3D(-lineVec.z(), 0, lineVec.x()).normalized();
             } else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::YZ) {
                 perpVec = QVector3D(0, -lineVec.z(), lineVec.y()).normalized();
             }
@@ -513,8 +513,8 @@ void LineTool::paintGL()
             for (int i = 0; i <= numSegments; ++i) {
                 double angle = refAngle + (lineAngle - refAngle) * i / numSegments;
                 QVector3D p;
-                if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) p = startPos + radius * QVector3D(cos(angle), 0, sin(angle));
+                if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) p = startPos + radius * QVector3D(cos(angle), sin(angle), 0);
-                else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) p = startPos + radius * QVector3D(cos(angle), sin(angle), 0);
+                else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) p = startPos + radius * QVector3D(cos(angle), 0, sin(angle));
                 else p = startPos + radius * QVector3D(0, cos(angle), sin(angle));
                 vertices << p.x() << p.y() << p.z();
             }
@@ -535,11 +535,11 @@ void LineTool::paintGL()
             double endAngle = lineAngle;
             QVector3D radialDir_end, tangentDir_end;
             if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) {
-                radialDir_end = QVector3D(cos(endAngle), 0, sin(endAngle));
-                tangentDir_end = QVector3D(-sin(endAngle), 0, cos(endAngle));
-            } else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) {
                 radialDir_end = QVector3D(cos(endAngle), sin(endAngle), 0);
                 tangentDir_end = QVector3D(-sin(endAngle), cos(endAngle), 0);
+            } else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) {
+                radialDir_end = QVector3D(cos(endAngle), 0, sin(endAngle));
+                tangentDir_end = QVector3D(-sin(endAngle), 0, cos(endAngle));
             } else {
                 radialDir_end = QVector3D(0, cos(endAngle), sin(endAngle));
                 tangentDir_end = QVector3D(0, -sin(endAngle), cos(endAngle));
@@ -555,11 +555,11 @@ void LineTool::paintGL()
             double startAngle = refAngle;
             QVector3D radialDir_start, tangentDir_start;
              if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) {
-                radialDir_start = QVector3D(cos(startAngle), 0, sin(startAngle));
-                tangentDir_start = QVector3D(-sin(startAngle), 0, cos(startAngle));
-            } else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) {
                 radialDir_start = QVector3D(cos(startAngle), sin(startAngle), 0);
                 tangentDir_start = QVector3D(-sin(startAngle), cos(startAngle), 0);
+            } else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) {
+                radialDir_start = QVector3D(cos(startAngle), 0, sin(startAngle));
+                tangentDir_start = QVector3D(-sin(startAngle), 0, cos(startAngle));
             } else {
                 radialDir_start = QVector3D(0, cos(startAngle), sin(startAngle));
                 tangentDir_start = QVector3D(0, -sin(startAngle), cos(startAngle));
@@ -584,22 +584,22 @@ void LineTool::paintGL()
             const float indicatorOffset = 0.02f * -m_viewport->camera()->zoom();
             if (m_viewport->isSnappingHorizontal()) {
                 if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) {
-                    vertices << midPoint.x() - indicatorSize << midPoint.y() << midPoint.z() + indicatorOffset;
-                    vertices << midPoint.x() + indicatorSize << midPoint.y() << midPoint.z() + indicatorOffset;
-                } else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) {
                     vertices << midPoint.x() - indicatorSize << midPoint.y() + indicatorOffset << midPoint.z();
                     vertices << midPoint.x() + indicatorSize << midPoint.y() + indicatorOffset << midPoint.z();
+                } else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) {
+                    vertices << midPoint.x() - indicatorSize << midPoint.y() << midPoint.z() + indicatorOffset;
+                    vertices << midPoint.x() + indicatorSize << midPoint.y() << midPoint.z() + indicatorOffset;
                 } else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::YZ) {
                     vertices << midPoint.x() << midPoint.y() - indicatorSize << midPoint.z() + indicatorOffset;
                     vertices << midPoint.x() << midPoint.y() + indicatorSize << midPoint.z() + indicatorOffset;
                 }
             } else { // m_isSnappingVertical
                 if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) {
-                    vertices << midPoint.x() + indicatorOffset << midPoint.y() << midPoint.z() - indicatorSize;
-                    vertices << midPoint.x() + indicatorOffset << midPoint.y() << midPoint.z() + indicatorSize;
-                } else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) {
                     vertices << midPoint.x() + indicatorOffset << midPoint.y() - indicatorSize << midPoint.z();
                     vertices << midPoint.x() + indicatorOffset << midPoint.y() + indicatorSize << midPoint.z();
+                } else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) {
+                    vertices << midPoint.x() + indicatorOffset << midPoint.y() << midPoint.z() - indicatorSize;
+                    vertices << midPoint.x() + indicatorOffset << midPoint.y() << midPoint.z() + indicatorSize;
                 } else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::YZ) {
                     vertices << midPoint.x() << midPoint.y() + indicatorOffset << midPoint.z() - indicatorSize;
                     vertices << midPoint.x() << midPoint.y() + indicatorOffset << midPoint.z() + indicatorSize;
@@ -647,7 +647,7 @@ void LineTool::paint2D(QPainter& painter, const QMatrix4x4& modelView, const QMa
                 if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY || m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) {
                     refDir = QVector3D(1, 0, 0);
                 } else { // YZ
-                    refDir = QVector3D(0, 0, -1);
+                    refDir = QVector3D(0, 1, 0);
                 }
             }
 
@@ -655,13 +655,13 @@ void LineTool::paint2D(QPainter& painter, const QMatrix4x4& modelView, const QMa
             QVector3D mouseVec = currentMouseWorldPos - startPos;
 
             double mouseAngle;
-            if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) mouseAngle = qRadiansToDegrees(atan2(mouseVec.z(), mouseVec.x()));
+            if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) mouseAngle = qRadiansToDegrees(atan2(mouseVec.y(), mouseVec.x()));
-            else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) mouseAngle = qRadiansToDegrees(atan2(mouseVec.y(), mouseVec.x()));
+            else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) mouseAngle = qRadiansToDegrees(atan2(mouseVec.z(), mouseVec.x()));
             else mouseAngle = qRadiansToDegrees(atan2(mouseVec.z(), mouseVec.y()));
 
             double refAngle;
-            if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) refAngle = qRadiansToDegrees(atan2(refDir.z(), refDir.x()));
+            if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) refAngle = qRadiansToDegrees(atan2(refDir.y(), refDir.x()));
-            else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) refAngle = qRadiansToDegrees(atan2(refDir.y(), refDir.x()));
+            else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) refAngle = qRadiansToDegrees(atan2(refDir.z(), refDir.x()));
             else refAngle = qRadiansToDegrees(atan2(refDir.z(), refDir.y()));
 
             double relativeMouseAngle = mouseAngle - refAngle;
@@ -681,8 +681,8 @@ void LineTool::paint2D(QPainter& painter, const QMatrix4x4& modelView, const QMa
 
             double finalAngleRad = qDegreesToRadians(refAngle + snappedAngle);
             QVector3D finalDir;
-            if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) finalDir = QVector3D(cos(finalAngleRad), 0, sin(finalAngleRad));
+            if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) finalDir = QVector3D(cos(finalAngleRad), sin(finalAngleRad), 0);
-            else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) finalDir = QVector3D(cos(finalAngleRad), sin(finalAngleRad), 0);
+            else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) finalDir = QVector3D(cos(finalAngleRad), 0, sin(finalAngleRad));
             else finalDir = QVector3D(0, cos(finalAngleRad), sin(finalAngleRad));
 
             if (lengthFromInput) {
@@ -714,8 +714,8 @@ void LineTool::paint2D(QPainter& painter, const QMatrix4x4& modelView, const QMa
             } else if (m_viewport->isSnappingVertex()) {
                 worldPos.setX(m_viewport->snapVertex().X()); worldPos.setY(m_viewport->snapVertex().Y()); worldPos.setZ(m_viewport->snapVertex().Z());
             } else if (m_viewport->isSnappingHorizontal()) {
-                if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) worldPos.setZ(m_firstLinePoint.Z());
+                if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) worldPos.setY(m_firstLinePoint.Y());
-                else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) worldPos.setY(m_firstLinePoint.Y());
+                else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) worldPos.setZ(m_firstLinePoint.Z());
                 else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::YZ) worldPos.setZ(m_firstLinePoint.Z());
             } else if (m_viewport->isSnappingVertical()) {
                 if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) worldPos.setX(m_firstLinePoint.X());
@@ -733,7 +733,7 @@ void LineTool::paint2D(QPainter& painter, const QMatrix4x4& modelView, const QMa
                 refDir = m_viewport->property("previousLineDirection").value<QVector3D>();
             } else {
                 if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY || m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) refDir = QVector3D(1, 0, 0);
-                else refDir = QVector3D(0, 0, -1);
+                else refDir = QVector3D(0, 1, 0);
             }
 
             QVector3D currentMouseWorldPosForText = m_viewport->unproject(m_viewport->currentMousePos(), m_viewport->currentPlane());
@@ -742,13 +742,13 @@ void LineTool::paint2D(QPainter& painter, const QMatrix4x4& modelView, const QMa
             if (angleFromInput) {
                 if (mouseVecForText.length() > 1e-6) {
                     double mouseAngle;
-                    if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) mouseAngle = qRadiansToDegrees(atan2(mouseVecForText.z(), mouseVecForText.x()));
+                    if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) mouseAngle = qRadiansToDegrees(atan2(mouseVecForText.y(), mouseVecForText.x()));
-                    else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) mouseAngle = qRadiansToDegrees(atan2(mouseVecForText.y(), mouseVecForText.x()));
+                    else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) mouseAngle = qRadiansToDegrees(atan2(mouseVecForText.z(), mouseVecForText.x()));
                     else mouseAngle = qRadiansToDegrees(atan2(mouseVecForText.z(), mouseVecForText.y()));
 
                     double refAngleForQuadrant;
-                    if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) refAngleForQuadrant = qRadiansToDegrees(atan2(refDir.z(), refDir.x()));
+                    if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) refAngleForQuadrant = qRadiansToDegrees(atan2(refDir.y(), refDir.x()));
-                    else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) refAngleForQuadrant = qRadiansToDegrees(atan2(refDir.y(), refDir.x()));
+                    else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) refAngleForQuadrant = qRadiansToDegrees(atan2(refDir.z(), refDir.x()));
                     else refAngleForQuadrant = qRadiansToDegrees(atan2(refDir.z(), refDir.y()));
 
                     double relativeMouseAngle = mouseAngle - refAngleForQuadrant;
@@ -766,11 +766,11 @@ void LineTool::paint2D(QPainter& painter, const QMatrix4x4& modelView, const QMa
             }
 
             if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) {
-                refAngle = atan2(refDir.z(), refDir.x());
-                lineAngle = atan2(lineVec.z(), lineVec.x());
-            } else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) {
                 refAngle = atan2(refDir.y(), refDir.x());
                 lineAngle = atan2(lineVec.y(), lineVec.x());
+            } else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) {
+                refAngle = atan2(refDir.z(), refDir.x());
+                lineAngle = atan2(lineVec.z(), lineVec.x());
             } else { // YZ
                 refAngle = atan2(refDir.z(), refDir.y());
                 lineAngle = atan2(lineVec.z(), lineVec.y());
@@ -783,9 +783,9 @@ void LineTool::paint2D(QPainter& painter, const QMatrix4x4& modelView, const QMa
 
             QVector3D perpVec;
             if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) {
-                perpVec = QVector3D(-lineVec.z(), 0, lineVec.x()).normalized();
-            } else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) {
                 perpVec = QVector3D(-lineVec.y(), lineVec.x(), 0).normalized();
+            } else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) {
+                perpVec = QVector3D(-lineVec.z(), 0, lineVec.x()).normalized();
             } else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::YZ) {
                 perpVec = QVector3D(0, -lineVec.z(), lineVec.y()).normalized();
             }
@@ -831,8 +831,8 @@ void LineTool::paint2D(QPainter& painter, const QMatrix4x4& modelView, const QMa
             QVector3D textPos3DAngle;
             float textOffset = 0.035f * -m_viewport->camera()->zoom();
 
-            if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) textPos3DAngle = startPos + (radius + textOffset) * QVector3D(cos(midAngle), 0, sin(midAngle));
+            if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) textPos3DAngle = startPos + (radius + textOffset) * QVector3D(cos(midAngle), sin(midAngle), 0);
-            else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) textPos3DAngle = startPos + (radius + textOffset) * QVector3D(cos(midAngle), sin(midAngle), 0);
+            else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) textPos3DAngle = startPos + (radius + textOffset) * QVector3D(cos(midAngle), 0, sin(midAngle));
             else textPos3DAngle = startPos + (radius + textOffset) * QVector3D(0, cos(midAngle), sin(midAngle));
 
             QVector3D screenPosAngle = m_viewport->project(textPos3DAngle, modelView, projection, m_viewport->rect());

src/MainWindow.cpp

@@ -4,6 +4,8 @@
 #include "SketchFeature.h"
 #include "Feature.h"
 #include "ApplicationController.h"
+#include "DebugWindow.h"
+#include "Camera.h"
 
 #include <QMenuBar>
 #include <QMenu>
@@ -19,6 +21,7 @@
 #include <QStringList>
 #include <QKeyEvent>
 #include <QApplication>
+#include <QProcessEnvironment>
 
 MainWindow::MainWindow(ApplicationController* appController, QWidget *parent)
     : QMainWindow(parent)
@@ -41,6 +44,10 @@ MainWindow::MainWindow(ApplicationController* appController, QWidget *parent)
     QAction *saveAsAction = fileMenu->addAction("Save &As...");
     connect(saveAsAction, &QAction::triggered, this, &MainWindow::saveAs);
 
+    QMenu *helpMenu = menuBar()->addMenu("&Help");
+    QAction *debugAction = helpMenu->addAction("&Debug");
+    connect(debugAction, &QAction::triggered, this, &MainWindow::showDebugWindow);
+
 
     QToolBar* mainToolBar = addToolBar("Main Toolbar");
     mainToolBar->setMovable(false);
@@ -151,6 +158,13 @@ MainWindow::MainWindow(ApplicationController* appController, QWidget *parent)
     connect(m_viewport, &ViewportWidget::planeSelected, m_appController, &ApplicationController::onPlaneSelected);
     connect(m_viewport, &ViewportWidget::toolDeactivated, m_appController, [this]() { m_appController->setActiveTool(ApplicationController::ToolType::None); });
 
+    connect(m_viewport->camera(), &Camera::cameraChanged, this, &MainWindow::updateDebugInfo);
+
+    m_debugWindow = new DebugWindow(this);
+    if (QProcessEnvironment::systemEnvironment().value("DEBUG") == "true") {
+        showDebugWindow();
+    }
+
     updateWindowTitle(QString());
 }
 
@@ -184,6 +198,17 @@ bool MainWindow::saveAs()
     return m_appController->saveDocumentAs();
 }
 
+void MainWindow::showDebugWindow()
+{
+    updateDebugInfo();
+    m_debugWindow->show();
+}
+
+void MainWindow::updateDebugInfo()
+{
+    m_debugWindow->updateCameraInfo(m_viewport->camera());
+}
+
 void MainWindow::enterSketchMode()
 {
     m_tabWidget->removeTab(m_tabWidget->indexOf(m_toolsTab));

src/MainWindow.h

@@ -10,6 +10,7 @@ class Feature;
 class QTabWidget;
 class QWidget;
 class ApplicationController;
+class DebugWindow;
 
 class MainWindow : public QMainWindow
 {
@@ -26,6 +27,9 @@ private slots:
     void createSketch();
     void saveSketch();
 
+    void showDebugWindow();
+    void updateDebugInfo();
+
     void enterSketchMode();
     void exitSketchMode();
     void updateWindowTitle(const QString& filePath);
@@ -36,6 +40,7 @@ protected:
 private:
     ApplicationController* m_appController;
     ViewportWidget *m_viewport;
+    DebugWindow* m_debugWindow;
 
     QTabWidget *m_tabWidget;
     QWidget *m_solidTab;

src/RectangleTool.cpp

@@ -69,10 +69,10 @@ void RectangleTool::mousePressEvent(QMouseEvent *event)
             double current_w, current_h;
             if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) {
                 current_w = qAbs(mouseDir.x());
-                current_h = qAbs(mouseDir.z());
+                current_h = qAbs(mouseDir.y());
             } else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) {
                 current_w = qAbs(mouseDir.x());
-                current_h = qAbs(mouseDir.y());
+                current_h = qAbs(mouseDir.z());
             } else { // YZ
                 current_w = qAbs(mouseDir.y());
                 current_h = qAbs(mouseDir.z());
@@ -85,10 +85,10 @@ void RectangleTool::mousePressEvent(QMouseEvent *event)
             worldPos = startPos;
             if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) {
                 worldPos.setX(startPos.x() + signX * rect_w);
-                worldPos.setZ(startPos.z() + signZ * rect_h);
+                worldPos.setY(startPos.y() + signY * rect_h);
             } else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) {
                 worldPos.setX(startPos.x() + signX * rect_w);
-                worldPos.setY(startPos.y() + signY * rect_h);
+                worldPos.setZ(startPos.z() + signZ * rect_h);
             } else { // YZ
                 worldPos.setY(startPos.y() + signY * rect_w);
                 worldPos.setZ(startPos.z() + signZ * rect_h);
@@ -140,10 +140,10 @@ void RectangleTool::finalizeCreation()
         double current_w, current_h;
         if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) {
             current_w = qAbs(mouseDir.x());
-            current_h = qAbs(mouseDir.z());
+            current_h = qAbs(mouseDir.y());
         } else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) {
             current_w = qAbs(mouseDir.x());
-            current_h = qAbs(mouseDir.y());
+            current_h = qAbs(mouseDir.z());
         } else { // YZ
             current_w = qAbs(mouseDir.y());
             current_h = qAbs(mouseDir.z());
@@ -156,10 +156,10 @@ void RectangleTool::finalizeCreation()
         worldPos = startPos;
         if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) {
             worldPos.setX(startPos.x() + signX * rect_w);
-            worldPos.setZ(startPos.z() + signZ * rect_h);
+            worldPos.setY(startPos.y() + signY * rect_h);
         } else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) {
             worldPos.setX(startPos.x() + signX * rect_w);
-            worldPos.setY(startPos.y() + signY * rect_h);
+            worldPos.setZ(startPos.z() + signZ * rect_h);
         } else { // YZ
             worldPos.setY(startPos.y() + signY * rect_w);
             worldPos.setZ(startPos.z() + signZ * rect_h);
@@ -206,10 +206,10 @@ void RectangleTool::paintGL()
             double current_w, current_h;
             if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) {
                 current_w = qAbs(mouseDir.x());
-                current_h = qAbs(mouseDir.z());
+                current_h = qAbs(mouseDir.y());
             } else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) {
                 current_w = qAbs(mouseDir.x());
-                current_h = qAbs(mouseDir.y());
+                current_h = qAbs(mouseDir.z());
             } else { // YZ
                 current_w = qAbs(mouseDir.y());
                 current_h = qAbs(mouseDir.z());
@@ -222,10 +222,10 @@ void RectangleTool::paintGL()
             worldPos = startPos;
             if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) {
                 worldPos.setX(startPos.x() + signX * rect_w);
-                worldPos.setZ(startPos.z() + signZ * rect_h);
+                worldPos.setY(startPos.y() + signY * rect_h);
             } else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) {
                 worldPos.setX(startPos.x() + signX * rect_w);
-                worldPos.setY(startPos.y() + signY * rect_h);
+                worldPos.setZ(startPos.z() + signZ * rect_h);
             } else { // YZ
                 worldPos.setY(startPos.y() + signY * rect_w);
                 worldPos.setZ(startPos.z() + signZ * rect_h);
@@ -245,10 +245,10 @@ void RectangleTool::paintGL()
 
         if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) {
             p2.setX(p3.x()); p2.setY(p1.y()); p2.setZ(p1.z());
-            p4.setX(p1.x()); p4.setY(p1.y()); p4.setZ(p3.z());
+            p4.setX(p1.x()); p4.setY(p3.y()); p4.setZ(p1.z());
         } else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) {
             p2.setX(p3.x()); p2.setY(p1.y()); p2.setZ(p1.z());
-            p4.setX(p1.x()); p4.setY(p3.y()); p4.setZ(p1.z());
+            p4.setX(p1.x()); p4.setY(p1.y()); p4.setZ(p3.z());
         } else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::YZ) {
             p2.setX(p1.x()); p2.setY(p3.y()); p2.setZ(p1.z());
             p4.setX(p1.x()); p4.setY(p1.y()); p4.setZ(p3.z());
@@ -300,10 +300,10 @@ void RectangleTool::paint2D(QPainter& painter, const QMatrix4x4& modelView, cons
             double current_w, current_h;
             if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) {
                 current_w = qAbs(mouseDir.x());
-                current_h = qAbs(mouseDir.z());
+                current_h = qAbs(mouseDir.y());
             } else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) {
                 current_w = qAbs(mouseDir.x());
-                current_h = qAbs(mouseDir.y());
+                current_h = qAbs(mouseDir.z());
             } else { // YZ
                 current_w = qAbs(mouseDir.y());
                 current_h = qAbs(mouseDir.z());
@@ -316,10 +316,10 @@ void RectangleTool::paint2D(QPainter& painter, const QMatrix4x4& modelView, cons
             worldPos = p1_3d;
             if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) {
                 worldPos.setX(p1_3d.x() + signX * rect_w);
-                worldPos.setZ(p1_3d.z() + signZ * rect_h);
+                worldPos.setY(p1_3d.y() + signY * rect_h);
             } else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) {
                 worldPos.setX(p1_3d.x() + signX * rect_w);
-                worldPos.setY(p1_3d.y() + signY * rect_h);
+                worldPos.setZ(p1_3d.z() + signZ * rect_h);
             } else { // YZ
                 worldPos.setY(p1_3d.y() + signY * rect_w);
                 worldPos.setZ(p1_3d.z() + signZ * rect_h);
@@ -338,15 +338,15 @@ void RectangleTool::paint2D(QPainter& painter, const QMatrix4x4& modelView, cons
         double w, h;
 
         if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) {
-            p2_3d.setX(p3_3d.x()); p2_3d.setY(p1_3d.y()); p2_3d.setZ(p1_3d.z());
-            p4_3d.setX(p1_3d.x()); p4_3d.setY(p1_3d.y()); p4_3d.setZ(p3_3d.z());
-            w = qAbs(p3_3d.x() - p1_3d.x());
-            h = qAbs(p3_3d.z() - p1_3d.z());
-        } else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) {
             p2_3d.setX(p3_3d.x()); p2_3d.setY(p1_3d.y()); p2_3d.setZ(p1_3d.z());
             p4_3d.setX(p1_3d.x()); p4_3d.setY(p3_3d.y()); p4_3d.setZ(p1_3d.z());
             w = qAbs(p3_3d.x() - p1_3d.x());
             h = qAbs(p3_3d.y() - p1_3d.y());
+        } else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) {
+            p2_3d.setX(p3_3d.x()); p2_3d.setY(p1_3d.y()); p2_3d.setZ(p1_3d.z());
+            p4_3d.setX(p1_3d.x()); p4_3d.setY(p1_3d.y()); p4_3d.setZ(p3_3d.z());
+            w = qAbs(p3_3d.x() - p1_3d.x());
+            h = qAbs(p3_3d.z() - p1_3d.z());
         } else { // YZ
             p2_3d.setX(p1_3d.x()); p2_3d.setY(p3_3d.y()); p2_3d.setZ(p1_3d.z());
             p4_3d.setX(p1_3d.x()); p4_3d.setY(p1_3d.y()); p4_3d.setZ(p3_3d.z());

src/SketchGrid.cpp

@@ -87,11 +87,11 @@ void SketchGrid::drawGridLines(SketchPlane plane, QOpenGLShaderProgram* shaderPr
         float pos = i * minorIncrement;
         QVector<GLfloat>& current_vector = (i % 5 == 0) ? majorLines : minorLines;
         if (plane == XY) {
-            current_vector << pos << 0 << -gridSize << pos << 0 << gridSize;
-            current_vector << -gridSize << 0 << pos << gridSize << 0 << pos;
-        } else if (plane == XZ) {
             current_vector << pos << -gridSize << 0 << pos << gridSize << 0;
             current_vector << -gridSize << pos << 0 << gridSize << pos << 0;
+        } else if (plane == XZ) {
+            current_vector << pos << 0 << -gridSize << pos << 0 << gridSize;
+            current_vector << -gridSize << 0 << pos << gridSize << 0 << pos;
         } else { // YZ
             current_vector << 0 << pos << -gridSize << 0 << pos << gridSize;
             current_vector << 0 << -gridSize << pos << 0 << gridSize << pos;
@@ -133,7 +133,7 @@ void SketchGrid::drawAxes(SketchPlane plane, QOpenGLShaderProgram* shaderProgram
     // Y Axis (Green)
     if (plane == XY || plane == YZ) {
         vertices.clear();
-        vertices << 0 << 0 << -axisLength << 0 << 0 << axisLength;
+        vertices << 0 << -axisLength << 0 << 0 << axisLength << 0;
         shaderProgram->setUniformValue(colorLoc, QVector4D(0.0f, 1.0f, 0.0f, 1.0f));
         m_vbo.allocate(vertices.constData(), vertices.size() * sizeof(GLfloat));
         glDrawArrays(GL_LINES, 0, 2);
@@ -141,7 +141,7 @@ void SketchGrid::drawAxes(SketchPlane plane, QOpenGLShaderProgram* shaderProgram
     // Z Axis (Blue)
     if (plane == XZ || plane == YZ) {
         vertices.clear();
-        vertices << 0 << -axisLength << 0 << 0 << axisLength << 0;
+        vertices << 0 << 0 << -axisLength << 0 << 0 << axisLength;
         shaderProgram->setUniformValue(colorLoc, QVector4D(0.0f, 0.0f, 1.0f, 1.0f));
         m_vbo.allocate(vertices.constData(), vertices.size() * sizeof(GLfloat));
         glDrawArrays(GL_LINES, 0, 2);
@@ -184,10 +184,10 @@ void SketchGrid::paintAxisLabels(QPainter& painter, SketchGrid::SketchPlane plan
 
     if (plane == SketchGrid::XY) {
         drawLabelsForAxis(0); // X
-        drawLabelsForAxis(2); // Y
+        drawLabelsForAxis(1); // Y
     } else if (plane == SketchGrid::XZ) {
         drawLabelsForAxis(0); // X
-        drawLabelsForAxis(1); // Z
+        drawLabelsForAxis(2); // Z
     } else if (plane == SketchGrid::YZ) {
         drawLabelsForAxis(1); // Y
         drawLabelsForAxis(2); // Z

src/Snapping.cpp

@@ -29,10 +29,10 @@ bool Snapping::update(const QPoint& mousePos)
 
         switch (m_viewport->currentPlane()) {
             case ViewportWidget::SketchPlane::XY:
-                shouldSnap = qAbs(worldPos.x()) < snapRectHalfSize && qAbs(worldPos.z()) < snapRectHalfSize;
+                shouldSnap = qAbs(worldPos.x()) < snapRectHalfSize && qAbs(worldPos.y()) < snapRectHalfSize;
                 break;
             case ViewportWidget::SketchPlane::XZ:
-                shouldSnap = qAbs(worldPos.x()) < snapRectHalfSize && qAbs(worldPos.y()) < snapRectHalfSize;
+                shouldSnap = qAbs(worldPos.x()) < snapRectHalfSize && qAbs(worldPos.z()) < snapRectHalfSize;
                 break;
             case ViewportWidget::SketchPlane::YZ:
                 shouldSnap = qAbs(worldPos.y()) < snapRectHalfSize && qAbs(worldPos.z()) < snapRectHalfSize;
@@ -62,10 +62,10 @@ bool Snapping::update(const QPoint& mousePos)
                             bool isClose = false;
                             switch (m_viewport->currentPlane()) {
                             case ViewportWidget::SketchPlane::XY:
-                                isClose = qAbs(worldPos.x() - vertex.X()) < snapRectHalfSize && qAbs(worldPos.z() - vertex.Z()) < snapRectHalfSize;
+                                isClose = qAbs(worldPos.x() - vertex.X()) < snapRectHalfSize && qAbs(worldPos.y() - vertex.Y()) < snapRectHalfSize;
                                 break;
                             case ViewportWidget::SketchPlane::XZ:
-                                isClose = qAbs(worldPos.x() - vertex.X()) < snapRectHalfSize && qAbs(worldPos.y() - vertex.Y()) < snapRectHalfSize;
+                                isClose = qAbs(worldPos.x() - vertex.X()) < snapRectHalfSize && qAbs(worldPos.z() - vertex.Z()) < snapRectHalfSize;
                                 break;
                             case ViewportWidget::SketchPlane::YZ:
                                 isClose = qAbs(worldPos.y() - vertex.Y()) < snapRectHalfSize && qAbs(worldPos.z() - vertex.Z()) < snapRectHalfSize;
@@ -88,10 +88,10 @@ bool Snapping::update(const QPoint& mousePos)
 
                         if (sketch->plane() == SketchFeature::SketchPlane::XY) {
                             p2.SetCoord(p3.X(), p1.Y(), p1.Z());
-                            p4.SetCoord(p1.X(), p1.Y(), p3.Z());
+                            p4.SetCoord(p1.X(), p3.Y(), p1.Z());
                         } else if (sketch->plane() == SketchFeature::SketchPlane::XZ) {
                             p2.SetCoord(p3.X(), p1.Y(), p1.Z());
-                            p4.SetCoord(p1.X(), p3.Y(), p1.Z());
+                            p4.SetCoord(p1.X(), p1.Y(), p3.Z());
                         } else if (sketch->plane() == SketchFeature::SketchPlane::YZ) {
                             p2.SetCoord(p1.X(), p3.Y(), p1.Z());
                             p4.SetCoord(p1.X(), p1.Y(), p3.Z());
@@ -102,10 +102,10 @@ bool Snapping::update(const QPoint& mousePos)
                             bool isClose = false;
                             switch (m_viewport->currentPlane()) {
                             case ViewportWidget::SketchPlane::XY:
-                                isClose = qAbs(worldPos.x() - vertex.X()) < snapRectHalfSize && qAbs(worldPos.z() - vertex.Z()) < snapRectHalfSize;
+                                isClose = qAbs(worldPos.x() - vertex.X()) < snapRectHalfSize && qAbs(worldPos.y() - vertex.Y()) < snapRectHalfSize;
                                 break;
                             case ViewportWidget::SketchPlane::XZ:
-                                isClose = qAbs(worldPos.x() - vertex.X()) < snapRectHalfSize && qAbs(worldPos.y() - vertex.Y()) < snapRectHalfSize;
+                                isClose = qAbs(worldPos.x() - vertex.X()) < snapRectHalfSize && qAbs(worldPos.z() - vertex.Z()) < snapRectHalfSize;
                                 break;
                             case ViewportWidget::SketchPlane::YZ:
                                 isClose = qAbs(worldPos.y() - vertex.Y()) < snapRectHalfSize && qAbs(worldPos.z() - vertex.Z()) < snapRectHalfSize;
@@ -140,15 +140,15 @@ void Snapping::paintGL() const
     if (m_isSnappingOrigin) {
         const float rectSize = 0.0075f * -m_viewport->camera()->zoom();
         if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) {
-            vertices << -rectSize << 0 << -rectSize << rectSize << 0 << -rectSize;
-            vertices << rectSize << 0 << -rectSize << rectSize << 0 << rectSize;
-            vertices << rectSize << 0 << rectSize << -rectSize << 0 << rectSize;
-            vertices << -rectSize << 0 << rectSize << -rectSize << 0 << -rectSize;
-        } else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) {
             vertices << -rectSize << -rectSize << 0 << rectSize << -rectSize << 0;
             vertices << rectSize << -rectSize << 0 << rectSize << rectSize << 0;
             vertices << rectSize << rectSize << 0 << -rectSize << rectSize << 0;
             vertices << -rectSize << rectSize << 0 << -rectSize << -rectSize << 0;
+        } else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) {
+            vertices << -rectSize << 0 << -rectSize << rectSize << 0 << -rectSize;
+            vertices << rectSize << 0 << -rectSize << rectSize << 0 << rectSize;
+            vertices << rectSize << 0 << rectSize << -rectSize << 0 << rectSize;
+            vertices << -rectSize << 0 << rectSize << -rectSize << 0 << -rectSize;
         } else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::YZ) {
             vertices << 0 << -rectSize << -rectSize << 0 << rectSize << -rectSize;
             vertices << 0 << rectSize << -rectSize << 0 << rectSize << rectSize;
@@ -159,15 +159,15 @@ void Snapping::paintGL() const
         const float rectSize = 0.0075f * -m_viewport->camera()->zoom();
         const auto& v = m_snapVertex;
         if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XY) {
-            vertices << v.X() - rectSize << v.Y() << v.Z() - rectSize << v.X() + rectSize << v.Y() << v.Z() - rectSize;
-            vertices << v.X() + rectSize << v.Y() << v.Z() - rectSize << v.X() + rectSize << v.Y() << v.Z() + rectSize;
-            vertices << v.X() + rectSize << v.Y() << v.Z() + rectSize << v.X() - rectSize << v.Y() << v.Z() + rectSize;
-            vertices << v.X() - rectSize << v.Y() << v.Z() + rectSize << v.X() - rectSize << v.Y() << v.Z() - rectSize;
-        } else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) {
             vertices << v.X() - rectSize << v.Y() - rectSize << v.Z() << v.X() + rectSize << v.Y() - rectSize << v.Z();
             vertices << v.X() + rectSize << v.Y() - rectSize << v.Z() << v.X() + rectSize << v.Y() + rectSize << v.Z();
             vertices << v.X() + rectSize << v.Y() + rectSize << v.Z() << v.X() - rectSize << v.Y() + rectSize << v.Z();
             vertices << v.X() - rectSize << v.Y() + rectSize << v.Z() << v.X() - rectSize << v.Y() - rectSize << v.Z();
+        } else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::XZ) {
+            vertices << v.X() - rectSize << v.Y() << v.Z() - rectSize << v.X() + rectSize << v.Y() << v.Z() - rectSize;
+            vertices << v.X() + rectSize << v.Y() << v.Z() - rectSize << v.X() + rectSize << v.Y() << v.Z() + rectSize;
+            vertices << v.X() + rectSize << v.Y() << v.Z() + rectSize << v.X() - rectSize << v.Y() << v.Z() + rectSize;
+            vertices << v.X() - rectSize << v.Y() << v.Z() + rectSize << v.X() - rectSize << v.Y() << v.Z() - rectSize;
         } else if (m_viewport->currentPlane() == ViewportWidget::SketchPlane::YZ) {
             vertices << v.X() << v.Y() - rectSize << v.Z() - rectSize << v.X() << v.Y() + rectSize << v.Z() - rectSize;
             vertices << v.X() << v.Y() + rectSize << v.Z() - rectSize << v.X() << v.Y() + rectSize << v.Z() + rectSize;

src/ViewCube.cpp

@@ -7,6 +7,7 @@
 #include <QScreen>
 #include <QSvgRenderer>
 #include <QVector>
+#include <QVector3D>
 
 namespace
 {
@@ -74,6 +75,35 @@ void ViewCube::paintGL(QOpenGLShaderProgram* simpleShader, int simpleShaderColor
     drawViewCube(viewCubeProjection, viewMatrix, opacity);
     drawAxes(simpleShader, simpleShaderColorLoc, viewCubeProjection, viewMatrix);
 
+    QMatrix4x4 mvp = viewCubeProjection * viewMatrix;
+    const float axisLen = 1.7f;
+
+    QVector3D xAxisEnd(axisLen, 0.0f, 0.0f);
+    QVector3D yAxisEnd(0.0f, 0.0f, axisLen);
+    QVector3D zAxisEnd(0.0f, axisLen, 0.0f);
+
+    QVector3D xAxisNdc = mvp.map(xAxisEnd);
+    QVector3D yAxisNdc = mvp.map(yAxisEnd);
+    QVector3D zAxisNdc = mvp.map(zAxisEnd);
+
+    const int vpX = width - viewCubeSize;
+    const int vpY = 0;
+    const int vpW = viewCubeSize;
+    const int vpH = viewCubeSize;
+    const float dpr = QGuiApplication::primaryScreen()->devicePixelRatio();
+
+    m_xAxisLabelPos.setX( (xAxisNdc.x() + 1.0f) * vpW / 2.0f + vpX );
+    m_xAxisLabelPos.setY( (1.0f - xAxisNdc.y()) * vpH / 2.0f + vpY );
+    m_xAxisLabelPos /= dpr;
+
+    m_yAxisLabelPos.setX( (yAxisNdc.x() + 1.0f) * vpW / 2.0f + vpX );
+    m_yAxisLabelPos.setY( (1.0f - yAxisNdc.y()) * vpH / 2.0f + vpY );
+    m_yAxisLabelPos /= dpr;
+
+    m_zAxisLabelPos.setX( (zAxisNdc.x() + 1.0f) * vpW / 2.0f + vpX );
+    m_zAxisLabelPos.setY( (1.0f - zAxisNdc.y()) * vpH / 2.0f + vpY );
+    m_zAxisLabelPos /= dpr;
+
     glDisable(GL_BLEND);
 }
 
@@ -229,6 +259,23 @@ void ViewCube::drawAxes(QOpenGLShaderProgram* simpleShader, int colorLoc, const
 
 void ViewCube::paint2D(QPainter& painter, int widgetWidth, int widgetHeight)
 {
+    QFont font("Arial", 10, QFont::Bold);
+    painter.setFont(font);
+    painter.setPen(Qt::white);
+    QFontMetrics fm(font);
+
+    QRect xRect = fm.boundingRect("X");
+    xRect.moveCenter(m_xAxisLabelPos);
+    painter.drawText(xRect, Qt::AlignCenter, "X");
+
+    QRect yRect = fm.boundingRect("Y");
+    yRect.moveCenter(m_yAxisLabelPos);
+    painter.drawText(yRect, Qt::AlignCenter, "Y");
+
+    QRect zRect = fm.boundingRect("Z");
+    zRect.moveCenter(m_zAxisLabelPos);
+    painter.drawText(zRect, Qt::AlignCenter, "Z");
+
     if (!m_isHovered) {
         return;
     }

src/ViewCube.h

@@ -34,6 +34,10 @@ private:
     QRect m_homeButtonRect;
     QSvgRenderer* m_homeButtonRenderer = nullptr;
 
+    QPoint m_xAxisLabelPos;
+    QPoint m_yAxisLabelPos;
+    QPoint m_zAxisLabelPos;
+
     QOpenGLTexture* m_faceTextures[6];
 
     QOpenGLShaderProgram* m_textureShaderProgram = nullptr;

src/ViewportWidget.cpp

@@ -489,8 +489,8 @@ QVector3D ViewportWidget::unproject(const QPoint& screenPos, SketchPlane plane)
 
     QVector3D planeNormal;
     switch (plane) {
-        case SketchPlane::XY: planeNormal = QVector3D(0, 1, 0); break;
+        case SketchPlane::XY: planeNormal = QVector3D(0, 0, 1); break;
-        case SketchPlane::XZ: planeNormal = QVector3D(0, 0, 1); break;
+        case SketchPlane::XZ: planeNormal = QVector3D(0, 1, 0); break;
         case SketchPlane::YZ: planeNormal = QVector3D(1, 0, 0); break;
         case SketchPlane::NONE: return QVector3D();
     }
@@ -532,15 +532,15 @@ void ViewportWidget::drawSketch(const SketchFeature* sketch)
             const int numSegments = 64;
             QVector3D u_axis, v_axis;
             switch (sketch->plane()) {
-                case SketchFeature::SketchPlane::XY:
+                case SketchFeature::SketchPlane::XY: // Top
-                    u_axis = QVector3D(1, 0, 0);
-                    v_axis = QVector3D(0, 0, 1);
-                    break;
-                case SketchFeature::SketchPlane::XZ:
                     u_axis = QVector3D(1, 0, 0);
                     v_axis = QVector3D(0, 1, 0);
                     break;
-                case SketchFeature::SketchPlane::YZ:
+                case SketchFeature::SketchPlane::XZ: // Front
+                    u_axis = QVector3D(1, 0, 0);
+                    v_axis = QVector3D(0, 0, 1);
+                    break;
+                case SketchFeature::SketchPlane::YZ: // Right
                     u_axis = QVector3D(0, 1, 0);
                     v_axis = QVector3D(0, 0, 1);
                     break;
@@ -564,10 +564,10 @@ void ViewportWidget::drawSketch(const SketchFeature* sketch)
             gp_Pnt p2, p4;
             if (sketch->plane() == SketchFeature::SketchPlane::XY) {
                 p2.SetCoord(p3.X(), p1.Y(), p1.Z());
-                p4.SetCoord(p1.X(), p1.Y(), p3.Z());
+                p4.SetCoord(p1.X(), p3.Y(), p1.Z());
             } else if (sketch->plane() == SketchFeature::SketchPlane::XZ) {
                 p2.SetCoord(p3.X(), p1.Y(), p1.Z());
-                p4.SetCoord(p1.X(), p3.Y(), p1.Z());
+                p4.SetCoord(p1.X(), p1.Y(), p3.Z());
             } else if (sketch->plane() == SketchFeature::SketchPlane::YZ) {
                 p2.SetCoord(p1.X(), p3.Y(), p1.Z());
                 p4.SetCoord(p1.X(), p1.Y(), p3.Z());
@@ -702,18 +702,18 @@ void ViewportWidget::drawSelectionPlanes()
     };
 
     // XY Plane (Top)
-    QVector<GLfloat> xyQuad = { planeOffset, 0, planeOffset, planeOffset + planeSize, 0, planeOffset,
+    QVector<GLfloat> xyQuad = { planeOffset, -planeOffset, 0, planeOffset + planeSize, -planeOffset, 0,
-                                planeOffset + planeSize, 0, planeOffset + planeSize, planeOffset, 0, planeOffset + planeSize };
+                                planeOffset + planeSize, -planeOffset - planeSize, 0, planeOffset, -planeOffset - planeSize, 0 };
     drawPlane(xyQuad, m_highlightedPlane == SketchPlane::XY);
 
     // XZ Plane (Front)
-    QVector<GLfloat> xzQuad = { planeOffset, planeOffset, 0, planeOffset + planeSize, planeOffset, 0,
+    QVector<GLfloat> xzQuad = { planeOffset, 0, planeOffset, planeOffset + planeSize, 0, planeOffset,
-                                planeOffset + planeSize, planeOffset + planeSize, 0, planeOffset, planeOffset + planeSize, 0 };
+                                planeOffset + planeSize, 0, planeOffset + planeSize, planeOffset, 0, planeOffset + planeSize };
     drawPlane(xzQuad, m_highlightedPlane == SketchPlane::XZ);
 
     // YZ Plane (Right)
-    QVector<GLfloat> yzQuad = { 0, planeOffset, planeOffset, 0, planeOffset + planeSize, planeOffset,
+    QVector<GLfloat> yzQuad = { 0, -planeOffset, planeOffset, 0, -planeOffset, planeOffset + planeSize,
-                                0, planeOffset + planeSize, planeOffset + planeSize, 0, planeOffset, planeOffset + planeSize };
+                                0, -planeOffset - planeSize, planeOffset + planeSize, 0, -planeOffset - planeSize, planeOffset };
     drawPlane(yzQuad, m_highlightedPlane == SketchPlane::YZ);
 
     glEnable(GL_CULL_FACE);
@@ -731,7 +731,7 @@ ViewportWidget::SketchPlane ViewportWidget::checkPlaneSelection(const QPoint& sc
     // Check front to back to handle overlaps
     // YZ plane (Right)
     intersection = unproject(screenPos, SketchPlane::YZ);
-    if (intersection.y() >= planeOffset && intersection.y() <= planeOffset + planeSize &&
+    if (intersection.y() >= -planeOffset - planeSize && intersection.y() <= -planeOffset &&
         intersection.z() >= planeOffset && intersection.z() <= planeOffset + planeSize) {
         return SketchPlane::YZ;
     }
@@ -739,14 +739,14 @@ ViewportWidget::SketchPlane ViewportWidget::checkPlaneSelection(const QPoint& sc
     // XZ plane (Front)
     intersection = unproject(screenPos, SketchPlane::XZ);
     if (intersection.x() >= planeOffset && intersection.x() <= planeOffset + planeSize &&
-        intersection.y() >= planeOffset && intersection.y() <= planeOffset + planeSize) {
+        intersection.z() >= planeOffset && intersection.z() <= planeOffset + planeSize) {
         return SketchPlane::XZ;
     }
 
     // XY plane (Top)
     intersection = unproject(screenPos, SketchPlane::XY);
     if (intersection.x() >= planeOffset && intersection.x() <= planeOffset + planeSize &&
-        intersection.z() >= planeOffset && intersection.z() <= planeOffset + planeSize) {
+        intersection.y() >= -planeOffset - planeSize && intersection.y() <= -planeOffset) {
         return SketchPlane::XY;
     }