Getting corner points of near and far planes?

Author

Message

Rudolpho

20

Years of Service

User Offline

Joined: 28th Dec 2005

Location: Sweden

Posted: 12th Sep 2013 18:26

Link

Like the title suggests, do anybody know of a efficient and simple way to accomplish that?
I've been struggling with various weird approaches that attempt to infer the corner coordinates from the view matrix, but they never seem to do what they're supposed to in the end.

Thanks in advance for any suggestions,
Rudolpho

"Why do programmers get Halloween and Christmas mixed up?"

+ Code Snippet

Because Oct(31) = Dec(25)

Back to top

Profile PM Email Website

pictionaryjr

17

Years of Service

User Offline

Joined: 12th Mar 2009

Location:

Posted: 12th Sep 2013 19:20 Edited at: 12th Sep 2013 19:42

Link

This is really quite simple to achieve with rotation matrices.

You would have to invision the plain at 0 with 0 rotation so if you had a 10 by 10 plain at 0 with no rotation it's top left corner would be -5,5,0. It's top right would be 5,5,0. It's bottom left would be -5,-5,0. It's bottom right would be 5,-5,0. You could then use rotation matrice's to calculate where the points would be at the actual rotation and then add the plains center coordinates onto the rotated corner coordinates. Bam you've got ure corners. I'll write a function for you in 1 sec.

Back to top

Profile PM Email

mr Handy

18

Years of Service

User Offline

Joined: 7th Sep 2007

Location: out of TGC

Posted: 12th Sep 2013 19:40

Link

Maybe do reversal (2d-to-3d) of this?

Back to top

Profile PM

pictionaryjr

17

Years of Service

User Offline

Joined: 12th Mar 2009

Location:

Posted: 12th Sep 2013 19:47

Link

This should work as long as you don't rotate the z axis. I made it for camera use originally so there was no z axis rotation. I'll fix for you though.

//1----2
//|    |
//3----4
Function PlainCornerXPosition( Corner as Integer , ObjNum as Integer )
	If Corner = 1 then XPos# = Object Position X( ObjNum ) + ThreeDimensionalRotationMatrixX( ( Object Size X( ObjNum ) / 2 ) * -1 , Object Size Y( ObjNum ) / 2 , 0 , Object Angle X( ObjNum ) , Object Angle Y( ObjNum ) )
	If Corner = 2 then XPos# = Object Position X( ObjNum ) + ThreeDimensionalRotationMatrixX( Object Size X( ObjNum ) / 2 , Object Size Y( ObjNum ) / 2 , 0 , Object Angle X( ObjNum ) , Object Angle Y( ObjNum ) )
	If Corner = 3 then XPos# = Object Position X( ObjNum ) + ThreeDimensionalRotationMatrixX( ( Object Size X( ObjNum ) / 2 ) * -1 , ( Object Size Y( ObjNum ) / 2 ) * -1 , 0 , Object Angle X( ObjNum ) , Object Angle Y( ObjNum ) )
	If Corner = 4 then XPos# = Object Position X( ObjNum ) + ThreeDimensionalRotationMatrixX( Object Size X( ObjNum ) / 2 , ( Object Size Y( ObjNum ) / 2 ) * -1 , 0 , Object Angle X( ObjNum ) , Object Angle Y( ObjNum ) )
EndFunction XPos#

Function PlainCornerYPosition( Corner as Integer , ObjNum as Integer )
	If Corner = 1 then YPos# = Object Position Y( ObjNum ) + ThreeDimensionalRotationMatrixY( ( Object Size X( ObjNum ) / 2 ) * -1 , Object Size Y( ObjNum ) / 2 , 0 , Object Angle X( ObjNum ) , Object Angle Y( ObjNum ) )
	If Corner = 2 then YPos# = Object Position Y( ObjNum ) + ThreeDimensionalRotationMatrixY( Object Size X( ObjNum ) / 2 , Object Size Y( ObjNum ) / 2 , 0 , Object Angle X( ObjNum ) , Object Angle Y( ObjNum ) )
	If Corner = 3 then YPos# = Object Position Y( ObjNum ) + ThreeDimensionalRotationMatrixY( ( Object Size X( ObjNum ) / 2 ) * -1 , ( Object Size Y( ObjNum ) / 2 ) * -1 , 0 , Object Angle X( ObjNum ) , Object Angle Y( ObjNum ) )
	If Corner = 4 then YPos# = Object Position Y( ObjNum ) + ThreeDimensionalRotationMatrixY( Object Size X( ObjNum ) / 2 , ( Object Size Y( ObjNum ) / 2 ) * -1 , 0 , Object Angle X( ObjNum ) , Object Angle Y( ObjNum ) )
EndFunction YPos#

Function PlainCornerZPosition( Corner as Integer , ObjNum as Integer )
	If Corner = 1 then ZPos# = Object Position Z( ObjNum ) + ThreeDimensionalRotationMatrixZ( ( Object Size X( ObjNum ) / 2 ) * -1 , Object Size Y( ObjNum ) / 2 , 0 , Object Angle X( ObjNum ) , Object Angle Y( ObjNum ) )
	If Corner = 2 then ZPos# = Object Position Z( ObjNum ) + ThreeDimensionalRotationMatrixZ( Object Size X( ObjNum ) / 2 , Object Size Y( ObjNum ) / 2 , 0 , Object Angle X( ObjNum ) , Object Angle Y( ObjNum ) )
	If Corner = 3 then ZPos# = Object Position Z( ObjNum ) + ThreeDimensionalRotationMatrixZ( ( Object Size X( ObjNum ) / 2 ) * -1 , ( Object Size Y( ObjNum ) / 2 ) * -1 , 0 , Object Angle X( ObjNum ) , Object Angle Y( ObjNum ) )
	If Corner = 4 then ZPos# = Object Position Z( ObjNum ) + ThreeDimensionalRotationMatrixZ( Object Size X( ObjNum ) / 2 , ( Object Size Y( ObjNum ) / 2 ) * -1 , 0 , Object Angle X( ObjNum ) , Object Angle Y( ObjNum ) )
EndFunction ZPos#

Function ThreeDimensionalRotationMatrixX(XPos as Float ,YPos as Float ,ZPos as Float ,AngX as Float ,AngY as Float )
   ZPos=(YPos*Sin(AngX))+(ZPos*Cos(AngX))
   XPos=(XPos*Cos(AngY))+(ZPos*Sin(AngY))
EndFunction XPos

Function ThreeDimensionalRotationMatrixY(XPos as Float ,YPos as Float ,ZPos as Float ,AngX as Float ,AngY as Float )
   YPos=(YPos*Cos(AngX))+(ZPos*(-1*Sin(AngX)))
EndFunction YPos

Function ThreeDimensionalRotationMatrixZ(XPos as Float ,YPos as Float ,ZPos as Float ,AngX as Float ,AngY as Float )
   ZPos=(YPos*Sin(AngX))+(ZPos*Cos(AngX))
   ZPos=(XPos*(-1*Sin(AngY)))+(ZPos*Cos(AngY))
EndFunction ZPos

+ Code Snippet

//1----2
//|    |
//3----4
Function PlainCornerXPosition( Corner as Integer , ObjNum as Integer )
	If Corner = 1 then XPos# = Object Position X( ObjNum ) + ThreeDimensionalRotationMatrixX( ( Object Size X( ObjNum ) / 2 ) * -1 , Object Size Y( ObjNum ) / 2 , 0 , Object Angle X( ObjNum ) , Object Angle Y( ObjNum ) )
	If Corner = 2 then XPos# = Object Position X( ObjNum ) + ThreeDimensionalRotationMatrixX( Object Size X( ObjNum ) / 2 , Object Size Y( ObjNum ) / 2 , 0 , Object Angle X( ObjNum ) , Object Angle Y( ObjNum ) )
	If Corner = 3 then XPos# = Object Position X( ObjNum ) + ThreeDimensionalRotationMatrixX( ( Object Size X( ObjNum ) / 2 ) * -1 , ( Object Size Y( ObjNum ) / 2 ) * -1 , 0 , Object Angle X( ObjNum ) , Object Angle Y( ObjNum ) )
	If Corner = 4 then XPos# = Object Position X( ObjNum ) + ThreeDimensionalRotationMatrixX( Object Size X( ObjNum ) / 2 , ( Object Size Y( ObjNum ) / 2 ) * -1 , 0 , Object Angle X( ObjNum ) , Object Angle Y( ObjNum ) )
EndFunction XPos#

Function PlainCornerYPosition( Corner as Integer , ObjNum as Integer )
	If Corner = 1 then YPos# = Object Position Y( ObjNum ) + ThreeDimensionalRotationMatrixY( ( Object Size X( ObjNum ) / 2 ) * -1 , Object Size Y( ObjNum ) / 2 , 0 , Object Angle X( ObjNum ) , Object Angle Y( ObjNum ) )
	If Corner = 2 then YPos# = Object Position Y( ObjNum ) + ThreeDimensionalRotationMatrixY( Object Size X( ObjNum ) / 2 , Object Size Y( ObjNum ) / 2 , 0 , Object Angle X( ObjNum ) , Object Angle Y( ObjNum ) )
	If Corner = 3 then YPos# = Object Position Y( ObjNum ) + ThreeDimensionalRotationMatrixY( ( Object Size X( ObjNum ) / 2 ) * -1 , ( Object Size Y( ObjNum ) / 2 ) * -1 , 0 , Object Angle X( ObjNum ) , Object Angle Y( ObjNum ) )
	If Corner = 4 then YPos# = Object Position Y( ObjNum ) + ThreeDimensionalRotationMatrixY( Object Size X( ObjNum ) / 2 , ( Object Size Y( ObjNum ) / 2 ) * -1 , 0 , Object Angle X( ObjNum ) , Object Angle Y( ObjNum ) )
EndFunction YPos#

Function PlainCornerZPosition( Corner as Integer , ObjNum as Integer )
	If Corner = 1 then ZPos# = Object Position Z( ObjNum ) + ThreeDimensionalRotationMatrixZ( ( Object Size X( ObjNum ) / 2 ) * -1 , Object Size Y( ObjNum ) / 2 , 0 , Object Angle X( ObjNum ) , Object Angle Y( ObjNum ) )
	If Corner = 2 then ZPos# = Object Position Z( ObjNum ) + ThreeDimensionalRotationMatrixZ( Object Size X( ObjNum ) / 2 , Object Size Y( ObjNum ) / 2 , 0 , Object Angle X( ObjNum ) , Object Angle Y( ObjNum ) )
	If Corner = 3 then ZPos# = Object Position Z( ObjNum ) + ThreeDimensionalRotationMatrixZ( ( Object Size X( ObjNum ) / 2 ) * -1 , ( Object Size Y( ObjNum ) / 2 ) * -1 , 0 , Object Angle X( ObjNum ) , Object Angle Y( ObjNum ) )
	If Corner = 4 then ZPos# = Object Position Z( ObjNum ) + ThreeDimensionalRotationMatrixZ( Object Size X( ObjNum ) / 2 , ( Object Size Y( ObjNum ) / 2 ) * -1 , 0 , Object Angle X( ObjNum ) , Object Angle Y( ObjNum ) )
EndFunction ZPos#

Function ThreeDimensionalRotationMatrixX(XPos as Float ,YPos as Float ,ZPos as Float ,AngX as Float ,AngY as Float )
   ZPos=(YPos*Sin(AngX))+(ZPos*Cos(AngX))
   XPos=(XPos*Cos(AngY))+(ZPos*Sin(AngY))
EndFunction XPos

Function ThreeDimensionalRotationMatrixY(XPos as Float ,YPos as Float ,ZPos as Float ,AngX as Float ,AngY as Float )
   YPos=(YPos*Cos(AngX))+(ZPos*(-1*Sin(AngX)))
EndFunction YPos

Function ThreeDimensionalRotationMatrixZ(XPos as Float ,YPos as Float ,ZPos as Float ,AngX as Float ,AngY as Float )
   ZPos=(YPos*Sin(AngX))+(ZPos*Cos(AngX))
   ZPos=(XPos*(-1*Sin(AngY)))+(ZPos*Cos(AngY))
EndFunction ZPos

Back to top

Profile PM Email

Rudolpho

20

Years of Service

User Offline

Joined: 28th Dec 2005

Location: Sweden

Posted: 12th Sep 2013 20:49

Link

Thanks for your suggestions.
I however don't have any actual plane object, but was rather referring to the near/far planes of a camera's view frustum. As such I don't know the dimensions of the planes. However, maybe that can be calculated from the fov, aspect ratio and near/far distances, in which case your approach might work. Will look into it

"Why do programmers get Halloween and Christmas mixed up?"

+ Code Snippet

Because Oct(31) = Dec(25)

Back to top

Profile PM Email Website

mr Handy

18

Years of Service

User Offline

Joined: 7th Sep 2007

Location: out of TGC

Posted: 12th Sep 2013 21:13 Edited at: 12th Sep 2013 21:27

Link

You need to get 4 vectors (are red), from camera to each of the corners (direction). From camera view that vectors would be seen as red dots, because they are view vectors. Then you get 3d coords from 2 distances - near and far. Look at that thread with matrices.

Back to top

Profile PM

pictionaryjr

17

Years of Service

User Offline

Joined: 12th Mar 2009

Location:

Posted: 12th Sep 2013 21:37 Edited at: 12th Sep 2013 21:40

Link

Edit:
Read comment sorry

DOUBLED EDIT:
MR Handy pretty much explains what you're looking for, but random question as to why. We might be able to help you further if you explain you're reason for finding the viewing planes

Back to top

Profile PM Email

Rudolpho

20

Years of Service

User Offline

Joined: 28th Dec 2005

Location: Sweden

Posted: 12th Sep 2013 22:15 Edited at: 12th Sep 2013 22:16

Link

@Mr Handy: Your solution makes sense, but how would I find a vector between two points to figure out the second point when all I have is the first?

Or maybe I'm missing something?

@pictionaryjr: The reason for this is so that I can create a bounding volume for what is seen by the main scene camera. The volume will then be used to build an orthographic projection matrix for a depth rendering camera, thus allowing for better shadow detail in large scenes by only considering the areas that are actually seen on screen.

"Why do programmers get Halloween and Christmas mixed up?"

+ Code Snippet

Because Oct(31) = Dec(25)

Back to top

Profile PM Email Website

pictionaryjr

17

Years of Service

User Offline

Joined: 12th Mar 2009

Location:

Posted: 12th Sep 2013 22:35 Edited at: 13th Sep 2013 07:37

Link

Use it each function twice for each corner of the screen. First time will be cast at the distance of 1 or 0 and second will be cast at whatever you want the edge of your bounding volume to be. Bam. All 8 corners with xyz

//////////////////////////////////////////////////////////////////
//Function Name: Three Dimensional Ray Point X					//
//////////////////////////////////////////////////////////////////
//Description: This calculates a 3D X coordinate from a 2D 		//
//	screen coordinate, rotates it with a rotation matrix, and	//
//	then repositions it to the camera X coordinate.				//
//Variables:													//
//	Distance - Zdepth you're casting the ray to					//
//	CameraXAng - The X angle of the camera						//
//	CameraYAng - The Y angle of the camera						//
//	CameraXPos - The 3D X coordinate position of the camera		//
//	ScreenXPos - The 2D X coordinate of the point to be casted	//
//	ScreenYPos - The 2D Y coordinate of the point to be casted	//
//////////////////////////////////////////////////////////////////
Function ThreeDimensionalRayPointX( Distance as Float , CameraXAng as Float , CameraYAng as Float , CameraZAng , CameraXPos as Float , ScreenXPos as Float , ScreenYPos as Float ) 
   FieldOfView# = (3.14/2.905)*57.2957795
   ScreenWidth# = ScreenWidth
   ScreenHeight# = ScreenHeight
   ScreenY# = Tan( FieldOfView# / 2 )
   ScreenX# = ScreenY# * ( ScreenWidth# / ScreenHeight# )
   PixelX# = ( ( ( Distance * ScreenX# ) + ScreenX# ) * 2 ) / ScreenWidth#
   PixelY# = ( ( ( Distance * ScreenY# ) + ScreenY# ) * 2 ) / ScreenHeight#
   XPos# = ( ScreenXPos * PixelX# ) - ( ( Distance * ScreenX# ) + ScreenX# )
   YPos# = ( ( Distance * ScreenY# ) + ScreenY# ) - ( ScreenYPos * PixelY# )
   ZPos# = Distance + 1
   	//X Axis
	RotatedYPos#=(YPos#*Cos(CameraXAng))+(ZPos#*(-1*Sin(CameraXAng)))
	RotatedZPos#=(YPos#*Sin(CameraXAng))+(ZPos#*Cos(CameraXAng))
	//Y Axis
	RotatedXPos#=(XPos#*Cos(CameraYAng))+(RotatedZPos#*Sin(CameraYAng))
	RotatedZPos#=(XPos#*(-1*Sin(CameraYAng)))+(RotatedZPos#*Cos(CameraYAng))
	//Z Axis
	RotatedXPos#=(RotatedXPos#*Cos(CameraZAng))+(RotatedYPos#*(-1*Sin(CameraZAng)))
   XPos# = RotatedXPos# + CameraXPos
EndFunction XPos#

//////////////////////////////////////////////////////////////////
//Function Name: Three Dimensional Ray Point Y					//
//////////////////////////////////////////////////////////////////
//Description: This calculates a 3D Y coordinate from a 2D 		//
//	screen coordinate, rotates it with a rotation matrix, and	//
//	then repositions it to the camera Y coordinate.				//
//Variables:													//
//	Distance - Zdepth you're casting the ray to					//
//	CameraXAng - The X angle of the camera						//
//	CameraYPos - The 3D Y coordinate position of the camera		//
//	ScreenYPos - The 2D Y coordinate of the point to be casted	//
//////////////////////////////////////////////////////////////////
Function ThreeDimensionalRayPointY( Distance as Float , CameraXAng as Float , CameraYAng as Float , CameraZAng , CameraYPos as Float , ScreenXPos as Float , ScreenYPos as Float )
   FieldOfView# = (3.14/2.905)*57.2957795
   ScreenWidth# = ScreenWidth
   ScreenHeight# = ScreenHeight
   ScreenY# = Tan( FieldOfView# / 2 )
   ScreenX# = ScreenY# * ( ScreenWidth# / ScreenHeight# )
   PixelX# = ( ( ( Distance * ScreenX# ) + ScreenX# ) * 2 ) / ScreenWidth#
   PixelY# = ( ( ( Distance * ScreenY# ) + ScreenY# ) * 2 ) / ScreenHeight#
   XPos# = ( ScreenXPos * PixelX# ) - ( ( Distance * ScreenX# ) + ScreenX# )
   YPos# = ( ( Distance * ScreenY# ) + ScreenY# ) - ( ScreenYPos * PixelY# )
   ZPos# = Distance + 1
   	//X Axis
	RotatedYPos#=(YPos#*Cos(CameraXAng))+(ZPos#*(-1*Sin(CameraXAng)))
	RotatedZPos#=(YPos#*Sin(CameraXAng))+(ZPos#*Cos(CameraXAng))
	//Y Axis
	RotatedXPos#=(XPos#*Cos(CameraYAng))+(RotatedZPos#*Sin(CameraYAng))
	RotatedZPos#=(XPos#*(-1*Sin(CameraYAng)))+(RotatedZPos#*Cos(CameraYAng))
	//Z Axis
	RotatedYPos#=(RotatedXPos#*Sin(CameraZAng))+(RotatedYPos#*Cos(CameraZAng))
   YPos# = RotatedYPos# + CameraYPos
EndFunction YPos#

//////////////////////////////////////////////////////////////////
//Function Name: Three Dimensional Ray Point Z					//
//////////////////////////////////////////////////////////////////
//Description: This calculates a 3D Z coordinate from a 2D 		//
//	screen coordinate, rotates it with a rotation matrix, and	//
//	then repositions it to the camera Z coordinate.				//
//Variables:													//
//	Distance - Zdepth you're casting the ray to					//
//	CameraXAng - The X angle of the camera						//
//	CameraYAng - The Y angle of the camera						//
//	CameraZPos - The 3D Z coordinate position of the camera		//
//	ScreenXPos - The 2D X coordinate of the point to be casted	//
//	ScreenYPos - The 2D Y coordinate of the point to be casted	//
//////////////////////////////////////////////////////////////////
Function ThreeDimensionalRayPointZ( Distance as Float , CameraXAng as Float , CameraYAng as Float , CameraZPos as Float , ScreenXPos as Float , ScreenYPos as Float )
   FieldOfView# = (3.14/2.905)*57.2957795
   ScreenWidth# = ScreenWidth
   ScreenHeight# = ScreenHeight
   ScreenY# = Tan( FieldOfView# / 2 )
   ScreenX# = ScreenY# * ( ScreenWidth# / ScreenHeight# )
   PixelX# = ( ( ( Distance * ScreenX# ) + ScreenX# ) * 2 ) / ScreenWidth#
   PixelY# = ( ( ( Distance * ScreenY# ) + ScreenY# ) * 2 ) / ScreenHeight#
   XPos# = ( ScreenXPos * PixelX# ) - ( ( Distance * ScreenX# ) + ScreenX# )
   YPos# = ( ( Distance * ScreenY# ) + ScreenY# ) - ( ScreenYPos * PixelY# )
   ZPos# = Distance + 1
   	//X Axis
	RotatedYPos#=(YPos#*Cos(CameraXAng))+(ZPos#*(-1*Sin(CameraXAng)))
	RotatedZPos#=(YPos#*Sin(CameraXAng))+(ZPos#*Cos(CameraXAng))
	//Y Axis
	RotatedXPos#=(XPos#*Cos(CameraYAng))+(RotatedZPos#*Sin(CameraYAng))
	RotatedZPos#=(XPos#*(-1*Sin(CameraYAng)))+(RotatedZPos#*Cos(CameraYAng))
   ZPos# = RotatedZPos# + CameraZPos
EndFunction ZPos#

+ Code Snippet

//////////////////////////////////////////////////////////////////
//Function Name: Three Dimensional Ray Point X					//
//////////////////////////////////////////////////////////////////
//Description: This calculates a 3D X coordinate from a 2D 		//
//	screen coordinate, rotates it with a rotation matrix, and	//
//	then repositions it to the camera X coordinate.				//
//Variables:													//
//	Distance - Zdepth you're casting the ray to					//
//	CameraXAng - The X angle of the camera						//
//	CameraYAng - The Y angle of the camera						//
//	CameraXPos - The 3D X coordinate position of the camera		//
//	ScreenXPos - The 2D X coordinate of the point to be casted	//
//	ScreenYPos - The 2D Y coordinate of the point to be casted	//
//////////////////////////////////////////////////////////////////
Function ThreeDimensionalRayPointX( Distance as Float , CameraXAng as Float , CameraYAng as Float , CameraZAng , CameraXPos as Float , ScreenXPos as Float , ScreenYPos as Float ) 
   FieldOfView# = (3.14/2.905)*57.2957795
   ScreenWidth# = ScreenWidth
   ScreenHeight# = ScreenHeight
   ScreenY# = Tan( FieldOfView# / 2 )
   ScreenX# = ScreenY# * ( ScreenWidth# / ScreenHeight# )
   PixelX# = ( ( ( Distance * ScreenX# ) + ScreenX# ) * 2 ) / ScreenWidth#
   PixelY# = ( ( ( Distance * ScreenY# ) + ScreenY# ) * 2 ) / ScreenHeight#
   XPos# = ( ScreenXPos * PixelX# ) - ( ( Distance * ScreenX# ) + ScreenX# )
   YPos# = ( ( Distance * ScreenY# ) + ScreenY# ) - ( ScreenYPos * PixelY# )
   ZPos# = Distance + 1
   	//X Axis
	RotatedYPos#=(YPos#*Cos(CameraXAng))+(ZPos#*(-1*Sin(CameraXAng)))
	RotatedZPos#=(YPos#*Sin(CameraXAng))+(ZPos#*Cos(CameraXAng))
	//Y Axis
	RotatedXPos#=(XPos#*Cos(CameraYAng))+(RotatedZPos#*Sin(CameraYAng))
	RotatedZPos#=(XPos#*(-1*Sin(CameraYAng)))+(RotatedZPos#*Cos(CameraYAng))
	//Z Axis
	RotatedXPos#=(RotatedXPos#*Cos(CameraZAng))+(RotatedYPos#*(-1*Sin(CameraZAng)))
   XPos# = RotatedXPos# + CameraXPos
EndFunction XPos#

//////////////////////////////////////////////////////////////////
//Function Name: Three Dimensional Ray Point Y					//
//////////////////////////////////////////////////////////////////
//Description: This calculates a 3D Y coordinate from a 2D 		//
//	screen coordinate, rotates it with a rotation matrix, and	//
//	then repositions it to the camera Y coordinate.				//
//Variables:													//
//	Distance - Zdepth you're casting the ray to					//
//	CameraXAng - The X angle of the camera						//
//	CameraYPos - The 3D Y coordinate position of the camera		//
//	ScreenYPos - The 2D Y coordinate of the point to be casted	//
//////////////////////////////////////////////////////////////////
Function ThreeDimensionalRayPointY( Distance as Float , CameraXAng as Float , CameraYAng as Float , CameraZAng , CameraYPos as Float , ScreenXPos as Float , ScreenYPos as Float )
   FieldOfView# = (3.14/2.905)*57.2957795
   ScreenWidth# = ScreenWidth
   ScreenHeight# = ScreenHeight
   ScreenY# = Tan( FieldOfView# / 2 )
   ScreenX# = ScreenY# * ( ScreenWidth# / ScreenHeight# )
   PixelX# = ( ( ( Distance * ScreenX# ) + ScreenX# ) * 2 ) / ScreenWidth#
   PixelY# = ( ( ( Distance * ScreenY# ) + ScreenY# ) * 2 ) / ScreenHeight#
   XPos# = ( ScreenXPos * PixelX# ) - ( ( Distance * ScreenX# ) + ScreenX# )
   YPos# = ( ( Distance * ScreenY# ) + ScreenY# ) - ( ScreenYPos * PixelY# )
   ZPos# = Distance + 1
   	//X Axis
	RotatedYPos#=(YPos#*Cos(CameraXAng))+(ZPos#*(-1*Sin(CameraXAng)))
	RotatedZPos#=(YPos#*Sin(CameraXAng))+(ZPos#*Cos(CameraXAng))
	//Y Axis
	RotatedXPos#=(XPos#*Cos(CameraYAng))+(RotatedZPos#*Sin(CameraYAng))
	RotatedZPos#=(XPos#*(-1*Sin(CameraYAng)))+(RotatedZPos#*Cos(CameraYAng))
	//Z Axis
	RotatedYPos#=(RotatedXPos#*Sin(CameraZAng))+(RotatedYPos#*Cos(CameraZAng))
   YPos# = RotatedYPos# + CameraYPos
EndFunction YPos#

//////////////////////////////////////////////////////////////////
//Function Name: Three Dimensional Ray Point Z					//
//////////////////////////////////////////////////////////////////
//Description: This calculates a 3D Z coordinate from a 2D 		//
//	screen coordinate, rotates it with a rotation matrix, and	//
//	then repositions it to the camera Z coordinate.				//
//Variables:													//
//	Distance - Zdepth you're casting the ray to					//
//	CameraXAng - The X angle of the camera						//
//	CameraYAng - The Y angle of the camera						//
//	CameraZPos - The 3D Z coordinate position of the camera		//
//	ScreenXPos - The 2D X coordinate of the point to be casted	//
//	ScreenYPos - The 2D Y coordinate of the point to be casted	//
//////////////////////////////////////////////////////////////////
Function ThreeDimensionalRayPointZ( Distance as Float , CameraXAng as Float , CameraYAng as Float , CameraZPos as Float , ScreenXPos as Float , ScreenYPos as Float )
   FieldOfView# = (3.14/2.905)*57.2957795
   ScreenWidth# = ScreenWidth
   ScreenHeight# = ScreenHeight
   ScreenY# = Tan( FieldOfView# / 2 )
   ScreenX# = ScreenY# * ( ScreenWidth# / ScreenHeight# )
   PixelX# = ( ( ( Distance * ScreenX# ) + ScreenX# ) * 2 ) / ScreenWidth#
   PixelY# = ( ( ( Distance * ScreenY# ) + ScreenY# ) * 2 ) / ScreenHeight#
   XPos# = ( ScreenXPos * PixelX# ) - ( ( Distance * ScreenX# ) + ScreenX# )
   YPos# = ( ( Distance * ScreenY# ) + ScreenY# ) - ( ScreenYPos * PixelY# )
   ZPos# = Distance + 1
   	//X Axis
	RotatedYPos#=(YPos#*Cos(CameraXAng))+(ZPos#*(-1*Sin(CameraXAng)))
	RotatedZPos#=(YPos#*Sin(CameraXAng))+(ZPos#*Cos(CameraXAng))
	//Y Axis
	RotatedXPos#=(XPos#*Cos(CameraYAng))+(RotatedZPos#*Sin(CameraYAng))
	RotatedZPos#=(XPos#*(-1*Sin(CameraYAng)))+(RotatedZPos#*Cos(CameraYAng))
   ZPos# = RotatedZPos# + CameraZPos
EndFunction ZPos#

Edit:
You could actually just apply it to the four corners using the desired distance and then just use a rotation matrix to calculate what the closest points would be

Double Edit:
Sorry I know I'm being cryptic, but if you'd like I could write up a function for that as well.

Back to top

Profile PM Email

Chris Tate

DBPro Master

17

Years of Service

User Offline

Joined: 29th Aug 2008

Location: London, England

Posted: 13th Sep 2013 00:05

Link

The 3D corner coordinates of the near and far planes are equal to the pick vectors of the viewport corner pixels using the near and far distance as the pick distance.

Back to top

Profile PM Email Website

Sasuke

20

Years of Service

User Offline

Joined: 2nd Dec 2005

Location: Milton Keynes UK

Posted: 13th Sep 2013 04:05 Edited at: 13th Sep 2013 04:24

Link

Wouldn't it be easier to just:

1: Work out offset distances from centre for vertical and horizontal
2: Get the camera Look, Up and Right vectors
3: Scale them by plane distance, vertical and horizontal distances
4: Add all vectors to camera position

For instance, this would calculate all points for a plane at any distance/angle:

` this bit you'd usually store when updating the camera so really all you need is the bit below (from the offsets)
camPosX = camera position x()
camPosY = camera position y()
camPosZ = camera position z()    
pitch   = camera angle x()
yaw     = camera angle y()
roll    = camera angle z()
lookX   = sin(roll)  * sin(pitch) + cos(roll) * sin(yaw) * cos(pitch)
lookY   = -cos(roll) * sin(pitch) + sin(roll) * sin(yaw) * cos(pitch)
lookZ   = cos(yaw)   * cos(pitch)    
upX     = -sin(roll) * cos(pitch) + cos(roll) * sin(yaw) * sin(pitch)
upY     = cos(roll)  * cos(pitch) + sin(roll) * sin(yaw) * sin(pitch)
upZ     = cos(yaw)   * sin(pitch)    
rightX  = cos(roll)  * cos(yaw)
rightY  = sin(roll)  * cos(yaw)
rightZ  = -sin(yaw)

` offsets from centre
verticalDistance = tan(FOV / 2.0) * planeDistance
horizontalDistance = verticalDistance * aspectRatio

` top left
x1X = camPosX + (lookX * planeDistance) + (upX * verticalDistance) + (rightX * -horizontalDistance)
x1Y = camPosY + (lookY * planeDistance) + (upY * verticalDistance) + (rightY * -horizontalDistance)
x1Z = camPosZ + (lookZ * planeDistance) + (upZ * verticalDistance) + (rightZ * -horizontalDistance)

` top right
y1X = camPosX + (lookX * planeDistance) + (upX * verticalDistance) + (rightX * horizontalDistance)
y1Y = camPosY + (lookY * planeDistance) + (upY * verticalDistance) + (rightY * horizontalDistance)
y1Z = camPosZ + (lookZ * planeDistance) + (upZ * verticalDistance) + (rightZ * horizontalDistance)

` bottom left
x2X = camPosZ + (lookX * planeDistance) + (upX * -verticalDistance) + (rightX * -horizontalDistance)
x2Y = camPosY + (lookY * planeDistance) + (upY * -verticalDistance) + (rightY * -horizontalDistance)
x2Z = camPosZ + (lookZ * planeDistance) + (upZ * -verticalDistance) + (rightZ * -horizontalDistance)

` bottom right
y2X = camPosZ + (lookX * planeDistance) + (upX * -verticalDistance) + (rightX * horizontalDistance)
y2Y = camPosY + (lookY * planeDistance) + (upY * -verticalDistance) + (rightY * horizontalDistance)
y2Z = camPosZ + (lookZ * planeDistance) + (upZ * -verticalDistance) + (rightZ * horizontalDistance)

+ Code Snippet

` this bit you'd usually store when updating the camera so really all you need is the bit below (from the offsets)
camPosX = camera position x()
camPosY = camera position y()
camPosZ = camera position z()    
pitch   = camera angle x()
yaw     = camera angle y()
roll    = camera angle z()
lookX   = sin(roll)  * sin(pitch) + cos(roll) * sin(yaw) * cos(pitch)
lookY   = -cos(roll) * sin(pitch) + sin(roll) * sin(yaw) * cos(pitch)
lookZ   = cos(yaw)   * cos(pitch)    
upX     = -sin(roll) * cos(pitch) + cos(roll) * sin(yaw) * sin(pitch)
upY     = cos(roll)  * cos(pitch) + sin(roll) * sin(yaw) * sin(pitch)
upZ     = cos(yaw)   * sin(pitch)    
rightX  = cos(roll)  * cos(yaw)
rightY  = sin(roll)  * cos(yaw)
rightZ  = -sin(yaw)

` offsets from centre
verticalDistance = tan(FOV / 2.0) * planeDistance
horizontalDistance = verticalDistance * aspectRatio

` top left
x1X = camPosX + (lookX * planeDistance) + (upX * verticalDistance) + (rightX * -horizontalDistance)
x1Y = camPosY + (lookY * planeDistance) + (upY * verticalDistance) + (rightY * -horizontalDistance)
x1Z = camPosZ + (lookZ * planeDistance) + (upZ * verticalDistance) + (rightZ * -horizontalDistance)

` top right
y1X = camPosX + (lookX * planeDistance) + (upX * verticalDistance) + (rightX * horizontalDistance)
y1Y = camPosY + (lookY * planeDistance) + (upY * verticalDistance) + (rightY * horizontalDistance)
y1Z = camPosZ + (lookZ * planeDistance) + (upZ * verticalDistance) + (rightZ * horizontalDistance) 

` bottom left
x2X = camPosZ + (lookX * planeDistance) + (upX * -verticalDistance) + (rightX * -horizontalDistance)
x2Y = camPosY + (lookY * planeDistance) + (upY * -verticalDistance) + (rightY * -horizontalDistance)
x2Z = camPosZ + (lookZ * planeDistance) + (upZ * -verticalDistance) + (rightZ * -horizontalDistance)

` bottom right
y2X = camPosZ + (lookX * planeDistance) + (upX * -verticalDistance) + (rightX * horizontalDistance)
y2Y = camPosY + (lookY * planeDistance) + (upY * -verticalDistance) + (rightY * horizontalDistance)
y2Z = camPosZ + (lookZ * planeDistance) + (upZ * -verticalDistance) + (rightZ * horizontalDistance)

"Get in the Van!" - Van B

Back to top

Profile PM Email

Chris Tate

DBPro Master

17

Years of Service

User Offline

Joined: 29th Aug 2008

Location: London, England

Posted: 13th Sep 2013 05:51

Link

Looks good

Back to top

Profile PM Email Website

Rudolpho

20

Years of Service

User Offline

Joined: 28th Dec 2005

Location: Sweden

Posted: 13th Sep 2013 14:35

Link

Quote: "The 3D corner coordinates of the near and far planes are equal to the pick vectors of the viewport corner pixels using the near and far distance as the pick distance."

Hah, I guess you're right about that, should've thought of that

@Sasuke: That's pretty much what I've been trying to do lately, albeit through vector math that gets weird when you cannot write it contiguously in DBPro and have to break it down. Not that that's hard per se, but it gets really funky to read 50 lines with copying to temporary vectors etc. because you can't just write (a * b) inline. Anyhow, your solution seems to yield the correct results, I will compare it to my code and see where I went wrong. Thank you very much

"Why do programmers get Halloween and Christmas mixed up?"

+ Code Snippet

Because Oct(31) = Dec(25)

Back to top

Profile PM Email Website

Sasuke

20

Years of Service

User Offline

Joined: 2nd Dec 2005

Location: Milton Keynes UK

Posted: 13th Sep 2013 15:16 Edited at: 13th Sep 2013 15:17

Link

Quote: "albeit through vector math that gets weird when you cannot write it contiguously in DBPro and have to break it down. Not that that's hard per se, but it gets really funky to read 50 lines with copying to temporary vectors etc. because you can't just write (a * b) inline."

Yeah, I just write wrappers to a temp vector for example:

type vector3
    x               as float
    y               as float
    z               as float
endtype

// temp vector
global _vector3     as vector3

global _pos             as vector3
global _ang             as vector3
global _right           as vector3
global _up              as vector3
global _look            as vector3

// **** how I would use the temp vector
getCameraPosition()     : _pos = _vector3
getCameraAngle()        : _ang = _vector3
getRightVector( _ang )  : _right = _vector3
getUpVector( _ang )     : _up = _vector3
getlookVector(  _ang )  : _look = _vector3
    
// vector functions
function setVector3( x as float, y as float, z as float )
    _vector3.x = x : _vector3.y = y : _vector3.z = z
endfunction

function getRightVector( angle as vector )
    _vector3.x = cos(angle.z) * cos(angle.y)
    _vector3.y = sin(angle.z) * cos(angle.y)
    _vector3.z = -sin(angle.y)
endfunction

function getUpVector( angle as vector )
    _vector3.x -sin(angle.z)  * cos(angle.x) + cos(angle.z) * sin(angle.y) * sin(angle.x)
    _vector3.y = cos(angle.z) * cos(angle.x) + sin(angle.z) * sin(angle.y) * sin(angle.x)
    _vector3.z = cos(angle.y) * sin(angle.x) 
endfunction    
    
function getLookVector( angle as vector )
    _vector3.x = sin(angle.z)  * sin(angle.x) + cos(angle.z) * sin(angle.y) * cos(angle.x)
    _vector3.y = -cos(angle.z) * sin(angle.x) + sin(angle.z) * sin(angle.y) * cos(angle.x)
    _vector3.z = cos(angle.y)  * cos(angle.x)
endfunction

// camera functions
function getCameraPosition()
    setVector3( camera position x(), camera position y(), camera position z() )
endfunction    
    
 function getCameraAngle()
    setVector3( camera angle x(), camera angle y(), camera angle z() )
endfunction

+ Code Snippet

type vector3
    x               as float
    y               as float
    z               as float
endtype

// temp vector
global _vector3     as vector3

global _pos             as vector3
global _ang             as vector3
global _right           as vector3
global _up              as vector3
global _look            as vector3

// **** how I would use the temp vector
getCameraPosition()     : _pos = _vector3
getCameraAngle()        : _ang = _vector3
getRightVector( _ang )  : _right = _vector3
getUpVector( _ang )     : _up = _vector3
getlookVector(  _ang )  : _look = _vector3
    
// vector functions
function setVector3( x as float, y as float, z as float )
    _vector3.x = x : _vector3.y = y : _vector3.z = z
endfunction

function getRightVector( angle as vector )
    _vector3.x = cos(angle.z) * cos(angle.y)
    _vector3.y = sin(angle.z) * cos(angle.y)
    _vector3.z = -sin(angle.y)
endfunction

function getUpVector( angle as vector )
    _vector3.x -sin(angle.z)  * cos(angle.x) + cos(angle.z) * sin(angle.y) * sin(angle.x)
    _vector3.y = cos(angle.z) * cos(angle.x) + sin(angle.z) * sin(angle.y) * sin(angle.x)
    _vector3.z = cos(angle.y) * sin(angle.x) 
endfunction    
    
function getLookVector( angle as vector )
    _vector3.x = sin(angle.z)  * sin(angle.x) + cos(angle.z) * sin(angle.y) * cos(angle.x)
    _vector3.y = -cos(angle.z) * sin(angle.x) + sin(angle.z) * sin(angle.y) * cos(angle.x)
    _vector3.z = cos(angle.y)  * cos(angle.x)
endfunction

// camera functions
function getCameraPosition()
    setVector3( camera position x(), camera position y(), camera position z() )
endfunction    
    
 function getCameraAngle()
    setVector3( camera angle x(), camera angle y(), camera angle z() )
endfunction

I also have a function set to just alter that temp vector so I only extract the final result, really cuts down on the work.

Quote: "Thank you very much "

No problem, I've found that the right, up and look vectors are extremely useful but not many people know of them. Maybe a tutorial should be written

"Get in the Van!" - Van B

Back to top

Profile PM Email

Rudolpho

20

Years of Service

User Offline

Joined: 28th Dec 2005

Location: Sweden

Posted: 13th Sep 2013 16:00 Edited at: 13th Sep 2013 16:01

Link

True that.
Here are some direct-access wrapper functions for retrieving the internal camera vectors that I use. Saves on all the extraneous trigonometric function calls (not that I think they will really slow down your application unless used way too often though).

rem Camera dll handle/index
#constant cameradll        1
load dll "DBProCameraDebug.dll", cameradll

rem Wrapper functions to said library follows

rem Retrieves a pointer to the tagCameraData struct of the given camera
function GetCameraData(cam as dword)
    ptr = call dll(cameradll, "?GetInternalData@@YAPAXH@Z", cam)
endfunction ptr

rem Retrieves a D3DXVECTOR3 from the given pointer and stores it to the provided vector3 index.
rem If 0 is provided as the vector index, a new vector will be created and it's ID is returned by this function.
function GetVector3(ptr as dword, vec as dword)
    if vec = 0 then vec = new vector3()
    set vector3 vec, peek float(ptr), peek float(ptr + 4), peek float(ptr + 8)
endfunction vec

rem Retrieves the look vector of the given camera
function GetCameraLookVector(cam as dword, vec as dword)
    rem The offset to the look vector in the tagCameraData struct is 128 bytes in.
    GetVector3(GetCameraData(cam) + 128, vec)
endfunction vec

rem Retrieves the up vector of the given camera
function GetCameraUpVector(cam as dword, vec as dword)
    rem The offset to the up vector in the tagCameraData struct is 140 bytes in.
    vec = GetVector3(GetCameraData(cam) + 140, vec)
endfunction vec

rem Retrieves the right vector of the given camera
function GetCameraRightVector(cam as dword, vec as dword)
    rem The offset to the right vector in the tagCameraData struct is 152 bytes in.
    vec = GetVector3(GetCameraData(cam) + 152, vec)
endfunction vec

rem Retrieves the position vector of the given camera
function GetCameraPositionVector(cam as dword, vec as dword)
    rem The offset to the position vector in the tagCameraData struct is 164 bytes in.
    vec = GetVector3(GetCameraData(cam) + 164, vec)
endfunction vec

+ Code Snippet

rem Camera dll handle/index
#constant cameradll        1
load dll "DBProCameraDebug.dll", cameradll

rem Wrapper functions to said library follows

rem Retrieves a pointer to the tagCameraData struct of the given camera
function GetCameraData(cam as dword)
    ptr = call dll(cameradll, "?GetInternalData@@YAPAXH@Z", cam)
endfunction ptr

rem Retrieves a D3DXVECTOR3 from the given pointer and stores it to the provided vector3 index.
rem If 0 is provided as the vector index, a new vector will be created and it's ID is returned by this function.
function GetVector3(ptr as dword, vec as dword)
    if vec = 0 then vec = new vector3()
    set vector3 vec, peek float(ptr), peek float(ptr + 4), peek float(ptr + 8)
endfunction vec

rem Retrieves the look vector of the given camera
function GetCameraLookVector(cam as dword, vec as dword)
    rem The offset to the look vector in the tagCameraData struct is 128 bytes in.
    GetVector3(GetCameraData(cam) + 128, vec)
endfunction vec

rem Retrieves the up vector of the given camera
function GetCameraUpVector(cam as dword, vec as dword)
    rem The offset to the up vector in the tagCameraData struct is 140 bytes in.
    vec = GetVector3(GetCameraData(cam) + 140, vec)
endfunction vec

rem Retrieves the right vector of the given camera
function GetCameraRightVector(cam as dword, vec as dword)
    rem The offset to the right vector in the tagCameraData struct is 152 bytes in.
    vec = GetVector3(GetCameraData(cam) + 152, vec)
endfunction vec

rem Retrieves the position vector of the given camera
function GetCameraPositionVector(cam as dword, vec as dword)
    rem The offset to the position vector in the tagCameraData struct is 164 bytes in.
    vec = GetVector3(GetCameraData(cam) + 164, vec)
endfunction vec

You can get all other relevant camera data (as well as set it) in the same way. The same goes for objects, images etc. Also something not too many seems to know about but that can indeed come in handy at times

"Why do programmers get Halloween and Christmas mixed up?"

+ Code Snippet

Because Oct(31) = Dec(25)

Back to top

Profile PM Email Website

Sasuke

20

Years of Service

User Offline

Joined: 2nd Dec 2005

Location: Milton Keynes UK

Posted: 13th Sep 2013 16:55

Link

Yeah I remember those, I tested the speed difference a while back, the only noticeable difference is the math equivalent for the right vector is far quicker where as the others aren't. There pretty identical though. But what I'd like to know is do they come back normalised?

Reason I use maths for most things is because I can see what's going on under the hood, plus I can see how things work so when I need to make some specific that you can't find a command for I know what do. Definitely feature specific though, what ever gets the job done faster wins so I use both.

"Get in the Van!" - Van B

Back to top

Profile PM Email

Sorry your browser is not supported!

DarkBASIC Professional Discussion / Getting corner points of near and far planes?