syncbuffer.hpp

Go to the documentation of this file.

/*
 * Author: Sven Gothel <sgothel@jausoft.com>
 * Copyright Gothel Software e.K.
 *
 * SPDX-License-Identifier: MIT
 *
 * This Source Code Form is subject to the terms of the MIT License
 * If a copy of the MIT was not distributed with this file,
 * you can obtain one at https://opensource.org/license/mit/.
 */
 
#ifndef JAU_MATH_UTIL_SYNCBUFFER_HPP_
#define JAU_MATH_UTIL_SYNCBUFFER_HPP_
 
#include <cmath>
#include <cstdarg>
#include <cassert>
 
#include <jau/float_types.hpp>
#include <jau/functional.hpp>
#include <jau/math/mat4f.hpp>
#include <jau/type_concepts.hpp>
 
namespace jau::math::util {
 
    /** \addtogroup Math
     *
     *  @{
     */
 
    /**
     * Specific data synchronization action implemented by the data provider
     * to update the buffer with the underlying data before usage, e.g. uploading the `GLUniformData` data to the GPU.
     */
    typedef jau::function<void()> sync_action_t;
 
    /** Plain function pointer type matching sync_action_t */
    typedef void(*sync_action_fptr)();
 
    /**
     * Convenient tuple of a sync_action_t and data buffer.
     *
     * sync_action_t is used to update the data buffer in case it is derived
     * or must be otherwise transported, defined by the data provider.
     */
    class SyncBuffer {
      public:
        virtual ~SyncBuffer() noexcept = default;
 
        /** Return the defined sync_action_t */
        virtual sync_action_t& action() noexcept = 0;
 
        /** Return the underlying data buffer as bytes w/o sync action(). */
        virtual const void* data() const noexcept = 0;
 
        /** Return the underlying data buffer as bytes after invoking sync action(). */
        const void* syncedData() noexcept { action()(); return data(); }
 
        /** Returns type signature of implementing class's stored component value type. */
        virtual const jau::type_info& compSignature() const noexcept = 0;
 
        /** The component's size in bytes */
        // virtual size_t bytesPerComp() const noexcept = 0;
 
        /** The number of components per element */
        // virtual size_t compsPerElem() const noexcept = 0;
 
        /** Returns element count. One element consist compsPerElem() components. */
        // virtual size_t elementCount() const noexcept = 0;
 
        /** Returns the byte size of all elements, i.e. elementCount() * compsPerElem() * bytesPerComp(). */
        // virtual size_t byteCount() const noexcept = 0;
 
        /**
         * Synchronizes the underlying data before usage.
         * <p>
         * Convenient shortcut for action()() plus chaining.
         * </p>
         */
        SyncBuffer& sync() noexcept { action()(); return *this; }
 
        virtual std::string toString() const = 0;
    };
 
    /** SyncBuffer interface with multiple underlying Matrix4. */
    template <jau::req::packed_floating_point Value_type>
    class SyncMatrices4 : public SyncBuffer {
      public:
        typedef Value_type               value_type;
        typedef Matrix4<value_type>      Mat4;
 
      private:
        const Mat4 &m_mat;
        size_t m_count;
        sync_action_t m_sync;
 
      public:
        SyncMatrices4(const Mat4 &first, size_t count, sync_action_t s = sync_action_t())
        : m_mat(first), m_count(count), m_sync(std::move(s)) {}
 
        /** Return the underlying Mat4 pointer, used to synchronize via action() to the buffer(). */
        constexpr const Mat4* matrices() const noexcept { return &m_mat; }
        /** Return the number of Mat4 referenced by matrices() */
        constexpr size_t matrixCount() const noexcept { return m_count; }
 
        /** Return the underlying float data buffer. */
        constexpr const value_type* floats() const noexcept { return m_mat.cbegin(); }
 
        sync_action_t& action() noexcept override { return m_sync; }
        const void* data() const noexcept override { return floats(); }
 
        /** Returns the component's value_type signature */
        const jau::type_info& compSignature() const noexcept override { return jau::static_ctti<value_type>(); }
        /** The component's size in bytes */
        constexpr size_t bytesPerComp() const noexcept { return sizeof(value_type); }
        /** The number of components per element */
        constexpr size_t compsPerElem() const noexcept { return 16; }
        /** Returns element count. One element consist compsPerElem() components. */
        constexpr size_t elementCount() const noexcept { return matrixCount(); }
        /** Returns the byte size of all elements, i.e. elementCount() * compsPerElem() * bytesPerComp(). */
        constexpr size_t byteCount() const noexcept { return matrixCount() * 16 * bytesPerComp(); }
 
        std::string toString() const override {
            return std::string("SyncMatrices4[").append(compSignature().name())
                   .append(", count ").append(std::to_string(elementCount()))
                   .append(" elem x ").append(std::to_string(compsPerElem()))
                   .append(" comp x ").append(std::to_string(bytesPerComp()))
                   .append(" = ").append(std::to_string(byteCount())).append(" bytes]");
        }
 
    };
    typedef SyncMatrices4<float> SyncMats4f;
 
 /**@}*/
 
 } // namespace jau::math::util
 
 #endif // JAU_MATH_UTIL_SYNCBUFFER_HPP_