1 files changed, 303 insertions, 24 deletions

diff --git a/scene/resources/visual_shader.cpp b/scene/resources/visual_shader.cpp
index 8236f9a9e3..e4851ad9f7 100644
--- a/scene/resources/visual_shader.cpp
+++ b/scene/resources/visual_shader.cpp
@@ -63,6 +63,44 @@ bool VisualShaderNode::is_port_separator(int p_index) const {
 	return false;
 }
 
+bool VisualShaderNode::is_output_port_connected(int p_port) const {
+	if (connected_output_ports.has(p_port)) {
+		return connected_output_ports[p_port];
+	}
+	return false;
+}
+
+void VisualShaderNode::set_output_port_connected(int p_port, bool p_connected) {
+	if (p_connected) {
+		connected_output_ports[p_port] = true;
+		++connected_output_count;
+	} else {
+		--connected_output_count;
+		if (connected_output_count == 0) {
+			connected_output_ports[p_port] = false;
+		}
+	}
+}
+
+bool VisualShaderNode::is_input_port_connected(int p_port) const {
+	if (connected_input_ports.has(p_port)) {
+		return connected_input_ports[p_port];
+	}
+	return false;
+}
+
+void VisualShaderNode::set_input_port_connected(int p_port, bool p_connected) {
+	connected_input_ports[p_port] = p_connected;
+}
+
+bool VisualShaderNode::is_generate_input_var(int p_port) const {
+	return true;
+}
+
+bool VisualShaderNode::is_code_generated() const {
+	return true;
+}
+
 Vector<VisualShader::DefaultTextureParam> VisualShaderNode::get_default_texture_parameters(VisualShader::Type p_type, int p_id) const {
 	return Vector<VisualShader::DefaultTextureParam>();
 }
@@ -429,6 +467,7 @@ void VisualShader::remove_node(Type p_type, int p_id) {
 			g->connections.erase(E);
 			if (E->get().from_node == p_id) {
 				g->nodes[E->get().to_node].prev_connected_nodes.erase(p_id);
+				g->nodes[E->get().to_node].node->set_input_port_connected(E->get().to_port, false);
 			}
 		}
 		E = N;
@@ -526,6 +565,8 @@ void VisualShader::connect_nodes_forced(Type p_type, int p_from_node, int p_from
 	c.to_port = p_to_port;
 	g->connections.push_back(c);
 	g->nodes[p_to_node].prev_connected_nodes.push_back(p_from_node);
+	g->nodes[p_from_node].node->set_output_port_connected(p_from_port, true);
+	g->nodes[p_to_node].node->set_input_port_connected(p_to_port, true);
 
 	_queue_update();
 }
@@ -557,6 +598,8 @@ Error VisualShader::connect_nodes(Type p_type, int p_from_node, int p_from_port,
 	c.to_port = p_to_port;
 	g->connections.push_back(c);
 	g->nodes[p_to_node].prev_connected_nodes.push_back(p_from_node);
+	g->nodes[p_from_node].node->set_output_port_connected(p_from_port, true);
+	g->nodes[p_to_node].node->set_input_port_connected(p_to_port, true);
 
 	_queue_update();
 	return OK;
@@ -570,6 +613,8 @@ void VisualShader::disconnect_nodes(Type p_type, int p_from_node, int p_from_por
 		if (E->get().from_node == p_from_node && E->get().from_port == p_from_port && E->get().to_node == p_to_node && E->get().to_port == p_to_port) {
 			g->connections.erase(E);
 			g->nodes[p_to_node].prev_connected_nodes.erase(p_from_node);
+			g->nodes[p_from_node].node->set_output_port_connected(p_from_port, false);
+			g->nodes[p_to_node].node->set_input_port_connected(p_to_port, false);
 			_queue_update();
 			return;
 		}
@@ -1105,6 +1150,38 @@ Error VisualShader::_write_node(Type type, StringBuilder &global_code, StringBui
 
 	// then this node
 
+	Vector<VisualShader::DefaultTextureParam> params = vsnode->get_default_texture_parameters(type, node);
+	for (int i = 0; i < params.size(); i++) {
+		def_tex_params.push_back(params[i]);
+	}
+
+	Ref<VisualShaderNodeInput> input = vsnode;
+	bool skip_global = input.is_valid() && for_preview;
+
+	if (!skip_global) {
+		Ref<VisualShaderNodeUniform> uniform = vsnode;
+		if (!uniform.is_valid() || !uniform->is_global_code_generated()) {
+			global_code += vsnode->generate_global(get_mode(), type, node);
+		}
+
+		String class_name = vsnode->get_class_name();
+		if (class_name == "VisualShaderNodeCustom") {
+			class_name = vsnode->get_script_instance()->get_script()->get_path();
+		}
+		if (!r_classes.has(class_name)) {
+			global_code_per_node += vsnode->generate_global_per_node(get_mode(), type, node);
+			for (int i = 0; i < TYPE_MAX; i++) {
+				global_code_per_func[Type(i)] += vsnode->generate_global_per_func(get_mode(), Type(i), node);
+			}
+			r_classes.insert(class_name);
+		}
+	}
+
+	if (!vsnode->is_code_generated()) { // just generate globals and ignore locals
+		processed.insert(node);
+		return OK;
+	}
+
 	code += "// " + vsnode->get_caption() + ":" + itos(node) + "\n";
 	Vector<String> input_vars;
 
@@ -1163,6 +1240,10 @@ Error VisualShader::_write_node(Type type, StringBuilder &global_code, StringBui
 				inputs[i] = "int(" + src_var + ")";
 			}
 		} else {
+			if (!vsnode->is_generate_input_var(i)) {
+				continue;
+			}
+
 			Variant defval = vsnode->get_input_port_default_value(i);
 			if (defval.get_type() == Variant::FLOAT) {
 				float val = defval;
@@ -1255,30 +1336,6 @@ Error VisualShader::_write_node(Type type, StringBuilder &global_code, StringBui
 		}
 	}
 
-	Vector<VisualShader::DefaultTextureParam> params = vsnode->get_default_texture_parameters(type, node);
-	for (int i = 0; i < params.size(); i++) {
-		def_tex_params.push_back(params[i]);
-	}
-
-	Ref<VisualShaderNodeInput> input = vsnode;
-	bool skip_global = input.is_valid() && for_preview;
-
-	if (!skip_global) {
-		global_code += vsnode->generate_global(get_mode(), type, node);
-
-		String class_name = vsnode->get_class_name();
-		if (class_name == "VisualShaderNodeCustom") {
-			class_name = vsnode->get_script_instance()->get_script()->get_path();
-		}
-		if (!r_classes.has(class_name)) {
-			global_code_per_node += vsnode->generate_global_per_node(get_mode(), type, node);
-			for (int i = 0; i < TYPE_MAX; i++) {
-				global_code_per_func[Type(i)] += vsnode->generate_global_per_func(get_mode(), Type(i), node);
-			}
-			r_classes.insert(class_name);
-		}
-	}
-
 	code += vsnode->generate_code(get_mode(), type, node, inputs, outputs, for_preview);
 
 	code += "\n"; //
@@ -1352,6 +1409,9 @@ void VisualShader::_update_shader() const {
 	static const char *func_name[TYPE_MAX] = { "vertex", "fragment", "light" };
 
 	String global_expressions;
+	Set<String> used_uniform_names;
+	List<VisualShaderNodeUniform *> uniforms;
+
 	for (int i = 0, index = 0; i < TYPE_MAX; i++) {
 		if (!ShaderTypes::get_singleton()->get_functions(RenderingServer::ShaderMode(shader_mode)).has(func_name[i])) {
 			continue;
@@ -1367,6 +1427,24 @@ void VisualShader::_update_shader() const {
 				expr += "\n";
 				global_expressions += expr;
 			}
+			Ref<VisualShaderNodeUniformRef> uniform_ref = Object::cast_to<VisualShaderNodeUniformRef>(E->get().node.ptr());
+			if (uniform_ref.is_valid()) {
+				used_uniform_names.insert(uniform_ref->get_uniform_name());
+			}
+			Ref<VisualShaderNodeUniform> uniform = Object::cast_to<VisualShaderNodeUniform>(E->get().node.ptr());
+			if (uniform.is_valid()) {
+				uniforms.push_back(uniform.ptr());
+			}
+		}
+	}
+
+	for (int i = 0; i < uniforms.size(); i++) {
+		VisualShaderNodeUniform *uniform = uniforms[i];
+		if (used_uniform_names.has(uniform->get_uniform_name())) {
+			global_code += uniform->generate_global(get_mode(), Type(i), -1);
+			const_cast<VisualShaderNodeUniform *>(uniform)->set_global_code_generated(true);
+		} else {
+			const_cast<VisualShaderNodeUniform *>(uniform)->set_global_code_generated(false);
 		}
 	}
 
@@ -1956,6 +2034,199 @@ VisualShaderNodeInput::VisualShaderNodeInput() {
 	shader_mode = Shader::MODE_MAX;
 }
 
+////////////// UniformRef
+
+List<VisualShaderNodeUniformRef::Uniform> uniforms;
+
+void VisualShaderNodeUniformRef::add_uniform(const String &p_name, UniformType p_type) {
+	uniforms.push_back({ p_name, p_type });
+}
+
+void VisualShaderNodeUniformRef::clear_uniforms() {
+	uniforms.clear();
+}
+
+String VisualShaderNodeUniformRef::get_caption() const {
+	return "UniformRef";
+}
+
+int VisualShaderNodeUniformRef::get_input_port_count() const {
+	return 0;
+}
+
+VisualShaderNodeUniformRef::PortType VisualShaderNodeUniformRef::get_input_port_type(int p_port) const {
+	return PortType::PORT_TYPE_SCALAR;
+}
+
+String VisualShaderNodeUniformRef::get_input_port_name(int p_port) const {
+	return "";
+}
+
+int VisualShaderNodeUniformRef::get_output_port_count() const {
+	if (uniform_name == "[None]") {
+		return 0;
+	}
+
+	switch (uniform_type) {
+		case UniformType::UNIFORM_TYPE_FLOAT:
+			return 1;
+		case UniformType::UNIFORM_TYPE_INT:
+			return 1;
+		case UniformType::UNIFORM_TYPE_BOOLEAN:
+			return 1;
+		case UniformType::UNIFORM_TYPE_VECTOR:
+			return 1;
+		case UniformType::UNIFORM_TYPE_TRANSFORM:
+			return 1;
+		case UniformType::UNIFORM_TYPE_COLOR:
+			return 2;
+		case UniformType::UNIFORM_TYPE_SAMPLER:
+			return 1;
+		default:
+			break;
+	}
+	return 0;
+}
+
+VisualShaderNodeUniformRef::PortType VisualShaderNodeUniformRef::get_output_port_type(int p_port) const {
+	switch (uniform_type) {
+		case UniformType::UNIFORM_TYPE_FLOAT:
+			return PortType::PORT_TYPE_SCALAR;
+		case UniformType::UNIFORM_TYPE_INT:
+			return PortType::PORT_TYPE_SCALAR_INT;
+		case UniformType::UNIFORM_TYPE_BOOLEAN:
+			return PortType::PORT_TYPE_BOOLEAN;
+		case UniformType::UNIFORM_TYPE_VECTOR:
+			return PortType::PORT_TYPE_VECTOR;
+		case UniformType::UNIFORM_TYPE_TRANSFORM:
+			return PortType::PORT_TYPE_TRANSFORM;
+		case UniformType::UNIFORM_TYPE_COLOR:
+			if (p_port == 0) {
+				return PortType::PORT_TYPE_VECTOR;
+			} else if (p_port == 1) {
+				return PORT_TYPE_SCALAR;
+			}
+			break;
+		case UniformType::UNIFORM_TYPE_SAMPLER:
+			return PortType::PORT_TYPE_SAMPLER;
+		default:
+			break;
+	}
+	return PORT_TYPE_SCALAR;
+}
+
+String VisualShaderNodeUniformRef::get_output_port_name(int p_port) const {
+	switch (uniform_type) {
+		case UniformType::UNIFORM_TYPE_FLOAT:
+			return "";
+		case UniformType::UNIFORM_TYPE_INT:
+			return "";
+		case UniformType::UNIFORM_TYPE_BOOLEAN:
+			return "";
+		case UniformType::UNIFORM_TYPE_VECTOR:
+			return "";
+		case UniformType::UNIFORM_TYPE_TRANSFORM:
+			return "";
+		case UniformType::UNIFORM_TYPE_COLOR:
+			if (p_port == 0) {
+				return "rgb";
+			} else if (p_port == 1) {
+				return "alpha";
+			}
+			break;
+		case UniformType::UNIFORM_TYPE_SAMPLER:
+			return "";
+			break;
+		default:
+			break;
+	}
+	return "";
+}
+
+void VisualShaderNodeUniformRef::set_uniform_name(const String &p_name) {
+	uniform_name = p_name;
+	if (p_name != "[None]") {
+		uniform_type = get_uniform_type_by_name(p_name);
+	} else {
+		uniform_type = UniformType::UNIFORM_TYPE_FLOAT;
+	}
+	emit_changed();
+}
+
+String VisualShaderNodeUniformRef::get_uniform_name() const {
+	return uniform_name;
+}
+
+int VisualShaderNodeUniformRef::get_uniforms_count() const {
+	return uniforms.size();
+}
+
+String VisualShaderNodeUniformRef::get_uniform_name_by_index(int p_idx) const {
+	if (p_idx >= 0 && p_idx < uniforms.size()) {
+		return uniforms[p_idx].name;
+	}
+	return "";
+}
+
+VisualShaderNodeUniformRef::UniformType VisualShaderNodeUniformRef::get_uniform_type_by_name(const String &p_name) const {
+	for (int i = 0; i < uniforms.size(); i++) {
+		if (uniforms[i].name == p_name) {
+			return uniforms[i].type;
+		}
+	}
+	return UniformType::UNIFORM_TYPE_FLOAT;
+}
+
+VisualShaderNodeUniformRef::UniformType VisualShaderNodeUniformRef::get_uniform_type_by_index(int p_idx) const {
+	if (p_idx >= 0 && p_idx < uniforms.size()) {
+		return uniforms[p_idx].type;
+	}
+	return UniformType::UNIFORM_TYPE_FLOAT;
+}
+
+String VisualShaderNodeUniformRef::generate_code(Shader::Mode p_mode, VisualShader::Type p_type, int p_id, const String *p_input_vars, const String *p_output_vars, bool p_for_preview) const {
+	switch (uniform_type) {
+		case UniformType::UNIFORM_TYPE_FLOAT:
+			return "\t" + p_output_vars[0] + " = " + get_uniform_name() + ";\n";
+		case UniformType::UNIFORM_TYPE_INT:
+			return "\t" + p_output_vars[0] + " = " + get_uniform_name() + ";\n";
+		case UniformType::UNIFORM_TYPE_BOOLEAN:
+			return "\t" + p_output_vars[0] + " = " + get_uniform_name() + ";\n";
+		case UniformType::UNIFORM_TYPE_VECTOR:
+			return "\t" + p_output_vars[0] + " = " + get_uniform_name() + ";\n";
+		case UniformType::UNIFORM_TYPE_TRANSFORM:
+			return "\t" + p_output_vars[0] + " = " + get_uniform_name() + ";\n";
+		case UniformType::UNIFORM_TYPE_COLOR: {
+			String code = "\t" + p_output_vars[0] + " = " + get_uniform_name() + ".rgb;\n";
+			code += "\t" + p_output_vars[1] + " = " + get_uniform_name() + ".a;\n";
+			return code;
+		} break;
+		case UniformType::UNIFORM_TYPE_SAMPLER:
+			break;
+		default:
+			break;
+	}
+	return "";
+}
+
+void VisualShaderNodeUniformRef::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("set_uniform_name", "name"), &VisualShaderNodeUniformRef::set_uniform_name);
+	ClassDB::bind_method(D_METHOD("get_uniform_name"), &VisualShaderNodeUniformRef::get_uniform_name);
+
+	ADD_PROPERTY(PropertyInfo(Variant::STRING_NAME, "uniform_name", PROPERTY_HINT_ENUM, ""), "set_uniform_name", "get_uniform_name");
+}
+
+Vector<StringName> VisualShaderNodeUniformRef::get_editable_properties() const {
+	Vector<StringName> props;
+	props.push_back("uniform_name");
+	return props;
+}
+
+VisualShaderNodeUniformRef::VisualShaderNodeUniformRef() {
+	uniform_name = "[None]";
+	uniform_type = UniformType::UNIFORM_TYPE_FLOAT;
+}
+
 ////////////////////////////////////////////
 
 const VisualShaderNodeOutput::Port VisualShaderNodeOutput::ports[] = {
@@ -2149,6 +2420,14 @@ VisualShaderNodeUniform::Qualifier VisualShaderNodeUniform::get_qualifier() cons
 	return qualifier;
 }
 
+void VisualShaderNodeUniform::set_global_code_generated(bool p_enabled) {
+	global_code_generated = p_enabled;
+}
+
+bool VisualShaderNodeUniform::is_global_code_generated() const {
+	return global_code_generated;
+}
+
 void VisualShaderNodeUniform::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("set_uniform_name", "name"), &VisualShaderNodeUniform::set_uniform_name);
 	ClassDB::bind_method(D_METHOD("get_uniform_name"), &VisualShaderNodeUniform::get_uniform_name);