Tutorial_204_Viewer_Qt/main.cpp

This example shows how to create a simple viewer using Qt.

The header file of the viewer class:

/********************************************************************
 * Copyright (C) 2015 Liangliang Nan <liangliang.nan@gmail.com>
 * https://3d.bk.tudelft.nl/liangliang/
 *
 * This file is part of Easy3D. If it is useful in your research/work,
 * I would be grateful if you show your appreciation by citing it:
 * ------------------------------------------------------------------
 *      Liangliang Nan.
 *      Easy3D: a lightweight, easy-to-use, and efficient C++ library
 *      for processing and rendering 3D data.
 *      Journal of Open Source Software, 6(64), 3255, 2021.
 * ------------------------------------------------------------------
 *
 * Easy3D is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License Version 3
 * as published by the Free Software Foundation.
 *
 * Easy3D is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 ********************************************************************/
 
#ifndef EASY3D_QT_VIEWER_H
#define EASY3D_QT_VIEWER_H
 
#include <easy3d/core/types.h>
 
#include <QOpenGLWidget>
#include <QOpenGLFunctions>
#include <QElapsedTimer>
 
 
class QWidget;
 
namespace easy3d {
 
    class Camera;
    class Model;
    class Drawable;
    class TrianglesDrawable;
    class TextRenderer;
 
    class Viewer : public QOpenGLWidget, public QOpenGLFunctions {
    Q_OBJECT
    public:
        explicit Viewer(QWidget *parent = nullptr);
        ~Viewer() override;
 
        virtual std::string usage() const;
 
        // the actual samples received
        int samples() const { return samples_; }
        // Scaling factor for high DPI devices
        float dpiScaling() const { return dpi_scaling_; }
 
        const easy3d::vec4 &backGroundColor() const { return background_color_; }
        void setBackgroundColor(const easy3d::vec4 &c);
 
        void addModel(easy3d::Model *model);
        void deleteModel(easy3d::Model *model);
 
        const std::vector<easy3d::Model *> &models() const { return models_; }
        easy3d::Model *currentModel() const;

        bool addDrawable(Drawable* drawable);
        bool deleteDrawable(Drawable* drawable);
        const std::vector<Drawable*>& drawables() const { return drawables_; }
 
        // the camera
        easy3d::Camera *camera() const { return camera_; }
 
        // moves the camera so that the 'model' is centered on the screen.
        // if 'model' is NULL, it centers the entire scene (all models).
        void fitScreen(const easy3d::Model *model = nullptr);
 
        // Returns the coordinates of the 3D point located at pixel (x,y) on screen.
        // x, y: screen point expressed in pixel units with an origin in the upper left corner.
        // found: indicates whether a point was found or not.
        // NOTE: This method assumes that a GL context is available, and that its
        //       content was drawn using the Camera (i.e. using its projection and modelview
        //       matrices). This method hence cannot be used for offscreen Camera computations.
        //       Use cameraCoordinatesOf() and worldCoordinatesOf() to perform similar
        //       operations in that case.
        //       The precision of the z-Buffer highly depends on how the zNear() and zFar()
        //       values are fitted to your scene. Loose boundaries will result in imprecision
        //       along the viewing direction.
        easy3d::vec3 pointUnderPixel(const QPoint &p, bool &found);
 
        // Save snapshot
        // file_name: the image file name
        bool saveSnapshot(const QString &file_name);
 
    protected:
 
        /* Set up required OpenGL resources/state and then calls user-defined init().
         * This method is called once before the first call to paintGL() or resizeGL().
         * Note:
         *  - Overload init() instead of this method to modify specific OpenGL state;
         *  - The framebuffer is not yet available at this stage.
         */
        void initializeGL() override;
 
        /* User-defined initialization method.
         * This method is called within initializeGL() and should be overloaded to
         * initialize OpenGL flags/resources, e.g.,
         *  - OpenGL state modification;
         *  - shader program/texture/VAOs creation;
         *  - camera initialization;
         *  - previous viewer state restoration;
         *  - ...
         * All OpenGL specific initializations must be done in this method.
         * OpenGL context is not yet available in your viewer constructor.
         * NOTE:
         *  - If you derive you own viewer from this class, don't forget to call
         *    Viewer::init() at the beginning of your inherited function.
         *  - Do not call updateGL() in this method (resulting in an infinite loop).
         */
        virtual void init();
 
        /* Sets up the OpenGL viewport, projection, etc. Gets called whenever the
         * widget has been resized (and also when it is shown for the first time
         * because all newly created widgets get a resize event automatically).
         * If you overload this method, first call the inherited method in which
         * the projection matrix is updated.
         */
        void resizeGL(int width, int height) override;
 
        /* Renders the OpenGL scene. Gets called whenever the widget needs to
         * be updated. Internally, it calls the following methods in order:
         *  - preDraw(): places the camera in the world coordinate system;
         *  - draw(): main drawing method. Should be overloaded.
         *  - postDraw(): display of visual hints (world axis, FPS...)
         * Note: For normal rendering, i.e., drawing triggered by the
         *       paintEvent(), the clearing of the color and depth buffers is
         *       done by the widget before entering paintGL(). However, if you
         *       want to reuse the paintGL() method for offscreen rendering,
         *       you have to clear both buffers before calling paintGL().
         */
        void paintGL() override;
 
        /* This function will be called before the main draw procedure.
         */
        virtual void preDraw();
 
        /* The core method of the viewer, that draws the scene.
         */
        virtual void draw();
 
        /* Called after draw() to draw viewer visual hints.
         * By default, it displays axis and visual hints if the respective flags are set.
         */
        virtual void postDraw();
 
        // OpenGL resources (e.g., shaders, textures, VAOs) can only be destroyed when there exists a valid
        // rendering context. It is (usually) a bad idea to clean up OpenGL in a destructor because the OpenGL
        // context may not exist (e.g., destroyed already) or the visible one is not *current*. This cleanup()
        // function is to ensure you have a valid rendering context. See also init().
        // NOTE: Don't forget to call Viewer::cleanup() at the end of your inherited function.
        void cleanup();
 
    protected:
        void mousePressEvent(QMouseEvent *) override;    // Mouse button press event handler
        void mouseMoveEvent(QMouseEvent *) override;
 
        void mouseReleaseEvent(QMouseEvent *) override;  // Mouse button release event handler
        void mouseDoubleClickEvent(QMouseEvent *) override;
 
        void wheelEvent(QWheelEvent *) override;         // Mouse scroll event handler
        void keyPressEvent(QKeyEvent *) override;        // Keyboard press event handler.
        void keyReleaseEvent(QKeyEvent *) override;      // Keyboard press event handler.
        void timerEvent(QTimerEvent *) override;
 
        void closeEvent(QCloseEvent *) override;
 
    protected:
 
        void drawCornerAxes();
 
    signals:
 
        void currentModelChanged();
 
    protected:
        float dpi_scaling_;
        int samples_;
 
        QElapsedTimer timer_;
        easy3d::TextRenderer *texter_;
 
        easy3d::Camera *camera_;
        easy3d::vec4 background_color_;
 
        Qt::MouseButton pressed_button_;
        QPoint mouse_pressed_pos_;
        QPoint mouse_previous_pos_;
 
        bool show_pivot_point_;
 
        //----------------- viewer data -------------------
 
        // corner axes
        easy3d::TrianglesDrawable *drawable_axes_;
        std::vector<easy3d::Model *> models_;
        int model_idx_;
 
        // drawables independent of any model
        std::vector<Drawable*> drawables_;
    };
 
}
 
#endif // EASY3D_QT_VIEWER_H

The source file of the viewer class:

/********************************************************************
 * Copyright (C) 2015 Liangliang Nan <liangliang.nan@gmail.com>
 * https://3d.bk.tudelft.nl/liangliang/
 *
 * This file is part of Easy3D. If it is useful in your research/work,
 * I would be grateful if you show your appreciation by citing it:
 * ------------------------------------------------------------------
 *      Liangliang Nan.
 *      Easy3D: a lightweight, easy-to-use, and efficient C++ library
 *      for processing and rendering 3D data.
 *      Journal of Open Source Software, 6(64), 3255, 2021.
 * ------------------------------------------------------------------
 *
 * Easy3D is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License Version 3
 * as published by the Free Software Foundation.
 *
 * Easy3D is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 ********************************************************************/
 
#include "viewer.h"
 
#include <QKeyEvent>
#include <QPainter>
#include <QOpenGLContext>
#include <QOpenGLFunctions>
#include <QOpenGLFramebufferObjectFormat>
#include <QApplication>
 
#include <easy3d/core/surface_mesh.h>
#include <easy3d/core/point_cloud.h>
#include <easy3d/core/graph.h>
#include <easy3d/renderer/drawable_points.h>
#include <easy3d/renderer/drawable_lines.h>
#include <easy3d/renderer/drawable_triangles.h>
#include <easy3d/renderer/shader_program.h>
#include <easy3d/renderer/shader_manager.h>
#include <easy3d/renderer/shape.h>
#include <easy3d/renderer/transform.h>
#include <easy3d/renderer/camera.h>
#include <easy3d/renderer/manipulated_camera_frame.h>
#include <easy3d/renderer/key_frame_interpolator.h>
#include <easy3d/renderer/opengl_util.h>
#include <easy3d/renderer/opengl_error.h>
#include <easy3d/renderer/texture_manager.h>
#include <easy3d/renderer/text_renderer.h>
#include <easy3d/renderer/renderer.h>
#include <easy3d/util/resource.h>
#include <easy3d/fileio/surface_mesh_io.h>
#include <easy3d/util/logging.h>
#include <easy3d/util/file_system.h>
#include <easy3d/util/setting.h>
 
 
namespace easy3d {
 
    // \cond
 
    Viewer::Viewer(QWidget *parent /* = nullptr*/)
            : QOpenGLWidget(parent), texter_(nullptr), pressed_button_(Qt::NoButton),
              mouse_pressed_pos_(0, 0), mouse_previous_pos_(0, 0), show_pivot_point_(false), drawable_axes_(nullptr),
              model_idx_(-1) {
        // like Qt::StrongFocus plus the widget accepts focus by using the mouse wheel.
        setFocusPolicy(Qt::WheelFocus);
        setMouseTracking(true);
 
        camera_ = new Camera;
        camera_->setType(Camera::PERSPECTIVE);
        camera_->setUpVector(vec3(0, 0, 1)); // Z pointing up
        camera_->setViewDirection(vec3(-1, 0, 0)); // X pointing out
        camera_->showEntireScene();
 
        easy3d::connect(&camera_->frame_modified, this, static_cast<void (Viewer::*)(void)>(&Viewer::update));
    }
 
 
    Viewer::~Viewer() {
        // Make sure the context is current and then explicitly
        // destroy all underlying OpenGL resources.
        makeCurrent();
 
        cleanup();
 
        doneCurrent();
 
        LOG(INFO) << "viewer terminated. Bye!";
    }
 
 
    void Viewer::cleanup() {
        delete camera_;
        delete drawable_axes_;
        delete texter_;
 
        for (auto m: models_)
            delete m;
        models_.clear();
 
        for (auto d : drawables_)
            delete d;
        drawables_.clear();
 
        ShaderManager::terminate();
        TextureManager::terminate();
    }
 
 
    void Viewer::init() {
        const std::string file_name = resource::directory() + "/data/easy3d.ply";
        auto mesh = SurfaceMeshIO::load(file_name);
        if (mesh)
            addModel(mesh);
 
        // We always want to look at the front of the easy3d logo.
        camera()->setViewDirection(vec3(0, 0, -1));
        camera()->setUpVector(vec3(0, 1, 0));
        fitScreen(mesh);
    }
 
 
    void Viewer::initializeGL() {
        QOpenGLWidget::initializeGL();
        initializeOpenGLFunctions();
 
        OpenglUtil::init();
#ifndef NDEBUG
        opengl::setup_gl_debug_callback();
#endif
 
        if (!hasOpenGLFeature(QOpenGLFunctions::Multisample))
            throw std::runtime_error("Multisample not supported on this machine!!! Viewer may not run properly");
        if (!hasOpenGLFeature(QOpenGLFunctions::Framebuffers))
            throw std::runtime_error(
                    "Framebuffer Object is not supported on this machine!!! Viewer may not run properly");
 
        background_color_ = setting::background_color;
 
        glEnable(GL_DEPTH_TEST);
        glClearDepthf(1.0f);
        glClearColor(background_color_[0], background_color_[1], background_color_[2], background_color_[3]);
 
        int major_requested = QSurfaceFormat::defaultFormat().majorVersion();
        int minor_requested = QSurfaceFormat::defaultFormat().minorVersion();
        VLOG(1) << "OpenGL vendor: " << glGetString(GL_VENDOR);
        VLOG(1) << "OpenGL renderer: " << glGetString(GL_RENDERER);
        VLOG(1) << "OpenGL version requested: " << major_requested << "." << minor_requested;
        VLOG(1) << "OpenGL version received: " << glGetString(GL_VERSION);
        VLOG(1) << "GLSL version received: " << glGetString(GL_SHADING_LANGUAGE_VERSION);
 
        int major = 0;
        glGetIntegerv(GL_MAJOR_VERSION, &major);
        int minor = 0;
        glGetIntegerv(GL_MINOR_VERSION, &minor);
        if (major * 10 + minor < 32) {
            throw std::runtime_error("Viewer requires at least OpenGL 3.2");
        }
 
#if (QT_VERSION >= QT_VERSION_CHECK(5, 6, 0))
        dpi_scaling_ = static_cast<float>(devicePixelRatioF());
#else
        dpi_scaling_ = static_cast<float>(devicePixelRatio());
#endif
        VLOG(1) << "DPI scaling: " << dpiScaling();
 
        // This won't work because QOpenGLWidget draws everything in framebuffer and
        // the framebuffer has not been created in the initializeGL() method. We
        // will query the actual samples in the paintGL() method.
        //int samples_received = 0;
        //func_->glgetintegerv(gl_samples, &samples_received);
 
        // create TextRenderer renderer and load default fonts
        texter_ = new TextRenderer(dpiScaling());
        texter_->add_font(resource::directory() + "/fonts/en_Earth-Normal.ttf");
        texter_->add_font(resource::directory() + "/fonts/en_Roboto-Medium.ttf");
 
        // Calls user defined method.
        init();
 
        // print usage
        std::cout << usage() << std::endl;
 
        timer_.start();
    }
 
 
    void Viewer::resizeGL(int w, int h) {
        QOpenGLWidget::resizeGL(w, h);
 
        // The viewport is set up by QOpenGLWidget before drawing.
        // So I don't need to set up.
        // func_->glViewport(0, 0, static_cast<int>(w * highdpi_), static_cast<int>(h * highdpi_));
 
        camera()->setScreenWidthAndHeight(w, h);
    }
 
 
    void Viewer::setBackgroundColor(const vec4 &c) {
        background_color_ = c;
 
        makeCurrent();
        glClearColor(background_color_[0], background_color_[1], background_color_[2], background_color_[3]);
        doneCurrent();
    }
 
 
    void Viewer::mousePressEvent(QMouseEvent *e) {
        pressed_button_ = e->button();
        mouse_previous_pos_ = e->pos();
        mouse_pressed_pos_ = e->pos();
 
        camera_->frame()->action_start();
        if (e->modifiers() == Qt::ShiftModifier) {
            if (e->button() == Qt::LeftButton) {
                bool found = false;
                const vec3 &p = pointUnderPixel(e->pos(), found);
                if (found) {
                    camera()->interpolateToLookAt(p);
                    camera_->setPivotPoint(p);
 
                    // show, but hide the visual hint of pivot point after \p delay milliseconds.
                    show_pivot_point_ = true;
                    Timer<>::single_shot(10000, [&]() {
                        show_pivot_point_ = false;
                        update();
                    });
                } else {
                    camera_->setPivotPoint(camera_->sceneCenter());
                    show_pivot_point_ = false;
                }
            } else if (e->button() == Qt::RightButton) {
                camera()->interpolateToFitScene();
                camera_->setPivotPoint(camera_->sceneCenter());
                show_pivot_point_ = false;
            }
        }
 
        QOpenGLWidget::mousePressEvent(e);
        update();
    }
 
 
    void Viewer::mouseReleaseEvent(QMouseEvent *e) {
        if (e->button() == Qt::LeftButton && e->modifiers() == Qt::ControlModifier) { // ZOOM_ON_REGION
            int xmin = std::min(mouse_pressed_pos_.x(), e->pos().x());
            int xmax = std::max(mouse_pressed_pos_.x(), e->pos().x());
            int ymin = std::min(mouse_pressed_pos_.y(), e->pos().y());
            int ymax = std::max(mouse_pressed_pos_.y(), e->pos().y());
            camera_->fitScreenRegion(xmin, ymin, xmax, ymax);
        } else
            camera_->frame()->action_end();
 
        pressed_button_ = Qt::NoButton;
        mouse_pressed_pos_ = QPoint(0, 0);
 
        QOpenGLWidget::mouseReleaseEvent(e);
        update();
    }
 
 
    void Viewer::mouseMoveEvent(QMouseEvent *e) {
        int x = e->pos().x(), y = e->pos().y();
        // Restrict the cursor to be within the client area during dragging
        if (x < 0 || x > width() || y < 0 || y > height()) {
            e->ignore();
            return;
        }
 
        if (pressed_button_ != Qt::NoButton) { // button pressed
            if (e->modifiers() == Qt::ControlModifier) {
                // zoom on region
            } else {
                int dx = x - mouse_previous_pos_.x();
                int dy = y - mouse_previous_pos_.y();
                if (pressed_button_ == Qt::LeftButton)
                    camera_->frame()->action_rotate(x, y, dx, dy, camera_, ManipulatedFrame::NONE);
                else if (pressed_button_ == Qt::RightButton)
                    camera_->frame()->action_translate(x, y, dx, dy, camera_, ManipulatedFrame::NONE);
                else if (pressed_button_ == Qt::MiddleButton) {
                    if (dy != 0)
                        camera_->frame()->action_zoom(dy > 0 ? 1 : -1, camera_);
                }
            }
        }
 
        mouse_previous_pos_ = e->pos();
        QOpenGLWidget::mouseMoveEvent(e);
    }
 
 
    void Viewer::mouseDoubleClickEvent(QMouseEvent *e) {
        QOpenGLWidget::mouseDoubleClickEvent(e);
        update();
    }
 
 
    void Viewer::wheelEvent(QWheelEvent *e) {
        const int delta = e->angleDelta().y();
        if (delta <= -1 || delta >= 1) {
            int dy = e->angleDelta().y() > 0 ? 1 : -1;
            camera_->frame()->action_zoom(dy, camera_);
        }
 
        QOpenGLWidget::wheelEvent(e);
        update();
    }
 
 
    bool Viewer::saveSnapshot(const QString &file_name) {
        makeCurrent();
 
        int w = static_cast<int>(static_cast<float>(width()) * dpiScaling());
        int h = static_cast<int>(static_cast<float>(height()) * dpiScaling());
 
        QOpenGLFramebufferObjectFormat format;
        format.setAttachment(QOpenGLFramebufferObject::CombinedDepthStencil);
        format.setSamples(4);
        auto fbo = new QOpenGLFramebufferObject(w, h, format);
        fbo->addColorAttachment(w, h);
 
        fbo->bind();
        glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
 
        draw();
 
        fbo->release();
 
        const QImage &image = fbo->toImage();
 
        // restore the clear color
        glClearColor(background_color_[0], background_color_[1], background_color_[2], background_color_[3]);
 
        doneCurrent();
 
        return image.save(file_name);
    }
 
 
    Model *Viewer::currentModel() const {
        if (models_.empty())
            return nullptr;
        if (model_idx_ < models_.size())
            return models_[model_idx_];
        return nullptr;
    }
 
    void Viewer::keyPressEvent(QKeyEvent *e) {
        if (e->key() == Qt::Key_F1 && e->modifiers() == Qt::NoModifier)
            std::cout << usage() << std::endl;
        else if (e->key() == Qt::Key_Left && e->modifiers() == Qt::KeypadModifier) {
            auto angle = static_cast<float>(1 * M_PI / 180.0); // turn left, 1 degrees each step
            camera_->frame()->action_turn(angle, camera_);
        } else if (e->key() == Qt::Key_Right && e->modifiers() == Qt::KeypadModifier) {
            auto angle = static_cast<float>(1 * M_PI / 180.0); // turn right, 1 degrees each step
            camera_->frame()->action_turn(-angle, camera_);
        } else if (e->key() == Qt::Key_Up && e->modifiers() == Qt::KeypadModifier) {    // move camera forward
            float step = 0.05f * camera_->sceneRadius();
            camera_->frame()->translate(camera_->frame()->inverseTransformOf(vec3(0.0, 0.0, -step)));
        } else if (e->key() == Qt::Key_Down && e->modifiers() == Qt::KeypadModifier) {// move camera backward
            float step = 0.05f * camera_->sceneRadius();
            camera_->frame()->translate(camera_->frame()->inverseTransformOf(vec3(0.0, 0.0, step)));
        } else if (e->key() == Qt::Key_Left &&
                   e->modifiers() == (Qt::KeypadModifier | Qt::ControlModifier)) {    // move camera left
            float step = 0.05f * camera_->sceneRadius();
            camera_->frame()->translate(camera_->frame()->inverseTransformOf(vec3(-step, 0.0, 0.0)));
        } else if (e->key() == Qt::Key_Right &&
                   e->modifiers() == (Qt::KeypadModifier | Qt::ControlModifier)) {    // move camera right
            float step = 0.05f * camera_->sceneRadius();
            camera_->frame()->translate(camera_->frame()->inverseTransformOf(vec3(step, 0.0, 0.0)));
        } else if (e->key() == Qt::Key_Up &&
                   e->modifiers() == (Qt::KeypadModifier | Qt::ControlModifier)) {    // move camera up
            float step = 0.05f * camera_->sceneRadius();
            camera_->frame()->translate(camera_->frame()->inverseTransformOf(vec3(0.0, step, 0.0)));
        } else if (e->key() == Qt::Key_Down &&
                   e->modifiers() == (Qt::KeypadModifier | Qt::ControlModifier)) {    // move camera down
            float step = 0.05f * camera_->sceneRadius();
            camera_->frame()->translate(camera_->frame()->inverseTransformOf(vec3(0.0, -step, 0.0)));
        } else if (e->key() == Qt::Key_A && e->modifiers() == Qt::NoModifier) {
            if (drawable_axes_)
                drawable_axes_->set_visible(!drawable_axes_->is_visible());
        } else if (e->key() == Qt::Key_C && e->modifiers() == Qt::NoModifier) {
            if (currentModel())
                fitScreen(currentModel());
        } else if (e->key() == Qt::Key_F && e->modifiers() == Qt::NoModifier) {
            fitScreen();
        } else if (e->key() == Qt::Key_P && e->modifiers() == Qt::NoModifier) {
            if (camera_->type() == Camera::PERSPECTIVE)
                camera_->setType(Camera::ORTHOGRAPHIC);
            else
                camera_->setType(Camera::PERSPECTIVE);
        } else if (e->key() == Qt::Key_Space && e->modifiers() == Qt::NoModifier) {
            // Aligns camera
            Frame frame;
            frame.setTranslation(camera_->pivotPoint());
            camera_->frame()->alignWithFrame(&frame, true);
 
            // Aligns frame
            //if (manipulatedFrame())
            //  manipulatedFrame()->alignWithFrame(camera_->frame());
        } else if (e->key() == Qt::Key_Minus && e->modifiers() == Qt::ControlModifier)
            camera_->frame()->action_zoom(-1, camera_);
        else if (e->key() == Qt::Key_Equal && e->modifiers() == Qt::ControlModifier)
            camera_->frame()->action_zoom(1, camera_);
 
        else if (e->key() == Qt::Key_K && e->modifiers() == Qt::AltModifier) { // add key frame
            easy3d::Frame *frame = camera()->frame();
            camera()->keyframe_interpolator()->add_keyframe(*frame);
            // update scene bounding box to make sure the path is within the view frustum
            float old_radius = camera()->sceneRadius();
            float candidate_radius = distance(camera()->sceneCenter(), frame->position());
            camera()->setSceneRadius(std::max(old_radius, candidate_radius));
        } else if (e->key() == Qt::Key_D && e->modifiers() == Qt::ControlModifier) { // delete path
            camera()->keyframe_interpolator()->delete_path();
 
            // update scene bounding box
            Box3 box;
            for (auto m: models_)
                box.grow(m->bounding_box());
            camera_->setSceneBoundingBox(box.min_point(), box.max_point());
        } else if (e->key() == Qt::Key_K && e->modifiers() == Qt::ControlModifier) { // play the path
            if (camera()->keyframe_interpolator()->is_interpolation_started())
                camera()->keyframe_interpolator()->stop_interpolation();
            else
                camera()->keyframe_interpolator()->start_interpolation();
        } else if (e->key() == Qt::Key_BracketLeft && e->modifiers() == Qt::NoModifier) {
            for (auto m: models_) {
                for (auto d: m->renderer()->lines_drawables()) {
                    float size = d->line_width() - 1.0f;
                    if (size < 1)
                        size = 1;
                    d->set_line_width(size);
                }
            }
        } else if (e->key() == Qt::Key_BracketRight && e->modifiers() == Qt::NoModifier) {
            for (auto m: models_) {
                for (auto d: m->renderer()->lines_drawables()) {
                    float size = d->line_width() + 1.0f;
                    d->set_line_width(size);
                }
            }
        } else if (e->key() == Qt::Key_Minus && e->modifiers() == Qt::NoModifier) {
            for (auto m: models_) {
                for (auto d: m->renderer()->points_drawables()) {
                    float size = d->point_size() - 1.0f;
                    if (size < 1)
                        size = 1;
                    d->set_point_size(size);
                }
            }
        } else if (e->key() == Qt::Key_Equal && e->modifiers() == Qt::NoModifier) {
            for (auto m: models_) {
                for (auto d: m->renderer()->points_drawables()) {
                    float size = d->point_size() + 1.0f;
                    d->set_point_size(size);
                }
            }
        } else if (e->key() == Qt::Key_Comma && e->modifiers() == Qt::NoModifier) {
            int pre_idx = model_idx_;
            if (models_.empty())
                model_idx_ = -1;
            else
                model_idx_ = int((model_idx_ - 1 + models_.size()) % models_.size());
            if (model_idx_ != pre_idx) {
                if (model_idx_ >= 0)
                    LOG(INFO) << "current model: " << model_idx_ << ", " << models_[model_idx_]->name();
            }
        } else if (e->key() == Qt::Key_Period && e->modifiers() == Qt::NoModifier) {
            int pre_idx = model_idx_;
            if (models_.empty())
                model_idx_ = -1;
            else
                model_idx_ = int((model_idx_ + 1) % models_.size());
            if (model_idx_ != pre_idx) {
                if (model_idx_ >= 0)
                    LOG(INFO) << "current model: " << model_idx_ << ", " << models_[model_idx_]->name();
            }
        } else if (e->key() == Qt::Key_Delete && e->modifiers() == Qt::NoModifier) {
            if (currentModel())
                deleteModel(currentModel());
        } else if (e->key() == Qt::Key_E && e->modifiers() == Qt::NoModifier) {
            if (currentModel()) {
                auto *drawable = currentModel()->renderer()->get_lines_drawable("edges");
                if (drawable)
                    drawable->set_visible(!drawable->is_visible());
            }
        } else if (e->key() == Qt::Key_V && e->modifiers() == Qt::NoModifier) {
            if (currentModel()) {
                auto drawable = currentModel()->renderer()->get_points_drawable("vertices");
                if (drawable)
                    drawable->set_visible(!drawable->is_visible());
            }
        } else if (e->key() == Qt::Key_B && e->modifiers() == Qt::NoModifier) {
            auto mesh = dynamic_cast<SurfaceMesh *>(currentModel());
            if (mesh) {
                auto drawable = mesh->renderer()->get_lines_drawable("borders");
                if (drawable)
                    drawable->set_visible(!drawable->is_visible());
            }
        } else if (e->key() == Qt::Key_L && e->modifiers() == Qt::NoModifier) { // locked vertices
            auto mesh = dynamic_cast<SurfaceMesh *>(currentModel());
            if (mesh) {
                auto drawable = mesh->renderer()->get_points_drawable("locks");
                if (drawable)
                    drawable->set_visible(!drawable->is_visible());
            }
        } else if (e->key() == Qt::Key_M && e->modifiers() == Qt::NoModifier) {
            if (dynamic_cast<SurfaceMesh *>(currentModel())) {
                auto drawable = currentModel()->renderer()->get_triangles_drawable("faces");
                if (drawable) {
                    drawable->set_smooth_shading(!drawable->smooth_shading());
                }
            }
        } else if (e->key() == Qt::Key_D && e->modifiers() == Qt::NoModifier) {
            if (currentModel()) {
                std::ostream &output = std::cout;
 
                output << "----------- " << file_system::simple_name(currentModel()->name()) << " -----------\n";
                if (dynamic_cast<SurfaceMesh *>(currentModel())) {
                    auto model = dynamic_cast<SurfaceMesh *>(currentModel());
                    output << "model is a surface mesh. #face: " << std::to_string(model->n_faces())
                           << ", #vertex: " + std::to_string(model->n_vertices())
                           << ", #edge: " + std::to_string(model->n_edges()) << std::endl;
                } else if (dynamic_cast<PointCloud *>(currentModel())) {
                    auto model = dynamic_cast<PointCloud *>(currentModel());
                    output << "model is a point cloud. #vertex: " + std::to_string(model->n_vertices()) << std::endl;
                } else if (dynamic_cast<Graph *>(currentModel())) {
                    auto model = dynamic_cast<Graph *>(currentModel());
                    output << "model is a graph. #vertex: " + std::to_string(model->n_vertices())
                           << ", #edge: " + std::to_string(model->n_edges()) << std::endl;
                }
 
                if (!currentModel()->renderer()->points_drawables().empty()) {
                    output << "points drawables:\n";
                    for (auto d: currentModel()->renderer()->points_drawables())
                        d->buffer_stats(output);
                }
                if (!currentModel()->renderer()->lines_drawables().empty()) {
                    output << "lines drawables:\n";
                    for (auto d: currentModel()->renderer()->lines_drawables())
                        d->buffer_stats(output);
                }
                if (!currentModel()->renderer()->triangles_drawables().empty()) {
                    output << "triangles drawables:\n";
                    for (auto d: currentModel()->renderer()->triangles_drawables())
                        d->buffer_stats(output);
                }
 
                currentModel()->property_stats(output);
            }
        } else if (e->key() == Qt::Key_R && e->modifiers() == Qt::NoModifier) {
            // Reload the shader(s) - useful for writing/debugging shader code.
            ShaderManager::reload();
        }
 
        QOpenGLWidget::keyPressEvent(e);
        update();
    }
 
 
    void Viewer::keyReleaseEvent(QKeyEvent *e) {
        QOpenGLWidget::keyReleaseEvent(e);
        update();
    }
 
 
    void Viewer::timerEvent(QTimerEvent *e) {
        QOpenGLWidget::timerEvent(e);
        update();
    }
 
 
    void Viewer::closeEvent(QCloseEvent *e) {
        cleanup();
        QOpenGLWidget::closeEvent(e);
    }
 
 
    std::string Viewer::usage() const {
        return  " ------------------------------------------------------------------\n"
                " Easy3D viewer usage:                                              \n"
                " ------------------------------------------------------------------\n"
                "  F1:                  Help                                        \n"
                " ------------------------------------------------------------------\n"
                "  Ctrl + 'o':          Open file                                   \n"
                "  Ctrl + 's':          Save file                                   \n"
                "  Fn + Delete:         Delete current model                        \n"
                "  '<' or '>':          Switch between models                       \n"
                "  's':                 Snapshot                                    \n"
                " ------------------------------------------------------------------\n"
                "  'p':                 Toggle perspective/orthographic projection) \n"
                "  Left:                Orbit-rotate the camera                     \n"
                "  Right:               Move up/down/left/right                     \n"
                "  Middle or Wheel:     Zoom in/out                                 \n"
                "  Ctrl + '+'/'-':      Zoom in/out                                 \n"
                "  Alt + Left:          Orbit-rotate the camera (screen based)      \n"
                "  Alt + Right:         Move up/down/left/right (screen based)      \n"
                "  Left/Right           Turn camera left/right                      \n"
                "  Ctrl + Left/Right:   Move camera left/right                      \n"
                "  Up/Down:             Move camera forward/backward                \n"
                "  Ctrl + Up/Down:      Move camera up/down                         \n"
                " ------------------------------------------------------------------\n"
                "  'f':                 Fit screen (all models)                     \n"
                "  'c':                 Fit screen (current model only)             \n"
                "  Shift + Left/Right:  Zoom to target/Zoom to fit screen           \n"
                " ------------------------------------------------------------------\n"
                "  '+'/'-':             Increase/Decrease point size (line width)   \n"
                "  'a':                 Toggle axes                                 \n"
                "  'b':                 Toggle borders                              \n"
                "  'e':                 Toggle edges                                \n"
                "  'v':                 Toggle vertices                             \n"
                "  'm':                 Toggle smooth shading (for SurfaceMesh)     \n"
                "  'd':                 Print model info (drawables, properties)    \n"
                " ------------------------------------------------------------------\n";
    }
 
 
    void Viewer::addModel(Model *model) {
        if (!model) {
            LOG(WARNING) << "model is nullptr";
            return;
        }
        for (auto m: models_) {
            if (model == m) {
                LOG(WARNING) << "model has already been added to the viewer.";
                return;
            }
        }
 
        if (model->empty()) {
            LOG(WARNING) << "model does not have vertices. Only complete model can be added to the viewer.";
            return;
        }
 
        makeCurrent();
        model->set_renderer(std::make_shared<Renderer>(model));
        doneCurrent();
 
        int pre_idx = model_idx_;
        models_.push_back(model);
        model_idx_ = static_cast<int>(models_.size()) - 1; // make the last one current
 
        if (model_idx_ != pre_idx) {
            emit currentModelChanged();
            if (model_idx_ >= 0)
                LOG(INFO) << "current model: " << model_idx_ << ", " << models_[model_idx_]->name();
        }
    }
 
 
    void Viewer::deleteModel(Model *model) {
        if (!model) {
            LOG(WARNING) << "model is nullptr";
            return;
        }
 
        int pre_idx = model_idx_;
        auto pos = std::find(models_.begin(), models_.end(), model);
        if (pos != models_.end()) {
            const std::string name = model->name();
            models_.erase(pos);
            makeCurrent();  // make sure the context is current
            delete model;   // internally the renderer and manipulator will be deleted
            doneCurrent();
            model_idx_ = static_cast<int>(models_.size()) - 1; // make the last one current
 
            std::cout << "model deleted: " << name << std::endl;
        } else
            LOG(WARNING) << "no such model: " << model->name();
 
        if (model_idx_ != pre_idx) {
            emit currentModelChanged();
            if (model_idx_ >= 0)
                LOG(INFO) << "current model: " << model_idx_ << ", " << models_[model_idx_]->name();
        }
    }
 
 
    bool Viewer::addDrawable(Drawable *drawable) {
        if (!drawable) {
            LOG(WARNING) << "drawable is nullptr";
            return false;
        }
        for (auto d : drawables_) {
            if (drawable == d) {
                LOG(WARNING) << "drawable has already been added to the viewer.";
                return false;
            }
        }
 
        drawables_.push_back(drawable);
        return true;
    }
 
 
    bool Viewer::deleteDrawable(Drawable *drawable) {
        if (!drawable) {
            LOG(WARNING) << "drawable is nullptr";
            return false;
        }
 
        for (auto it = drawables_.begin(); it != drawables_.end(); ++it) {
            if (*it == drawable) {
                delete drawable;
                drawables_.erase(it);
                return true;
            }
        }
 
        // if the drawable was not found
        LOG(WARNING) << "no such drawable: " << drawable->name();
        return false;
    }
 
 
    void Viewer::fitScreen(const Model *model) {
        if (!model && models_.empty() && drawables_.empty()) 
            return;
 
        Box3 box;
        if (model)
            box = model->bounding_box();
        else {
            for (auto m: models_)
                box.grow(m->bounding_box());
            for (auto d : drawables_)
                box.grow(d->bounding_box());
        }
        camera_->setSceneBoundingBox(box.min_point(), box.max_point());
        camera_->showEntireScene();
        update();
    }
 
 
    vec3 Viewer::pointUnderPixel(const QPoint &p, bool &found) {
    // Liangliang: Qt6's QOpenGLWidget implementation is a black box. Using glReadPixels to read the depth buffer
    //      outside the paintGL() function has some undefined behaviors, even I made sure the context is made
    //      current and the defaultFramebufferObject() is bound. Below is what I observed:
    //        - it works well on macOS and Ubuntu, but not on Windows; it works on all three platforms if Qt5 is used;
    //        - on Windows, it works if the glReadPixels is called within the paintGL() function;
    //        - on Windows, when the function is called outside paintGL(), if saving the obtained depth buffer to an
    //          image, only some edge(s) of the image show correct depth information, and the majority part of the
    //          depth image shows black and very sparse white pixels.
    //      I guess the reason might be:
    //        - Depth buffer clearing: on some platforms (e.g., Windows), the depth buffer may be cleared or invalidated
    //          when Qt performs post rendering operations (e.g., compositing).
    //        - Driver specific implementation: Windows drivers may optimize FBO usage differently, especially if
    //          rendering results are only needed for display. This could affect the depth buffer availability outside
    //          paintGL().
    //      These platform-specific behaviors are hard to resolve without fully understanding the source code of the
    //      QOpenGLWidget class. It is bad the Qt keeps such implementation private, and it may change over the time.
    //
    //      Solution: rendering into my own framebuffer object with only a depth attachment and then reading the depth
    //      values. This ensures we have full control over the depth buffer and avoids relying on the QOpenGLWidget's
    //      internal framebuffer.
 
    makeCurrent();
 
    int viewport[4];
    glGetIntegerv(GL_VIEWPORT, viewport);
    const int w = viewport[2];
    const int h = viewport[3];
 
    // Create an FBO with a depth attachment
    QOpenGLFramebufferObjectFormat format;
    format.setAttachment(QOpenGLFramebufferObject::Depth);
    format.setSamples(0); // No multisampling
    QOpenGLFramebufferObject fbo(w, h, format);
 
    // Bind the framebuffer
    fbo.bind();
    if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
        std::cerr << "Framebuffer is not complete!" << std::endl;
        return vec3(0, 0, 0);
    }
 
    // Configure OpenGL state for rendering
    GLboolean last_enable_depth_test = glIsEnabled(GL_DEPTH_TEST);
    if (!last_enable_depth_test)
        glEnable(GL_DEPTH_TEST);
    glClear(GL_DEPTH_BUFFER_BIT);
 
    // Render the scene
    draw();
 
    // Read the depth buffer
    // Qt (same as GLFW) uses upper corner for its origin while GL uses the lower corner.
    int glx = p.x();
    int gly = height() - 1 - p.y();
    // when dealing with OpenGL, all positions are relative to the viewer port. So we have to handle highdpi displays.
    glx = static_cast<int>(static_cast<float>(glx) * dpiScaling());
    gly = static_cast<int>(static_cast<float>(gly) * dpiScaling());
    float depth = std::numeric_limits<float>::max();
    glReadPixels(glx, gly, 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &depth);
 
    // Unbind the framebuffer
    fbo.release();
 
    // Restore previous depth test states
    if (!last_enable_depth_test)
        glDisable(GL_DEPTH_TEST);
 
    doneCurrent();
 
    found = depth < 1.0f;
    if (found) {
        // The input to unprojectedCoordinatesOf() is defined in the screen coordinate system
        return camera_->unprojectedCoordinatesOf(vec3(static_cast<float>(p.x()), static_cast<float>(p.y()), depth));
    }
 
    return {};
}
 
 
    void Viewer::paintGL() {
        easy3d_debug_log_gl_error
 
#if 1
        // QOpenGLWidget renders everything into an FBO. Internally it changes
        // QSurfaceFormat to always have samples = 0 and the OpenGL context is
        // not a multisample context. So we have to query the render-buffer
        // to know if it is using multisampling. At initializeGL() we were not
        // able to query the actual samples because the internal FBO has not
        // been created yet, so we do it here.
        static bool queried = false;
        if (!queried) {
#if 1
            glGetRenderbufferParameteriv(GL_RENDERBUFFER, GL_RENDERBUFFER_SAMPLES, &samples_);
            easy3d_debug_log_frame_buffer_error
#else   // the samples can also be retrieved using glGetIntegerv()
            glGetIntegerv(GL_SAMPLES, &samples_); easy3d_debug_log_gl_error
#endif
            // warn the user if the expected request was not satisfied
            int samples = QSurfaceFormat::defaultFormat().samples();
            int max_num = 0;
            glGetIntegerv(GL_MAX_SAMPLES, &max_num);
            if (samples > 0 && samples_ != samples) {
                if (samples_ == 0)
                    LOG(WARNING) << "MSAA is not available (" << samples << " samples requested)";
                else
                    LOG(WARNING) << "MSAA is available with " << samples_ << " samples (" << samples
                                 << " requested but max support is " << max_num << ")";
            } else VLOG(1) << "Samples received: " << samples_ << " (" << samples << " requested, max support is "
                           << max_num << ")";
 
            queried = true;
        }
#endif
 
        preDraw();
 
        draw();
 
        // Add visual hints: axis, camera, grid...
        postDraw();
    }
 
 
    void Viewer::drawCornerAxes() {
        ShaderProgram *program = ShaderManager::get_program("surface/surface");
        if (!program) {
            std::vector<ShaderProgram::Attribute> attributes;
            attributes.emplace_back(ShaderProgram::Attribute(ShaderProgram::POSITION, "vtx_position"));
            attributes.emplace_back(ShaderProgram::Attribute(ShaderProgram::TEXCOORD, "vtx_texcoord"));
            attributes.emplace_back(ShaderProgram::Attribute(ShaderProgram::COLOR, "vtx_color"));
            attributes.emplace_back(ShaderProgram::Attribute(ShaderProgram::NORMAL, "vtx_normal"));
            program = ShaderManager::create_program_from_files("surface/surface", attributes);
        }
        if (!program)
            return;
 
        if (!drawable_axes_) {
            const float base = 0.5f;   // the cylinder length, relative to the allowed region
            const float head = 0.2f;   // the cone length, relative to the allowed region
            std::vector<vec3> points, normals, colors;
            shape::create_cylinder(0.03, 10, vec3(0, 0, 0), vec3(base, 0, 0), vec3(1, 0, 0), points, normals, colors);
            shape::create_cylinder(0.03, 10, vec3(0, 0, 0), vec3(0, base, 0), vec3(0, 1, 0), points, normals, colors);
            shape::create_cylinder(0.03, 10, vec3(0, 0, 0), vec3(0, 0, base), vec3(0, 0, 1), points, normals, colors);
            shape::create_cone(0.06, 20, vec3(base, 0, 0), vec3(base + head, 0, 0), vec3(1, 0, 0), points, normals,
                                colors);
            shape::create_cone(0.06, 20, vec3(0, base, 0), vec3(0, base + head, 0), vec3(0, 1, 0), points, normals,
                                colors);
            shape::create_cone(0.06, 20, vec3(0, 0, base), vec3(0, 0, base + head), vec3(0, 0, 1), points, normals,
                                colors);
            shape::create_sphere(vec3(0, 0, 0), 0.06, 20, 20, vec3(0, 1, 1), points, normals, colors);
            drawable_axes_ = new TrianglesDrawable("corner_axes");
            drawable_axes_->update_vertex_buffer(points);
            drawable_axes_->update_normal_buffer(normals);
            drawable_axes_->update_color_buffer(colors);
            drawable_axes_->set_property_coloring(State::VERTEX);
        }
        if (!drawable_axes_->is_visible())
            return;
 
        // The viewport is changed to fit the lower left corner.
        int viewport[4];
        glGetIntegerv(GL_VIEWPORT, viewport);
 
        static const int corner_frame_size = static_cast<int>(100 * dpiScaling());
        glViewport(0, 0, corner_frame_size, corner_frame_size);
 
        // To make the axis appear over other objects: reserve a tiny bit of the
        // front depth range. NOTE: do remember to restore it later.
        glDepthRangef(0, 0.01f);
 
        const mat4 &proj = transform::ortho(-1, 1, -1, 1, -1, 1);
        const mat4 &view = camera_->orientation().inverse().matrix();
        const mat4 &MVP = proj * view;
 
        // camera position is defined in world coordinate system.
        const vec3 &wCamPos = camera_->position();
        // it can also be computed as follows:
        //const vec3& wCamPos = invMV * vec4(0, 0, 0, 1);
        const mat4 &MV = camera_->modelViewMatrix();
        const vec4 &wLightPos = inverse(MV) * setting::light_position;
 
        program->bind();
        program->set_uniform("MVP", MVP)
                ->set_uniform("MANIP", mat4::identity())
                ->set_uniform("NORMAL", mat3::identity())   // needs be padded when using uniform blocks
                ->set_uniform("lighting", true)
                ->set_uniform("two_sides_lighting", false)
                ->set_uniform("smooth_shading", true)
                ->set_uniform("wLightPos", wLightPos)
                ->set_uniform("wCamPos", wCamPos)
                ->set_uniform("ssaoEnabled", false)
                ->set_uniform("per_vertex_color", true)
                ->set_uniform("distinct_back_color", false)
                ->set_block_uniform("Material", "ambient", setting::material_ambient)
                ->set_block_uniform("Material", "specular", setting::material_specular)
                ->set_block_uniform("Material", "shininess", &setting::material_shininess)
                ->set_uniform("highlight", false)
                ->set_uniform("clippingPlaneEnabled", false)
                ->set_uniform("selected", false)
                ->set_uniform("highlight_color", setting::highlight_color)
                ->set_uniform("use_texture", false);
        drawable_axes_->gl_draw();
        program->release();
 
        // restore the viewport
        glViewport(viewport[0], viewport[1], viewport[2], viewport[3]);
        glDepthRangef(0.0f, 1.0f);
    }
 
 
    void Viewer::preDraw() {
        // The Qt6 documentation says (https://doc.qt.io/qt-6/qopenglwidget.html#paintGL):
        //      Default implementation performs a glClear(). Subclasses are not expected to invoke
        //      the base class implementation and should perform clearing on their own.
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
    }
 
 
    void Viewer::postDraw() {
        // draw the Easy3D logo and GPU time
        if (texter_ && texter_->num_fonts() >= 2) {
            const float font_size = 15.0f;
            const float offset = 20.0f * dpiScaling();
            texter_->draw("Easy3D", offset, offset, font_size, 0);
 
            // FPS computation
            static unsigned int fps_count = 0;
            static double fps = 0.0;
            static const unsigned int max_count = 40;
            static QString fps_string("fps: ??");
            if (++fps_count == max_count) {
                fps = 1000.0 * max_count / static_cast<double>(timer_.restart());
                fps_string = tr("fps: %1").arg(fps, 0, 'f', ((fps < 10.0) ? 1 : 0));
                fps_count = 0;
            }
            texter_->draw(fps_string.toStdString(), offset, 50.0f * dpiScaling(), 16, 1);
        }
 
        if (show_pivot_point_) {
            ShaderProgram *program = ShaderManager::get_program("lines/lines_plain_color");
            if (!program) {
                std::vector<ShaderProgram::Attribute> attributes;
                attributes.emplace_back(ShaderProgram::Attribute(ShaderProgram::POSITION, "vtx_position"));
                attributes.emplace_back(ShaderProgram::Attribute(ShaderProgram::COLOR, "vtx_color"));
                program = ShaderManager::create_program_from_files("lines/lines_plain_color", attributes);
            }
            if (!program)
                return;
 
            const float size = 10;
            LinesDrawable drawable("pivot_point");
            const vec3 &pivot = camera()->projectedCoordinatesOf(camera()->pivotPoint());
            std::vector<vec3> points = {
                    vec3(pivot.x - size, pivot.y, 0.5f), vec3(pivot.x + size, pivot.y, 0.5f),
                    vec3(pivot.x, pivot.y - size, 0.5f), vec3(pivot.x, pivot.y + size, 0.5f)
            };
            drawable.update_vertex_buffer(points);
 
            const mat4 &proj = transform::ortho(0.0f, static_cast<float>(width()), static_cast<float>(height()), 0.0f,
                                                0.0f,
                                                -1.0f);
            glDisable(GL_DEPTH_TEST);   // always on top
            program->bind();
            program->set_uniform("MVP", proj);
            program->set_uniform("per_vertex_color", false);
            program->set_uniform("default_color", vec4(0.0f, 0.0f, 1.0f, 1.0f));
            drawable.gl_draw();
            program->release();
            glEnable(GL_DEPTH_TEST);   // restore
        }
 
        drawCornerAxes();
    }
 
 
    void Viewer::draw() {
#if 0
        // Example code: split the view to have different rendering styles for the same object/scene.
        glEnable(GL_SCISSOR_TEST);
        int viewport[4];
        glGetIntegerv(GL_VIEWPORT, viewport);
        glScissor(viewport[0], viewport[1], viewport[2] * 0.5f, viewport[3]);
        for (const auto m : models_) {
            for (auto d : m->renderer()->triangles_drawables())
                d->draw(camera());
        }
        glScissor(viewport[2] * 0.5f, viewport[1], viewport[2] * 0.5f, viewport[3]);
        for (const auto m : models_) {
            for (auto d : m->renderer()->lines_drawables())
                d->draw(camera());
        }
        glScissor(viewport[0], viewport[1], viewport[2], viewport[3]);
 
#else 
 
        easy3d_debug_log_gl_error
 
        for (const auto m: models_) {
            if (!m->renderer()->is_visible())
                continue;
 
            // temporarily change the depth range and depth comparison method to properly render edges.
            glDepthRange(0.001, 1.0);
            for (auto d: m->renderer()->triangles_drawables()) {
                if (d->is_visible())
                    d->draw(camera());
                easy3d_debug_log_gl_error
            }
 
            glDepthRange(0.0, 1.0);
            glDepthFunc(GL_LEQUAL);
            for (auto d: m->renderer()->lines_drawables()) {
                if (d->is_visible())
                    d->draw(camera());
                easy3d_debug_log_gl_error
            }
            glDepthFunc(GL_LESS);
 
            for (auto d: m->renderer()->points_drawables()) {
                if (d->is_visible())
                    d->draw(camera());
                easy3d_debug_log_gl_error
            }
        }
 
        for (auto d : drawables_) {
            if (d->is_visible())
                d->draw(camera());
        }
#endif
    }
 
    // \endcond
 
}

The header file of the window class:

/********************************************************************
 * Copyright (C) 2015 Liangliang Nan <liangliang.nan@gmail.com>
 * https://3d.bk.tudelft.nl/liangliang/
 *
 * This file is part of Easy3D. If it is useful in your research/work,
 * I would be grateful if you show your appreciation by citing it:
 * ------------------------------------------------------------------
 *      Liangliang Nan.
 *      Easy3D: a lightweight, easy-to-use, and efficient C++ library
 *      for processing and rendering 3D data.
 *      Journal of Open Source Software, 6(64), 3255, 2021.
 * ------------------------------------------------------------------
 *
 * Easy3D is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License Version 3
 * as published by the Free Software Foundation.
 *
 * Easy3D is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 ********************************************************************/
 
#ifndef EASY3D_QT_VIEWER_WINDOW_H
#define EASY3D_QT_VIEWER_WINDOW_H
 
#include <string>
#include <QMainWindow>
 
 
namespace Ui {
    class Window;
}
 
namespace easy3d {
 
    class Model;
    class Viewer;
 
    class Window : public QMainWindow {
    Q_OBJECT
    public:
        explicit Window(QWidget *parent = nullptr);
        ~Window() override = default;
 
        Viewer *viewer() { return viewer_; }
 
    public slots:
 
        // file
        bool onOpen();
        bool onSave();
        void onOpenRecentFile();
        void onClearRecentFiles();
        void onCurrentModelChanged();
 
        // view
        void saveSnapshot();
        void setBackgroundColor();
 
        // topology
        void reportTopologyStatistics();
 
        // about
        void onAbout();
 
    protected:
        void dragEnterEvent(QDragEnterEvent *) override;
        void dropEvent(QDropEvent *) override;
        void closeEvent(QCloseEvent *) override;
 
    private:
 
        // open a file (given the file name) and add the model to the viewer
        // for visualization. It will also create the default drawables for
        // visualizing the model.
        easy3d::Model *open(const std::string &file_name);
 
    private:
        void createActions();
        void createActionsForFileMenu();
        void createActionsForViewMenu();
        void createActionsForTopologyMenu();
        bool okToContinue();
        void readSettings();
        void writeSettings();
        void updateWindowTitle();
        void setCurrentFile(const QString &fileName);
        void updateRecentFileActions();
        QString strippedName(const QString &fullFileName);
 
    private:
        Viewer *viewer_;
 
        QStringList recentFiles_;
        QString curDataDirectory_;
 
        enum {
            MaxRecentFiles = 5
        };
        QAction *actionsRecentFile[MaxRecentFiles],
                *actionSeparator;
 
    private:
        Ui::Window *ui;
 
    };
 
}
 
#endif // EASY3D_QT_VIEWER_WINDOW_H

The source file of the window class:

/********************************************************************
 * Copyright (C) 2015 Liangliang Nan <liangliang.nan@gmail.com>
 * https://3d.bk.tudelft.nl/liangliang/
 *
 * This file is part of Easy3D. If it is useful in your research/work,
 * I would be grateful if you show your appreciation by citing it:
 * ------------------------------------------------------------------
 *      Liangliang Nan.
 *      Easy3D: a lightweight, easy-to-use, and efficient C++ library
 *      for processing and rendering 3D data.
 *      Journal of Open Source Software, 6(64), 3255, 2021.
 * ------------------------------------------------------------------
 *
 * Easy3D is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License Version 3
 * as published by the Free Software Foundation.
 *
 * Easy3D is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 ********************************************************************/
 
#include "window.h"
 
#include <string>
#include <iostream>
 
#include <QFileDialog>
#include <QDropEvent>
#include <QMimeData>
#include <QSettings>
#include <QMessageBox>
#include <QColorDialog>
 
#include <easy3d/core/surface_mesh.h>
#include <easy3d/core/graph.h>
#include <easy3d/core/point_cloud.h>
#include <easy3d/core/poly_mesh.h>
#include <easy3d/fileio/point_cloud_io.h>
#include <easy3d/fileio/graph_io.h>
#include <easy3d/fileio/surface_mesh_io.h>
#include <easy3d/fileio/poly_mesh_io.h>
#include <easy3d/fileio/ply_reader_writer.h>
#include <easy3d/fileio/point_cloud_io_ptx.h>
#include <easy3d/util/file_system.h>
#include <easy3d/util/logging.h>
#include <easy3d/util/progress.h>
#include <easy3d/algo/surface_mesh_components.h>
#include <easy3d/algo/surface_mesh_topology.h>
 
#include "viewer.h"
 
#include <ui_window.h>
 
 
namespace easy3d {
 
    // \cond
 
    Window::Window(QWidget *parent)
            : QMainWindow(parent), ui(new Ui::Window) {
        ui->setupUi(this);
 
        viewer_ = new Viewer(this);
        connect(viewer_, SIGNAL(currentModelChanged()), this, SLOT(onCurrentModelChanged()));
        setCentralWidget(viewer_);
 
        createActions();
 
        setWindowIcon(QIcon(QString::fromStdString(":/resources/icons/ViewerQt.png")));
        setFocusPolicy(Qt::StrongFocus);
        setContextMenuPolicy(Qt::CustomContextMenu);
        setAcceptDrops(true);
 
        setBaseSize(1280, 960);
//    setWindowState(Qt::WindowMaximized);
 
        readSettings();
        updateWindowTitle();
    }
 
 
    void Window::dragEnterEvent(QDragEnterEvent *e) {
        if (e->mimeData()->hasUrls())
            e->acceptProposedAction();
    }
 
 
    void Window::dropEvent(QDropEvent *e) {
        if (e->mimeData()->hasUrls())
            e->acceptProposedAction();
 
        int count = 0;
                foreach (const QUrl &url, e->mimeData()->urls()) {
                const QString &fileName = url.toLocalFile();
                if (open(fileName.toStdString()))
                    ++count;
            }
 
        if (count > 0)
            viewer_->update();
    }
 
 
    bool Window::onOpen() {
        const QStringList &fileNames = QFileDialog::getOpenFileNames(
                this,
                "Open file(s)",
                curDataDirectory_,
                "Supported formats (*.ply *.obj *.off *.stl *.sm *.geojson *.trilist *.bin *.las *.laz *.xyz *.bxyz *.vg *.bvg *.ptx *.plm *.pm *.mesh)\n"
                "Surface Mesh (*.ply *.obj *.off *.stl *.sm *.geojson *.trilist)\n"
                "Point Cloud (*.ply *.bin *.ptx *.las *.laz *.xyz *.bxyz *.vg *.bvg *.ptx)\n"
                "Polyhedral Mesh (*.plm *.pm *.mesh)\n"
                "Graph (*.ply)\n"
                "All formats (*.*)"
        );
 
        // Hide closed dialog
        QApplication::processEvents();
 
        if (fileNames.empty())
            return false;
 
        int count = 0;
        ProgressLogger progress(fileNames.size(), false, false);
        for (const auto &name: fileNames) {
            if (progress.is_canceled()) {
                LOG(WARNING) << "opening files cancelled";
                break;
            }
            if (open(name.toStdString()))
                ++count;
            progress.next();
        }
        if (count > 0)
            viewer_->update();
 
        return count > 0;
    }
 
 
    bool Window::onSave() {
        const Model *model = viewer_->currentModel();
        if (!model) {
            std::cerr << "no model exists" << std::endl;
            return false;
        }
 
        std::string default_file_name = model->name();
        if (file_system::extension(default_file_name).empty()) // no extension?
            default_file_name += ".ply"; // default to ply
 
        const QString &fileName = QFileDialog::getSaveFileName(
                this,
                "Open file(s)",
                QString::fromStdString(default_file_name),
                "Supported formats (*.ply *.obj *.off *.stl *.sm *.bin *.las *.laz *.xyz *.bxyz *.vg *.bvg *.plm *.pm *.mesh)\n"
                "Surface Mesh (*.ply *.obj *.off *.stl *.sm)\n"
                "Point Cloud (*.ply *.bin *.ptx *.las *.laz *.xyz *.bxyz *.vg *.bvg)\n"
                "Polyhedral Mesh (*.plm *.pm *.mesh)\n"
                "Graph (*.ply)\n"
                "All formats (*.*)"
        );
 
        if (fileName.isEmpty())
            return false;
 
        bool saved = false;
        if (dynamic_cast<const PointCloud *>(model)) {
            const auto cloud = dynamic_cast<const PointCloud *>(model);
            saved = PointCloudIO::save(fileName.toStdString(), cloud);
        } else if (dynamic_cast<const SurfaceMesh *>(model)) {
            const auto mesh = dynamic_cast<const SurfaceMesh *>(model);
            saved = SurfaceMeshIO::save(fileName.toStdString(), mesh);
        } else if (dynamic_cast<const Graph *>(model)) {
            const auto graph = dynamic_cast<const Graph *>(model);
            saved = GraphIO::save(fileName.toStdString(), graph);
        }
 
        if (saved) {
            std::cout << "model successfully saved to: " << fileName.toStdString();
            setCurrentFile(fileName);
            return true;
        }
 
        return false;
    }
 
 
    Model *Window::open(const std::string &file_name) {
        auto models = viewer_->models();
        for (auto m: models) {
            if (m->name() == file_name) {
                LOG(WARNING) << "model already loaded: " << file_name;
                return nullptr;
            }
        }
 
        const std::string &ext = file_system::extension(file_name, true);
        bool is_ply_mesh = false;
        if (ext == "ply")
            is_ply_mesh = (io::PlyReader::num_instances(file_name, "face") > 0);
 
        Model *model = nullptr;
        if ((ext == "ply" && is_ply_mesh) || ext == "obj" || ext == "off" || ext == "stl" || ext == "sm" ||
            ext == "plg") { // mesh
            model = SurfaceMeshIO::load(file_name);
        } else if (ext == "ply" && io::PlyReader::num_instances(file_name, "edge") > 0) {
            model = GraphIO::load(file_name);
        } else if (ext == "plm" || ext == "pm" || ext == "mesh") {
            model = PolyMeshIO::load(file_name);
        } else { // point cloud
            if (ext == "ptx") {
                io::PointCloudIO_ptx serializer(file_name);
                while (auto cloud = serializer.load_next())
                    viewer_->addModel(cloud);
            } else
                model = PointCloudIO::load(file_name);
        }
 
        if (model) {
            model->set_name(file_name);
            viewer_->addModel(model);
            setCurrentFile(QString::fromStdString(file_name));
        }
 
        return model;
    }
 
 
    void Window::onCurrentModelChanged() {
        const Model *m = viewer_->currentModel();
        if (m) {
            viewer_->fitScreen(m);
 
            const std::string &name = m->name();
            setCurrentFile(QString::fromStdString(name));
        } else
            updateWindowTitle();
    }
 
 
    void Window::setCurrentFile(const QString &fileName) {
        QString dir = fileName.left(fileName.lastIndexOf("/"));
        if (!dir.isEmpty() && file_system::is_directory(dir.toStdString()))
            curDataDirectory_ = dir;
 
        setWindowModified(false);
 
        if (!fileName.isEmpty()) {
            recentFiles_.removeAll(fileName);
            recentFiles_.prepend(fileName);
            updateRecentFileActions();
        }
 
        updateWindowTitle();
    }
 
 
    void Window::onOpenRecentFile() {
        if (okToContinue()) {
            auto action = qobject_cast<QAction *>(sender());
            if (action) {
                const QString filename(action->data().toString());
                if (open(filename.toStdString()))
                    viewer_->update();
            }
        }
    }
 
 
    void Window::onClearRecentFiles() {
        recentFiles_.clear();
        updateRecentFileActions();
    }
 
 
    void Window::saveSnapshot() {
        const Model *model = viewer_->currentModel();
 
        const bool overwrite = false;
        std::string default_file_name("untitled.png");
        if (model)
            default_file_name = file_system::replace_extension(model->name(), "png");
        const QString fileName = QFileDialog::getSaveFileName(
                this,
                "Please choose a file name",
                QString::fromStdString(default_file_name),
                "Image Files (*.png *.jpg *.bmp *.ppm)\n"
                "PNG (*.png)\n"
                "JPG (*.jpg)\n"
                "Windows Bitmap (*.bmp)\n"
                "24bit RGB Bitmap (*.ppm)\n"
                "All Files (*.*)",
                nullptr,
                overwrite ? QFileDialog::DontConfirmOverwrite : QFileDialog::Option()
        );
        // Hide closed dialog
        QApplication::processEvents();
 
        if (fileName.isEmpty())
            return;
 
        viewer_->saveSnapshot(fileName);
    }
 
 
    void Window::setBackgroundColor() {
        const vec4 &c = viewer_->backGroundColor();
        QColor orig(static_cast<int>(c.r * 255), static_cast<int>(c.g * 255), static_cast<int>(c.b * 255),
                    static_cast<int>(c.a * 255));
        const QColor &color = QColorDialog::getColor(orig, this);
        if (color.isValid()) {
            const vec4 newColor(static_cast<float>(color.redF()), static_cast<float>(color.greenF()), static_cast<float>(color.blueF()), static_cast<float>(color.alphaF()));
            viewer_->setBackgroundColor(newColor);
            viewer_->update();
        }
    }
 
 
    bool Window::okToContinue() {
        if (isWindowModified()) {
            QMessageBox::StandardButton r = QMessageBox::warning(
                 this,
                 tr("Viewer"),
                 tr("The model has been modified.\n"
                    "Do you want to save your changes?"),
                 QMessageBox::Yes | QMessageBox::No | QMessageBox::Cancel,
                 QMessageBox::Yes
             );
            if (r == QMessageBox::Yes)
                return onSave();
            else if (r == QMessageBox::Cancel)
                return false;
        }
        return true;
    }
 
 
    void Window::onAbout() {
        const std::string name = "<h3>" + std::string(EXAMPLE_TITLE) + "</h3>";
        QString title = QMessageBox::tr(name.c_str());
 
        QString text = QMessageBox::tr(
                "<p>This viewer shows how to use Qt for GUI creation and event handling</p>"
                "<p>Liangliang Nan<br>"
                "<a href=\"mailto:liangliang.nan@gmail.com\">liangliang.nan@gmail.com</a><br>"
                "<a href=\"https://3d.bk.tudelft.nl/liangliang/\">https://3d.bk.tudelft.nl/liangliang/</a></p>"
        );
 
        //QMessageBox::about(this, title, text);
        QMessageBox::about(this, "About Viewer", title + text);
    }
 
 
    void Window::readSettings() {
        QSettings settings("liangliang.nan@gmail.com", "Viewer");
        recentFiles_ = settings.value("recentFiles").toStringList();
        updateRecentFileActions();
        curDataDirectory_ = settings.value("currentDirectory").toString();
    }
 
 
    void Window::writeSettings() {
        QSettings settings("liangliang.nan@gmail.com", "Viewer");
        settings.setValue("recentFiles", recentFiles_);
        if (!curDataDirectory_.isEmpty() && file_system::is_directory(curDataDirectory_.toStdString()))
            settings.setValue("currentDirectory", curDataDirectory_);
    }
 
 
    void Window::updateWindowTitle() {
        Model *model = viewer_->currentModel();
 
        QString title = QString::fromStdString(EXAMPLE_TITLE);
#ifndef NDEBUG
        title += " (Debug Version)";
#endif // NDEBUG
 
        QString fileName("Untitled");
        if (model)
            fileName = QString::fromStdString(model->name());
 
        title = tr("%1[*] - %2").arg(strippedName(fileName), title);
        setWindowTitle(title);
    }
 
 
    void Window::closeEvent(QCloseEvent *event) {
        if (okToContinue()) {
            writeSettings();
            event->accept();
        } else {
            event->ignore();
        }
    }
 
 
    void Window::updateRecentFileActions() {
        QMutableStringListIterator i(recentFiles_);
        while (i.hasNext()) {
            if (!QFile::exists(i.next()))
                i.remove();
        }
 
        for (int j = 0; j < MaxRecentFiles; ++j) {
            if (j < recentFiles_.count()) {
                QString text = tr("&%1 %2").arg(j + 1).arg(strippedName(recentFiles_[j]));
                actionsRecentFile[j]->setText(text);
                actionsRecentFile[j]->setData(recentFiles_[j]);
                actionsRecentFile[j]->setVisible(true);
            } else {
                actionsRecentFile[j]->setVisible(false);
            }
        }
 
        actionSeparator->setVisible(!recentFiles_.isEmpty());
    }
 
 
    QString Window::strippedName(const QString &fullFileName) {
        return QFileInfo(fullFileName).fileName();
    }
 
 
    void Window::createActions() {
        // file menu
        createActionsForFileMenu();
 
        // view menu
        createActionsForViewMenu();
 
        // topology menu
        createActionsForTopologyMenu();
 
        // about menu
        connect(ui->actionAbout, SIGNAL(triggered()), this, SLOT(onAbout()));
    }
 
 
    void Window::createActionsForFileMenu() {
        connect(ui->actionOpen, SIGNAL(triggered()), this, SLOT(onOpen()));
        connect(ui->actionSave, SIGNAL(triggered()), this, SLOT(onSave()));
 
        actionSeparator = ui->menuFile->addSeparator();
 
        QList<QAction*> actions;
        for (auto& action : actionsRecentFile) {
            action = new QAction(this);
            action->setVisible(false);
            connect(action, SIGNAL(triggered()), this, SLOT(onOpenRecentFile()));
            actions.push_back(action);
        }
        ui->menuRecentFiles->insertActions(ui->actionClearRecentFiles, actions);
        ui->menuRecentFiles->insertSeparator(ui->actionClearRecentFiles);
        connect(ui->actionClearRecentFiles, SIGNAL(triggered()), this, SLOT(onClearRecentFiles()));
 
        connect(ui->actionExit, SIGNAL(triggered()), this, SLOT(close()));
        ui->actionExit->setShortcut(QString("Ctrl+Q"));
    }
 
 
    void Window::createActionsForViewMenu() {
        connect(ui->actionSnapshot, SIGNAL(triggered()), this, SLOT(saveSnapshot()));
 
        ui->menuView->addSeparator();
 
        connect(ui->actionSetBackgroundColor, SIGNAL(triggered()), this, SLOT(setBackgroundColor()));
    }
 
 
    void Window::createActionsForTopologyMenu() {
        connect(ui->actionTopologyStatistics, SIGNAL(triggered()), this, SLOT(reportTopologyStatistics()));
    }
 
 
    void Window::reportTopologyStatistics() {
        auto mesh = dynamic_cast<SurfaceMesh *>(viewer()->currentModel());
        if (!mesh)
            return;
 
        const std::string simple_name = file_system::simple_name(mesh->name());
        if (simple_name.empty())
            std::cout << "#elements in model (with unknown name): ";
        else
            std::cout << "#elements in model '" << file_system::simple_name(mesh->name()) << "': ";
 
        std::cout << "#face = " << mesh->n_faces() << ", #vertex = " << mesh->n_vertices() << ", #edge = "
                  << mesh->n_edges() << std::endl;
 
        // count isolated vertices
        std::size_t count = 0;
        for (auto v: mesh->vertices()) {
            if (mesh->is_isolated(v))
                ++count;
        }
        if (count > 0)
            std::cout << "#isolated vertices: " << count << std::endl;
 
        const auto &components = SurfaceMeshComponent::extract(mesh);
        std::cout << "#connected component: " << components.size() << std::endl;
 
        const std::size_t num = 10;
        if (components.size() > num)
            std::cout << "\ttopology of the first " << num << " components:" << std::endl;
 
        for (std::size_t i = 0; i < std::min(components.size(), num); ++i) {
            const SurfaceMeshComponent &comp = components[i];
            SurfaceMeshTopology topo(&comp);
            std::string type = "unknown";
            if (topo.is_sphere())
                type = "sphere";
            else if (topo.is_disc())
                type = "disc";
            else if (topo.is_cylinder())
                type = "cylinder";
            else if (topo.is_torus())
                type = "torus";
            else if (topo.is_closed())
                type = "unknown closed";
 
            std::cout << "\t\t" << i << ": "
                      << type
                      << ", #face = " << comp.n_faces() << ", #vertex = " << comp.n_vertices() << ", #edge = "
                      << comp.n_edges()
                      << ", #border = " << topo.number_of_borders();
            if (topo.number_of_borders() == 1)
                std::cout << ", border size = " << topo.largest_border_size();
            else if (topo.number_of_borders() > 1)
                std::cout << ", largest border size = " << topo.largest_border_size();
            std::cout << std::endl;
        }
    }
 
    // \endcond
 
}

/********************************************************************
 * Copyright (C) 2015 Liangliang Nan <liangliang.nan@gmail.com>
 * https://3d.bk.tudelft.nl/liangliang/
 *
 * This file is part of Easy3D. If it is useful in your research/work,
 * I would be grateful if you show your appreciation by citing it:
 * ------------------------------------------------------------------
 *      Liangliang Nan.
 *      Easy3D: a lightweight, easy-to-use, and efficient C++ library
 *      for processing and rendering 3D data.
 *      Journal of Open Source Software, 6(64), 3255, 2021.
 * ------------------------------------------------------------------
 *
 * Easy3D is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License Version 3
 * as published by the Free Software Foundation.
 *
 * Easy3D is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 ********************************************************************/
 
#include <QDir>
#include <QTime>
#include <QApplication>
#include <QSurfaceFormat>
#include <QStyleFactory>
 
#include <easy3d/util/initializer.h>
 
#include "window.h"

 
using namespace easy3d;
 
int main(int argc, char *argv[]) {
    // Note: Calling QSurfaceFormat::setDefaultFormat() before constructing the
    //       QApplication instance is mandatory on some platforms (e.g., macOS)
    //       when an OpenGL core profile context is requested. This is to ensure
    //       that resource sharing between contexts stays functional as all internal
    //       contexts are created using the correct version and profile.
    QSurfaceFormat format = QSurfaceFormat::defaultFormat();
    format.setVersion(4, 3);
    format.setProfile(QSurfaceFormat::CoreProfile);
    format.setDepthBufferSize(24);
    format.setStencilBufferSize(8);
    format.setSamples(4);
    QSurfaceFormat::setDefaultFormat(format);
 
    // Commented to let Qt choose the most suitable OpenGL implementation
    QApplication::setAttribute(Qt::AA_UseDesktopOpenGL);
 
    QApplication::setAttribute(Qt::AA_ShareOpenGLContexts);
#if (QT_VERSION >= QT_VERSION_CHECK(5, 6, 0) && (QT_VERSION < QT_VERSION_CHECK(6, 0, 0)))
    QApplication::setAttribute(Qt::AA_UseHighDpiPixmaps);
    QApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
#endif
 
    QApplication app(argc, argv);
#ifdef _WIN32   // to have similar style as on macOS.
    app.setStyle(QStyleFactory::create("Fusion"));
#endif
 
    QDir workingDir = QCoreApplication::applicationDirPath();
#ifdef __APPLE__
    // This makes sure that our "working directory" is not within the application bundle
    if (workingDir.dirName() == "MacOS") {
        workingDir.cdUp();
        workingDir.cdUp();
        workingDir.cdUp();
    }
#endif
    QDir::setCurrent(workingDir.absolutePath());
 
    // initialize Easy3D.
    initialize();
 
    Window win;
    win.show();
    return app.exec();
}