SubdividePath.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 "PathVertex.hpp"
#include "ShapeVertex.hpp"
#include "Utility.hpp"
 
#include "CeresEngine/Foundation/Container/Vector.hpp"
 
namespace CeresEngine::MeshGenerator {
 
    template<typename Path> class SubdividePath {
    public:
        class Edges {
        public:
            [[nodiscard]] bool done() const noexcept { return mEdges.done(); }
 
            [[nodiscard]] Edge generate() const {
                Edge edge_ = mEdges.generate();
 
                if(i_ % 2 == 0)
                    return Edge{{edge_.vertices[0], static_cast<int>(mPath->mVertexCache.size()) + i_ / 2}};
 
                return Edge{{static_cast<int>(mPath->mVertexCache.size()) + i_ / 2, edge_.vertices[1]}};
            }
 
            void next() {
                ++i_;
                if(i_ % 2 == 0)
                    mEdges.next();
            }
 
        private:
            const SubdividePath* mPath;
 
            typename EdgeGeneratorType<Path>::Type mEdges;
 
            int i_;
 
            Edges(const SubdividePath& path) : mPath{&path}, mEdges{path.mPath.edges()}, i_{0} {}
 
            friend class SubdividePath;
        };
 
        class Vertices {
        public:
            [[nodiscard]] bool done() const noexcept { return vertexIndex_ == mPath->mVertexCache.size() && mEdges.done(); }
 
            PathVertex generate() const {
                if(vertexIndex_ < mPath->mVertexCache.size())
                    return mPath->mVertexCache[vertexIndex_];
 
                const Edge edge = mEdges.generate();
                const PathVertex& v1 = mPath->mVertexCache[edge.vertices[0]];
                const PathVertex& v2 = mPath->mVertexCache[edge.vertices[1]];
 
                PathVertex vertex;
                vertex.position = mix(v1.position, v2.position, 0.5);
                vertex.tangent = normalize(mix(v1.tangent, v2.tangent, 0.5));
                vertex.normal = normalize(mix(v1.normal, v2.normal, 0.5));
                vertex.texCoord = 0.5 * v1.texCoord + 0.5 * v2.texCoord;
                return vertex;
            }
 
            void next() {
                if(vertexIndex_ < mPath->mVertexCache.size())
                    ++vertexIndex_;
                else
                    mEdges.next();
            }
 
        private:
            const SubdividePath* mPath;
 
            int vertexIndex_;
 
            typename EdgeGeneratorType<Path>::Type mEdges;
 
            Vertices(const SubdividePath& path) : mPath{&path}, vertexIndex_{0}, mEdges{path.mPath.edges()} {}
 
            friend class SubdividePath;
        };
 
        SubdividePath(Path path) : mPath(std::move(path)), mVertexCache{} {
            for(const PathVertex& vertex : mPath.vertices()) {
                mVertexCache.push_back(vertex);
            }
        }
 
        [[nodiscard]] Edges edges() const { return *this; }
 
        [[nodiscard]] Vertices vertices() const { return *this; }
 
    private:
        Path mPath;
 
        Vector<PathVertex> mVertexCache;
    };
 
    template<typename Path> SubdividePath<Path> subdividePath(Path path) { return SubdividePath<Path>{std::move(path)}; }
 
} // namespace CeresEngine::MeshGenerator