xaymar/BlitzUtility
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Preparations for 1.2 update.

Browse Source
This commit is contained in:
Michael Dirks
2015-06-20 15:52:40 +02:00
parent f22d496961
commit 7a96afeda7
25 changed files with 1036 additions and 2080 deletions
Download Patch File Download Diff File Expand all files Collapse all files
BlitzUtility.bb
+309 -204
View File
@@ -14,9 +14,316 @@
; You should have received a copy of the GNU Lesser General Public License
; along with this program. If not, see <http:;www.gnu.org/licenses/>.
;----------------------------------------------------------------
; Utility ----------------------------------------------------------------------
;-- Mass Operation
; Constants: Supported Types
Const BU_MASSOP_TYPE_DOUBLE = 0
Const BU_MASSOP_TYPE_LONGLONG = 1
Const BU_MASSOP_TYPE_VECTOR2 = 10
Const BU_MASSOP_TYPE_VECTOR3 = 11
; Constants: Supported OpCodes
Const BU_MASSOP_OPCODE_CREATE = 0
Const BU_MASSOP_OPCODE_DESTROY = 1
Const BU_MASSOP_OPCODE_COPY = 2
Const BU_MASSOP_OPCODE_TEMPCREATE = 5
Const BU_MASSOP_OPCODE_TEMPDESTROY = 6
Const BU_MASSOP_OPCODE_TEMPCLEANUP = 7
Const BU_MASSOP_OPCODE_SET = 10
Const BU_MASSOP_OPCODE_ADD = 11
Const BU_MASSOP_OPCODE_SUB = 12
Const BU_MASSOP_OPCODE_MUL = 13
Const BU_MASSOP_OPCODE_DIV = 14
Const BU_MASSOP_OPCODE_COMPARE = 15
; GoTo
; leftOperand: new massop index
Const BU_MASSOP_OPCODE_GOTO = 249
; SetOpCode
; leftOperand: target massop index
; rightOperand: new OpCode
Const BU_MASSOP_OPCODE_SETOPCODE = 250
; CopyLeft
; leftOperand: source massop index
; rightOperand: target massop index
; result: target position (0/leftOperand, 1/rightOperand, 2/result)
Const BU_MASSOP_OPCODE_COPYLEFT = 251
; CopyRight
; leftOperand: source massop index
; rightOperand: target massop index
; result: target position (0/leftOperand, 1/rightOperand, 2/result)
Const BU_MASSOP_OPCODE_COPYRIGHT = 252
; CopyOut
; leftOperand: source massop index
; rightOperand: target massop index
; result: target position (0/leftOperand, 1/rightOperand, 2/result)
Const BU_MASSOP_OPCODE_COPYOUT = 253
; If - Compares the result of <leftOperand> with the result of <rightOperand>,
; skipping over <result> instructions if the results match.
; leftOperand: source massop index
; rightOperand: target massop index
; result: amount to skip
Const BU_MASSOP_OPCODE_IF = 254
; IfValue - Compares the result of <leftOperand> with <rightOperand>, skipping
; over <result> instructions if the results match.
; leftOperand: source massop index
; rightOperand: target massop index
; result: amount to skip
Const BU_MASSOP_OPCODE_IFVALUE = 255
; Helpers ----------------------------------------------------------------------
Type BU_Point
Field X,Y
End Type
Type BU_Rectangle
Field X,Y,X2,Y2
End Type
Function BU_Helper_Window_LockPointer(HWND% = 0)
If HWND = 0 Then
BU_User32_ClipCursor(0)
Else
Local tRect.BU_Rectangle = New BU_Rectangle
; Retrieve Information about the selected window.
BU_User32_GetWindowRect(HWND, tRect)
; Correct Rectangle to be inside the selected Window.
tRect\X2=tRect\X2-1
tRect\Y2=tRect\Y2-1
; Update clipping area.
BU_User32_ClipCursor(tRect)
Delete tRect
EndIf
End Function
Function BU_Helper_Window_LockPointerAuto(HWND=0)
If BU_User32_GetActiveWindow() = HWND Then
BU_Helper_Window_LockPointer(HWND)
Else
BU_Helper_Window_LockPointer(0)
EndIf
End Function
Function BU_Helper_Window_MakeBorderless(HWND=0)
If HWND = 0 Then HWND = SystemProperty("AppHwnd")
; Create Storage
Local tRect.BU_Rectangle = New BU_Rectangle
; Client Information
BU_User32_GetClientRect(HWND, tRect)
Local clientX, clientY, clientW, clientH
clientX = tRect\X
clientY = tRect\Y
clientW = tRect\X2 - clientX
clientH = tRect\Y2 - clientY
; Convert Client coordinates to screen position.
Local tPoint.BU_Point = New BU_Point
BU_User32_ClientToScreen(HWND, tPoint)
Local realClientX, realClientY
realClientX = tPoint\X
realClientY = tPoint\Y
Delete tPoint
; Window Information
BU_User32_GetWindowRect(HWND, tRect)
Local windowX, windowY, windowW, windowH
windowX = tRect\X
windowY = tRect\Y
windowW = tRect\X2 - windowX
windowH = tRect\Y2 - windowY
; Delete Storage
Delete tRect
; Calculate new position and size.
Local newX, newY, newW, newH
newX = windowX + (realClientX - windowX)
newY = windowY + (realClientY - windowY)
newW = clientW
newH = clientH
; DebugLog "Window: " + RSet(windowX,8) + "," + RSet(windowY,8) + ":" + RSet(windowW,8) + "," + RSet(windowH,8)
; DebugLog "Client: " + RSet(clientX,8) + "," + RSet(clientY,8) + ":" + RSet(clientW,8) + "," + RSet(clientH,8)
; DebugLog "RealClient: " + RSet(realClientX,8) + "," + RSet(realClientY,8)
; DebugLog "Diff: " + RSet(realClientX - windowX,8) + "," + RSet(realClientY - windowY,8) + ":" + RSet(windowW - clientW,8) + "," + RSet(windowH - clientH,8)
; DebugLog "New: " + RSet(newX,8) + "," + RSet(newY,8) + ":" + RSet(newW,8) + "," + RSet(newH,8)
; Apply changes
BU_User32_SetWindowLong HWND, -16, $01000000
BU_User32_SetWindowPos HWND, 0, newX, newY, newW, newH, $4 + $10 + $20 + $40
End Function
Function BU_Helper_Window_Center(HWND=0, Monitor=0)
Local displayEnumerator = BU_DisplayEnumerator_Create()
Local displayAmount = BU_DisplayEnumerator_Enumerate(displayEnumerator)
If Monitor >= displayAmount Then Monitor = displayAmount - 1
If Monitor < 0 Then Monitor = 0
; Get Display Information
Local displayRectangle.BU_Rectangle = New BU_Rectangle
BU_DisplayEnumerator_Retrieve displayEnumerator, Monitor, displayRectangle
BU_DisplayEnumerator_Destroy displayEnumerator
Local displayX, displayY, displayW, displayH
displayX = displayRectangle\X
displayY = displayRectangle\Y
displayW = displayRectangle\X2 - displayRectangle\X
displayH = displayRectangle\Y2 - displayRectangle\Y
Delete displayRectangle
; Get Window Information
Local windowRectangle.BU_Rectangle = New BU_Rectangle
BU_User32_GetWindowRect(HWND, windowRectangle)
Local windowW%, windowH%
windowW = windowRectangle\X2 - windowRectangle\X
windowH = windowRectangle\Y2 - windowRectangle\Y
Delete windowRectangle
; Calculate new position and size.
Local newX, newY, newW, newH
newX = displayX + (displayW/2 - windowW/2)
newY = displayY + (displayH/2 - windowH/2)
newW = windowW
newH = windowH
; DebugLog "New: " + RSet(newX,8) + "," + RSet(newY,8) + ":" + RSet(newW,8) + "," + RSet(newH,8)
; Apply changes
BU_User32_SetWindowPos HWND, 0, newX, newY, newW, newH, $1 + $4 + $10 + $20 + $40
End Function
; Database ---------------------------------------------------------------------
;-- SQLite3
;;[Block] Return Codes / Error Codes
;; Many SQLite functions return an integer result code from the set shown
;; here in order to indicate success or failure.
;;
;; New error codes may be added in future versions of SQLite.
;Const SQLITE_OK% = 0 ; Successful result
;Const SQLITE_ERROR% = 1 ; SQL error or missing database
;Const SQLITE_INTERNAL% = 2 ; Internal logic error in SQLite
;Const SQLITE_PERM% = 3 ; Access permission denied
;Const SQLITE_ABORT% = 4 ; Callback routine requested an abort
;Const SQLITE_BUSY% = 5 ; The database file is locked
;Const SQLITE_LOCKED% = 6 ; A table in the database is locked
;Const SQLITE_NOMEM% = 7 ; A malloc() failed
;Const SQLITE_READONLY% = 8 ; Attempt to write a readonly database
;Const SQLITE_INTERRUPT% = 9 ; Operation terminated by SQLite3_Interrupt()
;Const SQLITE_IOERR% = 10 ; Some kind of disk I/O error occurred
;Const SQLITE_CORRUPT% = 11 ; The database disk image is malformed
;Const SQLITE_NOTFOUND% = 12 ; Unknown opcode in sqlite3_file_control()
;Const SQLITE_FULL% = 13 ; Insertion failed because database is full
;Const SQLITE_CANTOPEN% = 14 ; Unable to open the database file
;Const SQLITE_PROTOCOL% = 15 ; Database lock protocol error
;Const SQLITE_EMPTY% = 16 ; Database is empty
;Const SQLITE_SCHEMA% = 17 ; The database schema changed
;Const SQLITE_TOOBIG% = 18 ; String or BLOB exceeds size limit
;Const SQLITE_CONSTRAINT% = 19 ; Abort due to constraint violation
;Const SQLITE_MISMATCH% = 20 ; Data type mismatch
;Const SQLITE_MISUSE% = 21 ; Library used incorrectly
;Const SQLITE_NOLFS% = 22 ; Uses OS features not supported on host
;Const SQLITE_AUTH% = 23 ; Authorization denied
;Const SQLITE_FORMAT% = 24 ; Auxiliary database format error
;Const SQLITE_RANGE% = 25 ; 2nd parameter to sqlite3_bind out of range
;Const SQLITE_NOTADB% = 26 ; File opened that is not a database file
;Const SQLITE_NOTICE% = 27 ; Notifications from sqlite3_log()
;Const SQLITE_WARNING% = 28 ; Warnings from sqlite3_log()
;Const SQLITE_ROW% = 100 ; sqlite3_step() has another row ready
;Const SQLITE_DONE% = 101 ; sqlite3_step() has finished executing
;;[End Block]
;
;;[Block] SQLite_Open Flags
;; These bit values are intended for use in the
;; 3rd parameter to the [sqlite3_open_v2()] interface.
;Const SQLITE_OPEN_READONLY% = $00000001
;Const SQLITE_OPEN_READWRITE% = $00000002
;Const SQLITE_OPEN_CREATE% = $00000004
;Const SQLITE_OPEN_URI% = $00000040
;Const SQLITE_OPEN_MEMORY% = $00000080
;Const SQLITE_OPEN_NOMUTEX% = $00008000
;Const SQLITE_OPEN_FULLMUTEX% = $00010000
;Const SQLITE_OPEN_SHAREDCACHE% = $00020000
;Const SQLITE_OPEN_PRIVATECACHE% = $00040000
;;[End Block]
;
;;[Block] Column Type
;Const SQLITE_UNKNOWN = 0
;Const SQLITE_INTEGER = 1
;Const SQLITE_REAL = 2
;Const SQLITE_FLOAT = 2
;Const SQLITE_DOUBLE = 2
;Const SQLITE_TEXT = 3
;Const SQLITE_STRING = 3
;Const SQLITE_BLOB = 4
;Const SQLITE_NULL = 5
;;[End Block]
;
;;[Block] Internal Types
;Type SQLite_Container
; Field Pointer%
;End Type
;
;Type SQLite_Int64
; Field Left%, Right%
;End Type
;;[End Block]
;
;Function SQLite_Open%(File$, Flags% = $00000006)
; ; Create a Container to hold the database pointer.
; Local Container.SQLite_Container = New SQLite_Container
; Local ErrCode = SQLite3_Open_V2(File, Container, Flags, 0)
; Local Database = Container\Pointer
; Delete Container
;
; If ErrCode = SQLITE_OK
; Return Database
; Else
; Return False
; EndIf
;End Function
;
;Function SQLite_Execute(Database, SQL$)
; Return SQLite3_Exec(Database, SQL, 0, 0, 0)
;End Function
;
;Function SQLite_Prepare(Database, SQL$)
; Local Container.SQLite_Container = New SQLite_Container
; Local ErrCode = SQLite3_Prepare(Database, SQL$, -1, Container, 0)
; Local Statement = Container\Pointer
; Delete Container
;
; If ErrCode = SQLITE_OK
; Return Statement
; Else
; Return False
; EndIf
;End Function
;
;Global SQLite_Column_Int64_L%, SQLite_Column_Int64_R%
;Function SQLite_Column_Int64(Statement, ColumnIndex%)
; Local Result.SQLite_Int64 = New SQLite_Int64
; SQLite3_Column_Int64(Statement, ColumnIndex, Result)
; SQLite_Column_Int64_L = Result\Left
; SQLite_Column_Int64_R = Result\Right
; Delete Result
;End Function
;
;Function SQLite_Bind_Text(Statement, ColumnIndex%, Value$)
; Return SQLite3_Bind_Text(Statement, ColumnIndex, Value, -1, -1)
;End Function
;
;Function SQLite_Bind_Blob(Statement, ColumnIndex%, Bank)
; If Bank <> 0 Then
; Local Size% = BankSize(Bank)
; Return SQLite3_Bind_Blob(Statement, ColumnIndex, Bank, Size, 0)
; EndIf
;End Function
; Math -------------------------------------------------------------------------
;-- Vector2
;----------------------------------------------------------------
Type Vector2
Field X#, Y#
End Type
@@ -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
BlitzUtility.decls
+147 -208
View File
@@ -15,218 +15,157 @@
; along with this program. If not, see <http:;www.gnu.org/licenses/>.
.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"
BU_Kernel32_FlushFileBuffers%(hFile%) : "FlushFileBuffers"
FlushFile%(hFile%) : "FlushFileBuffers"
BlitzUtility.vcxproj
+18 -10
View File
@@ -127,34 +127,42 @@
</CustomBuildStep>
</ItemDefinitionGroup>
<ItemGroup>
<ClInclude Include="Container\List.h" />
<ClInclude Include="dllmain.h" />
<ClInclude Include="Containers\BlitzList.h" />
<ClInclude Include="Container\TypeList.h" />
<ClInclude Include="Libraries\BlitzPointer.h" />
<ClInclude Include="Utility\MassOp.h" />
<ClInclude Include="Type\Double.h" />
<ClInclude Include="Type\LongLong.h" />
<ClInclude Include="Utility\IndexerV1.h" />
<ClInclude Include="Database\SQLite\SQLite.h" />
<ClInclude Include="Database\SQLite\sqlite3.h" />
<ClInclude Include="Math\Matrix3.h" />
<ClInclude Include="Math\Vector2.h" />
<ClInclude Include="Math\Vector3.h" />
<ClInclude Include="Utility\Display.h" />
<ClInclude Include="Math\FVector2.h" />
<ClInclude Include="Math\BVector3.h" />
<ClInclude Include="Utility\DisplayEnumerator.h" />
<ClInclude Include="Utility\IndexerV2.h" />
<ClInclude Include="Utility\WindowMessageHandler.h" />
</ItemGroup>
<ItemGroup>
<ClCompile Include="Containers\BlitzList.cpp" />
<ClCompile Include="Container\TypeList.cpp" />
<ClCompile Include="Container\List.cpp" />
<ClCompile Include="Database\SQLite\sqlite3.c">
<CallingConvention Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Cdecl</CallingConvention>
<CompileAs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">CompileAsC</CompileAs>
<CallingConvention Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Cdecl</CallingConvention>
<CompileAs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">CompileAsC</CompileAs>
</ClCompile>
<ClCompile Include="Libraries\BlitzPointer.cpp" />
<ClCompile Include="Type\Double.cpp" />
<ClCompile Include="Type\LongLong.cpp" />
<ClCompile Include="Utility\IndexerV1.cpp" />
<ClCompile Include="Database\SQLite\SQLite.cpp" />
<ClCompile Include="Math\Matrix3.cpp" />
<ClCompile Include="Math\Vector3.cpp" />
<ClCompile Include="Math\Vector2.cpp" />
<ClCompile Include="Math\BVector3.cpp" />
<ClCompile Include="Math\FVector2.cpp" />
<ClCompile Include="dllmain.cpp" />
<ClCompile Include="Utility\Display.cpp" />
<ClCompile Include="Utility\DisplayEnumerator.cpp" />
<ClCompile Include="Utility\IndexerV2.cpp" />
<ClCompile Include="Utility\MassOp.cpp" />
<ClCompile Include="Utility\WindowMessageHandler.cpp" />
</ItemGroup>
<ItemGroup>
BlitzUtility.vcxproj.filters
+65 -33
View File
@@ -8,9 +8,6 @@
<Filter Include="Source Files\Utility">
<UniqueIdentifier>{48292af9-63a5-40ae-a447-ad7cecfddd8a}</UniqueIdentifier>
</Filter>
<Filter Include="Source Files\Containers">
<UniqueIdentifier>{ff6bcb4d-9140-40a9-80dd-3698b63bd1c1}</UniqueIdentifier>
</Filter>
<Filter Include="Source Files\Database">
<UniqueIdentifier>{4b84c339-4e83-489c-b421-2cf9fd9e72d1}</UniqueIdentifier>
</Filter>
@@ -23,29 +20,23 @@
<Filter Include="Blitz Files">
<UniqueIdentifier>{e8e48b8c-14c2-40b5-b48d-d9b55fe6852d}</UniqueIdentifier>
</Filter>
<Filter Include="Source Files\Container">
<UniqueIdentifier>{ff6bcb4d-9140-40a9-80dd-3698b63bd1c1}</UniqueIdentifier>
</Filter>
<Filter Include="Source Files\Type">
<UniqueIdentifier>{605f2cca-0949-4af8-ab67-7042309a2abc}</UniqueIdentifier>
</Filter>
<Filter Include="Source Files\Libraries">
<UniqueIdentifier>{2b65f925-151d-4073-a06e-8d7d4603ef16}</UniqueIdentifier>
</Filter>
</ItemGroup>
<ItemGroup>
<ClCompile Include="dllmain.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="Containers\BlitzList.cpp">
<Filter>Source Files\Containers</Filter>
</ClCompile>
<ClCompile Include="Database\SQLite\SQLite.cpp">
<Filter>Source Files\Database\SQLite</Filter>
</ClCompile>
<ClCompile Include="Math\Matrix3.cpp">
<Filter>Source Files\Math</Filter>
</ClCompile>
<ClCompile Include="Math\Vector2.cpp">
<Filter>Source Files\Math</Filter>
</ClCompile>
<ClCompile Include="Math\Vector3.cpp">
<Filter>Source Files\Math</Filter>
</ClCompile>
<ClCompile Include="Utility\Display.cpp">
<Filter>Source Files\Utility</Filter>
</ClCompile>
<ClCompile Include="Utility\WindowMessageHandler.cpp">
<Filter>Source Files\Utility</Filter>
</ClCompile>
@@ -58,32 +49,44 @@
<ClCompile Include="Utility\IndexerV2.cpp">
<Filter>Source Files\Utility</Filter>
</ClCompile>
<ClCompile Include="Type\Double.cpp">
<Filter>Source Files\Type</Filter>
</ClCompile>
<ClCompile Include="Type\LongLong.cpp">
<Filter>Source Files\Type</Filter>
</ClCompile>
<ClCompile Include="Utility\MassOp.cpp">
<Filter>Source Files\Utility</Filter>
</ClCompile>
<ClCompile Include="Container\List.cpp">
<Filter>Source Files\Container</Filter>
</ClCompile>
<ClCompile Include="Container\TypeList.cpp">
<Filter>Source Files\Container</Filter>
</ClCompile>
<ClCompile Include="Utility\DisplayEnumerator.cpp">
<Filter>Source Files\Utility</Filter>
</ClCompile>
<ClCompile Include="Math\BVector3.cpp">
<Filter>Source Files\Math</Filter>
</ClCompile>
<ClCompile Include="Math\FVector2.cpp">
<Filter>Source Files\Math</Filter>
</ClCompile>
<ClCompile Include="Libraries\BlitzPointer.cpp">
<Filter>Source Files\Libraries</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="dllmain.h">
<Filter>Source Files</Filter>
</ClInclude>
<ClInclude Include="Containers\BlitzList.h">
<Filter>Source Files\Containers</Filter>
</ClInclude>
<ClInclude Include="Database\SQLite\SQLite.h">
<Filter>Source Files\Database\SQLite</Filter>
</ClInclude>
<ClInclude Include="Database\SQLite\sqlite3.h">
<Filter>Source Files\Database\SQLite</Filter>
</ClInclude>
<ClInclude Include="Math\Matrix3.h">
<Filter>Source Files\Math</Filter>
</ClInclude>
<ClInclude Include="Math\Vector2.h">
<Filter>Source Files\Math</Filter>
</ClInclude>
<ClInclude Include="Math\Vector3.h">
<Filter>Source Files\Math</Filter>
</ClInclude>
<ClInclude Include="Utility\Display.h">
<Filter>Source Files\Utility</Filter>
</ClInclude>
<ClInclude Include="Utility\WindowMessageHandler.h">
<Filter>Source Files\Utility</Filter>
</ClInclude>
@@ -93,6 +96,33 @@
<ClInclude Include="Utility\IndexerV2.h">
<Filter>Source Files\Utility</Filter>
</ClInclude>
<ClInclude Include="Type\Double.h">
<Filter>Source Files\Type</Filter>
</ClInclude>
<ClInclude Include="Type\LongLong.h">
<Filter>Source Files\Type</Filter>
</ClInclude>
<ClInclude Include="Utility\MassOp.h">
<Filter>Source Files\Utility</Filter>
</ClInclude>
<ClInclude Include="Container\List.h">
<Filter>Source Files\Container</Filter>
</ClInclude>
<ClInclude Include="Container\TypeList.h">
<Filter>Source Files\Container</Filter>
</ClInclude>
<ClInclude Include="Utility\DisplayEnumerator.h">
<Filter>Source Files\Utility</Filter>
</ClInclude>
<ClInclude Include="Math\BVector3.h">
<Filter>Source Files\Math</Filter>
</ClInclude>
<ClInclude Include="Math\FVector2.h">
<Filter>Source Files\Math</Filter>
</ClInclude>
<ClInclude Include="Libraries\BlitzPointer.h">
<Filter>Source Files\Libraries</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<None Include="BlitzUtility.bb">
@@ -101,5 +131,7 @@
<None Include="BlitzUtility.decls">
<Filter>Blitz Files</Filter>
</None>
<None Include="LICENSE" />
<None Include="LICENSE.lesser" />
</ItemGroup>
</Project>
Containers/BlitzList.cpp
-86
View File
@@ -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 <http://www.gnu.org/licenses/>.
#include "BlitzList.h"
std::list<BlitzTypeInfo*>* BlitzUtility_Lists;
void BlitzList_OnProcessAttach() {
BlitzUtility_Lists = new std::list<BlitzTypeInfo*>();
}
void BlitzList_OnProcessDetach() {
BlitzUtility_Lists->clear();
delete BlitzUtility_Lists;
}
DLL_EXPORT void* BlitzList_New(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")
Containers/BlitzList.h
-58
View File
@@ -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 <http://www.gnu.org/licenses/>.
#pragma once
#include "dllmain.h"
#include <memory>
#include <sstream>
#include <iomanip>
#include <list>
// Rev-engineered from https://github.com/blitz-research/blitz3d/blob/master/compiler/declnode.cpp
#define BBVARTYPE_GLOBAL 0
#define BBVARTYPE_INT 1
#define BBVARTYPE_FLOAT 2
#define BBVARTYPE_UNUSED 3
#define BBVARTYPE_STRING 4
#define BBVARTYPE_TYPE 5
#define BBVARTYPE_ARRAY 6
struct BBVar {
unsigned int Type;
};
struct BBVarElement {
int* currentPtr; // Points towards fields.
BBVarElement* nextPtr;
BBVarElement* prevPtr;
void* BBVarTypePtr;
unsigned int refCount; // Fields usually follow here, may be at another location, see currentPtr.
};
struct BBVarType : BBVar {
BBVarElement used, free;
unsigned int fieldCount; // Field Info follows (Exactly <fieldCount> int pointers to variable struct)
//BBVar* fields[];
};
struct BlitzTypeInfo {
BBVarType *type;
BBVarElement *lastNextPtr, *lastPrevPtr;
BBVarElement *ourNextPtr, *ourPrevPtr;
};
void BlitzList_OnProcessAttach();
void BlitzList_OnProcessDetach();
Database/SQLite/SQLite.cpp
+50 -39
View File
@@ -15,64 +15,75 @@
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#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")
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);
}
Database/SQLite/SQLite.h
+60 -18
View File
@@ -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 <http://www.gnu.org/licenses/>.
// BlitzUtility - Expanding the normal Blitz functionality.
// Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#pragma once
#include "dllmain.h"
#include "sqlite3.h"
#include <list>
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
Math/BlitzType.h
-132
View File
@@ -1,132 +0,0 @@
#include "Common.h"
#include <memory>
#include <sstream>
// Rev-engineered from https://github.com/blitz-research/blitz3d/blob/master/compiler/declnode.cpp
#define BBVARTYPE_GLOBAL 0
#define BBVARTYPE_INT 1
#define BBVARTYPE_FLOAT 2
#define BBVARTYPE_UNUSED 3
#define BBVARTYPE_STRING 4
#define BBVARTYPE_TYPE 5
#define BBVARTYPE_ARRAY 6
struct BBVar {
int Type = -1;
};
struct BBVarGlobal {
int GlobalType = -1;
int* Value;
};
struct BBVarInt : BBVar {
int Value;
};
struct BBVarFloat : BBVar {
float Value;
};
struct BBVarUnused : BBVar {
// Not a Dim, as you can see here:
// https://github.com/blitz-research/blitz3d/blob/master/compiler/stmtnode.cpp#L86
};
struct BBVarString : BBVar {
int Length;
char* Value;
};
struct BBVarElement;
struct BBVarType : BBVar {
BBVarElement used, free;
int fieldCount; // Field Info follows (Exactly <fieldCount> int pointers to variable struct)
int* fields[];
};
struct BBVarElement {
int* currentPtr; // Points towards fields.
int* nextPtr, prevPtr;
BBVarType* BBStructPtr;
int refCount; // Fields usually follow here, may be at another location, see currentPtr.
//BBVar* fields[];
};
struct BBVarArray : BBVar {
int Size; //???
BBVar* ArrayType;
};
std::string BBVar_Serialize(void* obj) {
std::stringstream myStream;
BBVar* var = (BBVar*)obj;
switch (var->Type) {
case BBVARTYPE_GLOBAL:
BBVarGlobal* varGlobal = (BBVarGlobal*)obj;
myStream << "[Global] " << BBVar_Serialize(varGlobal->Value) << std::endl;
break;
case BBVARTYPE_INT:
BBVarInt* varInt = (BBVarInt*)obj;
myStream << "Int" << std::endl;
break;
case BBVARTYPE_FLOAT:
BBVarFloat* varFloat = (BBVarFloat*)obj;
myStream << "Float" << std::endl;
break;
case BBVARTYPE_UNUSED:
BBVarUnused* varUnused = (BBVarUnused*)obj;
myStream << "Unused" << std::endl;
break;
case BBVARTYPE_STRING:
BBVarString* varString = (BBVarString*)obj;
myStream << "String" << std::endl;
break;
case BBVARTYPE_TYPE:
BBVarType* varType = (BBVarType*)obj;
myStream << BBVarType_Serialize(varType);
break;
case BBVARTYPE_ARRAY:
BBVarArray* varArray = (BBVarArray*)obj;
myStream << "Array = " << std::endl;
break;
}
return myStream.str();
}
std::string BBVarType_Serialize(BBVarType* obj, unsigned int indent = 0) {
std::stringstream myStream;
std::stringstream myPaddingSS;
for (unsigned int pad = 0; pad < indent; pad++) {
myPaddingSS << " ";
}
std::string myPadding = myPaddingSS.str();
myStream << myPadding << "Type {" << std::endl;
for (unsigned int fld = 0; fld < obj->fieldCount; fld++) {
myStream << myPadding << " (" << fld << ") => " << BBVar_Serialize(obj->fields[fld]) << std::endl;
}
myStream << myPadding << "}" << std::endl;
return myStream.str();
}
DLL_EXPORT(char*) SerializeObject(void* obj) {
return strdup(BBVar_Serialize(obj).c_str());
}
// Laut Mark Sibly:
struct BBType {
int obj_size;
BBObj usedList, freeList;
};
struct BBObj {
BBObj *curr;
BBObj *next, *prev;
int* bbtype;
int ref_cnt;
};
Math/Matrix3.cpp
-62
View File
@@ -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 <http://www.gnu.org/licenses/>.
#include "Matrix3.h"
void Matrix3::set(Matrix3 &M)
{
if (this != &M) {
this->X.set(M.X);
this->Y.set(M.Y);
this->Z.set(M.Z);
}
}
void Matrix3::set(Vector3 &X, Vector3 &Y, Vector3 &Z)
{
this->X.set(X);
this->Y.set(Y);
this->Z.set(Z);
}
void Matrix3::set(float &XX, float &XY, float &XZ, float &YX, float &YY, float &YZ, float &ZX, float &ZY, float &ZZ)
{
this->X.set(XX, XY, XZ);
this->Y.set(YX, YY, YZ);
this->Z.set(ZX, ZY, ZZ);
}
void Matrix3::rotate(float &pitch, float &yaw, float &roll)
{
this->X.mul(cos(yaw) * cos(roll), -sin(roll), sin(yaw));
this->Y.mul(sin(roll), cos(pitch) * cos(roll), -sin(pitch));
this->Z.mul(-sin(yaw), sin(pitch), cos(pitch) * cos(yaw));
}
void Matrix3::angles(float &pitch, float &yaw, float &roll)
{
// ToDo
}
void Matrix3::transpose()
{
Matrix3 temp;
temp.set(*this);
this->X.set(temp.X.X, temp.Y.X, temp.Z.X);
this->Y.set(temp.X.Y, temp.Y.Y, temp.Z.Y);
this->Z.set(temp.X.Z, temp.Y.Z, temp.Z.Z);
}
Math/Matrix3.h
-34
View File
@@ -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 <http://www.gnu.org/licenses/>.
#pragma once
#include <math.h>
#include "dllmain.h"
#include "Vector3.h"
struct Matrix3 {
Vector3 X, Y, Z;
void set(Matrix3 &M);
void set(Vector3 &X, Vector3 &Y, Vector3 &Z);
void set(float &XX, float &XY, float &XZ, float &YX, float &YY, float &YZ, float &ZX, float &ZY, float &ZZ);
void rotate(float &pitch, float &yaw, float &roll);
void angles(float &pitch, float &yaw, float &roll);
void transpose();
};
Math/Vector2.cpp
-305
View File
@@ -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 <http://www.gnu.org/licenses/>.
#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")
Math/Vector2.h
-73
View File
@@ -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 <http://www.gnu.org/licenses/>.
#pragma once
#include "dllmain.h"
#ifndef _USE_MATH_DEFINES
#define _USE_MATH_DEFINES
#include <math.h>
#undef _USE_MATH_DEFINES
#endif
struct 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);
};
Math/Vector3.cpp
-373
View File
@@ -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 <http://www.gnu.org/licenses/>.
#include "Vector3.h"
void Vector3::set(const float &o)
{
this->X = o;
this->Y = o;
this->Z = o;
}
void Vector3::set(const float &x, const float &y, const float &z)
{
this->X = x;
this->Y = y;
this->Z = z;
}
void Vector3::set(const Vector3 &o)
{
if (this != &o) {
this->X = o.X;
this->Y = o.Y;
this->Z = o.Z;
}
}
void Vector3::add(const float &o)
{
this->X += o;
this->Y += o;
this->Z += o;
}
void Vector3::add(const float &x, const float &y, const float &z)
{
this->X += x;
this->Y += y;
this->Z += z;
}
void Vector3::add(const Vector3 &o)
{
this->X += o.X;
this->Y += o.Y;
this->Z += o.Z;
}
void Vector3::sub(const float &o)
{
this->X -= o;
this->Y -= o;
this->Z -= o;
}
void Vector3::sub(const float &x, const float &y, const float &z)
{
this->X -= x;
this->Y -= y;
this->Z -= z;
}
void Vector3::sub(const Vector3 &o)
{
this->X -= o.X;
this->Y -= o.Y;
this->Z -= o.Z;
}
void Vector3::mul(const float &o)
{
this->X *= o;
this->Y *= o;
this->Z *= o;
}
void Vector3::mul(const float &x, const float &y, const float &z)
{
this->X *= x;
this->Y *= y;
this->Z *= z;
}
void Vector3::mul(const Vector3 &o)
{
this->X *= o.X;
this->Y *= o.Y;
this->Z *= o.Z;
}
void Vector3::div(const float &o)
{
this->X /= o;
this->Y /= o;
this->Z /= o;
}
void Vector3::div(const float &x, const float &y, const float &z)
{
this->X /= x;
this->Y /= y;
this->Z /= z;
}
void Vector3::div(const Vector3 &o)
{
this->X /= o.X;
this->Y /= o.Y;
this->Z /= o.Z;
}
float Vector3::length()
{
return sqrt(this->X * this->X + this->Y * this->Y + this->Z * this->Z);
}
float Vector3::distance(const float &x, const float &y, const float &z)
{
float X = (this->X - x);
float Y = (this->Y - y);
float Z = (this->Z - z);
return sqrt(X * X + Y * Y + Z * Z);
}
float Vector3::distance(const Vector3 &o)
{
float X = (this->X - o.X);
float Y = (this->Y - o.Y);
float Z = (this->Z - o.Z);
return sqrt(X * X + Y * Y + Z * Z);
}
float Vector3::dot(const float &x, const float &y, const float &z)
{
return (this->X * x) + (this->Y * y) + (this->Z * z);
}
float Vector3::dot(const Vector3 &o)
{
return (this->X * o.X) + (this->Y * o.Y) + (this->Z * o.Z);
}
Vector3 Vector3::cross(const float &x, const float &y, const float &z)
{
Vector3* data = new Vector3();
data->X = (this->Y * z) - (this->Z * y);
data->Y = (this->Z * x) - (this->X * z);
data->Z = (this->X * y) - (this->Y * x);
return *data;
}
Vector3 Vector3::cross(const Vector3 &o)
{
Vector3* data = new Vector3();
data->X = (this->Y * o.Z) - (this->Z * o.Y);
data->Y = (this->Z * o.X) - (this->X * o.Z);
data->Z = (this->X * o.Y) - (this->Y * o.X);
return *data;
}
void Vector3::normalize()
{
this->div(this->length());
}
void Vector3::rotate(float &pitch, float &yaw, float &roll)
{
float** matrix = new float*[3];
matrix[0] = new float[3]; matrix[1] = new float[3]; matrix[2] = new float[3];
matrix[0][0] = cos(yaw) * cos(roll); matrix[0][1] = -sin(roll); matrix[0][2] = sin(yaw);
matrix[1][0] = sin(roll); matrix[1][1] = cos(pitch) * cos(roll); matrix[1][2] = -sin(pitch);
matrix[2][0] = -sin(yaw); matrix[2][1] = sin(pitch); matrix[2][2] = cos(pitch) * cos(yaw);
float X = (this->X * matrix[0][0]) + (this->Y * matrix[0][1]) + (this->Z * matrix[0][2]);
float Y = (this->X * matrix[1][0]) + (this->Y * matrix[1][1]) + (this->Z * matrix[1][2]);
float Z = (this->X * matrix[2][0]) + (this->Y * matrix[2][1]) + (this->Z * matrix[2][2]);
this->X = X; this->Y = Y; this->Z = Z;
}
void Vector3::rotateAround(const float &x, const float &y, const float &z, float &pitch, float &yaw, float &roll)
{
this->sub(x, y, z);
this->rotate(pitch, yaw, roll);
this->add(x, y, z);
}
void Vector3::rotateAround(Vector3 &o, float &pitch, float &yaw, float &roll)
{
this->sub(o);
this->rotate(pitch, yaw, roll);
this->add(o);
}
float Vector3::deltaPitch() {
return (float)(atan(this->X / -this->Y) * (180.0 / M_PI));
}
float Vector3::deltaPitch(const float &x, const float &y, const float &z)
{
return (float)(atan((this->X - x) / (-(this->Y - y))) * (180.0 / M_PI));
}
float Vector3::deltaPitch(Vector3 &o)
{
return (float)(atan((this->X - o.X) / (-(this->Y - o.Y))) * (180.0 / M_PI));
}
float Vector3::deltaYaw() {
return (float)(atan(sqrt((this->X * this->X) + (this->Y * this->Y)) / this->Z) * (180.0 / M_PI));
}
float Vector3::deltaYaw(const float &x, const float &y, const float &z)
{
float X = (this->X - x);
float Y = (this->Y - y);
return (float)(atan(sqrt((X * X) + (Y * Y)) / (this->Z - z)) * (180.0 / M_PI));
}
float Vector3::deltaYaw(Vector3 &o)
{
float X = (this->X - o.X);
float Y = (this->Y - o.Y);
return (float)(atan(sqrt((X * X) + (Y * Y)) / (this->Z - o.Z)) * (180.0 / M_PI));
}
char* Vector3::serialize()
{
char* data = new char[13];
memcpy(data, this->Xc, 4);
memcpy(data + 4, this->Yc, 4);
memcpy(data + 8, this->Zc, 4);
data[12] = 0;
return data;
}
void Vector3::deserialize(char* o)
{
memcpy(o, this->Xc, 4);
memcpy(o + 4, this->Yc, 4);
memcpy(o + 8, this->Zc, 4);
}
/* ------------------------- 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")
Math/Vector3.h
-81
View File
@@ -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 <http://www.gnu.org/licenses/>.
#pragma once
#include "dllmain.h"
#ifndef _USE_MATH_DEFINES
#define _USE_MATH_DEFINES
#include <math.h>
#undef _USE_MATH_DEFINES
#endif
struct Vector3 {
union {
float X;
char Xc[4];
};
union {
float Y;
char Yc[4];
};
union {
float Z;
char Zc[4];
};
void set(const float &o);
void set(const float &x, const float &y, const float &z);
void set(const Vector3 &o);
void add(const float &o);
void add(const float &x, const float &y, const float &z);
void add(const Vector3 &o);
void sub(const float &o);
void sub(const float &x, const float &y, const float &z);
void sub(const Vector3 &o);
void mul(const float &o);
void mul(const float &x, const float &y, const float &z);
void mul(const Vector3 &o);
void div(const float &o);
void div(const float &x, const float &y, const float &z);
void div(const Vector3 &o);
float length();
float distance(const float &x, const float &y, const float &z);
float distance(const Vector3 &o);
float dot(const float &x, const float &y, const float &z);
float dot(const Vector3 &o);
Vector3 cross(const float &x, const float &y, const float &z);
Vector3 cross(const Vector3 &o);
void normalize();
void rotate(float &pitch, float &yaw, float &roll);
void rotateAround(const float &x, const float &y, const float &z, float &pitch, float &yaw, float &roll);
void rotateAround(Vector3 &o, float &pitch, float &yaw, float &roll);
float deltaPitch();
float deltaPitch(const float &x, const float &y, const float &z);
float deltaPitch(Vector3 &o);
float deltaYaw();
float deltaYaw(const float &x, const float &y, const float &z);
float deltaYaw(Vector3 &o);
char* serialize();
void deserialize(char* o);
};
Utility/Display.cpp
-73
View File
@@ -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 <http://www.gnu.org/licenses/>.
#include "Display.h"
std::list<Display>* Display_List = NULL;
void Display_OnProcessAttach() {
Display_List = new std::list<Display>();
}
void Display_OnProcessDetach() {
Display_List->clear();
delete Display_List;
}
DLL_EXPORT void Display_Enumerate() {
if (Display_List == NULL)
return;
Display_List->clear();
EnumDisplayMonitors(NULL, NULL, Display_EnumerateProcedure, 0);
}
#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")
Utility/Display.h
-31
View File
@@ -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 <http://www.gnu.org/licenses/>.
#pragma once
#include "dllmain.h"
#include <list>
struct Display {
int left;
int top;
int right;
int bottom;
};
void Display_OnProcessAttach();
void Display_OnProcessDetach();
BOOL CALLBACK Display_EnumerateProcedure(HMONITOR hMonitor, HDC hdcMonitor, LPRECT lprcMonitor, LPARAM dwData);
Utility/IndexerV1.cpp
+89 -58
View File
@@ -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);
}
Utility/IndexerV1.h
+31 -4
View File
@@ -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")
Utility/IndexerV2.cpp
+131 -94
View File
@@ -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 <http://www.gnu.org/licenses/>.
// BlitzUtility - Expanding the normal Blitz functionality.
// Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "IndexerV2.h"
IndexerV2::IndexerV2() {
this->range.reserve(32);
}
IndexerV2::~IndexerV2() {
this->range.clear();
}
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 = &range;
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<IndexerV2Range>::iterator iter = this->range.begin();
if (iter->min > 0) {
return --iter->min;
} else {
if (iter->max == UINT32_MAX)
return UINT32_MAX;
uint32_t index = ++iter->max;
// Check if we can combine this element with the next one.
std::vector<IndexerV2Range>::iterator iterN = this->range.begin() + 1;
if ((iterN != this->range.end()) && iterN->min == iter->max) {
iter->max = iterN->max;
this->range.erase(iterN);
}
return index;
}
return UINT32_MAX;
}
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")
Utility/IndexerV2.h
+45 -20
View File
@@ -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 <http://www.gnu.org/licenses/>.
// BlitzUtility - Expanding the normal Blitz functionality.
// Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#pragma once
#include "dllmain.h"
#include <vector>
@@ -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<IndexerV2Range> range;
};
DLL_METHOD IndexerV2* DLL_CALL BU_IndexerV2_Create();
#pragma comment(linker, "/EXPORT:BU_IndexerV2_Create=_BU_IndexerV2_Create@0")
DLL_METHOD void DLL_CALL BU_IndexerV2_Destroy(IndexerV2* indexer);
#pragma comment(linker, "/EXPORT:BU_IndexerV2_Destroy=_BU_IndexerV2_Destroy@4")
DLL_METHOD void DLL_CALL BU_IndexerV2_Mark(IndexerV2* indexer, uint32_t used, uint32_t index);
#pragma comment(linker, "/EXPORT:BU_IndexerV2_Mark=_BU_IndexerV2_Mark@12")
DLL_METHOD void DLL_CALL BU_IndexerV2_MarkFree(IndexerV2* indexer, uint32_t index);
#pragma comment(linker, "/EXPORT:BU_IndexerV2_MarkFree=_BU_IndexerV2_MarkFree@8")
DLL_METHOD void DLL_CALL BU_IndexerV2_MarkUsed(IndexerV2* indexer, uint32_t index);
#pragma comment(linker, "/EXPORT:BU_IndexerV2_MarkUsed=_BU_IndexerV2_MarkUsed@8")
DLL_METHOD uint32_t DLL_CALL BU_IndexerV2_Is(IndexerV2* indexer, uint32_t index, uint32_t used);
#pragma comment(linker, "/EXPORT:BU_IndexerV2_Is=_BU_IndexerV2_Is@12")
DLL_METHOD uint32_t DLL_CALL BU_IndexerV2_IsFree(IndexerV2* indexer, uint32_t index);
#pragma comment(linker, "/EXPORT:BU_IndexerV2_IsFree=_BU_IndexerV2_IsFree@8")
DLL_METHOD uint32_t DLL_CALL BU_IndexerV2_IsUsed(IndexerV2* indexer, uint32_t index);
#pragma comment(linker, "/EXPORT:BU_IndexerV2_IsUsed=_BU_IndexerV2_IsUsed@8")
DLL_METHOD uint32_t DLL_CALL BU_IndexerV2_Get(IndexerV2* indexer);
#pragma comment(linker, "/EXPORT:BU_IndexerV2_Get=_BU_IndexerV2_Get@4")
DLL_METHOD uint32_t DLL_CALL BU_IndexerV2_Count(IndexerV2* indexer, uint32_t used);
#pragma comment(linker, "/EXPORT:BU_IndexerV2_Count=_BU_IndexerV2_Count@8")
DLL_METHOD uint32_t DLL_CALL BU_IndexerV2_CountFree(IndexerV2* indexer);
#pragma comment(linker, "/EXPORT:BU_IndexerV2_CountFree=_BU_IndexerV2_CountFree@4")
DLL_METHOD uint32_t DLL_CALL BU_IndexerV2_CountUsed(IndexerV2* indexer);
#pragma comment(linker, "/EXPORT:BU_IndexerV2_CountUsed=_BU_IndexerV2_CountUsed@4")
Utility/WindowMessageHandler.cpp
+39 -46
View File
@@ -19,20 +19,20 @@
std::list<WindowUserData>* WindowMessageHandler_List;
void WindowMessageHandler_OnProcessAttach() {
void BU_WindowMessageHandler_OnProcessAttach() {
WindowMessageHandler_List = new std::list<WindowUserData>();
}
void WindowMessageHandler_OnProcessDetach() {
void BU_WindowMessageHandler_OnProcessDetach() {
for (auto iterator = WindowMessageHandler_List->begin(), end = WindowMessageHandler_List->end(); iterator != end; iterator++) {
WindowMessageHandler_Uninstall(iterator->hwnd);
BU_WindowMessageHandler_Uninstall(iterator->hwnd);
}
WindowMessageHandler_List->clear();
delete WindowMessageHandler_List;
}
LRESULT CALLBACK WindowMessageHandler_Procedure(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
LRESULT CALLBACK BU_WindowMessageHandler_Procedure(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
WindowUserData* UserData = (WindowUserData*)GetWindowLong(hwnd, GWL_USERDATA);
if (UserData) {
switch (uMsg) {
@@ -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")
Utility/WindowMessageHandler.h
+13 -5
View File
@@ -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);
DLL_METHOD void DLL_CALL BU_WindowMessageHandler_Install(HWND hwnd);
#pragma comment(linker, "/EXPORT:BU_WindowMessageHandler_Install=_BU_WindowMessageHandler_Install@4")
DLL_METHOD void DLL_CALL BU_WindowMessageHandler_Uninstall(HWND hwnd);
#pragma comment(linker, "/EXPORT:BU_WindowMessageHandler_Uninstall=_BU_WindowMessageHandler_Uninstall@4")
DLL_METHOD uint32_t DLL_CALL BU_WindowMessageHandler_Message_Resize(HWND hwnd, LPPOINT point);
#pragma comment(linker, "/EXPORT:BU_WindowMessageHandler_Message_Resize=_BU_WindowMessageHandler_Message_Resize@8")
DLL_METHOD uint32_t DLL_CALL BU_WindowMessageHandler_Message_Destroy(HWND hwnd);
#pragma comment(linker, "/EXPORT:BU_WindowMessageHandler_Message_Destroy=_BU_WindowMessageHandler_Message_Destroy@4")
DLL_METHOD uint32_t DLL_CALL BU_WindowMessageHandler_Message_Close(HWND hwnd);
#pragma comment(linker, "/EXPORT:BU_WindowMessageHandler_Message_Close=_BU_WindowMessageHandler_Message_Close@4")
dllmain.cpp
+4 -32
View File
@@ -14,47 +14,19 @@
// You should have received a copy of the GNU Lesser General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "dllmain.h"
#pragma once
#include <list>
#include "Containers\BlitzList.h"
#include "dllmain.h"
#include "Database\SQLite\SQLite.h"
#include "Math\Vector2.h"
#include "Math\Vector3.h"
#include "Math\Matrix3.h"
#include "Utility\Display.h"
#include "Utility\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;
dllmain.h
+35 -1
View File
@@ -23,8 +23,42 @@
// Memory Management
#include <memory>
// Strings
#include <string>
#include <sstream>
#include <iomanip>
// Platform specific: Windows
#include <windows.h>
// Macros
#define DLL_EXPORT extern "C" //__declspec(dllexport)
#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;
}