void ARVROrigin::_notification(int p_what) { switch (p_what) { case NOTIFICATION_ENTER_TREE: { set_process_internal(true); }; break; case NOTIFICATION_EXIT_TREE: { set_process_internal(false); }; break; case NOTIFICATION_INTERNAL_PROCESS: { // get our ARVRServer ARVRServer *arvr_server = ARVRServer::get_singleton(); ERR_FAIL_NULL(arvr_server); // set our world origin to our node transform arvr_server->set_world_origin(get_global_transform()); // check if we have a primary interface Ref<ARVRInterface> arvr_interface = arvr_server->get_primary_interface(); if (arvr_interface.is_valid() && tracked_camera != NULL) { // get our positioning transform for our headset Transform t = arvr_interface->get_transform_for_eye(ARVRInterface::EYE_MONO, Transform()); // now apply this to our camera tracked_camera->set_transform(t); }; }; break; default: break; }; };
void InterpolatedCamera::set_interpolation_enabled(bool p_enable) { if (enabled == p_enable) return; enabled = p_enable; if (p_enable) { if (is_inside_tree() && Engine::get_singleton()->is_editor_hint()) return; set_process_internal(true); } else set_process_internal(false); }
void ARVRController::_notification(int p_what) { switch (p_what) { case NOTIFICATION_ENTER_TREE: { set_process_internal(true); }; break; case NOTIFICATION_EXIT_TREE: { set_process_internal(false); }; break; case NOTIFICATION_INTERNAL_PROCESS: { // get our ARVRServer ARVRServer *arvr_server = ARVRServer::get_singleton(); ERR_FAIL_NULL(arvr_server); // find the tracker for our controller ARVRPositionalTracker *tracker = arvr_server->find_by_type_and_id(ARVRServer::TRACKER_CONTROLLER, controller_id); if (tracker == NULL) { // this controller is currently turned off is_active = false; button_states = 0; } else { is_active = true; set_transform(tracker->get_transform(true)); int joy_id = tracker->get_joy_id(); if (joy_id >= 0) { int mask = 1; // check button states for (int i = 0; i < 16; i++) { bool was_pressed = (button_states & mask) == mask; bool is_pressed = Input::get_singleton()->is_joy_button_pressed(joy_id, i); if (!was_pressed && is_pressed) { emit_signal("button_pressed", i); button_states += mask; } else if (was_pressed && !is_pressed) { emit_signal("button_release", i); button_states -= mask; }; mask = mask << 1; }; } else { button_states = 0; }; }; }; break; default: break; }; };
void AudioStreamPlayer::_notification(int p_what) { if (p_what == NOTIFICATION_ENTER_TREE) { AudioServer::get_singleton()->add_callback(_mix_audios, this); if (autoplay && !Engine::get_singleton()->is_editor_hint()) { play(); } } if (p_what == NOTIFICATION_INTERNAL_PROCESS) { if (!active || (setseek < 0 && !stream_playback->is_playing())) { active = false; set_process_internal(false); emit_signal("finished"); } } if (p_what == NOTIFICATION_EXIT_TREE) { AudioServer::get_singleton()->remove_callback(_mix_audios, this); } if (p_what == NOTIFICATION_PAUSED) { if (!can_process()) { // Node can't process so we start fading out to silence set_stream_paused(true); } } if (p_what == NOTIFICATION_UNPAUSED) { set_stream_paused(false); } }
void AudioStreamPlayer::stop() { if (stream_playback.is_valid()) { active = false; set_process_internal(false); } }
void Timer::_set_process(bool p_process, bool p_force) { switch (timer_process_mode) { case TIMER_PROCESS_PHYSICS: set_physics_process_internal(p_process && !paused); break; case TIMER_PROCESS_IDLE: set_process_internal(p_process && !paused); break; } processing = p_process; }
void AnimationTree::set_active(bool p_active) { if (active == p_active) return; active = p_active; started = active; if (process_mode == ANIMATION_PROCESS_IDLE) { set_process_internal(active); } else { set_physics_process_internal(active); } if (!active && is_inside_tree()) { for (Set<TrackCache *>::Element *E = playing_caches.front(); E; E = E->next()) { if (ObjectDB::get_instance(E->get()->object_id)) { E->get()->object->call("stop"); } } playing_caches.clear(); } }
void Timer::_set_process(bool p_process, bool p_force) { switch (timer_process_mode) { case TIMER_PROCESS_FIXED: set_fixed_process_internal(p_process && !paused); break; case TIMER_PROCESS_IDLE: set_process_internal(p_process && !paused); break; } processing = p_process; }
void HTTPRequest::cancel_request() { if (!requesting) return; if (!use_threads) { set_process_internal(false); } else { thread_request_quit = true; Thread::wait_to_finish(thread); memdelete(thread); thread = NULL; } if (file) { memdelete(file); file = NULL; } client->close(); body.resize(0); //downloaded=0; got_response = false; response_code = -1; //body_len=-1; request_sent = false; requesting = false; }
Error HTTPRequest::request(const String &p_url, const Vector<String> &p_custom_headers, bool p_ssl_validate_domain, HTTPClient::Method p_method, const String &p_request_data) { ERR_FAIL_COND_V(!is_inside_tree(), ERR_UNCONFIGURED); if (requesting) { ERR_EXPLAIN("HTTPRequest is processing a request. Wait for completion or cancel it before attempting a new one."); ERR_FAIL_V(ERR_BUSY); } method = p_method; Error err = _parse_url(p_url); if (err) return err; validate_ssl = p_ssl_validate_domain; bool has_user_agent = false; bool has_accept = false; headers = p_custom_headers; request_data = p_request_data; for (int i = 0; i < headers.size(); i++) { if (headers[i].findn("user-agent:") == 0) has_user_agent = true; if (headers[i].findn("Accept:") == 0) has_accept = true; } if (!has_user_agent) { headers.push_back("User-Agent: GodotEngine/" + String(VERSION_MKSTRING) + " (" + OS::get_singleton()->get_name() + ")"); } if (!has_accept) { headers.push_back("Accept: */*"); } requesting = true; if (use_threads) { thread_done = false; thread_request_quit = false; client->set_blocking_mode(true); thread = Thread::create(_thread_func, this); } else { client->set_blocking_mode(false); err = _request(); if (err != OK) { call_deferred("_request_done", RESULT_CANT_CONNECT, 0, PoolStringArray(), PoolByteArray()); return ERR_CANT_CONNECT; } set_process_internal(true); } return OK; }
void SpringArm::_notification(int p_what) { switch (p_what) { case NOTIFICATION_ENTER_TREE: if (!Engine::get_singleton()->is_editor_hint()) { set_process_internal(true); } break; case NOTIFICATION_EXIT_TREE: if (!Engine::get_singleton()->is_editor_hint()) { set_process_internal(false); } break; case NOTIFICATION_INTERNAL_PROCESS: process_spring(); break; } }
void AnimatedSprite::_set_playing(bool p_playing) { if (playing == p_playing) return; playing = p_playing; _reset_timeout(); set_process_internal(playing); }
void AudioStreamPlayer::play(float p_from_pos) { if (stream_playback.is_valid()) { //mix_volume_db = volume_db; do not reset volume ramp here, can cause clicks setseek = p_from_pos; active = true; set_process_internal(true); } }
void AudioStreamPlayer::play(float p_from_pos) { if (stream_playback.is_valid()) { mix_volume_db = volume_db; //reset volume ramp setseek = p_from_pos; active = true; set_process_internal(true); } }
void ARVRAnchor::_notification(int p_what) { switch (p_what) { case NOTIFICATION_ENTER_TREE: { set_process_internal(true); }; break; case NOTIFICATION_EXIT_TREE: { set_process_internal(false); }; break; case NOTIFICATION_INTERNAL_PROCESS: { // get our ARVRServer ARVRServer *arvr_server = ARVRServer::get_singleton(); ERR_FAIL_NULL(arvr_server); // find the tracker for our anchor ARVRPositionalTracker *tracker = arvr_server->find_by_type_and_id(ARVRServer::TRACKER_ANCHOR, anchor_id); if (tracker == NULL) { // this anchor is currently not available is_active = false; } else { is_active = true; Transform transform; // we'll need our world_scale real_t world_scale = arvr_server->get_world_scale(); // get our info from our tracker transform.basis = tracker->get_orientation(); transform.origin = tracker->get_position(); // <-- already adjusted to world scale // our basis is scaled to the size of the plane the anchor is tracking // extract the size from our basis and reset the scale size = transform.basis.get_scale() * world_scale; transform.basis.orthonormalize(); // apply our reference frame and set our transform set_transform(arvr_server->get_reference_frame() * transform); }; }; break; default: break; }; };
void Timer::set_timer_process_mode(TimerProcessMode p_mode) { if (timer_process_mode == p_mode) return; switch (timer_process_mode) { case TIMER_PROCESS_PHYSICS: if (is_physics_processing_internal()) { set_physics_process_internal(false); set_process_internal(true); } break; case TIMER_PROCESS_IDLE: if (is_processing_internal()) { set_process_internal(false); set_physics_process_internal(true); } break; } timer_process_mode = p_mode; }
void AnimationPlayer::_set_process(bool p_process, bool p_force) { if (processing == p_process && !p_force) return; switch (animation_process_mode) { case ANIMATION_PROCESS_PHYSICS: set_physics_process_internal(p_process && active); break; case ANIMATION_PROCESS_IDLE: set_process_internal(p_process && active); break; } processing = p_process; }
void InterpolatedCamera::_notification(int p_what) { switch (p_what) { case NOTIFICATION_ENTER_TREE: { if (Engine::get_singleton()->is_editor_hint() && enabled) set_process_internal(false); } break; case NOTIFICATION_INTERNAL_PROCESS: { if (!enabled) break; if (has_node(target)) { Spatial *node = Object::cast_to<Spatial>(get_node(target)); if (!node) break; float delta = speed * get_process_delta_time(); Transform target_xform = node->get_global_transform(); Transform local_transform = get_global_transform(); local_transform = local_transform.interpolate_with(target_xform, delta); set_global_transform(local_transform); Camera *cam = Object::cast_to<Camera>(node); if (cam) { if (cam->get_projection() == get_projection()) { float new_near = Math::lerp(get_znear(), cam->get_znear(), delta); float new_far = Math::lerp(get_zfar(), cam->get_zfar(), delta); if (cam->get_projection() == PROJECTION_ORTHOGONAL) { float size = Math::lerp(get_size(), cam->get_size(), delta); set_orthogonal(size, new_near, new_far); } else { float fov = Math::lerp(get_fov(), cam->get_fov(), delta); set_perspective(fov, new_near, new_far); } } } } } break; } }
void CPUParticles::set_emitting(bool p_emitting) { emitting = p_emitting; if (!is_processing_internal()) { set_process_internal(true); if (is_inside_tree()) { #ifndef NO_THREADS update_mutex->lock(); #endif VS::get_singleton()->connect("frame_pre_draw", this, "_update_render_thread"); VS::get_singleton()->instance_geometry_set_flag(get_instance(), VS::INSTANCE_FLAG_REDRAW_FRAME_IF_VISIBLE, true); #ifndef NO_THREADS update_mutex->unlock(); #endif } } }
void CPUParticles2D::set_emitting(bool p_emitting) { emitting = p_emitting; if (!is_processing_internal()) { set_process_internal(true); if (is_inside_tree()) { #ifndef NO_THREADS update_mutex->lock(); #endif VS::get_singleton()->connect("frame_pre_draw", this, "_update_render_thread"); VS::get_singleton()->canvas_item_set_update_when_visible(get_canvas_item(), true); #ifndef NO_THREADS update_mutex->unlock(); #endif } } }
void HTTPRequest::_notification(int p_what) { if (p_what == NOTIFICATION_INTERNAL_PROCESS) { if (use_threads) return; bool done = _update_connection(); if (done) { set_process_internal(false); //cancel_request(); called from _request done now } } if (p_what == NOTIFICATION_EXIT_TREE) { if (requesting) { cancel_request(); } } }
Error HTTPRequest::request(const String &p_url, const Vector<String> &p_custom_headers, bool p_ssl_validate_domain, HTTPClient::Method p_method, const String &p_request_data) { ERR_FAIL_COND_V(!is_inside_tree(), ERR_UNCONFIGURED); if (requesting) { ERR_EXPLAIN("HTTPRequest is processing a request. Wait for completion or cancel it before attempting a new one."); ERR_FAIL_V(ERR_BUSY); } method = p_method; Error err = _parse_url(p_url); if (err) return err; validate_ssl = p_ssl_validate_domain; headers = p_custom_headers; request_data = p_request_data; requesting = true; if (use_threads) { thread_done = false; thread_request_quit = false; client->set_blocking_mode(true); thread = Thread::create(_thread_func, this); } else { client->set_blocking_mode(false); err = _request(); if (err != OK) { call_deferred("_request_done", RESULT_CANT_CONNECT, 0, PoolStringArray(), PoolByteArray()); return ERR_CANT_CONNECT; } set_process_internal(true); } return OK; }
void AudioStreamPlayer::_notification(int p_what) { if (p_what == NOTIFICATION_ENTER_TREE) { AudioServer::get_singleton()->add_callback(_mix_audios, this); if (autoplay && !Engine::get_singleton()->is_editor_hint()) { play(); } } if (p_what == NOTIFICATION_INTERNAL_PROCESS) { if (!active || (setseek < 0 && !stream_playback->is_playing())) { active = false; emit_signal("finished"); set_process_internal(false); } } if (p_what == NOTIFICATION_EXIT_TREE) { AudioServer::get_singleton()->remove_callback(_mix_audios, this); } }