spk_transform_2d.hpp

#pragma once
 
#include "structure/design_pattern/spk_cached_data.hpp"
#include "structure/design_pattern/spk_contract_provider.hpp"
#include "structure/engine/2d/spk_component_2d.hpp"
#include "structure/engine/2d/spk_force_2d.hpp"
#include "structure/math/spk_matrix.hpp"
#include "structure/math/spk_vector2.hpp"
#include "structure/math/spk_vector3.hpp"
 
namespace spk
{
    class RigidBody2D;

    class Transform2D : public Component2D
    {
    public:
        using EditionContract = spk::ContractProvider::Contract;
        using EditionJob = spk::ContractProvider::Job;
 
    private:
        spk::Vector2 _position = {0, 0};
        spk::Vector2 _scale = {1, 1};
        float _rotation = 0;
 
        float _layer = 0;
        spk::Force2D _velocity{};
        spk::RigidBody2D *_rigidBodyCache = nullptr;
 
        spk::CachedData<spk::Matrix4x4> _localModelMatrix;
        spk::CachedData<spk::Matrix4x4> _localInverseModelMatrix;
        spk::CachedData<spk::Matrix4x4> _modelMatrix;
        spk::CachedData<spk::Matrix4x4> _inverseModelMatrix;
 
        spk::ContractProvider _onEditionContractProvider;
 
    protected:
        void _onUpdateEvent(spk::UpdateEvent &p_event) override;
 
    private:
        bool _checkCollision(const spk::Matrix4x4 &p_futureModelMatrix);
        spk::Matrix4x4 _composeLocalMatrix(const spk::Vector2 &p_position, const spk::Vector2 &p_scale, float p_rotation) const;
        void _setPosition(const spk::Vector2 &p_position);
        void _setScale(const spk::Vector2 &p_scale);
        void _setRotation(const float &p_rotation);
 
    protected:
        const Transform2D *_parentTransform() const;
        void _releaseGlobalCache();
        void _notifyEdition();
 
    public:
        explicit Transform2D(const std::wstring &p_name);

        const spk::Matrix4x4 &localModelMatrix() const;
        const spk::Matrix4x4 &modelMatrix() const;
        const spk::Matrix4x4 &localInverseModelMatrix() const;
        const spk::Matrix4x4 &inverseModelMatrix() const;

        void setLayer(const float &p_layer);
        const float &layer() const;
        float globalLayer() const;

        void setPosition(const spk::Vector2 &p_position);
        const spk::Vector2 &position() const;
        spk::Vector2 globalPosition() const;

        void setScale(const spk::Vector2 &p_scale);
        const spk::Vector2 &scale() const;
        spk::Vector2 globalScale() const;

        void setRotation(const float &p_rotation);
        const float &rotation() const;
        float globalRotation() const;

        void applyForce(const spk::Force2D &p_force);
        const spk::Force2D &velocity() const;

        void notifyParentTransformEdited();

        EditionContract subscribeToEdition(const EditionJob &p_job);
    };
}