scene_components.hpp

Go to the documentation of this file.

 
#ifndef TOYMAKERENGINE_SCENECOMPONENTS_H
#define TOYMAKERENGINE_SCENECOMPONENTS_H
 
#include <glm/glm.hpp>
#include <glm/gtc/quaternion.hpp>
#include <nlohmann/json.hpp>
 
#include "core/ecs_world.hpp"
 
namespace ToyMaker {
    using TransformComponentSet = uint8_t;

    enum TransformComponentOption: TransformComponentSet {
        TRANSFORMCOMPONENT_TRANSLATION=0x1,
        TRANSFORMCOMPONENT_ROTATION=0x2,
        TRANSFORMCOMPONENT_SCALE=0x4,
    };

    enum class TransformInheritMode: uint8_t {
        PARENT,
        GLOBAL,
        CAMERA,
    };

    struct Placement {
        glm::vec4 mPosition {glm::vec3{ 0.f }, 1.f};

        glm::quat mOrientation { glm::vec3{ 0.f } };

        glm::vec3 mScale { 1.f, 1.f, 1.f };

        TransformComponentSet mInheritedComponents { TRANSFORMCOMPONENT_TRANSLATION | TRANSFORMCOMPONENT_ROTATION | TRANSFORMCOMPONENT_SCALE };

        TransformInheritMode mInheritMode { TransformInheritMode::PARENT };

        inline static std::string getComponentTypeName() { return "Placement"; }

        inline bool operator==(const Placement& other) {
            return (
                mPosition == other.mPosition 
                && mOrientation == other.mOrientation
                && mScale == other.mScale
            );
        }

        inline bool operator!=(const Placement& other) { 
            return !(*this == other);
        }
    };

    struct Transform {
        glm::mat4 mModelMatrix { 1.f };

        TransformComponentSet mInheritedComponents { TRANSFORMCOMPONENT_TRANSLATION | TRANSFORMCOMPONENT_ROTATION | TRANSFORMCOMPONENT_SCALE };

        TransformInheritMode mInheritMode { TransformInheritMode::PARENT };

        inline static std::string getComponentTypeName() { return "Transform"; }

        inline glm::mat4 getMatrixTranslation() const {
            return getTranslationMatrix(mModelMatrix);
        }

        inline glm::mat4 getMatrixRotation() const {
            return getRotationMatrix(mModelMatrix);
        }

        inline glm::mat4 getMatrixScale() const {
            return getScaleMatrix(mModelMatrix);
        }
    };
 

    struct SceneHierarchyData {
        EntityID mParent { kMaxEntities };

        EntityID mSibling { kMaxEntities };

        EntityID mChild { kMaxEntities };

        inline static std::string getComponentTypeName() { return "SceneHierarchyData"; }
    };

    NLOHMANN_JSON_SERIALIZE_ENUM(TransformComponentOption, {
        { TransformComponentOption::TRANSFORMCOMPONENT_TRANSLATION, "translation" },
        { TransformComponentOption::TRANSFORMCOMPONENT_ROTATION, "rotation" },
        { TransformComponentOption::TRANSFORMCOMPONENT_SCALE, "scale" },
    });

    NLOHMANN_JSON_SERIALIZE_ENUM(TransformInheritMode, {
        { TransformInheritMode::PARENT, "parent" },
        { TransformInheritMode::GLOBAL, "global" },
        { TransformInheritMode::CAMERA, "camera" },
    });

    inline void from_json(const nlohmann::json& json, Placement& placement) {
        assert(json.at("type").get<std::string>() == Placement::getComponentTypeName() && "Type mismatch. Component json must have type Placement");
 
        // Initialize the placement component properly if not done already
        placement = Placement {};
 
        if(json.contains("inherit_mode")) {
            placement.mInheritMode = json.at("inherit_mode");
        }
 
        if(json.contains("inherit_components") && json.at("inherit_components").is_array()) {
            placement.mInheritedComponents = 0x0;
            for(const auto& component: json.at("inherit_components")) {
                placement.mInheritedComponents |= component.get<TransformComponentOption>();
            }
        }
 
        json.at("position")[0].get_to(placement.mPosition.x);
        json.at("position")[1].get_to(placement.mPosition.y);
        json.at("position")[2].get_to(placement.mPosition.z);
        json.at("position")[3].get_to(placement.mPosition.w);
 
        json.at("orientation")[0].get_to(placement.mOrientation.w);
        json.at("orientation")[1].get_to(placement.mOrientation.x);
        json.at("orientation")[2].get_to(placement.mOrientation.y);
        json.at("orientation")[3].get_to(placement.mOrientation.z);
        placement.mOrientation = glm::normalize(placement.mOrientation);
 
        json.at("scale")[0].get_to(placement.mScale.x);
        json.at("scale")[1].get_to(placement.mScale.y);
        json.at("scale")[2].get_to(placement.mScale.z);
    }

    inline void to_json(nlohmann::json& json, const Placement& placement) {
        std::vector<nlohmann::json> inheritComponentList {};
        if(placement.mInheritedComponents & TRANSFORMCOMPONENT_TRANSLATION) {
            const nlohmann::json translationComponent = TRANSFORMCOMPONENT_TRANSLATION;
            inheritComponentList.push_back(translationComponent);
        }
        if(placement.mInheritedComponents & TRANSFORMCOMPONENT_ROTATION) {
            const nlohmann::json rotationComponent = TRANSFORMCOMPONENT_ROTATION;
            inheritComponentList.push_back(rotationComponent);
        }
        if(placement.mInheritedComponents & TRANSFORMCOMPONENT_SCALE) {
            const nlohmann::json scaleComponent = TRANSFORMCOMPONENT_SCALE;
            inheritComponentList.push_back(scaleComponent);
        }
        json = {
            {"type", Placement::getComponentTypeName()},
            {"inherit_mode", placement.mInheritMode},
            {"inherit_components", inheritComponentList},
            {"position", {
                placement.mPosition.x,
                placement.mPosition.y,
                placement.mPosition.z,
                placement.mPosition.w,
            }},
            {"orientation", {
                placement.mOrientation.w,
                placement.mOrientation.x,
                placement.mOrientation.y,
                placement.mOrientation.z,
            }},
            {"scale", {
                placement.mScale.x,
                placement.mScale.y,
                placement.mScale.z,
            }}
        };
    }

    inline void to_json(nlohmann::json& json, const SceneHierarchyData& sceneHierarchyData) {
        (void)json; (void)sceneHierarchyData; // prevent unused parameter warnings
    }

    inline void from_json(const nlohmann::json& json, SceneHierarchyData& sceneHierarchyData) {
        (void)json; (void)sceneHierarchyData; // prevent unused parameter warnings
    }

    inline void to_json(nlohmann::json& json, const Transform& transform) {
        (void)transform; // prevent unused parameter warnings
        json = {
            {"type", Transform::getComponentTypeName()},
        };
    }

    inline void from_json(const nlohmann::json& json, Transform& transform) {
        assert(json.at("type") == Transform::getComponentTypeName() && "Type mismatch. Component json must have type Transform");
        transform.mModelMatrix = glm::mat4{1.f};
    }

    template<>
    inline Placement Interpolator<Placement>::operator() (
        const Placement& previousState, const Placement& nextState,
        float simulationProgress
    ) const {
        simulationProgress = mProgressLimits(simulationProgress);
        return {
            .mPosition{ (1.f - simulationProgress) * previousState.mPosition + simulationProgress * nextState.mPosition },
            .mOrientation{ glm::slerp(previousState.mOrientation, nextState.mOrientation, simulationProgress) },
            .mScale{ (1.f - simulationProgress) * previousState.mScale + simulationProgress * nextState.mScale }
        };
    }

    template<>
    inline Transform Interpolator<Transform>::operator() (
        const Transform& previousState, const Transform& nextState,
        float simulationProgress
    ) const {
        simulationProgress = mProgressLimits(simulationProgress);
        return {
            previousState.mModelMatrix * (1.f - simulationProgress)
            + nextState.mModelMatrix * (simulationProgress)
        };
    }

    template <>
    inline SceneHierarchyData Interpolator<SceneHierarchyData>::operator() (
        const SceneHierarchyData& previousState, const SceneHierarchyData& nextState,
        float simulationProgress
    ) const {
        (void)previousState; // prevent unused parameter warnings
        (void)simulationProgress; // prevent unused parameter warnings
        return nextState;
    }
}
 
#endif