add SPARQ linux port to main repo

.gitignore

@@ -3,4 +3,5 @@ imgui.ini
 *.zip
 *.o
 *.exe
-*.csv
+*.csv
+SPARQ

.gitmodules

@@ -4,3 +4,6 @@
 [submodule "src/ImStyles"]
 	path = src/ImStyles
 	url = https://github.com/vtx22/ImStyles.git
+[submodule "src/cpp-serial-lin"]
+	path = src/cpp-serial-lin
+	url = https://github.com/vtx22/cpp-serial-lin.git

src/ImGuiNotify.hpp

@@ -40,7 +40,7 @@
 #define NOTIFY_RENDER_LIMIT 5           // Max number of toasts rendered at the same time. Set to 0 for unlimited
 
 // Warning: Requires ImGui docking with multi-viewport enabled
-#define NOTIFY_RENDER_OUTSIDE_MAIN_WINDOW true // If true, the notifications will be rendered in the corner of the monitor, otherwise in the corner of the main window
+#define NOTIFY_RENDER_OUTSIDE_MAIN_WINDOW false // If true, the notifications will be rendered in the corner of the monitor, otherwise in the corner of the main window
 
 /**
  * CONFIGURATION SECTION End

src/Makefile

@@ -1,23 +1,40 @@
 NAME := SPARQ
 
 CCX = g++ 
-CFLAGS = -Wall -std=c++17 -DIMGUI_SFML_VIEWPORTS_ENABLE -DSFML_STATIC -DSFML_USE_STATIC_STD_LIBS
-LIBS = -lsfml-graphics-s -lsfml-window-s -lsfml-system-s -static-libstdc++ -static-libgcc -lwinmm -lopengl32 -lgdi32 -lfreetype -ldwmapi --static
-# Directories
-INCLUDE_DIRS = -I. -I./imgui-sfml/ -I./imgui/ -I./implot/ -I./sfml/include/ -I./ImStyles/ -I./cpp-serial-win/src
-SFML_LIB_DIR = -Lsfml/lib -Limgui-sfml/ -Limgui/ -Limplot/ -LImStyles/ -Lcpp-serial-win/ SPARQ.res
+CFLAGS = -Wall -std=c++17 
 
-# Source and object files
 OWN_SRC_FILES = $(wildcard ./*.cpp)
-EXT_SRC_FILES = $(wildcard imgui/*.cpp imgui-sfml/*.cpp implot/*.cpp ImStyles/*.cpp cpp-serial-win/src/*.cpp)
+EXT_SRC_FILES = $(wildcard imgui/*.cpp imgui-sfml/*.cpp implot/*.cpp ImStyles/*.cpp)
 
-OWN_OBJ_FILES = $(OWN_SRC_FILES:.cpp=.o)
-EXT_OBJ_FILES = $(EXT_SRC_FILES:.cpp=.o)
-OBJ_FILES = $(OWN_OBJ_FILES) $(EXT_OBJ_FILES)
+INCLUDE_DIRS = -I. -I./imgui-sfml/ -I./imgui/ -I./implot/ -I./ImStyles/
+SFML_LIB_DIR = -Limgui-sfml/ -Limgui/ -Limplot/ -LImStyles/ 
+
+UNAME_S := $(shell uname -s)
+ifeq ($(UNAME_S), Linux)
+	EXT_SRC_FILES += $(wildcard cpp-serial-lin/src/*.cpp)
 
+	CFLGAS += -DBUILD_LINUX
+	LIBS = -lsfml-graphics -lsfml-window -lsfml-system -lGL
+	INCLUDE_DIRS += -I./sfml-linux/include/ -I./cpp-serial-lin/src
+	SFML_LIB_DIR += -Lsfml-linux/lib/ -Lcpp-serial-lin/
+endif
+
+ifeq ($(OS), Windows_NT)
+	EXT_SRC_FILES += $(wildcard cpp-serial-win/src/*.cpp)
+
+	CFLAGS += -DBUILD_WINDOWS -DIMGUI_SFML_VIEWPORTS_ENABLE -DSFML_STATIC -DSFML_USE_STATIC_STD_LIBS
+	LIBS = -lsfml-graphics-s -lsfml-window-s -lsfml-system-s -static-libstdc++ -static-libgcc -lwinmm -lopengl32 -lgdi32 -lfreetype -ldwmapi --static
+	INCLUDE_DIRS += -I./sfml-windows/include/ -I./cpp-serial-win/src
+	SFML_LIB_DIR += -Lsfml-windows/lib/ -Lcpp-serial-win/ SPARQ.res
 ifdef release
     LIBS += -mwindows
 endif
+endif
+
+OWN_OBJ_FILES = $(OWN_SRC_FILES:.cpp=.o)
+EXT_OBJ_FILES = $(EXT_SRC_FILES:.cpp=.o)
+OBJ_FILES = $(OWN_OBJ_FILES) $(EXT_OBJ_FILES)
+
 
 # Build targets
 all: $(NAME)
@@ -32,8 +49,13 @@ $(NAME): $(OBJ_FILES)
 	$(CCX) $(CFLAGS) $(INCLUDE_DIRS) -c $< -o $@
 
 # Clean up object files and binary
+
 clean:
-	del /Q $(subst /,\,$(OWN_OBJ_FILES))
+ifeq ($(OS), Windows_NT)
+	del /Q $(subst /,\,$(OBJ_FILES))
+else
+	rm -f $(OBJ_FILES) $(NAME)
+endif
 
 clean_all:
 	del /Q $(subst /,\,$(OBJ_FILES))

src/main.cpp

@@ -1,4 +1,4 @@
-#include "SPARQ.hpp"
+#include "sparq.hpp"
 
 int main()
 {

src/run_linux.sh

@@ -0,0 +1,4 @@
+ #!/usr/bin/env bash
+
+chmod +x SPARQ
+export LD_LIBRARY_PATH=./sfml-linux/lib/ && ./SPARQ

src/sfml-linux/include/SFML/Graphics/RenderWindow.hpp

@@ -0,0 +1,291 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org)
+//
+// This software is provided 'as-is', without any express or implied warranty.
+// In no event will the authors be held liable for any damages arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it freely,
+// subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented;
+//    you must not claim that you wrote the original software.
+//    If you use this software in a product, an acknowledgment
+//    in the product documentation would be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such,
+//    and must not be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source distribution.
+//
+////////////////////////////////////////////////////////////
+
+#ifndef SFML_RENDERWINDOW_HPP
+#define SFML_RENDERWINDOW_HPP
+
+////////////////////////////////////////////////////////////
+// Headers
+////////////////////////////////////////////////////////////
+#include <SFML/Graphics/Export.hpp>
+#include <SFML/Graphics/RenderTarget.hpp>
+#include <SFML/Graphics/Image.hpp>
+#include <SFML/Window/Window.hpp>
+#include <string>
+
+
+namespace sf
+{
+////////////////////////////////////////////////////////////
+/// \brief Window that can serve as a target for 2D drawing
+///
+////////////////////////////////////////////////////////////
+class SFML_GRAPHICS_API RenderWindow : public Window, public RenderTarget
+{
+public:
+
+    ////////////////////////////////////////////////////////////
+    /// \brief Default constructor
+    ///
+    /// This constructor doesn't actually create the window,
+    /// use the other constructors or call create() to do so.
+    ///
+    ////////////////////////////////////////////////////////////
+    RenderWindow();
+
+    ////////////////////////////////////////////////////////////
+    /// \brief Construct a new window
+    ///
+    /// This constructor creates the window with the size and pixel
+    /// depth defined in \a mode. An optional style can be passed to
+    /// customize the look and behavior of the window (borders,
+    /// title bar, resizable, closable, ...).
+    ///
+    /// The fourth parameter is an optional structure specifying
+    /// advanced OpenGL context settings such as antialiasing,
+    /// depth-buffer bits, etc. You shouldn't care about these
+    /// parameters for a regular usage of the graphics module.
+    ///
+    /// \param mode     Video mode to use (defines the width, height and depth of the rendering area of the window)
+    /// \param title    Title of the window
+    /// \param style    %Window style, a bitwise OR combination of sf::Style enumerators
+    /// \param settings Additional settings for the underlying OpenGL context
+    ///
+    ////////////////////////////////////////////////////////////
+    RenderWindow(VideoMode mode, const String& title, Uint32 style = Style::Default, const ContextSettings& settings = ContextSettings());
+
+    ////////////////////////////////////////////////////////////
+    /// \brief Construct the window from an existing control
+    ///
+    /// Use this constructor if you want to create an SFML
+    /// rendering area into an already existing control.
+    ///
+    /// The second parameter is an optional structure specifying
+    /// advanced OpenGL context settings such as antialiasing,
+    /// depth-buffer bits, etc. You shouldn't care about these
+    /// parameters for a regular usage of the graphics module.
+    ///
+    /// \param handle   Platform-specific handle of the control (\a HWND on
+    ///                 Windows, \a %Window on Linux/FreeBSD, \a NSWindow on OS X)
+    /// \param settings Additional settings for the underlying OpenGL context
+    ///
+    ////////////////////////////////////////////////////////////
+    explicit RenderWindow(WindowHandle handle, const ContextSettings& settings = ContextSettings());
+
+    ////////////////////////////////////////////////////////////
+    /// \brief Destructor
+    ///
+    /// Closes the window and frees all the resources attached to it.
+    ///
+    ////////////////////////////////////////////////////////////
+    virtual ~RenderWindow();
+
+    ////////////////////////////////////////////////////////////
+    /// \brief Get the size of the rendering region of the window
+    ///
+    /// The size doesn't include the titlebar and borders
+    /// of the window.
+    ///
+    /// \return Size in pixels
+    ///
+    ////////////////////////////////////////////////////////////
+    virtual Vector2u getSize() const;
+
+    ////////////////////////////////////////////////////////////
+    /// \brief Activate or deactivate the window as the current target
+    ///        for OpenGL rendering
+    ///
+    /// A window is active only on the current thread, if you want to
+    /// make it active on another thread you have to deactivate it
+    /// on the previous thread first if it was active.
+    /// Only one window can be active on a thread at a time, thus
+    /// the window previously active (if any) automatically gets deactivated.
+    /// This is not to be confused with requestFocus().
+    ///
+    /// \param active True to activate, false to deactivate
+    ///
+    /// \return True if operation was successful, false otherwise
+    ///
+    ////////////////////////////////////////////////////////////
+    bool setActive(bool active = true);
+
+    ////////////////////////////////////////////////////////////
+    /// \brief Copy the current contents of the window to an image
+    ///
+    /// \deprecated
+    /// Use a sf::Texture and its sf::Texture::update(const Window&)
+    /// function and copy its contents into an sf::Image instead.
+    /// \code
+    /// sf::Vector2u windowSize = window.getSize();
+    /// sf::Texture texture;
+    /// texture.create(windowSize.x, windowSize.y);
+    /// texture.update(window);
+    /// sf::Image screenshot = texture.copyToImage();
+    /// \endcode
+    ///
+    /// This is a slow operation, whose main purpose is to make
+    /// screenshots of the application. If you want to update an
+    /// image with the contents of the window and then use it for
+    /// drawing, you should rather use a sf::Texture and its
+    /// update(Window&) function.
+    /// You can also draw things directly to a texture with the
+    /// sf::RenderTexture class.
+    ///
+    /// \return Image containing the captured contents
+    ///
+    ////////////////////////////////////////////////////////////
+    SFML_DEPRECATED Image capture() const;
+
+protected:
+
+    ////////////////////////////////////////////////////////////
+    /// \brief Function called after the window has been created
+    ///
+    /// This function is called so that derived classes can
+    /// perform their own specific initialization as soon as
+    /// the window is created.
+    ///
+    ////////////////////////////////////////////////////////////
+    virtual void onCreate();
+
+    ////////////////////////////////////////////////////////////
+    /// \brief Function called after the window has been resized
+    ///
+    /// This function is called so that derived classes can
+    /// perform custom actions when the size of the window changes.
+    ///
+    ////////////////////////////////////////////////////////////
+    virtual void onResize();
+
+private:
+
+    ////////////////////////////////////////////////////////////
+    // Member data
+    ////////////////////////////////////////////////////////////
+    unsigned int m_defaultFrameBuffer; ///< Framebuffer to bind when targeting this window
+};
+
+} // namespace sf
+
+
+#endif // SFML_RENDERWINDOW_HPP
+
+
+////////////////////////////////////////////////////////////
+/// \class sf::RenderWindow
+/// \ingroup graphics
+///
+/// sf::RenderWindow is the main class of the Graphics module.
+/// It defines an OS window that can be painted using the other
+/// classes of the graphics module.
+///
+/// sf::RenderWindow is derived from sf::Window, thus it inherits
+/// all its features: events, window management, OpenGL rendering,
+/// etc. See the documentation of sf::Window for a more complete
+/// description of all these features, as well as code examples.
+///
+/// On top of that, sf::RenderWindow adds more features related to
+/// 2D drawing with the graphics module (see its base class
+/// sf::RenderTarget for more details).
+/// Here is a typical rendering and event loop with a sf::RenderWindow:
+///
+/// \code
+/// // Declare and create a new render-window
+/// sf::RenderWindow window(sf::VideoMode(800, 600), "SFML window");
+///
+/// // Limit the framerate to 60 frames per second (this step is optional)
+/// window.setFramerateLimit(60);
+///
+/// // The main loop - ends as soon as the window is closed
+/// while (window.isOpen())
+/// {
+///    // Event processing
+///    sf::Event event;
+///    while (window.pollEvent(event))
+///    {
+///        // Request for closing the window
+///        if (event.type == sf::Event::Closed)
+///            window.close();
+///    }
+///
+///    // Clear the whole window before rendering a new frame
+///    window.clear();
+///
+///    // Draw some graphical entities
+///    window.draw(sprite);
+///    window.draw(circle);
+///    window.draw(text);
+///
+///    // End the current frame and display its contents on screen
+///    window.display();
+/// }
+/// \endcode
+///
+/// Like sf::Window, sf::RenderWindow is still able to render direct
+/// OpenGL stuff. It is even possible to mix together OpenGL calls
+/// and regular SFML drawing commands.
+///
+/// \code
+/// // Create the render window
+/// sf::RenderWindow window(sf::VideoMode(800, 600), "SFML OpenGL");
+///
+/// // Create a sprite and a text to display
+/// sf::Sprite sprite;
+/// sf::Text text;
+/// ...
+///
+/// // Perform OpenGL initializations
+/// glMatrixMode(GL_PROJECTION);
+/// ...
+///
+/// // Start the rendering loop
+/// while (window.isOpen())
+/// {
+///     // Process events
+///     ...
+///
+///     // Draw a background sprite
+///     window.pushGLStates();
+///     window.draw(sprite);
+///     window.popGLStates();
+///
+///     // Draw a 3D object using OpenGL
+///     glBegin(GL_QUADS);
+///         glVertex3f(...);
+///         ...
+///     glEnd();
+///
+///     // Draw text on top of the 3D object
+///     window.pushGLStates();
+///     window.draw(text);
+///     window.popGLStates();
+///
+///     // Finally, display the rendered frame on screen
+///     window.display();
+/// }
+/// \endcode
+///
+/// \see sf::Window, sf::RenderTarget, sf::RenderTexture, sf::View
+///
+////////////////////////////////////////////////////////////