Timing

shared/inc/canvas/Canvas.hpp

@@ -13,7 +13,6 @@ public:
   void newGen(RenderTexture2D &target, Dna *dna);
   bool tick(RenderTexture2D &target);
 
-private:
   BackGround backGround;
   Tree tree;
 };

shared/inc/canvas/Tree.hpp

@@ -23,6 +23,7 @@ public:
   void init(int size);
   void draw(Dna *dna);
   bool tick();
+  uint64_t circles;
 
 private:
   Dna *m_dna;
@@ -34,7 +35,8 @@ private:
 
   void calculateBranch();
 
-  void drawBranch(Vector2 startPoint, Vector2 endPoint, Color startColor, Color endColor, float startThickness, float endThickness);
+  void drawBranch_rlTriangle(Vector2 startPoint, Vector2 endPoint, Color startColor, Color endColor, float startThickness, float endThickness, float length);
+  void drawBranch_circles(Vector2 startPoint, Vector2 endPoint, Color startColor, Color endColor, float startThickness, float endThickness, float length);
   inline size_t getNumOfBranches(int dep);
   inline Color getStartColor(DrawArgs &arg);
   inline Color getEndColor(int dep, Color &start);

shared/inc/timing.hpp

@@ -0,0 +1,18 @@
+
+#include <chrono>
+
+
+struct Timer
+{
+  std::chrono::steady_clock::time_point start_t;
+  std::chrono::steady_clock::time_point end_t;
+  std::chrono::nanoseconds dur;
+  void start();
+  void stop();
+  void reset();
+  void print(const char * str);
+  void stop_and_print(const char * str);
+  void reset_and_start();
+};
+
+

shared/src/canvas/Canvas.cpp

@@ -1,4 +1,5 @@
 #include "canvas/Canvas.hpp"
+#include "timing.hpp"
 
 void Canvas::init(int size)
 {
@@ -6,8 +7,13 @@ void Canvas::init(int size)
   tree.init(size);
 }
 
+bool finished = false;
+Timer timer;
 void Canvas::newGen(RenderTexture2D &target, Dna *dna)
 {
+
+  finished = false;
+  timer.reset_and_start();
   BeginTextureMode(target);
   ClearBackground(WHITE);
 
@@ -15,13 +21,20 @@ void Canvas::newGen(RenderTexture2D &target, Dna *dna)
   tree.draw(dna);
 
   EndTextureMode();
+  timer.stop();
 }
 
 bool Canvas::tick(RenderTexture2D &target)
 {
+  timer.start();
   BeginTextureMode(target);
   bool ret = tree.tick();
   EndTextureMode();
+  timer.stop();
+  if(ret && !finished){
+    finished = true;
+    timer.print("to draw canvas");
+  }
   return ret;
 }
 

shared/src/canvas/Tree.cpp

@@ -1,12 +1,13 @@
 #include <cmath>
 
 #include "canvas/Tree.hpp"
+#include "timing.hpp"
 
 #include <raylib.h>
 #include <raymath.h>
 #include <rlgl.h>
 
-#define ITER_PER_FRAME 5000
+#define ITER_PER_FRAME 10000
 
 constexpr int maxColorChange = 15;
 constexpr int minColorChange = -15;
@@ -46,22 +47,23 @@ void Tree::init(int size)
 
 void Tree::draw(Dna *dna)
 {
+  circles = 0;
   m_dna = dna;
   branchSeed = dna->branchSeed;
   drawCalls.push_back({start, 180.0f, 0});
-  tick();
 }
 
 bool Tree::tick()
 {
-  size_t i = 0;
-  while (!drawCalls.empty())
+  using namespace std::chrono;
+  auto start = steady_clock::now();
+  nanoseconds dur = 0us;
+  while (!drawCalls.empty() && dur < 14ms)
   {
     calculateBranch();
     drawCalls.pop_front();
-    i++;
-    if (i >= ITER_PER_FRAME)
-      break;
+    auto end = steady_clock::now();
+    dur = end - start;
   }
 
   return drawCalls.empty();
@@ -83,20 +85,13 @@ void Tree::calculateBranch()
 
   int sizeStart = getStartSize(arg);
   int sizeEnd = getEndSize(arg, sizeStart);
-  float fstep = 1.0 / ((length / sizeStart) * 2.0f);
 
   Color colorStart = getStartColor(arg);
   Color colorEnd = getEndColor(arg.dep, colorStart);
-  // drawBranch(arg.start, end, colorStart, colorEnd, sizeStart, sizeEnd);
-  for (float i = 0; i < 1; i += fstep)
-  {
-    Vector2 point = Vector2Lerp(arg.start, end, i);
-    Color color = ColorLerp(colorStart, colorEnd, i);
-    int size = Lerp(sizeStart, sizeEnd, i);
-    DrawCircleV(point, size, color);
-    // DrawTextureEx(texBunny, point,0, ((float)size) / texBunny.height, color);
-  }
-
+  // drawBranch_rlTriangle(arg.start, end, colorStart, colorEnd, sizeStart, sizeEnd, length);
+  drawBranch_circles(arg.start, end, colorStart, colorEnd, sizeStart, sizeEnd, length);
+  // DrawLineEx(arg.start, end, sizeStart, colorStart);
+  
   // add more branches to draw
 
   if (arg.dep + 1 >= MAX_DEPTH)
@@ -114,6 +109,7 @@ void Tree::calculateBranch()
 
 inline size_t Tree::getNumOfBranches(int dep)
 {
+  return 3;
   if (m_dna->branches[dep].branchCount < 128)
     return 2;
   else
@@ -163,7 +159,7 @@ inline int Tree::getStartSize(DrawArgs &arg)
   float mixLevel = m_dna->branches[arg.dep].sizeLevel / 255.0f;
   size = std::lerp(size, sizes[MAX_DEPTH - arg.dep - 1], mixLevel);
 
-  if (size < 1)
+  //if (size < 1)
     size = 1;
   return size;
 }
@@ -173,7 +169,7 @@ inline int Tree::getEndSize(DrawArgs &arg, int start)
   int size = Remap(m_dna->branches[arg.dep].sizeChange, 0, 255, MinSizeChange, maxSizeChange);
   size += start;
 
-  if (size < 1)
+  //if (size < 1)
     size = 1;
   return size;
 }
@@ -181,9 +177,9 @@ inline int Tree::getEndSize(DrawArgs &arg, int start)
 inline float Tree::getLength(DrawArgs &arg)
 {
   float lenght = lengths[arg.dep];
-  float lenghtRatio = Remap(m_dna->branches[arg.dep].length, 0, 255, 0.5f, 1.3f);
+  float lenghtRatio = Remap(255, 0, 255, 0.5f, 1.3f);
   lenght *= lenghtRatio;
-  float lenghtVar = Remap(m_dna->branches[arg.dep].lengthVar, 0, 255, -0.15f, 0.15f);
+  float lenghtVar = Remap(255, 0, 255, -0.15f, 0.15f);
   lenght += lenght * lenghtVar * mrand::getFloat(&branchSeed);
   if (lenght < 1)
     lenght = 1;
@@ -199,15 +195,28 @@ inline float Tree::getAngleVar(DrawArgs &arg)
   return angleVar;
 }
 
-void Tree::drawBranch(Vector2 startPoint, Vector2 endPoint, Color startColor, Color endColor, float startThickness, float endThickness)
+void Tree::drawBranch_circles(Vector2 startPoint, Vector2 endPoint, Color startColor, Color endColor, float startThickness, float endThickness, float length)
+{ 
+
+  float fstep = 1.0 / ((length / startThickness) * 2.0f);
+  for (float i = 0; i < 1; i += fstep)
+  {
+    Vector2 point = Vector2Lerp(startPoint, endPoint, i);
+    Color color = ColorLerp(startColor, endColor, i);
+    int size = Lerp(startThickness, endThickness, i);
+    DrawCircleV(point, size, color);
+    circles++;
+  }
+}
+
+void Tree::drawBranch_rlTriangle(Vector2 startPoint, Vector2 endPoint, Color startColor, Color endColor, float startThickness, float endThickness, float length)
 {
+  DrawCircleV(startPoint, startThickness, startColor);
+  DrawCircleV(endPoint, endThickness, endColor);
   // Calculate the direction vector from startPoint to endPoint
   Vector2 direction = {endPoint.x - startPoint.x, endPoint.y - startPoint.y};
 
   // Normalize the direction vector
-  float length = sqrtf(direction.x * direction.x + direction.y * direction.y);
-  if (length == 0)
-    length = 1; // Avoid division by zero
   Vector2 normalizedDir = {direction.x / length, direction.y / length};
 
   // Calculate the perpendicular vector (rotate 90 degrees)

shared/src/timing.cpp

@@ -0,0 +1,42 @@
+#include <raylib.h>
+#include <chrono>
+#include "timing.hpp"
+
+using namespace std::chrono;
+
+void Timer::start()
+{
+  start_t = std::chrono::steady_clock::now();
+}
+
+void Timer::stop()
+{
+  end_t = std::chrono::steady_clock::now();
+  dur += end_t - start_t;
+}
+
+void Timer::reset()
+{
+  dur = 0ns;
+}
+
+void Timer::print(const char * str)
+{
+  auto s = std::chrono::duration_cast<std::chrono::milliseconds>(dur);
+  if (s > 1000us)
+  {
+    TraceLog(LOG_INFO, "%ld ms %s", s.count(), str);
+  }
+}
+
+void Timer::stop_and_print(const char *str)
+{
+  stop();
+  print(str);
+}
+
+void Timer::reset_and_start()
+{
+  reset();
+  start();
+}