RepeatPath.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 "Utility.hpp"
 
namespace CeresEngine::MeshGenerator {
 
    template<typename Path> class RepeatPath {
    public:
        class Edges {
        public:
            [[nodiscard]] bool done() const noexcept { return mIndex >= mRepeatPath->mInstances; }
 
            [[nodiscard]] Edge generate() const {
                Edge temp = mEdges.generate();
                temp.vertices += mDelta;
                return temp;
            }
 
            void next() noexcept {
                mEdges.next();
 
                if(mEdges.done()) {
                    ++mIndex;
                    mDelta += mRepeatPath->mVertexCount;
                    mEdges = mRepeatPath->mPath.edges();
                }
            }
 
        private:
            const RepeatPath* mRepeatPath;
 
            typename EdgeGeneratorType<Path>::Type mEdges;
            int mIndex;
            int mDelta;
 
            explicit Edges(const RepeatPath* repeatPath) noexcept
                    : mRepeatPath{repeatPath}, mEdges{repeatPath->mPath.edges()}, mIndex{repeatPath->mVertexCount > 0 ? 0 : repeatPath->mInstances}, mDelta{0} {}
 
            friend class RepeatPath;
        };
 
        class Vertices {
        public:
            [[nodiscard]] bool done() const noexcept { return mIndex >= mRepeatPath->mInstances; }
 
            PathVertex generate() const {
                PathVertex temp = mVertices.generate();
                temp.position += mDelta;
                return temp;
            }
 
            void next() {
                mVertices.next();
 
                if(mVertices.done()) {
                    ++mIndex;
                    mDelta += mRepeatPath->mDelta;
                    mVertices = mRepeatPath->mPath.vertices();
                }
            }
 
        private:
            explicit Vertices(const RepeatPath* repeatPath)
                    : mRepeatPath{repeatPath}, mVertices{repeatPath->mPath.vertices()}, mIndex{repeatPath->mVertexCount > 0 ? 0 : repeatPath->mInstances}, mDelta{} {
            }
 
            const RepeatPath* mRepeatPath;
            typename VertexGeneratorType<Path>::Type mVertices;
            int mIndex;
            Vector3 mDelta;
 
            int countVertices() const noexcept {
                if(mRepeatPath->mInstances < 1)
                    return 0;
 
                return mRepeatPath->mVertexCount * (mRepeatPath->mInstances - mIndex - 1) + count(mVertices);
            }
 
            friend int count(const Vertices& generator) noexcept { return generator.countVertices(); }
 
            friend class RepeatPath;
        };
 
        explicit RepeatPath(Path path, const int instances, const Vector3& delta) noexcept
                : mPath{std::move(path)}, mInstances{instances}, mDelta{delta}, mVertexCount{count(mPath.vertices())} {}
 
        [[nodiscard]] Edges edges() const noexcept { return Edges{this}; }
        [[nodiscard]] Vertices vertices() const noexcept { return Vertices{this}; }
 
    private:
        Path mPath;
        int mInstances;
        Vector3 mDelta;
        int mVertexCount;
    };
 
    template<typename Path> RepeatPath<Path> repeatPath(Path path, int instances, const Vector3& delta) noexcept {
        return RepeatPath<Path>{std::move(path), instances, delta};
    }
 
} // namespace CeresEngine::MeshGenerator