StreamIn.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 StreamIn : public NonCopyable
{
public:
    virtual             ~StreamIn() = default;
 
    virtual void        ReadBytes(void *outData, size_t inNumBytes) = 0;
 
    virtual bool        IsEOF() const = 0;
 
    virtual bool        IsFailed() const = 0;
 
    template <class T, std::enable_if_t<std::is_trivially_copyable_v<T>, bool> = true>
    void                Read(T &outT)
    {
        ReadBytes(&outT, sizeof(outT));
    }
 
    template <class T, class A, std::enable_if_t<std::is_trivially_copyable_v<T>, bool> = true>
    void                Read(Array<T, A> &outT)
    {
        typename Array<T, A>::size_type len = outT.size(); // Initialize to previous array size, this is used for validation in the StateRecorder class
        Read(len);
        if (!IsEOF() && !IsFailed())
        {
            outT.resize(len);
            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 read
                for (typename Array<T, A>::size_type i = 0; i < len; ++i)
                    Read(outT[i]);
            }
            else
            {
                // Read all elements at once
                ReadBytes(outT.data(), len * sizeof(T));
            }
        }
        else
            outT.clear();
    }
 
    template <class Type, class Traits, class Allocator>
    void                Read(std::basic_string<Type, Traits, Allocator> &outString)
    {
        typename std::basic_string<Type, Traits, Allocator>::size_type len = 0;
        Read(len);
        if (!IsEOF() && !IsFailed())
        {
            outString.resize(len);
            ReadBytes(outString.data(), len * sizeof(Type));
        }
        else
            outString.clear();
    }
 
    template <class T, class A, typename F>
    void                Read(Array<T, A> &outT, const F &inReadElement)
    {
        typename Array<T, A>::size_type len = outT.size(); // Initialize to previous array size, this is used for validation in the StateRecorder class
        Read(len);
        if (!IsEOF() && !IsFailed())
        {
            outT.resize(len);
            for (typename Array<T, A>::size_type i = 0; i < len; ++i)
                inReadElement(*this, outT[i]);
        }
        else
            outT.clear();
    }
 
    void                Read(Vec3 &outVec)
    {
        ReadBytes(&outVec, 3 * sizeof(float));
        outVec = Vec3::sFixW(outVec.mValue);
    }
 
    void                Read(DVec3 &outVec)
    {
        ReadBytes(&outVec, 3 * sizeof(double));
        outVec = DVec3::sFixW(outVec.mValue);
    }
 
    void                Read(DMat44 &outVec)
    {
        Vec4 x, y, z;
        Read(x);
        Read(y);
        Read(z);
 
        DVec3 t;
        Read(t);
 
        outVec = DMat44(x, y, z, t);
    }
};
 
JPH_NAMESPACE_END