Vector3.h

#pragma once
 
#include "MathHelper.h"
 
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);
        }
 
        kmyMath::Vector3 toNative() {
            return kmyMath::Vector3(x, y, z);
        }
 
        static Vector3 fromNative(const kmyMath::Vector3& v) {
            return Vector3(v.x, v.y, v.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);
    };
}