svg_writer.hpp

Go to the documentation of this file.

#ifndef GENERATOR_SVG_HPP
#define GENERATOR_SVG_HPP
 
#include <algorithm>
#include <array>
#include <map>
#include <memory>
#include <sstream>
#include <vector>
 
#include "math.hpp"
 
#include "iterator.hpp"
#include "mesh_vertex.hpp"
#include "path_vertex.hpp"
#include "shape_vertex.hpp"
#include "triangle.hpp"
 
namespace generator
{
 
class svg_writer_t
{
private:
    class BaseElem
    {
    public:
        double z_;
 
        gml::dvec3 color_;
 
        BaseElem(double z, const gml::dvec3& color);
 
        virtual ~BaseElem();
 
        // Writes this svg element to a stream.
        virtual void stream(std::ostream&) const = 0;
    };
 
    class VertexElem : public BaseElem
    {
    public:
        gml::dvec3 p_;
 
        VertexElem(const gml::dvec3& p, const gml::dvec3& color);
 
        virtual void stream(std::ostream& os) const override;
    };
 
    class LineElem : public BaseElem
    {
    public:
        gml::dvec3 p1_, p2_;
 
        LineElem(const gml::dvec3& p1, const gml::dvec3& p2, const gml::dvec3& color);
 
        virtual void stream(std::ostream& os) const override;
    };
 
    class TriangleElem : public BaseElem
    {
    public:
        std::array<gml::dvec3, 3> p_;
 
        TriangleElem(const gml::dvec3& p1, const gml::dvec3& p2, const gml::dvec3& p3, const gml::dvec3& color);
 
        virtual void stream(std::ostream& os) const override;
    };
 
    gml::dvec3 project(const gml::dvec3& p) const;
 
    gml::dvec3 normalToColor(const gml::dvec3& normal) const;
 
    gml::ivec2 size_;
 
    gml::dmat4 viewMatrix_;
    gml::dmat4 projMatrix_;
    gml::dmat4 viewProjMatrix_;
    gml::ivec2 viewportOrigin_;
    gml::ivec2 viewportSize_;
 
    gml::dvec3 lightDir_;
 
    bool cullface_;
 
    mutable std::vector<std::unique_ptr<BaseElem>> elems_;
 
public:
    svg_writer_t(int width, int height);
 
    void modelView(const gml::dmat4& matrix);
 
    void perspective(double fovy, double aspect, double zNear, double zFar);
 
    void ortho(double left, double right, double bottom, double top);
 
    void viewport(int x, int y, int width, int height);
 
    void cullface(bool cullface);
 
    void writePoint(const gml::dvec3& p, const gml::dvec3& color = {0.0, 0.0, 0.0});
 
    void writeLine(const gml::dvec3& p1, const gml::dvec3& p2, const gml::dvec3& color = {0.0, 0.0, 0.0});
 
    void writeTriangle(const gml::dvec3& p1, const gml::dvec3& p2, const gml::dvec3& p3, const gml::dvec3& color);
 
    void writeTriangle(const gml::dvec3& p1, const gml::dvec3& p2, const gml::dvec3& p3);
 
    template<typename shape_t>
    void writeShape(const shape_t& shape, bool writeVertices = false, bool writeAxis = false)
    {
        std::vector<shape_vertex_t> vertices{};
        for(const auto& vertex : shape.vertices())
        {
            vertices.push_back(vertex);
        }
 
        for(auto e : shape.edges())
        {
            auto p1 = gml::dvec3{vertices[e.vertices[0]].position, 0.0};
            auto p2 = gml::dvec3{vertices[e.vertices[1]].position, 0.0};
 
            writeLine(p1, p2, {0.5, 0.5, 0.5});
        }
 
        if(writeAxis)
        {
            for(auto v : vertices)
            {
                auto p1 = gml::dvec3{v.position, 0.0};
                auto p2 = gml::dvec3{v.position + 0.1 * v.tangent, 0.0};
                auto p3 = gml::dvec3{v.position + 0.1 * v.normal(), 0.0};
 
                writeLine(p1, p2, {0.0, 1.0, 0.0});
                writeLine(p1, p3, {1.0, 0.0, 0.0});
            }
        }
 
        if(writeVertices)
        {
            for(auto v : shape.vertices())
            {
                writePoint(gml::dvec3{v.position, 0.0});
            }
        }
    }
 
    template<typename Path>
    void writePath(const Path& path, bool writeVertices = false, bool writeAxis = false)
    {
        std::vector<path_vertex_t> vertices{};
        for(const auto& temp : path.vertices())
        {
            vertices.push_back(temp);
        }
 
        if(writeAxis)
        {
            for(const auto& v : path.vertices())
            {
                writeLine(v.position, v.position + 0.1 * v.tangent, {0.0, 0.0, 1.0});
                writeLine(v.position, v.position + 0.1 * v.normal, {1.0, 0.0, 0.0});
                writeLine(v.position, v.position + 0.1 * v.binormal(), {0.0, 1.0, 0.0});
            }
        }
 
        if(writeVertices)
        {
            for(const auto& v : path.vertices())
            {
                writePoint(v.position + 0.001 * v.normal);
            }
        }
 
        for(const auto& e : path.edges())
        {
            writeLine(vertices[e.vertices[0]].position, vertices[e.vertices[1]].position);
        }
    }
 
    template<typename Mesh>
    void writeMesh(const Mesh& mesh, bool writeVertices = false, bool writeNormals = false)
    {
        std::vector<mesh_vertex_t> vertices{};
        for(const mesh_vertex_t& vertex : mesh.vertices())
        {
            vertices.push_back(vertex);
        }
 
        for(triangle_t t : mesh.triangles())
        {
            writeTriangle(vertices[t.vertices[0]].position,
                          vertices[t.vertices[1]].position,
                          vertices[t.vertices[2]].position);
        }
 
        if(writeVertices)
        {
            for(const auto& v : vertices)
            {
                writePoint(v.position);
            }
        }
 
        // Normals
        if(writeNormals)
        {
            for(const auto& v : vertices)
            {
                writeLine(v.position, v.position + 0.1 * v.normal, {0.0, 0.0, 1.0});
            }
        }
    }
 
    std::string str() const;
};
} // namespace generator
 
#endif