Stuff?

Backup_SQLite.txt

@@ -0,0 +1,60 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+DLL_METHOD int sqlite3_bind_int64_ex(void* stmtPtr, uint32_t index, uint32_t low, uint32_t high) {
+	return sqlite3_bind_int64((sqlite3_stmt*)stmtPtr, index, (((uint64_t)low << 32) + (uint64_t)high));
+}
+#pragma comment(linker, "/EXPORT:sqlite3_bind_int64_ex=_sqlite3_bind_int64_ex@16")
+
+DLL_METHOD int sqlite3_bind_float(void* stmtPtr, uint32_t index, float value) {
+	return sqlite3_bind_double((sqlite3_stmt*)stmtPtr, index, (double)value);
+}
+#pragma comment(linker, "/EXPORT:sqlite3_bind_float=_sqlite3_bind_float@12")
+
+DLL_METHOD void sqlite3_column_int64_ex(void* stmtPtr, uint32_t index, void* outPtr) {
+	sqlite3_int64 out = sqlite3_column_int64((sqlite3_stmt*)stmtPtr, index);
+	uint32_t* ourPtr = (uint32_t*)outPtr;
+	(*ourPtr) = (uint32_t)(out & 0xFFFFFFFF);
+	(*(ourPtr + 1)) = (uint32_t)(out >> 32);
+}
+#pragma comment(linker, "/EXPORT:sqlite3_column_int64_ex=_sqlite3_column_int64_ex@12")
+
+DLL_METHOD float sqlite3_column_float(void* stmtPtr, uint32_t index) {
+	double out = sqlite3_column_double((sqlite3_stmt*)stmtPtr, index);
+	return (float)out;
+}
+#pragma comment(linker, "/EXPORT:sqlite3_column_float=_sqlite3_column_float@8")

Backup_Vector.txt

@@ -0,0 +1,338 @@
+
+struct Vector2 {
+	union {
+		float X;
+		char Xc[4];
+	};
+	union {
+		float Y;
+		char Yc[4];
+	};
+
+	void set(const float &o);
+	void set(const float &x, const float &y);
+	void set(const Vector2 &o);
+
+	void add(const float &o);
+	void add(const float &x, const float &y);
+	void add(const Vector2 &o);
+
+	void sub(const float &o);
+	void sub(const float &x, const float &y);
+	void sub(const Vector2 &o);
+
+	void mul(const float &o);
+	void mul(const float &x, const float &y);
+	void mul(const Vector2 &o);
+
+	void div(const float &o);
+	void div(const float &x, const float &y);
+	void div(const Vector2 &o);
+
+	float length();
+	float distance(const float &x, const float &y);
+	float distance(const Vector2 &o);
+
+	float dot(const float &x, const float &y);
+	float dot(const Vector2 &o);
+	void normalize();
+
+	void rotate(const float rotation);
+	void rotateAround(const float &x, const float &y, const float &rotation);
+	void rotateAround(const Vector2 &o, const float &rotation);
+	float deltaRotation();
+	float deltaRotation(const float &x, const float &y);
+	float deltaRotation(const Vector2 &o);
+
+	char* serialize();
+	void deserialize(char* o);
+};
+
+
+void Vector2::set(const float &o)
+{
+	this->X = o;
+	this->Y = o;
+}
+void Vector2::set(const float &x, const float &y)
+{
+	this->X = x;
+	this->Y = y;
+}
+void Vector2::set(const Vector2 &o)
+{
+	if (this != &o) {
+		this->X = o.X;
+		this->Y = o.Y;
+	}
+}
+
+void Vector2::add(const float &o)
+{
+	this->X += o;
+	this->Y += o;
+}
+void Vector2::add(const float &x, const float &y)
+{
+	this->X += x;
+	this->Y += y;
+}
+void Vector2::add(const Vector2 &o)
+{
+	this->X += o.X;
+	this->Y += o.Y;
+}
+
+void Vector2::sub(const float &o)
+{
+	this->X -= o;
+	this->Y -= o;
+}
+void Vector2::sub(const float &x, const float &y)
+{
+	this->X -= x;
+	this->Y -= y;
+}
+void Vector2::sub(const Vector2 &o)
+{
+	this->X -= o.X;
+	this->Y -= o.Y;
+}
+
+void Vector2::mul(const float &o)
+{
+	this->X *= o;
+	this->Y *= o;
+}
+void Vector2::mul(const float &x, const float &y)
+{
+	this->X *= x;
+	this->Y *= y;
+}
+void Vector2::mul(const Vector2 &o)
+{
+	this->X *= o.X;
+	this->Y *= o.Y;
+}
+
+void Vector2::div(const float &o)
+{
+	this->X /= o;
+	this->Y /= o;
+}
+void Vector2::div(const float &x, const float &y)
+{
+	this->X /= x;
+	this->Y /= y;
+}
+void Vector2::div(const Vector2 &o)
+{
+	this->X /= o.X;
+	this->Y /= o.Y;
+}
+
+float Vector2::length()
+{
+	return (float)sqrt((this->X * this->X) + (this->Y * this->Y));
+}
+float Vector2::distance(const float &x, const float &y)
+{
+	float X = this->X - x;
+	float Y = this->Y - y;
+	return (float)sqrt((X * X) + (Y * Y));
+}
+float Vector2::distance(const Vector2 &o)
+{
+	float X = this->X - o.X;
+	float Y = this->Y - o.Y;
+	return (float)sqrt((X * X) + (Y * Y));
+}
+
+float Vector2::dot(const float &x, const float &y)
+{
+	return (this->X * x) + (this->Y * y);
+}
+float Vector2::dot(const Vector2 &o)
+{
+	return (this->X * o.X) + (this->Y * o.Y);
+}
+void Vector2::normalize()
+{
+	this->div(this->length());
+}
+
+void Vector2::rotate(const float rotation)
+{
+	float mX = cos(rotation);
+	float mY = sin(rotation);
+
+	float X = this->X * mX + this->Y * mY; this->X = X;
+	float Y = this->X * mY + this->X * mX; this->Y = Y;
+}
+void Vector2::rotateAround(const float &x, const float &y, const float &rotation)
+{
+	this->sub(x, y);
+	this->rotate(rotation);
+	this->add(x, y);
+}
+void Vector2::rotateAround(const Vector2 &o, const float &rotation)
+{
+	this->sub(o);
+	this->rotate(rotation);
+	this->add(o);
+}
+
+float Vector2::deltaRotation() {
+	return (float)(atan2(this->Y, this->X) * (180.0 / M_PI));
+}
+float Vector2::deltaRotation(const float &x, const float &y)
+{
+	return (float)(atan2(this->Y - y, this->X - x) * (180.0 / M_PI));
+}
+float Vector2::deltaRotation(const Vector2 &o)
+{
+	return (float)(atan2(this->Y - o.Y, this->X - o.X) * (180.0 / M_PI));
+}
+
+char* Vector2::serialize()
+{
+	char* data = new char[9];
+
+	memcpy(data, this->Xc, 4);
+	memcpy(data + 4, this->Yc, 4);
+	data[8] = 0;
+
+	return data;
+}
+void Vector2::deserialize(char* o)
+{
+	memcpy(o, this->Xc, 4);
+	memcpy(o + 4, this->Yc, 4);
+}
+
+/* ------------------------- Exported Functionality ------------------------- */
+DLL_METHOD void Vector2_Set(Vector2* a, float o) {
+	a->set(o);
+}
+DLL_METHOD void Vector2_SetP(Vector2* a, float x, float y) {
+	a->set(x, y);
+}
+DLL_METHOD void Vector2_SetV(Vector2* a, Vector2* b) {
+	a->set(*b);
+}
+#pragma comment(linker, "/EXPORT:Vector2_Set=_Vector2_Set@8")
+#pragma comment(linker, "/EXPORT:Vector2_SetP=_Vector2_SetP@12")
+#pragma comment(linker, "/EXPORT:Vector2_SetV=_Vector2_SetV@8")
+
+DLL_METHOD void Vector2_Add(Vector2* a, float o) {
+	a->add(o);
+}
+DLL_METHOD void Vector2_AddP(Vector2* a, float x, float y) {
+	a->add(x, y);
+}
+DLL_METHOD void Vector2_AddV(Vector2* a, Vector2* b) {
+	a->add(*b);
+}
+#pragma comment(linker, "/EXPORT:Vector2_Add=_Vector2_Add@8")
+#pragma comment(linker, "/EXPORT:Vector2_AddP=_Vector2_AddP@12")
+#pragma comment(linker, "/EXPORT:Vector2_AddV=_Vector2_AddV@8")
+
+DLL_METHOD void Vector2_Sub(Vector2* a, float o) {
+	a->sub(o);
+}
+DLL_METHOD void Vector2_SubP(Vector2* a, float x, float y) {
+	a->sub(x, y);
+}
+DLL_METHOD void Vector2_SubV(Vector2* a, Vector2* b) {
+	a->sub(*b);
+}
+#pragma comment(linker, "/EXPORT:Vector2_Sub=_Vector2_Sub@8")
+#pragma comment(linker, "/EXPORT:Vector2_SubP=_Vector2_SubP@12")
+#pragma comment(linker, "/EXPORT:Vector2_SubV=_Vector2_SubV@8")
+
+DLL_METHOD void Vector2_Mul(Vector2* a, float o) {
+	a->mul(o);
+}
+DLL_METHOD void Vector2_MulP(Vector2* a, float x, float y) {
+	a->mul(x, y);
+}
+DLL_METHOD void Vector2_MulV(Vector2* a, Vector2* b) {
+	a->mul(*b);
+}
+#pragma comment(linker, "/EXPORT:Vector2_Mul=_Vector2_Mul@8")
+#pragma comment(linker, "/EXPORT:Vector2_MulP=_Vector2_MulP@12")
+#pragma comment(linker, "/EXPORT:Vector2_MulV=_Vector2_MulV@8")
+
+DLL_METHOD void Vector2_Div(Vector2* a, float o) {
+	a->div(o);
+}
+DLL_METHOD void Vector2_DivP(Vector2* a, float x, float y) {
+	a->div(x, y);
+}
+DLL_METHOD void Vector2_DivV(Vector2* a, Vector2* b) {
+	a->div(*b);
+}
+#pragma comment(linker, "/EXPORT:Vector2_Div=_Vector2_Div@8")
+#pragma comment(linker, "/EXPORT:Vector2_DivP=_Vector2_DivP@12")
+#pragma comment(linker, "/EXPORT:Vector2_DivV=_Vector2_DivV@8")
+
+DLL_METHOD float Vector2_Length(Vector2* a) {
+	return (float)a->length();
+}
+DLL_METHOD float Vector2_DistanceP(Vector2* a, float x, float y) {
+	return (float)a->distance(x, y);
+}
+DLL_METHOD float Vector2_DistanceV(Vector2* a, Vector2* b) {
+	return (float)a->distance(*b);
+}
+#pragma comment(linker, "/EXPORT:Vector2_Length=_Vector2_Length@4")
+#pragma comment(linker, "/EXPORT:Vector2_DistanceP=_Vector2_DistanceP@12")
+#pragma comment(linker, "/EXPORT:Vector2_DistanceV=_Vector2_DistanceV@8")
+
+DLL_METHOD float Vector2_DotP(Vector2* a, float x, float y) {
+	return (float)a->dot(x, y);
+}
+DLL_METHOD float Vector2_DotV(Vector2* a, Vector2* b) {
+	return (float)a->dot(*b);
+}
+DLL_METHOD void Vector2_Normalize(Vector2* a) {
+	a->normalize();
+}
+#pragma comment(linker, "/EXPORT:Vector2_DotP=_Vector2_DotP@12")
+#pragma comment(linker, "/EXPORT:Vector2_DotV=_Vector2_DotV@8")
+#pragma comment(linker, "/EXPORT:Vector2_Normalize=_Vector2_Normalize@4")
+
+DLL_METHOD void Vector2_Rotate(Vector2* a, float rotation) {
+	a->rotate(rotation);
+}
+DLL_METHOD void Vector2_RotateAroundP(Vector2* a, float x, float y, float rotation) {
+	a->rotateAround(x, y, rotation);
+}
+DLL_METHOD void Vector2_RotateAroundV(Vector2* a, Vector2* b, float rotation) {
+	a->rotateAround(*b, rotation);
+}
+#pragma comment(linker, "/EXPORT:Vector2_Rotate=_Vector2_Rotate@8")
+#pragma comment(linker, "/EXPORT:Vector2_RotateAroundP=_Vector2_RotateAroundP@16")
+#pragma comment(linker, "/EXPORT:Vector2_RotateAroundV=_Vector2_RotateAroundV@12")
+
+DLL_METHOD float Vector2_DeltaRotation(Vector2* a) {
+	return (float)a->deltaRotation();
+}
+DLL_METHOD float Vector2_DeltaRotationP(Vector2* a, float x, float y) {
+	return (float)a->deltaRotation(x, y);
+}
+DLL_METHOD float Vector2_DeltaRotationV(Vector2* a, Vector2* b) {
+	return (float)a->deltaRotation(*b);
+}
+#pragma comment(linker, "/EXPORT:Vector2_DeltaRotation=_Vector2_DeltaRotation@4")
+#pragma comment(linker, "/EXPORT:Vector2_DeltaRotationP=_Vector2_DeltaRotationP@12")
+#pragma comment(linker, "/EXPORT:Vector2_DeltaRotationV=_Vector2_DeltaRotationV@8")
+
+DLL_METHOD char* Vector2_Serialize(Vector2* a) {
+	return a->serialize();
+}
+DLL_METHOD void Vector2_Deserialize(Vector2* a, char* o) {
+	a->deserialize(o);
+}
+#pragma comment(linker, "/EXPORT:Vector2_Serialize=_Vector2_Serialize@4")
+#pragma comment(linker, "/EXPORT:Vector2_Deserialize=_Vector2_Deserialize@8")

BlitzUtility.bb

@@ -1,353 +0,0 @@
-;	BlitzUtility - Expanding the normal Blitz functionality.
-;	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
-;
-;	This program is free software: you can redistribute it and/or modify
-;	it under the terms of the GNU Lesser General Public License as
-;	published by the Free Software Foundation, either version 3 of the 
-;	License, or (at your option) any later version.
-;
-;	This program is distributed in the hope that it will be useful,
-;	but WITHOUT ANY WARRANTY; without even the implied warranty of
-;	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-;	GNU General Public License for more details.
-;
-;	You should have received a copy of the GNU Lesser General Public License
-;	along with this program.  If not, see <http:;www.gnu.org/licenses/>.
-
-; Utility ----------------------------------------------------------------------
-;-- Mass Operation
-; Constants: Supported Types
-Const BU_MASSOP_TYPE_DOUBLE							= 0
-Const BU_MASSOP_TYPE_LONGLONG							= 1
-Const BU_MASSOP_TYPE_VECTOR2							= 10
-Const BU_MASSOP_TYPE_VECTOR3							= 11
-; Constants: Supported OpCodes
-Const BU_MASSOP_OPCODE_CREATE							= 0
-Const BU_MASSOP_OPCODE_DESTROY							= 1
-Const BU_MASSOP_OPCODE_COPY							= 2
-Const BU_MASSOP_OPCODE_TEMPCREATE						= 5
-Const BU_MASSOP_OPCODE_TEMPDESTROY						= 6
-Const BU_MASSOP_OPCODE_TEMPCLEANUP						= 7
-Const BU_MASSOP_OPCODE_SET								= 10
-Const BU_MASSOP_OPCODE_ADD								= 11
-Const BU_MASSOP_OPCODE_SUB								= 12
-Const BU_MASSOP_OPCODE_MUL								= 13
-Const BU_MASSOP_OPCODE_DIV								= 14
-Const BU_MASSOP_OPCODE_COMPARE							= 15
-; GoTo
-;	leftOperand: new massop index
-Const BU_MASSOP_OPCODE_GOTO							= 249
-; SetOpCode
-;	leftOperand: target massop index
-;	rightOperand: new OpCode
-Const BU_MASSOP_OPCODE_SETOPCODE						= 250
-; CopyLeft
-;	leftOperand: source massop index
-;	rightOperand: target massop index
-;	result: target position (0/leftOperand, 1/rightOperand, 2/result)
-Const BU_MASSOP_OPCODE_COPYLEFT						= 251
-; CopyRight
-;	leftOperand: source massop index
-;	rightOperand: target massop index
-;	result: target position (0/leftOperand, 1/rightOperand, 2/result)
-Const BU_MASSOP_OPCODE_COPYRIGHT						= 252
-; CopyOut
-;	leftOperand: source massop index
-;	rightOperand: target massop index
-;	result: target position (0/leftOperand, 1/rightOperand, 2/result)
-Const BU_MASSOP_OPCODE_COPYOUT							= 253
-; If - Compares the result of <leftOperand> with the result of <rightOperand>, 
-;  skipping over <result> instructions if the results match.
-;	leftOperand: source massop index
-;	rightOperand: target massop index
-;	result: amount to skip
-Const BU_MASSOP_OPCODE_IF								= 254
-; IfValue - Compares the result of <leftOperand> with <rightOperand>, skipping
-;  over <result> instructions if the results match.
-;	leftOperand: source massop index
-;	rightOperand: target massop index
-;	result: amount to skip
-Const BU_MASSOP_OPCODE_IFVALUE							= 255
-
-; Helpers ----------------------------------------------------------------------
-Type BU_Point
-	Field X,Y
-End Type
-
-Type BU_Rectangle
-	Field X,Y,X2,Y2
-End Type
-
-Function BU_Helper_Window_LockPointer(HWND% = 0)
-	If HWND = 0 Then
-		BU_User32_ClipCursor(0)
-	Else
-		Local tRect.BU_Rectangle = New BU_Rectangle
-		
-		; Retrieve Information about the selected window.
-		BU_User32_GetWindowRect(HWND, tRect)
-		
-		; Correct Rectangle to be inside the selected Window.
-		tRect\X2=tRect\X2-1
-		tRect\Y2=tRect\Y2-1
-		
-		; Update clipping area.
-		BU_User32_ClipCursor(tRect)
-		
-		Delete tRect
-	EndIf
-End Function
-
-Function BU_Helper_Window_LockPointerAuto(HWND=0)
-	If BU_User32_GetActiveWindow() = HWND Then
-		BU_Helper_Window_LockPointer(HWND)
-	Else
-		BU_Helper_Window_LockPointer(0)
-	EndIf
-End Function
-
-Function BU_Helper_Window_MakeBorderless(HWND=0)
-	If HWND = 0 Then HWND = SystemProperty("AppHwnd")
-	
-	; Create Storage
-	Local tRect.BU_Rectangle = New BU_Rectangle
-	
-	; Client Information
-	BU_User32_GetClientRect(HWND, tRect)
-	Local clientX, clientY, clientW, clientH
-	clientX = tRect\X
-	clientY = tRect\Y
-	clientW = tRect\X2 - clientX
-	clientH = tRect\Y2 - clientY
-	
-	; Convert Client coordinates to screen position.
-	Local tPoint.BU_Point = New BU_Point
-	BU_User32_ClientToScreen(HWND, tPoint)
-	Local realClientX, realClientY
-	realClientX = tPoint\X
-	realClientY = tPoint\Y
-	Delete tPoint
-	
-	; Window Information
-	BU_User32_GetWindowRect(HWND, tRect)
-	Local windowX, windowY, windowW, windowH
-	windowX = tRect\X
-	windowY = tRect\Y
-	windowW = tRect\X2 - windowX
-	windowH = tRect\Y2 - windowY
-	
-	; Delete Storage
-	Delete tRect
-	
-	; Calculate new position and size.
-	Local newX, newY, newW, newH
-	newX = windowX + (realClientX - windowX)
-	newY = windowY + (realClientY - windowY)
-	newW = clientW
-	newH = clientH
-	
-;	DebugLog "Window:     " + RSet(windowX,8) + "," + RSet(windowY,8) + ":" + RSet(windowW,8) + "," + RSet(windowH,8)
-;	DebugLog "Client:     " + RSet(clientX,8) + "," + RSet(clientY,8) + ":" + RSet(clientW,8) + "," + RSet(clientH,8)
-;	DebugLog "RealClient: " + RSet(realClientX,8) + "," + RSet(realClientY,8)
-;	DebugLog "Diff:       " + RSet(realClientX - windowX,8) + "," + RSet(realClientY - windowY,8) + ":" + RSet(windowW - clientW,8) + "," + RSet(windowH - clientH,8)
-;	DebugLog "New:        " + RSet(newX,8) + "," + RSet(newY,8) + ":" + RSet(newW,8) + "," + RSet(newH,8)
-	
-	; Apply changes
-	BU_User32_SetWindowLong HWND, -16, $01000000
-	BU_User32_SetWindowPos HWND, 0, newX, newY, newW, newH, $4 + $10 + $20 + $40
-End Function
-
-Function BU_Helper_Window_Center(HWND=0, Monitor=0)
-	Local displayEnumerator = BU_DisplayEnumerator_Create()
-	Local displayAmount = BU_DisplayEnumerator_Enumerate(displayEnumerator)
-	If Monitor >= displayAmount Then Monitor = displayAmount - 1
-	If Monitor < 0 Then Monitor = 0
-	
-	; Get Display Information
-	Local displayRectangle.BU_Rectangle = New BU_Rectangle
-	BU_DisplayEnumerator_Retrieve displayEnumerator, Monitor, displayRectangle
-	BU_DisplayEnumerator_Destroy displayEnumerator
-	Local displayX, displayY, displayW, displayH
-	displayX = displayRectangle\X
-	displayY = displayRectangle\Y
-	displayW = displayRectangle\X2 - displayRectangle\X
-	displayH = displayRectangle\Y2 - displayRectangle\Y
-	Delete displayRectangle
-	
-	; Get Window Information
-	Local windowRectangle.BU_Rectangle = New BU_Rectangle
-	BU_User32_GetWindowRect(HWND, windowRectangle)
-	Local windowW%, windowH%
-	windowW = windowRectangle\X2 - windowRectangle\X
-	windowH = windowRectangle\Y2 - windowRectangle\Y
-	Delete windowRectangle
-	
-	; Calculate new position and size.
-	Local newX, newY, newW, newH
-	newX = displayX + (displayW/2 - windowW/2)
-	newY = displayY + (displayH/2 - windowH/2)
-	newW = windowW
-	newH = windowH
-	
-;	DebugLog "New:        " + RSet(newX,8) + "," + RSet(newY,8) + ":" + RSet(newW,8) + "," + RSet(newH,8)
-	
-	; Apply changes
-	BU_User32_SetWindowPos HWND, 0, newX, newY, newW, newH, $1 + $4 + $10 + $20 + $40 
-End Function
-
-; Database ---------------------------------------------------------------------
-;-- SQLite3
-;;[Block] Return Codes / Error Codes
-;; Many SQLite functions return an integer result code from the set shown
-;; here in order to indicate success or failure.
-;;
-;; New error codes may be added in future versions of SQLite.
-;Const SQLITE_OK%			= 0   ; Successful result
-;Const SQLITE_ERROR%			= 1   ; SQL error or missing database
-;Const SQLITE_INTERNAL%		= 2   ; Internal logic error in SQLite
-;Const SQLITE_PERM%			= 3   ; Access permission denied
-;Const SQLITE_ABORT%			= 4   ; Callback routine requested an abort
-;Const SQLITE_BUSY%			= 5   ; The database file is locked
-;Const SQLITE_LOCKED%		= 6   ; A table in the database is locked
-;Const SQLITE_NOMEM%			= 7   ; A malloc() failed
-;Const SQLITE_READONLY%		= 8   ; Attempt to write a readonly database
-;Const SQLITE_INTERRUPT%		= 9   ; Operation terminated by SQLite3_Interrupt()
-;Const SQLITE_IOERR%			= 10   ; Some kind of disk I/O error occurred
-;Const SQLITE_CORRUPT%		= 11   ; The database disk image is malformed
-;Const SQLITE_NOTFOUND%		= 12   ; Unknown opcode in sqlite3_file_control()
-;Const SQLITE_FULL%			= 13   ; Insertion failed because database is full
-;Const SQLITE_CANTOPEN%		= 14   ; Unable to open the database file
-;Const SQLITE_PROTOCOL%		= 15   ; Database lock protocol error
-;Const SQLITE_EMPTY%			= 16   ; Database is empty
-;Const SQLITE_SCHEMA%		= 17   ; The database schema changed
-;Const SQLITE_TOOBIG%		= 18   ; String or BLOB exceeds size limit
-;Const SQLITE_CONSTRAINT%	= 19   ; Abort due to constraint violation
-;Const SQLITE_MISMATCH%		= 20   ; Data type mismatch
-;Const SQLITE_MISUSE%		= 21   ; Library used incorrectly
-;Const SQLITE_NOLFS%			= 22   ; Uses OS features not supported on host
-;Const SQLITE_AUTH%			= 23   ; Authorization denied
-;Const SQLITE_FORMAT%		= 24   ; Auxiliary database format error
-;Const SQLITE_RANGE%			= 25   ; 2nd parameter to sqlite3_bind out of range
-;Const SQLITE_NOTADB%		= 26   ; File opened that is not a database file
-;Const SQLITE_NOTICE%		= 27   ; Notifications from sqlite3_log()
-;Const SQLITE_WARNING%		= 28   ; Warnings from sqlite3_log()
-;Const SQLITE_ROW%			= 100  ; sqlite3_step() has another row ready
-;Const SQLITE_DONE%			= 101  ; sqlite3_step() has finished executing
-;;[End Block]
-;
-;;[Block] SQLite_Open Flags
-;; These bit values are intended for use in the
-;; 3rd parameter to the [sqlite3_open_v2()] interface.
-;Const SQLITE_OPEN_READONLY%		= $00000001
-;Const SQLITE_OPEN_READWRITE%	= $00000002
-;Const SQLITE_OPEN_CREATE%		= $00000004
-;Const SQLITE_OPEN_URI%			= $00000040
-;Const SQLITE_OPEN_MEMORY%		= $00000080
-;Const SQLITE_OPEN_NOMUTEX%		= $00008000
-;Const SQLITE_OPEN_FULLMUTEX%	= $00010000
-;Const SQLITE_OPEN_SHAREDCACHE%	= $00020000
-;Const SQLITE_OPEN_PRIVATECACHE%	= $00040000
-;;[End Block]
-;
-;;[Block] Column Type
-;Const SQLITE_UNKNOWN	= 0
-;Const SQLITE_INTEGER	= 1
-;Const SQLITE_REAL		= 2
-;Const SQLITE_FLOAT		= 2
-;Const SQLITE_DOUBLE		= 2
-;Const SQLITE_TEXT		= 3
-;Const SQLITE_STRING		= 3
-;Const SQLITE_BLOB		= 4
-;Const SQLITE_NULL		= 5
-;;[End Block]
-;
-;;[Block] Internal Types
-;Type SQLite_Container
-;	Field Pointer%
-;End Type
-;
-;Type SQLite_Int64
-;	Field Left%, Right%
-;End Type
-;;[End Block]
-;
-;Function SQLite_Open%(File$, Flags% = $00000006)
-;	; Create a Container to hold the database pointer.
-;	Local Container.SQLite_Container = New SQLite_Container
-;	Local ErrCode = SQLite3_Open_V2(File, Container, Flags, 0)
-;	Local Database = Container\Pointer
-;	Delete Container
-;	
-;	If ErrCode = SQLITE_OK
-;		Return Database
-;	Else
-;		Return False
-;	EndIf
-;End Function
-;
-;Function SQLite_Execute(Database, SQL$)
-;	Return SQLite3_Exec(Database, SQL, 0, 0, 0)
-;End Function
-;
-;Function SQLite_Prepare(Database, SQL$)
-;	Local Container.SQLite_Container = New SQLite_Container
-;	Local ErrCode = SQLite3_Prepare(Database, SQL$, -1, Container, 0)
-;	Local Statement = Container\Pointer
-;	Delete Container
-;	
-;	If ErrCode = SQLITE_OK
-;		Return Statement
-;	Else
-;		Return False
-;	EndIf
-;End Function
-;
-;Global SQLite_Column_Int64_L%, SQLite_Column_Int64_R%
-;Function SQLite_Column_Int64(Statement, ColumnIndex%)
-;	Local Result.SQLite_Int64 = New SQLite_Int64
-;	SQLite3_Column_Int64(Statement, ColumnIndex, Result)
-;	SQLite_Column_Int64_L = Result\Left
-;	SQLite_Column_Int64_R = Result\Right
-;	Delete Result
-;End Function
-;
-;Function SQLite_Bind_Text(Statement, ColumnIndex%, Value$)
-;	Return SQLite3_Bind_Text(Statement, ColumnIndex, Value, -1, -1)
-;End Function
-;
-;Function SQLite_Bind_Blob(Statement, ColumnIndex%, Bank)
-;	If Bank <> 0 Then
-;		Local Size% = BankSize(Bank)
-;		Return SQLite3_Bind_Blob(Statement, ColumnIndex, Bank, Size, 0)
-;	EndIf
-;End Function
-
-; Math -------------------------------------------------------------------------
-;-- Vector2
-Type Vector2
-	Field X#, Y#
-End Type
-
-Function Vector2_Create.Vector2(X#, Y#)
-	Local vec.Vector2 = New Vector2
-	vec\X = X
-	vec\Y = Y
-	Return vec
-End Function
-
-;-- Vector3
-Type Vector3
-	Field X#, Y#, Z#
-End Type
-
-Function Vector3_Create.Vector3(X#, Y#, Z#)
-	Local vec.Vector3 = New Vector3
-	vec\X = X
-	vec\Y = Y
-	vec\Z = Z
-	Return vec
-End Function
-
-
-;~IDEal Editor Parameters:
-;~C#Blitz3D

BlitzUtility.cpp

@@ -1,33 +1,33 @@
-//	BlitzUtility - Expanding the normal Blitz functionality.
-//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
-//
-//	This program is free software: you can redistribute it and/or modify
-//	it under the terms of the GNU Lesser General Public License as
-//	published by the Free Software Foundation, either version 3 of the 
-//	License, or (at your option) any later version.
-//
-//	This program is distributed in the hope that it will be useful,
-//	but WITHOUT ANY WARRANTY; without even the implied warranty of
-//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//	GNU General Public License for more details.
-//
-//	You should have received a copy of the GNU Lesser General Public License
-//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-#pragma once
-#include <list>
-#include "dllmain.h"
-#include "Database\SQLite\SQLite.h"
-#include "Utility\WindowMessageHandler.h"
-
-bool WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved) {
-	switch (fdwReason) {
-		case DLL_PROCESS_ATTACH:
-			BU_WindowMessageHandler_OnProcessAttach();
-			break;
-		case DLL_PROCESS_DETACH:
-			BU_WindowMessageHandler_OnProcessDetach();
-			break;
-	}
-	return TRUE;
+//	BlitzUtility - Expanding the normal Blitz functionality.
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#pragma once
+#include <list>
+#include "BlitzUtility.h"
+#include "Database\SQLite\SQLite.h"
+#include "Utility\WindowMessageHandler.h"
+
+bool WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved) {
+	switch (fdwReason) {
+		case DLL_PROCESS_ATTACH:
+			BU_WindowMessageHandler_OnProcessAttach();
+			break;
+		case DLL_PROCESS_DETACH:
+			BU_WindowMessageHandler_OnProcessDetach();
+			break;
+	}
+	return TRUE;
 }

BlitzUtility.decls

@@ -1,171 +0,0 @@
-;	BlitzUtility - Expanding the normal Blitz functionality.
-;	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
-;
-;	This program is free software: you can redistribute it and/or modify
-;	it under the terms of the GNU Lesser General Public License as
-;	published by the Free Software Foundation, either version 3 of the 
-;	License, or (at your option) any later version.
-;
-;	This program is distributed in the hope that it will be useful,
-;	but WITHOUT ANY WARRANTY; without even the implied warranty of
-;	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-;	GNU General Public License for more details.
-;
-;	You should have received a copy of the GNU Lesser General Public License
-;	along with this program.  If not, see <http:;www.gnu.org/licenses/>.
-
-.lib "BlitzUtility.dll"
-; Container --------------------------------------------------------------------
-; -- List (Single Element)
-BU_List_Create%(element*)
-BU_List_Destroy%(list%)
-BU_List_First%(list%)
-BU_List_Last%(list%)
-BU_List_Previous%(list%)
-BU_List_Next%(list%)
-BU_List_Before%(list%, other*)
-BU_List_After%(list%, other*)
-BU_List_Insert(list%, element*)
-BU_List_InsertEx(list%, element*, other*)
-BU_List_Remove(list%, element*)
-; -- TypeList (Single Type)
-BU_TypeList_New%(obj*)
-BU_TypeList_Activate(list%)
-BU_TypeList_Deactivate(list%)
-BU_TypeList_Destroy(list%)
-
-; Types ------------------------------------------------------------------------
-; -- LongLong
-BU_LongLong_Create%()
-BU_LongLong_Destroy(LongLong%)
-BU_LongLong_Copy%(LongLong%)
-BU_LongLong_TempCreate%()
-BU_LongLong_TempCopy%(LongLong%)
-BU_LongLong_SetTemp(LongLong%)
-BU_LongLong_UnsetTemp(LongLong%)
-BU_LongLong_TempCleanup()
-BU_LongLong_Set(LongLong%, LongLong%)
-BU_LongLong_SetV(LongLong%, LongHigh%, LongLow%)
-BU_LongLong_Add(LongLong%, LongLong%)
-BU_LongLong_AddV(LongLong%, LongHigh%, LongLow%)
-BU_LongLong_Sub(LongLong%, LongLong%)
-BU_LongLong_SubV(LongLong%, LongHigh%, LongLow%)
-BU_LongLong_Mul(LongLong%, LongLong%)
-BU_LongLong_MulV(LongLong%, LongHigh%, LongLow%)
-BU_LongLong_Div(LongLong%, LongLong%)
-BU_LongLong_DivV(LongLong%, LongHigh%, LongLow%)
-BU_LongLong_Compare%(LongLong%, LongLong%)
-BU_LongLong_CompareV%(LongLong%, LongHigh%, LongLow%)
-BU_LongLong_ToString$(LongLong%)
-BU_LongLong_FromString%(String$)
-BU_LongLong_ToLong%(LongLong%, Modulus%)
-BU_LongLong_FromLong%(LongHigh%, LongLow%)
-BU_LongLong_ToLongHigh%(LongLong%)
-BU_LongLong_ToLongLow%(LongLong%)
-BU_LongLong_ToFloat#(LongLong%)
-BU_LongLong_FromFloat%(Float#)
-BU_LongLong_ToDouble%(LongLong%)
-BU_LongLong_FromDouble%(double%)
-BU_LongLong_Serialize$(LongLong%)
-BU_LongLong_Deserialize%(String$)
-; -- Double
-BU_Double_Create%()
-BU_Double_Destroy(Double%)
-BU_Double_Copy%(Double%)
-BU_Double_TempCreate%()
-BU_Double_TempCopy%(Double%)
-BU_Double_SetTemp(Double%)
-BU_Double_UnsetTemp(Double%)
-BU_Double_TempCleanup()
-BU_Double_Set(Double%, Double%)
-BU_Double_SetF(Double%, Float#)
-BU_Double_Add(Double%, Double%)
-BU_Double_AddF(Double%, Float#)
-BU_Double_Sub(Double%, Double%)
-BU_Double_SubF(Double%, Float#)
-BU_Double_Mul(Double%, Double%)
-BU_Double_MulF(Double%, Float#)
-BU_Double_Div(Double%, Double%)
-BU_Double_DivF(Double%, Float#)
-BU_Double_Compare%(Double%, Double%)
-BU_Double_CompareF%(Double%, Float#)
-BU_Double_ToString$(Double%)
-BU_Double_FromString%(String$)
-BU_Double_ToFloat#(Double%)
-BU_Double_FromFloat%(Float#)
-BU_Double_ToLongLong%(Double%)
-BU_Double_FromLongLong%(LongLong%)
-BU_Double_Serialize$(Double%)
-BU_Double_Deserialize%(String$)
-
-; Utility ----------------------------------------------------------------------
-; -- Display Enumerator
-BU_DisplayEnumerator_Create%()
-BU_DisplayEnumerator_Destroy(DisplayEnumerator%)
-BU_DisplayEnumerator_Enumerate%(DisplayEnumerator%)
-BU_DisplayEnumerator_Count%(DisplayEnumerator%)
-BU_DisplayEnumerator_Retrieve(DisplayEnumerator%, index%, Rect*)
-; -- Indexer V1 (Array)
-BU_IndexerV1_Create%()
-BU_IndexerV1_Destroy(Indexer%)
-BU_IndexerV1_Mark(Indexer%, Used%)
-BU_IndexerV1_MarkFree(Indexer%)
-BU_IndexerV1_MarkUsed(Indexer%)
-BU_IndexerV1_Is%(Indexer%, Used%)
-BU_IndexerV1_IsFree%(Indexer%)
-BU_IndexerV1_IsUsed%(Indexer%)
-BU_IndexerV1_Get%(Indexer%)
-BU_IndexerV1_Count%(Indexer%, Used%)
-BU_IndexerV1_CountFree%(Indexer%)
-BU_IndexerV1_CountUsed%(Indexer%)
-; -- Indexer V2 (List)
-BU_IndexerV2_Create%()
-BU_IndexerV2_Destroy(Indexer%)
-BU_IndexerV2_Mark(Indexer%, Used%)
-BU_IndexerV2_MarkFree(Indexer%)
-BU_IndexerV2_MarkUsed(Indexer%)
-BU_IndexerV2_Is%(Indexer%, Used%)
-BU_IndexerV2_IsFree%(Indexer%)
-BU_IndexerV2_IsUsed%(Indexer%)
-BU_IndexerV2_Get%(Indexer%)
-BU_IndexerV2_Count%(Indexer%, Used%)
-BU_IndexerV2_CountFree%(Indexer%)
-BU_IndexerV2_CountUsed%(Indexer%)
-; -- Mass Operation
-BU_MassOp_Create%(length%)
-BU_MassOp_Destroy(massop%)
-BU_MassOp_Instruction(massop%, index%, type%, code%, leftOperand%, rightOperand%, result%)
-BU_MassOp_Run(massop%)
-; -- Window Message Handler
-BU_WindowMessageHandler_Install(hwnd%)
-BU_WindowMessageHandler_Uninstall(hwnd%)
-BU_WindowMessageHandler_Message_Close%(hwnd%)
-BU_WindowMessageHandler_Message_Destroy%(hwnd%)
-BU_WindowMessageHandler_Message_Resize%(hwnd%, point*)
-
-; Helpers ----------------------------------------------------------------------
-.lib " "
-; -- Blitz Functions
-BU_Helper_Window_LockPointer(HWND%)
-BU_Helper_Window_LockPointerAuto(HWND%)
-BU_Helper_Window_MakeBorderless(HWND%)
-BU_Helper_Window_Center(HWND%, Monitor%)
-; -- Windows API (User32)
-.lib "User32.dll"
-BU_User32_ClientToScreen%(hwnd%, point*)										: "ClientToScreen"
-BU_User32_ClientToScreenEx%(hwnd%, point%)										: "ClientToScreen"
-BU_User32_ClipCursor%(rect*)													: "ClipCursor"
-BU_User32_ClipCursorEx%(ptr%)													: "ClipCursor"
-BU_User32_GetActiveWindow%()													: "GetActiveWindow"
-BU_User32_GetSystemMetrics%(index%)												: "GetSystemMetrics"
-BU_User32_SetWindowLong%(hwnd%, nIndex%, dwNewLong%)							: "SetWindowLongA"
-BU_User32_GetWindowLong%(hwnd%, index%)											: "GetWindowLongA"
-BU_User32_GetWindowRect%(hwnd%, rect*)											: "GetWindowRect"
-BU_User32_GetWindowRectEx%(hwnd%, rect%)										: "GetWindowRect"
-BU_User32_GetClientRect%(hwnd%, rect*)											: "GetClientRect"
-BU_User32_GetClientRectEx%(hwnd%, rect%)										: "GetClientRect"
-BU_User32_SetWindowPos%(hwnd%, hWndInsertAfter%, x%, y%, cx%, cy%, wFlags%)		: "SetWindowPos" 
-; -- Windows API (Kernel32)
-.lib "Kernel32.dll"
-BU_Kernel32_FlushFileBuffers%(hFile%)											: "FlushFileBuffers"
-FlushFile%(hFile%)																: "FlushFileBuffers"

BlitzUtility.h

@@ -1,56 +1,42 @@
-//	BlitzUtility - Expanding the normal Blitz functionality.
-//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
-//
-//	This program is free software: you can redistribute it and/or modify
-//	it under the terms of the GNU Lesser General Public License as
-//	published by the Free Software Foundation, either version 3 of the 
-//	License, or (at your option) any later version.
-//
-//	This program is distributed in the hope that it will be useful,
-//	but WITHOUT ANY WARRANTY; without even the implied warranty of
-//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//	GNU General Public License for more details.
-//
-//	You should have received a copy of the GNU Lesser General Public License
-//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-#pragma once
-
-// Memory Management
-#include <memory>
-
-// Strings
-#include <string>
-#include <sstream>
-#include <iomanip>
-
-// Platform specific: Windows
-#include <windows.h>
-
-// Macros
-#define DLL_METHOD extern "C"
-#define DLL_CALL __stdcall
-
-//Templates
-template< typename T >
-std::string int_to_hex(T i) {
-	std::stringstream stream;
-	stream
-		<< std::setfill('0')
-		<< std::setw(sizeof(T) * 2)
-		<< std::hex
-		<< i;
-	return stream.str();
-}
-
-template< typename T >
-T hex_to_int(std::string t) {
-	T x;
-	std::stringstream stream;
-	stream
-		<< std::hex
-		<< t;
-	stream
-		>> x;
-	return x;
-}
+//	BlitzUtility - Expanding the normal Blitz functionality.
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#pragma once
+
+// Standard Library
+#include <time.h>
+#include <exception>
+#include <stdexcept>
+#include <memory>
+
+// Platform specific: Windows
+#include <windows.h>
+
+// Macros
+#define DLL_FUNCTION(type) extern "C" __declspec(dllexport) type __stdcall
+
+// BlitzUtility Includes
+#include "Container/List.h"
+#include "Container/TypeList.h"
+#include "Database/SQLite/SQLite.h"
+#include "Time/HighResolutionClock.h"
+#include "Type/Double.h"
+#include "Type/Long.h"
+#include "Utility/DisplayEnumerator.h"
+#include "Utility/IndexerV1.h"
+#include "Utility/IndexerV2.h"
+#include "Utility/MassOp.h"
+#include "Utility/WindowMessageHandler.h"

BlitzUtility.vcxproj

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup Label="ProjectConfigurations">
     <ProjectConfiguration Include="Debug|Win32">
       <Configuration>Debug</Configuration>
@@ -13,18 +13,19 @@
   <PropertyGroup Label="Globals">
     <ProjectGuid>{C08C5F9A-0C63-4798-A93F-FE96C014074B}</ProjectGuid>
     <RootNamespace>BlitzUtility</RootNamespace>
+    <WindowsTargetPlatformVersion>8.1</WindowsTargetPlatformVersion>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
     <ConfigurationType>DynamicLibrary</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
+    <PlatformToolset>v140</PlatformToolset>
     <CharacterSet>Unicode</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
     <ConfigurationType>DynamicLibrary</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
+    <PlatformToolset>v140</PlatformToolset>
     <WholeProgramOptimization>false</WholeProgramOptimization>
     <CharacterSet>Unicode</CharacterSet>
   </PropertyGroup>
@@ -39,32 +40,29 @@
   </ImportGroup>
   <PropertyGroup Label="UserMacros" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <OutDir>$(SolutionDir)\#Build\$(ProjectName)\$(Configuration)\</OutDir>
-    <IntDir>$(SolutionDir)\#Intermediate\$(ProjectName)\$(Configuration)\</IntDir>
-    <LinkIncremental>true</LinkIncremental>
+    <OutDir>$(SolutionDir)#Build\$(ProjectName)\$(Configuration)\</OutDir>
+    <IntDir>$(SolutionDir)#Intermediate\$(ProjectName)\$(Configuration)\</IntDir>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <OutDir>$(SolutionDir)\#Build\$(ProjectName)\$(Configuration)\</OutDir>
-    <IntDir>$(SolutionDir)\#Intermediate\$(ProjectName)\$(Configuration)\</IntDir>
-    <LinkIncremental>false</LinkIncremental>
+    <OutDir>$(SolutionDir)#Build\$(ProjectName)\$(Configuration)\</OutDir>
+    <IntDir>$(SolutionDir)#Intermediate\$(ProjectName)\$(Configuration)\</IntDir>
+    <LinkIncremental>true</LinkIncremental>
   </PropertyGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <ClCompile>
       <WarningLevel>Level3</WarningLevel>
       <Optimization>Disabled</Optimization>
-      <SDLCheck>
-      </SDLCheck>
       <AdditionalIncludeDirectories>$(ProjectDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
-      <BasicRuntimeChecks>Default</BasicRuntimeChecks>
+      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
       <StructMemberAlignment>4Bytes</StructMemberAlignment>
       <BufferSecurityCheck>false</BufferSecurityCheck>
       <ForcedIncludeFiles>
       </ForcedIncludeFiles>
       <OpenMPSupport>false</OpenMPSupport>
-      <RuntimeTypeInfo>false</RuntimeTypeInfo>
-      <CreateHotpatchableImage>false</CreateHotpatchableImage>
-      <FunctionLevelLinking>false</FunctionLevelLinking>
+      <RuntimeTypeInfo>true</RuntimeTypeInfo>
+      <CreateHotpatchableImage>true</CreateHotpatchableImage>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
       <EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
       <MultiProcessorCompilation>true</MultiProcessorCompilation>
       <CompileAsManaged>false</CompileAsManaged>
@@ -75,34 +73,38 @@
       <IntrinsicFunctions>false</IntrinsicFunctions>
       <FavorSizeOrSpeed>Neither</FavorSizeOrSpeed>
       <StringPooling>true</StringPooling>
-      <EnableEnhancedInstructionSet>NoExtensions</EnableEnhancedInstructionSet>
-      <FloatingPointExceptions>false</FloatingPointExceptions>
+      <EnableEnhancedInstructionSet>NotSet</EnableEnhancedInstructionSet>
+      <FloatingPointExceptions>true</FloatingPointExceptions>
       <UseUnicodeForAssemblerListing>true</UseUnicodeForAssemblerListing>
       <PreprocessorDefinitions>%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ControlFlowGuard>false</ControlFlowGuard>
+      <EnforceTypeConversionRules>true</EnforceTypeConversionRules>
+      <DebugInformationFormat>EditAndContinue</DebugInformationFormat>
     </ClCompile>
     <Link>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <Version>1.0</Version>
+      <GenerateDebugInformation>Debug</GenerateDebugInformation>
       <LinkStatus>
       </LinkStatus>
       <CreateHotPatchableImage>Enabled</CreateHotPatchableImage>
       <EnableCOMDATFolding>false</EnableCOMDATFolding>
       <FixedBaseAddress>false</FixedBaseAddress>
+      <LargeAddressAware>false</LargeAddressAware>
+      <OptimizeReferences>false</OptimizeReferences>
+      <LinkTimeCodeGeneration>
+      </LinkTimeCodeGeneration>
+      <ImageHasSafeExceptionHandlers>false</ImageHasSafeExceptionHandlers>
+      <FullProgramDatabaseFile>true</FullProgramDatabaseFile>
     </Link>
     <CustomBuildStep>
       <Message>Copying Resources</Message>
     </CustomBuildStep>
-    <ProjectReference>
-      <LinkLibraryDependencies>false</LinkLibraryDependencies>
-    </ProjectReference>
+    <ProjectReference />
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
     <ClCompile>
       <WarningLevel>Level3</WarningLevel>
       <Optimization>Full</Optimization>
       <IntrinsicFunctions>true</IntrinsicFunctions>
-      <SDLCheck>
-      </SDLCheck>
       <AdditionalIncludeDirectories>$(ProjectDir);%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
       <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
@@ -112,82 +114,98 @@
       </ForcedIncludeFiles>
       <BasicRuntimeChecks>Default</BasicRuntimeChecks>
       <OpenMPSupport>false</OpenMPSupport>
-      <RuntimeTypeInfo>false</RuntimeTypeInfo>
+      <RuntimeTypeInfo>true</RuntimeTypeInfo>
       <CreateHotpatchableImage>false</CreateHotpatchableImage>
       <MinimalRebuild>false</MinimalRebuild>
-      <FunctionLevelLinking>false</FunctionLevelLinking>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
       <EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
       <MultiProcessorCompilation>true</MultiProcessorCompilation>
       <CompileAsManaged>false</CompileAsManaged>
       <CompileAsWinRT>false</CompileAsWinRT>
       <CallingConvention>Cdecl</CallingConvention>
-      <InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
+      <InlineFunctionExpansion>Default</InlineFunctionExpansion>
       <StringPooling>true</StringPooling>
-      <EnableEnhancedInstructionSet>NoExtensions</EnableEnhancedInstructionSet>
-      <FloatingPointExceptions>false</FloatingPointExceptions>
+      <EnableEnhancedInstructionSet>NotSet</EnableEnhancedInstructionSet>
+      <FloatingPointExceptions>true</FloatingPointExceptions>
       <UseUnicodeForAssemblerListing>true</UseUnicodeForAssemblerListing>
       <PreprocessorDefinitions>%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <DebugInformationFormat>None</DebugInformationFormat>
+      <ControlFlowGuard>false</ControlFlowGuard>
+      <EnforceTypeConversionRules>true</EnforceTypeConversionRules>
     </ClCompile>
     <Link>
-      <GenerateDebugInformation>false</GenerateDebugInformation>
+      <GenerateDebugInformation>No</GenerateDebugInformation>
       <EnableCOMDATFolding>false</EnableCOMDATFolding>
-      <OptimizeReferences>
-      </OptimizeReferences>
-      <Version>1.0</Version>
+      <OptimizeReferences>false</OptimizeReferences>
       <LinkStatus>
       </LinkStatus>
       <CreateHotPatchableImage>Enabled</CreateHotPatchableImage>
       <FixedBaseAddress>false</FixedBaseAddress>
+      <LargeAddressAware>false</LargeAddressAware>
+      <LinkTimeCodeGeneration>
+      </LinkTimeCodeGeneration>
+      <ImageHasSafeExceptionHandlers>false</ImageHasSafeExceptionHandlers>
+      <FullProgramDatabaseFile>false</FullProgramDatabaseFile>
     </Link>
     <CustomBuildStep>
       <Message>Copying Resources</Message>
     </CustomBuildStep>
-    <ProjectReference>
-      <LinkLibraryDependencies>false</LinkLibraryDependencies>
-    </ProjectReference>
+    <ProjectReference />
   </ItemDefinitionGroup>
   <ItemGroup>
     <ClInclude Include="Container\List.h" />
-    <ClInclude Include="dllmain.h" />
+    <ClInclude Include="BlitzUtility.h" />
     <ClInclude Include="Container\TypeList.h" />
+    <ClInclude Include="Database\SQLite\SQLite.h" />
+    <ClInclude Include="Database\SQLite\sqlite3.h" />
+    <ClInclude Include="System\FileSystem.h" />
+    <ClInclude Include="System\Threading.h" />
+    <ClInclude Include="Time\HighResolutionClock.h" />
+    <ClInclude Include="Time\SystemClock.h" />
+    <ClInclude Include="Time\Time.h" />
+    <ClInclude Include="Time\Timer.h" />
     <ClInclude Include="Utility\MassOp.h" />
     <ClInclude Include="Type\Double.h" />
-    <ClInclude Include="Type\LongLong.h" />
+    <ClInclude Include="Type\Long.h" />
     <ClInclude Include="Utility\IndexerV1.h" />
     <ClInclude Include="Utility\DisplayEnumerator.h" />
     <ClInclude Include="Utility\IndexerV2.h" />
+    <ClInclude Include="Utility\ThreadWrapper.h" />
     <ClInclude Include="Utility\WindowMessageHandler.h" />
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="Container\TypeList.cpp" />
     <ClCompile Include="Container\List.cpp" />
+    <ClCompile Include="Database\SQLite\SQLite.cpp" />
+    <ClCompile Include="Database\SQLite\sqlite3.c" />
+    <ClCompile Include="System\FileSystem.cpp" />
+    <ClCompile Include="System\Threading.cpp" />
+    <ClCompile Include="Time\HighResolutionClock.cpp" />
+    <ClCompile Include="Time\SystemClock.cpp" />
+    <ClCompile Include="Time\Time.cpp" />
+    <ClCompile Include="Time\Timer.cpp" />
     <ClCompile Include="Type\Double.cpp" />
-    <ClCompile Include="Type\LongLong.cpp" />
+    <ClCompile Include="Type\Long.cpp" />
     <ClCompile Include="Utility\IndexerV1.cpp" />
-    <ClCompile Include="dllmain.cpp" />
+    <ClCompile Include="BlitzUtility.cpp" />
     <ClCompile Include="Utility\DisplayEnumerator.cpp" />
     <ClCompile Include="Utility\IndexerV2.cpp" />
     <ClCompile Include="Utility\MassOp.cpp" />
+    <ClCompile Include="Utility\ThreadWrapper.cpp" />
     <ClCompile Include="Utility\WindowMessageHandler.cpp" />
   </ItemGroup>
   <ItemGroup>
-    <None Include="LICENSE">
-      <Link>LICENSE</Link>
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </None>
-    <None Include="LICENSE.lesser">
-      <Link>LICENSE.lesser</Link>
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </None>
-    <None Include="BlitzUtility.bb">
-      <Link>BlitzUtility.bb</Link>
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </None>
-    <None Include="BlitzUtility.decls">
-      <Link>BlitzUtility.decls</Link>
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </None>
+    <None Include="Resources\BlitzUtility.bb" />
+    <None Include="Resources\BlitzUtility.decls" />
+    <None Include="Resources\BlitzUtility.LICENSE" />
+    <None Include="Resources\BlitzUtility.LICENSE.lesser" />
   </ItemGroup>
+  <Target Name="CopyResources" AfterTargets="Build">
+    <ItemGroup>
+      <Resources Include="$(ProjectDir)\Resources\**\*.*" />
+    </ItemGroup>
+    <Copy SourceFiles="@(Resources)" DestinationFiles="@(Resources->'$(TargetDir)%(RecursiveDir)\%(Filename)%(Extension)')" SkipUnchangedFiles="True" UseHardlinksIfPossible="True" />
+  </Target>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">
   </ImportGroup>

BlitzUtility.vcxproj.filters

@@ -8,21 +8,54 @@
     <Filter Include="Source Files\Utility">
       <UniqueIdentifier>{48292af9-63a5-40ae-a447-ad7cecfddd8a}</UniqueIdentifier>
     </Filter>
-    <Filter Include="Blitz Files">
-      <UniqueIdentifier>{e8e48b8c-14c2-40b5-b48d-d9b55fe6852d}</UniqueIdentifier>
-      <Extensions>bb;decls;ipf</Extensions>
-    </Filter>
     <Filter Include="Source Files\Container">
       <UniqueIdentifier>{ff6bcb4d-9140-40a9-80dd-3698b63bd1c1}</UniqueIdentifier>
     </Filter>
     <Filter Include="Source Files\Type">
       <UniqueIdentifier>{605f2cca-0949-4af8-ab67-7042309a2abc}</UniqueIdentifier>
     </Filter>
+    <Filter Include="Source Files\Database">
+      <UniqueIdentifier>{dfe42881-d7cc-4245-8dc4-f56d80f20fa8}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Source Files\Database\SQLite">
+      <UniqueIdentifier>{82641744-2ff6-4000-9bec-718eb209a2a4}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Source Files\Time">
+      <UniqueIdentifier>{5a129704-2426-422d-8a40-c869f58d94cb}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{67ecd4f9-8888-4144-a4cc-0102188b329a}</UniqueIdentifier>
+      <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
+    </Filter>
+    <Filter Include="Header Files\Container">
+      <UniqueIdentifier>{61ad793e-f1b8-47c7-97b0-135344745ff4}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Header Files\Database">
+      <UniqueIdentifier>{fe289617-3503-42ab-bee1-85b54cae2f3c}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Header Files\Database\SQLite">
+      <UniqueIdentifier>{229e6434-139d-476e-91d4-1ff4e46906ef}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Header Files\Time">
+      <UniqueIdentifier>{e54a8406-e6ab-4f0b-89a4-5a2385d61d8d}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Header Files\Type">
+      <UniqueIdentifier>{83cba243-3e88-472d-a5b8-d0339ff1d72e}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Header Files\Utility">
+      <UniqueIdentifier>{35a5e71b-a977-4fa1-8428-25a0bade6db2}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Resource Files">
+      <UniqueIdentifier>{13f1a82e-2123-4652-a573-2dd8235ae033}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Header Files\System">
+      <UniqueIdentifier>{5545a0db-1127-4588-8522-680ec51473e0}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Source Files\System">
+      <UniqueIdentifier>{c14c025c-cae9-4d80-abe0-f04895a8f944}</UniqueIdentifier>
+    </Filter>
   </ItemGroup>
   <ItemGroup>
-    <ClCompile Include="dllmain.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
     <ClCompile Include="Utility\WindowMessageHandler.cpp">
       <Filter>Source Files\Utility</Filter>
     </ClCompile>
@@ -35,9 +68,6 @@
     <ClCompile Include="Type\Double.cpp">
       <Filter>Source Files\Type</Filter>
     </ClCompile>
-    <ClCompile Include="Type\LongLong.cpp">
-      <Filter>Source Files\Type</Filter>
-    </ClCompile>
     <ClCompile Include="Utility\MassOp.cpp">
       <Filter>Source Files\Utility</Filter>
     </ClCompile>
@@ -50,47 +80,111 @@
     <ClCompile Include="Utility\DisplayEnumerator.cpp">
       <Filter>Source Files\Utility</Filter>
     </ClCompile>
+    <ClCompile Include="BlitzUtility.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Database\SQLite\SQLite.cpp">
+      <Filter>Source Files\Database\SQLite</Filter>
+    </ClCompile>
+    <ClCompile Include="Time\HighResolutionClock.cpp">
+      <Filter>Source Files\Time</Filter>
+    </ClCompile>
+    <ClCompile Include="Database\SQLite\sqlite3.c">
+      <Filter>Source Files\Database\SQLite</Filter>
+    </ClCompile>
+    <ClCompile Include="Time\SystemClock.cpp">
+      <Filter>Source Files\Time</Filter>
+    </ClCompile>
+    <ClCompile Include="Time\Time.cpp">
+      <Filter>Source Files\Time</Filter>
+    </ClCompile>
+    <ClCompile Include="Type\Long.cpp">
+      <Filter>Source Files\Type</Filter>
+    </ClCompile>
+    <ClCompile Include="Utility\ThreadWrapper.cpp">
+      <Filter>Source Files\Utility</Filter>
+    </ClCompile>
+    <ClCompile Include="System\Threading.cpp">
+      <Filter>Source Files\System</Filter>
+    </ClCompile>
+    <ClCompile Include="Time\Timer.cpp">
+      <Filter>Source Files\Time</Filter>
+    </ClCompile>
+    <ClCompile Include="System\FileSystem.cpp">
+      <Filter>Source Files\System</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
-    <ClInclude Include="dllmain.h">
-      <Filter>Source Files</Filter>
-    </ClInclude>
-    <ClInclude Include="Utility\WindowMessageHandler.h">
-      <Filter>Source Files\Utility</Filter>
-    </ClInclude>
-    <ClInclude Include="Utility\IndexerV1.h">
-      <Filter>Source Files\Utility</Filter>
-    </ClInclude>
-    <ClInclude Include="Utility\IndexerV2.h">
-      <Filter>Source Files\Utility</Filter>
-    </ClInclude>
-    <ClInclude Include="Type\Double.h">
-      <Filter>Source Files\Type</Filter>
-    </ClInclude>
-    <ClInclude Include="Type\LongLong.h">
-      <Filter>Source Files\Type</Filter>
-    </ClInclude>
-    <ClInclude Include="Utility\MassOp.h">
-      <Filter>Source Files\Utility</Filter>
+    <ClInclude Include="BlitzUtility.h">
+      <Filter>Header Files</Filter>
     </ClInclude>
     <ClInclude Include="Container\List.h">
-      <Filter>Source Files\Container</Filter>
+      <Filter>Header Files\Container</Filter>
     </ClInclude>
     <ClInclude Include="Container\TypeList.h">
-      <Filter>Source Files\Container</Filter>
+      <Filter>Header Files\Container</Filter>
+    </ClInclude>
+    <ClInclude Include="Database\SQLite\SQLite.h">
+      <Filter>Header Files\Database\SQLite</Filter>
+    </ClInclude>
+    <ClInclude Include="Database\SQLite\sqlite3.h">
+      <Filter>Header Files\Database\SQLite</Filter>
+    </ClInclude>
+    <ClInclude Include="Time\HighResolutionClock.h">
+      <Filter>Header Files\Time</Filter>
+    </ClInclude>
+    <ClInclude Include="Time\SystemClock.h">
+      <Filter>Header Files\Time</Filter>
+    </ClInclude>
+    <ClInclude Include="Time\Time.h">
+      <Filter>Header Files\Time</Filter>
+    </ClInclude>
+    <ClInclude Include="Type\Double.h">
+      <Filter>Header Files\Type</Filter>
     </ClInclude>
     <ClInclude Include="Utility\DisplayEnumerator.h">
-      <Filter>Source Files\Utility</Filter>
+      <Filter>Header Files\Utility</Filter>
+    </ClInclude>
+    <ClInclude Include="Utility\IndexerV1.h">
+      <Filter>Header Files\Utility</Filter>
+    </ClInclude>
+    <ClInclude Include="Utility\IndexerV2.h">
+      <Filter>Header Files\Utility</Filter>
+    </ClInclude>
+    <ClInclude Include="Utility\MassOp.h">
+      <Filter>Header Files\Utility</Filter>
+    </ClInclude>
+    <ClInclude Include="Utility\WindowMessageHandler.h">
+      <Filter>Header Files\Utility</Filter>
+    </ClInclude>
+    <ClInclude Include="Type\Long.h">
+      <Filter>Header Files\Type</Filter>
+    </ClInclude>
+    <ClInclude Include="Utility\ThreadWrapper.h">
+      <Filter>Header Files\Utility</Filter>
+    </ClInclude>
+    <ClInclude Include="System\Threading.h">
+      <Filter>Header Files\System</Filter>
+    </ClInclude>
+    <ClInclude Include="Time\Timer.h">
+      <Filter>Header Files\Time</Filter>
+    </ClInclude>
+    <ClInclude Include="System\FileSystem.h">
+      <Filter>Header Files\System</Filter>
     </ClInclude>
   </ItemGroup>
   <ItemGroup>
-    <None Include="BlitzUtility.bb">
-      <Filter>Blitz Files</Filter>
+    <None Include="Resources\BlitzUtility.bb">
+      <Filter>Resource Files</Filter>
     </None>
-    <None Include="BlitzUtility.decls">
-      <Filter>Blitz Files</Filter>
+    <None Include="Resources\BlitzUtility.decls">
+      <Filter>Resource Files</Filter>
+    </None>
+    <None Include="Resources\BlitzUtility.LICENSE">
+      <Filter>Resource Files</Filter>
+    </None>
+    <None Include="Resources\BlitzUtility.LICENSE.lesser">
+      <Filter>Resource Files</Filter>
     </None>
-    <None Include="LICENSE" />
-    <None Include="LICENSE.lesser" />
   </ItemGroup>
 </Project>

BlitzUtility.vcxproj.user

@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <PropertyGroup />
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup />
 </Project>

Container/List.cpp

@@ -1,273 +1,272 @@
-//	BlitzUtility - Expanding the normal Blitz functionality.
-//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
-//
-//	This program is free software: you can redistribute it and/or modify
-//	it under the terms of the GNU Lesser General Public License as
-//	published by the Free Software Foundation, either version 3 of the 
-//	License, or (at your option) any later version.
-//
-//	This program is distributed in the hope that it will be useful,
-//	but WITHOUT ANY WARRANTY; without even the implied warranty of
-//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//	GNU General Public License for more details.
-//
-//	You should have received a copy of the GNU Lesser General Public License
-//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-#pragma once
-#include "List.h"
-
-
-DLL_METHOD List* DLL_CALL BU_List_Create(BBTypeElement* element) {
-	// Make sure the given element is valid.
-	if (element == NULL)
-		return NULL;
-	element = (BBTypeElement*)((uint32_t*)element - 5);
-
-	// Create our List.
-	List* myList = new List;
-	myList->originalType = element->type;
-
-	// Create a fake base Type by copying data.
-	myList->fakeType = new BBType;
-	myList->fakeType->fieldCount = myList->originalType->fieldCount;
-	myList->fakeType->free.type = myList->originalType->free.type;
-	myList->fakeType->free.refCount = myList->originalType->free.refCount;
-	myList->fakeType->free.fields = myList->originalType->free.fields;
-	myList->fakeType->free.next = (BBTypeElement*)&myList->fakeType->free;
-	myList->fakeType->free.prev = (BBTypeElement*)&myList->fakeType->free;
-	myList->fakeType->used.type = myList->originalType->used.type;
-	myList->fakeType->used.refCount = myList->originalType->used.refCount;
-	myList->fakeType->used.fields = myList->originalType->used.fields;
-	myList->fakeType->used.prev = (BBTypeElement*)&myList->fakeType->used;
-	myList->fakeType->used.next = (BBTypeElement*)&myList->fakeType->used;
-
-	// Remove element from original flow.
-	element->prev->next = element->next;
-	element->next->prev = element->prev;
-	element->prev = NULL;
-	element->next = NULL;
-	element->type = myList->fakeType;
-
-	// Store the element for later use;
-	myList->storageElement = element;
-	myList->storageElementFields = element->fields;
-
-	return myList;
-}
-
-DLL_METHOD void DLL_CALL BU_List_Destroy(List* list) {
-	if (list == NULL)
-		return;
-
-	// Append remaining elements to original type.
-	BBTypeElement *thisEl = NULL;
-	for (thisEl = list->fakeType->used.next; thisEl != (BBTypeElement*)&list->fakeType->used; thisEl = list->fakeType->used.next) {
-		// Remove from fakeType's flow.
-		thisEl->prev->next = thisEl->next;
-		thisEl->next->prev = thisEl->prev;
-
-		// Append to originalType's flow.
-		thisEl->prev = list->originalType->used.prev;
-		thisEl->prev->next = thisEl;
-		thisEl->next = (BBTypeElement*)&list->originalType->used;
-		thisEl->next->prev = thisEl;
-	}
-	for (thisEl = list->fakeType->free.next; thisEl != (BBTypeElement*)&list->fakeType->free; thisEl = list->fakeType->free.next) {
-		// Remove from fakeType's flow.
-		thisEl->prev->next = thisEl->next;
-		thisEl->next->prev = thisEl->prev;
-
-		// Append to originalType's flow.
-		thisEl->prev = list->originalType->free.prev;
-		thisEl->prev->next = thisEl;
-		thisEl->next = (BBTypeElement*)&list->originalType->free;
-		thisEl->next->prev = thisEl;
-	}
-	
-	// Append storageElement to original type.
-	thisEl = list->storageElement;
-	thisEl->prev = list->originalType->used.prev;
-	thisEl->prev->next = thisEl;
-	thisEl->next = (BBTypeElement*)&list->originalType->used;
-	thisEl->next->prev = thisEl;
-	thisEl->type = list->originalType;
-	thisEl->fields = list->storageElementFields;
-
-	// Delete custom objects.
-	delete list->fakeType;
-	delete list;
-}
-
-DLL_METHOD uint32_t DLL_CALL BU_List_First(List* list) {
-	if (list == NULL)
-		return FALSE;
-
-	BBTypeElement* element = list->fakeType->used.next;
-	if (element == (BBTypeElement*)&list->fakeType->used)
-		return FALSE; // End of List.
-
-	// Copy data from selected element.
-	list->storageElement->fields = element->fields;
-
-	// Make deletion easier
-	list->storageElement->next = element;
-	list->storageElement->prev = element;
-
-	return TRUE;
-}
-
-DLL_METHOD uint32_t DLL_CALL BU_List_Last(List* list) {
-	if (list == NULL)
-		return FALSE;
-	
-	BBTypeElement* element = list->fakeType->used.prev;
-	if (element == (BBTypeElement*)&list->fakeType->used)
-		return FALSE; // End of List.
-
-	// Copy data from selected element.
-	list->storageElement->fields = element->fields;
-
-	// Make deletion easier
-	list->storageElement->next = element;
-	list->storageElement->prev = element;
-
-	return TRUE;
-}
-
-DLL_METHOD uint32_t DLL_CALL BU_List_Previous(List* list) {
-	if (list == NULL)
-		return FALSE;
-
-	BBTypeElement* element = list->storageElement->prev->prev;
-	if (element == (BBTypeElement*)&list->fakeType->used)
-		return FALSE; // End of List.
-
-	// Copy data from selected element.
-	list->storageElement->fields = element->fields;
-
-	// Make deletion easier
-	list->storageElement->next = element;
-	list->storageElement->prev = element;
-
-	return TRUE;
-}
-
-DLL_METHOD uint32_t DLL_CALL BU_List_Next(List* list) {
-	if (list == NULL)
-		return FALSE;
-
-	BBTypeElement* element = list->storageElement->next->next;
-	if (element == (BBTypeElement*)&list->fakeType->used)
-		return FALSE; // End of List.
-
-	// Copy data from selected element.
-	list->storageElement->fields = element->fields;
-
-	// Make deletion easier
-	list->storageElement->next = element;
-	list->storageElement->prev = element;
-
-	return TRUE;
-}
-
-DLL_METHOD uint32_t DLL_CALL BU_List_Before(List* list, BBTypeElement* other) {
-	if (list == NULL)
-		return FALSE;
-	if (other == NULL)
-		return FALSE;
-
-	other = (BBTypeElement*)((uint32_t*)other - 5);
-	if (other->type != list->fakeType)
-		return FALSE;
-
-	BBTypeElement* element = other->prev;
-	if (element == (BBTypeElement*)&list->fakeType->used)
-		return FALSE; // End of List.
-
-	// Copy data from selected element.
-	list->storageElement->fields = element->fields;
-
-	// Make deletion easier
-	list->storageElement->next = element;
-	list->storageElement->prev = element;
-
-	return TRUE;
-}
-
-DLL_METHOD uint32_t DLL_CALL BU_List_After(List* list, BBTypeElement* other) {
-	if (list == NULL)
-		return FALSE;
-	if (other == NULL)
-		return FALSE;
-
-	other = (BBTypeElement*)((uint32_t*)other - 5);
-	if (other->type != list->fakeType)
-		return FALSE;
-
-	BBTypeElement* element = other->next;
-	if (element == (BBTypeElement*)&list->fakeType->used)
-		return FALSE; // End of List.
-
-	// Copy data from selected element.
-	list->storageElement->fields = element->fields;
-
-	// Make deletion easier
-	list->storageElement->next = element;
-	list->storageElement->prev = element;
-
-	return TRUE;
-}
-
-DLL_METHOD void DLL_CALL BU_List_Insert(List* list, BBTypeElement* element) {
-	BU_List_InsertEx(list, element, NULL);
-}
-
-DLL_METHOD void DLL_CALL BU_List_InsertEx(List* list, BBTypeElement* element, BBTypeElement* other) {
-	if (list == NULL)
-		return;
-
-	// Make sure element is a valid pointer.
-	if (element == NULL)
-		return;
-	element = (BBTypeElement*)((uint32_t*)element - 5);
-	if (element->type != list->originalType)
-		return; // Can't add elements from other types, could cause serious issues.
-
-	// Make sure other is a valid pointer.
-	if (other == NULL) {
-		other = (BBTypeElement*)&list->fakeType->used;
-	} else {
-		other = (BBTypeElement*)((uint32_t*)other - 5);
-
-		// Other element must be of the same fakeType.
-		if (other->type != list->fakeType)
-			return;
-	}
-
-	// Insert the element after(!) the other element.
-	element->prev = other->prev;
-	element->next = other;
-	element->prev->next = element;
-	element->next->prev = element;
-	element->type = list->fakeType;
-}
-
-DLL_METHOD void DLL_CALL BU_List_Remove(List* list, BBTypeElement* element) {
-	if (list == NULL)
-		return;
-	if (element == NULL)
-		return;
-	
-	element = (BBTypeElement*)((uint32_t*)element - 5);
-	if (element->type != list->fakeType)
-		return; // Can't remove elements from another type.
-
-	element->type = list->originalType;
-	element->prev = list->originalType->used.prev;
-	element->next = (BBTypeElement*)&list->originalType->used;
-	list->originalType->used.prev->next = element;
-	list->originalType->used.prev = element;
-}
-
-
+//	BlitzUtility - Expanding the normal Blitz functionality.
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#pragma once
+#include "List.h"
+
+DLL_FUNCTION(List*) BU_List_Create(BBTypeElement* element) {
+	// Make sure the given element is valid.
+	if (element == NULL)
+		return NULL;
+	element = (BBTypeElement*)((uint32_t*)element - 5);
+
+	// Create our List.
+	List* myList = new List;
+	myList->originalType = element->type;
+
+	// Create a fake base Type by copying data.
+	myList->fakeType = new BBType;
+	myList->fakeType->fieldCount = myList->originalType->fieldCount;
+	myList->fakeType->free.type = myList->originalType->free.type;
+	myList->fakeType->free.refCount = myList->originalType->free.refCount;
+	myList->fakeType->free.fields = myList->originalType->free.fields;
+	myList->fakeType->free.next = (BBTypeElement*)&myList->fakeType->free;
+	myList->fakeType->free.prev = (BBTypeElement*)&myList->fakeType->free;
+	myList->fakeType->used.type = myList->originalType->used.type;
+	myList->fakeType->used.refCount = myList->originalType->used.refCount;
+	myList->fakeType->used.fields = myList->originalType->used.fields;
+	myList->fakeType->used.prev = (BBTypeElement*)&myList->fakeType->used;
+	myList->fakeType->used.next = (BBTypeElement*)&myList->fakeType->used;
+
+	// Remove element from original flow.
+	element->prev->next = element->next;
+	element->next->prev = element->prev;
+	element->prev = NULL;
+	element->next = NULL;
+	element->type = myList->fakeType;
+
+	// Store the element for later use;
+	myList->storageElement = element;
+	myList->storageElementFields = element->fields;
+
+	return myList;
+}
+
+DLL_FUNCTION(void) BU_List_Destroy(List* list) {
+	if (list == NULL)
+		return;
+
+	// Append remaining elements to original type.
+	BBTypeElement *thisEl = NULL;
+	for (thisEl = list->fakeType->used.next; thisEl != (BBTypeElement*)&list->fakeType->used; thisEl = list->fakeType->used.next) {
+		// Remove from fakeType's flow.
+		thisEl->prev->next = thisEl->next;
+		thisEl->next->prev = thisEl->prev;
+
+		// Append to originalType's flow.
+		thisEl->prev = list->originalType->used.prev;
+		thisEl->prev->next = thisEl;
+		thisEl->next = (BBTypeElement*)&list->originalType->used;
+		thisEl->next->prev = thisEl;
+	}
+	for (thisEl = list->fakeType->free.next; thisEl != (BBTypeElement*)&list->fakeType->free; thisEl = list->fakeType->free.next) {
+		// Remove from fakeType's flow.
+		thisEl->prev->next = thisEl->next;
+		thisEl->next->prev = thisEl->prev;
+
+		// Append to originalType's flow.
+		thisEl->prev = list->originalType->free.prev;
+		thisEl->prev->next = thisEl;
+		thisEl->next = (BBTypeElement*)&list->originalType->free;
+		thisEl->next->prev = thisEl;
+	}
+	
+	// Append storageElement to original type.
+	thisEl = list->storageElement;
+	thisEl->prev = list->originalType->used.prev;
+	thisEl->prev->next = thisEl;
+	thisEl->next = (BBTypeElement*)&list->originalType->used;
+	thisEl->next->prev = thisEl;
+	thisEl->type = list->originalType;
+	thisEl->fields = list->storageElementFields;
+
+	// Delete custom objects.
+	delete list->fakeType;
+	delete list;
+}
+
+DLL_FUNCTION(uint32_t) BU_List_First(List* list) {
+	if (list == NULL)
+		return FALSE;
+
+	BBTypeElement* element = list->fakeType->used.next;
+	if (element == (BBTypeElement*)&list->fakeType->used)
+		return FALSE; // End of List.
+
+	// Copy data from selected element.
+	list->storageElement->fields = element->fields;
+
+	// Make deletion easier
+	list->storageElement->next = element;
+	list->storageElement->prev = element;
+
+	return TRUE;
+}
+
+DLL_FUNCTION(uint32_t) BU_List_Last(List* list) {
+	if (list == NULL)
+		return FALSE;
+	
+	BBTypeElement* element = list->fakeType->used.prev;
+	if (element == (BBTypeElement*)&list->fakeType->used)
+		return FALSE; // End of List.
+
+	// Copy data from selected element.
+	list->storageElement->fields = element->fields;
+
+	// Make deletion easier
+	list->storageElement->next = element;
+	list->storageElement->prev = element;
+
+	return TRUE;
+}
+
+DLL_FUNCTION(uint32_t) BU_List_Previous(List* list) {
+	if (list == NULL)
+		return FALSE;
+
+	BBTypeElement* element = list->storageElement->prev->prev;
+	if (element == (BBTypeElement*)&list->fakeType->used)
+		return FALSE; // End of List.
+
+	// Copy data from selected element.
+	list->storageElement->fields = element->fields;
+
+	// Make deletion easier
+	list->storageElement->next = element;
+	list->storageElement->prev = element;
+
+	return TRUE;
+}
+
+DLL_FUNCTION(uint32_t) BU_List_Next(List* list) {
+	if (list == NULL)
+		return FALSE;
+
+	BBTypeElement* element = list->storageElement->next->next;
+	if (element == (BBTypeElement*)&list->fakeType->used)
+		return FALSE; // End of List.
+
+	// Copy data from selected element.
+	list->storageElement->fields = element->fields;
+
+	// Make deletion easier
+	list->storageElement->next = element;
+	list->storageElement->prev = element;
+
+	return TRUE;
+}
+
+DLL_FUNCTION(uint32_t) BU_List_Before(List* list, BBTypeElement* other) {
+	if (list == NULL)
+		return FALSE;
+	if (other == NULL)
+		return FALSE;
+
+	other = (BBTypeElement*)((uint32_t*)other - 5);
+	if (other->type != list->fakeType)
+		return FALSE;
+
+	BBTypeElement* element = other->prev;
+	if (element == (BBTypeElement*)&list->fakeType->used)
+		return FALSE; // End of List.
+
+	// Copy data from selected element.
+	list->storageElement->fields = element->fields;
+
+	// Make deletion easier
+	list->storageElement->next = element;
+	list->storageElement->prev = element;
+
+	return TRUE;
+}
+
+DLL_FUNCTION(uint32_t) BU_List_After(List* list, BBTypeElement* other) {
+	if (list == NULL)
+		return FALSE;
+	if (other == NULL)
+		return FALSE;
+
+	other = (BBTypeElement*)((uint32_t*)other - 5);
+	if (other->type != list->fakeType)
+		return FALSE;
+
+	BBTypeElement* element = other->next;
+	if (element == (BBTypeElement*)&list->fakeType->used)
+		return FALSE; // End of List.
+
+	// Copy data from selected element.
+	list->storageElement->fields = element->fields;
+
+	// Make deletion easier
+	list->storageElement->next = element;
+	list->storageElement->prev = element;
+
+	return TRUE;
+}
+
+DLL_FUNCTION(void) BU_List_Insert(List* list, BBTypeElement* element) {
+	BU_List_InsertEx(list, element, NULL);
+}
+
+DLL_FUNCTION(void) BU_List_InsertEx(List* list, BBTypeElement* element, BBTypeElement* other) {
+	if (list == NULL)
+		return;
+
+	// Make sure element is a valid pointer.
+	if (element == NULL)
+		return;
+	element = (BBTypeElement*)((uint32_t*)element - 5);
+	if (element->type != list->originalType)
+		return; // Can't add elements from other types, could cause serious issues.
+
+	// Make sure other is a valid pointer.
+	if (other == NULL) {
+		other = (BBTypeElement*)&list->fakeType->used;
+	} else {
+		other = (BBTypeElement*)((uint32_t*)other - 5);
+
+		// Other element must be of the same fakeType.
+		if (other->type != list->fakeType)
+			return;
+	}
+
+	// Insert the element after(!) the other element.
+	element->prev = other->prev;
+	element->next = other;
+	element->prev->next = element;
+	element->next->prev = element;
+	element->type = list->fakeType;
+}
+
+DLL_FUNCTION(void) BU_List_Remove(List* list, BBTypeElement* element) {
+	if (list == NULL)
+		return;
+	if (element == NULL)
+		return;
+	
+	element = (BBTypeElement*)((uint32_t*)element - 5);
+	if (element->type != list->fakeType)
+		return; // Can't remove elements from another type.
+
+	element->type = list->originalType;
+	element->prev = list->originalType->used.prev;
+	element->next = (BBTypeElement*)&list->originalType->used;
+	list->originalType->used.prev->next = element;
+	list->originalType->used.prev = element;
+}
+
+

Container/List.h

@@ -1,85 +1,85 @@
-//	BlitzUtility - Expanding the normal Blitz functionality.
-//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
-//
-//	This program is free software: you can redistribute it and/or modify
-//	it under the terms of the GNU Lesser General Public License as
-//	published by the Free Software Foundation, either version 3 of the 
-//	License, or (at your option) any later version.
-//
-//	This program is distributed in the hope that it will be useful,
-//	but WITHOUT ANY WARRANTY; without even the implied warranty of
-//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//	GNU General Public License for more details.
-//
-//	You should have received a copy of the GNU Lesser General Public License
-//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-#pragma once
-#include "dllmain.h"
-
-// Reverse engineered from https://github.com/blitz-research/blitz3d/blob/master/compiler/declnode.cpp
-enum BBVarType {
-	Global = 0,
-	Int = 1,
-	Float = 2,
-	String = 4,
-	Type = 5,
-	Array = 6
-};
-
-// Basic Blitz Variable
-struct BBVar {
-	uint32_t type;
-	uint32_t value;
-};
-
-// Basic Type predefinition.
-struct BBType;
-
-// Basic Type Element
-struct BBTypeElement {
-	uint32_t* fields;
-	BBTypeElement* next;
-	BBTypeElement* prev;
-	BBType* type;
-	unsigned int refCount;
-};
-
-// Basic Type
-struct BBType {
-	uint32_t type;
-	BBTypeElement used, free;
-	uint32_t fieldCount;
-};
-
-// List struct.
-struct List {
-	BBType* originalType;
-	BBType* fakeType;
-
-	BBTypeElement* storageElement;
-	uint32_t* storageElementFields;
-};
-
-DLL_METHOD List* DLL_CALL BU_List_Create(BBTypeElement* element);
-#pragma comment(linker, "/EXPORT:BU_List_Create=_BU_List_Create@4")
-DLL_METHOD void DLL_CALL BU_List_Destroy(List* list);
-#pragma comment(linker, "/EXPORT:BU_List_Destroy=_BU_List_Destroy@4")
-DLL_METHOD uint32_t DLL_CALL BU_List_First(List* list);
-#pragma comment(linker, "/EXPORT:BU_List_First=_BU_List_First@4")
-DLL_METHOD uint32_t DLL_CALL BU_List_Last(List* list);
-#pragma comment(linker, "/EXPORT:BU_List_Last=_BU_List_Last@4")
-DLL_METHOD uint32_t DLL_CALL BU_List_Previous(List* list);
-#pragma comment(linker, "/EXPORT:BU_List_Previous=_BU_List_Previous@4")
-DLL_METHOD uint32_t DLL_CALL BU_List_Next(List* list);
-#pragma comment(linker, "/EXPORT:BU_List_Next=_BU_List_Next@4")
-DLL_METHOD uint32_t DLL_CALL BU_List_Before(List* list, BBTypeElement* other);
-#pragma comment(linker, "/EXPORT:BU_List_Before=_BU_List_Before@8")
-DLL_METHOD uint32_t DLL_CALL BU_List_After(List* list, BBTypeElement* other);
-#pragma comment(linker, "/EXPORT:BU_List_After=_BU_List_After@8")
-DLL_METHOD void DLL_CALL BU_List_Insert(List* list, BBTypeElement* element);
-#pragma comment(linker, "/EXPORT:BU_List_Insert=_BU_List_Insert@8")
-DLL_METHOD void DLL_CALL BU_List_InsertEx(List* list, BBTypeElement* element, BBTypeElement* other);
-#pragma comment(linker, "/EXPORT:BU_List_InsertEx=_BU_List_InsertEx@12")
-DLL_METHOD void DLL_CALL BU_List_Remove(List* list, BBTypeElement* element);
-#pragma comment(linker, "/EXPORT:BU_List_Remove=_BU_List_Remove@8")
+//	BlitzUtility - Expanding the normal Blitz functionality.
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#pragma once
+#include "BlitzUtility.h"
+
+// Reverse engineered from https://github.com/blitz-research/blitz3d/blob/master/compiler/declnode.cpp
+enum BBVarType {
+	Global = 0,
+	Int = 1,
+	Float = 2,
+	String = 4,
+	Type = 5,
+	Array = 6
+};
+
+// Basic Blitz Variable
+struct BBVar {
+	uint32_t type;
+	uint32_t value;
+};
+
+// Basic Type predefinition.
+struct BBType;
+
+// Basic Type Element
+struct BBTypeElement {
+	uint32_t* fields;
+	BBTypeElement* next;
+	BBTypeElement* prev;
+	BBType* type;
+	unsigned int refCount;
+};
+
+// Basic Type
+struct BBType {
+	uint32_t type;
+	BBTypeElement used, free;
+	uint32_t fieldCount;
+};
+
+// List struct.
+struct List {
+	BBType* originalType;
+	BBType* fakeType;
+
+	BBTypeElement* storageElement;
+	uint32_t* storageElementFields;
+};
+
+DLL_FUNCTION(List*) BU_List_Create(BBTypeElement* element);
+#pragma comment(linker, "/EXPORT:BU_List_Create=_BU_List_Create@4")
+DLL_FUNCTION(void) BU_List_Destroy(List* list);
+#pragma comment(linker, "/EXPORT:BU_List_Destroy=_BU_List_Destroy@4")
+DLL_FUNCTION(uint32_t) BU_List_First(List* list);
+#pragma comment(linker, "/EXPORT:BU_List_First=_BU_List_First@4")
+DLL_FUNCTION(uint32_t) BU_List_Last(List* list);
+#pragma comment(linker, "/EXPORT:BU_List_Last=_BU_List_Last@4")
+DLL_FUNCTION(uint32_t) BU_List_Previous(List* list);
+#pragma comment(linker, "/EXPORT:BU_List_Previous=_BU_List_Previous@4")
+DLL_FUNCTION(uint32_t) BU_List_Next(List* list);
+#pragma comment(linker, "/EXPORT:BU_List_Next=_BU_List_Next@4")
+DLL_FUNCTION(uint32_t) BU_List_Before(List* list, BBTypeElement* other);
+#pragma comment(linker, "/EXPORT:BU_List_Before=_BU_List_Before@8")
+DLL_FUNCTION(uint32_t) BU_List_After(List* list, BBTypeElement* other);
+#pragma comment(linker, "/EXPORT:BU_List_After=_BU_List_After@8")
+DLL_FUNCTION(void) BU_List_Insert(List* list, BBTypeElement* element);
+#pragma comment(linker, "/EXPORT:BU_List_Insert=_BU_List_Insert@8")
+DLL_FUNCTION(void) BU_List_InsertEx(List* list, BBTypeElement* element, BBTypeElement* other);
+#pragma comment(linker, "/EXPORT:BU_List_InsertEx=_BU_List_InsertEx@12")
+DLL_FUNCTION(void) BU_List_Remove(List* list, BBTypeElement* element);
+#pragma comment(linker, "/EXPORT:BU_List_Remove=_BU_List_Remove@8")

Container/TypeList.cpp

@@ -1,76 +1,76 @@
-//	BlitzUtility - Expanding the normal Blitz functionality.
-//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
-//
-//	This program is free software: you can redistribute it and/or modify
-//	it under the terms of the GNU Lesser General Public License as
-//	published by the Free Software Foundation, either version 3 of the 
-//	License, or (at your option) any later version.
-//
-//	This program is distributed in the hope that it will be useful,
-//	but WITHOUT ANY WARRANTY; without even the implied warranty of
-//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//	GNU General Public License for more details.
-//
-//	You should have received a copy of the GNU Lesser General Public License
-//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-#pragma once;
-#include "TypeList.h"
-
-DLL_METHOD TypeList* DLL_CALL BU_TypeList_Create(BBTypeElement* element) {
-	// Make sure the given element is valid.
-	if (element == NULL)
-		return NULL;
-	element = (BBTypeElement*)(((uint32_t*)element) - 5);
-
-	// Create our TypeList.
-	TypeList* list = new TypeList();
-	list->type = element->type;
-	list->firstElement = element;
-	list->lastElement = element;
-
-	// Remove the given element from the flow of the type.
-	element->prev->next = element->next;
-	element->next->prev = element->prev;
-	element->prev = (BBTypeElement*)&list->type->used;
-	element->next = (BBTypeElement*)&list->type->used;
-
-	// Return the list.
-	return list;
-}
-
-DLL_METHOD void DLL_CALL BU_TypeList_Destroy(TypeList* list) {
-	// Make sure we have a valid list.
-	if (list == NULL)
-		return;
-
-	// Append elements to the original type.
-	list->firstElement->prev = list->type->used.prev;
-	list->firstElement->prev->next = list->firstElement;
-	list->lastElement->next = (BBTypeElement*)&list->type->used;
-	list->lastElement->next->prev = list->lastElement;
-
-	// Free our TypeList.
-	delete list;
-}
-
-DLL_METHOD void DLL_CALL BU_TypeList_Activate(TypeList* list) {
-	// Store current pointers
-	list->storedFirstElement = list->type->used.next;
-	list->storedLastElement = list->type->used.prev;
-
-	// ... and replace them.
-	list->type->used.next = list->firstElement;
-	list->type->used.prev = list->lastElement;
-}
-
-DLL_METHOD void DLL_CALL BU_TypeList_Deactivate(TypeList* list) {
-	// Store current pointers
-	list->firstElement = list->type->used.next;
-	list->lastElement = list->type->used.prev;
-
-	// ... and replace them.
-	list->type->used.next = list->storedFirstElement;
-	list->type->used.prev = list->storedLastElement;
-}
-
+//	BlitzUtility - Expanding the normal Blitz functionality.
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#pragma once;
+#include "TypeList.h"
+
+DLL_FUNCTION(TypeList*) BU_TypeList_Create(BBTypeElement* element) {
+	// Make sure the given element is valid.
+	if (element == NULL)
+		return NULL;
+	element = (BBTypeElement*)(((uint32_t*)element) - 5);
+
+	// Create our TypeList.
+	TypeList* list = new TypeList();
+	list->type = element->type;
+	list->firstElement = element;
+	list->lastElement = element;
+
+	// Remove the given element from the flow of the type.
+	element->prev->next = element->next;
+	element->next->prev = element->prev;
+	element->prev = (BBTypeElement*)&list->type->used;
+	element->next = (BBTypeElement*)&list->type->used;
+
+	// Return the list.
+	return list;
+}
+
+DLL_FUNCTION(void) BU_TypeList_Destroy(TypeList* list) {
+	// Make sure we have a valid list.
+	if (list == NULL)
+		return;
+
+	// Append elements to the original type.
+	list->firstElement->prev = list->type->used.prev;
+	list->firstElement->prev->next = list->firstElement;
+	list->lastElement->next = (BBTypeElement*)&list->type->used;
+	list->lastElement->next->prev = list->lastElement;
+
+	// Free our TypeList.
+	delete list;
+}
+
+DLL_FUNCTION(void) BU_TypeList_Activate(TypeList* list) {
+	// Store current pointers
+	list->storedFirstElement = list->type->used.next;
+	list->storedLastElement = list->type->used.prev;
+
+	// ... and replace them.
+	list->type->used.next = list->firstElement;
+	list->type->used.prev = list->lastElement;
+}
+
+DLL_FUNCTION(void) BU_TypeList_Deactivate(TypeList* list) {
+	// Store current pointers
+	list->firstElement = list->type->used.next;
+	list->lastElement = list->type->used.prev;
+
+	// ... and replace them.
+	list->type->used.next = list->storedFirstElement;
+	list->type->used.prev = list->storedLastElement;
+}
+

Container/TypeList.h

@@ -1,36 +1,39 @@
-//	BlitzUtility - Expanding the normal Blitz functionality.
-//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
-//
-//	This program is free software: you can redistribute it and/or modify
-//	it under the terms of the GNU Lesser General Public License as
-//	published by the Free Software Foundation, either version 3 of the 
-//	License, or (at your option) any later version.
-//
-//	This program is distributed in the hope that it will be useful,
-//	but WITHOUT ANY WARRANTY; without even the implied warranty of
-//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//	GNU General Public License for more details.
-//
-//	You should have received a copy of the GNU Lesser General Public License
-//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-#pragma once
-#include "dllmain.h"
-#include "List.h"
-#include <list>
-
-struct TypeList {
-	BBType *type;
-
-	BBTypeElement *storedFirstElement, *storedLastElement;
-	BBTypeElement *firstElement, *lastElement;
-};
-
-DLL_METHOD TypeList* DLL_CALL BU_TypeList_Create(BBTypeElement* element);
-#pragma comment(linker, "/EXPORT:BU_TypeList_Create=_BU_TypeList_Create@4")
-DLL_METHOD void DLL_CALL BU_TypeList_Destroy(TypeList* list);
-#pragma comment(linker, "/EXPORT:BU_TypeList_Destroy=_BU_TypeList_Destroy@4")
-DLL_METHOD void DLL_CALL BU_TypeList_Activate(TypeList* list);
-#pragma comment(linker, "/EXPORT:BU_TypeList_Activate=_BU_TypeList_Activate@4")
-DLL_METHOD void DLL_CALL BU_TypeList_Deactivate(TypeList* list);
-#pragma comment(linker, "/EXPORT:BU_TypeList_Deactivate=_BU_TypeList_Deactivate@4")
+//	BlitzUtility - Expanding the normal Blitz functionality.
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#pragma once
+#include "BlitzUtility.h"
+#include "Container/List.h"
+#include <list>
+
+struct BBType;
+struct BBTypeElement;
+
+struct TypeList {
+	BBType *type;
+
+	BBTypeElement *storedFirstElement, *storedLastElement;
+	BBTypeElement *firstElement, *lastElement;
+};
+
+DLL_FUNCTION(TypeList*) BU_TypeList_Create(BBTypeElement* element);
+#pragma comment(linker, "/EXPORT:BU_TypeList_Create=_BU_TypeList_Create@4")
+DLL_FUNCTION(void) BU_TypeList_Destroy(TypeList* list);
+#pragma comment(linker, "/EXPORT:BU_TypeList_Destroy=_BU_TypeList_Destroy@4")
+DLL_FUNCTION(void) BU_TypeList_Activate(TypeList* list);
+#pragma comment(linker, "/EXPORT:BU_TypeList_Activate=_BU_TypeList_Activate@4")
+DLL_FUNCTION(void) BU_TypeList_Deactivate(TypeList* list);
+#pragma comment(linker, "/EXPORT:BU_TypeList_Deactivate=_BU_TypeList_Deactivate@4")

Database/SQLite/SQLite.cpp

@@ -1,90 +1,513 @@
-//	BlitzUtility - Expanding the normal Blitz functionality.
-//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
-//
-//	This program is free software: you can redistribute it and/or modify
-//	it under the terms of the GNU Lesser General Public License as
-//	published by the Free Software Foundation, either version 3 of the 
-//	License, or (at your option) any later version.
-//
-//	This program is distributed in the hope that it will be useful,
-//	but WITHOUT ANY WARRANTY; without even the implied warranty of
-//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//	GNU General Public License for more details.
-//
-//	You should have received a copy of the GNU Lesser General Public License
-//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-#include "SQLite.h"
-#include "..\BlitzPointer\BlitzPointer.h"
-
-DLL_METHOD const char* DLL_CALL SQLite_Version() {
-	return sqlite3_version;
-}
-DLL_METHOD int32_t DLL_CALL SQLite_ThreadSafe() {
-	return sqlite3_threadsafe();
-}
-
-DLL_METHOD int32_t DLL_CALL SQLite_Initialize() {
-	return sqlite3_initialize();
-}
-
-DLL_METHOD int32_t DLL_CALL SQLite_Shutdown() {
-	return sqlite3_shutdown();
-}
-
-DLL_METHOD int32_t DLL_CALL SQLite_Open(const char* file, sqlite3** db) {
-	return sqlite3_open(file, db);
-}
-
-DLL_METHOD int32_t DLL_CALL SQLite_Open_V2(const char* file, sqlite3** db, int32_t flags, const char* zVfs) {
-	return sqlite3_open_v2(file, db, flags, zVfs);
-}
-
-DLL_METHOD int32_t DLL_CALL SQLite_Close(sqlite3* db) {
-	return sqlite3_close(db);
-}
-
-DLL_METHOD int32_t DLL_CALL SQLite_Close_V2(sqlite3* db) {
-	return sqlite3_close_v2(db);
-}
-
-DLL_METHOD int32_t DLL_CALL SQLite_ErrCode(sqlite3* db) {
-	return sqlite3_errcode(db);
-}
-
-DLL_METHOD int32_t DLL_CALL SQLite_Extended_ErrCode(sqlite3* db) {
-	return sqlite3_extended_errcode(db);
-}
-
-DLL_METHOD const char* DLL_CALL SQLite_ErrMsg(sqlite3* db) {
-	return sqlite3_errmsg(db);
-}
-
-DLL_METHOD const char* DLL_CALL SQLite_ErrStr(int32_t errCode) {
-	return sqlite3_errstr(errCode);
-}
-
-DLL_METHOD int32_t DLL_CALL SQLite_Release_Memory(int32_t bytes) {
-	return sqlite3_release_memory(bytes);
-}
-
-DLL_METHOD int32_t DLL_CALL SQLite_DB_Release_Memory(sqlite3* db) {
-	return sqlite3_db_release_memory(db);
-}
-
-DLL_METHOD int32_t DLL_CALL SQLite_Busy_Timeout(sqlite3* db, int32_t timeout) {
-	return sqlite3_busy_timeout(db, timeout);
-}
-
-int __cdecl SQLite3_Busy_Handler_Internal(void* handler, int prm) {
-	BP_BlitzFunction1_t lpFunctionPointer = (BP_BlitzFunction1_t)handler;
-	return lpFunctionPointer((int32_t)prm);
-}
-
-DLL_METHOD int32_t DLL_CALL SQLite_Busy_Handler(sqlite3* db, int32_t handler) {
-	return sqlite3_busy_handler(db, SQLite3_Busy_Handler_Internal, (void*)handler);
-}
-
-
-
-
+//	BlitzUtility - Expanding the normal Blitz functionality.
+//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "SQLite.h"
+#include "..\BlitzPointer\BlitzPointer.h"
+
+static int32_t __BU_SQLite_OpenSimpleError = 0;
+
+#pragma region Core
+DLL_FUNCTION(const char*) BU_SQLite_Version() {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Version=_BU_SQLite_Version@0")
+	return sqlite3_libversion();
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Version_Number() {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Version_Number=_BU_SQLite_Version_Number@0")
+	return sqlite3_libversion_number();
+}
+
+DLL_FUNCTION(const char*) BU_SQLite_SourceID() {
+#pragma comment(linker, "/EXPORT:BU_SQLite_SourceID=_BU_SQLite_SourceID@0")
+	return sqlite3_sourceid();
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_CompileOption_Used(const char* zOptName) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_CompileOption_Used=_BU_SQLite_CompileOption_Used@4")
+	return sqlite3_compileoption_used(zOptName);
+}
+
+DLL_FUNCTION(const char*) BU_SQLite_CompileOption_Get(int32_t n) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_CompileOption_Get=_BU_SQLite_CompileOption_Get@4")
+	return sqlite3_compileoption_get(n);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_ThreadSafe() {
+#pragma comment(linker, "/EXPORT:BU_SQLite_ThreadSafe=_BU_SQLite_ThreadSafe@0")
+	return sqlite3_threadsafe();
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Initialize() {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Initialize=_BU_SQLite_Initialize@0")
+	return sqlite3_initialize();
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Shutdown() {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Shutdown=_BU_SQLite_Shutdown@0")
+	return sqlite3_shutdown();
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Sleep(int32_t ms) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Sleep=_BU_SQLite_Sleep@4")
+	return sqlite3_sleep(ms);
+}
+#pragma endregion Core
+
+#pragma region Open & Close
+DLL_FUNCTION(int32_t) BU_SQLite_Open(const char* file, sqlite3** db) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Open=_BU_SQLite_Open@8")
+	return sqlite3_open(file, db);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Open_V2(const char* file, sqlite3** db, int32_t flags, const char* zVfs) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Open_V2=_BU_SQLite_Open_V2@16")
+	return sqlite3_open_v2(file, db, flags, zVfs);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Close(sqlite3* db) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Close=_BU_SQLite_Close@4")
+	return sqlite3_close(db);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Close_V2(sqlite3* db) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Close_V2=_BU_SQLite_Close_V2@4")
+	return sqlite3_close_v2(db);
+}
+
+// Simple Open() and Open_V2()
+DLL_FUNCTION(sqlite3*) BU_SQLite_OpenSimple(const char* file) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_OpenSimple=_BU_SQLite_OpenSimple@4")
+	sqlite3** db = new sqlite3*();
+	__BU_SQLite_OpenSimpleError = sqlite3_open(file, db);
+	sqlite3* ret = *db; delete db; return ret;
+}
+
+DLL_FUNCTION(sqlite3*) BU_SQLite_OpenSimple_V2(const char* file, int32_t flags, const char* zVfs) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_OpenSimple_V2=_BU_SQLite_OpenSimple_V2@12")
+	sqlite3** db = new sqlite3*();
+	__BU_SQLite_OpenSimpleError = sqlite3_open_v2(file, db, flags, zVfs);
+	sqlite3* ret = *db;
+	delete db;
+	return ret;
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_OpenSimpleError() {
+#pragma comment(linker, "/EXPORT:BU_SQLite_OpenSimpleError=_BU_SQLite_OpenSimpleError@0")
+	return __BU_SQLite_OpenSimpleError;
+}
+#pragma endregion Open & Close
+
+#pragma region Error Handling
+DLL_FUNCTION(int32_t) BU_SQLite_Error_Code(sqlite3* db) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Error_Code=_BU_SQLite_Error_Code@4")
+	return sqlite3_errcode(db);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Extended_Error_Code(sqlite3* db) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Extended_Error_Code=_BU_SQLite_Extended_Error_Code@4")
+	return sqlite3_extended_errcode(db);
+}
+
+DLL_FUNCTION(const char*) BU_SQLite_Error_Message(sqlite3* db) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Error_Message=_BU_SQLite_Error_Message@4")
+	return sqlite3_errmsg(db);
+}
+
+DLL_FUNCTION(const char*) BU_SQLite_Error_String(int32_t errCode) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Error_String=_BU_SQLite_Error_String@4")
+	return sqlite3_errstr(errCode);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Extended_Result_Codes(sqlite3* db, int32_t onoff) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Extended_Result_Codes=_BU_SQLite_Extended_Result_Codes@8")
+	return sqlite3_extended_result_codes(db, onoff);
+}
+#pragma endregion Error Handling
+
+#pragma region Busy Handler
+DLL_FUNCTION(int32_t) BU_SQLite_Busy_Timeout(sqlite3* db, int32_t timeout) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Busy_Timeout=_BU_SQLite_Busy_Timeout@8")
+	return sqlite3_busy_timeout(db, timeout);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Busy_Handler(sqlite3* db, int(*phandlerfunc)(void*, int), void* param) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Busy_Handler=_BU_SQLite_Busy_Handler@12")
+	return sqlite3_busy_handler(db, phandlerfunc, param);
+}
+
+int __cdecl BU_SQLite_Busy_Handler_SimpleInternal(void* handler, int prm) {
+	BP_BlitzFunction1_t lpFunctionPointer = (BP_BlitzFunction1_t)handler;
+	return lpFunctionPointer((int32_t)prm);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Busy_Handler_Simple(sqlite3* db, BP_BlitzFunction1_t handler) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Busy_Handler_Simple=_BU_SQLite_Busy_Handler_Simple@8")
+	return sqlite3_busy_handler(db, BU_SQLite_Busy_Handler_SimpleInternal, (void*)handler);
+}
+#pragma endregion Busy Handler
+
+#pragma region Memory Management
+DLL_FUNCTION(int64_t*) BU_SQLite_Memory_Used() {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Memory_Used=_BU_SQLite_Memory_Used@0")
+	return new int64_t(sqlite3_memory_used());
+}
+
+DLL_FUNCTION(int64_t*) BU_SQLite_Memory_Highwater(int32_t bReset) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Memory_Highwater=_BU_SQLite_Memory_Highwater@4")
+	return new int64_t(sqlite3_memory_highwater(bReset));
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Release_Memory(int32_t bytes) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Release_Memory=_BU_SQLite_Release_Memory@4")
+	return sqlite3_release_memory(bytes);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_DB_Release_Memory(sqlite3* db) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_DB_Release_Memory=_BU_SQLite_DB_Release_Memory@4")
+	return sqlite3_db_release_memory(db);
+}
+
+DLL_FUNCTION(void) BU_SQLite_Randomness(int32_t n, void* p) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Randomness=_BU_SQLite_Randomness@8")
+	sqlite3_randomness(n, p);
+}
+#pragma endregion Memory Management
+
+#pragma region Database Management & Modification
+DLL_FUNCTION(int32_t) BU_SQLite_Exec(sqlite3* db, const char* sql, int(*callbackp)(void*, int, char**, char**), void* param, char** errMsg) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Exec=_BU_SQLite_Exec@20")
+	return sqlite3_exec(db, sql, callbackp, param, errMsg);
+}
+
+DLL_FUNCTION(int64_t*) BU_SQLite_Last_Insert_RowId(sqlite3* db) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Last_Insert_RowId=_BU_SQLite_Last_Insert_RowId@4")
+	return new int64_t(sqlite3_last_insert_rowid(db));
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Changes(sqlite3* db) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Changes=_BU_SQLite_Changes@4")
+	return sqlite3_changes(db);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Total_Changes(sqlite3* db) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Total_Changes=_BU_SQLite_Total_Changes@4")
+	return sqlite3_total_changes(db);
+}
+
+DLL_FUNCTION(void) BU_SQLite_Interrupt(sqlite3* db) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Interrupt=_BU_SQLite_Interrupt@4")
+	return sqlite3_interrupt(db);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Complete(const char* sql) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Complete=_BU_SQLite_Complete@4")
+	return sqlite3_complete(sql);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Get_Table(sqlite3* db, const char* zSql, char*** pazResult, int32_t* pnRow, int32_t* pnColumn, char** pzErrMessage) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Get_Table=_BU_SQLite_Get_Table@24")
+	return sqlite3_get_table(db, zSql, pazResult, pnRow, pnColumn, pzErrMessage);
+}
+
+DLL_FUNCTION(void) BU_SQLite_Free_Table(char** result) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Free_Table=_BU_SQLite_Free_Table@4")
+	sqlite3_free_table(result);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Set_Authorizer(sqlite3* db,
+											  int(*xAuth)(void*, int, const char*, const char*, const char*, const char*),
+											  void *pArg) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Set_Authorizer=_BU_SQLite_Set_Authorizer@12")
+	return sqlite3_set_authorizer(db, xAuth, pArg);
+}
+
+DLL_FUNCTION(void*) BU_SQLite_Trace(sqlite3* db,
+								   void(*xTrace)(void*, const char*),
+								   void* param) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Trace=_BU_SQLite_Trace@12")
+	return sqlite3_trace(db, xTrace, param);
+}
+
+DLL_FUNCTION(void*) BU_SQLite_Profile(sqlite3* db,
+									  void(*xProfile)(void*, const char*, sqlite3_uint64),
+									  void* param) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Profile=_BU_SQLite_Profile@12")
+	return sqlite3_profile(db, xProfile, param);
+}
+
+DLL_FUNCTION(void) BU_SQLite_Progress_Handler(sqlite3* db, int32_t nOps, int32_t(*xProgress)(void*), void* pArg) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Progress_Handler=_BU_SQLite_Progress_Handler@16")
+	sqlite3_progress_handler(db, nOps, xProgress, pArg);
+}
+
+DLL_FUNCTION(const char*) BU_SQLite_URI_Parameter(const char* zFilename, const char* zParam) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_URI_Parameter=_BU_SQLite_URI_Parameter@8")
+	return sqlite3_uri_parameter(zFilename, zParam);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_URI_Boolean(const char* zFilename, const char* zParam, int32_t bDefault) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_URI_Boolean=_BU_SQLite_URI_Boolean@12")
+	return sqlite3_uri_boolean(zFilename, zParam, bDefault);
+}
+
+DLL_FUNCTION(int64_t*) BU_SQLite_URI_LongLong(const char* zFilename, const char* zParam, int64_t* bDefault) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_URI_LongLong=_BU_SQLite_URI_LongLong@12")
+	return new int64_t(sqlite3_uri_int64(zFilename, zParam, *bDefault));
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Limit(sqlite3* db, int32_t id, int32_t newVal) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Limit=_BU_SQLite_Limit@12")
+	return sqlite3_limit(db, id, newVal);
+}
+#pragma endregion Database Management & Modification
+
+#pragma region Prepared Statements
+DLL_FUNCTION(sqlite3_stmt*) BU_SQLite_Next_Statement(sqlite3* db, sqlite3_stmt* pStmt) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Next_Statement=_BU_SQLite_Next_Statement@8")
+	return sqlite3_next_stmt(db, pStmt);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Prepare(sqlite3* db, const char* zSql, int32_t nByte, sqlite3_stmt** ppStmt, const char** pzTail) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Prepare=_BU_SQLite_Prepare@20")
+	return sqlite3_prepare(db, zSql, nByte, ppStmt, pzTail);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Prepare_V2(sqlite3* db, const char* zSql, int32_t nByte, sqlite3_stmt** ppStmt, const char** pzTail) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Prepare_V2=_BU_SQLite_Prepare_V2@20")
+	return sqlite3_prepare_v2(db, zSql, nByte, ppStmt, pzTail);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Statement_ReadOnly(sqlite3_stmt* pStmt) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Statement_ReadOnly=_BU_SQLite_Statement_ReadOnly@4")
+	return sqlite3_stmt_readonly(pStmt);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Statement_Busy(sqlite3_stmt* pStmt) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Statement_Busy=_BU_SQLite_Statement_Busy@4")
+	return sqlite3_stmt_busy(pStmt);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Statement_Status(sqlite3_stmt* pStmt, int32_t op, int32_t resetFlag) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Statement_Status=_BU_SQLite_Statement_Status@12")
+	return sqlite3_stmt_status(pStmt, op, resetFlag);
+}
+
+DLL_FUNCTION(const char*) BU_SQLite_SQL(sqlite3_stmt* pStmt) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_SQL=_BU_SQLite_SQL@4")
+	return sqlite3_sql(pStmt);
+}
+
+DLL_FUNCTION(sqlite3*) BU_SQLite_Database_Handle(sqlite3_stmt* pStmt) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Database_Handle=_BU_SQLite_Database_Handle@4")
+	return sqlite3_db_handle(pStmt);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Bind_Null(sqlite3_stmt* pStmt, int32_t index) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Bind_Null=_BU_SQLite_Bind_Null@8")
+	return sqlite3_bind_null(pStmt, index);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Bind_Int(sqlite3_stmt* pStmt, int32_t index, int32_t value) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Bind_Int=_BU_SQLite_Bind_Int@12")
+	return sqlite3_bind_int(pStmt, index, value);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Bind_LongLong(sqlite3_stmt* pStmt, int32_t index, int64_t* pValue) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Bind_LongLong=_BU_SQLite_Bind_LongLong@12")
+	return sqlite3_bind_int64(pStmt, index, *pValue);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Bind_Float(sqlite3_stmt* pStmt, int32_t index, float_t value) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Bind_Float=_BU_SQLite_Bind_Float@12")
+	return sqlite3_bind_double(pStmt, index, (double_t)value);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Bind_Double(sqlite3_stmt* pStmt, int32_t index, double_t* pValue) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Bind_Double=_BU_SQLite_Bind_Double@12")
+	return sqlite3_bind_double(pStmt, index, *pValue);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Bind_Text(sqlite3_stmt* pStmt, int32_t index, const char* zData, int32_t nData) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Bind_Text=_BU_SQLite_Bind_Text@16")
+	return sqlite3_bind_text(pStmt, index, zData, nData, nullptr);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Bind_Blob(sqlite3_stmt* pStmt, int32_t index, void* zData, int32_t nData) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Bind_Blob=_BU_SQLite_Bind_Blob@16")
+	return sqlite3_bind_blob(pStmt, index, zData, nData, nullptr);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Bind_Value(sqlite3_stmt* pStmt, int32_t index, const sqlite3_value* pValue) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Bind_Value=_BU_SQLite_Bind_Value@12")
+	return sqlite3_bind_value(pStmt, index, pValue);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Bind_ZeroBlob(sqlite3_stmt* pStmt, int32_t index, int32_t bytes) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Bind_ZeroBlob=_BU_SQLite_Bind_ZeroBlob@12")
+	return sqlite3_bind_zeroblob(pStmt, index, bytes);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Bind_Parameter_Count(sqlite3_stmt* pStmt) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Bind_Parameter_Count=_BU_SQLite_Bind_Parameter_Count@4")
+	return sqlite3_bind_parameter_count(pStmt);
+}
+
+DLL_FUNCTION(const char*) BU_SQLite_Bind_Parameter_Name(sqlite3_stmt* pStmt, int32_t index) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Bind_Parameter_Name=_BU_SQLite_Bind_Parameter_Name@8")
+	return sqlite3_bind_parameter_name(pStmt, index);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Bind_Parameter_Index(sqlite3_stmt* pStmt, const char* zName) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Bind_Parameter_Index=_BU_SQLite_Bind_Parameter_Index@8")
+	return sqlite3_bind_parameter_index(pStmt, zName);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Clear_Bindings(sqlite3_stmt* pStmt) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Clear_Bindings=_BU_SQLite_Clear_Bindings@4")
+	return sqlite3_clear_bindings(pStmt);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Column_Count(sqlite3_stmt* pStmt) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Column_Count=_BU_SQLite_Column_Count@4")
+	return sqlite3_column_count(pStmt);
+}
+
+DLL_FUNCTION(const char*) BU_SQLite_Column_Name(sqlite3_stmt* pStmt, int32_t n) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Column_Name=_BU_SQLite_Column_Name@8")
+	return sqlite3_column_name(pStmt, n);
+}
+
+DLL_FUNCTION(const char*) BU_SQLite_Column_DeclaredType(sqlite3_stmt* pStmt, int32_t n) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Column_DeclaredType=_BU_SQLite_Column_DeclaredType@8")
+	return sqlite3_column_decltype(pStmt, n);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Step(sqlite3_stmt* pStmt) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Step=_BU_SQLite_Step@4")
+	return sqlite3_step(pStmt);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Data_Count(sqlite3_stmt* pStmt) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Data_Count=_BU_SQLite_Data_Count@4")
+	return sqlite3_data_count(pStmt);
+}
+
+DLL_FUNCTION(const void*) BU_SQLite_Column_Blob(sqlite3_stmt* pStmt, int32_t iCol) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Column_Blob=_BU_SQLite_Column_Blob@8")
+	return sqlite3_column_blob(pStmt, iCol);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Column_Bytes(sqlite3_stmt* pStmt, int32_t iCol) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Column_Bytes=_BU_SQLite_Column_Bytes@8")
+	return sqlite3_column_bytes(pStmt, iCol);
+}
+
+DLL_FUNCTION(float_t) BU_SQLite_Column_Float(sqlite3_stmt* pStmt, int32_t iCol) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Column_Float=_BU_SQLite_Column_Float@8")
+	return (float_t)sqlite3_column_double(pStmt, iCol);
+}
+
+DLL_FUNCTION(double_t*) BU_SQLite_Column_Double(sqlite3_stmt* pStmt, int32_t iCol) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Column_Double=_BU_SQLite_Column_Double@8")
+	return new double_t(sqlite3_column_double(pStmt, iCol));
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Column_Int(sqlite3_stmt* pStmt, int32_t iCol) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Column_Int=_BU_SQLite_Column_Int@8")
+	return sqlite3_column_int(pStmt, iCol);
+}
+
+DLL_FUNCTION(int64_t*) BU_SQLite_Column_LongLong(sqlite3_stmt* pStmt, int32_t iCol) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Column_LongLong=_BU_SQLite_Column_LongLong@8")
+	return new int64_t(sqlite3_column_int64(pStmt, iCol));
+}
+
+DLL_FUNCTION(const char*) BU_SQLite_Column_Text(sqlite3_stmt* pStmt, int32_t iCol) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Column_Text=_BU_SQLite_Column_Text@8")
+	return (const char*)sqlite3_column_text(pStmt, iCol);
+}
+
+DLL_FUNCTION(sqlite3_value*) BU_SQLite_Column_Value(sqlite3_stmt* pStmt, int32_t iCol) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Column_Value=_BU_SQLite_Column_Value@8")
+	return sqlite3_column_value(pStmt, iCol);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Column_Type(sqlite3_stmt* pStmt, int32_t iCol) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Column_Type=_BU_SQLite_Column_Type@8")
+	return sqlite3_column_type(pStmt, iCol);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Finalize(sqlite3_stmt* pStmt) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Finalize=_BU_SQLite_Finalize@4")
+	return sqlite3_finalize(pStmt);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Reset(sqlite3_stmt* pStmt) {
+#pragma comment(linker, "/EXPORT:BU_SQLite_Reset=_BU_SQLite_Reset@4")
+	return sqlite3_reset(pStmt);
+}
+#pragma endregion Prepared Statements
+
+#pragma region SQLite Values
+DLL_FUNCTION(const void*) BU_SQLite_Value_Blob(sqlite3_value* pValue) {
+	return sqlite3_value_blob(pValue);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Value_Bytes(sqlite3_value* pValue) {
+	return sqlite3_value_bytes(pValue);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Value_Int(sqlite3_value* pValue) {
+	return sqlite3_value_int(pValue);
+}
+
+DLL_FUNCTION(int64_t*) BU_SQLite_Value_LongLong(sqlite3_value* pValue) {
+	return new int64_t(sqlite3_value_int64(pValue));
+}
+
+DLL_FUNCTION(float_t) BU_SQLite_Value_Float(sqlite3_value* pValue) {
+	return (float_t)sqlite3_value_double(pValue);
+}
+
+DLL_FUNCTION(double_t*) BU_SQLite_Value_Double(sqlite3_value* pValue) {
+	return new double_t(sqlite3_value_double(pValue));
+}
+
+DLL_FUNCTION(const char*) BU_SQLite_Value_Text(sqlite3_value* pValue) {
+	return (const char*)sqlite3_value_text(pValue);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Value_Type(sqlite3_value* pValue) {
+	return sqlite3_value_type(pValue);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Value_Numeric_Type(sqlite3_value* pValue) {
+	return sqlite3_value_numeric_type(pValue);
+}
+
+DLL_FUNCTION(int32_t) BU_SQLite_Value_SubType(sqlite3_value* pValue) {
+	return sqlite3_value_subtype(pValue);
+}
+
+DLL_FUNCTION(sqlite3_value*) BU_SQLite_Value_Duplicate(sqlite3_value* pValue) {
+	return sqlite3_value_dup(pValue);
+}
+
+DLL_FUNCTION(void) BU_SQLite_Value_Free(sqlite3_value* pValue) {
+	return sqlite3_value_free(pValue);
+}
+#pragma endregion
+

Database/SQLite/SQLite.h

@@ -15,51 +15,7 @@
 //	along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 #pragma once
-#include "dllmain.h"
-#include "sqlite3.h"
 #include <list>
+#include "BlitzUtility.h"
+#include "sqlite3.h"
 
-// Basic Info
-DLL_METHOD const char* DLL_CALL SQLite_Version();
-DLL_METHOD int32_t DLL_CALL SQLite_ThreadSafe();
-
-// Initialization and Finalization
-DLL_METHOD int32_t DLL_CALL SQLite_Initialize();
-DLL_METHOD int32_t DLL_CALL SQLite_Shutdown();
-
-// Database Handling
-DLL_METHOD int32_t DLL_CALL SQLite_Open(const char* file, sqlite3** db);
-DLL_METHOD int32_t DLL_CALL SQLite_Open_V2(const char* file, sqlite3** db, int32_t flags, const char* zVfs);
-DLL_METHOD int32_t DLL_CALL SQLite_Close(sqlite3* db);
-DLL_METHOD int32_t DLL_CALL SQLite_Close_V2(sqlite3* db);
-
-// Online Backup API
-DLL_METHOD sqlite3_backup* SQLite_Backup_Init(sqlite3* pDest, const char* zDestName, sqlite3* pSource, const char* zSourceName);
-DLL_METHOD int32_t DLL_CALL SQLite_Backup_Step(sqlite3_backup* p, int32_t nPage);
-DLL_METHOD int32_t DLL_CALL SQLite_Backup_Finish(sqlite3_backup* p);
-DLL_METHOD int32_t DLL_CALL SQLite_Backup_Remaining(sqlite3_backup* p);
-DLL_METHOD int32_t DLL_CALL SQLite_Backup_PageCount(sqlite3_backup* p);
-
-// Error Handling
-DLL_METHOD int32_t DLL_CALL SQLite_ErrCode(sqlite3* db);
-DLL_METHOD int32_t DLL_CALL SQLite_Extended_ErrCode(sqlite3* db);
-DLL_METHOD const char* DLL_CALL SQLite_ErrMsg(sqlite3* db);
-DLL_METHOD const char* DLL_CALL SQLite_ErrStr(int32_t errCode);
-
-// Memory Management
-DLL_METHOD int32_t DLL_CALL SQLite_Release_Memory(int32_t bytes);
-DLL_METHOD int32_t DLL_CALL SQLite_DB_Release_Memory(sqlite3* db);
-
-// Busy Timeout
-DLL_METHOD int32_t DLL_CALL SQLite_Busy_Timeout(sqlite3* db, int32_t timeout);
-DLL_METHOD int32_t DLL_CALL SQLite_Busy_Handler(sqlite3* db, int32_t handler);
-
-// Database Settings
-DLL_METHOD int32_t DLL_CALL SQLite_Get_AutoCommit(sqlite3* db);
-
-// Database Information
-DLL_METHOD const char* DLL_CALL SQLite_DB_FileName(sqlite3* db, const char* zDbName);
-DLL_METHOD sqlite3* DLL_CALL SQLite_DB_Handle(sqlite3_stmt* stmt);
-DLL_METHOD sqlite3_mutex* DLL_CALL SQLite_DB_Mutex(sqlite3* db);
-
-//Unsorted (Alphabetical

README.md

@@ -1,173 +1,183 @@
-# BlitzUtility
-BlitzUtility is aimed at extending Blitz beyond it's initial capabilities and is a sub-project of BlitzExtensions.
-All functions assume that you are passing valid parameters and do no extra checking to reduce performance impact.
-
-# Functionality
-## Containers
-### List
-An element-based method of creating a List in Blitz, works by creating a clone of the original Type and inserting the elements into the new flow.
-
-* List% = BU_List_Create(TypeObject*)  
-Creates a new list from an existing object, using it as a way of accessing the currently selected List entry.
-* BU_List_Destroy(List%)  
-Destroys an existing List, returning it's objects into the original type.
-* Sucess% = BU_List_First(List%)  
-Tries to selects the first object in a List, returning false if it failed.
-* Sucess% = BU_List_Last(List%)  
-Tries to selects the last object in a List, returning false if it failed.
-* Sucess% = BU_List_Previous(List%)  
-Tries to selects the previous object from the currently selected one, returning false if it failed.
-* Sucess% = BU_List_Next(List%)  
-Tries to selects the next object from the currently selected one, returning false if it failed.
-* Success% = BU_List_Before(List%, TypeObject*)  
-Tries to select the element before the given object, returning false if it failed.
-* Success% = BU_List_After(List%, TypeObject*)  
-Tries to select the element After the given object, returning false if it failed.
-* BU_List_Insert(List%, TypeObject*)  
-Inserts an object at the end of the given list.
-* BU_List_InsertEx(List%, TypeObject*, OtherObject*)  
-Inserts an object after the given other object.
-* BU_List_Remove(List%, TypeObject*)  
-Removes an object from a list, returning it to the original type.
-
-### Type List
-A type-based method of creating Lists in Blitz, works by modifying the base Type.
-
-* List% = BU_TypeList_Create(TypeObject*)  
-Creates a new list from an existing object, immediately removing it from the original type and inserting it into it's own list.
-* BU_TypeList_Destroy(List%)  
-Destroy an existing list, returning the objects into the flow of the base type.
-* BU_TypeList_Activate(List%)  
-Activates the list, making elements inside it available for use.
-* BU_TypeList_Deactivate(List%)  
-Deactivates the list, restoring the flow of elements to before activation.
-
-## Types
-### Long Long
-64-bit integers for Blitz.
-
-* LongLong% = BU_LongLong_Create%()
-* BU_LongLong_Destroy(LongLong%)
-* LongLong% = BU_LongLong_Copy%(LongLong%)
-* LongLong% = BU_LongLong_TempCreate%()
-* LongLong% = BU_LongLong_TempCopy%(LongLong%)
-* BU_LongLong_SetTemp(LongLong%)
-* BU_LongLong_UnsetTemp(LongLong%)
-* BU_LongLong_TempCleanup()
-* BU_LongLong_Set(LongLong%, LongLong%)
-* BU_LongLong_SetV(LongLong%, LongHigh%, LongLow%)
-* BU_LongLong_Add(LongLong%, LongLong%)
-* BU_LongLong_AddV(LongLong%, LongHigh%, LongLow%)
-* BU_LongLong_Sub(LongLong%, LongLong%)
-* BU_LongLong_SubV(LongLong%, LongHigh%, LongLow%)
-* BU_LongLong_Mul(LongLong%, LongLong%)
-* BU_LongLong_MulV(LongLong%, LongHigh%, LongLow%)
-* BU_LongLong_Div(LongLong%, LongLong%)
-* BU_LongLong_DivV(LongLong%, LongHigh%, LongLow%)
-* Result% = BU_LongLong_Compare%(LongLong%, LongLong%)
-* Result% = BU_LongLong_CompareV%(LongLong%, LongHigh%, LongLow%)
-* String$ = BU_LongLong_ToString$(LongLong%)
-* LongLong% = BU_LongLong_FromString%(String$)
-* Long% = BU_LongLong_ToLong%(LongLong%, Modulus%)
-* LongLong% = BU_LongLong_FromLong%(LongHigh%, LongLow%)
-* Long% = BU_LongLong_ToLongHigh%(LongLong%)
-* Long% = BU_LongLong_ToLongLow%(LongLong%)
-* Float# = BU_LongLong_ToFloat#(LongLong%)
-* LongLong% = BU_LongLong_FromFloat%(Float#)
-* Double% = BU_LongLong_ToDouble%(LongLong%)
-* LongLong% = BU_LongLong_FromDouble%(double%)
-* String$ = BU_LongLong_Serialize$(LongLong%)
-* LongLong% = BU_LongLong_Deserialize%(String$)
-
-### Double
-64-bit floating point for Blitz.
-
-* Double% = BU_Double_Create%()
-* BU_Double_Destroy(Double%)
-* Double% = BU_Double_Copy%(Double%)
-* Double% = BU_Double_TempCreate%()
-* Double% = BU_Double_TempCopy%(Double%)
-* BU_Double_SetTemp(Double%)
-* BU_Double_UnsetTemp(Double%)
-* BU_Double_TempCleanup()
-* BU_Double_Set(Double%, Double%)
-* BU_Double_SetF(Double%, Float#)
-* BU_Double_Add(Double%, Double%)
-* BU_Double_AddF(Double%, Float#)
-* BU_Double_Sub(Double%, Double%)
-* BU_Double_SubF(Double%, Float#)
-* BU_Double_Mul(Double%, Double%)
-* BU_Double_MulF(Double%, Float#)
-* BU_Double_Div(Double%, Double%)
-* BU_Double_DivF(Double%, Float#)
-* Result% = BU_Double_Compare%(Double%, Double%)
-Compares the two doubles and returns combinations of the following: 1 for equal, 2 for smaller, 4 for greater.
-* Result% = BU_Double_CompareF%(Double%, Float#)
-Compares the double as float with another float and returns combinations of the following: 1 for equal, 2 for smaller, 4 for greater.
-* String$ = BU_Double_ToString$(Double%)
-* Double% = BU_Double_FromString%(String$)
-* Float# = BU_Double_ToFloat#(Double%)
-* Double% = BU_Double_FromFloat%(Float#)
-* LongLong% = BU_Double_ToLongLong%(Double%)
-* Double% = BU_Double_FromLongLong%(LongLong%)
-* String$ = BU_Double_Serialize$(Double%)
-* String$ = BU_Double_Deserialize%(String$)
-
-## Utility
-### Display Enumerator
-Retrieve information about displays from Windows.
-
-* DisplayEnumerator% = BU_DisplayEnumerator_Create%()
-* BU_DisplayEnumerator_Destroy(DisplayEnumerator%)
-* BU_DisplayEnumerator_Enumerate%(DisplayEnumerator%)
-* BU_DisplayEnumerator_Count%(DisplayEnumerator%)
-* BU_DisplayEnumerator_Retrieve%(DisplayEnumerator%, index%, Rect*)
-
-### Indexer V1
-Fast array-based index generation. Uses a constant chunk of memory.
-
-* Indexer% = BU_IndexerV1_Create%()
-* BU_IndexerV1_Destroy(Indexer%)
-* BU_IndexerV1_Mark(Indexer%, Used%)
-* BU_IndexerV1_MarkFree(Indexer%)
-* BU_IndexerV1_MarkUsed(Indexer%)
-* Result% = BU_IndexerV1_Is%(Indexer%, Used%)
-* Result% = BU_IndexerV1_IsFree%(Indexer%)
-* Result% = BU_IndexerV1_IsUsed%(Indexer%)
-* Index% = BU_IndexerV1_Get%(Indexer%)
-* Amount% = BU_IndexerV1_Count%(Indexer%, Used%)
-* Amount% = BU_IndexerV1_CountFree%(Indexer%)
-* Amount% = BU_IndexerV1_CountUsed%(Indexer%)
-
-### Indexer V2
-Fast vector-based index generation, uses a dynamic amount of memory.
-
-* Indexer% = BU_IndexerV2_Create%()
-* BU_IndexerV2_Destroy(Indexer%)
-* BU_IndexerV2_Mark(Indexer%, Used%)
-* BU_IndexerV2_MarkFree(Indexer%)
-* BU_IndexerV2_MarkUsed(Indexer%)
-* Result% = BU_IndexerV2_Is%(Indexer%, Used%)
-* Result% = BU_IndexerV2_IsFree%(Indexer%)
-* Result% = BU_IndexerV2_IsUsed%(Indexer%)
-* Index% = BU_IndexerV2_Get%(Indexer%)
-* Amount% = BU_IndexerV2_Count%(Indexer%, Used%)
-* Amount% = BU_IndexerV2_CountFree%(Indexer%)
-* Amount% = BU_IndexerV2_CountUsed%(Indexer%)
-
-### Mass Operation
-Allows chaining operations on custom types, such as LongLong and Double. See contants
-
-* BU_MassOp_Create%(length%)
-* BU_MassOp_Destroy(massop%)
-* BU_MassOp_Instruction%(massop%, index%, type%, code%, leftOperand%, rightOperand%, result%)
-* BU_MassOp_Run(massop%)
-
-### Window Message Handler
-Easily handle messages sent to Blitz windows using these functions. May not work as expected initially.
-
-* BU_WindowMessageHandler_Install(hwnd%)
-* BU_WindowMessageHandler_Uninstall(hwnd%)
-* Count% = BU_WindowMessageHandler_Message_Close%(hwnd%)
-* Count% = BU_WindowMessageHandler_Message_Destroy%(hwnd%)
-* Count% = BU_WindowMessageHandler_Message_Resize%(hwnd%, point*)
+# BlitzUtility
+
+BlitzUtility is aimed at extending Blitz beyond it's initial capabilities and is a sub-project of BlitzExtensions.
+All functions assume that you are passing valid parameters and do no extra checking to reduce performance impact.
+
+# Functionality
+## Containers
+### List
+An element-based method of creating a List in Blitz, works by creating a clone of the original Type and inserting the elements into the new flow.
+
+* List% = BU_List_Create(TypeObject*)  
+Creates a new list from an existing object, using it as a way of accessing the currently selected List entry.
+* BU_List_Destroy(List%)  
+Destroys an existing List, returning it's objects into the original type.
+* Sucess% = BU_List_First(List%)  
+Tries to selects the first object in a List, returning false if it failed.
+* Sucess% = BU_List_Last(List%)  
+Tries to selects the last object in a List, returning false if it failed.
+* Sucess% = BU_List_Previous(List%)  
+Tries to selects the previous object from the currently selected one, returning false if it failed.
+* Sucess% = BU_List_Next(List%)  
+Tries to selects the next object from the currently selected one, returning false if it failed.
+* Success% = BU_List_Before(List%, TypeObject*)  
+Tries to select the element before the given object, returning false if it failed.
+* Success% = BU_List_After(List%, TypeObject*)  
+Tries to select the element After the given object, returning false if it failed.
+* BU_List_Insert(List%, TypeObject*)  
+Inserts an object at the end of the given list.
+* BU_List_InsertEx(List%, TypeObject*, OtherObject*)  
+Inserts an object after the given other object.
+* BU_List_Remove(List%, TypeObject*)  
+Removes an object from a list, returning it to the original type.
+
+### Type List
+A type-based method of creating Lists in Blitz, works by modifying the base Type.
+
+* List% = BU_TypeList_Create(TypeObject*)  
+Creates a new list from an existing object, immediately removing it from the original type and inserting it into it's own list.
+* BU_TypeList_Destroy(List%)  
+Destroy an existing list, returning the objects into the flow of the base type.
+* BU_TypeList_Activate(List%)  
+Activates the list, making elements inside it available for use.
+* BU_TypeList_Deactivate(List%)  
+Deactivates the list, restoring the flow of elements to before activation.
+
+## Types
+### Long Long
+64-bit integers for Blitz.
+
+* LongLong% = BU_LongLong_Create%()
+* BU_LongLong_Destroy(LongLong%)
+* LongLong% = BU_LongLong_Copy%(LongLong%)
+* LongLong% = BU_LongLong_TempCreate%()
+* LongLong% = BU_LongLong_TempCopy%(LongLong%)
+* BU_LongLong_SetTemp(LongLong%)
+* BU_LongLong_UnsetTemp(LongLong%)
+* BU_LongLong_TempCleanup()
+* BU_LongLong_Set(LongLong%, LongLong%)
+* BU_LongLong_SetV(LongLong%, LongHigh%, LongLow%)
+* BU_LongLong_Add(LongLong%, LongLong%)
+* BU_LongLong_AddV(LongLong%, LongHigh%, LongLow%)
+* BU_LongLong_Sub(LongLong%, LongLong%)
+* BU_LongLong_SubV(LongLong%, LongHigh%, LongLow%)
+* BU_LongLong_Mul(LongLong%, LongLong%)
+* BU_LongLong_MulV(LongLong%, LongHigh%, LongLow%)
+* BU_LongLong_Div(LongLong%, LongLong%)
+* BU_LongLong_DivV(LongLong%, LongHigh%, LongLow%)
+* Result% = BU_LongLong_Compare%(LongLong%, LongLong%)
+* Result% = BU_LongLong_CompareV%(LongLong%, LongHigh%, LongLow%)
+* String$ = BU_LongLong_ToString$(LongLong%)
+* LongLong% = BU_LongLong_FromString%(String$)
+* Long% = BU_LongLong_ToLong%(LongLong%, Modulus%)
+* LongLong% = BU_LongLong_FromLong%(LongHigh%, LongLow%)
+* Long% = BU_LongLong_ToLongHigh%(LongLong%)
+* Long% = BU_LongLong_ToLongLow%(LongLong%)
+* Float# = BU_LongLong_ToFloat#(LongLong%)
+* LongLong% = BU_LongLong_FromFloat%(Float#)
+* Double% = BU_LongLong_ToDouble%(LongLong%)
+* LongLong% = BU_LongLong_FromDouble%(double%)
+* String$ = BU_LongLong_Serialize$(LongLong%)
+* LongLong% = BU_LongLong_Deserialize%(String$)
+
+### Double
+64-bit floating point for Blitz.
+
+* Double% = BU_Double_Create%()
+* BU_Double_Destroy(Double%)
+* Double% = BU_Double_Copy%(Double%)
+* Double% = BU_Double_TempCreate%()
+* Double% = BU_Double_TempCopy%(Double%)
+* BU_Double_SetTemp(Double%)
+* BU_Double_UnsetTemp(Double%)
+* BU_Double_TempCleanup()
+* BU_Double_Set(Double%, Double%)
+* BU_Double_SetF(Double%, Float#)
+* BU_Double_Add(Double%, Double%)
+* BU_Double_AddF(Double%, Float#)
+* BU_Double_Sub(Double%, Double%)
+* BU_Double_SubF(Double%, Float#)
+* BU_Double_Mul(Double%, Double%)
+* BU_Double_MulF(Double%, Float#)
+* BU_Double_Div(Double%, Double%)
+* BU_Double_DivF(Double%, Float#)
+* Result% = BU_Double_Compare%(Double%, Double%)
+Compares the two doubles and returns combinations of the following: 1 for equal, 2 for smaller, 4 for greater.
+* Result% = BU_Double_CompareF%(Double%, Float#)
+Compares the double as float with another float and returns combinations of the following: 1 for equal, 2 for smaller, 4 for greater.
+* String$ = BU_Double_ToString$(Double%)
+* Double% = BU_Double_FromString%(String$)
+* Float# = BU_Double_ToFloat#(Double%)
+* Double% = BU_Double_FromFloat%(Float#)
+* LongLong% = BU_Double_ToLongLong%(Double%)
+* Double% = BU_Double_FromLongLong%(LongLong%)
+* String$ = BU_Double_Serialize$(Double%)
+* String$ = BU_Double_Deserialize%(String$)
+
+## Utility
+### Display Enumerator
+Retrieve information about displays from Windows.
+
+* DisplayEnumerator% = BU_DisplayEnumerator_Create%()
+* BU_DisplayEnumerator_Destroy(DisplayEnumerator%)
+* BU_DisplayEnumerator_Enumerate%(DisplayEnumerator%)
+* BU_DisplayEnumerator_Count%(DisplayEnumerator%)
+* BU_DisplayEnumerator_Retrieve%(DisplayEnumerator%, index%, Rect*)
+
+### Indexer V1
+Fast array-based index generation. Uses a constant chunk of memory.
+
+* Indexer% = BU_IndexerV1_Create%()
+* BU_IndexerV1_Destroy(Indexer%)
+* BU_IndexerV1_Mark(Indexer%, Used%)
+* BU_IndexerV1_MarkFree(Indexer%)
+* BU_IndexerV1_MarkUsed(Indexer%)
+* Result% = BU_IndexerV1_Is%(Indexer%, Used%)
+* Result% = BU_IndexerV1_IsFree%(Indexer%)
+* Result% = BU_IndexerV1_IsUsed%(Indexer%)
+* Index% = BU_IndexerV1_Get%(Indexer%)
+* Amount% = BU_IndexerV1_Count%(Indexer%, Used%)
+* Amount% = BU_IndexerV1_CountFree%(Indexer%)
+* Amount% = BU_IndexerV1_CountUsed%(Indexer%)
+
+### Indexer V2
+Fast vector-based index generation, uses a dynamic amount of memory.
+
+* Indexer% = BU_IndexerV2_Create%()
+* BU_IndexerV2_Destroy(Indexer%)
+* BU_IndexerV2_Mark(Indexer%, Used%)
+* BU_IndexerV2_MarkFree(Indexer%)
+* BU_IndexerV2_MarkUsed(Indexer%)
+* Result% = BU_IndexerV2_Is%(Indexer%, Used%)
+* Result% = BU_IndexerV2_IsFree%(Indexer%)
+* Result% = BU_IndexerV2_IsUsed%(Indexer%)
+* Index% = BU_IndexerV2_Get%(Indexer%)
+* Amount% = BU_IndexerV2_Count%(Indexer%, Used%)
+* Amount% = BU_IndexerV2_CountFree%(Indexer%)
+* Amount% = BU_IndexerV2_CountUsed%(Indexer%)
+
+### Mass Operation
+Allows chaining operations on custom types, such as LongLong and Double. See contants
+
+* BU_MassOp_Create%(length%)
+* BU_MassOp_Destroy(massop%)
+* BU_MassOp_Instruction%(massop%, index%, type%, code%, leftOperand%, rightOperand%, result%)
+* BU_MassOp_Run(massop%)
+
+### Window Message Handler
+Easily handle messages sent to Blitz windows using these functions. May not work as expected initially.
+
+* BU_WindowMessageHandler_Install(hwnd%)
+* BU_WindowMessageHandler_Uninstall(hwnd%)
+* Count% = BU_WindowMessageHandler_Message_Close%(hwnd%)
+* Count% = BU_WindowMessageHandler_Message_Destroy%(hwnd%)
+* Count% = BU_WindowMessageHandler_Message_Resize%(hwnd%, point*)
+
+# License
+Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+
+This program is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License along with this program.  If not, see <http://www.gnu.org/licenses/>.

Resources/BlitzUtility.LICENSE.lesser

@@ -1,165 +1,165 @@
-                   GNU LESSER GENERAL PUBLIC LICENSE
-                       Version 3, 29 June 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-
-  This version of the GNU Lesser General Public License incorporates
-the terms and conditions of version 3 of the GNU General Public
-License, supplemented by the additional permissions listed below.
-
-  0. Additional Definitions.
-
-  As used herein, "this License" refers to version 3 of the GNU Lesser
-General Public License, and the "GNU GPL" refers to version 3 of the GNU
-General Public License.
-
-  "The Library" refers to a covered work governed by this License,
-other than an Application or a Combined Work as defined below.
-
-  An "Application" is any work that makes use of an interface provided
-by the Library, but which is not otherwise based on the Library.
-Defining a subclass of a class defined by the Library is deemed a mode
-of using an interface provided by the Library.
-
-  A "Combined Work" is a work produced by combining or linking an
-Application with the Library.  The particular version of the Library
-with which the Combined Work was made is also called the "Linked
-Version".
-
-  The "Minimal Corresponding Source" for a Combined Work means the
-Corresponding Source for the Combined Work, excluding any source code
-for portions of the Combined Work that, considered in isolation, are
-based on the Application, and not on the Linked Version.
-
-  The "Corresponding Application Code" for a Combined Work means the
-object code and/or source code for the Application, including any data
-and utility programs needed for reproducing the Combined Work from the
-Application, but excluding the System Libraries of the Combined Work.
-
-  1. Exception to Section 3 of the GNU GPL.
-
-  You may convey a covered work under sections 3 and 4 of this License
-without being bound by section 3 of the GNU GPL.
-
-  2. Conveying Modified Versions.
-
-  If you modify a copy of the Library, and, in your modifications, a
-facility refers to a function or data to be supplied by an Application
-that uses the facility (other than as an argument passed when the
-facility is invoked), then you may convey a copy of the modified
-version:
-
-   a) under this License, provided that you make a good faith effort to
-   ensure that, in the event an Application does not supply the
-   function or data, the facility still operates, and performs
-   whatever part of its purpose remains meaningful, or
-
-   b) under the GNU GPL, with none of the additional permissions of
-   this License applicable to that copy.
-
-  3. Object Code Incorporating Material from Library Header Files.
-
-  The object code form of an Application may incorporate material from
-a header file that is part of the Library.  You may convey such object
-code under terms of your choice, provided that, if the incorporated
-material is not limited to numerical parameters, data structure
-layouts and accessors, or small macros, inline functions and templates
-(ten or fewer lines in length), you do both of the following:
-
-   a) Give prominent notice with each copy of the object code that the
-   Library is used in it and that the Library and its use are
-   covered by this License.
-
-   b) Accompany the object code with a copy of the GNU GPL and this license
-   document.
-
-  4. Combined Works.
-
-  You may convey a Combined Work under terms of your choice that,
-taken together, effectively do not restrict modification of the
-portions of the Library contained in the Combined Work and reverse
-engineering for debugging such modifications, if you also do each of
-the following:
-
-   a) Give prominent notice with each copy of the Combined Work that
-   the Library is used in it and that the Library and its use are
-   covered by this License.
-
-   b) Accompany the Combined Work with a copy of the GNU GPL and this license
-   document.
-
-   c) For a Combined Work that displays copyright notices during
-   execution, include the copyright notice for the Library among
-   these notices, as well as a reference directing the user to the
-   copies of the GNU GPL and this license document.
-
-   d) Do one of the following:
-
-       0) Convey the Minimal Corresponding Source under the terms of this
-       License, and the Corresponding Application Code in a form
-       suitable for, and under terms that permit, the user to
-       recombine or relink the Application with a modified version of
-       the Linked Version to produce a modified Combined Work, in the
-       manner specified by section 6 of the GNU GPL for conveying
-       Corresponding Source.
-
-       1) Use a suitable shared library mechanism for linking with the
-       Library.  A suitable mechanism is one that (a) uses at run time
-       a copy of the Library already present on the user's computer
-       system, and (b) will operate properly with a modified version
-       of the Library that is interface-compatible with the Linked
-       Version.
-
-   e) Provide Installation Information, but only if you would otherwise
-   be required to provide such information under section 6 of the
-   GNU GPL, and only to the extent that such information is
-   necessary to install and execute a modified version of the
-   Combined Work produced by recombining or relinking the
-   Application with a modified version of the Linked Version. (If
-   you use option 4d0, the Installation Information must accompany
-   the Minimal Corresponding Source and Corresponding Application
-   Code. If you use option 4d1, you must provide the Installation
-   Information in the manner specified by section 6 of the GNU GPL
-   for conveying Corresponding Source.)
-
-  5. Combined Libraries.
-
-  You may place library facilities that are a work based on the
-Library side by side in a single library together with other library
-facilities that are not Applications and are not covered by this
-License, and convey such a combined library under terms of your
-choice, if you do both of the following:
-
-   a) Accompany the combined library with a copy of the same work based
-   on the Library, uncombined with any other library facilities,
-   conveyed under the terms of this License.
-
-   b) Give prominent notice with the combined library that part of it
-   is a work based on the Library, and explaining where to find the
-   accompanying uncombined form of the same work.
-
-  6. Revised Versions of the GNU Lesser General Public License.
-
-  The Free Software Foundation may publish revised and/or new versions
-of the GNU Lesser General Public License from time to time. Such new
-versions will be similar in spirit to the present version, but may
-differ in detail to address new problems or concerns.
-
-  Each version is given a distinguishing version number. If the
-Library as you received it specifies that a certain numbered version
-of the GNU Lesser General Public License "or any later version"
-applies to it, you have the option of following the terms and
-conditions either of that published version or of any later version
-published by the Free Software Foundation. If the Library as you
-received it does not specify a version number of the GNU Lesser
-General Public License, you may choose any version of the GNU Lesser
-General Public License ever published by the Free Software Foundation.
-
-  If the Library as you received it specifies that a proxy can decide
-whether future versions of the GNU Lesser General Public License shall
-apply, that proxy's public statement of acceptance of any version is
-permanent authorization for you to choose that version for the
-Library.
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

Resources/BlitzUtility.bb

@@ -0,0 +1,536 @@
+;	BlitzUtility - Expanding the normal Blitz functionality.
+;	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+;
+;	This program is free software: you can redistribute it and/or modify
+;	it under the terms of the GNU Lesser General Public License as
+;	published by the Free Software Foundation, either version 3 of the 
+;	License, or (at your option) any later version.
+;
+;	This program is distributed in the hope that it will be useful,
+;	but WITHOUT ANY WARRANTY; without even the implied warranty of
+;	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;	GNU General Public License for more details.
+;
+;	You should have received a copy of the GNU Lesser General Public License
+;	along with this program.  If not, see <http:;www.gnu.org/licenses/>.
+
+; Utility ----------------------------------------------------------------------
+;-- Types
+Const BU_TYPES_COMPARE_INEQUAL								= 0
+Const BU_TYPES_COMPARE_EQUAL								= 1
+Const BU_TYPES_COMPARE_SMALLER								= 2
+Const BU_TYPES_COMPARE_GREATER								= 4
+
+;-- Mass Operation
+; Constants: Supported Types
+Const BU_MASSOP_TYPE_DOUBLE									= 0
+Const BU_MASSOP_TYPE_LONGLONG								= 1
+Const BU_MASSOP_TYPE_VECTOR2								= 10
+Const BU_MASSOP_TYPE_VECTOR3								= 11
+; Constants: Supported OpCodes
+Const BU_MASSOP_OPCODE_CREATE								= 0
+Const BU_MASSOP_OPCODE_DESTROY								= 1
+Const BU_MASSOP_OPCODE_COPY									= 2
+Const BU_MASSOP_OPCODE_TEMPCREATE							= 5
+Const BU_MASSOP_OPCODE_TEMPDESTROY							= 6
+Const BU_MASSOP_OPCODE_TEMPCLEANUP							= 7
+Const BU_MASSOP_OPCODE_SET									= 10
+Const BU_MASSOP_OPCODE_ADD									= 11
+Const BU_MASSOP_OPCODE_SUB									= 12
+Const BU_MASSOP_OPCODE_MUL									= 13
+Const BU_MASSOP_OPCODE_DIV									= 14
+Const BU_MASSOP_OPCODE_COMPARE								= 15
+; GoTo
+;	leftOperand: new massop index
+Const BU_MASSOP_OPCODE_GOTO									= 249
+; SetOpCode
+;	leftOperand: target massop index
+;	rightOperand: new OpCode
+Const BU_MASSOP_OPCODE_SETOPCODE							= 250
+; CopyLeft
+;	leftOperand: source massop index
+;	rightOperand: target massop index
+;	result: target position (0/leftOperand, 1/rightOperand, 2/result)
+Const BU_MASSOP_OPCODE_COPYLEFT								= 251
+; CopyRight
+;	leftOperand: source massop index
+;	rightOperand: target massop index
+;	result: target position (0/leftOperand, 1/rightOperand, 2/result)
+Const BU_MASSOP_OPCODE_COPYRIGHT							= 252
+; CopyOut
+;	leftOperand: source massop index
+;	rightOperand: target massop index
+;	result: target position (0/leftOperand, 1/rightOperand, 2/result)
+Const BU_MASSOP_OPCODE_COPYOUT								= 253
+; If - Compares the result of <leftOperand> with the result of <rightOperand>, 
+;  skipping over <result> instructions if the results match.
+;	leftOperand: source massop index
+;	rightOperand: target massop index
+;	result: amount to skip
+Const BU_MASSOP_OPCODE_IF									= 254
+; IfValue - Compares the result of <leftOperand> with <rightOperand>, skipping
+;  over <result> instructions if the results match.
+;	leftOperand: source massop index
+;	rightOperand: target massop index
+;	result: amount to skip
+Const BU_MASSOP_OPCODE_IFVALUE								= 255
+
+; Helpers ----------------------------------------------------------------------
+Type BU_Point
+	Field X,Y
+End Type
+
+Type BU_Rectangle
+	Field X,Y,X2,Y2
+End Type
+
+Function BU_Helper_Window_LockPointer(HWND% = 0)
+	If HWND = 0 Then
+		BU_User32_ClipCursorEx(0)
+	Else
+		Local tRect.BU_Rectangle = New BU_Rectangle
+		
+		; Retrieve Information about the selected window.
+		BU_User32_GetWindowRect(HWND, tRect)
+		
+		; Correct Rectangle to be inside the selected Window.
+		tRect\X2=tRect\X2-1
+		tRect\Y2=tRect\Y2-1
+		
+		; Update clipping area.
+		BU_User32_ClipCursor(tRect)
+		
+		Delete tRect
+	EndIf
+End Function
+
+Function BU_Helper_Window_LockPointerAuto(HWND=0)
+	If HWND = 0 Then HWND = SystemProperty("AppHwnd")
+	
+	If BU_User32_GetActiveWindow() = HWND Then
+		BU_Helper_Window_LockPointer(HWND)
+	Else
+		BU_Helper_Window_LockPointer(0)
+	EndIf
+End Function
+
+Function BU_Helper_Window_MakeBorderless(HWND=0)
+	If HWND = 0 Then HWND = SystemProperty("AppHwnd")
+	
+	; Create Storage
+	Local tRect.BU_Rectangle = New BU_Rectangle
+	
+	; Client Information
+	BU_User32_GetClientRect(HWND, tRect)
+	Local clientX, clientY, clientW, clientH
+	clientX = tRect\X
+	clientY = tRect\Y
+	clientW = tRect\X2 - clientX
+	clientH = tRect\Y2 - clientY
+	
+	; Convert Client coordinates to screen position.
+	Local tPoint.BU_Point = New BU_Point
+	BU_User32_ClientToScreen(HWND, tPoint)
+	Local realClientX, realClientY
+	realClientX = tPoint\X
+	realClientY = tPoint\Y
+	Delete tPoint
+	
+	; Window Information
+	BU_User32_GetWindowRect(HWND, tRect)
+	Local windowX, windowY, windowW, windowH
+	windowX = tRect\X
+	windowY = tRect\Y
+	windowW = tRect\X2 - windowX
+	windowH = tRect\Y2 - windowY
+	
+	; Delete Storage
+	Delete tRect
+	
+	; Calculate new position and size.
+	Local newX, newY, newW, newH
+	newX = windowX + (realClientX - windowX)
+	newY = windowY + (realClientY - windowY)
+	newW = clientW
+	newH = clientH
+	
+	; Apply changes
+	BU_User32_SetWindowLong HWND, -16, $10000000
+	BU_User32_SetWindowLong HWND, -20, $02840020
+	BU_User32_SetWindowPos HWND, 0, newX, newY, newW, newH, $2074
+End Function
+
+Function BU_Helper_Window_Center(HWND=0, Monitor=0)
+	If HWND = 0 Then HWND = SystemProperty("AppHwnd")
+	
+	Local displayEnumerator = BU_DisplayEnumerator_Create()
+	Local displayAmount = BU_DisplayEnumerator_Enumerate(displayEnumerator)
+	If Monitor >= displayAmount Then Monitor = displayAmount - 1
+	If Monitor < 0 Then Monitor = 0
+	
+	; Get Display Information
+	Local displayRectangle.BU_Rectangle = New BU_Rectangle
+	BU_DisplayEnumerator_Retrieve displayEnumerator, Monitor, displayRectangle
+	BU_DisplayEnumerator_Destroy displayEnumerator
+	Local displayX, displayY, displayW, displayH
+	displayX = displayRectangle\X
+	displayY = displayRectangle\Y
+	displayW = displayRectangle\X2 - displayRectangle\X
+	displayH = displayRectangle\Y2 - displayRectangle\Y
+	Delete displayRectangle
+	
+	; Get Window Information
+	Local windowRectangle.BU_Rectangle = New BU_Rectangle
+	BU_User32_GetWindowRect(HWND, windowRectangle)
+	Local windowW%, windowH%
+	windowW = windowRectangle\X2 - windowRectangle\X
+	windowH = windowRectangle\Y2 - windowRectangle\Y
+	Delete windowRectangle
+	
+	; Calculate new position and size.
+	Local newX, newY, newW, newH
+	newX = displayX + (displayW/2 - windowW/2)
+	newY = displayY + (displayH/2 - windowH/2)
+	newW = windowW
+	newH = windowH
+	
+	; Apply changes
+	BU_User32_SetWindowPos HWND, 0, newX, newY, newW, newH, $1 + $4 + $10 + $20 + $40 
+End Function
+
+Function BU_Helper_Window_Fill(HWND=0, Monitor=0)
+	If HWND = 0 Then HWND = SystemProperty("AppHwnd")
+	
+	Local displayEnumerator = BU_DisplayEnumerator_Create()
+	Local displayAmount = BU_DisplayEnumerator_Enumerate(displayEnumerator)
+	If Monitor >= displayAmount Then Monitor = displayAmount - 1
+	If Monitor < 0 Then Monitor = 0
+	
+	; Get Display Information
+	Local displayRectangle.BU_Rectangle = New BU_Rectangle
+	BU_DisplayEnumerator_Retrieve displayEnumerator, Monitor, displayRectangle
+	BU_DisplayEnumerator_Destroy displayEnumerator
+	Local displayX, displayY, displayW, displayH
+	displayX = displayRectangle\X
+	displayY = displayRectangle\Y
+	displayW = displayRectangle\X2 - displayRectangle\X
+	displayH = displayRectangle\Y2 - displayRectangle\Y
+	Delete displayRectangle
+	
+	; Calculate new position and size.
+	Local newX, newY, newW, newH
+	newX = displayX
+	newY = displayY
+	newW = displayW
+	newH = displayH
+	
+	; Apply changes
+	BU_User32_SetWindowPos HWND, 0, newX, newY, newW, newH, $4 + $10 + $20 + $40 
+End Function
+
+; Database ---------------------------------------------------------------------
+;-- SQLite3
+;[Block] Return Codes / Error Codes
+; Many SQLite functions return an integer result code from the set shown
+; here in order to indicate success or failure.
+;
+; New error codes may be added in future versions of SQLite.
+Const BU_SQLITE_OK%											= 0   ; Successful result
+Const BU_SQLITE_ERROR%										= 1   ; SQL error or missing database
+Const BU_SQLITE_INTERNAL%									= 2   ; Internal logic error in SQLite
+Const BU_SQLITE_PERM%										= 3   ; Access permission denied
+Const BU_SQLITE_ABORT%										= 4   ; Callback routine requested an abort
+Const BU_SQLITE_BUSY%										= 5   ; The database file is locked
+Const BU_SQLITE_LOCKED%										= 6   ; A table in the database is locked
+Const BU_SQLITE_NOMEM%										= 7   ; A malloc() failed
+Const BU_SQLITE_READONLY%									= 8   ; Attempt to write a readonly database
+Const BU_SQLITE_INTERRUPT%									= 9   ; Operation terminated by SQLite3_Interrupt()
+Const BU_SQLITE_IOERR%										= 10   ; Some kind of disk I/O error occurred
+Const BU_SQLITE_CORRUPT%									= 11   ; The database disk image is malformed
+Const BU_SQLITE_NOTFOUND%									= 12   ; Unknown opcode in sqlite3_file_control()
+Const BU_SQLITE_FULL%										= 13   ; Insertion failed because database is full
+Const BU_SQLITE_CANTOPEN%									= 14   ; Unable to open the database file
+Const BU_SQLITE_PROTOCOL%									= 15   ; Database lock protocol error
+Const BU_SQLITE_EMPTY%										= 16   ; Database is empty
+Const BU_SQLITE_SCHEMA%										= 17   ; The database schema changed
+Const BU_SQLITE_TOOBIG%										= 18   ; String or BLOB exceeds size limit
+Const BU_SQLITE_CONSTRAINT%									= 19   ; Abort due to constraint violation
+Const BU_SQLITE_MISMATCH%									= 20   ; Data type mismatch
+Const BU_SQLITE_MISUSE%										= 21   ; Library used incorrectly
+Const BU_SQLITE_NOLFS%										= 22   ; Uses OS features not supported on host
+Const BU_SQLITE_AUTH%										= 23   ; Authorization denied
+Const BU_SQLITE_FORMAT%										= 24   ; Auxiliary database format error
+Const BU_SQLITE_RANGE%										= 25   ; 2nd parameter to sqlite3_bind out of range
+Const BU_SQLITE_NOTADB%										= 26   ; File opened that is not a database file
+Const BU_SQLITE_NOTICE%										= 27   ; Notifications from sqlite3_log()
+Const BU_SQLITE_WARNING%									= 28   ; Warnings from sqlite3_log()
+Const BU_SQLITE_ROW%										= 100  ; sqlite3_step() has another row ready
+Const BU_SQLITE_DONE%										= 101  ; sqlite3_step() has finished executing
+;[End Block]
+
+;[Block] Extended Result Codes
+; In its default configuration, SQLite API routines return one of 30 integer
+; [result codes].  However, experience has shown that many of
+; these result codes are too coarse-grained.  They do not provide as
+; much information about problems as programmers might like.  In an effort to
+; address this, newer versions of SQLite (version 3.3.8 and later) include
+; support for additional result codes that provide more detailed information
+; about errors. These [extended result codes] are enabled or disabled
+; on a per database connection basis using the [sqlite3_extended_result_codes()]
+; API. Or, the extended code for the most recent error can be obtained using
+; [sqlite3_extended_errcode()].
+Const BU_SQLITE_IOERR_READ									= (BU_SQLITE_IOERR Or (1 Shl 8))
+Const BU_SQLITE_IOERR_SHORT_READ							= (BU_SQLITE_IOERR Or (2 Shl 8))
+Const BU_SQLITE_IOERR_WRITE									= (BU_SQLITE_IOERR Or (3 Shl 8))
+Const BU_SQLITE_IOERR_FSYNC									= (BU_SQLITE_IOERR Or (4 Shl 8))
+Const BU_SQLITE_IOERR_DIR_FSYNC								= (BU_SQLITE_IOERR Or (5 Shl 8))
+Const BU_SQLITE_IOERR_TRUNCATE								= (BU_SQLITE_IOERR Or (6 Shl 8))
+Const BU_SQLITE_IOERR_FSTAT									= (BU_SQLITE_IOERR Or (7 Shl 8))
+Const BU_SQLITE_IOERR_UNLOCK								= (BU_SQLITE_IOERR Or (8 Shl 8))
+Const BU_SQLITE_IOERR_RDLOCK								= (BU_SQLITE_IOERR Or (9 Shl 8))
+Const BU_SQLITE_IOERR_DELETE								= (BU_SQLITE_IOERR Or (10 Shl 8))
+Const BU_SQLITE_IOERR_BLOCKED								= (BU_SQLITE_IOERR Or (11 Shl 8))
+Const BU_SQLITE_IOERR_NOMEM									= (BU_SQLITE_IOERR Or (12 Shl 8))
+Const BU_SQLITE_IOERR_ACCESS								= (BU_SQLITE_IOERR Or (13 Shl 8))
+Const BU_SQLITE_IOERR_CHECKRESERVEDLOCK						= (BU_SQLITE_IOERR Or (14 Shl 8))
+Const BU_SQLITE_IOERR_LOCK									= (BU_SQLITE_IOERR Or (15 Shl 8))
+Const BU_SQLITE_IOERR_CLOSE									= (BU_SQLITE_IOERR Or (16 Shl 8))
+Const BU_SQLITE_IOERR_DIR_CLOSE								= (BU_SQLITE_IOERR Or (17 Shl 8))
+Const BU_SQLITE_IOERR_SHMOPEN								= (BU_SQLITE_IOERR Or (18 Shl 8))
+Const BU_SQLITE_IOERR_SHMSIZE								= (BU_SQLITE_IOERR Or (19 Shl 8))
+Const BU_SQLITE_IOERR_SHMLOCK								= (BU_SQLITE_IOERR Or (20 Shl 8))
+Const BU_SQLITE_IOERR_SHMMAP								= (BU_SQLITE_IOERR Or (21 Shl 8))
+Const BU_SQLITE_IOERR_SEEK									= (BU_SQLITE_IOERR Or (22 Shl 8))
+Const BU_SQLITE_IOERR_DELETE_NOENT							= (BU_SQLITE_IOERR Or (23 Shl 8))
+Const BU_SQLITE_IOERR_MMAP									= (BU_SQLITE_IOERR Or (24 Shl 8))
+Const BU_SQLITE_IOERR_GETTEMPPATH							= (BU_SQLITE_IOERR Or (25 Shl 8))
+Const BU_SQLITE_IOERR_CONVPATH								= (BU_SQLITE_IOERR Or (26 Shl 8))
+Const BU_SQLITE_IOERR_VNODE									= (BU_SQLITE_IOERR Or (27 Shl 8))
+Const BU_SQLITE_IOERR_AUTH									= (BU_SQLITE_IOERR Or (28 Shl 8))
+Const BU_SQLITE_LOCKED_SHAREDCACHE							= (BU_SQLITE_LOCKED Or  (1 Shl 8))
+Const BU_SQLITE_BUSY_RECOVERY								= (BU_SQLITE_BUSY   Or  (1 Shl 8))
+Const BU_SQLITE_BUSY_SNAPSHOT								= (BU_SQLITE_BUSY   Or  (2 Shl 8))
+Const BU_SQLITE_CANTOPEN_NOTEMPDIR							= (BU_SQLITE_CANTOPEN Or (1 Shl 8))
+Const BU_SQLITE_CANTOPEN_ISDIR								= (BU_SQLITE_CANTOPEN Or (2 Shl 8))
+Const BU_SQLITE_CANTOPEN_FULLPATH							= (BU_SQLITE_CANTOPEN Or (3 Shl 8))
+Const BU_SQLITE_CANTOPEN_CONVPATH							= (BU_SQLITE_CANTOPEN Or (4 Shl 8))
+Const BU_SQLITE_CORRUPT_VTAB								= (BU_SQLITE_CORRUPT Or (1 Shl 8))
+Const BU_SQLITE_READONLY_RECOVERY							= (BU_SQLITE_READONLY Or (1 Shl 8))
+Const BU_SQLITE_READONLY_CANTLOCK							= (BU_SQLITE_READONLY Or (2 Shl 8))
+Const BU_SQLITE_READONLY_ROLLBACK							= (BU_SQLITE_READONLY Or (3 Shl 8))
+Const BU_SQLITE_READONLY_DBMOVED							= (BU_SQLITE_READONLY Or (4 Shl 8))
+Const BU_SQLITE_ABORT_ROLLBACK								= (BU_SQLITE_ABORT Or (2 Shl 8))
+Const BU_SQLITE_CONSTRAINT_CHECK							= (BU_SQLITE_CONSTRAINT Or (1 Shl 8))
+Const BU_SQLITE_CONSTRAINT_COMMITHOOK						= (BU_SQLITE_CONSTRAINT Or (2 Shl 8))
+Const BU_SQLITE_CONSTRAINT_FOREIGNKEY						= (BU_SQLITE_CONSTRAINT Or (3 Shl 8))
+Const BU_SQLITE_CONSTRAINT_FUNCTION							= (BU_SQLITE_CONSTRAINT Or (4 Shl 8))
+Const BU_SQLITE_CONSTRAINT_NOTNULL							= (BU_SQLITE_CONSTRAINT Or (5 Shl 8))
+Const BU_SQLITE_CONSTRAINT_PRIMARYKEY						= (BU_SQLITE_CONSTRAINT Or (6 Shl 8))
+Const BU_SQLITE_CONSTRAINT_TRIGGER							= (BU_SQLITE_CONSTRAINT Or (7 Shl 8))
+Const BU_SQLITE_CONSTRAINT_UNIQUE							= (BU_SQLITE_CONSTRAINT Or (8 Shl 8))
+Const BU_SQLITE_CONSTRAINT_VTAB								= (BU_SQLITE_CONSTRAINT Or (9 Shl 8))
+Const BU_SQLITE_CONSTRAINT_ROWID							= (BU_SQLITE_CONSTRAINT Or (10 Shl 8))
+Const BU_SQLITE_NOTICE_RECOVER_WAL							= (BU_SQLITE_NOTICE Or (1 Shl 8))
+Const BU_SQLITE_NOTICE_RECOVER_ROLLBACK						= (BU_SQLITE_NOTICE Or (2 Shl 8))
+Const BU_SQLITE_WARNING_AUTOINDEX							= (BU_SQLITE_WARNING Or (1 Shl 8))
+Const BU_SQLITE_AUTH_USER									= (BU_SQLITE_AUTH Or (1 Shl 8))
+;[End Block]
+
+;[Block] Flags For File Open Operations
+; These bit values are intended for use in the
+; 3rd parameter to the [sqlite3_open_v2()] interface.
+Const BU_SQLITE_OPEN_READONLY								= $00000001  ;  Ok for sqlite3_open_v2() */
+Const BU_SQLITE_OPEN_READWRITE								= $00000002  ;  Ok for sqlite3_open_v2() */
+Const BU_SQLITE_OPEN_CREATE									= $00000004  ;  Ok for sqlite3_open_v2() */
+Const BU_SQLITE_OPEN_DELETEONCLOSE							= $00000008  ;  VFS only */
+Const BU_SQLITE_OPEN_EXCLUSIVE								= $00000010  ;  VFS only */
+Const BU_SQLITE_OPEN_AUTOPROXY								= $00000020  ;  VFS only */
+Const BU_SQLITE_OPEN_URI									= $00000040  ;  Ok for sqlite3_open_v2() */
+Const BU_SQLITE_OPEN_MEMORY									= $00000080  ;  Ok for sqlite3_open_v2() */
+Const BU_SQLITE_OPEN_MAIN_DB								= $00000100  ;  VFS only */
+Const BU_SQLITE_OPEN_TEMP_DB								= $00000200  ;  VFS only */
+Const BU_SQLITE_OPEN_TRANSIENT_DB							= $00000400  ;  VFS only */
+Const BU_SQLITE_OPEN_MAIN_JOURNAL							= $00000800  ;  VFS only */
+Const BU_SQLITE_OPEN_TEMP_JOURNAL							= $00001000  ;  VFS only */
+Const BU_SQLITE_OPEN_SUBJOURNAL								= $00002000  ;  VFS only */
+Const BU_SQLITE_OPEN_MASTER_JOURNAL							= $00004000  ;  VFS only */
+Const BU_SQLITE_OPEN_NOMUTEX								= $00008000  ;  Ok for sqlite3_open_v2() */
+Const BU_SQLITE_OPEN_FULLMUTEX								= $00010000  ;  Ok for sqlite3_open_v2() */
+Const BU_SQLITE_OPEN_SHAREDCACHE							= $00020000  ;  Ok for sqlite3_open_v2() */
+Const BU_SQLITE_OPEN_PRIVATECACHE							= $00040000  ;  Ok for sqlite3_open_v2() */
+Const BU_SQLITE_OPEN_WAL									= $00080000  ;  VFS only */
+;[End Block]
+
+;[Block] Authorizer Return Codes
+; The [sqlite3_set_authorizer | authorizer callback function] must
+; return either [SQLITE_OK] or one of these two constants in order
+; to signal SQLite whether or not the action is permitted.  See the
+; [sqlite3_set_authorizer | authorizer documentation] for additional
+; information.
+;
+; Note that SQLITE_IGNORE is also used as a [conflict resolution mode]
+; returned from the [sqlite3_vtab_on_conflict()] interface.
+Const BU_SQLITE_DENY										= 1 ; Abort the SQL statement with an error */
+Const BU_SQLITE_IGNORE										= 2 ; Don't allow access, but don't generate an error */
+;[End Block]
+
+;[Block] Authorizer Action Codes
+; The [sqlite3_set_authorizer()] interface registers a callback function
+; that is invoked to authorize certain SQL statement actions.  The
+; second parameter to the callback is an integer code that specifies
+; what action is being authorized.  These are the integer action codes that
+; the authorizer callback may be passed.
+;
+; These action code values signify what kind of operation is to be
+; authorized.  The 3rd and 4th parameters to the authorization
+; callback function will be parameters or NULL depending on which of these
+; codes is used as the second parameter.  ^(The 5th parameter to the
+; authorizer callback is the name of the database ("main", "temp",
+; etc.) if applicable.)^  ^The 6th parameter to the authorizer callback
+; is the name of the inner-most trigger or view that is responsible for
+; the access attempt or NULL if this access attempt is directly from
+; top-level SQL code.
+; ;;;;;;;;;;;;;;;;;;;;; 3rd ;;;;;; 4th ;;;;;*/
+Const BU_SQLITE_CREATE_INDEX         =  1   ;  Index Name      Table Name      */
+Const BU_SQLITE_CREATE_TABLE         =  2   ;  Table Name      NULL            */
+Const BU_SQLITE_CREATE_TEMP_INDEX    =  3   ;  Index Name      Table Name      */
+Const BU_SQLITE_CREATE_TEMP_TABLE    =  4   ;  Table Name      NULL            */
+Const BU_SQLITE_CREATE_TEMP_TRIGGER  =  5   ;  Trigger Name    Table Name      */
+Const BU_SQLITE_CREATE_TEMP_VIEW     =  6   ;  View Name       NULL            */
+Const BU_SQLITE_CREATE_TRIGGER       =  7   ;  Trigger Name    Table Name      */
+Const BU_SQLITE_CREATE_VIEW          =  8   ;  View Name       NULL            */
+Const BU_SQLITE_DELETE               =  9   ;  Table Name      NULL            */
+Const BU_SQLITE_DROP_INDEX           = 10   ;  Index Name      Table Name      */
+Const BU_SQLITE_DROP_TABLE           = 11   ;  Table Name      NULL            */
+Const BU_SQLITE_DROP_TEMP_INDEX      = 12   ;  Index Name      Table Name      */
+Const BU_SQLITE_DROP_TEMP_TABLE      = 13   ;  Table Name      NULL            */
+Const BU_SQLITE_DROP_TEMP_TRIGGER    = 14   ;  Trigger Name    Table Name      */
+Const BU_SQLITE_DROP_TEMP_VIEW       = 15   ;  View Name       NULL            */
+Const BU_SQLITE_DROP_TRIGGER         = 16   ;  Trigger Name    Table Name      */
+Const BU_SQLITE_DROP_VIEW            = 17   ;  View Name       NULL            */
+Const BU_SQLITE_INSERT               = 18   ;  Table Name      NULL            */
+Const BU_SQLITE_PRAGMA               = 19   ;  Pragma Name     1st arg or NULL */
+Const BU_SQLITE_READ                 = 20   ;  Table Name      Column Name     */
+Const BU_SQLITE_SELECT               = 21   ;  NULL            NULL            */
+Const BU_SQLITE_TRANSACTION          = 22   ;  Operation       NULL            */
+Const BU_SQLITE_UPDATE               = 23   ;  Table Name      Column Name     */
+Const BU_SQLITE_ATTACH               = 24   ;  Filename        NULL            */
+Const BU_SQLITE_DETACH               = 25   ;  Database Name   NULL            */
+Const BU_SQLITE_ALTER_TABLE          = 26   ;  Database Name   Table Name      */
+Const BU_SQLITE_REINDEX              = 27   ;  Index Name      NULL            */
+Const BU_SQLITE_ANALYZE              = 28   ;  Table Name      NULL            */
+Const BU_SQLITE_CREATE_VTABLE        = 29   ;  Table Name      Module Name     */
+Const BU_SQLITE_DROP_VTABLE          = 30   ;  Table Name      Module Name     */
+Const BU_SQLITE_FUNCTION             = 31   ;  NULL            Function Name   */
+Const BU_SQLITE_SAVEPOINT            = 32   ;  Operation       Savepoint Name  */
+Const BU_SQLITE_COPY                 =  0   ;  No longer used */
+Const BU_SQLITE_RECURSIVE            = 33   ;  NULL            NULL            */
+;[End Block]
+
+;[Block] Run-Time Limit Categories
+; KEYWORDS: {limit category} {*limit categories}
+;
+; These constants define various performance limits
+; that can be lowered at run-time using [sqlite3_limit()].
+; The synopsis of the meanings of the various limits is shown below.
+; Additional information is available at [limits | Limits in SQLite].
+;
+; <dl>
+; [[SQLITE_LIMIT_LENGTH]] ^(<dt>SQLITE_LIMIT_LENGTH</dt>
+; <dd>The maximum size of any string or BLOB or table row, in bytes.<dd>)^
+;
+; [[SQLITE_LIMIT_SQL_LENGTH]] ^(<dt>SQLITE_LIMIT_SQL_LENGTH</dt>
+; <dd>The maximum length of an SQL statement, in bytes.</dd>)^
+;
+; [[SQLITE_LIMIT_COLUMN]] ^(<dt>SQLITE_LIMIT_COLUMN</dt>
+; <dd>The maximum number of columns in a table definition or in the
+; result set of a [SELECT] or the maximum number of columns in an index
+; or in an ORDER BY or GROUP BY clause.</dd>)^
+;
+; [[SQLITE_LIMIT_EXPR_DEPTH]] ^(<dt>SQLITE_LIMIT_EXPR_DEPTH</dt>
+; <dd>The maximum depth of the parse tree on any expression.</dd>)^
+;
+; [[SQLITE_LIMIT_COMPOUND_SELECT]] ^(<dt>SQLITE_LIMIT_COMPOUND_SELECT</dt>
+; <dd>The maximum number of terms in a compound SELECT statement.</dd>)^
+;
+; [[SQLITE_LIMIT_VDBE_OP]] ^(<dt>SQLITE_LIMIT_VDBE_OP</dt>
+; <dd>The maximum number of instructions in a virtual machine program
+; used to implement an SQL statement.  This limit is not currently
+; enforced, though that might be added in some future release of
+; SQLite.</dd>)^
+;
+; [[SQLITE_LIMIT_FUNCTION_ARG]] ^(<dt>SQLITE_LIMIT_FUNCTION_ARG</dt>
+; <dd>The maximum number of arguments on a function.</dd>)^
+;
+; [[SQLITE_LIMIT_ATTACHED]] ^(<dt>SQLITE_LIMIT_ATTACHED</dt>
+; <dd>The maximum number of [ATTACH | attached databases].)^</dd>
+;
+; [[SQLITE_LIMIT_LIKE_PATTERN_LENGTH]]
+; ^(<dt>SQLITE_LIMIT_LIKE_PATTERN_LENGTH</dt>
+; <dd>The maximum length of the pattern argument to the [LIKE] or
+; [GLOB] operators.</dd>)^
+;
+; [[SQLITE_LIMIT_VARIABLE_NUMBER]]
+; ^(<dt>SQLITE_LIMIT_VARIABLE_NUMBER</dt>
+; <dd>The maximum index number of any [parameter] in an SQL statement.)^
+;
+; [[SQLITE_LIMIT_TRIGGER_DEPTH]] ^(<dt>SQLITE_LIMIT_TRIGGER_DEPTH</dt>
+; <dd>The maximum depth of recursion for triggers.</dd>)^
+;
+; [[SQLITE_LIMIT_WORKER_THREADS]] ^(<dt>SQLITE_LIMIT_WORKER_THREADS</dt>
+; <dd>The maximum number of auxiliary worker threads that a single
+; [prepared statement] may start.</dd>)^
+; </dl>
+Const BU_SQLITE_LIMIT_LENGTH                   =  0
+Const BU_SQLITE_LIMIT_SQL_LENGTH               =  1
+Const BU_SQLITE_LIMIT_COLUMN                   =  2
+Const BU_SQLITE_LIMIT_EXPR_DEPTH               =  3
+Const BU_SQLITE_LIMIT_COMPOUND_SELECT          =  4
+Const BU_SQLITE_LIMIT_VDBE_OP                  =  5
+Const BU_SQLITE_LIMIT_FUNCTION_ARG             =  6
+Const BU_SQLITE_LIMIT_ATTACHED                 =  7
+Const BU_SQLITE_LIMIT_LIKE_PATTERN_LENGTH      =  8
+Const BU_SQLITE_LIMIT_VARIABLE_NUMBER          =  9
+Const BU_SQLITE_LIMIT_TRIGGER_DEPTH            = 10
+Const BU_SQLITE_LIMIT_WORKER_THREADS           = 11
+;[End Block]
+
+;[Block] Column Type
+Const BU_SQLITE_UNKNOWN											= 0
+Const BU_SQLITE_INTEGER											= 1
+Const BU_SQLITE_REAL											= 2
+Const BU_SQLITE_FLOAT											= 2
+Const BU_SQLITE_DOUBLE											= 2
+Const BU_SQLITE_TEXT											= 3
+Const BU_SQLITE_STRING											= 3
+Const BU_SQLITE_BLOB											= 4
+Const BU_SQLITE_BANK											= 4
+Const BU_SQLITE_NULL											= 5
+;[End Block]
+
+; Math -------------------------------------------------------------------------
+;-- Vector2
+Type Vector2
+	Field X#, Y#
+End Type
+
+Function Vector2_Create.Vector2(X#, Y#)
+	Local vec.Vector2 = New Vector2
+	vec\X = X
+	vec\Y = Y
+	Return vec
+End Function
+
+;-- Vector3
+Type Vector3
+	Field X#, Y#, Z#
+End Type
+
+Function Vector3_Create.Vector3(X#, Y#, Z#)
+	Local vec.Vector3 = New Vector3
+	vec\X = X
+	vec\Y = Y
+	vec\Z = Z
+	Return vec
+End Function
+

Resources/BlitzUtility.decls

@@ -0,0 +1,378 @@
+;	BlitzUtility - Expanding the normal Blitz functionality.
+;	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+;
+;	This program is free software: you can redistribute it and/or modify
+;	it under the terms of the GNU Lesser General Public License as
+;	published by the Free Software Foundation, either version 3 of the 
+;	License, or (at your option) any later version.
+;
+;	This program is distributed in the hope that it will be useful,
+;	but WITHOUT ANY WARRANTY; without even the implied warranty of
+;	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;	GNU General Public License for more details.
+;
+;	You should have received a copy of the GNU Lesser General Public License
+;	along with this program.  If not, see <http:;www.gnu.org/licenses/>.
+
+.lib "BlitzUtility.dll"
+;----------------------------------------------------------------
+;! Container - List (Element-wide)
+;----------------------------------------------------------------
+BU_List_Create%(element*)
+BU_List_Destroy%(list%)
+BU_List_First%(list%)
+BU_List_Last%(list%)
+BU_List_Previous%(list%)
+BU_List_Next%(list%)
+BU_List_Before%(list%, other*)
+BU_List_After%(list%, other*)
+BU_List_Insert(list%, element*)
+BU_List_InsertEx(list%, element*, other*)
+BU_List_Remove(list%, element*)
+
+;----------------------------------------------------------------
+;! Container - TypeList (Type-wide)
+;----------------------------------------------------------------
+BU_TypeList_Create%(obj*)
+BU_TypeList_Activate(list%)
+BU_TypeList_Deactivate(list%)
+BU_TypeList_Destroy(list%)
+
+;----------------------------------------------------------------
+;! System - FileSystem
+;----------------------------------------------------------------
+BU_FileSystem_WriteFile%(Path$)
+;@desc: Opens or creates a file for writing only. Truncates existing content.
+BU_FileSystem_OpenFile%(Path$)
+;@desc: Opens an existing file for reading or writing.
+BU_FileSystem_ReadFile%(Path$)
+;@desc: Opens an existing file for reading only.
+BU_FileSystem_CloseFile(File%)
+;@desc: Closes an open file.
+BU_FileSystem_FlushFile(File%)
+;@desc: Flushes all buffers to disk for the file.
+BU_FileSystem_EOF%(File%)
+;@desc: Checks if the File handle is valid and not at the end of the file.
+;@return:
+; 0 = Good, Not End Of File
+; 1 = End Of File
+; -1 = Bad File Handle
+; -2 = Failed to do internal action.
+BU_FileSystem_SeekFile(File%, Pos%)
+BU_FileSystem_SeekFileIn(File%, Pos%)
+BU_FileSystem_SeekFileOut(File%, Pos%)
+BU_FileSystem_FilePos%(File%) : "BU_FileSystem_FilePosIn"
+BU_FileSystem_FilePosIn%(File%)
+BU_FileSystem_FilePosOut%(File%)
+
+BU_FileSystem_WriteByte(File%, Value%)
+BU_FileSystem_ReadByte%(File%)
+BU_FileSystem_WriteShort(File%, Value%)
+BU_FileSystem_ReadShort%(File%)
+BU_FileSystem_WriteInt(File%, Value%)
+BU_FileSystem_ReadInt%(File%)
+BU_FileSystem_WriteFloat(File%, Value#) : "BU_FileSystem_WriteInt"
+BU_FileSystem_ReadFloat#(File%) : "BU_FileSystem_ReadInt"
+
+;----------------------------------------------------------------
+;! System - Threading
+;----------------------------------------------------------------
+BU_Thread_Create%(pFunction%, pData%, uiStackSize%, bIsSuspended%)
+BU_Thread_Destroy(pThread%)
+BU_Thread_Terminate(pThread%, iExitCode%)
+BU_Thread_Suspend%(pThread%)
+BU_Thread_Resume%(pThread%)
+BU_Thread_Wait%(pThread%, iTimeout%)
+BU_Thread_GetExitCode%(pThread%)
+BU_Thread_Exit(iExitCode%)
+BU_Mutex_Create%()
+BU_Mutex_Destroy(pMutex%)
+BU_Mutex_Lock%(pMutex%, iTimeout%)
+BU_Mutex_Unlock%(pMutex%)
+
+;----------------------------------------------------------------
+;! Time - Time
+;----------------------------------------------------------------
+BU_Time_Now%()
+BU_Time_Create%(seconds%, minutes%, hours%, days%, months%, years%, isDST%)
+BU_Time_Destroy(pTime%)
+BU_Time_Format$(pTime%, formatString$)
+
+;----------------------------------------------------------------
+;! Time - Timer
+;----------------------------------------------------------------
+BU_Timer_Create%(Interval%, hwnd%) : "_BU_Timer_Create@8"
+BU_Timer_Destroy%(Timer%) : "_BU_Timer_Destroy@4"
+BU_Timer_Wait%(Timer%) : "_BU_Timer_Wait@4"
+
+;----------------------------------------------------------------
+;! Time - SystemClock
+;----------------------------------------------------------------
+BU_SystemClock_Now%()
+BU_SystemClock_Destroy(pSystemClock%)
+BU_SystemClock_FromTime%(pTime%)
+BU_SystemClock_AsTime%(pSystemClock%)
+
+;----------------------------------------------------------------
+;! Time - HighResolutionClock
+;----------------------------------------------------------------
+BU_HighResolutionClock_Now%()
+BU_HighResolutionClock_Destroy(pHighResolutionClock%)
+BU_HighResolutionClock_Duration%(pHighResolutionClock%, pOther%)
+BU_HighResolutionClock_DurationLL%(pHighResolutionClock%, pOther%)
+BU_HighResolutionClock_DurationF#(pHighResolutionClock%, pOther%)
+BU_HighResolutionClock_DurationD%(pHighResolutionClock%, pOther%)
+
+; Database --------------------------------------------------------------------
+; -- SQLite3
+; Core
+BU_SQLite_Version$()
+BU_SQLite_Version_Number%()
+BU_SQLite_SourceID$()
+BU_SQLite_CompileOption_Used%(zOptName$)
+BU_SQLite_CompileOption_Get$(n%)
+BU_SQLite_ThreadSafe%()
+BU_SQLite_Initialize%()
+BU_SQLite_Shutdown%()
+BU_SQLite_Sleep%(ms%)
+; Open & Close
+BU_SQLite_Open%(file$, db*)
+BU_SQLite_Open_V2%(file$, db*, flags%, zVfs$)
+BU_SQLite_Open_V2Ex%(file$, db*, flags%, zVfs%) : "BU_SQLite_Open_V2"
+BU_SQLite_Close%(db%)
+BU_SQLite_Close_V2%(db%)
+BU_SQLite_OpenSimple%(file$)
+BU_SQLite_OpenSimple_V2%(file$, flags%, zVfs$)
+BU_SQLite_OpenSimple_V2Ex%(file$, flags%, zVfs%) : "BU_SQLite_OpenSimple_V2"
+BU_SQLite_OpenSimpleError%()
+; Error Handling
+BU_SQLite_Error_Code%(db%)
+BU_SQLite_Extended_Error_Code%(db%)
+BU_SQLite_Error_Message$(db%)
+BU_SQLite_Error_String$(errorCode%)
+BU_SQLite_Extended_Result_Codes%(db%, onoff%)
+; Busy Handler
+BU_SQLite_Busy_Timeout%(db%, timeout%)
+BU_SQLite_Busy_Handler%(db%, pHandlerFunction3IPI%, param%)
+BU_SQLite_Busy_Handler_Simple%(db%, pHandlerFunc2II%)
+; Memory Management
+BU_SQLite_Memory_Used%()
+BU_SQLite_Memory_Highwater%(bReset%)
+BU_SQLite_Release_Memory%(bytes%)
+BU_SQLite_DB_Release_Memory%(db%)
+BU_SQLite_Randomness(n%, pBank*)
+; Database Management & Modification
+BU_SQLite_Exec%(db%, sql$, pCallback3PIPP%, param%, errMsg*)
+BU_SQLite_ExecEx%(db%, sql$, pCallback3PIPP%, param%, errMsg%) : "BU_SQLite_Exec"
+BU_SQLite_Last_Insert_RowId%(db%)
+BU_SQLite_Changes%(db%)
+BU_SQLite_Total_Changes%(db%)
+BU_SQLite_Interrupt(db%)
+BU_SQLite_Complete%(sql$)
+BU_SQLite_Get_Table%(db, zSql$, pazResult*, pnRow*, pnColumn*, pzErrMessage*)
+BU_SQLite_Free_Table%(result*)
+BU_SQLite_Set_Authorizer%(db%, pAuth5PIPPPP, pArg%)
+BU_SQLite_Trace%(db%, pTrace1PP, pArg%)
+BU_SQLite_Profile%(db%, pProfile2PPI, pArg%)
+BU_SQLite_Progress_Handler%(db%, nOps%, pProgress1IP%, pArg%)
+BU_SQLite_URI_Parameter$(zFilename$, zParam$)
+BU_SQLite_URI_Boolean%(zFilename$, zParam$, bDefault%)
+BU_SQLite_URI_LongLong%(zFilename$, zParam$, bDefault%)
+BU_SQLite_Limit%(db%, id%, newVal%)
+; Prepared Statements
+BU_SQLite_Next_Statement%(db%, pStmt%)
+BU_SQLite_Prepare%(db%, zSql$, nByte%, ppStmt*)
+BU_SQLite_PrepareEx%(db%, zSql$, nByte%, ppStmt%) : "BU_SQLite_Prepare"
+BU_SQLite_Prepare_V2%(db%, zSql$, nByte%, ppStmt*)
+BU_SQLite_Prepare_V2Ex%(db%, zSql$, nByte%, ppStmt%) : "BU_SQLite_Prepare_V2"
+BU_SQLite_Statement_ReadOnly%(pStmt%)
+BU_SQLite_Statement_Busy%(pStmt%)
+BU_SQLite_Statement_Status%(pStmt%, op%, resetFlag%)
+BU_SQLite_SQL$(pStmt%)
+BU_SQLite_Database_Handle%(pStmt%)
+BU_SQLite_Bind_Null%(pStmt%, index%)
+BU_SQLite_Bind_Int%(pStmt%, index%, value%)
+BU_SQLite_Bind_LongLong%(pStmt%, index%, pValue%)
+BU_SQLite_Bind_Float%(pStmt%, index%, value#)
+BU_SQLite_Bind_Double%(pStmt%, index%, pValue%)
+BU_SQLite_Bind_Text%(pStmt%, index%, zData$, nData%)
+BU_SQLite_Bind_Blob%(pStmt%, index%, zData$, nData%)
+BU_SQLite_Bind_Value%(pStmt%, index%, pValue%)
+BU_SQLite_Bind_ZeroBlob%(pStmt%, index%, bytes%)
+BU_SQLite_Bind_Parameter_Count%(pStmt%)
+BU_SQLite_Bind_Parameter_Name$(pStmt%, index%)
+BU_SQLite_Bind_Parameter_Index%(pStmt%, zName$)
+BU_SQLite_Clear_Bindings%(pStmt%)
+BU_SQLite_Column_Count%(pStmt%)
+BU_SQLite_Column_Name$(pStmt%, index%)
+BU_SQLite_Column_DeclaredType$(pStmt%, index%)
+BU_SQLite_Step%(pStmt%)
+BU_SQLite_Data_Count%(pStmt%)
+BU_SQLite_Column_Blob%(pStmt%, iCol%)
+BU_SQLite_Column_Bytes%(pStmt%, iCol%)
+BU_SQLite_Column_Float%(pStmt%, iCol%)
+BU_SQLite_Column_Double%(pStmt%, iCol%)
+BU_SQLite_Column_Int%(pStmt%, iCol%)
+BU_SQLite_Column_LongLong%(pStmt%, iCol%)
+BU_SQLite_Column_Text$(pStmt%, iCol%)
+BU_SQLite_Column_Value%(pStmt%, iCol%)
+BU_SQLite_Column_Type%(pStmt%, iCol%)
+BU_SQLite_Finalize%(pStmt%)
+BU_SQLite_Reset%(pStmt%)
+; SQLite Values
+BU_SQLite_Value_Blob%(pValue%)
+BU_SQLite_Value_Bytes%(pValue%)
+BU_SQLite_Value_Int%(pValue%)
+BU_SQLite_Value_LongLong%(pValue%)
+BU_SQLite_Value_Float#(pValue%)
+BU_SQLite_Value_Double%(pValue%)
+BU_SQLite_Value_Text$(pValue%)
+BU_SQLite_Value_Type%(pValue%)
+BU_SQLite_Value_Numeric_Type%(pValue%)
+BU_SQLite_Value_SubType%(pValue%)
+BU_SQLite_Value_Duplicate%(pValue%)
+BU_SQLite_Value_Free(pValue%)
+
+; Types - Long ----------------------------------------------------------------
+BU_Long_New%()																	:"_BU_Long_New@0"
+BU_Long_Copy%(pThis%)															:"_BU_Long_Copy@4"
+BU_Long_Destroy(pThis%)															:"_BU_Long_Destroy@4"
+BU_Long_ToString$(pThis%)														:"_BU_Long_ToString@4"
+BU_Long_FromString%(cString$)													:"_BU_Long_FromString@4"
+BU_Long_FromI%(iRight%)															:"_BU_Long_FromI@4"
+BU_Long_FromII%(iLeft%, iRight%)												:"_BU_Long_FromII@8"
+BU_Long_ToI%(pThis%, iShift%)													:"_BU_Long_ToI@8"
+BU_Long_ToIH%(pThis%)															:"_BU_Long_ToIH@4"
+BU_Long_ToIL%(pThis%)															:"_BU_Long_ToIL@4"
+BU_Long_FromF%(Float#)															:"_BU_Long_FromF@4"
+BU_Long_ToF#(pThis%)															:"_BU_Long_ToF@4"
+BU_Long_FromD(pDouble%)															:"_BU_Long_FromD@4"
+BU_Long_ToD(pThis%)																:"_BU_Long_ToD@4"
+BU_Long_Compare%(pThis%, pRight%)												:"_BU_Long_Compare@8"
+BU_Long_Set%(pThis%, pOther%)													:"_BU_Long_Set@8"
+BU_Long_Add%(pThis%, pOther%)													:"_BU_Long_Add@8"
+BU_Long_Sub%(pThis%, pOther%)													:"_BU_Long_Sub@8"
+BU_Long_Div%(pThis%, pOther%)													:"_BU_Long_Div@8"
+BU_Long_Mul%(pThis%, pOther%)													:"_BU_Long_Mul@8"
+BU_Long_Mod%(pThis%, pOther%)													:"_BU_Long_Mod@8"
+BU_Long_SetI%(pThis%, iRight%)													:"_BU_Long_SetI@8"
+BU_Long_AddI%(pThis%, iRight%)													:"_BU_Long_AddI@8"
+BU_Long_SubI%(pThis%, iRight%)													:"_BU_Long_SubI@8"
+BU_Long_DivI%(pThis%, iRight%)													:"_BU_Long_DivI@8"
+BU_Long_MulI%(pThis%, iRight%)													:"_BU_Long_MulI@8"
+BU_Long_ModI%(pThis%, iRight%)													:"_BU_Long_ModI@8"
+BU_Long_SetII%(pThis%, iLeft%, iRight%)											:"_BU_Long_SetII@12"
+BU_Long_AddII%(pThis%, iLeft%, iRight%)											:"_BU_Long_AddII@12"
+BU_Long_SubII%(pThis%, iLeft%, iRight%)											:"_BU_Long_SubII@12"
+BU_Long_DivII%(pThis%, iLeft%, iRight%)											:"_BU_Long_DivII@12"
+BU_Long_MulII%(pThis%, iLeft%, iRight%)											:"_BU_Long_MulII@12"
+BU_Long_ModII%(pThis%, iLeft%, iRight%)											:"_BU_Long_ModII@12"
+BU_Long_Shift%(pThis%, iRight%)													:"_BU_Long_Shift@8"
+
+; Double ------------------------------------------------------------------------
+BU_Double_New%()																:"_BU_Double_New@0"
+BU_Double_Copy%(pThis%)															:"_BU_Double_Copy@4"
+BU_Double_Destroy(pThis%)														:"_BU_Double_Destroy@4"
+BU_Double_ToString$(pThis%)														:"_BU_Double_ToString@4"
+BU_Double_FromString%(cString$)													:"_BU_Double_FromString@4"
+BU_Double_FromF%(Float#)														:"_BU_Double_FromF@4"
+BU_Double_ToF#(pThis%)															:"_BU_Double_ToF@4"
+BU_Double_FromI%(iRight%)														:"_BU_Double_FromI@4"
+BU_Double_ToI%(pThis%)															:"_BU_Double_ToI@8"
+BU_Double_FromL(pDouble%)														:"_BU_Double_FromL@4"
+BU_Double_ToL(pThis%)															:"_BU_Double_ToL@4"
+BU_Double_Compare%(pThis%, pOther%)												:"_BU_Double_Compare@8"
+BU_Double_Set%(pThis%, pOther%)													:"_BU_Double_Set@8"
+BU_Double_Add%(pThis%, pOther%)													:"_BU_Double_Add@8"
+BU_Double_Sub%(pThis%, pOther%)													:"_BU_Double_Sub@8"
+BU_Double_Div%(pThis%, pOther%)													:"_BU_Double_Div@8"
+BU_Double_Mul%(pThis%, pOther%)													:"_BU_Double_Mul@8"
+BU_Double_Mod%(pThis%, pOther%)													:"_BU_Double_Mod@8"
+BU_Double_SetF%(pThis%, fOther%)												:"_BU_Double_SetF@8"
+BU_Double_AddF%(pThis%, fOther%)												:"_BU_Double_AddF@8"
+BU_Double_SubF%(pThis%, fOther%)												:"_BU_Double_SubF@8"
+BU_Double_DivF%(pThis%, fOther%)												:"_BU_Double_DivF@8"
+BU_Double_MulF%(pThis%, fOther%)												:"_BU_Double_MulF@8"
+BU_Double_ModF%(pThis%, fOther%)												:"_BU_Double_ModF@8"
+
+; Utility ---------------------------------------------------------------------
+; -- Display Enumerator
+BU_DisplayEnumerator_Create%()													:"_BU_DisplayEnumerator_Create@0"
+BU_DisplayEnumerator_Destroy(DisplayEnumerator%)								:"_BU_DisplayEnumerator_Destroy@4"
+BU_DisplayEnumerator_Enumerate%(DisplayEnumerator%)								:"_BU_DisplayEnumerator_Enumerate@4"
+BU_DisplayEnumerator_Count%(DisplayEnumerator%)									:"_BU_DisplayEnumerator_Count@4"
+BU_DisplayEnumerator_Retrieve(DisplayEnumerator%, index%, Rect*)				:"_BU_DisplayEnumerator_Retrieve@12"
+; -- Indexer V1 (Array)
+BU_IndexerV1_Create%()
+BU_IndexerV1_Destroy(Indexer%)
+BU_IndexerV1_Mark(Indexer%, Used%)
+BU_IndexerV1_MarkFree(Indexer%)
+BU_IndexerV1_MarkUsed(Indexer%)
+BU_IndexerV1_Is%(Indexer%, Used%)
+BU_IndexerV1_IsFree%(Indexer%)
+BU_IndexerV1_IsUsed%(Indexer%)
+BU_IndexerV1_Get%(Indexer%)
+BU_IndexerV1_Count%(Indexer%, Used%)
+BU_IndexerV1_CountFree%(Indexer%)
+BU_IndexerV1_CountUsed%(Indexer%)
+; -- Indexer V2 (List)
+BU_IndexerV2_Create%()
+BU_IndexerV2_Destroy(Indexer%)
+BU_IndexerV2_Mark(Indexer%, Used%)
+BU_IndexerV2_MarkFree(Indexer%)
+BU_IndexerV2_MarkUsed(Indexer%)
+BU_IndexerV2_Is%(Indexer%, Used%)
+BU_IndexerV2_IsFree%(Indexer%)
+BU_IndexerV2_IsUsed%(Indexer%)
+BU_IndexerV2_Get%(Indexer%)
+BU_IndexerV2_Count%(Indexer%, Used%)
+BU_IndexerV2_CountFree%(Indexer%)
+BU_IndexerV2_CountUsed%(Indexer%)
+; -- Mass Operation
+BU_MassOp_Create%(length%)
+BU_MassOp_Destroy(massop%)
+BU_MassOp_Instruction(massop%, index%, type%, code%, leftOperand%, rightOperand%, result%)
+BU_MassOp_Run(massop%)
+; -- ThreadWrapper
+BU_ThreadWrapper_Create%(pFunction%, pData%)
+BU_ThreadWrapper_Destroy(pThreadWrapper%)
+; -- Window Message Handler
+BU_WindowMessageHandler_Install(hwnd%)
+BU_WindowMessageHandler_Uninstall(hwnd%)
+BU_WindowMessageHandler_Message_Close%(hwnd%)
+BU_WindowMessageHandler_Message_Destroy%(hwnd%)
+BU_WindowMessageHandler_Message_Resize%(hwnd%, point*)
+
+
+; Helpers ---------------------------------------------------------------------
+.lib " "
+; -- Blitz Functions
+BU_Helper_Window_LockPointer(HWND%)
+BU_Helper_Window_LockPointerAuto(HWND%)
+BU_Helper_Window_MakeBorderless(HWND%)
+BU_Helper_Window_Center(HWND%, Monitor%)
+BU_Helper_Window_Fill(HWND%, Monitor%)
+
+; -- Windows API (User32)
+.lib "User32.dll"
+BU_User32_ClientToScreen%(hwnd%, point*)										: "ClientToScreen"
+BU_User32_ClientToScreenEx%(hwnd%, point%)										: "ClientToScreen"
+BU_User32_ClipCursor%(rect*)													: "ClipCursor"
+BU_User32_ClipCursorEx%(ptr%)													: "ClipCursor"
+BU_User32_GetActiveWindow%()													: "GetActiveWindow"
+BU_User32_GetSystemMetrics%(index%)												: "GetSystemMetrics"
+BU_User32_SetWindowLong%(hwnd%, nIndex%, dwNewLong%)							: "SetWindowLongA"
+BU_User32_GetWindowLong%(hwnd%, index%)											: "GetWindowLongA"
+BU_User32_GetWindowRect%(hwnd%, rect*)											: "GetWindowRect"
+BU_User32_GetWindowRectEx%(hwnd%, rect%)										: "GetWindowRect"
+BU_User32_GetClientRect%(hwnd%, rect*)											: "GetClientRect"
+BU_User32_GetClientRectEx%(hwnd%, rect%)										: "GetClientRect"
+BU_User32_SetWindowPos%(hwnd%, hWndInsertAfter%, x%, y%, cx%, cy%, wFlags%)		: "SetWindowPos" 
+BU_User32_MessageBox%(hwnd%, lpText$, lpCaption$, uType%)						: "MessageBoxA"
+
+; -- Windows API (Kernel32)
+.lib "Kernel32.dll"
+BU_Kernel32_FlushFileBuffers%(hFile%)											: "FlushFileBuffers"
+FlushFile%(hFile%)																: "FlushFileBuffers"
+BU_Kernel32_QueryPerformanceCounter%(pLongLong%)								: "QueryPerformanceCounter"
+BU_Kernel32_QueryPerformanceFrequency%(pLongLong%)								: "QueryPerformanceFrequency"

System/FileSystem.cpp

@@ -0,0 +1,128 @@
+//	BlitzUtility - Expanding the normal Blitz functionality.
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "FileSystem.h"
+
+using namespace std;
+
+DLL_FUNCTION(std::fstream*) BU_FileSystem_WriteFile(const char* path) {
+#pragma comment(linker, "/EXPORT:BU_FileSystem_WriteFile=_BU_FileSystem_WriteFile@4")
+	std::fstream* file = new std::fstream();
+	file->open(path, ios::in | ios::out || ios::trunc | ios::binary);
+	return file;
+}
+
+DLL_FUNCTION(std::fstream*) BU_FileSystem_OpenFile(const char* path) {
+#pragma comment(linker, "/EXPORT:BU_FileSystem_OpenFile=_BU_FileSystem_OpenFile@4")
+	std::fstream* file = new std::fstream();
+	file->open(path, ios::in | ios::out | ios::binary);
+	return file;
+}
+
+DLL_FUNCTION(std::fstream*) BU_FileSystem_ReadFile(const char* path) {
+#pragma comment(linker, "/EXPORT:BU_FileSystem_ReadFile=_BU_FileSystem_ReadFile@4")
+	std::fstream* file = new std::fstream();
+	file->open(path, ios::in | ios::binary);
+	return file;
+}
+
+DLL_FUNCTION(void) BU_FileSystem_CloseFile(std::fstream* file) {
+#pragma comment(linker, "/EXPORT:BU_FileSystem_CloseFile=_BU_FileSystem_CloseFile@4")
+	file->close();
+	delete file;
+}
+
+DLL_FUNCTION(void) BU_FileSystem_FlushFile(std::fstream* file) {
+#pragma comment(linker, "/EXPORT:BU_FileSystem_FlushFile=_BU_FileSystem_FlushFile@4")
+	file->flush();
+}
+
+DLL_FUNCTION(int32_t) BU_FileSystem_EOF(std::fstream* file) {
+#pragma comment(linker, "/EXPORT:BU_FileSystem_EOF=_BU_FileSystem_EOF@4")
+	if (file->eof())
+		return 1;
+	if (file->bad())
+		return -1;
+	if (file->fail())
+		return -2;
+	
+	return 0;
+}
+
+DLL_FUNCTION(void) BU_FileSystem_SeekFile(std::fstream* file, int32_t pos) {
+#pragma comment(linker, "/EXPORT:BU_FileSystem_SeekFile=_BU_FileSystem_SeekFile@8")
+	file->seekg(pos);
+	file->seekp(pos);
+}
+
+DLL_FUNCTION(void) BU_FileSystem_SeekFileIn(std::fstream* file, int32_t pos) {
+#pragma comment(linker, "/EXPORT:BU_FileSystem_SeekFileIn=_BU_FileSystem_SeekFileIn@8")
+	file->seekg(pos);
+}
+
+DLL_FUNCTION(void) BU_FileSystem_SeekFileOut(std::fstream* file, int32_t pos) {
+#pragma comment(linker, "/EXPORT:BU_FileSystem_SeekFileOut=_BU_FileSystem_SeekFileOut@8")
+	file->seekp(pos);
+}
+
+DLL_FUNCTION(int32_t) BU_FileSystem_FilePosIn(std::fstream* file) {
+#pragma comment(linker, "/EXPORT:BU_FileSystem_FilePosIn=_BU_FileSystem_FilePosIn@4")
+	return (int32_t)file->tellg();
+}
+
+DLL_FUNCTION(int32_t) BU_FileSystem_FilePosOut(std::fstream* file) {
+#pragma comment(linker, "/EXPORT:BU_FileSystem_FilePosOut=_BU_FileSystem_FilePosOut@4")
+	return (int32_t)file->tellp();
+}
+
+DLL_FUNCTION(void) BU_FileSystem_WriteByte(std::fstream* file, int32_t value) {
+#pragma comment(linker, "/EXPORT:BU_FileSystem_WriteByte=_BU_FileSystem_WriteByte@8")
+	char myVal[1] = { value & 0xFF};
+	file->write(myVal, 1);
+}
+
+DLL_FUNCTION(int32_t) BU_FileSystem_ReadByte(std::fstream* file) {
+#pragma comment(linker, "/EXPORT:BU_FileSystem_ReadByte=_BU_FileSystem_ReadByte@4")
+	char myVal[1] = { 0 };
+	file->read(myVal, 1);
+	return myVal[0];
+}
+
+DLL_FUNCTION(void) BU_FileSystem_WriteShort(std::fstream* file, int32_t value) {
+#pragma comment(linker, "/EXPORT:BU_FileSystem_WriteShort=_BU_FileSystem_WriteShort@8")
+	char myVal[2] = { value & 0xFF, (value >> 8) & 0xFF};
+	file->write(myVal, 2);
+}
+
+DLL_FUNCTION(int32_t) BU_FileSystem_ReadShort(std::fstream* file) {
+#pragma comment(linker, "/EXPORT:BU_FileSystem_ReadShort=_BU_FileSystem_ReadShort@4")
+	char myVal[2] = { 0, 0 };
+	file->read(myVal, 2);
+	return (myVal[1] << 8) + myVal[0];
+}
+
+DLL_FUNCTION(void) BU_FileSystem_WriteInt(std::fstream* file, int32_t value) {
+#pragma comment(linker, "/EXPORT:BU_FileSystem_WriteInt=_BU_FileSystem_WriteInt@8")
+	char myVal[4] = { value & 0xFF, (value >> 8) & 0xFF, (value >> 16) & 0xFF , (value >> 24) & 0xFF };
+	file->write(myVal, 4);
+}
+
+DLL_FUNCTION(int32_t) BU_FileSystem_ReadInt(std::fstream* file) {
+#pragma comment(linker, "/EXPORT:BU_FileSystem_ReadInt=_BU_FileSystem_ReadInt@4")
+	char myVal[4] = { 0, 0, 0, 0 };
+	file->read(myVal, 4);
+	return (myVal[3] << 24) + (myVal[2] << 16) + (myVal[1] << 8) + myVal[0];
+}

System/FileSystem.h

@@ -0,0 +1,21 @@
+//	Blitz - Steam wrapper for Blitz.
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#pragma once
+#include "BlitzUtility.h"
+#include <mutex>
+#include <iostream>
+#include <fstream>

System/Threading.cpp

@@ -0,0 +1,143 @@
+//	BlitzUtility - Expanding the normal Blitz functionality.
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "Threading.h"
+
+// Types of Blitz Functions.
+typedef int32_t(__stdcall *BP_BlitzFunction1_t)(int32_t);
+int32_t BP_CallFunction1(BP_BlitzFunction1_t lpFunctionPointer, int32_t p1) {
+	int32_t returnValue, StackPointer;
+
+	__asm { // Store Stack Pointer
+		mov StackPointer, esp;
+	}
+
+	returnValue = lpFunctionPointer(p1);
+
+	__asm { // Restore Stack Pointer
+		mov esp, StackPointer;
+	}
+
+	return returnValue;
+}
+
+BlitzThread::BlitzThread(void* ptr, void* data, uint32_t uiStackSize, bool bIsSuspended) {
+	this->ptr = ptr;
+	this->data = data;
+
+	this->thread = CreateThread(NULL, uiStackSize, &ThreadMain, this, (bIsSuspended ? CREATE_SUSPENDED : 0), NULL);
+}
+
+BlitzThread::~BlitzThread() {
+	this->Terminate(-1);
+}
+
+void BlitzThread::Terminate(int32_t exitCode) {
+	if (this->thread) {
+		TerminateThread(this->thread, -1);
+		this->thread = 0;
+	}
+}
+
+int32_t BlitzThread::Suspend() {
+	return SuspendThread(this->thread);
+}
+
+int32_t BlitzThread::Resume() {
+	return ResumeThread(this->thread);
+}
+
+int32_t BlitzThread::Wait(int32_t timeout) {
+	return WaitForSingleObject(this->thread, timeout);
+}
+
+int32_t BlitzThread::GetExitCode() {
+	DWORD pExitCode;
+	GetExitCodeThread(this->thread, &pExitCode);
+	return pExitCode;
+}
+
+DWORD WINAPI BlitzThread::ThreadMain(LPVOID pData) {
+	BlitzThread* pThis = reinterpret_cast<BlitzThread*>(pData);
+
+	try {
+		return BP_CallFunction1((BP_BlitzFunction1_t)pThis->ptr, reinterpret_cast<int32_t>(pThis->data));
+	} catch (std::exception e) {
+		return -2;
+	} catch (...) {
+		return -1;
+	}
+}
+
+DLL_FUNCTION(BlitzThread*) BU_Thread_Create(void* pFunction, void* pData, uint32_t uiStackSize, uint32_t bIsSuspended) {
+#pragma comment(linker, "/EXPORT:BU_Thread_Create=_BU_Thread_Create@16")
+	return new BlitzThread(pFunction, pData, uiStackSize, !!bIsSuspended);
+}
+
+DLL_FUNCTION(void) BU_Thread_Destroy(BlitzThread* pThread) {
+#pragma comment(linker, "/EXPORT:BU_Thread_Destroy=_BU_Thread_Destroy@4")
+	delete pThread;
+}
+DLL_FUNCTION(void) BU_Thread_Terminate(BlitzThread* pThread, int32_t exitCode) {
+#pragma comment(linker, "/EXPORT:BU_Thread_Terminate=_BU_Thread_Terminate@8")
+	pThread->Terminate(exitCode);
+	delete pThread;
+}
+
+DLL_FUNCTION(int32_t) BU_Thread_Suspend(BlitzThread* pThread) {
+#pragma comment(linker, "/EXPORT:BU_Thread_Suspend=_BU_Thread_Suspend@4")
+	return pThread->Suspend();
+}
+
+DLL_FUNCTION(int32_t) BU_Thread_Resume(BlitzThread* pThread) {
+#pragma comment(linker, "/EXPORT:BU_Thread_Resume=_BU_Thread_Resume@4")
+	return pThread->Resume();
+}
+
+DLL_FUNCTION(int32_t) BU_Thread_Wait(BlitzThread* pThread, int32_t timeout) {
+#pragma comment(linker, "/EXPORT:BU_Thread_Wait=_BU_Thread_Wait@8")
+	return pThread->Wait(timeout);
+}
+
+DLL_FUNCTION(int32_t) BU_Thread_GetExitCode(BlitzThread* pThread) {
+#pragma comment(linker, "/EXPORT:BU_Thread_GetExitCode=_BU_Thread_GetExitCode@4")
+	return pThread->GetExitCode();
+}
+
+DLL_FUNCTION(void) BU_Thread_Exit(int32_t exitCode) {
+#pragma comment(linker, "/EXPORT:BU_Thread_Exit=_BU_Thread_Exit@4")
+	ExitThread(exitCode);
+}
+
+DLL_FUNCTION(HANDLE) BU_Mutex_Create(int32_t bInitialOwner) {
+#pragma comment(linker, "/EXPORT:BU_Mutex_Create=_BU_Mutex_Create@4")
+	return CreateMutex(NULL, !!bInitialOwner, NULL);
+}
+
+DLL_FUNCTION(void) BU_Mutex_Destroy(HANDLE mutex) {
+#pragma comment(linker, "/EXPORT:BU_Mutex_Destroy=_BU_Mutex_Destroy@4")
+	CloseHandle(mutex);
+}
+
+DLL_FUNCTION(int32_t) BU_Mutex_Lock(HANDLE mutex, int32_t timeout) {
+#pragma comment(linker, "/EXPORT:BU_Mutex_Lock=_BU_Mutex_Lock@8")
+	return WaitForSingleObject(mutex, timeout);
+}
+
+DLL_FUNCTION(int32_t) BU_Mutex_Unlock(HANDLE mutex) {
+#pragma comment(linker, "/EXPORT:BU_Mutex_Unlock=_BU_Mutex_Unlock@4")
+	return ReleaseMutex(mutex);
+}

System/Threading.h

@@ -0,0 +1,44 @@
+//	Blitz - Steam wrapper for Blitz.
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#pragma once
+#include "BlitzUtility.h"
+#include <mutex>
+#include <chrono>
+
+class BlitzThread {
+public:
+	BlitzThread(void* ptr, void* data, uint32_t uiStackSize, bool bIsSuspended);
+	~BlitzThread();
+
+	void Terminate(int32_t exitCode);
+
+	int32_t Suspend();
+	int32_t Resume();
+	int32_t Wait(int32_t timeout);
+	int32_t GetExitCode();
+
+	static DWORD WINAPI ThreadMain(LPVOID pData);
+private:
+	void *ptr, *data;
+	std::exception* ex;
+
+	HANDLE thread;
+};
+
+
+
+

Time/HighResolutionClock.cpp

@@ -0,0 +1,53 @@
+//	BlitzUtility - Expanding the normal Blitz functionality.
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "HighResolutionClock.h"
+using namespace std;
+using namespace std::chrono;
+
+DLL_FUNCTION(high_resolution_clock::time_point*) BU_HighResolutionClock_Now() {
+#pragma comment(linker, "/EXPORT:BU_HighResolutionClock_Now=_BU_HighResolutionClock_Now@0")
+	return new high_resolution_clock::time_point(high_resolution_clock::now());
+}
+
+DLL_FUNCTION(void) BU_HighResolutionClock_Destroy(high_resolution_clock::time_point* pThis) {
+#pragma comment(linker, "/EXPORT:BU_HighResolutionClock_Destroy=_BU_HighResolutionClock_Destroy@4")
+	delete pThis;
+}
+
+DLL_FUNCTION(int32_t) BU_HighResolutionClock_Duration(high_resolution_clock::time_point* pThis, high_resolution_clock::time_point* pOther) {
+#pragma comment(linker, "/EXPORT:BU_HighResolutionClock_Duration=_BU_HighResolutionClock_Duration@8")
+	duration<int32_t, std::nano> temp = chrono::duration_cast<duration<int32_t, std::nano>>(*pThis - *pOther);
+	return temp.count();
+}
+
+DLL_FUNCTION(int64_t*) BU_HighResolutionClock_DurationLL(high_resolution_clock::time_point* pThis, high_resolution_clock::time_point* pOther) {
+#pragma comment(linker, "/EXPORT:BU_HighResolutionClock_DurationLL=_BU_HighResolutionClock_DurationLL@8")
+	duration<int64_t, std::nano> temp = (*pThis - *pOther);
+	return new int64_t(temp.count());
+}
+
+DLL_FUNCTION(float_t) BU_HighResolutionClock_DurationF(high_resolution_clock::time_point* pThis, high_resolution_clock::time_point* pOther) {
+#pragma comment(linker, "/EXPORT:BU_HighResolutionClock_DurationF=_BU_HighResolutionClock_DurationF@8")
+	double_t duration = (chrono::duration_cast<chrono::duration<double_t>>(*pThis - *pOther)).count();
+	return (float_t)(duration);
+}
+
+DLL_FUNCTION(double_t*) BU_HighResolutionClock_DurationD(high_resolution_clock::time_point* pThis, high_resolution_clock::time_point* pOther) {
+#pragma comment(linker, "/EXPORT:BU_HighResolutionClock_DurationD=_BU_HighResolutionClock_DurationD@8")
+	double_t duration = (chrono::duration_cast<chrono::duration<double_t>>(*pThis - *pOther)).count();
+	return new double_t(duration);
+}

Time/HighResolutionClock.h

@@ -0,0 +1,26 @@
+//	BlitzUtility - Expanding the normal Blitz functionality.
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#pragma once
+#include "BlitzUtility.h"
+#include <chrono>
+
+DLL_FUNCTION(std::chrono::high_resolution_clock::time_point*) BU_HighResolutionClock_Now();
+DLL_FUNCTION(void) BU_HighResolutionClock_Destroy(std::chrono::high_resolution_clock::time_point* pThis);
+DLL_FUNCTION(int32_t) BU_HighResolutionClock_Duration(std::chrono::high_resolution_clock::time_point* pThis, std::chrono::high_resolution_clock::time_point* pOther);
+DLL_FUNCTION(int64_t*) BU_HighResolutionClock_DurationLL(std::chrono::high_resolution_clock::time_point* pThis, std::chrono::high_resolution_clock::time_point* pOther);
+DLL_FUNCTION(float_t) BU_HighResolutionClock_DurationF(std::chrono::high_resolution_clock::time_point* pThis, std::chrono::high_resolution_clock::time_point* pOther);
+DLL_FUNCTION(double_t*) BU_HighResolutionClock_DurationD(std::chrono::high_resolution_clock::time_point* pThis, std::chrono::high_resolution_clock::time_point* pOther);

Time/SystemClock.cpp

@@ -0,0 +1,37 @@
+//	BlitzUtility - Expanding the normal Blitz functionality.
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "SystemClock.h"
+
+DLL_FUNCTION(std::chrono::system_clock::time_point*) BU_SystemClock_Now() {
+#pragma comment(linker, "/EXPORT:BU_SystemClock_Now=_BU_SystemClock_Now@0")
+	return new std::chrono::system_clock::time_point(std::chrono::system_clock::now());
+}
+
+DLL_FUNCTION(void) BU_SystemClock_Destroy(std::chrono::system_clock::time_point* pThis) {
+#pragma comment(linker, "/EXPORT:BU_SystemClock_Destroy=_BU_SystemClock_Destroy@4")
+	delete pThis;
+}
+
+DLL_FUNCTION(std::chrono::system_clock::time_point*) BU_SystemClock_FromTime(time_t* pTime) {
+#pragma comment(linker, "/EXPORT:BU_SystemClock_FromTime=_BU_SystemClock_FromTime@4")
+	return new std::chrono::system_clock::time_point(std::chrono::system_clock::from_time_t(*pTime));
+}
+
+DLL_FUNCTION(time_t*) BU_SystemClock_AsTime(std::chrono::system_clock::time_point* pThis) {
+#pragma comment(linker, "/EXPORT:BU_SystemClock_AsTime=_BU_SystemClock_AsTime@4")
+	return new time_t(std::chrono::system_clock::to_time_t(*pThis));
+}

Time/SystemClock.h

@@ -0,0 +1,24 @@
+//	BlitzUtility - Expanding the normal Blitz functionality.
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#pragma once
+#include "BlitzUtility.h"
+#include <chrono>
+
+DLL_FUNCTION(std::chrono::system_clock::time_point*) BU_SystemClock_Now();
+DLL_FUNCTION(void) BU_SystemClock_Destroy(std::chrono::system_clock::time_point* pThis);
+DLL_FUNCTION(std::chrono::system_clock::time_point*) BU_SystemClock_FromTime(time_t* pTime);
+DLL_FUNCTION(time_t*) BU_SystemClock_AsTime(std::chrono::system_clock::time_point* pThis);

Time/Time.cpp

@@ -0,0 +1,57 @@
+//	BlitzUtility - Expanding the normal Blitz functionality.
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "Time.h"
+
+DLL_FUNCTION(time_t*) BU_Time_Now() {
+#pragma comment(linker, "/EXPORT:BU_Time_Now=_BU_Time_Now@0")
+	time_t* pTime = new time_t();
+	time(pTime);
+	return pTime;
+}
+
+DLL_FUNCTION(time_t*) BU_Time_Create(uint32_t seconds, uint32_t minutes, uint32_t hours, uint32_t days, uint32_t months, uint32_t years, uint32_t isDaylightSavings) {
+#pragma comment(linker, "/EXPORT:BU_Time_Create=_BU_Time_Create@28")
+	tm* pTM = new tm();
+	pTM->tm_sec = seconds;
+	pTM->tm_min = minutes;
+	pTM->tm_hour = hours;
+	pTM->tm_mday = days;
+	pTM->tm_mon = months;
+	pTM->tm_year = years;
+	pTM->tm_isdst = isDaylightSavings;
+
+	time_t* pTime = new time_t(mktime(pTM));
+	delete pTM;
+	return pTime;
+}
+
+DLL_FUNCTION(void) BU_Time_Destroy(time_t* pTime) {
+#pragma comment(linker, "/EXPORT:BU_Time_Destroy=_BU_Time_Destroy@4")
+	delete pTime;
+}
+
+char* BU_Time_Format_Buffer = new char[1024];
+DLL_FUNCTION(const char*) BU_Time_Format(time_t* pTime, const char* pchFormatString) {
+#pragma comment(linker, "/EXPORT:BU_Time_Format=_BU_Time_Format@8")
+	tm* pTM = new tm;
+	localtime_s(pTM, pTime);
+	
+	strftime(BU_Time_Format_Buffer, 1024, pchFormatString, pTM);
+	delete pTM;
+
+	return BU_Time_Format_Buffer;
+}

Time/Time.h

@@ -0,0 +1,25 @@
+//	BlitzUtility - Expanding the normal Blitz functionality.
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#pragma once
+#include "BlitzUtility.h"
+#include <chrono>
+#include <time.h>
+
+DLL_FUNCTION(time_t*) BU_Time_Now();
+DLL_FUNCTION(time_t*) BU_Time_Create(uint32_t seconds, uint32_t minutes, uint32_t hours, uint32_t days, uint32_t months, uint32_t years, uint32_t isDaylightSavings);
+DLL_FUNCTION(void) BU_Time_Destroy(time_t* pTime);
+DLL_FUNCTION(const char*) BU_Time_Format(time_t* pTime, const char* pchFormatString);

Time/Timer.cpp

@@ -0,0 +1,72 @@
+//	BlitzUtility - Expanding the normal Blitz functionality.
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "Timer.h"
+#include <string.h>
+#include <string>
+#include <functional>
+#include <chrono>
+#include <future>
+#include <cstdio>
+
+using namespace std;
+
+struct BlitzTimerInfo {
+	uint32_t Interval;
+
+	HANDLE hSemaphore;
+};
+
+int32_t BU_Timer_Index = 0;
+std::map<int32_t, BlitzTimerInfo> BU_Timer_List;// = new std::map<int32_t, HANDLE>();
+
+VOID CALLBACK BU_Timer_PROC(
+	_In_ HWND     hwnd,
+	_In_ UINT     uMsg,
+	_In_ UINT_PTR idEvent,
+	_In_ DWORD    dwTime
+) {
+	BlitzTimerInfo myTimer = BU_Timer_List[idEvent];
+	ReleaseSemaphore(myTimer.hSemaphore, 1, NULL);
+}
+
+DLL_FUNCTION(int32_t) BU_Timer_Create(uint32_t Interval, HWND hwnd) {
+	UINT_PTR timer = SetTimer(hwnd, 32767, Interval, &BU_Timer_PROC);
+
+	if (timer) {
+		BlitzTimerInfo myTimer = BlitzTimerInfo();
+		myTimer.Interval = Interval;
+		myTimer.hSemaphore = CreateSemaphore(NULL, 0, 32767, NULL);
+		BU_Timer_List[timer] = myTimer;
+		return timer;
+	} else {
+		return 0;
+	}
+}
+
+DLL_FUNCTION(void) BU_Timer_Destroy(uint32_t Id) {
+	BlitzTimerInfo myTimer = BU_Timer_List[Id];
+	CloseHandle(myTimer.hSemaphore);
+	BU_Timer_List.erase(Id);
+}
+
+DLL_FUNCTION(int32_t) BU_Timer_Wait(uint32_t Id) {
+	BlitzTimerInfo myTimer = BU_Timer_List[Id];
+
+	//HANDLE myHandles[] = { myTimer.hSemaphore };
+	//MsgWaitForMultipleObjects(1, myHandles, true, 0xFFFFFFFF, QS_TIMER);
+	return WaitForSingleObject(myTimer.hSemaphore, 0xFFFFFFFF);
+}

Time/Timer.h

@@ -0,0 +1,23 @@
+//	BlitzUtility - Expanding the normal Blitz functionality.
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#pragma once
+#include "BlitzUtility.h"
+#include <map>
+
+//DLL_FUNCTION(int32_t) BU_Timer_Create(uint32_t Interval);
+//DLL_FUNCTION(void) BU_Timer_Destroy(uint32_t Id);
+//DLL_FUNCTION(int32_t) BU_Timer_Wait(uint32_t Id);

Type/BVector3.cpp

@@ -1,374 +1,374 @@
-//	BlitzUtility - Expanding the normal Blitz functionality.
-//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
-//
-//	This program is free software: you can redistribute it and/or modify
-//	it under the terms of the GNU Lesser General Public License as
-//	published by the Free Software Foundation, either version 3 of the 
-//	License, or (at your option) any later version.
-//
-//	This program is distributed in the hope that it will be useful,
-//	but WITHOUT ANY WARRANTY; without even the implied warranty of
-//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//	GNU General Public License for more details.
-//
-//	You should have received a copy of the GNU Lesser General Public License
-//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-/*
-#include "Vector3.h"
-
-void Vector3::set(const float &o)
-{
-	this->X = o;
-	this->Y = o;
-	this->Z = o;
-}
-void Vector3::set(const float &x, const float &y, const float &z)
-{
-	this->X = x;
-	this->Y = y;
-	this->Z = z;
-}
-void Vector3::set(const Vector3 &o)
-{
-	if (this != &o) {
-		this->X = o.X;
-		this->Y = o.Y;
-		this->Z = o.Z;
-	}
-}
-
-void Vector3::add(const float &o)
-{
-	this->X += o;
-	this->Y += o;
-	this->Z += o;
-}
-void Vector3::add(const float &x, const float &y, const float &z)
-{
-	this->X += x;
-	this->Y += y;
-	this->Z += z;
-}
-void Vector3::add(const Vector3 &o)
-{
-	this->X += o.X;
-	this->Y += o.Y;
-	this->Z += o.Z;
-}
-
-void Vector3::sub(const float &o)
-{
-	this->X -= o;
-	this->Y -= o;
-	this->Z -= o;
-}
-void Vector3::sub(const float &x, const float &y, const float &z)
-{
-	this->X -= x;
-	this->Y -= y;
-	this->Z -= z;
-}
-void Vector3::sub(const Vector3 &o)
-{
-	this->X -= o.X;
-	this->Y -= o.Y;
-	this->Z -= o.Z;
-}
-
-void Vector3::mul(const float &o)
-{
-	this->X *= o;
-	this->Y *= o;
-	this->Z *= o;
-}
-void Vector3::mul(const float &x, const float &y, const float &z)
-{
-	this->X *= x;
-	this->Y *= y;
-	this->Z *= z;
-}
-void Vector3::mul(const Vector3 &o)
-{
-	this->X *= o.X;
-	this->Y *= o.Y;
-	this->Z *= o.Z;
-}
-
-void Vector3::div(const float &o)
-{
-	this->X /= o;
-	this->Y /= o;
-	this->Z /= o;
-}
-void Vector3::div(const float &x, const float &y, const float &z)
-{
-	this->X /= x;
-	this->Y /= y;
-	this->Z /= z;
-}
-void Vector3::div(const Vector3 &o)
-{
-	this->X /= o.X;
-	this->Y /= o.Y;
-	this->Z /= o.Z;
-}
-
-float Vector3::length()
-{
-	return sqrt(this->X * this->X + this->Y * this->Y + this->Z * this->Z);
-}
-float Vector3::distance(const float &x, const float &y, const float &z)
-{
-	float X = (this->X - x);
-	float Y = (this->Y - y);
-	float Z = (this->Z - z);
-	return sqrt(X * X + Y * Y + Z * Z);
-}
-float Vector3::distance(const Vector3 &o)
-{
-	float X = (this->X - o.X);
-	float Y = (this->Y - o.Y);
-	float Z = (this->Z - o.Z);
-	return sqrt(X * X + Y * Y + Z * Z);
-}
-
-float Vector3::dot(const float &x, const float &y, const float &z)
-{
-	return (this->X * x) + (this->Y * y) + (this->Z * z);
-}
-float Vector3::dot(const Vector3 &o)
-{
-	return (this->X * o.X) + (this->Y * o.Y) + (this->Z * o.Z);
-}
-Vector3 Vector3::cross(const float &x, const float &y, const float &z)
-{
-	Vector3* data = new Vector3();
-	data->X = (this->Y * z) - (this->Z * y);
-	data->Y = (this->Z * x) - (this->X * z);
-	data->Z = (this->X * y) - (this->Y * x);
-	return *data;
-}
-Vector3 Vector3::cross(const Vector3 &o)
-{
-	Vector3* data = new Vector3();
-	data->X = (this->Y * o.Z) - (this->Z * o.Y);
-	data->Y = (this->Z * o.X) - (this->X * o.Z);
-	data->Z = (this->X * o.Y) - (this->Y * o.X);
-	return *data;
-}
-void Vector3::normalize()
-{
-	this->div(this->length());
-}
-
-void Vector3::rotate(float &pitch, float &yaw, float &roll)
-{
-	float** matrix = new float*[3];
-	matrix[0] = new float[3];					matrix[1] = new float[3];					matrix[2] = new float[3];
-	matrix[0][0] = cos(yaw) * cos(roll);		matrix[0][1] = -sin(roll);					matrix[0][2] = sin(yaw);
-	matrix[1][0] = sin(roll);					matrix[1][1] = cos(pitch) * cos(roll);		matrix[1][2] = -sin(pitch);
-	matrix[2][0] = -sin(yaw);					matrix[2][1] = sin(pitch);					matrix[2][2] = cos(pitch) * cos(yaw);
-
-	float X = (this->X * matrix[0][0]) + (this->Y * matrix[0][1]) + (this->Z * matrix[0][2]);
-	float Y = (this->X * matrix[1][0]) + (this->Y * matrix[1][1]) + (this->Z * matrix[1][2]);
-	float Z = (this->X * matrix[2][0]) + (this->Y * matrix[2][1]) + (this->Z * matrix[2][2]);
-	this->X = X; this->Y = Y; this->Z = Z;
-}
-void Vector3::rotateAround(const float &x, const float &y, const float &z, float &pitch, float &yaw, float &roll)
-{
-	this->sub(x, y, z);
-	this->rotate(pitch, yaw, roll);
-	this->add(x, y, z);
-}
-void Vector3::rotateAround(Vector3 &o, float &pitch, float &yaw, float &roll)
-{
-	this->sub(o);
-	this->rotate(pitch, yaw, roll);
-	this->add(o);
-}
-float Vector3::deltaPitch() {
-	return (float)(atan(this->X / -this->Y) * (180.0 / M_PI));
-}
-float Vector3::deltaPitch(const float &x, const float &y, const float &z)
-{
-	return (float)(atan((this->X - x) / (-(this->Y - y))) * (180.0 / M_PI));
-}
-float Vector3::deltaPitch(Vector3 &o)
-{
-	return (float)(atan((this->X - o.X) / (-(this->Y - o.Y))) * (180.0 / M_PI));
-}
-float Vector3::deltaYaw() {
-	return (float)(atan(sqrt((this->X * this->X) + (this->Y * this->Y)) / this->Z) * (180.0 / M_PI));
-}
-float Vector3::deltaYaw(const float &x, const float &y, const float &z)
-{
-	float X = (this->X - x);
-	float Y = (this->Y - y);
-	return (float)(atan(sqrt((X * X) + (Y * Y)) / (this->Z - z)) * (180.0 / M_PI));
-}
-float Vector3::deltaYaw(Vector3 &o)
-{
-	float X = (this->X - o.X);
-	float Y = (this->Y - o.Y);
-	return (float)(atan(sqrt((X * X) + (Y * Y)) / (this->Z - o.Z)) * (180.0 / M_PI));
-}
-
-char* Vector3::serialize()
-{
-	char* data = new char[13];
-
-	memcpy(data, this->Xc, 4);
-	memcpy(data + 4, this->Yc, 4);
-	memcpy(data + 8, this->Zc, 4);
-	data[12] = 0;
-
-	return data;
-}
-void Vector3::deserialize(char* o)
-{
-	memcpy(o, this->Xc, 4);
-	memcpy(o + 4, this->Yc, 4);
-	memcpy(o + 8, this->Zc, 4);
-}
-
-DLL_METHOD void Vector3_Set(Vector3* a, float o) {
-	a->set(o);
-}
-DLL_METHOD void Vector3_SetP(Vector3* a, float x, float y, float z) {
-	a->set(x, y, z);
-}
-DLL_METHOD void Vector3_SetV(Vector3* a, Vector3* b) {
-	a->set(*b);
-}
-#pragma comment(linker, "/EXPORT:Vector3_Set=_Vector3_Set@8")
-#pragma comment(linker, "/EXPORT:Vector3_SetP=_Vector3_SetP@16")
-#pragma comment(linker, "/EXPORT:Vector3_SetV=_Vector3_SetV@8")
-
-DLL_METHOD void Vector3_Add(Vector3* a, float o) {
-	a->add(o);
-}
-DLL_METHOD void Vector3_AddP(Vector3* a, float x, float y, float z) {
-	a->add(x, y, z);
-}
-DLL_METHOD void Vector3_AddV(Vector3* a, Vector3* b) {
-	a->add(*b);
-}
-#pragma comment(linker, "/EXPORT:Vector3_Add=_Vector3_Add@8")
-#pragma comment(linker, "/EXPORT:Vector3_AddP=_Vector3_AddP@16")
-#pragma comment(linker, "/EXPORT:Vector3_AddV=_Vector3_AddV@8")
-
-DLL_METHOD void Vector3_Sub(Vector3* a, float o) {
-	a->sub(o);
-}
-DLL_METHOD void Vector3_SubP(Vector3* a, float x, float y, float z) {
-	a->sub(x, y, z);
-}
-DLL_METHOD void Vector3_SubV(Vector3* a, Vector3* b) {
-	a->sub(*b);
-}
-#pragma comment(linker, "/EXPORT:Vector3_Sub=_Vector3_Sub@8")
-#pragma comment(linker, "/EXPORT:Vector3_SubP=_Vector3_SubP@16")
-#pragma comment(linker, "/EXPORT:Vector3_SubV=_Vector3_SubV@8")
-
-DLL_METHOD void Vector3_Mul(Vector3* a, float o) {
-	a->mul(o);
-}
-DLL_METHOD void Vector3_MulP(Vector3* a, float x, float y, float z) {
-	a->mul(x, y, z);
-}
-DLL_METHOD void Vector3_MulV(Vector3* a, Vector3* b) {
-	a->mul(*b);
-}
-#pragma comment(linker, "/EXPORT:Vector3_Mul=_Vector3_Mul@8")
-#pragma comment(linker, "/EXPORT:Vector3_MulP=_Vector3_MulP@16")
-#pragma comment(linker, "/EXPORT:Vector3_MulV=_Vector3_MulV@8")
-
-DLL_METHOD void Vector3_Div(Vector3* a, float o) {
-	a->div(o);
-}
-DLL_METHOD void Vector3_DivP(Vector3* a, float x, float y, float z) {
-	a->div(x, y, z);
-}
-DLL_METHOD void Vector3_DivV(Vector3* a, Vector3* b) {
-	a->div(*b);
-}
-#pragma comment(linker, "/EXPORT:Vector3_Div=_Vector3_Div@8")
-#pragma comment(linker, "/EXPORT:Vector3_DivP=_Vector3_DivP@16")
-#pragma comment(linker, "/EXPORT:Vector3_DivV=_Vector3_DivV@8")
-
-DLL_METHOD float Vector3_Length(Vector3* a) {
-	return (float)a->length();
-}
-DLL_METHOD float Vector3_DistanceP(Vector3* a, float x, float y, float z) {
-	return (float)a->distance(x, y, z);
-}
-DLL_METHOD float Vector3_DistanceV(Vector3* a, Vector3* b) {
-	return (float)a->distance(*b);
-}
-#pragma comment(linker, "/EXPORT:Vector3_Length=_Vector3_Length@4")
-#pragma comment(linker, "/EXPORT:Vector3_DistanceP=_Vector3_DistanceP@16")
-#pragma comment(linker, "/EXPORT:Vector3_DistanceV=_Vector3_DistanceV@8")
-
-DLL_METHOD float Vector3_DotP(Vector3* a, float x, float y, float z) {
-	return (float)a->dot(x, y, z);
-}
-DLL_METHOD float Vector3_DotV(Vector3* a, Vector3* b) {
-	return (float)a->dot(*b);
-}
-DLL_METHOD void Vector3_CrossP(Vector3* a, float x, float y, float z, Vector3* out) {
-	Vector3 temp = a->cross(x, y, z);
-	*out = temp;
-}
-DLL_METHOD void Vector3_CrossV(Vector3* a, Vector3* b, Vector3* out) {
-	Vector3 temp = a->cross(*b);
-	*out = temp;
-}
-DLL_METHOD void Vector3_Normalize(Vector3* a) {
-	a->normalize();
-}
-#pragma comment(linker, "/EXPORT:Vector3_DotP=_Vector3_DotP@16")
-#pragma comment(linker, "/EXPORT:Vector3_DotV=_Vector3_DotV@8")
-#pragma comment(linker, "/EXPORT:Vector3_CrossP=_Vector3_CrossP@20")
-#pragma comment(linker, "/EXPORT:Vector3_CrossV=_Vector3_CrossV@12")
-#pragma comment(linker, "/EXPORT:Vector3_Normalize=_Vector3_Normalize@4")
-
-DLL_METHOD void Vector3_Rotate(Vector3* a, float pitch, float yaw, float roll) {
-	a->rotate(pitch, yaw, roll);
-}
-DLL_METHOD void Vector3_RotateAroundP(Vector3* a, float x, float y, float z, float pitch, float yaw, float roll) {
-	a->rotateAround(x, y, z, pitch, yaw, roll);
-}
-DLL_METHOD void Vector3_RotateAroundV(Vector3* a, Vector3* b, float pitch, float yaw, float roll) {
-	a->rotateAround(*b, pitch, yaw, roll);
-}
-#pragma comment(linker, "/EXPORT:Vector3_Rotate=_Vector3_Rotate@16")
-#pragma comment(linker, "/EXPORT:Vector3_RotateAroundP=_Vector3_RotateAroundP@28")
-#pragma comment(linker, "/EXPORT:Vector3_RotateAroundV=_Vector3_RotateAroundV@20")
-
-DLL_METHOD float Vector3_DeltaPitchP(Vector3* a, float x, float y, float z) {
-	return (float)a->deltaPitch(x, y, z);
-}
-DLL_METHOD float Vector3_DeltaPitchV(Vector3* a, Vector3* b) {
-	return (float)a->deltaPitch(*b);
-}
-DLL_METHOD float Vector3_DeltaYawP(Vector3* a, float x, float y, float z) {
-	return (float)a->deltaYaw(x, y, z);
-}
-DLL_METHOD float Vector3_DeltaYawV(Vector3* a, Vector3* b) {
-	return (float)a->deltaYaw(*b);
-}
-#pragma comment(linker, "/EXPORT:Vector3_DeltaPitchP=_Vector3_DeltaPitchP@16")
-#pragma comment(linker, "/EXPORT:Vector3_DeltaPitchV=_Vector3_DeltaPitchV@8")
-#pragma comment(linker, "/EXPORT:Vector3_DeltaYawP=_Vector3_DeltaYawP@16")
-#pragma comment(linker, "/EXPORT:Vector3_DeltaYawV=_Vector3_DeltaYawV@8")
-
-DLL_METHOD char* Vector3_Serialize(Vector3* a) {
-	return a->serialize();
-}
-DLL_METHOD void Vector3_Deserialize(Vector3* a, char* s) {
-	a->deserialize(s);
-}
-#pragma comment(linker, "/EXPORT:Vector3_Serialize=_Vector3_Serialize@4")
-#pragma comment(linker, "/EXPORT:Vector3_Deserialize=_Vector3_Deserialize@8")
+//	BlitzUtility - Expanding the normal Blitz functionality.
+//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+/*
+#include "Vector3.h"
+
+void Vector3::set(const float &o)
+{
+	this->X = o;
+	this->Y = o;
+	this->Z = o;
+}
+void Vector3::set(const float &x, const float &y, const float &z)
+{
+	this->X = x;
+	this->Y = y;
+	this->Z = z;
+}
+void Vector3::set(const Vector3 &o)
+{
+	if (this != &o) {
+		this->X = o.X;
+		this->Y = o.Y;
+		this->Z = o.Z;
+	}
+}
+
+void Vector3::add(const float &o)
+{
+	this->X += o;
+	this->Y += o;
+	this->Z += o;
+}
+void Vector3::add(const float &x, const float &y, const float &z)
+{
+	this->X += x;
+	this->Y += y;
+	this->Z += z;
+}
+void Vector3::add(const Vector3 &o)
+{
+	this->X += o.X;
+	this->Y += o.Y;
+	this->Z += o.Z;
+}
+
+void Vector3::sub(const float &o)
+{
+	this->X -= o;
+	this->Y -= o;
+	this->Z -= o;
+}
+void Vector3::sub(const float &x, const float &y, const float &z)
+{
+	this->X -= x;
+	this->Y -= y;
+	this->Z -= z;
+}
+void Vector3::sub(const Vector3 &o)
+{
+	this->X -= o.X;
+	this->Y -= o.Y;
+	this->Z -= o.Z;
+}
+
+void Vector3::mul(const float &o)
+{
+	this->X *= o;
+	this->Y *= o;
+	this->Z *= o;
+}
+void Vector3::mul(const float &x, const float &y, const float &z)
+{
+	this->X *= x;
+	this->Y *= y;
+	this->Z *= z;
+}
+void Vector3::mul(const Vector3 &o)
+{
+	this->X *= o.X;
+	this->Y *= o.Y;
+	this->Z *= o.Z;
+}
+
+void Vector3::div(const float &o)
+{
+	this->X /= o;
+	this->Y /= o;
+	this->Z /= o;
+}
+void Vector3::div(const float &x, const float &y, const float &z)
+{
+	this->X /= x;
+	this->Y /= y;
+	this->Z /= z;
+}
+void Vector3::div(const Vector3 &o)
+{
+	this->X /= o.X;
+	this->Y /= o.Y;
+	this->Z /= o.Z;
+}
+
+float Vector3::length()
+{
+	return sqrt(this->X * this->X + this->Y * this->Y + this->Z * this->Z);
+}
+float Vector3::distance(const float &x, const float &y, const float &z)
+{
+	float X = (this->X - x);
+	float Y = (this->Y - y);
+	float Z = (this->Z - z);
+	return sqrt(X * X + Y * Y + Z * Z);
+}
+float Vector3::distance(const Vector3 &o)
+{
+	float X = (this->X - o.X);
+	float Y = (this->Y - o.Y);
+	float Z = (this->Z - o.Z);
+	return sqrt(X * X + Y * Y + Z * Z);
+}
+
+float Vector3::dot(const float &x, const float &y, const float &z)
+{
+	return (this->X * x) + (this->Y * y) + (this->Z * z);
+}
+float Vector3::dot(const Vector3 &o)
+{
+	return (this->X * o.X) + (this->Y * o.Y) + (this->Z * o.Z);
+}
+Vector3 Vector3::cross(const float &x, const float &y, const float &z)
+{
+	Vector3* data = new Vector3();
+	data->X = (this->Y * z) - (this->Z * y);
+	data->Y = (this->Z * x) - (this->X * z);
+	data->Z = (this->X * y) - (this->Y * x);
+	return *data;
+}
+Vector3 Vector3::cross(const Vector3 &o)
+{
+	Vector3* data = new Vector3();
+	data->X = (this->Y * o.Z) - (this->Z * o.Y);
+	data->Y = (this->Z * o.X) - (this->X * o.Z);
+	data->Z = (this->X * o.Y) - (this->Y * o.X);
+	return *data;
+}
+void Vector3::normalize()
+{
+	this->div(this->length());
+}
+
+void Vector3::rotate(float &pitch, float &yaw, float &roll)
+{
+	float** matrix = new float*[3];
+	matrix[0] = new float[3];					matrix[1] = new float[3];					matrix[2] = new float[3];
+	matrix[0][0] = cos(yaw) * cos(roll);		matrix[0][1] = -sin(roll);					matrix[0][2] = sin(yaw);
+	matrix[1][0] = sin(roll);					matrix[1][1] = cos(pitch) * cos(roll);		matrix[1][2] = -sin(pitch);
+	matrix[2][0] = -sin(yaw);					matrix[2][1] = sin(pitch);					matrix[2][2] = cos(pitch) * cos(yaw);
+
+	float X = (this->X * matrix[0][0]) + (this->Y * matrix[0][1]) + (this->Z * matrix[0][2]);
+	float Y = (this->X * matrix[1][0]) + (this->Y * matrix[1][1]) + (this->Z * matrix[1][2]);
+	float Z = (this->X * matrix[2][0]) + (this->Y * matrix[2][1]) + (this->Z * matrix[2][2]);
+	this->X = X; this->Y = Y; this->Z = Z;
+}
+void Vector3::rotateAround(const float &x, const float &y, const float &z, float &pitch, float &yaw, float &roll)
+{
+	this->sub(x, y, z);
+	this->rotate(pitch, yaw, roll);
+	this->add(x, y, z);
+}
+void Vector3::rotateAround(Vector3 &o, float &pitch, float &yaw, float &roll)
+{
+	this->sub(o);
+	this->rotate(pitch, yaw, roll);
+	this->add(o);
+}
+float Vector3::deltaPitch() {
+	return (float)(atan(this->X / -this->Y) * (180.0 / M_PI));
+}
+float Vector3::deltaPitch(const float &x, const float &y, const float &z)
+{
+	return (float)(atan((this->X - x) / (-(this->Y - y))) * (180.0 / M_PI));
+}
+float Vector3::deltaPitch(Vector3 &o)
+{
+	return (float)(atan((this->X - o.X) / (-(this->Y - o.Y))) * (180.0 / M_PI));
+}
+float Vector3::deltaYaw() {
+	return (float)(atan(sqrt((this->X * this->X) + (this->Y * this->Y)) / this->Z) * (180.0 / M_PI));
+}
+float Vector3::deltaYaw(const float &x, const float &y, const float &z)
+{
+	float X = (this->X - x);
+	float Y = (this->Y - y);
+	return (float)(atan(sqrt((X * X) + (Y * Y)) / (this->Z - z)) * (180.0 / M_PI));
+}
+float Vector3::deltaYaw(Vector3 &o)
+{
+	float X = (this->X - o.X);
+	float Y = (this->Y - o.Y);
+	return (float)(atan(sqrt((X * X) + (Y * Y)) / (this->Z - o.Z)) * (180.0 / M_PI));
+}
+
+char* Vector3::serialize()
+{
+	char* data = new char[13];
+
+	memcpy(data, this->Xc, 4);
+	memcpy(data + 4, this->Yc, 4);
+	memcpy(data + 8, this->Zc, 4);
+	data[12] = 0;
+
+	return data;
+}
+void Vector3::deserialize(char* o)
+{
+	memcpy(o, this->Xc, 4);
+	memcpy(o + 4, this->Yc, 4);
+	memcpy(o + 8, this->Zc, 4);
+}
+
+DLL_METHOD void Vector3_Set(Vector3* a, float o) {
+	a->set(o);
+}
+DLL_METHOD void Vector3_SetP(Vector3* a, float x, float y, float z) {
+	a->set(x, y, z);
+}
+DLL_METHOD void Vector3_SetV(Vector3* a, Vector3* b) {
+	a->set(*b);
+}
+#pragma comment(linker, "/EXPORT:Vector3_Set=_Vector3_Set@8")
+#pragma comment(linker, "/EXPORT:Vector3_SetP=_Vector3_SetP@16")
+#pragma comment(linker, "/EXPORT:Vector3_SetV=_Vector3_SetV@8")
+
+DLL_METHOD void Vector3_Add(Vector3* a, float o) {
+	a->add(o);
+}
+DLL_METHOD void Vector3_AddP(Vector3* a, float x, float y, float z) {
+	a->add(x, y, z);
+}
+DLL_METHOD void Vector3_AddV(Vector3* a, Vector3* b) {
+	a->add(*b);
+}
+#pragma comment(linker, "/EXPORT:Vector3_Add=_Vector3_Add@8")
+#pragma comment(linker, "/EXPORT:Vector3_AddP=_Vector3_AddP@16")
+#pragma comment(linker, "/EXPORT:Vector3_AddV=_Vector3_AddV@8")
+
+DLL_METHOD void Vector3_Sub(Vector3* a, float o) {
+	a->sub(o);
+}
+DLL_METHOD void Vector3_SubP(Vector3* a, float x, float y, float z) {
+	a->sub(x, y, z);
+}
+DLL_METHOD void Vector3_SubV(Vector3* a, Vector3* b) {
+	a->sub(*b);
+}
+#pragma comment(linker, "/EXPORT:Vector3_Sub=_Vector3_Sub@8")
+#pragma comment(linker, "/EXPORT:Vector3_SubP=_Vector3_SubP@16")
+#pragma comment(linker, "/EXPORT:Vector3_SubV=_Vector3_SubV@8")
+
+DLL_METHOD void Vector3_Mul(Vector3* a, float o) {
+	a->mul(o);
+}
+DLL_METHOD void Vector3_MulP(Vector3* a, float x, float y, float z) {
+	a->mul(x, y, z);
+}
+DLL_METHOD void Vector3_MulV(Vector3* a, Vector3* b) {
+	a->mul(*b);
+}
+#pragma comment(linker, "/EXPORT:Vector3_Mul=_Vector3_Mul@8")
+#pragma comment(linker, "/EXPORT:Vector3_MulP=_Vector3_MulP@16")
+#pragma comment(linker, "/EXPORT:Vector3_MulV=_Vector3_MulV@8")
+
+DLL_METHOD void Vector3_Div(Vector3* a, float o) {
+	a->div(o);
+}
+DLL_METHOD void Vector3_DivP(Vector3* a, float x, float y, float z) {
+	a->div(x, y, z);
+}
+DLL_METHOD void Vector3_DivV(Vector3* a, Vector3* b) {
+	a->div(*b);
+}
+#pragma comment(linker, "/EXPORT:Vector3_Div=_Vector3_Div@8")
+#pragma comment(linker, "/EXPORT:Vector3_DivP=_Vector3_DivP@16")
+#pragma comment(linker, "/EXPORT:Vector3_DivV=_Vector3_DivV@8")
+
+DLL_METHOD float Vector3_Length(Vector3* a) {
+	return (float)a->length();
+}
+DLL_METHOD float Vector3_DistanceP(Vector3* a, float x, float y, float z) {
+	return (float)a->distance(x, y, z);
+}
+DLL_METHOD float Vector3_DistanceV(Vector3* a, Vector3* b) {
+	return (float)a->distance(*b);
+}
+#pragma comment(linker, "/EXPORT:Vector3_Length=_Vector3_Length@4")
+#pragma comment(linker, "/EXPORT:Vector3_DistanceP=_Vector3_DistanceP@16")
+#pragma comment(linker, "/EXPORT:Vector3_DistanceV=_Vector3_DistanceV@8")
+
+DLL_METHOD float Vector3_DotP(Vector3* a, float x, float y, float z) {
+	return (float)a->dot(x, y, z);
+}
+DLL_METHOD float Vector3_DotV(Vector3* a, Vector3* b) {
+	return (float)a->dot(*b);
+}
+DLL_METHOD void Vector3_CrossP(Vector3* a, float x, float y, float z, Vector3* out) {
+	Vector3 temp = a->cross(x, y, z);
+	*out = temp;
+}
+DLL_METHOD void Vector3_CrossV(Vector3* a, Vector3* b, Vector3* out) {
+	Vector3 temp = a->cross(*b);
+	*out = temp;
+}
+DLL_METHOD void Vector3_Normalize(Vector3* a) {
+	a->normalize();
+}
+#pragma comment(linker, "/EXPORT:Vector3_DotP=_Vector3_DotP@16")
+#pragma comment(linker, "/EXPORT:Vector3_DotV=_Vector3_DotV@8")
+#pragma comment(linker, "/EXPORT:Vector3_CrossP=_Vector3_CrossP@20")
+#pragma comment(linker, "/EXPORT:Vector3_CrossV=_Vector3_CrossV@12")
+#pragma comment(linker, "/EXPORT:Vector3_Normalize=_Vector3_Normalize@4")
+
+DLL_METHOD void Vector3_Rotate(Vector3* a, float pitch, float yaw, float roll) {
+	a->rotate(pitch, yaw, roll);
+}
+DLL_METHOD void Vector3_RotateAroundP(Vector3* a, float x, float y, float z, float pitch, float yaw, float roll) {
+	a->rotateAround(x, y, z, pitch, yaw, roll);
+}
+DLL_METHOD void Vector3_RotateAroundV(Vector3* a, Vector3* b, float pitch, float yaw, float roll) {
+	a->rotateAround(*b, pitch, yaw, roll);
+}
+#pragma comment(linker, "/EXPORT:Vector3_Rotate=_Vector3_Rotate@16")
+#pragma comment(linker, "/EXPORT:Vector3_RotateAroundP=_Vector3_RotateAroundP@28")
+#pragma comment(linker, "/EXPORT:Vector3_RotateAroundV=_Vector3_RotateAroundV@20")
+
+DLL_METHOD float Vector3_DeltaPitchP(Vector3* a, float x, float y, float z) {
+	return (float)a->deltaPitch(x, y, z);
+}
+DLL_METHOD float Vector3_DeltaPitchV(Vector3* a, Vector3* b) {
+	return (float)a->deltaPitch(*b);
+}
+DLL_METHOD float Vector3_DeltaYawP(Vector3* a, float x, float y, float z) {
+	return (float)a->deltaYaw(x, y, z);
+}
+DLL_METHOD float Vector3_DeltaYawV(Vector3* a, Vector3* b) {
+	return (float)a->deltaYaw(*b);
+}
+#pragma comment(linker, "/EXPORT:Vector3_DeltaPitchP=_Vector3_DeltaPitchP@16")
+#pragma comment(linker, "/EXPORT:Vector3_DeltaPitchV=_Vector3_DeltaPitchV@8")
+#pragma comment(linker, "/EXPORT:Vector3_DeltaYawP=_Vector3_DeltaYawP@16")
+#pragma comment(linker, "/EXPORT:Vector3_DeltaYawV=_Vector3_DeltaYawV@8")
+
+DLL_METHOD char* Vector3_Serialize(Vector3* a) {
+	return a->serialize();
+}
+DLL_METHOD void Vector3_Deserialize(Vector3* a, char* s) {
+	a->deserialize(s);
+}
+#pragma comment(linker, "/EXPORT:Vector3_Serialize=_Vector3_Serialize@4")
+#pragma comment(linker, "/EXPORT:Vector3_Deserialize=_Vector3_Deserialize@8")
 */

Type/BVector3.h

@@ -1,82 +1,82 @@
-//	BlitzUtility - Expanding the normal Blitz functionality.
-//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
-//
-//	This program is free software: you can redistribute it and/or modify
-//	it under the terms of the GNU Lesser General Public License as
-//	published by the Free Software Foundation, either version 3 of the 
-//	License, or (at your option) any later version.
-//
-//	This program is distributed in the hope that it will be useful,
-//	but WITHOUT ANY WARRANTY; without even the implied warranty of
-//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//	GNU General Public License for more details.
-//
-//	You should have received a copy of the GNU Lesser General Public License
-//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-/*
-#pragma once
-#include "dllmain.h"
-#ifndef _USE_MATH_DEFINES
-	#define _USE_MATH_DEFINES
-	#include <math.h>
-	#undef _USE_MATH_DEFINES
-#endif
-
-struct Vector3 {
-	union {
-		float X;
-		char Xc[4];
-	};
-	union {
-		float Y;
-		char Yc[4];
-	};
-	union {
-		float Z;
-		char Zc[4];
-	};
-
-	void set(const float &o);
-	void set(const float &x, const float &y, const float &z);
-	void set(const Vector3 &o);
-
-	void add(const float &o);
-	void add(const float &x, const float &y, const float &z);
-	void add(const Vector3 &o);
-
-	void sub(const float &o);
-	void sub(const float &x, const float &y, const float &z);
-	void sub(const Vector3 &o);
-
-	void mul(const float &o);
-	void mul(const float &x, const float &y, const float &z);
-	void mul(const Vector3 &o);
-
-	void div(const float &o);
-	void div(const float &x, const float &y, const float &z);
-	void div(const Vector3 &o);
-
-	float length();
-	float distance(const float &x, const float &y, const float &z);
-	float distance(const Vector3 &o);
-
-	float dot(const float &x, const float &y, const float &z);
-	float dot(const Vector3 &o);
-	Vector3 cross(const float &x, const float &y, const float &z);
-	Vector3 cross(const Vector3 &o);
-	void normalize();
-
-	void rotate(float &pitch, float &yaw, float &roll);
-	void rotateAround(const float &x, const float &y, const float &z, float &pitch, float &yaw, float &roll);
-	void rotateAround(Vector3 &o, float &pitch, float &yaw, float &roll);
-	float deltaPitch();
-	float deltaPitch(const float &x, const float &y, const float &z);
-	float deltaPitch(Vector3 &o);
-	float deltaYaw();
-	float deltaYaw(const float &x, const float &y, const float &z);
-	float deltaYaw(Vector3 &o);
-
-	char* serialize();
-	void deserialize(char* o);
+//	BlitzUtility - Expanding the normal Blitz functionality.
+//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+/*
+#pragma once
+#include "dllmain.h"
+#ifndef _USE_MATH_DEFINES
+	#define _USE_MATH_DEFINES
+	#include <math.h>
+	#undef _USE_MATH_DEFINES
+#endif
+
+struct Vector3 {
+	union {
+		float X;
+		char Xc[4];
+	};
+	union {
+		float Y;
+		char Yc[4];
+	};
+	union {
+		float Z;
+		char Zc[4];
+	};
+
+	void set(const float &o);
+	void set(const float &x, const float &y, const float &z);
+	void set(const Vector3 &o);
+
+	void add(const float &o);
+	void add(const float &x, const float &y, const float &z);
+	void add(const Vector3 &o);
+
+	void sub(const float &o);
+	void sub(const float &x, const float &y, const float &z);
+	void sub(const Vector3 &o);
+
+	void mul(const float &o);
+	void mul(const float &x, const float &y, const float &z);
+	void mul(const Vector3 &o);
+
+	void div(const float &o);
+	void div(const float &x, const float &y, const float &z);
+	void div(const Vector3 &o);
+
+	float length();
+	float distance(const float &x, const float &y, const float &z);
+	float distance(const Vector3 &o);
+
+	float dot(const float &x, const float &y, const float &z);
+	float dot(const Vector3 &o);
+	Vector3 cross(const float &x, const float &y, const float &z);
+	Vector3 cross(const Vector3 &o);
+	void normalize();
+
+	void rotate(float &pitch, float &yaw, float &roll);
+	void rotateAround(const float &x, const float &y, const float &z, float &pitch, float &yaw, float &roll);
+	void rotateAround(Vector3 &o, float &pitch, float &yaw, float &roll);
+	float deltaPitch();
+	float deltaPitch(const float &x, const float &y, const float &z);
+	float deltaPitch(Vector3 &o);
+	float deltaYaw();
+	float deltaYaw(const float &x, const float &y, const float &z);
+	float deltaYaw(Vector3 &o);
+
+	char* serialize();
+	void deserialize(char* o);
 };*/

Type/BlitzType.h

@@ -1,132 +1,132 @@
-#include "Common.h"
-#include <memory>
-#include <sstream>
-
-// Rev-engineered from https://github.com/blitz-research/blitz3d/blob/master/compiler/declnode.cpp
-#define BBVARTYPE_GLOBAL	0
-#define BBVARTYPE_INT		1
-#define BBVARTYPE_FLOAT		2
-#define BBVARTYPE_UNUSED	3
-#define BBVARTYPE_STRING	4
-#define BBVARTYPE_TYPE		5
-#define BBVARTYPE_ARRAY		6
-
-struct BBVar {
-	int Type = -1;
-};
-
-struct BBVarGlobal {
-	int GlobalType = -1;
-	int* Value;
-};
-
-struct BBVarInt : BBVar {
-	int Value;
-};
-
-struct BBVarFloat : BBVar {
-	float Value;
-};
-
-struct BBVarUnused : BBVar {
-	// Not a Dim, as you can see here:
-	// https://github.com/blitz-research/blitz3d/blob/master/compiler/stmtnode.cpp#L86
-};
-
-struct BBVarString : BBVar {
-	int Length;
-	char* Value;
-};
-
-struct BBVarElement;
-struct BBVarType : BBVar {
-	BBVarElement used, free;
-	int fieldCount; // Field Info follows (Exactly <fieldCount> int pointers to variable struct)
-	int* fields[];
-};
-
-struct BBVarElement {
-	int* currentPtr; // Points towards fields.
-	int* nextPtr, prevPtr;
-	BBVarType* BBStructPtr;
-	int refCount;	// Fields usually follow here, may be at another location, see currentPtr.
-	//BBVar* fields[];
-};
-
-struct BBVarArray : BBVar {
-	int Size; //???
-	BBVar* ArrayType;
-};
-
-std::string BBVar_Serialize(void* obj) {
-	std::stringstream myStream;
-
-	BBVar* var = (BBVar*)obj;
-	switch (var->Type) {
-	case BBVARTYPE_GLOBAL:
-		BBVarGlobal* varGlobal = (BBVarGlobal*)obj;
-		myStream << "[Global] " << BBVar_Serialize(varGlobal->Value) << std::endl;
-		break;
-	case BBVARTYPE_INT:
-		BBVarInt* varInt = (BBVarInt*)obj;
-		myStream << "Int" << std::endl;
-		break;
-	case BBVARTYPE_FLOAT:
-		BBVarFloat* varFloat = (BBVarFloat*)obj;
-		myStream << "Float" << std::endl;
-		break;
-	case BBVARTYPE_UNUSED:
-		BBVarUnused* varUnused = (BBVarUnused*)obj;
-		myStream << "Unused" << std::endl;
-		break;
-	case BBVARTYPE_STRING:
-		BBVarString* varString = (BBVarString*)obj;
-		myStream << "String" << std::endl;
-		break;
-	case BBVARTYPE_TYPE:
-		BBVarType* varType = (BBVarType*)obj;
-		myStream << BBVarType_Serialize(varType);
-		break;
-	case BBVARTYPE_ARRAY:
-		BBVarArray* varArray = (BBVarArray*)obj;
-		myStream << "Array = " << std::endl;
-		break;
-	}
-
-	return myStream.str();
-}
-
-std::string BBVarType_Serialize(BBVarType* obj, unsigned int indent = 0) {
-	std::stringstream myStream;
-
-	std::stringstream myPaddingSS;
-	for (unsigned int pad = 0; pad < indent; pad++) {
-		myPaddingSS << "  ";
-	}
-	std::string myPadding = myPaddingSS.str();
-	
-	myStream << myPadding << "Type {" << std::endl;
-	for (unsigned int fld = 0; fld < obj->fieldCount; fld++) {
-		myStream << myPadding << "  (" << fld << ") => " << BBVar_Serialize(obj->fields[fld]) << std::endl;
-	}
-	myStream << myPadding << "}" << std::endl;
-
-	return myStream.str();
-}
-
-DLL_EXPORT(char*) SerializeObject(void* obj) {
-	return strdup(BBVar_Serialize(obj).c_str());
-}
-
-// Laut Mark Sibly:
-struct BBType {
-	int obj_size;
-	BBObj usedList, freeList;
-};
-
-struct BBObj {
-	BBObj *curr;
-	BBObj *next, *prev;
-	int* bbtype;
-	int ref_cnt;
-};
+#include "Common.h"
+#include <memory>
+#include <sstream>
+
+// Rev-engineered from https://github.com/blitz-research/blitz3d/blob/master/compiler/declnode.cpp
+#define BBVARTYPE_GLOBAL	0
+#define BBVARTYPE_INT		1
+#define BBVARTYPE_FLOAT		2
+#define BBVARTYPE_UNUSED	3
+#define BBVARTYPE_STRING	4
+#define BBVARTYPE_TYPE		5
+#define BBVARTYPE_ARRAY		6
+
+struct BBVar {
+	int Type = -1;
+};
+
+struct BBVarGlobal {
+	int GlobalType = -1;
+	int* Value;
+};
+
+struct BBVarInt : BBVar {
+	int Value;
+};
+
+struct BBVarFloat : BBVar {
+	float Value;
+};
+
+struct BBVarUnused : BBVar {
+	// Not a Dim, as you can see here:
+	// https://github.com/blitz-research/blitz3d/blob/master/compiler/stmtnode.cpp#L86
+};
+
+struct BBVarString : BBVar {
+	int Length;
+	char* Value;
+};
+
+struct BBVarElement;
+struct BBVarType : BBVar {
+	BBVarElement used, free;
+	int fieldCount; // Field Info follows (Exactly <fieldCount> int pointers to variable struct)
+	int* fields[];
+};
+
+struct BBVarElement {
+	int* currentPtr; // Points towards fields.
+	int* nextPtr, prevPtr;
+	BBVarType* BBStructPtr;
+	int refCount;	// Fields usually follow here, may be at another location, see currentPtr.
+	//BBVar* fields[];
+};
+
+struct BBVarArray : BBVar {
+	int Size; //???
+	BBVar* ArrayType;
+};
+
+std::string BBVar_Serialize(void* obj) {
+	std::stringstream myStream;
+
+	BBVar* var = (BBVar*)obj;
+	switch (var->Type) {
+	case BBVARTYPE_GLOBAL:
+		BBVarGlobal* varGlobal = (BBVarGlobal*)obj;
+		myStream << "[Global] " << BBVar_Serialize(varGlobal->Value) << std::endl;
+		break;
+	case BBVARTYPE_INT:
+		BBVarInt* varInt = (BBVarInt*)obj;
+		myStream << "Int" << std::endl;
+		break;
+	case BBVARTYPE_FLOAT:
+		BBVarFloat* varFloat = (BBVarFloat*)obj;
+		myStream << "Float" << std::endl;
+		break;
+	case BBVARTYPE_UNUSED:
+		BBVarUnused* varUnused = (BBVarUnused*)obj;
+		myStream << "Unused" << std::endl;
+		break;
+	case BBVARTYPE_STRING:
+		BBVarString* varString = (BBVarString*)obj;
+		myStream << "String" << std::endl;
+		break;
+	case BBVARTYPE_TYPE:
+		BBVarType* varType = (BBVarType*)obj;
+		myStream << BBVarType_Serialize(varType);
+		break;
+	case BBVARTYPE_ARRAY:
+		BBVarArray* varArray = (BBVarArray*)obj;
+		myStream << "Array = " << std::endl;
+		break;
+	}
+
+	return myStream.str();
+}
+
+std::string BBVarType_Serialize(BBVarType* obj, unsigned int indent = 0) {
+	std::stringstream myStream;
+
+	std::stringstream myPaddingSS;
+	for (unsigned int pad = 0; pad < indent; pad++) {
+		myPaddingSS << "  ";
+	}
+	std::string myPadding = myPaddingSS.str();
+	
+	myStream << myPadding << "Type {" << std::endl;
+	for (unsigned int fld = 0; fld < obj->fieldCount; fld++) {
+		myStream << myPadding << "  (" << fld << ") => " << BBVar_Serialize(obj->fields[fld]) << std::endl;
+	}
+	myStream << myPadding << "}" << std::endl;
+
+	return myStream.str();
+}
+
+DLL_EXPORT(char*) SerializeObject(void* obj) {
+	return strdup(BBVar_Serialize(obj).c_str());
+}
+
+// Laut Mark Sibly:
+struct BBType {
+	int obj_size;
+	BBObj usedList, freeList;
+};
+
+struct BBObj {
+	BBObj *curr;
+	BBObj *next, *prev;
+	int* bbtype;
+	int ref_cnt;
+};

Type/Double.cpp

@@ -1,163 +1,122 @@
-//	Blitz - Steam wrapper for Blitz.
-//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
-//
-//	This program is free software: you can redistribute it and/or modify
-//	it under the terms of the GNU Lesser General Public License as
-//	published by the Free Software Foundation, either version 3 of the 
-//	License, or (at your option) any later version.
-//
-//	This program is distributed in the hope that it will be useful,
-//	but WITHOUT ANY WARRANTY; without even the implied warranty of
-//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//	GNU General Public License for more details.
-//
-//	You should have received a copy of the GNU Lesser General Public License
-//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-#include "Double.h"
-#include <list>
-
-std::list<double_t*> BU_DoubleTemporary;
-
-DLL_METHOD double_t* DLL_CALL BU_Double_Create() {
-	return new double_t;
-}
-
-DLL_METHOD void DLL_CALL BU_Double_Destroy(double_t* pthis) {
-	delete pthis;
-}
-
-DLL_METHOD double_t* DLL_CALL BU_Double_Copy(double_t* other) {
-	double_t* pthis = new double_t;
-	*pthis = *other;
-	return pthis;
-}
-
-DLL_METHOD double_t* DLL_CALL BU_Double_TempCreate() {
-	double_t* val = new double_t;
-	BU_DoubleTemporary.push_back(val);
-	return val;
-}
-
-DLL_METHOD double_t* DLL_CALL BU_Double_TempCopy(double_t* other) {
-	double_t* val = new double_t(*other);
-	BU_DoubleTemporary.push_back(val);
-	return val;
-}
-
-DLL_METHOD void DLL_CALL BU_Double_SetTemp(double_t* pthis) {
-	BU_DoubleTemporary.push_back(pthis);
-}
-
-DLL_METHOD void DLL_CALL BU_Double_UnsetTemp(double_t* pthis) {
-	BU_DoubleTemporary.remove(pthis);
-}
-
-DLL_METHOD void DLL_CALL BU_Double_TempCleanup() {
-	auto iterEnd = BU_DoubleTemporary.end();
-	for (auto iter = BU_DoubleTemporary.begin(); iter != iterEnd; ++iter) {
-		delete *iter;
-	}
-	BU_DoubleTemporary.clear();
-}
-
-DLL_METHOD void DLL_CALL BU_Double_Set(double_t* pthis, double_t* other) {
-	*pthis = *other;
-}
-
-DLL_METHOD void DLL_CALL BU_Double_SetF(double_t* pthis, float_t other) {
-	*pthis = other;
-}
-
-DLL_METHOD void DLL_CALL BU_Double_Add(double_t* pthis, double_t* other) {
-	*pthis += *other;
-}
-
-DLL_METHOD void DLL_CALL BU_Double_AddF(double_t* pthis, float_t other) {
-	*pthis += other;
-}
-
-DLL_METHOD void DLL_CALL BU_Double_Sub(double_t* pthis, double_t* other) {
-	*pthis -= *other;
-}
-
-DLL_METHOD void DLL_CALL BU_Double_SubF(double_t* pthis, float_t other) {
-	*pthis -= other;
-}
-
-DLL_METHOD void DLL_CALL BU_Double_Mul(double_t* pthis, double_t* other) {
-	*pthis *= *other;
-}
-
-DLL_METHOD void DLL_CALL BU_Double_MulF(double_t* pthis, float_t other) {
-	*pthis *= other;
-}
-
-DLL_METHOD void DLL_CALL BU_Double_Div(double_t* pthis, double_t* other) {
-	*pthis /= *other;
-}
-
-DLL_METHOD void DLL_CALL BU_Double_DivF(double_t* pthis, float_t other) {
-	*pthis /= other;
-}
-
-DLL_METHOD uint32_t DLL_CALL BU_Double_Compare(double_t* pthis, double_t* other) {
-	return (*pthis == *other ? 1 : 0) + (*pthis < *other ? 2 : 0) + (*pthis > *other ? 4 : 0);
-}
-
-DLL_METHOD uint32_t DLL_CALL BU_Double_CompareF(double_t* pthis, float_t other) {
-	return ((float_t)*pthis == other ? 1 : 0) + ((float_t)*pthis < other ? 2 : 0) + ((float_t)*pthis > other ? 4 : 0);
-}
-
-DLL_METHOD const char* DLL_CALL BU_Double_ToString(double_t* pthis) {
-	std::stringstream stream;
-	stream << *pthis;
-	return stream.str().c_str();
-}
-
-DLL_METHOD double_t* DLL_CALL BU_Double_FromString(const char* text) {
-	std::stringstream stream = std::stringstream(text);
-	double_t* doublePtr = new double_t;
-	stream >> *doublePtr;
-	return doublePtr;
-}
-
-DLL_METHOD float_t DLL_CALL BU_Double_ToFloat(double_t* pthis) {
-	return (float_t)*pthis;
-}
-
-DLL_METHOD double_t* DLL_CALL BU_Double_FromFloat(float_t other) {
-	double_t* val = new double_t;
-	*val = (double_t)other;
-	return val;
-}
-
-DLL_METHOD int64_t* DLL_CALL BU_Double_ToLongLong(double_t* pthis) {
-	int64_t* val = new int64_t;
-	*val = (int64_t)*pthis;
-	return val;
-}
-
-DLL_METHOD double_t* DLL_CALL BU_Double_FromLongLong(int64_t* other) {
-	double_t* val = new double_t;
-	*val = (double_t)*other;
-	return val;
-}
-
-DLL_METHOD const char* DLL_CALL BU_Double_Serialize(double_t* pthis) {
-	union {
-		double_t real;
-		int64_t integer;
-	} myval;
-	myval.real = *pthis;
-	return int_to_hex<int64_t>(myval.integer).c_str();
-}
-
-DLL_METHOD double_t* DLL_CALL BU_Double_Deserialize(const char* text) {
-	union {
-		double_t real;
-		int64_t integer;
-	} myval;
-	myval.integer = hex_to_int<int64_t>(std::string(text));
-	return BU_Double_Copy(&myval.real);
+//	Blitz - Steam wrapper for Blitz.
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "Long.h"
+
+DLL_FUNCTION(double_t*) BU_Double_New() {
+	return new double_t;
+}
+DLL_FUNCTION(double_t*) BU_Double_Copy(double_t* pOther) {
+	return new double_t(*pOther);
+}
+DLL_FUNCTION(void) BU_Double_Destroy(double_t* pThis) {
+	delete pThis;
+}
+
+char* BU_Double_Buffer = new char[32];
+DLL_FUNCTION(const char*) BU_Double_ToString(double_t* pThis) {
+	std::stringstream myStream;
+	myStream << (*pThis);
+
+	const char* myBuffer = myStream.str().c_str();
+	strcpy_s(BU_Double_Buffer, 32, myBuffer);
+	return BU_Double_Buffer;
+}
+DLL_FUNCTION(double_t*) BU_Double_FromString(const char* pString) {
+	double_t* pThis = new double_t;
+	std::stringstream myStream = std::stringstream(pString);
+	myStream >> *pThis;
+	return pThis;
+}
+
+DLL_FUNCTION(double_t*) BU_Double_FromF(float_t fOther) {
+	return new double_t(fOther);
+}
+DLL_FUNCTION(float_t) BU_Double_ToF(double_t* pThis) {
+	return (float_t)*pThis;
+}
+
+DLL_FUNCTION(double_t*) BU_Double_FromI(int32_t iOther) {
+	return new double_t(iOther);
+}
+DLL_FUNCTION(int32_t) BU_Double_ToI(double_t* pThis) {
+	return (int32_t)*pThis;
+}
+
+DLL_FUNCTION(double_t*) BU_Double_FromL(int64_t* pOther) {
+	return new double_t((double_t)*pOther);
+}
+DLL_FUNCTION(int64_t*) BU_Double_ToL(double_t* pThis) {
+	return new int64_t((int64_t)*pThis);
+}
+
+DLL_FUNCTION(int32_t) BU_Double_Compare(double_t* pThis, double_t* pOther) {
+	return /* It can either be Equal (0) or Smaller or Greater. Easy to check. */
+		   /* Greater */
+		(*pThis > *pOther ? 1 : 0) +
+		/* Smaller */
+		(*pThis < *pOther ? -1 : 0);
+}
+
+DLL_FUNCTION(double_t*) BU_Double_Set(double_t* pThis, double_t* pOther) {
+	*pThis = *pOther;
+	return pThis;
+}
+DLL_FUNCTION(double_t*) BU_Double_Add(double_t* pThis, double_t* pOther) {
+	*pThis += *pOther;
+	return pThis;
+}
+DLL_FUNCTION(double_t*) BU_Double_Sub(double_t* pThis, double_t* pOther) {
+	*pThis -= *pOther;
+	return pThis;
+}
+DLL_FUNCTION(double_t*) BU_Double_Div(double_t* pThis, double_t* pOther) {
+	*pThis /= *pOther;
+	return pThis;
+}
+DLL_FUNCTION(double_t*) BU_Double_Mul(double_t* pThis, double_t* pOther) {
+	*pThis *= *pOther;
+	return pThis;
+}
+DLL_FUNCTION(double_t*) BU_Double_Mod(double_t* pThis, double_t* pOther) {
+	*pThis = fmod(*pThis, *pOther);
+	return pThis;
+}
+
+DLL_FUNCTION(double_t*) BU_Double_SetF(double_t* pThis, float_t fOther) {
+	*pThis = fOther;
+	return pThis;
+}
+DLL_FUNCTION(double_t*) BU_Double_AddF(double_t* pThis, float_t fOther) {
+	*pThis += fOther;
+	return pThis;
+}
+DLL_FUNCTION(double_t*) BU_Double_SubF(double_t* pThis, float_t fOther) {
+	*pThis -= fOther;
+	return pThis;
+}
+DLL_FUNCTION(double_t*) BU_Double_DivF(double_t* pThis, float_t fOther) {
+	*pThis /= fOther;
+	return pThis;
+}
+DLL_FUNCTION(double_t*) BU_Double_MulF(double_t* pThis, float_t fOther) {
+	*pThis *= fOther;
+	return pThis;
+}
+DLL_FUNCTION(double_t*) BU_Double_ModF(double_t* pThis, float_t fOther) {
+	*pThis = fmod(*pThis, fOther);
+	return pThis;
 }

Type/Double.h

@@ -1,96 +1,51 @@
-//	Blitz - Steam wrapper for Blitz.
-//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
-//
-//	This program is free software: you can redistribute it and/or modify
-//	it under the terms of the GNU Lesser General Public License as
-//	published by the Free Software Foundation, either version 3 of the 
-//	License, or (at your option) any later version.
-//
-//	This program is distributed in the hope that it will be useful,
-//	but WITHOUT ANY WARRANTY; without even the implied warranty of
-//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//	GNU General Public License for more details.
-//
-//	You should have received a copy of the GNU Lesser General Public License
-//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-#pragma once
-#include "dllmain.h"
-#include "LongLong.h"
-
-#pragma region Constructor & Destructor
-DLL_METHOD double_t* DLL_CALL BU_Double_Create();
-DLL_METHOD void DLL_CALL BU_Double_Destroy(double_t* pthis);
-DLL_METHOD double_t* DLL_CALL BU_Double_Copy(double_t* other);
-#pragma comment(linker, "/EXPORT:BU_Double_Create=_BU_Double_Create@0")
-#pragma comment(linker, "/EXPORT:BU_Double_Destroy=_BU_Double_Destroy@4")
-#pragma comment(linker, "/EXPORT:BU_Double_Copy=_BU_Double_Copy@4")
-#pragma endregion Constructor & Destructor
-
-#pragma region Temporary Objects
-DLL_METHOD double_t* DLL_CALL BU_Double_TempCreate();
-DLL_METHOD double_t* DLL_CALL BU_Double_TempCopy(double_t* other);
-DLL_METHOD void DLL_CALL BU_Double_SetTemp(double_t* pthis);
-DLL_METHOD void DLL_CALL BU_Double_UnsetTemp(double_t* pthis);
-DLL_METHOD void DLL_CALL BU_Double_TempCleanup();
-#pragma comment(linker, "/EXPORT:BU_Double_TempCreate=_BU_Double_TempCreate@0")
-#pragma comment(linker, "/EXPORT:BU_Double_TempCopy=_BU_Double_TempCopy@4")
-#pragma comment(linker, "/EXPORT:BU_Double_SetTemp=_BU_Double_SetTemp@4")
-#pragma comment(linker, "/EXPORT:BU_Double_UnsetTemp=_BU_Double_UnsetTemp@4")
-#pragma comment(linker, "/EXPORT:BU_Double_TempCleanup=_BU_Double_TempCleanup@0")
-#pragma endregion Temporary Objects
-
-#pragma region Math
-DLL_METHOD void DLL_CALL BU_Double_Set(double_t* pthis, double_t* other);
-DLL_METHOD void DLL_CALL BU_Double_SetF(double_t* pthis, float_t other);
-#pragma comment(linker, "/EXPORT:BU_Double_Set=_BU_Double_Set@8")
-#pragma comment(linker, "/EXPORT:BU_Double_SetF=_BU_Double_SetF@8")
-DLL_METHOD void DLL_CALL BU_Double_Add(double_t* pthis, double_t* other);
-DLL_METHOD void DLL_CALL BU_Double_AddF(double_t* pthis, float_t other);
-#pragma comment(linker, "/EXPORT:BU_Double_Add=_BU_Double_Add@8")
-#pragma comment(linker, "/EXPORT:BU_Double_AddF=_BU_Double_AddF@8")
-DLL_METHOD void DLL_CALL BU_Double_Sub(double_t* pthis, double_t* other);
-DLL_METHOD void DLL_CALL BU_Double_SubF(double_t* pthis, float_t other);
-#pragma comment(linker, "/EXPORT:BU_Double_Sub=_BU_Double_Sub@8")
-#pragma comment(linker, "/EXPORT:BU_Double_SubF=_BU_Double_SubF@8")
-DLL_METHOD void DLL_CALL BU_Double_Mul(double_t* pthis, double_t* other);
-DLL_METHOD void DLL_CALL BU_Double_MulF(double_t* pthis, float_t other);
-#pragma comment(linker, "/EXPORT:BU_Double_Mul=_BU_Double_Mul@8")
-#pragma comment(linker, "/EXPORT:BU_Double_MulF=_BU_Double_MulF@8")
-DLL_METHOD void DLL_CALL BU_Double_Div(double_t* pthis, double_t* other);
-DLL_METHOD void DLL_CALL BU_Double_DivF(double_t* pthis, float_t other);
-#pragma comment(linker, "/EXPORT:BU_Double_Div=_BU_Double_Div@8")
-#pragma comment(linker, "/EXPORT:BU_Double_DivF=_BU_Double_DivF@8")
-#pragma endregion Math
-
-#pragma region Comparision
-DLL_METHOD uint32_t DLL_CALL BU_Double_Compare(double_t* pthis, double_t* other);
-DLL_METHOD uint32_t DLL_CALL BU_Double_CompareF(double_t* pthis, float_t other);
-#pragma comment(linker, "/EXPORT:BU_Double_Compare=_BU_Double_Compare@8")
-#pragma comment(linker, "/EXPORT:BU_Double_CompareF=_BU_Double_CompareF@8")
-#pragma endregion Comparision
-
-#pragma region Conversion
-// String conversion
-DLL_METHOD const char* DLL_CALL BU_Double_ToString(double_t* pthis);
-DLL_METHOD double_t* DLL_CALL BU_Double_FromString(const char* text);
-#pragma comment(linker, "/EXPORT:BU_Double_ToString=_BU_Double_ToString@4")
-#pragma comment(linker, "/EXPORT:BU_Double_FromString=_BU_Double_FromString@4")
-// 32-Bit Floating Point
-DLL_METHOD float_t DLL_CALL BU_Double_ToFloat(double_t* pthis);
-DLL_METHOD double_t* DLL_CALL BU_Double_FromFloat(float_t other);
-#pragma comment(linker, "/EXPORT:BU_Double_ToFloat=_BU_Double_ToFloat@4")
-#pragma comment(linker, "/EXPORT:BU_Double_FromFloat=_BU_Double_FromFloat@4")
-// 64-Bit Integer
-DLL_METHOD int64_t* DLL_CALL BU_Double_ToLongLong(double_t* pthis);
-DLL_METHOD double_t* DLL_CALL BU_Double_FromLongLong(int64_t* other);
-#pragma comment(linker, "/EXPORT:BU_Double_ToLongLong=_BU_Double_ToLongLong@4")
-#pragma comment(linker, "/EXPORT:BU_Double_FromLongLong=_BU_Double_FromLongLong@4")
-#pragma endregion Conversion
-
-#pragma region Serialization
-DLL_METHOD const char* DLL_CALL BU_Double_Serialize(double_t* pthis);
-DLL_METHOD double_t* DLL_CALL BU_Double_Deserialize(const char* text);
-#pragma comment(linker, "/EXPORT:BU_Double_Serialize=_BU_Double_Serialize@4")
-#pragma comment(linker, "/EXPORT:BU_Double_Deserialize=_BU_Double_Deserialize@4")
-#pragma endregion Serialization
+//	Blitz - Steam wrapper for Blitz.
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#pragma once
+#include "BlitzUtility.h"
+#include <sstream>
+
+DLL_FUNCTION(double_t*) BU_Double_New();
+DLL_FUNCTION(double_t*) BU_Double_Copy(double_t* pRight);
+DLL_FUNCTION(void) BU_Double_Destroy(double_t* pThis);
+
+DLL_FUNCTION(const char*) BU_Double_ToString(double_t* pThis);
+DLL_FUNCTION(double_t*) BU_Double_FromString(const char* pString);
+
+DLL_FUNCTION(double_t*) BU_Double_FromF(float_t fOther);
+DLL_FUNCTION(float_t) BU_Double_ToF(double_t* pThis);
+
+DLL_FUNCTION(double_t*) BU_Double_FromI(int32_t iOther);
+DLL_FUNCTION(int32_t) BU_Double_ToI(double_t* pThis);
+
+DLL_FUNCTION(double_t*) BU_Double_FromL(int64_t* pOther);
+DLL_FUNCTION(int64_t*) BU_Double_ToL(double_t* pThis);
+
+DLL_FUNCTION(int32_t) BU_Double_Compare(double_t* pThis, double_t* pOther);
+
+DLL_FUNCTION(double_t*) BU_Double_Set(double_t* pThis, double_t* pOther);
+DLL_FUNCTION(double_t*) BU_Double_Add(double_t* pThis, double_t* pOther);
+DLL_FUNCTION(double_t*) BU_Double_Sub(double_t* pThis, double_t* pOther);
+DLL_FUNCTION(double_t*) BU_Double_Div(double_t* pThis, double_t* pOther);
+DLL_FUNCTION(double_t*) BU_Double_Mul(double_t* pThis, double_t* pOther);
+DLL_FUNCTION(double_t*) BU_Double_Mod(double_t* pThis, double_t* pOther);
+
+DLL_FUNCTION(double_t*) BU_Double_SetF(double_t* pThis, float_t fOther);
+DLL_FUNCTION(double_t*) BU_Double_AddF(double_t* pThis, float_t fOther);
+DLL_FUNCTION(double_t*) BU_Double_SubF(double_t* pThis, float_t fOther);
+DLL_FUNCTION(double_t*) BU_Double_DivF(double_t* pThis, float_t fOther);
+DLL_FUNCTION(double_t*) BU_Double_MulF(double_t* pThis, float_t fOther);
+DLL_FUNCTION(double_t*) BU_Double_ModF(double_t* pThis, float_t fOther);

Type/FVector2.cpp

@@ -1,220 +1,220 @@
-//	BlitzUtility - Expanding the normal Blitz functionality.
-//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
-//
-//	This program is free software: you can redistribute it and/or modify
-//	it under the terms of the GNU Lesser General Public License as
-//	published by the Free Software Foundation, either version 3 of the 
-//	License, or (at your option) any later version.
-//
-//	This program is distributed in the hope that it will be useful,
-//	but WITHOUT ANY WARRANTY; without even the implied warranty of
-//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//	GNU General Public License for more details.
-//
-//	You should have received a copy of the GNU Lesser General Public License
-//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-/*
-#pragma once
-#include "FVector2.h"
-
-double FVector2::length()
-{
-	return std::sqrtf(std::abs((this->X*this->X) + (this->Y*this->Y)));
-}
-
-void FVector2::normalize() {
-	double len = this->length();
-	double divisor = 1.0 / (len != 0 ? len : FLT_EPSILON);
-}
-
-double FVector2::distance(const FVector2 r)
-{
-	float X = (this->X - r.X), Y = (this->Y - r.Y);
-	return std::sqrtf(std::abs(X*X + Y*Y));
-}
-
-const char* FVector2::serialize() {
-
-}
-
-FVector2& FVector2::deserialize(const char* serialized) {
-
-}
-
-FVector2::FVector2(float V) {
-
-}
-
-FVector2::FVector2(float X, float Y) {
-
-}
-
-FVector2::FVector2(FVector2& V) {
-
-}
-
-FVector2& FVector2::operator++() {
-
-}
-
-FVector2& FVector2::operator--() {
-
-}
-
-bool FVector2::operator>(const FVector2& r) {
-
-}
-
-bool FVector2::operator>(const float& r) {
-
-}
-
-
-bool FVector2::operator<(const FVector2& r) {
-
-}
-
-bool FVector2::operator<(const float& r) {
-
-}
-
-
-bool FVector2::operator==(const FVector2& r) {
-
-}
-
-bool FVector2::operator==(const float& r) {
-
-}
-
-
-bool FVector2::operator>=(const FVector2& r) {
-
-}
-
-bool FVector2::operator>=(const float& r) {
-
-}
-
-
-bool FVector2::operator<=(const FVector2& r) {
-
-}
-
-bool FVector2::operator<=(const float& r) {
-
-}
-
-
-bool FVector2::operator!=(const FVector2& r) {
-
-}
-
-bool FVector2::operator!=(const float& r) {
-
-}
-
-
-FVector2& FVector2::operator=(const FVector2& r) {
-
-}
-
-FVector2& FVector2::operator=(const float& r) {
-
-}
-
-
-FVector2& FVector2::operator+(const FVector2& r) {
-
-}
-
-FVector2& FVector2::operator+(const float& r) {
-
-}
-
-
-FVector2& FVector2::operator-(const FVector2& r) {
-
-}
-
-FVector2& FVector2::operator*(const FVector2& r) {
-
-}
-
-FVector2& FVector2::operator*(const float& r) {
-
-}
-
-
-FVector2& FVector2::operator/(const FVector2& r) {
-
-}
-
-FVector2& FVector2::operator/(const float& r) {
-
-}
-
-
-FVector2& FVector2::operator+=(const FVector2& r) {
-
-}
-
-FVector2& FVector2::operator+=(const float& r) {
-
-}
-
-
-FVector2& FVector2::operator-=(const FVector2& r) {
-
-}
-
-FVector2& FVector2::operator*=(const FVector2& r) {
-
-}
-
-FVector2& FVector2::operator*=(const float& r) {
-
-}
-
-
-FVector2& FVector2::operator/=(const FVector2& r) {
-
-}
-
-FVector2& FVector2::operator/=(const float& r) {
-
-}
-
-
-FVector2& FVector2::operator-(const float& r) {
-
-}
-
-FVector2& FVector2::operator-=(const float& r) {
-
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+//	BlitzUtility - Expanding the normal Blitz functionality.
+//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+/*
+#pragma once
+#include "FVector2.h"
+
+double FVector2::length()
+{
+	return std::sqrtf(std::abs((this->X*this->X) + (this->Y*this->Y)));
+}
+
+void FVector2::normalize() {
+	double len = this->length();
+	double divisor = 1.0 / (len != 0 ? len : FLT_EPSILON);
+}
+
+double FVector2::distance(const FVector2 r)
+{
+	float X = (this->X - r.X), Y = (this->Y - r.Y);
+	return std::sqrtf(std::abs(X*X + Y*Y));
+}
+
+const char* FVector2::serialize() {
+
+}
+
+FVector2& FVector2::deserialize(const char* serialized) {
+
+}
+
+FVector2::FVector2(float V) {
+
+}
+
+FVector2::FVector2(float X, float Y) {
+
+}
+
+FVector2::FVector2(FVector2& V) {
+
+}
+
+FVector2& FVector2::operator++() {
+
+}
+
+FVector2& FVector2::operator--() {
+
+}
+
+bool FVector2::operator>(const FVector2& r) {
+
+}
+
+bool FVector2::operator>(const float& r) {
+
+}
+
+
+bool FVector2::operator<(const FVector2& r) {
+
+}
+
+bool FVector2::operator<(const float& r) {
+
+}
+
+
+bool FVector2::operator==(const FVector2& r) {
+
+}
+
+bool FVector2::operator==(const float& r) {
+
+}
+
+
+bool FVector2::operator>=(const FVector2& r) {
+
+}
+
+bool FVector2::operator>=(const float& r) {
+
+}
+
+
+bool FVector2::operator<=(const FVector2& r) {
+
+}
+
+bool FVector2::operator<=(const float& r) {
+
+}
+
+
+bool FVector2::operator!=(const FVector2& r) {
+
+}
+
+bool FVector2::operator!=(const float& r) {
+
+}
+
+
+FVector2& FVector2::operator=(const FVector2& r) {
+
+}
+
+FVector2& FVector2::operator=(const float& r) {
+
+}
+
+
+FVector2& FVector2::operator+(const FVector2& r) {
+
+}
+
+FVector2& FVector2::operator+(const float& r) {
+
+}
+
+
+FVector2& FVector2::operator-(const FVector2& r) {
+
+}
+
+FVector2& FVector2::operator*(const FVector2& r) {
+
+}
+
+FVector2& FVector2::operator*(const float& r) {
+
+}
+
+
+FVector2& FVector2::operator/(const FVector2& r) {
+
+}
+
+FVector2& FVector2::operator/(const float& r) {
+
+}
+
+
+FVector2& FVector2::operator+=(const FVector2& r) {
+
+}
+
+FVector2& FVector2::operator+=(const float& r) {
+
+}
+
+
+FVector2& FVector2::operator-=(const FVector2& r) {
+
+}
+
+FVector2& FVector2::operator*=(const FVector2& r) {
+
+}
+
+FVector2& FVector2::operator*=(const float& r) {
+
+}
+
+
+FVector2& FVector2::operator/=(const FVector2& r) {
+
+}
+
+FVector2& FVector2::operator/=(const float& r) {
+
+}
+
+
+FVector2& FVector2::operator-(const float& r) {
+
+}
+
+FVector2& FVector2::operator-=(const float& r) {
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 */

Type/FVector2.h

@@ -1,98 +1,98 @@
-//	BlitzUtility - Expanding the normal Blitz functionality.
-//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
-//
-//	This program is free software: you can redistribute it and/or modify
-//	it under the terms of the GNU Lesser General Public License as
-//	published by the Free Software Foundation, either version 3 of the 
-//	License, or (at your option) any later version.
-//
-//	This program is distributed in the hope that it will be useful,
-//	but WITHOUT ANY WARRANTY; without even the implied warranty of
-//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//	GNU General Public License for more details.
-//
-//	You should have received a copy of the GNU Lesser General Public License
-//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-/*
-#pragma once
-#include "dllmain.h"
-#ifndef _USE_MATH_DEFINES
-	#define _USE_MATH_DEFINES
-	#include <math.h>
-	#undef _USE_MATH_DEFINES
-#endif
-
-struct FVector2 {
-	float X, Y;
-
-	// Constructor & Destructor
-	FVector2(float V);
-	FVector2(float X, float Y);
-	FVector2(FVector2& V);
-
-	// Operator Overloading
-	FVector2& operator++();
-	FVector2& operator--();
-	bool operator>(const FVector2& r);
-	bool operator<(const FVector2& r);
-	bool operator==(const FVector2& r);
-	bool operator>=(const FVector2& r);
-	bool operator<=(const FVector2& r);
-	bool operator!=(const FVector2& r);
-	FVector2& operator=(const FVector2& r);
-	FVector2& operator+(const FVector2& r);
-	FVector2& operator-(const FVector2& r);
-	FVector2& operator*(const FVector2& r);
-	FVector2& operator/(const FVector2& r);
-	FVector2& operator+=(const FVector2& r);
-	FVector2& operator-=(const FVector2& r);
-	FVector2& operator*=(const FVector2& r);
-	FVector2& operator/=(const FVector2& r);
-
-	// Operator Overloading - float
-	bool operator>(const float& r);
-	bool operator<(const float& r);
-	bool operator==(const float& r);
-	bool operator>=(const float& r);
-	bool operator<=(const float& r);
-	bool operator!=(const float& r);
-	FVector2& operator=(const float& r);
-	FVector2& operator+(const float& r);
-	FVector2& operator-(const float& r);
-	FVector2& operator*(const float& r);
-	FVector2& operator/(const float& r);
-	FVector2& operator+=(const float& r);
-	FVector2& operator-=(const float& r);
-	FVector2& operator*=(const float& r);
-	FVector2& operator/=(const float& r);
-
-	// Simple Math
-	double length();
-	void normalize();
-	double distance(const FVector2 r);
-
-	// Advanced Math
-	void rotate(const double )
-
-	// Serialization
-	const char* serialize();
-	static FVector2& deserialize(const char* serialized);
-};
-
-DLL_METHOD FVector2* DLL_CALL BU_FVector2_Create();
-DLL_METHOD FVector2* DLL_CALL BU_FVector2_Copy(FVector2* copyVector);
-DLL_METHOD void DLL_CALL BU_FVector2_Destroy();
-
-DLL_METHOD FVector2* DLL_CALL BU_FVector2_TempCreate();
-DLL_METHOD FVector2* DLL_CALL BU_FVector2_TempCopy(FVector2* copyVector);
-DLL_METHOD void DLL_CALL BU_FVector2_SetTemp(FVector2* vector);
-DLL_METHOD void DLL_CALL BU_FVector2_UnsetTemp(FVector2* vector);
-DLL_METHOD void DLL_CALL BU_FVector2_TempCleanup();
-
-DLL_METHOD float DLL_CALL BU_FVector2_Length(FVector2* vector);
-DLL_METHOD float DLL_CALL BU_FVector2_Normalize();
-DLL_METHOD float DLL_CALL BU_FVector2_Distance(FVector2* vector);
-DLL_METHOD float DLL_CALL BU_FVector2_DistanceL(float X, float Y);
-
+//	BlitzUtility - Expanding the normal Blitz functionality.
+//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+/*
+#pragma once
+#include "dllmain.h"
+#ifndef _USE_MATH_DEFINES
+	#define _USE_MATH_DEFINES
+	#include <math.h>
+	#undef _USE_MATH_DEFINES
+#endif
+
+struct FVector2 {
+	float X, Y;
+
+	// Constructor & Destructor
+	FVector2(float V);
+	FVector2(float X, float Y);
+	FVector2(FVector2& V);
+
+	// Operator Overloading
+	FVector2& operator++();
+	FVector2& operator--();
+	bool operator>(const FVector2& r);
+	bool operator<(const FVector2& r);
+	bool operator==(const FVector2& r);
+	bool operator>=(const FVector2& r);
+	bool operator<=(const FVector2& r);
+	bool operator!=(const FVector2& r);
+	FVector2& operator=(const FVector2& r);
+	FVector2& operator+(const FVector2& r);
+	FVector2& operator-(const FVector2& r);
+	FVector2& operator*(const FVector2& r);
+	FVector2& operator/(const FVector2& r);
+	FVector2& operator+=(const FVector2& r);
+	FVector2& operator-=(const FVector2& r);
+	FVector2& operator*=(const FVector2& r);
+	FVector2& operator/=(const FVector2& r);
+
+	// Operator Overloading - float
+	bool operator>(const float& r);
+	bool operator<(const float& r);
+	bool operator==(const float& r);
+	bool operator>=(const float& r);
+	bool operator<=(const float& r);
+	bool operator!=(const float& r);
+	FVector2& operator=(const float& r);
+	FVector2& operator+(const float& r);
+	FVector2& operator-(const float& r);
+	FVector2& operator*(const float& r);
+	FVector2& operator/(const float& r);
+	FVector2& operator+=(const float& r);
+	FVector2& operator-=(const float& r);
+	FVector2& operator*=(const float& r);
+	FVector2& operator/=(const float& r);
+
+	// Simple Math
+	double length();
+	void normalize();
+	double distance(const FVector2 r);
+
+	// Advanced Math
+	void rotate(const double )
+
+	// Serialization
+	const char* serialize();
+	static FVector2& deserialize(const char* serialized);
+};
+
+DLL_METHOD FVector2* DLL_CALL BU_FVector2_Create();
+DLL_METHOD FVector2* DLL_CALL BU_FVector2_Copy(FVector2* copyVector);
+DLL_METHOD void DLL_CALL BU_FVector2_Destroy();
+
+DLL_METHOD FVector2* DLL_CALL BU_FVector2_TempCreate();
+DLL_METHOD FVector2* DLL_CALL BU_FVector2_TempCopy(FVector2* copyVector);
+DLL_METHOD void DLL_CALL BU_FVector2_SetTemp(FVector2* vector);
+DLL_METHOD void DLL_CALL BU_FVector2_UnsetTemp(FVector2* vector);
+DLL_METHOD void DLL_CALL BU_FVector2_TempCleanup();
+
+DLL_METHOD float DLL_CALL BU_FVector2_Length(FVector2* vector);
+DLL_METHOD float DLL_CALL BU_FVector2_Normalize();
+DLL_METHOD float DLL_CALL BU_FVector2_Distance(FVector2* vector);
+DLL_METHOD float DLL_CALL BU_FVector2_DistanceL(float X, float Y);
+
 */

Type/Long.cpp

@@ -0,0 +1,167 @@
+//	Blitz - Steam wrapper for Blitz.
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "Long.h"
+
+DLL_FUNCTION(int64_t*) BU_Long_New() {
+	return new int64_t;
+}
+DLL_FUNCTION(int64_t*) BU_Long_Copy(int64_t* pOther) {
+	return new int64_t(*pOther);
+}
+DLL_FUNCTION(void) BU_Long_Destroy(int64_t* pThis) {
+	delete pThis;
+}
+
+char* BU_Long_Buffer = new char[32];
+DLL_FUNCTION(const char*) BU_Long_ToString(int64_t* pThis) {
+	std::stringstream myStream;
+	myStream << (*pThis);
+
+	const char* myBuffer = myStream.str().c_str();
+	strcpy_s(BU_Long_Buffer, 32, myBuffer);
+	return BU_Long_Buffer;
+}
+DLL_FUNCTION(int64_t*) BU_Long_FromString(const char* pString) {
+	int64_t* pThis = new int64_t;
+	std::stringstream myStream = std::stringstream(pString);
+	myStream >> *pThis;
+	return pThis;
+}
+
+DLL_FUNCTION(int64_t*) BU_Long_FromI(int32_t iRight) {
+	return new int64_t(iRight);
+}
+DLL_FUNCTION(int64_t*) BU_Long_FromII(int32_t iLeft, int32_t iRight) {
+	return new int64_t(((int64_t)(iLeft) << 32) + iRight);
+}
+DLL_FUNCTION(int32_t) BU_Long_ToI(int64_t* pThis, int32_t iShift) {
+	if (iShift >= 0)
+		return (int32_t)(*pThis >> iShift);
+	else
+		return (int32_t)(*pThis << -iShift);
+}
+DLL_FUNCTION(int32_t) BU_Long_ToIH(int64_t* pThis) {
+	return (int32_t)(*pThis >> 32);
+}
+DLL_FUNCTION(int32_t) BU_Long_ToIL(int64_t* pThis) {
+	return (int32_t)*pThis;
+}
+
+DLL_FUNCTION(int64_t*) BU_Long_FromF(float_t fOther) {
+	return new int64_t((int64_t)fOther);
+}
+DLL_FUNCTION(float_t) BU_Long_ToF(int64_t* pThis) {
+	return (float_t)*pThis;
+}
+
+DLL_FUNCTION(int64_t*) BU_Long_FromD(double_t* pOther) {
+	return new int64_t((int64_t)*pOther);
+}
+DLL_FUNCTION(double_t*) BU_Long_ToD(int64_t* pThis) {
+	return new double_t((double_t)*pThis);
+}
+
+DLL_FUNCTION(int32_t) BU_Long_Compare(int64_t* pThis, int64_t* pOther) {
+	return /* It can either be Equal (0) or Smaller or Greater. Easy to check. */
+		   /* Greater */
+		(*pThis > *pOther ? 1 : 0) +
+		/* Smaller */
+		(*pThis < *pOther ? -1 : 0);
+}
+
+DLL_FUNCTION(int64_t*) BU_Long_Set(int64_t* pThis, int64_t* pOther) {
+	*pThis = *pOther;
+	return pThis;
+}
+DLL_FUNCTION(int64_t*) BU_Long_Add(int64_t* pThis, int64_t* pOther) {
+	*pThis += *pOther;
+	return pThis;
+}
+DLL_FUNCTION(int64_t*) BU_Long_Sub(int64_t* pThis, int64_t* pOther) {
+	*pThis -= *pOther;
+	return pThis;
+}
+DLL_FUNCTION(int64_t*) BU_Long_Div(int64_t* pThis, int64_t* pOther) {
+	*pThis /= *pOther;
+	return pThis;
+}
+DLL_FUNCTION(int64_t*) BU_Long_Mul(int64_t* pThis, int64_t* pOther) {
+	*pThis *= *pOther;
+	return pThis;
+}
+DLL_FUNCTION(int64_t*) BU_Long_Mod(int64_t* pThis, int64_t* pOther) {
+	*pThis %= *pOther;
+	return pThis;
+}
+
+DLL_FUNCTION(int64_t*) BU_Long_SetI(int64_t* pThis, int32_t iRight) {
+	*pThis = iRight;
+	return pThis;
+}
+DLL_FUNCTION(int64_t*) BU_Long_AddI(int64_t* pThis, int32_t iRight) {
+	*pThis += iRight;
+	return pThis;
+}
+DLL_FUNCTION(int64_t*) BU_Long_SubI(int64_t* pThis, int32_t iRight) {
+	*pThis -= iRight;
+	return pThis;
+}
+DLL_FUNCTION(int64_t*) BU_Long_DivI(int64_t* pThis, int32_t iRight) {
+	*pThis /= iRight;
+	return pThis;
+}
+DLL_FUNCTION(int64_t*) BU_Long_MulI(int64_t* pThis, int32_t iRight) {
+	*pThis *= iRight;
+	return pThis;
+}
+DLL_FUNCTION(int64_t*) BU_Long_ModI(int64_t* pThis, int32_t iRight) {
+	*pThis %= iRight;
+	return pThis;
+}
+
+DLL_FUNCTION(int64_t*) BU_Long_SetII(int64_t* pThis, int32_t iLeft, int32_t iRight) {
+	*pThis = (((int64_t)iLeft << 32) + iRight);
+	return pThis;
+}
+DLL_FUNCTION(int64_t*) BU_Long_AddII(int64_t* pThis, int32_t iLeft, int32_t iRight) {
+	*pThis += (((int64_t)iLeft << 32) + iRight);
+	return pThis;
+}
+DLL_FUNCTION(int64_t*) BU_Long_SubII(int64_t* pThis, int32_t iLeft, int32_t iRight) {
+	*pThis -= (((int64_t)iLeft << 32) + iRight);
+	return pThis;
+}
+DLL_FUNCTION(int64_t*) BU_Long_DivII(int64_t* pThis, int32_t iLeft, int32_t iRight) {
+	*pThis /= (((int64_t)iLeft << 32) + iRight);
+	return pThis;
+}
+DLL_FUNCTION(int64_t*) BU_Long_MulII(int64_t* pThis, int32_t iLeft, int32_t iRight) {
+	*pThis *= (((int64_t)iLeft << 32) + iRight);
+	return pThis;
+}
+DLL_FUNCTION(int64_t*) BU_Long_ModII(int64_t* pThis, int32_t iLeft, int32_t iRight) {
+	*pThis %= (((int64_t)iLeft << 32) + iRight);
+	return pThis;
+}
+
+DLL_FUNCTION(int64_t*) BU_Long_Shift(int64_t* pThis, int32_t iRight) {
+	if (iRight >= 0)
+		*pThis >>= iRight;
+	else
+		*pThis <<= -iRight;
+	return pThis;
+}

Type/Long.h

@@ -0,0 +1,63 @@
+//	Blitz - Steam wrapper for Blitz.
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#pragma once
+#include "BlitzUtility.h"
+#include <sstream>
+
+DLL_FUNCTION(int64_t*) BU_Long_New();
+DLL_FUNCTION(int64_t*) BU_Long_Copy(int64_t* pRight);
+DLL_FUNCTION(void) BU_Long_Destroy(int64_t* pThis);
+
+DLL_FUNCTION(const char*) BU_Long_ToString(int64_t* pThis);
+DLL_FUNCTION(int64_t*) BU_Long_FromString(const char* pString);
+
+DLL_FUNCTION(int64_t*) BU_Long_FromI(int32_t iRight);
+DLL_FUNCTION(int64_t*) BU_Long_FromII(int32_t iLeft, int32_t iRight);
+DLL_FUNCTION(int32_t) BU_Long_ToI(int64_t* pThis, int32_t iShift);
+DLL_FUNCTION(int32_t) BU_Long_ToIH(int64_t* pThis);
+DLL_FUNCTION(int32_t) BU_Long_ToIL(int64_t* pThis);
+
+DLL_FUNCTION(int64_t*) BU_Long_FromF(float_t fOther);
+DLL_FUNCTION(float_t) BU_Long_ToF(int64_t* pThis);
+
+DLL_FUNCTION(int64_t*) BU_Long_FromD(double_t* pOther);
+DLL_FUNCTION(double_t*) BU_Long_ToD(int64_t* pThis);
+
+DLL_FUNCTION(int32_t) BU_Long_Compare(int64_t* pThis, int64_t* pOther);
+
+DLL_FUNCTION(int64_t*) BU_Long_Set(int64_t* pThis, int64_t* pOther);
+DLL_FUNCTION(int64_t*) BU_Long_Add(int64_t* pThis, int64_t* pOther);
+DLL_FUNCTION(int64_t*) BU_Long_Sub(int64_t* pThis, int64_t* pOther);
+DLL_FUNCTION(int64_t*) BU_Long_Div(int64_t* pThis, int64_t* pOther);
+DLL_FUNCTION(int64_t*) BU_Long_Mul(int64_t* pThis, int64_t* pOther);
+DLL_FUNCTION(int64_t*) BU_Long_Mod(int64_t* pThis, int64_t* pOther);
+
+DLL_FUNCTION(int64_t*) BU_Long_SetI(int64_t* pThis, int32_t iRight);
+DLL_FUNCTION(int64_t*) BU_Long_AddI(int64_t* pThis, int32_t iRight);
+DLL_FUNCTION(int64_t*) BU_Long_SubI(int64_t* pThis, int32_t iRight);
+DLL_FUNCTION(int64_t*) BU_Long_DivI(int64_t* pThis, int32_t iRight);
+DLL_FUNCTION(int64_t*) BU_Long_MulI(int64_t* pThis, int32_t iRight);
+DLL_FUNCTION(int64_t*) BU_Long_ModI(int64_t* pThis, int32_t iRight);
+
+DLL_FUNCTION(int64_t*) BU_Long_SetII(int64_t* pThis, int32_t iLeft, int32_t iRight);
+DLL_FUNCTION(int64_t*) BU_Long_AddII(int64_t* pThis, int32_t iLeft, int32_t iRight);
+DLL_FUNCTION(int64_t*) BU_Long_SubII(int64_t* pThis, int32_t iLeft, int32_t iRight);
+DLL_FUNCTION(int64_t*) BU_Long_DivII(int64_t* pThis, int32_t iLeft, int32_t iRight);
+DLL_FUNCTION(int64_t*) BU_Long_MulII(int64_t* pThis, int32_t iLeft, int32_t iRight);
+DLL_FUNCTION(int64_t*) BU_Long_ModII(int64_t* pThis, int32_t iLeft, int32_t iRight);
+
+DLL_FUNCTION(int64_t*) BU_Long_Shift(int64_t* pThis, int32_t iShift);

Type/LongLong.cpp

@@ -1,174 +0,0 @@
-//	Blitz - Steam wrapper for Blitz.
-//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
-//
-//	This program is free software: you can redistribute it and/or modify
-//	it under the terms of the GNU Lesser General Public License as
-//	published by the Free Software Foundation, either version 3 of the 
-//	License, or (at your option) any later version.
-//
-//	This program is distributed in the hope that it will be useful,
-//	but WITHOUT ANY WARRANTY; without even the implied warranty of
-//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//	GNU General Public License for more details.
-//
-//	You should have received a copy of the GNU Lesser General Public License
-//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-#pragma once
-#include "LongLong.h"
-#include <list>
-
-std::list<int64_t*> blitzLLTemporary;
-
-int64_t* DLL_CALL BU_LongLong_Create() {
-	return new int64_t;
-}
-
-void DLL_CALL BU_LongLong_Destroy(int64_t* pthis) {
-	delete pthis;
-}
-
-int64_t* DLL_CALL BU_LongLong_Copy(int64_t* other) {
-	int64_t* pthis = new int64_t;
-	*pthis = *other;
-	return pthis;
-}
-
-DLL_METHOD int64_t* DLL_CALL BU_LongLong_TempCreate() {
-	int64_t* val = new int64_t;
-	blitzLLTemporary.push_back(val);
-	return val;
-}
-
-DLL_METHOD int64_t* DLL_CALL BU_LongLong_TempCopy(int64_t* other) {
-	int64_t* val = new int64_t(*other);
-	blitzLLTemporary.push_back(val);
-	return val;
-}
-
-DLL_METHOD void DLL_CALL BU_LongLong_SetTemp(int64_t* pthis) {
-	blitzLLTemporary.push_back(pthis);
-}
-
-DLL_METHOD void DLL_CALL BU_LongLong_UnsetTemp(int64_t* pthis) {
-	blitzLLTemporary.remove(pthis);
-}
-
-DLL_METHOD void DLL_CALL BU_LongLong_TempCleanup() {
-	auto iterEnd = blitzLLTemporary.end();
-	for (auto iter = blitzLLTemporary.begin(); iter != iterEnd; ++iter) {
-		delete *iter;
-	}
-	blitzLLTemporary.clear();
-}
-
-
-void DLL_CALL BU_LongLong_Set(int64_t* pthis, int64_t* other) {
-	*pthis = *other;
-}
-
-void DLL_CALL BU_LongLong_SetV(int64_t* pthis, uint32_t left, uint32_t right) {
-	*pthis = ((int64_t)left << 32) + right;
-}
-
-void DLL_CALL BU_LongLong_Add(int64_t* pthis, int64_t* other) {
-	*pthis += *other;
-}
-
-void DLL_CALL BU_LongLong_AddV(int64_t* pthis, uint32_t left, uint32_t right) {
-	*pthis += ((int64_t)left << 32) + right;
-}
-
-void DLL_CALL BU_LongLong_Sub(int64_t* pthis, int64_t* other) {
-	*pthis -= *other;
-}
-
-void DLL_CALL BU_LongLong_SubV(int64_t* pthis, uint32_t left, uint32_t right) {
-	*pthis -= ((int64_t)left << 32) + right;
-}
-
-void DLL_CALL BU_LongLong_Mul(int64_t* pthis, int64_t* other) {
-	*pthis *= *other;
-}
-
-void DLL_CALL BU_LongLong_MulV(int64_t* pthis, uint32_t left, uint32_t right) {
-	*pthis *= ((int64_t)left << 32) + right;
-}
-
-void DLL_CALL BU_LongLong_Div(int64_t* pthis, int64_t* other) {
-	*pthis *= *other;
-}
-
-void DLL_CALL BU_LongLong_DivV(int64_t* pthis, uint32_t left, uint32_t right) {
-	*pthis *= ((int64_t)left << 32) + right;
-}
-
-uint32_t DLL_CALL BU_LongLong_Compare(int64_t* pthis, int64_t* other) {
-	return (*pthis == *other ? 1 : 0) + (*pthis < *other ? 2 : 0) + (*pthis > *other ? 4 : 0);
-}
-
-uint32_t DLL_CALL BU_LongLong_CompareV(int64_t* pthis, uint32_t left, uint32_t right) {
-	int64_t other = ((int64_t)left << 32) + right;
-	return (*pthis == other ? 1 : 0) + (*pthis < other ? 2 : 0) + (*pthis > other ? 4 : 0);
-}
-
-const char* DLL_CALL BU_LongLong_ToString(int64_t* pthis) {
-	std::stringstream stream;
-	stream << *pthis;
-	return stream.str().c_str();
-}
-
-int64_t* DLL_CALL BU_LongLong_FromString(const char* text) {
-	std::stringstream stream = std::stringstream(text);
-	int64_t* val = new int64_t;
-	stream >> *val;
-	return val;
-}
-
-int32_t DLL_CALL BU_LongLong_ToLong(int64_t* pthis, int32_t _modulus) {
-	return *pthis % _modulus;
-}
-
-int64_t* DLL_CALL BU_LongLong_FromLong(int32_t left, int32_t right) {
-	int64_t* val = new int64_t;
-	*val = ((int64_t)left << 32) + right;
-	return val;
-}
-
-int32_t DLL_CALL BU_LongLong_ToLongHigh(int64_t* pthis) {
-	return (int32_t)((*pthis) >> 32);
-}
-
-int32_t DLL_CALL BU_LongLong_ToLongLow(int64_t* pthis) {
-	return (int32_t)((*pthis) && 0xFFFFFFFF);
-}
-
-float_t DLL_CALL BU_LongLong_ToFloat(int64_t* pthis) {
-	return (float)*pthis;
-}
-
-int64_t* DLL_CALL BU_LongLong_FromFloat(float_t other) {
-	int64_t val = (int64_t)other;
-	return BU_LongLong_Copy(&val);
-}
-
-double_t* DLL_CALL BU_LongLong_ToDouble(int64_t* pthis) {
-	double_t* val = new double_t;
-	*val = (double_t)*pthis;
-	return val;
-}
-
-int64_t* DLL_CALL BU_LongLong_FromDouble(double_t* other) {
-	int64_t* val = new int64_t;
-	*val = (int64_t)*other;
-	return val;
-}
-
-const char* DLL_CALL BU_LongLong_Serialize(int64_t* pthis) {
-	return int_to_hex<int64_t>(*pthis).c_str();
-}
-
-int64_t* DLL_CALL BU_LongLong_Deserialize(const char* text) {
-	int64_t val = hex_to_int<int64_t>(std::string(text));
-	return BU_LongLong_Copy(&val);
-}

Type/LongLong.h

@@ -1,104 +0,0 @@
-//	Blitz - Steam wrapper for Blitz.
-//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
-//
-//	This program is free software: you can redistribute it and/or modify
-//	it under the terms of the GNU Lesser General Public License as
-//	published by the Free Software Foundation, either version 3 of the 
-//	License, or (at your option) any later version.
-//
-//	This program is distributed in the hope that it will be useful,
-//	but WITHOUT ANY WARRANTY; without even the implied warranty of
-//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//	GNU General Public License for more details.
-//
-//	You should have received a copy of the GNU Lesser General Public License
-//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-#pragma once
-#include "dllmain.h"
-#include "Double.h"
-#include <string>
-#include <sstream>
-
-#pragma region Constructor & Destructor
-DLL_METHOD int64_t* DLL_CALL BU_LongLong_Create();
-DLL_METHOD void DLL_CALL BU_LongLong_Destroy(int64_t* pthis);
-DLL_METHOD int64_t* DLL_CALL BU_LongLong_Copy(int64_t* other);
-#pragma comment(linker, "/EXPORT:BU_LongLong_Create=_BU_LongLong_Create@0")
-#pragma comment(linker, "/EXPORT:BU_LongLong_Destroy=_BU_LongLong_Destroy@4")
-#pragma comment(linker, "/EXPORT:BU_LongLong_Copy=_BU_LongLong_Copy@4")
-#pragma endregion Constructor & Destructor
-
-#pragma region Temporary Objects
-DLL_METHOD int64_t* DLL_CALL BU_LongLong_TempCreate();
-DLL_METHOD int64_t* DLL_CALL BU_LongLong_TempCopy(int64_t* other);
-DLL_METHOD void DLL_CALL BU_LongLong_SetTemp(int64_t* pthis);
-DLL_METHOD void DLL_CALL BU_LongLong_UnsetTemp(int64_t* pthis);
-DLL_METHOD void DLL_CALL BU_LongLong_TempCleanup();
-#pragma comment(linker, "/EXPORT:BU_LongLong_TempCreate=_BU_LongLong_TempCreate@0")
-#pragma comment(linker, "/EXPORT:BU_LongLong_TempCopy=_BU_LongLong_TempCopy@4")
-#pragma comment(linker, "/EXPORT:BU_LongLong_SetTemp=_BU_LongLong_SetTemp@4")
-#pragma comment(linker, "/EXPORT:BU_LongLong_UnsetTemp=_BU_LongLong_UnsetTemp@4")
-#pragma comment(linker, "/EXPORT:BU_LongLong_TempCleanup=_BU_LongLong_TempCleanup@0")
-#pragma endregion Temporary Objects
-
-#pragma region Math
-DLL_METHOD void DLL_CALL BU_LongLong_Set(int64_t* pthis, int64_t* other);
-DLL_METHOD void DLL_CALL BU_LongLong_SetV(int64_t* pthis, uint32_t left, uint32_t right);
-#pragma comment(linker, "/EXPORT:BU_LongLong_Set=_BU_LongLong_Set@8")
-#pragma comment(linker, "/EXPORT:BU_LongLong_SetV=_BU_LongLong_SetV@12")
-DLL_METHOD void DLL_CALL BU_LongLong_Add(int64_t* pthis, int64_t* other);
-DLL_METHOD void DLL_CALL BU_LongLong_AddV(int64_t* pthis, uint32_t left, uint32_t right);
-#pragma comment(linker, "/EXPORT:BU_LongLong_Add=_BU_LongLong_Add@8")
-#pragma comment(linker, "/EXPORT:BU_LongLong_AddV=_BU_LongLong_AddV@12")
-DLL_METHOD void DLL_CALL BU_LongLong_Sub(int64_t* pthis, int64_t* other);
-DLL_METHOD void DLL_CALL BU_LongLong_SubV(int64_t* pthis, uint32_t left, uint32_t right);
-#pragma comment(linker, "/EXPORT:BU_LongLong_Sub=_BU_LongLong_Sub@8")
-#pragma comment(linker, "/EXPORT:BU_LongLong_SubV=_BU_LongLong_SubV@12")
-DLL_METHOD void DLL_CALL BU_LongLong_Mul(int64_t* pthis, int64_t* other);
-DLL_METHOD void DLL_CALL BU_LongLong_MulV(int64_t* pthis, uint32_t left, uint32_t right);
-#pragma comment(linker, "/EXPORT:BU_LongLong_Mul=_BU_LongLong_Mul@8")
-#pragma comment(linker, "/EXPORT:BU_LongLong_MulV=_BU_LongLong_MulV@12")
-DLL_METHOD void DLL_CALL BU_LongLong_Div(int64_t* pthis, int64_t* other);
-DLL_METHOD void DLL_CALL BU_LongLong_DivV(int64_t* pthis, uint32_t left, uint32_t right);
-#pragma comment(linker, "/EXPORT:BU_LongLong_Div=_BU_LongLong_Div@8")
-#pragma comment(linker, "/EXPORT:BU_LongLong_DivV=_BU_LongLong_DivV@12")
-#pragma endregion Math
-
-#pragma region Comparison
-DLL_METHOD uint32_t DLL_CALL BU_LongLong_Compare(int64_t* pthis, int64_t* other);
-DLL_METHOD uint32_t DLL_CALL BU_LongLong_CompareV(int64_t* pthis, uint32_t left, uint32_t right);
-#pragma comment(linker, "/EXPORT:BU_LongLong_Compare=_BU_LongLong_Compare@8")
-#pragma comment(linker, "/EXPORT:BU_LongLong_CompareV=_BU_LongLong_CompareV@12")
-#pragma endregion Comparison
-
-
-#pragma region Conversion
-DLL_METHOD const char* DLL_CALL BU_LongLong_ToString(int64_t* pthis);
-DLL_METHOD int64_t* DLL_CALL BU_LongLong_FromString(const char* text);
-#pragma comment(linker, "/EXPORT:BU_LongLong_ToString=_BU_LongLong_ToString@4")
-#pragma comment(linker, "/EXPORT:BU_LongLong_FromString=_BU_LongLong_FromString@4")
-DLL_METHOD int32_t DLL_CALL BU_LongLong_ToLong(int64_t* pthis, int32_t _modulus);
-DLL_METHOD int64_t* DLL_CALL BU_LongLong_FromLong(int32_t left, int32_t right);
-#pragma comment(linker, "/EXPORT:BU_LongLong_ToLong=_BU_LongLong_ToLong@8")
-#pragma comment(linker, "/EXPORT:BU_LongLong_FromLong=_BU_LongLong_FromLong@8")
-DLL_METHOD int32_t DLL_CALL BU_LongLong_ToLongHigh(int64_t* pthis);
-DLL_METHOD int32_t DLL_CALL BU_LongLong_ToLongLow(int64_t* pthis);
-#pragma comment(linker, "/EXPORT:BU_LongLong_ToLongHigh=_BU_LongLong_ToLongHigh@4")
-#pragma comment(linker, "/EXPORT:BU_LongLong_ToLongLow=_BU_LongLong_ToLongLow@4")
-DLL_METHOD float_t DLL_CALL BU_LongLong_ToFloat(int64_t* pthis);
-DLL_METHOD int64_t* DLL_CALL BU_LongLong_FromFloat(float_t other);
-#pragma comment(linker, "/EXPORT:BU_LongLong_ToFloat=_BU_LongLong_ToFloat@4")
-#pragma comment(linker, "/EXPORT:BU_LongLong_FromFloat=_BU_LongLong_FromFloat@4")
-DLL_METHOD double_t* DLL_CALL BU_LongLong_ToDouble(int64_t* pthis);
-DLL_METHOD int64_t* DLL_CALL BU_LongLong_FromDouble(double_t* pthis);
-#pragma comment(linker, "/EXPORT:BU_LongLong_ToDouble=_BU_LongLong_ToDouble@4")
-#pragma comment(linker, "/EXPORT:BU_LongLong_FromDouble=_BU_LongLong_FromDouble@4")
-#pragma endregion Conversion
-
-#pragma region Serialization
-DLL_METHOD const char* DLL_CALL BU_LongLong_Serialize(int64_t* pthis);
-DLL_METHOD int64_t* DLL_CALL BU_LongLong_Deserialize(const char* text);
-#pragma comment(linker, "/EXPORT:BU_LongLong_Serialize=_BU_LongLong_Serialize@4")
-#pragma comment(linker, "/EXPORT:BU_LongLong_Deserialize=_BU_LongLong_Deserialize@4")
-#pragma endregion Serialization

Utility/DisplayEnumerator.cpp

@@ -1,55 +1,55 @@
-//	BlitzUtility - Expanding the normal Blitz functionality.
-//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
-//
-//	This program is free software: you can redistribute it and/or modify
-//	it under the terms of the GNU Lesser General Public License as
-//	published by the Free Software Foundation, either version 3 of the 
-//	License, or (at your option) any later version.
-//
-//	This program is distributed in the hope that it will be useful,
-//	but WITHOUT ANY WARRANTY; without even the implied warranty of
-//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//	GNU General Public License for more details.
-//
-//	You should have received a copy of the GNU Lesser General Public License
-//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-#include "DisplayEnumerator.h"
-
-BOOL CALLBACK BU_DisplayEnumerator_Callback(HMONITOR hMonitor, HDC hdcMonitor, LPRECT lprcMonitor, LPARAM dwData) {
-	DisplayEnumerator* displayEnumerator = (DisplayEnumerator*)dwData;
-
-	displayEnumerator->displays.push_back(RECT(*lprcMonitor));
-	return TRUE;
-}
-
-DLL_METHOD DisplayEnumerator* DLL_CALL BU_DisplayEnumerator_Create() {
-	DisplayEnumerator* displayEnumerator = new DisplayEnumerator();
-	return displayEnumerator;
-}
-
-DLL_METHOD void DLL_CALL BU_DisplayEnumerator_Destroy(DisplayEnumerator* displayEnumerator) {
-	delete displayEnumerator;
-}
-
-DLL_METHOD uint32_t DLL_CALL BU_DisplayEnumerator_Enumerate(DisplayEnumerator* displayEnumerator) {
-	EnumDisplayMonitors(NULL, NULL, BU_DisplayEnumerator_Callback, (LPARAM)displayEnumerator);
-
-	return displayEnumerator->displays.size();
-}
-
-DLL_METHOD uint32_t DLL_CALL BU_DisplayEnumerator_Count(DisplayEnumerator* displayEnumerator) {
-	return displayEnumerator->displays.size();
-}
-
-DLL_METHOD void DLL_CALL BU_DisplayEnumerator_Retrieve(DisplayEnumerator* displayEnumerator, uint32_t index, PRECT display) {
-	// Retrieve the requested index.
-	auto iterator = displayEnumerator->displays.begin();
-	std::advance(iterator, index);
-
-	// Copy data.
-	display->left = iterator->left;
-	display->top = iterator->top;
-	display->right = iterator->right;
-	display->bottom = iterator->bottom;
+//	BlitzUtility - Expanding the normal Blitz functionality.
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "DisplayEnumerator.h"
+
+BOOL CALLBACK BU_DisplayEnumerator_Callback(HMONITOR hMonitor, HDC hdcMonitor, LPRECT lprcMonitor, LPARAM dwData) {
+	DisplayEnumerator* displayEnumerator = (DisplayEnumerator*)dwData;
+
+	displayEnumerator->displays.push_back(RECT(*lprcMonitor));
+	return TRUE;
+}
+
+DLL_FUNCTION(DisplayEnumerator*) BU_DisplayEnumerator_Create() {
+	DisplayEnumerator* displayEnumerator = new DisplayEnumerator();
+	return displayEnumerator;
+}
+
+DLL_FUNCTION(void) BU_DisplayEnumerator_Destroy(DisplayEnumerator* displayEnumerator) {
+	delete displayEnumerator;
+}
+
+DLL_FUNCTION(uint32_t) BU_DisplayEnumerator_Enumerate(DisplayEnumerator* displayEnumerator) {
+	EnumDisplayMonitors(NULL, NULL, BU_DisplayEnumerator_Callback, (LPARAM)displayEnumerator);
+
+	return displayEnumerator->displays.size();
+}
+
+DLL_FUNCTION(uint32_t) BU_DisplayEnumerator_Count(DisplayEnumerator* displayEnumerator) {
+	return displayEnumerator->displays.size();
+}
+
+DLL_FUNCTION(void) BU_DisplayEnumerator_Retrieve(DisplayEnumerator* displayEnumerator, uint32_t index, LPRECT display) {
+	// Retrieve the requested index.
+	auto iterator = displayEnumerator->displays.begin();
+	std::advance(iterator, index);
+
+	// Copy data.
+	display->left = iterator->left;
+	display->top = iterator->top;
+	display->right = iterator->right;
+	display->bottom = iterator->bottom;
 }

Utility/DisplayEnumerator.h

@@ -1,38 +1,33 @@
-//	BlitzUtility - Expanding the normal Blitz functionality.
-//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
-//
-//	This program is free software: you can redistribute it and/or modify
-//	it under the terms of the GNU Lesser General Public License as
-//	published by the Free Software Foundation, either version 3 of the 
-//	License, or (at your option) any later version.
-//
-//	This program is distributed in the hope that it will be useful,
-//	but WITHOUT ANY WARRANTY; without even the implied warranty of
-//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//	GNU General Public License for more details.
-//
-//	You should have received a copy of the GNU Lesser General Public License
-//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-#pragma once
-#include "dllmain.h"
-#include <list>
-
-struct DisplayEnumerator {
-	std::list<RECT> displays;
-};
-
-// Internal Callback
-BOOL CALLBACK BU_DisplayEnumerator_Callback(HMONITOR hMonitor, HDC hdcMonitor, LPRECT lprcMonitor, LPARAM dwData);
-
-// Exported functions.
-DLL_METHOD DisplayEnumerator* DLL_CALL BU_DisplayEnumerator_Create();
-#pragma comment(linker, "/EXPORT:BU_DisplayEnumerator_Create=_BU_DisplayEnumerator_Create@0")
-DLL_METHOD void DLL_CALL BU_DisplayEnumerator_Destroy(DisplayEnumerator* displayEnumerator);
-#pragma comment(linker, "/EXPORT:BU_DisplayEnumerator_Destroy=_BU_DisplayEnumerator_Destroy@4")
-DLL_METHOD uint32_t DLL_CALL BU_DisplayEnumerator_Enumerate(DisplayEnumerator* displayEnumerator);
-#pragma comment(linker, "/EXPORT:BU_DisplayEnumerator_Enumerate=_BU_DisplayEnumerator_Enumerate@4")
-DLL_METHOD uint32_t DLL_CALL BU_DisplayEnumerator_Count(DisplayEnumerator* displayEnumerator);
-#pragma comment(linker, "/EXPORT:BU_DisplayEnumerator_Count=_BU_DisplayEnumerator_Count@4")
-DLL_METHOD void DLL_CALL BU_DisplayEnumerator_Retrieve(DisplayEnumerator* displayEnumerator, uint32_t index, LPRECT display);
-#pragma comment(linker, "/EXPORT:BU_DisplayEnumerator_Retrieve=_BU_DisplayEnumerator_Retrieve@12")
+//	BlitzUtility - Expanding the normal Blitz functionality.
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#pragma once
+#include "BlitzUtility.h"
+#include <list>
+
+struct DisplayEnumerator {
+	std::list<RECT> displays;
+};
+
+// Internal Callback
+BOOL CALLBACK BU_DisplayEnumerator_Callback(HMONITOR hMonitor, HDC hdcMonitor, LPRECT lprcMonitor, LPARAM dwData);
+
+// Exported functions.
+DLL_FUNCTION(DisplayEnumerator*) BU_DisplayEnumerator_Create();
+DLL_FUNCTION(void) BU_DisplayEnumerator_Destroy(DisplayEnumerator* displayEnumerator);
+DLL_FUNCTION(uint32_t) BU_DisplayEnumerator_Enumerate(DisplayEnumerator* displayEnumerator);
+DLL_FUNCTION(uint32_t) BU_DisplayEnumerator_Count(DisplayEnumerator* displayEnumerator);
+DLL_FUNCTION(void) BU_DisplayEnumerator_Retrieve(DisplayEnumerator* displayEnumerator, uint32_t index, LPRECT display);

Utility/IndexerV1.cpp

@@ -1,126 +1,126 @@
-//	BlitzUtility - Expanding the normal Blitz functionality.
-//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
-//
-//	This program is free software: you can redistribute it and/or modify
-//	it under the terms of the GNU Lesser General Public License as
-//	published by the Free Software Foundation, either version 3 of the 
-//	License, or (at your option) any later version.
-//
-//	This program is distributed in the hope that it will be useful,
-//	but WITHOUT ANY WARRANTY; without even the implied warranty of
-//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//	GNU General Public License for more details.
-//
-//	You should have received a copy of the GNU Lesser General Public License
-//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-#pragma once
-#include "IndexerV1.h"
-
-void IndexerV1::mark(uint32_t index, bool used) {
-	uint8_t bit = index & 0x3F;
-	index = index >> 6;
-
-	this->indexes[index] ^= (!(uint64_t)used ^ this->indexes[index]) & (1ULL << bit);
-}
-
-bool IndexerV1::is(uint32_t index, bool used) {
-	uint8_t bit = index & 0x3F;
-	index = index >> 6;
-
-	return (!!(this->indexes[index] & (1ULL << bit)) == used);
-}
-
-uint32_t IndexerV1::get() {
-	bool hasFoundIndex = false;
-	uint32_t foundIndex = 0;
-
-	// Our search begins and ends at lastAssignedIndex.
-	for (uint32_t indexOffset = 0; indexOffset <= INDEXER_INDEXES; indexOffset++) {
-		uint32_t index = (lastAssignedIndex >> 6) + indexOffset;
-		uint8_t bit = 0;
-
-		uint64_t checkValue = this->indexes[index];
-		for (uint8_t bit = 0; bit < 64; bit++) {
-			if (this->is((index << 6) + bit, false)) {
-				hasFoundIndex = true;
-				foundIndex = (index << 6) + bit;
-				break;
-			}
-		}
-	}
-
-	if (hasFoundIndex) {
-		this->mark(foundIndex, true);
-		return foundIndex;
-	}
-	
-	return FALSE;
-}
-
-uint32_t IndexerV1::count(bool used) {
-	uint32_t amount = 0;
-
-	for (uint32_t index = 0; index <= INDEXER_INDEXES; index++) {
-		uint8_t bit = 0;
-
-		uint64_t checkValue = this->indexes[index];
-		if (checkValue == !(uint64_t)!used) {
-			amount += 64;
-		} else {
-			for (uint8_t bit = 0; bit < 64; bit++) {
-				amount += this->is((index << 6) + bit, used);
-			}
-		}
-	}
-
-	return amount;
-}
-
-DLL_METHOD IndexerV1* DLL_CALL BU_IndexerV1_Create() {
-	return new IndexerV1();
-}
-
-DLL_METHOD void DLL_CALL BU_IndexerV1_Destroy(IndexerV1* indexer) {
-	delete indexer;
-}
-
-DLL_METHOD void DLL_CALL BU_IndexerV1_Mark(IndexerV1* indexer, uint32_t index, uint32_t used) {
-	indexer->mark(index, used != 0);
-}
-
-DLL_METHOD void DLL_CALL BU_IndexerV1_MarkFree(IndexerV1* indexer, uint32_t index) {
-	indexer->mark(index, false);
-}
-
-DLL_METHOD void DLL_CALL BU_IndexerV1_MarkUsed(IndexerV1* indexer, uint32_t index) {
-	indexer->mark(index, true);
-}
-
-DLL_METHOD uint32_t DLL_CALL BU_IndexerV1_Is(IndexerV1* indexer, uint32_t index, uint32_t used) {
-	return indexer->is(index, used != 0);
-}
-
-DLL_METHOD uint32_t DLL_CALL BU_IndexerV1_IsFree(IndexerV1* indexer, uint32_t index) {
-	return indexer->is(index, false);
-}
-
-DLL_METHOD uint32_t DLL_CALL BU_IndexerV1_IsUsed(IndexerV1* indexer, uint32_t index) {
-	return indexer->is(index, true);
-}
-
-DLL_METHOD uint32_t DLL_CALL BU_IndexerV1_Get(IndexerV1* indexer) {
-	return indexer->get();
-}
-
-DLL_METHOD uint32_t DLL_CALL BU_IndexerV1_Count(IndexerV1* indexer, uint32_t used) {
-	return indexer->count(used != 0);
-}
-
-DLL_METHOD uint32_t DLL_CALL BU_IndexerV1_CountFree(IndexerV1* indexer) {
-	return indexer->count(false);
-}
-
-DLL_METHOD uint32_t DLL_CALL BU_IndexerV1_CountUsed(IndexerV1* indexer) {
-	return indexer->count(true);
-}
+//	BlitzUtility - Expanding the normal Blitz functionality.
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#pragma once
+#include "IndexerV1.h"
+
+void IndexerV1::mark(uint32_t index, bool used) {
+	uint8_t bit = index & 0x3F;
+	index = index >> 6;
+
+	this->indexes[index] ^= (!(uint64_t)used ^ this->indexes[index]) & (1ULL << bit);
+}
+
+bool IndexerV1::is(uint32_t index, bool used) {
+	uint8_t bit = index & 0x3F;
+	index = index >> 6;
+
+	return (!!(this->indexes[index] & (1ULL << bit)) == used);
+}
+
+uint32_t IndexerV1::get() {
+	bool hasFoundIndex = false;
+	uint32_t foundIndex = 0;
+
+	// Our search begins and ends at lastAssignedIndex.
+	for (uint32_t indexOffset = 0; indexOffset <= INDEXER_INDEXES; indexOffset++) {
+		uint32_t index = (lastAssignedIndex >> 6) + indexOffset;
+		uint8_t bit = 0;
+
+		uint64_t checkValue = this->indexes[index];
+		for (uint8_t bit = 0; bit < 64; bit++) {
+			if (this->is((index << 6) + bit, false)) {
+				hasFoundIndex = true;
+				foundIndex = (index << 6) + bit;
+				break;
+			}
+		}
+	}
+
+	if (hasFoundIndex) {
+		this->mark(foundIndex, true);
+		return foundIndex;
+	}
+	
+	return FALSE;
+}
+
+uint32_t IndexerV1::count(bool used) {
+	uint32_t amount = 0;
+
+	for (uint32_t index = 0; index <= INDEXER_INDEXES; index++) {
+		uint8_t bit = 0;
+
+		uint64_t checkValue = this->indexes[index];
+		if (checkValue == !(uint64_t)!used) {
+			amount += 64;
+		} else {
+			for (uint8_t bit = 0; bit < 64; bit++) {
+				amount += this->is((index << 6) + bit, used);
+			}
+		}
+	}
+
+	return amount;
+}
+
+DLL_FUNCTION(IndexerV1*) BU_IndexerV1_Create() {
+	return new IndexerV1();
+}
+
+DLL_FUNCTION(void) BU_IndexerV1_Destroy(IndexerV1* indexer) {
+	delete indexer;
+}
+
+DLL_FUNCTION(void) BU_IndexerV1_Mark(IndexerV1* indexer, uint32_t index, uint32_t used) {
+	indexer->mark(index, used != 0);
+}
+
+DLL_FUNCTION(void) BU_IndexerV1_MarkFree(IndexerV1* indexer, uint32_t index) {
+	indexer->mark(index, false);
+}
+
+DLL_FUNCTION(void) BU_IndexerV1_MarkUsed(IndexerV1* indexer, uint32_t index) {
+	indexer->mark(index, true);
+}
+
+DLL_FUNCTION(uint32_t) BU_IndexerV1_Is(IndexerV1* indexer, uint32_t index, uint32_t used) {
+	return indexer->is(index, used != 0);
+}
+
+DLL_FUNCTION(uint32_t) BU_IndexerV1_IsFree(IndexerV1* indexer, uint32_t index) {
+	return indexer->is(index, false);
+}
+
+DLL_FUNCTION(uint32_t) BU_IndexerV1_IsUsed(IndexerV1* indexer, uint32_t index) {
+	return indexer->is(index, true);
+}
+
+DLL_FUNCTION(uint32_t) BU_IndexerV1_Get(IndexerV1* indexer) {
+	return indexer->get();
+}
+
+DLL_FUNCTION(uint32_t) BU_IndexerV1_Count(IndexerV1* indexer, uint32_t used) {
+	return indexer->count(used != 0);
+}
+
+DLL_FUNCTION(uint32_t) BU_IndexerV1_CountFree(IndexerV1* indexer) {
+	return indexer->count(false);
+}
+
+DLL_FUNCTION(uint32_t) BU_IndexerV1_CountUsed(IndexerV1* indexer) {
+	return indexer->count(true);
+}

Utility/IndexerV1.h

@@ -1,61 +1,61 @@
-//	BlitzUtility - Expanding the normal Blitz functionality.
-//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
-//
-//	This program is free software: you can redistribute it and/or modify
-//	it under the terms of the GNU Lesser General Public License as
-//	published by the Free Software Foundation, either version 3 of the 
-//	License, or (at your option) any later version.
-//
-//	This program is distributed in the hope that it will be useful,
-//	but WITHOUT ANY WARRANTY; without even the implied warranty of
-//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//	GNU General Public License for more details.
-//
-//	You should have received a copy of the GNU Lesser General Public License
-//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-#pragma once
-#include <cstdlib>
-#include <list>
-#include "dllmain.h"
-
-// 67108864 = 2 ^ 32 / 64
-#define INDEXER_INDEXES 67108864 //pow(2,32) / 64 
-
-/** Indexer structure helps with getting unique, unused Indexes (Ids).
-  * Doing this natively would be too slow, so I'm using a DLL for this.
-  */
-struct IndexerV1 {
-	uint64_t indexes[INDEXER_INDEXES];
-	uint32_t lastAssignedIndex;
-
-	void mark(uint32_t index, bool used);
-	bool is(uint32_t index, bool used);
-	uint32_t get();
-	uint32_t count(bool used);
-};
-
-DLL_METHOD IndexerV1* DLL_CALL BU_IndexerV1_Create();
-#pragma comment(linker, "/EXPORT:BU_IndexerV1_Create=_BU_IndexerV1_Create@0")
-DLL_METHOD void DLL_CALL BU_IndexerV1_Destroy(IndexerV1* indexer);
-#pragma comment(linker, "/EXPORT:BU_IndexerV1_Destroy=_BU_IndexerV1_Destroy@4")
-DLL_METHOD void DLL_CALL BU_IndexerV1_Mark(IndexerV1* indexer, uint32_t used, uint32_t index);
-#pragma comment(linker, "/EXPORT:BU_IndexerV1_Mark=_BU_IndexerV1_Mark@12")
-DLL_METHOD void DLL_CALL BU_IndexerV1_MarkFree(IndexerV1* indexer, uint32_t index);
-#pragma comment(linker, "/EXPORT:BU_IndexerV1_MarkFree=_BU_IndexerV1_MarkFree@8")
-DLL_METHOD void DLL_CALL BU_IndexerV1_MarkUsed(IndexerV1* indexer, uint32_t index);
-#pragma comment(linker, "/EXPORT:BU_IndexerV1_MarkUsed=_BU_IndexerV1_MarkUsed@8")
-DLL_METHOD uint32_t DLL_CALL BU_IndexerV1_Is(IndexerV1* indexer, uint32_t index, uint32_t used);
-#pragma comment(linker, "/EXPORT:BU_IndexerV1_Is=_BU_IndexerV1_Is@12")
-DLL_METHOD uint32_t DLL_CALL BU_IndexerV1_IsFree(IndexerV1* indexer, uint32_t index);
-#pragma comment(linker, "/EXPORT:BU_IndexerV1_IsFree=_BU_IndexerV1_IsFree@8")
-DLL_METHOD uint32_t DLL_CALL BU_IndexerV1_IsUsed(IndexerV1* indexer, uint32_t index);
-#pragma comment(linker, "/EXPORT:BU_IndexerV1_IsUsed=_BU_IndexerV1_IsUsed@8")
-DLL_METHOD uint32_t DLL_CALL BU_IndexerV1_Get(IndexerV1* indexer);
-#pragma comment(linker, "/EXPORT:BU_IndexerV1_Get=_BU_IndexerV1_Get@4")
-DLL_METHOD uint32_t DLL_CALL BU_IndexerV1_Count(IndexerV1* indexer, uint32_t used);
-#pragma comment(linker, "/EXPORT:BU_IndexerV1_Count=_BU_IndexerV1_Count@8")
-DLL_METHOD uint32_t DLL_CALL BU_IndexerV1_CountFree(IndexerV1* indexer);
-#pragma comment(linker, "/EXPORT:BU_IndexerV1_CountFree=_BU_IndexerV1_CountFree@4")
-DLL_METHOD uint32_t DLL_CALL BU_IndexerV1_CountUsed(IndexerV1* indexer);
-#pragma comment(linker, "/EXPORT:BU_IndexerV1_CountUsed=_BU_IndexerV1_CountUsed@4")
+//	BlitzUtility - Expanding the normal Blitz functionality.
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#pragma once
+#include <cstdlib>
+#include <list>
+#include "BlitzUtility.h"
+
+// 67108864 = 2 ^ 32 / 64
+#define INDEXER_INDEXES 67108864 //pow(2,32) / 64 
+
+/** Indexer structure helps with getting unique, unused Indexes (Ids).
+  * Doing this natively would be too slow, so I'm using a DLL for this.
+  */
+struct IndexerV1 {
+	uint64_t indexes[INDEXER_INDEXES];
+	uint32_t lastAssignedIndex;
+
+	void mark(uint32_t index, bool used);
+	bool is(uint32_t index, bool used);
+	uint32_t get();
+	uint32_t count(bool used);
+};
+
+DLL_FUNCTION(IndexerV1*) BU_IndexerV1_Create();
+#pragma comment(linker, "/EXPORT:BU_IndexerV1_Create=_BU_IndexerV1_Create@0")
+DLL_FUNCTION(void) BU_IndexerV1_Destroy(IndexerV1* indexer);
+#pragma comment(linker, "/EXPORT:BU_IndexerV1_Destroy=_BU_IndexerV1_Destroy@4")
+DLL_FUNCTION(void) BU_IndexerV1_Mark(IndexerV1* indexer, uint32_t used, uint32_t index);
+#pragma comment(linker, "/EXPORT:BU_IndexerV1_Mark=_BU_IndexerV1_Mark@12")
+DLL_FUNCTION(void) BU_IndexerV1_MarkFree(IndexerV1* indexer, uint32_t index);
+#pragma comment(linker, "/EXPORT:BU_IndexerV1_MarkFree=_BU_IndexerV1_MarkFree@8")
+DLL_FUNCTION(void) BU_IndexerV1_MarkUsed(IndexerV1* indexer, uint32_t index);
+#pragma comment(linker, "/EXPORT:BU_IndexerV1_MarkUsed=_BU_IndexerV1_MarkUsed@8")
+DLL_FUNCTION(uint32_t) BU_IndexerV1_Is(IndexerV1* indexer, uint32_t index, uint32_t used);
+#pragma comment(linker, "/EXPORT:BU_IndexerV1_Is=_BU_IndexerV1_Is@12")
+DLL_FUNCTION(uint32_t) BU_IndexerV1_IsFree(IndexerV1* indexer, uint32_t index);
+#pragma comment(linker, "/EXPORT:BU_IndexerV1_IsFree=_BU_IndexerV1_IsFree@8")
+DLL_FUNCTION(uint32_t) BU_IndexerV1_IsUsed(IndexerV1* indexer, uint32_t index);
+#pragma comment(linker, "/EXPORT:BU_IndexerV1_IsUsed=_BU_IndexerV1_IsUsed@8")
+DLL_FUNCTION(uint32_t) BU_IndexerV1_Get(IndexerV1* indexer);
+#pragma comment(linker, "/EXPORT:BU_IndexerV1_Get=_BU_IndexerV1_Get@4")
+DLL_FUNCTION(uint32_t) BU_IndexerV1_Count(IndexerV1* indexer, uint32_t used);
+#pragma comment(linker, "/EXPORT:BU_IndexerV1_Count=_BU_IndexerV1_Count@8")
+DLL_FUNCTION(uint32_t) BU_IndexerV1_CountFree(IndexerV1* indexer);
+#pragma comment(linker, "/EXPORT:BU_IndexerV1_CountFree=_BU_IndexerV1_CountFree@4")
+DLL_FUNCTION(uint32_t) BU_IndexerV1_CountUsed(IndexerV1* indexer);
+#pragma comment(linker, "/EXPORT:BU_IndexerV1_CountUsed=_BU_IndexerV1_CountUsed@4")

Utility/IndexerV2.cpp

@@ -1,5 +1,5 @@
 //	BlitzUtility - Expanding the normal Blitz functionality.
-//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
 //
 //	This program is free software: you can redistribute it and/or modify
 //	it under the terms of the GNU Lesser General Public License as
@@ -122,50 +122,50 @@ IndexerV2::IndexerV2Range::IndexerV2Range(uint32_t min, uint32_t max) {
 }
 
 
-DLL_METHOD IndexerV2* DLL_CALL BU_IndexerV2_Create() {
+DLL_FUNCTION(IndexerV2*) BU_IndexerV2_Create() {
 	return new IndexerV2();
 }
 
-DLL_METHOD void DLL_CALL BU_IndexerV2_Destroy(IndexerV2* indexer) {
+DLL_FUNCTION(void) BU_IndexerV2_Destroy(IndexerV2* indexer) {
 	delete indexer;
 }
 
-DLL_METHOD void DLL_CALL BU_IndexerV2_Mark(IndexerV2* indexer, uint32_t used, uint32_t index) {
+DLL_FUNCTION(void) BU_IndexerV2_Mark(IndexerV2* indexer, uint32_t used, uint32_t index) {
 	indexer->mark(index, used != 0);
 }
 
-DLL_METHOD void DLL_CALL BU_IndexerV2_MarkFree(IndexerV2* indexer, uint32_t index) {
+DLL_FUNCTION(void) BU_IndexerV2_MarkFree(IndexerV2* indexer, uint32_t index) {
 	indexer->mark(index, false);
 }
 
-DLL_METHOD void DLL_CALL BU_IndexerV2_MarkUsed(IndexerV2* indexer, uint32_t index) {
+DLL_FUNCTION(void) BU_IndexerV2_MarkUsed(IndexerV2* indexer, uint32_t index) {
 	indexer->mark(index, true);
 }
 
-DLL_METHOD uint32_t DLL_CALL BU_IndexerV2_Is(IndexerV2* indexer, uint32_t index, uint32_t used) {
+DLL_FUNCTION(uint32_t) BU_IndexerV2_Is(IndexerV2* indexer, uint32_t index, uint32_t used) {
 	return indexer->is(index, used != 0);
 }
 
-DLL_METHOD uint32_t DLL_CALL BU_IndexerV2_IsFree(IndexerV2* indexer, uint32_t index) {
+DLL_FUNCTION(uint32_t) BU_IndexerV2_IsFree(IndexerV2* indexer, uint32_t index) {
 	return indexer->is(index, false);
 }
 
-DLL_METHOD uint32_t DLL_CALL BU_IndexerV2_IsUsed(IndexerV2* indexer, uint32_t index) {
+DLL_FUNCTION(uint32_t) BU_IndexerV2_IsUsed(IndexerV2* indexer, uint32_t index) {
 	return indexer->is(index, true);
 }
 
-DLL_METHOD uint32_t DLL_CALL BU_IndexerV2_Get(IndexerV2* indexer) {
+DLL_FUNCTION(uint32_t) BU_IndexerV2_Get(IndexerV2* indexer) {
 	return indexer->get();
 }
 
-DLL_METHOD uint32_t DLL_CALL BU_IndexerV2_Count(IndexerV2* indexer, uint32_t used) {
+DLL_FUNCTION(uint32_t) BU_IndexerV2_Count(IndexerV2* indexer, uint32_t used) {
 	return indexer->count(used != 0);
 }
 
-DLL_METHOD uint32_t DLL_CALL BU_IndexerV2_CountFree(IndexerV2* indexer) {
+DLL_FUNCTION(uint32_t) BU_IndexerV2_CountFree(IndexerV2* indexer) {
 	return indexer->count(false);
 }
 
-DLL_METHOD uint32_t DLL_CALL BU_IndexerV2_CountUsed(IndexerV2* indexer) {
+DLL_FUNCTION(uint32_t) BU_IndexerV2_CountUsed(IndexerV2* indexer) {
 	return indexer->count(true);
 }

Utility/IndexerV2.h

@@ -1,5 +1,5 @@
 //	BlitzUtility - Expanding the normal Blitz functionality.
-//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
 //
 //	This program is free software: you can redistribute it and/or modify
 //	it under the terms of the GNU Lesser General Public License as
@@ -15,7 +15,7 @@
 //	along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 #pragma once
-#include "dllmain.h"
+#include "BlitzUtility.h"
 #include <vector>
 
 class IndexerV2 {
@@ -38,28 +38,28 @@ class IndexerV2 {
 		std::vector<IndexerV2Range> range;
 };
 
-DLL_METHOD IndexerV2* DLL_CALL BU_IndexerV2_Create();
+DLL_FUNCTION(IndexerV2*) BU_IndexerV2_Create();
 #pragma comment(linker, "/EXPORT:BU_IndexerV2_Create=_BU_IndexerV2_Create@0")
-DLL_METHOD void DLL_CALL BU_IndexerV2_Destroy(IndexerV2* indexer);
+DLL_FUNCTION(void) BU_IndexerV2_Destroy(IndexerV2* indexer);
 #pragma comment(linker, "/EXPORT:BU_IndexerV2_Destroy=_BU_IndexerV2_Destroy@4")
-DLL_METHOD void DLL_CALL BU_IndexerV2_Mark(IndexerV2* indexer, uint32_t used, uint32_t index);
+DLL_FUNCTION(void) BU_IndexerV2_Mark(IndexerV2* indexer, uint32_t used, uint32_t index);
 #pragma comment(linker, "/EXPORT:BU_IndexerV2_Mark=_BU_IndexerV2_Mark@12")
-DLL_METHOD void DLL_CALL BU_IndexerV2_MarkFree(IndexerV2* indexer, uint32_t index);
+DLL_FUNCTION(void) BU_IndexerV2_MarkFree(IndexerV2* indexer, uint32_t index);
 #pragma comment(linker, "/EXPORT:BU_IndexerV2_MarkFree=_BU_IndexerV2_MarkFree@8")
-DLL_METHOD void DLL_CALL BU_IndexerV2_MarkUsed(IndexerV2* indexer, uint32_t index);
+DLL_FUNCTION(void) BU_IndexerV2_MarkUsed(IndexerV2* indexer, uint32_t index);
 #pragma comment(linker, "/EXPORT:BU_IndexerV2_MarkUsed=_BU_IndexerV2_MarkUsed@8")
-DLL_METHOD uint32_t DLL_CALL BU_IndexerV2_Is(IndexerV2* indexer, uint32_t index, uint32_t used);
+DLL_FUNCTION(uint32_t) BU_IndexerV2_Is(IndexerV2* indexer, uint32_t index, uint32_t used);
 #pragma comment(linker, "/EXPORT:BU_IndexerV2_Is=_BU_IndexerV2_Is@12")
-DLL_METHOD uint32_t DLL_CALL BU_IndexerV2_IsFree(IndexerV2* indexer, uint32_t index);
+DLL_FUNCTION(uint32_t) BU_IndexerV2_IsFree(IndexerV2* indexer, uint32_t index);
 #pragma comment(linker, "/EXPORT:BU_IndexerV2_IsFree=_BU_IndexerV2_IsFree@8")
-DLL_METHOD uint32_t DLL_CALL BU_IndexerV2_IsUsed(IndexerV2* indexer, uint32_t index);
+DLL_FUNCTION(uint32_t) BU_IndexerV2_IsUsed(IndexerV2* indexer, uint32_t index);
 #pragma comment(linker, "/EXPORT:BU_IndexerV2_IsUsed=_BU_IndexerV2_IsUsed@8")
-DLL_METHOD uint32_t DLL_CALL BU_IndexerV2_Get(IndexerV2* indexer);
+DLL_FUNCTION(uint32_t) BU_IndexerV2_Get(IndexerV2* indexer);
 #pragma comment(linker, "/EXPORT:BU_IndexerV2_Get=_BU_IndexerV2_Get@4")
-DLL_METHOD uint32_t DLL_CALL BU_IndexerV2_Count(IndexerV2* indexer, uint32_t used);
+DLL_FUNCTION(uint32_t) BU_IndexerV2_Count(IndexerV2* indexer, uint32_t used);
 #pragma comment(linker, "/EXPORT:BU_IndexerV2_Count=_BU_IndexerV2_Count@8")
-DLL_METHOD uint32_t DLL_CALL BU_IndexerV2_CountFree(IndexerV2* indexer);
+DLL_FUNCTION(uint32_t) BU_IndexerV2_CountFree(IndexerV2* indexer);
 #pragma comment(linker, "/EXPORT:BU_IndexerV2_CountFree=_BU_IndexerV2_CountFree@4")
-DLL_METHOD uint32_t DLL_CALL BU_IndexerV2_CountUsed(IndexerV2* indexer);
+DLL_FUNCTION(uint32_t) BU_IndexerV2_CountUsed(IndexerV2* indexer);
 #pragma comment(linker, "/EXPORT:BU_IndexerV2_CountUsed=_BU_IndexerV2_CountUsed@4")
 

Utility/MassOp.cpp

@@ -1,200 +1,182 @@
-//	Blitz - Steam wrapper for Blitz.
-//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
-//
-//	This program is free software: you can redistribute it and/or modify
-//	it under the terms of the GNU Lesser General Public License as
-//	published by the Free Software Foundation, either version 3 of the 
-//	License, or (at your option) any later version.
-//
-//	This program is distributed in the hope that it will be useful,
-//	but WITHOUT ANY WARRANTY; without even the implied warranty of
-//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//	GNU General Public License for more details.
-//
-//	You should have received a copy of the GNU Lesser General Public License
-//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-#pragma once
-#include "dllmain.h"
-#include "MassOp.h"
-
-MassOp::MassOp(uint32_t length) : length(length) {
-	this->instructions = new MassOpInstruction[length];
-}
-
-MassOp::~MassOp() {
-	delete this->instructions;
-}
-
-DLL_METHOD MassOp* DLL_CALL BU_MassOp_Create(uint32_t length) {
-	MassOp* myMassOp = new MassOp(length);
-	return myMassOp;
-}
-
-DLL_METHOD void DLL_CALL BU_MassOp_Destroy(MassOp* massop) {
-	delete massop;
-}
-
-DLL_METHOD void DLL_CALL BU_MassOp_Instruction(MassOp* massop, uint32_t index, MassOpType type, MassOpCode code, intptr_t leftOperand, intptr_t rightOperand, intptr_t result) {
-	massop->instructions[index].type = type;
-	massop->instructions[index].code = code;
-	massop->instructions[index].leftOperand = leftOperand;
-	massop->instructions[index].rightOperand = rightOperand;
-	massop->instructions[index].result = result;
-}
-
-DLL_METHOD void DLL_CALL BU_MassOp_Run(MassOp* massop) {
-	for (uint32_t index = 0; index < massop->length; index++) {
-		MassOpInstruction* instr = &massop->instructions[index];
-		switch (instr->code) {
-			case GoTo:
-				index = instr->leftOperand;
-				break;
-			case SetOpCode:
-				massop->instructions[instr->leftOperand].code = instr->rightOperand;
-				break;
-			case CopyLeft:
-				if (instr->leftOperand != instr->rightOperand) {
-					switch (instr->result) {
-						case 0:
-							massop->instructions[instr->rightOperand].leftOperand = massop->instructions[instr->leftOperand].leftOperand;
-							break;
-						case 1:
-							massop->instructions[instr->rightOperand].rightOperand = massop->instructions[instr->leftOperand].leftOperand;
-							break;
-						case 2:
-							massop->instructions[instr->rightOperand].result = massop->instructions[instr->leftOperand].leftOperand;
-							break;
-					}
-				}
-				break;
-			case CopyRight:
-				if (instr->leftOperand != instr->rightOperand) {
-					switch (instr->result) {
-						case 0:
-							massop->instructions[instr->rightOperand].leftOperand = massop->instructions[instr->leftOperand].rightOperand;
-							break;
-						case 1:
-							massop->instructions[instr->rightOperand].rightOperand = massop->instructions[instr->leftOperand].rightOperand;
-							break;
-						case 2:
-							massop->instructions[instr->rightOperand].result = massop->instructions[instr->leftOperand].rightOperand;
-							break;
-					}
-				}
-				break;
-			case CopyOut:
-				if (instr->leftOperand != instr->rightOperand) {
-					switch (instr->result) {
-						case 0:
-							massop->instructions[instr->rightOperand].leftOperand = massop->instructions[instr->leftOperand].result;
-							break;
-						case 1:
-							massop->instructions[instr->rightOperand].rightOperand = massop->instructions[instr->leftOperand].result;
-							break;
-						case 2:
-							massop->instructions[instr->rightOperand].result = massop->instructions[instr->leftOperand].result;
-							break;
-					}
-				}
-				break;
-			case If:
-				if (instr->leftOperand != instr->rightOperand) {
-					if (massop->instructions[instr->leftOperand].result == massop->instructions[instr->rightOperand].result) {
-						index += instr->result;
-					}
-				}
-				break;
-			case IfValue:
-				if (instr->leftOperand != instr->rightOperand) {
-					if (massop->instructions[instr->rightOperand].result == instr->rightOperand) {
-						index += instr->result;
-					}
-				}
-				break;
-			default:
-				switch (instr->type) {
-					case Double:
-						switch (instr->code) {
-							case Create:
-								instr->result = (uint32_t)BU_Double_Create();
-								break;
-							case Destroy:
-								BU_Double_Destroy((double_t*)instr->leftOperand);
-								break;
-							case Copy:
-								instr->result = (uint32_t)BU_Double_Copy((double_t*)instr->leftOperand);
-								break;
-							case TempCreate:
-								instr->result = (uint32_t)BU_Double_TempCreate();
-								break;
-							case TempCopy:
-								instr->result = (uint32_t)BU_Double_TempCopy((double_t*)instr->leftOperand);
-								break;
-							case TempCleanup:
-								BU_Double_TempCleanup();
-								break;
-							case Set:
-								BU_Double_Set((double_t*)instr->leftOperand, (double_t*)instr->rightOperand);
-								break;
-							case Add:
-								BU_Double_Add((double_t*)instr->leftOperand, (double_t*)instr->rightOperand);
-								break;
-							case Sub:
-								BU_Double_Sub((double_t*)instr->leftOperand, (double_t*)instr->rightOperand);
-								break;
-							case Mul:
-								BU_Double_Mul((double_t*)instr->leftOperand, (double_t*)instr->rightOperand);
-								break;
-							case Div:
-								BU_Double_Div((double_t*)instr->leftOperand, (double_t*)instr->rightOperand);
-								break;
-							case Compare:
-								instr->result = BU_Double_Compare((double_t*)instr->leftOperand, (double_t*)instr->rightOperand);
-								break;
-						}
-						break;
-					case LongLong:
-						switch (instr->code) {
-							case Create:
-								instr->result = (uint32_t)BU_LongLong_Create();
-								break;
-							case Destroy:
-								BU_LongLong_Destroy((int64_t*)instr->leftOperand);
-								break;
-							case Copy:
-								instr->result = (uint32_t)BU_LongLong_Copy((int64_t*)instr->leftOperand);
-								break;
-							case TempCreate:
-								instr->result = (uint32_t)BU_LongLong_TempCreate();
-								break;
-							case TempCopy:
-								instr->result = (uint32_t)BU_LongLong_TempCopy((int64_t*)instr->leftOperand);
-								break;
-							case TempCleanup:
-								BU_LongLong_TempCleanup();
-								break;
-							case Set:
-								BU_LongLong_Set((int64_t*)instr->leftOperand, (int64_t*)instr->rightOperand);
-								break;
-							case Add:
-								BU_LongLong_Add((int64_t*)instr->leftOperand, (int64_t*)instr->rightOperand);
-								break;
-							case Sub:
-								BU_LongLong_Sub((int64_t*)instr->leftOperand, (int64_t*)instr->rightOperand);
-								break;
-							case Mul:
-								BU_LongLong_Mul((int64_t*)instr->leftOperand, (int64_t*)instr->rightOperand);
-								break;
-							case Div:
-								BU_LongLong_Div((int64_t*)instr->leftOperand, (int64_t*)instr->rightOperand);
-								break;
-							case Compare:
-								instr->result = BU_LongLong_Compare((int64_t*)instr->leftOperand, (int64_t*)instr->rightOperand);
-								break;
-						}
-						break;
-				}
-		}
-	}
-}
+//	Blitz - Steam wrapper for Blitz.
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#pragma once
+#include "BlitzUtility.h"
+#include "MassOp.h"
+
+MassOp::MassOp(uint32_t length) : length(length) {
+	this->instructions = new MassOpInstruction[length];
+}
+
+MassOp::~MassOp() {
+	delete this->instructions;
+}
+
+DLL_FUNCTION(MassOp*) BU_MassOp_Create(uint32_t length) {
+	MassOp* myMassOp = new MassOp(length);
+	return myMassOp;
+}
+
+DLL_FUNCTION(void) BU_MassOp_Destroy(MassOp* massop) {
+	delete massop;
+}
+
+DLL_FUNCTION(void) BU_MassOp_Instruction(MassOp* massop, uint32_t index, MassOpType type, MassOpCode code, intptr_t leftOperand, intptr_t rightOperand, intptr_t result) {
+	massop->instructions[index].type = type;
+	massop->instructions[index].code = code;
+	massop->instructions[index].leftOperand = leftOperand;
+	massop->instructions[index].rightOperand = rightOperand;
+	massop->instructions[index].result = result;
+}
+
+DLL_FUNCTION(void) BU_MassOp_Run(MassOp* massop) {
+	for (uint32_t index = 0; index < massop->length; index++) {
+		MassOpInstruction* instr = &massop->instructions[index];
+		switch (instr->code) {
+			case GoTo:
+				index = instr->leftOperand;
+				break;
+			case SetOpCode:
+				massop->instructions[instr->leftOperand].code = instr->rightOperand;
+				break;
+			case CopyLeft:
+				if (instr->leftOperand != instr->rightOperand) {
+					switch (instr->result) {
+						case 0:
+							massop->instructions[instr->rightOperand].leftOperand = massop->instructions[instr->leftOperand].leftOperand;
+							break;
+						case 1:
+							massop->instructions[instr->rightOperand].rightOperand = massop->instructions[instr->leftOperand].leftOperand;
+							break;
+						case 2:
+							massop->instructions[instr->rightOperand].result = massop->instructions[instr->leftOperand].leftOperand;
+							break;
+					}
+				}
+				break;
+			case CopyRight:
+				if (instr->leftOperand != instr->rightOperand) {
+					switch (instr->result) {
+						case 0:
+							massop->instructions[instr->rightOperand].leftOperand = massop->instructions[instr->leftOperand].rightOperand;
+							break;
+						case 1:
+							massop->instructions[instr->rightOperand].rightOperand = massop->instructions[instr->leftOperand].rightOperand;
+							break;
+						case 2:
+							massop->instructions[instr->rightOperand].result = massop->instructions[instr->leftOperand].rightOperand;
+							break;
+					}
+				}
+				break;
+			case CopyOut:
+				if (instr->leftOperand != instr->rightOperand) {
+					switch (instr->result) {
+						case 0:
+							massop->instructions[instr->rightOperand].leftOperand = massop->instructions[instr->leftOperand].result;
+							break;
+						case 1:
+							massop->instructions[instr->rightOperand].rightOperand = massop->instructions[instr->leftOperand].result;
+							break;
+						case 2:
+							massop->instructions[instr->rightOperand].result = massop->instructions[instr->leftOperand].result;
+							break;
+					}
+				}
+				break;
+			case If:
+				if (instr->leftOperand != instr->rightOperand) {
+					if (massop->instructions[instr->leftOperand].result == massop->instructions[instr->rightOperand].result) {
+						index += instr->result;
+					}
+				}
+				break;
+			case IfValue:
+				if (instr->leftOperand != instr->rightOperand) {
+					if (massop->instructions[instr->rightOperand].result == instr->rightOperand) {
+						index += instr->result;
+					}
+				}
+				break;
+			default:
+				switch (instr->type) {
+					case Double:
+						switch (instr->code) {
+							case Create:
+								instr->result = (uint32_t) BU_Double_New();
+								break;
+							case Destroy:
+								BU_Double_Destroy((double_t*)instr->leftOperand);
+								break;
+							case Copy:
+								instr->result = (uint32_t) BU_Double_Copy((double_t*)instr->leftOperand);
+								break;
+							case Set:
+								BU_Double_Set((double_t*)instr->leftOperand, (double_t*)instr->rightOperand);
+								break;
+							case Add:
+								BU_Double_Add((double_t*)instr->leftOperand, (double_t*)instr->rightOperand);
+								break;
+							case Sub:
+								BU_Double_Sub((double_t*)instr->leftOperand, (double_t*)instr->rightOperand);
+								break;
+							case Mul:
+								BU_Double_Mul((double_t*)instr->leftOperand, (double_t*)instr->rightOperand);
+								break;
+							case Div:
+								BU_Double_Div((double_t*)instr->leftOperand, (double_t*)instr->rightOperand);
+								break;
+							case Compare:
+								instr->result = BU_Double_Compare((double_t*)instr->leftOperand, (double_t*)instr->rightOperand);
+								break;
+						}
+						break;
+					case Long:
+						switch (instr->code) {
+							case Create:
+								instr->result = (uint32_t) BU_Long_New();
+								break;
+							case Destroy:
+								BU_Long_Destroy((int64_t*)instr->leftOperand);
+								break;
+							case Copy:
+								instr->result = (uint32_t) BU_Long_Copy((int64_t*)instr->leftOperand);
+								break;
+							case Set:
+								BU_Long_Set((int64_t*)instr->leftOperand, (int64_t*)instr->rightOperand);
+								break;
+							case Add:
+								BU_Long_Add((int64_t*)instr->leftOperand, (int64_t*)instr->rightOperand);
+								break;
+							case Sub:
+								BU_Long_Sub((int64_t*)instr->leftOperand, (int64_t*)instr->rightOperand);
+								break;
+							case Mul:
+								BU_Long_Mul((int64_t*)instr->leftOperand, (int64_t*)instr->rightOperand);
+								break;
+							case Div:
+								BU_Long_Div((int64_t*)instr->leftOperand, (int64_t*)instr->rightOperand);
+								break;
+							case Compare:
+								instr->result = BU_Long_Compare((int64_t*)instr->leftOperand, (int64_t*)instr->rightOperand);
+								break;
+						}
+						break;
+				}
+		}
+	}
+}

Utility/MassOp.h

@@ -1,108 +1,107 @@
-//	Blitz - Steam wrapper for Blitz.
-//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
-//
-//	This program is free software: you can redistribute it and/or modify
-//	it under the terms of the GNU Lesser General Public License as
-//	published by the Free Software Foundation, either version 3 of the 
-//	License, or (at your option) any later version.
-//
-//	This program is distributed in the hope that it will be useful,
-//	but WITHOUT ANY WARRANTY; without even the implied warranty of
-//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//	GNU General Public License for more details.
-//
-//	You should have received a copy of the GNU Lesser General Public License
-//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-#pragma once
-#include "dllmain.h"
-#include "Type\Double.h"
-#include "Type\LongLong.h"
-
-enum MassOpType {
-	LongLong	= 0,
-	Double		= 1,
-
-	Vector2		= 10,
-	Vector3		= 11,
-};
-
-enum MassOpCode {
-	Create		= 0,
-	Destroy		= 1,
-	Copy		= 2,
-	TempCreate	= 5,
-	TempCopy	= 6,
-	TempCleanup	= 7,
-
-	Set			= 10,
-	Add			= 11,
-	Sub			= 12,
-	Mul			= 13,
-	Div			= 14,
-	Compare		= 15,
-
-	// Special OPCodes (Control MassOp)
-	// Goto - Go to a specific intruction
-	//  oper_l = target massop index
-	GoTo		= 249,
-	// SetOpCode - Change OpCode at position
-	//  oper_l = target massop index
-	//  oper_r = new OpCode
-	SetOpCode	= 250, 
-	// CopyLeft - Copy oper_l to new MassOp instruction.
-	//  oper_l = source massop index
-	//  oper_r = target massop index
-	//  out = target position (0/oper_l, 1/oper_r, 2/out)
-	CopyLeft	= 251,
-	// CopyRight - Copy oper_r to new MassOp instruction.
-	//  oper_l = source massop index
-	//  oper_r = target massop index
-	//  out = target position (0/oper_l, 1/oper_r, 2/out)
-	CopyRight	= 252,
-	// CopyOut - Copy out to new MassOp instruction.
-	//  oper_l = source massop index
-	//  oper_r = target massop index
-	//  out = target position (0/oper_l, 1/oper_r, 2/out)
-	CopyOut = 253,
-	// If - If the result of index oper_l is equal to index oper_r, skip out instructions.
-	//  oper_l = source massop index
-	//  oper_r = target massop index
-	//  out = instructions to skip
-	If = 254,
-	// IfValue - If the result of index oper_l is equal to oper_r, skip out instructions.
-	//  oper_l = source massop index
-	//  oper_r = value to compare with
-	//  out = instructions to skip
-	IfValue = 255
-};
-
-struct BlitzBank {
-	uint32_t identifier;
-	uint32_t address;
-	uint32_t size;
-};
-
-struct MassOpInstruction {
-	uint8_t type;
-	uint8_t code;
-	uint32_t leftOperand, rightOperand;
-	uint32_t result;
-};
-
-struct MassOp {
-	MassOp(uint32_t length);
-	~MassOp();
-
-	uint32_t length;
-	MassOpInstruction* instructions;
-};
-
-DLL_METHOD MassOp* DLL_CALL BU_MassOp_Create(uint32_t length);
-#pragma comment(linker, "/EXPORT:BU_MassOp_Create=_BU_MassOp_Create@4")
-DLL_METHOD void DLL_CALL BU_MassOp_Destroy(MassOp* massop);
-#pragma comment(linker, "/EXPORT:BU_MassOp_Destroy=_BU_MassOp_Destroy@4")
-DLL_METHOD void DLL_CALL BU_MassOp_Instruction(MassOp* massop, uint32_t index, MassOpType type, MassOpCode code, intptr_t leftOperand, intptr_t rightOperand, intptr_t result);
-#pragma comment(linker, "/EXPORT:BU_MassOp_Instruction=_BU_MassOp_Instruction@28")
-DLL_METHOD void DLL_CALL BU_MassOp_Run(MassOp* massop);
+//	Blitz - Steam wrapper for Blitz.
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#pragma once
+#include "BlitzUtility.h"
+#include "Type\Double.h"
+
+enum MassOpType {
+	Long = 0,
+	Double		= 1,
+
+	Vector2		= 10,
+	Vector3		= 11,
+};
+
+enum MassOpCode {
+	Create		= 0,
+	Destroy		= 1,
+	Copy		= 2,
+	TempCreate	= 5,
+	TempCopy	= 6,
+	TempCleanup	= 7,
+
+	Set			= 10,
+	Add			= 11,
+	Sub			= 12,
+	Mul			= 13,
+	Div			= 14,
+	Compare		= 15,
+
+	// Special OPCodes (Control MassOp)
+	// Goto - Go to a specific intruction
+	//  oper_l = target massop index
+	GoTo		= 249,
+	// SetOpCode - Change OpCode at position
+	//  oper_l = target massop index
+	//  oper_r = new OpCode
+	SetOpCode	= 250, 
+	// CopyLeft - Copy oper_l to new MassOp instruction.
+	//  oper_l = source massop index
+	//  oper_r = target massop index
+	//  out = target position (0/oper_l, 1/oper_r, 2/out)
+	CopyLeft	= 251,
+	// CopyRight - Copy oper_r to new MassOp instruction.
+	//  oper_l = source massop index
+	//  oper_r = target massop index
+	//  out = target position (0/oper_l, 1/oper_r, 2/out)
+	CopyRight	= 252,
+	// CopyOut - Copy out to new MassOp instruction.
+	//  oper_l = source massop index
+	//  oper_r = target massop index
+	//  out = target position (0/oper_l, 1/oper_r, 2/out)
+	CopyOut = 253,
+	// If - If the result of index oper_l is equal to index oper_r, skip out instructions.
+	//  oper_l = source massop index
+	//  oper_r = target massop index
+	//  out = instructions to skip
+	If = 254,
+	// IfValue - If the result of index oper_l is equal to oper_r, skip out instructions.
+	//  oper_l = source massop index
+	//  oper_r = value to compare with
+	//  out = instructions to skip
+	IfValue = 255
+};
+
+struct BlitzBank {
+	uint32_t identifier;
+	uint32_t address;
+	uint32_t size;
+};
+
+struct MassOpInstruction {
+	uint8_t type;
+	uint8_t code;
+	uint32_t leftOperand, rightOperand;
+	uint32_t result;
+};
+
+struct MassOp {
+	MassOp(uint32_t length);
+	~MassOp();
+
+	uint32_t length;
+	MassOpInstruction* instructions;
+};
+
+DLL_FUNCTION(MassOp*) BU_MassOp_Create(uint32_t length);
+#pragma comment(linker, "/EXPORT:BU_MassOp_Create=_BU_MassOp_Create@4")
+DLL_FUNCTION(void) BU_MassOp_Destroy(MassOp* massop);
+#pragma comment(linker, "/EXPORT:BU_MassOp_Destroy=_BU_MassOp_Destroy@4")
+DLL_FUNCTION(void) BU_MassOp_Instruction(MassOp* massop, uint32_t index, MassOpType type, MassOpCode code, intptr_t leftOperand, intptr_t rightOperand, intptr_t result);
+#pragma comment(linker, "/EXPORT:BU_MassOp_Instruction=_BU_MassOp_Instruction@28")
+DLL_FUNCTION(void) BU_MassOp_Run(MassOp* massop);
 #pragma comment(linker, "/EXPORT:BU_MassOp_Run=_BU_MassOp_Run@4")

Utility/ThreadWrapper.cpp

@@ -0,0 +1,53 @@
+//	BlitzUtility - Expanding the normal Blitz functionality.
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "ThreadWrapper.h"
+
+class ThreadWrapper {
+public:
+	ThreadWrapper(void* ptr, void* data) {
+		this->ptr = ptr;
+		this->data = data;
+	}
+	~ThreadWrapper() {
+
+	}
+
+	static int Core(ThreadWrapper* data) {
+		try {
+			BP_CallFunction1((BP_BlitzFunction1_t)data->ptr, reinterpret_cast<int32_t>(data->data));
+		} catch (const std::exception& e) {
+			std::stringstream ss;
+			ss << e.what();
+			MessageBoxA(0, ss.str().c_str(), "ThreadWrapper", 0);
+			throw;
+		}
+	}
+
+private:
+	void *ptr, *data;
+	std::exception lastException;
+};
+
+DLL_FUNCTION(ThreadWrapper*) BU_ThreadWrapper_Create(void* ptr, void* data) {
+#pragma comment(linker, "/EXPORT:BU_ThreadWrapper_Create=_BU_ThreadWrapper_Create@8")
+	return new ThreadWrapper(ptr, data);
+}
+
+DLL_FUNCTION(void) BU_ThreadWrapper_Destroy(ThreadWrapper* pThreadWrapper) {
+#pragma comment(linker, "/EXPORT:BU_ThreadWrapper_Destroy=_BU_ThreadWrapper_Destroy@4")
+	delete pThreadWrapper;
+}

Utility/ThreadWrapper.h

@@ -0,0 +1,22 @@
+//	Blitz - Steam wrapper for Blitz.
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#pragma once
+#include "BlitzUtility.h"
+
+// Types of Blitz Functions.
+typedef int32_t(__stdcall *BP_BlitzFunction1_t)(int32_t);
+int32_t BP_CallFunction1(BP_BlitzFunction1_t lpFunctionPointer, int32_t p1);

Utility/WindowMessageHandler.cpp

@@ -1,118 +1,118 @@
-//	BlitzUtility - Expanding the normal Blitz functionality.
-//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
-//
-//	This program is free software: you can redistribute it and/or modify
-//	it under the terms of the GNU Lesser General Public License as
-//	published by the Free Software Foundation, either version 3 of the 
-//	License, or (at your option) any later version.
-//
-//	This program is distributed in the hope that it will be useful,
-//	but WITHOUT ANY WARRANTY; without even the implied warranty of
-//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//	GNU General Public License for more details.
-//
-//	You should have received a copy of the GNU Lesser General Public License
-//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-#pragma once
-#include "WindowMessageHandler.h"
-
-std::list<WindowUserData>* WindowMessageHandler_List;
-
-void BU_WindowMessageHandler_OnProcessAttach() {
-	WindowMessageHandler_List = new std::list<WindowUserData>();
-}
-
-void BU_WindowMessageHandler_OnProcessDetach() {
-	for (auto iterator = WindowMessageHandler_List->begin(), end = WindowMessageHandler_List->end(); iterator != end; iterator++) {
-		BU_WindowMessageHandler_Uninstall(iterator->hwnd);
-	}
-
-	WindowMessageHandler_List->clear();
-	delete WindowMessageHandler_List;
-}
-
-LRESULT CALLBACK BU_WindowMessageHandler_Procedure(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
-	WindowUserData* UserData = (WindowUserData*)GetWindowLong(hwnd, GWL_USERDATA);
-	if (UserData) {
-		switch (uMsg) {
-			case WM_SIZE:
-				UserData->WindowWasResized = true;
-				UserData->WindowClientWidth = lParam & 0xFFFF;
-				UserData->WindowClientHeight = lParam & 0xFFFF0000 >> 16;
-
-				return CallWindowProc(UserData->oWindowProcedure, hwnd, uMsg, wParam, lParam);
-				break;
-			
-			case WM_CLOSE:
-				UserData->DestroyCount++;
-				return false;
-
-			case WM_DESTROY:
-				UserData->CloseCount++;
-				return false;
-
-			default:
-				return CallWindowProc(UserData->oWindowProcedure, hwnd, uMsg, wParam, lParam);
-		}
-	} else {
-		return DefWindowProc(hwnd, uMsg, wParam, lParam);
-	}
-}
-
-DLL_METHOD void DLL_CALL BU_WindowMessageHandler_Install(HWND hwnd)
-{
-	WindowUserData* UserData = new WindowUserData;
-	ZeroMemory(UserData, sizeof(UserData));
-	UserData->oWindowProcedure = (WNDPROC)SetWindowLong(hwnd, GWL_WNDPROC, (LONG)&BU_WindowMessageHandler_Procedure);
-	UserData->oUserData = SetWindowLong(hwnd, GWL_USERDATA, (LONG)UserData);
-}
-
-DLL_METHOD void DLL_CALL BU_WindowMessageHandler_Uninstall(HWND hwnd)
-{
-	WindowUserData* UserData = (WindowUserData*)GetWindowLong(hwnd, GWL_USERDATA);
-	if (UserData) {
-		SetWindowLong(hwnd, GWL_USERDATA, UserData->oUserData);
-		SetWindowLong(hwnd, GWL_WNDPROC, (LONG)(UserData->oWindowProcedure));
-		delete UserData;
-	}
-}
-
-DLL_METHOD uint32_t DLL_CALL BU_WindowMessageHandler_Message_Resize(HWND hwnd, LPPOINT point)
-{
-	WindowUserData* UserData = (WindowUserData*)GetWindowLong(hwnd, GWL_USERDATA);
-	if (UserData) {
-		int toReturn = UserData->WindowWasResized;
-		point->x = UserData->WindowClientWidth;
-		point->y = UserData->WindowClientHeight;
-		UserData->WindowWasResized = false;
-		return toReturn;
-	}
-	return FALSE;
-}
-
-DLL_METHOD uint32_t DLL_CALL BU_WindowMessageHandler_Message_Destroy(HWND hwnd)
-{
-	WindowUserData* UserData = (WindowUserData*)GetWindowLong(hwnd, GWL_USERDATA);
-	if (UserData) {
-		int toReturn = UserData->DestroyCount;
-		UserData->DestroyCount = 0;
-		return toReturn;
-	}
-	return 0;
-}
-
-DLL_METHOD uint32_t DLL_CALL BU_WindowMessageHandler_Message_Close(HWND hwnd)
-{
-	if (hwnd) {
-		WindowUserData* UserData = (WindowUserData*)GetWindowLong(hwnd, GWL_USERDATA);
-		if (UserData) {
-			int toReturn = UserData->CloseCount;
-			UserData->CloseCount = 0;
-			return toReturn;
-		}
-	}
-	return 0;
-}
-
-
+//	BlitzUtility - Expanding the normal Blitz functionality.
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#pragma once
+#include "WindowMessageHandler.h"
+
+std::list<WindowUserData>* WindowMessageHandler_List;
+
+void BU_WindowMessageHandler_OnProcessAttach() {
+	WindowMessageHandler_List = new std::list<WindowUserData>();
+}
+
+void BU_WindowMessageHandler_OnProcessDetach() {
+	for (auto iterator = WindowMessageHandler_List->begin(), end = WindowMessageHandler_List->end(); iterator != end; iterator++) {
+		BU_WindowMessageHandler_Uninstall(iterator->hwnd);
+	}
+
+	WindowMessageHandler_List->clear();
+	delete WindowMessageHandler_List;
+}
+
+LRESULT CALLBACK BU_WindowMessageHandler_Procedure(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
+	WindowUserData* UserData = (WindowUserData*)GetWindowLong(hwnd, GWL_USERDATA);
+	if (UserData) {
+		switch (uMsg) {
+			case WM_SIZE:
+				UserData->WindowWasResized = true;
+				UserData->WindowClientWidth = lParam & 0xFFFF;
+				UserData->WindowClientHeight = lParam & 0xFFFF0000 >> 16;
+
+				return CallWindowProc(UserData->oWindowProcedure, hwnd, uMsg, wParam, lParam);
+				break;
+			
+			case WM_CLOSE:
+				UserData->DestroyCount++;
+				return false;
+
+			case WM_DESTROY:
+				UserData->CloseCount++;
+				return false;
+
+			default:
+				return CallWindowProc(UserData->oWindowProcedure, hwnd, uMsg, wParam, lParam);
+		}
+	} else {
+		return DefWindowProc(hwnd, uMsg, wParam, lParam);
+	}
+}
+
+DLL_FUNCTION(void) BU_WindowMessageHandler_Install(HWND hwnd)
+{
+	WindowUserData* UserData = new WindowUserData;
+	ZeroMemory(UserData, sizeof(UserData));
+	UserData->oWindowProcedure = (WNDPROC)SetWindowLong(hwnd, GWL_WNDPROC, (LONG)&BU_WindowMessageHandler_Procedure);
+	UserData->oUserData = SetWindowLong(hwnd, GWL_USERDATA, (LONG)UserData);
+}
+
+DLL_FUNCTION(void) BU_WindowMessageHandler_Uninstall(HWND hwnd)
+{
+	WindowUserData* UserData = (WindowUserData*)GetWindowLong(hwnd, GWL_USERDATA);
+	if (UserData) {
+		SetWindowLong(hwnd, GWL_USERDATA, UserData->oUserData);
+		SetWindowLong(hwnd, GWL_WNDPROC, (LONG)(UserData->oWindowProcedure));
+		delete UserData;
+	}
+}
+
+DLL_FUNCTION(uint32_t) BU_WindowMessageHandler_Message_Resize(HWND hwnd, LPPOINT point)
+{
+	WindowUserData* UserData = (WindowUserData*)GetWindowLong(hwnd, GWL_USERDATA);
+	if (UserData) {
+		int toReturn = UserData->WindowWasResized;
+		point->x = UserData->WindowClientWidth;
+		point->y = UserData->WindowClientHeight;
+		UserData->WindowWasResized = false;
+		return toReturn;
+	}
+	return FALSE;
+}
+
+DLL_FUNCTION(uint32_t) BU_WindowMessageHandler_Message_Destroy(HWND hwnd)
+{
+	WindowUserData* UserData = (WindowUserData*)GetWindowLong(hwnd, GWL_USERDATA);
+	if (UserData) {
+		int toReturn = UserData->DestroyCount;
+		UserData->DestroyCount = 0;
+		return toReturn;
+	}
+	return 0;
+}
+
+DLL_FUNCTION(uint32_t) BU_WindowMessageHandler_Message_Close(HWND hwnd)
+{
+	if (hwnd) {
+		WindowUserData* UserData = (WindowUserData*)GetWindowLong(hwnd, GWL_USERDATA);
+		if (UserData) {
+			int toReturn = UserData->CloseCount;
+			UserData->CloseCount = 0;
+			return toReturn;
+		}
+	}
+	return 0;
+}
+
+

Utility/WindowMessageHandler.h

@@ -1,49 +1,49 @@
-//	BlitzUtility - Expanding the normal Blitz functionality.
-//	Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
-//
-//	This program is free software: you can redistribute it and/or modify
-//	it under the terms of the GNU Lesser General Public License as
-//	published by the Free Software Foundation, either version 3 of the 
-//	License, or (at your option) any later version.
-//
-//	This program is distributed in the hope that it will be useful,
-//	but WITHOUT ANY WARRANTY; without even the implied warranty of
-//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-//	GNU General Public License for more details.
-//
-//	You should have received a copy of the GNU Lesser General Public License
-//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-#pragma once
-#include "dllmain.h"
-#include <list>
-
-struct WindowUserData {
-	HWND hwnd;
-
-	WNDPROC oWindowProcedure;
-	LONG oUserData;
-	
-	// WM_SIZE
-	bool WindowWasResized;
-	uint32_t WindowClientWidth, WindowClientHeight;
-
-	// WM_DESTROY, WM_CLOSE
-	uint32_t DestroyCount, CloseCount;
-};
-
-
-void BU_WindowMessageHandler_OnProcessAttach();
-void BU_WindowMessageHandler_OnProcessDetach();
-LRESULT CALLBACK BU_WindowMessageHandler_Procedure(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
-
-DLL_METHOD void DLL_CALL BU_WindowMessageHandler_Install(HWND hwnd);
-#pragma comment(linker, "/EXPORT:BU_WindowMessageHandler_Install=_BU_WindowMessageHandler_Install@4")
-DLL_METHOD void DLL_CALL BU_WindowMessageHandler_Uninstall(HWND hwnd);
-#pragma comment(linker, "/EXPORT:BU_WindowMessageHandler_Uninstall=_BU_WindowMessageHandler_Uninstall@4")
-DLL_METHOD uint32_t DLL_CALL BU_WindowMessageHandler_Message_Resize(HWND hwnd, LPPOINT point);
-#pragma comment(linker, "/EXPORT:BU_WindowMessageHandler_Message_Resize=_BU_WindowMessageHandler_Message_Resize@8")
-DLL_METHOD uint32_t DLL_CALL BU_WindowMessageHandler_Message_Destroy(HWND hwnd);
-#pragma comment(linker, "/EXPORT:BU_WindowMessageHandler_Message_Destroy=_BU_WindowMessageHandler_Message_Destroy@4")
-DLL_METHOD uint32_t DLL_CALL BU_WindowMessageHandler_Message_Close(HWND hwnd);
+//	BlitzUtility - Expanding the normal Blitz functionality.
+//	Copyright (C) 2015 Xaymar (Michael Fabian Dirks)
+//
+//	This program is free software: you can redistribute it and/or modify
+//	it under the terms of the GNU Lesser General Public License as
+//	published by the Free Software Foundation, either version 3 of the 
+//	License, or (at your option) any later version.
+//
+//	This program is distributed in the hope that it will be useful,
+//	but WITHOUT ANY WARRANTY; without even the implied warranty of
+//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//	GNU General Public License for more details.
+//
+//	You should have received a copy of the GNU Lesser General Public License
+//	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#pragma once
+#include "BlitzUtility.h"
+#include <list>
+
+struct WindowUserData {
+	HWND hwnd;
+
+	WNDPROC oWindowProcedure;
+	LONG oUserData;
+	
+	// WM_SIZE
+	bool WindowWasResized;
+	uint32_t WindowClientWidth, WindowClientHeight;
+
+	// WM_DESTROY, WM_CLOSE
+	uint32_t DestroyCount, CloseCount;
+};
+
+
+void BU_WindowMessageHandler_OnProcessAttach();
+void BU_WindowMessageHandler_OnProcessDetach();
+LRESULT CALLBACK BU_WindowMessageHandler_Procedure(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
+
+DLL_FUNCTION(void) BU_WindowMessageHandler_Install(HWND hwnd);
+#pragma comment(linker, "/EXPORT:BU_WindowMessageHandler_Install=_BU_WindowMessageHandler_Install@4")
+DLL_FUNCTION(void) BU_WindowMessageHandler_Uninstall(HWND hwnd);
+#pragma comment(linker, "/EXPORT:BU_WindowMessageHandler_Uninstall=_BU_WindowMessageHandler_Uninstall@4")
+DLL_FUNCTION(uint32_t) BU_WindowMessageHandler_Message_Resize(HWND hwnd, LPPOINT point);
+#pragma comment(linker, "/EXPORT:BU_WindowMessageHandler_Message_Resize=_BU_WindowMessageHandler_Message_Resize@8")
+DLL_FUNCTION(uint32_t) BU_WindowMessageHandler_Message_Destroy(HWND hwnd);
+#pragma comment(linker, "/EXPORT:BU_WindowMessageHandler_Message_Destroy=_BU_WindowMessageHandler_Message_Destroy@4")
+DLL_FUNCTION(uint32_t) BU_WindowMessageHandler_Message_Close(HWND hwnd);
 #pragma comment(linker, "/EXPORT:BU_WindowMessageHandler_Message_Close=_BU_WindowMessageHandler_Message_Close@4")