component_node_readers.h

#pragma once
 
#include "pixelbullet/scene/components/animation_state_component.h"
#include "pixelbullet/scene/components/audio_listener_component.h"
#include "pixelbullet/scene/components/audio_source_component.h"
#include "pixelbullet/scene/components/camera_component.h"
#include "pixelbullet/scene/components/collider_component.h"
#include "pixelbullet/scene/components/directional_light_component.h"
#include "pixelbullet/scene/components/material_uv_transform_component.h"
#include "pixelbullet/scene/components/mesh_renderer.h"
#include "pixelbullet/scene/components/morph_mesh_renderer.h"
#include "pixelbullet/scene/components/morph_weights_animation_component.h"
#include "pixelbullet/scene/components/morph_weights_component.h"
#include "pixelbullet/scene/components/name.h"
#include "pixelbullet/scene/components/point_light_component.h"
#include "pixelbullet/scene/components/prefab_instance_component.h"
#include "pixelbullet/scene/components/prefab_transform_overrides_component.h"
#include "pixelbullet/scene/components/rigid_body_component.h"
#include "pixelbullet/scene/components/skeleton_animation_component.h"
#include "pixelbullet/scene/components/skinned_mesh_renderer.h"
#include "pixelbullet/scene/components/skinned_morph_mesh_renderer.h"
#include "pixelbullet/scene/components/spot_light_component.h"
#include "pixelbullet/scene/components/sprite_renderer.h"
#include "pixelbullet/scene/components/transform.h"
#include "pixelbullet/scene/components/transform_animation_component.h"
#include "pixelbullet/scene/components/transform_parent_component.h"
#include "pixelbullet/serialization/node_reader.h"
 
#include <algorithm>
#include <utility>
 
namespace pixelbullet
{
[[nodiscard]] inline bool TryReadNode(const Node& node, AnimationStateComponent& component, serialization::NodeReader& reader)
{
    component = AnimationStateComponent{};
    bool ok = true;
    ok &= serialization::TryReadOptionalProperty(node, "enabled", component.enabled, reader);
    ok &= serialization::TryReadOptionalProperty(node, "activeClip", component.active_clip, reader);
    return ok;
}
 
[[nodiscard]] inline bool TryReadNode(const Node& node, AudioListenerComponent& component, serialization::NodeReader& reader)
{
    component = AudioListenerComponent{};
    return serialization::TryReadOptionalProperty(node, "enabled", component.enabled, reader);
}
 
[[nodiscard]] inline bool TryReadNode(const Node& node, AudioSourceComponent& component, serialization::NodeReader& reader)
{
    component = AudioSourceComponent{};
    bool ok = true;
    ok &= serialization::TryReadOptionalProperty(node, "enabled", component.enabled, reader);
    ok &= serialization::TryReadOptionalProperty(node, "clip", component.clip, reader);
    ok &= serialization::TryReadOptionalProperty(node, "autoplay", component.autoplay, reader);
    ok &= serialization::TryReadOptionalProperty(node, "loop", component.loop, reader);
    ok &= serialization::TryReadOptionalProperty(node, "volume", component.volume, reader);
    ok &= serialization::TryReadOptionalProperty(node, "spatial", component.spatial_settings.enabled, reader);
    ok &= serialization::TryReadOptionalProperty(node, "minDistance", component.spatial_settings.min_distance, reader);
    ok &= serialization::TryReadOptionalProperty(node, "maxDistance", component.spatial_settings.max_distance, reader);
    ok &= serialization::TryReadOptionalProperty(node, "loadMode", component.load_mode, reader);
    return ok;
}
 
[[nodiscard]] inline bool TryReadNode(const Node& node, CameraProjectionMode& value, serialization::NodeReader& reader)
{
    std::string serialized;
    if (!serialization::TryReadNode(node, serialized, reader))
    {
        return false;
    }
    value = serialized == "Orthographic" ? CameraProjectionMode::Orthographic : CameraProjectionMode::Perspective;
    return true;
}
 
[[nodiscard]] inline bool TryReadNode(const Node& node, CameraComponent& camera, serialization::NodeReader& reader)
{
    camera = CameraComponent{};
    bool ok = true;
    ok &= serialization::TryReadRequiredProperty(node, "primary", camera.primary, reader);
    ok &= serialization::TryReadRequiredProperty(node, "fieldOfViewDegrees", camera.field_of_view_degrees, reader);
    ok &= serialization::TryReadRequiredProperty(node, "nearPlane", camera.near_plane, reader);
    ok &= serialization::TryReadRequiredProperty(node, "farPlane", camera.far_plane, reader);
    ok &= serialization::TryReadOptionalProperty(node, "projectionMode", camera.projection_mode, reader);
    ok &= serialization::TryReadOptionalProperty(node, "orthographicXMag", camera.orthographic_x_mag, reader);
    ok &= serialization::TryReadOptionalProperty(node, "orthographicYMag", camera.orthographic_y_mag, reader);
    return ok;
}
 
[[nodiscard]] inline bool TryReadNode(const Node& node, ColliderComponent& component, serialization::NodeReader& reader)
{
    component = ColliderComponent{};
    bool ok = true;
    ok &= serialization::TryReadOptionalProperty(node, "enabled", component.enabled, reader);
    ok &= serialization::TryReadOptionalProperty(node, "shape", component.shape, reader);
    ok &= serialization::TryReadOptionalProperty(node, "boxHalfExtents", component.box_half_extents, reader);
    ok &= serialization::TryReadOptionalProperty(node, "sphereRadius", component.sphere_radius, reader);
    ok &= serialization::TryReadOptionalProperty(node, "capsuleRadius", component.capsule_radius, reader);
    ok &= serialization::TryReadOptionalProperty(node, "capsuleHalfHeight", component.capsule_half_height, reader);
    ok &= serialization::TryReadOptionalProperty(node, "center", component.center, reader);
    ok &= serialization::TryReadOptionalProperty(node, "friction", component.friction, reader);
    ok &= serialization::TryReadOptionalProperty(node, "restitution", component.restitution, reader);
    ok &= serialization::TryReadOptionalProperty(node, "isTrigger", component.is_trigger, reader);
    return ok;
}
 
[[nodiscard]] inline bool TryReadNode(const Node& node, DirectionalLightComponent& light, serialization::NodeReader& reader)
{
    light = DirectionalLightComponent{};
    bool ok = true;
    ok &= serialization::TryReadRequiredProperty(node, "enabled", light.enabled, reader);
    ok &= serialization::TryReadRequiredProperty(node, "color", light.color, reader);
    ok &= serialization::TryReadRequiredProperty(node, "intensity", light.intensity, reader);
    ok &= serialization::TryReadOptionalProperty(node, "shadowEnabled", light.shadow_enabled, reader);
    ok &= serialization::TryReadOptionalProperty(node, "shadowStrength", light.shadow_strength, reader);
    ok &= serialization::TryReadOptionalProperty(node, "shadowBias", light.shadow_bias, reader);
    ok &= serialization::TryReadOptionalProperty(node, "shadowNormalBias", light.shadow_normal_bias, reader);
    ok &= serialization::TryReadOptionalProperty(node, "shadowDistance", light.shadow_distance, reader);
    return ok;
}
 
[[nodiscard]] inline bool TryReadNode(const Node& node, MaterialUvTransformComponent& component, serialization::NodeReader& reader)
{
    component = MaterialUvTransformComponent{};
    return serialization::TryReadOptionalProperty(node, "transform", component.transform, reader);
}
 
[[nodiscard]] inline bool TryReadNode(const Node& node, MeshRenderer& mesh_renderer, serialization::NodeReader& reader)
{
    mesh_renderer = MeshRenderer{};
    bool ok = true;
    ok &= serialization::TryReadRequiredProperty(node, "mesh", mesh_renderer.mesh, reader);
    ok &= serialization::TryReadRequiredProperty(node, "material", mesh_renderer.material, reader);
    ok &= serialization::TryReadRequiredProperty(node, "visible", mesh_renderer.visible, reader);
    return ok;
}
 
[[nodiscard]] inline bool TryReadNode(const Node& node, MorphMeshRenderer& renderer, serialization::NodeReader& reader)
{
    renderer = MorphMeshRenderer{};
    bool ok = true;
    ok &= serialization::TryReadRequiredProperty(node, "mesh", renderer.mesh, reader);
    ok &= serialization::TryReadRequiredProperty(node, "material", renderer.material, reader);
    ok &= serialization::TryReadOptionalProperty(node, "weightsSource", renderer.weights_source, reader);
    ok &= serialization::TryReadRequiredProperty(node, "visible", renderer.visible, reader);
    return ok;
}
 
[[nodiscard]] inline bool TryReadNode(const Node& node, MorphWeightsKeyframe& keyframe, serialization::NodeReader& reader)
{
    keyframe = MorphWeightsKeyframe{};
    bool ok = true;
    ok &= serialization::TryReadRequiredProperty(node, "timeSeconds", keyframe.time_seconds, reader);
    ok &= serialization::TryReadOptionalProperty(node, "weights", keyframe.weights, reader);
    keyframe.time_seconds = std::max(keyframe.time_seconds, 0.0f);
    return ok;
}
 
[[nodiscard]] inline bool TryReadNode(const Node& node, MorphWeightsAnimationClip& clip, serialization::NodeReader& reader)
{
    clip = MorphWeightsAnimationClip{};
    bool ok = true;
    ok &= serialization::TryReadOptionalProperty(node, "name", clip.name, reader);
    ok &= serialization::TryReadOptionalProperty(node, "keys", clip.keys, reader);
    NormalizeMorphWeightsAnimationClip(clip);
    return ok;
}
 
[[nodiscard]] inline bool TryReadNode(const Node& node, MorphWeightsAnimationComponent& component, serialization::NodeReader& reader)
{
    component = MorphWeightsAnimationComponent{};
    bool ok = true;
    if (node.has_property("clips"))
    {
        ok &= serialization::TryReadOptionalProperty(node, "clips", component.clips, reader);
    }
    else
    {
        MorphWeightsAnimationClip clip;
        clip.name = "Default";
        ok &= serialization::TryReadOptionalProperty(node, "keys", clip.keys, reader);
        bool legacy_enabled = true;
        ok &= serialization::TryReadOptionalProperty(node, "enabled", legacy_enabled, reader);
        NormalizeMorphWeightsAnimationClip(clip);
        if (!clip.keys.empty() || node.has_property("enabled"))
        {
            component.clips.push_back(std::move(clip));
        }
    }
    NormalizeMorphWeightsAnimationComponent(component);
    return ok;
}
 
[[nodiscard]] inline bool TryReadNode(const Node& node, MorphWeightsComponent& component, serialization::NodeReader& reader)
{
    component = MorphWeightsComponent{};
    return serialization::TryReadOptionalProperty(node, "weights", component.weights, reader);
}
 
[[nodiscard]] inline bool TryReadNode(const Node& node, Name& name, serialization::NodeReader& reader)
{
    name = Name{};
    return serialization::TryReadRequiredProperty(node, "value", name.value, reader);
}
 
[[nodiscard]] inline bool TryReadNode(const Node& node, PointLightComponent& light, serialization::NodeReader& reader)
{
    light = PointLightComponent{};
    bool ok = true;
    ok &= serialization::TryReadRequiredProperty(node, "enabled", light.enabled, reader);
    ok &= serialization::TryReadRequiredProperty(node, "color", light.color, reader);
    ok &= serialization::TryReadRequiredProperty(node, "intensity", light.intensity, reader);
    ok &= serialization::TryReadRequiredProperty(node, "range", light.range, reader);
    return ok;
}
 
[[nodiscard]] inline bool TryReadNode(const Node& node, PrefabInstanceComponent& component, serialization::NodeReader& reader)
{
    component = PrefabInstanceComponent{};
    return serialization::TryReadRequiredProperty(node, "prefabPath", component.prefab_path, reader);
}
 
[[nodiscard]] inline bool TryReadNode(const Node& node, PrefabTransformOverrideEntry& entry, serialization::NodeReader& reader)
{
    entry = PrefabTransformOverrideEntry{};
    bool ok = true;
    ok &= serialization::TryReadOptionalProperty(node, "entity", entry.prefab_entity, reader);
    ok &= serialization::TryReadOptionalProperty(node, "transform", entry.transform, reader);
    return ok;
}
 
[[nodiscard]] inline bool TryReadNode(const Node& node, PrefabTransformOverridesComponent& component, serialization::NodeReader& reader)
{
    component = PrefabTransformOverridesComponent{};
    const bool ok = serialization::TryReadOptionalProperty(node, "transformOverrides", component.transform_overrides, reader);
    NormalizePrefabTransformOverrideEntries(component.transform_overrides);
    return ok;
}
 
[[nodiscard]] inline bool TryReadNode(const Node& node, RigidBodyComponent& component, serialization::NodeReader& reader)
{
    component = RigidBodyComponent{};
    bool ok = true;
    ok &= serialization::TryReadOptionalProperty(node, "enabled", component.enabled, reader);
    ok &= serialization::TryReadOptionalProperty(node, "motionType", component.motion_type, reader);
    ok &= serialization::TryReadOptionalProperty(node, "mass", component.mass, reader);
    ok &= serialization::TryReadOptionalProperty(node, "linearDamping", component.linear_damping, reader);
    ok &= serialization::TryReadOptionalProperty(node, "angularDamping", component.angular_damping, reader);
    ok &= serialization::TryReadOptionalProperty(node, "gravityScale", component.gravity_scale, reader);
    return ok;
}
 
[[nodiscard]] inline bool TryReadNode(const Node& node, SkeletonAnimationClipBinding& clip, serialization::NodeReader& reader)
{
    clip = SkeletonAnimationClipBinding{};
    bool ok = true;
    ok &= serialization::TryReadOptionalProperty(node, "name", clip.name, reader);
    ok &= serialization::TryReadRequiredProperty(node, "clipAsset", clip.clip_asset, reader);
    return ok;
}
 
[[nodiscard]] inline bool TryReadNode(const Node& node, SkeletonAnimationComponent& component, serialization::NodeReader& reader)
{
    component = SkeletonAnimationComponent{};
    bool ok = true;
    ok &= serialization::TryReadRequiredProperty(node, "skeletonAsset", component.skeleton_asset, reader);
    ok &= serialization::TryReadOptionalProperty(node, "jointEntities", component.joint_entities, reader);
    ok &= serialization::TryReadOptionalProperty(node, "clips", component.clips, reader);
    bool legacy_enabled = true;
    ok &= serialization::TryReadOptionalProperty(node, "enabled", legacy_enabled, reader);
    NormalizeSkeletonAnimationComponent(component);
    return ok;
}
 
[[nodiscard]] inline bool TryReadNode(const Node& node, SkinnedMeshRenderer& renderer, serialization::NodeReader& reader)
{
    renderer = SkinnedMeshRenderer{};
    bool ok = true;
    ok &= serialization::TryReadRequiredProperty(node, "mesh", renderer.mesh, reader);
    ok &= serialization::TryReadRequiredProperty(node, "material", renderer.material, reader);
    ok &= serialization::TryReadOptionalProperty(node, "joints", renderer.joints, reader);
    ok &= serialization::TryReadRequiredProperty(node, "visible", renderer.visible, reader);
    return ok;
}
 
[[nodiscard]] inline bool TryReadNode(const Node& node, SkinnedMorphMeshRenderer& renderer, serialization::NodeReader& reader)
{
    renderer = SkinnedMorphMeshRenderer{};
    bool ok = true;
    ok &= serialization::TryReadRequiredProperty(node, "mesh", renderer.mesh, reader);
    ok &= serialization::TryReadRequiredProperty(node, "material", renderer.material, reader);
    ok &= serialization::TryReadOptionalProperty(node, "joints", renderer.joints, reader);
    ok &= serialization::TryReadOptionalProperty(node, "weightsSource", renderer.weights_source, reader);
    ok &= serialization::TryReadRequiredProperty(node, "visible", renderer.visible, reader);
    return ok;
}
 
[[nodiscard]] inline bool TryReadNode(const Node& node, SpotLightComponent& light, serialization::NodeReader& reader)
{
    light = SpotLightComponent{};
    bool ok = true;
    ok &= serialization::TryReadRequiredProperty(node, "enabled", light.enabled, reader);
    ok &= serialization::TryReadRequiredProperty(node, "color", light.color, reader);
    ok &= serialization::TryReadRequiredProperty(node, "intensity", light.intensity, reader);
    ok &= serialization::TryReadRequiredProperty(node, "range", light.range, reader);
    ok &= serialization::TryReadOptionalProperty(node, "innerConeAngleDegrees", light.inner_cone_angle_degrees, reader);
    ok &= serialization::TryReadOptionalProperty(node, "outerConeAngleDegrees", light.outer_cone_angle_degrees, reader);
    return ok;
}
 
[[nodiscard]] inline bool TryReadNode(const Node& node, SpriteRenderer& sprite, serialization::NodeReader& reader)
{
    sprite = SpriteRenderer{};
    bool ok = true;
    ok &= serialization::TryReadRequiredProperty(node, "texture", sprite.texture, reader);
    ok &= serialization::TryReadRequiredProperty(node, "tint", sprite.tint, reader);
    ok &= serialization::TryReadRequiredProperty(node, "uvScale", sprite.uv_scale, reader);
    ok &= serialization::TryReadRequiredProperty(node, "uvOffset", sprite.uv_offset, reader);
    ok &= serialization::TryReadRequiredProperty(node, "visible", sprite.visible, reader);
    return ok;
}
 
[[nodiscard]] inline bool TryReadNode(const Node& node, Transform& transform, serialization::NodeReader& reader)
{
    transform = Transform{};
    bool ok = true;
    ok &= serialization::TryReadRequiredProperty(node, "position", transform.position, reader);
    ok &= serialization::TryReadRequiredProperty(node, "rotation", transform.rotation, reader);
    ok &= serialization::TryReadRequiredProperty(node, "scale", transform.scale, reader);
    return ok;
}
 
[[nodiscard]] inline bool TryReadNode(const Node& node, TransformKeyframe& keyframe, serialization::NodeReader& reader)
{
    keyframe = TransformKeyframe{};
    bool ok = true;
    ok &= serialization::TryReadRequiredProperty(node, "timeSeconds", keyframe.time_seconds, reader);
    ok &= serialization::TryReadRequiredProperty(node, "position", keyframe.transform.position, reader);
    ok &= serialization::TryReadRequiredProperty(node, "rotation", keyframe.transform.rotation, reader);
    ok &= serialization::TryReadRequiredProperty(node, "scale", keyframe.transform.scale, reader);
    keyframe.time_seconds = std::max(keyframe.time_seconds, 0.0f);
    return ok;
}
 
[[nodiscard]] inline bool TryReadNode(const Node& node, TransformAnimationClip& clip, serialization::NodeReader& reader)
{
    clip = TransformAnimationClip{};
    bool ok = true;
    ok &= serialization::TryReadOptionalProperty(node, "name", clip.name, reader);
    ok &= serialization::TryReadOptionalProperty(node, "keys", clip.keys, reader);
    NormalizeTransformAnimationClip(clip);
    return ok;
}
 
[[nodiscard]] inline bool TryReadNode(const Node& node, TransformAnimationComponent& component, serialization::NodeReader& reader)
{
    component = TransformAnimationComponent{};
    bool ok = true;
    if (node.has_property("clips"))
    {
        ok &= serialization::TryReadOptionalProperty(node, "clips", component.clips, reader);
    }
    else
    {
        TransformAnimationClip clip;
        clip.name = "Default";
        ok &= serialization::TryReadOptionalProperty(node, "keys", clip.keys, reader);
        bool legacy_enabled = true;
        ok &= serialization::TryReadOptionalProperty(node, "enabled", legacy_enabled, reader);
        NormalizeTransformAnimationClip(clip);
        if (!clip.keys.empty() || node.has_property("enabled"))
        {
            component.clips.push_back(std::move(clip));
        }
    }
    NormalizeTransformAnimationComponent(component);
    return ok;
}
 
[[nodiscard]] inline bool TryReadNode(const Node& node, TransformParentComponent& component, serialization::NodeReader& reader)
{
    component = TransformParentComponent{};
    return serialization::TryReadRequiredProperty(node, "parent", component.parent, reader);
}
} // namespace pixelbullet