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

More preparations. Also add a README.md

Browse Source
This commit is contained in:
Michael Dirks
2015-06-20 15:54:29 +02:00
parent 7a96afeda7
commit 7b3c7cc8f6
18 changed files with 2487 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Container/List.cpp
+273
View File
@@ -0,0 +1,273 @@
// BlitzUtility - Expanding the normal Blitz functionality.
// Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#pragma once
#include "List.h"
DLL_METHOD List* DLL_CALL BU_List_Create(BBTypeElement* element) {
// Make sure the given element is valid.
if (element == NULL)
return NULL;
element = (BBTypeElement*)((uint32_t*)element - 5);
// Create our List.
List* myList = new List;
myList->originalType = element->type;
// Create a fake base Type by copying data.
myList->fakeType = new BBType;
myList->fakeType->fieldCount = myList->originalType->fieldCount;
myList->fakeType->free.type = myList->originalType->free.type;
myList->fakeType->free.refCount = myList->originalType->free.refCount;
myList->fakeType->free.fields = myList->originalType->free.fields;
myList->fakeType->free.next = (BBTypeElement*)&myList->fakeType->free;
myList->fakeType->free.prev = (BBTypeElement*)&myList->fakeType->free;
myList->fakeType->used.type = myList->originalType->used.type;
myList->fakeType->used.refCount = myList->originalType->used.refCount;
myList->fakeType->used.fields = myList->originalType->used.fields;
myList->fakeType->used.prev = (BBTypeElement*)&myList->fakeType->used;
myList->fakeType->used.next = (BBTypeElement*)&myList->fakeType->used;
// Remove element from original flow.
element->prev->next = element->next;
element->next->prev = element->prev;
element->prev = NULL;
element->next = NULL;
element->type = myList->fakeType;
// Store the element for later use;
myList->storageElement = element;
myList->storageElementFields = element->fields;
return myList;
}
DLL_METHOD void DLL_CALL BU_List_Destroy(List* list) {
if (list == NULL)
return;
// Append remaining elements to original type.
BBTypeElement *thisEl = NULL;
for (thisEl = list->fakeType->used.next; thisEl != (BBTypeElement*)&list->fakeType->used; thisEl = list->fakeType->used.next) {
// Remove from fakeType's flow.
thisEl->prev->next = thisEl->next;
thisEl->next->prev = thisEl->prev;
// Append to originalType's flow.
thisEl->prev = list->originalType->used.prev;
thisEl->prev->next = thisEl;
thisEl->next = (BBTypeElement*)&list->originalType->used;
thisEl->next->prev = thisEl;
}
for (thisEl = list->fakeType->free.next; thisEl != (BBTypeElement*)&list->fakeType->free; thisEl = list->fakeType->free.next) {
// Remove from fakeType's flow.
thisEl->prev->next = thisEl->next;
thisEl->next->prev = thisEl->prev;
// Append to originalType's flow.
thisEl->prev = list->originalType->free.prev;
thisEl->prev->next = thisEl;
thisEl->next = (BBTypeElement*)&list->originalType->free;
thisEl->next->prev = thisEl;
}
// Append storageElement to original type.
thisEl = list->storageElement;
thisEl->prev = list->originalType->used.prev;
thisEl->prev->next = thisEl;
thisEl->next = (BBTypeElement*)&list->originalType->used;
thisEl->next->prev = thisEl;
thisEl->type = list->originalType;
thisEl->fields = list->storageElementFields;
// Delete custom objects.
delete list->fakeType;
delete list;
}
DLL_METHOD uint32_t DLL_CALL BU_List_First(List* list) {
if (list == NULL)
return FALSE;
BBTypeElement* element = list->fakeType->used.next;
if (element == (BBTypeElement*)&list->fakeType->used)
return FALSE; // End of List.
// Copy data from selected element.
list->storageElement->fields = element->fields;
// Make deletion easier
list->storageElement->next = element;
list->storageElement->prev = element;
return TRUE;
}
DLL_METHOD uint32_t DLL_CALL BU_List_Last(List* list) {
if (list == NULL)
return FALSE;
BBTypeElement* element = list->fakeType->used.prev;
if (element == (BBTypeElement*)&list->fakeType->used)
return FALSE; // End of List.
// Copy data from selected element.
list->storageElement->fields = element->fields;
// Make deletion easier
list->storageElement->next = element;
list->storageElement->prev = element;
return TRUE;
}
DLL_METHOD uint32_t DLL_CALL BU_List_Previous(List* list) {
if (list == NULL)
return FALSE;
BBTypeElement* element = list->storageElement->prev->prev;
if (element == (BBTypeElement*)&list->fakeType->used)
return FALSE; // End of List.
// Copy data from selected element.
list->storageElement->fields = element->fields;
// Make deletion easier
list->storageElement->next = element;
list->storageElement->prev = element;
return TRUE;
}
DLL_METHOD uint32_t DLL_CALL BU_List_Next(List* list) {
if (list == NULL)
return FALSE;
BBTypeElement* element = list->storageElement->next->next;
if (element == (BBTypeElement*)&list->fakeType->used)
return FALSE; // End of List.
// Copy data from selected element.
list->storageElement->fields = element->fields;
// Make deletion easier
list->storageElement->next = element;
list->storageElement->prev = element;
return TRUE;
}
DLL_METHOD uint32_t DLL_CALL BU_List_Before(List* list, BBTypeElement* other) {
if (list == NULL)
return FALSE;
if (other == NULL)
return FALSE;
other = (BBTypeElement*)((uint32_t*)other - 5);
if (other->type != list->fakeType)
return FALSE;
BBTypeElement* element = other->prev;
if (element == (BBTypeElement*)&list->fakeType->used)
return FALSE; // End of List.
// Copy data from selected element.
list->storageElement->fields = element->fields;
// Make deletion easier
list->storageElement->next = element;
list->storageElement->prev = element;
return TRUE;
}
DLL_METHOD uint32_t DLL_CALL BU_List_After(List* list, BBTypeElement* other) {
if (list == NULL)
return FALSE;
if (other == NULL)
return FALSE;
other = (BBTypeElement*)((uint32_t*)other - 5);
if (other->type != list->fakeType)
return FALSE;
BBTypeElement* element = other->next;
if (element == (BBTypeElement*)&list->fakeType->used)
return FALSE; // End of List.
// Copy data from selected element.
list->storageElement->fields = element->fields;
// Make deletion easier
list->storageElement->next = element;
list->storageElement->prev = element;
return TRUE;
}
DLL_METHOD void DLL_CALL BU_List_Insert(List* list, BBTypeElement* element) {
BU_List_InsertEx(list, element, NULL);
}
DLL_METHOD void DLL_CALL BU_List_InsertEx(List* list, BBTypeElement* element, BBTypeElement* other) {
if (list == NULL)
return;
// Make sure element is a valid pointer.
if (element == NULL)
return;
element = (BBTypeElement*)((uint32_t*)element - 5);
if (element->type != list->originalType)
return; // Can't add elements from other types, could cause serious issues.
// Make sure other is a valid pointer.
if (other == NULL) {
other = (BBTypeElement*)&list->fakeType->used;
} else {
other = (BBTypeElement*)((uint32_t*)other - 5);
// Other element must be of the same fakeType.
if (other->type != list->fakeType)
return;
}
// Insert the element after(!) the other element.
element->prev = other->prev;
element->next = other;
element->prev->next = element;
element->next->prev = element;
element->type = list->fakeType;
}
DLL_METHOD void DLL_CALL BU_List_Remove(List* list, BBTypeElement* element) {
if (list == NULL)
return;
if (element == NULL)
return;
element = (BBTypeElement*)((uint32_t*)element - 5);
if (element->type != list->fakeType)
return; // Can't remove elements from another type.
element->type = list->originalType;
element->prev = list->originalType->used.prev;
element->next = (BBTypeElement*)&list->originalType->used;
list->originalType->used.prev->next = element;
list->originalType->used.prev = element;
}
Container/List.h
+85
View File
@@ -0,0 +1,85 @@
// BlitzUtility - Expanding the normal Blitz functionality.
// Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#pragma once
#include "dllmain.h"
// Reverse engineered from https://github.com/blitz-research/blitz3d/blob/master/compiler/declnode.cpp
enum BBVarType {
Global = 0,
Int = 1,
Float = 2,
String = 4,
Type = 5,
Array = 6
};
// Basic Blitz Variable
struct BBVar {
uint32_t type;
uint32_t value;
};
// Basic Type predefinition.
struct BBType;
// Basic Type Element
struct BBTypeElement {
uint32_t* fields;
BBTypeElement* next;
BBTypeElement* prev;
BBType* type;
unsigned int refCount;
};
// Basic Type
struct BBType {
uint32_t type;
BBTypeElement used, free;
uint32_t fieldCount;
};
// List struct.
struct List {
BBType* originalType;
BBType* fakeType;
BBTypeElement* storageElement;
uint32_t* storageElementFields;
};
DLL_METHOD List* DLL_CALL BU_List_Create(BBTypeElement* element);
#pragma comment(linker, "/EXPORT:BU_List_Create=_BU_List_Create@4")
DLL_METHOD void DLL_CALL BU_List_Destroy(List* list);
#pragma comment(linker, "/EXPORT:BU_List_Destroy=_BU_List_Destroy@4")
DLL_METHOD uint32_t DLL_CALL BU_List_First(List* list);
#pragma comment(linker, "/EXPORT:BU_List_First=_BU_List_First@4")
DLL_METHOD uint32_t DLL_CALL BU_List_Last(List* list);
#pragma comment(linker, "/EXPORT:BU_List_Last=_BU_List_Last@4")
DLL_METHOD uint32_t DLL_CALL BU_List_Previous(List* list);
#pragma comment(linker, "/EXPORT:BU_List_Previous=_BU_List_Previous@4")
DLL_METHOD uint32_t DLL_CALL BU_List_Next(List* list);
#pragma comment(linker, "/EXPORT:BU_List_Next=_BU_List_Next@4")
DLL_METHOD uint32_t DLL_CALL BU_List_Before(List* list, BBTypeElement* other);
#pragma comment(linker, "/EXPORT:BU_List_Before=_BU_List_Before@8")
DLL_METHOD uint32_t DLL_CALL BU_List_After(List* list, BBTypeElement* other);
#pragma comment(linker, "/EXPORT:BU_List_After=_BU_List_After@8")
DLL_METHOD void DLL_CALL BU_List_Insert(List* list, BBTypeElement* element);
#pragma comment(linker, "/EXPORT:BU_List_Insert=_BU_List_Insert@8")
DLL_METHOD void DLL_CALL BU_List_InsertEx(List* list, BBTypeElement* element, BBTypeElement* other);
#pragma comment(linker, "/EXPORT:BU_List_InsertEx=_BU_List_InsertEx@12")
DLL_METHOD void DLL_CALL BU_List_Remove(List* list, BBTypeElement* element);
#pragma comment(linker, "/EXPORT:BU_List_Remove=_BU_List_Remove@8")
Container/TypeList.cpp
+76
View File
@@ -0,0 +1,76 @@
// BlitzUtility - Expanding the normal Blitz functionality.
// Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#pragma once;
#include "TypeList.h"
DLL_METHOD TypeList* DLL_CALL BU_TypeList_Create(BBTypeElement* element) {
// Make sure the given element is valid.
if (element == NULL)
return NULL;
element = (BBTypeElement*)(((uint32_t*)element) - 5);
// Create our TypeList.
TypeList* list = new TypeList();
list->type = element->type;
list->firstElement = element;
list->lastElement = element;
// Remove the given element from the flow of the type.
element->prev->next = element->next;
element->next->prev = element->prev;
element->prev = (BBTypeElement*)&list->type->used;
element->next = (BBTypeElement*)&list->type->used;
// Return the list.
return list;
}
DLL_METHOD void DLL_CALL BU_TypeList_Destroy(TypeList* list) {
// Make sure we have a valid list.
if (list == NULL)
return;
// Append elements to the original type.
list->firstElement->prev = list->type->used.prev;
list->firstElement->prev->next = list->firstElement;
list->lastElement->next = (BBTypeElement*)&list->type->used;
list->lastElement->next->prev = list->lastElement;
// Free our TypeList.
delete list;
}
DLL_METHOD void DLL_CALL BU_TypeList_Activate(TypeList* list) {
// Store current pointers
list->storedFirstElement = list->type->used.next;
list->storedLastElement = list->type->used.prev;
// ... and replace them.
list->type->used.next = list->firstElement;
list->type->used.prev = list->lastElement;
}
DLL_METHOD void DLL_CALL BU_TypeList_Deactivate(TypeList* list) {
// Store current pointers
list->firstElement = list->type->used.next;
list->lastElement = list->type->used.prev;
// ... and replace them.
list->type->used.next = list->storedFirstElement;
list->type->used.prev = list->storedLastElement;
}
Container/TypeList.h
+36
View File
@@ -0,0 +1,36 @@
// BlitzUtility - Expanding the normal Blitz functionality.
// Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#pragma once
#include "dllmain.h"
#include "List.h"
#include <list>
struct TypeList {
BBType *type;
BBTypeElement *storedFirstElement, *storedLastElement;
BBTypeElement *firstElement, *lastElement;
};
DLL_METHOD TypeList* DLL_CALL BU_TypeList_Create(BBTypeElement* element);
#pragma comment(linker, "/EXPORT:BU_TypeList_Create=_BU_TypeList_Create@4")
DLL_METHOD void DLL_CALL BU_TypeList_Destroy(TypeList* list);
#pragma comment(linker, "/EXPORT:BU_TypeList_Destroy=_BU_TypeList_Destroy@4")
DLL_METHOD void DLL_CALL BU_TypeList_Activate(TypeList* list);
#pragma comment(linker, "/EXPORT:BU_TypeList_Activate=_BU_TypeList_Activate@4")
DLL_METHOD void DLL_CALL BU_TypeList_Deactivate(TypeList* list);
#pragma comment(linker, "/EXPORT:BU_TypeList_Deactivate=_BU_TypeList_Deactivate@4")
README.md
+173
View File
@@ -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*)
Type/BVector3.cpp
+374
View File
@@ -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 <http://www.gnu.org/licenses/>.
/*
#include "Vector3.h"
void Vector3::set(const float &o)
{
this->X = o;
this->Y = o;
this->Z = o;
}
void Vector3::set(const float &x, const float &y, const float &z)
{
this->X = x;
this->Y = y;
this->Z = z;
}
void Vector3::set(const Vector3 &o)
{
if (this != &o) {
this->X = o.X;
this->Y = o.Y;
this->Z = o.Z;
}
}
void Vector3::add(const float &o)
{
this->X += o;
this->Y += o;
this->Z += o;
}
void Vector3::add(const float &x, const float &y, const float &z)
{
this->X += x;
this->Y += y;
this->Z += z;
}
void Vector3::add(const Vector3 &o)
{
this->X += o.X;
this->Y += o.Y;
this->Z += o.Z;
}
void Vector3::sub(const float &o)
{
this->X -= o;
this->Y -= o;
this->Z -= o;
}
void Vector3::sub(const float &x, const float &y, const float &z)
{
this->X -= x;
this->Y -= y;
this->Z -= z;
}
void Vector3::sub(const Vector3 &o)
{
this->X -= o.X;
this->Y -= o.Y;
this->Z -= o.Z;
}
void Vector3::mul(const float &o)
{
this->X *= o;
this->Y *= o;
this->Z *= o;
}
void Vector3::mul(const float &x, const float &y, const float &z)
{
this->X *= x;
this->Y *= y;
this->Z *= z;
}
void Vector3::mul(const Vector3 &o)
{
this->X *= o.X;
this->Y *= o.Y;
this->Z *= o.Z;
}
void Vector3::div(const float &o)
{
this->X /= o;
this->Y /= o;
this->Z /= o;
}
void Vector3::div(const float &x, const float &y, const float &z)
{
this->X /= x;
this->Y /= y;
this->Z /= z;
}
void Vector3::div(const Vector3 &o)
{
this->X /= o.X;
this->Y /= o.Y;
this->Z /= o.Z;
}
float Vector3::length()
{
return sqrt(this->X * this->X + this->Y * this->Y + this->Z * this->Z);
}
float Vector3::distance(const float &x, const float &y, const float &z)
{
float X = (this->X - x);
float Y = (this->Y - y);
float Z = (this->Z - z);
return sqrt(X * X + Y * Y + Z * Z);
}
float Vector3::distance(const Vector3 &o)
{
float X = (this->X - o.X);
float Y = (this->Y - o.Y);
float Z = (this->Z - o.Z);
return sqrt(X * X + Y * Y + Z * Z);
}
float Vector3::dot(const float &x, const float &y, const float &z)
{
return (this->X * x) + (this->Y * y) + (this->Z * z);
}
float Vector3::dot(const Vector3 &o)
{
return (this->X * o.X) + (this->Y * o.Y) + (this->Z * o.Z);
}
Vector3 Vector3::cross(const float &x, const float &y, const float &z)
{
Vector3* data = new Vector3();
data->X = (this->Y * z) - (this->Z * y);
data->Y = (this->Z * x) - (this->X * z);
data->Z = (this->X * y) - (this->Y * x);
return *data;
}
Vector3 Vector3::cross(const Vector3 &o)
{
Vector3* data = new Vector3();
data->X = (this->Y * o.Z) - (this->Z * o.Y);
data->Y = (this->Z * o.X) - (this->X * o.Z);
data->Z = (this->X * o.Y) - (this->Y * o.X);
return *data;
}
void Vector3::normalize()
{
this->div(this->length());
}
void Vector3::rotate(float &pitch, float &yaw, float &roll)
{
float** matrix = new float*[3];
matrix[0] = new float[3]; matrix[1] = new float[3]; matrix[2] = new float[3];
matrix[0][0] = cos(yaw) * cos(roll); matrix[0][1] = -sin(roll); matrix[0][2] = sin(yaw);
matrix[1][0] = sin(roll); matrix[1][1] = cos(pitch) * cos(roll); matrix[1][2] = -sin(pitch);
matrix[2][0] = -sin(yaw); matrix[2][1] = sin(pitch); matrix[2][2] = cos(pitch) * cos(yaw);
float X = (this->X * matrix[0][0]) + (this->Y * matrix[0][1]) + (this->Z * matrix[0][2]);
float Y = (this->X * matrix[1][0]) + (this->Y * matrix[1][1]) + (this->Z * matrix[1][2]);
float Z = (this->X * matrix[2][0]) + (this->Y * matrix[2][1]) + (this->Z * matrix[2][2]);
this->X = X; this->Y = Y; this->Z = Z;
}
void Vector3::rotateAround(const float &x, const float &y, const float &z, float &pitch, float &yaw, float &roll)
{
this->sub(x, y, z);
this->rotate(pitch, yaw, roll);
this->add(x, y, z);
}
void Vector3::rotateAround(Vector3 &o, float &pitch, float &yaw, float &roll)
{
this->sub(o);
this->rotate(pitch, yaw, roll);
this->add(o);
}
float Vector3::deltaPitch() {
return (float)(atan(this->X / -this->Y) * (180.0 / M_PI));
}
float Vector3::deltaPitch(const float &x, const float &y, const float &z)
{
return (float)(atan((this->X - x) / (-(this->Y - y))) * (180.0 / M_PI));
}
float Vector3::deltaPitch(Vector3 &o)
{
return (float)(atan((this->X - o.X) / (-(this->Y - o.Y))) * (180.0 / M_PI));
}
float Vector3::deltaYaw() {
return (float)(atan(sqrt((this->X * this->X) + (this->Y * this->Y)) / this->Z) * (180.0 / M_PI));
}
float Vector3::deltaYaw(const float &x, const float &y, const float &z)
{
float X = (this->X - x);
float Y = (this->Y - y);
return (float)(atan(sqrt((X * X) + (Y * Y)) / (this->Z - z)) * (180.0 / M_PI));
}
float Vector3::deltaYaw(Vector3 &o)
{
float X = (this->X - o.X);
float Y = (this->Y - o.Y);
return (float)(atan(sqrt((X * X) + (Y * Y)) / (this->Z - o.Z)) * (180.0 / M_PI));
}
char* Vector3::serialize()
{
char* data = new char[13];
memcpy(data, this->Xc, 4);
memcpy(data + 4, this->Yc, 4);
memcpy(data + 8, this->Zc, 4);
data[12] = 0;
return data;
}
void Vector3::deserialize(char* o)
{
memcpy(o, this->Xc, 4);
memcpy(o + 4, this->Yc, 4);
memcpy(o + 8, this->Zc, 4);
}
DLL_METHOD void Vector3_Set(Vector3* a, float o) {
a->set(o);
}
DLL_METHOD void Vector3_SetP(Vector3* a, float x, float y, float z) {
a->set(x, y, z);
}
DLL_METHOD void Vector3_SetV(Vector3* a, Vector3* b) {
a->set(*b);
}
#pragma comment(linker, "/EXPORT:Vector3_Set=_Vector3_Set@8")
#pragma comment(linker, "/EXPORT:Vector3_SetP=_Vector3_SetP@16")
#pragma comment(linker, "/EXPORT:Vector3_SetV=_Vector3_SetV@8")
DLL_METHOD void Vector3_Add(Vector3* a, float o) {
a->add(o);
}
DLL_METHOD void Vector3_AddP(Vector3* a, float x, float y, float z) {
a->add(x, y, z);
}
DLL_METHOD void Vector3_AddV(Vector3* a, Vector3* b) {
a->add(*b);
}
#pragma comment(linker, "/EXPORT:Vector3_Add=_Vector3_Add@8")
#pragma comment(linker, "/EXPORT:Vector3_AddP=_Vector3_AddP@16")
#pragma comment(linker, "/EXPORT:Vector3_AddV=_Vector3_AddV@8")
DLL_METHOD void Vector3_Sub(Vector3* a, float o) {
a->sub(o);
}
DLL_METHOD void Vector3_SubP(Vector3* a, float x, float y, float z) {
a->sub(x, y, z);
}
DLL_METHOD void Vector3_SubV(Vector3* a, Vector3* b) {
a->sub(*b);
}
#pragma comment(linker, "/EXPORT:Vector3_Sub=_Vector3_Sub@8")
#pragma comment(linker, "/EXPORT:Vector3_SubP=_Vector3_SubP@16")
#pragma comment(linker, "/EXPORT:Vector3_SubV=_Vector3_SubV@8")
DLL_METHOD void Vector3_Mul(Vector3* a, float o) {
a->mul(o);
}
DLL_METHOD void Vector3_MulP(Vector3* a, float x, float y, float z) {
a->mul(x, y, z);
}
DLL_METHOD void Vector3_MulV(Vector3* a, Vector3* b) {
a->mul(*b);
}
#pragma comment(linker, "/EXPORT:Vector3_Mul=_Vector3_Mul@8")
#pragma comment(linker, "/EXPORT:Vector3_MulP=_Vector3_MulP@16")
#pragma comment(linker, "/EXPORT:Vector3_MulV=_Vector3_MulV@8")
DLL_METHOD void Vector3_Div(Vector3* a, float o) {
a->div(o);
}
DLL_METHOD void Vector3_DivP(Vector3* a, float x, float y, float z) {
a->div(x, y, z);
}
DLL_METHOD void Vector3_DivV(Vector3* a, Vector3* b) {
a->div(*b);
}
#pragma comment(linker, "/EXPORT:Vector3_Div=_Vector3_Div@8")
#pragma comment(linker, "/EXPORT:Vector3_DivP=_Vector3_DivP@16")
#pragma comment(linker, "/EXPORT:Vector3_DivV=_Vector3_DivV@8")
DLL_METHOD float Vector3_Length(Vector3* a) {
return (float)a->length();
}
DLL_METHOD float Vector3_DistanceP(Vector3* a, float x, float y, float z) {
return (float)a->distance(x, y, z);
}
DLL_METHOD float Vector3_DistanceV(Vector3* a, Vector3* b) {
return (float)a->distance(*b);
}
#pragma comment(linker, "/EXPORT:Vector3_Length=_Vector3_Length@4")
#pragma comment(linker, "/EXPORT:Vector3_DistanceP=_Vector3_DistanceP@16")
#pragma comment(linker, "/EXPORT:Vector3_DistanceV=_Vector3_DistanceV@8")
DLL_METHOD float Vector3_DotP(Vector3* a, float x, float y, float z) {
return (float)a->dot(x, y, z);
}
DLL_METHOD float Vector3_DotV(Vector3* a, Vector3* b) {
return (float)a->dot(*b);
}
DLL_METHOD void Vector3_CrossP(Vector3* a, float x, float y, float z, Vector3* out) {
Vector3 temp = a->cross(x, y, z);
*out = temp;
}
DLL_METHOD void Vector3_CrossV(Vector3* a, Vector3* b, Vector3* out) {
Vector3 temp = a->cross(*b);
*out = temp;
}
DLL_METHOD void Vector3_Normalize(Vector3* a) {
a->normalize();
}
#pragma comment(linker, "/EXPORT:Vector3_DotP=_Vector3_DotP@16")
#pragma comment(linker, "/EXPORT:Vector3_DotV=_Vector3_DotV@8")
#pragma comment(linker, "/EXPORT:Vector3_CrossP=_Vector3_CrossP@20")
#pragma comment(linker, "/EXPORT:Vector3_CrossV=_Vector3_CrossV@12")
#pragma comment(linker, "/EXPORT:Vector3_Normalize=_Vector3_Normalize@4")
DLL_METHOD void Vector3_Rotate(Vector3* a, float pitch, float yaw, float roll) {
a->rotate(pitch, yaw, roll);
}
DLL_METHOD void Vector3_RotateAroundP(Vector3* a, float x, float y, float z, float pitch, float yaw, float roll) {
a->rotateAround(x, y, z, pitch, yaw, roll);
}
DLL_METHOD void Vector3_RotateAroundV(Vector3* a, Vector3* b, float pitch, float yaw, float roll) {
a->rotateAround(*b, pitch, yaw, roll);
}
#pragma comment(linker, "/EXPORT:Vector3_Rotate=_Vector3_Rotate@16")
#pragma comment(linker, "/EXPORT:Vector3_RotateAroundP=_Vector3_RotateAroundP@28")
#pragma comment(linker, "/EXPORT:Vector3_RotateAroundV=_Vector3_RotateAroundV@20")
DLL_METHOD float Vector3_DeltaPitchP(Vector3* a, float x, float y, float z) {
return (float)a->deltaPitch(x, y, z);
}
DLL_METHOD float Vector3_DeltaPitchV(Vector3* a, Vector3* b) {
return (float)a->deltaPitch(*b);
}
DLL_METHOD float Vector3_DeltaYawP(Vector3* a, float x, float y, float z) {
return (float)a->deltaYaw(x, y, z);
}
DLL_METHOD float Vector3_DeltaYawV(Vector3* a, Vector3* b) {
return (float)a->deltaYaw(*b);
}
#pragma comment(linker, "/EXPORT:Vector3_DeltaPitchP=_Vector3_DeltaPitchP@16")
#pragma comment(linker, "/EXPORT:Vector3_DeltaPitchV=_Vector3_DeltaPitchV@8")
#pragma comment(linker, "/EXPORT:Vector3_DeltaYawP=_Vector3_DeltaYawP@16")
#pragma comment(linker, "/EXPORT:Vector3_DeltaYawV=_Vector3_DeltaYawV@8")
DLL_METHOD char* Vector3_Serialize(Vector3* a) {
return a->serialize();
}
DLL_METHOD void Vector3_Deserialize(Vector3* a, char* s) {
a->deserialize(s);
}
#pragma comment(linker, "/EXPORT:Vector3_Serialize=_Vector3_Serialize@4")
#pragma comment(linker, "/EXPORT:Vector3_Deserialize=_Vector3_Deserialize@8")
*/
Type/BVector3.h
+82
View File
@@ -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 <http://www.gnu.org/licenses/>.
/*
#pragma once
#include "dllmain.h"
#ifndef _USE_MATH_DEFINES
#define _USE_MATH_DEFINES
#include <math.h>
#undef _USE_MATH_DEFINES
#endif
struct Vector3 {
union {
float X;
char Xc[4];
};
union {
float Y;
char Yc[4];
};
union {
float Z;
char Zc[4];
};
void set(const float &o);
void set(const float &x, const float &y, const float &z);
void set(const Vector3 &o);
void add(const float &o);
void add(const float &x, const float &y, const float &z);
void add(const Vector3 &o);
void sub(const float &o);
void sub(const float &x, const float &y, const float &z);
void sub(const Vector3 &o);
void mul(const float &o);
void mul(const float &x, const float &y, const float &z);
void mul(const Vector3 &o);
void div(const float &o);
void div(const float &x, const float &y, const float &z);
void div(const Vector3 &o);
float length();
float distance(const float &x, const float &y, const float &z);
float distance(const Vector3 &o);
float dot(const float &x, const float &y, const float &z);
float dot(const Vector3 &o);
Vector3 cross(const float &x, const float &y, const float &z);
Vector3 cross(const Vector3 &o);
void normalize();
void rotate(float &pitch, float &yaw, float &roll);
void rotateAround(const float &x, const float &y, const float &z, float &pitch, float &yaw, float &roll);
void rotateAround(Vector3 &o, float &pitch, float &yaw, float &roll);
float deltaPitch();
float deltaPitch(const float &x, const float &y, const float &z);
float deltaPitch(Vector3 &o);
float deltaYaw();
float deltaYaw(const float &x, const float &y, const float &z);
float deltaYaw(Vector3 &o);
char* serialize();
void deserialize(char* o);
};*/
Type/BlitzType.h
+132
View File
@@ -0,0 +1,132 @@
#include "Common.h"
#include <memory>
#include <sstream>
// Rev-engineered from https://github.com/blitz-research/blitz3d/blob/master/compiler/declnode.cpp
#define BBVARTYPE_GLOBAL 0
#define BBVARTYPE_INT 1
#define BBVARTYPE_FLOAT 2
#define BBVARTYPE_UNUSED 3
#define BBVARTYPE_STRING 4
#define BBVARTYPE_TYPE 5
#define BBVARTYPE_ARRAY 6
struct BBVar {
int Type = -1;
};
struct BBVarGlobal {
int GlobalType = -1;
int* Value;
};
struct BBVarInt : BBVar {
int Value;
};
struct BBVarFloat : BBVar {
float Value;
};
struct BBVarUnused : BBVar {
// Not a Dim, as you can see here:
// https://github.com/blitz-research/blitz3d/blob/master/compiler/stmtnode.cpp#L86
};
struct BBVarString : BBVar {
int Length;
char* Value;
};
struct BBVarElement;
struct BBVarType : BBVar {
BBVarElement used, free;
int fieldCount; // Field Info follows (Exactly <fieldCount> int pointers to variable struct)
int* fields[];
};
struct BBVarElement {
int* currentPtr; // Points towards fields.
int* nextPtr, prevPtr;
BBVarType* BBStructPtr;
int refCount; // Fields usually follow here, may be at another location, see currentPtr.
//BBVar* fields[];
};
struct BBVarArray : BBVar {
int Size; //???
BBVar* ArrayType;
};
std::string BBVar_Serialize(void* obj) {
std::stringstream myStream;
BBVar* var = (BBVar*)obj;
switch (var->Type) {
case BBVARTYPE_GLOBAL:
BBVarGlobal* varGlobal = (BBVarGlobal*)obj;
myStream << "[Global] " << BBVar_Serialize(varGlobal->Value) << std::endl;
break;
case BBVARTYPE_INT:
BBVarInt* varInt = (BBVarInt*)obj;
myStream << "Int" << std::endl;
break;
case BBVARTYPE_FLOAT:
BBVarFloat* varFloat = (BBVarFloat*)obj;
myStream << "Float" << std::endl;
break;
case BBVARTYPE_UNUSED:
BBVarUnused* varUnused = (BBVarUnused*)obj;
myStream << "Unused" << std::endl;
break;
case BBVARTYPE_STRING:
BBVarString* varString = (BBVarString*)obj;
myStream << "String" << std::endl;
break;
case BBVARTYPE_TYPE:
BBVarType* varType = (BBVarType*)obj;
myStream << BBVarType_Serialize(varType);
break;
case BBVARTYPE_ARRAY:
BBVarArray* varArray = (BBVarArray*)obj;
myStream << "Array = " << std::endl;
break;
}
return myStream.str();
}
std::string BBVarType_Serialize(BBVarType* obj, unsigned int indent = 0) {
std::stringstream myStream;
std::stringstream myPaddingSS;
for (unsigned int pad = 0; pad < indent; pad++) {
myPaddingSS << " ";
}
std::string myPadding = myPaddingSS.str();
myStream << myPadding << "Type {" << std::endl;
for (unsigned int fld = 0; fld < obj->fieldCount; fld++) {
myStream << myPadding << " (" << fld << ") => " << BBVar_Serialize(obj->fields[fld]) << std::endl;
}
myStream << myPadding << "}" << std::endl;
return myStream.str();
}
DLL_EXPORT(char*) SerializeObject(void* obj) {
return strdup(BBVar_Serialize(obj).c_str());
}
// Laut Mark Sibly:
struct BBType {
int obj_size;
BBObj usedList, freeList;
};
struct BBObj {
BBObj *curr;
BBObj *next, *prev;
int* bbtype;
int ref_cnt;
};
Type/Double.cpp
+163
View File
@@ -0,0 +1,163 @@
// Blitz - Steam wrapper for Blitz.
// Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "Double.h"
#include <list>
std::list<double_t*> BU_DoubleTemporary;
DLL_METHOD double_t* DLL_CALL BU_Double_Create() {
return new double_t;
}
DLL_METHOD void DLL_CALL BU_Double_Destroy(double_t* pthis) {
delete pthis;
}
DLL_METHOD double_t* DLL_CALL BU_Double_Copy(double_t* other) {
double_t* pthis = new double_t;
*pthis = *other;
return pthis;
}
DLL_METHOD double_t* DLL_CALL BU_Double_TempCreate() {
double_t* val = new double_t;
BU_DoubleTemporary.push_back(val);
return val;
}
DLL_METHOD double_t* DLL_CALL BU_Double_TempCopy(double_t* other) {
double_t* val = new double_t(*other);
BU_DoubleTemporary.push_back(val);
return val;
}
DLL_METHOD void DLL_CALL BU_Double_SetTemp(double_t* pthis) {
BU_DoubleTemporary.push_back(pthis);
}
DLL_METHOD void DLL_CALL BU_Double_UnsetTemp(double_t* pthis) {
BU_DoubleTemporary.remove(pthis);
}
DLL_METHOD void DLL_CALL BU_Double_TempCleanup() {
auto iterEnd = BU_DoubleTemporary.end();
for (auto iter = BU_DoubleTemporary.begin(); iter != iterEnd; ++iter) {
delete *iter;
}
BU_DoubleTemporary.clear();
}
DLL_METHOD void DLL_CALL BU_Double_Set(double_t* pthis, double_t* other) {
*pthis = *other;
}
DLL_METHOD void DLL_CALL BU_Double_SetF(double_t* pthis, float_t other) {
*pthis = other;
}
DLL_METHOD void DLL_CALL BU_Double_Add(double_t* pthis, double_t* other) {
*pthis += *other;
}
DLL_METHOD void DLL_CALL BU_Double_AddF(double_t* pthis, float_t other) {
*pthis += other;
}
DLL_METHOD void DLL_CALL BU_Double_Sub(double_t* pthis, double_t* other) {
*pthis -= *other;
}
DLL_METHOD void DLL_CALL BU_Double_SubF(double_t* pthis, float_t other) {
*pthis -= other;
}
DLL_METHOD void DLL_CALL BU_Double_Mul(double_t* pthis, double_t* other) {
*pthis *= *other;
}
DLL_METHOD void DLL_CALL BU_Double_MulF(double_t* pthis, float_t other) {
*pthis *= other;
}
DLL_METHOD void DLL_CALL BU_Double_Div(double_t* pthis, double_t* other) {
*pthis /= *other;
}
DLL_METHOD void DLL_CALL BU_Double_DivF(double_t* pthis, float_t other) {
*pthis /= other;
}
DLL_METHOD uint32_t DLL_CALL BU_Double_Compare(double_t* pthis, double_t* other) {
return (*pthis == *other ? 1 : 0) + (*pthis < *other ? 2 : 0) + (*pthis > *other ? 4 : 0);
}
DLL_METHOD uint32_t DLL_CALL BU_Double_CompareF(double_t* pthis, float_t other) {
return ((float_t)*pthis == other ? 1 : 0) + ((float_t)*pthis < other ? 2 : 0) + ((float_t)*pthis > other ? 4 : 0);
}
DLL_METHOD const char* DLL_CALL BU_Double_ToString(double_t* pthis) {
std::stringstream stream;
stream << *pthis;
return stream.str().c_str();
}
DLL_METHOD double_t* DLL_CALL BU_Double_FromString(const char* text) {
std::stringstream stream = std::stringstream(text);
double_t* doublePtr = new double_t;
stream >> *doublePtr;
return doublePtr;
}
DLL_METHOD float_t DLL_CALL BU_Double_ToFloat(double_t* pthis) {
return (float_t)*pthis;
}
DLL_METHOD double_t* DLL_CALL BU_Double_FromFloat(float_t other) {
double_t* val = new double_t;
*val = (double_t)other;
return val;
}
DLL_METHOD int64_t* DLL_CALL BU_Double_ToLongLong(double_t* pthis) {
int64_t* val = new int64_t;
*val = (int64_t)*pthis;
return val;
}
DLL_METHOD double_t* DLL_CALL BU_Double_FromLongLong(int64_t* other) {
double_t* val = new double_t;
*val = (double_t)*other;
return val;
}
DLL_METHOD const char* DLL_CALL BU_Double_Serialize(double_t* pthis) {
union {
double_t real;
int64_t integer;
} myval;
myval.real = *pthis;
return int_to_hex<int64_t>(myval.integer).c_str();
}
DLL_METHOD double_t* DLL_CALL BU_Double_Deserialize(const char* text) {
union {
double_t real;
int64_t integer;
} myval;
myval.integer = hex_to_int<int64_t>(std::string(text));
return BU_Double_Copy(&myval.real);
}
Type/Double.h
+96
View File
@@ -0,0 +1,96 @@
// Blitz - Steam wrapper for Blitz.
// Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#pragma once
#include "dllmain.h"
#include "LongLong.h"
#pragma region Constructor & Destructor
DLL_METHOD double_t* DLL_CALL BU_Double_Create();
DLL_METHOD void DLL_CALL BU_Double_Destroy(double_t* pthis);
DLL_METHOD double_t* DLL_CALL BU_Double_Copy(double_t* other);
#pragma comment(linker, "/EXPORT:BU_Double_Create=_BU_Double_Create@0")
#pragma comment(linker, "/EXPORT:BU_Double_Destroy=_BU_Double_Destroy@4")
#pragma comment(linker, "/EXPORT:BU_Double_Copy=_BU_Double_Copy@4")
#pragma endregion Constructor & Destructor
#pragma region Temporary Objects
DLL_METHOD double_t* DLL_CALL BU_Double_TempCreate();
DLL_METHOD double_t* DLL_CALL BU_Double_TempCopy(double_t* other);
DLL_METHOD void DLL_CALL BU_Double_SetTemp(double_t* pthis);
DLL_METHOD void DLL_CALL BU_Double_UnsetTemp(double_t* pthis);
DLL_METHOD void DLL_CALL BU_Double_TempCleanup();
#pragma comment(linker, "/EXPORT:BU_Double_TempCreate=_BU_Double_TempCreate@0")
#pragma comment(linker, "/EXPORT:BU_Double_TempCopy=_BU_Double_TempCopy@4")
#pragma comment(linker, "/EXPORT:BU_Double_SetTemp=_BU_Double_SetTemp@4")
#pragma comment(linker, "/EXPORT:BU_Double_UnsetTemp=_BU_Double_UnsetTemp@4")
#pragma comment(linker, "/EXPORT:BU_Double_TempCleanup=_BU_Double_TempCleanup@0")
#pragma endregion Temporary Objects
#pragma region Math
DLL_METHOD void DLL_CALL BU_Double_Set(double_t* pthis, double_t* other);
DLL_METHOD void DLL_CALL BU_Double_SetF(double_t* pthis, float_t other);
#pragma comment(linker, "/EXPORT:BU_Double_Set=_BU_Double_Set@8")
#pragma comment(linker, "/EXPORT:BU_Double_SetF=_BU_Double_SetF@8")
DLL_METHOD void DLL_CALL BU_Double_Add(double_t* pthis, double_t* other);
DLL_METHOD void DLL_CALL BU_Double_AddF(double_t* pthis, float_t other);
#pragma comment(linker, "/EXPORT:BU_Double_Add=_BU_Double_Add@8")
#pragma comment(linker, "/EXPORT:BU_Double_AddF=_BU_Double_AddF@8")
DLL_METHOD void DLL_CALL BU_Double_Sub(double_t* pthis, double_t* other);
DLL_METHOD void DLL_CALL BU_Double_SubF(double_t* pthis, float_t other);
#pragma comment(linker, "/EXPORT:BU_Double_Sub=_BU_Double_Sub@8")
#pragma comment(linker, "/EXPORT:BU_Double_SubF=_BU_Double_SubF@8")
DLL_METHOD void DLL_CALL BU_Double_Mul(double_t* pthis, double_t* other);
DLL_METHOD void DLL_CALL BU_Double_MulF(double_t* pthis, float_t other);
#pragma comment(linker, "/EXPORT:BU_Double_Mul=_BU_Double_Mul@8")
#pragma comment(linker, "/EXPORT:BU_Double_MulF=_BU_Double_MulF@8")
DLL_METHOD void DLL_CALL BU_Double_Div(double_t* pthis, double_t* other);
DLL_METHOD void DLL_CALL BU_Double_DivF(double_t* pthis, float_t other);
#pragma comment(linker, "/EXPORT:BU_Double_Div=_BU_Double_Div@8")
#pragma comment(linker, "/EXPORT:BU_Double_DivF=_BU_Double_DivF@8")
#pragma endregion Math
#pragma region Comparision
DLL_METHOD uint32_t DLL_CALL BU_Double_Compare(double_t* pthis, double_t* other);
DLL_METHOD uint32_t DLL_CALL BU_Double_CompareF(double_t* pthis, float_t other);
#pragma comment(linker, "/EXPORT:BU_Double_Compare=_BU_Double_Compare@8")
#pragma comment(linker, "/EXPORT:BU_Double_CompareF=_BU_Double_CompareF@8")
#pragma endregion Comparision
#pragma region Conversion
// String conversion
DLL_METHOD const char* DLL_CALL BU_Double_ToString(double_t* pthis);
DLL_METHOD double_t* DLL_CALL BU_Double_FromString(const char* text);
#pragma comment(linker, "/EXPORT:BU_Double_ToString=_BU_Double_ToString@4")
#pragma comment(linker, "/EXPORT:BU_Double_FromString=_BU_Double_FromString@4")
// 32-Bit Floating Point
DLL_METHOD float_t DLL_CALL BU_Double_ToFloat(double_t* pthis);
DLL_METHOD double_t* DLL_CALL BU_Double_FromFloat(float_t other);
#pragma comment(linker, "/EXPORT:BU_Double_ToFloat=_BU_Double_ToFloat@4")
#pragma comment(linker, "/EXPORT:BU_Double_FromFloat=_BU_Double_FromFloat@4")
// 64-Bit Integer
DLL_METHOD int64_t* DLL_CALL BU_Double_ToLongLong(double_t* pthis);
DLL_METHOD double_t* DLL_CALL BU_Double_FromLongLong(int64_t* other);
#pragma comment(linker, "/EXPORT:BU_Double_ToLongLong=_BU_Double_ToLongLong@4")
#pragma comment(linker, "/EXPORT:BU_Double_FromLongLong=_BU_Double_FromLongLong@4")
#pragma endregion Conversion
#pragma region Serialization
DLL_METHOD const char* DLL_CALL BU_Double_Serialize(double_t* pthis);
DLL_METHOD double_t* DLL_CALL BU_Double_Deserialize(const char* text);
#pragma comment(linker, "/EXPORT:BU_Double_Serialize=_BU_Double_Serialize@4")
#pragma comment(linker, "/EXPORT:BU_Double_Deserialize=_BU_Double_Deserialize@4")
#pragma endregion Serialization
Type/FVector2.cpp
+220
View File
@@ -0,0 +1,220 @@
// BlitzUtility - Expanding the normal Blitz functionality.
// Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
/*
#pragma once
#include "FVector2.h"
double FVector2::length()
{
return std::sqrtf(std::abs((this->X*this->X) + (this->Y*this->Y)));
}
void FVector2::normalize() {
double len = this->length();
double divisor = 1.0 / (len != 0 ? len : FLT_EPSILON);
}
double FVector2::distance(const FVector2 r)
{
float X = (this->X - r.X), Y = (this->Y - r.Y);
return std::sqrtf(std::abs(X*X + Y*Y));
}
const char* FVector2::serialize() {
}
FVector2& FVector2::deserialize(const char* serialized) {
}
FVector2::FVector2(float V) {
}
FVector2::FVector2(float X, float Y) {
}
FVector2::FVector2(FVector2& V) {
}
FVector2& FVector2::operator++() {
}
FVector2& FVector2::operator--() {
}
bool FVector2::operator>(const FVector2& r) {
}
bool FVector2::operator>(const float& r) {
}
bool FVector2::operator<(const FVector2& r) {
}
bool FVector2::operator<(const float& r) {
}
bool FVector2::operator==(const FVector2& r) {
}
bool FVector2::operator==(const float& r) {
}
bool FVector2::operator>=(const FVector2& r) {
}
bool FVector2::operator>=(const float& r) {
}
bool FVector2::operator<=(const FVector2& r) {
}
bool FVector2::operator<=(const float& r) {
}
bool FVector2::operator!=(const FVector2& r) {
}
bool FVector2::operator!=(const float& r) {
}
FVector2& FVector2::operator=(const FVector2& r) {
}
FVector2& FVector2::operator=(const float& r) {
}
FVector2& FVector2::operator+(const FVector2& r) {
}
FVector2& FVector2::operator+(const float& r) {
}
FVector2& FVector2::operator-(const FVector2& r) {
}
FVector2& FVector2::operator*(const FVector2& r) {
}
FVector2& FVector2::operator*(const float& r) {
}
FVector2& FVector2::operator/(const FVector2& r) {
}
FVector2& FVector2::operator/(const float& r) {
}
FVector2& FVector2::operator+=(const FVector2& r) {
}
FVector2& FVector2::operator+=(const float& r) {
}
FVector2& FVector2::operator-=(const FVector2& r) {
}
FVector2& FVector2::operator*=(const FVector2& r) {
}
FVector2& FVector2::operator*=(const float& r) {
}
FVector2& FVector2::operator/=(const FVector2& r) {
}
FVector2& FVector2::operator/=(const float& r) {
}
FVector2& FVector2::operator-(const float& r) {
}
FVector2& FVector2::operator-=(const float& r) {
}
*/
Type/FVector2.h
+98
View File
@@ -0,0 +1,98 @@
// BlitzUtility - Expanding the normal Blitz functionality.
// Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
/*
#pragma once
#include "dllmain.h"
#ifndef _USE_MATH_DEFINES
#define _USE_MATH_DEFINES
#include <math.h>
#undef _USE_MATH_DEFINES
#endif
struct FVector2 {
float X, Y;
// Constructor & Destructor
FVector2(float V);
FVector2(float X, float Y);
FVector2(FVector2& V);
// Operator Overloading
FVector2& operator++();
FVector2& operator--();
bool operator>(const FVector2& r);
bool operator<(const FVector2& r);
bool operator==(const FVector2& r);
bool operator>=(const FVector2& r);
bool operator<=(const FVector2& r);
bool operator!=(const FVector2& r);
FVector2& operator=(const FVector2& r);
FVector2& operator+(const FVector2& r);
FVector2& operator-(const FVector2& r);
FVector2& operator*(const FVector2& r);
FVector2& operator/(const FVector2& r);
FVector2& operator+=(const FVector2& r);
FVector2& operator-=(const FVector2& r);
FVector2& operator*=(const FVector2& r);
FVector2& operator/=(const FVector2& r);
// Operator Overloading - float
bool operator>(const float& r);
bool operator<(const float& r);
bool operator==(const float& r);
bool operator>=(const float& r);
bool operator<=(const float& r);
bool operator!=(const float& r);
FVector2& operator=(const float& r);
FVector2& operator+(const float& r);
FVector2& operator-(const float& r);
FVector2& operator*(const float& r);
FVector2& operator/(const float& r);
FVector2& operator+=(const float& r);
FVector2& operator-=(const float& r);
FVector2& operator*=(const float& r);
FVector2& operator/=(const float& r);
// Simple Math
double length();
void normalize();
double distance(const FVector2 r);
// Advanced Math
void rotate(const double )
// Serialization
const char* serialize();
static FVector2& deserialize(const char* serialized);
};
DLL_METHOD FVector2* DLL_CALL BU_FVector2_Create();
DLL_METHOD FVector2* DLL_CALL BU_FVector2_Copy(FVector2* copyVector);
DLL_METHOD void DLL_CALL BU_FVector2_Destroy();
DLL_METHOD FVector2* DLL_CALL BU_FVector2_TempCreate();
DLL_METHOD FVector2* DLL_CALL BU_FVector2_TempCopy(FVector2* copyVector);
DLL_METHOD void DLL_CALL BU_FVector2_SetTemp(FVector2* vector);
DLL_METHOD void DLL_CALL BU_FVector2_UnsetTemp(FVector2* vector);
DLL_METHOD void DLL_CALL BU_FVector2_TempCleanup();
DLL_METHOD float DLL_CALL BU_FVector2_Length(FVector2* vector);
DLL_METHOD float DLL_CALL BU_FVector2_Normalize();
DLL_METHOD float DLL_CALL BU_FVector2_Distance(FVector2* vector);
DLL_METHOD float DLL_CALL BU_FVector2_DistanceL(float X, float Y);
*/
Type/LongLong.cpp
+174
View File
@@ -0,0 +1,174 @@
// Blitz - Steam wrapper for Blitz.
// Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#pragma once
#include "LongLong.h"
#include <list>
std::list<int64_t*> blitzLLTemporary;
int64_t* DLL_CALL BU_LongLong_Create() {
return new int64_t;
}
void DLL_CALL BU_LongLong_Destroy(int64_t* pthis) {
delete pthis;
}
int64_t* DLL_CALL BU_LongLong_Copy(int64_t* other) {
int64_t* pthis = new int64_t;
*pthis = *other;
return pthis;
}
DLL_METHOD int64_t* DLL_CALL BU_LongLong_TempCreate() {
int64_t* val = new int64_t;
blitzLLTemporary.push_back(val);
return val;
}
DLL_METHOD int64_t* DLL_CALL BU_LongLong_TempCopy(int64_t* other) {
int64_t* val = new int64_t(*other);
blitzLLTemporary.push_back(val);
return val;
}
DLL_METHOD void DLL_CALL BU_LongLong_SetTemp(int64_t* pthis) {
blitzLLTemporary.push_back(pthis);
}
DLL_METHOD void DLL_CALL BU_LongLong_UnsetTemp(int64_t* pthis) {
blitzLLTemporary.remove(pthis);
}
DLL_METHOD void DLL_CALL BU_LongLong_TempCleanup() {
auto iterEnd = blitzLLTemporary.end();
for (auto iter = blitzLLTemporary.begin(); iter != iterEnd; ++iter) {
delete *iter;
}
blitzLLTemporary.clear();
}
void DLL_CALL BU_LongLong_Set(int64_t* pthis, int64_t* other) {
*pthis = *other;
}
void DLL_CALL BU_LongLong_SetV(int64_t* pthis, uint32_t left, uint32_t right) {
*pthis = ((int64_t)left << 32) + right;
}
void DLL_CALL BU_LongLong_Add(int64_t* pthis, int64_t* other) {
*pthis += *other;
}
void DLL_CALL BU_LongLong_AddV(int64_t* pthis, uint32_t left, uint32_t right) {
*pthis += ((int64_t)left << 32) + right;
}
void DLL_CALL BU_LongLong_Sub(int64_t* pthis, int64_t* other) {
*pthis -= *other;
}
void DLL_CALL BU_LongLong_SubV(int64_t* pthis, uint32_t left, uint32_t right) {
*pthis -= ((int64_t)left << 32) + right;
}
void DLL_CALL BU_LongLong_Mul(int64_t* pthis, int64_t* other) {
*pthis *= *other;
}
void DLL_CALL BU_LongLong_MulV(int64_t* pthis, uint32_t left, uint32_t right) {
*pthis *= ((int64_t)left << 32) + right;
}
void DLL_CALL BU_LongLong_Div(int64_t* pthis, int64_t* other) {
*pthis *= *other;
}
void DLL_CALL BU_LongLong_DivV(int64_t* pthis, uint32_t left, uint32_t right) {
*pthis *= ((int64_t)left << 32) + right;
}
uint32_t DLL_CALL BU_LongLong_Compare(int64_t* pthis, int64_t* other) {
return (*pthis == *other ? 1 : 0) + (*pthis < *other ? 2 : 0) + (*pthis > *other ? 4 : 0);
}
uint32_t DLL_CALL BU_LongLong_CompareV(int64_t* pthis, uint32_t left, uint32_t right) {
int64_t other = ((int64_t)left << 32) + right;
return (*pthis == other ? 1 : 0) + (*pthis < other ? 2 : 0) + (*pthis > other ? 4 : 0);
}
const char* DLL_CALL BU_LongLong_ToString(int64_t* pthis) {
std::stringstream stream;
stream << *pthis;
return stream.str().c_str();
}
int64_t* DLL_CALL BU_LongLong_FromString(const char* text) {
std::stringstream stream = std::stringstream(text);
int64_t* val = new int64_t;
stream >> *val;
return val;
}
int32_t DLL_CALL BU_LongLong_ToLong(int64_t* pthis, int32_t _modulus) {
return *pthis % _modulus;
}
int64_t* DLL_CALL BU_LongLong_FromLong(int32_t left, int32_t right) {
int64_t* val = new int64_t;
*val = ((int64_t)left << 32) + right;
return val;
}
int32_t DLL_CALL BU_LongLong_ToLongHigh(int64_t* pthis) {
return (int32_t)((*pthis) >> 32);
}
int32_t DLL_CALL BU_LongLong_ToLongLow(int64_t* pthis) {
return (int32_t)((*pthis) && 0xFFFFFFFF);
}
float_t DLL_CALL BU_LongLong_ToFloat(int64_t* pthis) {
return (float)*pthis;
}
int64_t* DLL_CALL BU_LongLong_FromFloat(float_t other) {
int64_t val = (int64_t)other;
return BU_LongLong_Copy(&val);
}
double_t* DLL_CALL BU_LongLong_ToDouble(int64_t* pthis) {
double_t* val = new double_t;
*val = (double_t)*pthis;
return val;
}
int64_t* DLL_CALL BU_LongLong_FromDouble(double_t* other) {
int64_t* val = new int64_t;
*val = (int64_t)*other;
return val;
}
const char* DLL_CALL BU_LongLong_Serialize(int64_t* pthis) {
return int_to_hex<int64_t>(*pthis).c_str();
}
int64_t* DLL_CALL BU_LongLong_Deserialize(const char* text) {
int64_t val = hex_to_int<int64_t>(std::string(text));
return BU_LongLong_Copy(&val);
}
Type/LongLong.h
+104
View File
@@ -0,0 +1,104 @@
// Blitz - Steam wrapper for Blitz.
// Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#pragma once
#include "dllmain.h"
#include "Double.h"
#include <string>
#include <sstream>
#pragma region Constructor & Destructor
DLL_METHOD int64_t* DLL_CALL BU_LongLong_Create();
DLL_METHOD void DLL_CALL BU_LongLong_Destroy(int64_t* pthis);
DLL_METHOD int64_t* DLL_CALL BU_LongLong_Copy(int64_t* other);
#pragma comment(linker, "/EXPORT:BU_LongLong_Create=_BU_LongLong_Create@0")
#pragma comment(linker, "/EXPORT:BU_LongLong_Destroy=_BU_LongLong_Destroy@4")
#pragma comment(linker, "/EXPORT:BU_LongLong_Copy=_BU_LongLong_Copy@4")
#pragma endregion Constructor & Destructor
#pragma region Temporary Objects
DLL_METHOD int64_t* DLL_CALL BU_LongLong_TempCreate();
DLL_METHOD int64_t* DLL_CALL BU_LongLong_TempCopy(int64_t* other);
DLL_METHOD void DLL_CALL BU_LongLong_SetTemp(int64_t* pthis);
DLL_METHOD void DLL_CALL BU_LongLong_UnsetTemp(int64_t* pthis);
DLL_METHOD void DLL_CALL BU_LongLong_TempCleanup();
#pragma comment(linker, "/EXPORT:BU_LongLong_TempCreate=_BU_LongLong_TempCreate@0")
#pragma comment(linker, "/EXPORT:BU_LongLong_TempCopy=_BU_LongLong_TempCopy@4")
#pragma comment(linker, "/EXPORT:BU_LongLong_SetTemp=_BU_LongLong_SetTemp@4")
#pragma comment(linker, "/EXPORT:BU_LongLong_UnsetTemp=_BU_LongLong_UnsetTemp@4")
#pragma comment(linker, "/EXPORT:BU_LongLong_TempCleanup=_BU_LongLong_TempCleanup@0")
#pragma endregion Temporary Objects
#pragma region Math
DLL_METHOD void DLL_CALL BU_LongLong_Set(int64_t* pthis, int64_t* other);
DLL_METHOD void DLL_CALL BU_LongLong_SetV(int64_t* pthis, uint32_t left, uint32_t right);
#pragma comment(linker, "/EXPORT:BU_LongLong_Set=_BU_LongLong_Set@8")
#pragma comment(linker, "/EXPORT:BU_LongLong_SetV=_BU_LongLong_SetV@12")
DLL_METHOD void DLL_CALL BU_LongLong_Add(int64_t* pthis, int64_t* other);
DLL_METHOD void DLL_CALL BU_LongLong_AddV(int64_t* pthis, uint32_t left, uint32_t right);
#pragma comment(linker, "/EXPORT:BU_LongLong_Add=_BU_LongLong_Add@8")
#pragma comment(linker, "/EXPORT:BU_LongLong_AddV=_BU_LongLong_AddV@12")
DLL_METHOD void DLL_CALL BU_LongLong_Sub(int64_t* pthis, int64_t* other);
DLL_METHOD void DLL_CALL BU_LongLong_SubV(int64_t* pthis, uint32_t left, uint32_t right);
#pragma comment(linker, "/EXPORT:BU_LongLong_Sub=_BU_LongLong_Sub@8")
#pragma comment(linker, "/EXPORT:BU_LongLong_SubV=_BU_LongLong_SubV@12")
DLL_METHOD void DLL_CALL BU_LongLong_Mul(int64_t* pthis, int64_t* other);
DLL_METHOD void DLL_CALL BU_LongLong_MulV(int64_t* pthis, uint32_t left, uint32_t right);
#pragma comment(linker, "/EXPORT:BU_LongLong_Mul=_BU_LongLong_Mul@8")
#pragma comment(linker, "/EXPORT:BU_LongLong_MulV=_BU_LongLong_MulV@12")
DLL_METHOD void DLL_CALL BU_LongLong_Div(int64_t* pthis, int64_t* other);
DLL_METHOD void DLL_CALL BU_LongLong_DivV(int64_t* pthis, uint32_t left, uint32_t right);
#pragma comment(linker, "/EXPORT:BU_LongLong_Div=_BU_LongLong_Div@8")
#pragma comment(linker, "/EXPORT:BU_LongLong_DivV=_BU_LongLong_DivV@12")
#pragma endregion Math
#pragma region Comparison
DLL_METHOD uint32_t DLL_CALL BU_LongLong_Compare(int64_t* pthis, int64_t* other);
DLL_METHOD uint32_t DLL_CALL BU_LongLong_CompareV(int64_t* pthis, uint32_t left, uint32_t right);
#pragma comment(linker, "/EXPORT:BU_LongLong_Compare=_BU_LongLong_Compare@8")
#pragma comment(linker, "/EXPORT:BU_LongLong_CompareV=_BU_LongLong_CompareV@12")
#pragma endregion Comparison
#pragma region Conversion
DLL_METHOD const char* DLL_CALL BU_LongLong_ToString(int64_t* pthis);
DLL_METHOD int64_t* DLL_CALL BU_LongLong_FromString(const char* text);
#pragma comment(linker, "/EXPORT:BU_LongLong_ToString=_BU_LongLong_ToString@4")
#pragma comment(linker, "/EXPORT:BU_LongLong_FromString=_BU_LongLong_FromString@4")
DLL_METHOD int32_t DLL_CALL BU_LongLong_ToLong(int64_t* pthis, int32_t _modulus);
DLL_METHOD int64_t* DLL_CALL BU_LongLong_FromLong(int32_t left, int32_t right);
#pragma comment(linker, "/EXPORT:BU_LongLong_ToLong=_BU_LongLong_ToLong@8")
#pragma comment(linker, "/EXPORT:BU_LongLong_FromLong=_BU_LongLong_FromLong@8")
DLL_METHOD int32_t DLL_CALL BU_LongLong_ToLongHigh(int64_t* pthis);
DLL_METHOD int32_t DLL_CALL BU_LongLong_ToLongLow(int64_t* pthis);
#pragma comment(linker, "/EXPORT:BU_LongLong_ToLongHigh=_BU_LongLong_ToLongHigh@4")
#pragma comment(linker, "/EXPORT:BU_LongLong_ToLongLow=_BU_LongLong_ToLongLow@4")
DLL_METHOD float_t DLL_CALL BU_LongLong_ToFloat(int64_t* pthis);
DLL_METHOD int64_t* DLL_CALL BU_LongLong_FromFloat(float_t other);
#pragma comment(linker, "/EXPORT:BU_LongLong_ToFloat=_BU_LongLong_ToFloat@4")
#pragma comment(linker, "/EXPORT:BU_LongLong_FromFloat=_BU_LongLong_FromFloat@4")
DLL_METHOD double_t* DLL_CALL BU_LongLong_ToDouble(int64_t* pthis);
DLL_METHOD int64_t* DLL_CALL BU_LongLong_FromDouble(double_t* pthis);
#pragma comment(linker, "/EXPORT:BU_LongLong_ToDouble=_BU_LongLong_ToDouble@4")
#pragma comment(linker, "/EXPORT:BU_LongLong_FromDouble=_BU_LongLong_FromDouble@4")
#pragma endregion Conversion
#pragma region Serialization
DLL_METHOD const char* DLL_CALL BU_LongLong_Serialize(int64_t* pthis);
DLL_METHOD int64_t* DLL_CALL BU_LongLong_Deserialize(const char* text);
#pragma comment(linker, "/EXPORT:BU_LongLong_Serialize=_BU_LongLong_Serialize@4")
#pragma comment(linker, "/EXPORT:BU_LongLong_Deserialize=_BU_LongLong_Deserialize@4")
#pragma endregion Serialization
Utility/DisplayEnumerator.cpp
+55
View File
@@ -0,0 +1,55 @@
// BlitzUtility - Expanding the normal Blitz functionality.
// Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "DisplayEnumerator.h"
BOOL CALLBACK BU_DisplayEnumerator_Callback(HMONITOR hMonitor, HDC hdcMonitor, LPRECT lprcMonitor, LPARAM dwData) {
DisplayEnumerator* displayEnumerator = (DisplayEnumerator*)dwData;
displayEnumerator->displays.push_back(RECT(*lprcMonitor));
return TRUE;
}
DLL_METHOD DisplayEnumerator* DLL_CALL BU_DisplayEnumerator_Create() {
DisplayEnumerator* displayEnumerator = new DisplayEnumerator();
return displayEnumerator;
}
DLL_METHOD void DLL_CALL BU_DisplayEnumerator_Destroy(DisplayEnumerator* displayEnumerator) {
delete displayEnumerator;
}
DLL_METHOD uint32_t DLL_CALL BU_DisplayEnumerator_Enumerate(DisplayEnumerator* displayEnumerator) {
EnumDisplayMonitors(NULL, NULL, BU_DisplayEnumerator_Callback, (LPARAM)displayEnumerator);
return displayEnumerator->displays.size();
}
DLL_METHOD uint32_t DLL_CALL BU_DisplayEnumerator_Count(DisplayEnumerator* displayEnumerator) {
return displayEnumerator->displays.size();
}
DLL_METHOD void DLL_CALL BU_DisplayEnumerator_Retrieve(DisplayEnumerator* displayEnumerator, uint32_t index, PRECT display) {
// Retrieve the requested index.
auto iterator = displayEnumerator->displays.begin();
std::advance(iterator, index);
// Copy data.
display->left = iterator->left;
display->top = iterator->top;
display->right = iterator->right;
display->bottom = iterator->bottom;
}
Utility/DisplayEnumerator.h
+38
View File
@@ -0,0 +1,38 @@
// BlitzUtility - Expanding the normal Blitz functionality.
// Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#pragma once
#include "dllmain.h"
#include <list>
struct DisplayEnumerator {
std::list<RECT> displays;
};
// Internal Callback
BOOL CALLBACK BU_DisplayEnumerator_Callback(HMONITOR hMonitor, HDC hdcMonitor, LPRECT lprcMonitor, LPARAM dwData);
// Exported functions.
DLL_METHOD DisplayEnumerator* DLL_CALL BU_DisplayEnumerator_Create();
#pragma comment(linker, "/EXPORT:BU_DisplayEnumerator_Create=_BU_DisplayEnumerator_Create@0")
DLL_METHOD void DLL_CALL BU_DisplayEnumerator_Destroy(DisplayEnumerator* displayEnumerator);
#pragma comment(linker, "/EXPORT:BU_DisplayEnumerator_Destroy=_BU_DisplayEnumerator_Destroy@4")
DLL_METHOD uint32_t DLL_CALL BU_DisplayEnumerator_Enumerate(DisplayEnumerator* displayEnumerator);
#pragma comment(linker, "/EXPORT:BU_DisplayEnumerator_Enumerate=_BU_DisplayEnumerator_Enumerate@4")
DLL_METHOD uint32_t DLL_CALL BU_DisplayEnumerator_Count(DisplayEnumerator* displayEnumerator);
#pragma comment(linker, "/EXPORT:BU_DisplayEnumerator_Count=_BU_DisplayEnumerator_Count@4")
DLL_METHOD void DLL_CALL BU_DisplayEnumerator_Retrieve(DisplayEnumerator* displayEnumerator, uint32_t index, LPRECT display);
#pragma comment(linker, "/EXPORT:BU_DisplayEnumerator_Retrieve=_BU_DisplayEnumerator_Retrieve@12")
Utility/MassOp.cpp
+200
View File
@@ -0,0 +1,200 @@
// Blitz - Steam wrapper for Blitz.
// Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#pragma once
#include "dllmain.h"
#include "MassOp.h"
MassOp::MassOp(uint32_t length) : length(length) {
this->instructions = new MassOpInstruction[length];
}
MassOp::~MassOp() {
delete this->instructions;
}
DLL_METHOD MassOp* DLL_CALL BU_MassOp_Create(uint32_t length) {
MassOp* myMassOp = new MassOp(length);
return myMassOp;
}
DLL_METHOD void DLL_CALL BU_MassOp_Destroy(MassOp* massop) {
delete massop;
}
DLL_METHOD void DLL_CALL BU_MassOp_Instruction(MassOp* massop, uint32_t index, MassOpType type, MassOpCode code, intptr_t leftOperand, intptr_t rightOperand, intptr_t result) {
massop->instructions[index].type = type;
massop->instructions[index].code = code;
massop->instructions[index].leftOperand = leftOperand;
massop->instructions[index].rightOperand = rightOperand;
massop->instructions[index].result = result;
}
DLL_METHOD void DLL_CALL BU_MassOp_Run(MassOp* massop) {
for (uint32_t index = 0; index < massop->length; index++) {
MassOpInstruction* instr = &massop->instructions[index];
switch (instr->code) {
case GoTo:
index = instr->leftOperand;
break;
case SetOpCode:
massop->instructions[instr->leftOperand].code = instr->rightOperand;
break;
case CopyLeft:
if (instr->leftOperand != instr->rightOperand) {
switch (instr->result) {
case 0:
massop->instructions[instr->rightOperand].leftOperand = massop->instructions[instr->leftOperand].leftOperand;
break;
case 1:
massop->instructions[instr->rightOperand].rightOperand = massop->instructions[instr->leftOperand].leftOperand;
break;
case 2:
massop->instructions[instr->rightOperand].result = massop->instructions[instr->leftOperand].leftOperand;
break;
}
}
break;
case CopyRight:
if (instr->leftOperand != instr->rightOperand) {
switch (instr->result) {
case 0:
massop->instructions[instr->rightOperand].leftOperand = massop->instructions[instr->leftOperand].rightOperand;
break;
case 1:
massop->instructions[instr->rightOperand].rightOperand = massop->instructions[instr->leftOperand].rightOperand;
break;
case 2:
massop->instructions[instr->rightOperand].result = massop->instructions[instr->leftOperand].rightOperand;
break;
}
}
break;
case CopyOut:
if (instr->leftOperand != instr->rightOperand) {
switch (instr->result) {
case 0:
massop->instructions[instr->rightOperand].leftOperand = massop->instructions[instr->leftOperand].result;
break;
case 1:
massop->instructions[instr->rightOperand].rightOperand = massop->instructions[instr->leftOperand].result;
break;
case 2:
massop->instructions[instr->rightOperand].result = massop->instructions[instr->leftOperand].result;
break;
}
}
break;
case If:
if (instr->leftOperand != instr->rightOperand) {
if (massop->instructions[instr->leftOperand].result == massop->instructions[instr->rightOperand].result) {
index += instr->result;
}
}
break;
case IfValue:
if (instr->leftOperand != instr->rightOperand) {
if (massop->instructions[instr->rightOperand].result == instr->rightOperand) {
index += instr->result;
}
}
break;
default:
switch (instr->type) {
case Double:
switch (instr->code) {
case Create:
instr->result = (uint32_t)BU_Double_Create();
break;
case Destroy:
BU_Double_Destroy((double_t*)instr->leftOperand);
break;
case Copy:
instr->result = (uint32_t)BU_Double_Copy((double_t*)instr->leftOperand);
break;
case TempCreate:
instr->result = (uint32_t)BU_Double_TempCreate();
break;
case TempCopy:
instr->result = (uint32_t)BU_Double_TempCopy((double_t*)instr->leftOperand);
break;
case TempCleanup:
BU_Double_TempCleanup();
break;
case Set:
BU_Double_Set((double_t*)instr->leftOperand, (double_t*)instr->rightOperand);
break;
case Add:
BU_Double_Add((double_t*)instr->leftOperand, (double_t*)instr->rightOperand);
break;
case Sub:
BU_Double_Sub((double_t*)instr->leftOperand, (double_t*)instr->rightOperand);
break;
case Mul:
BU_Double_Mul((double_t*)instr->leftOperand, (double_t*)instr->rightOperand);
break;
case Div:
BU_Double_Div((double_t*)instr->leftOperand, (double_t*)instr->rightOperand);
break;
case Compare:
instr->result = BU_Double_Compare((double_t*)instr->leftOperand, (double_t*)instr->rightOperand);
break;
}
break;
case LongLong:
switch (instr->code) {
case Create:
instr->result = (uint32_t)BU_LongLong_Create();
break;
case Destroy:
BU_LongLong_Destroy((int64_t*)instr->leftOperand);
break;
case Copy:
instr->result = (uint32_t)BU_LongLong_Copy((int64_t*)instr->leftOperand);
break;
case TempCreate:
instr->result = (uint32_t)BU_LongLong_TempCreate();
break;
case TempCopy:
instr->result = (uint32_t)BU_LongLong_TempCopy((int64_t*)instr->leftOperand);
break;
case TempCleanup:
BU_LongLong_TempCleanup();
break;
case Set:
BU_LongLong_Set((int64_t*)instr->leftOperand, (int64_t*)instr->rightOperand);
break;
case Add:
BU_LongLong_Add((int64_t*)instr->leftOperand, (int64_t*)instr->rightOperand);
break;
case Sub:
BU_LongLong_Sub((int64_t*)instr->leftOperand, (int64_t*)instr->rightOperand);
break;
case Mul:
BU_LongLong_Mul((int64_t*)instr->leftOperand, (int64_t*)instr->rightOperand);
break;
case Div:
BU_LongLong_Div((int64_t*)instr->leftOperand, (int64_t*)instr->rightOperand);
break;
case Compare:
instr->result = BU_LongLong_Compare((int64_t*)instr->leftOperand, (int64_t*)instr->rightOperand);
break;
}
break;
}
}
}
}
Utility/MassOp.h
+108
View File
@@ -0,0 +1,108 @@
// Blitz - Steam wrapper for Blitz.
// Copyright (C) 2015 Project Kube (Michael Fabian Dirks)
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#pragma once
#include "dllmain.h"
#include "Type\Double.h"
#include "Type\LongLong.h"
enum MassOpType {
LongLong = 0,
Double = 1,
Vector2 = 10,
Vector3 = 11,
};
enum MassOpCode {
Create = 0,
Destroy = 1,
Copy = 2,
TempCreate = 5,
TempCopy = 6,
TempCleanup = 7,
Set = 10,
Add = 11,
Sub = 12,
Mul = 13,
Div = 14,
Compare = 15,
// Special OPCodes (Control MassOp)
// Goto - Go to a specific intruction
// oper_l = target massop index
GoTo = 249,
// SetOpCode - Change OpCode at position
// oper_l = target massop index
// oper_r = new OpCode
SetOpCode = 250,
// CopyLeft - Copy oper_l to new MassOp instruction.
// oper_l = source massop index
// oper_r = target massop index
// out = target position (0/oper_l, 1/oper_r, 2/out)
CopyLeft = 251,
// CopyRight - Copy oper_r to new MassOp instruction.
// oper_l = source massop index
// oper_r = target massop index
// out = target position (0/oper_l, 1/oper_r, 2/out)
CopyRight = 252,
// CopyOut - Copy out to new MassOp instruction.
// oper_l = source massop index
// oper_r = target massop index
// out = target position (0/oper_l, 1/oper_r, 2/out)
CopyOut = 253,
// If - If the result of index oper_l is equal to index oper_r, skip out instructions.
// oper_l = source massop index
// oper_r = target massop index
// out = instructions to skip
If = 254,
// IfValue - If the result of index oper_l is equal to oper_r, skip out instructions.
// oper_l = source massop index
// oper_r = value to compare with
// out = instructions to skip
IfValue = 255
};
struct BlitzBank {
uint32_t identifier;
uint32_t address;
uint32_t size;
};
struct MassOpInstruction {
uint8_t type;
uint8_t code;
uint32_t leftOperand, rightOperand;
uint32_t result;
};
struct MassOp {
MassOp(uint32_t length);
~MassOp();
uint32_t length;
MassOpInstruction* instructions;
};
DLL_METHOD MassOp* DLL_CALL BU_MassOp_Create(uint32_t length);
#pragma comment(linker, "/EXPORT:BU_MassOp_Create=_BU_MassOp_Create@4")
DLL_METHOD void DLL_CALL BU_MassOp_Destroy(MassOp* massop);
#pragma comment(linker, "/EXPORT:BU_MassOp_Destroy=_BU_MassOp_Destroy@4")
DLL_METHOD void DLL_CALL BU_MassOp_Instruction(MassOp* massop, uint32_t index, MassOpType type, MassOpCode code, intptr_t leftOperand, intptr_t rightOperand, intptr_t result);
#pragma comment(linker, "/EXPORT:BU_MassOp_Instruction=_BU_MassOp_Instruction@28")
DLL_METHOD void DLL_CALL BU_MassOp_Run(MassOp* massop);
#pragma comment(linker, "/EXPORT:BU_MassOp_Run=_BU_MassOp_Run@4")