sprite_renderer.h

#pragma once
 
#include "pixelbullet/filesystem/virtual_path.h"
#include "pixelbullet/filesystem/virtual_path_serialization.h"
#include "pixelbullet/serialization/node.h"
 
#include <glm/glm.hpp>
 
namespace pixelbullet
{
struct SpriteRenderer
{
    VirtualPath texture;
    glm::vec4 tint = glm::vec4(1.0f);
    glm::vec2 uv_scale = glm::vec2(1.0f);
    glm::vec2 uv_offset = glm::vec2(0.0f);
    bool visible = true;
};
 
inline Node& operator<<(Node& node, const SpriteRenderer& sprite)
{
    node["texture"] << sprite.texture;
 
    Node tintNode;
    tintNode.SetType(NodeType::Array);
    auto& tintProperties = tintNode.GetProperties();
    tintProperties.clear();
    for (int index = 0; index < 4; ++index)
    {
        Node componentNode;
        componentNode << sprite.tint[index];
        tintProperties.emplace_back("", std::move(componentNode));
    }
    node["tint"] = std::move(tintNode);
 
    Node uvScaleNode;
    uvScaleNode.SetType(NodeType::Array);
    auto& uvScaleProperties = uvScaleNode.GetProperties();
    uvScaleProperties.clear();
    for (int index = 0; index < 2; ++index)
    {
        Node componentNode;
        componentNode << sprite.uv_scale[index];
        uvScaleProperties.emplace_back("", std::move(componentNode));
    }
    node["uvScale"] = std::move(uvScaleNode);
 
    Node uvOffsetNode;
    uvOffsetNode.SetType(NodeType::Array);
    auto& uvOffsetProperties = uvOffsetNode.GetProperties();
    uvOffsetProperties.clear();
    for (int index = 0; index < 2; ++index)
    {
        Node componentNode;
        componentNode << sprite.uv_offset[index];
        uvOffsetProperties.emplace_back("", std::move(componentNode));
    }
    node["uvOffset"] = std::move(uvOffsetNode);
 
    node["visible"] << sprite.visible;
    return node;
}
 
inline const Node& operator>>(const Node& node, SpriteRenderer& sprite)
{
    node["texture"] >> sprite.texture;
 
    const Node& tintNode = node["tint"];
    ASSERT(tintNode.GetType() == NodeType::Array, "SpriteRenderer tint must be an array");
    const auto& tintProperties = tintNode.GetProperties();
    ASSERT(tintProperties.size() >= 4, "SpriteRenderer tint requires four components");
    for (int index = 0; index < 4; ++index)
    {
        tintProperties[index].second >> sprite.tint[index];
    }
 
    const Node& uvScaleNode = node["uvScale"];
    ASSERT(uvScaleNode.GetType() == NodeType::Array, "SpriteRenderer uvScale must be an array");
    const auto& uvScaleProperties = uvScaleNode.GetProperties();
    ASSERT(uvScaleProperties.size() >= 2, "SpriteRenderer uvScale requires two components");
    for (int index = 0; index < 2; ++index)
    {
        uvScaleProperties[index].second >> sprite.uv_scale[index];
    }
 
    const Node& uvOffsetNode = node["uvOffset"];
    ASSERT(uvOffsetNode.GetType() == NodeType::Array, "SpriteRenderer uvOffset must be an array");
    const auto& uvOffsetProperties = uvOffsetNode.GetProperties();
    ASSERT(uvOffsetProperties.size() >= 2, "SpriteRenderer uvOffset requires two components");
    for (int index = 0; index < 2; ++index)
    {
        uvOffsetProperties[index].second >> sprite.uv_offset[index];
    }
 
    node["visible"] >> sprite.visible;
    return node;
}
} // namespace pixelbullet