ImportDock::ImportDock() {
imported = memnew(LineEdit);
imported->set_editable(false);
add_child(imported);
HBoxContainer *hb = memnew(HBoxContainer);
add_margin_child(TTR("Import As:"), hb);
import_as = memnew(OptionButton);
hb->add_child(import_as);
import_as->set_h_size_flags(SIZE_EXPAND_FILL);
preset = memnew(MenuButton);
preset->set_text(TTR("Preset.."));
preset->get_popup()->connect("index_pressed", this, "_preset_selected");
hb->add_child(preset);
import_opts = memnew(PropertyEditor);
add_child(import_opts);
import_opts->set_v_size_flags(SIZE_EXPAND_FILL);
import_opts->hide_top_label();
import_opts->set_hide_script(true);
hb = memnew(HBoxContainer);
add_child(hb);
import = memnew(Button);
import->set_text(TTR("Reimport"));
import->connect("pressed", this, "_reimport");
hb->add_spacer();
hb->add_child(import);
hb->add_spacer();
params = memnew(ImportDockParameters);
import_opts->edit(params);
}
SpriteEditor::SpriteEditor() {
options = memnew(MenuButton);
CanvasItemEditor::get_singleton()->add_control_to_menu_panel(options);
options->set_text(TTR("Sprite"));
options->set_icon(EditorNode::get_singleton()->get_gui_base()->get_icon("Sprite", "EditorIcons"));
options->get_popup()->add_item(TTR("Convert to Mesh2D"), MENU_OPTION_CONVERT_TO_MESH_2D);
options->get_popup()->add_item(TTR("Convert to Polygon2D"), MENU_OPTION_CONVERT_TO_POLYGON_2D);
options->get_popup()->add_item(TTR("Create CollisionPolygon2D Sibling"), MENU_OPTION_CREATE_COLLISION_POLY_2D);
options->get_popup()->add_item(TTR("Create LightOccluder2D Sibling"), MENU_OPTION_CREATE_LIGHT_OCCLUDER_2D);
options->set_switch_on_hover(true);
options->get_popup()->connect("id_pressed", this, "_menu_option");
err_dialog = memnew(AcceptDialog);
add_child(err_dialog);
debug_uv_dialog = memnew(ConfirmationDialog);
debug_uv_dialog->get_ok()->set_text(TTR("Create Mesh2D"));
debug_uv_dialog->set_title("Mesh 2D Preview");
VBoxContainer *vb = memnew(VBoxContainer);
debug_uv_dialog->add_child(vb);
ScrollContainer *scroll = memnew(ScrollContainer);
scroll->set_custom_minimum_size(Size2(800, 500) * EDSCALE);
scroll->set_enable_h_scroll(true);
scroll->set_enable_v_scroll(true);
vb->add_margin_child(TTR("Preview:"), scroll, true);
debug_uv = memnew(Control);
debug_uv->connect("draw", this, "_debug_uv_draw");
scroll->add_child(debug_uv);
debug_uv_dialog->connect("confirmed", this, "_create_node");
HBoxContainer *hb = memnew(HBoxContainer);
hb->add_child(memnew(Label(TTR("Simplification: "))));
simplification = memnew(SpinBox);
simplification->set_min(0.01);
simplification->set_max(10.00);
simplification->set_step(0.01);
simplification->set_value(2);
hb->add_child(simplification);
hb->add_spacer();
hb->add_child(memnew(Label(TTR("Grow (Pixels): "))));
island_merging = memnew(SpinBox);
island_merging->set_min(0);
island_merging->set_max(10);
island_merging->set_step(1);
island_merging->set_value(2);
hb->add_child(island_merging);
hb->add_spacer();
update_preview = memnew(Button);
update_preview->set_text(TTR("Update Preview"));
update_preview->connect("pressed", this, "_update_mesh_data");
hb->add_child(update_preview);
vb->add_margin_child(TTR("Settings:"), hb);
add_child(debug_uv_dialog);
}
MeshEditor::MeshEditor() {
viewport = memnew( Viewport );
Ref<World> world;
world.instance();
viewport->set_world(world); //use own world
add_child(viewport);
viewport->set_process_input(false);
camera = memnew( Camera );
camera->set_transform(Transform(Matrix3(),Vector3(0,0,3)));
camera->set_perspective(45,0.1,10);
viewport->add_child(camera);
light1 = memnew( DirectionalLight );
light1->set_transform(Transform().looking_at(Vector3(-1,-1,-1),Vector3(0,1,0)));
viewport->add_child(light1);
light2 = memnew( DirectionalLight );
light2->set_transform(Transform().looking_at(Vector3(0,1,0),Vector3(0,0,1)));
light2->set_color(Light::COLOR_DIFFUSE,Color(0.7,0.7,0.7));
light2->set_color(Light::COLOR_SPECULAR,Color(0.7,0.7,0.7));
viewport->add_child(light2);
mesh_instance = memnew( MeshInstance );
viewport->add_child(mesh_instance);
set_custom_minimum_size(Size2(1,150));
HBoxContainer *hb = memnew( HBoxContainer );
add_child(hb);
hb->set_area_as_parent_rect(2);
hb->add_spacer();
VBoxContainer *vb_light = memnew( VBoxContainer );
hb->add_child(vb_light);
light_1_switch = memnew( TextureButton );
light_1_switch->set_toggle_mode(true);
vb_light->add_child(light_1_switch);
light_1_switch->connect("pressed",this,"_button_pressed",varray(light_1_switch));
light_2_switch = memnew( TextureButton );
light_2_switch->set_toggle_mode(true);
vb_light->add_child(light_2_switch);
light_2_switch->connect("pressed",this,"_button_pressed",varray(light_2_switch));
first_enter=true;
rot_x=0;
rot_y=0;
}
MeshEditor::MeshEditor() {
viewport = memnew(Viewport);
Ref<World> world;
world.instance();
viewport->set_world(world); //use own world
add_child(viewport);
viewport->set_disable_input(true);
set_stretch(true);
camera = memnew(Camera);
camera->set_transform(Transform(Basis(), Vector3(0, 0, 1.1)));
camera->set_perspective(45, 0.1, 10);
viewport->add_child(camera);
light1 = memnew(DirectionalLight);
light1->set_transform(Transform().looking_at(Vector3(-1, -1, -1), Vector3(0, 1, 0)));
viewport->add_child(light1);
light2 = memnew(DirectionalLight);
light2->set_transform(Transform().looking_at(Vector3(0, 1, 0), Vector3(0, 0, 1)));
light2->set_color(Color(0.7, 0.7, 0.7));
viewport->add_child(light2);
rotation = memnew(Spatial);
viewport->add_child(rotation);
mesh_instance = memnew(MeshInstance);
rotation->add_child(mesh_instance);
set_custom_minimum_size(Size2(1, 150) * EDSCALE);
HBoxContainer *hb = memnew(HBoxContainer);
add_child(hb);
hb->set_anchors_and_margins_preset(Control::PRESET_WIDE, Control::PRESET_MODE_MINSIZE, 2);
hb->add_spacer();
VBoxContainer *vb_light = memnew(VBoxContainer);
hb->add_child(vb_light);
light_1_switch = memnew(TextureButton);
light_1_switch->set_toggle_mode(true);
vb_light->add_child(light_1_switch);
light_1_switch->connect("pressed", this, "_button_pressed", varray(light_1_switch));
light_2_switch = memnew(TextureButton);
light_2_switch->set_toggle_mode(true);
vb_light->add_child(light_2_switch);
light_2_switch->connect("pressed", this, "_button_pressed", varray(light_2_switch));
first_enter = true;
rot_x = 0;
rot_y = 0;
}
ConnectionsDock::ConnectionsDock(EditorNode *p_editor) {
editor=p_editor;
set_name(TTR("Signals"));
VBoxContainer *vbc = this;
tree = memnew( Tree );
tree->set_columns(1);
tree->set_select_mode(Tree::SELECT_ROW);
tree->set_hide_root(true);
vbc->add_child(tree);
tree->set_v_size_flags(SIZE_EXPAND_FILL);
connect_button = memnew( Button );
connect_button->set_text("Connect");
HBoxContainer *hb = memnew( HBoxContainer);
vbc->add_child(hb);
hb->add_spacer();
hb->add_child(connect_button);
connect_button->connect("pressed",this,"_connect_pressed");
//add_child(tree);
connect_dialog = memnew( ConnectDialog );
connect_dialog->set_as_toplevel(true);
add_child(connect_dialog);
remove_confirm = memnew( ConfirmationDialog );
remove_confirm->set_as_toplevel(true);
add_child(remove_confirm);
/*
node_only->set_anchor( MARGIN_TOP, ANCHOR_END );
node_only->set_anchor( MARGIN_BOTTOM, ANCHOR_END );
node_only->set_anchor( MARGIN_RIGHT, ANCHOR_END );
node_only->set_begin( Point2( 20,51) );
node_only->set_end( Point2( 10,44) );
*/
remove_confirm->connect("confirmed", this,"_remove_confirm");
connect_dialog->connect("connected", this,"_connect");
tree->connect("item_selected", this,"_something_selected");
tree->connect("item_activated", this,"_something_activated");
add_constant_override("separation",3*EDSCALE);
}
ItemListEditor::ItemListEditor() {
selected_idx=-1;
add_child( memnew( VSeparator ) );
toolbar_button = memnew( ToolButton );
toolbar_button->set_text(TTR("Items"));
add_child(toolbar_button);
toolbar_button->connect("pressed",this,"_edit_items");
dialog = memnew( AcceptDialog );
dialog->set_title(TTR("Item List Editor"));
add_child( dialog );
VBoxContainer *vbc = memnew( VBoxContainer );
dialog->add_child(vbc);
dialog->set_child_rect(vbc);
HBoxContainer *hbc = memnew( HBoxContainer );
hbc->set_h_size_flags(SIZE_EXPAND_FILL);
vbc->add_child(hbc);
add_button = memnew( Button );
add_button->set_text(TTR("Add"));
hbc->add_child(add_button);
add_button->connect("pressed",this,"_add_button");
hbc->add_spacer();
del_button = memnew( Button );
del_button->set_text(TTR("Delete"));
hbc->add_child(del_button);
del_button->connect("pressed",this,"_delete_button");
property_editor = memnew( PropertyEditor );
property_editor->hide_top_label();
property_editor->set_subsection_selectable(true);
vbc->add_child(property_editor);
property_editor->set_v_size_flags(SIZE_EXPAND_FILL);
tree = property_editor->get_scene_tree();
}
DependencyEditor::DependencyEditor() {
VBoxContainer *vb = memnew( VBoxContainer );
vb->set_name(TTR("Dependencies"));
add_child(vb);
set_child_rect(vb);
tree = memnew( Tree );
tree->set_columns(2);
tree->set_column_titles_visible(true);
tree->set_column_title(0,"Resource");
tree->set_column_title(1,"Path");
tree->set_hide_root(true);
tree->connect("button_pressed",this,"_load_pressed");
HBoxContainer *hbc = memnew( HBoxContainer );
Label *label = memnew( Label(TTR("Dependencies:")));
hbc->add_child(label);
hbc->add_spacer();
fixdeps = memnew( Button(TTR("Fix Broken")));
hbc->add_child(fixdeps);
fixdeps->connect("pressed",this,"_fix_all");
vb->add_child(hbc);
MarginContainer *mc = memnew( MarginContainer );
mc->set_v_size_flags(SIZE_EXPAND_FILL);
mc->add_child(tree);
vb->add_child(mc);
set_title(TTR("Dependency Editor"));
search = memnew( EditorFileDialog );
search->connect("file_selected",this,"_searched");
search->set_mode(EditorFileDialog::MODE_OPEN_FILE);
search->set_title(TTR("Search Replacement Resource:"));
add_child(search);
}
void VisualShaderEditor::_update_graph() {
if (updating)
return;
if (visual_shader.is_null())
return;
graph->set_scroll_ofs(visual_shader->get_graph_offset() * EDSCALE);
VisualShader::Type type = VisualShader::Type(edit_type->get_selected());
graph->clear_connections();
//erase all nodes
for (int i = 0; i < graph->get_child_count(); i++) {
if (Object::cast_to<GraphNode>(graph->get_child(i))) {
memdelete(graph->get_child(i));
i--;
}
}
static const Color type_color[3] = {
Color::html("#61daf4"),
Color::html("#d67dee"),
Color::html("#f6a86e")
};
List<VisualShader::Connection> connections;
visual_shader->get_node_connections(type, &connections);
Ref<StyleBoxEmpty> label_style = make_empty_stylebox(2, 1, 2, 1);
Vector<int> nodes = visual_shader->get_node_list(type);
for (int n_i = 0; n_i < nodes.size(); n_i++) {
Vector2 position = visual_shader->get_node_position(type, nodes[n_i]);
Ref<VisualShaderNode> vsnode = visual_shader->get_node(type, nodes[n_i]);
GraphNode *node = memnew(GraphNode);
graph->add_child(node);
/*if (!vsnode->is_connected("changed", this, "_node_changed")) {
vsnode->connect("changed", this, "_node_changed", varray(vsnode->get_instance_id()), CONNECT_DEFERRED);
}*/
node->set_offset(position);
node->set_title(vsnode->get_caption());
node->set_name(itos(nodes[n_i]));
if (nodes[n_i] >= 2) {
node->set_show_close_button(true);
node->connect("close_request", this, "_delete_request", varray(nodes[n_i]), CONNECT_DEFERRED);
}
node->connect("dragged", this, "_node_dragged", varray(nodes[n_i]));
Control *custom_editor = NULL;
int port_offset = 0;
Ref<VisualShaderNodeUniform> uniform = vsnode;
if (uniform.is_valid()) {
LineEdit *uniform_name = memnew(LineEdit);
uniform_name->set_text(uniform->get_uniform_name());
node->add_child(uniform_name);
uniform_name->connect("text_entered", this, "_line_edit_changed", varray(uniform_name, nodes[n_i]));
uniform_name->connect("focus_exited", this, "_line_edit_focus_out", varray(uniform_name, nodes[n_i]));
if (vsnode->get_input_port_count() == 0 && vsnode->get_output_port_count() == 1 && vsnode->get_output_port_name(0) == "") {
//shortcut
VisualShaderNode::PortType port_right = vsnode->get_output_port_type(0);
node->set_slot(0, false, VisualShaderNode::PORT_TYPE_SCALAR, Color(), true, port_right, type_color[port_right]);
continue;
}
port_offset++;
}
for (int i = 0; i < plugins.size(); i++) {
custom_editor = plugins.write[i]->create_editor(vsnode);
if (custom_editor) {
break;
}
}
if (custom_editor && vsnode->get_output_port_count() > 0 && vsnode->get_output_port_name(0) == "" && (vsnode->get_input_port_count() == 0 || vsnode->get_input_port_name(0) == "")) {
//will be embedded in first port
} else if (custom_editor) {
port_offset++;
node->add_child(custom_editor);
custom_editor = NULL;
}
for (int i = 0; i < MAX(vsnode->get_input_port_count(), vsnode->get_output_port_count()); i++) {
if (vsnode->is_port_separator(i)) {
node->add_child(memnew(HSeparator));
port_offset++;
}
bool valid_left = i < vsnode->get_input_port_count();
VisualShaderNode::PortType port_left = VisualShaderNode::PORT_TYPE_SCALAR;
bool port_left_used = false;
String name_left;
if (valid_left) {
name_left = vsnode->get_input_port_name(i);
port_left = vsnode->get_input_port_type(i);
for (List<VisualShader::Connection>::Element *E = connections.front(); E; E = E->next()) {
if (E->get().to_node == nodes[n_i] && E->get().to_port == i) {
port_left_used = true;
}
}
}
bool valid_right = i < vsnode->get_output_port_count();
VisualShaderNode::PortType port_right = VisualShaderNode::PORT_TYPE_SCALAR;
String name_right;
if (valid_right) {
name_right = vsnode->get_output_port_name(i);
port_right = vsnode->get_output_port_type(i);
}
HBoxContainer *hb = memnew(HBoxContainer);
Variant default_value;
if (valid_left && !port_left_used) {
default_value = vsnode->get_input_port_default_value(i);
}
if (default_value.get_type() != Variant::NIL) { // only a label
Button *button = memnew(Button);
hb->add_child(button);
button->connect("pressed", this, "_edit_port_default_input", varray(button, nodes[n_i], i));
switch (default_value.get_type()) {
case Variant::COLOR: {
button->set_custom_minimum_size(Size2(30, 0) * EDSCALE);
button->connect("draw", this, "_draw_color_over_button", varray(button, default_value));
} break;
case Variant::INT:
case Variant::REAL: {
button->set_text(String::num(default_value, 4));
} break;
case Variant::VECTOR3: {
Vector3 v = default_value;
button->set_text(String::num(v.x, 3) + "," + String::num(v.y, 3) + "," + String::num(v.z, 3));
} break;
default: {}
}
}
if (i == 0 && custom_editor) {
hb->add_child(custom_editor);
custom_editor->set_h_size_flags(SIZE_EXPAND_FILL);
} else {
if (valid_left) {
Label *label = memnew(Label);
label->set_text(name_left);
label->add_style_override("normal", label_style); //more compact
hb->add_child(label);
}
hb->add_spacer();
if (valid_right) {
Label *label = memnew(Label);
label->set_text(name_right);
label->set_align(Label::ALIGN_RIGHT);
label->add_style_override("normal", label_style); //more compact
hb->add_child(label);
}
}
if (valid_right && edit_type->get_selected() == VisualShader::TYPE_FRAGMENT) {
TextureButton *preview = memnew(TextureButton);
preview->set_toggle_mode(true);
preview->set_normal_texture(get_icon("GuiVisibilityHidden", "EditorIcons"));
preview->set_pressed_texture(get_icon("GuiVisibilityVisible", "EditorIcons"));
preview->set_v_size_flags(SIZE_SHRINK_CENTER);
if (vsnode->get_output_port_for_preview() == i) {
preview->set_pressed(true);
}
preview->connect("pressed", this, "_preview_select_port", varray(nodes[n_i], i), CONNECT_DEFERRED);
hb->add_child(preview);
}
node->add_child(hb);
node->set_slot(i + port_offset, valid_left, port_left, type_color[port_left], valid_right, port_right, type_color[port_right]);
if (EditorSettings::get_singleton()->get("interface/theme/use_graph_node_headers")) {
Ref<StyleBoxFlat> sb = node->get_stylebox("frame", "GraphNode");
Color c = sb->get_border_color(MARGIN_TOP);
Color mono_color = ((c.r + c.g + c.b) / 3) < 0.7 ? Color(1.0, 1.0, 1.0) : Color(0.0, 0.0, 0.0);
mono_color.a = 0.85;
c = mono_color;
node->add_color_override("title_color", c);
c.a = 0.7;
node->add_color_override("close_color", c);
}
}
if (vsnode->get_output_port_for_preview() >= 0) {
VisualShaderNodePortPreview *port_preview = memnew(VisualShaderNodePortPreview);
port_preview->setup(visual_shader, type, nodes[n_i], vsnode->get_output_port_for_preview());
port_preview->set_h_size_flags(SIZE_SHRINK_CENTER);
node->add_child(port_preview);
}
String error = vsnode->get_warning(visual_shader->get_mode(), type);
if (error != String()) {
Label *error_label = memnew(Label);
error_label->add_color_override("font_color", get_color("error_color", "Editor"));
error_label->set_text(error);
node->add_child(error_label);
}
}
for (List<VisualShader::Connection>::Element *E = connections.front(); E; E = E->next()) {
int from = E->get().from_node;
int from_idx = E->get().from_port;
int to = E->get().to_node;
int to_idx = E->get().to_port;
graph->connect_node(itos(from), from_idx, itos(to), to_idx);
}
}
ResourcesDock::ResourcesDock(EditorNode *p_editor) {
editor=p_editor;
VBoxContainer *vbc = this;
HBoxContainer *hbc = memnew( HBoxContainer );
vbc->add_child(hbc);
Button *b;
b = memnew( ToolButton );
b->set_tooltip(TTR("Create New Resource"));
b->connect("pressed",this,"_tool_selected",make_binds(TOOL_NEW));
hbc->add_child( b );
button_new=b;
b = memnew( ToolButton );
b->set_tooltip(TTR("Open Resource"));
b->connect("pressed",this,"_tool_selected",make_binds(TOOL_OPEN));
hbc->add_child( b );
button_open=b;
MenuButton *mb = memnew( MenuButton );
mb->set_tooltip(TTR("Save Resource"));
mb->get_popup()->add_item(TTR("Save Resource"),TOOL_SAVE);
mb->get_popup()->add_item(TTR("Save Resource As.."),TOOL_SAVE_AS);
mb->get_popup()->connect("item_pressed",this,"_tool_selected" );
hbc->add_child( mb );
button_save=mb;
hbc->add_spacer();
mb = memnew( MenuButton );
mb->set_tooltip(TTR("Resource Tools"));
mb->get_popup()->add_item(TTR("Make Local"),TOOL_MAKE_LOCAL);
mb->get_popup()->add_item(TTR("Copy"),TOOL_COPY);
mb->get_popup()->add_item(TTR("Paste"),TOOL_PASTE);
mb->get_popup()->connect("item_pressed",this,"_tool_selected" );
hbc->add_child( mb );
button_tools=mb;
resources = memnew( Tree );
vbc->add_child(resources);
resources->set_v_size_flags(SIZE_EXPAND_FILL);
resources->create_item(); //root
resources->set_hide_root(true);
resources->connect("cell_selected",this,"_resource_selected");
resources->connect("button_pressed",this,"_delete");
create_dialog = memnew( CreateDialog );
add_child(create_dialog);
create_dialog->set_base_type("Resource");
create_dialog->connect("create",this,"_create");
accept = memnew (AcceptDialog);
add_child(accept);
file = memnew( EditorFileDialog );
add_child(file);
file->connect("file_selected",this,"_file_action");
block_add=false;
}
HBoxContainer* EditorAddonLibrary::_make_pages(int p_page,int p_max_page,int p_page_len,int p_total_items,int p_current_items) {
HBoxContainer * hbc = memnew( HBoxContainer );
//do the mario
int from = p_page-5;
if (from<0)
from=0;
int to = from+10;
if (to>p_max_page)
to=p_max_page;
Color gray = Color(0.65,0.65,0.65);
hbc->add_spacer();
hbc->add_constant_override("separation",10);
LinkButton *first = memnew( LinkButton );
first->set_text("first");
first->add_color_override("font_color", gray );
first->set_underline_mode(LinkButton::UNDERLINE_MODE_ON_HOVER);
first->connect("pressed",this,"_search",varray(0));
hbc->add_child(first);
if (p_page>0) {
LinkButton *prev = memnew( LinkButton );
prev->set_text("prev");
prev->add_color_override("font_color", gray );
prev->set_underline_mode(LinkButton::UNDERLINE_MODE_ON_HOVER);
prev->connect("pressed",this,"_search",varray(p_page-1));
hbc->add_child(prev);
}
for(int i=from;i<=to;i++) {
if (i==p_page) {
Label *current = memnew(Label);
current->set_text(itos(i));
hbc->add_child(current);
} else {
LinkButton *current = memnew( LinkButton );
current->add_color_override("font_color", gray );
current->set_underline_mode(LinkButton::UNDERLINE_MODE_ON_HOVER);
current->set_text(itos(i));
current->connect("pressed",this,"_search",varray(i));
hbc->add_child(current);
}
}
if (p_page<p_max_page) {
LinkButton *next = memnew( LinkButton );
next->set_text("next");
next->add_color_override("font_color", gray );
next->set_underline_mode(LinkButton::UNDERLINE_MODE_ON_HOVER);
next->connect("pressed",this,"_search",varray(p_page+1));
hbc->add_child(next);
}
LinkButton *last = memnew( LinkButton );
last->set_text("last");
last->add_color_override("font_color", gray );
last->set_underline_mode(LinkButton::UNDERLINE_MODE_ON_HOVER);
hbc->add_child(last);
last->connect("pressed",this,"_search",varray(p_max_page));
Label *totals = memnew( Label );
totals->set_text("( "+itos(from*p_page_len)+" - "+itos(from*p_page_len+p_current_items-1)+" / "+itos(p_total_items)+" )");
hbc->add_child(totals);
hbc->add_spacer();
return hbc;
}
MaterialEditor::MaterialEditor() {
viewport = memnew( Viewport );
Ref<World> world;
world.instance();
viewport->set_world(world); //use own world
add_child(viewport);
viewport->set_disable_input(true);
camera = memnew( Camera );
camera->set_transform(Transform(Matrix3(),Vector3(0,0,3)));
camera->set_perspective(45,0.1,10);
viewport->add_child(camera);
light1 = memnew( DirectionalLight );
light1->set_transform(Transform().looking_at(Vector3(-1,-1,-1),Vector3(0,1,0)));
viewport->add_child(light1);
light2 = memnew( DirectionalLight );
light2->set_transform(Transform().looking_at(Vector3(0,1,0),Vector3(0,0,1)));
light2->set_color(Light::COLOR_DIFFUSE,Color(0.7,0.7,0.7));
light2->set_color(Light::COLOR_SPECULAR,Color(0.7,0.7,0.7));
viewport->add_child(light2);
sphere_instance = memnew( MeshInstance );
viewport->add_child(sphere_instance);
box_instance = memnew( MeshInstance );
viewport->add_child(box_instance);
Transform box_xform;
box_xform.basis.rotate(Vector3(1,0,0),Math::deg2rad(25));
box_xform.basis = box_xform.basis * Matrix3().rotated(Vector3(0,1,0),Math::deg2rad(25));
box_xform.basis.scale(Vector3(0.8,0.8,0.8));
box_instance->set_transform(box_xform);
{
sphere_mesh.instance();
int lats=32;
int lons=32;
float radius=1.0;
PoolVector<Vector3> vertices;
PoolVector<Vector3> normals;
PoolVector<Vector2> uvs;
PoolVector<float> tangents;
Matrix3 tt = Matrix3(Vector3(0,1,0),Math_PI*0.5);
for(int i = 1; i <= lats; i++) {
double lat0 = Math_PI * (-0.5 + (double) (i - 1) / lats);
double z0 = Math::sin(lat0);
double zr0 = Math::cos(lat0);
double lat1 = Math_PI * (-0.5 + (double) i / lats);
double z1 = Math::sin(lat1);
double zr1 = Math::cos(lat1);
for(int j = lons; j >= 1; j--) {
double lng0 = 2 * Math_PI * (double) (j - 1) / lons;
double x0 = Math::cos(lng0);
double y0 = Math::sin(lng0);
double lng1 = 2 * Math_PI * (double) (j) / lons;
double x1 = Math::cos(lng1);
double y1 = Math::sin(lng1);
Vector3 v[4]={
Vector3(x1 * zr0, z0, y1 *zr0),
Vector3(x1 * zr1, z1, y1 *zr1),
Vector3(x0 * zr1, z1, y0 *zr1),
Vector3(x0 * zr0, z0, y0 *zr0)
};
#define ADD_POINT(m_idx) \
normals.push_back(v[m_idx]);\
vertices.push_back(v[m_idx]*radius);\
{ Vector2 uv(Math::atan2(v[m_idx].x,v[m_idx].z),Math::atan2(-v[m_idx].y,v[m_idx].z));\
uv/=Math_PI;\
uv*=4.0;\
uv=uv*0.5+Vector2(0.5,0.5);\
uvs.push_back(uv);\
}\
{ Vector3 t = tt.xform(v[m_idx]);\
tangents.push_back(t.x);\
tangents.push_back(t.y);\
tangents.push_back(t.z);\
tangents.push_back(1.0);\
}
ADD_POINT(0);
ADD_POINT(1);
ADD_POINT(2);
ADD_POINT(2);
ADD_POINT(3);
ADD_POINT(0);
}
}
Array arr;
arr.resize(VS::ARRAY_MAX);
arr[VS::ARRAY_VERTEX]=vertices;
arr[VS::ARRAY_NORMAL]=normals;
arr[VS::ARRAY_TANGENT]=tangents;
arr[VS::ARRAY_TEX_UV]=uvs;
sphere_mesh->add_surface(Mesh::PRIMITIVE_TRIANGLES,arr);
sphere_instance->set_mesh(sphere_mesh);
}
{
box_mesh.instance();
PoolVector<Vector3> vertices;
PoolVector<Vector3> normals;
PoolVector<float> tangents;
PoolVector<Vector3> uvs;
int vtx_idx=0;
#define ADD_VTX(m_idx);\
vertices.push_back( face_points[m_idx] );\
normals.push_back( normal_points[m_idx] );\
tangents.push_back( normal_points[m_idx][1] );\
tangents.push_back( normal_points[m_idx][2] );\
tangents.push_back( normal_points[m_idx][0] );\
tangents.push_back( 1.0 );\
uvs.push_back( Vector3(uv_points[m_idx*2+0],uv_points[m_idx*2+1],0) );\
vtx_idx++;\
for (int i=0;i<6;i++) {
Vector3 face_points[4];
Vector3 normal_points[4];
float uv_points[8]={0,0,0,1,1,1,1,0};
for (int j=0;j<4;j++) {
float v[3];
v[0]=1.0;
v[1]=1-2*((j>>1)&1);
v[2]=v[1]*(1-2*(j&1));
for (int k=0;k<3;k++) {
if (i<3)
face_points[j][(i+k)%3]=v[k]*(i>=3?-1:1);
else
face_points[3-j][(i+k)%3]=v[k]*(i>=3?-1:1);
}
normal_points[j]=Vector3();
normal_points[j][i%3]=(i>=3?-1:1);
}
//tri 1
ADD_VTX(0);
ADD_VTX(1);
ADD_VTX(2);
//tri 2
ADD_VTX(2);
ADD_VTX(3);
ADD_VTX(0);
}
Array d;
d.resize(VS::ARRAY_MAX);
d[VisualServer::ARRAY_NORMAL]= normals ;
d[VisualServer::ARRAY_TANGENT]= tangents ;
d[VisualServer::ARRAY_TEX_UV]= uvs ;
d[VisualServer::ARRAY_VERTEX]= vertices ;
PoolVector<int> indices;
indices.resize(vertices.size());
for(int i=0;i<vertices.size();i++)
indices.set(i,i);
d[VisualServer::ARRAY_INDEX]=indices;
box_mesh->add_surface(Mesh::PRIMITIVE_TRIANGLES,d);
box_instance->set_mesh(box_mesh);
box_instance->hide();
}
set_custom_minimum_size(Size2(1,150)*EDSCALE);
HBoxContainer *hb = memnew( HBoxContainer );
add_child(hb);
hb->set_area_as_parent_rect(2);
VBoxContainer *vb_shape = memnew( VBoxContainer );
hb->add_child(vb_shape);
sphere_switch = memnew( TextureButton );
sphere_switch->set_toggle_mode(true);
sphere_switch->set_pressed(true);
vb_shape->add_child(sphere_switch);
sphere_switch->connect("pressed",this,"_button_pressed",varray(sphere_switch));
box_switch = memnew( TextureButton );
box_switch->set_toggle_mode(true);
box_switch->set_pressed(false);
vb_shape->add_child(box_switch);
box_switch->connect("pressed",this,"_button_pressed",varray(box_switch));
hb->add_spacer();
VBoxContainer *vb_light = memnew( VBoxContainer );
hb->add_child(vb_light);
light_1_switch = memnew( TextureButton );
light_1_switch->set_toggle_mode(true);
vb_light->add_child(light_1_switch);
light_1_switch->connect("pressed",this,"_button_pressed",varray(light_1_switch));
light_2_switch = memnew( TextureButton );
light_2_switch->set_toggle_mode(true);
vb_light->add_child(light_2_switch);
light_2_switch->connect("pressed",this,"_button_pressed",varray(light_2_switch));
first_enter=true;
}
TileMapEditor::TileMapEditor(EditorNode *p_editor) {
node=NULL;
canvas_item_editor=NULL;
editor=p_editor;
undo_redo = editor->get_undo_redo();
int mw = EDITOR_DEF("tile_map/palette_min_width",80);
Control *ec = memnew( Control);
ec->set_custom_minimum_size(Size2(mw,0));
add_child(ec);
HBoxContainer *hb = memnew( HBoxContainer );
add_child(hb);
hb->set_h_size_flags(SIZE_EXPAND_FILL);
hb->add_spacer(true);
button_thumbnail = memnew( ToolButton );
button_thumbnail->set_toggle_mode(true);
button_thumbnail->set_pressed(true);
button_thumbnail->set_icon(p_editor->get_gui_base()->get_icon("FileThumbnail","EditorIcons"));
hb->add_child(button_thumbnail);
button_thumbnail->connect("pressed", this, "_set_display_mode", varray(DISPLAY_THUMBNAIL));
button_list = memnew( ToolButton );
button_list->set_toggle_mode(true);
button_list->set_pressed(false);
button_list->set_icon(p_editor->get_gui_base()->get_icon("FileList","EditorIcons"));
hb->add_child(button_list);
button_list->connect("pressed", this, "_set_display_mode", varray(DISPLAY_LIST));
// Add tile palette
palette = memnew( ItemList );
palette->set_v_size_flags(SIZE_EXPAND_FILL);
add_child(palette);
// Add menu items
canvas_item_editor_hb = memnew( HBoxContainer );
CanvasItemEditor::get_singleton()->add_control_to_menu_panel(canvas_item_editor_hb);
canvas_item_editor_hb->add_child( memnew( VSeparator ));
transpose = memnew( ToolButton );
transpose->set_toggle_mode(true);
transpose->set_tooltip("Transpose");
transpose->set_focus_mode(FOCUS_NONE);
transpose->connect("pressed", this, "_update_transform_buttons", make_binds(transpose));
canvas_item_editor_hb->add_child(transpose);
mirror_x = memnew( ToolButton );
mirror_x->set_toggle_mode(true);
mirror_x->set_tooltip("Mirror X (A)");
mirror_x->set_focus_mode(FOCUS_NONE);
mirror_x->connect("pressed", this, "_update_transform_buttons", make_binds(mirror_x));
canvas_item_editor_hb->add_child(mirror_x);
mirror_y = memnew( ToolButton );
mirror_y->set_toggle_mode(true);
mirror_y->set_tooltip("Mirror Y (S)");
mirror_y->set_focus_mode(FOCUS_NONE);
mirror_y->connect("pressed", this, "_update_transform_buttons", make_binds(mirror_y));
canvas_item_editor_hb->add_child(mirror_y);
canvas_item_editor_hb->add_child(memnew(VSeparator));
rotate_0 = memnew( ToolButton );
rotate_0->set_toggle_mode(true);
rotate_0->set_tooltip("Rotate 0 degrees");
rotate_0->set_focus_mode(FOCUS_NONE);
rotate_0->connect("pressed", this, "_update_transform_buttons", make_binds(rotate_0));
canvas_item_editor_hb->add_child(rotate_0);
rotate_90 = memnew( ToolButton );
rotate_90->set_toggle_mode(true);
rotate_90->set_tooltip("Rotate 90 degrees");
rotate_90->set_focus_mode(FOCUS_NONE);
rotate_90->connect("pressed", this, "_update_transform_buttons", make_binds(rotate_90));
canvas_item_editor_hb->add_child(rotate_90);
rotate_180 = memnew( ToolButton );
rotate_180->set_toggle_mode(true);
rotate_180->set_tooltip("Rotate 180 degrees");
rotate_180->set_focus_mode(FOCUS_NONE);
rotate_180->connect("pressed", this, "_update_transform_buttons", make_binds(rotate_180));
canvas_item_editor_hb->add_child(rotate_180);
rotate_270 = memnew( ToolButton );
rotate_270->set_toggle_mode(true);
rotate_270->set_tooltip("Rotate 270 degrees");
rotate_270->set_focus_mode(FOCUS_NONE);
rotate_270->connect("pressed", this, "_update_transform_buttons", make_binds(rotate_270));
canvas_item_editor_hb->add_child(rotate_270);
canvas_item_editor_hb->hide();
rotate_0->set_pressed(true);
tool=TOOL_NONE;
selection_active=false;
mouse_over=false;
}
EditorAudioBus::EditorAudioBus(EditorAudioBuses *p_buses, bool p_is_master) {
buses = p_buses;
updating_bus = false;
is_master = p_is_master;
set_tooltip(TTR("Audio Bus, Drag and Drop to rearrange."));
VBoxContainer *vb = memnew(VBoxContainer);
add_child(vb);
set_v_size_flags(SIZE_EXPAND_FILL);
set_custom_minimum_size(Size2(100, 0) * EDSCALE);
track_name = memnew(LineEdit);
track_name->connect("text_entered", this, "_name_changed");
track_name->connect("focus_exited", this, "_name_focus_exit");
vb->add_child(track_name);
HBoxContainer *hbc = memnew(HBoxContainer);
vb->add_child(hbc);
solo = memnew(ToolButton);
solo->set_toggle_mode(true);
solo->set_tooltip(TTR("Solo"));
solo->set_focus_mode(FOCUS_NONE);
solo->connect("pressed", this, "_solo_toggled");
hbc->add_child(solo);
mute = memnew(ToolButton);
mute->set_toggle_mode(true);
mute->set_tooltip(TTR("Mute"));
mute->set_focus_mode(FOCUS_NONE);
mute->connect("pressed", this, "_mute_toggled");
hbc->add_child(mute);
bypass = memnew(ToolButton);
bypass->set_toggle_mode(true);
bypass->set_tooltip(TTR("Bypass"));
bypass->set_focus_mode(FOCUS_NONE);
bypass->connect("pressed", this, "_bypass_toggled");
hbc->add_child(bypass);
hbc->add_spacer();
bus_options = memnew(MenuButton);
bus_options->set_h_size_flags(SIZE_SHRINK_END);
bus_options->set_anchor(MARGIN_RIGHT, 0.0);
bus_options->set_tooltip(TTR("Bus options"));
hbc->add_child(bus_options);
Ref<StyleBoxEmpty> sbempty = memnew(StyleBoxEmpty);
for (int i = 0; i < hbc->get_child_count(); i++) {
Control *child = Object::cast_to<Control>(hbc->get_child(i));
child->add_style_override("normal", sbempty);
child->add_style_override("hover", sbempty);
child->add_style_override("focus", sbempty);
child->add_style_override("pressed", sbempty);
}
vb->add_child(memnew(HSeparator));
HBoxContainer *hb = memnew(HBoxContainer);
vb->add_child(hb);
slider = memnew(VSlider);
slider->set_min(-80);
slider->set_max(24);
slider->set_step(0.1);
slider->connect("value_changed", this, "_volume_db_changed");
hb->add_child(slider);
cc = 0;
for (int i = 0; i < CHANNELS_MAX; i++) {
channel[i].vu_l = memnew(TextureProgress);
channel[i].vu_l->set_fill_mode(TextureProgress::FILL_BOTTOM_TO_TOP);
hb->add_child(channel[i].vu_l);
channel[i].vu_l->set_min(-80);
channel[i].vu_l->set_max(24);
channel[i].vu_l->set_step(0.1);
channel[i].vu_r = memnew(TextureProgress);
channel[i].vu_r->set_fill_mode(TextureProgress::FILL_BOTTOM_TO_TOP);
hb->add_child(channel[i].vu_r);
channel[i].vu_r->set_min(-80);
channel[i].vu_r->set_max(24);
channel[i].vu_r->set_step(0.1);
channel[i].peak_l = 0.0f;
channel[i].peak_r = 0.0f;
}
scale = memnew(TextureRect);
hb->add_child(scale);
effects = memnew(Tree);
effects->set_hide_root(true);
effects->set_custom_minimum_size(Size2(0, 100) * EDSCALE);
effects->set_hide_folding(true);
effects->set_v_size_flags(SIZE_EXPAND_FILL);
vb->add_child(effects);
effects->connect("item_edited", this, "_effect_edited");
effects->connect("cell_selected", this, "_effect_selected");
effects->set_edit_checkbox_cell_only_when_checkbox_is_pressed(true);
effects->set_drag_forwarding(this);
effects->connect("item_rmb_selected", this, "_effect_rmb");
effects->set_allow_rmb_select(true);
effects->set_focus_mode(FOCUS_CLICK);
effects->set_allow_reselect(true);
send = memnew(OptionButton);
send->set_clip_text(true);
send->connect("item_selected", this, "_send_selected");
vb->add_child(send);
set_focus_mode(FOCUS_CLICK);
effect_options = memnew(PopupMenu);
effect_options->connect("index_pressed", this, "_effect_add");
add_child(effect_options);
List<StringName> effects;
ClassDB::get_inheriters_from_class("AudioEffect", &effects);
effects.sort_custom<StringName::AlphCompare>();
for (List<StringName>::Element *E = effects.front(); E; E = E->next()) {
if (!ClassDB::can_instance(E->get()))
continue;
Ref<Texture> icon = EditorNode::get_singleton()->get_class_icon(E->get());
String name = E->get().operator String().replace("AudioEffect", "");
effect_options->add_item(name);
effect_options->set_item_metadata(effect_options->get_item_count() - 1, E->get());
effect_options->set_item_icon(effect_options->get_item_count() - 1, icon);
}
bus_popup = bus_options->get_popup();
bus_popup->add_item(TTR("Duplicate"));
bus_popup->add_item(TTR("Delete"));
bus_popup->set_item_disabled(1, is_master);
bus_popup->add_item(TTR("Reset Volume"));
bus_popup->connect("index_pressed", this, "_bus_popup_pressed");
delete_effect_popup = memnew(PopupMenu);
delete_effect_popup->add_item(TTR("Delete Effect"));
add_child(delete_effect_popup);
delete_effect_popup->connect("index_pressed", this, "_delete_effect_pressed");
}
ProjectSettings::ProjectSettings(EditorData *p_data) {
singleton=this;
set_title("Project Settings (engine.cfg)");
undo_redo=&p_data->get_undo_redo();
data=p_data;
TabContainer *tab_container = memnew( TabContainer );
add_child(tab_container);
set_child_rect(tab_container);
//tab_container->set_anchor_and_margin(MARGIN_LEFT,ANCHOR_BEGIN, 15 );
//tab_container->set_anchor_and_margin(MARGIN_RIGHT,ANCHOR_END, 15 );
//tab_container->set_anchor_and_margin(MARGIN_TOP,ANCHOR_BEGIN, 15 );
//tab_container->set_anchor_and_margin(MARGIN_BOTTOM,ANCHOR_END, 35 );
Control *props_base = memnew( Control );
tab_container->add_child(props_base);
props_base->set_name("General");
globals_editor = memnew( PropertyEditor );
props_base->add_child(globals_editor);
globals_editor->set_area_as_parent_rect();
globals_editor->hide_top_label();
globals_editor->set_anchor_and_margin(MARGIN_TOP,ANCHOR_BEGIN, 55 );
globals_editor->set_anchor_and_margin(MARGIN_BOTTOM,ANCHOR_END, 35 );
globals_editor->set_anchor_and_margin(MARGIN_LEFT,ANCHOR_BEGIN, 5 );
globals_editor->set_anchor_and_margin(MARGIN_RIGHT,ANCHOR_END, 5 );
globals_editor->set_capitalize_paths(false);
globals_editor->get_tree()->connect("cell_selected",this,"_item_selected");
globals_editor->connect("property_toggled",this,"_item_checked");
globals_editor->connect("property_edited",this,"_settings_prop_edited");
Label *l = memnew( Label );
props_base->add_child(l);
l->set_pos(Point2(6,5));
l->set_text("Category:");
l = memnew( Label );
l->set_anchor(MARGIN_LEFT,ANCHOR_RATIO);
props_base->add_child(l);
l->set_begin(Point2(0.21,5));
l->set_text("Property:");
l = memnew( Label );
l->set_anchor(MARGIN_LEFT,ANCHOR_RATIO);
props_base->add_child(l);
l->set_begin(Point2(0.51,5));
l->set_text("Type:");
category = memnew( LineEdit );
props_base->add_child(category);
category->set_anchor(MARGIN_RIGHT,ANCHOR_RATIO);
category->set_begin( Point2(5,25) );
category->set_end( Point2(0.20,26) );
category->connect("text_entered",this,"_item_adds");
property = memnew( LineEdit );
props_base->add_child(property);
property->set_anchor(MARGIN_LEFT,ANCHOR_RATIO);
property->set_anchor(MARGIN_RIGHT,ANCHOR_RATIO);
property->set_begin( Point2(0.21,25) );
property->set_end( Point2(0.50,26) );
property->connect("text_entered",this,"_item_adds");
type = memnew( OptionButton );
props_base->add_child(type);
type->set_anchor(MARGIN_LEFT,ANCHOR_RATIO);
type->set_anchor(MARGIN_RIGHT,ANCHOR_RATIO);
type->set_begin( Point2(0.51,25) );
type->set_end( Point2(0.70,26) );
type->add_item("bool");
type->add_item("int");
type->add_item("float");
type->add_item("string");
Button *add = memnew( Button );
props_base->add_child(add);
add->set_anchor(MARGIN_LEFT,ANCHOR_RATIO);
add->set_anchor(MARGIN_RIGHT,ANCHOR_RATIO);
add->set_begin( Point2(0.71,25) );
add->set_end( Point2(0.85,26) );
add->set_text("Add");
add->connect("pressed",this,"_item_add");
Button *del = memnew( Button );
props_base->add_child(del);
del->set_anchor(MARGIN_LEFT,ANCHOR_RATIO);
del->set_anchor(MARGIN_RIGHT,ANCHOR_END);
del->set_begin( Point2(0.86,25) );
del->set_end( Point2(5,26) );
del->set_text("Del");
del->connect("pressed",this,"_item_del");
Button *save = memnew( Button );
props_base->add_child(save);
save->set_anchor(MARGIN_LEFT,ANCHOR_END);
save->set_anchor(MARGIN_RIGHT,ANCHOR_END);
save->set_anchor(MARGIN_TOP,ANCHOR_END);
save->set_anchor(MARGIN_BOTTOM,ANCHOR_END);
save->set_begin( Point2(80,28) );
save->set_end( Point2(10,20) );
save->set_text("Save");
save->connect("pressed",this,"_save");
popup_platform = memnew( MenuButton );
popup_platform->set_text("Copy To Platform..");
popup_platform->set_disabled(true);
props_base->add_child(popup_platform);
popup_platform->set_anchor(MARGIN_LEFT,ANCHOR_BEGIN);
popup_platform->set_anchor(MARGIN_RIGHT,ANCHOR_BEGIN);
popup_platform->set_anchor(MARGIN_TOP,ANCHOR_END);
popup_platform->set_anchor(MARGIN_BOTTOM,ANCHOR_END);
popup_platform->set_begin( Point2(10,28) );
popup_platform->set_end( Point2(150,20) );
List<StringName> ep;
EditorImportExport::get_singleton()->get_export_platforms(&ep);
ep.sort_custom<StringName::AlphCompare>();
for(List<StringName>::Element *E=ep.front();E;E=E->next()) {
popup_platform->get_popup()->add_item( E->get() );
}
popup_platform->get_popup()->connect("item_pressed",this,"_copy_to_platform");
get_ok()->set_text("Close");
set_hide_on_ok(true);
message = memnew( ConfirmationDialog );
add_child(message);
// message->get_cancel()->hide();
message->set_hide_on_ok(true);
Control *input_base = memnew( Control );
input_base->set_name("Input Map");
input_base->set_area_as_parent_rect();;
tab_container->add_child(input_base);
l = memnew( Label );
input_base->add_child(l);
l->set_pos(Point2(6,5));
l->set_text("Action:");
action_name = memnew( LineEdit );
action_name->set_anchor(MARGIN_RIGHT,ANCHOR_RATIO);
action_name->set_begin( Point2(5,25) );
action_name->set_end( Point2(0.85,26) );
input_base->add_child(action_name);
action_name->connect("text_entered",this,"_action_adds");
add = memnew( Button );
input_base->add_child(add);
add->set_anchor(MARGIN_LEFT,ANCHOR_RATIO);
add->set_begin( Point2(0.86,25) );
add->set_anchor(MARGIN_RIGHT,ANCHOR_END);
add->set_end( Point2(5,26) );
add->set_text("Add");
add->connect("pressed",this,"_action_add");
input_editor = memnew( Tree );
input_base->add_child(input_editor);
input_editor->set_area_as_parent_rect();
input_editor->set_anchor_and_margin(MARGIN_TOP,ANCHOR_BEGIN, 55 );
input_editor->set_anchor_and_margin(MARGIN_BOTTOM,ANCHOR_END, 35 );
input_editor->set_anchor_and_margin(MARGIN_LEFT,ANCHOR_BEGIN, 5 );
input_editor->set_anchor_and_margin(MARGIN_RIGHT,ANCHOR_END, 5 );
input_editor->connect("item_edited",this,"_action_persist_toggle");
input_editor->connect("button_pressed",this,"_action_button_pressed");
popup_add = memnew( PopupMenu );
add_child(popup_add);
popup_add->connect("item_pressed",this,"_add_item");
press_a_key = memnew( ConfirmationDialog );
press_a_key->set_focus_mode(FOCUS_ALL);
add_child(press_a_key);
l = memnew( Label );
l->set_text("Press a Key..");
l->set_area_as_parent_rect();
l->set_align(Label::ALIGN_CENTER);
l->set_margin(MARGIN_TOP,20);
l->set_anchor_and_margin(MARGIN_BOTTOM,ANCHOR_BEGIN,30);
press_a_key_label=l;
press_a_key->add_child(l);
press_a_key->connect("input_event",this,"_wait_for_key");
press_a_key->connect("confirmed",this,"_press_a_key_confirm");
device_input=memnew( ConfirmationDialog );
add_child(device_input);
device_input->get_ok()->set_text("Add");
device_input->connect("confirmed",this,"_device_input_add");
l = memnew( Label );
l->set_text("Device:");
l->set_pos(Point2(15,10));
device_input->add_child(l);
l = memnew( Label );
l->set_text("Index:");
l->set_pos(Point2(90,10));
device_input->add_child(l);
device_index_label=l;
device_id = memnew( SpinBox );
device_id->set_pos(Point2(20,30));
device_id->set_size(Size2(70,10));
device_id->set_val(0);
device_input->add_child(device_id);
device_index = memnew( OptionButton );
device_index->set_pos(Point2(95,30));
device_index->set_size(Size2(300,10));
device_index->set_anchor_and_margin(MARGIN_RIGHT,ANCHOR_END,10);
device_input->add_child(device_index);
save = memnew( Button );
input_base->add_child(save);
save->set_anchor(MARGIN_LEFT,ANCHOR_END);
save->set_anchor(MARGIN_RIGHT,ANCHOR_END);
save->set_anchor(MARGIN_TOP,ANCHOR_END);
save->set_anchor(MARGIN_BOTTOM,ANCHOR_END);
save->set_begin( Point2(80,28) );
save->set_end( Point2(10,20) );
save->set_text("Save");
save->connect("pressed",this,"_save");
setting=false;
//translations
TabContainer *translations = memnew( TabContainer );
translations->set_name("Localization");
tab_container->add_child(translations);
{
VBoxContainer *tvb = memnew( VBoxContainer );
translations->add_child(tvb);
tvb->set_name("Translations");
HBoxContainer *thb = memnew( HBoxContainer);
tvb->add_child(thb);
thb->add_child( memnew( Label("Translations:")));
thb->add_spacer();
Button *addtr = memnew( Button("Add..") );
addtr->connect("pressed",this,"_translation_file_open");
thb->add_child(addtr);
MarginContainer *tmc = memnew( MarginContainer );
tvb->add_child(tmc);
tmc->set_v_size_flags(SIZE_EXPAND_FILL);
translation_list = memnew( Tree );
translation_list->set_v_size_flags(SIZE_EXPAND_FILL);
tmc->add_child(translation_list);
translation_file_open=memnew( FileDialog );
add_child(translation_file_open);
translation_file_open->set_mode(FileDialog::MODE_OPEN_FILE);
translation_file_open->connect("file_selected",this,"_translation_add");
}
{
VBoxContainer *tvb = memnew( VBoxContainer );
translations->add_child(tvb);
tvb->set_name("Remaps");
HBoxContainer *thb = memnew( HBoxContainer);
tvb->add_child(thb);
thb->add_child( memnew( Label("Resources:")));
thb->add_spacer();
Button *addtr = memnew( Button("Add..") );
addtr->connect("pressed",this,"_translation_res_file_open");
thb->add_child(addtr);
MarginContainer *tmc = memnew( MarginContainer );
tvb->add_child(tmc);
tmc->set_v_size_flags(SIZE_EXPAND_FILL);
translation_remap = memnew( Tree );
translation_remap->set_v_size_flags(SIZE_EXPAND_FILL);
translation_remap->connect("cell_selected",this,"_translation_res_select");
tmc->add_child(translation_remap);
translation_remap->connect("button_pressed",this,"_translation_res_delete");
translation_res_file_open=memnew( FileDialog );
add_child(translation_res_file_open);
translation_res_file_open->set_mode(FileDialog::MODE_OPEN_FILE);
translation_res_file_open->connect("file_selected",this,"_translation_res_add");
thb = memnew( HBoxContainer);
tvb->add_child(thb);
thb->add_child( memnew( Label("Remaps by Locale:")));
thb->add_spacer();
addtr = memnew( Button("Add..") );
addtr->connect("pressed",this,"_translation_res_option_file_open");
translation_res_option_add_button=addtr;
thb->add_child(addtr);
tmc = memnew( MarginContainer );
tvb->add_child(tmc);
tmc->set_v_size_flags(SIZE_EXPAND_FILL);
translation_remap_options = memnew( Tree );
translation_remap_options->set_v_size_flags(SIZE_EXPAND_FILL);
tmc->add_child(translation_remap_options);
translation_remap_options->set_columns(2);
translation_remap_options->set_column_title(0,"Path");
translation_remap_options->set_column_title(1,"Locale");
translation_remap_options->set_column_titles_visible(true);
translation_remap_options->set_column_expand(0,true);
translation_remap_options->set_column_expand(1,false);
translation_remap_options->set_column_min_width(1,200);
translation_remap_options->connect("item_edited",this,"_translation_res_option_changed");
translation_remap_options->connect("button_pressed",this,"_translation_res_option_delete");
translation_res_option_file_open=memnew( FileDialog );
add_child(translation_res_option_file_open);
translation_res_option_file_open->set_mode(FileDialog::MODE_OPEN_FILE);
translation_res_option_file_open->connect("file_selected",this,"_translation_res_option_add");
}
{
VBoxContainer *avb = memnew( VBoxContainer );
tab_container->add_child(avb);
avb->set_name("AutoLoad");
HBoxContainer *ahb = memnew( HBoxContainer);
avb->add_child(ahb);
VBoxContainer *avb_name = memnew( VBoxContainer );
avb_name->set_h_size_flags(SIZE_EXPAND_FILL);
autoload_add_name = memnew(LineEdit);
avb_name->add_margin_child("Node Name:",autoload_add_name);
ahb->add_child(avb_name);
VBoxContainer *avb_path = memnew( VBoxContainer );
avb_path->set_h_size_flags(SIZE_EXPAND_FILL);
HBoxContainer *ahb_path = memnew( HBoxContainer );
autoload_add_path = memnew(LineEdit);
autoload_add_path->set_h_size_flags(SIZE_EXPAND_FILL);
ahb_path->add_child(autoload_add_path);
Button *browseaa = memnew( Button("..") );
ahb_path->add_child(browseaa);
browseaa->connect("pressed",this,"_autoload_file_open");
Button *addaa = memnew( Button("Add") );
ahb_path->add_child(addaa);
addaa->connect("pressed",this,"_autoload_add");
avb_path->add_margin_child("Path:",ahb_path);
ahb->add_child(avb_path);
autoload_list = memnew( Tree );
autoload_list->set_v_size_flags(SIZE_EXPAND_FILL);
avb->add_margin_child("List:",autoload_list,true);
autoload_file_open=memnew( FileDialog );
add_child(autoload_file_open);
autoload_file_open->set_mode(FileDialog::MODE_OPEN_FILE);
autoload_file_open->connect("file_selected",this,"_autoload_file_callback");
autoload_list->set_columns(2);
autoload_list->set_column_titles_visible(true);
autoload_list->set_column_title(0,"name");
autoload_list->set_column_title(1,"path");
autoload_list->connect("button_pressed",this,"_autoload_delete");
}
timer = memnew( Timer );
timer->set_wait_time(1.5);
timer->connect("timeout",Globals::get_singleton(),"save");
timer->set_one_shot(true);
add_child(timer);
updating_translations=false;
/*
Control * es = memnew( Control );
es->set_name("Export");
tab_container->add_child(es);
export_settings = memnew( ProjectExportSettings );
es->add_child(export_settings);
export_settings->set_area_as_parent_rect();
export_settings->set_anchor_and_margin(MARGIN_BOTTOM,ANCHOR_END, 35 );
*/
}
ConnectionsDock::ConnectionsDock(EditorNode *p_editor) {
editor = p_editor;
set_name(TTR("Signals"));
VBoxContainer *vbc = this;
tree = memnew(Tree);
tree->set_columns(1);
tree->set_select_mode(Tree::SELECT_ROW);
tree->set_hide_root(true);
vbc->add_child(tree);
tree->set_v_size_flags(SIZE_EXPAND_FILL);
tree->set_allow_rmb_select(true);
connect_button = memnew(Button);
connect_button->set_text(TTR("Connect"));
HBoxContainer *hb = memnew(HBoxContainer);
vbc->add_child(hb);
hb->add_spacer();
hb->add_child(connect_button);
connect_button->connect("pressed", this, "_connect_pressed");
connect_dialog = memnew(ConnectDialog);
connect_dialog->set_as_toplevel(true);
add_child(connect_dialog);
disconnect_all_dialog = memnew(ConfirmationDialog);
disconnect_all_dialog->set_as_toplevel(true);
add_child(disconnect_all_dialog);
disconnect_all_dialog->connect("confirmed", this, "_disconnect_all");
disconnect_all_dialog->set_text(TTR("Are you sure you want to remove all connections from this signal?"));
signal_menu = memnew(PopupMenu);
add_child(signal_menu);
signal_menu->connect("id_pressed", this, "_handle_signal_menu_option");
signal_menu->add_item(TTR("Connect..."), CONNECT);
signal_menu->add_item(TTR("Disconnect All"), DISCONNECT_ALL);
slot_menu = memnew(PopupMenu);
add_child(slot_menu);
slot_menu->connect("id_pressed", this, "_handle_slot_menu_option");
slot_menu->add_item(TTR("Edit..."), EDIT);
slot_menu->add_item(TTR("Go To Method"), GO_TO_SCRIPT);
slot_menu->add_item(TTR("Disconnect"), DISCONNECT);
/*
node_only->set_anchor( MARGIN_TOP, ANCHOR_END );
node_only->set_anchor( MARGIN_BOTTOM, ANCHOR_END );
node_only->set_anchor( MARGIN_RIGHT, ANCHOR_END );
node_only->set_begin( Point2( 20,51) );
node_only->set_end( Point2( 10,44) );
*/
connect_dialog->connect("connected", this, "_make_or_edit_connection");
tree->connect("item_selected", this, "_tree_item_selected");
tree->connect("item_activated", this, "_tree_item_activated");
tree->connect("item_rmb_selected", this, "_rmb_pressed");
add_constant_override("separation", 3 * EDSCALE);
}
MaterialEditor::MaterialEditor() {
vc = memnew(ViewportContainer);
vc->set_stretch(true);
add_child(vc);
vc->set_anchors_and_margins_preset(PRESET_WIDE);
viewport = memnew(Viewport);
Ref<World> world;
world.instance();
viewport->set_world(world); //use own world
vc->add_child(viewport);
viewport->set_disable_input(true);
viewport->set_transparent_background(true);
viewport->set_msaa(Viewport::MSAA_4X);
camera = memnew(Camera);
camera->set_transform(Transform(Basis(), Vector3(0, 0, 3)));
camera->set_perspective(45, 0.1, 10);
camera->make_current();
viewport->add_child(camera);
light1 = memnew(DirectionalLight);
light1->set_transform(Transform().looking_at(Vector3(-1, -1, -1), Vector3(0, 1, 0)));
viewport->add_child(light1);
light2 = memnew(DirectionalLight);
light2->set_transform(Transform().looking_at(Vector3(0, 1, 0), Vector3(0, 0, 1)));
light2->set_color(Color(0.7, 0.7, 0.7));
viewport->add_child(light2);
sphere_instance = memnew(MeshInstance);
viewport->add_child(sphere_instance);
box_instance = memnew(MeshInstance);
viewport->add_child(box_instance);
Transform box_xform;
box_xform.basis.rotate(Vector3(1, 0, 0), Math::deg2rad(25.0));
box_xform.basis = box_xform.basis * Basis().rotated(Vector3(0, 1, 0), Math::deg2rad(-25.0));
box_xform.basis.scale(Vector3(0.8, 0.8, 0.8));
box_xform.origin.y = 0.2;
box_instance->set_transform(box_xform);
sphere_mesh.instance();
sphere_instance->set_mesh(sphere_mesh);
box_mesh.instance();
box_instance->set_mesh(box_mesh);
box_instance->hide();
set_custom_minimum_size(Size2(1, 150) * EDSCALE);
HBoxContainer *hb = memnew(HBoxContainer);
add_child(hb);
hb->set_anchors_and_margins_preset(Control::PRESET_WIDE, Control::PRESET_MODE_MINSIZE, 2);
VBoxContainer *vb_shape = memnew(VBoxContainer);
hb->add_child(vb_shape);
sphere_switch = memnew(TextureButton);
sphere_switch->set_toggle_mode(true);
sphere_switch->set_pressed(true);
vb_shape->add_child(sphere_switch);
sphere_switch->connect("pressed", this, "_button_pressed", varray(sphere_switch));
box_switch = memnew(TextureButton);
box_switch->set_toggle_mode(true);
box_switch->set_pressed(false);
vb_shape->add_child(box_switch);
box_switch->connect("pressed", this, "_button_pressed", varray(box_switch));
hb->add_spacer();
VBoxContainer *vb_light = memnew(VBoxContainer);
hb->add_child(vb_light);
light_1_switch = memnew(TextureButton);
light_1_switch->set_toggle_mode(true);
vb_light->add_child(light_1_switch);
light_1_switch->connect("pressed", this, "_button_pressed", varray(light_1_switch));
light_2_switch = memnew(TextureButton);
light_2_switch->set_toggle_mode(true);
vb_light->add_child(light_2_switch);
light_2_switch->connect("pressed", this, "_button_pressed", varray(light_2_switch));
first_enter = true;
}
