imstkScene.h

/*
** This file is part of the Interactive Medical Simulation Toolkit (iMSTK)
** iMSTK is distributed under the Apache License, Version 2.0.
** See accompanying NOTICE for details.
*/

#pragma once

#include "imstkAccumulationBuffer.h"
#include "imstkEventObject.h"
#include "imstkMath.h"

#include <atomic>
#include <string>
#include <thread>
#include <unordered_map>
#include <unordered_set>
#include <vector>

namespace imstk
{
class Camera;
class CameraController;
class DeviceControl;
class Entity;
class IblProbe;
class Light;
class TaskGraph;
class TaskGraphController;
class TrackingDeviceControl;

namespace ParallelUtils { class SpinLock; }

struct SceneConfig
{
    // Keep track of the fps for the scene
    bool trackFPS = false;

    // If off, tasks will run sequentially
    bool taskParallelizationEnabled = false;

    // If on, elapsed times for computational steps will be reported in map
    bool taskTimingEnabled = false;

    // If on, the task graph will be written to a file
    bool writeTaskGraph = false;

    // If on, non functional nodes and redundant edges will be removed from final graph
    bool graphReductionEnabled = true;

    // If on, debug camera is positioned at scene bounding box
    bool debugCamBoundingBox = true;
};

class Scene : public EventObject
{
public:
    template<class T>
    using NamedMap = std::unordered_map<std::string, std::shared_ptr<T>>;

    Scene(const std::string& name, std::shared_ptr<SceneConfig> config = std::make_shared<SceneConfig>());
    ~Scene() override = default;

    // *INDENT-OFF*
    SIGNAL(Scene, configureTaskGraph);
    SIGNAL(Scene, modified);
    // *INDENT-ON*

    virtual bool initialize();

    void computeBoundingBox(Vec3d& lowerCorner, Vec3d& upperCorner, const double paddingPercent = 0.0);

    void buildTaskGraph();

    void initTaskGraph();

    void reset();

    void resetSceneObjects();

    virtual void advance(const double dt);

    virtual void updateVisuals(const double dt);

    void setEnableTaskTiming(const bool enabled);

    const std::unordered_set<std::shared_ptr<Entity>>& getSceneObjects() const { return m_sceneEntities; }

    std::shared_ptr<Entity> getSceneObject(const std::string& name) const;

    void addInteraction(std::shared_ptr<Entity> interaction);

    bool hasEntity(std::shared_ptr<Entity> entity) { return m_sceneEntities.find(entity) != m_sceneEntities.end(); }

    void addSceneObject(std::shared_ptr<Entity> entity);

    void removeSceneObject(const std::string& name);

    void removeSceneObject(std::shared_ptr<Entity> sceneObject);

    const std::vector<std::shared_ptr<Light>> getLights() const;

    std::shared_ptr<Light> getLight(const std::string& lightName) const;

    const std::unordered_map<std::string, std::shared_ptr<Camera>>& getCameras() const { return m_cameras; }

    void addLight(const std::string& name, std::shared_ptr<Light> newLight);

    void removeLight(const std::string& lightName);

    void setGlobalIBLProbe(std::shared_ptr<IblProbe> newIBLProbe) { m_globalIBLProbe = newIBLProbe; }

    std::shared_ptr<IblProbe> getGlobalIBLProbe() { return m_globalIBLProbe; }

    const std::string& getName() const { return m_name; }

    std::string getUniqueName(const std::string& name) const;

    std::shared_ptr<TaskGraph> getTaskGraph() const { return m_taskGraph; }

    std::shared_ptr<Camera> getActiveCamera() const { return m_activeCamera; }

    std::string getCameraName(const std::shared_ptr<Camera> cam) const;

    std::shared_ptr<Camera> getCamera(const std::string name) const;

    void addCamera(const std::string& name, std::shared_ptr<Camera> cam);

    void setActiveCamera(const std::string name);

    void removeCamera(const std::string name);

    void addControl(std::shared_ptr<DeviceControl> control);

    double getFPS() const { return m_fps; }

    double getFrameTime() const { return m_frameTimes.getAverage(); }

    double getSceneTime() const { return m_sceneTime; }

    const std::unordered_map<std::string, double>& getTaskComputeTimes() const { return m_nodeComputeTimes; }

    void lockComputeTimes();
    void unlockComputeTimes();

    std::shared_ptr<SceneConfig> getConfig() const { return m_config; };

protected:
    std::shared_ptr<SceneConfig> m_config;

    std::string m_name; 
    std::unordered_set<std::shared_ptr<Entity>> m_sceneEntities;
    std::unordered_map<std::string, std::shared_ptr<Light>> m_lightsMap;
    std::shared_ptr<IblProbe> m_globalIBLProbe = nullptr;

    std::unordered_map<std::string, std::shared_ptr<Camera>> m_cameras;
    std::shared_ptr<Camera> m_activeCamera;

    std::shared_ptr<TaskGraph> m_taskGraph;                                    
    std::shared_ptr<TaskGraphController> m_taskGraphController   = nullptr;    
    std::function<void(Scene*)> m_postTaskGraphConfigureCallback = nullptr;

    std::shared_ptr<ParallelUtils::SpinLock> m_computeTimesLock;
    std::unordered_map<std::string, double>  m_nodeComputeTimes; 

    AccumulationBuffer<double> m_frameTimes = AccumulationBuffer<double>(1024);
    double m_fps       = 0.0;
    double m_sceneTime = 0.0; 

    std::atomic<bool> m_resetRequested = ATOMIC_VAR_INIT(false);
};
} // namespace imstk