General improvements

Author: Alessio Linares

Color.h

@@ -0,0 +1,35 @@
+#ifndef HB_COLOR_h
+#define HB_COLOR_h
+
+namespace hb
+{
+	struct Color {
+		float r;
+		float g;
+		float b;
+		float a;
+
+		Color() {
+			this->r = 0.0f;
+			this->g = 0.0f;
+			this->b = 0.0f;
+			this->a = 1.0f;
+		}
+
+		Color(float r, float g, float b, float a = 1.0f) {
+			this->r = r;
+			this->g = g;
+			this->b = b;
+			this->a = a;
+		}
+
+		Color(int r, int g, int b, int a = 255) {
+			this->r = (float)r/255.0f;
+			this->g = (float)g/255.0f;
+			this->b = (float)b/255.0f;
+			this->a = (float)a/255.0f;
+		}
+	};
+}
+
+#endif

FunctionComponent.cpp

@@ -0,0 +1,45 @@
+#include "FunctionComponent.h"
+using namespace hb;
+
+FunctionComponent::FunctionComponent()
+{
+	m_pre_update = [&] (GameObject*) {};
+	m_update = [&] (GameObject*) {};
+	m_post_update = [&] (GameObject*) {};
+}
+
+
+void FunctionComponent::setPreUpdateFunction(std::function<void(GameObject*)> pre_update)
+{
+	m_pre_update = pre_update;
+}
+
+
+void FunctionComponent::setUpdateFunction(std::function<void(GameObject*)> update)
+{
+	m_update = update;
+}
+
+
+void FunctionComponent::setPostUpdateFunction(std::function<void(GameObject*)> post_update)
+{
+	m_post_update = post_update;
+}
+
+
+void FunctionComponent::preUpdate()
+{
+	m_pre_update(getGameObject());
+}
+
+
+void FunctionComponent::update()
+{
+	m_update(getGameObject());
+}
+
+
+void FunctionComponent::postUpdate()
+{
+	m_post_update(getGameObject());
+}

FunctionComponent.h

@@ -0,0 +1,25 @@
+#ifndef HB_FUNCTION_COMPONENT_H
+#define HB_FUNCTION_COMPONENT_H
+#include <functional>
+#include "GameObject.h"
+
+namespace hb
+{
+	class FunctionComponent : public GameObject::Component
+	{
+	public:
+		FunctionComponent();
+		void setPreUpdateFunction(std::function<void(GameObject*)> pre_update);
+		void setUpdateFunction(std::function<void(GameObject*)> update);
+		void setPostUpdateFunction(std::function<void(GameObject*)> post_update);
+		virtual void preUpdate() override;
+		virtual void update() override;
+		virtual void postUpdate() override;
+
+	private:
+		std::function<void(GameObject*)> m_pre_update;
+		std::function<void(GameObject*)> m_update;
+		std::function<void(GameObject*)> m_post_update;
+	};
+}
+#endif

GameObject.cpp

@@ -27,6 +27,7 @@ std::vector<GameObject*> GameObject::getGameObjectsByName(const std::string& nam
 	return v;
 }
 
+
 void GameObject::destroyAll()
 {
 	std::vector<std::pair<int, GameObject*>> v(s_game_objects_by_id.begin(), s_game_objects_by_id.end());
@@ -63,18 +64,23 @@ void GameObject::updateAll()
 }
 
 
-GameObject::GameObject(const Vector3d& init_pos):
-Transform(init_pos),
+GameObject::GameObject():
+Transform(),
 m_marked_to_destroy(false)
 {
-	m_identifier = s_game_object_identifier++;	
+	m_identifier = s_game_object_identifier++;
 	s_game_objects_by_id.insert(std::pair<int, GameObject*>(m_identifier, this));
 }
 
 
-GameObject::GameObject():
-GameObject(Vector3d())
-{}
+GameObject::GameObject(std::initializer_list<GameObject::Component*> components):
+GameObject()
+{
+	for (Component* c : components)
+	{
+		addComponent(c);
+	}
+}
 
 
 GameObject::~GameObject()
@@ -186,5 +192,6 @@ void GameObject::destroy()
 void GameObject::addComponent(Component* component)
 {
 	m_components.push_back(component);
-	m_components[m_components.size() - 1]->setGameObject(this);
+	component->setGameObject(this);
+	component->init();
 }

GameObject.h

@@ -3,8 +3,9 @@
 #include <vector>
 #include <string>
 #include <unordered_map>
+#include <initializer_list>
 #include "Transform.h"
-
+// TODO: Add to game object a std::unordered_map<std::string, union{.....}> to store gameobject variables. Make getters too.
 namespace hb
 {
 	class GameObject : public Transform
@@ -20,6 +21,7 @@ namespace hb
 				m_relative = true;
 			}
 			inline virtual ~Component(){}
+			virtual void init(){}
 			virtual void preUpdate(){}
 			virtual void update(){}
 			virtual void postUpdate(){}
@@ -56,7 +58,7 @@ namespace hb
 		static void updateAll();
 
 		GameObject();
-		GameObject(const Vector3d& init_pos);
+		GameObject(std::initializer_list<Component*> components);
 		virtual ~GameObject();
 		int getIdentifier() const;
 		const std::string& getName() const;
@@ -67,6 +69,16 @@ namespace hb
 		void destroy();
 		void addComponent(Component* component);
 		template <typename ComponentType>
+		ComponentType* getComponent() const
+		{
+			for (Component* component : m_components)
+			{
+				if (dynamic_cast<ComponentType*>(component))
+					return dynamic_cast<ComponentType*>(component);
+			}
+			return nullptr;
+		}
+		template <typename ComponentType>
 		std::vector<ComponentType*> getComponents() const
 		{
 			std::vector<ComponentType*> v;

Makefile

@@ -1,5 +1,4 @@
 CC        := g++
-ARCH      := $(shell getconf LONG_BIT)
 
 CFLAGS    := -std=c++11 -Wall
 

Resource.h

@@ -0,0 +1,46 @@
+#ifndef HB_RESOURCE_H
+#define HB_RESOURCE_H
+
+
+namespace hb
+{
+	template <typename ResourceType, typename ResourceId, typename ResourceManager>
+	class Resource
+	{
+	public:
+		Resource(const ResourceType& resource, const ResourceId& id)
+		{
+			m_id = ResourceManager::instance()->addResource(id, resource);
+		}
+		Resource(const Resource& other)
+		{
+			m_id = ResourceManager::instance()->addResource(other.id(), other.get());
+		}
+		Resource& operator=(const Resource& other)
+		{
+			m_id = ResourceManager::instance()->addResource(other.id(), other.get());
+			return *this;
+		}
+		~Resource()
+		{
+			ResourceManager::instance()->release(m_id);
+		}
+
+		const ResourceType& get() const
+		{
+			return ResourceManager::instance()->get(m_id);
+		}
+		ResourceType& get()
+		{
+			return ResourceManager::instance()->get(m_id);
+		}
+		const ResourceId& id() const
+		{
+			return ResourceManager::instance()->getId(m_id);
+		}
+	
+	protected:
+		int m_id;
+	};
+}
+#endif

ResourceManager.h

@@ -5,10 +5,17 @@
 
 namespace hb
 {
-	template <typename Resource, typename ResourceId, typename Hash = std::hash<ResourceId>>
+	template <typename ManagerType, typename Resource, typename ResourceId, typename Hash = std::hash<ResourceId>>
 	class ResourceManager
 	{
 	public:
+
+		static ManagerType* instance()
+		{
+			if (s_instance == nullptr)
+				s_instance = new ManagerType();
+			return s_instance;
+		}
 		// Constructor
 		ResourceManager()
 		{
@@ -39,7 +46,7 @@ namespace hb
 			return ret;
 		}
 		// Release a Resource resource with identifier id
-		void release(int id)
+		virtual void release(int id)
 		{
 			auto i = m_info_table.find(id);
 			if (i == m_info_table.end())
@@ -66,7 +73,23 @@ namespace hb
 		// Get Resource with identifier id
 		const Resource& get(int id) const
 		{
-			return m_info_table.find(id)->second.data;
+			auto it = m_info_table.find(id);
+			assert(it != m_info_table.end());
+			return it->second.data;
+		}
+		// Get Resource with identifier id
+		Resource& get(int id)
+		{
+			auto it = m_info_table.find(id);
+			assert(it != m_info_table.end());
+			return it->second.data;
+		}
+		// Get ResourceId of resource with identifier id 
+		const ResourceId& getId(int id) const
+		{
+			auto it = m_info_table.find(id);
+			assert(it != m_info_table.end());
+			return it->second.it->first;
 		}
 		// Returns wether the Resource resource with identifier id is loaded
 		bool isLoaded(int id) const
@@ -81,13 +104,22 @@ namespace hb
 		// Returns number of active requests for resource id
 		int countResourceUsage(int id) const
 		{
-			return m_info_table.find(id)->second.count;
+			int count = 0;
+			auto it = m_info_table.find(id);
+			if (it != m_info_table.end())
+				count = it->second.count;
+			return count;
 		}
-		// Returns total number of resources loaded
+		// Returns number of resources currently loaded
 		int size() const
 		{
 			return m_id_table.size();
 		}
+		// Returns number of all resources ever loaded
+		int resourceCount() const
+		{
+			return m_resource_count;
+		}
 		// Release all resources
 		void clear()
 		{
@@ -97,6 +129,7 @@ namespace hb
 		}
 
 	private:
+		static ManagerType* s_instance;
 		struct ResourceInfo
 		{
 			int id, count;
@@ -109,4 +142,6 @@ namespace hb
 		std::unordered_map<int, ResourceInfo> m_info_table;
 	};
 }
+template <typename ManagerType, typename Resource, typename ResourceId, typename Hash>
+ManagerType* hb::ResourceManager<ManagerType, Resource, ResourceId, Hash>::s_instance = nullptr;
 #endif

Vector2d.cpp

@@ -81,4 +81,9 @@ Vector2d& operator /=(Vector2d& left, double right)
 bool operator ==(const Vector2d& left, const Vector2d& right)
 {
 	return (left.x == right.x and left.y == right.y);
+}
+
+bool operator !=(const Vector2d& left, const Vector2d& right)
+{
+	return not (left.x == right.x and left.y == right.y);
 }

Vector2d.h

@@ -1,5 +1,6 @@
 #ifndef HB_VECTOR_2D_H
 #define HB_VECTOR_2D_H
+#include <cmath>
 
 namespace hb
 {
@@ -10,6 +11,21 @@ namespace hb
 		Vector2d(): x(0), y(0){};
 		Vector2d(double x, double y): x(x), y(y){};
 		Vector2d(const Vector2d& v): x(v.x), y(v.y){};
+
+		double module() const
+		{return sqrt(pow(x, 2) + pow(y, 2));}
+
+		Vector2d normalized() const
+		{
+			Vector2d v = *this;
+			double module = this->module();
+			if (module != 0.)
+			{
+				v.x /= module;
+				v.y /= module;
+			}
+			return v;
+		}
 	};
 
 }
@@ -25,4 +41,5 @@ hb::Vector2d& operator *=(hb::Vector2d& left, double right);
 hb::Vector2d operator /(const hb::Vector2d& left, double right);
 hb::Vector2d& operator /=(hb::Vector2d& left, double right);
 bool operator ==(const hb::Vector2d& left, const hb::Vector2d& right);
+bool operator !=(const hb::Vector2d& left, const hb::Vector2d& right);
 #endif