Reformat to folow style

src/Tree.cpp

@@ -4,6 +4,7 @@
 #include "Math.hpp"
 #include <cmath>
 
+// Public
 Tree::Tree(int size)
 {
   this->size = size;
@@ -11,7 +12,7 @@ Tree::Tree(int size)
   start.x = size / 2;
   start.y = size;
 
-  tree.assign(11, {0});
+  branches.assign(11, {0});
 }
 
 Tree::~Tree()
@@ -19,85 +20,90 @@ Tree::~Tree()
   UnloadRenderTexture(target);
 }
 
-void Tree::Draw(Rectangle dest)
+void Tree::draw(Rectangle dest, float rotation)
 {
   Rectangle source = {0, 0, (float)target.texture.width, (float)-target.texture.height};
   Vector2 origin = {0.0f, 0.0f};
-  DrawTexturePro(target.texture, source, dest, origin, 0.0f, WHITE);
+  DrawTexturePro(target.texture, source, dest, origin, rotation, WHITE);
 }
 
-Vector2 Tree::draw_line(Vector2 start, float angleDeg, float lenghth, int dep)
+void Tree::newTree()
 {
-  angleDeg += 180.0f;
-  float angle = (angleDeg * PI) / 180.0f;
-  float nx = lenghth * std::sin(angle);
-  float ny = lenghth * std::cos(angle);
-  Vector2 end = {start.x + nx, start.y + ny};
+  generateBranches();
+
+  BeginTextureMode(target);
+  ClearBackground(WHITE);
+  drawTree();
+  EndTextureMode();
+}
+
+// Private
+
+Vector2 Tree::drawLine()
+{
+  DrawArgs arg = draw_calls.front();
+
+  arg.angleDeg += 180.0f;
+  float angle = (arg.angleDeg * PI) / 180.0f;
+  float nx = arg.lenghth * std::sin(angle);
+  float ny = arg.lenghth * std::cos(angle);
+  Vector2 end = {arg.start.x + nx, arg.start.y + ny};
 
   float thick = 2.0;
-  float fstep = 1.0 / ((lenghth / thick) * 1.5);
+  float fstep = 1.0 / ((arg.lenghth / thick) * 1.5);
 
   for (float i = 0; i < 1; i += fstep)
   {
-    Vector2 point = Vector2Lerp(start, end, i);
-    Color color = ColorLerp(tree[dep - 1].color, tree[dep].color, i);
+    Vector2 point = Vector2Lerp(arg.start, end, i);
+    Color color = ColorLerp(branches[arg.dep - 1].color, branches[arg.dep].color, i);
     DrawCircleV(point, thick, color);
   }
   return end;
 }
 
-void Tree::draw_branch(draw_args arg)
+void Tree::drawBranch()
 {
+  DrawArgs arg = draw_calls.front();
   if (arg.dep >= MAX_DEPTH)
     return;
 
-  Vector2 next = draw_line(arg.start, arg.angleDeg, arg.lenghth, arg.dep);
+  Vector2 next = drawLine();
 
-  float next_len = tree[arg.dep].lenghthRatio;
-  float sectors = tree[arg.dep].numOfBranches + 1;
+  float next_len = branches[arg.dep].lenghthRatio;
+  float sectors = branches[arg.dep].numOfBranches + 1;
   float degres = 180.0f / sectors;
 
-  for (size_t i = 0; i < tree[arg.dep].numOfBranches; i++)
+  for (size_t i = 0; i < branches[arg.dep].numOfBranches; i++)
   {
     float newAngle = arg.angleDeg - 90 + (degres * (i + 1));
-    draw_calls.push_back((draw_args){next, newAngle, arg.lenghth * next_len, arg.dep + 1});
+    draw_calls.push_back((DrawArgs){next, newAngle, arg.lenghth * next_len, arg.dep + 1});
   }
 }
 
-void Tree::draw_tree(draw_args first)
+void Tree::drawTree()
 {
-  draw_calls.push_back(first);
+  draw_calls.push_back((DrawArgs){start, 0, size / 4, 1});
 
   while (!draw_calls.empty())
   {
-    draw_branch(draw_calls.front());
+    drawBranch();
     draw_calls.pop_front();
   }
 }
 
-void Tree::generate_tree()
+void Tree::generateBranches()
 {
   for (size_t i = 0; i < MAX_DEPTH; i++)
   {
     uint8_t r = GetRandomValue(0, 255);
     uint8_t g = GetRandomValue(0, 255);
     uint8_t b = GetRandomValue(0, 255);
-    tree[i].color = (Color){r, g, b, 255};
+    branches[i].color = (Color){r, g, b, 255};
 
-    tree[i].numOfBranches = GetRandomValue(1, 3);
+    branches[i].numOfBranches = GetRandomValue(1, 3);
 
-    tree[i].lenghthRatio = ((float)GetRandomValue(600, 700)) / 1000.0f;
+    branches[i].lenghthRatio = ((float)GetRandomValue(600, 700)) / 1000.0f;
   }
 
-  tree[0].color = tree[1].color;
+  branches[0].color = branches[1].color;
 }
-
-void Tree::new_tree()
-{
-  generate_tree();
-
-  BeginTextureMode(target);
-  ClearBackground(WHITE);
-  draw_tree((draw_args){start, 0, size / 4, 1});
-  EndTextureMode();
-}