mirror/godot
2
0
Fork 0
mirror of https://github.com/godotengine/godot.git synced 2024-12-21 10:25:24 +08:00
Code Issues Packages Projects Releases Wiki Activity
3fae505128
godot/modules/gridmap/grid_map.cpp
Juan Linietsky 118eed485e ObjectTypeDB was renamed to ClassDB. Types are meant to be more generic to Variant. 
All usages of "type" to refer to classes were renamed to "class"
ClassDB has been exposed to GDScript.
OBJ_TYPE() macro is now GDCLASS()
2017-01-02 23:03:46 -03:00

1846 lines
46 KiB
C++
Raw Blame History

/*************************************************************************/
/* grid_map.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2017 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 "servers/visual_server.h"
#include "scene/resources/surface_tool.h"
#include "message_queue.h"
#include "scene/3d/light.h"
#include "scene/3d/baked_light_instance.h"
#include "io/marshalls.h"
#include "scene/scene_string_names.h"
#include "os/os.h"
#include "scene/resources/mesh_library.h"
bool GridMap::_set(const StringName& p_name, const Variant& p_value) {
String name=p_name;
if (name=="theme/theme") {
set_theme(p_value);
} else if (name=="cell/size") {
set_cell_size(p_value);
} else if (name=="cell/octant_size") {
set_octant_size(p_value);
} else if (name=="cell/center_x") {
set_center_x(p_value);
} else if (name=="cell/center_y") {
set_center_y(p_value);
} else if (name=="cell/center_z") {
set_center_z(p_value);
} else if (name=="cell/scale") {
set_cell_scale(p_value);
} else if (name=="lighting/bake") {
set_use_baked_light(p_value);
} else if (name=="theme/bake") {
set_bake(p_value);
/* } else if (name=="cells") {
DVector<int> cells = p_value;
int amount=cells.size();
DVector<int>::Read r = cells.read();
ERR_FAIL_COND_V(amount&1,false); // not even
cell_map.clear();;
for(int i=0;i<amount/3;i++) {
IndexKey ik;
ik.key=decode_uint64(&r[i*3]);
Cell cell;
cell.cell=uint32_t(r[i*+1]);
cell_map[ik]=cell;
}
_recreate_octant_data();*/
} else if (name=="data") {
Dictionary d = p_value;
Dictionary baked;
if (d.has("baked"))
baked=d["baked"];
if (d.has("cells")) {
DVector<int> cells = d["cells"];
int amount=cells.size();
DVector<int>::Read r = cells.read();
ERR_FAIL_COND_V(amount%3,false); // not even
cell_map.clear();;
for(int i=0;i<amount/3;i++) {
IndexKey ik;
ik.key=decode_uint64((const uint8_t*)&r[i*3]);
Cell cell;
cell.cell=decode_uint32((const uint8_t*)&r[i*3+2]);
cell_map[ik]=cell;
}
}
baked_lock=baked.size()!=0;
_recreate_octant_data();
baked_lock=false;
if (!baked.empty()) {
List<Variant> kl;
baked.get_key_list(&kl);
for (List<Variant>::Element *E=kl.front();E;E=E->next()) {
Plane ikv = E->get();
Ref<Mesh> b=baked[ikv];
ERR_CONTINUE(!b.is_valid());
OctantKey ok;
ok.x=ikv.normal.x;
ok.y=ikv.normal.y;
ok.z=ikv.normal.z;
ok.area=ikv.d;
ERR_CONTINUE(!octant_map.has(ok));
Octant &g = *octant_map[ok];
g.baked=b;
g.bake_instance=VS::get_singleton()->instance_create();;
VS::get_singleton()->instance_set_base(g.bake_instance,g.baked->get_rid());
VS::get_singleton()->instance_geometry_set_baked_light(g.bake_instance,baked_light_instance?baked_light_instance->get_baked_light_instance():RID());
}
}
} else if (name.begins_with("areas/")) {
int which = name.get_slicec('/',1).to_int();
String what=name.get_slicec('/',2);
if (what=="bounds") {
ERR_FAIL_COND_V(area_map.has(which),false);
create_area(which,p_value);
return true;
}
ERR_FAIL_COND_V(!area_map.has(which),false);
if (what=="name")
area_set_name(which,p_value);
else if (what=="disable_distance")
area_set_portal_disable_distance(which,p_value);
else if (what=="exterior_portal")
area_set_portal_disable_color(which,p_value);
else
return false;
} else
return false;
return true;
}
bool GridMap::_get(const StringName& p_name,Variant &r_ret) const {
String name=p_name;
if (name=="theme/theme") {
r_ret= get_theme();
} else if (name=="cell/size") {
r_ret= get_cell_size();
} else if (name=="cell/octant_size") {
r_ret= get_octant_size();
} else if (name=="cell/center_x") {
r_ret= get_center_x();
} else if (name=="cell/center_y") {
r_ret= get_center_y();
} else if (name=="cell/center_z") {
r_ret= get_center_z();
} else if (name=="cell/scale") {
r_ret= cell_scale;
} else if (name=="lighting/bake") {
r_ret=is_using_baked_light();
} else if (name=="theme/bake") {
r_ret= bake;
} else if (name=="data") {
Dictionary d;
DVector<int> cells;
cells.resize(cell_map.size()*3);
{
DVector<int>::Write w = cells.write();
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;
Dictionary baked;
for(Map<OctantKey,Octant*>::Element *E=octant_map.front();E;E=E->next()) {
Octant &g=*E->get();
if (g.baked.is_valid()) {
baked[Plane(E->key().x,E->key().y,E->key().z,E->key().area)]=g.baked;
}
}
if (baked.size()) {
d["baked"]=baked;
}
r_ret= d;
} else if (name.begins_with("areas/")) {
int which = name.get_slicec('/',1).to_int();
String what=name.get_slicec('/',2);
if (what=="bounds")
r_ret= area_get_bounds(which);
else if (what=="name")
r_ret= area_get_name(which);
else if (what=="disable_distance")
r_ret= area_get_portal_disable_distance(which);
else if (what=="exterior_portal")
r_ret= area_is_exterior_portal(which);
else
return false;
} else
return false;
return true;
}
void GridMap::_get_property_list( List<PropertyInfo> *p_list) const {
p_list->push_back( PropertyInfo( Variant::OBJECT, "theme/theme", PROPERTY_HINT_RESOURCE_TYPE, "MeshLibrary"));
p_list->push_back( PropertyInfo( Variant::BOOL, "theme/bake"));
p_list->push_back( PropertyInfo( Variant::BOOL, "lighting/bake"));
p_list->push_back( PropertyInfo( Variant::REAL, "cell/size",PROPERTY_HINT_RANGE,"0.01,16384,0.01") );
p_list->push_back( PropertyInfo( Variant::INT, "cell/octant_size",PROPERTY_HINT_RANGE,"1,1024,1") );
p_list->push_back( PropertyInfo( Variant::BOOL, "cell/center_x") );
p_list->push_back( PropertyInfo( Variant::BOOL, "cell/center_y") );
p_list->push_back( PropertyInfo( Variant::BOOL, "cell/center_z") );
p_list->push_back( PropertyInfo( Variant::REAL, "cell/scale") );
p_list->push_back( PropertyInfo( Variant::DICTIONARY, "data", PROPERTY_HINT_NONE,"",PROPERTY_USAGE_STORAGE) );
for(const Map<int,Area*>::Element *E=area_map.front();E;E=E->next()) {
String base="areas/"+itos(E->key())+"/";
p_list->push_back( PropertyInfo( Variant::_AABB, base+"bounds", PROPERTY_HINT_NONE,"",PROPERTY_USAGE_STORAGE) );
p_list->push_back( PropertyInfo( Variant::STRING, base+"name", PROPERTY_HINT_NONE,"",PROPERTY_USAGE_STORAGE) );
p_list->push_back( PropertyInfo( Variant::REAL, base+"disable_distance", PROPERTY_HINT_NONE,"",PROPERTY_USAGE_STORAGE) );
p_list->push_back( PropertyInfo( Variant::COLOR, base+"disable_color", PROPERTY_HINT_NONE,"",PROPERTY_USAGE_STORAGE) );
p_list->push_back( PropertyInfo( Variant::BOOL, base+"exterior_portal", PROPERTY_HINT_NONE,"",PROPERTY_USAGE_STORAGE) );
}
}
void GridMap::set_theme(const Ref<MeshLibrary>& p_theme) {
if (!theme.is_null())
theme->unregister_owner(this);
theme=p_theme;
if (!theme.is_null())
theme->register_owner(this);
_recreate_octant_data();
_change_notify("theme");
}
Ref<MeshLibrary> GridMap::get_theme() const{
return theme;
}
void GridMap::set_cell_size(float p_size){
cell_size=p_size;
_recreate_octant_data();
}
float GridMap::get_cell_size() const{
return cell_size;
}
void GridMap::set_octant_size(int p_size){
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;
}
int GridMap::_find_area(const IndexKey& p_pos) const {
for(const Map<int,Area*>::Element *E=area_map.front();E;E=E->next()) {
//this should somehow be faster...
const Area& a=*E->get();
if ( p_pos.x>=a.from.x && p_pos.x<a.to.x &&
p_pos.y>=a.from.y && p_pos.y<a.to.y &&
p_pos.z>=a.from.z && p_pos.z<a.to.z ) {
return E->key();
}
}
return 0;
}
void GridMap::set_cell_item(int p_x,int p_y,int p_z, int p_item,int p_rot){
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;
ok.area = _find_area(key);
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() || !baked_lock) {
//unbake just in case
if (g.baked.is_valid()) {
VS::get_singleton()->free(g.bake_instance);
g.bake_instance=RID();
g.baked=Ref<Mesh>();
}
}
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.dirty=true;
}
cell_map.erase(key);
_queue_dirty_map();
}
if (p_item<0)
return;
OctantKey octantkey=ok;
//add later
if (!octant_map.has(octantkey)) {
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()) {
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;
}
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_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_baked_light(ii.multimesh_instance,baked_light_instance?baked_light_instance->get_baked_light_instance():RID());
if (!baked_lock) {
//unbake just in case
if (g.bake_instance.is_valid())
VS::get_singleton()->free(g.bake_instance);
g.baked=Ref<Mesh>();
if (is_inside_world()) {
VS::get_singleton()->instance_set_scenario(ii.multimesh_instance,get_world()->get_scenario());
if (ok.area) {
VS::get_singleton()->instance_set_room( ii.multimesh_instance,area_map[ok.area]->instance);
}
}
}
g.items[p_item]=ii;
}
Octant::ItemInstances &ii = g.items[p_item];
ii.cells.insert(key);
g.dirty=true;
_queue_dirty_map();
cell_map[key]=Cell();
Cell &c=cell_map[key];
c.item=p_item;
c.rot=p_rot;
}
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;
}
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());
if (area_map.has(p_key.area)) {
VS::get_singleton()->instance_set_room(g.collision_debug_instance,area_map[p_key.area]->instance);
}
}
if (g.baked.is_valid()) {
Transform xf = get_global_transform();
xf.translate(_octant_get_offset(p_key));
VS::get_singleton()->instance_set_transform(g.bake_instance,xf);
VS::get_singleton()->instance_set_scenario(g.bake_instance,get_world()->get_scenario());
if (area_map.has(p_key.area)) {
VS::get_singleton()->instance_set_room(g.bake_instance,area_map[p_key.area]->instance);
}
} else {
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());
if (area_map.has(p_key.area)) {
VS::get_singleton()->instance_set_room(E->get().multimesh_instance,area_map[p_key.area]->instance);
}
}
}
}
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());
}
if (g.baked.is_valid()) {
Transform xf = get_global_transform();
xf.origin+=_octant_get_offset(p_key);
VS::get_singleton()->instance_set_transform(g.bake_instance,xf);
} else {
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());
}
}
}
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));
Octant&g = *octant_map[p_key];
if (!g.dirty)
return;
Ref<Mesh> mesh;
_octant_clear_navmesh(p_key);
PhysicsServer::get_singleton()->body_clear_shapes(g.static_body);
if (g.collision_debug.is_valid()) {
VS::get_singleton()->mesh_clear(g.collision_debug);
}
DVector<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
*/
for(Map<int,Octant::ItemInstances>::Element *E=g.items.front();E;E=E->next()) {
Octant::ItemInstances &ii=E->get();
ii.multimesh->set_instance_count(ii.cells.size());
AABB aabb;
AABB mesh_aabb = ii.mesh.is_null()?AABB():ii.mesh->get_aabb();
Vector3 ofs(cell_size*0.5*int(center_x),cell_size*0.5*int(center_y),cell_size*0.5*int(center_z));
//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 );
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));
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));
}
// add the item's shape at given xform to octant's static_body
if (ii.shape.is_valid()) {
// add the item's shape
PhysicsServer::get_singleton()->body_add_shape(g.static_body,ii.shape->get_rid(),xform);
if (g.collision_debug.is_valid()) {
ii.shape->add_vertices_to_array(col_debug,xform);
}
// 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);
Octant::NavMesh nm;
nm.id=nm_id;
nm.xform=xform;
g.navmesh_ids[ik]=nm;
}
}
idx++;
}
ii.multimesh->set_aabb(aabb);
}
if (col_debug.size()) {
Array arr;
arr.resize(VS::ARRAY_MAX);
arr[VS::ARRAY_VERTEX]=col_debug;
VS::get_singleton()->mesh_add_surface(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;
}
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.baked.is_valid()) {
VS::get_singleton()->instance_set_room(g.bake_instance,RID());
VS::get_singleton()->instance_set_scenario(g.bake_instance,RID());
}
if (g.collision_debug_instance.is_valid()) {
VS::get_singleton()->instance_set_room(g.collision_debug_instance,RID());
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());
VS::get_singleton()->instance_set_room(E->get().multimesh_instance,RID());
}
}
void GridMap::_octant_clear_baked(const OctantKey &p_key) {
ERR_FAIL_COND(!octant_map.has(p_key));
Octant&g = *octant_map[p_key];
if (!g.baked.is_valid())
return;
VS::get_singleton()->free(g.bake_instance);
g.bake_instance=RID();
g.baked=Ref<Mesh>();
if (is_inside_tree())
_octant_enter_world(p_key);
g.dirty=true;
_queue_dirty_map();
}
void GridMap::_octant_bake(const OctantKey &p_key, const Ref<TriangleMesh>& p_tmesh,const Vector<BakeLight> &p_lights,List<Vector3> *p_prebake) {
ERR_FAIL_COND(!octant_map.has(p_key));
Octant&g = *octant_map[p_key];
Ref<TriangleMesh> tm=p_tmesh;
if (!p_prebake && is_inside_world())
_octant_exit_world(p_key);
Map< Ref<Material>, Ref<SurfaceTool> > surfaces;
Vector3 ofs(cell_size*0.5*int(center_x),cell_size*0.5*int(center_y),cell_size*0.5*int(center_z));
Vector3 octant_ofs=_octant_get_offset(p_key);
for(Map<int,Octant::ItemInstances>::Element *E=g.items.front();E;E=E->next()) {
Octant::ItemInstances &ii=E->get();
if (ii.mesh.is_null())
continue;
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;
xform.basis.set_orthogonal_index(C->get().rot);
xform.set_origin( cellpos*cell_size+ofs);
if (!p_prebake)
xform.origin-=octant_ofs;
for(int i=0;i<ii.mesh->get_surface_count();i++) {
if (p_prebake) {
if (ii.mesh->surface_get_primitive_type(i)!=Mesh::PRIMITIVE_TRIANGLES)
continue;
Array a = ii.mesh->surface_get_arrays(i);
DVector<Vector3> av=a[VS::ARRAY_VERTEX];
int avs = av.size();
DVector<Vector3>::Read vr = av.read();
DVector<int> ai=a[VS::ARRAY_INDEX];
int ais=ai.size();
if (ais) {
DVector<int>::Read ir=ai.read();
for(int j=0;j<ais;j++) {
p_prebake->push_back(xform.xform(vr[ir[j]]));
//print_line("V SET: "+xform.xform(vr[ir[j]]));
}
} else {
for(int j=0;j<avs;j++) {
p_prebake->push_back(xform.xform(vr[j]));
}
}
} else {
Ref<Material> m = ii.mesh->surface_get_material(i);
Map< Ref<Material>, Ref<SurfaceTool> >::Element *S=surfaces.find(m);
if (!S) {
S=surfaces.insert(m,Ref<SurfaceTool>( memnew( SurfaceTool )));
}
Ref<SurfaceTool> st = S->get();
List<SurfaceTool::Vertex>::Element *V=st->get_vertex_array().back();
st->append_from(ii.mesh,i,xform);
st->set_material(m);
if (tm.is_valid()) {
if (V)
V=V->next();
else
V=st->get_vertex_array().front();;
int lc = p_lights.size();
const BakeLight* bl = p_lights.ptr();
float ofs = cell_size*0.02;
for(;V;V=V->next()) {
SurfaceTool::Vertex &v=V->get();
Vector3 vertex = v.vertex + octant_ofs;
//print_line("V GET: "+vertex);
Vector3 normal = tm->get_area_normal( AABB( Vector3(-ofs,-ofs,-ofs)+vertex,Vector3(ofs,ofs,ofs)*2.0));
if (normal==Vector3()) {
print_line("couldn't find for vertex: "+vertex);
}
ERR_CONTINUE( normal== Vector3());
float max_l=1.0;
float max_dist=1.0;
if (lc) {
for(int j=0;j<lc;j++) {
const BakeLight &l=bl[j];
switch(l.type) {
case VS::LIGHT_DIRECTIONAL: {
Vector3 ray_from=vertex + normal *ofs;
Vector3 ray_to=l.dir*5000;
Vector3 n;
Vector3 p;
if (tm->intersect_segment(ray_from,ray_to,p,n)) {
float dist = 1.0-l.param[VS::LIGHT_PARAM_SHADOW_DARKENING];
if (dist<=max_dist) {
max_dist=dist;
max_l=1.0-dist;
}
}
} break;
}
}
}
v.color=Color(max_l,max_l,max_l,1.0);
}
st->add_to_format(VS::ARRAY_FORMAT_COLOR);
if (m.is_valid()) {
Ref<FixedSpatialMaterial> fm = m;
if (fm.is_valid())
fm->set_fixed_flag(FixedSpatialMaterial::FLAG_USE_COLOR_ARRAY,true);
}
}
}
}
}
}
if (p_prebake)
return;
g.baked = Ref<Mesh>( memnew( Mesh ));
for(Map< Ref<Material>, Ref<SurfaceTool> >::Element *E=surfaces.front();E;E=E->next()) {
Ref<SurfaceTool> st = E->get();
st->commit(g.baked);
}
g.bake_instance = VS::get_singleton()->instance_create();
VS::get_singleton()->instance_set_base(g.bake_instance,g.baked->get_rid());
if (is_inside_world())
_octant_enter_world(p_key);
g.dirty=true;
_queue_dirty_map();
}
void GridMap::_notification(int p_what) {
switch(p_what) {
case NOTIFICATION_ENTER_WORLD: {
_update_area_instances();
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());
}
awaiting_update=false;
last_transform=get_global_transform();
if (use_baked_light) {
_find_baked_light();
}
} 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;
} break;
case NOTIFICATION_EXIT_WORLD: {
for(Map<OctantKey,Octant*>::Element *E=octant_map.front();E;E=E->next()) {
_octant_exit_world(E->key());
}
if (use_baked_light) {
if (baked_light_instance) {
baked_light_instance->disconnect(SceneStringNames::get_singleton()->baked_light_changed,this,SceneStringNames::get_singleton()->_baked_light_changed);
baked_light_instance=NULL;
}
_baked_light_changed();
}
//_queue_dirty_map(MAP_DIRTY_INSTANCES|MAP_DIRTY_TRANSFORMS);
//_update_dirty_map_callback();
//_update_area_instances();
} break;
case NOTIFICATION_ENTER_TREE: {
Spatial *c=this;
while(c) {
navigation=c->cast_to<Navigation>();
if (navigation) {
break;
}
c=c->get_parent()->cast_to<Spatial>();
}
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() {
if (awaiting_update)
return;
if (is_inside_world()) {
MessageQueue::get_singleton()->push_call(this,"_update_dirty_map_callback");
awaiting_update=true;
}
}
void GridMap::_recreate_octant_data() {
Map<IndexKey,Cell> cell_copy=cell_map;
_clear_internal(true);
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);
}
}
void GridMap::_clear_internal(bool p_keep_areas) {
for(Map<OctantKey,Octant*>::Element *E=octant_map.front();E;E=E->next()) {
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);
}
//unbake just in case
if (E->get()->bake_instance.is_valid())
VS::get_singleton()->free(E->get()->bake_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);
memdelete(E->get());
}
octant_map.clear();
cell_map.clear();
if (p_keep_areas)
return;
for (Map<int,Area*>::Element *E=area_map.front();E;E=E->next()) {
VS::get_singleton()->free(E->get()->base_portal);
VS::get_singleton()->free(E->get()->instance);
for(int i=0;i<E->get()->portals.size();i++) {
VS::get_singleton()->free(E->get()->portals[i].instance);
}
memdelete(E->get());
}
}
void GridMap::clear() {
_clear_internal();
}
void GridMap::resource_changed(const RES& p_res) {
_recreate_octant_data();
}
void GridMap::_update_dirty_map_callback() {
if (!awaiting_update)
return;
for(Map<OctantKey,Octant*>::Element *E=octant_map.front();E;E=E->next()) {
_octant_update(E->key());
}
awaiting_update=false;
}
void GridMap::_bind_methods() {
ClassDB::bind_method(_MD("set_theme","theme:MeshLibrary"),&GridMap::set_theme);
ClassDB::bind_method(_MD("get_theme:MeshLibrary"),&GridMap::get_theme);
ClassDB::bind_method(_MD("set_bake","enable"),&GridMap::set_bake);
ClassDB::bind_method(_MD("is_baking_enabled"),&GridMap::is_baking_enabled);
ClassDB::bind_method(_MD("set_cell_size","size"),&GridMap::set_cell_size);
ClassDB::bind_method(_MD("get_cell_size"),&GridMap::get_cell_size);
ClassDB::bind_method(_MD("set_octant_size","size"),&GridMap::set_octant_size);
ClassDB::bind_method(_MD("get_octant_size"),&GridMap::get_octant_size);
ClassDB::bind_method(_MD("set_cell_item","x","y","z","item","orientation"),&GridMap::set_cell_item,DEFVAL(0));
ClassDB::bind_method(_MD("get_cell_item","x","y","z"),&GridMap::get_cell_item);
ClassDB::bind_method(_MD("get_cell_item_orientation","x","y","z"),&GridMap::get_cell_item_orientation);
// ClassDB::bind_method(_MD("_recreate_octants"),&GridMap::_recreate_octants);
ClassDB::bind_method(_MD("_update_dirty_map_callback"),&GridMap::_update_dirty_map_callback);
ClassDB::bind_method(_MD("resource_changed","resource"),&GridMap::resource_changed);
ClassDB::bind_method(_MD("set_center_x","enable"),&GridMap::set_center_x);
ClassDB::bind_method(_MD("get_center_x"),&GridMap::get_center_x);
ClassDB::bind_method(_MD("set_center_y","enable"),&GridMap::set_center_y);
ClassDB::bind_method(_MD("get_center_y"),&GridMap::get_center_y);
ClassDB::bind_method(_MD("set_center_z","enable"),&GridMap::set_center_z);
ClassDB::bind_method(_MD("get_center_z"),&GridMap::get_center_z);
ClassDB::bind_method(_MD("set_clip","enabled","clipabove","floor","axis"),&GridMap::set_clip,DEFVAL(true),DEFVAL(0),DEFVAL(Vector3::AXIS_X));
ClassDB::bind_method(_MD("create_area","id","area"),&GridMap::create_area);
ClassDB::bind_method(_MD("area_get_bounds","area","bounds"),&GridMap::area_get_bounds);
ClassDB::bind_method(_MD("area_set_exterior_portal","area","enable"),&GridMap::area_set_exterior_portal);
ClassDB::bind_method(_MD("area_set_name","area","name"),&GridMap::area_set_name);
ClassDB::bind_method(_MD("area_get_name","area"),&GridMap::area_get_name);
ClassDB::bind_method(_MD("area_is_exterior_portal","area"),&GridMap::area_is_exterior_portal);
ClassDB::bind_method(_MD("area_set_portal_disable_distance","area","distance"),&GridMap::area_set_portal_disable_distance);
ClassDB::bind_method(_MD("area_get_portal_disable_distance","area"),&GridMap::area_get_portal_disable_distance);
ClassDB::bind_method(_MD("area_set_portal_disable_color","area","color"),&GridMap::area_set_portal_disable_color);
ClassDB::bind_method(_MD("area_get_portal_disable_color","area"),&GridMap::area_get_portal_disable_color);
ClassDB::bind_method(_MD("erase_area","area"),&GridMap::erase_area);
ClassDB::bind_method(_MD("get_unused_area_id","area"),&GridMap::get_unused_area_id);
ClassDB::bind_method(_MD("bake_geometry"),&GridMap::bake_geometry);
ClassDB::bind_method(_MD("_baked_light_changed"),&GridMap::_baked_light_changed);
ClassDB::bind_method(_MD("set_use_baked_light","use"),&GridMap::set_use_baked_light);
ClassDB::bind_method(_MD("is_using_baked_light","use"),&GridMap::is_using_baked_light);
ClassDB::bind_method(_MD("_get_baked_light_meshes"),&GridMap::_get_baked_light_meshes);
ClassDB::set_method_flags("GridMap","bake_geometry",METHOD_FLAGS_DEFAULT|METHOD_FLAG_EDITOR);
ClassDB::bind_method(_MD("clear"),&GridMap::clear);
BIND_CONSTANT( INVALID_CELL_ITEM );
}
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_dirty_map_callback();
}
void GridMap::_update_areas() {
//clear the portals
for(Map<int,Area*>::Element *E=area_map.front();E;E=E->next()) {
//this should somehow be faster...
Area& a=*E->get();
a.portals.clear();
if (a.instance.is_valid()) {
VisualServer::get_singleton()->free(a.instance);
a.instance=RID();
}
}
//test all areas against all areas and create portals - this sucks (slow :( )
for(Map<int,Area*>::Element *E=area_map.front();E;E=E->next()) {
Area& a=*E->get();
if (a.exterior_portal) //that's pretty much all it does... yes it is
continue;
Vector3 from_a(a.from.x,a.from.y,a.from.z);
Vector3 to_a(a.to.x,a.to.y,a.to.z);
for(Map<int,Area*>::Element *F=area_map.front();F;F=F->next()) {
Area& b=*F->get();
Vector3 from_b(b.from.x,b.from.y,b.from.z);
Vector3 to_b(b.to.x,b.to.y,b.to.z);
// initially test intersection and discards
int axis=-1;
float sign=0;
bool valid=true;
Vector3 axmin,axmax;
for(int i=0;i<3;i++) {
if (from_a[i]==to_b[i]) {
if (axis!=-1) {
valid=false;
break;
}
axis=i;
sign=-1;
} else if (from_b[i]==to_a[i]) {
if (axis!=-1) {
valid=false;
break;
}
axis=i;
sign=+1;
}
if (from_a[i] > to_b[i] || to_a[i] < from_b[i] ) {
valid=false;
break;
} else {
axmin[i]= ( from_a[i] > from_b[i] ) ? from_a[i] :from_b[i];
axmax[i]= ( to_a[i] < to_b[i] ) ? to_a[i] :to_b[i];
}
}
if (axis==-1 || !valid)
continue;
Transform xf;
for(int i=0;i<3;i++) {
int ax=(axis+i)%3;
Vector3 axis_vec;
float scale = (i==0)?sign:((axmax[ax]-axmin[ax])*cell_size);
axis_vec[ax]=scale;
xf.basis.set_axis((2+i)%3,axis_vec);
xf.origin[i]=axmin[i]*cell_size;
}
Area::Portal portal;
portal.xform=xf;
a.portals.push_back(portal);
}
}
_update_area_instances();
}
void GridMap::_update_area_instances() {
Transform base_xform;
if (_in_tree)
base_xform=get_global_transform();
for(Map<int,Area*>::Element *E=area_map.front();E;E=E->next()) {
//this should somehow be faster...
Area& a=*E->get();
if (a.instance.is_valid()!=_in_tree) {
if (!_in_tree) {
for(int i=0;i<a.portals.size();i++) {
Area::Portal&p=a.portals[i];
ERR_CONTINUE(!p.instance.is_valid());
VisualServer::get_singleton()->free(p.instance);
p.instance=RID();
}
VisualServer::get_singleton()->free(a.instance);
a.instance=RID();
} else {
//a.instance = VisualServer::get_singleton()->instance_create2(base_room,get_world()->get_scenario());
for(int i=0;i<a.portals.size();i++) {
Area::Portal&p=a.portals[i];
ERR_CONTINUE(p.instance.is_valid());
p.instance=VisualServer::get_singleton()->instance_create2(a.base_portal,get_world()->get_scenario());
VisualServer::get_singleton()->instance_set_room(p.instance,a.instance);
}
}
}
if (a.instance.is_valid()) {
Transform xform;
Vector3 from_a(a.from.x,a.from.y,a.from.z);
Vector3 to_a(a.to.x,a.to.y,a.to.z);
for(int i=0;i<3;i++) {
xform.origin[i]=from_a[i]*cell_size;
Vector3 s;
s[i]=(to_a[i]-from_a[i])*cell_size;
xform.basis.set_axis(i,s);
}
VisualServer::get_singleton()->instance_set_transform(a.instance,base_xform * xform);
for(int i=0;i<a.portals.size();i++) {
Area::Portal&p=a.portals[i];
ERR_CONTINUE(!p.instance.is_valid());
VisualServer::get_singleton()->instance_set_transform(p.instance,base_xform * xform);
}
}
}
}
Error GridMap::create_area(int p_id,const AABB& p_bounds) {
ERR_FAIL_COND_V(area_map.has(p_id),ERR_ALREADY_EXISTS);
ERR_EXPLAIN("ID 0 is taken as global area, start from 1");
ERR_FAIL_COND_V(p_id==0,ERR_INVALID_PARAMETER);
ERR_FAIL_COND_V(p_bounds.has_no_area(),ERR_INVALID_PARAMETER);
// FIRST VALIDATE AREA
IndexKey from,to;
from.x=p_bounds.pos.x;
from.y=p_bounds.pos.y;
from.z=p_bounds.pos.z;
to.x=p_bounds.pos.x+p_bounds.size.x;
to.y=p_bounds.pos.y+p_bounds.size.y;
to.z=p_bounds.pos.z+p_bounds.size.z;
for(Map<int,Area*>::Element *E=area_map.front();E;E=E->next()) {
//this should somehow be faster...
Area& a=*E->get();
//does it interset with anything else?
if ( from.x >= a.to.x ||
to.x <= a.from.x ||
from.y >= a.to.y ||
to.y <= a.from.y ||
from.z >= a.to.z ||
to.z <= a.from.z ) {
// all good
} else {
return ERR_INVALID_PARAMETER;
}
}
Area *area = memnew( Area );
area->from=from;
area->to=to;
area->portal_disable_distance=0;
area->exterior_portal=false;
area->name="Area "+itos(p_id);
area_map[p_id]=area;
_recreate_octant_data();
return OK;
}
AABB GridMap::area_get_bounds(int p_area) const {
ERR_FAIL_COND_V(!area_map.has(p_area),AABB());
const Area *a = area_map[p_area];
AABB aabb;
aabb.pos=Vector3(a->from.x,a->from.y,a->from.z);
aabb.size=Vector3(a->to.x,a->to.y,a->to.z)-aabb.pos;
return aabb;
}
void GridMap::area_set_name(int p_area,const String& p_name) {
ERR_FAIL_COND(!area_map.has(p_area));
Area *a = area_map[p_area];
a->name=p_name;
}
String GridMap::area_get_name(int p_area) const {
ERR_FAIL_COND_V(!area_map.has(p_area),"");
const Area *a = area_map[p_area];
return a->name;
}
void GridMap::area_set_exterior_portal(int p_area,bool p_enable) {
ERR_FAIL_COND(!area_map.has(p_area));
Area *a = area_map[p_area];
if (a->exterior_portal==p_enable)
return;
a->exterior_portal=p_enable;
_recreate_octant_data();
}
bool GridMap::area_is_exterior_portal(int p_area) const {
ERR_FAIL_COND_V(!area_map.has(p_area),false);
const Area *a = area_map[p_area];
return a->exterior_portal;
}
void GridMap::area_set_portal_disable_distance(int p_area, float p_distance) {
ERR_FAIL_COND(!area_map.has(p_area));
Area *a = area_map[p_area];
a->portal_disable_distance=p_distance;
}
float GridMap::area_get_portal_disable_distance(int p_area) const {
ERR_FAIL_COND_V(!area_map.has(p_area),0);
const Area *a = area_map[p_area];
return a->portal_disable_distance;
}
void GridMap::area_set_portal_disable_color(int p_area, Color p_color) {
ERR_FAIL_COND(!area_map.has(p_area));
Area *a = area_map[p_area];
a->portal_disable_color=p_color;
}
Color GridMap::area_get_portal_disable_color(int p_area) const {
ERR_FAIL_COND_V(!area_map.has(p_area),Color());
const Area *a = area_map[p_area];
return a->portal_disable_color;
}
void GridMap::get_area_list(List<int> *p_areas) const {
for(const Map<int,Area*>::Element *E=area_map.front();E;E=E->next()) {
p_areas->push_back(E->key());
}
}
GridMap::Area::Portal::~Portal() {
if (instance.is_valid())
VisualServer::get_singleton()->free(instance);
}
GridMap::Area::Area() {
base_portal=VisualServer::get_singleton()->portal_create();
Vector< Point2 > points;
points.push_back( Point2( 0, 1 ) );
points.push_back( Point2( 1, 1 ) );
points.push_back( Point2( 1, 0 ) );
points.push_back( Point2( 0, 0 ) );
VisualServer::get_singleton()->portal_set_shape(base_portal,points);
}
GridMap::Area::~Area() {
if (instance.is_valid())
VisualServer::get_singleton()->free(instance);
VisualServer::get_singleton()->free(base_portal);
}
void GridMap::erase_area(int p_area) {
ERR_FAIL_COND(!area_map.has(p_area));
Area* a=area_map[p_area];
memdelete(a);
area_map.erase(p_area);
_recreate_octant_data();
}
int GridMap::get_unused_area_id() const {
if (area_map.empty())
return 1;
else
return area_map.back()->key()+1;
}
void GridMap::set_bake(bool p_bake) {
bake=p_bake;
if (bake==false) {
for(Map<OctantKey,Octant*>::Element *E=octant_map.front();E;E=E->next()) {
_octant_clear_baked(E->key());
}
}
}
bool GridMap::is_baking_enabled() const {
return bake;
}
void GridMap::set_cell_scale(float p_scale) {
cell_scale=p_scale;
_queue_dirty_map();
}
float GridMap::get_cell_scale() const{
return cell_scale;
}
void GridMap::bake_geometry() {
//used to compute vertex occlusion
Ref<TriangleMesh> tmesh;
Vector<BakeLight> lights;
if (true) {
List<Vector3> vertices;
for(Map<OctantKey,Octant*>::Element *E=octant_map.front();E;E=E->next()) {
_octant_bake(E->key(),tmesh,lights,&vertices);
}
DVector<Vector3> vv;
vv.fill_with(vertices);
//print_line("TOTAL VERTICES: "+itos(vv.size()));
tmesh = Ref<TriangleMesh>( memnew( TriangleMesh ));
tmesh->create(vv);
for(int i=0;i<get_child_count();i++) {
if (get_child(i)->cast_to<Light>()) {
Light *l = get_child(i)->cast_to<Light>();
BakeLight bl;
for(int i=0;i<Light::PARAM_MAX;i++) {
bl.param[i]=l->get_parameter(Light::Parameter(i));
}
Transform t=l->get_global_transform();
bl.pos=t.origin;
bl.dir=t.basis.get_axis(2);
bl.type=l->get_light_type();
lights.push_back(bl);
}
}
}
int idx=0;
for(Map<OctantKey,Octant*>::Element *E=octant_map.front();E;E=E->next()) {
if (E->get()->baked.is_valid())
_octant_clear_baked(E->key());
_octant_bake(E->key(),tmesh,lights);
print_line("baking "+itos(idx)+"/"+itos(octant_map.size()));
idx++;
}
}
void GridMap::_baked_light_changed() {
// if (!baked_light_instance)
// VS::get_singleton()->instance_geometry_set_baked_light(get_instance(),RID());
// else
// VS::get_singleton()->instance_geometry_set_baked_light(get_instance(),baked_light_instance->get_baked_light_instance());
for(Map<OctantKey,Octant*>::Element *E=octant_map.front();E;E=E->next()) {
for(Map<int,Octant::ItemInstances>::Element *F=E->get()->items.front();F;F=F->next()) {
VS::get_singleton()->instance_geometry_set_baked_light(F->get().multimesh_instance,baked_light_instance?baked_light_instance->get_baked_light_instance():RID());
}
}
}
void GridMap::_find_baked_light() {
Node *n=get_parent();
while(n) {
BakedLightInstance *bl=n->cast_to<BakedLightInstance>();
if (bl) {
baked_light_instance=bl;
baked_light_instance->connect(SceneStringNames::get_singleton()->baked_light_changed,this,SceneStringNames::get_singleton()->_baked_light_changed);
_baked_light_changed();
return;
}
n=n->get_parent();
}
_baked_light_changed();
}
Array GridMap::_get_baked_light_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));
Array meshes;
for (Map<IndexKey,Cell>::Element *E=cell_map.front();E;E=E->next()) {
int id = E->get().item;
if (!theme->has_item(id))
continue;
Ref<Mesh> mesh=theme->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;
}
void GridMap::set_use_baked_light(bool p_use) {
if (use_baked_light==p_use)
return;
use_baked_light=p_use;
if (is_inside_world()) {
if (!p_use) {
if (baked_light_instance) {
baked_light_instance->disconnect(SceneStringNames::get_singleton()->baked_light_changed,this,SceneStringNames::get_singleton()->_baked_light_changed);
baked_light_instance=NULL;
}
_baked_light_changed();
} else {
_find_baked_light();
}
}
}
bool GridMap::is_using_baked_light() const{
return use_baked_light;
}
GridMap::GridMap() {
cell_size=2;
octant_size=4;
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;
baked_lock=false;
bake=false;
cell_scale=1.0;
baked_light_instance=NULL;
use_baked_light=false;
navigation = NULL;
}
GridMap::~GridMap() {
if (!theme.is_null())
theme->unregister_owner(this);
clear();
}
Reference in New Issue View Git Blame Copy Permalink