WIP Replace SFML with Raylib

Need to fix Raygui usage in helpers.hpp.
Need to fix triangles being drawn flipped over the x-axis.

.gitmodules

@@ -1,6 +1,6 @@
-[submodule "third_party/imgui"]
+[submodule "third_party/raygui"]
-	path = third_party/imgui
+	path = third_party/raygui
-	url = https://github.com/ocornut/imgui.git
+	url = https://github.com/raysan5/raygui.git
-[submodule "third_party/imgui-sfml"]
+[submodule "third_party/glm"]
-	path = third_party/imgui-sfml
+	path = third_party/glm
-	url = https://github.com/eliasdaler/imgui-sfml.git
+	url = https://github.com/g-truc/glm.git

CMakeLists.txt

@@ -1,14 +1,14 @@
-cmake_minimum_required(VERSION 3.0)
+cmake_minimum_required(VERSION 3.8.2)
 project(Triangles LANGUAGES CXX VERSION 1.0)
 
-if(NOT EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/third_party/imgui/imgui.h)
+if(NOT EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/third_party/glm/glm/glm.hpp)
-    message(FATAL_ERROR "third_party/imgui/imgui.h is missing!\n \
+    message(FATAL_ERROR "third_party/glm/glm/glm.hpp is missing!\n \
-Please update the GameDevTools submodule by running 'git submodule init' and \
+Please update the glm submodule by running 'git submodule init' and \
 'git submodule update'!")
 endif()
-if(NOT EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/third_party/imgui-sfml/imgui-SFML.h)
+if(NOT EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/third_party/raygui/src/raygui.h)
-    message(FATAL_ERROR "third_party/imgui-sfml/imgui-SFML.h is missing!\n \
+    message(FATAL_ERROR "third_party/raygui/src/raygui.h is missing!\n \
-Please update the GameDevTools submodule by running 'git submodule init' and \
+Please update the raygui submodule by running 'git submodule init' and \
 'git submodule update'!")
 endif()
 
@@ -16,22 +16,16 @@ if(NOT DEFINED CMAKE_BUILD_TYPE)
     set(CMAKE_BUILD_TYPE "Debug")
 endif()
 
-if(CMAKE_BUILD_TYPE MATCHES "Debug")
-    set(ImGuiDemo "third_party/imgui/imgui_demo.cpp")
-else()
-    set(ImGuiDemo "")
-endif()
-
 set(Triangles_MAIN_SOURCES
     src/main.cpp
 )
 
 set(Triangles_LIB_SOURCES
     src/state.cpp
-    third_party/imgui/imgui.cpp
+    src/shape.cpp
-    third_party/imgui/imgui_draw.cpp
+    src/triangle.cpp
-    third_party/imgui/imgui_widgets.cpp
+    src/circle.cpp
-    third_party/imgui-sfml/imgui-SFML.cpp
+    src/raygui.cpp
 )
 
 if(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
@@ -57,44 +51,28 @@ target_link_libraries(Triangles PUBLIC TrianglesLib)
 target_compile_features(TrianglesLib PUBLIC cxx_std_17)
 
 if(BUILD_SHARED_LIBS OR (UNIX AND NOT CYGWIN) OR (CMAKE_CXX_COMPILER_ID MATCHES "MSVC"))
-    find_package(SFML 2 REQUIRED
+    find_package(raylib REQUIRED)
-        COMPONENTS audio network graphics window system)
 else()
-    find_package(SFML 2 REQUIRED
+    find_package(raylib REQUIRED)
-        COMPONENTS audio-s network-s graphics-s window-s system-s)
-    add_definitions(-DSFML_STATIC)
 endif()
 
 if(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
 target_link_libraries(TrianglesLib PUBLIC
-    sfml-graphics sfml-window sfml-system
+    raylib
     opengl32
 )
 else()
 target_link_libraries(TrianglesLib PUBLIC
-    sfml-graphics sfml-window sfml-system
+    raylib
     GL
 )
 endif()
 
-if(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
 target_include_directories(TrianglesLib PUBLIC
     ${CMAKE_CURRENT_SOURCE_DIR}/src
-        ${SFML_INCLUDE_DIR}
+    ${CMAKE_CURRENT_SOURCE_DIR}/third_party/raygui/src
-        ${CMAKE_CURRENT_SOURCE_DIR}/third_party/imgui # imgui related headers
+    ${CMAKE_CURRENT_SOURCE_DIR}/third_party/glm
-        ${CMAKE_CURRENT_SOURCE_DIR}/third_party/imgui-sfml # imgui-sfml related headers
 )
-else()
-    target_include_directories(TrianglesLib PUBLIC
-        ${CMAKE_CURRENT_SOURCE_DIR}/src
-        ${SFML_INCLUDE_DIR}
-        ${CMAKE_CURRENT_SOURCE_DIR}/build_include # imgui related headers
-    )
-endif()
-
-# Use macro to override imgui config header
-target_compile_definitions(TrianglesLib PUBLIC
-    "IMGUI_USER_CONFIG=\"${CMAKE_CURRENT_SOURCE_DIR}/third_party/imgui-sfml/imconfig-SFML.h\"")
 
 if(CMAKE_BUILD_TYPE MATCHES "Debug")
     set(Triangles_UNIT_TEST_SOURCES

build_include/imconfig.h

@@ -1 +0,0 @@
-../third_party/imgui-sfml/imconfig-SFML.h

build_include/imgui-SFML.h

@@ -1 +0,0 @@
-../third_party/imgui-sfml/imgui-SFML.h

build_include/imgui-SFML_export.h

@@ -1 +0,0 @@
-../third_party/imgui-sfml/imgui-SFML_export.h

build_include/imgui.h

@@ -1 +0,0 @@
-../third_party/imgui/imgui.h

build_include/imgui_internal.h

@@ -1 +0,0 @@
-../third_party/imgui/imgui_internal.h

build_include/imstb_rectpack.h

@@ -1 +0,0 @@
-../third_party/imgui/imstb_rectpack.h

build_include/imstb_textedit.h

@@ -1 +0,0 @@
-../third_party/imgui/imstb_textedit.h

build_include/imstb_truetype.h

@@ -1 +0,0 @@
-../third_party/imgui/imstb_truetype.h

src/circle.cpp

@@ -0,0 +1,60 @@
+#include "circle.hpp"
+
+#include <cmath>
+
+Tri::Circle::Circle() :
+Shape(),
+position{0.0f, 0.0f},
+radius(4.0f)
+{}
+
+Tri::Circle::Circle(glm::vec2 pos) :
+Shape(),
+position(pos),
+radius(4.0f)
+{}
+
+Tri::Circle::Circle(glm::vec2 pos, float radius) :
+Shape(),
+position(pos),
+radius(radius)
+{}
+
+Tri::Circle::Circle(glm::vec2 pos, float radius, Color fillColor) :
+Shape(fillColor),
+position(pos),
+radius(radius)
+{}
+
+Tri::Circle::Circle(glm::vec2 pos, float radius, Color fillColor, Color outlineColor) :
+Shape(fillColor, outlineColor),
+position(pos),
+radius(radius)
+{}
+
+Tri::Shape& Tri::Circle::draw() {
+    glm::vec2 transformed = transform * glm::vec3(position.x, position.y, 1.0f);
+    transformed.x = std::roundf(transformed.x);
+    transformed.y = std::roundf(transformed.y);
+    DrawCircle(transformed.x, transformed.y, radius, fillColor);
+    DrawCircleLines(transformed.x, transformed.y, radius, outlineColor);
+    return *this;
+}
+
+void Tri::Circle::getVertices(std::vector<glm::vec2> &verticesOut) const {
+    verticesOut.clear();
+    verticesOut.push_back(position);
+}
+
+void Tri::Circle::getTransformedVertices(std::vector<glm::vec2> &verticesOut) const {
+    verticesOut.clear();
+    verticesOut.push_back(transform * glm::vec3{position.x, position.y, 1.0f});
+}
+
+float Tri::Circle::getRadius() const {
+    return radius;
+}
+
+void Tri::Circle::setRadius(float radius) {
+    this->radius = radius;
+}

src/circle.hpp

@@ -0,0 +1,29 @@
+#ifndef TRIANGLES_CIRCLE_HPP
+#define TRIANGLES_CIRCLE_HPP
+
+#include "shape.hpp"
+
+namespace Tri {
+
+struct Circle : public Shape {
+    Circle();
+    Circle(glm::vec2 pos);
+    Circle(glm::vec2 pos, float radius);
+    Circle(glm::vec2 pos, float radius, Color fillColor);
+    Circle(glm::vec2 pos, float radius, Color fillColor, Color outlineColor);
+
+    glm::vec2 position;
+    float radius;
+
+    virtual Shape& draw() override;
+
+    virtual void getVertices(std::vector<glm::vec2> &verticesOut) const override;
+    virtual void getTransformedVertices(std::vector<glm::vec2> &verticesOut) const override;
+
+    virtual float getRadius() const override;
+    virtual void setRadius(float radius) override;
+}; // struct Circle
+
+} // namespace Tri
+
+#endif

src/helpers.hpp

@@ -3,9 +3,12 @@
 
 #include <cmath>
 #include <optional>
+#include <cassert>
 
-#include <imgui.h>
+#include <raylib.h>
+#include <raygui.h>
 
+#include "shape.hpp"
 #include "state.hpp"
 
 #define SHOW_HELP_WIDTH (state->get_width() / 2.0f)
@@ -20,126 +23,193 @@ namespace Tri {
     // so this should be called during update, not draw
     inline void draw_help(Tri::State *state) {
         if(state->get_flags().test(Tri::State::F_DISPLAY_HELP)) {
-            ImGui::SetNextWindowPos(sf::Vector2f(10.0f, 10.0f));
+            GuiFade(1.0f);
-            ImGui::SetNextWindowSize(sf::Vector2f(
+            if(!GuiWindowBox({10.0f,
-                state->get_width() - 20.0f,
+                             10.0f,
-                state->get_height() - 20.0f));
+                             800.0f - 20.0f,
-            ImGui::SetNextWindowBgAlpha(0.7f);
+                             600.0f - 20.0f},
-            ImGui::Begin("Help Window", nullptr, ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoSavedSettings);
+                             "Help")) {
-            ImGui::Text("This is the help window - Press \"H\" to toggle this window");
+                GuiLabel(
-            ImGui::Text("Click anywhere to create triangles, one point at a time");
+                    {4.0f, 4.0f, 800.0f - 28.0f, 16.0f},
-            ImGui::Text("You cannot draw when a window is open");
+                    "This is the help window - Press \"H\" to toggle this window");
-            ImGui::Text("Press \"U\" to undo. Clicking will remove all future undo history");
+                GuiLabel(
-            ImGui::Text("Press \"R\" to redo.");
+                    {4.0f, 22.0f, 800.0f - 28.0f, 16.0f},
-            ImGui::Text("Press \"C\" to change colors");
+                    "Click anywhere to create triangles, one point at a time");
-            ImGui::Text("Press \"B\" to change background color");
+                GuiLabel(
-            ImGui::Text("Press \"P\" to set current color to a color on screen");
+                    {4.0f, 40.0f, 800.0f - 28.0f, 16.0f},
-            ImGui::Text("Press \"S\" to save what was drawn as a png image");
+                    "You cannot draw when a window is open");
-            if(ImGui::Button("Close")) {
+                GuiLabel(
+                    {4.0f, 58.0f, 800.0f - 28.0f, 16.0f},
+                    "Press \"U\" to undo. Clicking will remove all future undo history");
+                GuiLabel(
+                    {4.0f, 76.0f, 800.0f - 28.0f, 16.0f},
+                    "Press \"R\" to redo.");
+                GuiLabel(
+                    {4.0f, 94.0f, 800.0f - 28.0f, 16.0f},
+                    "Press \"C\" to change colors");
+                GuiLabel(
+                    {4.0f, 112.0f, 800.0f - 28.0f, 16.0f},
+                    "Press \"B\" to change background color");
+                GuiLabel(
+                    {4.0f, 130.0f, 800.0f - 28.0f, 16.0f},
+                    "Press \"P\" to set current color to a color on screen");
+                GuiLabel(
+                    {4.0f, 148.0f, 800.0f - 28.0f, 16.0f},
+                    "Press \"S\" to save what was drawn as a png image");
+                if(GuiButton({4.0f, 168.0f, 100.0f, 16.0f}, "Close")) {
+                    state->close_help();
+                }
+            } else {
                 state->close_help();
             }
-            ImGui::End();
         }
     }
 
     inline void draw_notification(Tri::State *state) {
         float alpha = state->get_notification_alpha();
         if(alpha > 0.0f) {
-            ImGui::PushStyleVar(ImGuiStyleVar_Alpha, alpha);
+            GuiFade(alpha);
-
+            GuiPanel({(800 - SHOW_HELP_WIDTH) / 2.0f,
-            ImGui::SetNextWindowPos(sf::Vector2f(
+                          (600 - SHOW_HELP_HEIGHT) / 2.0f,
-                (state->get_width() - SHOW_HELP_WIDTH) / 2.0f,
-                (state->get_height() - SHOW_HELP_HEIGHT) / 2.0f));
-            ImGui::SetNextWindowSize(sf::Vector2f(
                           SHOW_HELP_WIDTH,
-                SHOW_HELP_HEIGHT));
+                          SHOW_HELP_HEIGHT});
-            ImGui::Begin(
+            GuiLabel({4.0f, 4.0f, SHOW_HELP_WIDTH - 8.0f, SHOW_HELP_HEIGHT - 8.0f},
-                "Notification Window",
+                     state->get_notification_text());
-                nullptr,
-                ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoSavedSettings);
-            ImGui::SetWindowFontScale(3.0f);
-            ImGui::Text("%s", state->get_notification_text());
-            ImGui::End();
-
-            ImGui::PopStyleVar();
         }
     }
 
     inline void draw_color_picker(Tri::State *state) {
         if(state->get_flags().test(Tri::State::F_DISPLAY_COLOR_P)) {
-            ImGui::Begin("Tri Color Picker");
+            GuiFade(1.0f);
-            ImGui::ColorPicker4("Tri Color", state->get_color());
+            if(!GuiWindowBox({4.0f, 4.0f, 242.0f, 292.0f}, "Tri Color Picker")) {
-            if(ImGui::Button("Close")) {
+                auto &colorArray = state->get_color();
+                Color color = GuiColorPicker(
+                    {4.0f, 4.0f, 234.0f, 264.0f},
+                    {(unsigned char)(colorArray[0] * 255.0f),
+                     (unsigned char)(colorArray[1] * 255.0f),
+                     (unsigned char)(colorArray[2] * 255.0f),
+                     (unsigned char)(colorArray[3] * 255.0f)});
+                colorArray = {
+                    color.r / 255.0f,
+                    color.g / 255.0f,
+                    color.b / 255.0f,
+                    color.a / 255.0f
+                };
+                if(GuiButton({4.0f, 268.0f, 234.0f, 16.0f}, "Close")) {
+                    state->close_color_picker();
+                }
+            } else {
                 state->close_color_picker();
             }
-            ImGui::End();
         }
     }
 
     inline void draw_bg_color_picker(Tri::State *state) {
         if(state->get_flags().test(Tri::State::F_DISPLAY_BG_COLOR_P)) {
-            ImGui::Begin("BG Color Picker");
+            GuiFade(1.0f);
-            ImGui::ColorPicker3("BG Color", state->get_bg_color());
+            if(!GuiWindowBox({250.0f, 4.0f, 242.0f, 292.0f}, "BG Color Picker")) {
-            if(ImGui::Button("Close")) {
+                auto &colorArray = state->get_bg_color();
+                Color color = GuiColorPicker(
+                    {4.0f, 4.0f, 234.0f, 264.0f},
+                    {(unsigned char)(colorArray[0] * 255.0f),
+                     (unsigned char)(colorArray[1] * 255.0f),
+                     (unsigned char)(colorArray[2] * 255.0f),
+                     255});
+                colorArray = {
+                    color.r / 255.0f,
+                    color.g / 255.0f,
+                    color.b / 255.0f
+                };
+                if(GuiButton({4.0f, 268.0f, 234.0f, 16.0f}, "Close")) {
+                    state->close_bg_color_picker();
+                }
+            } else {
                 state->close_bg_color_picker();
             }
-            ImGui::End();
         }
     }
 
     inline void draw_save(Tri::State *state) {
         if(state->get_flags().test(Tri::State::F_DISPLAY_SAVE)) {
             auto *filenameBuffer = state->get_save_filename_buffer();
-            ImGui::Begin("Save");
+            GuiFade(1.0f);
-            ImGui::InputText("Filename", filenameBuffer->data(), filenameBuffer->size() - 1);
+            if(!GuiWindowBox({4.0f, 300.0f, 292.0f, 292.0f}, "Save")) {
-            if(ImGui::Button("Save")) {
+                GuiTextBox(
+                    {4.0f, 4.0f, 284.0f, 150.0f},
+                    filenameBuffer->data(),
+                    filenameBuffer->size() - 1,
+                    true);
+                if(GuiButton({4.0f, 158.0f, 50.0f, 16.0f}, "Save")) {
                     if(state->do_save()) {
                         state->close_save();
                     }
-            } else if(ImGui::Button("Cancel")) {
+                }
+                const std::string &string = state->failed_message();
+                if(!string.empty()) {
+                    GuiLabel({4.0f, 178.0f, 284.0f, 16.0f}, string.c_str());
+                }
+            } else {
                 state->close_save();
             }
-            auto string_view = state->failed_message();
-            if(!string_view.empty()) {
-                ImGui::TextUnformatted(string_view.data(), string_view.data() + string_view.size());
-            }
-            ImGui::End();
         }
     }
 
     inline void draw_change_size(Tri::State *state) {
         if(state->get_flags().test(Tri::State::F_DISPLAY_CHANGE_SIZE)) {
-            ImGui::Begin("ChangeSize");
+            GuiFade(1.0f);
-            ImGui::InputInt2("Width and Height", state->get_input_width_height());
+            if(!GuiWindowBox({300.0f, 300.0f, 292.0f, 292.0f}, "Change Size")) {
-            auto string_view = state->failed_message();
+                GuiValueBox(
-            if(!string_view.empty()) {
+                        {4.0f, 4.0f, 80.0f, 16.0f},
-                ImGui::TextUnformatted(string_view.data(), string_view.data() + string_view.size());
+                        "Width",
+                        state->get_input_width(),
+                        800,
+                        1920,
+                        true);
+                GuiValueBox(
+                        {4.0f, 24.0f, 80.0f, 16.0f},
+                        "Height",
+                        state->get_input_height(),
+                        600,
+                        1080,
+                        true);
+                const std::string &failMessage = state->failed_message();
+                if(!failMessage.empty()) {
+                    GuiLabel({4.0f, 44.0f, 284.0f, 16.0f}, failMessage.c_str());
                 }
-            if(ImGui::Button("Cancel")) {
+                if(GuiButton({4.0f, 70.0f, 70.0f, 16.0f}, "Cancel")) {
                     state->close_input_width_height_window();
                 }
-            if(ImGui::Button("Set")) {
+                if(GuiButton({58.0f, 70.0f, 50.0f, 16.0f}, "Set")) {
                     if(state->change_width_height()) {
                         state->close_input_width_height_window();
                     }
                 }
-            ImGui::End();
+            } else {
+                state->close_input_width_height_window();
+            }
         }
     }
 
     inline bool is_within_shape(
-            const sf::ConvexShape &shape,
+            const Tri::Shape &shape,
-            sf::Vector2f xy) {
+            glm::vec2 xy) {
+        float radius = shape.getRadius();
+        std::vector<glm::vec2> vertices;
+        shape.getTransformedVertices(vertices);
+        if(radius > 0.0f) {
+            assert(vertices.size() == 1);
+
+            xy = xy - vertices[0];
+            return std::sqrt(xy.x * xy.x + xy.y * xy.y) <= radius;
+        } else {
+            assert(vertices.size() > 2);
+
             std::optional<bool> is_right;
-        sf::Transform t = shape.getTransform();
+            for(unsigned int i = 0; i < vertices.size(); ++i) {
-        for(unsigned int i = 0; i < shape.getPointCount(); ++i) {
+                glm::vec2 t_a, t_b;
-            sf::Vector2f t_a = t.transformPoint(shape.getPoint(i));
+                t_b = vertices[(i + 1) % vertices.size()] - vertices[i];
-            sf::Vector2f t_b = t.transformPoint(shape.getPoint((i + 1) % shape.getPointCount()));
+                t_a = xy - vertices[i];
 
-            t_b = t_b - t_a;
-            t_a = xy - t_a;
-
-            // TODO
                 // cross product, where z coordinate is 0
                 // Use sign of z value to determine if line is to right or left
                 //
@@ -164,19 +234,54 @@ namespace Tri {
             }
             return true;
         }
+    }
 
-    inline sf::Color invert_color(const sf::Color &other) {
+    inline Color invert_color(const Color &other) {
-        return sf::Color(255 - other.r, 255 - other.g, 255 - other.b);
+        return Color{
+            (unsigned char)(255 - (int)other.r),
+            (unsigned char)(255 - (int)other.g),
+            (unsigned char)(255 - (int)other.b),
+            other.a};
     }
 
     inline void draw_edit_tri(Tri::State *state) {
         if(state->get_flags().test(Tri::State::F_TRI_EDIT_MODE)) {
-            ImGui::Begin("Edit Tri Color Picker");
+            GuiFade(1.0f);
-            ImGui::ColorPicker4("Tri Color", state->get_selected_tri_color());
+            if(!GuiWindowBox({500.0f, 4.0f, 242.0f, 292.0f}, "Edit Tri Color Picker")) {
-            if(ImGui::Button("Close")) {
+                auto &colorArray = state->get_selected_tri_color();
+                Color color = GuiColorPicker(
+                    {4.0f, 4.0f, 234.0f, 264.0f},
+                    {(unsigned char)(colorArray[0] * 255.0f),
+                     (unsigned char)(colorArray[1] * 255.0f),
+                     (unsigned char)(colorArray[2] * 255.0f),
+                     (unsigned char)(colorArray[3] * 255.0f)});
+                colorArray = {
+                    color.r / 255.0f,
+                    color.g / 255.0f,
+                    color.b / 255.0f,
+                    color.a / 255.0f
+                };
+                if(GuiButton({4.0f, 268.0f, 234.0f, 16.0f}, "Close")) {
                     state->close_selected_tri_mode();
                 }
-            ImGui::End();
+            } else {
+                state->close_selected_tri_mode();
+            }
+        }
+    }
+
+    inline void make_counter_clockwise(std::array<glm::vec2, 3> &tri) {
+        // 2D cross product to get the sign to determine if clockwise
+        glm::vec2 t_a, t_b;
+        t_b = tri[1] - tri[0];
+        t_a = tri[2] - tri[0];
+
+        float z = t_b.x * t_a.y - t_b.y * t_a.x;
+        if(z >= 0.0f) {
+            // is clockwise, swap first with last
+            t_a = tri[0];
+            tri[0] = tri[2];
+            tri[2] = t_a;
         }
     }
 }

src/main.cpp

@@ -1,10 +1,3 @@
-#include <SFML/System.hpp>
-#include <SFML/Window.hpp>
-#include <SFML/Graphics.hpp>
-
-#include <imgui.h>
-#include <imgui-SFML.h>
-
 #include "state.hpp"
 
 #ifdef _MSC_VER

src/raygui.cpp

@@ -0,0 +1,2 @@
+#define RAYGUI_IMPLEMENTATION
+#include <raygui.h>

src/shape.cpp

@@ -0,0 +1,42 @@
+#include "shape.hpp"
+
+#include <glm/ext/matrix_transform.hpp>
+#include <glm/gtx/matrix_transform_2d.hpp>
+
+Tri::Shape::Shape() :
+transform(glm::identity<glm::mat3>()),
+fillColor(RAYWHITE),
+outlineColor(BLACK)
+{}
+
+Tri::Shape::Shape(Color fillColor) :
+transform(glm::identity<glm::mat3>()),
+fillColor(fillColor),
+outlineColor(BLACK)
+{}
+
+Tri::Shape::Shape(Color fillColor, Color outlineColor) :
+transform(glm::identity<glm::mat3>()),
+fillColor(fillColor),
+outlineColor(outlineColor)
+{}
+
+Tri::Shape& Tri::Shape::resetTransform() {
+    transform = glm::identity<glm::mat3>();
+    return *this;
+}
+
+Tri::Shape& Tri::Shape::translate(const glm::vec2 move) {
+    transform = glm::translate(transform, move);
+    return *this;
+}
+
+Tri::Shape& Tri::Shape::rotate(const float angle) {
+    transform = glm::rotate(transform, angle);
+    return *this;
+}
+
+Tri::Shape& Tri::Shape::scale(const glm::vec2 scale) {
+    transform = glm::scale(transform, scale);
+    return *this;
+}

src/shape.hpp

@@ -0,0 +1,37 @@
+#ifndef TRIANGLES_SHAPE_HPP
+#define TRIANGLES_SHAPE_HPP
+
+#include <vector>
+
+#include <raylib.h>
+#include <glm/glm.hpp>
+
+namespace Tri {
+
+struct Shape {
+    Shape();
+    Shape(Color fillColor);
+    Shape(Color fillColor, Color outlineColor);
+    virtual ~Shape() {}
+
+    glm::mat3 transform;
+    Color fillColor;
+    Color outlineColor;
+
+    Shape& resetTransform();
+    Shape& translate(const glm::vec2 move);
+    Shape& rotate(const float angle);
+    Shape& scale(const glm::vec2 scale);
+
+    virtual Shape& draw() = 0;
+
+    virtual void getVertices(std::vector<glm::vec2> &verticesOut) const = 0;
+    virtual void getTransformedVertices(std::vector<glm::vec2> &verticesOut) const = 0;
+
+    virtual float getRadius() const = 0;
+    virtual void setRadius(float radius) = 0;
+}; // struct Shape
+
+} // namespace Tri
+
+#endif

src/state.cpp

@@ -5,7 +5,7 @@
 #include <string>
 #include <cmath>
 
-#include <imgui-SFML.h>
+#include <raylib.h>
 
 #include "helpers.hpp"
 
@@ -18,61 +18,57 @@
 Tri::State::State(int argc, char **argv) :
 width(800),
 height(600),
-dt(sf::microseconds(16666)),
+dt(1.0f/60.0f),
 notification_alpha(1.0f),
-window(sf::VideoMode(800, 600), "Triangles", sf::Style::Titlebar | sf::Style::Close),
 trisIndex(0),
 currentTri_state(CurrentState::NONE),
 currentTri_maxState(CurrentState::NONE),
 colorPickerColor{1.0f, 1.0f, 1.0f, 1.0f},
 bgColorPickerColor{0.0f, 0.0f, 0.0f},
-bgColor(sf::Color::Black),
+bgColor(BLACK),
-inputWidthHeight{800, 600},
+pi(std::acos(-1.0f)),
-pi(std::acos(-1.0f))
+inputWidth(800),
+inputHeight(600)
 {
+    InitWindow(width, height, "Triangles");
+    SetTargetFPS(60);
+
     flags.set(F_IS_RUNNING); // is running
-    ImGui::SFML::Init(window);
-    window.setFramerateLimit(60);
 
     set_notification_text("Press \"H\" for help");
 
     pointCircle.setRadius(7.0f);
-    pointCircle.setOrigin(7.0f, 7.0f);
+    pointCircle.translate({7.0f, 7.0f});
-    pointCircle.setFillColor(sf::Color::White);
+    pointCircle.fillColor = WHITE;
-    pointCircle.setOutlineColor(sf::Color::Black);
+    pointCircle.outlineColor = BLACK;
-    pointCircle.setOutlineThickness(1.0f);
 
     saveFilenameBuffer.fill(0);
 
-    if(!drawCache.create(800, 600)) {
+    drawCache = LoadRenderTexture(width, height);
-#ifndef NDEBUG
-        puts("ERROR: Failed to initialize RenderTexture (draw cache)");
-#endif
-        flags.reset(F_DRAW_CACHE_INITIALIZED);
-    } else {
     flags.set(F_DRAW_CACHE_INITIALIZED);
     flags.set(F_DRAW_CACHE_DIRTY);
-        drawCacheSprite.setTexture(drawCache.getTexture(), true);
+
-    }
+    GuiSetStyle(DEFAULT, BACKGROUND_COLOR, 0x303030);
 }
 
 Tri::State::~State() {
-    window.close();
+    UnloadRenderTexture(drawCache);
-    ImGui::SFML::Shutdown();
+    CloseWindow();
 }
 
 void Tri::State::handle_events() {
-    while(window.pollEvent(event)) {
+    if(WindowShouldClose()) {
-        ImGui::SFML::ProcessEvent(event);
-        if(event.type == sf::Event::Closed) {
-            window.close();
         flags.reset(F_IS_RUNNING);
-        } else if(event.type == sf::Event::KeyPressed) {
+    }
+
+    int keyPressed = GetKeyPressed();
+    while(keyPressed > 0) {
         if(!flags.test(F_DISPLAY_SAVE)) {
-                // TODO use a switch statement
+            switch(keyPressed) {
-                if(event.key.code == sf::Keyboard::H) {
+            case KEY_H:
                 flags.flip(F_DISPLAY_HELP);
-                } else if(event.key.code == sf::Keyboard::U) {
+                break;
+            case KEY_U:
                 flags.set(F_DRAW_CACHE_DIRTY);
                 if(currentTri_state > 0) {
                     switch(currentTri_state) {
@@ -89,7 +85,8 @@ void Tri::State::handle_events() {
                 } else if(trisIndex > 0) {
                     --trisIndex;
                 }
-                } else if(event.key.code == sf::Keyboard::R) {
+                break;
+            case KEY_R:
                 flags.set(F_DRAW_CACHE_DIRTY);
                 if(currentTri_state != CurrentState::NONE
                         && currentTri_state < currentTri_maxState) {
@@ -119,21 +116,25 @@ void Tri::State::handle_events() {
                         break;
                     }
                 }
-                } else if(event.key.code == sf::Keyboard::C) {
+                break;
+            case KEY_C:
                 if(flags.test(F_DISPLAY_COLOR_P)) {
                     close_color_picker();
                 } else {
                     flags.set(F_DISPLAY_COLOR_P);
                 }
-                } else if(event.key.code == sf::Keyboard::B) {
+                break;
+            case KEY_B:
                 if(flags.test(F_DISPLAY_BG_COLOR_P)) {
                     close_bg_color_picker();
                 } else {
                     flags.set(F_DISPLAY_BG_COLOR_P);
                 }
-                } else if(event.key.code == sf::Keyboard::S) {
+                break;
+            case KEY_S:
                 flags.flip(F_DISPLAY_SAVE);
-                } else if(event.key.code == sf::Keyboard::P) {
+                break;
+            case KEY_P:
                 flags.flip(F_COPY_COLOR_MODE);
                 if(flags.test(F_COPY_COLOR_MODE)) {
                     set_notification_text(
@@ -145,13 +146,15 @@ void Tri::State::handle_events() {
                 } else {
                     notification_alpha = 0.0f;
                 }
-                } else if(event.key.code == sf::Keyboard::I) {
+                break;
+            case KEY_I:
                 flags.flip(F_DISPLAY_CHANGE_SIZE);
                 if(!flags.test(F_DISPLAY_CHANGE_SIZE)) {
-                        inputWidthHeight[0] = width;
+                    inputWidth = width;
-                        inputWidthHeight[1] = height;
+                    inputHeight = height;
                 }
-                } else if(event.key.code == sf::Keyboard::E) {
+                break;
+            case KEY_E:
                 if(flags.test(F_TRI_EDIT_MODE)) {
                     close_selected_tri_mode();
                 } else {
@@ -160,13 +163,17 @@ void Tri::State::handle_events() {
                         set_notification_text("Click on a tri\nto edit it");
                     }
                 }
+                break;
             }
         }
-        } else if(event.type == sf::Event::MouseButtonPressed) {
+        keyPressed = GetKeyPressed();
+    }
+
+    if(IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) {
         if(can_draw()) {
             switch(currentTri_state) {
             case CurrentState::NONE:
-                    currentTri[0] = sf::Vector2f(event.mouseButton.x, event.mouseButton.y);
+                currentTri[0] = {GetMouseX(), GetMouseY()};
                 if(trisIndex < tris.size()) {
                     tris.resize(trisIndex);
                 }
@@ -174,7 +181,7 @@ void Tri::State::handle_events() {
                 currentTri_maxState = CurrentState::FIRST;
                 break;
             case CurrentState::FIRST:
-                    currentTri[1] = sf::Vector2f(event.mouseButton.x, event.mouseButton.y);
+                currentTri[1] = {GetMouseX(), GetMouseY()};
                 if(trisIndex < tris.size()) {
                     tris.resize(trisIndex);
                 }
@@ -182,46 +189,59 @@ void Tri::State::handle_events() {
                 currentTri_maxState = CurrentState::SECOND;
                 break;
             case CurrentState::SECOND:
-                    currentTri[2] = sf::Vector2f(event.mouseButton.x, event.mouseButton.y);
+                currentTri[2] = {GetMouseX(), GetMouseY()};
                 if(trisIndex < tris.size()) {
                     tris.resize(trisIndex);
                 }
                 ++trisIndex;
-                    tris.emplace_back(sf::ConvexShape(3));
+                make_counter_clockwise(currentTri);
-                    tris.back().setPoint(0, currentTri[0]);
+                tris.emplace_back(currentTri, pointCircle.fillColor);
-                    tris.back().setPoint(1, currentTri[1]);
-                    tris.back().setPoint(2, currentTri[2]);
-                    tris.back().setFillColor(pointCircle.getFillColor());
                 currentTri_state = CurrentState::NONE;
                 currentTri_maxState = CurrentState::NONE;
                 flags.set(F_DRAW_CACHE_DIRTY);
                 break;
             }
         } else if(flags.test(F_COPY_COLOR_MODE)) {
-                auto color = drawCache.getTexture().copyToImage()
+            check_draw_cache();
-                    .getPixel(event.mouseButton.x, event.mouseButton.y);
+            Image drawImage = GetTextureData(drawCache.texture);
-                colorPickerColor[0] = color.r / 255.0f;
+            Color *colors = LoadImageColors(drawImage);
-                colorPickerColor[1] = color.g / 255.0f;
+            int mx = GetMouseX();
-                colorPickerColor[2] = color.b / 255.0f;
+            int my = GetMouseY();
+            if(mx < 0) { mx = 0; }
+            else if(mx >= (int)width) { mx = width - 1; }
+            if(my < 0) { my = 0; }
+            else if(my >= (int)height) { my = height - 1; }
+
+            colorPickerColor[0] = colors[mx + my * width].r;
+            colorPickerColor[1] = colors[mx + my * width].g;
+            colorPickerColor[2] = colors[mx + my * width].b;
             colorPickerColor[3] = 1.0f;
-                pointCircle.setFillColor(color);
+            pointCircle.fillColor = colors[mx + my * width];
             flags.reset(F_COPY_COLOR_MODE);
             set_notification_text("Color set");
+
+            UnloadImageColors(colors);
+            UnloadImage(drawImage);
         } else if(flags.test(F_SELECT_TRI_MODE)) {
-                sf::Vector2f mouseXY = window.mapPixelToCoords(
+            int mx = GetMouseX();
-                    {event.mouseButton.x, event.mouseButton.y});
+            int my = GetMouseY();
+            if(mx < 0) { mx = 0; }
+            else if(mx >= (int)width) { mx = width - 1; }
+            if(my < 0) { my = 0; }
+            else if(my >= (int)height) { my = height - 1; }
+
             for(unsigned int i = trisIndex; i-- > 0; ) {
-                    if(is_within_shape(tris.at(i), mouseXY)) {
+                if(is_within_shape(tris.at(i), {mx, my})) {
                     selectedTri = i;
-                        tris[i].setOutlineColor(invert_color(tris[i].getFillColor()));
+                    tris[i].outlineColor = invert_color(tris[i].fillColor);
                     flags.reset(F_SELECT_TRI_MODE);
                     flags.set(F_TRI_EDIT_MODE);
                     flags.set(F_TRI_EDIT_DRAW_TRI);
                     selectedTriBlinkTimer = 1.0f;
-                        selectedTriColor[0] = tris[i].getFillColor().r / 255.0f;
+                    selectedTriColor[0] = tris[i].fillColor.r / 255.0f;
-                        selectedTriColor[1] = tris[i].getFillColor().g / 255.0f;
+                    selectedTriColor[1] = tris[i].fillColor.g / 255.0f;
-                        selectedTriColor[2] = tris[i].getFillColor().b / 255.0f;
+                    selectedTriColor[2] = tris[i].fillColor.b / 255.0f;
-                        selectedTriColor[3] = tris[i].getFillColor().a / 255.0f;
+                    selectedTriColor[3] = tris[i].fillColor.a / 255.0f;
                     break;
                 }
             }
@@ -231,13 +251,12 @@ void Tri::State::handle_events() {
         }
     }
 }
-}
 
 void Tri::State::update() {
-    ImGui::SFML::Update(window, dt);
+    dt = GetFrameTime();
 
     if(notification_alpha > 0.0f) {
-        notification_alpha -= dt.asSeconds() * STARTING_HELP_FADE_RATE;
+        notification_alpha -= dt * STARTING_HELP_FADE_RATE;
         if(notification_alpha < 0.0f) {
             notification_alpha = 0.0f;
         }
@@ -245,11 +264,11 @@ void Tri::State::update() {
 
     if(flags.test(F_COLOR_P_COLOR_DIRTY)) {
         flags.reset(F_COLOR_P_COLOR_DIRTY);
-        pointCircle.setFillColor(sf::Color(
+        pointCircle.fillColor = Color{
             (unsigned char)(255 * colorPickerColor[0]),
             (unsigned char)(255 * colorPickerColor[1]),
             (unsigned char)(255 * colorPickerColor[2]),
-            (unsigned char)(255 * colorPickerColor[3])));
+            (unsigned char)(255 * colorPickerColor[3])};
     }
 
     if(flags.test(F_BG_COLOR_P_COLOR_DIRTY)) {
@@ -260,14 +279,40 @@ void Tri::State::update() {
     }
 
     if(flags.test(F_TRI_EDIT_MODE)) {
-        selectedTriBlinkTimer -= dt.asSeconds() * TRIANGLES_EDIT_TRI_BLINK_RATE;
+        selectedTriBlinkTimer -= dt * TRIANGLES_EDIT_TRI_BLINK_RATE;
         if(selectedTriBlinkTimer <= 0.0f) {
             selectedTriBlinkTimer = 1.0f;
             flags.flip(F_TRI_EDIT_DRAW_TRI);
         }
     }
+}
+
+void Tri::State::draw() {
+    // Should be able to directly draw a texture held by the RenderTexture2D
+    if(flags.test(F_DRAW_CACHE_INITIALIZED)) {
+        // draw cache initialized
+        check_draw_cache();
+        BeginDrawing();
+        DrawTexture(drawCache.texture, 0, 0, WHITE);
+    } else {
+        BeginDrawing();
+        draw_to_target(nullptr);
+    }
+
+    if(flags.test(F_TRI_EDIT_MODE) && flags.test(F_TRI_EDIT_DRAW_TRI)) {
+//        tris.at(selectedTri).setOutlineThickness(4.0f);
+        tris[selectedTri].draw();
+//        tris.at(selectedTri).setOutlineThickness(0.0f);
+    }
+
+    if(can_draw()) {
+        for(unsigned int i = 0; i < currentTri_state; ++i) {
+            pointCircle.resetTransform();
+            pointCircle.translate(currentTri[i]);
+            pointCircle.draw();
+        }
+    }
 
-    // Seems misleading, but imgui handles setting up the window during update
     Tri::draw_notification(this);
     Tri::draw_color_picker(this);
     Tri::draw_bg_color_picker(this);
@@ -276,48 +321,27 @@ void Tri::State::update() {
     Tri::draw_save(this);
     Tri::draw_help(this);
 
-    ImGui::EndFrame();
+    EndDrawing();
 }
 
-void Tri::State::draw() {
+void Tri::State::draw_to_target(RenderTexture2D *target) {
-    if(flags.test(F_DRAW_CACHE_INITIALIZED)) {
+    if(target) {
-        // draw cache initialized
+        BeginTextureMode(*target);
-        if(flags.test(F_DRAW_CACHE_DIRTY)) {
+        ClearBackground(bgColor);
-            // draw cache dirty
-            flags.reset(F_DRAW_CACHE_DIRTY);
-            draw_to_target(&drawCache);
-            drawCache.display();
-        }
-        window.draw(drawCacheSprite);
-    } else {
-        draw_to_target(&window);
-    }
-
-    if(flags.test(F_TRI_EDIT_MODE) && flags.test(F_TRI_EDIT_DRAW_TRI)) {
-        tris.at(selectedTri).setOutlineThickness(4.0f);
-        window.draw(tris[selectedTri]);
-        tris.at(selectedTri).setOutlineThickness(0.0f);
-    }
-
-    if(can_draw()) {
-        for(unsigned int i = 0; i < currentTri_state; ++i) {
-            pointCircle.setPosition(currentTri[i]);
-            window.draw(pointCircle);
-        }
-    }
-
-    // draw gui stuff
-    ImGui::SFML::Render(window);
-
-    window.display();
-}
-
-void Tri::State::draw_to_target(sf::RenderTarget *target) {
-    target->clear(bgColor);
 
         // draw tris
         for(unsigned int i = 0; i < trisIndex; ++i) {
-        target->draw(tris[i]);
+            tris[i].draw();
+        }
+        EndTextureMode();
+    } else {
+        // Expects BeginDrawing() already having been called prior to this fn
+        ClearBackground(bgColor);
+
+        // draw tris
+        for(unsigned int i = 0; i < trisIndex; ++i) {
+            tris[i].draw();
+        }
     }
 }
 
@@ -349,12 +373,12 @@ void Tri::State::set_notification_text(const char *text) {
     notification_alpha = 1.0f;
 }
 
-float* Tri::State::get_color() {
+std::array<float, 4>& Tri::State::get_color() {
     flags.set(F_COLOR_P_COLOR_DIRTY);
     return colorPickerColor;
 }
 
-float* Tri::State::get_bg_color() {
+std::array<float, 3>& Tri::State::get_bg_color() {
     flags.set(F_BG_COLOR_P_COLOR_DIRTY);
     return bgColorPickerColor;
 }
@@ -364,36 +388,30 @@ Tri::State::FilenameBufferType* Tri::State::get_save_filename_buffer() {
 }
 
 bool Tri::State::do_save() {
-    sf::RenderTexture saveTexture;
+    RenderTexture2D saveTexture = LoadRenderTexture(width, height);
-    if(!saveTexture.create(width, height)) {
-#ifndef NDEBUG
-        puts("ERROR: Failed to create texture for saving");
-#endif
-        failedMessage = std::string("Failed to create texture for saving");
-        return false;
-    }
 
     draw_to_target(&saveTexture);
-    saveTexture.display();
 
-    sf::Image saveImage = saveTexture.getTexture().copyToImage();
+    Image saveImage = GetTextureData(saveTexture.texture);
-    std::string filename = std::string(saveFilenameBuffer.data());
+    UnloadRenderTexture(saveTexture);
-    if(saveImage.saveToFile(filename)) {
+    if(ExportImage(saveImage, saveFilenameBuffer.data())) {
 #ifndef NDEBUG
-        printf("Saved to \"%s\"\n", filename.c_str());
+        printf("Saved to \"%s\"\n", saveFilenameBuffer.data());
 #endif
         failedMessage.clear();
+        UnloadImage(saveImage);
         return true;
     } else {
 #ifndef NDEBUG
-        printf("ERROR: Failed to save \"%s\"\n", filename.c_str());
+        printf("ERROR: Failed to save \"%s\"\n", saveFilenameBuffer.data());
 #endif
         failedMessage = std::string("Failed to save (does the name end in \".png\"?)");
+        UnloadImage(saveImage);
         return false;
     }
 }
 
-std::string_view Tri::State::failed_message() const {
+const std::string& Tri::State::failed_message() const {
     return failedMessage;
 }
 
@@ -439,38 +457,35 @@ void Tri::State::close_bg_color_picker() {
 
 bool Tri::State::change_width_height() {
     std::bitset<2> warnings;
-    if(inputWidthHeight[0] < 0 || inputWidthHeight[1] < 0) {
+    if(inputWidth < 0 || inputHeight < 0) {
         failedMessage = "Width or Height cannot be less than 0";
         return false;
     }
-    if(inputWidthHeight[0] < 200) {
+    if(inputWidth < 800) {
-        inputWidthHeight[0] = 200;
+        inputWidth = 800;
-        warnings.set(F_DISPLAY_HELP);
+        warnings.set(0);
     }
-    if(inputWidthHeight[1] < 150) {
+    if(inputHeight < 600) {
-        inputWidthHeight[1] = 150;
+        inputHeight = 600;
-        warnings.set(F_IS_RUNNING);
+        warnings.set(1);
     }
 
     if(warnings.test(0) && warnings.test(1)) {
-        set_notification_text("Width set to 200\nHeight set to 150");
+        set_notification_text("Width set to 800\nHeight set to 600");
     } else if(warnings.test(0)) {
-        set_notification_text("Width set to 200");
+        set_notification_text("Width set to 800");
     } else if(warnings.test(1)) {
-        set_notification_text("Height set to 150");
+        set_notification_text("Height set to 600");
     }
 
-    this->width = inputWidthHeight[0];
+    this->width = inputWidth;
-    this->height = inputWidthHeight[1];
+    this->height = inputHeight;
 
-    window.setSize({this->width, this->height});
+    SetWindowSize(this->width, this->height);
-    sf::View newView(
+
-        sf::Vector2f(width / 2.0f, height / 2.0f),
+    UnloadRenderTexture(drawCache);
-        sf::Vector2f(width, height));
+    drawCache = LoadRenderTexture(this->width, this->height);
-    window.setView(newView);
 
-    drawCache.create(width, height);
-    drawCacheSprite.setTexture(drawCache.getTexture(), true);
     flags.set(F_DRAW_CACHE_DIRTY);
 
     currentTri_state = CurrentState::NONE;
@@ -478,10 +493,6 @@ bool Tri::State::change_width_height() {
     return true;
 }
 
-int* Tri::State::get_input_width_height() {
-    return inputWidthHeight;
-}
-
 void Tri::State::close_input_width_height_window() {
     flags.reset(F_DISPLAY_CHANGE_SIZE);
 }
@@ -490,21 +501,40 @@ float Tri::State::get_pi() const {
     return pi;
 }
 
-float* Tri::State::get_selected_tri_color() {
+std::array<float, 4>& Tri::State::get_selected_tri_color() {
-    tris.at(selectedTri).setFillColor(sf::Color(
+    tris.at(selectedTri).fillColor = Color{
         (unsigned char)(255.0f * selectedTriColor[0]),
         (unsigned char)(255.0f * selectedTriColor[1]),
         (unsigned char)(255.0f * selectedTriColor[2]),
-        (unsigned char)(255.0f * selectedTriColor[3])));
+        (unsigned char)(255.0f * selectedTriColor[3])};
     return selectedTriColor;
 }
 
 void Tri::State::close_selected_tri_mode() {
-    tris.at(selectedTri).setFillColor(sf::Color(
+    tris.at(selectedTri).fillColor = Color{
         (unsigned char)(255.0f * selectedTriColor[0]),
         (unsigned char)(255.0f * selectedTriColor[1]),
         (unsigned char)(255.0f * selectedTriColor[2]),
-        (unsigned char)(255.0f * selectedTriColor[3])));
+        (unsigned char)(255.0f * selectedTriColor[3])};
     flags.set(F_DRAW_CACHE_DIRTY);
     reset_modes();
 }
+
+bool Tri::State::check_draw_cache() {
+    if(flags.test(F_DRAW_CACHE_INITIALIZED) && flags.test(F_DRAW_CACHE_DIRTY)) {
+        // draw cache initialized and dirty
+        flags.reset(F_DRAW_CACHE_DIRTY);
+        draw_to_target(&drawCache);
+        return true;
+    } else {
+        return false;
+    }
+}
+
+int* Tri::State::get_input_width() {
+    return &inputWidth;
+}
+
+int* Tri::State::get_input_height() {
+    return &inputHeight;
+}

src/state.hpp

@@ -7,8 +7,10 @@
 #include <vector>
 #include <array>
 
-#include <SFML/System.hpp>
+#include "glm/glm.hpp"
-#include <SFML/Graphics.hpp>
+
+#include "triangle.hpp"
+#include "circle.hpp"
 
 namespace Tri {
     class State {
@@ -40,47 +42,44 @@ namespace Tri {
         BitsetType flags;
         unsigned int width;
         unsigned int height;
-        const sf::Time dt;
+        float dt;
         float notification_alpha;
-        typedef std::array<char, 256> NotificationBufferType;
+        typedef std::array<char, 256> NBufferType;
-        NotificationBufferType notification_text;
+        NBufferType notification_text;
 
-        sf::RenderWindow window;
+        std::vector<Triangle> tris;
-        std::vector<sf::ConvexShape> tris;
         unsigned int trisIndex;
-        sf::Vector2f currentTri[3];
+        std::array<glm::vec2, 3> currentTri;
         CurrentState currentTri_state;
         CurrentState currentTri_maxState;
-        sf::CircleShape pointCircle;
+        Circle pointCircle;
 
-        sf::Event event;
+        std::array<float, 4> colorPickerColor;
-
+        std::array<float, 3> bgColorPickerColor;
-        float colorPickerColor[4];
+        Color bgColor;
-        float bgColorPickerColor[3];
-        sf::Color bgColor;
 
         typedef std::array<char, 256> FilenameBufferType;
         FilenameBufferType saveFilenameBuffer;
         std::string failedMessage;
 
-        sf::RenderTexture drawCache;
+        RenderTexture2D drawCache;
-        sf::Sprite drawCacheSprite;
-
-        int inputWidthHeight[2];
 
         const float pi;
 
         unsigned int selectedTri;
-        float selectedTriColor[4];
+        std::array<float, 4> selectedTriColor;
         float selectedTriBlinkTimer;
 
+        int inputWidth;
+        int inputHeight;
+
     public:
         void handle_events();
         void update();
         void draw();
 
     private:
-        void draw_to_target(sf::RenderTarget *target);
+        void draw_to_target(RenderTexture2D *target);
 
     public:
         unsigned int get_width() const;
@@ -95,12 +94,12 @@ namespace Tri {
         void set_notification_text(const char *text);
 
     public:
-        float* get_color();
+        std::array<float, 4>& get_color();
-        float* get_bg_color();
+        std::array<float, 3>& get_bg_color();
 
         FilenameBufferType* get_save_filename_buffer();
         bool do_save();
-        std::string_view failed_message() const;
+        const std::string& failed_message() const;
         void close_save();
 
     private:
@@ -113,14 +112,20 @@ namespace Tri {
         void close_bg_color_picker();
 
         bool change_width_height();
-        int* get_input_width_height();
         void close_input_width_height_window();
 
         float get_pi() const;
 
-        float* get_selected_tri_color();
+        std::array<float, 4>& get_selected_tri_color();
         void close_selected_tri_mode();
 
+    private:
+        bool check_draw_cache();
+
+    public:
+        int* get_input_width();
+        int* get_input_height();
+
     };
 }
 

src/triangle.cpp

@@ -0,0 +1,63 @@
+#include "triangle.hpp"
+
+Tri::Triangle::Triangle() :
+Shape(),
+vertices{
+    glm::vec2{0.0f, 0.0f},
+    glm::vec2{1.0f, 0.0f},
+    glm::vec2{0.0f, 1.0f}
+}
+{}
+
+Tri::Triangle::Triangle(std::array<glm::vec2, 3> vertices) :
+Shape(),
+vertices(vertices)
+{}
+
+Tri::Triangle::Triangle(std::array<glm::vec2, 3> vertices, Color fillColor) :
+Shape(fillColor),
+vertices(vertices)
+{}
+
+Tri::Triangle::Triangle(std::array<glm::vec2, 3> vertices, Color fillColor, Color outlineColor) :
+Shape(fillColor, outlineColor),
+vertices(vertices)
+{}
+
+Tri::Shape& Tri::Triangle::draw() {
+    std::array<glm::vec2, 3> transformed = {
+        transform * glm::vec3(vertices[0].x, vertices[0].y, 1.0f),
+        transform * glm::vec3(vertices[1].x, vertices[1].y, 1.0f),
+        transform * glm::vec3(vertices[2].x, vertices[2].y, 1.0f)
+    };
+    DrawTriangle(
+        {transformed[0].x, transformed[0].y},
+        {transformed[1].x, transformed[1].y},
+        {transformed[2].x, transformed[2].y},
+        fillColor);
+    DrawTriangleLines(
+        {transformed[0].x, transformed[0].y},
+        {transformed[1].x, transformed[1].y},
+        {transformed[2].x, transformed[2].y},
+        outlineColor);
+    return *this;
+}
+
+void Tri::Triangle::getVertices(std::vector<glm::vec2> &verticesOut) const {
+    verticesOut.clear();
+    for(const glm::vec2 &vertex : vertices) {
+        verticesOut.push_back(vertex);
+    }
+}
+
+void Tri::Triangle::getTransformedVertices(std::vector<glm::vec2> &verticesOut) const {
+    verticesOut.clear();
+    for(glm::vec2 vertex : vertices) {
+        vertex = transform * glm::vec3(vertex.x, vertex.y, 1.0f);
+        verticesOut.push_back(vertex);
+    }
+}
+
+float Tri::Triangle::getRadius() const {
+    return 0.0f;
+}

src/triangle.hpp

@@ -0,0 +1,29 @@
+#ifndef TRIANGLES_TRIANGLE_HPP
+#define TRIANGLES_TRIANGLE_HPP
+
+#include <array>
+
+#include "shape.hpp"
+
+namespace Tri {
+
+struct Triangle : public Shape {
+    Triangle();
+    Triangle(std::array<glm::vec2, 3> vertices);
+    Triangle(std::array<glm::vec2, 3> vertices, Color fillColor);
+    Triangle(std::array<glm::vec2, 3> vertices, Color fillColor, Color outlineColor);
+
+    std::array<glm::vec2, 3> vertices;
+
+    virtual Shape& draw() override;
+
+    virtual void getVertices(std::vector<glm::vec2> &verticesOut) const override;
+    virtual void getTransformedVertices(std::vector<glm::vec2> &verticesOut) const override;
+
+    virtual float getRadius() const override;
+    virtual void setRadius(float /* radius */) override {};
+}; // struct Triangle
+
+} // namespace Tri
+
+#endif

src/unittest/test_helpers.cpp

@@ -1,18 +1,17 @@
 #include "catch.hpp"
 
-#include <SFML/Graphics.hpp>
-
 #include "helpers.hpp"
+#include "triangle.hpp"
 
 TEST_CASE("Test is_within_shape", "[Triangles]") {
-    sf::ConvexShape shape;
+    Tri::Triangle triangle({{
-    shape.setPointCount(3);
+        {0.0f, 10.0f},
-    shape.setPoint(0, {0.0f, 10.0f});
+        {10.0f, 10.0f},
-    shape.setPoint(1, {10.0f, 10.0f});
+        {10.0f, 0.0f}
-    shape.setPoint(2, {10.0f, 0.0f});
+    }});
 
-    CHECK(Tri::is_within_shape(shape, {2.0f, 2.0f}) == false);
+    CHECK(Tri::is_within_shape(triangle, {2.0f, 2.0f}) == false);
-    CHECK(Tri::is_within_shape(shape, {5.0f, 15.0f}) == false);
+    CHECK(Tri::is_within_shape(triangle, {5.0f, 15.0f}) == false);
-    CHECK(Tri::is_within_shape(shape, {15.0f, 5.0f}) == false);
+    CHECK(Tri::is_within_shape(triangle, {15.0f, 5.0f}) == false);
-    CHECK(Tri::is_within_shape(shape, {7.0f, 7.0f}) == true);
+    CHECK(Tri::is_within_shape(triangle, {7.0f, 7.0f}) == true);
 }

third_party/glm

@@ -0,0 +1 @@
+Subproject commit ace16e47780dcef815294715237f51e9129b6eb3

third_party/imgui

@@ -1 +0,0 @@
-Subproject commit 9418dcb69355558f70de260483424412c5ca2fce

third_party/imgui-sfml

@@ -1 +0,0 @@
-Subproject commit 488c321155547cb499697dac155aa6269d53c21f

third_party/raygui

@@ -0,0 +1 @@
+Subproject commit 6b216626ec8486b98ec38ae307bfb2cf32f9efcc