mirror of
https://github.com/luanti-org/luanti.git
synced 2025-11-04 09:15:29 +01:00
ac11a14509
Co-authored-by: Lars Mueller <appgurulars@gmx.de> Co-authored-by: jordan4ibanez <jordan4ibanez@users.noreply.github.com> Co-authored-by: sfan5 <sfan5@live.de> Co-authored-by: SmallJoker <SmallJoker@users.noreply.github.com>
1358 lines
36 KiB
C++
1358 lines
36 KiB
C++
#pragma once
|
|
|
|
#include <json/json.h>
|
|
#include <functional>
|
|
#include <stack>
|
|
#include <string>
|
|
#include <string_view>
|
|
#include <variant>
|
|
#include <vector>
|
|
#include <array>
|
|
#include <optional>
|
|
#include <limits>
|
|
#include <stdexcept>
|
|
#include <unordered_map>
|
|
#include <unordered_set>
|
|
#include "util/base64.h"
|
|
|
|
namespace tiniergltf {
|
|
|
|
static inline void check(bool cond) {
|
|
if (!cond)
|
|
throw std::runtime_error("invalid glTF");
|
|
}
|
|
|
|
template <typename T>
|
|
static inline void checkIndex(const std::optional<std::vector<T>> &vec,
|
|
const std::optional<std::size_t> &i) {
|
|
if (!i.has_value()) return;
|
|
check(vec.has_value());
|
|
check(i < vec->size());
|
|
}
|
|
|
|
template <typename T>
|
|
static inline void checkIndex(const std::vector<T> &vec,
|
|
const std::optional<std::size_t> &i) {
|
|
if (!i.has_value()) return;
|
|
check(i < vec.size());
|
|
}
|
|
|
|
template <typename T, typename F>
|
|
static inline void checkForall(const std::optional<std::vector<T>> &vec, const F &cond) {
|
|
if (!vec.has_value())
|
|
return;
|
|
for (const T &v : vec.value())
|
|
cond(v);
|
|
}
|
|
|
|
template <typename T>
|
|
static inline void checkDuplicateFree(const std::vector<T> &vec) {
|
|
check(std::unordered_set<T>(vec.begin(), vec.end()).size() == vec.size());
|
|
}
|
|
|
|
template <typename T>
|
|
static inline T as(const Json::Value &o);
|
|
|
|
template<>
|
|
bool as(const Json::Value &o) {
|
|
check(o.isBool());
|
|
return o.asBool();
|
|
}
|
|
|
|
template<>
|
|
double as (const Json::Value &o) {
|
|
check(o.isDouble());
|
|
return o.asDouble();
|
|
}
|
|
|
|
template<>
|
|
std::size_t as(const Json::Value &o) {
|
|
check(o.isUInt64());
|
|
auto u = o.asUInt64();
|
|
check(u <= std::numeric_limits<std::size_t>::max());
|
|
return u;
|
|
}
|
|
|
|
template<>
|
|
std::string as(const Json::Value &o) {
|
|
check(o.isString());
|
|
return o.asString();
|
|
}
|
|
|
|
template<typename U>
|
|
std::vector<U> asVec(const Json::Value &o) {
|
|
check(o.isArray());
|
|
std::vector<U> res;
|
|
res.reserve(o.size());
|
|
for (Json::ArrayIndex i = 0; i < o.size(); ++i) {
|
|
res.push_back(as<U>(o[i]));
|
|
}
|
|
return res;
|
|
}
|
|
|
|
template<typename U, std::size_t n>
|
|
std::array<U, n> asArr(const Json::Value &o) {
|
|
check(o.isArray());
|
|
check(o.size() == n);
|
|
std::array<U, n> res;
|
|
for (Json::ArrayIndex i = 0; i < n; ++i) {
|
|
res[i] = as<U>(o[i]);
|
|
}
|
|
return res;
|
|
}
|
|
|
|
struct AccessorSparseIndices {
|
|
std::size_t bufferView;
|
|
std::size_t byteOffset;
|
|
// as defined in the glTF specification
|
|
enum class ComponentType {
|
|
UNSIGNED_BYTE,
|
|
UNSIGNED_SHORT,
|
|
UNSIGNED_INT,
|
|
};
|
|
ComponentType componentType;
|
|
std::size_t componentSize() const {
|
|
switch (componentType) {
|
|
case ComponentType::UNSIGNED_BYTE:
|
|
return 1;
|
|
case ComponentType::UNSIGNED_SHORT:
|
|
return 2;
|
|
case ComponentType::UNSIGNED_INT:
|
|
return 4;
|
|
}
|
|
throw std::logic_error("invalid component type");
|
|
}
|
|
std::size_t elementSize() const {
|
|
return componentSize();
|
|
}
|
|
AccessorSparseIndices(const Json::Value &o)
|
|
: bufferView(as<std::size_t>(o["bufferView"]))
|
|
, byteOffset(0)
|
|
{
|
|
check(o.isObject());
|
|
if (o.isMember("byteOffset")) {
|
|
byteOffset = as<std::size_t>(o["byteOffset"]);
|
|
check(byteOffset >= 0);
|
|
}
|
|
{
|
|
static std::unordered_map<Json::UInt64, ComponentType> map = {
|
|
{5121, ComponentType::UNSIGNED_BYTE},
|
|
{5123, ComponentType::UNSIGNED_SHORT},
|
|
{5125, ComponentType::UNSIGNED_INT},
|
|
};
|
|
const auto &v = o["componentType"]; check(v.isUInt64());
|
|
componentType = map.at(v.asUInt64());
|
|
}
|
|
}
|
|
};
|
|
template<> AccessorSparseIndices as(const Json::Value &o) { return o; }
|
|
|
|
struct AccessorSparseValues {
|
|
std::size_t bufferView;
|
|
std::size_t byteOffset;
|
|
AccessorSparseValues(const Json::Value &o)
|
|
: bufferView(as<std::size_t>(o["bufferView"]))
|
|
, byteOffset(0)
|
|
{
|
|
check(o.isObject());
|
|
if (o.isMember("byteOffset")) {
|
|
byteOffset = as<std::size_t>(o["byteOffset"]);
|
|
check(byteOffset >= 0);
|
|
}
|
|
}
|
|
};
|
|
template<> AccessorSparseValues as(const Json::Value &o) { return o; }
|
|
|
|
struct AccessorSparse {
|
|
std::size_t count;
|
|
AccessorSparseIndices indices;
|
|
AccessorSparseValues values;
|
|
AccessorSparse(const Json::Value &o)
|
|
: count(as<std::size_t>(o["count"]))
|
|
, indices(as<AccessorSparseIndices>(o["indices"]))
|
|
, values(as<AccessorSparseValues>(o["values"]))
|
|
{
|
|
check(o.isObject());
|
|
check(count >= 1);
|
|
}
|
|
};
|
|
template<> AccessorSparse as(const Json::Value &o) { return o; }
|
|
|
|
struct Accessor {
|
|
std::optional<std::size_t> bufferView;
|
|
std::size_t byteOffset;
|
|
// as defined in the glTF specification
|
|
enum class ComponentType {
|
|
BYTE,
|
|
UNSIGNED_BYTE,
|
|
SHORT,
|
|
UNSIGNED_SHORT,
|
|
UNSIGNED_INT,
|
|
FLOAT,
|
|
};
|
|
ComponentType componentType;
|
|
std::size_t componentSize() const {
|
|
switch (componentType) {
|
|
case ComponentType::BYTE:
|
|
case ComponentType::UNSIGNED_BYTE:
|
|
return 1;
|
|
case ComponentType::SHORT:
|
|
case ComponentType::UNSIGNED_SHORT:
|
|
return 2;
|
|
case ComponentType::UNSIGNED_INT:
|
|
case ComponentType::FLOAT:
|
|
return 4;
|
|
}
|
|
throw std::logic_error("invalid component type");
|
|
}
|
|
std::size_t count;
|
|
std::optional<std::vector<double>> max;
|
|
std::optional<std::vector<double>> min;
|
|
std::optional<std::string> name;
|
|
bool normalized;
|
|
std::optional<AccessorSparse> sparse;
|
|
enum class Type {
|
|
MAT2,
|
|
MAT3,
|
|
MAT4,
|
|
SCALAR,
|
|
VEC2,
|
|
VEC3,
|
|
VEC4,
|
|
};
|
|
std::size_t typeCount() const {
|
|
switch (type) {
|
|
case Type::SCALAR:
|
|
return 1;
|
|
case Type::VEC2:
|
|
return 2;
|
|
case Type::VEC3:
|
|
return 3;
|
|
case Type::MAT2:
|
|
case Type::VEC4:
|
|
return 4;
|
|
case Type::MAT3:
|
|
return 9;
|
|
case Type::MAT4:
|
|
return 16;
|
|
}
|
|
throw std::logic_error("invalid type");
|
|
}
|
|
Type type;
|
|
std::size_t elementSize() const {
|
|
return componentSize() * typeCount();
|
|
}
|
|
Accessor(const Json::Value &o)
|
|
: byteOffset(0)
|
|
, count(as<std::size_t>(o["count"]))
|
|
, normalized(false)
|
|
{
|
|
check(o.isObject());
|
|
if (o.isMember("bufferView")) {
|
|
bufferView = as<std::size_t>(o["bufferView"]);
|
|
}
|
|
{
|
|
static std::unordered_map<Json::UInt64, ComponentType> map = {
|
|
{5120, ComponentType::BYTE},
|
|
{5121, ComponentType::UNSIGNED_BYTE},
|
|
{5122, ComponentType::SHORT},
|
|
{5123, ComponentType::UNSIGNED_SHORT},
|
|
{5125, ComponentType::UNSIGNED_INT},
|
|
{5126, ComponentType::FLOAT},
|
|
};
|
|
const auto &v = o["componentType"]; check(v.isUInt64());
|
|
componentType = map.at(v.asUInt64());
|
|
}
|
|
if (o.isMember("byteOffset")) {
|
|
byteOffset = as<std::size_t>(o["byteOffset"]);
|
|
check(byteOffset >= 0);
|
|
check(byteOffset % componentSize() == 0);
|
|
}
|
|
check(count >= 1);
|
|
if (o.isMember("name")) {
|
|
name = as<std::string>(o["name"]);
|
|
}
|
|
if (o.isMember("normalized")) {
|
|
normalized = as<bool>(o["normalized"]);
|
|
}
|
|
if (o.isMember("sparse")) {
|
|
sparse = as<AccessorSparse>(o["sparse"]);
|
|
}
|
|
{
|
|
static std::unordered_map<Json::String, Type> map = {
|
|
{"MAT2", Type::MAT2},
|
|
{"MAT3", Type::MAT3},
|
|
{"MAT4", Type::MAT4},
|
|
{"SCALAR", Type::SCALAR},
|
|
{"VEC2", Type::VEC2},
|
|
{"VEC3", Type::VEC3},
|
|
{"VEC4", Type::VEC4},
|
|
};
|
|
const auto &v = o["type"]; check(v.isString());
|
|
type = map.at(v.asString());
|
|
}
|
|
if (o.isMember("max")) {
|
|
max = asVec<double>(o["max"]);
|
|
check(max->size() == typeCount());
|
|
}
|
|
if (o.isMember("min")) {
|
|
min = asVec<double>(o["min"]);
|
|
check(min->size() == typeCount());
|
|
}
|
|
}
|
|
};
|
|
template<> Accessor as(const Json::Value &o) { return o; }
|
|
|
|
struct AnimationChannelTarget {
|
|
std::optional<std::size_t> node;
|
|
enum class Path {
|
|
ROTATION,
|
|
SCALE,
|
|
TRANSLATION,
|
|
WEIGHTS,
|
|
};
|
|
Path path;
|
|
AnimationChannelTarget(const Json::Value &o)
|
|
{
|
|
check(o.isObject());
|
|
if (o.isMember("node")) {
|
|
node = as<std::size_t>(o["node"]);
|
|
}
|
|
{
|
|
static std::unordered_map<Json::String, Path> map = {
|
|
{"rotation", Path::ROTATION},
|
|
{"scale", Path::SCALE},
|
|
{"translation", Path::TRANSLATION},
|
|
{"weights", Path::WEIGHTS},
|
|
};
|
|
const auto &v = o["path"]; check(v.isString());
|
|
path = map.at(v.asString());
|
|
}
|
|
}
|
|
};
|
|
template<> AnimationChannelTarget as(const Json::Value &o) { return o; }
|
|
|
|
struct AnimationChannel {
|
|
std::size_t sampler;
|
|
AnimationChannelTarget target;
|
|
AnimationChannel(const Json::Value &o)
|
|
: sampler(as<std::size_t>(o["sampler"]))
|
|
, target(as<AnimationChannelTarget>(o["target"]))
|
|
{
|
|
check(o.isObject());
|
|
}
|
|
};
|
|
template<> AnimationChannel as(const Json::Value &o) { return o; }
|
|
|
|
struct AnimationSampler {
|
|
std::size_t input;
|
|
enum class Interpolation {
|
|
CUBICSPLINE,
|
|
LINEAR,
|
|
STEP,
|
|
};
|
|
Interpolation interpolation;
|
|
std::size_t output;
|
|
AnimationSampler(const Json::Value &o)
|
|
: input(as<std::size_t>(o["input"]))
|
|
, interpolation(Interpolation::LINEAR)
|
|
, output(as<std::size_t>(o["output"]))
|
|
{
|
|
check(o.isObject());
|
|
if (o.isMember("interpolation")) {
|
|
static std::unordered_map<Json::String, Interpolation> map = {
|
|
{"CUBICSPLINE", Interpolation::CUBICSPLINE},
|
|
{"LINEAR", Interpolation::LINEAR},
|
|
{"STEP", Interpolation::STEP},
|
|
};
|
|
const auto &v = o["interpolation"]; check(v.isString());
|
|
interpolation = map.at(v.asString());
|
|
}
|
|
}
|
|
};
|
|
template<> AnimationSampler as(const Json::Value &o) { return o; }
|
|
|
|
struct Animation {
|
|
std::vector<AnimationChannel> channels;
|
|
std::optional<std::string> name;
|
|
std::vector<AnimationSampler> samplers;
|
|
Animation(const Json::Value &o)
|
|
: channels(asVec<AnimationChannel>(o["channels"]))
|
|
, samplers(asVec<AnimationSampler>(o["samplers"]))
|
|
{
|
|
check(o.isObject());
|
|
check(channels.size() >= 1);
|
|
if (o.isMember("name")) {
|
|
name = as<std::string>(o["name"]);
|
|
}
|
|
check(samplers.size() >= 1);
|
|
}
|
|
};
|
|
template<> Animation as(const Json::Value &o) { return o; }
|
|
|
|
struct Asset {
|
|
std::optional<std::string> copyright;
|
|
std::optional<std::string> generator;
|
|
std::optional<std::string> minVersion;
|
|
std::string version;
|
|
Asset(const Json::Value &o)
|
|
: version(as<std::string>(o["version"]))
|
|
{
|
|
check(o.isObject());
|
|
if (o.isMember("copyright")) {
|
|
copyright = as<std::string>(o["copyright"]);
|
|
}
|
|
if (o.isMember("generator")) {
|
|
generator = as<std::string>(o["generator"]);
|
|
}
|
|
if (o.isMember("minVersion")) {
|
|
minVersion = as<std::string>(o["minVersion"]);
|
|
}
|
|
}
|
|
};
|
|
template<> Asset as(const Json::Value &o) { return o; }
|
|
|
|
struct BufferView {
|
|
std::size_t buffer;
|
|
std::size_t byteLength;
|
|
std::size_t byteOffset;
|
|
std::optional<std::size_t> byteStride;
|
|
std::optional<std::string> name;
|
|
enum class Target {
|
|
ARRAY_BUFFER,
|
|
ELEMENT_ARRAY_BUFFER,
|
|
};
|
|
std::optional<Target> target;
|
|
BufferView(const Json::Value &o)
|
|
: buffer(as<std::size_t>(o["buffer"]))
|
|
, byteLength(as<std::size_t>(o["byteLength"]))
|
|
, byteOffset(0)
|
|
{
|
|
check(o.isObject());
|
|
check(byteLength >= 1);
|
|
if (o.isMember("byteOffset")) {
|
|
byteOffset = as<std::size_t>(o["byteOffset"]);
|
|
check(byteOffset >= 0);
|
|
}
|
|
if (o.isMember("byteStride")) {
|
|
byteStride = as<std::size_t>(o["byteStride"]);
|
|
check(byteStride.value() >= 4);
|
|
check(byteStride.value() <= 252);
|
|
check(byteStride.value() % 4 == 0);
|
|
}
|
|
if (o.isMember("name")) {
|
|
name = as<std::string>(o["name"]);
|
|
}
|
|
if (o.isMember("target")) {
|
|
static std::unordered_map<Json::UInt64, Target> map = {
|
|
{34962, Target::ARRAY_BUFFER},
|
|
{34963, Target::ELEMENT_ARRAY_BUFFER},
|
|
};
|
|
const auto &v = o["target"]; check(v.isUInt64());
|
|
target = map.at(v.asUInt64());
|
|
}
|
|
}
|
|
};
|
|
template<> BufferView as(const Json::Value &o) { return o; }
|
|
|
|
struct Buffer {
|
|
std::size_t byteLength;
|
|
std::optional<std::string> name;
|
|
std::string data;
|
|
Buffer(const Json::Value &o,
|
|
const std::function<std::string(const std::string &uri)> &resolveURI)
|
|
: byteLength(as<std::size_t>(o["byteLength"]))
|
|
{
|
|
check(o.isObject());
|
|
check(byteLength >= 1);
|
|
if (o.isMember("name")) {
|
|
name = as<std::string>(o["name"]);
|
|
}
|
|
check(o.isMember("uri"));
|
|
bool dataURI = false;
|
|
const std::string uri = as<std::string>(o["uri"]);
|
|
for (auto &prefix : std::array<std::string, 2> {
|
|
"data:application/octet-stream;base64,",
|
|
"data:application/gltf-buffer;base64,"
|
|
}) {
|
|
if (std::string_view(uri).substr(0, prefix.length()) == prefix) {
|
|
auto view = std::string_view(uri).substr(prefix.length());
|
|
check(base64_is_valid(view));
|
|
data = base64_decode(view);
|
|
dataURI = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!dataURI)
|
|
data = resolveURI(uri);
|
|
check(data.size() >= byteLength);
|
|
data.resize(byteLength);
|
|
}
|
|
};
|
|
|
|
struct CameraOrthographic {
|
|
double xmag;
|
|
double ymag;
|
|
double zfar;
|
|
double znear;
|
|
CameraOrthographic(const Json::Value &o)
|
|
: xmag(as<double>(o["xmag"]))
|
|
, ymag(as<double>(o["ymag"]))
|
|
, zfar(as<double>(o["zfar"]))
|
|
, znear(as<double>(o["znear"]))
|
|
{
|
|
check(o.isObject());
|
|
check(zfar > 0);
|
|
check(znear >= 0);
|
|
}
|
|
};
|
|
template<> CameraOrthographic as(const Json::Value &o) { return o; }
|
|
|
|
struct CameraPerspective {
|
|
std::optional<double> aspectRatio;
|
|
double yfov;
|
|
std::optional<double> zfar;
|
|
double znear;
|
|
CameraPerspective(const Json::Value &o)
|
|
: yfov(as<double>(o["yfov"]))
|
|
, znear(as<double>(o["znear"]))
|
|
{
|
|
check(o.isObject());
|
|
if (o.isMember("aspectRatio")) {
|
|
aspectRatio = as<double>(o["aspectRatio"]);
|
|
check(aspectRatio.value() > 0);
|
|
}
|
|
check(yfov > 0);
|
|
if (o.isMember("zfar")) {
|
|
zfar = as<double>(o["zfar"]);
|
|
check(zfar.value() > 0);
|
|
}
|
|
check(znear > 0);
|
|
}
|
|
};
|
|
template<> CameraPerspective as(const Json::Value &o) { return o; }
|
|
|
|
struct Camera {
|
|
std::optional<std::string> name;
|
|
std::optional<CameraOrthographic> orthographic;
|
|
std::optional<CameraPerspective> perspective;
|
|
enum class Type {
|
|
ORTHOGRAPHIC,
|
|
PERSPECTIVE,
|
|
};
|
|
Type type;
|
|
Camera(const Json::Value &o)
|
|
{
|
|
check(o.isObject());
|
|
if (o.isMember("name")) {
|
|
name = as<std::string>(o["name"]);
|
|
}
|
|
if (o.isMember("orthographic")) {
|
|
orthographic = as<CameraOrthographic>(o["orthographic"]);
|
|
}
|
|
if (o.isMember("perspective")) {
|
|
perspective = as<CameraPerspective>(o["perspective"]);
|
|
}
|
|
{
|
|
static std::unordered_map<Json::String, Type> map = {
|
|
{"orthographic", Type::ORTHOGRAPHIC},
|
|
{"perspective", Type::PERSPECTIVE},
|
|
};
|
|
const auto &v = o["type"]; check(v.isString());
|
|
type = map.at(v.asString());
|
|
}
|
|
}
|
|
};
|
|
template<> Camera as(const Json::Value &o) { return o; }
|
|
|
|
struct Image {
|
|
std::optional<std::size_t> bufferView;
|
|
enum class MimeType {
|
|
IMAGE_JPEG,
|
|
IMAGE_PNG,
|
|
};
|
|
std::optional<MimeType> mimeType;
|
|
std::optional<std::string> name;
|
|
std::optional<std::string> uri;
|
|
Image(const Json::Value &o)
|
|
{
|
|
check(o.isObject());
|
|
if (o.isMember("bufferView")) {
|
|
bufferView = as<std::size_t>(o["bufferView"]);
|
|
}
|
|
if (o.isMember("mimeType")) {
|
|
static std::unordered_map<Json::String, MimeType> map = {
|
|
{"image/jpeg", MimeType::IMAGE_JPEG},
|
|
{"image/png", MimeType::IMAGE_PNG},
|
|
};
|
|
const auto &v = o["mimeType"]; check(v.isString());
|
|
mimeType = map.at(v.asString());
|
|
}
|
|
if (o.isMember("name")) {
|
|
name = as<std::string>(o["name"]);
|
|
}
|
|
if (o.isMember("uri")) {
|
|
uri = as<std::string>(o["uri"]);
|
|
}
|
|
}
|
|
};
|
|
template<> Image as(const Json::Value &o) { return o; }
|
|
|
|
struct TextureInfo {
|
|
std::size_t index;
|
|
std::size_t texCoord;
|
|
TextureInfo(const Json::Value &o)
|
|
: index(as<std::size_t>(o["index"]))
|
|
, texCoord(0)
|
|
{
|
|
check(o.isObject());
|
|
if (o.isMember("texCoord")) {
|
|
texCoord = as<std::size_t>(o["texCoord"]);
|
|
check(texCoord >= 0);
|
|
}
|
|
}
|
|
};
|
|
template<> TextureInfo as(const Json::Value &o) { return o; }
|
|
|
|
struct MaterialNormalTextureInfo {
|
|
std::size_t index;
|
|
double scale;
|
|
std::size_t texCoord;
|
|
MaterialNormalTextureInfo(const Json::Value &o)
|
|
: index(as<std::size_t>(o["index"]))
|
|
, scale(1)
|
|
, texCoord(0)
|
|
{
|
|
check(o.isObject());
|
|
if (o.isMember("scale")) {
|
|
scale = as<double>(o["scale"]);
|
|
}
|
|
if (o.isMember("texCoord")) {
|
|
texCoord = as<std::size_t>(o["texCoord"]);
|
|
}
|
|
}
|
|
};
|
|
template<> MaterialNormalTextureInfo as(const Json::Value &o) { return o; }
|
|
|
|
struct MaterialOcclusionTextureInfo {
|
|
std::size_t index;
|
|
double strength;
|
|
std::size_t texCoord;
|
|
MaterialOcclusionTextureInfo(const Json::Value &o)
|
|
: index(as<std::size_t>(o["index"]))
|
|
, strength(1)
|
|
, texCoord(0)
|
|
{
|
|
check(o.isObject());
|
|
if (o.isMember("strength")) {
|
|
strength = as<double>(o["strength"]);
|
|
check(strength >= 0);
|
|
check(strength <= 1);
|
|
}
|
|
if (o.isMember("texCoord")) {
|
|
texCoord = as<std::size_t>(o["texCoord"]);
|
|
}
|
|
}
|
|
};
|
|
template<> MaterialOcclusionTextureInfo as(const Json::Value &o) { return o; }
|
|
|
|
struct MaterialPbrMetallicRoughness {
|
|
std::array<double, 4> baseColorFactor;
|
|
std::optional<TextureInfo> baseColorTexture;
|
|
double metallicFactor;
|
|
std::optional<TextureInfo> metallicRoughnessTexture;
|
|
double roughnessFactor;
|
|
MaterialPbrMetallicRoughness(const Json::Value &o)
|
|
: baseColorFactor{1, 1, 1, 1}
|
|
, metallicFactor(1)
|
|
, roughnessFactor(1)
|
|
{
|
|
check(o.isObject());
|
|
if (o.isMember("baseColorFactor")) {
|
|
baseColorFactor = asArr<double, 4>(o["baseColorFactor"]);
|
|
for (auto v: baseColorFactor) {
|
|
check(v >= 0);
|
|
check(v <= 1);
|
|
}
|
|
}
|
|
if (o.isMember("baseColorTexture")) {
|
|
baseColorTexture = as<TextureInfo>(o["baseColorTexture"]);
|
|
}
|
|
if (o.isMember("metallicFactor")) {
|
|
metallicFactor = as<double>(o["metallicFactor"]);
|
|
check(metallicFactor >= 0);
|
|
check(metallicFactor <= 1);
|
|
}
|
|
if (o.isMember("metallicRoughnessTexture")) {
|
|
metallicRoughnessTexture = as<TextureInfo>(o["metallicRoughnessTexture"]);
|
|
}
|
|
if (o.isMember("roughnessFactor")) {
|
|
roughnessFactor = as<double>(o["roughnessFactor"]);
|
|
check(roughnessFactor >= 0);
|
|
check(roughnessFactor <= 1);
|
|
}
|
|
}
|
|
};
|
|
template<> MaterialPbrMetallicRoughness as(const Json::Value &o) { return o; }
|
|
|
|
struct Material {
|
|
double alphaCutoff;
|
|
enum class AlphaMode {
|
|
BLEND,
|
|
MASK,
|
|
OPAQUE,
|
|
};
|
|
AlphaMode alphaMode;
|
|
bool doubleSided;
|
|
std::array<double, 3> emissiveFactor;
|
|
std::optional<TextureInfo> emissiveTexture;
|
|
std::optional<std::string> name;
|
|
std::optional<MaterialNormalTextureInfo> normalTexture;
|
|
std::optional<MaterialOcclusionTextureInfo> occlusionTexture;
|
|
std::optional<MaterialPbrMetallicRoughness> pbrMetallicRoughness;
|
|
Material(const Json::Value &o)
|
|
: alphaCutoff(0.5)
|
|
, alphaMode(AlphaMode::OPAQUE)
|
|
, doubleSided(false)
|
|
, emissiveFactor{0, 0, 0}
|
|
{
|
|
check(o.isObject());
|
|
if (o.isMember("alphaCutoff")) {
|
|
alphaCutoff = as<double>(o["alphaCutoff"]);
|
|
check(alphaCutoff >= 0);
|
|
}
|
|
if (o.isMember("alphaMode")){
|
|
static std::unordered_map<Json::String, AlphaMode> map = {
|
|
{"BLEND", AlphaMode::BLEND},
|
|
{"MASK", AlphaMode::MASK},
|
|
{"OPAQUE", AlphaMode::OPAQUE},
|
|
};
|
|
const auto &v = o["alphaMode"]; check(v.isString());
|
|
alphaMode = map.at(v.asString());
|
|
}
|
|
if (o.isMember("doubleSided")) {
|
|
doubleSided = as<bool>(o["doubleSided"]);
|
|
}
|
|
if (o.isMember("emissiveFactor")) {
|
|
emissiveFactor = asArr<double, 3>(o["emissiveFactor"]);
|
|
for (const auto &v: emissiveFactor) {
|
|
check(v >= 0);
|
|
check(v <= 1);
|
|
}
|
|
}
|
|
if (o.isMember("emissiveTexture")) {
|
|
emissiveTexture = as<TextureInfo>(o["emissiveTexture"]);
|
|
}
|
|
if (o.isMember("name")) {
|
|
name = as<std::string>(o["name"]);
|
|
}
|
|
if (o.isMember("normalTexture")) {
|
|
normalTexture = as<MaterialNormalTextureInfo>(o["normalTexture"]);
|
|
}
|
|
if (o.isMember("occlusionTexture")) {
|
|
occlusionTexture = as<MaterialOcclusionTextureInfo>(o["occlusionTexture"]);
|
|
}
|
|
if (o.isMember("pbrMetallicRoughness")) {
|
|
pbrMetallicRoughness = as<MaterialPbrMetallicRoughness>(o["pbrMetallicRoughness"]);
|
|
}
|
|
}
|
|
};
|
|
template<> Material as(const Json::Value &o) { return o; }
|
|
|
|
struct MeshPrimitive {
|
|
static void enumeratedProps(const Json::Value &o, const std::string &name, std::optional<std::vector<std::size_t>> &attr) {
|
|
for (std::size_t i = 0;; ++i) {
|
|
const std::string s = name + "_" + std::to_string(i);
|
|
if (!o.isMember(s)) break;
|
|
if (i == 0) {
|
|
attr = std::vector<std::size_t>();
|
|
}
|
|
attr->push_back(as<std::size_t>(o[s]));
|
|
}
|
|
}
|
|
struct Attributes {
|
|
std::optional<std::size_t> position, normal, tangent;
|
|
std::optional<std::vector<std::size_t>> texcoord, color, joints, weights;
|
|
Attributes(const Json::Value &o) {
|
|
if (o.isMember("POSITION"))
|
|
position = as<std::size_t>(o["POSITION"]);
|
|
if (o.isMember("NORMAL"))
|
|
normal = as<std::size_t>(o["NORMAL"]);
|
|
if (o.isMember("TANGENT"))
|
|
tangent = as<std::size_t>(o["TANGENT"]);
|
|
enumeratedProps(o, "TEXCOORD", texcoord);
|
|
enumeratedProps(o, "COLOR", color);
|
|
enumeratedProps(o, "JOINTS", joints);
|
|
enumeratedProps(o, "WEIGHTS", weights);
|
|
check(joints.has_value() == weights.has_value());
|
|
if (joints.has_value()) {
|
|
check(joints->size() == weights->size());
|
|
}
|
|
check(position.has_value()
|
|
|| normal.has_value()
|
|
|| tangent.has_value()
|
|
|| texcoord.has_value()
|
|
|| color.has_value()
|
|
|| joints.has_value()
|
|
|| weights.has_value());
|
|
}
|
|
};
|
|
Attributes attributes;
|
|
std::optional<std::size_t> indices;
|
|
std::optional<std::size_t> material;
|
|
enum class Mode {
|
|
POINTS,
|
|
LINES,
|
|
LINE_LOOP,
|
|
LINE_STRIP,
|
|
TRIANGLES,
|
|
TRIANGLE_STRIP,
|
|
TRIANGLE_FAN,
|
|
};
|
|
Mode mode;
|
|
struct MorphTargets {
|
|
std::optional<std::size_t> position, normal, tangent;
|
|
std::optional<std::vector<std::size_t>> texcoord, color;
|
|
MorphTargets(const Json::Value &o) {
|
|
if (o.isMember("POSITION"))
|
|
position = as<std::size_t>(o["POSITION"]);
|
|
if (o.isMember("NORMAL"))
|
|
normal = as<std::size_t>(o["NORMAL"]);
|
|
if (o.isMember("TANGENT"))
|
|
tangent = as<std::size_t>(o["TANGENT"]);
|
|
enumeratedProps(o, "TEXCOORD", texcoord);
|
|
enumeratedProps(o, "COLOR", color);
|
|
check(position.has_value()
|
|
|| normal.has_value()
|
|
|| tangent.has_value()
|
|
|| texcoord.has_value()
|
|
|| color.has_value());
|
|
}
|
|
};
|
|
std::optional<std::vector<MorphTargets>> targets;
|
|
MeshPrimitive(const Json::Value &o)
|
|
: attributes(Attributes(o["attributes"]))
|
|
, mode(Mode::TRIANGLES)
|
|
{
|
|
check(o.isObject());
|
|
if (o.isMember("indices")) {
|
|
indices = as<std::size_t>(o["indices"]);
|
|
}
|
|
if (o.isMember("material")) {
|
|
material = as<std::size_t>(o["material"]);
|
|
}
|
|
if (o.isMember("mode")) {
|
|
static std::unordered_map<Json::UInt64, Mode> map = {
|
|
{0, Mode::POINTS},
|
|
{1, Mode::LINES},
|
|
{2, Mode::LINE_LOOP},
|
|
{3, Mode::LINE_STRIP},
|
|
{4, Mode::TRIANGLES},
|
|
{5, Mode::TRIANGLE_STRIP},
|
|
{6, Mode::TRIANGLE_FAN},
|
|
};
|
|
const auto &v = o["mode"]; check(v.isUInt64());
|
|
mode = map.at(v.asUInt64());
|
|
}
|
|
if (o.isMember("targets")) {
|
|
targets = asVec<MorphTargets>(o["targets"]);
|
|
check(targets->size() >= 1);
|
|
}
|
|
}
|
|
};
|
|
template<> MeshPrimitive::MorphTargets as(const Json::Value &o) { return o; }
|
|
template<> MeshPrimitive as(const Json::Value &o) { return o; }
|
|
|
|
struct Mesh {
|
|
std::optional<std::string> name;
|
|
std::vector<MeshPrimitive> primitives;
|
|
std::optional<std::vector<double>> weights;
|
|
Mesh(const Json::Value &o)
|
|
: primitives(asVec<MeshPrimitive>(o["primitives"]))
|
|
{
|
|
check(o.isObject());
|
|
if (o.isMember("name")) {
|
|
name = as<std::string>(o["name"]);
|
|
}
|
|
check(primitives.size() >= 1);
|
|
if (o.isMember("weights")) {
|
|
weights = asVec<double>(o["weights"]);
|
|
check(weights->size() >= 1);
|
|
}
|
|
}
|
|
};
|
|
template<> Mesh as(const Json::Value &o) { return o; }
|
|
|
|
struct Node {
|
|
std::optional<std::size_t> camera;
|
|
std::optional<std::vector<std::size_t>> children;
|
|
typedef std::array<double, 16> Matrix;
|
|
struct TRS {
|
|
std::array<double, 3> translation = {0, 0, 0};
|
|
std::array<double, 4> rotation = {0, 0, 0, 1};
|
|
std::array<double, 3> scale = {1, 1, 1};
|
|
};
|
|
std::variant<Matrix, TRS> transform;
|
|
std::optional<std::size_t> mesh;
|
|
std::optional<std::string> name;
|
|
std::optional<std::size_t> skin;
|
|
std::optional<std::vector<double>> weights;
|
|
Node(const Json::Value &o)
|
|
: transform(Matrix {
|
|
1, 0, 0, 0,
|
|
0, 1, 0, 0,
|
|
0, 0, 1, 0,
|
|
0, 0, 0, 1
|
|
})
|
|
{
|
|
check(o.isObject());
|
|
if (o.isMember("camera")) {
|
|
camera = as<std::size_t>(o["camera"]);
|
|
}
|
|
if (o.isMember("children")) {
|
|
children = asVec<std::size_t>(o["children"]);
|
|
check(children->size() >= 1);
|
|
checkDuplicateFree(*children);
|
|
}
|
|
bool hasTRS = o.isMember("translation") || o.isMember("rotation") || o.isMember("scale");
|
|
if (o.isMember("matrix")) {
|
|
check(!hasTRS);
|
|
transform = asArr<double, 16>(o["matrix"]);
|
|
} else if (hasTRS) {
|
|
TRS trs;
|
|
if (o.isMember("translation")) {
|
|
trs.translation = asArr<double, 3>(o["translation"]);
|
|
}
|
|
if (o.isMember("rotation")) {
|
|
trs.rotation = asArr<double, 4>(o["rotation"]);
|
|
for (auto v: trs.rotation) {
|
|
check(v >= -1);
|
|
check(v <= 1);
|
|
}
|
|
}
|
|
if (o.isMember("scale")) {
|
|
trs.scale = asArr<double, 3>(o["scale"]);
|
|
}
|
|
transform = trs;
|
|
}
|
|
if (o.isMember("mesh")) {
|
|
mesh = as<std::size_t>(o["mesh"]);
|
|
}
|
|
if (o.isMember("name")) {
|
|
name = as<std::string>(o["name"]);
|
|
}
|
|
if (o.isMember("skin")) {
|
|
check(mesh.has_value());
|
|
skin = as<std::size_t>(o["skin"]);
|
|
}
|
|
if (o.isMember("weights")) {
|
|
weights = asVec<double>(o["weights"]);
|
|
check(weights->size() >= 1);
|
|
}
|
|
}
|
|
};
|
|
template<> Node as(const Json::Value &o) { return o; }
|
|
|
|
struct Sampler {
|
|
enum class MagFilter {
|
|
NEAREST,
|
|
LINEAR,
|
|
};
|
|
std::optional<MagFilter> magFilter;
|
|
enum class MinFilter {
|
|
NEAREST,
|
|
LINEAR,
|
|
NEAREST_MIPMAP_NEAREST,
|
|
LINEAR_MIPMAP_NEAREST,
|
|
NEAREST_MIPMAP_LINEAR,
|
|
LINEAR_MIPMAP_LINEAR,
|
|
};
|
|
std::optional<MinFilter> minFilter;
|
|
std::optional<std::string> name;
|
|
enum class WrapS {
|
|
REPEAT,
|
|
CLAMP_TO_EDGE,
|
|
MIRRORED_REPEAT,
|
|
};
|
|
WrapS wrapS;
|
|
enum class WrapT {
|
|
REPEAT,
|
|
CLAMP_TO_EDGE,
|
|
MIRRORED_REPEAT,
|
|
};
|
|
WrapT wrapT;
|
|
Sampler(const Json::Value &o)
|
|
: wrapS(WrapS::REPEAT)
|
|
, wrapT(WrapT::REPEAT)
|
|
{
|
|
check(o.isObject());
|
|
if (o.isMember("magFilter")) {
|
|
static std::unordered_map<Json::UInt64, MagFilter> map = {
|
|
{9728, MagFilter::NEAREST},
|
|
{9729, MagFilter::LINEAR},
|
|
};
|
|
const auto &v = o["magFilter"]; check(v.isUInt64());
|
|
magFilter = map.at(v.asUInt64());
|
|
}
|
|
if (o.isMember("minFilter")) {
|
|
static std::unordered_map<Json::UInt64, MinFilter> map = {
|
|
{9728, MinFilter::NEAREST},
|
|
{9729, MinFilter::LINEAR},
|
|
{9984, MinFilter::NEAREST_MIPMAP_NEAREST},
|
|
{9985, MinFilter::LINEAR_MIPMAP_NEAREST},
|
|
{9986, MinFilter::NEAREST_MIPMAP_LINEAR},
|
|
{9987, MinFilter::LINEAR_MIPMAP_LINEAR},
|
|
};
|
|
const auto &v = o["minFilter"]; check(v.isUInt64());
|
|
minFilter = map.at(v.asUInt64());
|
|
}
|
|
if (o.isMember("name")) {
|
|
name = as<std::string>(o["name"]);
|
|
}
|
|
if (o.isMember("wrapS")) {
|
|
static std::unordered_map<Json::UInt64, WrapS> map = {
|
|
{10497, WrapS::REPEAT},
|
|
{33071, WrapS::CLAMP_TO_EDGE},
|
|
{33648, WrapS::MIRRORED_REPEAT},
|
|
};
|
|
const auto &v = o["wrapS"]; check(v.isUInt64());
|
|
wrapS = map.at(v.asUInt64());
|
|
}
|
|
if (o.isMember("wrapT")) {
|
|
static std::unordered_map<Json::UInt64, WrapT> map = {
|
|
{10497, WrapT::REPEAT},
|
|
{33071, WrapT::CLAMP_TO_EDGE},
|
|
{33648, WrapT::MIRRORED_REPEAT},
|
|
};
|
|
const auto &v = o["wrapT"]; check(v.isUInt64());
|
|
wrapT = map.at(v.asUInt64());
|
|
}
|
|
}
|
|
};
|
|
template<> Sampler as(const Json::Value &o) { return o; }
|
|
|
|
struct Scene {
|
|
std::optional<std::string> name;
|
|
std::optional<std::vector<std::size_t>> nodes;
|
|
Scene(const Json::Value &o)
|
|
{
|
|
check(o.isObject());
|
|
if (o.isMember("name")) {
|
|
name = as<std::string>(o["name"]);
|
|
}
|
|
if (o.isMember("nodes")) {
|
|
nodes = asVec<std::size_t>(o["nodes"]);
|
|
check(nodes->size() >= 1);
|
|
checkDuplicateFree(*nodes);
|
|
}
|
|
}
|
|
};
|
|
template<> Scene as(const Json::Value &o) { return o; }
|
|
|
|
struct Skin {
|
|
std::optional<std::size_t> inverseBindMatrices;
|
|
std::vector<std::size_t> joints;
|
|
std::optional<std::string> name;
|
|
std::optional<std::size_t> skeleton;
|
|
Skin(const Json::Value &o)
|
|
: joints(asVec<std::size_t>(o["joints"]))
|
|
{
|
|
check(o.isObject());
|
|
if (o.isMember("inverseBindMatrices")) {
|
|
inverseBindMatrices = as<std::size_t>(o["inverseBindMatrices"]);
|
|
}
|
|
check(joints.size() >= 1);
|
|
checkDuplicateFree(joints);
|
|
if (o.isMember("name")) {
|
|
name = as<std::string>(o["name"]);
|
|
}
|
|
if (o.isMember("skeleton")) {
|
|
skeleton = as<std::size_t>(o["skeleton"]);
|
|
}
|
|
}
|
|
};
|
|
template<> Skin as(const Json::Value &o) { return o; }
|
|
|
|
struct Texture {
|
|
std::optional<std::string> name;
|
|
std::optional<std::size_t> sampler;
|
|
std::optional<std::size_t> source;
|
|
Texture(const Json::Value &o)
|
|
{
|
|
check(o.isObject());
|
|
if (o.isMember("name")) {
|
|
name = as<std::string>(o["name"]);
|
|
}
|
|
if (o.isMember("sampler")) {
|
|
sampler = as<std::size_t>(o["sampler"]);
|
|
}
|
|
if (o.isMember("source")) {
|
|
source = as<std::size_t>(o["source"]);
|
|
}
|
|
}
|
|
};
|
|
template<> Texture as(const Json::Value &o) { return o; }
|
|
|
|
struct GlTF {
|
|
std::optional<std::vector<Accessor>> accessors;
|
|
std::optional<std::vector<Animation>> animations;
|
|
Asset asset;
|
|
std::optional<std::vector<BufferView>> bufferViews;
|
|
std::optional<std::vector<Buffer>> buffers;
|
|
std::optional<std::vector<Camera>> cameras;
|
|
std::optional<std::vector<std::string>> extensionsRequired;
|
|
std::optional<std::vector<std::string>> extensionsUsed;
|
|
std::optional<std::vector<Image>> images;
|
|
std::optional<std::vector<Material>> materials;
|
|
std::optional<std::vector<Mesh>> meshes;
|
|
std::optional<std::vector<Node>> nodes;
|
|
std::optional<std::vector<Sampler>> samplers;
|
|
std::optional<std::size_t> scene;
|
|
std::optional<std::vector<Scene>> scenes;
|
|
std::optional<std::vector<Skin>> skins;
|
|
std::optional<std::vector<Texture>> textures;
|
|
static std::string uriError(const std::string &uri) {
|
|
// only base64 data URI support by default
|
|
throw std::runtime_error("unsupported URI: " + uri);
|
|
}
|
|
GlTF(const Json::Value &o,
|
|
const std::function<std::string(const std::string &uri)> &resolveURI = uriError)
|
|
: asset(as<Asset>(o["asset"]))
|
|
{
|
|
check(o.isObject());
|
|
if (o.isMember("accessors")) {
|
|
accessors = asVec<Accessor>(o["accessors"]);
|
|
check(accessors->size() >= 1);
|
|
}
|
|
if (o.isMember("animations")) {
|
|
animations = asVec<Animation>(o["animations"]);
|
|
check(animations->size() >= 1);
|
|
}
|
|
if (o.isMember("bufferViews")) {
|
|
bufferViews = asVec<BufferView>(o["bufferViews"]);
|
|
check(bufferViews->size() >= 1);
|
|
}
|
|
if (o.isMember("buffers")) {
|
|
auto b = o["buffers"];
|
|
check(b.isArray());
|
|
std::vector<Buffer> bufs;
|
|
bufs.reserve(b.size());
|
|
for (Json::ArrayIndex i = 0; i < b.size(); ++i) {
|
|
bufs.emplace_back(b[i], resolveURI);
|
|
}
|
|
check(bufs.size() >= 1);
|
|
buffers = std::move(bufs);
|
|
}
|
|
if (o.isMember("cameras")) {
|
|
cameras = asVec<Camera>(o["cameras"]);
|
|
check(cameras->size() >= 1);
|
|
}
|
|
if (o.isMember("extensionsRequired")) {
|
|
extensionsRequired = asVec<std::string>(o["extensionsRequired"]);
|
|
check(extensionsRequired->size() >= 1);
|
|
checkDuplicateFree(*extensionsRequired);
|
|
}
|
|
if (o.isMember("extensionsUsed")) {
|
|
extensionsUsed = asVec<std::string>(o["extensionsUsed"]);
|
|
check(extensionsUsed->size() >= 1);
|
|
checkDuplicateFree(*extensionsUsed);
|
|
}
|
|
if (o.isMember("images")) {
|
|
images = asVec<Image>(o["images"]);
|
|
check(images->size() >= 1);
|
|
}
|
|
if (o.isMember("materials")) {
|
|
materials = asVec<Material>(o["materials"]);
|
|
check(materials->size() >= 1);
|
|
}
|
|
if (o.isMember("meshes")) {
|
|
meshes = asVec<Mesh>(o["meshes"]);
|
|
check(meshes->size() >= 1);
|
|
}
|
|
if (o.isMember("nodes")) {
|
|
nodes = asVec<Node>(o["nodes"]);
|
|
check(nodes->size() >= 1);
|
|
// Nodes must be a forest:
|
|
// 1. Each node should have indegree 0 or 1:
|
|
std::vector<std::size_t> indeg(nodes->size());
|
|
for (std::size_t i = 0; i < nodes->size(); ++i) {
|
|
auto children = nodes->at(i).children;
|
|
if (!children.has_value()) continue;
|
|
for (auto child : children.value()) {
|
|
++indeg.at(child);
|
|
}
|
|
}
|
|
for (const auto deg : indeg) {
|
|
check(deg <= 1);
|
|
}
|
|
// 2. There should be no cycles:
|
|
std::vector<bool> visited(nodes->size());
|
|
std::stack<std::size_t, std::vector<std::size_t>> toVisit;
|
|
for (std::size_t i = 0; i < nodes->size(); ++i) {
|
|
// Only start DFS in roots.
|
|
if (indeg[i] > 0)
|
|
continue;
|
|
|
|
toVisit.push(i);
|
|
do {
|
|
std::size_t j = toVisit.top();
|
|
check(!visited.at(j));
|
|
visited[j] = true;
|
|
toVisit.pop();
|
|
auto children = nodes->at(j).children;
|
|
if (!children.has_value())
|
|
continue;
|
|
for (auto child : *children) {
|
|
toVisit.push(child);
|
|
}
|
|
} while (!toVisit.empty());
|
|
}
|
|
}
|
|
if (o.isMember("samplers")) {
|
|
samplers = asVec<Sampler>(o["samplers"]);
|
|
check(samplers->size() >= 1);
|
|
}
|
|
if (o.isMember("scene")) {
|
|
scene = as<std::size_t>(o["scene"]);
|
|
}
|
|
if (o.isMember("scenes")) {
|
|
scenes = asVec<Scene>(o["scenes"]);
|
|
check(scenes->size() >= 1);
|
|
}
|
|
if (o.isMember("skins")) {
|
|
skins = asVec<Skin>(o["skins"]);
|
|
check(skins->size() >= 1);
|
|
}
|
|
if (o.isMember("textures")) {
|
|
textures = asVec<Texture>(o["textures"]);
|
|
check(textures->size() >= 1);
|
|
}
|
|
|
|
// Validation
|
|
|
|
checkForall(bufferViews, [&](const BufferView &view) {
|
|
check(buffers.has_value());
|
|
const Buffer &buf = buffers->at(view.buffer);
|
|
// Be careful because of possible integer overflows.
|
|
check(view.byteOffset < buf.byteLength);
|
|
check(view.byteLength <= buf.byteLength);
|
|
check(view.byteOffset <= buf.byteLength - view.byteLength);
|
|
});
|
|
|
|
const auto checkAccessor = [&](const auto &accessor,
|
|
std::size_t bufferView, std::size_t byteOffset, std::size_t count) {
|
|
const BufferView &view = bufferViews->at(bufferView);
|
|
if (view.byteStride.has_value())
|
|
check(*view.byteStride % accessor.componentSize() == 0);
|
|
check(byteOffset < view.byteLength);
|
|
// Use division to avoid overflows.
|
|
const auto effective_byte_stride = view.byteStride.value_or(accessor.elementSize());
|
|
check(count <= (view.byteLength - byteOffset) / effective_byte_stride);
|
|
};
|
|
checkForall(accessors, [&](const Accessor &accessor) {
|
|
if (accessor.bufferView.has_value())
|
|
checkAccessor(accessor, *accessor.bufferView, accessor.byteOffset, accessor.count);
|
|
if (accessor.sparse.has_value()) {
|
|
const auto &indices = accessor.sparse->indices;
|
|
checkAccessor(indices, indices.bufferView, indices.byteOffset, accessor.sparse->count);
|
|
const auto &values = accessor.sparse->values;
|
|
checkAccessor(accessor, values.bufferView, values.byteOffset, accessor.sparse->count);
|
|
}
|
|
});
|
|
|
|
checkForall(images, [&](const Image &image) {
|
|
checkIndex(bufferViews, image.bufferView);
|
|
});
|
|
|
|
checkForall(meshes, [&](const Mesh &mesh) {
|
|
for (const auto &primitive : mesh.primitives) {
|
|
checkIndex(accessors, primitive.indices);
|
|
checkIndex(materials, primitive.material);
|
|
checkIndex(accessors, primitive.attributes.normal);
|
|
checkIndex(accessors, primitive.attributes.position);
|
|
checkIndex(accessors, primitive.attributes.tangent);
|
|
checkForall(primitive.attributes.texcoord, [&](const std::size_t &i) {
|
|
checkIndex(accessors, i);
|
|
});
|
|
checkForall(primitive.attributes.color, [&](const std::size_t &i) {
|
|
checkIndex(accessors, i);
|
|
});
|
|
checkForall(primitive.attributes.joints, [&](const std::size_t &i) {
|
|
checkIndex(accessors, i);
|
|
});
|
|
checkForall(primitive.attributes.weights, [&](const std::size_t &i) {
|
|
checkIndex(accessors, i);
|
|
});
|
|
if (primitive.material.has_value()) {
|
|
const Material &material = materials->at(primitive.material.value());
|
|
if (material.emissiveTexture.has_value()) {
|
|
check(primitive.attributes.texcoord.has_value());
|
|
check(material.emissiveTexture->texCoord < primitive.attributes.texcoord->size());
|
|
}
|
|
if (material.normalTexture.has_value()) {
|
|
check(primitive.attributes.texcoord.has_value());
|
|
check(material.normalTexture->texCoord < primitive.attributes.texcoord->size());
|
|
}
|
|
if (material.occlusionTexture.has_value()) {
|
|
check(primitive.attributes.texcoord.has_value());
|
|
check(material.occlusionTexture->texCoord < primitive.attributes.texcoord->size());
|
|
}
|
|
}
|
|
checkForall(primitive.targets, [&](const MeshPrimitive::MorphTargets &target) {
|
|
checkIndex(accessors, target.normal);
|
|
checkIndex(accessors, target.position);
|
|
checkIndex(accessors, target.tangent);
|
|
checkForall(target.texcoord, [&](const std::size_t &i) {
|
|
checkIndex(accessors, i);
|
|
});
|
|
checkForall(target.color, [&](const std::size_t &i) {
|
|
checkIndex(accessors, i);
|
|
});
|
|
});
|
|
}
|
|
});
|
|
|
|
checkForall(nodes, [&](const Node &node) {
|
|
checkIndex(cameras, node.camera);
|
|
checkIndex(meshes, node.mesh);
|
|
checkIndex(skins, node.skin);
|
|
});
|
|
|
|
checkForall(scenes, [&](const Scene &scene) {
|
|
checkForall(scene.nodes, [&](const size_t &i) {
|
|
checkIndex(nodes, i);
|
|
});
|
|
});
|
|
|
|
checkForall(skins, [&](const Skin &skin) {
|
|
checkIndex(accessors, skin.inverseBindMatrices);
|
|
for (const std::size_t &i : skin.joints)
|
|
checkIndex(nodes, i);
|
|
checkIndex(nodes, skin.skeleton);
|
|
});
|
|
|
|
checkForall(textures, [&](const Texture &texture) {
|
|
checkIndex(samplers, texture.sampler);
|
|
checkIndex(images, texture.source);
|
|
});
|
|
|
|
checkForall(animations, [&](const Animation &animation) {
|
|
for (const auto &sampler : animation.samplers) {
|
|
checkIndex(accessors, sampler.input);
|
|
const auto &accessor = accessors->at(sampler.input);
|
|
check(accessor.type == Accessor::Type::SCALAR);
|
|
check(accessor.componentType == Accessor::ComponentType::FLOAT);
|
|
checkIndex(accessors, sampler.output);
|
|
}
|
|
for (const auto &channel : animation.channels) {
|
|
checkIndex(nodes, channel.target.node);
|
|
checkIndex(animation.samplers, channel.sampler);
|
|
}
|
|
});
|
|
|
|
checkIndex(scenes, scene);
|
|
}
|
|
};
|
|
|
|
}
|