1 files changed, 207 insertions, 102 deletions

diff --git a/scene/2d/canvas_item.cpp b/scene/2d/canvas_item.cpp
index 223adaf9bb..4a1842100a 100644
--- a/scene/2d/canvas_item.cpp
+++ b/scene/2d/canvas_item.cpp
@@ -36,6 +36,192 @@
 #include "scene/resources/texture.h"
 #include "scene/resources/style_box.h"
 
+
+bool CanvasItemMaterial::_set(const StringName& p_name, const Variant& p_value) {
+
+	if (p_name==SceneStringNames::get_singleton()->shader_shader) {
+		set_shader(p_value);
+		return true;
+	} else if (p_name==SceneStringNames::get_singleton()->shader_unshaded) {
+		set_unshaded(p_value);
+		print_line("set unshaded");
+		return true;
+	} else {
+
+		if (shader.is_valid()) {
+
+
+			StringName pr = shader->remap_param(p_name);
+			if (!pr) {
+				String n = p_name;
+				if (n.find("param/")==0) { //backwards compatibility
+					pr = n.substr(6,n.length());
+				}
+			}
+			if (pr) {
+				VisualServer::get_singleton()->canvas_item_material_set_shader_param(material,pr,p_value);
+				return true;
+			}
+		}
+	}
+
+	return false;
+}
+
+bool CanvasItemMaterial::_get(const StringName& p_name,Variant &r_ret) const {
+
+
+	if (p_name==SceneStringNames::get_singleton()->shader_shader) {
+
+		r_ret=get_shader();
+		return true;
+	} else if (p_name==SceneStringNames::get_singleton()->shader_unshaded) {
+
+
+		r_ret=unshaded;
+		return true;
+	} else {
+
+		if (shader.is_valid()) {
+
+			StringName pr = shader->remap_param(p_name);
+			if (pr) {
+				r_ret=VisualServer::get_singleton()->canvas_item_material_get_shader_param(material,pr);
+				return true;
+			}
+		}
+
+	}
+
+
+	return false;
+}
+
+
+void CanvasItemMaterial::_get_property_list( List<PropertyInfo> *p_list) const {
+
+	p_list->push_back( PropertyInfo( Variant::OBJECT, "shader/shader", PROPERTY_HINT_RESOURCE_TYPE,"CanvasItemShader,CanvasItemShaderGraph" ) );
+	p_list->push_back( PropertyInfo( Variant::BOOL, "shader/unshaded") );
+
+	if (!shader.is_null()) {
+
+		shader->get_param_list(p_list);
+	}
+
+}
+
+void CanvasItemMaterial::set_shader(const Ref<Shader>& p_shader) {
+
+	ERR_FAIL_COND(p_shader.is_valid() && p_shader->get_mode()!=Shader::MODE_CANVAS_ITEM);
+#ifdef TOOLS_ENABLED
+
+	if (shader.is_valid()) {
+		shader->disconnect("changed",this,"_shader_changed");
+	}
+#endif
+	shader=p_shader;
+
+#ifdef TOOLS_ENABLED
+
+	if (shader.is_valid()) {
+		shader->connect("changed",this,"_shader_changed");
+	}
+#endif
+
+	RID rid;
+	if (shader.is_valid())
+		rid=shader->get_rid();
+
+	VS::get_singleton()->canvas_item_material_set_shader(material,rid);
+	_change_notify(); //properties for shader exposed
+	emit_changed();
+}
+
+Ref<Shader> CanvasItemMaterial::get_shader() const{
+
+	return shader;
+}
+
+void CanvasItemMaterial::set_shader_param(const StringName& p_param,const Variant& p_value){
+
+	VS::get_singleton()->canvas_item_material_set_shader_param(material,p_param,p_value);
+}
+
+Variant CanvasItemMaterial::get_shader_param(const StringName& p_param) const{
+
+	return VS::get_singleton()->canvas_item_material_get_shader_param(material,p_param);
+}
+
+void CanvasItemMaterial::_shader_changed() {
+
+
+}
+
+RID CanvasItemMaterial::get_rid() const {
+
+	return material;
+}
+
+void CanvasItemMaterial::set_unshaded(bool p_unshaded) {
+
+	unshaded=p_unshaded;
+	VS::get_singleton()->canvas_item_material_set_unshaded(material,p_unshaded);
+}
+
+bool CanvasItemMaterial::is_unshaded() const{
+
+	return unshaded;
+}
+
+void CanvasItemMaterial::_bind_methods() {
+
+	ObjectTypeDB::bind_method(_MD("set_shader","shader:Shader"),&CanvasItemMaterial::set_shader);
+	ObjectTypeDB::bind_method(_MD("get_shader:Shader"),&CanvasItemMaterial::get_shader);
+	ObjectTypeDB::bind_method(_MD("set_shader_param","param","value"),&CanvasItemMaterial::set_shader_param);
+	ObjectTypeDB::bind_method(_MD("get_shader_param","param"),&CanvasItemMaterial::get_shader_param);
+	ObjectTypeDB::bind_method(_MD("set_unshaded","unshaded"),&CanvasItemMaterial::set_unshaded);
+	ObjectTypeDB::bind_method(_MD("is_unshaded"),&CanvasItemMaterial::is_unshaded);
+
+}
+
+void CanvasItemMaterial::get_argument_options(const StringName& p_function,int p_idx,List<String>*r_options) const {
+
+	String f = p_function.operator String();
+	if ((f=="get_shader_param" || f=="set_shader_param") && p_idx==0) {
+
+		if (shader.is_valid()) {
+			List<PropertyInfo> pl;
+			shader->get_param_list(&pl);
+			for (List<PropertyInfo>::Element *E=pl.front();E;E=E->next()) {
+				r_options->push_back("\""+E->get().name.replace_first("shader_param/","")+"\"");
+			}
+		}
+	}
+	Resource::get_argument_options(p_function,p_idx,r_options);
+}
+
+CanvasItemMaterial::CanvasItemMaterial() {
+
+	material=VS::get_singleton()->canvas_item_material_create();
+	unshaded=false;
+}
+
+CanvasItemMaterial::~CanvasItemMaterial(){
+
+	VS::get_singleton()->free(material);
+}
+
+
+
+
+
+
+
+
+///////////////////////////////////////////////////////////////////
+
+
+
 bool CanvasItem::is_visible() const {
 
 	if (!is_inside_tree())
@@ -730,111 +916,35 @@ bool CanvasItem::is_draw_behind_parent_enabled() const{
 	return behind;
 }
 
-void CanvasItem::set_shader(const Ref<Shader>& p_shader) {
-
-	ERR_FAIL_COND(p_shader.is_valid() && p_shader->get_mode()!=Shader::MODE_CANVAS_ITEM);
-
-#ifdef TOOLS_ENABLED
-
-	if (shader.is_valid()) {
-		shader->disconnect("changed",this,"_shader_changed");
-	}
-#endif
-	shader=p_shader;
-
-#ifdef TOOLS_ENABLED
+void CanvasItem::set_material(const Ref<CanvasItemMaterial>& p_material) {
 
-	if (shader.is_valid()) {
-		shader->connect("changed",this,"_shader_changed");
-	}
-#endif
 
+	material=p_material;
 	RID rid;
-	if (shader.is_valid())
-		rid=shader->get_rid();
-	VS::get_singleton()->canvas_item_set_shader(canvas_item,rid);
-	_change_notify(); //properties for shader exposed
-}
-
-void CanvasItem::set_use_parent_shader(bool p_use_parent_shader) {
-
-	use_parent_shader=p_use_parent_shader;
-	VS::get_singleton()->canvas_item_set_use_parent_shader(canvas_item,p_use_parent_shader);
+	if (material.is_valid())
+		rid=material->get_rid();
+	VS::get_singleton()->canvas_item_set_material(canvas_item,rid);
+	_change_notify(); //properties for material exposed
 }
 
-bool CanvasItem::get_use_parent_shader() const{
+void CanvasItem::set_use_parent_material(bool p_use_parent_material) {
 
-	return use_parent_shader;
+	use_parent_material=p_use_parent_material;
+	VS::get_singleton()->canvas_item_set_use_parent_material(canvas_item,p_use_parent_material);
 }
 
-Ref<Shader> CanvasItem::get_shader() const{
+bool CanvasItem::get_use_parent_material() const{
 
-	return shader;
+	return use_parent_material;
 }
 
-void CanvasItem::set_shader_param(const StringName& p_param,const Variant& p_value) {
+Ref<CanvasItemMaterial> CanvasItem::get_material() const{
 
-	VS::get_singleton()->canvas_item_set_shader_param(canvas_item,p_param,p_value);
+	return material;
 }
 
-Variant CanvasItem::get_shader_param(const StringName& p_param) const {
-
-	return VS::get_singleton()->canvas_item_get_shader_param(canvas_item,p_param);
-}
-
-bool CanvasItem::_set(const StringName& p_name, const Variant& p_value) {
-
-	if (shader.is_valid()) {
-		StringName pr = shader->remap_param(p_name);
-		if (pr) {
-			set_shader_param(pr,p_value);
-			return true;
-		}
-	}
-	return false;
-}
 
-bool CanvasItem::_get(const StringName& p_name,Variant &r_ret) const{
 
-	if (shader.is_valid()) {
-		StringName pr = shader->remap_param(p_name);
-		if (pr) {
-			r_ret=get_shader_param(pr);
-			return true;
-		}
-	}
-	return false;
-
-}
-void CanvasItem::_get_property_list( List<PropertyInfo> *p_list) const{
-
-	if (shader.is_valid()) {
-		shader->get_param_list(p_list);
-	}
-}
-
-#ifdef TOOLS_ENABLED
-void CanvasItem::_shader_changed() {
-
-	_change_notify();
-}
-#endif
-
-void CanvasItem::get_argument_options(const StringName& p_function,int p_idx,List<String>*r_options) const {
-
-	if (p_idx==0 && shader.is_valid() && (p_function.operator String()=="get_shader_param" || p_function.operator String()=="set_shader_param")) {
-
-		List<PropertyInfo> pl;
-		shader->get_param_list(&pl);
-		for(List<PropertyInfo>::Element *E=pl.front();E;E=E->next()) {
-			r_options->push_back("\""+E->get().name.replace_first("shader_param/","")+"\"");
-		}
-
-		return;
-	}
-
-	Node::get_argument_options(p_function,p_idx,r_options);
-}
 
 
 void CanvasItem::_bind_methods() {
@@ -880,9 +990,6 @@ void CanvasItem::_bind_methods() {
 
 	ObjectTypeDB::bind_method(_MD("_set_on_top","on_top"),&CanvasItem::_set_on_top);
 	ObjectTypeDB::bind_method(_MD("_is_on_top"),&CanvasItem::_is_on_top);
-#ifdef TOOLS_ENABLED
-	ObjectTypeDB::bind_method(_MD("_shader_changed"),&CanvasItem::_shader_changed);
-#endif
 	//ObjectTypeDB::bind_method(_MD("get_transform"),&CanvasItem::get_transform);
 
 	ObjectTypeDB::bind_method(_MD("draw_line","from","to","color","width"),&CanvasItem::draw_line,DEFVAL(1.0));
@@ -901,20 +1008,18 @@ void CanvasItem::_bind_methods() {
 	ObjectTypeDB::bind_method(_MD("draw_set_transform","pos","rot","scale"),&CanvasItem::draw_set_transform);
 	ObjectTypeDB::bind_method(_MD("get_transform"),&CanvasItem::get_transform);
 	ObjectTypeDB::bind_method(_MD("get_global_transform"),&CanvasItem::get_global_transform);
+	ObjectTypeDB::bind_method(_MD("get_global_transform_with_canvas"),&CanvasItem::get_global_transform_with_canvas);
 	ObjectTypeDB::bind_method(_MD("get_viewport_transform"),&CanvasItem::get_viewport_transform);
 	ObjectTypeDB::bind_method(_MD("get_viewport_rect"),&CanvasItem::get_viewport_rect);
 	ObjectTypeDB::bind_method(_MD("get_canvas"),&CanvasItem::get_canvas);
 	ObjectTypeDB::bind_method(_MD("get_world_2d"),&CanvasItem::get_world_2d);
 	//ObjectTypeDB::bind_method(_MD("get_viewport"),&CanvasItem::get_viewport);
 
-	ObjectTypeDB::bind_method(_MD("set_shader","shader"),&CanvasItem::set_shader);
-	ObjectTypeDB::bind_method(_MD("get_shader"),&CanvasItem::get_shader);
-	ObjectTypeDB::bind_method(_MD("set_use_parent_shader","enable"),&CanvasItem::set_use_parent_shader);
-	ObjectTypeDB::bind_method(_MD("get_use_parent_shader"),&CanvasItem::get_use_parent_shader);
-
-	ObjectTypeDB::bind_method(_MD("set_shader_param","param","value"),&CanvasItem::set_shader_param);
-	ObjectTypeDB::bind_method(_MD("get_shader_param","param"),&CanvasItem::get_shader_param);
+	ObjectTypeDB::bind_method(_MD("set_material","material:CanvasItemMaterial"),&CanvasItem::set_material);
+	ObjectTypeDB::bind_method(_MD("get_material:CanvasItemMaterial"),&CanvasItem::get_material);
 
+	ObjectTypeDB::bind_method(_MD("set_use_parent_material","enable"),&CanvasItem::set_use_parent_material);
+	ObjectTypeDB::bind_method(_MD("get_use_parent_material"),&CanvasItem::get_use_parent_material);
 
 	BIND_VMETHOD(MethodInfo("_draw"));
 
@@ -926,8 +1031,8 @@ void CanvasItem::_bind_methods() {
 
 	ADD_PROPERTYNZ( PropertyInfo(Variant::INT,"visibility/blend_mode",PROPERTY_HINT_ENUM, "Mix,Add,Sub,Mul,PMAlpha"), _SCS("set_blend_mode"),_SCS("get_blend_mode") );
 	ADD_PROPERTYNZ( PropertyInfo(Variant::INT,"visibility/light_mask",PROPERTY_HINT_ALL_FLAGS), _SCS("set_light_mask"),_SCS("get_light_mask") );
-	ADD_PROPERTYNZ( PropertyInfo(Variant::OBJECT,"shader/shader",PROPERTY_HINT_RESOURCE_TYPE, "CanvasItemShader,CanvasItemShaderGraph"), _SCS("set_shader"),_SCS("get_shader") );
-	ADD_PROPERTYNZ( PropertyInfo(Variant::BOOL,"shader/use_parent"), _SCS("set_use_parent_shader"),_SCS("get_use_parent_shader") );
+	ADD_PROPERTYNZ( PropertyInfo(Variant::OBJECT,"material/material",PROPERTY_HINT_RESOURCE_TYPE, "CanvasItemMaterial"), _SCS("set_material"),_SCS("get_material") );
+	ADD_PROPERTYNZ( PropertyInfo(Variant::BOOL,"material/use_parent"), _SCS("set_use_parent_material"),_SCS("get_use_parent_material") );
 	//exporting these two things doesn't really make much sense i think
 	//ADD_PROPERTY( PropertyInfo(Variant::BOOL,"transform/toplevel"), _SCS("set_as_toplevel"),_SCS("is_set_as_toplevel") );
 	//ADD_PROPERTY(PropertyInfo(Variant::BOOL,"transform/notify"),_SCS("set_transform_notify"),_SCS("is_transform_notify_enabled"));
@@ -1004,7 +1109,7 @@ CanvasItem::CanvasItem() : xform_change(this) {
 	block_transform_notify=false;
 //	viewport=NULL;
 	canvas_layer=NULL;
-	use_parent_shader=false;
+	use_parent_material=false;
 	global_invalid=true;
 	light_mask=1;