StreamOut.h

Go to the documentation of this file.

// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
// SPDX-License-Identifier: MIT
 
#pragma once
 
#include <Jolt/Core/NonCopyable.h>
 
JPH_NAMESPACE_BEGIN
 
class JPH_EXPORT StreamOut : public NonCopyable
{
public:
    virtual             ~StreamOut() = default;
 
    virtual void        WriteBytes(const void *inData, size_t inNumBytes) = 0;
 
    virtual bool        IsFailed() const = 0;
 
    template <class T, std::enable_if_t<std::is_trivially_copyable_v<T>, bool> = true>
    void                Write(const T &inT)
    {
        WriteBytes(&inT, sizeof(inT));
    }
 
    template <class T, class A, std::enable_if_t<std::is_trivially_copyable_v<T>, bool> = true>
    void                Write(const Array<T, A> &inT)
    {
        typename Array<T, A>::size_type len = inT.size();
        Write(len);
        if (!IsFailed())
        {
            if constexpr (std::is_same_v<T, Vec3> || std::is_same_v<T, DVec3> || std::is_same_v<T, DMat44>)
            {
                // These types have unused components that we don't want to write
                for (typename Array<T, A>::size_type i = 0; i < len; ++i)
                    Write(inT[i]);
            }
            else
            {
                // Write all elements at once
                WriteBytes(inT.data(), len * sizeof(T));
            }
        }
    }
 
    template <class Type, class Traits, class Allocator>
    void                Write(const std::basic_string<Type, Traits, Allocator> &inString)
    {
        typename std::basic_string<Type, Traits, Allocator>::size_type len = inString.size();
        Write(len);
        if (!IsFailed())
            WriteBytes(inString.data(), len * sizeof(Type));
    }
 
    template <class T, class A, typename F>
    void                Write(const Array<T, A> &inT, const F &inWriteElement)
    {
        typename Array<T, A>::size_type len = inT.size();
        Write(len);
        if (!IsFailed())
            for (typename Array<T, A>::size_type i = 0; i < len; ++i)
                inWriteElement(inT[i], *this);
    }
 
    void                Write(const Vec3 &inVec)
    {
        WriteBytes(&inVec, 3 * sizeof(float));
    }
 
    void                Write(const DVec3 &inVec)
    {
        WriteBytes(&inVec, 3 * sizeof(double));
    }
 
    void                Write(const DMat44 &inVec)
    {
        Write(inVec.GetColumn4(0));
        Write(inVec.GetColumn4(1));
        Write(inVec.GetColumn4(2));
 
        Write(inVec.GetTranslation());
    }
};
 
JPH_NAMESPACE_END