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