Project::OSiRiON - Git repositories
Project::OSiRiON
News . About . Screenshots . Downloads . Forum . Wiki . Tracker . Git
summaryrefslogtreecommitdiff
blob: a7437aa3e5b7b8bd3ed83fd8d8509ef4a8876fc7 (plain)
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
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
/*
   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"

#include "LinearMath/btVector3.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);
	
	/// assign bullet btVector3 value
	void assign(const btVector3 & 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);

/// helper function to convert Vector3f to btVector3
inline btVector3 to_btVector3(const math::Vector3f & v)
{
	return btVector3(v[0], v[1], v[2]);
}

} // namespace math

#endif // __INCLUDED_MATH_VECTOR3F_H__