SvgWriter.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "Iterator.hpp"
#include "MeshVertex.hpp"
#include "PathVertex.hpp"
#include "ShapeVertex.hpp"
#include "Triangle.hpp"
#include "CeresEngine/Math/Math.hpp"
 
#include "CeresEngine/Foundation/SmartPtr.hpp"
#include "CeresEngine/Foundation/Container/Array.hpp"
#include "CeresEngine/Foundation/Container/Vector.hpp"
 
#include <algorithm>
#include <map>
#include <sstream>
 
namespace CeresEngine::MeshGenerator {
 
    class SvgWriter {
    private:
        class BaseElem {
        public:
            double z_;
 
            Vector3 color_;
 
            BaseElem(double z, const Vector3& color);
 
            virtual ~BaseElem();
 
            // Writes this svg element to a stream.
            virtual void stream(std::ostream&) const = 0;
        };
 
        class VertexElem : public BaseElem {
        public:
            Vector3 p_;
 
            VertexElem(const Vector3& p, const Vector3& color);
 
            virtual void stream(std::ostream& os) const override;
        };
 
        class LineElem : public BaseElem {
        public:
            Vector3 p1_, p2_;
 
            LineElem(const Vector3& p1, const Vector3& p2, const Vector3& color);
 
            virtual void stream(std::ostream& os) const override;
        };
 
        class TriangleElem : public BaseElem {
        public:
            Array<Vector3, 3> p_;
 
            TriangleElem(const Vector3& p1, const Vector3& p2, const Vector3& p3, const Vector3& color);
 
            virtual void stream(std::ostream& os) const override;
        };
 
        Vector3 project(const Vector3& p) const;
 
        Vector3 normalToColor(const Vector3& normal) const;
 
        Vector2i size_;
 
        Matrix4 viewMatrix_;
        Matrix4 projMatrix_;
        Matrix4 viewProjMatrix_;
        Vector2i viewportOrigin_;
        Vector2i viewportSize_;
 
        Vector3 lightDir_;
 
        bool cullface_;
 
        mutable Vector<UPtr<BaseElem>> elems_;
 
    public:
        SvgWriter(int width, int height);
 
        void modelView(const Matrix4& 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 Vector3& p, const Vector3& color = {0.0, 0.0, 0.0});
 
        void writeLine(const Vector3& p1, const Vector3& p2, const Vector3& color = {0.0, 0.0, 0.0});
 
        void writeTriangle(const Vector3& p1, const Vector3& p2, const Vector3& p3, const Vector3& color);
 
        void writeTriangle(const Vector3& p1, const Vector3& p2, const Vector3& p3);
 
        template<typename Shape> void writeShape(const Shape& shape, bool writeVertices = false, bool writeAxis = false) {
            Vector<ShapeVertex> vertices{};
            for(const auto& vertex : shape.vertices()) {
                vertices.push_back(vertex);
            }
 
            for(auto e : shape.edges()) {
                auto p1 = Vector3{vertices[e.vertices[0]].position, 0.0};
                auto p2 = Vector3{vertices[e.vertices[1]].position, 0.0};
 
                writeLine(p1, p2, {0.5, 0.5, 0.5});
            }
 
            if(writeAxis) {
                for(auto v : vertices) {
                    auto p1 = Vector3{v.position, 0.0};
                    auto p2 = Vector3{v.position + 0.1 * v.tangent, 0.0};
                    auto p3 = Vector3{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(Vector3{v.position, 0.0});
                }
            }
        }
 
        template<typename Path> void writePath(const Path& path, const bool writeVertices = false, const bool writeAxis = false) {
            Vector<PathVertex> 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, const bool writeVertices = false, const bool writeNormals = false) {
            Vector<MeshVertex> vertices{};
            for(const MeshVertex& vertex : mesh.vertices()) {
                vertices.push_back(vertex);
            }
 
            for(Triangle 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 CeresEngine::MeshGenerator