Quaternion problems

BlitzMax Forums/OpenGL Module/Quaternion problems

KronosUK

(Posted 2010) [#1]

I'm trying to implement quaternions into an opengl project but I am having some problems.

I am using Wavey's quaternion code taken from the archives as a basis. The object should be rotating around its respective axes however it doesn't.

Waveys demo works fine (in blitz3d) so I don't think its a problem with his quaternion code.

Type vector3d
	Field x:Float
	Field y:Float
	Field z:Float
End Type

Type Quat
	Field w:Float
	Field x:Float
	Field y:Float
	Field z:Float
End Type

'Change these constants If you notice slips in accuracy
Const QuatToEulerAccuracy# = 0.001
Const QuatSlerpAccuracy#   = 0.0001

'convert a Rotation To a Quat
Function EulerToQuat(out:Quat, src:vector3d)
			
	Local cr# = Cos(src.z*0.5)
	Local cp# = Cos(src.x*0.5)
	Local cy# = Cos(src.y*0.5)

	Local sr# = Sin(src.z*0.5)
	Local sp# = Sin(src.x*0.5)
	Local sy# = Sin(src.y*0.5)

	' These variables are only here To cut down on the number of multiplications
	Local cpcy# = cp * cy
	Local spsy# = sp * sy
	Local spcy# = sp * cy
	Local cpsy# = cp * sy

	' Generate the output quat
	out.w = cr * cpcy + sr * spsy
	out.x = sr * cpcy - cr * spsy
	out.y = cr * spcy + sr * cpsy
	out.z = cr * cpsy - sr * spcy
End Function


' convert a Quat To a Rotation
Function QuatToEuler(out:vector3d, src:Quat)
	Local sint#, cost#, sinv#, cosv#, sinf#, cosf#
	Local cost_temp#

	sint = (2 * src.w * src.y) - (2 * src.x * src.z)
	cost_temp = 1.0 - (sint * sint)

	If Abs(cost_temp) > QuatToEulerAccuracy
		cost = Sqr(cost_temp)
	Else
		cost = 0
	EndIf

	If Abs(cost) > QuatToEulerAccuracy
		sinv = ((2 * src.y * src.z) + (2 * src.w * src.x)) / cost
		cosv = (1 - (2 * src.x * src.x) - (2 * src.y * src.y)) / cost
		sinf = ((2 * src.x * src.y) + (2 * src.w * src.z)) / cost
		cosf = (1 - (2 * src.y * src.y) - (2 * src.z * src.z)) / cost
	Else
		sinv = (2 * src.w * src.x) - (2 * src.y * src.z)
		cosv = 1 - (2 * src.x * src.x) - (2 * src.z * src.z)
		sinf = 0
		cosf = 1
	EndIf

	' Generate the output rotation
	out.z = ATan2(sinv, cosv)
	out.x = ATan2(sint, cost)
	out.y = ATan2(sinf, cosf)
End Function



' use this To interpolate between quaternions
Function QuatSlerp:quat(start:Quat, fin:Quat, t#)
	Local scaler_w#, scaler_x#, scaler_y#, scaler_z#
	Local omega#, cosom#, sinom#, scale0#, scale1#
	Local res:quat = New quat
	cosom = start.x * fin.x + start.y * fin.y + start.z * fin.z + start.w * fin.w

	If cosom <= 0.0
		cosom = -cosom
		scaler_w = -fin.w
		scaler_x = -fin.x
		scaler_y = -fin.y
		scaler_z = -fin.z
	Else
		scaler_w = fin.w
		scaler_x = fin.x
		scaler_y = fin.y
		scaler_z = fin.z
	EndIf

	If (1 - cosom) > QuatSlerpAccuracy
		omega = ACos(cosom)
		sinom = Sin(omega)
		scale0 = Sin((1 - t) * omega) / sinom
		scale1 = Sin(t * omega) / sinom
	Else
		' Angle too small: use linear interpolation instead
		scale0 = 1 - t
		scale1 = t
	EndIf

	res.x = scale0 * start.x + scale1 * scaler_x
	res.y = scale0 * start.y + scale1 * scaler_y
	res.z = scale0 * start.z + scale1 * scaler_z
	res.w = scale0 * start.w + scale1 * scaler_w
End Function

' result will be the same rotation as doing q1 Then q2 (order matters!)
Function MultiplyQuat(result:Quat, q1:Quat, q2:Quat)
	Local a#, b#, c#, d#, e#, f#, g#, h#

	a = (q1.w + q1.x) * (q2.w + q2.x)
	b = (q1.z - q1.y) * (q2.y - q2.z)
	c = (q1.w - q1.x) * (q2.y + q2.z)
	d = (q1.y + q1.z) * (q2.w - q2.x)
	e = (q1.x + q1.z) * (q2.x + q2.y)
	f = (q1.x - q1.z) * (q2.x - q2.y)
	g = (q1.w + q1.y) * (q2.w - q2.z)
	h = (q1.w - q1.y) * (q2.w + q2.z)

	result.w = b + (-e - f + g + h) / 2
	result.x = a - ( e + f + g + h) / 2
	result.y = c + ( e - f + g - h) / 2
	result.z = d + ( e - f - g + h) / 2
End Function

' program starts here
Const ScreenWidth:Float = 1024
Const ScreenHeight:Float = 768
Const AspectRatio:Float = ScreenWidth/ScreenHeight
Const Viewdistance = 120000
Const FieldOfView = 75

GLGraphics (ScreenWidth,ScreenHeight)

GlewInit()


glViewport( 0, 0, screenwidth, screenheight )
glMatrixMode( GL_PROJECTION )
glLoadIdentity()
gluPerspective( fieldofview, AspectRatio, 1.0, ViewDistance)
glMatrixMode(GL_MODELVIEW)
glLoadIdentity()
glEnable(GL_DEPTH_TEST)
glEnable(GL_CULL_FACE)
glFrontFace(GL_CCW)
glShadeModel(GL_SMOOTH)




HideMouse()

Local turn:vector3d = New vector3d
Local rotation:vector3d = New vector3d
Local quat1:quat = New quat
Local quat2:Quat = New Quat
Local quat3:Quat = New Quat
'main loop
While Not AppTerminate() And Not KeyDown(KEY_ESCAPE)


'clear screen
glClear GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT
glMatrixMode(GL_MODELVIEW)
glLoadIdentity()

glulookat(0,25,-30,0,10,0,0,1,0)

turn.x = 0
turn.y = 0
turn.z = 0

If KeyDown(key_num7) Then turn.z= 1.0
If KeyDown(key_num9) Then turn.z=-1.0
If KeyDown(key_num8) Then turn.x= 1.0
If KeyDown(key_num2) Then turn.x =-1.0
If KeyDown(key_num4) Then turn.y= 1.0
If KeyDown(key_num6) Then turn.y=-1.0

EulertoQuat(quat1,turn)'the amount to turn
EulerToQuat(quat2,rotation)'existing rotation of axes object
MultiplyQuat(quat3,quat1, quat2)' make a new quat
QuatToEuler(rotation,quat3)' convert new quat back to rotation
	


glpushmatrix()

glscalef(5,5,5)
gltranslatef(0,3,0)
glrotatef(rotation.x,1,0,0)
glrotatef(rotation.y,0,1,0)
glrotatef(rotation.z,0,0,1)
glbegin(gl_lines)
glcolor3f(200,0,0)
glvertex3f(0,0,0)
glvertex3f(0,1,0)
glcolor3f(0,200,0)
glvertex3f(0,0,0)
glvertex3f(1,0,0)
glcolor3f(0,0,200)
glvertex3f(0,0,0)
glvertex3f(0,0,1)
glend()
glpopmatrix()

'add a surface

glpushmatrix()

glcolor3f(200,200,0)
glrotatef(180,1,0,0)
glscalef(10,10,10)
glbegin(gl_quads)
glvertex3f(-10,0,-10)
glvertex3f(10,0,-10)
glvertex3f(10,0,10)
glvertex3f(-10,0,10)
glend()
glpopmatrix()

gldisable(gl_lighting)

glcolor3f(255,255,255)
Flip(1)
Wend

ShowMouse()

End

slenkar

(Posted 2010) [#2]

are you sure you know what you are doing with pushmatrix and popmatrix?

you have to use loadmatrix with an array to get your matrix into opengl, then draw the model's triangles.
If you want a camera you get a matrix for the cameras rotation and load its reverse matrix