RepeatShape.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 "ShapeVertex.hpp"
#include "Utility.hpp"
 
namespace CeresEngine::MeshGenerator {
 
    template<typename Shape> class RepeatShape {
    public:
        class Edges {
        public:
            [[nodiscard]] bool done() const noexcept { return mIndex >= mRepeatShape->mInstances; }
 
            [[nodiscard]] Edge generate() const {
                Edge temp = mEdges.generate();
                temp.vertices += mDelta;
                return temp;
            }
 
            void next() noexcept {
                mEdges.next();
 
                if(mEdges.done()) {
                    ++mIndex;
                    mDelta += mRepeatShape->mVertexCount;
                    mEdges = mRepeatShape->mShape.edges();
                }
            }
 
        private:
            const RepeatShape* mRepeatShape;
 
            typename EdgeGeneratorType<Shape>::Type mEdges;
 
            int mIndex;
 
            int mDelta;
 
            explicit Edges(const RepeatShape* repeatShape) noexcept
                    : mRepeatShape{repeatShape}, mEdges{repeatShape->mShape.edges()}, mIndex{repeatShape->mVertexCount > 0 ? 0 : repeatShape->mInstances}, mDelta{
                                                                                                                                                               0} {}
 
            int countEdges() const noexcept {
                if(mRepeatShape->mInstances < 1)
                    return 0;
 
                return count(mRepeatShape->mShape.edges()) * (mRepeatShape->mInstances - mIndex - 1) + count(mEdges);
            }
 
            friend int count(const Edges& generator) noexcept { return generator.countEdges(); }
 
            friend class RepeatShape;
        };
 
        class Vertices {
        public:
            [[nodiscard]] bool done() const noexcept { return mIndex >= mRepeatShape->mInstances; }
 
            ShapeVertex generate() const {
                ShapeVertex temp = mVertices.generate();
                temp.position += mDelta;
                return temp;
            }
 
            void next() {
                mVertices.next();
 
                if(mVertices.done()) {
                    ++mIndex;
                    mDelta += mRepeatShape->mDelta;
                    mVertices = mRepeatShape->mShape.vertices();
                }
            }
 
        private:
            explicit Vertices(const RepeatShape* repeatShape)
                    : mRepeatShape{repeatShape}, mVertices{repeatShape->mShape.vertices()}, mIndex{repeatShape->mVertexCount > 0 ? 0 : repeatShape->mInstances},
                      mDelta{} {}
 
            const RepeatShape* mRepeatShape;
 
            typename VertexGeneratorType<Shape>::Type mVertices;
 
            int mIndex;
 
            Vector2 mDelta;
 
            int countVertices() const noexcept {
                if(mRepeatShape->mInstances < 1)
                    return 0;
 
                return mRepeatShape->mVertexCount * (mRepeatShape->mInstances - mIndex - 1) + count(mVertices);
            }
 
            friend int count(const Vertices& generator) noexcept { return generator.countVertices(); }
 
            friend class RepeatShape;
        };
 
        explicit RepeatShape(Shape shape, const int instances, const Vector2& delta) noexcept
                : mShape{std::move(shape)}, mInstances{instances}, mDelta{delta}, mVertexCount{count(mShape.vertices())} {}
 
        [[nodiscard]] Edges edges() const noexcept { return Edges{this}; }
 
        [[nodiscard]] Vertices vertices() const noexcept { return Vertices{this}; }
 
    private:
        Shape mShape;
 
        int mInstances;
 
        Vector2 mDelta;
 
        int mVertexCount;
    };
 
    template<typename Shape> RepeatShape<Shape> repeatShape(Shape shape, int instances, const Vector2& delta) noexcept {
        return RepeatShape<Shape>{std::move(shape), instances, delta};
    }
 
} // namespace CeresEngine::MeshGenerator