SceneLoader.h

浏览该文件的文档.

#pragma once
 
#include "common/Module.h"
#include "scene/NodeDesc.h"
 
#include <functional>
#include <memory>
#include <mutex>
#include <string>
#include <unordered_map>
#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 {
class 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 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 SceneLoader : public Module {
public:
    Module_REG(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);
 
    bool reload(const std::string &path, SceneDiff *out = nullptr,
                const LoadOptions &options = {});
 
    bool reloadChecked(const std::string &path) { return reload(path, nullptr); }
 
    SceneDiff diff(const std::string &path);
 
    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);
 
    int pollAsync();
 
    bool prewarmAsync(const std::string &path, const LoadOptions &options = {});
    bool prewarmed(const std::string &path) const;
    void clearPrewarm(const std::string &path);
 
    int pendingAsyncCount() 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 {
        std::string path;
        model3d::ModelData *md = nullptr;
        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::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_;
    mutable std::mutex pendingMu_;
};
 
}  // namespace sceneloader
}  // namespace eve