Clean project structure.

src/rendering/visual_elements/nodes/AbstractVisualNode.cpp

@@ -0,0 +1,77 @@
+#include "AbstractVisualNode.h"
+
+AbstractVisualNode::AbstractVisualNode(const Point& location, const std::string& name)
+    : mLocation(location),
+      mName(name)
+{
+
+}
+
+SceneItem* AbstractVisualNode::getSceneItem(std::size_t idx) const
+{
+    return mSceneItems[idx].get();
+}
+
+std::size_t AbstractVisualNode::getNumSceneItems() const
+{
+    return mSceneItems.size();
+}
+
+void AbstractVisualNode::update(SceneInfo* sceneInfo)
+{
+
+}
+
+Image* AbstractVisualNode::getImage() const
+{
+    return mImage.get();
+}
+
+void AbstractVisualNode::syncChildren(const std::vector<AbstractVisualNode*>& children)
+{
+    mChildren = children;
+}
+
+void AbstractVisualNode::addChild(AbstractVisualNode* child)
+{
+    mChildren.push_back(child);
+}
+
+const std::vector<AbstractVisualNode*>& AbstractVisualNode::getChildren() const
+{
+    return mChildren;
+}
+
+void AbstractVisualNode::setIsVisible(bool isVisible)
+{
+    mIsVisible = isVisible;
+}
+
+std::size_t AbstractVisualNode::getNumChildren() const
+{
+    return mChildren.size();
+}
+
+void AbstractVisualNode::setName(const std::string& name)
+{
+    mName = name;
+}
+
+const std::string& AbstractVisualNode::getName() const
+{
+    return mName;
+}
+
+bool AbstractVisualNode::getIsVisible() const
+{
+    return mIsVisible;
+}
+
+void AbstractVisualNode::setLocation(const Point& loc)
+{
+    if (mLocation != loc)
+    {
+        mTransformIsDirty = true;
+        mLocation = loc;
+    }
+}

src/rendering/visual_elements/nodes/AbstractVisualNode.h

@@ -0,0 +1,58 @@
+#pragma once
+
+#include "SceneModel.h"
+#include "AbstractMesh.h"
+
+#include "Image.h"
+#include "Point.h"
+
+#include <memory>
+
+#include <iostream>
+
+struct SceneInfo;
+
+class AbstractVisualNode
+{
+public:
+    AbstractVisualNode(const Point& location, const std::string& name = {});
+
+    virtual ~AbstractVisualNode() = default;
+
+    void addChild(AbstractVisualNode* child);
+
+    virtual SceneItem* getSceneItem(std::size_t idx) const;
+
+    virtual std::size_t getNumSceneItems() const;
+
+    std::size_t getNumChildren() const;
+
+    const std::vector<AbstractVisualNode*>& getChildren() const;
+
+    const std::string& getName() const;
+
+    Image* getImage() const;
+
+    bool getIsVisible() const;
+
+    void syncChildren(const std::vector<AbstractVisualNode*>& children);
+
+    void setIsVisible(bool isVisible);
+
+    void setName(const std::string& name);
+
+    void setLocation(const Point& loc);
+
+    virtual void update(SceneInfo* sceneInfo);
+
+protected:
+    Point mLocation;
+    std::vector<std::unique_ptr<SceneItem> > mSceneItems;
+    std::unique_ptr<Image> mImage;
+
+    std::vector<AbstractVisualNode*> mChildren;
+
+    bool mIsVisible{true};
+    bool mTransformIsDirty{true};
+    std::string mName;
+};

src/rendering/visual_elements/nodes/GeometryNode.cpp

@@ -0,0 +1,89 @@
+#include "GeometryNode.h"
+
+#include "SceneInfo.h"
+#include "SceneModel.h"
+
+GeometryNode::GeometryNode(const Point& location)
+    :   MaterialNode(location),
+        mStrokeThickness(1.0),
+        mType(Type::Path)
+{
+
+}
+
+GeometryNode::~GeometryNode()
+{
+
+}
+
+SceneItem* GeometryNode::getSceneItem(std::size_t idx) const
+{
+    if (idx == 0)
+    {
+        return mBackgroundItem.get();
+    }
+    else
+    {
+        return nullptr;
+    }
+}
+
+std::size_t GeometryNode::getNumSceneItems() const
+{
+    return 1;
+}
+
+
+double GeometryNode::getStrokeThickness() const
+{
+    return mStrokeThickness;
+}
+
+void GeometryNode::setStrokeThickness(double thickness)
+{
+    if (mStrokeThickness != thickness)
+    {
+        mGeometryIsDirty = true;
+        mStrokeThickness = thickness;
+    }
+}
+
+void GeometryNode::updateMaterial()
+{
+    if (!mBackgroundItem)
+    {
+        return;
+    }
+
+    if (mHasFillColor)
+    {
+        mBackgroundItem->setFillColor(mFillColor);
+    }
+
+    if (mHasStrokeColor && mStrokeThickness > 0)
+    {
+        mBackgroundItem->setOutlineColor(mStrokeColor);
+        mBackgroundItem->setOutlineThickness(mStrokeThickness);
+    }
+}
+
+void GeometryNode::update(SceneInfo* sceneInfo)
+{
+    if (!mBackgroundItem || mGeometryIsDirty)
+    {
+        createOrUpdateGeometry(sceneInfo);
+        mGeometryIsDirty = false;
+    }
+
+    if (mTransformIsDirty)
+    {
+        updateTransform();
+        mTransformIsDirty = false;
+    }
+
+    if (mMaterialIsDirty)
+    {
+        updateMaterial();
+        mMaterialIsDirty = false;
+    }
+}

src/rendering/visual_elements/nodes/GeometryNode.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#include "MaterialNode.h"
+
+struct SceneInfo;
+class SceneModel;
+
+class GeometryNode : public MaterialNode
+{
+public:
+    enum class Type
+    {
+        Path,
+        Rectangle,
+        Circle,
+        Arc,
+        Line
+    };
+
+public:
+    GeometryNode(const Point& location);
+    virtual ~GeometryNode();
+
+    virtual Type getType() = 0;
+
+    SceneItem* getSceneItem(std::size_t idx) const override;
+    std::size_t getNumSceneItems() const override;
+
+    double getStrokeThickness() const;
+    void setStrokeThickness(double thickness);
+
+    void update(SceneInfo* sceneInfo) override;
+
+protected:
+    virtual void createOrUpdateGeometry(SceneInfo* sceneInfo) = 0;
+    virtual void updateMaterial();
+    virtual void updateTransform() = 0;
+
+    double mStrokeThickness{0};
+    Type mType;
+    bool mGeometryIsDirty{true};
+
+    std::unique_ptr<SceneModel> mBackgroundItem;
+};
+
+using GeometryNodePtr = std::unique_ptr<GeometryNode>;

src/rendering/visual_elements/nodes/GridNode.cpp

@@ -0,0 +1,140 @@
+#include "GridNode.h"
+
+#include "MeshPrimitives.h"
+
+GridNode::GridNode(const Point& location)
+ : MaterialNode(location)
+{
+
+}
+
+void GridNode::setNumX(std::size_t numX)
+{
+    if (mNumberX != numX)
+    {
+        mNumberX = numX;
+        mDataDirty = true;
+    }
+}
+
+void GridNode::setNumY(std::size_t numY)
+{
+    if (mNumberY != numY)
+    {
+        mNumberY = numY;
+        mDataDirty = true;
+    }
+}
+
+void GridNode::setWidth(double width)
+{
+    if (mWidth != width)
+    {
+        mTransformIsDirty = true;
+        mWidth = width;
+    }
+}
+
+void GridNode::setHeight(double height)
+{
+    if (mHeight != height)
+    {
+        mTransformIsDirty = true;
+        mHeight = height;
+    }
+}
+
+void GridNode::setData(const std::vector<Color>& colors)
+{
+    if (mData != colors)
+    {
+        mData = colors;
+        mDataDirty = true;
+    }
+}
+
+SceneItem* GridNode::getSceneItem(std::size_t idx) const
+{
+    if (idx == 0)
+    {
+        return mBackgroundModel.get();
+    }
+    else
+    {
+        return mOutlineModel.get();
+    }
+}
+
+std::size_t GridNode::getNumSceneItems() const
+{
+    return 2;
+}
+
+void GridNode::update(SceneInfo* sceneInfo)
+{
+    if (!mBackgroundModel || mDataDirty)
+    {
+        auto mesh = MeshPrimitives::buildExplodedGridAsTriMesh(mNumberX, mNumberY);
+
+        if (!mBackgroundModel)
+        {
+            mBackgroundModel = std::make_unique<SceneModel>(std::move(mesh));
+            mBackgroundModel->setName(mName + "_BackgroundModel");
+        }
+        else
+        {
+            mBackgroundModel.get()->updateMesh(std::move(mesh));
+        }
+    }
+
+    if (mOutlineModel || mDataDirty)
+    {
+        auto mesh = MeshPrimitives::buildExplodedGridAsLineMesh(mNumberX, mNumberY);
+
+        if (!mOutlineModel)
+        {
+            mOutlineModel = std::make_unique<SceneModel>(std::move(mesh));
+            mOutlineModel->setName(mName + "_OulineModel");
+        }
+        else
+        {
+            mOutlineModel.get()->updateMesh(std::move(mesh));
+        }
+    }
+
+    if (mDataDirty)
+    {
+        auto difference = mNumberX*mNumberY - mData.size();
+        mData.resize(mNumberX*mNumberY, {});
+
+        auto node_data = std::vector<std::vector<double> >(4*mNumberX*mNumberY);
+        for (unsigned idx=0; idx< node_data.size(); idx++)
+        {
+            if (idx < mData.size())
+            {
+                node_data[idx] = mData[idx].getAsVectorDouble();
+            }
+
+        }
+        //mBackgroundModel->getMesh()->addVectorAttribute("Color", mData);
+
+    }
+
+    if (mTransformIsDirty)
+    {
+        auto size = mHeight > mWidth ? mWidth : mHeight;
+
+        mBackgroundModel->updateTransform({mLocation, static_cast<double>(size), static_cast<double>(size)});
+        mOutlineModel->updateTransform({mLocation, static_cast<double>(size), static_cast<double>(size)});
+        mTransformIsDirty = false;
+    }
+
+    if (mMaterialIsDirty)
+    {
+        mOutlineModel->setFillColor(mStrokeColor);
+        mMaterialIsDirty = false;
+    }
+
+    mDataDirty = false;
+}
+

src/rendering/visual_elements/nodes/GridNode.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include "MaterialNode.h"
+#include "Color.h"
+
+class GridNode : public MaterialNode
+{
+
+public:
+    GridNode(const Point& location);
+
+    void setNumX(std::size_t numX);
+
+    void setNumY(std::size_t numY);
+
+    void setData(const std::vector<Color>& colors);
+
+    SceneItem* getSceneItem(std::size_t idx) const override;
+    std::size_t getNumSceneItems() const override;
+
+    void update(SceneInfo* sceneInfo) override;
+
+    void setWidth(double width);
+    void setHeight(double height);
+
+private:
+    std::size_t mNumberX{5};
+    std::size_t mNumberY{5};
+    double mWidth{1};
+    double mHeight{1};
+    bool mDataDirty = true;
+    std::vector<Color> mData;
+
+    std::unique_ptr<SceneModel> mBackgroundModel;
+    std::unique_ptr<SceneModel> mOutlineModel;
+};

src/rendering/visual_elements/nodes/MaterialNode.cpp

@@ -0,0 +1,52 @@
+#include "MaterialNode.h"
+
+#include <iostream>
+
+MaterialNode::MaterialNode(const Point& location)
+    : AbstractVisualNode(location),
+        mFillColor(Color(255, 255, 255)),
+        mStrokeColor(Color(0, 0, 0))
+{
+
+}
+
+const Color& MaterialNode::getFillColor() const
+{
+    return mFillColor;
+}
+
+const Color& MaterialNode::getStrokeColor() const
+{
+    return mStrokeColor;
+}
+
+void MaterialNode::setHasStrokeColor(bool hasStroke)
+{
+    if (mHasStrokeColor != hasStroke)
+    {
+        mHasStrokeColor = hasStroke;
+        mMaterialIsDirty = true;
+    }
+}
+
+void MaterialNode::setFillColor(const Color& color)
+{
+    mHasFillColor = true;
+
+    if (mFillColor != color)
+    {
+        mMaterialIsDirty = true;
+        mFillColor = color;       
+    }
+}
+
+void MaterialNode::setStrokeColor(const Color&  color)
+{
+    mHasStrokeColor = true;
+
+    if (mStrokeColor != color)
+    {
+        mMaterialIsDirty = true;
+        mStrokeColor = color;    
+    }
+}

src/rendering/visual_elements/nodes/MaterialNode.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "AbstractVisualNode.h"
+
+#include "Color.h"
+
+class MaterialNode : public AbstractVisualNode
+{
+public:
+    MaterialNode(const Point& location);
+
+    const Color& getFillColor() const;
+    const Color& getStrokeColor() const;
+
+    void setHasStrokeColor(bool hasStroke);
+
+    void setFillColor(const Color& color);
+    void setStrokeColor(const Color& color);
+
+protected:
+    bool mHasFillColor{ false };
+    bool mHasStrokeColor{ true };
+
+    Color mFillColor;
+    Color mStrokeColor;
+    bool mMaterialIsDirty{true};
+};

src/rendering/visual_elements/nodes/MeshNode.cpp

@@ -0,0 +1,90 @@
+#include "MeshNode.h"
+
+#include <iostream>
+
+MeshNode::MeshNode(const Point& location)
+ : MaterialNode(location)
+{
+
+}
+
+void MeshNode::setWidth(double width)
+{
+    if (mWidth != width)
+    {
+        mTransformIsDirty = true;
+        mWidth = width;
+    }
+}
+
+void MeshNode::setHeight(double height)
+{
+    if (mHeight != height)
+    {
+        mTransformIsDirty = true;
+        mHeight = height;
+    }
+}
+
+void MeshNode::setMesh(AbstractMesh* mesh)
+{
+    mWorkingMesh = mesh;
+    mMeshIsDirty = true;
+}
+
+SceneItem* MeshNode::getSceneItem(std::size_t idx) const
+{
+    return mModel.get();
+}
+
+std::size_t MeshNode::getNumSceneItems() const
+{
+    if (mWorkingMesh)
+    {
+        return 1;
+    }
+    else
+    {
+        return 0;
+    }
+}
+
+void MeshNode::update(SceneInfo* sceneInfo)
+{
+    if (!mModel || mMeshIsDirty)
+    {
+        if (!mModel)
+        {
+            mModel = std::make_unique<SceneModel>();
+            mModel->setName(mName + "_MeshModel");
+            mModel->setShowOutline(true);
+        }
+
+        if (mWorkingMesh)
+        {
+            mModel->updateMesh(mWorkingMesh);
+            mMeshIsDirty = false;
+        }
+    }
+
+    if (mWorkingMesh && mMeshIsDirty)
+    {
+        std::cout << "Updating mesh with " << mWorkingMesh->getNumNodes() << std::endl;
+        mModel->updateMesh(mWorkingMesh);
+        mMeshIsDirty = false;
+    }
+
+    if (mTransformIsDirty)
+    {
+        auto size = mHeight > mWidth ? mWidth : mHeight;
+        mModel->updateTransform({mLocation, static_cast<double>(size), static_cast<double>(size)});
+        mTransformIsDirty = false;
+    }
+
+    if (mMaterialIsDirty)
+    {
+        mModel->setFillColor(mFillColor);
+        mMaterialIsDirty = false;
+    }
+}
+

src/rendering/visual_elements/nodes/MeshNode.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "MaterialNode.h"
+
+class AbstractMesh;
+
+class MeshNode : public MaterialNode
+{
+public:
+    MeshNode(const Point& location);
+    void setMesh(AbstractMesh* mesh);
+
+    SceneItem* getSceneItem(std::size_t idx) const override;
+    std::size_t getNumSceneItems() const override;
+
+    void setWidth(double width);
+    void setHeight(double height);
+
+    void update(SceneInfo* sceneInfo) override;
+
+private:
+    bool mMeshIsDirty{true};
+    AbstractMesh* mWorkingMesh{nullptr};
+
+    double mWidth{1};
+    double mHeight{1};
+    std::unique_ptr<SceneModel> mModel;
+};

src/rendering/visual_elements/nodes/RootNode.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "AbstractVisualNode.h"
+
+class RootNode : public AbstractVisualNode
+{
+public:
+    RootNode()
+        : AbstractVisualNode(DiscretePoint(0, 0))
+    {
+
+    }
+
+};

src/rendering/visual_elements/nodes/TextNode.cpp

@@ -0,0 +1,180 @@
+#include "TextNode.h"
+
+#include "Rectangle.h"
+#include "FontsManager.h"
+#include "IFontEngine.h"
+#include "MeshPrimitives.h"
+#include "FontItem.h"
+#include "FontGlyph.h"
+#include "SceneInfo.h"
+
+#include "SceneText.h"
+
+#include "Color.h"
+
+#include "StringUtils.h"
+
+#include <iostream>
+
+TextNode::TextNode(const std::string& content, const Point& loc)
+    :   MaterialNode(loc)
+{
+    mTextData.mContent= content;
+}
+
+TextNode::~TextNode()
+{
+
+}
+
+std::unique_ptr<TextNode> TextNode::Create(const std::string& content, const Point& loc)
+{
+    return std::make_unique<TextNode>(content, loc);
+}
+
+std::string TextNode::getFontLabel() const
+{
+    return {};
+}
+
+std::string TextNode::getContent() const
+{
+    return mTextData.mContent;
+}
+
+double TextNode::getWidth() const
+{
+    return mWidth;
+}
+
+double TextNode::getHeight() const
+{
+    return mHeight;
+}
+
+void TextNode::setWidth(double width)
+{
+    if (mWidth != width)
+    {
+        mTransformIsDirty = true;
+        mWidth = width;
+    }
+}
+
+void TextNode::setHeight(double height)
+{
+    if (mHeight != height)
+    {
+        mTransformIsDirty = true;
+        mHeight = height;
+    }
+}
+
+void TextNode::setContent(const std::string& content)
+{
+    if (mTextData.mContent != content)
+    {
+        mTextData.mContent = content;
+        mContentIsDirty = true;
+    }
+}
+
+void TextNode::setFont(const FontItem& font)
+{
+    if (mTextData.mFont != font)
+    {
+        mTextData.mFont = font;
+        mContentIsDirty = true;
+    }
+}
+
+SceneItem* TextNode::getSceneItem(std::size_t idx) const
+{
+    if (idx == 0)
+    {
+        return mTextItem.get();
+    }
+    else
+    {
+        return 0;
+    }
+}
+
+std::size_t TextNode::getNumSceneItems() const
+{
+    return 1;
+}
+
+void TextNode::updateLines(FontsManager* fontsManager)
+{
+    if (!fontsManager || !fontsManager->usesGlyphs())
+    {
+        return;
+    }
+
+    auto original_count = mTextData.mLines.size();
+    std::vector<std::string> lines = StringUtils::toLines(mTextData.mContent);
+    std::vector<std::string> output_lines;
+    for (auto line : lines)
+    {
+        double running_width{0};
+        std::string working_line;
+        for (auto c : line)
+        {
+            auto glyph_advance = fontsManager->getGlyph(mTextData.mFont.getFaceName(), mTextData.mFont.getSize(), c)->getAdvanceX();
+            if (false)
+            //if (running_width + glyph_advance > mWidth)
+            {
+                output_lines.push_back(working_line);
+                working_line = c;
+                running_width = glyph_advance;
+            }
+            else
+            {
+                working_line += c;
+                running_width += glyph_advance;
+            }
+        }
+        output_lines.push_back(working_line);
+        running_width = 0;
+    }
+    mTextData.mLines = output_lines;
+
+    if (original_count != mTextData.mLines.size())
+    {
+        mLinesAreDirty = true;
+    }
+}
+
+void TextNode::update(SceneInfo* sceneInfo)
+{
+    if (!mTextItem)
+    {
+        mTextItem = std::make_unique<SceneText>();
+        mTextItem->setName(mName + "_SceneText");
+    }
+
+    if (mTransformIsDirty || mContentIsDirty)
+    {
+        updateLines(sceneInfo->mFontsManager);
+    }
+
+    if (mContentIsDirty || mLinesAreDirty)
+    {
+        dynamic_cast<SceneText*>(mTextItem.get())->setTextData(mTextData);
+        mContentIsDirty = false;
+        mLinesAreDirty = false;
+    }
+
+    if (mTransformIsDirty)
+    {
+        mTextItem->updateTransform({mLocation});
+        mTransformIsDirty = false;
+    }
+
+    if (mMaterialIsDirty)
+    {
+        mTextItem->setFillColor(mFillColor);
+        mMaterialIsDirty = false;
+    }
+}

src/rendering/visual_elements/nodes/TextNode.h

@@ -0,0 +1,53 @@
+#pragma once
+
+#include "MaterialNode.h"
+
+#include "FontItem.h"
+#include "TextData.h"
+
+#include <memory>
+#include <string>
+
+class FontsManager;
+
+class TextNode : public MaterialNode
+{
+public:
+    TextNode(const std::string& content, const Point& loc);
+
+    ~TextNode();
+
+    static std::unique_ptr<TextNode> Create(const std::string& content, const Point& loc);
+
+    std::string getContent() const;
+    std::string getFontLabel() const;
+
+    SceneItem* getSceneItem(std::size_t idx) const override;
+    std::size_t getNumSceneItems() const override;
+
+    double getWidth() const;
+    double getHeight() const;
+
+    void setWidth(double width);
+    void setHeight(double height);
+
+    void setContent(const std::string& content);
+
+    void setFont(const FontItem& font);
+
+    void update(SceneInfo* sceneInfo) override;
+private:
+
+    void updateLines(FontsManager* fontsManager);
+
+    TextData mTextData;
+    bool mContentIsDirty{true};
+    bool mLinesAreDirty{true};
+
+    double mWidth{1};
+    double mHeight{1};
+
+    std::unique_ptr<SceneItem> mTextItem;
+};
+
+using TextNodetr = std::unique_ptr<TextNode>;

src/rendering/visual_elements/nodes/TransformNode.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include "AbstractVisualNode.h"
+
+class TransformNode : public AbstractVisualNode
+{
+public:
+
+    TransformNode()
+        : AbstractVisualNode(DiscretePoint(0, 0))
+    {
+
+    }
+
+    ~TransformNode() = default;
+};