1068 lines
31 KiB
C++
1068 lines
31 KiB
C++
#pragma once
|
|
|
|
/**
|
|
* @file buffer_util.inl
|
|
* @brief LL GLTF Implementation
|
|
*
|
|
* $LicenseInfo:firstyear=2024&license=viewerlgpl$
|
|
* Second Life Viewer Source Code
|
|
* Copyright (C) 2024, Linden Research, Inc.
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation;
|
|
* version 2.1 of the License only.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*
|
|
* Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA
|
|
* $/LicenseInfo$
|
|
*/
|
|
|
|
// inline template implementations for copying data out of GLTF buffers
|
|
// DO NOT include from header files to avoid the need to rebuild the whole project
|
|
// whenever we add support for more types
|
|
|
|
#ifdef _MSC_VER
|
|
#define LL_FUNCSIG __FUNCSIG__
|
|
#else
|
|
#define LL_FUNCSIG __PRETTY_FUNCTION__
|
|
#endif
|
|
|
|
#include "accessor.h"
|
|
|
|
namespace LL
|
|
{
|
|
namespace GLTF
|
|
{
|
|
|
|
using string_view = boost::json::string_view;
|
|
|
|
// copy one Scalar from src to dst
|
|
template<class S, class T>
|
|
inline void copyScalar(S* src, T& dst)
|
|
{
|
|
LL_ERRS() << "TODO: implement " << LL_FUNCSIG << LL_ENDL;
|
|
}
|
|
|
|
// copy one vec2 from src to dst
|
|
template<class S, class T>
|
|
inline void copyVec2(S* src, T& dst)
|
|
{
|
|
LL_ERRS() << "TODO: implement " << LL_FUNCSIG << LL_ENDL;
|
|
}
|
|
|
|
// copy one vec3 from src to dst
|
|
template<class S, class T>
|
|
inline void copyVec3(S* src, T& dst)
|
|
{
|
|
LL_ERRS() << "TODO: implement " << LL_FUNCSIG << LL_ENDL;
|
|
}
|
|
|
|
// copy one vec4 from src to dst
|
|
template<class S, class T>
|
|
inline void copyVec4(S* src, T& dst)
|
|
{
|
|
LL_ERRS() << "TODO: implement " << LL_FUNCSIG << LL_ENDL;
|
|
}
|
|
|
|
// copy one mat2 from src to dst
|
|
template<class S, class T>
|
|
inline void copyMat2(S* src, T& dst)
|
|
{
|
|
LL_ERRS() << "TODO: implement " << LL_FUNCSIG << LL_ENDL;
|
|
}
|
|
|
|
// copy one mat3 from src to dst
|
|
template<class S, class T>
|
|
inline void copyMat3(S* src, T& dst)
|
|
{
|
|
LL_ERRS() << "TODO: implement " << LL_FUNCSIG << LL_ENDL;
|
|
}
|
|
|
|
// copy one mat4 from src to dst
|
|
template<class S, class T>
|
|
inline void copyMat4(S* src, T& dst)
|
|
{
|
|
LL_ERRS() << "TODO: implement " << LL_FUNCSIG << LL_ENDL;
|
|
}
|
|
|
|
//=========================================================================================================
|
|
// concrete implementations for different types of source and destination
|
|
//=========================================================================================================
|
|
|
|
template<>
|
|
inline void copyScalar<F32, F32>(F32* src, F32& dst)
|
|
{
|
|
dst = *src;
|
|
}
|
|
|
|
template<>
|
|
inline void copyScalar<U32, U32>(U32* src, U32& dst)
|
|
{
|
|
dst = *src;
|
|
}
|
|
|
|
template<>
|
|
inline void copyScalar<U32, U16>(U32* src, U16& dst)
|
|
{
|
|
dst = *src;
|
|
}
|
|
|
|
template<>
|
|
inline void copyScalar<U16, U16>(U16* src, U16& dst)
|
|
{
|
|
dst = *src;
|
|
}
|
|
|
|
template<>
|
|
inline void copyScalar<U16, U32>(U16* src, U32& dst)
|
|
{
|
|
dst = *src;
|
|
}
|
|
|
|
template<>
|
|
inline void copyScalar<U8, U16>(U8* src, U16& dst)
|
|
{
|
|
dst = *src;
|
|
}
|
|
|
|
template<>
|
|
inline void copyScalar<U8, U32>(U8* src, U32& dst)
|
|
{
|
|
dst = *src;
|
|
}
|
|
|
|
template<>
|
|
inline void copyVec2<F32, LLVector2>(F32* src, LLVector2& dst)
|
|
{
|
|
dst.set(src[0], src[1]);
|
|
}
|
|
|
|
template<>
|
|
inline void copyVec3<F32, vec3>(F32* src, vec3& dst)
|
|
{
|
|
dst = vec3(src[0], src[1], src[2]);
|
|
}
|
|
|
|
template<>
|
|
inline void copyVec3<F32, LLVector4a>(F32* src, LLVector4a& dst)
|
|
{
|
|
dst.load3(src);
|
|
}
|
|
|
|
template<>
|
|
inline void copyVec3<U16, LLColor4U>(U16* src, LLColor4U& dst)
|
|
{
|
|
dst.set(src[0], src[1], src[2], 255);
|
|
}
|
|
|
|
template<>
|
|
inline void copyVec4<U8, LLColor4U>(U8* src, LLColor4U& dst)
|
|
{
|
|
dst.set(src[0], src[1], src[2], src[3]);
|
|
}
|
|
|
|
template<>
|
|
inline void copyVec4<U16, U64>(U16* src, U64& dst)
|
|
{
|
|
U16* data = (U16*)&dst;
|
|
data[0] = src[0];
|
|
data[1] = src[1];
|
|
data[2] = src[2];
|
|
data[3] = src[3];
|
|
}
|
|
|
|
template<>
|
|
inline void copyVec4<U8, U64>(U8* src, U64& dst)
|
|
{
|
|
U8* data = (U8*)&dst;
|
|
data[0] = src[0];
|
|
data[1] = src[1];
|
|
data[2] = src[2];
|
|
data[3] = src[3];
|
|
}
|
|
|
|
template<>
|
|
inline void copyVec4<U16, LLColor4U>(U16* src, LLColor4U& dst)
|
|
{
|
|
dst.set(src[0], src[1], src[2], src[3]);
|
|
}
|
|
|
|
template<>
|
|
inline void copyVec4<F32, LLColor4U>(F32* src, LLColor4U& dst)
|
|
{
|
|
dst.set(src[0]*255, src[1]*255, src[2]*255, src[3]*255);
|
|
}
|
|
|
|
template<>
|
|
inline void copyVec4<F32, LLVector4a>(F32* src, LLVector4a& dst)
|
|
{
|
|
dst.loadua(src);
|
|
}
|
|
|
|
template<>
|
|
inline void copyVec4<U16, LLVector4a>(U16* src, LLVector4a& dst)
|
|
{
|
|
dst.set(src[0], src[1], src[2], src[3]);
|
|
}
|
|
|
|
template<>
|
|
inline void copyVec4<U8, LLVector4a>(U8* src, LLVector4a& dst)
|
|
{
|
|
dst.set(src[0], src[1], src[2], src[3]);
|
|
}
|
|
|
|
template<>
|
|
inline void copyVec4<F32, quat>(F32* src, quat& dst)
|
|
{
|
|
dst.x = src[0];
|
|
dst.y = src[1];
|
|
dst.z = src[2];
|
|
dst.w = src[3];
|
|
}
|
|
|
|
template<>
|
|
inline void copyMat4<F32, mat4>(F32* src, mat4& dst)
|
|
{
|
|
dst = glm::make_mat4(src);
|
|
}
|
|
|
|
//=========================================================================================================
|
|
|
|
// copy from src to dst, stride is the number of bytes between each element in src, count is number of elements to copy
|
|
template<class S, class T>
|
|
inline void copyScalar(S* src, LLStrider<T> dst, S32 stride, S32 count)
|
|
{
|
|
for (S32 i = 0; i < count; ++i)
|
|
{
|
|
copyScalar(src, *dst);
|
|
dst++;
|
|
src = (S*)((U8*)src + stride);
|
|
}
|
|
}
|
|
|
|
// copy from src to dst, stride is the number of bytes between each element in src, count is number of elements to copy
|
|
template<class S, class T>
|
|
inline void copyVec2(S* src, LLStrider<T> dst, S32 stride, S32 count)
|
|
{
|
|
for (S32 i = 0; i < count; ++i)
|
|
{
|
|
copyVec2(src, *dst);
|
|
dst++;
|
|
src = (S*)((U8*)src + stride);
|
|
}
|
|
}
|
|
|
|
// copy from src to dst, stride is the number of bytes between each element in src, count is number of elements to copy
|
|
template<class S, class T>
|
|
inline void copyVec3(S* src, LLStrider<T> dst, S32 stride, S32 count)
|
|
{
|
|
for (S32 i = 0; i < count; ++i)
|
|
{
|
|
copyVec3(src, *dst);
|
|
dst++;
|
|
src = (S*)((U8*)src + stride);
|
|
}
|
|
}
|
|
|
|
// copy from src to dst, stride is the number of bytes between each element in src, count is number of elements to copy
|
|
template<class S, class T>
|
|
inline void copyVec4(S* src, LLStrider<T> dst, S32 stride, S32 count)
|
|
{
|
|
for (S32 i = 0; i < count; ++i)
|
|
{
|
|
copyVec4(src, *dst);
|
|
dst++;
|
|
src = (S*)((U8*)src + stride);
|
|
}
|
|
}
|
|
|
|
// copy from src to dst, stride is the number of bytes between each element in src, count is number of elements to copy
|
|
template<class S, class T>
|
|
inline void copyMat2(S* src, LLStrider<T> dst, S32 stride, S32 count)
|
|
{
|
|
for (S32 i = 0; i < count; ++i)
|
|
{
|
|
copyMat2(src, *dst);
|
|
dst++;
|
|
src = (S*)((U8*)src + stride);
|
|
}
|
|
}
|
|
|
|
// copy from src to dst, stride is the number of bytes between each element in src, count is number of elements to copy
|
|
template<class S, class T>
|
|
inline void copyMat3(S* src, LLStrider<T> dst, S32 stride, S32 count)
|
|
{
|
|
for (S32 i = 0; i < count; ++i)
|
|
{
|
|
copyMat3(src, *dst);
|
|
dst++;
|
|
src = (S*)((U8*)src + stride);
|
|
}
|
|
}
|
|
|
|
// copy from src to dst, stride is the number of bytes between each element in src, count is number of elements to copy
|
|
template<class S, class T>
|
|
inline void copyMat4(S* src, LLStrider<T> dst, S32 stride, S32 count)
|
|
{
|
|
for (S32 i = 0; i < count; ++i)
|
|
{
|
|
copyMat4(src, *dst);
|
|
dst++;
|
|
src = (S*)((U8*)src + stride);
|
|
}
|
|
}
|
|
|
|
template<class S, class T>
|
|
inline void copy(Asset& asset, Accessor& accessor, const S* src, LLStrider<T>& dst, S32 byteStride)
|
|
{
|
|
if (accessor.mType == Accessor::Type::SCALAR)
|
|
{
|
|
S32 stride = byteStride == 0 ? sizeof(S) * 1 : byteStride;
|
|
copyScalar((S*)src, dst, stride, accessor.mCount);
|
|
}
|
|
else if (accessor.mType == Accessor::Type::VEC2)
|
|
{
|
|
S32 stride = byteStride == 0 ? sizeof(S) * 2 : byteStride;
|
|
copyVec2((S*)src, dst, stride, accessor.mCount);
|
|
}
|
|
else if (accessor.mType == Accessor::Type::VEC3)
|
|
{
|
|
S32 stride = byteStride == 0 ? sizeof(S) * 3 : byteStride;
|
|
copyVec3((S*)src, dst, stride, accessor.mCount);
|
|
}
|
|
else if (accessor.mType == Accessor::Type::VEC4)
|
|
{
|
|
S32 stride = byteStride == 0 ? sizeof(S) * 4 : byteStride;
|
|
copyVec4((S*)src, dst, stride, accessor.mCount);
|
|
}
|
|
else if (accessor.mType == Accessor::Type::MAT2)
|
|
{
|
|
S32 stride = byteStride == 0 ? sizeof(S) * 4 : byteStride;
|
|
copyMat2((S*)src, dst, stride, accessor.mCount);
|
|
}
|
|
else if (accessor.mType == Accessor::Type::MAT3)
|
|
{
|
|
S32 stride = byteStride == 0 ? sizeof(S) * 9 : byteStride;
|
|
copyMat3((S*)src, dst, stride, accessor.mCount);
|
|
}
|
|
else if (accessor.mType == Accessor::Type::MAT4)
|
|
{
|
|
S32 stride = byteStride == 0 ? sizeof(S) * 16 : byteStride;
|
|
copyMat4((S*)src, dst, stride, accessor.mCount);
|
|
}
|
|
else
|
|
{
|
|
LL_ERRS("GLTF") << "Unsupported accessor type" << LL_ENDL;
|
|
}
|
|
}
|
|
|
|
// copy data from accessor to strider
|
|
template<class T>
|
|
inline void copy(Asset& asset, Accessor& accessor, LLStrider<T>& dst)
|
|
{
|
|
const BufferView& bufferView = asset.mBufferViews[accessor.mBufferView];
|
|
const Buffer& buffer = asset.mBuffers[bufferView.mBuffer];
|
|
const U8* src = buffer.mData.data() + bufferView.mByteOffset + accessor.mByteOffset;
|
|
|
|
switch (accessor.mComponentType)
|
|
{
|
|
case Accessor::ComponentType::FLOAT:
|
|
copy(asset, accessor, (const F32*)src, dst, bufferView.mByteStride);
|
|
break;
|
|
case Accessor::ComponentType::UNSIGNED_INT:
|
|
copy(asset, accessor, (const U32*)src, dst, bufferView.mByteStride);
|
|
break;
|
|
case Accessor::ComponentType::SHORT:
|
|
copy(asset, accessor, (const S16*)src, dst, bufferView.mByteStride);
|
|
break;
|
|
case Accessor::ComponentType::UNSIGNED_SHORT:
|
|
copy(asset, accessor, (const U16*)src, dst, bufferView.mByteStride);
|
|
break;
|
|
case Accessor::ComponentType::BYTE:
|
|
copy(asset, accessor, (const S8*)src, dst, bufferView.mByteStride);
|
|
break;
|
|
case Accessor::ComponentType::UNSIGNED_BYTE:
|
|
copy(asset, accessor, (const U8*)src, dst, bufferView.mByteStride);
|
|
break;
|
|
default:
|
|
LL_ERRS("GLTF") << "Invalid component type" << LL_ENDL;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// copy data from accessor to vector
|
|
template<class T>
|
|
inline void copy(Asset& asset, Accessor& accessor, std::vector<T>& dst)
|
|
{
|
|
dst.resize(accessor.mCount);
|
|
LLStrider<T> strider = dst.data();
|
|
copy(asset, accessor, strider);
|
|
}
|
|
|
|
|
|
//=========================================================================================================
|
|
// boost::json copying utilities
|
|
// ========================================================================================================
|
|
|
|
//====================== unspecialized base template, single value ===========================
|
|
|
|
// to/from Value
|
|
template<typename T>
|
|
inline bool copy(const Value& src, T& dst)
|
|
{
|
|
dst = src;
|
|
return true;
|
|
}
|
|
|
|
template<typename T>
|
|
inline bool write(const T& src, Value& dst)
|
|
{
|
|
dst = boost::json::object();
|
|
src.serialize(dst.as_object());
|
|
return true;
|
|
}
|
|
|
|
template<typename T>
|
|
inline bool copy(const Value& src, std::unordered_map<std::string, T>& dst)
|
|
{
|
|
if (src.is_object())
|
|
{
|
|
const boost::json::object& obj = src.as_object();
|
|
for (const auto& [key, value] : obj)
|
|
{
|
|
copy<T>(value, dst[key]);
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
template<typename T>
|
|
inline bool write(const std::unordered_map<std::string, T>& src, Value& dst)
|
|
{
|
|
boost::json::object obj;
|
|
for (const auto& [key, value] : src)
|
|
{
|
|
Value v;
|
|
if (write<T>(value, v))
|
|
{
|
|
obj[key] = v;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
dst = obj;
|
|
return true;
|
|
}
|
|
|
|
// to/from array
|
|
template<typename T>
|
|
inline bool copy(const Value& src, std::vector<T>& dst)
|
|
{
|
|
if (src.is_array())
|
|
{
|
|
const boost::json::array& arr = src.get_array();
|
|
dst.resize(arr.size());
|
|
for (size_t i = 0; i < arr.size(); ++i)
|
|
{
|
|
copy(arr[i], dst[i]);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
template<typename T>
|
|
inline bool write(const std::vector<T>& src, Value& dst)
|
|
{
|
|
boost::json::array arr;
|
|
for (const T& t : src)
|
|
{
|
|
Value v;
|
|
if (write(t, v))
|
|
{
|
|
arr.push_back(v);
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
dst = arr;
|
|
return true;
|
|
}
|
|
|
|
// to/from object member
|
|
template<typename T>
|
|
inline bool copy(const boost::json::object& src, string_view member, T& dst)
|
|
{
|
|
auto it = src.find(member);
|
|
if (it != src.end())
|
|
{
|
|
return copy(it->value(), dst);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// always write a member to an object without checking default
|
|
template<typename T>
|
|
inline bool write_always(const T& src, string_view member, boost::json::object& dst)
|
|
{
|
|
Value& v = dst[member];
|
|
if (!write(src, v))
|
|
{
|
|
dst.erase(member);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
// to/from extension
|
|
|
|
// for internal use only, use copy_extensions instead
|
|
template<typename T>
|
|
inline bool _copy_extension(const boost::json::object& extensions, std::string_view member, T* dst)
|
|
{
|
|
if (extensions.contains(member))
|
|
{
|
|
return copy(extensions.at(member), *dst);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// Copy all extensions from src.extensions to provided destinations
|
|
// Usage:
|
|
// copy_extensions(src,
|
|
// "KHR_materials_unlit", &mUnlit,
|
|
// "KHR_materials_pbrSpecularGlossiness", &mPbrSpecularGlossiness);
|
|
// returns true if any of the extensions are copied
|
|
template<class... Types>
|
|
inline bool copy_extensions(const boost::json::value& src, Types... args)
|
|
{
|
|
// extract the extensions object (don't assume it exists and verify that it is an object)
|
|
if (src.is_object())
|
|
{
|
|
boost::json::object obj = src.get_object();
|
|
if (obj.contains("extensions"))
|
|
{
|
|
const boost::json::value& extensions = obj.at("extensions");
|
|
if (extensions.is_object())
|
|
{
|
|
const boost::json::object& ext_obj = extensions.as_object();
|
|
bool success = false;
|
|
// copy each extension, return true if any of them succeed, do not short circuit on success
|
|
U32 count = sizeof...(args);
|
|
for (U32 i = 0; i < count; i += 2)
|
|
{
|
|
if (_copy_extension(ext_obj, args...))
|
|
{
|
|
success = true;
|
|
}
|
|
}
|
|
return success;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// internal use aonly, use write_extensions instead
|
|
template<typename T>
|
|
inline bool _write_extension(boost::json::object& extensions, const T* src, string_view member)
|
|
{
|
|
if (src->mPresent)
|
|
{
|
|
Value v;
|
|
if (write(*src, v))
|
|
{
|
|
extensions[member] = v;
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Write all extensions to dst.extensions
|
|
// Usage:
|
|
// write_extensions(dst,
|
|
// mUnlit, "KHR_materials_unlit",
|
|
// mPbrSpecularGlossiness, "KHR_materials_pbrSpecularGlossiness");
|
|
// returns true if any of the extensions are written
|
|
template<class... Types>
|
|
inline bool write_extensions(boost::json::object& dst, Types... args)
|
|
{
|
|
bool success = false;
|
|
|
|
boost::json::object extensions;
|
|
U32 count = sizeof...(args) - 1;
|
|
|
|
for (U32 i = 0; i < count; i += 2)
|
|
{
|
|
if (_write_extension(extensions, args...))
|
|
{
|
|
success = true;
|
|
}
|
|
}
|
|
|
|
if (success)
|
|
{
|
|
dst["extensions"] = extensions;
|
|
}
|
|
|
|
return success;
|
|
}
|
|
|
|
// conditionally write a member to an object if the member
|
|
// is not the default value
|
|
template<typename T>
|
|
inline bool write(const T& src, string_view member, boost::json::object& dst, const T& default_value = T())
|
|
{
|
|
if (src != default_value)
|
|
{
|
|
return write_always(src, member, dst);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
template<typename T>
|
|
inline bool write(const std::unordered_map<std::string, T>& src, string_view member, boost::json::object& dst, const std::unordered_map<std::string, T>& default_value = std::unordered_map<std::string, T>())
|
|
{
|
|
if (!src.empty())
|
|
{
|
|
Value v;
|
|
if (write<T>(src, v))
|
|
{
|
|
dst[member] = v;
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
template<typename T>
|
|
inline bool write(const std::vector<T>& src, string_view member, boost::json::object& dst, const std::vector<T>& deafault_value = std::vector<T>())
|
|
{
|
|
if (!src.empty())
|
|
{
|
|
Value v;
|
|
if (write(src, v))
|
|
{
|
|
dst[member] = v;
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
template<typename T>
|
|
inline bool copy(const Value& src, string_view member, T& dst)
|
|
{
|
|
if (src.is_object())
|
|
{
|
|
const boost::json::object& obj = src.as_object();
|
|
return copy(obj, member, dst);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// Accessor::ComponentType
|
|
template<>
|
|
inline bool copy(const Value& src, Accessor::ComponentType& dst)
|
|
{
|
|
if (src.is_int64())
|
|
{
|
|
dst = (Accessor::ComponentType)src.get_int64();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
template<>
|
|
inline bool write(const Accessor::ComponentType& src, Value& dst)
|
|
{
|
|
dst = (S32)src;
|
|
return true;
|
|
}
|
|
|
|
//Primitive::Mode
|
|
template<>
|
|
inline bool copy(const Value& src, Primitive::Mode& dst)
|
|
{
|
|
if (src.is_int64())
|
|
{
|
|
dst = (Primitive::Mode)src.get_int64();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
template<>
|
|
inline bool write(const Primitive::Mode& src, Value& dst)
|
|
{
|
|
dst = (S32)src;
|
|
return true;
|
|
}
|
|
|
|
// vec4
|
|
template<>
|
|
inline bool copy(const Value& src, vec4& dst)
|
|
{
|
|
if (src.is_array())
|
|
{
|
|
const boost::json::array& arr = src.as_array();
|
|
if (arr.size() == 4)
|
|
{
|
|
vec4 v;
|
|
std::error_code ec;
|
|
|
|
v.x = arr[0].to_number<F32>(ec); if (ec) return false;
|
|
v.y = arr[1].to_number<F32>(ec); if (ec) return false;
|
|
v.z = arr[2].to_number<F32>(ec); if (ec) return false;
|
|
v.w = arr[3].to_number<F32>(ec); if (ec) return false;
|
|
|
|
dst = v;
|
|
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
template<>
|
|
inline bool write(const vec4& src, Value& dst)
|
|
{
|
|
dst = boost::json::array();
|
|
boost::json::array& arr = dst.get_array();
|
|
arr.resize(4);
|
|
arr[0] = src.x;
|
|
arr[1] = src.y;
|
|
arr[2] = src.z;
|
|
arr[3] = src.w;
|
|
return true;
|
|
}
|
|
|
|
// quat
|
|
template<>
|
|
inline bool copy(const Value& src, quat& dst)
|
|
{
|
|
if (src.is_array())
|
|
{
|
|
const boost::json::array& arr = src.as_array();
|
|
if (arr.size() == 4)
|
|
{
|
|
std::error_code ec;
|
|
dst.x = arr[0].to_number<F32>(ec); if (ec) return false;
|
|
dst.y = arr[1].to_number<F32>(ec); if (ec) return false;
|
|
dst.z = arr[2].to_number<F32>(ec); if (ec) return false;
|
|
dst.w = arr[3].to_number<F32>(ec); if (ec) return false;
|
|
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
template<>
|
|
inline bool write(const quat& src, Value& dst)
|
|
{
|
|
dst = boost::json::array();
|
|
boost::json::array& arr = dst.get_array();
|
|
arr.resize(4);
|
|
arr[0] = src.x;
|
|
arr[1] = src.y;
|
|
arr[2] = src.z;
|
|
arr[3] = src.w;
|
|
return true;
|
|
}
|
|
|
|
|
|
// vec3
|
|
template<>
|
|
inline bool copy(const Value& src, vec3& dst)
|
|
{
|
|
if (src.is_array())
|
|
{
|
|
const boost::json::array& arr = src.as_array();
|
|
if (arr.size() == 3)
|
|
{
|
|
std::error_code ec;
|
|
vec3 t;
|
|
t.x = arr[0].to_number<F32>(ec); if (ec) return false;
|
|
t.y = arr[1].to_number<F32>(ec); if (ec) return false;
|
|
t.z = arr[2].to_number<F32>(ec); if (ec) return false;
|
|
|
|
dst = t;
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
template<>
|
|
inline bool write(const vec3& src, Value& dst)
|
|
{
|
|
dst = boost::json::array();
|
|
boost::json::array& arr = dst.as_array();
|
|
arr.resize(3);
|
|
arr[0] = src.x;
|
|
arr[1] = src.y;
|
|
arr[2] = src.z;
|
|
return true;
|
|
}
|
|
|
|
// vec2
|
|
template<>
|
|
inline bool copy(const Value& src, vec2& dst)
|
|
{
|
|
if (src.is_array())
|
|
{
|
|
const boost::json::array& arr = src.as_array();
|
|
if (arr.size() == 2)
|
|
{
|
|
std::error_code ec;
|
|
vec2 t;
|
|
t.x = arr[0].to_number<F32>(ec); if (ec) return false;
|
|
t.y = arr[1].to_number<F32>(ec); if (ec) return false;
|
|
|
|
dst = t;
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
template<>
|
|
inline bool write(const vec2& src, Value& dst)
|
|
{
|
|
dst = boost::json::array();
|
|
boost::json::array& arr = dst.as_array();
|
|
arr.resize(2);
|
|
arr[0] = src.x;
|
|
arr[1] = src.y;
|
|
|
|
return true;
|
|
}
|
|
|
|
// bool
|
|
template<>
|
|
inline bool copy(const Value& src, bool& dst)
|
|
{
|
|
if (src.is_bool())
|
|
{
|
|
dst = src.get_bool();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
template<>
|
|
inline bool write(const bool& src, Value& dst)
|
|
{
|
|
dst = src;
|
|
return true;
|
|
}
|
|
|
|
// F32
|
|
template<>
|
|
inline bool copy(const Value& src, F32& dst)
|
|
{
|
|
std::error_code ec;
|
|
F32 t = src.to_number<F32>(ec); if (ec) return false;
|
|
dst = t;
|
|
return true;
|
|
}
|
|
|
|
template<>
|
|
inline bool write(const F32& src, Value& dst)
|
|
{
|
|
dst = src;
|
|
return true;
|
|
}
|
|
|
|
|
|
// U32
|
|
template<>
|
|
inline bool copy(const Value& src, U32& dst)
|
|
{
|
|
if (src.is_int64())
|
|
{
|
|
dst = src.get_int64();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
template<>
|
|
inline bool write(const U32& src, Value& dst)
|
|
{
|
|
dst = src;
|
|
return true;
|
|
}
|
|
|
|
// F64
|
|
template<>
|
|
inline bool copy(const Value& src, F64& dst)
|
|
{
|
|
std::error_code ec;
|
|
F64 t = src.to_number<F64>(ec); if (ec) return false;
|
|
dst = t;
|
|
return true;
|
|
}
|
|
|
|
template<>
|
|
inline bool write(const F64& src, Value& dst)
|
|
{
|
|
dst = src;
|
|
return true;
|
|
}
|
|
|
|
// Accessor::Type
|
|
template<>
|
|
inline bool copy(const Value& src, Accessor::Type& dst)
|
|
{
|
|
if (src.is_string())
|
|
{
|
|
dst = gltf_type_to_enum(src.get_string().c_str());
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
template<>
|
|
inline bool write(const Accessor::Type& src, Value& dst)
|
|
{
|
|
dst = enum_to_gltf_type(src);
|
|
return true;
|
|
}
|
|
|
|
// S32
|
|
template<>
|
|
inline bool copy(const Value& src, S32& dst)
|
|
{
|
|
if (src.is_int64())
|
|
{
|
|
dst = src.get_int64();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
template<>
|
|
inline bool write(const S32& src, Value& dst)
|
|
{
|
|
dst = src;
|
|
return true;
|
|
}
|
|
|
|
|
|
// std::string
|
|
template<>
|
|
inline bool copy(const Value& src, std::string& dst)
|
|
{
|
|
if (src.is_string())
|
|
{
|
|
dst = src.get_string().c_str();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
template<>
|
|
inline bool write(const std::string& src, Value& dst)
|
|
{
|
|
dst = src;
|
|
return true;
|
|
}
|
|
|
|
// mat4
|
|
template<>
|
|
inline bool copy(const Value& src, mat4& dst)
|
|
{
|
|
if (src.is_array())
|
|
{
|
|
const boost::json::array& arr = src.get_array();
|
|
if (arr.size() == 16)
|
|
{
|
|
// populate a temporary local in case
|
|
// we hit an error in the middle of the array
|
|
// (don't partially write a matrix)
|
|
mat4 t;
|
|
F32* p = glm::value_ptr(t);
|
|
|
|
for (U32 i = 0; i < arr.size(); ++i)
|
|
{
|
|
std::error_code ec;
|
|
p[i] = arr[i].to_number<F32>(ec);
|
|
if (ec)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
dst = t;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
template<>
|
|
inline bool write(const mat4& src, Value& dst)
|
|
{
|
|
dst = boost::json::array();
|
|
boost::json::array& arr = dst.get_array();
|
|
arr.resize(16);
|
|
const F32* p = glm::value_ptr(src);
|
|
for (U32 i = 0; i < 16; ++i)
|
|
{
|
|
arr[i] = p[i];
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Material::AlphaMode
|
|
template<>
|
|
inline bool copy(const Value& src, Material::AlphaMode& dst)
|
|
{
|
|
if (src.is_string())
|
|
{
|
|
dst = gltf_alpha_mode_to_enum(src.get_string().c_str());
|
|
return true;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
template<>
|
|
inline bool write(const Material::AlphaMode& src, Value& dst)
|
|
{
|
|
dst = enum_to_gltf_alpha_mode(src);
|
|
return true;
|
|
}
|
|
|
|
//
|
|
// ========================================================================================================
|
|
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|