How to target voxel, Minecraft - style?

Blitz3D Forums/Blitz3D Tutorials/How to target voxel, Minecraft - style?

Liimbix

(Posted 2015) [#1]

Hi all, I am very experienced with Blitz3D, and I am going to create a *very* basic and small voxel engine, just to mess around in. I notice in games such as Minecraft and the trillion ripoffs of it, when you point at a block, a black outline appears around it to show that you have it selected and you know what block you are pointing at. Just a question, what code / function / etc would I use to be able to target a block in an array? Let's say you're pointing to block[0,0,0] in coordinates. How would I highlight that block. I'm just confused as to how to get what coordinates you are looking at. Like I think I need mouse pitch and yaw or something to tell where you are looking, but I'm not sure. Sorry if this was confusing, and if you need me to help clarify, I would be happy to restate something. (this is an example of what I mean: http://forum.unity3d.com/attachments/77876/ ) Thanks!! (sorry for bad english btw I am learning) (:

xlsior

(Posted 2015) [#2]

Overlay the block at that location with a slightly-larger wireframe cube object, which would highlight the edges?

Liimbix

(Posted 2015) [#3]

Yeah, I pretty much know how to do it, I am sorry if I didn't word my question right, I was just wondering how to tell where the mouse is pointing, and then highlight the block the mouse is pointing at. I believe I need to use the camera z and x coordinates and mouse pitch and yaw.. I'm just not sure exactly what the algorithm would be.

Kryzon

(Posted 2015) [#4]

Hello Liimbix.
Your computer screen is aligned perfectly with the near-plane of the camera in the 3D world. The default near-plane distance in Blitz3D is 1.0.

At a distance of 1.0 units from the camera in its viewing direction you'll find your near-plane. At this distance, with the default zoom of 1.0 (which is equivalent to a 90º degree field-of-view), the size of the near-plane is 2.0 x 2*(height / width) in 3D units.
So imagine a 3D rectangle of size 2.0 x 2*(height / width), centered on the camera viewing direction.

You want to map the mouse coordinates -- a 2D point on the near plane with the origin at the top-left corner -- to 3D units so that you can find the ray that goes from the camera position through the mouse coordinates on the near plane to far away into infinity. You can compute that with the following:

Graphics3D( 800, 600, 0, 2 )

Local myCamera = CreateCamera()
CameraClsColor( myCamera, 0, 20, 20 )

Local mouseSphere = CreateSphere()
EntityColor( mouseSphere, 255, 200, 20 )

Local l = CreateLight()
TurnEntity( l, 30, 60, 0 )
AmbientLight( 50, 0, 250 ) ;Colour the shadows.

Local renderTimer = CreateTimer( 30 ) ;Avoids the CPU from going to 100%.

Const KEY_ESCAPE = 1
Const NEAR_PLANE_DISTANCE# = 1.0 ;As defined by CameraRange().
Const RAY_LENGTH# = 10.0 ;Ten 3D units away from the camera.

While Not KeyHit( KEY_ESCAPE )

	WaitTimer( renderTimer )
	
	;The following will normalise the mouse coordinates with the centre of the screen as origin:

	screenCentreX# = GraphicsWidth() / 2.0
	screenCentreY# = GraphicsHeight() / 2.0

	;MouseX() as seen from the centre of the screen and within the range [ -1.0, +1.0 ]
	;The distance from -1.0 to +1.0 is 2.0, the width of the near-plane in 3D units with a zoom of 1.0.
	;It goes from half of the plane to the other half because the plane is centered on the screen.
	
	normalisedMX# = ( MouseX() - screenCentreX ) / screenCentreX

	;MouseY() as seen from the centre of the screen and within the range [ -ratio, +ratio ]
	;Note that 'ratio' is height / width, NOT width over height as it's usually calculated (like 16:9, 4:3 etc.).
	
	heightToWidthRatio# = Float( GraphicsHeight() ) / GraphicsWidth()
	
	normalisedMY# = ( MouseY() - screenCentreY ) / screenCentreY * heightToWidthRatio
	
	;Now compute the ray direction from the camera to the point on the near-plane marked by the mouse.
	;This direction vector is in world coordinates.
	
	TFormNormal( normalisedMX, -normalisedMY, NEAR_PLANE_DISTANCE, myCamera, 0 )
	
	;Store the normal components in named variables to clarify their meaning.
	
	rayDirectionX# = TFormedX()
	rayDirectionY# = TFormedY()
	rayDirectionZ# = TFormedZ()
	
	;The ray is the following.
	;It starts from the camera. It goes towards rayDirection[N] * RAY_LENGTH.
		
	rayStartX# = EntityX( myCamera, True )
	rayStartY# = EntityY( myCamera, True )
	rayStartZ# = EntityZ( myCamera, True )
	
	rayEndX# = rayStartX + ( rayDirectionX * RAY_LENGTH )
	rayEndY# = rayStartY + ( rayDirectionY * RAY_LENGTH )
	rayEndZ# = rayStartZ + ( rayDirectionZ * RAY_LENGTH )
	
	PositionEntity( mouseSphere, rayEndX, rayEndY, rayEndZ, True ) ;Position the sphere at the end of the mouse ray.
	
	RenderWorld()	
	Flip( True )
	
Wend

End

Since that Minecraft clone has the mouse always centered you don't need all these calculations, but they're good to know nonetheless.
The normalised direction of the ray coming from the camera to the centre of the screen is this:

;Get the normalised vector going from the camera in its view direction, in world-space coordinates.
;The position of the camera is already its centre, so there's no need for any offset.

TFormNormal( 0, 0, 1, myCamera, 0 )

Const RAY_LENGTH# = 1000000.0

rayStartX# = EntityX( myCamera, True )
rayStartY# = EntityY( myCamera, True )
rayStartZ# = EntityZ( myCamera, True )

rayEndX# = rayStartX + ( TFormedX() * RAY_LENGTH )
rayEndY# = rayStartY + ( TFormedY() * RAY_LENGTH )
rayEndZ# = rayStartZ + ( TFormedZ() * RAY_LENGTH )

Liimbix

(Posted 2015) [#5]

Kryzon, that helped a lot! I wasn't sure how to raycast straight from the camera to the centre of the screen, and I was going to use a makeshift cube and use the cameras pitch values to locate where the camera is pointing, but your method is better. Thanks so much (:

Kryzon

(Posted 2015) [#6]

I changed the first section in that post to a practical example, there were some things I had written wrong.
The size of the near plane depends on the zoom of the camera (it's related to its field-of-view angle). The FOV angle dictates how wide the near-plane is depending on how far you go from the camera.

If you imagine a 90º FOV split in the middle, each half has tangents of 45º and this results in 1.0. Because of this, with a 90º FOV the near-plane is always twice as wide as it is far from the camera.
When you go 1.0 units in front of the camera, the near plane has 1.0 units to either side, which totals 2.0 width.
The height of the near-plane is always derived from its width and the inverse resolution ratio, so it's (screenHeight / screenWidth) * (planeWidth), with 'planeWidth' being 2.0.

Liimbix

(Posted 2015) [#7]

Thanks Kryzon for all the help, but I am not using rays. I am using MousePick, and it is working great! Thank you though (:

Kryzon

(Posted 2015) [#8]

Perhaps you mean CameraPick? That's a good alternative, I had forgotten about it.

It uses the internal picking system from Blitz3D. If you start noticing performance issues from picking scenes with thousands of cubes, you'll have to use ray-casting and an octree structure (to be implemented in code).