move vec to generated

src/game/Global.cpp

@@ -6,12 +6,52 @@
 #include <cassert>
 #include <cstdint>
 
+using namespace Generated;
+
 namespace
 {
     SharedData* SharedInstance = nullptr;
     Game::GameInstance* GameInst = nullptr;
 } // namespace
 
+namespace Game
+{
+    SharedData& GetShared()
+    {
+        assert(SharedInstance != nullptr);
+        return *SharedInstance;
+    }
+
+    void SetShared(SharedData& instance)
+    {
+        SharedInstance = &instance;
+    }
+
+    GameInstance& GetInstance()
+    {
+        assert(GameInst != nullptr);
+        return *GameInst;
+    }
+
+    void SetInstance(Game::GameInstance& instance)
+    {
+        GameInst = &instance;
+    }
+
+    void* AllocateScratch(size_t byteCount, size_t align)
+    {
+        size_t offset = GetInstance().UsedScratchAmount;
+        uint8_t* base = static_cast<uint8_t*>(GetShared().Game.TransientStorage);
+        uint8_t* current = base + offset;
+        size_t offsetAligned = ((offset + align - 1) / align) * align;
+        uint8_t* ptrAligned = base + offsetAligned;
+        size_t newOffset = offsetAligned + byteCount;
+        if (newOffset > GetShared().Game.TransientStorageSize) return nullptr;
+        GetInstance().UsedScratchAmount = newOffset;
+        return reinterpret_cast<void*>(ptrAligned);
+    }
+} // namespace Game
+
 void Transform::CreateTransform(float* out, bx::Vec3 pos, bx::Quaternion rot, bx::Vec3 scale)
 {
     if (out == nullptr) return;
@@ -82,49 +122,12 @@ void Transform::UpdateMatrix()
     bx::mtxInverse(MI.M, M.M);
 }
 
-namespace Game
-{
-    SharedData& GetShared()
-    {
-        assert(SharedInstance != nullptr);
-        return *SharedInstance;
-    }
-
-    void SetShared(SharedData& instance)
-    {
-        SharedInstance = &instance;
-    }
-
-    GameInstance& GetInstance()
-    {
-        assert(GameInst != nullptr);
-        return *GameInst;
-    }
-
-    void SetInstance(Game::GameInstance& instance)
-    {
-        GameInst = &instance;
-    }
-
-    void* AllocateScratch(size_t byteCount, size_t align)
-    {
-        size_t offset = GetInstance().UsedScratchAmount;
-        uint8_t* base = static_cast<uint8_t*>(GetShared().Game.TransientStorage);
-        uint8_t* current = base + offset;
-        size_t offsetAligned = ((offset + align - 1) / align) * align;
-        uint8_t* ptrAligned = base + offsetAligned;
-        size_t newOffset = offsetAligned + byteCount;
-        if (newOffset > GetShared().Game.TransientStorageSize) return nullptr;
-        GetInstance().UsedScratchAmount = newOffset;
-        return reinterpret_cast<void*>(ptrAligned);
-    }
-} // namespace Game
 Vec3 Transform::GlobalToLocalDirection(Vec3 global)
 {
     UpdateMatrix();
     float in[4]{global.x, global.y, global.z, 0.0f};
     float out[4]{0.0f};
-    bx::vec4MulMtx(out, in, MI.Transpose().M);
+    bx::vec4MulMtx(out, in, Transpose(MI).M);
     return {out[0], out[1], out[2]};
 }
 Vec3 Transform::GlobalToLocalPoint(Vec3 global)
@@ -140,7 +143,7 @@ Vec3 Transform::LocalToGlobalDirection(Vec3 local)
     UpdateMatrix();
     float in[4]{local.x, local.y, local.z, 0.0f};
     float out[4]{0.0f};
-    bx::vec4MulMtx(out, in, M.Transpose().M);
+    bx::vec4MulMtx(out, in, Transpose(M).M);
     return {out[0], out[1], out[2]};
 }
 Vec3 Transform::LocalToGlobalPoint(Vec3 local)
@@ -159,24 +162,286 @@ Vec3 Transform::GetPosition()
 {
     return {Position.x, Position.y, Position.z};
 }
-Mat4 Mat4::Inverse()
+
+// Vec4
+Vec4& operator+=(Vec4& lhs, const Vec4& rhs)
+{
+    lhs.x += rhs.x;
+    lhs.y += rhs.y;
+    lhs.z += rhs.z;
+    lhs.w += rhs.w;
+    return lhs;
+}
+Vec4 operator+(const Vec4& lhs, const Vec4& rhs)
+{
+    Vec4 out = lhs;
+    return out += rhs;
+}
+Vec4& operator+=(Vec4& lhs, float rhs)
+{
+    lhs.x += rhs;
+    lhs.y += rhs;
+    lhs.z += rhs;
+    lhs.w += rhs;
+    return lhs;
+}
+Vec4 operator+(Vec4& lhs, float rhs)
+{
+    Vec4 out = lhs;
+    return out += rhs;
+}
+
+Vec4& operator-=(Vec4& lhs, const Vec4& rhs)
+{
+    lhs.x -= rhs.x;
+    lhs.y -= rhs.y;
+    lhs.z -= rhs.z;
+    lhs.w -= rhs.w;
+    return lhs;
+}
+Vec4 operator-(const Vec4& lhs, const Vec4& rhs)
+{
+    Vec4 out = lhs;
+    return out -= rhs;
+}
+Vec4& operator-=(Vec4& lhs, float rhs)
+{
+    lhs.x -= rhs;
+    lhs.y -= rhs;
+    lhs.z -= rhs;
+    lhs.w -= rhs;
+    return lhs;
+}
+Vec4 operator-(const Vec4& lhs, float rhs)
+{
+    Vec4 out = lhs;
+    return out -= rhs;
+}
+
+Vec4& operator*=(Vec4& lhs, float rhs)
+{
+    lhs.x *= rhs;
+    lhs.y *= rhs;
+    lhs.z *= rhs;
+    lhs.w *= rhs;
+    return lhs;
+}
+Vec4 operator*(const Vec4& lhs, float rhs)
+{
+    Vec4 out = lhs;
+    return out *= rhs;
+}
+
+Vec4& operator/=(Vec4& lhs, float rhs)
+{
+    lhs.x /= rhs;
+    lhs.y /= rhs;
+    lhs.z /= rhs;
+    lhs.w /= rhs;
+    return lhs;
+}
+Vec4 operator/(const Vec4& lhs, float rhs)
+{
+    Vec4 out = lhs;
+    return out /= rhs;
+}
+
+// Vec3
+Vec3& operator+=(Vec3& lhs, const Vec3& rhs)
+{
+    lhs.x += rhs.x;
+    lhs.y += rhs.y;
+    lhs.z += rhs.z;
+    return lhs;
+}
+Vec3 operator+(const Vec3& lhs, const Vec3& rhs)
+{
+    Vec3 out = lhs;
+    return out += rhs;
+}
+Vec3& operator+=(Vec3& lhs, float rhs)
+{
+    lhs.x += rhs;
+    lhs.y += rhs;
+    lhs.z += rhs;
+    return lhs;
+}
+Vec3 operator+(Vec3& lhs, float rhs)
+{
+    Vec3 out = lhs;
+    return out += rhs;
+}
+
+Vec3& operator-=(Vec3& lhs, const Vec3& rhs)
+{
+    lhs.x -= rhs.x;
+    lhs.y -= rhs.y;
+    lhs.z -= rhs.z;
+    return lhs;
+}
+Vec3 operator-(const Vec3& lhs, const Vec3& rhs)
+{
+    Vec3 out = lhs;
+    return out -= rhs;
+}
+Vec3& operator-=(Vec3& lhs, float rhs)
+{
+    lhs.x -= rhs;
+    lhs.y -= rhs;
+    lhs.z -= rhs;
+    return lhs;
+}
+Vec3 operator-(const Vec3& lhs, float rhs)
+{
+    Vec3 out = lhs;
+    return out -= rhs;
+}
+
+Vec3& operator*=(Vec3& lhs, float rhs)
+{
+    lhs.x *= rhs;
+    lhs.y *= rhs;
+    lhs.z *= rhs;
+    return lhs;
+}
+Vec3 operator*(const Vec3& lhs, float rhs)
+{
+    Vec3 out = lhs;
+    return out *= rhs;
+}
+
+Vec3& operator/=(Vec3& lhs, float rhs)
+{
+    lhs.x /= rhs;
+    lhs.y /= rhs;
+    lhs.z /= rhs;
+    return lhs;
+}
+Vec3 operator/(const Vec3& lhs, float rhs)
+{
+    Vec3 out = lhs;
+    return out /= rhs;
+}
+
+// Vec2
+Vec2& operator+=(Vec2& lhs, const Vec2& rhs)
+{
+    lhs.x += rhs.x;
+    lhs.y += rhs.y;
+    return lhs;
+}
+Vec2 operator+(const Vec2& lhs, const Vec2& rhs)
+{
+    Vec2 out = lhs;
+    return out += rhs;
+}
+Vec2& operator+=(Vec2& lhs, float rhs)
+{
+    lhs.x += rhs;
+    lhs.y += rhs;
+    return lhs;
+}
+Vec2 operator+(Vec2& lhs, float rhs)
+{
+    Vec2 out = lhs;
+    return out += rhs;
+}
+
+Vec2& operator-=(Vec2& lhs, const Vec2& rhs)
+{
+    lhs.x -= rhs.x;
+    lhs.y -= rhs.y;
+    return lhs;
+}
+Vec2 operator-(const Vec2& lhs, const Vec2& rhs)
+{
+    Vec2 out = lhs;
+    return out -= rhs;
+}
+Vec2& operator-=(Vec2& lhs, float rhs)
+{
+    lhs.x -= rhs;
+    lhs.y -= rhs;
+    return lhs;
+}
+Vec2 operator-(const Vec2& lhs, float rhs)
+{
+    Vec2 out = lhs;
+    return out -= rhs;
+}
+
+Vec2& operator*=(Vec2& lhs, float rhs)
+{
+    lhs.x *= rhs;
+    lhs.y *= rhs;
+    return lhs;
+}
+Vec2 operator*(const Vec2& lhs, float rhs)
+{
+    Vec2 out = lhs;
+    return out *= rhs;
+}
+
+Vec2& operator/=(Vec2& lhs, float rhs)
+{
+    lhs.x /= rhs;
+    lhs.y /= rhs;
+    return lhs;
+}
+Vec2 operator/(const Vec2& lhs, float rhs)
+{
+    Vec2 out = lhs;
+    return out /= rhs;
+}
+
+Mat4 Inverse(const Mat4& mat)
 {
     Mat4 result;
-    bx::mtxInverse(result.M, M);
+    bx::mtxInverse(result.M, &mat.M[0]);
     return result;
 }
-Mat4 Mat4::Transpose()
+Mat4 Transpose(const Mat4& mat)
 {
     Mat4 result;
-    bx::mtxTranspose(result.M, M);
+    bx::mtxTranspose(result.M, &mat.M[0]);
     return result;
 }
-Vec4 Mat4::Mul(const Vec4& vec)
+Vec4 Mul(const Mat4& mat, const Vec4& vec)
 {
     Vec4 out;
-    bx::vec4MulMtx(&out.x, &vec.x, &M[0]);
+    bx::vec4MulMtx(&out.x, &vec.x, &mat.M[0]);
     return out;
 }
+
+float Magnitude(const Vec4& vec)
+{
+    return bx::sqrt(vec.x * vec.x + vec.y * vec.y + vec.z * vec.z + vec.w * vec.w);
+}
+float Magnitude(const Vec3& vec)
+{
+    return bx::sqrt(vec.x * vec.x + vec.y * vec.y + vec.z * vec.z);
+}
+float Magnitude(const Vec2& vec)
+{
+    return bx::sqrt(vec.x * vec.x + vec.y * vec.y);
+}
+
+Vec4 Normalized(const Vec4& vec)
+{
+    Vec4 res = vec;
+    return res /= Magnitude(vec);
+}
+Vec3 Normalized(const Vec3& vec)
+{
+    Vec3 res = vec;
+    return res /= Magnitude(vec);
+}
+Vec2 Normalized(const Vec2& vec)
+{
+    Vec2 res = vec;
+    return res /= Magnitude(vec);
+}
+
 float DotProduct(Vec3 a, Vec3 b)
 {
     return a.x * b.x + a.y * b.y + a.z * b.z;
@@ -191,8 +456,8 @@ Vec3 CrossProduct(Vec3 a, Vec3 b)
 Vec3 CrossProductFromPlane(Vec3 a, Vec3 b, Vec3 c)
 {
     // TODO: normalize might not be necessary
-    Vec3 lineA = (b - a).Normalize();
-    Vec3 lineB = (c - a).Normalize();
+    Vec3 lineA = Normalized(b - a);
+    Vec3 lineB = Normalized(c - a);
     return CrossProduct(lineA, lineB);
 }
 bool RayPlaneIntersect(Vec3 l1, Vec3 l2, Vec3 p1, Vec3 p2, Vec3 p3, Vec3& out)