Removed script from editor

src/modules/stream/buildings_editor.cpp

@@ -144,6 +144,7 @@ static std::vector<Object *> ui_handlers;
 BuildingsEditor::BuildingsEditor(WorldEditor *editor)
 	: editor(editor)
 	, selected_building(-1)
+	, active(false)
 {
 }
 
@@ -156,6 +157,9 @@ void BuildingsEditor::exit()
 void BuildingsEditor::activate()
 {
 	assert(!active);
+	ConfigFile config;
+	Error result = config.load("res://config/stream.conf");
+	ERR_FAIL_COND_MSG(result != OK, "Failed to load config");
 	print_line("BuildingsEditor ACTIVE");
 	Array args;
 	ui_handlers.push_back(memnew(HandleButton(
@@ -165,9 +169,24 @@ void BuildingsEditor::activate()
 	int i;
 	for (i = 0; i < (int)ui_handlers.size(); i++)
 		assert(ui_handlers[i]);
-	active = true;
+	/* TODO: make separate function for this */
 	EditorEvent::get_singleton()->event.add_listener(
 		this, &BuildingsEditor::event_handler);
+	Dictionary buildings_data =
+		config.get_value("buildings", "building_data");
+	OptionButton *building_type =
+		get_as_node<OptionButton>("%building_type");
+	building_type->clear();
+	List<Variant> keys;
+	buildings_data.get_key_list(&keys);
+	List<Variant>::Element *e = keys.front();
+	while (e) {
+		const String &key = e->get();
+		print_line("EE::" + key);
+		building_type->add_item(key);
+		e = e->next();
+	}
+	active = true;
 }
 
 void BuildingsEditor::deactivate()
@@ -200,6 +219,8 @@ void BuildingsEditor::event_handler(const String &event, const Array &args)
 			get_as_node<Spatial>("%building_rot_cursor")
 				->set_global_transform(selected_building_xform);
 		}
+	} else if (event == "result:get_building_types") {
+		/* TODO: replace with direct data access */
 	}
 	print_line("buildings::" + event);
 }

src/modules/stream/road_lines_data.cpp

@@ -207,19 +207,18 @@ void RoadLinesData::index_lines(
 	std::vector<Vector3> &road_lines_nodes)
 {
 	List<String> keys;
-	RoadLinesData *rld = RoadLinesData::get_singleton();
-	rld->get_road_lines_key_list(&keys);
+	get_road_lines_key_list(&keys);
 	List<String>::Element *e = keys.front();
 	while (e) {
 		String rkey = e->get();
-		struct RoadLinesData::road_line &pt = rld->lines[rkey];
+		struct RoadLinesData::road_line &pt = lines[rkey];
 		pt.indices.clear();
 		e = e->next();
 	}
 	e = keys.front();
 	while (e) {
 		String rkey = e->get();
-		struct RoadLinesData::road_line &pt = rld->lines[rkey];
+		struct RoadLinesData::road_line &pt = lines[rkey];
 		road_lines_curve_index(pt, road_lines_nodes_hash,
 				       road_lines_nodes);
 		e = e->next();
@@ -481,28 +480,10 @@ void RoadLinesData::process_lines(
 		&road_lines_nodes_hash,
 	std::vector<Vector3> &road_lines_nodes)
 {
-	int i;
-	get_debug_node()->clear();
 	index_lines(road_lines_nodes_hash, road_lines_nodes);
 	insert_close_points(road_lines_nodes, 160.0f);
 	update_road_lines_nodes(road_lines_nodes);
 	dump_road_lines(road_lines_nodes);
-	if (debug_flags & 1) {
-		get_debug_node()->begin(Mesh::PRIMITIVE_LINES);
-		for (i = 0; i < (int)road_lines_nodes.size(); i++) {
-			print_line("debug_node: " + itos(i) + " " +
-				   (road_lines_nodes[i].operator String()));
-			get_debug_node()->set_color(
-				Color(0.1f, 0.6f, 0.6f, 1.0f));
-			get_debug_node()->add_vertex(road_lines_nodes[i]);
-			get_debug_node()->set_color(
-				Color(0.1f, 0.6f, 0.6f, 1.0f));
-			get_debug_node()->add_vertex(
-				road_lines_nodes[i] +
-				Vector3(0.0f, 200.0f, 0.0f));
-		}
-		get_debug_node()->end();
-	}
 }
 
 void RoadLinesData::set_debug_flags(int debug_flags)

src/modules/stream/road_lines_data.h

@@ -7,7 +7,6 @@ class RoadLinesData {
 	String road_lines_path;
 	uint32_t road_lines_hash(const Vector3 &v);
 	static ImmediateGeometry *debug_im;
-	static ImmediateGeometry *get_debug_node();
 
 protected:
 	RoadLinesData();
@@ -15,6 +14,7 @@ protected:
 	_Signal<void> lines_updated;
 
 public:
+	static ImmediateGeometry *get_debug_node();
 	struct road_line {
 		std::vector<Transform> points;
 		std::vector<int> indices;
@@ -38,6 +38,7 @@ public:
 	int get_debug_flags() const;
 
 private:
+	void create_segments_from_lines();
 	void index_lines(std::unordered_map<uint32_t, std::vector<Vector3> >
 				 &road_lines_nodes_hash,
 			 std::vector<Vector3> &road_lines_nodes);

src/modules/stream/road_lines_editor.cpp

@@ -1177,5 +1177,7 @@ void RoadLinesEditor::event_handler(const String &event, const Array &args)
 			print_line("the line is a road");
 		if (current_line.ends_with("_road") && update_roads)
 			rebuild_roads();
+	} else if (event == "result:get_building_types") {
+		/* TODO:: implement */
 	}
 }

src/modules/stream/road_processing.cpp

@@ -94,6 +94,11 @@ struct RoadLinesProcessing {
 			}
 			e = e->next();
 		}
+	}
+	void sort_neighbors()
+	{
+		int i;
+		/* sort neighbors by angle */
 		for (i = 0; i < (int)nodes.size(); i++) {
 			std::sort(
 				edges[i].neighbors.begin(),
@@ -110,6 +115,72 @@ struct RoadLinesProcessing {
 				});
 		}
 	}
+	/* need to find nodes too close to edge and split them */
+	void optimize_nodes(float maxdst)
+	{
+		int i, j, k;
+		for (k = 0; k < (int)nodes.size(); k++) {
+			const Vector3 &p = nodes[k];
+			Vector3 np;
+			float dst = Math_INF;
+			int n1, n2;
+			for (i = 0; i < (int)nodes.size(); i++) {
+				if (k == i)
+					continue;
+				for (j = 0; j < (int)edges[i].neighbors.size();
+				     j++) {
+					const Vector3 &p1 = nodes[i];
+					const Vector3 &p2 =
+						nodes[edges[i].neighbors[j]];
+					const Vector3 seg[] = { p1, p2 };
+					Vector3 tmp = Geometry::
+						get_closest_point_to_segment(
+							p, &seg[0]);
+					if (tmp.is_equal_approx(p1) ||
+					    tmp.is_equal_approx(p2))
+						/* edges of segment, bad */
+						continue;
+					float tmpdst =
+						p.distance_squared_to(tmp);
+					if (tmpdst > maxdst * maxdst)
+						continue;
+					if (dst > tmpdst) {
+						dst = tmpdst;
+						np = tmp;
+						n1 = i;
+						n2 = edges[i].neighbors[j];
+					}
+				}
+			}
+			if (dst <= maxdst * maxdst) {
+				nodes[k] = np;
+				edges[n2].neighbors.erase(std::remove(
+					edges[n2].neighbors.begin(),
+					edges[n2].neighbors.end(), n1));
+				edges[n1].neighbors.erase(std::remove(
+					edges[n1].neighbors.begin(),
+					edges[n1].neighbors.end(), n2));
+				if (std::find(edges[k].neighbors.begin(),
+					      edges[k].neighbors.end(),
+					      n1) == edges[k].neighbors.end())
+					edges[k].neighbors.push_back(n1);
+				if (std::find(edges[k].neighbors.begin(),
+					      edges[k].neighbors.end(),
+					      n2) == edges[k].neighbors.end())
+					edges[k].neighbors.push_back(n2);
+				if (std::find(edges[n1].neighbors.begin(),
+					      edges[n1].neighbors.end(),
+					      k) == edges[n1].neighbors.end())
+					edges[n1].neighbors.push_back(k);
+				if (std::find(edges[n2].neighbors.begin(),
+					      edges[n2].neighbors.end(),
+					      k) == edges[n2].neighbors.end())
+					edges[n2].neighbors.push_back(k);
+				print_verbose("FIXED: " + itos(k) + ": " +
+					      String::num(dst));
+			}
+		}
+	}
 	Vector3 tangent(const Vector3 &v)
 	{
 		Vector2 rv = Vector2(v.x, v.z).tangent();
@@ -197,6 +268,7 @@ struct RoadLinesProcessing {
 	}
 	void road_setup()
 	{
+		int i, j;
 		RoadLinesData *rld = RoadLinesData::get_singleton();
 		std::vector<Vector3> road_lines_nodes;
 		std::unordered_map<uint32_t, std::vector<Vector3> >
@@ -207,8 +279,70 @@ struct RoadLinesProcessing {
 		rld->process_lines(road_lines_nodes_hash, road_lines_nodes);
 		create_nodes(road_lines_nodes);
 		create_edges();
+		optimize_nodes(16.0f);
+		sort_neighbors();
 		wedges.clear();
 		build_wedges(wedges);
+		ImmediateGeometry *d = rld->get_debug_node();
+		d->clear();
+		if (debug_flags & 1) {
+			d->begin(Mesh::PRIMITIVE_LINES);
+			for (i = 0; i < (int)nodes.size(); i++) {
+				d->set_color(Color(0.1f, 0.6f, 0.6f, 1.0f));
+				d->add_vertex(nodes[i]);
+				d->set_color(Color(0.1f, 0.6f, 0.6f, 1.0f));
+				d->add_vertex(nodes[i] +
+					      Vector3(0.0f, 200.0f, 0.0f));
+			}
+			d->end();
+		}
+		if (debug_flags & 2) {
+			d->begin(Mesh::PRIMITIVE_LINES);
+			for (i = 0; i < (int)nodes.size(); i++) {
+				const struct edgedata &e = edges[i];
+				for (j = 0; j < (int)e.neighbors.size(); j++) {
+					int idx1 = i;
+					int idx2 = e.neighbors[j];
+					assert(idx1 != idx2);
+					const Vector3 &p1 =
+						nodes[idx1] + Vector3(0, 10, 0);
+					const Vector3 &p2 =
+						nodes[idx2] + Vector3(0, 10, 0);
+					d->set_color(
+						Color(0.1f, 0.6f, 0.6f, 1.0f));
+					d->add_vertex(p1);
+					d->set_color(
+						Color(0.1f, 0.6f, 0.6f, 1.0f));
+					d->add_vertex(p2);
+				}
+			}
+			d->end();
+		}
+		if (debug_flags & 4) {
+			d->begin(Mesh::PRIMITIVE_LINES);
+			for (i = 0; i < (int)nodes.size(); i++) {
+				std::vector<struct wedge> wedge = wedges[i];
+				for (j = 0; j < (int)wedge.size(); j++) {
+					struct wedge w = wedge[j];
+					Vector3 p0 = w.p[0] + Vector3(0, 20, 0);
+					Vector3 p1 = w.p[1] + Vector3(0, 30, 0);
+					Vector3 p2 = w.p[2] + Vector3(0, 40, 0);
+					d->set_color(
+						Color(0.1f, 0.6f, 0.1f, 1.0f));
+					d->add_vertex(p0);
+					d->set_color(
+						Color(0.1f, 0.6f, 0.1f, 1.0f));
+					d->add_vertex(p1);
+					d->set_color(
+						Color(0.1f, 0.6f, 0.1f, 1.0f));
+					d->add_vertex(p1);
+					d->set_color(
+						Color(0.1f, 0.6f, 0.1f, 1.0f));
+					d->add_vertex(p2);
+				}
+			}
+			d->end();
+		}
 		print_line("ROAD SETUP DONE");
 	}
 };

src/modules/stream/world_editor.cpp

@@ -51,6 +51,7 @@ WorldEditor::WorldEditor()
 		InputMap::get_singleton()->add_action("mouse1");
 	EditorEvent::get_singleton()->event.add_listener(
 		this, &WorldEditor::event_signal_handler);
+	print_line("constructed");
 }
 
 WorldEditor::~WorldEditor()
@@ -65,6 +66,7 @@ WorldEditor::~WorldEditor()
 		memdelete(buildings_editor);
 		buildings_editor = nullptr;
 	}
+	print_line("destructed");
 }
 
 void WorldEditor::set_camera_mode(int mode)
@@ -159,6 +161,13 @@ static std::unordered_map<String, int, StringHasher> modes = {
 	{ "select_road_lines", WorldEditor::MODE_ROAD_LINES },
 	{ "select_npc", WorldEditor::MODE_NPC }
 };
+
+static std::unordered_map<int, String> vmode = { { 2, "%v_buildings" },
+						 { 3, "%v_navigation" },
+						 { 5, "%v_poi" },
+						 { 6, "%v_road_lines" },
+						 { 7, "%v_npc" } };
+
 void WorldEditor::tools_button(const String &button)
 {
 	Array change;
@@ -166,8 +175,11 @@ void WorldEditor::tools_button(const String &button)
 	print_line("tools_button: " + button);
 	if (modes.find(button) == modes.end())
 		goto end;
+	assert(modes[button] >= 0);
 	if (current_mode == modes[button])
 		goto end;
+	print_line("mode change: " + itos(current_mode) + " " +
+		   itos(modes[button]));
 	change[0] = current_mode;
 	change[1] = modes[button];
 	EditorEvent::get_singleton()->event.emit("mode_change_pre", change);
@@ -197,7 +209,9 @@ void WorldEditor::tools_button(const String &button)
 		break;
 	}
 	EditorEvent::get_singleton()->event.emit("mode_change_post", change);
+	assert(modes[button] >= 0);
 	current_mode = modes[button];
+	assert(current_mode >= 0);
 end:;
 }
 
@@ -269,6 +283,50 @@ int WorldEditor::get_current_mode() const
 
 void WorldEditor::event_signal_handler(const String &event, const Array &args)
 {
+	if (event == "mode_change_pre") {
+		int prev_mode = args[0];
+		if (prev_mode == -1) {
+			auto pt = vmode.begin();
+			while (pt != vmode.end()) {
+				auto data = *pt;
+				Control *p = Object::cast_to<Control>(
+					get_node(NodePath(data.second)));
+				assert(p);
+				p->hide();
+				pt++;
+			}
+		} else {
+			Control *p = Object::cast_to<Control>(
+				get_node(NodePath(vmode[prev_mode])));
+			assert(p);
+			p->hide();
+		}
+	} else if (event == "mode_change_post") {
+		int mode_next = args[1];
+		Control *p = Object::cast_to<Control>(
+			get_node(NodePath(vmode[mode_next])));
+		assert(p);
+		p->show();
+		switch (mode_next) {
+		case 2:
+			editor_command("get_building_types", Array());
+			break;
+		case 6:
+			editor_command("get_lines_list", Array());
+			break;
+		}
+	} else if (event == "editor_camera_moved") {
+		Camera *cam = get_viewport()->get_camera();
+		Spatial *area = Object::cast_to<Spatial>(
+			get_node(NodePath("%selection_area")));
+		assert(cam);
+		assert(area);
+		Transform area_transform = area->get_global_transform();
+		const Transform &cam_transform = cam->get_global_transform();
+		area_transform.origin.x = cam_transform.origin.x;
+		area_transform.origin.z = cam_transform.origin.z;
+		area->set_global_transform(area_transform);
+	}
 	emit_signal("editor_event", event, args);
 }
 
@@ -287,6 +345,9 @@ void WorldEditor::_notification(int which)
 {
 	switch (which) {
 	case NOTIFICATION_ENTER_TREE: {
+		if (Engine::get_singleton()->is_editor_hint()) {
+			return;
+		}
 		Node *base = get_parent();
 		int count = base->get_child_count();
 		int i;
@@ -303,6 +364,24 @@ void WorldEditor::_notification(int which)
 					    "world_command_result");
 			}
 		}
+		auto pt = vmode.begin();
+		while (pt != vmode.end()) {
+			auto data = *pt;
+			Control *p = Object::cast_to<Control>(
+				get_node(NodePath(data.second)));
+			assert(p);
+			p->hide();
+			pt++;
+		}
+		Spatial *building_cursor = Object::cast_to<Spatial>(
+			get_node(NodePath("%building_cursor")));
+		assert(building_cursor);
+		building_cursor->hide();
+		Spatial *line_cursor = Object::cast_to<Spatial>(
+			get_node(NodePath("%line_cursor")));
+		assert(line_cursor);
+		line_cursor->hide();
+
 		set_process_unhandled_input(true);
 		set_physics_process(true);
 		Spatial *cursor = Object::cast_to<Spatial>(
@@ -319,6 +398,9 @@ void WorldEditor::_notification(int which)
 		set_process_unhandled_input(false);
 		break;
 	case NOTIFICATION_PHYSICS_PROCESS: {
+		if (Engine::get_singleton()->is_editor_hint()) {
+			return;
+		}
 		if (!is_inside_tree())
 			return;
 		Camera *cam = get_viewport()->get_camera();
@@ -359,7 +441,6 @@ void WorldEditor::_notification(int which)
 			buildings_editor->update(delta);
 			break;
 		case MODE_ROAD_LINES:
-			// print_line("current_mode: " + itos(current_mode));
 			road_lines_editor->update(delta);
 			break;
 		}