fixed alloc, added warning

Author: mpv-enjoyer

.gitignore

@@ -7,4 +7,5 @@
 /imgui_impl_opengl3.o
 /imgui_tables.o
 /imgui_widgets.o
-/main.o
+/main.o
+cantor

README

@@ -1,3 +1 @@
-Cantor function rendered in real time :DD
-
-(for now using dumb getter + dumb recursive function with lots of allocations)
+Cantor function rendered in real time :DD

main.cpp

@@ -6,43 +6,44 @@
 #include <GLFW/glfw3.h>
 #include <math.h>
 #include <vector>
+#include <iostream>
 #if defined(_MSC_VER) && (_MSC_VER >= 1900) && !defined(IMGUI_DISABLE_WIN32_FUNCTIONS)
 #pragma comment(lib, "legacy_stdio_definitions")
 #endif
 
-std::vector<bool> generate_plus_null(int horisontal_steps) //Recursive function to generate monotonous sections
+#define MAX_STEP     20
+#define WARNING_STEP 15
+
+void generate_plus_null(int horisontal_steps, int current_position, bool* output_function) //Recursive function to generate monotonous sections
 {
-    std::vector<bool> output;
     if (horisontal_steps == 1)
     {
-        output.push_back(false);
-        return output;
+        output_function[current_position] = false;
+        return;
+    }
+    generate_plus_null(horisontal_steps / 3, current_position, output_function);
+    for (int i = current_position + horisontal_steps / 3; i < current_position + 2 * horisontal_steps / 3; i++)
+    {
+        output_function[i] = true;
     }
-    std::vector<bool> left_side = generate_plus_null(horisontal_steps / 3);
-    for (int i = 0; i < horisontal_steps / 3; i++) output.push_back(left_side.at(i));
-    for (int i = 0; i < horisontal_steps / 3; i++) output.push_back(true);
-    for (int i = 0; i < horisontal_steps / 3; i++) output.push_back(left_side.at(left_side.size() - i - 1));
-    return output;
+    generate_plus_null(horisontal_steps / 3, current_position + 2 * horisontal_steps / 3, output_function);
 }
 
 static void glfw_error_callback(int error, const char* description)
 {
     fprintf(stderr, "GLFW Error %d: %s\n", error, description);
 }
 
-// Main code
 int main(int, char**)
 {
     // Generic setup stuff
     glfwSetErrorCallback(glfw_error_callback);
-    if (!glfwInit())
-        return 1;
+    if (!glfwInit()) return 1;
     const char* glsl_version = "#version 130";
     glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
     glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
     GLFWwindow* window = glfwCreateWindow(1280, 720, "Cantor", nullptr, nullptr);
-    if (window == nullptr)
-        return 1;
+    if (window == nullptr) return 1;
     glfwMakeContextCurrent(window);
     glfwSwapInterval(1);
     IMGUI_CHECKVERSION();
@@ -54,6 +55,15 @@ int main(int, char**)
     ImGui_ImplGlfw_InitForOpenGL(window, true);
     ImGui_ImplOpenGL3_Init(glsl_version);
     ImVec4 clear_color = ImVec4(0.45f, 0.55f, 0.60f, 1.00f);
+    // Setting up values
+    float* function = (float*)IM_ALLOC(sizeof(float) * 4);
+    function[0] = 0.0f; function[1] = 0.5f; function[2] = 0.5f; function[3] = 1.0f;
+    int size = 3;
+    int display_count = 1;
+    bool warning_shown = false;
+    bool warning_active = false;
+    int pre_warning_value = 1;
+    int post_warning_value = 1;
     // Main loop
     while (!glfwWindowShouldClose(window))
     {
@@ -63,41 +73,64 @@ int main(int, char**)
         ImGui::NewFrame();
         // Actual code
         {
-            static int display_count = 1;
-            static std::vector<bool> plus_null = {false, true, false};
-            static std::vector<float> current_integral_function = {0.5f, 0.5f, 1.0f};
-            static ImGuiWindowFlags flags = ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoSavedSettings;
+            if (warning_active)
+            {
+                ImGui::OpenPopup("Warning!");
+                ImVec2 center = ImGui::GetMainViewport()->GetCenter();
+                ImGui::SetNextWindowPos(center, ImGuiCond_Appearing, ImVec2(0.5f, 0.5f));
+                if (ImGui::BeginPopupModal("Warning!", NULL, ImGuiWindowFlags_AlwaysAutoResize))
+                {
+                    ImGui::Text("Your computer may hang.");
+                    if (ImGui::Button("OK."))
+                    {
+                        display_count = post_warning_value;
+                        warning_active = false;
+                        warning_shown = true;
+                    }
+                    ImGui::SameLine();
+                    if (ImGui::Button("Cancel.")) 
+                    {
+                        display_count = pre_warning_value;
+                        warning_active = false;
+                    }
+                    if (!warning_active) ImGui::CloseCurrentPopup();
+                    ImGui::EndPopup();
+                }
+            }
             const ImGuiViewport* viewport = ImGui::GetMainViewport();
             ImGui::SetNextWindowPos(viewport->WorkPos);
             ImGui::SetNextWindowSize(viewport->WorkSize);
-            ImGui::Begin("Cantor", nullptr, flags);
-            struct Funcs
+            ImGui::Begin("Cantor", nullptr, ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoMove | ImGuiWindowFlags_NoSavedSettings);
+            int pre_step_value = display_count;
+            if (ImGui::SliderInt("Step count", &display_count, 1, MAX_STEP, "%d", ImGuiSliderFlags_NoInput))
             {
-                static float KantorLines(void*, int i)
+                if (display_count > WARNING_STEP && !warning_shown)
                 {
-                    if (i==0) return 0.0f;
-                    i-=1;
-                    return current_integral_function[i];
+                    pre_warning_value = pre_step_value;
+                    post_warning_value = display_count;
+                    warning_active = true;
                 }
-            };
-            if (ImGui::SliderInt("Step count", &display_count, 1, 15))
-            {
-                plus_null = generate_plus_null(pow(3, display_count));
-                float current = 0;
-                current_integral_function = std::vector<float>();
-                for (int i = 0; i < plus_null.size(); i++)
+                else
                 {
-                    plus_null[i] ? current : current += 1.0f/pow(2,display_count);
-                    current_integral_function.push_back(current);
+                    free(function);
+                    size = pow(3, display_count);
+                    function = (float*)IM_ALLOC(sizeof(float) * pow(3, display_count) + 1);
+                    bool* plus_null = (bool*)IM_ALLOC(sizeof(bool) * pow(3, display_count));
+                    generate_plus_null(pow(3, display_count), 0, plus_null);
+                    float current_value = 0;
+                    function[0] = 0.0f; // We always store one extra null value so our plot doesn't start from nowhere
+                    for (int i = 0; i < size; i++)
+                    {
+                        plus_null[i] ? current_value : current_value += (1.0f / pow(2, display_count));
+                        function[i + 1] = current_value;
+                    }
+                    free(plus_null);
                 }
+
             }
             ImGui::SameLine();
-            ImGui::Text(": %.1f FPS.", io.Framerate);
-            float (*func)(void*, int) = Funcs::KantorLines;
-            if (current_integral_function.size() == pow(3, display_count))
-            {
-                ImGui::PlotLines("##Lines", func, NULL, pow(3, display_count) + 1, 0, NULL, 0.0f, 1.0f, ImVec2(-FLT_MIN, -FLT_MIN));
-            }
+            ImGui::Text("| %.1f FPS.", io.Framerate);
+            ImGui::PlotLines("##Lines", function, size + 1, 0, NULL, 0.0f, 1.0f, ImVec2(-FLT_MIN, -FLT_MIN));
             ImGui::End();
         }
         // Rendering
@@ -117,4 +150,4 @@ int main(int, char**)
     glfwDestroyWindow(window);
     glfwTerminate();
     return 0;
-}
+}