C_object.hpp

/*
 * Copyright 2024 Guillaume Guillet
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef _FGE_C_OBJECT_HPP_INCLUDED
#define _FGE_C_OBJECT_HPP_INCLUDED
 
#include "FastEngine/fge_extern.hpp"
#include "C_childObjectsAccessor.hpp"
#include "FastEngine/C_event.hpp"
#include "FastEngine/C_propertyList.hpp"
#include "FastEngine/C_quad.hpp"
#include "FastEngine/C_rect.hpp"
#include "FastEngine/C_tagList.hpp"
#include "FastEngine/graphic/C_drawable.hpp"
#include "FastEngine/graphic/C_transformable.hpp"
#include "FastEngine/network/C_networkType.hpp"
#include "FastEngine/object/C_objectAnchor.hpp"
#include "FastEngine/vulkan/C_context.hpp"
#include "json.hpp"
 
#include <chrono>
#include <string>
 
#define FGE_OBJ_BADCLASSNAME "NULL"
#define FGE_OBJ_NOSCENE nullptr
#define FGE_OBJ_DEFAULT_COPYMETHOD(objClass)                                                                           \
    fge::Object* copy() override                                                                                       \
    {                                                                                                                  \
        return new objClass(*this);                                                                                    \
    }
 
#ifdef FGE_DEF_SERVER
    #define FGE_OBJ_UPDATE_DECLARE                                                                                     \
        void update(fge::Event& event, const std::chrono::microseconds& deltaTime, fge::Scene& scene) override;
#else
    #define FGE_OBJ_UPDATE_DECLARE                                                                                     \
        void update(fge::RenderWindow& screen, fge::Event& event, const std::chrono::microseconds& deltaTime,          \
                    fge::Scene& scene) override;
#endif //FGE_DEF_SERVER
 
#ifdef FGE_DEF_SERVER
    #define FGE_OBJ_UPDATE_BODY(class_)                                                                                \
        void class_::update([[maybe_unused]] fge::Event& event,                                                        \
                            [[maybe_unused]] const std::chrono::microseconds& deltaTime,                               \
                            [[maybe_unused]] fge::Scene& scene)
 
    #define FGE_OBJ_UPDATE_CALL(object_) object_.update(event, deltaTime, scene)
    #define FGE_OBJ_UPDATE_PTRCALL(object_) object_->update(event, deltaTime, scene)
#else
    #define FGE_OBJ_UPDATE_BODY(class_)                                                                                \
        void class_::update([[maybe_unused]] fge::RenderWindow& screen, [[maybe_unused]] fge::Event& event,            \
                            [[maybe_unused]] const std::chrono::microseconds& deltaTime,                               \
                            [[maybe_unused]] fge::Scene& scene)
 
    #define FGE_OBJ_UPDATE_CALL(object_) object_.update(screen, event, deltaTime, scene)
    #define FGE_OBJ_UPDATE_PTRCALL(object_) object_->update(screen, event, deltaTime, scene)
#endif //FGE_DEF_SERVER
 
#ifdef FGE_DEF_SERVER
    #define FGE_OBJ_DRAW_DECLARE
#else
    #define FGE_OBJ_DRAW_DECLARE void draw(fge::RenderTarget& target, const fge::RenderStates& states) const override;
#endif //FGE_DEF_SERVER
 
#define FGE_OBJ_DRAW_BODY(class_) void class_::draw(fge::RenderTarget& target, const fge::RenderStates& states) const
 
namespace fge
{
 
class GuiElementHandler;
class GuiElement;
 
class Scene;
 
class ObjectData;
using ObjectDataWeak = std::weak_ptr<fge::ObjectData>;
using ObjectDataShared = std::shared_ptr<fge::ObjectData>;
 
#ifdef FGE_DEF_SERVER
class FGE_API Object : public fge::Transformable, public fge::Anchor
#else
class FGE_API Object : public fge::Drawable, public fge::Transformable, public fge::Anchor
#endif //FGE_DEF_SERVER
{
public:
    Object();
    Object(Object const& r);
    Object(Object&& r) noexcept;
    ~Object() override = default;
 
    virtual fge::Object* copy();
 
    virtual void first(fge::Scene& scene);
    virtual void transfered(fge::Scene& oldScene, fge::Scene& newScene);
    virtual void callbackRegister(fge::Event& event, fge::GuiElementHandler* guiElementHandlerPtr);
#ifdef FGE_DEF_SERVER
    virtual void update(fge::Event& event, std::chrono::microseconds const& deltaTime, fge::Scene& scene);
    void update(fge::Event& event, std::chrono::microseconds const& deltaTime);
#else
    virtual void
    update(fge::RenderWindow& screen, fge::Event& event, std::chrono::microseconds const& deltaTime, fge::Scene& scene);
    void update(fge::RenderWindow& screen, fge::Event& event, std::chrono::microseconds const& deltaTime);
#endif //FGE_DEF_SERVER
#ifndef FGE_DEF_SERVER
    virtual void draw(fge::RenderTarget& target, fge::RenderStates const& states) const override;
#endif //FGE_DEF_SERVER
    virtual void networkRegister();
    virtual void netSignaled(int8_t signal);
    virtual void removed(fge::Scene& scene);
 
    virtual void save(nlohmann::json& jsonObject, fge::Scene* scene);
    virtual void load(nlohmann::json& jsonObject, fge::Scene* scene);
    virtual void pack(fge::net::Packet& pck);
    virtual void unpack(fge::net::Packet const& pck);
    //TODO: Apply network rules on every extraction method on every objects.
 
    virtual char const* getClassName() const;
    virtual char const* getReadableClassName() const;
 
    [[nodiscard]] virtual fge::RectFloat getGlobalBounds() const;
    [[nodiscard]] virtual fge::Quad getGlobalQuad() const;
    [[nodiscard]] virtual fge::RectFloat getLocalBounds() const;
    [[nodiscard]] virtual fge::Quad getLocalQuad() const;
 
    bool saveInFile(std::string const& path);
    bool loadFromFile(std::string const& path);
    static fge::Object* LoadFromFile(std::string const& path);
 
    virtual fge::GuiElement* getGuiElement();
 
    glm::mat4 getParentsTransform() const;
    fge::Vector2f getParentsScale() const;
 
    //Data
 
    fge::TagList _tags;            
    fge::PropertyList _properties; 
 
    //Network
 
    fge::net::NetworkTypeHandler _netList; 
 
    //Scene control
 
    fge::ObjectDataWeak _myObjectData; 
 
    enum class DrawModes : uint8_t
    {
        DRAW_IF_ON_TARGET,
        DRAW_ALWAYS_HIDDEN,
        DRAW_ALWAYS_DRAWN,
 
        DRAW_DEFAULT = DRAW_IF_ON_TARGET
    };
    fge::Object::DrawModes _drawMode{
            fge::Object::DrawModes::DRAW_DEFAULT}; 
 
    enum class CallbackContextModes : uint8_t
    {
        CONTEXT_MANUAL,
        CONTEXT_AUTO,
 
        CONTEXT_DEFAULT = CONTEXT_AUTO
    };
    fge::Object::CallbackContextModes _callbackContextMode{
            fge::Object::CallbackContextModes::
                    CONTEXT_DEFAULT}; 
 
    //Child objects
 
    enum ChildrenControlFlags : uint8_t
    {
        CHILDREN_AUTO_CLEAR_ON_REMOVE = 1 << 0,
        CHILDREN_AUTO_UPDATE = 1 << 1,
        CHILDREN_AUTO_DRAW = 1 << 2,
 
        CHILDREN_DEFAULT = CHILDREN_AUTO_CLEAR_ON_REMOVE
    };
    using ChildrenControlFlags_t = std::underlying_type_t<ChildrenControlFlags>;
 
    ChildrenControlFlags_t _childrenControlFlags{CHILDREN_DEFAULT}; 
    fge::ChildObjectsAccessor _children;                            
};
 
} // namespace fge
 
#endif // _FGE_C_OBJECT_HPP_INCLUDED