/*
* Scale a complex number by a power of two.
*/
COMPLEX *
cscale(COMPLEX *c, long n)
{
COMPLEX *r;
if (ciszero(c) || (n == 0))
return clink(c);
r = comalloc();
qfree(r->real);
qfree(r->imag);
r->real = qscale(c->real, n);
r->imag = qscale(c->imag, n);
return r;
}
QMatrix4x4 ModelInterface::getMatrix(const aiMatrix4x4* m)
{
QMatrix4x4 nodeMatrix;
if(m->IsIdentity())
return nodeMatrix;
aiQuaternion rotation;
aiVector3D position;
aiVector3D scale;
m->Decompose(scale, rotation, position);
QVector3D qscale(scale.x,scale.y, scale.z);
QVector3D qposition(position.x, position.y, position.z);
QQuaternion qrotation(rotation.w, rotation.x, rotation.y, rotation.z);
if(!qscale.isNull())
nodeMatrix.scale(qscale);
if(!qposition.isNull())
nodeMatrix.translate(qposition);
if(!qrotation.isNull())
nodeMatrix.rotate(qrotation);
return nodeMatrix;
}
/* ************************************************************
PROCEDURE qlmul : LORENTZ SCALE z = D(x)y (full version)
z=D(x)y = [x'*y / sqrt(2); mu * x(2:n) + rdetx * y(2:n)],
where mu = (z(1)+rdetx*y1) / (x(1)+ sqrt(2) * rdetx)
INPUT
x,y - full n x 1
rdetx - sqrt(det(x))
n - order of x,y,z.
OUTPUT
z - full n x 1. Let z := D(x)y.
************************************************************ */
void qlmul(double *z,const double *x,const double *y,
const double rdetx,const int n)
{
double mu;
mu = qscale(z, x,y,rdetx,n);
addscalarmul(z,mu,x,n);
}
/*
* Square a complex number.
*/
COMPLEX *
csquare(COMPLEX *c)
{
COMPLEX *r;
NUMBER *q1, *q2;
if (ciszero(c))
return clink(&_czero_);
if (cisrunit(c))
return clink(&_cone_);
if (cisiunit(c))
return clink(&_cnegone_);
r = comalloc();
if (cisreal(c)) {
qfree(r->real);
r->real = qsquare(c->real);
return r;
}
if (cisimag(c)) {
qfree(r->real);
q1 = qsquare(c->imag);
r->real = qneg(q1);
qfree(q1);
return r;
}
q1 = qsquare(c->real);
q2 = qsquare(c->imag);
qfree(r->real);
r->real = qsub(q1, q2);
qfree(q1);
qfree(q2);
qfree(r->imag);
q1 = qmul(c->real, c->imag);
r->imag = qscale(q1, 1L);
qfree(q1);
return r;
}
