dada.cpp

Go to the documentation of this file.

/*  Dada
 *  Copyright (C) 2005 David Griffiths <dave@pawfal.org>
 *
 *  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; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/ 
#include "dada.h"

using namespace Fluxus;

static const int SINCOS_TABLESIZE = 2048;
static float SinTab[SINCOS_TABLESIZE];
static float CosTab[SINCOS_TABLESIZE];
static const float SINCOS_LOOKUP=SINCOS_TABLESIZE/(float)TWO_PI;


float Fluxus::RandFloat()
{
    return rand()%10000/10000.0f;
}

float Fluxus::RandRange(float L, float H)
{
    return ((rand()%10000/10000.0f)*(H-L))+L;
}

void Fluxus::InitDada()
{
    for (int n=0; n<SINCOS_TABLESIZE; n++)
    {
        float a=n*(TWO_PI/(float)SINCOS_TABLESIZE);
        SinTab[n]=sin(a);
        CosTab[n]=cos(a);
    }
}

void Fluxus::dSinCos(float a, float &s, float &c)
{
    int Index=(int)rint(a*SINCOS_LOOKUP)&SINCOS_TABLESIZE-1;
    s=SinTab[Index];
    c=CosTab[Index];    
}

dVector &dVector::operator=(dVector const &rhs)
{
    x=rhs.x; y=rhs.y; z=rhs.z; w=rhs.w;
    return *this;
}

dVector dVector::operator+(dVector const &rhs) const
{
    dVector t;
    t.x=x+rhs.x; t.y=y+rhs.y; t.z=z+rhs.z; //t.w=w+rhs.w;
    return t;
}

dVector dVector::operator-(dVector const &rhs) const
{
    dVector t;
    t.x=x-rhs.x; t.y=y-rhs.y; t.z=z-rhs.z; //t.w=w-rhs.w;
    return t;
}

dVector dVector::operator*(dVector const &rhs) const
{
    dVector t;
    t.x=x*rhs.x; t.y=y*rhs.y; t.z=z*rhs.z; //t.w=w+rhs.w;
    return t;
}

dVector dVector::operator/(dVector const &rhs) const
{
    dVector t;
    t.x=x/rhs.x; t.y=y/rhs.y; t.z=z/rhs.z; //t.w=w-rhs.w;
    return t;
}

dVector dVector::operator+(float rhs) const
{
    dVector t;
    t.x=x+rhs; t.y=y+rhs; t.z=z+rhs; //t.w=w*rhs;
    return t;
}

dVector dVector::operator-(float rhs) const
{
    dVector t;
    t.x=x-rhs; t.y=y-rhs; t.z=z-rhs; //t.w=w/rhs;
    return t;
}

dVector dVector::operator*(float rhs) const
{
    dVector t;
    t.x=x*rhs; t.y=y*rhs; t.z=z*rhs; //t.w=w*rhs;
    return t;
}

dVector dVector::operator/(float rhs) const
{
    dVector t;
    t.x=x/rhs; t.y=y/rhs; t.z=z/rhs; //t.w=w/rhs;
    return t;
}

dVector &dVector::operator+=(dVector const &rhs)
{
    x+=rhs.x; y+=rhs.y; z+=rhs.z; //w+=rhs.w;
    return *this;
}

dVector &dVector::operator-=(dVector const &rhs)
{
    x-=rhs.x; y-=rhs.y; z-=rhs.z; //w-=rhs.w;
    return *this;
}

dVector &dVector::operator*=(float rhs)
{
    x*=rhs; y*=rhs; z*=rhs; //w*=rhs;
    return *this;
}

dVector &dVector::operator/=(float rhs)
{
    if (rhs) {x/=rhs; y/=rhs; z/=rhs;}// w/=rhs;}
    return *this;
}

float dVector::dot(dVector const &rhs) const
{
    return x*rhs.x+y*rhs.y+z*rhs.z;
}

dVector dVector::cross(dVector const &rhs) const
{
    return dVector(y*rhs.z - z*rhs.y,
                      z*rhs.x - x*rhs.z,
                      x*rhs.y - y*rhs.x);
}

dVector dVector::reflect(dVector const &rhs) const
{
    float vdn=dot(rhs)*2.0f;
    return (*this)-rhs*vdn;
}

float dVector::dist(dVector const &rhs) const
{
    return sqrt((rhs.x-x)*(rhs.x-x)+
                (rhs.y-y)*(rhs.y-y)+
                (rhs.z-z)*(rhs.z-z));
}

float dVector::distsq(dVector const &rhs) const
{
    return (rhs.x-x)*(rhs.x-x)+
           (rhs.y-y)*(rhs.y-y)+
           (rhs.z-z)*(rhs.z-z);
}

void dVector::get_euler(float &rx, float &ry, float &rz) const
{
    if (z==0) rx=0;
    else rx=atan(y/z)*RAD_CONV;
    if (x==0) ry=0;
    else ry=atan(z/x)*RAD_CONV;
    if (y==0) rz=0;
    else rz=atan(x/y)*RAD_CONV;
}

float dVector::mag()
{
    return dist(dVector(0,0,0));
}

dVector Fluxus::operator-(dVector rhs)
{
    return dVector(-rhs.x,-rhs.y,-rhs.z);
}

ostream &Fluxus::operator<<(ostream &os, dVector const &om)
{
    os<<om.x<<" "<<om.y<<" "<<om.z<<" "<<om.w<<" ";
    return os;
}

istream &Fluxus::operator>>(istream &is, dVector &om)
{
    is>>om.x>>om.y>>om.z>>om.w;
    return is;
}

void dVector::get_rot(float m[16],dVector up)
{
    dVector a,b,c;
    a.x=this->x; a.y=this->y; a.z=this->z;
    a.normalise();
    if (a==up) a.x+=0.01;
    b=a.cross(up);
    b.normalise();
    c=b.cross(a);
    c.normalise();
    
    for (int n=0; n<16; n++)
    {
        m[n]=0;
    }

    m[15]=1;

    m[0]=a.x; m[1]=a.y; m[2]=a.z;   
    m[4]=b.x; m[5]=b.y; m[6]=b.z;   
    m[8]=c.x; m[9]=c.y; m[10]=c.z;
}

bool dVector::feq(const dVector &other, float epsilon)
{
    return (fabs(x-other.x)<epsilon && fabs(y-other.y)<epsilon && fabs(z-other.z)<epsilon);
}


dColour &dColour::operator=(dColour const &rhs)
{
    r=rhs.r; g=rhs.g; b=rhs.b; a=rhs.a;
    return *this;
}

dColour dColour::operator+(dColour const &rhs) const
{
    dColour t;
    t.r=r+rhs.r; t.g=g+rhs.g; t.b=b+rhs.b; t.a=a+rhs.a;
    return t;
}

dColour dColour::operator-(dColour const &rhs) const
{
    dColour t;
    t.r=r-rhs.r; t.g=g-rhs.g; t.b=b-rhs.b; t.a=a-rhs.a;
    return t;
}

dColour dColour::operator*(dColour const &rhs) const
{
    dColour t;
    t.r=r*rhs.r; t.g=g*rhs.g; t.b=b*rhs.b; t.a=a*rhs.a;
    return t;
}

dColour dColour::operator/(dColour const &rhs) const
{
    dColour t;
    t.r=r/rhs.r; t.g=g/rhs.g; t.b=b/rhs.b; t.a=a/rhs.a;
    return t;
}

dColour dColour::operator+(float rhs) const
{
    dColour t;
    t.r=r+rhs; t.g=g+rhs; t.b=b+rhs; t.a=a+rhs;
    return t;
}

dColour dColour::operator-(float rhs) const
{
    dColour t;
    t.r=r-rhs; t.g=g-rhs; t.b=b-rhs; t.a=a-rhs;
    return t;
}

dColour dColour::operator*(float rhs) const
{
    dColour t;
    t.r=r*rhs; t.g=g*rhs; t.b=b*rhs; t.a=a*rhs;
    return t;
}

dColour dColour::operator/(float rhs) const
{
    dColour t;
    t.r=r/rhs; t.g=g/rhs; t.b=b/rhs; t.a=a/rhs;
    return t;
}

dColour &dColour::operator+=(dColour const &rhs)
{
    r+=rhs.r; g+=rhs.g; b+=rhs.b; a+=rhs.a;
    return *this;
}

dColour &dColour::operator-=(dColour const &rhs)
{
    r-=rhs.r; g-=rhs.g; b-=rhs.b; a-=rhs.a;
    return *this;
}

dColour &dColour::operator*=(float rhs)
{
    r*=rhs; g*=rhs; b*=rhs; a*=rhs;
    return *this;
}

dColour &dColour::operator/=(float rhs)
{
    if (rhs) {r/=rhs; g/=rhs; b/=rhs; a/=rhs;}
    return *this;
}

ostream &Fluxus::operator<<(ostream &os, dColour const &om)
{
    os<<"r="<<om.r<<" g="<<om.g<<" b="<<om.b<<" a="<<om.a<<" ";
    return os;
}


dVertex const &dVertex::operator=(dVertex const &rhs)
{
    point=rhs.point;
    normal=rhs.normal;
    col=rhs.col;
    s=rhs.s;
    t=rhs.t;
    return rhs;
}

ostream &Fluxus::operator<<(ostream &os, dVertex const &v)
{
    os<<"Vertex : p="<<v.point<<" n="<<v.normal<<v.col<<" "<<v.s<<" "<<v.t<<endl;
    return os;
}


dMatrix::dMatrix(float m00, float m10, float m20, float m30, 
            float m01, float m11, float m21, float m31, 
            float m02, float m12, float m22, float m32, 
            float m03, float m13, float m23, float m33)
{
    m[0][0]=m00; m[1][0]=m10; m[2][0]=m20; m[3][0]=m30;
    m[0][1]=m01; m[1][1]=m11; m[2][1]=m21; m[3][1]=m31;
    m[0][2]=m02; m[1][2]=m12; m[2][2]=m22; m[3][2]=m32;
    m[0][3]=m03; m[1][3]=m13; m[2][3]=m23; m[3][3]=m33;
}

void dMatrix::init()
{
    zero();
    m[0][0]=m[1][1]=m[2][2]=m[3][3]=1;
}

void dMatrix::zero()
{
    memset(m,0,sizeof(float)*16);
}

const dMatrix &dMatrix::operator=(dMatrix const &rhs)
{
    m[0][0]=rhs.m[0][0]; m[0][1]=rhs.m[0][1]; m[0][2]=rhs.m[0][2]; m[0][3]=rhs.m[0][3];
    m[1][0]=rhs.m[1][0]; m[1][1]=rhs.m[1][1]; m[1][2]=rhs.m[1][2]; m[1][3]=rhs.m[1][3];
    m[2][0]=rhs.m[2][0]; m[2][1]=rhs.m[2][1]; m[2][2]=rhs.m[2][2]; m[2][3]=rhs.m[2][3];
    m[3][0]=rhs.m[3][0]; m[3][1]=rhs.m[3][1]; m[3][2]=rhs.m[3][2]; m[3][3]=rhs.m[3][3];
    return rhs;
}

dMatrix dMatrix::operator+(dMatrix const &rhs) const
{
    dMatrix t;
    for (int i=0; i<4; i++)
    {
        for (int j=0; j<4; j++)
        {
            t.m[i][j]=m[i][j]+rhs.m[i][j];
        }
    }
    return t;
}

dMatrix dMatrix::operator-(dMatrix const &rhs) const
{
    dMatrix t;
    for (int i=0; i<4; i++)
    {
        for (int j=0; j<4; j++)
        {
            t.m[i][j]=m[i][j]-rhs.m[i][j];
        }
    }
    return t;
}

dMatrix dMatrix::operator*(dMatrix const &rhs) const
{
    //dMatrix t;
    //for (int i=0; i<4; i++)
    //    for (int j=0; j<4; j++)
    //        t.m[i][j]=m[i][0]*rhs.m[0][j]+
    //                  m[i][1]*rhs.m[1][j]+
    //                  m[i][2]*rhs.m[2][j]+
    //                  m[i][3]*rhs.m[3][j];

    dMatrix t;
    /*for (int i=0; i<4; i++)
        for (int j=0; j<4; j++)
    t.m[i][j]=m[0][j]*rhs.m[i][0]+m[1][j]*rhs.m[i][1]+m[2][j]*rhs.m[i][2]+m[3][j]*rhs.m[i][3];
    */

    t.m[0][0]=m[0][0]*rhs.m[0][0]+m[1][0]*rhs.m[0][1]+m[2][0]*rhs.m[0][2]+m[3][0]*rhs.m[0][3];
    t.m[0][1]=m[0][1]*rhs.m[0][0]+m[1][1]*rhs.m[0][1]+m[2][1]*rhs.m[0][2]+m[3][1]*rhs.m[0][3];
    t.m[0][2]=m[0][2]*rhs.m[0][0]+m[1][2]*rhs.m[0][1]+m[2][2]*rhs.m[0][2]+m[3][2]*rhs.m[0][3];
    t.m[0][3]=m[0][3]*rhs.m[0][0]+m[1][3]*rhs.m[0][1]+m[2][3]*rhs.m[0][2]+m[3][3]*rhs.m[0][3];

    t.m[1][0]=m[0][0]*rhs.m[1][0]+m[1][0]*rhs.m[1][1]+m[2][0]*rhs.m[1][2]+m[3][0]*rhs.m[1][3];
    t.m[1][1]=m[0][1]*rhs.m[1][0]+m[1][1]*rhs.m[1][1]+m[2][1]*rhs.m[1][2]+m[3][1]*rhs.m[1][3];
    t.m[1][2]=m[0][2]*rhs.m[1][0]+m[1][2]*rhs.m[1][1]+m[2][2]*rhs.m[1][2]+m[3][2]*rhs.m[1][3];
    t.m[1][3]=m[0][3]*rhs.m[1][0]+m[1][3]*rhs.m[1][1]+m[2][3]*rhs.m[1][2]+m[3][3]*rhs.m[1][3];

    t.m[2][0]=m[0][0]*rhs.m[2][0]+m[1][0]*rhs.m[2][1]+m[2][0]*rhs.m[2][2]+m[3][0]*rhs.m[2][3];
    t.m[2][1]=m[0][1]*rhs.m[2][0]+m[1][1]*rhs.m[2][1]+m[2][1]*rhs.m[2][2]+m[3][1]*rhs.m[2][3];
    t.m[2][2]=m[0][2]*rhs.m[2][0]+m[1][2]*rhs.m[2][1]+m[2][2]*rhs.m[2][2]+m[3][2]*rhs.m[2][3];
    t.m[2][3]=m[0][3]*rhs.m[2][0]+m[1][3]*rhs.m[2][1]+m[2][3]*rhs.m[2][2]+m[3][3]*rhs.m[2][3];

    t.m[3][0]=m[0][0]*rhs.m[3][0]+m[1][0]*rhs.m[3][1]+m[2][0]*rhs.m[3][2]+m[3][0]*rhs.m[3][3];
    t.m[3][1]=m[0][1]*rhs.m[3][0]+m[1][1]*rhs.m[3][1]+m[2][1]*rhs.m[3][2]+m[3][1]*rhs.m[3][3];
    t.m[3][2]=m[0][2]*rhs.m[3][0]+m[1][2]*rhs.m[3][1]+m[2][2]*rhs.m[3][2]+m[3][2]*rhs.m[3][3];
    t.m[3][3]=m[0][3]*rhs.m[3][0]+m[1][3]*rhs.m[3][1]+m[2][3]*rhs.m[3][2]+m[3][3]*rhs.m[3][3];

    return t;
}

dMatrix dMatrix::operator/(dMatrix const &rhs) const
{
    dMatrix t;
    for (int i=0; i<4; i++)
    {
        for (int j=0; j<4; j++)
        {
            t.m[i][j]=m[i][0]/rhs.m[0][j]+
                      m[i][1]/rhs.m[1][j]+
                      m[i][2]/rhs.m[2][j]+
                      m[i][3]/rhs.m[3][j];
        }
    }
    return t;
}

dMatrix dMatrix::operator+(float rhs) const
{
    dMatrix t;
    for (int i=0; i<4; i++)
    {
        for (int j=0; j<4; j++)
        {
            t.m[i][j]=m[i][j]+rhs;
        }
    }
    return t;
}

dMatrix dMatrix::operator-(float rhs) const
{
    dMatrix t;
    for (int i=0; i<4; i++)
    {
        for (int j=0; j<4; j++)
        {
            t.m[i][j]=m[i][j]-rhs;
        }
    }
    return t;
}

dMatrix dMatrix::operator*(float rhs) const
{
    dMatrix t;
    for (int i=0; i<4; i++)
    {
        for (int j=0; j<4; j++)
        {
            t.m[i][j]=m[i][j]*rhs;
        }
    }
    return t;
}

dMatrix dMatrix::operator/(float rhs) const
{
    dMatrix t;
    for (int i=0; i<4; i++)
    {
        for (int j=0; j<4; j++)
        {
            t.m[i][j]=m[i][j]/rhs;
        }
    }
    return t;
}

dMatrix &dMatrix::operator+=(dMatrix const &rhs)
{
    for (int i=0; i<4; i++)
    {
        for (int j=0; j<4; j++)
        {
            m[i][j]+=rhs.m[i][j];
        }
    }
    return *this;
}

dMatrix &dMatrix::operator-=(dMatrix const &rhs)
{
    for (int i=0; i<4; i++)
    {
        for (int j=0; j<4; j++)
        {
            m[i][j]-=rhs.m[i][j];
        }
    }
    return *this;
}

dMatrix &dMatrix::operator*=(dMatrix const &rhs)
{
    *this=*this*rhs;
    return *this;
}

dMatrix &dMatrix::operator/=(dMatrix const &rhs)
{
    *this=*this/rhs;
    return *this;
}

dMatrix &dMatrix::translate(float x, float y, float z)
{
    dMatrix t;
    t.m[3][0]=x;
    t.m[3][1]=y;
    t.m[3][2]=z;
    *this=*this*t;
    return *this;

}

dMatrix &dMatrix::translate(dVector &tr)
{
    dMatrix t;
    t.m[3][0]=tr.x;
    t.m[3][1]=tr.y;
    t.m[3][2]=tr.z;
    *this=*this*t;
    return *this;

}

void dMatrix::settranslate(dVector &tr)
{
    m[3][0]=tr.x;
    m[3][1]=tr.y;
    m[3][2]=tr.z;
}

dVector dMatrix::gettranslate() const
{
    return dVector(m[3][0],m[3][1],m[3][2]);
}

//#define USE_FAST_SINCOS

dMatrix &dMatrix::rotxyz(float x,float y,float z)
{
    dMatrix t;
    if (x)
    {
        x*=0.017453292;
        
        #ifdef USE_FAST_SINCOS
        float sx,cx;
        dSinCos(x,sx,cx);
        #else
        float sx=sin(x);
        float cx=cos(x);
        #endif
        
        t.m[1][1]=cx;
        t.m[2][1]=-sx;
        t.m[1][2]=sx;
        t.m[2][2]=cx;
        *this=*this*t;
    }
    
    if (y)
    {
        y*=0.017453292;
        
        #ifdef USE_FAST_SINCOS
        float sy,cy;
        dSinCos(y,sy,cy);
        #else
        float sy=sin(y);
        float cy=cos(y);
        #endif
        
        t.init();
        t.m[0][0]=cy;
        t.m[2][0]=-sy;
        t.m[0][2]=sy;
        t.m[2][2]=cy;
        *this=*this*t;
    }

    if (z)
    {
        z*=0.017453292;
        
        #ifdef USE_FAST_SINCOS
        float sz,cz;
        dSinCos(z,sz,cz);
        #else
        float sz=sin(z);
        float cz=cos(z);
        #endif
        
        t.init();
        t.m[0][0]=cz;
        t.m[1][0]=-sz;
        t.m[0][1]=sz;
        t.m[1][1]=cz;
        *this=*this*t;
    }

    return *this;
}

dMatrix &dMatrix::rotx(float a)
{
    a*=0.017453292;
    dMatrix t;

    t.m[1][1]=cos(a);
    t.m[2][1]=-sin(a);
    t.m[1][2]=sin(a);
    t.m[2][2]=cos(a);

    *this=*this*t;
    return *this;
}

dMatrix &dMatrix::roty(float a)
{
    a*=0.017453292;
    dMatrix t;

    t.m[0][0]=cos(a);
    t.m[2][0]=-sin(a);
    t.m[0][2]=sin(a);
    t.m[2][2]=cos(a);

    *this=*this*t;
    return *this;
}

dMatrix &dMatrix::rotz(float a)
{
    a*=0.017453292;
    dMatrix t;

    t.m[0][0]=cos(a);
    t.m[1][0]=-sin(a);
    t.m[0][1]=sin(a);
    t.m[1][1]=cos(a);

    *this=*this*t;
    return *this;
}

dMatrix &dMatrix::scale(float x, float y, float z)
{
    dMatrix t;

    t.m[0][0]=x;
    t.m[1][1]=y;
    t.m[2][2]=z;

    *this=*this*t;
    return *this;
}

dVector dMatrix::transform(dVector const &p) const
{
    dVector t;
    t.x=p.x*m[0][0] + p.y*m[1][0] + p.z*m[2][0] + p.w*m[3][0];
    t.y=p.x*m[0][1] + p.y*m[1][1] + p.z*m[2][1] + p.w*m[3][1];
    t.z=p.x*m[0][2] + p.y*m[1][2] + p.z*m[2][2] + p.w*m[3][2];
    t.w=p.x*m[0][3] + p.y*m[1][3] + p.z*m[2][3] + p.w*m[3][3];
    return t;
}

dVector dMatrix::transform_persp(dVector const &p) const
{
    dVector t;
    t.x=p.x*m[0][0] + p.y*m[1][0] + p.z*m[2][0] + p.w*m[3][0];
    t.y=p.x*m[0][1] + p.y*m[1][1] + p.z*m[2][1] + p.w*m[3][1];
    t.z=p.x*m[0][2] + p.y*m[1][2] + p.z*m[2][2] + p.w*m[3][2];
    t.w=p.x*m[0][3] + p.y*m[1][3] + p.z*m[2][3] + p.w*m[3][3];
    t.homog();
    return t;
}

dVertex dMatrix::transform(dVertex const &p) const
{
    dVertex t=p;
    t.point=transform(p.point);
    t.normal=transform_no_trans(p.normal);
    return t;
}

dVector dMatrix::transform_no_trans(dVector const &p) const
{
    dVector t;
    t.x=p.x*m[0][0] + p.y*m[1][0] + p.z*m[2][0];
    t.y=p.x*m[0][1] + p.y*m[1][1] + p.z*m[2][1];
    t.z=p.x*m[0][