Quaternion Camera Source Code

[AvengerDr]

Hello there! This is my Quaternion Camera Class:

package com.AvengersUTD.GLEngine;

/**

• Quaternion Camera V1.0
• by Adalberto L. Simeone (lafcadio at tin dot it)
• part of Project Diviner - Avengers UTD
• Redistribution of source code is freely allowed if
• you mantain the above disclaimer

*/

import net.java.games.jogl.GL;
import net.java.games.jogl.GLU;
import com.AvengersUTD.Universe.Quaternion;
import com.AvengersUTD.Universe.Vector3;
import com.AvengersUTD.Universe.Point2D;
import com.AvengersUTD.GUI.Util;

public class QuaternionCam {

public Vector3 vPosition;
public Vector3 vView;
Vector3 vUp;

double dCurRot;

//Current and Previous FPS
private static long lastTime = 0;
private int FPS = 0;
private int previousFPS = 0;

Util u;

public QuaternionCam() {
vPosition = new Vector3(0, 0, -5);
vView = new Vector3();
vUp = new Vector3(‘y’);
u = new Util();
}

public void set(Vector3 pos, Vector3 view, Vector3 up) {
vPosition = pos;
vView = view;
vUp = up;
}

public void move(double speed) {
Vector3 vNewDir = new Vector3();
vNewDir = vView.diff(vPosition).norm();
update(vNewDir, speed);
}

public void strafe(double speed) {
Vector3 vStrafe = new Vector3();
vStrafe = vView.diff(vPosition).crossProduct(new Vector3(‘y’)).norm();
update(vStrafe, speed);
}

public void rotate(double speed, Vector3 vAxis) {
Quaternion qRot = new Quaternion();
Quaternion qNewDir = new Quaternion();
Quaternion qNewRot = new Quaternion();

qRot = qRot.buildFromAxisAngle(speed, vAxis);
qNewDir = qNewDir.buildFromVector(vView.diff(vPosition));
qNewRot = qRot.mult(qNewDir).mult(qRot.conjugate());

vView = vPosition.sum(qNewRot.v);

}

public void orbit(Vector3 vCenter, double speed, Vector3 vAxis) {
Quaternion qRot = new Quaternion();
Quaternion qPos = new Quaternion();
Quaternion qNewPos = new Quaternion();
Vector3 vTmp = vPosition.diff(vCenter);
qRot = qRot.buildFromAxisAngle(speed, vAxis);
qPos = qPos.buildFromVector(vTmp);
qNewPos = qRot.mult(qPos).mult(qRot.inverse());
Vector3 v = qNewPos.v;

vPosition = vView.sum(v);

}

public void hover(double speed) {
vPosition.y += speed;
vView.y += speed;
}

public void update(Vector3 vDirection, double speed) {
vPosition = vDirection.scalarMul(speed).sum(vPosition);
vView = vDirection.scalarMul(speed).sum(vView);
}

public void mouselook(Point2D mousePos) {
Point2D center = new Point2D(u.getGLArea().getWidth() >> 1,
u.getGLArea().getHeight() >> 1);
Point2D origin = new Point2D(center);
origin = origin.add(u.getScreenPos());
u.mouseMove(origin);

double xRot, yRot;
xRot = (center.x - mousePos.x) / 10.0;
yRot = (center.y - mousePos.y) / 10.0;

dCurRot -= yRot;

if (dCurRot > 60.0) {
  dCurRot = 60.0;
  return;
}
if (dCurRot < -60.0) {
  dCurRot = -60.0;
  return;
}

Vector3 vXAxis = new Vector3();
vXAxis = vView.diff(vPosition).crossProduct(vUp).norm();
rotate(yRot, vXAxis);
rotate(xRot, new Vector3('y'));

}

public void look(GL gl, GLU glu, Frustum frustum) {
glu.gluLookAt(vPosition.x, vPosition.y, vPosition.z,
vView.x, vView.y, vView.z,
vUp.x, vUp.y, vUp.z);
frustum.CalculateFrustum(gl);
u.log("FPS: " + String.valueOf(calculateFPS()));
}

public float calculateFPS() {

long currentTime = System.currentTimeMillis() / 1000;
++FPS;

if (currentTime - lastTime > 1.0) {
  lastTime = currentTime;
  previousFPS = FPS;
  FPS = 0;
  return previousFPS;
}
return previousFPS;

}

}

[AvengerDr]

Quaternion Class:

package com.AvengersUTD.Universe;

/**

• Quaternion Class V1.0
• by Adalberto L. Simeone (lafcadio at tin dot it)
• part of Project Diviner - Avengers UTD
• Redistribution of source code is freely allowed if
• you mantain the above disclaimer

*/

public class Quaternion {

// A Quaternion is Q = [w,v] where
// w is a scalar and v is a vector
// v = xi + yj + zk
// i, j, k are sqrt(-1)

public double w;
public Vector3 v;

public Quaternion() {
this.w=1;
this.v=new Vector3();
}

public Quaternion (double w, Vector3 v) {
this.w=w;
this.v=v;
}

private double magnitude() {
return Math.sqrt(this.wthis.w + this.v.xthis.v.x + this.v.ythis.v.y + this.v.zthis.v.z);
}

public Quaternion norm() {
double M=this.magnitude();

Quaternion Q=new Quaternion();
Q.w = this.w / M;
Q.v.x = this.v.x / M;
Q.v.y = this.v.y / M;
Q.v.z = this.v.z / M;

return Q;

}

public Quaternion conjugate() {
Quaternion Q=new Quaternion();
Q.w= this.w;
Q.v.x = -this.v.x;
Q.v.y = -this.v.y;
Q.v.z = -this.v.z;
return Q;
}

public Quaternion mult(Quaternion B) {
{
Quaternion C=new Quaternion();
// Qr = Q1.Q2 = ( w1.w2 - v1.v2, w1.v2 + w2.v1 + v1 x v2 )

   C.v.x = this.w*B.v.x + this.v.x*B.w + this.v.y*B.v.z - this.v.z*B.v.y;
   C.v.y = this.w*B.v.y - this.v.x*B.v.z + this.v.y*B.w + this.v.z*B.v.x;
   C.v.z = this.w*B.v.z + this.v.x*B.v.y - this.v.y*B.v.x + this.v.z*B.w;
   C.w = this.w*B.w - this.v.x*B.v.x - this.v.y*B.v.y - this.v.z*B.v.z;
   return C;

}
}

public Quaternion buildFromSC(Vector3 v) {
double sinZ= Math.sin(v.z);
double cosZ=Math.cos(v.z);
double sinLat=Math.sin(v.x);
double sinLon=Math.sin(v.y);
double cosLat=Math.cos(v.x);
double cosLon=Math.cos(v.y);

 Quaternion Q=new Quaternion();

 Q.v.x= sinZ * cosLat * sinLon;
 Q.v.y= sinZ * sinLat;
 Q.v.z= sinZ * sinLat * cosLon;
 Q.w= cosZ;

 return Q;

}

public Quaternion buildFromVector(Vector3 v) {
Quaternion Q=new Quaternion();
Q.w=0.0;
Q.v=v;
return Q;
}

public Quaternion toAxisAngle() {
Quaternion Q=new Quaternion();
Quaternion R=new Quaternion();

R=this;
R=R.norm();
double cosa=R.w;
double angle = Math.acos(cosa) * 2;
double scale = R.v.magnitude();
Q.w=angle;
Q.v.x= R.v.x / scale;
    Q.v.y= R.v.y / scale;
        Q.v.z= R.v.z / scale;
return Q;

}

public Quaternion buildFromAxisAngle(double rad, Vector3 v) {
double alpha = Math.toRadians(rad);
double sinAlpha = Math.sin(alpha / 2.0);

 Quaternion Q=new Quaternion();
 Q.w = Math.cos(alpha / 2.0);
 Q.v.x= v.x * sinAlpha;
 Q.v.y= v.y * sinAlpha;
 Q.v.z= v.z * sinAlpha;
 return Q;

}

public Quaternion inverse() {
Quaternion Q=new Quaternion();
Q=this;
Q=Q.norm();
Q=Q.conjugate();
return Q;

}

public double[] toMatrix() {
/*
Matrix = [ 1 - 2y2 - 2z2 2xy - 2wz 2xz + 2wy
2xy + 2wz 1 - 2x2 - 2z2 2yz - 2wx
2xz - 2wy 2yz + 2wx 1 - 2x2 - 2y2 ]
*/
double[] A = new double[16];

// First Row

A[0] = 1.0 - 2.0 * (Math.pow(this.v.y,2.0) + Math.pow(this.v.z,2.0));
A[1] = 2.0 * (this.v.x * this.v.y + this.w * this.v.z);
A[2] = 2.0 * (this.v.x * this.v.z - this.w * this.v.y);
A[3] = 0.0;

//Second Row
A[4] = 2.0 * (this.v.x * this.v.y - this.w * this.v.z);
A[5] = 1.0 - 2.0 * (Math.pow(this.v.x,2.0) + Math.pow(this.v.z,2.0));
A[6] = 2.0 * (this.v.y * this.v.z + this.w * this.v.x);
A[7] = 0.0;

//Third Row
A[8] = 2.0 * (this.v.x * this.v.z + this.w * this.v.y);
A[9] = 2.0 * (this.v.y * this.v.z - this.w * this.v.x);
A[10] = 1.0 - 2.0 * (Math.pow(this.v.x,2.0) + Math.pow(this.v.y,2.0));
A[11] = 0.0;

//Fourth Row
A[12]=0.0;
A[13]=0.0;
A[14]=0.0;
A[15]=1.0;

return A;
}

}

[AvengerDr]

Vector class:

package com.AvengersUTD.Universe;

/**

• Vector Class V1.0
• by Adalberto L. Simeone (lafcadio at tin dot it)
• part of Project Diviner - Avengers UTD
• Redistribution of source code is freely allowed if
• you mantain the above disclaimer

*/

public class Vector3 {
public double x,y,z;

public Vector3(double x1, double y1, double z1) {
this.x=x1;
this.y=y1;
this.z=z1;
}

public Vector3() {
this.x=0;
this.y=0;
this.z=0;
}

public Vector3(char c) {
switch © {
case ‘x’:
this.x=1;
this.y=0;
this.z=0;
break;
case ‘y’:
this.x=0.0;
this.y=1.0;
this.z=0.0;
break;
case ‘z’:
this.x=0;
this.y=0;
this.z=1;
break;
default:
this.x=0;
this.y=0;
this.z=0;
}
}

public Vector3 scalarMul(double a) {
Vector3 v=new Vector3();
v.x=this.xa;
v.y=this.ya;
v.z=this.z*a;
return v;
}

public Vector3 sum(Vector3 b){
Vector3 v=new Vector3();
v.x=this.x+b.x;
v.y=this.y+b.y;
v.z=this.z+b.z;
return v;
}

public Vector3 diff(Vector3 b){
Vector3 v=new Vector3();
v.x=this.x-b.x;
v.y=this.y-b.y;
v.z=this.z-b.z;
return v;
}

public Vector3 scalarDiv(double a) {
Vector3 v=new Vector3();
v.x=this.x/a;
v.y=this.y/a;
v.z=this.z/a;
return v;
}

public Vector3 crossProduct(Vector3 b) {
Vector3 v=new Vector3();
v.x = ((this.y * b.z) - (this.z * b.y));
v.y = ((this.z * b.x) - (this.x * b.z));
v.z = ((this.x * b.y) - (this.y * b.x));
return v;
}

public double dotProduct(Vector3 b) {
double dot;
// X = V . W
// = V1W1 + V2W2 + V3W3
dot = (this.x * b.x) + (this.y * b.y) + (this.z * b.z);
return dot;
}

public double magnitude() {
return (double)Math.sqrt( (this.x * this.x) + (this.y * this.y) +
(this.z * this.z) );
}

public Vector3 norm() {
Vector3 v=new Vector3();
// Get the magnitude of our normal
double magnitude = this.magnitude();

// Now that we have the magnitude, we can divide our Vector by that magnitude.
// That will make our Vector a total length of 1.
v = this.scalarDiv(magnitude);

// Finally, return our normalized Vector
return v;

}

public boolean isZero() {
if (this.x==0 & this.y==0 & this.z==0) return true;
else return false;
}

public Matrix buildTranslationM() {
Matrix T=new Matrix(‘i’);
T.array[12]=-this.x;
T.array[13]=-this.y;
T.array[14]=this.z;
return T;
}

}

Point2D class:

package com.AvengersUTD.Universe;

public class Point2D {

public double x;
public double y;

public Point2D() {
this.x=0.0;
this.y=0.0;
}

public Point2D(double x1, double y1) {
this.x=x1;
this.y=y1;
}

public Point2D(Point2D p) {
this.x=p.x;
this.y=p.y;
}

public Point2D add(Point2D b) {
Point2D a=new Point2D(this);
a.x+=b.x;
a.y+=b.y;
return a;
}

}

[AvengerDr]

This is an excerpt of my InputHandle class:

private void processKeyEvent(KeyEvent e, boolean pressed) {
switch (e.getKeyCode()) {
case KeyEvent.VK_PAGE_UP: case KeyEvent.VK_E:
renderer.hoverUP(pressed);
break;
case KeyEvent.VK_PAGE_DOWN: case KeyEvent.VK_Q:
renderer.hoverDW(pressed);
break;
case KeyEvent.VK_SHIFT:
shiftDown=true;
break;
case KeyEvent.VK_UP: case KeyEvent.VK_W:
if (shiftDown)
renderer.orbitUP(pressed);
else
renderer.goFW(pressed);
break;
case KeyEvent.VK_DOWN: case KeyEvent.VK_S:
if (shiftDown)
renderer.orbitDW(pressed);
else
renderer.goBW(pressed);
break;
case KeyEvent.VK_RIGHT: case KeyEvent.VK_D:
if (shiftDown)
renderer.orbitR(pressed);
else
renderer.strafeR(pressed);
break;
case KeyEvent.VK_LEFT: case KeyEvent.VK_A:
if (shiftDown)
renderer.orbitL(pressed);
else
renderer.strafeL(pressed);
break;
}
}

Then you have to define a set of boolean methods in your renderer class like this one (if you want to do it like I did):

public void goFW(boolean goFW) {
this.goFW = goFW;
}

Then you define a Update() method that has to be called in your Display() method like:

public void update() {
if (goFW) {
qCam.move(0.1);
}
if (goBW) {
qCam.move(-0.1);
}
if (orbitR) {
qCam.orbit(qCam.vView,-2.0, new Vector3(‘y’));
}

[…]

Finally, after your glLoadIdentity you should call:

qCam.look(gl,glu);

[AvengerDr]

As you may have noticed, this code is uncommented… I have not yet had the time to do it Anyway if there is something that you do not understand I’ll be happy to clarify every doubt.

There are some things in QuaternionCam that are only needed by my Project. You can delete the Util class references and the Frustum one (I’m currently implementing a Frustum Culling technique).

I followed the “industry” 's standard in term of keyboard layout. You have the usual WASD keys for movement and the mouse for looking around. In the mouselook method movement is capped to a certain degree. In that method you’ll notice that you’ll have to use the Java Robot class to return the pointer to the center. Is there a better way to do it?

I encourage you to try this because there’s a small bug in orbiting up/down. In theory you should rotate the viewing vector around the X-axis. If you try to rotate looking Norh/South it works fine, If you try to rotate Up/down in a east/west sense it doesn’t work… You should try and look and you’ll understand.

Orbiting left/right works fine although I have net yet understood how I can influence the radius of rotation.

Hope this helps.

[Malohkan]

I’m stuck on the same issue described by AvengerDr here. After 1.5 years does anyone have any new insight?

[Vorax]

@AvengerDr

Orbiting left/right works fine although I have net yet understood how I can influence the radius of rotation.

Hope this helps.

Wouldn’t it simply be a mater of performing a translation prior to applying the camera rotation?

Such as:

// Position camera 10 points on the z axis (10 unit radius)
gl.glTranslatef(0, 0, 10);

// Apply camera rotation (note: getRotation is simply a method that would convert the quaternion rotation to a 4x4 matrix float[16])
gl.glMultMatrixf( camera.getRotationMatrix() );

// Translate to the position of the thing your orbiting (another fake method that returns the position of the thing your obiting)
gl.glTranslatefv( orbitThing.getPosition() );

Of course some of those methods you will have to map to your class, but you have a quaternion for the camera, so you can easily make a matrix from it, and of course, you must of the position of the thing your orbiting.

I think that should about do it… unless I am misunderstanding your issue.

[kbr]

The gleem ExaminerViewer has a mode which rotates around a focal point at a specified distance from the camera. You might be able to borrow some of the math from there, or just use the class directly. It supports only mouse input, not keyboard input, however.

[Malohkan]

ahh Vorax, that wasn’t the issue I was referring to. Thanks though!

“I encourage you to try this because there’s a small bug in orbiting up/down. In theory you should rotate the viewing vector around the X-axis. If you try to rotate looking Norh/South it works fine, If you try to rotate Up/down in a east/west sense it doesn’t work… You should try and look and you’ll understand.”

That was the one I was talking about.

Ken, I checked out the ExamineViewer. I’m afraid I can’t make heads or tails of what it’s doing I’m very new to OpenGL and that class is jam packed with things that I have no understanding of.

[quartz13163]

I noticed this thread and thought I would post to it.

I have created a camera class that is structured for easy use. The code is very isolated from the engine and has lots of comments.

It does both Pan and Orbit style camera using both Arcball and YawPitch algorithms. The camera is fully functional at all orientations, up, down, left, right etc…

I also added Roll correction using lookAt method with the Arcball style. Arcballs introduce twists when implementing lookAts. I finally figured
out how to correct this and I have commented to code, for me as well.

If you are interested the code it is at:
http://www.distanthumans.info/programming/java/misc.php

or more specifically:

http://www.distanthumans.info/programming/java/projects/gloctree/GLOctree_2_24.jar

Don’t worry about the rest of the code.

The camera code is all in the “view” package of the project. To instanciate it take a look at Database.Database() and to use it look at GlRender.render(). You will see code like: gl.glLoadMatrixf(camera.getTransformArray()); in the render method.

As with most cameras the motion is handled with mouse input. It is simple, just look at say, GLRenderLeft.mouseDragged(), mousePressed() and mouseReleased()

Let me know if this helps.

[eraboin]

Why does your Quaternion.inverse() method say;

Quaternion Q=new Quaternion();
Q=this;
...

Isn’t that the same as saying Quaternion Q = this; ?

I’m having trouble with inverses in my own implementation, but I thought that was odd.

[Malohkan]

yeah that’s what I was thinking too. When I made it I made a new constructor that created a copy of the old one so the new line became Quaternion q = new Quaternion(this); Doesn’t seem to change any of the results though.

[Gorgorath]

kick;)

is there a way to specify the ‘up vector’ coz in my application the upVector is 0,0,1 not 0,1,0 so using the lookAt function gives not the desired results( everything is upside down

paul