RepeatMesh.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 "MeshVertex.hpp"
#include "Triangle.hpp"
#include "Utility.hpp"
 
namespace CeresEngine::MeshGenerator {
 
    template<typename Mesh> class RepeatMesh {
    public:
        class Triangles {
        public:
            [[nodiscard]] bool done() const noexcept { return mIndex >= mRepeatMesh->mInstances; }
 
            [[nodiscard]] Triangle generate() const {
                Triangle temp = mTriangles.generate();
                temp.vertices += mDelta;
                return temp;
            }
 
            void next() noexcept {
                mTriangles.next();
 
                if(mTriangles.done()) {
                    ++mIndex;
                    mDelta += mRepeatMesh->mVertexCount;
                    mTriangles = mRepeatMesh->mMesh.triangles();
                }
            }
 
        private:
            const RepeatMesh* mRepeatMesh;
 
            typename TriangleGeneratorType<Mesh>::Type mTriangles;
 
            int mIndex;
 
            int mDelta;
 
            explicit Triangles(const RepeatMesh* repeatMesh) noexcept
                    : mRepeatMesh{repeatMesh},
                      mTriangles{repeatMesh->mMesh.triangles()}, mIndex{repeatMesh->mVertexCount > 0 ? 0 : repeatMesh->mInstances}, mDelta{0} {}
 
            int countTriangles() const noexcept {
                if(mRepeatMesh->mInstances < 1)
                    return 0;
 
                return count(mRepeatMesh->mMesh.triangles()) * (mRepeatMesh->mInstances - mIndex - 1) + count(mTriangles);
            }
 
            friend int count(const Triangles& generator) noexcept { return generator.countTriangles(); }
 
            friend class RepeatMesh;
        };
 
        class Vertices {
        public:
            [[nodiscard]] bool done() const noexcept { return mIndex >= mRepeatMesh->mInstances; }
 
            [[nodiscard]] MeshVertex generate() const {
                MeshVertex temp = mVertices.generate();
                temp.position += mDelta;
                return temp;
            }
 
            void next() {
                mVertices.next();
 
                if(mVertices.done()) {
                    ++mIndex;
                    mDelta += mRepeatMesh->mDelta;
                    mVertices = mRepeatMesh->mMesh.vertices();
                }
            }
 
        private:
            explicit Vertices(const RepeatMesh* repeatMesh)
                    : mRepeatMesh{repeatMesh}, mVertices{repeatMesh->mMesh.vertices()}, mIndex{repeatMesh->mVertexCount > 0 ? 0 : repeatMesh->mInstances}, mDelta{} {
            }
 
            const RepeatMesh* mRepeatMesh;
 
            typename VertexGeneratorType<Mesh>::Type mVertices;
 
            int mIndex;
 
            Vector3 mDelta;
 
            int countVertices() const noexcept {
                if(mRepeatMesh->mInstances < 1)
                    return 0;
 
                return mRepeatMesh->mVertexCount * (mRepeatMesh->mInstances - mIndex - 1) + count(mVertices);
            }
 
            friend int count(const Vertices& generator) noexcept { return generator.countVertices(); }
 
            friend class RepeatMesh;
        };
 
        explicit RepeatMesh(Mesh mesh, const int instances, const Vector3& delta) noexcept
                : mMesh{std::move(mesh)}, mInstances{instances}, mDelta{delta}, mVertexCount{count(mMesh.vertices())} {}
 
        [[nodiscard]] Triangles triangles() const noexcept { return Triangles{this}; }
 
        [[nodiscard]] Vertices vertices() const noexcept { return Vertices{this}; }
 
    private:
        Mesh mMesh;
 
        int mInstances;
 
        Vector3 mDelta;
 
        int mVertexCount;
    };
 
    template<typename Mesh> RepeatMesh<Mesh> repeatMesh(Mesh mesh, int instances, const Vector3& delta) noexcept {
        return RepeatMesh<Mesh>{std::move(mesh), instances, delta};
    }
 
} // namespace CeresEngine::MeshGenerator