/
Vector3d.h
144 lines (107 loc) · 3.57 KB
/
Vector3d.h
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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
//
// Created by afan on 2022/10/24.
//
#ifndef LAB4_VECTOR3D_H
#define LAB4_VECTOR3D_H
#include <cmath>
#include <iostream>
#include "obj/OBJ_Loader.h"
using std::sqrt;
using std::fabs;
class Vector3d {
public:
double e[3];
Vector3d() : e{0, 0, 0} {}
Vector3d(objl::Vector3 &v) : e{v.X, v.Y, v.Z} {}
Vector3d(double e0, double e1, double e2) : e{e0, e1, e2} {}
double x() const { return e[0]; }
double y() const { return e[1]; }
double z() const { return e[2]; }
Vector3d operator-() const { return {-e[0], -e[1], -e[2]}; }
double operator[](int i) const { return e[i]; }
double &operator[](int i) { return e[i]; }
Vector3d &operator+=(const Vector3d &v) {
e[0] += v.e[0];
e[1] += v.e[1];
e[2] += v.e[2];
return *this;
}
Vector3d &operator*=(const double t) {
e[0] *= t;
e[1] *= t;
e[2] *= t;
return *this;
}
Vector3d &operator/=(const double t) {
return *this *= 1 / t;
}
double length() const {
return sqrt(length_squared());
}
double length_squared() const {
return e[0] * e[0] + e[1] * e[1] + e[2] * e[2];
}
double dot(Vector3d &v) const {
return e[0] * v[0] + e[1] * v[1] + e[2] * v[2];
}
Vector3d cross(Vector3d &v) const {
return {e[1] * v.e[2] - e[2] * v.e[1],
e[2] * v.e[0] - e[0] * v.e[2],
e[0] * v.e[1] - e[1] * v.e[0]};
}
bool near_zero() const {
// Return true if the vector is close to zero in all dimensions.
const auto s = 1e-8;
return (fabs(e[0]) < s) && (fabs(e[1]) < s) && (fabs(e[2]) < s);
}
void copy(Vector3d &v) {
for (int i = 0; i < 3; i++) {
e[i] = v[i];
}
}
inline static double random_double(int min = 0, int max = 1) {
return (max - min) * rand() / (RAND_MAX + max) + min;
}
inline static Vector3d random() {
return Vector3d(random_double(), random_double(), random_double());
}
inline static Vector3d random(double min, double max) {
return Vector3d(random_double(min, max), random_double(min, max), random_double(min, max));
}
};
// Vector3d Utility Functions
inline std::ostream &operator<<(std::ostream &out, const Vector3d &v) {
return out << v.e[0] << ' ' << v.e[1] << ' ' << v.e[2];
}
inline Vector3d operator+(const Vector3d &u, const Vector3d &v) {
return {u.e[0] + v.e[0], u.e[1] + v.e[1], u.e[2] + v.e[2]};
}
inline Vector3d operator-(const Vector3d &u, const Vector3d &v) {
return {u.e[0] - v.e[0], u.e[1] - v.e[1], u.e[2] - v.e[2]};
}
inline Vector3d operator*(const Vector3d &u, const Vector3d &v) {
return {u.e[0] * v.e[0], u.e[1] * v.e[1], u.e[2] * v.e[2]};
}
inline Vector3d operator*(double t, const Vector3d &v) {
return {t * v.e[0], t * v.e[1], t * v.e[2]};
}
inline Vector3d operator*(const Vector3d &v, double t) {
return t * v;
}
inline Vector3d operator/(Vector3d v, double t) {
return (1 / t) * v;
}
inline double dot(const Vector3d &u, const Vector3d &v) {
return u.e[0] * v.e[0] +
u.e[1] * v.e[1] +
u.e[2] * v.e[2];
}
inline Vector3d cross(const Vector3d &u, const Vector3d &v) {
return {u.e[1] * v.e[2] - u.e[2] * v.e[1],
u.e[2] * v.e[0] - u.e[0] * v.e[2],
u.e[0] * v.e[1] - u.e[1] * v.e[0]};
}
inline Vector3d unit_vector(Vector3d v) {
return v / v.length();
}
#endif //LAB4_VECTOR3D_H