xaymar/BlitzUtility
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
8049964bd118cf39c247351f17e990380d744c67
BlitzUtility/Math/Vector2.cpp
T
Michael Fabian Dirks 8049964bd1 Update BlitzUtility: 
- New DECLS
- Begin wrapping __cdecl sqlite3 into __stdcall functions (sqlite3 doesn't understand __stdcall)
- Use __stdcall and /EXPORT instead of __cdecl to not corrupt the stack.
- Implement two versions of the Indexer, V1 for really fast access and V2 for memory saving.

Signed-off-by: Michael Fabian Dirks <michael.dirks@realitybends.de>
2015-06-06 14:09:40 +02:00

290 lines
7.2 KiB
C++
Raw Blame History

#include "Vector2.h"
void Vector2::set(const float &o)
{
this->X = o;
this->Y = o;
}
void Vector2::set(const float &x, const float &y)
{
this->X = x;
this->Y = y;
}
void Vector2::set(const Vector2 &o)
{
if (this != &o) {
this->X = o.X;
this->Y = o.Y;
}
}
void Vector2::add(const float &o)
{
this->X += o;
this->Y += o;
}
void Vector2::add(const float &x, const float &y)
{
this->X += x;
this->Y += y;
}
void Vector2::add(const Vector2 &o)
{
this->X += o.X;
this->Y += o.Y;
}
void Vector2::sub(const float &o)
{
this->X -= o;
this->Y -= o;
}
void Vector2::sub(const float &x, const float &y)
{
this->X -= x;
this->Y -= y;
}
void Vector2::sub(const Vector2 &o)
{
this->X -= o.X;
this->Y -= o.Y;
}
void Vector2::mul(const float &o)
{
this->X *= o;
this->Y *= o;
}
void Vector2::mul(const float &x, const float &y)
{
this->X *= x;
this->Y *= y;
}
void Vector2::mul(const Vector2 &o)
{
this->X *= o.X;
this->Y *= o.Y;
}
void Vector2::div(const float &o)
{
this->X /= o;
this->Y /= o;
}
void Vector2::div(const float &x, const float &y)
{
this->X /= x;
this->Y /= y;
}
void Vector2::div(const Vector2 &o)
{
this->X /= o.X;
this->Y /= o.Y;
}
float Vector2::length()
{
return (float)sqrt((this->X * this->X) + (this->Y * this->Y));
}
float Vector2::distance(const float &x, const float &y)
{
float X = this->X - x;
float Y = this->Y - y;
return (float)sqrt((X * X) + (Y * Y));
}
float Vector2::distance(const Vector2 &o)
{
float X = this->X - o.X;
float Y = this->Y - o.Y;
return (float)sqrt((X * X) + (Y * Y));
}
float Vector2::dot(const float &x, const float &y)
{
return (this->X * x) + (this->Y * y);
}
float Vector2::dot(const Vector2 &o)
{
return (this->X * o.X) + (this->Y * o.Y);
}
void Vector2::normalize()
{
this->div(this->length());
}
void Vector2::rotate(const float rotation)
{
float mX = cos(rotation);
float mY = sin(rotation);
float X = this->X * mX + this->Y * mY; this->X = X;
float Y = this->X * mY + this->X * mX; this->Y = Y;
}
void Vector2::rotateAround(const float &x, const float &y, const float &rotation)
{
this->sub(x, y);
this->rotate(rotation);
this->add(x, y);
}
void Vector2::rotateAround(const Vector2 &o, const float &rotation)
{
this->sub(o);
this->rotate(rotation);
this->add(o);
}
float Vector2::deltaRotation() {
return (float)(atan2(this->Y, this->X) * (180.0 / M_PI));
}
float Vector2::deltaRotation(const float &x, const float &y)
{
return (float)(atan2(this->Y - y, this->X - x) * (180.0 / M_PI));
}
float Vector2::deltaRotation(const Vector2 &o)
{
return (float)(atan2(this->Y - o.Y, this->X - o.X) * (180.0 / M_PI));
}
char* Vector2::serialize()
{
char* data = new char[9];
memcpy(data, this->Xc, 4);
memcpy(data + 4, this->Yc, 4);
data[8] = 0;
return data;
}
void Vector2::deserialize(char* o)
{
memcpy(o, this->Xc, 4);
memcpy(o + 4, this->Yc, 4);
}
/* ------------------------- Exported Functionality ------------------------- */
DLL_EXPORT void Vector2_Set(Vector2* a, float o) {
a->set(o);
}
DLL_EXPORT void Vector2_SetP(Vector2* a, float x, float y) {
a->set(x, y);
}
DLL_EXPORT void Vector2_SetV(Vector2* a, Vector2* b) {
a->set(*b);
}
#pragma comment(linker, "/EXPORT:Vector2_Set=_Vector2_Set@8")
#pragma comment(linker, "/EXPORT:Vector2_SetP=_Vector2_SetP@12")
#pragma comment(linker, "/EXPORT:Vector2_SetV=_Vector2_SetV@8")
DLL_EXPORT void Vector2_Add(Vector2* a, float o) {
a->add(o);
}
DLL_EXPORT void Vector2_AddP(Vector2* a, float x, float y) {
a->add(x, y);
}
DLL_EXPORT void Vector2_AddV(Vector2* a, Vector2* b) {
a->add(*b);
}
#pragma comment(linker, "/EXPORT:Vector2_Add=_Vector2_Add@8")
#pragma comment(linker, "/EXPORT:Vector2_AddP=_Vector2_AddP@12")
#pragma comment(linker, "/EXPORT:Vector2_AddV=_Vector2_AddV@8")
DLL_EXPORT void Vector2_Sub(Vector2* a, float o) {
a->sub(o);
}
DLL_EXPORT void Vector2_SubP(Vector2* a, float x, float y) {
a->sub(x, y);
}
DLL_EXPORT void Vector2_SubV(Vector2* a, Vector2* b) {
a->sub(*b);
}
#pragma comment(linker, "/EXPORT:Vector2_Sub=_Vector2_Sub@8")
#pragma comment(linker, "/EXPORT:Vector2_SubP=_Vector2_SubP@12")
#pragma comment(linker, "/EXPORT:Vector2_SubV=_Vector2_SubV@8")
DLL_EXPORT void Vector2_Mul(Vector2* a, float o) {
a->mul(o);
}
DLL_EXPORT void Vector2_MulP(Vector2* a, float x, float y) {
a->mul(x, y);
}
DLL_EXPORT void Vector2_MulV(Vector2* a, Vector2* b) {
a->mul(*b);
}
#pragma comment(linker, "/EXPORT:Vector2_Mul=_Vector2_Mul@8")
#pragma comment(linker, "/EXPORT:Vector2_MulP=_Vector2_MulP@12")
#pragma comment(linker, "/EXPORT:Vector2_MulV=_Vector2_MulV@8")
DLL_EXPORT void Vector2_Div(Vector2* a, float o) {
a->div(o);
}
DLL_EXPORT void Vector2_DivP(Vector2* a, float x, float y) {
a->div(x, y);
}
DLL_EXPORT void Vector2_DivV(Vector2* a, Vector2* b) {
a->div(*b);
}
#pragma comment(linker, "/EXPORT:Vector2_Div=_Vector2_Div@8")
#pragma comment(linker, "/EXPORT:Vector2_DivP=_Vector2_DivP@12")
#pragma comment(linker, "/EXPORT:Vector2_DivV=_Vector2_DivV@8")
DLL_EXPORT float Vector2_Length(Vector2* a) {
return (float)a->length();
}
DLL_EXPORT float Vector2_DistanceP(Vector2* a, float x, float y) {
return (float)a->distance(x, y);
}
DLL_EXPORT float Vector2_DistanceV(Vector2* a, Vector2* b) {
return (float)a->distance(*b);
}
#pragma comment(linker, "/EXPORT:Vector2_Length=_Vector2_Length@4")
#pragma comment(linker, "/EXPORT:Vector2_DistanceP=_Vector2_DistanceP@12")
#pragma comment(linker, "/EXPORT:Vector2_DistanceV=_Vector2_DistanceV@8")
DLL_EXPORT float Vector2_DotP(Vector2* a, float x, float y) {
return (float)a->dot(x, y);
}
DLL_EXPORT float Vector2_DotV(Vector2* a, Vector2* b) {
return (float)a->dot(*b);
}
DLL_EXPORT void Vector2_Normalize(Vector2* a) {
a->normalize();
}
#pragma comment(linker, "/EXPORT:Vector2_DotP=_Vector2_DotP@12")
#pragma comment(linker, "/EXPORT:Vector2_DotV=_Vector2_DotV@8")
#pragma comment(linker, "/EXPORT:Vector2_Normalize=_Vector2_Normalize@4")
DLL_EXPORT void Vector2_Rotate(Vector2* a, float rotation) {
a->rotate(rotation);
}
DLL_EXPORT void Vector2_RotateAroundP(Vector2* a, float x, float y, float rotation) {
a->rotateAround(x, y, rotation);
}
DLL_EXPORT void Vector2_RotateAroundV(Vector2* a, Vector2* b, float rotation) {
a->rotateAround(*b, rotation);
}
#pragma comment(linker, "/EXPORT:Vector2_Rotate=_Vector2_Rotate@8")
#pragma comment(linker, "/EXPORT:Vector2_RotateAroundP=_Vector2_RotateAroundP@16")
#pragma comment(linker, "/EXPORT:Vector2_RotateAroundV=_Vector2_RotateAroundV@12")
DLL_EXPORT float Vector2_DeltaRotation(Vector2* a) {
return (float)a->deltaRotation();
}
DLL_EXPORT float Vector2_DeltaRotationP(Vector2* a, float x, float y) {
return (float)a->deltaRotation(x, y);
}
DLL_EXPORT float Vector2_DeltaRotationV(Vector2* a, Vector2* b) {
return (float)a->deltaRotation(*b);
}
#pragma comment(linker, "/EXPORT:Vector2_DeltaRotation=_Vector2_DeltaRotation@4")
#pragma comment(linker, "/EXPORT:Vector2_DeltaRotationP=_Vector2_DeltaRotationP@12")
#pragma comment(linker, "/EXPORT:Vector2_DeltaRotationV=_Vector2_DeltaRotationV@8")
DLL_EXPORT char* Vector2_Serialize(Vector2* a) {
return a->serialize();
}
DLL_EXPORT void Vector2_Deserialize(Vector2* a, char* o) {
a->deserialize(o);
}
#pragma comment(linker, "/EXPORT:Vector2_Serialize=_Vector2_Serialize@4")
#pragma comment(linker, "/EXPORT:Vector2_Deserialize=_Vector2_Deserialize@8")
Reference in New Issue View Git Blame Copy Permalink