DesignerObject.h

Go to the documentation of this file.

#pragma once
 
#include "Designer/AbstractDesignerObject.h"
#include "Designer/designer_fwd.h"
 
#include <Common/primitive_type.h>
#include <Utility/TSpan.h>
#include <SDL/sdl_interface.h>
#include <Math/math_fwd.h>
#include <Math/Transform/TDecomposedTransform.h>
#include "Utility/TFunction.h"
 
#include <string>
#include <memory>
#include <cstddef>
#include <vector>
#include <type_traits>
 
namespace ph::editor::render { class System; }
 
namespace ph::editor
{
 
class RenderThreadCaller;
class MainThreadUpdateContext;
class MainThreadRenderUpdateContext;
class RenderThreadCaller;
class RenderData;
 
class DesignerObject : public AbstractDesignerObject
{
    using Base = AbstractDesignerObject;
 
public:
    // Work type should be kept in sync with `RenderThread::Work`
    using RenderWorkType = TFunction<void(render::System&)>;
 
    static std::string generateObjectName();
 
public:
    ~DesignerObject() override;
 
    virtual TSpanView<DesignerObject*> getChildren() const = 0;
    virtual bool canHaveChildren() const = 0;
    virtual math::TDecomposedTransform<real> getLocalToParent() const = 0;
    virtual void setLocalToParent(const math::TDecomposedTransform<real>& transform) = 0;
 
    virtual void init();
    virtual void uninit();
    virtual void renderInit(RenderThreadCaller& caller);
    virtual void renderUninit(RenderThreadCaller& caller);
    virtual void update(const MainThreadUpdateContext& ctx);
    virtual void renderUpdate(const MainThreadRenderUpdateContext& ctx);
    virtual void createRenderCommands(RenderThreadCaller& caller);
 
    virtual void editorTranslate(const math::Vector3R& amount);
    virtual void editorRotate(const math::QuaternionR& additionalRotation);
    virtual void editorScale(const math::Vector3R& amount);
 
    UIPropertyLayout layoutProperties() override;
 
    template<typename ChildType>
    ChildType* newChild(
        bool shouldInit = true,
        bool shouldSetToDefault = true);
 
    DesignerObject* newChild(
        const SdlClass* clazz,
        bool shouldInit = true,
        bool shouldSetToDefault = true);
 
    DesignerObject* addNewChild(DesignerObject* childObj);
 
    void deleteChild(DesignerObject* childObj);
 
    void deleteAllChildren();
 
    void enqueueRenderWork(RenderWorkType work);
 
    void setName(std::string name);
 
    void setUniqueName(std::string uniqueName);
 
    void select();
    void deselect();
    bool isSelected() const;
    void setVisibility(bool isVisible);
    bool isVisible() const;
    void setTick(bool shouldTick);
    void setRenderTick(bool shouldTick);
    bool haveChildren() const;
    DesignerScene& getScene();
    const DesignerScene& getScene() const;
    DesignerObject* getParent();
    const DesignerObject* getParent() const;
    const std::string& getName() const;
 
protected:
    DesignerObject();
    DesignerObject(const DesignerObject& other);
    DesignerObject(DesignerObject&& other) noexcept;
 
    DesignerObject& operator = (const DesignerObject& rhs);
    DesignerObject& operator = (DesignerObject&& rhs) noexcept;
 
private:
    // For accessing `setParentScene()` when creating root objects
    friend class DesignerScene;
 
    virtual DesignerObject* addChild(DesignerObject* childObj) = 0;
 
    virtual bool removeChild(DesignerObject* childObj) = 0;
 
    virtual void selected();
 
    virtual void deselected();
 
    void setParentObject(DesignerObject* object);
    void setParentScene(DesignerScene* scene);
 
private:
    union GeneralParent
    {
        DesignerScene* u_scene;
        DesignerObject* u_object;
    };
    
    GeneralParent m_parent;
 
    // SDL-binded fields:
    std::string m_name;
 
public:
    PH_DEFINE_SDL_CLASS(TSdlOwnerClass<DesignerObject>)
    {
        ClassType clazz("dobj");
        clazz.docName("Designer Object");
        clazz.description("Main base class of designer object.");
 
        // Creation and removal should be handled by designer scene
        clazz.allowCreateFromClass(false);
 
        clazz.baseOn<AbstractDesignerObject>();
 
        TSdlString<OwnerType> name("name", &OwnerType::m_name);
        name.description("Name of the designer object.");
        name.noDefault();// we are supplying custom default name in ctor
        clazz.addField(name);
 
        return clazz;
    }
};
 
}// end namespace ph::editor
 
#include "Designer/DesignerObject.ipp"