SceneHost.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/ECS.h"
#include "common/Identity.h"
#include "common/Result.h"
 
#include <cstdint>
#include <functional>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
 
#include <glm/mat4x4.hpp>
 
#include "scene/NodeDesc.h"
#include "scene/SceneLink.h"
 
// Only pointers to these cross the interface, so a forward declaration is
// enough: scene links carry them as void* and the owning module does the casts.
namespace eve::graphics {
class Renderable2D;
class Renderable3D;
class Camera3D;
}
 
namespace eve::physics {
class Body;
class Body3D;
}
 
namespace eve::audio {
class Source;
}
 
namespace eve::scene {
 
enum class SceneMutationStatus { Applied, Rejected };
 
struct SceneNode {
    std::string id;
    eve::SceneObjectId persistentId;
    std::string key;
    std::string name;
    std::string space = "3d";  // "2d" | "3d"
    bool visible = true;
    std::vector<std::string> tags;
    int layer = 0;
    float bminX = 0.f, bminY = 0.f, bminZ = 0.f;
    float bmaxX = 0.f, bmaxY = 0.f, bmaxZ = 0.f;
    bool hasBounds = false;
 
    float x = 0.f, y = 0.f, z = 0.f;
    float yaw = 0.f, pitch = 0.f, roll = 0.f;
    float sx = 1.f, sy = 1.f, sz = 1.f;
 
    bool localDirty = true;
    bool subtreeDirty = true;
    glm::mat4 world{1.f};
 
    std::vector<SceneLink> links;
 
    uint32_t objectId = 0;
 
    int firstChild = -1;
    int nextSibling = -1;
    int parent = -1;
};
 
using GameObject = SceneNode;
 
class EVENGINE_API_PLATFORM SceneHost : public ecs::Entity {
public:
    ENTITY(SceneHost, ecs::Entity)
 
    
    void release() override {}
 
    struct Meta {
        bool visible = true;
        int layer = 0;
        std::string name;
        uint32_t ownerId = 0;
        SceneHost *entity = nullptr;
    };
 
    struct Tree {
        bool dirty = true;
        bool transformDirty = true;
        bool indexValid = false;
        std::unordered_map<std::string, int> idIndex;
        std::vector<SceneNode> nodes;
        int root = -1;
    };
 
    [[nodiscard]] static eve::Result<Tree> buildDetachedTree(const Tree* previous, NodeDesc root);
 
    COMPONENT(Meta, meta)
    COMPONENT(Tree, tree)
 
    
    [[nodiscard]] static eve::Result<SceneHost *> createHost(const std::string &name = "");
 
    void setName(const std::string &name);
    const std::string &getName();
    void setOwnerId(uint32_t ownerId) { meta()->ownerId = ownerId; }
    uint32_t getOwnerId() { return meta()->ownerId; }
 
    void setTree(NodeDesc root);
    bool setTreeReconcile(NodeDesc root);
 
    [[nodiscard]] eve::Result<SceneNode *> findById(const std::string &id);
    [[nodiscard]] eve::Result<SceneNode *> findByKey(const std::string &key);
    [[nodiscard]] eve::Result<SceneNode *> findByName(const std::string &name);
    [[nodiscard]] eve::Result<SceneNode *> findByPath(const std::string &path);
    int findIndexById(const std::string &id);
    int findIndexByKey(const std::string &key);
    int findIndexByName(const std::string &name);
    int findIndexByPath(const std::string &path);
 
    bool hasNode(const std::string &id);
    int getNodeCount();
    int getRootIndex();
    [[nodiscard]] SceneNode *getRoot();
    [[nodiscard]] SceneNode *getNode(int index);
 
    int getParentIndex(int nodeIndex);
    [[nodiscard]] SceneNode *getParent(int nodeIndex);
    [[nodiscard]] SceneNode *getParentById(const std::string &id);
    int getChildCount(int nodeIndex);
    int getChildCountById(const std::string &id);
    int getChildIndexAt(int parentIndex, int childOrdinal);
    [[nodiscard]] SceneNode *getChildAt(int parentIndex, int childOrdinal);
    [[nodiscard]] SceneNode *getChildAtById(const std::string &parentId, int childOrdinal);
    std::vector<int> getChildIndices(int nodeIndex);
    std::vector<SceneNode *> getChildren(int nodeIndex);
    std::vector<std::string> getChildIds(const std::string &parentId);
 
    std::string getPath(int nodeIndex);
    std::string getPathById(const std::string &id);
 
    bool isAncestorOf(int ancestorIndex, int nodeIndex);
    bool isAncestorOfById(const std::string &ancestorId, const std::string &nodeId);
    bool isDescendantOf(int nodeIndex, int ancestorIndex);
    bool isDescendantOfById(const std::string &nodeId, const std::string &ancestorId);
 
    void markDirty() { tree()->dirty = true; }
    void markTransformDirty() { tree()->transformDirty = true; }
    void markSubtreeDirty(int nodeIndex);
    void markSubtreeDirtyById(const std::string &nodeId) {
        markSubtreeDirty(findIndexById(nodeId));
    }
    void invalidateIndex() { tree()->indexValid = false; }
 
    // --- Node lifecycle events ---
    using SceneEventFn = std::function<void(SceneHost *host, const std::string &action,
                                            const std::string &nodeId,
                                            const std::string &parentId)>;
    void setEventHandler(SceneEventFn fn) { eventHandler_ = std::move(fn); }
    void fireEvent(const std::string &action, const std::string &nodeId,
                   const std::string &parentId = {});
 
    void setVisible(bool v) { meta()->visible = v; }
    void setLayer(int layer) { meta()->layer = layer; }
 
    bool setParent(int childIndex, int parentIndex);
    bool addChild(int parentIndex, int childIndex);
    bool removeChild(int parentIndex, int childIndex);
 
    SceneMutationStatus appendNode(SceneNode node, const std::string &parentId = {});
    SceneMutationStatus removeLeaf(const std::string &nodeId);
    SceneMutationStatus renameNode(const std::string &nodeId, const std::string &name);
    SceneMutationStatus setLocalTransform(const std::string &nodeId, float x, float y, float z,
                           float yaw, float pitch, float roll, float sx, float sy, float sz);
 
    void forEachDepthFirst(int nodeIndex, void (*fn)(SceneHost *, int, void *), void *user);
 
    using NodeVisitFn = std::function<void(SceneHost *host, int index, SceneNode &node)>;
    using NodePredFn = std::function<bool(SceneHost *host, int index, const SceneNode &node)>;
 
    void walkDepthFirst(NodeVisitFn fn);
    void walkDepthFirstFrom(int nodeIndex, NodeVisitFn fn);
    void walkBreadthFirst(NodeVisitFn fn);
    void walkBreadthFirstFrom(int nodeIndex, NodeVisitFn fn);
    void walkChildren(int parentIndex, NodeVisitFn fn);
    void walkAncestors(int nodeIndex, NodeVisitFn fn);
 
    [[nodiscard]] SceneNode *findIf(NodePredFn pred);
    [[nodiscard]] SceneNode *findIfFrom(int nodeIndex, NodePredFn pred);
    std::vector<SceneNode *> filter(NodePredFn pred);
    std::vector<SceneNode *> filterFrom(int nodeIndex, NodePredFn pred);
    std::vector<int> filterIndices(NodePredFn pred);
    std::vector<int> filterIndicesFrom(int nodeIndex, NodePredFn pred);
 
    std::vector<SceneNode *> findAllByName(const std::string &name);
    std::vector<SceneNode *> findAllByKey(const std::string &key);
    std::vector<SceneNode *> findAllVisible(bool visible = true);
    std::vector<SceneNode *> findAllBySpace(const std::string &space);
    std::vector<SceneNode *> findAllLinked();
 
    std::vector<std::string> collectIds();
    std::vector<std::string> collectIdsFrom(int nodeIndex);
    std::vector<std::string> collectIdsWhere(NodePredFn pred);
    std::vector<std::string> collectIdsByName(const std::string &name);
    std::vector<std::string> collectIdsVisible(bool visible = true);
 
    bool link(const std::string &nodeId, int kind, void *target, int syncMode = 0);
 
    bool linkRenderable2D(const std::string &nodeId, graphics::Renderable2D *r);
    bool linkRenderable3D(const std::string &nodeId, graphics::Renderable3D *r);
    bool linkPhysics2D(const std::string &nodeId, physics::Body *b, int syncMode = 0);
    bool linkPhysics3D(const std::string &nodeId, physics::Body3D *b, int syncMode = 0);
    bool linkCamera3D(const std::string &nodeId, graphics::Camera3D *c);
    bool linkAudio3D(const std::string &nodeId, audio::Source *s);
 
    bool unlink(const std::string &nodeId, int kind);
    bool unlink(const std::string &nodeId);
 
    [[nodiscard]] SceneLink *findLink(SceneNode *node, int kind);
    [[nodiscard]] const SceneLink *findLink(const SceneNode *node, int kind) const;
    int linkCount(const std::string &nodeId);
 
    bool setParentById(const std::string &childId, const std::string &parentId);
    bool removeChildById(const std::string &parentId, const std::string &childId);
 
    bool addTag(SceneNode *node, const std::string &tag);
    bool removeTag(SceneNode *node, const std::string &tag);
    bool hasTag(const SceneNode *node, const std::string &tag) const;
    std::vector<SceneNode *> findAllByTag(const std::string &tag);
 
private:
    SceneEventFn eventHandler_;
};
 
}  // namespace eve::scene