gluUnProject is popping entity position

BlitzMax Forums/MiniB3D Module/gluUnProject is popping entity position

AdamRedwoods

(Posted 2012) [#1]

I have no idea why gluUnProject is popping my entity (sphere2) when I get my position back and am moving the camera. It pops back when I am stationary.

I have tried my own routine and the glu library, both do the same popping. Any ideas?

Here's the full code

Import "../minib3d.bmx"


SuperStrict

Local width#=640,height#=480,depth#=0,mode#=2

Graphics3D width,height,depth,mode

Local cam:TCamera=CreateCamera()
PositionEntity cam,0,0,-5

Local light:TLight=CreateLight(1)


Local cube:TMesh=CreateCube()
Local sphere:TMesh=CreateSphere()
Local cylinder:TMesh=CreateCylinder()
Local cone:TMesh=CreateCone() 

PositionEntity cube,-3,0,0
PositionEntity sphere,-1,0,0
PositionEntity cylinder,1,0,0
PositionEntity cone,3,0,0

''need to set the surfaces the same

Local sphere2:TEntity = CopyEntity(sphere)
PositionEntity sphere2,-1,2,0
ScaleEntity sphere2,0.5,0.5,0.5
EntityColor sphere2,0,200,0

EntityTexture(sphere, LoadTexture("media/stars.png"))
EntityFX(sphere,32)

' used by fps code
Local old_ms%=MilliSecs()
Local renders%
Local fps%

Local a#=0.999, dir%=0

While Not KeyDown(KEY_ESCAPE)	 And Not AppTerminate()	

	If KeyHit(KEY_ENTER) Then DebugStop

	' control camera
	MoveEntity cam,KeyDown(KEY_D)-KeyDown(KEY_A),0,KeyDown(KEY_W)-KeyDown(KEY_S)
	TurnEntity cam,KeyDown(KEY_DOWN)-KeyDown(KEY_UP),KeyDown(KEY_LEFT)-KeyDown(KEY_RIGHT),0
	'MoveEntity sphere,KeyDown(KEY_DOWN)-KeyDown(KEY_UP),KeyDown(KEY_LEFT)-KeyDown(KEY_RIGHT),0	

	TurnEntity cube,0,1,0

	
	Local vec:TVector = camUnProject(10.0,height,0.3, cam.mod_mat, cam.proj_mat, cam.viewport, cam)


	Local vx:Double, vy:Double, vz:Double
	Local y% = TGlobal.height - 10.0
	gluUnProject(10.0,y,0.3,cam.mod_mat,cam.proj_mat, cam.viewport, Varptr vx, Varptr vy, Varptr vz)


	PositionEntity sphere2, vec.x,vec.y,-vec.z
	'PositionEntity sphere2, vx,vy,-vz

	RenderWorld
	renders=renders+1

	' calculate fps
	If MilliSecs()-old_ms>=1000
		old_ms=MilliSecs()
		fps=renders
		renders=0
	EndIf
	
	Text 0,0,"FPS: "+fps

	Flip

Wend
End

Function camUnProject:TVector(wx:Float, wy:Float, wz:Float=1.0, model:Double[], proj:Double[], viewport:Int[], cam:TCamera=Null)

	'' takes a 2d screen point and returns 3d coordinates.
	
	
	Local temp:Float[4]

		
	wy = TGlobal.height - wy ''adjust since opengl is 0,0 at bottom left
	
	Local x# = ((wx-viewport[0]) / viewport[2]) *2.0 -1.0
	Local y# = ((wy-viewport[1]) / viewport[3]) *2.0 -1.0 '2.0 * (wy-viewport[1] + viewport[3]*1.5) / viewport[3]
	Local z# = ( wz*2.0 - 1.0)

	Local mod_mat:TMatrix = New TMatrix
	mod_mat=MatrixFromArray(model)
	
	Local proj_mat:TMatrix = New TMatrix
	proj_mat=MatrixFromArray(proj)
	

	Local inv_mat:TMatrix = New TMatrix
	'inv_mat.LoadIdentity()

	inv_mat= mod_mat.Inverse()
	inv_mat.Multiply(proj_mat.Inverse())
	
	'temp = TransformPoint(inv_mat, x, y, -z, 1.0)
	inv_mat.Translate(x, y, z)

'PrintMatrix inv_mat	

	temp = [inv_mat.grid[3,0],inv_mat.grid[3,1],inv_mat.grid[3,2]]

	
	Local newvec:TVector = New TVector
	newvec.x = temp[0]; newvec.y = temp[1]; newvec.z = temp[2]
	Return newvec

End Function

Function MatrixFromArray:TMatrix( arr:Double[] )
	
	Local m:TMatrix = New TMatrix
	
	m.grid[0,0] = arr[0];  m.grid[0,1] = arr[1];  m.grid[0,2] = arr[2];  m.grid[0,3] = arr[3]
	m.grid[1,0] = arr[4];  m.grid[1,1] = arr[5];  m.grid[1,2] = arr[6];  m.grid[1,3] = arr[7]
	m.grid[2,0] = arr[8];  m.grid[2,1] = arr[9];  m.grid[2,2] = arr[10]; m.grid[2,3] = arr[11]
	m.grid[3,0] = arr[12]; m.grid[3,1] = arr[13]; m.grid[3,2] = arr[14]; m.grid[3,3] = arr[15]

	Return m
End Function

Function PrintMatrix(mat:TMatrix)
	
	Print mat.grid[0,0]+":"+mat.grid[1,0]+":"+mat.grid[2,0]+":"+mat.grid[3,0]
	Print mat.grid[0,1]+":"+mat.grid[1,1]+":"+mat.grid[2,1]+":"+mat.grid[3,1]
	Print mat.grid[0,2]+":"+mat.grid[1,2]+":"+mat.grid[2,2]+":"+mat.grid[3,2]	
	Print mat.grid[0,3]+":"+mat.grid[1,3]+":"+mat.grid[2,3]+":"+mat.grid[3,3]
	
EndFunction

Function TransformPoint:Float[](m:TMatrix, x:Float, y:Float, z:Float, w:Float=1.0)
	
	Local p0:Float,p1:Float,p2:Float,p3:Float
	
	'' -z, opengl
	
	p0 = m.grid[0,0]*x + m.grid[1,0]*y + m.grid[2,0]*-z + m.grid[3,0] *w
	p1 = m.grid[0,1]*x + m.grid[1,1]*y + m.grid[2,1]*-z + m.grid[3,1] *w
	p2 = m.grid[0,2]*x + m.grid[1,2]*y + m.grid[2,2]*-z + m.grid[3,2] *w
	p3 = m.grid[0,3]*x + m.grid[1,3]*y + m.grid[2,3]*-z + m.grid[3,3] *w
	
	Return [p0,p1,-p2,p3]
EndFunction

many thanks

Last edited 2012

AdamRedwoods

(Posted 2012) [#2]

Solved: when using the camera's proj[] and mod[] matrixes, these are only updated during render (using glGetDouble), so I was getting the correct camera matrix too late.

So I used the internal camera matrix and inversed it to get the modelview matrix.

Local cam_mat:TMatrix = cam.mat.Copy().Inverse()

inv_mat= cam_mat.Inverse()
inv_mat.Multiply(proj_mat.Inverse())
''...etc...

..but this leads to another thought. When converting miniB3D to use openGL2.0, we need the projection matrix internal.
Has anyone done this yet?

Last edited 2012

AdamRedwoods

(Posted 2012) [#3]

The above doesn't work. using the camera matrix gets closer, but something is still wrong.

Using this in the main routine shows what is off:

	Local x:Float = MouseX()
	Local y:Float = MouseY()
	
	Local vec:TVector = camUnProject(x,y,0.8, cam.mod_mat, cam.proj_mat, cam.viewport, cam)


	Local vx:Double, vy:Double, vz:Double
	y = TGlobal.height - y
	gluUnProject(x,y,0.8,cam.mod_mat,cam.proj_mat, cam.viewport, Varptr vx, Varptr vy, Varptr vz)

the zdepth input changes the location when drawn. it shouldn't do that, because eventually I need a ray from camera near to camera far planes.

I'm open for suggestions. One thought is I need a complete matrix.Inverse() method.

Last edited 2012

AdamRedwoods

(Posted 2012) [#4]

GOT IT!!!!
whew, ugh my brain hurts....

The problem was two-fold:
1. needed the full TMatrix.Inverse() for 4x4 matrix
2. needed the full TMatrix.Translate() for 4x4 matrix
3. then the grid[3][3] can be normalized with the x,y,z result

Thanks to kfprimm for his Matrix.Inverse() through max3d.

Notes on UnProject:
This can be optimized. Not only can the full Inverse() be optimized, but by using the camera's matrix and caching the Projection Matrix inverse, UnProject can be sped up considerably.

final code


Function camUnProject:TVector(wx:Float, wy:Float, wz:Float=1.0, model:Double[], proj:Double[], viewport:Int[], cam:TCamera=Null)

	'' takes a 2d screen point and returns 3d coordinates.
	
	Local pos:Float[4]	
	Local temp:Float[4]

		
	wy = TGlobal.height - wy ''adjust since opengl is 0,0 at bottom left
	
	Local x# = ((wx-viewport[0]) / viewport[2]) *2.0 -1.0
	Local y# = ((wy-viewport[1]) / viewport[3]) *2.0 -1.0
	Local z# = ( wz*2.0 - 1.0)


	Local mod_mat:TMatrix = New TMatrix
	mod_mat=MatrixFromArray(model)
	
	Local proj_mat:TMatrix = New TMatrix
	proj_mat=MatrixFromArray(proj)
	
	Local cam_mat:TMatrix = cam.mat.Copy() '.Inverse()
	
'Print""
'PrintMatrix proj_mat	

	Local inv_mat:TMatrix = New TMatrix

	inv_mat= cam_mat '.Inverse() ''we had a double inverse...
	inv_mat.Multiply(proj_mat.InverseFull())	

	inv_mat.Translate4(x, y, z, 1.0)

	Local d:Float = inv_mat.grid[3,3]
	If d=0.0 Then Return New TVector
	d = 1.0/d
	inv_mat.grid[3,3] = inv_mat.grid[3,3]*d


	temp = [inv_mat.grid[3,0]*d,inv_mat.grid[3,1]*d,inv_mat.grid[3,2]*d]
	
	Local newvec:TVector = New TVector
	newvec.x = temp[0]; newvec.y = temp[1]; newvec.z = temp[2]
	Return newvec

End Function

Add to TMatrix:

Method InverseFull:TMatrix()
			Local matrix:TMatrix=New TMatrix
			Local d:Float ''determinant
			
			'Local d# = Determinant()
			'If d=0 Then Print "matrix det 0"
			'If d = 0
				'matrix.LoadIdentity()
				'Return matrix
			'EndIf
			'd = 1.0/d
	
			matrix.grid[0,0] = (grid[1,1]*grid[2,2]*grid[3,3] + grid[1,2]*grid[2,3]*grid[3,1] + grid[1,3]*grid[2,1]*grid[3,2] - grid[1,1]*grid[2,3]*grid[3,2] - grid[1,2]*grid[2,1]*grid[3,3] - grid[1,3]*grid[2,2]*grid[3,1])'*d
			matrix.grid[1,0] = (grid[1,0]*grid[2,3]*grid[3,2] + grid[1,2]*grid[2,0]*grid[3,3] + grid[1,3]*grid[2,2]*grid[3,0] - grid[1,0]*grid[2,2]*grid[3,3] - grid[1,2]*grid[2,3]*grid[3,0] - grid[1,3]*grid[2,0]*grid[3,2])'*d
			matrix.grid[2,0] = (grid[1,0]*grid[2,1]*grid[3,3] + grid[1,1]*grid[2,3]*grid[3,0] + grid[1,3]*grid[2,0]*grid[3,1] - grid[1,0]*grid[2,3]*grid[3,1] - grid[1,1]*grid[2,0]*grid[3,3] - grid[1,3]*grid[2,1]*grid[3,0])'*d
			matrix.grid[3,0] = (grid[1,0]*grid[2,2]*grid[3,1] + grid[1,1]*grid[2,0]*grid[3,2] + grid[1,2]*grid[2,1]*grid[3,0] - grid[1,0]*grid[2,1]*grid[3,2] - grid[1,1]*grid[2,2]*grid[3,0] - grid[1,2]*grid[2,0]*grid[3,1])'*d
			
			
			''determinate & check
			d = grid[0,0]*matrix.grid[0,0] + grid[0,1]*matrix.grid[1,0] + grid[0,2]*matrix.grid[2,0] + grid[0,3]*matrix.grid[3,0]
			
			If d = 0
				matrix.grid[0,0]=0.0; matrix.grid[1,0]=0.0; matrix.grid[2,0]=0.0; matrix.grid[3,0]=0.0
				Return matrix
			EndIf
			d = 1.0/d
			
			matrix.grid[0,0] :* d
			matrix.grid[1,0] :* d
			matrix.grid[2,0] :* d
			matrix.grid[3,0] :* d
			matrix.grid[0,1] = (grid[0,1]*grid[2,3]*grid[3,2] + grid[0,2]*grid[2,1]*grid[3,3] + grid[0,3]*grid[2,2]*grid[3,1] - grid[0,1]*grid[2,2]*grid[3,3] - grid[0,2]*grid[2,3]*grid[3,1] - grid[0,3]*grid[2,1]*grid[3,2])*d
			matrix.grid[0,2] = (grid[0,1]*grid[1,2]*grid[3,3] + grid[0,2]*grid[1,3]*grid[3,1] + grid[0,3]*grid[1,1]*grid[3,2] - grid[0,1]*grid[1,3]*grid[3,2] - grid[0,2]*grid[1,1]*grid[3,3] - grid[0,3]*grid[1,2]*grid[3,1])*d
			matrix.grid[0,3] = (grid[0,1]*grid[1,3]*grid[2,2] + grid[0,2]*grid[1,1]*grid[2,3] + grid[0,3]*grid[1,2]*grid[2,1] - grid[0,1]*grid[1,2]*grid[2,3] - grid[0,2]*grid[1,3]*grid[2,1] - grid[0,3]*grid[1,1]*grid[2,2])*d
			matrix.grid[1,1] = (grid[0,0]*grid[2,2]*grid[3,3] + grid[0,2]*grid[2,3]*grid[3,0] + grid[0,3]*grid[2,0]*grid[3,2] - grid[0,0]*grid[2,3]*grid[3,2] - grid[0,2]*grid[2,0]*grid[3,3] - grid[0,3]*grid[2,2]*grid[3,0])*d
			matrix.grid[1,2] = (grid[0,0]*grid[1,3]*grid[3,2] + grid[0,2]*grid[1,0]*grid[3,3] + grid[0,3]*grid[1,2]*grid[3,0] - grid[0,0]*grid[1,2]*grid[3,3] - grid[0,2]*grid[1,3]*grid[3,0] - grid[0,3]*grid[1,0]*grid[3,2])*d
			matrix.grid[1,3] = (grid[0,0]*grid[1,2]*grid[2,3] + grid[0,2]*grid[1,3]*grid[2,0] + grid[0,3]*grid[1,0]*grid[2,2] - grid[0,0]*grid[1,3]*grid[2,2] - grid[0,2]*grid[1,0]*grid[2,3] - grid[0,3]*grid[1,2]*grid[2,0])*d
			matrix.grid[2,1] = (grid[0,0]*grid[2,3]*grid[3,1] + grid[0,1]*grid[2,0]*grid[3,3] + grid[0,3]*grid[2,1]*grid[3,0] - grid[0,0]*grid[2,1]*grid[3,3] - grid[0,1]*grid[2,3]*grid[3,0] - grid[0,3]*grid[2,0]*grid[3,1])*d
			matrix.grid[2,2] = (grid[0,0]*grid[1,1]*grid[3,3] + grid[0,1]*grid[1,3]*grid[3,0] + grid[0,3]*grid[1,0]*grid[3,1] - grid[0,0]*grid[1,3]*grid[3,1] - grid[0,1]*grid[1,0]*grid[3,3] - grid[0,3]*grid[1,1]*grid[3,0])*d
			matrix.grid[2,3] = (grid[0,0]*grid[1,3]*grid[2,1] + grid[0,1]*grid[1,0]*grid[2,3] + grid[0,3]*grid[1,1]*grid[2,0] - grid[0,0]*grid[1,1]*grid[2,3] - grid[0,1]*grid[1,3]*grid[2,0] - grid[0,3]*grid[1,0]*grid[2,1])*d
			matrix.grid[3,1] = (grid[0,0]*grid[2,1]*grid[3,2] + grid[0,1]*grid[2,2]*grid[3,0] + grid[0,2]*grid[2,0]*grid[3,1] - grid[0,0]*grid[2,2]*grid[3,1] - grid[0,1]*grid[2,0]*grid[3,2] - grid[0,2]*grid[2,1]*grid[3,0])*d
			matrix.grid[3,2] = (grid[0,0]*grid[1,2]*grid[3,1] + grid[0,1]*grid[1,0]*grid[3,2] + grid[0,2]*grid[1,1]*grid[3,0] - grid[0,0]*grid[1,1]*grid[3,2] - grid[0,1]*grid[1,2]*grid[3,0] - grid[0,2]*grid[1,0]*grid[3,1])*d
			matrix.grid[3,3] = (grid[0,0]*grid[1,1]*grid[2,2] + grid[0,1]*grid[1,2]*grid[2,0] + grid[0,2]*grid[1,0]*grid[2,1] - grid[0,0]*grid[1,2]*grid[2,1] - grid[0,1]*grid[1,0]*grid[2,2] - grid[0,2]*grid[1,1]*grid[2,0])*d
	
			Return matrix
	End Method

	Method Translate4(x#,y#,z#,w#=1.0)
	
		grid[3,0] = grid#[0,0]*x# + grid#[1,0]*y# + grid#[2,0]*z# + grid#[3,0]*w
		grid[3,1] = grid#[0,1]*x# + grid#[1,1]*y# + grid#[2,1]*z# + grid#[3,1]*w
		grid[3,2] = grid#[0,2]*x# + grid#[1,2]*y# + grid#[2,2]*z# + grid#[3,2]*w
		grid[3,3] = grid#[0,3]*x# + grid#[1,3]*y# + grid#[2,3]*z# + grid#[3,3]*w
		
	End Method

Last edited 2012