-Largely rewrote gridmap to simplify it
-Got editor working again -Added a current-floor marker on selection
This commit is contained in:
Juan Linietsky
parent
bd282ff43f
commit
37da8155a4
7 changed files with 429 additions and 334 deletions
|
|
@ -98,7 +98,7 @@ void MeshLibraryEditor::_import_scene(Node *p_scene, Ref<MeshLibrary> p_library,
|
|||
|
||||
p_library->set_item_mesh(id, mesh);
|
||||
|
||||
Ref<Shape> collision;
|
||||
Vector<MeshLibrary::ShapeData> collisions;
|
||||
|
||||
for (int j = 0; j < mi->get_child_count(); j++) {
|
||||
|
||||
|
|
@ -119,24 +119,19 @@ void MeshLibraryEditor::_import_scene(Node *p_scene, Ref<MeshLibrary> p_library,
|
|||
|
||||
for (int k = 0; k < sb->shape_owner_get_shape_count(E->get()); k++) {
|
||||
|
||||
collision = sb->shape_owner_get_shape(E->get(), k);
|
||||
Ref<Shape> collision = sb->shape_owner_get_shape(E->get(), k);
|
||||
if (collision.is_valid())
|
||||
break;
|
||||
/* TileSet::ShapeData shape_data;
|
||||
shape_data.shape = shape;
|
||||
shape_data.shape_transform = shape_transform;
|
||||
shape_data.one_way_collision = one_way;
|
||||
collisions.push_back(shape_data);*/
|
||||
continue;
|
||||
MeshLibrary::ShapeData shape_data;
|
||||
shape_data.shape = collision;
|
||||
shape_data.local_transform = sb->shape_owner_get_transform(E->get());
|
||||
collisions.push_back(shape_data);
|
||||
}
|
||||
if (collision.is_valid())
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!collision.is_null()) {
|
||||
p_library->set_item_shapes(id, collisions);
|
||||
|
||||
p_library->set_item_shape(id, collision);
|
||||
}
|
||||
Ref<NavigationMesh> navmesh;
|
||||
for (int j = 0; j < mi->get_child_count(); j++) {
|
||||
Node *child2 = mi->get_child(j);
|
||||
|
|
|
|||
|
|
@ -46,7 +46,13 @@ bool GridMap::_set(const StringName &p_name, const Variant &p_value) {
|
|||
|
||||
set_theme(p_value);
|
||||
} else if (name == "cell_size") {
|
||||
if (p_value.get_type() == Variant::INT || p_value.get_type() == Variant::REAL) {
|
||||
//compatibility
|
||||
float cs = p_value;
|
||||
set_cell_size(Vector3(cs, cs, cs));
|
||||
} else {
|
||||
set_cell_size(p_value);
|
||||
}
|
||||
} else if (name == "cell_octant_size") {
|
||||
set_octant_size(p_value);
|
||||
} else if (name == "cell_center_x") {
|
||||
|
|
@ -176,12 +182,12 @@ Ref<MeshLibrary> GridMap::get_theme() const {
|
|||
return theme;
|
||||
}
|
||||
|
||||
void GridMap::set_cell_size(float p_size) {
|
||||
void GridMap::set_cell_size(const Vector3 &p_size) {
|
||||
|
||||
cell_size = p_size;
|
||||
_recreate_octant_data();
|
||||
}
|
||||
float GridMap::get_cell_size() const {
|
||||
Vector3 GridMap::get_cell_size() const {
|
||||
|
||||
return cell_size;
|
||||
}
|
||||
|
|
@ -242,56 +248,29 @@ void GridMap::set_cell_item(int p_x, int p_y, int p_z, int p_item, int p_rot) {
|
|||
ok.y = p_y / octant_size;
|
||||
ok.z = p_z / octant_size;
|
||||
|
||||
if (p_item < 0) {
|
||||
//erase
|
||||
if (cell_map.has(key)) {
|
||||
|
||||
int prev_item = cell_map[key].item;
|
||||
|
||||
OctantKey octantkey = ok;
|
||||
|
||||
ERR_FAIL_COND(!octant_map.has(octantkey));
|
||||
Octant &g = *octant_map[octantkey];
|
||||
ERR_FAIL_COND(!g.items.has(prev_item));
|
||||
ERR_FAIL_COND(!g.items[prev_item].cells.has(key));
|
||||
|
||||
g.items[prev_item].cells.erase(key);
|
||||
if (g.items[prev_item].cells.size() == 0) {
|
||||
VS::get_singleton()->free(g.items[prev_item].multimesh_instance);
|
||||
g.items.erase(prev_item);
|
||||
}
|
||||
if (g.items.empty()) {
|
||||
|
||||
PhysicsServer::get_singleton()->free(g.static_body);
|
||||
if (g.collision_debug.is_valid()) {
|
||||
PhysicsServer::get_singleton()->free(g.collision_debug);
|
||||
PhysicsServer::get_singleton()->free(g.collision_debug_instance);
|
||||
}
|
||||
|
||||
memdelete(&g);
|
||||
octant_map.erase(octantkey);
|
||||
} else {
|
||||
|
||||
g.cells.erase(key);
|
||||
g.dirty = true;
|
||||
}
|
||||
cell_map.erase(key);
|
||||
|
||||
_queue_dirty_map();
|
||||
_queue_octants_dirty();
|
||||
}
|
||||
|
||||
if (p_item < 0)
|
||||
return;
|
||||
}
|
||||
|
||||
OctantKey octantkey = ok;
|
||||
|
||||
//add later
|
||||
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());
|
||||
if (is_inside_world())
|
||||
PhysicsServer::get_singleton()->body_set_space(g->static_body, get_world()->get_space());
|
||||
|
||||
SceneTree *st = SceneTree::get_singleton();
|
||||
|
||||
if (st && st->is_debugging_collisions_hint()) {
|
||||
|
|
@ -299,45 +278,26 @@ void GridMap::set_cell_item(int p_x, int p_y, int p_z, int p_item, int p_rot) {
|
|||
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);
|
||||
if (is_inside_world()) {
|
||||
VisualServer::get_singleton()->instance_set_scenario(g->collision_debug_instance, get_world()->get_scenario());
|
||||
VisualServer::get_singleton()->instance_set_transform(g->collision_debug_instance, get_global_transform());
|
||||
}
|
||||
}
|
||||
|
||||
octant_map[octantkey] = g;
|
||||
|
||||
if (is_inside_world()) {
|
||||
_octant_enter_world(octantkey);
|
||||
_octant_transform(octantkey);
|
||||
}
|
||||
}
|
||||
|
||||
Octant &g = *octant_map[octantkey];
|
||||
if (!g.items.has(p_item)) {
|
||||
|
||||
Octant::ItemInstances ii;
|
||||
if (theme.is_valid() && theme->has_item(p_item)) {
|
||||
ii.mesh = theme->get_item_mesh(p_item);
|
||||
ii.shape = theme->get_item_shape(p_item);
|
||||
ii.navmesh = theme->get_item_navmesh(p_item);
|
||||
}
|
||||
ii.multimesh = Ref<MultiMesh>(memnew(MultiMesh));
|
||||
ii.multimesh->set_color_format(MultiMesh::COLOR_NONE);
|
||||
ii.multimesh->set_transform_format(MultiMesh::TRANSFORM_3D);
|
||||
ii.multimesh->set_mesh(ii.mesh);
|
||||
ii.multimesh_instance = VS::get_singleton()->instance_create();
|
||||
VS::get_singleton()->instance_set_base(ii.multimesh_instance, ii.multimesh->get_rid());
|
||||
VS::get_singleton()->instance_geometry_set_flag(ii.multimesh_instance, VS::INSTANCE_FLAG_USE_BAKED_LIGHT, true);
|
||||
|
||||
g.items[p_item] = ii;
|
||||
}
|
||||
|
||||
Octant::ItemInstances &ii = g.items[p_item];
|
||||
ii.cells.insert(key);
|
||||
g.cells.insert(key);
|
||||
g.dirty = true;
|
||||
_queue_octants_dirty();
|
||||
|
||||
_queue_dirty_map();
|
||||
|
||||
cell_map[key] = Cell();
|
||||
Cell &c = cell_map[key];
|
||||
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 {
|
||||
|
|
@ -372,71 +332,6 @@ int GridMap::get_cell_item_orientation(int p_x, int p_y, int p_z) const {
|
|||
return cell_map[key].rot;
|
||||
}
|
||||
|
||||
void GridMap::_octant_enter_tree(const OctantKey &p_key) {
|
||||
ERR_FAIL_COND(!octant_map.has(p_key));
|
||||
if (navigation) {
|
||||
Octant &g = *octant_map[p_key];
|
||||
|
||||
Vector3 ofs(cell_size * 0.5 * int(center_x), cell_size * 0.5 * int(center_y), cell_size * 0.5 * int(center_z));
|
||||
_octant_clear_navmesh(p_key);
|
||||
|
||||
for (Map<int, Octant::ItemInstances>::Element *E = g.items.front(); E; E = E->next()) {
|
||||
Octant::ItemInstances &ii = E->get();
|
||||
|
||||
for (Set<IndexKey>::Element *F = ii.cells.front(); F; F = F->next()) {
|
||||
|
||||
IndexKey ik = F->get();
|
||||
Map<IndexKey, Cell>::Element *C = cell_map.find(ik);
|
||||
ERR_CONTINUE(!C);
|
||||
|
||||
Vector3 cellpos = Vector3(ik.x, ik.y, ik.z);
|
||||
|
||||
Transform xform;
|
||||
|
||||
if (clip && ((clip_above && cellpos[clip_axis] > clip_floor) || (!clip_above && cellpos[clip_axis] < clip_floor))) {
|
||||
|
||||
xform.basis.set_zero();
|
||||
|
||||
} else {
|
||||
|
||||
xform.basis.set_orthogonal_index(C->get().rot);
|
||||
}
|
||||
|
||||
xform.set_origin(cellpos * cell_size + ofs);
|
||||
xform.basis.scale(Vector3(cell_scale, cell_scale, cell_scale));
|
||||
// add the item's navmesh at given xform to GridMap's Navigation ancestor
|
||||
if (ii.navmesh.is_valid()) {
|
||||
int nm_id = navigation->navmesh_create(ii.navmesh, xform, this);
|
||||
Octant::NavMesh nm;
|
||||
nm.id = nm_id;
|
||||
nm.xform = xform;
|
||||
g.navmesh_ids[ik] = nm;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
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());
|
||||
//print_line("BODYPOS: "+get_global_transform());
|
||||
|
||||
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 (Map<int, Octant::ItemInstances>::Element *E = g.items.front(); E; E = E->next()) {
|
||||
|
||||
VS::get_singleton()->instance_set_scenario(E->get().multimesh_instance, get_world()->get_scenario());
|
||||
VS::get_singleton()->instance_set_transform(E->get().multimesh_instance, get_global_transform());
|
||||
//print_line("INSTANCEPOS: "+get_global_transform());
|
||||
}
|
||||
}
|
||||
|
||||
void GridMap::_octant_transform(const OctantKey &p_key) {
|
||||
|
||||
ERR_FAIL_COND(!octant_map.has(p_key));
|
||||
|
|
@ -447,42 +342,49 @@ void GridMap::_octant_transform(const OctantKey &p_key) {
|
|||
VS::get_singleton()->instance_set_transform(g.collision_debug_instance, get_global_transform());
|
||||
}
|
||||
|
||||
for (Map<int, Octant::ItemInstances>::Element *E = g.items.front(); E; E = E->next()) {
|
||||
|
||||
VS::get_singleton()->instance_set_transform(E->get().multimesh_instance, get_global_transform());
|
||||
//print_line("UPDATEPOS: "+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());
|
||||
}
|
||||
}
|
||||
|
||||
void GridMap::_octant_clear_navmesh(const OctantKey &p_key) {
|
||||
Octant &g = *octant_map[p_key];
|
||||
if (navigation) {
|
||||
for (Map<IndexKey, Octant::NavMesh>::Element *E = g.navmesh_ids.front(); E; E = E->next()) {
|
||||
Octant::NavMesh *nvm = &E->get();
|
||||
if (nvm && nvm->id) {
|
||||
navigation->navmesh_remove(E->get().id);
|
||||
}
|
||||
}
|
||||
g.navmesh_ids.clear();
|
||||
}
|
||||
}
|
||||
|
||||
void GridMap::_octant_update(const OctantKey &p_key) {
|
||||
ERR_FAIL_COND(!octant_map.has(p_key));
|
||||
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;
|
||||
return false;
|
||||
|
||||
Ref<Mesh> mesh;
|
||||
|
||||
_octant_clear_navmesh(p_key);
|
||||
//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
|
||||
if (navigation) {
|
||||
for (Map<IndexKey, Octant::NavMesh>::Element *E = g.navmesh_ids.front(); E; E = E->next()) {
|
||||
navigation->navmesh_remove(E->get().id);
|
||||
}
|
||||
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;
|
||||
}
|
||||
|
||||
PoolVector<Vector3> col_debug;
|
||||
|
||||
/*
|
||||
|
|
@ -490,80 +392,111 @@ void GridMap::_octant_update(const OctantKey &p_key) {
|
|||
* 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
|
||||
*/
|
||||
for (Map<int, Octant::ItemInstances>::Element *E = g.items.front(); E; E = E->next()) {
|
||||
|
||||
Octant::ItemInstances &ii = E->get();
|
||||
Map<int, List<Pair<Transform, IndexKey> > > multimesh_items;
|
||||
|
||||
ii.multimesh->set_instance_count(ii.cells.size());
|
||||
print_line("updating octant " + itos(p_key.x) + ", " + itos(p_key.y) + ", " + itos(p_key.z) + " cells: " + itos(g.cells.size()));
|
||||
|
||||
Rect3 aabb;
|
||||
Rect3 mesh_aabb = ii.mesh.is_null() ? Rect3() : ii.mesh->get_aabb();
|
||||
for (Set<IndexKey>::Element *E = g.cells.front(); E; E = E->next()) {
|
||||
|
||||
Vector3 ofs(cell_size * 0.5 * int(center_x), cell_size * 0.5 * int(center_y), cell_size * 0.5 * int(center_z));
|
||||
ERR_CONTINUE(!cell_map.has(E->get()));
|
||||
const Cell &c = cell_map[E->get()];
|
||||
|
||||
if (!theme.is_valid() || !theme->has_item(c.item))
|
||||
continue;
|
||||
|
||||
//print_line("OCTANT, CELLS: "+itos(ii.cells.size()));
|
||||
int idx = 0;
|
||||
// foreach cell containing this item type
|
||||
for (Set<IndexKey>::Element *F = ii.cells.front(); F; F = F->next()) {
|
||||
IndexKey ik = F->get();
|
||||
Map<IndexKey, Cell>::Element *C = cell_map.find(ik);
|
||||
ERR_CONTINUE(!C);
|
||||
|
||||
Vector3 cellpos = Vector3(ik.x, ik.y, ik.z);
|
||||
Vector3 cellpos = Vector3(E->get().x, E->get().y, E->get().z);
|
||||
Vector3 ofs(cell_size.x * 0.5 * int(center_x), cell_size.y * 0.5 * int(center_y), cell_size.z * 0.5 * int(center_z));
|
||||
|
||||
Transform xform;
|
||||
|
||||
if (clip && ((clip_above && cellpos[clip_axis] > clip_floor) || (!clip_above && cellpos[clip_axis] < clip_floor))) {
|
||||
|
||||
xform.basis.set_zero();
|
||||
|
||||
} else {
|
||||
|
||||
xform.basis.set_orthogonal_index(C->get().rot);
|
||||
}
|
||||
|
||||
xform.basis.set_orthogonal_index(c.rot);
|
||||
xform.set_origin(cellpos * cell_size + ofs);
|
||||
xform.basis.scale(Vector3(cell_scale, cell_scale, cell_scale));
|
||||
|
||||
ii.multimesh->set_instance_transform(idx, xform);
|
||||
//ii.multimesh->set_instance_transform(idx,Transform() );
|
||||
//ii.multimesh->set_instance_color(idx,Color(1,1,1,1));
|
||||
//print_line("MMINST: "+xform);
|
||||
|
||||
if (idx == 0) {
|
||||
|
||||
aabb = xform.xform(mesh_aabb);
|
||||
} else {
|
||||
|
||||
aabb.merge_with(xform.xform(mesh_aabb));
|
||||
if (theme->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 = theme->get_item_shapes(c.item);
|
||||
// add the item's shape at given xform to octant's static_body
|
||||
if (ii.shape.is_valid()) {
|
||||
for (int i = 0; i < shapes.size(); i++) {
|
||||
// add the item's shape
|
||||
PhysicsServer::get_singleton()->body_add_shape(g.static_body, ii.shape->get_rid(), xform);
|
||||
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()) {
|
||||
ii.shape->add_vertices_to_array(col_debug, xform);
|
||||
shapes[i].shape->add_vertices_to_array(col_debug, xform * shapes[i].local_transform);
|
||||
}
|
||||
|
||||
//print_line("PHIS x: "+xform);
|
||||
}
|
||||
|
||||
// add the item's navmesh at given xform to GridMap's Navigation ancestor
|
||||
if (navigation) {
|
||||
if (ii.navmesh.is_valid()) {
|
||||
int nm_id = navigation->navmesh_create(ii.navmesh, xform, this);
|
||||
Ref<NavigationMesh> navmesh = theme->get_item_navmesh(c.item);
|
||||
if (navmesh.is_valid()) {
|
||||
Octant::NavMesh nm;
|
||||
nm.id = nm_id;
|
||||
nm.xform = xform;
|
||||
g.navmesh_ids[ik] = nm;
|
||||
|
||||
if (navigation) {
|
||||
nm.id = navigation->navmesh_create(navmesh, xform, this);
|
||||
} else {
|
||||
nm.id = -1;
|
||||
}
|
||||
g.navmesh_ids[E->get()] = nm;
|
||||
}
|
||||
}
|
||||
|
||||
//update multimeshes
|
||||
for (Map<int, List<Pair<Transform, IndexKey> > >::Element *E = multimesh_items.front(); E; E = E->next()) {
|
||||
print_line("multimesh item " + itos(E->key()) + " transforms " + itos(E->get().size()));
|
||||
Octant::MultimeshInstance mmi;
|
||||
|
||||
RID mm = 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, theme->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++;
|
||||
}
|
||||
|
||||
//ii.multimesh->set_aabb(aabb);
|
||||
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()) {
|
||||
|
|
@ -580,6 +513,39 @@ void GridMap::_octant_update(const OctantKey &p_key) {
|
|||
}
|
||||
|
||||
g.dirty = false;
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
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());
|
||||
//print_line("BODYPOS: "+get_global_transform());
|
||||
|
||||
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 && theme.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().id < 0) {
|
||||
Ref<NavigationMesh> nm = theme->get_item_navmesh(cell_map[F->key()].item);
|
||||
if (nm.is_valid()) {
|
||||
F->get().id = navigation->navmesh_create(nm, F->get().xform, this);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void GridMap::_octant_exit_world(const OctantKey &p_key) {
|
||||
|
|
@ -594,11 +560,49 @@ void GridMap::_octant_exit_world(const OctantKey &p_key) {
|
|||
VS::get_singleton()->instance_set_scenario(g.collision_debug_instance, RID());
|
||||
}
|
||||
|
||||
for (Map<int, Octant::ItemInstances>::Element *E = g.items.front(); E; E = E->next()) {
|
||||
|
||||
VS::get_singleton()->instance_set_scenario(E->get().multimesh_instance, RID());
|
||||
//VS::get_singleton()->instance_set_transform(E->get().multimesh_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, RID());
|
||||
}
|
||||
|
||||
if (navigation) {
|
||||
for (Map<IndexKey, Octant::NavMesh>::Element *F = g.navmesh_ids.front(); F; F = F->next()) {
|
||||
|
||||
if (F->get().id >= 0) {
|
||||
navigation->navmesh_remove(F->get().id);
|
||||
F->get().id = -1;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
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
|
||||
if (navigation) {
|
||||
for (Map<IndexKey, Octant::NavMesh>::Element *E = g.navmesh_ids.front(); E; E = E->next()) {
|
||||
navigation->navmesh_remove(E->get().id);
|
||||
}
|
||||
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) {
|
||||
|
|
@ -607,17 +611,22 @@ void GridMap::_notification(int p_what) {
|
|||
|
||||
case NOTIFICATION_ENTER_WORLD: {
|
||||
|
||||
for (Map<OctantKey, Octant *>::Element *E = octant_map.front(); E; E = E->next()) {
|
||||
//IndexKey ik;
|
||||
//ik.key = E->key().indexkey;
|
||||
_octant_enter_world(E->key());
|
||||
_octant_update(E->key());
|
||||
Spatial *c = this;
|
||||
while (c) {
|
||||
navigation = Object::cast_to<Navigation>(c);
|
||||
if (navigation) {
|
||||
break;
|
||||
}
|
||||
|
||||
awaiting_update = false;
|
||||
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());
|
||||
}
|
||||
|
||||
} break;
|
||||
case NOTIFICATION_TRANSFORM_CHANGED: {
|
||||
|
||||
|
|
@ -638,57 +647,24 @@ void GridMap::_notification(int p_what) {
|
|||
_octant_exit_world(E->key());
|
||||
}
|
||||
|
||||
//_queue_dirty_map(MAP_DIRTY_INSTANCES|MAP_DIRTY_TRANSFORMS);
|
||||
//_update_dirty_map_callback();
|
||||
navigation = NULL;
|
||||
|
||||
//_queue_octants_dirty(MAP_DIRTY_INSTANCES|MAP_DIRTY_TRANSFORMS);
|
||||
//_update_octants_callback();
|
||||
//_update_area_instances();
|
||||
|
||||
} break;
|
||||
case NOTIFICATION_ENTER_TREE: {
|
||||
|
||||
Spatial *c = this;
|
||||
while (c) {
|
||||
navigation = Object::cast_to<Navigation>(c);
|
||||
if (navigation) {
|
||||
break;
|
||||
}
|
||||
|
||||
c = Object::cast_to<Spatial>(c->get_parent());
|
||||
}
|
||||
|
||||
if (navigation) {
|
||||
for (Map<OctantKey, Octant *>::Element *E = octant_map.front(); E; E = E->next()) {
|
||||
if (navigation) {
|
||||
_octant_enter_tree(E->key());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
_queue_dirty_map();
|
||||
} break;
|
||||
case NOTIFICATION_EXIT_TREE: {
|
||||
for (Map<OctantKey, Octant *>::Element *E = octant_map.front(); E; E = E->next()) {
|
||||
if (navigation) {
|
||||
_octant_clear_navmesh(E->key());
|
||||
}
|
||||
}
|
||||
|
||||
navigation = NULL;
|
||||
|
||||
} break;
|
||||
}
|
||||
}
|
||||
|
||||
void GridMap::_queue_dirty_map() {
|
||||
void GridMap::_queue_octants_dirty() {
|
||||
|
||||
if (awaiting_update)
|
||||
return;
|
||||
|
||||
if (is_inside_world()) {
|
||||
|
||||
MessageQueue::get_singleton()->push_call(this, "_update_dirty_map_callback");
|
||||
MessageQueue::get_singleton()->push_call(this, "_update_octants_callback");
|
||||
awaiting_update = true;
|
||||
}
|
||||
}
|
||||
|
||||
void GridMap::_recreate_octant_data() {
|
||||
|
||||
|
|
@ -706,17 +682,7 @@ void GridMap::_clear_internal() {
|
|||
if (is_inside_world())
|
||||
_octant_exit_world(E->key());
|
||||
|
||||
for (Map<int, Octant::ItemInstances>::Element *F = E->get()->items.front(); F; F = F->next()) {
|
||||
|
||||
VS::get_singleton()->free(F->get().multimesh_instance);
|
||||
}
|
||||
|
||||
if (E->get()->collision_debug.is_valid())
|
||||
VS::get_singleton()->free(E->get()->collision_debug);
|
||||
if (E->get()->collision_debug_instance.is_valid())
|
||||
VS::get_singleton()->free(E->get()->collision_debug_instance);
|
||||
|
||||
PhysicsServer::get_singleton()->free(E->get()->static_body);
|
||||
_octant_clean_up(E->key());
|
||||
memdelete(E->get());
|
||||
}
|
||||
|
||||
|
|
@ -734,13 +700,23 @@ void GridMap::resource_changed(const RES &p_res) {
|
|||
_recreate_octant_data();
|
||||
}
|
||||
|
||||
void GridMap::_update_dirty_map_callback() {
|
||||
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()) {
|
||||
_octant_update(E->key());
|
||||
|
||||
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_back();
|
||||
}
|
||||
|
||||
awaiting_update = false;
|
||||
|
|
@ -762,7 +738,7 @@ void GridMap::_bind_methods() {
|
|||
ClassDB::bind_method(D_METHOD("get_cell_item_orientation", "x", "y", "z"), &GridMap::get_cell_item_orientation);
|
||||
|
||||
//ClassDB::bind_method(D_METHOD("_recreate_octants"),&GridMap::_recreate_octants);
|
||||
ClassDB::bind_method(D_METHOD("_update_dirty_map_callback"), &GridMap::_update_dirty_map_callback);
|
||||
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);
|
||||
|
|
@ -800,13 +776,13 @@ void GridMap::set_clip(bool p_enabled, bool p_clip_above, int p_floor, Vector3::
|
|||
g->dirty = true;
|
||||
}
|
||||
awaiting_update = true;
|
||||
_update_dirty_map_callback();
|
||||
_update_octants_callback();
|
||||
}
|
||||
|
||||
void GridMap::set_cell_scale(float p_scale) {
|
||||
|
||||
cell_scale = p_scale;
|
||||
_queue_dirty_map();
|
||||
_queue_octants_dirty();
|
||||
}
|
||||
|
||||
float GridMap::get_cell_scale() const {
|
||||
|
|
@ -819,7 +795,7 @@ Array GridMap::get_meshes() {
|
|||
if (theme.is_null())
|
||||
return Array();
|
||||
|
||||
Vector3 ofs(cell_size * 0.5 * int(center_x), cell_size * 0.5 * int(center_y), cell_size * 0.5 * int(center_z));
|
||||
Vector3 ofs(cell_size.x * 0.5 * int(center_x), cell_size.y * 0.5 * int(center_y), cell_size.z * 0.5 * int(center_z));
|
||||
Array meshes;
|
||||
|
||||
for (Map<IndexKey, Cell>::Element *E = cell_map.front(); E; E = E->next()) {
|
||||
|
|
@ -851,7 +827,7 @@ Array GridMap::get_meshes() {
|
|||
|
||||
GridMap::GridMap() {
|
||||
|
||||
cell_size = 2;
|
||||
cell_size = Vector3(2, 2, 2);
|
||||
octant_size = 4;
|
||||
awaiting_update = false;
|
||||
_in_tree = false;
|
||||
|
|
|
|||
|
|
@ -96,21 +96,25 @@ class GridMap : public Spatial {
|
|||
Transform xform;
|
||||
};
|
||||
|
||||
struct ItemInstances {
|
||||
Set<IndexKey> cells;
|
||||
Ref<Mesh> mesh;
|
||||
Ref<Shape> shape;
|
||||
Ref<MultiMesh> multimesh;
|
||||
RID multimesh_instance;
|
||||
Ref<NavigationMesh> navmesh;
|
||||
struct MultimeshInstance {
|
||||
RID instance;
|
||||
RID multimesh;
|
||||
struct Item {
|
||||
int index;
|
||||
Transform transform;
|
||||
IndexKey key;
|
||||
};
|
||||
|
||||
Vector<Item> items; //tools only, for changing visibility
|
||||
};
|
||||
|
||||
Vector<MultimeshInstance> multimesh_instances;
|
||||
Set<IndexKey> cells;
|
||||
RID collision_debug;
|
||||
RID collision_debug_instance;
|
||||
|
||||
bool dirty;
|
||||
RID static_body;
|
||||
Map<int, ItemInstances> items;
|
||||
Map<IndexKey, NavMesh> navmesh_ids;
|
||||
};
|
||||
|
||||
|
|
@ -137,7 +141,7 @@ class GridMap : public Spatial {
|
|||
Transform last_transform;
|
||||
|
||||
bool _in_tree;
|
||||
float cell_size;
|
||||
Vector3 cell_size;
|
||||
int octant_size;
|
||||
bool center_x, center_y, center_z;
|
||||
float cell_scale;
|
||||
|
|
@ -169,15 +173,14 @@ class GridMap : public Spatial {
|
|||
}
|
||||
|
||||
void _octant_enter_world(const OctantKey &p_key);
|
||||
void _octant_enter_tree(const OctantKey &p_key);
|
||||
void _octant_exit_world(const OctantKey &p_key);
|
||||
void _octant_update(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);
|
||||
void _octant_clear_navmesh(const GridMap::OctantKey &);
|
||||
bool awaiting_update;
|
||||
|
||||
void _queue_dirty_map();
|
||||
void _update_dirty_map_callback();
|
||||
void _queue_octants_dirty();
|
||||
void _update_octants_callback();
|
||||
|
||||
void resource_changed(const RES &p_res);
|
||||
|
||||
|
|
@ -199,8 +202,8 @@ public:
|
|||
void set_theme(const Ref<MeshLibrary> &p_theme);
|
||||
Ref<MeshLibrary> get_theme() const;
|
||||
|
||||
void set_cell_size(float p_size);
|
||||
float get_cell_size() 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;
|
||||
|
|
|
|||
|
|
@ -217,12 +217,15 @@ void GridMapEditor::_update_cursor_transform() {
|
|||
}
|
||||
|
||||
void GridMapEditor::_update_selection_transform() {
|
||||
Transform xf_zero;
|
||||
xf_zero.basis.set_zero();
|
||||
|
||||
if (!selection.active) {
|
||||
|
||||
Transform xf;
|
||||
xf.basis.set_zero();
|
||||
VisualServer::get_singleton()->instance_set_transform(selection_instance, xf);
|
||||
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;
|
||||
}
|
||||
|
||||
|
|
@ -231,6 +234,27 @@ void GridMapEditor::_update_selection_transform() {
|
|||
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 xf;
|
||||
xf.basis.scale(scale);
|
||||
xf.origin = pos;
|
||||
|
||||
VisualServer::get_singleton()->instance_set_transform(selection_level_instance[i], xf);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void GridMapEditor::_validate_selection() {
|
||||
|
|
@ -273,7 +297,7 @@ bool GridMapEditor::do_input_action(Camera *p_camera, const Point2 &p_point, boo
|
|||
|
||||
Plane p;
|
||||
p.normal[edit_axis] = 1.0;
|
||||
p.d = edit_floor[edit_axis] * node->get_cell_size();
|
||||
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))
|
||||
|
|
@ -289,7 +313,7 @@ bool GridMapEditor::do_input_action(Camera *p_camera, const Point2 &p_point, boo
|
|||
}
|
||||
|
||||
int cell[3];
|
||||
float cell_size[3] = { node->get_cell_size(), node->get_cell_size(), node->get_cell_size() };
|
||||
float cell_size[3] = { node->get_cell_size().x, node->get_cell_size().y, node->get_cell_size().z };
|
||||
|
||||
last_mouseover = Vector3(-1, -1, -1);
|
||||
|
||||
|
|
@ -299,7 +323,7 @@ bool GridMapEditor::do_input_action(Camera *p_camera, const Point2 &p_point, boo
|
|||
cell[i] = edit_floor[i];
|
||||
else {
|
||||
|
||||
cell[i] = inters[i] / node->get_cell_size();
|
||||
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];
|
||||
|
|
@ -717,6 +741,7 @@ void GridMapEditor::edit(GridMap *p_gridmap) {
|
|||
//update grids
|
||||
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));
|
||||
|
|
@ -724,7 +749,7 @@ void GridMapEditor::edit(GridMap *p_gridmap) {
|
|||
Vector<Vector3> grid_points[3];
|
||||
Vector<Color> grid_colors[3];
|
||||
|
||||
float cell_size[3] = { p_gridmap->get_cell_size(), p_gridmap->get_cell_size(), p_gridmap->get_cell_size() };
|
||||
float cell_size[3] = { p_gridmap->get_cell_size().x, p_gridmap->get_cell_size().y, p_gridmap->get_cell_size().z };
|
||||
|
||||
for (int i = 0; i < 3; i++) {
|
||||
|
||||
|
|
@ -788,7 +813,7 @@ void GridMapEditor::update_grid() {
|
|||
|
||||
//VS *vs = VS::get_singleton();
|
||||
|
||||
grid_ofs[edit_axis] = edit_floor[edit_axis] * node->get_cell_size();
|
||||
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();
|
||||
|
|
@ -811,6 +836,7 @@ void GridMapEditor::_notification(int p_what) {
|
|||
|
||||
grid[i] = VS::get_singleton()->mesh_create();
|
||||
grid_instance[i] = VS::get_singleton()->instance_create2(grid[i], get_tree()->get_root()->get_world()->get_scenario());
|
||||
selection_level_instance[i] = VisualServer::get_singleton()->instance_create2(selection_level_mesh[i], get_tree()->get_root()->get_world()->get_scenario());
|
||||
}
|
||||
|
||||
selection_instance = VisualServer::get_singleton()->instance_create2(selection_mesh, get_tree()->get_root()->get_world()->get_scenario());
|
||||
|
|
@ -827,6 +853,7 @@ void GridMapEditor::_notification(int p_what) {
|
|||
VS::get_singleton()->free(grid[i]);
|
||||
grid_instance[i] = RID();
|
||||
grid[i] = RID();
|
||||
VisualServer::get_singleton()->free(selection_level_instance[i]);
|
||||
}
|
||||
|
||||
VisualServer::get_singleton()->free(selection_instance);
|
||||
|
|
@ -858,7 +885,7 @@ void GridMapEditor::_notification(int p_what) {
|
|||
|
||||
Plane p;
|
||||
p.normal[edit_axis] = 1.0;
|
||||
p.d = edit_floor[edit_axis] * node->get_cell_size();
|
||||
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<SpatialEditorPlugin>(editor->get_editor_plugin_screen());
|
||||
|
|
@ -906,6 +933,7 @@ void GridMapEditor::_floor_changed(float 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::_bind_methods() {
|
||||
|
|
@ -1047,6 +1075,7 @@ GridMapEditor::GridMapEditor(EditorNode *p_editor) {
|
|||
|
||||
PoolVector<Vector3> lines;
|
||||
PoolVector<Vector3> triangles;
|
||||
PoolVector<Vector3> square[3];
|
||||
|
||||
for (int i = 0; i < 6; i++) {
|
||||
|
||||
|
|
@ -1086,12 +1115,41 @@ GridMapEditor::GridMapEditor(EditorNode *p_editor) {
|
|||
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] = { 0, 1, 1, 0 };
|
||||
static const bool ordery[4] = { 0, 0, 1, 1 };
|
||||
|
||||
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.3));
|
||||
inner_mat->set_flag(SpatialMaterial::FLAG_ONTOP, true);
|
||||
inner_mat->set_albedo(Color(0.7, 0.7, 1.0, 0.2));
|
||||
//inner_mat->set_flag(SpatialMaterial::FLAG_ONTOP, true);
|
||||
inner_mat->set_flag(SpatialMaterial::FLAG_UNSHADED, true);
|
||||
inner_mat->set_feature(SpatialMaterial::FEATURE_TRANSPARENT, true);
|
||||
|
||||
|
|
@ -1100,12 +1158,19 @@ GridMapEditor::GridMapEditor(EditorNode *p_editor) {
|
|||
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.3));
|
||||
outer_mat->set_albedo(Color(0.7, 0.7, 1.0, 0.8));
|
||||
outer_mat->set_flag(SpatialMaterial::FLAG_ONTOP, true);
|
||||
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_flag(SpatialMaterial::FLAG_ONTOP, true);
|
||||
selection_floor_mat->set_flag(SpatialMaterial::FLAG_UNSHADED, true);
|
||||
selection_floor_mat->set_line_width(3.0);
|
||||
//selection_floor_mat->set_feature(SpatialMaterial::FEATURE_TRANSPARENT, true);
|
||||
|
||||
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());
|
||||
|
|
@ -1117,6 +1182,13 @@ GridMapEditor::GridMapEditor(EditorNode *p_editor) {
|
|||
d[VS::ARRAY_VERTEX] = lines;
|
||||
VisualServer::get_singleton()->mesh_add_surface_from_arrays(duplicate_mesh, VS::PRIMITIVE_LINES, d);
|
||||
VisualServer::get_singleton()->mesh_surface_set_material(duplicate_mesh, 1, outer_mat->get_rid());
|
||||
|
||||
for (int i = 0; i < 3; i++) {
|
||||
d[VS::ARRAY_VERTEX] = square[i];
|
||||
selection_level_mesh[i] = 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());
|
||||
}
|
||||
}
|
||||
|
||||
selection.active = false;
|
||||
|
|
@ -1133,6 +1205,9 @@ GridMapEditor::~GridMapEditor() {
|
|||
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]);
|
||||
}
|
||||
}
|
||||
|
||||
VisualServer::get_singleton()->free(selection_mesh);
|
||||
|
|
|
|||
|
|
@ -109,12 +109,15 @@ class GridMapEditor : public VBoxContainer {
|
|||
RID cursor_instance;
|
||||
RID selection_mesh;
|
||||
RID selection_instance;
|
||||
RID selection_level_mesh[3];
|
||||
RID selection_level_instance[3];
|
||||
RID duplicate_mesh;
|
||||
RID duplicate_instance;
|
||||
|
||||
Ref<SpatialMaterial> indicator_mat;
|
||||
Ref<SpatialMaterial> inner_mat;
|
||||
Ref<SpatialMaterial> outer_mat;
|
||||
Ref<SpatialMaterial> selection_floor_mat;
|
||||
|
||||
bool updating;
|
||||
|
||||
|
|
@ -223,7 +226,7 @@ class GridMapEditorPlugin : public EditorPlugin {
|
|||
EditorNode *editor;
|
||||
|
||||
public:
|
||||
virtual bool forward_spatial_input_event(Camera *p_camera, const Ref<InputEvent> &p_event) { return gridmap_editor->forward_spatial_input_event(p_camera, p_event); }
|
||||
virtual bool forward_spatial_gui_input(Camera *p_camera, const Ref<InputEvent> &p_event) { return gridmap_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);
|
||||
|
|
|
|||
|
|
@ -43,9 +43,15 @@ bool MeshLibrary::_set(const StringName &p_name, const Variant &p_value) {
|
|||
set_item_name(idx, p_value);
|
||||
else if (what == "mesh")
|
||||
set_item_mesh(idx, p_value);
|
||||
else if (what == "shape")
|
||||
set_item_shape(idx, p_value);
|
||||
else if (what == "preview")
|
||||
else if (what == "shape") {
|
||||
Vector<ShapeData> shapes;
|
||||
ShapeData sd;
|
||||
sd.shape = p_value;
|
||||
shapes.push_back(sd);
|
||||
set_item_shapes(idx, shapes);
|
||||
} else if (what == "shapes") {
|
||||
_set_item_shapes(idx, p_value);
|
||||
} else if (what == "preview")
|
||||
set_item_preview(idx, p_value);
|
||||
else if (what == "navmesh")
|
||||
set_item_navmesh(idx, p_value);
|
||||
|
|
@ -69,8 +75,8 @@ bool MeshLibrary::_get(const StringName &p_name, Variant &r_ret) const {
|
|||
r_ret = get_item_name(idx);
|
||||
else if (what == "mesh")
|
||||
r_ret = get_item_mesh(idx);
|
||||
else if (what == "shape")
|
||||
r_ret = get_item_shape(idx);
|
||||
else if (what == "shapes")
|
||||
r_ret = _get_item_shapes(idx);
|
||||
else if (what == "navmesh")
|
||||
r_ret = get_item_navmesh(idx);
|
||||
else if (what == "preview")
|
||||
|
|
@ -88,7 +94,7 @@ void MeshLibrary::_get_property_list(List<PropertyInfo> *p_list) const {
|
|||
String name = "item/" + itos(E->key()) + "/";
|
||||
p_list->push_back(PropertyInfo(Variant::STRING, name + "name"));
|
||||
p_list->push_back(PropertyInfo(Variant::OBJECT, name + "mesh", PROPERTY_HINT_RESOURCE_TYPE, "Mesh"));
|
||||
p_list->push_back(PropertyInfo(Variant::OBJECT, name + "shape", PROPERTY_HINT_RESOURCE_TYPE, "Shape"));
|
||||
p_list->push_back(PropertyInfo(Variant::ARRAY, name + "shapes"));
|
||||
p_list->push_back(PropertyInfo(Variant::OBJECT, name + "navmesh", PROPERTY_HINT_RESOURCE_TYPE, "NavigationMesh"));
|
||||
p_list->push_back(PropertyInfo(Variant::OBJECT, name + "preview", PROPERTY_HINT_RESOURCE_TYPE, "Texture", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_EDITOR_HELPER));
|
||||
}
|
||||
|
|
@ -118,10 +124,10 @@ void MeshLibrary::set_item_mesh(int p_item, const Ref<Mesh> &p_mesh) {
|
|||
_change_notify();
|
||||
}
|
||||
|
||||
void MeshLibrary::set_item_shape(int p_item, const Ref<Shape> &p_shape) {
|
||||
void MeshLibrary::set_item_shapes(int p_item, const Vector<ShapeData> &p_shapes) {
|
||||
|
||||
ERR_FAIL_COND(!item_map.has(p_item));
|
||||
item_map[p_item].shape = p_shape;
|
||||
item_map[p_item].shapes = p_shapes;
|
||||
_change_notify();
|
||||
notify_change_to_owners();
|
||||
emit_changed();
|
||||
|
|
@ -156,10 +162,10 @@ Ref<Mesh> MeshLibrary::get_item_mesh(int p_item) const {
|
|||
return item_map[p_item].mesh;
|
||||
}
|
||||
|
||||
Ref<Shape> MeshLibrary::get_item_shape(int p_item) const {
|
||||
Vector<MeshLibrary::ShapeData> MeshLibrary::get_item_shapes(int p_item) const {
|
||||
|
||||
ERR_FAIL_COND_V(!item_map.has(p_item), Ref<Shape>());
|
||||
return item_map[p_item].shape;
|
||||
ERR_FAIL_COND_V(!item_map.has(p_item), Vector<ShapeData>());
|
||||
return item_map[p_item].shapes;
|
||||
}
|
||||
|
||||
Ref<NavigationMesh> MeshLibrary::get_item_navmesh(int p_item) const {
|
||||
|
|
@ -226,17 +232,46 @@ int MeshLibrary::get_last_unused_item_id() const {
|
|||
return item_map.back()->key() + 1;
|
||||
}
|
||||
|
||||
void MeshLibrary::_set_item_shapes(int p_item, const Array &p_shapes) {
|
||||
|
||||
ERR_FAIL_COND(p_shapes.size() & 1);
|
||||
Vector<ShapeData> shapes;
|
||||
for (int i = 0; i < p_shapes.size(); i += 2) {
|
||||
ShapeData sd;
|
||||
sd.shape = p_shapes[i + 0];
|
||||
sd.local_transform = p_shapes[i + 1];
|
||||
|
||||
if (sd.shape.is_valid()) {
|
||||
shapes.push_back(sd);
|
||||
}
|
||||
}
|
||||
|
||||
set_item_shapes(p_item, shapes);
|
||||
}
|
||||
|
||||
Array MeshLibrary::_get_item_shapes(int p_item) const {
|
||||
|
||||
Vector<ShapeData> shapes = get_item_shapes(p_item);
|
||||
Array ret;
|
||||
for (int i = 0; i < shapes.size(); i++) {
|
||||
ret.push_back(shapes[i].shape);
|
||||
ret.push_back(shapes[i].local_transform);
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
void MeshLibrary::_bind_methods() {
|
||||
|
||||
ClassDB::bind_method(D_METHOD("create_item", "id"), &MeshLibrary::create_item);
|
||||
ClassDB::bind_method(D_METHOD("set_item_name", "id", "name"), &MeshLibrary::set_item_name);
|
||||
ClassDB::bind_method(D_METHOD("set_item_mesh", "id", "mesh"), &MeshLibrary::set_item_mesh);
|
||||
ClassDB::bind_method(D_METHOD("set_item_navmesh", "id", "navmesh"), &MeshLibrary::set_item_navmesh);
|
||||
ClassDB::bind_method(D_METHOD("set_item_shape", "id", "shape"), &MeshLibrary::set_item_shape);
|
||||
ClassDB::bind_method(D_METHOD("set_item_shapes", "id", "shapes"), &MeshLibrary::_set_item_shapes);
|
||||
ClassDB::bind_method(D_METHOD("get_item_name", "id"), &MeshLibrary::get_item_name);
|
||||
ClassDB::bind_method(D_METHOD("get_item_mesh", "id"), &MeshLibrary::get_item_mesh);
|
||||
ClassDB::bind_method(D_METHOD("get_item_navmesh", "id"), &MeshLibrary::get_item_navmesh);
|
||||
ClassDB::bind_method(D_METHOD("get_item_shape", "id"), &MeshLibrary::get_item_shape);
|
||||
ClassDB::bind_method(D_METHOD("get_item_shapes", "id"), &MeshLibrary::_get_item_shapes);
|
||||
ClassDB::bind_method(D_METHOD("remove_item", "id"), &MeshLibrary::remove_item);
|
||||
ClassDB::bind_method(D_METHOD("clear"), &MeshLibrary::clear);
|
||||
ClassDB::bind_method(D_METHOD("get_item_list"), &MeshLibrary::get_item_list);
|
||||
|
|
|
|||
|
|
@ -41,16 +41,24 @@ class MeshLibrary : public Resource {
|
|||
GDCLASS(MeshLibrary, Resource);
|
||||
RES_BASE_EXTENSION("meshlib");
|
||||
|
||||
public:
|
||||
struct ShapeData {
|
||||
Ref<Shape> shape;
|
||||
Transform local_transform;
|
||||
};
|
||||
struct Item {
|
||||
String name;
|
||||
Ref<Mesh> mesh;
|
||||
Ref<Shape> shape;
|
||||
Vector<ShapeData> shapes;
|
||||
Ref<Texture> preview;
|
||||
Ref<NavigationMesh> navmesh;
|
||||
};
|
||||
|
||||
Map<int, Item> item_map;
|
||||
|
||||
void _set_item_shapes(int p_item, const Array &p_shapes);
|
||||
Array _get_item_shapes(int p_item) const;
|
||||
|
||||
protected:
|
||||
bool _set(const StringName &p_name, const Variant &p_value);
|
||||
bool _get(const StringName &p_name, Variant &r_ret) const;
|
||||
|
|
@ -63,12 +71,12 @@ public:
|
|||
void set_item_name(int p_item, const String &p_name);
|
||||
void set_item_mesh(int p_item, const Ref<Mesh> &p_mesh);
|
||||
void set_item_navmesh(int p_item, const Ref<NavigationMesh> &p_navmesh);
|
||||
void set_item_shape(int p_item, const Ref<Shape> &p_shape);
|
||||
void set_item_shapes(int p_item, const Vector<ShapeData> &p_shapes);
|
||||
void set_item_preview(int p_item, const Ref<Texture> &p_preview);
|
||||
String get_item_name(int p_item) const;
|
||||
Ref<Mesh> get_item_mesh(int p_item) const;
|
||||
Ref<NavigationMesh> get_item_navmesh(int p_item) const;
|
||||
Ref<Shape> get_item_shape(int p_item) const;
|
||||
Vector<ShapeData> get_item_shapes(int p_item) const;
|
||||
Ref<Texture> get_item_preview(int p_item) const;
|
||||
|
||||
void remove_item(int p_item);
|
||||
|
|
|
|||
Loading…
Reference in a new issue