Finally shrinking looks sane

src/modules/stream/SCsub

@@ -8,6 +8,7 @@ Import("env_modules")
 module_obj = []
 
 SConscript("buildings/SCsub")
+SConscript("rtree/SCsub")
 SConscript("ui/SCsub")
 
 env_stream = env_modules.Clone()

src/modules/stream/rtree/SCsub

@@ -0,0 +1,17 @@
+Import("env")
+Import("env_modules")
+
+#env_modules.stream_building_sources = []
+#
+#env_modules.add_source_files(env_modules.stream_building_sources, "*.cpp")
+#
+#lib = env_modules.add_library("buildings", env_modules.stream_building_sources)
+#env_modules.Prepend(LIBS=[lib])
+
+env.stream_building_sources = []
+
+env.add_source_files(env.stream_building_sources, "*.cpp")
+
+lib = env.add_library("rtree", env.stream_building_sources)
+env.Prepend(LIBS=[lib])
+env.Prepend(CPPPATH=["..", ".", "../ui"])

src/modules/stream/rtree/region_rect2.h

@@ -197,6 +197,10 @@ struct RegionRect2i {
 		position = begin;
 		size = end - begin;
 	}
+	inline bool intersects_or_encloses(const RegionRect2i &other)
+	{
+		return encloses(other) || intersects(other);
+	}
 
 	operator String() const
 	{

src/modules/stream/rtree/region_tree.cpp

@@ -6,19 +6,27 @@
 #include <core/hash_map.h>
 #include "building_layout_graph.h"
 #include "region_tree.h"
+static inline bool check_rtree_split(const struct region_tree *rt,
+				     flecs::entity grid_floor_e,
+				     const List<struct region> &regions)
+{
+	assert((rt->region.rect.size.x > 1 || rt->region.rect.size.y > 1) &&
+	       rt->region.rect.get_area() > regions.size());
+	assert(rt->children.size() == 0);
+	const region_tree *base_rtree = grid_floor_e.get<region_tree>();
+	assert(base_rtree->check(grid_floor_e));
+	assert(!rt->is_a_room(grid_floor_e));
+	assert(!rt->flag_room);
+	return true;
+}
 
 void region_tree::split(flecs::entity grid_floor_e,
 			const List<struct region> &regions)
 {
-	assert((region.rect.size.x > 1 || region.rect.size.y > 1) &&
-	       region.rect.get_area() > regions.size());
-	assert(children.size() == 0);
+	check_rtree_split(this, grid_floor_e, regions);
 	const region_tree *base_rtree = grid_floor_e.get<region_tree>();
 	const List<struct region>::Element *e = regions.front();
 	int count = 0;
-	assert(base_rtree->check(grid_floor_e));
-	assert(!is_a_room(grid_floor_e));
-	assert(!flag_room);
 	flecs::entity room_c = grid_floor_e.world().lookup(
 		"::graph_module::buildings_layout_room");
 	assert(room_c.is_valid());
@@ -495,23 +503,41 @@ bool region_tree::check(flecs::entity grid_floor_e) const
 			"some leaf regions intersect other leaf regions");
 	return ok;
 }
+static inline bool can_shrink_rooms(const struct region_tree *rtree)
+{
+	int i;
+	List<const struct region_tree *> queue;
+	queue.push_back(rtree);
+	while (!queue.empty()) {
+		const struct region_tree *item = queue.front()->get();
+		queue.pop_front();
+		if (item->region.can_grow)
+			return false;
+		if (item->is_leaf() && item->region.can_move)
+			return false;
+		for (i = 0; i < (int)item->children.size(); i++)
+			queue.push_back(item->children[i]);
+	}
+	return true;
+}
 
 // TODO: calculate if rooms touch each other and shrink smaller one
 void region_tree::shrink_rooms(flecs::entity grid_floor_e)
 {
 	int i, accepted = 0;
 	assert(!parent);
+	flecs::log::dbg("====== start shrinking");
 	dump(grid_floor_e);
+	find_neighbors(grid_floor_e);
 	List<struct region_tree *> queue, shrinkable;
-	List<struct region_tree *> left_rooms, right_rooms, forward_rooms,
-		backward_rooms, inside_rooms;
+	List<struct region_tree *> shrink_rooms;
 	List<struct region_tree *>::Element *rp, *rp1, *rp2;
 	struct touching_result {
 		struct region_tree *first;
 		struct region_tree *second;
 		int how;
 	};
-	const struct region_tree *base_rtree = grid_floor_e.get<region_tree>();
+	struct region_tree *base_rtree = grid_floor_e.get_mut<region_tree>();
 	assert(base_rtree);
 	assert(base_rtree->check(grid_floor_e));
 	List<struct touching_result> touching;
@@ -519,17 +545,8 @@ void region_tree::shrink_rooms(flecs::entity grid_floor_e)
 				.get<WorldEditor::components::
 					     buildings_layout_grid_floor>()
 				->grid_size;
-	queue.push_back(this);
-	while (!queue.empty()) {
-		const struct region_tree *item = queue.front()->get();
-		queue.pop_front();
-		if (item->region.can_grow)
-			return;
-		if (item->is_leaf() && item->region.can_move)
-			return;
-		for (i = 0; i < (int)item->children.size(); i++)
-			queue.push_back(item->children[i]);
-	}
+	if (!can_shrink_rooms(base_rtree))
+		return;
 	queue.clear();
 	queue.push_back(this);
 	while (!queue.empty()) {
@@ -540,174 +557,169 @@ void region_tree::shrink_rooms(flecs::entity grid_floor_e)
 			acceptable = 0xf;
 		flecs::log::dbg("acceptable: %d", acceptable);
 		if ((acceptable & 0xf) == 0xf) {
-			shrinkable.push_back(item);
-			accepted++;
-			int rx, px, ry, py;
-			rx = item->region.rect.position.x;
-			px = item->parent->region.rect.position.x;
-			if (rx == px) {
-				left_rooms.push_back(item);
-				acceptable |= (1 << 4);
-			}
-			rx = item->region.rect.position.x +
-			     item->region.rect.size.x - 1;
-			px = item->parent->region.rect.position.x +
-			     item->parent->region.rect.size.x - 1;
-			if (rx == px) {
-				right_rooms.push_back(item);
-				acceptable |= (1 << 5);
-			}
-			ry = item->region.rect.position.y;
-			py = item->parent->region.rect.position.y;
-			if (ry == py) {
-				forward_rooms.push_back(item);
-				acceptable |= (1 << 6);
-			}
-			ry = item->region.rect.position.y +
-			     item->region.rect.size.y - 1;
-			py = item->parent->region.rect.position.y +
-			     item->parent->region.rect.size.y - 1;
-			if (ry == py) {
-				backward_rooms.push_back(item);
-				acceptable |= (1 << 7);
-			}
-			if ((acceptable & 0xf0) == 0)
-				inside_rooms.push_back(item);
+			/* allocate rooms into proper buckets */
 			flecs::log::dbg("acceptable: %d", acceptable);
+			if (acceptable != 0)
+				shrink_rooms.push_back(item);
 		}
 		for (i = 0; i < (int)item->children.size(); i++)
 			queue.push_back(item->children[i]);
 	}
-#if 0
-	rp1 = rooms.front();
-	while (rp1) {
-		rp2 = rooms.front();
-		while (rp2) {
-			if (rp1 == rp2) {
-				rp2 = rp2->next();
-				continue;
-			}
-			int style = rp1->get()->what_touching(rp2->get());
-			struct region_tree *item1 = rp1->get(),
-					   *item2 = rp2->get();
-			if (style & TOUCH_RIGHT) {
-				if (shrinkable.find(item2)) {
-					if (!right_rooms.find(item2))
-						right_rooms.push_back(item2);
-				} else if (shrinkable.find(item1)) {
-					if (!left_rooms.find(item1))
-						left_rooms.push_back(item1);
-				}
-			}
-			if (style & TOUCH_LEFT) {
-				if (shrinkable.find(item2)) {
-					if (!left_rooms.find(item2))
-						left_rooms.push_back(item2);
-				} else if (shrinkable.find(item1)) {
-					if (!right_rooms.find(item1))
-						right_rooms.push_back(item1);
-				}
-			}
-			if (style & TOUCH_FORWARD) {
-				if (shrinkable.find(item2)) {
-					if (!forward_rooms.find(item2))
-						forward_rooms.push_back(item2);
-				} else if (shrinkable.find(item1)) {
-					if (!backward_rooms.find(item1))
-						backward_rooms.push_back(item1);
-				}
-			}
-			if (style & TOUCH_BACKWARD) {
-				if (shrinkable.find(item2)) {
-					if (!backward_rooms.find(item2))
-						backward_rooms.push_back(item2);
-				} else if (shrinkable.find(item1)) {
-					if (!forward_rooms.find(item1))
-						forward_rooms.push_back(item1);
-				}
-			}
-			rp2 = rp2->next();
-		}
-		rp1 = rp1->next();
-	}
-#endif
 	int shrunk = 0;
-	int shrink_mode = SHRINK_LEFT_ROOM;
-	while (1) {
-		switch (shrink_mode) {
-		case SHRINK_LEFT_ROOM:
-			rp = left_rooms.front();
-			break;
-		case SHRINK_RIGHT_ROOM:
-			rp = right_rooms.front();
-			break;
-		case SHRINK_FORWARD_ROOM:
-			rp = forward_rooms.front();
-			break;
-		case SHRINK_BACKWARD_ROOM:
-			rp = backward_rooms.front();
-			break;
-		case SHRINK_INSIDE_ROOM:
-			rp = inside_rooms.front();
-			break;
-		}
-		while (rp) {
-			struct region backup = rp->get()->region;
-			List<struct region_tree *> neighbors;
-			switch (shrink_mode) {
-			case SHRINK_LEFT_ROOM:
-				get_neighbors(grid_floor_e, RIGHT, &neighbors);
-				if (neighbors.size() > 0) {
-					rp->get()->region.rect.size.x -= 1;
-					shrunk++;
-				}
-				break;
-			case SHRINK_RIGHT_ROOM:
-				get_neighbors(grid_floor_e, LEFT, &neighbors);
-				if (neighbors.size() > 0) {
-					rp->get()->region.rect.position.x += 1;
-					rp->get()->region.rect.size.x -= 1;
-					shrunk++;
-				}
-				break;
-			case SHRINK_FORWARD_ROOM:
-				get_neighbors(grid_floor_e, BACKWARD,
-					      &neighbors);
-				if (neighbors.size() > 0) {
-					rp->get()->region.rect.size.y -= 1;
-					shrunk++;
-				}
-				break;
-			case SHRINK_BACKWARD_ROOM:
-				get_neighbors(grid_floor_e, FORWARD,
-					      &neighbors);
-				if (neighbors.size() > 0) {
-					rp->get()->region.rect.position.y += 1;
-					rp->get()->region.rect.size.y -= 1;
-					shrunk++;
-				}
-				break;
-			case SHRINK_INSIDE_ROOM:
-				// TODO: check neighbors
-				rp->get()->region.rect =
-					rp->get()->region.rect.grow(-1);
-				shrunk++;
-				break;
-			default:
+	while (!shrink_rooms.empty()) {
+		struct region_tree *item = shrink_rooms.front()->get();
+		shrink_rooms.pop_front();
+		struct region backup = item->region;
+		List<struct region_tree *> neighbors;
+
+#define SHRINK_RIGHT (1 << 0)
+#define SHRINK_LEFT (1 << 1)
+#define SHRINK_BACKWARD (1 << 2)
+#define SHRINK_FORWARD (1 << 3)
+
+		int shrink_flags = 0;
+		if (item->neighbors_left.size() > 0)
+			shrink_flags |= SHRINK_LEFT;
+		if (item->neighbors_right.size() > 0)
+			shrink_flags |= SHRINK_RIGHT;
+		if (item->neighbors_backward.size() > 0)
+			shrink_flags |= SHRINK_BACKWARD;
+		if (item->neighbors_forward.size() > 0)
+			shrink_flags |= SHRINK_FORWARD;
+		flecs::log::dbg("shrink_flags: %08x", shrink_flags);
+		if (shrink_flags & SHRINK_RIGHT) {
+			item->region.rect.size.x -= 1;
+			shrunk++;
+			if (!base_rtree->check(grid_floor_e)) {
+				item->region.rect.size.x = backup.rect.size.x;
 				assert(false);
 			}
-			if (!base_rtree->check(grid_floor_e))
-				rp->get()->region = backup;
-			assert(base_rtree->check(grid_floor_e));
-			rp = rp->next();
 		}
-		if (shrink_mode >= SHRINK_INSIDE_ROOM)
-			break;
-		shrink_mode++;
+		if (shrink_flags & SHRINK_LEFT) {
+			item->region.rect.position.x += 1;
+			item->region.rect.size.x -= 1;
+			shrunk++;
+			if (!base_rtree->check(grid_floor_e)) {
+				item->region.rect.position.x =
+					backup.rect.position.x;
+				item->region.rect.size.x = backup.rect.size.x;
+				assert(false);
+			}
+		}
+		if (shrink_flags & SHRINK_BACKWARD) {
+			item->region.rect.size.y -= 1;
+			shrunk++;
+			if (!base_rtree->check(grid_floor_e)) {
+				item->region.rect.size.y = backup.rect.size.y;
+				assert(false);
+			}
+		}
+		if (shrink_flags & SHRINK_FORWARD) {
+			item->region.rect.position.y += 1;
+			item->region.rect.size.y -= 1;
+			shrunk++;
+			if (!base_rtree->check(grid_floor_e)) {
+				item->region.rect.position.y =
+					backup.rect.position.y;
+				item->region.rect.size.y = backup.rect.size.y;
+				assert(false);
+			}
+		}
+		if (shrink_flags)
+			base_rtree->find_neighbors(grid_floor_e);
+#if 0
+		if (shrink_flags == 0xf)
+			item->region.rect = item->region.rect.grow(-1);
+		if (!base_rtree->check(grid_floor_e))
+			item->region = backup;
+#endif
 	}
 	assert(base_rtree->check(grid_floor_e));
 	// assert(accepted == 0 || shrunk > 0);
 	grid_floor_e.modified<region_tree>();
+	flecs::log::dbg("====== end shrinking");
+}
+template <class T>
+static inline void list2vector(const List<T> &data, Vector<T> &v)
+{
+	int idx = v.size();
+	v.resize(idx + data.size());
+	const typename List<T>::Element *e = data.front();
+	while (e) {
+		v.write[idx++] = e->get();
+		e = e->next();
+	}
+}
+template <class T>
+static inline void append_if_none(Vector<T> &v, const T &data)
+{
+	if (v.find(data) < 0)
+		v.push_back(data);
+}
+
+void region_tree::find_neighbors(flecs::entity grid_floor_e)
+{
+	int i, j;
+	Vector<struct region_tree *> leaf_regions;
+	List<struct region_tree *> node_list;
+	struct region_tree *base_rtree = grid_floor_e.get_mut<region_tree>();
+	base_rtree->get_leaf_nodes(&node_list);
+	list2vector(node_list, leaf_regions);
+	for (i = 0; i < leaf_regions.size(); i++) {
+		leaf_regions[i]->neighbors_left.clear();
+		leaf_regions[i]->neighbors_right.clear();
+		leaf_regions[i]->neighbors_forward.clear();
+		leaf_regions[i]->neighbors_backward.clear();
+	}
+	for (i = 0; i < leaf_regions.size(); i++) {
+		for (j = 0; j < leaf_regions.size(); j++) {
+			if (i == j)
+				continue;
+			RegionRect2i left = leaf_regions[i]->left_rect();
+			RegionRect2i right = leaf_regions[i]->right_rect();
+			RegionRect2i forward = leaf_regions[i]->forward_rect();
+			RegionRect2i backward =
+				leaf_regions[i]->backward_rect();
+			if (left.intersects_or_encloses(
+				    leaf_regions[j]->region.rect)) {
+				append_if_none(leaf_regions[i]->neighbors_left,
+					       leaf_regions[j]);
+				append_if_none(leaf_regions[j]->neighbors_right,
+					       leaf_regions[i]);
+			}
+			if (right.intersects_or_encloses(
+				    leaf_regions[j]->region.rect)) {
+				append_if_none(leaf_regions[i]->neighbors_right,
+					       leaf_regions[j]);
+				append_if_none(leaf_regions[j]->neighbors_left,
+					       leaf_regions[i]);
+			}
+			if (backward.intersects_or_encloses(
+				    leaf_regions[j]->region.rect)) {
+				append_if_none(
+					leaf_regions[i]->neighbors_backward,
+					leaf_regions[j]);
+				append_if_none(
+					leaf_regions[j]->neighbors_forward,
+					leaf_regions[i]);
+			}
+			if (forward.intersects_or_encloses(
+				    leaf_regions[j]->region.rect)) {
+				append_if_none(
+					leaf_regions[i]->neighbors_forward,
+					leaf_regions[j]);
+				append_if_none(
+					leaf_regions[j]->neighbors_backward,
+					leaf_regions[i]);
+			}
+		}
+		int neighbors_count = leaf_regions[i]->neighbors_left.size();
+		neighbors_count += leaf_regions[i]->neighbors_right.size();
+		neighbors_count += leaf_regions[i]->neighbors_forward.size();
+		neighbors_count += leaf_regions[i]->neighbors_backward.size();
+		flecs::log::dbg("%d: neighbors: %d", i, neighbors_count);
+	}
+	grid_floor_e.modified<region_tree>();
 }
 void region_tree::place(flecs::entity grid_floor_e) const
 {
@@ -1168,6 +1180,34 @@ int region_tree::area() const
 {
 	return region.rect.get_area();
 }
+RegionRect2i region_tree::left_rect() const
+{
+	RegionRect2i ret = region.rect;
+	ret.position.x -= 1;
+	ret.size.x = 2;
+	return ret;
+}
+RegionRect2i region_tree::right_rect() const
+{
+	RegionRect2i ret = region.rect;
+	ret.position.x += ret.size.x - 1;
+	ret.size.x = 2;
+	return ret;
+}
+RegionRect2i region_tree::forward_rect() const
+{
+	RegionRect2i ret = region.rect;
+	ret.position.y -= 1;
+	ret.size.y = 2;
+	return ret;
+}
+RegionRect2i region_tree::backward_rect() const
+{
+	RegionRect2i ret = region.rect;
+	ret.position.y += ret.size.y - 1;
+	ret.size.y = 2;
+	return ret;
+}
 bool region_tree::check_candidate(int i, const RegionRect2i &candidate) const
 {
 	int j;

src/modules/stream/rtree/region_tree.h

@@ -5,6 +5,8 @@
 struct region_tree {
 	struct region region;
 	Vector<struct region_tree *> children;
+	Vector<struct region_tree *> neighbors_left, neighbors_right,
+		neighbors_forward, neighbors_backward;
 	struct region_tree *parent;
 	bool flag_room;
 	bool flag_special;
@@ -23,6 +25,7 @@ struct region_tree {
 	bool check(flecs::entity grid_floor_e) const;
 	void place(flecs::entity grid_floor_e) const;
 	void shrink_rooms(flecs::entity grid_floor_e);
+	void find_neighbors(flecs::entity grid_floor_e);
 	void move(flecs::entity grid_floor_e);
 	void get_rects(List<RegionRect2i> *rect_list) const;
 	void get_leaf_nodes(List<const struct region_tree *> *node_list) const;
@@ -59,6 +62,10 @@ struct region_tree {
 	Vector2i get_global_center() const;
 	Vector2i get_center() const;
 	int area() const;
+	RegionRect2i left_rect() const;
+	RegionRect2i right_rect() const;
+	RegionRect2i forward_rect() const;
+	RegionRect2i backward_rect() const;
 
 private:
 	bool check_candidate(int i, const RegionRect2i &candidate) const;

src/modules/stream/ui/SCsub

@@ -14,5 +14,6 @@ env.add_source_files(env.stream_building_sources, "*.cpp")
 
 lib = env.add_library("ui", env.stream_building_sources)
 env.Prepend(LIBS=[lib])
+env.Prepend(CPPPATH=["../rtree"])
 env.Prepend(CPPPATH=[".."])
 env.Prepend(CPPPATH=["../../../meshoptimizer/src"])

src/modules/stream/ui/grow_job.cpp

@@ -33,10 +33,25 @@ grow_job_queue::grow_job_queue(
 	, grid_size(size.grid_size)
 	, subregions(subregions)
 	, module_name(module_name)
+	, is_valid(false)
 {
+	int floor_count = 0;
 	const List<Pair<int, flecs::entity_t> >::Element *me;
 	List<Pair<flecs::entity_t, flecs::entity_t> > job_create_queue;
 	me = size.floors.front();
+	flecs::query<growth_regions> q =
+		grid_e.world()
+			.query_builder<growth_regions>()
+			.with(flecs::ChildOf, grid_e)
+			.build();
+	q.each([this, &floor_count](flecs::entity e, growth_regions &g) {
+		flecs::log::warn("pre-pre floor: %s", e.path().c_str());
+		floor_count++;
+	});
+	flecs::log::dbg("floor count: %d %d", size.floors.size(), floor_count);
+	if (size.floors.size() != floor_count)
+		return;
+	assert(size.floors.size() == floor_count);
 	while (me) {
 		// graph entity
 		job_create_queue.push_back(
@@ -49,8 +64,10 @@ grow_job_queue::grow_job_queue(
 			get_grid_floor(grid_e, base_floor_e);
 		grid_floor_e.get_mut<growth_regions>()->job_list =
 			List<grow_job>();
+		grid_floor_e.modified<growth_regions>();
 		me = me->next();
 	}
+	assert(!job_create_queue.empty());
 	while (!job_create_queue.empty()) {
 		// graph entity
 		flecs::entity_t et = job_create_queue.front()->get().first;
@@ -97,13 +114,21 @@ grow_job_queue::grow_job_queue(
 			flecs::log::dbg(
 				"no subregions for: %s",
 				grid_e.world().entity(et).path().c_str());
+		assert(!grid_floor_e.get_mut<growth_regions>()
+				->job_list.empty());
 	}
+	q.each([this](flecs::entity e, growth_regions &g) {
+		flecs::log::warn("pre floor: %s", e.path().c_str());
+		assert(!g.job_list.empty());
+	});
+	is_valid = true;
 }
 /* Unlimited growth for squares */
 void grow_job_queue::job_initial(struct grow_job *job)
 {
 	flecs::entity base_floor_e = grid_e.world().entity(job->base_floor_id);
 	flecs::entity grid_floor_e = grid_e.world().entity(job->grid_floor_id);
+	assert(is_valid);
 	flecs::log::dbg("create: base_floor: %s", base_floor_e.path().c_str());
 	flecs::log::dbg("create: grid_floor: %s", grid_floor_e.path().c_str());
 	growth_regions *g = grid_floor_e.get_mut<growth_regions>();
@@ -119,6 +144,10 @@ void grow_job_queue::job_initial(struct grow_job *job)
 		    clip_rect.grow(-1), grid_size * grid_size, false, false,
 		    false, true },
 		  Vector<struct region_tree *>(),
+		  {},
+		  {},
+		  {},
+		  {},
 		  nullptr,
 		  false,
 		  false,
@@ -171,6 +200,7 @@ void grow_job_queue::job_initial(struct grow_job *job)
 }
 void grow_job_queue::job_common(struct grow_job *job)
 {
+	assert(is_valid);
 	make_random r(172);
 	flecs::entity base_floor_e = grid_e.world().entity(job->base_floor_id);
 	flecs::entity grid_floor_e = grid_e.world().entity(job->grid_floor_id);
@@ -220,6 +250,7 @@ void grow_job_queue::job_common(struct grow_job *job)
 }
 void grow_job_queue::commit_common_queue()
 {
+	assert(is_valid);
 	grid_e.world()
 		.query_builder<
 			WorldEditor::components::buildings_layout_grid_floor,
@@ -290,6 +321,7 @@ void grow_job_queue::create_region_list(
 	region_tree *rtree, const List<Pair<flecs::entity, float> > &subregions,
 	List<struct region> &region_list)
 {
+	assert(is_valid);
 	int i, j;
 	const List<Pair<flecs::entity, float> >::Element *fe =
 		subregions.front();
@@ -471,18 +503,31 @@ void grow_job_queue::create_region_list(
 }
 void grow_job_queue::iterate()
 {
+	int badness = 0;
+	assert(is_valid);
 	assert(grid_e.is_valid());
 	assert(this);
 	/* once for each grid floor */
 	flecs::query<growth_regions> q =
 		grid_e.world().query_builder<growth_regions>().build();
+	//	q.each([this, &badness](flecs::entity e, growth_regions &g) {
+	//		if (g.job_list.empty()) {
+	//			flecs::log::err("bad grid: %s floor: %s",
+	//					e.parent().path().c_str(),
+	//					e.path().c_str());
+	//			badness++;
+	//		} else
+	//			flecs::log::dbg("ok grid %s floor %s",
+	//					e.parent().path().c_str(),
+	//					e.path().c_str());
+	//	});
+	//	assert(badness == 0);
 	q.each([this](flecs::entity e, growth_regions &g) {
-		flecs::log::warn("pre floor: %s", e.path().c_str());
-	});
-	q.each([this](flecs::entity e, growth_regions &g) {
-		struct region_tree *rtree = e.get_mut<region_tree>();
 		flecs::log::warn("floor: %s", e.path().c_str());
 		flecs::log::warn("job count: %d", g.job_list.size());
+		if (g.job_list.empty())
+			return;
+		assert(!g.job_list.empty());
 		while (!g.job_list.empty()) {
 			List<struct grow_job>::Element *job_e =
 				g.job_list.front();
@@ -533,20 +578,28 @@ void grow_job_queue::iterate()
 			//				if (common_count > 0)
 			//					break;
 		}
+		struct region_tree *rtree = e.get_mut<region_tree>();
+		assert(rtree);
 		flecs::log::dbg(
 			"processed jobs (created region initial positions): %d",
 			g.job_list.size());
 		assert(rtree->check(e));
-		rtree->shrink_rooms(e);
-		rtree->place(e);
-		e.modified<region_tree>();
 		g.job_list.clear();
 	});
 }
 
 void grow_job_queue::finalize()
 {
+	assert(is_valid);
+#if 0
 	flecs::query<growth_regions> q =
 		grid_e.world().query_builder<growth_regions>().build();
-	q.each([this](flecs::entity e, growth_regions &g) {});
+	q.each([this](flecs::entity e, growth_regions &g) {
+		struct region_tree *rtree = e.get_mut<region_tree>();
+		assert(rtree->check(e));
+		rtree->shrink_rooms(e);
+		rtree->place(e);
+		e.modified<region_tree>();
+	});
+#endif
 }

src/modules/stream/ui/grow_job.h

@@ -15,6 +15,7 @@ struct grow_job_queue {
 	int grid_size;
 	struct subregions &subregions;
 	const String &module_name;
+	bool is_valid;
 	grow_job_queue(
 		flecs::entity grid_e, struct subregions &subregions,
 		const WorldEditor::components::buildings_layout_grid_size &size,

src/modules/stream/ui/growth_module.cpp

@@ -1,3 +1,4 @@
+#include <map>
 #include <core/math/a_star.h>
 #include "growth_regions.h"
 #include "region_tree.h"
@@ -59,15 +60,16 @@ growth_module::growth_module(flecs::world &ecs)
 			EditorEvent::get_singleton()->event.emit(
 				"update_layout_view", varray());
 			// assert(false);
-			struct subregions subregions(ecs_);
 			struct queries queries(ecs_);
 			flecs::log::dbg("Creating regions grow...");
+			/* for each grid build subregions */
+			std::map<uint64_t, struct subregions> subreg;
 			queries.get_qp().each(
-				[this, &subregions, &queries,
-				 module_name](flecs::iter &it2, size_t count,
-					      const WorldEditor::components::
-						      buildings_layout_grid_size
-							      &size) {
+				[this, &subreg, &queries, module_name,
+				 &ecs_](flecs::iter &it2, size_t count,
+					const WorldEditor::components::
+						buildings_layout_grid_size
+							&size) {
 					struct grid_misc grid;
 					//					grid.subregions_init(it2.world());
 					flecs::entity graph_e =
@@ -81,19 +83,131 @@ growth_module::growth_module(flecs::world &ecs)
 						grid_base_e.lookup(
 							graph_e.name());
 					assert(grid_e.is_valid());
+					subreg.emplace(grid_e.id(),
+						       subregions(ecs_));
 					flecs::log::warn(
 						"creating grid for: %s: %s",
 						graph_e.path().c_str(),
 						grid_e.path().c_str());
 					/* starting at grid center */
-					subregions.build_subregions(grid_e,
-								    grid, size);
-					struct grow_job_queue job_queue(
-						grid_e, subregions, size,
-						module_name);
-					job_queue.iterate();
-					job_queue.finalize();
+					/* prevent default constructor from running */
+					subreg.at(grid_e.id())
+						.build_subregions(grid_e, grid,
+								  size);
 				});
+			/* for each grid */
+			std::map<flecs::entity_t, struct grow_job_queue>
+				job_queues;
+			queries.get_qp().each([this, &subreg, &queries,
+					       module_name, &job_queues](
+						      flecs::iter &it2,
+						      size_t count,
+						      const WorldEditor::components::
+							      buildings_layout_grid_size
+								      &size) {
+				int floor_count = 0;
+				flecs::entity graph_e = it2.entity(count);
+				flecs::entity grid_base_e =
+					queries.get_layout_grid_base();
+				flecs::entity grid_e =
+					grid_base_e.lookup(graph_e.name());
+				assert(grid_e.is_valid());
+
+				/* creating queue for each grid floor */
+				struct grow_job_queue job_queue(
+					grid_e, subreg.at(grid_e.id()), size,
+					module_name);
+				job_queues.insert(
+					std::make_pair(grid_e, job_queue));
+
+				/* each floor in grid */
+				flecs::query<growth_regions> grid_floor_q =
+					it2.world()
+						.query_builder<growth_regions>()
+						.with(flecs::ChildOf, grid_e)
+						.build();
+				grid_floor_q.each([grid_e](flecs::entity me,
+							   const growth_regions
+								   &g) {
+					flecs::log::dbg(
+						"processed: grid: %s: floor: %s",
+						grid_e.path().c_str(),
+						me.path().c_str());
+					assert(!g.job_list.empty());
+				});
+				flecs::log::warn("grid processed %s",
+						 grid_e.path().c_str());
+			});
+			{
+				int badness = 0;
+				flecs::query<growth_regions> q =
+					it.world()
+						.query_builder<growth_regions>()
+						.build();
+				q.each([this, &badness](flecs::entity e,
+							growth_regions &g) {
+					if (g.job_list.empty()) {
+						flecs::log::err(
+							"bad grid: %s floor: %s",
+							e.parent()
+								.path()
+								.c_str(),
+							e.path().c_str());
+						badness++;
+					} else
+						flecs::log::dbg(
+							"ok grid %s floor %s",
+							e.parent()
+								.path()
+								.c_str(),
+							e.path().c_str());
+				});
+				assert(badness == 0);
+			}
+			{
+				flecs::query<growth_regions> test_q =
+					it.world()
+						.query_builder<growth_regions>()
+						.build();
+				test_q.each([this](flecs::entity e,
+						   growth_regions &g) {
+					flecs::log::warn("test floor: %s",
+							 e.path().c_str());
+					assert(!g.job_list.empty());
+				});
+			}
+			queries.get_qp().each(
+				[this, &queries, module_name,
+				 &job_queues](flecs::iter &it2, size_t count,
+					      const WorldEditor::components::
+						      buildings_layout_grid_size
+							      &size) {
+					flecs::entity graph_e =
+						it2.entity(count);
+					flecs::entity grid_base_e =
+						queries.get_layout_grid_base();
+					flecs::entity grid_e =
+						grid_base_e.lookup(
+							graph_e.name());
+					assert(grid_e.is_valid());
+					assert(job_queues.at(grid_e).is_valid);
+					flecs::log::dbg("grid iteration %s",
+							grid_e.path().c_str());
+					job_queues.at(grid_e).iterate();
+					job_queues.at(grid_e).finalize();
+				});
+			flecs::query<growth_regions> q =
+				it.world()
+					.query_builder<growth_regions>()
+					.build();
+			q.each([this](flecs::entity e, growth_regions &g) {
+				struct region_tree *rtree =
+					e.get_mut<region_tree>();
+				assert(rtree->check(e));
+				rtree->shrink_rooms(e);
+				rtree->place(e);
+				e.modified<region_tree>();
+			});
 			commit_growth_queue(it.world());
 			mark_cells(it.world());
 			mark_doors(it.world());

src/modules/stream/ui/queries.h

@@ -155,6 +155,7 @@ struct subregions {
 			subregions->push_back({ ce, area.area });
 		});
 	}
+	/** build_subregions() - leaf regions have empty subregions */
 	void build_subregions(
 		flecs::entity grid_e, struct grid_misc &grid,
 		const WorldEditor::components::buildings_layout_grid_size &size)