LatheMesh.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 "Axis.hpp"
#include "MeshVertex.hpp"
#include "ShapeVertex.hpp"
#include "Triangle.hpp"
 
#include <memory>
#include <vector>
 
namespace CeresEngine::MeshGenerator {
 
    template<typename Shape> class LatheMesh {
    public:
        class Triangles {
        public:
            [[nodiscard]] Triangle generate() const {
                Triangle triangle;
 
                const auto& shapeEdge = mShapeEdges.generate();
 
                int slice = i_ / 2;
 
                const int delta = mMesh->mSlices + 1;
 
                if(i_ % 2 == 0) {
                    triangle.vertices[0] = shapeEdge.vertices[0] * delta + slice;
                    triangle.vertices[1] = shapeEdge.vertices[1] * delta + slice;
                    triangle.vertices[2] = shapeEdge.vertices[1] * delta + slice + 1;
                } else {
                    triangle.vertices[0] = shapeEdge.vertices[0] * delta + slice;
                    triangle.vertices[1] = shapeEdge.vertices[1] * delta + slice + 1;
                    triangle.vertices[2] = shapeEdge.vertices[0] * delta + slice + 1;
                }
 
                return triangle;
            }
 
            [[nodiscard]] bool done() const noexcept { return mShapeEdges.done(); }
 
            void next() {
                ++i_;
                if(i_ == 2 * mMesh->mSlices) {
                    i_ = 0;
                    mShapeEdges.next();
                }
            }
 
        private:
            const LatheMesh* mMesh;
 
            decltype(mMesh->mShape.edges()) mShapeEdges;
 
            int i_;
 
            Triangles(const LatheMesh& mesh) : mMesh{&mesh}, mShapeEdges{mesh.mShape.edges()}, i_{0} {}
 
            friend class LatheMesh;
        };
 
        class Vertices {
        public:
            [[nodiscard]] MeshVertex generate() const {
                MeshVertex vertex;
 
                const auto shapeVertex = mShapeVertices.generate();
                const Vector2 normal = shapeVertex.normal();
 
                const double deltaAngle = mMesh->sweep_ / mMesh->mSlices;
                double angle = i_ * deltaAngle + mMesh->start_;
 
                const Quaternion q = qrotate(angle, mMesh->axis_);
 
                vertex.position = Math::transform(q, Vector3{shapeVertex.position[0], shapeVertex.position[1], 0.0});
 
                vertex.normal = Math::transform(q, Vector3{normal[0], normal[1], 0.0});
 
                vertex.texCoord[0] = shapeVertex.texCoord;
                vertex.texCoord[1] = angle / mMesh->sweep_;
 
                return vertex;
            }
 
            [[nodiscard]] bool done() const noexcept { return mShapeVertices.done(); }
 
            void next() {
                ++i_;
 
                if(i_ == mMesh->mSlices + 1) {
                    i_ = 0;
                    mShapeVertices.next();
                }
            }
 
        private:
            const LatheMesh* mMesh;
 
            decltype(mMesh->mShape.vertices()) mShapeVertices;
 
            int i_;
 
            Vertices(const LatheMesh& mesh) : mMesh{&mesh}, mShapeVertices{mesh.mShape.vertices()}, i_{0} {}
 
            friend class LatheMesh;
        };
 
        LatheMesh(Shape shape, const Vector2& axis, const int slices = 32, const double start = 0.0, const double sweep = radians(360.0))
                : axis_{axis, 0.0}, mShape{std::move(shape)}, mSlices{slices}, start_{start}, sweep_{sweep} {}
 
        [[nodiscard]] Triangles triangles() const noexcept { return *this; }
        [[nodiscard]] Vertices vertices() const noexcept { return *this; }
 
    private:
        Vector3 axis_;
        Shape mShape;
        int mSlices;
        double start_;
        double sweep_;
    };
 
    template<typename Shape> LatheMesh<Shape> lathe(Shape shape, Axis axis = Axis::X, int slices = 32, double start = 0.0, double sweep = radians(360.0)) {
        return LatheMesh<Shape>{std::move(shape), axis, slices, start, sweep};
    }
 
} // namespace CeresEngine::MeshGenerator