Latest Changes

Signed-off-by: Michael Dirks <michael.fabian.dirks@gmail.com>

BlitzUtility.bb

@@ -1,6 +1,329 @@
-;----------------------------------------------------------------
+;	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
@@ -12,9 +335,7 @@ Function Vector2_Create.Vector2(X#, Y#)
 	Return vec
 End Function
 
-;----------------------------------------------------------------
 ;-- Vector3
-;----------------------------------------------------------------
 Type Vector3
 	Field X#, Y#, Z#
 End Type
@@ -27,206 +348,6 @@ Function Vector3_Create.Vector3(X#, Y#, Z#)
 	Return vec
 End Function
 
-;----------------------------------------------------------------
-;-- 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
-
-;----------------------------------------------------------------
-;-- Helpers
-;----------------------------------------------------------------
-Type BlitzUtility_Rectangle
-	Field X,Y,X2,Y2
-End Type
-
-Type BlitzUtility_Point
-	Field X,Y
-End Type
-
-Global BlitzUtility_Rect.BlitzUtility_Rectangle = New BlitzUtility_Rectangle
-Global BlitzUtility_Point.BlitzUtility_Point = New BlitzUtility_Point
-
-Function BlitzUtility_LockPointerToWindow(hwnd=0)
-	If hwnd = 0 Then
-		BlitzUtility_User32_ClipCursorI(0)
-	Else
-		BlitzUtility_User32_GetWindowRect(hwnd, BlitzUtility_Rect)
-
-		;Grab TopLeft
-		BlitzUtility_Point\X = BlitzUtility_Rect\X
-		BlitzUtility_Point\Y = BlitzUtility_Rect\Y
-		BlitzUtility_Rect\X = BlitzUtility_Point\X
-		BlitzUtility_Rect\Y = BlitzUtility_Point\Y
-		
-		;Grab BottomRight
-		BlitzUtility_Point\X = BlitzUtility_Rect\X2 - 1
-		BlitzUtility_Point\Y = BlitzUtility_Rect\Y2 - 1
-		BlitzUtility_Rect\X2 = BlitzUtility_Point\X
-		BlitzUtility_Rect\Y2 = BlitzUtility_Point\Y
-		
-		BlitzUtility_User32_ClipCursor(BlitzUtility_Rect)
-	EndIf
-End Function
-
-Function BlitzUtility_LockPointerToWindowAuto(hwnd=0)
-	If BlitzUtility_User32_GetActiveWindow() = hwnd Then
-		BlitzUtility_LockPointerToWindow(hwnd)
-	Else
-		BlitzUtility_LockPointerToWindow(0)
-	EndIf
-End Function
-
-Function BlitzUtility_BorderlessWindowmode(hwnd=0, MonitorId=0, Width=0, Height=0)
-	If hwnd = 0 Then hwnd = SystemProperty("AppHwnd")
-	
-	BlitzUtility_EnumerateDisplays()
-	Local dispCnt = BlitzUtility_GetDisplayCount()
-	If MonitorId < 0 Then MonitorId = 0
-	If MonitorId >= dispCnt Then MonitorId = dispCnt - 1
-	
-	Local rct.BlitzUtility_Rectangle = New BlitzUtility_Rectangle
-	BlitzUtility_GetDisplay(MonitorId, rct)
-	Local rctW, rctH
-	rctW = (rct\X2 - rct\X)
-	rctH = (rct\Y2 - rct\Y)
-	
-	
-	rct\X = rct\X + (rctW / 2.0) - Width / 2.0
-	rct\Y = rct\Y + (rctH / 2.0) - Height / 2.0
-	rct\X2 = Width
-	rct\Y2 = Height
-	BlitzUtility_User32_SetWindowLong hwnd, -16, $01000000
-	BlitzUtility_User32_SetWindowPos hwnd, 0, rct\X, rct\Y, rct\X2, rct\Y2, 64
-	Delete rct
-End Function
-
-Function FlushFile(File%)
-	Return BlitzUtility_Kernel32_FlushFileBuffers(File)
-End Function
 
 ;~IDEal Editor Parameters:
-;~F#20#46#54
 ;~C#Blitz3D

BlitzUtility.decls

@@ -1,224 +1,171 @@
-.lib "User32.dll"
-BlitzUtility_User32_ClientToScreen%(hwnd%, point*)										: "ClientToScreen"
-BlitzUtility_User32_ClipCursor%(rect*)													: "ClipCursor"
-BlitzUtility_User32_ClipCursorI%(ptr%)													: "ClipCursor"
-BlitzUtility_User32_GetActiveWindow%()													: "GetActiveWindow"
-BlitzUtility_User32_GetSystemMetrics%(index%)											: "GetSystemMetrics"
-BlitzUtility_User32_SetWindowLong%(hwnd%, nIndex%, dwNewLong%)							: "SetWindowLongA"
-BlitzUtility_User32_GetWindowLong%(hwnd%, index%)										: "GetWindowLongA"
-BlitzUtility_User32_GetWindowRect%(hwnd%, rect*)										: "GetWindowRect"
-BlitzUtility_User32_GetClientRect%(hwnd%, rect*)										: "GetClientRect"
-BlitzUtility_User32_SetWindowPos%(hwnd%, hWndInsertAfter%, x%, y%, cx%, cy%, wFlags%)	: "SetWindowPos" 
-
-.lib "Kernel32.dll"
-BlitzUtility_Kernel32_FlushFileBuffers%(hFile%)											: "FlushFileBuffers"
+;	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"
-; Containers - BlitzList
-BU_BlitzList_New%(obj*)																	: "BlitzList_New"
-BU_BlitzList_Activate(list%)															: "BlitzList_Activate"
-BU_BlitzList_Deactivate(list%)															: "BlitzList_Deactivate"
-BU_BlitzList_Destroy(list%)																: "BlitzList_Delete"
-; Containers - BlitzList - Backward Compatability
-BlitzUtility_List_New%(obj*)															: "BlitzList_New"
-BlitzUtility_List_Activate(list%)														: "BlitzList_Activate"
-BlitzUtility_List_Deactivate(list%)														: "BlitzList_Deactivate"
-BlitzUtility_List_Destroy(list%)														: "BlitzList_Delete"
+; 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%)
 
-; Database - SQLite3
-SQLite3_LibVersion$()																	: "sqlite3_libversion"
-; Opening and Closing ------------------------------------------------
-SQLite3_Open%(Filename$, DatabaseHandle*)												: "sqlite3_open"
-SQLite3_Open_V2%(Filename$, DatabaseHandle*, Flags%, VFS%)								: "sqlite3_open_v2"
-SQLite3_Close%(DatabaseHandle)															: "sqlite3_close"
-; Misc ---------------------------------------------------------------
-SQLite3_Busy_TimeOut%(DatabaseHandle, TimeOut)											: "sqlite3_busy_timeout"
-SQLite3_Get_AutoCommit%(DatabaseHandle)													: "sqlite3_get_autocommit"
-SQLite3_Interrupt(DatabaseHandle)														: "sqlite3_interrupt"
-; Errors -------------------------------------------------------------
-SQLite3_ErrCode%(DatabaseHandle)														: "sqlite3_errcode"
-SQLite3_ErrMsg$(DatabaseHandle)															: "sqlite3_errmsg"
-; Executing SQL without results --------------------------------------
-; As Blitz3D doesn't have function pointers the CallBack is pointless
-; and this can only really be used for result-less SQL statements.
-; Also, I've never got the Error return to work. So just pass in
-; zeros for the last three parameters and use SQLite3_ErrMsg if you
-; need to get the error message.
-SQLite3_Exec%(DatabaseHandle, SQL$, CallBack, FirstParam, Error)						: "sqlite3_exec"
-SQLite3_Changes%(DatabaseHandle)														: "sqlite3_changes"
-SQLite3_Total_Changes%(DatabaseHandle)													: "sqlite3_total_changes"
-SQLite3_Last_Insert_RowID%(DatabaseHandle)												: "sqlite3_last_insert_rowid"
-; Executing SQL with results -----------------------------------------
-; Never got the SQLTail to work so just pass in a zero.
-SQLite3_Prepare%(DatabaseHandle, SQL$, LengthOfSQL, StatementHandle*, SQLTail)			: "sqlite3_prepare"
-SQLite3_Step%(StatementHandle)															: "sqlite3_step"
-SQLite3_Reset%(StatementHandle)															: "sqlite3_reset"
-SQLite3_Finalize%(StatementHandle)														: "sqlite3_finalize"
-SQLite3_Data_Count%(StatementHandle)													: "sqlite3_data_count"
-SQLite3_DB_Handle%(StatementHandle)														: "sqlite3_db_handle"
-; SQL Parameter Binding ----------------------------------------------
-SQLite3_Bind_Parameter_Count%(StatementHandle)											: "sqlite3_bind_parameter_count"
-SQLite3_Bind_Parameter_Index%(StatementHandle, ParameterName$)							: "sqlite3_bind_parameter_index"
-SQLite3_Bind_Parameter_Name$(StatementHandle, ParameterIndex)							: "sqlite3_bind_parameter_name"
-; Never tested this for real, but it should work.
-SQLite3_Transfer_Bindings%(StatementHandle1, StatementHandle2)							: "sqlite3_transfer_bindings"
-SQLite3_Bind_Null%(StatementHandle, Index)												: "sqlite3_bind_null"
-SQLite3_Bind_Int%(StatementHandle, Index, Value)										: "sqlite3_bind_int"
-; If you pass -1 for LengthOfText it will work it out for itself. Pass a zero in for Destructor.
-SQLite3_Bind_Text%(StatementHandle, Index, Value$, LengthOfText, Destructor)			: "sqlite3_bind_text"
-; Never tried this so it probably won't work. Pass a zero in for Destructor.
-SQLite3_Bind_Blob%(StatementHandle, Index, Value, LengthOfBlob, Destructor)				: "sqlite3_bind_blob"
-; Doesn't seem to work unfortunately.
-SQLite3_Bind_Double%(StatementHandle, Index, Value#)									: "sqlite3_bind_double"
-; Helpers
-SQLite3_Bind_Int64%(StatementHandle, Index, Left, Right)								: "sqlite3_bind_int64_ex"
-SQLite3_Bind_Float%(StatementHandle, Index, Value#)										: "sqlite3_bind_float"
-; Getting values from executed SQL  ----------------------------------
-SQLite3_Column_Count%(StatementHandle)													: "sqlite3_column_count"
-SQLite3_Column_Name$(StatementHandle, ColumnIndex)										: "sqlite3_column_name"
-SQLite3_Column_Type%(StatementHandle, ColumnIndex)										: "sqlite3_column_type"
-SQLite3_Column_DeclType$(StatementHandle, ColumnIndex)									: "sqlite3_column_decltype"
-SQLite3_Column_Int%(StatementHandle, ColumnIndex)										: "sqlite3_column_int"
-SQLite3_Column_Double#(StatementHandle, ColumnIndex)									: "sqlite3_column_double"
-SQLite3_Column_Text$(StatementHandle, ColumnIndex)										: "sqlite3_column_text"
-SQLite3_Column_Bytes%(StatementHandle, ColumnIndex)										: "sqlite3_column_bytes"
-; Never tried this so it probably won't work.
-SQLite3_Column_Blob%(StatementHandle, ColumnIndex)										: "sqlite3_column_blob"
-; Helpers
-SQLite3_Column_Int64(StatementHandle, ColumnIndex, outPtr*)								: "sqlite3_column_int64_ex"
-SQLite3_Column_Float#(StatementHandle, ColumnIndex)										: "sqlite3_column_float"
-; Helpers ------------------------------------------------------------
-SQLite_Version$()																		: "sqlite3_libversion"
-SQLite_Close%(DatabaseHandle)															: "sqlite3_close"
-SQLite_SetTimeOut%(DatabaseHandle, TimeOut)												: "sqlite3_busy_timeout"
-SQLite_Get_AutoCommit%(DatabaseHandle)													: "sqlite3_get_autocommit"
-SQLite_Interrupt(DatabaseHandle)														: "sqlite3_interrupt"
-SQLite_ErrCode%(DatabaseHandle)															: "sqlite3_errcode"
-SQLite_ErrMsg$(DatabaseHandle)															: "sqlite3_errmsg"
-SQLite_Changes%(DatabaseHandle)															: "sqlite3_changes"
-SQLite_Total_Changes%(DatabaseHandle)													: "sqlite3_total_changes"
-SQLite_Last_Insert_RowID%(DatabaseHandle)												: "sqlite3_last_insert_rowid"
-SQLite_Step%(StatementHandle)															: "sqlite3_step"
-SQLite_Reset%(StatementHandle)															: "sqlite3_reset"
-SQLite_Finalize%(StatementHandle)														: "sqlite3_finalize"
-SQLite_Data_Count%(StatementHandle)														: "sqlite3_data_count"
-SQLite_DB_Handle%(StatementHandle)														: "sqlite3_db_handle"
-SQLite_Bind_Parameter_Count%(StatementHandle)											: "sqlite3_bind_parameter_count"
-SQLite_Bind_Parameter_Index%(StatementHandle, ParameterName$)							: "sqlite3_bind_parameter_index"
-SQLite_Bind_Parameter_Name$(StatementHandle, ParameterIndex)							: "sqlite3_bind_parameter_name"
-SQLite_Transfer_Bindings%(StatementHandle1, StatementHandle2)							: "sqlite3_transfer_bindings"
-SQLite_Bind_Null%(StatementHandle, Index)												: "sqlite3_bind_null"
-SQLite_Bind_Int%(StatementHandle, Index, Value)											: "sqlite3_bind_int"
-SQLite_Bind_Int64%(StatementHandle, Index, Left, Right)									: "sqlite3_bind_int64_ex"
-;SQLite_Bind_Text%(StatementHandle, Index, Value$, LengthOfText, Destructor)				: "sqlite3_bind_text"
-;SQLite_Bind_Blob%(StatementHandle, Index, Value, LengthOfBlob, Destructor)				: "sqlite3_bind_blob"
-SQLite_Bind_Double%(StatementHandle, Index, Value#)										: "sqlite3_bind_double"
-SQLite_Bind_Float%(StatementHandle, Index, Value#)										: "sqlite3_bind_float"
-SQLite_Column_Count%(StatementHandle)													: "sqlite3_column_count"
-SQLite_Column_Name$(StatementHandle, ColumnIndex)										: "sqlite3_column_name"
-SQLite_Column_Type%(StatementHandle, ColumnIndex)										: "sqlite3_column_type"
-SQLite_Column_DeclType$(StatementHandle, ColumnIndex)									: "sqlite3_column_decltype"
-SQLite_Column_Int%(StatementHandle, ColumnIndex)										: "sqlite3_column_int"
-SQLite_Column_Double#(StatementHandle, ColumnIndex)										: "sqlite3_column_double"
-SQLite_Column_Text$(StatementHandle, ColumnIndex)										: "sqlite3_column_text"
-SQLite_Column_Bytes%(StatementHandle, ColumnIndex)										: "sqlite3_column_bytes"
-SQLite_Column_Blob%(StatementHandle, ColumnIndex)										: "sqlite3_column_blob"
-SQLite_Column_Float#(StatementHandle, ColumnIndex)										: "sqlite3_column_float"
+; 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$)
 
-; Math - Vector2
-Vector2_Set(vector*, value#)															: "Vector2_Set"
-Vector2_SetP(vector*, x#, y#)															: "Vector2_SetP"
-Vector2_SetV(vector*, other*)															: "Vector2_SetV"
-Vector2_Add(vector*, value#)															: "Vector2_Add"
-Vector2_AddP(vector*, x#, y#)															: "Vector2_AddP"
-Vector2_AddV(vector*, other*)															: "Vector2_AddV"
-Vector2_Sub(vector*, value#)															: "Vector2_Sub"
-Vector2_SubP(vector*, x#, y#)															: "Vector2_SubP"
-Vector2_SubV(vector*, other*)															: "Vector2_SubV"
-Vector2_Mul(vector*, value#)															: "Vector2_Mul"
-Vector2_MulP(vector*, x#, y#)															: "Vector2_MulP"
-Vector2_MulV(vector*, other*)															: "Vector2_MulV"
-Vector2_Div(vector*, value#)															: "Vector2_Div"
-Vector2_DivP(vector*, x#, y#)															: "Vector2_DivP"
-Vector2_DivV(vector*, other*)															: "Vector2_DivV"
-Vector2_Length#(vector*)																: "Vector2_Length"
-Vector2_DistanceP#(vector*, x#, y#)														: "Vector2_DistanceP"
-Vector2_DistanceV#(vector*, other*)														: "Vector2_DistanceV"
-Vector2_DotP#(vector*, x#, y#)															: "Vector2_DotP"
-Vector2_DotV#(vector*, other*)															: "Vector2_DotV"
-Vector2_Normalize(vector*)																: "Vector2_Normalize"
-Vector2_Rotate(vector*, rotation#)														: "Vector2_Rotate"
-Vector2_RotateAroundP(vector*, x#, y#, rotation#)										: "Vector2_RotateAroundP"
-Vector2_RotateAroundV(vector*, other*, rotation#)										: "Vector2_RotateAroundV"
-Vector2_DeltaRotation#(vector*)															: "Vector2_DeltaRotation"
-Vector2_DeltaRotationP#(vector*, x#, y#)												: "Vector2_DeltaRotationP"
-Vector2_DeltaRotationV#(vector*, other*)												: "Vector2_DeltaRotationV"
-Vector2_Serialize$(vector*)																: "Vector2_Serialize"
-Vector2_Deserialize(vector*, serial$)													: "Vector2_Deserialize"
+; 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*)
 
-; Math - Vector3
-Vector3_Set(vector*, value#)															: "Vector3_Set"
-Vector3_SetP(vector*, x#, y#, z#)														: "Vector3_SetP"
-Vector3_SetV(vector*, other*)															: "Vector3_SetV"
-Vector3_Add(vector*, value#)															: "Vector3_Add"
-Vector3_AddP(vector*, x#, y#, z#)														: "Vector3_AddP"
-Vector3_AddV(vector*, other*)															: "Vector3_AddV"
-Vector3_Sub(vector*, value#)															: "Vector3_Sub"
-Vector3_SubP(vector*, x#, y#, z#)														: "Vector3_SubP"
-Vector3_SubV(vector*, other*)															: "Vector3_SubV"
-Vector3_Mul(vector*, value#)															: "Vector3_Mul"
-Vector3_MulP(vector*, x#, y#, z#)														: "Vector3_MulP"
-Vector3_MulV(vector*, other*)															: "Vector3_MulV"
-Vector3_Div(vector*, value#)															: "Vector3_Div"
-Vector3_DivP(vector*, x#, y#, z#)														: "Vector3_DivP"
-Vector3_DivV(vector*, other*)															: "Vector3_DivV"
-Vector3_Length#(vector*)																: "Vector3_Length"
-Vector3_DistanceP#(vector*, x#, y#, z#)													: "Vector3_DistanceP"
-Vector3_DistanceV#(vector*, other*)														: "Vector3_DistanceV"
-Vector3_DotP#(vector*, x#, y#, z#)														: "Vector3_DotP"
-Vector3_DotV#(vector*, other*)															: "Vector3_DotV"
-Vector3_CrossP(vector*, x#, y#, z#, out*)												: "Vector3_CrossP"
-Vector3_CrossV(vector*, other*, out*)													: "Vector3_CrossV"
-Vector3_Normalize(vector*)																: "Vector3_Normalize"
-Vector3_Rotate(vector*, pitch#, yaw#, roll#)											: "Vector3_Rotate"
-Vector3_RotateAroundP(vector*, x#, y#, z#, pitch#, yaw#, roll#)							: "Vector3_RotateAroundP"
-Vector3_RotateAroundV(vector*, other*, pitch#, yaw#, roll#)								: "Vector3_RotateAroundV"
-Vector3_DeltaPitch#(vector*)															: "Vector3_DeltaPitch"
-Vector3_DeltaPitchP#(vector*, x#, y#, z#)												: "Vector3_DeltaPitchP"
-Vector3_DeltaPitchV#(vector*, other*)													: "Vector3_DeltaPitchV"
-Vector3_DeltaYaw#(vector*)																: "Vector3_DeltaYaw"
-Vector3_DeltaYawP#(vector*, x#, y#, z#)													: "Vector3_DeltaYawP"
-Vector3_DeltaYawV#(vector*, other*)														: "Vector3_DeltaYawV"
-Vector3_Serialize$(vector*)																: "Vector3_Serialize"
-Vector3_Deserialize(vector*, serial$)													: "Vector3_Deserialize"
-
-; Utility - Displays
-BU_Display_Enumerate()																	: "Display_Enumerate"
-BU_Display_Count%()																		: "Display_Count"
-BU_Display_Get(id%, rectangle*)															: "Display_Get"
-; Utility - Displays - Backward Compatability
-BlitzUtility_EnumerateDisplays()														: "Display_Enumerate"
-BlitzUtility_GetDisplayCount%()															: "Display_Count"
-BlitzUtility_GetDisplay(id%, rectangle*)												: "Display_Get"
-
-; Utility - Indexing
-BU_Indexer_Create%()																	: "Indexer_Create"
-BU_Indexer_GetFreeIndex%(indexer%)														: "Indexer_GetFreeIndex"
-BU_Indexer_MarkFreeIndex(indexer%, index%)												: "Indexer_MarkFreeIndex"
-BU_Indexer_Destroy(indexer%)															: "Indexer_Destroy"
-; Utility - Indexing - Backward Compatability
-Indexer_Create%()																		: "Indexer_Create"
-Indexer_GetFreeIndex%(indexer%)															: "Indexer_GetFreeIndex"
-Indexer_MarkFreeIndex(indexer%, index%)													: "Indexer_MarkFreeIndex"
-Indexer_Destroy(indexer%)																: "Indexer_Destroy"
-
-; Utility - Window Messages
-BU_WindowMessageHandler_InstallHandler(hwnd%)											: "WindowMessageHandler_Install"
-BU_WindowMessageHandler_UninstallHandler(hwnd%)											: "WindowMessageHandler_Uninstall"
-BU_WindowMessageHandler_Message_Close%(hwnd%)											: "WindowMessageHandler_Message_Close"
-BU_WindowMessageHandler_Message_Destroy%(hwnd%)											: "WindowMessageHandler_Message_Destroy"
-BU_WindowMessageHandler_Message_Resize%(hwnd%, point*)									: "WindowMessageHandler_Message_Resize"
-; Utility - Window Messages - Backward Compatability
-BlitzUtility_InstallCloseHandler(hwnd%)													: "WindowMessageHandler_InstallHandler"
-BlitzUtility_UninstallCloseHandler(hwnd%)												: "WindowMessageHandler_UninstallHandler"
-BlitzUtility_GetCloseCount%(hwnd%)														: "WindowMessageHandler_CountCloseMessages"
+; 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.vcxproj

@@ -1,171 +1,194 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup Label="ProjectConfigurations">
-    <ProjectConfiguration Include="Debug|Win32">
-      <Configuration>Debug</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|Win32">
-      <Configuration>Release</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-  </ItemGroup>
-  <PropertyGroup Label="Globals">
-    <ProjectGuid>{C08C5F9A-0C63-4798-A93F-FE96C014074B}</ProjectGuid>
-    <RootNamespace>BlitzUtility</RootNamespace>
-  </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>
-    <CharacterSet>Unicode</CharacterSet>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
-    <ConfigurationType>DynamicLibrary</ConfigurationType>
-    <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
-    <WholeProgramOptimization>false</WholeProgramOptimization>
-    <CharacterSet>Unicode</CharacterSet>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
-  <ImportGroup Label="ExtensionSettings">
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </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>
-    <IncludePath>$(ProjectDir);$(VC_IncludePath);$(WindowsSDK_IncludePath);</IncludePath>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <OutDir>$(SolutionDir)\#Build\$(ProjectName)\$(Configuration)\</OutDir>
-    <IntDir>$(SolutionDir)\#Intermediate\$(ProjectName)\$(Configuration)\</IntDir>
-    <LinkIncremental>true</LinkIncremental>
-    <IncludePath>$(ProjectDir);$(VC_IncludePath);$(WindowsSDK_IncludePath);</IncludePath>
-  </PropertyGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <ClCompile>
-      <WarningLevel>Level3</WarningLevel>
-      <Optimization>Disabled</Optimization>
-      <SDLCheck>
-      </SDLCheck>
-      <AdditionalIncludeDirectories>$(SolutionDir);$(ProjectDir)</AdditionalIncludeDirectories>
-      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
-      <PreprocessorDefinitions>SQLITE_ENABLE_FTS4;SQLITE_ENABLE_RTREE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <BasicRuntimeChecks>Default</BasicRuntimeChecks>
-      <StructMemberAlignment>4Bytes</StructMemberAlignment>
-      <BufferSecurityCheck>false</BufferSecurityCheck>
-      <ForcedIncludeFiles>
-      </ForcedIncludeFiles>
-      <OpenMPSupport>false</OpenMPSupport>
-      <RuntimeTypeInfo>false</RuntimeTypeInfo>
-      <CreateHotpatchableImage>false</CreateHotpatchableImage>
-      <FunctionLevelLinking>false</FunctionLevelLinking>
-      <EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
-      <MultiProcessorCompilation>false</MultiProcessorCompilation>
-      <CompileAsManaged>false</CompileAsManaged>
-      <MinimalRebuild>false</MinimalRebuild>
-      <CompileAsWinRT>false</CompileAsWinRT>
-      <CallingConvention>StdCall</CallingConvention>
-    </ClCompile>
-    <Link>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <Version>1.0</Version>
-      <LinkStatus>
-      </LinkStatus>
-    </Link>
-    <CustomBuildStep>
-      <Message>Copying Resources</Message>
-    </CustomBuildStep>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <ClCompile>
-      <WarningLevel>Level3</WarningLevel>
-      <Optimization>Full</Optimization>
-      <IntrinsicFunctions>true</IntrinsicFunctions>
-      <SDLCheck>
-      </SDLCheck>
-      <AdditionalIncludeDirectories>$(SolutionDir);$(ProjectDir)</AdditionalIncludeDirectories>
-      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>
-      <PreprocessorDefinitions>SQLITE_ENABLE_FTS4;SQLITE_ENABLE_RTREE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
-      <StructMemberAlignment>4Bytes</StructMemberAlignment>
-      <BufferSecurityCheck>false</BufferSecurityCheck>
-      <ForcedIncludeFiles>
-      </ForcedIncludeFiles>
-      <BasicRuntimeChecks>Default</BasicRuntimeChecks>
-      <OpenMPSupport>false</OpenMPSupport>
-      <RuntimeTypeInfo>false</RuntimeTypeInfo>
-      <CreateHotpatchableImage>false</CreateHotpatchableImage>
-      <MinimalRebuild>false</MinimalRebuild>
-      <FunctionLevelLinking>false</FunctionLevelLinking>
-      <EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
-      <MultiProcessorCompilation>false</MultiProcessorCompilation>
-      <CompileAsManaged>false</CompileAsManaged>
-      <CompileAsWinRT>false</CompileAsWinRT>
-      <CallingConvention>StdCall</CallingConvention>
-    </ClCompile>
-    <Link>
-      <GenerateDebugInformation>false</GenerateDebugInformation>
-      <EnableCOMDATFolding>
-      </EnableCOMDATFolding>
-      <OptimizeReferences>
-      </OptimizeReferences>
-      <Version>1.0</Version>
-      <LinkStatus>
-      </LinkStatus>
-    </Link>
-    <CustomBuildStep>
-      <Message>Copying Resources</Message>
-    </CustomBuildStep>
-  </ItemDefinitionGroup>
-  <ItemGroup>
-    <ClInclude Include="dllmain.h" />
-    <ClInclude Include="Containers\BlitzList.h" />
-    <ClInclude Include="Utility\Indexer.h" />
-    <ClInclude Include="Database\SQLite\SQLite.h" />
-    <ClInclude Include="Database\SQLite\sqlite3.h" />
-    <ClInclude Include="Math\Matrix3.h" />
-    <ClInclude Include="Math\Vector2.h" />
-    <ClInclude Include="Math\Vector3.h" />
-    <ClInclude Include="Utility\Display.h" />
-    <ClInclude Include="Utility\WindowMessageHandler.h" />
-  </ItemGroup>
-  <ItemGroup>
-    <ClCompile Include="Containers\BlitzList.cpp" />
-    <ClCompile Include="Database\SQLite\sqlite3.c">
-      <CallingConvention Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Cdecl</CallingConvention>
-      <CompileAs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">CompileAsC</CompileAs>
-      <CallingConvention Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Cdecl</CallingConvention>
-      <CompileAs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">CompileAsC</CompileAs>
-    </ClCompile>
-    <ClCompile Include="Utility\Indexer.cpp" />
-    <ClCompile Include="Database\SQLite\SQLite.cpp" />
-    <ClCompile Include="Math\Matrix3.cpp" />
-    <ClCompile Include="Math\Vector3.cpp" />
-    <ClCompile Include="Math\Vector2.cpp" />
-    <ClCompile Include="dllmain.cpp" />
-    <ClCompile Include="Utility\Display.cpp" />
-    <ClCompile Include="Utility\WindowMessageHandler.cpp" />
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="BlitzUtility.bb">
-      <Link>BlitzUtility.bb</Link>
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </None>
-    <None Include="BlitzUtility.decls">
-      <Link>BlitzUtility.decls</Link>
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </None>
-  </ItemGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <ImportGroup Label="ExtensionTargets">
-  </ImportGroup>
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="12.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>{C08C5F9A-0C63-4798-A93F-FE96C014074B}</ProjectGuid>
+    <RootNamespace>BlitzUtility</RootNamespace>
+  </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>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v120</PlatformToolset>
+    <WholeProgramOptimization>false</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </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>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <OutDir>$(SolutionDir)\#Build\$(ProjectName)\$(Configuration)\</OutDir>
+    <IntDir>$(SolutionDir)\#Intermediate\$(ProjectName)\$(Configuration)\</IntDir>
+    <LinkIncremental>false</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>
+      <StructMemberAlignment>4Bytes</StructMemberAlignment>
+      <BufferSecurityCheck>false</BufferSecurityCheck>
+      <ForcedIncludeFiles>
+      </ForcedIncludeFiles>
+      <OpenMPSupport>false</OpenMPSupport>
+      <RuntimeTypeInfo>false</RuntimeTypeInfo>
+      <CreateHotpatchableImage>false</CreateHotpatchableImage>
+      <FunctionLevelLinking>false</FunctionLevelLinking>
+      <EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <CompileAsManaged>false</CompileAsManaged>
+      <MinimalRebuild>false</MinimalRebuild>
+      <CompileAsWinRT>false</CompileAsWinRT>
+      <CallingConvention>Cdecl</CallingConvention>
+      <InlineFunctionExpansion>Disabled</InlineFunctionExpansion>
+      <IntrinsicFunctions>false</IntrinsicFunctions>
+      <FavorSizeOrSpeed>Neither</FavorSizeOrSpeed>
+      <StringPooling>true</StringPooling>
+      <EnableEnhancedInstructionSet>NoExtensions</EnableEnhancedInstructionSet>
+      <FloatingPointExceptions>false</FloatingPointExceptions>
+      <UseUnicodeForAssemblerListing>true</UseUnicodeForAssemblerListing>
+      <PreprocessorDefinitions>%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <Version>1.0</Version>
+      <LinkStatus>
+      </LinkStatus>
+      <CreateHotPatchableImage>Enabled</CreateHotPatchableImage>
+      <EnableCOMDATFolding>false</EnableCOMDATFolding>
+      <FixedBaseAddress>false</FixedBaseAddress>
+    </Link>
+    <CustomBuildStep>
+      <Message>Copying Resources</Message>
+    </CustomBuildStep>
+    <ProjectReference>
+      <LinkLibraryDependencies>false</LinkLibraryDependencies>
+    </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>
+      <StructMemberAlignment>4Bytes</StructMemberAlignment>
+      <BufferSecurityCheck>false</BufferSecurityCheck>
+      <ForcedIncludeFiles>
+      </ForcedIncludeFiles>
+      <BasicRuntimeChecks>Default</BasicRuntimeChecks>
+      <OpenMPSupport>false</OpenMPSupport>
+      <RuntimeTypeInfo>false</RuntimeTypeInfo>
+      <CreateHotpatchableImage>false</CreateHotpatchableImage>
+      <MinimalRebuild>false</MinimalRebuild>
+      <FunctionLevelLinking>false</FunctionLevelLinking>
+      <EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
+      <MultiProcessorCompilation>true</MultiProcessorCompilation>
+      <CompileAsManaged>false</CompileAsManaged>
+      <CompileAsWinRT>false</CompileAsWinRT>
+      <CallingConvention>Cdecl</CallingConvention>
+      <InlineFunctionExpansion>AnySuitable</InlineFunctionExpansion>
+      <StringPooling>true</StringPooling>
+      <EnableEnhancedInstructionSet>NoExtensions</EnableEnhancedInstructionSet>
+      <FloatingPointExceptions>false</FloatingPointExceptions>
+      <UseUnicodeForAssemblerListing>true</UseUnicodeForAssemblerListing>
+      <PreprocessorDefinitions>%(PreprocessorDefinitions)</PreprocessorDefinitions>
+    </ClCompile>
+    <Link>
+      <GenerateDebugInformation>false</GenerateDebugInformation>
+      <EnableCOMDATFolding>false</EnableCOMDATFolding>
+      <OptimizeReferences>
+      </OptimizeReferences>
+      <Version>1.0</Version>
+      <LinkStatus>
+      </LinkStatus>
+      <CreateHotPatchableImage>Enabled</CreateHotPatchableImage>
+      <FixedBaseAddress>false</FixedBaseAddress>
+    </Link>
+    <CustomBuildStep>
+      <Message>Copying Resources</Message>
+    </CustomBuildStep>
+    <ProjectReference>
+      <LinkLibraryDependencies>false</LinkLibraryDependencies>
+    </ProjectReference>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClInclude Include="Container\List.h" />
+    <ClInclude Include="dllmain.h" />
+    <ClInclude Include="Container\TypeList.h" />
+    <ClInclude Include="Utility\MassOp.h" />
+    <ClInclude Include="Type\Double.h" />
+    <ClInclude Include="Type\LongLong.h" />
+    <ClInclude Include="Utility\IndexerV1.h" />
+    <ClInclude Include="Utility\DisplayEnumerator.h" />
+    <ClInclude Include="Utility\IndexerV2.h" />
+    <ClInclude Include="Utility\WindowMessageHandler.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="Container\TypeList.cpp" />
+    <ClCompile Include="Container\List.cpp" />
+    <ClCompile Include="Type\Double.cpp" />
+    <ClCompile Include="Type\LongLong.cpp" />
+    <ClCompile Include="Utility\IndexerV1.cpp" />
+    <ClCompile Include="dllmain.cpp" />
+    <ClCompile Include="Utility\DisplayEnumerator.cpp" />
+    <ClCompile Include="Utility\IndexerV2.cpp" />
+    <ClCompile Include="Utility\MassOp.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>
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
 </Project>

BlitzUtility.vcxproj.filters

@@ -1,92 +1,96 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup>
-    <Filter Include="Source Files">
-      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
-      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
-    </Filter>
-    <Filter Include="Source Files\Utility">
-      <UniqueIdentifier>{48292af9-63a5-40ae-a447-ad7cecfddd8a}</UniqueIdentifier>
-    </Filter>
-    <Filter Include="Source Files\Containers">
-      <UniqueIdentifier>{ff6bcb4d-9140-40a9-80dd-3698b63bd1c1}</UniqueIdentifier>
-    </Filter>
-    <Filter Include="Source Files\Database">
-      <UniqueIdentifier>{4b84c339-4e83-489c-b421-2cf9fd9e72d1}</UniqueIdentifier>
-    </Filter>
-    <Filter Include="Source Files\Database\SQLite">
-      <UniqueIdentifier>{3ac37a01-a835-479c-b0b0-ecfd04640134}</UniqueIdentifier>
-    </Filter>
-    <Filter Include="Source Files\Math">
-      <UniqueIdentifier>{38444b44-ebf1-4cae-a1a3-1a0b80b045a1}</UniqueIdentifier>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <ClCompile Include="dllmain.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="Containers\BlitzList.cpp">
-      <Filter>Source Files\Containers</Filter>
-    </ClCompile>
-    <ClCompile Include="Database\SQLite\SQLite.cpp">
-      <Filter>Source Files\Database\SQLite</Filter>
-    </ClCompile>
-    <ClCompile Include="Math\Matrix3.cpp">
-      <Filter>Source Files\Math</Filter>
-    </ClCompile>
-    <ClCompile Include="Math\Vector2.cpp">
-      <Filter>Source Files\Math</Filter>
-    </ClCompile>
-    <ClCompile Include="Math\Vector3.cpp">
-      <Filter>Source Files\Math</Filter>
-    </ClCompile>
-    <ClCompile Include="Utility\Display.cpp">
-      <Filter>Source Files\Utility</Filter>
-    </ClCompile>
-    <ClCompile Include="Utility\Indexer.cpp">
-      <Filter>Source Files\Utility</Filter>
-    </ClCompile>
-    <ClCompile Include="Utility\WindowMessageHandler.cpp">
-      <Filter>Source Files\Utility</Filter>
-    </ClCompile>
-    <ClCompile Include="Database\SQLite\sqlite3.c">
-      <Filter>Source Files\Database\SQLite</Filter>
-    </ClCompile>
-  </ItemGroup>
-  <ItemGroup>
-    <ClInclude Include="dllmain.h">
-      <Filter>Source Files</Filter>
-    </ClInclude>
-    <ClInclude Include="Containers\BlitzList.h">
-      <Filter>Source Files\Containers</Filter>
-    </ClInclude>
-    <ClInclude Include="Database\SQLite\SQLite.h">
-      <Filter>Source Files\Database\SQLite</Filter>
-    </ClInclude>
-    <ClInclude Include="Database\SQLite\sqlite3.h">
-      <Filter>Source Files\Database\SQLite</Filter>
-    </ClInclude>
-    <ClInclude Include="Math\Matrix3.h">
-      <Filter>Source Files\Math</Filter>
-    </ClInclude>
-    <ClInclude Include="Math\Vector2.h">
-      <Filter>Source Files\Math</Filter>
-    </ClInclude>
-    <ClInclude Include="Math\Vector3.h">
-      <Filter>Source Files\Math</Filter>
-    </ClInclude>
-    <ClInclude Include="Utility\Display.h">
-      <Filter>Source Files\Utility</Filter>
-    </ClInclude>
-    <ClInclude Include="Utility\Indexer.h">
-      <Filter>Source Files\Utility</Filter>
-    </ClInclude>
-    <ClInclude Include="Utility\WindowMessageHandler.h">
-      <Filter>Source Files\Utility</Filter>
-    </ClInclude>
-  </ItemGroup>
-  <ItemGroup>
-    <None Include="BlitzUtility.decls" />
-    <None Include="BlitzUtility.bb" />
-  </ItemGroup>
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <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>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="dllmain.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Utility\WindowMessageHandler.cpp">
+      <Filter>Source Files\Utility</Filter>
+    </ClCompile>
+    <ClCompile Include="Utility\IndexerV1.cpp">
+      <Filter>Source Files\Utility</Filter>
+    </ClCompile>
+    <ClCompile Include="Utility\IndexerV2.cpp">
+      <Filter>Source Files\Utility</Filter>
+    </ClCompile>
+    <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>
+    <ClCompile Include="Container\List.cpp">
+      <Filter>Source Files\Container</Filter>
+    </ClCompile>
+    <ClCompile Include="Container\TypeList.cpp">
+      <Filter>Source Files\Container</Filter>
+    </ClCompile>
+    <ClCompile Include="Utility\DisplayEnumerator.cpp">
+      <Filter>Source Files\Utility</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>
+    <ClInclude Include="Container\List.h">
+      <Filter>Source Files\Container</Filter>
+    </ClInclude>
+    <ClInclude Include="Container\TypeList.h">
+      <Filter>Source Files\Container</Filter>
+    </ClInclude>
+    <ClInclude Include="Utility\DisplayEnumerator.h">
+      <Filter>Source Files\Utility</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="BlitzUtility.bb">
+      <Filter>Blitz Files</Filter>
+    </None>
+    <None Include="BlitzUtility.decls">
+      <Filter>Blitz Files</Filter>
+    </None>
+    <None Include="LICENSE" />
+    <None Include="LICENSE.lesser" />
+  </ItemGroup>
 </Project>

Container/List.cpp

@@ -0,0 +1,273 @@
+//	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;
+}
+
+

Container/List.h

@@ -0,0 +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")

Container/TypeList.cpp

@@ -0,0 +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;
+}
+

Container/TypeList.h

@@ -0,0 +1,36 @@
+//	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")

Containers/BlitzList.cpp

@@ -1,67 +0,0 @@
-#pragma once
-#include "BlitzList.h"
-
-std::list<BlitzTypeInfo*>* BlitzUtility_Lists;
-
-void BlitzList_OnProcessAttach() {
-	BlitzUtility_Lists = new std::list<BlitzTypeInfo*>();
-}
-
-void BlitzList_OnProcessDetach() {
-	BlitzUtility_Lists->clear();
-	delete BlitzUtility_Lists;
-}
-
-DLL_EXPORT void* BlitzList_New(void* elementPtr) {
-	BBVarElement* element = (BBVarElement*)(((int*)elementPtr) - 5);
-	BBVarType* type = (BBVarType*)(*(((int*)elementPtr) - 2));
-
-	// Create and initialize structure to hold information about this change.
-	BlitzTypeInfo* bti = new BlitzTypeInfo();
-	bti->type = type;
-
-	// Store list pointers.
-	bti->ourNextPtr = element;
-	bti->ourPrevPtr = element;
-
-	// Remove passed object from the flow of the old list.
-	element->prevPtr->nextPtr = element->nextPtr;
-	element->nextPtr->prevPtr = element->prevPtr;
-
-	// Correct element next/prev pointers to no longer be inside the old list.
-	element->prevPtr = (BBVarElement*)((int*)type + 1);
-	element->nextPtr = (BBVarElement*)((int*)type + 1);
-
-	BlitzUtility_Lists->push_back(bti);
-	return bti;
-}
-
-DLL_EXPORT void BlitzList_Activate(void* list) {
-	BlitzTypeInfo* bti = (BlitzTypeInfo*)list;
-
-	// Store current pointers
-	bti->lastNextPtr = bti->type->used.nextPtr;
-	bti->lastPrevPtr = bti->type->used.prevPtr;
-
-	// ... and replace them.
-	bti->type->used.nextPtr = bti->ourNextPtr;
-	bti->type->used.prevPtr = bti->ourPrevPtr;
-}
-
-DLL_EXPORT void BlitzList_Deactivate(void* list) {
-	BlitzTypeInfo* bti = (BlitzTypeInfo*)list;
-
-	// Store current pointers
-	bti->ourNextPtr = bti->type->used.nextPtr;
-	bti->ourPrevPtr = bti->type->used.prevPtr;
-
-	// ... and replace them.
-	bti->type->used.nextPtr = bti->lastNextPtr;
-	bti->type->used.prevPtr = bti->lastPrevPtr;
-}
-
-DLL_EXPORT void BlitzList_Delete(void* list) {
-	BlitzTypeInfo* bti = (BlitzTypeInfo*)list;
-	BlitzUtility_Lists->remove(bti);
-	delete bti;
-}

Containers/BlitzList.h

@@ -1,47 +0,0 @@
-#pragma once
-#include "dllmain.h"
-#include <memory>
-#include <sstream>
-#include <iomanip>
-#include <list>
-
-// 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 {
-	unsigned int Type;
-};
-
-struct BBVarElement {
-	int* currentPtr; // Points towards fields.
-	BBVarElement* nextPtr;
-	BBVarElement* prevPtr;
-	void* BBVarTypePtr;
-	unsigned int refCount;	// Fields usually follow here, may be at another location, see currentPtr.
-};
-
-struct BBVarType : BBVar {
-	BBVarElement used, free;
-	unsigned int fieldCount; // Field Info follows (Exactly <fieldCount> int pointers to variable struct)
-	//BBVar* fields[];
-};
-
-struct BlitzTypeInfo {
-	BBVarType *type;
-	BBVarElement *lastNextPtr, *lastPrevPtr;
-	BBVarElement *ourNextPtr, *ourPrevPtr;
-};
-
-void BlitzList_OnProcessAttach();
-void BlitzList_OnProcessDetach();
-
-DLL_EXPORT void* BlitzList_New(void* type);
-DLL_EXPORT void BlitzList_Activate(void* list);
-DLL_EXPORT void BlitzList_Deactivate(void* list);
-DLL_EXPORT void BlitzList_Delete(void* list);

Database/SQLite/SQLite.cpp

@@ -1,30 +1,90 @@
-#pragma once
+//	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"
 
-void SQLite3_OnProcessAttach() {
-	sqlite3_initialize();
+DLL_METHOD const char* DLL_CALL SQLite_Version() {
+	return sqlite3_version;
+}
+DLL_METHOD int32_t DLL_CALL SQLite_ThreadSafe() {
+	return sqlite3_threadsafe();
 }
 
-void SQLite3_OnProcessDetach() {
-	sqlite3_shutdown();
+DLL_METHOD int32_t DLL_CALL SQLite_Initialize() {
+	return sqlite3_initialize();
 }
 
-DLL_EXPORT 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));
+DLL_METHOD int32_t DLL_CALL SQLite_Shutdown() {
+	return sqlite3_shutdown();
 }
 
-DLL_EXPORT int sqlite3_bind_float(void* stmtPtr, uint32_t index, float value) {
-	return sqlite3_bind_double((sqlite3_stmt*)stmtPtr, index, (double)value);
+DLL_METHOD int32_t DLL_CALL SQLite_Open(const char* file, sqlite3** db) {
+	return sqlite3_open(file, db);
 }
 
-DLL_EXPORT void sqlite3_column_int64_ex(void* stmtPtr, uint32_t index, void* outPtr) {
-	sqlite3_int64 out = sqlite3_column_int64((sqlite3_stmt*)stmtPtr, index);
-	int* ourPtr = (int*)outPtr;
-	(*ourPtr) = (int)(out & 0xFFFFFFFF);
-	(*(ourPtr + 1)) = (int)(out >> 32);
+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_EXPORT float sqlite3_column_float(void* stmtPtr, uint32_t index) {
-	double out = sqlite3_column_double((sqlite3_stmt*)stmtPtr, index);
-	return (float)out;
-}
+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);
+}
+
+
+
+

Database/SQLite/SQLite.h

@@ -1,14 +1,65 @@
-#include "dllmain.h"
-#include <list>
-#include "sqlite3.h"
-
-void SQLite3_OnProcessAttach();
-void SQLite3_OnProcessDetach();
-
-extern "C" {
-	DLL_EXPORT int sqlite3_bind_int64_ex(void* stmtPtr, uint32_t index, uint32_t low, uint32_t high);
-	DLL_EXPORT int sqlite3_bind_float(void* stmtPtr, uint32_t index, float value);
-
-	DLL_EXPORT void sqlite3_column_int64_ex(void* stmtPtr, uint32_t index, void* outPtr);
-	DLL_EXPORT float sqlite3_column_float(void* stmtPtr, uint32_t index);
-}
+//	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 "sqlite3.h"
+#include <list>
+
+// 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

Database/SQLite/sqlite3.c

@@ -259,7 +259,7 @@ extern "C" {
 # define SQLITE_API 
 #endif
 #ifndef SQLITE_CDECL
-# define SQLITE_CDECL
+# define SQLITE_CDECL __cdecl
 #endif
 #ifndef SQLITE_STDCALL
 # define SQLITE_STDCALL __cdecl

Database/SQLite/sqlite3.h

@@ -46,13 +46,13 @@ extern "C" {
 ** Provide the ability to override linkage features of the interface.
 */
 #ifndef SQLITE_EXTERN
-# define SQLITE_EXTERN extern "C" __declspec(dllexport)
+# define SQLITE_EXTERN 
 #endif
 #ifndef SQLITE_API
-# define SQLITE_API 
+# define SQLITE_API extern "C" __declspec(dllexport)
 #endif
 #ifndef SQLITE_CDECL
-# define SQLITE_CDECL
+# define SQLITE_CDECL __cdecl 
 #endif
 #ifndef SQLITE_STDCALL
 # define SQLITE_STDCALL __cdecl

LICENSE

@@ -0,0 +1,674 @@
+                    GNU 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.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU 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
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    {one line to give the program's name and a brief idea of what it does.}
+    Copyright (C) {year}  {name of author}
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU 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 General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    {project}  Copyright (C) {year}  {fullname}
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.

LICENSE.lesser

@@ -0,0 +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.

Math/Matrix3.cpp

@@ -1,48 +0,0 @@
-#pragma once
-#include "Matrix3.h"
-
-
-void Matrix3::set(Matrix3 &M)
-{
-	if (this != &M) {
-		this->X.set(M.X);
-		this->Y.set(M.Y);
-		this->Z.set(M.Z);
-	}
-}
-
-void Matrix3::set(Vector3 &X, Vector3 &Y, Vector3 &Z)
-{
-	this->X.set(X);
-	this->Y.set(Y);
-	this->Z.set(Z);
-}
-
-void Matrix3::set(float &XX, float &XY, float &XZ, float &YX, float &YY, float &YZ, float &ZX, float &ZY, float &ZZ)
-{
-	this->X.set(XX, XY, XZ);
-	this->Y.set(YX, YY, YZ);
-	this->Z.set(ZX, ZY, ZZ);
-}
-
-void Matrix3::rotate(float &pitch, float &yaw, float &roll)
-{
-	this->X.mul(cos(yaw) * cos(roll), -sin(roll), sin(yaw));
-	this->Y.mul(sin(roll), cos(pitch) * cos(roll), -sin(pitch));
-	this->Z.mul(-sin(yaw), sin(pitch), cos(pitch) * cos(yaw));
-}
-
-void Matrix3::angles(float &pitch, float &yaw, float &roll)
-{
-	// ToDo
-}
-
-void Matrix3::transpose()
-{
-	Matrix3 temp;
-
-	temp.set(*this);
-	this->X.set(temp.X.X, temp.Y.X, temp.Z.X);
-	this->Y.set(temp.X.Y, temp.Y.Y, temp.Z.Y);
-	this->Z.set(temp.X.Z, temp.Y.Z, temp.Z.Z);
-}

Math/Matrix3.h

@@ -1,18 +0,0 @@
-#pragma once
-#include <math.h>
-#include "dllmain.h"
-#include "Vector3.h"
-
-struct Matrix3 {
-	Vector3 X, Y, Z;
-
-	void set(Matrix3 &M);
-	void set(Vector3 &X, Vector3 &Y, Vector3 &Z);
-	void set(float &XX, float &XY, float &XZ, float &YX, float &YY, float &YZ, float &ZX, float &ZY, float &ZZ);
-	
-	void rotate(float &pitch, float &yaw, float &roll);
-	void angles(float &pitch, float &yaw, float &roll);
-
-	void transpose();
-};
-

Math/Vector2.cpp

@@ -1,261 +0,0 @@
-#pragma once
-#include "Vector2.h"
-
-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_EXPORT void Vector2_Set(Vector2* a, float o) {
-	a->set(o);
-}
-DLL_EXPORT void Vector2_SetP(Vector2* a, float x, float y) {
-	a->set(x, y);
-}
-DLL_EXPORT void Vector2_SetV(Vector2* a, Vector2* b) {
-	a->set(*b);
-}
-
-DLL_EXPORT void Vector2_Add(Vector2* a, float o) {
-	a->add(o);
-}
-DLL_EXPORT void Vector2_AddP(Vector2* a, float x, float y) {
-	a->add(x, y);
-}
-DLL_EXPORT void Vector2_AddV(Vector2* a, Vector2* b) {
-	a->add(*b);
-}
-
-DLL_EXPORT void Vector2_Sub(Vector2* a, float o) {
-	a->sub(o);
-}
-DLL_EXPORT void Vector2_SubP(Vector2* a, float x, float y) {
-	a->sub(x, y);
-}
-DLL_EXPORT void Vector2_SubV(Vector2* a, Vector2* b) {
-	a->sub(*b);
-}
-
-DLL_EXPORT void Vector2_Mul(Vector2* a, float o) {
-	a->mul(o);
-}
-DLL_EXPORT void Vector2_MulP(Vector2* a, float x, float y) {
-	a->mul(x, y);
-}
-DLL_EXPORT void Vector2_MulV(Vector2* a, Vector2* b) {
-	a->mul(*b);
-}
-
-DLL_EXPORT void Vector2_Div(Vector2* a, float o) {
-	a->div(o);
-}
-DLL_EXPORT void Vector2_DivP(Vector2* a, float x, float y) {
-	a->div(x, y);
-}
-DLL_EXPORT void Vector2_DivV(Vector2* a, Vector2* b) {
-	a->div(*b);
-}
-
-DLL_EXPORT float Vector2_Length(Vector2* a) {
-	return (float)a->length();
-}
-DLL_EXPORT float Vector2_DistanceP(Vector2* a, float x, float y) {
-	return (float)a->distance(x, y);
-}
-DLL_EXPORT float Vector2_DistanceV(Vector2* a, Vector2* b) {
-	return (float)a->distance(*b);
-}
-
-DLL_EXPORT float Vector2_DotP(Vector2* a, float x, float y) {
-	return (float)a->dot(x, y);
-}
-DLL_EXPORT float Vector2_DotV(Vector2* a, Vector2* b) {
-	return (float)a->dot(*b);
-}
-DLL_EXPORT void Vector2_Normalize(Vector2* a) {
-	a->normalize();
-}
-
-DLL_EXPORT void Vector2_Rotate(Vector2* a, float rotation) {
-	a->rotate(rotation);
-}
-DLL_EXPORT void Vector2_RotateAroundP(Vector2* a, float x, float y, float rotation) {
-	a->rotateAround(x, y, rotation);
-}
-DLL_EXPORT void Vector2_RotateAroundV(Vector2* a, Vector2* b, float rotation) {
-	a->rotateAround(*b, rotation);
-}
-
-DLL_EXPORT float Vector2_DeltaRotation(Vector2* a) {
-	return (float)a->deltaRotation();
-}
-DLL_EXPORT float Vector2_DeltaRotationP(Vector2* a, float x, float y) {
-	return (float)a->deltaRotation(x, y);
-}
-DLL_EXPORT float Vector2_DeltaRotationV(Vector2* a, Vector2* b) {
-	return (float)a->deltaRotation(*b);
-}
-
-DLL_EXPORT char* Vector2_Serialize(Vector2* a) {
-	return a->serialize();
-}
-DLL_EXPORT void Vector2_Deserialize(Vector2* a, char* o) {
-	a->deserialize(o);
-}

Math/Vector2.h

@@ -1,57 +0,0 @@
-#pragma once
-#include "dllmain.h"
-#ifndef _USE_MATH_DEFINES
-	#define _USE_MATH_DEFINES
-	#include <math.h>
-	#undef _USE_MATH_DEFINES
-#endif
-
-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);
-};
-

README.md

@@ -0,0 +1,173 @@
+# 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*)

Type/BVector3.cpp

@@ -1,4 +1,20 @@
-#pragma once
+//	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)
@@ -216,111 +232,143 @@ void Vector3::deserialize(char* o)
 	memcpy(o + 8, this->Zc, 4);
 }
 
-/* ------------------------- Exported Functionality ------------------------- */
-DLL_EXPORT void Vector3_Set(Vector3* a, float o) {
+DLL_METHOD void Vector3_Set(Vector3* a, float o) {
 	a->set(o);
 }
-DLL_EXPORT void Vector3_SetP(Vector3* a, float x, float y, float z) {
+DLL_METHOD void Vector3_SetP(Vector3* a, float x, float y, float z) {
 	a->set(x, y, z);
 }
-DLL_EXPORT void Vector3_SetV(Vector3* a, Vector3* b) {
+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_EXPORT void Vector3_Add(Vector3* a, float o) {
+DLL_METHOD void Vector3_Add(Vector3* a, float o) {
 	a->add(o);
 }
-DLL_EXPORT void Vector3_AddP(Vector3* a, float x, float y, float z) {
+DLL_METHOD void Vector3_AddP(Vector3* a, float x, float y, float z) {
 	a->add(x, y, z);
 }
-DLL_EXPORT void Vector3_AddV(Vector3* a, Vector3* b) {
+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_EXPORT void Vector3_Sub(Vector3* a, float o) {
+DLL_METHOD void Vector3_Sub(Vector3* a, float o) {
 	a->sub(o);
 }
-DLL_EXPORT void Vector3_SubP(Vector3* a, float x, float y, float z) {
+DLL_METHOD void Vector3_SubP(Vector3* a, float x, float y, float z) {
 	a->sub(x, y, z);
 }
-DLL_EXPORT void Vector3_SubV(Vector3* a, Vector3* b) {
+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_EXPORT void Vector3_Mul(Vector3* a, float o) {
+DLL_METHOD void Vector3_Mul(Vector3* a, float o) {
 	a->mul(o);
 }
-DLL_EXPORT void Vector3_MulP(Vector3* a, float x, float y, float z) {
+DLL_METHOD void Vector3_MulP(Vector3* a, float x, float y, float z) {
 	a->mul(x, y, z);
 }
-DLL_EXPORT void Vector3_MulV(Vector3* a, Vector3* b) {
+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_EXPORT void Vector3_Div(Vector3* a, float o) {
+DLL_METHOD void Vector3_Div(Vector3* a, float o) {
 	a->div(o);
 }
-DLL_EXPORT void Vector3_DivP(Vector3* a, float x, float y, float z) {
+DLL_METHOD void Vector3_DivP(Vector3* a, float x, float y, float z) {
 	a->div(x, y, z);
 }
-DLL_EXPORT void Vector3_DivV(Vector3* a, Vector3* b) {
+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_EXPORT float Vector3_Length(Vector3* a) {
+DLL_METHOD float Vector3_Length(Vector3* a) {
 	return (float)a->length();
 }
-DLL_EXPORT float Vector3_DistanceP(Vector3* a, float x, float y, float z) {
+DLL_METHOD float Vector3_DistanceP(Vector3* a, float x, float y, float z) {
 	return (float)a->distance(x, y, z);
 }
-DLL_EXPORT float Vector3_DistanceV(Vector3* a, Vector3* b) {
+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_EXPORT float Vector3_DotP(Vector3* a, float x, float y, float z) {
+DLL_METHOD float Vector3_DotP(Vector3* a, float x, float y, float z) {
 	return (float)a->dot(x, y, z);
 }
-DLL_EXPORT float Vector3_DotV(Vector3* a, Vector3* b) {
+DLL_METHOD float Vector3_DotV(Vector3* a, Vector3* b) {
 	return (float)a->dot(*b);
 }
-DLL_EXPORT void Vector3_CrossP(Vector3* a, float x, float y, float z, Vector3* out) {
+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_EXPORT void Vector3_CrossV(Vector3* a, Vector3* b, Vector3* out) {
+DLL_METHOD void Vector3_CrossV(Vector3* a, Vector3* b, Vector3* out) {
 	Vector3 temp = a->cross(*b);
 	*out = temp;
 }
-DLL_EXPORT void Vector3_Normalize(Vector3* a) {
+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_EXPORT void Vector3_Rotate(Vector3* a, float pitch, float yaw, float roll) {
+DLL_METHOD void Vector3_Rotate(Vector3* a, float pitch, float yaw, float roll) {
 	a->rotate(pitch, yaw, roll);
 }
-DLL_EXPORT void Vector3_RotateAroundP(Vector3* a, float x, float y, float z, float pitch, float yaw, float 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_EXPORT void Vector3_RotateAroundV(Vector3* a, Vector3* b, float pitch, float yaw, float 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_EXPORT float Vector3_DeltaPitchP(Vector3* a, float x, float y, float z) {
+DLL_METHOD float Vector3_DeltaPitchP(Vector3* a, float x, float y, float z) {
 	return (float)a->deltaPitch(x, y, z);
 }
-DLL_EXPORT float Vector3_DeltaPitchV(Vector3* a, Vector3* b) {
+DLL_METHOD float Vector3_DeltaPitchV(Vector3* a, Vector3* b) {
 	return (float)a->deltaPitch(*b);
 }
-DLL_EXPORT float Vector3_DeltaYawP(Vector3* a, float x, float y, float z) {
+DLL_METHOD float Vector3_DeltaYawP(Vector3* a, float x, float y, float z) {
 	return (float)a->deltaYaw(x, y, z);
 }
-DLL_EXPORT float Vector3_DeltaYawV(Vector3* a, Vector3* b) {
+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_EXPORT char* Vector3_Serialize(Vector3* a) {
+DLL_METHOD char* Vector3_Serialize(Vector3* a) {
 	return a->serialize();
 }
-DLL_EXPORT void Vector3_Deserialize(Vector3* a, char* s) {
+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,3 +1,20 @@
+//	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
@@ -62,4 +79,4 @@ struct Vector3 {
 
 	char* serialize();
 	void deserialize(char* o);
-};
+};*/

Type/Double.cpp

@@ -0,0 +1,163 @@
+//	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);
+}

Type/Double.h

@@ -0,0 +1,96 @@
+//	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

Type/FVector2.cpp

@@ -0,0 +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) {
+
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+*/

Type/FVector2.h

@@ -0,0 +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);
+
+*/

Type/LongLong.cpp

@@ -0,0 +1,174 @@
+//	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

@@ -0,0 +1,104 @@
+//	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/Display.cpp

@@ -1,54 +0,0 @@
-#include "Display.h"
-
-std::list<Display>* Display_List = NULL;
-
-void Display_OnProcessAttach() {
-	Display_List = new std::list<Display>();
-}
-
-void Display_OnProcessDetach() {
-	Display_List->clear();
-	delete Display_List;
-}
-
-DLL_EXPORT void Display_Enumerate() {
-	if (Display_List == NULL)
-		return;
-
-	Display_List->clear();
-
-	EnumDisplayMonitors(NULL, NULL, Display_EnumerateProcedure, 0);
-}
-
-BOOL CALLBACK Display_EnumerateProcedure(HMONITOR hMonitor, HDC hdcMonitor, LPRECT lprcMonitor, LPARAM dwData) {
-	Display *thisDisplay = new Display;
-
-	thisDisplay->left = lprcMonitor->left;
-	thisDisplay->top = lprcMonitor->top;
-	thisDisplay->right = lprcMonitor->right;
-	thisDisplay->bottom = lprcMonitor->bottom;
-
-	Display_List->push_back(*thisDisplay);
-
-	return TRUE;
-}
-
-DLL_EXPORT int Display_Count() {
-	return Display_List->size();
-}
-
-DLL_EXPORT void Display_Get(int displayId, LPRECT display) {
-	if (Display_List->size() > (unsigned)displayId) {
-		auto iterator = Display_List->begin();
-
-		std::advance(iterator, displayId);
-
-		if (display != NULL) {
-			display->left = iterator->left;
-			display->top = iterator->top;
-			display->right = iterator->right;
-			display->bottom = iterator->bottom;
-		}
-	}
-}
-

Utility/Display.h

@@ -1,21 +0,0 @@
-#pragma once
-#include "dllmain.h"
-#include <list>
-
-struct Display {
-	int left;
-	int top;
-	int right;
-	int bottom;
-};
-
-void Display_OnProcessAttach();
-void Display_OnProcessDetach();
-
-BOOL CALLBACK Display_EnumerateProcedure(HMONITOR hMonitor, HDC hdcMonitor, LPRECT lprcMonitor, LPARAM dwData);
-
-extern "C" {
-	DLL_EXPORT void Display_Enumerate();
-	DLL_EXPORT int Display_Count();
-	DLL_EXPORT void Display_Get(int displayId, LPRECT display);
-}

Utility/DisplayEnumerator.cpp

@@ -0,0 +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;
+}

Utility/DisplayEnumerator.h

@@ -0,0 +1,38 @@
+//	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")

Utility/Indexer.cpp

@@ -1,75 +0,0 @@
-#pragma once
-#include "Indexer.h"
-
-#define INDEX_OFF_0 0x00000000
-#define INDEX_OFF_1 0x10000000
-#define INDEX_OFF_2 0x20000000
-#define INDEX_OFF_3 0x30000000
-#define INDEX_OFF_4 0x40000000
-#define INDEX_OFF_5 0x50000000
-#define INDEX_OFF_6 0x60000000
-#define INDEX_OFF_7 0x70000000
-#define INDEX_OFF_8 0x80000000
-#define INDEX_OFF_9 0x90000000
-#define INDEX_OFF_A 0xA0000000
-#define INDEX_OFF_B 0xB0000000
-#define INDEX_OFF_C 0xC0000000
-#define INDEX_OFF_D 0xD0000000
-#define INDEX_OFF_E 0xE0000000
-#define INDEX_OFF_F 0xF0000000
-
-unsigned int Indexer::GetFreeIndex()
-{
-	unsigned int index = lastAssignedIndex + 1;
-
-	bool foundIndex = false;
-	char indexBitOffset = 0;
-
-	// We use 16 offsets here to speed up the search for a free index.
-	while (foundIndex == false) {
-		index = index + 64;
-
-		uint64_t toCheck = this->indexes[index >> 6];
-		for (indexBitOffset = 0; indexBitOffset < 64; indexBitOffset++) {
-			if ((toCheck & (1ULL << indexBitOffset)) == false) {
-				foundIndex = true;
-				break;
-			}
-		}
-	}
-	index = index + indexBitOffset;
-
-	// Mark Index as in use.
-	this->indexes[index >> 6] |= 1ULL << indexBitOffset;
-	lastAssignedIndex = index;
-
-	return lastAssignedIndex;
-}
-
-void Indexer::MarkFreeIndex(int index)
-{
-	unsigned short bitFlip = index % 64;
-
-	// Mark index as unused.
-	this->indexes[index >> 6] &= ~(1ULL << bitFlip);
-}
-
-DLL_EXPORT void* Indexer_Create() {
-	Indexer* indexer = new Indexer();
-	return indexer;
-}
-
-DLL_EXPORT int Indexer_GetFreeIndex(void* indexerPtr) {
-	Indexer* indexer = (Indexer*)indexerPtr;
-	return indexer->GetFreeIndex();
-}
-
-DLL_EXPORT void Indexer_MarkFreeIndex(void* indexerPtr, int Index) {
-	Indexer* indexer = (Indexer*)indexerPtr;
-	indexer->MarkFreeIndex(Index);
-}
-
-DLL_EXPORT void Indexer_Destroy(void* indexerPtr) {
-	Indexer* indexer = (Indexer*)indexerPtr;
-	delete indexer;
-}

Utility/Indexer.h

@@ -1,25 +0,0 @@
-#pragma once
-#include <cstdlib>
-#include <list>
-#include "dllmain.h"
-
-// 67108864 = 2 ^ 32 / 64
-#define INDEXER_INDEXES 67108864
-
-/** 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 Indexer {
-	uint64_t indexes[67108864];
-	uint32_t lastAssignedIndex;
-
-	unsigned int GetFreeIndex();
-	void MarkFreeIndex(int index);
-};
-
-extern "C" {
-	DLL_EXPORT void* Indexer_Create();
-	DLL_EXPORT int Indexer_GetFreeIndex(void* index);
-	DLL_EXPORT void Indexer_MarkFreeIndex(void* index, int Index);
-	DLL_EXPORT void Indexer_Destroy(void* index);
-}

Utility/IndexerV1.cpp

@@ -0,0 +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);
+}

Utility/IndexerV1.h

@@ -0,0 +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")

Utility/IndexerV2.cpp

@@ -0,0 +1,171 @@
+//	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 "IndexerV2.h"
+
+IndexerV2::IndexerV2() {
+	this->range.reserve(32);
+}
+
+IndexerV2::~IndexerV2() {
+	this->range.clear();
+}
+
+void IndexerV2::mark(uint32_t index, bool used) {
+	if (this->range.size() == 0) {
+		if (used == true)
+			this->range.push_back(IndexerV2Range(index, index));
+	} else {
+		auto iter = this->range.begin();
+		for (auto iter = this->range.begin(); iter != this->range.end(); iter++) {
+			if (used) {
+				if ((index + 1) == iter->min) {
+					iter->min--;
+					break;
+				} else if ((index - 1) == iter->max) {
+					iter->max++;
+					if ((iter + 1) != this->range.end() && iter->max == (iter + 1)->min) {
+						(iter + 1)->min = iter->min;
+						this->range.erase(iter);
+					}
+					break;
+				} else if (index < iter->min) {
+					this->range.insert(iter, IndexerV2Range(index, index));
+					break;
+				} 
+			} else {
+				if (index >= iter->min && index <= iter->max) {
+					this->range.insert(iter - 1, IndexerV2Range(iter->min, index - 1));
+					this->range.insert(iter + 1, IndexerV2Range(index + 1, iter->max));
+					this->range.erase(iter); break;
+				} else if (index == iter->min) {
+					iter->min++;
+					if (iter->min == iter->max)
+						this->range.erase(iter);
+					break;
+				} else if (index == iter->max) {
+					iter->max--;
+					if (iter->min == iter->max)
+						this->range.erase(iter);
+					
+					break;
+				}
+			}
+		}
+	}
+}
+
+bool IndexerV2::is(uint32_t index, bool used) {
+	bool isUsed = false;
+	for (auto iter = this->range.begin(); iter != this->range.end(); iter++) {
+		if (index >= iter->min && index <= iter->max) {
+			isUsed = true;
+			break;
+		}
+	}
+	return (isUsed == used);
+}
+
+uint32_t IndexerV2::get() {
+	if (this->range.size() == 0) {
+		this->range.push_back(IndexerV2Range(0, 0));
+		return 0;
+	}
+
+	// We only need to check the first element to get a new free index.
+	std::vector<IndexerV2Range>::iterator iter = this->range.begin();
+	if (iter->min > 0) {
+		return --iter->min;
+	} else {
+		if (iter->max == UINT32_MAX)
+			return UINT32_MAX;
+
+		uint32_t index = ++iter->max;
+
+		// Check if we can combine this element with the next one.
+		std::vector<IndexerV2Range>::iterator iterN = this->range.begin() + 1;
+		if ((iterN != this->range.end()) && iterN->min == iter->max) {
+			iter->max = iterN->max;
+			this->range.erase(iterN);
+		}
+
+		return index;
+	}
+
+	return UINT32_MAX;
+}
+
+uint32_t IndexerV2::count(bool used) {
+	uint32_t amount = 0;
+	for (auto iter = this->range.begin(); iter != this->range.end(); iter++) {
+		amount += iter->max - iter->min;
+	}
+	return (used ? UINT32_MAX - amount : amount);
+}
+
+IndexerV2::IndexerV2Range::IndexerV2Range(uint32_t min, uint32_t max) {
+	this->min = min;
+	this->max = max;
+}
+
+
+DLL_METHOD IndexerV2* DLL_CALL BU_IndexerV2_Create() {
+	return new IndexerV2();
+}
+
+DLL_METHOD void DLL_CALL BU_IndexerV2_Destroy(IndexerV2* indexer) {
+	delete indexer;
+}
+
+DLL_METHOD void DLL_CALL 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) {
+	indexer->mark(index, false);
+}
+
+DLL_METHOD void DLL_CALL 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) {
+	return indexer->is(index, used != 0);
+}
+
+DLL_METHOD uint32_t DLL_CALL 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) {
+	return indexer->is(index, true);
+}
+
+DLL_METHOD uint32_t DLL_CALL BU_IndexerV2_Get(IndexerV2* indexer) {
+	return indexer->get();
+}
+
+DLL_METHOD uint32_t DLL_CALL BU_IndexerV2_Count(IndexerV2* indexer, uint32_t used) {
+	return indexer->count(used != 0);
+}
+
+DLL_METHOD uint32_t DLL_CALL BU_IndexerV2_CountFree(IndexerV2* indexer) {
+	return indexer->count(false);
+}
+
+DLL_METHOD uint32_t DLL_CALL BU_IndexerV2_CountUsed(IndexerV2* indexer) {
+	return indexer->count(true);
+}

Utility/IndexerV2.h

@@ -0,0 +1,65 @@
+//	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 <vector>
+
+class IndexerV2 {
+	public:
+		IndexerV2();
+		~IndexerV2();
+
+		void mark(uint32_t index, bool used);
+		bool is(uint32_t index, bool used);
+		uint32_t get();
+		uint32_t count(bool used);
+
+	private:
+		struct IndexerV2Range {
+			uint32_t min, max;
+
+			IndexerV2Range(uint32_t pmin, uint32_t pmax);
+		};
+
+		std::vector<IndexerV2Range> range;
+};
+
+DLL_METHOD IndexerV2* DLL_CALL BU_IndexerV2_Create();
+#pragma comment(linker, "/EXPORT:BU_IndexerV2_Create=_BU_IndexerV2_Create@0")
+DLL_METHOD void DLL_CALL 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);
+#pragma comment(linker, "/EXPORT:BU_IndexerV2_Mark=_BU_IndexerV2_Mark@12")
+DLL_METHOD void DLL_CALL 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);
+#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);
+#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);
+#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);
+#pragma comment(linker, "/EXPORT:BU_IndexerV2_IsUsed=_BU_IndexerV2_IsUsed@8")
+DLL_METHOD uint32_t DLL_CALL 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);
+#pragma comment(linker, "/EXPORT:BU_IndexerV2_Count=_BU_IndexerV2_Count@8")
+DLL_METHOD uint32_t DLL_CALL 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);
+#pragma comment(linker, "/EXPORT:BU_IndexerV2_CountUsed=_BU_IndexerV2_CountUsed@4")
+

Utility/MassOp.cpp

@@ -0,0 +1,200 @@
+//	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;
+				}
+		}
+	}
+}

Utility/MassOp.h

@@ -0,0 +1,108 @@
+//	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);
+#pragma comment(linker, "/EXPORT:BU_MassOp_Run=_BU_MassOp_Run@4")

Utility/WindowMessageHandler.cpp

@@ -1,22 +1,38 @@
+//	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 WindowMessageHandler_OnProcessAttach() {
+void BU_WindowMessageHandler_OnProcessAttach() {
 	WindowMessageHandler_List = new std::list<WindowUserData>();
 }
 
-void WindowMessageHandler_OnProcessDetach() {
+void BU_WindowMessageHandler_OnProcessDetach() {
 	for (auto iterator = WindowMessageHandler_List->begin(), end = WindowMessageHandler_List->end(); iterator != end; iterator++) {
-		WindowMessageHandler_Uninstall(iterator->hwnd);
+		BU_WindowMessageHandler_Uninstall(iterator->hwnd);
 	}
 
 	WindowMessageHandler_List->clear();
 	delete WindowMessageHandler_List;
 }
 
-LRESULT CALLBACK WindowMessageHandler_Procedure(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
+LRESULT CALLBACK BU_WindowMessageHandler_Procedure(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
 	WindowUserData* UserData = (WindowUserData*)GetWindowLong(hwnd, GWL_USERDATA);
 	if (UserData) {
 		switch (uMsg) {
@@ -44,57 +60,50 @@ LRESULT CALLBACK WindowMessageHandler_Procedure(HWND hwnd, UINT uMsg, WPARAM wPa
 	}
 }
 
-DLL_EXPORT void WindowMessageHandler_Install(HWND hwnd) {
-	if (hwnd) {
-		WindowUserData* UserData = new WindowUserData;
-		ZeroMemory(UserData, sizeof(UserData));
-		UserData->oWindowProcedure = (WNDPROC)SetWindowLong(hwnd, GWL_WNDPROC, (LONG)&WindowMessageHandler_Procedure);
-		UserData->oUserData = SetWindowLong(hwnd, GWL_USERDATA, (LONG)UserData);
+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;
 	}
 }
-#pragma comment(linker, "/EXPORT:WindowMessageHandler_Install=_WindowMessageHandler_Install@4")
 
-DLL_EXPORT void WindowMessageHandler_Uninstall(HWND hwnd) {
-	if (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;
 }
-#pragma comment(linker, "/EXPORT:WindowMessageHandler_Uninstall=_WindowMessageHandler_Uninstall@4")
 
-DLL_EXPORT int WindowMessageHandler_Message_Resize(HWND hwnd, LPPOINT point) {
-	if (hwnd) {
-		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;
-		}
+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;
 }
-#pragma comment(linker, "/EXPORT:WindowMessageHandler_Message_Resize=_WindowMessageHandler_Message_Resize@8")
 
-DLL_EXPORT int WindowMessageHandler_Message_Destroy(HWND hwnd) {
-	if (hwnd) {
-		WindowUserData* UserData = (WindowUserData*)GetWindowLong(hwnd, GWL_USERDATA);
-		if (UserData) {
-			int toReturn = UserData->DestroyCount;
-			UserData->DestroyCount = 0;
-			return toReturn;
-		}
-	}
-	return 0;
-}
-#pragma comment(linker, "/EXPORT:WindowMessageHandler_Message_Destroy=_WindowMessageHandler_Message_Destroy@4")
-
-DLL_EXPORT int WindowMessageHandler_Message_Close(HWND hwnd) {
+DLL_METHOD uint32_t DLL_CALL BU_WindowMessageHandler_Message_Close(HWND hwnd)
+{
 	if (hwnd) {
 		WindowUserData* UserData = (WindowUserData*)GetWindowLong(hwnd, GWL_USERDATA);
 		if (UserData) {
@@ -105,5 +114,5 @@ DLL_EXPORT int WindowMessageHandler_Message_Close(HWND hwnd) {
 	}
 	return 0;
 }
-#pragma comment(linker, "/EXPORT:WindowMessageHandler_Message_Close=_WindowMessageHandler_Message_Close@4")
+
 

Utility/WindowMessageHandler.h

@@ -1,3 +1,19 @@
+//	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>
@@ -17,15 +33,17 @@ struct WindowUserData {
 };
 
 
-void WindowMessageHandler_OnProcessAttach();
-void WindowMessageHandler_OnProcessDetach();
+void BU_WindowMessageHandler_OnProcessAttach();
+void BU_WindowMessageHandler_OnProcessDetach();
+LRESULT CALLBACK BU_WindowMessageHandler_Procedure(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
 
-LRESULT CALLBACK WindowMessageHandler_Procedure(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
-
-extern "C" {
-	DLL_EXPORT void WindowMessageHandler_Install(HWND hwnd);
-	DLL_EXPORT void WindowMessageHandler_Uninstall(HWND hwnd);
-	DLL_EXPORT int WindowMessageHandler_Message_Resize(HWND hwnd, LPPOINT point);
-	DLL_EXPORT int WindowMessageHandler_Message_Destroy(HWND hwnd);
-	DLL_EXPORT int WindowMessageHandler_Message_Close(HWND hwnd);
-}
+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);
+#pragma comment(linker, "/EXPORT:BU_WindowMessageHandler_Message_Close=_BU_WindowMessageHandler_Message_Close@4")

dllmain.cpp

@@ -1,45 +1,32 @@
-#pragma once
-#include "dllmain.h"
+//	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 "Containers\BlitzList.h"
+#include "dllmain.h"
 #include "Database\SQLite\SQLite.h"
-#include "Math\Vector2.h"
-#include "Math\Vector3.h"
-#include "Math\Matrix3.h"
-#include "Utility\Display.h"
-#include "Utility\Indexer.h"
 #include "Utility\WindowMessageHandler.h"
 
 bool WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved) {
 	switch (fdwReason) {
 		case DLL_PROCESS_ATTACH:
-			// Containers
-			BlitzList_OnProcessAttach();
-
-			// Math
-
-			// Database
-			SQLite3_OnProcessAttach();
-
-			// Utility
-			Display_OnProcessAttach();
-			WindowMessageHandler_OnProcessAttach();
-
+			BU_WindowMessageHandler_OnProcessAttach();
 			break;
 		case DLL_PROCESS_DETACH:
-			// Containers
-			BlitzList_OnProcessDetach();
-
-			// Math
-
-			// Database
-			SQLite3_OnProcessDetach();
-
-			// Utility
-			Display_OnProcessDetach();
-			WindowMessageHandler_OnProcessDetach();
-
+			BU_WindowMessageHandler_OnProcessDetach();
 			break;
 	}
 	return TRUE;

dllmain.h

@@ -1,12 +1,56 @@
-// STL Exceptions
-#include <exception>
-#include <stdexcept>
+//	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_EXPORT extern "C" __declspec(dllexport)
+#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;
+}