algebra3.h
上传用户:gb3593
上传日期:2022-01-07
资源大小:3028k
文件大小:20k
源码类别:

游戏引擎

开发平台:

Visual C++

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