Which is better (tiling question)

[dracule]

I am making a game, and was wondering which would be more effecient, 16x16 tiles, or larger tiles (say 32x32 or 64x64), the map is around 900x900 (the max before it started crashing, lua for some reason wont support anything bigger). Also, would it free up memory to only draw tiles that are on screen? Because I was going to not draw tiles that were off the screen, but I thought that it would have the same performance because all the information still remains in the psp's memory.

[yaustar]

If the tilemap, map structure and the blitting process is done correctly, you should have a higher framerate and less memory usage.

[Access_Denied]

Originally Posted by dracule

I am making a game, and was wondering which would be more effecient, 16x16 tiles, or larger tiles (say 32x32 or 64x64), the map is around 900x900 (the max before it started crashing, lua for some reason wont support anything bigger). Also, would it free up memory to only draw tiles that are on screen? Because I was going to not draw tiles that were off the screen, but I thought that it would have the same performance because all the information still remains in the psp's memory.

No, smaller tiles will slow it down, since it will have to blit more images per loop. And yes, only blit images that are on the screen. It will save RAM.

[yaustar]

Why would it be slower? You are blitting more SMALLER images rather then one LARGE one. 32x32 tile x 135 tiles = 138240 pixels to blit. 900x900 = 810000 pixels to blit. To me, thats a LOT faster.

[Access_Denied]

Originally Posted by head_54us

Why would it be slower? You are blitting more SMALLER images rather then one LARGE one. 32x32 tile x 135 tiles = 138240 pixels to blit. 900x900 = 810000 pixels to blit. To me, thats a LOT faster.

I have witnessed this first hand with Pencil Puzzles. That blitted 1600 5 x 5 tiles per loop. It ran slow as HELL. Trust me. It has to process more data with more tiles. It doesn't matter about the size.

[yaustar]

Hmm.. I wonder if this is due to Lua being a scripting language and taking a performence hit on the for loops. Compiled languages should optimise quite a bit at this point. It *shouldn't* be slower.

[Access_Denied]

Put it in perspective. You have two puzzles. On has 50 small pieces and one has 15 larger pieces. Which one is going to take you longer to put together?

[Grimfate126]

Originally Posted by ARza

I have witnessed this first hand with Pencil Puzzles. That blitted 1600 5 x 5 tiles per loop. It ran slow as HELL. Trust me. It has to process more data with more tiles. It doesn't matter about the size.

thats because you were using 5x5. you have to balance both out. not too many tiles, and not too large. which is faster:blitting 65280 2x2 tiles or just one big 480x272 map?? the map. and, which is better: blitting 2 450x272 maps, or blitting 400 50x50 tiles? actually, theyre both about the same, but tiles use less ram.

does lua have vram storage capabilities?? that would speed it up a lot.

[yaustar]

You have a frame to put those pieces in, which set of pieces is less likely to waste space?
Edit: Time for proof

-- Tile version. Blitted the screen 10 times in one frame Average time taken is 0-16 ms
WHITE = Color.new(255, 255, 255);
GREEN = Color.new(0, 255, 0);
Tile = Image.createEmpty(16, 16);
Tile:clear(GREEN);

ProcessTimer = Timer.new();

while true do
	screen:clear(GREEN);
	ProcessTimer:reset();
	ProcessTimer:start();
	for x=0,15 do
		for y=0,9 do
			screen:blit(x * 32, y * 32, Tile);
		end
	end
	for x=0,15 do
		for y=0,9 do
			screen:blit(x * 32, y * 32, Tile);
		end
	end
	for x=0,15 do
		for y=0,9 do
			screen:blit(x * 32, y * 32, Tile);
		end
	end
	for x=0,15 do
		for y=0,9 do
			screen:blit(x * 32, y * 32, Tile);
		end
	end
	for x=0,15 do
		for y=0,9 do
			screen:blit(x * 32, y * 32, Tile);
		end
	end
	for x=0,15 do
		for y=0,9 do
			screen:blit(x * 32, y * 32, Tile);
		end
	end
	for x=0,15 do
		for y=0,9 do
			screen:blit(x * 32, y * 32, Tile);
		end
	end
	for x=0,15 do
		for y=0,9 do
			screen:blit(x * 32, y * 32, Tile);
		end
	end
	for x=0,15 do
		for y=0,9 do
			screen:blit(x * 32, y * 32, Tile);
		end
	end
	for x=0,15 do
		for y=0,9 do
			screen:blit(x * 32, y * 32, Tile);
		end
	end
	local TimeElapsed = ProcessTimer:time();
	screen:print(1, 1, "Time Taken: "..TimeElapsed);
	screen:waitVblankStart();
	screen:flip();
end

-- Large 512x512 image version. Blitted the screen 10 times in one frame Average time taken is 16-32 ms
WHITE = Color.new(255, 255, 255);
GREEN = Color.new(0, 255, 0);
Tile = Image.createEmpty(512, 512);
Tile:clear(GREEN);

ProcessTimer = Timer.new();

while true do
	screen:clear(GREEN);
	ProcessTimer:reset();
	ProcessTimer:start();
	screen:blit(0, 0, Tile);
	screen:blit(0, 0, Tile);
	screen:blit(0, 0, Tile);
	screen:blit(0, 0, Tile);
	screen:blit(0, 0, Tile);
	screen:blit(0, 0, Tile);
	screen:blit(0, 0, Tile);
	screen:blit(0, 0, Tile);
	screen:blit(0, 0, Tile);
	screen:blit(0, 0, Tile);
	local TimeElapsed = ProcessTimer:time();
	screen:print(1, 1, "Time Taken: "..TimeElapsed);
	screen:waitVblankStart();
	screen:flip();
end

[Access_Denied]

Why don't we just test it out. Take PSP Millionaires scrolling tile engine to test it. Make each map 900 x 900, but one with 16 x 16 tile and one with 32 x 32 tiles. See what you come up with.

[yaustar]

Originally Posted by ARza

Why don't we just test it out. Take PSP Millionaires scrolling tile engine to test it. Make each map 900 x 900, but one with 16 x 16 tile and one with 32 x 32 tiles. See what you come up with.

In terms of pure blitting, I just did. Tiling is faster.

Edit: Opps, I made a big mistake in my tiling version. Here is the correct version

WHITE = Color.new(255, 255, 255);
GREEN = Color.new(0, 255, 0);
Tile = Image.createEmpty(32, 32);
Tile:clear(GREEN);

ProcessTimer = Timer.new();

while true do
	screen:clear(WHITE);
	ProcessTimer:reset();
	ProcessTimer:start();
	for x=0,15 do
		for y=0,9 do
			screen:blit(x * 32, y * 32, Tile);
		end
	end
	for x=0,15 do
		for y=0,9 do
			screen:blit(x * 32, y * 32, Tile);
		end
	end
	for x=0,15 do
		for y=0,9 do
			screen:blit(x * 32, y * 32, Tile);
		end
	end
	for x=0,15 do
		for y=0,9 do
			screen:blit(x * 32, y * 32, Tile);
		end
	end
	for x=0,15 do
		for y=0,9 do
			screen:blit(x * 32, y * 32, Tile);
		end
	end
	for x=0,15 do
		for y=0,9 do
			screen:blit(x * 32, y * 32, Tile);
		end
	end
	for x=0,15 do
		for y=0,9 do
			screen:blit(x * 32, y * 32, Tile);
		end
	end
	for x=0,15 do
		for y=0,9 do
			screen:blit(x * 32, y * 32, Tile);
		end
	end
	for x=0,15 do
		for y=0,9 do
			screen:blit(x * 32, y * 32, Tile);
		end
	end
	for x=0,15 do
		for y=0,9 do
			screen:blit(x * 32, y * 32, Tile);
		end
	end
	local TimeElapsed = ProcessTimer:time();
	screen:print(1, 1, "Time Taken: "..TimeElapsed);
	screen:waitVblankStart();
	screen:flip();
end

And for the single large image

WHITE = Color.new(255, 255, 255);
GREEN = Color.new(0, 255, 0);
Tile = Image.createEmpty(512, 512);
Tile:clear(GREEN);

ProcessTimer = Timer.new();

while true do
	screen:clear(WHITE);
	ProcessTimer:reset();
	ProcessTimer:start();
	screen:blit(0, 0, Tile);
	screen:blit(0, 0, Tile);
	screen:blit(0, 0, Tile);
	screen:blit(0, 0, Tile);
	screen:blit(0, 0, Tile);
	screen:blit(0, 0, Tile);
	screen:blit(0, 0, Tile);
	screen:blit(0, 0, Tile);
	screen:blit(0, 0, Tile);
	screen:blit(0, 0, Tile);
	local TimeElapsed = ProcessTimer:time();
	screen:print(1, 1, "Time Taken: "..TimeElapsed);
	screen:waitVblankStart();
	screen:flip();
end

[LMelior]

Can't believe you made us test it ourselves.

At first I thought you cheated, because the one large image is 512x512 and the tiles only add up to 480x288, but changing both for loops to 0,16 didn't make a difference. Neither did shrinking the one large to 480x272...tiling still went faster on my Windows Luaplayer.

[Zettablade]

EDIT: Oops, didn't notice the lua.

[yaustar]

Originally Posted by LMelior

Can't believe you made us test it ourselves.

At first I thought you cheated, because the one large image is 512x512 and the tiles only add up to 480x288, but changing both for loops to 0,16 didn't make a difference. Neither did shrinking the one large to 480x272...tiling still went faster on my Windows Luaplayer.

No that was intential. With a tiling engine, you only need to blit the tiles that can be shown by the player hence the total 'size' of the image is 480x288. If you only have a single large image, you have to blit the entire image (or actually thinking about it, you can probably crop it to fit the screen, I have to try that later).

[LMelior]

Originally Posted by head_54us

No that was intential. With a tiling engine, you only need to blit the tiles that can be shown by the player hence the total 'size' of the image is 480x288. If you only have a single large image, you have to blit the entire image (or actually thinking about it, you can probably crop it to fit the screen, I have to try that later).

Ah, that makes sense. Well, like I said, I changed the empty image to 480x272 and it hardly changed the time at all; just like the 512x512, it averaged about 130 milliseconds on Windows Luaplayer. Tiling 480x288 averaged about 60-70 milliseconds, and, surprisingly, tiling 512x512 averaged around 70-80 milliseconds. To get to approximately the same speed, I was blitting over 3000 32x32 tiles (totaling about 1800x1800 pixels), ten times each, in about 130 ms.

Of course, this could all be meaningless because I'm using Windows Luaplayer, but it is interesting nonetheless. Can anybody duplicate these results? Maybe not the number (that probably depends on the computer), but the comparison between head54_us' single image blitting 10 times and this code (modified for easier testing):

WHITE = Color.new(255, 255, 255);
GREEN = Color.new(0, 255, 0);
Tile = Image.createEmpty(32, 32);
Tile:clear(GREEN);

ProcessTimer = Timer.new();
tlength=56
theight=56

while true do
	screen:clear(WHITE);
	ProcessTimer:reset();
	ProcessTimer:start();
	for x=0,tlength do
		for y=0,theight do
			screen:blit(x * 32, y * 32, Tile);
		end
	end
	for x=0,tlength do
		for y=0,theight do
			screen:blit(x * 32, y * 32, Tile);
		end
	end
	for x=0,tlength do
		for y=0,theight do
			screen:blit(x * 32, y * 32, Tile);
		end
	end
	for x=0,tlength do
		for y=0,theight do
			screen:blit(x * 32, y * 32, Tile);
		end
	end
	for x=0,tlength do
		for y=0,theight do
			screen:blit(x * 32, y * 32, Tile);
		end
	end
	for x=0,tlength do
		for y=0,theight do
			screen:blit(x * 32, y * 32, Tile);
		end
	end
	for x=0,tlength do
		for y=0,theight do
			screen:blit(x * 32, y * 32, Tile);
		end
	end
	for x=0,tlength do
		for y=0,theight do
			screen:blit(x * 32, y * 32, Tile);
		end
	end
	for x=0,tlength do
		for y=0,theight do
			screen:blit(x * 32, y * 32, Tile);
		end
	end
	for x=0,tlength do
		for y=0,theight do
			screen:blit(x * 32, y * 32, Tile);
		end
	end
	local TimeElapsed = ProcessTimer:time();
	screen:print(1, 1, "Time Taken: "..TimeElapsed);
	screen:waitVblankStart();
	screen:flip();
end

[Zettablade]

Sorry to bump up an old topic like this, found it while searching for some junk on google.
Anyways, just in case any one is interested, 64x64 tiles would be the best, since it takes full advantage of the cache. sending over anything with a smaller width would result in wasted data (64 - image width = wasted data). Anything bigger the 64 would result in it having to do multiple passes to display the entire texture.
So in short, always make your images 64 pixels wide, and for anything bigger blit the image in strips. The speed gain is quite impressive

[Merick]

I know that some of you more experience programmers probably already do something like this, but for those who might not I'll post this anyway.

In the tile map tutorials I've seen, the author always has the for loops run though the entire map data. Even if you use checks inside the loops to only draw what would currently be on screen, going through the entire map data will still slow the game down.

To speed things up, use the tilesize to calculate how much of the map area around the current map position would be visible, then use the for loops to scan only that area of the map data. With this method and a tile size of 64x64, drawing a 500x500 (250,000 tiles) map will be just as fast as drawing a map thats only 4x8 (32 tiles)

[TacticalPenguin]

Why the hell would you blit 500 bazillion images rather than use a buffer? It really shouldn't matter how many tiles you use if you use buffer images for them.

[cools]

Buffers are a good way to go! Take for example block dude... It uses 24x24 size tiles. Since some levels are longer (ex: Level 8) they require two buffers for the entire level. This is because the max size of a picture buffer in pixels has a width of 512. So if [tile size] * max width of level > 512, it uses two buffers. It draws up the entire level before the loop and then blits it to the screen. Then it updates the square of where block dude is and a couple of squares around him. That way it only ends up blitting 3-7 images to the screen at a time, compared to XXXXX images.