---

algebra3.h

Go to the documentation of this file.

//                          algebra3.h                                  //
//                             -------------------                      //
//    begin                : 1998                                       //
//    copyright            : Jean-Francois DOUE                         //
//    modified             : cbaudry (mainly removed global funcs)      //
//    email                : cedric.baudry@tremplin-utc.fr              //

//                                                                        //
//   This program is free software; you can redistribute it and/or modify //
//   it under the terms of the GNU General Public License as published by //
//   the Free Software Foundation, version 2 of the License               //
//                                                                        //

/*

  algebra3.cpp, algebra3.h -  C++ Vector and Matrix Algebra routines           

  There are two vector classes and two matrix classes: vec3, vec4, mat3, and mat4.

  All the standard arithmetic operations are defined, with '*'
  for dot product of two vectors and multiplication of two matrices,
  and '^' for cross product of two vectors.

  Additional functions include length(), normalize(), homogenize for
  vectors, and print(), set(), apply() for all classes.

  There is a function transpose() for matrices, but note that it 
  does not actually change the matrix, 

  When multiplied with a matrix, a vector is treated as a row vector
  if it precedes the matrix (v*M), and as a column vector if it
  follows the matrix (M*v).

  Matrices are stored in row-major form.

  A vector of one dimension (3d, or 4d) can be cast to a vector
  of a higher or lower dimension.  If casting to a higher dimension,
  the new component is set by default to 1.0, unless a value is
  specified:
     vec3 a(1.0, 2.0, 3.0 );
     vec4 b( a, 4.0 );       // now b == {1.0, 2.0, 3.0, 4.0};
  When casting to a lower dimension, the vector is homogenized in
  the lower dimension.  E.g., if a 4d {X,Y,Z,W} is cast to 3d, the
  resulting vector is {X/W, Y/W, Z/W}.  It is up to the user to 
  insure the fourth component is not zero before casting.

  There are also the following function for building matrices:
     identity3D(), translation3D(),
     rotation3D(), rotation3Drad(),
     scaling3D(),  perspective3D()

  NOTE: When compiling for Windows, include this file first, to avoid
        certain name conflicts
 
*/

#pragma once

#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include "macros.h"

#ifdef VEC_ERROR_FATAL
#ifndef VEC_ERROR
#define VEC_ERROR(E) { printf( "VERROR %s\n", E ); exit(1); }
#endif
#else
#ifndef VEC_ERROR
#define VEC_ERROR(E) { printf( "VERROR %s\n", E ); }
#endif
#endif

class vec3;
class vec4;
class mat3;
class mat4;

enum
{ VX, VY, VZ, VW };             
enum
{ PA, PB, PC, PD };             
enum
{ RED, GREEN, BLUE, ALPHA };    
enum
{ KA, KD, KS, ES };             

class vec3
{
  protected:
    float n[3];

  public:

    // Constructors

      vec3 (void);
      vec3 (const float x, const float y, const float z);
      vec3 (const float d);
      vec3 (const vec3 & v);    
      vec3 (const vec4 & v);    
      vec3 (const vec4 & v, int dropAxis); 

    // Read accessors

    float x ();
    float y ();
    float z ();
    float *px ()
    {
        return n;
    };
    float *py ()
    {
        return n + 1;
    };
    float *pz ()
    {
        return n + 2;
    };

    // Assignment operators

    vec3 & operator  = (const vec3 & v); 
    vec3 & operator += (const vec3 & v); 
    vec3 & operator -= (const vec3 & v); 
    vec3 & operator *= (const float d); 
    vec3 & operator /= (const float d); 
    float &operator [] (int i); 

    // Special functions

    float length (void);        
    float length2 (void);       
    vec3 & normalize (void);    
    void set (float x, float y, float z); 
    void print (FILE * file, char *name); 

    // Unary and binary operators

    vec3 operator - ();         
    vec3 operator + (const vec3 & a); 
    vec3 operator - (const vec3 & b); 
    vec3 operator * (const float d); 
    vec3 operator * (mat4 & m); 
    float operator * (const vec3 & a); 
    vec3 operator / (const float d); 
    vec3 operator ^ (const vec3 & b); 
    int operator == (const vec3 & b); 
    int operator != (const vec3 & b); 

    // Static methods

    static void swap (vec3 & a, vec3 & b); 
    static vec3 min (const vec3 & a, const vec3 & b); 
    static vec3 max (const vec3 & a, const vec3 & b); 
    static vec3 prod (const vec3 & a, const vec3 & b); 

    // Friends

    friend class vec4;
    friend class mat3;
    friend class mat4;

};

class vec4
{
  protected:
    float n[4];

  public:

    // Constructors

      vec4 (void);
      vec4 (const float x, const float y, const float z, const float w);
      vec4 (const float d);
      vec4 (const vec4 & v);    
      vec4 (const vec3 & v);    
      vec4 (const vec3 & v, const float d); 

    // Assignment operators

      vec4 & operator	= (const vec4 & v); 
      vec4 & operator += (const vec4 & v); 
      vec4 & operator -= (const vec4 & v); 
      vec4 & operator *= (const float d); 
      vec4 & operator /= (const float d); 
    float &operator [] (int i); 

    // Special functions

    float length (void);        
    float length2 (void);       
      vec4 & normalize (void);  
      vec4 & homogenize (void); 
    void print (FILE * file, char *name); 
    void set (float x, float y, float z, float a);

    // Unary and binary operators

    vec4 operator - ();         
    vec4 operator + (const vec4 & b); 
    vec4 operator - (const vec4 & b); 
    vec4 operator * (const float d); 
    vec4 operator * (mat4 & a); 
    float operator * (const vec4 & a); 
    vec4 operator / (const float d); 
    int operator == (const vec4 & a); 
    int operator != (const vec4 & a); 

    // Static methods

    static void swap (vec4 & a, vec4 & b); 
    static vec4 min (const vec4 & a, const vec4 & b); 
    static vec4 max (const vec4 & a, const vec4 & b); 
    static vec4 prod (const vec4 & a, const vec4 & b); 

    // Friends

    friend class vec3;
    friend class mat4;

};

class mat3
{
  protected:
    vec3 v[3];

  public:

    // Constructors

    mat3 (void);
      mat3 (const vec3 & v0, const vec3 & v1, const vec3 & v2);
      mat3 (const float d);
      mat3 (const mat3 & m);

    // Assignment operators

      mat3 & operator	= (const mat3 & m); 
      mat3 & operator += (const mat3 & m); 
      mat3 & operator -= (const mat3 & m); 
      mat3 & operator *= (const float d); 
      mat3 & operator /= (const float d); 
      vec3 & operator [] (int i); 

    // special functions

    mat3 transpose (void);      
    mat3 inverse (void);        
    void print (FILE * file, char *name); 
    void set (const vec3 & v0, const vec3 & v1, const vec3 & v2);

    // Operators

    mat3 operator - ();         
    mat3 operator + (const mat3 & b); 
    mat3 operator - (const mat3 & b); 
    mat3 operator * (mat3 & b); 
    mat3 operator * (const float d); 
    mat3 operator / (const float d); 
    int operator == (const mat3 & b); 
    int operator != (const mat3 & b); 
    vec3 operator * (const vec3 & v); 

    // Static methods

    static void swap (mat3 & a, mat3 & b); 
    static mat3 identity (void);

};

class mat4
{
  protected:
    vec4 v[4];

  public:

    // Constructors

    mat4 (void);
      mat4 (const vec4 & v0, const vec4 & v1, const vec4 & v2, const vec4 & v3);
      mat4 (const float d);
      mat4 (const mat4 & m);
      mat4 (const float a00, const float a01, const float a02, const float a03,
            const float a10, const float a11, const float a12, const float a13,
            const float a20, const float a21, const float a22, const float a23, const float a30, const float a31, const float a32, const float a33);

    // Assignment operators

      mat4 & operator	= (const mat4 & m); 
      mat4 & operator += (const mat4 & m); 
      mat4 & operator -= (const mat4 & m); 
      mat4 & operator *= (const float d); 
      mat4 & operator /= (const float d); 
      vec4 & operator [] (int i); 

    // Special functions

    mat4 transpose (void);      
    mat4 inverse (void);        
    void print (FILE * file, char *name); 
    void swap_rows (int i, int j); 
    void swap_cols (int i, int j); 

    // Operators

    mat4 operator - ();         
    mat4 operator + (const mat4 & b); 
    mat4 operator - (const mat4 & b); 
    mat4 operator * (mat4 & b); 
    mat4 operator * (const float d); 
    mat4 operator / (const float d); 
    int operator == (const mat4 & b); 
    int operator != (const mat4 & b); 
    vec4 operator * (const vec4 & v); 
    vec3 operator * (const vec3 & v); 

    // Static methods

    static void swap (mat4 & a, mat4 & b); 

    // Transformations

    static mat4 identity3D (void); 
    static mat4 translation3D (vec3 & v); 
    static mat4 rotation3D (vec3 & Axis, const float angleDeg); 
    static mat4 rotation3Drad (vec3 & Axis, const float angleRad); 
    static mat4 scaling3D (vec3 & scaleVector); 
    static mat4 perspective3D (const float d); 

};

---