m_vec.hpp

#pragma once
#include <lib/nw4r/math/vec.hpp>
#include <lib/rvl/mtx/vec.h>
#include <dol/mLib/m_angle.hpp>
 
class mVec2_c {
public:
 
    mVec2_c() {}
 
    mVec2_c(const f32 *p) { x = p[0]; y = p[1]; }
 
    mVec2_c(f32 fx, f32 fy) { x = fx; y = fy; }
 
    mVec2_c(const Vec2 &v) { x = v.x; y = v.y; }
 
    mVec2_c(const nw4r::math::VEC2 &v) { x = v.x; y = v.y; }
 
    operator f32*() { return &x; }
 
    operator const f32*() const { return &x; }
 
    operator Vec2*() { return (Vec2*)&x; }
 
    operator const Vec2*() const { return (const Vec2*)&x; }
 
    operator nw4r::math::VEC2*() { return (nw4r::math::VEC2*)&x; }
 
    operator const nw4r::math::VEC2*() const { return (const nw4r::math::VEC2*)&x; }
 
    mVec2_c &operator+=(const mVec2_c &v) { x += v.x; y += v.y; return *this; }
 
    mVec2_c &operator-=(const mVec2_c &v) { x -= v.x; y -= v.y; return *this; }
 
    mVec2_c &operator*=(f32 f) { x *= f; y *= f; return *this; }
 
    mVec2_c &operator/=(f32 f) { return operator*=(1.0f / f); }
 
    mVec2_c operator+() const { return *this; }
 
    mVec2_c operator-() const { return mVec2_c(-x, -y); }
 
    mVec2_c operator+(const mVec2_c &v) const { return mVec2_c(x + v.x, y + v.y); }
 
    mVec2_c operator-(const mVec2_c &v) const { return mVec2_c(x - v.x, y - v.y); }
 
    mVec2_c operator*(f32 f) const { return mVec2_c(f * x, f * y); }
 
    mVec2_c operator/(f32 f) const { f32 r = 1.0f / f; return operator*(r); }
 
    bool operator==(const mVec2_c &v) const { return x == v.x && y == v.y; }
 
    bool operator!=(const mVec2_c &v) const { return x != v.x || y != v.y; }
 
    float x; 
    float y; 
};
 
class mVec3_c {
public:
 
    mVec3_c() {}
 
    mVec3_c(const f32 *p) { x = p[0]; y = p[1]; z = p[2]; }
 
    mVec3_c(f32 fx, f32 fy, f32 fz) { x = fx; y = fy; z = fz; }
 
    mVec3_c(const Vec &v) { x = v.x; y = v.y; z = v.z; }
 
    mVec3_c(const nw4r::math::VEC3 &v) { x = v.x; y = v.y; z = v.z; }
 
    operator f32*() { return &x; }
 
    operator const f32*() const { return &x; }
 
    operator Vec*() { return (Vec*)&x; }
 
    operator const Vec*() const { return (const Vec*)&x; }
 
    operator nw4r::math::VEC3*() { return (nw4r::math::VEC3*)&x; }
 
    operator const nw4r::math::VEC3*() const { return (const nw4r::math::VEC3*)&x; }
 
    mVec3_c &operator+=(const mVec3_c &v) { x += v.x; y += v.y; z += v.z; return *this; }
 
    mVec3_c &operator-=(const mVec3_c &v) { x -= v.x; y -= v.y; z -= v.z; return *this; }
 
    mVec3_c &operator*=(f32 f) { x *= f; y *= f; z *= f; return *this; }
 
    mVec3_c &operator/=(f32 f) { return operator*=(1.0f / f); }
 
    mVec3_c operator+() const { return *this; }
 
    mVec3_c operator-() const { return mVec3_c(-x, -y, -z); }
 
    mVec3_c operator+(const mVec3_c &v) const { return mVec3_c(x + v.x, y + v.y, z + v.z); }
 
    mVec3_c operator-(const mVec3_c &v) const { return mVec3_c(x - v.x, y - v.y, z - v.z); }
 
    mVec3_c operator*(f32 f) const { return mVec3_c(f * x, f * y, f * z); }
 
    mVec3_c operator/(f32 f) const { f32 r = 1.0f / f; return operator*(r); }
 
    bool operator==(const mVec3_c &v) const { return x == v.x && y == v.y && z == v.z; }
 
    bool operator!=(const mVec3_c &v) const { return x != v.x || y != v.y || z != v.z; }
 
    float normalize();
 
    bool normalizeRS();
 
    void rotX(mAng angle); 
    void rotY(mAng angle); 
 
    float x; 
    float y; 
    float z; 
 
    static mVec3_c Zero; 
    static mVec3_c Ex; 
    static mVec3_c Ey; 
    static mVec3_c Ez; 
};