Controller.h

Go to the documentation of this file.

#pragma once
 
#include "gui/Settings.h"
#include "io/Path.h"
#include "objects/wrappers/Locking.h"
#include "objects/wrappers/SharedPtr.h"
#include "run/IRun.h"
#include "run/Node.h"
#include "system/Settings.h"
#include <condition_variable>
#include <thread>
 
class wxWindow;
class wxSizer;
 
NAMESPACE_SPH_BEGIN
 
class RunPage;
class Storage;
class Statistics;
class Timer;
struct Pixel;
class Palette;
class JobNode;
class Project;
class IRenderer;
class ICamera;
class IColorizer;
enum class ColorizerId;
using ExtColorizerId = ExtendedEnum<ColorizerId>;
 
enum class RunStatus {
    RUNNING,  
    PAUSED,   
    STOPPED,  
    QUITTING, 
};
 
 
class Controller : public IJobCallbacks {
private:
    RawPtr<RunPage> page;
 
    Project& project;
 
    struct {
        std::thread thread;
 
        SharedPtr<INode> run;
 
        RunSettings globals;
 
        RawPtr<const Storage> storage;
 
        Path path;
 
        std::atomic_bool shouldContinue;
 
        using TimeStepCallback = Function<void(const Storage& storage, const Statistics& stats)>;
        Locking<Array<TimeStepCallback>> onTimeStepCallbacks;
 
    } sph;
 
    struct Vis {
        Array<Vector> positions;
 
        AutoPtr<Statistics> stats;
 
        AutoPtr<IRenderer> renderer;
 
        SharedPtr<IColorizer> colorizer;
 
        AutoPtr<ICamera> camera;
        mutable std::mutex cameraMutex;
 
        Optional<Size> selectedParticle;
 
        AutoPtr<wxBitmap> bitmap;
 
        std::atomic_bool redrawOnNextTimeStep;
 
        mutable std::atomic_bool refreshPending;
 
        std::thread renderThread;
 
        std::atomic_bool needsRefresh;
 
        std::mutex renderThreadMutex;
        std::condition_variable renderThreadVar;
 
        AutoPtr<Timer> timer;
 
        Vis();
 
        void initialize(const Project& project);
 
        bool isInitialized();
 
        void refresh();
    } vis;
 
    RunStatus status = RunStatus::STOPPED;
 
    std::mutex continueMutex;
    std::condition_variable continueVar;
 
    std::mutex updateMutex;
    std::condition_variable updateVar;
 
public:
    Controller(wxWindow* parent);
 
    ~Controller();
 
    RawPtr<RunPage> getPage() const;
 
 
    bool isRunning() const;
 
 
    Array<SharedPtr<IColorizer>> getColorizerList(const Storage& storage) const;
 
    const wxBitmap& getRenderedBitmap() const;
 
    AutoPtr<ICamera> getCurrentCamera() const;
 
    SharedPtr<IColorizer> getCurrentColorizer() const;
 
    Optional<Size> getIntersectedParticle(const Pixel position, const float toleranceEps);
 
    Optional<Size> getSelectedParticle() const;
 
    const Storage& getStorage() const;
 
    GuiSettings& getParams();
 
 
 
    void update(const Storage& storage, const Statistics& stats);
 
    void setColorizer(const SharedPtr<IColorizer>& newColorizer);
 
    void setRenderer(AutoPtr<IRenderer>&& newRenderer);
 
    void setSelectedParticle(const Optional<Size>& particleIdx);
 
    void setPaletteOverride(const Palette palette);
 
    bool tryRedraw();
 
    void redrawOnNextTimeStep();
 
    void refresh(AutoPtr<ICamera>&& camera);
 
 
    void start(SharedPtr<INode> run, const RunSettings& globals);
 
    void open(const Path& path, const bool sequence = false);
 
    void restart();
 
    void pause();
 
    void stop(const bool waitForFinish = false);
 
    RunStatus getStatus() const;
 
    void saveState(const Path& path);
 
    void quit(const bool waitForFinish = false);
 
    void setAutoZoom(const bool enable);
 
private:
    virtual void onStart(const IJob& job) override;
 
    virtual void onEnd(const Storage& storage, const Statistics& stats) override;
 
    virtual void onSetUp(const Storage& storage, Statistics& stats) override;
 
    virtual void onTimeStep(const Storage& storage, Statistics& stats) override;
 
    virtual bool shouldAbortRun() const override;
 
    void redraw(const Storage& storage, const Statistics& stats);
 
    // main thread call if page exists
    void safePageCall(Function<void(RunPage*)> func);
 
    void startRunThread();
 
    void startRenderThread();
};
 
Array<ExtColorizerId> getColorizerIds();
 
NAMESPACE_SPH_END