ExtrudeMesh.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 "Iterator.hpp"
#include "MeshVertex.hpp"
#include "PathVertex.hpp"
#include "ShapeVertex.hpp"
#include "Triangle.hpp"
 
namespace CeresEngine::MeshGenerator {
 
    template<typename Shape, typename Path> class ExtrudeMesh {
    public:
        class Triangles {
        public:
            [[nodiscard]] Triangle generate() const {
                Triangle triangle;
 
                const auto& shapeEdge = mShapeEdges.generate();
                const auto& pathEdge = mPathEdges.generate();
 
                if(odd_ == 0) {
                    triangle.vertices[0] = shapeEdge.vertices[0] + pathEdge.vertices[0] * mMesh->mShapeVertexCount;
                    triangle.vertices[1] = shapeEdge.vertices[1] + pathEdge.vertices[1] * mMesh->mShapeVertexCount;
                    triangle.vertices[2] = shapeEdge.vertices[0] + pathEdge.vertices[1] * mMesh->mShapeVertexCount;
                } else {
                    triangle.vertices[0] = shapeEdge.vertices[0] + pathEdge.vertices[0] * mMesh->mShapeVertexCount;
                    triangle.vertices[1] = shapeEdge.vertices[1] + pathEdge.vertices[0] * mMesh->mShapeVertexCount;
                    triangle.vertices[2] = shapeEdge.vertices[1] + pathEdge.vertices[1] * mMesh->mShapeVertexCount;
                }
 
                return triangle;
            }
 
            [[nodiscard]] bool done() const noexcept { return mPathEdges.done(); }
 
            void next() {
                odd_ = !odd_;
 
                if(odd_) {
                    mShapeEdges.next();
                    if(mShapeEdges.done()) {
                        mPathEdges.next();
                        mShapeEdges = mMesh->mShape.edges();
                    }
                }
            }
 
        private:
            const ExtrudeMesh* mMesh;
 
            decltype(mMesh->mShape.edges()) mShapeEdges;
            decltype(mMesh->mPath.edges()) mPathEdges;
            bool odd_;
 
            Triangles(const ExtrudeMesh& mesh) : mMesh{&mesh}, mShapeEdges{mesh.mShape.edges()}, mPathEdges{mesh.mPath.edges()}, odd_{true} {}
 
            friend class ExtrudeMesh;
        };
 
        class Vertices {
        public:
            [[nodiscard]] MeshVertex generate() const {
                MeshVertex vertex;
 
                const auto& shapeVertex = mShapeVertices.generate();
                const auto& pathVertex = mPathVertices.generate();
 
                Vector3 pathBinormal = pathVertex.binormal();
                vertex.position = pathVertex.position + shapeVertex.position[0] * pathVertex.normal + shapeVertex.position[1] * pathBinormal;
 
                Vector2 shapeNormal = shapeVertex.normal();
                vertex.normal = shapeNormal[0] * pathVertex.normal + shapeNormal[1] * pathBinormal;
 
                vertex.texCoord[0] = shapeVertex.texCoord;
                vertex.texCoord[1] = pathVertex.texCoord;
 
                return vertex;
            }
 
            [[nodiscard]] bool done() const noexcept { return mPathVertices.done(); }
 
            void next() {
                mShapeVertices.next();
                if(mShapeVertices.done()) {
                    mPathVertices.next();
                    mShapeVertices = mMesh->mShape.vertices();
                }
            }
 
        private:
            const ExtrudeMesh* mMesh;
            decltype(mMesh->mShape.vertices()) mShapeVertices;
            decltype(mMesh->mPath.vertices()) mPathVertices;
 
            Vertices(const ExtrudeMesh& mesh) : mMesh{&mesh}, mShapeVertices{mesh.mShape.vertices()}, mPathVertices{mesh.mPath.vertices()} {}
 
            friend class ExtrudeMesh;
        };
 
        [[nodiscard]] Triangles triangles() const noexcept { return *this; }
        [[nodiscard]] Vertices vertices() const noexcept { return *this; }
 
        ExtrudeMesh(Shape shape, Path path) : mShape{std::move(shape)}, mPath{std::move(path)}, mShapeVertexCount{count(mShape.vertices())} {}
 
    private:
        Shape mShape;
        Path mPath;
        int mShapeVertexCount;
    };
 
    template<typename Shape, typename Path> ExtrudeMesh<Shape, Path> extrudeMesh(Shape shape, Path path) {
        return ExtrudeMesh<Shape, Path>{std::move(shape), std::move(path)};
    }
 
} // namespace CeresEngine::MeshGenerator