Apply webkit style clang format on code base

application/sources/about_widget.cc

@@ -1,22 +1,22 @@
+#include <QOpenGLFunctions>
 #include <QTextEdit>
 #include <QVBoxLayout>
-#include <QOpenGLFunctions>
 
 #include "about_widget.h"
-#include "version.h"
 #include "model_widget.h"
+#include "version.h"
 
 AboutWidget::AboutWidget()
 {
-    QTextEdit *versionInfoLabel = new QTextEdit;
+    QTextEdit* versionInfoLabel = new QTextEdit;
     versionInfoLabel->setText(QString("%1 %2 (version: %3 build: %4 %5)\nopengl: %6 shader: %7 core: %8").arg(APP_NAME).arg(APP_HUMAN_VER).arg(APP_VER).arg(__DATE__).arg(__TIME__).arg(ModelWidget::m_openGLVersion).arg(ModelWidget::m_openGLShadingLanguageVersion).arg(ModelWidget::m_openGLIsCoreProfile ? "true" : "false"));
     versionInfoLabel->setReadOnly(true);
-    
+
-    QVBoxLayout *mainLayout = new QVBoxLayout;
+    QVBoxLayout* mainLayout = new QVBoxLayout;
     mainLayout->addWidget(versionInfoLabel);
-    
+
     setLayout(mainLayout);
     setFixedSize(QSize(350, 100));
-    
+
     setWindowTitle(applicationTitle(tr("About")));
 }

application/sources/about_widget.h

@@ -3,8 +3,7 @@
 
 #include <QDialog>
 
-class AboutWidget : public QDialog
+class AboutWidget : public QDialog {
-{
     Q_OBJECT
 public:
     AboutWidget();

application/sources/ccd_ik_resolver.cc

@@ -1,9 +1,9 @@
-#include <QtGlobal>
-#include <QMatrix4x4>
-#include <QDebug>
-#include <cmath>
-#include <QtMath>
 #include "ccd_ik_resolver.h"
+#include <QDebug>
+#include <QMatrix4x4>
+#include <QtGlobal>
+#include <QtMath>
+#include <cmath>
 
 CcdIkSolver::CcdIkSolver()
 {
@@ -15,9 +15,9 @@ void CcdIkSolver::setSolveFrom(int fromNodeIndex)
 }
 
 void CcdIkSolver::setNodeHingeConstraint(int nodeIndex,
-        const QVector3D &axis, double minLimitDegrees, double maxLimitDegrees)
+    const QVector3D& axis, double minLimitDegrees, double maxLimitDegrees)
 {
-    auto &node = m_nodes[nodeIndex];
+    auto& node = m_nodes[nodeIndex];
     node.axis = axis;
     node.minLimitDegrees = minLimitDegrees;
     node.maxLimitDegrees = maxLimitDegrees;
@@ -33,7 +33,7 @@ void CcdIkSolver::setDistanceThreshod(float threshold)
     m_distanceThreshold2 = threshold * threshold;
 }
 
-int CcdIkSolver::addNodeInOrder(const QVector3D &position)
+int CcdIkSolver::addNodeInOrder(const QVector3D& position)
 {
     CcdIkNode node;
     node.position = position;
@@ -42,13 +42,13 @@ int CcdIkSolver::addNodeInOrder(const QVector3D &position)
     return nodeCount;
 }
 
-void CcdIkSolver::solveTo(const QVector3D &position)
+void CcdIkSolver::solveTo(const QVector3D& position)
 {
     //qDebug() << "solveTo:" << position;
     m_destination = position;
     float lastDistance2 = 0;
     for (int i = 0; i < m_maxRound; i++) {
-        const auto &endEffector = m_nodes[m_nodes.size() - 1];
+        const auto& endEffector = m_nodes[m_nodes.size() - 1];
         float distance2 = (endEffector.position - m_destination).lengthSquared();
         //qDebug() << "Round:" << i << " distance2:" << distance2;
         if (distance2 <= m_distanceThreshold2)
@@ -60,7 +60,7 @@ void CcdIkSolver::solveTo(const QVector3D &position)
     }
 }
 
-const QVector3D &CcdIkSolver::getNodeSolvedPosition(int index)
+const QVector3D& CcdIkSolver::getNodeSolvedPosition(int index)
 {
     Q_ASSERT(index >= 0 && index < (int)m_nodes.size());
     return m_nodes[index].position;
@@ -82,18 +82,18 @@ float CcdIkSolver::angleInRangle360BetweenTwoVectors(QVector3D a, QVector3D b, Q
 
 void CcdIkSolver::iterate()
 {
-    auto rotateChildren = [&](const QQuaternion &quaternion, int i) {
+    auto rotateChildren = [&](const QQuaternion& quaternion, int i) {
-        const auto &origin = m_nodes[i];
+        const auto& origin = m_nodes[i];
         for (size_t j = i + 1; j <= m_nodes.size() - 1; j++) {
-            auto &next = m_nodes[j];
+            auto& next = m_nodes[j];
             const auto offset = next.position - origin.position;
             next.position = origin.position + quaternion.rotatedVector(offset);
         }
     };
-    
+
     for (int i = m_nodes.size() - 2; i >= m_fromNodeIndex; i--) {
-        const auto &origin = m_nodes[i];
+        const auto& origin = m_nodes[i];
-        const auto &endEffector = m_nodes[m_nodes.size() - 1];
+        const auto& endEffector = m_nodes[m_nodes.size() - 1];
         QVector3D from = (endEffector.position - origin.position).normalized();
         QVector3D to = (m_destination - origin.position).normalized();
         auto quaternion = QQuaternion::rotationTo(from, to);
@@ -111,12 +111,10 @@ void CcdIkSolver::iterate()
         int childIndex = i + 1;
         if (childIndex >= m_nodes.size())
             continue;
-        const auto &parent = m_nodes[parentIndex];
+        const auto& parent = m_nodes[parentIndex];
-        const auto &child = m_nodes[childIndex];
+        const auto& child = m_nodes[childIndex];
-        QVector3D angleFrom = (QVector3D(0.0, parent.position.y(), parent.position.z()) - 
+        QVector3D angleFrom = (QVector3D(0.0, parent.position.y(), parent.position.z()) - QVector3D(0.0, origin.position.y(), origin.position.z())).normalized();
-            QVector3D(0.0, origin.position.y(), origin.position.z())).normalized();
+        QVector3D angleTo = (QVector3D(0.0, child.position.y(), child.position.z()) - QVector3D(0.0, origin.position.y(), origin.position.z())).normalized();
-        QVector3D angleTo = (QVector3D(0.0, child.position.y(), child.position.z()) - 
-            QVector3D(0.0, origin.position.y(), origin.position.z())).normalized();
         float degrees = angleInRangle360BetweenTwoVectors(angleFrom, angleTo, QVector3D(1.0, 0.0, 0.0));
         if (degrees < origin.minLimitDegrees) {
             auto quaternion = QQuaternion::fromAxisAndAngle(QVector3D(1.0, 0.0, 0.0), origin.minLimitDegrees - degrees);

application/sources/ccd_ik_resolver.h

@@ -1,31 +1,30 @@
 #ifndef DUST3D_APPLICATION_CCD_IK_SOLVER_H_
 #define DUST3D_APPLICATION_CCD_IK_SOLVER_H_
 
-#include <vector>
-#include <QVector3D>
 #include <QQuaternion>
+#include <QVector3D>
+#include <vector>
 
-struct CcdIkNode
+struct CcdIkNode {
-{
     QVector3D position;
     QVector3D axis;
     double minLimitDegrees;
     double maxLimitDegrees;
 };
 
-class CcdIkSolver
+class CcdIkSolver {
-{
 public:
     CcdIkSolver();
     void setMaxRound(int maxRound);
     void setDistanceThreshod(float threshold);
-    int addNodeInOrder(const QVector3D &position);
+    int addNodeInOrder(const QVector3D& position);
-    void solveTo(const QVector3D &position);
+    void solveTo(const QVector3D& position);
-    const QVector3D &getNodeSolvedPosition(int index);
+    const QVector3D& getNodeSolvedPosition(int index);
     int getNodeCount();
     void setNodeHingeConstraint(int nodeIndex,
-        const QVector3D &axis, double minLimitDegrees, double maxLimitDegrees);
+        const QVector3D& axis, double minLimitDegrees, double maxLimitDegrees);
     void setSolveFrom(int fromNodeIndex);
+
 private:
     float angleInRangle360BetweenTwoVectors(QVector3D a, QVector3D b, QVector3D planeNormal);
     void iterate();

application/sources/component_list_model.cc

@@ -1,13 +1,13 @@
-#include <QAbstractListModel>
-#include <dust3d/base/debug.h>
 #include "component_list_model.h"
 #include "document.h"
+#include <QAbstractListModel>
+#include <dust3d/base/debug.h>
 
-ComponentListModel::ComponentListModel(const Document *document, QObject *parent):
+ComponentListModel::ComponentListModel(const Document* document, QObject* parent)
-    QAbstractListModel(parent),
+    : QAbstractListModel(parent)
-    m_document(document)
+    , m_document(document)
 {
-    connect(m_document, &Document::componentPreviewPixmapChanged, [this](const dust3d::Uuid &componentId) {
+    connect(m_document, &Document::componentPreviewPixmapChanged, [this](const dust3d::Uuid& componentId) {
         auto findIndex = this->m_componentIdToIndexMap.find(componentId);
         if (findIndex != this->m_componentIdToIndexMap.end()) {
             //dust3dDebug << "dataChanged:" << findIndex->second.row();
@@ -18,7 +18,7 @@ ComponentListModel::ComponentListModel(const Document *document, QObject *parent
         this->setListingComponentId(dust3d::Uuid());
         this->reload();
     });
-    connect(m_document, &Document::componentChildrenChanged, [this](const dust3d::Uuid &componentId) {
+    connect(m_document, &Document::componentChildrenChanged, [this](const dust3d::Uuid& componentId) {
         if (componentId != this->listingComponentId())
             return;
         this->reload();
@@ -29,7 +29,7 @@ void ComponentListModel::reload()
 {
     beginResetModel();
     m_componentIdToIndexMap.clear();
-    const SkeletonComponent *listingComponent = m_document->findComponent(m_listingComponentId);
+    const SkeletonComponent* listingComponent = m_document->findComponent(m_listingComponentId);
     if (nullptr != listingComponent) {
         for (int i = 0; i < (int)listingComponent->childrenIds.size(); ++i) {
             m_componentIdToIndexMap[listingComponent->childrenIds[i]] = createIndex(i, 0);
@@ -39,7 +39,7 @@ void ComponentListModel::reload()
     emit layoutChanged();
 }
 
-QModelIndex ComponentListModel::componentIdToIndex(const dust3d::Uuid &componentId) const
+QModelIndex ComponentListModel::componentIdToIndex(const dust3d::Uuid& componentId) const
 {
     auto findIndex = m_componentIdToIndexMap.find(componentId);
     if (findIndex == m_componentIdToIndexMap.end())
@@ -47,34 +47,34 @@ QModelIndex ComponentListModel::componentIdToIndex(const dust3d::Uuid &component
     return findIndex->second;
 }
 
-int ComponentListModel::rowCount(const QModelIndex &parent) const
+int ComponentListModel::rowCount(const QModelIndex& parent) const
 {
     if (parent.isValid())
         return 0;
-    const SkeletonComponent *listingComponent = m_document->findComponent(m_listingComponentId);
+    const SkeletonComponent* listingComponent = m_document->findComponent(m_listingComponentId);
     if (nullptr == listingComponent)
         return 0;
     return (int)listingComponent->childrenIds.size();
 }
 
-int ComponentListModel::columnCount(const QModelIndex &parent) const
+int ComponentListModel::columnCount(const QModelIndex& parent) const
 {
     if (parent.isValid())
         return 0;
     return 1;
 }
 
-const SkeletonComponent *ComponentListModel::modelIndexToComponent(const QModelIndex &index) const
+const SkeletonComponent* ComponentListModel::modelIndexToComponent(const QModelIndex& index) const
 {
-    const SkeletonComponent *listingComponent = m_document->findComponent(m_listingComponentId);
+    const SkeletonComponent* listingComponent = m_document->findComponent(m_listingComponentId);
     if (nullptr == listingComponent)
         return nullptr;
     if (index.row() >= (int)listingComponent->childrenIds.size()) {
         dust3dDebug << "Component list row is out of range, size:" << listingComponent->childrenIds.size() << "row:" << index.row();
         return nullptr;
     }
-    const auto &componentId = listingComponent->childrenIds[index.row()];
+    const auto& componentId = listingComponent->childrenIds[index.row()];
-    const SkeletonComponent *component = m_document->findComponent(componentId);
+    const SkeletonComponent* component = m_document->findComponent(componentId);
     if (nullptr == component) {
         dust3dDebug << "Component not found:" << componentId.toString();
         return nullptr;
@@ -82,50 +82,48 @@ const SkeletonComponent *ComponentListModel::modelIndexToComponent(const QModelI
     return component;
 }
 
-const dust3d::Uuid ComponentListModel::modelIndexToComponentId(const QModelIndex &index) const
+const dust3d::Uuid ComponentListModel::modelIndexToComponentId(const QModelIndex& index) const
 {
-    const SkeletonComponent *listingComponent = m_document->findComponent(m_listingComponentId);
+    const SkeletonComponent* listingComponent = m_document->findComponent(m_listingComponentId);
     if (nullptr == listingComponent)
         return dust3d::Uuid();
     if (index.row() >= (int)listingComponent->childrenIds.size()) {
         dust3dDebug << "Component list row is out of range, size:" << listingComponent->childrenIds.size() << "row:" << index.row();
         return dust3d::Uuid();
     }
-    const auto &componentId = listingComponent->childrenIds[index.row()];
+    const auto& componentId = listingComponent->childrenIds[index.row()];
     return componentId;
 }
 
-QVariant ComponentListModel::data(const QModelIndex &index, int role) const
+QVariant ComponentListModel::data(const QModelIndex& index, int role) const
 {
     switch (role) {
     case Qt::ToolTipRole: {
-            const SkeletonComponent *component = modelIndexToComponent(index);
+        const SkeletonComponent* component = modelIndexToComponent(index);
-            if (nullptr != component) {
+        if (nullptr != component) {
-                return component->name;
+            return component->name;
-            }
         }
-        break;
+    } break;
     case Qt::DecorationRole: {
-            const SkeletonComponent *component = modelIndexToComponent(index);
+        const SkeletonComponent* component = modelIndexToComponent(index);
-            if (nullptr != component) {
+        if (nullptr != component) {
-                if (0 == component->previewPixmap.width()) {
+            if (0 == component->previewPixmap.width()) {
-                    static QPixmap s_emptyPixmap;
+                static QPixmap s_emptyPixmap;
-                    if (0 == s_emptyPixmap.width()) {
+                if (0 == s_emptyPixmap.width()) {
-                        QImage image((int)Theme::partPreviewImageSize, (int)Theme::partPreviewImageSize, QImage::Format_ARGB32);
+                    QImage image((int)Theme::partPreviewImageSize, (int)Theme::partPreviewImageSize, QImage::Format_ARGB32);
-                        image.fill(Qt::transparent);
+                    image.fill(Qt::transparent);
-                        s_emptyPixmap = QPixmap::fromImage(image);
+                    s_emptyPixmap = QPixmap::fromImage(image);
-                    }
-                    return s_emptyPixmap;
                 }
-                return component->previewPixmap;
+                return s_emptyPixmap;
             }
+            return component->previewPixmap;
         }
-        break;
+    } break;
     }
     return QVariant();
 }
 
-void ComponentListModel::setListingComponentId(const dust3d::Uuid &componentId)
+void ComponentListModel::setListingComponentId(const dust3d::Uuid& componentId)
 {
     if (m_listingComponentId == componentId)
         return;

application/sources/component_list_model.h

@@ -1,32 +1,33 @@
 #ifndef DUST3D_APPLICATION_COMPONENT_LIST_MODEL_H_
 #define DUST3D_APPLICATION_COMPONENT_LIST_MODEL_H_
 
-#include <unordered_map>
-#include <dust3d/base/uuid.h>
 #include <QAbstractListModel>
+#include <dust3d/base/uuid.h>
+#include <unordered_map>
 
 class Document;
 class SkeletonComponent;
 
-class ComponentListModel: public QAbstractListModel
+class ComponentListModel : public QAbstractListModel {
-{
     Q_OBJECT
 signals:
-    void listingComponentChanged(const dust3d::Uuid &componentId);
+    void listingComponentChanged(const dust3d::Uuid& componentId);
+
 public:
-    ComponentListModel(const Document *document, QObject *parent=nullptr);
+    ComponentListModel(const Document* document, QObject* parent = nullptr);
-    int rowCount(const QModelIndex &parent = QModelIndex()) const;
+    int rowCount(const QModelIndex& parent = QModelIndex()) const;
-    int columnCount(const QModelIndex &parent = QModelIndex()) const;
+    int columnCount(const QModelIndex& parent = QModelIndex()) const;
-    QVariant data(const QModelIndex &index, int role) const;
+    QVariant data(const QModelIndex& index, int role) const;
-    const SkeletonComponent *modelIndexToComponent(const QModelIndex &index) const;
+    const SkeletonComponent* modelIndexToComponent(const QModelIndex& index) const;
-    QModelIndex componentIdToIndex(const dust3d::Uuid &componentId) const;
+    QModelIndex componentIdToIndex(const dust3d::Uuid& componentId) const;
-    const dust3d::Uuid modelIndexToComponentId(const QModelIndex &index) const;
+    const dust3d::Uuid modelIndexToComponentId(const QModelIndex& index) const;
     const dust3d::Uuid listingComponentId() const;
 public slots:
-    void setListingComponentId(const dust3d::Uuid &componentId);
+    void setListingComponentId(const dust3d::Uuid& componentId);
     void reload();
+
 private:
-    const Document *m_document = nullptr;
+    const Document* m_document = nullptr;
     dust3d::Uuid m_listingComponentId;
     std::unordered_map<dust3d::Uuid, QModelIndex> m_componentIdToIndexMap;
 };

application/sources/component_preview_grid_widget.cc

@@ -1,23 +1,23 @@
-#include <memory>
 #include "component_preview_grid_widget.h"
 #include "component_list_model.h"
 #include "document.h"
+#include <memory>
 
-ComponentPreviewGridWidget::ComponentPreviewGridWidget(Document *document, QWidget *parent):
+ComponentPreviewGridWidget::ComponentPreviewGridWidget(Document* document, QWidget* parent)
-    PreviewGridView(parent),
+    : PreviewGridView(parent)
-    m_document(document)
+    , m_document(document)
 {
     m_componentListModel = std::make_unique<ComponentListModel>(m_document);
     setModel(m_componentListModel.get());
 
-    connect(this, &ComponentPreviewGridWidget::doubleClicked, [this](const QModelIndex &index) {
+    connect(this, &ComponentPreviewGridWidget::doubleClicked, [this](const QModelIndex& index) {
-        const SkeletonComponent *component = this->componentListModel()->modelIndexToComponent(index);
+        const SkeletonComponent* component = this->componentListModel()->modelIndexToComponent(index);
         if (nullptr == component)
             return;
         if (component->childrenIds.empty()) {
             std::vector<dust3d::Uuid> partIds;
             this->m_document->collectComponentDescendantParts(component->id, partIds);
-            for (const auto &partId: partIds)
+            for (const auto& partId : partIds)
                 emit this->selectPartOnCanvas(partId);
         } else {
             this->componentListModel()->setListingComponentId(component->id);
@@ -25,17 +25,17 @@ ComponentPreviewGridWidget::ComponentPreviewGridWidget(Document *document, QWidg
     });
 }
 
-ComponentListModel *ComponentPreviewGridWidget::componentListModel()
+ComponentListModel* ComponentPreviewGridWidget::componentListModel()
 {
     return m_componentListModel.get();
 }
 
-std::vector<const SkeletonComponent *> ComponentPreviewGridWidget::getSelectedComponents() const
+std::vector<const SkeletonComponent*> ComponentPreviewGridWidget::getSelectedComponents() const
 {
-    std::vector<const SkeletonComponent *> components;
+    std::vector<const SkeletonComponent*> components;
     QModelIndexList selected = selectionModel()->selectedIndexes();
-    for (const auto &it: selected) {
+    for (const auto& it : selected) {
-        const auto &component = m_componentListModel->modelIndexToComponent(it);
+        const auto& component = m_componentListModel->modelIndexToComponent(it);
         if (nullptr == component)
             continue;
         components.push_back(component);
@@ -47,8 +47,8 @@ std::vector<dust3d::Uuid> ComponentPreviewGridWidget::getSelectedComponentIds()
 {
     std::vector<dust3d::Uuid> componentIds;
     QModelIndexList selected = selectionModel()->selectedIndexes();
-    for (const auto &it: selected) {
+    for (const auto& it : selected) {
-        const auto &componentId = m_componentListModel->modelIndexToComponentId(it);
+        const auto& componentId = m_componentListModel->modelIndexToComponentId(it);
         if (componentId.isNull())
             continue;
         componentIds.push_back(componentId);
@@ -60,7 +60,7 @@ std::vector<dust3d::Uuid> ComponentPreviewGridWidget::getSelectedPartIds() const
 {
     auto selectedComponents = getSelectedComponents();
     std::vector<dust3d::Uuid> partIds;
-    for (const auto &component: selectedComponents) {
+    for (const auto& component : selectedComponents) {
         if (component->linkToPartId.isNull())
             continue;
         partIds.push_back(component->linkToPartId);

application/sources/component_preview_grid_widget.h

@@ -1,30 +1,31 @@
 #ifndef DUST3D_APPLICATION_COMPONENT_PREVIEW_GRID_WIDGET_H_
 #define DUST3D_APPLICATION_COMPONENT_PREVIEW_GRID_WIDGET_H_
 
-#include <memory>
-#include <dust3d/base/uuid.h>
-#include <QAbstractListModel>
-#include "preview_grid_view.h"
 #include "component_list_model.h"
+#include "preview_grid_view.h"
+#include <QAbstractListModel>
+#include <dust3d/base/uuid.h>
+#include <memory>
 
 class Document;
 class SkeletonComponent;
 
-class ComponentPreviewGridWidget: public PreviewGridView
+class ComponentPreviewGridWidget : public PreviewGridView {
-{
     Q_OBJECT
 signals:
     void unselectAllOnCanvas();
-    void selectPartOnCanvas(const dust3d::Uuid &partId);
+    void selectPartOnCanvas(const dust3d::Uuid& partId);
+
 public:
-    ComponentPreviewGridWidget(Document *document, QWidget *parent=nullptr);
+    ComponentPreviewGridWidget(Document* document, QWidget* parent = nullptr);
-    ComponentListModel *componentListModel();
+    ComponentListModel* componentListModel();
-    std::vector<const SkeletonComponent *> getSelectedComponents() const;
+    std::vector<const SkeletonComponent*> getSelectedComponents() const;
     std::vector<dust3d::Uuid> getSelectedComponentIds() const;
     std::vector<dust3d::Uuid> getSelectedPartIds() const;
+
 private:
     std::unique_ptr<ComponentListModel> m_componentListModel;
-    Document *m_document = nullptr;
+    Document* m_document = nullptr;
 };
 
 #endif

application/sources/component_preview_images_decorator.cc

@@ -1,7 +1,7 @@
-#include <dust3d/base/debug.h>
-#include <QPainter>
-#include "theme.h"
 #include "component_preview_images_decorator.h"
+#include "theme.h"
+#include <QPainter>
+#include <dust3d/base/debug.h>
 
 ComponentPreviewImagesDecorator::ComponentPreviewImagesDecorator(std::unique_ptr<std::vector<PreviewInput>> previewInputs)
 {
@@ -21,7 +21,7 @@ void ComponentPreviewImagesDecorator::decorate()
     m_resultImages = std::make_unique<std::unordered_map<dust3d::Uuid, std::unique_ptr<QImage>>>();
 
     QPointF iconOffset(Theme::previewIconMargin, 0);
-    for (auto &it: *m_previewInputs) {
+    for (auto& it : *m_previewInputs) {
         if (it.isDirectory) {
             QPainter painter(it.image.get());
             painter.setRenderHints(QPainter::Antialiasing);

application/sources/component_preview_images_decorator.h

@@ -1,17 +1,15 @@
 #ifndef DUST3D_APPLICATION_COMPONENT_PREVIEW_IMAGES_DECORATOR_H_
 #define DUST3D_APPLICATION_COMPONENT_PREVIEW_IMAGES_DECORATOR_H_
 
+#include <QImage>
+#include <dust3d/base/uuid.h>
 #include <memory>
 #include <unordered_map>
-#include <dust3d/base/uuid.h>
-#include <QImage>
 
-class ComponentPreviewImagesDecorator: public QObject
+class ComponentPreviewImagesDecorator : public QObject {
-{
     Q_OBJECT
 public:
-    struct PreviewInput
+    struct PreviewInput {
-    {
         dust3d::Uuid id;
         std::unique_ptr<QImage> image;
         bool isDirectory = false;
@@ -23,6 +21,7 @@ signals:
     void finished();
 public slots:
     void process();
+
 private:
     std::unique_ptr<std::vector<PreviewInput>> m_previewInputs;
     std::unique_ptr<std::unordered_map<dust3d::Uuid, std::unique_ptr<QImage>>> m_resultImages;

application/sources/component_property_widget.cc

@@ -1,96 +1,96 @@
-#include <unordered_set>
+#include "component_property_widget.h"
-#include <QVBoxLayout>
+#include "document.h"
-#include <QHBoxLayout>
+#include "float_number_widget.h"
-#include <QPushButton>
+#include "theme.h"
 #include <QColorDialog>
 #include <QGroupBox>
-#include "component_property_widget.h"
+#include <QHBoxLayout>
-#include "float_number_widget.h"
+#include <QPushButton>
-#include "document.h"
+#include <QVBoxLayout>
-#include "theme.h"
+#include <unordered_set>
 
-ComponentPropertyWidget::ComponentPropertyWidget(Document *document, 
+ComponentPropertyWidget::ComponentPropertyWidget(Document* document,
-        const std::vector<dust3d::Uuid> &componentIds,
+    const std::vector<dust3d::Uuid>& componentIds,
-        QWidget *parent):
+    QWidget* parent)
-    QWidget(parent),
+    : QWidget(parent)
-    m_document(document),
+    , m_document(document)
-    m_componentIds(componentIds)
+    , m_componentIds(componentIds)
 {
     preparePartIds();
     m_color = lastColor();
 
-    QPushButton *colorPreviewArea = new QPushButton;
+    QPushButton* colorPreviewArea = new QPushButton;
     colorPreviewArea->setStyleSheet("QPushButton {background-color: " + m_color.name() + "; border-radius: 0;}");
     colorPreviewArea->setFixedSize(Theme::toolIconSize * 1.8, Theme::toolIconSize);
 
-    QPushButton *colorPickerButton = new QPushButton(QChar(fa::eyedropper));
+    QPushButton* colorPickerButton = new QPushButton(QChar(fa::eyedropper));
     Theme::initIconButton(colorPickerButton);
     connect(colorPickerButton, &QPushButton::clicked, this, &ComponentPropertyWidget::showColorDialog);
 
-    QHBoxLayout *colorLayout = new QHBoxLayout;
+    QHBoxLayout* colorLayout = new QHBoxLayout;
     colorLayout->addWidget(colorPreviewArea);
     colorLayout->addWidget(colorPickerButton);
     colorLayout->addStretch();
     colorLayout->setSizeConstraint(QLayout::SetFixedSize);
 
-    QGroupBox *deformGroupBox = nullptr;
+    QGroupBox* deformGroupBox = nullptr;
     if (nullptr != m_part) {
-        FloatNumberWidget *thicknessWidget = new FloatNumberWidget;
+        FloatNumberWidget* thicknessWidget = new FloatNumberWidget;
         thicknessWidget->setItemName(tr("Thickness"));
         thicknessWidget->setRange(0, 2);
         thicknessWidget->setValue(m_part->deformThickness);
-        
+
         connect(thicknessWidget, &FloatNumberWidget::valueChanged, [=](float value) {
             emit setPartDeformThickness(m_partId, value);
             emit groupOperationAdded();
         });
-        
+
-        FloatNumberWidget *widthWidget = new FloatNumberWidget;
+        FloatNumberWidget* widthWidget = new FloatNumberWidget;
         widthWidget->setItemName(tr("Width"));
         widthWidget->setRange(0, 2);
         widthWidget->setValue(m_part->deformWidth);
-        
+
         connect(widthWidget, &FloatNumberWidget::valueChanged, [=](float value) {
             emit setPartDeformWidth(m_partId, value);
             emit groupOperationAdded();
         });
-        
+
-        QPushButton *thicknessEraser = new QPushButton(QChar(fa::eraser));
+        QPushButton* thicknessEraser = new QPushButton(QChar(fa::eraser));
         Theme::initIconButton(thicknessEraser);
-        
+
         connect(thicknessEraser, &QPushButton::clicked, [=]() {
             thicknessWidget->setValue(1.0);
             emit groupOperationAdded();
         });
-        
+
-        QPushButton *widthEraser = new QPushButton(QChar(fa::eraser));
+        QPushButton* widthEraser = new QPushButton(QChar(fa::eraser));
         Theme::initIconButton(widthEraser);
-        
+
         connect(widthEraser, &QPushButton::clicked, [=]() {
             widthWidget->setValue(1.0);
             emit groupOperationAdded();
         });
-        
+
-        QVBoxLayout *deformLayout = new QVBoxLayout;
+        QVBoxLayout* deformLayout = new QVBoxLayout;
-        
+
-        QHBoxLayout *thicknessLayout = new QHBoxLayout;
+        QHBoxLayout* thicknessLayout = new QHBoxLayout;
-        QHBoxLayout *widthLayout = new QHBoxLayout;
+        QHBoxLayout* widthLayout = new QHBoxLayout;
         thicknessLayout->addWidget(thicknessEraser);
         thicknessLayout->addWidget(thicknessWidget);
         widthLayout->addWidget(widthEraser);
         widthLayout->addWidget(widthWidget);
-        
+
-        QCheckBox *deformUnifyStateBox = new QCheckBox();
+        QCheckBox* deformUnifyStateBox = new QCheckBox();
         Theme::initCheckbox(deformUnifyStateBox);
         deformUnifyStateBox->setText(tr("Unified"));
         deformUnifyStateBox->setChecked(m_part->deformUnified);
-        
+
         connect(deformUnifyStateBox, &QCheckBox::stateChanged, this, [=]() {
             emit setPartDeformUnified(m_partId, deformUnifyStateBox->isChecked());
             emit groupOperationAdded();
         });
-        
+
-        QHBoxLayout *deformUnifyLayout = new QHBoxLayout;
+        QHBoxLayout* deformUnifyLayout = new QHBoxLayout;
         deformUnifyLayout->addStretch();
         deformUnifyLayout->addWidget(deformUnifyStateBox);
 
@@ -102,85 +102,85 @@ ComponentPropertyWidget::ComponentPropertyWidget(Document *document,
         deformGroupBox->setLayout(deformLayout);
     }
 
-    QGroupBox *cutFaceGroupBox = nullptr;
+    QGroupBox* cutFaceGroupBox = nullptr;
     if (nullptr != m_part) {
-        FloatNumberWidget *rotationWidget = new FloatNumberWidget;
+        FloatNumberWidget* rotationWidget = new FloatNumberWidget;
         rotationWidget->setItemName(tr("Rotation"));
         rotationWidget->setRange(-1, 1);
         rotationWidget->setValue(m_part->cutRotation);
-        
+
         connect(rotationWidget, &FloatNumberWidget::valueChanged, [=](float value) {
             emit setPartCutRotation(m_partId, value);
             emit groupOperationAdded();
         });
-        
+
-        QPushButton *rotationEraser = new QPushButton(QChar(fa::eraser));
+        QPushButton* rotationEraser = new QPushButton(QChar(fa::eraser));
         Theme::initIconButton(rotationEraser);
-        
+
         connect(rotationEraser, &QPushButton::clicked, [=]() {
             rotationWidget->setValue(0.0);
             emit groupOperationAdded();
         });
-        
+
-        QPushButton *rotationMinus5Button = new QPushButton(QChar(fa::rotateleft));
+        QPushButton* rotationMinus5Button = new QPushButton(QChar(fa::rotateleft));
         Theme::initIconButton(rotationMinus5Button);
-        
+
         connect(rotationMinus5Button, &QPushButton::clicked, [=]() {
             rotationWidget->setValue(-0.5);
             emit groupOperationAdded();
         });
-        
+
-        QPushButton *rotation5Button = new QPushButton(QChar(fa::rotateright));
+        QPushButton* rotation5Button = new QPushButton(QChar(fa::rotateright));
         Theme::initIconButton(rotation5Button);
-        
+
         connect(rotation5Button, &QPushButton::clicked, [=]() {
             rotationWidget->setValue(0.5);
             emit groupOperationAdded();
         });
 
-        QHBoxLayout *rotationLayout = new QHBoxLayout;
+        QHBoxLayout* rotationLayout = new QHBoxLayout;
         rotationLayout->addWidget(rotationEraser);
         rotationLayout->addWidget(rotationWidget);
         rotationLayout->addWidget(rotationMinus5Button);
         rotationLayout->addWidget(rotation5Button);
 
-        QCheckBox *subdivStateBox = new QCheckBox();
+        QCheckBox* subdivStateBox = new QCheckBox();
         Theme::initCheckbox(subdivStateBox);
         subdivStateBox->setText(tr("Subdivided"));
         subdivStateBox->setChecked(m_part->subdived);
-        
+
         connect(subdivStateBox, &QCheckBox::stateChanged, this, [=]() {
             emit setPartSubdivState(m_partId, subdivStateBox->isChecked());
             emit groupOperationAdded();
         });
 
-        QCheckBox *chamferStateBox = new QCheckBox();
+        QCheckBox* chamferStateBox = new QCheckBox();
         Theme::initCheckbox(chamferStateBox);
         chamferStateBox->setText(tr("Chamfered"));
         chamferStateBox->setChecked(m_part->chamfered);
-        
+
         connect(chamferStateBox, &QCheckBox::stateChanged, this, [=]() {
             emit setPartChamferState(m_partId, chamferStateBox->isChecked());
             emit groupOperationAdded();
         });
 
-        QCheckBox *roundEndStateBox = new QCheckBox();
+        QCheckBox* roundEndStateBox = new QCheckBox();
         Theme::initCheckbox(roundEndStateBox);
         roundEndStateBox->setText(tr("Round end"));
         roundEndStateBox->setChecked(m_part->rounded);
-        
+
         connect(roundEndStateBox, &QCheckBox::stateChanged, this, [=]() {
             emit setPartRoundState(m_partId, roundEndStateBox->isChecked());
             emit groupOperationAdded();
         });
 
-        QHBoxLayout *optionsLayout = new QHBoxLayout;
+        QHBoxLayout* optionsLayout = new QHBoxLayout;
         optionsLayout->addStretch();
         optionsLayout->addWidget(roundEndStateBox);
         optionsLayout->addWidget(chamferStateBox);
         optionsLayout->addWidget(subdivStateBox);
 
-        QVBoxLayout *cutFaceLayout = new QVBoxLayout;
+        QVBoxLayout* cutFaceLayout = new QVBoxLayout;
         cutFaceLayout->addLayout(rotationLayout);
         cutFaceLayout->addLayout(optionsLayout);
 
@@ -188,7 +188,7 @@ ComponentPropertyWidget::ComponentPropertyWidget(Document *document,
         cutFaceGroupBox->setLayout(cutFaceLayout);
     }
 
-    QVBoxLayout *mainLayout = new QVBoxLayout;
+    QVBoxLayout* mainLayout = new QVBoxLayout;
     mainLayout->addLayout(colorLayout);
     if (nullptr != deformGroupBox)
         mainLayout->addWidget(deformGroupBox);
@@ -216,10 +216,10 @@ ComponentPropertyWidget::ComponentPropertyWidget(Document *document,
 void ComponentPropertyWidget::preparePartIds()
 {
     std::unordered_set<dust3d::Uuid> addedPartIdSet;
-    for (const auto &componentId: m_componentIds) {
+    for (const auto& componentId : m_componentIds) {
         std::vector<dust3d::Uuid> partIds;
         m_document->collectComponentDescendantParts(componentId, partIds);
-        for (const auto &it: partIds) {
+        for (const auto& it : partIds) {
             if (addedPartIdSet.insert(it).second)
                 m_partIds.emplace_back(it);
         }
@@ -234,18 +234,18 @@ void ComponentPropertyWidget::preparePartIds()
 QColor ComponentPropertyWidget::lastColor()
 {
     QColor color = Qt::white;
-    std::map<QString, int> colorMap; 
+    std::map<QString, int> colorMap;
-    for (const auto &partId: m_partIds) {
+    for (const auto& partId : m_partIds) {
-        const SkeletonPart *part = m_document->findPart(partId);
+        const SkeletonPart* part = m_document->findPart(partId);
         if (nullptr == part)
             continue;
         colorMap[part->color.name()]++;
     }
     if (!colorMap.empty()) {
-        color = std::max_element(colorMap.begin(), colorMap.end(), 
+        color = std::max_element(colorMap.begin(), colorMap.end(),
-                [](const std::map<QString, int>::value_type &a, const std::map<QString, int>::value_type &b) {
+            [](const std::map<QString, int>::value_type& a, const std::map<QString, int>::value_type& b) {
-            return a.second < b.second;
+                return a.second < b.second;
-        })->first;
+            })->first;
     }
     return color;
 }
@@ -258,7 +258,7 @@ void ComponentPropertyWidget::showColorDialog()
     if (!color.isValid())
         return;
 
-    for (const auto &partId: m_partIds) {
+    for (const auto& partId : m_partIds) {
         emit setPartColorState(partId, true, color);
     }
     emit groupOperationAdded();

application/sources/component_property_widget.h

@@ -1,39 +1,40 @@
 #ifndef DUST3D_APPLICATION_COMPONENT_PROPERTY_WIDGET_H_
 #define DUST3D_APPLICATION_COMPONENT_PROPERTY_WIDGET_H_
 
-#include <dust3d/base/uuid.h>
 #include <QWidget>
+#include <dust3d/base/uuid.h>
 
 class Document;
 class SkeletonPart;
 
-class ComponentPropertyWidget: public QWidget
+class ComponentPropertyWidget : public QWidget {
-{
     Q_OBJECT
 signals:
     void beginColorPicking();
     void endColorPicking();
-    void setPartColorState(const dust3d::Uuid &partId, bool hasColor, const QColor &color);
+    void setPartColorState(const dust3d::Uuid& partId, bool hasColor, const QColor& color);
-    void setPartDeformThickness(const dust3d::Uuid &partId, float thickness);
+    void setPartDeformThickness(const dust3d::Uuid& partId, float thickness);
-    void setPartDeformWidth(const dust3d::Uuid &partId, float width);
+    void setPartDeformWidth(const dust3d::Uuid& partId, float width);
-    void setPartDeformUnified(const dust3d::Uuid &partId, bool unified);
+    void setPartDeformUnified(const dust3d::Uuid& partId, bool unified);
-    void setPartSubdivState(const dust3d::Uuid &partId, bool subdived);
+    void setPartSubdivState(const dust3d::Uuid& partId, bool subdived);
-    void setPartChamferState(const dust3d::Uuid &partId, bool chamfered);
+    void setPartChamferState(const dust3d::Uuid& partId, bool chamfered);
-    void setPartRoundState(const dust3d::Uuid &partId, bool rounded);
+    void setPartRoundState(const dust3d::Uuid& partId, bool rounded);
-    void setPartCutRotation(const dust3d::Uuid &partId, float cutRotation);
+    void setPartCutRotation(const dust3d::Uuid& partId, float cutRotation);
     void groupOperationAdded();
+
 public:
-    ComponentPropertyWidget(Document *document, 
+    ComponentPropertyWidget(Document* document,
-        const std::vector<dust3d::Uuid> &componentIds, 
+        const std::vector<dust3d::Uuid>& componentIds,
-        QWidget *parent=nullptr);
+        QWidget* parent = nullptr);
 public slots:
     void showColorDialog();
+
 private:
-    Document *m_document = nullptr;
+    Document* m_document = nullptr;
     std::vector<dust3d::Uuid> m_componentIds;
     std::vector<dust3d::Uuid> m_partIds;
     dust3d::Uuid m_partId;
-    const SkeletonPart *m_part = nullptr;
+    const SkeletonPart* m_part = nullptr;
     QColor m_color;
     QColor lastColor();
     void preparePartIds();

application/sources/cut_face_preview.cc

@@ -1,15 +1,15 @@
-#include <QPainter>
-#include <QPainterPath>
 #include "cut_face_preview.h"
 #include "theme.h"
+#include <QPainter>
+#include <QPainterPath>
 
-static std::map<int, QImage *> g_standardCutFaceMap;
+static std::map<int, QImage*> g_standardCutFaceMap;
 
-QImage *buildCutFaceTemplatePreviewImage(const std::vector<dust3d::Vector2> &cutTemplate)
+QImage* buildCutFaceTemplatePreviewImage(const std::vector<dust3d::Vector2>& cutTemplate)
 {
-    QImage *image = new QImage(Theme::partPreviewImageSize, Theme::partPreviewImageSize, QImage::Format_ARGB32);
+    QImage* image = new QImage(Theme::partPreviewImageSize, Theme::partPreviewImageSize, QImage::Format_ARGB32);
     image->fill(Qt::transparent);
-    
+
     if (cutTemplate.empty())
         return image;
 
@@ -17,41 +17,41 @@ QImage *buildCutFaceTemplatePreviewImage(const std::vector<dust3d::Vector2> &cut
     painter.begin(image);
     painter.setRenderHint(QPainter::Antialiasing);
     painter.setRenderHint(QPainter::HighQualityAntialiasing);
-    
+
     QPen pen(Theme::red, 2);
     painter.setPen(pen);
-    
+
     QBrush brush;
     brush.setColor(Theme::white);
     brush.setStyle(Qt::SolidPattern);
-    
+
     painter.setBrush(brush);
-    
+
     const float scale = 0.7f;
     QPolygon polygon;
     for (size_t i = 0; i <= cutTemplate.size(); ++i) {
-        const auto &it = cutTemplate[i % cutTemplate.size()];
+        const auto& it = cutTemplate[i % cutTemplate.size()];
-        polygon.append(QPoint((it.x() * scale + 1.0) * 0.5 * Theme::partPreviewImageSize, 
+        polygon.append(QPoint((it.x() * scale + 1.0) * 0.5 * Theme::partPreviewImageSize,
             (it.y() * scale + 1.0) * 0.5 * Theme::partPreviewImageSize));
     }
-    
+
     QPainterPath path;
     path.addPolygon(polygon);
     painter.fillPath(path, brush);
     painter.drawPath(path);
-    
+
     painter.end();
 
     return image;
 }
 
-const QImage *cutFacePreviewImage(dust3d::CutFace cutFace)
+const QImage* cutFacePreviewImage(dust3d::CutFace cutFace)
 {
     auto findItem = g_standardCutFaceMap.find((int)cutFace);
     if (findItem != g_standardCutFaceMap.end())
         return findItem->second;
     std::vector<dust3d::Vector2> cutTemplate = dust3d::CutFaceToPoints(cutFace);
-    QImage *image = buildCutFaceTemplatePreviewImage(cutTemplate);
+    QImage* image = buildCutFaceTemplatePreviewImage(cutTemplate);
-    g_standardCutFaceMap.insert({(int)cutFace, image});
+    g_standardCutFaceMap.insert({ (int)cutFace, image });
     return image;
 }

application/sources/cut_face_preview.h

@@ -4,7 +4,7 @@
 #include <QImage>
 #include <dust3d/base/cut_face.h>
 
-QImage *buildCutFaceTemplatePreviewImage(const std::vector<dust3d::Vector2> &cutTemplate);
+QImage* buildCutFaceTemplatePreviewImage(const std::vector<dust3d::Vector2>& cutTemplate);
-const QImage *cutFacePreviewImage(dust3d::CutFace cutFace);
+const QImage* cutFacePreviewImage(dust3d::CutFace cutFace);
 
 #endif

application/sources/dds_file.cc

@@ -1,10 +1,10 @@
-#include <QtGlobal>
-#include <QFile>
-#include <QDebug>
-#include <QtEndian>
-#include <QByteArray>
-#include <QOpenGLPixelTransferOptions>
 #include "dds_file.h"
+#include <QByteArray>
+#include <QDebug>
+#include <QFile>
+#include <QOpenGLPixelTransferOptions>
+#include <QtEndian>
+#include <QtGlobal>
 
 #ifndef _WIN32
 typedef quint32 DWORD;
@@ -37,20 +37,20 @@ typedef enum {
 } DDS_CAPS2_FLAGS;
 
 typedef struct {
-    DWORD           dwSize;
+    DWORD dwSize;
-    DWORD           dwFlags;
+    DWORD dwFlags;
-    DWORD           dwHeight;
+    DWORD dwHeight;
-    DWORD           dwWidth;
+    DWORD dwWidth;
-    DWORD           dwPitchOrLinearSize;
+    DWORD dwPitchOrLinearSize;
-    DWORD           dwDepth;
+    DWORD dwDepth;
-    DWORD           dwMipMapCount;
+    DWORD dwMipMapCount;
-    DWORD           dwReserved1[11];
+    DWORD dwReserved1[11];
     DDS_PIXELFORMAT ddspf;
-    DWORD           dwCaps;
+    DWORD dwCaps;
-    DWORD           dwCaps2;
+    DWORD dwCaps2;
-    DWORD           dwCaps3;
+    DWORD dwCaps3;
-    DWORD           dwCaps4;
+    DWORD dwCaps4;
-    DWORD           dwReserved2;
+    DWORD dwReserved2;
 } DDS_HEADER;
 
 typedef enum {
@@ -176,9 +176,9 @@ typedef enum {
     DXGI_FORMAT_FORCE_UINT
 } DXGI_FORMAT;
 
-static const char *DxgiFormatToString(DXGI_FORMAT dxgiFormat)
+static const char* DxgiFormatToString(DXGI_FORMAT dxgiFormat)
 {
-    static const char *names[] = {
+    static const char* names[] = {
         "DXGI_FORMAT_UNKNOWN",
         "DXGI_FORMAT_R32G32B32A32_TYPELESS",
         "DXGI_FORMAT_R32G32B32A32_FLOAT",
@@ -314,9 +314,9 @@ typedef enum {
     D3D10_RESOURCE_DIMENSION_TEXTURE3D
 } D3D10_RESOURCE_DIMENSION;
 
-static const char *ResourceDimensionToString(D3D10_RESOURCE_DIMENSION resourceDimension)
+static const char* ResourceDimensionToString(D3D10_RESOURCE_DIMENSION resourceDimension)
 {
-    static const char *names[] = {
+    static const char* names[] = {
         "D3D10_RESOURCE_DIMENSION_UNKNOWN",
         "D3D10_RESOURCE_DIMENSION_BUFFER",
         "D3D10_RESOURCE_DIMENSION_TEXTURE1D",
@@ -337,9 +337,9 @@ typedef enum {
     D3D10_RESOURCE_MISC_GDI_COMPATIBLE
 } D3D10_RESOURCE_MISC_FLAG;
 
-static const char *MiscFlagToString(UINT miscFlag)
+static const char* MiscFlagToString(UINT miscFlag)
 {
-    static const char *names[] = {
+    static const char* names[] = {
         "D3D10_RESOURCE_MISC_GENERATE_MIPS",
         "D3D10_RESOURCE_MISC_SHARED",
         "D3D10_RESOURCE_MISC_TEXTURECUBE",
@@ -353,76 +353,76 @@ static const char *MiscFlagToString(UINT miscFlag)
 }
 
 typedef struct {
-    DXGI_FORMAT              dxgiFormat;
+    DXGI_FORMAT dxgiFormat;
     D3D10_RESOURCE_DIMENSION resourceDimension;
-    UINT                     miscFlag;
+    UINT miscFlag;
-    UINT                     arraySize;
+    UINT arraySize;
-    UINT                     miscFlags2;
+    UINT miscFlags2;
 } DDS_HEADER_DXT10;
 
 typedef struct {
-    DWORD               dwMagic;
+    DWORD dwMagic;
-    DDS_HEADER          header;
+    DDS_HEADER header;
-    DDS_HEADER_DXT10    header10;
+    DDS_HEADER_DXT10 header10;
 } DDS_FILE_HEADER;
 
-DdsFileReader::DdsFileReader(const QString &filename) :
+DdsFileReader::DdsFileReader(const QString& filename)
-    m_filename(filename)
+    : m_filename(filename)
-{     
+{
 }
 
 std::unique_ptr<std::vector<std::unique_ptr<QOpenGLTexture>>> DdsFileReader::createOpenGLTextures()
 {
     QFile file(m_filename);
-    
+
     if (!file.open(QIODevice::ReadOnly)) {
         qDebug() << "Open" << m_filename << "failed";
         return nullptr;
     }
-    
+
     DDS_FILE_HEADER fileHeader;
-    if (sizeof(fileHeader) != file.read((char *)&fileHeader, sizeof(fileHeader))) {
+    if (sizeof(fileHeader) != file.read((char*)&fileHeader, sizeof(fileHeader))) {
         qDebug() << "Read DDS file hader failed";
         return nullptr;
     }
-    
+
     if (0x20534444 != qFromLittleEndian<quint32>(&fileHeader.dwMagic)) {
         qDebug() << "Not a DDS file";
         return nullptr;
     }
-    
+
     if (0x30315844 != qFromLittleEndian<quint32>(&fileHeader.header.ddspf.dwFourCC)) {
         qDebug() << "Unsupported DDS file, expected DX10 file";
         return nullptr;
     }
-    
+
     auto caps2 = qFromLittleEndian<quint32>(&fileHeader.header.dwCaps2);
     if (!(DDSCAPS2_CUBEMAP & caps2)) {
         qDebug() << "Unsupported DDS file, expected CUBEMAP file";
         return nullptr;
     }
-    
+
     //qDebug() << "Start anyalize DDS file...";
-    
+
     int width = qFromLittleEndian<quint32>(&fileHeader.header.dwWidth);
     int height = qFromLittleEndian<quint32>(&fileHeader.header.dwHeight);
-    
+
     //qDebug() << "DDS size:" << width << "X" << height;
-    
+
     //auto pitchOrLinearSize = qFromLittleEndian<quint32>(&fileHeader.header.dwPitchOrLinearSize);
     //qDebug() << "DDS pitch or linear size:" << pitchOrLinearSize;
-    
+
     auto arraySize = qFromLittleEndian<quint32>(&fileHeader.header10.arraySize);
     //qDebug() << "DDS array size:" << arraySize;
-    
+
     auto mipMapCount = qFromLittleEndian<quint32>(&fileHeader.header.dwMipMapCount);
     //qDebug() << "DDS mip map count:" << mipMapCount;
-    
+
     DXGI_FORMAT dxgiFormat = (DXGI_FORMAT)qFromLittleEndian<quint32>(&fileHeader.header10.dxgiFormat);
     //qDebug() << "DDS dxgi format:" << DxgiFormatToString(dxgiFormat);
     //qDebug() << "DDS resource dimension:" << ResourceDimensionToString((D3D10_RESOURCE_DIMENSION)qFromLittleEndian<quint32>(&fileHeader.header10.resourceDimension));
     //qDebug() << "DDS misc flag:" << MiscFlagToString((UINT)qFromLittleEndian<quint32>(&fileHeader.header10.miscFlag));
-    
+
     quint32 faces = 0;
     if (DDSCAPS2_CUBEMAP_POSITIVEX & caps2) {
         //qDebug() << "DDS found +x";
@@ -448,20 +448,20 @@ std::unique_ptr<std::vector<std::unique_ptr<QOpenGLTexture>>> DdsFileReader::cre
         //qDebug() << "DDS found -z";
         ++faces;
     }
-    
+
     if (6 != faces) {
         qDebug() << "Unsupported DDS file, expected six faces";
         return nullptr;
     }
-    
+
     if (1 != arraySize) {
         qDebug() << "Unsupported DDS file, expected one layer";
         return nullptr;
     }
-    
+
     if (DXGI_FORMAT_R16G16B16A16_FLOAT != dxgiFormat) {
         qDebug() << "Unsupported DDS file, expected dxgi format: DXGI_FORMAT_R16G16B16A16_FLOAT";
-        return nullptr; 
+        return nullptr;
     }
     int components = 8;
     int oneFaceSize = 0;
@@ -479,7 +479,7 @@ std::unique_ptr<std::vector<std::unique_ptr<QOpenGLTexture>>> DdsFileReader::cre
     }
 
     int depth = 1;
-    
+
     auto textures = std::make_unique<std::vector<std::unique_ptr<QOpenGLTexture>>>();
     textures->resize(6);
 
@@ -488,7 +488,7 @@ std::unique_ptr<std::vector<std::unique_ptr<QOpenGLTexture>>> DdsFileReader::cre
         for (quint32 face = 0; face < faces; ++face) {
             for (quint32 level = 0; level < mipMapCount; ++level) {
                 if (0 == layer && 0 == level) {
-                    QOpenGLTexture *texture = new QOpenGLTexture(QOpenGLTexture::Target2D);
+                    QOpenGLTexture* texture = new QOpenGLTexture(QOpenGLTexture::Target2D);
                     texture->setMinificationFilter(QOpenGLTexture::NearestMipMapNearest);
                     texture->setMagnificationFilter(QOpenGLTexture::Nearest);
                     texture->setFormat(QOpenGLTexture::RGBA16F);
@@ -504,58 +504,58 @@ std::unique_ptr<std::vector<std::unique_ptr<QOpenGLTexture>>> DdsFileReader::cre
     return std::move(textures);
 }
 
-QOpenGLTexture *DdsFileReader::createOpenGLTexture()
+QOpenGLTexture* DdsFileReader::createOpenGLTexture()
 {
     QFile file(m_filename);
-    
+
     if (!file.open(QIODevice::ReadOnly)) {
         qDebug() << "Open" << m_filename << "failed";
         return nullptr;
     }
-    
+
     DDS_FILE_HEADER fileHeader;
-    if (sizeof(fileHeader) != file.read((char *)&fileHeader, sizeof(fileHeader))) {
+    if (sizeof(fileHeader) != file.read((char*)&fileHeader, sizeof(fileHeader))) {
         qDebug() << "Read DDS file hader failed";
         return nullptr;
     }
-    
+
     if (0x20534444 != qFromLittleEndian<quint32>(&fileHeader.dwMagic)) {
         qDebug() << "Not a DDS file";
         return nullptr;
     }
-    
+
     if (0x30315844 != qFromLittleEndian<quint32>(&fileHeader.header.ddspf.dwFourCC)) {
         qDebug() << "Unsupported DDS file, expected DX10 file";
         return nullptr;
     }
-    
+
     auto caps2 = qFromLittleEndian<quint32>(&fileHeader.header.dwCaps2);
     if (!(DDSCAPS2_CUBEMAP & caps2)) {
         qDebug() << "Unsupported DDS file, expected CUBEMAP file";
         return nullptr;
     }
-    
+
     //qDebug() << "Start anyalize DDS file...";
-    
+
     int width = qFromLittleEndian<quint32>(&fileHeader.header.dwWidth);
     int height = qFromLittleEndian<quint32>(&fileHeader.header.dwHeight);
-    
+
     //qDebug() << "DDS size:" << width << "X" << height;
-    
+
     //auto pitchOrLinearSize = qFromLittleEndian<quint32>(&fileHeader.header.dwPitchOrLinearSize);
     //qDebug() << "DDS pitch or linear size:" << pitchOrLinearSize;
-    
+
     auto arraySize = qFromLittleEndian<quint32>(&fileHeader.header10.arraySize);
     //qDebug() << "DDS array size:" << arraySize;
-    
+
     auto mipMapCount = qFromLittleEndian<quint32>(&fileHeader.header.dwMipMapCount);
     //qDebug() << "DDS mip map count:" << mipMapCount;
-    
+
     DXGI_FORMAT dxgiFormat = (DXGI_FORMAT)qFromLittleEndian<quint32>(&fileHeader.header10.dxgiFormat);
     //qDebug() << "DDS dxgi format:" << DxgiFormatToString(dxgiFormat);
     //qDebug() << "DDS resource dimension:" << ResourceDimensionToString((D3D10_RESOURCE_DIMENSION)qFromLittleEndian<quint32>(&fileHeader.header10.resourceDimension));
     //qDebug() << "DDS misc flag:" << MiscFlagToString((UINT)qFromLittleEndian<quint32>(&fileHeader.header10.miscFlag));
-    
+
     quint32 faces = 0;
     if (DDSCAPS2_CUBEMAP_POSITIVEX & caps2) {
         //qDebug() << "DDS found +x";
@@ -581,20 +581,20 @@ QOpenGLTexture *DdsFileReader::createOpenGLTexture()
         //qDebug() << "DDS found -z";
         ++faces;
     }
-    
+
     if (6 != faces) {
         qDebug() << "Unsupported DDS file, expected six faces";
         return nullptr;
     }
-    
+
     if (1 != arraySize) {
         qDebug() << "Unsupported DDS file, expected one layer";
         return nullptr;
     }
-    
+
     if (DXGI_FORMAT_R16G16B16A16_FLOAT != dxgiFormat) {
         qDebug() << "Unsupported DDS file, expected dxgi format: DXGI_FORMAT_R16G16B16A16_FLOAT";
-        return nullptr; 
+        return nullptr;
     }
     int components = 8;
     int oneFaceSize = 0;
@@ -610,9 +610,9 @@ QOpenGLTexture *DdsFileReader::createOpenGLTexture()
         qDebug() << "DDS file invalid, expected total size:" << totalSize << "read size:" << data.size();
         return nullptr;
     }
-    
+
     int depth = 1;
-    
+
     QOpenGLTexture* texture = new QOpenGLTexture(QOpenGLTexture::TargetCubeMap);
     texture->setFormat(QOpenGLTexture::RGBA16F);
     texture->setSize(width, height, depth);
@@ -620,37 +620,37 @@ QOpenGLTexture *DdsFileReader::createOpenGLTexture()
     texture->setMipBaseLevel(0);
     texture->setMipMaxLevel(mipMapCount - 1);
     texture->setMipLevels(mipMapCount);
-    
+
     if (!texture->create()) {
         qDebug() << "QOpenGLTexture::create failed";
         delete texture;
         return nullptr;
     }
-    
+
     texture->allocateStorage();
     if (!texture->isStorageAllocated()) {
         qDebug() << "QOpenGLTexture::isStorageAllocated false";
         delete texture;
         return nullptr;
     }
-    
+
     uint64_t dataOffset = 0;
     for (quint32 layer = 0; layer < arraySize; ++layer) {
         for (quint32 face = 0; face < faces; ++face) {
             for (quint32 level = 0; level < mipMapCount; ++level) {
                 QOpenGLPixelTransferOptions uploadOptions;
                 uploadOptions.setAlignment(1);
-                texture->setData(level, 
+                texture->setData(level,
-                    layer, 
+                    layer,
-                    static_cast<QOpenGLTexture::CubeMapFace>(QOpenGLTexture::CubeMapPositiveX + face), 
+                    static_cast<QOpenGLTexture::CubeMapFace>(QOpenGLTexture::CubeMapPositiveX + face),
-                    QOpenGLTexture::RGBA, 
+                    QOpenGLTexture::RGBA,
-                    QOpenGLTexture::Float16, 
+                    QOpenGLTexture::Float16,
-                    data.constData() + dataOffset, 
+                    data.constData() + dataOffset,
                     &uploadOptions);
                 dataOffset += calculateOneFaceSizeAtLevel(level);
             }
         }
     }
-    
+
     return texture;
 }

application/sources/dds_file.h

@@ -1,16 +1,16 @@
 #ifndef DUST3D_APPLICATION_DDS_FILE_H_
 #define DUST3D_APPLICATION_DDS_FILE_H_
 
-#include <memory>
-#include <QString>
 #include <QOpenGLTexture>
+#include <QString>
+#include <memory>
 
-class DdsFileReader
+class DdsFileReader {
-{
 public:
-    DdsFileReader(const QString &filename);
+    DdsFileReader(const QString& filename);
-    QOpenGLTexture *createOpenGLTexture();
+    QOpenGLTexture* createOpenGLTexture();
     std::unique_ptr<std::vector<std::unique_ptr<QOpenGLTexture>>> createOpenGLTextures();
+
 private:
     QString m_filename;
 };

application/sources/debug.cc

@@ -1,13 +1,13 @@
 #include "debug.h"
 
-QDebug operator<<(QDebug debug, const dust3d::Uuid &uuid)
+QDebug operator<<(QDebug debug, const dust3d::Uuid& uuid)
 {
     QDebugStateSaver stateSaver(debug);
     debug.nospace() << uuid.toString().c_str();
     return debug;
 }
 
-QDebug operator<<(QDebug debug, const std::string &string)
+QDebug operator<<(QDebug debug, const std::string& string)
 {
     QDebugStateSaver stateSaver(debug);
     debug.nospace() << string.c_str();

application/sources/debug.h

@@ -4,7 +4,7 @@
 #include <QDebug>
 #include <dust3d/base/uuid.h>
 
-QDebug operator<<(QDebug debug, const dust3d::Uuid &uuid);
+QDebug operator<<(QDebug debug, const dust3d::Uuid& uuid);
-QDebug operator<<(QDebug debug, const std::string &string);
+QDebug operator<<(QDebug debug, const std::string& string);
 
 #endif

application/sources/document.cc

@@ -1,34 +1,34 @@
-#include <QFileDialog>
-#include <QDebug>
-#include <QThread>
-#include <QGuiApplication>
-#include <QClipboard>
-#include <QMimeData>
-#include <QApplication>
-#include <QVector3D>
-#include <functional>
-#include <QtCore/qbuffer.h>
-#include <QElapsedTimer>
-#include <queue>
-#include <dust3d/base/snapshot_xml.h>
-#include <dust3d/base/texture_type.h>
 #include "document.h"
 #include "image_forever.h"
+#include "material_previews_generator.h"
 #include "mesh_generator.h"
 #include "mesh_result_post_processor.h"
 #include "texture_generator.h"
-#include "material_previews_generator.h"
+#include <QApplication>
+#include <QClipboard>
+#include <QDebug>
+#include <QElapsedTimer>
+#include <QFileDialog>
+#include <QGuiApplication>
+#include <QMimeData>
+#include <QThread>
+#include <QVector3D>
+#include <QtCore/qbuffer.h>
+#include <dust3d/base/snapshot_xml.h>
+#include <dust3d/base/texture_type.h>
+#include <functional>
+#include <queue>
 
 unsigned long Document::m_maxSnapshot = 1000;
 
-Document::Document() :
+Document::Document()
-    SkeletonDocument()
+    : SkeletonDocument()
 {
 }
 
 Document::~Document()
 {
-    delete (dust3d::MeshGenerator::GeneratedCacheContext *)m_generatedCacheContext;
+    delete (dust3d::MeshGenerator::GeneratedCacheContext*)m_generatedCacheContext;
     delete m_resultMesh;
     delete m_postProcessedObject;
     delete textureImage;
@@ -55,7 +55,7 @@ bool Document::originSettled() const
     return !qFuzzyIsNull(getOriginX()) && !qFuzzyIsNull(getOriginY()) && !qFuzzyIsNull(getOriginZ());
 }
 
-const Material *Document::findMaterial(dust3d::Uuid materialId) const
+const Material* Document::findMaterial(dust3d::Uuid materialId) const
 {
     auto it = materialMap.find(materialId);
     if (it == materialMap.end())
@@ -104,8 +104,7 @@ void Document::setNodeCutFaceLinkedId(dust3d::Uuid nodeId, dust3d::Uuid linkedId
         qDebug() << "Node not found:" << nodeId;
         return;
     }
-    if (node->second.cutFace == dust3d::CutFace::UserDefined &&
+    if (node->second.cutFace == dust3d::CutFace::UserDefined && node->second.cutFaceLinkedId == linkedId)
-            node->second.cutFaceLinkedId == linkedId)
         return;
     node->second.setCutFaceLinkedId(linkedId);
     auto part = partMap.find(node->second.partId);
@@ -132,7 +131,7 @@ void Document::clearNodeCutFaceSettings(dust3d::Uuid nodeId)
     emit skeletonChanged();
 }
 
-void Document::updateTurnaround(const QImage &image)
+void Document::updateTurnaround(const QImage& image)
 {
     turnaround = image;
     turnaroundPngByteArray.clear();
@@ -149,47 +148,47 @@ void Document::clearTurnaround()
     emit turnaroundChanged();
 }
 
-void Document::updateTextureImage(QImage *image)
+void Document::updateTextureImage(QImage* image)
 {
     delete textureImageByteArray;
     textureImageByteArray = nullptr;
-    
+
     delete textureImage;
     textureImage = image;
 }
 
-void Document::updateTextureNormalImage(QImage *image)
+void Document::updateTextureNormalImage(QImage* image)
 {
     delete textureNormalImageByteArray;
     textureNormalImageByteArray = nullptr;
-    
+
     delete textureNormalImage;
     textureNormalImage = image;
 }
 
-void Document::updateTextureMetalnessImage(QImage *image)
+void Document::updateTextureMetalnessImage(QImage* image)
 {
     delete textureMetalnessImageByteArray;
     textureMetalnessImageByteArray = nullptr;
-    
+
     delete textureMetalnessImage;
     textureMetalnessImage = image;
 }
 
-void Document::updateTextureRoughnessImage(QImage *image)
+void Document::updateTextureRoughnessImage(QImage* image)
 {
     delete textureRoughnessImageByteArray;
     textureRoughnessImageByteArray = nullptr;
-    
+
     delete textureRoughnessImage;
     textureRoughnessImage = image;
 }
 
-void Document::updateTextureAmbientOcclusionImage(QImage *image)
+void Document::updateTextureAmbientOcclusionImage(QImage* image)
 {
     delete textureAmbientOcclusionImageByteArray;
     textureAmbientOcclusionImageByteArray = nullptr;
-    
+
     delete textureAmbientOcclusionImage;
     textureAmbientOcclusionImage = image;
 }
@@ -198,28 +197,27 @@ void Document::setEditMode(SkeletonDocumentEditMode mode)
 {
     if (editMode == mode)
         return;
-    
+
     editMode = mode;
     emit editModeChanged();
 }
 
-void Document::toSnapshot(dust3d::Snapshot *snapshot, const std::set<dust3d::Uuid> &limitNodeIds,
+void Document::toSnapshot(dust3d::Snapshot* snapshot, const std::set<dust3d::Uuid>& limitNodeIds,
     DocumentToSnapshotFor forWhat,
-    const std::set<dust3d::Uuid> &limitMaterialIds) const
+    const std::set<dust3d::Uuid>& limitMaterialIds) const
 {
-    if (DocumentToSnapshotFor::Document == forWhat ||
+    if (DocumentToSnapshotFor::Document == forWhat || DocumentToSnapshotFor::Nodes == forWhat) {
-            DocumentToSnapshotFor::Nodes == forWhat) {
         std::set<dust3d::Uuid> limitPartIds;
         std::set<dust3d::Uuid> limitComponentIds;
-        for (const auto &nodeId: limitNodeIds) {
+        for (const auto& nodeId : limitNodeIds) {
-            const SkeletonNode *node = findNode(nodeId);
+            const SkeletonNode* node = findNode(nodeId);
             if (!node)
                 continue;
-            const SkeletonPart *part = findPart(node->partId);
+            const SkeletonPart* part = findPart(node->partId);
             if (!part)
                 continue;
             limitPartIds.insert(node->partId);
-            const SkeletonComponent *component = findComponent(part->componentId);
+            const SkeletonComponent* component = findComponent(part->componentId);
             while (component) {
                 limitComponentIds.insert(component->id);
                 if (component->id.isNull())
@@ -227,7 +225,7 @@ void Document::toSnapshot(dust3d::Snapshot *snapshot, const std::set<dust3d::Uui
                 component = findComponent(component->parentId);
             }
         }
-        for (const auto &partIt : partMap) {
+        for (const auto& partIt : partMap) {
             if (!limitPartIds.empty() && limitPartIds.find(partIt.first) == limitPartIds.end())
                 continue;
             std::map<std::string, std::string> part;
@@ -281,7 +279,7 @@ void Document::toSnapshot(dust3d::Snapshot *snapshot, const std::set<dust3d::Uui
                 part["smooth"] = "true";
             snapshot->parts[part["id"]] = part;
         }
-        for (const auto &nodeIt: nodeMap) {
+        for (const auto& nodeIt : nodeMap) {
             if (!limitNodeIds.empty() && limitNodeIds.find(nodeIt.first) == limitNodeIds.end())
                 continue;
             std::map<std::string, std::string> node;
@@ -305,12 +303,10 @@ void Document::toSnapshot(dust3d::Snapshot *snapshot, const std::set<dust3d::Uui
                 node["name"] = nodeIt.second.name.toUtf8().constData();
             snapshot->nodes[node["id"]] = node;
         }
-        for (const auto &edgeIt: edgeMap) {
+        for (const auto& edgeIt : edgeMap) {
             if (edgeIt.second.nodeIds.size() != 2)
                 continue;
-            if (!limitNodeIds.empty() &&
+            if (!limitNodeIds.empty() && (limitNodeIds.find(edgeIt.second.nodeIds[0]) == limitNodeIds.end() || limitNodeIds.find(edgeIt.second.nodeIds[1]) == limitNodeIds.end()))
-                    (limitNodeIds.find(edgeIt.second.nodeIds[0]) == limitNodeIds.end() ||
-                        limitNodeIds.find(edgeIt.second.nodeIds[1]) == limitNodeIds.end()))
                 continue;
             std::map<std::string, std::string> edge;
             edge["id"] = edgeIt.second.id.toString();
@@ -321,7 +317,7 @@ void Document::toSnapshot(dust3d::Snapshot *snapshot, const std::set<dust3d::Uui
                 edge["name"] = edgeIt.second.name.toUtf8().constData();
             snapshot->edges[edge["id"]] = edge;
         }
-        for (const auto &componentIt: componentMap) {
+        for (const auto& componentIt : componentMap) {
             if (!limitComponentIds.empty() && limitComponentIds.find(componentIt.first) == limitComponentIds.end())
                 continue;
             std::map<std::string, std::string> component;
@@ -332,7 +328,7 @@ void Document::toSnapshot(dust3d::Snapshot *snapshot, const std::set<dust3d::Uui
             component["combineMode"] = CombineModeToString(componentIt.second.combineMode);
             component["__dirty"] = componentIt.second.dirty ? "true" : "false";
             std::vector<std::string> childIdList;
-            for (const auto &childId: componentIt.second.childrenIds) {
+            for (const auto& childId : componentIt.second.childrenIds) {
                 childIdList.push_back(childId.toString());
             }
             std::string children = dust3d::String::join(childIdList, ",");
@@ -349,7 +345,7 @@ void Document::toSnapshot(dust3d::Snapshot *snapshot, const std::set<dust3d::Uui
         }
         if (limitComponentIds.empty() || limitComponentIds.find(dust3d::Uuid()) != limitComponentIds.end()) {
             std::vector<std::string> childIdList;
-            for (const auto &childId: rootComponent.childrenIds) {
+            for (const auto& childId : rootComponent.childrenIds) {
                 childIdList.push_back(childId.toString());
             }
             std::string children = dust3d::String::join(childIdList, ",");
@@ -357,9 +353,8 @@ void Document::toSnapshot(dust3d::Snapshot *snapshot, const std::set<dust3d::Uui
                 snapshot->rootComponent["children"] = children;
         }
     }
-    if (DocumentToSnapshotFor::Document == forWhat ||
+    if (DocumentToSnapshotFor::Document == forWhat || DocumentToSnapshotFor::Materials == forWhat) {
-            DocumentToSnapshotFor::Materials == forWhat) {
+        for (const auto& materialId : materialIdList) {
-        for (const auto &materialId: materialIdList) {
             if (!limitMaterialIds.empty() && limitMaterialIds.find(materialId) == limitMaterialIds.end())
                 continue;
             auto findMaterialResult = materialMap.find(materialId);
@@ -367,16 +362,16 @@ void Document::toSnapshot(dust3d::Snapshot *snapshot, const std::set<dust3d::Uui
                 qDebug() << "Find material failed:" << materialId;
                 continue;
             }
-            auto &materialIt = *findMaterialResult;
+            auto& materialIt = *findMaterialResult;
             std::map<std::string, std::string> material;
             material["id"] = materialIt.second.id.toString();
             material["type"] = "MetalRoughness";
             if (!materialIt.second.name.isEmpty())
                 material["name"] = materialIt.second.name.toUtf8().constData();
             std::vector<std::pair<std::map<std::string, std::string>, std::vector<std::map<std::string, std::string>>>> layers;
-            for (const auto &layer: materialIt.second.layers) {
+            for (const auto& layer : materialIt.second.layers) {
                 std::vector<std::map<std::string, std::string>> maps;
-                for (const auto &mapItem: layer.maps) {
+                for (const auto& mapItem : layer.maps) {
                     std::map<std::string, std::string> textureMap;
                     textureMap["for"] = TextureTypeToString(mapItem.forWhat);
                     textureMap["linkDataType"] = "imageId";
@@ -386,7 +381,7 @@ void Document::toSnapshot(dust3d::Snapshot *snapshot, const std::set<dust3d::Uui
                 std::map<std::string, std::string> layerAttributes;
                 if (!qFuzzyCompare((float)layer.tileScale, (float)1.0))
                     layerAttributes["tileScale"] = std::to_string(layer.tileScale);
-                layers.push_back({layerAttributes, maps});
+                layers.push_back({ layerAttributes, maps });
             }
             snapshot->materials.push_back(std::make_pair(material, layers));
         }
@@ -400,34 +395,31 @@ void Document::toSnapshot(dust3d::Snapshot *snapshot, const std::set<dust3d::Uui
     }
 }
 
-void Document::addFromSnapshot(const dust3d::Snapshot &snapshot, enum SnapshotSource source)
+void Document::addFromSnapshot(const dust3d::Snapshot& snapshot, enum SnapshotSource source)
 {
     bool isOriginChanged = false;
-    if (SnapshotSource::Paste != source &&
+    if (SnapshotSource::Paste != source && SnapshotSource::Import != source) {
-            SnapshotSource::Import != source) {
+        const auto& originXit = snapshot.canvas.find("originX");
-        const auto &originXit = snapshot.canvas.find("originX");
+        const auto& originYit = snapshot.canvas.find("originY");
-        const auto &originYit = snapshot.canvas.find("originY");
+        const auto& originZit = snapshot.canvas.find("originZ");
-        const auto &originZit = snapshot.canvas.find("originZ");
+        if (originXit != snapshot.canvas.end() && originYit != snapshot.canvas.end() && originZit != snapshot.canvas.end()) {
-        if (originXit != snapshot.canvas.end() &&
-                originYit != snapshot.canvas.end() &&
-                originZit != snapshot.canvas.end()) {
             setOriginX(dust3d::String::toFloat(originXit->second));
             setOriginY(dust3d::String::toFloat(originYit->second));
             setOriginZ(dust3d::String::toFloat(originZit->second));
             isOriginChanged = true;
         }
     }
-    
+
     std::set<dust3d::Uuid> newAddedNodeIds;
     std::set<dust3d::Uuid> newAddedEdgeIds;
     std::set<dust3d::Uuid> newAddedPartIds;
     std::set<dust3d::Uuid> newAddedComponentIds;
-    
+
     std::set<dust3d::Uuid> inversePartIds;
-    
+
     std::map<dust3d::Uuid, dust3d::Uuid> oldNewIdMap;
-    for (const auto &materialIt: snapshot.materials) {
+    for (const auto& materialIt : snapshot.materials) {
-        const auto &materialAttributes = materialIt.first;
+        const auto& materialAttributes = materialIt.first;
         auto materialType = dust3d::String::valueOrEmpty(materialAttributes, "type");
         if ("MetalRoughness" != materialType) {
             qDebug() << "Unsupported material type:" << materialType;
@@ -437,15 +429,15 @@ void Document::addFromSnapshot(const dust3d::Snapshot &snapshot, enum SnapshotSo
         dust3d::Uuid newMaterialId = SnapshotSource::Import == source ? oldMaterialId : dust3d::Uuid::createUuid();
         oldNewIdMap[oldMaterialId] = newMaterialId;
         if (materialMap.end() == materialMap.find(newMaterialId)) {
-            auto &newMaterial = materialMap[newMaterialId];
+            auto& newMaterial = materialMap[newMaterialId];
             newMaterial.id = newMaterialId;
             newMaterial.name = dust3d::String::valueOrEmpty(materialAttributes, "name").c_str();
-            for (const auto &layerIt: materialIt.second) {
+            for (const auto& layerIt : materialIt.second) {
                 MaterialLayer layer;
                 auto findTileScale = layerIt.first.find("tileScale");
                 if (findTileScale != layerIt.first.end())
                     layer.tileScale = dust3d::String::toFloat(findTileScale->second);
-                for (const auto &mapItem: layerIt.second) {
+                for (const auto& mapItem : layerIt.second) {
                     auto textureTypeString = dust3d::String::valueOrEmpty(mapItem, "for");
                     auto textureType = dust3d::TextureTypeFromString(textureTypeString.c_str());
                     if (dust3d::TextureType::None == textureType) {
@@ -470,13 +462,13 @@ void Document::addFromSnapshot(const dust3d::Snapshot &snapshot, enum SnapshotSo
         }
     }
     std::map<dust3d::Uuid, dust3d::Uuid> cutFaceLinkedIdModifyMap;
-    for (const auto &partKv: snapshot.parts) {
+    for (const auto& partKv : snapshot.parts) {
         const auto newUuid = dust3d::Uuid::createUuid();
-        SkeletonPart &part = partMap[newUuid];
+        SkeletonPart& part = partMap[newUuid];
         part.id = newUuid;
         oldNewIdMap[dust3d::Uuid(partKv.first)] = part.id;
         part.name = dust3d::String::valueOrEmpty(partKv.second, "name").c_str();
-        const auto &visibleIt = partKv.second.find("visible");
+        const auto& visibleIt = partKv.second.find("visible");
         if (visibleIt != partKv.second.end()) {
             part.visible = dust3d::String::isTrue(visibleIt->second);
         } else {
@@ -490,56 +482,56 @@ void Document::addFromSnapshot(const dust3d::Snapshot &snapshot, enum SnapshotSo
         part.rounded = dust3d::String::isTrue(dust3d::String::valueOrEmpty(partKv.second, "rounded"));
         part.chamfered = dust3d::String::isTrue(dust3d::String::valueOrEmpty(partKv.second, "chamfered"));
         part.target = dust3d::PartTargetFromString(dust3d::String::valueOrEmpty(partKv.second, "target").c_str());
-        const auto &cutRotationIt = partKv.second.find("cutRotation");
+        const auto& cutRotationIt = partKv.second.find("cutRotation");
         if (cutRotationIt != partKv.second.end())
             part.setCutRotation(dust3d::String::toFloat(cutRotationIt->second));
-        const auto &cutFaceIt = partKv.second.find("cutFace");
+        const auto& cutFaceIt = partKv.second.find("cutFace");
         if (cutFaceIt != partKv.second.end()) {
             dust3d::Uuid cutFaceLinkedId = dust3d::Uuid(cutFaceIt->second);
             if (cutFaceLinkedId.isNull()) {
                 part.setCutFace(dust3d::CutFaceFromString(cutFaceIt->second.c_str()));
             } else {
                 part.setCutFaceLinkedId(cutFaceLinkedId);
-                cutFaceLinkedIdModifyMap.insert({part.id, cutFaceLinkedId});
+                cutFaceLinkedIdModifyMap.insert({ part.id, cutFaceLinkedId });
             }
         }
         if (dust3d::String::isTrue(dust3d::String::valueOrEmpty(partKv.second, "inverse")))
             inversePartIds.insert(part.id);
-        const auto &colorIt = partKv.second.find("color");
+        const auto& colorIt = partKv.second.find("color");
         if (colorIt != partKv.second.end()) {
             part.color = QColor(colorIt->second.c_str());
             part.hasColor = true;
         }
-        const auto &colorSolubilityIt = partKv.second.find("colorSolubility");
+        const auto& colorSolubilityIt = partKv.second.find("colorSolubility");
         if (colorSolubilityIt != partKv.second.end())
             part.colorSolubility = dust3d::String::toFloat(colorSolubilityIt->second);
-        const auto &metalnessIt = partKv.second.find("metallic");
+        const auto& metalnessIt = partKv.second.find("metallic");
         if (metalnessIt != partKv.second.end())
             part.metalness = dust3d::String::toFloat(metalnessIt->second);
-        const auto &roughnessIt = partKv.second.find("roughness");
+        const auto& roughnessIt = partKv.second.find("roughness");
         if (roughnessIt != partKv.second.end())
             part.roughness = dust3d::String::toFloat(roughnessIt->second);
-        const auto &deformThicknessIt = partKv.second.find("deformThickness");
+        const auto& deformThicknessIt = partKv.second.find("deformThickness");
         if (deformThicknessIt != partKv.second.end())
             part.setDeformThickness(dust3d::String::toFloat(deformThicknessIt->second));
-        const auto &deformWidthIt = partKv.second.find("deformWidth");
+        const auto& deformWidthIt = partKv.second.find("deformWidth");
         if (deformWidthIt != partKv.second.end())
             part.setDeformWidth(dust3d::String::toFloat(deformWidthIt->second));
-        const auto &deformUnifiedIt = partKv.second.find("deformUnified");
+        const auto& deformUnifiedIt = partKv.second.find("deformUnified");
         if (deformUnifiedIt != partKv.second.end())
             part.deformUnified = dust3d::String::isTrue(dust3d::String::valueOrEmpty(partKv.second, "deformUnified"));
-        const auto &hollowThicknessIt = partKv.second.find("hollowThickness");
+        const auto& hollowThicknessIt = partKv.second.find("hollowThickness");
         if (hollowThicknessIt != partKv.second.end())
             part.hollowThickness = dust3d::String::toFloat(hollowThicknessIt->second);
-        const auto &materialIdIt = partKv.second.find("materialId");
+        const auto& materialIdIt = partKv.second.find("materialId");
         if (materialIdIt != partKv.second.end())
             part.materialId = oldNewIdMap[dust3d::Uuid(materialIdIt->second)];
         part.countershaded = dust3d::String::isTrue(dust3d::String::valueOrEmpty(partKv.second, "countershaded"));
         part.smooth = dust3d::String::isTrue(dust3d::String::valueOrEmpty(partKv.second, "smooth"));
         newAddedPartIds.insert(part.id);
     }
-    for (const auto &it: cutFaceLinkedIdModifyMap) {
+    for (const auto& it : cutFaceLinkedIdModifyMap) {
-        SkeletonPart &part = partMap[it.first];
+        SkeletonPart& part = partMap[it.first];
         auto findNewLinkedId = oldNewIdMap.find(it.second);
         if (findNewLinkedId == oldNewIdMap.end()) {
             if (partMap.find(it.second) == partMap.end()) {
@@ -549,12 +541,8 @@ void Document::addFromSnapshot(const dust3d::Snapshot &snapshot, enum SnapshotSo
             part.setCutFaceLinkedId(findNewLinkedId->second);
         }
     }
-    for (const auto &nodeKv: snapshot.nodes) {
+    for (const auto& nodeKv : snapshot.nodes) {
-        if (nodeKv.second.find("radius") == nodeKv.second.end() ||
+        if (nodeKv.second.find("radius") == nodeKv.second.end() || nodeKv.second.find("x") == nodeKv.second.end() || nodeKv.second.find("y") == nodeKv.second.end() || nodeKv.second.find("z") == nodeKv.second.end() || nodeKv.second.find("partId") == nodeKv.second.end())
-                nodeKv.second.find("x") == nodeKv.second.end() ||
-                nodeKv.second.find("y") == nodeKv.second.end() ||
-                nodeKv.second.find("z") == nodeKv.second.end() ||
-                nodeKv.second.find("partId") == nodeKv.second.end())
             continue;
         dust3d::Uuid oldNodeId = dust3d::Uuid(nodeKv.first);
         SkeletonNode node(nodeMap.find(oldNodeId) == nodeMap.end() ? oldNodeId : dust3d::Uuid::createUuid());
@@ -565,10 +553,10 @@ void Document::addFromSnapshot(const dust3d::Snapshot &snapshot, enum SnapshotSo
         node.setY(dust3d::String::toFloat(dust3d::String::valueOrEmpty(nodeKv.second, "y")));
         node.setZ(dust3d::String::toFloat(dust3d::String::valueOrEmpty(nodeKv.second, "z")));
         node.partId = oldNewIdMap[dust3d::Uuid(dust3d::String::valueOrEmpty(nodeKv.second, "partId"))];
-        const auto &cutRotationIt = nodeKv.second.find("cutRotation");
+        const auto& cutRotationIt = nodeKv.second.find("cutRotation");
         if (cutRotationIt != nodeKv.second.end())
             node.setCutRotation(dust3d::String::toFloat(cutRotationIt->second));
-        const auto &cutFaceIt = nodeKv.second.find("cutFace");
+        const auto& cutFaceIt = nodeKv.second.find("cutFace");
         if (cutFaceIt != nodeKv.second.end()) {
             dust3d::Uuid cutFaceLinkedId = dust3d::Uuid(cutFaceIt->second);
             if (cutFaceLinkedId.isNull()) {
@@ -588,10 +576,8 @@ void Document::addFromSnapshot(const dust3d::Snapshot &snapshot, enum SnapshotSo
         nodeMap[node.id] = node;
         newAddedNodeIds.insert(node.id);
     }
-    for (const auto &edgeKv: snapshot.edges) {
+    for (const auto& edgeKv : snapshot.edges) {
-        if (edgeKv.second.find("from") == edgeKv.second.end() ||
+        if (edgeKv.second.find("from") == edgeKv.second.end() || edgeKv.second.find("to") == edgeKv.second.end() || edgeKv.second.find("partId") == edgeKv.second.end())
-                edgeKv.second.find("to") == edgeKv.second.end() ||
-                edgeKv.second.find("partId") == edgeKv.second.end())
             continue;
         dust3d::Uuid oldEdgeId = dust3d::Uuid(edgeKv.first);
         SkeletonEdge edge(edgeMap.find(oldEdgeId) == edgeMap.end() ? oldEdgeId : dust3d::Uuid::createUuid());
@@ -613,12 +599,12 @@ void Document::addFromSnapshot(const dust3d::Snapshot &snapshot, enum SnapshotSo
         edgeMap[edge.id] = edge;
         newAddedEdgeIds.insert(edge.id);
     }
-    for (const auto &nodeIt: nodeMap) {
+    for (const auto& nodeIt : nodeMap) {
         if (newAddedNodeIds.find(nodeIt.first) == newAddedNodeIds.end())
             continue;
         partMap[nodeIt.second.partId].nodeIds.push_back(nodeIt.first);
     }
-    for (const auto &componentKv: snapshot.components) {
+    for (const auto& componentKv : snapshot.components) {
         QString linkData = dust3d::String::valueOrEmpty(componentKv.second, "linkData").c_str();
         QString linkDataType = dust3d::String::valueOrEmpty(componentKv.second, "linkDataType").c_str();
         SkeletonComponent component(dust3d::Uuid(), linkData, linkDataType);
@@ -642,9 +628,9 @@ void Document::addFromSnapshot(const dust3d::Snapshot &snapshot, enum SnapshotSo
         componentMap.emplace(component.id, std::move(component));
         newAddedComponentIds.insert(component.id);
     }
-    const auto &rootComponentChildren = snapshot.rootComponent.find("children");
+    const auto& rootComponentChildren = snapshot.rootComponent.find("children");
     if (rootComponentChildren != snapshot.rootComponent.end()) {
-        for (const auto &childId: dust3d::String::split(rootComponentChildren->second, ',')) {
+        for (const auto& childId : dust3d::String::split(rootComponentChildren->second, ',')) {
             if (childId.empty())
                 continue;
             dust3d::Uuid componentId = oldNewIdMap[dust3d::Uuid(childId)];
@@ -654,11 +640,11 @@ void Document::addFromSnapshot(const dust3d::Snapshot &snapshot, enum SnapshotSo
             rootComponent.addChild(componentId);
         }
     }
-    for (const auto &componentKv: snapshot.components) {
+    for (const auto& componentKv : snapshot.components) {
         dust3d::Uuid componentId = oldNewIdMap[dust3d::Uuid(componentKv.first)];
         if (componentMap.find(componentId) == componentMap.end())
             continue;
-        for (const auto &childId: dust3d::String::split(dust3d::String::valueOrEmpty(componentKv.second, "children"), ',')) {
+        for (const auto& childId : dust3d::String::split(dust3d::String::valueOrEmpty(componentKv.second, "children"), ',')) {
             if (childId.empty())
                 continue;
             dust3d::Uuid childComponentId = oldNewIdMap[dust3d::Uuid(childId)];
@@ -669,34 +655,34 @@ void Document::addFromSnapshot(const dust3d::Snapshot &snapshot, enum SnapshotSo
             componentMap[childComponentId].parentId = componentId;
         }
     }
-    
+
-    for (const auto &nodeIt: newAddedNodeIds) {
+    for (const auto& nodeIt : newAddedNodeIds) {
         emit nodeAdded(nodeIt);
     }
-    for (const auto &edgeIt: newAddedEdgeIds) {
+    for (const auto& edgeIt : newAddedEdgeIds) {
         emit edgeAdded(edgeIt);
     }
-    for (const auto &partIt : newAddedPartIds) {
+    for (const auto& partIt : newAddedPartIds) {
         emit partAdded(partIt);
     }
-    
+
     emit componentChildrenChanged(dust3d::Uuid());
     if (isOriginChanged)
         emit originChanged();
     emit skeletonChanged();
-    
+
-    for (const auto &partIt : newAddedPartIds) {
+    for (const auto& partIt : newAddedPartIds) {
         emit partVisibleStateChanged(partIt);
     }
-    
+
     emit uncheckAll();
-    for (const auto &nodeIt: newAddedNodeIds) {
+    for (const auto& nodeIt : newAddedNodeIds) {
         emit checkNode(nodeIt);
     }
-    for (const auto &edgeIt: newAddedEdgeIds) {
+    for (const auto& edgeIt : newAddedEdgeIds) {
         emit checkEdge(edgeIt);
     }
-    
+
     if (!snapshot.materials.empty())
         emit materialListChanged();
 }
@@ -722,22 +708,22 @@ void Document::reset()
     emit skeletonChanged();
 }
 
-void Document::fromSnapshot(const dust3d::Snapshot &snapshot)
+void Document::fromSnapshot(const dust3d::Snapshot& snapshot)
 {
     reset();
     addFromSnapshot(snapshot, SnapshotSource::Unknown);
     emit uncheckAll();
 }
 
-ModelMesh *Document::takeResultMesh()
+ModelMesh* Document::takeResultMesh()
 {
     if (nullptr == m_resultMesh)
         return nullptr;
-    ModelMesh *resultMesh = new ModelMesh(*m_resultMesh);
+    ModelMesh* resultMesh = new ModelMesh(*m_resultMesh);
     return resultMesh;
 }
 
-MonochromeMesh *Document::takeWireframeMesh()
+MonochromeMesh* Document::takeWireframeMesh()
 {
     if (nullptr == m_wireframeMesh)
         return nullptr;
@@ -749,51 +735,51 @@ bool Document::isMeshGenerationSucceed()
     return m_isMeshGenerationSucceed;
 }
 
-ModelMesh *Document::takeResultTextureMesh()
+ModelMesh* Document::takeResultTextureMesh()
 {
     if (nullptr == m_resultTextureMesh)
         return nullptr;
-    ModelMesh *resultTextureMesh = new ModelMesh(*m_resultTextureMesh);
+    ModelMesh* resultTextureMesh = new ModelMesh(*m_resultTextureMesh);
     return resultTextureMesh;
 }
 
 void Document::meshReady()
 {
-    ModelMesh *resultMesh = m_meshGenerator->takeResultMesh();
+    ModelMesh* resultMesh = m_meshGenerator->takeResultMesh();
     m_wireframeMesh.reset(m_meshGenerator->takeWireframeMesh());
-    dust3d::Object *object = m_meshGenerator->takeObject();
+    dust3d::Object* object = m_meshGenerator->takeObject();
     bool isSuccessful = m_meshGenerator->isSuccessful();
-    
+
     std::unique_ptr<std::map<dust3d::Uuid, std::unique_ptr<ModelMesh>>> componentPreviewMeshes;
     componentPreviewMeshes.reset(m_meshGenerator->takeComponentPreviewMeshes());
     bool componentPreviewsChanged = componentPreviewMeshes && !componentPreviewMeshes->empty();
     if (componentPreviewsChanged) {
-        for (auto &it: *componentPreviewMeshes) {
+        for (auto& it : *componentPreviewMeshes) {
             setComponentPreviewMesh(it.first, std::move(it.second));
         }
         emit resultComponentPreviewMeshesChanged();
     }
-    
+
     delete m_resultMesh;
     m_resultMesh = resultMesh;
-    
+
     m_isMeshGenerationSucceed = isSuccessful;
-    
+
     delete m_currentObject;
     m_currentObject = object;
-    
+
     if (nullptr == m_resultMesh) {
         qDebug() << "Result mesh is null";
     }
-    
+
     delete m_meshGenerator;
     m_meshGenerator = nullptr;
-    
+
     qDebug() << "Mesh generation done";
-    
+
     m_isPostProcessResultObsolete = true;
     emit resultMeshChanged();
-    
+
     if (m_isResultMeshObsolete) {
         generateMesh();
     }
@@ -843,18 +829,18 @@ void Document::generateMesh()
         m_isResultMeshObsolete = true;
         return;
     }
-    
+
     emit meshGenerating();
-    
+
     qDebug() << "Mesh generating..";
-    
+
     settleOrigin();
-    
+
     m_isResultMeshObsolete = false;
-    
+
-    QThread *thread = new QThread;
+    QThread* thread = new QThread;
-    
+
-    dust3d::Snapshot *snapshot = new dust3d::Snapshot;
+    dust3d::Snapshot* snapshot = new dust3d::Snapshot;
     toSnapshot(snapshot);
     resetDirtyFlags();
     m_meshGenerator = new MeshGenerator(snapshot);
@@ -862,7 +848,7 @@ void Document::generateMesh()
     m_meshGenerator->setDefaultPartColor(dust3d::Color::createWhite());
     if (nullptr == m_generatedCacheContext)
         m_generatedCacheContext = new MeshGenerator::GeneratedCacheContext;
-    m_meshGenerator->setGeneratedCacheContext((dust3d::MeshGenerator::GeneratedCacheContext *)m_generatedCacheContext);
+    m_meshGenerator->setGeneratedCacheContext((dust3d::MeshGenerator::GeneratedCacheContext*)m_generatedCacheContext);
     if (!m_smoothNormal) {
         m_meshGenerator->setSmoothShadingThresholdAngleDegrees(0);
     }
@@ -880,16 +866,16 @@ void Document::generateTexture()
         m_isTextureObsolete = true;
         return;
     }
-    
+
     qDebug() << "Texture guide generating..";
     emit textureGenerating();
-    
+
     m_isTextureObsolete = false;
-    
+
-    dust3d::Snapshot *snapshot = new dust3d::Snapshot;
+    dust3d::Snapshot* snapshot = new dust3d::Snapshot;
     toSnapshot(snapshot);
-    
+
-    QThread *thread = new QThread;
+    QThread* thread = new QThread;
     m_textureGenerator = new TextureGenerator(*m_postProcessedObject, snapshot);
     m_textureGenerator->moveToThread(thread);
     connect(thread, &QThread::started, m_textureGenerator, &TextureGenerator::process);
@@ -906,21 +892,21 @@ void Document::textureReady()
     updateTextureMetalnessImage(m_textureGenerator->takeResultTextureMetalnessImage());
     updateTextureRoughnessImage(m_textureGenerator->takeResultTextureRoughnessImage());
     updateTextureAmbientOcclusionImage(m_textureGenerator->takeResultTextureAmbientOcclusionImage());
-    
+
     delete m_resultTextureMesh;
     m_resultTextureMesh = m_textureGenerator->takeResultMesh();
-    
+
     m_postProcessedObject->alphaEnabled = m_textureGenerator->hasTransparencySettings();
 
     m_textureImageUpdateVersion++;
-    
+
     delete m_textureGenerator;
     m_textureGenerator = nullptr;
-    
+
     qDebug() << "Texture guide generation done";
-    
+
     emit resultTextureChanged();
-    
+
     if (m_isTextureObsolete) {
         generateTexture();
     } else {
@@ -945,7 +931,7 @@ void Document::postProcess()
     qDebug() << "Post processing..";
     emit postProcessing();
 
-    QThread *thread = new QThread;
+    QThread* thread = new QThread;
     m_postProcessor = new MeshResultPostProcessor(*m_currentObject);
     m_postProcessor->moveToThread(thread);
     connect(thread, &QThread::started, m_postProcessor, &MeshResultPostProcessor::process);
@@ -972,7 +958,7 @@ void Document::postProcessedMeshResultReady()
     }
 }
 
-const dust3d::Object &Document::currentPostProcessedObject() const
+const dust3d::Object& Document::currentPostProcessedObject() const
 {
     return *m_postProcessedObject;
 }
@@ -1007,7 +993,7 @@ void Document::setPartSubdivState(dust3d::Uuid partId, bool subdived)
     emit skeletonChanged();
 }
 
-void Document::resolveSnapshotBoundingBox(const dust3d::Snapshot &snapshot, QRectF *mainProfile, QRectF *sideProfile)
+void Document::resolveSnapshotBoundingBox(const dust3d::Snapshot& snapshot, QRectF* mainProfile, QRectF* sideProfile)
 {
     float left = 0;
     bool leftFirstTime = true;
@@ -1021,7 +1007,7 @@ void Document::resolveSnapshotBoundingBox(const dust3d::Snapshot &snapshot, QRec
     bool zLeftFirstTime = true;
     float zRight = 0;
     bool zRightFirstTime = true;
-    for (const auto &nodeIt: snapshot.nodes) {
+    for (const auto& nodeIt : snapshot.nodes) {
         float radius = dust3d::String::toFloat(dust3d::String::valueOrEmpty(nodeIt.second, "radius"));
         float x = dust3d::String::toFloat(dust3d::String::valueOrEmpty(nodeIt.second, "x"));
         float y = dust3d::String::toFloat(dust3d::String::valueOrEmpty(nodeIt.second, "y"));
@@ -1330,8 +1316,7 @@ void Document::setPartCutFaceLinkedId(dust3d::Uuid partId, dust3d::Uuid linkedId
         qDebug() << "Part not found:" << partId;
         return;
     }
-    if (part->second.cutFace == dust3d::CutFace::UserDefined &&
+    if (part->second.cutFace == dust3d::CutFace::UserDefined && part->second.cutFaceLinkedId == linkedId)
-            part->second.cutFaceLinkedId == linkedId)
         return;
     part->second.setCutFaceLinkedId(linkedId);
     part->second.dirty = true;
@@ -1370,7 +1355,7 @@ void Document::undo()
         return;
     m_redoItems.push_back(m_undoItems.back());
     m_undoItems.pop_back();
-    const auto &item = m_undoItems.back();
+    const auto& item = m_undoItems.back();
     fromSnapshot(item.snapshot);
     qDebug() << "Undo/Redo items:" << m_undoItems.size() << m_redoItems.size();
 }
@@ -1380,7 +1365,7 @@ void Document::redo()
     if (m_redoItems.empty())
         return;
     m_undoItems.push_back(m_redoItems.back());
-    const auto &item = m_redoItems.back();
+    const auto& item = m_redoItems.back();
     fromSnapshot(item.snapshot);
     m_redoItems.pop_back();
     qDebug() << "Undo/Redo items:" << m_undoItems.size() << m_redoItems.size();
@@ -1394,12 +1379,12 @@ void Document::clearHistories()
 
 void Document::paste()
 {
-    const QClipboard *clipboard = QApplication::clipboard();
+    const QClipboard* clipboard = QApplication::clipboard();
-    const QMimeData *mimeData = clipboard->mimeData();
+    const QMimeData* mimeData = clipboard->mimeData();
     if (mimeData->hasText()) {
         dust3d::Snapshot snapshot;
         std::string text = mimeData->text().toUtf8().constData();
-        loadSnapshotFromXmlString(&snapshot, (char *)text.c_str());
+        loadSnapshotFromXmlString(&snapshot, (char*)text.c_str());
         addFromSnapshot(snapshot, SnapshotSource::Paste);
         saveSnapshot();
     }
@@ -1407,8 +1392,8 @@ void Document::paste()
 
 bool Document::hasPastableNodesInClipboard() const
 {
-    const QClipboard *clipboard = QApplication::clipboard();
+    const QClipboard* clipboard = QApplication::clipboard();
-    const QMimeData *mimeData = clipboard->mimeData();
+    const QMimeData* mimeData = clipboard->mimeData();
     if (mimeData->hasText()) {
         if (-1 != mimeData->text().indexOf("<node "))
             return true;
@@ -1418,8 +1403,8 @@ bool Document::hasPastableNodesInClipboard() const
 
 bool Document::hasPastableMaterialsInClipboard() const
 {
-    const QClipboard *clipboard = QApplication::clipboard();
+    const QClipboard* clipboard = QApplication::clipboard();
-    const QMimeData *mimeData = clipboard->mimeData();
+    const QMimeData* mimeData = clipboard->mimeData();
     if (mimeData->hasText()) {
         if (-1 != mimeData->text().indexOf("<material "))
             return true;
@@ -1439,7 +1424,7 @@ bool Document::redoable() const
 
 bool Document::isNodeEditable(dust3d::Uuid nodeId) const
 {
-    const SkeletonNode *node = findNode(nodeId);
+    const SkeletonNode* node = findNode(nodeId);
     if (!node) {
         qDebug() << "Node id not found:" << nodeId;
         return false;
@@ -1449,7 +1434,7 @@ bool Document::isNodeEditable(dust3d::Uuid nodeId) const
 
 bool Document::isEdgeEditable(dust3d::Uuid edgeId) const
 {
-    const SkeletonEdge *edge = findEdge(edgeId);
+    const SkeletonEdge* edge = findEdge(edgeId);
     if (!edge) {
         qDebug() << "Edge id not found:" << edgeId;
         return false;
@@ -1459,16 +1444,12 @@ bool Document::isEdgeEditable(dust3d::Uuid edgeId) const
 
 bool Document::isExportReady() const
 {
-    if (m_meshGenerator ||
+    if (m_meshGenerator || m_textureGenerator || m_postProcessor)
-            m_textureGenerator ||
-            m_postProcessor)
         return false;
-    
+
-    if (m_isResultMeshObsolete ||
+    if (m_isResultMeshObsolete || m_isTextureObsolete || m_isPostProcessResultObsolete)
-            m_isTextureObsolete ||
-            m_isPostProcessResultObsolete)
         return false;
-        
+
     return true;
 }
 
@@ -1485,17 +1466,17 @@ void Document::addMaterial(dust3d::Uuid materialId, QString name, std::vector<Ma
         qDebug() << "Material already exist:" << materialId;
         return;
     }
-    
+
     dust3d::Uuid newMaterialId = materialId;
-    auto &material = materialMap[newMaterialId];
+    auto& material = materialMap[newMaterialId];
     material.id = newMaterialId;
-    
+
     material.name = name;
     material.layers = layers;
     material.dirty = true;
-    
+
     materialIdList.push_back(newMaterialId);
-    
+
     emit materialAdded(newMaterialId);
     emit materialListChanged();
     emit optionsChanged();
@@ -1510,7 +1491,7 @@ void Document::removeMaterial(dust3d::Uuid materialId)
     }
     materialIdList.erase(std::remove(materialIdList.begin(), materialIdList.end(), materialId), materialIdList.end());
     materialMap.erase(findMaterialResult);
-    
+
     emit materialListChanged();
     emit materialRemoved(materialId);
     emit optionsChanged();
@@ -1539,7 +1520,7 @@ void Document::renameMaterial(dust3d::Uuid materialId, QString name)
     }
     if (findMaterialResult->second.name == name)
         return;
-    
+
     findMaterialResult->second.name = name;
     emit materialNameChanged(materialId);
     emit materialListChanged();
@@ -1552,10 +1533,10 @@ void Document::generateMaterialPreviews()
         return;
     }
 
-    QThread *thread = new QThread;
+    QThread* thread = new QThread;
     m_materialPreviewsGenerator = new MaterialPreviewsGenerator();
     bool hasDirtyMaterial = false;
-    for (auto &materialIt: materialMap) {
+    for (auto& materialIt : materialMap) {
         if (!materialIt.second.dirty)
             continue;
         m_materialPreviewsGenerator->addMaterial(materialIt.first, materialIt.second.layers);
@@ -1568,9 +1549,9 @@ void Document::generateMaterialPreviews()
         delete thread;
         return;
     }
-    
+
     qDebug() << "Material previews generating..";
-    
+
     m_materialPreviewsGenerator->moveToThread(thread);
     connect(thread, &QThread::started, m_materialPreviewsGenerator, &MaterialPreviewsGenerator::process);
     connect(m_materialPreviewsGenerator, &MaterialPreviewsGenerator::finished, this, &Document::materialPreviewsReady);
@@ -1581,10 +1562,10 @@ void Document::generateMaterialPreviews()
 
 void Document::materialPreviewsReady()
 {
-    for (const auto &materialId: m_materialPreviewsGenerator->generatedPreviewMaterialIds()) {
+    for (const auto& materialId : m_materialPreviewsGenerator->generatedPreviewMaterialIds()) {
         auto material = materialMap.find(materialId);
         if (material != materialMap.end()) {
-            ModelMesh *resultPartPreviewMesh = m_materialPreviewsGenerator->takePreview(materialId);
+            ModelMesh* resultPartPreviewMesh = m_materialPreviewsGenerator->takePreview(materialId);
             material->second.updatePreviewMesh(resultPartPreviewMesh);
             emit materialPreviewChanged(materialId);
         }
@@ -1592,9 +1573,9 @@ void Document::materialPreviewsReady()
 
     delete m_materialPreviewsGenerator;
     m_materialPreviewsGenerator = nullptr;
-    
+
     qDebug() << "Material previews generation done";
-    
+
     generateMaterialPreviews();
 }
 
@@ -1619,18 +1600,18 @@ void Document::copyNodes(std::set<dust3d::Uuid> nodeIdSet) const
     toSnapshot(&snapshot, nodeIdSet, DocumentToSnapshotFor::Nodes);
     std::string snapshotXml;
     dust3d::saveSnapshotToXmlString(snapshot, snapshotXml);
-    QClipboard *clipboard = QApplication::clipboard();
+    QClipboard* clipboard = QApplication::clipboard();
     clipboard->setText(snapshotXml.c_str());
 }
 
-void Document::collectCutFaceList(std::vector<QString> &cutFaces) const
+void Document::collectCutFaceList(std::vector<QString>& cutFaces) const
 {
     cutFaces.clear();
-    
+
     std::vector<dust3d::Uuid> cutFacePartIdList;
-    
+
     std::set<dust3d::Uuid> cutFacePartIds;
-    for (const auto &it: partMap) {
+    for (const auto& it : partMap) {
         if (dust3d::PartTarget::CutFace == it.second.target) {
             if (cutFacePartIds.find(it.first) != cutFacePartIds.end())
                 continue;
@@ -1644,16 +1625,16 @@ void Document::collectCutFaceList(std::vector<QString> &cutFaces) const
             cutFacePartIdList.push_back(it.second.cutFaceLinkedId);
         }
     }
-    
+
     // Sort cut face by center.x of front view
     std::map<dust3d::Uuid, float> centerOffsetMap;
-    for (const auto &partId: cutFacePartIdList) {
+    for (const auto& partId : cutFacePartIdList) {
-        const SkeletonPart *part = findPart(partId);
+        const SkeletonPart* part = findPart(partId);
         if (nullptr == part)
             continue;
         float offsetSum = 0;
-        for (const auto &nodeId: part->nodeIds) {
+        for (const auto& nodeId : part->nodeIds) {
-            const SkeletonNode *node = findNode(nodeId);
+            const SkeletonNode* node = findNode(nodeId);
             if (nullptr == node)
                 continue;
             offsetSum += node->getX();
@@ -1663,16 +1644,16 @@ void Document::collectCutFaceList(std::vector<QString> &cutFaces) const
         centerOffsetMap[partId] = offsetSum / part->nodeIds.size();
     }
     std::sort(cutFacePartIdList.begin(), cutFacePartIdList.end(),
-            [&](const dust3d::Uuid &firstPartId, const dust3d::Uuid &secondPartId) {
+        [&](const dust3d::Uuid& firstPartId, const dust3d::Uuid& secondPartId) {
-        return centerOffsetMap[firstPartId] < centerOffsetMap[secondPartId];
+            return centerOffsetMap[firstPartId] < centerOffsetMap[secondPartId];
-    });
+        });
-    
+
     size_t cutFaceTypeCount = (size_t)dust3d::CutFace::UserDefined;
     for (size_t i = 0; i < (size_t)cutFaceTypeCount; ++i) {
         dust3d::CutFace cutFace = (dust3d::CutFace)i;
         cutFaces.push_back(QString(dust3d::CutFaceToString(cutFace).c_str()));
     }
-    
+
-    for (const auto &it: cutFacePartIdList)
+    for (const auto& it : cutFacePartIdList)
         cutFaces.push_back(QString(it.toString().c_str()));
 }

application/sources/document.h

@@ -1,38 +1,36 @@
 #ifndef DUST3D_APPLICATION_DOCUMENT_H_
 #define DUST3D_APPLICATION_DOCUMENT_H_
 
-#include <QObject>
+#include "material_layer.h"
-#include <vector>
-#include <map>
-#include <set>
-#include <deque>
-#include <QImage>
-#include <cmath>
-#include <algorithm>
-#include <QPolygon>
-#include <dust3d/base/uuid.h>
-#include <dust3d/base/snapshot.h>
-#include <dust3d/base/texture_type.h>
-#include <dust3d/base/combine_mode.h>
 #include "model_mesh.h"
 #include "monochrome_mesh.h"
-#include "theme.h"
 #include "skeleton_document.h"
-#include "material_layer.h"
+#include "theme.h"
+#include <QImage>
+#include <QObject>
+#include <QPolygon>
+#include <algorithm>
+#include <cmath>
+#include <deque>
+#include <dust3d/base/combine_mode.h>
+#include <dust3d/base/snapshot.h>
+#include <dust3d/base/texture_type.h>
+#include <dust3d/base/uuid.h>
+#include <map>
+#include <set>
+#include <vector>
 
 class MaterialPreviewsGenerator;
 class TextureGenerator;
 class MeshGenerator;
 class MeshResultPostProcessor;
 
-class HistoryItem
+class HistoryItem {
-{
 public:
     dust3d::Snapshot snapshot;
 };
 
-class Material
+class Material {
-{
 public:
     Material()
     {
@@ -45,31 +43,30 @@ public:
     QString name;
     bool dirty = true;
     std::vector<MaterialLayer> layers;
-    void updatePreviewMesh(ModelMesh *previewMesh)
+    void updatePreviewMesh(ModelMesh* previewMesh)
     {
         delete m_previewMesh;
         m_previewMesh = previewMesh;
     }
-    ModelMesh *takePreviewMesh() const
+    ModelMesh* takePreviewMesh() const
     {
         if (nullptr == m_previewMesh)
             return nullptr;
         return new ModelMesh(*m_previewMesh);
     }
+
 private:
     Q_DISABLE_COPY(Material);
-    ModelMesh *m_previewMesh = nullptr;
+    ModelMesh* m_previewMesh = nullptr;
 };
 
-enum class DocumentToSnapshotFor
+enum class DocumentToSnapshotFor {
-{
     Document = 0,
     Nodes,
     Materials
 };
 
-class Document : public SkeletonDocument
+class Document : public SkeletonDocument {
-{
     Q_OBJECT
 signals:
     void nodeCutRotationChanged(dust3d::Uuid nodeId);
@@ -121,26 +118,28 @@ signals:
     void postProcessing();
     void textureGenerating();
     void textureChanged();
+
 public: // need initialize
-    QImage *textureImage = nullptr;
+    QImage* textureImage = nullptr;
-    QByteArray *textureImageByteArray = nullptr;
+    QByteArray* textureImageByteArray = nullptr;
-    QImage *textureNormalImage = nullptr;
+    QImage* textureNormalImage = nullptr;
-    QByteArray *textureNormalImageByteArray = nullptr;
+    QByteArray* textureNormalImageByteArray = nullptr;
-    QImage *textureMetalnessImage = nullptr;
+    QImage* textureMetalnessImage = nullptr;
-    QByteArray *textureMetalnessImageByteArray = nullptr;
+    QByteArray* textureMetalnessImageByteArray = nullptr;
-    QImage *textureRoughnessImage = nullptr;
+    QImage* textureRoughnessImage = nullptr;
-    QByteArray *textureRoughnessImageByteArray = nullptr;
+    QByteArray* textureRoughnessImageByteArray = nullptr;
-    QImage *textureAmbientOcclusionImage = nullptr;
+    QImage* textureAmbientOcclusionImage = nullptr;
-    QByteArray *textureAmbientOcclusionImageByteArray = nullptr;
+    QByteArray* textureAmbientOcclusionImageByteArray = nullptr;
     bool weldEnabled = true;
     float brushMetalness = ModelMesh::m_defaultMetalness;
     float brushRoughness = ModelMesh::m_defaultRoughness;
+
 public:
     Document();
     ~Document();
     std::map<dust3d::Uuid, Material> materialMap;
     std::vector<dust3d::Uuid> materialIdList;
-    
+
     bool undoable() const override;
     bool redoable() const override;
     bool hasPastableNodesInClipboard() const override;
@@ -148,39 +147,38 @@ public:
     bool isNodeEditable(dust3d::Uuid nodeId) const override;
     bool isEdgeEditable(dust3d::Uuid edgeId) const override;
     void copyNodes(std::set<dust3d::Uuid> nodeIdSet) const override;
-    void toSnapshot(dust3d::Snapshot *snapshot, const std::set<dust3d::Uuid> &limitNodeIds=std::set<dust3d::Uuid>(),
+    void toSnapshot(dust3d::Snapshot* snapshot, const std::set<dust3d::Uuid>& limitNodeIds = std::set<dust3d::Uuid>(),
-        DocumentToSnapshotFor forWhat=DocumentToSnapshotFor::Document,
+        DocumentToSnapshotFor forWhat = DocumentToSnapshotFor::Document,
-        const std::set<dust3d::Uuid> &limitMaterialIds=std::set<dust3d::Uuid>()) const;
+        const std::set<dust3d::Uuid>& limitMaterialIds = std::set<dust3d::Uuid>()) const;
-    void fromSnapshot(const dust3d::Snapshot &snapshot);
+    void fromSnapshot(const dust3d::Snapshot& snapshot);
-    enum class SnapshotSource
+    enum class SnapshotSource {
-    {
         Unknown,
         Paste,
         Import
     };
-    void addFromSnapshot(const dust3d::Snapshot &snapshot, enum SnapshotSource source=SnapshotSource::Paste);
+    void addFromSnapshot(const dust3d::Snapshot& snapshot, enum SnapshotSource source = SnapshotSource::Paste);
-    const Material *findMaterial(dust3d::Uuid materialId) const;
+    const Material* findMaterial(dust3d::Uuid materialId) const;
-    ModelMesh *takeResultMesh();
+    ModelMesh* takeResultMesh();
-    MonochromeMesh *takeWireframeMesh();
+    MonochromeMesh* takeWireframeMesh();
-    ModelMesh *takePaintedMesh();
+    ModelMesh* takePaintedMesh();
     bool isMeshGenerationSucceed();
-    ModelMesh *takeResultTextureMesh();
+    ModelMesh* takeResultTextureMesh();
-    ModelMesh *takeResultRigWeightMesh();
+    ModelMesh* takeResultRigWeightMesh();
-    void updateTurnaround(const QImage &image);
+    void updateTurnaround(const QImage& image);
     void clearTurnaround();
-    void updateTextureImage(QImage *image);
+    void updateTextureImage(QImage* image);
-    void updateTextureNormalImage(QImage *image);
+    void updateTextureNormalImage(QImage* image);
-    void updateTextureMetalnessImage(QImage *image);
+    void updateTextureMetalnessImage(QImage* image);
-    void updateTextureRoughnessImage(QImage *image);
+    void updateTextureRoughnessImage(QImage* image);
-    void updateTextureAmbientOcclusionImage(QImage *image);
+    void updateTextureAmbientOcclusionImage(QImage* image);
     bool hasPastableMaterialsInClipboard() const;
-    const dust3d::Object &currentPostProcessedObject() const;
+    const dust3d::Object& currentPostProcessedObject() const;
     bool isExportReady() const;
     bool isPostProcessResultObsolete() const;
     bool isMeshGenerating() const;
     bool isPostProcessing() const;
     bool isTextureGenerating() const;
-    void collectCutFaceList(std::vector<QString> &cutFaces) const;
+    void collectCutFaceList(std::vector<QString>& cutFaces) const;
 public slots:
     void undo() override;
     void redo() override;
@@ -233,30 +231,32 @@ public slots:
     void removeMaterial(dust3d::Uuid materialId);
     void setMaterialLayers(dust3d::Uuid materialId, std::vector<MaterialLayer> layers);
     void renameMaterial(dust3d::Uuid materialId, QString name);
+
 private:
-    void resolveSnapshotBoundingBox(const dust3d::Snapshot &snapshot, QRectF *mainProfile, QRectF *sideProfile);
+    void resolveSnapshotBoundingBox(const dust3d::Snapshot& snapshot, QRectF* mainProfile, QRectF* sideProfile);
     void settleOrigin();
     void checkExportReadyState();
 
     bool m_isResultMeshObsolete = false;
-    MeshGenerator *m_meshGenerator = nullptr;
+    MeshGenerator* m_meshGenerator = nullptr;
-    ModelMesh *m_resultMesh = nullptr;
+    ModelMesh* m_resultMesh = nullptr;
     std::unique_ptr<MonochromeMesh> m_wireframeMesh;
     bool m_isMeshGenerationSucceed = true;
     int m_batchChangeRefCount = 0;
-    dust3d::Object *m_currentObject = nullptr;
+    dust3d::Object* m_currentObject = nullptr;
     bool m_isTextureObsolete = false;
-    TextureGenerator *m_textureGenerator = nullptr;
+    TextureGenerator* m_textureGenerator = nullptr;
     bool m_isPostProcessResultObsolete = false;
-    MeshResultPostProcessor *m_postProcessor = nullptr;
+    MeshResultPostProcessor* m_postProcessor = nullptr;
-    dust3d::Object *m_postProcessedObject = new dust3d::Object;
+    dust3d::Object* m_postProcessedObject = new dust3d::Object;
-    ModelMesh *m_resultTextureMesh = nullptr;
+    ModelMesh* m_resultTextureMesh = nullptr;
     unsigned long long m_textureImageUpdateVersion = 0;
     bool m_smoothNormal = false;
-    MaterialPreviewsGenerator *m_materialPreviewsGenerator = nullptr;
+    MaterialPreviewsGenerator* m_materialPreviewsGenerator = nullptr;
     quint64 m_meshGenerationId = 0;
     quint64 m_nextMeshGenerationId = 0;
-    void *m_generatedCacheContext = nullptr;
+    void* m_generatedCacheContext = nullptr;
+
 private:
     static unsigned long m_maxSnapshot;
     std::deque<HistoryItem> m_undoItems;

application/sources/document_saver.cc

@@ -1,17 +1,17 @@
-#include <set>
+#include "document_saver.h"
+#include "image_forever.h"
 #include <QGuiApplication>
 #include <QtCore/qbuffer.h>
 #include <dust3d/base/ds3_file.h>
 #include <dust3d/base/snapshot_xml.h>
-#include "document_saver.h"
+#include <set>
-#include "image_forever.h"
 
-DocumentSaver::DocumentSaver(const QString *filename, 
+DocumentSaver::DocumentSaver(const QString* filename,
-        dust3d::Snapshot *snapshot,
+    dust3d::Snapshot* snapshot,
-        QByteArray *turnaroundPngByteArray) :
+    QByteArray* turnaroundPngByteArray)
-    m_filename(filename),
+    : m_filename(filename)
-    m_snapshot(snapshot),
+    , m_snapshot(snapshot)
-    m_turnaroundPngByteArray(turnaroundPngByteArray)
+    , m_turnaroundPngByteArray(turnaroundPngByteArray)
 {
 }
 
@@ -29,12 +29,12 @@ void DocumentSaver::process()
     emit finished();
 }
 
-void DocumentSaver::collectUsedResourceIds(const dust3d::Snapshot *snapshot,
+void DocumentSaver::collectUsedResourceIds(const dust3d::Snapshot* snapshot,
-    std::set<dust3d::Uuid> &imageIds)
+    std::set<dust3d::Uuid>& imageIds)
 {
-    for (const auto &material: snapshot->materials) {
+    for (const auto& material : snapshot->materials) {
-        for (auto &layer: material.second) {
+        for (auto& layer : material.second) {
-            for (auto &mapItem: layer.second) {
+            for (auto& mapItem : layer.second) {
                 auto findImageIdString = mapItem.find("linkData");
                 if (findImageIdString == mapItem.end())
                     continue;
@@ -45,12 +45,12 @@ void DocumentSaver::collectUsedResourceIds(const dust3d::Snapshot *snapshot,
     }
 }
 
-bool DocumentSaver::save(const QString *filename, 
+bool DocumentSaver::save(const QString* filename,
-        dust3d::Snapshot *snapshot,
+    dust3d::Snapshot* snapshot,
-        const QByteArray *turnaroundPngByteArray)
+    const QByteArray* turnaroundPngByteArray)
 {
     dust3d::Ds3FileWriter ds3Writer;
-    
+
     {
         std::string modelXml;
         saveSnapshotToXmlString(*snapshot, modelXml);
@@ -58,20 +58,20 @@ bool DocumentSaver::save(const QString *filename,
             ds3Writer.add("model.xml", "model", modelXml.c_str(), modelXml.size());
         }
     }
-    
+
     if (nullptr != turnaroundPngByteArray && turnaroundPngByteArray->size() > 0)
         ds3Writer.add("canvas.png", "asset", turnaroundPngByteArray->data(), turnaroundPngByteArray->size());
-    
+
     std::set<dust3d::Uuid> imageIds;
     collectUsedResourceIds(snapshot, imageIds);
 
-    for (const auto &imageId: imageIds) {
+    for (const auto& imageId : imageIds) {
-        const QByteArray *pngByteArray = ImageForever::getPngByteArray(imageId);
+        const QByteArray* pngByteArray = ImageForever::getPngByteArray(imageId);
         if (nullptr == pngByteArray)
             continue;
         if (pngByteArray->size() > 0)
             ds3Writer.add("images/" + imageId.toString() + ".png", "asset", pngByteArray->data(), pngByteArray->size());
     }
-    
+
     return ds3Writer.save(filename->toUtf8().constData());
 }

application/sources/document_saver.h

@@ -1,35 +1,35 @@
 #ifndef DUST3D_APPLICATION_DOCUMENT_SAVER_H_
 #define DUST3D_APPLICATION_DOCUMENT_SAVER_H_
 
-#include <QString>
-#include <QObject>
 #include <QByteArray>
+#include <QObject>
+#include <QString>
+#include <dust3d/base/snapshot.h>
+#include <dust3d/base/uuid.h>
 #include <map>
 #include <set>
-#include <dust3d/base/uuid.h>
-#include <dust3d/base/snapshot.h>
 
-class DocumentSaver : public QObject
+class DocumentSaver : public QObject {
-{
     Q_OBJECT
 public:
-    DocumentSaver(const QString *filename, 
+    DocumentSaver(const QString* filename,
-        dust3d::Snapshot *snapshot,
+        dust3d::Snapshot* snapshot,
-        QByteArray *turnaroundPngByteArray);
+        QByteArray* turnaroundPngByteArray);
     ~DocumentSaver();
-    static bool save(const QString *filename, 
+    static bool save(const QString* filename,
-        dust3d::Snapshot *snapshot,
+        dust3d::Snapshot* snapshot,
-        const QByteArray *turnaroundPngByteArray);
+        const QByteArray* turnaroundPngByteArray);
-    static void collectUsedResourceIds(const dust3d::Snapshot *snapshot,
+    static void collectUsedResourceIds(const dust3d::Snapshot* snapshot,
-        std::set<dust3d::Uuid> &imageIds);
+        std::set<dust3d::Uuid>& imageIds);
 signals:
     void finished();
 public slots:
     void process();
+
 private:
-    const QString *m_filename = nullptr;
+    const QString* m_filename = nullptr;
-    dust3d::Snapshot *m_snapshot = nullptr;
+    dust3d::Snapshot* m_snapshot = nullptr;
-    QByteArray *m_turnaroundPngByteArray = nullptr;
+    QByteArray* m_turnaroundPngByteArray = nullptr;
 };
 
 #endif

application/sources/document_window.h

@@ -1,21 +1,21 @@
 #ifndef DUST3D_APPLICATION_DOCUMENT_WINDOW_H_
 #define DUST3D_APPLICATION_DOCUMENT_WINDOW_H_
 
-#include <memory>
+#include "component_preview_images_decorator.h"
-#include <QMainWindow>
-#include <QShowEvent>
-#include <QPushButton>
-#include <QString>
-#include <QMenu>
-#include <QAction>
-#include <map>
-#include <QStringList>
-#include <QLabel>
-#include <QShortcut>
-#include "model_widget.h"
 #include "graphics_container_widget.h"
 #include "mesh_preview_images_generator.h"
-#include "component_preview_images_decorator.h"
+#include "model_widget.h"
+#include <QAction>
+#include <QLabel>
+#include <QMainWindow>
+#include <QMenu>
+#include <QPushButton>
+#include <QShortcut>
+#include <QShowEvent>
+#include <QString>
+#include <QStringList>
+#include <map>
+#include <memory>
 
 class Document;
 class SkeletonGraphicsWidget;
@@ -23,38 +23,39 @@ class PartManageWidget;
 class ToolbarButton;
 class SpinnableToolbarIcon;
 
-class DocumentWindow : public QMainWindow
+class DocumentWindow : public QMainWindow {
-{
     Q_OBJECT
 signals:
     void initialized();
     void uninialized();
-    void waitingExportFinished(const QString &filename, bool isSuccessful);
+    void waitingExportFinished(const QString& filename, bool isSuccessful);
     void workingStatusChanged(bool isWorking);
+
 public:
     DocumentWindow();
     ~DocumentWindow();
-    Document *document();
+    Document* document();
-    ModelWidget *modelWidget();
+    ModelWidget* modelWidget();
     bool isWorking();
-    static DocumentWindow *createDocumentWindow();
+    static DocumentWindow* createDocumentWindow();
-    static const std::map<DocumentWindow *, dust3d::Uuid> &documentWindows();
+    static const std::map<DocumentWindow*, dust3d::Uuid>& documentWindows();
     static void showAcknowlegements();
     static void showContributors();
     static void showSupporters();
     static void showAbout();
     static size_t total();
+
 protected:
-    void showEvent(QShowEvent *event);
+    void showEvent(QShowEvent* event);
-    void closeEvent(QCloseEvent *event);
+    void closeEvent(QCloseEvent* event);
-    void mousePressEvent(QMouseEvent *event);
+    void mousePressEvent(QMouseEvent* event);
 public slots:
     void changeTurnaround();
     void save();
-    void saveTo(const QString &saveAsFilename);
+    void saveTo(const QString& saveAsFilename);
     void open();
-    void openExample(const QString &modelName);
+    void openExample(const QString& modelName);
-    void openPathAs(const QString &path, const QString &asName);
+    void openPathAs(const QString& path, const QString& asName);
     void exportObjResult();
     void exportGlbResult();
     void exportFbxResult();
@@ -76,13 +77,13 @@ public slots:
     void updateYlockButtonState();
     void updateZlockButtonState();
     void updateRadiusLockButtonState();
-    void registerDialog(QWidget *widget);
+    void registerDialog(QWidget* widget);
-    void unregisterDialog(QWidget *widget);
+    void unregisterDialog(QWidget* widget);
-    void setExportWaitingList(const QStringList &filenames);
+    void setExportWaitingList(const QStringList& filenames);
     void checkExportWaitingList();
-    void exportObjToFilename(const QString &filename);
+    void exportObjToFilename(const QString& filename);
-    void exportFbxToFilename(const QString &filename);
+    void exportFbxToFilename(const QString& filename);
-    void exportGlbToFilename(const QString &filename);
+    void exportGlbToFilename(const QString& filename);
     void toggleRotation();
     void generateComponentPreviewImages();
     void componentPreviewImagesReady();
@@ -92,88 +93,88 @@ public slots:
     void openRecentFile();
     void updateRecentFileActions();
     void toggleRenderColor();
+
 private:
-    void setCurrentFilename(const QString &filename);
+    void setCurrentFilename(const QString& filename);
     void updateTitle();
     void initializeShortcuts();
-    void initializeToolShortcuts(SkeletonGraphicsWidget *graphicsWidget);
+    void initializeToolShortcuts(SkeletonGraphicsWidget* graphicsWidget);
-    void initializeCanvasShortcuts(SkeletonGraphicsWidget *graphicsWidget);
+    void initializeCanvasShortcuts(SkeletonGraphicsWidget* graphicsWidget);
-    QShortcut *createShortcut(QKeySequence key);
+    QShortcut* createShortcut(QKeySequence key);
-    QString strippedName(const QString &fullFileName);
+    QString strippedName(const QString& fullFileName);
-    bool openFiles(const QStringList &pathList);
+    bool openFiles(const QStringList& pathList);
 
-    Document *m_document = nullptr;
+    Document* m_document = nullptr;
     bool m_firstShow = true;
     bool m_documentSaved = true;
-    std::vector<QWidget *> m_dialogs;
+    std::vector<QWidget*> m_dialogs;
     bool m_isLastMeshGenerationSucceed = true;
     quint64 m_currentUpdatedMeshId = 0;
     QStringList m_waitingForExportToFilenames;
-    
-    QString m_currentFilename;
-    
-    ModelWidget *m_modelRenderWidget = nullptr;
-    SkeletonGraphicsWidget *m_canvasGraphicsWidget = nullptr;
-    GraphicsContainerWidget *m_graphicsContainerWidget = nullptr;
-    
-    QMenu *m_fileMenu = nullptr;
-    QAction *m_newWindowAction = nullptr;
-    QAction *m_newDocumentAction = nullptr;
-    QAction *m_openAction = nullptr;
-    QMenu *m_openExampleMenu = nullptr;
-    QAction *m_saveAction = nullptr;
-    QAction *m_saveAsAction = nullptr;
-    QAction *m_saveAllAction = nullptr;
-    QAction *m_changeTurnaroundAction = nullptr;
-    std::vector<QAction *> m_recentFileActions;
-    QAction *m_recentFileSeparatorAction = nullptr;
-    QAction *m_quitAction = nullptr;
 
-    QAction *m_exportAsObjAction = nullptr;
+    QString m_currentFilename;
-    QAction *m_exportAsGlbAction = nullptr;
+
-    QAction *m_exportAsFbxAction = nullptr;
+    ModelWidget* m_modelRenderWidget = nullptr;
-    
+    SkeletonGraphicsWidget* m_canvasGraphicsWidget = nullptr;
-    QMenu *m_viewMenu = nullptr;
+    GraphicsContainerWidget* m_graphicsContainerWidget = nullptr;
-    QAction *m_toggleWireframeAction = nullptr;
+
-    QAction *m_toggleRotationAction = nullptr;
+    QMenu* m_fileMenu = nullptr;
-    QAction *m_toggleColorAction = nullptr;
+    QAction* m_newWindowAction = nullptr;
+    QAction* m_newDocumentAction = nullptr;
+    QAction* m_openAction = nullptr;
+    QMenu* m_openExampleMenu = nullptr;
+    QAction* m_saveAction = nullptr;
+    QAction* m_saveAsAction = nullptr;
+    QAction* m_saveAllAction = nullptr;
+    QAction* m_changeTurnaroundAction = nullptr;
+    std::vector<QAction*> m_recentFileActions;
+    QAction* m_recentFileSeparatorAction = nullptr;
+    QAction* m_quitAction = nullptr;
+
+    QAction* m_exportAsObjAction = nullptr;
+    QAction* m_exportAsGlbAction = nullptr;
+    QAction* m_exportAsFbxAction = nullptr;
+
+    QMenu* m_viewMenu = nullptr;
+    QAction* m_toggleWireframeAction = nullptr;
+    QAction* m_toggleRotationAction = nullptr;
+    QAction* m_toggleColorAction = nullptr;
     bool m_modelRemoveColor = false;
-    
+
-    QMenu *m_windowMenu = nullptr;
+    QMenu* m_windowMenu = nullptr;
-    QAction *m_showPartsListAction = nullptr;
+    QAction* m_showPartsListAction = nullptr;
-    QAction *m_showDebugDialogAction = nullptr;
+    QAction* m_showDebugDialogAction = nullptr;
-    QAction *m_showMaterialsAction = nullptr;
+    QAction* m_showMaterialsAction = nullptr;
-    
+
-    QMenu *m_helpMenu = nullptr;
+    QMenu* m_helpMenu = nullptr;
-    QAction *m_gotoHomepageAction = nullptr;
+    QAction* m_gotoHomepageAction = nullptr;
-    QAction *m_viewSourceAction = nullptr;
+    QAction* m_viewSourceAction = nullptr;
-    QAction *m_aboutAction = nullptr;
+    QAction* m_aboutAction = nullptr;
-    QAction *m_checkForUpdatesAction = nullptr;
+    QAction* m_checkForUpdatesAction = nullptr;
-    QAction *m_reportIssuesAction = nullptr;
+    QAction* m_reportIssuesAction = nullptr;
-    QAction *m_seeContributorsAction = nullptr;
+    QAction* m_seeContributorsAction = nullptr;
-    QAction *m_seeSupportersAction = nullptr;
+    QAction* m_seeSupportersAction = nullptr;
-    QAction *m_seeAcknowlegementsAction = nullptr;
+    QAction* m_seeAcknowlegementsAction = nullptr;
-    QAction *m_seeReferenceGuideAction = nullptr;
+    QAction* m_seeReferenceGuideAction = nullptr;
-    
+
-    ToolbarButton *m_xLockButton = nullptr;
+    ToolbarButton* m_xLockButton = nullptr;
-    ToolbarButton *m_yLockButton = nullptr;
+    ToolbarButton* m_yLockButton = nullptr;
-    ToolbarButton *m_zLockButton = nullptr;
+    ToolbarButton* m_zLockButton = nullptr;
-    ToolbarButton *m_radiusLockButton = nullptr;
+    ToolbarButton* m_radiusLockButton = nullptr;
-    
+
     QMetaObject::Connection m_partListDockerVisibleSwitchConnection;
-    
+
-    MeshPreviewImagesGenerator *m_componentPreviewImagesGenerator = nullptr;
+    MeshPreviewImagesGenerator* m_componentPreviewImagesGenerator = nullptr;
     bool m_isComponentPreviewImagesObsolete = false;
 
     std::unique_ptr<ComponentPreviewImagesDecorator> m_componentPreviewImagesDecorator;
     bool m_isComponentPreviewImageDecorationsObsolete = false;
-    
+
-    PartManageWidget *m_partManageWidget = nullptr;
+    PartManageWidget* m_partManageWidget = nullptr;
-    
+
-    SpinnableToolbarIcon *m_inprogressIndicator = nullptr;
+    SpinnableToolbarIcon* m_inprogressIndicator = nullptr;
-    
+
-    std::map<QKeySequence, QShortcut *> m_shortcutMap;
+    std::map<QKeySequence, QShortcut*> m_shortcutMap;
 };
 
 #endif
-

application/sources/fbx_file.cc

@@ -1,13 +1,13 @@
+#include "fbx_file.h"
+#include "document.h"
+#include "version.h"
+#include <QByteArray>
+#include <QDateTime>
+#include <QFileInfo>
+#include <QtCore/qbuffer.h>
+#include <QtMath>
 #include <fbxnode.h>
 #include <fbxproperty.h>
-#include <QDateTime>
-#include <QtMath>
-#include <QtCore/qbuffer.h>
-#include <QByteArray>
-#include <QFileInfo>
-#include "fbx_file.h"
-#include "version.h"
-#include "document.h"
 
 using namespace fbx;
 
@@ -27,9 +27,9 @@ void FbxFileWriter::createFbxHeader()
     headerExtension.addPropertyNode("EncryptionType", (int32_t)0);
     {
         auto currentDateTime = QDateTime::currentDateTime();
-        const auto &currentDate = currentDateTime.date();
+        const auto& currentDate = currentDateTime.date();
-        const auto &currentTime = currentDateTime.time();
+        const auto& currentTime = currentDateTime.time();
-        
+
         FBXNode creationTimeStamp("CreationTimeStamp");
         creationTimeStamp.addPropertyNode("Version", (int32_t)1000);
         creationTimeStamp.addPropertyNode("Year", (int32_t)currentDate.year());
@@ -45,7 +45,7 @@ void FbxFileWriter::createFbxHeader()
     headerExtension.addPropertyNode("Creator", APP_NAME " " APP_HUMAN_VER);
     {
         FBXNode sceneInfo("SceneInfo");
-        sceneInfo.addProperty(std::vector<uint8_t>({'G','l','o','b','a','l','I','n','f','o',0,1,'S','c','e','n','e','I','n','f','o'}), 'S');
+        sceneInfo.addProperty(std::vector<uint8_t>({ 'G', 'l', 'o', 'b', 'a', 'l', 'I', 'n', 'f', 'o', 0, 1, 'S', 'c', 'e', 'n', 'e', 'I', 'n', 'f', 'o' }), 'S');
         sceneInfo.addProperty("UserData");
         sceneInfo.addPropertyNode("Type", "UserData");
         sceneInfo.addPropertyNode("Version", 100);
@@ -185,7 +185,7 @@ void FbxFileWriter::createFbxHeader()
         headerExtension.addChild(sceneInfo);
         headerExtension.addChild(FBXNode());
     }
-    
+
     m_fbxDocument.nodes.push_back(headerExtension);
 }
 
@@ -198,7 +198,7 @@ void FbxFileWriter::createCreationTime()
 
 void FbxFileWriter::createFileId()
 {
-    std::vector<uint8_t> fileIdBytes = {40, (uint8_t)-77, 42, (uint8_t)-21, (uint8_t)-74, 36, (uint8_t)-52, (uint8_t)-62, (uint8_t)-65, (uint8_t)-56, (uint8_t)-80, 42, (uint8_t)-87, 43, (uint8_t)-4, (uint8_t)-15};
+    std::vector<uint8_t> fileIdBytes = { 40, (uint8_t)-77, 42, (uint8_t)-21, (uint8_t)-74, 36, (uint8_t)-52, (uint8_t)-62, (uint8_t)-65, (uint8_t)-56, (uint8_t)-80, 42, (uint8_t)-87, 43, (uint8_t)-4, (uint8_t)-15 };
     FBXNode fileId("FileId");
     fileId.addProperty(fileIdBytes, 'R');
     m_fbxDocument.nodes.push_back(fileId);
@@ -415,13 +415,13 @@ void FbxFileWriter::createReferences()
 }
 
 void FbxFileWriter::createDefinitions(size_t deformerCount,
-        size_t textureCount,
+    size_t textureCount,
-        size_t videoCount,
+    size_t videoCount,
-        bool hasAnimtion,
+    bool hasAnimtion,
-        size_t animationStackCount,
+    size_t animationStackCount,
-        size_t animationLayerCount,
+    size_t animationLayerCount,
-        size_t animationCurveNodeCount,
+    size_t animationCurveNodeCount,
-        size_t animationCurveCount)
+    size_t animationCurveCount)
 {
     FBXNode definitions("Definitions");
     definitions.addPropertyNode("Version", (int32_t)100);
@@ -2198,15 +2198,15 @@ void FbxFileWriter::createDefinitions(size_t deformerCount,
     m_fbxDocument.nodes.push_back(definitions);
 }
 
-FbxFileWriter::FbxFileWriter(dust3d::Object &object,
+FbxFileWriter::FbxFileWriter(dust3d::Object& object,
-        const QString &filename,
+    const QString& filename,
-        QImage *textureImage,
+    QImage* textureImage,
-        QImage *normalImage,
+    QImage* normalImage,
-        QImage *metalnessImage,
+    QImage* metalnessImage,
-        QImage *roughnessImage,
+    QImage* roughnessImage,
-        QImage *ambientOcclusionImage) :
+    QImage* ambientOcclusionImage)
-    m_filename(filename),
+    : m_filename(filename)
-    m_baseName(QFileInfo(m_filename).baseName())
+    , m_baseName(QFileInfo(m_filename).baseName())
 {
     createFbxHeader();
     createFileId();
@@ -2215,24 +2215,24 @@ FbxFileWriter::FbxFileWriter(dust3d::Object &object,
     createGlobalSettings();
     createDocuments();
     createReferences();
-    
+
     FBXNode connections("Connections");
-    
+
     size_t deformerCount = 0;
-    
+
     FBXNode geometry("Geometry");
     int64_t geometryId = m_next64Id++;
     geometry.addProperty(geometryId);
-    geometry.addProperty(std::vector<uint8_t>({'u','n','a','m','e','d','m','e','s','h',0,1,'G','e','o','m','e','t','r','y'}), 'S');
+    geometry.addProperty(std::vector<uint8_t>({ 'u', 'n', 'a', 'm', 'e', 'd', 'm', 'e', 's', 'h', 0, 1, 'G', 'e', 'o', 'm', 'e', 't', 'r', 'y' }), 'S');
     geometry.addProperty("Mesh");
     std::vector<double> positions;
-    for (const auto &vertex: object.vertices) {
+    for (const auto& vertex : object.vertices) {
         positions.push_back((double)vertex.x());
         positions.push_back((double)vertex.y());
         positions.push_back((double)vertex.z());
     }
     std::vector<int32_t> indices;
-    for (const auto &triangle: object.triangles) {
+    for (const auto& triangle : object.triangles) {
         indices.push_back(triangle[0]);
         indices.push_back(triangle[1]);
         indices.push_back(triangle[2] ^ -1);
@@ -2248,7 +2248,7 @@ FbxFileWriter::FbxFileWriter(dust3d::Object &object,
         std::vector<double> normals;
         for (decltype(triangleVertexNormals->size()) i = 0; i < triangleVertexNormals->size(); ++i) {
             for (size_t j = 0; j < 3; ++j) {
-                const auto &n = (*triangleVertexNormals)[i][j];
+                const auto& n = (*triangleVertexNormals)[i][j];
                 normals.push_back((double)n.x());
                 normals.push_back((double)n.y());
                 normals.push_back((double)n.z());
@@ -2269,7 +2269,7 @@ FbxFileWriter::FbxFileWriter(dust3d::Object &object,
         //std::vector<int32_t> uvIndices;
         for (decltype(triangleVertexUvs->size()) i = 0; i < triangleVertexUvs->size(); ++i) {
             for (size_t j = 0; j < 3; ++j) {
-                const auto &uv = (*triangleVertexUvs)[i][j];
+                const auto& uv = (*triangleVertexUvs)[i][j];
                 uvs.push_back((double)uv.x());
                 uvs.push_back((double)1.0 - uv.y());
                 //uvIndices.push_back(uvIndices.size());
@@ -2285,7 +2285,7 @@ FbxFileWriter::FbxFileWriter(dust3d::Object &object,
     layerElementMaterial.addPropertyNode("Name", "");
     layerElementMaterial.addPropertyNode("MappingInformationType", "AllSame");
     layerElementMaterial.addPropertyNode("ReferenceInformationType", "IndexToDirect");
-    std::vector<int32_t> materials = {(int32_t)0};
+    std::vector<int32_t> materials = { (int32_t)0 };
     layerElementMaterial.addPropertyNode("Materials", materials);
     layerElementMaterial.addChild(FBXNode());
     FBXNode layer("Layer");
@@ -2323,11 +2323,11 @@ FbxFileWriter::FbxFileWriter(dust3d::Object &object,
         geometry.addChild(layerElementUv);
     geometry.addChild(layer);
     geometry.addChild(FBXNode());
-    
+
     int64_t modelId = m_next64Id++;
     FBXNode model("Model");
     model.addProperty(modelId);
-    model.addProperty(std::vector<uint8_t>({'u','n','a','m','e','d',0,1,'M','o','d','e','l'}), 'S');
+    model.addProperty(std::vector<uint8_t>({ 'u', 'n', 'a', 'm', 'e', 'd', 0, 1, 'M', 'o', 'd', 'e', 'l' }), 'S');
     model.addProperty("Mesh");
     model.addPropertyNode("Version", (int32_t)232);
     {
@@ -2390,7 +2390,7 @@ FbxFileWriter::FbxFileWriter(dust3d::Object &object,
     model.addPropertyNode("Shading", (bool)true);
     model.addPropertyNode("Culling", "CullingOff");
     model.addChild(FBXNode());
-    
+
     FBXNode pose("Pose");
     int64_t poseId = 0;
     std::vector<FBXNode> deformers;
@@ -2401,12 +2401,11 @@ FbxFileWriter::FbxFileWriter(dust3d::Object &object,
     std::vector<int64_t> nodeAttributeIds;
     int64_t skinId = 0;
     int64_t armatureId = 0;
-    
+
-    if (deformerCount > 0)
+    if (deformerCount > 0) {
-    {
         poseId = m_next64Id++;
         pose.addProperty(poseId);
-        pose.addProperty(std::vector<uint8_t>({'u','n','a','m','e','d',0,1,'P','o','s','e'}), 'S');
+        pose.addProperty(std::vector<uint8_t>({ 'u', 'n', 'a', 'm', 'e', 'd', 0, 1, 'P', 'o', 's', 'e' }), 'S');
         pose.addProperty("BindPose");
         pose.addPropertyNode("Type", "BindPose");
         pose.addPropertyNode("Version", (int32_t)100);
@@ -2427,17 +2426,17 @@ FbxFileWriter::FbxFileWriter(dust3d::Object &object,
         }
         pose.addChild(FBXNode());
     }
-    
+
     size_t textureCount = 0;
     size_t videoCount = 0;
-    
+
     std::vector<FBXNode> videos;
     std::vector<FBXNode> textures;
-    
+
     FBXNode material("Material");
     int64_t materialId = m_next64Id++;
     material.addProperty(materialId);
-    material.addProperty(std::vector<uint8_t>({'M','a','t','e','r','i','a','l',0,1,'S','t','i','n','g','r','a','y','P','B','S'}), 'S');
+    material.addProperty(std::vector<uint8_t>({ 'M', 'a', 't', 'e', 'r', 'i', 'a', 'l', 0, 1, 'S', 't', 'i', 'n', 'g', 'r', 'a', 'y', 'P', 'B', 'S' }), 'S');
     material.addProperty("");
     material.addPropertyNode("Version", (int32_t)102);
     material.addPropertyNode("ShadingModel", "unknown");
@@ -2696,7 +2695,7 @@ FbxFileWriter::FbxFileWriter(dust3d::Object &object,
         material.addChild(properties);
     }
     material.addChild(FBXNode());
-    
+
     /*
     FBXNode material("Material");
     int64_t materialId = m_next64Id++;
@@ -2833,11 +2832,11 @@ FbxFileWriter::FbxFileWriter(dust3d::Object &object,
     }
     material.addChild(FBXNode());
     */
-    
+
     FBXNode implementation("Implementation");
     int64_t implementationId = m_next64Id++;
     implementation.addProperty(implementationId);
-    implementation.addProperty(std::vector<uint8_t>({'I','m','p','l','e','m','e','n','t','a','t','i','o','n',0,1,'S','t','i','n','g','r','a','y','P','B','S','_','I','m','p','l','e','m','e','n','t','a','t','i','o','n'}), 'S');
+    implementation.addProperty(std::vector<uint8_t>({ 'I', 'm', 'p', 'l', 'e', 'm', 'e', 'n', 't', 'a', 't', 'i', 'o', 'n', 0, 1, 'S', 't', 'i', 'n', 'g', 'r', 'a', 'y', 'P', 'B', 'S', '_', 'I', 'm', 'p', 'l', 'e', 'm', 'e', 'n', 't', 'a', 't', 'i', 'o', 'n' }), 'S');
     implementation.addProperty("");
     implementation.addPropertyNode("Version", (int32_t)100);
     {
@@ -2896,11 +2895,11 @@ FbxFileWriter::FbxFileWriter(dust3d::Object &object,
         implementation.addChild(properties);
     }
     implementation.addChild(FBXNode());
-    
+
     FBXNode bindingTable("BindingTable");
     int64_t bindingTableId = m_next64Id++;
     bindingTable.addProperty(bindingTableId);
-    bindingTable.addProperty(std::vector<uint8_t>({'B','i','n','d','i','n','g','T','a','b','l','e',0,1,'S','t','i','n','g','r','a','y','P','B','S','_','B','i','n','d','i','n','g','T','a','b','l','e'}), 'S');
+    bindingTable.addProperty(std::vector<uint8_t>({ 'B', 'i', 'n', 'd', 'i', 'n', 'g', 'T', 'a', 'b', 'l', 'e', 0, 1, 'S', 't', 'i', 'n', 'g', 'r', 'a', 'y', 'P', 'B', 'S', '_', 'B', 'i', 'n', 'd', 'i', 'n', 'g', 'T', 'a', 'b', 'l', 'e' }), 'S');
     bindingTable.addProperty("");
     bindingTable.addPropertyNode("Version", (int32_t)100);
     {
@@ -3103,8 +3102,8 @@ FbxFileWriter::FbxFileWriter(dust3d::Object &object,
         bindingTable.addChild(entry);
     }
     bindingTable.addChild(FBXNode());
-    
+
-    auto addTexture = [&](const QImage *image, const std::vector<uint8_t> &clipName, const std::vector<uint8_t> &textureName, const QString &filename, const QString &propertyName){
+    auto addTexture = [&](const QImage* image, const std::vector<uint8_t>& clipName, const std::vector<uint8_t>& textureName, const QString& filename, const QString& propertyName) {
         FBXNode video("Video");
         int64_t videoId = m_next64Id++;
         video.addProperty(videoId);
@@ -3136,7 +3135,7 @@ FbxFileWriter::FbxFileWriter(dust3d::Object &object,
         video.addChild(FBXNode());
         videos.push_back(video);
         videoCount++;
-        
+
         FBXNode texture("Texture");
         int64_t textureId = m_next64Id++;
         texture.addProperty(textureId);
@@ -3195,7 +3194,7 @@ FbxFileWriter::FbxFileWriter(dust3d::Object &object,
         texture.addChild(FBXNode());
         textures.push_back(texture);
         textureCount++;
-        
+
         {
             FBXNode p("C");
             p.addProperty("OO");
@@ -3214,46 +3213,46 @@ FbxFileWriter::FbxFileWriter(dust3d::Object &object,
     };
     if (nullptr != textureImage) {
         addTexture(textureImage,
-            std::vector<uint8_t>({'V','i','d','e','o',0,1,'B','a','s','e','C','o','l','o','r'}),
+            std::vector<uint8_t>({ 'V', 'i', 'd', 'e', 'o', 0, 1, 'B', 'a', 's', 'e', 'C', 'o', 'l', 'o', 'r' }),
-            std::vector<uint8_t>({'T','e','x','t','u','r','e',0,1,'B','a','s','e','C','o','l','o','r'}),
+            std::vector<uint8_t>({ 'T', 'e', 'x', 't', 'u', 'r', 'e', 0, 1, 'B', 'a', 's', 'e', 'C', 'o', 'l', 'o', 'r' }),
             m_baseName + "_color.png",
             "Maya|TEX_color_map");
     }
     if (nullptr != normalImage) {
         addTexture(normalImage,
-            std::vector<uint8_t>({'V','i','d','e','o',0,1,'N','o','r','m','a','l'}),
+            std::vector<uint8_t>({ 'V', 'i', 'd', 'e', 'o', 0, 1, 'N', 'o', 'r', 'm', 'a', 'l' }),
-            std::vector<uint8_t>({'T','e','x','t','u','r','e',0,1,'N','o','r','m','a','l'}),
+            std::vector<uint8_t>({ 'T', 'e', 'x', 't', 'u', 'r', 'e', 0, 1, 'N', 'o', 'r', 'm', 'a', 'l' }),
             m_baseName + "_normal.png",
             "Maya|TEX_normal_map");
     }
     if (nullptr != metalnessImage) {
         addTexture(metalnessImage,
-            std::vector<uint8_t>({'V','i','d','e','o',0,1,'M','e','t','a','l','l','i','c'}),
+            std::vector<uint8_t>({ 'V', 'i', 'd', 'e', 'o', 0, 1, 'M', 'e', 't', 'a', 'l', 'l', 'i', 'c' }),
-            std::vector<uint8_t>({'T','e','x','t','u','r','e',0,1,'M','e','t','a','l','l','i','c'}),
+            std::vector<uint8_t>({ 'T', 'e', 'x', 't', 'u', 'r', 'e', 0, 1, 'M', 'e', 't', 'a', 'l', 'l', 'i', 'c' }),
             m_baseName + "_metallic.png",
             "Maya|TEX_metallic_map");
     }
     if (nullptr != roughnessImage) {
         addTexture(roughnessImage,
-            std::vector<uint8_t>({'V','i','d','e','o',0,1,'R','o','u','g','h','n','e','s','s'}),
+            std::vector<uint8_t>({ 'V', 'i', 'd', 'e', 'o', 0, 1, 'R', 'o', 'u', 'g', 'h', 'n', 'e', 's', 's' }),
-            std::vector<uint8_t>({'T','e','x','t','u','r','e',0,1,'R','o','u','g','h','n','e','s','s'}),
+            std::vector<uint8_t>({ 'T', 'e', 'x', 't', 'u', 'r', 'e', 0, 1, 'R', 'o', 'u', 'g', 'h', 'n', 'e', 's', 's' }),
             m_baseName + "_roughness.png",
             "Maya|TEX_roughness_map");
     }
     if (nullptr != ambientOcclusionImage) {
         addTexture(ambientOcclusionImage,
-            std::vector<uint8_t>({'V','i','d','e','o',0,1,'A','o'}),
+            std::vector<uint8_t>({ 'V', 'i', 'd', 'e', 'o', 0, 1, 'A', 'o' }),
-            std::vector<uint8_t>({'T','e','x','t','u','r','e',0,1,'A','o'}),
+            std::vector<uint8_t>({ 'T', 'e', 'x', 't', 'u', 'r', 'e', 0, 1, 'A', 'o' }),
             m_baseName + "_ao.png",
             "Maya|TEX_ao_map");
     }
-    
+
     bool hasAnimation = false;
     size_t animationStackCount = 0;
     size_t animationLayerCount = 0;
     size_t animationCurveNodeCount = 0;
     size_t animationCurveCount = 0;
-    
+
     std::vector<FBXNode> animationStacks;
     std::vector<FBXNode> animationLayers;
     std::vector<FBXNode> animationCurveNodes;
@@ -3263,11 +3262,11 @@ FbxFileWriter::FbxFileWriter(dust3d::Object &object,
         textureCount, videoCount,
         hasAnimation,
         animationStackCount, animationLayerCount, animationCurveNodeCount, animationCurveCount);
-    
+
     FBXNode objects("Objects");
     objects.addChild(geometry);
     objects.addChild(model);
-    for (const auto &limbNode: limbNodes) {
+    for (const auto& limbNode : limbNodes) {
         objects.addChild(limbNode);
     }
     if (deformerCount > 0)
@@ -3276,38 +3275,38 @@ FbxFileWriter::FbxFileWriter(dust3d::Object &object,
     objects.addChild(implementation);
     objects.addChild(bindingTable);
     if (textureCount > 0) {
-        for (const auto &texture: textures) {
+        for (const auto& texture : textures) {
             objects.addChild(texture);
         }
     }
     if (videoCount > 0) {
-        for (const auto &video: videos) {
+        for (const auto& video : videos) {
             objects.addChild(video);
         }
     }
-    for (const auto &deformer: deformers) {
+    for (const auto& deformer : deformers) {
         objects.addChild(deformer);
     }
-    for (const auto &nodeAttribute: nodeAttributes) {
+    for (const auto& nodeAttribute : nodeAttributes) {
         objects.addChild(nodeAttribute);
     }
     if (hasAnimation) {
-        for (const auto &animationStack: animationStacks) {
+        for (const auto& animationStack : animationStacks) {
             objects.addChild(animationStack);
         }
-        for (const auto &animationLayer: animationLayers) {
+        for (const auto& animationLayer : animationLayers) {
             objects.addChild(animationLayer);
         }
-        for (const auto &animationCurveNode: animationCurveNodes) {
+        for (const auto& animationCurveNode : animationCurveNodes) {
             objects.addChild(animationCurveNode);
         }
-        for (const auto &animationCurve: animationCurves) {
+        for (const auto& animationCurve : animationCurves) {
             objects.addChild(animationCurve);
         }
     }
     objects.addChild(FBXNode());
     m_fbxDocument.nodes.push_back(objects);
-    
+
     {
         FBXNode p("C");
         p.addProperty("OO");
@@ -3315,8 +3314,7 @@ FbxFileWriter::FbxFileWriter(dust3d::Object &object,
         p.addProperty((int64_t)0);
         connections.addChild(p);
     }
-    if (armatureId > 0)
+    if (armatureId > 0) {
-    {
         FBXNode p("C");
         p.addProperty("OO");
         p.addProperty(armatureId);
@@ -3330,8 +3328,7 @@ FbxFileWriter::FbxFileWriter(dust3d::Object &object,
         p.addProperty(modelId);
         connections.addChild(p);
     }
-    if (skinId > 0)
+    if (skinId > 0) {
-    {
         FBXNode p("C");
         p.addProperty("OO");
         p.addProperty(skinId);
@@ -3375,7 +3372,7 @@ FbxFileWriter::FbxFileWriter(dust3d::Object &object,
     }
     connections.addChild(FBXNode());
     m_fbxDocument.nodes.push_back(connections);
-    
+
     createTakes();
 }
 
@@ -3394,11 +3391,11 @@ bool FbxFileWriter::save()
     return true;
 }
 
-std::vector<double> FbxFileWriter::matrixToVector(const QMatrix4x4 &matrix)
+std::vector<double> FbxFileWriter::matrixToVector(const QMatrix4x4& matrix)
 {
     std::vector<double> vec;
     for (size_t col = 0; col < 4; ++col) {
-        const auto &line = matrix.column(col);
+        const auto& line = matrix.column(col);
         vec.push_back(line.x());
         vec.push_back(line.y());
         vec.push_back(line.z());

application/sources/fbx_file.h

@@ -1,25 +1,24 @@
 #ifndef DUST3D_APPLICATION_FBX_FILE_H_
 #define DUST3D_APPLICATION_FBX_FILE_H_
 
-#include <map>
+#include "fbxdocument.h"
-#include <QString>
+#include <QImage>
 #include <QMatrix4x4>
 #include <QQuaternion>
-#include <QImage>
+#include <QString>
 #include <dust3d/base/object.h>
-#include "fbxdocument.h"
+#include <map>
 
-class FbxFileWriter : public QObject
+class FbxFileWriter : public QObject {
-{
     Q_OBJECT
 public:
-    FbxFileWriter(dust3d::Object &object,
+    FbxFileWriter(dust3d::Object& object,
-        const QString &filename,
+        const QString& filename,
-        QImage *textureImage=nullptr,
+        QImage* textureImage = nullptr,
-        QImage *normalImage=nullptr,
+        QImage* normalImage = nullptr,
-        QImage *metalnessImage=nullptr,
+        QImage* metalnessImage = nullptr,
-        QImage *roughnessImage=nullptr,
+        QImage* roughnessImage = nullptr,
-        QImage *ambientOcclusionImage=nullptr);
+        QImage* ambientOcclusionImage = nullptr);
     bool save();
 
 private:
@@ -31,17 +30,17 @@ private:
     void createDocuments();
     void createReferences();
     void createDefinitions(size_t deformerCount,
-        size_t textureCount=0,
+        size_t textureCount = 0,
-        size_t videoCount=0,
+        size_t videoCount = 0,
-        bool hasAnimtion=false,
+        bool hasAnimtion = false,
-        size_t animationStackCount=0,
+        size_t animationStackCount = 0,
-        size_t animationLayerCount=0,
+        size_t animationLayerCount = 0,
-        size_t animationCurveNodeCount=0,
+        size_t animationCurveNodeCount = 0,
-        size_t animationCurveCount=0);
+        size_t animationCurveCount = 0);
     void createTakes();
-    std::vector<double> matrixToVector(const QMatrix4x4 &matrix);
+    std::vector<double> matrixToVector(const QMatrix4x4& matrix);
     int64_t secondsToKtime(double seconds);
-    
+
     int64_t m_next64Id = 612150000;
     QString m_filename;
     QString m_baseName;
@@ -51,4 +50,3 @@ private:
 };
 
 #endif
-

application/sources/float_number_widget.cc

@@ -1,11 +1,11 @@
-#include <QtWidgets>
+#include "float_number_widget.h"
+#include "theme.h"
 #include <QHBoxLayout>
 #include <QVBoxLayout>
-#include "theme.h"
+#include <QtWidgets>
-#include "float_number_widget.h"
 
-FloatNumberWidget::FloatNumberWidget(QWidget *parent, bool singleLine) :
+FloatNumberWidget::FloatNumberWidget(QWidget* parent, bool singleLine)
-    QWidget(parent)
+    : QWidget(parent)
 {
     m_slider = new QSlider(Qt::Horizontal, this);
     m_slider->setRange(0, 100);
@@ -19,8 +19,8 @@ FloatNumberWidget::FloatNumberWidget(QWidget *parent, bool singleLine) :
         updateValueLabel(fvalue);
         emit valueChanged(fvalue);
     });
-    
+
-    QBoxLayout *layout = nullptr;
+    QBoxLayout* layout = nullptr;
     if (singleLine) {
         layout = new QHBoxLayout(this);
         layout->setMargin(2);
@@ -48,7 +48,7 @@ void FloatNumberWidget::updateValueLabel(float value)
         m_label->setText(m_itemName + ": " + valueString);
 }
 
-void FloatNumberWidget::setItemName(const QString &name)
+void FloatNumberWidget::setItemName(const QString& name)
 {
     m_itemName = name;
     updateValueLabel(value());

application/sources/float_number_widget.h

@@ -6,14 +6,13 @@
 QT_FORWARD_DECLARE_CLASS(QLabel)
 QT_FORWARD_DECLARE_CLASS(QSlider)
 
-class FloatNumberWidget : public QWidget
+class FloatNumberWidget : public QWidget {
-{
     Q_OBJECT
 public:
-    explicit FloatNumberWidget(QWidget *parent=nullptr, bool singleLine=true);
+    explicit FloatNumberWidget(QWidget* parent = nullptr, bool singleLine = true);
     void setRange(float min, float max);
     float value() const;
-    void setItemName(const QString &name);
+    void setItemName(const QString& name);
     void setSliderFixedWidth(float width);
 
 public slots:
@@ -23,13 +22,13 @@ public slots:
 
 signals:
     void valueChanged(float value);
-    
+
 private:
     void updateValueLabel(float value);
 
 private:
-    QLabel *m_label = nullptr;
+    QLabel* m_label = nullptr;
-    QSlider *m_slider = nullptr;
+    QSlider* m_slider = nullptr;
     QString m_itemName;
 };
 

application/sources/flow_layout.cc

@@ -52,26 +52,29 @@
 
 #include "flow_layout.h"
 
-FlowLayout::FlowLayout(QWidget *parent, int margin, int hSpacing, int vSpacing)
+FlowLayout::FlowLayout(QWidget* parent, int margin, int hSpacing, int vSpacing)
-    : QLayout(parent), m_hSpace(hSpacing), m_vSpace(vSpacing)
+    : QLayout(parent)
+    , m_hSpace(hSpacing)
+    , m_vSpace(vSpacing)
 {
     setContentsMargins(margin, margin, margin, margin);
 }
 
 FlowLayout::FlowLayout(int margin, int hSpacing, int vSpacing)
-    : m_hSpace(hSpacing), m_vSpace(vSpacing)
+    : m_hSpace(hSpacing)
+    , m_vSpace(vSpacing)
 {
     setContentsMargins(margin, margin, margin, margin);
 }
 
 FlowLayout::~FlowLayout()
 {
-    QLayoutItem *item;
+    QLayoutItem* item;
     while ((item = takeAt(0)))
         delete item;
 }
 
-void FlowLayout::addItem(QLayoutItem *item)
+void FlowLayout::addItem(QLayoutItem* item)
 {
     itemList.append(item);
 }
@@ -99,12 +102,12 @@ int FlowLayout::count() const
     return itemList.size();
 }
 
-QLayoutItem *FlowLayout::itemAt(int index) const
+QLayoutItem* FlowLayout::itemAt(int index) const
 {
     return itemList.value(index);
 }
 
-QLayoutItem *FlowLayout::takeAt(int index)
+QLayoutItem* FlowLayout::takeAt(int index)
 {
     if (index >= 0 && index < itemList.size())
         return itemList.takeAt(index);
@@ -128,7 +131,7 @@ int FlowLayout::heightForWidth(int width) const
     return height;
 }
 
-void FlowLayout::setGeometry(const QRect &rect)
+void FlowLayout::setGeometry(const QRect& rect)
 {
     QLayout::setGeometry(rect);
     doLayout(rect, false);
@@ -142,15 +145,15 @@ QSize FlowLayout::sizeHint() const
 QSize FlowLayout::minimumSize() const
 {
     QSize size;
-    QLayoutItem *item;
+    QLayoutItem* item;
     foreach (item, itemList)
         size = size.expandedTo(item->minimumSize());
 
-    size += QSize(2*margin(), 2*margin());
+    size += QSize(2 * margin(), 2 * margin());
     return size;
 }
 
-int FlowLayout::doLayout(const QRect &rect, bool testOnly) const
+int FlowLayout::doLayout(const QRect& rect, bool testOnly) const
 {
     int left, top, right, bottom;
     getContentsMargins(&left, &top, &right, &bottom);
@@ -159,9 +162,9 @@ int FlowLayout::doLayout(const QRect &rect, bool testOnly) const
     int y = effectiveRect.y();
     int lineHeight = 0;
 
-    QLayoutItem *item;
+    QLayoutItem* item;
     foreach (item, itemList) {
-        QWidget *wid = item->widget();
+        QWidget* wid = item->widget();
         int spaceX = horizontalSpacing();
         if (spaceX == -1)
             spaceX = wid->style()->layoutSpacing(
@@ -189,13 +192,13 @@ int FlowLayout::doLayout(const QRect &rect, bool testOnly) const
 
 int FlowLayout::smartSpacing(QStyle::PixelMetric pm) const
 {
-    QObject *parent = this->parent();
+    QObject* parent = this->parent();
     if (!parent) {
         return -1;
     } else if (parent->isWidgetType()) {
-        QWidget *pw = static_cast<QWidget *>(parent);
+        QWidget* pw = static_cast<QWidget*>(parent);
         return pw->style()->pixelMetric(pm, 0, pw);
     } else {
-        return static_cast<QLayout *>(parent)->spacing();
+        return static_cast<QLayout*>(parent)->spacing();
     }
 }

application/sources/flow_layout.h

@@ -55,31 +55,30 @@
 #include <QRect>
 #include <QStyle>
 
-class FlowLayout : public QLayout
+class FlowLayout : public QLayout {
-{
 public:
-    explicit FlowLayout(QWidget *parent, int margin=-1, int hSpacing=-1, int vSpacing=-1);
+    explicit FlowLayout(QWidget* parent, int margin = -1, int hSpacing = -1, int vSpacing = -1);
-    explicit FlowLayout(int margin=-1, int hSpacing=-1, int vSpacing=-1);
+    explicit FlowLayout(int margin = -1, int hSpacing = -1, int vSpacing = -1);
     ~FlowLayout();
 
-    void addItem(QLayoutItem *item) override;
+    void addItem(QLayoutItem* item) override;
     int horizontalSpacing() const;
     int verticalSpacing() const;
     Qt::Orientations expandingDirections() const override;
     bool hasHeightForWidth() const override;
     int heightForWidth(int) const override;
     int count() const override;
-    QLayoutItem *itemAt(int index) const override;
+    QLayoutItem* itemAt(int index) const override;
     QSize minimumSize() const override;
-    void setGeometry(const QRect &rect) override;
+    void setGeometry(const QRect& rect) override;
     QSize sizeHint() const override;
-    QLayoutItem *takeAt(int index) override;
+    QLayoutItem* takeAt(int index) override;
 
 private:
-    int doLayout(const QRect &rect, bool testOnly) const;
+    int doLayout(const QRect& rect, bool testOnly) const;
     int smartSpacing(QStyle::PixelMetric pm) const;
 
-    QList<QLayoutItem *> itemList;
+    QList<QLayoutItem*> itemList;
     int m_hSpace;
     int m_vSpace;
 };

application/sources/glb_file.cc

@@ -1,29 +1,29 @@
-#include <QFile>
+#include "glb_file.h"
-#include <QQuaternion>
+#include "model_mesh.h"
+#include "version.h"
 #include <QByteArray>
 #include <QDataStream>
-#include <QFileInfo>
 #include <QDir>
+#include <QFile>
+#include <QFileInfo>
+#include <QQuaternion>
 #include <QtCore/qbuffer.h>
-#include "glb_file.h"
-#include "version.h"
-#include "model_mesh.h"
 
 bool GlbFileWriter::m_enableComment = false;
 
-GlbFileWriter::GlbFileWriter(dust3d::Object &object,
+GlbFileWriter::GlbFileWriter(dust3d::Object& object,
-        const QString &filename,
+    const QString& filename,
-        QImage *textureImage,
+    QImage* textureImage,
-        QImage *normalImage,
+    QImage* normalImage,
-        QImage *ormImage) :
+    QImage* ormImage)
-    m_filename(filename)
+    : m_filename(filename)
 {
-    const std::vector<std::vector<dust3d::Vector3>> *triangleVertexNormals = object.triangleVertexNormals();
+    const std::vector<std::vector<dust3d::Vector3>>* triangleVertexNormals = object.triangleVertexNormals();
     if (m_outputNormal) {
         m_outputNormal = nullptr != triangleVertexNormals;
     }
-    
+
-    const std::vector<std::vector<dust3d::Vector2>> *triangleVertexUvs = object.triangleVertexUvs();
+    const std::vector<std::vector<dust3d::Vector2>>* triangleVertexUvs = object.triangleVertexUvs();
     if (m_outputUv) {
         m_outputUv = nullptr != triangleVertexUvs;
     }
@@ -31,35 +31,35 @@ GlbFileWriter::GlbFileWriter(dust3d::Object &object,
     QDataStream binStream(&m_binByteArray, QIODevice::WriteOnly);
     binStream.setFloatingPointPrecision(QDataStream::SinglePrecision);
     binStream.setByteOrder(QDataStream::LittleEndian);
-    
+
     auto alignBin = [this, &binStream] {
         while (0 != this->m_binByteArray.size() % 4) {
             binStream << (quint8)0;
         }
     };
-    
+
     QDataStream jsonStream(&m_jsonByteArray, QIODevice::WriteOnly);
     jsonStream.setFloatingPointPrecision(QDataStream::SinglePrecision);
     jsonStream.setByteOrder(QDataStream::LittleEndian);
-    
+
     auto alignJson = [this, &jsonStream] {
         while (0 != this->m_jsonByteArray.size() % 4) {
             jsonStream << (quint8)' ';
         }
     };
-    
+
     int bufferViewIndex = 0;
     int bufferViewFromOffset;
-    
+
     m_json["asset"]["version"] = "2.0";
     m_json["asset"]["generator"] = APP_NAME " " APP_HUMAN_VER;
-    m_json["scenes"][0]["nodes"] = {0};
+    m_json["scenes"][0]["nodes"] = { 0 };
-    
+
     m_json["nodes"][0]["mesh"] = 0;
 
     std::vector<dust3d::Vector3> triangleVertexPositions;
     std::vector<size_t> triangleVertexOldIndices;
-    for (const auto &triangleIndices: object.triangles) {
+    for (const auto& triangleIndices : object.triangles) {
         for (size_t j = 0; j < 3; ++j) {
             triangleVertexOldIndices.push_back(triangleIndices[j]);
             triangleVertexPositions.push_back(object.vertices[triangleIndices[j]]);
@@ -68,7 +68,7 @@ GlbFileWriter::GlbFileWriter(dust3d::Object &object,
 
     int primitiveIndex = 0;
     if (!triangleVertexPositions.empty()) {
-        
+
         m_json["meshes"][0]["primitives"][primitiveIndex]["indices"] = bufferViewIndex;
         m_json["meshes"][0]["primitives"][primitiveIndex]["material"] = primitiveIndex;
         int attributeIndex = 0;
@@ -93,7 +93,7 @@ GlbFileWriter::GlbFileWriter(dust3d::Object &object,
             m_json["materials"][primitiveIndex]["pbrMetallicRoughness"]["roughnessFactor"] = 1.0;
             textureIndex++;
         }
-        
+
         primitiveIndex++;
 
         bufferViewFromOffset = (int)m_binByteArray.size();
@@ -114,7 +114,7 @@ GlbFileWriter::GlbFileWriter(dust3d::Object &object,
         m_json["accessors"][bufferViewIndex]["count"] = triangleVertexPositions.size();
         m_json["accessors"][bufferViewIndex]["type"] = "SCALAR";
         bufferViewIndex++;
-        
+
         bufferViewFromOffset = (int)m_binByteArray.size();
         m_json["bufferViews"][bufferViewIndex]["buffer"] = 0;
         m_json["bufferViews"][bufferViewIndex]["byteOffset"] = bufferViewFromOffset;
@@ -124,7 +124,7 @@ GlbFileWriter::GlbFileWriter(dust3d::Object &object,
         float maxY = -100;
         float minZ = 100;
         float maxZ = -100;
-        for (const auto &position: triangleVertexPositions) {
+        for (const auto& position : triangleVertexPositions) {
             if (position.x() < minX)
                 minX = position.x();
             if (position.x() > maxX)
@@ -140,7 +140,7 @@ GlbFileWriter::GlbFileWriter(dust3d::Object &object,
             binStream << (float)position.x() << (float)position.y() << (float)position.z();
         }
         Q_ASSERT((int)triangleVertexPositions.size() * 3 * sizeof(float) == m_binByteArray.size() - bufferViewFromOffset);
-        m_json["bufferViews"][bufferViewIndex]["byteLength"] =  triangleVertexPositions.size() * 3 * sizeof(float);
+        m_json["bufferViews"][bufferViewIndex]["byteLength"] = triangleVertexPositions.size() * 3 * sizeof(float);
         m_json["bufferViews"][bufferViewIndex]["target"] = 34962;
         alignBin();
         if (m_enableComment)
@@ -148,26 +148,26 @@ GlbFileWriter::GlbFileWriter(dust3d::Object &object,
         m_json["accessors"][bufferViewIndex]["bufferView"] = bufferViewIndex;
         m_json["accessors"][bufferViewIndex]["byteOffset"] = 0;
         m_json["accessors"][bufferViewIndex]["componentType"] = 5126;
-        m_json["accessors"][bufferViewIndex]["count"] =  triangleVertexPositions.size();
+        m_json["accessors"][bufferViewIndex]["count"] = triangleVertexPositions.size();
         m_json["accessors"][bufferViewIndex]["type"] = "VEC3";
-        m_json["accessors"][bufferViewIndex]["max"] = {maxX, maxY, maxZ};
+        m_json["accessors"][bufferViewIndex]["max"] = { maxX, maxY, maxZ };
-        m_json["accessors"][bufferViewIndex]["min"] = {minX, minY, minZ};
+        m_json["accessors"][bufferViewIndex]["min"] = { minX, minY, minZ };
         bufferViewIndex++;
-        
+
         if (m_outputNormal) {
             bufferViewFromOffset = (int)m_binByteArray.size();
             m_json["bufferViews"][bufferViewIndex]["buffer"] = 0;
             m_json["bufferViews"][bufferViewIndex]["byteOffset"] = bufferViewFromOffset;
             QStringList normalList;
-            for (const auto &normals: (*triangleVertexNormals)) {
+            for (const auto& normals : (*triangleVertexNormals)) {
-                for (const auto &it: normals) {
+                for (const auto& it : normals) {
                     binStream << (float)it.x() << (float)it.y() << (float)it.z();
                     if (m_enableComment && m_outputNormal)
                         normalList.append(QString("<%1,%2,%3>").arg(QString::number(it.x())).arg(QString::number(it.y())).arg(QString::number(it.z())));
                 }
             }
             Q_ASSERT((int)triangleVertexNormals->size() * 3 * 3 * sizeof(float) == m_binByteArray.size() - bufferViewFromOffset);
-            m_json["bufferViews"][bufferViewIndex]["byteLength"] =  triangleVertexNormals->size() * 3 * 3 * sizeof(float);
+            m_json["bufferViews"][bufferViewIndex]["byteLength"] = triangleVertexNormals->size() * 3 * 3 * sizeof(float);
             m_json["bufferViews"][bufferViewIndex]["target"] = 34962;
             alignBin();
             if (m_enableComment)
@@ -175,17 +175,17 @@ GlbFileWriter::GlbFileWriter(dust3d::Object &object,
             m_json["accessors"][bufferViewIndex]["bufferView"] = bufferViewIndex;
             m_json["accessors"][bufferViewIndex]["byteOffset"] = 0;
             m_json["accessors"][bufferViewIndex]["componentType"] = 5126;
-            m_json["accessors"][bufferViewIndex]["count"] =  triangleVertexNormals->size() * 3;
+            m_json["accessors"][bufferViewIndex]["count"] = triangleVertexNormals->size() * 3;
             m_json["accessors"][bufferViewIndex]["type"] = "VEC3";
             bufferViewIndex++;
         }
-        
+
         if (m_outputUv) {
             bufferViewFromOffset = (int)m_binByteArray.size();
             m_json["bufferViews"][bufferViewIndex]["buffer"] = 0;
             m_json["bufferViews"][bufferViewIndex]["byteOffset"] = bufferViewFromOffset;
-            for (const auto &uvs: (*triangleVertexUvs)) {
+            for (const auto& uvs : (*triangleVertexUvs)) {
-                for (const auto &it: uvs)
+                for (const auto& it : uvs)
                     binStream << (float)it.x() << (float)it.y();
             }
             m_json["bufferViews"][bufferViewIndex]["byteLength"] = m_binByteArray.size() - bufferViewFromOffset;
@@ -195,7 +195,7 @@ GlbFileWriter::GlbFileWriter(dust3d::Object &object,
             m_json["accessors"][bufferViewIndex]["bufferView"] = bufferViewIndex;
             m_json["accessors"][bufferViewIndex]["byteOffset"] = 0;
             m_json["accessors"][bufferViewIndex]["componentType"] = 5126;
-            m_json["accessors"][bufferViewIndex]["count"] =  triangleVertexUvs->size() * 3;
+            m_json["accessors"][bufferViewIndex]["count"] = triangleVertexUvs->size() * 3;
             m_json["accessors"][bufferViewIndex]["type"] = "VEC2";
             bufferViewIndex++;
         }
@@ -205,15 +205,15 @@ GlbFileWriter::GlbFileWriter(dust3d::Object &object,
     m_json["samplers"][0]["minFilter"] = 9987;
     m_json["samplers"][0]["wrapS"] = 33648;
     m_json["samplers"][0]["wrapT"] = 33648;
-    
+
     int imageIndex = 0;
     int textureIndex = 0;
-    
+
     // Images should be put in the end of the buffer, because we are not using accessors
     if (nullptr != textureImage) {
         m_json["textures"][textureIndex]["sampler"] = 0;
         m_json["textures"][textureIndex]["source"] = imageIndex;
-    
+
         bufferViewFromOffset = (int)m_binByteArray.size();
         m_json["bufferViews"][bufferViewIndex]["buffer"] = 0;
         m_json["bufferViews"][bufferViewIndex]["byteOffset"] = bufferViewFromOffset;
@@ -226,14 +226,14 @@ GlbFileWriter::GlbFileWriter(dust3d::Object &object,
         m_json["images"][imageIndex]["bufferView"] = bufferViewIndex;
         m_json["images"][imageIndex]["mimeType"] = "image/png";
         bufferViewIndex++;
-        
+
         imageIndex++;
         textureIndex++;
     }
     if (nullptr != normalImage) {
         m_json["textures"][textureIndex]["sampler"] = 0;
         m_json["textures"][textureIndex]["source"] = imageIndex;
-    
+
         bufferViewFromOffset = (int)m_binByteArray.size();
         m_json["bufferViews"][bufferViewIndex]["buffer"] = 0;
         m_json["bufferViews"][bufferViewIndex]["byteOffset"] = bufferViewFromOffset;
@@ -246,14 +246,14 @@ GlbFileWriter::GlbFileWriter(dust3d::Object &object,
         m_json["images"][imageIndex]["bufferView"] = bufferViewIndex;
         m_json["images"][imageIndex]["mimeType"] = "image/png";
         bufferViewIndex++;
-        
+
         imageIndex++;
         textureIndex++;
     }
     if (nullptr != ormImage) {
         m_json["textures"][textureIndex]["sampler"] = 0;
         m_json["textures"][textureIndex]["source"] = imageIndex;
-    
+
         bufferViewFromOffset = (int)m_binByteArray.size();
         m_json["bufferViews"][bufferViewIndex]["buffer"] = 0;
         m_json["bufferViews"][bufferViewIndex]["byteOffset"] = bufferViewFromOffset;
@@ -266,13 +266,13 @@ GlbFileWriter::GlbFileWriter(dust3d::Object &object,
         m_json["images"][imageIndex]["bufferView"] = bufferViewIndex;
         m_json["images"][imageIndex]["mimeType"] = "image/png";
         bufferViewIndex++;
-        
+
         imageIndex++;
         textureIndex++;
     }
-    
+
     m_json["buffers"][0]["byteLength"] = m_binByteArray.size();
-    
+
     auto jsonString = m_enableComment ? m_json.dump(4) : m_json.dump();
     jsonStream.writeRawData(jsonString.data(), jsonString.size());
     alignJson();
@@ -287,50 +287,48 @@ bool GlbFileWriter::save()
     QDataStream output(&file);
     output.setFloatingPointPrecision(QDataStream::SinglePrecision);
     output.setByteOrder(QDataStream::LittleEndian);
-    
+
     uint32_t headerSize = 12;
     uint32_t chunk0DescriptionSize = 8;
     uint32_t chunk1DescriptionSize = 8;
-    uint32_t fileSize = headerSize +
+    uint32_t fileSize = headerSize + chunk0DescriptionSize + m_jsonByteArray.size() + chunk1DescriptionSize + m_binByteArray.size();
-        chunk0DescriptionSize + m_jsonByteArray.size() +
+
-        chunk1DescriptionSize + m_binByteArray.size();
-    
     qDebug() << "Chunk 0 data size:" << m_jsonByteArray.size();
     qDebug() << "Chunk 1 data size:" << m_binByteArray.size();
     qDebug() << "File size:" << fileSize;
-    
+
     //////////// Header ////////////
 
     // magic
     output << (uint32_t)0x46546C67;
-    
+
     // version
     output << (uint32_t)0x00000002;
-    
+
     // length
     output << (uint32_t)fileSize;
-    
+
     //////////// Chunk 0 (Json) ////////////
-    
+
     // length
     output << (uint32_t)m_jsonByteArray.size();
-    
+
     // type
     output << (uint32_t)0x4E4F534A;
-    
+
     // data
     output.writeRawData(m_jsonByteArray.data(), m_jsonByteArray.size());
-    
+
     //////////// Chunk 1 (Binary Buffer) ///
-    
+
     // length
     output << (uint32_t)m_binByteArray.size();
-    
+
     // type
     output << (uint32_t)0x004E4942;
-    
+
     // data
     output.writeRawData(m_binByteArray.data(), m_binByteArray.size());
-    
+
     return true;
 }

application/sources/glb_file.h

@@ -1,35 +1,37 @@
 #ifndef DUST3D_APPLICATION_GLB_FILE_H_
 #define DUST3D_APPLICATION_GLB_FILE_H_
 
-#include <QObject>
-#include <QString>
-#include <QByteArray>
-#include <QMatrix4x4>
-#include <vector>
-#include <QQuaternion>
-#include <QImage>
-#include <dust3d/base/object.h>
-#include "json.hpp"
 #include "document.h"
+#include "json.hpp"
+#include <QByteArray>
+#include <QImage>
+#include <QMatrix4x4>
+#include <QObject>
+#include <QQuaternion>
+#include <QString>
+#include <dust3d/base/object.h>
+#include <vector>
 
-class GlbFileWriter : public QObject
+class GlbFileWriter : public QObject {
-{
     Q_OBJECT
 public:
-    GlbFileWriter(dust3d::Object &object,
+    GlbFileWriter(dust3d::Object& object,
-        const QString &filename,
+        const QString& filename,
-        QImage *textureImage=nullptr,
+        QImage* textureImage = nullptr,
-        QImage *normalImage=nullptr,
+        QImage* normalImage = nullptr,
-        QImage *ormImage=nullptr);
+        QImage* ormImage = nullptr);
     bool save();
+
 private:
     QString m_filename;
     bool m_outputNormal = true;
     bool m_outputUv = true;
     QByteArray m_binByteArray;
     QByteArray m_jsonByteArray;
+
 private:
     nlohmann::json m_json;
+
 public:
     static bool m_enableComment;
 };

application/sources/graphics_container_widget.cc

@@ -5,47 +5,47 @@ GraphicsContainerWidget::GraphicsContainerWidget()
     setMouseTracking(true);
 }
 
-void GraphicsContainerWidget::resizeEvent(QResizeEvent *event)
+void GraphicsContainerWidget::resizeEvent(QResizeEvent* event)
 {
     if (m_graphicsWidget && m_graphicsWidget->size() != event->size())
         emit containerSizeChanged(event->size());
 }
 
-void GraphicsContainerWidget::mousePressEvent(QMouseEvent *event)
+void GraphicsContainerWidget::mousePressEvent(QMouseEvent* event)
 {
     if (m_modelWidget)
         m_modelWidget->inputMousePressEventFromOtherWidget(event);
 }
 
-void GraphicsContainerWidget::mouseMoveEvent(QMouseEvent *event)
+void GraphicsContainerWidget::mouseMoveEvent(QMouseEvent* event)
 {
     if (m_modelWidget)
         m_modelWidget->inputMouseMoveEventFromOtherWidget(event);
 }
 
-void GraphicsContainerWidget::mouseReleaseEvent(QMouseEvent *event)
+void GraphicsContainerWidget::mouseReleaseEvent(QMouseEvent* event)
 {
     if (m_modelWidget)
         m_modelWidget->inputMouseReleaseEventFromOtherWidget(event);
 }
 
-void GraphicsContainerWidget::wheelEvent(QWheelEvent *event)
+void GraphicsContainerWidget::wheelEvent(QWheelEvent* event)
 {
     if (m_graphicsWidget) {
         m_graphicsWidget->inputWheelEventFromOtherWidget(event);
         return;
     }
-        
+
     if (m_modelWidget)
         m_modelWidget->inputWheelEventFromOtherWidget(event);
 }
 
-void GraphicsContainerWidget::setGraphicsWidget(SkeletonGraphicsWidget *graphicsWidget)
+void GraphicsContainerWidget::setGraphicsWidget(SkeletonGraphicsWidget* graphicsWidget)
 {
     m_graphicsWidget = graphicsWidget;
 }
 
-void GraphicsContainerWidget::setModelWidget(ModelWidget *modelWidget)
+void GraphicsContainerWidget::setModelWidget(ModelWidget* modelWidget)
 {
     m_modelWidget = modelWidget;
 }

application/sources/graphics_container_widget.h

@@ -1,31 +1,33 @@
 #ifndef DUST3D_APPLICATION_GRAPHICS_CONTAINER_WIDGET_H_
 #define DUST3D_APPLICATION_GRAPHICS_CONTAINER_WIDGET_H_
 
-#include <QWidget>
-#include <QResizeEvent>
-#include <QMouseEvent>
-#include <QWheelEvent>
 #include "model_widget.h"
 #include "skeleton_graphics_widget.h"
+#include <QMouseEvent>
+#include <QResizeEvent>
+#include <QWheelEvent>
+#include <QWidget>
 
-class GraphicsContainerWidget : public QWidget
+class GraphicsContainerWidget : public QWidget {
-{
     Q_OBJECT
 signals:
     void containerSizeChanged(QSize size);
+
 public:
     GraphicsContainerWidget();
-    void setGraphicsWidget(SkeletonGraphicsWidget *graphicsWidget);
+    void setGraphicsWidget(SkeletonGraphicsWidget* graphicsWidget);
-    void setModelWidget(ModelWidget *modelWidget);
+    void setModelWidget(ModelWidget* modelWidget);
+
 protected:
-    void resizeEvent(QResizeEvent *event) override;
+    void resizeEvent(QResizeEvent* event) override;
-    void mousePressEvent(QMouseEvent *event) override;
+    void mousePressEvent(QMouseEvent* event) override;
-    void mouseMoveEvent(QMouseEvent *event) override;
+    void mouseMoveEvent(QMouseEvent* event) override;
-    void mouseReleaseEvent(QMouseEvent *event) override;
+    void mouseReleaseEvent(QMouseEvent* event) override;
-    void wheelEvent(QWheelEvent *event) override;
+    void wheelEvent(QWheelEvent* event) override;
+
 private:
-    ModelWidget *m_modelWidget = nullptr;
+    ModelWidget* m_modelWidget = nullptr;
-    SkeletonGraphicsWidget *m_graphicsWidget = nullptr;
+    SkeletonGraphicsWidget* m_graphicsWidget = nullptr;
 };
 
 #endif

application/sources/horizontal_line_widget.cc

@@ -1,7 +1,7 @@
 #include "horizontal_line_widget.h"
 
-HorizontalLineWidget::HorizontalLineWidget() :
+HorizontalLineWidget::HorizontalLineWidget()
-    QWidget()
+    : QWidget()
 {
     setFixedHeight(1);
     setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);

application/sources/horizontal_line_widget.h

@@ -3,8 +3,7 @@
 
 #include <QWidget>
 
-class HorizontalLineWidget : public QWidget
+class HorizontalLineWidget : public QWidget {
-{
     Q_OBJECT
 public:
     HorizontalLineWidget();

application/sources/image_forever.cc

@@ -1,19 +1,18 @@
-#include <map>
+#include "image_forever.h"
 #include <QMutex>
 #include <QMutexLocker>
 #include <QtCore/qbuffer.h>
-#include "image_forever.h"
+#include <map>
 
-struct ImageForeverItem
+struct ImageForeverItem {
-{
+    QImage* image;
-    QImage *image;
     dust3d::Uuid id;
-    QByteArray *imageByteArray;
+    QByteArray* imageByteArray;
 };
 static std::map<dust3d::Uuid, ImageForeverItem> g_foreverMap;
 static QMutex g_mapMutex;
 
-const QImage *ImageForever::get(const dust3d::Uuid &id)
+const QImage* ImageForever::get(const dust3d::Uuid& id)
 {
     QMutexLocker locker(&g_mapMutex);
     auto findResult = g_foreverMap.find(id);
@@ -22,7 +21,7 @@ const QImage *ImageForever::get(const dust3d::Uuid &id)
     return findResult->second.image;
 }
 
-void ImageForever::copy(const dust3d::Uuid &id, QImage &image)
+void ImageForever::copy(const dust3d::Uuid& id, QImage& image)
 {
     QMutexLocker locker(&g_mapMutex);
     auto findResult = g_foreverMap.find(id);
@@ -31,7 +30,7 @@ void ImageForever::copy(const dust3d::Uuid &id, QImage &image)
     image = *findResult->second.image;
 }
 
-const QByteArray *ImageForever::getPngByteArray(const dust3d::Uuid &id)
+const QByteArray* ImageForever::getPngByteArray(const dust3d::Uuid& id)
 {
     QMutexLocker locker(&g_mapMutex);
     auto findResult = g_foreverMap.find(id);
@@ -40,7 +39,7 @@ const QByteArray *ImageForever::getPngByteArray(const dust3d::Uuid &id)
     return findResult->second.imageByteArray;
 }
 
-dust3d::Uuid ImageForever::add(const QImage *image, dust3d::Uuid toId)
+dust3d::Uuid ImageForever::add(const QImage* image, dust3d::Uuid toId)
 {
     QMutexLocker locker(&g_mapMutex);
     if (nullptr == image)
@@ -48,16 +47,16 @@ dust3d::Uuid ImageForever::add(const QImage *image, dust3d::Uuid toId)
     dust3d::Uuid newId = toId.isNull() ? dust3d::Uuid::createUuid() : toId;
     if (g_foreverMap.find(newId) != g_foreverMap.end())
         return newId;
-    QImage *newImage = new QImage(*image);
+    QImage* newImage = new QImage(*image);
-    QByteArray *imageByteArray = new QByteArray();
+    QByteArray* imageByteArray = new QByteArray();
     QBuffer pngBuffer(imageByteArray);
     pngBuffer.open(QIODevice::WriteOnly);
     newImage->save(&pngBuffer, "PNG");
-    g_foreverMap[newId] = {newImage, newId, imageByteArray};
+    g_foreverMap[newId] = { newImage, newId, imageByteArray };
     return newId;
 }
 
-void ImageForever::remove(const dust3d::Uuid &id)
+void ImageForever::remove(const dust3d::Uuid& id)
 {
     QMutexLocker locker(&g_mapMutex);
     auto findImage = g_foreverMap.find(id);

application/sources/image_forever.h

@@ -1,18 +1,17 @@
 #ifndef DUST3D_APPLICATION_IMAGE_FOREVER_H_
 #define DUST3D_APPLICATION_IMAGE_FOREVER_H_
 
-#include <QImage>
 #include <QByteArray>
+#include <QImage>
 #include <dust3d/base/uuid.h>
 
-class ImageForever
+class ImageForever {
-{
 public:
-    static const QImage *get(const dust3d::Uuid &id);
+    static const QImage* get(const dust3d::Uuid& id);
-    static void copy(const dust3d::Uuid &id, QImage &image);
+    static void copy(const dust3d::Uuid& id, QImage& image);
-    static const QByteArray *getPngByteArray(const dust3d::Uuid &id);
+    static const QByteArray* getPngByteArray(const dust3d::Uuid& id);
-    static dust3d::Uuid add(const QImage *image, dust3d::Uuid toId=dust3d::Uuid());
+    static dust3d::Uuid add(const QImage* image, dust3d::Uuid toId = dust3d::Uuid());
-    static void remove(const dust3d::Uuid &id);
+    static void remove(const dust3d::Uuid& id);
 };
 
 #endif

application/sources/image_preview_widget.cc

@@ -1,28 +1,28 @@
-#include <QPainter>
 #include "image_preview_widget.h"
+#include <QPainter>
 
-ImagePreviewWidget::ImagePreviewWidget(QWidget *parent) :
+ImagePreviewWidget::ImagePreviewWidget(QWidget* parent)
-    QWidget(parent)
+    : QWidget(parent)
 {
 }
 
-void ImagePreviewWidget::updateImage(const QImage &image)
+void ImagePreviewWidget::updateImage(const QImage& image)
 {
     m_image = image;
     update();
 }
 
-void ImagePreviewWidget::updateBackgroundColor(const QColor &color)
+void ImagePreviewWidget::updateBackgroundColor(const QColor& color)
 {
     m_backgroundColor = color;
 }
 
-void ImagePreviewWidget::mousePressEvent(QMouseEvent *event)
+void ImagePreviewWidget::mousePressEvent(QMouseEvent* event)
 {
     emit clicked();
 }
 
-void ImagePreviewWidget::paintEvent(QPaintEvent *event)
+void ImagePreviewWidget::paintEvent(QPaintEvent* event)
 {
     QPainter painter(this);
     if (!m_image.isNull())
@@ -30,4 +30,3 @@ void ImagePreviewWidget::paintEvent(QPaintEvent *event)
     else
         painter.fillRect(QRect(0, 0, width(), height()), QBrush(m_backgroundColor));
 }
-

application/sources/image_preview_widget.h

@@ -1,30 +1,30 @@
 #ifndef DUST3D_APPLICATION_IMAGE_PREVIEW_WIDGET_H_
 #define DUST3D_APPLICATION_IMAGE_PREVIEW_WIDGET_H_
 
-#include <QWidget>
 #include <QImage>
-#include <QPaintEvent>
 #include <QMouseEvent>
+#include <QPaintEvent>
+#include <QWidget>
 
-class ImagePreviewWidget : public QWidget
+class ImagePreviewWidget : public QWidget {
-{
     Q_OBJECT
 signals:
     void clicked();
+
 public:
-    ImagePreviewWidget(QWidget *parent=nullptr);
+    ImagePreviewWidget(QWidget* parent = nullptr);
-    void updateImage(const QImage &image);
+    void updateImage(const QImage& image);
-    void updateBackgroundColor(const QColor &color);
+    void updateBackgroundColor(const QColor& color);
-    
+
 protected:
-    void paintEvent(QPaintEvent *event);
+    void paintEvent(QPaintEvent* event);
-    void mousePressEvent(QMouseEvent *event);
+    void mousePressEvent(QMouseEvent* event);
-    
+
 private:
     QImage m_image;
     QColor m_backgroundColor;
-    
+
-    void resizeImage(QImage *image, const QSize &newSize);
+    void resizeImage(QImage* image, const QSize& newSize);
 };
 
 #endif

application/sources/info_label.cc

@@ -1,25 +1,25 @@
-#include <QHBoxLayout>
 #include "info_label.h"
 #include "theme.h"
+#include <QHBoxLayout>
 
-InfoLabel::InfoLabel(const QString &text, QWidget *parent) :
+InfoLabel::InfoLabel(const QString& text, QWidget* parent)
-    QWidget(parent)
+    : QWidget(parent)
 {
     m_icon = new QLabel(QChar(fa::infocircle));
     Theme::initAwesomeLabel(m_icon);
-    
+
     m_label = new QLabel(text);
     m_label->setWordWrap(true);
-    
+
-    QHBoxLayout *mainLayout = new QHBoxLayout;
+    QHBoxLayout* mainLayout = new QHBoxLayout;
     mainLayout->addWidget(m_icon);
     mainLayout->addWidget(m_label);
     mainLayout->addStretch();
-    
+
     setLayout(mainLayout);
 }
 
-void InfoLabel::setText(const QString &text)
+void InfoLabel::setText(const QString& text)
 {
     m_label->setText(text);
 }

application/sources/info_label.h

@@ -1,18 +1,18 @@
 #ifndef DUST3D_APPLICATION_INFO_LABEL_H_
 #define DUST3D_APPLICATION_INFO_LABEL_H_
 
-#include <QLabel>
 #include <QIcon>
+#include <QLabel>
 #include <QWidget>
 
-class InfoLabel : public QWidget
+class InfoLabel : public QWidget {
-{
 public:
-    InfoLabel(const QString &text=QString(), QWidget *parent=nullptr);
+    InfoLabel(const QString& text = QString(), QWidget* parent = nullptr);
-    void setText(const QString &text);
+    void setText(const QString& text);
+
 private:
-    QLabel *m_label = nullptr;
+    QLabel* m_label = nullptr;
-    QLabel *m_icon = nullptr;
+    QLabel* m_icon = nullptr;
 };
 
 #endif

application/sources/int_number_widget.cc

@@ -1,11 +1,11 @@
-#include <QtWidgets>
+#include "int_number_widget.h"
+#include "theme.h"
 #include <QHBoxLayout>
 #include <QVBoxLayout>
-#include "theme.h"
+#include <QtWidgets>
-#include "int_number_widget.h"
 
-IntNumberWidget::IntNumberWidget(QWidget *parent, bool singleLine) :
+IntNumberWidget::IntNumberWidget(QWidget* parent, bool singleLine)
-    QWidget(parent)
+    : QWidget(parent)
 {
     m_slider = new QSlider(Qt::Horizontal, this);
     m_slider->setRange(0, 100);
@@ -18,8 +18,8 @@ IntNumberWidget::IntNumberWidget(QWidget *parent, bool singleLine) :
         updateValueLabel(value);
         emit valueChanged(value);
     });
-    
+
-    QBoxLayout *layout = nullptr;
+    QBoxLayout* layout = nullptr;
     if (singleLine) {
         layout = new QHBoxLayout(this);
         layout->setMargin(2);
@@ -42,7 +42,7 @@ void IntNumberWidget::updateValueLabel(int value)
         m_label->setText(m_itemName + ": " + valueString);
 }
 
-void IntNumberWidget::setItemName(const QString &name)
+void IntNumberWidget::setItemName(const QString& name)
 {
     m_itemName = name;
     updateValueLabel(value());

application/sources/int_number_widget.h

@@ -6,14 +6,13 @@
 QT_FORWARD_DECLARE_CLASS(QLabel)
 QT_FORWARD_DECLARE_CLASS(QSlider)
 
-class IntNumberWidget : public QWidget
+class IntNumberWidget : public QWidget {
-{
     Q_OBJECT
 public:
-    explicit IntNumberWidget(QWidget *parent = nullptr, bool singleLine=true);
+    explicit IntNumberWidget(QWidget* parent = nullptr, bool singleLine = true);
     void setRange(int min, int max);
     int value() const;
-    void setItemName(const QString &name);
+    void setItemName(const QString& name);
 
 public slots:
     void increaseValue();
@@ -22,13 +21,13 @@ public slots:
 
 signals:
     void valueChanged(int value);
-    
+
 private:
     void updateValueLabel(int value);
 
 private:
-    QLabel *m_label = nullptr;
+    QLabel* m_label = nullptr;
-    QSlider *m_slider = nullptr;
+    QSlider* m_slider = nullptr;
     QString m_itemName;
 };
 

application/sources/log_browser.cc

@@ -1,17 +1,17 @@
-#include <QMetaType>
-#include <QDir>
 #include "log_browser.h"
 #include "log_browser_dialog.h"
+#include <QDir>
+#include <QMetaType>
 
 bool LogBrowser::m_enableOutputToFile = true;
 
-LogBrowser::LogBrowser(QObject *parent) :
+LogBrowser::LogBrowser(QObject* parent)
-    QObject(parent)
+    : QObject(parent)
 {
     qRegisterMetaType<QtMsgType>("QtMsgType");
     m_browserDialog = new LogBrowserDialog;
     connect(this, &LogBrowser::sendMessage, m_browserDialog, &LogBrowserDialog::outputMessage, Qt::QueuedConnection);
-    
+
     if (m_enableOutputToFile) {
         QString filePath = "application.log";
         m_outputTo = fopen(filePath.toUtf8().constData(), "w");
@@ -42,7 +42,7 @@ bool LogBrowser::isDialogVisible()
     return m_browserDialog->isVisible();
 }
 
-void LogBrowser::outputMessage(QtMsgType type, const QString &msg, const QString &source, int line)
+void LogBrowser::outputMessage(QtMsgType type, const QString& msg, const QString& source, int line)
 {
     if (m_outputTo) {
         fprintf(m_outputTo, "[%s:%d]: %s\n", source.toUtf8().constData(), line, msg.toUtf8().constData());

application/sources/log_browser.h

@@ -6,25 +6,24 @@
 
 class LogBrowserDialog;
 
-class LogBrowser : public QObject
+class LogBrowser : public QObject {
-{
     Q_OBJECT
 public:
-    explicit LogBrowser(QObject *parent=0);
+    explicit LogBrowser(QObject* parent = 0);
     ~LogBrowser();
 
 public slots:
-    void outputMessage(QtMsgType type, const QString &msg, const QString &source, int line);
+    void outputMessage(QtMsgType type, const QString& msg, const QString& source, int line);
     void showDialog();
     void hideDialog();
     bool isDialogVisible();
 
 signals:
-    void sendMessage(QtMsgType type, const QString &msg, const QString &source, int line);
+    void sendMessage(QtMsgType type, const QString& msg, const QString& source, int line);
 
 private:
-    LogBrowserDialog *m_browserDialog = nullptr;
+    LogBrowserDialog* m_browserDialog = nullptr;
-    FILE *m_outputTo = nullptr;
+    FILE* m_outputTo = nullptr;
     static bool m_enableOutputToFile;
 };
 

application/sources/log_browser_dialog.cc

@@ -1,30 +1,30 @@
-#include <QVBoxLayout>
-#include <QHBoxLayout>
-#include <QTextBrowser>
-#include <QPushButton>
-#include <QFileDialog>
-#include <QDir>
-#include <QFile>
-#include <QMessageBox>
-#include <QTextStream>
-#include <QCloseEvent>
-#include <QKeyEvent>
-#include "version.h"
 #include "log_browser_dialog.h"
 #include "document_window.h"
+#include "version.h"
+#include <QCloseEvent>
+#include <QDir>
+#include <QFile>
+#include <QFileDialog>
+#include <QHBoxLayout>
+#include <QKeyEvent>
+#include <QMessageBox>
+#include <QPushButton>
+#include <QTextBrowser>
+#include <QTextStream>
+#include <QVBoxLayout>
 
-LogBrowserDialog::LogBrowserDialog(QWidget *parent) :
+LogBrowserDialog::LogBrowserDialog(QWidget* parent)
-    QDialog(parent)
+    : QDialog(parent)
 {
     setWindowFlags(windowFlags() | Qt::WindowStaysOnTopHint);
-    
+
-    QVBoxLayout *layout = new QVBoxLayout;
+    QVBoxLayout* layout = new QVBoxLayout;
     setLayout(layout);
 
     m_browser = new QTextBrowser(this);
     layout->addWidget(m_browser);
 
-    QHBoxLayout *buttonLayout = new QHBoxLayout;
+    QHBoxLayout* buttonLayout = new QHBoxLayout;
     buttonLayout->setContentsMargins(0, 0, 0, 0);
     layout->addLayout(buttonLayout);
 
@@ -41,20 +41,17 @@ LogBrowserDialog::LogBrowserDialog(QWidget *parent) :
     connect(m_saveButton, SIGNAL(clicked()), this, SLOT(save()));
 
     resize(600, 300);
-    
+
     setWindowTitle(applicationTitle(tr("Debug")));
-    
+
     hide();
 }
 
-
 LogBrowserDialog::~LogBrowserDialog()
 {
-
 }
 
-
+void LogBrowserDialog::outputMessage(QtMsgType type, const QString& msg, const QString& source, int line)
-void LogBrowserDialog::outputMessage(QtMsgType type, const QString &msg, const QString &source, int line)
 {
     switch (type) {
     case QtDebugMsg:
@@ -79,7 +76,6 @@ void LogBrowserDialog::outputMessage(QtMsgType type, const QString &msg, const Q
     }
 }
 
-
 void LogBrowserDialog::save()
 {
     QString saveFileName = QFileDialog::getSaveFileName(this,
@@ -95,8 +91,8 @@ void LogBrowserDialog::save()
         QMessageBox::warning(this,
             tr("Error"),
             QString(tr("<nobr>File '%1'<br/>cannot be opened for writing.<br/><br/>"
-            "The log output could <b>not</b> be saved!</nobr>"))
+                       "The log output could <b>not</b> be saved!</nobr>"))
-            .arg(saveFileName));
+                .arg(saveFileName));
         return;
     }
 
@@ -105,7 +101,7 @@ void LogBrowserDialog::save()
     file.close();
 }
 
-void LogBrowserDialog::closeEvent(QCloseEvent *e)
+void LogBrowserDialog::closeEvent(QCloseEvent* e)
 {
     if (0 == DocumentWindow::total()) {
         e->accept();
@@ -115,7 +111,7 @@ void LogBrowserDialog::closeEvent(QCloseEvent *e)
     hide();
 }
 
-void LogBrowserDialog::keyPressEvent(QKeyEvent *e)
+void LogBrowserDialog::keyPressEvent(QKeyEvent* e)
 {
     e->ignore();
 }

application/sources/log_browser_dialog.h

@@ -6,26 +6,25 @@
 class QTextBrowser;
 class QPushButton;
 
-class LogBrowserDialog : public QDialog
+class LogBrowserDialog : public QDialog {
-{
     Q_OBJECT
 public:
-    LogBrowserDialog(QWidget *parent = 0);
+    LogBrowserDialog(QWidget* parent = 0);
     ~LogBrowserDialog();
 
 public slots:
-    void outputMessage(QtMsgType type, const QString &msg, const QString &source, int line);
+    void outputMessage(QtMsgType type, const QString& msg, const QString& source, int line);
 
 protected slots:
     void save();
 
 protected:
-    virtual void keyPressEvent(QKeyEvent *e);
+    virtual void keyPressEvent(QKeyEvent* e);
-    virtual void closeEvent(QCloseEvent *e);
+    virtual void closeEvent(QCloseEvent* e);
 
-    QTextBrowser *m_browser;
+    QTextBrowser* m_browser;
-    QPushButton *m_clearButton;
+    QPushButton* m_clearButton;
-    QPushButton *m_saveButton;
+    QPushButton* m_saveButton;
 };
 
 #endif

application/sources/main.cc

@@ -1,41 +1,40 @@
-#include <QApplication>
-#include <QSurfaceFormat>
-#include <QDebug>
-#include <iostream>
-#include <cstdio>
-#include <dust3d/base/string.h>
-#include "document_window.h"
 #include "document.h"
+#include "document_window.h"
 #include "theme.h"
 #include "version.h"
+#include <QApplication>
+#include <QDebug>
+#include <QSurfaceFormat>
+#include <cstdio>
+#include <dust3d/base/string.h>
+#include <iostream>
 
-int main(int argc, char *argv[])
+int main(int argc, char* argv[])
 {
     QApplication app(argc, argv);
-    
+
     QSurfaceFormat format = QSurfaceFormat::defaultFormat();
     format.setProfile(QSurfaceFormat::OpenGLContextProfile::CoreProfile);
     format.setVersion(3, 3);
     QSurfaceFormat::setDefaultFormat(format);
-    
+
     Theme::initialize();
-    
+
     QCoreApplication::setApplicationName(APP_NAME);
     QCoreApplication::setOrganizationName(APP_COMPANY);
     QCoreApplication::setOrganizationDomain(APP_HOMEPAGE_URL);
-    
+
     //freopen("dust3d.log", "w", stdout);
     //setvbuf(stdout, 0, _IONBF, 0);
-    
+
-    DocumentWindow *firstWindow = DocumentWindow::createDocumentWindow();
+    DocumentWindow* firstWindow = DocumentWindow::createDocumentWindow();
 
     QStringList openFileList;
     QStringList waitingExportList;
     bool toggleColor = false;
     for (int i = 1; i < argc; ++i) {
         if ('-' == argv[i][0]) {
-            if (0 == strcmp(argv[i], "-output") ||
+            if (0 == strcmp(argv[i], "-output") || 0 == strcmp(argv[i], "-o")) {
-                    0 == strcmp(argv[i], "-o")) {
                 ++i;
                 if (i < argc)
                     waitingExportList.append(argv[i]);
@@ -55,12 +54,12 @@ int main(int argc, char *argv[])
             continue;
         }
     }
-    
+
     int finishedExportFileNum = 0;
     int totalExportFileNum = 0;
     int succeedExportNum = 0;
     int exitCode = -1;
-    std::vector<DocumentWindow *> windowList;
+    std::vector<DocumentWindow*> windowList;
     auto checkToSafelyExit = [&]() {
         if (-1 == exitCode)
             return;
@@ -76,17 +75,16 @@ int main(int argc, char *argv[])
             windowList.push_back(DocumentWindow::createDocumentWindow());
         }
         if (toggleColor) {
-            for (auto &it: windowList)
+            for (auto& it : windowList)
                 it->toggleRenderColor();
         }
-        if (!waitingExportList.empty() &&
+        if (!waitingExportList.empty() && openFileList.size() == 1) {
-                openFileList.size() == 1) {
             totalExportFileNum = openFileList.size() * waitingExportList.size();
             for (int i = 0; i < openFileList.size(); ++i) {
                 QObject::connect(windowList[i], &DocumentWindow::workingStatusChanged, &app, checkToSafelyExit);
             }
             for (int i = 0; i < openFileList.size(); ++i) {
-                QObject::connect(windowList[i], &DocumentWindow::waitingExportFinished, &app, [&](const QString &filename, bool isSuccessful) {
+                QObject::connect(windowList[i], &DocumentWindow::waitingExportFinished, &app, [&](const QString& filename, bool isSuccessful) {
                     qDebug() << "Export to" << filename << (isSuccessful ? "isSuccessful" : "failed");
                     ++finishedExportFileNum;
                     if (isSuccessful)
@@ -112,6 +110,6 @@ int main(int argc, char *argv[])
             windowList[i]->openPathAs(openFileList[i], openFileList[i]);
         }
     }
-    
+
     return app.exec();
 }

application/sources/material.cc

@@ -1,21 +1,21 @@
 #include "material.h"
 #include "image_forever.h"
 
-void initializeMaterialTexturesFromSnapshot(const dust3d::Snapshot &snapshot,
+void initializeMaterialTexturesFromSnapshot(const dust3d::Snapshot& snapshot,
-    const dust3d::Uuid &materialId,
+    const dust3d::Uuid& materialId,
-    MaterialTextures &materialTextures,
+    MaterialTextures& materialTextures,
-    float &tileScale)
+    float& tileScale)
 {
     auto materialIdString = materialId.toString();
-    for (const auto &materialItem: snapshot.materials) {
+    for (const auto& materialItem : snapshot.materials) {
         if (materialIdString != dust3d::String::valueOrEmpty(materialItem.first, "id"))
             continue;
-        for (const auto &layer: materialItem.second) {
+        for (const auto& layer : materialItem.second) {
             //FIXME: Only support one layer currently
             auto findTileScale = layer.first.find("tileScale");
             if (findTileScale != layer.first.end())
                 tileScale = dust3d::String::toFloat(findTileScale->second);
-            for (const auto &mapItem: layer.second) {
+            for (const auto& mapItem : layer.second) {
                 auto textureType = dust3d::TextureTypeFromString(dust3d::String::valueOrEmpty(mapItem, "for").c_str());
                 if (textureType != dust3d::TextureType::None) {
                     int index = (int)textureType - 1;

application/sources/material.h

@@ -2,18 +2,17 @@
 #define DUST3D_APPLICATION_MATERIAL_H_
 
 #include <QImage>
-#include <dust3d/base/uuid.h>
-#include <dust3d/base/texture_type.h>
 #include <dust3d/base/snapshot.h>
+#include <dust3d/base/texture_type.h>
+#include <dust3d/base/uuid.h>
 
-struct MaterialTextures
+struct MaterialTextures {
-{
+    const QImage* textureImages[(int)dust3d::TextureType::Count - 1] = { nullptr };
-    const QImage *textureImages[(int)dust3d::TextureType::Count - 1] = {nullptr};
 };
 
-void initializeMaterialTexturesFromSnapshot(const dust3d::Snapshot &snapshot,
+void initializeMaterialTexturesFromSnapshot(const dust3d::Snapshot& snapshot,
-    const dust3d::Uuid &materialId,
+    const dust3d::Uuid& materialId,
-    MaterialTextures &materialTextures,
+    MaterialTextures& materialTextures,
-    float &tileScale);
+    float& tileScale);
 
 #endif

application/sources/material_edit_widget.cc

@@ -1,49 +1,49 @@
-#include <QVBoxLayout>
+#include "material_edit_widget.h"
-#include <QHBoxLayout>
+#include "document.h"
-#include <QGridLayout>
+#include "float_number_widget.h"
+#include "horizontal_line_widget.h"
+#include "image_forever.h"
+#include "theme.h"
+#include "version.h"
+#include <QFileDialog>
 #include <QFormLayout>
 #include <QGridLayout>
-#include <QMenu>
+#include <QHBoxLayout>
-#include <QWidgetAction>
-#include <QLineEdit>
-#include <QMessageBox>
-#include <QFileDialog>
 #include <QLabel>
+#include <QLineEdit>
+#include <QMenu>
+#include <QMessageBox>
 #include <QThread>
-#include "theme.h"
+#include <QVBoxLayout>
-#include "material_edit_widget.h"
+#include <QWidgetAction>
-#include "float_number_widget.h"
-#include "version.h"
-#include "image_forever.h"
-#include "document.h"
-#include "horizontal_line_widget.h"
 
-ImagePreviewWidget *MaterialEditWidget::createMapButton()
+ImagePreviewWidget* MaterialEditWidget::createMapButton()
 {
-    ImagePreviewWidget *mapButton = new ImagePreviewWidget;
+    ImagePreviewWidget* mapButton = new ImagePreviewWidget;
     mapButton->setFixedSize(Theme::partPreviewImageSize * 2, Theme::partPreviewImageSize * 2);
     updateMapButtonBackground(mapButton, nullptr);
     return mapButton;
 }
 
-QImage *MaterialEditWidget::pickImage()
+QImage* MaterialEditWidget::pickImage()
 {
     QString fileName = QFileDialog::getOpenFileName(this, QString(), QString(),
-        tr("Image Files (*.png *.jpg *.bmp)")).trimmed();
+        tr("Image Files (*.png *.jpg *.bmp)"))
+                           .trimmed();
     if (fileName.isEmpty())
         return nullptr;
-    QImage *image = new QImage();
+    QImage* image = new QImage();
     if (!image->load(fileName))
         return nullptr;
     return image;
 }
 
-MaterialEditWidget::MaterialEditWidget(const Document *document, QWidget *parent) :
+MaterialEditWidget::MaterialEditWidget(const Document* document, QWidget* parent)
-    QDialog(parent),
+    : QDialog(parent)
-    m_document(document)
+    , m_document(document)
 {
     setWindowFlags(windowFlags() | Qt::WindowStaysOnTopHint);
-    
+
     m_layers.resize(1);
 
     m_previewWidget = new ModelWidget(this);
@@ -51,24 +51,24 @@ MaterialEditWidget::MaterialEditWidget(const Document *document, QWidget *parent
     m_previewWidget->resize(512, 512);
     m_previewWidget->move(-128, -128);
     m_previewWidget->setNotGraphics(true);
-    
+
     QFont nameFont;
     nameFont.setWeight(QFont::Light);
     nameFont.setBold(false);
-    
+
-    QGridLayout *mapLayout = new QGridLayout;
+    QGridLayout* mapLayout = new QGridLayout;
     int row = 0;
     int col = 0;
     for (int i = 1; i < (int)dust3d::TextureType::Count; i++) {
-        QVBoxLayout *textureManageLayout = new QVBoxLayout;
+        QVBoxLayout* textureManageLayout = new QVBoxLayout;
-    
+
         MaterialMap item;
         item.forWhat = (dust3d::TextureType)i;
         m_layers[0].maps.push_back(item);
-        
+
-        ImagePreviewWidget *imageButton = createMapButton();
+        ImagePreviewWidget* imageButton = createMapButton();
         connect(imageButton, &ImagePreviewWidget::clicked, [=]() {
-            QImage *image = pickImage();
+            QImage* image = pickImage();
             if (nullptr == image)
                 return;
             m_layers[0].maps[(int)i - 1].imageId = ImageForever::add(image);
@@ -76,41 +76,41 @@ MaterialEditWidget::MaterialEditWidget(const Document *document, QWidget *parent
             delete image;
             emit layersAdjusted();
         });
-        
+
-        QLabel *nameLabel = new QLabel(tr(dust3d::TextureTypeToDispName(item.forWhat).c_str()));
+        QLabel* nameLabel = new QLabel(tr(dust3d::TextureTypeToDispName(item.forWhat).c_str()));
         nameLabel->setFont(nameFont);
-        
+
-        QPushButton *eraser = new QPushButton(QChar(fa::eraser));
+        QPushButton* eraser = new QPushButton(QChar(fa::eraser));
         Theme::initAwesomeToolButton(eraser);
-        
+
         connect(eraser, &QPushButton::clicked, [=]() {
             m_layers[0].maps[(int)i - 1].imageId = dust3d::Uuid();
             updateMapButtonBackground(imageButton, nullptr);
             emit layersAdjusted();
         });
-        
+
-        QHBoxLayout *textureTitleLayout = new QHBoxLayout;
+        QHBoxLayout* textureTitleLayout = new QHBoxLayout;
         textureTitleLayout->addWidget(eraser);
         textureTitleLayout->addWidget(nameLabel);
         textureTitleLayout->addStretch();
-        
+
         textureManageLayout->addWidget(imageButton);
         textureManageLayout->addLayout(textureTitleLayout);
         m_textureMapButtons[i - 1] = imageButton;
-        
+
         mapLayout->addLayout(textureManageLayout, row, col++);
         if (col == 2) {
             col = 0;
             row++;
         }
     }
-    
+
-    QVBoxLayout *rightLayout = new QVBoxLayout;
+    QVBoxLayout* rightLayout = new QVBoxLayout;
     rightLayout->addStretch();
     rightLayout->addLayout(mapLayout);
     rightLayout->addStretch();
 
-    QHBoxLayout *paramtersLayout = new QHBoxLayout;
+    QHBoxLayout* paramtersLayout = new QHBoxLayout;
     paramtersLayout->setContentsMargins(256, 0, 0, 0);
     paramtersLayout->addStretch();
     paramtersLayout->addLayout(rightLayout);
@@ -120,41 +120,41 @@ MaterialEditWidget::MaterialEditWidget(const Document *document, QWidget *parent
         m_unsaved = true;
         updateTitle();
     });
-    QPushButton *saveButton = new QPushButton(tr("Save"));
+    QPushButton* saveButton = new QPushButton(tr("Save"));
     connect(saveButton, &QPushButton::clicked, this, &MaterialEditWidget::save);
     saveButton->setDefault(true);
-    
+
-    FloatNumberWidget *tileScaleWidget = new FloatNumberWidget;
+    FloatNumberWidget* tileScaleWidget = new FloatNumberWidget;
     tileScaleWidget->setItemName(tr("Tile Scale"));
     tileScaleWidget->setRange(0.01, 1.0);
     tileScaleWidget->setValue(m_layers[0].tileScale);
-    
+
     m_tileScaleSlider = tileScaleWidget;
-    
+
     connect(tileScaleWidget, &FloatNumberWidget::valueChanged, [=](float value) {
         m_layers[0].tileScale = value;
         emit layersAdjusted();
     });
-    
+
-    QPushButton *tileScaleEraser = new QPushButton(QChar(fa::eraser));
+    QPushButton* tileScaleEraser = new QPushButton(QChar(fa::eraser));
     Theme::initAwesomeToolButton(tileScaleEraser);
-    
+
     connect(tileScaleEraser, &QPushButton::clicked, [=]() {
         tileScaleWidget->setValue(1.0);
     });
-    
+
-    QHBoxLayout *tileScaleLayout = new QHBoxLayout;
+    QHBoxLayout* tileScaleLayout = new QHBoxLayout;
     tileScaleLayout->addWidget(tileScaleEraser);
     tileScaleLayout->addWidget(tileScaleWidget);
     tileScaleLayout->addStretch();
 
-    QHBoxLayout *baseInfoLayout = new QHBoxLayout;
+    QHBoxLayout* baseInfoLayout = new QHBoxLayout;
     baseInfoLayout->addWidget(new QLabel(tr("Name")));
     baseInfoLayout->addWidget(m_nameEdit);
     baseInfoLayout->addStretch();
     baseInfoLayout->addWidget(saveButton);
 
-    QVBoxLayout *mainLayout = new QVBoxLayout;
+    QVBoxLayout* mainLayout = new QVBoxLayout;
     mainLayout->addLayout(paramtersLayout);
     mainLayout->addStretch();
     mainLayout->addWidget(new HorizontalLineWidget());
@@ -176,7 +176,7 @@ MaterialEditWidget::MaterialEditWidget(const Document *document, QWidget *parent
     updateTitle();
 }
 
-void MaterialEditWidget::updateMapButtonBackground(ImagePreviewWidget *button, const QImage *image)
+void MaterialEditWidget::updateMapButtonBackground(ImagePreviewWidget* button, const QImage* image)
 {
     if (nullptr == image)
         button->updateImage(QImage());
@@ -189,7 +189,7 @@ void MaterialEditWidget::reject()
     close();
 }
 
-void MaterialEditWidget::closeEvent(QCloseEvent *event)
+void MaterialEditWidget::closeEvent(QCloseEvent* event)
 {
     if (m_unsaved && !m_closed) {
         QMessageBox::StandardButton answer = QMessageBox::question(this,
@@ -235,7 +235,7 @@ void MaterialEditWidget::updatePreview()
 
     qDebug() << "Material preview generating..";
 
-    QThread *thread = new QThread;
+    QThread* thread = new QThread;
     m_materialPreviewsGenerator = new MaterialPreviewsGenerator();
     m_materialPreviewsGenerator->addMaterial(dust3d::Uuid(), m_layers);
     m_materialPreviewsGenerator->moveToThread(thread);
@@ -279,7 +279,7 @@ void MaterialEditWidget::updateTitle()
         setWindowTitle(applicationTitle(tr("New") + (m_unsaved ? "*" : "")));
         return;
     }
-    const Material *material = m_document->findMaterial(m_materialId);
+    const Material* material = m_document->findMaterial(m_materialId);
     if (nullptr == material) {
         qDebug() << "Find material failed:" << m_materialId;
         return;
@@ -299,9 +299,9 @@ void MaterialEditWidget::setEditMaterialLayers(std::vector<MaterialLayer> layers
         m_layers[0].maps[i - 1].imageId = dust3d::Uuid();
     }
     if (!layers.empty()) {
-        for (const auto &layer: layers) {
+        for (const auto& layer : layers) {
             m_layers[0].tileScale = layer.tileScale;
-            for (const auto &mapItem: layer.maps) {
+            for (const auto& mapItem : layer.maps) {
                 int index = (int)mapItem.forWhat - 1;
                 if (index >= 0 && index < (int)dust3d::TextureType::Count - 1) {
                     m_layers[0].maps[index].imageId = mapItem.imageId;

application/sources/material_edit_widget.h

@@ -1,26 +1,24 @@
 #ifndef DUST3D_APPLICATION_MATERIAL_EDIT_WIDGET_H_
 #define DUST3D_APPLICATION_MATERIAL_EDIT_WIDGET_H_
 
-#include <QDialog>
-#include <map>
-#include <QCloseEvent>
-#include <QLineEdit>
-#include "model_widget.h"
-#include "material_previews_generator.h"
-#include "image_preview_widget.h"
 #include "float_number_widget.h"
+#include "image_preview_widget.h"
 #include "material_layer.h"
+#include "material_previews_generator.h"
+#include "model_widget.h"
+#include <QCloseEvent>
+#include <QDialog>
+#include <QLineEdit>
+#include <map>
 
 class Document;
 
-enum class PopupWidgetType
+enum class PopupWidgetType {
-{
     PitchYawRoll,
     Intersection
 };
 
-class MaterialEditWidget : public QDialog
+class MaterialEditWidget : public QDialog {
-{
     Q_OBJECT
 signals:
     void addMaterial(dust3d::Uuid materialId, QString name, std::vector<MaterialLayer> layers);
@@ -28,8 +26,9 @@ signals:
     void setMaterialLayers(dust3d::Uuid materialId, std::vector<MaterialLayer> layers);
     void renameMaterial(dust3d::Uuid materialId, QString name);
     void layersAdjusted();
+
 public:
-    MaterialEditWidget(const Document *document, QWidget *parent=nullptr);
+    MaterialEditWidget(const Document* document, QWidget* parent = nullptr);
     ~MaterialEditWidget();
 public slots:
     void updatePreview();
@@ -40,25 +39,27 @@ public slots:
     void save();
     void clearUnsaveState();
     void previewReady();
+
 protected:
     QSize sizeHint() const override;
-    void closeEvent(QCloseEvent *event) override;
+    void closeEvent(QCloseEvent* event) override;
     void reject() override;
+
 private:
-    void updateMapButtonBackground(ImagePreviewWidget *button, const QImage *image);
+    void updateMapButtonBackground(ImagePreviewWidget* button, const QImage* image);
-    ImagePreviewWidget *createMapButton();
+    ImagePreviewWidget* createMapButton();
-    QImage *pickImage();
+    QImage* pickImage();
-    const Document *m_document = nullptr;
+    const Document* m_document = nullptr;
-    MaterialPreviewsGenerator *m_materialPreviewsGenerator = nullptr;
+    MaterialPreviewsGenerator* m_materialPreviewsGenerator = nullptr;
-    ModelWidget *m_previewWidget = nullptr;
+    ModelWidget* m_previewWidget = nullptr;
-    FloatNumberWidget *m_tileScaleSlider = nullptr;
+    FloatNumberWidget* m_tileScaleSlider = nullptr;
     bool m_isPreviewDirty = false;
     bool m_closed = false;
     dust3d::Uuid m_materialId;
     bool m_unsaved = false;
-    QLineEdit *m_nameEdit = nullptr;
+    QLineEdit* m_nameEdit = nullptr;
     std::vector<MaterialLayer> m_layers;
-    ImagePreviewWidget *m_textureMapButtons[(int)dust3d::TextureType::Count - 1] = {nullptr};
+    ImagePreviewWidget* m_textureMapButtons[(int)dust3d::TextureType::Count - 1] = { nullptr };
 };
 
 #endif

application/sources/material_layer.h

@@ -1,19 +1,17 @@
 #ifndef DUST3D_APPLICATION_MATERIAL_LAYER_H_
 #define DUST3D_APPLICATION_MATERIAL_LAYER_H_
 
-#include <vector>
 #include <dust3d/base/texture_type.h>
 #include <dust3d/base/uuid.h>
+#include <vector>
 
-class MaterialMap
+class MaterialMap {
-{
 public:
     dust3d::TextureType forWhat;
     dust3d::Uuid imageId;
 };
 
-class MaterialLayer
+class MaterialLayer {
-{
 public:
     std::vector<MaterialMap> maps;
     float tileScale = 1.0;

application/sources/material_list_widget.cc

@@ -1,15 +1,15 @@
+#include "material_list_widget.h"
+#include "document.h"
+#include <QApplication>
+#include <QClipboard>
 #include <QGuiApplication>
 #include <QMenu>
 #include <QXmlStreamWriter>
-#include <QClipboard>
-#include <QApplication>
 #include <dust3d/base/snapshot_xml.h>
-#include "material_list_widget.h"
-#include "document.h"
 
-MaterialListWidget::MaterialListWidget(const Document *document, QWidget *parent) :
+MaterialListWidget::MaterialListWidget(const Document* document, QWidget* parent)
-    QTreeWidget(parent),
+    : QTreeWidget(parent)
-    m_document(document)
+    , m_document(document)
 {
     setVerticalScrollMode(QAbstractItemView::ScrollPerPixel);
     setFocusPolicy(Qt::NoFocus);
@@ -59,7 +59,7 @@ void MaterialListWidget::updateMaterialSelectState(dust3d::Uuid materialId, bool
         qDebug() << "Find material item failed:" << materialId;
         return;
     }
-    MaterialWidget *materialWidget = (MaterialWidget *)itemWidget(findItemResult->second.first, findItemResult->second.second);
+    MaterialWidget* materialWidget = (MaterialWidget*)itemWidget(findItemResult->second.first, findItemResult->second.second);
     materialWidget->updateCheckedState(selected);
 }
 
@@ -90,7 +90,7 @@ void MaterialListWidget::selectMaterial(dust3d::Uuid materialId, bool multiple)
         }
     }
     if (!m_selectedMaterialIds.empty()) {
-        for (const auto &id: m_selectedMaterialIds) {
+        for (const auto& id : m_selectedMaterialIds) {
             updateMaterialSelectState(id, false);
         }
         m_selectedMaterialIds.clear();
@@ -107,20 +107,20 @@ void MaterialListWidget::selectMaterial(dust3d::Uuid materialId, bool multiple)
     }
 }
 
-void MaterialListWidget::mousePressEvent(QMouseEvent *event)
+void MaterialListWidget::mousePressEvent(QMouseEvent* event)
 {
     QModelIndex itemIndex = indexAt(event->pos());
     QTreeView::mousePressEvent(event);
     if (event->button() == Qt::LeftButton) {
         bool multiple = QGuiApplication::queryKeyboardModifiers().testFlag(Qt::ControlModifier);
         if (itemIndex.isValid()) {
-            QTreeWidgetItem *item = itemFromIndex(itemIndex);
+            QTreeWidgetItem* item = itemFromIndex(itemIndex);
             auto materialId = dust3d::Uuid(item->data(itemIndex.column(), Qt::UserRole).toString().toUtf8().constData());
             if (QGuiApplication::queryKeyboardModifiers().testFlag(Qt::ShiftModifier)) {
                 bool startAdd = false;
                 bool stopAdd = false;
                 std::vector<dust3d::Uuid> waitQueue;
-                for (const auto &childId: m_document->materialIdList) {
+                for (const auto& childId : m_document->materialIdList) {
                     if (m_shiftStartMaterialId == childId || materialId == childId) {
                         if (startAdd) {
                             stopAdd = true;
@@ -135,7 +135,7 @@ void MaterialListWidget::mousePressEvent(QMouseEvent *event)
                 }
                 if (stopAdd && !waitQueue.empty()) {
                     if (!m_selectedMaterialIds.empty()) {
-                        for (const auto &id: m_selectedMaterialIds) {
+                        for (const auto& id : m_selectedMaterialIds) {
                             updateMaterialSelectState(id, false);
                         }
                         m_selectedMaterialIds.clear();
@@ -143,7 +143,7 @@ void MaterialListWidget::mousePressEvent(QMouseEvent *event)
                     if (!m_currentSelectedMaterialId.isNull()) {
                         m_currentSelectedMaterialId = dust3d::Uuid();
                     }
-                    for (const auto &waitId: waitQueue) {
+                    for (const auto& waitId : waitQueue) {
                         selectMaterial(waitId, true);
                     }
                 }
@@ -161,11 +161,10 @@ void MaterialListWidget::mousePressEvent(QMouseEvent *event)
 
 bool MaterialListWidget::isMaterialSelected(dust3d::Uuid materialId)
 {
-    return (m_currentSelectedMaterialId == materialId ||
+    return (m_currentSelectedMaterialId == materialId || m_selectedMaterialIds.find(materialId) != m_selectedMaterialIds.end());
-        m_selectedMaterialIds.find(materialId) != m_selectedMaterialIds.end());
 }
 
-void MaterialListWidget::showContextMenu(const QPoint &pos)
+void MaterialListWidget::showContextMenu(const QPoint& pos)
 {
     if (!m_hasContextMenu)
         return;
@@ -177,7 +176,7 @@ void MaterialListWidget::showContextMenu(const QPoint &pos)
         unorderedMaterialIds.insert(m_currentSelectedMaterialId);
 
     std::vector<dust3d::Uuid> materialIds;
-    for (const auto &cand: m_document->materialIdList) {
+    for (const auto& cand : m_document->materialIdList) {
         if (unorderedMaterialIds.find(cand) != unorderedMaterialIds.end())
             materialIds.push_back(cand);
     }
@@ -205,7 +204,7 @@ void MaterialListWidget::showContextMenu(const QPoint &pos)
     QAction deleteAction(tr("Delete"), this);
     if (!materialIds.empty()) {
         connect(&deleteAction, &QAction::triggered, [=]() {
-            for (const auto &materialId: materialIds)
+            for (const auto& materialId : materialIds)
                 emit removeMaterial(materialId);
         });
         contextMenu.addAction(&deleteAction);
@@ -214,7 +213,7 @@ void MaterialListWidget::showContextMenu(const QPoint &pos)
     contextMenu.exec(mapToGlobal(pos));
 }
 
-void MaterialListWidget::resizeEvent(QResizeEvent *event)
+void MaterialListWidget::resizeEvent(QResizeEvent* event)
 {
     QTreeWidget::resizeEvent(event);
     if (calculateColumnCount() != columnCount())
@@ -247,11 +246,11 @@ void MaterialListWidget::reload()
     setColumnCount(columns);
     for (int i = 0; i < columns; i++)
         setColumnWidth(i, columnWidth);
-    
+
     std::vector<dust3d::Uuid> orderedMaterialIdList = m_document->materialIdList;
-    std::sort(orderedMaterialIdList.begin(), orderedMaterialIdList.end(), [&](const dust3d::Uuid &firstMaterialId, const dust3d::Uuid &secondMaterialId) {
+    std::sort(orderedMaterialIdList.begin(), orderedMaterialIdList.end(), [&](const dust3d::Uuid& firstMaterialId, const dust3d::Uuid& secondMaterialId) {
-        const auto *firstMaterial = m_document->findMaterial(firstMaterialId);
+        const auto* firstMaterial = m_document->findMaterial(firstMaterialId);
-        const auto *secondMaterial = m_document->findMaterial(secondMaterialId);
+        const auto* secondMaterial = m_document->findMaterial(secondMaterialId);
         if (nullptr == firstMaterial || nullptr == secondMaterial)
             return false;
         return QString::compare(firstMaterial->name, secondMaterial->name, Qt::CaseInsensitive) < 0;
@@ -259,13 +258,13 @@ void MaterialListWidget::reload()
 
     decltype(orderedMaterialIdList.size()) materialIndex = 0;
     while (materialIndex < orderedMaterialIdList.size()) {
-        QTreeWidgetItem *item = new QTreeWidgetItem(this);
+        QTreeWidgetItem* item = new QTreeWidgetItem(this);
         item->setFlags((item->flags() | Qt::ItemIsEnabled) & ~(Qt::ItemIsSelectable) & ~(Qt::ItemIsEditable));
         for (int col = 0; col < columns && materialIndex < orderedMaterialIdList.size(); col++, materialIndex++) {
-            const auto &materialId = orderedMaterialIdList[materialIndex];
+            const auto& materialId = orderedMaterialIdList[materialIndex];
             item->setSizeHint(col, QSize(columnWidth, MaterialWidget::preferredHeight() + 2));
             item->setData(col, Qt::UserRole, QString(materialId.toString().c_str()));
-            MaterialWidget *widget = new MaterialWidget(m_document, materialId);
+            MaterialWidget* widget = new MaterialWidget(m_document, materialId);
             connect(widget, &MaterialWidget::modifyMaterial, this, &MaterialListWidget::modifyMaterial);
             setItemWidget(item, col, widget);
             widget->reload();
@@ -301,9 +300,9 @@ void MaterialListWidget::copy()
     dust3d::Snapshot snapshot;
     m_document->toSnapshot(&snapshot, emptySet, DocumentToSnapshotFor::Materials,
         limitMaterialIds);
-        
+
     std::string snapshotXml;
     dust3d::saveSnapshotToXmlString(snapshot, snapshotXml);
-    QClipboard *clipboard = QApplication::clipboard();
+    QClipboard* clipboard = QApplication::clipboard();
     clipboard->setText(snapshotXml.c_str());
 }

application/sources/material_list_widget.h

@@ -1,41 +1,43 @@
 #ifndef DUST3D_APPLICATION_MATERIAL_LIST_WIDGET_H_
 #define DUST3D_APPLICATION_MATERIAL_LIST_WIDGET_H_
 
+#include "material_widget.h"
+#include <QMouseEvent>
 #include <QTreeWidget>
 #include <map>
-#include <QMouseEvent>
-#include "material_widget.h"
 
 class Document;
 
-class MaterialListWidget : public QTreeWidget
+class MaterialListWidget : public QTreeWidget {
-{
     Q_OBJECT
 signals:
     void removeMaterial(dust3d::Uuid materialId);
     void modifyMaterial(dust3d::Uuid materialId);
     void cornerButtonClicked(dust3d::Uuid materialId);
     void currentSelectedMaterialChanged(dust3d::Uuid materialId);
+
 public:
-    MaterialListWidget(const Document *document, QWidget *parent=nullptr);
+    MaterialListWidget(const Document* document, QWidget* parent = nullptr);
     bool isMaterialSelected(dust3d::Uuid materialId);
     void enableMultipleSelection(bool enabled);
 public slots:
     void reload();
     void removeAllContent();
     void materialRemoved(dust3d::Uuid materialId);
-    void showContextMenu(const QPoint &pos);
+    void showContextMenu(const QPoint& pos);
-    void selectMaterial(dust3d::Uuid materialId, bool multiple=false);
+    void selectMaterial(dust3d::Uuid materialId, bool multiple = false);
     void copy();
     void setHasContextMenu(bool hasContextMenu);
+
 protected:
-    void resizeEvent(QResizeEvent *event) override;
+    void resizeEvent(QResizeEvent* event) override;
-    void mousePressEvent(QMouseEvent *event) override;
+    void mousePressEvent(QMouseEvent* event) override;
+
 private:
     int calculateColumnCount();
     void updateMaterialSelectState(dust3d::Uuid materialId, bool selected);
-    const Document *m_document = nullptr;
+    const Document* m_document = nullptr;
-    std::map<dust3d::Uuid, std::pair<QTreeWidgetItem *, int>> m_itemMap;
+    std::map<dust3d::Uuid, std::pair<QTreeWidgetItem*, int>> m_itemMap;
     std::set<dust3d::Uuid> m_selectedMaterialIds;
     dust3d::Uuid m_currentSelectedMaterialId;
     dust3d::Uuid m_shiftStartMaterialId;

application/sources/material_manage_widget.cc

@@ -1,34 +1,34 @@
-#include <QHBoxLayout>
-#include <QVBoxLayout>
-#include <QPushButton>
 #include "material_manage_widget.h"
-#include "theme.h"
-#include "material_edit_widget.h"
-#include "info_label.h"
 #include "document.h"
+#include "info_label.h"
+#include "material_edit_widget.h"
+#include "theme.h"
+#include <QHBoxLayout>
+#include <QPushButton>
+#include <QVBoxLayout>
 
-MaterialManageWidget::MaterialManageWidget(const Document *document, QWidget *parent) :
+MaterialManageWidget::MaterialManageWidget(const Document* document, QWidget* parent)
-    QWidget(parent),
+    : QWidget(parent)
-    m_document(document)
+    , m_document(document)
 {
-    QPushButton *addMaterialButton = new QPushButton(Theme::awesome()->icon(fa::plus), tr("Add Material..."));
+    QPushButton* addMaterialButton = new QPushButton(Theme::awesome()->icon(fa::plus), tr("Add Material..."));
 
     connect(addMaterialButton, &QPushButton::clicked, this, &MaterialManageWidget::showAddMaterialDialog);
 
-    QHBoxLayout *toolsLayout = new QHBoxLayout;
+    QHBoxLayout* toolsLayout = new QHBoxLayout;
     toolsLayout->addWidget(addMaterialButton);
 
     m_materialListWidget = new MaterialListWidget(document);
     connect(m_materialListWidget, &MaterialListWidget::modifyMaterial, this, &MaterialManageWidget::showMaterialDialog);
 
-    QVBoxLayout *mainLayout = new QVBoxLayout;
+    QVBoxLayout* mainLayout = new QVBoxLayout;
     mainLayout->addLayout(toolsLayout);
     mainLayout->addWidget(m_materialListWidget);
 
     setLayout(mainLayout);
 }
 
-MaterialListWidget *MaterialManageWidget::materialListWidget()
+MaterialListWidget* MaterialManageWidget::materialListWidget()
 {
     return m_materialListWidget;
 }
@@ -45,10 +45,10 @@ void MaterialManageWidget::showAddMaterialDialog()
 
 void MaterialManageWidget::showMaterialDialog(dust3d::Uuid materialId)
 {
-    MaterialEditWidget *materialEditWidget = new MaterialEditWidget(m_document);
+    MaterialEditWidget* materialEditWidget = new MaterialEditWidget(m_document);
     materialEditWidget->setAttribute(Qt::WA_DeleteOnClose);
     if (!materialId.isNull()) {
-        const Material *material = m_document->findMaterial(materialId);
+        const Material* material = m_document->findMaterial(materialId);
         if (nullptr != material) {
             materialEditWidget->setEditMaterialId(materialId);
             materialEditWidget->setEditMaterialName(material->name);
@@ -58,7 +58,7 @@ void MaterialManageWidget::showMaterialDialog(dust3d::Uuid materialId)
     }
     materialEditWidget->show();
     connect(materialEditWidget, &QDialog::destroyed, [=]() {
-        emit unregisterDialog((QWidget *)materialEditWidget);
+        emit unregisterDialog((QWidget*)materialEditWidget);
     });
-    emit registerDialog((QWidget *)materialEditWidget);
+    emit registerDialog((QWidget*)materialEditWidget);
 }

application/sources/material_manage_widget.h

@@ -1,28 +1,30 @@
 #ifndef DUST3D_APPLICATION_MATERIAL_MANAGE_WIDGET_H_
 #define DUST3D_APPLICATION_MATERIAL_MANAGE_WIDGET_H_
 
-#include <QWidget>
 #include "material_list_widget.h"
+#include <QWidget>
 
 class Document;
 
-class MaterialManageWidget : public QWidget
+class MaterialManageWidget : public QWidget {
-{
     Q_OBJECT
 signals:
-    void registerDialog(QWidget *widget);
+    void registerDialog(QWidget* widget);
-    void unregisterDialog(QWidget *widget);
+    void unregisterDialog(QWidget* widget);
+
 public:
-    MaterialManageWidget(const Document *document, QWidget *parent=nullptr);
+    MaterialManageWidget(const Document* document, QWidget* parent = nullptr);
-    MaterialListWidget *materialListWidget();
+    MaterialListWidget* materialListWidget();
+
 protected:
     virtual QSize sizeHint() const;
 public slots:
     void showAddMaterialDialog();
     void showMaterialDialog(dust3d::Uuid materialId);
+
 private:
-    const Document *m_document = nullptr;
+    const Document* m_document = nullptr;
-    MaterialListWidget *m_materialListWidget = nullptr;
+    MaterialListWidget* m_materialListWidget = nullptr;
 };
 
 #endif

application/sources/material_previews_generator.cc

@@ -1,14 +1,14 @@
-#include <QGuiApplication>
+#include "material_previews_generator.h"
-#include <QElapsedTimer>
+#include "image_forever.h"
+#include "mesh_generator.h"
+#include "mesh_result_post_processor.h"
+#include "texture_generator.h"
 #include <QDebug>
+#include <QElapsedTimer>
 #include <QFile>
+#include <QGuiApplication>
 #include <dust3d/base/ds3_file.h>
 #include <dust3d/base/snapshot_xml.h>
-#include "material_previews_generator.h"
-#include "mesh_generator.h"
-#include "texture_generator.h"
-#include "image_forever.h"
-#include "mesh_result_post_processor.h"
 
 MaterialPreviewsGenerator::MaterialPreviewsGenerator()
 {
@@ -16,78 +16,78 @@ MaterialPreviewsGenerator::MaterialPreviewsGenerator()
 
 MaterialPreviewsGenerator::~MaterialPreviewsGenerator()
 {
-    for (auto &item: m_previews) {
+    for (auto& item : m_previews) {
         delete item.second;
     }
 }
 
-void MaterialPreviewsGenerator::addMaterial(dust3d::Uuid materialId, const std::vector<MaterialLayer> &layers)
+void MaterialPreviewsGenerator::addMaterial(dust3d::Uuid materialId, const std::vector<MaterialLayer>& layers)
 {
-    m_materials.push_back({materialId, layers});
+    m_materials.push_back({ materialId, layers });
 }
 
-const std::set<dust3d::Uuid> &MaterialPreviewsGenerator::generatedPreviewMaterialIds()
+const std::set<dust3d::Uuid>& MaterialPreviewsGenerator::generatedPreviewMaterialIds()
 {
     return m_generatedMaterialIds;
 }
 
-ModelMesh *MaterialPreviewsGenerator::takePreview(dust3d::Uuid materialId)
+ModelMesh* MaterialPreviewsGenerator::takePreview(dust3d::Uuid materialId)
 {
-    ModelMesh *resultMesh = m_previews[materialId];
+    ModelMesh* resultMesh = m_previews[materialId];
     m_previews[materialId] = nullptr;
     return resultMesh;
 }
 
 void MaterialPreviewsGenerator::generate()
 {
-    dust3d::Snapshot *snapshot = new dust3d::Snapshot;
+    dust3d::Snapshot* snapshot = new dust3d::Snapshot;
-    
+
     QFile file(":/resources/material-demo-model.ds3");
     file.open(QFile::ReadOnly);
     QByteArray fileData = file.readAll();
-    
+
     std::vector<dust3d::Uuid> partIds;
-    dust3d::Ds3FileReader ds3Reader((const std::uint8_t *)fileData.data(), fileData.size());
+    dust3d::Ds3FileReader ds3Reader((const std::uint8_t*)fileData.data(), fileData.size());
     for (int i = 0; i < (int)ds3Reader.items().size(); ++i) {
         dust3d::Ds3ReaderItem item = ds3Reader.items().at(i);
         if (item.type == "model") {
             std::vector<std::uint8_t> data;
             ds3Reader.loadItem(item.name, &data);
-            std::string xmlString((char *)data.data(), data.size());
+            std::string xmlString((char*)data.data(), data.size());
-            dust3d::loadSnapshotFromXmlString(snapshot, (char *)xmlString.c_str());
+            dust3d::loadSnapshotFromXmlString(snapshot, (char*)xmlString.c_str());
-            for (const auto &item: snapshot->parts) {
+            for (const auto& item : snapshot->parts) {
                 partIds.push_back(dust3d::Uuid(item.first));
             }
         }
     }
-    
+
-    dust3d::MeshGenerator::GeneratedCacheContext *cacheContext = new dust3d::MeshGenerator::GeneratedCacheContext();
+    dust3d::MeshGenerator::GeneratedCacheContext* cacheContext = new dust3d::MeshGenerator::GeneratedCacheContext();
-    MeshGenerator *meshGenerator = new MeshGenerator(snapshot);
+    MeshGenerator* meshGenerator = new MeshGenerator(snapshot);
     meshGenerator->setGeneratedCacheContext(cacheContext);
-    
+
     meshGenerator->generate();
-    for (const auto &mirror: cacheContext->partMirrorIdMap) {
+    for (const auto& mirror : cacheContext->partMirrorIdMap) {
         partIds.push_back(dust3d::Uuid(mirror.first));
     }
-    
+
-    dust3d::Object *object = meshGenerator->takeObject();
+    dust3d::Object* object = meshGenerator->takeObject();
     if (nullptr != object) {
-        MeshResultPostProcessor *poseProcessor = new MeshResultPostProcessor(*object);
+        MeshResultPostProcessor* poseProcessor = new MeshResultPostProcessor(*object);
         poseProcessor->poseProcess();
         delete object;
         object = poseProcessor->takePostProcessedObject();
         delete poseProcessor;
     }
-    
+
     if (nullptr != object) {
-        for (const auto &material: m_materials) {
+        for (const auto& material : m_materials) {
-            TextureGenerator *textureGenerator = new TextureGenerator(*object);
+            TextureGenerator* textureGenerator = new TextureGenerator(*object);
-            for (const auto &layer: material.second) {
+            for (const auto& layer : material.second) {
-                for (const auto &mapItem: layer.maps) {
+                for (const auto& mapItem : layer.maps) {
-                    const QImage *image = ImageForever::get(mapItem.imageId);
+                    const QImage* image = ImageForever::get(mapItem.imageId);
                     if (nullptr == image)
                         continue;
-                    for (const auto &partId: partIds) {
+                    for (const auto& partId : partIds) {
                         if (dust3d::TextureType::BaseColor == mapItem.forWhat)
                             textureGenerator->addPartColorMap(partId, image, layer.tileScale);
                         else if (dust3d::TextureType::Normal == mapItem.forWhat)
@@ -102,7 +102,7 @@ void MaterialPreviewsGenerator::generate()
                 }
             }
             textureGenerator->generate();
-            ModelMesh *texturedResultMesh = textureGenerator->takeResultMesh();
+            ModelMesh* texturedResultMesh = textureGenerator->takeResultMesh();
             if (nullptr != texturedResultMesh) {
                 m_previews[material.first] = new ModelMesh(*texturedResultMesh);
                 m_generatedMaterialIds.insert(material.first);
@@ -111,9 +111,9 @@ void MaterialPreviewsGenerator::generate()
             delete textureGenerator;
         }
     }
-    
+
     delete object;
-    
+
     delete meshGenerator;
     delete cacheContext;
 }

application/sources/material_previews_generator.h

@@ -1,29 +1,29 @@
 #ifndef DUST3D_APPLICATION_MATERIAL_PREVIEWS_GENERATOR_H_
 #define DUST3D_APPLICATION_MATERIAL_PREVIEWS_GENERATOR_H_
 
+#include "material_layer.h"
+#include "model_mesh.h"
 #include <QObject>
 #include <map>
 #include <vector>
-#include "model_mesh.h"
-#include "material_layer.h"
 
-class MaterialPreviewsGenerator : public QObject
+class MaterialPreviewsGenerator : public QObject {
-{
     Q_OBJECT
 public:
     MaterialPreviewsGenerator();
     ~MaterialPreviewsGenerator();
-    void addMaterial(dust3d::Uuid materialId, const std::vector<MaterialLayer> &layers);
+    void addMaterial(dust3d::Uuid materialId, const std::vector<MaterialLayer>& layers);
-    const std::set<dust3d::Uuid> &generatedPreviewMaterialIds();
+    const std::set<dust3d::Uuid>& generatedPreviewMaterialIds();
-    ModelMesh *takePreview(dust3d::Uuid materialId);
+    ModelMesh* takePreview(dust3d::Uuid materialId);
     void generate();
 signals:
     void finished();
 public slots:
     void process();
+
 private:
     std::vector<std::pair<dust3d::Uuid, std::vector<MaterialLayer>>> m_materials;
-    std::map<dust3d::Uuid, ModelMesh *> m_previews;
+    std::map<dust3d::Uuid, ModelMesh*> m_previews;
     std::set<dust3d::Uuid> m_generatedMaterialIds;
 };
 

application/sources/material_widget.cc

@@ -1,10 +1,10 @@
-#include <QVBoxLayout>
 #include "material_widget.h"
 #include "document.h"
+#include <QVBoxLayout>
 
-MaterialWidget::MaterialWidget(const Document *document, dust3d::Uuid materialId) :
+MaterialWidget::MaterialWidget(const Document* document, dust3d::Uuid materialId)
-    m_materialId(materialId),
+    : m_materialId(materialId)
-    m_document(document)
+    , m_document(document)
 {
     setObjectName("MaterialFrame");
 
@@ -23,7 +23,7 @@ MaterialWidget::MaterialWidget(const Document *document, dust3d::Uuid materialId
     nameFont.setBold(false);
     m_nameLabel->setFont(nameFont);
 
-    QVBoxLayout *mainLayout = new QVBoxLayout;
+    QVBoxLayout* mainLayout = new QVBoxLayout;
     mainLayout->setContentsMargins(0, 0, 0, 0);
     mainLayout->addStretch();
     mainLayout->addWidget(m_nameLabel);
@@ -36,7 +36,7 @@ MaterialWidget::MaterialWidget(const Document *document, dust3d::Uuid materialId
     connect(document, &Document::materialPreviewChanged, this, &MaterialWidget::updatePreview);
 }
 
-void MaterialWidget::resizeEvent(QResizeEvent *event)
+void MaterialWidget::resizeEvent(QResizeEvent* event)
 {
     QWidget::resizeEvent(event);
     m_previewWidget->move((width() - Theme::materialPreviewImageSize) / 2, 0);
@@ -57,12 +57,12 @@ void MaterialWidget::updatePreview(dust3d::Uuid materialId)
 {
     if (materialId != m_materialId)
         return;
-    const Material *material = m_document->findMaterial(m_materialId);
+    const Material* material = m_document->findMaterial(m_materialId);
     if (!material) {
         qDebug() << "Material not found:" << m_materialId;
         return;
     }
-    ModelMesh *previewMesh = material->takePreviewMesh();
+    ModelMesh* previewMesh = material->takePreviewMesh();
     m_previewWidget->updateMesh(previewMesh);
 }
 
@@ -70,7 +70,7 @@ void MaterialWidget::updateName(dust3d::Uuid materialId)
 {
     if (materialId != m_materialId)
         return;
-    const Material *material = m_document->findMaterial(m_materialId);
+    const Material* material = m_document->findMaterial(m_materialId);
     if (!material) {
         qDebug() << "Material not found:" << m_materialId;
         return;
@@ -86,12 +86,12 @@ void MaterialWidget::updateCheckedState(bool checked)
         setStyleSheet("#MaterialFrame {border: 1px solid transparent;}");
 }
 
-ModelWidget *MaterialWidget::previewWidget()
+ModelWidget* MaterialWidget::previewWidget()
 {
     return m_previewWidget;
 }
 
-void MaterialWidget::mouseDoubleClickEvent(QMouseEvent *event)
+void MaterialWidget::mouseDoubleClickEvent(QMouseEvent* event)
 {
     QFrame::mouseDoubleClickEvent(event);
     emit modifyMaterial(m_materialId);

application/sources/material_widget.h

@@ -1,36 +1,38 @@
 #ifndef DUST3D_APPLICATION_MATERIAL_WIDGET_H_
 #define DUST3D_APPLICATION_MATERIAL_WIDGET_H_
 
-#include <QFrame>
-#include <QLabel>
-#include <QIcon>
-#include <QPushButton>
 #include "model_widget.h"
+#include <QFrame>
+#include <QIcon>
+#include <QLabel>
+#include <QPushButton>
 
 class Document;
 
-class MaterialWidget : public QFrame
+class MaterialWidget : public QFrame {
-{
     Q_OBJECT
 signals:
     void modifyMaterial(dust3d::Uuid materialId);
+
 public:
-    MaterialWidget(const Document *document, dust3d::Uuid materialId);
+    MaterialWidget(const Document* document, dust3d::Uuid materialId);
     static int preferredHeight();
-    ModelWidget *previewWidget();
+    ModelWidget* previewWidget();
+
 protected:
-    void mouseDoubleClickEvent(QMouseEvent *event) override;
+    void mouseDoubleClickEvent(QMouseEvent* event) override;
-    void resizeEvent(QResizeEvent *event) override;
+    void resizeEvent(QResizeEvent* event) override;
 public slots:
     void reload();
     void updatePreview(dust3d::Uuid materialId);
     void updateName(dust3d::Uuid materialId);
     void updateCheckedState(bool checked);
+
 private:
     dust3d::Uuid m_materialId;
-    const Document *m_document = nullptr;
+    const Document* m_document = nullptr;
-    ModelWidget *m_previewWidget = nullptr;
+    ModelWidget* m_previewWidget = nullptr;
-    QLabel *m_nameLabel = nullptr;
+    QLabel* m_nameLabel = nullptr;
 };
 
 #endif

application/sources/mesh_generator.cc

@@ -1,13 +1,13 @@
 
-#include <dust3d/mesh/smooth_normal.h>
-#include <dust3d/mesh/trim_vertices.h>
-#include <QElapsedTimer>
-#include <QDebug>
 #include "mesh_generator.h"
 #include "cut_face_preview.h"
+#include <QDebug>
+#include <QElapsedTimer>
+#include <dust3d/mesh/smooth_normal.h>
+#include <dust3d/mesh/trim_vertices.h>
 
-MeshGenerator::MeshGenerator(dust3d::Snapshot *snapshot) :
+MeshGenerator::MeshGenerator(dust3d::Snapshot* snapshot)
-    dust3d::MeshGenerator(snapshot)
+    : dust3d::MeshGenerator(snapshot)
 {
 }
 
@@ -15,12 +15,12 @@ MeshGenerator::~MeshGenerator()
 {
 }
 
-std::map<dust3d::Uuid, std::unique_ptr<ModelMesh>> *MeshGenerator::takeComponentPreviewMeshes()
+std::map<dust3d::Uuid, std::unique_ptr<ModelMesh>>* MeshGenerator::takeComponentPreviewMeshes()
 {
     return m_componentPreviewMeshes.release();
 }
 
-MonochromeMesh *MeshGenerator::takeWireframeMesh()
+MonochromeMesh* MeshGenerator::takeWireframeMesh()
 {
     return m_wireframeMesh.release();
 }
@@ -29,29 +29,28 @@ void MeshGenerator::process()
 {
     QElapsedTimer countTimeConsumed;
     countTimeConsumed.start();
-    
+
     generate();
-    
+
     if (nullptr != m_object)
         m_resultMesh = std::make_unique<ModelMesh>(*m_object);
-    
+
     m_componentPreviewMeshes = std::make_unique<std::map<dust3d::Uuid, std::unique_ptr<ModelMesh>>>();
-    for (const auto &componentId: m_generatedPreviewComponentIds) {
+    for (const auto& componentId : m_generatedPreviewComponentIds) {
         auto it = m_generatedComponentPreviews.find(componentId);
         if (it == m_generatedComponentPreviews.end())
             continue;
         dust3d::trimVertices(&it->second.vertices, true);
-        for (auto &it: it->second.vertices) {
+        for (auto& it : it->second.vertices) {
             it *= 2.0;
         }
         std::vector<dust3d::Vector3> previewTriangleNormals;
         previewTriangleNormals.reserve(it->second.triangles.size());
-        for (const auto &face: it->second.triangles) {
+        for (const auto& face : it->second.triangles) {
             previewTriangleNormals.emplace_back(dust3d::Vector3::normal(
                 it->second.vertices[face[0]],
                 it->second.vertices[face[1]],
-                it->second.vertices[face[2]]
+                it->second.vertices[face[2]]));
-            ));
         }
         std::vector<std::vector<dust3d::Vector3>> previewTriangleVertexNormals;
         dust3d::smoothNormal(it->second.vertices,
@@ -70,14 +69,13 @@ void MeshGenerator::process()
 
     if (nullptr != m_object)
         m_wireframeMesh = std::make_unique<MonochromeMesh>(*m_object);
-    
+
     qDebug() << "The mesh generation took" << countTimeConsumed.elapsed() << "milliseconds";
-    
+
     emit finished();
 }
 
-ModelMesh *MeshGenerator::takeResultMesh()
+ModelMesh* MeshGenerator::takeResultMesh()
 {
     return m_resultMesh.release();
 }
-

application/sources/mesh_generator.h

@@ -1,26 +1,26 @@
 #ifndef DUST3D_APPLICATION_MESH_GENERATOR_H_
 #define DUST3D_APPLICATION_MESH_GENERATOR_H_
 
-#include <memory>
-#include <QObject>
-#include <QImage>
-#include <dust3d/mesh/mesh_generator.h>
 #include "model_mesh.h"
 #include "monochrome_mesh.h"
+#include <QImage>
+#include <QObject>
+#include <dust3d/mesh/mesh_generator.h>
+#include <memory>
 
-class MeshGenerator : public QObject, public dust3d::MeshGenerator
+class MeshGenerator : public QObject, public dust3d::MeshGenerator {
-{
     Q_OBJECT
 public:
-    MeshGenerator(dust3d::Snapshot *snapshot);
+    MeshGenerator(dust3d::Snapshot* snapshot);
     ~MeshGenerator();
-    ModelMesh *takeResultMesh();
+    ModelMesh* takeResultMesh();
-    std::map<dust3d::Uuid, std::unique_ptr<ModelMesh>> *takeComponentPreviewMeshes();
+    std::map<dust3d::Uuid, std::unique_ptr<ModelMesh>>* takeComponentPreviewMeshes();
-    MonochromeMesh *takeWireframeMesh();
+    MonochromeMesh* takeWireframeMesh();
 public slots:
     void process();
 signals:
     void finished();
+
 private:
     std::unique_ptr<ModelMesh> m_resultMesh;
     std::unique_ptr<std::map<dust3d::Uuid, std::unique_ptr<ModelMesh>>> m_componentPreviewMeshes;

application/sources/mesh_preview_images_generator.cc

@@ -1,20 +1,20 @@
-#include <QDebug>
 #include "mesh_preview_images_generator.h"
 #include "theme.h"
+#include <QDebug>
 
-void MeshPreviewImagesGenerator::addInput(const dust3d::Uuid &inputId, std::unique_ptr<ModelMesh> previewMesh, bool useFrontView)
+void MeshPreviewImagesGenerator::addInput(const dust3d::Uuid& inputId, std::unique_ptr<ModelMesh> previewMesh, bool useFrontView)
 {
-    m_previewInputMap.insert({inputId, PreviewInput {std::move(previewMesh), useFrontView}});
+    m_previewInputMap.insert({ inputId, PreviewInput { std::move(previewMesh), useFrontView } });
 }
 
 void MeshPreviewImagesGenerator::process()
 {
     generate();
-    
+
     emit finished();
 }
 
-std::map<dust3d::Uuid, QImage> *MeshPreviewImagesGenerator::takeImages()
+std::map<dust3d::Uuid, QImage>* MeshPreviewImagesGenerator::takeImages()
 {
     return m_partImages.release();
 }
@@ -22,10 +22,10 @@ std::map<dust3d::Uuid, QImage> *MeshPreviewImagesGenerator::takeImages()
 void MeshPreviewImagesGenerator::generate()
 {
     m_partImages = std::make_unique<std::map<dust3d::Uuid, QImage>>();
-    
+
     m_offscreenRender->setZRotation(0);
     m_offscreenRender->setEyePosition(QVector3D(0, 0, -4.0));
-    for (auto &it: m_previewInputMap) {
+    for (auto& it : m_previewInputMap) {
         if (it.second.useFrontView) {
             m_offscreenRender->setXRotation(0);
             m_offscreenRender->setYRotation(0);

application/sources/mesh_preview_images_generator.h

@@ -1,43 +1,42 @@
 #ifndef DUST3D_APPLICATION_MESH_PREVIEW_IMAGES_GENERATOR_H_
 #define DUST3D_APPLICATION_MESH_PREVIEW_IMAGES_GENERATOR_H_
 
-#include <QObject>
-#include <QImage>
-#include <memory>
-#include <map>
-#include <dust3d/base/uuid.h>
 #include "model_offscreen_render.h"
+#include <QImage>
+#include <QObject>
+#include <dust3d/base/uuid.h>
+#include <map>
+#include <memory>
 
-class MeshPreviewImagesGenerator : public QObject
+class MeshPreviewImagesGenerator : public QObject {
-{
     Q_OBJECT
 public:
-    MeshPreviewImagesGenerator(ModelOffscreenRender *modelOffscreenRender) :
+    MeshPreviewImagesGenerator(ModelOffscreenRender* modelOffscreenRender)
-        m_offscreenRender(modelOffscreenRender)
+        : m_offscreenRender(modelOffscreenRender)
     {
     }
-    
+
-    struct PreviewInput
+    struct PreviewInput {
-    {
         std::unique_ptr<ModelMesh> mesh;
         bool useFrontView = false;
     };
-    
+
     ~MeshPreviewImagesGenerator()
     {
         delete m_offscreenRender;
     }
 
-    void addInput(const dust3d::Uuid &inputId, std::unique_ptr<ModelMesh> previewMesh, bool useFrontView=false);
+    void addInput(const dust3d::Uuid& inputId, std::unique_ptr<ModelMesh> previewMesh, bool useFrontView = false);
     void generate();
-    std::map<dust3d::Uuid, QImage> *takeImages();
+    std::map<dust3d::Uuid, QImage>* takeImages();
 signals:
     void finished();
 public slots:
     void process();
+
 private:
     std::map<dust3d::Uuid, PreviewInput> m_previewInputMap;
-    ModelOffscreenRender *m_offscreenRender = nullptr;
+    ModelOffscreenRender* m_offscreenRender = nullptr;
     std::unique_ptr<std::map<dust3d::Uuid, QImage>> m_partImages;
 };
 

application/sources/mesh_result_post_processor.cc

@@ -1,9 +1,9 @@
-#include <QGuiApplication>
-#include <dust3d/uv/unwrap_uv.h>
-#include <dust3d/mesh/resolve_triangle_tangent.h>
 #include "mesh_result_post_processor.h"
+#include <QGuiApplication>
+#include <dust3d/mesh/resolve_triangle_tangent.h>
+#include <dust3d/uv/unwrap_uv.h>
 
-MeshResultPostProcessor::MeshResultPostProcessor(const dust3d::Object &object)
+MeshResultPostProcessor::MeshResultPostProcessor(const dust3d::Object& object)
 {
     m_object = new dust3d::Object;
     *m_object = object;
@@ -14,9 +14,9 @@ MeshResultPostProcessor::~MeshResultPostProcessor()
     delete m_object;
 }
 
-dust3d::Object *MeshResultPostProcessor::takePostProcessedObject()
+dust3d::Object* MeshResultPostProcessor::takePostProcessedObject()
 {
-    dust3d::Object *object = m_object;
+    dust3d::Object* object = m_object;
     m_object = nullptr;
     return object;
 }
@@ -32,7 +32,7 @@ void MeshResultPostProcessor::poseProcess()
             m_object->setTriangleVertexUvs(triangleVertexUvs);
             m_object->setPartUvRects(partUvRects);
         }
-        
+
         {
             std::vector<dust3d::Vector3> triangleTangents;
             dust3d::resolveTriangleTangent(*m_object, triangleTangents);

application/sources/mesh_result_post_processor.h

@@ -4,20 +4,20 @@
 #include <QObject>
 #include <dust3d/base/object.h>
 
-class MeshResultPostProcessor : public QObject
+class MeshResultPostProcessor : public QObject {
-{
     Q_OBJECT
 public:
-    MeshResultPostProcessor(const dust3d::Object &object);
+    MeshResultPostProcessor(const dust3d::Object& object);
     ~MeshResultPostProcessor();
-    dust3d::Object *takePostProcessedObject();
+    dust3d::Object* takePostProcessedObject();
     void poseProcess();
 signals:
     void finished();
 public slots:
     void process();
+
 private:
-    dust3d::Object *m_object = nullptr;
+    dust3d::Object* m_object = nullptr;
 };
 
 #endif

application/sources/model_mesh.cc

@@ -1,20 +1,19 @@
-#include <assert.h>
-#include <QTextStream>
-#include <QFile>
-#include <cmath>
 #include "model_mesh.h"
 #include "version.h"
+#include <QFile>
+#include <QTextStream>
+#include <assert.h>
+#include <cmath>
 
 float ModelMesh::m_defaultMetalness = 0.0;
 float ModelMesh::m_defaultRoughness = 1.0;
 
-ModelMesh::ModelMesh(const ModelMesh &mesh) :
+ModelMesh::ModelMesh(const ModelMesh& mesh)
-    m_triangleVertices(nullptr),
+    : m_triangleVertices(nullptr)
-    m_triangleVertexCount(0),
+    , m_triangleVertexCount(0)
-    m_textureImage(nullptr)
+    , m_textureImage(nullptr)
 {
-    if (nullptr != mesh.m_triangleVertices &&
+    if (nullptr != mesh.m_triangleVertices && mesh.m_triangleVertexCount > 0) {
-            mesh.m_triangleVertexCount > 0) {
         this->m_triangleVertices = new ModelOpenGLVertex[mesh.m_triangleVertexCount];
         this->m_triangleVertexCount = mesh.m_triangleVertexCount;
         for (int i = 0; i < mesh.m_triangleVertexCount; i++)
@@ -42,39 +41,39 @@ void ModelMesh::removeColor()
 {
     delete this->m_textureImage;
     this->m_textureImage = nullptr;
-    
+
     delete this->m_normalMapImage;
     this->m_normalMapImage = nullptr;
-    
+
     delete this->m_metalnessRoughnessAmbientOcclusionMapImage;
     this->m_metalnessRoughnessAmbientOcclusionMapImage = nullptr;
-    
+
     this->m_hasMetalnessInImage = false;
     this->m_hasRoughnessInImage = false;
     this->m_hasAmbientOcclusionInImage = false;
-    
+
     for (int i = 0; i < this->m_triangleVertexCount; ++i) {
-        auto &vertex = this->m_triangleVertices[i];
+        auto& vertex = this->m_triangleVertices[i];
         vertex.colorR = 1.0;
         vertex.colorG = 1.0;
         vertex.colorB = 1.0;
     }
 }
 
-ModelMesh::ModelMesh(ModelOpenGLVertex *triangleVertices, int vertexNum) :
+ModelMesh::ModelMesh(ModelOpenGLVertex* triangleVertices, int vertexNum)
-    m_triangleVertices(triangleVertices),
+    : m_triangleVertices(triangleVertices)
-    m_triangleVertexCount(vertexNum),
+    , m_triangleVertexCount(vertexNum)
-    m_textureImage(nullptr)
+    , m_textureImage(nullptr)
 {
 }
 
-ModelMesh::ModelMesh(const std::vector<dust3d::Vector3> &vertices, 
+ModelMesh::ModelMesh(const std::vector<dust3d::Vector3>& vertices,
-    const std::vector<std::vector<size_t>> &triangles,
+    const std::vector<std::vector<size_t>>& triangles,
-    const std::vector<std::vector<dust3d::Vector3>> &triangleVertexNormals,
+    const std::vector<std::vector<dust3d::Vector3>>& triangleVertexNormals,
-    const dust3d::Color &color,
+    const dust3d::Color& color,
     float metalness,
     float roughness,
-    const std::vector<std::tuple<dust3d::Color, float/*metalness*/, float/*roughness*/>> *vertexProperties)
+    const std::vector<std::tuple<dust3d::Color, float /*metalness*/, float /*roughness*/>>* vertexProperties)
 {
     m_triangleVertexCount = (int)triangles.size() * 3;
     m_triangleVertices = new ModelOpenGLVertex[m_triangleVertexCount];
@@ -82,9 +81,9 @@ ModelMesh::ModelMesh(const std::vector<dust3d::Vector3> &vertices,
     for (size_t i = 0; i < triangles.size(); ++i) {
         for (auto j = 0; j < 3; j++) {
             int vertexIndex = (int)triangles[i][j];
-            const dust3d::Vector3 *srcVert = &vertices[vertexIndex];
+            const dust3d::Vector3* srcVert = &vertices[vertexIndex];
-            const dust3d::Vector3 *srcNormal = &(triangleVertexNormals)[i][j];
+            const dust3d::Vector3* srcNormal = &(triangleVertexNormals)[i][j];
-            ModelOpenGLVertex *dest = &m_triangleVertices[destIndex];
+            ModelOpenGLVertex* dest = &m_triangleVertices[destIndex];
             dest->posX = srcVert->x();
             dest->posY = srcVert->y();
             dest->posZ = srcVert->z();
@@ -101,7 +100,7 @@ ModelMesh::ModelMesh(const std::vector<dust3d::Vector3> &vertices,
                 dest->metalness = metalness;
                 dest->roughness = roughness;
             } else {
-                const auto &property = (*vertexProperties)[vertexIndex];
+                const auto& property = (*vertexProperties)[vertexIndex];
                 dest->colorR = std::get<0>(property).r();
                 dest->colorG = std::get<0>(property).g();
                 dest->colorB = std::get<0>(property).b();
@@ -117,21 +116,21 @@ ModelMesh::ModelMesh(const std::vector<dust3d::Vector3> &vertices,
     }
 }
 
-ModelMesh::ModelMesh(dust3d::Object &object) :
+ModelMesh::ModelMesh(dust3d::Object& object)
-    m_triangleVertices(nullptr),
+    : m_triangleVertices(nullptr)
-    m_triangleVertexCount(0),
+    , m_triangleVertexCount(0)
-    m_textureImage(nullptr)
+    , m_textureImage(nullptr)
 {
     m_meshId = object.meshId;
     m_vertices = object.vertices;
     m_faces = object.triangleAndQuads;
 
-    std::map<std::pair<dust3d::Uuid, dust3d::Uuid>, const dust3d::ObjectNode *> nodeMap;
+    std::map<std::pair<dust3d::Uuid, dust3d::Uuid>, const dust3d::ObjectNode*> nodeMap;
     for (size_t i = 0; i < object.nodes.size(); ++i) {
-        const auto &node = object.nodes[i];
+        const auto& node = object.nodes[i];
-        nodeMap.insert({{node.partId, node.nodeId}, &node});
+        nodeMap.insert({ { node.partId, node.nodeId }, &node });
     }
-    
+
     m_triangleVertexCount = (int)object.triangles.size() * 3;
     m_triangleVertices = new ModelOpenGLVertex[m_triangleVertexCount];
     int destIndex = 0;
@@ -142,20 +141,20 @@ ModelMesh::ModelMesh(dust3d::Object &object) :
     const dust3d::Vector2 defaultUv = dust3d::Vector2(0, 0);
     const dust3d::Vector3 defaultTangent = dust3d::Vector3(0, 0, 0);
     for (size_t i = 0; i < object.triangles.size(); ++i) {
-        const auto &triangleColor = &object.triangleColors[i];
+        const auto& triangleColor = &object.triangleColors[i];
         for (auto j = 0; j < 3; j++) {
             int vertexIndex = (int)object.triangles[i][j];
-            const dust3d::Vector3 *srcVert = &object.vertices[vertexIndex];
+            const dust3d::Vector3* srcVert = &object.vertices[vertexIndex];
-            const dust3d::Vector3 *srcNormal = &defaultNormal;
+            const dust3d::Vector3* srcNormal = &defaultNormal;
             if (triangleVertexNormals)
                 srcNormal = &(*triangleVertexNormals)[i][j];
-            const dust3d::Vector2 *srcUv = &defaultUv;
+            const dust3d::Vector2* srcUv = &defaultUv;
             if (triangleVertexUvs)
                 srcUv = &(*triangleVertexUvs)[i][j];
-            const dust3d::Vector3 *srcTangent = &defaultTangent;
+            const dust3d::Vector3* srcTangent = &defaultTangent;
             if (triangleTangents)
                 srcTangent = &(*triangleTangents)[i];
-            ModelOpenGLVertex *dest = &m_triangleVertices[destIndex];
+            ModelOpenGLVertex* dest = &m_triangleVertices[destIndex];
             dest->colorR = triangleColor->r();
             dest->colorG = triangleColor->g();
             dest->colorB = triangleColor->b();
@@ -184,10 +183,10 @@ ModelMesh::ModelMesh(dust3d::Object &object) :
     }
 }
 
-ModelMesh::ModelMesh() :
+ModelMesh::ModelMesh()
-    m_triangleVertices(nullptr),
+    : m_triangleVertices(nullptr)
-    m_triangleVertexCount(0),
+    , m_triangleVertexCount(0)
-    m_textureImage(nullptr)
+    , m_textureImage(nullptr)
 {
 }
 
@@ -200,22 +199,22 @@ ModelMesh::~ModelMesh()
     delete m_metalnessRoughnessAmbientOcclusionMapImage;
 }
 
-const std::vector<dust3d::Vector3> &ModelMesh::vertices()
+const std::vector<dust3d::Vector3>& ModelMesh::vertices()
 {
     return m_vertices;
 }
 
-const std::vector<std::vector<size_t>> &ModelMesh::faces()
+const std::vector<std::vector<size_t>>& ModelMesh::faces()
 {
     return m_faces;
 }
 
-const std::vector<dust3d::Vector3> &ModelMesh::triangulatedVertices()
+const std::vector<dust3d::Vector3>& ModelMesh::triangulatedVertices()
 {
     return m_triangulatedVertices;
 }
 
-ModelOpenGLVertex *ModelMesh::triangleVertices()
+ModelOpenGLVertex* ModelMesh::triangleVertices()
 {
     return m_triangleVertices;
 }
@@ -225,53 +224,53 @@ int ModelMesh::triangleVertexCount()
     return m_triangleVertexCount;
 }
 
-void ModelMesh::setTextureImage(QImage *textureImage)
+void ModelMesh::setTextureImage(QImage* textureImage)
 {
     m_textureImage = textureImage;
 }
 
-const QImage *ModelMesh::textureImage()
+const QImage* ModelMesh::textureImage()
 {
     return m_textureImage;
 }
 
-QImage *ModelMesh::takeTextureImage()
+QImage* ModelMesh::takeTextureImage()
 {
     auto image = m_textureImage;
     m_textureImage = nullptr;
     return image;
 }
 
-void ModelMesh::setNormalMapImage(QImage *normalMapImage)
+void ModelMesh::setNormalMapImage(QImage* normalMapImage)
 {
     m_normalMapImage = normalMapImage;
 }
 
-const QImage *ModelMesh::normalMapImage()
+const QImage* ModelMesh::normalMapImage()
 {
     return m_normalMapImage;
 }
 
-QImage *ModelMesh::takeNormalMapImage()
+QImage* ModelMesh::takeNormalMapImage()
 {
     auto image = m_normalMapImage;
     m_normalMapImage = nullptr;
     return image;
 }
 
-const QImage *ModelMesh::metalnessRoughnessAmbientOcclusionMapImage()
+const QImage* ModelMesh::metalnessRoughnessAmbientOcclusionMapImage()
 {
     return m_metalnessRoughnessAmbientOcclusionMapImage;
 }
 
-QImage *ModelMesh::takeMetalnessRoughnessAmbientOcclusionMapImage()
+QImage* ModelMesh::takeMetalnessRoughnessAmbientOcclusionMapImage()
 {
     auto image = m_metalnessRoughnessAmbientOcclusionMapImage;
     m_metalnessRoughnessAmbientOcclusionMapImage = nullptr;
     return image;
 }
 
-void ModelMesh::setMetalnessRoughnessAmbientOcclusionMapImage(QImage *image)
+void ModelMesh::setMetalnessRoughnessAmbientOcclusionMapImage(QImage* image)
 {
     m_metalnessRoughnessAmbientOcclusionMapImage = image;
 }
@@ -306,24 +305,24 @@ void ModelMesh::setHasAmbientOcclusionInImage(bool hasInImage)
     m_hasAmbientOcclusionInImage = hasInImage;
 }
 
-void ModelMesh::exportAsObj(QTextStream *textStream)
+void ModelMesh::exportAsObj(QTextStream* textStream)
 {
-    auto &stream = *textStream;
+    auto& stream = *textStream;
     stream << "# " << APP_NAME << " " << APP_HUMAN_VER << endl;
     stream << "# " << APP_HOMEPAGE_URL << endl;
-    for (std::vector<dust3d::Vector3>::const_iterator it = vertices().begin() ; it != vertices().end(); ++it) {
+    for (std::vector<dust3d::Vector3>::const_iterator it = vertices().begin(); it != vertices().end(); ++it) {
         stream << "v " << QString::number((*it).x()) << " " << QString::number((*it).y()) << " " << QString::number((*it).z()) << endl;
     }
-    for (std::vector<std::vector<size_t>>::const_iterator it = faces().begin() ; it != faces().end(); ++it) {
+    for (std::vector<std::vector<size_t>>::const_iterator it = faces().begin(); it != faces().end(); ++it) {
         stream << "f";
-        for (std::vector<size_t>::const_iterator subIt = (*it).begin() ; subIt != (*it).end(); ++subIt) {
+        for (std::vector<size_t>::const_iterator subIt = (*it).begin(); subIt != (*it).end(); ++subIt) {
             stream << " " << QString::number((1 + *subIt));
         }
         stream << endl;
     }
 }
 
-void ModelMesh::exportAsObj(const QString &filename)
+void ModelMesh::exportAsObj(const QString& filename)
 {
     QFile file(filename);
     if (file.open(QIODevice::WriteOnly)) {
@@ -332,12 +331,12 @@ void ModelMesh::exportAsObj(const QString &filename)
     }
 }
 
-void ModelMesh::updateTriangleVertices(ModelOpenGLVertex *triangleVertices, int triangleVertexCount)
+void ModelMesh::updateTriangleVertices(ModelOpenGLVertex* triangleVertices, int triangleVertexCount)
 {
     delete[] m_triangleVertices;
     m_triangleVertices = 0;
     m_triangleVertexCount = 0;
-    
+
     m_triangleVertices = triangleVertices;
     m_triangleVertexCount = triangleVertexCount;
 }

application/sources/model_mesh.h

@@ -1,44 +1,43 @@
 #ifndef DUST3D_APPLICATION_MODEL_MESH_H_
 #define DUST3D_APPLICATION_MODEL_MESH_H_
 
-#include <QObject>
+#include "model_opengl_vertex.h"
-#include <vector>
 #include <QImage>
+#include <QObject>
 #include <QTextStream>
-#include <dust3d/base/vector3.h>
 #include <dust3d/base/color.h>
 #include <dust3d/base/object.h>
-#include "model_opengl_vertex.h"
+#include <dust3d/base/vector3.h>
+#include <vector>
 
-class ModelMesh
+class ModelMesh {
-{
 public:
-    ModelMesh(const std::vector<dust3d::Vector3> &vertices, 
+    ModelMesh(const std::vector<dust3d::Vector3>& vertices,
-        const std::vector<std::vector<size_t>> &triangles,
+        const std::vector<std::vector<size_t>>& triangles,
-        const std::vector<std::vector<dust3d::Vector3>> &triangleVertexNormals,
+        const std::vector<std::vector<dust3d::Vector3>>& triangleVertexNormals,
-        const dust3d::Color &color=dust3d::Color::createWhite(),
+        const dust3d::Color& color = dust3d::Color::createWhite(),
-        float metalness=0.0,
+        float metalness = 0.0,
-        float roughness=1.0,
+        float roughness = 1.0,
-        const std::vector<std::tuple<dust3d::Color, float/*metalness*/, float/*roughness*/>> *vertexProperties=nullptr);
+        const std::vector<std::tuple<dust3d::Color, float /*metalness*/, float /*roughness*/>>* vertexProperties = nullptr);
-    ModelMesh(dust3d::Object &object);
+    ModelMesh(dust3d::Object& object);
-    ModelMesh(ModelOpenGLVertex *triangleVertices, int vertexNum);
+    ModelMesh(ModelOpenGLVertex* triangleVertices, int vertexNum);
-    ModelMesh(const ModelMesh &mesh);
+    ModelMesh(const ModelMesh& mesh);
     ModelMesh();
     ~ModelMesh();
-    ModelOpenGLVertex *triangleVertices();
+    ModelOpenGLVertex* triangleVertices();
     int triangleVertexCount();
-    const std::vector<dust3d::Vector3> &vertices();
+    const std::vector<dust3d::Vector3>& vertices();
-    const std::vector<std::vector<size_t>> &faces();
+    const std::vector<std::vector<size_t>>& faces();
-    const std::vector<dust3d::Vector3> &triangulatedVertices();
+    const std::vector<dust3d::Vector3>& triangulatedVertices();
-    void setTextureImage(QImage *textureImage);
+    void setTextureImage(QImage* textureImage);
-    const QImage *textureImage();
+    const QImage* textureImage();
-    QImage *takeTextureImage();
+    QImage* takeTextureImage();
-    void setNormalMapImage(QImage *normalMapImage);
+    void setNormalMapImage(QImage* normalMapImage);
-    const QImage *normalMapImage();
+    const QImage* normalMapImage();
-    QImage *takeNormalMapImage();
+    QImage* takeNormalMapImage();
-    const QImage *metalnessRoughnessAmbientOcclusionMapImage();
+    const QImage* metalnessRoughnessAmbientOcclusionMapImage();
-    QImage *takeMetalnessRoughnessAmbientOcclusionMapImage();
+    QImage* takeMetalnessRoughnessAmbientOcclusionMapImage();
-    void setMetalnessRoughnessAmbientOcclusionMapImage(QImage *image);
+    void setMetalnessRoughnessAmbientOcclusionMapImage(QImage* image);
     bool hasMetalnessInImage();
     void setHasMetalnessInImage(bool hasInImage);
     bool hasRoughnessInImage();
@@ -47,21 +46,22 @@ public:
     void setHasAmbientOcclusionInImage(bool hasInImage);
     static float m_defaultMetalness;
     static float m_defaultRoughness;
-    void exportAsObj(const QString &filename);
+    void exportAsObj(const QString& filename);
-    void exportAsObj(QTextStream *textStream);
+    void exportAsObj(QTextStream* textStream);
-    void updateTriangleVertices(ModelOpenGLVertex *triangleVertices, int triangleVertexCount);
+    void updateTriangleVertices(ModelOpenGLVertex* triangleVertices, int triangleVertexCount);
     quint64 meshId() const;
     void setMeshId(quint64 id);
     void removeColor();
+
 private:
-    ModelOpenGLVertex *m_triangleVertices = nullptr;
+    ModelOpenGLVertex* m_triangleVertices = nullptr;
     int m_triangleVertexCount = 0;
     std::vector<dust3d::Vector3> m_vertices;
     std::vector<std::vector<size_t>> m_faces;
     std::vector<dust3d::Vector3> m_triangulatedVertices;
-    QImage *m_textureImage = nullptr;
+    QImage* m_textureImage = nullptr;
-    QImage *m_normalMapImage = nullptr;
+    QImage* m_normalMapImage = nullptr;
-    QImage *m_metalnessRoughnessAmbientOcclusionMapImage = nullptr;
+    QImage* m_metalnessRoughnessAmbientOcclusionMapImage = nullptr;
     bool m_hasMetalnessInImage = false;
     bool m_hasRoughnessInImage = false;
     bool m_hasAmbientOcclusionInImage = false;

application/sources/model_offscreen_render.cc

@@ -2,10 +2,10 @@
 #include "model_opengl_object.h"
 #include "model_opengl_program.h"
 
-ModelOffscreenRender::ModelOffscreenRender(const QSurfaceFormat &format, QScreen *targetScreen):
+ModelOffscreenRender::ModelOffscreenRender(const QSurfaceFormat& format, QScreen* targetScreen)
-    QOffscreenSurface(targetScreen),
+    : QOffscreenSurface(targetScreen)
-    m_context(nullptr),
+    , m_context(nullptr)
-    m_mesh(nullptr)
+    , m_mesh(nullptr)
 {
     setFormat(format);
     create();
@@ -13,11 +13,11 @@ ModelOffscreenRender::ModelOffscreenRender(const QSurfaceFormat &format, QScreen
 
 ModelOffscreenRender::~ModelOffscreenRender()
 {
-    // FIXME: If delete m_renderFbo inside toImage, 
+    // FIXME: If delete m_renderFbo inside toImage,
     // sometimes, the application will freeze, maybe there are dead locks inside the destruction call
     // move it here can make sure it will be deleted on the main GUI thread to avoid dead locks
     delete m_renderFbo;
-    
+
     destroy();
     delete m_mesh;
 }
@@ -37,28 +37,28 @@ void ModelOffscreenRender::setZRotation(int angle)
     m_zRot = angle;
 }
 
-void ModelOffscreenRender::setEyePosition(const QVector3D &eyePosition)
+void ModelOffscreenRender::setEyePosition(const QVector3D& eyePosition)
 {
     m_eyePosition = eyePosition;
 }
 
-void ModelOffscreenRender::setMoveToPosition(const QVector3D &moveToPosition)
+void ModelOffscreenRender::setMoveToPosition(const QVector3D& moveToPosition)
 {
     m_moveToPosition = moveToPosition;
 }
 
-void ModelOffscreenRender::setRenderThread(QThread *thread)
+void ModelOffscreenRender::setRenderThread(QThread* thread)
 {
     moveToThread(thread);
 }
 
-void ModelOffscreenRender::updateMesh(ModelMesh *mesh)
+void ModelOffscreenRender::updateMesh(ModelMesh* mesh)
 {
     delete m_mesh;
     m_mesh = mesh;
 }
 
-QImage ModelOffscreenRender::toImage(const QSize &size)
+QImage ModelOffscreenRender::toImage(const QSize& size)
 {
     QImage image;
 
@@ -105,7 +105,7 @@ QImage ModelOffscreenRender::toImage(const QSize &size)
     m_renderFbo = new QOpenGLFramebufferObject(size, format);
     m_renderFbo->bind();
 
-    QOpenGLFunctions *f = m_context->functions();
+    QOpenGLFunctions* f = m_context->functions();
     f->glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
     f->glEnable(GL_BLEND);
     f->glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

application/sources/model_offscreen_render.h

@@ -1,34 +1,34 @@
 #ifndef DUST3D_APPLICATION_MODEL_OFFSCREEN_RENDER_H_
 #define DUST3D_APPLICATION_MODEL_OFFSCREEN_RENDER_H_
 
+#include "model_mesh.h"
 #include <QOffscreenSurface>
 #include <QOpenGLFramebufferObject>
 #include <QSurfaceFormat>
 #include <QVector3D>
-#include "model_mesh.h"
 
-class ModelOffscreenRender: public QOffscreenSurface
+class ModelOffscreenRender : public QOffscreenSurface {
-{
 public:
-    ModelOffscreenRender(const QSurfaceFormat &format, QScreen *targetScreen=Q_NULLPTR);
+    ModelOffscreenRender(const QSurfaceFormat& format, QScreen* targetScreen = Q_NULLPTR);
     ~ModelOffscreenRender();
     void setXRotation(int angle);
     void setYRotation(int angle);
     void setZRotation(int angle);
-    void setEyePosition(const QVector3D &eyePosition);
+    void setEyePosition(const QVector3D& eyePosition);
-    void setMoveToPosition(const QVector3D &moveToPosition);
+    void setMoveToPosition(const QVector3D& moveToPosition);
-    void setRenderThread(QThread *thread);
+    void setRenderThread(QThread* thread);
-    void updateMesh(ModelMesh *mesh);
+    void updateMesh(ModelMesh* mesh);
-    QImage toImage(const QSize &size);
+    QImage toImage(const QSize& size);
+
 private:
     int m_xRot = 0;
     int m_yRot = 0;
     int m_zRot = 0;
     QVector3D m_eyePosition;
     QVector3D m_moveToPosition;
-    QOpenGLContext *m_context = nullptr;
+    QOpenGLContext* m_context = nullptr;
-    QOpenGLFramebufferObject *m_renderFbo = nullptr;
+    QOpenGLFramebufferObject* m_renderFbo = nullptr;
-    ModelMesh *m_mesh = nullptr;
+    ModelMesh* m_mesh = nullptr;
 };
 
 #endif

application/sources/model_opengl_object.cc

@@ -1,7 +1,7 @@
-#include <dust3d/base/debug.h>
-#include <QOpenGLFunctions>
-#include <QOpenGLContext>
 #include "model_opengl_object.h"
+#include <QOpenGLContext>
+#include <QOpenGLFunctions>
+#include <dust3d/base/debug.h>
 
 void ModelOpenGLObject::update(std::unique_ptr<ModelMesh> mesh)
 {
@@ -15,7 +15,7 @@ void ModelOpenGLObject::draw()
     copyMeshToOpenGL();
     if (0 == m_meshTriangleVertexCount)
         return;
-    QOpenGLFunctions *f = QOpenGLContext::currentContext()->functions();
+    QOpenGLFunctions* f = QOpenGLContext::currentContext()->functions();
     QOpenGLVertexArrayObject::Binder binder(&m_vertexArrayObject);
     f->glDrawArrays(GL_TRIANGLES, 0, m_meshTriangleVertexCount);
 }
@@ -43,7 +43,7 @@ void ModelOpenGLObject::copyMeshToOpenGL()
         m_buffer.bind();
         m_buffer.allocate(mesh->triangleVertices(), mesh->triangleVertexCount() * sizeof(ModelOpenGLVertex));
         m_meshTriangleVertexCount = mesh->triangleVertexCount();
-        QOpenGLFunctions *f = QOpenGLContext::currentContext()->functions();
+        QOpenGLFunctions* f = QOpenGLContext::currentContext()->functions();
         f->glEnableVertexAttribArray(0);
         f->glEnableVertexAttribArray(1);
         f->glEnableVertexAttribArray(2);
@@ -53,13 +53,13 @@ void ModelOpenGLObject::copyMeshToOpenGL()
         f->glEnableVertexAttribArray(6);
         f->glEnableVertexAttribArray(7);
         f->glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(ModelOpenGLVertex), 0);
-        f->glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(ModelOpenGLVertex), reinterpret_cast<void *>(3 * sizeof(GLfloat)));
+        f->glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(ModelOpenGLVertex), reinterpret_cast<void*>(3 * sizeof(GLfloat)));
-        f->glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, sizeof(ModelOpenGLVertex), reinterpret_cast<void *>(6 * sizeof(GLfloat)));
+        f->glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, sizeof(ModelOpenGLVertex), reinterpret_cast<void*>(6 * sizeof(GLfloat)));
-        f->glVertexAttribPointer(3, 2, GL_FLOAT, GL_FALSE, sizeof(ModelOpenGLVertex), reinterpret_cast<void *>(9 * sizeof(GLfloat)));
+        f->glVertexAttribPointer(3, 2, GL_FLOAT, GL_FALSE, sizeof(ModelOpenGLVertex), reinterpret_cast<void*>(9 * sizeof(GLfloat)));
-        f->glVertexAttribPointer(4, 1, GL_FLOAT, GL_FALSE, sizeof(ModelOpenGLVertex), reinterpret_cast<void *>(11 * sizeof(GLfloat)));
+        f->glVertexAttribPointer(4, 1, GL_FLOAT, GL_FALSE, sizeof(ModelOpenGLVertex), reinterpret_cast<void*>(11 * sizeof(GLfloat)));
-        f->glVertexAttribPointer(5, 1, GL_FLOAT, GL_FALSE, sizeof(ModelOpenGLVertex), reinterpret_cast<void *>(12 * sizeof(GLfloat)));
+        f->glVertexAttribPointer(5, 1, GL_FLOAT, GL_FALSE, sizeof(ModelOpenGLVertex), reinterpret_cast<void*>(12 * sizeof(GLfloat)));
-        f->glVertexAttribPointer(6, 3, GL_FLOAT, GL_FALSE, sizeof(ModelOpenGLVertex), reinterpret_cast<void *>(13 * sizeof(GLfloat)));
+        f->glVertexAttribPointer(6, 3, GL_FLOAT, GL_FALSE, sizeof(ModelOpenGLVertex), reinterpret_cast<void*>(13 * sizeof(GLfloat)));
-        f->glVertexAttribPointer(7, 1, GL_FLOAT, GL_FALSE, sizeof(ModelOpenGLVertex), reinterpret_cast<void *>(16 * sizeof(GLfloat)));
+        f->glVertexAttribPointer(7, 1, GL_FLOAT, GL_FALSE, sizeof(ModelOpenGLVertex), reinterpret_cast<void*>(16 * sizeof(GLfloat)));
         m_buffer.release();
     }
 }

application/sources/model_opengl_object.h

@@ -1,17 +1,17 @@
 #ifndef DUST3D_APPLICATION_MODEL_OPENGL_OBJECT_H_
 #define DUST3D_APPLICATION_MODEL_OPENGL_OBJECT_H_
 
-#include <memory>
-#include <QMutex>
-#include <QOpenGLVertexArrayObject>
-#include <QOpenGLBuffer>
 #include "model_mesh.h"
+#include <QMutex>
+#include <QOpenGLBuffer>
+#include <QOpenGLVertexArrayObject>
+#include <memory>
 
-class ModelOpenGLObject
+class ModelOpenGLObject {
-{
 public:
     void update(std::unique_ptr<ModelMesh> mesh);
     void draw();
+
 private:
     void copyMeshToOpenGL();
     QOpenGLVertexArrayObject m_vertexArrayObject;

application/sources/model_opengl_program.cc

@@ -1,11 +1,11 @@
-#include <QOpenGLFunctions>
-#include <QFile>
-#include <QMutexLocker>
-#include <dust3d/base/debug.h>
 #include "model_opengl_program.h"
 #include "dds_file.h"
+#include <QFile>
+#include <QMutexLocker>
+#include <QOpenGLFunctions>
+#include <dust3d/base/debug.h>
 
-static const QString &loadShaderSource(const QString &name)
+static const QString& loadShaderSource(const QString& name)
 {
     static std::map<QString, QString> s_shaderSources;
     auto findShader = s_shaderSources.find(name);
@@ -15,11 +15,11 @@ static const QString &loadShaderSource(const QString &name)
     QFile file(name);
     file.open(QFile::ReadOnly | QFile::Text);
     QTextStream stream(&file);
-    auto insertResult = s_shaderSources.insert({name, stream.readAll()});
+    auto insertResult = s_shaderSources.insert({ name, stream.readAll() });
     return insertResult.first->second;
 }
 
-void ModelOpenGLProgram::addShaderFromResource(QOpenGLShader::ShaderType type, const char *resourceName)
+void ModelOpenGLProgram::addShaderFromResource(QOpenGLShader::ShaderType type, const char* resourceName)
 {
     if (!addShaderFromSourceCode(type, loadShaderSource(resourceName)))
         dust3dDebug << "Failed to addShaderFromResource, resource:" << resourceName << ", " << log().toStdString();
@@ -57,7 +57,7 @@ void ModelOpenGLProgram::updateMetalnessRoughnessAmbientOcclusionMapImage(std::u
     m_imageIsDirty = true;
 }
 
-void ModelOpenGLProgram::activeAndBindTexture(int location, QOpenGLTexture *texture)
+void ModelOpenGLProgram::activeAndBindTexture(int location, QOpenGLTexture* texture)
 {
     if (0 == texture->textureId()) {
         dust3dDebug << "Expected texture with a bound id";
@@ -105,7 +105,7 @@ void ModelOpenGLProgram::bindMaps()
             DdsFileReader irradianceFile(":/resources/cedar_bridge_specular.dds");
             m_environmentSpecularMap.reset(irradianceFile.createOpenGLTexture());
         }
-        
+
         bindLocation++;
         activeAndBindTexture(bindLocation, m_environmentIrradianceMap.get());
         setUniformValue(getUniformLocationByName("environmentIrradianceMapId"), bindLocation);
@@ -224,12 +224,12 @@ void ModelOpenGLProgram::releaseMaps()
     }
 }
 
-int ModelOpenGLProgram::getUniformLocationByName(const std::string &name)
+int ModelOpenGLProgram::getUniformLocationByName(const std::string& name)
 {
     auto findLocation = m_uniformLocationMap.find(name);
     if (findLocation != m_uniformLocationMap.end())
         return findLocation->second;
     int location = uniformLocation(name.c_str());
-    m_uniformLocationMap.insert({name, location});
+    m_uniformLocationMap.insert({ name, location });
     return location;
 }

application/sources/model_opengl_program.h

@@ -1,30 +1,29 @@
 #ifndef DUST3D_APPLICATION_MODEL_OPENGL_PROGRAM_H_
 #define DUST3D_APPLICATION_MODEL_OPENGL_PROGRAM_H_
 
-#include <memory>
-#include <QOpenGLShaderProgram>
-#include <QOpenGLShader>
-#include <QOpenGLTexture>
 #include <QMutex>
+#include <QOpenGLShader>
+#include <QOpenGLShaderProgram>
+#include <QOpenGLTexture>
+#include <memory>
 
-class ModelOpenGLProgram: public QOpenGLShaderProgram
+class ModelOpenGLProgram : public QOpenGLShaderProgram {
-{
 public:
-    void load(bool isCoreProfile=false);
+    void load(bool isCoreProfile = false);
-    int getUniformLocationByName(const std::string &name);
+    int getUniformLocationByName(const std::string& name);
     bool isCoreProfile() const;
     void bindMaps();
     void releaseMaps();
     void updateTextureImage(std::unique_ptr<QImage> image);
     void updateNormalMapImage(std::unique_ptr<QImage> image);
     void updateMetalnessRoughnessAmbientOcclusionMapImage(std::unique_ptr<QImage> image,
-        bool hasMetalnessMap = false, 
+        bool hasMetalnessMap = false,
-        bool hasRoughnessMap = false, 
+        bool hasRoughnessMap = false,
         bool hasAmbientOcclusionMap = false);
 
 private:
-    void addShaderFromResource(QOpenGLShader::ShaderType type, const char *resourceName);
+    void addShaderFromResource(QOpenGLShader::ShaderType type, const char* resourceName);
-    void activeAndBindTexture(int location, QOpenGLTexture *texture);
+    void activeAndBindTexture(int location, QOpenGLTexture* texture);
 
     bool m_isLoaded = false;
     bool m_isCoreProfile = false;

application/sources/model_widget.cc

@@ -1,11 +1,11 @@
-#include <QMouseEvent>
-#include <QCoreApplication>
-#include <QGuiApplication>
-#include <cmath>
-#include <QVector4D>
-#include <QSurfaceFormat>
 #include "model_widget.h"
 #include "dds_file.h"
+#include <QCoreApplication>
+#include <QGuiApplication>
+#include <QMouseEvent>
+#include <QSurfaceFormat>
+#include <QVector4D>
+#include <cmath>
 
 float ModelWidget::m_minZoomRatio = 5.0;
 float ModelWidget::m_maxZoomRatio = 80.0;
@@ -18,36 +18,36 @@ QString ModelWidget::m_openGLVersion = "";
 QString ModelWidget::m_openGLShadingLanguageVersion = "";
 bool ModelWidget::m_openGLIsCoreProfile = false;
 
-ModelWidget::ModelWidget(QWidget *parent) :
+ModelWidget::ModelWidget(QWidget* parent)
-    QOpenGLWidget(parent)
+    : QOpenGLWidget(parent)
 {
     setAttribute(Qt::WA_AlwaysStackOnTop);
     setAttribute(Qt::WA_TranslucentBackground);
-    
+
     QSurfaceFormat fmt = format();
     fmt.setAlphaBufferSize(8);
     fmt.setSamples(4);
     setFormat(fmt);
 
     setContextMenuPolicy(Qt::CustomContextMenu);
-    
+
     m_widthInPixels = width() * window()->devicePixelRatio();
-	m_heightInPixels = height() * window()->devicePixelRatio();
+    m_heightInPixels = height() * window()->devicePixelRatio();
-	
+
     zoom(200);
 }
 
-const QVector3D &ModelWidget::eyePosition()
+const QVector3D& ModelWidget::eyePosition()
 {
-	return m_eyePosition;
+    return m_eyePosition;
 }
 
-const QVector3D &ModelWidget::moveToPosition()
+const QVector3D& ModelWidget::moveToPosition()
 {
     return m_moveToPosition;
 }
 
-void ModelWidget::setEyePosition(const QVector3D &eyePosition)
+void ModelWidget::setEyePosition(const QVector3D& eyePosition)
 {
     m_eyePosition = eyePosition;
     emit eyePositionChanged(m_eyePosition);
@@ -130,7 +130,7 @@ void ModelWidget::disableCullFace()
     m_enableCullFace = false;
 }
 
-void ModelWidget::setMoveToPosition(const QVector3D &moveToPosition)
+void ModelWidget::setMoveToPosition(const QVector3D& moveToPosition)
 {
     m_moveToPosition = moveToPosition;
 }
@@ -144,13 +144,13 @@ void ModelWidget::updateProjectionMatrix()
 
 void ModelWidget::resizeGL(int w, int h)
 {
-	m_widthInPixels = w * window()->devicePixelRatio();
+    m_widthInPixels = w * window()->devicePixelRatio();
-	m_heightInPixels = h * window()->devicePixelRatio();
+    m_heightInPixels = h * window()->devicePixelRatio();
     updateProjectionMatrix();
     emit renderParametersChanged();
 }
 
-std::pair<QVector3D, QVector3D> ModelWidget::screenPositionToMouseRay(const QPoint &screenPosition)
+std::pair<QVector3D, QVector3D> ModelWidget::screenPositionToMouseRay(const QPoint& screenPosition)
 {
     auto modelView = m_camera * m_world;
     float x = qMax(qMin(screenPosition.x(), width() - 1), 0);
@@ -190,12 +190,11 @@ void ModelWidget::toggleRotation()
     }
 }
 
-bool ModelWidget::inputMousePressEventFromOtherWidget(QMouseEvent *event, bool notGraphics)
+bool ModelWidget::inputMousePressEventFromOtherWidget(QMouseEvent* event, bool notGraphics)
 {
     bool shouldStartMove = false;
     if (event->button() == Qt::LeftButton) {
-        if ((notGraphics || QGuiApplication::queryKeyboardModifiers().testFlag(Qt::AltModifier)) &&
+        if ((notGraphics || QGuiApplication::queryKeyboardModifiers().testFlag(Qt::AltModifier)) && !QGuiApplication::queryKeyboardModifiers().testFlag(Qt::ControlModifier)) {
-                !QGuiApplication::queryKeyboardModifiers().testFlag(Qt::ControlModifier)) {
             shouldStartMove = m_moveEnabled;
         }
         if (!shouldStartMove && !m_mousePickTargetPositionInModelSpace.isNull())
@@ -216,7 +215,7 @@ bool ModelWidget::inputMousePressEventFromOtherWidget(QMouseEvent *event, bool n
     return false;
 }
 
-bool ModelWidget::inputMouseReleaseEventFromOtherWidget(QMouseEvent *event)
+bool ModelWidget::inputMouseReleaseEventFromOtherWidget(QMouseEvent* event)
 {
     Q_UNUSED(event);
     if (m_moveStarted) {
@@ -235,10 +234,10 @@ void ModelWidget::canvasResized()
     resize(parentWidget()->size());
 }
 
-bool ModelWidget::inputMouseMoveEventFromOtherWidget(QMouseEvent *event)
+bool ModelWidget::inputMouseMoveEventFromOtherWidget(QMouseEvent* event)
 {
     QPoint pos = convertInputPosFromOtherWidget(event);
-    
+
     if (m_mousePickingEnabled) {
         auto segment = screenPositionToMouseRay(pos);
         emit mouseRayChanged(segment.first, segment.second);
@@ -247,12 +246,11 @@ bool ModelWidget::inputMouseMoveEventFromOtherWidget(QMouseEvent *event)
     if (!m_moveStarted) {
         return false;
     }
-    
+
     int dx = pos.x() - m_lastPos.x();
     int dy = pos.y() - m_lastPos.y();
 
-    if ((event->buttons() & Qt::MidButton) ||
+    if ((event->buttons() & Qt::MidButton) || (m_moveStarted && (event->buttons() & Qt::LeftButton))) {
-            (m_moveStarted && (event->buttons() & Qt::LeftButton))) {
         if (QGuiApplication::queryKeyboardModifiers().testFlag(Qt::ShiftModifier)) {
             if (m_moveStarted) {
                 if (m_moveAndZoomByWindow) {
@@ -283,27 +281,27 @@ bool ModelWidget::inputMouseMoveEventFromOtherWidget(QMouseEvent *event)
         }
     }
     m_lastPos = pos;
-    
+
     return true;
 }
 
-QPoint ModelWidget::convertInputPosFromOtherWidget(QMouseEvent *event)
+QPoint ModelWidget::convertInputPosFromOtherWidget(QMouseEvent* event)
 {
     return mapFromGlobal(event->globalPos());
 }
 
-bool ModelWidget::inputWheelEventFromOtherWidget(QWheelEvent *event)
+bool ModelWidget::inputWheelEventFromOtherWidget(QWheelEvent* event)
 {
     if (m_moveStarted)
         return true;
-    
+
     if (m_mousePickingEnabled) {
         if (QGuiApplication::queryKeyboardModifiers().testFlag(Qt::ShiftModifier)) {
             emit addMouseRadius((float)event->delta() / 200 / height());
             return true;
         }
     }
-    
+
     if (!m_zoomEnabled)
         return false;
 
@@ -311,7 +309,7 @@ bool ModelWidget::inputWheelEventFromOtherWidget(QWheelEvent *event)
     if (event->delta() < 0)
         delta = -delta;
     zoom(delta);
-    
+
     return true;
 }
 
@@ -359,7 +357,7 @@ void ModelWidget::setMousePickRadius(float radius)
     update();
 }
 
-void ModelWidget::updateMesh(ModelMesh *mesh)
+void ModelWidget::updateMesh(ModelMesh* mesh)
 {
     if (!m_modelOpenGLProgram)
         m_modelOpenGLProgram = std::make_unique<ModelOpenGLProgram>();
@@ -369,7 +367,7 @@ void ModelWidget::updateMesh(ModelMesh *mesh)
         mesh && mesh->hasMetalnessInImage(),
         mesh && mesh->hasRoughnessInImage(),
         mesh && mesh->hasAmbientOcclusionInImage());
-    
+
     if (!m_modelOpenGLObject)
         m_modelOpenGLObject = std::make_unique<ModelOpenGLObject>();
     m_modelOpenGLObject->update(std::unique_ptr<ModelMesh>(mesh));
@@ -378,7 +376,7 @@ void ModelWidget::updateMesh(ModelMesh *mesh)
     update();
 }
 
-void ModelWidget::updateWireframeMesh(MonochromeMesh *mesh)
+void ModelWidget::updateWireframeMesh(MonochromeMesh* mesh)
 {
     if (!m_wireframeOpenGLObject)
         m_wireframeOpenGLObject = std::make_unique<MonochromeOpenGLObject>();
@@ -389,12 +387,12 @@ void ModelWidget::updateWireframeMesh(MonochromeMesh *mesh)
 
 int ModelWidget::widthInPixels()
 {
-	return m_widthInPixels;
+    return m_widthInPixels;
 }
 
 int ModelWidget::heightInPixels()
 {
-	return m_heightInPixels;
+    return m_heightInPixels;
 }
 
 void ModelWidget::enableMove(bool enabled)
@@ -417,22 +415,22 @@ void ModelWidget::setMoveAndZoomByWindow(bool byWindow)
     m_moveAndZoomByWindow = byWindow;
 }
 
-void ModelWidget::mousePressEvent(QMouseEvent *event)
+void ModelWidget::mousePressEvent(QMouseEvent* event)
 {
     inputMousePressEventFromOtherWidget(event, m_notGraphics);
 }
 
-void ModelWidget::mouseMoveEvent(QMouseEvent *event)
+void ModelWidget::mouseMoveEvent(QMouseEvent* event)
 {
     inputMouseMoveEventFromOtherWidget(event);
 }
 
-void ModelWidget::wheelEvent(QWheelEvent *event)
+void ModelWidget::wheelEvent(QWheelEvent* event)
 {
     inputWheelEventFromOtherWidget(event);
 }
 
-void ModelWidget::mouseReleaseEvent(QMouseEvent *event)
+void ModelWidget::mouseReleaseEvent(QMouseEvent* event)
 {
     inputMouseReleaseEventFromOtherWidget(event);
 }
@@ -442,7 +440,7 @@ void ModelWidget::setNotGraphics(bool notGraphics)
     m_notGraphics = notGraphics;
 }
 
-void ModelWidget::normalizeAngle(int &angle)
+void ModelWidget::normalizeAngle(int& angle)
 {
     while (angle < 0)
         angle += 360 * 16;
@@ -455,10 +453,10 @@ void ModelWidget::initializeGL()
     connect(context(), &QOpenGLContext::aboutToBeDestroyed, this, &ModelWidget::cleanup);
 
     if (m_openGLVersion.isEmpty()) {
-        QOpenGLFunctions *f = QOpenGLContext::currentContext()->functions();
+        QOpenGLFunctions* f = QOpenGLContext::currentContext()->functions();
-        const char *openGLVersion = (const char *)f->glGetString(GL_VERSION);
+        const char* openGLVersion = (const char*)f->glGetString(GL_VERSION);
         m_openGLVersion = nullptr != openGLVersion ? openGLVersion : "<Unknown>";
-        const char *shadingLanguageVersion = (const char *)glGetString(GL_SHADING_LANGUAGE_VERSION);
+        const char* shadingLanguageVersion = (const char*)glGetString(GL_SHADING_LANGUAGE_VERSION);
         m_openGLShadingLanguageVersion = nullptr != shadingLanguageVersion ? shadingLanguageVersion : "<Unknown>";
         m_openGLIsCoreProfile = QSurfaceFormat::defaultFormat().profile() == QSurfaceFormat::CoreProfile;
     }
@@ -466,7 +464,7 @@ void ModelWidget::initializeGL()
 
 void ModelWidget::paintGL()
 {
-    QOpenGLFunctions *f = QOpenGLContext::currentContext()->functions();
+    QOpenGLFunctions* f = QOpenGLContext::currentContext()->functions();
 
     f->glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
     f->glEnable(GL_BLEND);
@@ -485,13 +483,13 @@ void ModelWidget::paintGL()
     f->glEnable(GL_POLYGON_OFFSET_FILL);
     f->glPolygonOffset(1.0, 1.0);
 
-	f->glViewport(0, 0, m_widthInPixels, m_heightInPixels);
+    f->glViewport(0, 0, m_widthInPixels, m_heightInPixels);
 
     m_world.setToIdentity();
     m_world.rotate(m_xRot / 16.0f, 1, 0, 0);
     m_world.rotate(m_yRot / 16.0f, 0, 1, 0);
     m_world.rotate(m_zRot / 16.0f, 0, 0, 1);
-    
+
     m_camera.setToIdentity();
     m_camera.translate(m_eyePosition.x(), m_eyePosition.y(), m_eyePosition.z());
 
@@ -506,7 +504,7 @@ void ModelWidget::paintGL()
             m_monochromeOpenGLProgram->load(format().profile() == QSurfaceFormat::CoreProfile);
         }
     }
-    
+
     drawModel();
     if (m_isWireframeVisible) {
         drawWireframe();

application/sources/model_widget.h

@@ -1,27 +1,26 @@
 #ifndef DUST3D_APPLICATION_MODEL_WIDGET_H_
 #define DUST3D_APPLICATION_MODEL_WIDGET_H_
 
-#include <memory>
+#include "model_mesh.h"
-#include <QOpenGLWidget>
+#include "model_opengl_object.h"
-#include <QOpenGLBuffer>
+#include "model_opengl_program.h"
-#include <QOpenGLTexture>
+#include "monochrome_mesh.h"
+#include "monochrome_opengl_object.h"
+#include "monochrome_opengl_program.h"
 #include <QMatrix4x4>
 #include <QMutex>
-#include <QVector2D>
+#include <QOpenGLBuffer>
-#include <QTimer>
+#include <QOpenGLTexture>
+#include <QOpenGLWidget>
 #include <QString>
-#include "model_mesh.h"
+#include <QTimer>
-#include "model_opengl_program.h"
+#include <QVector2D>
-#include "model_opengl_object.h"
+#include <memory>
-#include "monochrome_mesh.h"
-#include "monochrome_opengl_program.h"
-#include "monochrome_opengl_object.h"
 
-class ModelWidget : public QOpenGLWidget
+class ModelWidget : public QOpenGLWidget {
-{
     Q_OBJECT
 signals:
-    void mouseRayChanged(const QVector3D &near, const QVector3D &far);
+    void mouseRayChanged(const QVector3D& near, const QVector3D& far);
     void mousePressed();
     void mouseReleased();
     void addMouseRadius(float radius);
@@ -29,13 +28,14 @@ signals:
     void xRotationChanged(int angle);
     void yRotationChanged(int angle);
     void zRotationChanged(int angle);
-    void eyePositionChanged(const QVector3D &eyePosition);
+    void eyePositionChanged(const QVector3D& eyePosition);
-    void moveToPositionChanged(const QVector3D &moveToPosition);
+    void moveToPositionChanged(const QVector3D& moveToPosition);
+
 public:
-    ModelWidget(QWidget *parent = 0);
+    ModelWidget(QWidget* parent = 0);
     ~ModelWidget();
-    void updateMesh(ModelMesh *mesh);
+    void updateMesh(ModelMesh* mesh);
-    void updateWireframeMesh(MonochromeMesh *mesh);
+    void updateWireframeMesh(MonochromeMesh* mesh);
     void toggleWireframe();
     bool isWireframeVisible();
     void toggleRotation();
@@ -44,40 +44,42 @@ public:
     void enableMousePicking(bool enabled);
     void setMoveAndZoomByWindow(bool byWindow);
     void disableCullFace();
-    void setMoveToPosition(const QVector3D &moveToPosition);
+    void setMoveToPosition(const QVector3D& moveToPosition);
-    bool inputMousePressEventFromOtherWidget(QMouseEvent *event, bool notGraphics=false);
+    bool inputMousePressEventFromOtherWidget(QMouseEvent* event, bool notGraphics = false);
-    bool inputMouseMoveEventFromOtherWidget(QMouseEvent *event);
+    bool inputMouseMoveEventFromOtherWidget(QMouseEvent* event);
-    bool inputWheelEventFromOtherWidget(QWheelEvent *event);
+    bool inputWheelEventFromOtherWidget(QWheelEvent* event);
-    bool inputMouseReleaseEventFromOtherWidget(QMouseEvent *event);
+    bool inputMouseReleaseEventFromOtherWidget(QMouseEvent* event);
-    QPoint convertInputPosFromOtherWidget(QMouseEvent *event);
+    QPoint convertInputPosFromOtherWidget(QMouseEvent* event);
     int widthInPixels();
     int heightInPixels();
     void setNotGraphics(bool notGraphics);
     int xRot();
     int yRot();
     int zRot();
-    const QVector3D &eyePosition();
+    const QVector3D& eyePosition();
-    const QVector3D &moveToPosition();
+    const QVector3D& moveToPosition();
-    const QString &openGLVersion();
+    const QString& openGLVersion();
 public slots:
     void setXRotation(int angle);
     void setYRotation(int angle);
     void setZRotation(int angle);
-    void setEyePosition(const QVector3D &eyePosition);
+    void setEyePosition(const QVector3D& eyePosition);
     void cleanup();
     void zoom(float delta);
     void setMousePickTargetPositionInModelSpace(QVector3D position);
     void setMousePickRadius(float radius);
     void reRender();
     void canvasResized();
+
 protected:
     void initializeGL() override;
     void paintGL() override;
     void resizeGL(int width, int height) override;
-    void mousePressEvent(QMouseEvent *event) override;
+    void mousePressEvent(QMouseEvent* event) override;
-    void mouseMoveEvent(QMouseEvent *event) override;
+    void mouseMoveEvent(QMouseEvent* event) override;
-    void wheelEvent(QWheelEvent *event) override;
+    void wheelEvent(QWheelEvent* event) override;
-    void mouseReleaseEvent(QMouseEvent *event) override;
+    void mouseReleaseEvent(QMouseEvent* event) override;
+
 private:
     int m_xRot = m_defaultXRotation;
     int m_yRot = m_defaultYRotation;
@@ -103,7 +105,7 @@ private:
     QPoint m_moveStartPos;
     QRect m_moveStartGeometry;
     int m_modelInitialHeight = 0;
-    QTimer *m_rotationTimer = nullptr;
+    QTimer* m_rotationTimer = nullptr;
     int m_widthInPixels = 0;
     int m_heightInPixels = 0;
     QVector3D m_moveToPosition;
@@ -111,11 +113,12 @@ private:
     bool m_enableCullFace = true;
     bool m_notGraphics = false;
     bool m_isWireframeVisible = false;
-    std::pair<QVector3D, QVector3D> screenPositionToMouseRay(const QPoint &screenPosition);
+    std::pair<QVector3D, QVector3D> screenPositionToMouseRay(const QPoint& screenPosition);
     void updateProjectionMatrix();
-    void normalizeAngle(int &angle);
+    void normalizeAngle(int& angle);
     void drawModel();
     void drawWireframe();
+
 public:
     static int m_defaultXRotation;
     static int m_defaultYRotation;

application/sources/monochrome_mesh.cc

@@ -1,59 +1,57 @@
-#include <set>
 #include "monochrome_mesh.h"
+#include <set>
 
-MonochromeMesh::MonochromeMesh(const MonochromeMesh &mesh)
+MonochromeMesh::MonochromeMesh(const MonochromeMesh& mesh)
 {
     m_lineVertices = mesh.m_lineVertices;
 }
 
-MonochromeMesh::MonochromeMesh(MonochromeMesh &&mesh)
+MonochromeMesh::MonochromeMesh(MonochromeMesh&& mesh)
 {
     m_lineVertices = std::move(mesh.m_lineVertices);
 }
 
-MonochromeMesh::MonochromeMesh(const dust3d::Object &object)
+MonochromeMesh::MonochromeMesh(const dust3d::Object& object)
 {
     std::set<std::pair<size_t, size_t>> halfEdges;
-    for (const auto &face: object.triangleAndQuads) {
+    for (const auto& face : object.triangleAndQuads) {
         if (3 == face.size()) {
-            halfEdges.insert({face[0], face[1]});
+            halfEdges.insert({ face[0], face[1] });
-            halfEdges.insert({face[1], face[0]});
+            halfEdges.insert({ face[1], face[0] });
-            halfEdges.insert({face[1], face[2]});
+            halfEdges.insert({ face[1], face[2] });
-            halfEdges.insert({face[2], face[1]});
+            halfEdges.insert({ face[2], face[1] });
-            halfEdges.insert({face[2], face[0]});
+            halfEdges.insert({ face[2], face[0] });
-            halfEdges.insert({face[0], face[2]});
+            halfEdges.insert({ face[0], face[2] });
             continue;
         }
-        halfEdges.insert({face[0], face[1]});
+        halfEdges.insert({ face[0], face[1] });
-        halfEdges.insert({face[1], face[0]});
+        halfEdges.insert({ face[1], face[0] });
-        halfEdges.insert({face[1], face[2]});
+        halfEdges.insert({ face[1], face[2] });
-        halfEdges.insert({face[2], face[1]});
+        halfEdges.insert({ face[2], face[1] });
-        halfEdges.insert({face[2], face[3]});
+        halfEdges.insert({ face[2], face[3] });
-        halfEdges.insert({face[3], face[2]});
+        halfEdges.insert({ face[3], face[2] });
-        halfEdges.insert({face[3], face[0]});
+        halfEdges.insert({ face[3], face[0] });
-        halfEdges.insert({face[0], face[3]});
+        halfEdges.insert({ face[0], face[3] });
     }
     m_lineVertices.reserve(halfEdges.size() * 2);
-    for (const auto &halfEdge: halfEdges) {
+    for (const auto& halfEdge : halfEdges) {
         // For two halfedges shared one edge, only output one line
         if (halfEdge.first > halfEdge.second)
             continue;
-        const auto &from = object.vertices[halfEdge.first];
+        const auto& from = object.vertices[halfEdge.first];
-        const auto &to = object.vertices[halfEdge.second];
+        const auto& to = object.vertices[halfEdge.second];
         m_lineVertices.emplace_back(MonochromeOpenGLVertex {
-            (GLfloat)from.x(), 
+            (GLfloat)from.x(),
-            (GLfloat)from.y(), 
+            (GLfloat)from.y(),
-            (GLfloat)from.z()
+            (GLfloat)from.z() });
-        });
         m_lineVertices.emplace_back(MonochromeOpenGLVertex {
-            (GLfloat)to.x(), 
+            (GLfloat)to.x(),
-            (GLfloat)to.y(), 
+            (GLfloat)to.y(),
-            (GLfloat)to.z()
+            (GLfloat)to.z() });
-        });
     }
 }
 
-const MonochromeOpenGLVertex *MonochromeMesh::lineVertices()
+const MonochromeOpenGLVertex* MonochromeMesh::lineVertices()
 {
     if (m_lineVertices.empty())
         return nullptr;

application/sources/monochrome_mesh.h

@@ -1,21 +1,20 @@
 #ifndef DUST3D_APPLICATION_MONOCHROME_MESH_H_
 #define DUST3D_APPLICATION_MONOCHROME_MESH_H_
 
-#include <memory>
-#include <dust3d/base/object.h>
 #include "monochrome_opengl_vertex.h"
+#include <dust3d/base/object.h>
+#include <memory>
 
-class MonochromeMesh
+class MonochromeMesh {
-{
 public:
-    MonochromeMesh(const MonochromeMesh &mesh);
+    MonochromeMesh(const MonochromeMesh& mesh);
-    MonochromeMesh(MonochromeMesh &&mesh);
+    MonochromeMesh(MonochromeMesh&& mesh);
-    MonochromeMesh(const dust3d::Object &object);
+    MonochromeMesh(const dust3d::Object& object);
-    const MonochromeOpenGLVertex *lineVertices();
+    const MonochromeOpenGLVertex* lineVertices();
     int lineVertexCount();
+
 private:
     std::vector<MonochromeOpenGLVertex> m_lineVertices;
 };
 
 #endif
-

application/sources/monochrome_opengl_object.cc

@@ -1,7 +1,7 @@
-#include <dust3d/base/debug.h>
-#include <QOpenGLFunctions>
-#include <QOpenGLContext>
 #include "monochrome_opengl_object.h"
+#include <QOpenGLContext>
+#include <QOpenGLFunctions>
+#include <dust3d/base/debug.h>
 
 void MonochromeOpenGLObject::update(std::unique_ptr<MonochromeMesh> mesh)
 {
@@ -15,7 +15,7 @@ void MonochromeOpenGLObject::draw()
     copyMeshToOpenGL();
     if (0 == m_meshLineVertexCount)
         return;
-    QOpenGLFunctions *f = QOpenGLContext::currentContext()->functions();
+    QOpenGLFunctions* f = QOpenGLContext::currentContext()->functions();
     QOpenGLVertexArrayObject::Binder binder(&m_vertexArrayObject);
     f->glDrawArrays(GL_LINES, 0, m_meshLineVertexCount);
 }
@@ -43,13 +43,13 @@ void MonochromeOpenGLObject::copyMeshToOpenGL()
         m_buffer.bind();
         m_buffer.allocate(mesh->lineVertices(), mesh->lineVertexCount() * sizeof(MonochromeOpenGLVertex));
         m_meshLineVertexCount = mesh->lineVertexCount();
-        QOpenGLFunctions *f = QOpenGLContext::currentContext()->functions();
+        QOpenGLFunctions* f = QOpenGLContext::currentContext()->functions();
         f->glEnableVertexAttribArray(0);
         f->glEnableVertexAttribArray(1);
         f->glEnableVertexAttribArray(2);
         f->glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(MonochromeOpenGLVertex), 0);
-        f->glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(MonochromeOpenGLVertex), reinterpret_cast<void *>(3 * sizeof(GLfloat)));
+        f->glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(MonochromeOpenGLVertex), reinterpret_cast<void*>(3 * sizeof(GLfloat)));
-        f->glVertexAttribPointer(2, 1, GL_FLOAT, GL_FALSE, sizeof(MonochromeOpenGLVertex), reinterpret_cast<void *>(6 * sizeof(GLfloat)));
+        f->glVertexAttribPointer(2, 1, GL_FLOAT, GL_FALSE, sizeof(MonochromeOpenGLVertex), reinterpret_cast<void*>(6 * sizeof(GLfloat)));
         m_buffer.release();
     }
 }

application/sources/monochrome_opengl_object.h

@@ -1,17 +1,17 @@
 #ifndef DUST3D_APPLICATION_MONOCHROME_OPENGL_OBJECT_H_
 #define DUST3D_APPLICATION_MONOCHROME_OPENGL_OBJECT_H_
 
-#include <memory>
-#include <QMutex>
-#include <QOpenGLVertexArrayObject>
-#include <QOpenGLBuffer>
 #include "monochrome_mesh.h"
+#include <QMutex>
+#include <QOpenGLBuffer>
+#include <QOpenGLVertexArrayObject>
+#include <memory>
 
-class MonochromeOpenGLObject
+class MonochromeOpenGLObject {
-{
 public:
     void update(std::unique_ptr<MonochromeMesh> mesh);
     void draw();
+
 private:
     void copyMeshToOpenGL();
     QOpenGLVertexArrayObject m_vertexArrayObject;

application/sources/monochrome_opengl_program.cc

@@ -1,9 +1,9 @@
-#include <QOpenGLFunctions>
-#include <QFile>
-#include <dust3d/base/debug.h>
 #include "monochrome_opengl_program.h"
+#include <QFile>
+#include <QOpenGLFunctions>
+#include <dust3d/base/debug.h>
 
-static const QString &loadShaderSource(const QString &name)
+static const QString& loadShaderSource(const QString& name)
 {
     static std::map<QString, QString> s_shaderSources;
     auto findShader = s_shaderSources.find(name);
@@ -13,11 +13,11 @@ static const QString &loadShaderSource(const QString &name)
     QFile file(name);
     file.open(QFile::ReadOnly | QFile::Text);
     QTextStream stream(&file);
-    auto insertResult = s_shaderSources.insert({name, stream.readAll()});
+    auto insertResult = s_shaderSources.insert({ name, stream.readAll() });
     return insertResult.first->second;
 }
 
-void MonochromeOpenGLProgram::addShaderFromResource(QOpenGLShader::ShaderType type, const char *resourceName)
+void MonochromeOpenGLProgram::addShaderFromResource(QOpenGLShader::ShaderType type, const char* resourceName)
 {
     if (!addShaderFromSourceCode(type, loadShaderSource(resourceName)))
         dust3dDebug << "Failed to addShaderFromResource, resource:" << resourceName << ", " << log().toStdString();
@@ -49,12 +49,12 @@ void MonochromeOpenGLProgram::load(bool isCoreProfile)
     m_isLoaded = true;
 }
 
-int MonochromeOpenGLProgram::getUniformLocationByName(const std::string &name)
+int MonochromeOpenGLProgram::getUniformLocationByName(const std::string& name)
 {
     auto findLocation = m_uniformLocationMap.find(name);
     if (findLocation != m_uniformLocationMap.end())
         return findLocation->second;
     int location = uniformLocation(name.c_str());
-    m_uniformLocationMap.insert({name, location});
+    m_uniformLocationMap.insert({ name, location });
     return location;
 }

application/sources/monochrome_opengl_program.h

@@ -1,19 +1,18 @@
 #ifndef DUST3D_APPLICATION_MONOCHROME_OPENGL_PROGRAM_H_
 #define DUST3D_APPLICATION_MONOCHROME_OPENGL_PROGRAM_H_
 
-#include <memory>
-#include <QOpenGLShaderProgram>
 #include <QOpenGLShader>
+#include <QOpenGLShaderProgram>
+#include <memory>
 
-class MonochromeOpenGLProgram: public QOpenGLShaderProgram
+class MonochromeOpenGLProgram : public QOpenGLShaderProgram {
-{
 public:
-    void load(bool isCoreProfile=false);
+    void load(bool isCoreProfile = false);
-    int getUniformLocationByName(const std::string &name);
+    int getUniformLocationByName(const std::string& name);
     bool isCoreProfile() const;
 
 private:
-    void addShaderFromResource(QOpenGLShader::ShaderType type, const char *resourceName);
+    void addShaderFromResource(QOpenGLShader::ShaderType type, const char* resourceName);
 
     bool m_isLoaded = false;
     bool m_isCoreProfile = false;

application/sources/part_manage_widget.cc

@@ -1,27 +1,27 @@
-#include <QVBoxLayout>
-#include <QWidgetAction>
-#include <QMenu>
 #include "part_manage_widget.h"
+#include "component_list_model.h"
 #include "component_preview_grid_widget.h"
 #include "component_property_widget.h"
-#include "component_list_model.h"
-#include "theme.h"
 #include "document.h"
+#include "theme.h"
+#include <QMenu>
+#include <QVBoxLayout>
+#include <QWidgetAction>
 
-PartManageWidget::PartManageWidget(Document *document, QWidget *parent):
+PartManageWidget::PartManageWidget(Document* document, QWidget* parent)
-    QWidget(parent),
+    : QWidget(parent)
-    m_document(document)
+    , m_document(document)
 {
     setContextMenuPolicy(Qt::CustomContextMenu);
 
-    QHBoxLayout *toolsLayout = new QHBoxLayout;
+    QHBoxLayout* toolsLayout = new QHBoxLayout;
     toolsLayout->setSpacing(0);
     toolsLayout->setMargin(0);
 
     setStyleSheet("QPushButton:disabled {border: 0; color: " + Theme::gray.name() + "}");
 
-    auto createButton = [](QChar icon, const QString &title) {
+    auto createButton = [](QChar icon, const QString& title) {
-        QPushButton *button = new QPushButton(icon);
+        QPushButton* button = new QPushButton(icon);
         Theme::initIconButton(button);
         button->setToolTip(title);
         return button;
@@ -58,50 +58,50 @@ PartManageWidget::PartManageWidget(Document *document, QWidget *parent):
     //connect(m_componentPreviewGridWidget->selectionModel(), &QItemSelectionModel::selectionChanged, this, &PartManageWidget::showSelectedComponentProperties);
 
     connect(m_levelUpButton, &QPushButton::clicked, [this]() {
-        const auto &parent = m_document->findComponentParent(this->m_componentPreviewGridWidget->componentListModel()->listingComponentId());
+        const auto& parent = m_document->findComponentParent(this->m_componentPreviewGridWidget->componentListModel()->listingComponentId());
         if (nullptr == parent)
             return;
         this->m_componentPreviewGridWidget->componentListModel()->setListingComponentId(parent->id);
     });
 
     connect(m_hideButton, &QPushButton::clicked, [this]() {
-        for (const auto &partId: this->m_componentPreviewGridWidget->getSelectedPartIds())
+        for (const auto& partId : this->m_componentPreviewGridWidget->getSelectedPartIds())
             this->m_document->setPartVisibleState(partId, false);
         this->m_document->saveSnapshot();
     });
     connect(m_showButton, &QPushButton::clicked, [this]() {
-        for (const auto &partId: this->m_componentPreviewGridWidget->getSelectedPartIds())
+        for (const auto& partId : this->m_componentPreviewGridWidget->getSelectedPartIds())
             this->m_document->setPartVisibleState(partId, true);
         this->m_document->saveSnapshot();
     });
 
     connect(m_unlockButton, &QPushButton::clicked, [this]() {
-        for (const auto &partId: this->m_componentPreviewGridWidget->getSelectedPartIds())
+        for (const auto& partId : this->m_componentPreviewGridWidget->getSelectedPartIds())
             this->m_document->setPartLockState(partId, false);
         this->m_document->saveSnapshot();
     });
     connect(m_lockButton, &QPushButton::clicked, [this]() {
-        for (const auto &partId: this->m_componentPreviewGridWidget->getSelectedPartIds())
+        for (const auto& partId : this->m_componentPreviewGridWidget->getSelectedPartIds())
             this->m_document->setPartLockState(partId, true);
         this->m_document->saveSnapshot();
     });
 
     connect(m_unlinkButton, &QPushButton::clicked, [this]() {
-        for (const auto &partId: this->m_componentPreviewGridWidget->getSelectedPartIds())
+        for (const auto& partId : this->m_componentPreviewGridWidget->getSelectedPartIds())
             this->m_document->setPartDisableState(partId, true);
         this->m_document->saveSnapshot();
     });
     connect(m_linkButton, &QPushButton::clicked, [this]() {
-        for (const auto &partId: this->m_componentPreviewGridWidget->getSelectedPartIds())
+        for (const auto& partId : this->m_componentPreviewGridWidget->getSelectedPartIds())
             this->m_document->setPartDisableState(partId, false);
         this->m_document->saveSnapshot();
     });
 
     connect(m_selectButton, &QPushButton::clicked, [this]() {
-        for (const auto &componentId: this->m_componentPreviewGridWidget->getSelectedComponentIds()) {
+        for (const auto& componentId : this->m_componentPreviewGridWidget->getSelectedComponentIds()) {
             std::vector<dust3d::Uuid> partIds;
             this->m_document->collectComponentDescendantParts(componentId, partIds);
-            for (const auto &partId: partIds)
+            for (const auto& partId : partIds)
                 emit this->selectPartOnCanvas(partId);
         }
     });
@@ -119,7 +119,7 @@ PartManageWidget::PartManageWidget(Document *document, QWidget *parent):
 
     connect(this, &PartManageWidget::customContextMenuRequested, this, &PartManageWidget::showContextMenu);
 
-    QVBoxLayout *mainLayout = new QVBoxLayout;
+    QVBoxLayout* mainLayout = new QVBoxLayout;
     mainLayout->addLayout(toolsLayout);
     mainLayout->addWidget(m_componentPreviewGridWidget);
 
@@ -135,10 +135,10 @@ void PartManageWidget::showSelectedComponentProperties()
     if (componentIds.empty())
         return;
 
-    auto *propertyWidget = new ComponentPropertyWidget(m_document, componentIds);
+    auto* propertyWidget = new ComponentPropertyWidget(m_document, componentIds);
 
     auto menu = std::make_unique<QMenu>(this->parentWidget());
-    QWidgetAction *widgetAction = new QWidgetAction(menu.get());
+    QWidgetAction* widgetAction = new QWidgetAction(menu.get());
     widgetAction->setDefaultWidget(propertyWidget);
     menu->addAction(widgetAction);
 
@@ -146,14 +146,13 @@ void PartManageWidget::showSelectedComponentProperties()
     if (x <= 0)
         x = QCursor::pos().x();
     menu->exec(QPoint(
-        x - propertyWidget->width(), 
+        x - propertyWidget->width(),
-        QCursor::pos().y()
+        QCursor::pos().y()));
-    ));
 }
 
-void PartManageWidget::selectComponentByPartId(const dust3d::Uuid &partId)
+void PartManageWidget::selectComponentByPartId(const dust3d::Uuid& partId)
 {
-    const auto &part = m_document->findPart(partId);
+    const auto& part = m_document->findPart(partId);
     if (nullptr == part)
         return;
     auto componentId = part->componentId;
@@ -163,7 +162,7 @@ void PartManageWidget::selectComponentByPartId(const dust3d::Uuid &partId)
         m_componentPreviewGridWidget->scrollTo(index);
         return;
     }
-    const auto &component = m_document->findComponent(componentId);
+    const auto& component = m_document->findComponent(componentId);
     if (nullptr == component)
         return;
     m_componentPreviewGridWidget->componentListModel()->setListingComponentId(component->parentId);
@@ -178,7 +177,7 @@ void PartManageWidget::selectComponentByPartId(const dust3d::Uuid &partId)
 
 void PartManageWidget::updateLevelUpButton()
 {
-    const auto &parent = m_document->findComponentParent(m_componentPreviewGridWidget->componentListModel()->listingComponentId());
+    const auto& parent = m_document->findComponentParent(m_componentPreviewGridWidget->componentListModel()->listingComponentId());
     m_levelUpButton->setEnabled(nullptr != parent);
 }
 
@@ -193,13 +192,13 @@ void PartManageWidget::updateToolButtons()
     bool enableUnlinkButton = false;
     bool enableLinkButton = false;
     bool enablePropertyButton = false;
-    for (const auto &component: selectedComponents) {
+    for (const auto& component : selectedComponents) {
         enablePropertyButton = true;
         enableSelectButton = true;
         if (component->linkToPartId.isNull()) {
             continue;
         }
-        const auto &part = m_document->findPart(component->linkToPartId);
+        const auto& part = m_document->findPart(component->linkToPartId);
         if (part->visible) {
             enableHideButton = true;
         } else {
@@ -229,14 +228,14 @@ void PartManageWidget::updateToolButtons()
 bool PartManageWidget::hasSelectedGroupedComponent()
 {
     auto selectedComponents = m_componentPreviewGridWidget->getSelectedComponents();
-    for (auto &component: selectedComponents) {
+    for (auto& component : selectedComponents) {
         if (!component->childrenIds.empty())
             return true;
     }
     return false;
 }
 
-void PartManageWidget::showContextMenu(const QPoint &pos)
+void PartManageWidget::showContextMenu(const QPoint& pos)
 {
     auto selectedComponentIds = m_componentPreviewGridWidget->getSelectedComponentIds();
     if (selectedComponentIds.empty())
@@ -255,7 +254,7 @@ void PartManageWidget::showContextMenu(const QPoint &pos)
     QAction ungroupAction(tr("Ungroup"), this);
     if (hasSelectedGroupedComponent()) {
         connect(&ungroupAction, &QAction::triggered, this, [=]() {
-            for (const auto &it: selectedComponentIds)
+            for (const auto& it : selectedComponentIds)
                 emit this->ungroupComponent(it);
             emit this->groupOperationAdded();
         });

application/sources/part_manage_widget.h

@@ -1,41 +1,42 @@
 #ifndef DUST3D_APPLICATION_PART_MANAGE_WIDGET_H_
 #define DUST3D_APPLICATION_PART_MANAGE_WIDGET_H_
 
-#include <dust3d/base/uuid.h>
 #include <QWidget>
+#include <dust3d/base/uuid.h>
 
 class Document;
 class ComponentPreviewGridWidget;
 class ComponentPropertyWidget;
 class QPushButton;
 
-class PartManageWidget: public QWidget
+class PartManageWidget : public QWidget {
-{
     Q_OBJECT
 signals:
     void unselectAllOnCanvas();
-    void selectPartOnCanvas(const dust3d::Uuid &partId);
+    void selectPartOnCanvas(const dust3d::Uuid& partId);
-    void groupComponents(const std::vector<dust3d::Uuid> &componentIds);
+    void groupComponents(const std::vector<dust3d::Uuid>& componentIds);
-    void ungroupComponent(const dust3d::Uuid &componentId);
+    void ungroupComponent(const dust3d::Uuid& componentId);
     void groupOperationAdded();
 public slots:
-    void selectComponentByPartId(const dust3d::Uuid &partId);
+    void selectComponentByPartId(const dust3d::Uuid& partId);
     void showSelectedComponentProperties();
-    void showContextMenu(const QPoint &pos);
+    void showContextMenu(const QPoint& pos);
+
 public:
-    PartManageWidget(Document *document, QWidget *parent=nullptr);
+    PartManageWidget(Document* document, QWidget* parent = nullptr);
+
 private:
-    Document *m_document = nullptr;
+    Document* m_document = nullptr;
-    ComponentPreviewGridWidget *m_componentPreviewGridWidget = nullptr;
+    ComponentPreviewGridWidget* m_componentPreviewGridWidget = nullptr;
-    QPushButton *m_levelUpButton = nullptr;
+    QPushButton* m_levelUpButton = nullptr;
-    QPushButton *m_selectButton = nullptr;
+    QPushButton* m_selectButton = nullptr;
-    QPushButton *m_lockButton = nullptr;
+    QPushButton* m_lockButton = nullptr;
-    QPushButton *m_unlockButton = nullptr;
+    QPushButton* m_unlockButton = nullptr;
-    QPushButton *m_showButton = nullptr;
+    QPushButton* m_showButton = nullptr;
-    QPushButton *m_hideButton = nullptr;
+    QPushButton* m_hideButton = nullptr;
-    QPushButton *m_unlinkButton = nullptr;
+    QPushButton* m_unlinkButton = nullptr;
-    QPushButton *m_linkButton = nullptr;
+    QPushButton* m_linkButton = nullptr;
-    QPushButton *m_propertyButton = nullptr;
+    QPushButton* m_propertyButton = nullptr;
     void updateToolButtons();
     void updateLevelUpButton();
     bool hasSelectedGroupedComponent();

application/sources/preferences.cc

@@ -1,10 +1,10 @@
 #include "preferences.h"
 
-#define MAX_RECENT_FILES            7
+#define MAX_RECENT_FILES 7
 
-Preferences &Preferences::instance()
+Preferences& Preferences::instance()
 {
-    static Preferences *s_preferences = nullptr;
+    static Preferences* s_preferences = nullptr;
     if (nullptr == s_preferences) {
         s_preferences = new Preferences;
     }
@@ -40,15 +40,15 @@ int Preferences::maxRecentFiles() const
     return MAX_RECENT_FILES;
 }
 
-void Preferences::setCurrentFile(const QString &fileName)
+void Preferences::setCurrentFile(const QString& fileName)
 {
     QStringList files = m_settings.value("recentFileList").toStringList();
-    
+
     files.removeAll(fileName);
     files.prepend(fileName);
     while (files.size() > MAX_RECENT_FILES)
         files.removeLast();
-    
+
     m_settings.setValue("recentFileList", files);
 }
 
@@ -57,6 +57,6 @@ void Preferences::reset()
     auto files = m_settings.value("recentFileList").toStringList();
     m_settings.clear();
     m_settings.setValue("recentFileList", files);
-    
+
     loadDefault();
 }

application/sources/preferences.h

@@ -5,19 +5,19 @@
 #include <QSize>
 #include <QStringList>
 
-class Preferences : public QObject
+class Preferences : public QObject {
-{
     Q_OBJECT
 public:
-    static Preferences &instance();
+    static Preferences& instance();
     Preferences();
     QSize documentWindowSize() const;
     void setDocumentWindowSize(const QSize&);
     QStringList recentFileList() const;
     int maxRecentFiles() const;
 public slots:
-    void setCurrentFile(const QString &fileName);
+    void setCurrentFile(const QString& fileName);
     void reset();
+
 private:
     QSettings m_settings;
     void loadDefault();

application/sources/preview_grid_view.cc

@@ -1,8 +1,8 @@
 #include "preview_grid_view.h"
 #include "theme.h"
 
-PreviewGridView::PreviewGridView(QWidget *parent):
+PreviewGridView::PreviewGridView(QWidget* parent)
-    QListView(parent)
+    : QListView(parent)
 {
     QPalette viewPalette = palette();
     viewPalette.setColor(QPalette::Window, Qt::transparent);
@@ -13,9 +13,7 @@ PreviewGridView::PreviewGridView(QWidget *parent):
     auto margin = Theme::previewIconMargin;
     auto borderRadius = Theme::previewIconBorderRadius;
     setStyleSheet(
-        "QListView::item {border:" + QString::number(borderSize) + "px solid transparent; margin:" + QString::number(margin) + "px; background-color: " + Theme::gray.name() +"; border-radius: " + QString::number(borderRadius) + ";}" +
+        "QListView::item {border:" + QString::number(borderSize) + "px solid transparent; margin:" + QString::number(margin) + "px; background-color: " + Theme::gray.name() + "; border-radius: " + QString::number(borderRadius) + ";}" + "QListView::item:selected {border-color: " + Theme::red.name() + ";}");
-        "QListView::item:selected {border-color: " + Theme::red.name() + ";}"
-    );
 
     setViewMode(QListView::IconMode);
     setGridSize(QSize(Theme::partPreviewImageSize, Theme::partPreviewImageSize));

application/sources/preview_grid_view.h

@@ -3,11 +3,10 @@
 
 #include <QListView>
 
-class PreviewGridView: public QListView
+class PreviewGridView : public QListView {
-{
     Q_OBJECT
 public:
-    PreviewGridView(QWidget *parent=nullptr);
+    PreviewGridView(QWidget* parent = nullptr);
 };
 
 #endif

application/sources/skeleton_document.cc

@@ -1,7 +1,7 @@
-#include <QDebug>
 #include "skeleton_document.h"
+#include <QDebug>
 
-const SkeletonNode *SkeletonDocument::findNode(dust3d::Uuid nodeId) const
+const SkeletonNode* SkeletonDocument::findNode(dust3d::Uuid nodeId) const
 {
     auto it = nodeMap.find(nodeId);
     if (it == nodeMap.end())
@@ -9,7 +9,7 @@ const SkeletonNode *SkeletonDocument::findNode(dust3d::Uuid nodeId) const
     return &it->second;
 }
 
-const SkeletonEdge *SkeletonDocument::findEdge(dust3d::Uuid edgeId) const
+const SkeletonEdge* SkeletonDocument::findEdge(dust3d::Uuid edgeId) const
 {
     auto it = edgeMap.find(edgeId);
     if (it == edgeMap.end())
@@ -17,7 +17,7 @@ const SkeletonEdge *SkeletonDocument::findEdge(dust3d::Uuid edgeId) const
     return &it->second;
 }
 
-const SkeletonPart *SkeletonDocument::findPart(dust3d::Uuid partId) const
+const SkeletonPart* SkeletonDocument::findPart(dust3d::Uuid partId) const
 {
     auto it = partMap.find(partId);
     if (it == partMap.end())
@@ -25,9 +25,9 @@ const SkeletonPart *SkeletonDocument::findPart(dust3d::Uuid partId) const
     return &it->second;
 }
 
-const SkeletonEdge *SkeletonDocument::findEdgeByNodes(dust3d::Uuid firstNodeId, dust3d::Uuid secondNodeId) const
+const SkeletonEdge* SkeletonDocument::findEdgeByNodes(dust3d::Uuid firstNodeId, dust3d::Uuid secondNodeId) const
 {
-    const SkeletonNode *firstNode = nullptr;
+    const SkeletonNode* firstNode = nullptr;
     firstNode = findNode(firstNodeId);
     if (nullptr == firstNode) {
         return nullptr;
@@ -43,18 +43,18 @@ const SkeletonEdge *SkeletonDocument::findEdgeByNodes(dust3d::Uuid firstNodeId,
     return nullptr;
 }
 
-void SkeletonDocument::findAllNeighbors(dust3d::Uuid nodeId, std::set<dust3d::Uuid> &neighbors) const
+void SkeletonDocument::findAllNeighbors(dust3d::Uuid nodeId, std::set<dust3d::Uuid>& neighbors) const
 {
-    const auto &node = findNode(nodeId);
+    const auto& node = findNode(nodeId);
     if (nullptr == node) {
         return;
     }
-    for (const auto &edgeId: node->edgeIds) {
+    for (const auto& edgeId : node->edgeIds) {
-        const auto &edge = findEdge(edgeId);
+        const auto& edge = findEdge(edgeId);
         if (nullptr == edge) {
             continue;
         }
-        const auto &neighborNodeId = edge->neighborOf(nodeId);
+        const auto& neighborNodeId = edge->neighborOf(nodeId);
         if (neighborNodeId.isNull()) {
             continue;
         }
@@ -68,7 +68,7 @@ void SkeletonDocument::findAllNeighbors(dust3d::Uuid nodeId, std::set<dust3d::Uu
 
 bool SkeletonDocument::isNodeConnectable(dust3d::Uuid nodeId) const
 {
-    const auto &node = findNode(nodeId);
+    const auto& node = findNode(nodeId);
     if (nullptr == node)
         return false;
     if (node->edgeIds.size() < 2)
@@ -78,7 +78,7 @@ bool SkeletonDocument::isNodeConnectable(dust3d::Uuid nodeId) const
 
 void SkeletonDocument::reduceNode(dust3d::Uuid nodeId)
 {
-    const SkeletonNode *node = findNode(nodeId);
+    const SkeletonNode* node = findNode(nodeId);
     if (nullptr == node) {
         return;
     }
@@ -87,11 +87,11 @@ void SkeletonDocument::reduceNode(dust3d::Uuid nodeId)
     }
     dust3d::Uuid firstEdgeId = node->edgeIds[0];
     dust3d::Uuid secondEdgeId = node->edgeIds[1];
-    const SkeletonEdge *firstEdge = findEdge(firstEdgeId);
+    const SkeletonEdge* firstEdge = findEdge(firstEdgeId);
     if (nullptr == firstEdge) {
         return;
     }
-    const SkeletonEdge *secondEdge = findEdge(secondEdgeId);
+    const SkeletonEdge* secondEdge = findEdge(secondEdgeId);
     if (nullptr == secondEdge) {
         return;
     }
@@ -103,7 +103,7 @@ void SkeletonDocument::reduceNode(dust3d::Uuid nodeId)
 
 void SkeletonDocument::breakEdge(dust3d::Uuid edgeId)
 {
-    const SkeletonEdge *edge = findEdge(edgeId);
+    const SkeletonEdge* edge = findEdge(edgeId);
     if (nullptr == edge) {
         return;
     }
@@ -112,11 +112,11 @@ void SkeletonDocument::breakEdge(dust3d::Uuid edgeId)
     }
     dust3d::Uuid firstNodeId = edge->nodeIds[0];
     dust3d::Uuid secondNodeId = edge->nodeIds[1];
-    const SkeletonNode *firstNode = findNode(firstNodeId);
+    const SkeletonNode* firstNode = findNode(firstNodeId);
     if (nullptr == firstNode) {
         return;
     }
-    const SkeletonNode *secondNode = findNode(secondNodeId);
+    const SkeletonNode* secondNode = findNode(secondNodeId);
     if (nullptr == secondNode) {
         return;
     }
@@ -134,7 +134,7 @@ void SkeletonDocument::breakEdge(dust3d::Uuid edgeId)
 
 void SkeletonDocument::reverseEdge(dust3d::Uuid edgeId)
 {
-    SkeletonEdge *edge = (SkeletonEdge *)findEdge(edgeId);
+    SkeletonEdge* edge = (SkeletonEdge*)findEdge(edgeId);
     if (nullptr == edge) {
         return;
     }
@@ -151,13 +151,13 @@ void SkeletonDocument::reverseEdge(dust3d::Uuid edgeId)
 
 void SkeletonDocument::removeEdge(dust3d::Uuid edgeId)
 {
-    const SkeletonEdge *edge = findEdge(edgeId);
+    const SkeletonEdge* edge = findEdge(edgeId);
     if (nullptr == edge) {
         return;
     }
     if (isPartReadonly(edge->partId))
         return;
-    const SkeletonPart *oldPart = findPart(edge->partId);
+    const SkeletonPart* oldPart = findPart(edge->partId);
     if (nullptr == oldPart) {
         return;
     }
@@ -169,7 +169,7 @@ void SkeletonDocument::removeEdge(dust3d::Uuid edgeId)
     std::vector<dust3d::Uuid> newPartIds;
     for (auto groupIt = groups.begin(); groupIt != groups.end(); groupIt++) {
         const auto newUuid = dust3d::Uuid::createUuid();
-        SkeletonPart &part = partMap[newUuid];
+        SkeletonPart& part = partMap[newUuid];
         part.id = newUuid;
         part.copyAttributes(*oldPart);
         part.name = nextPartName;
@@ -189,7 +189,7 @@ void SkeletonDocument::removeEdge(dust3d::Uuid edgeId)
             }
         }
         addPartToComponent(part.id, findComponentParentId(part.componentId));
-        newPartNodeNumMap.push_back({part.id, part.nodeIds.size()});
+        newPartNodeNumMap.push_back({ part.id, part.nodeIds.size() });
         newPartIds.push_back(part.id);
         emit partAdded(part.id);
     }
@@ -204,27 +204,26 @@ void SkeletonDocument::removeEdge(dust3d::Uuid edgeId)
     edgeMap.erase(edgeId);
     emit edgeRemoved(edgeId);
     removePart(oldPartId);
-    
+
     if (!newPartNodeNumMap.empty()) {
-        std::sort(newPartNodeNumMap.begin(), newPartNodeNumMap.end(), [&](
+        std::sort(newPartNodeNumMap.begin(), newPartNodeNumMap.end(), [&](const std::pair<dust3d::Uuid, size_t>& first, const std::pair<dust3d::Uuid, size_t>& second) {
-                const std::pair<dust3d::Uuid, size_t> &first, const std::pair<dust3d::Uuid, size_t> &second) {
             return first.second > second.second;
         });
         updateLinkedPart(oldPartId, newPartNodeNumMap[0].first);
     }
-    
+
     emit skeletonChanged();
 }
 
 void SkeletonDocument::removeNode(dust3d::Uuid nodeId)
 {
-    const SkeletonNode *node = findNode(nodeId);
+    const SkeletonNode* node = findNode(nodeId);
     if (nullptr == node) {
         return;
     }
     if (isPartReadonly(node->partId))
         return;
-    const SkeletonPart *oldPart = findPart(node->partId);
+    const SkeletonPart* oldPart = findPart(node->partId);
     if (nullptr == oldPart) {
         return;
     }
@@ -236,7 +235,7 @@ void SkeletonDocument::removeNode(dust3d::Uuid nodeId)
     std::vector<dust3d::Uuid> newPartIds;
     for (auto groupIt = groups.begin(); groupIt != groups.end(); groupIt++) {
         const auto newUuid = dust3d::Uuid::createUuid();
-        SkeletonPart &part = partMap[newUuid];
+        SkeletonPart& part = partMap[newUuid];
         part.id = newUuid;
         part.copyAttributes(*oldPart);
         part.name = nextPartName;
@@ -256,7 +255,7 @@ void SkeletonDocument::removeNode(dust3d::Uuid nodeId)
             }
         }
         addPartToComponent(part.id, findComponentParentId(part.componentId));
-        newPartNodeNumMap.push_back({part.id, part.nodeIds.size()});
+        newPartNodeNumMap.push_back({ part.id, part.nodeIds.size() });
         newPartIds.push_back(part.id);
         emit partAdded(part.id);
     }
@@ -277,15 +276,14 @@ void SkeletonDocument::removeNode(dust3d::Uuid nodeId)
     nodeMap.erase(nodeId);
     emit nodeRemoved(nodeId);
     removePart(oldPartId);
-    
+
     if (!newPartNodeNumMap.empty()) {
-        std::sort(newPartNodeNumMap.begin(), newPartNodeNumMap.end(), [&](
+        std::sort(newPartNodeNumMap.begin(), newPartNodeNumMap.end(), [&](const std::pair<dust3d::Uuid, size_t>& first, const std::pair<dust3d::Uuid, size_t>& second) {
-                const std::pair<dust3d::Uuid, size_t> &first, const std::pair<dust3d::Uuid, size_t> &second) {
             return first.second > second.second;
         });
         updateLinkedPart(oldPartId, newPartNodeNumMap[0].first);
     }
-    
+
     emit skeletonChanged();
 }
 
@@ -302,11 +300,11 @@ void SkeletonDocument::addNodeWithId(dust3d::Uuid nodeId, float x, float y, floa
 dust3d::Uuid SkeletonDocument::createNode(dust3d::Uuid nodeId, float x, float y, float z, float radius, dust3d::Uuid fromNodeId)
 {
     dust3d::Uuid partId;
-    const SkeletonNode *fromNode = nullptr;
+    const SkeletonNode* fromNode = nullptr;
     bool newPartAdded = false;
     if (fromNodeId.isNull()) {
         const auto newUuid = dust3d::Uuid::createUuid();
-        SkeletonPart &part = partMap[newUuid];
+        SkeletonPart& part = partMap[newUuid];
         part.id = newUuid;
         partId = part.id;
         emit partAdded(partId);
@@ -331,35 +329,35 @@ dust3d::Uuid SkeletonDocument::createNode(dust3d::Uuid nodeId, float x, float y,
     node.setZ(z);
     nodeMap[node.id] = node;
     partMap[partId].nodeIds.push_back(node.id);
-    
+
     emit nodeAdded(node.id);
-    
+
     if (nullptr != fromNode) {
         SkeletonEdge edge;
         edge.partId = partId;
         edge.nodeIds.push_back(fromNode->id);
         edge.nodeIds.push_back(node.id);
         edgeMap[edge.id] = edge;
-        
+
         nodeMap[node.id].edgeIds.push_back(edge.id);
         nodeMap[fromNode->id].edgeIds.push_back(edge.id);
-        
+
         emit edgeAdded(edge.id);
     }
-    
+
     if (newPartAdded)
         addPartToComponent(partId, m_currentCanvasComponentId);
-    
+
     emit skeletonChanged();
-    
+
     return node.id;
 }
 
-void SkeletonDocument::joinNodeAndNeiborsToGroup(std::vector<dust3d::Uuid> *group, dust3d::Uuid nodeId, std::set<dust3d::Uuid> *visitMap, dust3d::Uuid noUseEdgeId)
+void SkeletonDocument::joinNodeAndNeiborsToGroup(std::vector<dust3d::Uuid>* group, dust3d::Uuid nodeId, std::set<dust3d::Uuid>* visitMap, dust3d::Uuid noUseEdgeId)
 {
     if (nodeId.isNull() || visitMap->find(nodeId) != visitMap->end())
         return;
-    const SkeletonNode *node = findNode(nodeId);
+    const SkeletonNode* node = findNode(nodeId);
     if (nullptr == node) {
         return;
     }
@@ -368,7 +366,7 @@ void SkeletonDocument::joinNodeAndNeiborsToGroup(std::vector<dust3d::Uuid> *grou
     for (auto edgeIt = node->edgeIds.begin(); edgeIt != node->edgeIds.end(); edgeIt++) {
         if (noUseEdgeId == *edgeIt)
             continue;
-        const SkeletonEdge *edge = findEdge(*edgeIt);
+        const SkeletonEdge* edge = findEdge(*edgeIt);
         if (nullptr == edge) {
             continue;
         }
@@ -378,14 +376,14 @@ void SkeletonDocument::joinNodeAndNeiborsToGroup(std::vector<dust3d::Uuid> *grou
     }
 }
 
-void SkeletonDocument::splitPartByNode(std::vector<std::vector<dust3d::Uuid>> *groups, dust3d::Uuid nodeId)
+void SkeletonDocument::splitPartByNode(std::vector<std::vector<dust3d::Uuid>>* groups, dust3d::Uuid nodeId)
 {
-    const SkeletonNode *node = findNode(nodeId);
+    const SkeletonNode* node = findNode(nodeId);
     std::set<dust3d::Uuid> visitMap;
     visitMap.insert(nodeId);
     for (auto edgeIt = node->edgeIds.begin(); edgeIt != node->edgeIds.end(); edgeIt++) {
         std::vector<dust3d::Uuid> group;
-        const SkeletonEdge *edge = findEdge(*edgeIt);
+        const SkeletonEdge* edge = findEdge(*edgeIt);
         if (nullptr == edge) {
             continue;
         }
@@ -395,9 +393,9 @@ void SkeletonDocument::splitPartByNode(std::vector<std::vector<dust3d::Uuid>> *g
     }
 }
 
-void SkeletonDocument::splitPartByEdge(std::vector<std::vector<dust3d::Uuid>> *groups, dust3d::Uuid edgeId)
+void SkeletonDocument::splitPartByEdge(std::vector<std::vector<dust3d::Uuid>>* groups, dust3d::Uuid edgeId)
 {
-    const SkeletonEdge *edge = findEdge(edgeId);
+    const SkeletonEdge* edge = findEdge(edgeId);
     if (nullptr == edge) {
         return;
     }
@@ -410,17 +408,17 @@ void SkeletonDocument::splitPartByEdge(std::vector<std::vector<dust3d::Uuid>> *g
     }
 }
 
-const SkeletonComponent *SkeletonDocument::findComponentParent(dust3d::Uuid componentId) const
+const SkeletonComponent* SkeletonDocument::findComponentParent(dust3d::Uuid componentId) const
 {
     auto component = componentMap.find(componentId);
     if (component == componentMap.end()) {
         return nullptr;
     }
-    
+
     if (component->second.parentId.isNull())
         return &rootComponent;
-    
+
-    return (SkeletonComponent *)findComponent(component->second.parentId);
+    return (SkeletonComponent*)findComponent(component->second.parentId);
 }
 
 dust3d::Uuid SkeletonDocument::findComponentParentId(dust3d::Uuid componentId) const
@@ -429,18 +427,18 @@ dust3d::Uuid SkeletonDocument::findComponentParentId(dust3d::Uuid componentId) c
     if (component == componentMap.end()) {
         return dust3d::Uuid();
     }
-    
+
     return component->second.parentId;
 }
 
 void SkeletonDocument::moveComponentUp(dust3d::Uuid componentId)
 {
-    SkeletonComponent *parent = (SkeletonComponent *)findComponentParent(componentId);
+    SkeletonComponent* parent = (SkeletonComponent*)findComponentParent(componentId);
     if (nullptr == parent)
         return;
-    
+
     dust3d::Uuid parentId = findComponentParentId(componentId);
-    
+
     parent->moveChildUp(componentId);
     parent->dirty = true;
     emit componentChildrenChanged(parentId);
@@ -449,12 +447,12 @@ void SkeletonDocument::moveComponentUp(dust3d::Uuid componentId)
 
 void SkeletonDocument::moveComponentDown(dust3d::Uuid componentId)
 {
-    SkeletonComponent *parent = (SkeletonComponent *)findComponentParent(componentId);
+    SkeletonComponent* parent = (SkeletonComponent*)findComponentParent(componentId);
     if (nullptr == parent)
         return;
-    
+
     dust3d::Uuid parentId = findComponentParentId(componentId);
-    
+
     parent->moveChildDown(componentId);
     parent->dirty = true;
     emit componentChildrenChanged(parentId);
@@ -463,12 +461,12 @@ void SkeletonDocument::moveComponentDown(dust3d::Uuid componentId)
 
 void SkeletonDocument::moveComponentToTop(dust3d::Uuid componentId)
 {
-    SkeletonComponent *parent = (SkeletonComponent *)findComponentParent(componentId);
+    SkeletonComponent* parent = (SkeletonComponent*)findComponentParent(componentId);
     if (nullptr == parent)
         return;
-    
+
     dust3d::Uuid parentId = findComponentParentId(componentId);
-    
+
     parent->moveChildToTop(componentId);
     parent->dirty = true;
     emit componentChildrenChanged(parentId);
@@ -477,12 +475,12 @@ void SkeletonDocument::moveComponentToTop(dust3d::Uuid componentId)
 
 void SkeletonDocument::moveComponentToBottom(dust3d::Uuid componentId)
 {
-    SkeletonComponent *parent = (SkeletonComponent *)findComponentParent(componentId);
+    SkeletonComponent* parent = (SkeletonComponent*)findComponentParent(componentId);
     if (nullptr == parent)
         return;
-    
+
     dust3d::Uuid parentId = findComponentParentId(componentId);
-    
+
     parent->moveChildToBottom(componentId);
     parent->dirty = true;
     emit componentChildrenChanged(parentId);
@@ -495,10 +493,10 @@ void SkeletonDocument::renameComponent(dust3d::Uuid componentId, QString name)
     if (component == componentMap.end()) {
         return;
     }
-    
+
     if (component->second.name == name)
         return;
-    
+
     if (!name.trimmed().isEmpty())
         component->second.name = name;
     emit componentNameChanged(componentId);
@@ -511,20 +509,20 @@ void SkeletonDocument::setComponentExpandState(dust3d::Uuid componentId, bool ex
     if (component == componentMap.end()) {
         return;
     }
-    
+
     if (component->second.expanded == expanded)
         return;
-    
+
     component->second.expanded = expanded;
     emit componentExpandStateChanged(componentId);
     emit optionsChanged();
 }
 
-void SkeletonDocument::ungroupComponent(const dust3d::Uuid &componentId)
+void SkeletonDocument::ungroupComponent(const dust3d::Uuid& componentId)
 {
     if (componentId.isNull())
         return;
-    SkeletonComponent *component = (SkeletonComponent *)findComponent(componentId);
+    SkeletonComponent* component = (SkeletonComponent*)findComponent(componentId);
     if (nullptr == component) {
         dust3dDebug << "Component not found:" << componentId.toString();
         return;
@@ -532,15 +530,15 @@ void SkeletonDocument::ungroupComponent(const dust3d::Uuid &componentId)
     if (component->childrenIds.empty())
         return;
     auto childrenIds = component->childrenIds;
-    SkeletonComponent *newParent = (SkeletonComponent *)findComponentParent(componentId);
+    SkeletonComponent* newParent = (SkeletonComponent*)findComponentParent(componentId);
     if (nullptr == newParent) {
         dust3dDebug << "Expected parent component to be found, component:" << componentId.toString();
         return;
     }
     auto newParentId = newParent->id;
     newParent->replaceChildWithOthers(componentId, childrenIds);
-    for (const auto &childId: childrenIds) {
+    for (const auto& childId : childrenIds) {
-        SkeletonComponent *child = (SkeletonComponent *)findComponent(childId);
+        SkeletonComponent* child = (SkeletonComponent*)findComponent(childId);
         if (nullptr == child)
             continue;
         child->parentId = newParentId;
@@ -551,7 +549,7 @@ void SkeletonDocument::ungroupComponent(const dust3d::Uuid &componentId)
     emit skeletonChanged();
 }
 
-void SkeletonDocument::groupComponents(const std::vector<dust3d::Uuid> &componentIds)
+void SkeletonDocument::groupComponents(const std::vector<dust3d::Uuid>& componentIds)
 {
     if (componentIds.empty())
         return;
@@ -563,7 +561,7 @@ void SkeletonDocument::groupComponents(const std::vector<dust3d::Uuid> &componen
 
     auto it = componentIds.begin();
 
-    SkeletonComponent *oldParent = (SkeletonComponent *)findComponentParent(*it);
+    SkeletonComponent* oldParent = (SkeletonComponent*)findComponentParent(*it);
     if (nullptr == oldParent) {
         dust3dDebug << "Expected parent component to be found, component:" << it->toString();
         return;
@@ -574,7 +572,7 @@ void SkeletonDocument::groupComponents(const std::vector<dust3d::Uuid> &componen
         oldParent->removeChild(*it);
     }
 
-    for (const auto &componentId: componentIds) {
+    for (const auto& componentId : componentIds) {
         auto component = componentMap.find(componentId);
         if (component == componentMap.end()) {
             continue;
@@ -594,21 +592,21 @@ void SkeletonDocument::groupComponents(const std::vector<dust3d::Uuid> &componen
 
 void SkeletonDocument::createNewChildComponent(dust3d::Uuid parentComponentId)
 {
-    SkeletonComponent *parentComponent = (SkeletonComponent *)findComponent(parentComponentId);
+    SkeletonComponent* parentComponent = (SkeletonComponent*)findComponent(parentComponentId);
     if (!parentComponent->linkToPartId.isNull()) {
         parentComponentId = parentComponent->parentId;
-        parentComponent = (SkeletonComponent *)findComponent(parentComponentId);
+        parentComponent = (SkeletonComponent*)findComponent(parentComponentId);
     }
-    
+
     SkeletonComponent newComponent(dust3d::Uuid::createUuid());
     newComponent.name = tr("Group") + " " + QString::number(componentMap.size() - partMap.size() + 1);
-    
+
     parentComponent->addChild(newComponent.id);
     newComponent.parentId = parentComponentId;
-    
+
     auto newComponentId = newComponent.id;
     componentMap.emplace(newComponentId, std::move(newComponent));
-    
+
     emit componentChildrenChanged(parentComponentId);
     emit componentAdded(newComponentId);
     emit optionsChanged();
@@ -620,12 +618,12 @@ void SkeletonDocument::removePart(dust3d::Uuid partId)
     if (part == partMap.end()) {
         return;
     }
-    
+
     if (!part->second.componentId.isNull()) {
         removeComponent(part->second.componentId);
         return;
     }
-    
+
     removePartDontCareComponent(partId);
 }
 
@@ -635,10 +633,10 @@ void SkeletonDocument::removePartDontCareComponent(dust3d::Uuid partId)
     if (part == partMap.end()) {
         return;
     }
-    
+
     std::vector<dust3d::Uuid> removedNodeIds;
     std::vector<dust3d::Uuid> removedEdgeIds;
-    
+
     for (auto nodeIt = nodeMap.begin(); nodeIt != nodeMap.end();) {
         if (nodeIt->second.partId != partId) {
             nodeIt++;
@@ -647,7 +645,7 @@ void SkeletonDocument::removePartDontCareComponent(dust3d::Uuid partId)
         removedNodeIds.push_back(nodeIt->second.id);
         nodeIt = nodeMap.erase(nodeIt);
     }
-    
+
     for (auto edgeIt = edgeMap.begin(); edgeIt != edgeMap.end();) {
         if (edgeIt->second.partId != partId) {
             edgeIt++;
@@ -656,13 +654,13 @@ void SkeletonDocument::removePartDontCareComponent(dust3d::Uuid partId)
         removedEdgeIds.push_back(edgeIt->second.id);
         edgeIt = edgeMap.erase(edgeIt);
     }
-    
+
     partMap.erase(part);
-    
+
-    for (const auto &nodeId: removedNodeIds) {
+    for (const auto& nodeId : removedNodeIds) {
         emit nodeRemoved(nodeId);
     }
-    for (const auto &edgeId: removedEdgeIds) {
+    for (const auto& edgeId : removedEdgeIds) {
         emit edgeRemoved(edgeId);
     }
     emit partRemoved(partId);
@@ -671,7 +669,7 @@ void SkeletonDocument::removePartDontCareComponent(dust3d::Uuid partId)
 void SkeletonDocument::addPartToComponent(dust3d::Uuid partId, dust3d::Uuid componentId)
 {
     SkeletonComponent child(dust3d::Uuid::createUuid());
-    
+
     if (!componentId.isNull()) {
         auto parentComponent = componentMap.find(componentId);
         if (parentComponent == componentMap.end()) {
@@ -683,13 +681,13 @@ void SkeletonDocument::addPartToComponent(dust3d::Uuid partId, dust3d::Uuid comp
     } else {
         rootComponent.addChild(child.id);
     }
-    
+
     partMap[partId].componentId = child.id;
     child.linkToPartId = partId;
     child.parentId = componentId;
     auto childId = child.id;
     componentMap.emplace(childId, std::move(child));
-    
+
     emit componentChildrenChanged(componentId);
     emit componentAdded(childId);
 }
@@ -706,16 +704,16 @@ void SkeletonDocument::removeComponentRecursively(dust3d::Uuid componentId)
     if (component == componentMap.end()) {
         return;
     }
-    
+
     if (!component->second.linkToPartId.isNull()) {
         removePartDontCareComponent(component->second.linkToPartId);
     }
-    
+
     auto childrenIds = component->second.childrenIds;
-    for (const auto &childId: childrenIds) {
+    for (const auto& childId : childrenIds) {
         removeComponentRecursively(childId);
     }
-    
+
     dust3d::Uuid parentId = component->second.parentId;
     if (!parentId.isNull()) {
         auto parentComponent = componentMap.find(parentId);
@@ -726,7 +724,7 @@ void SkeletonDocument::removeComponentRecursively(dust3d::Uuid componentId)
     } else {
         rootComponent.removeChild(componentId);
     }
-    
+
     componentMap.erase(component);
     emit componentRemoved(componentId);
     emit componentChildrenChanged(parentId);
@@ -735,7 +733,7 @@ void SkeletonDocument::removeComponentRecursively(dust3d::Uuid componentId)
 void SkeletonDocument::setCurrentCanvasComponentId(dust3d::Uuid componentId)
 {
     m_currentCanvasComponentId = componentId;
-    const SkeletonComponent *component = findComponent(m_currentCanvasComponentId);
+    const SkeletonComponent* component = findComponent(m_currentCanvasComponentId);
     if (nullptr == component) {
         m_currentCanvasComponentId = dust3d::Uuid();
     } else {
@@ -749,7 +747,7 @@ void SkeletonDocument::setCurrentCanvasComponentId(dust3d::Uuid componentId)
 void SkeletonDocument::addComponent(dust3d::Uuid parentId)
 {
     SkeletonComponent component(dust3d::Uuid::createUuid());
-    
+
     if (!parentId.isNull()) {
         auto parentComponent = componentMap.find(parentId);
         if (parentComponent == componentMap.end()) {
@@ -759,18 +757,18 @@ void SkeletonDocument::addComponent(dust3d::Uuid parentId)
     } else {
         rootComponent.addChild(component.id);
     }
-    
+
     component.parentId = parentId;
     auto componentId = component.id;
     componentMap.emplace(componentId, std::move(component));
-    
+
     emit componentChildrenChanged(parentId);
     emit componentAdded(componentId);
 }
 
 bool SkeletonDocument::isDescendantComponent(dust3d::Uuid componentId, dust3d::Uuid suspiciousId)
 {
-    const SkeletonComponent *loopComponent = findComponentParent(suspiciousId);
+    const SkeletonComponent* loopComponent = findComponentParent(suspiciousId);
     while (nullptr != loopComponent) {
         if (loopComponent->id == componentId)
             return true;
@@ -788,13 +786,13 @@ void SkeletonDocument::moveComponent(dust3d::Uuid componentId, dust3d::Uuid toPa
     if (component == componentMap.end()) {
         return;
     }
-    
+
     if (component->second.parentId == toParentId)
         return;
-    
+
     if (isDescendantComponent(componentId, toParentId))
         return;
-    
+
     if (component->second.parentId.isNull()) {
         rootComponent.removeChild(componentId);
         emit componentChildrenChanged(rootComponent.id);
@@ -806,9 +804,9 @@ void SkeletonDocument::moveComponent(dust3d::Uuid componentId, dust3d::Uuid toPa
             emit componentChildrenChanged(oldParent->second.id);
         }
     }
-    
+
     component->second.parentId = toParentId;
-    
+
     if (toParentId.isNull()) {
         rootComponent.addChild(componentId);
         emit componentChildrenChanged(rootComponent.id);
@@ -820,7 +818,7 @@ void SkeletonDocument::moveComponent(dust3d::Uuid componentId, dust3d::Uuid toPa
             emit componentChildrenChanged(newParent->second.id);
         }
     }
-    
+
     emit skeletonChanged();
 }
 
@@ -864,25 +862,25 @@ void SkeletonDocument::setPartDisableState(dust3d::Uuid partId, bool disabled)
     emit skeletonChanged();
 }
 
-void SkeletonDocument::collectComponentDescendantParts(dust3d::Uuid componentId, std::vector<dust3d::Uuid> &partIds) const
+void SkeletonDocument::collectComponentDescendantParts(dust3d::Uuid componentId, std::vector<dust3d::Uuid>& partIds) const
 {
-    const SkeletonComponent *component = findComponent(componentId);
+    const SkeletonComponent* component = findComponent(componentId);
     if (nullptr == component)
         return;
-    
+
     if (!component->linkToPartId.isNull()) {
         partIds.push_back(component->linkToPartId);
         return;
     }
-    
+
-    for (const auto &childId: component->childrenIds) {
+    for (const auto& childId : component->childrenIds) {
         collectComponentDescendantParts(childId, partIds);
     }
 }
 
-void SkeletonDocument::collectComponentDescendantComponents(dust3d::Uuid componentId, std::vector<dust3d::Uuid> &componentIds) const
+void SkeletonDocument::collectComponentDescendantComponents(dust3d::Uuid componentId, std::vector<dust3d::Uuid>& componentIds) const
 {
-    const SkeletonComponent *component = findComponent(componentId);
+    const SkeletonComponent* component = findComponent(componentId);
     if (nullptr == component)
         return;
 
@@ -890,7 +888,7 @@ void SkeletonDocument::collectComponentDescendantComponents(dust3d::Uuid compone
         return;
     }
 
-    for (const auto &childId: component->childrenIds) {
+    for (const auto& childId : component->childrenIds) {
         componentIds.push_back(childId);
         collectComponentDescendantComponents(childId, componentIds);
     }
@@ -901,10 +899,10 @@ void SkeletonDocument::hideOtherComponents(dust3d::Uuid componentId)
     std::vector<dust3d::Uuid> partIds;
     collectComponentDescendantParts(componentId, partIds);
     std::set<dust3d::Uuid> partIdSet;
-    for (const auto &partId: partIds) {
+    for (const auto& partId : partIds) {
         partIdSet.insert(partId);
     }
-    for (const auto &part: partMap) {
+    for (const auto& part : partMap) {
         if (partIdSet.find(part.first) != partIdSet.end())
             continue;
         setPartVisibleState(part.first, false);
@@ -916,10 +914,10 @@ void SkeletonDocument::lockOtherComponents(dust3d::Uuid componentId)
     std::vector<dust3d::Uuid> partIds;
     collectComponentDescendantParts(componentId, partIds);
     std::set<dust3d::Uuid> partIdSet;
-    for (const auto &partId: partIds) {
+    for (const auto& partId : partIds) {
         partIdSet.insert(partId);
     }
-    for (const auto &part: partMap) {
+    for (const auto& part : partMap) {
         if (partIdSet.find(part.first) != partIdSet.end())
             continue;
         setPartLockState(part.first, true);
@@ -928,14 +926,14 @@ void SkeletonDocument::lockOtherComponents(dust3d::Uuid componentId)
 
 void SkeletonDocument::hideAllComponents()
 {
-    for (const auto &part: partMap) {
+    for (const auto& part : partMap) {
         setPartVisibleState(part.first, false);
     }
 }
 
 void SkeletonDocument::showAllComponents()
 {
-    for (const auto &part: partMap) {
+    for (const auto& part : partMap) {
         setPartVisibleState(part.first, true);
     }
 }
@@ -943,7 +941,7 @@ void SkeletonDocument::showAllComponents()
 void SkeletonDocument::showOrHideAllComponents()
 {
     bool foundVisiblePart = false;
-    for (const auto &part: partMap) {
+    for (const auto& part : partMap) {
         if (part.second.visible) {
             foundVisiblePart = true;
         }
@@ -956,7 +954,7 @@ void SkeletonDocument::showOrHideAllComponents()
 
 void SkeletonDocument::collapseAllComponents()
 {
-    for (const auto &component: componentMap) {
+    for (const auto& component : componentMap) {
         if (!component.second.linkToPartId.isNull())
             continue;
         setComponentExpandState(component.first, false);
@@ -965,7 +963,7 @@ void SkeletonDocument::collapseAllComponents()
 
 void SkeletonDocument::expandAllComponents()
 {
-    for (const auto &component: componentMap) {
+    for (const auto& component : componentMap) {
         if (!component.second.linkToPartId.isNull())
             continue;
         setComponentExpandState(component.first, true);
@@ -974,14 +972,14 @@ void SkeletonDocument::expandAllComponents()
 
 void SkeletonDocument::lockAllComponents()
 {
-    for (const auto &part: partMap) {
+    for (const auto& part : partMap) {
         setPartLockState(part.first, true);
     }
 }
 
 void SkeletonDocument::unlockAllComponents()
 {
-    for (const auto &part: partMap) {
+    for (const auto& part : partMap) {
         setPartLockState(part.first, false);
     }
 }
@@ -990,7 +988,7 @@ void SkeletonDocument::hideDescendantComponents(dust3d::Uuid componentId)
 {
     std::vector<dust3d::Uuid> partIds;
     collectComponentDescendantParts(componentId, partIds);
-    for (const auto &partId: partIds) {
+    for (const auto& partId : partIds) {
         setPartVisibleState(partId, false);
     }
 }
@@ -999,7 +997,7 @@ void SkeletonDocument::showDescendantComponents(dust3d::Uuid componentId)
 {
     std::vector<dust3d::Uuid> partIds;
     collectComponentDescendantParts(componentId, partIds);
-    for (const auto &partId: partIds) {
+    for (const auto& partId : partIds) {
         setPartVisibleState(partId, true);
     }
 }
@@ -1008,7 +1006,7 @@ void SkeletonDocument::lockDescendantComponents(dust3d::Uuid componentId)
 {
     std::vector<dust3d::Uuid> partIds;
     collectComponentDescendantParts(componentId, partIds);
-    for (const auto &partId: partIds) {
+    for (const auto& partId : partIds) {
         setPartLockState(partId, true);
     }
 }
@@ -1017,7 +1015,7 @@ void SkeletonDocument::unlockDescendantComponents(dust3d::Uuid componentId)
 {
     std::vector<dust3d::Uuid> partIds;
     collectComponentDescendantParts(componentId, partIds);
-    for (const auto &partId: partIds) {
+    for (const auto& partId : partIds) {
         setPartLockState(partId, false);
     }
 }
@@ -1042,7 +1040,7 @@ void SkeletonDocument::scaleNodeByAddRadius(dust3d::Uuid nodeId, float amount)
 
 bool SkeletonDocument::isPartReadonly(dust3d::Uuid partId) const
 {
-    const SkeletonPart *part = findPart(partId);
+    const SkeletonPart* part = findPart(partId);
     if (nullptr == part) {
         return true;
     }
@@ -1151,7 +1149,7 @@ void SkeletonDocument::switchNodeXZ(dust3d::Uuid nodeId)
     emit skeletonChanged();
 }
 
-const SkeletonComponent *SkeletonDocument::findComponent(dust3d::Uuid componentId) const
+const SkeletonComponent* SkeletonDocument::findComponent(dust3d::Uuid componentId) const
 {
     if (componentId.isNull())
         return &rootComponent;
@@ -1166,36 +1164,36 @@ void SkeletonDocument::addEdge(dust3d::Uuid fromNodeId, dust3d::Uuid toNodeId)
     if (findEdgeByNodes(fromNodeId, toNodeId)) {
         return;
     }
-    
+
-    const SkeletonNode *fromNode = nullptr;
+    const SkeletonNode* fromNode = nullptr;
-    const SkeletonNode *toNode = nullptr;
+    const SkeletonNode* toNode = nullptr;
     bool toPartRemoved = false;
-    
+
     fromNode = findNode(fromNodeId);
     if (nullptr == fromNode) {
         return;
     }
-    
+
     if (isPartReadonly(fromNode->partId))
         return;
-    
+
     toNode = findNode(toNodeId);
     if (nullptr == toNode) {
         return;
     }
-    
+
     if (isPartReadonly(toNode->partId))
         return;
-    
+
     dust3d::Uuid toPartId = toNode->partId;
-    
+
     auto fromPart = partMap.find(fromNode->partId);
     if (fromPart == partMap.end()) {
         return;
     }
-    
+
     fromPart->second.dirty = true;
-    
+
     if (fromNode->partId != toNode->partId) {
         toPartRemoved = true;
         std::vector<dust3d::Uuid> toGroup;
@@ -1217,7 +1215,7 @@ void SkeletonDocument::addEdge(dust3d::Uuid fromNodeId, dust3d::Uuid toNodeId)
             }
         }
     }
-    
+
     SkeletonEdge edge;
     edge.partId = fromNode->partId;
     edge.nodeIds.push_back(fromNode->id);
@@ -1226,34 +1224,34 @@ void SkeletonDocument::addEdge(dust3d::Uuid fromNodeId, dust3d::Uuid toNodeId)
 
     nodeMap[toNodeId].edgeIds.push_back(edge.id);
     nodeMap[fromNode->id].edgeIds.push_back(edge.id);
-    
+
     emit edgeAdded(edge.id);
-    
+
     if (toPartRemoved) {
         updateLinkedPart(toPartId, fromNode->partId);
         removePart(toPartId);
     }
-    
+
     emit skeletonChanged();
 }
 
 void SkeletonDocument::updateLinkedPart(dust3d::Uuid oldPartId, dust3d::Uuid newPartId)
 {
-    for (auto &partIt: partMap) {
+    for (auto& partIt : partMap) {
         if (partIt.second.cutFaceLinkedId == oldPartId) {
             partIt.second.dirty = true;
             partIt.second.setCutFaceLinkedId(newPartId);
         }
     }
     std::set<dust3d::Uuid> dirtyPartIds;
-    for (auto &nodeIt: nodeMap) {
+    for (auto& nodeIt : nodeMap) {
         if (nodeIt.second.cutFaceLinkedId == oldPartId) {
             dirtyPartIds.insert(nodeIt.second.partId);
             nodeIt.second.setCutFaceLinkedId(newPartId);
         }
     }
-    for (const auto &partId: dirtyPartIds) {
+    for (const auto& partId : dirtyPartIds) {
-        SkeletonPart *part = (SkeletonPart *)findPart(partId);
+        SkeletonPart* part = (SkeletonPart*)findPart(partId);
         if (nullptr == part)
             continue;
         part->dirty = true;
@@ -1272,17 +1270,17 @@ void SkeletonDocument::disableAllPositionRelatedLocks()
 
 void SkeletonDocument::resetDirtyFlags()
 {
-    for (auto &part: partMap) {
+    for (auto& part : partMap) {
         part.second.dirty = false;
     }
-    for (auto &component: componentMap) {
+    for (auto& component : componentMap) {
         component.second.dirty = false;
     }
 }
 
 void SkeletonDocument::markAllDirty()
 {
-    for (auto &part: partMap) {
+    for (auto& part : partMap) {
         part.second.dirty = true;
     }
 }
@@ -1319,27 +1317,27 @@ void SkeletonDocument::setRadiusLockState(bool locked)
     emit radiusLockStateChanged();
 }
 
-void SkeletonDocument::setComponentPreviewImage(const dust3d::Uuid &componentId, std::unique_ptr<QImage> image)
+void SkeletonDocument::setComponentPreviewImage(const dust3d::Uuid& componentId, std::unique_ptr<QImage> image)
 {
-    SkeletonComponent *component = (SkeletonComponent *)findComponent(componentId);
+    SkeletonComponent* component = (SkeletonComponent*)findComponent(componentId);
     if (nullptr == component)
         return;
     component->isPreviewImageDecorationObsolete = true;
     component->previewImage = std::move(image);
 }
 
-void SkeletonDocument::setComponentPreviewPixmap(const dust3d::Uuid &componentId, const QPixmap &pixmap)
+void SkeletonDocument::setComponentPreviewPixmap(const dust3d::Uuid& componentId, const QPixmap& pixmap)
 {
-    SkeletonComponent *component = (SkeletonComponent *)findComponent(componentId);
+    SkeletonComponent* component = (SkeletonComponent*)findComponent(componentId);
     if (nullptr == component)
         return;
     component->previewPixmap = pixmap;
     emit componentPreviewPixmapChanged(componentId);
 }
 
-void SkeletonDocument::setComponentPreviewMesh(const dust3d::Uuid &componentId, std::unique_ptr<ModelMesh> mesh)
+void SkeletonDocument::setComponentPreviewMesh(const dust3d::Uuid& componentId, std::unique_ptr<ModelMesh> mesh)
 {
-    SkeletonComponent *component = (SkeletonComponent *)findComponent(componentId);
+    SkeletonComponent* component = (SkeletonComponent*)findComponent(componentId);
     if (nullptr == component)
         return;
     component->updatePreviewMesh(std::move(mesh));

application/sources/skeleton_document.h

@@ -1,35 +1,34 @@
 #ifndef DUST3D_APPLICATION_SKELETON_DOCUMENT_H_
 #define DUST3D_APPLICATION_SKELETON_DOCUMENT_H_
 
-#include <QObject>
-#include <QString>
-#include <cmath>
-#include <QImage>
-#include <QByteArray>
-#include <QDebug>
-#include <QVector3D>
-#include <QPixmap>
-#include <dust3d/base/uuid.h>
-#include <dust3d/base/cut_face.h>
-#include <dust3d/base/part_target.h>
-#include <dust3d/base/part_base.h>
-#include <dust3d/base/combine_mode.h>
-#include "theme.h"
-#include "model_mesh.h"
 #include "debug.h"
 #include "mesh_generator.h"
+#include "model_mesh.h"
+#include "theme.h"
+#include <QByteArray>
+#include <QDebug>
+#include <QImage>
+#include <QObject>
+#include <QPixmap>
+#include <QString>
+#include <QVector3D>
+#include <cmath>
+#include <dust3d/base/combine_mode.h>
+#include <dust3d/base/cut_face.h>
+#include <dust3d/base/part_base.h>
+#include <dust3d/base/part_target.h>
+#include <dust3d/base/uuid.h>
 
-class SkeletonNode
+class SkeletonNode {
-{
 public:
-    SkeletonNode(const dust3d::Uuid &withId=dust3d::Uuid()) :
+    SkeletonNode(const dust3d::Uuid& withId = dust3d::Uuid())
-        radius(0),
+        : radius(0)
-        cutRotation(0.0),
+        , cutRotation(0.0)
-        cutFace(dust3d::CutFace::Quad),
+        , cutFace(dust3d::CutFace::Quad)
-        hasCutFaceSettings(false),
+        , hasCutFaceSettings(false)
-        m_x(0),
+        , m_x(0)
-        m_y(0),
+        , m_y(0)
-        m_z(0)
+        , m_z(0)
     {
         id = withId.isNull() ? dust3d::Uuid::createUuid() : withId;
     }
@@ -56,7 +55,7 @@ public:
         cutFaceLinkedId = dust3d::Uuid();
         hasCutFaceSettings = true;
     }
-    void setCutFaceLinkedId(const dust3d::Uuid &linkedId)
+    void setCutFaceLinkedId(const dust3d::Uuid& linkedId)
     {
         if (linkedId.isNull()) {
             clearCutFaceSettings();
@@ -73,21 +72,21 @@ public:
         cutRotation = 0;
         hasCutFaceSettings = false;
     }
-    float getX(bool rotated=false) const
+    float getX(bool rotated = false) const
     {
         if (rotated)
             return m_y;
         return m_x;
     }
-    float getY(bool rotated=false) const
+    float getY(bool rotated = false) const
     {
         if (rotated)
             return m_x;
         return m_y;
     }
-    float getZ(bool rotated=false) const
+    float getZ(bool rotated = false) const
     {
-        (void) rotated;
+        (void)rotated;
         return m_z;
     }
     void setX(float x)
@@ -123,16 +122,16 @@ public:
     dust3d::Uuid cutFaceLinkedId;
     bool hasCutFaceSettings;
     std::vector<dust3d::Uuid> edgeIds;
+
 private:
     float m_x;
     float m_y;
     float m_z;
 };
 
-class SkeletonEdge
+class SkeletonEdge {
-{
 public:
-    SkeletonEdge(const dust3d::Uuid &withId=dust3d::Uuid())
+    SkeletonEdge(const dust3d::Uuid& withId = dust3d::Uuid())
     {
         id = withId.isNull() ? dust3d::Uuid::createUuid() : withId;
     }
@@ -148,8 +147,7 @@ public:
     }
 };
 
-class SkeletonPart
+class SkeletonPart {
-{
 public:
     dust3d::Uuid id;
     QString name;
@@ -180,30 +178,30 @@ public:
     float hollowThickness;
     bool countershaded;
     bool smooth;
-    SkeletonPart(const dust3d::Uuid &withId=dust3d::Uuid()) :
+    SkeletonPart(const dust3d::Uuid& withId = dust3d::Uuid())
-        visible(true),
+        : visible(true)
-        locked(false),
+        , locked(false)
-        subdived(false),
+        , subdived(false)
-        disabled(false),
+        , disabled(false)
-        xMirrored(false),
+        , xMirrored(false)
-        base(dust3d::PartBase::Average),
+        , base(dust3d::PartBase::Average)
-        deformThickness(1.0),
+        , deformThickness(1.0)
-        deformWidth(1.0),
+        , deformWidth(1.0)
-        deformUnified(false),
+        , deformUnified(false)
-        rounded(false),
+        , rounded(false)
-        chamfered(false),
+        , chamfered(false)
-        color(Qt::white),
+        , color(Qt::white)
-        hasColor(false),
+        , hasColor(false)
-        dirty(true),
+        , dirty(true)
-        cutRotation(0.0),
+        , cutRotation(0.0)
-        cutFace(dust3d::CutFace::Quad),
+        , cutFace(dust3d::CutFace::Quad)
-        target(dust3d::PartTarget::Model),
+        , target(dust3d::PartTarget::Model)
-        colorSolubility(0.0),
+        , colorSolubility(0.0)
-        metalness(0.0),
+        , metalness(0.0)
-        roughness(1.0),
+        , roughness(1.0)
-        hollowThickness(0.0),
+        , hollowThickness(0.0)
-        countershaded(false),
+        , countershaded(false)
-        smooth(false)
+        , smooth(false)
     {
         id = withId.isNull() ? dust3d::Uuid::createUuid() : withId;
     }
@@ -296,7 +294,7 @@ public:
         cutFace = face;
         cutFaceLinkedId = dust3d::Uuid();
     }
-    void setCutFaceLinkedId(const dust3d::Uuid &linkedId)
+    void setCutFaceLinkedId(const dust3d::Uuid& linkedId)
     {
         if (linkedId.isNull()) {
             setCutFace(dust3d::CutFace::Quad);
@@ -353,7 +351,7 @@ public:
     {
         return visible && !disabled;
     }
-    void copyAttributes(const SkeletonPart &other)
+    void copyAttributes(const SkeletonPart& other)
     {
         visible = other.visible;
         locked = other.locked;
@@ -382,12 +380,12 @@ public:
         smooth = other.smooth;
         hollowThickness = other.hollowThickness;
     }
+
 private:
     Q_DISABLE_COPY(SkeletonPart);
 };
 
-enum class SkeletonDocumentEditMode
+enum class SkeletonDocumentEditMode {
-{
     Add = 0,
     Select,
     Paint,
@@ -396,20 +394,18 @@ enum class SkeletonDocumentEditMode
     ZoomOut
 };
 
-enum class SkeletonProfile
+enum class SkeletonProfile {
-{
     Unknown = 0,
     Main,
     Side
 };
 
-class SkeletonComponent
+class SkeletonComponent {
-{
 public:
     SkeletonComponent()
     {
     }
-    SkeletonComponent(const dust3d::Uuid &withId, const QString &linkData=QString(), const QString &linkDataType=QString())
+    SkeletonComponent(const dust3d::Uuid& withId, const QString& linkData = QString(), const QString& linkDataType = QString())
     {
         id = withId.isNull() ? dust3d::Uuid::createUuid() : withId;
         if (!linkData.isEmpty()) {
@@ -445,13 +441,13 @@ public:
         m_childrenIdSet.insert(childId);
         childrenIds.push_back(childId);
     }
-    void replaceChildWithOthers(const dust3d::Uuid &childId, const std::vector<dust3d::Uuid> &others)
+    void replaceChildWithOthers(const dust3d::Uuid& childId, const std::vector<dust3d::Uuid>& others)
     {
         if (m_childrenIdSet.find(childId) == m_childrenIdSet.end())
             return;
         m_childrenIdSet.erase(childId);
         std::vector<dust3d::Uuid> candidates;
-        for (const auto &it: others) {
+        for (const auto& it : others) {
             if (m_childrenIdSet.find(it) == m_childrenIdSet.end()) {
                 m_childrenIdSet.insert(it);
                 candidates.emplace_back(it);
@@ -500,7 +496,7 @@ public:
         if (it == childrenIds.end()) {
             return;
         }
-        
+
         auto index = std::distance(childrenIds.begin(), it);
         if (index == 0)
             return;
@@ -512,7 +508,7 @@ public:
         if (it == childrenIds.end()) {
             return;
         }
-        
+
         auto index = std::distance(childrenIds.begin(), it);
         if (index == (int)childrenIds.size() - 1)
             return;
@@ -524,7 +520,7 @@ public:
         if (it == childrenIds.end()) {
             return;
         }
-        
+
         auto index = std::distance(childrenIds.begin(), it);
         if (index == 0)
             return;
@@ -537,7 +533,7 @@ public:
         if (it == childrenIds.end()) {
             return;
         }
-        
+
         auto index = std::distance(childrenIds.begin(), it);
         if (index == (int)childrenIds.size() - 1)
             return;
@@ -549,19 +545,19 @@ public:
         m_previewMesh = std::move(mesh);
         isPreviewMeshObsolete = true;
     }
-    ModelMesh *takePreviewMesh() const
+    ModelMesh* takePreviewMesh() const
     {
         if (nullptr == m_previewMesh)
             return nullptr;
         return new ModelMesh(*m_previewMesh);
     }
+
 private:
     std::unique_ptr<ModelMesh> m_previewMesh;
     std::set<dust3d::Uuid> m_childrenIdSet;
 };
 
-class SkeletonDocument : public QObject
+class SkeletonDocument : public QObject {
-{
     Q_OBJECT
 signals:
     void partAdded(dust3d::Uuid partId);
@@ -576,8 +572,8 @@ signals:
     void componentRemoved(dust3d::Uuid componentId);
     void componentAdded(dust3d::Uuid componentId);
     void componentExpandStateChanged(dust3d::Uuid componentId);
-    void componentPreviewMeshChanged(const dust3d::Uuid &componentId);
+    void componentPreviewMeshChanged(const dust3d::Uuid& componentId);
-    void componentPreviewPixmapChanged(const dust3d::Uuid &componentId);
+    void componentPreviewPixmapChanged(const dust3d::Uuid& componentId);
     void nodeRemoved(dust3d::Uuid nodeId);
     void edgeRemoved(dust3d::Uuid edgeId);
     void nodeRadiusChanged(dust3d::Uuid nodeId);
@@ -590,6 +586,7 @@ signals:
     void ylockStateChanged();
     void zlockStateChanged();
     void radiusLockStateChanged();
+
 public:
     SkeletonDocumentEditMode editMode = SkeletonDocumentEditMode::Select;
     bool xlocked = false;
@@ -604,22 +601,22 @@ public:
     std::map<dust3d::Uuid, SkeletonComponent> componentMap;
     SkeletonComponent rootComponent;
 
-    const SkeletonNode *findNode(dust3d::Uuid nodeId) const;
+    const SkeletonNode* findNode(dust3d::Uuid nodeId) const;
-    const SkeletonEdge *findEdge(dust3d::Uuid edgeId) const;
+    const SkeletonEdge* findEdge(dust3d::Uuid edgeId) const;
-    const SkeletonPart *findPart(dust3d::Uuid partId) const;
+    const SkeletonPart* findPart(dust3d::Uuid partId) const;
-    const SkeletonEdge *findEdgeByNodes(dust3d::Uuid firstNodeId, dust3d::Uuid secondNodeId) const;
+    const SkeletonEdge* findEdgeByNodes(dust3d::Uuid firstNodeId, dust3d::Uuid secondNodeId) const;
-    void findAllNeighbors(dust3d::Uuid nodeId, std::set<dust3d::Uuid> &neighbors) const;
+    void findAllNeighbors(dust3d::Uuid nodeId, std::set<dust3d::Uuid>& neighbors) const;
     bool isNodeConnectable(dust3d::Uuid nodeId) const;
-    const SkeletonComponent *findComponent(dust3d::Uuid componentId) const;
+    const SkeletonComponent* findComponent(dust3d::Uuid componentId) const;
-    const SkeletonComponent *findComponentParent(dust3d::Uuid componentId) const;
+    const SkeletonComponent* findComponentParent(dust3d::Uuid componentId) const;
     dust3d::Uuid findComponentParentId(dust3d::Uuid componentId) const;
-    void collectComponentDescendantParts(dust3d::Uuid componentId, std::vector<dust3d::Uuid> &partIds) const;
+    void collectComponentDescendantParts(dust3d::Uuid componentId, std::vector<dust3d::Uuid>& partIds) const;
-    void collectComponentDescendantComponents(dust3d::Uuid componentId, std::vector<dust3d::Uuid> &componentIds) const;
+    void collectComponentDescendantComponents(dust3d::Uuid componentId, std::vector<dust3d::Uuid>& componentIds) const;
-    void setComponentPreviewMesh(const dust3d::Uuid &componentId, std::unique_ptr<ModelMesh> mesh);
+    void setComponentPreviewMesh(const dust3d::Uuid& componentId, std::unique_ptr<ModelMesh> mesh);
-    void setComponentPreviewImage(const dust3d::Uuid &componentId, std::unique_ptr<QImage> image);
+    void setComponentPreviewImage(const dust3d::Uuid& componentId, std::unique_ptr<QImage> image);
     void resetDirtyFlags();
     void markAllDirty();
-    
+
     virtual bool undoable() const = 0;
     virtual bool redoable() const = 0;
     virtual bool hasPastableNodesInClipboard() const = 0;
@@ -628,31 +625,31 @@ public:
     virtual bool isEdgeEditable(dust3d::Uuid edgeId) const = 0;
     virtual bool isNodeDeactivated(dust3d::Uuid nodeId) const
     {
-        (void) nodeId;
+        (void)nodeId;
         return false;
     };
     virtual bool isEdgeDeactivated(dust3d::Uuid edgeId) const
     {
-        (void) edgeId;
+        (void)edgeId;
         return false;
     };
     virtual void copyNodes(std::set<dust3d::Uuid> nodeIdSet) const = 0;
-    
+
-    float getOriginX(bool rotated=false) const
+    float getOriginX(bool rotated = false) const
     {
         if (rotated)
             return m_originY;
         return m_originX;
     }
-    float getOriginY(bool rotated=false) const
+    float getOriginY(bool rotated = false) const
     {
         if (rotated)
             return m_originX;
         return m_originY;
     }
-    float getOriginZ(bool rotated=false) const
+    float getOriginZ(bool rotated = false) const
     {
-        (void) rotated;
+        (void)rotated;
         return m_originZ;
     }
     void setOriginX(float originX)
@@ -679,7 +676,7 @@ public:
     {
         m_originZ += originZ;
     }
-    
+
 public slots:
     virtual void undo() = 0;
     virtual void redo() = 0;
@@ -706,8 +703,8 @@ public slots:
     void addComponent(dust3d::Uuid parentId);
     void moveComponent(dust3d::Uuid componentId, dust3d::Uuid toParentId);
     void setCurrentCanvasComponentId(dust3d::Uuid componentId);
-    void groupComponents(const std::vector<dust3d::Uuid> &componentIds);
+    void groupComponents(const std::vector<dust3d::Uuid>& componentIds);
-    void ungroupComponent(const dust3d::Uuid &componentId);
+    void ungroupComponent(const dust3d::Uuid& componentId);
     void createNewChildComponent(dust3d::Uuid parentComponentId);
     void setComponentExpandState(dust3d::Uuid componentId, bool expanded);
     void hideOtherComponents(dust3d::Uuid componentId);
@@ -723,7 +720,7 @@ public slots:
     void showDescendantComponents(dust3d::Uuid componentId);
     void lockDescendantComponents(dust3d::Uuid componentId);
     void unlockDescendantComponents(dust3d::Uuid componentId);
-    void setComponentPreviewPixmap(const dust3d::Uuid &componentId, const QPixmap &pixmap);
+    void setComponentPreviewPixmap(const dust3d::Uuid& componentId, const QPixmap& pixmap);
     void setPartLockState(dust3d::Uuid partId, bool locked);
     void setPartVisibleState(dust3d::Uuid partId, bool visible);
     void setPartDisableState(dust3d::Uuid partId, bool disabled);
@@ -737,18 +734,18 @@ public slots:
     void setYlockState(bool locked);
     void setZlockState(bool locked);
     void setRadiusLockState(bool locked);
-    
+
 private:
     float m_originX = 0;
     float m_originY = 0;
     float m_originZ = 0;
-    
+
     dust3d::Uuid m_currentCanvasComponentId;
     bool m_allPositionRelatedLocksEnabled = true;
-    
+
-    void splitPartByNode(std::vector<std::vector<dust3d::Uuid>> *groups, dust3d::Uuid nodeId);
+    void splitPartByNode(std::vector<std::vector<dust3d::Uuid>>* groups, dust3d::Uuid nodeId);
-    void joinNodeAndNeiborsToGroup(std::vector<dust3d::Uuid> *group, dust3d::Uuid nodeId, std::set<dust3d::Uuid> *visitMap, dust3d::Uuid noUseEdgeId=dust3d::Uuid());
+    void joinNodeAndNeiborsToGroup(std::vector<dust3d::Uuid>* group, dust3d::Uuid nodeId, std::set<dust3d::Uuid>* visitMap, dust3d::Uuid noUseEdgeId = dust3d::Uuid());
-    void splitPartByEdge(std::vector<std::vector<dust3d::Uuid>> *groups, dust3d::Uuid edgeId);
+    void splitPartByEdge(std::vector<std::vector<dust3d::Uuid>>* groups, dust3d::Uuid edgeId);
     void removePartDontCareComponent(dust3d::Uuid partId);
     void addPartToComponent(dust3d::Uuid partId, dust3d::Uuid componentId);
     bool isDescendantComponent(dust3d::Uuid componentId, dust3d::Uuid suspiciousId);

application/sources/skeleton_graphics_widget.h

@@ -1,32 +1,31 @@
 #ifndef DUST3D_APPLICATION_SKELETON_GRAPHICS_VIEW_H_
 #define DUST3D_APPLICATION_SKELETON_GRAPHICS_VIEW_H_
 
-#include <map>
+#include "model_widget.h"
-#include <QMouseEvent>
+#include "skeleton_document.h"
-#include <QKeyEvent>
+#include "skeleton_ik_mover.h"
+#include "theme.h"
+#include "turnaround_loader.h"
 #include <QGraphicsEllipseItem>
 #include <QGraphicsLineItem>
-#include <QGraphicsView>
 #include <QGraphicsPixmapItem>
 #include <QGraphicsPolygonItem>
+#include <QGraphicsView>
+#include <QKeyEvent>
+#include <QMouseEvent>
 #include <QThread>
-#include <cmath>
-#include <set>
 #include <QTimer>
-#include "skeleton_document.h"
+#include <cmath>
-#include "turnaround_loader.h"
+#include <map>
-#include "theme.h"
+#include <set>
-#include "skeleton_ik_mover.h"
-#include "model_widget.h"
 
-class SkeletonGraphicsOriginItem : public QGraphicsPolygonItem
+class SkeletonGraphicsOriginItem : public QGraphicsPolygonItem {
-{
 public:
-    SkeletonGraphicsOriginItem(SkeletonProfile profile=SkeletonProfile::Unknown) :
+    SkeletonGraphicsOriginItem(SkeletonProfile profile = SkeletonProfile::Unknown)
-        m_profile(profile),
+        : m_profile(profile)
-        m_hovered(false),
+        , m_hovered(false)
-        m_checked(false),
+        , m_checked(false)
-        m_rotated(false)
+        , m_rotated(false)
     {
         setData(0, "origin");
     }
@@ -37,9 +36,8 @@ public:
     void updateAppearance()
     {
         QColor color = Theme::white;
-        
+
-        switch (m_profile)
+        switch (m_profile) {
-        {
         case SkeletonProfile::Unknown:
             break;
         case SkeletonProfile::Main:
@@ -49,13 +47,13 @@ public:
             color = Theme::green;
             break;
         }
-        
+
         QColor penColor = color;
         penColor.setAlphaF(m_checked ? Theme::checkedAlpha : Theme::normalAlpha);
         QPen pen(penColor);
         pen.setWidth(0);
         setPen(pen);
-        
+
         QColor brushColor = color;
         brushColor.setAlphaF((m_checked || m_hovered) ? Theme::checkedAlpha : Theme::normalAlpha);
         QBrush brush(brushColor);
@@ -99,6 +97,7 @@ public:
     {
         return m_hovered;
     }
+
 private:
     SkeletonProfile m_profile;
     bool m_hovered;
@@ -107,8 +106,7 @@ private:
     bool m_rotated;
 };
 
-class SkeletonGraphicsSelectionItem : public QGraphicsRectItem
+class SkeletonGraphicsSelectionItem : public QGraphicsRectItem {
-{
 public:
     SkeletonGraphicsSelectionItem()
     {
@@ -124,16 +122,15 @@ public:
     }
 };
 
-class SkeletonGraphicsNodeItem : public QGraphicsEllipseItem
+class SkeletonGraphicsNodeItem : public QGraphicsEllipseItem {
-{
 public:
-    SkeletonGraphicsNodeItem(SkeletonProfile profile=SkeletonProfile::Unknown) :
+    SkeletonGraphicsNodeItem(SkeletonProfile profile = SkeletonProfile::Unknown)
-        m_profile(profile),
+        : m_profile(profile)
-        m_hovered(false),
+        , m_hovered(false)
-        m_checked(false),
+        , m_checked(false)
-        m_markColor(Qt::transparent),
+        , m_markColor(Qt::transparent)
-        m_deactivated(false),
+        , m_deactivated(false)
-        m_rotated(false)
+        , m_rotated(false)
     {
         setData(0, "node");
         setRadius(32);
@@ -145,10 +142,9 @@ public:
     void updateAppearance()
     {
         QColor color = Qt::gray;
-        
+
         if (!m_deactivated) {
-            switch (m_profile)
+            switch (m_profile) {
-            {
             case SkeletonProfile::Unknown:
                 break;
             case SkeletonProfile::Main:
@@ -159,13 +155,13 @@ public:
                 break;
             }
         }
-        
+
         QColor penColor = color;
         penColor.setAlphaF((m_checked || m_hovered) ? Theme::checkedAlpha : Theme::normalAlpha);
         QPen pen(penColor);
         pen.setWidth(0);
         setPen(pen);
-        
+
         QColor brushColor;
         Qt::BrushStyle style;
         if (m_markColor == Qt::transparent) {
@@ -253,6 +249,7 @@ public:
     {
         return m_hovered;
     }
+
 private:
     dust3d::Uuid m_uuid;
     SkeletonProfile m_profile;
@@ -263,17 +260,16 @@ private:
     bool m_rotated;
 };
 
-class SkeletonGraphicsEdgeItem : public QGraphicsPolygonItem
+class SkeletonGraphicsEdgeItem : public QGraphicsPolygonItem {
-{
 public:
-    SkeletonGraphicsEdgeItem() :
+    SkeletonGraphicsEdgeItem()
-        m_firstItem(nullptr),
+        : m_firstItem(nullptr)
-        m_secondItem(nullptr),
+        , m_secondItem(nullptr)
-        m_hovered(false),
+        , m_hovered(false)
-        m_checked(false),
+        , m_checked(false)
-        m_profile(SkeletonProfile::Unknown),
+        , m_profile(SkeletonProfile::Unknown)
-        m_deactivated(false),
+        , m_deactivated(false)
-        m_rotated(false)
+        , m_rotated(false)
     {
         setData(0, "edge");
     }
@@ -281,17 +277,17 @@ public:
     {
         m_rotated = rotated;
     }
-    void setEndpoints(SkeletonGraphicsNodeItem *first, SkeletonGraphicsNodeItem *second)
+    void setEndpoints(SkeletonGraphicsNodeItem* first, SkeletonGraphicsNodeItem* second)
     {
         m_firstItem = first;
         m_secondItem = second;
         updateAppearance();
     }
-    SkeletonGraphicsNodeItem *firstItem()
+    SkeletonGraphicsNodeItem* firstItem()
     {
         return m_firstItem;
     }
-    SkeletonGraphicsNodeItem *secondItem()
+    SkeletonGraphicsNodeItem* secondItem()
     {
         return m_secondItem;
     }
@@ -299,11 +295,11 @@ public:
     {
         if (nullptr == m_firstItem || nullptr == m_secondItem)
             return;
-        
+
         m_profile = m_firstItem->profile();
-        
+
         QLineF line(m_firstItem->origin(), m_secondItem->origin());
-        
+
         QPolygonF polygon;
         float radAngle = line.angle() * M_PI / 180;
         float dx = 2 * sin(radAngle);
@@ -313,12 +309,11 @@ public:
         //polygon << line.p1() + offset1 << line.p1() + offset2 << line.p2() + offset2 << line.p2() + offset1;
         polygon << line.p1() + offset1 << line.p1() + offset2 << line.p2();
         setPolygon(polygon);
-        
+
         QColor color = Qt::gray;
-        
+
         if (!m_deactivated) {
-            switch (m_firstItem->profile())
+            switch (m_firstItem->profile()) {
-            {
             case SkeletonProfile::Unknown:
                 break;
             case SkeletonProfile::Main:
@@ -329,7 +324,7 @@ public:
                 break;
             }
         }
-        
+
         QColor penColor = color;
         penColor.setAlphaF((m_checked || m_hovered) ? Theme::checkedAlpha : Theme::normalAlpha);
         QPen pen(penColor);
@@ -380,10 +375,11 @@ public:
     {
         return m_hovered;
     }
+
 private:
     dust3d::Uuid m_uuid;
-    SkeletonGraphicsNodeItem *m_firstItem;
+    SkeletonGraphicsNodeItem* m_firstItem;
-    SkeletonGraphicsNodeItem *m_secondItem;
+    SkeletonGraphicsNodeItem* m_secondItem;
     QPolygonF m_selectionPolygon;
     bool m_hovered;
     bool m_checked;
@@ -392,8 +388,7 @@ private:
     bool m_rotated;
 };
 
-class SkeletonGraphicsWidget : public QGraphicsView
+class SkeletonGraphicsWidget : public QGraphicsView {
-{
     Q_OBJECT
 public:
     ~SkeletonGraphicsWidget();
@@ -445,43 +440,45 @@ signals:
     void shortcutToggleFlatShading();
     void shortcutToggleRotation();
     void loadedTurnaroundImageChanged();
+
 public:
-    SkeletonGraphicsWidget(const SkeletonDocument *document);
+    SkeletonGraphicsWidget(const SkeletonDocument* document);
-    std::map<dust3d::Uuid, std::pair<SkeletonGraphicsNodeItem *, SkeletonGraphicsNodeItem *>> nodeItemMap;
+    std::map<dust3d::Uuid, std::pair<SkeletonGraphicsNodeItem*, SkeletonGraphicsNodeItem*>> nodeItemMap;
-    std::map<dust3d::Uuid, std::pair<SkeletonGraphicsEdgeItem *, SkeletonGraphicsEdgeItem *>> edgeItemMap;
+    std::map<dust3d::Uuid, std::pair<SkeletonGraphicsEdgeItem*, SkeletonGraphicsEdgeItem*>> edgeItemMap;
-    bool mouseMove(QMouseEvent *event);
+    bool mouseMove(QMouseEvent* event);
-    bool wheel(QWheelEvent *event);
+    bool wheel(QWheelEvent* event);
-    bool mouseRelease(QMouseEvent *event);
+    bool mouseRelease(QMouseEvent* event);
-    bool mousePress(QMouseEvent *event);
+    bool mousePress(QMouseEvent* event);
-    bool mouseDoubleClick(QMouseEvent *event);
+    bool mouseDoubleClick(QMouseEvent* event);
-    bool keyPress(QKeyEvent *event);
+    bool keyPress(QKeyEvent* event);
-    bool keyRelease(QKeyEvent *event);
+    bool keyRelease(QKeyEvent* event);
-    bool checkSkeletonItem(QGraphicsItem *item, bool checked);
+    bool checkSkeletonItem(QGraphicsItem* item, bool checked);
-    dust3d::Uuid querySkeletonItemPartId(QGraphicsItem *item);
+    dust3d::Uuid querySkeletonItemPartId(QGraphicsItem* item);
-    static SkeletonProfile readSkeletonItemProfile(QGraphicsItem *item);
+    static SkeletonProfile readSkeletonItemProfile(QGraphicsItem* item);
-    void getOtherProfileNodeItems(const std::set<SkeletonGraphicsNodeItem *> &nodeItemSet,
+    void getOtherProfileNodeItems(const std::set<SkeletonGraphicsNodeItem*>& nodeItemSet,
-        std::set<SkeletonGraphicsNodeItem *> *otherProfileNodeItemSet);
+        std::set<SkeletonGraphicsNodeItem*>* otherProfileNodeItemSet);
-    void readMergedSkeletonNodeSetFromRangeSelection(std::set<SkeletonGraphicsNodeItem *> *nodeItemSet);
+    void readMergedSkeletonNodeSetFromRangeSelection(std::set<SkeletonGraphicsNodeItem*>* nodeItemSet);
-    void readSkeletonNodeAndEdgeIdSetFromRangeSelection(std::set<dust3d::Uuid> *nodeIdSet, std::set<dust3d::Uuid> *edgeIdSet=nullptr);
+    void readSkeletonNodeAndEdgeIdSetFromRangeSelection(std::set<dust3d::Uuid>* nodeIdSet, std::set<dust3d::Uuid>* edgeIdSet = nullptr);
-    bool readSkeletonNodeAndAnyEdgeOfNodeFromRangeSelection(SkeletonGraphicsNodeItem **nodeItem, SkeletonGraphicsEdgeItem **edgeItem);
+    bool readSkeletonNodeAndAnyEdgeOfNodeFromRangeSelection(SkeletonGraphicsNodeItem** nodeItem, SkeletonGraphicsEdgeItem** edgeItem);
     bool hasSelection();
     bool hasItems();
     bool hasMultipleSelection();
     bool hasEdgeSelection();
     bool hasNodeSelection();
     bool hasTwoDisconnectedNodesSelection();
-    void setModelWidget(ModelWidget *modelWidget);
+    void setModelWidget(ModelWidget* modelWidget);
-    bool inputWheelEventFromOtherWidget(QWheelEvent *event);
+    bool inputWheelEventFromOtherWidget(QWheelEvent* event);
     bool rotated();
-    const QImage *loadedTurnaroundImage() const;
+    const QImage* loadedTurnaroundImage() const;
+
 protected:
-    void mouseMoveEvent(QMouseEvent *event) override;
+    void mouseMoveEvent(QMouseEvent* event) override;
-    void wheelEvent(QWheelEvent *event) override;
+    void wheelEvent(QWheelEvent* event) override;
-    void mouseReleaseEvent(QMouseEvent *event) override;
+    void mouseReleaseEvent(QMouseEvent* event) override;
-    void mousePressEvent(QMouseEvent *event) override;
+    void mousePressEvent(QMouseEvent* event) override;
-    void mouseDoubleClickEvent(QMouseEvent *event) override;
+    void mouseDoubleClickEvent(QMouseEvent* event) override;
-    void keyPressEvent(QKeyEvent *event) override;
+    void keyPressEvent(QKeyEvent* event) override;
-    void keyReleaseEvent(QKeyEvent *event) override;
+    void keyReleaseEvent(QKeyEvent* event) override;
 public slots:
     void nodeAdded(dust3d::Uuid nodeId);
     void edgeAdded(dust3d::Uuid edgeId);
@@ -495,7 +492,7 @@ public slots:
     void editModeChanged();
     void updateCursor();
     void partVisibleStateChanged(dust3d::Uuid partId);
-    void showContextMenu(const QPoint &pos);
+    void showContextMenu(const QPoint& pos);
     void deleteSelected();
     void selectAll();
     void unselectAll();
@@ -577,8 +574,9 @@ public slots:
     void shortcutEscape();
 private slots:
     void turnaroundImageReady();
+
 private:
-    QPointF mouseEventScenePos(QMouseEvent *event);
+    QPointF mouseEventScenePos(QMouseEvent* event);
     QPointF scenePosToUnified(QPointF pos);
     QPointF scenePosFromUnified(QPointF pos);
     float sceneRadiusToUnified(float radius);
@@ -587,56 +585,57 @@ private:
     void updateItems();
     void checkRangeSelection();
     void clearRangeSelection();
-    void removeItem(QGraphicsItem *item);
+    void removeItem(QGraphicsItem* item);
-    QVector2D centerOfNodeItemSet(const std::set<SkeletonGraphicsNodeItem *> &set);
+    QVector2D centerOfNodeItemSet(const std::set<SkeletonGraphicsNodeItem*>& set);
     bool isSingleNodeSelected();
-    void addItemToRangeSelection(QGraphicsItem *item);
+    void addItemToRangeSelection(QGraphicsItem* item);
-    void removeItemFromRangeSelection(QGraphicsItem *item);
+    void removeItemFromRangeSelection(QGraphicsItem* item);
     void hoverPart(dust3d::Uuid partId);
     void switchProfileOnRangeSelection();
-    void setItemHoveredOnAllProfiles(QGraphicsItem *item, bool hovered);
+    void setItemHoveredOnAllProfiles(QGraphicsItem* item, bool hovered);
     void alignSelectedToGlobal(bool alignToVerticalCenter, bool alignToHorizontalCenter);
     void alignSelectedToLocal(bool alignToVerticalCenter, bool alignToHorizontalCenter);
-    void rotateItems(const std::set<SkeletonGraphicsNodeItem *> &nodeItems, int degree, QVector2D center);
+    void rotateItems(const std::set<SkeletonGraphicsNodeItem*>& nodeItems, int degree, QVector2D center);
     void rotateAllSideProfile(int degree);
     bool isFloatEqual(float a, float b);
+
 private:
-    const SkeletonDocument *m_document = nullptr;
+    const SkeletonDocument* m_document = nullptr;
-    QGraphicsPixmapItem *m_backgroundItem = nullptr;
+    QGraphicsPixmapItem* m_backgroundItem = nullptr;
     bool m_turnaroundChanged = false;
-    TurnaroundLoader *m_turnaroundLoader = nullptr;
+    TurnaroundLoader* m_turnaroundLoader = nullptr;
     bool m_dragStarted = false;
     bool m_moveStarted = false;
-    SkeletonGraphicsNodeItem *m_cursorNodeItem = nullptr;
+    SkeletonGraphicsNodeItem* m_cursorNodeItem = nullptr;
-    SkeletonGraphicsEdgeItem *m_cursorEdgeItem = nullptr;
+    SkeletonGraphicsEdgeItem* m_cursorEdgeItem = nullptr;
-    SkeletonGraphicsNodeItem *m_addFromNodeItem = nullptr;
+    SkeletonGraphicsNodeItem* m_addFromNodeItem = nullptr;
-    SkeletonGraphicsNodeItem *m_hoveredNodeItem = nullptr;
+    SkeletonGraphicsNodeItem* m_hoveredNodeItem = nullptr;
-    SkeletonGraphicsEdgeItem *m_hoveredEdgeItem = nullptr;
+    SkeletonGraphicsEdgeItem* m_hoveredEdgeItem = nullptr;
     float m_lastAddedX = false;
     float m_lastAddedY = false;
     float m_lastAddedZ = false;
-    SkeletonGraphicsSelectionItem *m_selectionItem = nullptr;
+    SkeletonGraphicsSelectionItem* m_selectionItem = nullptr;
     bool m_rangeSelectionStarted = false;
     bool m_mouseEventFromSelf = false;
     bool m_moveHappened = false;
     int m_lastRot = 0;
-    SkeletonGraphicsOriginItem *m_mainOriginItem = nullptr;
+    SkeletonGraphicsOriginItem* m_mainOriginItem = nullptr;
-    SkeletonGraphicsOriginItem *m_sideOriginItem = nullptr;
+    SkeletonGraphicsOriginItem* m_sideOriginItem = nullptr;
-    SkeletonGraphicsOriginItem *m_hoveredOriginItem = nullptr;
+    SkeletonGraphicsOriginItem* m_hoveredOriginItem = nullptr;
-    SkeletonGraphicsOriginItem *m_checkedOriginItem = nullptr;
+    SkeletonGraphicsOriginItem* m_checkedOriginItem = nullptr;
     unsigned long long m_ikMoveUpdateVersion = 0;
-    SkeletonIkMover *m_ikMover = nullptr;
+    SkeletonIkMover* m_ikMover = nullptr;
-    QTimer *m_deferredRemoveTimer = nullptr;
+    QTimer* m_deferredRemoveTimer = nullptr;
     bool m_eventForwardingToModelWidget = false;
-    ModelWidget *m_modelWidget = nullptr;
+    ModelWidget* m_modelWidget = nullptr;
     bool m_inTempDragMode = false;
     SkeletonDocumentEditMode m_modeBeforeEnterTempDragMode = SkeletonDocumentEditMode::Select;
     float m_turnaroundOpacity = 0.25f;
     bool m_rotated = false;
-    QImage *m_backgroundImage = nullptr;
+    QImage* m_backgroundImage = nullptr;
     QVector3D m_ikMoveTarget;
     dust3d::Uuid m_ikMoveEndEffectorId;
-    std::set<QGraphicsItem *> m_rangeSelectionSet;
+    std::set<QGraphicsItem*> m_rangeSelectionSet;
     QPoint m_lastGlobalPos;
     QPointF m_lastScenePos;
     QPointF m_rangeSelectionStartPos;
@@ -645,27 +644,28 @@ private:
     std::set<dust3d::Uuid> m_deferredRemoveEdgeIds;
 };
 
-class SkeletonGraphicsContainerWidget : public QWidget
+class SkeletonGraphicsContainerWidget : public QWidget {
-{
     Q_OBJECT
 signals:
     void containerSizeChanged(QSize size);
+
 public:
-    SkeletonGraphicsContainerWidget() :
+    SkeletonGraphicsContainerWidget()
-        m_graphicsWidget(nullptr)
+        : m_graphicsWidget(nullptr)
     {
     }
-    void resizeEvent(QResizeEvent *event) override
+    void resizeEvent(QResizeEvent* event) override
     {
         if (m_graphicsWidget && m_graphicsWidget->size() != event->size())
             emit containerSizeChanged(event->size());
     }
-    void setGraphicsWidget(SkeletonGraphicsWidget *graphicsWidget)
+    void setGraphicsWidget(SkeletonGraphicsWidget* graphicsWidget)
     {
         m_graphicsWidget = graphicsWidget;
     }
+
 private:
-    SkeletonGraphicsWidget *m_graphicsWidget;
+    SkeletonGraphicsWidget* m_graphicsWidget;
 };
 
 #endif

application/sources/skeleton_ik_mover.cc

@@ -1,6 +1,6 @@
-#include <QGuiApplication>
 #include "skeleton_ik_mover.h"
 #include "ccd_ik_resolver.h"
+#include <QGuiApplication>
 
 SkeletonIkMover::SkeletonIkMover()
 {
@@ -10,7 +10,7 @@ SkeletonIkMover::~SkeletonIkMover()
 {
 }
 
-void SkeletonIkMover::setTarget(const QVector3D &target)
+void SkeletonIkMover::setTarget(const QVector3D& target)
 {
     m_target = target;
 }
@@ -33,7 +33,7 @@ void SkeletonIkMover::addNode(dust3d::Uuid id, QVector3D position)
     m_ikNodes.push_back(ikNode);
 }
 
-const std::vector<SkeletonIkNode> &SkeletonIkMover::ikNodes()
+const std::vector<SkeletonIkNode>& SkeletonIkMover::ikNodes()
 {
     return m_ikNodes;
 }
@@ -41,7 +41,7 @@ const std::vector<SkeletonIkNode> &SkeletonIkMover::ikNodes()
 void SkeletonIkMover::process()
 {
     resolve();
-    
+
     emit finished();
 }
 

application/sources/skeleton_ik_mover.h

@@ -2,34 +2,34 @@
 #define DUST3D_APPLICATION_SKELETON_IK_MOVER_H_
 
 #include <QObject>
-#include <vector>
 #include <QVector3D>
 #include <dust3d/base/uuid.h>
+#include <vector>
 
-struct SkeletonIkNode
+struct SkeletonIkNode {
-{
     dust3d::Uuid id;
     QVector3D position;
     QVector3D newPosition;
 };
 
-class SkeletonIkMover : public QObject
+class SkeletonIkMover : public QObject {
-{
     Q_OBJECT
 public:
     SkeletonIkMover();
     ~SkeletonIkMover();
-    void setTarget(const QVector3D &target);
+    void setTarget(const QVector3D& target);
     void setUpdateVersion(unsigned long long version);
     unsigned long long getUpdateVersion();
     void addNode(dust3d::Uuid id, QVector3D position);
-    const std::vector<SkeletonIkNode> &ikNodes();
+    const std::vector<SkeletonIkNode>& ikNodes();
 signals:
     void finished();
 public slots:
     void process();
+
 private:
     void resolve();
+
 private:
     unsigned long long m_updateVersion = 0;
     std::vector<SkeletonIkNode> m_ikNodes;

application/sources/spinnable_toolbar_icon.cc

@@ -1,8 +1,8 @@
 #include "spinnable_toolbar_icon.h"
 #include "theme.h"
 
-SpinnableToolbarIcon::SpinnableToolbarIcon(QWidget *parent) :
+SpinnableToolbarIcon::SpinnableToolbarIcon(QWidget* parent)
-    QWidget(parent)
+    : QWidget(parent)
 {
     setFixedSize(Theme::toolIconSize, Theme::toolIconSize);
 

application/sources/spinnable_toolbar_icon.h

@@ -1,18 +1,18 @@
 #ifndef DUST3D_APPLICATION_SPINNABLE_TOOLBAR_ICON_H_
 #define DUST3D_APPLICATION_SPINNABLE_TOOLBAR_ICON_H_
 
-#include <QWidget>
-#include "waitingspinnerwidget.h"
 #include "toolbar_button.h"
+#include "waitingspinnerwidget.h"
+#include <QWidget>
 
-class SpinnableToolbarIcon : public QWidget
+class SpinnableToolbarIcon : public QWidget {
-{
 public:
-    SpinnableToolbarIcon(QWidget *parent=nullptr);
+    SpinnableToolbarIcon(QWidget* parent = nullptr);
-    void showSpinner(bool showSpinner=true);
+    void showSpinner(bool showSpinner = true);
     bool isSpinning();
+
 private:
-    WaitingSpinnerWidget *m_spinner = nullptr;
+    WaitingSpinnerWidget* m_spinner = nullptr;
 };
 
 #endif

application/sources/texture_generator.cc

@@ -1,19 +1,19 @@
-#include <QPainter>
-#include <QGuiApplication>
-#include <QRegion>
-#include <QPolygon>
-#include <QElapsedTimer>
-#include <QRadialGradient>
-#include <dust3d/base/texture_type.h>
 #include "texture_generator.h"
-#include "theme.h"
-#include "material.h"
 #include "debug.h"
+#include "material.h"
+#include "theme.h"
+#include <QElapsedTimer>
+#include <QGuiApplication>
+#include <QPainter>
+#include <QPolygon>
+#include <QRadialGradient>
+#include <QRegion>
+#include <dust3d/base/texture_type.h>
 
 QColor TextureGenerator::m_defaultTextureColor = Qt::transparent;
 
-TextureGenerator::TextureGenerator(const dust3d::Object &object, dust3d::Snapshot *snapshot) :
+TextureGenerator::TextureGenerator(const dust3d::Object& object, dust3d::Snapshot* snapshot)
-    m_snapshot(snapshot)
+    : m_snapshot(snapshot)
 {
     m_object = new dust3d::Object();
     *m_object = object;
@@ -31,84 +31,84 @@ TextureGenerator::~TextureGenerator()
     delete m_snapshot;
 }
 
-QImage *TextureGenerator::takeResultTextureColorImage()
+QImage* TextureGenerator::takeResultTextureColorImage()
 {
-    QImage *resultTextureColorImage = m_resultTextureColorImage;
+    QImage* resultTextureColorImage = m_resultTextureColorImage;
     m_resultTextureColorImage = nullptr;
     return resultTextureColorImage;
 }
 
-QImage *TextureGenerator::takeResultTextureNormalImage()
+QImage* TextureGenerator::takeResultTextureNormalImage()
 {
-    QImage *resultTextureNormalImage = m_resultTextureNormalImage;
+    QImage* resultTextureNormalImage = m_resultTextureNormalImage;
     m_resultTextureNormalImage = nullptr;
     return resultTextureNormalImage;
 }
 
-QImage *TextureGenerator::takeResultTextureRoughnessImage()
+QImage* TextureGenerator::takeResultTextureRoughnessImage()
 {
-    QImage *resultTextureRoughnessImage = m_resultTextureRoughnessImage;
+    QImage* resultTextureRoughnessImage = m_resultTextureRoughnessImage;
     m_resultTextureRoughnessImage = nullptr;
     return resultTextureRoughnessImage;
 }
 
-QImage *TextureGenerator::takeResultTextureMetalnessImage()
+QImage* TextureGenerator::takeResultTextureMetalnessImage()
 {
-    QImage *resultTextureMetalnessImage = m_resultTextureMetalnessImage;
+    QImage* resultTextureMetalnessImage = m_resultTextureMetalnessImage;
     m_resultTextureMetalnessImage = nullptr;
     return resultTextureMetalnessImage;
 }
 
-QImage *TextureGenerator::takeResultTextureAmbientOcclusionImage()
+QImage* TextureGenerator::takeResultTextureAmbientOcclusionImage()
 {
-    QImage *resultTextureAmbientOcclusionImage = m_resultTextureAmbientOcclusionImage;
+    QImage* resultTextureAmbientOcclusionImage = m_resultTextureAmbientOcclusionImage;
     m_resultTextureAmbientOcclusionImage = nullptr;
     return resultTextureAmbientOcclusionImage;
 }
 
-dust3d::Object *TextureGenerator::takeObject()
+dust3d::Object* TextureGenerator::takeObject()
 {
-    dust3d::Object *object = m_object;
+    dust3d::Object* object = m_object;
     m_object = nullptr;
     return object;
 }
 
-ModelMesh *TextureGenerator::takeResultMesh()
+ModelMesh* TextureGenerator::takeResultMesh()
 {
-    ModelMesh *resultMesh = m_resultMesh;
+    ModelMesh* resultMesh = m_resultMesh;
     m_resultMesh = nullptr;
     return resultMesh;
 }
 
-void TextureGenerator::addPartColorMap(dust3d::Uuid partId, const QImage *image, float tileScale)
+void TextureGenerator::addPartColorMap(dust3d::Uuid partId, const QImage* image, float tileScale)
 {
     if (nullptr == image)
         return;
     m_partColorTextureMap[partId] = std::make_pair(*image, tileScale);
 }
 
-void TextureGenerator::addPartNormalMap(dust3d::Uuid partId, const QImage *image, float tileScale)
+void TextureGenerator::addPartNormalMap(dust3d::Uuid partId, const QImage* image, float tileScale)
 {
     if (nullptr == image)
         return;
     m_partNormalTextureMap[partId] = std::make_pair(*image, tileScale);
 }
 
-void TextureGenerator::addPartMetalnessMap(dust3d::Uuid partId, const QImage *image, float tileScale)
+void TextureGenerator::addPartMetalnessMap(dust3d::Uuid partId, const QImage* image, float tileScale)
 {
     if (nullptr == image)
         return;
     m_partMetalnessTextureMap[partId] = std::make_pair(*image, tileScale);
 }
 
-void TextureGenerator::addPartRoughnessMap(dust3d::Uuid partId, const QImage *image, float tileScale)
+void TextureGenerator::addPartRoughnessMap(dust3d::Uuid partId, const QImage* image, float tileScale)
 {
     if (nullptr == image)
         return;
     m_partRoughnessTextureMap[partId] = std::make_pair(*image, tileScale);
 }
 
-void TextureGenerator::addPartAmbientOcclusionMap(dust3d::Uuid partId, const QImage *image, float tileScale)
+void TextureGenerator::addPartAmbientOcclusionMap(dust3d::Uuid partId, const QImage* image, float tileScale)
 {
     if (nullptr == image)
         return;
@@ -119,28 +119,28 @@ void TextureGenerator::prepare()
 {
     if (nullptr == m_snapshot)
         return;
-    
+
     std::map<dust3d::Uuid, dust3d::Uuid> updatedMaterialIdMap;
     std::map<dust3d::Uuid, bool> updatedCountershadedMap;
-    for (const auto &partIt: m_snapshot->parts) {
+    for (const auto& partIt : m_snapshot->parts) {
         dust3d::Uuid materialId;
         auto materialIdIt = partIt.second.find("materialId");
         if (materialIdIt != partIt.second.end())
             materialId = dust3d::Uuid(materialIdIt->second);
         dust3d::Uuid partId = dust3d::Uuid(partIt.first);
-        updatedMaterialIdMap.insert({partId, materialId});
+        updatedMaterialIdMap.insert({ partId, materialId });
-        updatedCountershadedMap.insert({partId,
+        updatedCountershadedMap.insert({ partId,
-            dust3d::String::isTrue(dust3d::String::valueOrEmpty(partIt.second, "countershaded"))});
+            dust3d::String::isTrue(dust3d::String::valueOrEmpty(partIt.second, "countershaded")) });
     }
-    for (const auto &bmeshNode: m_object->nodes) {
+    for (const auto& bmeshNode : m_object->nodes) {
-    
+
         bool countershaded = bmeshNode.countershaded;
         auto findUpdatedCountershadedMap = updatedCountershadedMap.find(bmeshNode.mirrorFromPartId.isNull() ? bmeshNode.partId : bmeshNode.mirrorFromPartId);
         if (findUpdatedCountershadedMap != updatedCountershadedMap.end())
             countershaded = findUpdatedCountershadedMap->second;
         if (countershaded)
             m_countershadedPartIds.insert(bmeshNode.partId);
-        
+
         for (size_t i = 0; i < (int)dust3d::TextureType::Count - 1; ++i) {
             dust3d::TextureType forWhat = (dust3d::TextureType)(i + 1);
             MaterialTextures materialTextures;
@@ -150,7 +150,7 @@ void TextureGenerator::prepare()
                 materialId = findUpdatedMaterialIdResult->second;
             float tileScale = 1.0;
             initializeMaterialTexturesFromSnapshot(*m_snapshot, materialId, materialTextures, tileScale);
-            const QImage *image = materialTextures.textureImages[i];
+            const QImage* image = materialTextures.textureImages[i];
             if (nullptr != image) {
                 if (dust3d::TextureType::BaseColor == forWhat)
                     addPartColorMap(bmeshNode.partId, image, tileScale);
@@ -175,100 +175,100 @@ bool TextureGenerator::hasTransparencySettings()
 void TextureGenerator::generate()
 {
     m_resultMesh = new ModelMesh(*m_object);
-    
+
     if (nullptr == m_object->triangleVertexUvs())
         return;
     if (nullptr == m_object->triangleSourceNodes())
         return;
     if (nullptr == m_object->partUvRects())
         return;
-    
+
     QElapsedTimer countTimeConsumed;
     countTimeConsumed.start();
-    
+
     prepare();
-    
+
     bool hasNormalMap = false;
     bool hasMetalnessMap = false;
     bool hasRoughnessMap = false;
     bool hasAmbientOcclusionMap = false;
-    
+
-    const auto &triangleVertexUvs = *m_object->triangleVertexUvs();
+    const auto& triangleVertexUvs = *m_object->triangleVertexUvs();
-    const auto &triangleSourceNodes = *m_object->triangleSourceNodes();
+    const auto& triangleSourceNodes = *m_object->triangleSourceNodes();
-    const auto &partUvRects = *m_object->partUvRects();
+    const auto& partUvRects = *m_object->partUvRects();
-    const auto &triangleNormals = m_object->triangleNormals;
+    const auto& triangleNormals = m_object->triangleNormals;
-    
+
     std::map<dust3d::Uuid, QColor> partColorMap;
-    std::map<std::pair<dust3d::Uuid, dust3d::Uuid>, const dust3d::ObjectNode *> nodeMap;
+    std::map<std::pair<dust3d::Uuid, dust3d::Uuid>, const dust3d::ObjectNode*> nodeMap;
     std::map<dust3d::Uuid, float> partColorSolubilityMap;
     std::map<dust3d::Uuid, float> partMetalnessMap;
     std::map<dust3d::Uuid, float> partRoughnessMap;
-    for (const auto &item: m_object->nodes) {
+    for (const auto& item : m_object->nodes) {
         if (!m_hasTransparencySettings) {
             if (!qFuzzyCompare(1.0, item.color.alpha()))
                 m_hasTransparencySettings = true;
         }
-        nodeMap.insert({{item.partId, item.nodeId}, &item});
+        nodeMap.insert({ { item.partId, item.nodeId }, &item });
-        partColorMap.insert({item.partId, QColor(item.color.toString().c_str())});
+        partColorMap.insert({ item.partId, QColor(item.color.toString().c_str()) });
-        partColorSolubilityMap.insert({item.partId, item.colorSolubility});
+        partColorSolubilityMap.insert({ item.partId, item.colorSolubility });
-        partMetalnessMap.insert({item.partId, item.metalness});
+        partMetalnessMap.insert({ item.partId, item.metalness });
-        partRoughnessMap.insert({item.partId, item.roughness});
+        partRoughnessMap.insert({ item.partId, item.roughness });
     }
-    
+
     m_resultTextureColorImage = new QImage(TextureGenerator::m_textureSize, TextureGenerator::m_textureSize, QImage::Format_ARGB32);
     m_resultTextureColorImage->fill(m_hasTransparencySettings ? m_defaultTextureColor : Qt::white);
-    
+
     m_resultTextureNormalImage = new QImage(TextureGenerator::m_textureSize, TextureGenerator::m_textureSize, QImage::Format_ARGB32);
     m_resultTextureNormalImage->fill(QColor(128, 128, 255));
-    
+
     m_resultTextureMetalnessImage = new QImage(TextureGenerator::m_textureSize, TextureGenerator::m_textureSize, QImage::Format_ARGB32);
     m_resultTextureMetalnessImage->fill(Qt::black);
-    
+
     m_resultTextureRoughnessImage = new QImage(TextureGenerator::m_textureSize, TextureGenerator::m_textureSize, QImage::Format_ARGB32);
     m_resultTextureRoughnessImage->fill(Qt::white);
-    
+
     m_resultTextureAmbientOcclusionImage = new QImage(TextureGenerator::m_textureSize, TextureGenerator::m_textureSize, QImage::Format_ARGB32);
     m_resultTextureAmbientOcclusionImage->fill(Qt::white);
 
     QColor borderColor = Qt::darkGray;
     QPen pen(borderColor);
-    
+
     QPainter texturePainter;
     texturePainter.begin(m_resultTextureColorImage);
     texturePainter.setRenderHint(QPainter::Antialiasing);
     texturePainter.setRenderHint(QPainter::HighQualityAntialiasing);
-    
+
     QPainter textureNormalPainter;
     textureNormalPainter.begin(m_resultTextureNormalImage);
     textureNormalPainter.setRenderHint(QPainter::Antialiasing);
     textureNormalPainter.setRenderHint(QPainter::HighQualityAntialiasing);
-    
+
     QPainter textureMetalnessPainter;
     textureMetalnessPainter.begin(m_resultTextureMetalnessImage);
     textureMetalnessPainter.setRenderHint(QPainter::Antialiasing);
     textureMetalnessPainter.setRenderHint(QPainter::HighQualityAntialiasing);
-    
+
     QPainter textureRoughnessPainter;
     textureRoughnessPainter.begin(m_resultTextureRoughnessImage);
     textureRoughnessPainter.setRenderHint(QPainter::Antialiasing);
     textureRoughnessPainter.setRenderHint(QPainter::HighQualityAntialiasing);
-    
+
     QPainter textureAmbientOcclusionPainter;
     textureAmbientOcclusionPainter.begin(m_resultTextureAmbientOcclusionImage);
     textureAmbientOcclusionPainter.setRenderHint(QPainter::Antialiasing);
     textureAmbientOcclusionPainter.setRenderHint(QPainter::HighQualityAntialiasing);
-    
+
     texturePainter.setPen(Qt::NoPen);
-    
+
-    for (const auto &it: partUvRects) {
+    for (const auto& it : partUvRects) {
-        const auto &partId = it.first;
+        const auto& partId = it.first;
-        const auto &rects = it.second;
+        const auto& rects = it.second;
         auto findSourceColorResult = partColorMap.find(partId);
         if (findSourceColorResult != partColorMap.end()) {
-            const auto &color = findSourceColorResult->second;
+            const auto& color = findSourceColorResult->second;
             QBrush brush(color);
             float fillExpandSize = 2;
-            for (const auto &rect: rects) {
+            for (const auto& rect : rects) {
                 QRectF translatedRect = {
                     rect.left() * TextureGenerator::m_textureSize - fillExpandSize,
                     rect.top() * TextureGenerator::m_textureSize - fillExpandSize,
@@ -279,20 +279,20 @@ void TextureGenerator::generate()
             }
         }
     }
-    
+
-    for (const auto &it: partUvRects) {
+    for (const auto& it : partUvRects) {
-        const auto &partId = it.first;
+        const auto& partId = it.first;
-        const auto &rects = it.second;
+        const auto& rects = it.second;
         auto findMetalnessResult = partMetalnessMap.find(partId);
         if (findMetalnessResult != partMetalnessMap.end()) {
             if (qFuzzyCompare(findMetalnessResult->second, (float)0.0))
                 continue;
-            const auto &color = QColor(findMetalnessResult->second * 255,
+            const auto& color = QColor(findMetalnessResult->second * 255,
                 findMetalnessResult->second * 255,
                 findMetalnessResult->second * 255);
             QBrush brush(color);
             float fillExpandSize = 2;
-            for (const auto &rect: rects) {
+            for (const auto& rect : rects) {
                 QRectF translatedRect = {
                     rect.left() * TextureGenerator::m_textureSize - fillExpandSize,
                     rect.top() * TextureGenerator::m_textureSize - fillExpandSize,
@@ -304,20 +304,20 @@ void TextureGenerator::generate()
             }
         }
     }
-    
+
-    for (const auto &it: partUvRects) {
+    for (const auto& it : partUvRects) {
-        const auto &partId = it.first;
+        const auto& partId = it.first;
-        const auto &rects = it.second;
+        const auto& rects = it.second;
         auto findRoughnessResult = partRoughnessMap.find(partId);
         if (findRoughnessResult != partRoughnessMap.end()) {
             if (qFuzzyCompare(findRoughnessResult->second, (float)1.0))
                 continue;
-            const auto &color = QColor(findRoughnessResult->second * 255,
+            const auto& color = QColor(findRoughnessResult->second * 255,
                 findRoughnessResult->second * 255,
                 findRoughnessResult->second * 255);
             QBrush brush(color);
             float fillExpandSize = 2;
-            for (const auto &rect: rects) {
+            for (const auto& rect : rects) {
                 QRectF translatedRect = {
                     rect.left() * TextureGenerator::m_textureSize - fillExpandSize,
                     rect.top() * TextureGenerator::m_textureSize - fillExpandSize,
@@ -329,25 +329,25 @@ void TextureGenerator::generate()
             }
         }
     }
-    
+
-    auto drawTexture = [&](const std::map<dust3d::Uuid, std::pair<QPixmap, QPixmap>> &map, QPainter &painter, bool useAlpha) {
+    auto drawTexture = [&](const std::map<dust3d::Uuid, std::pair<QPixmap, QPixmap>>& map, QPainter& painter, bool useAlpha) {
-        for (const auto &it: partUvRects) {
+        for (const auto& it : partUvRects) {
-            const auto &partId = it.first;
+            const auto& partId = it.first;
-            const auto &rects = it.second;
+            const auto& rects = it.second;
             float alpha = 1.0;
             if (useAlpha) {
                 auto findSourceColorResult = partColorMap.find(partId);
                 if (findSourceColorResult != partColorMap.end()) {
-                    const auto &color = findSourceColorResult->second;
+                    const auto& color = findSourceColorResult->second;
                     alpha = color.alphaF();
                 }
             }
             auto findTextureResult = map.find(partId);
             if (findTextureResult != map.end()) {
-                const auto &pixmap = findTextureResult->second.first;
+                const auto& pixmap = findTextureResult->second.first;
-                const auto &rotatedPixmap = findTextureResult->second.second;
+                const auto& rotatedPixmap = findTextureResult->second.second;
                 painter.setOpacity(alpha);
-                for (const auto &rect: rects) {
+                for (const auto& rect : rects) {
                     QRectF translatedRect = {
                         rect.left() * TextureGenerator::m_textureSize,
                         rect.top() * TextureGenerator::m_textureSize,
@@ -364,12 +364,12 @@ void TextureGenerator::generate()
             }
         }
     };
-    
+
-    auto convertTextureImageToPixmap = [&](const std::map<dust3d::Uuid, std::pair<QImage, float>> &sourceMap,
+    auto convertTextureImageToPixmap = [&](const std::map<dust3d::Uuid, std::pair<QImage, float>>& sourceMap,
-            std::map<dust3d::Uuid, std::pair<QPixmap, QPixmap>> &targetMap) {
+                                           std::map<dust3d::Uuid, std::pair<QPixmap, QPixmap>>& targetMap) {
-        for (const auto &it: sourceMap) {
+        for (const auto& it : sourceMap) {
             float tileScale = it.second.second;
-            const auto &image = it.second.first;
+            const auto& image = it.second.first;
             auto newSize = image.size() * tileScale;
             QImage scaledImage = image.scaled(newSize);
             QPoint center = scaledImage.rect().center();
@@ -381,53 +381,52 @@ void TextureGenerator::generate()
                 QPixmap::fromImage(rotatedImage));
         }
     };
-    
+
     std::map<dust3d::Uuid, std::pair<QPixmap, QPixmap>> partColorTexturePixmaps;
     std::map<dust3d::Uuid, std::pair<QPixmap, QPixmap>> partNormalTexturePixmaps;
     std::map<dust3d::Uuid, std::pair<QPixmap, QPixmap>> partMetalnessTexturePixmaps;
     std::map<dust3d::Uuid, std::pair<QPixmap, QPixmap>> partRoughnessTexturePixmaps;
     std::map<dust3d::Uuid, std::pair<QPixmap, QPixmap>> partAmbientOcclusionTexturePixmaps;
-    
+
     convertTextureImageToPixmap(m_partColorTextureMap, partColorTexturePixmaps);
     convertTextureImageToPixmap(m_partNormalTextureMap, partNormalTexturePixmaps);
     convertTextureImageToPixmap(m_partMetalnessTextureMap, partMetalnessTexturePixmaps);
     convertTextureImageToPixmap(m_partRoughnessTextureMap, partRoughnessTexturePixmaps);
     convertTextureImageToPixmap(m_partAmbientOcclusionTextureMap, partAmbientOcclusionTexturePixmaps);
-    
+
     drawTexture(partColorTexturePixmaps, texturePainter, true);
     drawTexture(partNormalTexturePixmaps, textureNormalPainter, false);
     drawTexture(partMetalnessTexturePixmaps, textureMetalnessPainter, false);
     drawTexture(partRoughnessTexturePixmaps, textureRoughnessPainter, false);
     drawTexture(partAmbientOcclusionTexturePixmaps, textureAmbientOcclusionPainter, false);
-    
+
-    auto drawBySolubility = [&](const dust3d::Uuid &partId, size_t triangleIndex, size_t firstVertexIndex, size_t secondVertexIndex,
+    auto drawBySolubility = [&](const dust3d::Uuid& partId, size_t triangleIndex, size_t firstVertexIndex, size_t secondVertexIndex,
-            const dust3d::Uuid &neighborPartId) {
+                                const dust3d::Uuid& neighborPartId) {
-        const std::vector<dust3d::Vector2> &uv = triangleVertexUvs[triangleIndex];
+        const std::vector<dust3d::Vector2>& uv = triangleVertexUvs[triangleIndex];
-        const auto &allRects = partUvRects.find(partId);
+        const auto& allRects = partUvRects.find(partId);
         if (allRects == partUvRects.end()) {
             qDebug() << "Found part uv rects failed";
             return;
         }
-        const auto &firstPoint = uv[firstVertexIndex];
+        const auto& firstPoint = uv[firstVertexIndex];
-        const auto &secondPoint = uv[secondVertexIndex];
+        const auto& secondPoint = uv[secondVertexIndex];
         auto edgeLength = (firstPoint - secondPoint).length();
         auto middlePoint = (firstPoint + secondPoint) / 2.0;
         float alpha = 1.0;
-        const auto &findColor = partColorMap.find(partId);
+        const auto& findColor = partColorMap.find(partId);
         if (findColor == partColorMap.end())
             return;
         alpha = findColor->second.alphaF();
-        const auto &findNeighborColorSolubility = partColorSolubilityMap.find(neighborPartId);
+        const auto& findNeighborColorSolubility = partColorSolubilityMap.find(neighborPartId);
         if (findNeighborColorSolubility == partColorSolubilityMap.end())
             return;
         if (qFuzzyIsNull(findNeighborColorSolubility->second))
             return;
-        const auto &findNeighborColor = partColorMap.find(neighborPartId);
+        const auto& findNeighborColor = partColorMap.find(neighborPartId);
         if (findNeighborColor == partColorMap.end())
             return;
-        for (const auto &it: allRects->second) {
+        for (const auto& it : allRects->second) {
-            if (it.contains(firstPoint.x(), firstPoint.y()) ||
+            if (it.contains(firstPoint.x(), firstPoint.y()) || it.contains(secondPoint.x(), secondPoint.y())) {
-                    it.contains(secondPoint.x(), secondPoint.y())) {
                 float finalRadius = (it.width() + it.height()) * 0.5 * findNeighborColorSolubility->second;
                 if (finalRadius < edgeLength)
                     finalRadius = edgeLength;
@@ -445,14 +444,14 @@ void TextureGenerator::generate()
                 texturePainter.setOpacity(alpha);
                 auto findTextureResult = partColorTexturePixmaps.find(neighborPartId);
                 if (findTextureResult != partColorTexturePixmaps.end()) {
-                    const auto &pixmap = findTextureResult->second.first;
+                    const auto& pixmap = findTextureResult->second.first;
-                    const auto &rotatedPixmap = findTextureResult->second.second;
+                    const auto& rotatedPixmap = findTextureResult->second.second;
-                    
+
                     QImage tmpImage(translatedRect.width(), translatedRect.height(), QImage::Format_ARGB32);
                     QPixmap tmpPixmap = QPixmap::fromImage(tmpImage);
                     QPainter tmpPainter;
                     QRectF tmpImageFrame = QRectF(0, 0, translatedRect.width(), translatedRect.height());
-                    
+
                     // Fill tiled texture
                     tmpPainter.begin(&tmpPixmap);
                     tmpPainter.setOpacity(alpha);
@@ -463,23 +462,23 @@ void TextureGenerator::generate()
                     }
                     tmpPainter.setOpacity(1.0);
                     tmpPainter.end();
-                    
+
                     // Apply gradient
                     QRadialGradient gradient(QPointF(middlePoint.x() * TextureGenerator::m_textureSize - translatedRect.left(),
-                        middlePoint.y() * TextureGenerator::m_textureSize - translatedRect.top()),
+                                                 middlePoint.y() * TextureGenerator::m_textureSize - translatedRect.top()),
                         finalRadius * TextureGenerator::m_textureSize);
                     gradient.setColorAt(0.0, findNeighborColor->second);
                     gradient.setColorAt(1.0, Qt::transparent);
-                    
+
                     tmpPainter.begin(&tmpPixmap);
                     tmpPainter.setCompositionMode(QPainter::CompositionMode_DestinationIn);
                     tmpPainter.fillRect(tmpImageFrame, gradient);
                     tmpPainter.end();
-                    
+
                     texturePainter.drawPixmap(translatedRect, tmpPixmap, tmpImageFrame);
                 } else {
                     QRadialGradient gradient(QPointF(middlePoint.x() * TextureGenerator::m_textureSize,
-                        middlePoint.y() * TextureGenerator::m_textureSize),
+                                                 middlePoint.y() * TextureGenerator::m_textureSize),
                         finalRadius * TextureGenerator::m_textureSize);
                     gradient.setColorAt(0.0, findNeighborColor->second);
                     gradient.setColorAt(1.0, Qt::transparent);
@@ -490,10 +489,10 @@ void TextureGenerator::generate()
             }
         }
     };
-    
+
     std::map<std::pair<size_t, size_t>, std::tuple<size_t, size_t, size_t>> halfEdgeToTriangleMap;
     for (size_t i = 0; i < m_object->triangles.size(); ++i) {
-        const auto &triangleIndices = m_object->triangles[i];
+        const auto& triangleIndices = m_object->triangles[i];
         if (triangleIndices.size() != 3) {
             qDebug() << "Found invalid triangle indices";
             continue;
@@ -504,38 +503,38 @@ void TextureGenerator::generate()
                 std::make_tuple(i, j, k)));
         }
     }
-    for (const auto &it: halfEdgeToTriangleMap) {
+    for (const auto& it : halfEdgeToTriangleMap) {
         auto oppositeHalfEdge = std::make_pair(it.first.second, it.first.first);
-        const auto &opposite = halfEdgeToTriangleMap.find(oppositeHalfEdge);
+        const auto& opposite = halfEdgeToTriangleMap.find(oppositeHalfEdge);
         if (opposite == halfEdgeToTriangleMap.end())
             continue;
-        const std::pair<dust3d::Uuid, dust3d::Uuid> &source = triangleSourceNodes[std::get<0>(it.second)];
+        const std::pair<dust3d::Uuid, dust3d::Uuid>& source = triangleSourceNodes[std::get<0>(it.second)];
-        const std::pair<dust3d::Uuid, dust3d::Uuid> &oppositeSource = triangleSourceNodes[std::get<0>(opposite->second)];
+        const std::pair<dust3d::Uuid, dust3d::Uuid>& oppositeSource = triangleSourceNodes[std::get<0>(opposite->second)];
         if (source.first == oppositeSource.first)
             continue;
         drawBySolubility(source.first, std::get<0>(it.second), std::get<1>(it.second), std::get<2>(it.second), oppositeSource.first);
         drawBySolubility(oppositeSource.first, std::get<0>(opposite->second), std::get<1>(opposite->second), std::get<2>(opposite->second), source.first);
     }
-    
+
     // Draw belly white
     texturePainter.setCompositionMode(QPainter::CompositionMode_SoftLight);
     for (size_t triangleIndex = 0; triangleIndex < m_object->triangles.size(); ++triangleIndex) {
-        const auto &normal = triangleNormals[triangleIndex];
+        const auto& normal = triangleNormals[triangleIndex];
-        const std::pair<dust3d::Uuid, dust3d::Uuid> &source = triangleSourceNodes[triangleIndex];
+        const std::pair<dust3d::Uuid, dust3d::Uuid>& source = triangleSourceNodes[triangleIndex];
-        const auto &partId = source.first;
+        const auto& partId = source.first;
         if (m_countershadedPartIds.find(partId) == m_countershadedPartIds.end())
             continue;
-        
+
-        const auto &allRects = partUvRects.find(partId);
+        const auto& allRects = partUvRects.find(partId);
         if (allRects == partUvRects.end()) {
             qDebug() << "Found part uv rects failed";
             continue;
         }
-        
+
-        const auto &findObjectNode = nodeMap.find(source);
+        const auto& findObjectNode = nodeMap.find(source);
         if (findObjectNode == nodeMap.end())
             continue;
-        const dust3d::ObjectNode *objectNode = findObjectNode->second;
+        const dust3d::ObjectNode* objectNode = findObjectNode->second;
         if (qAbs(dust3d::Vector3::dotProduct(objectNode->direction, dust3d::Vector3(0, 1, 0))) >= 0.707) {
             if (dust3d::Vector3::dotProduct(normal, dust3d::Vector3(0, 0, 1)) <= 0.0)
                 continue;
@@ -543,24 +542,22 @@ void TextureGenerator::generate()
             if (dust3d::Vector3::dotProduct(normal, dust3d::Vector3(0, -1, 0)) <= 0.0)
                 continue;
         }
-        
+
-        const auto &triangleIndices = m_object->triangles[triangleIndex];
+        const auto& triangleIndices = m_object->triangles[triangleIndex];
         if (triangleIndices.size() != 3) {
             qDebug() << "Found invalid triangle indices";
             continue;
         }
-        
+
-        const std::vector<dust3d::Vector2> &uv = triangleVertexUvs[triangleIndex];
+        const std::vector<dust3d::Vector2>& uv = triangleVertexUvs[triangleIndex];
         dust3d::Vector2 middlePoint = (uv[0] + uv[1] + uv[2]) / 3.0;
-        float finalRadius = ((uv[0] - uv[1]).length() +
+        float finalRadius = ((uv[0] - uv[1]).length() + (uv[1] - uv[2]).length() + (uv[2] - uv[0]).length()) / 3.0;
-            (uv[1] - uv[2]).length() +
-            (uv[2] - uv[0]).length()) / 3.0;
         QRadialGradient gradient(QPointF(middlePoint.x() * TextureGenerator::m_textureSize,
-            middlePoint.y() * TextureGenerator::m_textureSize),
+                                     middlePoint.y() * TextureGenerator::m_textureSize),
             finalRadius * TextureGenerator::m_textureSize);
         gradient.setColorAt(0.0, Qt::white);
         gradient.setColorAt(1.0, Qt::transparent);
-        for (const auto &it: allRects->second) {
+        for (const auto& it : allRects->second) {
             if (it.contains(middlePoint.x(), middlePoint.y())) {
                 dust3d::Rectangle fillTarget((middlePoint.x() - finalRadius),
                     (middlePoint.y() - finalRadius),
@@ -576,31 +573,31 @@ void TextureGenerator::generate()
                 texturePainter.fillRect(translatedRect, gradient);
             }
         }
-        
+
         // Fill the neighbor halfedges
         for (int i = 0; i < 3; ++i) {
             int j = (i + 1) % 3;
             auto oppositeHalfEdge = std::make_pair(triangleIndices[j], triangleIndices[i]);
-            const auto &opposite = halfEdgeToTriangleMap.find(oppositeHalfEdge);
+            const auto& opposite = halfEdgeToTriangleMap.find(oppositeHalfEdge);
             if (opposite == halfEdgeToTriangleMap.end())
                 continue;
             auto oppositeTriangleIndex = std::get<0>(opposite->second);
-            const std::pair<dust3d::Uuid, dust3d::Uuid> &oppositeSource = triangleSourceNodes[oppositeTriangleIndex];
+            const std::pair<dust3d::Uuid, dust3d::Uuid>& oppositeSource = triangleSourceNodes[oppositeTriangleIndex];
             if (partId == oppositeSource.first)
                 continue;
-            const auto &oppositeAllRects = partUvRects.find(oppositeSource.first);
+            const auto& oppositeAllRects = partUvRects.find(oppositeSource.first);
             if (oppositeAllRects == partUvRects.end()) {
                 qDebug() << "Found part uv rects failed";
                 continue;
             }
-            const std::vector<dust3d::Vector2> &oppositeUv = triangleVertexUvs[oppositeTriangleIndex];
+            const std::vector<dust3d::Vector2>& oppositeUv = triangleVertexUvs[oppositeTriangleIndex];
             dust3d::Vector2 oppositeMiddlePoint = (oppositeUv[std::get<1>(opposite->second)] + oppositeUv[std::get<2>(opposite->second)]) * 0.5;
             QRadialGradient oppositeGradient(QPointF(oppositeMiddlePoint.x() * TextureGenerator::m_textureSize,
-                oppositeMiddlePoint.y() * TextureGenerator::m_textureSize),
+                                                 oppositeMiddlePoint.y() * TextureGenerator::m_textureSize),
                 finalRadius * TextureGenerator::m_textureSize);
             oppositeGradient.setColorAt(0.0, Qt::white);
             oppositeGradient.setColorAt(1.0, Qt::transparent);
-            for (const auto &it: oppositeAllRects->second) {
+            for (const auto& it : oppositeAllRects->second) {
                 if (it.contains(oppositeMiddlePoint.x(), oppositeMiddlePoint.y())) {
                     dust3d::Rectangle fillTarget((oppositeMiddlePoint.x() - finalRadius),
                         (oppositeMiddlePoint.y() - finalRadius),
@@ -618,7 +615,7 @@ void TextureGenerator::generate()
             }
         }
     }
-    
+
     hasNormalMap = !m_partNormalTextureMap.empty();
     if (!m_partMetalnessTextureMap.empty())
         hasMetalnessMap = true;
@@ -631,12 +628,12 @@ void TextureGenerator::generate()
     textureMetalnessPainter.end();
     textureRoughnessPainter.end();
     textureAmbientOcclusionPainter.end();
-    
+
     if (!hasNormalMap) {
         delete m_resultTextureNormalImage;
         m_resultTextureNormalImage = nullptr;
     }
-    
+
     if (!hasMetalnessMap && !hasRoughnessMap && !hasAmbientOcclusionMap) {
         delete m_resultTextureMetalnessImage;
         m_resultTextureMetalnessImage = nullptr;
@@ -647,7 +644,7 @@ void TextureGenerator::generate()
         delete m_resultTextureAmbientOcclusionImage;
         m_resultTextureAmbientOcclusionImage = nullptr;
     }
-    
+
     m_resultMesh->setTextureImage(new QImage(*m_resultTextureColorImage));
     if (nullptr != m_resultTextureNormalImage)
         m_resultMesh->setNormalMapImage(new QImage(*m_resultTextureNormalImage));
@@ -660,18 +657,16 @@ void TextureGenerator::generate()
         m_resultMesh->setHasRoughnessInImage(hasRoughnessMap);
         m_resultMesh->setHasAmbientOcclusionInImage(hasAmbientOcclusionMap);
     }
-    
+
     qDebug() << "The texture[" << TextureGenerator::m_textureSize << "x" << TextureGenerator::m_textureSize << "] generation took" << countTimeConsumed.elapsed() << "milliseconds";
 }
 
-QImage *TextureGenerator::combineMetalnessRoughnessAmbientOcclusionImages(QImage *metalnessImage,
+QImage* TextureGenerator::combineMetalnessRoughnessAmbientOcclusionImages(QImage* metalnessImage,
-        QImage *roughnessImage,
+    QImage* roughnessImage,
-        QImage *ambientOcclusionImage)
+    QImage* ambientOcclusionImage)
 {
-    QImage *textureMetalnessRoughnessAmbientOcclusionImage = nullptr;
+    QImage* textureMetalnessRoughnessAmbientOcclusionImage = nullptr;
-    if (nullptr != metalnessImage ||
+    if (nullptr != metalnessImage || nullptr != roughnessImage || nullptr != ambientOcclusionImage) {
-            nullptr != roughnessImage ||
-            nullptr != ambientOcclusionImage) {
         int textureSize = 0;
         if (nullptr != metalnessImage)
             textureSize = metalnessImage->height();

application/sources/texture_generator.h

@@ -1,61 +1,63 @@
 #ifndef DUST3D_APPLICATION_TEXTURE_GENERATOR_H_
 #define DUST3D_APPLICATION_TEXTURE_GENERATOR_H_
 
-#include <QObject>
+#include "model_mesh.h"
-#include <vector>
-#include <QImage>
 #include <QColor>
+#include <QImage>
+#include <QObject>
 #include <QPixmap>
 #include <dust3d/base/object.h>
 #include <dust3d/base/snapshot.h>
-#include "model_mesh.h"
+#include <vector>
 
-class TextureGenerator : public QObject
+class TextureGenerator : public QObject {
-{
     Q_OBJECT
 public:
-    TextureGenerator(const dust3d::Object &object, dust3d::Snapshot *snapshot=nullptr);
+    TextureGenerator(const dust3d::Object& object, dust3d::Snapshot* snapshot = nullptr);
     ~TextureGenerator();
-    QImage *takeResultTextureColorImage();
+    QImage* takeResultTextureColorImage();
-    QImage *takeResultTextureNormalImage();
+    QImage* takeResultTextureNormalImage();
-    QImage *takeResultTextureRoughnessImage();
+    QImage* takeResultTextureRoughnessImage();
-    QImage *takeResultTextureMetalnessImage();
+    QImage* takeResultTextureMetalnessImage();
-    QImage *takeResultTextureAmbientOcclusionImage();
+    QImage* takeResultTextureAmbientOcclusionImage();
-    dust3d::Object *takeObject();
+    dust3d::Object* takeObject();
-    ModelMesh *takeResultMesh();
+    ModelMesh* takeResultMesh();
     bool hasTransparencySettings();
-    void addPartColorMap(dust3d::Uuid partId, const QImage *image, float tileScale);
+    void addPartColorMap(dust3d::Uuid partId, const QImage* image, float tileScale);
-    void addPartNormalMap(dust3d::Uuid partId, const QImage *image, float tileScale);
+    void addPartNormalMap(dust3d::Uuid partId, const QImage* image, float tileScale);
-    void addPartMetalnessMap(dust3d::Uuid partId, const QImage *image, float tileScale);
+    void addPartMetalnessMap(dust3d::Uuid partId, const QImage* image, float tileScale);
-    void addPartRoughnessMap(dust3d::Uuid partId, const QImage *image, float tileScale);
+    void addPartRoughnessMap(dust3d::Uuid partId, const QImage* image, float tileScale);
-    void addPartAmbientOcclusionMap(dust3d::Uuid partId, const QImage *image, float tileScale);
+    void addPartAmbientOcclusionMap(dust3d::Uuid partId, const QImage* image, float tileScale);
     void generate();
-    static QImage *combineMetalnessRoughnessAmbientOcclusionImages(QImage *metalnessImage,
+    static QImage* combineMetalnessRoughnessAmbientOcclusionImages(QImage* metalnessImage,
-            QImage *roughnessImage,
+        QImage* roughnessImage,
-            QImage *ambientOcclusionImage);
+        QImage* ambientOcclusionImage);
 signals:
     void finished();
 public slots:
     void process();
+
 public:
     static QColor m_defaultTextureColor;
+
 private:
     void prepare();
+
 private:
-    dust3d::Object *m_object = nullptr;
+    dust3d::Object* m_object = nullptr;
-    QImage *m_resultTextureColorImage = nullptr;
+    QImage* m_resultTextureColorImage = nullptr;
-    QImage *m_resultTextureNormalImage = nullptr;
+    QImage* m_resultTextureNormalImage = nullptr;
-    QImage *m_resultTextureRoughnessImage = nullptr;
+    QImage* m_resultTextureRoughnessImage = nullptr;
-    QImage *m_resultTextureMetalnessImage = nullptr;
+    QImage* m_resultTextureMetalnessImage = nullptr;
-    QImage *m_resultTextureAmbientOcclusionImage = nullptr;
+    QImage* m_resultTextureAmbientOcclusionImage = nullptr;
-    ModelMesh *m_resultMesh = nullptr;
+    ModelMesh* m_resultMesh = nullptr;
     std::map<dust3d::Uuid, std::pair<QImage, float>> m_partColorTextureMap;
     std::map<dust3d::Uuid, std::pair<QImage, float>> m_partNormalTextureMap;
     std::map<dust3d::Uuid, std::pair<QImage, float>> m_partMetalnessTextureMap;
     std::map<dust3d::Uuid, std::pair<QImage, float>> m_partRoughnessTextureMap;
     std::map<dust3d::Uuid, std::pair<QImage, float>> m_partAmbientOcclusionTextureMap;
     std::set<dust3d::Uuid> m_countershadedPartIds;
-    dust3d::Snapshot *m_snapshot = nullptr;
+    dust3d::Snapshot* m_snapshot = nullptr;
     bool m_hasTransparencySettings = false;
     int m_textureSize = 1024;
 };