d95794ec8a
As many open source projects have started doing it, we're removing the current year from the copyright notice, so that we don't need to bump it every year. It seems like only the first year of publication is technically relevant for copyright notices, and even that seems to be something that many companies stopped listing altogether (in a version controlled codebase, the commits are a much better source of date of publication than a hardcoded copyright statement). We also now list Godot Engine contributors first as we're collectively the current maintainers of the project, and we clarify that the "exclusive" copyright of the co-founders covers the timespan before opensourcing (their further contributions are included as part of Godot Engine contributors). Also fixed "cf." Frenchism - it's meant as "refer to / see".
1444 lines
48 KiB
C++
1444 lines
48 KiB
C++
/**************************************************************************/
|
|
/* grid_map.cpp */
|
|
/**************************************************************************/
|
|
/* This file is part of: */
|
|
/* GODOT ENGINE */
|
|
/* https://godotengine.org */
|
|
/**************************************************************************/
|
|
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
|
|
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
|
|
/* */
|
|
/* 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/object/message_queue.h"
|
|
#include "scene/3d/light_3d.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_3d.h"
|
|
#include "servers/rendering_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")) {
|
|
Vector<int> cells = d["cells"];
|
|
int amount = cells.size();
|
|
const int *r = cells.ptr();
|
|
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 = RS::get_singleton()->instance_create();
|
|
RS::get_singleton()->instance_set_base(bm.instance, bm.mesh->get_rid());
|
|
RS::get_singleton()->instance_attach_object_instance_id(bm.instance, get_instance_id());
|
|
if (is_inside_tree()) {
|
|
RS::get_singleton()->instance_set_scenario(bm.instance, get_world_3d()->get_scenario());
|
|
RS::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;
|
|
|
|
Vector<int> cells;
|
|
cells.resize(cell_map.size() * 3);
|
|
{
|
|
int *w = cells.ptrw();
|
|
int i = 0;
|
|
for (const KeyValue<IndexKey, Cell> &E : cell_map) {
|
|
encode_uint64(E.key.key, (uint8_t *)&w[i * 3]);
|
|
encode_uint32(E.value.cell, (uint8_t *)&w[i * 3 + 2]);
|
|
i++;
|
|
}
|
|
}
|
|
|
|
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<PropertyInfo> *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;
|
|
_update_physics_bodies_collision_properties();
|
|
}
|
|
|
|
uint32_t GridMap::get_collision_layer() const {
|
|
return collision_layer;
|
|
}
|
|
|
|
void GridMap::set_collision_mask(uint32_t p_mask) {
|
|
collision_mask = p_mask;
|
|
_update_physics_bodies_collision_properties();
|
|
}
|
|
|
|
uint32_t GridMap::get_collision_mask() const {
|
|
return collision_mask;
|
|
}
|
|
|
|
void GridMap::set_collision_layer_value(int p_layer_number, bool p_value) {
|
|
ERR_FAIL_COND_MSG(p_layer_number < 1, "Collision layer number must be between 1 and 32 inclusive.");
|
|
ERR_FAIL_COND_MSG(p_layer_number > 32, "Collision layer number must be between 1 and 32 inclusive.");
|
|
uint32_t collision_layer_new = get_collision_layer();
|
|
if (p_value) {
|
|
collision_layer_new |= 1 << (p_layer_number - 1);
|
|
} else {
|
|
collision_layer_new &= ~(1 << (p_layer_number - 1));
|
|
}
|
|
set_collision_layer(collision_layer_new);
|
|
}
|
|
|
|
bool GridMap::get_collision_layer_value(int p_layer_number) const {
|
|
ERR_FAIL_COND_V_MSG(p_layer_number < 1, false, "Collision layer number must be between 1 and 32 inclusive.");
|
|
ERR_FAIL_COND_V_MSG(p_layer_number > 32, false, "Collision layer number must be between 1 and 32 inclusive.");
|
|
return get_collision_layer() & (1 << (p_layer_number - 1));
|
|
}
|
|
|
|
void GridMap::set_collision_mask_value(int p_layer_number, bool p_value) {
|
|
ERR_FAIL_COND_MSG(p_layer_number < 1, "Collision layer number must be between 1 and 32 inclusive.");
|
|
ERR_FAIL_COND_MSG(p_layer_number > 32, "Collision layer number must be between 1 and 32 inclusive.");
|
|
uint32_t mask = get_collision_mask();
|
|
if (p_value) {
|
|
mask |= 1 << (p_layer_number - 1);
|
|
} else {
|
|
mask &= ~(1 << (p_layer_number - 1));
|
|
}
|
|
set_collision_mask(mask);
|
|
}
|
|
|
|
void GridMap::set_collision_priority(real_t p_priority) {
|
|
collision_priority = p_priority;
|
|
_update_physics_bodies_collision_properties();
|
|
}
|
|
|
|
real_t GridMap::get_collision_priority() const {
|
|
return collision_priority;
|
|
}
|
|
|
|
void GridMap::set_physics_material(Ref<PhysicsMaterial> p_material) {
|
|
physics_material = p_material;
|
|
_recreate_octant_data();
|
|
}
|
|
|
|
Ref<PhysicsMaterial> GridMap::get_physics_material() const {
|
|
return physics_material;
|
|
}
|
|
|
|
bool GridMap::get_collision_mask_value(int p_layer_number) const {
|
|
ERR_FAIL_COND_V_MSG(p_layer_number < 1, false, "Collision layer number must be between 1 and 32 inclusive.");
|
|
ERR_FAIL_COND_V_MSG(p_layer_number > 32, false, "Collision layer number must be between 1 and 32 inclusive.");
|
|
return get_collision_mask() & (1 << (p_layer_number - 1));
|
|
}
|
|
|
|
Array GridMap::get_collision_shapes() const {
|
|
Array shapes;
|
|
for (const KeyValue<OctantKey, Octant *> &E : octant_map) {
|
|
Octant *g = E.value;
|
|
RID body = g->static_body;
|
|
Transform3D body_xform = PhysicsServer3D::get_singleton()->body_get_state(body, PhysicsServer3D::BODY_STATE_TRANSFORM);
|
|
int nshapes = PhysicsServer3D::get_singleton()->body_get_shape_count(body);
|
|
for (int i = 0; i < nshapes; i++) {
|
|
RID shape = PhysicsServer3D::get_singleton()->body_get_shape(body, i);
|
|
Transform3D xform = PhysicsServer3D::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_map(RID p_navigation_map) {
|
|
map_override = p_navigation_map;
|
|
for (const KeyValue<OctantKey, Octant *> &E : octant_map) {
|
|
Octant &g = *octant_map[E.key];
|
|
for (KeyValue<IndexKey, Octant::NavigationCell> &F : g.navigation_cell_ids) {
|
|
if (F.value.region.is_valid()) {
|
|
NavigationServer3D::get_singleton()->region_set_map(F.value.region, map_override);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
RID GridMap::get_navigation_map() const {
|
|
if (map_override.is_valid()) {
|
|
return map_override;
|
|
} else if (is_inside_tree()) {
|
|
return get_world_3d()->get_navigation_map();
|
|
}
|
|
return RID();
|
|
}
|
|
|
|
void GridMap::set_mesh_library(const Ref<MeshLibrary> &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();
|
|
}
|
|
|
|
Ref<MeshLibrary> GridMap::get_mesh_library() const {
|
|
return mesh_library;
|
|
}
|
|
|
|
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(SNAME("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(const Vector3i &p_position, 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_position.x), 1 << 20);
|
|
ERR_FAIL_INDEX(ABS(p_position.y), 1 << 20);
|
|
ERR_FAIL_INDEX(ABS(p_position.z), 1 << 20);
|
|
|
|
IndexKey key;
|
|
key.x = p_position.x;
|
|
key.y = p_position.y;
|
|
key.z = p_position.z;
|
|
|
|
OctantKey ok;
|
|
ok.x = p_position.x / octant_size;
|
|
ok.y = p_position.y / octant_size;
|
|
ok.z = p_position.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 = PhysicsServer3D::get_singleton()->body_create();
|
|
PhysicsServer3D::get_singleton()->body_set_mode(g->static_body, PhysicsServer3D::BODY_MODE_STATIC);
|
|
PhysicsServer3D::get_singleton()->body_attach_object_instance_id(g->static_body, get_instance_id());
|
|
PhysicsServer3D::get_singleton()->body_set_collision_layer(g->static_body, collision_layer);
|
|
PhysicsServer3D::get_singleton()->body_set_collision_mask(g->static_body, collision_mask);
|
|
PhysicsServer3D::get_singleton()->body_set_collision_priority(g->static_body, collision_priority);
|
|
if (physics_material.is_valid()) {
|
|
PhysicsServer3D::get_singleton()->body_set_param(g->static_body, PhysicsServer3D::BODY_PARAM_FRICTION, physics_material->get_friction());
|
|
PhysicsServer3D::get_singleton()->body_set_param(g->static_body, PhysicsServer3D::BODY_PARAM_BOUNCE, physics_material->get_bounce());
|
|
}
|
|
SceneTree *st = SceneTree::get_singleton();
|
|
|
|
if (st && st->is_debugging_collisions_hint()) {
|
|
g->collision_debug = RenderingServer::get_singleton()->mesh_create();
|
|
g->collision_debug_instance = RenderingServer::get_singleton()->instance_create();
|
|
RenderingServer::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(const Vector3i &p_position) const {
|
|
ERR_FAIL_INDEX_V(ABS(p_position.x), 1 << 20, INVALID_CELL_ITEM);
|
|
ERR_FAIL_INDEX_V(ABS(p_position.y), 1 << 20, INVALID_CELL_ITEM);
|
|
ERR_FAIL_INDEX_V(ABS(p_position.z), 1 << 20, INVALID_CELL_ITEM);
|
|
|
|
IndexKey key;
|
|
key.x = p_position.x;
|
|
key.y = p_position.y;
|
|
key.z = p_position.z;
|
|
|
|
if (!cell_map.has(key)) {
|
|
return INVALID_CELL_ITEM;
|
|
}
|
|
return cell_map[key].item;
|
|
}
|
|
|
|
int GridMap::get_cell_item_orientation(const Vector3i &p_position) const {
|
|
ERR_FAIL_INDEX_V(ABS(p_position.x), 1 << 20, -1);
|
|
ERR_FAIL_INDEX_V(ABS(p_position.y), 1 << 20, -1);
|
|
ERR_FAIL_INDEX_V(ABS(p_position.z), 1 << 20, -1);
|
|
|
|
IndexKey key;
|
|
key.x = p_position.x;
|
|
key.y = p_position.y;
|
|
key.z = p_position.z;
|
|
|
|
if (!cell_map.has(key)) {
|
|
return -1;
|
|
}
|
|
return cell_map[key].rot;
|
|
}
|
|
|
|
static const Basis _ortho_bases[24] = {
|
|
Basis(1, 0, 0, 0, 1, 0, 0, 0, 1),
|
|
Basis(0, -1, 0, 1, 0, 0, 0, 0, 1),
|
|
Basis(-1, 0, 0, 0, -1, 0, 0, 0, 1),
|
|
Basis(0, 1, 0, -1, 0, 0, 0, 0, 1),
|
|
Basis(1, 0, 0, 0, 0, -1, 0, 1, 0),
|
|
Basis(0, 0, 1, 1, 0, 0, 0, 1, 0),
|
|
Basis(-1, 0, 0, 0, 0, 1, 0, 1, 0),
|
|
Basis(0, 0, -1, -1, 0, 0, 0, 1, 0),
|
|
Basis(1, 0, 0, 0, -1, 0, 0, 0, -1),
|
|
Basis(0, 1, 0, 1, 0, 0, 0, 0, -1),
|
|
Basis(-1, 0, 0, 0, 1, 0, 0, 0, -1),
|
|
Basis(0, -1, 0, -1, 0, 0, 0, 0, -1),
|
|
Basis(1, 0, 0, 0, 0, 1, 0, -1, 0),
|
|
Basis(0, 0, -1, 1, 0, 0, 0, -1, 0),
|
|
Basis(-1, 0, 0, 0, 0, -1, 0, -1, 0),
|
|
Basis(0, 0, 1, -1, 0, 0, 0, -1, 0),
|
|
Basis(0, 0, 1, 0, 1, 0, -1, 0, 0),
|
|
Basis(0, -1, 0, 0, 0, 1, -1, 0, 0),
|
|
Basis(0, 0, -1, 0, -1, 0, -1, 0, 0),
|
|
Basis(0, 1, 0, 0, 0, -1, -1, 0, 0),
|
|
Basis(0, 0, 1, 0, -1, 0, 1, 0, 0),
|
|
Basis(0, 1, 0, 0, 0, 1, 1, 0, 0),
|
|
Basis(0, 0, -1, 0, 1, 0, 1, 0, 0),
|
|
Basis(0, -1, 0, 0, 0, -1, 1, 0, 0)
|
|
};
|
|
|
|
Basis GridMap::get_cell_item_basis(const Vector3i &p_position) const {
|
|
int orientation = get_cell_item_orientation(p_position);
|
|
|
|
if (orientation == -1) {
|
|
return Basis();
|
|
}
|
|
|
|
return get_basis_with_orthogonal_index(orientation);
|
|
}
|
|
|
|
Basis GridMap::get_basis_with_orthogonal_index(int p_index) const {
|
|
ERR_FAIL_INDEX_V(p_index, 24, Basis());
|
|
|
|
return _ortho_bases[p_index];
|
|
}
|
|
|
|
int GridMap::get_orthogonal_index_from_basis(const Basis &p_basis) const {
|
|
Basis orth = p_basis;
|
|
for (int i = 0; i < 3; i++) {
|
|
for (int j = 0; j < 3; j++) {
|
|
real_t v = orth[i][j];
|
|
if (v > 0.5) {
|
|
v = 1.0;
|
|
} else if (v < -0.5) {
|
|
v = -1.0;
|
|
} else {
|
|
v = 0;
|
|
}
|
|
|
|
orth[i][j] = v;
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < 24; i++) {
|
|
if (_ortho_bases[i] == orth) {
|
|
return i;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
Vector3i GridMap::local_to_map(const Vector3 &p_world_position) const {
|
|
Vector3 map_position = (p_world_position / cell_size).floor();
|
|
return Vector3i(map_position);
|
|
}
|
|
|
|
Vector3 GridMap::map_to_local(const Vector3i &p_map_position) const {
|
|
Vector3 offset = _get_offset();
|
|
Vector3 local_position(
|
|
p_map_position.x * cell_size.x + offset.x,
|
|
p_map_position.y * cell_size.y + offset.y,
|
|
p_map_position.z * cell_size.z + offset.z);
|
|
return local_position;
|
|
}
|
|
|
|
void GridMap::_octant_transform(const OctantKey &p_key) {
|
|
ERR_FAIL_COND(!octant_map.has(p_key));
|
|
Octant &g = *octant_map[p_key];
|
|
PhysicsServer3D::get_singleton()->body_set_state(g.static_body, PhysicsServer3D::BODY_STATE_TRANSFORM, get_global_transform());
|
|
|
|
if (g.collision_debug_instance.is_valid()) {
|
|
RS::get_singleton()->instance_set_transform(g.collision_debug_instance, get_global_transform());
|
|
}
|
|
|
|
// update transform for NavigationServer regions and navigation debugmesh instances
|
|
for (const KeyValue<IndexKey, Octant::NavigationCell> &E : g.navigation_cell_ids) {
|
|
if (bake_navigation) {
|
|
if (E.value.region.is_valid()) {
|
|
NavigationServer3D::get_singleton()->region_set_transform(E.value.region, get_global_transform() * E.value.xform);
|
|
}
|
|
if (E.value.navigation_mesh_debug_instance.is_valid()) {
|
|
RS::get_singleton()->instance_set_transform(E.value.navigation_mesh_debug_instance, get_global_transform() * E.value.xform);
|
|
}
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < g.multimesh_instances.size(); i++) {
|
|
RS::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
|
|
PhysicsServer3D::get_singleton()->body_clear_shapes(g.static_body);
|
|
|
|
//erase body shapes debug
|
|
if (g.collision_debug.is_valid()) {
|
|
RS::get_singleton()->mesh_clear(g.collision_debug);
|
|
}
|
|
|
|
//erase navigation
|
|
for (const KeyValue<IndexKey, Octant::NavigationCell> &E : g.navigation_cell_ids) {
|
|
NavigationServer3D::get_singleton()->free(E.value.region);
|
|
if (E.value.navigation_mesh_debug_instance.is_valid()) {
|
|
RS::get_singleton()->free(E.value.navigation_mesh_debug_instance);
|
|
}
|
|
}
|
|
g.navigation_cell_ids.clear();
|
|
|
|
//erase multimeshes
|
|
|
|
for (int i = 0; i < g.multimesh_instances.size(); i++) {
|
|
RS::get_singleton()->free(g.multimesh_instances[i].instance);
|
|
RS::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;
|
|
}
|
|
|
|
Vector<Vector3> 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
|
|
*/
|
|
|
|
HashMap<int, List<Pair<Transform3D, IndexKey>>> multimesh_items;
|
|
|
|
for (const IndexKey &E : g.cells) {
|
|
ERR_CONTINUE(!cell_map.has(E));
|
|
const Cell &c = cell_map[E];
|
|
|
|
if (!mesh_library.is_valid() || !mesh_library->has_item(c.item)) {
|
|
continue;
|
|
}
|
|
|
|
Vector3 cellpos = Vector3(E.x, E.y, E.z);
|
|
Vector3 ofs = _get_offset();
|
|
|
|
Transform3D xform;
|
|
|
|
xform.basis = _ortho_bases[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<Transform3D, IndexKey>>();
|
|
}
|
|
|
|
Pair<Transform3D, IndexKey> p;
|
|
p.first = xform * mesh_library->get_item_mesh_transform(c.item);
|
|
p.second = E;
|
|
multimesh_items[c.item].push_back(p);
|
|
}
|
|
}
|
|
|
|
Vector<MeshLibrary::ShapeData> 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;
|
|
}
|
|
PhysicsServer3D::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 navigation_mesh at given xform to GridMap's Navigation ancestor
|
|
Ref<NavigationMesh> navigation_mesh = mesh_library->get_item_navigation_mesh(c.item);
|
|
if (navigation_mesh.is_valid()) {
|
|
Octant::NavigationCell nm;
|
|
nm.xform = xform * mesh_library->get_item_navigation_mesh_transform(c.item);
|
|
nm.navigation_layers = mesh_library->get_item_navigation_layers(c.item);
|
|
|
|
if (bake_navigation) {
|
|
RID region = NavigationServer3D::get_singleton()->region_create();
|
|
NavigationServer3D::get_singleton()->region_set_owner_id(region, get_instance_id());
|
|
NavigationServer3D::get_singleton()->region_set_navigation_layers(region, nm.navigation_layers);
|
|
NavigationServer3D::get_singleton()->region_set_navigation_mesh(region, navigation_mesh);
|
|
NavigationServer3D::get_singleton()->region_set_transform(region, get_global_transform() * nm.xform);
|
|
if (is_inside_tree()) {
|
|
if (map_override.is_valid()) {
|
|
NavigationServer3D::get_singleton()->region_set_map(region, map_override);
|
|
} else {
|
|
NavigationServer3D::get_singleton()->region_set_map(region, get_world_3d()->get_navigation_map());
|
|
}
|
|
}
|
|
nm.region = region;
|
|
|
|
#ifdef DEBUG_ENABLED
|
|
// add navigation debugmesh visual instances if debug is enabled
|
|
SceneTree *st = SceneTree::get_singleton();
|
|
if (st && st->is_debugging_navigation_hint()) {
|
|
if (!nm.navigation_mesh_debug_instance.is_valid()) {
|
|
RID navigation_mesh_debug_rid = navigation_mesh->get_debug_mesh()->get_rid();
|
|
nm.navigation_mesh_debug_instance = RS::get_singleton()->instance_create();
|
|
RS::get_singleton()->instance_set_base(nm.navigation_mesh_debug_instance, navigation_mesh_debug_rid);
|
|
}
|
|
if (is_inside_tree()) {
|
|
RS::get_singleton()->instance_set_scenario(nm.navigation_mesh_debug_instance, get_world_3d()->get_scenario());
|
|
RS::get_singleton()->instance_set_transform(nm.navigation_mesh_debug_instance, get_global_transform() * nm.xform);
|
|
}
|
|
}
|
|
#endif // DEBUG_ENABLED
|
|
}
|
|
g.navigation_cell_ids[E] = nm;
|
|
}
|
|
}
|
|
|
|
#ifdef DEBUG_ENABLED
|
|
if (bake_navigation) {
|
|
_update_octant_navigation_debug_edge_connections_mesh(p_key);
|
|
}
|
|
#endif // DEBUG_ENABLED
|
|
|
|
//update multimeshes, only if not baked
|
|
if (baked_meshes.size() == 0) {
|
|
for (const KeyValue<int, List<Pair<Transform3D, IndexKey>>> &E : multimesh_items) {
|
|
Octant::MultimeshInstance mmi;
|
|
|
|
RID mm = RS::get_singleton()->multimesh_create();
|
|
RS::get_singleton()->multimesh_allocate_data(mm, E.value.size(), RS::MULTIMESH_TRANSFORM_3D);
|
|
RS::get_singleton()->multimesh_set_mesh(mm, mesh_library->get_item_mesh(E.key)->get_rid());
|
|
|
|
int idx = 0;
|
|
for (const Pair<Transform3D, IndexKey> &F : E.value) {
|
|
RS::get_singleton()->multimesh_instance_set_transform(mm, idx, F.first);
|
|
#ifdef TOOLS_ENABLED
|
|
|
|
Octant::MultimeshInstance::Item it;
|
|
it.index = idx;
|
|
it.transform = F.first;
|
|
it.key = F.second;
|
|
mmi.items.push_back(it);
|
|
#endif
|
|
|
|
idx++;
|
|
}
|
|
|
|
RID instance = RS::get_singleton()->instance_create();
|
|
RS::get_singleton()->instance_set_base(instance, mm);
|
|
|
|
if (is_inside_tree()) {
|
|
RS::get_singleton()->instance_set_scenario(instance, get_world_3d()->get_scenario());
|
|
RS::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(RS::ARRAY_MAX);
|
|
arr[RS::ARRAY_VERTEX] = col_debug;
|
|
|
|
RS::get_singleton()->mesh_add_surface_from_arrays(g.collision_debug, RS::PRIMITIVE_LINES, arr);
|
|
SceneTree *st = SceneTree::get_singleton();
|
|
if (st) {
|
|
RS::get_singleton()->mesh_surface_set_material(g.collision_debug, 0, st->get_debug_collision_material()->get_rid());
|
|
}
|
|
}
|
|
|
|
g.dirty = false;
|
|
|
|
return false;
|
|
}
|
|
|
|
void GridMap::_update_physics_bodies_collision_properties() {
|
|
for (const KeyValue<OctantKey, Octant *> &E : octant_map) {
|
|
PhysicsServer3D::get_singleton()->body_set_collision_layer(E.value->static_body, collision_layer);
|
|
PhysicsServer3D::get_singleton()->body_set_collision_mask(E.value->static_body, collision_mask);
|
|
PhysicsServer3D::get_singleton()->body_set_collision_priority(E.value->static_body, collision_priority);
|
|
}
|
|
}
|
|
|
|
void GridMap::_octant_enter_world(const OctantKey &p_key) {
|
|
ERR_FAIL_COND(!octant_map.has(p_key));
|
|
Octant &g = *octant_map[p_key];
|
|
PhysicsServer3D::get_singleton()->body_set_state(g.static_body, PhysicsServer3D::BODY_STATE_TRANSFORM, get_global_transform());
|
|
PhysicsServer3D::get_singleton()->body_set_space(g.static_body, get_world_3d()->get_space());
|
|
|
|
if (g.collision_debug_instance.is_valid()) {
|
|
RS::get_singleton()->instance_set_scenario(g.collision_debug_instance, get_world_3d()->get_scenario());
|
|
RS::get_singleton()->instance_set_transform(g.collision_debug_instance, get_global_transform());
|
|
}
|
|
|
|
for (int i = 0; i < g.multimesh_instances.size(); i++) {
|
|
RS::get_singleton()->instance_set_scenario(g.multimesh_instances[i].instance, get_world_3d()->get_scenario());
|
|
RS::get_singleton()->instance_set_transform(g.multimesh_instances[i].instance, get_global_transform());
|
|
}
|
|
|
|
if (bake_navigation && mesh_library.is_valid()) {
|
|
for (KeyValue<IndexKey, Octant::NavigationCell> &F : g.navigation_cell_ids) {
|
|
if (cell_map.has(F.key) && F.value.region.is_valid() == false) {
|
|
Ref<NavigationMesh> navigation_mesh = mesh_library->get_item_navigation_mesh(cell_map[F.key].item);
|
|
if (navigation_mesh.is_valid()) {
|
|
RID region = NavigationServer3D::get_singleton()->region_create();
|
|
NavigationServer3D::get_singleton()->region_set_owner_id(region, get_instance_id());
|
|
NavigationServer3D::get_singleton()->region_set_navigation_layers(region, F.value.navigation_layers);
|
|
NavigationServer3D::get_singleton()->region_set_navigation_mesh(region, navigation_mesh);
|
|
NavigationServer3D::get_singleton()->region_set_transform(region, get_global_transform() * F.value.xform);
|
|
if (map_override.is_valid()) {
|
|
NavigationServer3D::get_singleton()->region_set_map(region, map_override);
|
|
} else {
|
|
NavigationServer3D::get_singleton()->region_set_map(region, get_world_3d()->get_navigation_map());
|
|
}
|
|
|
|
F.value.region = region;
|
|
}
|
|
}
|
|
}
|
|
|
|
#ifdef DEBUG_ENABLED
|
|
if (bake_navigation) {
|
|
if (!g.navigation_debug_edge_connections_instance.is_valid()) {
|
|
g.navigation_debug_edge_connections_instance = RenderingServer::get_singleton()->instance_create();
|
|
}
|
|
if (!g.navigation_debug_edge_connections_mesh.is_valid()) {
|
|
g.navigation_debug_edge_connections_mesh = Ref<ArrayMesh>(memnew(ArrayMesh));
|
|
}
|
|
|
|
_update_octant_navigation_debug_edge_connections_mesh(p_key);
|
|
}
|
|
#endif // DEBUG_ENABLED
|
|
}
|
|
}
|
|
|
|
void GridMap::_octant_exit_world(const OctantKey &p_key) {
|
|
ERR_FAIL_NULL(RenderingServer::get_singleton());
|
|
ERR_FAIL_NULL(PhysicsServer3D::get_singleton());
|
|
ERR_FAIL_NULL(NavigationServer3D::get_singleton());
|
|
|
|
ERR_FAIL_COND(!octant_map.has(p_key));
|
|
Octant &g = *octant_map[p_key];
|
|
PhysicsServer3D::get_singleton()->body_set_state(g.static_body, PhysicsServer3D::BODY_STATE_TRANSFORM, get_global_transform());
|
|
PhysicsServer3D::get_singleton()->body_set_space(g.static_body, RID());
|
|
|
|
if (g.collision_debug_instance.is_valid()) {
|
|
RS::get_singleton()->instance_set_scenario(g.collision_debug_instance, RID());
|
|
}
|
|
|
|
for (int i = 0; i < g.multimesh_instances.size(); i++) {
|
|
RS::get_singleton()->instance_set_scenario(g.multimesh_instances[i].instance, RID());
|
|
}
|
|
|
|
for (KeyValue<IndexKey, Octant::NavigationCell> &F : g.navigation_cell_ids) {
|
|
if (F.value.region.is_valid()) {
|
|
NavigationServer3D::get_singleton()->free(F.value.region);
|
|
F.value.region = RID();
|
|
}
|
|
if (F.value.navigation_mesh_debug_instance.is_valid()) {
|
|
RS::get_singleton()->free(F.value.navigation_mesh_debug_instance);
|
|
F.value.navigation_mesh_debug_instance = RID();
|
|
}
|
|
}
|
|
|
|
#ifdef DEBUG_ENABLED
|
|
if (bake_navigation) {
|
|
if (g.navigation_debug_edge_connections_instance.is_valid()) {
|
|
RenderingServer::get_singleton()->free(g.navigation_debug_edge_connections_instance);
|
|
g.navigation_debug_edge_connections_instance = RID();
|
|
}
|
|
if (g.navigation_debug_edge_connections_mesh.is_valid()) {
|
|
RenderingServer::get_singleton()->free(g.navigation_debug_edge_connections_mesh->get_rid());
|
|
}
|
|
}
|
|
#endif // DEBUG_ENABLED
|
|
}
|
|
|
|
void GridMap::_octant_clean_up(const OctantKey &p_key) {
|
|
ERR_FAIL_NULL(RenderingServer::get_singleton());
|
|
ERR_FAIL_NULL(PhysicsServer3D::get_singleton());
|
|
ERR_FAIL_NULL(NavigationServer3D::get_singleton());
|
|
|
|
ERR_FAIL_COND(!octant_map.has(p_key));
|
|
Octant &g = *octant_map[p_key];
|
|
|
|
if (g.collision_debug.is_valid()) {
|
|
RS::get_singleton()->free(g.collision_debug);
|
|
}
|
|
if (g.collision_debug_instance.is_valid()) {
|
|
RS::get_singleton()->free(g.collision_debug_instance);
|
|
}
|
|
|
|
PhysicsServer3D::get_singleton()->free(g.static_body);
|
|
|
|
// Erase navigation
|
|
for (const KeyValue<IndexKey, Octant::NavigationCell> &E : g.navigation_cell_ids) {
|
|
if (E.value.region.is_valid()) {
|
|
NavigationServer3D::get_singleton()->free(E.value.region);
|
|
}
|
|
if (E.value.navigation_mesh_debug_instance.is_valid()) {
|
|
RS::get_singleton()->free(E.value.navigation_mesh_debug_instance);
|
|
}
|
|
}
|
|
g.navigation_cell_ids.clear();
|
|
|
|
#ifdef DEBUG_ENABLED
|
|
if (bake_navigation) {
|
|
if (g.navigation_debug_edge_connections_instance.is_valid()) {
|
|
RenderingServer::get_singleton()->free(g.navigation_debug_edge_connections_instance);
|
|
g.navigation_debug_edge_connections_instance = RID();
|
|
}
|
|
if (g.navigation_debug_edge_connections_mesh.is_valid()) {
|
|
RenderingServer::get_singleton()->free(g.navigation_debug_edge_connections_mesh->get_rid());
|
|
}
|
|
}
|
|
#endif // DEBUG_ENABLED
|
|
|
|
//erase multimeshes
|
|
|
|
for (int i = 0; i < g.multimesh_instances.size(); i++) {
|
|
RS::get_singleton()->free(g.multimesh_instances[i].instance);
|
|
RS::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: {
|
|
last_transform = get_global_transform();
|
|
|
|
for (const KeyValue<OctantKey, Octant *> &E : octant_map) {
|
|
_octant_enter_world(E.key);
|
|
}
|
|
|
|
for (int i = 0; i < baked_meshes.size(); i++) {
|
|
RS::get_singleton()->instance_set_scenario(baked_meshes[i].instance, get_world_3d()->get_scenario());
|
|
RS::get_singleton()->instance_set_transform(baked_meshes[i].instance, get_global_transform());
|
|
}
|
|
} break;
|
|
|
|
#ifdef DEBUG_ENABLED
|
|
case NOTIFICATION_ENTER_TREE: {
|
|
if (bake_navigation && NavigationServer3D::get_singleton()->get_debug_enabled()) {
|
|
_update_navigation_debug_edge_connections();
|
|
}
|
|
} break;
|
|
#endif // DEBUG_ENABLED
|
|
|
|
case NOTIFICATION_TRANSFORM_CHANGED: {
|
|
Transform3D new_xform = get_global_transform();
|
|
if (new_xform == last_transform) {
|
|
break;
|
|
}
|
|
//update run
|
|
for (const KeyValue<OctantKey, Octant *> &E : octant_map) {
|
|
_octant_transform(E.key);
|
|
}
|
|
|
|
last_transform = new_xform;
|
|
|
|
for (int i = 0; i < baked_meshes.size(); i++) {
|
|
RS::get_singleton()->instance_set_transform(baked_meshes[i].instance, get_global_transform());
|
|
}
|
|
} break;
|
|
|
|
case NOTIFICATION_EXIT_WORLD: {
|
|
for (const KeyValue<OctantKey, Octant *> &E : octant_map) {
|
|
_octant_exit_world(E.key);
|
|
}
|
|
|
|
//_queue_octants_dirty(MAP_DIRTY_INSTANCES|MAP_DIRTY_TRANSFORMS);
|
|
//_update_octants_callback();
|
|
//_update_area_instances();
|
|
for (int i = 0; i < baked_meshes.size(); i++) {
|
|
RS::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;
|
|
}
|
|
|
|
for (KeyValue<OctantKey, Octant *> &e : octant_map) {
|
|
Octant *octant = e.value;
|
|
for (int i = 0; i < octant->multimesh_instances.size(); i++) {
|
|
const Octant::MultimeshInstance &mi = octant->multimesh_instances[i];
|
|
RS::get_singleton()->instance_set_visible(mi.instance, is_visible_in_tree());
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < baked_meshes.size(); i++) {
|
|
RS::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;
|
|
HashMap<IndexKey, Cell, IndexKey> cell_copy = cell_map;
|
|
_clear_internal();
|
|
for (const KeyValue<IndexKey, Cell> &E : cell_copy) {
|
|
set_cell_item(Vector3i(E.key), E.value.item, E.value.rot);
|
|
}
|
|
recreating_octants = false;
|
|
}
|
|
|
|
void GridMap::_clear_internal() {
|
|
for (const KeyValue<OctantKey, Octant *> &E : octant_map) {
|
|
if (is_inside_world()) {
|
|
_octant_exit_world(E.key);
|
|
}
|
|
|
|
_octant_clean_up(E.key);
|
|
memdelete(E.value);
|
|
}
|
|
|
|
octant_map.clear();
|
|
cell_map.clear();
|
|
}
|
|
|
|
void GridMap::clear() {
|
|
_clear_internal();
|
|
clear_baked_meshes();
|
|
}
|
|
|
|
void GridMap::resource_changed(const Ref<Resource> &p_res) {
|
|
_recreate_octant_data();
|
|
}
|
|
|
|
void GridMap::_update_octants_callback() {
|
|
if (!awaiting_update) {
|
|
return;
|
|
}
|
|
|
|
List<OctantKey> to_delete;
|
|
for (const KeyValue<OctantKey, Octant *> &E : octant_map) {
|
|
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_value", "layer_number", "value"), &GridMap::set_collision_mask_value);
|
|
ClassDB::bind_method(D_METHOD("get_collision_mask_value", "layer_number"), &GridMap::get_collision_mask_value);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_collision_layer_value", "layer_number", "value"), &GridMap::set_collision_layer_value);
|
|
ClassDB::bind_method(D_METHOD("get_collision_layer_value", "layer_number"), &GridMap::get_collision_layer_value);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_collision_priority", "priority"), &GridMap::set_collision_priority);
|
|
ClassDB::bind_method(D_METHOD("get_collision_priority"), &GridMap::get_collision_priority);
|
|
|
|
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_map", "navigation_map"), &GridMap::set_navigation_map);
|
|
ClassDB::bind_method(D_METHOD("get_navigation_map"), &GridMap::get_navigation_map);
|
|
|
|
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", "position", "item", "orientation"), &GridMap::set_cell_item, DEFVAL(0));
|
|
ClassDB::bind_method(D_METHOD("get_cell_item", "position"), &GridMap::get_cell_item);
|
|
ClassDB::bind_method(D_METHOD("get_cell_item_orientation", "position"), &GridMap::get_cell_item_orientation);
|
|
ClassDB::bind_method(D_METHOD("get_cell_item_basis", "position"), &GridMap::get_cell_item_basis);
|
|
ClassDB::bind_method(D_METHOD("get_basis_with_orthogonal_index", "index"), &GridMap::get_basis_with_orthogonal_index);
|
|
ClassDB::bind_method(D_METHOD("get_orthogonal_index_from_basis", "basis"), &GridMap::get_orthogonal_index_from_basis);
|
|
|
|
ClassDB::bind_method(D_METHOD("local_to_map", "local_position"), &GridMap::local_to_map);
|
|
ClassDB::bind_method(D_METHOD("map_to_local", "map_position"), &GridMap::map_to_local);
|
|
|
|
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("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));
|
|
|
|
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_GROUP("Cell", "cell_");
|
|
ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "cell_size", PROPERTY_HINT_NONE, "suffix:m"), "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::FLOAT, "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::FLOAT, "collision_priority"), "set_collision_priority", "get_collision_priority");
|
|
ADD_GROUP("Navigation", "");
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "bake_navigation"), "set_bake_navigation", "is_baking_navigation");
|
|
|
|
BIND_CONSTANT(INVALID_CELL_ITEM);
|
|
|
|
ADD_SIGNAL(MethodInfo("cell_size_changed", PropertyInfo(Variant::VECTOR3, "cell_size")));
|
|
}
|
|
|
|
void GridMap::set_cell_scale(float p_scale) {
|
|
cell_scale = p_scale;
|
|
_recreate_octant_data();
|
|
}
|
|
|
|
float GridMap::get_cell_scale() const {
|
|
return cell_scale;
|
|
}
|
|
|
|
TypedArray<Vector3i> GridMap::get_used_cells() const {
|
|
TypedArray<Vector3i> a;
|
|
a.resize(cell_map.size());
|
|
int i = 0;
|
|
for (const KeyValue<IndexKey, Cell> &E : cell_map) {
|
|
Vector3i p(E.key.x, E.key.y, E.key.z);
|
|
a[i++] = p;
|
|
}
|
|
|
|
return a;
|
|
}
|
|
|
|
TypedArray<Vector3i> GridMap::get_used_cells_by_item(int p_item) const {
|
|
TypedArray<Vector3i> a;
|
|
for (const KeyValue<IndexKey, Cell> &E : cell_map) {
|
|
if ((int)E.value.item == p_item) {
|
|
Vector3i 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 (const KeyValue<IndexKey, Cell> &E : cell_map) {
|
|
int id = E.value.item;
|
|
if (!mesh_library->has_item(id)) {
|
|
continue;
|
|
}
|
|
Ref<Mesh> 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);
|
|
|
|
Transform3D xform;
|
|
|
|
xform.basis = _ortho_bases[E.value.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() {
|
|
ERR_FAIL_NULL(RenderingServer::get_singleton());
|
|
for (int i = 0; i < baked_meshes.size(); i++) {
|
|
RS::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
|
|
HashMap<OctantKey, HashMap<Ref<Material>, Ref<SurfaceTool>>, OctantKey> surface_map;
|
|
|
|
for (KeyValue<IndexKey, Cell> &E : cell_map) {
|
|
IndexKey key = E.key;
|
|
|
|
int item = E.value.item;
|
|
if (!mesh_library->has_item(item)) {
|
|
continue;
|
|
}
|
|
|
|
Ref<Mesh> 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();
|
|
|
|
Transform3D xform;
|
|
|
|
xform.basis = _ortho_bases[E.value.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] = HashMap<Ref<Material>, Ref<SurfaceTool>>();
|
|
}
|
|
|
|
HashMap<Ref<Material>, Ref<SurfaceTool>> &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<Material> surf_mat = mesh->surface_get_material(i);
|
|
if (!mat_map.has(surf_mat)) {
|
|
Ref<SurfaceTool> st;
|
|
st.instantiate();
|
|
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 (KeyValue<OctantKey, HashMap<Ref<Material>, Ref<SurfaceTool>>> &E : surface_map) {
|
|
Ref<ArrayMesh> mesh;
|
|
mesh.instantiate();
|
|
for (KeyValue<Ref<Material>, Ref<SurfaceTool>> &F : E.value) {
|
|
F.value->commit(mesh);
|
|
}
|
|
|
|
BakedMesh bm;
|
|
bm.mesh = mesh;
|
|
bm.instance = RS::get_singleton()->instance_create();
|
|
RS::get_singleton()->instance_set_base(bm.instance, bm.mesh->get_rid());
|
|
RS::get_singleton()->instance_attach_object_instance_id(bm.instance, get_instance_id());
|
|
if (is_inside_tree()) {
|
|
RS::get_singleton()->instance_set_scenario(bm.instance, get_world_3d()->get_scenario());
|
|
RS::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 (!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(Transform3D());
|
|
}
|
|
|
|
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() {
|
|
set_notify_transform(true);
|
|
#ifdef DEBUG_ENABLED
|
|
NavigationServer3D::get_singleton_mut()->connect("map_changed", callable_mp(this, &GridMap::_navigation_map_changed));
|
|
NavigationServer3D::get_singleton_mut()->connect("navigation_debug_changed", callable_mp(this, &GridMap::_update_navigation_debug_edge_connections));
|
|
#endif // DEBUG_ENABLED
|
|
}
|
|
|
|
#ifdef DEBUG_ENABLED
|
|
void GridMap::_update_navigation_debug_edge_connections() {
|
|
if (bake_navigation) {
|
|
for (const KeyValue<OctantKey, Octant *> &E : octant_map) {
|
|
_update_octant_navigation_debug_edge_connections_mesh(E.key);
|
|
}
|
|
}
|
|
}
|
|
|
|
void GridMap::_navigation_map_changed(RID p_map) {
|
|
if (bake_navigation && is_inside_tree() && p_map == get_world_3d()->get_navigation_map()) {
|
|
_update_navigation_debug_edge_connections();
|
|
}
|
|
}
|
|
#endif // DEBUG_ENABLED
|
|
|
|
GridMap::~GridMap() {
|
|
if (!mesh_library.is_null()) {
|
|
mesh_library->unregister_owner(this);
|
|
}
|
|
|
|
clear();
|
|
#ifdef DEBUG_ENABLED
|
|
NavigationServer3D::get_singleton_mut()->disconnect("map_changed", callable_mp(this, &GridMap::_navigation_map_changed));
|
|
NavigationServer3D::get_singleton_mut()->disconnect("navigation_debug_changed", callable_mp(this, &GridMap::_update_navigation_debug_edge_connections));
|
|
#endif // DEBUG_ENABLED
|
|
}
|
|
|
|
#ifdef DEBUG_ENABLED
|
|
void GridMap::_update_octant_navigation_debug_edge_connections_mesh(const OctantKey &p_key) {
|
|
ERR_FAIL_COND(!octant_map.has(p_key));
|
|
Octant &g = *octant_map[p_key];
|
|
|
|
if (!NavigationServer3D::get_singleton()->get_debug_enabled()) {
|
|
if (g.navigation_debug_edge_connections_instance.is_valid()) {
|
|
RS::get_singleton()->instance_set_visible(g.navigation_debug_edge_connections_instance, false);
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (!is_inside_tree()) {
|
|
return;
|
|
}
|
|
|
|
if (!bake_navigation) {
|
|
if (g.navigation_debug_edge_connections_instance.is_valid()) {
|
|
RS::get_singleton()->instance_set_visible(g.navigation_debug_edge_connections_instance, false);
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (!g.navigation_debug_edge_connections_instance.is_valid()) {
|
|
g.navigation_debug_edge_connections_instance = RenderingServer::get_singleton()->instance_create();
|
|
}
|
|
|
|
if (!g.navigation_debug_edge_connections_mesh.is_valid()) {
|
|
g.navigation_debug_edge_connections_mesh = Ref<ArrayMesh>(memnew(ArrayMesh));
|
|
}
|
|
|
|
g.navigation_debug_edge_connections_mesh->clear_surfaces();
|
|
|
|
float edge_connection_margin = NavigationServer3D::get_singleton()->map_get_edge_connection_margin(get_world_3d()->get_navigation_map());
|
|
float half_edge_connection_margin = edge_connection_margin * 0.5;
|
|
|
|
Vector<Vector3> vertex_array;
|
|
|
|
for (KeyValue<IndexKey, Octant::NavigationCell> &F : g.navigation_cell_ids) {
|
|
if (cell_map.has(F.key) && F.value.region.is_valid()) {
|
|
int connections_count = NavigationServer3D::get_singleton()->region_get_connections_count(F.value.region);
|
|
if (connections_count == 0) {
|
|
continue;
|
|
}
|
|
|
|
for (int i = 0; i < connections_count; i++) {
|
|
Vector3 connection_pathway_start = NavigationServer3D::get_singleton()->region_get_connection_pathway_start(F.value.region, i);
|
|
Vector3 connection_pathway_end = NavigationServer3D::get_singleton()->region_get_connection_pathway_end(F.value.region, i);
|
|
|
|
Vector3 direction_start_end = connection_pathway_start.direction_to(connection_pathway_end);
|
|
Vector3 direction_end_start = connection_pathway_end.direction_to(connection_pathway_start);
|
|
|
|
Vector3 start_right_dir = direction_start_end.cross(Vector3(0, 1, 0));
|
|
Vector3 start_left_dir = -start_right_dir;
|
|
|
|
Vector3 end_right_dir = direction_end_start.cross(Vector3(0, 1, 0));
|
|
Vector3 end_left_dir = -end_right_dir;
|
|
|
|
Vector3 left_start_pos = connection_pathway_start + (start_left_dir * half_edge_connection_margin);
|
|
Vector3 right_start_pos = connection_pathway_start + (start_right_dir * half_edge_connection_margin);
|
|
Vector3 left_end_pos = connection_pathway_end + (end_right_dir * half_edge_connection_margin);
|
|
Vector3 right_end_pos = connection_pathway_end + (end_left_dir * half_edge_connection_margin);
|
|
|
|
vertex_array.push_back(right_end_pos);
|
|
vertex_array.push_back(left_start_pos);
|
|
vertex_array.push_back(right_start_pos);
|
|
|
|
vertex_array.push_back(left_end_pos);
|
|
vertex_array.push_back(right_end_pos);
|
|
vertex_array.push_back(right_start_pos);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (vertex_array.size() == 0) {
|
|
return;
|
|
}
|
|
|
|
Ref<StandardMaterial3D> edge_connections_material = NavigationServer3D::get_singleton_mut()->get_debug_navigation_edge_connections_material();
|
|
|
|
Array mesh_array;
|
|
mesh_array.resize(Mesh::ARRAY_MAX);
|
|
mesh_array[Mesh::ARRAY_VERTEX] = vertex_array;
|
|
|
|
g.navigation_debug_edge_connections_mesh->add_surface_from_arrays(Mesh::PRIMITIVE_TRIANGLES, mesh_array);
|
|
g.navigation_debug_edge_connections_mesh->surface_set_material(0, edge_connections_material);
|
|
|
|
RS::get_singleton()->instance_set_base(g.navigation_debug_edge_connections_instance, g.navigation_debug_edge_connections_mesh->get_rid());
|
|
RS::get_singleton()->instance_set_visible(g.navigation_debug_edge_connections_instance, is_visible_in_tree());
|
|
if (is_inside_tree()) {
|
|
RS::get_singleton()->instance_set_scenario(g.navigation_debug_edge_connections_instance, get_world_3d()->get_scenario());
|
|
}
|
|
|
|
bool enable_edge_connections = NavigationServer3D::get_singleton()->get_debug_navigation_enable_edge_connections();
|
|
if (!enable_edge_connections) {
|
|
RS::get_singleton()->instance_set_visible(g.navigation_debug_edge_connections_instance, false);
|
|
}
|
|
}
|
|
#endif // DEBUG_ENABLED
|