33b5c57199
- Renames PackedIntArray to PackedInt32Array. - Renames PackedFloatArray to PackedFloat32Array. - Adds PackedInt64Array and PackedFloat64Array. - Renames Variant::REAL to Variant::FLOAT for consistency. Packed arrays are for storing large amount of data and creating stuff like meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of memory. That said, many users requested the ability to have 64 bits packed arrays for their games, so this is just an optional added type. For Variant, the float datatype is always 64 bits, and exposed as `float`. We still have `real_t` which is the datatype that can change from 32 to 64 bits depending on a compile flag (not entirely working right now, but that's the idea). It affects math related datatypes and code only. Neither Variant nor PackedArray make use of real_t, which is only intended for math precision, so the term is removed from there to keep only float.
1122 lines
32 KiB
C++
1122 lines
32 KiB
C++
/*************************************************************************/
|
|
/* grid_map.cpp */
|
|
/*************************************************************************/
|
|
/* This file is part of: */
|
|
/* GODOT ENGINE */
|
|
/* https://godotengine.org */
|
|
/*************************************************************************/
|
|
/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */
|
|
/* Copyright (c) 2014-2020 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/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")) {
|
|
|
|
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 = VS::get_singleton()->instance_create();
|
|
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;
|
|
|
|
Vector<int> cells;
|
|
cells.resize(cell_map.size() * 3);
|
|
{
|
|
int *w = cells.ptrw();
|
|
int i = 0;
|
|
for (Map<IndexKey, Cell>::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<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;
|
|
_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) {
|
|
|
|
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 {
|
|
|
|
return get_collision_mask() & (1 << p_bit);
|
|
}
|
|
|
|
void GridMap::set_collision_layer_bit(int p_bit, bool p_value) {
|
|
|
|
uint32_t mask = get_collision_layer();
|
|
if (p_value)
|
|
mask |= 1 << p_bit;
|
|
else
|
|
mask &= ~(1 << p_bit);
|
|
set_collision_layer(mask);
|
|
}
|
|
|
|
bool GridMap::get_collision_layer_bit(int p_bit) const {
|
|
|
|
return get_collision_layer() & (1 << p_bit);
|
|
}
|
|
|
|
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();
|
|
_change_notify("mesh_library");
|
|
}
|
|
|
|
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("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 = 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);
|
|
SceneTree *st = SceneTree::get_singleton();
|
|
|
|
if (st && st->is_debugging_collisions_hint()) {
|
|
|
|
g->collision_debug = VisualServer::get_singleton()->mesh_create();
|
|
g->collision_debug_instance = VisualServer::get_singleton()->instance_create();
|
|
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());
|
|
}
|
|
|
|
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<IndexKey, Octant::NavMesh>::Element *E = g.navmesh_ids.front(); E; E = E->next()) {
|
|
NavigationServer::get_singleton()->free(E->get().region);
|
|
}
|
|
g.navmesh_ids.clear();
|
|
|
|
//erase multimeshes
|
|
|
|
for (int i = 0; i < g.multimesh_instances.size(); i++) {
|
|
|
|
VS::get_singleton()->free(g.multimesh_instances[i].instance);
|
|
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;
|
|
}
|
|
|
|
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
|
|
*/
|
|
|
|
Map<int, List<Pair<Transform, IndexKey> > > multimesh_items;
|
|
|
|
for (Set<IndexKey>::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<Transform, IndexKey> >();
|
|
}
|
|
|
|
Pair<Transform, IndexKey> p;
|
|
p.first = xform;
|
|
p.second = E->get();
|
|
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;
|
|
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<NavigationMesh> 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 (navigation) {
|
|
RID region = NavigationServer::get_singleton()->region_create();
|
|
NavigationServer::get_singleton()->region_set_navmesh(region, navmesh);
|
|
NavigationServer::get_singleton()->region_set_transform(region, navigation->get_global_transform() * nm.xform);
|
|
NavigationServer::get_singleton()->region_set_map(region, navigation->get_rid());
|
|
nm.region = region;
|
|
}
|
|
g.navmesh_ids[E->get()] = nm;
|
|
}
|
|
}
|
|
|
|
//update multimeshes, only if not baked
|
|
if (baked_meshes.size() == 0) {
|
|
|
|
for (Map<int, List<Pair<Transform, IndexKey> > >::Element *E = multimesh_items.front(); E; E = E->next()) {
|
|
Octant::MultimeshInstance mmi;
|
|
|
|
RID mm = VS::get_singleton()->multimesh_create();
|
|
VS::get_singleton()->multimesh_allocate(mm, E->get().size(), VS::MULTIMESH_TRANSFORM_3D);
|
|
VS::get_singleton()->multimesh_set_mesh(mm, mesh_library->get_item_mesh(E->key())->get_rid());
|
|
|
|
int idx = 0;
|
|
for (List<Pair<Transform, IndexKey> >::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 = VS::get_singleton()->instance_create();
|
|
VS::get_singleton()->instance_set_base(instance, mm);
|
|
|
|
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<OctantKey, Octant *>::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 (navigation && mesh_library.is_valid()) {
|
|
for (Map<IndexKey, Octant::NavMesh>::Element *F = g.navmesh_ids.front(); F; F = F->next()) {
|
|
|
|
if (cell_map.has(F->key()) && F->get().region.is_valid() == false) {
|
|
Ref<NavigationMesh> nm = mesh_library->get_item_navmesh(cell_map[F->key()].item);
|
|
if (nm.is_valid()) {
|
|
RID region = NavigationServer::get_singleton()->region_create();
|
|
NavigationServer::get_singleton()->region_set_navmesh(region, nm);
|
|
NavigationServer::get_singleton()->region_set_transform(region, navigation->get_global_transform() * F->get().xform);
|
|
NavigationServer::get_singleton()->region_set_map(region, navigation->get_rid());
|
|
F->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());
|
|
}
|
|
|
|
if (navigation) {
|
|
for (Map<IndexKey, Octant::NavMesh>::Element *F = g.navmesh_ids.front(); F; F = F->next()) {
|
|
|
|
if (F->get().region.is_valid()) {
|
|
NavigationServer::get_singleton()->free(F->get().region);
|
|
F->get().region = 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);
|
|
if (g.collision_debug_instance.is_valid())
|
|
VS::get_singleton()->free(g.collision_debug_instance);
|
|
|
|
PhysicsServer::get_singleton()->free(g.static_body);
|
|
|
|
// Erase navigation
|
|
for (Map<IndexKey, Octant::NavMesh>::Element *E = g.navmesh_ids.front(); E; E = E->next()) {
|
|
NavigationServer::get_singleton()->free(E->get().region);
|
|
}
|
|
g.navmesh_ids.clear();
|
|
|
|
//erase multimeshes
|
|
|
|
for (int i = 0; i < g.multimesh_instances.size(); i++) {
|
|
|
|
VS::get_singleton()->free(g.multimesh_instances[i].instance);
|
|
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<Navigation>(c);
|
|
if (navigation) {
|
|
break;
|
|
}
|
|
|
|
c = Object::cast_to<Spatial>(c->get_parent());
|
|
}
|
|
|
|
last_transform = get_global_transform();
|
|
|
|
for (Map<OctantKey, Octant *>::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<OctantKey, Octant *>::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<OctantKey, Octant *>::Element *E = octant_map.front(); E; E = E->next()) {
|
|
_octant_exit_world(E->key());
|
|
}
|
|
|
|
navigation = NULL;
|
|
|
|
//_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<OctantKey, Octant *>::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());
|
|
}
|
|
}
|
|
}
|
|
|
|
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<IndexKey, Cell> cell_copy = cell_map;
|
|
_clear_internal();
|
|
for (Map<IndexKey, Cell>::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<OctantKey, Octant *>::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<OctantKey> to_delete;
|
|
for (Map<OctantKey, Octant *>::Element *E = octant_map.front(); E; E = E->next()) {
|
|
|
|
if (_octant_update(E->key())) {
|
|
to_delete.push_back(E->key());
|
|
}
|
|
}
|
|
|
|
while (to_delete.front()) {
|
|
octant_map.erase(to_delete.front()->get());
|
|
to_delete.pop_back();
|
|
}
|
|
|
|
_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_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_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_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::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");
|
|
|
|
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<OctantKey, Octant *>::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<IndexKey, Cell>::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_meshes() {
|
|
|
|
if (mesh_library.is_null())
|
|
return Array();
|
|
|
|
Vector3 ofs = _get_offset();
|
|
Array meshes;
|
|
|
|
for (Map<IndexKey, Cell>::Element *E = cell_map.front(); E; E = E->next()) {
|
|
|
|
int id = E->get().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);
|
|
|
|
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);
|
|
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++) {
|
|
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<OctantKey, Map<Ref<Material>, Ref<SurfaceTool> > > surface_map;
|
|
|
|
for (Map<IndexKey, Cell>::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 = 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<Material>, Ref<SurfaceTool> >();
|
|
}
|
|
|
|
Map<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.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<OctantKey, Map<Ref<Material>, Ref<SurfaceTool> > >::Element *E = surface_map.front(); E; E = E->next()) {
|
|
|
|
Ref<ArrayMesh> mesh;
|
|
mesh.instance();
|
|
for (Map<Ref<Material>, Ref<SurfaceTool> >::Element *F = E->get().front(); F; F = F->next()) {
|
|
F->get()->commit(mesh);
|
|
}
|
|
|
|
BakedMesh bm;
|
|
bm.mesh = mesh;
|
|
bm.instance = VS::get_singleton()->instance_create();
|
|
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 (!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 = NULL;
|
|
set_notify_transform(true);
|
|
recreating_octants = false;
|
|
}
|
|
|
|
GridMap::~GridMap() {
|
|
|
|
if (!mesh_library.is_null())
|
|
mesh_library->unregister_owner(this);
|
|
|
|
clear();
|
|
}
|