MeshBuilder.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 "CeresEngine/DataTypes.hpp"
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Container/Vector.hpp"
 
#include "CeresEngine/Mesh/Mesh.hpp"
 
namespace CeresEngine {
 
    template<typename V, typename I = UInt32> class TriangleMeshBuilder {
    public:
        Vector<V> vertices;
        Vector<I> indices;
        Vector<SubMesh> subMeshes;
 
    public:
        explicit TriangleMeshBuilder() { subMeshes.emplace_back(); }
 
    public:
        void addTriangle(const V& v0, const V& v1, const V& v2) {
            vertices.emplace_back(v0);
            vertices.emplace_back(v1);
            vertices.emplace_back(v2);
 
            addTriangleIndices(UInt32(indices.size() - 3), UInt32(indices.size() - 2), UInt32(indices.size() - 1));
        }
 
        void addTriangleIndices(UInt32 v0, UInt32 v1, UInt32 v2) {
            SubMesh& currentSubMesh = getLatestSubMesh();
            indices.emplace_back(v0);
            indices.emplace_back(v1);
            indices.emplace_back(v2);
            currentSubMesh.indexCount += VertexCount(3);
        }
 
        void addTriangleStrip(const V& v) {
            SubMesh& currentSubMesh = getLatestSubMesh();
 
            vertices.emplace_back(v);
            if(currentSubMesh.indexCount >= 3) { // on the second triangle we do this
                const UInt32 i = currentSubMesh.indexCount / 3;
                if(i % 2 == 1) {
                    addTriangleIndices(UInt32(vertices.size() - 3), UInt32(vertices.size() - 1), UInt32(vertices.size() - 2));
                } else {
                    addTriangleIndices(UInt32(vertices.size() - 3), UInt32(vertices.size() - 2), UInt32(vertices.size() - 1));
                }
                currentSubMesh.indexCount += 3;
            } else {
                indices.emplace_back(UInt32(vertices.size() - 1));
                currentSubMesh.indexCount += 1;
            }
        }
 
        void addTriangleFan(const V& v) {
            SubMesh& currentSubMesh = getLatestSubMesh();
 
            vertices.emplace_back(v);
            if(currentSubMesh.indexCount >= 3) { // on the second triangle we do this
                indices.emplace_back(indices[currentSubMesh.indexOffset]);
                indices.emplace_back(UInt32(vertices.size() - 2));
                indices.emplace_back(UInt32(vertices.size() - 1));
                currentSubMesh.indexCount += 3;
            } else {
                indices.emplace_back(UInt32(vertices.size() - 1));
                currentSubMesh.indexCount += 1;
            }
        }
 
        UInt32 nextSubMesh() {
            const SubMesh& currentSubMesh = getLatestSubMesh();
            if(currentSubMesh.indexCount == 0) {
                return UInt32(subMeshes.size() - 1);
            }
 
            CE_ASSERT(indices.size() % 3 == 0);
            CE_ASSERT(currentSubMesh.indexCount % 3 == 0);
 
            SubMesh& newSubMesh = subMeshes.emplace_back();
            newSubMesh.indexOffset = UInt32(indices.size()); // next-vertex!
            newSubMesh.indexCount = 0;
            return UInt32(subMeshes.size() - 1);
        }
 
        [[nodiscard]] const SubMesh& getCurrentSubMesh() const { return subMeshes.back(); }
 
        void validate() {
            for(const UInt32 index : indices) {
                (void)index;
                CE_ASSERT(index < vertices.size());
            }
        }
 
    private:
        SubMesh& getLatestSubMesh() { return subMeshes.back(); }
    };
 
} // namespace CeresEngine