162 lines
3.2 KiB
C++
162 lines
3.2 KiB
C++
#ifndef VEC3_H
|
|
#define VEC3_H
|
|
|
|
#include "rtweekend.hpp"
|
|
|
|
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;
|
|
}
|
|
|
|
// Get a vec3 with random components in the range [0,1)
|
|
inline static vec3 random()
|
|
{
|
|
return vec3(random_double(), random_double(), random_double());
|
|
}
|
|
|
|
// Get a vec3 with random components in the range [min, max)
|
|
inline static vec3 random(double min, double max)
|
|
{
|
|
return vec3(random_double(min, max), random_double(min, max), random_double(min, max));
|
|
}
|
|
};
|
|
|
|
/* 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();
|
|
}
|
|
|
|
// Returns a vec3 of random components between [-1,1) that is inside a unit sphere
|
|
vec3 random_in_unit_sphere()
|
|
{
|
|
// Iterate until we find a vector with length < 1
|
|
while (true)
|
|
{
|
|
vec3 p = vec3::random(-1,1);
|
|
if (p.length_squared() >= 1)
|
|
continue;
|
|
return p;
|
|
}
|
|
}
|
|
|
|
#endif
|