Setup variable in build script for user to adjust thread timers

We use a #define here to set these up - if you define them via a -D
block yourself, you can adjust these as you require.

build.sh

@@ -6,7 +6,8 @@ OUT="cw_tree.out"
 GFLAGS="-Wall -Wextra -Wswitch-enum -std=c++17"
 DFLAGS="-ggdb -fsanitize=address -fsanitize=undefined"
 RFLAGS="-O2"
-CFLAGS="$GFLAGS $DFLAGS"
+VARFLAGS="-DTHREAD_PAUSE_MS=1000 -DTHREAD_GENERAL_MS=1"
+CFLAGS="$GFLAGS $VARFLAGS $DFLAGS"
 LIBS="-lraylib -lm"
 
 build() {
@@ -18,7 +19,7 @@ then
     build && ./$OUT
 elif [ "$1" = "release" ]
 then
-    CFLAGS="$GFLAGS $RFLAGS"
+    CFLAGS="$GFLAGS $VARFLAGS $RFLAGS"
     build;
 else
     build;

src/main.cpp

@@ -15,17 +15,19 @@
 #include <tuple>
 
 #include <raylib.h>
+#include <raymath.h>
 
 #include "base.hpp"
 #include "node.hpp"
 #include "worker.hpp"
 
 #define WIDTH       1024
-#define HEIGHT      1024
+#define HEIGHT      800
 #define FONT_SIZE   20
 #define CIRCLE_SIZE 2
 #define LINE_TOP    (7 * HEIGHT / 16)
 #define LINE_BOTTOM (9 * HEIGHT / 16)
+#define N_THREADS   15
 
 using cw::state::DrawState;
 using cw::state::State;
@@ -46,23 +48,12 @@ void draw_fraction(cw::node::Fraction f, u64 x, u64 y)
   DrawText(s.c_str(), x - width / 2, y - FONT_SIZE, FONT_SIZE, WHITE);
 }
 
-constexpr u64 clamp_to_width(const DrawState &ds, f64 val)
-{
-  return (WIDTH / (ds.bounds.upper_val - ds.bounds.lower_val)) *
-         (val - ds.bounds.lower_val);
-}
-
 void draw_tree(DrawState &ds, State &state)
 {
   // Number line
   DrawLine(0, HEIGHT / 2, WIDTH, HEIGHT / 2, WHITE);
 
   // Bounds
-  u64 lower_x = clamp_to_width(ds, ds.bounds.leftmost.value.norm);
-  u64 upper_x = clamp_to_width(ds, ds.bounds.rightmost.value.norm);
-  DrawLine(lower_x, LINE_TOP, lower_x, LINE_BOTTOM, WHITE);
-  DrawLine(upper_x, LINE_TOP, upper_x, LINE_BOTTOM, WHITE);
-
   state.mutex.lock();
   std::stack<std::pair<u64, f64>> stack;
   cw::node::Node n = state.allocator.get_val(0);
@@ -73,7 +64,7 @@ void draw_tree(DrawState &ds, State &state)
     f64 norm;
     std::tie(node_index, norm) = stack.top();
     stack.pop();
-    u64 x = clamp_to_width(ds, norm);
+    u64 x = Remap(norm, ds.bounds.lower_val, ds.bounds.upper_val, 0, WIDTH);
     DrawLine(x, LINE_TOP, x, LINE_BOTTOM, RED);
 
     cw::node::Node n = state.allocator.get_val(node_index);
@@ -89,6 +80,14 @@ void draw_tree(DrawState &ds, State &state)
     }
   }
   state.mutex.unlock();
+
+  DrawLine(0, LINE_TOP, 0, LINE_BOTTOM, WHITE);
+  DrawText("0", 0, LINE_TOP - FONT_SIZE, FONT_SIZE, WHITE);
+  DrawLine(WIDTH, LINE_TOP, WIDTH, LINE_BOTTOM, WHITE);
+  char buffer[64];
+  sprintf(buffer, "%d", (int)ds.bounds.upper_val);
+  DrawText(buffer, WIDTH - (FONT_SIZE / 2), LINE_TOP - FONT_SIZE, FONT_SIZE,
+           WHITE);
 }
 
 using Clock = std::chrono::steady_clock;
@@ -116,10 +115,9 @@ int main(void)
   std::string format_str;
   u64 format_str_width = 0;
 
-// Init threads
+  // Init threads
-#define THREADS 15
+  std::thread threads[N_THREADS];
-  std::thread threads[THREADS];
+  for (auto i = 0; i < N_THREADS; ++i)
-  for (auto i = 0; i < THREADS; ++i)
   {
     threads[i] = std::move(std::thread(cw::worker::worker, std::ref(state)));
   }
@@ -128,6 +126,13 @@ int main(void)
   InitWindow(WIDTH, HEIGHT, "Calkin-Wilf tree");
   SetTargetFPS(60);
 
+  // setup camera
+  Camera2D camera;
+  camera.target   = {.x = 0, .y = 0};
+  camera.offset   = {.x = WIDTH / 16, .y = 0};
+  camera.rotation = 0.0f;
+  camera.zoom     = 0.8f;
+
   while (!WindowShouldClose())
   {
     // Update
@@ -155,17 +160,33 @@ int main(void)
     }
 
     if (IsKeyPressed(KEY_SPACE))
-    {
       state.pause_work = !state.pause_work;
+
+    if (IsMouseButtonDown(MOUSE_BUTTON_LEFT))
+    {
+      Vector2 delta = GetMouseDelta();
+      delta         = Vector2Scale(delta, -1.0f / camera.zoom);
+      camera.target = Vector2Add(camera.target, delta);
+    }
+    float wheel = GetMouseWheelMove();
+    if (wheel != 0)
+    {
+      Vector2 mouse_to_world = GetScreenToWorld2D(GetMousePosition(), camera);
+      camera.offset          = GetMousePosition();
+      camera.target          = mouse_to_world;
+      camera.zoom            = Clamp(camera.zoom + (wheel * 0.1f), 0.125, 64);
+      printf("%lf\n", camera.zoom);
     }
 
     // Draw
 
     ClearBackground(BLACK);
     BeginDrawing();
+    BeginMode2D(camera);
     draw_tree(draw_state, state);
-    DrawText(format_str.c_str(), WIDTH / 2 - format_str_width / 2, HEIGHT / 8,
+    EndMode2D();
-             FONT_SIZE, WHITE);
+    DrawText(format_str.c_str(), (31 * WIDTH / 32) - format_str_width / 2,
+             HEIGHT / 32, FONT_SIZE, WHITE);
     EndDrawing();
   }
 
@@ -179,178 +200,6 @@ int main(void)
   return 0;
 }
 
-#if 0
-struct State
-{
-  NodeAllocator allocator;
-  std::queue<word_t> iteration_queue;
-  word_t root;
-
-  struct Bounds
-  {
-    Node leftmost, rightmost;
-    long double lower, upper;
-  } bounds;
-
-  struct Iteration
-  {
-    Fraction left, centre, right;
-  } iteration;
-
-  State(const Fraction start) : allocator{256}
-  {
-    root = allocator.alloc(start);
-    iteration_queue.push(root);
-    bounds.leftmost  = allocator.getVal(root);
-    bounds.rightmost = allocator.getVal(root);
-    compute_bounds();
-  }
-
-  void do_iteration(void)
-  {
-    std::tie(iteration.left, iteration.centre, iteration.right) =
-        iterate(iteration_queue, allocator);
-    compute_bound_nodes();
-    compute_bounds();
-  }
-
-  void compute_bounds()
-  {
-    bounds.lower = std::floorl(bounds.leftmost.value.norm);
-    bounds.upper = std::ceill(bounds.rightmost.value.norm);
-  }
-
-  void compute_bound_nodes()
-  {
-    bounds.leftmost = allocator.getVal(0);
-    while (bounds.leftmost.left.has_value())
-      bounds.leftmost = allocator.getVal(bounds.leftmost.left.value());
-
-    bounds.rightmost = allocator.getVal(0);
-    while (bounds.rightmost.right.has_value())
-      bounds.rightmost = allocator.getVal(bounds.rightmost.right.value());
-  }
-
-  constexpr word_t clamp_to_width(long double value)
-  {
-    return (WIDTH / (bounds.upper - bounds.lower)) * (value - bounds.lower);
-  }
-
-  void draw_bounds()
-  {
-    word_t lower_x = clamp_to_width(bounds.leftmost.value.norm);
-    word_t upper_x = clamp_to_width(bounds.rightmost.value.norm);
-    DrawLine(lower_x, LINE_TOP, lower_x, LINE_BOTTOM, WHITE);
-    DrawLine(upper_x, LINE_TOP, upper_x, LINE_BOTTOM, WHITE);
-  }
-
-  void draw_nodes()
-  {
-    std::stack<Node> stack;
-    stack.push(allocator.getVal(0));
-    while (!stack.empty())
-    {
-      Node n = stack.top();
-      stack.pop();
-      word_t x = clamp_to_width(n.value.norm);
-      DrawLine(x, LINE_TOP, x, LINE_BOTTOM, RED);
-      if (n.left.has_value())
-        stack.push(allocator.getVal(n.left.value()));
-      if (n.right.has_value())
-        stack.push(allocator.getVal(n.right.value()));
-    }
-  }
-
-  void draw_iteration_nodes()
-  {
-    word_t x_left   = clamp_to_width(iteration.left.norm);
-    word_t x_centre = clamp_to_width(iteration.centre.norm);
-    word_t x_right  = clamp_to_width(iteration.right.norm);
-    DrawLine(x_left, LINE_TOP, x_left, LINE_BOTTOM, BLUE);
-    DrawLine(x_right, LINE_TOP, x_right, LINE_BOTTOM, BLUE);
-    DrawLine(x_centre, LINE_TOP, x_centre, LINE_BOTTOM, GREEN);
-  }
-};
-
-using Clock = std::chrono::steady_clock;
-using Ms    = std::chrono::milliseconds;
-
-int main(void)
-{
-  // Setup state
-  State state{{1, 1}};
-
-  // Setup meta text (counter, iterations, etc)
-  word_t count = 1, prev_count = 0;
-  std::stringstream format_stream;
-  std::string format_str;
-  word_t format_str_width = 0;
-
-  // Setup timer
-  bool is_playing           = false;
-  auto time_current         = Clock::now();
-  auto time_previous        = time_current;
-  constexpr auto time_delta = 1;
-
-  InitWindow(WIDTH, HEIGHT, "Calkin-Wilf Tree");
-  while (!WindowShouldClose())
-  {
-    // timer logic
-    time_current = Clock::now();
-    if (is_playing &&
-        std::chrono::duration_cast<Ms>(time_current - time_previous).count() >=
-            time_delta)
-    {
-      time_previous = time_current;
-      state.do_iteration();
-      count += 2;
-    }
-
-    // Input logic
-    if (IsKeyDown(KEY_SPACE))
-    {
-      is_playing = true;
-    }
-    else if (IsKeyUp(KEY_SPACE))
-    {
-      is_playing = false;
-    }
-
-    if (IsKeyPressed(KEY_PERIOD))
-    {
-      state.do_iteration();
-      count += 2;
-    }
-
-    // Meta text logic
-    if (prev_count != count)
-    {
-      prev_count = count;
-      format_stream << "Count=" << count << "\n\n"
-                    << "Iterations=" << (count - 1) / 2 << "\n\n"
-                    << "Lower=" << to_string(state.bounds.leftmost.value)
-                    << "\n\n"
-                    << "Upper=" << to_string(state.bounds.rightmost.value);
-      format_str = format_stream.str();
-      format_stream.str("");
-      format_str_width = MeasureText(format_str.c_str(), FONT_SIZE * 2);
-    }
-
-    ClearBackground(BLACK);
-    BeginDrawing();
-    DrawLine(0, HEIGHT / 2, WIDTH, HEIGHT / 2, WHITE);
-    state.draw_nodes();
-    state.draw_bounds();
-    state.draw_iteration_nodes();
-    DrawText(format_str.c_str(), WIDTH / 2 - format_str_width / 2, HEIGHT / 8,
-             FONT_SIZE, WHITE);
-    EndDrawing();
-  }
-  CloseWindow();
-  return 0;
-}
-#endif
-
 /* Copyright (C) 2024, 2025 Aryadev Chavali
 
  * This program is distributed in the hope that it will be useful, but WITHOUT

src/state.cpp

@@ -22,7 +22,6 @@ namespace cw::state
       bounds.rightmost = state.allocator.get_val(bounds.rightmost.right);
     state.mutex.unlock();
 
-    bounds.lower_val = std::floorl(bounds.leftmost.value.norm);
     bounds.upper_val = std::ceill(bounds.rightmost.value.norm);
   }
 } // namespace cw::state

src/state.hpp

@@ -36,7 +36,11 @@ namespace cw::state
       f64 lower_val, upper_val;
     } bounds;
 
-    DrawState(State &state) : state{state} {};
+    DrawState(State &state) : state{state}
+    {
+      // lim n -> -∞
+      bounds.lower_val = 0;
+    };
 
     void compute_bounds(void);
   };

src/worker.hpp

@@ -13,12 +13,21 @@
 
 #include "state.hpp"
 
+#ifndef THREAD_PAUSE_MS
+#define THREAD_PAUSE_MS 1000
+#endif
+#ifndef THREAD_GENERAL_MS
+#define THREAD_GENERAL_MS 10
+#endif
+
 namespace cw::worker
 {
   using cw::node::NodeAllocator;
   using cw::state::State;
-  constexpr auto THREAD_PAUSE_DELAY   = std::chrono::milliseconds(1000);
+  constexpr auto THREAD_PAUSE_DELAY =
-  constexpr auto THREAD_GENERAL_DELAY = std::chrono::milliseconds(1);
+      std::chrono::milliseconds(THREAD_PAUSE_MS);
+  constexpr auto THREAD_GENERAL_DELAY =
+      std::chrono::milliseconds(THREAD_GENERAL_MS);
 
   // Performs a single iteration which consists of the following:
   // 1) pop an index off the iteration queue