← Back to branch summary

~ubuntu-branches/ubuntu/vivid/emscripten/vivid

« back to all changes in this revision

Viewing changes to tests/bullet/Extras/glui/algebra3.h

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2013-05-02 13:11:51 UTC
  • Revision ID: package-import@ubuntu.com-20130502131151-q8dvteqr1ef2x7xz
Tags: upstream-1.4.1~20130504~adb56cb
Import upstream version 1.4.1~20130504~adb56cb

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/bullet/Extras/glui/algebra3.h
 
1
/*
 
2
 
 
3
  algebra3.cpp, algebra3.h -  C++ Vector and Matrix Algebra routines
 
4
 
 
5
  GLUI User Interface Toolkit (LGPL)
 
6
  Copyright (c) 1998 Paul Rademacher
 
7
 
 
8
  WWW:    http://sourceforge.net/projects/glui/
 
9
  Forums: http://sourceforge.net/forum/?group_id=92496
 
10
 
 
11
  This library is free software; you can redistribute it and/or
 
12
  modify it under the terms of the GNU Lesser General Public
 
13
  License as published by the Free Software Foundation; either
 
14
  version 2.1 of the License, or (at your option) any later version.
 
15
 
 
16
  This library is distributed in the hope that it will be useful,
 
17
  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
18
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
19
  Lesser General Public License for more details.
 
20
 
 
21
  You should have received a copy of the GNU Lesser General Public
 
22
  License along with this library; if not, write to the Free Software
 
23
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
24
 
 
25
*/
 
26
 
 
27
/**************************************************************************
 
28
    
 
29
  There are three vector classes and two matrix classes: vec2, vec3,
 
30
  vec4, mat3, and mat4.
 
31
 
 
32
  All the standard arithmetic operations are defined, with '*'
 
33
  for dot product of two vectors and multiplication of two matrices,
 
34
  and '^' for cross product of two vectors.
 
35
 
 
36
  Additional functions include length(), normalize(), homogenize for
 
37
  vectors, and print(), set(), apply() for all classes.
 
38
 
 
39
  There is a function transpose() for matrices, but note that it 
 
40
  does not actually change the matrix, 
 
41
 
 
42
  When multiplied with a matrix, a vector is treated as a row vector
 
43
  if it precedes the matrix (v*M), and as a column vector if it
 
44
  follows the matrix (M*v).
 
45
 
 
46
  Matrices are stored in row-major form.
 
47
 
 
48
  A vector of one dimension (2d, 3d, or 4d) can be cast to a vector
 
49
  of a higher or lower dimension.  If casting to a higher dimension,
 
50
  the new component is set by default to 1.0, unless a value is
 
51
  specified:
 
52
     vec3 a(1.0, 2.0, 3.0 );
 
53
     vec4 b( a, 4.0 );       // now b == {1.0, 2.0, 3.0, 4.0};
 
54
  When casting to a lower dimension, the vector is homogenized in
 
55
  the lower dimension.  E.g., if a 4d {X,Y,Z,W} is cast to 3d, the
 
56
  resulting vector is {X/W, Y/W, Z/W}.  It is up to the user to 
 
57
  insure the fourth component is not zero before casting.
 
58
 
 
59
  There are also the following function for building matrices:
 
60
     identity2D(), translation2D(), rotation2D(),
 
61
     scaling2D(),  identity3D(),    translation3D(),
 
62
     rotation3D(), rotation3Drad(),  scaling3D(),
 
63
     perspective3D()
 
64
 
 
65
  NOTE: When compiling for Windows, include this file first, to avoid
 
66
        certain name conflicts
 
67
 
 
68
  ---------------------------------------------------------------------
 
69
  
 
70
  Author: Jean-Francois DOUEg                   
 
71
  Revised: Paul Rademacher                                      
 
72
  Version 3.2 - Feb 1998
 
73
  Revised: Nigel Stewart (GLUI Code Cleaning)
 
74
  
 
75
**************************************************************************/
 
76
 
 
77
#ifndef GLUI_ALGEBRA3_H
 
78
#define GLUI_ALGEBRA3_H
 
79
 
 
80
#include <cmath>
 
81
#include <cstdio>
 
82
#include <cstdlib>
 
83
 
 
84
// this line defines a new type: pointer to a function which returns a
 
85
// float and takes as argument a float
 
86
typedef float (*V_FCT_PTR)(float);
 
87
 
 
88
class vec2;
 
89
class vec3;
 
90
class vec4;
 
91
class mat3;
 
92
class mat4;
 
93
 
 
94
#ifndef M_PI
 
95
#define M_PI 3.141592654
 
96
#endif
 
97
 
 
98
enum {VX, VY, VZ, VW};           // axes
 
99
enum {PA, PB, PC, PD};           // planes
 
100
enum {RED, GREEN, BLUE, ALPHA};  // colors
 
101
enum {KA, KD, KS, ES};           // phong coefficients
 
102
 
 
103
/****************************************************************
 
104
 *                                                              *
 
105
 *              2D Vector                                       *
 
106
 *                                                              *
 
107
 ****************************************************************/
 
108
 
 
109
class vec2
 
110
{
 
111
  friend class vec3;
 
112
 
 
113
protected:
 
114
 
 
115
  float n[2];
 
116
 
 
117
public:
 
118
 
 
119
  // Constructors
 
120
 
 
121
  vec2();
 
122
  vec2(float x, float y);
 
123
  vec2(const vec2 &v);                   // copy constructor
 
124
  vec2(const vec3 &v);                   // cast v3 to v2
 
125
  vec2(const vec3 &v, int dropAxis);     // cast v3 to v2
 
126
 
 
127
  // Assignment operators
 
128
 
 
129
  vec2  &operator  = (const vec2 &v);    // assignment of a vec2
 
130
  vec2  &operator += (const vec2 &v);    // incrementation by a vec2
 
131
  vec2  &operator -= (const vec2 &v);    // decrementation by a vec2
 
132
  vec2  &operator *= (float d);    // multiplication by a constant
 
133
  vec2  &operator /= (float d);    // division by a constant
 
134
 
 
135
  // special functions
 
136
 
 
137
  float  length()  const;                   // length of a vec2
 
138
  float  length2() const;                   // squared length of a vec2
 
139
  vec2  &normalize();                       // normalize a vec2
 
140
  vec2  &apply(V_FCT_PTR fct);              // apply a func. to each component
 
141
  void   set(float x, float y);             // set vector
 
142
 
 
143
  float &operator [] (int i);         // indexing
 
144
  const float &operator [] (int i) const;   // indexing
 
145
 
 
146
  // friends
 
147
 
 
148
  friend vec2  operator -  (const vec2 &v);                   // -v1
 
149
  friend vec2  operator +  (const vec2 &a, const vec2 &b);    // v1 + v2
 
150
  friend vec2  operator -  (const vec2 &a, const vec2 &b);    // v1 - v2
 
151
  friend vec2  operator *  (const vec2 &a, float d);          // v1 * 3.0
 
152
  friend vec2  operator *  (float d, const vec2 &a);          // 3.0 * v1
 
153
  friend vec2  operator *  (const mat3 &a, const vec2 &v);    // M . v
 
154
  friend vec2  operator *  (const vec2 &v, const mat3 &a);    // v . M
 
155
  friend float operator *  (const vec2 &a, const vec2 &b);    // dot product
 
156
  friend vec2  operator /  (const vec2 &a, float d);          // v1 / 3.0
 
157
  friend vec3  operator ^  (const vec2 &a, const vec2 &b);    // cross product
 
158
  friend int   operator == (const vec2 &a, const vec2 &b);    // v1 == v2 ?
 
159
  friend int   operator != (const vec2 &a, const vec2 &b);    // v1 != v2 ?
 
160
  //friend ostream& operator << (ostream& s, vec2& v);        // output to stream
 
161
  //friend istream& operator >> (istream& s, vec2& v);        // input from strm.
 
162
  friend void swap(vec2 &a, vec2 &b);                         // swap v1 & v2
 
163
  friend vec2 min_vec(const vec2 &a, const vec2 &b);          // min(v1, v2)
 
164
  friend vec2 max_vec(const vec2 &a, const vec2 &b);          // max(v1, v2)
 
165
  friend vec2 prod   (const vec2 &a, const vec2 &b);          // term by term *
 
166
};
 
167
 
 
168
/****************************************************************
 
169
 *                                                              *
 
170
 *               3D Vector                                      *
 
171
 *                                                              *
 
172
 ****************************************************************/
 
173
 
 
174
class vec3
 
175
{
 
176
  friend class vec2;
 
177
  friend class vec4;
 
178
  friend class mat3;
 
179
 
 
180
protected:
 
181
 
 
182
  float n[3];
 
183
 
 
184
public:
 
185
 
 
186
  // Constructors
 
187
 
 
188
  vec3();
 
189
  vec3(float x, float y, float z);
 
190
  vec3(const vec3 &v);               // copy constructor
 
191
  vec3(const vec2 &v);               // cast v2 to v3
 
192
  vec3(const vec2 &v, float d);      // cast v2 to v3
 
193
  vec3(const vec4 &v);               // cast v4 to v3
 
194
  vec3(const vec4 &v, int dropAxis); // cast v4 to v3
 
195
 
 
196
  // Assignment operators
 
197
 
 
198
  vec3  &operator  = (const vec3 &v);      // assignment of a vec3
 
199
  vec3  &operator += (const vec3 &v);      // incrementation by a vec3
 
200
  vec3  &operator -= (const vec3 &v);      // decrementation by a vec3
 
201
  vec3  &operator *= (float d);      // multiplication by a constant
 
202
  vec3  &operator /= (float d);      // division by a constant
 
203
 
 
204
  // special functions
 
205
 
 
206
  float  length()  const;                     // length of a vec3
 
207
  float  length2() const;                     // squared length of a vec3
 
208
  vec3&  normalize();                         // normalize a vec3
 
209
  vec3&  homogenize();                        // homogenize (div by Z)
 
210
  vec3&  apply(V_FCT_PTR fct);                // apply a func. to each component
 
211
  void   set(float x, float y, float z);      // set vector
 
212
 
 
213
  void   print(FILE *file, const char *name) const; // print vector to a file
 
214
 
 
215
 
 
216
  float &operator [] (int i);       // indexing
 
217
  const float &operator [] (int i) const; // indexing
 
218
 
 
219
  // friends
 
220
 
 
221
  friend vec3  operator -  (const vec3 &v);                 // -v1
 
222
  friend vec3  operator +  (const vec3 &a, const vec3 &b);  // v1 + v2
 
223
  friend vec3  operator -  (const vec3 &a, const vec3 &b);  // v1 - v2
 
224
  friend vec3  operator *  (const vec3 &a, float d);        // v1 * 3.0
 
225
  friend vec3  operator *  (float d, const vec3 &a);        // 3.0 * v1
 
226
  friend vec3  operator *  (const mat4 &a, const vec3 &v);  // M . v
 
227
  friend vec3  operator *  (const vec3 &v, const mat4 &a);  // v . M
 
228
  friend float operator *  (const vec3 &a, const vec3 &b);  // dot product
 
229
  friend vec3  operator /  (const vec3 &a, float d);  // v1 / 3.0
 
230
  friend vec3  operator ^  (const vec3 &a, const vec3 &b);  // cross product
 
231
  friend int   operator == (const vec3 &a, const vec3 &b);  // v1 == v2 ?
 
232
  friend int   operator != (const vec3 &a, const vec3 &b);  // v1 != v2 ?
 
233
  //friend ostream& operator << (ostream& s, vec3& v);      // output to stream
 
234
  //friend istream& operator >> (istream& s, vec3& v);      // input from strm.
 
235
  friend void swap(vec3 &a, vec3 &b);                       // swap v1 & v2
 
236
  friend vec3 min_vec(const vec3 &a, const vec3 &b);        // min(v1, v2)
 
237
  friend vec3 max_vec(const vec3 &a, const vec3 &b);        // max(v1, v2)
 
238
  friend vec3 prod(const vec3 &a, const vec3 &b);           // term by term *
 
239
 
 
240
  // necessary friend declarations
 
241
 
 
242
  friend vec2 operator * (const mat3 &a, const vec2 &v);    // linear transform
 
243
  friend vec3 operator * (const mat3 &a, const vec3 &v);    // linear transform
 
244
  friend mat3 operator * (const mat3 &a, const mat3 &b);    // matrix 3 product
 
245
};
 
246
 
 
247
/****************************************************************
 
248
 *                                                              *
 
249
 *              4D Vector                                       *
 
250
 *                                                              *
 
251
 ****************************************************************/
 
252
 
 
253
class vec4
 
254
{
 
255
  friend class vec3;
 
256
  friend class mat4;
 
257
 
 
258
protected:
 
259
 
 
260
  float n[4];
 
261
 
 
262
public:
 
263
 
 
264
  // Constructors
 
265
 
 
266
  vec4();
 
267
  vec4(float x, float y, float z, float w);
 
268
  vec4(const vec4 &v);             // copy constructor
 
269
  vec4(const vec3 &v);             // cast vec3 to vec4
 
270
  vec4(const vec3 &v, float d);    // cast vec3 to vec4
 
271
 
 
272
  // Assignment operators
 
273
 
 
274
  vec4  &operator  = (const vec4 &v);    // assignment of a vec4
 
275
  vec4  &operator += (const vec4 &v);    // incrementation by a vec4
 
276
  vec4  &operator -= (const vec4 &v);    // decrementation by a vec4
 
277
  vec4  &operator *= (float d);    // multiplication by a constant
 
278
  vec4  &operator /= (float d);    // division by a constant
 
279
 
 
280
  // special functions
 
281
 
 
282
  float  length()  const;                     // length of a vec4
 
283
  float  length2() const;                     // squared length of a vec4
 
284
  vec4  &normalize();                         // normalize a vec4
 
285
  vec4  &apply(V_FCT_PTR fct);                // apply a func. to each component
 
286
  vec4  &homogenize();
 
287
 
 
288
  void   print(FILE *file, const char *name) const; // print vector to a file
 
289
 
 
290
  void   set(float x, float y, float z, float a);                        
 
291
 
 
292
  float &operator [] (int i);             // indexing
 
293
  const float &operator [] (int i) const; // indexing
 
294
 
 
295
  // friends
 
296
 
 
297
  friend vec4  operator -  (const vec4 &v);                  // -v1
 
298
  friend vec4  operator +  (const vec4 &a, const vec4 &b);   // v1 + v2
 
299
  friend vec4  operator -  (const vec4 &a, const vec4 &b);   // v1 - v2
 
300
  friend vec4  operator *  (const vec4 &a, float d);         // v1 * 3.0
 
301
  friend vec4  operator *  (float d, const vec4 &a);         // 3.0 * v1
 
302
  friend vec4  operator *  (const mat4 &a, const vec4 &v);   // M . v
 
303
  friend vec4  operator *  (const vec4 &v, const mat4 &a);   // v . M
 
304
  friend float operator *  (const vec4 &a, const vec4 &b);   // dot product
 
305
  friend vec4  operator /  (const vec4 &a, float d);   // v1 / 3.0
 
306
  friend int   operator == (const vec4 &a, const vec4 &b);   // v1 == v2 ?
 
307
  friend int   operator != (const vec4 &a, const vec4 &b);   // v1 != v2 ?
 
308
  //friend ostream& operator << (ostream& s, vec4& v);       // output to stream
 
309
  //friend istream& operator >> (istream& s, vec4& v);       // input from strm.
 
310
  friend void swap(vec4 &a, vec4 &b);                        // swap v1 & v2
 
311
  friend vec4 min_vec(const vec4 &a, const vec4 &b);         // min(v1, v2)
 
312
  friend vec4 max_vec(const vec4 &a, const vec4 &b);         // max(v1, v2)
 
313
  friend vec4 prod   (const vec4 &a, const vec4 &b);         // term by term *
 
314
 
 
315
  // necessary friend declarations
 
316
 
 
317
  friend vec3 operator * (const mat4 &a, const vec3 &v);     // linear transform
 
318
  friend mat4 operator * (const mat4 &a, const mat4 &b);     // matrix 4 product
 
319
};
 
320
 
 
321
/****************************************************************
 
322
 *                                                              *
 
323
 *             3x3 Matrix                                       *
 
324
 *                                                              *
 
325
 ****************************************************************/
 
326
 
 
327
class mat3
 
328
{
 
329
protected:
 
330
 
 
331
  vec3 v[3];
 
332
 
 
333
public:
 
334
 
 
335
  // Constructors
 
336
 
 
337
  mat3();
 
338
  mat3(const vec3 &v0, const vec3 &v1, const vec3 &v2);
 
339
  mat3(const mat3 &m);
 
340
 
 
341
  // Assignment operators
 
342
 
 
343
  mat3 &operator  = (const mat3  &m);        // assignment of a mat3
 
344
  mat3 &operator += (const mat3  &m);        // incrementation by a mat3
 
345
  mat3 &operator -= (const mat3  &m);        // decrementation by a mat3
 
346
  mat3 &operator *= (float  d);        // multiplication by a constant
 
347
  mat3 &operator /= (float  d);        // division by a constant
 
348
 
 
349
  // special functions
 
350
 
 
351
  mat3  transpose() const;                    // transpose
 
352
  mat3  inverse() const;                      // inverse
 
353
  mat3 &apply(V_FCT_PTR fct);                 // apply a func. to each element
 
354
 
 
355
  void  print(FILE *file, const char *name ) const; // print matrix to a file
 
356
 
 
357
  void  set(const vec3 &v0, const vec3 &v1, const vec3 &v2);
 
358
 
 
359
  vec3 &operator [] (int i);       // indexing
 
360
  const vec3 &operator [] (int i) const; // indexing
 
361
 
 
362
  // friends
 
363
 
 
364
  friend mat3 operator -  (const mat3 &a);                     // -m1
 
365
  friend mat3 operator +  (const mat3 &a, const mat3 &b);      // m1 + m2
 
366
  friend mat3 operator -  (const mat3 &a, const mat3 &b);      // m1 - m2
 
367
  friend mat3 operator *  (const mat3 &a, const mat3 &b);      // m1 * m2
 
368
  friend mat3 operator *  (const mat3 &a, float d);            // m1 * 3.0
 
369
  friend mat3 operator *  (float d, const mat3 &a);            // 3.0 * m1
 
370
  friend mat3 operator /  (const mat3 &a, float d);            // m1 / 3.0
 
371
  friend int  operator == (const mat3 &a, const mat3 &b);      // m1 == m2 ?
 
372
  friend int  operator != (const mat3 &a, const mat3 &b);      // m1 != m2 ?
 
373
  //friend ostream& operator << (ostream& s, mat3& m);         // output to stream
 
374
  //friend istream& operator >> (istream& s, mat3& m);         // input from strm.
 
375
  friend void swap(mat3 &a, mat3 &b);                          // swap m1 & m2
 
376
 
 
377
  // necessary friend declarations
 
378
 
 
379
  friend vec3 operator * (const mat3 &a, const vec3 &v);     // linear transform
 
380
  friend vec2 operator * (const mat3 &a, const vec2 &v);     // linear transform
 
381
};
 
382
 
 
383
/****************************************************************
 
384
 *                                                              *
 
385
 *             4x4 Matrix                                       *
 
386
 *                                                              *
 
387
 ****************************************************************/
 
388
 
 
389
class mat4
 
390
{
 
391
protected:
 
392
 
 
393
  vec4 v[4];
 
394
 
 
395
public:
 
396
 
 
397
  // Constructors
 
398
 
 
399
  mat4();
 
400
  mat4(const vec4 &v0, const vec4 &v1, const vec4 &v2, const vec4 &v3);
 
401
  mat4(const mat4 &m);
 
402
  mat4(float a00, float a01, float a02, float a03,
 
403
       float a10, float a11, float a12, float a13,
 
404
       float a20, float a21, float a22, float a23,
 
405
       float a30, float a31, float a32, float a33 );
 
406
 
 
407
 
 
408
  // Assignment operators
 
409
 
 
410
  mat4 &operator  = (const mat4 &m);        // assignment of a mat4
 
411
  mat4 &operator += (const mat4 &m);        // incrementation by a mat4
 
412
  mat4 &operator -= (const mat4 &m);        // decrementation by a mat4
 
413
  mat4 &operator *= (float d);        // multiplication by a constant
 
414
  mat4 &operator /= (float d);        // division by a constant
 
415
 
 
416
  // special functions
 
417
 
 
418
  mat4  transpose() const;                   // transpose
 
419
  mat4  inverse() const;                     // inverse
 
420
  mat4 &apply(V_FCT_PTR fct);                // apply a func. to each element
 
421
 
 
422
  void  print(FILE *file, const char *name) const; // print matrix to a file
 
423
    
 
424
  vec4 &operator [] (int i);       // indexing
 
425
  const vec4 &operator [] (int i) const; // indexing
 
426
 
 
427
  void  swap_rows(int i, int j); // swap rows i and j
 
428
  void  swap_cols(int i, int j); // swap cols i and j
 
429
 
 
430
  // friends
 
431
 
 
432
  friend mat4 operator -  (const mat4 &a);                     // -m1
 
433
  friend mat4 operator +  (const mat4 &a, const mat4 &b);      // m1 + m2
 
434
  friend mat4 operator -  (const mat4 &a, const mat4 &b);      // m1 - m2
 
435
  friend mat4 operator *  (const mat4 &a, const mat4 &b);      // m1 * m2
 
436
  friend mat4 operator *  (const mat4 &a, float d);            // m1 * 4.0
 
437
  friend mat4 operator *  (float d, const mat4 &a);            // 4.0 * m1
 
438
  friend mat4 operator /  (const mat4 &a, float d);            // m1 / 3.0
 
439
  friend int  operator == (const mat4 &a, const mat4 &b);      // m1 == m2 ?
 
440
  friend int  operator != (const mat4 &a, const mat4 &b);      // m1 != m2 ?
 
441
  //friend ostream& operator << (ostream& s, mat4& m);         // output to stream
 
442
  //friend istream& operator >> (istream& s, mat4& m);         // input from strm.
 
443
  friend void swap(mat4 &a, mat4 &b);                          // swap m1 & m2
 
444
 
 
445
  // necessary friend declarations
 
446
 
 
447
  friend vec4 operator * (const mat4 &a, const vec4 &v);      // linear transform
 
448
  //friend vec4 operator * (const vec4& v, const mat4& a);    // linear transform
 
449
  friend vec3 operator * (const mat4 &a, const vec3 &v);      // linear transform
 
450
  friend vec3 operator * (const vec3 &v, const mat4 &a);      // linear transform
 
451
};
 
452
 
 
453
/****************************************************************
 
454
 *                                                              *
 
455
 *         2D functions and 3D functions                        *
 
456
 *                                                              *
 
457
 ****************************************************************/
 
458
 
 
459
mat3 identity2D   ();                                   // identity 2D
 
460
mat3 translation2D(const vec2 &v);                      // translation 2D
 
461
mat3 rotation2D   (const vec2 &Center, float angleDeg); // rotation 2D
 
462
mat3 scaling2D    (const vec2 &scaleVector);            // scaling 2D
 
463
mat4 identity3D   ();                                   // identity 3D
 
464
mat4 translation3D(const vec3 &v);                      // translation 3D
 
465
mat4 rotation3D   (const vec3 &Axis, float angleDeg);   // rotation 3D
 
466
mat4 rotation3Drad(const vec3 &Axis, float angleRad);   // rotation 3D
 
467
mat4 scaling3D    (const vec3 &scaleVector);            // scaling 3D
 
468
mat4 perspective3D(float d);                            // perspective 3D
 
469
 
 
470
vec3 operator * (const vec3 &v, const mat3 &a);
 
471
vec2 operator * (const vec2 &v, const mat3 &a);
 
472
vec3 operator * (const vec3 &v, const mat4 &a);
 
473
vec4 operator * (const vec4 &v, const mat4 &a);
 
474
 
 
475
#endif