C++ set_process函数代码示例

void BakedLightEditor::_bake_pressed() {

	ERR_FAIL_COND(!node);
	if (node->get_baked_light().is_null()) {
		err_dialog->set_text("BakedLightInstance does not contain a BakedLight resource.");
		err_dialog->popup_centered(Size2(350,70));
		button_bake->set_pressed(false);
		return;
	}

	if (baker->is_baking()) {

		baker->set_pause(!button_bake->is_pressed());
		if (baker->is_paused()) {

			set_process(false);
			bake_info->set_text("");
		} else {

			update_timeout=0;
			set_process(true);
		}

	} else {
		baker->bake(node->get_baked_light(),node);
		update_timeout=0;
		set_process(true);
	}

}

void CollisionPolygonEditor::edit(Node *p_collision_polygon) {



	if (p_collision_polygon) {

		node=p_collision_polygon->cast_to<CollisionPolygon>();
		wip.clear();
		wip_active=false;
		edited_point=-1;
		p_collision_polygon->add_child(imgeom);
		_polygon_draw();
		set_process(true);
		prev_depth=-1;

	} else {
		node=NULL;

		if (imgeom->get_parent())
			imgeom->get_parent()->remove_child(imgeom);

		set_process(false);
	}

}

void Polygon3DEditor::edit(Node *p_collision_polygon) {

	if (p_collision_polygon) {

		node = Object::cast_to<Spatial>(p_collision_polygon);
		//Enable the pencil tool if the polygon is empty
		if (Vector<Vector2>(node->call("get_polygon")).size() == 0) {
			_menu_option(MODE_CREATE);
		}
		wip.clear();
		wip_active = false;
		edited_point = -1;
		p_collision_polygon->add_child(imgeom);
		_polygon_draw();
		set_process(true);
		prev_depth = -1;

	} else {
		node = NULL;

		if (imgeom->get_parent())
			imgeom->get_parent()->remove_child(imgeom);

		set_process(false);
	}
}

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(true);
	} else
		set_process(false);
}

void ExportTemplateManager::_begin_template_download(const String &p_url) {

	for (int i = 0; i < template_list->get_child_count(); i++) {
		BaseButton *b = Object::cast_to<BaseButton>(template_list->get_child(0));
		if (b) {
			b->set_disabled(true);
		}
	}

	download_data.clear();

	Error err = download_templates->request(p_url);
	if (err != OK) {
		EditorNode::get_singleton()->show_warning(TTR("Error requesting url: ") + p_url);
		return;
	}

	set_process(true);

	template_list_state->show();
	template_download_progress->set_max(100);
	template_download_progress->set_value(0);
	template_download_progress->show();
	template_list_state->set_text(TTR("Connecting to Mirror.."));
}

void UI_List::SetSpaceY(int v) {
	if (spacey_ != v) {
		spacey_ = v;
		layout_ = true;
		set_process(true);
	}
}

void UI_List::_notification(int p_what) {
	if (setattribute_) {
		content_->set_size(get_size());
		unsigned count = box_->get_child_count();
		UI_Box* node = NULL;
		for (unsigned i = 0; i < count; i++) {
			node = Object::cast_to<UI_Box>(box_->get_child(i));
			if (node) {
				node->set_visible(false);
			}
		}
		int len = data_.size();
		for (unsigned i = 0; i < len; i++) {
			if (box_->get_child_count() <= i) {
				node = memnew(UI_Box);
				node->SetXml(render_, NULL);
				node->set_name("ui_list_item_" + itos(i));
				box_->add_child(node);
			}
			else {
				node = Object::cast_to<UI_Button>(box_->get_child(i));
			}
			node->set_visible(true);
			node->SetDataSource(data_[i]);
		}
		setattribute_ = false;
		return;
	}
	if (layout_) {
		int count = box_->get_child_count();
		int rx = 0;
		int ry = 0;
		real_t x = 0;
		real_t y = 0;
		UI_Box* node = NULL;
		Size2 size;
		Size2 max;
		for (unsigned i = 0; i < count; i++) {
			node = Object::cast_to<UI_Box>(box_->get_child(i));
			size = node->get_size();
			rx = i % repeatx_;
			ry = i / repeatx_;
			x = size.width * rx + rx * spacex_;
			y = size.height * ry + ry * spacey_;
			node->set_position(Point2(x, y));
			max.width = x + size.width;
			max.height = y + size.height;
		}
		max.width -= spacex_;
		max.height -= spacey_;
		node_size.width = size.width + spacex_;
		node_size.height = size.height + spacey_;
		size = get_size();
		if (size.width > max.width)max.width = size.width;
		if (size.height > max.height)max.height = size.height;
		box_->set_size(max);
		layout_ = false;
		set_process(false);
	}
}

void EditorFileSystem::scan_sources() {

	if (scanning || scanning_sources|| thread)
		return;

	sources_changed.clear();
	scanning_sources=true;
	scanning_sources_done=false;

	abort_scan=false;

	if (!use_threads) {
		if (filesystem)
			_scan_sources(filesystem,NULL);
		scanning_sources=false;
		scanning_sources_done=true;
		emit_signal("sources_changed",sources_changed.size()>0);
	} else {

		ERR_FAIL_COND(thread_sources);
		set_process(true);
		Thread::Settings s;
		ss_amount=0;
		s.priority=Thread::PRIORITY_LOW;
		thread_sources = Thread::create(_thread_func_sources,this,s);
		//tree->hide();
		//print_line("SCAN BEGIN!");
		//progress->show();
	}



}

void SampleLibraryEditor::_notification(int p_what) {

    if (p_what==NOTIFICATION_PROCESS) {
        if (is_playing && !player->is_active()) {
            TreeItem *tl=last_sample_playing->cast_to<TreeItem>();
            tl->set_button(0,0,get_icon("Play","EditorIcons"));
            is_playing = false;
            set_process(false);
        }
    }

    if (p_what==NOTIFICATION_ENTER_TREE) {
        load->set_icon( get_icon("Folder","EditorIcons") );
        load->set_tooltip("Open Sample File(s)");
    }

    if (p_what==NOTIFICATION_READY) {

//		NodePath("/root")->connect("node_removed", this,"_node_removed",Vector<Variant>(),true);
    }

    if (p_what==NOTIFICATION_DRAW) {

    }
}

void ExportTemplateManager::_begin_template_download(const String &p_url) {

	if (Input::get_singleton()->is_key_pressed(KEY_SHIFT)) {
		OS::get_singleton()->shell_open(p_url);
		return;
	}

	for (int i = 0; i < template_list->get_child_count(); i++) {
		BaseButton *b = Object::cast_to<BaseButton>(template_list->get_child(0));
		if (b) {
			b->set_disabled(true);
		}
	}

	download_data.clear();
	download_templates->set_download_file(EditorSettings::get_singleton()->get_cache_dir().plus_file("tmp_templates.tpz"));
	download_templates->set_use_threads(true);

	Error err = download_templates->request(p_url);
	if (err != OK) {
		EditorNode::get_singleton()->show_warning(TTR("Error requesting url: ") + p_url);
		return;
	}

	set_process(true);

	template_list_state->show();
	template_download_progress->set_max(100);
	template_download_progress->set_value(0);
	template_download_progress->show();
	template_list_state->set_text(TTR("Connecting to Mirror..."));
}

void ScriptEditorDebugger::stop(){


	set_process(false);

	server->stop();

	ppeer->set_stream_peer(Ref<StreamPeer>());

	if (connection.is_valid()) {
		EditorNode::get_log()->add_message("** Debug Process Stopped **");
		connection.unref();
	}

	pending_in_queue=0;
	message.clear();

	if (log_forced_visible) {
		EditorNode::get_log()->hide();
		log_forced_visible=false;
	}

	node_path_cache.clear();
	res_path_cache.clear();
	le_clear->set_disabled(false);
	le_set->set_disabled(true);


	hide();
	emit_signal("show_debugger",false);

}

void BakedLightEditor::_menu_option(int p_option) {


	switch(p_option) {


		case MENU_OPTION_BAKE: {

			ERR_FAIL_COND(!node);
			ERR_FAIL_COND(node->get_baked_light().is_null());
			baker->bake(node->get_baked_light(),node);
			node->get_baked_light()->set_mode(BakedLight::MODE_OCTREE);
			update_timeout=0;
			set_process(true);


		} break;
		case MENU_OPTION_CLEAR: {



		} break;

	}
}

void BakedLightEditor::_end_baking() {

	baker->clear();
	set_process(false);
	button_bake->set_pressed(false);
	bake_info->set_text("");
}

void Timer::_set_process(bool p_process, bool p_force) 
{
	switch (timer_process_mode) {
		case TIMER_PROCESS_FIXED: set_fixed_process(p_process); break;
		case TIMER_PROCESS_IDLE: set_process(p_process); break;
	}
}

void AnimationPlayerEditor::set_state(const Dictionary& p_state) {

	if (p_state.has("visible") && p_state["visible"]) {

		Node *n = EditorNode::get_singleton()->get_edited_scene()->get_node(p_state["player"]);
		if (n && n->cast_to<AnimationPlayer>()) {
			player=n->cast_to<AnimationPlayer>();
			_update_player();
			show();
			set_process(true);
			ensure_visibility();
			EditorNode::get_singleton()->animation_panel_make_visible(true);

			if (p_state.has("animation")) {
				String anim = p_state["animation"];
				_select_anim_by_name(anim);
				if (p_state.has("editing") && p_state["editing"]) {

					edit_anim->set_pressed(true);
					_animation_edit();
				}
			}

		}
	}

}