SceneLoader.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/Module.h"
#include "common/Result.h"
 
#include <functional>
#include <memory>
#include <mutex>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
struct aiScene;
struct aiNode;
struct aiMesh;
 
namespace eve {
namespace animation {
class AnimSkeleton;
class AnimClip;
}  // namespace animation
namespace graphics {
class Graphics;
class Renderable3D;
class Light3D;
class Camera3D;
class Texture;
class Mesh;
}  // namespace graphics
namespace model3d {
class ModelData;
}  // namespace model3d
namespace scene {
struct NodeDesc;
class SceneHost;
}  // namespace scene
namespace thread {
class ThreadPool;
}
 
namespace sceneloader {
 
struct SceneDiffEntry {
    enum class Action { Add, Remove, Modify, Move };
 
    Action action = Action::Add;
    std::string id;      // GameObject id (scene-object id).
    std::string parent;  // new parent id (Add / Move only).
};
 
struct SceneDiff {
    std::vector<SceneDiffEntry> entries;
    int added = 0;
    int removed = 0;
    int modified = 0;
    int moved = 0;
 
    bool empty() const { return entries.empty(); }
};
 
struct SceneInspection {
    SceneDiff diff;
    int nodeCount = 0;
    int meshNodeCount = 0;
    std::vector<std::string> warnings;
    std::vector<std::string> sockets;
    std::vector<std::string> collisions;
};
 
struct MeshSlot {
    const aiScene *scene = nullptr;
    const aiMesh *mesh = nullptr;
    unsigned materialIndex = 0;
};
using MeshSlotMap = std::unordered_map<std::string, std::vector<MeshSlot>>;
 
struct LoadOptions {
    bool triangulate = true;
    bool generateNormalsIfMissing = true;
    bool joinIdenticalVertices = true;
    bool flipUVs = true;
    bool improveCacheLocality = true;
    bool sharedMeshes = true;
    bool mipmaps = true;
    bool importLights = true;
    bool importCameras = false;
    bool importAnimations = true;
};
 
class EVENGINE_API_ORCHESTRATION SceneLoader : public Module {
public:
    Module_REG(SceneLoader);
 
    SceneLoader();
    ~SceneLoader() override;
 
    scene::SceneHost *load(const std::string &path, bool linkRenderables = true,
                           const LoadOptions &options = {});
    scene::SceneHost *load(const std::string &path, const LoadOptions &options);
    scene::SceneHost *loadPreset(const std::string &path, const std::string &preset);
 
    [[nodiscard("scene reload outcome must be checked")]] eve::Result<bool> reload(const std::string &path,
                                                                                   SceneDiff         *out     = nullptr,
                                                                                   const LoadOptions &options = {});
 
    SceneDiff diff(const std::string &path);
    [[nodiscard]] eve::Result<SceneInspection> inspect(const std::string &path,
                                                       const LoadOptions &options = {});
 
    scene::SceneHost *host(const std::string &path);
 
    void unload(const std::string &path);
 
    int nodeCount(const std::string &path);
    bool loaded(const std::string &path);
 
    // ---- async loading (decode off-thread, mount on the main thread) ----
 
    bool loadAsync(const std::string &path, const LoadOptions &options = {},
                   std::function<void(scene::SceneHost *)> done = nullptr);
 
    bool loadAsyncDefault(const std::string &path) { return loadAsync(path); }
    bool loadAsyncPreset(const std::string &path, const std::string &preset);
 
    int pollAsync();
 
    bool prewarmAsync(const std::string &path, const LoadOptions &options = {});
    bool prewarm(const std::string &path) { return prewarmAsync(path); }
    bool prewarmed(const std::string &path) const;
    void clearPrewarm(const std::string &path);
 
    int pendingAsyncCount() const;
 
    int warningCount(const std::string &path) const;
    std::string warning(const std::string &path, int index) const;
    bool setLod(const std::string &path, int level);
    int socketCount(const std::string &path) const;
    std::string socketName(const std::string &path, int index) const;
    int collisionCount(const std::string &path) const;
    std::string collisionName(const std::string &path, int index) const;
 
    // ---- imported scene extras ----
 
    int lightCount(const std::string &path);
    graphics::Light3D *light(const std::string &path, int index);
 
    int cameraCount(const std::string &path);
    graphics::Camera3D *camera(const std::string &path, int index);
 
    int animationCount(const std::string &path);
    animation::AnimSkeleton *skeleton(const std::string &path);
    animation::AnimClip *clip(const std::string &path, int index);
 
    // ---- pure tree helpers (no graphics required; unit-testable) ----
 
    using TextureCache = std::unordered_map<std::string, graphics::Texture *>;
    using MeshCache = std::unordered_map<const aiMesh *, graphics::Mesh *>;
    struct CpuImage {
        int w = 0;
        int h = 0;
        std::vector<uint8_t> rgba;
    };
    using CpuImageMap = std::unordered_map<std::string, CpuImage>;
 
    static scene::NodeDesc buildNodeDesc(const aiScene *scene, MeshSlotMap *slotsOut = nullptr);
 
    static SceneDiff diffTree(scene::SceneHost *host, const scene::NodeDesc &newRoot);
 
    static bool applyTreeDiff(scene::SceneHost *host, const scene::NodeDesc &newRoot,
                              const SceneDiff &diff, graphics::Graphics *gfx,
                              const MeshSlotMap *slots);
 
    static void fillSceneBounds(scene::SceneHost *host, const MeshSlotMap &slots);
 
private:
    struct Loaded {
        std::string path;
        scene::SceneHost *host = nullptr;
        graphics::Graphics *gfx = nullptr;
        LoadOptions options;
        std::vector<graphics::Light3D *> lights;
        std::vector<graphics::Camera3D *> cameras;
        animation::AnimSkeleton *skeleton = nullptr;
        std::vector<animation::AnimClip *> clips;
    };
 
    struct DecodedScene {
        DecodedScene();
        ~DecodedScene();
        DecodedScene(DecodedScene &&) noexcept;
        DecodedScene &operator=(DecodedScene &&) noexcept;
        DecodedScene(const DecodedScene &) = delete;
        DecodedScene &operator=(const DecodedScene &) = delete;
 
        std::string path;
        model3d::ModelData *md = nullptr;
        std::unique_ptr<scene::NodeDesc> root;
        MeshSlotMap slots;
        LoadOptions options;
        CpuImageMap cpuImages;  // external textures pre-decoded off-thread
        std::vector<graphics::Light3D *> lights;
        std::vector<graphics::Camera3D *> cameras;
        animation::AnimSkeleton *skeleton = nullptr;
        std::vector<animation::AnimClip *> clips;
        bool prewarmOnly = false;
        std::function<void(scene::SceneHost *)> done;
    };
 
    bool decode(const std::string &path, const LoadOptions &options, DecodedScene *out);
    scene::SceneHost *mount(DecodedScene &d);
    void linkMeshNodes(scene::SceneHost *host, const MeshSlotMap &slots,
                       graphics::Graphics *gfx, const LoadOptions &options,
                       TextureCache &textures, MeshCache &shared,
                       const CpuImageMap *predecoded = nullptr);
    void clearTextures();
    std::string decodeErrorFor(const std::string &path) const;
 
    std::unordered_map<std::string, Loaded> scenes_;
    std::unordered_map<std::string, DecodedScene> prewarmed_;
    TextureCache textures_;
    std::shared_ptr<thread::ThreadPool> pool_;
    std::vector<DecodedScene> pending_;
    std::unordered_set<std::string> inFlight_;
    // Internal async/decode diagnostics; public operations return structured Results.
    std::unordered_map<std::string, std::string> lastErrors_;
    std::unordered_map<std::string, std::vector<std::string>> warnings_;
    mutable std::mutex pendingMu_;
};
 
}  // namespace sceneloader
}  // namespace eve