tmp

Modules/public/Module.hpp

@@ -30,6 +30,4 @@ namespace tp {
 		uhalni mInitCount = 0;
 		void* mCustomData = nullptr;
 	};
-
-	extern ModuleManifest gModuleBase;
 };

Modules/public/Sorting.hpp

@@ -0,0 +1,95 @@
+
+#pragma once
+
+#include "Utils.hpp"
+
+namespace tp {
+
+	template <typename Type>
+	inline bool compare(const Type& val1, const Type& val2) {
+		return val1 > val2;
+	}
+
+	struct SortMerge {
+
+		template <typename Type>
+		static void sort(Type* buff, int length, bool (*grater)(const Type& obj1, const Type& obj2) = &compare) {
+			mergeSort(buff, 0, length - 1, grater);
+		}
+
+	private:
+		template <typename Type>
+		static void merge(Type* buff, int left, int middle, int right, bool (*grater)(const Type& obj1, const Type& obj2)) {
+			int n1 = middle - left + 1;
+			int n2 = right - middle;
+
+			Type* Left = new Type[n1];
+			Type* Right = new Type[n2];
+
+			for (int i = 0; i < n1; i++) {
+				Left[i] = buff[left + i];
+			}
+
+			for (int j = 0; j < n2; j++) {
+				Right[j] = buff[middle + 1 + j];
+			}
+
+			int i = 0;
+			int j = 0;
+			int k = left;
+
+			while (i < n1 && j < n2) {
+				if (!(grater(Left[i], Right[j]))) {
+					buff[k] = Left[i];
+					i++;
+				} else {
+					buff[k] = Right[j];
+					j++;
+				}
+				k++;
+			}
+
+			while (i < n1) {
+				buff[k] = Left[i];
+				i++;
+				k++;
+			}
+
+			while (j < n2) {
+				buff[k] = Right[j];
+				j++;
+				k++;
+			}
+
+			delete[] Left;
+			delete[] Right;
+		}
+
+		template <typename Type>
+		static void mergeSort(Type* buff, int left, int right, bool (*grater)(const Type& obj1, const Type& obj2)) {
+
+			if (left >= right) {
+				return;
+			}
+
+			int middle = left + (right - left) / 2;
+
+			mergeSort(buff, left, middle, grater);
+			mergeSort(buff, middle + 1, right, grater);
+			merge(buff, left, middle, right, grater);
+		}
+	};
+
+	struct SortInsert {
+		template <typename Type>
+		static void sort(Type* buff, int length, bool (*grater)(const Type& obj1, const Type& obj2) = &compare) {
+			for (int i = 0; i < length; i++) {
+				for (int j = i + 1; j < length; j++) {
+					if (grater(*buff[i], *buff[j])) {
+						swap(buff[i], buff[j]);
+					}
+				}
+			}
+		}
+	};
+}

Modules/public/Timing.hpp

@@ -0,0 +1,58 @@
+#pragma once
+
+#include "Environment.hpp"
+
+namespace tp {
+
+	typedef alni time_ms;
+	typedef alni time_ns;
+
+	extern time_ms gCurrentTime;
+
+	class Timer {
+
+		time_ms mStart;
+		time_ms mDuration;
+
+	public:
+		Timer();
+		explicit Timer(time_ms time);
+
+		time_ms start();
+		time_ms duration();
+		void setDuration(time_ms dur);
+
+		bool isTimeout();
+		void reset();
+		time_ms timePassed();
+		time_ms remainder();
+		void wait();
+
+		float easeIn(time_ms duration = 0);
+		float easeOut(time_ms duration = 0);
+	};
+
+	void sleep(time_ms duration);
+	time_ms get_time();
+
+	struct FpsCounter {
+		halni frames = 0;
+		Timer time;
+		halni fps = 0;
+
+		FpsCounter() :
+			time(1000) {}
+
+		void update(bool log = true) {
+			frames++;
+			if (time.isTimeout()) {
+				fps = frames;
+				if (log) {
+					// printf("fps %i \n", fps);
+				}
+				frames = 0;
+				time.reset();
+			}
+		}
+	};
+}

Modules/public/Utils.hpp

@@ -0,0 +1,96 @@
+#pragma once
+
+#include "Module.hpp"
+
+#define PTR_OFFSET(first, offset) (*((&first) + offset))
+#define MEMBER_OFFSET(s, m) (alni(&(((s*) 0)->m)))
+
+namespace tp {
+	void memSetVal(void* p, uhalni byteSize, uint1 val);
+	void memCopy(void* left, const void* right, uhalni len);
+	int1 memCompare(const void* left, const void* right, uhalni len);
+	bool memEqual(const void* left, const void* right, uhalni len);
+	int1 memCompareVal(const void* left, uhalni len, uint1 val);
+}
+
+namespace tp {
+	[[nodiscard]] alnf randomFloat();
+}
+
+namespace tp {
+
+	template <typename Type = alni>
+	class Bits {
+		Type mFlags = 0;
+
+	public:
+		Bits() = default;
+
+		explicit Bits(Type val) { mFlags = val; }
+
+		explicit Bits(bool val) {
+			for (int bit = 0; bit < sizeof(Type); bit++) {
+				set(bit, val);
+			}
+		}
+
+		bool get(int1 idx) { return mFlags & (1l << idx); }
+
+		void set(int1 idx, bool val) {
+			if (val) {
+				mFlags |= (1l << idx);
+			} else {
+				mFlags &= ~(1l << idx);
+			}
+		}
+	};
+
+	template <typename tType = ualni>
+	class Range {
+	public:
+		class Iterator {
+		public:
+			tType mIndex;
+
+			explicit Iterator(tType pStartIndex) :
+				mIndex(pStartIndex) {}
+
+			tType index() const { return mIndex; }
+
+			inline void operator++() { mIndex++; }
+
+			inline operator tType() const { return mIndex; }
+
+			inline bool operator==(Iterator pIndex) { return mIndex == pIndex.mIndex; }
+
+			inline bool operator!=(Iterator pIndex) { return mIndex != pIndex.mIndex; }
+
+			inline const Iterator& operator*() { return *this; }
+		};
+
+		tType mBegin{};
+		tType mEnd{};
+
+		Range() = default;
+
+		explicit Range(tType pEndIndex) :
+			mBegin(0),
+			mEnd(pEndIndex) {}
+
+		Range(tType pStartIndex, tType pEndIndex) :
+			mBegin(pStartIndex),
+			mEnd(pEndIndex) {}
+
+		bool valid() const { return mBegin < mEnd; }
+
+		tType idxBegin() const { return mBegin; }
+
+		tType idxEnd() const { return mEnd; }
+
+		tType idxDiff() const { return mEnd - mBegin; }
+
+		Iterator begin() const { return Iterator(mBegin); }
+
+		Iterator end() const { return Iterator(mEnd); }
+	};
+}