ScenePaintEngine.h

Go to the documentation of this file.

#pragma once
#include "DLLInfo.h"
#if NDEVR_VIEWPORT
#include <NDEVR/QTTools.h>
#include <NDEVR/Material.h>
#include <NDEVR/Model.h>
#include <NDEVR/Geometry.h>
#include <NDEVR/ShapeConstructors.h>
#include <NDEVR/TextConstructor.h>
#include <QTextItem>
#include <QScreen>
#include <QSize>
#include <QPaintEngine>
namespace NDEVR
{
    class ScenePaintEngine;
    class WidgetIterator;
    class DesignObjectLookup;
    class NDEVR_API ScenePaintDevice : public QPaintDevice
    {
    public:
        ScenePaintDevice(Model& model);
        virtual QPaintEngine* paintEngine() const override;
        void setRoot(Model& model);
        virtual int metric(PaintDeviceMetric metric) const override
        {
            switch (metric)
            {
            case PdmWidth: return 1024;
            case PdmHeight: return 1024;
            case PdmWidthMM: return 1024;
            case PdmHeightMM: return 1024;
            case PdmNumColors: return INT_MAX;
            case PdmDepth: return 1;
            case PdmDpiX: return m_dpi[X];
            case PdmDpiY: return m_dpi[Y];
            case PdmPhysicalDpiX: return m_physical_dpi[X];
            case PdmPhysicalDpiY: return m_physical_dpi[Y];
            case PdmDevicePixelRatio: return m_device_pixel_ratio;
            case PdmDevicePixelRatioScaled: return m_device_pixel_ratio_scaled;
            }
            return 0;
        }
        void setPhysicalDPI(int dpi_x, int dpi_y) { m_physical_dpi = { dpi_x , dpi_y }; }
        void setDevicePixelRatio(int ratio) { m_device_pixel_ratio = ratio; }
        void setDevicePixelRatioScaled(int ratio) { m_device_pixel_ratio_scaled = ratio; }
        void setDPI(int dpi) { m_dpi = dpi; }
        void setDPIX(int dpi) { m_dpi[X] = dpi; }
        void setDPIY(int dpi) { m_dpi[Y] = dpi; }
        ScenePaintEngine* scenePaintEngine() { return m_paint_engine; }
 
        void drawWidget(QWidget* widget, QPainter& painter, QPoint offset, uint04 depth);
    protected:
        Vector<2, int> m_dpi = {1024, 1024};
        Vector<2, int> m_physical_dpi = { 1024, 1024 };
        int m_device_pixel_ratio = 1;
        int m_device_pixel_ratio_scaled = 1;
        QWidget* m_widget = nullptr;
        ScenePaintEngine* m_paint_engine;
        Time m_last_update_update;
    };
    class NDEVR_API ScenePaintEngine : public QPaintEngine
    {
    public:
        ScenePaintEngine();
        explicit ScenePaintEngine(Model& scene);
        virtual ~ScenePaintEngine()
        {}
        static void AutoWidgetsToPDF(File file, WidgetIterator reports, QSize size = QSize(), bool send_file = false);
        static Buffer<QSize> WidgetsToModel(const WidgetIterator& reports, Model& model, QSize size = QSize(), bool is_flat = false);
        static void PrepareWidgetsToModel(const Buffer<QWidget*>& widgets, QSize size = QSize());
        static Buffer<UUID> PrepareWidgetsViews(DesignObjectLookup& lookup, const WidgetIterator& reports, QSize size = QSize());
        static Buffer<UUID> PrepareWidgetsViews(DesignObjectLookup& lookup, const Buffer<QWidget*>& widgets, QSize size = QSize());
        static void WidgetsToPDF(const File& file, const Buffer<QWidget*>& widgets, QSize size = QSize());
        static void ModelsToPDF(const File& file, DesignObjectLookup& lookup, const Buffer<UUID>& camera_ids, fltp08 dpi);
        void updateClipping(Model& model);
        void setCurrentName(const String& current_name);
        
        
        void setRoot(Model& new_root);
        virtual bool begin(QPaintDevice*) override
        {
            return true;
        }
        virtual bool end() override
        {
            return true;
        }
        void pushModel();
        void popModel();
        void resetExtraDepth();
        virtual void updateState(const QPaintEngineState& state) override;
 
        template<class t_type>
        void drawRectsT(const t_type* rect, int rect_count)
        {
            Model model = m_models.last().createChild();
            setupShapeModel(model);
            Geometry geo = model.createChildGeometry();
            if (!m_is_flat)
                geo.setProperty(DesignObject::e_name, "RectsT");
            geo.setTransform(getTransform(false));
            geo.setGeometryType(GeometryType::e_convex_polygons);
            geo.setupVertexTable(0, Geometry::VertexMode::e_cartesian_3F);
            for (uint04 i = 0; i < cast<uint04>(rect_count); i++)
            {
                ShapeConstructors::Rectangle(geo, Matrix<fltp08>::OffsetMatrix(
                    Vertex<3, fltp08>(rect->center().x(), rect->center().y(), 0.0))
                    .scale(Vector<3, fltp08>(rect->width() / 2.0, rect->height() / 2.0, 1.0)));
            }
            geo.autoCalculateIndices(PrimitiveProperty::Solid);
            geo.updateModifiedTime();
            finishShape(true);
        }
        virtual void drawRects(const QRect* rects, int rectCount) override
        {
            drawRectsT(rects, rectCount);
        }
        virtual void drawRects(const QRectF* rects, int rectCount) override
        {
            drawRectsT(rects, rectCount);
        }
        template<class t_type>
        void drawLinesT(const t_type* lines, int line_count)
        {
            Model model = m_models.last().createChild();
            setupShapeModel(model);
            Geometry geo = model.createChildGeometry();
            if (!m_is_flat)
                geo.setProperty(DesignObject::e_name, "LinesT");
            geo.setTransform(getTransform(false));
            geo.setGeometryType(GeometryType::e_linework);
            geo.setPrimitiveMode(PrimitiveProperty::Solid, PrimitiveMode::e_lines);
            geo.setPrimitiveMode(PrimitiveProperty::Outline, PrimitiveMode::e_lines);
            geo.setupVertexTable(0, Geometry::VertexMode::e_cartesian_3F);
            uint04 primitive_start = geo.addPrimitives(PrimitiveProperty::Outline, cast<uint04>(line_count));
            uint04 vertex_start = geo.addVertices(cast<uint04>(line_count) * 2);
            for (uint04 i = 0; i < cast<uint04>(line_count); i++)
            {
                geo.setVertex(VertexProperty::Position, vertex_start + 2 * i, Vertex<3, fltp08>(lines[i].x1(), lines[i].y1(), 0.0));
                geo.setVertex(VertexProperty::Position, vertex_start + 2 * i + 1, Vertex<3, fltp08>(lines[i].x2(), lines[i].y2(), 0.0));
                geo.setPrimitive(PrimitiveProperty::Outline, primitive_start + i, vertex_start + Vector<2, uint04>(2 * i, 2 * i + 1));
            }
            geo.autoCalculateIndices(PrimitiveProperty::Solid);
            geo.updateModifiedTime();
            finishShape(false);
        }
        virtual void drawLines(const QLine* lines, int line_count) override
        {
            drawLinesT<QLine>(lines, line_count);
        }
        virtual void drawLines(const QLineF* lines, int line_count) override
        {
            drawLinesT<QLineF>(lines, line_count);
        }
        
        template<class t_type>
        void drawEllipseT(const t_type& r)
        {
            if (r.width() == 0 || r.height() == 0)
            {
                if (r.width() == 0 && r.height() == 0)
                {
                    QPointF p(r.center().x(), r.center().y());
                    drawPoints(&p, 1);
                }
                else if (r.width() == 0)
                {
                    QPointF p1(r.center().x(), r.center().y() - r.height() / 2.0);
                    QPointF p2(r.center().x(), r.center().y() + r.height() / 2.0);
                    QLineF l(p1, p2);
                    drawLines(&l, 1);
                }
                else if (r.height() == 0)
                {
                    QPointF p1(r.center().x() - r.width() / 2.0, r.center().y());
                    QPointF p2(r.center().x() + r.width() / 2.0, r.center().y());
                    QLineF l(p1, p2);
                    drawLines(&l, 1);
                }
                return;
            }
            Model model = m_models.last().createChild();
            setupShapeModel(model);
 
            Geometry geo = model.createChildGeometry();
            if (!m_is_flat)
                geo.setProperty(DesignObject::e_name, "EllipseT");
            geo.setTransform(getTransform(false));
            geo.setGeometryType(GeometryType::e_convex_polygons);
            geo.setupVertexTable(0, Geometry::VertexMode::e_cartesian_3F);
            ShapeConstructors::Circle(geo, Matrix<fltp08>::OffsetMatrix(Vertex<3, fltp08>(r.center().x(), r.center().y(), 0.0))
                .scale(Vector<3, fltp08>(r.width() / 2.0, r.height() / 2.0, 1.0)));
            geo.autoCalculateIndices(PrimitiveProperty::Solid);
            finishShape(true);
        }
        virtual void drawEllipse(const QRectF& r) override
        {
            drawEllipseT(r);
        }
        virtual void drawEllipse(const QRect& r) override
        {
            drawEllipseT(r);
        }
        static QPalette ScenePalette();
        static QStyle* SceneStyle();
        virtual void drawPath(const QPainterPath& path) override;
        template<class t_type>
        void drawPointsT(const t_type* points, int point_count)
        {
            Model model = m_models.last().createChild();
            setupShapeModel(model, false);
 
            Geometry geo = model.createChildGeometry();
            geo.setTransform(getTransform(false));
            geo.setGeometryType(GeometryType::e_points);
            if (!m_is_flat)
                geo.setProperty(DesignObject::e_name, "PointsT");
            geo.setupVertexTable(0, Geometry::VertexMode::e_cartesian_3F);
            uint04 vertex_start = geo.addVertices(cast<uint04>(point_count));
            for (uint04 i = 0; i < cast<uint04>(point_count); i++)
            {
                geo.setVertex(VertexProperty::Position, vertex_start + i, Vertex<3, fltp08>(points[i].x(), points[i].y(), 0.0));
            }
            geo.autoCalculateIndices(PrimitiveProperty::Solid);
            finishShape(false);
        }
        virtual void drawPoints(const QPointF* points, int point_count) override
        {
            drawPointsT(points, point_count);
        }
        virtual void drawPoints(const QPoint* points, int point_count) override
        {
            drawPointsT(points, point_count);
        }
        template<class t_type>
        void drawPolygonT(const t_type * points, int point_count, PolygonDrawMode mode)
        {
            if (point_count <= 0)
                return;
            Model model = m_is_clipping ? m_models.last() : m_models.last().createChild();
            if(!m_is_clipping)
                setupShapeModel(model, mode != PolygonDrawMode::PolylineMode);
 
            Geometry geo = model.createChildGeometry();
            if(!m_is_flat)
                geo.setProperty(DesignObject::e_name, "PolygonT");
            geo.setTransform(getTransform(false));
            if (mode == PolygonDrawMode::ConvexMode)
                geo.setGeometryType(GeometryType::e_convex_polygons);
            else if (mode == PolygonDrawMode::PolylineMode)
                geo.setGeometryType(GeometryType::e_linework);
            else
                geo.setGeometryType(GeometryType::e_concave_polygons);
            
            Polygon<fltp08> poly(point_count);
            for (uint04 i = 0; i < cast<uint04>(point_count); i++)
            {
                poly.add(Vertex<2, fltp08>(points[i].x(), points[i].y()));
            }
            poly.simplify();
            geo.setupVertexTable(poly.vertexCount(), Geometry::VertexMode::e_cartesian_3F);
            geo.addPrimitives(PrimitiveProperty::Outline, poly.vertexCount() + 1);
            for (uint04 i = 0; i < poly.vertexCount(); i++)
            {
                geo.setVertex(VertexProperty::Position, i, poly.vertex(i).as<3, fltp08>(0.0));
                geo.setPrimitive(PrimitiveProperty::Outline, i, i);
            }
            geo.setPrimitive(PrimitiveProperty::Outline, poly.vertexCount(), 0);
            if(!m_is_clipping)
                geo.autoCalculateIndices(PrimitiveProperty::Solid);
            geo.setGeometryProperty(Geometry::e_is_clipping_geo, m_is_clipping);
            finishShape(true);
        }
        virtual void drawPolygon(const QPointF* points, int point_count, PolygonDrawMode mode) override
        {
            drawPolygonT(points, point_count, mode);
        }
        virtual void drawPolygon(const QPoint* points, int point_count, PolygonDrawMode mode) override
        {
            drawPolygonT(points, point_count, mode);
        }
 
        virtual void drawPixmap(const QRectF& r, const QPixmap& pm, const QRectF& sr) override
        {
            QImage image = pm.toImage();
            drawImage(r, image, sr);
            
        }
        virtual void drawTextItem(const QPointF& p, const QTextItem& text_item) override;
        virtual void drawTiledPixmap(const QRectF& r, const QPixmap& pixmap, const QPointF& s) override
        {
            drawImage(r, pixmap.toImage(), QRectF(s, QSizeF(1.0, 1.0)));
        }
        virtual void drawImage(const QRectF& r, const QImage& image, const QRectF& sr, Qt::ImageConversionFlags flags = Qt::AutoColor) override;
        virtual Type type() const override
        {
            return Type::User;
        }
        static PaintEngineFeatures SceneRenderFeatures();
        void finishShape(bool is_solid);
        Matrix<fltp08> getTransform(bool is_text) const;
        void setupShapeModel(Model& model, bool has_solid = true, bool is_text = false);
        Material currentMaterial(PrimitiveProperty property, bool is_text);
        void setIsFlat(bool is_flat) { m_is_flat = is_flat; };
        bool isFlat() const { return m_is_flat; }
        Material createCurrentMaterial(PrimitiveProperty property, bool is_text);
        [[nodiscard]] bool hasOutline() const;
        [[nodiscard]] bool hasSolid() const;
        fltp08 currentThickness() const
        {
            return state->pen().widthF();
        }
        RGBColor currentFillColor() const
        {
            return QTTools::convert(state->brush().color());
        }
        RGBColor currentOutlineColor() const
        {
            return QTTools::convert(state->pen().color());
        }
        const Model& root() const
        {
            return m_root;
        }
    protected:
        String m_current_image;
        Dictionary<UUID, Material> m_materials;
#if NDEVR_TEXT_MODEL
        Dictionary<String, DynamicPointer<TextConstructor>> m_text_constructors;
#endif
        Model m_root;
        Buffer<Model> m_models;
        uint04 m_extra_depth = 0;
        uint04 m_geometry_depth = 0;
        bool m_is_clipping;
        bool m_is_flat = false;
    };
}
#endif