Subversion Repository Public Repository

Divide-Framework

This repository has no backups
This repository's network speed is throttled to 100KB/sec

Diff Revisions 330 vs 331 for /trunk/Source Code/Core/Math/Headers/MathVectors.h

Diff revisions: vs.
  @@ -148,19 +148,19 @@
148 148 };
149 149
150 150 /// return the closest point on the line defined by the 2 points (A, B) and this vector
151 - template <class T>
151 + template<typename T>
152 152 inline vec2<T> closestPointOnLine(const vec2<T> &vA, const vec2<T> &vB);
153 153 /// return the closest point on the line segment defined between the 2 points (A, B) and this vector
154 - template <class T>
154 + template<typename T>
155 155 inline vec2<T> closestPointOnSegment(const vec2<T> &vA, const vec2<T> &vB);
156 156 /// lerp between the 2 specified vectors by the specified amount
157 - template <class T>
157 + template<typename T>
158 158 inline vec2<T> lerp(const vec2<T> &u, const vec2<T> &v, T factor);
159 159 /// lerp between the 2 specified vectors by the specified amount for each component
160 - template <class T>
160 + template<typename T>
161 161 inline vec2<T> lerp(const vec2<T> &u, const vec2<T> &v, const vec2<T>& factor);
162 162
163 - template <class T>
163 + template<typename T>
164 164 inline vec2<T> normalize(vec2<T>& vector) {
165 165 vector.normalize();
166 166 return vector;
  @@ -170,7 +170,7 @@
170 170 /* vec3 - A 3-tuple used to represent things like a vector in 3D space,
171 171 /* a point in 3D space or just 3 values linked together
172 172 /***********************************************************************/
173 - template <class T>
173 + template<typename T>
174 174 class vec3 {
175 175 public:
176 176 vec3() : x(0), y(0), z(0) { }
  @@ -295,19 +295,19 @@
295 295 };
296 296
297 297 /// return the closest point on the line defined by the 2 points (A, B) and this vector
298 - template <class T>
298 + template<typename T>
299 299 inline vec3<T> closestPointOnLine(const vec3<T> &vA, const vec3<T> &vB);
300 300 /// return the closest point on the line segment created between the 2 points (A, B) and this vector
301 - template <class T>
301 + template<typename T>
302 302 inline vec3<T> closestPointOnSegment(const vec3<T> &vA, const vec3<T> &vB);
303 303 /// lerp between the 2 specified vectors by the specified amount
304 - template <class T>
304 + template<typename T>
305 305 inline vec3<T> lerp(const vec3<T> &u, const vec3<T> &v, T factor);
306 306 /// lerp between the 2 specified vectors by the specified amount for each component
307 - template <class T>
307 + template<typename T>
308 308 inline vec3<T> lerp(const vec3<T> &u, const vec3<T> &v, const vec3<T>& factor);
309 - template <class T>
310 309
310 + template<typename T>
311 311 inline vec3<T> normalize(vec3<T>& vector) {
312 312 vector.normalize();
313 313 return vector;
  @@ -317,7 +317,7 @@
317 317 /* vec4 - A 4-tuple used to represent things like a vector in 4D space (w-component)
318 318 /* or just 4 values linked together
319 319 /************************************************************************************/
320 - template <class T>
320 + template<typename T>
321 321 class vec4 {
322 322 public:
323 323 vec4() : x(0), y(0), z(0), w(1) { }
  @@ -444,21 +444,21 @@
444 444 };
445 445
446 446 /// lerp between the 2 specified vectors by the specified amount
447 - template <class T>
447 + template<typename T>
448 448 inline vec4<T> lerp(const vec4<T> &u, const vec4<T> &v, T factor);
449 449 /// lerp between the 2 specified vectors by the specified amount for each component
450 - template <class T>
450 + template<typename T>
451 451 inline vec4<T> lerp(const vec4<T> &u, const vec4<T> &v, const vec4<T>& factor);
452 452 /// min/max functions
453 - template <class T>
453 + template<typename T>
454 454 inline vec4<T> min(const vec4<T> &v1, const vec4<T> &v2) {
455 455 return vec4<T>(std::min(v1.x, v2.x), std::min(v1.y, v2.y), std::min(v1.z, v2.z), std::min(v1.w, v2.w));
456 456 }
457 - template <class T>
457 + template<typename T>
458 458 inline vec4<T> max(const vec4<T> &v1, const vec4<T> &v2) {
459 459 return vec4<T>(std::max(v1.x, v2.x), std::max(v1.y, v2.y), std::max(v1.z, v2.z), std::max(v1.w, v2.w));
460 460 }
461 - template <class T>
461 + template<typename T>
462 462 inline vec4<T> normalize(vec4<T>& vector) {
463 463 vector.normalize();
464 464 return vector;