3d tilemaps - a possbility?

How feasible would it be, performance-wise, to use Blitz3d to create a 3D tilemap engine (imagine a large 128 x 128 grid comprising of a seperate mesh for each tile)?

By my calculations there could be millions of polyons on screen at any one time...

Just wondering if anyone's tried this?

This was actually something I looked into when I first obtained Blitz3D. The first hurdle is what the landscape is going to be made of. Blitz's own terrains have fantastic LOD (Level of Detail) handling, but unfortunately you will notice "seams" between the tiles where the polygons are approximated leaving ugly voids. The second obvious hurdle is poly count. With a mesh you won't have the problems terrains have, but unless you have a mammoth machine with plenty of memory, your poor renderer might suffer under the strain.

Its not a completely bad idea though, as long as you can create a workable LOD system. This entails cutting down polygon counts for distant objects either by using premade lower-poly models or dynamically altering the model (much like Blitz terrain). But I guess it all depends on what you want each tile to contain. Perhaps if you could give a few more details on what you want to achieve?

Well, I was thinking back to an old PC game called Jagged Alliance, an isometric tiled turn-based tactical shooter. The thing I liked about the game was the ability to blow holes in walls.

The main idea behind using small tiles in 3d would be the ability to destruct any tile on the board. However given the poly count and problems with LOD as you mentioned, I don't think it would be achievable sadly.

The other option could be to remove tile-based combat altogether, and use CSG to blow holes in stuff, but again that's completely unpredictable and slow.

Games like Rollercoaster Tycoon 3 pretty much work like this. I think it's pretty feasible. As for the seams, I believe this works fine if you actually overlap the tiles slightly.

Wouldn't the only real problem for Blitz be its 'surface' problem, or would it be possible to combine them to be one surface?

I've had a little play around with this idea, and its not unrealistic at all. Unless you have the full 128x128 map in view at all times, Blitz does a decent enough job of minimising the rendering so it runs at an acceptable pace. To make things interesting, I even threw in multiple heights and joined them together with extra polys, as you would have in a real game without any problems.

If you're going to have a lot of the map on view at a time, I'd suggest using fogging to cut down render costs (using CameraFogMode is the easiest way). That way it doesn't look ugly, but at the same time distant objects are not being rendered so your scene is still moving along at a decent pace.

Another way would be using EntityAutoFade for objects. That way they fade in/out automatically depending on their distance to you. (similar to fog but not this ugly wall in front of you)

Well, I figure I might as well post my source code here for you to take a look at. Its not very pretty since it was a really quick throw-together piece but it should help you somewhat on your way to figuring out how you want to work things.

The system creates tiles (32x32 in my map) and then uses a seperate single-surface mesh to fill the gaps between raised and unraised tiles. I'm sure you can improve upon this simple idea.

Graphics3D 640, 480
SetBuffer BackBuffer()

Dim map(32, 32)

Global quad = CreateMesh()
Global cam = CreateCamera()
Global brush = LoadBrush("grass.jpg", 9)
PaintEntity quad, brush

Global overmesh = 0

surf = CreateSurface(quad)

v1 = AddVertex(surf, -.5, 0, 0.5, 0, 0)
v2 = AddVertex(surf, -.5, 0, -.5, 0, 1)
v3 = AddVertex(surf, 0.5, 0, 0.5, 1, 0)
v4 = AddVertex(surf, 0.5, 0, -.5, 1, 1)

AddTriangle(surf, v1, v3, v2)
AddTriangle(surf, v4, v2, v3)

For x = -16 To 16
	For z = -16 To 16
		map(x + 16, z + 16) = CopyEntity(quad)
		PositionEntity map(x + 16, z + 16), x, Rnd#(0, 3), z
	Next
Next

FreeEntity quad
TranslateEntity map(16,16), 0, 1, 0
TranslateEntity cam, 0, 1, 0

Main()

Function Main()
	omesh = True
	Repeat 
		
		If KeyDown(200) TranslateEntity cam, 0, 0, 0.5
		If KeyDown(208) TranslateEntity cam, 0, 0, -.5
		If KeyDown(205) TranslateEntity cam, 0.5, 0, 0
		If KeyDown(203) TranslateEntity cam, -.5, 0, 0
		If KeyDown(30) TranslateEntity cam, 0, 0.1, 0
		If KeyDown(44) TranslateEntity cam, 0, -.1, 0
		If KeyHit(15) wframe = Not wframe
		If KeyHit(57) omesh = Not omesh
		
		WireFrame wframe
		
		RenderGaps()
		If omesh
			ShowEntity overmesh
		Else
			HideEntity overmesh
		EndIf
	
		UpdateWorld
		RenderWorld
		Text 0,0, TrisRendered()
		Text 0,12, sun
		Flip
	Until KeyHit(1)
End Function

Function RenderGaps()

	Local e1, e2, e3
	Local y1#, y2#, y3#
	e1 = e2 = e3 = 0
	y1# = y2# = y3# = 0

	If overmesh <> 0
		FreeEntity overmesh
		overmesh = 0
	EndIf
	
	overmesh = CreateMesh()
	oversurf = CreateSurface(overmesh)
	
	For a = 0 To 32
		For b = 0 To 32
			e1 = map(a, b)
			If a < 32
				e2 = map(a + 1, b)
			Else
				e2 = 0
			EndIf
			
			If b < 32
				e3 = map(a, b + 1)
			Else
				e3 = 0
			EndIf
			
			If e2 <> 0
				y1# = EntityY#(e1)
				y2# = EntityY#(e2)
				
				If y1# <> y2#
					HRZCombine(e1, e2, oversurf)
				EndIf
			EndIf
			
			If e3 <> 0
				y1# = EntityY#(e1)
				y3# = EntityY#(e3)
				
				If y1# <> y3#
					VRTCombine(e1, e3, oversurf)
				EndIf
			EndIf
		Next
	Next
	PaintEntity overmesh, brush
End Function

Function HRZCombine(mesh1, mesh2, surf)
	Local v1, v2, v3, v4
	Local v1x#, v1y#, v1z#
	Local v2x#, v2y#, v2z#
	Local v3x#, v3y#, v3z#
	Local v4x#, v4y#, v4z#

	v1x# = VertexX#(GetSurface(mesh1, 1), 2) + EntityX#(mesh1,1)
	v1y# = VertexY#(GetSurface(mesh1, 1), 2) + EntityY#(mesh1,1)
	v1z# = VertexZ#(GetSurface(mesh1, 1), 2) + EntityZ#(mesh1,1)
	
	v2x# = VertexX#(GetSurface(mesh1, 1), 3) + EntityX#(mesh1,1)
	v2y# = VertexY#(GetSurface(mesh1, 1), 3) + EntityY#(mesh1,1)
	v2z# = VertexZ#(GetSurface(mesh1, 1), 3) + EntityZ#(mesh1,1)
	
	v3x# = VertexX#(GetSurface(mesh2, 1), 0) + EntityX#(mesh2,1)
	v3y# = VertexY#(GetSurface(mesh2, 1), 0) + EntityY#(mesh2,1)
	v3z# = VertexZ#(GetSurface(mesh2, 1), 0) + EntityZ#(mesh2,1)
	
	v4x# = VertexX#(GetSurface(mesh2, 1), 1) + EntityX#(mesh2,1)
	v4y# = VertexY#(GetSurface(mesh2, 1), 1) + EntityY#(mesh2,1)
	v4z# = VertexZ#(GetSurface(mesh2, 1), 1) + EntityZ#(mesh2,1)
	
	v1 = AddVertex(surf, v1x#, v1y#, v1z#, 0, 0)
	v2 = AddVertex(surf, v2x#, v2y#, v2z#, 0, 1)
	v3 = AddVertex(surf, v3x#, v3y#, v3z#, 1, 0)
	v4 = AddVertex(surf, v4x#, v4y#, v4z#, 1, 1)
	
	AddTriangle(surf, v1, v3, v2)
	AddTriangle(surf, v4, v2, v3)
End Function

Function VRTCombine(mesh1, mesh2, surf)
	Local v1, v2, v3, v4
	Local v1x#, v1y#, v1z#
	Local v2x#, v2y#, v2z#
	Local v3x#, v3y#, v3z#
	Local v4x#, v4y#, v4z#

	v1x# = VertexX#(GetSurface(mesh1, 1), 0) + EntityX#(mesh1,1)
	v1y# = VertexY#(GetSurface(mesh1, 1), 0) + EntityY#(mesh1,1)
	v1z# = VertexZ#(GetSurface(mesh1, 1), 0) + EntityZ#(mesh1,1)
	
	v2x# = VertexX#(GetSurface(mesh1, 1), 2) + EntityX#(mesh1,1)
	v2y# = VertexY#(GetSurface(mesh1, 1), 2) + EntityY#(mesh1,1)
	v2z# = VertexZ#(GetSurface(mesh1, 1), 2) + EntityZ#(mesh1,1)
	
	v3x# = VertexX#(GetSurface(mesh2, 1), 1) + EntityX#(mesh2,1)
	v3y# = VertexY#(GetSurface(mesh2, 1), 1) + EntityY#(mesh2,1)
	v3z# = VertexZ#(GetSurface(mesh2, 1), 1) + EntityZ#(mesh2,1)
	
	v4x# = VertexX#(GetSurface(mesh2, 1), 3) + EntityX#(mesh2,1)
	v4y# = VertexY#(GetSurface(mesh2, 1), 3) + EntityY#(mesh2,1)
	v4z# = VertexZ#(GetSurface(mesh2, 1), 3) + EntityZ#(mesh2,1)
	
	v1 = AddVertex(surf, v1x#, v1y#, v1z#, 0, 0)
	v2 = AddVertex(surf, v2x#, v2y#, v2z#, 0, 1)
	v3 = AddVertex(surf, v3x#, v3y#, v3z#, 1, 0)
	v4 = AddVertex(surf, v4x#, v4y#, v4z#, 1, 1)
	
	AddTriangle(surf, v1, v3, v2)
	AddTriangle(surf, v4, v2, v3)
End Function

Oh, one thing I forgot to add. In my source code, I make the call to RenderGaps during the main loop. In your main code, you only need call this function if you move any of the tiles (for example, destroying a wall would lower the y# coordinate of a tile to the ground level) which speeds things up considerably.