ApplicationBase.hh

#ifndef VTESTBED_GUI_APPLICATIONBASE_HH
#define VTESTBED_GUI_APPLICATIONBASE_HH

#include <vtestbed/config/opencl.hh>
#include <vtestbed/core/macros.hh>
#include <vtestbed/core/policy.hh>
#include <vtestbed/gui/MagnumImgui/MagnumImGui.h>
#include <vtestbed/gui/types.hh>
#include <vtestbed/ini/ini_settings.hh>

#if defined(VTB_WITH_OPENCL)
#include <vtestbed/opencl/opencl.hh>
#endif

VTB_WARNING_IGNORE_PUSH("-Wnon-virtual-dtor")

namespace vtb {

    namespace gui {

        class ApplicationBase: public Application {

        public:
            using Policy = vtb::core::Policy;
            using settings_type = vtb::ini::Ini_settings;
            #if defined(VTB_WITH_OPENCL)
            using opencl_context_type = vtb::opencl::Context;
            #endif

        private:
            settings_type _settings, _colors;
            #if defined(VTB_WITH_OPENCL)
            opencl_context_type _opencl_context;
            #endif
            Scene3D _scene;
            Object3D* _cameraObject;
            Camera3D* _camera;
            Float _cameraTranslationDelta{10.f};
            Float _cameraDistanceToObject{200.f};
            Vector2i _previousMousePosition;
            Policy _policy = Policy::OpenMP;

        public:
            ApplicationBase(const Arguments& args, const Configuration& conf);
            virtual ~ApplicationBase() {}

            inline settings_type* settings_ptr() { return &this->_settings; }
            inline settings_type* colors_ptr() { return &this->_colors; }
            inline const settings_type& settings() const { return this->_settings; }
            inline settings_type& settings() { return this->_settings; }
            inline Policy policy() const { return this->_policy; }
            #if defined(VTB_WITH_OPENCL)
            inline opencl_context_type* opencl_context() { return &this->_opencl_context; }
            inline const opencl_context_type* opencl_context() const { return &this->_opencl_context; }
            #endif

        private:
            void initSettings();
            void initLocale();
            void initOpenGL(const Configuration& conf);
            void initSharing();
            void initOpenCL();
            void initCamera();
            void resetCamera();
            void cameraTranslation(KeyEvent& event);
            void cameraRotation(MouseMoveEvent& event);

        protected:

            void initImGui(MagnumImGui& imgui);
            void enableDebugOutput();
            inline Scene3D* scene() { return &this->_scene; }
            inline const Scene3D* scene() const { return &this->_scene; }
            inline Camera3D* camera() { return this->_camera; }
            inline const Camera3D* camera() const { return this->_camera; }
            inline Object3D* cameraObject() { return this->_cameraObject; }
            inline const Object3D* cameraObject() const { return this->_cameraObject; }

            inline void
            setCameraTranslationDelta(Float rhs) {
                this->_cameraTranslationDelta = rhs;
            }

            void viewportEvent(const Vector2i& size) override;
            void keyPressEvent(KeyEvent& event) override;
            void mouseMoveEvent(MouseMoveEvent& event) override;

            inline void
            mousePressEvent(MouseEvent& event) override {
                this->_previousMousePosition = event.position();
            }

            inline void keyReleaseEvent(KeyEvent& event) override {}
            inline void mouseReleaseEvent(MouseEvent& event) override {}
            inline void mouseScrollEvent(MouseScrollEvent& event) override {}
            inline void textInputEvent(TextInputEvent& event) override {}

        };

    }

}

VTB_WARNING_POP

#endif // vim:filetype=cpp