SubdivideMesh.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 "Edge.hpp"
#include "MeshVertex.hpp"
#include "Triangle.hpp"
#include "Utility.hpp"
 
#include "CeresEngine/Foundation/Container/Map.hpp"
#include "CeresEngine/Foundation/Container/Vector.hpp"
 
namespace CeresEngine::MeshGenerator {
 
    template<typename Mesh, int Iterations> class SubdivideMesh {
        static_assert(Iterations > 0, "Iterations must be greater than zero!");
 
    private:
        using Impl = SubdivideMesh<SubdivideMesh<Mesh, Iterations - 1>, 1>;
        Impl mSubdivideMesh;
 
    public:
        SubdivideMesh(Mesh mesh) : mSubdivideMesh{SubdivideMesh<Mesh, Iterations - 1>{std::move(mesh)}} {}
 
        using Triangles = typename Impl::Triangles;
        [[nodiscard]] Triangles triangles() const noexcept { return mSubdivideMesh.triangles(); }
 
        using Vertices = typename Impl::Vertices;
        [[nodiscard]] Vertices vertices() const noexcept { return mSubdivideMesh.vertices(); }
    };
 
    template<typename Mesh> class SubdivideMesh<Mesh, 0> {
    private:
        using Impl = Mesh;
        Impl mMesh;
 
    public:
        SubdivideMesh(Mesh mesh) : mMesh{std::move(mesh)} {}
 
        using Triangles = typename Impl::Triangles;
        [[nodiscard]] Triangles triangles() const noexcept { return mMesh.triangles(); }
 
        using Vertices = typename Impl::Vertices;
        [[nodiscard]] Vertices vertices() const noexcept { return mMesh.vertices(); }
    };
 
    template<typename Mesh> class SubdivideMesh<Mesh, 1> {
    public:
        class Triangles {
        public:
            [[nodiscard]] bool done() const noexcept { return mTriangles.done(); }
 
            [[nodiscard]] Triangle generate() const {
                if(i_ == 0)
                    triangle_ = mTriangles.generate();
 
                if(i_ == 3) {
                    return Triangle{{vertexFromEdge(triangle_.vertices[0], triangle_.vertices[1]), vertexFromEdge(triangle_.vertices[1], triangle_.vertices[2]),
                        vertexFromEdge(triangle_.vertices[2], triangle_.vertices[0])}};
                }
 
                const int j = (i_ + 1) % 3;
                const int k = (i_ + 2) % 3;
                return Triangle{{triangle_.vertices[i_], vertexFromEdge(triangle_.vertices[i_], triangle_.vertices[j]),
                    vertexFromEdge(triangle_.vertices[k], triangle_.vertices[i_])}};
            }
 
            void next() {
                ++i_;
                if(i_ == 4) {
                    i_ = 0;
                    mTriangles.next();
                }
            }
 
        private:
            const SubdivideMesh* mMesh;
 
            int i_;
 
            typename TriangleGeneratorType<Mesh>::Type mTriangles;
 
            mutable Triangle triangle_;
 
            Triangles(const SubdivideMesh& mesh) : mMesh{&mesh}, i_{0}, mTriangles{mesh.mMesh.triangles()}, triangle_{} {}
 
            int vertexFromEdge(int a, int b) const {
                if(a > b)
                    std::swap(a, b);
                return static_cast<int>(mMesh->mVertexCache.size()) + mMesh->edgeMap_.at({a, b});
            }
 
            friend class SubdivideMesh;
        };
 
        class Vertices {
        public:
            [[nodiscard]] bool done() const noexcept { return vertexIndex_ == mMesh->mVertexCache.size() && edgeIndex_ == mMesh->edgeCache_.size(); }
 
            [[nodiscard]] MeshVertex generate() const {
                if(vertexIndex_ < mMesh->mVertexCache.size())
                    return mMesh->mVertexCache[vertexIndex_];
 
                const MeshVertex& v1 = mMesh->mVertexCache[mMesh->edgeCache_[edgeIndex_].vertices[0]];
                const MeshVertex& v2 = mMesh->mVertexCache[mMesh->edgeCache_[edgeIndex_].vertices[1]];
 
                MeshVertex vertex;
                vertex.position = mix(v1.position, v2.position, 0.5);
                vertex.texCoord = mix(v1.texCoord, v2.texCoord, 0.5);
                vertex.normal = normalize(mix(v1.normal, v2.normal, 0.5));
                return vertex;
            }
 
            void next() {
                if(vertexIndex_ < mMesh->mVertexCache.size())
                    ++vertexIndex_;
                else
                    ++edgeIndex_;
            }
 
        private:
            const SubdivideMesh* mMesh;
 
            int edgeIndex_;
            int vertexIndex_;
 
            Vertices(const SubdivideMesh& mesh) : mMesh{&mesh}, edgeIndex_{0}, vertexIndex_{0} {}
 
            friend class SubdivideMesh;
        };
 
        SubdivideMesh(Mesh mesh) : mMesh{std::move(mesh)} {
            for(const MeshVertex& vertex : mMesh.vertices()) {
                mVertexCache.push_back(vertex);
            }
 
            for(const Triangle& triangle : mMesh.triangles()) {
                for(int i = 0; i < 3; ++i) {
                    const int j = (i + 1) % 3;
 
                    Edge e{{triangle.vertices[i], triangle.vertices[j]}};
                    if(e.vertices[0] > e.vertices[1])
                        std::swap(e.vertices[0], e.vertices[1]);
 
                    if(edgeMap_.find(e.vertices) == edgeMap_.end()) {
                        edgeMap_[e.vertices] = static_cast<int>(edgeCache_.size());
                        edgeCache_.push_back(e);
                    }
                }
            }
        }
 
        [[nodiscard]] Triangles triangles() const noexcept { return *this; }
 
        [[nodiscard]] Vertices vertices() const noexcept { return *this; }
 
    private:
        Mesh mMesh;
 
        Vector<Edge> edgeCache_;
 
        Map<Vector2i, int> edgeMap_;
 
        Vector<MeshVertex> mVertexCache;
    };
 
} // namespace CeresEngine::MeshGenerator