tfSimulator.h

Go to the documentation of this file.

/*******************************************************************************
 * This file is part of Tissue Forge.
 * Copyright (c) 2022-2024 T.J. Sego
 * 
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published
 * by the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 * 
 ******************************************************************************/
 
#ifndef _SOURCE_TFSIMULATOR_H_
#define _SOURCE_TFSIMULATOR_H_
 
#include "TissueForge_private.h"
 
#include "io/tfFIO.h"
#ifdef TF_WITHCUDA
#include "cuda/tfSimulatorConfig.h"
#endif
 
#include "tfUniverse.h"
 
#include <cstdint>
 
 
namespace TissueForge {
 
 
    namespace rendering {
        struct Application;
        struct GlfwWindow;
    }
 
 
    struct CAPI_EXPORT Simulator {
 
        struct Config;
        class GLConfig;
 
        enum WindowFlags : std::uint16_t
        {
            Fullscreen = 1 << 0,
 
            Borderless = 1 << 1,
 
            Resizable = 1 << 2,    
            Hidden = 1 << 3,       
            Maximized = 1 << 4,
 
 
            Minimized = 1 << 5,    
            AlwaysOnTop = 1 << 6,
 
 
 
            AutoIconify = 1 << 7,
 
            Focused = 1 << 8,
 
            Contextless = 1 << 9
 
        };
 
        // Of the available integrator types, these are supported by Simulator
        enum class EngineIntegrator : int {
            FORWARD_EULER = TissueForge::EngineIntegrator::FORWARD_EULER,
            RUNGE_KUTTA_4 = TissueForge::EngineIntegrator::RUNGE_KUTTA_4
        };
 
        enum Key {
            NONE,
            WINDOWLESS,
            GLFW
        };
 
        enum Options {
            Windowless = 1 << 0,
 
            glfw = 1 << 1,
            GlForwardCompatible = 1 << 2,
 
            GlNoError = 1 << 3,
 
 
            GlDebug = 1 << 4,
 
            GlStereo = 1 << 5     
        };
 
        enum class DpiScalingPolicy : std::uint8_t {
            /* Using 0 for an "unset" value */
 
            #ifdef CORRADE_TARGET_APPLE
            Framebuffer = 1,
            #endif
 
            #ifndef CORRADE_TARGET_APPLE
            Virtual = 2,
 
            Physical = 3,
            #endif
 
            Default
                #ifdef CORRADE_TARGET_APPLE
                = Framebuffer
                #else
                = Virtual
                #endif
        };
 
        int32_t kind;
        struct rendering::Application *app;
 
        enum Flags {
            Running = 1 << 0
        };
 
        static Simulator *get();
 
        HRESULT makeCurrent();
 
        static HRESULT initConfig(const Config &conf, const GLConfig &glConf);
 
        static HRESULT pollEvents();
 
        static HRESULT waitEvents();
 
        static HRESULT waitEventsTimeout(FloatP_t timeout);
 
        static HRESULT postEmptyEvent();
 
        static HRESULT run(FloatP_t et);
 
        static HRESULT show();
 
        static HRESULT close();
 
        static HRESULT destroy();
 
        static HRESULT redraw();
 
        static HRESULT swapInterval(int si);
 
        static const int getNumThreads();
 
        static const rendering::GlfwWindow *getWindow();
 
        #ifdef TF_WITHCUDA
        static cuda::SimulatorConfig *getCUDAConfig();
 
        static HRESULT makeCUDAConfigCurrent(cuda::SimulatorConfig *config);
        #endif
 
        static HRESULT throwExceptions(const bool &_throw);
 
        static bool throwingExceptions();
        
        // list of windows.
        std::vector<rendering::GlfwWindow*> windows;
    };
 
    CAPI_FUNC(bool) isTerminalInteractiveShell();
 
    CAPI_FUNC(HRESULT) setIsTerminalInteractiveShell(const bool &_interactive);
 
    CPPAPI_FUNC(HRESULT) Simulator_init(const std::vector<std::string> &argv);
 
    CPPAPI_FUNC(HRESULT) Simulator_init(Simulator::Config &conf, const std::vector<std::string> &appArgv=std::vector<std::string>());
 
    struct CAPI_EXPORT Simulator::Config {
 
        /*implicit*/
        Config();
 
        ~Config() {};
 
        std::string title() const
        {
            return _title;
        }
 
        void setTitle(std::string title)
        {
            _title = std::move(title);
        }
 
        iVector2 windowSize() const
        {
            return _size;
        }
 
        Simulator::DpiScalingPolicy dpiScalingPolicy() const
        {
            return _dpiScalingPolicy;
        }
 
        fVector2 dpiScaling() const
        {
            return _dpiScaling;
        }
 
        void setDpiScaling(const fVector2 &vec)
            {
                _dpiScaling = vec;
            }
 
 
        void setSizeAndScaling(const iVector2& size, Simulator::DpiScalingPolicy dpiScalingPolicy = Simulator::DpiScalingPolicy::Default) {
                    _size = size;
                    _dpiScalingPolicy = dpiScalingPolicy;
 
                }
 
 
        void setSizeAndScaling(const iVector2& size, const FVector2& dpiScaling) {
                    _size = size;
                    _dpiScaling = dpiScaling;
        }
 
        void setWindowSize(const iVector2 &size)
        {
            _size = size;
        }
 
        uint32_t windowFlags() const
        {
            return _windowFlags;
        }
 
        void setWindowFlags(uint32_t windowFlags)
        {
            _windowFlags = windowFlags;
        }
 
        bool windowless() const {
            return _windowless;
        }
 
        void setWindowless(bool val) {
            _windowless = val;
        }
 
        int size() const {
            return universeConfig.nParticles;
        }
 
        void setSize(int i ) {
            universeConfig.nParticles = i;
        }
 
        unsigned int *seed() {
            return _seed;
        }
 
        void setSeed(const unsigned int &seed) {
            if(_seed != NULL) *_seed = seed;
            else _seed = new unsigned int(seed);
        }
 
        bool throwingExceptions() const {
            return _throwingExceptions;
        }
 
        void setThrowingExceptions(const bool &throwingExceptions) {
            _throwingExceptions = throwingExceptions;
        }
 
        std::string *importDataFilePath() {
            return _importDataFilePath;
        }
 
        bool hasImportDataFilePath() const { 
            return _importDataFilePath;
        }
 
        void clearImportDataFilePath() {
            if(_importDataFilePath) {
                delete _importDataFilePath;
                _importDataFilePath = NULL;
            }
        }
 
        void setImportDataFilePath(const std::string &_path) {
            clearImportDataFilePath();
            _importDataFilePath = new std::string();
            *_importDataFilePath = _path;
        }
 
        UniverseConfig universeConfig;
 
        int queues;
 
        int argc = 0;
 
        char** argv = NULL;
        
        std::vector<FVector4> clipPlanes;
 
    private:
        std::string _title;
        iVector2 _size;
        uint32_t _windowFlags;
        Simulator::DpiScalingPolicy _dpiScalingPolicy;
        FVector2 _dpiScaling;
        bool _windowless;
        unsigned int *_seed = NULL;
        bool _throwingExceptions = false;
        std::string *_importDataFilePath = NULL;
    };
 
    class CAPI_EXPORT Simulator::GLConfig {
    public:
        enum  Flag: uint32_t {
    #ifndef MAGNUM_TARGET_GLES
            ForwardCompatible = 1 << 0,
    #endif
 
    #if defined(DOXYGEN_GENERATING_OUTPUT) || defined(GLFW_CONTEXT_NO_ERROR)
            NoError = 1 << 1,
    #endif
 
            Debug = 1 << 2,
 
            Stereo = 1 << 3     
        };
 
        typedef uint32_t Flags;
 
        explicit GLConfig();
        ~GLConfig();
 
        Flags flags() const { return _flags; }
 
        GLConfig& setFlags(Flags flags) {
            _flags = flags;
            return *this;
        }
 
        GLConfig& addFlags(Flags flags) {
            _flags |= flags;
            return *this;
        }
 
        GLConfig& clearFlags(Flags flags) {
            _flags &= ~flags;
            return *this;
        }
 
        std::int32_t version() const { return _version; }
 
        GLConfig& setVersion(std::int32_t version) {
            _version = version;
            return *this;
        }
 
        iVector4 colorBufferSize() const { return _colorBufferSize; }
 
        GLConfig& setColorBufferSize(const iVector4& size) {
            _colorBufferSize = size;
            return *this;
        }
 
        std::int32_t depthBufferSize() const { return _depthBufferSize; }
 
        GLConfig& setDepthBufferSize(std::int32_t size) {
            _depthBufferSize = size;
            return *this;
        }
 
        std::int32_t stencilBufferSize() const { return _stencilBufferSize; }
 
        GLConfig& setStencilBufferSize(std::int32_t size) {
            _stencilBufferSize = size;
            return *this;
        }
 
        std::int32_t sampleCount() const { return _sampleCount; }
 
        GLConfig& setSampleCount(std::int32_t count) {
            _sampleCount = count;
            return *this;
        }
 
        bool isSrgbCapable() const { return _srgbCapable; }
 
        GLConfig& setSrgbCapable(bool enabled) {
            _srgbCapable = enabled;
            return *this;
        }
 
 
    private:
        iVector4 _colorBufferSize;
        std::int32_t _depthBufferSize, _stencilBufferSize;
        std::int32_t _sampleCount;
        std::int32_t _version;
        Flags _flags;
        bool _srgbCapable;
    };
 
    HRESULT initSimConfigFromFile(Simulator::Config &conf);
 
    CAPI_FUNC(HRESULT) universe_init(const UniverseConfig &conf);
 
    CAPI_FUNC(HRESULT) modules_init();
 
 
    namespace io {
 
        template <>
        HRESULT toFile(const Simulator &dataElement, const MetaData &metaData, IOElement &fileElement);
 
        template <>
        HRESULT fromFile(const IOElement &fileElement, const MetaData &metaData, Simulator::Config *dataElement);
 
    }
 
};
 
#endif // _SOURCE_TFSIMULATOR_H_