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
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
|
/*
math/vector3f.h
This file is part of the Osirion project and is distributed under
the terms of the GNU General Public License version 2
*/
#ifndef __INCLUDED_MATH_VECTOR3F_H__
#define __INCLUDED_MATH_VECTOR3F_H__
#include <iostream>
#include "math/vector3f.h"
namespace math
{
/// a point or vector in 3D space
/** An instance of this class represents a point in 3D-space or a 3D-vector
* and forms the basic building block for all spatial calculations.
*/
class Vector3f
{
public:
/// default constructor, assigns (0,0,0)
Vector3f();
/// copy constructor
/** Create a new Vector3f that is a copy from an other
* @param other the vector to copy values from
*/
Vector3f(const Vector3f &other);
/// create a Vector3f with given coordinates
/** @param x the x-coordinate of the location
* @param y the y-coordinate of the location
* @param z the z-coordinate of the location
*/
Vector3f(const float x, const float y, const float z);
/// destructor
~Vector3f();
/* -- Assignment operators -- */
/// assign (0, 0, 0)
void clear();
/// assignment
void assign(const float x, const float y, const float z);
/// assignment
void assign(const Vector3f & other);
/// assignment operator
Vector3f& operator=(const Vector3f &other);
/// scalar multiplication assignment
/** @param scalar multiplication factor
*/
Vector3f& operator*=(const float scalar);
/// scalar division assignment
/** @param scalar divider
*/
Vector3f& operator/=(const float scalar);
/// vector sum assignment
Vector3f& operator+=(const Vector3f &other);
/// vector difference assignment
Vector3f& operator-=(const Vector3f &other);
/* -- Mathematical operators -- */
/// scalar multiplication
inline Vector3f operator*(const float scalar) const {
Vector3f v(coord[0] * scalar, coord[1] * scalar, coord[2] * scalar);
return v;
}
/// scalar division
Vector3f operator/(const float scalar) const {
Vector3f v(coord[0] / scalar, coord[1] / scalar, coord[2] / scalar);
return v;
}
/// vector sum
inline Vector3f operator+(const Vector3f &other) const {
Vector3f v(coord[0] + other.coord[0], coord[1] + other.coord[1], coord[2] + other.coord[2]);
return v;
}
/// vector difference
inline Vector3f operator-(const Vector3f &other) const {
Vector3f v(coord[0] - other.coord[0], coord[1] - other.coord[1], coord[2] - other.coord[2]);
return v;
}
/// comparison operator
bool operator==(const Vector3f &other) const;
/// assign a value to an element of this vector
/*! range is not checked
* @param index the index of the element to assign to ( 0 <= index < 3 )
*/
inline float& operator[](const size_t index) {
return coord[index];
}
/// returns the value of an element of this vector
/*! range is not checked
* @param index the index of the element to return ( 0 <= index < 3 )
*/
inline float operator[](const size_t index) const {
return coord[index];
}
/// x coordinate
inline float x() const { return coord[0]; }
/// y coordinate
inline float y() const { return coord[1]; }
/// z coordinate
inline float z() const { return coord[2]; }
/// mutable reference to the x coordinate
inline float & get_x() { return coord[0]; }
/// mutable reference to the y coordinate
inline float & get_y() { return coord[1]; }
/// mutable reference to the z coordinate
inline float & get_z() { return coord[2]; }
/// a pointer to the internal data
inline float *ptr() const { return (float *) coord; }
/// cartesian length
float length() const;
/// cartesian length squared
float lengthsquared() const;
/// divide this Vector by its length
/// @see normalized()
/// vector must not be (0, 0, 0)
void normalize();
/* static functions */
/// Returns the unity vector on the X-axis
static inline Vector3f Xaxis() {
return Vector3f(1.0f, 0.0f, 0.0f);
}
/// Returns the unity vector on the Y-axis
static inline Vector3f Yaxis() {
return Vector3f(0.0f, 1.0f, 0.0f);
}
/// Returns the unity vector on the Z-axis
static inline Vector3f Zaxis() {
return Vector3f(0.0f, 0.0f, 1.0f);
}
/// cartesian lenght
static inline float length(const Vector3f & vector) {
return vector.length();
}
/// Return a vector divided by it's length
/// @see normalize()
/// WARNING: vector must not be (0, 0, 0)
static inline Vector3f normalized(const Vector3f & vector) {
return (vector / vector.length());
}
private:
float coord[3];
};
/// Write a Vector3f to a std::ostream
std::ostream &operator<<(std::ostream & os, const Vector3f & vector);
/// Read a Vector3d from a std::istream
std::istream &operator>>(std::istream & is, Vector3f & vector);
/// scalar * Vector3f operators
Vector3f operator*(float scalar, const Vector3f & vector);
/// vector cross product
const Vector3f crossproduct(const Vector3f & first, const Vector3f & second);
/// vector dot product
float dotproduct(const Vector3f& first, const Vector3f & second);
/// distance between two vectors
float distance(const Vector3f& first, const Vector3f& second);
/// distance between two vectors squared
float distancesquared(const Vector3f& first, const Vector3f& second);
} // namespace math
#endif // __INCLUDED_MATH_VECTOR3F_H__
|
