 }
 
 func sortPlacesIntoPoiPlanes<T: GeoIdentifiable>(_ places: Set<GeoPlace>, in container: T) -> [PoiPlane] {
-	let rankedPlaces = bucketPlaceMarkers(places: places)
-	return rankedPlaces.map { (rank, places) in
-		let (vertices, indices) = buildPlaceMarkers(places: places)
+	let placeMarkers = places.filter { $0.kind != .Region }
+	let areaMarkers = places.filter { $0.kind == .Region }
+	let rankedPlaces = bucketPlaceMarkers(places: placeMarkers)
+	let rankedAreas = bucketPlaceMarkers(places: areaMarkers )
+	
+	let generatePlacePlanes = makePoiPlaneFactory(forArea: false, in: container)
+	let generateAreaPlanes = makePoiPlaneFactory(forArea: true, in: container)
+	
+	let placePlanes = rankedPlaces.map(generatePlacePlanes)
+	let areaPlanes = rankedAreas.map(generateAreaPlanes)
+	
+	return areaPlanes + placePlanes
+}
+
+typealias PoiFactory = (Int, Set<GeoPlace>) -> PoiPlane
+func makePoiPlaneFactory<T:GeoIdentifiable>(forArea: Bool, in container: T) -> PoiFactory {
+	return { (rank: Int, pois: Set<GeoPlace>) -> PoiPlane in
+		let (vertices, indices) = buildPlaceMarkers(places: pois)
 		let primitive = IndexedRenderPrimitive<ScaleVertex>(vertices: vertices,
 																						indices: indices,
 																						color: rank.hashColor.tuple(),
 																						ownerHash: container.geographyId.hashed,	// The hash of the owning region
-																						debugName: "\(container.name) - poi plane @ \(rank)")
-		let hashes = places.map { $0.hashValue }
-		return PoiPlane(primitive: primitive, rank: rank, poiHashes: hashes)
+																							debugName: "\(container.name) - \(forArea ? "area" : "poi") plane @ \(rank)")
+		let hashes = pois.map { $0.hashValue }
+		return PoiPlane(primitive: primitive, rank: rank, representsArea: forArea, poiHashes: hashes)
 	}
 }
 

		return lhs.hashValue == rhs.hashValue
	}
}

class PoiRenderer {
	enum Visibility {

struct PoiPlane: Hashable {
	let primitive: IndexedRenderPrimitive<ScaleVertex>
	let rank: Int
	let representsArea: Bool
	var ownerHash: Int { return primitive.ownerHash }
	let poiHashes: [Int]
	
