// This file has been generated by beamsplitter

#include "Settings_generated.h"

#include <filament/Options.h>
#include <utils/Log.h>

#include <ostream>
#include <cstring>

#include "jsonParseUtils.h"

using namespace utils;

namespace filament::viewer {

// Compares a JSON string token against a C string.
int compare(jsmntok_t tok, const char* jsonChunk, const char* str) {
    size_t slen = strlen(str);
    size_t tlen = tok.end - tok.start;
    return (slen == tlen) ? strncmp(jsonChunk + tok.start, str, slen) : 128;
}

std::ostream& writeJson(std::ostream& oss, const float* v, int count) {
    oss << "[";
    for (int i = 0; i < count; i++) {
        oss << v[i];
        if (i < count - 1) {
            oss << ", ";
        }
    }
    oss << "]";
    return oss;
}

std::ostream& operator<<(std::ostream& out, math::float2 v) {
    return writeJson(out, v.v, 2);
}

std::ostream& operator<<(std::ostream& out, math::float3 v) {
    return writeJson(out, v.v, 3);
}

std::ostream& operator<<(std::ostream& out, math::float4 v) {
    return writeJson(out, v.v, 4);
}

const char* to_string(bool b) { return b ? "true" : "false"; }

int parse(jsmntok_t const* tokens, int i, const char* jsonChunk, uint8_t* val) {
    CHECK_TOKTYPE(tokens[i], JSMN_PRIMITIVE);
    *val = strtol(jsonChunk + tokens[i].start, nullptr, 10);
    return i + 1;
}

int parse(jsmntok_t const* tokens, int i, const char* jsonChunk, uint16_t* val) {
    CHECK_TOKTYPE(tokens[i], JSMN_PRIMITIVE);
    *val = strtol(jsonChunk + tokens[i].start, nullptr, 10);
    return i + 1;
}

int parse(jsmntok_t const* tokens, int i, const char* jsonChunk, uint32_t* val) {
    CHECK_TOKTYPE(tokens[i], JSMN_PRIMITIVE);
    *val = strtol(jsonChunk + tokens[i].start, nullptr, 10);
    return i + 1;
}

int parse(jsmntok_t const* tokens, int i, const char* jsonChunk, int* val) {
    CHECK_TOKTYPE(tokens[i], JSMN_PRIMITIVE);
    *val = strtol(jsonChunk + tokens[i].start, nullptr, 10);
    return i + 1;
}

int parse(jsmntok_t const* tokens, int i, const char* jsonChunk, float* val) {
    CHECK_TOKTYPE(tokens[i], JSMN_PRIMITIVE);
    *val = strtod(jsonChunk + tokens[i].start, nullptr);
    return i + 1;
}

int parse(jsmntok_t const* tokens, int i, const char* jsonChunk, float* vals, int size) {
    CHECK_TOKTYPE(tokens[i], JSMN_ARRAY);
    if (tokens[i].size != size) {
        slog.w << "Expected " << size << " floats, got " << tokens[i].size << io::endl;
        return i + 1 + tokens[i].size;
    }
    ++i;
    for (int j = 0; j < size; ++j) {
        i = parse(tokens, i, jsonChunk, &vals[j]);
    }
    return i;
}

int parse(jsmntok_t const* tokens, int i, const char* jsonChunk, bool* val) {
    CHECK_TOKTYPE(tokens[i], JSMN_PRIMITIVE);
    if (0 == compare(tokens[i], jsonChunk, "true")) {
        *val = true;
        return i + 1;
    }
    if (0 == compare(tokens[i], jsonChunk, "false")) {
        *val = false;
        return i + 1;
    }
    return -1;
}

int parse(jsmntok_t const* tokens, int i, const char* jsonChunk, math::float2* val) {
    float values[2];
    i = parse(tokens, i, jsonChunk, values, 2);
    *val = {values[0], values[1]};
    return i;
}

int parse(jsmntok_t const* tokens, int i, const char* jsonChunk, math::float3* val) {
    float values[3];
    i = parse(tokens, i, jsonChunk, values, 3);
    *val = {values[0], values[1], values[2]};
    return i;
}

int parse(jsmntok_t const* tokens, int i, const char* jsonChunk, math::float4* val) {
    float values[4];
    i = parse(tokens, i, jsonChunk, values, 4);
    *val = {values[0], values[1], values[2], values[3]};
    return i;
}

int parse(jsmntok_t const* tokens, int i, const char* jsonChunk, QualityLevel* out) {
    if (0 == compare(tokens[i], jsonChunk, "LOW")) { *out = QualityLevel::LOW; }
    else if (0 == compare(tokens[i], jsonChunk, "MEDIUM")) { *out = QualityLevel::MEDIUM; }
    else if (0 == compare(tokens[i], jsonChunk, "HIGH")) { *out = QualityLevel::HIGH; }
    else if (0 == compare(tokens[i], jsonChunk, "ULTRA")) { *out = QualityLevel::ULTRA; }
    else {
        slog.w << "Invalid QualityLevel: '" << STR(tokens[i], jsonChunk) << "'" << io::endl;
    }
    return i + 1;
}

std::ostream& operator<<(std::ostream& out, QualityLevel in) {
    switch (in) {
        case QualityLevel::LOW: return out << "\"LOW\"";
        case QualityLevel::MEDIUM: return out << "\"MEDIUM\"";
        case QualityLevel::HIGH: return out << "\"HIGH\"";
        case QualityLevel::ULTRA: return out << "\"ULTRA\"";
    }
    return out << "\"INVALID\"";
}

int parse(jsmntok_t const* tokens, int i, const char* jsonChunk, BlendMode* out) {
    if (0 == compare(tokens[i], jsonChunk, "OPAQUE")) { *out = BlendMode::OPAQUE; }
    else if (0 == compare(tokens[i], jsonChunk, "TRANSLUCENT")) { *out = BlendMode::TRANSLUCENT; }
    else {
        slog.w << "Invalid BlendMode: '" << STR(tokens[i], jsonChunk) << "'" << io::endl;
    }
    return i + 1;
}

std::ostream& operator<<(std::ostream& out, BlendMode in) {
    switch (in) {
        case BlendMode::OPAQUE: return out << "\"OPAQUE\"";
        case BlendMode::TRANSLUCENT: return out << "\"TRANSLUCENT\"";
    }
    return out << "\"INVALID\"";
}

int parse(jsmntok_t const* tokens, int i, const char* jsonChunk, DynamicResolutionOptions* out) {
    CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
    int size = tokens[i++].size;
    for (int j = 0; j < size; ++j) {
        const jsmntok_t tok = tokens[i];
        CHECK_KEY(tok);
        if (compare(tok, jsonChunk, "minScale") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->minScale);
        } else if (compare(tok, jsonChunk, "maxScale") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->maxScale);
        } else if (compare(tok, jsonChunk, "sharpness") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->sharpness);
        } else if (compare(tok, jsonChunk, "enabled") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->enabled);
        } else if (compare(tok, jsonChunk, "homogeneousScaling") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->homogeneousScaling);
        } else if (compare(tok, jsonChunk, "quality") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->quality);
        } else {
            slog.w << "Invalid DynamicResolutionOptions key: '" << STR(tok, jsonChunk) << "'" << io::endl;
            i = parse(tokens, i + 1);
        }
        if (i < 0) {
            slog.e << "Invalid DynamicResolutionOptions value: '" << STR(tok, jsonChunk) << "'" << io::endl;
            return i;
        }
    }
    return i;
}

std::ostream& operator<<(std::ostream& out, const DynamicResolutionOptions& in) {
    return out << "{\n"
        << "\"minScale\": " << (in.minScale) << ",\n"
        << "\"maxScale\": " << (in.maxScale) << ",\n"
        << "\"sharpness\": " << (in.sharpness) << ",\n"
        << "\"enabled\": " << to_string(in.enabled) << ",\n"
        << "\"homogeneousScaling\": " << to_string(in.homogeneousScaling) << ",\n"
        << "\"quality\": " << (in.quality) << "\n"
        << "}";
}

int parse(jsmntok_t const* tokens, int i, const char* jsonChunk, BloomOptions::BlendMode* out) {
    if (0 == compare(tokens[i], jsonChunk, "ADD")) { *out = BloomOptions::BlendMode::ADD; }
    else if (0 == compare(tokens[i], jsonChunk, "INTERPOLATE")) { *out = BloomOptions::BlendMode::INTERPOLATE; }
    else {
        slog.w << "Invalid BloomOptions::BlendMode: '" << STR(tokens[i], jsonChunk) << "'" << io::endl;
    }
    return i + 1;
}

std::ostream& operator<<(std::ostream& out, BloomOptions::BlendMode in) {
    switch (in) {
        case BloomOptions::BlendMode::ADD: return out << "\"ADD\"";
        case BloomOptions::BlendMode::INTERPOLATE: return out << "\"INTERPOLATE\"";
    }
    return out << "\"INVALID\"";
}

int parse(jsmntok_t const* tokens, int i, const char* jsonChunk, BloomOptions* out) {
    CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
    int size = tokens[i++].size;
    for (int j = 0; j < size; ++j) {
        const jsmntok_t tok = tokens[i];
        CHECK_KEY(tok);
        if (compare(tok, jsonChunk, "dirt") == 0) {
            // JSON serialization for dirt is not supported.
            int unused;
            i = parse(tokens, i + 1, jsonChunk, &unused);
        } else if (compare(tok, jsonChunk, "dirtStrength") == 0) {
            // JSON serialization for dirtStrength is not supported.
            int unused;
            i = parse(tokens, i + 1, jsonChunk, &unused);
        } else if (compare(tok, jsonChunk, "strength") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->strength);
        } else if (compare(tok, jsonChunk, "resolution") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->resolution);
        } else if (compare(tok, jsonChunk, "levels") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->levels);
        } else if (compare(tok, jsonChunk, "blendMode") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->blendMode);
        } else if (compare(tok, jsonChunk, "threshold") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->threshold);
        } else if (compare(tok, jsonChunk, "enabled") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->enabled);
        } else if (compare(tok, jsonChunk, "highlight") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->highlight);
        } else if (compare(tok, jsonChunk, "quality") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->quality);
        } else if (compare(tok, jsonChunk, "lensFlare") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->lensFlare);
        } else if (compare(tok, jsonChunk, "starburst") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->starburst);
        } else if (compare(tok, jsonChunk, "chromaticAberration") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->chromaticAberration);
        } else if (compare(tok, jsonChunk, "ghostCount") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->ghostCount);
        } else if (compare(tok, jsonChunk, "ghostSpacing") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->ghostSpacing);
        } else if (compare(tok, jsonChunk, "ghostThreshold") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->ghostThreshold);
        } else if (compare(tok, jsonChunk, "haloThickness") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->haloThickness);
        } else if (compare(tok, jsonChunk, "haloRadius") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->haloRadius);
        } else if (compare(tok, jsonChunk, "haloThreshold") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->haloThreshold);
        } else {
            slog.w << "Invalid BloomOptions key: '" << STR(tok, jsonChunk) << "'" << io::endl;
            i = parse(tokens, i + 1);
        }
        if (i < 0) {
            slog.e << "Invalid BloomOptions value: '" << STR(tok, jsonChunk) << "'" << io::endl;
            return i;
        }
    }
    return i;
}

std::ostream& operator<<(std::ostream& out, const BloomOptions& in) {
    return out << "{\n"
        // JSON serialization for dirt is not supported.
        // JSON serialization for dirtStrength is not supported.
        << "\"strength\": " << (in.strength) << ",\n"
        << "\"resolution\": " << (in.resolution) << ",\n"
        << "\"levels\": " << int(in.levels) << ",\n"
        << "\"blendMode\": " << (in.blendMode) << ",\n"
        << "\"threshold\": " << to_string(in.threshold) << ",\n"
        << "\"enabled\": " << to_string(in.enabled) << ",\n"
        << "\"highlight\": " << (in.highlight) << ",\n"
        << "\"quality\": " << (in.quality) << ",\n"
        << "\"lensFlare\": " << to_string(in.lensFlare) << ",\n"
        << "\"starburst\": " << to_string(in.starburst) << ",\n"
        << "\"chromaticAberration\": " << (in.chromaticAberration) << ",\n"
        << "\"ghostCount\": " << int(in.ghostCount) << ",\n"
        << "\"ghostSpacing\": " << (in.ghostSpacing) << ",\n"
        << "\"ghostThreshold\": " << (in.ghostThreshold) << ",\n"
        << "\"haloThickness\": " << (in.haloThickness) << ",\n"
        << "\"haloRadius\": " << (in.haloRadius) << ",\n"
        << "\"haloThreshold\": " << (in.haloThreshold) << "\n"
        << "}";
}

int parse(jsmntok_t const* tokens, int i, const char* jsonChunk, FogOptions* out) {
    CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
    int size = tokens[i++].size;
    for (int j = 0; j < size; ++j) {
        const jsmntok_t tok = tokens[i];
        CHECK_KEY(tok);
        if (compare(tok, jsonChunk, "distance") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->distance);
        } else if (compare(tok, jsonChunk, "cutOffDistance") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->cutOffDistance);
        } else if (compare(tok, jsonChunk, "maximumOpacity") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->maximumOpacity);
        } else if (compare(tok, jsonChunk, "height") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->height);
        } else if (compare(tok, jsonChunk, "heightFalloff") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->heightFalloff);
        } else if (compare(tok, jsonChunk, "color") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->color);
        } else if (compare(tok, jsonChunk, "density") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->density);
        } else if (compare(tok, jsonChunk, "inScatteringStart") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->inScatteringStart);
        } else if (compare(tok, jsonChunk, "inScatteringSize") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->inScatteringSize);
        } else if (compare(tok, jsonChunk, "fogColorFromIbl") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->fogColorFromIbl);
        } else if (compare(tok, jsonChunk, "skyColor") == 0) {
            // JSON serialization for skyColor is not supported.
            int unused;
            i = parse(tokens, i + 1, jsonChunk, &unused);
        } else if (compare(tok, jsonChunk, "enabled") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->enabled);
        } else {
            slog.w << "Invalid FogOptions key: '" << STR(tok, jsonChunk) << "'" << io::endl;
            i = parse(tokens, i + 1);
        }
        if (i < 0) {
            slog.e << "Invalid FogOptions value: '" << STR(tok, jsonChunk) << "'" << io::endl;
            return i;
        }
    }
    return i;
}

std::ostream& operator<<(std::ostream& out, const FogOptions& in) {
    return out << "{\n"
        << "\"distance\": " << (in.distance) << ",\n"
        << "\"cutOffDistance\": " << (in.cutOffDistance) << ",\n"
        << "\"maximumOpacity\": " << (in.maximumOpacity) << ",\n"
        << "\"height\": " << (in.height) << ",\n"
        << "\"heightFalloff\": " << (in.heightFalloff) << ",\n"
        << "\"color\": " << (in.color) << ",\n"
        << "\"density\": " << (in.density) << ",\n"
        << "\"inScatteringStart\": " << (in.inScatteringStart) << ",\n"
        << "\"inScatteringSize\": " << (in.inScatteringSize) << ",\n"
        << "\"fogColorFromIbl\": " << to_string(in.fogColorFromIbl) << ",\n"
        // JSON serialization for skyColor is not supported.
        << "\"enabled\": " << to_string(in.enabled) << "\n"
        << "}";
}

int parse(jsmntok_t const* tokens, int i, const char* jsonChunk, DepthOfFieldOptions::Filter* out) {
    if (0 == compare(tokens[i], jsonChunk, "NONE")) { *out = DepthOfFieldOptions::Filter::NONE; }
    else if (0 == compare(tokens[i], jsonChunk, "UNUSED")) { *out = DepthOfFieldOptions::Filter::UNUSED; }
    else if (0 == compare(tokens[i], jsonChunk, "MEDIAN")) { *out = DepthOfFieldOptions::Filter::MEDIAN; }
    else {
        slog.w << "Invalid DepthOfFieldOptions::Filter: '" << STR(tokens[i], jsonChunk) << "'" << io::endl;
    }
    return i + 1;
}

std::ostream& operator<<(std::ostream& out, DepthOfFieldOptions::Filter in) {
    switch (in) {
        case DepthOfFieldOptions::Filter::NONE: return out << "\"NONE\"";
        case DepthOfFieldOptions::Filter::UNUSED: return out << "\"UNUSED\"";
        case DepthOfFieldOptions::Filter::MEDIAN: return out << "\"MEDIAN\"";
    }
    return out << "\"INVALID\"";
}

int parse(jsmntok_t const* tokens, int i, const char* jsonChunk, DepthOfFieldOptions* out) {
    CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
    int size = tokens[i++].size;
    for (int j = 0; j < size; ++j) {
        const jsmntok_t tok = tokens[i];
        CHECK_KEY(tok);
        if (compare(tok, jsonChunk, "cocScale") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->cocScale);
        } else if (compare(tok, jsonChunk, "cocAspectRatio") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->cocAspectRatio);
        } else if (compare(tok, jsonChunk, "maxApertureDiameter") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->maxApertureDiameter);
        } else if (compare(tok, jsonChunk, "enabled") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->enabled);
        } else if (compare(tok, jsonChunk, "filter") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->filter);
        } else if (compare(tok, jsonChunk, "nativeResolution") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->nativeResolution);
        } else if (compare(tok, jsonChunk, "foregroundRingCount") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->foregroundRingCount);
        } else if (compare(tok, jsonChunk, "backgroundRingCount") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->backgroundRingCount);
        } else if (compare(tok, jsonChunk, "fastGatherRingCount") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->fastGatherRingCount);
        } else if (compare(tok, jsonChunk, "maxForegroundCOC") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->maxForegroundCOC);
        } else if (compare(tok, jsonChunk, "maxBackgroundCOC") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->maxBackgroundCOC);
        } else {
            slog.w << "Invalid DepthOfFieldOptions key: '" << STR(tok, jsonChunk) << "'" << io::endl;
            i = parse(tokens, i + 1);
        }
        if (i < 0) {
            slog.e << "Invalid DepthOfFieldOptions value: '" << STR(tok, jsonChunk) << "'" << io::endl;
            return i;
        }
    }
    return i;
}

std::ostream& operator<<(std::ostream& out, const DepthOfFieldOptions& in) {
    return out << "{\n"
        << "\"cocScale\": " << (in.cocScale) << ",\n"
        << "\"cocAspectRatio\": " << (in.cocAspectRatio) << ",\n"
        << "\"maxApertureDiameter\": " << (in.maxApertureDiameter) << ",\n"
        << "\"enabled\": " << to_string(in.enabled) << ",\n"
        << "\"filter\": " << (in.filter) << ",\n"
        << "\"nativeResolution\": " << to_string(in.nativeResolution) << ",\n"
        << "\"foregroundRingCount\": " << int(in.foregroundRingCount) << ",\n"
        << "\"backgroundRingCount\": " << int(in.backgroundRingCount) << ",\n"
        << "\"fastGatherRingCount\": " << int(in.fastGatherRingCount) << ",\n"
        << "\"maxForegroundCOC\": " << (in.maxForegroundCOC) << ",\n"
        << "\"maxBackgroundCOC\": " << (in.maxBackgroundCOC) << "\n"
        << "}";
}

int parse(jsmntok_t const* tokens, int i, const char* jsonChunk, VignetteOptions* out) {
    CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
    int size = tokens[i++].size;
    for (int j = 0; j < size; ++j) {
        const jsmntok_t tok = tokens[i];
        CHECK_KEY(tok);
        if (compare(tok, jsonChunk, "midPoint") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->midPoint);
        } else if (compare(tok, jsonChunk, "roundness") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->roundness);
        } else if (compare(tok, jsonChunk, "feather") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->feather);
        } else if (compare(tok, jsonChunk, "color") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->color);
        } else if (compare(tok, jsonChunk, "enabled") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->enabled);
        } else {
            slog.w << "Invalid VignetteOptions key: '" << STR(tok, jsonChunk) << "'" << io::endl;
            i = parse(tokens, i + 1);
        }
        if (i < 0) {
            slog.e << "Invalid VignetteOptions value: '" << STR(tok, jsonChunk) << "'" << io::endl;
            return i;
        }
    }
    return i;
}

std::ostream& operator<<(std::ostream& out, const VignetteOptions& in) {
    return out << "{\n"
        << "\"midPoint\": " << (in.midPoint) << ",\n"
        << "\"roundness\": " << (in.roundness) << ",\n"
        << "\"feather\": " << (in.feather) << ",\n"
        << "\"color\": " << (in.color) << ",\n"
        << "\"enabled\": " << to_string(in.enabled) << "\n"
        << "}";
}

int parse(jsmntok_t const* tokens, int i, const char* jsonChunk, RenderQuality* out) {
    CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
    int size = tokens[i++].size;
    for (int j = 0; j < size; ++j) {
        const jsmntok_t tok = tokens[i];
        CHECK_KEY(tok);
        if (compare(tok, jsonChunk, "hdrColorBuffer") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->hdrColorBuffer);
        } else {
            slog.w << "Invalid RenderQuality key: '" << STR(tok, jsonChunk) << "'" << io::endl;
            i = parse(tokens, i + 1);
        }
        if (i < 0) {
            slog.e << "Invalid RenderQuality value: '" << STR(tok, jsonChunk) << "'" << io::endl;
            return i;
        }
    }
    return i;
}

std::ostream& operator<<(std::ostream& out, const RenderQuality& in) {
    return out << "{\n"
        << "\"hdrColorBuffer\": " << (in.hdrColorBuffer) << "\n"
        << "}";
}

int parse(jsmntok_t const* tokens, int i, const char* jsonChunk, AmbientOcclusionOptions::AmbientOcclusionType* out) {
    if (0 == compare(tokens[i], jsonChunk, "SAO")) { *out = AmbientOcclusionOptions::AmbientOcclusionType::SAO; }
    else if (0 == compare(tokens[i], jsonChunk, "GTAO")) { *out = AmbientOcclusionOptions::AmbientOcclusionType::GTAO; }
    else {
        slog.w << "Invalid AmbientOcclusionOptions::AmbientOcclusionType: '" << STR(tokens[i], jsonChunk) << "'" << io::endl;
    }
    return i + 1;
}

std::ostream& operator<<(std::ostream& out, AmbientOcclusionOptions::AmbientOcclusionType in) {
    switch (in) {
        case AmbientOcclusionOptions::AmbientOcclusionType::SAO: return out << "\"SAO\"";
        case AmbientOcclusionOptions::AmbientOcclusionType::GTAO: return out << "\"GTAO\"";
    }
    return out << "\"INVALID\"";
}

int parse(jsmntok_t const* tokens, int i, const char* jsonChunk, AmbientOcclusionOptions::Ssct* out) {
    CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
    int size = tokens[i++].size;
    for (int j = 0; j < size; ++j) {
        const jsmntok_t tok = tokens[i];
        CHECK_KEY(tok);
        if (compare(tok, jsonChunk, "lightConeRad") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->lightConeRad);
        } else if (compare(tok, jsonChunk, "shadowDistance") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->shadowDistance);
        } else if (compare(tok, jsonChunk, "contactDistanceMax") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->contactDistanceMax);
        } else if (compare(tok, jsonChunk, "intensity") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->intensity);
        } else if (compare(tok, jsonChunk, "lightDirection") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->lightDirection);
        } else if (compare(tok, jsonChunk, "depthBias") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->depthBias);
        } else if (compare(tok, jsonChunk, "depthSlopeBias") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->depthSlopeBias);
        } else if (compare(tok, jsonChunk, "sampleCount") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->sampleCount);
        } else if (compare(tok, jsonChunk, "rayCount") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->rayCount);
        } else if (compare(tok, jsonChunk, "enabled") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->enabled);
        } else {
            slog.w << "Invalid Ssct key: '" << STR(tok, jsonChunk) << "'" << io::endl;
            i = parse(tokens, i + 1);
        }
        if (i < 0) {
            slog.e << "Invalid Ssct value: '" << STR(tok, jsonChunk) << "'" << io::endl;
            return i;
        }
    }
    return i;
}

std::ostream& operator<<(std::ostream& out, const AmbientOcclusionOptions::Ssct& in) {
    return out << "{\n"
        << "\"lightConeRad\": " << (in.lightConeRad) << ",\n"
        << "\"shadowDistance\": " << (in.shadowDistance) << ",\n"
        << "\"contactDistanceMax\": " << (in.contactDistanceMax) << ",\n"
        << "\"intensity\": " << (in.intensity) << ",\n"
        << "\"lightDirection\": " << (in.lightDirection) << ",\n"
        << "\"depthBias\": " << (in.depthBias) << ",\n"
        << "\"depthSlopeBias\": " << (in.depthSlopeBias) << ",\n"
        << "\"sampleCount\": " << int(in.sampleCount) << ",\n"
        << "\"rayCount\": " << int(in.rayCount) << ",\n"
        << "\"enabled\": " << to_string(in.enabled) << "\n"
        << "}";
}

int parse(jsmntok_t const* tokens, int i, const char* jsonChunk, AmbientOcclusionOptions::Gtao* out) {
    CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
    int size = tokens[i++].size;
    for (int j = 0; j < size; ++j) {
        const jsmntok_t tok = tokens[i];
        CHECK_KEY(tok);
        if (compare(tok, jsonChunk, "sampleSliceCount") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->sampleSliceCount);
        } else if (compare(tok, jsonChunk, "sampleStepsPerSlice") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->sampleStepsPerSlice);
        } else if (compare(tok, jsonChunk, "thicknessHeuristic") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->thicknessHeuristic);
        } else if (compare(tok, jsonChunk, "useVisibilityBitmasks") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->useVisibilityBitmasks);
        } else if (compare(tok, jsonChunk, "constThickness") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->constThickness);
        } else if (compare(tok, jsonChunk, "linearThickness") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->linearThickness);
        } else {
            slog.w << "Invalid Gtao key: '" << STR(tok, jsonChunk) << "'" << io::endl;
            i = parse(tokens, i + 1);
        }
        if (i < 0) {
            slog.e << "Invalid Gtao value: '" << STR(tok, jsonChunk) << "'" << io::endl;
            return i;
        }
    }
    return i;
}

std::ostream& operator<<(std::ostream& out, const AmbientOcclusionOptions::Gtao& in) {
    return out << "{\n"
        << "\"sampleSliceCount\": " << int(in.sampleSliceCount) << ",\n"
        << "\"sampleStepsPerSlice\": " << int(in.sampleStepsPerSlice) << ",\n"
        << "\"thicknessHeuristic\": " << (in.thicknessHeuristic) << ",\n"
        << "\"useVisibilityBitmasks\": " << to_string(in.useVisibilityBitmasks) << ",\n"
        << "\"constThickness\": " << (in.constThickness) << ",\n"
        << "\"linearThickness\": " << to_string(in.linearThickness) << "\n"
        << "}";
}

int parse(jsmntok_t const* tokens, int i, const char* jsonChunk, AmbientOcclusionOptions* out) {
    CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
    int size = tokens[i++].size;
    for (int j = 0; j < size; ++j) {
        const jsmntok_t tok = tokens[i];
        CHECK_KEY(tok);
        if (compare(tok, jsonChunk, "aoType") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->aoType);
        } else if (compare(tok, jsonChunk, "radius") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->radius);
        } else if (compare(tok, jsonChunk, "power") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->power);
        } else if (compare(tok, jsonChunk, "bias") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->bias);
        } else if (compare(tok, jsonChunk, "resolution") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->resolution);
        } else if (compare(tok, jsonChunk, "intensity") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->intensity);
        } else if (compare(tok, jsonChunk, "bilateralThreshold") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->bilateralThreshold);
        } else if (compare(tok, jsonChunk, "quality") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->quality);
        } else if (compare(tok, jsonChunk, "lowPassFilter") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->lowPassFilter);
        } else if (compare(tok, jsonChunk, "upsampling") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->upsampling);
        } else if (compare(tok, jsonChunk, "enabled") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->enabled);
        } else if (compare(tok, jsonChunk, "bentNormals") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->bentNormals);
        } else if (compare(tok, jsonChunk, "minHorizonAngleRad") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->minHorizonAngleRad);
        } else if (compare(tok, jsonChunk, "ssct") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->ssct);
        } else if (compare(tok, jsonChunk, "gtao") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->gtao);
        } else {
            slog.w << "Invalid AmbientOcclusionOptions key: '" << STR(tok, jsonChunk) << "'" << io::endl;
            i = parse(tokens, i + 1);
        }
        if (i < 0) {
            slog.e << "Invalid AmbientOcclusionOptions value: '" << STR(tok, jsonChunk) << "'" << io::endl;
            return i;
        }
    }
    return i;
}

std::ostream& operator<<(std::ostream& out, const AmbientOcclusionOptions& in) {
    return out << "{\n"
        << "\"aoType\": " << (in.aoType) << ",\n"
        << "\"radius\": " << (in.radius) << ",\n"
        << "\"power\": " << (in.power) << ",\n"
        << "\"bias\": " << (in.bias) << ",\n"
        << "\"resolution\": " << (in.resolution) << ",\n"
        << "\"intensity\": " << (in.intensity) << ",\n"
        << "\"bilateralThreshold\": " << (in.bilateralThreshold) << ",\n"
        << "\"quality\": " << (in.quality) << ",\n"
        << "\"lowPassFilter\": " << (in.lowPassFilter) << ",\n"
        << "\"upsampling\": " << (in.upsampling) << ",\n"
        << "\"enabled\": " << to_string(in.enabled) << ",\n"
        << "\"bentNormals\": " << to_string(in.bentNormals) << ",\n"
        << "\"minHorizonAngleRad\": " << (in.minHorizonAngleRad) << ",\n"
        << "\"ssct\": " << (in.ssct) << ",\n"
        << "\"gtao\": " << (in.gtao) << "\n"
        << "}";
}

int parse(jsmntok_t const* tokens, int i, const char* jsonChunk, MultiSampleAntiAliasingOptions* out) {
    CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
    int size = tokens[i++].size;
    for (int j = 0; j < size; ++j) {
        const jsmntok_t tok = tokens[i];
        CHECK_KEY(tok);
        if (compare(tok, jsonChunk, "enabled") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->enabled);
        } else if (compare(tok, jsonChunk, "sampleCount") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->sampleCount);
        } else if (compare(tok, jsonChunk, "customResolve") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->customResolve);
        } else {
            slog.w << "Invalid MultiSampleAntiAliasingOptions key: '" << STR(tok, jsonChunk) << "'" << io::endl;
            i = parse(tokens, i + 1);
        }
        if (i < 0) {
            slog.e << "Invalid MultiSampleAntiAliasingOptions value: '" << STR(tok, jsonChunk) << "'" << io::endl;
            return i;
        }
    }
    return i;
}

std::ostream& operator<<(std::ostream& out, const MultiSampleAntiAliasingOptions& in) {
    return out << "{\n"
        << "\"enabled\": " << to_string(in.enabled) << ",\n"
        << "\"sampleCount\": " << int(in.sampleCount) << ",\n"
        << "\"customResolve\": " << to_string(in.customResolve) << "\n"
        << "}";
}

int parse(jsmntok_t const* tokens, int i, const char* jsonChunk, TemporalAntiAliasingOptions::BoxType* out) {
    if (0 == compare(tokens[i], jsonChunk, "AABB")) { *out = TemporalAntiAliasingOptions::BoxType::AABB; }
    else if (0 == compare(tokens[i], jsonChunk, "VARIANCE")) { *out = TemporalAntiAliasingOptions::BoxType::VARIANCE; }
    else if (0 == compare(tokens[i], jsonChunk, "AABB_VARIANCE")) { *out = TemporalAntiAliasingOptions::BoxType::AABB_VARIANCE; }
    else {
        slog.w << "Invalid TemporalAntiAliasingOptions::BoxType: '" << STR(tokens[i], jsonChunk) << "'" << io::endl;
    }
    return i + 1;
}

std::ostream& operator<<(std::ostream& out, TemporalAntiAliasingOptions::BoxType in) {
    switch (in) {
        case TemporalAntiAliasingOptions::BoxType::AABB: return out << "\"AABB\"";
        case TemporalAntiAliasingOptions::BoxType::VARIANCE: return out << "\"VARIANCE\"";
        case TemporalAntiAliasingOptions::BoxType::AABB_VARIANCE: return out << "\"AABB_VARIANCE\"";
    }
    return out << "\"INVALID\"";
}

int parse(jsmntok_t const* tokens, int i, const char* jsonChunk, TemporalAntiAliasingOptions::BoxClipping* out) {
    if (0 == compare(tokens[i], jsonChunk, "ACCURATE")) { *out = TemporalAntiAliasingOptions::BoxClipping::ACCURATE; }
    else if (0 == compare(tokens[i], jsonChunk, "CLAMP")) { *out = TemporalAntiAliasingOptions::BoxClipping::CLAMP; }
    else if (0 == compare(tokens[i], jsonChunk, "NONE")) { *out = TemporalAntiAliasingOptions::BoxClipping::NONE; }
    else {
        slog.w << "Invalid TemporalAntiAliasingOptions::BoxClipping: '" << STR(tokens[i], jsonChunk) << "'" << io::endl;
    }
    return i + 1;
}

std::ostream& operator<<(std::ostream& out, TemporalAntiAliasingOptions::BoxClipping in) {
    switch (in) {
        case TemporalAntiAliasingOptions::BoxClipping::ACCURATE: return out << "\"ACCURATE\"";
        case TemporalAntiAliasingOptions::BoxClipping::CLAMP: return out << "\"CLAMP\"";
        case TemporalAntiAliasingOptions::BoxClipping::NONE: return out << "\"NONE\"";
    }
    return out << "\"INVALID\"";
}

int parse(jsmntok_t const* tokens, int i, const char* jsonChunk, TemporalAntiAliasingOptions::JitterPattern* out) {
    if (0 == compare(tokens[i], jsonChunk, "RGSS_X4")) { *out = TemporalAntiAliasingOptions::JitterPattern::RGSS_X4; }
    else if (0 == compare(tokens[i], jsonChunk, "UNIFORM_HELIX_X4")) { *out = TemporalAntiAliasingOptions::JitterPattern::UNIFORM_HELIX_X4; }
    else if (0 == compare(tokens[i], jsonChunk, "HALTON_23_X8")) { *out = TemporalAntiAliasingOptions::JitterPattern::HALTON_23_X8; }
    else if (0 == compare(tokens[i], jsonChunk, "HALTON_23_X16")) { *out = TemporalAntiAliasingOptions::JitterPattern::HALTON_23_X16; }
    else if (0 == compare(tokens[i], jsonChunk, "HALTON_23_X32")) { *out = TemporalAntiAliasingOptions::JitterPattern::HALTON_23_X32; }
    else {
        slog.w << "Invalid TemporalAntiAliasingOptions::JitterPattern: '" << STR(tokens[i], jsonChunk) << "'" << io::endl;
    }
    return i + 1;
}

std::ostream& operator<<(std::ostream& out, TemporalAntiAliasingOptions::JitterPattern in) {
    switch (in) {
        case TemporalAntiAliasingOptions::JitterPattern::RGSS_X4: return out << "\"RGSS_X4\"";
        case TemporalAntiAliasingOptions::JitterPattern::UNIFORM_HELIX_X4: return out << "\"UNIFORM_HELIX_X4\"";
        case TemporalAntiAliasingOptions::JitterPattern::HALTON_23_X8: return out << "\"HALTON_23_X8\"";
        case TemporalAntiAliasingOptions::JitterPattern::HALTON_23_X16: return out << "\"HALTON_23_X16\"";
        case TemporalAntiAliasingOptions::JitterPattern::HALTON_23_X32: return out << "\"HALTON_23_X32\"";
    }
    return out << "\"INVALID\"";
}

int parse(jsmntok_t const* tokens, int i, const char* jsonChunk, TemporalAntiAliasingOptions* out) {
    CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
    int size = tokens[i++].size;
    for (int j = 0; j < size; ++j) {
        const jsmntok_t tok = tokens[i];
        CHECK_KEY(tok);
        if (compare(tok, jsonChunk, "filterWidth") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->filterWidth);
        } else if (compare(tok, jsonChunk, "feedback") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->feedback);
        } else if (compare(tok, jsonChunk, "lodBias") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->lodBias);
        } else if (compare(tok, jsonChunk, "sharpness") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->sharpness);
        } else if (compare(tok, jsonChunk, "enabled") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->enabled);
        } else if (compare(tok, jsonChunk, "upscaling") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->upscaling);
        } else if (compare(tok, jsonChunk, "filterHistory") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->filterHistory);
        } else if (compare(tok, jsonChunk, "filterInput") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->filterInput);
        } else if (compare(tok, jsonChunk, "useYCoCg") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->useYCoCg);
        } else if (compare(tok, jsonChunk, "boxType") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->boxType);
        } else if (compare(tok, jsonChunk, "boxClipping") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->boxClipping);
        } else if (compare(tok, jsonChunk, "jitterPattern") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->jitterPattern);
        } else if (compare(tok, jsonChunk, "varianceGamma") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->varianceGamma);
        } else if (compare(tok, jsonChunk, "preventFlickering") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->preventFlickering);
        } else if (compare(tok, jsonChunk, "historyReprojection") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->historyReprojection);
        } else {
            slog.w << "Invalid TemporalAntiAliasingOptions key: '" << STR(tok, jsonChunk) << "'" << io::endl;
            i = parse(tokens, i + 1);
        }
        if (i < 0) {
            slog.e << "Invalid TemporalAntiAliasingOptions value: '" << STR(tok, jsonChunk) << "'" << io::endl;
            return i;
        }
    }
    return i;
}

std::ostream& operator<<(std::ostream& out, const TemporalAntiAliasingOptions& in) {
    return out << "{\n"
        << "\"filterWidth\": " << (in.filterWidth) << ",\n"
        << "\"feedback\": " << (in.feedback) << ",\n"
        << "\"lodBias\": " << (in.lodBias) << ",\n"
        << "\"sharpness\": " << (in.sharpness) << ",\n"
        << "\"enabled\": " << to_string(in.enabled) << ",\n"
        << "\"upscaling\": " << to_string(in.upscaling) << ",\n"
        << "\"filterHistory\": " << to_string(in.filterHistory) << ",\n"
        << "\"filterInput\": " << to_string(in.filterInput) << ",\n"
        << "\"useYCoCg\": " << to_string(in.useYCoCg) << ",\n"
        << "\"boxType\": " << (in.boxType) << ",\n"
        << "\"boxClipping\": " << (in.boxClipping) << ",\n"
        << "\"jitterPattern\": " << (in.jitterPattern) << ",\n"
        << "\"varianceGamma\": " << (in.varianceGamma) << ",\n"
        << "\"preventFlickering\": " << to_string(in.preventFlickering) << ",\n"
        << "\"historyReprojection\": " << to_string(in.historyReprojection) << "\n"
        << "}";
}

int parse(jsmntok_t const* tokens, int i, const char* jsonChunk, ScreenSpaceReflectionsOptions* out) {
    CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
    int size = tokens[i++].size;
    for (int j = 0; j < size; ++j) {
        const jsmntok_t tok = tokens[i];
        CHECK_KEY(tok);
        if (compare(tok, jsonChunk, "thickness") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->thickness);
        } else if (compare(tok, jsonChunk, "bias") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->bias);
        } else if (compare(tok, jsonChunk, "maxDistance") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->maxDistance);
        } else if (compare(tok, jsonChunk, "stride") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->stride);
        } else if (compare(tok, jsonChunk, "enabled") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->enabled);
        } else {
            slog.w << "Invalid ScreenSpaceReflectionsOptions key: '" << STR(tok, jsonChunk) << "'" << io::endl;
            i = parse(tokens, i + 1);
        }
        if (i < 0) {
            slog.e << "Invalid ScreenSpaceReflectionsOptions value: '" << STR(tok, jsonChunk) << "'" << io::endl;
            return i;
        }
    }
    return i;
}

std::ostream& operator<<(std::ostream& out, const ScreenSpaceReflectionsOptions& in) {
    return out << "{\n"
        << "\"thickness\": " << (in.thickness) << ",\n"
        << "\"bias\": " << (in.bias) << ",\n"
        << "\"maxDistance\": " << (in.maxDistance) << ",\n"
        << "\"stride\": " << (in.stride) << ",\n"
        << "\"enabled\": " << to_string(in.enabled) << "\n"
        << "}";
}

int parse(jsmntok_t const* tokens, int i, const char* jsonChunk, GuardBandOptions* out) {
    CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
    int size = tokens[i++].size;
    for (int j = 0; j < size; ++j) {
        const jsmntok_t tok = tokens[i];
        CHECK_KEY(tok);
        if (compare(tok, jsonChunk, "enabled") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->enabled);
        } else {
            slog.w << "Invalid GuardBandOptions key: '" << STR(tok, jsonChunk) << "'" << io::endl;
            i = parse(tokens, i + 1);
        }
        if (i < 0) {
            slog.e << "Invalid GuardBandOptions value: '" << STR(tok, jsonChunk) << "'" << io::endl;
            return i;
        }
    }
    return i;
}

std::ostream& operator<<(std::ostream& out, const GuardBandOptions& in) {
    return out << "{\n"
        << "\"enabled\": " << to_string(in.enabled) << "\n"
        << "}";
}

int parse(jsmntok_t const* tokens, int i, const char* jsonChunk, AntiAliasing* out) {
    if (0 == compare(tokens[i], jsonChunk, "NONE")) { *out = AntiAliasing::NONE; }
    else if (0 == compare(tokens[i], jsonChunk, "FXAA")) { *out = AntiAliasing::FXAA; }
    else {
        slog.w << "Invalid AntiAliasing: '" << STR(tokens[i], jsonChunk) << "'" << io::endl;
    }
    return i + 1;
}

std::ostream& operator<<(std::ostream& out, AntiAliasing in) {
    switch (in) {
        case AntiAliasing::NONE: return out << "\"NONE\"";
        case AntiAliasing::FXAA: return out << "\"FXAA\"";
    }
    return out << "\"INVALID\"";
}

int parse(jsmntok_t const* tokens, int i, const char* jsonChunk, Dithering* out) {
    if (0 == compare(tokens[i], jsonChunk, "NONE")) { *out = Dithering::NONE; }
    else if (0 == compare(tokens[i], jsonChunk, "TEMPORAL")) { *out = Dithering::TEMPORAL; }
    else {
        slog.w << "Invalid Dithering: '" << STR(tokens[i], jsonChunk) << "'" << io::endl;
    }
    return i + 1;
}

std::ostream& operator<<(std::ostream& out, Dithering in) {
    switch (in) {
        case Dithering::NONE: return out << "\"NONE\"";
        case Dithering::TEMPORAL: return out << "\"TEMPORAL\"";
    }
    return out << "\"INVALID\"";
}

int parse(jsmntok_t const* tokens, int i, const char* jsonChunk, ShadowType* out) {
    if (0 == compare(tokens[i], jsonChunk, "PCF")) { *out = ShadowType::PCF; }
    else if (0 == compare(tokens[i], jsonChunk, "VSM")) { *out = ShadowType::VSM; }
    else if (0 == compare(tokens[i], jsonChunk, "DPCF")) { *out = ShadowType::DPCF; }
    else if (0 == compare(tokens[i], jsonChunk, "PCSS")) { *out = ShadowType::PCSS; }
    else if (0 == compare(tokens[i], jsonChunk, "PCFd")) { *out = ShadowType::PCFd; }
    else {
        slog.w << "Invalid ShadowType: '" << STR(tokens[i], jsonChunk) << "'" << io::endl;
    }
    return i + 1;
}

std::ostream& operator<<(std::ostream& out, ShadowType in) {
    switch (in) {
        case ShadowType::PCF: return out << "\"PCF\"";
        case ShadowType::VSM: return out << "\"VSM\"";
        case ShadowType::DPCF: return out << "\"DPCF\"";
        case ShadowType::PCSS: return out << "\"PCSS\"";
        case ShadowType::PCFd: return out << "\"PCFd\"";
    }
    return out << "\"INVALID\"";
}

int parse(jsmntok_t const* tokens, int i, const char* jsonChunk, VsmShadowOptions* out) {
    CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
    int size = tokens[i++].size;
    for (int j = 0; j < size; ++j) {
        const jsmntok_t tok = tokens[i];
        CHECK_KEY(tok);
        if (compare(tok, jsonChunk, "anisotropy") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->anisotropy);
        } else if (compare(tok, jsonChunk, "mipmapping") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->mipmapping);
        } else if (compare(tok, jsonChunk, "msaaSamples") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->msaaSamples);
        } else if (compare(tok, jsonChunk, "highPrecision") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->highPrecision);
        } else if (compare(tok, jsonChunk, "minVarianceScale") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->minVarianceScale);
        } else if (compare(tok, jsonChunk, "lightBleedReduction") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->lightBleedReduction);
        } else {
            slog.w << "Invalid VsmShadowOptions key: '" << STR(tok, jsonChunk) << "'" << io::endl;
            i = parse(tokens, i + 1);
        }
        if (i < 0) {
            slog.e << "Invalid VsmShadowOptions value: '" << STR(tok, jsonChunk) << "'" << io::endl;
            return i;
        }
    }
    return i;
}

std::ostream& operator<<(std::ostream& out, const VsmShadowOptions& in) {
    return out << "{\n"
        << "\"anisotropy\": " << int(in.anisotropy) << ",\n"
        << "\"mipmapping\": " << to_string(in.mipmapping) << ",\n"
        << "\"msaaSamples\": " << int(in.msaaSamples) << ",\n"
        << "\"highPrecision\": " << to_string(in.highPrecision) << ",\n"
        << "\"minVarianceScale\": " << (in.minVarianceScale) << ",\n"
        << "\"lightBleedReduction\": " << (in.lightBleedReduction) << "\n"
        << "}";
}

int parse(jsmntok_t const* tokens, int i, const char* jsonChunk, SoftShadowOptions* out) {
    CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
    int size = tokens[i++].size;
    for (int j = 0; j < size; ++j) {
        const jsmntok_t tok = tokens[i];
        CHECK_KEY(tok);
        if (compare(tok, jsonChunk, "penumbraScale") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->penumbraScale);
        } else if (compare(tok, jsonChunk, "penumbraRatioScale") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->penumbraRatioScale);
        } else {
            slog.w << "Invalid SoftShadowOptions key: '" << STR(tok, jsonChunk) << "'" << io::endl;
            i = parse(tokens, i + 1);
        }
        if (i < 0) {
            slog.e << "Invalid SoftShadowOptions value: '" << STR(tok, jsonChunk) << "'" << io::endl;
            return i;
        }
    }
    return i;
}

std::ostream& operator<<(std::ostream& out, const SoftShadowOptions& in) {
    return out << "{\n"
        << "\"penumbraScale\": " << (in.penumbraScale) << ",\n"
        << "\"penumbraRatioScale\": " << (in.penumbraRatioScale) << "\n"
        << "}";
}

int parse(jsmntok_t const* tokens, int i, const char* jsonChunk, StereoscopicOptions* out) {
    CHECK_TOKTYPE(tokens[i], JSMN_OBJECT);
    int size = tokens[i++].size;
    for (int j = 0; j < size; ++j) {
        const jsmntok_t tok = tokens[i];
        CHECK_KEY(tok);
        if (compare(tok, jsonChunk, "enabled") == 0) {
            i = parse(tokens, i + 1, jsonChunk, &out->enabled);
        } else {
            slog.w << "Invalid StereoscopicOptions key: '" << STR(tok, jsonChunk) << "'" << io::endl;
            i = parse(tokens, i + 1);
        }
        if (i < 0) {
            slog.e << "Invalid StereoscopicOptions value: '" << STR(tok, jsonChunk) << "'" << io::endl;
            return i;
        }
    }
    return i;
}

std::ostream& operator<<(std::ostream& out, const StereoscopicOptions& in) {
    return out << "{\n"
        << "\"enabled\": " << to_string(in.enabled) << "\n"
        << "}";
}

} // namespace filament::viewer