33
template<class T> class vec2 {
38
vec2(const vec2<T>& vec) {
43
vec2(T x = 0, T y = 0) {
48
vec2<T> perpendicular() const {
49
return vec2<T>(y * -1.0f, x);
53
T dot(const vec2<T> &vec) const {
54
return x*vec.x + y*vec.y;
57
T operator* (const vec2<T> &vec) const {
58
return x*vec.x + y*vec.y;
61
vec2<T> operator+ (const vec2<T> &vec) const {
62
return vec2<T>(x+vec.x, y+vec.y);
65
vec2<T> operator- (const vec2<T> &vec) const {
66
return vec2<T>(x-vec.x, y-vec.y);
69
vec2<T> operator* (const T n) const {
70
return vec2<T>(x*n, y*n);
73
vec2<T> operator/ (const T n) const {
74
return vec2<T>(x/n, y/n);
77
friend vec2<T> operator* (T n, const vec2<T>& vec) {
78
return vec2<T>(vec.x*n, vec.y*n);
81
bool operator== (const vec2<T> &vec) const {
82
return (vec.x==x && vec.y==y);
85
bool operator!= (const vec2<T> &vec) const {
86
return (vec.x!=x || vec.y!=y);
94
return sqrt(x*x + y*y);
104
vec2<T> normal() const {
110
vec2<T> rotate(float angle) const {
112
float s = sinf(angle);
113
float c = cosf(angle);
115
return vec2<T>( x * c - y * s, x * s + y * c );
118
vec2<T> rotate(float s, float c) const {
119
return vec2<T>( x * c - y * s, x * s + y * c );
122
vec2<T> rotate(const vec2<T> ¢re, float angle) const {
123
vec2<T> v = *this - centre;
125
float s = sinf(angle);
126
float c = cosf(angle);
128
v = vec2<T>( v.x * c - v.y * s, v.x * s + v.y * c );
133
vec2<T> rotate(const vec2<T> ¢re, float s, float c) const {
134
vec2<T> v = *this - centre;
136
v = vec2<T>( v.x * c - v.y * s, v.x * s + v.y * c );
142
operator T*() const {
146
vec2<T>& operator= (const vec2<T> &vec) {
152
void operator+= (const vec2<T> &vec) {
157
void operator-= (const vec2<T> &vec) {
162
void operator*= (T n) {
167
void operator/= (T n) {
173
template<class T> class vec3 {
179
vec3(const vec3<T>& vec) {
185
vec3(const vec2<T>& vec, float z) {
191
vec3(T x = 0, T y = 0, T z = 0) {
197
vec3<T> cross(const vec3<T>& vec) const {
198
return vec3<T>(y*vec.z-z*vec.y, z*vec.x-x*vec.z, x*vec.y-y*vec.x);
201
T dot(const vec3<T>& vec) const {
202
return x*vec.x + y*vec.y + z*vec.z;
205
T operator* (const vec3<T> &vec) const {
206
return x*vec.x + y*vec.y + z*vec.z;
209
vec3<T> operator+ (const vec3<T> &vec) const {
210
return vec3<T>(x+vec.x,y+vec.y,z+vec.z);
213
vec3<T> operator- (const vec3<T> &vec) const {
214
return vec3<T>(x-vec.x,y-vec.y,z-vec.z);
217
vec3<T> operator* (T n) const {
218
return vec3<T>(x*n,y*n,z*n);
221
vec3<T> operator/ (const T n) const {
222
return vec3<T>(x/n, y/n, z/n);
225
friend vec3<T> operator* (T n, const vec3<T>& vec) {
226
return vec3<T>(vec.x*n,vec.y*n,vec.z*n);
229
bool operator== (vec3<T> &vec) const {
230
return (vec.x==x && vec.y==y && vec.z==z);
233
bool operator!= (vec3<T> &vec) const {
234
return (vec.x!=x || vec.y!=y || vec.z!=z);
238
return x*x + y*y + z*z;
242
return sqrt(x*x + y*y + z*z);
252
vec3<T> normal() const {
258
vec2<T> truncate() const {
259
return vec2<T>(x, y);
262
operator T*() const {
266
vec3<T>& operator= (const vec3<T> &vec) {
273
void operator+= (const vec3<T> &vec) {
279
void operator-= (const vec3<T> &vec) {
285
void operator*= (T n) {
291
void operator/= (T n) {
298
template<class T> class lerp3 : public vec3<T> {
303
lerp3() : vec3<T>(), p(), l() {
306
lerp3(const vec3<T>& vec) : vec3<T>(vec) {
313
const vec3<T>& lerp(T n) {
314
l = p * n + *this * (1.0-n);
319
template<class T> class vec4 {
326
vec4(T x = 0, T y = 0, T z = 0, T w = 0) {
333
vec4(const vec4<T>& vec) {
340
vec4(const vec3<T>& vec, T w) {
347
vec4<T>& operator= (const vec4<T> &vec) {
355
T dot(const vec4<T>& vec) const {
356
return x*vec.x + y*vec.y + z*vec.z + w*vec.w;
359
vec4<T> operator+ (const vec4<T> &vec) const {
360
return vec4<T>(x+vec.x, y+vec.y, z+vec.z, w+vec.w);
363
vec4<T> operator- (const vec4<T> &vec) const {
364
return vec4<T>(x-vec.x, y-vec.y, z-vec.z, w-vec.w);
367
vec4<T> operator* (T n) const {
368
return vec4<T>(x*n, y*n, z*n, w*n);
371
vec4<T> operator/ (const T n) const {
372
return vec4<T>(x/n, y/n, z/n, w/n);
375
T operator* (const vec4<T> &vec) const {
376
return x*vec.x + y*vec.y + z*vec.z + w*vec.w;
379
friend vec4<T> operator* (T n, const vec4<T>& vec) {
380
return vec4<T>(vec.x*n, vec.y*n, vec.z*n, vec.w*n);
383
bool operator== (const vec4<T> &vec) const {
384
return (vec.x==x && vec.y==y && vec.z==z && vec.w==w);
387
bool operator!= (const vec4<T> &vec) const {
388
return (vec.x!=x || vec.y!=y || vec.z!=z || vec.w!=w);
392
return x*x + y*y + z*z + w*w;
396
return sqrt(x*x + y*y + z*z + w*w);
406
vec4<T> normal() const {
412
vec3<T> truncate() const {
413
return vec3<T>(x, y, z);
416
operator T*() const {
420
void operator+= (const vec4<T> &vec) {
427
void operator-= (const vec4<T> &vec) {
434
void operator*= (T n) {
441
void operator/= (T n) {
449
typedef vec2<float> vec2f;
450
typedef vec3<float> vec3f;
451
typedef vec4<float> vec4f;
453
typedef lerp3<float> lerp3f;
455
typedef vec2<int> vec2i;
456
typedef vec3<int> vec3i;
457
typedef vec4<int> vec4i;
31
#include <glm/glm.hpp>
32
#include <glm/gtc/type_ptr.hpp>
33
#include <glm/gtc/matrix_transform.hpp>
34
#include <glm/gtc/matrix_access.hpp>
35
#include <glm/gtx/norm.hpp>
43
vec2 rotate_vec2(const vec2& v, float s, float c);
45
vec2 normalise(const vec2& v);
46
vec3 normalise(const vec3& v);
47
vec4 normalise(const vec4& v);
49
class lerp2 : public glm::vec2 {
54
lerp2() : vec2(), p(), l() {
62
static vec2 lerp(const vec2& a, const vec2& b, float n) {
63
return a + (b - a) * n;
66
const vec2& lerp(float n) {
67
l = p + (*this - p) * n;
71
const lerp2& operator= (const vec2& vec) {
78
class lerp3 : public vec3 {
83
lerp3() : vec3(), p(), l() {
91
static vec3 lerp(const vec3& a, const vec3& b, float n) {
92
return a + (b - a) * n;
95
const vec3& lerp(float n) {
96
l = p + (*this - p) * n;
100
const lerp3& operator= (const vec3& vec) {
added
removed
src/core/vectors.h
