GraphicsBuffer.h

Go to the documentation of this file.

/*--------------------------------------------------------------------------------------------
Copyright (c) 2019, NDEVR LLC
tyler.parke@ndevr.org
  __    __   ____     _____ __     __  _______
 |  \  |  | |  __ \  |  ___|\ \   / / |   __  \
 |   \ |  | | |  \ \ | |___  \ \ / /  |  |__)  |
 |  . \|  | | |__/ / | |___   \ V /   |   _   /
 |  |\    |_|_____/__|_____|___\_/____|  | \  \
 |__| \__________________________________|  \__\
 
Subject to the terms of the Enterprise+ Agreement, NDEVR hereby grants
Licensee a limited, non-exclusive, non-transferable, royalty-free license
(without the right to sublicense) to use the API solely for the purpose of
Licensee's internal development efforts to develop applications for which
the API was provided.
 
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
 
Library: Graphics
File: GraphicsBuffer
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include "DLLInfo.h"
#include "Database/Headers/TableColumn.h"
 
namespace NDEVR
{
    class GraphicsBuffer : public TableColumn
    {
    public:
        enum Type
        {
              VERTEX
            , UNIFORM
            , INDEX
            , INSTANCE
        };
 
    public:
        NDEVR_GRAPHICS_API GraphicsBuffer(const String& label);
        NDEVR_GRAPHICS_API GraphicsBuffer(GraphicsBuffer&& buffer) noexcept;
 
        
        virtual void cleanup() = 0;
        virtual void setAccessable(bool is_accessable, bool copy_existing)
        {
            if (m_allocated_size == 0)
            {
                m_is_accessable = is_accessable;
                return;
            }
            if (m_is_accessable == is_accessable)
                return;
            if (!is_accessable)
                sendToVideoCard(copy_existing);
            else
                getFromVideoCard(copy_existing);
            m_is_accessable = is_accessable;
        }
 
        bool isAccessable() const { return m_is_accessable; };
        void setUsage(Type type)
        {
            m_internal_type = type;
        }
        virtual void compress(BinaryCompressionObject& object) override
        {
            UNUSED(object);
        }
        virtual void mapToFile(BinaryFile& file, BinaryCompressionObject& object) override
        {
            UNUSED(file);
            UNUSED(object);
        }
        virtual void mapToFile(BinaryFile& file, int compression) override
        {
            UNUSED(file);
            UNUSED(compression);
        }
        virtual void mapFromFile(BinaryFile& file, uint08 version_number) override
        {
            UNUSED(file);
            UNUSED(version_number);
        }
        [[nodiscard]] bool isSame(uint04 index, const String& value) const override { UNUSED(index); UNUSED(value); return false; }
        [[nodiscard]] bool isSame(uint04 index, const char* value) const override { UNUSED(index); UNUSED(value); return false; }
        [[nodiscard]] bool contains(uint04 index, const String& value, bool ignore_case) const override { UNUSED(index); UNUSED(value); UNUSED(ignore_case); return false; }
        [[nodiscard]] bool contains(uint04 index, const char* value, bool ignore_case) const override { UNUSED(index); UNUSED(value); UNUSED(ignore_case); return false; }
        [[nodiscard]] bool beginsWith(uint04 index, const String& value, bool ignore_case) const override { UNUSED(index); UNUSED(value); UNUSED(ignore_case); return false; }
        [[nodiscard]] bool beginsWith(uint04 index, const char* value, bool ignore_case) const override { UNUSED(index); UNUSED(value); UNUSED(ignore_case); return false; }
        virtual TableColumn* getSelected(const Buffer<bool>&) const override { return nullptr; }
        template<class t_type_a, class t_type_b>
        void move(void* memory, const t_type_b& value) const
        {
            t_type_a new_value = cast<t_type_a>(value);
            memcpy(memory, &new_value, sizeof(t_type_a));
        }
 
        template<class t_type_a, class t_type_b>
        void move(t_type_b& value, void* memory) const
        {
            t_type_a new_value;
            memcpy(&new_value, memory, sizeof(t_type_a));
            value = cast<t_type_b>(new_value);
        }
 
        template<class t_type_a>
        void move(void* memory, const String& value) const
        {
            t_type_a new_value = value.getAs<t_type_a>();
            memcpy(memory, &new_value, sizeof(t_type_a));
        }
 
        template<class t_type_a, class t_type_b>
        void get(void* memory, t_type_b& value)
        {
            t_type_a new_value;
            memcpy(&new_value, memory, sizeof(t_type_a));
            value = cast<t_type_b>(new_value);
        }
 
        template<class t_type_a>
        void get(void* memory, String& value)
        {
            t_type_a new_value;
            memcpy(&new_value, memory, sizeof(t_type_a));
            value = String(new_value);
        }
 
        template<class t_type>
        void setMemory(uint04 index, uint04 vector_pos, const t_type& value)
        {
            lib_assert(m_is_accessable, "Tried to edit unaccessible vertex");
            void* temp_value = mapMemory(index * type().total_size + vector_pos * type().byte_size, type().total_size);
            setMemory(temp_value, value);
            unmapMemory();
        }
 
        template<class t_type>
        void setMemory(void* temp_value, const t_type& value)
        {
            switch (type().byte_size)
            {
            case 1:
                if (type().is_unsigned)
                    move<uint01>(temp_value, value);
                else
                    move<sint01>(temp_value, value);
                break;
            case 2:
                if (type().is_unsigned)
                    move<uint02>(temp_value, value);
                else
                    move<sint02>(temp_value, value);
                break;
            case 4:
                if (type().is_float)
                    move<fltp04>(temp_value, value);
                else if (type().is_unsigned)
                    move<uint04>(temp_value, value);
                else
                    move<sint04>(temp_value, value);
                break;
            case 8:
                if (type().is_float)
                    move<fltp08>(temp_value, value);
                else if (type().is_unsigned)
                    move<uint08>(temp_value, value);
                else
                    move<sint08>(temp_value, value);
                break;
            default:
                lib_assert(false, "Bad type");
            }
        }
 
        template<class t_type>
        void setMemory(const t_type* data_to_insert, uint04 offset, uint04 size)
        {
            lib_assert(m_is_accessable, "Tried to edit unaccessible vertex");
            switch (type().byte_size)
            {
            case 1:
                if (type().is_unsigned)
                    _setRawData<uint01, t_type>(data_to_insert, offset, size);
                else
                    _setRawData<sint01, t_type>(data_to_insert, offset, size);
                break;
            case 2:
                if (type().is_unsigned)
                    _setRawData<uint02, t_type>(data_to_insert, offset, size);
                else
                    _setRawData<sint02, t_type>(data_to_insert, offset, size);
                break;
            case 4:
                if (type().is_float)
                    _setRawData<fltp04, t_type>(data_to_insert, offset, size);
                else if (type().is_unsigned)
                    _setRawData<uint04, t_type>(data_to_insert, offset, size);
                else
                    _setRawData<sint04, t_type>(data_to_insert, offset, size);
                break;
            case 8:
                if (type().is_float)
                    _setRawData<fltp08, t_type>(data_to_insert, offset, size);
                else if (type().is_unsigned)
                    _setRawData<uint08, t_type>(data_to_insert, offset, size);
                else
                    _setRawData<sint08, t_type>(data_to_insert, offset, size);
                break;
            case 16:
                if (type().is_float)
                    _setRawData<fltp04, t_type>(data_to_insert, offset, size);
                else if (type().is_unsigned)
                    _setRawData<uint04, t_type>(data_to_insert, offset, size);
                else
                    _setRawData<sint04, t_type>(data_to_insert, offset, size);
                break;
            default:
                lib_assert(false, "unknown type");
            }
            lib_assert(m_is_accessable, "Tried to edit unaccessible vertex");
        }
 
        template<class t_type>
        void getMemory(uint04 index, uint04 vector_pos, t_type& value) const
        {
            lib_assert(m_is_accessable, "Tried to edit unaccessible vertex");
            void* temp_value = mapMemory(index * type().total_size + vector_pos * type().byte_size, type().byte_size);
            switch (type().byte_size)
            {
            case 1:
                if (type().is_unsigned)
                    move<uint01>(value, temp_value);
                else
                    move<sint01>(value, temp_value);
                break;
            case 2:
                if (type().is_unsigned)
                    move<uint02>(value, temp_value);
                else
                    move<sint02>(value, temp_value);
                break;
            case 4:
                if (type().is_float)
                    move<fltp04>(value, temp_value);
                else if (type().is_unsigned)
                    move<uint04>(value, temp_value);
                else
                    move<sint04>(value, temp_value);
                break;
            case 8:
                if (type().is_float)
                    move<fltp08>(value, temp_value);
                else if (type().is_unsigned)
                    move<uint08>(value, temp_value);
                else
                    move<sint08>(value, temp_value);
                break;
            default:
                lib_assert(false, "Bad type");
            }
            unmapMemory();
            lib_assert(m_is_accessable, "Tried to edit unaccessible vertex");
        }
        template<class t_type>
        void setRawMemory(uint04 index, const t_type& value)
        {
            lib_assert(m_is_accessable, "Tried to edit unaccessible vertex");
            void* temp_value = mapMemory(index * type().total_size, type().total_size);
            move<t_type>(temp_value, value);
            unmapMemory();
        }
        template<class t_type>
        void getMemory(uint04 index, t_type& value) const
        {
            getMemory(index, 0, value);
        }
        template<class t_type>
        void setMemory(uint04 index, const t_type& value)
        {
            setMemory(index, 0, value);
        }
 
        void set(uint04 index, uint04 vector_pos, bool value) final override { setMemory(index, vector_pos, value); };
        void set(uint04 index, uint04 vector_pos, uint01 value) final override { setMemory(index, vector_pos, value); };
        void set(uint04 index, uint04 vector_pos, uint02 value) final override { setMemory(index, vector_pos, value); };
        void set(uint04 index, uint04 vector_pos, uint04 value) final override { setMemory(index, vector_pos, value); };
        void set(uint04 index, uint04 vector_pos, uint08 value) final override { setMemory(index, vector_pos, value); };
        void set(uint04 index, uint04 vector_pos, sint01 value) final override { setMemory(index, vector_pos, value); };
        void set(uint04 index, uint04 vector_pos, sint02 value) final override { setMemory(index, vector_pos, value); };
        void set(uint04 index, uint04 vector_pos, sint04 value) final override { setMemory(index, vector_pos, value); };
        void set(uint04 index, uint04 vector_pos, sint08 value) final override { setMemory(index, vector_pos, value); };
        void set(uint04 index, uint04 vector_pos, fltp04 value) final override { setMemory(index, vector_pos, value); };
        void set(uint04 index, uint04 vector_pos, fltp08 value) final override { setMemory(index, vector_pos, value); };
 
        void set(uint04 index, uint04 vector_pos, const String& value) final override { setMemory(index, vector_pos, value); };
 
        void set(uint04 index, bool value) final override { setMemory(index, value); };
        void set(uint04 index, uint01 value) final override { setMemory(index, value); };
        void set(uint04 index, uint02 value) final override { setMemory(index, value); };
        void set(uint04 index, uint04 value) final override { setMemory(index, value); };
        void set(uint04 index, uint08 value) final override { setMemory(index, value); };
        void set(uint04 index, sint01 value) final override { setMemory(index, value); };
        void set(uint04 index, sint02 value) final override { setMemory(index, value); };
        void set(uint04 index, sint04 value) final override { setMemory(index, value); };
        void set(uint04 index, sint08 value) final override { setMemory(index, value); };
        void set(uint04 index, fltp04 value) final override { setMemory(index, value); };
        void set(uint04 index, fltp08 value) final override { setMemory(index, value); };
        void set(uint04 index, const String& value) final override { setMemory(index, value); };
        void set(uint04 index, RGBColor value) final override { UNUSED(index); UNUSED(value);/*setMemory(index, value);*/ };
        
        void get(uint04 index, uint04 vector_pos, bool& value) const final override { getMemory(index, vector_pos, value); };
        void get(uint04 index, uint04 vector_pos, uint01& value) const final override { getMemory(index, vector_pos, value); };
        void get(uint04 index, uint04 vector_pos, uint02& value) const final override { getMemory(index, vector_pos, value); };
        void get(uint04 index, uint04 vector_pos, uint04& value) const final override { getMemory(index, vector_pos, value); };
        void get(uint04 index, uint04 vector_pos, uint08& value) const final override { getMemory(index, vector_pos, value); };
        void get(uint04 index, uint04 vector_pos, sint01& value) const final override { getMemory(index, vector_pos, value); };
        void get(uint04 index, uint04 vector_pos, sint02& value) const final override { getMemory(index, vector_pos, value); };
        void get(uint04 index, uint04 vector_pos, sint04& value) const final override { getMemory(index, vector_pos, value); };
        void get(uint04 index, uint04 vector_pos, sint08& value) const final override { getMemory(index, vector_pos, value); };
        void get(uint04 index, uint04 vector_pos, fltp04& value) const final override { getMemory(index, vector_pos, value); };
        void get(uint04 index, uint04 vector_pos, fltp08& value) const final override { getMemory(index, vector_pos, value); };
        void get(uint04 index, uint04 vector_pos, String& value) const final override { getMemory(index, vector_pos, value); };
 
        void get(uint04 index, bool& value) const final override { getMemory(index, value); };
        void get(uint04 index, uint01& value) const final override { getMemory(index, value); };
        void get(uint04 index, uint02& value) const final override { getMemory(index, value); };
        void get(uint04 index, uint04& value) const final override { getMemory(index, value); };
        void get(uint04 index, uint08& value) const final override { getMemory(index, value); };
        void get(uint04 index, sint01& value) const final override { getMemory(index, value); };
        void get(uint04 index, sint02& value) const final override { getMemory(index, value); };
        void get(uint04 index, sint04& value) const final override { getMemory(index, value); };
        void get(uint04 index, sint08& value) const final override { getMemory(index, value); };
        void get(uint04 index, fltp04& value) const final override { getMemory(index, value); };
        void get(uint04 index, fltp08& value) const final override { getMemory(index, value); };
        void get(uint04 index, String& value) const final override { getMemory(index, value); };
        void get(uint04 index, RGBColor& value) const final override { UNUSED(index); UNUSED(value);/*getMemory(index, value);*/ };
 
        virtual void copyRow(uint04 source, uint04 destination) override
        {
            UNUSED(source);
            UNUSED(destination);
            lib_assert(false, "Not yet implemented");
        }
        virtual void copyRows(uint04 source, uint04 destination, uint04 size) override
        {
            UNUSED(source);
            UNUSED(destination);
            UNUSED(size);
            lib_assert(false, "Not yet implemented");
        }
        virtual void insertIndices(uint04 location, uint04 size) override
        {
            UNUSED(location);
            UNUSED(size);
            lib_assert(false, "Not yet implemented");
        }
        virtual void removeIndices(uint04 location, uint04 size) override
        {
            UNUSED(location);
            UNUSED(size);
            lib_assert(false, "Not yet implemented");
        }
        void removeIndices(const Buffer<uint04>& offset_lookup_list) override final { UNUSED(offset_lookup_list); };
        uint04 size() const final override { return m_size; }
 
        NDEVR_GRAPHICS_API virtual void updateFrom(const TableColumn& column) override;
        void removeRow(uint04 index) override final { UNUSED(index); };
        void removeRows(uint04 index, uint04 size) override final { UNUSED(index); UNUSED(size); };
        void removeRows(const Buffer<uint04>& indices) override final { UNUSED(indices); };
        void removeRows(uint04 offset, const Buffer<bool>& indices) override { UNUSED(offset); UNUSED(indices); }
        void insert(uint04 index) override final { insertRows(index, 1); };
        virtual void copyData(const TableColumn& reference_data, bool set_type) = 0;
        NDEVR_GRAPHICS_API void setType(const TypeInfo& type);
        uint04 capacity() { return m_allocated_size; }
        template<class t_type>
        void setData(const t_type* begin, const t_type* end, bool set_type)
        {
            if (set_type && m_type != GetTypeInfo<t_type>())
            {
                cleanup();
                setType(GetTypeInfo<t_type>());
            }
            uint04 size = cast<uint04>(end - begin);
            setSize(size);
            if (size != 0)
            {
                TypeInfo insertion_type = GetTypeInfo<t_type>();
                if (insertion_type.is_number)
                {
                    if (insertion_type.vector_size > 0)
                        size = size * insertion_type.vector_size;
                    switch (insertion_type.byte_size)
                    {
                    case 1:
                        if (insertion_type.is_unsigned)
                            setMemory((uint01*)begin, 0, size);
                        else
                            setMemory((sint01*)begin, 0, size);
                        break;
                    case 2:
                        if (insertion_type.is_unsigned)
                            setMemory((uint02*)begin, 0, size);
                        else
                            setMemory((sint02*)begin, 0, size);
                        break;
                    case 4:
                        if (insertion_type.is_float)
                            setMemory((fltp04*)begin, 0, size);
                        else if (insertion_type.is_unsigned)
                            setMemory((uint04*)begin, 0, size);
                        else
                            setMemory((sint04*)begin, 0, size);
                        break;
                    case 8:
                        if (insertion_type.is_float)
                            setMemory((fltp08*)begin, 0, size);
                        else if (insertion_type.is_unsigned)
                            setMemory((uint08*)begin, 0, size);
                        else
                            setMemory((sint08*)begin, 0, size);
                        break;
                    case 16://
                        if (insertion_type.is_float)
                            setMemory((fltp04*)begin, 0, size);
                        else if (insertion_type.is_unsigned)
                            setMemory((uint04*)begin, 0, size);
                        else
                            setMemory((sint04*)begin, 0, size);
                        break;
                    default:
                        lib_assert(false, "unknown buffer format");
                        break;
                    }
                }
                else
                {
                    lib_assert(insertion_type == m_type, "unexpected vertex insertion");
                    _setRawData<t_type, t_type>(begin, 0, size);
                }
            }
            lib_assert(m_is_accessable, "Tried to edit unaccessible vertex");
        }
 
 
        void* begin() final { return nullptr; };
        void* end() final { return nullptr; };
 
        const void* begin() const final { return nullptr; };
        const void* end() const final { return nullptr; };
    protected:
        virtual void getFromVideoCard(bool copy_existing) = 0;
        virtual void sendToVideoCard(bool copy_existing) = 0;
#if _MSC_VER
#pragma warning( disable : 4244)
#endif
        template<class t_convert_type, class t_type>
        void _setRawData(const t_type* begin, uint04 offset, uint04 size)
        {
            void* data = mapMemory(cast<size_t>(offset) * type().byte_size, size * type().byte_size);
            if constexpr (std::is_same<t_convert_type, t_type>())
            {
                memcpy((uint01*)data, (uint01*)begin, size * type().byte_size);
            }
            else
            {
                for (uint04 i = 0; i < size; i++)
                {
                    t_convert_type conversion(*(begin + i));
                    memcpy((uint01*)(data)+type().byte_size * i, &conversion, sizeof(t_convert_type));
                }
            }
            unmapMemory();
        }
#if _MSC_VER
#pragma warning( default : 4244)
#endif
        template<class t_type>
        void getData(t_type* data_to_get, uint04 offset, uint04 size)
        {
            void* data = mapMemory(offset * type().total_size, size * type().total_size);
            memcpy(data_to_get, data, size * type().total_size);
            unmapMemory();
        }
 
        virtual void* mapMemory(size_t offset, size_t size) const = 0;
        virtual void unmapMemory() const = 0;
        virtual void updateRegion(const TableColumn& reference_data, uint04 offset, uint04 size) = 0;
    protected:
        uint04 m_size;
        uint04 m_allocated_size;
        Type m_internal_type;
        bool m_is_accessable;
        bool m_is_normalized;
        bool m_is_memory_owner;
    };
}