Fix the rendering order problems.

1 files changed, 39 insertions, 24 deletions

diff --git a/src/render.cpp b/src/render.cpp
index beda97b..9056d9c 100644
--- a/src/render.cpp
+++ b/src/render.cpp
@@ -33,10 +33,11 @@ state_t::state_t(sf::RenderWindow *window_)
 typedef struct {
 	sf::Texture *top, *side;
 	float height;
+	layer_t layer;
 } tiledata_t;
 static tiledata_t tiledata[256] = {0};
 
-void register_tile(uint8_t type, const char *top, const char *side, float height)
+void register_tile(uint8_t type, const char *top, const char *side, float height, layer_t layer)
 {
 	tiledata_t *tile = tiledata + type;
 
@@ -52,6 +53,8 @@ void register_tile(uint8_t type, const char *top, const char *side, float height
 		tile->side->loadFromFile(side);
 		tile->side->setRepeated(true);
 	}
+
+	tile->layer = layer;
 }
 
 
@@ -202,32 +205,23 @@ rectf_t state_t::window_in_world_space(void)
 
 bool rendering_order(const world::entity_t *x, const world::entity_t *y)
 {
-	if (x->render_layer < y->render_layer)
-		return true;
-	else if (x->render_layer > y->render_layer)
-		return false;
-	else
-		return x->render_bounds[1][1] < y->render_bounds[1][1];
+	return x->render_bounds[1][1] < y->render_bounds[1][1];
 }
 
 bool visibility_order(const world::entity_t *x, const world::entity_t *y)
 {
-	return !rendering_order(x, y);
+	if (x->render_layer < y->render_layer)
+		return false;
+	else if (x->render_layer > y->render_layer)
+		return true;
+	else
+		return x->render_bounds[1][1] > y->render_bounds[1][1];
 }
 
-void state_t::render(game::state_t *game)
+void state_t::render_layer(game::state_t *game, rect_t<world::coord_t, 2> &sectors,
+                           std::list<world::entity_t*> &ents, layer_t layer)
 {
-	rectf_t bounds;
-	std::list<world::entity_t*> ents;
 	std::list<world::entity_t*>::iterator ent;
-	rect_t<world::coord_t, 2> sectors;
-
-	bounds = window_bounds(window);
-	sectors[0] = world::sector_index_at(bounds[0]);
-	sectors[1] = world::sector_index_at(bounds[1]);
-
-	ents = game->world.get_render_entities(bounds);
-	ents.sort(rendering_order);
 
 	ent = ents.begin();
 	for (world::coord_t sy = sectors[0][1]; sy <= sectors[1][1]; sy++)
@@ -240,8 +234,11 @@ void state_t::render(game::state_t *game)
 
 		while (ent != ents.end() &&
 		       (*ent)->render_bounds[1][1] < sy * SECTOR_SIZE + ty) {
-			(*ent)->render_to(this);
-			stats.entities++;
+			if ((*ent)->render_layer == layer) {
+				(*ent)->render_to(this);
+				stats.entities++;
+			}
+
 			ent++;
 		}
 
@@ -253,14 +250,32 @@ void state_t::render(game::state_t *game)
 			        world::tile_index_t(tx, ty);
 			tile = sector->tiles + ty * SECTOR_SIZE + tx;
 
+			if (tiledata[tile->type].layer != layer)
+				continue;
+
 			render_tile(&game->world, index, tile);
                 }
 
-		stats.sectors++;
+		if (layer == LAYER_COUNT - 1)
+			stats.sectors++;
 	}
+}
+
+void state_t::render(game::state_t *game)
+{
+	rectf_t bounds;
+	std::list<world::entity_t*> ents;
+	rect_t<world::coord_t, 2> sectors;
+
+	bounds = window_bounds(window);
+	sectors[0] = world::sector_index_at(bounds[0]);
+	sectors[1] = world::sector_index_at(bounds[1]);
+
+	ents = game->world.get_render_entities(bounds);
+	ents.sort(rendering_order);
 
-	// Every sector is iterated SECTOR_SIZE times.
-	stats.sectors /= SECTOR_SIZE;
+	for (layer_t layer = LAYER_FLAT; layer < LAYER_COUNT; layer++)
+		render_layer(game, sectors, ents, layer);
 
 	if (debug_draw_tile_coords) {
 		for (world::sector_t *sector : game->world.get_sectors(bounds, world::SECTOR_FULL))