Vadimgl

11-21-2010, 01:48 PM

Hello everybody. I'm now learning mathematical basics of perspective projection and camera positioning. I want to make my own gluLookAt function, which I did, but it is not doing the task it should do. So a few questions about this.

Firstly OpenGl has model-viev matrix known as current vertex transformation: CT = V*M; To add some affine transformation to vertexes I do this: CT = CT * MNew - which works fine in my program. But how do I add new camera transformation? Is it done in this way: CT = VNew * CT? How do I need to apply my new camera transformation, setted by matrix V? Doing so in my program it functions somewhat strange...

If apply new transformation like this:

TVector3D eye = {0, 0, 1};

TVector3D look = {0, 0, 0};

TVector3D up = {0, 1, 0};

LookAt(eye, look, up);

- my program results in simple picture zooming.

if apply this:

TVector3D eye = {0, 0, -1}; //notice sign -

TVector3D look = {0, 0, 0};

TVector3D up = {0, 1, 0};

LookAt(eye, look, up);

the new image is turned in some different way, it is like it was mirrored, turned in 90 degrees and zoomed out a little bit.

Here is the code for my function LookAt:

void LookAt(TVector3D eye, TVector3D look, TVector3D up)

{

//here i'm calculating this:

//n = eye - look;

//u = up x n;

//v = n x u;

TVector3D n, u, v;

Diff(eye, look, n);

VectMult(up, n, u);

Normalize(&n);

Normalize(&u);

VectMult(n, u, v);

float x, y, z, c;

//Now i'm calculating this: CT = V * CT;

x = u.x * CT[0][0] + u.y * CT[1][0] + u.z * CT[2][0];

y = u.x * CT[0][1] + u.y * CT[1][1] + u.z * CT[2][1];

z = u.x * CT[0][2] + u.y * CT[1][2] + u.z * CT[2][2];

c = u.x * CT[0][3] + u.y * CT[1][3] + u.z * CT[2][3] - (eye.x * u.x + eye.y * u.y + eye.z * u.z);

CT[0][0] = x;

CT[0][1] = y;

CT[0][2] = z;

CT[0][3] = c;

x = v.x * CT[0][0] + v.y * CT[1][0] + v.z * CT[2][0];

y = v.x * CT[0][1] + v.y * CT[1][1] + v.z * CT[2][1];

z = v.x * CT[0][2] + v.y * CT[1][2] + v.z * CT[2][2];

c = v.x * CT[0][3] + v.y * CT[1][3] + v.z * CT[2][3] - (eye.x * v.x + eye.y * v.y + eye.z * v.z);

CT[1][0] = x;

CT[1][1] = y;

CT[1][2] = z;

CT[1][3] = c;

x = n.x * CT[0][0] + n.y * CT[1][0] + n.z * CT[2][0];

y = n.x * CT[0][1] + n.y * CT[1][1] + n.z * CT[2][1];

z = n.x * CT[0][2] + n.y * CT[1][2] + n.z * CT[2][2];

c = n.x * CT[0][3] + n.y * CT[1][3] + n.z * CT[2][3] - (eye.x * n.x + eye.y * n.y + eye.z * n.z);

CT[2][0] = x;

CT[2][1] = y;

CT[2][2] = z;

CT[2][3] = c;

}

//-------------------------------------------------------------

void Diff(TVector3D &eye, TVector3D &look, TVector3D &result)//finds vector difference

{

result.x = eye.x - look.x;

result.y = eye.y - look.y;

result.z = eye.z - look.z;

}

//-------------------------------------------------------------

void VectMult(TVector3D &a, TVector3D &b, TVector3D &result)

{//finds vectors vector multiplication

//|i j k |

//|a.x a.y a.z|

//|b.x b.y b.z|

result.x = a.y * b.z - b.y * a.z;

result.y = -(a.x * b.z - b.x * a.z);

result.z = a.x * b.y - b.x * a.y;

}

//-------------------------------------------------------------

void Normalize(TVector3D *vect)

{

float len = Sqrt(vect->x * vect->x + vect->y * vect->y + vect->z * vect->z);

vect->x /= len;

vect->y /= len;

vect->z /= len;

}

Please help! What I'm doing wrong?

Firstly OpenGl has model-viev matrix known as current vertex transformation: CT = V*M; To add some affine transformation to vertexes I do this: CT = CT * MNew - which works fine in my program. But how do I add new camera transformation? Is it done in this way: CT = VNew * CT? How do I need to apply my new camera transformation, setted by matrix V? Doing so in my program it functions somewhat strange...

If apply new transformation like this:

TVector3D eye = {0, 0, 1};

TVector3D look = {0, 0, 0};

TVector3D up = {0, 1, 0};

LookAt(eye, look, up);

- my program results in simple picture zooming.

if apply this:

TVector3D eye = {0, 0, -1}; //notice sign -

TVector3D look = {0, 0, 0};

TVector3D up = {0, 1, 0};

LookAt(eye, look, up);

the new image is turned in some different way, it is like it was mirrored, turned in 90 degrees and zoomed out a little bit.

Here is the code for my function LookAt:

void LookAt(TVector3D eye, TVector3D look, TVector3D up)

{

//here i'm calculating this:

//n = eye - look;

//u = up x n;

//v = n x u;

TVector3D n, u, v;

Diff(eye, look, n);

VectMult(up, n, u);

Normalize(&n);

Normalize(&u);

VectMult(n, u, v);

float x, y, z, c;

//Now i'm calculating this: CT = V * CT;

x = u.x * CT[0][0] + u.y * CT[1][0] + u.z * CT[2][0];

y = u.x * CT[0][1] + u.y * CT[1][1] + u.z * CT[2][1];

z = u.x * CT[0][2] + u.y * CT[1][2] + u.z * CT[2][2];

c = u.x * CT[0][3] + u.y * CT[1][3] + u.z * CT[2][3] - (eye.x * u.x + eye.y * u.y + eye.z * u.z);

CT[0][0] = x;

CT[0][1] = y;

CT[0][2] = z;

CT[0][3] = c;

x = v.x * CT[0][0] + v.y * CT[1][0] + v.z * CT[2][0];

y = v.x * CT[0][1] + v.y * CT[1][1] + v.z * CT[2][1];

z = v.x * CT[0][2] + v.y * CT[1][2] + v.z * CT[2][2];

c = v.x * CT[0][3] + v.y * CT[1][3] + v.z * CT[2][3] - (eye.x * v.x + eye.y * v.y + eye.z * v.z);

CT[1][0] = x;

CT[1][1] = y;

CT[1][2] = z;

CT[1][3] = c;

x = n.x * CT[0][0] + n.y * CT[1][0] + n.z * CT[2][0];

y = n.x * CT[0][1] + n.y * CT[1][1] + n.z * CT[2][1];

z = n.x * CT[0][2] + n.y * CT[1][2] + n.z * CT[2][2];

c = n.x * CT[0][3] + n.y * CT[1][3] + n.z * CT[2][3] - (eye.x * n.x + eye.y * n.y + eye.z * n.z);

CT[2][0] = x;

CT[2][1] = y;

CT[2][2] = z;

CT[2][3] = c;

}

//-------------------------------------------------------------

void Diff(TVector3D &eye, TVector3D &look, TVector3D &result)//finds vector difference

{

result.x = eye.x - look.x;

result.y = eye.y - look.y;

result.z = eye.z - look.z;

}

//-------------------------------------------------------------

void VectMult(TVector3D &a, TVector3D &b, TVector3D &result)

{//finds vectors vector multiplication

//|i j k |

//|a.x a.y a.z|

//|b.x b.y b.z|

result.x = a.y * b.z - b.y * a.z;

result.y = -(a.x * b.z - b.x * a.z);

result.z = a.x * b.y - b.x * a.y;

}

//-------------------------------------------------------------

void Normalize(TVector3D *vect)

{

float len = Sqrt(vect->x * vect->x + vect->y * vect->y + vect->z * vect->z);

vect->x /= len;

vect->y /= len;

vect->z /= len;

}

Please help! What I'm doing wrong?