implementing renderpass and vieport

src/Engine/Containers/List.h

@@ -2,207 +2,216 @@
 #include "MinimalEngine.h"
 namespace Seele
 {
-	template<typename T>
-	class List
+template <typename T>
+class List
+{
+private:
+	struct Node
+	{
+		Node *prev;
+		Node *next;
+		T data;
+	};
+
+public:
+	List()
+	{
+		root = nullptr;
+		tail = nullptr;
+		beginIt = Iterator(root);
+		endIt = Iterator(tail);
+		size = 0;
+	}
+	~List()
+	{
+		clear();
+	}
+	template <typename X>
+	class IteratorBase
 	{
-	private:
-		struct Node
-		{
-			Node* prev;
-			Node* next;
-			T data;
-		};
 	public:
-		List()
-		{
-			root = nullptr;
-			tail = nullptr;
-			beginIt = Iterator(root);
-			endIt = Iterator(tail);
-			size = 0;
-		}
-		~List()
-		{
-			clear();
-		}
-		template<typename X>
-		class IteratorBase {
-		public:
-			typedef std::forward_iterator_tag iterator_category;
-			typedef X value_type;
-			typedef std::ptrdiff_t difference_type;
-			typedef X& reference;
-			typedef X* pointer;
+		typedef std::forward_iterator_tag iterator_category;
+		typedef X value_type;
+		typedef std::ptrdiff_t difference_type;
+		typedef X &reference;
+		typedef X *pointer;
 
-			IteratorBase(Node* x = nullptr)
-				: node(x)
-			{}
-			IteratorBase(const IteratorBase& i)
-				: node(i.node)
-			{}
-			reference operator*() const
-			{
-				return node->data;
-			}
-			pointer operator->() const
-			{
-				return &node->data;
-			}
-			inline bool operator!=(const IteratorBase& other)
-			{
-				return node != other.node;
-			}
-			inline bool operator==(const IteratorBase& other)
-			{
-				return node == other.node;
-			}
-			IteratorBase& operator--() {
-				node = node->prev;
-				return *this;
-			}
-			IteratorBase operator--(int) {
-				IteratorBase tmp(*this);
-				--* this;
-				return tmp;
-			}
-			IteratorBase& operator++() {
-				node = node->next;
-				return *this;
-			}
-			IteratorBase operator++(int) {
-				IteratorBase tmp(*this);
-				++* this;
-				return tmp;
-			}
-		private:
-			Node* node;
-			friend class List<T>;
-		};
-		typedef IteratorBase<T> Iterator;
-		typedef IteratorBase<const T> ConstIterator;
+		IteratorBase(Node *x = nullptr)
+			: node(x)
+		{
+		}
+		IteratorBase(const IteratorBase &i)
+			: node(i.node)
+		{
+		}
+		reference operator*() const
+		{
+			return node->data;
+		}
+		pointer operator->() const
+		{
+			return &node->data;
+		}
+		inline bool operator!=(const IteratorBase &other)
+		{
+			return node != other.node;
+		}
+		inline bool operator==(const IteratorBase &other)
+		{
+			return node == other.node;
+		}
+		IteratorBase &operator--()
+		{
+			node = node->prev;
+			return *this;
+		}
+		IteratorBase operator--(int)
+		{
+			IteratorBase tmp(*this);
+			--*this;
+			return tmp;
+		}
+		IteratorBase &operator++()
+		{
+			node = node->next;
+			return *this;
+		}
+		IteratorBase operator++(int)
+		{
+			IteratorBase tmp(*this);
+			++*this;
+			return tmp;
+		}
 
-		T& front()
+	private:
+		Node *node;
+		friend class List<T>;
+	};
+	typedef IteratorBase<T> Iterator;
+	typedef IteratorBase<const T> ConstIterator;
+
+	T &front()
+	{
+		return root->data;
+	}
+	T &back()
+	{
+		return tail->prev->data;
+	}
+	void clear()
+	{
+		if (empty())
 		{
-			return root->data;
+			return;
 		}
-		T& back()
+		for (Node *tmp = root; tmp != tail;)
 		{
-			return tail->prev->data;
+			tmp = tmp->next;
+			delete tmp->prev;
 		}
-		void clear()
+		delete tail;
+		tail = nullptr;
+		root = nullptr;
+	}
+	//Insert at the end
+	Iterator add(const T &value)
+	{
+		if (root == nullptr)
 		{
-			if (empty())
-			{
-				return;
-			}
-			for (Node* tmp = root; tmp != tail;)
-			{
-				tmp = tmp->next;
-				delete tmp->prev;
-			}
-			delete tail;
-			tail = nullptr;
-			root = nullptr;
+			root = new Node();
+			tail = root;
 		}
-		//Insert at the end
-		Iterator add(const T& value)
+		tail->data = value;
+		Node *newTail = new Node();
+		newTail->prev = tail;
+		newTail->next = nullptr;
+		tail->next = newTail;
+		Iterator insertedElement(tail);
+		tail = newTail;
+		refreshIterators();
+		size++;
+		return insertedElement;
+	}
+	Iterator remove(Iterator pos)
+	{
+		size--;
+		Node *prev = pos.node->prev;
+		Node *next = pos.node->next;
+		if (prev == nullptr)
 		{
-			if (root == nullptr)
-			{
-				root = new Node();
-				tail = root;
-			}
-			tail->data = value;
-			Node* newTail = new Node();
-			newTail->prev = tail;
-			newTail->next = nullptr;
-			tail->next = newTail;
-			Iterator insertedElement(tail);
-			tail = newTail;
+			root = next;
+		}
+		else
+		{
+			prev->next = next;
+		}
+		next->prev = prev;
+		delete pos.node;
+		refreshIterators();
+		return Iterator(next);
+	}
+	Iterator insert(Iterator pos, const T &value)
+	{
+		size++;
+		if (root == nullptr)
+		{
+			root = new Node();
+			root->data = value;
+			tail = new Node();
+			root->next = tail;
+			root->prev = nullptr;
+			tail->prev = root;
+			tail->next = nullptr;
 			refreshIterators();
-			size++;
-			return insertedElement;
-		}
-		Iterator remove(Iterator pos)
-		{
-			size--;
-			Node* prev = pos.node->prev;
-			Node* next = pos.node->next;
-			if (prev == nullptr)
-			{
-				root = next;
-			}
-			else
-			{
-				prev->next = next;
-			}
-			next->prev = prev;
-			delete pos.node;
-			refreshIterators();
-			return Iterator(next);
-		}
-		Iterator insert(Iterator pos, const T& value)
-		{
-			size++;
-			if (root == nullptr)
-			{
-				root = new Node();
-				root->data = value;
-				tail = new Node();
-				root->next = tail;
-				root->prev = nullptr;
-				tail->prev = root;
-				tail->next = nullptr;
-				refreshIterators();
-				return beginIt;
-			}
-			Node* tmp = pos.node->prev;
-			Node* newNode = new Node();
-			newNode->data = value;
-			tmp->next = newNode;
-			newNode->prev = tmp;
-			newNode->next = pos.node;
-			pos.node->prev = newNode;
-			return Iterator(newNode);
-		}
-		Iterator find(const T& value)
-		{
-			for (Node* i = root; i != tail; i = i->next)
-			{
-				if (!(i->data < value) && !(value < i->data))
-				{
-					return Iterator(i);
-				}
-			}
-			return endIt;
-		}
-		bool empty()
-		{
-			return size == 0;
-		}
-		uint32 length()
-		{
-			return size;
-		}
-		Iterator begin()
-		{
 			return beginIt;
 		}
-		Iterator end()
+		Node *tmp = pos.node->prev;
+		Node *newNode = new Node();
+		newNode->data = value;
+		tmp->next = newNode;
+		newNode->prev = tmp;
+		newNode->next = pos.node;
+		pos.node->prev = newNode;
+		return Iterator(newNode);
+	}
+	Iterator find(const T &value)
+	{
+		for (Node *i = root; i != tail; i = i->next)
 		{
-			return endIt;
+			if (!(i->data < value) && !(value < i->data))
+			{
+				return Iterator(i);
+			}
 		}
+		return endIt;
+	}
+	bool empty()
+	{
+		return size == 0;
+	}
+	uint32 length()
+	{
+		return size;
+	}
+	Iterator begin()
+	{
+		return beginIt;
+	}
+	Iterator end()
+	{
+		return endIt;
+	}
 
-	private:
-		void refreshIterators()
-		{
-			beginIt = Iterator(root);
-			endIt = Iterator(tail);
-		}
-		Node* root;
-		Node* tail;
-		Iterator beginIt;
-		Iterator endIt;
-		uint32 size;
-	};
-}
+private:
+	void refreshIterators()
+	{
+		beginIt = Iterator(root);
+		endIt = Iterator(tail);
+	}
+	Node *root;
+	Node *tail;
+	Iterator beginIt;
+	Iterator endIt;
+	uint32 size;
+};
+} // namespace Seele