From 7a96afeda7fc235e098fbd45d84ee23aea03b251 Mon Sep 17 00:00:00 2001 From: Michael Dirks Date: Sat, 20 Jun 2015 15:52:40 +0200 Subject: [PATCH] Preparations for 1.2 update. --- BlitzUtility.bb | 513 +++++++++++++++++++------------ BlitzUtility.decls | 355 +++++++++------------ BlitzUtility.vcxproj | 28 +- BlitzUtility.vcxproj.filters | 98 ++++-- Containers/BlitzList.cpp | 86 ------ Containers/BlitzList.h | 58 ---- Database/SQLite/SQLite.cpp | 89 +++--- Database/SQLite/SQLite.h | 78 +++-- Math/BlitzType.h | 132 -------- Math/Matrix3.cpp | 62 ---- Math/Matrix3.h | 34 -- Math/Vector2.cpp | 305 ------------------ Math/Vector2.h | 73 ----- Math/Vector3.cpp | 373 ---------------------- Math/Vector3.h | 81 ----- Utility/Display.cpp | 73 ----- Utility/Display.h | 31 -- Utility/IndexerV1.cpp | 147 +++++---- Utility/IndexerV1.h | 35 ++- Utility/IndexerV2.cpp | 225 ++++++++------ Utility/IndexerV2.h | 65 ++-- Utility/WindowMessageHandler.cpp | 85 +++-- Utility/WindowMessageHandler.h | 18 +- dllmain.cpp | 36 +-- dllmain.h | 36 ++- 25 files changed, 1036 insertions(+), 2080 deletions(-) delete mode 100644 Containers/BlitzList.cpp delete mode 100644 Containers/BlitzList.h delete mode 100644 Math/BlitzType.h delete mode 100644 Math/Matrix3.cpp delete mode 100644 Math/Matrix3.h delete mode 100644 Math/Vector2.cpp delete mode 100644 Math/Vector2.h delete mode 100644 Math/Vector3.cpp delete mode 100644 Math/Vector3.h delete mode 100644 Utility/Display.cpp delete mode 100644 Utility/Display.h diff --git a/BlitzUtility.bb b/BlitzUtility.bb index be2b40b..daeac96 100644 --- a/BlitzUtility.bb +++ b/BlitzUtility.bb @@ -14,9 +14,316 @@ ; You should have received a copy of the GNU Lesser General Public License ; along with this program. If not, see . -;---------------------------------------------------------------- +; 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 with the result of , +; skipping over 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 with , skipping +; over 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 @@ -28,9 +335,7 @@ Function Vector2_Create.Vector2(X#, Y#) Return vec End Function -;---------------------------------------------------------------- ;-- Vector3 -;---------------------------------------------------------------- Type Vector3 Field X#, Y#, Z# End Type @@ -43,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 \ No newline at end of file diff --git a/BlitzUtility.decls b/BlitzUtility.decls index a34c36f..c2944fb 100644 --- a/BlitzUtility.decls +++ b/BlitzUtility.decls @@ -15,218 +15,157 @@ ; along with this program. If not, see . .lib "BlitzUtility.dll" -; Math ------------------------------------------------------------------------- -; -- 2D Vector -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" -; -- 3D Vector -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" +; 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%) -; Containers ------------------------------------------------------------------- -; -- Native Blitz List (Not Threadsafe) -BU_BlitzList_New%(obj*) : "BlitzList_New" -BU_BlitzList_Activate(list%) : "BlitzList_Activate" -BU_BlitzList_Deactivate(list%) : "BlitzList_Deactivate" -BU_BlitzList_Destroy(list%) : "BlitzList_Delete" +; Types ------------------------------------------------------------------------ +; -- LongLong +BU_LongLong_Create%() +BU_LongLong_Destroy(LongLong%) +BU_LongLong_Copy%(LongLong%) +BU_LongLong_TempCreate%() +BU_LongLong_TempCopy%(LongLong%) +BU_LongLong_SetTemp(LongLong%) +BU_LongLong_UnsetTemp(LongLong%) +BU_LongLong_TempCleanup() +BU_LongLong_Set(LongLong%, LongLong%) +BU_LongLong_SetV(LongLong%, LongHigh%, LongLow%) +BU_LongLong_Add(LongLong%, LongLong%) +BU_LongLong_AddV(LongLong%, LongHigh%, LongLow%) +BU_LongLong_Sub(LongLong%, LongLong%) +BU_LongLong_SubV(LongLong%, LongHigh%, LongLow%) +BU_LongLong_Mul(LongLong%, LongLong%) +BU_LongLong_MulV(LongLong%, LongHigh%, LongLow%) +BU_LongLong_Div(LongLong%, LongLong%) +BU_LongLong_DivV(LongLong%, LongHigh%, LongLow%) +BU_LongLong_Compare%(LongLong%, LongLong%) +BU_LongLong_CompareV%(LongLong%, LongHigh%, LongLow%) +BU_LongLong_ToString$(LongLong%) +BU_LongLong_FromString%(String$) +BU_LongLong_ToLong%(LongLong%, Modulus%) +BU_LongLong_FromLong%(LongHigh%, LongLow%) +BU_LongLong_ToLongHigh%(LongLong%) +BU_LongLong_ToLongLow%(LongLong%) +BU_LongLong_ToFloat#(LongLong%) +BU_LongLong_FromFloat%(Float#) +BU_LongLong_ToDouble%(LongLong%) +BU_LongLong_FromDouble%(double%) +BU_LongLong_Serialize$(LongLong%) +BU_LongLong_Deserialize%(String$) +; -- Double +BU_Double_Create%() +BU_Double_Destroy(Double%) +BU_Double_Copy%(Double%) +BU_Double_TempCreate%() +BU_Double_TempCopy%(Double%) +BU_Double_SetTemp(Double%) +BU_Double_UnsetTemp(Double%) +BU_Double_TempCleanup() +BU_Double_Set(Double%, Double%) +BU_Double_SetF(Double%, Float#) +BU_Double_Add(Double%, Double%) +BU_Double_AddF(Double%, Float#) +BU_Double_Sub(Double%, Double%) +BU_Double_SubF(Double%, Float#) +BU_Double_Mul(Double%, Double%) +BU_Double_MulF(Double%, Float#) +BU_Double_Div(Double%, Double%) +BU_Double_DivF(Double%, Float#) +BU_Double_Compare%(Double%, Double%) +BU_Double_CompareF%(Double%, Float#) +BU_Double_ToString$(Double%) +BU_Double_FromString%(String$) +BU_Double_ToFloat#(Double%) +BU_Double_FromFloat%(Float#) +BU_Double_ToLongLong%(Double%) +BU_Double_FromLongLong%(LongLong%) +BU_Double_Serialize$(Double%) +BU_Double_Deserialize%(String$) ; Utility ---------------------------------------------------------------------- -; -- Monitor/Display Enumeration -BU_Display_Enumerate() : "Display_Enumerate" -BU_Display_Count%() : "Display_Count" -BU_Display_Get(id%, rectangle*) : "Display_Get" -; -- Fast Indexing V1 (Array-based) -BU_IndexerV1_Create%() : "IndexerV1_Create" -BU_IndexerV1_Destroy(indexer%) : "IndexerV1_Destroy" -BU_IndexerV1_GetIndex%(indexer%) : "IndexerV1_GetFreeIndex" -BU_IndexerV1_MarkIndex(indexer%, index%) : "IndexerV1_MarkFreeIndex" -; -- Fast Indexing V2 (Vector-based) -BU_IndexerV2_Create%() : "IndexerV2_Create" -BU_IndexerV2_Destroy(indexer%) : "IndexerV2_Destroy" -BU_IndexerV2_GetIndex%(indexer%) : "IndexerV2_GetIndex" -BU_IndexerV2_MarkIndex(indexer%, index%) : "IndexerV2_MarkIndex" -BU_IndexerV2_IsFree%(indexer%, index%) : "IndexerV2_IsFree" -BU_IndexerV2_IsUsed%(indexer%, index%) : "IndexerV2_IsUsed" +; -- 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_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" +BU_WindowMessageHandler_Install(hwnd%) +BU_WindowMessageHandler_Uninstall(hwnd%) +BU_WindowMessageHandler_Message_Close%(hwnd%) +BU_WindowMessageHandler_Message_Destroy%(hwnd%) +BU_WindowMessageHandler_Message_Resize%(hwnd%, point*) -; Databases -------------------------------------------------------------------- -; -- SQLite3 -SQLite3_LibVersion$() : "sqlite3_libversion" -SQLite3_Open%(Filename$, DatabaseHandle*) : "sqlite3_open" -SQLite3_Open_V2%(Filename$, DatabaseHandle*, Flags%, VFS%) : "sqlite3_open_v2" -SQLite3_Close%(DatabaseHandle) : "sqlite3_close" -SQLite3_Busy_TimeOut%(DatabaseHandle, TimeOut) : "sqlite3_busy_timeout" -SQLite3_Get_AutoCommit%(DatabaseHandle) : "sqlite3_get_autocommit" -SQLite3_Interrupt(DatabaseHandle) : "sqlite3_interrupt" -SQLite3_ErrCode%(DatabaseHandle) : "sqlite3_errcode" -SQLite3_ErrMsg$(DatabaseHandle) : "sqlite3_errmsg" -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" -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" -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" -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" -SQLite3_Bind_Int64%(StatementHandle, Index, Left, Right) : "sqlite3_bind_int64_ex" -SQLite3_Bind_Float%(StatementHandle, Index, Value#) : "sqlite3_bind_float" -SQLite3_Bind_Double%(StatementHandle, Index, Value#) : "sqlite3_bind_double" -SQLite3_Bind_Text%(StatementHandle, Index, Value$, LengthOfText, Destructor) : "sqlite3_bind_text" -SQLite3_Bind_Blob%(StatementHandle, Index, Value, LengthOfBlob, Destructor) : "sqlite3_bind_blob" -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_Int64(StatementHandle, ColumnIndex, outPtr*) : "sqlite3_column_int64_ex" -SQLite3_Column_Float#(StatementHandle, ColumnIndex) : "sqlite3_column_float" -SQLite3_Column_Double#(StatementHandle, ColumnIndex) : "sqlite3_column_double" -SQLite3_Column_Text$(StatementHandle, ColumnIndex) : "sqlite3_column_text" -SQLite3_Column_Bytes%(StatementHandle, ColumnIndex) : "sqlite3_column_bytes" -SQLite3_Column_Blob%(StatementHandle, ColumnIndex) : "sqlite3_column_blob" -; SQLite3 Wrapped -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" - -; Backwards Compatability - Containers ----------------------------------------- -; -- Lists -BlitzUtility_List_New%(obj*) : "BlitzList_New" -BlitzUtility_List_Activate(list%) : "BlitzList_Activate" -BlitzUtility_List_Deactivate(list%) : "BlitzList_Deactivate" -BlitzUtility_List_Destroy(list%) : "BlitzList_Delete" -; Backwards Compatability - Utility -------------------------------------------- -; -- Monitor/Display Enumeration -BlitzUtility_EnumerateDisplays() : "Display_Enumerate" -BlitzUtility_GetDisplayCount%() : "Display_Count" -BlitzUtility_GetDisplay(id%, rectangle*) : "Display_Get" -; -- Fast Indexing V1 (Array-based) -Indexer_Create%() : "IndexerV1_Create" -Indexer_GetFreeIndex%(indexer%) : "IndexerV1_GetFreeIndex" -Indexer_MarkFreeIndex(indexer%, index%) : "IndexerV1_MarkFreeIndex" -Indexer_Destroy(indexer%) : "IndexerV1_Destroy" -; -- Window Message Handler -BlitzUtility_InstallCloseHandler(hwnd%) : "WindowMessageHandler_Install" -BlitzUtility_UninstallCloseHandler(hwnd%) : "WindowMessageHandler_Uninstall" -BlitzUtility_GetCloseCount%(hwnd%) : "WindowMessageHandler_Message_Close" - -; Internal --------------------------------------------------------------------- +; 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" -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" - +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" -BlitzUtility_Kernel32_FlushFileBuffers%(hFile%) : "FlushFileBuffers" \ No newline at end of file +BU_Kernel32_FlushFileBuffers%(hFile%) : "FlushFileBuffers" +FlushFile%(hFile%) : "FlushFileBuffers" \ No newline at end of file diff --git a/BlitzUtility.vcxproj b/BlitzUtility.vcxproj index 1cebea8..4c440f2 100644 --- a/BlitzUtility.vcxproj +++ b/BlitzUtility.vcxproj @@ -127,34 +127,42 @@ + - + + + + + - - - - + + + - + + Cdecl CompileAsC Cdecl CompileAsC + + + - - - + + - + + diff --git a/BlitzUtility.vcxproj.filters b/BlitzUtility.vcxproj.filters index a2e4fe0..b562fa0 100644 --- a/BlitzUtility.vcxproj.filters +++ b/BlitzUtility.vcxproj.filters @@ -8,9 +8,6 @@ {48292af9-63a5-40ae-a447-ad7cecfddd8a} - - {ff6bcb4d-9140-40a9-80dd-3698b63bd1c1} - {4b84c339-4e83-489c-b421-2cf9fd9e72d1} @@ -23,29 +20,23 @@ {e8e48b8c-14c2-40b5-b48d-d9b55fe6852d} + + {ff6bcb4d-9140-40a9-80dd-3698b63bd1c1} + + + {605f2cca-0949-4af8-ab67-7042309a2abc} + + + {2b65f925-151d-4073-a06e-8d7d4603ef16} + Source Files - - Source Files\Containers - Source Files\Database\SQLite - - Source Files\Math - - - Source Files\Math - - - Source Files\Math - - - Source Files\Utility - Source Files\Utility @@ -58,32 +49,44 @@ Source Files\Utility + + Source Files\Type + + + Source Files\Type + + + Source Files\Utility + + + Source Files\Container + + + Source Files\Container + + + Source Files\Utility + + + Source Files\Math + + + Source Files\Math + + + Source Files\Libraries + Source Files - - Source Files\Containers - Source Files\Database\SQLite Source Files\Database\SQLite - - Source Files\Math - - - Source Files\Math - - - Source Files\Math - - - Source Files\Utility - Source Files\Utility @@ -93,6 +96,33 @@ Source Files\Utility + + Source Files\Type + + + Source Files\Type + + + Source Files\Utility + + + Source Files\Container + + + Source Files\Container + + + Source Files\Utility + + + Source Files\Math + + + Source Files\Math + + + Source Files\Libraries + @@ -101,5 +131,7 @@ Blitz Files + + \ No newline at end of file diff --git a/Containers/BlitzList.cpp b/Containers/BlitzList.cpp deleted file mode 100644 index 8bcba52..0000000 --- a/Containers/BlitzList.cpp +++ /dev/null @@ -1,86 +0,0 @@ -// BlitzUtility - Expanding the normal Blitz functionality. -// Copyright (C) 2015 Project Kube (Michael Fabian Dirks) -// -// This program is free software: you can redistribute it and/or modify -// it under the terms of the GNU Lesser General Public License as -// published by the Free Software Foundation, either version 3 of the -// License, or (at your option) any later version. -// -// This program is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. -// -// You should have received a copy of the GNU Lesser General Public License -// along with this program. If not, see . - -#include "BlitzList.h" - -std::list* BlitzUtility_Lists; - -void BlitzList_OnProcessAttach() { - BlitzUtility_Lists = new std::list(); -} - -void BlitzList_OnProcessDetach() { - BlitzUtility_Lists->clear(); - delete BlitzUtility_Lists; -} - -DLL_EXPORT void* BlitzList_New(uint32_t* elementPtr) { - BBVarElement* element = (BBVarElement*)(((uint32_t*)elementPtr) - 5); - BBVarType* type = (BBVarType*)(*(((uint32_t*)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*)((uint32_t*)type + 1); - element->nextPtr = (BBVarElement*)((uint32_t*)type + 1); - - BlitzUtility_Lists->push_back(bti); - return bti; -} -#pragma comment(linker, "/EXPORT:BlitzList_New=_BlitzList_New@4") - -DLL_EXPORT void BlitzList_Activate(uint32_t* 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; -} -#pragma comment(linker, "/EXPORT:BlitzList_Activate=_BlitzList_Activate@4") - -DLL_EXPORT void BlitzList_Deactivate(uint32_t* 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; -} -#pragma comment(linker, "/EXPORT:BlitzList_Deactivate=_BlitzList_Deactivate@4") - -DLL_EXPORT void BlitzList_Delete(uint32_t* list) { - BlitzTypeInfo* bti = (BlitzTypeInfo*)list; - BlitzUtility_Lists->remove(bti); - delete bti; -} -#pragma comment(linker, "/EXPORT:BlitzList_Delete=_BlitzList_Delete@4") \ No newline at end of file diff --git a/Containers/BlitzList.h b/Containers/BlitzList.h deleted file mode 100644 index 2d9a6fb..0000000 --- a/Containers/BlitzList.h +++ /dev/null @@ -1,58 +0,0 @@ -// BlitzUtility - Expanding the normal Blitz functionality. -// Copyright (C) 2015 Project Kube (Michael Fabian Dirks) -// -// This program is free software: you can redistribute it and/or modify -// it under the terms of the GNU Lesser General Public License as -// published by the Free Software Foundation, either version 3 of the -// License, or (at your option) any later version. -// -// This program is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. -// -// You should have received a copy of the GNU Lesser General Public License -// along with this program. If not, see . - -#pragma once -#include "dllmain.h" -#include -#include -#include -#include - -// 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 int pointers to variable struct) - //BBVar* fields[]; -}; - -struct BlitzTypeInfo { - BBVarType *type; - BBVarElement *lastNextPtr, *lastPrevPtr; - BBVarElement *ourNextPtr, *ourPrevPtr; -}; - -void BlitzList_OnProcessAttach(); -void BlitzList_OnProcessDetach(); \ No newline at end of file diff --git a/Database/SQLite/SQLite.cpp b/Database/SQLite/SQLite.cpp index e91437c..2a23d04 100644 --- a/Database/SQLite/SQLite.cpp +++ b/Database/SQLite/SQLite.cpp @@ -15,64 +15,75 @@ // along with this program. If not, see . #include "SQLite.h" +#include "..\BlitzPointer\Include\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 const char* SQLite_LibVersion() { - return sqlite3_libversion(); +DLL_METHOD int32_t DLL_CALL SQLite_Shutdown() { + return sqlite3_shutdown(); } -DLL_EXPORT uint32_t SQLite_LibVersionNumber() { - return sqlite3_libversion_number(); +DLL_METHOD int32_t DLL_CALL SQLite_Open(const char* file, sqlite3** db) { + return sqlite3_open(file, db); } -DLL_EXPORT uint32_t* SQLite_Open(char* dbFilename) { - sqlite3* dbHandle; - sqlite3_open(dbFilename, &dbHandle); - return (uint32_t*)dbHandle; +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 uint32_t* SQLite_Open_V2(char* dbFilename, uint32_t flags) { - sqlite3* dbHandle; - sqlite3_open_v2(dbFilename, &dbHandle, flags, nullptr); - return (uint32_t*)dbHandle; +DLL_METHOD int32_t DLL_CALL SQLite_Close(sqlite3* db) { + return sqlite3_close(db); } -DLL_EXPORT void SQLite_Close(uint32_t* dbHandlePtr) { - sqlite3* dbHandle = (sqlite3*)dbHandlePtr; - sqlite3_close(dbHandle); +DLL_METHOD int32_t DLL_CALL SQLite_Close_V2(sqlite3* db) { + return sqlite3_close_v2(db); } -DLL_EXPORT int SQLite_Busy_TimeOut() { - -}*/ - -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_ErrCode(sqlite3* db) { + return sqlite3_errcode(db); } -#pragma comment(linker, "/EXPORT:sqlite3_bind_int64_ex=_sqlite3_bind_int64_ex@16") -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_Extended_ErrCode(sqlite3* db) { + return sqlite3_extended_errcode(db); } -#pragma comment(linker, "/EXPORT:sqlite3_bind_float=_sqlite3_bind_float@12") -DLL_EXPORT void sqlite3_column_int64_ex(void* stmtPtr, uint32_t index, void* outPtr) { - sqlite3_int64 out = sqlite3_column_int64((sqlite3_stmt*)stmtPtr, index); - uint32_t* ourPtr = (uint32_t*)outPtr; - (*ourPtr) = (uint32_t)(out & 0xFFFFFFFF); - (*(ourPtr + 1)) = (uint32_t)(out >> 32); +DLL_METHOD const char* DLL_CALL SQLite_ErrMsg(sqlite3* db) { + return sqlite3_errmsg(db); } -#pragma comment(linker, "/EXPORT:sqlite3_column_int64_ex=_sqlite3_column_int64_ex@12") -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 const char* DLL_CALL SQLite_ErrStr(int32_t errCode) { + return sqlite3_errstr(errCode); } -#pragma comment(linker, "/EXPORT:sqlite3_column_float=_sqlite3_column_float@8") \ No newline at end of file + +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) { + return BlitzPointer_CallFunction1((int32_t)handler, (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); +} + + + + diff --git a/Database/SQLite/SQLite.h b/Database/SQLite/SQLite.h index d84736f..1046427 100644 --- a/Database/SQLite/SQLite.h +++ b/Database/SQLite/SQLite.h @@ -1,23 +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 . - +// 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 . + #pragma once #include "dllmain.h" #include "sqlite3.h" #include -void SQLite3_OnProcessAttach(); -void SQLite3_OnProcessDetach(); +// 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 diff --git a/Math/BlitzType.h b/Math/BlitzType.h deleted file mode 100644 index 60a4ddd..0000000 --- a/Math/BlitzType.h +++ /dev/null @@ -1,132 +0,0 @@ -#include "Common.h" -#include -#include - -// Rev-engineered from https://github.com/blitz-research/blitz3d/blob/master/compiler/declnode.cpp -#define BBVARTYPE_GLOBAL 0 -#define BBVARTYPE_INT 1 -#define BBVARTYPE_FLOAT 2 -#define BBVARTYPE_UNUSED 3 -#define BBVARTYPE_STRING 4 -#define BBVARTYPE_TYPE 5 -#define BBVARTYPE_ARRAY 6 - -struct BBVar { - int Type = -1; -}; - -struct BBVarGlobal { - int GlobalType = -1; - int* Value; -}; - -struct BBVarInt : BBVar { - int Value; -}; - -struct BBVarFloat : BBVar { - float Value; -}; - -struct BBVarUnused : BBVar { - // Not a Dim, as you can see here: - // https://github.com/blitz-research/blitz3d/blob/master/compiler/stmtnode.cpp#L86 -}; - -struct BBVarString : BBVar { - int Length; - char* Value; -}; - -struct BBVarElement; -struct BBVarType : BBVar { - BBVarElement used, free; - int fieldCount; // Field Info follows (Exactly int pointers to variable struct) - int* fields[]; -}; - -struct BBVarElement { - int* currentPtr; // Points towards fields. - int* nextPtr, prevPtr; - BBVarType* BBStructPtr; - int refCount; // Fields usually follow here, may be at another location, see currentPtr. - //BBVar* fields[]; -}; - -struct BBVarArray : BBVar { - int Size; //??? - BBVar* ArrayType; -}; - -std::string BBVar_Serialize(void* obj) { - std::stringstream myStream; - - BBVar* var = (BBVar*)obj; - switch (var->Type) { - case BBVARTYPE_GLOBAL: - BBVarGlobal* varGlobal = (BBVarGlobal*)obj; - myStream << "[Global] " << BBVar_Serialize(varGlobal->Value) << std::endl; - break; - case BBVARTYPE_INT: - BBVarInt* varInt = (BBVarInt*)obj; - myStream << "Int" << std::endl; - break; - case BBVARTYPE_FLOAT: - BBVarFloat* varFloat = (BBVarFloat*)obj; - myStream << "Float" << std::endl; - break; - case BBVARTYPE_UNUSED: - BBVarUnused* varUnused = (BBVarUnused*)obj; - myStream << "Unused" << std::endl; - break; - case BBVARTYPE_STRING: - BBVarString* varString = (BBVarString*)obj; - myStream << "String" << std::endl; - break; - case BBVARTYPE_TYPE: - BBVarType* varType = (BBVarType*)obj; - myStream << BBVarType_Serialize(varType); - break; - case BBVARTYPE_ARRAY: - BBVarArray* varArray = (BBVarArray*)obj; - myStream << "Array = " << std::endl; - break; - } - - return myStream.str(); -} - -std::string BBVarType_Serialize(BBVarType* obj, unsigned int indent = 0) { - std::stringstream myStream; - - std::stringstream myPaddingSS; - for (unsigned int pad = 0; pad < indent; pad++) { - myPaddingSS << " "; - } - std::string myPadding = myPaddingSS.str(); - - myStream << myPadding << "Type {" << std::endl; - for (unsigned int fld = 0; fld < obj->fieldCount; fld++) { - myStream << myPadding << " (" << fld << ") => " << BBVar_Serialize(obj->fields[fld]) << std::endl; - } - myStream << myPadding << "}" << std::endl; - - return myStream.str(); -} - -DLL_EXPORT(char*) SerializeObject(void* obj) { - return strdup(BBVar_Serialize(obj).c_str()); -} - -// Laut Mark Sibly: -struct BBType { - int obj_size; - BBObj usedList, freeList; -}; - -struct BBObj { - BBObj *curr; - BBObj *next, *prev; - int* bbtype; - int ref_cnt; -}; diff --git a/Math/Matrix3.cpp b/Math/Matrix3.cpp deleted file mode 100644 index 478c766..0000000 --- a/Math/Matrix3.cpp +++ /dev/null @@ -1,62 +0,0 @@ -// BlitzUtility - Expanding the normal Blitz functionality. -// Copyright (C) 2015 Project Kube (Michael Fabian Dirks) -// -// This program is free software: you can redistribute it and/or modify -// it under the terms of the GNU Lesser General Public License as -// published by the Free Software Foundation, either version 3 of the -// License, or (at your option) any later version. -// -// This program is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. -// -// You should have received a copy of the GNU Lesser General Public License -// along with this program. If not, see . - -#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); -} diff --git a/Math/Matrix3.h b/Math/Matrix3.h deleted file mode 100644 index de256a1..0000000 --- a/Math/Matrix3.h +++ /dev/null @@ -1,34 +0,0 @@ -// BlitzUtility - Expanding the normal Blitz functionality. -// Copyright (C) 2015 Project Kube (Michael Fabian Dirks) -// -// This program is free software: you can redistribute it and/or modify -// it under the terms of the GNU Lesser General Public License as -// published by the Free Software Foundation, either version 3 of the -// License, or (at your option) any later version. -// -// This program is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. -// -// You should have received a copy of the GNU Lesser General Public License -// along with this program. If not, see . - -#pragma once -#include -#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(); -}; - diff --git a/Math/Vector2.cpp b/Math/Vector2.cpp deleted file mode 100644 index 77f4984..0000000 --- a/Math/Vector2.cpp +++ /dev/null @@ -1,305 +0,0 @@ -// BlitzUtility - Expanding the normal Blitz functionality. -// Copyright (C) 2015 Project Kube (Michael Fabian Dirks) -// -// This program is free software: you can redistribute it and/or modify -// it under the terms of the GNU Lesser General Public License as -// published by the Free Software Foundation, either version 3 of the -// License, or (at your option) any later version. -// -// This program is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. -// -// You should have received a copy of the GNU Lesser General Public License -// along with this program. If not, see . - -#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); -} -#pragma comment(linker, "/EXPORT:Vector2_Set=_Vector2_Set@8") -#pragma comment(linker, "/EXPORT:Vector2_SetP=_Vector2_SetP@12") -#pragma comment(linker, "/EXPORT:Vector2_SetV=_Vector2_SetV@8") - -DLL_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); -} -#pragma comment(linker, "/EXPORT:Vector2_Add=_Vector2_Add@8") -#pragma comment(linker, "/EXPORT:Vector2_AddP=_Vector2_AddP@12") -#pragma comment(linker, "/EXPORT:Vector2_AddV=_Vector2_AddV@8") - -DLL_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); -} -#pragma comment(linker, "/EXPORT:Vector2_Sub=_Vector2_Sub@8") -#pragma comment(linker, "/EXPORT:Vector2_SubP=_Vector2_SubP@12") -#pragma comment(linker, "/EXPORT:Vector2_SubV=_Vector2_SubV@8") - -DLL_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); -} -#pragma comment(linker, "/EXPORT:Vector2_Mul=_Vector2_Mul@8") -#pragma comment(linker, "/EXPORT:Vector2_MulP=_Vector2_MulP@12") -#pragma comment(linker, "/EXPORT:Vector2_MulV=_Vector2_MulV@8") - -DLL_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); -} -#pragma comment(linker, "/EXPORT:Vector2_Div=_Vector2_Div@8") -#pragma comment(linker, "/EXPORT:Vector2_DivP=_Vector2_DivP@12") -#pragma comment(linker, "/EXPORT:Vector2_DivV=_Vector2_DivV@8") - -DLL_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); -} -#pragma comment(linker, "/EXPORT:Vector2_Length=_Vector2_Length@4") -#pragma comment(linker, "/EXPORT:Vector2_DistanceP=_Vector2_DistanceP@12") -#pragma comment(linker, "/EXPORT:Vector2_DistanceV=_Vector2_DistanceV@8") - -DLL_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(); -} -#pragma comment(linker, "/EXPORT:Vector2_DotP=_Vector2_DotP@12") -#pragma comment(linker, "/EXPORT:Vector2_DotV=_Vector2_DotV@8") -#pragma comment(linker, "/EXPORT:Vector2_Normalize=_Vector2_Normalize@4") - -DLL_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); -} -#pragma comment(linker, "/EXPORT:Vector2_Rotate=_Vector2_Rotate@8") -#pragma comment(linker, "/EXPORT:Vector2_RotateAroundP=_Vector2_RotateAroundP@16") -#pragma comment(linker, "/EXPORT:Vector2_RotateAroundV=_Vector2_RotateAroundV@12") - -DLL_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); -} -#pragma comment(linker, "/EXPORT:Vector2_DeltaRotation=_Vector2_DeltaRotation@4") -#pragma comment(linker, "/EXPORT:Vector2_DeltaRotationP=_Vector2_DeltaRotationP@12") -#pragma comment(linker, "/EXPORT:Vector2_DeltaRotationV=_Vector2_DeltaRotationV@8") - -DLL_EXPORT char* Vector2_Serialize(Vector2* a) { - return a->serialize(); -} -DLL_EXPORT void Vector2_Deserialize(Vector2* a, char* o) { - a->deserialize(o); -} -#pragma comment(linker, "/EXPORT:Vector2_Serialize=_Vector2_Serialize@4") -#pragma comment(linker, "/EXPORT:Vector2_Deserialize=_Vector2_Deserialize@8") diff --git a/Math/Vector2.h b/Math/Vector2.h deleted file mode 100644 index b720f77..0000000 --- a/Math/Vector2.h +++ /dev/null @@ -1,73 +0,0 @@ -// BlitzUtility - Expanding the normal Blitz functionality. -// Copyright (C) 2015 Project Kube (Michael Fabian Dirks) -// -// This program is free software: you can redistribute it and/or modify -// it under the terms of the GNU Lesser General Public License as -// published by the Free Software Foundation, either version 3 of the -// License, or (at your option) any later version. -// -// This program is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. -// -// You should have received a copy of the GNU Lesser General Public License -// along with this program. If not, see . - -#pragma once -#include "dllmain.h" -#ifndef _USE_MATH_DEFINES - #define _USE_MATH_DEFINES - #include - #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); -}; - diff --git a/Math/Vector3.cpp b/Math/Vector3.cpp deleted file mode 100644 index fda7a17..0000000 --- a/Math/Vector3.cpp +++ /dev/null @@ -1,373 +0,0 @@ -// BlitzUtility - Expanding the normal Blitz functionality. -// Copyright (C) 2015 Project Kube (Michael Fabian Dirks) -// -// This program is free software: you can redistribute it and/or modify -// it under the terms of the GNU Lesser General Public License as -// published by the Free Software Foundation, either version 3 of the -// License, or (at your option) any later version. -// -// This program is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. -// -// You should have received a copy of the GNU Lesser General Public License -// along with this program. If not, see . - -#include "Vector3.h" - -void Vector3::set(const float &o) -{ - this->X = o; - this->Y = o; - this->Z = o; -} -void Vector3::set(const float &x, const float &y, const float &z) -{ - this->X = x; - this->Y = y; - this->Z = z; -} -void Vector3::set(const Vector3 &o) -{ - if (this != &o) { - this->X = o.X; - this->Y = o.Y; - this->Z = o.Z; - } -} - -void Vector3::add(const float &o) -{ - this->X += o; - this->Y += o; - this->Z += o; -} -void Vector3::add(const float &x, const float &y, const float &z) -{ - this->X += x; - this->Y += y; - this->Z += z; -} -void Vector3::add(const Vector3 &o) -{ - this->X += o.X; - this->Y += o.Y; - this->Z += o.Z; -} - -void Vector3::sub(const float &o) -{ - this->X -= o; - this->Y -= o; - this->Z -= o; -} -void Vector3::sub(const float &x, const float &y, const float &z) -{ - this->X -= x; - this->Y -= y; - this->Z -= z; -} -void Vector3::sub(const Vector3 &o) -{ - this->X -= o.X; - this->Y -= o.Y; - this->Z -= o.Z; -} - -void Vector3::mul(const float &o) -{ - this->X *= o; - this->Y *= o; - this->Z *= o; -} -void Vector3::mul(const float &x, const float &y, const float &z) -{ - this->X *= x; - this->Y *= y; - this->Z *= z; -} -void Vector3::mul(const Vector3 &o) -{ - this->X *= o.X; - this->Y *= o.Y; - this->Z *= o.Z; -} - -void Vector3::div(const float &o) -{ - this->X /= o; - this->Y /= o; - this->Z /= o; -} -void Vector3::div(const float &x, const float &y, const float &z) -{ - this->X /= x; - this->Y /= y; - this->Z /= z; -} -void Vector3::div(const Vector3 &o) -{ - this->X /= o.X; - this->Y /= o.Y; - this->Z /= o.Z; -} - -float Vector3::length() -{ - return sqrt(this->X * this->X + this->Y * this->Y + this->Z * this->Z); -} -float Vector3::distance(const float &x, const float &y, const float &z) -{ - float X = (this->X - x); - float Y = (this->Y - y); - float Z = (this->Z - z); - return sqrt(X * X + Y * Y + Z * Z); -} -float Vector3::distance(const Vector3 &o) -{ - float X = (this->X - o.X); - float Y = (this->Y - o.Y); - float Z = (this->Z - o.Z); - return sqrt(X * X + Y * Y + Z * Z); -} - -float Vector3::dot(const float &x, const float &y, const float &z) -{ - return (this->X * x) + (this->Y * y) + (this->Z * z); -} -float Vector3::dot(const Vector3 &o) -{ - return (this->X * o.X) + (this->Y * o.Y) + (this->Z * o.Z); -} -Vector3 Vector3::cross(const float &x, const float &y, const float &z) -{ - Vector3* data = new Vector3(); - data->X = (this->Y * z) - (this->Z * y); - data->Y = (this->Z * x) - (this->X * z); - data->Z = (this->X * y) - (this->Y * x); - return *data; -} -Vector3 Vector3::cross(const Vector3 &o) -{ - Vector3* data = new Vector3(); - data->X = (this->Y * o.Z) - (this->Z * o.Y); - data->Y = (this->Z * o.X) - (this->X * o.Z); - data->Z = (this->X * o.Y) - (this->Y * o.X); - return *data; -} -void Vector3::normalize() -{ - this->div(this->length()); -} - -void Vector3::rotate(float &pitch, float &yaw, float &roll) -{ - float** matrix = new float*[3]; - matrix[0] = new float[3]; matrix[1] = new float[3]; matrix[2] = new float[3]; - matrix[0][0] = cos(yaw) * cos(roll); matrix[0][1] = -sin(roll); matrix[0][2] = sin(yaw); - matrix[1][0] = sin(roll); matrix[1][1] = cos(pitch) * cos(roll); matrix[1][2] = -sin(pitch); - matrix[2][0] = -sin(yaw); matrix[2][1] = sin(pitch); matrix[2][2] = cos(pitch) * cos(yaw); - - float X = (this->X * matrix[0][0]) + (this->Y * matrix[0][1]) + (this->Z * matrix[0][2]); - float Y = (this->X * matrix[1][0]) + (this->Y * matrix[1][1]) + (this->Z * matrix[1][2]); - float Z = (this->X * matrix[2][0]) + (this->Y * matrix[2][1]) + (this->Z * matrix[2][2]); - this->X = X; this->Y = Y; this->Z = Z; -} -void Vector3::rotateAround(const float &x, const float &y, const float &z, float &pitch, float &yaw, float &roll) -{ - this->sub(x, y, z); - this->rotate(pitch, yaw, roll); - this->add(x, y, z); -} -void Vector3::rotateAround(Vector3 &o, float &pitch, float &yaw, float &roll) -{ - this->sub(o); - this->rotate(pitch, yaw, roll); - this->add(o); -} -float Vector3::deltaPitch() { - return (float)(atan(this->X / -this->Y) * (180.0 / M_PI)); -} -float Vector3::deltaPitch(const float &x, const float &y, const float &z) -{ - return (float)(atan((this->X - x) / (-(this->Y - y))) * (180.0 / M_PI)); -} -float Vector3::deltaPitch(Vector3 &o) -{ - return (float)(atan((this->X - o.X) / (-(this->Y - o.Y))) * (180.0 / M_PI)); -} -float Vector3::deltaYaw() { - return (float)(atan(sqrt((this->X * this->X) + (this->Y * this->Y)) / this->Z) * (180.0 / M_PI)); -} -float Vector3::deltaYaw(const float &x, const float &y, const float &z) -{ - float X = (this->X - x); - float Y = (this->Y - y); - return (float)(atan(sqrt((X * X) + (Y * Y)) / (this->Z - z)) * (180.0 / M_PI)); -} -float Vector3::deltaYaw(Vector3 &o) -{ - float X = (this->X - o.X); - float Y = (this->Y - o.Y); - return (float)(atan(sqrt((X * X) + (Y * Y)) / (this->Z - o.Z)) * (180.0 / M_PI)); -} - -char* Vector3::serialize() -{ - char* data = new char[13]; - - memcpy(data, this->Xc, 4); - memcpy(data + 4, this->Yc, 4); - memcpy(data + 8, this->Zc, 4); - data[12] = 0; - - return data; -} -void Vector3::deserialize(char* o) -{ - memcpy(o, this->Xc, 4); - memcpy(o + 4, this->Yc, 4); - memcpy(o + 8, this->Zc, 4); -} - -/* ------------------------- Exported Functionality ------------------------- */ -DLL_EXPORT void Vector3_Set(Vector3* a, float o) { - a->set(o); -} -DLL_EXPORT 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) { - 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) { - a->add(o); -} -DLL_EXPORT 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) { - 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) { - a->sub(o); -} -DLL_EXPORT 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) { - 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) { - a->mul(o); -} -DLL_EXPORT 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) { - 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) { - a->div(o); -} -DLL_EXPORT 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) { - 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) { - return (float)a->length(); -} -DLL_EXPORT 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) { - 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) { - return (float)a->dot(x, y, z); -} -DLL_EXPORT 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) { - Vector3 temp = a->cross(x, y, z); - *out = temp; -} -DLL_EXPORT void Vector3_CrossV(Vector3* a, Vector3* b, Vector3* out) { - Vector3 temp = a->cross(*b); - *out = temp; -} -DLL_EXPORT 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) { - a->rotate(pitch, yaw, roll); -} -DLL_EXPORT 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) { - 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) { - return (float)a->deltaPitch(x, y, z); -} -DLL_EXPORT 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) { - return (float)a->deltaYaw(x, y, z); -} -DLL_EXPORT 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) { - return a->serialize(); -} -DLL_EXPORT 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") diff --git a/Math/Vector3.h b/Math/Vector3.h deleted file mode 100644 index 6d255fb..0000000 --- a/Math/Vector3.h +++ /dev/null @@ -1,81 +0,0 @@ -// BlitzUtility - Expanding the normal Blitz functionality. -// Copyright (C) 2015 Project Kube (Michael Fabian Dirks) -// -// This program is free software: you can redistribute it and/or modify -// it under the terms of the GNU Lesser General Public License as -// published by the Free Software Foundation, either version 3 of the -// License, or (at your option) any later version. -// -// This program is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. -// -// You should have received a copy of the GNU Lesser General Public License -// along with this program. If not, see . - -#pragma once -#include "dllmain.h" -#ifndef _USE_MATH_DEFINES - #define _USE_MATH_DEFINES - #include - #undef _USE_MATH_DEFINES -#endif - -struct Vector3 { - union { - float X; - char Xc[4]; - }; - union { - float Y; - char Yc[4]; - }; - union { - float Z; - char Zc[4]; - }; - - void set(const float &o); - void set(const float &x, const float &y, const float &z); - void set(const Vector3 &o); - - void add(const float &o); - void add(const float &x, const float &y, const float &z); - void add(const Vector3 &o); - - void sub(const float &o); - void sub(const float &x, const float &y, const float &z); - void sub(const Vector3 &o); - - void mul(const float &o); - void mul(const float &x, const float &y, const float &z); - void mul(const Vector3 &o); - - void div(const float &o); - void div(const float &x, const float &y, const float &z); - void div(const Vector3 &o); - - float length(); - float distance(const float &x, const float &y, const float &z); - float distance(const Vector3 &o); - - float dot(const float &x, const float &y, const float &z); - float dot(const Vector3 &o); - Vector3 cross(const float &x, const float &y, const float &z); - Vector3 cross(const Vector3 &o); - void normalize(); - - void rotate(float &pitch, float &yaw, float &roll); - void rotateAround(const float &x, const float &y, const float &z, float &pitch, float &yaw, float &roll); - void rotateAround(Vector3 &o, float &pitch, float &yaw, float &roll); - float deltaPitch(); - float deltaPitch(const float &x, const float &y, const float &z); - float deltaPitch(Vector3 &o); - float deltaYaw(); - float deltaYaw(const float &x, const float &y, const float &z); - float deltaYaw(Vector3 &o); - - char* serialize(); - void deserialize(char* o); -}; \ No newline at end of file diff --git a/Utility/Display.cpp b/Utility/Display.cpp deleted file mode 100644 index 6fe6f17..0000000 --- a/Utility/Display.cpp +++ /dev/null @@ -1,73 +0,0 @@ -// BlitzUtility - Expanding the normal Blitz functionality. -// Copyright (C) 2015 Project Kube (Michael Fabian Dirks) -// -// This program is free software: you can redistribute it and/or modify -// it under the terms of the GNU Lesser General Public License as -// published by the Free Software Foundation, either version 3 of the -// License, or (at your option) any later version. -// -// This program is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. -// -// You should have received a copy of the GNU Lesser General Public License -// along with this program. If not, see . - -#include "Display.h" - -std::list* Display_List = NULL; - -void Display_OnProcessAttach() { - Display_List = new std::list(); -} - -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); -} -#pragma comment(linker, "/EXPORT:Display_Enumerate=_Display_Enumerate@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(); -} -#pragma comment(linker, "/EXPORT:Display_Count=_Display_Count@0") - -DLL_EXPORT void Display_Get(uint32_t displayId, LPRECT display) { - if (Display_List->size() > 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; - } - } -} -#pragma comment(linker, "/EXPORT:Display_Get=_Display_Get@8") - diff --git a/Utility/Display.h b/Utility/Display.h deleted file mode 100644 index 00a6556..0000000 --- a/Utility/Display.h +++ /dev/null @@ -1,31 +0,0 @@ -// BlitzUtility - Expanding the normal Blitz functionality. -// Copyright (C) 2015 Project Kube (Michael Fabian Dirks) -// -// This program is free software: you can redistribute it and/or modify -// it under the terms of the GNU Lesser General Public License as -// published by the Free Software Foundation, either version 3 of the -// License, or (at your option) any later version. -// -// This program is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. -// -// You should have received a copy of the GNU Lesser General Public License -// along with this program. If not, see . - -#pragma once -#include "dllmain.h" -#include - -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); \ No newline at end of file diff --git a/Utility/IndexerV1.cpp b/Utility/IndexerV1.cpp index a0e0f52..9440f4b 100644 --- a/Utility/IndexerV1.cpp +++ b/Utility/IndexerV1.cpp @@ -17,79 +17,110 @@ #pragma once #include "IndexerV1.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 +void IndexerV1::mark(uint32_t index, bool used) { + uint8_t bit = index & 0x3F; + index = index >> 6; -unsigned int IndexerV1::GetFreeIndex() -{ - unsigned int index = lastAssignedIndex + 1; + this->indexes[index] ^= (!(uint64_t)used ^ this->indexes[index]) & (1ULL << bit); +} - bool foundIndex = false; - char indexBitOffset = 0; +bool IndexerV1::is(uint32_t index, bool used) { + uint8_t bit = index & 0x3F; + index = index >> 6; - // We use 16 offsets here to speed up the search for a free index. - while (foundIndex == false) { - index = index + 64; + return (!!(this->indexes[index] & (1ULL << bit)) == used); +} - uint64_t toCheck = this->indexes[index >> 6]; - for (indexBitOffset = 0; indexBitOffset < 64; indexBitOffset++) { - if ((toCheck & (1ULL << indexBitOffset)) == false) { - foundIndex = true; +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; } } } - index = index + indexBitOffset; - // Mark Index as in use. - this->indexes[index >> 6] |= 1ULL << indexBitOffset; - lastAssignedIndex = index; - - return lastAssignedIndex; + if (hasFoundIndex) { + this->mark(foundIndex, true); + return foundIndex; + } + + return FALSE; } -void IndexerV1::MarkFreeIndex(int index) -{ - unsigned short bitFlip = index % 64; +uint32_t IndexerV1::count(bool used) { + uint32_t amount = 0; - // Mark index as unused. - this->indexes[index >> 6] &= ~(1ULL << bitFlip); + 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_EXPORT void* IndexerV1_Create() { - IndexerV1* indexer = new IndexerV1(); - return indexer; +DLL_METHOD IndexerV1* DLL_CALL BU_IndexerV1_Create() { + return new IndexerV1(); } -#pragma comment(linker, "/EXPORT:IndexerV1_Create=_IndexerV1_Create@0") -DLL_EXPORT int IndexerV1_GetFreeIndex(uint32_t* indexerPtr) { - IndexerV1* indexer = (IndexerV1*)indexerPtr; - return indexer->GetFreeIndex(); -} -#pragma comment(linker, "/EXPORT:IndexerV1_GetFreeIndex=_IndexerV1_GetFreeIndex@4") - -DLL_EXPORT void IndexerV1_MarkFreeIndex(uint32_t* indexerPtr, uint32_t Index) { - IndexerV1* indexer = (IndexerV1*)indexerPtr; - indexer->MarkFreeIndex(Index); -} -#pragma comment(linker, "/EXPORT:IndexerV1_MarkFreeIndex=_IndexerV1_MarkFreeIndex@8") - -DLL_EXPORT void IndexerV1_Destroy(uint32_t* indexerPtr) { - IndexerV1* indexer = (IndexerV1*)indexerPtr; +DLL_METHOD void DLL_CALL BU_IndexerV1_Destroy(IndexerV1* indexer) { delete indexer; } -#pragma comment(linker, "/EXPORT:IndexerV1_Destroy=_IndexerV1_Destroy@4") + +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); +} diff --git a/Utility/IndexerV1.h b/Utility/IndexerV1.h index a92f874..1170438 100644 --- a/Utility/IndexerV1.h +++ b/Utility/IndexerV1.h @@ -20,15 +20,42 @@ #include "dllmain.h" // 67108864 = 2 ^ 32 / 64 -#define INDEXER_INDEXES 67108864 +#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[67108864]; + uint64_t indexes[INDEXER_INDEXES]; uint32_t lastAssignedIndex; - unsigned int GetFreeIndex(); - void MarkFreeIndex(int index); + 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") diff --git a/Utility/IndexerV2.cpp b/Utility/IndexerV2.cpp index 61057d9..fbf0e9d 100644 --- a/Utility/IndexerV2.cpp +++ b/Utility/IndexerV2.cpp @@ -1,101 +1,119 @@ -// 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 . - +// 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 . + #include "IndexerV2.h" IndexerV2::IndexerV2() { this->range.reserve(32); } - IndexerV2::~IndexerV2() { this->range.clear(); } -uint32_t IndexerV2::GetIndex() { - uint32_t index = 0; - +void IndexerV2::mark(uint32_t index, bool used) { if (this->range.size() == 0) { - this->range.push_back(IndexerV2Range(0, 0)); + if (used == true) + this->range.push_back(IndexerV2Range(index, index)); } else { - auto range = this->range[0]; - - if (range.min > 0) { - index = --range.min; - } else { - index = ++range.max; - } - - // Combine the next and current element if we need to. - if (this->range.size() > 1) { - auto rangeNext = this->range[1]; - - if (rangeNext.min == (index + 1)) { - uint32_t newMin, newMax; - newMin = range.min; - newMax = rangeNext.max; - - this->range.erase(this->range.begin(), this->range.begin() + 1); - this->range.insert(this->range.begin(), IndexerV2Range(newMin, newMax)); + 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; + } } } } - - return index; } -void IndexerV2::MarkIndex(uint32_t index) { - IndexerV2Range* rangePtr; - uint32_t rangePtrPos; - - uint32_t rangeSize = this->range.size(); - for (uint32_t rangePos = 0; rangePos < rangeSize; rangePos++) { - auto range = this->range[rangePos]; - - if (index >= range.min && index <= range.max) { - rangePtr = ⦥ - rangePtrPos = rangePos; +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; } } - - // Temporarily store the values needed for swapping. - uint32_t leftMin, leftMax, rightMin, rightMax; - leftMin = rangePtr->min; leftMax = index - 1; - rightMin = index + 1; rightMax = rangePtr->max; - - // Due to us doing this instead of push_back, our vector is always sorted. - auto rangeIter = this->range.begin() + rangePtrPos; - this->range.erase(rangeIter); - this->range.insert(rangeIter, IndexerV2Range(leftMin, leftMax)); - this->range.insert(rangeIter + 1, IndexerV2Range(rightMin, rightMax)); + return (isUsed == used); } -bool IndexerV2::IsFree(uint32_t index) { - uint32_t rangeSize = this->range.size(); - for (uint32_t rangePos = 0; rangePos < rangeSize; rangePos++) { - auto range = this->range[rangePos]; - if (index >= range.min && index <= range.max) - return false; +uint32_t IndexerV2::get() { + if (this->range.size() == 0) { + this->range.push_back(IndexerV2Range(0, 0)); + return 0; } - return true; + + // We only need to check the first element to get a new free index. + std::vector::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::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; } -bool IndexerV2::IsUsed(uint32_t index) { - return !IsFree(index); +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) { @@ -103,32 +121,51 @@ IndexerV2::IndexerV2Range::IndexerV2Range(uint32_t min, uint32_t max) { this->max = max; } -DLL_EXPORT void* IndexerV2_Create() { - IndexerV2* indexerPtr = new IndexerV2(); - return indexerPtr; -} -#pragma comment(linker, "/EXPORT:IndexerV2_Create=_IndexerV2_Create@0") -DLL_EXPORT void IndexerV2_Destroy(uint32_t indexerIntPtr) { - IndexerV2* indexerPtr = (IndexerV2*)indexerIntPtr; - delete indexerPtr; +DLL_METHOD IndexerV2* DLL_CALL BU_IndexerV2_Create() { + return new IndexerV2(); } -#pragma comment(linker, "/EXPORT:IndexerV2_Destroy=_IndexerV2_Destroy@4") -DLL_EXPORT uint32_t IndexerV2_GetIndex(uint32_t indexerIntPtr) { - IndexerV2* indexerPtr = (IndexerV2*)indexerIntPtr; - return indexerPtr->GetIndex(); +DLL_METHOD void DLL_CALL BU_IndexerV2_Destroy(IndexerV2* indexer) { + delete indexer; } -#pragma comment(linker, "/EXPORT:IndexerV2_GetIndex=_IndexerV2_GetIndex@4") -DLL_EXPORT uint32_t IndexerV2_IsFree(uint32_t indexerIntPtr, uint32_t index) { - IndexerV2* indexerPtr = (IndexerV2*)indexerIntPtr; - return indexerPtr->IsFree(index); +DLL_METHOD void DLL_CALL BU_IndexerV2_Mark(IndexerV2* indexer, uint32_t used, uint32_t index) { + indexer->mark(index, used != 0); } -#pragma comment(linker, "/EXPORT:IndexerV2_IsFree=_IndexerV2_IsFree@8") -DLL_EXPORT uint32_t IndexerV2_IsUsed(uint32_t indexerIntPtr, uint32_t index) { - IndexerV2* indexerPtr = (IndexerV2*)indexerIntPtr; - return indexerPtr->IsUsed(index); +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); } -#pragma comment(linker, "/EXPORT:IndexerV2_IsUsed=_IndexerV2_IsUsed@8") diff --git a/Utility/IndexerV2.h b/Utility/IndexerV2.h index 0d52915..c25be31 100644 --- a/Utility/IndexerV2.h +++ b/Utility/IndexerV2.h @@ -1,19 +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 . - +// 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 . + #pragma once #include "dllmain.h" #include @@ -23,11 +23,11 @@ class IndexerV2 { IndexerV2(); ~IndexerV2(); - uint32_t GetIndex(); - void MarkIndex(uint32_t index); + void mark(uint32_t index, bool used); + bool is(uint32_t index, bool used); + uint32_t get(); + uint32_t count(bool used); - bool IsFree(uint32_t index); - bool IsUsed(uint32_t index); private: struct IndexerV2Range { uint32_t min, max; @@ -38,3 +38,28 @@ class IndexerV2 { std::vector 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") + diff --git a/Utility/WindowMessageHandler.cpp b/Utility/WindowMessageHandler.cpp index 0b9414e..064f1a8 100644 --- a/Utility/WindowMessageHandler.cpp +++ b/Utility/WindowMessageHandler.cpp @@ -19,20 +19,20 @@ std::list* WindowMessageHandler_List; -void WindowMessageHandler_OnProcessAttach() { +void BU_WindowMessageHandler_OnProcessAttach() { WindowMessageHandler_List = new std::list(); } -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) { @@ -60,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) { @@ -121,5 +114,5 @@ DLL_EXPORT int WindowMessageHandler_Message_Close(HWND hwnd) { } return 0; } -#pragma comment(linker, "/EXPORT:WindowMessageHandler_Message_Close=_WindowMessageHandler_Message_Close@4") + diff --git a/Utility/WindowMessageHandler.h b/Utility/WindowMessageHandler.h index af14497..8704c37 100644 --- a/Utility/WindowMessageHandler.h +++ b/Utility/WindowMessageHandler.h @@ -33,9 +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); -DLL_EXPORT void WindowMessageHandler_Install(HWND hwnd); -DLL_EXPORT void WindowMessageHandler_Uninstall(HWND hwnd); \ No newline at end of file +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") \ No newline at end of file diff --git a/dllmain.cpp b/dllmain.cpp index a6a2f00..39c654a 100644 --- a/dllmain.cpp +++ b/dllmain.cpp @@ -14,47 +14,19 @@ // You should have received a copy of the GNU Lesser General Public License // along with this program. If not, see . -#include "dllmain.h" - +#pragma once #include -#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\IndexerV1.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; diff --git a/dllmain.h b/dllmain.h index 34de5ca..7c701b5 100644 --- a/dllmain.h +++ b/dllmain.h @@ -23,8 +23,42 @@ // Memory Management #include +// Strings +#include +#include +#include + // Platform specific: Windows #include // Macros -#define DLL_EXPORT extern "C" //__declspec(dllexport) \ No newline at end of file +#ifndef IMPORT + #define DLL_METHOD extern "C" //__declspec(dllexport) +#else + #define DLL_METHOD extern "c" __declspec(dllimport) +#endif +#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; +} \ No newline at end of file