diff --git a/Container/List.cpp b/Container/List.cpp new file mode 100644 index 0000000..277b82a --- /dev/null +++ b/Container/List.cpp @@ -0,0 +1,273 @@ +// BlitzUtility - Expanding the normal Blitz functionality. +// Copyright (C) 2015 Project Kube (Michael Fabian Dirks) +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program. If not, see . + +#pragma once +#include "List.h" + + +DLL_METHOD List* DLL_CALL BU_List_Create(BBTypeElement* element) { + // Make sure the given element is valid. + if (element == NULL) + return NULL; + element = (BBTypeElement*)((uint32_t*)element - 5); + + // Create our List. + List* myList = new List; + myList->originalType = element->type; + + // Create a fake base Type by copying data. + myList->fakeType = new BBType; + myList->fakeType->fieldCount = myList->originalType->fieldCount; + myList->fakeType->free.type = myList->originalType->free.type; + myList->fakeType->free.refCount = myList->originalType->free.refCount; + myList->fakeType->free.fields = myList->originalType->free.fields; + myList->fakeType->free.next = (BBTypeElement*)&myList->fakeType->free; + myList->fakeType->free.prev = (BBTypeElement*)&myList->fakeType->free; + myList->fakeType->used.type = myList->originalType->used.type; + myList->fakeType->used.refCount = myList->originalType->used.refCount; + myList->fakeType->used.fields = myList->originalType->used.fields; + myList->fakeType->used.prev = (BBTypeElement*)&myList->fakeType->used; + myList->fakeType->used.next = (BBTypeElement*)&myList->fakeType->used; + + // Remove element from original flow. + element->prev->next = element->next; + element->next->prev = element->prev; + element->prev = NULL; + element->next = NULL; + element->type = myList->fakeType; + + // Store the element for later use; + myList->storageElement = element; + myList->storageElementFields = element->fields; + + return myList; +} + +DLL_METHOD void DLL_CALL BU_List_Destroy(List* list) { + if (list == NULL) + return; + + // Append remaining elements to original type. + BBTypeElement *thisEl = NULL; + for (thisEl = list->fakeType->used.next; thisEl != (BBTypeElement*)&list->fakeType->used; thisEl = list->fakeType->used.next) { + // Remove from fakeType's flow. + thisEl->prev->next = thisEl->next; + thisEl->next->prev = thisEl->prev; + + // Append to originalType's flow. + thisEl->prev = list->originalType->used.prev; + thisEl->prev->next = thisEl; + thisEl->next = (BBTypeElement*)&list->originalType->used; + thisEl->next->prev = thisEl; + } + for (thisEl = list->fakeType->free.next; thisEl != (BBTypeElement*)&list->fakeType->free; thisEl = list->fakeType->free.next) { + // Remove from fakeType's flow. + thisEl->prev->next = thisEl->next; + thisEl->next->prev = thisEl->prev; + + // Append to originalType's flow. + thisEl->prev = list->originalType->free.prev; + thisEl->prev->next = thisEl; + thisEl->next = (BBTypeElement*)&list->originalType->free; + thisEl->next->prev = thisEl; + } + + // Append storageElement to original type. + thisEl = list->storageElement; + thisEl->prev = list->originalType->used.prev; + thisEl->prev->next = thisEl; + thisEl->next = (BBTypeElement*)&list->originalType->used; + thisEl->next->prev = thisEl; + thisEl->type = list->originalType; + thisEl->fields = list->storageElementFields; + + // Delete custom objects. + delete list->fakeType; + delete list; +} + +DLL_METHOD uint32_t DLL_CALL BU_List_First(List* list) { + if (list == NULL) + return FALSE; + + BBTypeElement* element = list->fakeType->used.next; + if (element == (BBTypeElement*)&list->fakeType->used) + return FALSE; // End of List. + + // Copy data from selected element. + list->storageElement->fields = element->fields; + + // Make deletion easier + list->storageElement->next = element; + list->storageElement->prev = element; + + return TRUE; +} + +DLL_METHOD uint32_t DLL_CALL BU_List_Last(List* list) { + if (list == NULL) + return FALSE; + + BBTypeElement* element = list->fakeType->used.prev; + if (element == (BBTypeElement*)&list->fakeType->used) + return FALSE; // End of List. + + // Copy data from selected element. + list->storageElement->fields = element->fields; + + // Make deletion easier + list->storageElement->next = element; + list->storageElement->prev = element; + + return TRUE; +} + +DLL_METHOD uint32_t DLL_CALL BU_List_Previous(List* list) { + if (list == NULL) + return FALSE; + + BBTypeElement* element = list->storageElement->prev->prev; + if (element == (BBTypeElement*)&list->fakeType->used) + return FALSE; // End of List. + + // Copy data from selected element. + list->storageElement->fields = element->fields; + + // Make deletion easier + list->storageElement->next = element; + list->storageElement->prev = element; + + return TRUE; +} + +DLL_METHOD uint32_t DLL_CALL BU_List_Next(List* list) { + if (list == NULL) + return FALSE; + + BBTypeElement* element = list->storageElement->next->next; + if (element == (BBTypeElement*)&list->fakeType->used) + return FALSE; // End of List. + + // Copy data from selected element. + list->storageElement->fields = element->fields; + + // Make deletion easier + list->storageElement->next = element; + list->storageElement->prev = element; + + return TRUE; +} + +DLL_METHOD uint32_t DLL_CALL BU_List_Before(List* list, BBTypeElement* other) { + if (list == NULL) + return FALSE; + if (other == NULL) + return FALSE; + + other = (BBTypeElement*)((uint32_t*)other - 5); + if (other->type != list->fakeType) + return FALSE; + + BBTypeElement* element = other->prev; + if (element == (BBTypeElement*)&list->fakeType->used) + return FALSE; // End of List. + + // Copy data from selected element. + list->storageElement->fields = element->fields; + + // Make deletion easier + list->storageElement->next = element; + list->storageElement->prev = element; + + return TRUE; +} + +DLL_METHOD uint32_t DLL_CALL BU_List_After(List* list, BBTypeElement* other) { + if (list == NULL) + return FALSE; + if (other == NULL) + return FALSE; + + other = (BBTypeElement*)((uint32_t*)other - 5); + if (other->type != list->fakeType) + return FALSE; + + BBTypeElement* element = other->next; + if (element == (BBTypeElement*)&list->fakeType->used) + return FALSE; // End of List. + + // Copy data from selected element. + list->storageElement->fields = element->fields; + + // Make deletion easier + list->storageElement->next = element; + list->storageElement->prev = element; + + return TRUE; +} + +DLL_METHOD void DLL_CALL BU_List_Insert(List* list, BBTypeElement* element) { + BU_List_InsertEx(list, element, NULL); +} + +DLL_METHOD void DLL_CALL BU_List_InsertEx(List* list, BBTypeElement* element, BBTypeElement* other) { + if (list == NULL) + return; + + // Make sure element is a valid pointer. + if (element == NULL) + return; + element = (BBTypeElement*)((uint32_t*)element - 5); + if (element->type != list->originalType) + return; // Can't add elements from other types, could cause serious issues. + + // Make sure other is a valid pointer. + if (other == NULL) { + other = (BBTypeElement*)&list->fakeType->used; + } else { + other = (BBTypeElement*)((uint32_t*)other - 5); + + // Other element must be of the same fakeType. + if (other->type != list->fakeType) + return; + } + + // Insert the element after(!) the other element. + element->prev = other->prev; + element->next = other; + element->prev->next = element; + element->next->prev = element; + element->type = list->fakeType; +} + +DLL_METHOD void DLL_CALL BU_List_Remove(List* list, BBTypeElement* element) { + if (list == NULL) + return; + if (element == NULL) + return; + + element = (BBTypeElement*)((uint32_t*)element - 5); + if (element->type != list->fakeType) + return; // Can't remove elements from another type. + + element->type = list->originalType; + element->prev = list->originalType->used.prev; + element->next = (BBTypeElement*)&list->originalType->used; + list->originalType->used.prev->next = element; + list->originalType->used.prev = element; +} + + diff --git a/Container/List.h b/Container/List.h new file mode 100644 index 0000000..15ca66a --- /dev/null +++ b/Container/List.h @@ -0,0 +1,85 @@ +// BlitzUtility - Expanding the normal Blitz functionality. +// Copyright (C) 2015 Project Kube (Michael Fabian Dirks) +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program. If not, see . + +#pragma once +#include "dllmain.h" + +// Reverse engineered from https://github.com/blitz-research/blitz3d/blob/master/compiler/declnode.cpp +enum BBVarType { + Global = 0, + Int = 1, + Float = 2, + String = 4, + Type = 5, + Array = 6 +}; + +// Basic Blitz Variable +struct BBVar { + uint32_t type; + uint32_t value; +}; + +// Basic Type predefinition. +struct BBType; + +// Basic Type Element +struct BBTypeElement { + uint32_t* fields; + BBTypeElement* next; + BBTypeElement* prev; + BBType* type; + unsigned int refCount; +}; + +// Basic Type +struct BBType { + uint32_t type; + BBTypeElement used, free; + uint32_t fieldCount; +}; + +// List struct. +struct List { + BBType* originalType; + BBType* fakeType; + + BBTypeElement* storageElement; + uint32_t* storageElementFields; +}; + +DLL_METHOD List* DLL_CALL BU_List_Create(BBTypeElement* element); +#pragma comment(linker, "/EXPORT:BU_List_Create=_BU_List_Create@4") +DLL_METHOD void DLL_CALL BU_List_Destroy(List* list); +#pragma comment(linker, "/EXPORT:BU_List_Destroy=_BU_List_Destroy@4") +DLL_METHOD uint32_t DLL_CALL BU_List_First(List* list); +#pragma comment(linker, "/EXPORT:BU_List_First=_BU_List_First@4") +DLL_METHOD uint32_t DLL_CALL BU_List_Last(List* list); +#pragma comment(linker, "/EXPORT:BU_List_Last=_BU_List_Last@4") +DLL_METHOD uint32_t DLL_CALL BU_List_Previous(List* list); +#pragma comment(linker, "/EXPORT:BU_List_Previous=_BU_List_Previous@4") +DLL_METHOD uint32_t DLL_CALL BU_List_Next(List* list); +#pragma comment(linker, "/EXPORT:BU_List_Next=_BU_List_Next@4") +DLL_METHOD uint32_t DLL_CALL BU_List_Before(List* list, BBTypeElement* other); +#pragma comment(linker, "/EXPORT:BU_List_Before=_BU_List_Before@8") +DLL_METHOD uint32_t DLL_CALL BU_List_After(List* list, BBTypeElement* other); +#pragma comment(linker, "/EXPORT:BU_List_After=_BU_List_After@8") +DLL_METHOD void DLL_CALL BU_List_Insert(List* list, BBTypeElement* element); +#pragma comment(linker, "/EXPORT:BU_List_Insert=_BU_List_Insert@8") +DLL_METHOD void DLL_CALL BU_List_InsertEx(List* list, BBTypeElement* element, BBTypeElement* other); +#pragma comment(linker, "/EXPORT:BU_List_InsertEx=_BU_List_InsertEx@12") +DLL_METHOD void DLL_CALL BU_List_Remove(List* list, BBTypeElement* element); +#pragma comment(linker, "/EXPORT:BU_List_Remove=_BU_List_Remove@8") diff --git a/Container/TypeList.cpp b/Container/TypeList.cpp new file mode 100644 index 0000000..ef195f9 --- /dev/null +++ b/Container/TypeList.cpp @@ -0,0 +1,76 @@ +// BlitzUtility - Expanding the normal Blitz functionality. +// Copyright (C) 2015 Project Kube (Michael Fabian Dirks) +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program. If not, see . + +#pragma once; +#include "TypeList.h" + +DLL_METHOD TypeList* DLL_CALL BU_TypeList_Create(BBTypeElement* element) { + // Make sure the given element is valid. + if (element == NULL) + return NULL; + element = (BBTypeElement*)(((uint32_t*)element) - 5); + + // Create our TypeList. + TypeList* list = new TypeList(); + list->type = element->type; + list->firstElement = element; + list->lastElement = element; + + // Remove the given element from the flow of the type. + element->prev->next = element->next; + element->next->prev = element->prev; + element->prev = (BBTypeElement*)&list->type->used; + element->next = (BBTypeElement*)&list->type->used; + + // Return the list. + return list; +} + +DLL_METHOD void DLL_CALL BU_TypeList_Destroy(TypeList* list) { + // Make sure we have a valid list. + if (list == NULL) + return; + + // Append elements to the original type. + list->firstElement->prev = list->type->used.prev; + list->firstElement->prev->next = list->firstElement; + list->lastElement->next = (BBTypeElement*)&list->type->used; + list->lastElement->next->prev = list->lastElement; + + // Free our TypeList. + delete list; +} + +DLL_METHOD void DLL_CALL BU_TypeList_Activate(TypeList* list) { + // Store current pointers + list->storedFirstElement = list->type->used.next; + list->storedLastElement = list->type->used.prev; + + // ... and replace them. + list->type->used.next = list->firstElement; + list->type->used.prev = list->lastElement; +} + +DLL_METHOD void DLL_CALL BU_TypeList_Deactivate(TypeList* list) { + // Store current pointers + list->firstElement = list->type->used.next; + list->lastElement = list->type->used.prev; + + // ... and replace them. + list->type->used.next = list->storedFirstElement; + list->type->used.prev = list->storedLastElement; +} + diff --git a/Container/TypeList.h b/Container/TypeList.h new file mode 100644 index 0000000..da22d2c --- /dev/null +++ b/Container/TypeList.h @@ -0,0 +1,36 @@ +// BlitzUtility - Expanding the normal Blitz functionality. +// Copyright (C) 2015 Project Kube (Michael Fabian Dirks) +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program. If not, see . + +#pragma once +#include "dllmain.h" +#include "List.h" +#include + +struct TypeList { + BBType *type; + + BBTypeElement *storedFirstElement, *storedLastElement; + BBTypeElement *firstElement, *lastElement; +}; + +DLL_METHOD TypeList* DLL_CALL BU_TypeList_Create(BBTypeElement* element); +#pragma comment(linker, "/EXPORT:BU_TypeList_Create=_BU_TypeList_Create@4") +DLL_METHOD void DLL_CALL BU_TypeList_Destroy(TypeList* list); +#pragma comment(linker, "/EXPORT:BU_TypeList_Destroy=_BU_TypeList_Destroy@4") +DLL_METHOD void DLL_CALL BU_TypeList_Activate(TypeList* list); +#pragma comment(linker, "/EXPORT:BU_TypeList_Activate=_BU_TypeList_Activate@4") +DLL_METHOD void DLL_CALL BU_TypeList_Deactivate(TypeList* list); +#pragma comment(linker, "/EXPORT:BU_TypeList_Deactivate=_BU_TypeList_Deactivate@4") diff --git a/README.md b/README.md new file mode 100644 index 0000000..5add218 --- /dev/null +++ b/README.md @@ -0,0 +1,173 @@ +# BlitzUtility +BlitzUtility is aimed at extending Blitz beyond it's initial capabilities and is a sub-project of BlitzExtensions. +All functions assume that you are passing valid parameters and do no extra checking to reduce performance impact. + +# Functionality +## Containers +### List +An element-based method of creating a List in Blitz, works by creating a clone of the original Type and inserting the elements into the new flow. + +* List% = BU_List_Create(TypeObject*) +Creates a new list from an existing object, using it as a way of accessing the currently selected List entry. +* BU_List_Destroy(List%) +Destroys an existing List, returning it's objects into the original type. +* Sucess% = BU_List_First(List%) +Tries to selects the first object in a List, returning false if it failed. +* Sucess% = BU_List_Last(List%) +Tries to selects the last object in a List, returning false if it failed. +* Sucess% = BU_List_Previous(List%) +Tries to selects the previous object from the currently selected one, returning false if it failed. +* Sucess% = BU_List_Next(List%) +Tries to selects the next object from the currently selected one, returning false if it failed. +* Success% = BU_List_Before(List%, TypeObject*) +Tries to select the element before the given object, returning false if it failed. +* Success% = BU_List_After(List%, TypeObject*) +Tries to select the element After the given object, returning false if it failed. +* BU_List_Insert(List%, TypeObject*) +Inserts an object at the end of the given list. +* BU_List_InsertEx(List%, TypeObject*, OtherObject*) +Inserts an object after the given other object. +* BU_List_Remove(List%, TypeObject*) +Removes an object from a list, returning it to the original type. + +### Type List +A type-based method of creating Lists in Blitz, works by modifying the base Type. + +* List% = BU_TypeList_Create(TypeObject*) +Creates a new list from an existing object, immediately removing it from the original type and inserting it into it's own list. +* BU_TypeList_Destroy(List%) +Destroy an existing list, returning the objects into the flow of the base type. +* BU_TypeList_Activate(List%) +Activates the list, making elements inside it available for use. +* BU_TypeList_Deactivate(List%) +Deactivates the list, restoring the flow of elements to before activation. + +## Types +### Long Long +64-bit integers for Blitz. + +* LongLong% = BU_LongLong_Create%() +* BU_LongLong_Destroy(LongLong%) +* LongLong% = BU_LongLong_Copy%(LongLong%) +* LongLong% = BU_LongLong_TempCreate%() +* LongLong% = BU_LongLong_TempCopy%(LongLong%) +* BU_LongLong_SetTemp(LongLong%) +* BU_LongLong_UnsetTemp(LongLong%) +* BU_LongLong_TempCleanup() +* BU_LongLong_Set(LongLong%, LongLong%) +* BU_LongLong_SetV(LongLong%, LongHigh%, LongLow%) +* BU_LongLong_Add(LongLong%, LongLong%) +* BU_LongLong_AddV(LongLong%, LongHigh%, LongLow%) +* BU_LongLong_Sub(LongLong%, LongLong%) +* BU_LongLong_SubV(LongLong%, LongHigh%, LongLow%) +* BU_LongLong_Mul(LongLong%, LongLong%) +* BU_LongLong_MulV(LongLong%, LongHigh%, LongLow%) +* BU_LongLong_Div(LongLong%, LongLong%) +* BU_LongLong_DivV(LongLong%, LongHigh%, LongLow%) +* Result% = BU_LongLong_Compare%(LongLong%, LongLong%) +* Result% = BU_LongLong_CompareV%(LongLong%, LongHigh%, LongLow%) +* String$ = BU_LongLong_ToString$(LongLong%) +* LongLong% = BU_LongLong_FromString%(String$) +* Long% = BU_LongLong_ToLong%(LongLong%, Modulus%) +* LongLong% = BU_LongLong_FromLong%(LongHigh%, LongLow%) +* Long% = BU_LongLong_ToLongHigh%(LongLong%) +* Long% = BU_LongLong_ToLongLow%(LongLong%) +* Float# = BU_LongLong_ToFloat#(LongLong%) +* LongLong% = BU_LongLong_FromFloat%(Float#) +* Double% = BU_LongLong_ToDouble%(LongLong%) +* LongLong% = BU_LongLong_FromDouble%(double%) +* String$ = BU_LongLong_Serialize$(LongLong%) +* LongLong% = BU_LongLong_Deserialize%(String$) + +### Double +64-bit floating point for Blitz. + +* Double% = BU_Double_Create%() +* BU_Double_Destroy(Double%) +* Double% = BU_Double_Copy%(Double%) +* Double% = BU_Double_TempCreate%() +* Double% = BU_Double_TempCopy%(Double%) +* BU_Double_SetTemp(Double%) +* BU_Double_UnsetTemp(Double%) +* BU_Double_TempCleanup() +* BU_Double_Set(Double%, Double%) +* BU_Double_SetF(Double%, Float#) +* BU_Double_Add(Double%, Double%) +* BU_Double_AddF(Double%, Float#) +* BU_Double_Sub(Double%, Double%) +* BU_Double_SubF(Double%, Float#) +* BU_Double_Mul(Double%, Double%) +* BU_Double_MulF(Double%, Float#) +* BU_Double_Div(Double%, Double%) +* BU_Double_DivF(Double%, Float#) +* Result% = BU_Double_Compare%(Double%, Double%) +Compares the two doubles and returns combinations of the following: 1 for equal, 2 for smaller, 4 for greater. +* Result% = BU_Double_CompareF%(Double%, Float#) +Compares the double as float with another float and returns combinations of the following: 1 for equal, 2 for smaller, 4 for greater. +* String$ = BU_Double_ToString$(Double%) +* Double% = BU_Double_FromString%(String$) +* Float# = BU_Double_ToFloat#(Double%) +* Double% = BU_Double_FromFloat%(Float#) +* LongLong% = BU_Double_ToLongLong%(Double%) +* Double% = BU_Double_FromLongLong%(LongLong%) +* String$ = BU_Double_Serialize$(Double%) +* String$ = BU_Double_Deserialize%(String$) + +## Utility +### Display Enumerator +Retrieve information about displays from Windows. + +* DisplayEnumerator% = BU_DisplayEnumerator_Create%() +* BU_DisplayEnumerator_Destroy(DisplayEnumerator%) +* BU_DisplayEnumerator_Enumerate%(DisplayEnumerator%) +* BU_DisplayEnumerator_Count%(DisplayEnumerator%) +* BU_DisplayEnumerator_Retrieve%(DisplayEnumerator%, index%, Rect*) + +### Indexer V2 +Fast array-based index generation. Uses a constant chunk of memory. + +* Indexer% = BU_IndexerV2_Create%() +* BU_IndexerV2_Destroy(Indexer%) +* BU_IndexerV2_Mark(Indexer%, Used%) +* BU_IndexerV2_MarkFree(Indexer%) +* BU_IndexerV2_MarkUsed(Indexer%) +* Result% = BU_IndexerV2_Is%(Indexer%, Used%) +* Result% = BU_IndexerV2_IsFree%(Indexer%) +* Result% = BU_IndexerV2_IsUsed%(Indexer%) +* Index% = BU_IndexerV2_Get%(Indexer%) +* Amount% = BU_IndexerV2_Count%(Indexer%, Used%) +* Amount% = BU_IndexerV2_CountFree%(Indexer%) +* Amount% = BU_IndexerV2_CountUsed%(Indexer%) + +### Indexer V2 +Fast vector-based index generation, uses a dynamic amount of memory. + +* Indexer% = BU_IndexerV2_Create%() +* BU_IndexerV2_Destroy(Indexer%) +* BU_IndexerV2_Mark(Indexer%, Used%) +* BU_IndexerV2_MarkFree(Indexer%) +* BU_IndexerV2_MarkUsed(Indexer%) +* Result% = BU_IndexerV2_Is%(Indexer%, Used%) +* Result% = BU_IndexerV2_IsFree%(Indexer%) +* Result% = BU_IndexerV2_IsUsed%(Indexer%) +* Index% = BU_IndexerV2_Get%(Indexer%) +* Amount% = BU_IndexerV2_Count%(Indexer%, Used%) +* Amount% = BU_IndexerV2_CountFree%(Indexer%) +* Amount% = BU_IndexerV2_CountUsed%(Indexer%) + +### Mass Operation +Allows chaining operations on custom types, such as LongLong and Double. See contants + +* BU_MassOp_Create%(length%) +* BU_MassOp_Destroy(massop%) +* BU_MassOp_Instruction%(massop%, index%, type%, code%, leftOperand%, rightOperand%, result%) +* BU_MassOp_Run(massop%) + +### Window Message Handler +Easily handle messages sent to Blitz windows using these functions. May not work as expected initially. + +* BU_WindowMessageHandler_Install(hwnd%) +* BU_WindowMessageHandler_Uninstall(hwnd%) +* Count% = BU_WindowMessageHandler_Message_Close%(hwnd%) +* Count% = BU_WindowMessageHandler_Message_Destroy%(hwnd%) +* Count% = BU_WindowMessageHandler_Message_Resize%(hwnd%, point*) \ No newline at end of file diff --git a/Type/BVector3.cpp b/Type/BVector3.cpp new file mode 100644 index 0000000..8519ea8 --- /dev/null +++ b/Type/BVector3.cpp @@ -0,0 +1,374 @@ +// BlitzUtility - Expanding the normal Blitz functionality. +// Copyright (C) 2015 Project Kube (Michael Fabian Dirks) +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program. If not, see . + +/* +#include "Vector3.h" + +void Vector3::set(const float &o) +{ + this->X = o; + this->Y = o; + this->Z = o; +} +void Vector3::set(const float &x, const float &y, const float &z) +{ + this->X = x; + this->Y = y; + this->Z = z; +} +void Vector3::set(const Vector3 &o) +{ + if (this != &o) { + this->X = o.X; + this->Y = o.Y; + this->Z = o.Z; + } +} + +void Vector3::add(const float &o) +{ + this->X += o; + this->Y += o; + this->Z += o; +} +void Vector3::add(const float &x, const float &y, const float &z) +{ + this->X += x; + this->Y += y; + this->Z += z; +} +void Vector3::add(const Vector3 &o) +{ + this->X += o.X; + this->Y += o.Y; + this->Z += o.Z; +} + +void Vector3::sub(const float &o) +{ + this->X -= o; + this->Y -= o; + this->Z -= o; +} +void Vector3::sub(const float &x, const float &y, const float &z) +{ + this->X -= x; + this->Y -= y; + this->Z -= z; +} +void Vector3::sub(const Vector3 &o) +{ + this->X -= o.X; + this->Y -= o.Y; + this->Z -= o.Z; +} + +void Vector3::mul(const float &o) +{ + this->X *= o; + this->Y *= o; + this->Z *= o; +} +void Vector3::mul(const float &x, const float &y, const float &z) +{ + this->X *= x; + this->Y *= y; + this->Z *= z; +} +void Vector3::mul(const Vector3 &o) +{ + this->X *= o.X; + this->Y *= o.Y; + this->Z *= o.Z; +} + +void Vector3::div(const float &o) +{ + this->X /= o; + this->Y /= o; + this->Z /= o; +} +void Vector3::div(const float &x, const float &y, const float &z) +{ + this->X /= x; + this->Y /= y; + this->Z /= z; +} +void Vector3::div(const Vector3 &o) +{ + this->X /= o.X; + this->Y /= o.Y; + this->Z /= o.Z; +} + +float Vector3::length() +{ + return sqrt(this->X * this->X + this->Y * this->Y + this->Z * this->Z); +} +float Vector3::distance(const float &x, const float &y, const float &z) +{ + float X = (this->X - x); + float Y = (this->Y - y); + float Z = (this->Z - z); + return sqrt(X * X + Y * Y + Z * Z); +} +float Vector3::distance(const Vector3 &o) +{ + float X = (this->X - o.X); + float Y = (this->Y - o.Y); + float Z = (this->Z - o.Z); + return sqrt(X * X + Y * Y + Z * Z); +} + +float Vector3::dot(const float &x, const float &y, const float &z) +{ + return (this->X * x) + (this->Y * y) + (this->Z * z); +} +float Vector3::dot(const Vector3 &o) +{ + return (this->X * o.X) + (this->Y * o.Y) + (this->Z * o.Z); +} +Vector3 Vector3::cross(const float &x, const float &y, const float &z) +{ + Vector3* data = new Vector3(); + data->X = (this->Y * z) - (this->Z * y); + data->Y = (this->Z * x) - (this->X * z); + data->Z = (this->X * y) - (this->Y * x); + return *data; +} +Vector3 Vector3::cross(const Vector3 &o) +{ + Vector3* data = new Vector3(); + data->X = (this->Y * o.Z) - (this->Z * o.Y); + data->Y = (this->Z * o.X) - (this->X * o.Z); + data->Z = (this->X * o.Y) - (this->Y * o.X); + return *data; +} +void Vector3::normalize() +{ + this->div(this->length()); +} + +void Vector3::rotate(float &pitch, float &yaw, float &roll) +{ + float** matrix = new float*[3]; + matrix[0] = new float[3]; matrix[1] = new float[3]; matrix[2] = new float[3]; + matrix[0][0] = cos(yaw) * cos(roll); matrix[0][1] = -sin(roll); matrix[0][2] = sin(yaw); + matrix[1][0] = sin(roll); matrix[1][1] = cos(pitch) * cos(roll); matrix[1][2] = -sin(pitch); + matrix[2][0] = -sin(yaw); matrix[2][1] = sin(pitch); matrix[2][2] = cos(pitch) * cos(yaw); + + float X = (this->X * matrix[0][0]) + (this->Y * matrix[0][1]) + (this->Z * matrix[0][2]); + float Y = (this->X * matrix[1][0]) + (this->Y * matrix[1][1]) + (this->Z * matrix[1][2]); + float Z = (this->X * matrix[2][0]) + (this->Y * matrix[2][1]) + (this->Z * matrix[2][2]); + this->X = X; this->Y = Y; this->Z = Z; +} +void Vector3::rotateAround(const float &x, const float &y, const float &z, float &pitch, float &yaw, float &roll) +{ + this->sub(x, y, z); + this->rotate(pitch, yaw, roll); + this->add(x, y, z); +} +void Vector3::rotateAround(Vector3 &o, float &pitch, float &yaw, float &roll) +{ + this->sub(o); + this->rotate(pitch, yaw, roll); + this->add(o); +} +float Vector3::deltaPitch() { + return (float)(atan(this->X / -this->Y) * (180.0 / M_PI)); +} +float Vector3::deltaPitch(const float &x, const float &y, const float &z) +{ + return (float)(atan((this->X - x) / (-(this->Y - y))) * (180.0 / M_PI)); +} +float Vector3::deltaPitch(Vector3 &o) +{ + return (float)(atan((this->X - o.X) / (-(this->Y - o.Y))) * (180.0 / M_PI)); +} +float Vector3::deltaYaw() { + return (float)(atan(sqrt((this->X * this->X) + (this->Y * this->Y)) / this->Z) * (180.0 / M_PI)); +} +float Vector3::deltaYaw(const float &x, const float &y, const float &z) +{ + float X = (this->X - x); + float Y = (this->Y - y); + return (float)(atan(sqrt((X * X) + (Y * Y)) / (this->Z - z)) * (180.0 / M_PI)); +} +float Vector3::deltaYaw(Vector3 &o) +{ + float X = (this->X - o.X); + float Y = (this->Y - o.Y); + return (float)(atan(sqrt((X * X) + (Y * Y)) / (this->Z - o.Z)) * (180.0 / M_PI)); +} + +char* Vector3::serialize() +{ + char* data = new char[13]; + + memcpy(data, this->Xc, 4); + memcpy(data + 4, this->Yc, 4); + memcpy(data + 8, this->Zc, 4); + data[12] = 0; + + return data; +} +void Vector3::deserialize(char* o) +{ + memcpy(o, this->Xc, 4); + memcpy(o + 4, this->Yc, 4); + memcpy(o + 8, this->Zc, 4); +} + +DLL_METHOD void Vector3_Set(Vector3* a, float o) { + a->set(o); +} +DLL_METHOD void Vector3_SetP(Vector3* a, float x, float y, float z) { + a->set(x, y, z); +} +DLL_METHOD void Vector3_SetV(Vector3* a, Vector3* b) { + a->set(*b); +} +#pragma comment(linker, "/EXPORT:Vector3_Set=_Vector3_Set@8") +#pragma comment(linker, "/EXPORT:Vector3_SetP=_Vector3_SetP@16") +#pragma comment(linker, "/EXPORT:Vector3_SetV=_Vector3_SetV@8") + +DLL_METHOD void Vector3_Add(Vector3* a, float o) { + a->add(o); +} +DLL_METHOD void Vector3_AddP(Vector3* a, float x, float y, float z) { + a->add(x, y, z); +} +DLL_METHOD void Vector3_AddV(Vector3* a, Vector3* b) { + a->add(*b); +} +#pragma comment(linker, "/EXPORT:Vector3_Add=_Vector3_Add@8") +#pragma comment(linker, "/EXPORT:Vector3_AddP=_Vector3_AddP@16") +#pragma comment(linker, "/EXPORT:Vector3_AddV=_Vector3_AddV@8") + +DLL_METHOD void Vector3_Sub(Vector3* a, float o) { + a->sub(o); +} +DLL_METHOD void Vector3_SubP(Vector3* a, float x, float y, float z) { + a->sub(x, y, z); +} +DLL_METHOD void Vector3_SubV(Vector3* a, Vector3* b) { + a->sub(*b); +} +#pragma comment(linker, "/EXPORT:Vector3_Sub=_Vector3_Sub@8") +#pragma comment(linker, "/EXPORT:Vector3_SubP=_Vector3_SubP@16") +#pragma comment(linker, "/EXPORT:Vector3_SubV=_Vector3_SubV@8") + +DLL_METHOD void Vector3_Mul(Vector3* a, float o) { + a->mul(o); +} +DLL_METHOD void Vector3_MulP(Vector3* a, float x, float y, float z) { + a->mul(x, y, z); +} +DLL_METHOD void Vector3_MulV(Vector3* a, Vector3* b) { + a->mul(*b); +} +#pragma comment(linker, "/EXPORT:Vector3_Mul=_Vector3_Mul@8") +#pragma comment(linker, "/EXPORT:Vector3_MulP=_Vector3_MulP@16") +#pragma comment(linker, "/EXPORT:Vector3_MulV=_Vector3_MulV@8") + +DLL_METHOD void Vector3_Div(Vector3* a, float o) { + a->div(o); +} +DLL_METHOD void Vector3_DivP(Vector3* a, float x, float y, float z) { + a->div(x, y, z); +} +DLL_METHOD void Vector3_DivV(Vector3* a, Vector3* b) { + a->div(*b); +} +#pragma comment(linker, "/EXPORT:Vector3_Div=_Vector3_Div@8") +#pragma comment(linker, "/EXPORT:Vector3_DivP=_Vector3_DivP@16") +#pragma comment(linker, "/EXPORT:Vector3_DivV=_Vector3_DivV@8") + +DLL_METHOD float Vector3_Length(Vector3* a) { + return (float)a->length(); +} +DLL_METHOD float Vector3_DistanceP(Vector3* a, float x, float y, float z) { + return (float)a->distance(x, y, z); +} +DLL_METHOD float Vector3_DistanceV(Vector3* a, Vector3* b) { + return (float)a->distance(*b); +} +#pragma comment(linker, "/EXPORT:Vector3_Length=_Vector3_Length@4") +#pragma comment(linker, "/EXPORT:Vector3_DistanceP=_Vector3_DistanceP@16") +#pragma comment(linker, "/EXPORT:Vector3_DistanceV=_Vector3_DistanceV@8") + +DLL_METHOD float Vector3_DotP(Vector3* a, float x, float y, float z) { + return (float)a->dot(x, y, z); +} +DLL_METHOD float Vector3_DotV(Vector3* a, Vector3* b) { + return (float)a->dot(*b); +} +DLL_METHOD void Vector3_CrossP(Vector3* a, float x, float y, float z, Vector3* out) { + Vector3 temp = a->cross(x, y, z); + *out = temp; +} +DLL_METHOD void Vector3_CrossV(Vector3* a, Vector3* b, Vector3* out) { + Vector3 temp = a->cross(*b); + *out = temp; +} +DLL_METHOD void Vector3_Normalize(Vector3* a) { + a->normalize(); +} +#pragma comment(linker, "/EXPORT:Vector3_DotP=_Vector3_DotP@16") +#pragma comment(linker, "/EXPORT:Vector3_DotV=_Vector3_DotV@8") +#pragma comment(linker, "/EXPORT:Vector3_CrossP=_Vector3_CrossP@20") +#pragma comment(linker, "/EXPORT:Vector3_CrossV=_Vector3_CrossV@12") +#pragma comment(linker, "/EXPORT:Vector3_Normalize=_Vector3_Normalize@4") + +DLL_METHOD void Vector3_Rotate(Vector3* a, float pitch, float yaw, float roll) { + a->rotate(pitch, yaw, roll); +} +DLL_METHOD void Vector3_RotateAroundP(Vector3* a, float x, float y, float z, float pitch, float yaw, float roll) { + a->rotateAround(x, y, z, pitch, yaw, roll); +} +DLL_METHOD void Vector3_RotateAroundV(Vector3* a, Vector3* b, float pitch, float yaw, float roll) { + a->rotateAround(*b, pitch, yaw, roll); +} +#pragma comment(linker, "/EXPORT:Vector3_Rotate=_Vector3_Rotate@16") +#pragma comment(linker, "/EXPORT:Vector3_RotateAroundP=_Vector3_RotateAroundP@28") +#pragma comment(linker, "/EXPORT:Vector3_RotateAroundV=_Vector3_RotateAroundV@20") + +DLL_METHOD float Vector3_DeltaPitchP(Vector3* a, float x, float y, float z) { + return (float)a->deltaPitch(x, y, z); +} +DLL_METHOD float Vector3_DeltaPitchV(Vector3* a, Vector3* b) { + return (float)a->deltaPitch(*b); +} +DLL_METHOD float Vector3_DeltaYawP(Vector3* a, float x, float y, float z) { + return (float)a->deltaYaw(x, y, z); +} +DLL_METHOD float Vector3_DeltaYawV(Vector3* a, Vector3* b) { + return (float)a->deltaYaw(*b); +} +#pragma comment(linker, "/EXPORT:Vector3_DeltaPitchP=_Vector3_DeltaPitchP@16") +#pragma comment(linker, "/EXPORT:Vector3_DeltaPitchV=_Vector3_DeltaPitchV@8") +#pragma comment(linker, "/EXPORT:Vector3_DeltaYawP=_Vector3_DeltaYawP@16") +#pragma comment(linker, "/EXPORT:Vector3_DeltaYawV=_Vector3_DeltaYawV@8") + +DLL_METHOD char* Vector3_Serialize(Vector3* a) { + return a->serialize(); +} +DLL_METHOD void Vector3_Deserialize(Vector3* a, char* s) { + a->deserialize(s); +} +#pragma comment(linker, "/EXPORT:Vector3_Serialize=_Vector3_Serialize@4") +#pragma comment(linker, "/EXPORT:Vector3_Deserialize=_Vector3_Deserialize@8") +*/ \ No newline at end of file diff --git a/Type/BVector3.h b/Type/BVector3.h new file mode 100644 index 0000000..395335e --- /dev/null +++ b/Type/BVector3.h @@ -0,0 +1,82 @@ +// BlitzUtility - Expanding the normal Blitz functionality. +// Copyright (C) 2015 Project Kube (Michael Fabian Dirks) +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program. If not, see . + +/* +#pragma once +#include "dllmain.h" +#ifndef _USE_MATH_DEFINES + #define _USE_MATH_DEFINES + #include + #undef _USE_MATH_DEFINES +#endif + +struct Vector3 { + union { + float X; + char Xc[4]; + }; + union { + float Y; + char Yc[4]; + }; + union { + float Z; + char Zc[4]; + }; + + void set(const float &o); + void set(const float &x, const float &y, const float &z); + void set(const Vector3 &o); + + void add(const float &o); + void add(const float &x, const float &y, const float &z); + void add(const Vector3 &o); + + void sub(const float &o); + void sub(const float &x, const float &y, const float &z); + void sub(const Vector3 &o); + + void mul(const float &o); + void mul(const float &x, const float &y, const float &z); + void mul(const Vector3 &o); + + void div(const float &o); + void div(const float &x, const float &y, const float &z); + void div(const Vector3 &o); + + float length(); + float distance(const float &x, const float &y, const float &z); + float distance(const Vector3 &o); + + float dot(const float &x, const float &y, const float &z); + float dot(const Vector3 &o); + Vector3 cross(const float &x, const float &y, const float &z); + Vector3 cross(const Vector3 &o); + void normalize(); + + void rotate(float &pitch, float &yaw, float &roll); + void rotateAround(const float &x, const float &y, const float &z, float &pitch, float &yaw, float &roll); + void rotateAround(Vector3 &o, float &pitch, float &yaw, float &roll); + float deltaPitch(); + float deltaPitch(const float &x, const float &y, const float &z); + float deltaPitch(Vector3 &o); + float deltaYaw(); + float deltaYaw(const float &x, const float &y, const float &z); + float deltaYaw(Vector3 &o); + + char* serialize(); + void deserialize(char* o); +};*/ \ No newline at end of file diff --git a/Type/BlitzType.h b/Type/BlitzType.h new file mode 100644 index 0000000..60a4ddd --- /dev/null +++ b/Type/BlitzType.h @@ -0,0 +1,132 @@ +#include "Common.h" +#include +#include + +// Rev-engineered from https://github.com/blitz-research/blitz3d/blob/master/compiler/declnode.cpp +#define BBVARTYPE_GLOBAL 0 +#define BBVARTYPE_INT 1 +#define BBVARTYPE_FLOAT 2 +#define BBVARTYPE_UNUSED 3 +#define BBVARTYPE_STRING 4 +#define BBVARTYPE_TYPE 5 +#define BBVARTYPE_ARRAY 6 + +struct BBVar { + int Type = -1; +}; + +struct BBVarGlobal { + int GlobalType = -1; + int* Value; +}; + +struct BBVarInt : BBVar { + int Value; +}; + +struct BBVarFloat : BBVar { + float Value; +}; + +struct BBVarUnused : BBVar { + // Not a Dim, as you can see here: + // https://github.com/blitz-research/blitz3d/blob/master/compiler/stmtnode.cpp#L86 +}; + +struct BBVarString : BBVar { + int Length; + char* Value; +}; + +struct BBVarElement; +struct BBVarType : BBVar { + BBVarElement used, free; + int fieldCount; // Field Info follows (Exactly int pointers to variable struct) + int* fields[]; +}; + +struct BBVarElement { + int* currentPtr; // Points towards fields. + int* nextPtr, prevPtr; + BBVarType* BBStructPtr; + int refCount; // Fields usually follow here, may be at another location, see currentPtr. + //BBVar* fields[]; +}; + +struct BBVarArray : BBVar { + int Size; //??? + BBVar* ArrayType; +}; + +std::string BBVar_Serialize(void* obj) { + std::stringstream myStream; + + BBVar* var = (BBVar*)obj; + switch (var->Type) { + case BBVARTYPE_GLOBAL: + BBVarGlobal* varGlobal = (BBVarGlobal*)obj; + myStream << "[Global] " << BBVar_Serialize(varGlobal->Value) << std::endl; + break; + case BBVARTYPE_INT: + BBVarInt* varInt = (BBVarInt*)obj; + myStream << "Int" << std::endl; + break; + case BBVARTYPE_FLOAT: + BBVarFloat* varFloat = (BBVarFloat*)obj; + myStream << "Float" << std::endl; + break; + case BBVARTYPE_UNUSED: + BBVarUnused* varUnused = (BBVarUnused*)obj; + myStream << "Unused" << std::endl; + break; + case BBVARTYPE_STRING: + BBVarString* varString = (BBVarString*)obj; + myStream << "String" << std::endl; + break; + case BBVARTYPE_TYPE: + BBVarType* varType = (BBVarType*)obj; + myStream << BBVarType_Serialize(varType); + break; + case BBVARTYPE_ARRAY: + BBVarArray* varArray = (BBVarArray*)obj; + myStream << "Array = " << std::endl; + break; + } + + return myStream.str(); +} + +std::string BBVarType_Serialize(BBVarType* obj, unsigned int indent = 0) { + std::stringstream myStream; + + std::stringstream myPaddingSS; + for (unsigned int pad = 0; pad < indent; pad++) { + myPaddingSS << " "; + } + std::string myPadding = myPaddingSS.str(); + + myStream << myPadding << "Type {" << std::endl; + for (unsigned int fld = 0; fld < obj->fieldCount; fld++) { + myStream << myPadding << " (" << fld << ") => " << BBVar_Serialize(obj->fields[fld]) << std::endl; + } + myStream << myPadding << "}" << std::endl; + + return myStream.str(); +} + +DLL_EXPORT(char*) SerializeObject(void* obj) { + return strdup(BBVar_Serialize(obj).c_str()); +} + +// Laut Mark Sibly: +struct BBType { + int obj_size; + BBObj usedList, freeList; +}; + +struct BBObj { + BBObj *curr; + BBObj *next, *prev; + int* bbtype; + int ref_cnt; +}; diff --git a/Type/Double.cpp b/Type/Double.cpp new file mode 100644 index 0000000..74576ce --- /dev/null +++ b/Type/Double.cpp @@ -0,0 +1,163 @@ +// Blitz - Steam wrapper for Blitz. +// Copyright (C) 2015 Project Kube (Michael Fabian Dirks) +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program. If not, see . + +#include "Double.h" +#include + +std::list BU_DoubleTemporary; + +DLL_METHOD double_t* DLL_CALL BU_Double_Create() { + return new double_t; +} + +DLL_METHOD void DLL_CALL BU_Double_Destroy(double_t* pthis) { + delete pthis; +} + +DLL_METHOD double_t* DLL_CALL BU_Double_Copy(double_t* other) { + double_t* pthis = new double_t; + *pthis = *other; + return pthis; +} + +DLL_METHOD double_t* DLL_CALL BU_Double_TempCreate() { + double_t* val = new double_t; + BU_DoubleTemporary.push_back(val); + return val; +} + +DLL_METHOD double_t* DLL_CALL BU_Double_TempCopy(double_t* other) { + double_t* val = new double_t(*other); + BU_DoubleTemporary.push_back(val); + return val; +} + +DLL_METHOD void DLL_CALL BU_Double_SetTemp(double_t* pthis) { + BU_DoubleTemporary.push_back(pthis); +} + +DLL_METHOD void DLL_CALL BU_Double_UnsetTemp(double_t* pthis) { + BU_DoubleTemporary.remove(pthis); +} + +DLL_METHOD void DLL_CALL BU_Double_TempCleanup() { + auto iterEnd = BU_DoubleTemporary.end(); + for (auto iter = BU_DoubleTemporary.begin(); iter != iterEnd; ++iter) { + delete *iter; + } + BU_DoubleTemporary.clear(); +} + +DLL_METHOD void DLL_CALL BU_Double_Set(double_t* pthis, double_t* other) { + *pthis = *other; +} + +DLL_METHOD void DLL_CALL BU_Double_SetF(double_t* pthis, float_t other) { + *pthis = other; +} + +DLL_METHOD void DLL_CALL BU_Double_Add(double_t* pthis, double_t* other) { + *pthis += *other; +} + +DLL_METHOD void DLL_CALL BU_Double_AddF(double_t* pthis, float_t other) { + *pthis += other; +} + +DLL_METHOD void DLL_CALL BU_Double_Sub(double_t* pthis, double_t* other) { + *pthis -= *other; +} + +DLL_METHOD void DLL_CALL BU_Double_SubF(double_t* pthis, float_t other) { + *pthis -= other; +} + +DLL_METHOD void DLL_CALL BU_Double_Mul(double_t* pthis, double_t* other) { + *pthis *= *other; +} + +DLL_METHOD void DLL_CALL BU_Double_MulF(double_t* pthis, float_t other) { + *pthis *= other; +} + +DLL_METHOD void DLL_CALL BU_Double_Div(double_t* pthis, double_t* other) { + *pthis /= *other; +} + +DLL_METHOD void DLL_CALL BU_Double_DivF(double_t* pthis, float_t other) { + *pthis /= other; +} + +DLL_METHOD uint32_t DLL_CALL BU_Double_Compare(double_t* pthis, double_t* other) { + return (*pthis == *other ? 1 : 0) + (*pthis < *other ? 2 : 0) + (*pthis > *other ? 4 : 0); +} + +DLL_METHOD uint32_t DLL_CALL BU_Double_CompareF(double_t* pthis, float_t other) { + return ((float_t)*pthis == other ? 1 : 0) + ((float_t)*pthis < other ? 2 : 0) + ((float_t)*pthis > other ? 4 : 0); +} + +DLL_METHOD const char* DLL_CALL BU_Double_ToString(double_t* pthis) { + std::stringstream stream; + stream << *pthis; + return stream.str().c_str(); +} + +DLL_METHOD double_t* DLL_CALL BU_Double_FromString(const char* text) { + std::stringstream stream = std::stringstream(text); + double_t* doublePtr = new double_t; + stream >> *doublePtr; + return doublePtr; +} + +DLL_METHOD float_t DLL_CALL BU_Double_ToFloat(double_t* pthis) { + return (float_t)*pthis; +} + +DLL_METHOD double_t* DLL_CALL BU_Double_FromFloat(float_t other) { + double_t* val = new double_t; + *val = (double_t)other; + return val; +} + +DLL_METHOD int64_t* DLL_CALL BU_Double_ToLongLong(double_t* pthis) { + int64_t* val = new int64_t; + *val = (int64_t)*pthis; + return val; +} + +DLL_METHOD double_t* DLL_CALL BU_Double_FromLongLong(int64_t* other) { + double_t* val = new double_t; + *val = (double_t)*other; + return val; +} + +DLL_METHOD const char* DLL_CALL BU_Double_Serialize(double_t* pthis) { + union { + double_t real; + int64_t integer; + } myval; + myval.real = *pthis; + return int_to_hex(myval.integer).c_str(); +} + +DLL_METHOD double_t* DLL_CALL BU_Double_Deserialize(const char* text) { + union { + double_t real; + int64_t integer; + } myval; + myval.integer = hex_to_int(std::string(text)); + return BU_Double_Copy(&myval.real); +} \ No newline at end of file diff --git a/Type/Double.h b/Type/Double.h new file mode 100644 index 0000000..fa9ae4c --- /dev/null +++ b/Type/Double.h @@ -0,0 +1,96 @@ +// Blitz - Steam wrapper for Blitz. +// Copyright (C) 2015 Project Kube (Michael Fabian Dirks) +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program. If not, see . + +#pragma once +#include "dllmain.h" +#include "LongLong.h" + +#pragma region Constructor & Destructor +DLL_METHOD double_t* DLL_CALL BU_Double_Create(); +DLL_METHOD void DLL_CALL BU_Double_Destroy(double_t* pthis); +DLL_METHOD double_t* DLL_CALL BU_Double_Copy(double_t* other); +#pragma comment(linker, "/EXPORT:BU_Double_Create=_BU_Double_Create@0") +#pragma comment(linker, "/EXPORT:BU_Double_Destroy=_BU_Double_Destroy@4") +#pragma comment(linker, "/EXPORT:BU_Double_Copy=_BU_Double_Copy@4") +#pragma endregion Constructor & Destructor + +#pragma region Temporary Objects +DLL_METHOD double_t* DLL_CALL BU_Double_TempCreate(); +DLL_METHOD double_t* DLL_CALL BU_Double_TempCopy(double_t* other); +DLL_METHOD void DLL_CALL BU_Double_SetTemp(double_t* pthis); +DLL_METHOD void DLL_CALL BU_Double_UnsetTemp(double_t* pthis); +DLL_METHOD void DLL_CALL BU_Double_TempCleanup(); +#pragma comment(linker, "/EXPORT:BU_Double_TempCreate=_BU_Double_TempCreate@0") +#pragma comment(linker, "/EXPORT:BU_Double_TempCopy=_BU_Double_TempCopy@4") +#pragma comment(linker, "/EXPORT:BU_Double_SetTemp=_BU_Double_SetTemp@4") +#pragma comment(linker, "/EXPORT:BU_Double_UnsetTemp=_BU_Double_UnsetTemp@4") +#pragma comment(linker, "/EXPORT:BU_Double_TempCleanup=_BU_Double_TempCleanup@0") +#pragma endregion Temporary Objects + +#pragma region Math +DLL_METHOD void DLL_CALL BU_Double_Set(double_t* pthis, double_t* other); +DLL_METHOD void DLL_CALL BU_Double_SetF(double_t* pthis, float_t other); +#pragma comment(linker, "/EXPORT:BU_Double_Set=_BU_Double_Set@8") +#pragma comment(linker, "/EXPORT:BU_Double_SetF=_BU_Double_SetF@8") +DLL_METHOD void DLL_CALL BU_Double_Add(double_t* pthis, double_t* other); +DLL_METHOD void DLL_CALL BU_Double_AddF(double_t* pthis, float_t other); +#pragma comment(linker, "/EXPORT:BU_Double_Add=_BU_Double_Add@8") +#pragma comment(linker, "/EXPORT:BU_Double_AddF=_BU_Double_AddF@8") +DLL_METHOD void DLL_CALL BU_Double_Sub(double_t* pthis, double_t* other); +DLL_METHOD void DLL_CALL BU_Double_SubF(double_t* pthis, float_t other); +#pragma comment(linker, "/EXPORT:BU_Double_Sub=_BU_Double_Sub@8") +#pragma comment(linker, "/EXPORT:BU_Double_SubF=_BU_Double_SubF@8") +DLL_METHOD void DLL_CALL BU_Double_Mul(double_t* pthis, double_t* other); +DLL_METHOD void DLL_CALL BU_Double_MulF(double_t* pthis, float_t other); +#pragma comment(linker, "/EXPORT:BU_Double_Mul=_BU_Double_Mul@8") +#pragma comment(linker, "/EXPORT:BU_Double_MulF=_BU_Double_MulF@8") +DLL_METHOD void DLL_CALL BU_Double_Div(double_t* pthis, double_t* other); +DLL_METHOD void DLL_CALL BU_Double_DivF(double_t* pthis, float_t other); +#pragma comment(linker, "/EXPORT:BU_Double_Div=_BU_Double_Div@8") +#pragma comment(linker, "/EXPORT:BU_Double_DivF=_BU_Double_DivF@8") +#pragma endregion Math + +#pragma region Comparision +DLL_METHOD uint32_t DLL_CALL BU_Double_Compare(double_t* pthis, double_t* other); +DLL_METHOD uint32_t DLL_CALL BU_Double_CompareF(double_t* pthis, float_t other); +#pragma comment(linker, "/EXPORT:BU_Double_Compare=_BU_Double_Compare@8") +#pragma comment(linker, "/EXPORT:BU_Double_CompareF=_BU_Double_CompareF@8") +#pragma endregion Comparision + +#pragma region Conversion +// String conversion +DLL_METHOD const char* DLL_CALL BU_Double_ToString(double_t* pthis); +DLL_METHOD double_t* DLL_CALL BU_Double_FromString(const char* text); +#pragma comment(linker, "/EXPORT:BU_Double_ToString=_BU_Double_ToString@4") +#pragma comment(linker, "/EXPORT:BU_Double_FromString=_BU_Double_FromString@4") +// 32-Bit Floating Point +DLL_METHOD float_t DLL_CALL BU_Double_ToFloat(double_t* pthis); +DLL_METHOD double_t* DLL_CALL BU_Double_FromFloat(float_t other); +#pragma comment(linker, "/EXPORT:BU_Double_ToFloat=_BU_Double_ToFloat@4") +#pragma comment(linker, "/EXPORT:BU_Double_FromFloat=_BU_Double_FromFloat@4") +// 64-Bit Integer +DLL_METHOD int64_t* DLL_CALL BU_Double_ToLongLong(double_t* pthis); +DLL_METHOD double_t* DLL_CALL BU_Double_FromLongLong(int64_t* other); +#pragma comment(linker, "/EXPORT:BU_Double_ToLongLong=_BU_Double_ToLongLong@4") +#pragma comment(linker, "/EXPORT:BU_Double_FromLongLong=_BU_Double_FromLongLong@4") +#pragma endregion Conversion + +#pragma region Serialization +DLL_METHOD const char* DLL_CALL BU_Double_Serialize(double_t* pthis); +DLL_METHOD double_t* DLL_CALL BU_Double_Deserialize(const char* text); +#pragma comment(linker, "/EXPORT:BU_Double_Serialize=_BU_Double_Serialize@4") +#pragma comment(linker, "/EXPORT:BU_Double_Deserialize=_BU_Double_Deserialize@4") +#pragma endregion Serialization \ No newline at end of file diff --git a/Type/FVector2.cpp b/Type/FVector2.cpp new file mode 100644 index 0000000..7d0c742 --- /dev/null +++ b/Type/FVector2.cpp @@ -0,0 +1,220 @@ +// BlitzUtility - Expanding the normal Blitz functionality. +// Copyright (C) 2015 Project Kube (Michael Fabian Dirks) +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program. If not, see . + +/* +#pragma once +#include "FVector2.h" + +double FVector2::length() +{ + return std::sqrtf(std::abs((this->X*this->X) + (this->Y*this->Y))); +} + +void FVector2::normalize() { + double len = this->length(); + double divisor = 1.0 / (len != 0 ? len : FLT_EPSILON); +} + +double FVector2::distance(const FVector2 r) +{ + float X = (this->X - r.X), Y = (this->Y - r.Y); + return std::sqrtf(std::abs(X*X + Y*Y)); +} + +const char* FVector2::serialize() { + +} + +FVector2& FVector2::deserialize(const char* serialized) { + +} + +FVector2::FVector2(float V) { + +} + +FVector2::FVector2(float X, float Y) { + +} + +FVector2::FVector2(FVector2& V) { + +} + +FVector2& FVector2::operator++() { + +} + +FVector2& FVector2::operator--() { + +} + +bool FVector2::operator>(const FVector2& r) { + +} + +bool FVector2::operator>(const float& r) { + +} + + +bool FVector2::operator<(const FVector2& r) { + +} + +bool FVector2::operator<(const float& r) { + +} + + +bool FVector2::operator==(const FVector2& r) { + +} + +bool FVector2::operator==(const float& r) { + +} + + +bool FVector2::operator>=(const FVector2& r) { + +} + +bool FVector2::operator>=(const float& r) { + +} + + +bool FVector2::operator<=(const FVector2& r) { + +} + +bool FVector2::operator<=(const float& r) { + +} + + +bool FVector2::operator!=(const FVector2& r) { + +} + +bool FVector2::operator!=(const float& r) { + +} + + +FVector2& FVector2::operator=(const FVector2& r) { + +} + +FVector2& FVector2::operator=(const float& r) { + +} + + +FVector2& FVector2::operator+(const FVector2& r) { + +} + +FVector2& FVector2::operator+(const float& r) { + +} + + +FVector2& FVector2::operator-(const FVector2& r) { + +} + +FVector2& FVector2::operator*(const FVector2& r) { + +} + +FVector2& FVector2::operator*(const float& r) { + +} + + +FVector2& FVector2::operator/(const FVector2& r) { + +} + +FVector2& FVector2::operator/(const float& r) { + +} + + +FVector2& FVector2::operator+=(const FVector2& r) { + +} + +FVector2& FVector2::operator+=(const float& r) { + +} + + +FVector2& FVector2::operator-=(const FVector2& r) { + +} + +FVector2& FVector2::operator*=(const FVector2& r) { + +} + +FVector2& FVector2::operator*=(const float& r) { + +} + + +FVector2& FVector2::operator/=(const FVector2& r) { + +} + +FVector2& FVector2::operator/=(const float& r) { + +} + + +FVector2& FVector2::operator-(const float& r) { + +} + +FVector2& FVector2::operator-=(const float& r) { + +} + + + + + + + + + + + + + + + + + + + + + + + +*/ \ No newline at end of file diff --git a/Type/FVector2.h b/Type/FVector2.h new file mode 100644 index 0000000..cf6f628 --- /dev/null +++ b/Type/FVector2.h @@ -0,0 +1,98 @@ +// BlitzUtility - Expanding the normal Blitz functionality. +// Copyright (C) 2015 Project Kube (Michael Fabian Dirks) +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program. If not, see . + +/* +#pragma once +#include "dllmain.h" +#ifndef _USE_MATH_DEFINES + #define _USE_MATH_DEFINES + #include + #undef _USE_MATH_DEFINES +#endif + +struct FVector2 { + float X, Y; + + // Constructor & Destructor + FVector2(float V); + FVector2(float X, float Y); + FVector2(FVector2& V); + + // Operator Overloading + FVector2& operator++(); + FVector2& operator--(); + bool operator>(const FVector2& r); + bool operator<(const FVector2& r); + bool operator==(const FVector2& r); + bool operator>=(const FVector2& r); + bool operator<=(const FVector2& r); + bool operator!=(const FVector2& r); + FVector2& operator=(const FVector2& r); + FVector2& operator+(const FVector2& r); + FVector2& operator-(const FVector2& r); + FVector2& operator*(const FVector2& r); + FVector2& operator/(const FVector2& r); + FVector2& operator+=(const FVector2& r); + FVector2& operator-=(const FVector2& r); + FVector2& operator*=(const FVector2& r); + FVector2& operator/=(const FVector2& r); + + // Operator Overloading - float + bool operator>(const float& r); + bool operator<(const float& r); + bool operator==(const float& r); + bool operator>=(const float& r); + bool operator<=(const float& r); + bool operator!=(const float& r); + FVector2& operator=(const float& r); + FVector2& operator+(const float& r); + FVector2& operator-(const float& r); + FVector2& operator*(const float& r); + FVector2& operator/(const float& r); + FVector2& operator+=(const float& r); + FVector2& operator-=(const float& r); + FVector2& operator*=(const float& r); + FVector2& operator/=(const float& r); + + // Simple Math + double length(); + void normalize(); + double distance(const FVector2 r); + + // Advanced Math + void rotate(const double ) + + // Serialization + const char* serialize(); + static FVector2& deserialize(const char* serialized); +}; + +DLL_METHOD FVector2* DLL_CALL BU_FVector2_Create(); +DLL_METHOD FVector2* DLL_CALL BU_FVector2_Copy(FVector2* copyVector); +DLL_METHOD void DLL_CALL BU_FVector2_Destroy(); + +DLL_METHOD FVector2* DLL_CALL BU_FVector2_TempCreate(); +DLL_METHOD FVector2* DLL_CALL BU_FVector2_TempCopy(FVector2* copyVector); +DLL_METHOD void DLL_CALL BU_FVector2_SetTemp(FVector2* vector); +DLL_METHOD void DLL_CALL BU_FVector2_UnsetTemp(FVector2* vector); +DLL_METHOD void DLL_CALL BU_FVector2_TempCleanup(); + +DLL_METHOD float DLL_CALL BU_FVector2_Length(FVector2* vector); +DLL_METHOD float DLL_CALL BU_FVector2_Normalize(); +DLL_METHOD float DLL_CALL BU_FVector2_Distance(FVector2* vector); +DLL_METHOD float DLL_CALL BU_FVector2_DistanceL(float X, float Y); + +*/ \ No newline at end of file diff --git a/Type/LongLong.cpp b/Type/LongLong.cpp new file mode 100644 index 0000000..ee9d139 --- /dev/null +++ b/Type/LongLong.cpp @@ -0,0 +1,174 @@ +// Blitz - Steam wrapper for Blitz. +// Copyright (C) 2015 Project Kube (Michael Fabian Dirks) +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program. If not, see . + +#pragma once +#include "LongLong.h" +#include + +std::list blitzLLTemporary; + +int64_t* DLL_CALL BU_LongLong_Create() { + return new int64_t; +} + +void DLL_CALL BU_LongLong_Destroy(int64_t* pthis) { + delete pthis; +} + +int64_t* DLL_CALL BU_LongLong_Copy(int64_t* other) { + int64_t* pthis = new int64_t; + *pthis = *other; + return pthis; +} + +DLL_METHOD int64_t* DLL_CALL BU_LongLong_TempCreate() { + int64_t* val = new int64_t; + blitzLLTemporary.push_back(val); + return val; +} + +DLL_METHOD int64_t* DLL_CALL BU_LongLong_TempCopy(int64_t* other) { + int64_t* val = new int64_t(*other); + blitzLLTemporary.push_back(val); + return val; +} + +DLL_METHOD void DLL_CALL BU_LongLong_SetTemp(int64_t* pthis) { + blitzLLTemporary.push_back(pthis); +} + +DLL_METHOD void DLL_CALL BU_LongLong_UnsetTemp(int64_t* pthis) { + blitzLLTemporary.remove(pthis); +} + +DLL_METHOD void DLL_CALL BU_LongLong_TempCleanup() { + auto iterEnd = blitzLLTemporary.end(); + for (auto iter = blitzLLTemporary.begin(); iter != iterEnd; ++iter) { + delete *iter; + } + blitzLLTemporary.clear(); +} + + +void DLL_CALL BU_LongLong_Set(int64_t* pthis, int64_t* other) { + *pthis = *other; +} + +void DLL_CALL BU_LongLong_SetV(int64_t* pthis, uint32_t left, uint32_t right) { + *pthis = ((int64_t)left << 32) + right; +} + +void DLL_CALL BU_LongLong_Add(int64_t* pthis, int64_t* other) { + *pthis += *other; +} + +void DLL_CALL BU_LongLong_AddV(int64_t* pthis, uint32_t left, uint32_t right) { + *pthis += ((int64_t)left << 32) + right; +} + +void DLL_CALL BU_LongLong_Sub(int64_t* pthis, int64_t* other) { + *pthis -= *other; +} + +void DLL_CALL BU_LongLong_SubV(int64_t* pthis, uint32_t left, uint32_t right) { + *pthis -= ((int64_t)left << 32) + right; +} + +void DLL_CALL BU_LongLong_Mul(int64_t* pthis, int64_t* other) { + *pthis *= *other; +} + +void DLL_CALL BU_LongLong_MulV(int64_t* pthis, uint32_t left, uint32_t right) { + *pthis *= ((int64_t)left << 32) + right; +} + +void DLL_CALL BU_LongLong_Div(int64_t* pthis, int64_t* other) { + *pthis *= *other; +} + +void DLL_CALL BU_LongLong_DivV(int64_t* pthis, uint32_t left, uint32_t right) { + *pthis *= ((int64_t)left << 32) + right; +} + +uint32_t DLL_CALL BU_LongLong_Compare(int64_t* pthis, int64_t* other) { + return (*pthis == *other ? 1 : 0) + (*pthis < *other ? 2 : 0) + (*pthis > *other ? 4 : 0); +} + +uint32_t DLL_CALL BU_LongLong_CompareV(int64_t* pthis, uint32_t left, uint32_t right) { + int64_t other = ((int64_t)left << 32) + right; + return (*pthis == other ? 1 : 0) + (*pthis < other ? 2 : 0) + (*pthis > other ? 4 : 0); +} + +const char* DLL_CALL BU_LongLong_ToString(int64_t* pthis) { + std::stringstream stream; + stream << *pthis; + return stream.str().c_str(); +} + +int64_t* DLL_CALL BU_LongLong_FromString(const char* text) { + std::stringstream stream = std::stringstream(text); + int64_t* val = new int64_t; + stream >> *val; + return val; +} + +int32_t DLL_CALL BU_LongLong_ToLong(int64_t* pthis, int32_t _modulus) { + return *pthis % _modulus; +} + +int64_t* DLL_CALL BU_LongLong_FromLong(int32_t left, int32_t right) { + int64_t* val = new int64_t; + *val = ((int64_t)left << 32) + right; + return val; +} + +int32_t DLL_CALL BU_LongLong_ToLongHigh(int64_t* pthis) { + return (int32_t)((*pthis) >> 32); +} + +int32_t DLL_CALL BU_LongLong_ToLongLow(int64_t* pthis) { + return (int32_t)((*pthis) && 0xFFFFFFFF); +} + +float_t DLL_CALL BU_LongLong_ToFloat(int64_t* pthis) { + return (float)*pthis; +} + +int64_t* DLL_CALL BU_LongLong_FromFloat(float_t other) { + int64_t val = (int64_t)other; + return BU_LongLong_Copy(&val); +} + +double_t* DLL_CALL BU_LongLong_ToDouble(int64_t* pthis) { + double_t* val = new double_t; + *val = (double_t)*pthis; + return val; +} + +int64_t* DLL_CALL BU_LongLong_FromDouble(double_t* other) { + int64_t* val = new int64_t; + *val = (int64_t)*other; + return val; +} + +const char* DLL_CALL BU_LongLong_Serialize(int64_t* pthis) { + return int_to_hex(*pthis).c_str(); +} + +int64_t* DLL_CALL BU_LongLong_Deserialize(const char* text) { + int64_t val = hex_to_int(std::string(text)); + return BU_LongLong_Copy(&val); +} \ No newline at end of file diff --git a/Type/LongLong.h b/Type/LongLong.h new file mode 100644 index 0000000..8bee256 --- /dev/null +++ b/Type/LongLong.h @@ -0,0 +1,104 @@ +// Blitz - Steam wrapper for Blitz. +// Copyright (C) 2015 Project Kube (Michael Fabian Dirks) +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program. If not, see . + +#pragma once +#include "dllmain.h" +#include "Double.h" +#include +#include + +#pragma region Constructor & Destructor +DLL_METHOD int64_t* DLL_CALL BU_LongLong_Create(); +DLL_METHOD void DLL_CALL BU_LongLong_Destroy(int64_t* pthis); +DLL_METHOD int64_t* DLL_CALL BU_LongLong_Copy(int64_t* other); +#pragma comment(linker, "/EXPORT:BU_LongLong_Create=_BU_LongLong_Create@0") +#pragma comment(linker, "/EXPORT:BU_LongLong_Destroy=_BU_LongLong_Destroy@4") +#pragma comment(linker, "/EXPORT:BU_LongLong_Copy=_BU_LongLong_Copy@4") +#pragma endregion Constructor & Destructor + +#pragma region Temporary Objects +DLL_METHOD int64_t* DLL_CALL BU_LongLong_TempCreate(); +DLL_METHOD int64_t* DLL_CALL BU_LongLong_TempCopy(int64_t* other); +DLL_METHOD void DLL_CALL BU_LongLong_SetTemp(int64_t* pthis); +DLL_METHOD void DLL_CALL BU_LongLong_UnsetTemp(int64_t* pthis); +DLL_METHOD void DLL_CALL BU_LongLong_TempCleanup(); +#pragma comment(linker, "/EXPORT:BU_LongLong_TempCreate=_BU_LongLong_TempCreate@0") +#pragma comment(linker, "/EXPORT:BU_LongLong_TempCopy=_BU_LongLong_TempCopy@4") +#pragma comment(linker, "/EXPORT:BU_LongLong_SetTemp=_BU_LongLong_SetTemp@4") +#pragma comment(linker, "/EXPORT:BU_LongLong_UnsetTemp=_BU_LongLong_UnsetTemp@4") +#pragma comment(linker, "/EXPORT:BU_LongLong_TempCleanup=_BU_LongLong_TempCleanup@0") +#pragma endregion Temporary Objects + +#pragma region Math +DLL_METHOD void DLL_CALL BU_LongLong_Set(int64_t* pthis, int64_t* other); +DLL_METHOD void DLL_CALL BU_LongLong_SetV(int64_t* pthis, uint32_t left, uint32_t right); +#pragma comment(linker, "/EXPORT:BU_LongLong_Set=_BU_LongLong_Set@8") +#pragma comment(linker, "/EXPORT:BU_LongLong_SetV=_BU_LongLong_SetV@12") +DLL_METHOD void DLL_CALL BU_LongLong_Add(int64_t* pthis, int64_t* other); +DLL_METHOD void DLL_CALL BU_LongLong_AddV(int64_t* pthis, uint32_t left, uint32_t right); +#pragma comment(linker, "/EXPORT:BU_LongLong_Add=_BU_LongLong_Add@8") +#pragma comment(linker, "/EXPORT:BU_LongLong_AddV=_BU_LongLong_AddV@12") +DLL_METHOD void DLL_CALL BU_LongLong_Sub(int64_t* pthis, int64_t* other); +DLL_METHOD void DLL_CALL BU_LongLong_SubV(int64_t* pthis, uint32_t left, uint32_t right); +#pragma comment(linker, "/EXPORT:BU_LongLong_Sub=_BU_LongLong_Sub@8") +#pragma comment(linker, "/EXPORT:BU_LongLong_SubV=_BU_LongLong_SubV@12") +DLL_METHOD void DLL_CALL BU_LongLong_Mul(int64_t* pthis, int64_t* other); +DLL_METHOD void DLL_CALL BU_LongLong_MulV(int64_t* pthis, uint32_t left, uint32_t right); +#pragma comment(linker, "/EXPORT:BU_LongLong_Mul=_BU_LongLong_Mul@8") +#pragma comment(linker, "/EXPORT:BU_LongLong_MulV=_BU_LongLong_MulV@12") +DLL_METHOD void DLL_CALL BU_LongLong_Div(int64_t* pthis, int64_t* other); +DLL_METHOD void DLL_CALL BU_LongLong_DivV(int64_t* pthis, uint32_t left, uint32_t right); +#pragma comment(linker, "/EXPORT:BU_LongLong_Div=_BU_LongLong_Div@8") +#pragma comment(linker, "/EXPORT:BU_LongLong_DivV=_BU_LongLong_DivV@12") +#pragma endregion Math + +#pragma region Comparison +DLL_METHOD uint32_t DLL_CALL BU_LongLong_Compare(int64_t* pthis, int64_t* other); +DLL_METHOD uint32_t DLL_CALL BU_LongLong_CompareV(int64_t* pthis, uint32_t left, uint32_t right); +#pragma comment(linker, "/EXPORT:BU_LongLong_Compare=_BU_LongLong_Compare@8") +#pragma comment(linker, "/EXPORT:BU_LongLong_CompareV=_BU_LongLong_CompareV@12") +#pragma endregion Comparison + + +#pragma region Conversion +DLL_METHOD const char* DLL_CALL BU_LongLong_ToString(int64_t* pthis); +DLL_METHOD int64_t* DLL_CALL BU_LongLong_FromString(const char* text); +#pragma comment(linker, "/EXPORT:BU_LongLong_ToString=_BU_LongLong_ToString@4") +#pragma comment(linker, "/EXPORT:BU_LongLong_FromString=_BU_LongLong_FromString@4") +DLL_METHOD int32_t DLL_CALL BU_LongLong_ToLong(int64_t* pthis, int32_t _modulus); +DLL_METHOD int64_t* DLL_CALL BU_LongLong_FromLong(int32_t left, int32_t right); +#pragma comment(linker, "/EXPORT:BU_LongLong_ToLong=_BU_LongLong_ToLong@8") +#pragma comment(linker, "/EXPORT:BU_LongLong_FromLong=_BU_LongLong_FromLong@8") +DLL_METHOD int32_t DLL_CALL BU_LongLong_ToLongHigh(int64_t* pthis); +DLL_METHOD int32_t DLL_CALL BU_LongLong_ToLongLow(int64_t* pthis); +#pragma comment(linker, "/EXPORT:BU_LongLong_ToLongHigh=_BU_LongLong_ToLongHigh@4") +#pragma comment(linker, "/EXPORT:BU_LongLong_ToLongLow=_BU_LongLong_ToLongLow@4") +DLL_METHOD float_t DLL_CALL BU_LongLong_ToFloat(int64_t* pthis); +DLL_METHOD int64_t* DLL_CALL BU_LongLong_FromFloat(float_t other); +#pragma comment(linker, "/EXPORT:BU_LongLong_ToFloat=_BU_LongLong_ToFloat@4") +#pragma comment(linker, "/EXPORT:BU_LongLong_FromFloat=_BU_LongLong_FromFloat@4") +DLL_METHOD double_t* DLL_CALL BU_LongLong_ToDouble(int64_t* pthis); +DLL_METHOD int64_t* DLL_CALL BU_LongLong_FromDouble(double_t* pthis); +#pragma comment(linker, "/EXPORT:BU_LongLong_ToDouble=_BU_LongLong_ToDouble@4") +#pragma comment(linker, "/EXPORT:BU_LongLong_FromDouble=_BU_LongLong_FromDouble@4") +#pragma endregion Conversion + +#pragma region Serialization +DLL_METHOD const char* DLL_CALL BU_LongLong_Serialize(int64_t* pthis); +DLL_METHOD int64_t* DLL_CALL BU_LongLong_Deserialize(const char* text); +#pragma comment(linker, "/EXPORT:BU_LongLong_Serialize=_BU_LongLong_Serialize@4") +#pragma comment(linker, "/EXPORT:BU_LongLong_Deserialize=_BU_LongLong_Deserialize@4") +#pragma endregion Serialization diff --git a/Utility/DisplayEnumerator.cpp b/Utility/DisplayEnumerator.cpp new file mode 100644 index 0000000..aa345ab --- /dev/null +++ b/Utility/DisplayEnumerator.cpp @@ -0,0 +1,55 @@ +// BlitzUtility - Expanding the normal Blitz functionality. +// Copyright (C) 2015 Project Kube (Michael Fabian Dirks) +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program. If not, see . + +#include "DisplayEnumerator.h" + +BOOL CALLBACK BU_DisplayEnumerator_Callback(HMONITOR hMonitor, HDC hdcMonitor, LPRECT lprcMonitor, LPARAM dwData) { + DisplayEnumerator* displayEnumerator = (DisplayEnumerator*)dwData; + + displayEnumerator->displays.push_back(RECT(*lprcMonitor)); + return TRUE; +} + +DLL_METHOD DisplayEnumerator* DLL_CALL BU_DisplayEnumerator_Create() { + DisplayEnumerator* displayEnumerator = new DisplayEnumerator(); + return displayEnumerator; +} + +DLL_METHOD void DLL_CALL BU_DisplayEnumerator_Destroy(DisplayEnumerator* displayEnumerator) { + delete displayEnumerator; +} + +DLL_METHOD uint32_t DLL_CALL BU_DisplayEnumerator_Enumerate(DisplayEnumerator* displayEnumerator) { + EnumDisplayMonitors(NULL, NULL, BU_DisplayEnumerator_Callback, (LPARAM)displayEnumerator); + + return displayEnumerator->displays.size(); +} + +DLL_METHOD uint32_t DLL_CALL BU_DisplayEnumerator_Count(DisplayEnumerator* displayEnumerator) { + return displayEnumerator->displays.size(); +} + +DLL_METHOD void DLL_CALL BU_DisplayEnumerator_Retrieve(DisplayEnumerator* displayEnumerator, uint32_t index, PRECT display) { + // Retrieve the requested index. + auto iterator = displayEnumerator->displays.begin(); + std::advance(iterator, index); + + // Copy data. + display->left = iterator->left; + display->top = iterator->top; + display->right = iterator->right; + display->bottom = iterator->bottom; +} \ No newline at end of file diff --git a/Utility/DisplayEnumerator.h b/Utility/DisplayEnumerator.h new file mode 100644 index 0000000..01f6c5d --- /dev/null +++ b/Utility/DisplayEnumerator.h @@ -0,0 +1,38 @@ +// BlitzUtility - Expanding the normal Blitz functionality. +// Copyright (C) 2015 Project Kube (Michael Fabian Dirks) +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program. If not, see . + +#pragma once +#include "dllmain.h" +#include + +struct DisplayEnumerator { + std::list displays; +}; + +// Internal Callback +BOOL CALLBACK BU_DisplayEnumerator_Callback(HMONITOR hMonitor, HDC hdcMonitor, LPRECT lprcMonitor, LPARAM dwData); + +// Exported functions. +DLL_METHOD DisplayEnumerator* DLL_CALL BU_DisplayEnumerator_Create(); +#pragma comment(linker, "/EXPORT:BU_DisplayEnumerator_Create=_BU_DisplayEnumerator_Create@0") +DLL_METHOD void DLL_CALL BU_DisplayEnumerator_Destroy(DisplayEnumerator* displayEnumerator); +#pragma comment(linker, "/EXPORT:BU_DisplayEnumerator_Destroy=_BU_DisplayEnumerator_Destroy@4") +DLL_METHOD uint32_t DLL_CALL BU_DisplayEnumerator_Enumerate(DisplayEnumerator* displayEnumerator); +#pragma comment(linker, "/EXPORT:BU_DisplayEnumerator_Enumerate=_BU_DisplayEnumerator_Enumerate@4") +DLL_METHOD uint32_t DLL_CALL BU_DisplayEnumerator_Count(DisplayEnumerator* displayEnumerator); +#pragma comment(linker, "/EXPORT:BU_DisplayEnumerator_Count=_BU_DisplayEnumerator_Count@4") +DLL_METHOD void DLL_CALL BU_DisplayEnumerator_Retrieve(DisplayEnumerator* displayEnumerator, uint32_t index, LPRECT display); +#pragma comment(linker, "/EXPORT:BU_DisplayEnumerator_Retrieve=_BU_DisplayEnumerator_Retrieve@12") diff --git a/Utility/MassOp.cpp b/Utility/MassOp.cpp new file mode 100644 index 0000000..f3bddd7 --- /dev/null +++ b/Utility/MassOp.cpp @@ -0,0 +1,200 @@ +// Blitz - Steam wrapper for Blitz. +// Copyright (C) 2015 Project Kube (Michael Fabian Dirks) +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program. If not, see . + +#pragma once +#include "dllmain.h" +#include "MassOp.h" + +MassOp::MassOp(uint32_t length) : length(length) { + this->instructions = new MassOpInstruction[length]; +} + +MassOp::~MassOp() { + delete this->instructions; +} + +DLL_METHOD MassOp* DLL_CALL BU_MassOp_Create(uint32_t length) { + MassOp* myMassOp = new MassOp(length); + return myMassOp; +} + +DLL_METHOD void DLL_CALL BU_MassOp_Destroy(MassOp* massop) { + delete massop; +} + +DLL_METHOD void DLL_CALL BU_MassOp_Instruction(MassOp* massop, uint32_t index, MassOpType type, MassOpCode code, intptr_t leftOperand, intptr_t rightOperand, intptr_t result) { + massop->instructions[index].type = type; + massop->instructions[index].code = code; + massop->instructions[index].leftOperand = leftOperand; + massop->instructions[index].rightOperand = rightOperand; + massop->instructions[index].result = result; +} + +DLL_METHOD void DLL_CALL BU_MassOp_Run(MassOp* massop) { + for (uint32_t index = 0; index < massop->length; index++) { + MassOpInstruction* instr = &massop->instructions[index]; + switch (instr->code) { + case GoTo: + index = instr->leftOperand; + break; + case SetOpCode: + massop->instructions[instr->leftOperand].code = instr->rightOperand; + break; + case CopyLeft: + if (instr->leftOperand != instr->rightOperand) { + switch (instr->result) { + case 0: + massop->instructions[instr->rightOperand].leftOperand = massop->instructions[instr->leftOperand].leftOperand; + break; + case 1: + massop->instructions[instr->rightOperand].rightOperand = massop->instructions[instr->leftOperand].leftOperand; + break; + case 2: + massop->instructions[instr->rightOperand].result = massop->instructions[instr->leftOperand].leftOperand; + break; + } + } + break; + case CopyRight: + if (instr->leftOperand != instr->rightOperand) { + switch (instr->result) { + case 0: + massop->instructions[instr->rightOperand].leftOperand = massop->instructions[instr->leftOperand].rightOperand; + break; + case 1: + massop->instructions[instr->rightOperand].rightOperand = massop->instructions[instr->leftOperand].rightOperand; + break; + case 2: + massop->instructions[instr->rightOperand].result = massop->instructions[instr->leftOperand].rightOperand; + break; + } + } + break; + case CopyOut: + if (instr->leftOperand != instr->rightOperand) { + switch (instr->result) { + case 0: + massop->instructions[instr->rightOperand].leftOperand = massop->instructions[instr->leftOperand].result; + break; + case 1: + massop->instructions[instr->rightOperand].rightOperand = massop->instructions[instr->leftOperand].result; + break; + case 2: + massop->instructions[instr->rightOperand].result = massop->instructions[instr->leftOperand].result; + break; + } + } + break; + case If: + if (instr->leftOperand != instr->rightOperand) { + if (massop->instructions[instr->leftOperand].result == massop->instructions[instr->rightOperand].result) { + index += instr->result; + } + } + break; + case IfValue: + if (instr->leftOperand != instr->rightOperand) { + if (massop->instructions[instr->rightOperand].result == instr->rightOperand) { + index += instr->result; + } + } + break; + default: + switch (instr->type) { + case Double: + switch (instr->code) { + case Create: + instr->result = (uint32_t)BU_Double_Create(); + break; + case Destroy: + BU_Double_Destroy((double_t*)instr->leftOperand); + break; + case Copy: + instr->result = (uint32_t)BU_Double_Copy((double_t*)instr->leftOperand); + break; + case TempCreate: + instr->result = (uint32_t)BU_Double_TempCreate(); + break; + case TempCopy: + instr->result = (uint32_t)BU_Double_TempCopy((double_t*)instr->leftOperand); + break; + case TempCleanup: + BU_Double_TempCleanup(); + break; + case Set: + BU_Double_Set((double_t*)instr->leftOperand, (double_t*)instr->rightOperand); + break; + case Add: + BU_Double_Add((double_t*)instr->leftOperand, (double_t*)instr->rightOperand); + break; + case Sub: + BU_Double_Sub((double_t*)instr->leftOperand, (double_t*)instr->rightOperand); + break; + case Mul: + BU_Double_Mul((double_t*)instr->leftOperand, (double_t*)instr->rightOperand); + break; + case Div: + BU_Double_Div((double_t*)instr->leftOperand, (double_t*)instr->rightOperand); + break; + case Compare: + instr->result = BU_Double_Compare((double_t*)instr->leftOperand, (double_t*)instr->rightOperand); + break; + } + break; + case LongLong: + switch (instr->code) { + case Create: + instr->result = (uint32_t)BU_LongLong_Create(); + break; + case Destroy: + BU_LongLong_Destroy((int64_t*)instr->leftOperand); + break; + case Copy: + instr->result = (uint32_t)BU_LongLong_Copy((int64_t*)instr->leftOperand); + break; + case TempCreate: + instr->result = (uint32_t)BU_LongLong_TempCreate(); + break; + case TempCopy: + instr->result = (uint32_t)BU_LongLong_TempCopy((int64_t*)instr->leftOperand); + break; + case TempCleanup: + BU_LongLong_TempCleanup(); + break; + case Set: + BU_LongLong_Set((int64_t*)instr->leftOperand, (int64_t*)instr->rightOperand); + break; + case Add: + BU_LongLong_Add((int64_t*)instr->leftOperand, (int64_t*)instr->rightOperand); + break; + case Sub: + BU_LongLong_Sub((int64_t*)instr->leftOperand, (int64_t*)instr->rightOperand); + break; + case Mul: + BU_LongLong_Mul((int64_t*)instr->leftOperand, (int64_t*)instr->rightOperand); + break; + case Div: + BU_LongLong_Div((int64_t*)instr->leftOperand, (int64_t*)instr->rightOperand); + break; + case Compare: + instr->result = BU_LongLong_Compare((int64_t*)instr->leftOperand, (int64_t*)instr->rightOperand); + break; + } + break; + } + } + } +} diff --git a/Utility/MassOp.h b/Utility/MassOp.h new file mode 100644 index 0000000..8b96c40 --- /dev/null +++ b/Utility/MassOp.h @@ -0,0 +1,108 @@ +// Blitz - Steam wrapper for Blitz. +// Copyright (C) 2015 Project Kube (Michael Fabian Dirks) +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Lesser General Public License as +// published by the Free Software Foundation, either version 3 of the +// License, or (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this program. If not, see . + +#pragma once +#include "dllmain.h" +#include "Type\Double.h" +#include "Type\LongLong.h" + +enum MassOpType { + LongLong = 0, + Double = 1, + + Vector2 = 10, + Vector3 = 11, +}; + +enum MassOpCode { + Create = 0, + Destroy = 1, + Copy = 2, + TempCreate = 5, + TempCopy = 6, + TempCleanup = 7, + + Set = 10, + Add = 11, + Sub = 12, + Mul = 13, + Div = 14, + Compare = 15, + + // Special OPCodes (Control MassOp) + // Goto - Go to a specific intruction + // oper_l = target massop index + GoTo = 249, + // SetOpCode - Change OpCode at position + // oper_l = target massop index + // oper_r = new OpCode + SetOpCode = 250, + // CopyLeft - Copy oper_l to new MassOp instruction. + // oper_l = source massop index + // oper_r = target massop index + // out = target position (0/oper_l, 1/oper_r, 2/out) + CopyLeft = 251, + // CopyRight - Copy oper_r to new MassOp instruction. + // oper_l = source massop index + // oper_r = target massop index + // out = target position (0/oper_l, 1/oper_r, 2/out) + CopyRight = 252, + // CopyOut - Copy out to new MassOp instruction. + // oper_l = source massop index + // oper_r = target massop index + // out = target position (0/oper_l, 1/oper_r, 2/out) + CopyOut = 253, + // If - If the result of index oper_l is equal to index oper_r, skip out instructions. + // oper_l = source massop index + // oper_r = target massop index + // out = instructions to skip + If = 254, + // IfValue - If the result of index oper_l is equal to oper_r, skip out instructions. + // oper_l = source massop index + // oper_r = value to compare with + // out = instructions to skip + IfValue = 255 +}; + +struct BlitzBank { + uint32_t identifier; + uint32_t address; + uint32_t size; +}; + +struct MassOpInstruction { + uint8_t type; + uint8_t code; + uint32_t leftOperand, rightOperand; + uint32_t result; +}; + +struct MassOp { + MassOp(uint32_t length); + ~MassOp(); + + uint32_t length; + MassOpInstruction* instructions; +}; + +DLL_METHOD MassOp* DLL_CALL BU_MassOp_Create(uint32_t length); +#pragma comment(linker, "/EXPORT:BU_MassOp_Create=_BU_MassOp_Create@4") +DLL_METHOD void DLL_CALL BU_MassOp_Destroy(MassOp* massop); +#pragma comment(linker, "/EXPORT:BU_MassOp_Destroy=_BU_MassOp_Destroy@4") +DLL_METHOD void DLL_CALL BU_MassOp_Instruction(MassOp* massop, uint32_t index, MassOpType type, MassOpCode code, intptr_t leftOperand, intptr_t rightOperand, intptr_t result); +#pragma comment(linker, "/EXPORT:BU_MassOp_Instruction=_BU_MassOp_Instruction@28") +DLL_METHOD void DLL_CALL BU_MassOp_Run(MassOp* massop); +#pragma comment(linker, "/EXPORT:BU_MassOp_Run=_BU_MassOp_Run@4") \ No newline at end of file