CMDS

full_code/Space_Partitioning_Engine/Core/AABBTree.h

@@ -43,6 +43,7 @@ struct AABBNode
 	AABBNode();
 	~AABBNode();
 
+	//Initialize node data
 	void Init(AABBTree*, AABBNode*, int, int, int, int);
 
 	//Min and Max node positions that construct the rect
@@ -67,21 +68,28 @@ struct AABBNode
 
 	void SetRect(int, int, int, int);
 
+	//Returns the node rect
 	Rect GetRect() 
 	{ 
 			return {minPos.x, minPos.y, maxPos.x - minPos.x, maxPos.y - minPos.y};
 	}
+
+	//Returns a pointer to the node data list
 	std::list<Entity*>* GetData() 
 	{
 		return &data;
 	}
+
+	//Returns a copy of the node data list
 	std::list<Entity*> GetDataValue() 
 	{
 		return data;
 	}
 
-	//Updates the node points (min and max) with the data elements
+	//Updates the node min and max positions
 	void UpdateNode();
+
+	//Creates a node subdivision and distributes the old node data
 	static void SubDivide(AABBNode&);
 };
 
@@ -99,19 +107,25 @@ class AABBTree
 	//Display variable, debug info won't be rendered if this is false
 	bool displayTree;
 
-
+	//Initialize tree data
 	void Init(int, int, int, int);
-	//Adds a unit to the tree and manages subdivisions
+
+	//Adds a unit to the tree by positions and manages subdivisions
 	void AddUnitToTree(Entity&);
 
+	//Updates all tree nodes with recursivity
 	void UpdateAllNodes(AABBNode& node);
+
+	//Returns a pointer to the lowest node inside a point
 	AABBNode* FindLowestNodeInPoint(AABBNode*, const Point);
 
+	//Loads all the leaves in a list
 	void LoadLeavesToList(AABBNode*, std::list<AABBNode*>&);
-	void LoadLeafNodesInsideRect(AABBNode*, std::vector<AABBNode*>&, Rect& collider);
 
-	void DeleteDataElement(AABBNode&, Entity*);
+	//Loads all leaves inside the rect
+	void LoadLeafNodesInsideRect(AABBNode*, std::vector<AABBNode*>&, Rect& collider);
 
+	//Deletes the tree if it’s a pointer
 	void Clear();
 
 };

full_code/Space_Partitioning_Engine/Core/MaykMath.h

@@ -35,16 +35,19 @@ struct Point
 {
 	int x = 0, y = 0;
 
+	//Overrides the operator* to allow dot product between Points
 	float operator*(Point const &b) 
 	{
 		return (x * b.x) + (y * b.y);
 	}
 
+	//Returns the Manhattan distance between two points
 	float DistanceManhattan(const Point& v) const
 	{
 		return ABS(v.x - x) + ABS(v.y - y);
 	}
 
+	//Returns true if X and Y are equal to 0
 	bool IsZero() 
 	{
 		return (x == 0 && y == 0);
@@ -55,6 +58,7 @@ struct Rect
 {
 	int x = 0, y = 0, w = 0, h = 0;
 
+	//Returns the rect’s central point
 	Point GetCentralPoint() 
 	{
 		return {x + w / 2, y + h / 2};
@@ -83,13 +87,25 @@ struct Vector4
 
 namespace MaykMath
 {
+	//Calculate a vector from two points and invert the Y (we need this for OA detection)
 	Point NegatedYVectorFromPoints(Point, Point);
+
+	//Calculate and return the area of any triangle
 	float GetTriangleArea(Point, Point, Point);
+
+	//Returns true if the Point is inside an OA rectangle
 	bool IsPointInsideOffAxisRectangle(Point, Point, Point, Point, Point);
+
+	//Returns true is the point is inside the AA rectangle
 	bool IsPointInsideAxisAlignedRectangle(Rect, Point);
+
+	//Returns true if the input rects are overlaping
 	bool CheckRectCollision(const Rect&, const Rect&);
 
+	//Returns a Point with the minimum values of the two input Points
 	Point GetMinPoint(Point, Point);
+
+	//Returns a Point with the maximum values of the two input Points
 	Point GetMaxPoint(Point, Point);
 }
 

full_code/Space_Partitioning_Engine/Core/QuadTree.h

@@ -41,6 +41,7 @@ struct QuadNode
 	QuadNode();
 	~QuadNode();
 
+	//Initialize node data
 	void Init(QuadTree*, QuadNode*, int, int, int, int);
 
 	//Positions
@@ -58,11 +59,16 @@ struct QuadNode
 	//Data
 	std::list<Entity*> data;
 
+	//Sets the rect info
 	void SetRect(int&, int&, int&, int&);
 
+	//Returns the node rect
 	Rect GetRect() { return {x, y, w, h}; };
+
+	//Return a pointer to the data list
 	const std::list<Entity*>* GetContent() { return &data; }
 
+	//Subdivides the tree X number of times
 	static void SubDivide(QuadNode&, int);
 };
 
@@ -73,6 +79,7 @@ class QuadTree
 	QuadTree();
 	~QuadTree();
 
+	//Initialize tree data
 	void Init(TreeType, int, int, int, int);
 
 	QuadNode baseNode;
@@ -85,15 +92,22 @@ class QuadTree
 	int lowest_height = 0;
 	QuadNode* lowestNode = nullptr;
 
+	//Adds an entity to the tree by positions and manages subdivisions
 	void AddEntityToNode(Entity&, Point);
 
+	//Loads all nodes overlaping with the point in a list
 	void LoadNodesToList(std::list<QuadNode*>*, QuadNode*, Point, Point);
+
+	//Finds the leaf inside a point
 	void FindLowestNodeInPoint(QuadNode*, const Point&);
 
+	//Checks off axis rect overlap
 	static bool CheckNodeOverLap(Rect, Rect);
+
+	//Transforms input to isometric space
 	static Point CoordsToIsometricInt(Point, Point);
 
-	//Delete and free all the tree memory
+	//Deletes the tree if it’s a pointer
 	void Clear();
 
 };