2942 lines
93 KiB
C++
2942 lines
93 KiB
C++
/*************************************************************************/
|
|
/* shader_graph_editor_plugin.cpp */
|
|
/*************************************************************************/
|
|
/* This file is part of: */
|
|
/* GODOT ENGINE */
|
|
/* http://www.godotengine.org */
|
|
/*************************************************************************/
|
|
/* Copyright (c) 2007-2016 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"
|
|
|
|
|
|
#include "scene/gui/check_box.h"
|
|
#include "scene/gui/menu_button.h"
|
|
#include "scene/gui/panel.h"
|
|
#include "spatial_editor_plugin.h"
|
|
#include "os/keyboard.h"
|
|
#include "canvas_item_editor_plugin.h"
|
|
|
|
void GraphColorRampEdit::_input_event(const InputEvent& p_event) {
|
|
|
|
if (p_event.type==InputEvent::KEY && p_event.key.pressed && p_event.key.scancode==KEY_DELETE && grabbed!=-1) {
|
|
|
|
points.remove(grabbed);
|
|
grabbed=-1;
|
|
update();
|
|
emit_signal("ramp_changed");
|
|
accept_event();
|
|
}
|
|
|
|
if (p_event.type==InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index==1 && p_event.mouse_button.pressed) {
|
|
|
|
update();
|
|
int x = p_event.mouse_button.x;
|
|
int total_w = get_size().width-get_size().height-3;
|
|
if (x>total_w+3) {
|
|
|
|
if (grabbed==-1)
|
|
return;
|
|
Size2 ms = Size2(350, picker->get_combined_minimum_size().height+10);
|
|
picker->set_color(points[grabbed].color);
|
|
popup->set_pos(get_global_pos()-Size2(0,ms.height));
|
|
popup->set_size(ms);
|
|
popup->popup();
|
|
return;
|
|
}
|
|
|
|
|
|
float ofs = CLAMP(x/float(total_w),0,1);
|
|
|
|
grabbed=-1;
|
|
grabbing=true;
|
|
int pos=-1;
|
|
for(int i=0;i<points.size();i++) {
|
|
|
|
if (ABS(x-points[i].offset*total_w)<4) {
|
|
grabbed=i;
|
|
}
|
|
if (points[i].offset<ofs)
|
|
pos=i;
|
|
}
|
|
|
|
grabbed_at=ofs;
|
|
//grab or select
|
|
if (grabbed!=-1) {
|
|
return;
|
|
}
|
|
//insert
|
|
|
|
|
|
Point p;
|
|
p.offset=ofs;
|
|
|
|
Point prev;
|
|
Point next;
|
|
|
|
if (pos==-1) {
|
|
|
|
prev.color=Color(0,0,0);
|
|
prev.offset=0;
|
|
if (points.size()) {
|
|
next=points[0];
|
|
} else {
|
|
next.color=Color(1,1,1);
|
|
next.offset=1.0;
|
|
}
|
|
} else {
|
|
|
|
if (pos==points.size()-1) {
|
|
next.color=Color(1,1,1);
|
|
next.offset=1.0;
|
|
} else {
|
|
next=points[pos+1];
|
|
}
|
|
prev=points[pos];
|
|
|
|
}
|
|
|
|
p.color=prev.color.linear_interpolate(next.color,(p.offset-prev.offset)/(next.offset-prev.offset));
|
|
|
|
points.push_back(p);
|
|
points.sort();
|
|
for(int i=0;i<points.size();i++) {
|
|
if (points[i].offset==ofs) {
|
|
grabbed=i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
emit_signal("ramp_changed");
|
|
|
|
}
|
|
|
|
if (p_event.type==InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index==1 && !p_event.mouse_button.pressed) {
|
|
|
|
if (grabbing) {
|
|
grabbing=false;
|
|
emit_signal("ramp_changed");
|
|
}
|
|
update();
|
|
}
|
|
|
|
if (p_event.type==InputEvent::MOUSE_MOTION && grabbing) {
|
|
|
|
int total_w = get_size().width-get_size().height-3;
|
|
|
|
int x = p_event.mouse_motion.x;
|
|
float newofs = CLAMP(x/float(total_w),0,1);
|
|
|
|
bool valid=true;
|
|
for(int i=0;i<points.size();i++) {
|
|
|
|
if (points[i].offset==newofs && i!=grabbed) {
|
|
valid=false;
|
|
}
|
|
}
|
|
|
|
if (!valid)
|
|
return;
|
|
|
|
points[grabbed].offset=newofs;
|
|
|
|
points.sort();
|
|
for(int i=0;i<points.size();i++) {
|
|
if (points[i].offset==newofs) {
|
|
grabbed=i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
emit_signal("ramp_changed");
|
|
|
|
update();
|
|
}
|
|
}
|
|
|
|
void GraphColorRampEdit::_notification(int p_what){
|
|
|
|
if (p_what==NOTIFICATION_ENTER_TREE) {
|
|
if (!picker->is_connected("color_changed",this,"_color_changed")) {
|
|
picker->connect("color_changed",this,"_color_changed");
|
|
}
|
|
}
|
|
if (p_what==NOTIFICATION_DRAW) {
|
|
|
|
|
|
Point prev;
|
|
prev.offset=0;
|
|
prev.color=Color(0,0,0);
|
|
int w = get_size().x;
|
|
int h = get_size().y;
|
|
|
|
int total_w = get_size().width-get_size().height-3;
|
|
|
|
for(int i=-1;i<points.size();i++) {
|
|
|
|
Point next;
|
|
if (i+1==points.size()) {
|
|
next.color=Color(1,1,1);
|
|
next.offset=1;
|
|
} else {
|
|
next=points[i+1];
|
|
}
|
|
|
|
if (prev.offset==next.offset) {
|
|
prev=next;
|
|
continue;
|
|
}
|
|
|
|
Vector<Vector2> points;
|
|
Vector<Color> colors;
|
|
points.push_back(Vector2(prev.offset*total_w,h));
|
|
points.push_back(Vector2(prev.offset*total_w,0));
|
|
points.push_back(Vector2(next.offset*total_w,0));
|
|
points.push_back(Vector2(next.offset*total_w,h));
|
|
colors.push_back(prev.color);
|
|
colors.push_back(prev.color);
|
|
colors.push_back(next.color);
|
|
colors.push_back(next.color);
|
|
draw_primitive(points,colors,Vector<Point2>());
|
|
prev=next;
|
|
}
|
|
|
|
for(int i=0;i<points.size();i++) {
|
|
|
|
Color col=i==grabbed?Color(1,0.0,0.0,0.9):Color(1,1,1,0.8);
|
|
|
|
draw_line(Vector2(points[i].offset*total_w,0),Vector2(points[i].offset*total_w,h-1),Color(0,0,0,0.7));
|
|
draw_line(Vector2(points[i].offset*total_w-1,h/2),Vector2(points[i].offset*total_w-1,h-1),col);
|
|
draw_line(Vector2(points[i].offset*total_w+1,h/2),Vector2(points[i].offset*total_w+1,h-1),col);
|
|
draw_line(Vector2(points[i].offset*total_w-1,h/2),Vector2(points[i].offset*total_w+1,h/2),col);
|
|
draw_line(Vector2(points[i].offset*total_w-1,h-1),Vector2(points[i].offset*total_w+1,h-1),col);
|
|
|
|
}
|
|
|
|
if (grabbed!=-1) {
|
|
|
|
draw_rect(Rect2(total_w+3,0,h,h),points[grabbed].color);
|
|
}
|
|
|
|
if (has_focus()) {
|
|
|
|
draw_line(Vector2(-1,-1),Vector2(total_w+1,-1),Color(1,1,1,0.6));
|
|
draw_line(Vector2(total_w+1,-1),Vector2(total_w+1,h+1),Color(1,1,1,0.6));
|
|
draw_line(Vector2(total_w+1,h+1),Vector2(-1,h+1),Color(1,1,1,0.6));
|
|
draw_line(Vector2(-1,-1),Vector2(-1,h+1),Color(1,1,1,0.6));
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
Size2 GraphColorRampEdit::get_minimum_size() const {
|
|
|
|
return Vector2(0,16);
|
|
}
|
|
|
|
|
|
void GraphColorRampEdit::_color_changed(const Color& p_color) {
|
|
|
|
if (grabbed==-1)
|
|
return;
|
|
points[grabbed].color=p_color;
|
|
update();
|
|
emit_signal("ramp_changed");
|
|
|
|
}
|
|
|
|
void GraphColorRampEdit::set_ramp(const Vector<float>& p_offsets,const Vector<Color>& p_colors) {
|
|
|
|
ERR_FAIL_COND(p_offsets.size()!=p_colors.size());
|
|
points.clear();
|
|
for(int i=0;i<p_offsets.size();i++) {
|
|
Point p;
|
|
p.offset=p_offsets[i];
|
|
p.color=p_colors[i];
|
|
points.push_back(p);
|
|
}
|
|
|
|
points.sort();
|
|
update();
|
|
}
|
|
|
|
Vector<float> GraphColorRampEdit::get_offsets() const{
|
|
Vector<float> ret;
|
|
for(int i=0;i<points.size();i++)
|
|
ret.push_back(points[i].offset);
|
|
return ret;
|
|
}
|
|
Vector<Color> GraphColorRampEdit::get_colors() const{
|
|
|
|
Vector<Color> ret;
|
|
for(int i=0;i<points.size();i++)
|
|
ret.push_back(points[i].color);
|
|
return ret;
|
|
}
|
|
|
|
|
|
void GraphColorRampEdit::_bind_methods(){
|
|
|
|
ObjectTypeDB::bind_method(_MD("_input_event"),&GraphColorRampEdit::_input_event);
|
|
ObjectTypeDB::bind_method(_MD("_color_changed"),&GraphColorRampEdit::_color_changed);
|
|
ADD_SIGNAL(MethodInfo("ramp_changed"));
|
|
}
|
|
|
|
GraphColorRampEdit::GraphColorRampEdit(){
|
|
|
|
grabbed=-1;
|
|
grabbing=false;
|
|
set_focus_mode(FOCUS_ALL);
|
|
|
|
popup = memnew( PopupPanel );
|
|
picker = memnew( ColorPicker );
|
|
popup->add_child(picker);
|
|
popup->set_child_rect(picker);
|
|
add_child(popup);
|
|
|
|
}
|
|
////////////
|
|
|
|
void GraphCurveMapEdit::_input_event(const InputEvent& p_event) {
|
|
|
|
if (p_event.type==InputEvent::KEY && p_event.key.pressed && p_event.key.scancode==KEY_DELETE && grabbed!=-1) {
|
|
|
|
points.remove(grabbed);
|
|
grabbed=-1;
|
|
update();
|
|
emit_signal("curve_changed");
|
|
accept_event();
|
|
}
|
|
|
|
if (p_event.type==InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index==1 && p_event.mouse_button.pressed) {
|
|
|
|
update();
|
|
Point2 p = Vector2(p_event.mouse_button.x,p_event.mouse_button.y)/get_size();
|
|
p.y=1.0-p.y;
|
|
grabbed=-1;
|
|
grabbing=true;
|
|
|
|
for(int i=0;i<points.size();i++) {
|
|
|
|
Vector2 ps = p*get_size();
|
|
Vector2 pt = Vector2(points[i].offset,points[i].height)*get_size();
|
|
if (ps.distance_to(pt)<4) {
|
|
grabbed=i;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
//grab or select
|
|
if (grabbed!=-1) {
|
|
return;
|
|
}
|
|
//insert
|
|
|
|
|
|
Point np;
|
|
np.offset=p.x;
|
|
np.height=p.y;
|
|
|
|
points.push_back(np);
|
|
points.sort();
|
|
for(int i=0;i<points.size();i++) {
|
|
if (points[i].offset==p.x && points[i].height==p.y) {
|
|
grabbed=i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
emit_signal("curve_changed");
|
|
|
|
}
|
|
|
|
if (p_event.type==InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index==1 && !p_event.mouse_button.pressed) {
|
|
|
|
if (grabbing) {
|
|
grabbing=false;
|
|
emit_signal("curve_changed");
|
|
}
|
|
update();
|
|
}
|
|
|
|
if (p_event.type==InputEvent::MOUSE_MOTION && grabbing && grabbed != -1) {
|
|
|
|
Point2 p = Vector2(p_event.mouse_button.x,p_event.mouse_button.y)/get_size();
|
|
p.y=1.0-p.y;
|
|
|
|
p.x = CLAMP(p.x,0.0,1.0);
|
|
p.y = CLAMP(p.y,0.0,1.0);
|
|
|
|
bool valid=true;
|
|
|
|
for(int i=0;i<points.size();i++) {
|
|
|
|
if (points[i].offset==p.x && points[i].height==p.y && i!=grabbed) {
|
|
valid=false;
|
|
}
|
|
}
|
|
|
|
if (!valid)
|
|
return;
|
|
|
|
points[grabbed].offset=p.x;
|
|
points[grabbed].height=p.y;
|
|
|
|
points.sort();
|
|
for(int i=0;i<points.size();i++) {
|
|
if (points[i].offset==p.x && points[i].height==p.y) {
|
|
grabbed=i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
emit_signal("curve_changed");
|
|
|
|
update();
|
|
}
|
|
}
|
|
|
|
void GraphCurveMapEdit::_plot_curve(const Vector2& p_a,const Vector2& p_b,const Vector2& p_c,const Vector2& p_d) {
|
|
|
|
float geometry[4][4];
|
|
float tmp1[4][4];
|
|
float tmp2[4][4];
|
|
float deltas[4][4];
|
|
double x, dx, dx2, dx3;
|
|
double y, dy, dy2, dy3;
|
|
double d, d2, d3;
|
|
int lastx, lasty;
|
|
int newx, newy;
|
|
int ntimes;
|
|
int i,j;
|
|
|
|
int xmax=get_size().x;
|
|
int ymax=get_size().y;
|
|
|
|
/* construct the geometry matrix from the segment */
|
|
for (i = 0; i < 4; i++) {
|
|
geometry[i][2] = 0;
|
|
geometry[i][3] = 0;
|
|
}
|
|
|
|
geometry[0][0] = (p_a[0] * xmax);
|
|
geometry[1][0] = (p_b[0] * xmax);
|
|
geometry[2][0] = (p_c[0] * xmax);
|
|
geometry[3][0] = (p_d[0] * xmax);
|
|
|
|
geometry[0][1] = (p_a[1] * ymax);
|
|
geometry[1][1] = (p_b[1] * ymax);
|
|
geometry[2][1] = (p_c[1] * ymax);
|
|
geometry[3][1] = (p_d[1] * ymax);
|
|
|
|
/* subdivide the curve ntimes (1000) times */
|
|
ntimes = 4 * xmax;
|
|
/* ntimes can be adjusted to give a finer or coarser curve */
|
|
d = 1.0 / ntimes;
|
|
d2 = d * d;
|
|
d3 = d * d * d;
|
|
|
|
/* construct a temporary matrix for determining the forward differencing deltas */
|
|
tmp2[0][0] = 0; tmp2[0][1] = 0; tmp2[0][2] = 0; tmp2[0][3] = 1;
|
|
tmp2[1][0] = d3; tmp2[1][1] = d2; tmp2[1][2] = d; tmp2[1][3] = 0;
|
|
tmp2[2][0] = 6*d3; tmp2[2][1] = 2*d2; tmp2[2][2] = 0; tmp2[2][3] = 0;
|
|
tmp2[3][0] = 6*d3; tmp2[3][1] = 0; tmp2[3][2] = 0; tmp2[3][3] = 0;
|
|
|
|
/* compose the basis and geometry matrices */
|
|
|
|
static const float CR_basis[4][4] =
|
|
{
|
|
{ -0.5, 1.5, -1.5, 0.5 },
|
|
{ 1.0, -2.5, 2.0, -0.5 },
|
|
{ -0.5, 0.0, 0.5, 0.0 },
|
|
{ 0.0, 1.0, 0.0, 0.0 },
|
|
};
|
|
|
|
for (i = 0; i < 4; i++)
|
|
{
|
|
for (j = 0; j < 4; j++)
|
|
{
|
|
tmp1[i][j] = (CR_basis[i][0] * geometry[0][j] +
|
|
CR_basis[i][1] * geometry[1][j] +
|
|
CR_basis[i][2] * geometry[2][j] +
|
|
CR_basis[i][3] * geometry[3][j]);
|
|
}
|
|
}
|
|
/* compose the above results to get the deltas matrix */
|
|
|
|
for (i = 0; i < 4; i++)
|
|
{
|
|
for (j = 0; j < 4; j++)
|
|
{
|
|
deltas[i][j] = (tmp2[i][0] * tmp1[0][j] +
|
|
tmp2[i][1] * tmp1[1][j] +
|
|
tmp2[i][2] * tmp1[2][j] +
|
|
tmp2[i][3] * tmp1[3][j]);
|
|
}
|
|
}
|
|
|
|
|
|
/* extract the x deltas */
|
|
x = deltas[0][0];
|
|
dx = deltas[1][0];
|
|
dx2 = deltas[2][0];
|
|
dx3 = deltas[3][0];
|
|
|
|
/* extract the y deltas */
|
|
y = deltas[0][1];
|
|
dy = deltas[1][1];
|
|
dy2 = deltas[2][1];
|
|
dy3 = deltas[3][1];
|
|
|
|
|
|
lastx = CLAMP (x, 0, xmax);
|
|
lasty = CLAMP (y, 0, ymax);
|
|
|
|
/* if (fix255)
|
|
{
|
|
cd->curve[cd->outline][lastx] = lasty;
|
|
}
|
|
else
|
|
{
|
|
cd->curve_ptr[cd->outline][lastx] = lasty;
|
|
if(gb_debug) printf("bender_plot_curve xmax:%d ymax:%d\n", (int)xmax, (int)ymax);
|
|
}
|
|
*/
|
|
/* loop over the curve */
|
|
for (i = 0; i < ntimes; i++)
|
|
{
|
|
/* increment the x values */
|
|
x += dx;
|
|
dx += dx2;
|
|
dx2 += dx3;
|
|
|
|
/* increment the y values */
|
|
y += dy;
|
|
dy += dy2;
|
|
dy2 += dy3;
|
|
|
|
newx = CLAMP ((Math::round (x)), 0, xmax);
|
|
newy = CLAMP ((Math::round (y)), 0, ymax);
|
|
|
|
/* if this point is different than the last one...then draw it */
|
|
if ((lastx != newx) || (lasty != newy))
|
|
{
|
|
#if 0
|
|
if(fix255)
|
|
{
|
|
/* use fixed array size (for the curve graph) */
|
|
cd->curve[cd->outline][newx] = newy;
|
|
}
|
|
else
|
|
{
|
|
/* use dynamic allocated curve_ptr (for the real curve) */
|
|
cd->curve_ptr[cd->outline][newx] = newy;
|
|
|
|
if(gb_debug) printf("outline: %d cX: %d cY: %d\n", (int)cd->outline, (int)newx, (int)newy);
|
|
}
|
|
#endif
|
|
draw_line(Vector2(lastx,ymax-lasty),Vector2(newx,ymax-newy),Color(0.8,0.8,0.8,0.8),2.0);
|
|
}
|
|
|
|
lastx = newx;
|
|
lasty = newy;
|
|
}
|
|
}
|
|
|
|
|
|
void GraphCurveMapEdit::_notification(int p_what){
|
|
|
|
if (p_what==NOTIFICATION_DRAW) {
|
|
|
|
draw_style_box(get_stylebox("bg","Tree"),Rect2(Point2(),get_size()));
|
|
|
|
int w = get_size().x;
|
|
int h = get_size().y;
|
|
|
|
Vector2 prev=Vector2(0,0);
|
|
Vector2 prev2=Vector2(0,0);
|
|
|
|
for(int i=-1;i<points.size();i++) {
|
|
|
|
Vector2 next;
|
|
Vector2 next2;
|
|
if (i+1>=points.size()) {
|
|
next=Vector2(1,1);
|
|
} else {
|
|
next=Vector2(points[i+1].offset,points[i+1].height);
|
|
}
|
|
|
|
if (i+2>=points.size()) {
|
|
next2=Vector2(1,1);
|
|
} else {
|
|
next2=Vector2(points[i+2].offset,points[i+2].height);
|
|
}
|
|
|
|
/*if (i==-1 && prev.offset==next.offset) {
|
|
prev=next;
|
|
continue;
|
|
}*/
|
|
|
|
_plot_curve(prev2,prev,next,next2);
|
|
|
|
prev2=prev;
|
|
prev=next;
|
|
}
|
|
|
|
for(int i=0;i<points.size();i++) {
|
|
|
|
Color col=i==grabbed?Color(1,0.0,0.0,0.9):Color(1,1,1,0.8);
|
|
|
|
|
|
draw_rect(Rect2( Vector2(points[i].offset,1.0-points[i].height)*get_size()-Vector2(2,2),Vector2(5,5)),col);
|
|
}
|
|
|
|
/* if (grabbed!=-1) {
|
|
|
|
draw_rect(Rect2(total_w+3,0,h,h),points[grabbed].color);
|
|
}
|
|
*/
|
|
if (has_focus()) {
|
|
|
|
draw_line(Vector2(-1,-1),Vector2(w+1,-1),Color(1,1,1,0.6));
|
|
draw_line(Vector2(w+1,-1),Vector2(w+1,h+1),Color(1,1,1,0.6));
|
|
draw_line(Vector2(w+1,h+1),Vector2(-1,h+1),Color(1,1,1,0.6));
|
|
draw_line(Vector2(-1,-1),Vector2(-1,h+1),Color(1,1,1,0.6));
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
Size2 GraphCurveMapEdit::get_minimum_size() const {
|
|
|
|
return Vector2(64,64);
|
|
}
|
|
|
|
|
|
|
|
void GraphCurveMapEdit::set_points(const Vector<Vector2>& p_points) {
|
|
|
|
|
|
points.clear();
|
|
for(int i=0;i<p_points.size();i++) {
|
|
Point p;
|
|
p.offset=p_points[i].x;
|
|
p.height=p_points[i].y;
|
|
points.push_back(p);
|
|
}
|
|
|
|
points.sort();
|
|
update();
|
|
}
|
|
|
|
Vector<Vector2> GraphCurveMapEdit::get_points() const {
|
|
Vector<Vector2> ret;
|
|
for(int i=0;i<points.size();i++)
|
|
ret.push_back(Vector2(points[i].offset,points[i].height));
|
|
return ret;
|
|
}
|
|
|
|
void GraphCurveMapEdit::_bind_methods(){
|
|
|
|
ObjectTypeDB::bind_method(_MD("_input_event"),&GraphCurveMapEdit::_input_event);
|
|
ADD_SIGNAL(MethodInfo("curve_changed"));
|
|
}
|
|
|
|
GraphCurveMapEdit::GraphCurveMapEdit(){
|
|
|
|
grabbed=-1;
|
|
grabbing=false;
|
|
set_focus_mode(FOCUS_ALL);
|
|
|
|
}
|
|
|
|
|
|
////cbacks
|
|
///
|
|
void ShaderGraphView::_scalar_const_changed(double p_value,int p_id) {
|
|
|
|
UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
|
|
ur->create_action(TTR("Change Scalar Constant"),true);
|
|
ur->add_do_method(graph.ptr(),"scalar_const_node_set_value",type,p_id,p_value);
|
|
ur->add_undo_method(graph.ptr(),"scalar_const_node_set_value",type,p_id,graph->scalar_const_node_get_value(type,p_id));
|
|
ur->add_do_method(this,"_update_graph");
|
|
ur->add_undo_method(this,"_update_graph");
|
|
block_update=true;
|
|
ur->commit_action();
|
|
block_update=false;
|
|
}
|
|
|
|
void ShaderGraphView::_vec_const_changed(double p_value, int p_id,Array p_arr){
|
|
|
|
Vector3 val;
|
|
for(int i=0;i<p_arr.size();i++) {
|
|
val[i]=p_arr[i].call("get_val");
|
|
}
|
|
|
|
UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
|
|
ur->create_action(TTR("Change Vec Constant"),true);
|
|
ur->add_do_method(graph.ptr(),"vec_const_node_set_value",type,p_id,val);
|
|
ur->add_undo_method(graph.ptr(),"vec_const_node_set_value",type,p_id,graph->vec_const_node_get_value(type,p_id));
|
|
ur->add_do_method(this,"_update_graph");
|
|
ur->add_undo_method(this,"_update_graph");
|
|
block_update=true;
|
|
ur->commit_action();
|
|
block_update=false;
|
|
|
|
}
|
|
void ShaderGraphView::_rgb_const_changed(const Color& p_color, int p_id){
|
|
|
|
UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
|
|
ur->create_action(TTR("Change RGB Constant"),true);
|
|
ur->add_do_method(graph.ptr(),"rgb_const_node_set_value",type,p_id,p_color);
|
|
ur->add_undo_method(graph.ptr(),"rgb_const_node_set_value",type,p_id,graph->rgb_const_node_get_value(type,p_id));
|
|
ur->add_do_method(this,"_update_graph");
|
|
ur->add_undo_method(this,"_update_graph");
|
|
block_update=true;
|
|
ur->commit_action();
|
|
block_update=false;
|
|
|
|
}
|
|
void ShaderGraphView::_scalar_op_changed(int p_op, int p_id){
|
|
|
|
UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
|
|
ur->create_action(TTR("Change Scalar Operator"));
|
|
ur->add_do_method(graph.ptr(),"scalar_op_node_set_op",type,p_id,p_op);
|
|
ur->add_undo_method(graph.ptr(),"scalar_op_node_set_op",type,p_id,graph->scalar_op_node_get_op(type,p_id));
|
|
ur->add_do_method(this,"_update_graph");
|
|
ur->add_undo_method(this,"_update_graph");
|
|
block_update=true;
|
|
ur->commit_action();
|
|
block_update=false;
|
|
|
|
}
|
|
void ShaderGraphView::_vec_op_changed(int p_op, int p_id){
|
|
|
|
UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
|
|
ur->create_action(TTR("Change Vec Operator"));
|
|
ur->add_do_method(graph.ptr(),"vec_op_node_set_op",type,p_id,p_op);
|
|
ur->add_undo_method(graph.ptr(),"vec_op_node_set_op",type,p_id,graph->vec_op_node_get_op(type,p_id));
|
|
ur->add_do_method(this,"_update_graph");
|
|
ur->add_undo_method(this,"_update_graph");
|
|
block_update=true;
|
|
ur->commit_action();
|
|
block_update=false;
|
|
}
|
|
void ShaderGraphView::_vec_scalar_op_changed(int p_op, int p_id){
|
|
|
|
UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
|
|
ur->create_action(TTR("Change Vec Scalar Operator"));
|
|
ur->add_do_method(graph.ptr(),"vec_scalar_op_node_set_op",type,p_id,p_op);
|
|
ur->add_undo_method(graph.ptr(),"vec_scalar_op_node_set_op",type,p_id,graph->vec_scalar_op_node_get_op(type,p_id));
|
|
ur->add_do_method(this,"_update_graph");
|
|
ur->add_undo_method(this,"_update_graph");
|
|
block_update=true;
|
|
ur->commit_action();
|
|
block_update=false;
|
|
|
|
}
|
|
void ShaderGraphView::_rgb_op_changed(int p_op, int p_id){
|
|
|
|
UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
|
|
ur->create_action(TTR("Change RGB Operator"));
|
|
ur->add_do_method(graph.ptr(),"rgb_op_node_set_op",type,p_id,p_op);
|
|
ur->add_undo_method(graph.ptr(),"rgb_op_node_set_op",type,p_id,graph->rgb_op_node_get_op(type,p_id));
|
|
ur->add_do_method(this,"_update_graph");
|
|
ur->add_undo_method(this,"_update_graph");
|
|
block_update=true;
|
|
ur->commit_action();
|
|
block_update=false;
|
|
}
|
|
void ShaderGraphView::_xform_inv_rev_changed(bool p_enabled, int p_id){
|
|
|
|
UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
|
|
ur->create_action(TTR("Toggle Rot Only"));
|
|
ur->add_do_method(graph.ptr(),"xform_vec_mult_node_set_no_translation",type,p_id,p_enabled);
|
|
ur->add_undo_method(graph.ptr(),"xform_vec_mult_node_set_no_translation",type,p_id,graph->xform_vec_mult_node_get_no_translation(type,p_id));
|
|
ur->add_do_method(this,"_update_graph");
|
|
ur->add_undo_method(this,"_update_graph");
|
|
block_update=true;
|
|
ur->commit_action();
|
|
block_update=false;
|
|
}
|
|
void ShaderGraphView::_scalar_func_changed(int p_func, int p_id){
|
|
|
|
|
|
UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
|
|
ur->create_action(TTR("Change Scalar Function"));
|
|
ur->add_do_method(graph.ptr(),"scalar_func_node_set_function",type,p_id,p_func);
|
|
ur->add_undo_method(graph.ptr(),"scalar_func_node_set_function",type,p_id,graph->scalar_func_node_get_function(type,p_id));
|
|
ur->add_do_method(this,"_update_graph");
|
|
ur->add_undo_method(this,"_update_graph");
|
|
block_update=true;
|
|
ur->commit_action();
|
|
block_update=false;
|
|
}
|
|
void ShaderGraphView::_vec_func_changed(int p_func, int p_id){
|
|
|
|
UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
|
|
ur->create_action(TTR("Change Vec Function"));
|
|
ur->add_do_method(graph.ptr(),"vec_func_node_set_function",type,p_id,p_func);
|
|
ur->add_undo_method(graph.ptr(),"vec_func_node_set_function",type,p_id,graph->vec_func_node_get_function(type,p_id));
|
|
ur->add_do_method(this,"_update_graph");
|
|
ur->add_undo_method(this,"_update_graph");
|
|
block_update=true;
|
|
ur->commit_action();
|
|
block_update=false;
|
|
|
|
}
|
|
void ShaderGraphView::_scalar_input_changed(double p_value,int p_id){
|
|
|
|
UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
|
|
ur->create_action(TTR("Change Scalar Uniform"),true);
|
|
ur->add_do_method(graph.ptr(),"scalar_input_node_set_value",type,p_id,p_value);
|
|
ur->add_undo_method(graph.ptr(),"scalar_input_node_set_value",type,p_id,graph->scalar_input_node_get_value(type,p_id));
|
|
ur->add_do_method(this,"_update_graph");
|
|
ur->add_undo_method(this,"_update_graph");
|
|
block_update=true;
|
|
ur->commit_action();
|
|
block_update=false;
|
|
|
|
}
|
|
void ShaderGraphView::_vec_input_changed(double p_value, int p_id,Array p_arr){
|
|
|
|
Vector3 val;
|
|
for(int i=0;i<p_arr.size();i++) {
|
|
val[i]=p_arr[i].call("get_val");
|
|
}
|
|
|
|
UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
|
|
ur->create_action(TTR("Change Vec Uniform"),true);
|
|
ur->add_do_method(graph.ptr(),"vec_input_node_set_value",type,p_id,val);
|
|
ur->add_undo_method(graph.ptr(),"vec_input_node_set_value",type,p_id,graph->vec_input_node_get_value(type,p_id));
|
|
ur->add_do_method(this,"_update_graph");
|
|
ur->add_undo_method(this,"_update_graph");
|
|
block_update=true;
|
|
ur->commit_action();
|
|
block_update=false;
|
|
|
|
}
|
|
void ShaderGraphView::_xform_input_changed(int p_id, Node *p_button){
|
|
|
|
|
|
ToolButton *tb = p_button->cast_to<ToolButton>();
|
|
ped_popup->set_pos(tb->get_global_pos()+Vector2(0,tb->get_size().height));
|
|
ped_popup->set_size(tb->get_size());
|
|
edited_id=p_id;
|
|
edited_def=-1;
|
|
ped_popup->edit(NULL,"",Variant::TRANSFORM,graph->xform_input_node_get_value(type,p_id),PROPERTY_HINT_NONE,"");
|
|
ped_popup->popup();
|
|
|
|
}
|
|
void ShaderGraphView::_xform_const_changed(int p_id, Node *p_button){
|
|
|
|
ToolButton *tb = p_button->cast_to<ToolButton>();
|
|
ped_popup->set_pos(tb->get_global_pos()+Vector2(0,tb->get_size().height));
|
|
ped_popup->set_size(tb->get_size());
|
|
edited_id=p_id;
|
|
edited_def=-1;
|
|
ped_popup->edit(NULL,"",Variant::TRANSFORM,graph->xform_const_node_get_value(type,p_id),PROPERTY_HINT_NONE,"");
|
|
ped_popup->popup();
|
|
|
|
}
|
|
|
|
void ShaderGraphView::_rgb_input_changed(const Color& p_color, int p_id){
|
|
|
|
|
|
UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
|
|
ur->create_action(TTR("Change RGB Uniform"),true);
|
|
ur->add_do_method(graph.ptr(),"rgb_input_node_set_value",type,p_id,p_color);
|
|
ur->add_undo_method(graph.ptr(),"rgb_input_node_set_value",type,p_id,graph->rgb_input_node_get_value(type,p_id));
|
|
ur->add_do_method(this,"_update_graph");
|
|
ur->add_undo_method(this,"_update_graph");
|
|
block_update=true;
|
|
ur->commit_action();
|
|
block_update=false;
|
|
}
|
|
void ShaderGraphView::_tex_input_change(int p_id, Node *p_button){
|
|
|
|
|
|
}
|
|
void ShaderGraphView::_cube_input_change(int p_id){
|
|
|
|
|
|
}
|
|
|
|
void ShaderGraphView::_variant_edited() {
|
|
|
|
if (edited_def != -1) {
|
|
|
|
Variant v = ped_popup->get_variant();
|
|
Variant v2 = graph->default_get_value(type,edited_id,edited_def);
|
|
if (v2.get_type() == Variant::NIL)
|
|
switch (v.get_type()) {
|
|
case Variant::VECTOR3:
|
|
v2=Vector3();
|
|
break;
|
|
case Variant::REAL:
|
|
v2=0.0;
|
|
break;
|
|
case Variant::TRANSFORM:
|
|
v2=Transform();
|
|
break;
|
|
case Variant::COLOR:
|
|
v2=Color();
|
|
break;
|
|
}
|
|
UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
|
|
ur->create_action(TTR("Change Default Value"));
|
|
ur->add_do_method(graph.ptr(),"default_set_value",type,edited_id,edited_def, v);
|
|
ur->add_undo_method(graph.ptr(),"default_set_value",type,edited_id,edited_def, v2);
|
|
ur->add_do_method(this,"_update_graph");
|
|
ur->add_undo_method(this,"_update_graph");
|
|
ur->commit_action();
|
|
return;
|
|
}
|
|
|
|
if (graph->node_get_type(type,edited_id)==ShaderGraph::NODE_XFORM_CONST) {
|
|
|
|
UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
|
|
ur->create_action(TTR("Change XForm Uniform"));
|
|
ur->add_do_method(graph.ptr(),"xform_const_node_set_value",type,edited_id,ped_popup->get_variant());
|
|
ur->add_undo_method(graph.ptr(),"xform_const_node_set_value",type,edited_id,graph->xform_const_node_get_value(type,edited_id));
|
|
ur->add_do_method(this,"_update_graph");
|
|
ur->add_undo_method(this,"_update_graph");
|
|
ur->commit_action();
|
|
}
|
|
|
|
|
|
if (graph->node_get_type(type,edited_id)==ShaderGraph::NODE_XFORM_INPUT) {
|
|
|
|
UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
|
|
ur->create_action(TTR("Change XForm Uniform"));
|
|
ur->add_do_method(graph.ptr(),"xform_input_node_set_value",type,edited_id,ped_popup->get_variant());
|
|
ur->add_undo_method(graph.ptr(),"xform_input_node_set_value",type,edited_id,graph->xform_input_node_get_value(type,edited_id));
|
|
ur->add_do_method(this,"_update_graph");
|
|
ur->add_undo_method(this,"_update_graph");
|
|
ur->commit_action();
|
|
}
|
|
|
|
if (graph->node_get_type(type,edited_id)==ShaderGraph::NODE_TEXTURE_INPUT) {
|
|
|
|
UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
|
|
ur->create_action(TTR("Change Texture Uniform"));
|
|
ur->add_do_method(graph.ptr(),"texture_input_node_set_value",type,edited_id,ped_popup->get_variant());
|
|
ur->add_undo_method(graph.ptr(),"texture_input_node_set_value",type,edited_id,graph->texture_input_node_get_value(type,edited_id));
|
|
ur->add_do_method(this,"_update_graph");
|
|
ur->add_undo_method(this,"_update_graph");
|
|
ur->commit_action();
|
|
}
|
|
|
|
if (graph->node_get_type(type,edited_id)==ShaderGraph::NODE_CUBEMAP_INPUT) {
|
|
|
|
UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
|
|
ur->create_action(TTR("Change Cubemap Uniform"));
|
|
ur->add_do_method(graph.ptr(),"cubemap_input_node_set_value",type,edited_id,ped_popup->get_variant());
|
|
ur->add_undo_method(graph.ptr(),"cubemap_input_node_set_value",type,edited_id,graph->cubemap_input_node_get_value(type,edited_id));
|
|
ur->add_do_method(this,"_update_graph");
|
|
ur->add_undo_method(this,"_update_graph");
|
|
ur->commit_action();
|
|
}
|
|
|
|
}
|
|
|
|
void ShaderGraphView::_comment_edited(int p_id,Node* p_button) {
|
|
|
|
UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
|
|
TextEdit *te=p_button->cast_to<TextEdit>();
|
|
ur->create_action(TTR("Change Comment"),true);
|
|
ur->add_do_method(graph.ptr(),"comment_node_set_text",type,p_id,te->get_text());
|
|
ur->add_undo_method(graph.ptr(),"comment_node_set_text",type,p_id,graph->comment_node_get_text(type,p_id));
|
|
ur->add_do_method(this,"_update_graph");
|
|
ur->add_undo_method(this,"_update_graph");
|
|
block_update=true;
|
|
ur->commit_action();
|
|
block_update=false;
|
|
|
|
}
|
|
|
|
void ShaderGraphView::_color_ramp_changed(int p_id,Node* p_ramp) {
|
|
|
|
GraphColorRampEdit *cr=p_ramp->cast_to<GraphColorRampEdit>();
|
|
|
|
UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
|
|
|
|
|
|
Vector<float> offsets=cr->get_offsets();
|
|
Vector<Color> colors=cr->get_colors();
|
|
|
|
DVector<float> new_offsets;
|
|
DVector<Color> new_colors;
|
|
{
|
|
new_offsets.resize(offsets.size());
|
|
new_colors.resize(colors.size());
|
|
DVector<float>::Write ow=new_offsets.write();
|
|
DVector<Color>::Write cw=new_colors.write();
|
|
for(int i=0;i<new_offsets.size();i++) {
|
|
ow[i]=offsets[i];
|
|
cw[i]=colors[i];
|
|
}
|
|
|
|
}
|
|
|
|
|
|
DVector<float> old_offsets=graph->color_ramp_node_get_offsets(type,p_id);
|
|
DVector<Color> old_colors=graph->color_ramp_node_get_colors(type,p_id);
|
|
|
|
if (old_offsets.size()!=new_offsets.size())
|
|
ur->create_action(TTR("Add/Remove to Color Ramp"));
|
|
else
|
|
ur->create_action(TTR("Modify Color Ramp"),true);
|
|
|
|
ur->add_do_method(graph.ptr(),"color_ramp_node_set_ramp",type,p_id,new_colors,new_offsets);
|
|
ur->add_undo_method(graph.ptr(),"color_ramp_node_set_ramp",type,p_id,old_colors,old_offsets);
|
|
ur->add_do_method(this,"_update_graph");
|
|
ur->add_undo_method(this,"_update_graph");
|
|
block_update=true;
|
|
ur->commit_action();
|
|
block_update=false;
|
|
}
|
|
|
|
void ShaderGraphView::_curve_changed(int p_id,Node* p_curve) {
|
|
|
|
GraphCurveMapEdit *cr=p_curve->cast_to<GraphCurveMapEdit>();
|
|
|
|
UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
|
|
|
|
|
|
Vector<Point2> points=cr->get_points();
|
|
|
|
DVector<Vector2> new_points;
|
|
{
|
|
new_points.resize(points.size());
|
|
DVector<Vector2>::Write ow=new_points.write();
|
|
for(int i=0;i<new_points.size();i++) {
|
|
ow[i]=points[i];
|
|
}
|
|
|
|
}
|
|
|
|
|
|
DVector<Vector2> old_points=graph->curve_map_node_get_points(type,p_id);
|
|
|
|
if (old_points.size()!=new_points.size())
|
|
ur->create_action(TTR("Add/Remove to Curve Map"));
|
|
else
|
|
ur->create_action(TTR("Modify Curve Map"),true);
|
|
|
|
ur->add_do_method(graph.ptr(),"curve_map_node_set_points",type,p_id,new_points);
|
|
ur->add_undo_method(graph.ptr(),"curve_map_node_set_points",type,p_id,old_points);
|
|
ur->add_do_method(this,"_update_graph");
|
|
ur->add_undo_method(this,"_update_graph");
|
|
block_update=true;
|
|
ur->commit_action();
|
|
block_update=false;
|
|
}
|
|
|
|
|
|
void ShaderGraphView::_input_name_changed(const String& p_name, int p_id, Node *p_line_edit) {
|
|
|
|
LineEdit *le=p_line_edit->cast_to<LineEdit>();
|
|
ERR_FAIL_COND(!le);
|
|
|
|
UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
|
|
ur->create_action(TTR("Change Input Name"));
|
|
ur->add_do_method(graph.ptr(),"input_node_set_name",type,p_id,p_name);
|
|
ur->add_undo_method(graph.ptr(),"input_node_set_name",type,p_id,graph->input_node_get_name(type,p_id));
|
|
ur->add_do_method(this,"_update_graph");
|
|
ur->add_undo_method(this,"_update_graph");
|
|
block_update=true;
|
|
ur->commit_action();
|
|
block_update=false;
|
|
le->set_text(graph->input_node_get_name(type,p_id));
|
|
}
|
|
|
|
void ShaderGraphView::_tex_edited(int p_id,Node* p_button) {
|
|
|
|
ToolButton *tb = p_button->cast_to<ToolButton>();
|
|
ped_popup->set_pos(tb->get_global_pos()+Vector2(0,tb->get_size().height));
|
|
ped_popup->set_size(tb->get_size());
|
|
edited_id=p_id;
|
|
edited_def=-1;
|
|
ped_popup->edit(NULL,"",Variant::OBJECT,graph->texture_input_node_get_value(type,p_id),PROPERTY_HINT_RESOURCE_TYPE,"Texture");
|
|
}
|
|
|
|
void ShaderGraphView::_cube_edited(int p_id,Node* p_button) {
|
|
|
|
ToolButton *tb = p_button->cast_to<ToolButton>();
|
|
ped_popup->set_pos(tb->get_global_pos()+Vector2(0,tb->get_size().height));
|
|
ped_popup->set_size(tb->get_size());
|
|
edited_id=p_id;
|
|
edited_def=-1;
|
|
ped_popup->edit(NULL,"",Variant::OBJECT,graph->cubemap_input_node_get_value(type,p_id),PROPERTY_HINT_RESOURCE_TYPE,"CubeMap");
|
|
}
|
|
|
|
|
|
//////////////view/////////////
|
|
|
|
|
|
void ShaderGraphView::_connection_request(const String& p_from, int p_from_slot,const String& p_to,int p_to_slot) {
|
|
|
|
UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
|
|
|
|
int from_idx=-1;
|
|
int to_idx=-1;
|
|
for (Map<int,GraphNode*>::Element *E=node_map.front();E;E=E->next()) {
|
|
|
|
if (p_from==E->get()->get_name())
|
|
from_idx=E->key();
|
|
if (p_to==E->get()->get_name())
|
|
to_idx=E->key();
|
|
}
|
|
|
|
ERR_FAIL_COND(from_idx==-1);
|
|
ERR_FAIL_COND(to_idx==-1);
|
|
|
|
ur->create_action(TTR("Connect Graph Nodes"));
|
|
|
|
List<ShaderGraph::Connection> conns;
|
|
|
|
graph->get_node_connections(type,&conns);
|
|
//disconnect/reconnect dependencies
|
|
ur->add_undo_method(graph.ptr(),"disconnect_node",type,from_idx,p_from_slot,to_idx,p_to_slot);
|
|
for(List<ShaderGraph::Connection>::Element *E=conns.front();E;E=E->next()) {
|
|
|
|
if (E->get().dst_id==to_idx && E->get().dst_slot==p_to_slot) {
|
|
ur->add_do_method(graph.ptr(),"disconnect_node",type,E->get().src_id,E->get().src_slot,E->get().dst_id,E->get().dst_slot);
|
|
ur->add_undo_method(graph.ptr(),"connect_node",type,E->get().src_id,E->get().src_slot,E->get().dst_id,E->get().dst_slot);
|
|
}
|
|
}
|
|
ur->add_do_method(graph.ptr(),"connect_node",type,from_idx,p_from_slot,to_idx,p_to_slot);
|
|
ur->add_do_method(this,"_update_graph");
|
|
ur->add_undo_method(this,"_update_graph");
|
|
ur->commit_action();
|
|
|
|
|
|
}
|
|
|
|
void ShaderGraphView::_disconnection_request(const String& p_from, int p_from_slot,const String& p_to,int p_to_slot) {
|
|
|
|
UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
|
|
|
|
int from_idx=-1;
|
|
int to_idx=-1;
|
|
for (Map<int,GraphNode*>::Element *E=node_map.front();E;E=E->next()) {
|
|
|
|
if (p_from==E->get()->get_name())
|
|
from_idx=E->key();
|
|
if (p_to==E->get()->get_name())
|
|
to_idx=E->key();
|
|
}
|
|
|
|
ERR_FAIL_COND(from_idx==-1);
|
|
ERR_FAIL_COND(to_idx==-1);
|
|
|
|
if (!graph->is_node_connected(type,from_idx,p_from_slot,to_idx,p_to_slot))
|
|
return; //nothing to disconnect
|
|
|
|
ur->create_action(TTR("Disconnect Graph Nodes"));
|
|
|
|
List<ShaderGraph::Connection> conns;
|
|
|
|
graph->get_node_connections(type,&conns);
|
|
//disconnect/reconnect dependencies
|
|
ur->add_do_method(graph.ptr(),"disconnect_node",type,from_idx,p_from_slot,to_idx,p_to_slot);
|
|
ur->add_undo_method(graph.ptr(),"connect_node",type,from_idx,p_from_slot,to_idx,p_to_slot);
|
|
ur->add_do_method(this,"_update_graph");
|
|
ur->add_undo_method(this,"_update_graph");
|
|
ur->commit_action();
|
|
|
|
|
|
}
|
|
|
|
void ShaderGraphView::_node_removed(int p_id) {
|
|
|
|
UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
|
|
ur->create_action(TTR("Remove Shader Graph Node"));
|
|
|
|
ur->add_do_method(graph.ptr(),"node_remove",type,p_id);
|
|
ur->add_undo_method(graph.ptr(),"node_add",type,graph->node_get_type(type,p_id),p_id);
|
|
ur->add_undo_method(graph.ptr(),"node_set_state",type,p_id,graph->node_get_state(type,p_id));
|
|
List<ShaderGraph::Connection> conns;
|
|
|
|
graph->get_node_connections(type,&conns);
|
|
for(List<ShaderGraph::Connection>::Element *E=conns.front();E;E=E->next()) {
|
|
|
|
if (E->get().dst_id==p_id || E->get().src_id==p_id) {
|
|
ur->add_undo_method(graph.ptr(),"connect_node",type,E->get().src_id,E->get().src_slot,E->get().dst_id,E->get().dst_slot);
|
|
}
|
|
}
|
|
ur->add_do_method(this,"_update_graph");
|
|
ur->add_undo_method(this,"_update_graph");
|
|
ur->commit_action();
|
|
|
|
}
|
|
|
|
void ShaderGraphView::_begin_node_move()
|
|
{
|
|
UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
|
|
ur->create_action(TTR("Move Shader Graph Node"));
|
|
}
|
|
|
|
void ShaderGraphView::_node_moved(const Vector2& p_from, const Vector2& p_to,int p_id) {
|
|
|
|
|
|
ERR_FAIL_COND(!node_map.has(p_id));
|
|
UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
|
|
ur->add_do_method(this,"_move_node",p_id,p_to);
|
|
ur->add_undo_method(this,"_move_node",p_id,p_from);
|
|
}
|
|
|
|
void ShaderGraphView::_end_node_move()
|
|
{
|
|
UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
|
|
ur->commit_action();
|
|
}
|
|
|
|
void ShaderGraphView::_move_node(int p_id,const Vector2& p_to) {
|
|
|
|
ERR_FAIL_COND(!node_map.has(p_id));
|
|
node_map[p_id]->set_offset(p_to);
|
|
graph->node_set_pos(type,p_id,p_to);
|
|
}
|
|
|
|
void ShaderGraphView::_duplicate_nodes_request()
|
|
{
|
|
Array s_id;
|
|
|
|
for(Map<int,GraphNode*>::Element *E=node_map.front();E;E=E->next()) {
|
|
ShaderGraph::NodeType t=graph->node_get_type(type, E->key());
|
|
if (t==ShaderGraph::NODE_OUTPUT || t==ShaderGraph::NODE_INPUT)
|
|
continue;
|
|
GraphNode *gn = E->get();
|
|
if (gn && gn->is_selected())
|
|
s_id.push_back(E->key());
|
|
}
|
|
|
|
if (s_id.size()==0)
|
|
return;
|
|
|
|
UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
|
|
ur->create_action(TTR("Duplicate Graph Node(s)"));
|
|
ur->add_do_method(this,"_duplicate_nodes",s_id);
|
|
List<int> n_ids = graph->generate_ids(type, s_id.size());
|
|
for (List<int>::Element *E=n_ids.front();E;E=E->next())
|
|
ur->add_undo_method(graph.ptr(),"node_remove",type,E->get());
|
|
ur->add_do_method(this,"_update_graph");
|
|
ur->add_undo_method(this,"_update_graph");
|
|
ur->commit_action();
|
|
|
|
}
|
|
|
|
void ShaderGraphView::_duplicate_nodes(const Array &p_nodes)
|
|
{
|
|
List<int> n = List<int>();
|
|
for (int i=0; i<p_nodes.size();i++)
|
|
n.push_back(p_nodes.get(i));
|
|
graph->duplicate_nodes(type, n);
|
|
call_deferred("_update_graph");
|
|
}
|
|
|
|
void ShaderGraphView::_delete_nodes_request()
|
|
{
|
|
List<int> s_id=List<int>();
|
|
|
|
for(Map<int,GraphNode*>::Element *E=node_map.front();E;E=E->next()) {
|
|
ShaderGraph::NodeType t=graph->node_get_type(type, E->key());
|
|
if (t==ShaderGraph::NODE_OUTPUT)
|
|
continue;
|
|
GraphNode *gn = E->get();
|
|
if (gn && gn->is_selected())
|
|
s_id.push_back(E->key());
|
|
}
|
|
|
|
if (s_id.size()==0)
|
|
return;
|
|
|
|
UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
|
|
ur->create_action(TTR("Delete Shader Graph Node(s)"));
|
|
|
|
for (List<int>::Element *N=s_id.front();N;N=N->next()) {
|
|
ur->add_do_method(graph.ptr(),"node_remove",type,N->get());
|
|
ur->add_undo_method(graph.ptr(),"node_add",type,graph->node_get_type(type,N->get()),N->get());
|
|
ur->add_undo_method(graph.ptr(),"node_set_state",type,N->get(),graph->node_get_state(type,N->get()));
|
|
List<ShaderGraph::Connection> conns;
|
|
|
|
graph->get_node_connections(type,&conns);
|
|
for(List<ShaderGraph::Connection>::Element *E=conns.front();E;E=E->next()) {
|
|
|
|
if (E->get().dst_id==N->get() || E->get().src_id==N->get()) {
|
|
ur->add_undo_method(graph.ptr(),"connect_node",type,E->get().src_id,E->get().src_slot,E->get().dst_id,E->get().dst_slot);
|
|
}
|
|
}
|
|
}
|
|
ur->add_do_method(this,"_update_graph");
|
|
ur->add_undo_method(this,"_update_graph");
|
|
ur->commit_action();
|
|
|
|
}
|
|
|
|
void ShaderGraphView::_default_changed(int p_id, Node *p_button, int p_param, int v_type, String p_hint)
|
|
{
|
|
ToolButton *tb = p_button->cast_to<ToolButton>();
|
|
ped_popup->set_pos(tb->get_global_pos()+Vector2(0,tb->get_size().height));
|
|
ped_popup->set_size(tb->get_size());
|
|
edited_id=p_id;
|
|
edited_def=p_param;
|
|
Variant::Type vt = (Variant::Type)v_type;
|
|
Variant v = graph->default_get_value(type,p_id,edited_def);
|
|
int h=PROPERTY_HINT_NONE;
|
|
if (v.get_type() == Variant::NIL)
|
|
switch (vt) {
|
|
case Variant::VECTOR3:
|
|
v=Vector3();
|
|
break;
|
|
case Variant::REAL:
|
|
h=PROPERTY_HINT_RANGE;
|
|
v=0.0;
|
|
break;
|
|
case Variant::TRANSFORM:
|
|
v=Transform();
|
|
break;
|
|
case Variant::COLOR:
|
|
h=PROPERTY_HINT_COLOR_NO_ALPHA;
|
|
v=Color();
|
|
break;
|
|
}
|
|
|
|
ped_popup->edit(NULL,"",vt,v,h,p_hint);
|
|
|
|
ped_popup->popup();
|
|
}
|
|
|
|
ToolButton *ShaderGraphView::make_label(String text, Variant::Type v_type) {
|
|
ToolButton *l = memnew( ToolButton );
|
|
l->set_text(text);
|
|
l->set_text_align(ToolButton::ALIGN_LEFT);
|
|
l->add_style_override("hover", l->get_stylebox("normal", "ToolButton"));
|
|
l->add_style_override("pressed", l->get_stylebox("normal", "ToolButton"));
|
|
l->add_style_override("focus", l->get_stylebox("normal", "ToolButton"));
|
|
switch (v_type) {
|
|
case Variant::REAL:
|
|
l->set_icon(ped_popup->get_icon("Real", "EditorIcons"));
|
|
break;
|
|
case Variant::VECTOR3:
|
|
l->set_icon(ped_popup->get_icon("Vector", "EditorIcons"));
|
|
break;
|
|
case Variant::TRANSFORM:
|
|
l->set_icon(ped_popup->get_icon("Matrix", "EditorIcons"));
|
|
break;
|
|
case Variant::COLOR:
|
|
l->set_icon(ped_popup->get_icon("Color", "EditorIcons"));
|
|
}
|
|
return l;
|
|
}
|
|
|
|
ToolButton *ShaderGraphView::make_editor(String text,GraphNode* gn,int p_id,int param,Variant::Type v_type, String p_hint) {
|
|
ToolButton *edit = memnew( ToolButton );
|
|
edit->set_text(text);
|
|
edit->set_text_align(ToolButton::ALIGN_LEFT);
|
|
edit->set_flat(false);
|
|
edit->add_style_override("normal", gn->get_stylebox("defaultframe", "GraphNode"));
|
|
edit->add_style_override("hover", gn->get_stylebox("defaultframe", "GraphNode"));
|
|
edit->add_style_override("pressed", gn->get_stylebox("defaultframe", "GraphNode"));
|
|
edit->add_style_override("focus", gn->get_stylebox("defaultfocus", "GraphNode"));
|
|
edit->connect("pressed",this,"_default_changed",varray(p_id,edit,param,v_type,p_hint));
|
|
|
|
switch (v_type) {
|
|
case Variant::REAL:
|
|
edit->set_icon(ped_popup->get_icon("Real", "EditorIcons"));
|
|
break;
|
|
case Variant::VECTOR3:
|
|
edit->set_icon(ped_popup->get_icon("Vector", "EditorIcons"));
|
|
break;
|
|
case Variant::TRANSFORM:
|
|
edit->set_icon(ped_popup->get_icon("Matrix", "EditorIcons"));
|
|
break;
|
|
case Variant::COLOR:
|
|
Image icon_color = Image(15,15,false,Image::FORMAT_RGB);
|
|
Color c = graph->default_get_value(type,p_id,param);
|
|
for (int x=1;x<14;x++)
|
|
for (int y=1;y<14;y++)
|
|
icon_color.put_pixel(x,y,c);
|
|
Ref<ImageTexture> t;
|
|
t.instance();
|
|
t->create_from_image(icon_color);
|
|
edit->set_icon(t);
|
|
break;
|
|
}
|
|
return edit;
|
|
}
|
|
|
|
void ShaderGraphView::_create_node(int p_id) {
|
|
|
|
|
|
GraphNode *gn = memnew( GraphNode );
|
|
gn->set_show_close_button(true);
|
|
Color typecol[4]={
|
|
Color(0.9,0.4,1),
|
|
Color(0.8,1,0.2),
|
|
Color(1,0.2,0.2),
|
|
Color(0,1,1)
|
|
};
|
|
|
|
const String hint_spin = "-65536,65535,0.001";
|
|
const String hint_slider = "0.0,1.0,0.01,slider";
|
|
|
|
|
|
switch(graph->node_get_type(type,p_id)) {
|
|
|
|
case ShaderGraph::NODE_INPUT: {
|
|
|
|
gn->set_title("Input");
|
|
|
|
List<ShaderGraph::SlotInfo> si;
|
|
ShaderGraph::get_input_output_node_slot_info(graph->get_mode(),type,&si);
|
|
|
|
int idx=0;
|
|
for (List<ShaderGraph::SlotInfo>::Element *E=si.front();E;E=E->next()) {
|
|
ShaderGraph::SlotInfo& s=E->get();
|
|
if (s.dir==ShaderGraph::SLOT_IN) {
|
|
|
|
Label *l= memnew( Label );
|
|
l->set_text(s.name);
|
|
l->set_align(Label::ALIGN_RIGHT);
|
|
gn->add_child(l);
|
|
gn->set_slot(idx,false,0,Color(),true,s.type,typecol[s.type]);
|
|
idx++;
|
|
}
|
|
}
|
|
|
|
} break; // all inputs (case Shader type dependent)
|
|
case ShaderGraph::NODE_SCALAR_CONST: {
|
|
gn->set_title("Scalar");
|
|
SpinBox *sb = memnew( SpinBox );
|
|
sb->set_min(-100000);
|
|
sb->set_max(100000);
|
|
sb->set_step(0.001);
|
|
sb->set_val(graph->scalar_const_node_get_value(type,p_id));
|
|
sb->connect("value_changed",this,"_scalar_const_changed",varray(p_id));
|
|
gn->add_child(sb);
|
|
gn->set_slot(0,false,0,Color(),true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
|
|
|
|
} break; //scalar constant
|
|
case ShaderGraph::NODE_VEC_CONST: {
|
|
|
|
gn->set_title("Vector");
|
|
Array v3p(true);
|
|
for(int i=0;i<3;i++) {
|
|
HBoxContainer *hbc = memnew( HBoxContainer );
|
|
Label *l = memnew( Label );
|
|
l->set_text(String::chr('X'+i));
|
|
hbc->add_child(l);
|
|
SpinBox *sb = memnew( SpinBox );
|
|
sb->set_h_size_flags(Control::SIZE_EXPAND_FILL);
|
|
sb->set_min(-100000);
|
|
sb->set_max(100000);
|
|
sb->set_step(0.001);
|
|
sb->set_val(graph->vec_const_node_get_value(type,p_id)[i]);
|
|
sb->connect("value_changed",this,"_vec_const_changed",varray(p_id,v3p));
|
|
v3p.push_back(sb);
|
|
hbc->add_child(sb);
|
|
gn->add_child(hbc);
|
|
}
|
|
gn->set_slot(0,false,0,Color(),true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
|
|
|
|
} break; //vec3 constant
|
|
case ShaderGraph::NODE_RGB_CONST: {
|
|
|
|
gn->set_title("Color");
|
|
ColorPickerButton *cpb = memnew( ColorPickerButton );
|
|
cpb->set_color(graph->rgb_const_node_get_value(type,p_id));
|
|
cpb->connect("color_changed",this,"_rgb_const_changed",varray(p_id));
|
|
gn->add_child(cpb);
|
|
Label *l = memnew( Label );
|
|
l->set_text("RGB");
|
|
l->set_align(Label::ALIGN_RIGHT);
|
|
gn->add_child(l);
|
|
l = memnew( Label );
|
|
l->set_text("Alpha");
|
|
l->set_align(Label::ALIGN_RIGHT);
|
|
gn->add_child(l);
|
|
|
|
gn->set_slot(1,false,0,Color(),true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
|
|
gn->set_slot(2,false,0,Color(),true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
|
|
|
|
} break; //rgb constant (shows a color picker instead)
|
|
case ShaderGraph::NODE_XFORM_CONST: {
|
|
gn->set_title("XForm");
|
|
ToolButton *edit = memnew( ToolButton );
|
|
edit->set_text("edit..");
|
|
edit->connect("pressed",this,"_xform_const_changed",varray(p_id,edit));
|
|
gn->add_child(edit);
|
|
gn->set_slot(0,false,0,Color(),true,ShaderGraph::SLOT_TYPE_XFORM,typecol[ShaderGraph::SLOT_TYPE_XFORM]);
|
|
|
|
} break; // 4x4 matrix constant
|
|
case ShaderGraph::NODE_TIME: {
|
|
|
|
gn->set_title("Time");
|
|
Label *l = memnew( Label );
|
|
l->set_text("(s)");
|
|
l->set_align(Label::ALIGN_RIGHT);
|
|
gn->add_child(l);
|
|
gn->set_slot(0,false,0,Color(),true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
|
|
|
|
} break; // time in seconds
|
|
case ShaderGraph::NODE_SCREEN_TEX: {
|
|
|
|
gn->set_title("ScreenTex");
|
|
HBoxContainer *hbc = memnew( HBoxContainer );
|
|
hbc->add_constant_override("separation",0);
|
|
if (!graph->is_slot_connected(type,p_id,0)) {
|
|
Vector3 v = graph->default_get_value(type, p_id, 0);
|
|
hbc->add_child(make_editor("UV: " + v,gn,p_id,0,Variant::VECTOR3));
|
|
} else {
|
|
hbc->add_child(make_label("UV",Variant::VECTOR3));
|
|
}
|
|
hbc->add_spacer();
|
|
hbc->add_child( memnew(Label("RGB")));
|
|
gn->add_child(hbc);
|
|
gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
|
|
|
|
} break; // screen texture sampler (takes UV) (only usable in fragment case Shader)
|
|
case ShaderGraph::NODE_SCALAR_OP: {
|
|
|
|
gn->set_title("ScalarOp");
|
|
static const char* op_name[ShaderGraph::SCALAR_MAX_OP]={
|
|
("Add"),
|
|
("Sub"),
|
|
("Mul"),
|
|
("Div"),
|
|
("Mod"),
|
|
("Pow"),
|
|
("Max"),
|
|
("Min"),
|
|
("Atan2")
|
|
};
|
|
|
|
OptionButton *ob = memnew( OptionButton );
|
|
for(int i=0;i<ShaderGraph::SCALAR_MAX_OP;i++) {
|
|
|
|
ob->add_item(op_name[i],i);
|
|
}
|
|
|
|
ob->select(graph->scalar_op_node_get_op(type,p_id));
|
|
ob->connect("item_selected",this,"_scalar_op_changed",varray(p_id));
|
|
gn->add_child(ob);
|
|
|
|
HBoxContainer *hbc = memnew( HBoxContainer );
|
|
hbc->add_constant_override("separation",0);
|
|
if (graph->is_slot_connected(type, p_id, 0)) {
|
|
hbc->add_child(make_label("a",Variant::REAL));
|
|
} else {
|
|
float v = graph->default_get_value(type,p_id,0);
|
|
hbc->add_child(make_editor(String("a: ")+Variant(v),gn,p_id,0,Variant::REAL,hint_spin));
|
|
}
|
|
hbc->add_spacer();
|
|
hbc->add_child( memnew(Label("out")));
|
|
gn->add_child(hbc);
|
|
if (graph->is_slot_connected(type, p_id, 1)) {
|
|
gn->add_child(make_label("b",Variant::REAL));
|
|
} else {
|
|
float v = graph->default_get_value(type,p_id,1);
|
|
gn->add_child(make_editor(String("b: ")+Variant(v),gn,p_id,1,Variant::REAL,hint_spin));
|
|
}
|
|
|
|
gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
|
|
gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],false,0,Color());
|
|
|
|
|
|
} break; // scalar vs scalar op (mul: { } break; add: { } break; div: { } break; etc)
|
|
case ShaderGraph::NODE_VEC_OP: {
|
|
|
|
gn->set_title("VecOp");
|
|
static const char* op_name[ShaderGraph::VEC_MAX_OP]={
|
|
("Add"),
|
|
("Sub"),
|
|
("Mul"),
|
|
("Div"),
|
|
("Mod"),
|
|
("Pow"),
|
|
("Max"),
|
|
("Min"),
|
|
("Cross")
|
|
};
|
|
|
|
OptionButton *ob = memnew( OptionButton );
|
|
for(int i=0;i<ShaderGraph::VEC_MAX_OP;i++) {
|
|
|
|
ob->add_item(op_name[i],i);
|
|
}
|
|
|
|
ob->select(graph->vec_op_node_get_op(type,p_id));
|
|
ob->connect("item_selected",this,"_vec_op_changed",varray(p_id));
|
|
gn->add_child(ob);
|
|
|
|
HBoxContainer *hbc = memnew( HBoxContainer );
|
|
hbc->add_constant_override("separation",0);
|
|
if (graph->is_slot_connected(type, p_id, 0)) {
|
|
hbc->add_child(make_label("a",Variant::VECTOR3));
|
|
} else {
|
|
Vector3 v = graph->default_get_value(type,p_id,0);
|
|
hbc->add_child(make_editor(String("a: ")+v,gn,p_id,0,Variant::VECTOR3));
|
|
}
|
|
hbc->add_spacer();
|
|
hbc->add_child( memnew(Label("out")));
|
|
gn->add_child(hbc);
|
|
if (graph->is_slot_connected(type, p_id, 1)) {
|
|
gn->add_child(make_label("b",Variant::VECTOR3));
|
|
} else {
|
|
Vector3 v = graph->default_get_value(type,p_id,1);
|
|
gn->add_child(make_editor(String("b: ")+v,gn,p_id,1,Variant::VECTOR3));
|
|
}
|
|
|
|
gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
|
|
gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],false,0,Color());
|
|
|
|
|
|
} break; // vec3 vs vec3 op (mul: { } break;ad: { } break;div: { } break;crossprod: { } break;etc)
|
|
case ShaderGraph::NODE_VEC_SCALAR_OP: {
|
|
|
|
gn->set_title("VecScalarOp");
|
|
static const char* op_name[ShaderGraph::VEC_SCALAR_MAX_OP]={
|
|
("Mul"),
|
|
("Div"),
|
|
("Pow"),
|
|
};
|
|
|
|
OptionButton *ob = memnew( OptionButton );
|
|
for(int i=0;i<ShaderGraph::VEC_SCALAR_MAX_OP;i++) {
|
|
|
|
ob->add_item(op_name[i],i);
|
|
}
|
|
|
|
ob->select(graph->vec_scalar_op_node_get_op(type,p_id));
|
|
ob->connect("item_selected",this,"_vec_scalar_op_changed",varray(p_id));
|
|
gn->add_child(ob);
|
|
|
|
HBoxContainer *hbc = memnew( HBoxContainer );
|
|
hbc->add_constant_override("separation",0);
|
|
if (graph->is_slot_connected(type, p_id, 0)) {
|
|
hbc->add_child(make_label("a",Variant::VECTOR3));
|
|
} else {
|
|
Vector3 v = graph->default_get_value(type,p_id,0);
|
|
hbc->add_child(make_editor(String("a: ")+v,gn,p_id,0,Variant::VECTOR3));
|
|
}
|
|
hbc->add_spacer();
|
|
hbc->add_child( memnew(Label("out")));
|
|
gn->add_child(hbc);
|
|
|
|
if (graph->is_slot_connected(type, p_id, 1)) {
|
|
gn->add_child(make_label("b",Variant::REAL));
|
|
} else {
|
|
float v = graph->default_get_value(type,p_id,1);
|
|
gn->add_child(make_editor(String("b: ")+Variant(v),gn,p_id,1,Variant::REAL,hint_spin));
|
|
}
|
|
gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
|
|
gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],false,0,Color());
|
|
|
|
|
|
} break; // vec3 vs scalar op (mul: { } break; add: { } break; div: { } break; etc)
|
|
case ShaderGraph::NODE_RGB_OP: {
|
|
|
|
gn->set_title("RGB Op");
|
|
static const char* op_name[ShaderGraph::RGB_MAX_OP]={
|
|
("Screen"),
|
|
("Difference"),
|
|
("Darken"),
|
|
("Lighten"),
|
|
("Overlay"),
|
|
("Dodge"),
|
|
("Burn"),
|
|
("SoftLight"),
|
|
("HardLight")
|
|
};
|
|
|
|
OptionButton *ob = memnew( OptionButton );
|
|
for(int i=0;i<ShaderGraph::RGB_MAX_OP;i++) {
|
|
|
|
ob->add_item(op_name[i],i);
|
|
}
|
|
|
|
ob->select(graph->rgb_op_node_get_op(type,p_id));
|
|
ob->connect("item_selected",this,"_rgb_op_changed",varray(p_id));
|
|
gn->add_child(ob);
|
|
|
|
HBoxContainer *hbc = memnew( HBoxContainer );
|
|
hbc->add_constant_override("separation",0);
|
|
if (graph->is_slot_connected(type, p_id, 0)) {
|
|
hbc->add_child(make_label("a",Variant::COLOR));
|
|
} else {
|
|
hbc->add_child(make_editor(String("a: "),gn,p_id,0,Variant::COLOR));
|
|
}
|
|
hbc->add_spacer();
|
|
hbc->add_child( memnew(Label("out")));
|
|
gn->add_child(hbc);
|
|
if (graph->is_slot_connected(type, p_id, 1)) {
|
|
gn->add_child(make_label("b",Variant::COLOR));
|
|
} else {
|
|
gn->add_child(make_editor(String("b: "),gn,p_id,1,Variant::COLOR));
|
|
}
|
|
|
|
gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
|
|
gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],false,0,Color());
|
|
|
|
} break; // vec3 vs vec3 rgb op (with scalar amount): { } break; like brighten: { } break; darken: { } break; burn: { } break; dodge: { } break; multiply: { } break; etc.
|
|
case ShaderGraph::NODE_XFORM_MULT: {
|
|
|
|
gn->set_title("XFMult");
|
|
HBoxContainer *hbc = memnew( HBoxContainer );
|
|
if (graph->is_slot_connected(type, p_id, 0)) {
|
|
hbc->add_child(make_label("a",Variant::TRANSFORM));
|
|
} else {
|
|
hbc->add_child(make_editor(String("a: edit..."),gn,p_id,0,Variant::TRANSFORM));
|
|
}
|
|
hbc->add_spacer();
|
|
hbc->add_child( memnew(Label("out")));
|
|
gn->add_child(hbc);
|
|
if (graph->is_slot_connected(type, p_id, 1)) {
|
|
gn->add_child(make_label("b",Variant::TRANSFORM));
|
|
} else {
|
|
gn->add_child(make_editor(String("b: edit..."),gn,p_id,1,Variant::TRANSFORM));
|
|
}
|
|
|
|
gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_XFORM,typecol[ShaderGraph::SLOT_TYPE_XFORM],true,ShaderGraph::SLOT_TYPE_XFORM,typecol[ShaderGraph::SLOT_TYPE_XFORM]);
|
|
gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_XFORM,typecol[ShaderGraph::SLOT_TYPE_XFORM],false,0,Color());
|
|
|
|
|
|
} break; // mat4 x mat4
|
|
case ShaderGraph::NODE_XFORM_VEC_MULT: {
|
|
|
|
gn->set_title("XFVecMult");
|
|
|
|
CheckBox *button = memnew (CheckBox("RotOnly"));
|
|
button->set_pressed(graph->xform_vec_mult_node_get_no_translation(type,p_id));
|
|
button->connect("toggled",this,"_xform_inv_rev_changed",varray(p_id));
|
|
|
|
gn->add_child(button);
|
|
|
|
HBoxContainer *hbc = memnew( HBoxContainer );
|
|
hbc->add_constant_override("separation",0);
|
|
if (graph->is_slot_connected(type, p_id, 0)) {
|
|
hbc->add_child(make_label("xf",Variant::TRANSFORM));
|
|
} else {
|
|
hbc->add_child(make_editor(String("xf: edit..."),gn,p_id,0,Variant::TRANSFORM));
|
|
}
|
|
hbc->add_spacer();
|
|
Label *l = memnew(Label("out"));
|
|
l->set_align(Label::ALIGN_RIGHT);
|
|
hbc->add_child( l);
|
|
gn->add_child(hbc);
|
|
if (graph->is_slot_connected(type, p_id, 1)) {
|
|
gn->add_child(make_label("a",Variant::VECTOR3));
|
|
} else {
|
|
Vector3 v = graph->default_get_value(type,p_id,1);
|
|
gn->add_child(make_editor(String("a: ")+v,gn,p_id,1,Variant::VECTOR3));
|
|
}
|
|
|
|
gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_XFORM,typecol[ShaderGraph::SLOT_TYPE_XFORM],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
|
|
gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],false,0,Color());
|
|
|
|
} break;
|
|
case ShaderGraph::NODE_XFORM_VEC_INV_MULT: {
|
|
|
|
gn->set_title("XFVecInvMult");
|
|
|
|
|
|
CheckBox *button = memnew( CheckBox("RotOnly"));
|
|
button->set_pressed(graph->xform_vec_mult_node_get_no_translation(type,p_id));
|
|
button->connect("toggled",this,"_xform_inv_rev_changed",varray(p_id));
|
|
|
|
gn->add_child(button);
|
|
|
|
if (graph->is_slot_connected(type, p_id, 0)) {
|
|
gn->add_child(make_label("a",Variant::VECTOR3));
|
|
} else {
|
|
Vector3 v = graph->default_get_value(type,p_id,0);
|
|
gn->add_child(make_editor(String("a: ")+v,gn,p_id,0,Variant::VECTOR3));
|
|
}
|
|
HBoxContainer *hbc = memnew( HBoxContainer );
|
|
hbc->add_constant_override("separation",0);
|
|
if (graph->is_slot_connected(type, p_id, 1)) {
|
|
hbc->add_child(make_label("xf", Variant::TRANSFORM));
|
|
} else {
|
|
hbc->add_child(make_editor(String("xf: edit..."),gn,p_id,1,Variant::TRANSFORM));
|
|
}
|
|
hbc->add_spacer();
|
|
Label *l = memnew(Label("out"));
|
|
l->set_align(Label::ALIGN_RIGHT);
|
|
hbc->add_child( l);
|
|
gn->add_child(hbc);
|
|
|
|
gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],false,0,Color());
|
|
gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_XFORM,typecol[ShaderGraph::SLOT_TYPE_XFORM],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
|
|
|
|
|
|
} break; // mat4 x vec3 inverse mult (with no-translation option)
|
|
case ShaderGraph::NODE_SCALAR_FUNC: {
|
|
|
|
gn->set_title("ScalarFunc");
|
|
static const char* func_name[ShaderGraph::SCALAR_MAX_FUNC]={
|
|
("Sin"),
|
|
("Cos"),
|
|
("Tan"),
|
|
("ASin"),
|
|
("ACos"),
|
|
("ATan"),
|
|
("SinH"),
|
|
("CosH"),
|
|
("TanH"),
|
|
("Log"),
|
|
("Exp"),
|
|
("Sqrt"),
|
|
("Abs"),
|
|
("Sign"),
|
|
("Floor"),
|
|
("Round"),
|
|
("Ceil"),
|
|
("Frac"),
|
|
("Satr"),
|
|
("Neg")
|
|
};
|
|
|
|
OptionButton *ob = memnew( OptionButton );
|
|
for(int i=0;i<ShaderGraph::SCALAR_MAX_FUNC;i++) {
|
|
|
|
ob->add_item(func_name[i],i);
|
|
}
|
|
|
|
ob->select(graph->scalar_func_node_get_function(type,p_id));
|
|
ob->connect("item_selected",this,"_scalar_func_changed",varray(p_id));
|
|
gn->add_child(ob);
|
|
|
|
HBoxContainer *hbc = memnew( HBoxContainer );
|
|
if (graph->is_slot_connected(type, p_id, 0)) {
|
|
hbc->add_child(make_label("in", Variant::REAL));
|
|
} else {
|
|
float v = graph->default_get_value(type,p_id,0);
|
|
hbc->add_child(make_editor(String("in: ")+Variant(v),gn,p_id,0,Variant::REAL,hint_spin));
|
|
}
|
|
hbc->add_spacer();
|
|
hbc->add_child( memnew(Label("out")));
|
|
gn->add_child(hbc);
|
|
|
|
gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
|
|
|
|
|
|
} break; // scalar function (sin: { } break; cos: { } break; etc)
|
|
case ShaderGraph::NODE_VEC_FUNC: {
|
|
|
|
|
|
|
|
gn->set_title("VecFunc");
|
|
static const char* func_name[ShaderGraph::VEC_MAX_FUNC]={
|
|
("Normalize"),
|
|
("Saturate"),
|
|
("Negate"),
|
|
("Reciprocal"),
|
|
("RGB to HSV"),
|
|
("HSV to RGB"),
|
|
};
|
|
|
|
OptionButton *ob = memnew( OptionButton );
|
|
for(int i=0;i<ShaderGraph::VEC_MAX_FUNC;i++) {
|
|
|
|
ob->add_item(func_name[i],i);
|
|
}
|
|
|
|
ob->select(graph->vec_func_node_get_function(type,p_id));
|
|
ob->connect("item_selected",this,"_vec_func_changed",varray(p_id));
|
|
gn->add_child(ob);
|
|
|
|
HBoxContainer *hbc = memnew( HBoxContainer );
|
|
hbc->add_constant_override("separation",0);
|
|
if (graph->is_slot_connected(type, p_id, 0)) {
|
|
hbc->add_child(make_label("in", Variant::VECTOR3));
|
|
} else {
|
|
Vector3 v = graph->default_get_value(type,p_id,0);
|
|
hbc->add_child(make_editor(String("in: ")+v,gn,p_id,0,Variant::VECTOR3));
|
|
}
|
|
hbc->add_spacer();
|
|
hbc->add_child( memnew(Label("out")));
|
|
gn->add_child(hbc);
|
|
|
|
gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
|
|
|
|
} break; // vector function (normalize: { } break; negate: { } break; reciprocal: { } break; rgb2hsv: { } break; hsv2rgb: { } break; etc: { } break; etc)
|
|
case ShaderGraph::NODE_VEC_LEN: {
|
|
gn->set_title("VecLength");
|
|
HBoxContainer *hbc = memnew( HBoxContainer );
|
|
if (graph->is_slot_connected(type, p_id, 0)) {
|
|
hbc->add_child(make_label("in", Variant::VECTOR3));
|
|
} else {
|
|
Vector3 v = graph->default_get_value(type,p_id,0);
|
|
hbc->add_child(make_editor(String("in: ")+v,gn,p_id,0,Variant::VECTOR3));
|
|
}
|
|
hbc->add_spacer();
|
|
hbc->add_child( memnew(Label("len")));
|
|
gn->add_child(hbc);
|
|
|
|
gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
|
|
|
|
} break; // vec3 length
|
|
case ShaderGraph::NODE_DOT_PROD: {
|
|
|
|
gn->set_title("DotProduct");
|
|
HBoxContainer *hbc = memnew( HBoxContainer );
|
|
hbc->add_constant_override("separation",0);
|
|
if (graph->is_slot_connected(type, p_id, 0)) {
|
|
hbc->add_child(make_label("a", Variant::VECTOR3));
|
|
} else {
|
|
Vector3 v = graph->default_get_value(type,p_id,0);
|
|
hbc->add_child(make_editor(String("a: ")+v,gn,p_id,0,Variant::VECTOR3));
|
|
}
|
|
hbc->add_spacer();
|
|
hbc->add_child( memnew(Label("dp")));
|
|
gn->add_child(hbc);
|
|
if (graph->is_slot_connected(type, p_id, 1)) {
|
|
gn->add_child(make_label("b", Variant::VECTOR3));
|
|
} else {
|
|
Vector3 v = graph->default_get_value(type,p_id,1);
|
|
gn->add_child(make_editor(String("b: ")+v,gn,p_id,1,Variant::VECTOR3));
|
|
}
|
|
|
|
gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
|
|
gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],false,0,Color());
|
|
|
|
} break; // vec3 . vec3 (dot product -> scalar output)
|
|
case ShaderGraph::NODE_VEC_TO_SCALAR: {
|
|
|
|
gn->set_title("Vec2Scalar");
|
|
HBoxContainer *hbc = memnew( HBoxContainer );
|
|
hbc->add_constant_override("separation",0);
|
|
if (graph->is_slot_connected(type, p_id, 0)) {
|
|
hbc->add_child(make_label("vec", Variant::VECTOR3));
|
|
} else {
|
|
Vector3 v = graph->default_get_value(type,p_id,0);
|
|
hbc->add_child(make_editor(String("vec: ")+v,gn,p_id,0,Variant::VECTOR3));
|
|
}
|
|
hbc->add_spacer();
|
|
Label *l=memnew(Label("x"));
|
|
l->set_align(Label::ALIGN_RIGHT);
|
|
hbc->add_child( l);
|
|
gn->add_child(hbc);
|
|
l=memnew(Label("y"));
|
|
l->set_align(Label::ALIGN_RIGHT);
|
|
gn->add_child( l );
|
|
l=memnew(Label("z"));
|
|
l->set_align(Label::ALIGN_RIGHT);
|
|
gn->add_child( l);
|
|
|
|
gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
|
|
gn->set_slot(1,false,0,Color(),true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
|
|
gn->set_slot(2,false,0,Color(),true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
|
|
|
|
|
|
|
|
|
|
} break; // 1 vec3 input: { } break; 3 scalar outputs
|
|
case ShaderGraph::NODE_SCALAR_TO_VEC: {
|
|
|
|
gn->set_title("Scalar2Vec");
|
|
HBoxContainer *hbc = memnew( HBoxContainer );
|
|
if (graph->is_slot_connected(type, p_id, 0)) {
|
|
hbc->add_child(make_label("x", Variant::REAL));
|
|
} else {
|
|
float v = graph->default_get_value(type,p_id,0);
|
|
hbc->add_child(make_editor(String("x: ")+Variant(v),gn,p_id,0,Variant::REAL));
|
|
}
|
|
hbc->add_spacer();
|
|
hbc->add_child( memnew(Label("vec")));
|
|
gn->add_child(hbc);
|
|
if (graph->is_slot_connected(type, p_id, 1)) {
|
|
gn->add_child(make_label("y", Variant::REAL));
|
|
} else {
|
|
float v = graph->default_get_value(type,p_id,1);
|
|
gn->add_child(make_editor(String("y: ")+Variant(v),gn,p_id,1,Variant::REAL));
|
|
}
|
|
if (graph->is_slot_connected(type, p_id, 2)) {
|
|
gn->add_child(make_label("in", Variant::REAL));
|
|
} else {
|
|
float v = graph->default_get_value(type,p_id,2);
|
|
gn->add_child(make_editor(String("in: ")+Variant(v),gn,p_id,2,Variant::REAL));
|
|
}
|
|
|
|
gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
|
|
gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],false,0,Color());
|
|
gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],false,0,Color());
|
|
|
|
} break; // 3 scalar input: { } break; 1 vec3 output
|
|
case ShaderGraph::NODE_VEC_TO_XFORM: {
|
|
|
|
gn->set_title("Vec2XForm");
|
|
HBoxContainer *hbc = memnew( HBoxContainer );
|
|
hbc->add_constant_override("separation",0);
|
|
if (graph->is_slot_connected(type, p_id, 0)) {
|
|
hbc->add_child(make_label("x", Variant::VECTOR3));
|
|
} else {
|
|
Vector3 v = graph->default_get_value(type,p_id,0);
|
|
hbc->add_child(make_editor(String("x: ")+v,gn,p_id,0,Variant::VECTOR3));
|
|
}
|
|
hbc->add_spacer();
|
|
hbc->add_child( memnew(Label("xf")));
|
|
gn->add_child(hbc);
|
|
if (graph->is_slot_connected(type, p_id, 1)) {
|
|
gn->add_child(make_label("y", Variant::VECTOR3));
|
|
} else {
|
|
Vector3 v = graph->default_get_value(type,p_id,1);
|
|
gn->add_child(make_editor(String("y: ")+v,gn,p_id,1,Variant::VECTOR3));
|
|
}
|
|
if (graph->is_slot_connected(type, p_id, 2)) {
|
|
gn->add_child(make_label("z", Variant::VECTOR3));
|
|
} else {
|
|
Vector3 v = graph->default_get_value(type,p_id,2);
|
|
gn->add_child(make_editor(String("z: ")+v,gn,p_id,2,Variant::VECTOR3));
|
|
}
|
|
if (graph->is_slot_connected(type, p_id, 3)) {
|
|
gn->add_child(make_label("ofs", Variant::VECTOR3));
|
|
} else {
|
|
Vector3 v = graph->default_get_value(type,p_id,3);
|
|
gn->add_child(make_editor(String("ofs: ")+v,gn,p_id,3,Variant::VECTOR3));
|
|
}
|
|
|
|
gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_XFORM,typecol[ShaderGraph::SLOT_TYPE_XFORM]);
|
|
gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],false,0,Color());
|
|
gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],false,0,Color());
|
|
gn->set_slot(3,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],false,0,Color());
|
|
|
|
} break; // 3 vec input: { } break; 1 xform output
|
|
case ShaderGraph::NODE_XFORM_TO_VEC: {
|
|
|
|
gn->set_title("XForm2Vec");
|
|
|
|
HBoxContainer *hbc = memnew( HBoxContainer );
|
|
hbc->add_constant_override("separation",0);
|
|
if (graph->is_slot_connected(type, p_id, 0)) {
|
|
hbc->add_child(make_label("fx", Variant::TRANSFORM));
|
|
} else {
|
|
hbc->add_child(make_editor(String("fx: edit..."),gn,p_id,0,Variant::TRANSFORM));
|
|
}
|
|
hbc->add_spacer();
|
|
Label *l=memnew(Label("x"));
|
|
l->set_align(Label::ALIGN_RIGHT);
|
|
hbc->add_child( l);
|
|
gn->add_child(hbc);
|
|
l=memnew(Label("y"));
|
|
l->set_align(Label::ALIGN_RIGHT);
|
|
gn->add_child( l );
|
|
l=memnew(Label("z"));
|
|
l->set_align(Label::ALIGN_RIGHT);
|
|
gn->add_child( l);
|
|
l=memnew(Label("ofs"));
|
|
l->set_align(Label::ALIGN_RIGHT);
|
|
gn->add_child( l);
|
|
|
|
gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_XFORM,typecol[ShaderGraph::SLOT_TYPE_XFORM],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
|
|
gn->set_slot(1,false,0,Color(),true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
|
|
gn->set_slot(2,false,0,Color(),true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
|
|
gn->set_slot(3,false,0,Color(),true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
|
|
|
|
} break; // 3 vec input: { } break; 1 xform output
|
|
case ShaderGraph::NODE_SCALAR_INTERP: {
|
|
|
|
gn->set_title("ScalarInterp");
|
|
HBoxContainer *hbc = memnew( HBoxContainer );
|
|
hbc->add_constant_override("separation",0);
|
|
if (graph->is_slot_connected(type, p_id, 0)) {
|
|
hbc->add_child(make_label("a", Variant::REAL));
|
|
} else {
|
|
float v = graph->default_get_value(type,p_id,0);
|
|
hbc->add_child(make_editor(String("a: ")+Variant(v),gn,p_id,0,Variant::REAL,hint_spin));
|
|
}
|
|
hbc->add_spacer();
|
|
hbc->add_child( memnew(Label("interp")));
|
|
gn->add_child(hbc);
|
|
if (graph->is_slot_connected(type, p_id, 1)) {
|
|
gn->add_child(make_label("b", Variant::REAL));
|
|
} else {
|
|
float v = graph->default_get_value(type,p_id,1);
|
|
gn->add_child(make_editor(String("b: ")+Variant(v),gn,p_id,1,Variant::REAL,hint_spin));
|
|
}
|
|
if (graph->is_slot_connected(type, p_id, 2)) {
|
|
gn->add_child(make_label("c", Variant::REAL));
|
|
} else {
|
|
float v = graph->default_get_value(type,p_id,2);
|
|
gn->add_child(make_editor(String("c: ")+Variant(v),gn,p_id,2,Variant::REAL,hint_slider));
|
|
}
|
|
|
|
gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
|
|
gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],false,0,Color());
|
|
gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],false,0,Color());
|
|
|
|
|
|
} break; // scalar interpolation (with optional curve)
|
|
case ShaderGraph::NODE_VEC_INTERP: {
|
|
|
|
gn->set_title("VecInterp");
|
|
HBoxContainer *hbc = memnew( HBoxContainer );
|
|
if (graph->is_slot_connected(type, p_id, 0)) {
|
|
hbc->add_child(make_label("a", Variant::VECTOR3));
|
|
} else {
|
|
Vector3 v = graph->default_get_value(type,p_id,0);
|
|
hbc->add_child(make_editor(String("a: ")+v,gn,p_id,0,Variant::VECTOR3));
|
|
}
|
|
hbc->add_spacer();
|
|
hbc->add_child( memnew(Label("interp")));
|
|
gn->add_child(hbc);
|
|
if (graph->is_slot_connected(type, p_id, 1)) {
|
|
gn->add_child(make_label("b", Variant::VECTOR3));
|
|
} else {
|
|
Vector3 v = graph->default_get_value(type,p_id,1);
|
|
gn->add_child(make_editor(String("b: ")+v,gn,p_id,1,Variant::VECTOR3));
|
|
}
|
|
if (graph->is_slot_connected(type, p_id, 2)) {
|
|
gn->add_child(make_label("c", Variant::REAL));
|
|
} else {
|
|
float v = graph->default_get_value(type,p_id,2);
|
|
gn->add_child(make_editor(String("c: ")+Variant(v),gn,p_id,2,Variant::REAL,hint_slider));
|
|
}
|
|
|
|
gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
|
|
gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],false,0,Color());
|
|
gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],false,0,Color());
|
|
|
|
} break; // vec3 interpolation (with optional curve)
|
|
case ShaderGraph::NODE_COLOR_RAMP: {
|
|
|
|
gn->set_title("ColorRamp");
|
|
GraphColorRampEdit * ramp = memnew( GraphColorRampEdit );
|
|
|
|
DVector<real_t> offsets = graph->color_ramp_node_get_offsets(type,p_id);
|
|
DVector<Color> colors = graph->color_ramp_node_get_colors(type,p_id);
|
|
|
|
int oc = offsets.size();
|
|
|
|
if (oc) {
|
|
DVector<real_t>::Read rofs = offsets.read();
|
|
DVector<Color>::Read rcol = colors.read();
|
|
|
|
Vector<float> ofsv;
|
|
Vector<Color> colorv;
|
|
for(int i=0;i<oc;i++) {
|
|
ofsv.push_back(rofs[i]);
|
|
colorv.push_back(rcol[i]);
|
|
}
|
|
|
|
ramp->set_ramp(ofsv,colorv);
|
|
|
|
}
|
|
|
|
ramp->connect("ramp_changed",this,"_color_ramp_changed",varray(p_id,ramp));
|
|
ramp->set_custom_minimum_size(Size2(128,1));
|
|
gn->add_child(ramp);
|
|
|
|
|
|
HBoxContainer *hbc = memnew( HBoxContainer );
|
|
hbc->add_constant_override("separation",0);
|
|
if (graph->is_slot_connected(type, p_id, 0)) {
|
|
hbc->add_child(make_label("c", Variant::REAL));
|
|
} else {
|
|
float v = graph->default_get_value(type,p_id,0);
|
|
hbc->add_child(make_editor(String("c: ")+Variant(v),gn,p_id,0,Variant::REAL,hint_slider));
|
|
}
|
|
hbc->add_spacer();
|
|
Label *l=memnew(Label("rgb"));
|
|
l->set_align(Label::ALIGN_RIGHT);
|
|
hbc->add_child( l);
|
|
gn->add_child(hbc);
|
|
l=memnew(Label("alpha"));
|
|
l->set_align(Label::ALIGN_RIGHT);
|
|
gn->add_child( l);
|
|
|
|
|
|
gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
|
|
gn->set_slot(2,false,ShaderGraph::SLOT_MAX,Color(),true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
|
|
|
|
|
|
} break; // scalar interpolation (with optional curve)
|
|
case ShaderGraph::NODE_CURVE_MAP: {
|
|
|
|
gn->set_title("CurveMap");
|
|
GraphCurveMapEdit * map = memnew( GraphCurveMapEdit );
|
|
|
|
DVector<Vector2> points = graph->curve_map_node_get_points(type,p_id);
|
|
|
|
int oc = points.size();
|
|
|
|
if (oc) {
|
|
DVector<Vector2>::Read rofs = points.read();
|
|
|
|
|
|
Vector<Vector2> ofsv;
|
|
for(int i=0;i<oc;i++) {
|
|
ofsv.push_back(rofs[i]);
|
|
}
|
|
|
|
map->set_points(ofsv);
|
|
|
|
}
|
|
map->connect("curve_changed",this,"_curve_changed",varray(p_id,map));
|
|
|
|
//map->connect("map_changed",this,"_curve_map_changed",varray(p_id,map));
|
|
map->set_custom_minimum_size(Size2(128,64));
|
|
gn->add_child(map);
|
|
|
|
HBoxContainer *hbc = memnew( HBoxContainer );
|
|
hbc->add_constant_override("separation",0);
|
|
if (graph->is_slot_connected(type, p_id, 0)) {
|
|
hbc->add_child(make_label("c", Variant::REAL));
|
|
} else {
|
|
float v = graph->default_get_value(type,p_id,0);
|
|
hbc->add_child(make_editor(String("c: ")+Variant(v),gn,p_id,0,Variant::REAL,hint_slider));
|
|
}
|
|
hbc->add_spacer();
|
|
Label *l=memnew(Label("cmap"));
|
|
l->set_align(Label::ALIGN_RIGHT);
|
|
hbc->add_child( l);
|
|
gn->add_child(hbc);
|
|
|
|
|
|
gn->set_slot(1,true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR],true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
|
|
|
|
|
|
} break; // scalar interpolation (with optional curve)
|
|
|
|
case ShaderGraph::NODE_SCALAR_INPUT: {
|
|
|
|
gn->set_title("ScalarUniform");
|
|
LineEdit *le = memnew( LineEdit );
|
|
gn->add_child(le);
|
|
le->set_text(graph->input_node_get_name(type,p_id));
|
|
le->connect("text_entered",this,"_input_name_changed",varray(p_id,le));
|
|
SpinBox *sb = memnew( SpinBox );
|
|
sb->set_min(-100000);
|
|
sb->set_max(100000);
|
|
sb->set_step(0.001);
|
|
sb->set_val(graph->scalar_input_node_get_value(type,p_id));
|
|
sb->connect("value_changed",this,"_scalar_input_changed",varray(p_id));
|
|
gn->add_child(sb);
|
|
gn->set_slot(1,false,0,Color(),true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
|
|
|
|
} break; // scalar uniform (assignable in material)
|
|
case ShaderGraph::NODE_VEC_INPUT: {
|
|
|
|
gn->set_title("VectorUniform");
|
|
LineEdit *le = memnew( LineEdit );
|
|
gn->add_child(le);
|
|
le->set_text(graph->input_node_get_name(type,p_id));
|
|
le->connect("text_entered",this,"_input_name_changed",varray(p_id,le));
|
|
Array v3p(true);
|
|
for(int i=0;i<3;i++) {
|
|
HBoxContainer *hbc = memnew( HBoxContainer );
|
|
Label *l = memnew( Label );
|
|
l->set_text(String::chr('X'+i));
|
|
hbc->add_child(l);
|
|
SpinBox *sb = memnew( SpinBox );
|
|
sb->set_h_size_flags(Control::SIZE_EXPAND_FILL);
|
|
sb->set_min(-100000);
|
|
sb->set_max(100000);
|
|
sb->set_step(0.001);
|
|
sb->set_val(graph->vec_input_node_get_value(type,p_id)[i]);
|
|
sb->connect("value_changed",this,"_vec_input_changed",varray(p_id,v3p));
|
|
v3p.push_back(sb);
|
|
hbc->add_child(sb);
|
|
gn->add_child(hbc);
|
|
}
|
|
gn->set_slot(1,false,0,Color(),true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
|
|
|
|
} break; // vec3 uniform (assignable in material)
|
|
case ShaderGraph::NODE_RGB_INPUT: {
|
|
|
|
gn->set_title("ColorUniform");
|
|
LineEdit *le = memnew( LineEdit );
|
|
gn->add_child(le);
|
|
le->set_text(graph->input_node_get_name(type,p_id));
|
|
le->connect("text_entered",this,"_input_name_changed",varray(p_id,le));
|
|
ColorPickerButton *cpb = memnew( ColorPickerButton );
|
|
cpb->set_color(graph->rgb_input_node_get_value(type,p_id));
|
|
cpb->connect("color_changed",this,"_rgb_input_changed",varray(p_id));
|
|
gn->add_child(cpb);
|
|
Label *l = memnew( Label );
|
|
l->set_text("RGB");
|
|
l->set_align(Label::ALIGN_RIGHT);
|
|
gn->add_child(l);
|
|
l = memnew( Label );
|
|
l->set_text("Alpha");
|
|
l->set_align(Label::ALIGN_RIGHT);
|
|
gn->add_child(l);
|
|
|
|
gn->set_slot(2,false,0,Color(),true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
|
|
gn->set_slot(3,false,0,Color(),true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
|
|
|
|
|
|
} break; // color uniform (assignable in material)
|
|
case ShaderGraph::NODE_XFORM_INPUT: {
|
|
gn->set_title("XFUniform");
|
|
LineEdit *le = memnew( LineEdit );
|
|
gn->add_child(le);
|
|
le->set_text(graph->input_node_get_name(type,p_id));
|
|
le->connect("text_entered",this,"_input_name_changed",varray(p_id,le));
|
|
ToolButton *edit = memnew( ToolButton );
|
|
edit->set_text("edit..");
|
|
edit->connect("pressed",this,"_xform_input_changed",varray(p_id,edit));
|
|
gn->add_child(edit);
|
|
gn->set_slot(1,false,0,Color(),true,ShaderGraph::SLOT_TYPE_XFORM,typecol[ShaderGraph::SLOT_TYPE_XFORM]);
|
|
|
|
} break; // mat4 uniform (assignable in material)
|
|
case ShaderGraph::NODE_TEXTURE_INPUT: {
|
|
|
|
gn->set_title("TexUniform");
|
|
LineEdit *le = memnew( LineEdit );
|
|
gn->add_child(le);
|
|
le->set_text(graph->input_node_get_name(type,p_id));
|
|
le->connect("text_entered",this,"_input_name_changed",varray(p_id,le));
|
|
TextureFrame *tex = memnew( TextureFrame );
|
|
tex->set_expand(true);
|
|
tex->set_custom_minimum_size(Size2(80,80));
|
|
tex->set_drag_forwarding(this);
|
|
gn->add_child(tex);
|
|
tex->set_ignore_mouse(false);
|
|
tex->set_texture(graph->texture_input_node_get_value(type,p_id));
|
|
ToolButton *edit = memnew( ToolButton );
|
|
edit->set_text("edit..");
|
|
edit->connect("pressed",this,"_tex_edited",varray(p_id,edit));
|
|
gn->add_child(edit);
|
|
|
|
HBoxContainer *hbc = memnew( HBoxContainer );
|
|
hbc->add_constant_override("separation",0);
|
|
if (graph->is_slot_connected(type, p_id, 0)) {
|
|
hbc->add_child(make_label("UV", Variant::VECTOR3));
|
|
} else {
|
|
Vector3 v = graph->default_get_value(type,p_id,0);
|
|
hbc->add_child(make_editor(String("UV: ")+v,gn,p_id,0,Variant::VECTOR3));
|
|
}
|
|
hbc->add_spacer();
|
|
Label *l=memnew(Label("RGB"));
|
|
l->set_align(Label::ALIGN_RIGHT);
|
|
hbc->add_child(l);
|
|
gn->add_child(hbc);
|
|
l = memnew( Label );
|
|
l->set_text("Alpha");
|
|
l->set_align(Label::ALIGN_RIGHT);
|
|
gn->add_child(l);
|
|
|
|
gn->set_slot(3,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
|
|
gn->set_slot(4,false,0,Color(),true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
|
|
|
|
} break; // texture input (assignable in material)
|
|
case ShaderGraph::NODE_CUBEMAP_INPUT: {
|
|
|
|
gn->set_title("TexUniform");
|
|
LineEdit *le = memnew( LineEdit );
|
|
gn->add_child(le);
|
|
le->set_text(graph->input_node_get_name(type,p_id));
|
|
le->connect("text_entered",this,"_input_name_changed",varray(p_id,le));
|
|
|
|
ToolButton *edit = memnew( ToolButton );
|
|
edit->set_text("edit..");
|
|
edit->connect("pressed",this,"_cube_edited",varray(p_id,edit));
|
|
gn->add_child(edit);
|
|
|
|
|
|
HBoxContainer *hbc = memnew( HBoxContainer );
|
|
hbc->add_constant_override("separation",0);
|
|
if (graph->is_slot_connected(type, p_id, 0)) {
|
|
hbc->add_child(make_label("UV", Variant::VECTOR3));
|
|
} else {
|
|
Vector3 v = graph->default_get_value(type,p_id,0);
|
|
hbc->add_child(make_editor(String("UV: ")+v,gn,p_id,0,Variant::VECTOR3));
|
|
}
|
|
hbc->add_spacer();
|
|
Label *l=memnew(Label("RGB"));
|
|
l->set_align(Label::ALIGN_RIGHT);
|
|
hbc->add_child(l);
|
|
gn->add_child(hbc);
|
|
l = memnew( Label );
|
|
l->set_text("Alpha");
|
|
l->set_align(Label::ALIGN_RIGHT);
|
|
gn->add_child(l);
|
|
|
|
gn->set_slot(2,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
|
|
gn->set_slot(3,false,0,Color(),true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
|
|
|
|
} break; // cubemap input (assignable in material)
|
|
case ShaderGraph::NODE_DEFAULT_TEXTURE: {
|
|
|
|
gn->set_title("CanvasItemTex");
|
|
HBoxContainer *hbc = memnew( HBoxContainer );
|
|
hbc->add_constant_override("separation",0);
|
|
if (graph->is_slot_connected(type, p_id, 0)) {
|
|
hbc->add_child(make_label("UV", Variant::VECTOR3));
|
|
} else {
|
|
Vector3 v = graph->default_get_value(type,p_id,0);
|
|
hbc->add_child(make_editor(String("UV: ")+v,gn,p_id,0,Variant::VECTOR3));
|
|
}
|
|
hbc->add_spacer();
|
|
Label *l=memnew(Label("RGB"));
|
|
l->set_align(Label::ALIGN_RIGHT);
|
|
hbc->add_child(l);
|
|
gn->add_child(hbc);
|
|
l = memnew( Label );
|
|
l->set_text("Alpha");
|
|
l->set_align(Label::ALIGN_RIGHT);
|
|
gn->add_child(l);
|
|
|
|
gn->set_slot(0,true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC],true,ShaderGraph::SLOT_TYPE_VEC,typecol[ShaderGraph::SLOT_TYPE_VEC]);
|
|
gn->set_slot(1,false,0,Color(),true,ShaderGraph::SLOT_TYPE_SCALAR,typecol[ShaderGraph::SLOT_TYPE_SCALAR]);
|
|
|
|
|
|
} break; // screen texture sampler (takes UV) (only usable in fragment case Shader)
|
|
|
|
case ShaderGraph::NODE_OUTPUT: {
|
|
gn->set_title("Output");
|
|
gn->set_show_close_button(false);
|
|
|
|
List<ShaderGraph::SlotInfo> si;
|
|
ShaderGraph::get_input_output_node_slot_info(graph->get_mode(),type,&si);
|
|
|
|
Array colors;
|
|
colors.push_back("Color");
|
|
colors.push_back("LightColor");
|
|
colors.push_back("Light");
|
|
colors.push_back("Diffuse");
|
|
colors.push_back("Specular");
|
|
colors.push_back("Emmision");
|
|
Array reals;
|
|
reals.push_back("Alpha");
|
|
reals.push_back("DiffuseAlpha");
|
|
reals.push_back("NormalMapDepth");
|
|
reals.push_back("SpecExp");
|
|
reals.push_back("Glow");
|
|
reals.push_back("ShadeParam");
|
|
reals.push_back("SpecularExp");
|
|
reals.push_back("LightAlpha");
|
|
reals.push_back("PointSize");
|
|
reals.push_back("Discard");
|
|
|
|
int idx=0;
|
|
for (List<ShaderGraph::SlotInfo>::Element *E=si.front();E;E=E->next()) {
|
|
ShaderGraph::SlotInfo& s=E->get();
|
|
if (s.dir==ShaderGraph::SLOT_OUT) {
|
|
Variant::Type v;
|
|
if (colors.find(s.name)>=0)
|
|
v=Variant::COLOR;
|
|
else if (reals.find(s.name)>=0)
|
|
v=Variant::REAL;
|
|
else
|
|
v=Variant::VECTOR3;
|
|
gn->add_child(make_label(s.name, v));
|
|
gn->set_slot(idx,true,s.type,typecol[s.type],false,0,Color());
|
|
idx++;
|
|
}
|
|
}
|
|
|
|
} break; // output (case Shader type dependent)
|
|
case ShaderGraph::NODE_COMMENT: {
|
|
gn->set_title("Comment");
|
|
TextEdit *te = memnew(TextEdit);
|
|
te->set_custom_minimum_size(Size2(100,100));
|
|
gn->add_child(te);
|
|
te->set_text(graph->comment_node_get_text(type,p_id));
|
|
te->connect("text_changed",this,"_comment_edited",varray(p_id,te));
|
|
|
|
} break; // comment
|
|
|
|
|
|
|
|
}
|
|
|
|
gn->connect("dragged",this,"_node_moved",varray(p_id));
|
|
gn->connect("close_request",this,"_node_removed",varray(p_id),CONNECT_DEFERRED);
|
|
graph_edit->add_child(gn);
|
|
node_map[p_id]=gn;
|
|
gn->set_offset(graph->node_get_pos(type,p_id));
|
|
|
|
|
|
}
|
|
|
|
void ShaderGraphView::_update_graph() {
|
|
|
|
|
|
if (block_update)
|
|
return;
|
|
|
|
for (Map<int,GraphNode*>::Element *E=node_map.front();E;E=E->next()) {
|
|
|
|
memdelete(E->get());
|
|
}
|
|
|
|
node_map.clear();
|
|
|
|
if (!graph.is_valid())
|
|
return;
|
|
|
|
|
|
List<int> nl;
|
|
graph->get_node_list(type,&nl);
|
|
|
|
for(List<int>::Element *E=nl.front();E;E=E->next()) {
|
|
|
|
_create_node(E->get());
|
|
}
|
|
graph_edit->clear_connections();
|
|
|
|
List<ShaderGraph::Connection> connections;
|
|
graph->get_node_connections(type,&connections);
|
|
for(List<ShaderGraph::Connection>::Element *E=connections.front();E;E=E->next()) {
|
|
|
|
ERR_CONTINUE(!node_map.has(E->get().src_id) || !node_map.has(E->get().dst_id));
|
|
graph_edit->connect_node(node_map[E->get().src_id]->get_name(),E->get().src_slot,node_map[E->get().dst_id]->get_name(),E->get().dst_slot);
|
|
}
|
|
|
|
}
|
|
|
|
void ShaderGraphView::_sg_updated() {
|
|
|
|
if (!graph.is_valid())
|
|
return;
|
|
switch(graph->get_graph_error(type)) {
|
|
case ShaderGraph::GRAPH_OK: status->set_text(""); break;
|
|
case ShaderGraph::GRAPH_ERROR_CYCLIC: status->set_text(TTR("Error: Cyclic Connection Link")); break;
|
|
case ShaderGraph::GRAPH_ERROR_MISSING_CONNECTIONS: status->set_text(TTR("Error: Missing Input Connections")); break;
|
|
}
|
|
}
|
|
|
|
Variant ShaderGraphView::get_drag_data_fw(const Point2 &p_point, Control *p_from)
|
|
{
|
|
TextureFrame* frame = p_from->cast_to<TextureFrame>();
|
|
if (!frame)
|
|
return Variant();
|
|
|
|
if (!frame->get_texture().is_valid())
|
|
return Variant();
|
|
|
|
RES res = frame->get_texture();
|
|
return EditorNode::get_singleton()->drag_resource(res,p_from);
|
|
|
|
return Variant();
|
|
}
|
|
|
|
bool ShaderGraphView::can_drop_data_fw(const Point2 &p_point, const Variant &p_data, Control *p_from) const
|
|
{
|
|
if (p_data.get_type() != Variant::DICTIONARY)
|
|
return false;
|
|
|
|
Dictionary d = p_data;
|
|
|
|
if (d.has("type")){
|
|
if (d["type"] == "resource" && d.has("resource")) {
|
|
Variant val = d["resource"];
|
|
|
|
if (val.get_type()==Variant::OBJECT) {
|
|
RES res = val;
|
|
if (res.is_valid() && res->cast_to<Texture>())
|
|
return true;
|
|
}
|
|
}
|
|
else if (d["type"] == "files" && d.has("files")) {
|
|
Vector<String> files = d["files"];
|
|
if (files.size() != 1)
|
|
return false;
|
|
return (ResourceLoader::get_resource_type(files[0]) == "ImageTexture");
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void ShaderGraphView::drop_data_fw(const Point2 &p_point, const Variant &p_data, Control *p_from)
|
|
{
|
|
if (!can_drop_data_fw(p_point, p_data, p_from))
|
|
return;
|
|
|
|
TextureFrame *frame = p_from->cast_to<TextureFrame>();
|
|
if (!frame)
|
|
return;
|
|
|
|
Dictionary d = p_data;
|
|
Ref<Texture> tex;
|
|
|
|
if (d.has("type")) {
|
|
if (d["type"] == "resource" && d.has("resource")){
|
|
Variant val = d["resource"];
|
|
|
|
if (val.get_type()==Variant::OBJECT) {
|
|
RES res = val;
|
|
if (res.is_valid())
|
|
tex = Ref<Texture>(res->cast_to<Texture>());
|
|
}
|
|
}
|
|
else if (d["type"] == "files" && d.has("files")) {
|
|
Vector<String> files = d["files"];
|
|
RES res = ResourceLoader::load(files[0]);
|
|
if (res.is_valid())
|
|
tex = Ref<Texture>(res->cast_to<Texture>());
|
|
}
|
|
}
|
|
|
|
if (!tex.is_valid()) return;
|
|
|
|
GraphNode *gn = frame->get_parent()->cast_to<GraphNode>();
|
|
if (!gn) return;
|
|
|
|
int id = -1;
|
|
for(Map<int,GraphNode*>::Element *E = node_map.front();E;E=E->next())
|
|
if (E->get() == gn) {
|
|
id = E->key();
|
|
break;
|
|
}
|
|
print_line(String::num(double(id)));
|
|
if (id < 0) return;
|
|
|
|
if (graph->node_get_type(type,id)==ShaderGraph::NODE_TEXTURE_INPUT) {
|
|
|
|
UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
|
|
ur->create_action(TTR("Change Texture Uniform"));
|
|
ur->add_do_method(graph.ptr(),"texture_input_node_set_value",type,id,tex);
|
|
ur->add_undo_method(graph.ptr(),"texture_input_node_set_value",type,id,graph->texture_input_node_get_value(type,id));
|
|
ur->add_do_method(this,"_update_graph");
|
|
ur->add_undo_method(this,"_update_graph");
|
|
ur->commit_action();
|
|
}
|
|
}
|
|
|
|
void ShaderGraphView::set_graph(Ref<ShaderGraph> p_graph){
|
|
|
|
|
|
if (graph.is_valid()) {
|
|
graph->disconnect("updated",this,"_sg_updated");
|
|
}
|
|
graph=p_graph;
|
|
if (graph.is_valid()) {
|
|
graph->connect("updated",this,"_sg_updated");
|
|
}
|
|
_update_graph();
|
|
_sg_updated();
|
|
|
|
}
|
|
|
|
void ShaderGraphView::_notification(int p_what) {
|
|
|
|
if (p_what==NOTIFICATION_ENTER_TREE) {
|
|
|
|
ped_popup->connect("variant_changed",this,"_variant_edited");
|
|
}
|
|
}
|
|
|
|
void ShaderGraphView::add_node(int p_type, const Vector2 &location) {
|
|
|
|
if (p_type==ShaderGraph::NODE_INPUT && graph->node_count(type, p_type)>0)
|
|
return;
|
|
|
|
List<int> existing;
|
|
graph->get_node_list(type,&existing);
|
|
existing.sort();
|
|
int newid=1;
|
|
for(List<int>::Element *E=existing.front();E;E=E->next()) {
|
|
if (!E->next() || (E->get()+1!=E->next()->get())){
|
|
newid=E->get()+1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
Vector2 init_ofs = location;
|
|
while(true) {
|
|
bool valid=true;
|
|
for(List<int>::Element *E=existing.front();E;E=E->next()) {
|
|
Vector2 pos = graph->node_get_pos(type,E->get());
|
|
if (init_ofs==pos) {
|
|
init_ofs+=Vector2(20,20);
|
|
valid=false;
|
|
break;
|
|
|
|
}
|
|
}
|
|
|
|
if (valid)
|
|
break;
|
|
}
|
|
UndoRedo *ur=EditorNode::get_singleton()->get_undo_redo();
|
|
ur->create_action(TTR("Add Shader Graph Node"));
|
|
ur->add_do_method(graph.ptr(),"node_add",type,p_type,newid);
|
|
ur->add_do_method(graph.ptr(),"node_set_pos",type,newid,init_ofs);
|
|
ur->add_undo_method(graph.ptr(),"node_remove",type,newid);
|
|
ur->add_do_method(this,"_update_graph");
|
|
ur->add_undo_method(this,"_update_graph");
|
|
ur->commit_action();
|
|
|
|
}
|
|
|
|
void ShaderGraphView::_bind_methods() {
|
|
|
|
ObjectTypeDB::bind_method("_update_graph",&ShaderGraphView::_update_graph);
|
|
ObjectTypeDB::bind_method("_begin_node_move", &ShaderGraphView::_begin_node_move);
|
|
ObjectTypeDB::bind_method("_node_moved",&ShaderGraphView::_node_moved);
|
|
ObjectTypeDB::bind_method("_end_node_move", &ShaderGraphView::_end_node_move);
|
|
ObjectTypeDB::bind_method("_move_node",&ShaderGraphView::_move_node);
|
|
ObjectTypeDB::bind_method("_node_removed",&ShaderGraphView::_node_removed);
|
|
ObjectTypeDB::bind_method("_connection_request",&ShaderGraphView::_connection_request);
|
|
ObjectTypeDB::bind_method("_disconnection_request",&ShaderGraphView::_disconnection_request);
|
|
ObjectTypeDB::bind_method("_duplicate_nodes_request", &ShaderGraphView::_duplicate_nodes_request);
|
|
ObjectTypeDB::bind_method("_duplicate_nodes", &ShaderGraphView::_duplicate_nodes);
|
|
ObjectTypeDB::bind_method("_delete_nodes_request", &ShaderGraphView::_delete_nodes_request);
|
|
|
|
ObjectTypeDB::bind_method("_default_changed",&ShaderGraphView::_default_changed);
|
|
ObjectTypeDB::bind_method("_scalar_const_changed",&ShaderGraphView::_scalar_const_changed);
|
|
ObjectTypeDB::bind_method("_vec_const_changed",&ShaderGraphView::_vec_const_changed);
|
|
ObjectTypeDB::bind_method("_rgb_const_changed",&ShaderGraphView::_rgb_const_changed);
|
|
ObjectTypeDB::bind_method("_xform_const_changed",&ShaderGraphView::_xform_const_changed);
|
|
ObjectTypeDB::bind_method("_scalar_op_changed",&ShaderGraphView::_scalar_op_changed);
|
|
ObjectTypeDB::bind_method("_vec_op_changed",&ShaderGraphView::_vec_op_changed);
|
|
ObjectTypeDB::bind_method("_vec_scalar_op_changed",&ShaderGraphView::_vec_scalar_op_changed);
|
|
ObjectTypeDB::bind_method("_rgb_op_changed",&ShaderGraphView::_rgb_op_changed);
|
|
ObjectTypeDB::bind_method("_xform_inv_rev_changed",&ShaderGraphView::_xform_inv_rev_changed);
|
|
ObjectTypeDB::bind_method("_scalar_func_changed",&ShaderGraphView::_scalar_func_changed);
|
|
ObjectTypeDB::bind_method("_vec_func_changed",&ShaderGraphView::_vec_func_changed);
|
|
ObjectTypeDB::bind_method("_scalar_input_changed",&ShaderGraphView::_scalar_input_changed);
|
|
ObjectTypeDB::bind_method("_vec_input_changed",&ShaderGraphView::_vec_input_changed);
|
|
ObjectTypeDB::bind_method("_xform_input_changed",&ShaderGraphView::_xform_input_changed);
|
|
ObjectTypeDB::bind_method("_rgb_input_changed",&ShaderGraphView::_rgb_input_changed);
|
|
ObjectTypeDB::bind_method("_tex_input_change",&ShaderGraphView::_tex_input_change);
|
|
ObjectTypeDB::bind_method("_cube_input_change",&ShaderGraphView::_cube_input_change);
|
|
ObjectTypeDB::bind_method("_input_name_changed",&ShaderGraphView::_input_name_changed);
|
|
ObjectTypeDB::bind_method("_tex_edited",&ShaderGraphView::_tex_edited);
|
|
ObjectTypeDB::bind_method("_variant_edited",&ShaderGraphView::_variant_edited);
|
|
ObjectTypeDB::bind_method("_cube_edited",&ShaderGraphView::_cube_edited);
|
|
ObjectTypeDB::bind_method("_comment_edited",&ShaderGraphView::_comment_edited);
|
|
ObjectTypeDB::bind_method("_color_ramp_changed",&ShaderGraphView::_color_ramp_changed);
|
|
ObjectTypeDB::bind_method("_curve_changed",&ShaderGraphView::_curve_changed);
|
|
|
|
ObjectTypeDB::bind_method(_MD("get_drag_data_fw"), &ShaderGraphView::get_drag_data_fw);
|
|
ObjectTypeDB::bind_method(_MD("can_drop_data_fw"), &ShaderGraphView::can_drop_data_fw);
|
|
ObjectTypeDB::bind_method(_MD("drop_data_fw"), &ShaderGraphView::drop_data_fw);
|
|
|
|
ObjectTypeDB::bind_method("_sg_updated",&ShaderGraphView::_sg_updated);
|
|
}
|
|
|
|
ShaderGraphView::ShaderGraphView(ShaderGraph::ShaderType p_type) {
|
|
|
|
type=p_type;
|
|
graph_edit = memnew( GraphEdit );
|
|
block_update=false;
|
|
ped_popup = memnew( CustomPropertyEditor );
|
|
graph_edit->add_child(ped_popup);
|
|
status = memnew( Label );
|
|
graph_edit->get_top_layer()->add_child(status);
|
|
graph_edit->connect("_begin_node_move", this, "_begin_node_move");
|
|
graph_edit->connect("_end_node_move", this, "_end_node_move");
|
|
status->set_pos(Vector2(5,5));
|
|
status->add_color_override("font_color_shadow",Color(0,0,0));
|
|
status->add_color_override("font_color",Color(1,0.4,0.3));
|
|
status->add_constant_override("shadow_as_outline",1);
|
|
status->add_constant_override("shadow_offset_x",2);
|
|
status->add_constant_override("shadow_offset_y",2);
|
|
status->set_text("");
|
|
}
|
|
|
|
|
|
//////////////edit//////////////
|
|
void ShaderGraphEditor::edit(Ref<ShaderGraph> p_shader) {
|
|
|
|
for(int i=0;i<ShaderGraph::SHADER_TYPE_MAX;i++) {
|
|
graph_edits[i]->set_graph(p_shader);
|
|
}
|
|
}
|
|
|
|
void ShaderGraphEditor::_add_node(int p_type) {
|
|
|
|
ShaderGraph::ShaderType shader_type=ShaderGraph::ShaderType(tabs->get_current_tab());
|
|
graph_edits[shader_type]->add_node(p_type, next_location);
|
|
}
|
|
|
|
void ShaderGraphEditor::_popup_requested(const Vector2 &p_position)
|
|
{
|
|
Vector2 scroll_ofs=graph_edits[tabs->get_current_tab()]->get_graph_edit()->get_scroll_ofs();
|
|
next_location = get_local_mouse_pos() + scroll_ofs;
|
|
popup->set_global_pos(p_position);
|
|
popup->set_size( Size2( 200, 0) );
|
|
popup->popup();
|
|
popup->call_deferred("grab_click_focus");
|
|
popup->set_invalidate_click_until_motion();
|
|
}
|
|
|
|
void ShaderGraphEditor::_notification(int p_what) {
|
|
if (p_what==NOTIFICATION_ENTER_TREE) {
|
|
|
|
for(int i=0;i<ShaderGraph::NODE_TYPE_MAX;i++) {
|
|
|
|
if (i==ShaderGraph::NODE_OUTPUT)
|
|
continue;
|
|
if (!_2d && i==ShaderGraph::NODE_DEFAULT_TEXTURE)
|
|
continue;
|
|
|
|
String nn = node_names[i];
|
|
String ic = nn.get_slice(":",0);
|
|
String v = nn.get_slice(":",1);
|
|
bool addsep=false;
|
|
if (nn.ends_with(":")) {
|
|
addsep=true;
|
|
}
|
|
popup->add_icon_item(get_icon(ic,"EditorIcons"),v,i);
|
|
if (addsep)
|
|
popup->add_separator();
|
|
}
|
|
popup->connect("item_pressed",this,"_add_node");
|
|
|
|
|
|
}
|
|
}
|
|
|
|
void ShaderGraphEditor::_bind_methods() {
|
|
|
|
ObjectTypeDB::bind_method("_add_node",&ShaderGraphEditor::_add_node);
|
|
ObjectTypeDB::bind_method("_popup_requested",&ShaderGraphEditor::_popup_requested);
|
|
}
|
|
|
|
|
|
const char* ShaderGraphEditor::node_names[ShaderGraph::NODE_TYPE_MAX]={
|
|
("GraphInput:Input"), // all inputs (shader type dependent)
|
|
("GraphScalar:Scalar Constant"), //scalar constant
|
|
("GraphVector:Vector Constant"), //vec3 constant
|
|
("GraphRgb:RGB Constant"), //rgb constant (shows a color picker instead)
|
|
("GraphXform:XForm Constant"), // 4x4 matrix constant
|
|
("GraphTime:Time:"), // time in seconds
|
|
("GraphTexscreen:Screen Sample"), // screen texture sampler (takes uv) (only usable in fragment shader)
|
|
("GraphScalarOp:Scalar Operator"), // scalar vs scalar op (mul", add", div", etc)
|
|
("GraphVecOp:Vector Operator"), // vec3 vs vec3 op (mul",ad",div",crossprod",etc)
|
|
("GraphVecScalarOp:Scalar+Vector Operator"), // vec3 vs scalar op (mul", add", div", etc)
|
|
("GraphRgbOp:RGB Operator:"), // vec3 vs vec3 rgb op (with scalar amount)", like brighten", darken", burn", dodge", multiply", etc.
|
|
("GraphXformMult:XForm Multiply"), // mat4 x mat4
|
|
("GraphXformVecMult:XForm+Vector Multiply"), // mat4 x vec3 mult (with no-translation option)
|
|
("GraphXformVecImult:Form+Vector InvMultiply:"), // mat4 x vec3 inverse mult (with no-translation option)
|
|
("GraphXformScalarFunc:Scalar Function"), // scalar function (sin", cos", etc)
|
|
("GraphXformVecFunc:Vector Function"), // vector function (normalize", negate", reciprocal", rgb2hsv", hsv2rgb", etc", etc)
|
|
("GraphVecLength:Vector Length"), // vec3 length
|
|
("GraphVecDp:Dot Product:"), // vec3 . vec3 (dot product -> scalar output)
|
|
("GraphVecToScalars:Vector -> Scalars"), // 1 vec3 input", 3 scalar outputs
|
|
("GraphScalarsToVec:Scalars -> Vector"), // 3 scalar input", 1 vec3 output
|
|
("GraphXformToVecs:XForm -> Vectors"), // 3 vec input", 1 xform output
|
|
("GraphVecsToXform:Vectors -> XForm:"), // 3 vec input", 1 xform output
|
|
("GraphScalarInterp:Scalar Interpolate"), // scalar interpolation (with optional curve)
|
|
("GraphVecInterp:Vector Interpolate:"), // vec3 interpolation (with optional curve)
|
|
("GraphColorRamp:Color Ramp"), // vec3 interpolation (with optional curve)
|
|
("GraphCurveMap:Curve Remap:"), // vec3 interpolation (with optional curve)
|
|
("GraphScalarUniform:Scalar Uniform"), // scalar uniform (assignable in material)
|
|
("GraphVectorUniform:Vector Uniform"), // vec3 uniform (assignable in material)
|
|
("GraphRgbUniform:RGB Uniform"), // color uniform (assignable in material)
|
|
("GraphXformUniform:XForm Uniform"), // mat4 uniform (assignable in material)
|
|
("GraphTextureUniform:Texture Uniform"), // texture input (assignable in material)
|
|
("GraphCubeUniform:CubeMap Uniform:"), // cubemap input (assignable in material)
|
|
("GraphDefaultTexture:CanvasItem Texture:"), // cubemap input (assignable in material)
|
|
("Output"), // output (shader type dependent)
|
|
("GraphComment:Comment"), // comment
|
|
|
|
|
|
};
|
|
ShaderGraphEditor::ShaderGraphEditor(bool p_2d) {
|
|
_2d=p_2d;
|
|
|
|
popup = memnew( PopupMenu );
|
|
add_child(popup);
|
|
|
|
|
|
tabs = memnew(TabContainer);
|
|
tabs->set_v_size_flags(SIZE_EXPAND_FILL);
|
|
add_child(tabs);
|
|
const char* sname[ShaderGraph::SHADER_TYPE_MAX]={
|
|
"Vertex",
|
|
"Fragment",
|
|
"Light"
|
|
};
|
|
for(int i=0;i<ShaderGraph::SHADER_TYPE_MAX;i++) {
|
|
|
|
graph_edits[i]= memnew( ShaderGraphView(ShaderGraph::ShaderType(i)) );
|
|
add_child(graph_edits[i]);
|
|
graph_edits[i]->get_graph_edit()->set_name(sname[i]);
|
|
tabs->add_child(graph_edits[i]->get_graph_edit());
|
|
graph_edits[i]->get_graph_edit()->connect("connection_request",graph_edits[i],"_connection_request");
|
|
graph_edits[i]->get_graph_edit()->connect("disconnection_request",graph_edits[i],"_disconnection_request");
|
|
graph_edits[i]->get_graph_edit()->connect("duplicate_nodes_request", graph_edits[i], "_duplicate_nodes_request");
|
|
graph_edits[i]->get_graph_edit()->connect("popup_request",this,"_popup_requested");
|
|
graph_edits[i]->get_graph_edit()->connect("delete_nodes_request",graph_edits[i],"_delete_nodes_request");
|
|
graph_edits[i]->get_graph_edit()->set_right_disconnects(true);
|
|
}
|
|
|
|
tabs->set_current_tab(1);
|
|
|
|
set_custom_minimum_size(Size2(100,300));
|
|
}
|
|
|
|
|
|
void ShaderGraphEditorPlugin::edit(Object *p_object) {
|
|
|
|
shader_editor->edit(p_object->cast_to<ShaderGraph>());
|
|
}
|
|
|
|
bool ShaderGraphEditorPlugin::handles(Object *p_object) const {
|
|
|
|
ShaderGraph *shader=p_object->cast_to<ShaderGraph>();
|
|
if (!shader)
|
|
return false;
|
|
if (_2d)
|
|
return shader->get_mode()==Shader::MODE_CANVAS_ITEM;
|
|
else
|
|
return shader->get_mode()==Shader::MODE_MATERIAL;
|
|
}
|
|
|
|
void ShaderGraphEditorPlugin::make_visible(bool p_visible) {
|
|
|
|
if (p_visible) {
|
|
shader_editor->show();
|
|
} else {
|
|
|
|
shader_editor->hide();
|
|
}
|
|
|
|
}
|
|
|
|
ShaderGraphEditorPlugin::ShaderGraphEditorPlugin(EditorNode *p_node, bool p_2d) {
|
|
|
|
_2d=p_2d;
|
|
editor=p_node;
|
|
shader_editor = memnew( ShaderGraphEditor(p_2d) );
|
|
shader_editor->hide();
|
|
if (p_2d)
|
|
CanvasItemEditor::get_singleton()->get_bottom_split()->add_child(shader_editor);
|
|
else
|
|
SpatialEditor::get_singleton()->get_shader_split()->add_child(shader_editor);
|
|
|
|
|
|
// editor->get_viewport()->add_child(shader_editor);
|
|
// shader_editor->set_area_as_parent_rect();
|
|
// shader_editor->hide();
|
|
|
|
}
|
|
|
|
|
|
ShaderGraphEditorPlugin::~ShaderGraphEditorPlugin()
|
|
{
|
|
}
|
|
|
|
|
|
|