BroadPhase2DHashGrid::BroadPhase2DHashGrid() {
hash_table_size = GLOBAL_DEF("physics_2d/bp_hash_table_size",4096);
hash_table_size = Math::larger_prime(hash_table_size);
hash_table = memnew_arr( PosBin*, hash_table_size);
cell_size = GLOBAL_DEF("physics_2d/cell_size",128);
for(int i=0;i<hash_table_size;i++)
hash_table[i]=NULL;
pass=1;
current=0;
}
BroadPhase2DHashGrid::BroadPhase2DHashGrid() {
hash_table_size = GLOBAL_DEF("physics/2d/bp_hash_table_size", 4096);
hash_table_size = Math::larger_prime(hash_table_size);
hash_table = memnew_arr(PosBin *, hash_table_size);
cell_size = GLOBAL_DEF("physics/2d/cell_size", 128);
large_object_min_surface = GLOBAL_DEF("physics/2d/large_object_surface_threshold_in_cells", 512);
for (int i = 0; i < hash_table_size; i++)
hash_table[i] = NULL;
pass = 1;
current = 0;
}
Error EditorRun::run(const String& p_scene,const String p_custom_args,const List<String>& p_breakpoints,const String& p_edited_scene) {
List<String> args;
String resource_path = Globals::get_singleton()->get_resource_path();
if (resource_path!="") {
args.push_back("-path");
args.push_back(resource_path.replace(" ","%20"));
}
if (true) {
args.push_back("-rdebug");
args.push_back("localhost:"+String::num(GLOBAL_DEF("debug/debug_port", 6007)));
}
if (p_custom_args!="") {
Vector<String> cargs=p_custom_args.split(" ",false);
for(int i=0; i<cargs.size(); i++) {
args.push_back(cargs[i].replace("%20"," ").replace("$scene",p_edited_scene.replace(" ","%20")));
}
}
if (p_breakpoints.size()) {
args.push_back("-bp");
String bpoints;
for(const List<String>::Element *E=p_breakpoints.front(); E; E=E->next()) {
bpoints+=E->get().replace(" ","%20");
if (E->next())
bpoints+=",";
}
args.push_back(bpoints);
}
args.push_back(p_scene);
String exec = OS::get_singleton()->get_executable_path();
printf("running: %ls", exec.c_str());
for (List<String>::Element* E = args.front(); E ; E = E->next()) {
printf(" %ls", E->get().c_str());
};
printf("\n");
pid=0;
Error err = OS::get_singleton()->execute(exec,args,false,&pid);
ERR_FAIL_COND_V(err,err);
status = STATUS_PLAY;
return OK;
}
EditorFileSystem::EditorFileSystem() {
reimport_on_missing_imported_files = GLOBAL_DEF("editor/reimport_missing_imported_files", true);
singleton = this;
filesystem = memnew(EditorFileSystemDirectory); //like, empty
filesystem->parent = NULL;
thread = NULL;
scanning = false;
importing = false;
use_threads = true;
thread_sources = NULL;
new_filesystem = NULL;
abort_scan = false;
scanning_changes = false;
scanning_changes_done = false;
ResourceSaver::set_save_callback(_resource_saved);
DirAccess *da = DirAccess::create(DirAccess::ACCESS_RESOURCES);
if (da->change_dir("res://.import") != OK) {
da->make_dir("res://.import");
}
memdelete(da);
scan_total = 0;
}
void OSIPhone::mouse_move(int p_idx, int p_prev_x, int p_prev_y, int p_x, int p_y, bool p_use_as_mouse) {
if (!GLOBAL_DEF("debug/disable_touch", false)) {
Ref<InputEventScreenDrag> ev;
ev.instance();
ev->set_index(p_idx);
ev->set_position(Vector2(p_x, p_y));
ev->set_relative(Vector2(p_x - p_prev_x, p_y - p_prev_y));
queue_event(ev);
};
if (p_use_as_mouse) {
Ref<InputEventMouseMotion> ev;
ev.instance();
ev->set_position(Vector2(p_x, p_y));
ev->set_global_position(Vector2(p_x, p_y));
ev->set_relative(Vector2(p_x - p_prev_x, p_y - p_prev_y));
input->set_mouse_position(ev->get_position());
ev->set_speed(input->get_last_mouse_speed());
ev->set_button_mask(BUTTON_LEFT); // pressed
queue_event(ev);
};
};
void OSIPhone::mouse_button(int p_idx, int p_x, int p_y, bool p_pressed, bool p_doubleclick, bool p_use_as_mouse) {
if (!GLOBAL_DEF("debug/disable_touch", false)) {
Ref<InputEventScreenTouch> ev;
ev.instance();
ev->set_index(p_idx);
ev->set_pressed(p_pressed);
ev->set_position(Vector2(p_x, p_y));
queue_event(ev);
};
mouse_list.pressed[p_idx] = p_pressed;
if (p_use_as_mouse) {
Ref<InputEventMouseButton> ev;
ev.instance();
ev->set_position(Vector2(p_x, p_y));
ev->set_global_position(Vector2(p_x, p_y));
//mouse_list.pressed[p_idx] = p_pressed;
input->set_mouse_position(ev->get_position());
ev->set_button_index(BUTTON_LEFT);
ev->set_doubleclick(p_doubleclick);
ev->set_pressed(p_pressed);
queue_event(ev);
};
};
ScriptDebuggerRemote::ScriptDebuggerRemote() {
tcp_client = StreamPeerTCP::create_ref();
packet_peer_stream = Ref<PacketPeerStream>( memnew(PacketPeerStream) );
packet_peer_stream->set_stream_peer(tcp_client);
mutex = Mutex::create();
locking=false;
phl.printfunc=_print_handler;
phl.userdata=this;
add_print_handler(&phl);
requested_quit=false;
performance = Globals::get_singleton()->get_singleton_object("Performance");
last_perf_time=0;
poll_every=0;
request_scene_tree=NULL;
live_edit_funcs=NULL;
max_cps = GLOBAL_DEF("debug/max_remote_stdout_chars_per_second",2048);
char_count=0;
msec_count=0;
last_msec=0;
eh.errfunc=_err_handler;
eh.userdata=this;
add_error_handler(&eh);
}
VisualServerWrapMT::VisualServerWrapMT(VisualServer* p_contained,bool p_create_thread) : command_queue(p_create_thread) {
visual_server=p_contained;
create_thread=p_create_thread;
thread=NULL;
draw_mutex=NULL;
draw_pending=0;
draw_thread_up=false;
alloc_mutex=Mutex::create();
texture_pool_max_size=GLOBAL_DEF("render/thread_textures_prealloc",20);
mesh_pool_max_size=GLOBAL_DEF("render/thread_meshes_prealloc",20);
if (!p_create_thread) {
server_thread=Thread::get_caller_ID();
} else {
server_thread=0;
}
}
Error AudioDriverAndroid::init(){
mutex = Mutex::create();
/*
// TODO: pass in/return a (Java) device ID, also whether we're opening for input or output
this->spec.samples = Android_JNI_OpenAudioDevice(this->spec.freq, this->spec.format == AUDIO_U8 ? 0 : 1, this->spec.channels, this->spec.samples);
SDL_CalculateAudioSpec(&this->spec);
if (this->spec.samples == 0) {
// Init failed?
SDL_SetError("Java-side initialization failed!");
return 0;
}
*/
//Android_JNI_SetupThread();
// __android_log_print(ANDROID_LOG_VERBOSE, "SDL", "SDL audio: opening device");
JNIEnv *env = ThreadAndroid::get_env();
int mix_rate = GLOBAL_DEF("audio/mix_rate",44100);
int latency = GLOBAL_DEF("audio/output_latency",25);
latency=50;
unsigned int buffer_size = nearest_power_of_2( latency * mix_rate / 1000 );
if (OS::get_singleton()->is_stdout_verbose()) {
print_line("audio buffer size: "+itos(buffer_size));
}
__android_log_print(ANDROID_LOG_INFO,"godot","Initializing audio! params: %i,%i ",mix_rate,buffer_size);
audioBuffer = env->CallObjectMethod(io,_init_audio, mix_rate, buffer_size);
ERR_FAIL_COND_V( audioBuffer == NULL, ERR_INVALID_PARAMETER);
audioBuffer = env->NewGlobalRef(audioBuffer);
jboolean isCopy = JNI_FALSE;
audioBufferPinned = env->GetShortArrayElements((jshortArray)audioBuffer, &isCopy);
audioBufferFrames = env->GetArrayLength((jshortArray)audioBuffer);
audioBuffer32 = memnew_arr(int32_t,audioBufferFrames);
return OK;
}
VisualServer::VisualServer() {
// ERR_FAIL_COND(singleton);
singleton=this;
mm_policy=GLOBAL_DEF("render/mipmap_policy",0);
if (mm_policy<0 || mm_policy>2)
mm_policy=0;
}
PacketPeerStream::PacketPeerStream() {
int rbsize=GLOBAL_DEF( "core/packet_stream_peer_max_buffer_po2",(16));
ring_buffer.resize(rbsize);
temp_buffer.resize(1<<rbsize);
}
Error AudioDriverXAudio2::init() {
active = false;
thread_exited = false;
exit_thread = false;
pcm_open = false;
samples_in = NULL;
mix_rate = 48000;
// FIXME: speaker_mode seems unused in the Xaudio2 driver so far
speaker_mode = SPEAKER_MODE_STEREO;
channels = 2;
int latency = GLOBAL_DEF("audio/output_latency", 25);
buffer_size = closest_power_of_2(latency * mix_rate / 1000);
samples_in = memnew_arr(int32_t, buffer_size * channels);
for (int i = 0; i < AUDIO_BUFFERS; i++) {
samples_out[i] = memnew_arr(int16_t, buffer_size * channels);
xaudio_buffer[i].AudioBytes = buffer_size * channels * sizeof(int16_t);
xaudio_buffer[i].pAudioData = (const BYTE *)(samples_out[i]);
xaudio_buffer[i].Flags = 0;
}
HRESULT hr;
hr = XAudio2Create(&xaudio, 0, XAUDIO2_DEFAULT_PROCESSOR);
if (hr != S_OK) {
ERR_EXPLAIN("Error creating XAudio2 engine.");
ERR_FAIL_V(ERR_UNAVAILABLE);
}
hr = xaudio->CreateMasteringVoice(&mastering_voice);
if (hr != S_OK) {
ERR_EXPLAIN("Error creating XAudio2 mastering voice.");
ERR_FAIL_V(ERR_UNAVAILABLE);
}
wave_format.nChannels = channels;
wave_format.cbSize = 0;
wave_format.nSamplesPerSec = mix_rate;
wave_format.wFormatTag = WAVE_FORMAT_PCM;
wave_format.wBitsPerSample = 16;
wave_format.nBlockAlign = channels * wave_format.wBitsPerSample >> 3;
wave_format.nAvgBytesPerSec = mix_rate * wave_format.nBlockAlign;
hr = xaudio->CreateSourceVoice(&source_voice, &wave_format, 0, XAUDIO2_MAX_FREQ_RATIO, &voice_callback);
if (hr != S_OK) {
ERR_EXPLAIN("Error creating XAudio2 source voice. " + itos(hr));
ERR_FAIL_V(ERR_UNAVAILABLE);
}
mutex = Mutex::create();
thread = Thread::create(AudioDriverXAudio2::thread_func, this);
return OK;
};
MessageQueue::MessageQueue() {
ERR_FAIL_COND(singleton!=NULL);
singleton=this;
buffer_end=0;
buffer_max_used=0;
buffer_size=GLOBAL_DEF( "core/message_queue_size_kb", DEFAULT_QUEUE_SIZE_KB );
buffer_size*=1024;
buffer = memnew_arr( uint8_t, buffer_size );
}
void OSIPhone::touch_drag(int p_idx, int p_prev_x, int p_prev_y, int p_x, int p_y) {
if (!GLOBAL_DEF("debug/disable_touch", false)) {
Ref<InputEventScreenDrag> ev;
ev.instance();
ev->set_index(p_idx);
ev->set_position(Vector2(p_x, p_y));
ev->set_relative(Vector2(p_x - p_prev_x, p_y - p_prev_y));
queue_event(ev);
};
};
FileAccessNetwork::FileAccessNetwork() {
eof_flag=false;
opened=false;
pos=0;
sem=Semaphore::create();
page_sem=Semaphore::create();
buffer_mutex=Mutex::create();
FileAccessNetworkClient *nc = FileAccessNetworkClient::singleton;
nc->lock_mutex();
id=nc->last_id++;
nc->accesses[id]=this;
nc->unlock_mutex();
page_size = GLOBAL_DEF("remote_fs/page_size",65536);
read_ahead = GLOBAL_DEF("remote_fs/page_read_ahead",4);
max_pages = GLOBAL_DEF("remote_fs/max_pages",20);
last_activity_val=0;
waiting_on_page=-1;
last_page=-1;
}
void OSIPhone::touch_press(int p_idx, int p_x, int p_y, bool p_pressed, bool p_doubleclick) {
if (!GLOBAL_DEF("debug/disable_touch", false)) {
Ref<InputEventScreenTouch> ev;
ev.instance();
ev->set_index(p_idx);
ev->set_pressed(p_pressed);
ev->set_position(Vector2(p_x, p_y));
queue_event(ev);
};
touch_list.pressed[p_idx] = p_pressed;
};
ResourceFormatLoaderImage::ResourceFormatLoaderImage() {
max_texture_size = GLOBAL_DEF("debug/max_texture_size",0);
GLOBAL_DEF("debug/max_texture_size_alert",false);
debug_load_times=GLOBAL_DEF("debug/image_load_times",false);
GLOBAL_DEF("texture_import/filter",true);
GLOBAL_DEF("texture_import/gen_mipmaps",true);
GLOBAL_DEF("texture_import/repeat",true);
}
void ScriptEditorDebugger::start() {
stop();
uint16_t port = GLOBAL_DEF("debug/remote_port",6007);
perf_history.clear();
for(int i=0;i<Performance::MONITOR_MAX;i++) {
perf_max[i]=0;
}
server->listen(port);
set_process(true);
}
RES Skeleton::_get_gizmo_geometry() const {
if (!GLOBAL_DEF("debug/draw_skeleton", true))
return RES();
if (bones.size()==0)
return RES();
Ref<SurfaceTool> surface_tool( memnew( SurfaceTool ));
Ref<FixedMaterial> mat( memnew( FixedMaterial ));
mat->set_parameter( FixedMaterial::PARAM_DIFFUSE,Color(0.6,1.0,0.3,0.1) );
mat->set_line_width(4);
mat->set_flag(Material::FLAG_DOUBLE_SIDED,true);
mat->set_flag(Material::FLAG_UNSHADED,true);
mat->set_flag(Material::FLAG_ONTOP,true);
// mat->set_hint(Material::HINT_NO_DEPTH_DRAW,true);
surface_tool->begin(Mesh::PRIMITIVE_LINES);
surface_tool->set_material(mat);
const Bone *bonesptr=&bones[0];
int len=bones.size();
for (int i=0;i<len;i++) {
const Bone &b=bonesptr[i];
Transform t;
if (b.parent<0)
continue;
Vector3 v1=(bonesptr[b.parent].pose_global * bonesptr[b.parent].rest_global_inverse).xform(bonesptr[b.parent].rest_global_inverse.affine_inverse().origin);
Vector3 v2=(b.pose_global * b.rest_global_inverse).xform(b.rest_global_inverse.affine_inverse().origin);
surface_tool->add_vertex(v1);
surface_tool->add_vertex(v2);
}
return surface_tool->commit();
}
void OSIPhone::mouse_move(int p_idx, int p_prev_x, int p_prev_y, int p_x, int p_y, bool p_use_as_mouse) {
if (!GLOBAL_DEF("debug/disable_touch", false)) {
InputEvent ev;
ev.type = InputEvent::SCREEN_DRAG;
ev.ID = ++last_event_id;
ev.screen_drag.index = p_idx;
ev.screen_drag.x = p_x;
ev.screen_drag.y = p_y;
ev.screen_drag.relative_x = p_x - p_prev_x;
ev.screen_drag.relative_y = p_y - p_prev_y;
queue_event(ev);
};
if (p_use_as_mouse) {
InputEvent ev;
ev.type = InputEvent::MOUSE_MOTION;
ev.device = 0;
ev.mouse_motion.pointer_index = p_idx;
ev.ID = ++last_event_id;
if (true) { // vertical
ev.mouse_motion.x = ev.mouse_button.global_x = p_x;
ev.mouse_motion.y = ev.mouse_button.global_y = p_y;
ev.mouse_motion.relative_x = ev.mouse_motion.x - p_prev_x;
ev.mouse_motion.relative_y = ev.mouse_motion.y - p_prev_y;
} else { // horizontal?
ev.mouse_motion.x = ev.mouse_button.global_x = video_mode.height - p_y;
ev.mouse_motion.y = ev.mouse_button.global_y = p_x;
ev.mouse_motion.relative_x = ev.mouse_motion.x - (video_mode.height - p_prev_x);
ev.mouse_motion.relative_y = ev.mouse_motion.y - p_prev_x;
};
input->set_mouse_pos(Point2(ev.mouse_motion.x, ev.mouse_motion.y));
ev.mouse_motion.speed_x = input->get_mouse_speed().x;
ev.mouse_motion.speed_y = input->get_mouse_speed().y;
ev.mouse_motion.button_mask = 1; // pressed
queue_event(ev);
};
};
void ScriptEditorDebugger::start() {
stop();
if (!EditorNode::get_log()->is_visible()) {
EditorNode::get_singleton()->make_bottom_panel_item_visible(EditorNode::get_log());
}
uint16_t port = GLOBAL_DEF("debug/remote_port",6007);
perf_history.clear();
for(int i=0;i<Performance::MONITOR_MAX;i++) {
perf_max[i]=0;
}
server->listen(port);
set_process(true);
}
void VideoStreamTheoraplayer::set_file(const String& p_file) {
FileAccess* f = FileAccess::open(p_file, FileAccess::READ);
if (!f || !f->is_open())
return;
if (!audio_factory) {
audio_factory = memnew(TPAudioGodotFactory);
};
if (mgr == NULL) {
mgr = memnew(TheoraVideoManager(4));
mgr->setAudioInterfaceFactory(audio_factory);
};
int track = GLOBAL_DEF("theora/audio_track", 0); // hack
if (p_file.find(".mp4") != -1) {
std::string file = p_file.replace("res://", "").utf8().get_data();
clip = mgr->createVideoClip(file, TH_RGBX, 2, false, track);
//clip->set_audio_track(audio_track);
memdelete(f);
} else {
TheoraDataSource* ds = memnew(TPDataFA(f, p_file));
try {
clip = mgr->createVideoClip(ds);
clip->set_audio_track(audio_track);
} catch (_TheoraGenericException e) {
printf("exception ocurred! %s\n", e.repr().c_str());
clip = NULL;
};
};
clip->pause();
started = true;
};
void OSIPhone::mouse_button(int p_idx, int p_x, int p_y, bool p_pressed, bool p_doubleclick, bool p_use_as_mouse) {
if (!GLOBAL_DEF("debug/disable_touch", false)) {
InputEvent ev;
ev.type = InputEvent::SCREEN_TOUCH;
ev.ID = ++last_event_id;
ev.screen_touch.index = p_idx;
ev.screen_touch.pressed = p_pressed;
ev.screen_touch.x = p_x;
ev.screen_touch.y = p_y;
queue_event(ev);
};
mouse_list.pressed[p_idx] = p_pressed;
if (p_use_as_mouse) {
InputEvent ev;
ev.type = InputEvent::MOUSE_BUTTON;
ev.device = 0;
ev.mouse_button.pointer_index = p_idx;
ev.ID = ++last_event_id;
// swaped it for tilted screen
//ev.mouse_button.x = ev.mouse_button.global_x = video_mode.height - p_y;
//ev.mouse_button.y = ev.mouse_button.global_y = p_x;
ev.mouse_button.x = ev.mouse_button.global_x = p_x;
ev.mouse_button.y = ev.mouse_button.global_y = p_y;
//mouse_list.pressed[p_idx] = p_pressed;
input->set_mouse_pos(Point2(ev.mouse_motion.x, ev.mouse_motion.y));
ev.mouse_button.button_index = BUTTON_LEFT;
ev.mouse_button.doubleclick = p_doubleclick;
ev.mouse_button.pressed = p_pressed;
queue_event(ev);
};
};
Error AudioDriverDummy::init() {
active=false;
thread_exited=false;
exit_thread=false;
pcm_open = false;
samples_in = NULL;
mix_rate = 44100;
speaker_mode = SPEAKER_MODE_STEREO;
channels = 2;
int latency = GLOBAL_DEF("audio/output_latency",25);
buffer_size = nearest_power_of_2( latency * mix_rate / 1000 );
samples_in = memnew_arr(int32_t, buffer_size*channels);
mutex=Mutex::create();
thread = Thread::create(AudioDriverDummy::thread_func, this);
return OK;
};
Error AudioDriverMediaKit::init() {
active = false;
mix_rate = 44100;
output_format = OUTPUT_STEREO;
channels = 2;
int latency = GLOBAL_DEF("audio/output_latency", 25);
buffer_size = nearest_power_of_2(latency * mix_rate / 1000);
samples_in = memnew_arr(int32_t, buffer_size * channels);
media_raw_audio_format format;
format = media_raw_audio_format::wildcard;
format.frame_rate = mix_rate;
format.channel_count = channels;
format.format = media_raw_audio_format::B_AUDIO_INT;
format.byte_order = B_MEDIA_LITTLE_ENDIAN;
format.buffer_size = buffer_size * sizeof(int32_t) * channels;
player = new BSoundPlayer(
&format,
"godot_sound_server",
AudioDriverMediaKit::PlayBuffer,
NULL,
this
);
if (player->InitCheck() != B_OK) {
fprintf(stderr, "MediaKit ERR: can not create a BSoundPlayer instance\n");
ERR_FAIL_COND_V(player == NULL, ERR_CANT_OPEN);
}
mutex = Mutex::create();
player->Start();
return OK;
}
void StreamPeerMbedTLS::initialize_ssl() {
_create = _create_func;
load_certs_func = _load_certs;
mbedtls_x509_crt_init(&cacert);
#ifdef DEBUG_ENABLED
mbedtls_debug_set_threshold(1);
#endif
String certs_path = GLOBAL_DEF("network/ssl/certificates", "");
ProjectSettings::get_singleton()->set_custom_property_info("network/ssl/certificates", PropertyInfo(Variant::STRING, "network/ssl/certificates", PROPERTY_HINT_FILE, "*.crt"));
if (certs_path != "") {
FileAccess *f = FileAccess::open(certs_path, FileAccess::READ);
if (f) {
PoolByteArray arr;
int flen = f->get_len();
arr.resize(flen + 1);
{
PoolByteArray::Write w = arr.write();
f->get_buffer(w.ptr(), flen);
w[flen] = 0; //end f string
}
memdelete(f);
_load_certs(arr);
print_line("Loaded certs from '" + certs_path);
}
}
available = true;
}
void register_scene_types() {
SceneStringNames::create();
OS::get_singleton()->yield(); //may take time to init
Node::init_node_hrcr();
resource_loader_image = memnew( ResourceFormatLoaderImage );
ResourceLoader::add_resource_format_loader( resource_loader_image );
resource_loader_wav = memnew( ResourceFormatLoaderWAV );
ResourceLoader::add_resource_format_loader( resource_loader_wav );
#ifdef TOOLS_ENABLED
//scene first!
#endif
resource_loader_theme = memnew( ResourceFormatLoaderTheme );
ResourceLoader::add_resource_format_loader( resource_loader_theme );
resource_loader_shader = memnew( ResourceFormatLoaderShader );
ResourceLoader::add_resource_format_loader( resource_loader_shader );
make_default_theme();
OS::get_singleton()->yield(); //may take time to init
ObjectTypeDB::register_type<Object>();
ObjectTypeDB::register_type<Node>();
ObjectTypeDB::register_virtual_type<InstancePlaceholder>();
ObjectTypeDB::register_type<Viewport>();
ObjectTypeDB::register_virtual_type<RenderTargetTexture>();
ObjectTypeDB::register_type<HTTPRequest>();
ObjectTypeDB::register_type<Timer>();
ObjectTypeDB::register_type<CanvasLayer>();
ObjectTypeDB::register_type<CanvasModulate>();
ObjectTypeDB::register_type<ResourcePreloader>();
/* REGISTER GUI */
ObjectTypeDB::register_type<ButtonGroup>();
ObjectTypeDB::register_virtual_type<BaseButton>();
OS::get_singleton()->yield(); //may take time to init
ObjectTypeDB::register_type<Control>();
// ObjectTypeDB::register_type<EmptyControl>();
ObjectTypeDB::add_compatibility_type("EmptyControl","Control");
ObjectTypeDB::register_type<Button>();
ObjectTypeDB::register_type<Label>();
ObjectTypeDB::register_type<HScrollBar>();
ObjectTypeDB::register_type<VScrollBar>();
ObjectTypeDB::register_type<ProgressBar>();
ObjectTypeDB::register_type<HSlider>();
ObjectTypeDB::register_type<VSlider>();
ObjectTypeDB::register_type<Popup>();
ObjectTypeDB::register_type<PopupPanel>();
ObjectTypeDB::register_type<MenuButton>();
ObjectTypeDB::register_type<CheckBox>();
ObjectTypeDB::register_type<CheckButton>();
ObjectTypeDB::register_type<ToolButton>();
ObjectTypeDB::register_type<LinkButton>();
ObjectTypeDB::register_type<Panel>();
ObjectTypeDB::register_type<Range>();
OS::get_singleton()->yield(); //may take time to init
ObjectTypeDB::register_type<TextureFrame>();
ObjectTypeDB::register_type<Patch9Frame>();
ObjectTypeDB::register_type<TabContainer>();
ObjectTypeDB::register_type<Tabs>();
ObjectTypeDB::register_virtual_type<Separator>();
ObjectTypeDB::register_type<HSeparator>();
ObjectTypeDB::register_type<VSeparator>();
ObjectTypeDB::register_type<TextureButton>();
ObjectTypeDB::register_type<Container>();
ObjectTypeDB::register_virtual_type<BoxContainer>();
ObjectTypeDB::register_type<HBoxContainer>();
ObjectTypeDB::register_type<VBoxContainer>();
ObjectTypeDB::register_type<GridContainer>();
ObjectTypeDB::register_type<CenterContainer>();
ObjectTypeDB::register_type<ScrollContainer>();
ObjectTypeDB::register_type<PanelContainer>();
ObjectTypeDB::register_virtual_type<SplitContainer>();
ObjectTypeDB::register_type<HSplitContainer>();
ObjectTypeDB::register_type<VSplitContainer>();
ObjectTypeDB::register_type<GraphNode>();
ObjectTypeDB::register_type<GraphEdit>();
OS::get_singleton()->yield(); //may take time to init
ObjectTypeDB::register_virtual_type<ButtonArray>();
ObjectTypeDB::register_type<HButtonArray>();
ObjectTypeDB::register_type<VButtonArray>();
ObjectTypeDB::register_type<TextureProgress>();
ObjectTypeDB::register_type<ItemList>();
#ifndef ADVANCED_GUI_DISABLED
ObjectTypeDB::register_type<FileDialog>();
ObjectTypeDB::register_type<LineEdit>();
ObjectTypeDB::register_type<PopupMenu>();
ObjectTypeDB::register_type<Tree>();
ObjectTypeDB::register_type<TextEdit>();
ObjectTypeDB::register_virtual_type<TreeItem>();
ObjectTypeDB::register_type<OptionButton>();
ObjectTypeDB::register_type<SpinBox>();
ObjectTypeDB::register_type<ReferenceFrame>();
ObjectTypeDB::register_type<ColorPicker>();
ObjectTypeDB::register_type<ColorPickerButton>();
ObjectTypeDB::register_type<RichTextLabel>();
ObjectTypeDB::register_type<PopupDialog>();
ObjectTypeDB::register_type<WindowDialog>();
ObjectTypeDB::register_type<AcceptDialog>();
ObjectTypeDB::register_type<ConfirmationDialog>();
ObjectTypeDB::register_type<VideoPlayer>();
ObjectTypeDB::register_type<MarginContainer>();
OS::get_singleton()->yield(); //may take time to init
#endif
/* REGISTER 3D */
ObjectTypeDB::register_type<Spatial>();
ObjectTypeDB::register_type<Skeleton>();
ObjectTypeDB::register_type<AnimationPlayer>();
ObjectTypeDB::register_type<Tween>();
OS::get_singleton()->yield(); //may take time to init
#ifndef _3D_DISABLED
ObjectTypeDB::register_type<BoneAttachment>();
ObjectTypeDB::register_virtual_type<VisualInstance>();
ObjectTypeDB::register_type<Camera>();
ObjectTypeDB::register_type<InterpolatedCamera>();
ObjectTypeDB::register_type<TestCube>();
ObjectTypeDB::register_type<MeshInstance>();
ObjectTypeDB::register_type<ImmediateGeometry>();
ObjectTypeDB::register_type<Sprite3D>();
ObjectTypeDB::register_type<AnimatedSprite3D>();
ObjectTypeDB::register_virtual_type<Light>();
ObjectTypeDB::register_type<DirectionalLight>();
ObjectTypeDB::register_type<OmniLight>();
ObjectTypeDB::register_type<SpotLight>();
ObjectTypeDB::register_type<AnimationTreePlayer>();
ObjectTypeDB::register_type<Portal>();
ObjectTypeDB::register_type<Particles>();
ObjectTypeDB::register_type<Position3D>();
ObjectTypeDB::register_type<Quad>();
ObjectTypeDB::register_type<NavigationMeshInstance>();
ObjectTypeDB::register_type<NavigationMesh>();
ObjectTypeDB::register_type<Navigation>();
OS::get_singleton()->yield(); //may take time to init
ObjectTypeDB::register_virtual_type<CollisionObject>();
ObjectTypeDB::register_type<StaticBody>();
ObjectTypeDB::register_type<RigidBody>();
ObjectTypeDB::register_type<KinematicBody>();
ObjectTypeDB::register_type<VehicleBody>();
ObjectTypeDB::register_type<VehicleWheel>();
ObjectTypeDB::register_type<Area>();
ObjectTypeDB::register_type<ProximityGroup>();
ObjectTypeDB::register_type<CollisionShape>();
ObjectTypeDB::register_type<CollisionPolygon>();
ObjectTypeDB::register_type<RayCast>();
ObjectTypeDB::register_type<MultiMeshInstance>();
ObjectTypeDB::register_type<Room>();
ObjectTypeDB::register_type<Curve3D>();
ObjectTypeDB::register_type<Path>();
ObjectTypeDB::register_type<PathFollow>();
ObjectTypeDB::register_type<VisibilityNotifier>();
ObjectTypeDB::register_type<VisibilityEnabler>();
ObjectTypeDB::register_type<BakedLightInstance>();
ObjectTypeDB::register_type<BakedLightSampler>();
ObjectTypeDB::register_type<WorldEnvironment>();
ObjectTypeDB::register_virtual_type<Joint>();
ObjectTypeDB::register_type<PinJoint>();
ObjectTypeDB::register_type<HingeJoint>();
ObjectTypeDB::register_type<SliderJoint>();
ObjectTypeDB::register_type<ConeTwistJoint>();
ObjectTypeDB::register_type<Generic6DOFJoint>();
//scenariofx
OS::get_singleton()->yield(); //may take time to init
ObjectTypeDB::register_type<SpatialSamplePlayer>();
ObjectTypeDB::register_type<SpatialStreamPlayer>();
ObjectTypeDB::register_type<SoundRoomParams>();
#endif
ObjectTypeDB::register_type<MeshLibrary>();
AcceptDialog::set_swap_ok_cancel( GLOBAL_DEF("display/swap_ok_cancel",bool(OS::get_singleton()->get_swap_ok_cancel())) );
ObjectTypeDB::register_type<SamplePlayer>();
// ObjectTypeDB::register_type<StaticBody>();
// ObjectTypeDB::register_type<RigidBody>();
// ObjectTypeDB::register_type<CharacterBody>();
// ObjectTypeDB::register_type<BodyVolumeSphere>();
//ObjectTypeDB::register_type<BodyVolumeBox>();
//ObjectTypeDB::register_type<BodyVolumeCylinder>();
//ObjectTypeDB::register_type<BodyVolumeCapsule>();
//ObjectTypeDB::register_type<PhysicsJointPin>();
ObjectTypeDB::register_type<StreamPlayer>();
ObjectTypeDB::register_type<EventPlayer>();
/* disable types by default, only editors should enable them */
//ObjectTypeDB::set_type_enabled("BodyVolumeSphere",false);
//ObjectTypeDB::set_type_enabled("BodyVolumeBox",false);
//ObjectTypeDB::set_type_enabled("BodyVolumeCapsule",false);
//ObjectTypeDB::set_type_enabled("BodyVolumeCylinder",false);
//ObjectTypeDB::set_type_enabled("BodyVolumeConvexPolygon",false);
ObjectTypeDB::register_type<CanvasItemMaterial>();
ObjectTypeDB::register_virtual_type<CanvasItem>();
ObjectTypeDB::register_type<Node2D>();
ObjectTypeDB::register_type<Particles2D>();
ObjectTypeDB::register_type<ParticleAttractor2D>();
ObjectTypeDB::register_type<Sprite>();
ObjectTypeDB::register_type<ViewportSprite>();
ObjectTypeDB::register_type<SpriteFrames>();
ObjectTypeDB::register_type<AnimatedSprite>();
ObjectTypeDB::register_type<Position2D>();
ObjectTypeDB::register_virtual_type<CollisionObject2D>();
ObjectTypeDB::register_virtual_type<PhysicsBody2D>();
ObjectTypeDB::register_type<StaticBody2D>();
ObjectTypeDB::register_type<RigidBody2D>();
ObjectTypeDB::register_type<KinematicBody2D>();
ObjectTypeDB::register_type<Area2D>();
ObjectTypeDB::register_type<CollisionShape2D>();
ObjectTypeDB::register_type<CollisionPolygon2D>();
ObjectTypeDB::register_type<RayCast2D>();
ObjectTypeDB::register_type<VisibilityNotifier2D>();
ObjectTypeDB::register_type<VisibilityEnabler2D>();
ObjectTypeDB::register_type<Polygon2D>();
ObjectTypeDB::register_type<Light2D>();
ObjectTypeDB::register_type<LightOccluder2D>();
ObjectTypeDB::register_type<OccluderPolygon2D>();
ObjectTypeDB::register_type<YSort>();
ObjectTypeDB::register_type<BackBufferCopy>();
if (bool(GLOBAL_DEF("physics/remove_collision_helpers_at_runtime",false))) {
ObjectTypeDB::set_type_enabled("CollisionShape2D",false);
ObjectTypeDB::set_type_enabled("CollisionPolygon2D",false);
ObjectTypeDB::set_type_enabled("CollisionShape",false);
ObjectTypeDB::set_type_enabled("CollisionPolygon",false);
}
OS::get_singleton()->yield(); //may take time to init
ObjectTypeDB::register_type<Camera2D>();
ObjectTypeDB::register_virtual_type<Joint2D>();
ObjectTypeDB::register_type<PinJoint2D>();
ObjectTypeDB::register_type<GrooveJoint2D>();
ObjectTypeDB::register_type<DampedSpringJoint2D>();
ObjectTypeDB::register_type<TileSet>();
ObjectTypeDB::register_type<TileMap>();
ObjectTypeDB::register_type<ParallaxBackground>();
ObjectTypeDB::register_type<ParallaxLayer>();
ObjectTypeDB::register_virtual_type<SoundPlayer2D>();
ObjectTypeDB::register_type<SamplePlayer2D>();
ObjectTypeDB::register_type<TouchScreenButton>();
ObjectTypeDB::register_type<RemoteTransform2D>();
OS::get_singleton()->yield(); //may take time to init
/* REGISTER RESOURCES */
ObjectTypeDB::register_virtual_type<Shader>();
ObjectTypeDB::register_virtual_type<ShaderGraph>();
ObjectTypeDB::register_type<CanvasItemShader>();
ObjectTypeDB::register_type<CanvasItemShaderGraph>();
#ifndef _3D_DISABLED
ObjectTypeDB::register_type<Mesh>();
ObjectTypeDB::register_virtual_type<Material>();
ObjectTypeDB::register_type<FixedMaterial>();
ObjectTypeDB::register_type<ShaderMaterial>();
ObjectTypeDB::register_type<RoomBounds>();
ObjectTypeDB::register_type<MaterialShaderGraph>();
ObjectTypeDB::register_type<MaterialShader>();
ObjectTypeDB::add_compatibility_type("Shader","MaterialShader");
ObjectTypeDB::add_compatibility_type("ParticleSystemMaterial","FixedMaterial");
ObjectTypeDB::add_compatibility_type("UnshadedMaterial","FixedMaterial");
ObjectTypeDB::register_type<MultiMesh>();
ObjectTypeDB::register_type<MeshLibrary>();
OS::get_singleton()->yield(); //may take time to init
ObjectTypeDB::register_type<RayShape>();
ObjectTypeDB::register_type<SphereShape>();
ObjectTypeDB::register_type<BoxShape>();
ObjectTypeDB::register_type<CapsuleShape>();
ObjectTypeDB::register_type<PlaneShape>();
ObjectTypeDB::register_type<ConvexPolygonShape>();
ObjectTypeDB::register_type<ConcavePolygonShape>();
ObjectTypeDB::register_type<SurfaceTool>();
ObjectTypeDB::register_type<MeshDataTool>();
ObjectTypeDB::register_type<BakedLight>();
OS::get_singleton()->yield(); //may take time to init
#endif
ObjectTypeDB::register_type<World>();
ObjectTypeDB::register_type<Environment>();
ObjectTypeDB::register_type<World2D>();
ObjectTypeDB::register_virtual_type<Texture>();
ObjectTypeDB::register_type<ImageTexture>();
ObjectTypeDB::register_type<AtlasTexture>();
ObjectTypeDB::register_type<LargeTexture>();
ObjectTypeDB::register_type<CubeMap>();
ObjectTypeDB::register_type<Animation>();
ObjectTypeDB::register_virtual_type<Font>();
ObjectTypeDB::register_type<BitmapFont>();
ObjectTypeDB::register_type<StyleBoxEmpty>();
ObjectTypeDB::register_type<StyleBoxTexture>();
ObjectTypeDB::register_type<StyleBoxFlat>();
ObjectTypeDB::register_type<StyleBoxImageMask>();
ObjectTypeDB::register_type<Theme>();
ObjectTypeDB::add_compatibility_type("Font","BitmapFont");
ObjectTypeDB::register_type<PolygonPathFinder>();
ObjectTypeDB::register_type<BitMap>();
ObjectTypeDB::register_type<ColorRamp>();
OS::get_singleton()->yield(); //may take time to init
//ObjectTypeDB::register_type<Volume>();
ObjectTypeDB::register_type<Sample>();
ObjectTypeDB::register_type<SampleLibrary>();
ObjectTypeDB::register_virtual_type<AudioStream>();
ObjectTypeDB::register_virtual_type<AudioStreamPlayback>();
// ObjectTypeDB::register_type<AudioStreamGibberish>();
ObjectTypeDB::register_virtual_type<VideoStream>();
OS::get_singleton()->yield(); //may take time to init
ObjectTypeDB::register_virtual_type<Shape2D>();
ObjectTypeDB::register_type<LineShape2D>();
ObjectTypeDB::register_type<SegmentShape2D>();
ObjectTypeDB::register_type<RayShape2D>();
ObjectTypeDB::register_type<CircleShape2D>();
ObjectTypeDB::register_type<RectangleShape2D>();
ObjectTypeDB::register_type<CapsuleShape2D>();
ObjectTypeDB::register_type<ConvexPolygonShape2D>();
ObjectTypeDB::register_type<ConcavePolygonShape2D>();
ObjectTypeDB::register_type<Curve2D>();
ObjectTypeDB::register_type<Path2D>();
ObjectTypeDB::register_type<PathFollow2D>();
ObjectTypeDB::register_type<Navigation2D>();
ObjectTypeDB::register_type<NavigationPolygon>();
ObjectTypeDB::register_type<NavigationPolygonInstance>();
OS::get_singleton()->yield(); //may take time to init
ObjectTypeDB::register_virtual_type<SceneState>();
ObjectTypeDB::register_type<PackedScene>();
ObjectTypeDB::register_type<SceneTree>();
OS::get_singleton()->yield(); //may take time to init
resource_saver_text = memnew( ResourceFormatSaverText );
ResourceSaver::add_resource_format_saver(resource_saver_text);
resource_loader_text = memnew( ResourceFormatLoaderText );
ResourceLoader::add_resource_format_loader(resource_loader_text);
}
void OSIPhone::initialize(const VideoMode& p_desired,int p_video_driver,int p_audio_driver) {
supported_orientations = 0;
supported_orientations |= ((GLOBAL_DEF("video_mode/allow_horizontal", true)?1:0) << LandscapeLeft);
supported_orientations |= ((GLOBAL_DEF("video_mode/allow_horizontal_flipped", false)?1:0) << LandscapeRight);
supported_orientations |= ((GLOBAL_DEF("video_mode/allow_vertical", false)?1:0) << PortraitDown);
supported_orientations |= ((GLOBAL_DEF("video_mode/allow_vertical_flipped", false)?1:0) << PortraitUp);
#ifdef GLES1_OVERRIDE
rasterizer = memnew( RasterizerGLES1 );
#else
rasterizer_gles22 = memnew( RasterizerGLES2(false, false, false) );
rasterizer = rasterizer_gles22;
rasterizer_gles22->set_base_framebuffer(gl_view_base_fb);
#endif
visual_server = memnew( VisualServerRaster(rasterizer) );
if (get_render_thread_mode() != RENDER_THREAD_UNSAFE) {
visual_server = memnew(VisualServerWrapMT(visual_server, false));
};
visual_server->init();
visual_server->init();
visual_server->cursor_set_visible(false, 0);
audio_driver = memnew(AudioDriverIphone);
audio_driver->set_singleton();
audio_driver->init();
sample_manager = memnew( SampleManagerMallocSW );
audio_server = memnew( AudioServerSW(sample_manager) );
audio_server->init();
spatial_sound_server = memnew( SpatialSoundServerSW );
spatial_sound_server->init();
spatial_sound_2d_server = memnew( SpatialSound2DServerSW );
spatial_sound_2d_server->init();
//
physics_server = memnew( PhysicsServerSW );
physics_server->init();
physics_2d_server = memnew( Physics2DServerSW );
physics_2d_server->init();
input = memnew( InputDefault );
/*
#ifdef IOS_SCORELOOP_ENABLED
scoreloop = memnew(ScoreloopIOS);
Globals::get_singleton()->add_singleton(Globals::Singleton("Scoreloop", scoreloop));
scoreloop->connect();
#endif
*/
#ifdef GAME_CENTER_ENABLED
game_center = memnew(GameCenter);
Globals::get_singleton()->add_singleton(Globals::Singleton("GameCenter", game_center));
game_center->connect();
#endif
#ifdef STOREKIT_ENABLED
store_kit = memnew(InAppStore);
Globals::get_singleton()->add_singleton(Globals::Singleton("InAppStore", store_kit));
#endif
};
EditorSceneImportDialog::EditorSceneImportDialog(EditorNode *p_editor, EditorSceneImportPlugin *p_plugin) {
editor=p_editor;
plugin=p_plugin;
set_title("Import 3D Scene");
HBoxContainer *import_hb = memnew( HBoxContainer );
add_child(import_hb);
set_child_rect(import_hb);
VBoxContainer *vbc = memnew( VBoxContainer );
import_hb->add_child(vbc);
vbc->set_h_size_flags(SIZE_EXPAND_FILL);
HBoxContainer *hbc = memnew( HBoxContainer );
vbc->add_margin_child("Source Scene:",hbc);
import_path = memnew( LineEdit );
import_path->set_h_size_flags(SIZE_EXPAND_FILL);
hbc->add_child(import_path);
Button * import_choose = memnew( Button );
import_choose->set_text(" .. ");
hbc->add_child(import_choose);
import_choose->connect("pressed", this,"_browse");
hbc = memnew( HBoxContainer );
vbc->add_margin_child("Target Scene:",hbc);
save_path = memnew( LineEdit );
save_path->set_h_size_flags(SIZE_EXPAND_FILL);
hbc->add_child(save_path);
Button * save_choose = memnew( Button );
save_choose->set_text(" .. ");
hbc->add_child(save_choose);
save_choose->connect("pressed", this,"_browse_target");
texture_action = memnew( OptionButton );
texture_action->add_item("Same as Target Scene");
texture_action->add_item("Shared");
texture_action->select(0);
vbc->add_margin_child("Target Texture Folder:",texture_action);
import_options = memnew( Tree );
vbc->set_v_size_flags(SIZE_EXPAND_FILL);
vbc->add_margin_child("Options:",import_options,true);
file_select = memnew(FileDialog);
file_select->set_access(FileDialog::ACCESS_FILESYSTEM);
add_child(file_select);
file_select->set_mode(FileDialog::MODE_OPEN_FILE);
file_select->connect("file_selected", this,"_choose_file");
save_select = memnew(EditorDirDialog);
add_child(save_select);
//save_select->set_mode(FileDialog::MODE_SAVE_FILE);
save_select->connect("dir_selected", this,"_choose_save_file");
get_ok()->connect("pressed", this,"_import");
get_ok()->set_text("Import");
TreeItem *root = import_options->create_item(NULL);
import_options->set_hide_root(true);
TreeItem *importopts = import_options->create_item(root);
importopts->set_text(0,"Import:");
const FlagInfo* fn=scene_flag_names;
while(fn->text) {
TreeItem *opt = import_options->create_item(importopts);
opt->set_cell_mode(0,TreeItem::CELL_MODE_CHECK);
opt->set_checked(0,true);
opt->set_editable(0,true);
opt->set_text(0,fn->text);
opt->set_metadata(0,fn->value);
scene_flags.push_back(opt);
fn++;
}
hbc = memnew( HBoxContainer );
vbc->add_margin_child("Post-Process Script:",hbc);
script_path = memnew( LineEdit );
script_path->set_h_size_flags(SIZE_EXPAND_FILL);
hbc->add_child(script_path);
Button * script_choose = memnew( Button );
script_choose->set_text(" .. ");
hbc->add_child(script_choose);
script_choose->connect("pressed", this,"_browse_script");
script_select = memnew(FileDialog);
add_child(script_select);
for(int i=0;i<ScriptServer::get_language_count();i++) {
ScriptLanguage *sl=ScriptServer::get_language(i);
String ext = sl->get_extension();
if (ext=="")
continue;
script_select->add_filter("*."+ext+" ; "+sl->get_name());
}
script_select->set_mode(FileDialog::MODE_OPEN_FILE);
script_select->connect("file_selected", this,"_choose_script");
error_dialog = memnew ( ConfirmationDialog );
add_child(error_dialog);
error_dialog->get_ok()->set_text("Accept");
// error_dialog->get_cancel()->hide();
set_hide_on_ok(false);
GLOBAL_DEF("import/shared_textures","res://");
Globals::get_singleton()->set_custom_property_info("import/shared_textures",PropertyInfo(Variant::STRING,"import/shared_textures",PROPERTY_HINT_DIR));
import_hb->add_constant_override("separation",30);
VBoxContainer *ovb = memnew( VBoxContainer);
ovb->set_h_size_flags(SIZE_EXPAND_FILL);
import_hb->add_child(ovb);
texture_options = memnew( EditorImportTextureOptions );
ovb->add_child(texture_options);
texture_options->set_v_size_flags(SIZE_EXPAND_FILL);
//animation_options->set_flags(EditorImport::
texture_options->set_format(EditorTextureImportPlugin::IMAGE_FORMAT_COMPRESS_RAM);
texture_options->set_flags( EditorTextureImportPlugin::IMAGE_FLAG_FIX_BORDER_ALPHA | EditorTextureImportPlugin::IMAGE_FLAG_REPEAT | EditorTextureImportPlugin::IMAGE_FLAG_FILTER );
animation_options = memnew( EditorImportAnimationOptions );
ovb->add_child(animation_options);
animation_options->set_v_size_flags(SIZE_EXPAND_FILL);
animation_options->set_flags(EditorSceneAnimationImportPlugin::ANIMATION_DETECT_LOOP|EditorSceneAnimationImportPlugin::ANIMATION_KEEP_VALUE_TRACKS|EditorSceneAnimationImportPlugin::ANIMATION_OPTIMIZE);
confirm_import = memnew( ConfirmationDialog );
add_child(confirm_import);
VBoxContainer *cvb = memnew( VBoxContainer );
confirm_import->add_child(cvb);
confirm_import->set_child_rect(cvb);
PanelContainer *pc = memnew( PanelContainer );
pc->add_style_override("panel",get_stylebox("normal","TextEdit"));
//ec->add_child(pc);
missing_files = memnew( RichTextLabel );
cvb->add_margin_child("The Following Files are Missing:",pc,true);
pc->add_child(missing_files);
confirm_import->get_ok()->set_text("Import Anyway");
confirm_import->get_cancel()->set_text("Cancel");
confirm_import->connect("popup_hide",this,"_dialog_hid");
confirm_import->connect("confirmed",this,"_import_confirm");
confirm_import->set_hide_on_ok(false);
add_button("Import & Open",!OS::get_singleton()->get_swap_ok_cancel())->connect("pressed",this,"_open_and_import");
confirm_open = memnew( ConfirmationDialog );
add_child(confirm_open);
confirm_open->set_text("Edited scene has not been saved, open imported scene anyway?");
confirm_open->connect("confirmed",this,"_import",varray(true));
wip_import=NULL;
wip_blocked=false;
wip_open=false;
//texture_options->set_format(EditorImport::IMAGE_FORMAT_C);
}
void register_core_settings() {
//since in register core types, globals may not e present
GLOBAL_DEF("network/limits/packet_peer_stream/max_buffer_po2", (16));
}
