spk_mesh.hpp

#pragma once
 
#include "structure/design_pattern/spk_cached_data.hpp"
#include "structure/design_pattern/spk_contract_provider.hpp"
#include "structure/geometry/spk_polygon.hpp"
#include "structure/opengl/spk_buffer_set_object.hpp"
 
#include <cstdint>
#include <memory>
#include <utility>
#include <vector>
 
namespace spk
{
    template <typename TVertex>
    class IMesh
    {
    public:
        using Polygon = IPolygon<TVertex>;
        using EditionContract = ContractProvider::Contract;
        using EditionJob = ContractProvider::Job;
 
    private:
        std::vector<Polygon> _shapes;
        mutable std::shared_ptr<spk::OpenGL::BufferSetObject> _bufferSet;
        mutable bool _bufferSetConfigured = false;
        mutable bool _needsSynchronization = true;
 
        struct Cache
        {
            std::vector<TVertex> vertices;
            std::vector<uint32_t> indexes;
        };
 
        CachedData<Cache> _cache;
        mutable ContractProvider _onEditionContractProvider;
 
        std::pair<std::size_t, std::size_t> _computeTotals() const
        {
            std::size_t totalVertices = 0;
            std::size_t totalIndices = 0;
 
            for (const auto &polygon : _shapes)
            {
                const std::size_t n = polygon.points.size();
                totalVertices += n;
 
                if (n >= 3)
                {
                    totalIndices += (n - 2) * 3;
                }
            }
 
            return {totalVertices, totalIndices};
        }
 
        void _appendPolygon(const Polygon &p_polygon, Cache &p_cache) const
        {
            const std::size_t vertexCount = p_polygon.points.size();
            if (vertexCount < 3)
            {
                return;
            }
 
            const uint32_t startIndex = static_cast<uint32_t>(p_cache.vertices.size());
 
            p_cache.vertices.insert(p_cache.vertices.end(), p_polygon.points.begin(), p_polygon.points.end());
 
            switch (p_polygon.order)
            {
            case PolygonOrder::TriangleFanFromFirst:
                _emitTriangleFanIndices(startIndex, vertexCount, p_cache.indexes);
                break;
 
            case PolygonOrder::TriangleStrip:
                _emitTriangleStripIndices(startIndex, vertexCount, p_cache.indexes);
                break;
            }
        }
 
        static void _emitTriangleFanIndices(uint32_t p_startIndex, std::size_t p_vertexCount, std::vector<uint32_t> &p_indices)
        {
            for (uint32_t i = 1; i + 1 < p_vertexCount; ++i)
            {
                p_indices.push_back(p_startIndex);
                p_indices.push_back(p_startIndex + i);
                p_indices.push_back(p_startIndex + i + 1);
            }
        }
 
        static void _emitTriangleStripIndices(uint32_t p_startIndex, std::size_t p_vertexCount, std::vector<uint32_t> &p_indices)
        {
            for (uint32_t i = 0; i + 2 < p_vertexCount; ++i)
            {
                if ((i % 2) == 0)
                {
                    p_indices.push_back(p_startIndex + i);
                    p_indices.push_back(p_startIndex + i + 1);
                    p_indices.push_back(p_startIndex + i + 2);
                }
                else
                {
                    p_indices.push_back(p_startIndex + i + 1);
                    p_indices.push_back(p_startIndex + i);
                    p_indices.push_back(p_startIndex + i + 2);
                }
            }
        }
 
        Cache _updateCache() const
        {
            Cache cache;
 
            const auto [totalVertices, totalIndices] = _computeTotals();
            cache.vertices.reserve(totalVertices);
            cache.indexes.reserve(totalIndices);
 
            for (const auto &polygon : _shapes)
            {
                _appendPolygon(polygon, cache);
            }
 
            return cache;
        }
 
        void _synchronize() const
        {
            if (_bufferSet == nullptr)
            {
                return;
            }
 
            if (_bufferSetConfigured == false)
            {
                _configureBufferSet();
                _bufferSetConfigured = true;
            }
 
            _bufferSet->vbo().setVertices(vertices());
            _bufferSet->ibo().setIndexes(indexes());
        }
 
        virtual void _configureBufferSet() const = 0;
 
    public:
        IMesh() :
            _bufferSet(std::make_shared<spk::OpenGL::BufferSetObject>(spk::OpenGL::BufferObject::Usage::Dynamic)),
            _cache([this]() {
                return _updateCache();
            })
        {
        }

        IMesh(const IMesh &p_other) :
            _shapes(p_other._shapes),
            _bufferSet(std::make_shared<spk::OpenGL::BufferSetObject>(spk::OpenGL::BufferObject::Usage::Dynamic)),
            _bufferSetConfigured(false),
            _needsSynchronization(true),
            _cache([this]() {
                return _updateCache();
            }),
            _onEditionContractProvider()
        {
        }

        IMesh &operator=(const IMesh &p_other)
        {
            if (this != &p_other)
            {
                _shapes = p_other._shapes;
                _bufferSet = std::make_shared<spk::OpenGL::BufferSetObject>(spk::OpenGL::BufferObject::Usage::Dynamic);
                _bufferSetConfigured = false;
                _needsSynchronization = true;
                _cache.configure([this]() {
                    return _updateCache();
                });
                _onEditionContractProvider = ContractProvider{};
            }
            return *this;
        }

        IMesh(IMesh &&p_other) noexcept :
            _shapes(std::move(p_other._shapes)),
            _bufferSet(std::move(p_other._bufferSet)),
            _bufferSetConfigured(p_other._bufferSetConfigured),
            _needsSynchronization(p_other._needsSynchronization),
            _cache([this]() {
                return _updateCache();
            }),
            _onEditionContractProvider(std::move(p_other._onEditionContractProvider))
        {
            _cache.release();
        }

        IMesh &operator=(IMesh &&p_other) noexcept
        {
            if (this != &p_other)
            {
                _shapes = std::move(p_other._shapes);
                _bufferSet = std::move(p_other._bufferSet);
                _bufferSetConfigured = p_other._bufferSetConfigured;
                _needsSynchronization = p_other._needsSynchronization;
                _onEditionContractProvider = std::move(p_other._onEditionContractProvider);
                _cache.configure([this]() {
                    return _updateCache();
                });
            }
            return *this;
        }
 
        virtual ~IMesh() = default;

        void clear()
        {
            _shapes.clear();
            _cache.release();
            _needsSynchronization = true;
            _onEditionContractProvider.trigger();
        }

        void append(const Polygon &p_shape)
        {
            _shapes.push_back(p_shape);
            _cache.release();
            _needsSynchronization = true;
            _onEditionContractProvider.trigger();
        }

        EditionContract subscribeToEdition(const EditionJob &p_job) const
        {
            return (std::move(_onEditionContractProvider.subscribe(p_job)));
        }

        const std::vector<TVertex> &vertices() const
        {
            return (_cache.get().vertices);
        }

        const std::vector<Polygon> &polygons() const
        {
            return (_shapes);
        }

        const std::vector<uint32_t> &indexes() const
        {
            return (_cache.get().indexes);
        }

        IMesh &operator+=(const IMesh &p_other)
        {
            if (p_other._shapes.empty())
            {
                return *this;
            }
 
            _shapes.insert(_shapes.end(), p_other._shapes.begin(), p_other._shapes.end());
            _cache.release();
            _needsSynchronization = true;
            _onEditionContractProvider.trigger();
            return *this;
        }

        const std::shared_ptr<spk::OpenGL::BufferSetObject> &bufferSet() const
        {
            return _bufferSet;
        }

        void synchronize() const
        {
            if (_needsSynchronization == false)
            {
                return;
            }
 
            _synchronize();
            _needsSynchronization = false;
        }

        IMesh fuze(const IMesh &p_other) const
        {
            IMesh result(*this);
            result += p_other;
            return result;
        }

        friend IMesh operator+(const IMesh<TVertex> &p_lhs, const IMesh<TVertex> &p_rhs)
        {
            p_lhs += p_rhs;
            return p_lhs;
        }
    };
}