material_serialization.h

#pragma once
 
#include "pixelbullet/graphics/material_types.h"
#include "pixelbullet/serialization/node.h"
#include "pixelbullet/serialization/node_reader.h"
 
#include <string>
#include <utility>
 
namespace pixelbullet
{
inline Node& operator<<(Node& node, const MaterialAlphaMode& value)
{
    node << std::string(ToString(value));
    return node;
}
 
inline const Node& operator>>(const Node& node, MaterialAlphaMode& value)
{
    std::string serialized;
    node >> serialized;
    if (serialized == "Mask")
    {
        value = MaterialAlphaMode::Mask;
    }
    else if (serialized == "Blend")
    {
        value = MaterialAlphaMode::Blend;
    }
    else
    {
        value = MaterialAlphaMode::Opaque;
    }
    return node;
}
 
[[nodiscard]] inline bool TryReadNode(const Node& node, MaterialAlphaMode& value, serialization::NodeReader& reader)
{
    std::string serialized;
    if (!serialization::TryReadNode(node, serialized, reader))
    {
        return false;
    }
    if (serialized == "Opaque")
    {
        value = MaterialAlphaMode::Opaque;
    }
    else if (serialized == "Mask")
    {
        value = MaterialAlphaMode::Mask;
    }
    else if (serialized == "Blend")
    {
        value = MaterialAlphaMode::Blend;
    }
    else
    {
        return reader.Fail("Unknown MaterialAlphaMode token '" + serialized + "'.");
    }
    return true;
}
 
inline Node& operator<<(Node& node, const MaterialTextureWrapMode& value)
{
    node << std::string(ToString(value));
    return node;
}
 
inline const Node& operator>>(const Node& node, MaterialTextureWrapMode& value)
{
    std::string serialized;
    node >> serialized;
    if (serialized == "ClampToEdge")
    {
        value = MaterialTextureWrapMode::ClampToEdge;
    }
    else if (serialized == "MirroredRepeat")
    {
        value = MaterialTextureWrapMode::MirroredRepeat;
    }
    else
    {
        value = MaterialTextureWrapMode::Repeat;
    }
    return node;
}
 
[[nodiscard]] inline bool TryReadNode(const Node& node, MaterialTextureWrapMode& value, serialization::NodeReader& reader)
{
    std::string serialized;
    if (!serialization::TryReadNode(node, serialized, reader))
    {
        return false;
    }
    if (serialized == "Repeat")
    {
        value = MaterialTextureWrapMode::Repeat;
    }
    else if (serialized == "ClampToEdge")
    {
        value = MaterialTextureWrapMode::ClampToEdge;
    }
    else if (serialized == "MirroredRepeat")
    {
        value = MaterialTextureWrapMode::MirroredRepeat;
    }
    else
    {
        return reader.Fail("Unknown MaterialTextureWrapMode token '" + serialized + "'.");
    }
    return true;
}
 
inline Node& operator<<(Node& node, const MaterialTextureMagFilter& value)
{
    node << std::string(ToString(value));
    return node;
}
 
inline const Node& operator>>(const Node& node, MaterialTextureMagFilter& value)
{
    std::string serialized;
    node >> serialized;
    value = serialized == "Nearest" ? MaterialTextureMagFilter::Nearest : MaterialTextureMagFilter::Linear;
    return node;
}
 
[[nodiscard]] inline bool TryReadNode(const Node& node, MaterialTextureMagFilter& value, serialization::NodeReader& reader)
{
    std::string serialized;
    if (!serialization::TryReadNode(node, serialized, reader))
    {
        return false;
    }
    if (serialized == "Linear")
    {
        value = MaterialTextureMagFilter::Linear;
    }
    else if (serialized == "Nearest")
    {
        value = MaterialTextureMagFilter::Nearest;
    }
    else
    {
        return reader.Fail("Unknown MaterialTextureMagFilter token '" + serialized + "'.");
    }
    return true;
}
 
inline Node& operator<<(Node& node, const MaterialTextureMinFilter& value)
{
    node << std::string(ToString(value));
    return node;
}
 
inline Node& operator<<(Node& node, const MaterialTextureUvSet& value)
{
    node << std::string(ToString(value));
    return node;
}
 
inline const Node& operator>>(const Node& node, MaterialTextureMinFilter& value)
{
    std::string serialized;
    node >> serialized;
    if (serialized == "Linear")
    {
        value = MaterialTextureMinFilter::Linear;
    }
    else if (serialized == "Nearest")
    {
        value = MaterialTextureMinFilter::Nearest;
    }
    else if (serialized == "NearestMipmapNearest")
    {
        value = MaterialTextureMinFilter::NearestMipmapNearest;
    }
    else if (serialized == "LinearMipmapNearest")
    {
        value = MaterialTextureMinFilter::LinearMipmapNearest;
    }
    else if (serialized == "NearestMipmapLinear")
    {
        value = MaterialTextureMinFilter::NearestMipmapLinear;
    }
    else
    {
        value = MaterialTextureMinFilter::LinearMipmapLinear;
    }
    return node;
}
 
[[nodiscard]] inline bool TryReadNode(const Node& node, MaterialTextureMinFilter& value, serialization::NodeReader& reader)
{
    std::string serialized;
    if (!serialization::TryReadNode(node, serialized, reader))
    {
        return false;
    }
    if (serialized == "Linear")
    {
        value = MaterialTextureMinFilter::Linear;
    }
    else if (serialized == "Nearest")
    {
        value = MaterialTextureMinFilter::Nearest;
    }
    else if (serialized == "NearestMipmapNearest")
    {
        value = MaterialTextureMinFilter::NearestMipmapNearest;
    }
    else if (serialized == "LinearMipmapNearest")
    {
        value = MaterialTextureMinFilter::LinearMipmapNearest;
    }
    else if (serialized == "NearestMipmapLinear")
    {
        value = MaterialTextureMinFilter::NearestMipmapLinear;
    }
    else if (serialized == "LinearMipmapLinear")
    {
        value = MaterialTextureMinFilter::LinearMipmapLinear;
    }
    else
    {
        return reader.Fail("Unknown MaterialTextureMinFilter token '" + serialized + "'.");
    }
    return true;
}
 
inline const Node& operator>>(const Node& node, MaterialTextureUvSet& value)
{
    std::string serialized;
    node >> serialized;
    value = serialized == "Uv1" ? MaterialTextureUvSet::Uv1 : MaterialTextureUvSet::Uv0;
    return node;
}
 
[[nodiscard]] inline bool TryReadNode(const Node& node, MaterialTextureUvSet& value, serialization::NodeReader& reader)
{
    std::string serialized;
    if (!serialization::TryReadNode(node, serialized, reader))
    {
        return false;
    }
    if (serialized == "Uv0")
    {
        value = MaterialTextureUvSet::Uv0;
    }
    else if (serialized == "Uv1")
    {
        value = MaterialTextureUvSet::Uv1;
    }
    else
    {
        return reader.Fail("Unknown MaterialTextureUvSet token '" + serialized + "'.");
    }
    return true;
}
 
inline Node& operator<<(Node& node, const MaterialShadingModel& value)
{
    node << std::string(ToString(value));
    return node;
}
 
inline const Node& operator>>(const Node& node, MaterialShadingModel& value)
{
    std::string serialized;
    node >> serialized;
    value = serialized == "Unlit" ? MaterialShadingModel::Unlit : MaterialShadingModel::Lit;
    return node;
}
 
[[nodiscard]] inline bool TryReadNode(const Node& node, MaterialShadingModel& value, serialization::NodeReader& reader)
{
    std::string serialized;
    if (!serialization::TryReadNode(node, serialized, reader))
    {
        return false;
    }
    if (serialized == "Lit")
    {
        value = MaterialShadingModel::Lit;
    }
    else if (serialized == "Unlit")
    {
        value = MaterialShadingModel::Unlit;
    }
    else
    {
        return reader.Fail("Unknown MaterialShadingModel token '" + serialized + "'.");
    }
    return true;
}
 
inline Node& operator<<(Node& node, const MaterialTextureSamplerSettings& sampler)
{
    node["wrapU"] << sampler.wrap_u;
    node["wrapV"] << sampler.wrap_v;
    node["magFilter"] << sampler.mag_filter;
    node["minFilter"] << sampler.min_filter;
    return node;
}
 
inline const Node& operator>>(const Node& node, MaterialTextureSamplerSettings& sampler)
{
    if (node.has_property("wrapU"))
    {
        node["wrapU"] >> sampler.wrap_u;
    }
    if (node.has_property("wrapV"))
    {
        node["wrapV"] >> sampler.wrap_v;
    }
    if (node.has_property("magFilter"))
    {
        node["magFilter"] >> sampler.mag_filter;
    }
    if (node.has_property("minFilter"))
    {
        node["minFilter"] >> sampler.min_filter;
    }
    return node;
}
 
[[nodiscard]] inline bool TryReadNode(const Node& node, MaterialTextureSamplerSettings& sampler, serialization::NodeReader& reader)
{
    bool ok = true;
    ok &= serialization::TryReadOptionalProperty(node, "wrapU", sampler.wrap_u, reader);
    ok &= serialization::TryReadOptionalProperty(node, "wrapV", sampler.wrap_v, reader);
    ok &= serialization::TryReadOptionalProperty(node, "magFilter", sampler.mag_filter, reader);
    ok &= serialization::TryReadOptionalProperty(node, "minFilter", sampler.min_filter, reader);
    return ok;
}
 
inline Node& operator<<(Node& node, const MaterialTextureTransform& transform)
{
    Node offset_node;
    offset_node.set_type(NodeType::Array);
    auto& offset_properties = offset_node.properties();
    offset_properties.clear();
    for (int index = 0; index < 2; ++index)
    {
        Node component_node;
        component_node << transform.offset[index];
        offset_properties.emplace_back("", std::move(component_node));
    }
    node["offset"] = std::move(offset_node);
 
    Node scale_node;
    scale_node.set_type(NodeType::Array);
    auto& scale_properties = scale_node.properties();
    scale_properties.clear();
    for (int index = 0; index < 2; ++index)
    {
        Node component_node;
        component_node << transform.scale[index];
        scale_properties.emplace_back("", std::move(component_node));
    }
    node["scale"] = std::move(scale_node);
    node["rotationDegrees"] << transform.rotation_degrees;
    return node;
}
 
inline const Node& operator>>(const Node& node, MaterialTextureTransform& transform)
{
    if (node.has_property("offset"))
    {
        const Node& offset_node = node["offset"];
        ASSERT(offset_node.type() == NodeType::Array, "material texture transform offset must be an array");
        const auto& offset_properties = offset_node.properties();
        ASSERT(offset_properties.size() >= 2, "material texture transform offset requires two components");
        for (int index = 0; index < 2; ++index)
        {
            offset_properties[index].second >> transform.offset[index];
        }
    }
 
    if (node.has_property("scale"))
    {
        const Node& scale_node = node["scale"];
        ASSERT(scale_node.type() == NodeType::Array, "material texture transform scale must be an array");
        const auto& scale_properties = scale_node.properties();
        ASSERT(scale_properties.size() >= 2, "material texture transform scale requires two components");
        for (int index = 0; index < 2; ++index)
        {
            scale_properties[index].second >> transform.scale[index];
        }
    }
 
    if (node.has_property("rotationDegrees"))
    {
        node["rotationDegrees"] >> transform.rotation_degrees;
    }
 
    return node;
}
 
[[nodiscard]] inline bool TryReadNode(const Node& node, MaterialTextureTransform& transform, serialization::NodeReader& reader)
{
    bool ok = true;
    ok &= serialization::TryReadOptionalProperty(node, "offset", transform.offset, reader);
    ok &= serialization::TryReadOptionalProperty(node, "scale", transform.scale, reader);
    ok &= serialization::TryReadOptionalProperty(node, "rotationDegrees", transform.rotation_degrees, reader);
    return ok;
}
} // namespace pixelbullet