Math.hpp

Go to the documentation of this file.

 
#pragma once
 
namespace small3d {
 
  struct Vec3 {
    float x = 0.0f;
    float y = 0.0f;
    float z = 0.0f;
    Vec3();
    Vec3(float x, float y, float z);
    Vec3(float v);
    Vec3& operator+=(const Vec3& other);
    Vec3 operator+(const Vec3& other);
    Vec3 operator*(const Vec3& other) const;
    Vec3 operator*(const float v) const;
    Vec3 operator/(const float v) const;
    Vec3& operator=(const Vec3& other);
    template <class Archive>
    void serialize(Archive& archive) {
      archive(x, y, z);
    }
  };
 
  struct Vec3i {
    int x = 0;
    int y = 0;
    int z = 0;
    Vec3i();
    Vec3i(int x, int y, int z);
  };
 
  struct Vec4 {
    float x = 0.0f;
    float y = 0.0f;
    float z = 0.0f;
    float w = 0.0f;
    Vec4();
    Vec4(float x, float y, float z, float w);
    Vec4(const Vec3& vec3, float w);
    
    Vec4& operator+=(const Vec4& other);
    Vec4 operator+(const Vec4& other);
    Vec4 operator-(const Vec4& other);
    Vec4 operator*(const float v) const;
    Vec4 operator*(const Vec4& other) const;
    Vec4& operator/=(const float div);
    float& operator[](int idx);
    Vec4& operator=(const Vec4& other);
    template <class Archive>
    void serialize(Archive& archive) {
      archive(x, y, z, w);
    }
  };
 
  struct Vec4i {
    int x = 0;
    int y = 0;
    int z = 0;
    int w = 0;
    Vec4i();
    Vec4i(int x, int y, int z, int w);
    Vec4i(const Vec3i& vec3i, float w);
  };
 
  struct Mat4 {
    Vec4 data[4];
    Mat4();
    Mat4(float v);
    Mat4(Vec4 r0, Vec4 r1, Vec4 r2, Vec4 r3);
    Mat4(float r0x, float r0y, float r0z, float r0w,
      float r1x, float r1y, float r1z, float r1w, 
      float r2x, float r2y, float r2z, float r2w, 
      float r3x, float r3y, float r3z, float r3w );
    Vec4& operator[](int idx);
    Mat4 operator-(const Mat4& other) const;
    Mat4 operator*(const Mat4& other) const;
    Vec4 operator*(const Vec4& vec) const;
    Mat4& operator*=(const Mat4& other);
    Mat4& operator/=(const float div);
    Mat4& operator=(const Mat4& other);
    template <class Archive>
    void serialize(Archive& archive) {
      archive(data);
    }
  };
 
  struct Quat {
 
    
    float x;
    float y;
    float z;
    float w;
 
    Mat4 toMatrix() const;
    Quat operator*(const Quat& other);
    template <class Archive>
    void serialize(Archive& archive) {
      archive(w, x, y, z);
    }
  };
 
  Mat4 translate(const Mat4& mat, const Vec3& vec);
 
  Mat4 scale(const Mat4& mat, const Vec3& vec);
 
  Mat4 rotate(const Mat4& mat, const float angle, const Vec3& vec);
 
  Mat4 ortho(float left, float right, float bottom, float top, float zNear, float zFar);
 
  Mat4 perspective(float fovy, float aspect, float zNear, float zFar);
 
  Mat4 inverse(const Mat4 mat);
 
  float* Value_ptr(Mat4& mat);
 
  float* Value_ptr(Vec3& vec);
 
  float* Value_ptr(Vec4& vec);
 
}