RayTracer/vector.h at master · hatahet/RayTracer · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
#ifndef VECTOR_H_
#define VECTOR_H_
#pragma once

#include <cmath>
#include <limits>

namespace raytracer {

class Vector3 {
 public:
  Vector3(double x, double y, double z);
  Vector3(const Vector3& v);
  Vector3& operator=(const Vector3& v);

  ~Vector3();

  double Dot(const Vector3& v) const;
  double Magnitude() const;
  Vector3 Cross(const Vector3& v) const;
  Vector3 Normal() const;

  friend Vector3 operator+(const Vector3& l, const Vector3& r);
  friend Vector3 operator-(const Vector3& l, const Vector3& r);
  friend Vector3 operator*(double d, const Vector3& r);
  friend bool operator==(const Vector3& l, const Vector3& r);

  double x;
  double y;
  double z;
};

inline Vector3::Vector3(double X, double Y, double Z)
    : x(X), y(Y), z(Z) { }
inline Vector3::Vector3(const Vector3& v)
    :  x(v.x), y(v.y), z(v.z) { }

inline Vector3& Vector3::operator=(const Vector3& v) {
  x = v.x;
  y = v.y;
  z = v.z;
  return *this;
}

inline Vector3::~Vector3() { }

inline double Vector3::Dot(const Vector3& v) const {
  return x*v.x + y*v.y + z*v.z;
}

inline double Vector3::Magnitude() const {
  return std::sqrt(Dot(*this));
}

inline Vector3 Vector3::Cross(const Vector3& v) const {
  return Vector3(y*v.z - z*v.y,
                 z*v.x - x*v.z,
                 x*v.y - y*v.x);
}

inline Vector3 Vector3::Normal() const {
  double mag = Magnitude();
  double div = mag == 0 ?
      std::numeric_limits<double>::infinity() : 1 / mag;
  return div * (*this);
}

inline Vector3 operator+(const Vector3& l, const Vector3& r) {
  return Vector3(l.x + r.x, l.y + r.y, l.z + r.z);
}

inline Vector3 operator-(const Vector3& l, const Vector3& r) {
  return Vector3(l.x - r.x, l.y - r.y, l.z - r.z);
}

inline Vector3 operator*(double d, const Vector3& v) {
  return Vector3(d * v.x, d * v.y, d * v.z);
}

inline bool operator==(const Vector3& l, const Vector3& r) {
  return l.x == r.x && l.y == r.y && l.z == r.z;
}

}

#endif  // VECTOR_H_