Merge pull request #38386 from reduz/new-lightmapper

New GPU lightmapper

10 files changed, 1523 insertions, 816 deletions

diff --git a/scene/3d/baked_lightmap.cpp b/scene/3d/baked_lightmap.cpp
index 6bde56104e..6efe7f60b2 100644
--- a/scene/3d/baked_lightmap.cpp
+++ b/scene/3d/baked_lightmap.cpp
@@ -28,72 +28,24 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
 
-#if 0
 #include "baked_lightmap.h"
 #include "core/io/config_file.h"
 #include "core/io/resource_saver.h"
+#include "core/math/camera_matrix.h"
+#include "core/math/delaunay_3d.h"
 #include "core/os/dir_access.h"
+#include "core/os/file_access.h"
 #include "core/os/os.h"
-#include "voxel_light_baker.h"
+#include "core/sort_array.h"
+#include "lightmap_probe.h"
 
-void BakedLightmapData::set_bounds(const AABB &p_bounds) {
+void BakedLightmapData::add_user(const NodePath &p_path, const Rect2 &p_uv_scale, int p_slice_index, int32_t p_sub_instance) {
 
-	bounds = p_bounds;
-	RS::get_singleton()->lightmap_capture_set_bounds(baked_light, p_bounds);
-}
-
-AABB BakedLightmapData::get_bounds() const {
-
-	return bounds;
-}
-
-void BakedLightmapData::set_octree(const Vector<uint8_t> &p_octree) {
-
-	RS::get_singleton()->lightmap_capture_set_octree(baked_light, p_octree);
-}
-
-Vector<uint8_t> BakedLightmapData::get_octree() const {
-
-	return RS::get_singleton()->lightmap_capture_get_octree(baked_light);
-}
-
-void BakedLightmapData::set_cell_space_transform(const Transform &p_xform) {
-
-	cell_space_xform = p_xform;
-	RS::get_singleton()->lightmap_capture_set_octree_cell_transform(baked_light, p_xform);
-}
-
-Transform BakedLightmapData::get_cell_space_transform() const {
-	return cell_space_xform;
-}
-
-void BakedLightmapData::set_cell_subdiv(int p_cell_subdiv) {
-	cell_subdiv = p_cell_subdiv;
-	RS::get_singleton()->lightmap_capture_set_octree_cell_subdiv(baked_light, p_cell_subdiv);
-}
-
-int BakedLightmapData::get_cell_subdiv() const {
-	return cell_subdiv;
-}
-
-void BakedLightmapData::set_energy(float p_energy) {
-
-	energy = p_energy;
-	RS::get_singleton()->lightmap_capture_set_energy(baked_light, energy);
-}
-
-float BakedLightmapData::get_energy() const {
-
-	return energy;
-}
-
-void BakedLightmapData::add_user(const NodePath &p_path, const Ref<Texture2D> &p_lightmap, int p_instance) {
-
-	ERR_FAIL_COND_MSG(p_lightmap.is_null(), "It's not a reference to a valid Texture object.");
 	User user;
 	user.path = p_path;
-	user.lightmap = p_lightmap;
-	user.instance_index = p_instance;
+	user.uv_scale = p_uv_scale;
+	user.slice_index = p_slice_index;
+	user.sub_instance = p_sub_instance;
 	users.push_back(user);
 }
 
@@ -106,16 +58,23 @@ NodePath BakedLightmapData::get_user_path(int p_user) const {
 	ERR_FAIL_INDEX_V(p_user, users.size(), NodePath());
 	return users[p_user].path;
 }
-Ref<Texture2D> BakedLightmapData::get_user_lightmap(int p_user) const {
 
-	ERR_FAIL_INDEX_V(p_user, users.size(), Ref<Texture2D>());
-	return users[p_user].lightmap;
+int32_t BakedLightmapData::get_user_sub_instance(int p_user) const {
+
+	ERR_FAIL_INDEX_V(p_user, users.size(), -1);
+	return users[p_user].sub_instance;
+}
+
+Rect2 BakedLightmapData::get_user_lightmap_uv_scale(int p_user) const {
+
+	ERR_FAIL_INDEX_V(p_user, users.size(), Rect2());
+	return users[p_user].uv_scale;
 }
 
-int BakedLightmapData::get_user_instance(int p_user) const {
+int BakedLightmapData::get_user_lightmap_slice_index(int p_user) const {
 
 	ERR_FAIL_INDEX_V(p_user, users.size(), -1);
-	return users[p_user].instance_index;
+	return users[p_user].slice_index;
 }
 
 void BakedLightmapData::clear_users() {
@@ -124,10 +83,10 @@ void BakedLightmapData::clear_users() {
 
 void BakedLightmapData::_set_user_data(const Array &p_data) {
 
-	ERR_FAIL_COND((p_data.size() % 3) != 0);
+	ERR_FAIL_COND((p_data.size() % 4) != 0);
 
-	for (int i = 0; i < p_data.size(); i += 3) {
-		add_user(p_data[i], p_data[i + 1], p_data[i + 2]);
+	for (int i = 0; i < p_data.size(); i += 4) {
+		add_user(p_data[i + 0], p_data[i + 1], p_data[i + 2], p_data[i + 3]);
 	}
 }
 
@@ -136,522 +95,1132 @@ Array BakedLightmapData::_get_user_data() const {
 	Array ret;
 	for (int i = 0; i < users.size(); i++) {
 		ret.push_back(users[i].path);
-		ret.push_back(users[i].lightmap);
-		ret.push_back(users[i].instance_index);
+		ret.push_back(users[i].uv_scale);
+		ret.push_back(users[i].slice_index);
+		ret.push_back(users[i].sub_instance);
 	}
 	return ret;
 }
 
 RID BakedLightmapData::get_rid() const {
-	return baked_light;
+	return lightmap;
 }
-void BakedLightmapData::_bind_methods() {
 
-	ClassDB::bind_method(D_METHOD("_set_user_data", "data"), &BakedLightmapData::_set_user_data);
-	ClassDB::bind_method(D_METHOD("_get_user_data"), &BakedLightmapData::_get_user_data);
+void BakedLightmapData::clear() {
+	users.clear();
+}
 
-	ClassDB::bind_method(D_METHOD("set_bounds", "bounds"), &BakedLightmapData::set_bounds);
-	ClassDB::bind_method(D_METHOD("get_bounds"), &BakedLightmapData::get_bounds);
+void BakedLightmapData::set_light_texture(const Ref<TextureLayered> &p_light_texture) {
+	light_texture = p_light_texture;
+	RS::get_singleton()->lightmap_set_textures(lightmap, light_texture.is_valid() ? light_texture->get_rid() : RID(), uses_spherical_harmonics);
+}
 
-	ClassDB::bind_method(D_METHOD("set_cell_space_transform", "xform"), &BakedLightmapData::set_cell_space_transform);
-	ClassDB::bind_method(D_METHOD("get_cell_space_transform"), &BakedLightmapData::get_cell_space_transform);
+Ref<TextureLayered> BakedLightmapData::get_light_texture() const {
+	return light_texture;
+}
 
-	ClassDB::bind_method(D_METHOD("set_cell_subdiv", "cell_subdiv"), &BakedLightmapData::set_cell_subdiv);
-	ClassDB::bind_method(D_METHOD("get_cell_subdiv"), &BakedLightmapData::get_cell_subdiv);
+void BakedLightmapData::set_uses_spherical_harmonics(bool p_enable) {
+	uses_spherical_harmonics = p_enable;
+	RS::get_singleton()->lightmap_set_textures(lightmap, light_texture.is_valid() ? light_texture->get_rid() : RID(), uses_spherical_harmonics);
+}
 
-	ClassDB::bind_method(D_METHOD("set_octree", "octree"), &BakedLightmapData::set_octree);
-	ClassDB::bind_method(D_METHOD("get_octree"), &BakedLightmapData::get_octree);
+bool BakedLightmapData::is_using_spherical_harmonics() const {
+	return uses_spherical_harmonics;
+}
 
-	ClassDB::bind_method(D_METHOD("set_energy", "energy"), &BakedLightmapData::set_energy);
-	ClassDB::bind_method(D_METHOD("get_energy"), &BakedLightmapData::get_energy);
+void BakedLightmapData::set_capture_data(const AABB &p_bounds, bool p_interior, const PackedVector3Array &p_points, const PackedColorArray &p_point_sh, const PackedInt32Array &p_tetrahedra, const PackedInt32Array &p_bsp_tree) {
+	if (p_points.size()) {
+		int pc = p_points.size();
+		ERR_FAIL_COND(pc * 9 != p_point_sh.size());
+		ERR_FAIL_COND((p_tetrahedra.size() % 4) != 0);
+		ERR_FAIL_COND((p_bsp_tree.size() % 6) != 0);
+		RS::get_singleton()->lightmap_set_probe_capture_data(lightmap, p_points, p_point_sh, p_tetrahedra, p_bsp_tree);
+		RS::get_singleton()->lightmap_set_probe_bounds(lightmap, p_bounds);
+		RS::get_singleton()->lightmap_set_probe_interior(lightmap, p_interior);
+	} else {
+		RS::get_singleton()->lightmap_set_probe_capture_data(lightmap, PackedVector3Array(), PackedColorArray(), PackedInt32Array(), PackedInt32Array());
+		RS::get_singleton()->lightmap_set_probe_bounds(lightmap, AABB());
+		RS::get_singleton()->lightmap_set_probe_interior(lightmap, false);
+	}
+	interior = p_interior;
+	bounds = p_bounds;
+}
 
-	ClassDB::bind_method(D_METHOD("add_user", "path", "lightmap", "instance"), &BakedLightmapData::add_user);
-	ClassDB::bind_method(D_METHOD("get_user_count"), &BakedLightmapData::get_user_count);
-	ClassDB::bind_method(D_METHOD("get_user_path", "user_idx"), &BakedLightmapData::get_user_path);
-	ClassDB::bind_method(D_METHOD("get_user_lightmap", "user_idx"), &BakedLightmapData::get_user_lightmap);
-	ClassDB::bind_method(D_METHOD("clear_users"), &BakedLightmapData::clear_users);
+PackedVector3Array BakedLightmapData::get_capture_points() const {
+	return RS::get_singleton()->lightmap_get_probe_capture_points(lightmap);
+}
+PackedColorArray BakedLightmapData::get_capture_sh() const {
+	return RS::get_singleton()->lightmap_get_probe_capture_sh(lightmap);
+}
+PackedInt32Array BakedLightmapData::get_capture_tetrahedra() const {
+	return RS::get_singleton()->lightmap_get_probe_capture_tetrahedra(lightmap);
+}
 
-	ADD_PROPERTY(PropertyInfo(Variant::AABB, "bounds", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR), "set_bounds", "get_bounds");
-	ADD_PROPERTY(PropertyInfo(Variant::TRANSFORM, "cell_space_transform", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR), "set_cell_space_transform", "get_cell_space_transform");
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "cell_subdiv", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR), "set_cell_subdiv", "get_cell_subdiv");
-	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "energy", PROPERTY_HINT_RANGE, "0,16,0.01,or_greater"), "set_energy", "get_energy");
-	ADD_PROPERTY(PropertyInfo(Variant::PACKED_BYTE_ARRAY, "octree", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR), "set_octree", "get_octree");
-	ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "user_data", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL), "_set_user_data", "_get_user_data");
+PackedInt32Array BakedLightmapData::get_capture_bsp_tree() const {
+	return RS::get_singleton()->lightmap_get_probe_capture_bsp_tree(lightmap);
 }
 
-BakedLightmapData::BakedLightmapData() {
+AABB BakedLightmapData::get_capture_bounds() const {
+	return bounds;
+}
 
-	baked_light = RS::get_singleton()->lightmap_capture_create();
-	energy = 1;
-	cell_subdiv = 1;
+bool BakedLightmapData::is_interior() const {
+	return interior;
 }
 
-BakedLightmapData::~BakedLightmapData() {
+void BakedLightmapData::_set_probe_data(const Dictionary &p_data) {
+	ERR_FAIL_COND(!p_data.has("bounds"));
+	ERR_FAIL_COND(!p_data.has("points"));
+	ERR_FAIL_COND(!p_data.has("tetrahedra"));
+	ERR_FAIL_COND(!p_data.has("bsp"));
+	ERR_FAIL_COND(!p_data.has("sh"));
+	ERR_FAIL_COND(!p_data.has("interior"));
+	set_capture_data(p_data["bounds"], p_data["interior"], p_data["points"], p_data["sh"], p_data["tetrahedra"], p_data["bsp"]);
+}
 
-	RS::get_singleton()->free(baked_light);
+Dictionary BakedLightmapData::_get_probe_data() const {
+	Dictionary d;
+	d["bounds"] = get_capture_bounds();
+	d["points"] = get_capture_points();
+	d["tetrahedra"] = get_capture_tetrahedra();
+	d["bsp"] = get_capture_bsp_tree();
+	d["sh"] = get_capture_sh();
+	d["interior"] = is_interior();
+	return d;
 }
+void BakedLightmapData::_bind_methods() {
 
-///////////////////////////
+	ClassDB::bind_method(D_METHOD("_set_user_data", "data"), &BakedLightmapData::_set_user_data);
+	ClassDB::bind_method(D_METHOD("_get_user_data"), &BakedLightmapData::_get_user_data);
 
-BakedLightmap::BakeBeginFunc BakedLightmap::bake_begin_function = nullptr;
-BakedLightmap::BakeStepFunc BakedLightmap::bake_step_function = nullptr;
-BakedLightmap::BakeEndFunc BakedLightmap::bake_end_function = nullptr;
+	ClassDB::bind_method(D_METHOD("set_light_texture", "light_texture"), &BakedLightmapData::set_light_texture);
+	ClassDB::bind_method(D_METHOD("get_light_texture"), &BakedLightmapData::get_light_texture);
 
-void BakedLightmap::set_bake_cell_size(float p_cell_size) {
-	bake_cell_size = p_cell_size;
-}
+	ClassDB::bind_method(D_METHOD("set_uses_spherical_harmonics", "uses_spherical_harmonics"), &BakedLightmapData::set_uses_spherical_harmonics);
+	ClassDB::bind_method(D_METHOD("is_using_spherical_harmonics"), &BakedLightmapData::is_using_spherical_harmonics);
 
-float BakedLightmap::get_bake_cell_size() const {
-	return bake_cell_size;
-}
+	ClassDB::bind_method(D_METHOD("add_user", "path", "lightmap", "offset"), &BakedLightmapData::add_user);
+	ClassDB::bind_method(D_METHOD("get_user_count"), &BakedLightmapData::get_user_count);
+	ClassDB::bind_method(D_METHOD("get_user_path", "user_idx"), &BakedLightmapData::get_user_path);
+	ClassDB::bind_method(D_METHOD("clear_users"), &BakedLightmapData::clear_users);
 
-void BakedLightmap::set_capture_cell_size(float p_cell_size) {
-	capture_cell_size = p_cell_size;
-}
+	ClassDB::bind_method(D_METHOD("_set_probe_data", "data"), &BakedLightmapData::_set_probe_data);
+	ClassDB::bind_method(D_METHOD("_get_probe_data"), &BakedLightmapData::_get_probe_data);
 
-float BakedLightmap::get_capture_cell_size() const {
-	return capture_cell_size;
+	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "light_texture", PROPERTY_HINT_RESOURCE_TYPE, "TextureLayered"), "set_light_texture", "get_light_texture");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "uses_spherical_harmonics", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL), "set_uses_spherical_harmonics", "is_using_spherical_harmonics");
+	ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "user_data", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL), "_set_user_data", "_get_user_data");
+	ADD_PROPERTY(PropertyInfo(Variant::DICTIONARY, "probe_data", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL), "_set_probe_data", "_get_probe_data");
 }
 
-void BakedLightmap::set_extents(const Vector3 &p_extents) {
-	extents = p_extents;
-	update_gizmo();
-	_change_notify("bake_extents");
-}
+BakedLightmapData::BakedLightmapData() {
 
-Vector3 BakedLightmap::get_extents() const {
-	return extents;
+	lightmap = RS::get_singleton()->lightmap_create();
 }
 
-void BakedLightmap::set_bake_default_texels_per_unit(const float &p_bake_texels_per_unit) {
-	bake_default_texels_per_unit = p_bake_texels_per_unit;
-	update_gizmo();
-}
+BakedLightmapData::~BakedLightmapData() {
 
-float BakedLightmap::get_bake_default_texels_per_unit() const {
-	return bake_default_texels_per_unit;
+	RS::get_singleton()->free(lightmap);
 }
 
-void BakedLightmap::_find_meshes_and_lights(Node *p_at_node, List<PlotMesh> &plot_meshes, List<PlotLight> &plot_lights) {
+///////////////////////////
+
+void BakedLightmap::_find_meshes_and_lights(Node *p_at_node, Vector<MeshesFound> &meshes, Vector<LightsFound> &lights, Vector<Vector3> &probes) {
 
-	MeshInstance *mi = Object::cast_to<MeshInstance>(p_at_node);
-	if (mi && mi->get_flag(GeometryInstance::FLAG_USE_BAKED_LIGHT) && mi->is_visible_in_tree()) {
+	MeshInstance3D *mi = Object::cast_to<MeshInstance3D>(p_at_node);
+	if (mi && mi->get_gi_mode() == GeometryInstance3D::GI_MODE_BAKED && mi->is_visible_in_tree()) {
 		Ref<Mesh> mesh = mi->get_mesh();
 		if (mesh.is_valid()) {
 
-			bool all_have_uv2 = true;
+			bool all_have_uv2_and_normal = true;
+			bool surfaces_found = false;
 			for (int i = 0; i < mesh->get_surface_count(); i++) {
+
+				if (mesh->surface_get_primitive_type(i) != Mesh::PRIMITIVE_TRIANGLES) {
+					continue;
+				}
 				if (!(mesh->surface_get_format(i) & Mesh::ARRAY_FORMAT_TEX_UV2)) {
-					all_have_uv2 = false;
+					all_have_uv2_and_normal = false;
+					break;
+				}
+				if (!(mesh->surface_get_format(i) & Mesh::ARRAY_FORMAT_NORMAL)) {
+					all_have_uv2_and_normal = false;
 					break;
 				}
+				surfaces_found = true;
 			}
 
-			if (all_have_uv2) {
+			if (surfaces_found && all_have_uv2_and_normal) {
 				//READY TO BAKE! size hint could be computed if not found, actually..
 
-				AABB aabb = mesh->get_aabb();
-
-				Transform xf = get_global_transform().affine_inverse() * mi->get_global_transform();
-
-				if (AABB(-extents, extents * 2).intersects(xf.xform(aabb))) {
-					PlotMesh pm;
-					pm.local_xform = xf;
-					pm.mesh = mesh;
-					pm.path = get_path_to(mi);
-					pm.instance_idx = -1;
-					for (int i = 0; i < mesh->get_surface_count(); i++) {
-						pm.instance_materials.push_back(mi->get_surface_material(i));
+				MeshesFound mf;
+				mf.xform = get_global_transform().affine_inverse() * mi->get_global_transform();
+				mf.node_path = get_path_to(mi);
+				mf.subindex = -1;
+				mf.mesh = mesh;
+
+				static const int lightmap_scale[GeometryInstance3D::LIGHTMAP_SCALE_MAX] = { 1, 2, 4, 8 };
+				mf.lightmap_scale = lightmap_scale[mi->get_lightmap_scale()];
+
+				Ref<Material> all_override = mi->get_material_override();
+				for (int i = 0; i < mesh->get_surface_count(); i++) {
+					if (all_override.is_valid()) {
+						mf.overrides.push_back(all_override);
+					} else {
+						mf.overrides.push_back(mi->get_surface_material(i));
 					}
-					pm.override_material = mi->get_material_override();
-					plot_meshes.push_back(pm);
 				}
+
+				meshes.push_back(mf);
 			}
 		}
 	}
 
-	Spatial *s = Object::cast_to<Spatial>(p_at_node);
+	Node3D *s = Object::cast_to<Node3D>(p_at_node);
 
 	if (!mi && s) {
-		Array meshes = p_at_node->call("get_bake_meshes");
-		if (meshes.size() && (meshes.size() & 1) == 0) {
+		Array bmeshes = p_at_node->call("get_bake_bmeshes");
+		if (bmeshes.size() && (bmeshes.size() & 1) == 0) {
 			Transform xf = get_global_transform().affine_inverse() * s->get_global_transform();
-			for (int i = 0; i < meshes.size(); i += 2) {
-				PlotMesh pm;
-				Transform mesh_xf = meshes[i + 1];
-				pm.local_xform = xf * mesh_xf;
-				pm.mesh = meshes[i];
-				pm.instance_idx = i / 2;
-				if (!pm.mesh.is_valid())
+			for (int i = 0; i < bmeshes.size(); i += 2) {
+
+				Ref<Mesh> mesh = bmeshes[i];
+				if (!mesh.is_valid())
 					continue;
-				pm.path = get_path_to(s);
-				plot_meshes.push_back(pm);
+
+				MeshesFound mf;
+
+				Transform mesh_xf = bmeshes[i + 1];
+				mf.xform = xf * mesh_xf;
+				mf.node_path = get_path_to(s);
+				mf.subindex = i / 2;
+				mf.lightmap_scale = 1;
+				mf.mesh = mesh;
+
+				meshes.push_back(mf);
 			}
 		}
 	}
 
-	Light *light = Object::cast_to<Light>(p_at_node);
+	Light3D *light = Object::cast_to<Light3D>(p_at_node);
 
-	if (light && light->get_bake_mode() != Light::BAKE_DISABLED) {
-		PlotLight pl;
-		Transform xf = get_global_transform().affine_inverse() * light->get_global_transform();
+	if (light && light->get_bake_mode() != Light3D::BAKE_DISABLED) {
 
-		pl.local_xform = xf;
-		pl.light = light;
-		plot_lights.push_back(pl);
+		LightsFound lf;
+		lf.xform = get_global_transform().affine_inverse() * light->get_global_transform();
+		lf.light = light;
+		lights.push_back(lf);
 	}
+
+	LightmapProbe *probe = Object::cast_to<LightmapProbe>(p_at_node);
+
+	if (probe) {
+		Transform xf = get_global_transform().affine_inverse() * probe->get_global_transform();
+		probes.push_back(xf.origin);
+	}
+
 	for (int i = 0; i < p_at_node->get_child_count(); i++) {
 
 		Node *child = p_at_node->get_child(i);
 		if (!child->get_owner())
 			continue; //maybe a helper
 
-		_find_meshes_and_lights(child, plot_meshes, plot_lights);
+		_find_meshes_and_lights(child, meshes, lights, probes);
 	}
 }
 
-void BakedLightmap::set_hdr(bool p_enable) {
-	hdr = p_enable;
-}
+int BakedLightmap::_bsp_get_simplex_side(const Vector<Vector3> &p_points, const LocalVector<BSPSimplex> &p_simplices, const Plane &p_plane, uint32_t p_simplex) const {
+
+	int over = 0;
+	int under = 0;
+	int coplanar = 0;
+	const BSPSimplex &s = p_simplices[p_simplex];
+	for (int i = 0; i < 4; i++) {
+		const Vector3 v = p_points[s.vertices[i]];
+		if (p_plane.has_point(v)) { //coplanar
+			coplanar++;
+		} else if (p_plane.is_point_over(v)) {
+			over++;
+		} else {
+			under++;
+		}
+	}
 
-bool BakedLightmap::is_hdr() const {
-	return hdr;
+	ERR_FAIL_COND_V(under == 0 && over == 0, -2); //should never happen, we discarded flat simplices before, but in any case drop it from the bsp tree and throw an error
+	if (under == 0) {
+		return 1; // all over
+	} else if (over == 0) {
+		return -1; // all under
+	} else {
+		return 0; // crossing
+	}
 }
 
-bool BakedLightmap::_bake_time(void *ud, float p_secs, float p_progress) {
+//#define DEBUG_BSP
 
-	uint64_t time = OS::get_singleton()->get_ticks_usec();
-	BakeTimeData *btd = (BakeTimeData *)ud;
+int32_t BakedLightmap::_compute_bsp_tree(const Vector<Vector3> &p_points, const LocalVector<Plane> &p_planes, LocalVector<int32_t> &planes_tested, const LocalVector<BSPSimplex> &p_simplices, const LocalVector<int32_t> &p_simplex_indices, LocalVector<BSPNode> &bsp_nodes) {
 
-	if (time - btd->last_step > 1000000) {
+	//if we reach here, it means there is more than one simplex
+	int32_t node_index = (int32_t)bsp_nodes.size();
+	bsp_nodes.push_back(BSPNode());
 
-		int mins_left = p_secs / 60;
-		int secs_left = Math::fmod(p_secs, 60.0f);
-		int percent = p_progress * 100;
-		bool abort = bake_step_function(btd->pass + percent, btd->text + " " + vformat(RTR("%d%%"), percent) + " " + vformat(RTR("(Time Left: %d:%02d s)"), mins_left, secs_left));
-		btd->last_step = time;
-		if (abort)
-			return true;
-	}
+	//test with all the simplex planes
+	Plane best_plane;
+	float best_plane_score = -1.0;
 
-	return false;
-}
+	for (uint32_t i = 0; i < p_simplex_indices.size(); i++) {
+		const BSPSimplex &s = p_simplices[p_simplex_indices[i]];
+		for (int j = 0; j < 4; j++) {
+			uint32_t plane_index = s.planes[j];
+			if (planes_tested[plane_index] == node_index) {
+				continue; //tested this plane already
+			}
+
+			planes_tested[plane_index] = node_index;
+
+			static const int face_order[4][3] = {
+				{ 0, 1, 2 },
+				{ 0, 2, 3 },
+				{ 0, 1, 3 },
+				{ 1, 2, 3 }
+			};
+
+			// despite getting rid of plane duplicates, we should still use here the actual plane to avoid numerical error
+			// from thinking this same simplex is intersecting rather than on a side
+			Vector3 v0 = p_points[s.vertices[face_order[j][0]]];
+			Vector3 v1 = p_points[s.vertices[face_order[j][1]]];
+			Vector3 v2 = p_points[s.vertices[face_order[j][2]]];
+
+			Plane plane(v0, v1, v2);
+
+			//test with all the simplices
+			int over_count = 0;
+			int under_count = 0;
+
+			for (uint32_t k = 0; k < p_simplex_indices.size(); k++) {
+				int side = _bsp_get_simplex_side(p_points, p_simplices, plane, p_simplex_indices[k]);
+				if (side == -2) {
+					continue; //this simplex is invalid, skip for now
+				} else if (side < 0) {
+					under_count++;
+				} else if (side > 0) {
+					over_count++;
+				}
+			}
 
-BakedLightmap::BakeError BakedLightmap::bake(Node *p_from_node, bool p_create_visual_debug) {
+			if (under_count == 0 && over_count == 0) {
+				continue; //most likely precision issue with a flat simplex, do not try this plane
+			}
 
-	String save_path;
+			if (under_count > over_count) { //make sure under is always less than over, so we can compute the same ratio
+				SWAP(under_count, over_count);
+			}
 
-	if (image_path.begins_with("res://")) {
-		save_path = image_path;
-	} else {
-		if (get_filename() != "") {
-			save_path = get_filename().get_base_dir();
-		} else if (get_owner() && get_owner()->get_filename() != "") {
-			save_path = get_owner()->get_filename().get_base_dir();
+			float score = 0; //by default, score is 0 (worst)
+			if (over_count > 0) {
+				//give score mainly based on ratio (under / over), this means that this plane is splitting simplices a lot, but its balanced
+				score = float(under_count) / over_count;
+			}
+
+			//adjusting priority over least splits, probably not a great idea
+			//score *= Math::sqrt(float(over_count + under_count) / p_simplex_indices.size()); //also multiply score
+
+			if (score > best_plane_score) {
+
+				best_plane = plane;
+				best_plane_score = score;
+			}
 		}
+	}
 
-		if (save_path == "") {
-			return BAKE_ERROR_NO_SAVE_PATH;
+	LocalVector<int32_t> indices_over;
+	LocalVector<int32_t> indices_under;
+
+	//split again, but add to list
+	for (uint32_t i = 0; i < p_simplex_indices.size(); i++) {
+
+		uint32_t index = p_simplex_indices[i];
+		int side = _bsp_get_simplex_side(p_points, p_simplices, best_plane, index);
+
+		if (side == -2) {
+			continue; //simplex sits on the plane, does not make sense to use it
 		}
-		if (image_path != "") {
-			save_path.plus_file(image_path);
+		if (side <= 0) {
+			indices_under.push_back(index);
 		}
-	}
-	{
-		//check for valid save path
-		DirAccessRef d = DirAccess::open(save_path);
-		if (!d) {
-			ERR_PRINT("Invalid Save Path '" + save_path + "'.");
-			return BAKE_ERROR_NO_SAVE_PATH;
+
+		if (side >= 0) {
+			indices_over.push_back(index);
 		}
 	}
 
-	Ref<BakedLightmapData> new_light_data;
-	new_light_data.instance();
+#ifdef DEBUG_BSP
+	print_line("node " + itos(node_index) + " found plane: " + best_plane + " score:" + rtos(best_plane_score) + " - over " + itos(indices_over.size()) + " under " + itos(indices_under.size()) + " intersecting " + itos(intersecting));
+#endif
+
+	if (best_plane_score < 0.0 || indices_over.size() == p_simplex_indices.size() || indices_under.size() == p_simplex_indices.size()) {
+		ERR_FAIL_COND_V(p_simplex_indices.size() <= 1, 0); //should not happen, this is a bug
 
-	Voxelizer baker;
+		// Failed to separate the tetrahedrons using planes
+		// this means Delaunay borked at some point.
+		// Luckily, because we are using tetrahedrons, we can resort to
+		// less precise but still working ways to generate the separating plane
+		// this will most likely look bad when interpolating, but at least it will not crash.
+		// and the arctifact will most likely also be very small, so too difficult to notice.
 
-	int bake_subdiv;
-	int capture_subdiv;
-	AABB bake_bounds;
-	{
-		bake_bounds = AABB(-extents, extents * 2.0);
-		int subdiv = nearest_power_of_2_templated(int(bake_bounds.get_longest_axis_size() / bake_cell_size));
-		bake_bounds.size[bake_bounds.get_longest_axis_index()] = subdiv * bake_cell_size;
-		bake_subdiv = nearest_shift(subdiv) + 1;
+		//find the longest axis
+
+		WARN_PRINT("Inconsistency found in triangulation while building BSP, probe interpolation quality may degrade a bit.");
 
-		capture_subdiv = bake_subdiv;
-		float css = bake_cell_size;
-		while (css < capture_cell_size && capture_subdiv > 2) {
-			capture_subdiv--;
-			css *= 2.0;
+		LocalVector<Vector3> centers;
+		AABB bounds_all;
+		for (uint32_t i = 0; i < p_simplex_indices.size(); i++) {
+			AABB bounds;
+			for (uint32_t j = 0; j < 4; j++) {
+
+				Vector3 p = p_points[p_simplices[p_simplex_indices[i]].vertices[j]];
+				if (j == 0) {
+					bounds.position = p;
+				} else {
+					bounds.expand_to(p);
+				}
+			}
+			if (i == 0) {
+				centers.push_back(bounds.position + bounds.size * 0.5);
+			} else {
+				bounds_all.merge_with(bounds);
+			}
 		}
+		Vector3::Axis longest_axis = Vector3::Axis(bounds_all.get_longest_axis_index());
+
+		//find the simplex that will go under
+		uint32_t min_d_idx = 0xFFFFFFFF;
+		float min_d_dist = 1e20;
+
+		for (uint32_t i = 0; i < centers.size(); i++) {
+			if (centers[i][longest_axis] < min_d_dist) {
+				min_d_idx = i;
+				min_d_dist = centers[i][longest_axis];
+			}
+		}
+		//rebuild best_plane and over/under arrays
+		best_plane = Plane();
+		best_plane.normal[longest_axis] = 1.0;
+		best_plane.d = min_d_dist;
+
+		indices_under.clear();
+		indices_under.push_back(min_d_idx);
+
+		indices_over.clear();
+
+		for (uint32_t i = 0; i < p_simplex_indices.size(); i++) {
+			if (i == min_d_idx) {
+				continue;
+			}
+			indices_over.push_back(p_simplex_indices[i]);
+		}
+	}
+
+	BSPNode node;
+	node.plane = best_plane;
+
+	if (indices_under.size() == 0) {
+		//noting to do here
+		node.under = BSPNode::EMPTY_LEAF;
+	} else if (indices_under.size() == 1) {
+		node.under = -(indices_under[0] + 1);
+	} else {
+		node.under = _compute_bsp_tree(p_points, p_planes, planes_tested, p_simplices, indices_under, bsp_nodes);
+	}
+
+	if (indices_over.size() == 0) {
+		//noting to do here
+		node.over = BSPNode::EMPTY_LEAF;
+	} else if (indices_over.size() == 1) {
+		node.over = -(indices_over[0] + 1);
+	} else {
+		node.over = _compute_bsp_tree(p_points, p_planes, planes_tested, p_simplices, indices_over, bsp_nodes);
 	}
 
-	baker.begin_bake(bake_subdiv, bake_bounds);
+	bsp_nodes[node_index] = node;
 
-	List<PlotMesh> mesh_list;
-	List<PlotLight> light_list;
+	return node_index;
+}
 
-	_find_meshes_and_lights(p_from_node ? p_from_node : get_parent(), mesh_list, light_list);
+bool BakedLightmap::_lightmap_bake_step_function(float p_completion, const String &p_text, void *ud, bool p_refresh) {
 
-	if (bake_begin_function) {
-		bake_begin_function(mesh_list.size() + light_list.size() + 1 + mesh_list.size() * 100);
+	BakeStepUD *bsud = (BakeStepUD *)ud;
+	bool ret = false;
+	if (bsud->func) {
+		ret = bsud->func(bsud->from_percent + p_completion * (bsud->to_percent - bsud->from_percent), p_text, bsud->ud, p_refresh);
 	}
+	return ret;
+}
 
-	int step = 0;
+void BakedLightmap::_plot_triangle_into_octree(GenProbesOctree *p_cell, float p_cell_size, const Vector3 *p_triangle) {
 
-	int pmc = 0;
+	for (int i = 0; i < 8; i++) {
+		Vector3i pos = p_cell->offset;
+		uint32_t half_size = p_cell->size / 2;
+		if (i & 1) {
+			pos.x += half_size;
+		}
+		if (i & 2) {
+			pos.y += half_size;
+		}
+		if (i & 4) {
+			pos.z += half_size;
+		}
+
+		AABB subcell;
+		subcell.position = Vector3(pos) * p_cell_size;
+		subcell.size = Vector3(half_size, half_size, half_size) * p_cell_size;
 
-	for (List<PlotMesh>::Element *E = mesh_list.front(); E; E = E->next()) {
+		if (!Geometry::triangle_box_overlap(subcell.position + subcell.size * 0.5, subcell.size * 0.5, p_triangle))
+			continue;
 
-		if (bake_step_function) {
-			bake_step_function(step++, RTR("Plotting Meshes: ") + " (" + itos(pmc + 1) + "/" + itos(mesh_list.size()) + ")");
+		if (p_cell->children[i] == nullptr) {
+			GenProbesOctree *child = memnew(GenProbesOctree);
+			child->offset = pos;
+			child->size = half_size;
+			p_cell->children[i] = child;
 		}
 
-		pmc++;
-		baker.plot_mesh(E->get().local_xform, E->get().mesh, E->get().instance_materials, E->get().override_material);
+		if (half_size > 1) {
+			//still levels missing
+			_plot_triangle_into_octree(p_cell->children[i], p_cell_size, p_triangle);
+		}
 	}
+}
+void BakedLightmap::_gen_new_positions_from_octree(const GenProbesOctree *p_cell, float p_cell_size, const Vector<Vector3> &probe_positions, LocalVector<Vector3> &new_probe_positions, HashMap<Vector3i, bool, Vector3iHash> &positions_used, const AABB &p_bounds) {
+
+	for (int i = 0; i < 8; i++) {
+
+		Vector3i pos = p_cell->offset;
+		if (i & 1) {
+			pos.x += p_cell->size;
+		}
+		if (i & 2) {
+			pos.y += p_cell->size;
+		}
+		if (i & 4) {
+			pos.z += p_cell->size;
+		}
+
+		if (p_cell->size == 1 && !positions_used.has(pos)) {
+			//new position to insert!
+			Vector3 real_pos = p_bounds.position + Vector3(pos) * p_cell_size;
+			//see if a user submitted probe is too close
+			int ppcount = probe_positions.size();
+			const Vector3 *pp = probe_positions.ptr();
+			bool exists = false;
+			for (int j = 0; j < ppcount; j++) {
+
+				if (pp[j].distance_to(real_pos) < CMP_EPSILON) {
+					exists = true;
+					break;
+				}
+			}
 
-	pmc = 0;
-	baker.begin_bake_light(Voxelizer::BakeQuality(bake_quality), Voxelizer::BakeMode(bake_mode), propagation, energy);
+			if (!exists) {
+				new_probe_positions.push_back(real_pos);
+			}
 
-	for (List<PlotLight>::Element *E = light_list.front(); E; E = E->next()) {
+			positions_used[pos] = true;
+		}
 
-		if (bake_step_function) {
-			bake_step_function(step++, RTR("Plotting Lights:") + " (" + itos(pmc + 1) + "/" + itos(light_list.size()) + ")");
+		if (p_cell->children[i] != nullptr) {
+			_gen_new_positions_from_octree(p_cell->children[i], p_cell_size, probe_positions, new_probe_positions, positions_used, p_bounds);
 		}
+	}
+}
+BakedLightmap::BakeError BakedLightmap::bake(Node *p_from_node, String p_image_data_path, Lightmapper::BakeStepFunc p_bake_step, void *p_bake_userdata) {
 
-		pmc++;
-		PlotLight pl = E->get();
-		switch (pl.light->get_light_type()) {
-			case RS::LIGHT_DIRECTIONAL: {
-				baker.plot_light_directional(-pl.local_xform.basis.get_axis(2), pl.light->get_color(), pl.light->get_param(Light::PARAM_ENERGY), pl.light->get_param(Light::PARAM_INDIRECT_ENERGY), pl.light->get_bake_mode() == Light::BAKE_ALL);
-			} break;
-			case RS::LIGHT_OMNI: {
-				baker.plot_light_omni(pl.local_xform.origin, pl.light->get_color(), pl.light->get_param(Light::PARAM_ENERGY), pl.light->get_param(Light::PARAM_INDIRECT_ENERGY), pl.light->get_param(Light::PARAM_RANGE), pl.light->get_param(Light::PARAM_ATTENUATION), pl.light->get_bake_mode() == Light::BAKE_ALL);
-			} break;
-			case RS::LIGHT_SPOT: {
-				baker.plot_light_spot(pl.local_xform.origin, pl.local_xform.basis.get_axis(2), pl.light->get_color(), pl.light->get_param(Light::PARAM_ENERGY), pl.light->get_param(Light::PARAM_INDIRECT_ENERGY), pl.light->get_param(Light::PARAM_RANGE), pl.light->get_param(Light::PARAM_ATTENUATION), pl.light->get_param(Light::PARAM_SPOT_ANGLE), pl.light->get_param(Light::PARAM_SPOT_ATTENUATION), pl.light->get_bake_mode() == Light::BAKE_ALL);
+	if (p_image_data_path == "" && (get_light_data().is_null() || !get_light_data()->get_path().is_resource_file())) {
+		return BAKE_ERROR_NO_SAVE_PATH;
+	}
 
-			} break;
+	if (p_image_data_path == "") {
+
+		if (get_light_data().is_null()) {
+			return BAKE_ERROR_NO_SAVE_PATH;
+		}
+
+		p_image_data_path = get_light_data()->get_path();
+		if (!p_image_data_path.is_resource_file()) {
+			return BAKE_ERROR_NO_SAVE_PATH;
 		}
 	}
-	/*if (bake_step_function) {
-		bake_step_function(pmc++, RTR("Finishing Plot"));
-	}*/
 
-	baker.end_bake();
+	Ref<Lightmapper> lightmapper = Lightmapper::create();
+	ERR_FAIL_COND_V(lightmapper.is_null(), BAKE_ERROR_NO_LIGHTMAPPER);
 
-	Set<String> used_mesh_names;
+	BakeStepUD bsud;
+	bsud.func = p_bake_step;
+	bsud.ud = p_bake_userdata;
+	bsud.from_percent = 0.2;
+	bsud.to_percent = 0.8;
 
-	pmc = 0;
-	for (List<PlotMesh>::Element *E = mesh_list.front(); E; E = E->next()) {
+	if (p_bake_step) {
+		p_bake_step(0.0, TTR("Finding meshes, lights and probes"), p_bake_userdata, true);
+	}
+	/* STEP 1, FIND MESHES, LIGHTS AND PROBES */
+	Vector<Lightmapper::MeshData> mesh_data;
+	Vector<LightsFound> lights_found;
+	Vector<Vector3> probes_found;
+	AABB bounds;
+	{
+		Vector<MeshesFound> meshes_found;
+		_find_meshes_and_lights(p_from_node ? p_from_node : get_parent(), meshes_found, lights_found, probes_found);
 
-		String mesh_name = E->get().mesh->get_name();
-		if (mesh_name == "" || mesh_name.find(":") != -1 || mesh_name.find("/") != -1) {
-			mesh_name = "LightMap";
+		if (meshes_found.size() == 0) {
+			return BAKE_ERROR_NO_MESHES;
 		}
+		// create mesh data for insert
 
-		if (used_mesh_names.has(mesh_name)) {
-			int idx = 2;
-			String base = mesh_name;
-			while (true) {
-				mesh_name = base + itos(idx);
-				if (!used_mesh_names.has(mesh_name))
-					break;
-				idx++;
+		//get the base material textures, help compute altlas size and bounds
+		for (int m_i = 0; m_i < meshes_found.size(); m_i++) {
+
+			if (p_bake_step) {
+				float p = (float)(m_i) / meshes_found.size();
+				p_bake_step(p * 0.1, vformat(TTR("Preparing geometry %d/%d"), m_i, meshes_found.size()), p_bake_userdata, false);
 			}
-		}
-		used_mesh_names.insert(mesh_name);
 
-		pmc++;
-		Voxelizer::LightMapData lm;
+			MeshesFound &mf = meshes_found.write[m_i];
 
-		Error err;
-		if (bake_step_function) {
-			BakeTimeData btd;
-			btd.text = RTR("Lighting Meshes: ") + mesh_name + " (" + itos(pmc) + "/" + itos(mesh_list.size()) + ")";
-			btd.pass = step;
-			btd.last_step = 0;
-			err = baker.make_lightmap(E->get().local_xform, E->get().mesh, bake_default_texels_per_unit, lm, _bake_time, &btd);
-			if (err != OK) {
-				bake_end_function();
-				if (err == ERR_SKIP)
-					return BAKE_ERROR_USER_ABORTED;
-				return BAKE_ERROR_CANT_CREATE_IMAGE;
+			Size2i lightmap_size = mf.mesh->get_lightmap_size_hint() * mf.lightmap_scale;
+			Vector<RID> overrides;
+			overrides.resize(mf.overrides.size());
+			for (int i = 0; i < mf.overrides.size(); i++) {
+				if (mf.overrides[i].is_valid()) {
+					overrides.write[i] = mf.overrides[i]->get_rid();
+				}
 			}
-			step += 100;
-		} else {
+			TypedArray<Image> images = RS::get_singleton()->bake_render_uv2(mf.mesh->get_rid(), overrides, lightmap_size);
 
-			err = baker.make_lightmap(E->get().local_xform, E->get().mesh, bake_default_texels_per_unit, lm);
-		}
+			ERR_FAIL_COND_V(images.empty(), BAKE_ERROR_CANT_CREATE_IMAGE);
+
+			Ref<Image> albedo = images[RS::BAKE_CHANNEL_ALBEDO_ALPHA];
+			Ref<Image> orm = images[RS::BAKE_CHANNEL_ORM];
 
-		if (err == OK) {
+			//multiply albedo by metal
 
-			Ref<Image> image;
-			image.instance();
+			Lightmapper::MeshData md;
 
-			if (hdr) {
+			{
+				Dictionary d;
+				d["path"] = mf.node_path;
+				if (mf.subindex >= 0) {
+					d["subindex"] = mf.subindex;
+				}
+				md.userdata = d;
+			}
 
-				//just save a regular image
-				Vector<uint8_t> data;
-				int s = lm.light.size();
-				data.resize(lm.light.size() * 2);
-				{
+			{
 
-					uint8_t* w = data.ptrw();
-					const float* r = lm.light.ptr();
-					uint16_t *hfw = (uint16_t *)w.ptr();
-					for (int i = 0; i < s; i++) {
-						hfw[i] = Math::make_half_float(r[i]);
-					}
+				if (albedo->get_format() != Image::FORMAT_RGBA8) {
+					albedo->convert(Image::FORMAT_RGBA8);
+				}
+				if (orm->get_format() != Image::FORMAT_RGBA8) {
+					orm->convert(Image::FORMAT_RGBA8);
+				}
+				Vector<uint8_t> albedo_alpha = albedo->get_data();
+				Vector<uint8_t> orm_data = orm->get_data();
+
+				Vector<uint8_t> albedom;
+				uint32_t len = albedo_alpha.size();
+				albedom.resize(len);
+				const uint8_t *r_aa = albedo_alpha.ptr();
+				const uint8_t *r_orm = orm_data.ptr();
+				uint8_t *w_albedo = albedom.ptrw();
+
+				for (uint32_t i = 0; i < len; i += 4) {
+					w_albedo[i + 0] = uint8_t(CLAMP(float(r_aa[i + 0]) * (1.0 - float(r_orm[i + 2] / 255.0)), 0, 255));
+					w_albedo[i + 1] = uint8_t(CLAMP(float(r_aa[i + 1]) * (1.0 - float(r_orm[i + 2] / 255.0)), 0, 255));
+					w_albedo[i + 2] = uint8_t(CLAMP(float(r_aa[i + 2]) * (1.0 - float(r_orm[i + 2] / 255.0)), 0, 255));
+					w_albedo[i + 3] = 255;
 				}
 
-				image->create(lm.width, lm.height, false, Image::FORMAT_RGBH, data);
+				md.albedo_on_uv2.instance();
+				md.albedo_on_uv2->create(lightmap_size.width, lightmap_size.height, false, Image::FORMAT_RGBA8, albedom);
+			}
 
-			} else {
+			md.emission_on_uv2 = images[RS::BAKE_CHANNEL_EMISSION];
+			if (md.emission_on_uv2->get_format() != Image::FORMAT_RGBAH) {
+				md.emission_on_uv2->convert(Image::FORMAT_RGBAH);
+			}
 
-				//just save a regular image
-				Vector<uint8_t> data;
-				int s = lm.light.size();
-				data.resize(lm.light.size());
-				{
-
-					uint8_t* w = data.ptrw();
-					const float* r = lm.light.ptr();
-					for (int i = 0; i < s; i += 3) {
-						Color c(r[i + 0], r[i + 1], r[i + 2]);
-						c = c.to_srgb();
-						w[i + 0] = CLAMP(c.r * 255, 0, 255);
-						w[i + 1] = CLAMP(c.g * 255, 0, 255);
-						w[i + 2] = CLAMP(c.b * 255, 0, 255);
-					}
+			//get geometry
+
+			Basis normal_xform = mf.xform.basis.inverse().transposed();
+
+			for (int i = 0; i < mf.mesh->get_surface_count(); i++) {
+				if (mf.mesh->surface_get_primitive_type(i) != Mesh::PRIMITIVE_TRIANGLES) {
+					continue;
 				}
+				Array a = mf.mesh->surface_get_arrays(i);
 
-				image->create(lm.width, lm.height, false, Image::FORMAT_RGB8, data);
+				Vector<Vector3> vertices = a[Mesh::ARRAY_VERTEX];
+				const Vector3 *vr = vertices.ptr();
+				Vector<Vector2> uv = a[Mesh::ARRAY_TEX_UV2];
+				const Vector2 *uvr = nullptr;
+				Vector<Vector3> normals = a[Mesh::ARRAY_NORMAL];
+				const Vector3 *nr = nullptr;
+				Vector<int> index = a[Mesh::ARRAY_INDEX];
 
-				//This texture is saved to SRGB for two reasons:
-				// 1) first is so it looks better when doing the LINEAR->SRGB conversion (more accurate)
-				// 2) So it can be used in the GLES2 backend, which does not support linkear workflow
-			}
+				ERR_CONTINUE(uv.size() == 0);
+				ERR_CONTINUE(normals.size() == 0);
 
-			String image_path = save_path.plus_file(mesh_name);
-			Ref<Texture2D> texture;
+				uvr = uv.ptr();
+				nr = normals.ptr();
 
-			if (ResourceLoader::import) {
+				int facecount;
+				const int *ir = nullptr;
 
-				bool srgb = false;
-				if (false && hdr) {
-					//save hdr
+				if (index.size()) {
+
+					facecount = index.size() / 3;
+					ir = index.ptr();
 				} else {
-					image_path += ".png";
-					print_line("image path saving png: " + image_path);
-					image->save_png(image_path);
-					srgb = true;
+					facecount = vertices.size() / 3;
 				}
 
-				if (!FileAccess::exists(image_path + ".import")) {
-					Ref<ConfigFile> config;
-					config.instance();
-					config->set_value("remap", "importer", "texture");
-					config->set_value("remap", "type", "StreamTexture");
-					config->set_value("params", "compress/mode", 2);
-					config->set_value("params", "detect_3d", false);
-					config->set_value("params", "flags/repeat", false);
-					config->set_value("params", "flags/filter", true);
-					config->set_value("params", "flags/mipmaps", false);
-					config->set_value("params", "flags/srgb", srgb);
-
-					config->save(image_path + ".import");
-				}
+				for (int j = 0; j < facecount; j++) {
 
-				ResourceLoader::import(image_path);
-				texture = ResourceLoader::load(image_path); //if already loaded, it will be updated on refocus?
-			} else {
+					uint32_t vidx[3];
 
-				image_path += ".text";
-				Ref<ImageTexture> tex;
-				bool set_path = true;
-				if (ResourceCache::has(image_path)) {
-					tex = Ref<Resource>((Resource *)ResourceCache::get(image_path));
-					set_path = false;
-				}
+					if (ir) {
+						for (int k = 0; k < 3; k++) {
+							vidx[k] = ir[j * 3 + k];
+						}
+					} else {
+						for (int k = 0; k < 3; k++) {
+							vidx[k] = j * 3 + k;
+						}
+					}
 
-				if (!tex.is_valid()) {
-					tex.instance();
+					for (int k = 0; k < 3; k++) {
+						Vector3 v = mf.xform.xform(vr[vidx[k]]);
+						if (bounds == AABB()) {
+							bounds.position = v;
+						} else {
+							bounds.expand_to(v);
+						}
+						md.points.push_back(v);
+
+						md.uv2.push_back(uvr[vidx[k]]);
+						md.normal.push_back(normal_xform.xform(nr[vidx[k]]).normalized());
+					}
 				}
+			}
 
-				tex->create_from_image(image);
+			mesh_data.push_back(md);
+		}
+	}
 
-				err = ResourceSaver::save(image_path, tex, ResourceSaver::FLAG_CHANGE_PATH);
-				if (set_path) {
-					tex->set_path(image_path);
-				}
-				texture = tex;
+	/* STEP 2, CREATE PROBES */
+
+	if (p_bake_step) {
+		p_bake_step(0.3, TTR("Creating probes"), p_bake_userdata, true);
+	}
+
+	//bounds need to include the user probes
+	for (int i = 0; i < probes_found.size(); i++) {
+		bounds.expand_to(probes_found[i]);
+	}
+
+	bounds.grow_by(bounds.size.length() * 0.001);
+
+	if (gen_probes == GENERATE_PROBES_DISABLED) {
+		// generate 8 probes on bound endpoints
+		for (int i = 0; i < 8; i++) {
+			probes_found.push_back(bounds.get_endpoint(i));
+		}
+	} else {
+		// detect probes from geometry
+		static const int subdiv_values[6] = { 0, 4, 8, 16, 32 };
+		int subdiv = subdiv_values[gen_probes];
+
+		float subdiv_cell_size;
+		Vector3i bound_limit;
+		{
+			int longest_axis = bounds.get_longest_axis_index();
+			subdiv_cell_size = bounds.size[longest_axis] / subdiv;
+			int axis_n1 = (longest_axis + 1) % 3;
+			int axis_n2 = (longest_axis + 2) % 3;
+
+			bound_limit[longest_axis] = subdiv;
+			bound_limit[axis_n1] = int(Math::ceil(bounds.size[axis_n1] / subdiv_cell_size));
+			bound_limit[axis_n2] = int(Math::ceil(bounds.size[axis_n2] / subdiv_cell_size));
+			//compensate bounds
+			bounds.size[axis_n1] = bound_limit[axis_n1] * subdiv_cell_size;
+			bounds.size[axis_n2] = bound_limit[axis_n2] * subdiv_cell_size;
+		}
+
+		GenProbesOctree octree;
+		octree.size = subdiv;
+
+		for (int i = 0; i < mesh_data.size(); i++) {
+			if (p_bake_step) {
+				float p = (float)(i) / mesh_data.size();
+				p_bake_step(0.3 + p * 0.1, vformat(TTR("Creating probes from mesh %d/%d"), i, mesh_data.size()), p_bake_userdata, false);
 			}
-			if (err != OK) {
-				if (bake_end_function) {
-					bake_end_function();
-				}
-				ERR_FAIL_COND_V(err != OK, BAKE_ERROR_CANT_CREATE_IMAGE);
+
+			for (int j = 0; j < mesh_data[i].points.size(); j += 3) {
+				Vector3 points[3] = { mesh_data[i].points[j + 0] - bounds.position, mesh_data[i].points[j + 1] - bounds.position, mesh_data[i].points[j + 2] - bounds.position };
+				_plot_triangle_into_octree(&octree, subdiv_cell_size, points);
+			}
+		}
+
+		LocalVector<Vector3> new_probe_positions;
+		HashMap<Vector3i, bool, Vector3iHash> positions_used;
+		for (uint32_t i = 0; i < 8; i++) { //insert bounding endpoints
+			Vector3i pos;
+			if (i & 1) {
+				pos.x += bound_limit.x;
+			}
+			if (i & 2) {
+				pos.y += bound_limit.y;
+			}
+			if (i & 4) {
+				pos.z += bound_limit.z;
+			}
+
+			positions_used[pos] = true;
+			Vector3 real_pos = bounds.position + Vector3(pos) * subdiv_cell_size; //use same formula for numerical stability
+			new_probe_positions.push_back(real_pos);
+		}
+		//skip first level, since probes are always added at bounds endpoints anyway (code above this)
+		for (int i = 0; i < 8; i++) {
+
+			if (octree.children[i]) {
+				_gen_new_positions_from_octree(octree.children[i], subdiv_cell_size, probes_found, new_probe_positions, positions_used, bounds);
 			}
+		}
 
-			new_light_data->add_user(E->get().path, texture, E->get().instance_idx);
+		for (uint32_t i = 0; i < new_probe_positions.size(); i++) {
+			probes_found.push_back(new_probe_positions[i]);
 		}
 	}
 
-	AABB bounds = AABB(-extents, extents * 2);
-	new_light_data->set_cell_subdiv(capture_subdiv);
-	new_light_data->set_bounds(bounds);
-	new_light_data->set_octree(baker.create_capture_octree(capture_subdiv));
+	// Add everything to lightmapper
+	if (p_bake_step) {
+		p_bake_step(0.4, TTR("Preparing Lightmapper"), p_bake_userdata, true);
+	}
+
 	{
 
-		float bake_bound_size = bake_bounds.get_longest_axis_size();
-		Transform to_bounds;
-		to_bounds.basis.scale(Vector3(bake_bound_size, bake_bound_size, bake_bound_size));
-		to_bounds.origin = bounds.position;
+		for (int i = 0; i < mesh_data.size(); i++) {
+			lightmapper->add_mesh(mesh_data[i]);
+		}
+		for (int i = 0; i < lights_found.size(); i++) {
+			Light3D *light = lights_found[i].light;
+			Transform xf = lights_found[i].xform;
+
+			if (Object::cast_to<DirectionalLight3D>(light)) {
+				DirectionalLight3D *l = Object::cast_to<DirectionalLight3D>(light);
+				lightmapper->add_directional_light(light->get_bake_mode() == Light3D::BAKE_ALL, -xf.basis.get_axis(Vector3::AXIS_Z).normalized(), l->get_color(), l->get_param(Light3D::PARAM_ENERGY), l->get_param(Light3D::PARAM_SIZE));
+			} else if (Object::cast_to<OmniLight3D>(light)) {
+				OmniLight3D *l = Object::cast_to<OmniLight3D>(light);
+				lightmapper->add_omni_light(light->get_bake_mode() == Light3D::BAKE_ALL, xf.origin, l->get_color(), l->get_param(Light3D::PARAM_ENERGY), l->get_param(Light3D::PARAM_RANGE), l->get_param(Light3D::PARAM_ATTENUATION), l->get_param(Light3D::PARAM_SIZE));
+			} else if (Object::cast_to<SpotLight3D>(light)) {
+				SpotLight3D *l = Object::cast_to<SpotLight3D>(light);
+				lightmapper->add_spot_light(light->get_bake_mode() == Light3D::BAKE_ALL, xf.origin, -xf.basis.get_axis(Vector3::AXIS_Z).normalized(), l->get_color(), l->get_param(Light3D::PARAM_ENERGY), l->get_param(Light3D::PARAM_RANGE), l->get_param(Light3D::PARAM_ATTENUATION), l->get_param(Light3D::PARAM_SPOT_ANGLE), l->get_param(Light3D::PARAM_SPOT_ATTENUATION), l->get_param(Light3D::PARAM_SIZE));
+			}
+		}
+		for (int i = 0; i < probes_found.size(); i++) {
+			lightmapper->add_probe(probes_found[i]);
+		}
+	}
+
+	Ref<Image> environment_image;
+	Basis environment_transform;
+
+	// Add everything to lightmapper
+	if (environment_mode != ENVIRONMENT_MODE_DISABLED) {
+		if (p_bake_step) {
+			p_bake_step(4.1, TTR("Preparing Environment"), p_bake_userdata, true);
+		}
+
+		environment_transform = get_global_transform().basis;
 
-		Transform to_grid;
-		to_grid.basis.scale(Vector3(1 << (capture_subdiv - 1), 1 << (capture_subdiv - 1), 1 << (capture_subdiv - 1)));
+		switch (environment_mode) {
+			case ENVIRONMENT_MODE_DISABLED: {
+				//nothing
+			} break;
+			case ENVIRONMENT_MODE_SCENE: {
+				Ref<World3D> world = get_world_3d();
+				if (world.is_valid()) {
+					Ref<Environment> env = world->get_environment();
+					if (env.is_null()) {
+						env = world->get_fallback_environment();
+					}
+
+					if (env.is_valid()) {
+						environment_image = RS::get_singleton()->environment_bake_panorama(env->get_rid(), true, Size2i(128, 64));
+					}
+				}
+			} break;
+			case ENVIRONMENT_MODE_CUSTOM_SKY: {
+				if (environment_custom_sky.is_valid()) {
+					environment_image = RS::get_singleton()->sky_bake_panorama(environment_custom_sky->get_rid(), environment_custom_energy, true, Size2i(128, 64));
+				}
+
+			} break;
+			case ENVIRONMENT_MODE_CUSTOM_COLOR: {
+				environment_image.instance();
+				environment_image->create(128, 64, false, Image::FORMAT_RGBAF);
+				Color c = environment_custom_color;
+				c.r *= environment_custom_energy;
+				c.g *= environment_custom_energy;
+				c.b *= environment_custom_energy;
+				for (int i = 0; i < 128; i++) {
+					for (int j = 0; j < 64; j++) {
+						environment_image->set_pixel(i, j, c);
+					}
+				}
 
-		Transform to_cell_space = to_grid * to_bounds.affine_inverse();
-		new_light_data->set_cell_space_transform(to_cell_space);
+			} break;
+		}
 	}
 
-	if (bake_end_function) {
-		bake_end_function();
+	Lightmapper::BakeError bake_err = lightmapper->bake(Lightmapper::BakeQuality(bake_quality), use_denoiser, bounces, bias, max_texture_size, directional, Lightmapper::GenerateProbes(gen_probes), environment_image, environment_transform, _lightmap_bake_step_function, &bsud);
+
+	if (bake_err == Lightmapper::BAKE_ERROR_LIGHTMAP_CANT_PRE_BAKE_MESHES) {
+		return BAKE_ERROR_MESHES_INVALID;
 	}
 
-	//create the data for visual server
+	/* POSTBAKE: Save Textures */
 
-	if (p_create_visual_debug) {
-		MultiMeshInstance *mmi = memnew(MultiMeshInstance);
-		mmi->set_multimesh(baker.create_debug_multimesh(Voxelizer::DEBUG_LIGHT));
-		add_child(mmi);
-#ifdef TOOLS_ENABLED
-		if (get_tree()->get_edited_scene_root() == this) {
-			mmi->set_owner(this);
-		} else {
-			mmi->set_owner(get_owner());
+	Ref<TextureLayered> texture;
+	{
+
+		Vector<Ref<Image>> images;
+		for (int i = 0; i < lightmapper->get_bake_texture_count(); i++) {
+			images.push_back(lightmapper->get_bake_texture(i));
+		}
+		//we assume they are all the same, so lets create a large one for saving
+		Ref<Image> large_image;
+		large_image.instance();
+
+		large_image->create(images[0]->get_width(), images[0]->get_height() * images.size(), false, images[0]->get_format());
+
+		for (int i = 0; i < lightmapper->get_bake_texture_count(); i++) {
+			large_image->blit_rect(images[i], Rect2(0, 0, images[i]->get_width(), images[i]->get_height()), Point2(0, images[i]->get_height() * i));
+		}
+
+		String base_path = p_image_data_path.get_basename() + ".exr";
+
+		Ref<ConfigFile> config;
+
+		config.instance();
+		if (FileAccess::exists(base_path + ".import")) {
+
+			config->load(base_path + ".import");
+		}
+
+		config->set_value("remap", "importer", "2d_array_texture");
+		config->set_value("remap", "type", "StreamTexture2DArray");
+		if (!config->has_section_key("params", "compress/mode")) {
+			config->set_value("params", "compress/mode", 2); //user may want another compression, so leave it be
+		}
+		config->set_value("params", "compress/channel_pack", 1);
+		config->set_value("params", "mipmaps/generate", false);
+		config->set_value("params", "slices/horizontal", 1);
+		config->set_value("params", "slices/vertical", images.size());
+
+		config->save(base_path + ".import");
+
+		Error err = large_image->save_exr(base_path, false);
+		ERR_FAIL_COND_V(err, BAKE_ERROR_CANT_CREATE_IMAGE);
+		ResourceLoader::import(base_path);
+		Ref<Texture> t = ResourceLoader::load(base_path); //if already loaded, it will be updated on refocus?
+		ERR_FAIL_COND_V(t.is_null(), BAKE_ERROR_CANT_CREATE_IMAGE);
+		texture = t;
+	}
+
+	/* POSTBAKE: Save Light Data */
+
+	Ref<BakedLightmapData> data;
+	if (get_light_data().is_valid()) {
+		data = get_light_data();
+		set_light_data(Ref<BakedLightmapData>()); //clear
+		data->clear();
+	} else {
+		data.instance();
+	}
+
+	data->set_light_texture(texture);
+	data->set_uses_spherical_harmonics(directional);
+
+	for (int i = 0; i < lightmapper->get_bake_mesh_count(); i++) {
+		Dictionary d = lightmapper->get_bake_mesh_userdata(i);
+		NodePath np = d["path"];
+		int32_t subindex = -1;
+		if (d.has("subindex")) {
+			subindex = d["subindex"];
 		}
-#else
-		mmi->set_owner(get_owner());
+
+		Rect2 uv_scale = lightmapper->get_bake_mesh_uv_scale(i);
+		int slice_index = lightmapper->get_bake_mesh_texture_slice(i);
+		data->add_user(np, uv_scale, slice_index, subindex);
+	}
+
+	{
+		// create tetrahedrons
+		Vector<Vector3> points;
+		Vector<Color> sh;
+		points.resize(lightmapper->get_bake_probe_count());
+		sh.resize(lightmapper->get_bake_probe_count() * 9);
+		for (int i = 0; i < lightmapper->get_bake_probe_count(); i++) {
+			points.write[i] = lightmapper->get_bake_probe_point(i);
+			Vector<Color> colors = lightmapper->get_bake_probe_sh(i);
+			ERR_CONTINUE(colors.size() != 9);
+			for (int j = 0; j < 9; j++) {
+				sh.write[i * 9 + j] = colors[j];
+			}
+		}
+
+		//Obtain solved simplices
+
+		if (p_bake_step) {
+			p_bake_step(0.8, TTR("Generating Probe Volumes"), p_bake_userdata, true);
+		}
+		Vector<Delaunay3D::OutputSimplex> solved_simplices = Delaunay3D::tetrahedralize(points);
+
+		LocalVector<BSPSimplex> bsp_simplices;
+		LocalVector<Plane> bsp_planes;
+		LocalVector<int32_t> bsp_simplex_indices;
+		PackedInt32Array tetrahedrons;
+
+		for (int i = 0; i < solved_simplices.size(); i++) {
+
+			//Prepare a special representation of the simplex, which uses a BSP Tree
+			BSPSimplex bsp_simplex;
+			for (int j = 0; j < 4; j++) {
+				bsp_simplex.vertices[j] = solved_simplices[i].points[j];
+			}
+			for (int j = 0; j < 4; j++) {
+				static const int face_order[4][3] = {
+					{ 0, 1, 2 },
+					{ 0, 2, 3 },
+					{ 0, 1, 3 },
+					{ 1, 2, 3 }
+				};
+				Vector3 a = points[solved_simplices[i].points[face_order[j][0]]];
+				Vector3 b = points[solved_simplices[i].points[face_order[j][1]]];
+				Vector3 c = points[solved_simplices[i].points[face_order[j][2]]];
+
+				//store planes in an array, but ensure they are reused, to speed up processing
+
+				Plane p(a, b, c);
+				int plane_index = -1;
+				for (uint32_t k = 0; k < bsp_planes.size(); k++) {
+
+					if (bsp_planes[k].is_equal_approx_any_side(p)) {
+						plane_index = k;
+						break;
+					}
+				}
+
+				if (plane_index == -1) {
+					plane_index = bsp_planes.size();
+					bsp_planes.push_back(p);
+				}
+
+				bsp_simplex.planes[j] = plane_index;
+
+				//also fill simplex array
+				tetrahedrons.push_back(solved_simplices[i].points[j]);
+			}
+
+			bsp_simplex_indices.push_back(bsp_simplices.size());
+			bsp_simplices.push_back(bsp_simplex);
+		}
+
+//#define DEBUG_SIMPLICES_AS_OBJ_FILE
+#ifdef DEBUG_SIMPLICES_AS_OBJ_FILE
+		{
+			FileAccessRef f = FileAccess::open("res://bsp.obj", FileAccess::WRITE);
+			for (uint32_t i = 0; i < bsp_simplices.size(); i++) {
+				f->store_line("o Simplex" + itos(i));
+				for (int j = 0; j < 4; j++) {
+					f->store_line(vformat("v %f %f %f", points[bsp_simplices[i].vertices[j]].x, points[bsp_simplices[i].vertices[j]].y, points[bsp_simplices[i].vertices[j]].z));
+				}
+				static const int face_order[4][3] = {
+					{ 1, 2, 3 },
+					{ 1, 3, 4 },
+					{ 1, 2, 4 },
+					{ 2, 3, 4 }
+				};
+
+				for (int j = 0; j < 4; j++) {
+					f->store_line(vformat("f %d %d %d", 4 * i + face_order[j][0], 4 * i + face_order[j][1], 4 * i + face_order[j][2]));
+				}
+			}
+			f->close();
+		}
+#endif
+
+		LocalVector<BSPNode> bsp_nodes;
+		LocalVector<int32_t> planes_tested;
+		planes_tested.resize(bsp_planes.size());
+		for (uint32_t i = 0; i < planes_tested.size(); i++) {
+			planes_tested[i] = 0x7FFFFFFF;
+		}
+
+		if (p_bake_step) {
+			p_bake_step(0.9, TTR("Generating Probe Acceleration Structures"), p_bake_userdata, true);
+		}
+
+		_compute_bsp_tree(points, bsp_planes, planes_tested, bsp_simplices, bsp_simplex_indices, bsp_nodes);
+
+		PackedInt32Array bsp_array;
+		bsp_array.resize(bsp_nodes.size() * 6); // six 32 bits values used for each BSP node
+		{
+			float *fptr = (float *)bsp_array.ptrw();
+			int32_t *iptr = (int32_t *)bsp_array.ptrw();
+			for (uint32_t i = 0; i < bsp_nodes.size(); i++) {
+				fptr[i * 6 + 0] = bsp_nodes[i].plane.normal.x;
+				fptr[i * 6 + 1] = bsp_nodes[i].plane.normal.y;
+				fptr[i * 6 + 2] = bsp_nodes[i].plane.normal.z;
+				fptr[i * 6 + 3] = bsp_nodes[i].plane.d;
+				iptr[i * 6 + 4] = bsp_nodes[i].over;
+				iptr[i * 6 + 5] = bsp_nodes[i].under;
+			}
+//#define DEBUG_BSP_TREE
+#ifdef DEBUG_BSP_TREE
+			FileAccessRef f = FileAccess::open("res://bsp.txt", FileAccess::WRITE);
+			for (uint32_t i = 0; i < bsp_nodes.size(); i++) {
+				f->store_line(itos(i) + " - plane: " + bsp_nodes[i].plane + " over: " + itos(bsp_nodes[i].over) + " under: " + itos(bsp_nodes[i].under));
+			}
 #endif
+		}
+
+		/* Obtain the colors from the images, they will be re-created as cubemaps on the server, depending on the driver */
+
+		data->set_capture_data(bounds, interior, points, sh, tetrahedrons, bsp_array);
+		/* Compute a BSP tree of the simplices, so it's easy to find the exact one */
+	}
+
+	Error err = ResourceSaver::save(p_image_data_path, data);
+	data->set_path(p_image_data_path);
+
+	if (err != OK) {
+		return BAKE_ERROR_CANT_CREATE_IMAGE;
 	}
 
-	set_light_data(new_light_data);
+	set_light_data(data);
 
 	return BAKE_ERROR_OK;
 }
 
 void BakedLightmap::_notification(int p_what) {
-	if (p_what == NOTIFICATION_READY) {
+	if (p_what == NOTIFICATION_POST_ENTER_TREE) {
 
 		if (light_data.is_valid()) {
 			_assign_lightmaps();
 		}
-		request_ready(); //will need ready again if re-enters tree
 	}
 
 	if (p_what == NOTIFICATION_EXIT_TREE) {
@@ -667,20 +1236,18 @@ void BakedLightmap::_assign_lightmaps() {
 	ERR_FAIL_COND(!light_data.is_valid());
 
 	for (int i = 0; i < light_data->get_user_count(); i++) {
-		Ref<Texture2D> lightmap = light_data->get_user_lightmap(i);
-		ERR_CONTINUE(!lightmap.is_valid());
 
 		Node *node = get_node(light_data->get_user_path(i));
-		int instance_idx = light_data->get_user_instance(i);
+		int instance_idx = light_data->get_user_sub_instance(i);
 		if (instance_idx >= 0) {
 			RID instance = node->call("get_bake_mesh_instance", instance_idx);
 			if (instance.is_valid()) {
-				RS::get_singleton()->instance_set_use_lightmap(instance, get_instance(), lightmap->get_rid());
+				RS::get_singleton()->instance_geometry_set_lightmap(instance, get_instance(), light_data->get_user_lightmap_uv_scale(i), light_data->get_user_lightmap_slice_index(i));
 			}
 		} else {
-			VisualInstance *vi = Object::cast_to<VisualInstance>(node);
+			VisualInstance3D *vi = Object::cast_to<VisualInstance3D>(node);
 			ERR_CONTINUE(!vi);
-			RS::get_singleton()->instance_set_use_lightmap(vi->get_instance(), get_instance(), lightmap->get_rid());
+			RS::get_singleton()->instance_geometry_set_lightmap(vi->get_instance(), get_instance(), light_data->get_user_lightmap_uv_scale(i), light_data->get_user_lightmap_slice_index(i));
 		}
 	}
 }
@@ -689,16 +1256,16 @@ void BakedLightmap::_clear_lightmaps() {
 	ERR_FAIL_COND(!light_data.is_valid());
 	for (int i = 0; i < light_data->get_user_count(); i++) {
 		Node *node = get_node(light_data->get_user_path(i));
-		int instance_idx = light_data->get_user_instance(i);
+		int instance_idx = light_data->get_user_sub_instance(i);
 		if (instance_idx >= 0) {
 			RID instance = node->call("get_bake_mesh_instance", instance_idx);
 			if (instance.is_valid()) {
-				RS::get_singleton()->instance_set_use_lightmap(instance, get_instance(), RID());
+				RS::get_singleton()->instance_geometry_set_lightmap(instance, RID(), Rect2(), 0);
 			}
 		} else {
-			VisualInstance *vi = Object::cast_to<VisualInstance>(node);
+			VisualInstance3D *vi = Object::cast_to<VisualInstance3D>(node);
 			ERR_CONTINUE(!vi);
-			RS::get_singleton()->instance_set_use_lightmap(vi->get_instance(), get_instance(), RID());
+			RS::get_singleton()->instance_geometry_set_lightmap(vi->get_instance(), RID(), Rect2(), 0);
 		}
 	}
 }
@@ -719,6 +1286,8 @@ void BakedLightmap::set_light_data(const Ref<BakedLightmapData> &p_data) {
 			_assign_lightmaps();
 		}
 	}
+
+	update_gizmo();
 }
 
 Ref<BakedLightmapData> BakedLightmap::get_light_data() const {
@@ -726,57 +1295,122 @@ Ref<BakedLightmapData> BakedLightmap::get_light_data() const {
 	return light_data;
 }
 
-void BakedLightmap::_debug_bake() {
-	bake(get_parent(), true);
+void BakedLightmap::set_bake_quality(BakeQuality p_quality) {
+	bake_quality = p_quality;
 }
 
-void BakedLightmap::set_propagation(float p_propagation) {
-	propagation = p_propagation;
+BakedLightmap::BakeQuality BakedLightmap::get_bake_quality() const {
+	return bake_quality;
 }
 
-float BakedLightmap::get_propagation() const {
+AABB BakedLightmap::get_aabb() const {
+	return AABB();
+}
+Vector<Face3> BakedLightmap::get_faces(uint32_t p_usage_flags) const {
+	return Vector<Face3>();
+}
+
+void BakedLightmap::set_use_denoiser(bool p_enable) {
 
-	return propagation;
+	use_denoiser = p_enable;
 }
 
-void BakedLightmap::set_energy(float p_energy) {
-	energy = p_energy;
+bool BakedLightmap::is_using_denoiser() const {
+
+	return use_denoiser;
 }
 
-float BakedLightmap::get_energy() const {
+void BakedLightmap::set_directional(bool p_enable) {
+	directional = p_enable;
+}
 
-	return energy;
+bool BakedLightmap::is_directional() const {
+	return directional;
 }
 
-void BakedLightmap::set_bake_quality(BakeQuality p_quality) {
-	bake_quality = p_quality;
+void BakedLightmap::set_interior(bool p_enable) {
+	interior = p_enable;
+}
+bool BakedLightmap::is_interior() const {
+	return interior;
 }
 
-BakedLightmap::BakeQuality BakedLightmap::get_bake_quality() const {
-	return bake_quality;
+void BakedLightmap::set_environment_mode(EnvironmentMode p_mode) {
+	environment_mode = p_mode;
+	_change_notify();
 }
 
-void BakedLightmap::set_bake_mode(BakeMode p_mode) {
-	bake_mode = p_mode;
+BakedLightmap::EnvironmentMode BakedLightmap::get_environment_mode() const {
+	return environment_mode;
 }
 
-BakedLightmap::BakeMode BakedLightmap::get_bake_mode() const {
-	return bake_mode;
+void BakedLightmap::set_environment_custom_sky(const Ref<Sky> &p_sky) {
+	environment_custom_sky = p_sky;
 }
 
-void BakedLightmap::set_image_path(const String &p_path) {
-	image_path = p_path;
+Ref<Sky> BakedLightmap::get_environment_custom_sky() const {
+	return environment_custom_sky;
 }
 
-String BakedLightmap::get_image_path() const {
-	return image_path;
+void BakedLightmap::set_environment_custom_color(const Color &p_color) {
+	environment_custom_color = p_color;
+}
+Color BakedLightmap::get_environment_custom_color() const {
+	return environment_custom_color;
 }
 
-AABB BakedLightmap::get_aabb() const {
-	return AABB(-extents, extents * 2);
+void BakedLightmap::set_environment_custom_energy(float p_energy) {
+	environment_custom_energy = p_energy;
 }
-Vector<Face3> BakedLightmap::get_faces(uint32_t p_usage_flags) const {
-	return Vector<Face3>();
+float BakedLightmap::get_environment_custom_energy() const {
+	return environment_custom_energy;
+}
+
+void BakedLightmap::set_bounces(int p_bounces) {
+	ERR_FAIL_COND(p_bounces < 0 || p_bounces > 16);
+	bounces = p_bounces;
+}
+
+int BakedLightmap::get_bounces() const {
+	return bounces;
+}
+
+void BakedLightmap::set_bias(float p_bias) {
+	ERR_FAIL_COND(p_bias < 0.00001);
+	bias = p_bias;
+}
+
+float BakedLightmap::get_bias() const {
+	return bias;
+}
+
+void BakedLightmap::set_max_texture_size(int p_size) {
+	ERR_FAIL_COND(p_size < 2048);
+	max_texture_size = p_size;
+}
+
+int BakedLightmap::get_max_texture_size() const {
+	return max_texture_size;
+}
+
+void BakedLightmap::set_generate_probes(GenerateProbes p_generate_probes) {
+	gen_probes = p_generate_probes;
+}
+
+BakedLightmap::GenerateProbes BakedLightmap::get_generate_probes() const {
+	return gen_probes;
+}
+
+void BakedLightmap::_validate_property(PropertyInfo &property) const {
+	if (property.name == "environment_custom_sky" && environment_mode != ENVIRONMENT_MODE_CUSTOM_SKY) {
+		property.usage = 0;
+	}
+	if (property.name == "environment_custom_color" && environment_mode != ENVIRONMENT_MODE_CUSTOM_COLOR) {
+		property.usage = 0;
+	}
+	if (property.name == "environment_custom_energy" && environment_mode != ENVIRONMENT_MODE_CUSTOM_COLOR && environment_mode != ENVIRONMENT_MODE_CUSTOM_SKY) {
+		property.usage = 0;
+	}
 }
 
 void BakedLightmap::_bind_methods() {
@@ -784,81 +1418,91 @@ void BakedLightmap::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("set_light_data", "data"), &BakedLightmap::set_light_data);
 	ClassDB::bind_method(D_METHOD("get_light_data"), &BakedLightmap::get_light_data);
 
-	ClassDB::bind_method(D_METHOD("set_bake_cell_size", "bake_cell_size"), &BakedLightmap::set_bake_cell_size);
-	ClassDB::bind_method(D_METHOD("get_bake_cell_size"), &BakedLightmap::get_bake_cell_size);
-
-	ClassDB::bind_method(D_METHOD("set_capture_cell_size", "capture_cell_size"), &BakedLightmap::set_capture_cell_size);
-	ClassDB::bind_method(D_METHOD("get_capture_cell_size"), &BakedLightmap::get_capture_cell_size);
-
 	ClassDB::bind_method(D_METHOD("set_bake_quality", "bake_quality"), &BakedLightmap::set_bake_quality);
 	ClassDB::bind_method(D_METHOD("get_bake_quality"), &BakedLightmap::get_bake_quality);
 
-	ClassDB::bind_method(D_METHOD("set_bake_mode", "bake_mode"), &BakedLightmap::set_bake_mode);
-	ClassDB::bind_method(D_METHOD("get_bake_mode"), &BakedLightmap::get_bake_mode);
+	ClassDB::bind_method(D_METHOD("set_bounces", "bounces"), &BakedLightmap::set_bounces);
+	ClassDB::bind_method(D_METHOD("get_bounces"), &BakedLightmap::get_bounces);
+
+	ClassDB::bind_method(D_METHOD("set_generate_probes", "subdivision"), &BakedLightmap::set_generate_probes);
+	ClassDB::bind_method(D_METHOD("get_generate_probes"), &BakedLightmap::get_generate_probes);
 
-	ClassDB::bind_method(D_METHOD("set_extents", "extents"), &BakedLightmap::set_extents);
-	ClassDB::bind_method(D_METHOD("get_extents"), &BakedLightmap::get_extents);
+	ClassDB::bind_method(D_METHOD("set_bias", "bias"), &BakedLightmap::set_bias);
+	ClassDB::bind_method(D_METHOD("get_bias"), &BakedLightmap::get_bias);
 
-	ClassDB::bind_method(D_METHOD("set_bake_default_texels_per_unit", "texels"), &BakedLightmap::set_bake_default_texels_per_unit);
-	ClassDB::bind_method(D_METHOD("get_bake_default_texels_per_unit"), &BakedLightmap::get_bake_default_texels_per_unit);
+	ClassDB::bind_method(D_METHOD("set_environment_mode", "mode"), &BakedLightmap::set_environment_mode);
+	ClassDB::bind_method(D_METHOD("get_environment_mode"), &BakedLightmap::get_environment_mode);
 
-	ClassDB::bind_method(D_METHOD("set_propagation", "propagation"), &BakedLightmap::set_propagation);
-	ClassDB::bind_method(D_METHOD("get_propagation"), &BakedLightmap::get_propagation);
+	ClassDB::bind_method(D_METHOD("set_environment_custom_sky", "sky"), &BakedLightmap::set_environment_custom_sky);
+	ClassDB::bind_method(D_METHOD("get_environment_custom_sky"), &BakedLightmap::get_environment_custom_sky);
 
-	ClassDB::bind_method(D_METHOD("set_energy", "energy"), &BakedLightmap::set_energy);
-	ClassDB::bind_method(D_METHOD("get_energy"), &BakedLightmap::get_energy);
+	ClassDB::bind_method(D_METHOD("set_environment_custom_color", "color"), &BakedLightmap::set_environment_custom_color);
+	ClassDB::bind_method(D_METHOD("get_environment_custom_color"), &BakedLightmap::get_environment_custom_color);
 
-	ClassDB::bind_method(D_METHOD("set_hdr", "hdr"), &BakedLightmap::set_hdr);
-	ClassDB::bind_method(D_METHOD("is_hdr"), &BakedLightmap::is_hdr);
+	ClassDB::bind_method(D_METHOD("set_environment_custom_energy", "energy"), &BakedLightmap::set_environment_custom_energy);
+	ClassDB::bind_method(D_METHOD("get_environment_custom_energy"), &BakedLightmap::get_environment_custom_energy);
 
-	ClassDB::bind_method(D_METHOD("set_image_path", "image_path"), &BakedLightmap::set_image_path);
-	ClassDB::bind_method(D_METHOD("get_image_path"), &BakedLightmap::get_image_path);
+	ClassDB::bind_method(D_METHOD("set_max_texture_size", "max_texture_size"), &BakedLightmap::set_max_texture_size);
+	ClassDB::bind_method(D_METHOD("get_max_texture_size"), &BakedLightmap::get_max_texture_size);
 
-	ClassDB::bind_method(D_METHOD("bake", "from_node", "create_visual_debug"), &BakedLightmap::bake, DEFVAL(Variant()), DEFVAL(false));
-	ClassDB::bind_method(D_METHOD("debug_bake"), &BakedLightmap::_debug_bake);
-	ClassDB::set_method_flags(get_class_static(), _scs_create("debug_bake"), METHOD_FLAGS_DEFAULT | METHOD_FLAG_EDITOR);
+	ClassDB::bind_method(D_METHOD("set_use_denoiser", "use_denoiser"), &BakedLightmap::set_use_denoiser);
+	ClassDB::bind_method(D_METHOD("is_using_denoiser"), &BakedLightmap::is_using_denoiser);
 
-	ADD_GROUP("Bake", "bake_");
-	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "bake_cell_size", PROPERTY_HINT_RANGE, "0.01,64,0.01"), "set_bake_cell_size", "get_bake_cell_size");
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "bake_quality", PROPERTY_HINT_ENUM, "Low,Medium,High"), "set_bake_quality", "get_bake_quality");
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "bake_mode", PROPERTY_HINT_ENUM, "ConeTrace,RayTrace"), "set_bake_mode", "get_bake_mode");
-	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "bake_propagation", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_propagation", "get_propagation");
-	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "bake_energy", PROPERTY_HINT_RANGE, "0,32,0.01"), "set_energy", "get_energy");
-	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "bake_hdr"), "set_hdr", "is_hdr");
-	ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "bake_extents"), "set_extents", "get_extents");
-	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "bake_default_texels_per_unit"), "set_bake_default_texels_per_unit", "get_bake_default_texels_per_unit");
-	ADD_GROUP("Capture", "capture_");
-	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "capture_cell_size", PROPERTY_HINT_RANGE, "0.01,64,0.01"), "set_capture_cell_size", "get_capture_cell_size");
+	ClassDB::bind_method(D_METHOD("set_interior", "enable"), &BakedLightmap::set_interior);
+	ClassDB::bind_method(D_METHOD("is_interior"), &BakedLightmap::is_interior);
+
+	ClassDB::bind_method(D_METHOD("set_directional", "directional"), &BakedLightmap::set_directional);
+	ClassDB::bind_method(D_METHOD("is_directional"), &BakedLightmap::is_directional);
+
+	//	ClassDB::bind_method(D_METHOD("bake", "from_node"), &BakedLightmap::bake, DEFVAL(Variant()));
+
+	ADD_GROUP("Tweaks", "");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "quality", PROPERTY_HINT_ENUM, "Low,Medium,High,Ultra"), "set_bake_quality", "get_bake_quality");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "bounces", PROPERTY_HINT_RANGE, "0,16,1"), "set_bounces", "get_bounces");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "directional"), "set_directional", "is_directional");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "interior"), "set_interior", "is_interior");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "use_denoiser"), "set_use_denoiser", "is_using_denoiser");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "bias", PROPERTY_HINT_RANGE, "0.00001,0.1,0.00001,or_greater"), "set_bias", "get_bias");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "max_texture_size"), "set_max_texture_size", "get_max_texture_size");
+	ADD_GROUP("Environment", "environment_");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "environment_mode", PROPERTY_HINT_ENUM, "Disabled,Scene,Custom Sky,Custom Color"), "set_environment_mode", "get_environment_mode");
+	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "environment_custom_sky", PROPERTY_HINT_RESOURCE_TYPE, "Sky"), "set_environment_custom_sky", "get_environment_custom_sky");
+	ADD_PROPERTY(PropertyInfo(Variant::COLOR, "environment_custom_color", PROPERTY_HINT_COLOR_NO_ALPHA), "set_environment_custom_color", "get_environment_custom_color");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "environment_custom_energy", PROPERTY_HINT_RANGE, "0,64,0.01"), "set_environment_custom_energy", "get_environment_custom_energy");
+	ADD_GROUP("Gen Probes", "generate_probes_");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "generate_probes_subdiv", PROPERTY_HINT_ENUM, "Disabled,4,8,16,32"), "set_generate_probes", "get_generate_probes");
 	ADD_GROUP("Data", "");
-	ADD_PROPERTY(PropertyInfo(Variant::STRING, "image_path", PROPERTY_HINT_DIR), "set_image_path", "get_image_path");
 	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "light_data", PROPERTY_HINT_RESOURCE_TYPE, "BakedLightmapData"), "set_light_data", "get_light_data");
 
 	BIND_ENUM_CONSTANT(BAKE_QUALITY_LOW);
 	BIND_ENUM_CONSTANT(BAKE_QUALITY_MEDIUM);
 	BIND_ENUM_CONSTANT(BAKE_QUALITY_HIGH);
-	BIND_ENUM_CONSTANT(BAKE_MODE_CONE_TRACE);
-	BIND_ENUM_CONSTANT(BAKE_MODE_RAY_TRACE);
 
 	BIND_ENUM_CONSTANT(BAKE_ERROR_OK);
 	BIND_ENUM_CONSTANT(BAKE_ERROR_NO_SAVE_PATH);
 	BIND_ENUM_CONSTANT(BAKE_ERROR_NO_MESHES);
 	BIND_ENUM_CONSTANT(BAKE_ERROR_CANT_CREATE_IMAGE);
 	BIND_ENUM_CONSTANT(BAKE_ERROR_USER_ABORTED);
+
+	BIND_ENUM_CONSTANT(ENVIRONMENT_MODE_DISABLED);
+	BIND_ENUM_CONSTANT(ENVIRONMENT_MODE_SCENE);
+	BIND_ENUM_CONSTANT(ENVIRONMENT_MODE_CUSTOM_SKY);
+	BIND_ENUM_CONSTANT(ENVIRONMENT_MODE_CUSTOM_COLOR);
 }
 
 BakedLightmap::BakedLightmap() {
 
-	extents = Vector3(10, 10, 10);
-	bake_default_texels_per_unit = 20;
-	bake_cell_size = 0.25;
-	capture_cell_size = 0.5;
+	environment_mode = ENVIRONMENT_MODE_DISABLED;
+	environment_custom_color = Color(0.2, 0.7, 1.0);
+	environment_custom_energy = 1.0;
 
 	bake_quality = BAKE_QUALITY_MEDIUM;
-	bake_mode = BAKE_MODE_CONE_TRACE;
-	energy = 1;
-	propagation = 1;
-	hdr = false;
-	image_path = ".";
-	set_disable_scale(true);
+	interior = false;
+	directional = false;
+
+	gen_probes = GENERATE_PROBES_DISABLED;
+	use_denoiser = true;
+	bounces = 1;
+	bias = 0.0005;
+	max_texture_size = 16384;
 }
-#endif
diff --git a/scene/3d/baked_lightmap.h b/scene/3d/baked_lightmap.h
index bc9e3f55ea..020d5fe1e0 100644
--- a/scene/3d/baked_lightmap.h
+++ b/scene/3d/baked_lightmap.h
@@ -28,189 +28,257 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
 
-#if 0
 #ifndef BAKED_INDIRECT_LIGHT_H
 #define BAKED_INDIRECT_LIGHT_H
 
-#include "multimesh_instance.h"
-#include "scene/3d/light.h"
-#include "scene/3d/visual_instance.h"
+#include "core/local_vector.h"
+#include "scene/3d/light_3d.h"
+#include "scene/3d/lightmapper.h"
+#include "scene/3d/mesh_instance_3d.h"
+#include "scene/3d/multimesh_instance_3d.h"
+#include "scene/3d/visual_instance_3d.h"
+#include "scene/resources/sky.h"
 
 class BakedLightmapData : public Resource {
 	GDCLASS(BakedLightmapData, Resource);
+	RES_BASE_EXTENSION("lmbake")
 
-	RID baked_light;
+	Ref<TextureLayered> light_texture;
+
+	bool uses_spherical_harmonics = false;
+	bool interior = false;
+
+	RID lightmap;
 	AABB bounds;
-	float energy;
-	int cell_subdiv;
-	Transform cell_space_xform;
 
 	struct User {
 
 		NodePath path;
-		Ref<Texture2D> lightmap;
-		int instance_index;
+		int32_t sub_instance;
+		Rect2 uv_scale;
+		int slice_index;
 	};
 
 	Vector<User> users;
 
 	void _set_user_data(const Array &p_data);
 	Array _get_user_data() const;
+	void _set_probe_data(const Dictionary &p_data);
+	Dictionary _get_probe_data() const;
 
 protected:
 	static void _bind_methods();
 
 public:
-	void set_bounds(const AABB &p_bounds);
-	AABB get_bounds() const;
+	void add_user(const NodePath &p_path, const Rect2 &p_uv_scale, int p_slice_index, int32_t p_sub_instance = -1);
+	int get_user_count() const;
+	NodePath get_user_path(int p_user) const;
+	int32_t get_user_sub_instance(int p_user) const;
+	Rect2 get_user_lightmap_uv_scale(int p_user) const;
+	int get_user_lightmap_slice_index(int p_user) const;
+	void clear_users();
 
-	void set_octree(const Vector<uint8_t> &p_octree);
-	Vector<uint8_t> get_octree() const;
+	void set_light_texture(const Ref<TextureLayered> &p_light_texture);
+	Ref<TextureLayered> get_light_texture() const;
 
-	void set_cell_space_transform(const Transform &p_xform);
-	Transform get_cell_space_transform() const;
+	void set_uses_spherical_harmonics(bool p_enable);
+	bool is_using_spherical_harmonics() const;
 
-	void set_cell_subdiv(int p_cell_subdiv);
-	int get_cell_subdiv() const;
+	bool is_interior() const;
 
-	void set_energy(float p_energy);
-	float get_energy() const;
+	void set_capture_data(const AABB &p_bounds, bool p_interior, const PackedVector3Array &p_points, const PackedColorArray &p_point_sh, const PackedInt32Array &p_tetrahedra, const PackedInt32Array &p_bsp_tree);
+	PackedVector3Array get_capture_points() const;
+	PackedColorArray get_capture_sh() const;
+	PackedInt32Array get_capture_tetrahedra() const;
+	PackedInt32Array get_capture_bsp_tree() const;
+	AABB get_capture_bounds() const;
 
-	void add_user(const NodePath &p_path, const Ref<Texture2D> &p_lightmap, int p_instance = -1);
-	int get_user_count() const;
-	NodePath get_user_path(int p_user) const;
-	Ref<Texture2D> get_user_lightmap(int p_user) const;
-	int get_user_instance(int p_user) const;
-	void clear_users();
+	void clear();
 
 	virtual RID get_rid() const;
 	BakedLightmapData();
 	~BakedLightmapData();
 };
 
-class BakedLightmap : public VisualInstance {
-	GDCLASS(BakedLightmap, VisualInstance);
+class BakedLightmap : public VisualInstance3D {
+	GDCLASS(BakedLightmap, VisualInstance3D);
 
 public:
 	enum BakeQuality {
 		BAKE_QUALITY_LOW,
 		BAKE_QUALITY_MEDIUM,
-		BAKE_QUALITY_HIGH
+		BAKE_QUALITY_HIGH,
+		BAKE_QUALITY_ULTRA,
 	};
-
-	enum BakeMode {
-		BAKE_MODE_CONE_TRACE,
-		BAKE_MODE_RAY_TRACE,
+	enum GenerateProbes {
+		GENERATE_PROBES_DISABLED,
+		GENERATE_PROBES_SUBDIV_4,
+		GENERATE_PROBES_SUBDIV_8,
+		GENERATE_PROBES_SUBDIV_16,
+		GENERATE_PROBES_SUBDIV_32,
 	};
 
 	enum BakeError {
 		BAKE_ERROR_OK,
+		BAKE_ERROR_NO_LIGHTMAPPER,
 		BAKE_ERROR_NO_SAVE_PATH,
 		BAKE_ERROR_NO_MESHES,
+		BAKE_ERROR_MESHES_INVALID,
 		BAKE_ERROR_CANT_CREATE_IMAGE,
 		BAKE_ERROR_USER_ABORTED
 
 	};
 
-	typedef void (*BakeBeginFunc)(int);
-	typedef bool (*BakeStepFunc)(int, const String &);
-	typedef void (*BakeEndFunc)();
+	enum EnvironmentMode {
+		ENVIRONMENT_MODE_DISABLED,
+		ENVIRONMENT_MODE_SCENE,
+		ENVIRONMENT_MODE_CUSTOM_SKY,
+		ENVIRONMENT_MODE_CUSTOM_COLOR,
+	};
 
 private:
-	float bake_cell_size;
-	float capture_cell_size;
-	Vector3 extents;
-	float bake_default_texels_per_unit;
-	float propagation;
-	float energy;
 	BakeQuality bake_quality;
-	BakeMode bake_mode;
-	bool hdr;
-	String image_path;
+	bool use_denoiser;
+	int bounces;
+	float bias;
+	int max_texture_size;
+	bool interior;
+	EnvironmentMode environment_mode;
+	Ref<Sky> environment_custom_sky;
+	Color environment_custom_color;
+	float environment_custom_energy;
+	bool directional;
+	GenerateProbes gen_probes;
 
 	Ref<BakedLightmapData> light_data;
 
-	struct PlotMesh {
-		Ref<Material> override_material;
-		Vector<Ref<Material> > instance_materials;
-		Ref<Mesh> mesh;
-		Transform local_xform;
-		NodePath path;
-		int instance_idx;
+	struct LightsFound {
+		Transform xform;
+		Light3D *light;
 	};
 
-	struct PlotLight {
-		Light *light;
-		Transform local_xform;
+	struct MeshesFound {
+		Transform xform;
+		NodePath node_path;
+		int32_t subindex;
+		Ref<Mesh> mesh;
+		int32_t lightmap_scale;
+		Vector<Ref<Material>> overrides;
 	};
 
-	void _find_meshes_and_lights(Node *p_at_node, List<PlotMesh> &plot_meshes, List<PlotLight> &plot_lights);
-
-	void _debug_bake();
+	void _find_meshes_and_lights(Node *p_at_node, Vector<MeshesFound> &meshes, Vector<LightsFound> &lights, Vector<Vector3> &probes);
 
 	void _assign_lightmaps();
 	void _clear_lightmaps();
 
-	static bool _bake_time(void *ud, float p_secs, float p_progress);
-
 	struct BakeTimeData {
 		String text;
 		int pass;
 		uint64_t last_step;
 	};
 
+	struct BSPSimplex {
+		int vertices[4];
+		int planes[4];
+	};
+
+	struct BSPNode {
+		static const int32_t EMPTY_LEAF = INT32_MIN;
+		Plane plane;
+		int32_t over = EMPTY_LEAF, under = EMPTY_LEAF;
+	};
+
+	int _bsp_get_simplex_side(const Vector<Vector3> &p_points, const LocalVector<BSPSimplex> &p_simplices, const Plane &p_plane, uint32_t p_simplex) const;
+	int32_t _compute_bsp_tree(const Vector<Vector3> &p_points, const LocalVector<Plane> &p_planes, LocalVector<int32_t> &planes_tested, const LocalVector<BSPSimplex> &p_simplices, const LocalVector<int32_t> &p_simplex_indices, LocalVector<BSPNode> &bsp_nodes);
+
+	struct BakeStepUD {
+		Lightmapper::BakeStepFunc func;
+		void *ud;
+		float from_percent;
+		float to_percent;
+	};
+
+	static bool _lightmap_bake_step_function(float p_completion, const String &p_text, void *ud, bool p_refresh);
+
+	struct GenProbesOctree {
+		Vector3i offset;
+		uint32_t size;
+		GenProbesOctree *children[8] = { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr };
+		~GenProbesOctree() {
+			for (int i = 0; i < 8; i++) {
+				if (children[i] != nullptr) {
+					memdelete(children[i]);
+				}
+			}
+		}
+	};
+
+	struct Vector3iHash {
+		_FORCE_INLINE_ static uint32_t hash(const Vector3i &p_vtx) {
+			uint32_t h = hash_djb2_one_32(p_vtx.x);
+			h = hash_djb2_one_32(p_vtx.y, h);
+			return hash_djb2_one_32(p_vtx.z, h);
+		}
+	};
+
+	void _plot_triangle_into_octree(GenProbesOctree *p_cell, float p_cell_size, const Vector3 *p_triangle);
+	void _gen_new_positions_from_octree(const GenProbesOctree *p_cell, float p_cell_size, const Vector<Vector3> &probe_positions, LocalVector<Vector3> &new_probe_positions, HashMap<Vector3i, bool, Vector3iHash> &positions_used, const AABB &p_bounds);
+
 protected:
+	void _validate_property(PropertyInfo &property) const;
 	static void _bind_methods();
 	void _notification(int p_what);
 
 public:
-	static BakeBeginFunc bake_begin_function;
-	static BakeStepFunc bake_step_function;
-	static BakeEndFunc bake_end_function;
-
 	void set_light_data(const Ref<BakedLightmapData> &p_data);
 	Ref<BakedLightmapData> get_light_data() const;
 
-	void set_bake_cell_size(float p_cell_size);
-	float get_bake_cell_size() const;
+	void set_bake_quality(BakeQuality p_quality);
+	BakeQuality get_bake_quality() const;
+
+	void set_use_denoiser(bool p_enable);
+	bool is_using_denoiser() const;
 
-	void set_capture_cell_size(float p_cell_size);
-	float get_capture_cell_size() const;
+	void set_directional(bool p_enable);
+	bool is_directional() const;
 
-	void set_extents(const Vector3 &p_extents);
-	Vector3 get_extents() const;
+	void set_interior(bool p_interior);
+	bool is_interior() const;
 
-	void set_bake_default_texels_per_unit(const float &p_bake_texels_per_unit);
-	float get_bake_default_texels_per_unit() const;
+	void set_environment_mode(EnvironmentMode p_mode);
+	EnvironmentMode get_environment_mode() const;
 
-	void set_propagation(float p_propagation);
-	float get_propagation() const;
+	void set_environment_custom_sky(const Ref<Sky> &p_sky);
+	Ref<Sky> get_environment_custom_sky() const;
 
-	void set_energy(float p_energy);
-	float get_energy() const;
+	void set_environment_custom_color(const Color &p_color);
+	Color get_environment_custom_color() const;
 
-	void set_bake_quality(BakeQuality p_quality);
-	BakeQuality get_bake_quality() const;
+	void set_environment_custom_energy(float p_energy);
+	float get_environment_custom_energy() const;
+
+	void set_bounces(int p_bounces);
+	int get_bounces() const;
 
-	void set_bake_mode(BakeMode p_mode);
-	BakeMode get_bake_mode() const;
+	void set_bias(float p_bias);
+	float get_bias() const;
 
-	void set_hdr(bool p_enable);
-	bool is_hdr() const;
+	void set_max_texture_size(int p_size);
+	int get_max_texture_size() const;
 
-	void set_image_path(const String &p_path);
-	String get_image_path() const;
+	void set_generate_probes(GenerateProbes p_generate_probes);
+	GenerateProbes get_generate_probes() const;
 
 	AABB get_aabb() const;
 	Vector<Face3> get_faces(uint32_t p_usage_flags) const;
 
-	BakeError bake(Node *p_from_node, bool p_create_visual_debug = false);
+	BakeError bake(Node *p_from_node, String p_image_data_path = "", Lightmapper::BakeStepFunc p_bake_step = nullptr, void *p_bake_userdata = nullptr);
 	BakedLightmap();
 };
 
+VARIANT_ENUM_CAST(BakedLightmap::GenerateProbes);
 VARIANT_ENUM_CAST(BakedLightmap::BakeQuality);
-VARIANT_ENUM_CAST(BakedLightmap::BakeMode);
 VARIANT_ENUM_CAST(BakedLightmap::BakeError);
+VARIANT_ENUM_CAST(BakedLightmap::EnvironmentMode);
 
-#endif
 #endif // BAKED_INDIRECT_LIGHT_H
diff --git a/scene/3d/gi_probe.cpp b/scene/3d/gi_probe.cpp
index 6d571ee4f2..65a330ddc0 100644
--- a/scene/3d/gi_probe.cpp
+++ b/scene/3d/gi_probe.cpp
@@ -349,7 +349,7 @@ Vector3 GIProbe::get_extents() const {
 void GIProbe::_find_meshes(Node *p_at_node, List<PlotMesh> &plot_meshes) {
 
 	MeshInstance3D *mi = Object::cast_to<MeshInstance3D>(p_at_node);
-	if (mi && mi->get_flag(GeometryInstance3D::FLAG_USE_BAKED_LIGHT) && mi->is_visible_in_tree()) {
+	if (mi && mi->get_gi_mode() == GeometryInstance3D::GI_MODE_BAKED && mi->is_visible_in_tree()) {
 		Ref<Mesh> mesh = mi->get_mesh();
 		if (mesh.is_valid()) {
 
diff --git a/scene/3d/lightmap_probe.cpp b/scene/3d/lightmap_probe.cpp
new file mode 100644
index 0000000000..2da81337f0
--- /dev/null
+++ b/scene/3d/lightmap_probe.cpp
@@ -0,0 +1,4 @@
+#include "lightmap_probe.h"
+
+LightmapProbe::LightmapProbe() {
+}
diff --git a/scene/3d/lightmap_probe.h b/scene/3d/lightmap_probe.h
new file mode 100644
index 0000000000..65bc6914f4
--- /dev/null
+++ b/scene/3d/lightmap_probe.h
@@ -0,0 +1,12 @@
+#ifndef LIGHTMAP_PROBE_H
+#define LIGHTMAP_PROBE_H
+
+#include "scene/3d/node_3d.h"
+
+class LightmapProbe : public Node3D {
+	GDCLASS(LightmapProbe, Node3D)
+public:
+	LightmapProbe();
+};
+
+#endif // LIGHTMAP_PROBE_H
diff --git a/scene/3d/lightmapper.cpp b/scene/3d/lightmapper.cpp
new file mode 100644
index 0000000000..53ebd5ee2e
--- /dev/null
+++ b/scene/3d/lightmapper.cpp
@@ -0,0 +1,37 @@
+#include "lightmapper.h"
+
+LightmapDenoiser *(*LightmapDenoiser::create_function)() = nullptr;
+
+Ref<LightmapDenoiser> LightmapDenoiser::create() {
+	if (create_function) {
+		return Ref<LightmapDenoiser>(create_function());
+	}
+	return Ref<LightmapDenoiser>();
+}
+
+Lightmapper::CreateFunc Lightmapper::create_custom = nullptr;
+Lightmapper::CreateFunc Lightmapper::create_gpu = nullptr;
+Lightmapper::CreateFunc Lightmapper::create_cpu = nullptr;
+
+Ref<Lightmapper> Lightmapper::create() {
+	Lightmapper *lm = nullptr;
+	if (create_custom) {
+		lm = create_custom();
+	}
+
+	if (!lm && create_gpu) {
+		lm = create_gpu();
+	}
+
+	if (!lm && create_cpu) {
+		lm = create_cpu();
+	}
+	if (!lm) {
+		return Ref<Lightmapper>();
+	} else {
+		return Ref<Lightmapper>(lm);
+	}
+}
+
+Lightmapper::Lightmapper() {
+}
diff --git a/scene/3d/lightmapper.h b/scene/3d/lightmapper.h
new file mode 100644
index 0000000000..7c052a30a0
--- /dev/null
+++ b/scene/3d/lightmapper.h
@@ -0,0 +1,90 @@
+#ifndef LIGHTMAPPER_H
+#define LIGHTMAPPER_H
+
+#include "scene/resources/mesh.h"
+#include "servers/rendering/rendering_device.h"
+
+class LightmapDenoiser : public Reference {
+	GDCLASS(LightmapDenoiser, Reference)
+protected:
+	static LightmapDenoiser *(*create_function)();
+
+public:
+	virtual Ref<Image> denoise_image(const Ref<Image> &p_image) = 0;
+	static Ref<LightmapDenoiser> create();
+};
+
+class Lightmapper : public Reference {
+	GDCLASS(Lightmapper, Reference)
+public:
+	enum GenerateProbes {
+		GENERATE_PROBES_DISABLED,
+		GENERATE_PROBES_SUBDIV_4,
+		GENERATE_PROBES_SUBDIV_8,
+		GENERATE_PROBES_SUBDIV_16,
+		GENERATE_PROBES_SUBDIV_32,
+
+	};
+
+	enum LightType {
+		LIGHT_TYPE_DIRECTIONAL,
+		LIGHT_TYPE_OMNI,
+		LIGHT_TYPE_SPOT
+	};
+
+	enum BakeError {
+		BAKE_ERROR_LIGHTMAP_TOO_SMALL,
+		BAKE_ERROR_LIGHTMAP_CANT_PRE_BAKE_MESHES,
+		BAKE_OK
+	};
+
+	enum BakeQuality {
+		BAKE_QUALITY_LOW,
+		BAKE_QUALITY_MEDIUM,
+		BAKE_QUALITY_HIGH,
+		BAKE_QUALITY_ULTRA,
+	};
+
+	typedef Lightmapper *(*CreateFunc)();
+
+	static CreateFunc create_custom;
+	static CreateFunc create_gpu;
+	static CreateFunc create_cpu;
+
+protected:
+public:
+	typedef bool (*BakeStepFunc)(float, const String &, void *, bool); //step index, step total, step description, userdata
+
+	struct MeshData {
+		//triangle data
+		Vector<Vector3> points;
+		Vector<Vector2> uv2;
+		Vector<Vector3> normal;
+		Ref<Image> albedo_on_uv2;
+		Ref<Image> emission_on_uv2;
+		Variant userdata;
+	};
+
+	virtual void add_mesh(const MeshData &p_mesh) = 0;
+	virtual void add_directional_light(bool p_static, const Vector3 &p_direction, const Color &p_color, float p_energy, float p_angular_distance) = 0;
+	virtual void add_omni_light(bool p_static, const Vector3 &p_position, const Color &p_color, float p_energy, float p_range, float p_attenuation, float p_size) = 0;
+	virtual void add_spot_light(bool p_static, const Vector3 &p_position, const Vector3 p_direction, const Color &p_color, float p_energy, float p_range, float p_attenuation, float p_spot_angle, float p_spot_attenuation, float p_size) = 0;
+	virtual void add_probe(const Vector3 &p_position) = 0;
+	virtual BakeError bake(BakeQuality p_quality, bool p_use_denoiser, int p_bounces, float p_bias, int p_max_texture_size, bool p_bake_sh, GenerateProbes p_generate_probes, const Ref<Image> &p_environment_panorama, const Basis &p_environment_transform, BakeStepFunc p_step_function = nullptr, void *p_step_userdata = nullptr) = 0;
+
+	virtual int get_bake_texture_count() const = 0;
+	virtual Ref<Image> get_bake_texture(int p_index) const = 0;
+	virtual int get_bake_mesh_count() const = 0;
+	virtual Variant get_bake_mesh_userdata(int p_index) const = 0;
+	virtual Rect2 get_bake_mesh_uv_scale(int p_index) const = 0;
+	virtual int get_bake_mesh_texture_slice(int p_index) const = 0;
+	virtual int get_bake_probe_count() const = 0;
+	virtual Vector3 get_bake_probe_point(int p_probe) const = 0;
+	virtual Vector<Color> get_bake_probe_sh(int p_probe) const = 0;
+
+	static Ref<Lightmapper> create();
+
+	Lightmapper();
+};
+
+#endif // LIGHTMAPPER_H
diff --git a/scene/3d/visual_instance_3d.cpp b/scene/3d/visual_instance_3d.cpp
index ce8672c1dd..4724c88a30 100644
--- a/scene/3d/visual_instance_3d.cpp
+++ b/scene/3d/visual_instance_3d.cpp
@@ -239,7 +239,17 @@ bool GeometryInstance3D::_set(const StringName &p_name, const Variant &p_value)
 		set_shader_instance_uniform(*r, p_value);
 		return true;
 	}
+#ifndef DISABLE_DEPRECATED
+	if (p_name == SceneStringNames::get_singleton()->use_in_baked_light && bool(p_value)) {
+		set_gi_mode(GI_MODE_BAKED);
+		return true;
+	}
 
+	if (p_name == SceneStringNames::get_singleton()->use_dynamic_gi && bool(p_value)) {
+		set_gi_mode(GI_MODE_DYNAMIC);
+		return true;
+	}
+#endif
 	return false;
 }
 
@@ -273,23 +283,6 @@ void GeometryInstance3D::_get_property_list(List<PropertyInfo> *p_list) const {
 	}
 }
 
-void GeometryInstance3D::set_flag(Flags p_flag, bool p_value) {
-
-	ERR_FAIL_INDEX(p_flag, FLAG_MAX);
-	if (flags[p_flag] == p_value)
-		return;
-
-	flags[p_flag] = p_value;
-	RS::get_singleton()->instance_geometry_set_flag(get_instance(), (RS::InstanceFlags)p_flag, p_value);
-}
-
-bool GeometryInstance3D::get_flag(Flags p_flag) const {
-
-	ERR_FAIL_INDEX_V(p_flag, FLAG_MAX, false);
-
-	return flags[p_flag];
-}
-
 void GeometryInstance3D::set_cast_shadows_setting(ShadowCastingSetting p_shadow_casting_setting) {
 
 	shadow_casting_setting = p_shadow_casting_setting;
@@ -335,14 +328,45 @@ void GeometryInstance3D::set_custom_aabb(AABB aabb) {
 	RS::get_singleton()->instance_set_custom_aabb(get_instance(), aabb);
 }
 
+void GeometryInstance3D::set_lightmap_scale(LightmapScale p_scale) {
+	ERR_FAIL_INDEX(p_scale, LIGHTMAP_SCALE_MAX);
+	lightmap_scale = p_scale;
+}
+
+GeometryInstance3D::LightmapScale GeometryInstance3D::get_lightmap_scale() const {
+	return lightmap_scale;
+}
+
+void GeometryInstance3D::set_gi_mode(GIMode p_mode) {
+
+	switch (p_mode) {
+		case GI_MODE_DISABLED: {
+			RS::get_singleton()->instance_geometry_set_flag(get_instance(), RS::INSTANCE_FLAG_USE_BAKED_LIGHT, false);
+			RS::get_singleton()->instance_geometry_set_flag(get_instance(), RS::INSTANCE_FLAG_USE_DYNAMIC_GI, false);
+		} break;
+		case GI_MODE_BAKED: {
+			RS::get_singleton()->instance_geometry_set_flag(get_instance(), RS::INSTANCE_FLAG_USE_BAKED_LIGHT, true);
+			RS::get_singleton()->instance_geometry_set_flag(get_instance(), RS::INSTANCE_FLAG_USE_DYNAMIC_GI, false);
+
+		} break;
+		case GI_MODE_DYNAMIC: {
+			RS::get_singleton()->instance_geometry_set_flag(get_instance(), RS::INSTANCE_FLAG_USE_BAKED_LIGHT, false);
+			RS::get_singleton()->instance_geometry_set_flag(get_instance(), RS::INSTANCE_FLAG_USE_DYNAMIC_GI, true);
+		} break;
+	}
+
+	gi_mode = p_mode;
+}
+
+GeometryInstance3D::GIMode GeometryInstance3D::get_gi_mode() const {
+	return gi_mode;
+}
+
 void GeometryInstance3D::_bind_methods() {
 
 	ClassDB::bind_method(D_METHOD("set_material_override", "material"), &GeometryInstance3D::set_material_override);
 	ClassDB::bind_method(D_METHOD("get_material_override"), &GeometryInstance3D::get_material_override);
 
-	ClassDB::bind_method(D_METHOD("set_flag", "flag", "value"), &GeometryInstance3D::set_flag);
-	ClassDB::bind_method(D_METHOD("get_flag", "flag"), &GeometryInstance3D::get_flag);
-
 	ClassDB::bind_method(D_METHOD("set_cast_shadows_setting", "shadow_casting_setting"), &GeometryInstance3D::set_cast_shadows_setting);
 	ClassDB::bind_method(D_METHOD("get_cast_shadows_setting"), &GeometryInstance3D::get_cast_shadows_setting);
 
@@ -364,6 +388,12 @@ void GeometryInstance3D::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("set_extra_cull_margin", "margin"), &GeometryInstance3D::set_extra_cull_margin);
 	ClassDB::bind_method(D_METHOD("get_extra_cull_margin"), &GeometryInstance3D::get_extra_cull_margin);
 
+	ClassDB::bind_method(D_METHOD("set_lightmap_scale", "scale"), &GeometryInstance3D::set_lightmap_scale);
+	ClassDB::bind_method(D_METHOD("get_lightmap_scale"), &GeometryInstance3D::get_lightmap_scale);
+
+	ClassDB::bind_method(D_METHOD("set_gi_mode", "mode"), &GeometryInstance3D::set_gi_mode);
+	ClassDB::bind_method(D_METHOD("get_gi_mode"), &GeometryInstance3D::get_gi_mode);
+
 	ClassDB::bind_method(D_METHOD("set_custom_aabb", "aabb"), &GeometryInstance3D::set_custom_aabb);
 
 	ClassDB::bind_method(D_METHOD("get_aabb"), &GeometryInstance3D::get_aabb);
@@ -372,8 +402,9 @@ void GeometryInstance3D::_bind_methods() {
 	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "material_override", PROPERTY_HINT_RESOURCE_TYPE, "ShaderMaterial,StandardMaterial3D", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_DEFERRED_SET_RESOURCE), "set_material_override", "get_material_override");
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "cast_shadow", PROPERTY_HINT_ENUM, "Off,On,Double-Sided,Shadows Only"), "set_cast_shadows_setting", "get_cast_shadows_setting");
 	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "extra_cull_margin", PROPERTY_HINT_RANGE, "0,16384,0.01"), "set_extra_cull_margin", "get_extra_cull_margin");
-	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "use_in_baked_light"), "set_flag", "get_flag", FLAG_USE_BAKED_LIGHT);
-	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "use_dynamic_gi"), "set_flag", "get_flag", FLAG_USE_DYNAMIC_GI);
+	ADD_GROUP("Global Illumination", "gi_");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "gi_mode", PROPERTY_HINT_ENUM, "Disabled,Baked,Dynamic"), "set_gi_mode", "get_gi_mode");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "gi_lightmap_scale", PROPERTY_HINT_ENUM, "1x,2x,4x,8x"), "set_lightmap_scale", "get_lightmap_scale");
 
 	ADD_GROUP("LOD", "lod_");
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "lod_min_distance", PROPERTY_HINT_RANGE, "0,32768,0.01"), "set_lod_min_distance", "get_lod_min_distance");
@@ -388,10 +419,15 @@ void GeometryInstance3D::_bind_methods() {
 	BIND_ENUM_CONSTANT(SHADOW_CASTING_SETTING_DOUBLE_SIDED);
 	BIND_ENUM_CONSTANT(SHADOW_CASTING_SETTING_SHADOWS_ONLY);
 
-	BIND_ENUM_CONSTANT(FLAG_USE_BAKED_LIGHT);
-	BIND_ENUM_CONSTANT(FLAG_USE_DYNAMIC_GI);
-	BIND_ENUM_CONSTANT(FLAG_DRAW_NEXT_FRAME_IF_VISIBLE);
-	BIND_ENUM_CONSTANT(FLAG_MAX);
+	BIND_ENUM_CONSTANT(GI_MODE_DISABLED);
+	BIND_ENUM_CONSTANT(GI_MODE_BAKED);
+	BIND_ENUM_CONSTANT(GI_MODE_DYNAMIC);
+
+	BIND_ENUM_CONSTANT(LIGHTMAP_SCALE_1X);
+	BIND_ENUM_CONSTANT(LIGHTMAP_SCALE_2X);
+	BIND_ENUM_CONSTANT(LIGHTMAP_SCALE_4X);
+	BIND_ENUM_CONSTANT(LIGHTMAP_SCALE_8X);
+	BIND_ENUM_CONSTANT(LIGHTMAP_SCALE_MAX);
 }
 
 GeometryInstance3D::GeometryInstance3D() {
@@ -400,9 +436,8 @@ GeometryInstance3D::GeometryInstance3D() {
 	lod_min_hysteresis = 0;
 	lod_max_hysteresis = 0;
 
-	for (int i = 0; i < FLAG_MAX; i++) {
-		flags[i] = false;
-	}
+	gi_mode = GI_MODE_DISABLED;
+	lightmap_scale = LIGHTMAP_SCALE_1X;
 
 	shadow_casting_setting = SHADOW_CASTING_SETTING_ON;
 	extra_cull_margin = 0;
diff --git a/scene/3d/visual_instance_3d.h b/scene/3d/visual_instance_3d.h
index cc5f92066f..a871c65b6a 100644
--- a/scene/3d/visual_instance_3d.h
+++ b/scene/3d/visual_instance_3d.h
@@ -85,13 +85,6 @@ class GeometryInstance3D : public VisualInstance3D {
 	GDCLASS(GeometryInstance3D, VisualInstance3D);
 
 public:
-	enum Flags {
-		FLAG_USE_BAKED_LIGHT = RS::INSTANCE_FLAG_USE_BAKED_LIGHT,
-		FLAG_USE_DYNAMIC_GI = RS::INSTANCE_FLAG_USE_DYNAMIC_GI,
-		FLAG_DRAW_NEXT_FRAME_IF_VISIBLE = RS::INSTANCE_FLAG_DRAW_NEXT_FRAME_IF_VISIBLE,
-		FLAG_MAX = RS::INSTANCE_FLAG_MAX,
-	};
-
 	enum ShadowCastingSetting {
 		SHADOW_CASTING_SETTING_OFF = RS::SHADOW_CASTING_SETTING_OFF,
 		SHADOW_CASTING_SETTING_ON = RS::SHADOW_CASTING_SETTING_ON,
@@ -99,8 +92,21 @@ public:
 		SHADOW_CASTING_SETTING_SHADOWS_ONLY = RS::SHADOW_CASTING_SETTING_SHADOWS_ONLY
 	};
 
+	enum GIMode {
+		GI_MODE_DISABLED,
+		GI_MODE_BAKED,
+		GI_MODE_DYNAMIC
+	};
+
+	enum LightmapScale {
+		LIGHTMAP_SCALE_1X,
+		LIGHTMAP_SCALE_2X,
+		LIGHTMAP_SCALE_4X,
+		LIGHTMAP_SCALE_8X,
+		LIGHTMAP_SCALE_MAX,
+	};
+
 private:
-	bool flags[FLAG_MAX];
 	ShadowCastingSetting shadow_casting_setting;
 	Ref<Material> material_override;
 	float lod_min_distance;
@@ -112,6 +118,8 @@ private:
 	mutable HashMap<StringName, StringName> instance_uniform_property_remap;
 
 	float extra_cull_margin;
+	LightmapScale lightmap_scale;
+	GIMode gi_mode;
 
 	const StringName *_instance_uniform_get_remap(const StringName p_name) const;
 
@@ -124,9 +132,6 @@ protected:
 	static void _bind_methods();
 
 public:
-	void set_flag(Flags p_flag, bool p_value);
-	bool get_flag(Flags p_flag) const;
-
 	void set_cast_shadows_setting(ShadowCastingSetting p_shadow_casting_setting);
 	ShadowCastingSetting get_cast_shadows_setting() const;
 
@@ -148,6 +153,12 @@ public:
 	void set_extra_cull_margin(float p_margin);
 	float get_extra_cull_margin() const;
 
+	void set_gi_mode(GIMode p_mode);
+	GIMode get_gi_mode() const;
+
+	void set_lightmap_scale(LightmapScale p_scale);
+	LightmapScale get_lightmap_scale() const;
+
 	void set_shader_instance_uniform(const StringName &p_uniform, const Variant &p_value);
 	Variant get_shader_instance_uniform(const StringName &p_uniform) const;
 
@@ -156,7 +167,8 @@ public:
 	GeometryInstance3D();
 };
 
-VARIANT_ENUM_CAST(GeometryInstance3D::Flags);
 VARIANT_ENUM_CAST(GeometryInstance3D::ShadowCastingSetting);
+VARIANT_ENUM_CAST(GeometryInstance3D::LightmapScale);
+VARIANT_ENUM_CAST(GeometryInstance3D::GIMode);
 
 #endif
diff --git a/scene/3d/voxelizer.cpp b/scene/3d/voxelizer.cpp
index a2d305f3cb..f9c3810843 100644
--- a/scene/3d/voxelizer.cpp
+++ b/scene/3d/voxelizer.cpp
@@ -29,207 +29,12 @@
 /*************************************************************************/
 
 #include "voxelizer.h"
+#include "core/math/geometry.h"
 #include "core/os/os.h"
 #include "core/os/threaded_array_processor.h"
 
 #include <stdlib.h>
 
-#define FINDMINMAX(x0, x1, x2, min, max) \
-	min = max = x0;                      \
-	if (x1 < min)                        \
-		min = x1;                        \
-	if (x1 > max)                        \
-		max = x1;                        \
-	if (x2 < min)                        \
-		min = x2;                        \
-	if (x2 > max)                        \
-		max = x2;
-
-static bool planeBoxOverlap(Vector3 normal, float d, Vector3 maxbox) {
-	int q;
-	Vector3 vmin, vmax;
-	for (q = 0; q <= 2; q++) {
-		if (normal[q] > 0.0f) {
-			vmin[q] = -maxbox[q];
-			vmax[q] = maxbox[q];
-		} else {
-			vmin[q] = maxbox[q];
-			vmax[q] = -maxbox[q];
-		}
-	}
-	if (normal.dot(vmin) + d > 0.0f)
-		return false;
-	if (normal.dot(vmax) + d >= 0.0f)
-		return true;
-
-	return false;
-}
-
-/*======================== X-tests ========================*/
-#define AXISTEST_X01(a, b, fa, fb)                 \
-	p0 = a * v0.y - b * v0.z;                      \
-	p2 = a * v2.y - b * v2.z;                      \
-	if (p0 < p2) {                                 \
-		min = p0;                                  \
-		max = p2;                                  \
-	} else {                                       \
-		min = p2;                                  \
-		max = p0;                                  \
-	}                                              \
-	rad = fa * boxhalfsize.y + fb * boxhalfsize.z; \
-	if (min > rad || max < -rad)                   \
-		return false;
-
-#define AXISTEST_X2(a, b, fa, fb)                  \
-	p0 = a * v0.y - b * v0.z;                      \
-	p1 = a * v1.y - b * v1.z;                      \
-	if (p0 < p1) {                                 \
-		min = p0;                                  \
-		max = p1;                                  \
-	} else {                                       \
-		min = p1;                                  \
-		max = p0;                                  \
-	}                                              \
-	rad = fa * boxhalfsize.y + fb * boxhalfsize.z; \
-	if (min > rad || max < -rad)                   \
-		return false;
-
-/*======================== Y-tests ========================*/
-#define AXISTEST_Y02(a, b, fa, fb)                 \
-	p0 = -a * v0.x + b * v0.z;                     \
-	p2 = -a * v2.x + b * v2.z;                     \
-	if (p0 < p2) {                                 \
-		min = p0;                                  \
-		max = p2;                                  \
-	} else {                                       \
-		min = p2;                                  \
-		max = p0;                                  \
-	}                                              \
-	rad = fa * boxhalfsize.x + fb * boxhalfsize.z; \
-	if (min > rad || max < -rad)                   \
-		return false;
-
-#define AXISTEST_Y1(a, b, fa, fb)                  \
-	p0 = -a * v0.x + b * v0.z;                     \
-	p1 = -a * v1.x + b * v1.z;                     \
-	if (p0 < p1) {                                 \
-		min = p0;                                  \
-		max = p1;                                  \
-	} else {                                       \
-		min = p1;                                  \
-		max = p0;                                  \
-	}                                              \
-	rad = fa * boxhalfsize.x + fb * boxhalfsize.z; \
-	if (min > rad || max < -rad)                   \
-		return false;
-
-/*======================== Z-tests ========================*/
-
-#define AXISTEST_Z12(a, b, fa, fb)                 \
-	p1 = a * v1.x - b * v1.y;                      \
-	p2 = a * v2.x - b * v2.y;                      \
-	if (p2 < p1) {                                 \
-		min = p2;                                  \
-		max = p1;                                  \
-	} else {                                       \
-		min = p1;                                  \
-		max = p2;                                  \
-	}                                              \
-	rad = fa * boxhalfsize.x + fb * boxhalfsize.y; \
-	if (min > rad || max < -rad)                   \
-		return false;
-
-#define AXISTEST_Z0(a, b, fa, fb)                  \
-	p0 = a * v0.x - b * v0.y;                      \
-	p1 = a * v1.x - b * v1.y;                      \
-	if (p0 < p1) {                                 \
-		min = p0;                                  \
-		max = p1;                                  \
-	} else {                                       \
-		min = p1;                                  \
-		max = p0;                                  \
-	}                                              \
-	rad = fa * boxhalfsize.x + fb * boxhalfsize.y; \
-	if (min > rad || max < -rad)                   \
-		return false;
-
-static bool fast_tri_box_overlap(const Vector3 &boxcenter, const Vector3 boxhalfsize, const Vector3 *triverts) {
-
-	/*    use separating axis theorem to test overlap between triangle and box */
-	/*    need to test for overlap in these directions: */
-	/*    1) the {x,y,z}-directions (actually, since we use the AABB of the triangle */
-	/*       we do not even need to test these) */
-	/*    2) normal of the triangle */
-	/*    3) crossproduct(edge from tri, {x,y,z}-directin) */
-	/*       this gives 3x3=9 more tests */
-	Vector3 v0, v1, v2;
-	float min, max, d, p0, p1, p2, rad, fex, fey, fez;
-	Vector3 normal, e0, e1, e2;
-
-	/* This is the fastest branch on Sun */
-	/* move everything so that the boxcenter is in (0,0,0) */
-
-	v0 = triverts[0] - boxcenter;
-	v1 = triverts[1] - boxcenter;
-	v2 = triverts[2] - boxcenter;
-
-	/* compute triangle edges */
-	e0 = v1 - v0; /* tri edge 0 */
-	e1 = v2 - v1; /* tri edge 1 */
-	e2 = v0 - v2; /* tri edge 2 */
-
-	/* Bullet 3:  */
-	/*  test the 9 tests first (this was faster) */
-	fex = Math::abs(e0.x);
-	fey = Math::abs(e0.y);
-	fez = Math::abs(e0.z);
-	AXISTEST_X01(e0.z, e0.y, fez, fey);
-	AXISTEST_Y02(e0.z, e0.x, fez, fex);
-	AXISTEST_Z12(e0.y, e0.x, fey, fex);
-
-	fex = Math::abs(e1.x);
-	fey = Math::abs(e1.y);
-	fez = Math::abs(e1.z);
-	AXISTEST_X01(e1.z, e1.y, fez, fey);
-	AXISTEST_Y02(e1.z, e1.x, fez, fex);
-	AXISTEST_Z0(e1.y, e1.x, fey, fex);
-
-	fex = Math::abs(e2.x);
-	fey = Math::abs(e2.y);
-	fez = Math::abs(e2.z);
-	AXISTEST_X2(e2.z, e2.y, fez, fey);
-	AXISTEST_Y1(e2.z, e2.x, fez, fex);
-	AXISTEST_Z12(e2.y, e2.x, fey, fex);
-
-	/* Bullet 1: */
-	/*  first test overlap in the {x,y,z}-directions */
-	/*  find min, max of the triangle each direction, and test for overlap in */
-	/*  that direction -- this is equivalent to testing a minimal AABB around */
-	/*  the triangle against the AABB */
-
-	/* test in X-direction */
-	FINDMINMAX(v0.x, v1.x, v2.x, min, max);
-	if (min > boxhalfsize.x || max < -boxhalfsize.x)
-		return false;
-
-	/* test in Y-direction */
-	FINDMINMAX(v0.y, v1.y, v2.y, min, max);
-	if (min > boxhalfsize.y || max < -boxhalfsize.y)
-		return false;
-
-	/* test in Z-direction */
-	FINDMINMAX(v0.z, v1.z, v2.z, min, max);
-	if (min > boxhalfsize.z || max < -boxhalfsize.z)
-		return false;
-
-	/* Bullet 2: */
-	/*  test if the box intersects the plane of the triangle */
-	/*  compute plane equation of triangle: normal*x+d=0 */
-	normal = e0.cross(e1);
-	d = -normal.dot(v0); /* plane eq: normal.x+d=0 */
-	return planeBoxOverlap(normal, d, boxhalfsize); /* if true, box and triangle overlaps */
-}
-
 static _FORCE_INLINE_ void get_uv_and_normal(const Vector3 &p_pos, const Vector3 *p_vtx, const Vector2 *p_uv, const Vector3 *p_normal, Vector2 &r_uv, Vector3 &r_normal) {
 
 	if (p_pos.distance_squared_to(p_vtx[0]) < CMP_EPSILON2) {
@@ -324,7 +129,7 @@ void Voxelizer::_plot_face(int p_idx, int p_level, int p_x, int p_y, int p_z, co
 				Vector3 half = (to - from) * 0.5;
 
 				//is in this cell?
-				if (!fast_tri_box_overlap(from + half, half, p_vtx)) {
+				if (!Geometry::triangle_box_overlap(from + half, half, p_vtx)) {
 					continue; //face does not span this cell
 				}
 
@@ -467,7 +272,7 @@ void Voxelizer::_plot_face(int p_idx, int p_level, int p_x, int p_y, int p_z, co
 				//test_aabb.grow_by(test_aabb.get_longest_axis_size()*0.05); //grow a bit to avoid numerical error in real-time
 				Vector3 qsize = test_aabb.size * 0.5; //quarter size, for fast aabb test
 
-				if (!fast_tri_box_overlap(test_aabb.position + qsize, qsize, p_vtx)) {
+				if (!Geometry::triangle_box_overlap(test_aabb.position + qsize, qsize, p_vtx)) {
 					//if (!Face3(p_vtx[0],p_vtx[1],p_vtx[2]).intersects_aabb2(aabb)) {
 					//does not fit in child, go on
 					continue;
@@ -648,7 +453,7 @@ void Voxelizer::plot_mesh(const Transform &p_xform, Ref<Mesh> &p_mesh, const Vec
 				}
 
 				//test against original bounds
-				if (!fast_tri_box_overlap(original_bounds.position + original_bounds.size * 0.5, original_bounds.size * 0.5, vtxs))
+				if (!Geometry::triangle_box_overlap(original_bounds.position + original_bounds.size * 0.5, original_bounds.size * 0.5, vtxs))
 					continue;
 				//plot
 				_plot_face(0, 0, 0, 0, 0, vtxs, normal, uvs, material, po2_bounds);
@@ -681,7 +486,7 @@ void Voxelizer::plot_mesh(const Transform &p_xform, Ref<Mesh> &p_mesh, const Vec
 				}
 
 				//test against original bounds
-				if (!fast_tri_box_overlap(original_bounds.position + original_bounds.size * 0.5, original_bounds.size * 0.5, vtxs))
+				if (!Geometry::triangle_box_overlap(original_bounds.position + original_bounds.size * 0.5, original_bounds.size * 0.5, vtxs))
 					continue;
 				//plot face
 				_plot_face(0, 0, 0, 0, 0, vtxs, normal, uvs, material, po2_bounds);