138 lines
2.5 KiB
C++
138 lines
2.5 KiB
C++
#ifndef VEC3_H
|
|
#define VEC3_H
|
|
|
|
#include <math.h>
|
|
#include <stdio.h>
|
|
|
|
struct vec3 {
|
|
/* Members */
|
|
double x;
|
|
double y;
|
|
double z;
|
|
|
|
// Constructor proper. Values default to 0
|
|
vec3(double x = 0, double y = 0, double z = 0)
|
|
{
|
|
this->x = x;
|
|
this->y = y;
|
|
this->z = z;
|
|
}
|
|
|
|
/* Overriden operators */
|
|
|
|
// - operator. Not to be confused with substraction
|
|
vec3 operator-() const
|
|
{
|
|
return vec3(-x, -y, -z);
|
|
}
|
|
|
|
// Straightforward vector sum
|
|
vec3& operator+=(const vec3 &v)
|
|
{
|
|
this->x += v.x;
|
|
this->y += v.y;
|
|
this->z += v.z;
|
|
return *this;
|
|
}
|
|
|
|
// Scalar multiplication
|
|
vec3& operator*=(const double t)
|
|
{
|
|
x *= t;
|
|
y *= t;
|
|
z *= t;
|
|
return *this;
|
|
}
|
|
|
|
// Division by a scalar t
|
|
vec3& operator/=(const double t)
|
|
{
|
|
x /= t;
|
|
y /= t;
|
|
z /= t;
|
|
return *this;
|
|
}
|
|
|
|
/* Methods */
|
|
|
|
double length() const
|
|
{
|
|
return sqrt(x*x + y*y + z*z);
|
|
}
|
|
|
|
// Length squared, useful for some calculations
|
|
double length_squared() const
|
|
{
|
|
return x*x + y*y + z*z;
|
|
}
|
|
};
|
|
|
|
/* Type aliases */
|
|
typedef vec3 point3;
|
|
typedef vec3 color;
|
|
|
|
|
|
/* More overloads */
|
|
|
|
// Straightforward vector sum
|
|
inline vec3 operator+(const vec3 &u, const vec3 &v)
|
|
{
|
|
return vec3(u.x + v.x,
|
|
u.y + v.y,
|
|
u.z + v.z);
|
|
}
|
|
|
|
// Straightforward vector difference
|
|
inline vec3 operator-(const vec3 &u, const vec3 &v)
|
|
{
|
|
return vec3(u.x - v.x,
|
|
u.y - v.y,
|
|
u.z - v.z);
|
|
}
|
|
|
|
// Hadamard product
|
|
inline vec3 operator*(const vec3 &u, const vec3 &v)
|
|
{
|
|
return vec3(u.x * v.x,
|
|
u.y * v.y,
|
|
u.z * v.z);
|
|
}
|
|
|
|
// Scalar product
|
|
inline vec3 operator*(double t,const vec3 &v)
|
|
{
|
|
return vec3(t*v.x, t*v.y, t*v.z);
|
|
}
|
|
|
|
inline vec3 operator*(const vec3 &v, double t)
|
|
{
|
|
return t * v;
|
|
}
|
|
|
|
// Vector division by scalar. Note that we redefine it as multiplying by 1/t to avoid division by 0
|
|
inline vec3 operator/(vec3 v, double t)
|
|
{
|
|
return 1/t * v;
|
|
}
|
|
|
|
// Straightforward dot product
|
|
inline double dot(const vec3 &u, const vec3 &v)
|
|
{
|
|
return u.x*v.x + u.y*v.y + u.z*v.z;
|
|
}
|
|
|
|
// Cross product between two vectors
|
|
inline vec3 cross(const vec3 &u, const vec3 &v)
|
|
{
|
|
return vec3(u.y * v.z - u.z * v.y,
|
|
u.z * v.x - u.x * v.z,
|
|
u.x * v.y - u.y * v.x);
|
|
}
|
|
|
|
// Normalize vector so its length = 1
|
|
inline vec3 normalize(const vec3 v)
|
|
{
|
|
return v / v.length();
|
|
}
|
|
|
|
#endif
|