diff --git a/modules/gridmap/SCsub b/modules/gridmap/SCsub
new file mode 100644
index 000000000..13618d0ad
--- /dev/null
+++ b/modules/gridmap/SCsub
@@ -0,0 +1,9 @@
+#!/usr/bin/env python
+
+Import("env")
+Import("env_modules")
+
+env_gridmap = env_modules.Clone()
+
+# Godot source files
+env_gridmap.add_source_files(env.modules_sources, "*.cpp")
diff --git a/modules/gridmap/config.py b/modules/gridmap/config.py
new file mode 100644
index 000000000..f5e49695d
--- /dev/null
+++ b/modules/gridmap/config.py
@@ -0,0 +1,16 @@
+def can_build(env, platform):
+ return False
+
+
+def configure(env):
+ pass
+
+
+def get_doc_classes():
+ return [
+ "GridMap",
+ ]
+
+
+def get_doc_path():
+ return "doc_classes"
diff --git a/modules/gridmap/doc_classes/GridMap.xml b/modules/gridmap/doc_classes/GridMap.xml
new file mode 100644
index 000000000..39121dd14
--- /dev/null
+++ b/modules/gridmap/doc_classes/GridMap.xml
@@ -0,0 +1,219 @@
+
+
+
+ Node for 3D tile-based maps.
+
+
+ GridMap lets you place meshes on a grid interactively. It works both from the editor and from scripts, which can help you create in-game level editors.
+ GridMaps use a [MeshLibrary] which contains a list of tiles. Each tile is a mesh with materials plus optional collision and navigation shapes.
+ A GridMap contains a collection of cells. Each grid cell refers to a tile in the [MeshLibrary]. All cells in the map have the same dimensions.
+ Internally, a GridMap is split into a sparse collection of octants for efficient rendering and physics processing. Every octant has the same dimensions and can contain several cells.
+ [b]Note:[/b] GridMap doesn't extend [VisualInstance] and therefore can't be hidden or cull masked based on [member VisualInstance.layers]. If you make a light not affect the first layer, the whole GridMap won't be lit by the light in question.
+
+
+ $DOCS_URL/tutorials/3d/using_gridmaps.html
+ https://godotengine.org/asset-library/asset/125
+ https://godotengine.org/asset-library/asset/126
+
+
+
+
+
+ Clear all cells.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Returns an array of [ArrayMesh]es and [Transform] references of all bake meshes that exist within the current GridMap.
+
+
+
+
+
+
+
+
+ The [MeshLibrary] item index located at the grid-based X, Y and Z coordinates. If the cell is empty, [constant INVALID_CELL_ITEM] will be returned.
+
+
+
+
+
+
+
+
+ The orientation of the cell at the grid-based X, Y and Z coordinates. -1 is returned if the cell is empty.
+
+
+
+
+
+
+ Returns an individual bit on the [member collision_layer].
+
+
+
+
+
+
+ Returns an individual bit on the [member collision_mask].
+
+
+
+
+
+ Returns an array of [Transform] and [Mesh] references corresponding to the non-empty cells in the grid. The transforms are specified in world space.
+
+
+
+
+
+ Returns an array of [Vector3] with the non-empty cell coordinates in the grid map.
+
+
+
+
+
+
+ Returns an array of all cells with the given item index specified in [code]item[/code].
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Returns the position of a grid cell in the GridMap's local coordinate space.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Sets the mesh index for the cell referenced by its grid-based X, Y and Z coordinates.
+ A negative item index such as [constant INVALID_CELL_ITEM] will clear the cell.
+ Optionally, the item's orientation can be passed. For valid orientation values, see [method Basis.get_orthogonal_index].
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Sets an individual bit on the [member collision_layer].
+
+
+
+
+
+
+
+ Sets an individual bit on the [member collision_mask].
+
+
+
+
+
+
+ Returns the coordinates of the grid cell containing the given point.
+ [code]pos[/code] should be in the GridMap's local coordinate space.
+
+
+
+
+
+ If [code]true[/code], this GridMap uses cell navmesh resources to create navigation regions.
+
+
+ If [code]true[/code], grid items are centered on the X axis.
+
+
+ If [code]true[/code], grid items are centered on the Y axis.
+
+
+ If [code]true[/code], grid items are centered on the Z axis.
+
+
+ The size of each octant measured in number of cells. This applies to all three axis.
+
+
+ The scale of the cell items.
+ This does not affect the size of the grid cells themselves, only the items in them. This can be used to make cell items overlap their neighbors.
+
+
+ The dimensions of the grid's cells.
+ This does not affect the size of the meshes. See [member cell_scale].
+
+
+ The physics layers this GridMap is in.
+ GridMaps act as static bodies, meaning they aren't affected by gravity or other forces. They only affect other physics bodies that collide with them.
+
+
+ The physics layers this GridMap detects collisions in. See [url=$DOCS_URL/tutorials/physics/physics_introduction.html#collision-layers-and-masks]Collision layers and masks[/url] in the documentation for more information.
+
+
+ The assigned [MeshLibrary].
+
+
+ The navigation layers the GridMap generates its navigation regions in.
+
+
+ Overrides the default friction and bounce physics properties for the whole [GridMap].
+
+
+ Controls whether this GridMap will be baked in a [BakedLightmap] or not.
+
+
+
+
+
+
+ Emitted when [member cell_size] changes.
+
+
+
+
+
+ Invalid cell item that can be used in [method set_cell_item] to clear cells (or represent an empty cell in [method get_cell_item]).
+
+
+
diff --git a/modules/gridmap/grid_map.cpp b/modules/gridmap/grid_map.cpp
new file mode 100644
index 000000000..b0a2689e0
--- /dev/null
+++ b/modules/gridmap/grid_map.cpp
@@ -0,0 +1,1245 @@
+/*************************************************************************/
+/* grid_map.cpp */
+/*************************************************************************/
+/* This file is part of: */
+/* GODOT ENGINE */
+/* https://godotengine.org */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md). */
+/* */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the */
+/* "Software"), to deal in the Software without restriction, including */
+/* without limitation the rights to use, copy, modify, merge, publish, */
+/* distribute, sublicense, and/or sell copies of the Software, and to */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions: */
+/* */
+/* The above copyright notice and this permission notice shall be */
+/* included in all copies or substantial portions of the Software. */
+/* */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
+/*************************************************************************/
+
+#include "grid_map.h"
+
+#include "core/io/marshalls.h"
+#include "core/message_queue.h"
+#include "scene/3d/light.h"
+#include "scene/resources/mesh_library.h"
+#include "scene/resources/physics_material.h"
+#include "scene/resources/primitive_meshes.h"
+#include "scene/resources/surface_tool.h"
+#include "scene/scene_string_names.h"
+#include "servers/navigation_server.h"
+#include "servers/visual_server.h"
+
+bool GridMap::_set(const StringName &p_name, const Variant &p_value) {
+ String name = p_name;
+
+ if (name == "data") {
+ Dictionary d = p_value;
+
+ if (d.has("cells")) {
+ PoolVector cells = d["cells"];
+ int amount = cells.size();
+ PoolVector::Read r = cells.read();
+ ERR_FAIL_COND_V(amount % 3, false); // not even
+ cell_map.clear();
+ for (int i = 0; i < amount / 3; i++) {
+ IndexKey ik;
+ ik.key = decode_uint64((const uint8_t *)&r[i * 3]);
+ Cell cell;
+ cell.cell = decode_uint32((const uint8_t *)&r[i * 3 + 2]);
+ cell_map[ik] = cell;
+ }
+ }
+
+ _recreate_octant_data();
+
+ } else if (name == "baked_meshes") {
+ clear_baked_meshes();
+
+ Array meshes = p_value;
+
+ for (int i = 0; i < meshes.size(); i++) {
+ BakedMesh bm;
+ bm.mesh = meshes[i];
+ ERR_CONTINUE(!bm.mesh.is_valid());
+ bm.instance = RID_PRIME(VS::get_singleton()->instance_create());
+ VS::get_singleton()->instance_set_portal_mode(bm.instance, VisualServer::InstancePortalMode::INSTANCE_PORTAL_MODE_GLOBAL);
+ VS::get_singleton()->get_singleton()->instance_set_base(bm.instance, bm.mesh->get_rid());
+ VS::get_singleton()->instance_attach_object_instance_id(bm.instance, get_instance_id());
+ if (is_inside_tree()) {
+ VS::get_singleton()->instance_set_scenario(bm.instance, get_world()->get_scenario());
+ VS::get_singleton()->instance_set_transform(bm.instance, get_global_transform());
+ }
+ baked_meshes.push_back(bm);
+ }
+
+ _recreate_octant_data();
+
+ } else {
+ return false;
+ }
+
+ return true;
+}
+
+bool GridMap::_get(const StringName &p_name, Variant &r_ret) const {
+ String name = p_name;
+
+ if (name == "data") {
+ Dictionary d;
+
+ PoolVector cells;
+ cells.resize(cell_map.size() * 3);
+ {
+ PoolVector::Write w = cells.write();
+ int i = 0;
+ for (Map::Element *E = cell_map.front(); E; E = E->next(), i++) {
+ encode_uint64(E->key().key, (uint8_t *)&w[i * 3]);
+ encode_uint32(E->get().cell, (uint8_t *)&w[i * 3 + 2]);
+ }
+ }
+
+ d["cells"] = cells;
+
+ r_ret = d;
+ } else if (name == "baked_meshes") {
+ Array ret;
+ ret.resize(baked_meshes.size());
+ for (int i = 0; i < baked_meshes.size(); i++) {
+ ret[i] = baked_meshes[i].mesh;
+ }
+ r_ret = ret;
+
+ } else {
+ return false;
+ }
+
+ return true;
+}
+
+void GridMap::_get_property_list(List *p_list) const {
+ if (baked_meshes.size()) {
+ p_list->push_back(PropertyInfo(Variant::ARRAY, "baked_meshes", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_STORAGE));
+ }
+
+ p_list->push_back(PropertyInfo(Variant::DICTIONARY, "data", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_STORAGE));
+}
+
+void GridMap::set_collision_layer(uint32_t p_layer) {
+ collision_layer = p_layer;
+ _reset_physic_bodies_collision_filters();
+}
+
+uint32_t GridMap::get_collision_layer() const {
+ return collision_layer;
+}
+
+void GridMap::set_collision_mask(uint32_t p_mask) {
+ collision_mask = p_mask;
+ _reset_physic_bodies_collision_filters();
+}
+
+uint32_t GridMap::get_collision_mask() const {
+ return collision_mask;
+}
+
+void GridMap::set_collision_mask_bit(int p_bit, bool p_value) {
+ ERR_FAIL_INDEX_MSG(p_bit, 32, "Collision mask bit must be between 0 and 31 inclusive.");
+ uint32_t mask = get_collision_mask();
+ if (p_value) {
+ mask |= 1 << p_bit;
+ } else {
+ mask &= ~(1 << p_bit);
+ }
+ set_collision_mask(mask);
+}
+
+bool GridMap::get_collision_mask_bit(int p_bit) const {
+ ERR_FAIL_INDEX_V_MSG(p_bit, 32, false, "Collision mask bit must be between 0 and 31 inclusive.");
+ return get_collision_mask() & (1 << p_bit);
+}
+
+void GridMap::set_collision_layer_bit(int p_bit, bool p_value) {
+ ERR_FAIL_INDEX_MSG(p_bit, 32, "Collision layer bit must be between 0 and 31 inclusive.");
+ uint32_t layer = get_collision_layer();
+ if (p_value) {
+ layer |= 1 << p_bit;
+ } else {
+ layer &= ~(1 << p_bit);
+ }
+ set_collision_layer(layer);
+}
+
+bool GridMap::get_collision_layer_bit(int p_bit) const {
+ ERR_FAIL_INDEX_V_MSG(p_bit, 32, false, "Collision layer bit must be between 0 and 31 inclusive.");
+ return get_collision_layer() & (1 << p_bit);
+}
+
+void GridMap::set_physics_material(Ref p_material) {
+ physics_material = p_material;
+ _recreate_octant_data();
+}
+
+Ref GridMap::get_physics_material() const {
+ return physics_material;
+}
+
+Array GridMap::get_collision_shapes() const {
+ Array shapes;
+ for (Map::Element *E = octant_map.front(); E; E = E->next()) {
+ Octant *g = E->get();
+ RID body = g->static_body;
+ Transform body_xform = PhysicsServer::get_singleton()->body_get_state(body, PhysicsServer::BODY_STATE_TRANSFORM);
+ int nshapes = PhysicsServer::get_singleton()->body_get_shape_count(body);
+ for (int i = 0; i < nshapes; i++) {
+ RID shape = PhysicsServer::get_singleton()->body_get_shape(body, i);
+ Transform xform = PhysicsServer::get_singleton()->body_get_shape_transform(body, i);
+ shapes.push_back(body_xform * xform);
+ shapes.push_back(shape);
+ }
+ }
+
+ return shapes;
+}
+
+void GridMap::set_bake_navigation(bool p_bake_navigation) {
+ bake_navigation = p_bake_navigation;
+ _recreate_octant_data();
+}
+
+bool GridMap::is_baking_navigation() {
+ return bake_navigation;
+}
+
+void GridMap::set_navigation_layers(uint32_t p_navigation_layers) {
+ navigation_layers = p_navigation_layers;
+ _recreate_octant_data();
+}
+
+uint32_t GridMap::get_navigation_layers() {
+ return navigation_layers;
+}
+
+void GridMap::set_mesh_library(const Ref &p_mesh_library) {
+ if (!mesh_library.is_null()) {
+ mesh_library->unregister_owner(this);
+ }
+ mesh_library = p_mesh_library;
+ if (!mesh_library.is_null()) {
+ mesh_library->register_owner(this);
+ }
+
+ _recreate_octant_data();
+ _change_notify("mesh_library");
+}
+
+Ref GridMap::get_mesh_library() const {
+ return mesh_library;
+}
+
+void GridMap::set_use_in_baked_light(bool p_use_baked_light) {
+ use_in_baked_light = p_use_baked_light;
+}
+
+bool GridMap::get_use_in_baked_light() const {
+ return use_in_baked_light;
+}
+
+void GridMap::set_cell_size(const Vector3 &p_size) {
+ ERR_FAIL_COND(p_size.x < 0.001 || p_size.y < 0.001 || p_size.z < 0.001);
+ cell_size = p_size;
+ _recreate_octant_data();
+ emit_signal("cell_size_changed", cell_size);
+}
+Vector3 GridMap::get_cell_size() const {
+ return cell_size;
+}
+
+void GridMap::set_octant_size(int p_size) {
+ ERR_FAIL_COND(p_size == 0);
+ octant_size = p_size;
+ _recreate_octant_data();
+}
+int GridMap::get_octant_size() const {
+ return octant_size;
+}
+
+void GridMap::set_center_x(bool p_enable) {
+ center_x = p_enable;
+ _recreate_octant_data();
+}
+
+bool GridMap::get_center_x() const {
+ return center_x;
+}
+
+void GridMap::set_center_y(bool p_enable) {
+ center_y = p_enable;
+ _recreate_octant_data();
+}
+
+bool GridMap::get_center_y() const {
+ return center_y;
+}
+
+void GridMap::set_center_z(bool p_enable) {
+ center_z = p_enable;
+ _recreate_octant_data();
+}
+
+bool GridMap::get_center_z() const {
+ return center_z;
+}
+
+void GridMap::set_cell_item(int p_x, int p_y, int p_z, int p_item, int p_rot) {
+ if (baked_meshes.size() && !recreating_octants) {
+ //if you set a cell item, baked meshes go good bye
+ clear_baked_meshes();
+ _recreate_octant_data();
+ }
+
+ ERR_FAIL_INDEX(ABS(p_x), 1 << 20);
+ ERR_FAIL_INDEX(ABS(p_y), 1 << 20);
+ ERR_FAIL_INDEX(ABS(p_z), 1 << 20);
+
+ IndexKey key;
+ key.x = p_x;
+ key.y = p_y;
+ key.z = p_z;
+
+ OctantKey ok;
+ ok.x = p_x / octant_size;
+ ok.y = p_y / octant_size;
+ ok.z = p_z / octant_size;
+
+ if (p_item < 0) {
+ //erase
+ if (cell_map.has(key)) {
+ OctantKey octantkey = ok;
+
+ ERR_FAIL_COND(!octant_map.has(octantkey));
+ Octant &g = *octant_map[octantkey];
+ g.cells.erase(key);
+ g.dirty = true;
+ cell_map.erase(key);
+ _queue_octants_dirty();
+ }
+ return;
+ }
+
+ OctantKey octantkey = ok;
+
+ if (!octant_map.has(octantkey)) {
+ //create octant because it does not exist
+ Octant *g = memnew(Octant);
+ g->dirty = true;
+ g->static_body = RID_PRIME(PhysicsServer::get_singleton()->body_create(PhysicsServer::BODY_MODE_STATIC));
+ PhysicsServer::get_singleton()->body_attach_object_instance_id(g->static_body, get_instance_id());
+ PhysicsServer::get_singleton()->body_set_collision_layer(g->static_body, collision_layer);
+ PhysicsServer::get_singleton()->body_set_collision_mask(g->static_body, collision_mask);
+ if (physics_material.is_valid()) {
+ PhysicsServer::get_singleton()->body_set_param(g->static_body, PhysicsServer::BODY_PARAM_FRICTION, physics_material->get_friction());
+ PhysicsServer::get_singleton()->body_set_param(g->static_body, PhysicsServer::BODY_PARAM_BOUNCE, physics_material->get_bounce());
+ }
+ SceneTree *st = SceneTree::get_singleton();
+
+ if (st && st->is_debugging_collisions_hint()) {
+ g->collision_debug = RID_PRIME(VisualServer::get_singleton()->mesh_create());
+ g->collision_debug_instance = RID_PRIME(VisualServer::get_singleton()->instance_create());
+ VS::get_singleton()->instance_set_portal_mode(g->collision_debug_instance, VisualServer::InstancePortalMode::INSTANCE_PORTAL_MODE_GLOBAL);
+ VisualServer::get_singleton()->instance_set_base(g->collision_debug_instance, g->collision_debug);
+ }
+
+ octant_map[octantkey] = g;
+
+ if (is_inside_world()) {
+ _octant_enter_world(octantkey);
+ _octant_transform(octantkey);
+ }
+ }
+
+ Octant &g = *octant_map[octantkey];
+ g.cells.insert(key);
+ g.dirty = true;
+ _queue_octants_dirty();
+
+ Cell c;
+ c.item = p_item;
+ c.rot = p_rot;
+
+ cell_map[key] = c;
+}
+
+int GridMap::get_cell_item(int p_x, int p_y, int p_z) const {
+ ERR_FAIL_INDEX_V(ABS(p_x), 1 << 20, INVALID_CELL_ITEM);
+ ERR_FAIL_INDEX_V(ABS(p_y), 1 << 20, INVALID_CELL_ITEM);
+ ERR_FAIL_INDEX_V(ABS(p_z), 1 << 20, INVALID_CELL_ITEM);
+
+ IndexKey key;
+ key.x = p_x;
+ key.y = p_y;
+ key.z = p_z;
+
+ if (!cell_map.has(key)) {
+ return INVALID_CELL_ITEM;
+ }
+ return cell_map[key].item;
+}
+
+int GridMap::get_cell_item_orientation(int p_x, int p_y, int p_z) const {
+ ERR_FAIL_INDEX_V(ABS(p_x), 1 << 20, -1);
+ ERR_FAIL_INDEX_V(ABS(p_y), 1 << 20, -1);
+ ERR_FAIL_INDEX_V(ABS(p_z), 1 << 20, -1);
+
+ IndexKey key;
+ key.x = p_x;
+ key.y = p_y;
+ key.z = p_z;
+
+ if (!cell_map.has(key)) {
+ return -1;
+ }
+ return cell_map[key].rot;
+}
+
+Vector3 GridMap::world_to_map(const Vector3 &p_world_pos) const {
+ Vector3 map_pos = p_world_pos / cell_size;
+ map_pos.x = floor(map_pos.x);
+ map_pos.y = floor(map_pos.y);
+ map_pos.z = floor(map_pos.z);
+ return map_pos;
+}
+
+Vector3 GridMap::map_to_world(int p_x, int p_y, int p_z) const {
+ Vector3 offset = _get_offset();
+ Vector3 world_pos(
+ p_x * cell_size.x + offset.x,
+ p_y * cell_size.y + offset.y,
+ p_z * cell_size.z + offset.z);
+ return world_pos;
+}
+
+void GridMap::_octant_transform(const OctantKey &p_key) {
+ ERR_FAIL_COND(!octant_map.has(p_key));
+ Octant &g = *octant_map[p_key];
+ PhysicsServer::get_singleton()->body_set_state(g.static_body, PhysicsServer::BODY_STATE_TRANSFORM, get_global_transform());
+
+ if (g.collision_debug_instance.is_valid()) {
+ VS::get_singleton()->instance_set_transform(g.collision_debug_instance, get_global_transform());
+ }
+
+ // update transform for NavigationServer regions and navigation debugmesh instances
+ if (bake_navigation) {
+ for (Map::Element *E = g.navmesh_ids.front(); E; E = E->next()) {
+ if (E->get().region.is_valid()) {
+ NavigationServer::get_singleton()->region_set_transform(E->get().region, get_global_transform() * E->get().xform);
+ }
+ if (E->get().navmesh_debug_instance.is_valid()) {
+ VS::get_singleton()->instance_set_transform(E->get().navmesh_debug_instance, get_global_transform() * E->get().xform);
+ }
+ }
+ }
+
+ for (int i = 0; i < g.multimesh_instances.size(); i++) {
+ VS::get_singleton()->instance_set_transform(g.multimesh_instances[i].instance, get_global_transform());
+ }
+}
+
+bool GridMap::_octant_update(const OctantKey &p_key) {
+ ERR_FAIL_COND_V(!octant_map.has(p_key), false);
+ Octant &g = *octant_map[p_key];
+ if (!g.dirty) {
+ return false;
+ }
+
+ //erase body shapes
+ PhysicsServer::get_singleton()->body_clear_shapes(g.static_body);
+
+ //erase body shapes debug
+ if (g.collision_debug.is_valid()) {
+ VS::get_singleton()->mesh_clear(g.collision_debug);
+ }
+
+ //erase navigation
+ for (Map::Element *E = g.navmesh_ids.front(); E; E = E->next()) {
+ NavigationServer::get_singleton()->free(E->get().region);
+ if (E->get().navmesh_debug_instance.is_valid()) {
+ VS::get_singleton()->free(E->get().navmesh_debug_instance);
+ }
+ }
+ g.navmesh_ids.clear();
+
+ //erase multimeshes
+
+ for (int i = 0; i < g.multimesh_instances.size(); i++) {
+ if (g.multimesh_instances[i].instance.is_valid()) {
+ VS::get_singleton()->free(g.multimesh_instances[i].instance);
+ }
+ if (g.multimesh_instances[i].multimesh.is_valid()) {
+ VS::get_singleton()->free(g.multimesh_instances[i].multimesh);
+ }
+ }
+ g.multimesh_instances.clear();
+
+ if (g.cells.size() == 0) {
+ //octant no longer needed
+ _octant_clean_up(p_key);
+ return true;
+ }
+
+ PoolVector col_debug;
+
+ /*
+ * foreach item in this octant,
+ * set item's multimesh's instance count to number of cells which have this item
+ * and set said multimesh bounding box to one containing all cells which have this item
+ */
+
+ Map>> multimesh_items;
+
+ for (Set::Element *E = g.cells.front(); E; E = E->next()) {
+ ERR_CONTINUE(!cell_map.has(E->get()));
+ const Cell &c = cell_map[E->get()];
+
+ if (!mesh_library.is_valid() || !mesh_library->has_item(c.item)) {
+ continue;
+ }
+
+ Vector3 cellpos = Vector3(E->get().x, E->get().y, E->get().z);
+ Vector3 ofs = _get_offset();
+
+ Transform xform;
+
+ xform.basis.set_orthogonal_index(c.rot);
+ xform.set_origin(cellpos * cell_size + ofs);
+ xform.basis.scale(Vector3(cell_scale, cell_scale, cell_scale));
+ if (baked_meshes.size() == 0) {
+ if (mesh_library->get_item_mesh(c.item).is_valid()) {
+ if (!multimesh_items.has(c.item)) {
+ multimesh_items[c.item] = List>();
+ }
+
+ Pair p;
+ p.first = xform * mesh_library->get_item_mesh_transform(c.item);
+ p.second = E->get();
+ multimesh_items[c.item].push_back(p);
+ }
+ }
+
+ Vector shapes = mesh_library->get_item_shapes(c.item);
+ // add the item's shape at given xform to octant's static_body
+ for (int i = 0; i < shapes.size(); i++) {
+ // add the item's shape
+ if (!shapes[i].shape.is_valid()) {
+ continue;
+ }
+ PhysicsServer::get_singleton()->body_add_shape(g.static_body, shapes[i].shape->get_rid(), xform * shapes[i].local_transform);
+ if (g.collision_debug.is_valid()) {
+ shapes.write[i].shape->add_vertices_to_array(col_debug, xform * shapes[i].local_transform);
+ }
+ }
+
+ // add the item's navmesh at given xform to GridMap's Navigation ancestor
+ Ref navmesh = mesh_library->get_item_navmesh(c.item);
+ if (navmesh.is_valid()) {
+ Octant::NavMesh nm;
+ nm.xform = xform * mesh_library->get_item_navmesh_transform(c.item);
+
+ if (bake_navigation) {
+ RID region = NavigationServer::get_singleton()->region_create();
+ NavigationServer::get_singleton()->region_set_navigation_layers(region, navigation_layers);
+ NavigationServer::get_singleton()->region_set_navmesh(region, navmesh);
+ NavigationServer::get_singleton()->region_set_transform(region, get_global_transform() * nm.xform);
+ if (navigation) {
+ NavigationServer::get_singleton()->region_set_map(region, navigation->get_rid());
+ } else {
+ NavigationServer::get_singleton()->region_set_map(region, get_world()->get_navigation_map());
+ }
+ nm.region = region;
+
+ // add navigation debugmesh visual instances if debug is enabled
+ SceneTree *st = SceneTree::get_singleton();
+ if (st && st->is_debugging_navigation_hint()) {
+ if (!nm.navmesh_debug_instance.is_valid()) {
+ RID navmesh_debug_rid = navmesh->get_debug_mesh()->get_rid();
+ nm.navmesh_debug_instance = VS::get_singleton()->instance_create();
+ VS::get_singleton()->instance_set_base(nm.navmesh_debug_instance, navmesh_debug_rid);
+ VS::get_singleton()->mesh_surface_set_material(navmesh_debug_rid, 0, st->get_debug_navigation_material()->get_rid());
+ }
+ if (is_inside_tree()) {
+ VS::get_singleton()->instance_set_scenario(nm.navmesh_debug_instance, get_world()->get_scenario());
+ VS::get_singleton()->instance_set_transform(nm.navmesh_debug_instance, get_global_transform() * nm.xform);
+ }
+ }
+ }
+ g.navmesh_ids[E->get()] = nm;
+ }
+ }
+
+ //update multimeshes, only if not baked
+ if (baked_meshes.size() == 0) {
+ for (Map>>::Element *E = multimesh_items.front(); E; E = E->next()) {
+ Octant::MultimeshInstance mmi;
+
+ RID mm = RID_PRIME(VS::get_singleton()->multimesh_create());
+ VS::get_singleton()->multimesh_allocate(mm, E->get().size(), VS::MULTIMESH_TRANSFORM_3D, VS::MULTIMESH_COLOR_NONE);
+ VS::get_singleton()->multimesh_set_mesh(mm, mesh_library->get_item_mesh(E->key())->get_rid());
+
+ int idx = 0;
+ for (List>::Element *F = E->get().front(); F; F = F->next()) {
+ VS::get_singleton()->multimesh_instance_set_transform(mm, idx, F->get().first);
+#ifdef TOOLS_ENABLED
+
+ Octant::MultimeshInstance::Item it;
+ it.index = idx;
+ it.transform = F->get().first;
+ it.key = F->get().second;
+ mmi.items.push_back(it);
+#endif
+
+ idx++;
+ }
+
+ RID instance = RID_PRIME(VS::get_singleton()->instance_create());
+ VS::get_singleton()->instance_set_base(instance, mm);
+ VS::get_singleton()->instance_set_portal_mode(instance, VisualServer::InstancePortalMode::INSTANCE_PORTAL_MODE_GLOBAL);
+
+ if (is_inside_tree()) {
+ VS::get_singleton()->instance_set_scenario(instance, get_world()->get_scenario());
+ VS::get_singleton()->instance_set_transform(instance, get_global_transform());
+ }
+
+ mmi.multimesh = mm;
+ mmi.instance = instance;
+
+ g.multimesh_instances.push_back(mmi);
+ }
+ }
+
+ if (col_debug.size()) {
+ Array arr;
+ arr.resize(VS::ARRAY_MAX);
+ arr[VS::ARRAY_VERTEX] = col_debug;
+
+ VS::get_singleton()->mesh_add_surface_from_arrays(g.collision_debug, VS::PRIMITIVE_LINES, arr);
+ SceneTree *st = SceneTree::get_singleton();
+ if (st) {
+ VS::get_singleton()->mesh_surface_set_material(g.collision_debug, 0, st->get_debug_collision_material()->get_rid());
+ }
+ }
+
+ g.dirty = false;
+
+ return false;
+}
+
+void GridMap::_reset_physic_bodies_collision_filters() {
+ for (Map::Element *E = octant_map.front(); E; E = E->next()) {
+ PhysicsServer::get_singleton()->body_set_collision_layer(E->get()->static_body, collision_layer);
+ PhysicsServer::get_singleton()->body_set_collision_mask(E->get()->static_body, collision_mask);
+ }
+}
+
+void GridMap::_octant_enter_world(const OctantKey &p_key) {
+ ERR_FAIL_COND(!octant_map.has(p_key));
+ Octant &g = *octant_map[p_key];
+ PhysicsServer::get_singleton()->body_set_state(g.static_body, PhysicsServer::BODY_STATE_TRANSFORM, get_global_transform());
+ PhysicsServer::get_singleton()->body_set_space(g.static_body, get_world()->get_space());
+
+ if (g.collision_debug_instance.is_valid()) {
+ VS::get_singleton()->instance_set_scenario(g.collision_debug_instance, get_world()->get_scenario());
+ VS::get_singleton()->instance_set_transform(g.collision_debug_instance, get_global_transform());
+ }
+
+ for (int i = 0; i < g.multimesh_instances.size(); i++) {
+ VS::get_singleton()->instance_set_scenario(g.multimesh_instances[i].instance, get_world()->get_scenario());
+ VS::get_singleton()->instance_set_transform(g.multimesh_instances[i].instance, get_global_transform());
+ }
+
+ if (bake_navigation && mesh_library.is_valid()) {
+ for (Map::Element *E = g.navmesh_ids.front(); E; E = E->next()) {
+ if (cell_map.has(E->key()) && E->get().region.is_valid() == false) {
+ Ref nm = mesh_library->get_item_navmesh(cell_map[E->key()].item);
+ if (nm.is_valid()) {
+ RID region = NavigationServer::get_singleton()->region_create();
+ NavigationServer::get_singleton()->region_set_navigation_layers(region, navigation_layers);
+ NavigationServer::get_singleton()->region_set_navmesh(region, nm);
+ NavigationServer::get_singleton()->region_set_transform(region, get_global_transform() * E->get().xform);
+ if (navigation) {
+ NavigationServer::get_singleton()->region_set_map(region, navigation->get_rid());
+ } else {
+ NavigationServer::get_singleton()->region_set_map(region, get_world()->get_navigation_map());
+ }
+ E->get().region = region;
+ }
+ }
+ }
+ }
+}
+
+void GridMap::_octant_exit_world(const OctantKey &p_key) {
+ ERR_FAIL_COND(!octant_map.has(p_key));
+ Octant &g = *octant_map[p_key];
+ PhysicsServer::get_singleton()->body_set_state(g.static_body, PhysicsServer::BODY_STATE_TRANSFORM, get_global_transform());
+ PhysicsServer::get_singleton()->body_set_space(g.static_body, RID());
+
+ if (g.collision_debug_instance.is_valid()) {
+ VS::get_singleton()->instance_set_scenario(g.collision_debug_instance, RID());
+ }
+
+ for (int i = 0; i < g.multimesh_instances.size(); i++) {
+ VS::get_singleton()->instance_set_scenario(g.multimesh_instances[i].instance, RID());
+ }
+
+ for (Map::Element *E = g.navmesh_ids.front(); E; E = E->next()) {
+ if (E->get().region.is_valid()) {
+ NavigationServer::get_singleton()->free(E->get().region);
+ E->get().region = RID();
+ }
+ if (E->get().navmesh_debug_instance.is_valid()) {
+ VS::get_singleton()->free(E->get().navmesh_debug_instance);
+ E->get().navmesh_debug_instance = RID();
+ }
+ }
+}
+
+void GridMap::_octant_clean_up(const OctantKey &p_key) {
+ ERR_FAIL_COND(!octant_map.has(p_key));
+ Octant &g = *octant_map[p_key];
+
+ if (g.collision_debug.is_valid()) {
+ VS::get_singleton()->free(g.collision_debug);
+ g.collision_debug = RID();
+ }
+
+ if (g.collision_debug_instance.is_valid()) {
+ VS::get_singleton()->free(g.collision_debug_instance);
+ g.collision_debug_instance = RID();
+ }
+
+ if (g.static_body.is_valid()) {
+ PhysicsServer::get_singleton()->free(g.static_body);
+ g.static_body = RID();
+ }
+
+ // Erase navigation
+ for (Map::Element *E = g.navmesh_ids.front(); E; E = E->next()) {
+ if (E->get().region.is_valid()) {
+ NavigationServer::get_singleton()->free(E->get().region);
+ }
+ if (E->get().navmesh_debug_instance.is_valid()) {
+ VS::get_singleton()->free(E->get().navmesh_debug_instance);
+ }
+ }
+ g.navmesh_ids.clear();
+
+ //erase multimeshes
+
+ for (int i = 0; i < g.multimesh_instances.size(); i++) {
+ if (g.multimesh_instances[i].instance.is_valid()) {
+ VS::get_singleton()->free(g.multimesh_instances[i].instance);
+ }
+ if (g.multimesh_instances[i].multimesh.is_valid()) {
+ VS::get_singleton()->free(g.multimesh_instances[i].multimesh);
+ }
+ }
+ g.multimesh_instances.clear();
+}
+
+void GridMap::_notification(int p_what) {
+ switch (p_what) {
+ case NOTIFICATION_ENTER_WORLD: {
+ Spatial *c = this;
+ while (c) {
+ navigation = Object::cast_to(c);
+ if (navigation) {
+ break;
+ }
+
+ c = Object::cast_to(c->get_parent());
+ }
+
+ last_transform = get_global_transform();
+
+ for (Map::Element *E = octant_map.front(); E; E = E->next()) {
+ _octant_enter_world(E->key());
+ }
+
+ for (int i = 0; i < baked_meshes.size(); i++) {
+ VS::get_singleton()->instance_set_scenario(baked_meshes[i].instance, get_world()->get_scenario());
+ VS::get_singleton()->instance_set_transform(baked_meshes[i].instance, get_global_transform());
+ }
+
+ } break;
+ case NOTIFICATION_TRANSFORM_CHANGED: {
+ Transform new_xform = get_global_transform();
+ if (new_xform == last_transform) {
+ break;
+ }
+ //update run
+ for (Map::Element *E = octant_map.front(); E; E = E->next()) {
+ _octant_transform(E->key());
+ }
+
+ last_transform = new_xform;
+
+ for (int i = 0; i < baked_meshes.size(); i++) {
+ VS::get_singleton()->instance_set_transform(baked_meshes[i].instance, get_global_transform());
+ }
+
+ } break;
+ case NOTIFICATION_EXIT_WORLD: {
+ for (Map::Element *E = octant_map.front(); E; E = E->next()) {
+ _octant_exit_world(E->key());
+ }
+
+ navigation = nullptr;
+
+ //_queue_octants_dirty(MAP_DIRTY_INSTANCES|MAP_DIRTY_TRANSFORMS);
+ //_update_octants_callback();
+ //_update_area_instances();
+ for (int i = 0; i < baked_meshes.size(); i++) {
+ VS::get_singleton()->instance_set_scenario(baked_meshes[i].instance, RID());
+ }
+
+ } break;
+ case NOTIFICATION_VISIBILITY_CHANGED: {
+ _update_visibility();
+ } break;
+ }
+}
+
+void GridMap::_update_visibility() {
+ if (!is_inside_tree()) {
+ return;
+ }
+
+ _change_notify("visible");
+
+ for (Map::Element *e = octant_map.front(); e; e = e->next()) {
+ Octant *octant = e->value();
+ for (int i = 0; i < octant->multimesh_instances.size(); i++) {
+ const Octant::MultimeshInstance &mi = octant->multimesh_instances[i];
+ VS::get_singleton()->instance_set_visible(mi.instance, is_visible_in_tree());
+ }
+ }
+
+ for (int i = 0; i < baked_meshes.size(); i++) {
+ VS::get_singleton()->instance_set_visible(baked_meshes[i].instance, is_visible_in_tree());
+ }
+}
+
+void GridMap::_queue_octants_dirty() {
+ if (awaiting_update) {
+ return;
+ }
+
+ MessageQueue::get_singleton()->push_call(this, "_update_octants_callback");
+ awaiting_update = true;
+}
+
+void GridMap::_recreate_octant_data() {
+ recreating_octants = true;
+ Map cell_copy = cell_map;
+ _clear_internal();
+ for (Map::Element *E = cell_copy.front(); E; E = E->next()) {
+ set_cell_item(E->key().x, E->key().y, E->key().z, E->get().item, E->get().rot);
+ }
+ recreating_octants = false;
+}
+
+void GridMap::_clear_internal() {
+ for (Map::Element *E = octant_map.front(); E; E = E->next()) {
+ if (is_inside_world()) {
+ _octant_exit_world(E->key());
+ }
+
+ _octant_clean_up(E->key());
+ memdelete(E->get());
+ }
+
+ octant_map.clear();
+ cell_map.clear();
+}
+
+void GridMap::clear() {
+ _clear_internal();
+ clear_baked_meshes();
+}
+
+void GridMap::resource_changed(const RES &p_res) {
+ _recreate_octant_data();
+}
+
+void GridMap::_update_octants_callback() {
+ if (!awaiting_update) {
+ return;
+ }
+
+ List to_delete;
+ for (Map::Element *E = octant_map.front(); E; E = E->next()) {
+ if (_octant_update(E->key())) {
+ to_delete.push_back(E->key());
+ }
+ }
+
+ while (to_delete.front()) {
+ memdelete(octant_map[to_delete.front()->get()]);
+ octant_map.erase(to_delete.front()->get());
+ to_delete.pop_front();
+ }
+
+ _update_visibility();
+ awaiting_update = false;
+}
+
+void GridMap::_bind_methods() {
+ ClassDB::bind_method(D_METHOD("set_collision_layer", "layer"), &GridMap::set_collision_layer);
+ ClassDB::bind_method(D_METHOD("get_collision_layer"), &GridMap::get_collision_layer);
+
+ ClassDB::bind_method(D_METHOD("set_collision_mask", "mask"), &GridMap::set_collision_mask);
+ ClassDB::bind_method(D_METHOD("get_collision_mask"), &GridMap::get_collision_mask);
+
+ ClassDB::bind_method(D_METHOD("set_collision_mask_bit", "bit", "value"), &GridMap::set_collision_mask_bit);
+ ClassDB::bind_method(D_METHOD("get_collision_mask_bit", "bit"), &GridMap::get_collision_mask_bit);
+
+ ClassDB::bind_method(D_METHOD("set_collision_layer_bit", "bit", "value"), &GridMap::set_collision_layer_bit);
+ ClassDB::bind_method(D_METHOD("get_collision_layer_bit", "bit"), &GridMap::get_collision_layer_bit);
+
+ ClassDB::bind_method(D_METHOD("set_physics_material", "material"), &GridMap::set_physics_material);
+ ClassDB::bind_method(D_METHOD("get_physics_material"), &GridMap::get_physics_material);
+
+ ClassDB::bind_method(D_METHOD("set_bake_navigation", "bake_navigation"), &GridMap::set_bake_navigation);
+ ClassDB::bind_method(D_METHOD("is_baking_navigation"), &GridMap::is_baking_navigation);
+
+ ClassDB::bind_method(D_METHOD("set_navigation_layers", "navigation_layers"), &GridMap::set_navigation_layers);
+ ClassDB::bind_method(D_METHOD("get_navigation_layers"), &GridMap::get_navigation_layers);
+
+ ClassDB::bind_method(D_METHOD("set_mesh_library", "mesh_library"), &GridMap::set_mesh_library);
+ ClassDB::bind_method(D_METHOD("get_mesh_library"), &GridMap::get_mesh_library);
+
+ ClassDB::bind_method(D_METHOD("set_cell_size", "size"), &GridMap::set_cell_size);
+ ClassDB::bind_method(D_METHOD("get_cell_size"), &GridMap::get_cell_size);
+
+ ClassDB::bind_method(D_METHOD("set_cell_scale", "scale"), &GridMap::set_cell_scale);
+ ClassDB::bind_method(D_METHOD("get_cell_scale"), &GridMap::get_cell_scale);
+
+ ClassDB::bind_method(D_METHOD("set_octant_size", "size"), &GridMap::set_octant_size);
+ ClassDB::bind_method(D_METHOD("get_octant_size"), &GridMap::get_octant_size);
+
+ ClassDB::bind_method(D_METHOD("set_cell_item", "x", "y", "z", "item", "orientation"), &GridMap::set_cell_item, DEFVAL(0));
+ ClassDB::bind_method(D_METHOD("get_cell_item", "x", "y", "z"), &GridMap::get_cell_item);
+ ClassDB::bind_method(D_METHOD("get_cell_item_orientation", "x", "y", "z"), &GridMap::get_cell_item_orientation);
+
+ ClassDB::bind_method(D_METHOD("world_to_map", "pos"), &GridMap::world_to_map);
+ ClassDB::bind_method(D_METHOD("map_to_world", "x", "y", "z"), &GridMap::map_to_world);
+
+ ClassDB::bind_method(D_METHOD("_update_octants_callback"), &GridMap::_update_octants_callback);
+ ClassDB::bind_method(D_METHOD("resource_changed", "resource"), &GridMap::resource_changed);
+
+ ClassDB::bind_method(D_METHOD("set_center_x", "enable"), &GridMap::set_center_x);
+ ClassDB::bind_method(D_METHOD("get_center_x"), &GridMap::get_center_x);
+ ClassDB::bind_method(D_METHOD("set_center_y", "enable"), &GridMap::set_center_y);
+ ClassDB::bind_method(D_METHOD("get_center_y"), &GridMap::get_center_y);
+ ClassDB::bind_method(D_METHOD("set_center_z", "enable"), &GridMap::set_center_z);
+ ClassDB::bind_method(D_METHOD("get_center_z"), &GridMap::get_center_z);
+
+ ClassDB::bind_method(D_METHOD("set_clip", "enabled", "clipabove", "floor", "axis"), &GridMap::set_clip, DEFVAL(true), DEFVAL(0), DEFVAL(Vector3::AXIS_X));
+
+ ClassDB::bind_method(D_METHOD("clear"), &GridMap::clear);
+
+ ClassDB::bind_method(D_METHOD("get_used_cells"), &GridMap::get_used_cells);
+ ClassDB::bind_method(D_METHOD("get_used_cells_by_item", "item"), &GridMap::get_used_cells_by_item);
+
+ ClassDB::bind_method(D_METHOD("get_meshes"), &GridMap::get_meshes);
+ ClassDB::bind_method(D_METHOD("get_bake_meshes"), &GridMap::get_bake_meshes);
+ ClassDB::bind_method(D_METHOD("get_bake_mesh_instance", "idx"), &GridMap::get_bake_mesh_instance);
+
+ ClassDB::bind_method(D_METHOD("clear_baked_meshes"), &GridMap::clear_baked_meshes);
+ ClassDB::bind_method(D_METHOD("make_baked_meshes", "gen_lightmap_uv", "lightmap_uv_texel_size"), &GridMap::make_baked_meshes, DEFVAL(false), DEFVAL(0.1));
+
+ ClassDB::bind_method(D_METHOD("set_use_in_baked_light", "use_in_baked_light"), &GridMap::set_use_in_baked_light);
+ ClassDB::bind_method(D_METHOD("get_use_in_baked_light"), &GridMap::get_use_in_baked_light);
+
+ ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "mesh_library", PROPERTY_HINT_RESOURCE_TYPE, "MeshLibrary"), "set_mesh_library", "get_mesh_library");
+ ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "physics_material", PROPERTY_HINT_RESOURCE_TYPE, "PhysicsMaterial"), "set_physics_material", "get_physics_material");
+ ADD_PROPERTY(PropertyInfo(Variant::BOOL, "use_in_baked_light"), "set_use_in_baked_light", "get_use_in_baked_light");
+ ADD_GROUP("Cell", "cell_");
+ ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "cell_size"), "set_cell_size", "get_cell_size");
+ ADD_PROPERTY(PropertyInfo(Variant::INT, "cell_octant_size", PROPERTY_HINT_RANGE, "1,1024,1"), "set_octant_size", "get_octant_size");
+ ADD_PROPERTY(PropertyInfo(Variant::BOOL, "cell_center_x"), "set_center_x", "get_center_x");
+ ADD_PROPERTY(PropertyInfo(Variant::BOOL, "cell_center_y"), "set_center_y", "get_center_y");
+ ADD_PROPERTY(PropertyInfo(Variant::BOOL, "cell_center_z"), "set_center_z", "get_center_z");
+ ADD_PROPERTY(PropertyInfo(Variant::REAL, "cell_scale"), "set_cell_scale", "get_cell_scale");
+ ADD_GROUP("Collision", "collision_");
+ ADD_PROPERTY(PropertyInfo(Variant::INT, "collision_layer", PROPERTY_HINT_LAYERS_3D_PHYSICS), "set_collision_layer", "get_collision_layer");
+ ADD_PROPERTY(PropertyInfo(Variant::INT, "collision_mask", PROPERTY_HINT_LAYERS_3D_PHYSICS), "set_collision_mask", "get_collision_mask");
+ ADD_PROPERTY(PropertyInfo(Variant::BOOL, "bake_navigation"), "set_bake_navigation", "is_baking_navigation");
+ ADD_PROPERTY(PropertyInfo(Variant::INT, "navigation_layers", PROPERTY_HINT_LAYERS_3D_NAVIGATION), "set_navigation_layers", "get_navigation_layers");
+
+ BIND_CONSTANT(INVALID_CELL_ITEM);
+
+ ADD_SIGNAL(MethodInfo("cell_size_changed", PropertyInfo(Variant::VECTOR3, "cell_size")));
+}
+
+void GridMap::set_clip(bool p_enabled, bool p_clip_above, int p_floor, Vector3::Axis p_axis) {
+ if (!p_enabled && !clip) {
+ return;
+ }
+ if (clip && p_enabled && clip_floor == p_floor && p_clip_above == clip_above && p_axis == clip_axis) {
+ return;
+ }
+
+ clip = p_enabled;
+ clip_floor = p_floor;
+ clip_axis = p_axis;
+ clip_above = p_clip_above;
+
+ //make it all update
+ for (Map::Element *E = octant_map.front(); E; E = E->next()) {
+ Octant *g = E->get();
+ g->dirty = true;
+ }
+ awaiting_update = true;
+ _update_octants_callback();
+}
+
+void GridMap::set_cell_scale(float p_scale) {
+ cell_scale = p_scale;
+ _recreate_octant_data();
+}
+
+float GridMap::get_cell_scale() const {
+ return cell_scale;
+}
+
+Array GridMap::get_used_cells() const {
+ Array a;
+ a.resize(cell_map.size());
+ int i = 0;
+ for (Map::Element *E = cell_map.front(); E; E = E->next()) {
+ Vector3 p(E->key().x, E->key().y, E->key().z);
+ a[i++] = p;
+ }
+
+ return a;
+}
+
+Array GridMap::get_used_cells_by_item(int p_item) const {
+ Array a;
+ for (Map::Element *E = cell_map.front(); E; E = E->next()) {
+ if (E->value().item == p_item) {
+ Vector3 p(E->key().x, E->key().y, E->key().z);
+ a.push_back(p);
+ }
+ }
+
+ return a;
+}
+
+Array GridMap::get_meshes() const {
+ if (mesh_library.is_null()) {
+ return Array();
+ }
+
+ Vector3 ofs = _get_offset();
+ Array meshes;
+
+ for (Map::Element *E = cell_map.front(); E; E = E->next()) {
+ int id = E->get().item;
+ if (!mesh_library->has_item(id)) {
+ continue;
+ }
+ Ref mesh = mesh_library->get_item_mesh(id);
+ if (mesh.is_null()) {
+ continue;
+ }
+
+ IndexKey ik = E->key();
+
+ Vector3 cellpos = Vector3(ik.x, ik.y, ik.z);
+
+ Transform xform;
+
+ xform.basis.set_orthogonal_index(E->get().rot);
+
+ xform.set_origin(cellpos * cell_size + ofs);
+ xform.basis.scale(Vector3(cell_scale, cell_scale, cell_scale));
+
+ meshes.push_back(xform * mesh_library->get_item_mesh_transform(id));
+ meshes.push_back(mesh);
+ }
+
+ return meshes;
+}
+
+Vector3 GridMap::_get_offset() const {
+ return Vector3(
+ cell_size.x * 0.5 * int(center_x),
+ cell_size.y * 0.5 * int(center_y),
+ cell_size.z * 0.5 * int(center_z));
+}
+
+void GridMap::clear_baked_meshes() {
+ for (int i = 0; i < baked_meshes.size(); i++) {
+ if (baked_meshes[i].instance.is_valid()) {
+ VS::get_singleton()->free(baked_meshes[i].instance);
+ }
+ }
+ baked_meshes.clear();
+
+ _recreate_octant_data();
+}
+
+void GridMap::make_baked_meshes(bool p_gen_lightmap_uv, float p_lightmap_uv_texel_size) {
+ if (!mesh_library.is_valid()) {
+ return;
+ }
+
+ //generate
+ Map, Ref>> surface_map;
+
+ for (Map::Element *E = cell_map.front(); E; E = E->next()) {
+ IndexKey key = E->key();
+
+ int item = E->get().item;
+ if (!mesh_library->has_item(item)) {
+ continue;
+ }
+
+ Ref mesh = mesh_library->get_item_mesh(item);
+ if (!mesh.is_valid()) {
+ continue;
+ }
+
+ Vector3 cellpos = Vector3(key.x, key.y, key.z);
+ Vector3 ofs = _get_offset();
+
+ Transform xform;
+
+ xform.basis.set_orthogonal_index(E->get().rot);
+ xform.set_origin(cellpos * cell_size + ofs);
+ xform.basis.scale(Vector3(cell_scale, cell_scale, cell_scale));
+
+ OctantKey ok;
+ ok.x = key.x / octant_size;
+ ok.y = key.y / octant_size;
+ ok.z = key.z / octant_size;
+
+ if (!surface_map.has(ok)) {
+ surface_map[ok] = Map, Ref>();
+ }
+
+ Map, Ref> &mat_map = surface_map[ok];
+
+ for (int i = 0; i < mesh->get_surface_count(); i++) {
+ if (mesh->surface_get_primitive_type(i) != Mesh::PRIMITIVE_TRIANGLES) {
+ continue;
+ }
+
+ Ref surf_mat = mesh->surface_get_material(i);
+ if (!mat_map.has(surf_mat)) {
+ Ref st;
+ st.instance();
+ st->begin(Mesh::PRIMITIVE_TRIANGLES);
+ st->set_material(surf_mat);
+ mat_map[surf_mat] = st;
+ }
+
+ mat_map[surf_mat]->append_from(mesh, i, xform);
+ }
+ }
+
+ for (Map, Ref>>::Element *E = surface_map.front(); E; E = E->next()) {
+ Ref mesh;
+ mesh.instance();
+ for (Map, Ref>::Element *F = E->get().front(); F; F = F->next()) {
+ F->get()->commit(mesh);
+ }
+
+ BakedMesh bm;
+ bm.mesh = mesh;
+ bm.instance = RID_PRIME(VS::get_singleton()->instance_create());
+ VS::get_singleton()->instance_set_portal_mode(bm.instance, VisualServer::InstancePortalMode::INSTANCE_PORTAL_MODE_GLOBAL);
+ VS::get_singleton()->get_singleton()->instance_set_base(bm.instance, bm.mesh->get_rid());
+ VS::get_singleton()->instance_attach_object_instance_id(bm.instance, get_instance_id());
+ if (is_inside_tree()) {
+ VS::get_singleton()->instance_set_scenario(bm.instance, get_world()->get_scenario());
+ VS::get_singleton()->instance_set_transform(bm.instance, get_global_transform());
+ }
+
+ if (p_gen_lightmap_uv) {
+ mesh->lightmap_unwrap(get_global_transform(), p_lightmap_uv_texel_size);
+ }
+ baked_meshes.push_back(bm);
+ }
+
+ _recreate_octant_data();
+}
+
+Array GridMap::get_bake_meshes() {
+ if (!use_in_baked_light) {
+ return Array();
+ }
+
+ if (!baked_meshes.size()) {
+ make_baked_meshes(true);
+ }
+
+ Array arr;
+ for (int i = 0; i < baked_meshes.size(); i++) {
+ arr.push_back(baked_meshes[i].mesh);
+ arr.push_back(Transform());
+ }
+
+ return arr;
+}
+
+RID GridMap::get_bake_mesh_instance(int p_idx) {
+ ERR_FAIL_INDEX_V(p_idx, baked_meshes.size(), RID());
+ return baked_meshes[p_idx].instance;
+}
+
+GridMap::GridMap() {
+ collision_layer = 1;
+ collision_mask = 1;
+
+ cell_size = Vector3(2, 2, 2);
+ octant_size = 8;
+ awaiting_update = false;
+ _in_tree = false;
+ center_x = true;
+ center_y = true;
+ center_z = true;
+
+ clip = false;
+ clip_floor = 0;
+ clip_axis = Vector3::AXIS_Z;
+ clip_above = true;
+ cell_scale = 1.0;
+
+ navigation = nullptr;
+ set_notify_transform(true);
+ recreating_octants = false;
+
+ use_in_baked_light = false;
+}
+
+GridMap::~GridMap() {
+ if (!mesh_library.is_null()) {
+ mesh_library->unregister_owner(this);
+ }
+
+ clear();
+}
diff --git a/modules/gridmap/grid_map.h b/modules/gridmap/grid_map.h
new file mode 100644
index 000000000..b0ebe18bb
--- /dev/null
+++ b/modules/gridmap/grid_map.h
@@ -0,0 +1,287 @@
+/*************************************************************************/
+/* grid_map.h */
+/*************************************************************************/
+/* This file is part of: */
+/* GODOT ENGINE */
+/* https://godotengine.org */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md). */
+/* */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the */
+/* "Software"), to deal in the Software without restriction, including */
+/* without limitation the rights to use, copy, modify, merge, publish, */
+/* distribute, sublicense, and/or sell copies of the Software, and to */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions: */
+/* */
+/* The above copyright notice and this permission notice shall be */
+/* included in all copies or substantial portions of the Software. */
+/* */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
+/*************************************************************************/
+
+#ifndef GRID_MAP_H
+#define GRID_MAP_H
+
+#include "scene/3d/navigation.h"
+#include "scene/3d/spatial.h"
+#include "scene/resources/mesh_library.h"
+#include "scene/resources/multimesh.h"
+
+//heh heh, godotsphir!! this shares no code and the design is completely different with previous projects i've done..
+//should scale better with hardware that supports instancing
+
+class PhysicsMaterial;
+
+class GridMap : public Spatial {
+ GDCLASS(GridMap, Spatial);
+
+ enum {
+ MAP_DIRTY_TRANSFORMS = 1,
+ MAP_DIRTY_INSTANCES = 2,
+ };
+
+ union IndexKey {
+ struct {
+ int16_t x;
+ int16_t y;
+ int16_t z;
+ };
+ uint64_t key;
+
+ _FORCE_INLINE_ bool operator<(const IndexKey &p_key) const {
+ return key < p_key.key;
+ }
+
+ IndexKey() { key = 0; }
+ };
+
+ /**
+ * @brief A Cell is a single cell in the cube map space; it is defined by its coordinates and the populating Item, identified by int id.
+ */
+ union Cell {
+ struct {
+ unsigned int item : 16;
+ unsigned int rot : 5;
+ unsigned int layer : 8;
+ };
+ uint32_t cell;
+
+ Cell() {
+ item = 0;
+ rot = 0;
+ layer = 0;
+ }
+ };
+
+ /**
+ * @brief An Octant is a prism containing Cells, and possibly belonging to an Area.
+ * A GridMap can have multiple Octants.
+ */
+ struct Octant {
+ struct NavMesh {
+ RID region;
+ Transform xform;
+ RID navmesh_debug_instance;
+ };
+
+ struct MultimeshInstance {
+ RID instance;
+ RID multimesh;
+ struct Item {
+ int index;
+ Transform transform;
+ IndexKey key;
+ };
+
+ Vector- items; //tools only, for changing visibility
+ };
+
+ Vector multimesh_instances;
+ Set cells;
+ RID collision_debug;
+ RID collision_debug_instance;
+
+ bool dirty;
+ RID static_body;
+ Map navmesh_ids;
+ };
+
+ union OctantKey {
+ struct {
+ int16_t x;
+ int16_t y;
+ int16_t z;
+ int16_t empty;
+ };
+
+ uint64_t key;
+
+ _FORCE_INLINE_ bool operator<(const OctantKey &p_key) const {
+ return key < p_key.key;
+ }
+
+ //OctantKey(const IndexKey& p_k, int p_item) { indexkey=p_k.key; item=p_item; }
+ OctantKey() { key = 0; }
+ };
+
+ uint32_t collision_layer;
+ uint32_t collision_mask;
+ Ref physics_material;
+ bool bake_navigation = false;
+ uint32_t navigation_layers = 1;
+
+ Transform last_transform;
+
+ bool _in_tree;
+ Vector3 cell_size;
+ int octant_size;
+ bool center_x, center_y, center_z;
+ float cell_scale;
+ Navigation *navigation;
+
+ bool clip;
+ bool clip_above;
+ int clip_floor;
+
+ bool recreating_octants;
+
+ Vector3::Axis clip_axis;
+
+ Ref mesh_library;
+ bool use_in_baked_light;
+
+ Map octant_map;
+ Map cell_map;
+
+ void _recreate_octant_data();
+
+ struct BakeLight {
+ VS::LightType type;
+ Vector3 pos;
+ Vector3 dir;
+ float param[VS::LIGHT_PARAM_MAX];
+ };
+
+ _FORCE_INLINE_ Vector3 _octant_get_offset(const OctantKey &p_key) const {
+ return Vector3(p_key.x, p_key.y, p_key.z) * cell_size * octant_size;
+ }
+
+ void _reset_physic_bodies_collision_filters();
+ void _octant_enter_world(const OctantKey &p_key);
+ void _octant_exit_world(const OctantKey &p_key);
+ bool _octant_update(const OctantKey &p_key);
+ void _octant_clean_up(const OctantKey &p_key);
+ void _octant_transform(const OctantKey &p_key);
+ bool awaiting_update;
+
+ void _queue_octants_dirty();
+ void _update_octants_callback();
+
+ void resource_changed(const RES &p_res);
+
+ void _clear_internal();
+
+ Vector3 _get_offset() const;
+
+ struct BakedMesh {
+ Ref mesh;
+ RID instance;
+ };
+
+ Vector baked_meshes;
+
+protected:
+ bool _set(const StringName &p_name, const Variant &p_value);
+ bool _get(const StringName &p_name, Variant &r_ret) const;
+ void _get_property_list(List *p_list) const;
+
+ void _notification(int p_what);
+ void _update_visibility();
+ static void _bind_methods();
+
+public:
+ enum {
+ INVALID_CELL_ITEM = -1
+ };
+
+ void set_collision_layer(uint32_t p_layer);
+ uint32_t get_collision_layer() const;
+
+ void set_collision_mask(uint32_t p_mask);
+ uint32_t get_collision_mask() const;
+
+ void set_collision_layer_bit(int p_bit, bool p_value);
+ bool get_collision_layer_bit(int p_bit) const;
+
+ void set_collision_mask_bit(int p_bit, bool p_value);
+ bool get_collision_mask_bit(int p_bit) const;
+
+ void set_physics_material(Ref p_material);
+ Ref get_physics_material() const;
+
+ Array get_collision_shapes() const;
+
+ void set_bake_navigation(bool p_bake_navigation);
+ bool is_baking_navigation();
+
+ void set_navigation_layers(uint32_t p_navigation_layers);
+ uint32_t get_navigation_layers();
+
+ void set_mesh_library(const Ref &p_mesh_library);
+ Ref get_mesh_library() const;
+
+ void set_use_in_baked_light(bool p_use_baked_light);
+ bool get_use_in_baked_light() const;
+
+ void set_cell_size(const Vector3 &p_size);
+ Vector3 get_cell_size() const;
+
+ void set_octant_size(int p_size);
+ int get_octant_size() const;
+
+ void set_center_x(bool p_enable);
+ bool get_center_x() const;
+ void set_center_y(bool p_enable);
+ bool get_center_y() const;
+ void set_center_z(bool p_enable);
+ bool get_center_z() const;
+
+ void set_cell_item(int p_x, int p_y, int p_z, int p_item, int p_rot = 0);
+ int get_cell_item(int p_x, int p_y, int p_z) const;
+ int get_cell_item_orientation(int p_x, int p_y, int p_z) const;
+
+ Vector3 world_to_map(const Vector3 &p_world_pos) const;
+ Vector3 map_to_world(int p_x, int p_y, int p_z) const;
+
+ void set_clip(bool p_enabled, bool p_clip_above = true, int p_floor = 0, Vector3::Axis p_axis = Vector3::AXIS_X);
+
+ void set_cell_scale(float p_scale);
+ float get_cell_scale() const;
+
+ Array get_used_cells() const;
+ Array get_used_cells_by_item(int p_item) const;
+
+ Array get_meshes() const;
+
+ void clear_baked_meshes();
+ void make_baked_meshes(bool p_gen_lightmap_uv = false, float p_lightmap_uv_texel_size = 0.1);
+
+ void clear();
+
+ Array get_bake_meshes();
+ RID get_bake_mesh_instance(int p_idx);
+
+ GridMap();
+ ~GridMap();
+};
+
+#endif // GRID_MAP_H
diff --git a/modules/gridmap/grid_map_editor_plugin.cpp b/modules/gridmap/grid_map_editor_plugin.cpp
new file mode 100644
index 000000000..20bcefbe5
--- /dev/null
+++ b/modules/gridmap/grid_map_editor_plugin.cpp
@@ -0,0 +1,1564 @@
+/*************************************************************************/
+/* grid_map_editor_plugin.cpp */
+/*************************************************************************/
+/* This file is part of: */
+/* GODOT ENGINE */
+/* https://godotengine.org */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md). */
+/* */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the */
+/* "Software"), to deal in the Software without restriction, including */
+/* without limitation the rights to use, copy, modify, merge, publish, */
+/* distribute, sublicense, and/or sell copies of the Software, and to */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions: */
+/* */
+/* The above copyright notice and this permission notice shall be */
+/* included in all copies or substantial portions of the Software. */
+/* */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
+/*************************************************************************/
+
+#include "grid_map_editor_plugin.h"
+#include "core/os/input.h"
+#include "editor/editor_scale.h"
+#include "editor/editor_settings.h"
+#include "editor/plugins/spatial_editor_plugin.h"
+#include "scene/3d/camera.h"
+
+#include "core/math/geometry.h"
+#include "core/os/keyboard.h"
+
+void GridMapEditor::_node_removed(Node *p_node) {
+ if (p_node == node) {
+ node = nullptr;
+ }
+}
+
+void GridMapEditor::_configure() {
+ if (!node) {
+ return;
+ }
+
+ update_grid();
+}
+
+void GridMapEditor::_menu_option(int p_option) {
+ switch (p_option) {
+ case MENU_OPTION_PREV_LEVEL: {
+ floor->set_value(floor->get_value() - 1);
+ } break;
+
+ case MENU_OPTION_NEXT_LEVEL: {
+ floor->set_value(floor->get_value() + 1);
+ } break;
+
+ case MENU_OPTION_LOCK_VIEW: {
+ int index = options->get_popup()->get_item_index(MENU_OPTION_LOCK_VIEW);
+ lock_view = !options->get_popup()->is_item_checked(index);
+
+ options->get_popup()->set_item_checked(index, lock_view);
+ } break;
+ case MENU_OPTION_CLIP_DISABLED:
+ case MENU_OPTION_CLIP_ABOVE:
+ case MENU_OPTION_CLIP_BELOW: {
+ clip_mode = ClipMode(p_option - MENU_OPTION_CLIP_DISABLED);
+ for (int i = 0; i < 3; i++) {
+ int index = options->get_popup()->get_item_index(MENU_OPTION_CLIP_DISABLED + i);
+ options->get_popup()->set_item_checked(index, i == clip_mode);
+ }
+
+ _update_clip();
+ } break;
+ case MENU_OPTION_X_AXIS:
+ case MENU_OPTION_Y_AXIS:
+ case MENU_OPTION_Z_AXIS: {
+ int new_axis = p_option - MENU_OPTION_X_AXIS;
+ for (int i = 0; i < 3; i++) {
+ int idx = options->get_popup()->get_item_index(MENU_OPTION_X_AXIS + i);
+ options->get_popup()->set_item_checked(idx, i == new_axis);
+ }
+
+ if (edit_axis != new_axis) {
+ int item1 = options->get_popup()->get_item_index(MENU_OPTION_NEXT_LEVEL);
+ int item2 = options->get_popup()->get_item_index(MENU_OPTION_PREV_LEVEL);
+ if (edit_axis == Vector3::AXIS_Y) {
+ options->get_popup()->set_item_text(item1, TTR("Next Plane"));
+ options->get_popup()->set_item_text(item2, TTR("Previous Plane"));
+ spin_box_label->set_text(TTR("Plane:"));
+ } else if (new_axis == Vector3::AXIS_Y) {
+ options->get_popup()->set_item_text(item1, TTR("Next Floor"));
+ options->get_popup()->set_item_text(item2, TTR("Previous Floor"));
+ spin_box_label->set_text(TTR("Floor:"));
+ }
+ }
+ edit_axis = Vector3::Axis(new_axis);
+ update_grid();
+ _update_clip();
+
+ } break;
+ case MENU_OPTION_CURSOR_ROTATE_Y: {
+ Basis r;
+ if (input_action == INPUT_PASTE) {
+ r.set_orthogonal_index(paste_indicator.orientation);
+ r.rotate(Vector3(0, 1, 0), -Math_PI / 2.0);
+ paste_indicator.orientation = r.get_orthogonal_index();
+ _update_paste_indicator();
+ break;
+ }
+
+ r.set_orthogonal_index(cursor_rot);
+ r.rotate(Vector3(0, 1, 0), -Math_PI / 2.0);
+ cursor_rot = r.get_orthogonal_index();
+ _update_cursor_transform();
+ } break;
+ case MENU_OPTION_CURSOR_ROTATE_X: {
+ Basis r;
+ if (input_action == INPUT_PASTE) {
+ r.set_orthogonal_index(paste_indicator.orientation);
+ r.rotate(Vector3(1, 0, 0), -Math_PI / 2.0);
+ paste_indicator.orientation = r.get_orthogonal_index();
+ _update_paste_indicator();
+ break;
+ }
+
+ r.set_orthogonal_index(cursor_rot);
+ r.rotate(Vector3(1, 0, 0), -Math_PI / 2.0);
+ cursor_rot = r.get_orthogonal_index();
+ _update_cursor_transform();
+ } break;
+ case MENU_OPTION_CURSOR_ROTATE_Z: {
+ Basis r;
+ if (input_action == INPUT_PASTE) {
+ r.set_orthogonal_index(paste_indicator.orientation);
+ r.rotate(Vector3(0, 0, 1), -Math_PI / 2.0);
+ paste_indicator.orientation = r.get_orthogonal_index();
+ _update_paste_indicator();
+ break;
+ }
+
+ r.set_orthogonal_index(cursor_rot);
+ r.rotate(Vector3(0, 0, 1), -Math_PI / 2.0);
+ cursor_rot = r.get_orthogonal_index();
+ _update_cursor_transform();
+ } break;
+ case MENU_OPTION_CURSOR_BACK_ROTATE_Y: {
+ Basis r;
+ if (input_action == INPUT_PASTE) {
+ r.set_orthogonal_index(paste_indicator.orientation);
+ r.rotate(Vector3(0, 1, 0), Math_PI / 2.0);
+ paste_indicator.orientation = r.get_orthogonal_index();
+ _update_paste_indicator();
+ break;
+ }
+
+ r.set_orthogonal_index(cursor_rot);
+ r.rotate(Vector3(0, 1, 0), Math_PI / 2.0);
+ cursor_rot = r.get_orthogonal_index();
+ _update_cursor_transform();
+ } break;
+ case MENU_OPTION_CURSOR_BACK_ROTATE_X: {
+ Basis r;
+ if (input_action == INPUT_PASTE) {
+ r.set_orthogonal_index(paste_indicator.orientation);
+ r.rotate(Vector3(1, 0, 0), Math_PI / 2.0);
+ paste_indicator.orientation = r.get_orthogonal_index();
+ _update_paste_indicator();
+ break;
+ }
+
+ r.set_orthogonal_index(cursor_rot);
+ r.rotate(Vector3(1, 0, 0), Math_PI / 2.0);
+ cursor_rot = r.get_orthogonal_index();
+ _update_cursor_transform();
+ } break;
+ case MENU_OPTION_CURSOR_BACK_ROTATE_Z: {
+ Basis r;
+ if (input_action == INPUT_PASTE) {
+ r.set_orthogonal_index(paste_indicator.orientation);
+ r.rotate(Vector3(0, 0, 1), Math_PI / 2.0);
+ paste_indicator.orientation = r.get_orthogonal_index();
+ _update_paste_indicator();
+ break;
+ }
+
+ r.set_orthogonal_index(cursor_rot);
+ r.rotate(Vector3(0, 0, 1), Math_PI / 2.0);
+ cursor_rot = r.get_orthogonal_index();
+ _update_cursor_transform();
+ } break;
+ case MENU_OPTION_CURSOR_CLEAR_ROTATION: {
+ if (input_action == INPUT_PASTE) {
+ paste_indicator.orientation = 0;
+ _update_paste_indicator();
+ break;
+ }
+
+ cursor_rot = 0;
+ _update_cursor_transform();
+ } break;
+
+ case MENU_OPTION_PASTE_SELECTS: {
+ int idx = options->get_popup()->get_item_index(MENU_OPTION_PASTE_SELECTS);
+ options->get_popup()->set_item_checked(idx, !options->get_popup()->is_item_checked(idx));
+ } break;
+
+ case MENU_OPTION_SELECTION_DUPLICATE:
+ case MENU_OPTION_SELECTION_CUT: {
+ if (!(selection.active && input_action == INPUT_NONE)) {
+ break;
+ }
+
+ _set_clipboard_data();
+
+ if (p_option == MENU_OPTION_SELECTION_CUT) {
+ _delete_selection();
+ }
+
+ input_action = INPUT_PASTE;
+ paste_indicator.click = selection.begin;
+ paste_indicator.current = selection.begin;
+ paste_indicator.begin = selection.begin;
+ paste_indicator.end = selection.end;
+ paste_indicator.orientation = 0;
+ _update_paste_indicator();
+ } break;
+ case MENU_OPTION_SELECTION_CLEAR: {
+ if (!selection.active) {
+ break;
+ }
+
+ _delete_selection();
+
+ } break;
+ case MENU_OPTION_SELECTION_FILL: {
+ if (!selection.active) {
+ return;
+ }
+
+ _fill_selection();
+
+ } break;
+ case MENU_OPTION_GRIDMAP_SETTINGS: {
+ settings_dialog->popup_centered(settings_vbc->get_combined_minimum_size() + Size2(50, 50) * EDSCALE);
+ } break;
+ }
+}
+
+void GridMapEditor::_update_cursor_transform() {
+ cursor_transform = Transform();
+ cursor_transform.origin = cursor_origin;
+ cursor_transform.basis.set_orthogonal_index(cursor_rot);
+ cursor_transform.basis *= node->get_cell_scale();
+ cursor_transform = node->get_global_transform() * cursor_transform;
+
+ if (selected_palette >= 0) {
+ if (node && !node->get_mesh_library().is_null()) {
+ cursor_transform *= node->get_mesh_library()->get_item_mesh_transform(selected_palette);
+ }
+ }
+
+ if (cursor_instance.is_valid()) {
+ VisualServer::get_singleton()->instance_set_transform(cursor_instance, cursor_transform);
+ VisualServer::get_singleton()->instance_set_visible(cursor_instance, cursor_visible);
+ }
+}
+
+void GridMapEditor::_update_selection_transform() {
+ Transform xf_zero;
+ xf_zero.basis.set_zero();
+
+ if (!selection.active) {
+ VisualServer::get_singleton()->instance_set_transform(selection_instance, xf_zero);
+ for (int i = 0; i < 3; i++) {
+ VisualServer::get_singleton()->instance_set_transform(selection_level_instance[i], xf_zero);
+ }
+ return;
+ }
+
+ Transform xf;
+ xf.scale((Vector3(1, 1, 1) + (selection.end - selection.begin)) * node->get_cell_size());
+ xf.origin = selection.begin * node->get_cell_size();
+
+ VisualServer::get_singleton()->instance_set_transform(selection_instance, node->get_global_transform() * xf);
+
+ for (int i = 0; i < 3; i++) {
+ if (i != edit_axis || (edit_floor[edit_axis] < selection.begin[edit_axis]) || (edit_floor[edit_axis] > selection.end[edit_axis] + 1)) {
+ VisualServer::get_singleton()->instance_set_transform(selection_level_instance[i], xf_zero);
+ } else {
+ Vector3 scale = (selection.end - selection.begin + Vector3(1, 1, 1));
+ scale[edit_axis] = 1.0;
+ Vector3 pos = selection.begin;
+ pos[edit_axis] = edit_floor[edit_axis];
+
+ scale *= node->get_cell_size();
+ pos *= node->get_cell_size();
+
+ Transform xf2;
+ xf2.basis.scale(scale);
+ xf2.origin = pos;
+
+ VisualServer::get_singleton()->instance_set_transform(selection_level_instance[i], xf2);
+ }
+ }
+}
+
+void GridMapEditor::_validate_selection() {
+ if (!selection.active) {
+ return;
+ }
+ selection.begin = selection.click;
+ selection.end = selection.current;
+
+ if (selection.begin.x > selection.end.x) {
+ SWAP(selection.begin.x, selection.end.x);
+ }
+ if (selection.begin.y > selection.end.y) {
+ SWAP(selection.begin.y, selection.end.y);
+ }
+ if (selection.begin.z > selection.end.z) {
+ SWAP(selection.begin.z, selection.end.z);
+ }
+
+ _update_selection_transform();
+}
+
+void GridMapEditor::_set_selection(bool p_active, const Vector3 &p_begin, const Vector3 &p_end) {
+ selection.active = p_active;
+ selection.begin = p_begin;
+ selection.end = p_end;
+ selection.click = p_begin;
+ selection.current = p_end;
+
+ if (is_visible_in_tree()) {
+ _update_selection_transform();
+ }
+
+ options->get_popup()->set_item_disabled(options->get_popup()->get_item_index(MENU_OPTION_SELECTION_CLEAR), !selection.active);
+ options->get_popup()->set_item_disabled(options->get_popup()->get_item_index(MENU_OPTION_SELECTION_CUT), !selection.active);
+ options->get_popup()->set_item_disabled(options->get_popup()->get_item_index(MENU_OPTION_SELECTION_DUPLICATE), !selection.active);
+ options->get_popup()->set_item_disabled(options->get_popup()->get_item_index(MENU_OPTION_SELECTION_FILL), !selection.active);
+}
+
+bool GridMapEditor::do_input_action(Camera *p_camera, const Point2 &p_point, bool p_click) {
+ if (!spatial_editor) {
+ return false;
+ }
+
+ if (selected_palette < 0 && input_action != INPUT_PICK && input_action != INPUT_SELECT && input_action != INPUT_PASTE) {
+ return false;
+ }
+ Ref mesh_library = node->get_mesh_library();
+ if (mesh_library.is_null()) {
+ return false;
+ }
+ if (input_action != INPUT_PICK && input_action != INPUT_SELECT && input_action != INPUT_PASTE && !mesh_library->has_item(selected_palette)) {
+ return false;
+ }
+
+ Camera *camera = p_camera;
+ Vector3 from = camera->project_ray_origin(p_point);
+ Vector3 normal = camera->project_ray_normal(p_point);
+ Transform local_xform = node->get_global_transform().affine_inverse();
+ Vector planes = camera->get_frustum();
+ from = local_xform.xform(from);
+ normal = local_xform.basis.xform(normal).normalized();
+
+ Plane p;
+ p.normal[edit_axis] = 1.0;
+ p.d = edit_floor[edit_axis] * node->get_cell_size()[edit_axis];
+
+ Vector3 inters;
+ if (!p.intersects_segment(from, from + normal * settings_pick_distance->get_value(), &inters)) {
+ return false;
+ }
+
+ // Make sure the intersection is inside the frustum planes, to avoid
+ // Painting on invisible regions.
+ for (int i = 0; i < planes.size(); i++) {
+ Plane fp = local_xform.xform(planes[i]);
+ if (fp.is_point_over(inters)) {
+ return false;
+ }
+ }
+
+ int cell[3];
+ float cell_size[3] = { node->get_cell_size().x, node->get_cell_size().y, node->get_cell_size().z };
+
+ for (int i = 0; i < 3; i++) {
+ if (i == edit_axis) {
+ cell[i] = edit_floor[i];
+ } else {
+ cell[i] = inters[i] / node->get_cell_size()[i];
+ if (inters[i] < 0) {
+ cell[i] -= 1; // Compensate negative.
+ }
+ grid_ofs[i] = cell[i] * cell_size[i];
+ }
+ }
+
+ VS::get_singleton()->instance_set_transform(grid_instance[edit_axis], node->get_global_transform() * edit_grid_xform);
+
+ if (cursor_instance.is_valid()) {
+ cursor_origin = (Vector3(cell[0], cell[1], cell[2]) + Vector3(0.5 * node->get_center_x(), 0.5 * node->get_center_y(), 0.5 * node->get_center_z())) * node->get_cell_size();
+ cursor_visible = true;
+
+ if (input_action == INPUT_SELECT || input_action == INPUT_PASTE) {
+ cursor_visible = false;
+ }
+
+ _update_cursor_transform();
+ }
+
+ if (input_action == INPUT_PASTE) {
+ paste_indicator.current = Vector3(cell[0], cell[1], cell[2]);
+ _update_paste_indicator();
+
+ } else if (input_action == INPUT_SELECT) {
+ selection.current = Vector3(cell[0], cell[1], cell[2]);
+ if (p_click) {
+ selection.click = selection.current;
+ }
+ selection.active = true;
+ _validate_selection();
+
+ return true;
+ } else if (input_action == INPUT_PICK) {
+ int item = node->get_cell_item(cell[0], cell[1], cell[2]);
+ if (item >= 0) {
+ selected_palette = item;
+ mesh_library_palette->set_current(item);
+ update_palette();
+ _update_cursor_instance();
+ }
+ return true;
+ }
+ if (input_action == INPUT_PAINT) {
+ SetItem si;
+ si.pos = Vector3(cell[0], cell[1], cell[2]);
+ si.new_value = selected_palette;
+ si.new_orientation = cursor_rot;
+ si.old_value = node->get_cell_item(cell[0], cell[1], cell[2]);
+ si.old_orientation = node->get_cell_item_orientation(cell[0], cell[1], cell[2]);
+ set_items.push_back(si);
+ node->set_cell_item(cell[0], cell[1], cell[2], selected_palette, cursor_rot);
+ return true;
+ } else if (input_action == INPUT_ERASE) {
+ SetItem si;
+ si.pos = Vector3(cell[0], cell[1], cell[2]);
+ si.new_value = -1;
+ si.new_orientation = 0;
+ si.old_value = node->get_cell_item(cell[0], cell[1], cell[2]);
+ si.old_orientation = node->get_cell_item_orientation(cell[0], cell[1], cell[2]);
+ set_items.push_back(si);
+ node->set_cell_item(cell[0], cell[1], cell[2], -1);
+ return true;
+ }
+
+ return false;
+}
+
+void GridMapEditor::_delete_selection() {
+ if (!selection.active) {
+ return;
+ }
+
+ undo_redo->create_action(TTR("GridMap Delete Selection"));
+ for (int i = selection.begin.x; i <= selection.end.x; i++) {
+ for (int j = selection.begin.y; j <= selection.end.y; j++) {
+ for (int k = selection.begin.z; k <= selection.end.z; k++) {
+ undo_redo->add_do_method(node, "set_cell_item", i, j, k, GridMap::INVALID_CELL_ITEM);
+ undo_redo->add_undo_method(node, "set_cell_item", i, j, k, node->get_cell_item(i, j, k), node->get_cell_item_orientation(i, j, k));
+ }
+ }
+ }
+ undo_redo->add_do_method(this, "_set_selection", !selection.active, selection.begin, selection.end);
+ undo_redo->add_undo_method(this, "_set_selection", selection.active, selection.begin, selection.end);
+ undo_redo->commit_action();
+}
+
+void GridMapEditor::_fill_selection() {
+ if (!selection.active) {
+ return;
+ }
+
+ undo_redo->create_action(TTR("GridMap Fill Selection"));
+ for (int i = selection.begin.x; i <= selection.end.x; i++) {
+ for (int j = selection.begin.y; j <= selection.end.y; j++) {
+ for (int k = selection.begin.z; k <= selection.end.z; k++) {
+ undo_redo->add_do_method(node, "set_cell_item", i, j, k, selected_palette, cursor_rot);
+ undo_redo->add_undo_method(node, "set_cell_item", i, j, k, node->get_cell_item(i, j, k), node->get_cell_item_orientation(i, j, k));
+ }
+ }
+ }
+ undo_redo->add_do_method(this, "_set_selection", !selection.active, selection.begin, selection.end);
+ undo_redo->add_undo_method(this, "_set_selection", selection.active, selection.begin, selection.end);
+ undo_redo->commit_action();
+}
+
+void GridMapEditor::_clear_clipboard_data() {
+ for (List::Element *E = clipboard_items.front(); E; E = E->next()) {
+ if (E->get().instance.is_valid()) {
+ VisualServer::get_singleton()->free(E->get().instance);
+ }
+ }
+
+ clipboard_items.clear();
+}
+
+void GridMapEditor::_set_clipboard_data() {
+ _clear_clipboard_data();
+
+ Ref meshLibrary = node->get_mesh_library();
+
+ for (int i = selection.begin.x; i <= selection.end.x; i++) {
+ for (int j = selection.begin.y; j <= selection.end.y; j++) {
+ for (int k = selection.begin.z; k <= selection.end.z; k++) {
+ int itm = node->get_cell_item(i, j, k);
+ if (itm == GridMap::INVALID_CELL_ITEM) {
+ continue;
+ }
+
+ Ref mesh = meshLibrary->get_item_mesh(itm);
+
+ ClipboardItem item;
+ item.cell_item = itm;
+ item.grid_offset = Vector3(i, j, k) - selection.begin;
+ item.orientation = node->get_cell_item_orientation(i, j, k);
+ item.instance = VisualServer::get_singleton()->instance_create2(mesh->get_rid(), get_tree()->get_root()->get_world()->get_scenario());
+
+ clipboard_items.push_back(item);
+ }
+ }
+ }
+}
+
+void GridMapEditor::_update_paste_indicator() {
+ if (input_action != INPUT_PASTE) {
+ Transform xf;
+ xf.basis.set_zero();
+ VisualServer::get_singleton()->instance_set_transform(paste_instance, xf);
+ return;
+ }
+
+ Vector3 center = 0.5 * Vector3(float(node->get_center_x()), float(node->get_center_y()), float(node->get_center_z()));
+ Vector3 scale = (Vector3(1, 1, 1) + (paste_indicator.end - paste_indicator.begin)) * node->get_cell_size();
+ Transform xf;
+ xf.scale(scale);
+ xf.origin = (paste_indicator.begin + (paste_indicator.current - paste_indicator.click) + center) * node->get_cell_size();
+ Basis rot;
+ rot.set_orthogonal_index(paste_indicator.orientation);
+ xf.basis = rot * xf.basis;
+ xf.translate((-center * node->get_cell_size()) / scale);
+
+ VisualServer::get_singleton()->instance_set_transform(paste_instance, node->get_global_transform() * xf);
+
+ for (List::Element *E = clipboard_items.front(); E; E = E->next()) {
+ ClipboardItem &item = E->get();
+
+ xf = Transform();
+ xf.origin = (paste_indicator.begin + (paste_indicator.current - paste_indicator.click) + center) * node->get_cell_size();
+ xf.basis = rot * xf.basis;
+ xf.translate(item.grid_offset * node->get_cell_size());
+
+ Basis item_rot;
+ item_rot.set_orthogonal_index(item.orientation);
+ xf.basis = item_rot * xf.basis * node->get_cell_scale();
+
+ VisualServer::get_singleton()->instance_set_transform(item.instance, node->get_global_transform() * xf);
+ }
+}
+
+void GridMapEditor::_do_paste() {
+ int idx = options->get_popup()->get_item_index(MENU_OPTION_PASTE_SELECTS);
+ bool reselect = options->get_popup()->is_item_checked(idx);
+
+ Basis rot;
+ rot.set_orthogonal_index(paste_indicator.orientation);
+
+ Vector3 ofs = paste_indicator.current - paste_indicator.click;
+ undo_redo->create_action(TTR("GridMap Paste Selection"));
+
+ for (List::Element *E = clipboard_items.front(); E; E = E->next()) {
+ ClipboardItem &item = E->get();
+
+ Vector3 pos = rot.xform(item.grid_offset) + paste_indicator.begin + ofs;
+
+ Basis orm;
+ orm.set_orthogonal_index(item.orientation);
+ orm = rot * orm;
+
+ undo_redo->add_do_method(node, "set_cell_item", pos.x, pos.y, pos.z, item.cell_item, orm.get_orthogonal_index());
+ undo_redo->add_undo_method(node, "set_cell_item", pos.x, pos.y, pos.z, node->get_cell_item(pos.x, pos.y, pos.z), node->get_cell_item_orientation(pos.x, pos.y, pos.z));
+ }
+
+ if (reselect) {
+ undo_redo->add_do_method(this, "_set_selection", true, paste_indicator.begin + ofs, paste_indicator.end + ofs);
+ undo_redo->add_undo_method(this, "_set_selection", selection.active, selection.begin, selection.end);
+ }
+
+ undo_redo->commit_action();
+
+ _clear_clipboard_data();
+}
+
+bool GridMapEditor::forward_spatial_input_event(Camera *p_camera, const Ref &p_event) {
+ if (!node) {
+ return false;
+ }
+
+ Ref mb = p_event;
+
+ if (mb.is_valid()) {
+ if (mb->get_button_index() == BUTTON_WHEEL_UP && (mb->get_command() || mb->get_shift())) {
+ if (mb->is_pressed()) {
+ floor->set_value(floor->get_value() + mb->get_factor());
+ }
+
+ return true; // Eaten.
+ } else if (mb->get_button_index() == BUTTON_WHEEL_DOWN && (mb->get_command() || mb->get_shift())) {
+ if (mb->is_pressed()) {
+ floor->set_value(floor->get_value() - mb->get_factor());
+ }
+ return true;
+ }
+
+ if (mb->is_pressed()) {
+ SpatialEditorViewport::NavigationScheme nav_scheme = (SpatialEditorViewport::NavigationScheme)EditorSettings::get_singleton()->get("editors/3d/navigation/navigation_scheme").operator int();
+ if ((nav_scheme == SpatialEditorViewport::NAVIGATION_MAYA || nav_scheme == SpatialEditorViewport::NAVIGATION_MODO) && mb->get_alt()) {
+ input_action = INPUT_NONE;
+ } else if (mb->get_button_index() == BUTTON_LEFT) {
+ bool can_edit = (node && node->get_mesh_library().is_valid());
+ if (input_action == INPUT_PASTE) {
+ _do_paste();
+ input_action = INPUT_NONE;
+ _update_paste_indicator();
+ } else if (mb->get_shift() && can_edit) {
+ input_action = INPUT_SELECT;
+ last_selection = selection;
+ } else if (mb->get_command() && can_edit) {
+ input_action = INPUT_PICK;
+ } else {
+ input_action = INPUT_PAINT;
+ set_items.clear();
+ }
+ } else if (mb->get_button_index() == BUTTON_RIGHT) {
+ if (input_action == INPUT_PASTE) {
+ _clear_clipboard_data();
+ input_action = INPUT_NONE;
+ _update_paste_indicator();
+ return true;
+ } else if (selection.active) {
+ _set_selection(false);
+ return true;
+ } else {
+ input_action = INPUT_ERASE;
+ set_items.clear();
+ }
+ } else {
+ return false;
+ }
+
+ return do_input_action(p_camera, Point2(mb->get_position().x, mb->get_position().y), true);
+ } else {
+ if ((mb->get_button_index() == BUTTON_RIGHT && input_action == INPUT_ERASE) || (mb->get_button_index() == BUTTON_LEFT && input_action == INPUT_PAINT)) {
+ if (set_items.size()) {
+ undo_redo->create_action(TTR("GridMap Paint"));
+ for (List::Element *E = set_items.front(); E; E = E->next()) {
+ const SetItem &si = E->get();
+ undo_redo->add_do_method(node, "set_cell_item", si.pos.x, si.pos.y, si.pos.z, si.new_value, si.new_orientation);
+ }
+ for (List::Element *E = set_items.back(); E; E = E->prev()) {
+ const SetItem &si = E->get();
+ undo_redo->add_undo_method(node, "set_cell_item", si.pos.x, si.pos.y, si.pos.z, si.old_value, si.old_orientation);
+ }
+
+ undo_redo->commit_action();
+ }
+ set_items.clear();
+ input_action = INPUT_NONE;
+ return set_items.size() > 0;
+ }
+
+ if (mb->get_button_index() == BUTTON_LEFT && input_action == INPUT_SELECT) {
+ undo_redo->create_action(TTR("GridMap Selection"));
+ undo_redo->add_do_method(this, "_set_selection", selection.active, selection.begin, selection.end);
+ undo_redo->add_undo_method(this, "_set_selection", last_selection.active, last_selection.begin, last_selection.end);
+ undo_redo->commit_action();
+ }
+
+ if (mb->get_button_index() == BUTTON_LEFT && input_action != INPUT_NONE) {
+ set_items.clear();
+ input_action = INPUT_NONE;
+ return true;
+ }
+ if (mb->get_button_index() == BUTTON_RIGHT && (input_action == INPUT_ERASE || input_action == INPUT_PASTE)) {
+ input_action = INPUT_NONE;
+ return true;
+ }
+ }
+ }
+
+ Ref mm = p_event;
+
+ if (mm.is_valid()) {
+ return do_input_action(p_camera, mm->get_position(), false);
+ }
+
+ Ref k = p_event;
+
+ if (k.is_valid()) {
+ if (k->is_pressed()) {
+ if (k->get_scancode() == KEY_ESCAPE) {
+ if (input_action == INPUT_PASTE) {
+ _clear_clipboard_data();
+ input_action = INPUT_NONE;
+ _update_paste_indicator();
+ return true;
+ } else if (selection.active) {
+ _set_selection(false);
+ return true;
+ } else {
+ selected_palette = -1;
+ mesh_library_palette->unselect_all();
+ update_palette();
+ _update_cursor_instance();
+ return true;
+ }
+ }
+
+ if (k->get_shift() && selection.active && input_action != INPUT_PASTE) {
+ if (k->get_scancode() == options->get_popup()->get_item_accelerator(options->get_popup()->get_item_index(MENU_OPTION_PREV_LEVEL))) {
+ selection.click[edit_axis]--;
+ _validate_selection();
+ return true;
+ }
+ if (k->get_scancode() == options->get_popup()->get_item_accelerator(options->get_popup()->get_item_index(MENU_OPTION_NEXT_LEVEL))) {
+ selection.click[edit_axis]++;
+ _validate_selection();
+ return true;
+ }
+ }
+ }
+ }
+
+ Ref pan_gesture = p_event;
+ if (pan_gesture.is_valid()) {
+ if (pan_gesture->get_alt() && (pan_gesture->get_command() || pan_gesture->get_shift())) {
+ const real_t delta = pan_gesture->get_delta().y * 0.5;
+ accumulated_floor_delta += delta;
+ int step = 0;
+ if (ABS(accumulated_floor_delta) > 1.0) {
+ step = SGN(accumulated_floor_delta);
+ accumulated_floor_delta -= step;
+ }
+ if (step) {
+ floor->set_value(floor->get_value() + step);
+ }
+ return true;
+ }
+ }
+ accumulated_floor_delta = 0.0;
+
+ return false;
+}
+
+struct _CGMEItemSort {
+ String name;
+ int id;
+ _FORCE_INLINE_ bool operator<(const _CGMEItemSort &r_it) const { return name < r_it.name; }
+};
+
+void GridMapEditor::_set_display_mode(int p_mode) {
+ if (display_mode == p_mode) {
+ return;
+ }
+
+ if (p_mode == DISPLAY_LIST) {
+ mode_list->set_pressed(true);
+ mode_thumbnail->set_pressed(false);
+ } else if (p_mode == DISPLAY_THUMBNAIL) {
+ mode_list->set_pressed(false);
+ mode_thumbnail->set_pressed(true);
+ }
+
+ display_mode = p_mode;
+
+ update_palette();
+}
+
+void GridMapEditor::_text_changed(const String &p_text) {
+ update_palette();
+}
+
+void GridMapEditor::_sbox_input(const Ref &p_ie) {
+ const Ref k = p_ie;
+
+ if (k.is_valid() && (k->get_scancode() == KEY_UP || k->get_scancode() == KEY_DOWN || k->get_scancode() == KEY_PAGEUP || k->get_scancode() == KEY_PAGEDOWN)) {
+ // Forward the key input to the ItemList so it can be scrolled
+ mesh_library_palette->call("_gui_input", k);
+ search_box->accept_event();
+ }
+}
+
+void GridMapEditor::_mesh_library_palette_input(const Ref &p_ie) {
+ const Ref mb = p_ie;
+
+ // Zoom in/out using Ctrl + mouse wheel
+ if (mb.is_valid() && mb->is_pressed() && mb->get_command()) {
+ if (mb->is_pressed() && mb->get_button_index() == BUTTON_WHEEL_UP) {
+ size_slider->set_value(size_slider->get_value() + 0.2);
+ }
+
+ if (mb->is_pressed() && mb->get_button_index() == BUTTON_WHEEL_DOWN) {
+ size_slider->set_value(size_slider->get_value() - 0.2);
+ }
+ }
+}
+
+void GridMapEditor::_icon_size_changed(float p_value) {
+ mesh_library_palette->set_icon_scale(p_value);
+ update_palette();
+}
+
+void GridMapEditor::update_palette() {
+ int selected = mesh_library_palette->get_current();
+
+ float min_size = EDITOR_GET("editors/grid_map/preview_size");
+ min_size *= EDSCALE;
+
+ mesh_library_palette->clear();
+ if (display_mode == DISPLAY_THUMBNAIL) {
+ mesh_library_palette->set_max_columns(0);
+ mesh_library_palette->set_icon_mode(ItemList::ICON_MODE_TOP);
+ mesh_library_palette->set_fixed_column_width(min_size * MAX(size_slider->get_value(), 1.5));
+ } else if (display_mode == DISPLAY_LIST) {
+ mesh_library_palette->set_max_columns(1);
+ mesh_library_palette->set_icon_mode(ItemList::ICON_MODE_LEFT);
+ mesh_library_palette->set_fixed_column_width(0);
+ }
+
+ mesh_library_palette->set_fixed_icon_size(Size2(min_size, min_size));
+ mesh_library_palette->set_max_text_lines(2);
+
+ Ref mesh_library = node->get_mesh_library();
+
+ if (mesh_library.is_null()) {
+ last_mesh_library = nullptr;
+ search_box->set_text("");
+ search_box->set_editable(false);
+ info_message->show();
+ return;
+ }
+
+ search_box->set_editable(true);
+ info_message->hide();
+
+ Vector ids;
+ ids = mesh_library->get_item_list();
+
+ List<_CGMEItemSort> il;
+ for (int i = 0; i < ids.size(); i++) {
+ _CGMEItemSort is;
+ is.id = ids[i];
+ is.name = mesh_library->get_item_name(ids[i]);
+ il.push_back(is);
+ }
+ il.sort();
+
+ String filter = search_box->get_text().strip_edges();
+
+ int item = 0;
+
+ for (List<_CGMEItemSort>::Element *E = il.front(); E; E = E->next()) {
+ int id = E->get().id;
+ String name = mesh_library->get_item_name(id);
+ Ref preview = mesh_library->get_item_preview(id);
+
+ if (name == "") {
+ name = "#" + itos(id);
+ }
+
+ if (filter != "" && !filter.is_subsequence_ofi(name)) {
+ continue;
+ }
+
+ mesh_library_palette->add_item("");
+ if (!preview.is_null()) {
+ mesh_library_palette->set_item_icon(item, preview);
+ mesh_library_palette->set_item_tooltip(item, name);
+ }
+ mesh_library_palette->set_item_text(item, name);
+ mesh_library_palette->set_item_metadata(item, id);
+
+ item++;
+ }
+
+ if (selected != -1 && mesh_library_palette->get_item_count() > 0) {
+ // Make sure that this variable is set correctly.
+ selected_palette = MIN(selected, mesh_library_palette->get_item_count() - 1);
+ mesh_library_palette->select(selected_palette);
+ }
+
+ last_mesh_library = *mesh_library;
+}
+
+void GridMapEditor::edit(GridMap *p_gridmap) {
+ if (!p_gridmap && node) {
+ node->disconnect("cell_size_changed", this, "_draw_grids");
+ }
+
+ node = p_gridmap;
+
+ input_action = INPUT_NONE;
+ selection.active = false;
+ _update_selection_transform();
+ _update_paste_indicator();
+
+ spatial_editor = Object::cast_to(editor->get_editor_plugin_screen());
+
+ if (!node) {
+ set_process(false);
+ for (int i = 0; i < 3; i++) {
+ VisualServer::get_singleton()->instance_set_visible(grid_instance[i], false);
+ }
+
+ if (cursor_instance.is_valid()) {
+ VisualServer::get_singleton()->instance_set_visible(cursor_instance, false);
+ }
+
+ return;
+ }
+
+ update_palette();
+ _update_cursor_instance();
+
+ set_process(true);
+
+ clip_mode = p_gridmap->has_meta("_editor_clip_") ? ClipMode(p_gridmap->get_meta("_editor_clip_").operator int()) : CLIP_DISABLED;
+
+ _draw_grids(node->get_cell_size());
+ update_grid();
+ _update_clip();
+
+ node->connect("cell_size_changed", this, "_draw_grids");
+}
+
+void GridMapEditor::_update_clip() {
+ node->set_meta("_editor_clip_", clip_mode);
+ if (clip_mode == CLIP_DISABLED) {
+ node->set_clip(false);
+ } else {
+ node->set_clip(true, clip_mode == CLIP_ABOVE, edit_floor[edit_axis], edit_axis);
+ }
+}
+
+void GridMapEditor::update_grid() {
+ grid_xform.origin.x -= 1; // Force update in hackish way.
+
+ grid_ofs[edit_axis] = edit_floor[edit_axis] * node->get_cell_size()[edit_axis];
+
+ edit_grid_xform.origin = grid_ofs;
+ edit_grid_xform.basis = Basis();
+
+ for (int i = 0; i < 3; i++) {
+ VisualServer::get_singleton()->instance_set_visible(grid_instance[i], i == edit_axis);
+ }
+
+ updating = true;
+ floor->set_value(edit_floor[edit_axis]);
+ updating = false;
+}
+
+void GridMapEditor::_draw_grids(const Vector3 &cell_size) {
+ Vector3 edited_floor = node->has_meta("_editor_floor_") ? node->get_meta("_editor_floor_") : Variant();
+
+ for (int i = 0; i < 3; i++) {
+ if (VS::get_singleton()->mesh_get_surface_count(grid[i]) > 0) {
+ VS::get_singleton()->mesh_remove_surface(grid[i], 0);
+ }
+ edit_floor[i] = edited_floor[i];
+ }
+
+ Vector grid_points[3];
+ Vector grid_colors[3];
+
+ for (int i = 0; i < 3; i++) {
+ Vector3 axis;
+ axis[i] = 1;
+ Vector3 axis_n1;
+ axis_n1[(i + 1) % 3] = cell_size[(i + 1) % 3];
+ Vector3 axis_n2;
+ axis_n2[(i + 2) % 3] = cell_size[(i + 2) % 3];
+
+ for (int j = -GRID_CURSOR_SIZE; j <= GRID_CURSOR_SIZE; j++) {
+ for (int k = -GRID_CURSOR_SIZE; k <= GRID_CURSOR_SIZE; k++) {
+ Vector3 p = axis_n1 * j + axis_n2 * k;
+ float trans = Math::pow(MAX(0, 1.0 - (Vector2(j, k).length() / GRID_CURSOR_SIZE)), 2);
+
+ Vector3 pj = axis_n1 * (j + 1) + axis_n2 * k;
+ float transj = Math::pow(MAX(0, 1.0 - (Vector2(j + 1, k).length() / GRID_CURSOR_SIZE)), 2);
+
+ Vector3 pk = axis_n1 * j + axis_n2 * (k + 1);
+ float transk = Math::pow(MAX(0, 1.0 - (Vector2(j, k + 1).length() / GRID_CURSOR_SIZE)), 2);
+
+ grid_points[i].push_back(p);
+ grid_points[i].push_back(pk);
+ grid_colors[i].push_back(Color(1, 1, 1, trans));
+ grid_colors[i].push_back(Color(1, 1, 1, transk));
+
+ grid_points[i].push_back(p);
+ grid_points[i].push_back(pj);
+ grid_colors[i].push_back(Color(1, 1, 1, trans));
+ grid_colors[i].push_back(Color(1, 1, 1, transj));
+ }
+ }
+
+ Array d;
+ d.resize(VS::ARRAY_MAX);
+ d[VS::ARRAY_VERTEX] = grid_points[i];
+ d[VS::ARRAY_COLOR] = grid_colors[i];
+ VisualServer::get_singleton()->mesh_add_surface_from_arrays(grid[i], VisualServer::PRIMITIVE_LINES, d);
+ VisualServer::get_singleton()->mesh_surface_set_material(grid[i], 0, indicator_mat->get_rid());
+ }
+}
+
+void GridMapEditor::_notification(int p_what) {
+ switch (p_what) {
+ case NOTIFICATION_ENTER_TREE: {
+ get_tree()->connect("node_removed", this, "_node_removed");
+ mesh_library_palette->connect("item_selected", this, "_item_selected_cbk");
+ for (int i = 0; i < 3; i++) {
+ grid[i] = RID_PRIME(VS::get_singleton()->mesh_create());
+ grid_instance[i] = VS::get_singleton()->instance_create2(grid[i], get_tree()->get_root()->get_world()->get_scenario());
+ VS::get_singleton()->instance_set_layer_mask(grid_instance[i], 1 << SpatialEditorViewport::MISC_TOOL_LAYER);
+ selection_level_instance[i] = VisualServer::get_singleton()->instance_create2(selection_level_mesh[i], get_tree()->get_root()->get_world()->get_scenario());
+ VS::get_singleton()->instance_set_layer_mask(selection_level_instance[i], 1 << SpatialEditorViewport::MISC_TOOL_LAYER);
+ }
+
+ selection_instance = VisualServer::get_singleton()->instance_create2(selection_mesh, get_tree()->get_root()->get_world()->get_scenario());
+ VS::get_singleton()->instance_set_layer_mask(selection_instance, 1 << SpatialEditorViewport::MISC_TOOL_LAYER);
+ paste_instance = VisualServer::get_singleton()->instance_create2(paste_mesh, get_tree()->get_root()->get_world()->get_scenario());
+ VS::get_singleton()->instance_set_layer_mask(paste_instance, 1 << SpatialEditorViewport::MISC_TOOL_LAYER);
+
+ _update_selection_transform();
+ _update_paste_indicator();
+ } break;
+
+ case NOTIFICATION_EXIT_TREE: {
+ get_tree()->disconnect("node_removed", this, "_node_removed");
+ _clear_clipboard_data();
+
+ for (int i = 0; i < 3; i++) {
+ if (grid_instance[i].is_valid()) {
+ VS::get_singleton()->free(grid_instance[i]);
+ grid_instance[i] = RID();
+ }
+
+ if (grid[i].is_valid()) {
+ VS::get_singleton()->free(grid[i]);
+ grid[i] = RID();
+ }
+
+ if (selection_level_instance[i].is_valid()) {
+ VS::get_singleton()->free(selection_level_instance[i]);
+ selection_level_instance[i] = RID();
+ }
+ }
+
+ if (selection_instance.is_valid()) {
+ VS::get_singleton()->free(selection_instance);
+ selection_instance = RID();
+ }
+
+ if (paste_instance.is_valid()) {
+ VS::get_singleton()->free(paste_instance);
+ paste_instance = RID();
+ }
+ } break;
+
+ case NOTIFICATION_PROCESS: {
+ if (!node) {
+ return;
+ }
+
+ Transform xf = node->get_global_transform();
+
+ if (xf != grid_xform) {
+ for (int i = 0; i < 3; i++) {
+ VS::get_singleton()->instance_set_transform(grid_instance[i], xf * edit_grid_xform);
+ }
+ grid_xform = xf;
+ }
+ Ref cgmt = node->get_mesh_library();
+ if (cgmt.operator->() != last_mesh_library) {
+ update_palette();
+ }
+
+ if (lock_view) {
+ EditorNode *editor = Object::cast_to(get_tree()->get_root()->get_child(0));
+
+ Plane p;
+ p.normal[edit_axis] = 1.0;
+ p.d = edit_floor[edit_axis] * node->get_cell_size()[edit_axis];
+ p = node->get_transform().xform(p); // plane to snap
+
+ SpatialEditorPlugin *sep = Object::cast_to(editor->get_editor_plugin_screen());
+ if (sep) {
+ sep->snap_cursor_to_plane(p);
+ }
+ }
+ } break;
+
+ case NOTIFICATION_THEME_CHANGED: {
+ options->set_icon(get_icon("GridMap", "EditorIcons"));
+ search_box->set_right_icon(get_icon("Search", "EditorIcons"));
+ } break;
+
+ case NOTIFICATION_WM_FOCUS_OUT: {
+ if (input_action == INPUT_PAINT) {
+ // Simulate mouse released event to stop drawing when editor focus exists.
+ Ref release;
+ release.instance();
+ release->set_button_index(BUTTON_LEFT);
+ forward_spatial_input_event(nullptr, release);
+ }
+ } break;
+ }
+}
+
+void GridMapEditor::_update_cursor_instance() {
+ if (!node) {
+ return;
+ }
+
+ if (cursor_instance.is_valid()) {
+ VisualServer::get_singleton()->free(cursor_instance);
+ cursor_instance = RID();
+ }
+
+ if (selected_palette >= 0) {
+ if (node && !node->get_mesh_library().is_null()) {
+ Ref mesh = node->get_mesh_library()->get_item_mesh(selected_palette);
+ if (!mesh.is_null() && mesh->get_rid().is_valid()) {
+ cursor_instance = VisualServer::get_singleton()->instance_create2(mesh->get_rid(), get_tree()->get_root()->get_world()->get_scenario());
+ VisualServer::get_singleton()->instance_set_transform(cursor_instance, cursor_transform);
+ }
+ }
+ }
+}
+
+void GridMapEditor::_item_selected_cbk(int idx) {
+ selected_palette = mesh_library_palette->get_item_metadata(idx);
+
+ _update_cursor_instance();
+}
+
+void GridMapEditor::_floor_changed(float p_value) {
+ if (updating) {
+ return;
+ }
+
+ edit_floor[edit_axis] = p_value;
+ node->set_meta("_editor_floor_", Vector3(edit_floor[0], edit_floor[1], edit_floor[2]));
+ update_grid();
+ _update_clip();
+ _update_selection_transform();
+}
+
+void GridMapEditor::_floor_mouse_exited() {
+ floor->get_line_edit()->release_focus();
+}
+
+void GridMapEditor::_bind_methods() {
+ ClassDB::bind_method("_text_changed", &GridMapEditor::_text_changed);
+ ClassDB::bind_method("_sbox_input", &GridMapEditor::_sbox_input);
+ ClassDB::bind_method("_mesh_library_palette_input", &GridMapEditor::_mesh_library_palette_input);
+ ClassDB::bind_method("_icon_size_changed", &GridMapEditor::_icon_size_changed);
+ ClassDB::bind_method("_menu_option", &GridMapEditor::_menu_option);
+ ClassDB::bind_method("_configure", &GridMapEditor::_configure);
+ ClassDB::bind_method("_item_selected_cbk", &GridMapEditor::_item_selected_cbk);
+ ClassDB::bind_method("_floor_changed", &GridMapEditor::_floor_changed);
+ ClassDB::bind_method("_floor_mouse_exited", &GridMapEditor::_floor_mouse_exited);
+ ClassDB::bind_method("_set_selection", &GridMapEditor::_set_selection);
+ ClassDB::bind_method("_node_removed", &GridMapEditor::_node_removed);
+
+ ClassDB::bind_method(D_METHOD("_set_display_mode", "mode"), &GridMapEditor::_set_display_mode);
+ ClassDB::bind_method("_draw_grids", &GridMapEditor::_draw_grids);
+}
+
+GridMapEditor::GridMapEditor(EditorNode *p_editor) {
+ input_action = INPUT_NONE;
+ node = nullptr;
+ editor = p_editor;
+ undo_redo = p_editor->get_undo_redo();
+
+ int mw = EDITOR_DEF("editors/grid_map/palette_min_width", 230);
+ Control *ec = memnew(Control);
+ ec->set_custom_minimum_size(Size2(mw, 0) * EDSCALE);
+ add_child(ec);
+
+ spatial_editor_hb = memnew(HBoxContainer);
+ spatial_editor_hb->set_h_size_flags(SIZE_EXPAND_FILL);
+ spatial_editor_hb->set_alignment(BoxContainer::ALIGN_END);
+ SpatialEditor::get_singleton()->add_control_to_menu_panel(spatial_editor_hb);
+
+ spin_box_label = memnew(Label);
+ spin_box_label->set_text(TTR("Floor:"));
+ spatial_editor_hb->add_child(spin_box_label);
+
+ floor = memnew(SpinBox);
+ floor->set_min(-32767);
+ floor->set_max(32767);
+ floor->set_step(1);
+ floor->get_line_edit()->add_constant_override("minimum_spaces", 16);
+
+ spatial_editor_hb->add_child(floor);
+ floor->connect("value_changed", this, "_floor_changed");
+ floor->connect("mouse_exited", this, "_floor_mouse_exited");
+ floor->get_line_edit()->connect("mouse_exited", this, "_floor_mouse_exited");
+
+ spatial_editor_hb->add_child(memnew(VSeparator));
+
+ options = memnew(MenuButton);
+ spatial_editor_hb->add_child(options);
+ spatial_editor_hb->hide();
+
+ options->set_text(TTR("Grid Map"));
+ options->get_popup()->add_check_item(TTR("Snap View"), MENU_OPTION_LOCK_VIEW);
+ options->get_popup()->add_separator();
+ options->get_popup()->add_item(TTR("Previous Floor"), MENU_OPTION_PREV_LEVEL, KEY_Q);
+ options->get_popup()->add_item(TTR("Next Floor"), MENU_OPTION_NEXT_LEVEL, KEY_E);
+ options->get_popup()->add_separator();
+ options->get_popup()->add_radio_check_item(TTR("Clip Disabled"), MENU_OPTION_CLIP_DISABLED);
+ options->get_popup()->set_item_checked(options->get_popup()->get_item_index(MENU_OPTION_CLIP_DISABLED), true);
+ options->get_popup()->add_radio_check_item(TTR("Clip Above"), MENU_OPTION_CLIP_ABOVE);
+ options->get_popup()->add_radio_check_item(TTR("Clip Below"), MENU_OPTION_CLIP_BELOW);
+ options->get_popup()->add_separator();
+ options->get_popup()->add_radio_check_item(TTR("Edit X Axis"), MENU_OPTION_X_AXIS, KEY_Z);
+ options->get_popup()->add_radio_check_item(TTR("Edit Y Axis"), MENU_OPTION_Y_AXIS, KEY_X);
+ options->get_popup()->add_radio_check_item(TTR("Edit Z Axis"), MENU_OPTION_Z_AXIS, KEY_C);
+ options->get_popup()->set_item_checked(options->get_popup()->get_item_index(MENU_OPTION_Y_AXIS), true);
+ options->get_popup()->add_separator();
+ options->get_popup()->add_item(TTR("Cursor Rotate X"), MENU_OPTION_CURSOR_ROTATE_X, KEY_A);
+ options->get_popup()->add_item(TTR("Cursor Rotate Y"), MENU_OPTION_CURSOR_ROTATE_Y, KEY_S);
+ options->get_popup()->add_item(TTR("Cursor Rotate Z"), MENU_OPTION_CURSOR_ROTATE_Z, KEY_D);
+ options->get_popup()->add_item(TTR("Cursor Back Rotate X"), MENU_OPTION_CURSOR_BACK_ROTATE_X, KEY_MASK_SHIFT + KEY_A);
+ options->get_popup()->add_item(TTR("Cursor Back Rotate Y"), MENU_OPTION_CURSOR_BACK_ROTATE_Y, KEY_MASK_SHIFT + KEY_S);
+ options->get_popup()->add_item(TTR("Cursor Back Rotate Z"), MENU_OPTION_CURSOR_BACK_ROTATE_Z, KEY_MASK_SHIFT + KEY_D);
+ options->get_popup()->add_item(TTR("Cursor Clear Rotation"), MENU_OPTION_CURSOR_CLEAR_ROTATION, KEY_W);
+ options->get_popup()->add_separator();
+ options->get_popup()->add_check_item(TTR("Paste Selects"), MENU_OPTION_PASTE_SELECTS);
+ options->get_popup()->add_separator();
+ options->get_popup()->add_item(TTR("Duplicate Selection"), MENU_OPTION_SELECTION_DUPLICATE, KEY_MASK_CTRL + KEY_C);
+ options->get_popup()->add_item(TTR("Cut Selection"), MENU_OPTION_SELECTION_CUT, KEY_MASK_CTRL + KEY_X);
+ options->get_popup()->add_item(TTR("Clear Selection"), MENU_OPTION_SELECTION_CLEAR, KEY_DELETE);
+ options->get_popup()->add_item(TTR("Fill Selection"), MENU_OPTION_SELECTION_FILL, KEY_MASK_CTRL + KEY_F);
+
+ options->get_popup()->add_separator();
+ options->get_popup()->add_item(TTR("Settings..."), MENU_OPTION_GRIDMAP_SETTINGS);
+
+ settings_dialog = memnew(ConfirmationDialog);
+ settings_dialog->set_title(TTR("GridMap Settings"));
+ add_child(settings_dialog);
+ settings_vbc = memnew(VBoxContainer);
+ settings_vbc->set_custom_minimum_size(Size2(200, 0) * EDSCALE);
+ settings_dialog->add_child(settings_vbc);
+
+ settings_pick_distance = memnew(SpinBox);
+ settings_pick_distance->set_max(10000.0f);
+ settings_pick_distance->set_min(500.0f);
+ settings_pick_distance->set_step(1.0f);
+ settings_pick_distance->set_value(EDITOR_DEF("editors/grid_map/pick_distance", 5000.0));
+ settings_vbc->add_margin_child(TTR("Pick Distance:"), settings_pick_distance);
+
+ clip_mode = CLIP_DISABLED;
+ options->get_popup()->connect("id_pressed", this, "_menu_option");
+
+ HBoxContainer *hb = memnew(HBoxContainer);
+ add_child(hb);
+ hb->set_h_size_flags(SIZE_EXPAND_FILL);
+
+ search_box = memnew(LineEdit);
+ search_box->set_h_size_flags(SIZE_EXPAND_FILL);
+ search_box->set_placeholder(TTR("Filter meshes"));
+ hb->add_child(search_box);
+ search_box->connect("text_changed", this, "_text_changed");
+ search_box->connect("gui_input", this, "_sbox_input");
+
+ mode_thumbnail = memnew(ToolButton);
+ mode_thumbnail->set_toggle_mode(true);
+ mode_thumbnail->set_pressed(true);
+ mode_thumbnail->set_icon(p_editor->get_gui_base()->get_icon("FileThumbnail", "EditorIcons"));
+ hb->add_child(mode_thumbnail);
+ mode_thumbnail->connect("pressed", this, "_set_display_mode", varray(DISPLAY_THUMBNAIL));
+
+ mode_list = memnew(ToolButton);
+ mode_list->set_toggle_mode(true);
+ mode_list->set_pressed(false);
+ mode_list->set_icon(p_editor->get_gui_base()->get_icon("FileList", "EditorIcons"));
+ hb->add_child(mode_list);
+ mode_list->connect("pressed", this, "_set_display_mode", varray(DISPLAY_LIST));
+
+ size_slider = memnew(HSlider);
+ size_slider->set_h_size_flags(SIZE_EXPAND_FILL);
+ size_slider->set_min(0.2f);
+ size_slider->set_max(4.0f);
+ size_slider->set_step(0.1f);
+ size_slider->set_value(1.0f);
+ size_slider->connect("value_changed", this, "_icon_size_changed");
+ add_child(size_slider);
+
+ display_mode = DISPLAY_THUMBNAIL;
+
+ mesh_library_palette = memnew(ItemList);
+ add_child(mesh_library_palette);
+ mesh_library_palette->set_v_size_flags(SIZE_EXPAND_FILL);
+ mesh_library_palette->connect("gui_input", this, "_mesh_library_palette_input");
+
+ info_message = memnew(Label);
+ info_message->set_text(TTR("Give a MeshLibrary resource to this GridMap to use its meshes."));
+ info_message->set_valign(Label::VALIGN_CENTER);
+ info_message->set_align(Label::ALIGN_CENTER);
+ info_message->set_autowrap(true);
+ info_message->set_custom_minimum_size(Size2(100 * EDSCALE, 0));
+ info_message->set_anchors_and_margins_preset(PRESET_WIDE, PRESET_MODE_KEEP_SIZE, 8 * EDSCALE);
+ mesh_library_palette->add_child(info_message);
+
+ edit_axis = Vector3::AXIS_Y;
+ edit_floor[0] = -1;
+ edit_floor[1] = -1;
+ edit_floor[2] = -1;
+
+ cursor_visible = false;
+ selected_palette = -1;
+ lock_view = false;
+ cursor_rot = 0;
+
+ selection_mesh = RID_PRIME(VisualServer::get_singleton()->mesh_create());
+ paste_mesh = RID_PRIME(VisualServer::get_singleton()->mesh_create());
+
+ {
+ // Selection mesh create.
+
+ PoolVector lines;
+ PoolVector triangles;
+ PoolVector square[3];
+
+ for (int i = 0; i < 6; i++) {
+ Vector3 face_points[4];
+
+ for (int j = 0; j < 4; j++) {
+ float v[3];
+ v[0] = 1.0;
+ v[1] = 1 - 2 * ((j >> 1) & 1);
+ v[2] = v[1] * (1 - 2 * (j & 1));
+
+ for (int k = 0; k < 3; k++) {
+ if (i < 3) {
+ face_points[j][(i + k) % 3] = v[k];
+ } else {
+ face_points[3 - j][(i + k) % 3] = -v[k];
+ }
+ }
+ }
+
+ triangles.push_back(face_points[0] * 0.5 + Vector3(0.5, 0.5, 0.5));
+ triangles.push_back(face_points[1] * 0.5 + Vector3(0.5, 0.5, 0.5));
+ triangles.push_back(face_points[2] * 0.5 + Vector3(0.5, 0.5, 0.5));
+
+ triangles.push_back(face_points[2] * 0.5 + Vector3(0.5, 0.5, 0.5));
+ triangles.push_back(face_points[3] * 0.5 + Vector3(0.5, 0.5, 0.5));
+ triangles.push_back(face_points[0] * 0.5 + Vector3(0.5, 0.5, 0.5));
+ }
+
+ for (int i = 0; i < 12; i++) {
+ AABB base(Vector3(0, 0, 0), Vector3(1, 1, 1));
+ Vector3 a, b;
+ base.get_edge(i, a, b);
+ lines.push_back(a);
+ lines.push_back(b);
+ }
+
+ for (int i = 0; i < 3; i++) {
+ Vector3 points[4];
+ for (int j = 0; j < 4; j++) {
+ static const bool orderx[4] = { false, true, true, false };
+ static const bool ordery[4] = { false, false, true, true };
+
+ Vector3 sp;
+ if (orderx[j]) {
+ sp[(i + 1) % 3] = 1.0;
+ }
+ if (ordery[j]) {
+ sp[(i + 2) % 3] = 1.0;
+ }
+
+ points[j] = sp;
+ }
+
+ for (int j = 0; j < 4; j++) {
+ Vector3 ofs;
+ ofs[i] += 0.01;
+ square[i].push_back(points[j] - ofs);
+ square[i].push_back(points[(j + 1) % 4] - ofs);
+ square[i].push_back(points[j] + ofs);
+ square[i].push_back(points[(j + 1) % 4] + ofs);
+ }
+ }
+
+ Array d;
+ d.resize(VS::ARRAY_MAX);
+
+ inner_mat.instance();
+ inner_mat->set_albedo(Color(0.7, 0.7, 1.0, 0.2));
+ inner_mat->set_flag(SpatialMaterial::FLAG_UNSHADED, true);
+ inner_mat->set_feature(SpatialMaterial::FEATURE_TRANSPARENT, true);
+
+ d[VS::ARRAY_VERTEX] = triangles;
+ VisualServer::get_singleton()->mesh_add_surface_from_arrays(selection_mesh, VS::PRIMITIVE_TRIANGLES, d);
+ VisualServer::get_singleton()->mesh_surface_set_material(selection_mesh, 0, inner_mat->get_rid());
+
+ outer_mat.instance();
+ outer_mat->set_albedo(Color(0.7, 0.7, 1.0, 0.8));
+ outer_mat->set_on_top_of_alpha();
+ outer_mat->set_flag(SpatialMaterial::FLAG_UNSHADED, true);
+ outer_mat->set_line_width(3.0);
+ outer_mat->set_feature(SpatialMaterial::FEATURE_TRANSPARENT, true);
+
+ selection_floor_mat.instance();
+ selection_floor_mat->set_albedo(Color(0.80, 0.80, 1.0, 1));
+ selection_floor_mat->set_on_top_of_alpha();
+ selection_floor_mat->set_flag(SpatialMaterial::FLAG_UNSHADED, true);
+ selection_floor_mat->set_line_width(3.0);
+
+ d[VS::ARRAY_VERTEX] = lines;
+ VisualServer::get_singleton()->mesh_add_surface_from_arrays(selection_mesh, VS::PRIMITIVE_LINES, d);
+ VisualServer::get_singleton()->mesh_surface_set_material(selection_mesh, 1, outer_mat->get_rid());
+
+ d[VS::ARRAY_VERTEX] = triangles;
+ VisualServer::get_singleton()->mesh_add_surface_from_arrays(paste_mesh, VS::PRIMITIVE_TRIANGLES, d);
+ VisualServer::get_singleton()->mesh_surface_set_material(paste_mesh, 0, inner_mat->get_rid());
+
+ d[VS::ARRAY_VERTEX] = lines;
+ VisualServer::get_singleton()->mesh_add_surface_from_arrays(paste_mesh, VS::PRIMITIVE_LINES, d);
+ VisualServer::get_singleton()->mesh_surface_set_material(paste_mesh, 1, outer_mat->get_rid());
+
+ for (int i = 0; i < 3; i++) {
+ d[VS::ARRAY_VERTEX] = square[i];
+ selection_level_mesh[i] = RID_PRIME(VS::get_singleton()->mesh_create());
+ VisualServer::get_singleton()->mesh_add_surface_from_arrays(selection_level_mesh[i], VS::PRIMITIVE_LINES, d);
+ VisualServer::get_singleton()->mesh_surface_set_material(selection_level_mesh[i], 0, selection_floor_mat->get_rid());
+ }
+ }
+
+ _set_selection(false);
+ updating = false;
+ accumulated_floor_delta = 0.0;
+
+ indicator_mat.instance();
+ indicator_mat->set_flag(SpatialMaterial::FLAG_UNSHADED, true);
+ indicator_mat->set_feature(SpatialMaterial::FEATURE_TRANSPARENT, true);
+ indicator_mat->set_flag(SpatialMaterial::FLAG_SRGB_VERTEX_COLOR, true);
+ indicator_mat->set_flag(SpatialMaterial::FLAG_ALBEDO_FROM_VERTEX_COLOR, true);
+ indicator_mat->set_albedo(Color(0.8, 0.5, 0.1));
+}
+
+GridMapEditor::~GridMapEditor() {
+ _clear_clipboard_data();
+
+ for (int i = 0; i < 3; i++) {
+ if (grid[i].is_valid()) {
+ VisualServer::get_singleton()->free(grid[i]);
+ }
+ if (grid_instance[i].is_valid()) {
+ VisualServer::get_singleton()->free(grid_instance[i]);
+ }
+ if (cursor_instance.is_valid()) {
+ VisualServer::get_singleton()->free(cursor_instance);
+ }
+ if (selection_level_instance[i].is_valid()) {
+ VisualServer::get_singleton()->free(selection_level_instance[i]);
+ }
+ if (selection_level_mesh[i].is_valid()) {
+ VisualServer::get_singleton()->free(selection_level_mesh[i]);
+ }
+ }
+
+ if (selection_mesh.is_valid()) {
+ VisualServer::get_singleton()->free(selection_mesh);
+ }
+ if (selection_instance.is_valid()) {
+ VisualServer::get_singleton()->free(selection_instance);
+ }
+ if (paste_mesh.is_valid()) {
+ VisualServer::get_singleton()->free(paste_mesh);
+ }
+ if (paste_instance.is_valid()) {
+ VisualServer::get_singleton()->free(paste_instance);
+ }
+}
+
+void GridMapEditorPlugin::_notification(int p_what) {
+ if (p_what == EditorSettings::NOTIFICATION_EDITOR_SETTINGS_CHANGED) {
+ switch ((int)EditorSettings::get_singleton()->get("editors/grid_map/editor_side")) {
+ case 0: { // Left.
+ SpatialEditor::get_singleton()->move_control_to_left_panel(grid_map_editor);
+ } break;
+ case 1: { // Right.
+ SpatialEditor::get_singleton()->move_control_to_right_panel(grid_map_editor);
+ } break;
+ }
+ }
+}
+
+void GridMapEditorPlugin::edit(Object *p_object) {
+ grid_map_editor->edit(Object::cast_to(p_object));
+}
+
+bool GridMapEditorPlugin::handles(Object *p_object) const {
+ return p_object->is_class("GridMap");
+}
+
+void GridMapEditorPlugin::make_visible(bool p_visible) {
+ if (p_visible) {
+ grid_map_editor->show();
+ grid_map_editor->spatial_editor_hb->show();
+ grid_map_editor->set_process(true);
+ } else {
+ grid_map_editor->spatial_editor_hb->hide();
+ grid_map_editor->hide();
+ grid_map_editor->edit(nullptr);
+ grid_map_editor->set_process(false);
+ }
+}
+
+GridMapEditorPlugin::GridMapEditorPlugin(EditorNode *p_node) {
+ editor = p_node;
+
+ EDITOR_DEF("editors/grid_map/editor_side", 1);
+ EditorSettings::get_singleton()->add_property_hint(PropertyInfo(Variant::INT, "editors/grid_map/editor_side", PROPERTY_HINT_ENUM, "Left,Right"));
+
+ grid_map_editor = memnew(GridMapEditor(editor));
+ switch ((int)EditorSettings::get_singleton()->get("editors/grid_map/editor_side")) {
+ case 0: { // Left.
+ SpatialEditor::get_singleton()->add_control_to_left_panel(grid_map_editor);
+ } break;
+ case 1: { // Right.
+ SpatialEditor::get_singleton()->add_control_to_right_panel(grid_map_editor);
+ } break;
+ }
+ grid_map_editor->hide();
+}
+
+GridMapEditorPlugin::~GridMapEditorPlugin() {
+}
diff --git a/modules/gridmap/grid_map_editor_plugin.h b/modules/gridmap/grid_map_editor_plugin.h
new file mode 100644
index 000000000..f6ac63d45
--- /dev/null
+++ b/modules/gridmap/grid_map_editor_plugin.h
@@ -0,0 +1,270 @@
+/*************************************************************************/
+/* grid_map_editor_plugin.h */
+/*************************************************************************/
+/* This file is part of: */
+/* GODOT ENGINE */
+/* https://godotengine.org */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md). */
+/* */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the */
+/* "Software"), to deal in the Software without restriction, including */
+/* without limitation the rights to use, copy, modify, merge, publish, */
+/* distribute, sublicense, and/or sell copies of the Software, and to */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions: */
+/* */
+/* The above copyright notice and this permission notice shall be */
+/* included in all copies or substantial portions of the Software. */
+/* */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
+/*************************************************************************/
+
+#ifndef GRID_MAP_EDITOR_PLUGIN_H
+#define GRID_MAP_EDITOR_PLUGIN_H
+
+#include "editor/editor_node.h"
+#include "editor/editor_plugin.h"
+#include "editor/pane_drag.h"
+#include "grid_map.h"
+
+class SpatialEditorPlugin;
+
+class GridMapEditor : public VBoxContainer {
+ GDCLASS(GridMapEditor, VBoxContainer);
+
+ enum {
+
+ GRID_CURSOR_SIZE = 50
+ };
+
+ enum InputAction {
+
+ INPUT_NONE,
+ INPUT_PAINT,
+ INPUT_ERASE,
+ INPUT_PICK,
+ INPUT_SELECT,
+ INPUT_PASTE,
+ };
+
+ enum ClipMode {
+
+ CLIP_DISABLED,
+ CLIP_ABOVE,
+ CLIP_BELOW
+ };
+
+ enum DisplayMode {
+ DISPLAY_THUMBNAIL,
+ DISPLAY_LIST
+ };
+
+ UndoRedo *undo_redo;
+ InputAction input_action;
+ Panel *panel;
+ MenuButton *options;
+ SpinBox *floor;
+ double accumulated_floor_delta;
+ ToolButton *mode_thumbnail;
+ ToolButton *mode_list;
+ LineEdit *search_box;
+ HSlider *size_slider;
+ HBoxContainer *spatial_editor_hb;
+ ConfirmationDialog *settings_dialog;
+ VBoxContainer *settings_vbc;
+ SpinBox *settings_pick_distance;
+ Label *spin_box_label;
+
+ struct SetItem {
+ Vector3 pos;
+ int new_value;
+ int new_orientation;
+ int old_value;
+ int old_orientation;
+ };
+
+ List set_items;
+
+ GridMap *node;
+ MeshLibrary *last_mesh_library;
+ ClipMode clip_mode;
+
+ bool lock_view;
+ Transform grid_xform;
+ Transform edit_grid_xform;
+ Vector3::Axis edit_axis;
+ int edit_floor[3];
+ Vector3 grid_ofs;
+
+ RID grid[3];
+ RID grid_instance[3];
+ RID cursor_instance;
+ RID selection_mesh;
+ RID selection_instance;
+ RID selection_level_mesh[3];
+ RID selection_level_instance[3];
+ RID paste_mesh;
+ RID paste_instance;
+
+ struct ClipboardItem {
+ int cell_item;
+ Vector3 grid_offset;
+ int orientation;
+ RID instance;
+ };
+
+ List clipboard_items;
+
+ Ref indicator_mat;
+ Ref inner_mat;
+ Ref outer_mat;
+ Ref selection_floor_mat;
+
+ bool updating;
+
+ struct Selection {
+ Vector3 click;
+ Vector3 current;
+ Vector3 begin;
+ Vector3 end;
+ bool active;
+ } selection;
+ Selection last_selection;
+
+ struct PasteIndicator {
+ Vector3 click;
+ Vector3 current;
+ Vector3 begin;
+ Vector3 end;
+ int orientation;
+ };
+ PasteIndicator paste_indicator;
+
+ bool cursor_visible;
+ Transform cursor_transform;
+
+ Vector3 cursor_origin;
+
+ int display_mode;
+ int selected_palette;
+ int cursor_rot;
+
+ enum Menu {
+
+ MENU_OPTION_NEXT_LEVEL,
+ MENU_OPTION_PREV_LEVEL,
+ MENU_OPTION_LOCK_VIEW,
+ MENU_OPTION_CLIP_DISABLED,
+ MENU_OPTION_CLIP_ABOVE,
+ MENU_OPTION_CLIP_BELOW,
+ MENU_OPTION_X_AXIS,
+ MENU_OPTION_Y_AXIS,
+ MENU_OPTION_Z_AXIS,
+ MENU_OPTION_CURSOR_ROTATE_Y,
+ MENU_OPTION_CURSOR_ROTATE_X,
+ MENU_OPTION_CURSOR_ROTATE_Z,
+ MENU_OPTION_CURSOR_BACK_ROTATE_Y,
+ MENU_OPTION_CURSOR_BACK_ROTATE_X,
+ MENU_OPTION_CURSOR_BACK_ROTATE_Z,
+ MENU_OPTION_CURSOR_CLEAR_ROTATION,
+ MENU_OPTION_PASTE_SELECTS,
+ MENU_OPTION_SELECTION_DUPLICATE,
+ MENU_OPTION_SELECTION_CUT,
+ MENU_OPTION_SELECTION_CLEAR,
+ MENU_OPTION_SELECTION_FILL,
+ MENU_OPTION_GRIDMAP_SETTINGS
+
+ };
+
+ SpatialEditorPlugin *spatial_editor;
+
+ struct AreaDisplay {
+ RID mesh;
+ RID instance;
+ };
+
+ ItemList *mesh_library_palette;
+ Label *info_message;
+
+ EditorNode *editor;
+
+ void update_grid(); // Change which and where the grid is displayed
+ void _draw_grids(const Vector3 &cell_size);
+ void _configure();
+ void _menu_option(int);
+ void update_palette();
+ void _set_display_mode(int p_mode);
+ void _item_selected_cbk(int idx);
+ void _update_cursor_transform();
+ void _update_cursor_instance();
+ void _update_clip();
+
+ void _text_changed(const String &p_text);
+ void _sbox_input(const Ref &p_ie);
+ void _mesh_library_palette_input(const Ref &p_ie);
+
+ void _icon_size_changed(float p_value);
+
+ void _clear_clipboard_data();
+ void _set_clipboard_data();
+ void _update_paste_indicator();
+ void _do_paste();
+ void _update_selection_transform();
+ void _validate_selection();
+ void _set_selection(bool p_active, const Vector3 &p_begin = Vector3(), const Vector3 &p_end = Vector3());
+
+ void _floor_changed(float p_value);
+ void _floor_mouse_exited();
+
+ void _delete_selection();
+ void _fill_selection();
+
+ bool do_input_action(Camera *p_camera, const Point2 &p_point, bool p_click);
+
+ friend class GridMapEditorPlugin;
+
+protected:
+ void _notification(int p_what);
+ void _node_removed(Node *p_node);
+ static void _bind_methods();
+
+public:
+ bool forward_spatial_input_event(Camera *p_camera, const Ref &p_event);
+
+ void edit(GridMap *p_gridmap);
+ GridMapEditor() {}
+ GridMapEditor(EditorNode *p_editor);
+ ~GridMapEditor();
+};
+
+class GridMapEditorPlugin : public EditorPlugin {
+ GDCLASS(GridMapEditorPlugin, EditorPlugin);
+
+ GridMapEditor *grid_map_editor;
+ EditorNode *editor;
+
+protected:
+ void _notification(int p_what);
+
+public:
+ virtual bool forward_spatial_gui_input(Camera *p_camera, const Ref &p_event) { return grid_map_editor->forward_spatial_input_event(p_camera, p_event); }
+ virtual String get_name() const { return "GridMap"; }
+ bool has_main_screen() const { return false; }
+ virtual void edit(Object *p_object);
+ virtual bool handles(Object *p_object) const;
+ virtual void make_visible(bool p_visible);
+
+ GridMapEditorPlugin(EditorNode *p_node);
+ ~GridMapEditorPlugin();
+};
+
+#endif // GRID_MAP_EDITOR_PLUGIN_H
diff --git a/modules/gridmap/icons/icon_grid_map.svg b/modules/gridmap/icons/icon_grid_map.svg
new file mode 100644
index 000000000..eafe1211f
--- /dev/null
+++ b/modules/gridmap/icons/icon_grid_map.svg
@@ -0,0 +1,5 @@
+
diff --git a/modules/gridmap/register_types.cpp b/modules/gridmap/register_types.cpp
new file mode 100644
index 000000000..adacbea7f
--- /dev/null
+++ b/modules/gridmap/register_types.cpp
@@ -0,0 +1,48 @@
+/*************************************************************************/
+/* register_types.cpp */
+/*************************************************************************/
+/* This file is part of: */
+/* GODOT ENGINE */
+/* https://godotengine.org */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md). */
+/* */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the */
+/* "Software"), to deal in the Software without restriction, including */
+/* without limitation the rights to use, copy, modify, merge, publish, */
+/* distribute, sublicense, and/or sell copies of the Software, and to */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions: */
+/* */
+/* The above copyright notice and this permission notice shall be */
+/* included in all copies or substantial portions of the Software. */
+/* */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
+/*************************************************************************/
+
+#include "register_types.h"
+#ifndef _3D_DISABLED
+#include "core/class_db.h"
+#include "grid_map.h"
+#include "grid_map_editor_plugin.h"
+#endif
+
+void register_gridmap_types() {
+#ifndef _3D_DISABLED
+ ClassDB::register_class();
+#ifdef TOOLS_ENABLED
+ EditorPlugins::add_by_type();
+#endif
+#endif
+}
+
+void unregister_gridmap_types() {
+}
diff --git a/modules/gridmap/register_types.h b/modules/gridmap/register_types.h
new file mode 100644
index 000000000..fa3511c5d
--- /dev/null
+++ b/modules/gridmap/register_types.h
@@ -0,0 +1,37 @@
+/*************************************************************************/
+/* register_types.h */
+/*************************************************************************/
+/* This file is part of: */
+/* GODOT ENGINE */
+/* https://godotengine.org */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md). */
+/* */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the */
+/* "Software"), to deal in the Software without restriction, including */
+/* without limitation the rights to use, copy, modify, merge, publish, */
+/* distribute, sublicense, and/or sell copies of the Software, and to */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions: */
+/* */
+/* The above copyright notice and this permission notice shall be */
+/* included in all copies or substantial portions of the Software. */
+/* */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
+/*************************************************************************/
+
+#ifndef GRIDMAP_REGISTER_TYPES_H
+#define GRIDMAP_REGISTER_TYPES_H
+
+void register_gridmap_types();
+void unregister_gridmap_types();
+
+#endif // GRIDMAP_REGISTER_TYPES_H