godotengine
/
godot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
godot/tools/editor/plugins/shader_graph_editor_plugin.cpp

1110 lines
31 KiB
C++
Raw Blame History

/*************************************************************************/
/* shader_graph_editor_plugin.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#include "shader_graph_editor_plugin.h"
#if 0
#include "scene/gui/menu_button.h"
#include "scene/gui/panel.h"
class _ShaderTester : public ShaderCodeGenerator {
public:
Set<int> *_set;
virtual void begin() {}
virtual Error add_node(VS::ShaderNodeType p_type,int p_node_pos,int p_id,const Variant& p_param,const Vector<int>& p_in_connections,const Vector<int>& p_out_connections,const Vector<int>& p_out_connection_outputs) { if (_set) _set->insert(p_id); return OK; }
virtual void end() {}
_ShaderTester() { _set=NULL; }
};
void ShaderEditor::edit(Ref<Shader> p_shader) {
shader=p_shader;
if (shader.is_null())
hide();
else {
_read_shader_graph();
}
}
Size2 ShaderEditor::_get_maximum_size() {
Size2 max;
for(List<int>::Element *E=order.front();E;E=E->next()) {
Point2 pos = Point2( shader_graph.node_get_pos_x(E->get()), shader_graph.node_get_pos_y(E->get()) );
if (click_type==CLICK_NODE && click_node==E->get()) {
pos+=click_motion-click_pos;
}
pos+=get_node_size(E->get());
if (pos.x>max.x)
max.x=pos.x;
if (pos.y>max.y)
max.y=pos.y;
}
return max;
}
Size2 ShaderEditor::get_node_size(int p_node) const {
VisualServer::ShaderNodeType type=shader_graph.node_get_type(p_node);
Ref<StyleBox> style = get_stylebox("panel","PopupMenu");
Ref<Font> font = get_font("font","PopupMenu");
Color font_color = get_color("font_color","PopupMenu");
Size2 size = style->get_minimum_size();
int count=1; // title
count += VisualServer::shader_get_input_count( type) + VisualServer::shader_get_output_count( type);
float max_w=font->get_string_size( VisualServer::shader_node_get_type_info(type).name ).width;
for(int i=0;i<VisualServer::shader_get_input_count(type);i++)
max_w = MAX( max_w, font->get_string_size( VisualServer::shader_get_input_name(type,i) ).width );
for(int i=0;i<VisualServer::shader_get_output_count(type);i++)
max_w = MAX( max_w, font->get_string_size( VisualServer::shader_get_output_name(type,i) ).width );
switch(type) {
case VS::NODE_IN:
case VS::NODE_OUT:
case VS::NODE_VEC_IN:
case VS::NODE_VEC_OUT:
case VS::NODE_PARAMETER:
case VS::NODE_VEC_PARAMETER:
case VS::NODE_COLOR_PARAMETER:
case VS::NODE_TEXTURE_PARAMETER:
case VS::NODE_TEXTURE_2D_PARAMETER:
case VS::NODE_TEXTURE_CUBE_PARAMETER:
case VS::NODE_TRANSFORM_PARAMETER:
case VS::NODE_LABEL: {
max_w=MAX( max_w, font->get_string_size( shader_graph.node_get_param(p_node) ).width );
count++;
} break;
case VS::NODE_TIME:
case VS::NODE_CONSTANT:
case VS::NODE_VEC_CONSTANT:
case VS::NODE_COLOR_CONSTANT:
case VS::NODE_TRANSFORM_CONSTANT: {
count++;
} break;
case VS::NODE_TEXTURE:
case VS::NODE_VEC_TEXTURE_2D:
case VS::NODE_VEC_TEXTURE_CUBE: {
RefPtr res = shader_graph.node_get_param(p_node);
Ref<Texture> texture = res;
if (texture.is_null() || texture->get_width()==0) {
size.y+=max_w;
} else {
size.y+=max_w * texture->get_height() / texture->get_width();
}
} break;
default: {}
}
size.x+=max_w;
size.y+=count*(font->get_height()+get_constant("vseparation","PopupMenu"));
return size;
}
Error ShaderEditor::validate_graph() {
_ShaderTester st;
active_nodes.clear();
st._set=&active_nodes;
return shader_graph.generate(&st);
}
void ShaderEditor::_draw_node(int p_node) {
VisualServer::ShaderNodeType type=shader_graph.node_get_type(p_node);
Ref<StyleBox> style = active_nodes.has(p_node)?get_stylebox("panel","PopupMenu"):get_stylebox("panel_disabled","PopupMenu");
Ref<Font> font = get_font("font","PopupMenu");
Color font_color = get_color("font_color","PopupMenu");
Color font_color_title = get_color("font_color_hover","PopupMenu");
Size2 size=get_node_size(p_node);
Point2 pos = Point2( shader_graph.node_get_pos_x(p_node), shader_graph.node_get_pos_y(p_node) )-offset;
if (click_type==CLICK_NODE && click_node==p_node) {
pos+=click_motion-click_pos;
}
RID ci = get_canvas_item();
style->draw(ci,Rect2(pos,size));
Point2 ofs=style->get_offset()+pos;
Point2 ascent=Point2(0,font->get_ascent());
float w = size.width-style->get_minimum_size().width;
float h = font->get_height()+get_constant("vseparation","PopupMenu");
font->draw_halign( ci, ofs+ascent, HALIGN_CENTER,w, VisualServer::shader_node_get_type_info(type).name,font_color_title);
ofs.y+=h;
Ref<Texture> vec_icon = get_icon("NodeVecSlot","EditorIcons");
Ref<Texture> real_icon = get_icon("NodeRealSlot","EditorIcons");
float icon_h_ofs = Math::floor(( font->get_height()-vec_icon->get_height())/2.0 )+1;
for(int i=0;i<VisualServer::shader_get_input_count(type);i++) {
String name = VisualServer::shader_get_input_name(type,i);
font->draw_halign( ci, ofs+ascent, HALIGN_LEFT,w, name,font_color);
Ref<Texture> icon = VisualServer::shader_is_input_vector(type,i)?vec_icon:real_icon;
icon->draw(ci,ofs+Point2(-real_icon->get_width(),icon_h_ofs));
ofs.y+=h;
}
for(int i=0;i<VisualServer::shader_get_output_count(type);i++) {
String name = VisualServer::shader_get_output_name(type,i);
font->draw_halign( ci, ofs+ascent, HALIGN_RIGHT,w, name,font_color);
Ref<Texture> icon = VisualServer::shader_is_output_vector(type,i)?vec_icon:real_icon;
icon->draw(ci,ofs+Point2(w,icon_h_ofs));
ofs.y+=h;
}
switch(type) {
case VS::NODE_IN:
case VS::NODE_OUT:
case VS::NODE_PARAMETER:
case VS::NODE_VEC_IN:
case VS::NODE_COLOR_PARAMETER:
case VS::NODE_VEC_OUT:
case VS::NODE_TEXTURE_PARAMETER:
case VS::NODE_TEXTURE_2D_PARAMETER:
case VS::NODE_TEXTURE_CUBE_PARAMETER:
case VS::NODE_TRANSFORM_CONSTANT:
case VS::NODE_TRANSFORM_PARAMETER:
case VS::NODE_VEC_PARAMETER:
case VS::NODE_LABEL: {
String text = shader_graph.node_get_param(p_node);
font->draw_halign( ci, ofs+ascent, HALIGN_CENTER,w, text,font_color);
} break;
case VS::NODE_TIME:
case VS::NODE_CONSTANT: {
String text = rtos(shader_graph.node_get_param(p_node));
font->draw_halign( ci, ofs+ascent, HALIGN_CENTER,w, text,font_color);
} break;
case VS::NODE_VEC_CONSTANT: {
String text = Vector3(shader_graph.node_get_param(p_node));
font->draw_halign( ci, ofs+ascent, HALIGN_CENTER,w, text,font_color);
} break;
case VS::NODE_COLOR_CONSTANT: {
Color color = shader_graph.node_get_param(p_node);
Rect2 r(ofs,Size2(w,h));
VisualServer::get_singleton()->canvas_item_add_rect(ci,r,color);
} break;
case VS::NODE_TEXTURE:
case VS::NODE_VEC_TEXTURE_2D:
case VS::NODE_VEC_TEXTURE_CUBE: {
Rect2 r(ofs,Size2(w,(pos.y+size.y-style->get_margin(MARGIN_BOTTOM))-ofs.y));
Vector<Point2> points;
Vector<Point2> uvs;
points.resize(4);
uvs.resize(4);
points[0]=r.pos;
points[1]=r.pos+Point2(r.size.x,0);
points[2]=r.pos+r.size;
points[3]=r.pos+Point2(0,r.size.y);
uvs[0]=Point2(0,0);
uvs[1]=Point2(1,0);
uvs[2]=Point2(1,1);
uvs[3]=Point2(0,1);
Ref<Texture> texture = shader_graph.node_get_param(p_node).operator RefPtr();
if (texture.is_null() || texture->get_width()==0) {
texture=get_icon("Click2Edit","EditorIcons");
}
VisualServer::get_singleton()->canvas_item_add_primitive(ci,points,Vector<Color>(),uvs,texture->get_rid());
} break;
default: {}
}
}
void ShaderEditor::_node_param_changed() {
shader_graph.node_set_param( click_node,property_editor->get_variant() );
update();
_write_shader_graph();
}
ShaderEditor::ClickType ShaderEditor::_locate_click(const Point2& p_click,int *p_node_id,int *p_slot_index) const {
Ref<StyleBox> style = get_stylebox("panel","PopupMenu");
Ref<Texture> real_icon = get_icon("NodeRealSlot","EditorIcons");
Ref<Font> font = get_font("font","PopupMenu");
float h = font->get_height()+get_constant("vseparation","PopupMenu");
float extra_left=MAX( real_icon->get_width()-style->get_margin(MARGIN_LEFT), 0 );
float extra_right=MAX( real_icon->get_width()-style->get_margin(MARGIN_RIGHT), 0 );
for(const List<int>::Element *E=order.back();E;E=E->prev()) {
Size2 size=get_node_size(E->get());
size.width+=extra_left+extra_right;
Point2 pos = Point2( shader_graph.node_get_pos_x(E->get()), shader_graph.node_get_pos_y(E->get()) )-offset;
pos.x-=extra_left;
Rect2 rect( pos, size );
if (!rect.has_point(p_click))
continue;
VisualServer::ShaderNodeType type=shader_graph.node_get_type(E->get());
if (p_node_id)
*p_node_id=E->get();
float y=p_click.y-(pos.y+style->get_margin(MARGIN_TOP));
if (y<h)
return CLICK_NODE;
y-=h;
for(int i=0;i<VisualServer::shader_get_input_count(type);i++) {
if (y<h) {
if (p_slot_index)
*p_slot_index=i;
return CLICK_INPUT_SLOT;
}
y-=h;
}
for(int i=0;i<VisualServer::shader_get_output_count(type);i++) {
if (y<h) {
if (p_slot_index)
*p_slot_index=i;
return CLICK_OUTPUT_SLOT;
}
y-=h;
}
if (p_click.y<(rect.pos.y+rect.size.height-style->get_margin(MARGIN_BOTTOM)))
return CLICK_PARAMETER;
else
return CLICK_NODE;
}
return CLICK_NONE;
}
Point2 ShaderEditor::_get_slot_pos(int p_node_id,bool p_input,int p_slot) {
Ref<StyleBox> style = get_stylebox("panel","PopupMenu");
float w = get_node_size(p_node_id).width;
Ref<Font> font = get_font("font","PopupMenu");
float h = font->get_height()+get_constant("vseparation","PopupMenu");
Ref<Texture> vec_icon = get_icon("NodeVecSlot","EditorIcons");
Point2 pos = Point2( shader_graph.node_get_pos_x(p_node_id), shader_graph.node_get_pos_y(p_node_id) )-offset;
pos+=style->get_offset();
pos.y+=h;
if(p_input) {
pos.y+=p_slot*h;
pos+=Point2( -vec_icon->get_width()/2.0, h/2.0).floor();
return pos;
} else {
pos.y+=VisualServer::shader_get_input_count( shader_graph.node_get_type(p_node_id ) )*h;
}
pos.y+=p_slot*h;
pos+=Point2( w-style->get_minimum_size().width+vec_icon->get_width()/2.0, h/2.0).floor();
return pos;
}
void ShaderEditor::_node_edit_property(int p_node) {
Ref<StyleBox> style = get_stylebox("panel","PopupMenu");
Size2 size = get_node_size(p_node);
Point2 pos = Point2( shader_graph.node_get_pos_x(p_node), shader_graph.node_get_pos_y(p_node) )-offset;
VisualServer::ShaderNodeType type=shader_graph.node_get_type(p_node);
PropertyInfo ph = VisualServer::get_singleton()->shader_node_get_type_info(type);
if (ph.type==Variant::NIL)
return;
if (ph.type==Variant::_RID)
ph.type=Variant::OBJECT;
property_editor->edit(NULL,ph.name,ph.type,shader_graph.node_get_param(p_node),ph.hint,ph.hint_string);
Point2 popup_pos=Point2( pos.x+(size.width-property_editor->get_size().width)/2.0,pos.y+(size.y-style->get_margin(MARGIN_BOTTOM))).floor();
popup_pos+=get_global_pos();
property_editor->set_pos(popup_pos);
property_editor->popup();
}
bool ShaderEditor::has_point(const Point2& p_point) const {
int n,si;
return _locate_click(p_point,&n,&si)!=CLICK_NONE;
}
void ShaderEditor::_input_event(InputEvent p_event) {
switch(p_event.type) {
case InputEvent::MOUSE_BUTTON: {
if (p_event.mouse_button.pressed) {
if (p_event.mouse_button.button_index==1) {
click_pos=Point2(p_event.mouse_button.x,p_event.mouse_button.y);
click_motion=click_pos;
click_type = _locate_click(click_pos,&click_node,&click_slot);
if( click_type!=CLICK_NONE) {
order.erase(click_node);
order.push_back(click_node);
update();
}
switch(click_type) {
case CLICK_INPUT_SLOT: {
click_pos=_get_slot_pos(click_node,true,click_slot);
} break;
case CLICK_OUTPUT_SLOT: {
click_pos=_get_slot_pos(click_node,false,click_slot);
} break;
case CLICK_PARAMETER: {
//open editor
_node_edit_property(click_node);
} break;
}
}
if (p_event.mouse_button.button_index==2) {
if (click_type!=CLICK_NONE) {
click_type=CLICK_NONE;
update();
} else {
// try to disconnect/remove
Point2 rclick_pos=Point2(p_event.mouse_button.x,p_event.mouse_button.y);
rclick_type = _locate_click(rclick_pos,&rclick_node,&rclick_slot);
if (rclick_type==CLICK_INPUT_SLOT || rclick_type==CLICK_OUTPUT_SLOT) {
node_popup->clear();
node_popup->add_item("Disconnect",NODE_DISCONNECT);
node_popup->set_pos(rclick_pos);
node_popup->popup();
}
if (rclick_type==CLICK_NODE) {
node_popup->clear();
node_popup->add_item("Remove",NODE_ERASE);
node_popup->set_pos(rclick_pos);
node_popup->popup();
}
}
}
} else {
if (p_event.mouse_button.button_index==1 && click_type!=CLICK_NONE) {
switch(click_type) {
case CLICK_INPUT_SLOT:
case CLICK_OUTPUT_SLOT: {
Point2 dst_click_pos=Point2(p_event.mouse_button.x,p_event.mouse_button.y);
int id;
int slot;
ClickType dst_click_type = _locate_click(dst_click_pos,&id,&slot);
if (dst_click_type==CLICK_INPUT_SLOT && click_type==CLICK_OUTPUT_SLOT) {
shader_graph.connect(click_node,click_slot,id,slot);
Error err = validate_graph();
if (err==ERR_CYCLIC_LINK)
shader_graph.disconnect(click_node,click_slot,id,slot);
_write_shader_graph();
}
if (click_type==CLICK_INPUT_SLOT && dst_click_type==CLICK_OUTPUT_SLOT) {
shader_graph.connect(id,slot,click_node,click_slot);
Error err = validate_graph();
if (err==ERR_CYCLIC_LINK)
shader_graph.disconnect(id,slot,click_node,click_slot);
_write_shader_graph();
}
} break;
case CLICK_NODE: {
int new_x=shader_graph.node_get_pos_x(click_node)+(click_motion.x-click_pos.x);
int new_y=shader_graph.node_get_pos_y(click_node)+(click_motion.y-click_pos.y);
shader_graph.node_set_pos(click_node,new_x,new_y);
_write_shader_graph();
} break;
}
click_type=CLICK_NONE;
update();
}
}
}
case InputEvent::MOUSE_MOTION: {
if (p_event.mouse_motion.button_mask&1 && click_type!=CLICK_NONE) {
click_motion=Point2(p_event.mouse_button.x,p_event.mouse_button.y);
update();
}
} break;
}
}
void ShaderEditor::_notification(int p_what) {
switch(p_what) {
case NOTIFICATION_DRAW: {
_update_scrollbars();
//VisualServer::get_singleton()->canvas_item_add_rect(get_canvas_item(),Rect2(Point2(),get_size()),Color(0,0,0,1));
for(List<int>::Element *E=order.front();E;E=E->next()) {
_draw_node(E->get());
}
if (click_type==CLICK_INPUT_SLOT || click_type==CLICK_OUTPUT_SLOT) {
VisualServer::get_singleton()->canvas_item_add_line(get_canvas_item(),click_pos,click_motion,Color(0.5,1,0.5,0.8),2);
}
List<ShaderGraph::Connection> connections = shader_graph.get_connection_list();
for(List<ShaderGraph::Connection>::Element *E=connections.front();E;E=E->next()) {
const ShaderGraph::Connection &c=E->get();
Point2 source = _get_slot_pos(c.src_id,false,c.src_slot);
Point2 dest = _get_slot_pos(c.dst_id,true,c.dst_slot);
bool vec = VisualServer::shader_is_input_vector( shader_graph.node_get_type(c.dst_id), c.dst_slot );
Color col = vec?Color(1,0.5,0.5,0.8):Color(1,1,0.5,0.8);
if (click_type==CLICK_NODE && click_node==c.src_id) {
source+=click_motion-click_pos;
}
if (click_type==CLICK_NODE && click_node==c.dst_id) {
dest+=click_motion-click_pos;
}
VisualServer::get_singleton()->canvas_item_add_line(get_canvas_item(),source,dest,col,2);
}
} break;
}
}
void ShaderEditor::_update_scrollbars() {
Size2 size = get_size();
Size2 hmin = h_scroll->get_minimum_size();
Size2 vmin = v_scroll->get_minimum_size();
v_scroll->set_begin( Point2(size.width - vmin.width, 0) );
v_scroll->set_end( Point2(size.width, size.height) );
h_scroll->set_begin( Point2( 0, size.height - hmin.height) );
h_scroll->set_end( Point2(size.width-vmin.width, size.height) );
Size2 min = _get_maximum_size();
if (min.height < size.height - hmin.height) {
v_scroll->hide();
offset.y=0;
} else {
v_scroll->show();
v_scroll->set_max(min.height);
v_scroll->set_page(size.height - hmin.height);
offset.y=v_scroll->get_val();
}
if (min.width < size.width - vmin.width) {
h_scroll->hide();
offset.x=0;
} else {
h_scroll->show();
h_scroll->set_max(min.width);
h_scroll->set_page(size.width - vmin.width);
offset.x=h_scroll->get_val();
}
}
void ShaderEditor::_scroll_moved() {
offset.x=h_scroll->get_val();
offset.y=v_scroll->get_val();
update();
}
void ShaderEditor::_bind_methods() {
ObjectTypeDB::bind_method( "_node_menu_item", &ShaderEditor::_node_menu_item );
ObjectTypeDB::bind_method( "_node_add_callback", &ShaderEditor::_node_add_callback );
ObjectTypeDB::bind_method( "_input_event", &ShaderEditor::_input_event );
ObjectTypeDB::bind_method( "_node_param_changed", &ShaderEditor::_node_param_changed );
ObjectTypeDB::bind_method( "_scroll_moved", &ShaderEditor::_scroll_moved );
ObjectTypeDB::bind_method( "_vertex_item", &ShaderEditor::_vertex_item );
ObjectTypeDB::bind_method( "_fragment_item", &ShaderEditor::_fragment_item );
ObjectTypeDB::bind_method( "_post_item", &ShaderEditor::_post_item );
}
void ShaderEditor::_read_shader_graph() {
shader_graph.clear();;
order.clear();
List<int> nodes;
shader->get_node_list(&nodes);
int larger_id=0;
for(List<int>::Element *E=nodes.front();E;E=E->next()) {
if (E->get() > larger_id)
larger_id = E->get();
shader_graph.node_add( (VS::ShaderNodeType)shader->node_get_type(E->get()), E->get() );
shader_graph.node_set_param( E->get(), shader->node_get_param( E->get() ) );
Point2 pos = shader->node_get_pos(E->get());
shader_graph.node_set_pos( E->get(), pos.x,pos.y );
order.push_back(E->get());
}
last_id=larger_id+1;
List<Shader::Connection> connections;
shader->get_connections(&connections);
for(List<Shader::Connection>::Element *E=connections.front();E;E=E->next()) {
Shader::Connection &c=E->get();
shader_graph.connect(c.src_id,c.src_slot,c.dst_id,c.dst_slot);
}
validate_graph();
update();
}
void ShaderEditor::_write_shader_graph() {
shader->clear();
List<int> nodes;
shader_graph.get_node_list(&nodes);
for(List<int>::Element *E=nodes.front();E;E=E->next()) {
shader->node_add((Shader::NodeType)shader_graph.node_get_type(E->get()),E->get());
shader->node_set_param(E->get(),shader_graph.node_get_param(E->get()));
shader->node_set_pos(E->get(),Point2( shader_graph.node_get_pos_x(E->get()),shader_graph.node_get_pos_y(E->get()) ) );
}
List<ShaderGraph::Connection> connections = shader_graph.get_connection_list();
for(List<ShaderGraph::Connection>::Element *E=connections.front();E;E=E->next()) {
const ShaderGraph::Connection &c=E->get();
shader->connect(c.src_id,c.src_slot,c.dst_id,c.dst_slot);
}
}
void ShaderEditor::_add_node_from_text(const String& p_text) {
ERR_FAIL_COND( p_text.get_slice_count(" ") != 3 );
bool input = p_text.get_slice(" ",0)=="In:";
String name = p_text.get_slice(" ",1);
bool vec = p_text.get_slice(" ",2)=="(vec3)";
_node_add( input?
( vec? VisualServer::NODE_VEC_IN : VisualServer::NODE_IN ) :
( vec? VisualServer::NODE_VEC_OUT : VisualServer::NODE_OUT ) );
shader_graph.node_set_param( last_id-1,name );
_write_shader_graph();
}
void ShaderEditor::_vertex_item(int p_item) {
_add_node_from_text(vertex_popup->get_item_text(p_item));
}
void ShaderEditor::_fragment_item(int p_item) {
_add_node_from_text(fragment_popup->get_item_text(p_item));
}
void ShaderEditor::_post_item(int p_item) {
_add_node_from_text(post_popup->get_item_text(p_item));
}
void ShaderEditor::_node_menu_item(int p_item) {
switch(p_item) {
case GRAPH_ADD_NODE: {
add_popup->popup_centered_ratio();
validate_graph();
} break;
case NODE_DISCONNECT: {
if (rclick_type==CLICK_INPUT_SLOT) {
List<ShaderGraph::Connection> connections = shader_graph.get_connection_list();
for(List<ShaderGraph::Connection>::Element *E=connections.front();E;E=E->next()) {
const ShaderGraph::Connection &c=E->get();
if( c.dst_id==rclick_node && c.dst_slot==rclick_slot) {
shader_graph.disconnect(c.src_id,c.src_slot,c.dst_id,c.dst_slot);
}
}
update();
_write_shader_graph();
validate_graph();
}
if (rclick_type==CLICK_OUTPUT_SLOT) {
List<ShaderGraph::Connection> connections = shader_graph.get_connection_list();
for(List<ShaderGraph::Connection>::Element *E=connections.front();E;E=E->next()) {
const ShaderGraph::Connection &c=E->get();
if( c.src_id==rclick_node && c.src_slot==rclick_slot) {
shader_graph.disconnect(c.src_id,c.src_slot,c.dst_id,c.dst_slot);
}
}
update();
_write_shader_graph();
validate_graph();
}
} break;
case NODE_ERASE: {
order.erase(rclick_node);
shader_graph.node_remove(rclick_node);
update();
_write_shader_graph();
validate_graph();
} break;
case GRAPH_CLEAR: {
order.clear();
shader_graph.clear();
last_id=1;
last_x=20;
last_y=20;
update();
_write_shader_graph();
validate_graph();
} break;
}
}
void ShaderEditor::_node_add(VisualServer::ShaderNodeType p_type) {
shader_graph.node_add(p_type,last_id );
shader_graph.node_set_pos(last_id ,last_x,last_y);
String test_param;
switch(p_type) {
case VS::NODE_PARAMETER: {
test_param="param";
} break;
case VS::NODE_VEC_PARAMETER: {
test_param="vec";
} break;
case VS::NODE_COLOR_PARAMETER: {
test_param="color";
} break;
case VS::NODE_TEXTURE_PARAMETER: {
test_param="tex";
} break;
case VS::NODE_TEXTURE_2D_PARAMETER: {
test_param="tex2D";
} break;
case VS::NODE_TEXTURE_CUBE_PARAMETER: {
test_param="cubemap";
} break;
case VS::NODE_TRANSFORM_PARAMETER: {
test_param="xform";
} break;
case VS::NODE_LABEL: {
test_param="label";
} break;
}
if(test_param!="") {
int iter=0;
List<int> l;
shader_graph.get_node_list(&l);
bool found;
String test;
do {
iter++;
test=test_param;
if (iter>1)
test+="_"+itos(iter);
found=false;
for(List<int>::Element *E=l.front();E;E=E->next()) {
String param = shader_graph.node_get_param( E->get() );
if (param==test) {
found=true;
break;
}
}
} while (found);
shader_graph.node_set_param(last_id,test);
}
order.push_back(last_id);
last_x+=10;
last_y+=10;
last_id++;
last_x=last_x % (int)get_size().width;
last_y=last_y % (int)get_size().height;
update();
add_popup->hide();;
_write_shader_graph();
}
void ShaderEditor::_node_add_callback() {
TreeItem * item = add_types->get_selected();
ERR_FAIL_COND(!item);
_node_add((VisualServer::ShaderNodeType)(int)item->get_metadata(0));
add_popup->hide() ;
}
ShaderEditor::ShaderEditor() {
set_focus_mode(FOCUS_ALL);
Panel* menu_panel = memnew( Panel );
menu_panel->set_anchor( MARGIN_RIGHT, Control::ANCHOR_END );
menu_panel->set_end( Point2(0,22) );
add_child( menu_panel );
PopupMenu *p;
List<PropertyInfo> defaults;
MenuButton* node_menu = memnew( MenuButton );
node_menu->set_text("Graph");
node_menu->set_pos( Point2( 5,0) );
menu_panel->add_child( node_menu );
p=node_menu->get_popup();
p->add_item("Add Node",GRAPH_ADD_NODE);
p->add_separator();
p->add_item("Clear",GRAPH_CLEAR);
p->connect("item_pressed", this,"_node_menu_item");
MenuButton* vertex_menu = memnew( MenuButton );
vertex_menu->set_text("Vertex");
vertex_menu->set_pos( Point2( 49,0) );
menu_panel->add_child( vertex_menu );
p=vertex_menu->get_popup();
defaults.clear();
VisualServer::shader_get_default_input_nodes(VisualServer::SHADER_VERTEX,&defaults);
int id=0;
for(int i=0;i<defaults.size();i++) {
p->add_item("In: "+defaults[i].name+(defaults[i].type==Variant::VECTOR3?" (vec3)":" (real)"),id++);
}
p->add_separator();
id++;
defaults.clear();
VisualServer::shader_get_default_output_nodes(VisualServer::SHADER_VERTEX,&defaults);
for(int i=0;i<defaults.size();i++) {
p->add_item("Out: "+defaults[i].name+(defaults[i].type==Variant::VECTOR3?" (vec3)":" (real)"),id++);
}
vertex_popup=p;
vertex_popup->connect("item_pressed", this,"_vertex_item");
MenuButton* fragment_menu = memnew( MenuButton );
fragment_menu->set_text("Fragment");
fragment_menu->set_pos( Point2( 95 ,0) );
menu_panel->add_child( fragment_menu );
p=fragment_menu->get_popup();
defaults.clear();
VisualServer::shader_get_default_input_nodes(VisualServer::SHADER_FRAGMENT,&defaults);
id=0;
for(int i=0;i<defaults.size();i++) {
p->add_item("In: "+defaults[i].name+(defaults[i].type==Variant::VECTOR3?" (vec3)":" (real)"),id++);
}
p->add_separator();
id++;
defaults.clear();
VisualServer::shader_get_default_output_nodes(VisualServer::SHADER_FRAGMENT,&defaults);
for(int i=0;i<defaults.size();i++) {
p->add_item("Out: "+defaults[i].name+(defaults[i].type==Variant::VECTOR3?" (vec3)":" (real)"),id++);
}
fragment_popup=p;
fragment_popup->connect("item_pressed", this,"_fragment_item");
MenuButton* post_menu = memnew( MenuButton );
post_menu->set_text("Post");
post_menu->set_pos( Point2( 161,0) );
menu_panel->add_child( post_menu );
p=post_menu->get_popup();
defaults.clear();
VisualServer::shader_get_default_input_nodes(VisualServer::SHADER_POST_PROCESS,&defaults);
id=0;
for(int i=0;i<defaults.size();i++) {
p->add_item("In: "+defaults[i].name+(defaults[i].type==Variant::VECTOR3?" (vec3)":" (real)"),id++);
}
p->add_separator();
id++;
defaults.clear();
VisualServer::shader_get_default_output_nodes(VisualServer::SHADER_POST_PROCESS,&defaults);
for(int i=0;i<defaults.size();i++) {
p->add_item("Out: "+defaults[i].name+(defaults[i].type==Variant::VECTOR3?" (vec3)":" (real)"),id++);
}
post_popup=p;
post_popup->connect("item_pressed", this,"_post_item");
/* add popup */
add_popup = memnew( Popup );
add_child(add_popup);
add_popup->set_as_toplevel(true);
Panel *add_panel = memnew( Panel );
add_popup->add_child(add_panel);
add_panel->set_area_as_parent_rect();
Label *add_label = memnew (Label );
add_label->set_pos(Point2(5,5));
add_label->set_text("Available Nodes:");
add_panel->add_child(add_label);
add_types = memnew( Tree );
add_types->set_anchor( MARGIN_RIGHT, ANCHOR_END );
add_types->set_anchor( MARGIN_BOTTOM, ANCHOR_END );
add_types->set_begin( Point2( 20,25 ) );
add_types->set_end( Point2( 10, 30 ) );
add_types->set_hide_root(true);
add_types->set_columns(4);
add_types->set_select_mode(Tree::SELECT_ROW);
TreeItem *add_types_root = add_types->create_item(NULL);
TreeItem *info_item = add_types->create_item(add_types_root);
for(int i=0;i<VisualServer::NODE_TYPE_MAX;i++) {
TreeItem *item = add_types->create_item(add_types_root);
PropertyInfo prop = VisualServer::shader_node_get_type_info((VisualServer::ShaderNodeType)i);
item->set_text(0,prop.name);
item->set_text(1,itos(VisualServer::shader_get_input_count((VisualServer::ShaderNodeType)i)));
item->set_text(2,itos(VisualServer::shader_get_output_count((VisualServer::ShaderNodeType)i)));
String hint = (prop.type==Variant::_RID)?prop.hint_string:Variant::get_type_name(prop.type);
item->set_text(3,hint);
item->set_metadata(0,i);
}
info_item->set_text(0,"::NODE::");
info_item->set_custom_color(0,Color(0.6,0.1,0.1));
info_item->set_text(1,"::INPUTS::");
info_item->set_custom_color(1,Color(0.6,0.1,0.1));
info_item->set_text(2,"::OUTPUTS::");
info_item->set_custom_color(2,Color(0.6,0.1,0.1));
info_item->set_text(3,"::PARAM::");
info_item->set_custom_color(3,Color(0.6,0.1,0.1));
info_item->set_selectable(0,false);
info_item->set_selectable(1,false);
info_item->set_selectable(2,false);
info_item->set_selectable(3,false);
add_panel->add_child(add_types);
add_confirm = memnew( Button );
add_confirm->set_anchor( MARGIN_LEFT, ANCHOR_END );
add_confirm->set_anchor( MARGIN_TOP, ANCHOR_END );
add_confirm->set_anchor( MARGIN_RIGHT, ANCHOR_END );
add_confirm->set_anchor( MARGIN_BOTTOM, ANCHOR_END );
add_confirm->set_begin( Point2( 75, 29 ) );
add_confirm->set_end( Point2( 10, 15 ) );
add_confirm->set_text("Add");
add_panel->add_child(add_confirm);
add_confirm->connect("pressed", this,"_node_add_callback");
last_id=1;
last_x=20;
last_y=20;
property_editor = memnew( CustomPropertyEditor );
add_child(property_editor);
property_editor->connect("variant_changed", this,"_node_param_changed");
h_scroll = memnew( HScrollBar );
v_scroll = memnew( VScrollBar );
add_child(h_scroll);
add_child(v_scroll);
h_scroll->connect("value_changed", this,"_scroll_moved");
v_scroll->connect("value_changed", this,"_scroll_moved");
node_popup= memnew(PopupMenu );
add_child(node_popup);
node_popup->set_as_toplevel(true);
node_popup->connect("item_pressed", this,"_node_menu_item");
}
void ShaderEditorPlugin::edit(Object *p_object) {
shader_editor->edit(p_object->cast_to<Shader>());
}
bool ShaderEditorPlugin::handles(Object *p_object) const {
return p_object->is_type("Shader");
}
void ShaderEditorPlugin::make_visible(bool p_visible) {
if (p_visible) {
shader_editor->show();
shader_editor->set_process(true);
} else {
shader_editor->hide();
shader_editor->set_process(false);
}
}
ShaderEditorPlugin::ShaderEditorPlugin(EditorNode *p_node) {
editor=p_node;
shader_editor = memnew( ShaderEditor );
editor->get_viewport()->add_child(shader_editor);
shader_editor->set_area_as_parent_rect();
shader_editor->hide();
}
ShaderEditorPlugin::~ShaderEditorPlugin()
{
}
#endif
Reference in New Issue View Git Blame Copy Permalink