Vector3.h

#pragma once
 
#include "math/Math.h"
#undef PI
 
namespace SharpKmyMath{
 
    public value struct Vector3{
 
    public:
        float x, y, z;
 
        Vector3(float v)
        {
            x = y = z = v;
        }
 
        Vector3(float _x, float _y, float _z)
        {
            x = _x;
            y = _y;
            z = _z;
        }
 
        float length()
        {
            return sqrt(x*x + y*y + z*z);
        }
 
        static Vector3 normalize(Vector3 v)
        {
            float l = sqrt(v.x * v.x + v.y * v.y + v.z * v.z);
            Vector3 ret;
            ret.x = v.x / l;
            ret.y = v.y / l;
            ret.z = v.z / l;
            return ret;
        }
 
        static Vector3 operator-(Vector3 v1, Vector3 v2)
        {
            Vector3 ret;
            ret.x = v1.x - v2.x;
            ret.y = v1.y - v2.y;
            ret.z = v1.z - v2.z;
            return ret;
        }
 
        static Vector3 operator+(Vector3 v1, Vector3 v2)
        {
            Vector3 ret;
            ret.x = v1.x + v2.x;
            ret.y = v1.y + v2.y;
            ret.z = v1.z + v2.z;
            return ret;
        }
 
        static Vector3 operator*(Vector3 v, float f)
        {
            Vector3 ret;
            ret.x = v.x * f;
            ret.y = v.y * f;
            ret.z = v.z * f;
            return ret;
        }
 
        static Vector3 operator*(Vector3 v1, Vector3 v2)
        {
            Vector3 ret;
            ret.x = v1.x * v2.x;
            ret.y = v1.y * v2.y;
            ret.z = v1.z * v2.z;
            return ret;
        }
 
        static Vector3 operator/(Vector3 v, float f)
        {
            Vector3 ret;
            ret.x = v.x / f;
            ret.y = v.y / f;
            ret.z = v.z / f;
            return ret;
        }
 
        static Vector3 operator- (Vector3 v)
        {
            Vector3 ret;
            ret.x = -v.x;
            ret.y = -v.y;
            ret.z = -v.z;
            return ret;
        }
 
        static float dotProduct(Vector3 v1, Vector3 v2)
        {
            return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z;
        }
 
        static Vector3 crossProduct(Vector3 v1, Vector3 v2)
        {
            Vector3 tmp;
            tmp.x = v1.y * v2.z - v1.z * v2.y;
            tmp.y = v1.z * v2.x - v1.x * v2.z;
            tmp.z = v1.x * v2.y - v1.y * v2.x;
            return tmp;
        }
 
        static Vector3 one = Vector3(1, 1, 1);
        static Vector3 zero = Vector3(0, 0, 0);
    };
 
    public value struct Vector4{
 
    public:
        float x, y, z, w;
 
        Vector4(float v)
        {
            x = y = z = w = v;
        }
 
        Vector4(float _x, float _y, float _z, float _w)
        {
            x = _x;
            y = _y;
            z = _z;
            w = _w;
        }
 
        static Vector4 operator * (Vector4 v, float f)
        {
            Vector4 ret;
            ret.x = v.x * f;
            ret.y = v.y * f;
            ret.z = v.z * f;
            ret.w = v.w * f;
            return ret;
        }
 
        static Vector4 operator / (Vector4 v, float f)
        {
            Vector4 ret;
            ret.x = v.x / f;
            ret.y = v.y / f;
            ret.z = v.z / f;
            ret.w = v.w / f;
            return ret;
        }
 
        static Vector4 operator + (Vector4 v, Vector4 v2)
        {
            Vector4 ret;
            ret.x = v.x + v2.x;
            ret.y = v.y + v2.y;
            ret.z = v.z + v2.z;
            ret.w = v.w + v2.w;
            return ret;
        }
 
        static Vector4 operator - (Vector4 v, Vector4 v2)
        {
            Vector4 ret;
            ret.x = v.x - v2.x;
            ret.y = v.y - v2.y;
            ret.z = v.z - v2.z;
            ret.w = v.w - v2.w;
            return ret;
        }
 
        static Vector4 operator - (Vector4 v)
        {
            Vector4 ret;
            ret.x = -v.x;
            ret.y = -v.y;
            ret.z = -v.z;
            ret.w = -v.w;
            return ret;
        }
 
        Vector3 getXYZ()
        {
            return Vector3(x, y, z);
        }
    };
 
    public value struct Vector2{
 
    public:
        float x, y;
 
        Vector2(float v)
        {
            x = y = v;
        }
 
        Vector2(float _x, float _y)
        {
            x = _x;
            y = _y;
        }
 
        static Vector2 operator + (Vector2 v, Vector2 v2)
        {
            Vector2 ret;
            ret.x = v.x + v2.x;
            ret.y = v.y + v2.y;
            return ret;
        }
 
        static Vector2 operator - (Vector2 v, Vector2 v2)
        {
            Vector2 ret;
            ret.x = v.x - v2.x;
            ret.y = v.y - v2.y;
            return ret;
        }
 
        static Vector2 operator / (Vector2 v, float f)
        {
            Vector2 ret;
            ret.x = v.x/f;
            ret.y = v.y/f;
            return ret;
        }
 
        static Vector2 operator * (Vector2 v, float f)
        {
            Vector2 ret;
            ret.x = v.x * f;
            ret.y = v.y * f;
            return ret;
        }
 
        static Vector2 operator - (Vector2 v)
        {
            Vector2 ret;
            ret.x = -v.x;
            ret.y = -v.y;
            return ret;
        }
    };
 
    public ref class Helper{
 
    public:
        static float ToDeg(float d){
            return RAD_TO_DEG(d);
        }
 
        static float ToRad(float d){
            return DEG_TO_RAD(d);
        }
 
        static float lerp(float start, float end, float rate)
        {
            return start * (1 - rate) + end * rate;
        }
 
        static const float PI=3.1415f;
 
    };
 
    public value class Rectangle
    {
    public:
        float x, y, height, width;
        Rectangle(float _x, float _y, float _w, float _h)
        {
            x = _x;
            y = _y;
            height = _h;
            width = _w;
        }
    };
 
 
}