stephenseo/Triangles
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity Actions

WIP Replace SFML with Raylib

Browse source 
Need to fix Raygui usage in helpers.hpp.
Need to fix triangles being drawn flipped over the x-axis.
This commit is contained in:
Stephen Seo 2021-03-29 17:03:39 +09:00
parent ef19ff326a
commit 2919be2aff
26 changed files with 834 additions and 470 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
.gitmodules vendored
View file

@ -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

62
CMakeLists.txt
View file

@ -1,14 +1,14 @@
cmake_minimum_required(VERSION 3.0) cmake_minimum_required(VERSION 3.8.2)
project(Triangles LANGUAGES CXX VERSION 1.0) 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'!") 'git submodule update'!")
endif() 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'!") 'git submodule update'!")
endif() endif()
@ -16,22 +16,16 @@ if(NOT DEFINED CMAKE_BUILD_TYPE)
set(CMAKE_BUILD_TYPE "Debug") set(CMAKE_BUILD_TYPE "Debug")
endif() endif()
if(CMAKE_BUILD_TYPE MATCHES "Debug")
set(ImGuiDemo "third_party/imgui/imgui_demo.cpp")
else()
set(ImGuiDemo "")
endif()
set(Triangles_MAIN_SOURCES set(Triangles_MAIN_SOURCES
src/main.cpp src/main.cpp
) )
set(Triangles_LIB_SOURCES set(Triangles_LIB_SOURCES
src/state.cpp 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") 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) target_compile_features(TrianglesLib PUBLIC cxx_std_17)
if(BUILD_SHARED_LIBS OR (UNIX AND NOT CYGWIN) OR (CMAKE_CXX_COMPILER_ID MATCHES "MSVC")) 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() 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() endif()
if(CMAKE_CXX_COMPILER_ID MATCHES "MSVC") if(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
target_link_libraries(TrianglesLib PUBLIC target_link_libraries(TrianglesLib PUBLIC
sfml-graphics sfml-window sfml-system raylib
opengl32 opengl32
) )
else() else()
target_link_libraries(TrianglesLib PUBLIC target_link_libraries(TrianglesLib PUBLIC
sfml-graphics sfml-window sfml-system raylib
GL GL
) )
endif() endif()
if(CMAKE_CXX_COMPILER_ID MATCHES "MSVC") target_include_directories(TrianglesLib PUBLIC
target_include_directories(TrianglesLib PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/src
${CMAKE_CURRENT_SOURCE_DIR}/src ${CMAKE_CURRENT_SOURCE_DIR}/third_party/raygui/src
${SFML_INCLUDE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/third_party/glm
${CMAKE_CURRENT_SOURCE_DIR}/third_party/imgui # imgui related headers )
${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") if(CMAKE_BUILD_TYPE MATCHES "Debug")
set(Triangles_UNIT_TEST_SOURCES set(Triangles_UNIT_TEST_SOURCES

1
build_include/imconfig.h
View file

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

1
build_include/imgui-SFML.h
View file

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

1
build_include/imgui-SFML_export.h
View file

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

1
build_include/imgui.h
View file

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

1
build_include/imgui_internal.h
View file

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

1
build_include/imstb_rectpack.h
View file

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

1
build_include/imstb_textedit.h
View file

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

1
build_include/imstb_truetype.h
View file

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

60
src/circle.cpp Normal file
View file

@ -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;
}

29
src/circle.hpp Normal file
View file

@ -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

305
src/helpers.hpp
View file

@ -3,9 +3,12 @@
#include <cmath> #include <cmath>
#include <optional> #include <optional>
#include <cassert>
#include <imgui.h> #include <raylib.h>
#include <raygui.h>
#include "shape.hpp"
#include "state.hpp" #include "state.hpp"
#define SHOW_HELP_WIDTH (state->get_width() / 2.0f) #define SHOW_HELP_WIDTH (state->get_width() / 2.0f)
@ -20,163 +23,265 @@ namespace Tri {
// so this should be called during update, not draw // so this should be called during update, not draw
inline void draw_help(Tri::State *state) { inline void draw_help(Tri::State *state) {
if(state->get_flags().test(Tri::State::F_DISPLAY_HELP)) { 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(); state->close_help();
} }
ImGui::End();
} }
} }
inline void draw_notification(Tri::State *state) { inline void draw_notification(Tri::State *state) {
float alpha = state->get_notification_alpha(); float alpha = state->get_notification_alpha();
if(alpha > 0.0f) { 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, SHOW_HELP_WIDTH,
(state->get_height() - SHOW_HELP_HEIGHT) / 2.0f)); SHOW_HELP_HEIGHT});
ImGui::SetNextWindowSize(sf::Vector2f( GuiLabel({4.0f, 4.0f, SHOW_HELP_WIDTH - 8.0f, SHOW_HELP_HEIGHT - 8.0f},
SHOW_HELP_WIDTH, state->get_notification_text());
SHOW_HELP_HEIGHT));
ImGui::Begin(
"Notification Window",
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) { inline void draw_color_picker(Tri::State *state) {
if(state->get_flags().test(Tri::State::F_DISPLAY_COLOR_P)) { 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(); state->close_color_picker();
} }
ImGui::End();
} }
} }
inline void draw_bg_color_picker(Tri::State *state) { inline void draw_bg_color_picker(Tri::State *state) {
if(state->get_flags().test(Tri::State::F_DISPLAY_BG_COLOR_P)) { 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(); state->close_bg_color_picker();
} }
ImGui::End();
} }
} }
inline void draw_save(Tri::State *state) { inline void draw_save(Tri::State *state) {
if(state->get_flags().test(Tri::State::F_DISPLAY_SAVE)) { if(state->get_flags().test(Tri::State::F_DISPLAY_SAVE)) {
auto *filenameBuffer = state->get_save_filename_buffer(); 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(
if(state->do_save()) { {4.0f, 4.0f, 284.0f, 150.0f},
state->close_save(); 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(); 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) { inline void draw_change_size(Tri::State *state) {
if(state->get_flags().test(Tri::State::F_DISPLAY_CHANGE_SIZE)) { 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(),
if(ImGui::Button("Cancel")) { 800,
state->close_input_width_height_window(); 1920,
} true);
if(ImGui::Button("Set")) { GuiValueBox(
if(state->change_width_height()) { {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(GuiButton({4.0f, 70.0f, 70.0f, 16.0f}, "Cancel")) {
state->close_input_width_height_window(); state->close_input_width_height_window();
} }
if(GuiButton({58.0f, 70.0f, 50.0f, 16.0f}, "Set")) {
if(state->change_width_height()) {
state->close_input_width_height_window();
}
}
} else {
state->close_input_width_height_window();
} }
ImGui::End();
} }
} }
inline bool is_within_shape( inline bool is_within_shape(
const sf::ConvexShape &shape, const Tri::Shape &shape,
sf::Vector2f xy) { glm::vec2 xy) {
std::optional<bool> is_right; float radius = shape.getRadius();
sf::Transform t = shape.getTransform(); std::vector<glm::vec2> vertices;
for(unsigned int i = 0; i < shape.getPointCount(); ++i) { shape.getTransformedVertices(vertices);
sf::Vector2f t_a = t.transformPoint(shape.getPoint(i)); if(radius > 0.0f) {
sf::Vector2f t_b = t.transformPoint(shape.getPoint((i + 1) % shape.getPointCount())); assert(vertices.size() == 1);
t_b = t_b - t_a; xy = xy - vertices[0];
t_a = xy - t_a; return std::sqrt(xy.x * xy.x + xy.y * xy.y) <= radius;
} else {
assert(vertices.size() > 2);
// TODO std::optional<bool> is_right;
// cross product, where z coordinate is 0 for(unsigned int i = 0; i < vertices.size(); ++i) {
// Use sign of z value to determine if line is to right or left glm::vec2 t_a, t_b;
// t_b = vertices[(i + 1) % vertices.size()] - vertices[i];
// a x b = c t_a = xy - vertices[i];
// a_1 b_1 0
// a_2 b_2 0 // cross product, where z coordinate is 0
// 0 0 a_1 * b_2 - a_2 * b_1 // Use sign of z value to determine if line is to right or left
// //
// in this case "a" is "t_b" // a x b = c
float z = t_b.x * t_a.y - t_b.y * t_a.x; // a_1 b_1 0
if(is_right.has_value()) { // a_2 b_2 0
if(is_right.value()) { // 0 0 a_1 * b_2 - a_2 * b_1
if(z >= 0.0f) { //
// in this case "a" is "t_b"
float z = t_b.x * t_a.y - t_b.y * t_a.x;
if(is_right.has_value()) {
if(is_right.value()) {
if(z >= 0.0f) {
return false;
}
} else if(z < 0.0f) {
return false; return false;
} }
} else if(z < 0.0f) { } else {
return false; is_right = z < 0.0f;
} }
} else {
is_right = z < 0.0f;
} }
return true;
} }
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) { inline void draw_edit_tri(Tri::State *state) {
if(state->get_flags().test(Tri::State::F_TRI_EDIT_MODE)) { 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();
}
} else {
state->close_selected_tri_mode(); state->close_selected_tri_mode();
} }
ImGui::End(); }
}
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;
} }
} }
} }

7
src/main.cpp
View file

@ -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" #include "state.hpp"
#ifdef _MSC_VER #ifdef _MSC_VER

2
src/raygui.cpp Normal file
View file

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

42
src/shape.cpp Normal file
View file

@ -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;
}

37
src/shape.hpp Normal file
View file

@ -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

568
src/state.cpp
View file

@ -5,7 +5,7 @@
#include <string> #include <string>
#include <cmath> #include <cmath>
#include <imgui-SFML.h> #include <raylib.h>
#include "helpers.hpp" #include "helpers.hpp"
@ -18,226 +18,245 @@
Tri::State::State(int argc, char **argv) : Tri::State::State(int argc, char **argv) :
width(800), width(800),
height(600), height(600),
dt(sf::microseconds(16666)), dt(1.0f/60.0f),
notification_alpha(1.0f), notification_alpha(1.0f),
window(sf::VideoMode(800, 600), "Triangles", sf::Style::Titlebar | sf::Style::Close),
trisIndex(0), trisIndex(0),
currentTri_state(CurrentState::NONE), currentTri_state(CurrentState::NONE),
currentTri_maxState(CurrentState::NONE), currentTri_maxState(CurrentState::NONE),
colorPickerColor{1.0f, 1.0f, 1.0f, 1.0f}, colorPickerColor{1.0f, 1.0f, 1.0f, 1.0f},
bgColorPickerColor{0.0f, 0.0f, 0.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 flags.set(F_IS_RUNNING); // is running
ImGui::SFML::Init(window);
window.setFramerateLimit(60);
set_notification_text("Press \"H\" for help"); set_notification_text("Press \"H\" for help");
pointCircle.setRadius(7.0f); 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); saveFilenameBuffer.fill(0);
if(!drawCache.create(800, 600)) { drawCache = LoadRenderTexture(width, height);
#ifndef NDEBUG flags.set(F_DRAW_CACHE_INITIALIZED);
puts("ERROR: Failed to initialize RenderTexture (draw cache)"); flags.set(F_DRAW_CACHE_DIRTY);
#endif
flags.reset(F_DRAW_CACHE_INITIALIZED); GuiSetStyle(DEFAULT, BACKGROUND_COLOR, 0x303030);
} else {
flags.set(F_DRAW_CACHE_INITIALIZED);
flags.set(F_DRAW_CACHE_DIRTY);
drawCacheSprite.setTexture(drawCache.getTexture(), true);
}
} }
Tri::State::~State() { Tri::State::~State() {
window.close(); UnloadRenderTexture(drawCache);
ImGui::SFML::Shutdown(); CloseWindow();
} }
void Tri::State::handle_events() { void Tri::State::handle_events() {
while(window.pollEvent(event)) { if(WindowShouldClose()) {
ImGui::SFML::ProcessEvent(event); flags.reset(F_IS_RUNNING);
if(event.type == sf::Event::Closed) { }
window.close();
flags.reset(F_IS_RUNNING); int keyPressed = GetKeyPressed();
} else if(event.type == sf::Event::KeyPressed) { while(keyPressed > 0) {
if(!flags.test(F_DISPLAY_SAVE)) { 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); flags.flip(F_DISPLAY_HELP);
} else if(event.key.code == sf::Keyboard::U) { break;
flags.set(F_DRAW_CACHE_DIRTY); case KEY_U:
if(currentTri_state > 0) { flags.set(F_DRAW_CACHE_DIRTY);
switch(currentTri_state) { if(currentTri_state > 0) {
case FIRST: switch(currentTri_state) {
currentTri_state = CurrentState::NONE; case FIRST:
break; currentTri_state = CurrentState::NONE;
case SECOND: break;
currentTri_state = CurrentState::FIRST; case SECOND:
break; currentTri_state = CurrentState::FIRST;
default: break;
assert(!"Unreachable code"); default:
break; assert(!"Unreachable code");
} break;
} else if(trisIndex > 0) {
--trisIndex;
}
} else if(event.key.code == sf::Keyboard::R) {
flags.set(F_DRAW_CACHE_DIRTY);
if(currentTri_state != CurrentState::NONE
&& currentTri_state < currentTri_maxState) {
switch(currentTri_state) {
case NONE:
currentTri_state = CurrentState::FIRST;
break;
case FIRST:
currentTri_state = CurrentState::SECOND;
break;
default:
assert(!"Unreachable code");
break;
}
} else if(tris.size() > trisIndex) {
++trisIndex;
} else if(currentTri_state < currentTri_maxState) {
switch(currentTri_state) {
case NONE:
currentTri_state = CurrentState::FIRST;
break;
case FIRST:
currentTri_state = CurrentState::SECOND;
break;
default:
assert(!"Unreachable code");
break;
}
}
} else if(event.key.code == sf::Keyboard::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) {
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) {
flags.flip(F_DISPLAY_SAVE);
} else if(event.key.code == sf::Keyboard::P) {
flags.flip(F_COPY_COLOR_MODE);
if(flags.test(F_COPY_COLOR_MODE)) {
set_notification_text(
"Copy color mode\n"
"Click to change\n"
"current draw color\n"
"to what was\n"
"clicked on");
} else {
notification_alpha = 0.0f;
}
} else if(event.key.code == sf::Keyboard::I) {
flags.flip(F_DISPLAY_CHANGE_SIZE);
if(!flags.test(F_DISPLAY_CHANGE_SIZE)) {
inputWidthHeight[0] = width;
inputWidthHeight[1] = height;
}
} else if(event.key.code == sf::Keyboard::E) {
if(flags.test(F_TRI_EDIT_MODE)) {
close_selected_tri_mode();
} else {
flags.flip(F_SELECT_TRI_MODE);
if(flags.test(F_SELECT_TRI_MODE)) {
set_notification_text("Click on a tri\nto edit it");
}
} }
} else if(trisIndex > 0) {
--trisIndex;
} }
} break;
} else if(event.type == sf::Event::MouseButtonPressed) { case KEY_R:
if(can_draw()) { flags.set(F_DRAW_CACHE_DIRTY);
switch(currentTri_state) { if(currentTri_state != CurrentState::NONE
case CurrentState::NONE: && currentTri_state < currentTri_maxState) {
currentTri[0] = sf::Vector2f(event.mouseButton.x, event.mouseButton.y); switch(currentTri_state) {
if(trisIndex < tris.size()) { case NONE:
tris.resize(trisIndex); currentTri_state = CurrentState::FIRST;
} break;
currentTri_state = CurrentState::FIRST; case FIRST:
currentTri_maxState = CurrentState::FIRST; currentTri_state = CurrentState::SECOND;
break; break;
case CurrentState::FIRST: default:
currentTri[1] = sf::Vector2f(event.mouseButton.x, event.mouseButton.y); assert(!"Unreachable code");
if(trisIndex < tris.size()) { break;
tris.resize(trisIndex);
}
currentTri_state = CurrentState::SECOND;
currentTri_maxState = CurrentState::SECOND;
break;
case CurrentState::SECOND:
currentTri[2] = sf::Vector2f(event.mouseButton.x, event.mouseButton.y);
if(trisIndex < tris.size()) {
tris.resize(trisIndex);
} }
} else if(tris.size() > trisIndex) {
++trisIndex; ++trisIndex;
tris.emplace_back(sf::ConvexShape(3)); } else if(currentTri_state < currentTri_maxState) {
tris.back().setPoint(0, currentTri[0]); switch(currentTri_state) {
tris.back().setPoint(1, currentTri[1]); case NONE:
tris.back().setPoint(2, currentTri[2]); currentTri_state = CurrentState::FIRST;
tris.back().setFillColor(pointCircle.getFillColor()); break;
currentTri_state = CurrentState::NONE; case FIRST:
currentTri_maxState = CurrentState::NONE; currentTri_state = CurrentState::SECOND;
flags.set(F_DRAW_CACHE_DIRTY); break;
break; default:
} assert(!"Unreachable code");
} else if(flags.test(F_COPY_COLOR_MODE)) {
auto color = drawCache.getTexture().copyToImage()
.getPixel(event.mouseButton.x, event.mouseButton.y);
colorPickerColor[0] = color.r / 255.0f;
colorPickerColor[1] = color.g / 255.0f;
colorPickerColor[2] = color.b / 255.0f;
colorPickerColor[3] = 1.0f;
pointCircle.setFillColor(color);
flags.reset(F_COPY_COLOR_MODE);
set_notification_text("Color set");
} else if(flags.test(F_SELECT_TRI_MODE)) {
sf::Vector2f mouseXY = window.mapPixelToCoords(
{event.mouseButton.x, event.mouseButton.y});
for(unsigned int i = trisIndex; i-- > 0; ) {
if(is_within_shape(tris.at(i), mouseXY)) {
selectedTri = i;
tris[i].setOutlineColor(invert_color(tris[i].getFillColor()));
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[1] = tris[i].getFillColor().g / 255.0f;
selectedTriColor[2] = tris[i].getFillColor().b / 255.0f;
selectedTriColor[3] = tris[i].getFillColor().a / 255.0f;
break; break;
} }
} }
if(!flags.test(F_TRI_EDIT_MODE)) { break;
set_notification_text("Did not select\nanything"); case KEY_C:
if(flags.test(F_DISPLAY_COLOR_P)) {
close_color_picker();
} else {
flags.set(F_DISPLAY_COLOR_P);
} }
break;
case KEY_B:
if(flags.test(F_DISPLAY_BG_COLOR_P)) {
close_bg_color_picker();
} else {
flags.set(F_DISPLAY_BG_COLOR_P);
}
break;
case KEY_S:
flags.flip(F_DISPLAY_SAVE);
break;
case KEY_P:
flags.flip(F_COPY_COLOR_MODE);
if(flags.test(F_COPY_COLOR_MODE)) {
set_notification_text(
"Copy color mode\n"
"Click to change\n"
"current draw color\n"
"to what was\n"
"clicked on");
} else {
notification_alpha = 0.0f;
}
break;
case KEY_I:
flags.flip(F_DISPLAY_CHANGE_SIZE);
if(!flags.test(F_DISPLAY_CHANGE_SIZE)) {
inputWidth = width;
inputHeight = height;
}
break;
case KEY_E:
if(flags.test(F_TRI_EDIT_MODE)) {
close_selected_tri_mode();
} else {
flags.flip(F_SELECT_TRI_MODE);
if(flags.test(F_SELECT_TRI_MODE)) {
set_notification_text("Click on a tri\nto edit it");
}
}
break;
}
}
keyPressed = GetKeyPressed();
}
if(IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) {
if(can_draw()) {
switch(currentTri_state) {
case CurrentState::NONE:
currentTri[0] = {GetMouseX(), GetMouseY()};
if(trisIndex < tris.size()) {
tris.resize(trisIndex);
}
currentTri_state = CurrentState::FIRST;
currentTri_maxState = CurrentState::FIRST;
break;
case CurrentState::FIRST:
currentTri[1] = {GetMouseX(), GetMouseY()};
if(trisIndex < tris.size()) {
tris.resize(trisIndex);
}
currentTri_state = CurrentState::SECOND;
currentTri_maxState = CurrentState::SECOND;
break;
case CurrentState::SECOND:
currentTri[2] = {GetMouseX(), GetMouseY()};
if(trisIndex < tris.size()) {
tris.resize(trisIndex);
}
++trisIndex;
make_counter_clockwise(currentTri);
tris.emplace_back(currentTri, pointCircle.fillColor);
currentTri_state = CurrentState::NONE;
currentTri_maxState = CurrentState::NONE;
flags.set(F_DRAW_CACHE_DIRTY);
break;
}
} else if(flags.test(F_COPY_COLOR_MODE)) {
check_draw_cache();
Image drawImage = GetTextureData(drawCache.texture);
Color *colors = LoadImageColors(drawImage);
int mx = GetMouseX();
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.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)) {
int mx = GetMouseX();
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), {mx, my})) {
selectedTri = i;
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].fillColor.r / 255.0f;
selectedTriColor[1] = tris[i].fillColor.g / 255.0f;
selectedTriColor[2] = tris[i].fillColor.b / 255.0f;
selectedTriColor[3] = tris[i].fillColor.a / 255.0f;
break;
}
}
if(!flags.test(F_TRI_EDIT_MODE)) {
set_notification_text("Did not select\nanything");
} }
} }
} }
} }
void Tri::State::update() { void Tri::State::update() {
ImGui::SFML::Update(window, dt); dt = GetFrameTime();
if(notification_alpha > 0.0f) { 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) { if(notification_alpha < 0.0f) {
notification_alpha = 0.0f; notification_alpha = 0.0f;
} }
@ -245,11 +264,11 @@ void Tri::State::update() {
if(flags.test(F_COLOR_P_COLOR_DIRTY)) { if(flags.test(F_COLOR_P_COLOR_DIRTY)) {
flags.reset(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[0]),
(unsigned char)(255 * colorPickerColor[1]), (unsigned char)(255 * colorPickerColor[1]),
(unsigned char)(255 * colorPickerColor[2]), (unsigned char)(255 * colorPickerColor[2]),
(unsigned char)(255 * colorPickerColor[3]))); (unsigned char)(255 * colorPickerColor[3])};
} }
if(flags.test(F_BG_COLOR_P_COLOR_DIRTY)) { if(flags.test(F_BG_COLOR_P_COLOR_DIRTY)) {
@ -260,14 +279,40 @@ void Tri::State::update() {
} }
if(flags.test(F_TRI_EDIT_MODE)) { 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) { if(selectedTriBlinkTimer <= 0.0f) {
selectedTriBlinkTimer = 1.0f; selectedTriBlinkTimer = 1.0f;
flags.flip(F_TRI_EDIT_DRAW_TRI); 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_notification(this);
Tri::draw_color_picker(this); Tri::draw_color_picker(this);
Tri::draw_bg_color_picker(this); Tri::draw_bg_color_picker(this);
@ -276,49 +321,28 @@ void Tri::State::update() {
Tri::draw_save(this); Tri::draw_save(this);
Tri::draw_help(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 tris
draw_to_target(&drawCache); for(unsigned int i = 0; i < trisIndex; ++i) {
drawCache.display(); tris[i].draw();
} }
window.draw(drawCacheSprite); EndTextureMode();
} else { } else {
draw_to_target(&window); // Expects BeginDrawing() already having been called prior to this fn
} ClearBackground(bgColor);
if(flags.test(F_TRI_EDIT_MODE) && flags.test(F_TRI_EDIT_DRAW_TRI)) { // draw tris
tris.at(selectedTri).setOutlineThickness(4.0f); for(unsigned int i = 0; i < trisIndex; ++i) {
window.draw(tris[selectedTri]); tris[i].draw();
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]);
}
} }
unsigned int Tri::State::get_width() const { unsigned int Tri::State::get_width() const {
@ -349,12 +373,12 @@ void Tri::State::set_notification_text(const char *text) {
notification_alpha = 1.0f; notification_alpha = 1.0f;
} }
float* Tri::State::get_color() { std::array<float, 4>& Tri::State::get_color() {
flags.set(F_COLOR_P_COLOR_DIRTY); flags.set(F_COLOR_P_COLOR_DIRTY);
return colorPickerColor; 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); flags.set(F_BG_COLOR_P_COLOR_DIRTY);
return bgColorPickerColor; return bgColorPickerColor;
} }
@ -364,36 +388,30 @@ Tri::State::FilenameBufferType* Tri::State::get_save_filename_buffer() {
} }
bool Tri::State::do_save() { 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); 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 #ifndef NDEBUG
printf("Saved to \"%s\"\n", filename.c_str()); printf("Saved to \"%s\"\n", saveFilenameBuffer.data());
#endif #endif
failedMessage.clear(); failedMessage.clear();
UnloadImage(saveImage);
return true; return true;
} else { } else {
#ifndef NDEBUG #ifndef NDEBUG
printf("ERROR: Failed to save \"%s\"\n", filename.c_str()); printf("ERROR: Failed to save \"%s\"\n", saveFilenameBuffer.data());
#endif #endif
failedMessage = std::string("Failed to save (does the name end in \".png\"?)"); failedMessage = std::string("Failed to save (does the name end in \".png\"?)");
UnloadImage(saveImage);
return false; return false;
} }
} }
std::string_view Tri::State::failed_message() const { const std::string& Tri::State::failed_message() const {
return failedMessage; return failedMessage;
} }
@ -439,38 +457,35 @@ void Tri::State::close_bg_color_picker() {
bool Tri::State::change_width_height() { bool Tri::State::change_width_height() {
std::bitset<2> warnings; 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"; failedMessage = "Width or Height cannot be less than 0";
return false; 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)) { 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)) { } else if(warnings.test(0)) {
set_notification_text("Width set to 200"); set_notification_text("Width set to 800");
} else if(warnings.test(1)) { } 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); flags.set(F_DRAW_CACHE_DIRTY);
currentTri_state = CurrentState::NONE; currentTri_state = CurrentState::NONE;
@ -478,10 +493,6 @@ bool Tri::State::change_width_height() {
return true; return true;
} }
int* Tri::State::get_input_width_height() {
return inputWidthHeight;
}
void Tri::State::close_input_width_height_window() { void Tri::State::close_input_width_height_window() {
flags.reset(F_DISPLAY_CHANGE_SIZE); flags.reset(F_DISPLAY_CHANGE_SIZE);
} }
@ -490,21 +501,40 @@ float Tri::State::get_pi() const {
return pi; 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[0]),
(unsigned char)(255.0f * selectedTriColor[1]), (unsigned char)(255.0f * selectedTriColor[1]),
(unsigned char)(255.0f * selectedTriColor[2]), (unsigned char)(255.0f * selectedTriColor[2]),
(unsigned char)(255.0f * selectedTriColor[3]))); (unsigned char)(255.0f * selectedTriColor[3])};
return selectedTriColor; return selectedTriColor;
} }
void Tri::State::close_selected_tri_mode() { 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[0]),
(unsigned char)(255.0f * selectedTriColor[1]), (unsigned char)(255.0f * selectedTriColor[1]),
(unsigned char)(255.0f * selectedTriColor[2]), (unsigned char)(255.0f * selectedTriColor[2]),
(unsigned char)(255.0f * selectedTriColor[3]))); (unsigned char)(255.0f * selectedTriColor[3])};
flags.set(F_DRAW_CACHE_DIRTY); flags.set(F_DRAW_CACHE_DIRTY);
reset_modes(); 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;
}

55
src/state.hpp
View file

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

63
src/triangle.cpp Normal file
View file

@ -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;
}

29
src/triangle.hpp Normal file
View file

@ -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

21
src/unittest/test_helpers.cpp
View file

@ -1,18 +1,17 @@
#include "catch.hpp" #include "catch.hpp"
#include <SFML/Graphics.hpp>
#include "helpers.hpp" #include "helpers.hpp"
#include "triangle.hpp"
TEST_CASE("Test is_within_shape", "[Triangles]") { 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);
} }

1
third_party/glm vendored Submodule

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

1
third_party/imgui vendored

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

1
third_party/imgui-sfml vendored

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

1
third_party/raygui vendored Submodule

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