Node.h

Go to the documentation of this file.

#pragma once
 
#include <string>
#include <vector>
 
#include "PolyphaseAPI.h"
#include "Object.h"
#include "Assertion.h"
#include "EngineTypes.h"
#include "Property.h"
#include "Stream.h"
#include "Factory.h"
#include "Maths.h"
#include "NetDatum.h"
#include "NetFunc.h"
#include "ScriptUtils.h"
#include "ScriptAutoReg.h"
#include "Signals.h"
#include "Assets/StaticMesh.h"
 
#include "Bullet/btBulletCollisionCommon.h"
 
#include <unordered_map>
#include <unordered_set>
 
class Node;
class Scene;
class World;
class Script;
 
#define DECLARE_NODE(Class, Parent) \
        DECLARE_FACTORY(Class, Node); \
        DECLARE_OBJECT(Class, Parent); \
        DECLARE_SCRIPT_LINK(Class, Parent, Node) \
        typedef Parent Super;
 
#define DEFINE_NODE(Class, Parent) \
        DEFINE_FACTORY(Class, Node); \
        DEFINE_OBJECT(Class); \
        DEFINE_SCRIPT_LINK(Class, Parent, Node);
 
typedef std::unordered_map<std::string, NetFunc> NetFuncMap;
 
// Can also use a lambda for Traverse() and ForEach() functions
typedef bool(*NodeTraversalFP)(Node*);
 
// Forward declarations so we can use these in the Node class below
template<typename T = Node>
SharedPtr<T> ResolvePtr(Node* node);
 
template<typename T = Node>
WeakPtr<T> ResolveWeakPtr(Node* node);
 
#if 0
struct NodeNetData
{
    std::vector<NetDatum> mReplicatedData;
    NetId mNetId = INVALID_NET_ID;
    NetHostId mOwningHost = INVALID_HOST_ID;
    bool mReplicate = false;
    bool mReplicateTransform = false;
    bool mForceReplicate = false;
};
#endif
 
class POLYPHASE_API Node : public Object
{
public:
 
    DECLARE_FACTORY_MANAGER(Node);
    DECLARE_FACTORY(Node, Node);
    DECLARE_OBJECT(Node, Object);
    DECLARE_SCRIPT_LINK_BASE(Node);
 
    // Linear-scan lookup for a registered node factory by class name. Returns
    // nullptr if no factory matches. Used by the editor's "Add Node" menu
    // categorization (PolyphaseEngineAPI::SetNodeCategory threads through here).
    static Factory* FindFactory(const char* className);
 
    static NodePtr Construct(const std::string& name);
    static NodePtr Construct(TypeId typeId);
    static void Destruct(Node* node);
 
    Node();
    virtual ~Node();
 
    virtual void Create();
    virtual void Destroy();
    void DestroyDeferred();
    void Doom(); // Alias for DestroyDeferred
 
    virtual void SaveStream(Stream& stream, Platform platform);
    virtual void LoadStream(Stream& stream, Platform platform, uint32_t version);
 
    virtual void Copy(Node* srcNode, bool recurse);
    virtual void Render(PipelineConfig pipelineConfig);
 
    virtual void Awake();
    virtual void Start();
    virtual void Stop();
    virtual void PrepareTick(std::vector<NodePtrWeak>& outTickNodes, bool game, bool recurse);
    virtual void Tick(float deltaTime);
    virtual void EditorTick(float deltaTime);
    uint32_t GetLastTickedFrame() const;
    virtual void Render();
    virtual void OnInstanced();
 
    // Called once, only for a node freshly created via the editor's Add Node
    // menu (ActionSpawnNodes) -- unlike OnInstanced()/Create(), this is never
    // called when reconstructing a node from a saved scene, subscene, or
    // clone. Use this for starter child content that shouldn't be silently
    // re-added every time a saved node is reloaded.
    virtual void OnSpawnedInEditor();
 
    virtual VertexType GetVertexType() const;
 
    virtual void GatherProperties(std::vector<Property>& outProps) override;
 
    virtual void GatherReplicatedData(std::vector<NetDatum>& outData);
    virtual void GatherNetFuncs(std::vector<NetFunc>& outFuncs);
 
    void GatherPropertyOverrides(std::vector<Property>& outOverrides);
    void ApplyPropertyOverrides(const std::vector<Property>& overs);
 
    virtual void BeginOverlap(Primitive3D* thisComp, Primitive3D* otherComp);
    virtual void EndOverlap(Primitive3D* thisComp, Primitive3D* otherComp);
    virtual void OnCollision(
        Primitive3D* thisComp,
        Primitive3D* otherComp,
        glm::vec3 impactPoint,
        glm::vec3 impactNormal,
        btPersistentManifold* manifold);
 
    NodeId GetNodeId() const;
 
    uint64_t GetPersistentUuid() const;
    void SetPersistentUuid(uint64_t uuid);
    void EnsurePersistentUuid();
 
    void EmitSignal(const std::string& name, const std::vector<Datum>& args);
    void ConnectSignal(const std::string& name, Node* listener, SignalHandlerFP func);
    void ConnectSignal(const std::string& name, Node* listener, const ScriptFunc& func);
    void DisconnectSignal(const std::string& name, Node* listener);
 
    void RenderShadow();
    void RenderSelected(bool renderChildren);
 
    Node* CreateChild(TypeId nodeType);
    Node* CreateChild(const char* typeName);
    Node* CreateChildClone(Node* srcNode, bool recurse);
    NodePtr Clone(bool recurse, bool instantiateLinkedScene = true, bool resolveNodePaths = false);
    void DestroyAllChildren();
 
    Node* GetRoot();
    bool IsWorldRoot() const;
    Node* GetSubRoot();
 
    template<class NodeClass>
    NodeClass* CreateChild()
    {
        return (NodeClass*)CreateChild(NodeClass::GetStaticType());
    }
 
    template<class NodeClass>
    SharedPtr<NodeClass> CreateChildSp()
    {
        return ResolvePtr<NodeClass>(CreateChild(NodeClass::GetStaticType()));
    }
 
    template<class NodeClass>
    NodeClass* CreateChild(const char* name)
    {
        NodeClass* ret = (NodeClass*)CreateChild(NodeClass::GetStaticType());
        ret->SetName(name);
        return ret;
    }
 
    template<class NodeClass>
    SharedPtr<NodeClass> CreateChildSp(const char* name)
    {
        NodeClass* ret = (NodeClass*)CreateChild(NodeClass::GetStaticType());
        ret->SetName(name);
        return ResolvePtr<NodeClass>(ret);
    }
 
    bool IsDestroyed() const;
    bool IsPendingDestroy() const;
    bool IsDoomed() const;
 
    bool HasStarted() const;
    bool HasAwoken() const;
 
    void EnableTick(bool enable);
    bool IsTickEnabled() const;
 
    virtual void SetWorld(World* world, bool subRoot);
    World* GetWorld();
 
    void SetScene(Scene* scene);
    Scene* GetScene();
 
    uint8_t GetTargetScreen() const { return mTargetScreen; }
    void SetTargetScreen(uint8_t screen) { mTargetScreen = screen; }
 
    // Target Screen is authored on scene-root-level nodes and is NOT inherited, so
    // reading it off a nested node always gives the default 0. This walks up to the
    // direct child of the scene root, which is the granularity the renderer's screen
    // filter prunes at, and reports the screen that node actually renders on.
    // Pass a scene root explicitly to stop there; otherwise the node's world root is used.
    uint8_t GetEffectiveTargetScreen(Node* sceneRoot = nullptr);
 
    std::vector<NetDatum>& GetReplicatedData();
 
    void SetNetId(NetId id);
    NetId GetNetId() const;
 
    NetHostId GetOwningHost() const;
    void SetOwningHost(NetHostId hostId, bool setAsPawn = false);
 
    void SetReplicate(bool replicate);
    bool IsReplicated() const;
    void SetReplicateTransform(bool repTransform);
    bool IsTransformReplicated() const;
 
    void ForceReplication();
    void ClearForcedReplication();
    bool NeedsForcedReplication();
 
    virtual bool CheckNetRelevance(Node* playerNode);
    bool IsAlwaysRelevant() const;
    void SetAlwaysRelevant(bool alwaysRelevant);
 
    bool HasTag(const std::string& tag);
    void AddTag(const std::string& tag);
    void RemoveTag(const std::string& tag);
 
    void SetName(const std::string& newName);
    const std::string& GetName() const;
    virtual void SetActive(bool active);
    bool IsActive(bool recurse = false) const;
    virtual void SetVisible(bool visible);
    bool IsVisible(bool recurse = false) const;
    void SetTransient(bool transient);
    virtual bool IsTransient() const;
    void SetPersistent(bool persistent);
    bool IsPersistent() const;
 
    void SetDefault(bool isDefault);
    bool IsDefault() const;
 
    void SetUserdataCreated(bool created);
    bool IsUserdataCreated() const;
 
    virtual const char* GetTypeName() const;
    virtual DrawData GetDrawData();
 
    virtual bool IsNode3D() const;
    virtual bool IsWidget() const;
    virtual bool IsPrimitive3D() const;
    virtual bool IsLight3D() const;
 
    Node* GetParent();
    const Node* GetParent() const;
    const std::vector<NodePtr>& GetChildren() const;
 
    virtual void Attach(Node* parent, bool keepWorldTransform = false, int32_t index = -1);
    void Detach(bool keepWorldTransform = false);
    void AddChild(Node* child, int32_t index = -1);
    void RemoveChild(Node* child);
    void RemoveChild(int32_t index);
 
    template<typename T>
    void AddChild(const SharedPtr<T>& child, int32_t index = -1)
    {
        AddChild(child.Get(), index);
    }
 
    template<typename T>
    void RemoveChild(const SharedPtr<Node>& child)
    {
        RemoveChild(child.Get());
    }
 
    int32_t FindChildIndex(const std::string& name) const;
    int32_t FindChildIndex(Node* child) const;
    Node* FindChild(const std::string& name, bool recurse) const;
    Node* FindChildWithTag(const std::string& name, bool recurse) const;
    Node* FindDescendant(const std::string& name);
    Node* FindAncestor(const std::string& name);
    bool HasAncestor(Node* node);
    Node* GetChild(int32_t index) const;
    Node* GetChildByType(TypeId type) const;
    uint32_t GetNumChildren() const;
    int32_t FindParentNodeIndex() const;
 
    void SetHitCheckId(uint32_t id);
    uint32_t GetHitCheckId() const;
 
    bool IsLateTickEnabled() const;
    void EnableLateTick(bool enable);
 
    Script* GetScript();
    void SetScriptFile(const std::string& fileName);
 
    bool DoChildrenHaveUniqueNames() const;
    void BreakSceneLink();
    bool IsSceneLinked(bool ignoreInPie = true) const;
    bool IsSceneLinkedChild(bool ignoreInPie = true);
    bool IsForeign() const;
 
    bool HasAuthority() const;
    bool IsOwned() const;
    bool IsLocallyControlled() const;
 
    Datum GetField(const std::string& key);
    void SetField(const std::string& name, const Datum& value);
    Datum GetField(int32_t key);
    void SetField(int32_t key, const Datum& value);
    Datum CallFunction(const std::string& name, const std::vector<Datum>& args = {});
 
    NetFunc* FindNetFunc(const char* name);
    NetFunc* FindNetFunc(uint16_t index);
 
    void InvokeNetFunc(const char* name);
    void InvokeNetFunc(const char* name, Datum param0);
    void InvokeNetFunc(const char* name, Datum param0, Datum param1);
    void InvokeNetFunc(const char* name, Datum param0, Datum param1, Datum param2);
    void InvokeNetFunc(const char* name, Datum param0, Datum param1, Datum param2, Datum param3);
    void InvokeNetFunc(const char* name, Datum param0, Datum param1, Datum param2, Datum param3, Datum param4);
    void InvokeNetFunc(const char* name, Datum param0, Datum param1, Datum param2, Datum param3, Datum param4, Datum param5);
    void InvokeNetFunc(const char* name, Datum param0, Datum param1, Datum param2, Datum param3, Datum param4, Datum param5, Datum param6);
    void InvokeNetFunc(const char* name, Datum param0, Datum param1, Datum param2, Datum param3, Datum param4, Datum param5, Datum param6, Datum param7);
    void InvokeNetFunc(const char* name, const std::vector<Datum>& params);
 
    static void ProcessPendingDestroys();
 
    static void RegisterNetFuncs(Node* node);
 
    static void Deleter(Node* node);
 
    const WeakPtr<Node>& GetSelfPtr() const { return mSelf; }
 
    template<typename T>
    T* FindChild(const std::string& name, bool recurse)
    {
        T* ret = nullptr;
        Node* child = FindChild(name, recurse);
        if (child != nullptr)
        {
            ret = child->As<T>();
        }
 
        return ret;
    }
 
    template<typename T>
    void Traverse(T func, bool inverted = false)
    {
        bool traverseChildren = true;
        
        if (!inverted)
        {
            traverseChildren = func(this);
        }
 
        if (traverseChildren)
        {
            if (inverted)
            {
                for (int32_t i = int32_t(mChildren.size()) - 1; i >= 0; --i)
                {
                    mChildren[i]->Traverse(func, inverted);
                }
            }
            else
            {
                for (uint32_t i = 0; i < mChildren.size(); ++i)
                {
                    mChildren[i]->Traverse(func, inverted);
                }
            }
        }
 
        if (inverted)
        {
            func(this);
        }
    }
 
    template<typename T>
    bool ForEach(T func, bool inverted = false)
    {
        bool cont = true;
 
        if (!inverted)
        {
            cont = func(this);
        }
 
        if (cont)
        {
            if (inverted)
            {
                for (int32_t i = int32_t(mChildren.size()) - 1; i >= 0; --i)
                {
                    cont = mChildren[i]->ForEach(func, inverted);
 
                    if (!cont)
                    {
                        break;
                    }
                }
            }
            else
            {
                for (uint32_t i = 0; i < mChildren.size(); ++i)
                {
                    cont = mChildren[i]->ForEach(func, inverted);
 
                    if (!cont)
                    {
                        break;
                    }
                }
            }
        }
 
        if (cont && inverted)
        {
            cont = func(this);
        }
 
        return cont;
    }
 
    template<class NodeClass>
    static SharedPtr<NodeClass> Construct()
    {
        // Code copied across other Construct() functions
        NodeClass* newNode = (NodeClass*)Node::CreateInstance(NodeClass::GetStaticType());
        SharedPtr<NodeClass> newNodePtr;
 
        if (newNode != nullptr)
        {
            newNodePtr.Set(newNode, nullptr);
            newNodePtr.SetDeleter([](NodeClass* node) { Node::Deleter(node); });
            newNodePtr->mSelf = PtrStaticCast<Node>(newNodePtr);
            newNodePtr->Create();
        }
 
        return newNodePtr;
    }
 
protected:
 
    static bool HandlePropChange(Datum* datum, uint32_t index, const void* newValue);
 
    static bool OnRep_OwningHost(Datum* datum, uint32_t index, const void* newValue);
 
    void TickCommon(float deltaTime);
 
    virtual void SetParent(Node* parent);
    void ValidateUniqueChildName(Node* newChild);
 
    void SendNetFunc(NetFunc* func, uint32_t numParams, const Datum** params);
 
    static std::unordered_map<TypeId, NetFuncMap> sTypeNetFuncMap;
    static std::unordered_set<NodePtrWeak> sPendingDestroySet;
    static NodeId sNextNodeId;
 
    std::string mName;
 
    World* mWorld = nullptr;
    NodePtrWeak mParent;
    NodePtrWeak mSelf;
    std::vector<NodePtr> mChildren;
    std::unordered_map<std::string, Node*> mChildNameMap;
    std::unordered_map<std::string, Signal> mSignalMap;
    std::string mScriptFile;
    uint32_t mLastTickedFrame = 0;
    bool mActive = true;
    bool mVisible = true;
    bool mTransient = false;
    bool mPersistent = false;
    bool mDefault = false;
    bool mUserdataCreated = false;
    bool mHasStarted = false;
    bool mHasAwoken = false;
    bool mDestroyed = false;
    bool mTickEnabled = true;
    bool mLateTick = false;
 
    // Merged from Actor
    SceneRef mScene;
    uint8_t mTargetScreen = 0; // 0 = Top Screen, 1 = Bottom Screen
    std::vector<std::string> mTags;
    NodeId mNodeId = INVALID_NODE_ID;
    uint64_t mPersistentUuid = 0;
 
    // Network Data
    // This is only about 44 bytes, so right now, we will keep this data as direct members of Node.
    // But if we need to save data, then consider allocating a NodeNetData struct only if replicated.
    // Leaving these as direct members will improve cache performance too.
    std::vector<NetDatum> mReplicatedData;
    NetId mNetId = INVALID_NET_ID;
    NetHostId mOwningHost = INVALID_HOST_ID;
    bool mReplicate = false;
    bool mReplicateTransform = false;
    bool mForceReplicate = false;
    bool mAlwaysRelevant = true;
 
    Script* mScript = nullptr;
    //NodeNetData* mNetData = nullptr;
 
#if EDITOR
public:
    // TODO-NODE: Either remove mExposeVariable, or make sure it works with Scenes.
    // Could consider moving this up to Node if it would be useful from avoiding FindChild() calls in Start().
    bool ShouldExposeVariable() const;
    void SetExposeVariable(bool expose);
    bool AreAllChildrenHiddenInTree() const;
 
    uint32_t mHitCheckId = 0;
    bool mExposeVariable = false;
    bool mHiddenInTree = false;
#endif
};
 
// Eventually, if we move the mSelf pointer into Object, we will have to
// move these functions also (and make them take Object* param)
//
// Defensive: if `node`'s mSelf has been stomped so it no longer points back
// at `node` (most often a dangling Node* from a previous world/addon load
// whose memory got reused), Lock() will crash inside IsValid when it
// dereferences the dangling mPointer. Gate the Lock with a self-consistency
// check and return null on mismatch so callers see "couldn't resolve" instead
// of an access violation. Callers that care surface a user-visible error
// (see Node::AddChild for the editor alert).
template<typename T>
SharedPtr<T> ResolvePtr(Node* node)
{
    if (node == nullptr)
    {
        return nullptr;
    }
 
    const NodePtrWeak& selfWeak = node->GetSelfPtr();
    if (selfWeak.GetPointerRaw() != node || selfWeak.GetRefCount() == nullptr)
    {
        return nullptr;
    }
 
    NodePtr nodePtr = selfWeak.Lock();
    return PtrStaticCast<T>(nodePtr);
}
 
template<typename T>
WeakPtr<T> ResolveWeakPtr(Node* node)
{
    if (node == nullptr)
    {
        return WeakPtr<T>();
    }
 
    const NodePtrWeak& selfWeak = node->GetSelfPtr();
    if (selfWeak.GetPointerRaw() != node || selfWeak.GetRefCount() == nullptr)
    {
        return WeakPtr<T>();
    }
 
    return PtrStaticCast<T>(selfWeak);
}