asgardius/virtualx-engine
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge remote-tracking branch 'upstream/master' into x11-window-management

Browse source
This commit is contained in:
hurikhan 2015-01-22 00:12:53 +09:00
commit 6dd1a21fb7
13 changed files with 163 additions and 41 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

58
drivers/gles2/rasterizer_gles2.cpp
View file

@ -4588,6 +4588,9 @@ void RasterizerGLES2::_update_shader( Shader* p_shader) const {
enablers.push_back("#define USE_TEXPIXEL_SIZE\n"); enablers.push_back("#define USE_TEXPIXEL_SIZE\n");
} }
if (vertex_flags.uses_worldvec) {
enablers.push_back("#define USE_WORLD_VEC\n");
}
canvas_shader.set_custom_shader_code(p_shader->custom_code_id,vertex_code, vertex_globals,fragment_code, light_code, fragment_globals,uniform_names,enablers); canvas_shader.set_custom_shader_code(p_shader->custom_code_id,vertex_code, vertex_globals,fragment_code, light_code, fragment_globals,uniform_names,enablers);
//postprocess_shader.set_custom_shader_code(p_shader->custom_code_id,vertex_code, vertex_globals,fragment_code, fragment_globals,uniform_names); //postprocess_shader.set_custom_shader_code(p_shader->custom_code_id,vertex_code, vertex_globals,fragment_code, fragment_globals,uniform_names);
@ -4954,12 +4957,26 @@ _FORCE_INLINE_ void RasterizerGLES2::_update_material_shader_params(Material *p_
Material::UniformData ud; Material::UniformData ud;
bool keep=true; //keep material value bool keep=true; //keep material value
bool has_old = old_mparams.has(E->key());
Map<StringName,Material::UniformData>::Element *OLD=old_mparams.find(E->key());
bool has_old = OLD;
bool old_inuse=has_old && old_mparams[E->key()].inuse; bool old_inuse=has_old && old_mparams[E->key()].inuse;
if (!has_old || !old_inuse) ud.istexture=(E->get().type==ShaderLanguage::TYPE_TEXTURE || E->get().type==ShaderLanguage::TYPE_CUBEMAP);
if (!has_old || !old_inuse) {
keep=false; keep=false;
else if (old_mparams[E->key()].value.get_type()!=E->value().default_value.get_type()) { }
else if (OLD->get().value.get_type()!=E->value().default_value.get_type()) {
if (OLD->get().value.get_type()==Variant::INT && E->get().type==ShaderLanguage::TYPE_FLOAT) {
//handle common mistake using shaders (feeding ints instead of float)
OLD->get().value=float(OLD->get().value);
keep=true;
} else if (!ud.istexture && E->value().default_value.get_type()!=Variant::NIL) {
keep=false;
}
//type changed between old and new //type changed between old and new
/* if (old_mparams[E->key()].value.get_type()==Variant::OBJECT) { /* if (old_mparams[E->key()].value.get_type()==Variant::OBJECT) {
if (E->value().default_value.get_type()!=Variant::_RID) //hackfor textures if (E->value().default_value.get_type()!=Variant::_RID) //hackfor textures
@ -4968,11 +4985,9 @@ _FORCE_INLINE_ void RasterizerGLES2::_update_material_shader_params(Material *p_
keep=false;*/ keep=false;*/
//value is invalid because type differs and default is not null //value is invalid because type differs and default is not null
if (E->value().default_value.get_type()!=Variant::NIL) ;
keep=false;
} }
ud.istexture=(E->get().type==ShaderLanguage::TYPE_TEXTURE || E->get().type==ShaderLanguage::TYPE_CUBEMAP);
if (keep) { if (keep) {
ud.value=old_mparams[E->key()].value; ud.value=old_mparams[E->key()].value;
@ -5096,8 +5111,10 @@ bool RasterizerGLES2::_setup_material(const Geometry *p_geometry,const Material
int texcoord=0; int texcoord=0;
for (Map<StringName,Material::UniformData>::Element *E=p_material->shader_params.front();E;E=E->next()) { for (Map<StringName,Material::UniformData>::Element *E=p_material->shader_params.front();E;E=E->next()) {
if (E->get().index<0) if (E->get().index<0)
continue; continue;
// print_line(String(E->key())+": "+E->get().value);
if (E->get().istexture) { if (E->get().istexture) {
//clearly a texture.. //clearly a texture..
RID rid = E->get().value; RID rid = E->get().value;
@ -8362,15 +8379,29 @@ void RasterizerGLES2::canvas_render_items(CanvasItem *p_item_list) {
int idx=0; int idx=0;
for(Map<StringName,ShaderLanguage::Uniform>::Element *E=shader->uniforms.front();E;E=E->next()) { for(Map<StringName,ShaderLanguage::Uniform>::Element *E=shader->uniforms.front();E;E=E->next()) {
Map<StringName,Variant>::Element *F=shader_owner->shader_param.find(E->key()); Map<StringName,Variant>::Element *F=shader_owner->shader_param.find(E->key());
Variant &v=F?F->get():E->get().default_value;
if (v.get_type()==Variant::_RID || v.get_type()==Variant::OBJECT) { if ((E->get().type==ShaderLanguage::TYPE_TEXTURE || E->get().type==ShaderLanguage::TYPE_CUBEMAP)) {
RID rid;
if (F) {
rid=F->get();
}
if (!rid.is_valid()) {
Map<StringName,RID>::Element *DT=shader->default_textures.find(E->key());
if (DT) {
rid=DT->get();
}
}
if (rid.is_valid()) {
int loc = canvas_shader.get_custom_uniform_location(idx); //should be automatic.. int loc = canvas_shader.get_custom_uniform_location(idx); //should be automatic..
glActiveTexture(GL_TEXTURE0+tex_id); glActiveTexture(GL_TEXTURE0+tex_id);
RID tex = v; Texture *t=texture_owner.get(rid);
Texture *t=texture_owner.get(tex);
if (!t) if (!t)
glBindTexture(GL_TEXTURE_2D,white_tex); glBindTexture(GL_TEXTURE_2D,white_tex);
else else
@ -8378,8 +8409,9 @@ void RasterizerGLES2::canvas_render_items(CanvasItem *p_item_list) {
glUniform1i(loc,tex_id); glUniform1i(loc,tex_id);
tex_id++; tex_id++;
}
} else { } else {
Variant &v=F?F->get():E->get().default_value;
canvas_shader.set_custom_uniform(idx,v); canvas_shader.set_custom_uniform(idx,v);
} }
@ -8403,7 +8435,7 @@ void RasterizerGLES2::canvas_render_items(CanvasItem *p_item_list) {
#endif #endif
glCopyTexSubImage2D(GL_TEXTURE_2D,0,x,y,x,y,viewport.width,viewport.height); glCopyTexSubImage2D(GL_TEXTURE_2D,0,x,y,x,y,viewport.width,viewport.height);
if (current_clip) { if (current_clip) {
print_line(" a clip "); // print_line(" a clip ");
} }
canvas_texscreen_used=true; canvas_texscreen_used=true;

15
drivers/gles2/shader_compiler_gles2.cpp
View file

@ -226,6 +226,9 @@ String ShaderCompilerGLES2::dump_node_code(SL::Node *p_node,int p_level,bool p_a
if (vnode->name==vname_var2_interp) { if (vnode->name==vname_var2_interp) {
flags->use_var2_interp=true; flags->use_var2_interp=true;
} }
if (vnode->name==vname_world_vec) {
uses_worldvec=true;
}
} }
@ -307,13 +310,13 @@ String ShaderCompilerGLES2::dump_node_code(SL::Node *p_node,int p_level,bool p_a
String mul_l=dump_node_code(onode->arguments[0],p_level,true); String mul_l=dump_node_code(onode->arguments[0],p_level,true);
String mul_r=dump_node_code(onode->arguments[1],p_level); String mul_r=dump_node_code(onode->arguments[1],p_level);
code=mul_l+"=(vec4("+mul_l+",1.0,1.0)*("+mul_r+")).xy"; code=mul_l+"=(vec4("+mul_l+",0.0,1.0)*("+mul_r+")).xy";
break; break;
} else if (onode->arguments[0]->get_datatype()==SL::TYPE_MAT4 && onode->arguments[1]->get_datatype()==SL::TYPE_VEC2) { } else if (onode->arguments[0]->get_datatype()==SL::TYPE_MAT4 && onode->arguments[1]->get_datatype()==SL::TYPE_VEC2) {
String mul_l=dump_node_code(onode->arguments[0],p_level,true); String mul_l=dump_node_code(onode->arguments[0],p_level,true);
String mul_r=dump_node_code(onode->arguments[1],p_level); String mul_r=dump_node_code(onode->arguments[1],p_level);
code=mul_l+"=(("+mul_l+")*vec4("+mul_r+",1.0,1.0)).xy"; code=mul_l+"=(("+mul_l+")*vec4("+mul_r+",0.0,1.0)).xy";
break; break;
} else if (onode->arguments[0]->get_datatype()==SL::TYPE_VEC2 && onode->arguments[1]->get_datatype()==SL::TYPE_MAT3) { } else if (onode->arguments[0]->get_datatype()==SL::TYPE_VEC2 && onode->arguments[1]->get_datatype()==SL::TYPE_MAT3) {
String mul_l=dump_node_code(onode->arguments[0],p_level,true); String mul_l=dump_node_code(onode->arguments[0],p_level,true);
@ -343,11 +346,11 @@ String ShaderCompilerGLES2::dump_node_code(SL::Node *p_node,int p_level,bool p_a
break; break;
} else if (onode->arguments[0]->get_datatype()==SL::TYPE_MAT4 && onode->arguments[1]->get_datatype()==SL::TYPE_VEC2) { } else if (onode->arguments[0]->get_datatype()==SL::TYPE_MAT4 && onode->arguments[1]->get_datatype()==SL::TYPE_VEC2) {
code="("+dump_node_code(onode->arguments[0],p_level)+"*vec4("+dump_node_code(onode->arguments[1],p_level)+",1.0,1.0)).xyz"; code="("+dump_node_code(onode->arguments[0],p_level)+"*vec4("+dump_node_code(onode->arguments[1],p_level)+",0.0,1.0)).xy";
break; break;
} else if (onode->arguments[0]->get_datatype()==SL::TYPE_VEC2 && onode->arguments[1]->get_datatype()==SL::TYPE_MAT4) { } else if (onode->arguments[0]->get_datatype()==SL::TYPE_VEC2 && onode->arguments[1]->get_datatype()==SL::TYPE_MAT4) {
code="(vec4("+dump_node_code(onode->arguments[0],p_level)+",1.0,1.0)*"+dump_node_code(onode->arguments[1],p_level)+").xyz"; code="(vec4("+dump_node_code(onode->arguments[0],p_level)+",0.0,1.0)*"+dump_node_code(onode->arguments[1],p_level)+").xy";
break; break;
} else if (onode->arguments[0]->get_datatype()==SL::TYPE_MAT3 && onode->arguments[1]->get_datatype()==SL::TYPE_VEC2) { } else if (onode->arguments[0]->get_datatype()==SL::TYPE_MAT3 && onode->arguments[1]->get_datatype()==SL::TYPE_VEC2) {
@ -599,6 +602,7 @@ Error ShaderCompilerGLES2::compile(const String& p_code, ShaderLanguage::ShaderT
uses_normalmap=false; uses_normalmap=false;
uses_normal=false; uses_normal=false;
uses_texpixel_size=false; uses_texpixel_size=false;
uses_worldvec=false;
vertex_code_writes_vertex=false; vertex_code_writes_vertex=false;
uniforms=r_uniforms; uniforms=r_uniforms;
flags=&r_flags; flags=&r_flags;
@ -634,6 +638,7 @@ Error ShaderCompilerGLES2::compile(const String& p_code, ShaderLanguage::ShaderT
r_flags.uses_normalmap=uses_normalmap; r_flags.uses_normalmap=uses_normalmap;
r_flags.uses_normal=uses_normalmap; r_flags.uses_normal=uses_normalmap;
r_flags.uses_texpixel_size=uses_texpixel_size; r_flags.uses_texpixel_size=uses_texpixel_size;
r_flags.uses_worldvec=uses_worldvec;
r_code_line=code; r_code_line=code;
r_globals_line=global_code; r_globals_line=global_code;
@ -774,6 +779,7 @@ ShaderCompilerGLES2::ShaderCompilerGLES2() {
mode_replace_table[3]["SRC_VERTEX"]="src_vtx"; mode_replace_table[3]["SRC_VERTEX"]="src_vtx";
mode_replace_table[3]["VERTEX"]="outvec.xy"; mode_replace_table[3]["VERTEX"]="outvec.xy";
mode_replace_table[3]["WORLD_VERTEX"]="outvec.xy";
mode_replace_table[3]["UV"]="uv_interp"; mode_replace_table[3]["UV"]="uv_interp";
mode_replace_table[3]["COLOR"]="color_interp"; mode_replace_table[3]["COLOR"]="color_interp";
mode_replace_table[3]["VAR1"]="var1_interp"; mode_replace_table[3]["VAR1"]="var1_interp";
@ -830,5 +836,6 @@ ShaderCompilerGLES2::ShaderCompilerGLES2() {
vname_normalmap="NORMALMAP"; vname_normalmap="NORMALMAP";
vname_normal="NORMAL"; vname_normal="NORMAL";
vname_texpixel_size="TEXTURE_PIXEL_SIZE"; vname_texpixel_size="TEXTURE_PIXEL_SIZE";
vname_world_vec="WORLD_VERTEX";
} }

3
drivers/gles2/shader_compiler_gles2.h
View file

@ -53,6 +53,7 @@ private:
bool uses_normalmap; bool uses_normalmap;
bool uses_normal; bool uses_normal;
bool uses_texpixel_size; bool uses_texpixel_size;
bool uses_worldvec;
bool vertex_code_writes_vertex; bool vertex_code_writes_vertex;
Flags *flags; Flags *flags;
@ -72,6 +73,7 @@ private:
StringName vname_normalmap; StringName vname_normalmap;
StringName vname_normal; StringName vname_normal;
StringName vname_texpixel_size; StringName vname_texpixel_size;
StringName vname_world_vec;
Map<StringName,ShaderLanguage::Uniform> *uniforms; Map<StringName,ShaderLanguage::Uniform> *uniforms;
@ -107,6 +109,7 @@ public:
bool uses_time; bool uses_time;
bool uses_normal; bool uses_normal;
bool uses_texpixel_size; bool uses_texpixel_size;
bool uses_worldvec;
}; };
Error compile(const String& p_code, ShaderLanguage::ShaderType p_type, String& r_code_line, String& r_globals_line, Flags& r_flags, Map<StringName,ShaderLanguage::Uniform> *r_uniforms=NULL); Error compile(const String& p_code, ShaderLanguage::ShaderType p_type, String& r_code_line, String& r_globals_line, Flags& r_flags, Map<StringName,ShaderLanguage::Uniform> *r_uniforms=NULL);

8
drivers/gles2/shaders/canvas.glsl
View file

@ -52,8 +52,10 @@ void main() {
VERTEX_SHADER_CODE VERTEX_SHADER_CODE
} }
#if !defined(USE_WORLD_VEC)
outvec = extra_matrix * outvec; outvec = extra_matrix * outvec;
outvec = modelview_matrix * outvec; outvec = modelview_matrix * outvec;
#endif
#ifdef USE_PIXEL_SNAP #ifdef USE_PIXEL_SNAP
@ -61,15 +63,15 @@ VERTEX_SHADER_CODE
#endif #endif
gl_Position = projection_matrix * outvec;
#ifdef USE_LIGHTING #ifdef USE_LIGHTING
light_tex_pos.xy = light_matrix * outvec; light_tex_pos.xy = light_matrix * gl_Position;
light_tex_pos.zw=outvec.xy - light_matrix[4].xy; //likely wrong light_tex_pos.zw=outvec.xy - light_matrix[4].xy; //likely wrong
#endif #endif
gl_Position = projection_matrix * outvec;
} }
[fragment] [fragment]

2
scene/2d/canvas_item.cpp
View file

@ -969,7 +969,7 @@ CanvasItem::CanvasItem() : xform_change(this) {
block_transform_notify=false; block_transform_notify=false;
// viewport=NULL; // viewport=NULL;
canvas_layer=NULL; canvas_layer=NULL;
use_parent_shader; use_parent_shader=false;
global_invalid=true; global_invalid=true;
C=NULL; C=NULL;

1
scene/register_scene_types.cpp
View file

@ -499,6 +499,7 @@ void register_scene_types() {
ObjectTypeDB::register_virtual_type<Shader>(); ObjectTypeDB::register_virtual_type<Shader>();
ObjectTypeDB::register_virtual_type<ShaderGraph>(); ObjectTypeDB::register_virtual_type<ShaderGraph>();
ObjectTypeDB::register_type<CanvasItemShader>(); ObjectTypeDB::register_type<CanvasItemShader>();
ObjectTypeDB::register_type<CanvasItemShaderGraph>();
#ifndef _3D_DISABLED #ifndef _3D_DISABLED
ObjectTypeDB::register_type<Mesh>(); ObjectTypeDB::register_type<Mesh>();

51
scene/resources/shader_graph.cpp
View file

@ -1320,6 +1320,43 @@ const ShaderGraph::InOutParamInfo ShaderGraph::inout_param_info[]={
{MODE_MATERIAL,SHADER_TYPE_LIGHT,"ShadeParam","SHADE_PARAM","",SLOT_TYPE_SCALAR,SLOT_IN}, {MODE_MATERIAL,SHADER_TYPE_LIGHT,"ShadeParam","SHADE_PARAM","",SLOT_TYPE_SCALAR,SLOT_IN},
//light out //light out
{MODE_MATERIAL,SHADER_TYPE_LIGHT,"Light","LIGHT","",SLOT_TYPE_VEC,SLOT_OUT}, {MODE_MATERIAL,SHADER_TYPE_LIGHT,"Light","LIGHT","",SLOT_TYPE_VEC,SLOT_OUT},
//canvas item vertex in
{MODE_CANVAS_ITEM,SHADER_TYPE_VERTEX,"Vertex","vec3(SRC_VERTEX,0)","",SLOT_TYPE_VEC,SLOT_IN},
{MODE_CANVAS_ITEM,SHADER_TYPE_VERTEX,"UV","SRC_UV","",SLOT_TYPE_VEC,SLOT_IN},
{MODE_CANVAS_ITEM,SHADER_TYPE_VERTEX,"Color","SRC_COLOR.rgb","",SLOT_TYPE_VEC,SLOT_IN},
{MODE_CANVAS_ITEM,SHADER_TYPE_VERTEX,"Alpha","SRC_COLOR.a","",SLOT_TYPE_SCALAR,SLOT_IN},
{MODE_CANVAS_ITEM,SHADER_TYPE_VERTEX,"WorldMatrix","WORLD_MATRIX","",SLOT_TYPE_XFORM,SLOT_IN},
{MODE_CANVAS_ITEM,SHADER_TYPE_VERTEX,"ExtraMatrix","EXTRA_MATRIX","",SLOT_TYPE_XFORM,SLOT_IN},
{MODE_CANVAS_ITEM,SHADER_TYPE_VERTEX,"ProjectionMatrix","PROJECTION_MATRIX","",SLOT_TYPE_XFORM,SLOT_IN},
//canvas item vertex out
{MODE_CANVAS_ITEM,SHADER_TYPE_VERTEX,"Vertex","VERTEX",".xy",SLOT_TYPE_VEC,SLOT_OUT},
{MODE_CANVAS_ITEM,SHADER_TYPE_VERTEX,"UV","UV",".xy",SLOT_TYPE_VEC,SLOT_OUT},
{MODE_CANVAS_ITEM,SHADER_TYPE_VERTEX,"Color","COLOR.rgb","",SLOT_TYPE_VEC,SLOT_OUT},
{MODE_CANVAS_ITEM,SHADER_TYPE_VERTEX,"Alpha","COLOR.a","",SLOT_TYPE_SCALAR,SLOT_OUT},
{MODE_CANVAS_ITEM,SHADER_TYPE_VERTEX,"Var1","VAR1.rgb","",SLOT_TYPE_VEC,SLOT_OUT},
{MODE_CANVAS_ITEM,SHADER_TYPE_VERTEX,"Var2","VAR2.rgb","",SLOT_TYPE_VEC,SLOT_OUT},
{MODE_CANVAS_ITEM,SHADER_TYPE_VERTEX,"PointSize","POINT_SIZE","",SLOT_TYPE_SCALAR,SLOT_OUT},
//canvas item fragment in
{MODE_CANVAS_ITEM,SHADER_TYPE_FRAGMENT,"Color","SRC_COLOR.rgb","",SLOT_TYPE_VEC,SLOT_IN},
{MODE_CANVAS_ITEM,SHADER_TYPE_FRAGMENT,"Alpha","SRC_COLOR.a","",SLOT_TYPE_SCALAR,SLOT_IN},
{MODE_CANVAS_ITEM,SHADER_TYPE_FRAGMENT,"UV","vec3(UV,0)","",SLOT_TYPE_VEC,SLOT_IN},
{MODE_CANVAS_ITEM,SHADER_TYPE_FRAGMENT,"UVScreen","vec3(SCREEN_UV,0)","",SLOT_TYPE_VEC,SLOT_IN},
{MODE_CANVAS_ITEM,SHADER_TYPE_FRAGMENT,"TexPixelSize","vec3(TEXTURE_PIXEL_SIZE,0)","",SLOT_TYPE_VEC,SLOT_IN},
{MODE_CANVAS_ITEM,SHADER_TYPE_FRAGMENT,"Var1","VAR1.rgb","",SLOT_TYPE_VEC,SLOT_IN},
{MODE_CANVAS_ITEM,SHADER_TYPE_FRAGMENT,"Var2","VAR2.rgb","",SLOT_TYPE_VEC,SLOT_IN},
{MODE_CANVAS_ITEM,SHADER_TYPE_FRAGMENT,"PointCoord","POINT_COORD","",SLOT_TYPE_VEC,SLOT_IN},
//canvas item fragment out
{MODE_CANVAS_ITEM,SHADER_TYPE_FRAGMENT,"Color","COLOR.rgb","",SLOT_TYPE_VEC,SLOT_OUT},
{MODE_CANVAS_ITEM,SHADER_TYPE_FRAGMENT,"Alpha","COLOR.a","",SLOT_TYPE_SCALAR,SLOT_OUT},
{MODE_CANVAS_ITEM,SHADER_TYPE_FRAGMENT,"Normal","NORMAL","",SLOT_TYPE_VEC,SLOT_OUT},
//canvas item light in
{MODE_CANVAS_ITEM,SHADER_TYPE_LIGHT,"Color","COLOR.rgb","",SLOT_TYPE_VEC,SLOT_IN},
{MODE_CANVAS_ITEM,SHADER_TYPE_LIGHT,"Normal","NORMAL","",SLOT_TYPE_VEC,SLOT_IN},
{MODE_CANVAS_ITEM,SHADER_TYPE_LIGHT,"LightDist","LIGHT_DISTANCE","",SLOT_TYPE_SCALAR,SLOT_IN},
{MODE_CANVAS_ITEM,SHADER_TYPE_LIGHT,"LightDir","vec3(LIGHT_DIR,0)","",SLOT_TYPE_VEC,SLOT_IN},
{MODE_CANVAS_ITEM,SHADER_TYPE_LIGHT,"PointCoord","POINT_COORD","",SLOT_TYPE_VEC,SLOT_IN},
//canvas item light out
{MODE_CANVAS_ITEM,SHADER_TYPE_LIGHT,"Light","LIGHT","",SLOT_TYPE_VEC,SLOT_OUT},
//end //end
{MODE_MATERIAL,SHADER_TYPE_FRAGMENT,NULL,NULL,NULL,SLOT_TYPE_SCALAR,SLOT_OUT}, {MODE_MATERIAL,SHADER_TYPE_FRAGMENT,NULL,NULL,NULL,SLOT_TYPE_SCALAR,SLOT_OUT},
@ -1373,6 +1410,7 @@ const ShaderGraph::NodeSlotInfo ShaderGraph::node_slot_info[]= {
{NODE_XFORM_INPUT,{SLOT_MAX},{SLOT_TYPE_XFORM,SLOT_MAX}}, // mat4 uniform (assignable in material) {NODE_XFORM_INPUT,{SLOT_MAX},{SLOT_TYPE_XFORM,SLOT_MAX}}, // mat4 uniform (assignable in material)
{NODE_TEXTURE_INPUT,{SLOT_TYPE_VEC,SLOT_MAX},{SLOT_TYPE_VEC,SLOT_TYPE_SCALAR,SLOT_MAX}}, // texture input (assignable in material) {NODE_TEXTURE_INPUT,{SLOT_TYPE_VEC,SLOT_MAX},{SLOT_TYPE_VEC,SLOT_TYPE_SCALAR,SLOT_MAX}}, // texture input (assignable in material)
{NODE_CUBEMAP_INPUT,{SLOT_TYPE_VEC,SLOT_MAX},{SLOT_TYPE_VEC,SLOT_TYPE_SCALAR,SLOT_MAX}}, // cubemap input (assignable in material) {NODE_CUBEMAP_INPUT,{SLOT_TYPE_VEC,SLOT_MAX},{SLOT_TYPE_VEC,SLOT_TYPE_SCALAR,SLOT_MAX}}, // cubemap input (assignable in material)
{NODE_DEFAULT_TEXTURE,{SLOT_TYPE_VEC,SLOT_MAX},{SLOT_TYPE_VEC,SLOT_TYPE_SCALAR,SLOT_MAX}}, // cubemap input (assignable in material)
{NODE_COMMENT,{SLOT_MAX},{SLOT_MAX}}, // comment {NODE_COMMENT,{SLOT_MAX},{SLOT_MAX}}, // comment
{NODE_TYPE_MAX,{SLOT_MAX},{SLOT_MAX}} {NODE_TYPE_MAX,{SLOT_MAX},{SLOT_MAX}}
}; };
@ -1731,6 +1769,11 @@ void ShaderGraph::_update_shader() {
} else if (i==SHADER_TYPE_FRAGMENT && get_mode()==MODE_MATERIAL) { } else if (i==SHADER_TYPE_FRAGMENT && get_mode()==MODE_MATERIAL) {
if (name==("IN_NORMAL")) if (name==("IN_NORMAL"))
code[i]="vec3 IN_NORMAL=NORMAL;\n"+code[i]; code[i]="vec3 IN_NORMAL=NORMAL;\n"+code[i];
} else if (i==SHADER_TYPE_VERTEX && get_mode()==MODE_CANVAS_ITEM) {
if (name==("SRC_COLOR"))
code[i]="vec3 SRC_COLOR=COLOR.rgb;\n"+code[i];
if (name==("SRC_UV"))
code[i]="vec3 SRC_UV=vec3(UV,0);\n"+code[i];
} }
} }
@ -1747,6 +1790,10 @@ void ShaderGraph::_update_shader() {
all_ok=false; all_ok=false;
} }
/*print_line("VERTEX: \n"+code[0]);
print_line("FRAGMENT: \n"+code[1]);
print_line("LIGHT: \n"+code[2]);*/
if (all_ok) { if (all_ok) {
set_code(code[0],code[1],code[2]); set_code(code[0],code[1],code[2]);
} }
@ -1926,7 +1973,7 @@ void ShaderGraph::_add_node_code(ShaderType p_type,Node *p_node,const Vector<Str
code+=OUTNAME(p_node->id,0)+"=TIME;\n"; code+=OUTNAME(p_node->id,0)+"=TIME;\n";
}break; }break;
case NODE_SCREEN_TEX: { case NODE_SCREEN_TEX: {
code+=OUTNAME(p_node->id,0)+"=texscreen("+p_inputs[0]+");\n"; code+=OUTNAME(p_node->id,0)+"=texscreen("+p_inputs[0]+".xy);\n";
}break; }break;
case NODE_SCALAR_OP: { case NODE_SCALAR_OP: {
int op = p_node->param1; int op = p_node->param1;
@ -2372,7 +2419,7 @@ void ShaderGraph::_add_node_code(ShaderType p_type,Node *p_node,const Vector<Str
code += OUTNAME(p_node->id,1)+"="+rname+".a;\n"; code += OUTNAME(p_node->id,1)+"="+rname+".a;\n";
} else { } else {
//not supported
code += OUTNAME(p_node->id,0)+"=vec3(0,0,0);\n"; code += OUTNAME(p_node->id,0)+"=vec3(0,0,0);\n";
code += OUTNAME(p_node->id,1)+"=1.0;\n"; code += OUTNAME(p_node->id,1)+"=1.0;\n";

14
scene/resources/shader_graph.h
View file

@ -406,7 +406,6 @@ VARIANT_ENUM_CAST( ShaderGraph::GraphError );
class MaterialShaderGraph : public ShaderGraph { class MaterialShaderGraph : public ShaderGraph {
OBJ_TYPE( MaterialShaderGraph, ShaderGraph ); OBJ_TYPE( MaterialShaderGraph, ShaderGraph );
RES_BASE_EXTENSION("sgp");
public: public:
@ -416,4 +415,17 @@ public:
} }
}; };
class CanvasItemShaderGraph : public ShaderGraph {
OBJ_TYPE( CanvasItemShaderGraph, ShaderGraph );
public:
CanvasItemShaderGraph() : ShaderGraph(MODE_CANVAS_ITEM) {
}
};
#endif // SHADER_GRAPH_H #endif // SHADER_GRAPH_H

1
servers/visual/shader_language.cpp
View file

@ -1112,6 +1112,7 @@ const ShaderLanguage::BuiltinsDef ShaderLanguage::ci_vertex_builtins_defs[]={
{ "SRC_VERTEX", TYPE_VEC2}, { "SRC_VERTEX", TYPE_VEC2},
{ "VERTEX", TYPE_VEC2}, { "VERTEX", TYPE_VEC2},
{ "WORLD_VERTEX", TYPE_VEC2},
{ "UV", TYPE_VEC2}, { "UV", TYPE_VEC2},
{ "COLOR", TYPE_VEC4}, { "COLOR", TYPE_VEC4},
{ "VAR1", TYPE_VEC4}, { "VAR1", TYPE_VEC4},

3
tools/editor/editor_node.cpp
View file

@ -4035,7 +4035,8 @@ EditorNode::EditorNode() {
add_editor_plugin( memnew( ScriptEditorPlugin(this) ) ); add_editor_plugin( memnew( ScriptEditorPlugin(this) ) );
add_editor_plugin( memnew( EditorHelpPlugin(this) ) ); add_editor_plugin( memnew( EditorHelpPlugin(this) ) );
add_editor_plugin( memnew( AnimationPlayerEditorPlugin(this) ) ); add_editor_plugin( memnew( AnimationPlayerEditorPlugin(this) ) );
add_editor_plugin( memnew( ShaderGraphEditorPlugin(this) ) ); add_editor_plugin( memnew( ShaderGraphEditorPlugin(this,true) ) );
add_editor_plugin( memnew( ShaderGraphEditorPlugin(this,false) ) );
add_editor_plugin( memnew( ShaderEditorPlugin(this,true) ) ); add_editor_plugin( memnew( ShaderEditorPlugin(this,true) ) );
add_editor_plugin( memnew( ShaderEditorPlugin(this,false) ) ); add_editor_plugin( memnew( ShaderEditorPlugin(this,false) ) );
add_editor_plugin( memnew( CameraEditorPlugin(this) ) ); add_editor_plugin( memnew( CameraEditorPlugin(this) ) );

2
tools/editor/plugins/shader_editor_plugin.cpp
View file

@ -396,7 +396,7 @@ void ShaderEditor::edit(const Ref<Shader>& p_shader) {
light_editor->set_edited_shader(shader,ShaderLanguage::SHADER_CANVAS_ITEM_LIGHT); light_editor->set_edited_shader(shader,ShaderLanguage::SHADER_CANVAS_ITEM_LIGHT);
} }
vertex_editor->set_edited_shader(shader,ShaderLanguage::SHADER_MATERIAL_VERTEX); //vertex_editor->set_edited_shader(shader,ShaderLanguage::SHADER_MATERIAL_VERTEX);
// see if already has it // see if already has it

24
tools/editor/plugins/shader_graph_editor_plugin.cpp
View file

@ -33,7 +33,7 @@
#include "scene/gui/panel.h" #include "scene/gui/panel.h"
#include "spatial_editor_plugin.h" #include "spatial_editor_plugin.h"
#include "os/keyboard.h" #include "os/keyboard.h"
#include "canvas_item_editor_plugin.h"
void GraphColorRampEdit::_input_event(const InputEvent& p_event) { void GraphColorRampEdit::_input_event(const InputEvent& p_event) {
@ -2234,6 +2234,9 @@ void ShaderGraphEditor::_notification(int p_what) {
if (i==ShaderGraph::NODE_OUTPUT) if (i==ShaderGraph::NODE_OUTPUT)
continue; continue;
if (!_2d && i==ShaderGraph::NODE_DEFAULT_TEXTURE)
continue;
String nn = node_names[i]; String nn = node_names[i];
String ic = nn.get_slice(":",0); String ic = nn.get_slice(":",0);
String v = nn.get_slice(":",1); String v = nn.get_slice(":",1);
@ -2297,7 +2300,8 @@ const char* ShaderGraphEditor::node_names[ShaderGraph::NODE_TYPE_MAX]={
}; };
ShaderGraphEditor::ShaderGraphEditor() { ShaderGraphEditor::ShaderGraphEditor(bool p_2d) {
_2d=p_2d;
HBoxContainer *hbc = memnew( HBoxContainer ); HBoxContainer *hbc = memnew( HBoxContainer );
menu = memnew( MenuButton ); menu = memnew( MenuButton );
@ -2339,7 +2343,13 @@ void ShaderGraphEditorPlugin::edit(Object *p_object) {
bool ShaderGraphEditorPlugin::handles(Object *p_object) const { bool ShaderGraphEditorPlugin::handles(Object *p_object) const {
return p_object->is_type("ShaderGraph"); 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) { void ShaderGraphEditorPlugin::make_visible(bool p_visible) {
@ -2353,11 +2363,15 @@ void ShaderGraphEditorPlugin::make_visible(bool p_visible) {
} }
ShaderGraphEditorPlugin::ShaderGraphEditorPlugin(EditorNode *p_node) { ShaderGraphEditorPlugin::ShaderGraphEditorPlugin(EditorNode *p_node, bool p_2d) {
_2d=p_2d;
editor=p_node; editor=p_node;
shader_editor = memnew( ShaderGraphEditor ); shader_editor = memnew( ShaderGraphEditor(p_2d) );
shader_editor->hide(); 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); SpatialEditor::get_singleton()->get_shader_split()->add_child(shader_editor);

6
tools/editor/plugins/shader_graph_editor_plugin.h
View file

@ -191,6 +191,7 @@ class ShaderGraphEditor : public VBoxContainer {
ShaderGraphView *graph_edits[ShaderGraph::SHADER_TYPE_MAX]; ShaderGraphView *graph_edits[ShaderGraph::SHADER_TYPE_MAX];
static const char* node_names[ShaderGraph::NODE_TYPE_MAX]; static const char* node_names[ShaderGraph::NODE_TYPE_MAX];
bool _2d;
void _add_node(int p_type); void _add_node(int p_type);
protected: protected:
void _notification(int p_what); void _notification(int p_what);
@ -198,13 +199,14 @@ protected:
public: public:
void edit(Ref<ShaderGraph> p_shader); void edit(Ref<ShaderGraph> p_shader);
ShaderGraphEditor(); ShaderGraphEditor(bool p_2d);
}; };
class ShaderGraphEditorPlugin : public EditorPlugin { class ShaderGraphEditorPlugin : public EditorPlugin {
OBJ_TYPE( ShaderGraphEditorPlugin, EditorPlugin ); OBJ_TYPE( ShaderGraphEditorPlugin, EditorPlugin );
bool _2d;
ShaderGraphEditor *shader_editor; ShaderGraphEditor *shader_editor;
EditorNode *editor; EditorNode *editor;
@ -216,7 +218,7 @@ public:
virtual bool handles(Object *p_node) const; virtual bool handles(Object *p_node) const;
virtual void make_visible(bool p_visible); virtual void make_visible(bool p_visible);
ShaderGraphEditorPlugin(EditorNode *p_node); ShaderGraphEditorPlugin(EditorNode *p_node,bool p_2d);
~ShaderGraphEditorPlugin(); ~ShaderGraphEditorPlugin();
}; };