Merge pull request #60175 from Geometror/visual-shader-vector4

4 files changed, 661 insertions, 22 deletions

diff --git a/scene/resources/visual_shader.cpp b/scene/resources/visual_shader.cpp
index 129f76702e..8a7020add5 100644
--- a/scene/resources/visual_shader.cpp
+++ b/scene/resources/visual_shader.cpp
@@ -74,6 +74,10 @@ void VisualShaderNode::set_input_port_default_value(int p_port, const Variant &p
 						Vector3 pv = p_prev_value;
 						value = pv.x;
 					} break;
+					case Variant::QUATERNION: {
+						Quaternion pv = p_prev_value;
+						value = pv.x;
+					} break;
 					default:
 						break;
 				}
@@ -94,6 +98,10 @@ void VisualShaderNode::set_input_port_default_value(int p_port, const Variant &p
 						Vector3 pv = p_prev_value;
 						value = (int)pv.x;
 					} break;
+					case Variant::QUATERNION: {
+						Quaternion pv = p_prev_value;
+						value = (int)pv.x;
+					} break;
 					default:
 						break;
 				}
@@ -115,6 +123,10 @@ void VisualShaderNode::set_input_port_default_value(int p_port, const Variant &p
 						Vector3 pv = p_prev_value;
 						value = Vector2(pv.x, pv.y);
 					} break;
+					case Variant::QUATERNION: {
+						Quaternion pv = p_prev_value;
+						value = Vector2(pv.x, pv.y);
+					} break;
 					default:
 						break;
 				}
@@ -136,6 +148,35 @@ void VisualShaderNode::set_input_port_default_value(int p_port, const Variant &p
 					case Variant::VECTOR3: {
 						value = p_prev_value;
 					} break;
+					case Variant::QUATERNION: {
+						Quaternion pv = p_prev_value;
+						value = Vector3(pv.x, pv.y, pv.z);
+					} break;
+					default:
+						break;
+				}
+			} break;
+			case Variant::QUATERNION: {
+				switch (p_prev_value.get_type()) {
+					case Variant::INT: {
+						float pv = (float)(int)p_prev_value;
+						value = Quaternion(pv, pv, pv, pv);
+					} break;
+					case Variant::FLOAT: {
+						float pv = p_prev_value;
+						value = Quaternion(pv, pv, pv, pv);
+					} break;
+					case Variant::VECTOR2: {
+						Vector2 pv = p_prev_value;
+						value = Quaternion(pv.x, pv.y, pv.y, pv.y);
+					} break;
+					case Variant::VECTOR3: {
+						Vector3 pv = p_prev_value;
+						value = Quaternion(pv.x, pv.y, pv.z, pv.z);
+					} break;
+					case Variant::QUATERNION: {
+						value = p_prev_value;
+					} break;
 					default:
 						break;
 				}
@@ -253,6 +294,9 @@ int VisualShaderNode::get_expanded_output_port_count() const {
 				case PORT_TYPE_VECTOR_3D: {
 					count2 += 3;
 				} break;
+				case PORT_TYPE_VECTOR_4D: {
+					count2 += 4;
+				} break;
 				default:
 					break;
 			}
@@ -360,6 +404,7 @@ void VisualShaderNode::_bind_methods() {
 	BIND_ENUM_CONSTANT(PORT_TYPE_SCALAR_INT);
 	BIND_ENUM_CONSTANT(PORT_TYPE_VECTOR_2D);
 	BIND_ENUM_CONSTANT(PORT_TYPE_VECTOR_3D);
+	BIND_ENUM_CONSTANT(PORT_TYPE_VECTOR_4D);
 	BIND_ENUM_CONSTANT(PORT_TYPE_BOOLEAN);
 	BIND_ENUM_CONSTANT(PORT_TYPE_TRANSFORM);
 	BIND_ENUM_CONSTANT(PORT_TYPE_SAMPLER);
@@ -1203,6 +1248,9 @@ String VisualShader::generate_preview_shader(Type p_type, int p_node, int p_port
 		case VisualShaderNode::PORT_TYPE_VECTOR_3D: {
 			code += "	COLOR.rgb = n_out" + itos(p_node) + "p" + itos(p_port) + ";\n";
 		} break;
+		case VisualShaderNode::PORT_TYPE_VECTOR_4D: {
+			code += "	COLOR.rgb = n_out" + itos(p_node) + "p" + itos(p_port) + ".xyz;\n";
+		} break;
 		default: {
 			code += "	COLOR.rgb = vec3(0.0);\n";
 		} break;
@@ -1687,11 +1735,14 @@ Error VisualShader::_write_node(Type type, StringBuilder *global_code, StringBui
 								inputs[i] = "(" + src_var + " ? 1.0 : 0.0)";
 							} break;
 							case VisualShaderNode::PORT_TYPE_VECTOR_2D: {
-								inputs[i] = "dot(" + src_var + ", vec2(0.333333, 0.333333))";
+								inputs[i] = "dot(" + src_var + ", vec2(0.5, 0.5))";
 							} break;
 							case VisualShaderNode::PORT_TYPE_VECTOR_3D: {
 								inputs[i] = "dot(" + src_var + ", vec3(0.333333, 0.333333, 0.333333))";
 							} break;
+							case VisualShaderNode::PORT_TYPE_VECTOR_4D: {
+								inputs[i] = "dot(" + src_var + ", vec4(0.25, 0.25, 0.25, 0.25))";
+							} break;
 							default:
 								break;
 						}
@@ -1705,11 +1756,14 @@ Error VisualShader::_write_node(Type type, StringBuilder *global_code, StringBui
 								inputs[i] = "(" + src_var + " ? 1 : 0)";
 							} break;
 							case VisualShaderNode::PORT_TYPE_VECTOR_2D: {
-								inputs[i] = "dot(float(" + src_var + "), vec2(0.333333, 0.333333))";
+								inputs[i] = "dot(float(" + src_var + "), vec2(0.5, 0.5))";
 							} break;
 							case VisualShaderNode::PORT_TYPE_VECTOR_3D: {
 								inputs[i] = "dot(float(" + src_var + "), vec3(0.333333, 0.333333, 0.333333))";
 							} break;
+							case VisualShaderNode::PORT_TYPE_VECTOR_4D: {
+								inputs[i] = "dot(float(" + src_var + "), vec4(0.25, 0.25, 0.25, 0.25))";
+							} break;
 							default:
 								break;
 						}
@@ -1728,6 +1782,9 @@ Error VisualShader::_write_node(Type type, StringBuilder *global_code, StringBui
 							case VisualShaderNode::PORT_TYPE_VECTOR_3D: {
 								inputs[i] = "all(bvec3(" + src_var + "))";
 							} break;
+							case VisualShaderNode::PORT_TYPE_VECTOR_4D: {
+								inputs[i] = "all(bvec4(" + src_var + "))";
+							} break;
 							default:
 								break;
 						}
@@ -1743,7 +1800,8 @@ Error VisualShader::_write_node(Type type, StringBuilder *global_code, StringBui
 							case VisualShaderNode::PORT_TYPE_BOOLEAN: {
 								inputs[i] = "vec2(" + src_var + " ? 1.0 : 0.0)";
 							} break;
-							case VisualShaderNode::PORT_TYPE_VECTOR_3D: {
+							case VisualShaderNode::PORT_TYPE_VECTOR_3D:
+							case VisualShaderNode::PORT_TYPE_VECTOR_4D: {
 								inputs[i] = "vec2(" + src_var + ".xy)";
 							} break;
 							default:
@@ -1765,6 +1823,30 @@ Error VisualShader::_write_node(Type type, StringBuilder *global_code, StringBui
 							case VisualShaderNode::PORT_TYPE_VECTOR_2D: {
 								inputs[i] = "vec3(" + src_var + ", 0.0)";
 							} break;
+							case VisualShaderNode::PORT_TYPE_VECTOR_4D: {
+								inputs[i] = "vec3(" + src_var + ".xyz)";
+							} break;
+							default:
+								break;
+						}
+					} break;
+					case VisualShaderNode::PORT_TYPE_VECTOR_4D: {
+						switch (out_type) {
+							case VisualShaderNode::PORT_TYPE_SCALAR: {
+								inputs[i] = "vec4(" + src_var + ")";
+							} break;
+							case VisualShaderNode::PORT_TYPE_SCALAR_INT: {
+								inputs[i] = "vec4(float(" + src_var + "))";
+							} break;
+							case VisualShaderNode::PORT_TYPE_BOOLEAN: {
+								inputs[i] = "vec4(" + src_var + " ? 1.0 : 0.0)";
+							} break;
+							case VisualShaderNode::PORT_TYPE_VECTOR_2D: {
+								inputs[i] = "vec4(" + src_var + ", 0.0, 0.0)";
+							} break;
+							case VisualShaderNode::PORT_TYPE_VECTOR_3D: {
+								inputs[i] = "vec4(" + src_var + ", 0.0)";
+							} break;
 							default:
 								break;
 						}
@@ -1799,6 +1881,10 @@ Error VisualShader::_write_node(Type type, StringBuilder *global_code, StringBui
 				Vector3 val = defval;
 				inputs[i] = "n_in" + itos(node) + "p" + itos(i);
 				node_code += "	vec3 " + inputs[i] + " = " + vformat("vec3(%.5f, %.5f, %.5f);\n", val.x, val.y, val.z);
+			} else if (defval.get_type() == Variant::QUATERNION) {
+				Quaternion val = defval;
+				inputs[i] = "n_in" + itos(node) + "p" + itos(i);
+				node_code += "	vec4 " + inputs[i] + " = " + vformat("vec4(%.5f, %.5f, %.5f, %.5f);\n", val.x, val.y, val.z, val.w);
 			} else if (defval.get_type() == Variant::TRANSFORM3D) {
 				Transform3D val = defval;
 				val.basis.transpose();
@@ -1838,6 +1924,9 @@ Error VisualShader::_write_node(Type type, StringBuilder *global_code, StringBui
 				case VisualShaderNode::PORT_TYPE_VECTOR_3D: {
 					output_count += 3;
 				} break;
+				case VisualShaderNode::PORT_TYPE_VECTOR_4D: {
+					output_count += 4;
+				} break;
 				default:
 					break;
 			}
@@ -1865,6 +1954,9 @@ Error VisualShader::_write_node(Type type, StringBuilder *global_code, StringBui
 				case VisualShaderNode::PORT_TYPE_VECTOR_3D:
 					outputs[i] = "vec3 " + var_name;
 					break;
+				case VisualShaderNode::PORT_TYPE_VECTOR_4D:
+					outputs[i] = "vec4 " + var_name;
+					break;
 				case VisualShaderNode::PORT_TYPE_BOOLEAN:
 					outputs[i] = "bool " + var_name;
 					break;
@@ -1882,6 +1974,9 @@ Error VisualShader::_write_node(Type type, StringBuilder *global_code, StringBui
 					case VisualShaderNode::PORT_TYPE_VECTOR_3D: {
 						j += 3;
 					} break;
+					case VisualShaderNode::PORT_TYPE_VECTOR_4D: {
+						j += 4;
+					} break;
 					default:
 						break;
 				}
@@ -1904,6 +1999,9 @@ Error VisualShader::_write_node(Type type, StringBuilder *global_code, StringBui
 				case VisualShaderNode::PORT_TYPE_VECTOR_3D:
 					code += "	vec3 " + outputs[i] + ";\n";
 					break;
+				case VisualShaderNode::PORT_TYPE_VECTOR_4D:
+					code += "	vec4 " + outputs[i] + ";\n";
+					break;
 				case VisualShaderNode::PORT_TYPE_BOOLEAN:
 					code += "	bool " + outputs[i] + ";\n";
 					break;
@@ -1921,6 +2019,9 @@ Error VisualShader::_write_node(Type type, StringBuilder *global_code, StringBui
 					case VisualShaderNode::PORT_TYPE_VECTOR_3D: {
 						j += 3;
 					} break;
+					case VisualShaderNode::PORT_TYPE_VECTOR_4D: {
+						j += 4;
+					} break;
 					default:
 						break;
 				}
@@ -1995,6 +2096,49 @@ Error VisualShader::_write_node(Type type, StringBuilder *global_code, StringBui
 
 					i += 3;
 				} break;
+				case VisualShaderNode::PORT_TYPE_VECTOR_4D: {
+					if (vsnode->is_output_port_connected(i + 1) || (for_preview && vsnode->get_output_port_for_preview() == (i + 1))) { // red-component
+						if (!new_line_inserted) {
+							code += "\n";
+							new_line_inserted = true;
+						}
+						String r = "n_out" + itos(node) + "p" + itos(i + 1);
+						code += "	float " + r + " = n_out" + itos(node) + "p" + itos(i) + ".r;\n";
+						outputs[i + 1] = r;
+					}
+
+					if (vsnode->is_output_port_connected(i + 2) || (for_preview && vsnode->get_output_port_for_preview() == (i + 2))) { // green-component
+						if (!new_line_inserted) {
+							code += "\n";
+							new_line_inserted = true;
+						}
+						String g = "n_out" + itos(node) + "p" + itos(i + 2);
+						code += "	float " + g + " = n_out" + itos(node) + "p" + itos(i) + ".g;\n";
+						outputs[i + 2] = g;
+					}
+
+					if (vsnode->is_output_port_connected(i + 3) || (for_preview && vsnode->get_output_port_for_preview() == (i + 3))) { // blue-component
+						if (!new_line_inserted) {
+							code += "\n";
+							new_line_inserted = true;
+						}
+						String b = "n_out" + itos(node) + "p" + itos(i + 3);
+						code += "	float " + b + " = n_out" + itos(node) + "p" + itos(i) + ".b;\n";
+						outputs[i + 3] = b;
+					}
+
+					if (vsnode->is_output_port_connected(i + 4) || (for_preview && vsnode->get_output_port_for_preview() == (i + 4))) { // alpha-component
+						if (!new_line_inserted) {
+							code += "\n";
+							new_line_inserted = true;
+						}
+						String b = "n_out" + itos(node) + "p" + itos(i + 3);
+						code += "	float " + b + " = n_out" + itos(node) + "p" + itos(i) + ".a;\n";
+						outputs[i + 4] = b;
+					}
+
+					i += 4;
+				} break;
 				default:
 					break;
 			}
@@ -2147,6 +2291,9 @@ void VisualShader::_update_shader() const {
 				case VaryingType::VARYING_TYPE_VECTOR_3D:
 					global_code += "vec3 ";
 					break;
+				case VaryingType::VARYING_TYPE_VECTOR_4D:
+					global_code += "vec4 ";
+					break;
 				case VaryingType::VARYING_TYPE_COLOR:
 					global_code += "vec4 ";
 					break;
@@ -2207,6 +2354,9 @@ void VisualShader::_update_shader() const {
 							case VaryingType::VARYING_TYPE_VECTOR_3D:
 								code2 += "vec3(0.0)";
 								break;
+							case VaryingType::VARYING_TYPE_VECTOR_4D:
+								code2 += "vec4(0.0)";
+								break;
 							case VaryingType::VARYING_TYPE_COLOR:
 								code2 += "vec4(0.0)";
 								break;
@@ -2527,6 +2677,7 @@ void VisualShader::_bind_methods() {
 	BIND_ENUM_CONSTANT(VARYING_TYPE_FLOAT);
 	BIND_ENUM_CONSTANT(VARYING_TYPE_VECTOR_2D);
 	BIND_ENUM_CONSTANT(VARYING_TYPE_VECTOR_3D);
+	BIND_ENUM_CONSTANT(VARYING_TYPE_VECTOR_4D);
 	BIND_ENUM_CONSTANT(VARYING_TYPE_COLOR);
 	BIND_ENUM_CONSTANT(VARYING_TYPE_TRANSFORM);
 	BIND_ENUM_CONSTANT(VARYING_TYPE_MAX);
@@ -2970,6 +3121,9 @@ String VisualShaderNodeInput::generate_code(Shader::Mode p_mode, VisualShader::T
 				case PORT_TYPE_VECTOR_3D: {
 					code = "	" + p_output_vars[0] + " = vec3(0.0);\n";
 				} break;
+				case PORT_TYPE_VECTOR_4D: {
+					code = "	" + p_output_vars[0] + " = vec4(0.0);\n";
+				} break;
 				case PORT_TYPE_BOOLEAN: {
 					code = "	" + p_output_vars[0] + " = false;\n";
 				} break;
@@ -3186,6 +3340,8 @@ int VisualShaderNodeUniformRef::get_output_port_count() const {
 			return 1;
 		case UniformType::UNIFORM_TYPE_VECTOR3:
 			return 1;
+		case UniformType::UNIFORM_TYPE_VECTOR4:
+			return 1;
 		case UniformType::UNIFORM_TYPE_TRANSFORM:
 			return 1;
 		case UniformType::UNIFORM_TYPE_COLOR:
@@ -3210,6 +3366,8 @@ VisualShaderNodeUniformRef::PortType VisualShaderNodeUniformRef::get_output_port
 			return PortType::PORT_TYPE_VECTOR_2D;
 		case UniformType::UNIFORM_TYPE_VECTOR3:
 			return PortType::PORT_TYPE_VECTOR_3D;
+		case UniformType::UNIFORM_TYPE_VECTOR4:
+			return PortType::PORT_TYPE_VECTOR_4D;
 		case UniformType::UNIFORM_TYPE_TRANSFORM:
 			return PortType::PORT_TYPE_TRANSFORM;
 		case UniformType::UNIFORM_TYPE_COLOR:
@@ -3239,6 +3397,8 @@ String VisualShaderNodeUniformRef::get_output_port_name(int p_port) const {
 			return "";
 		case UniformType::UNIFORM_TYPE_VECTOR3:
 			return "";
+		case UniformType::UNIFORM_TYPE_VECTOR4:
+			return "";
 		case UniformType::UNIFORM_TYPE_TRANSFORM:
 			return "";
 		case UniformType::UNIFORM_TYPE_COLOR:
@@ -3311,6 +3471,8 @@ VisualShaderNodeUniformRef::PortType VisualShaderNodeUniformRef::get_port_type_b
 				return PORT_TYPE_VECTOR_2D;
 			case UniformType::UNIFORM_TYPE_VECTOR3:
 				return PORT_TYPE_VECTOR_3D;
+			case UniformType::UNIFORM_TYPE_VECTOR4:
+				return PORT_TYPE_VECTOR_4D;
 			case UniformType::UNIFORM_TYPE_TRANSFORM:
 				return PORT_TYPE_TRANSFORM;
 			case UniformType::UNIFORM_TYPE_COLOR:
@@ -3697,6 +3859,11 @@ String VisualShaderNodeUniform::get_warning(Shader::Mode p_mode, VisualShader::T
 					incompatible_type = true;
 				}
 			} break;
+			case RS::GLOBAL_VAR_TYPE_VEC4: {
+				if (!Object::cast_to<VisualShaderNodeVec4Uniform>(this)) {
+					incompatible_type = true;
+				}
+			} break;
 			case RS::GLOBAL_VAR_TYPE_TRANSFORM: {
 				if (!Object::cast_to<VisualShaderNodeTransformUniform>(this)) {
 					incompatible_type = true;
@@ -4404,6 +4571,9 @@ String VisualShaderNodeExpression::generate_code(Shader::Mode p_mode, VisualShad
 			case PORT_TYPE_VECTOR_3D:
 				tk = "vec3(0.0, 0.0, 0.0)";
 				break;
+			case PORT_TYPE_VECTOR_4D:
+				tk = "vec4(0.0, 0.0, 0.0, 0.0)";
+				break;
 			case PORT_TYPE_BOOLEAN:
 				tk = "false";
 				break;
@@ -4542,6 +4712,8 @@ String VisualShaderNodeVarying::get_type_str() const {
 			return "vec2";
 		case VisualShader::VARYING_TYPE_VECTOR_3D:
 			return "vec3";
+		case VisualShader::VARYING_TYPE_VECTOR_4D:
+			return "vec4";
 		case VisualShader::VARYING_TYPE_COLOR:
 			return "vec4";
 		case VisualShader::VARYING_TYPE_TRANSFORM:
@@ -4558,6 +4730,8 @@ VisualShaderNodeVarying::PortType VisualShaderNodeVarying::get_port_type(VisualS
 			return PORT_TYPE_VECTOR_2D;
 		case VisualShader::VARYING_TYPE_VECTOR_3D:
 			return PORT_TYPE_VECTOR_3D;
+		case VisualShader::VARYING_TYPE_VECTOR_4D:
+			return PORT_TYPE_VECTOR_4D;
 		case VisualShader::VARYING_TYPE_COLOR:
 			if (p_port == 1) {
 				break; // scalar
@@ -4718,6 +4892,9 @@ String VisualShaderNodeVaryingGetter::generate_code(Shader::Mode p_mode, VisualS
 			case VisualShader::VARYING_TYPE_VECTOR_3D:
 				from = "vec3(0.0)";
 				break;
+			case VisualShader::VARYING_TYPE_VECTOR_4D:
+				from = "vec4(0.0)";
+				break;
 			case VisualShader::VARYING_TYPE_COLOR:
 				from = "vec3(0.0)";
 				from2 = "0.0";
diff --git a/scene/resources/visual_shader.h b/scene/resources/visual_shader.h
index 2d4b2852e9..56371c9bba 100644
--- a/scene/resources/visual_shader.h
+++ b/scene/resources/visual_shader.h
@@ -83,6 +83,7 @@ public:
 		VARYING_TYPE_FLOAT,
 		VARYING_TYPE_VECTOR_2D,
 		VARYING_TYPE_VECTOR_3D,
+		VARYING_TYPE_VECTOR_4D,
 		VARYING_TYPE_COLOR,
 		VARYING_TYPE_TRANSFORM,
 		VARYING_TYPE_MAX,
@@ -271,6 +272,7 @@ public:
 		PORT_TYPE_SCALAR_INT,
 		PORT_TYPE_VECTOR_2D,
 		PORT_TYPE_VECTOR_3D,
+		PORT_TYPE_VECTOR_4D,
 		PORT_TYPE_BOOLEAN,
 		PORT_TYPE_TRANSFORM,
 		PORT_TYPE_SAMPLER,
@@ -556,6 +558,7 @@ public:
 		UNIFORM_TYPE_BOOLEAN,
 		UNIFORM_TYPE_VECTOR2,
 		UNIFORM_TYPE_VECTOR3,
+		UNIFORM_TYPE_VECTOR4,
 		UNIFORM_TYPE_TRANSFORM,
 		UNIFORM_TYPE_COLOR,
 		UNIFORM_TYPE_SAMPLER,
diff --git a/scene/resources/visual_shader_nodes.cpp b/scene/resources/visual_shader_nodes.cpp
index 4e16353460..c302ea8afd 100644
--- a/scene/resources/visual_shader_nodes.cpp
+++ b/scene/resources/visual_shader_nodes.cpp
@@ -38,6 +38,8 @@ VisualShaderNodeVectorBase::PortType VisualShaderNodeVectorBase::get_input_port_
 			return PORT_TYPE_VECTOR_2D;
 		case OP_TYPE_VECTOR_3D:
 			return PORT_TYPE_VECTOR_3D;
+		case OP_TYPE_VECTOR_4D:
+			return PORT_TYPE_VECTOR_4D;
 		default:
 			break;
 	}
@@ -50,6 +52,8 @@ VisualShaderNodeVectorBase::PortType VisualShaderNodeVectorBase::get_output_port
 			return PORT_TYPE_VECTOR_2D;
 		case OP_TYPE_VECTOR_3D:
 			return PORT_TYPE_VECTOR_3D;
+		case OP_TYPE_VECTOR_4D:
+			return PORT_TYPE_VECTOR_4D;
 		default:
 			break;
 	}
@@ -73,10 +77,11 @@ void VisualShaderNodeVectorBase::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("set_op_type", "type"), &VisualShaderNodeVectorBase::set_op_type);
 	ClassDB::bind_method(D_METHOD("get_op_type"), &VisualShaderNodeVectorBase::get_op_type);
 
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "op_type", PROPERTY_HINT_ENUM, "Vector2,Vector3"), "set_op_type", "get_op_type");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "op_type", PROPERTY_HINT_ENUM, "Vector2,Vector3,Vector4"), "set_op_type", "get_op_type");
 
 	BIND_ENUM_CONSTANT(OP_TYPE_VECTOR_2D);
 	BIND_ENUM_CONSTANT(OP_TYPE_VECTOR_3D);
+	BIND_ENUM_CONSTANT(OP_TYPE_VECTOR_4D);
 	BIND_ENUM_CONSTANT(OP_TYPE_MAX);
 }
 
@@ -477,6 +482,68 @@ void VisualShaderNodeVec3Constant::_bind_methods() {
 VisualShaderNodeVec3Constant::VisualShaderNodeVec3Constant() {
 }
 
+////////////// Vector4
+
+String VisualShaderNodeVec4Constant::get_caption() const {
+	return "Vector4Constant";
+}
+
+int VisualShaderNodeVec4Constant::get_input_port_count() const {
+	return 0;
+}
+
+VisualShaderNodeVec4Constant::PortType VisualShaderNodeVec4Constant::get_input_port_type(int p_port) const {
+	return PORT_TYPE_VECTOR_4D;
+}
+
+String VisualShaderNodeVec4Constant::get_input_port_name(int p_port) const {
+	return String();
+}
+
+int VisualShaderNodeVec4Constant::get_output_port_count() const {
+	return 1;
+}
+
+VisualShaderNodeVec4Constant::PortType VisualShaderNodeVec4Constant::get_output_port_type(int p_port) const {
+	return PORT_TYPE_VECTOR_4D;
+}
+
+String VisualShaderNodeVec4Constant::get_output_port_name(int p_port) const {
+	return ""; // No output port means the editor will be used as port.
+}
+
+String VisualShaderNodeVec4Constant::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 {
+	return "	" + p_output_vars[0] + " = " + vformat("vec4(%.6f, %.6f, %.6f, %.6f)", constant.x, constant.y, constant.z, constant.w) + ";\n";
+}
+
+void VisualShaderNodeVec4Constant::set_constant(const Quaternion &p_constant) {
+	if (constant.is_equal_approx(p_constant)) {
+		return;
+	}
+	constant = p_constant;
+	emit_changed();
+}
+
+Quaternion VisualShaderNodeVec4Constant::get_constant() const {
+	return constant;
+}
+
+Vector<StringName> VisualShaderNodeVec4Constant::get_editable_properties() const {
+	Vector<StringName> props;
+	props.push_back("constant");
+	return props;
+}
+
+void VisualShaderNodeVec4Constant::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("set_constant", "constant"), &VisualShaderNodeVec4Constant::set_constant);
+	ClassDB::bind_method(D_METHOD("get_constant"), &VisualShaderNodeVec4Constant::get_constant);
+
+	ADD_PROPERTY(PropertyInfo(Variant::QUATERNION, "constant"), "set_constant", "get_constant");
+}
+
+VisualShaderNodeVec4Constant::VisualShaderNodeVec4Constant() {
+}
+
 ////////////// Transform3D
 
 String VisualShaderNodeTransformConstant::get_caption() const {
@@ -1891,8 +1958,10 @@ String VisualShaderNodeVectorOp::generate_code(Shader::Mode p_mode, VisualShader
 			code += "min(" + p_input_vars[0] + ", " + p_input_vars[1] + ");\n";
 			break;
 		case OP_CROSS:
-			if (op_type == OP_TYPE_VECTOR_2D) { // not supported
+			if (op_type == OP_TYPE_VECTOR_2D) { // Not supported.
 				code += "vec2(0.0);\n";
+			} else if (op_type == OP_TYPE_VECTOR_4D) { // Not supported.
+				code += "vec4(0.0);\n";
 			} else {
 				code += "cross(" + p_input_vars[0] + ", " + p_input_vars[1] + ");\n";
 			}
@@ -1901,8 +1970,10 @@ String VisualShaderNodeVectorOp::generate_code(Shader::Mode p_mode, VisualShader
 			code += "atan(" + p_input_vars[0] + ", " + p_input_vars[1] + ");\n";
 			break;
 		case OP_REFLECT:
-			if (op_type == OP_TYPE_VECTOR_2D) { // not supported
+			if (op_type == OP_TYPE_VECTOR_2D) { // Not supported.
 				code += "vec2(0.0);\n";
+			} else if (op_type == OP_TYPE_VECTOR_4D) { // Not supported.
+				code += "vec4(0.0);\n";
 			} else {
 				code += "reflect(" + p_input_vars[0] + ", " + p_input_vars[1] + ");\n";
 			}
@@ -1931,6 +2002,10 @@ void VisualShaderNodeVectorOp::set_op_type(OpType p_op_type) {
 			set_input_port_default_value(0, Vector3(), get_input_port_default_value(0));
 			set_input_port_default_value(1, Vector3(), get_input_port_default_value(1));
 		} break;
+		case OP_TYPE_VECTOR_4D: {
+			set_input_port_default_value(0, Quaternion(), get_input_port_default_value(0));
+			set_input_port_default_value(1, Quaternion(), get_input_port_default_value(1));
+		} break;
 		default:
 			break;
 	}
@@ -1960,7 +2035,7 @@ Vector<StringName> VisualShaderNodeVectorOp::get_editable_properties() const {
 String VisualShaderNodeVectorOp::get_warning(Shader::Mode p_mode, VisualShader::Type p_type) const {
 	bool invalid_type = false;
 
-	if (op_type == OP_TYPE_VECTOR_2D) {
+	if (op_type == OP_TYPE_VECTOR_2D || op_type == OP_TYPE_VECTOR_4D) {
 		if (op == OP_CROSS || op == OP_REFLECT) {
 			invalid_type = true;
 		}
@@ -2004,6 +2079,10 @@ VisualShaderNodeVectorOp::VisualShaderNodeVectorOp() {
 			set_input_port_default_value(0, Vector3());
 			set_input_port_default_value(1, Vector3());
 		} break;
+		case OP_TYPE_VECTOR_4D: {
+			set_input_port_default_value(0, Quaternion());
+			set_input_port_default_value(1, Quaternion());
+		} break;
 		default:
 			break;
 	}
@@ -2636,8 +2715,10 @@ String VisualShaderNodeVectorFunc::generate_code(Shader::Mode p_mode, VisualShad
 
 		if (op_type == OP_TYPE_VECTOR_2D) {
 			code = "max(min($, vec2(1.0)), vec2(0.0))";
-		} else {
+		} else if (op_type == OP_TYPE_VECTOR_3D) {
 			code = "max(min($, vec3(1.0)), vec3(0.0))";
+		} else {
+			code = "max(min($, vec4(1.0)), vec4(0.0))";
 		}
 		return "	" + p_output_vars[0] + " = " + code.replace("$", p_input_vars[0]) + ";\n";
 	}
@@ -2646,9 +2727,11 @@ String VisualShaderNodeVectorFunc::generate_code(Shader::Mode p_mode, VisualShad
 		String code;
 
 		if (op_type == OP_TYPE_VECTOR_2D) {
-			code = "vec2(1.0, 1.0) - $";
+			code = "vec2(1.0) - $";
+		} else if (op_type == OP_TYPE_VECTOR_3D) {
+			code = "vec3(1.0) - $";
 		} else {
-			code = "vec3(1.0, 1.0, 1.0) - $";
+			code = "vec4(1.0) - $";
 		}
 		return "	" + p_output_vars[0] + " = " + code.replace("$", p_input_vars[0]) + ";\n";
 	}
@@ -2656,9 +2739,12 @@ String VisualShaderNodeVectorFunc::generate_code(Shader::Mode p_mode, VisualShad
 	String code;
 
 	if (func == FUNC_RGB2HSV) {
-		if (op_type == OP_TYPE_VECTOR_2D) { // not supported
+		if (op_type == OP_TYPE_VECTOR_2D) { // Not supported.
 			return "	" + p_output_vars[0] + " = vec2(0.0);\n";
 		}
+		if (op_type == OP_TYPE_VECTOR_4D) { // Not supported.
+			return "	" + p_output_vars[0] + " = vec4(0.0);\n";
+		}
 		code += "	{\n";
 		code += "		vec3 c = " + p_input_vars[0] + ";\n";
 		code += "		vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);\n";
@@ -2669,9 +2755,12 @@ String VisualShaderNodeVectorFunc::generate_code(Shader::Mode p_mode, VisualShad
 		code += "		" + p_output_vars[0] + " = vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);\n";
 		code += "	}\n";
 	} else if (func == FUNC_HSV2RGB) {
-		if (op_type == OP_TYPE_VECTOR_2D) { // not supported
+		if (op_type == OP_TYPE_VECTOR_2D) { // Not supported.
 			return "	" + p_output_vars[0] + " = vec2(0.0);\n";
 		}
+		if (op_type == OP_TYPE_VECTOR_4D) { // Not supported.
+			return "	" + p_output_vars[0] + " = vec4(0.0);\n";
+		}
 		code += "	{\n";
 		code += "		vec3 c = " + p_input_vars[0] + ";\n";
 		code += "		vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);\n";
@@ -2698,6 +2787,9 @@ void VisualShaderNodeVectorFunc::set_op_type(OpType p_op_type) {
 		case OP_TYPE_VECTOR_3D: {
 			set_input_port_default_value(0, Vector3(), get_input_port_default_value(0));
 		} break;
+		case OP_TYPE_VECTOR_4D: {
+			set_input_port_default_value(0, Quaternion(), get_input_port_default_value(0));
+		} break;
 		default:
 			break;
 	}
@@ -2734,7 +2826,7 @@ Vector<StringName> VisualShaderNodeVectorFunc::get_editable_properties() const {
 String VisualShaderNodeVectorFunc::get_warning(Shader::Mode p_mode, VisualShader::Type p_type) const {
 	bool invalid_type = false;
 
-	if (op_type == OP_TYPE_VECTOR_2D) {
+	if (op_type == OP_TYPE_VECTOR_2D || op_type == OP_TYPE_VECTOR_4D) {
 		if (func == FUNC_RGB2HSV || func == FUNC_HSV2RGB) {
 			invalid_type = true;
 		}
@@ -2799,6 +2891,9 @@ VisualShaderNodeVectorFunc::VisualShaderNodeVectorFunc() {
 		case OP_TYPE_VECTOR_3D: {
 			set_input_port_default_value(0, Vector3());
 		} break;
+		case OP_TYPE_VECTOR_4D: {
+			set_input_port_default_value(0, Quaternion());
+		} break;
 		default:
 			break;
 	}
@@ -3189,6 +3284,9 @@ void VisualShaderNodeVectorLen::set_op_type(OpType p_op_type) {
 		case OP_TYPE_VECTOR_3D: {
 			set_input_port_default_value(0, Vector3(), get_input_port_default_value(0));
 		} break;
+		case OP_TYPE_VECTOR_4D: {
+			set_input_port_default_value(0, Quaternion(), get_input_port_default_value(0));
+		} break;
 		default:
 			break;
 	}
@@ -3258,6 +3356,8 @@ VisualShaderNodeDerivativeFunc::PortType VisualShaderNodeDerivativeFunc::get_inp
 			return PORT_TYPE_VECTOR_2D;
 		case OP_TYPE_VECTOR_3D:
 			return PORT_TYPE_VECTOR_3D;
+		case OP_TYPE_VECTOR_4D:
+			return PORT_TYPE_VECTOR_4D;
 		default:
 			break;
 	}
@@ -3278,6 +3378,8 @@ VisualShaderNodeDerivativeFunc::PortType VisualShaderNodeDerivativeFunc::get_out
 			return PORT_TYPE_VECTOR_2D;
 		case OP_TYPE_VECTOR_3D:
 			return PORT_TYPE_VECTOR_3D;
+		case OP_TYPE_VECTOR_4D:
+			return PORT_TYPE_VECTOR_4D;
 		default:
 			break;
 	}
@@ -3315,6 +3417,9 @@ void VisualShaderNodeDerivativeFunc::set_op_type(OpType p_op_type) {
 		case OP_TYPE_VECTOR_3D: {
 			set_input_port_default_value(0, Vector3(), get_input_port_default_value(0));
 		} break;
+		case OP_TYPE_VECTOR_4D: {
+			set_input_port_default_value(0, Quaternion(), get_input_port_default_value(0));
+		} break;
 		default:
 			break;
 	}
@@ -3353,12 +3458,13 @@ void VisualShaderNodeDerivativeFunc::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("set_function", "func"), &VisualShaderNodeDerivativeFunc::set_function);
 	ClassDB::bind_method(D_METHOD("get_function"), &VisualShaderNodeDerivativeFunc::get_function);
 
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "op_type", PROPERTY_HINT_ENUM, "Scalar,Vector2,Vector3"), "set_op_type", "get_op_type");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "op_type", PROPERTY_HINT_ENUM, "Scalar,Vector2,Vector3,Vector4"), "set_op_type", "get_op_type");
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "function", PROPERTY_HINT_ENUM, "Sum,X,Y"), "set_function", "get_function");
 
 	BIND_ENUM_CONSTANT(OP_TYPE_SCALAR);
 	BIND_ENUM_CONSTANT(OP_TYPE_VECTOR_2D);
 	BIND_ENUM_CONSTANT(OP_TYPE_VECTOR_3D);
+	BIND_ENUM_CONSTANT(OP_TYPE_VECTOR_4D);
 	BIND_ENUM_CONSTANT(OP_TYPE_MAX);
 
 	BIND_ENUM_CONSTANT(FUNC_SUM);
@@ -3389,6 +3495,8 @@ VisualShaderNodeClamp::PortType VisualShaderNodeClamp::get_input_port_type(int p
 			return PORT_TYPE_VECTOR_2D;
 		case OP_TYPE_VECTOR_3D:
 			return PORT_TYPE_VECTOR_3D;
+		case OP_TYPE_VECTOR_4D:
+			return PORT_TYPE_VECTOR_4D;
 		default:
 			break;
 	}
@@ -3418,6 +3526,8 @@ VisualShaderNodeClamp::PortType VisualShaderNodeClamp::get_output_port_type(int
 			return PORT_TYPE_VECTOR_2D;
 		case OP_TYPE_VECTOR_3D:
 			return PORT_TYPE_VECTOR_3D;
+		case OP_TYPE_VECTOR_4D:
+			return PORT_TYPE_VECTOR_4D;
 		default:
 			break;
 	}
@@ -3458,6 +3568,11 @@ void VisualShaderNodeClamp::set_op_type(OpType p_op_type) {
 			set_input_port_default_value(1, Vector3(), get_input_port_default_value(1));
 			set_input_port_default_value(2, Vector3(), get_input_port_default_value(2));
 			break;
+		case OP_TYPE_VECTOR_4D:
+			set_input_port_default_value(0, Quaternion(), get_input_port_default_value(0));
+			set_input_port_default_value(1, Quaternion(), get_input_port_default_value(1));
+			set_input_port_default_value(2, Quaternion(), get_input_port_default_value(2));
+			break;
 		default:
 			break;
 	}
@@ -3479,12 +3594,13 @@ void VisualShaderNodeClamp::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("set_op_type", "op_type"), &VisualShaderNodeClamp::set_op_type);
 	ClassDB::bind_method(D_METHOD("get_op_type"), &VisualShaderNodeClamp::get_op_type);
 
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "op_type", PROPERTY_HINT_ENUM, "Float,Int,Vector2,Vector3"), "set_op_type", "get_op_type");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "op_type", PROPERTY_HINT_ENUM, "Float,Int,Vector2,Vector3,Vector4"), "set_op_type", "get_op_type");
 
 	BIND_ENUM_CONSTANT(OP_TYPE_FLOAT);
 	BIND_ENUM_CONSTANT(OP_TYPE_INT);
 	BIND_ENUM_CONSTANT(OP_TYPE_VECTOR_2D);
 	BIND_ENUM_CONSTANT(OP_TYPE_VECTOR_3D);
+	BIND_ENUM_CONSTANT(OP_TYPE_VECTOR_4D);
 	BIND_ENUM_CONSTANT(OP_TYPE_MAX);
 }
 
@@ -3541,6 +3657,11 @@ void VisualShaderNodeFaceForward::set_op_type(OpType p_op_type) {
 			set_input_port_default_value(1, Vector3(), get_input_port_default_value(1));
 			set_input_port_default_value(2, Vector3(), get_input_port_default_value(2));
 		} break;
+		case OP_TYPE_VECTOR_4D: {
+			set_input_port_default_value(0, Quaternion(), get_input_port_default_value(0));
+			set_input_port_default_value(1, Quaternion(), get_input_port_default_value(1));
+			set_input_port_default_value(2, Quaternion(), get_input_port_default_value(2));
+		} break;
 		default:
 			break;
 	}
@@ -3630,6 +3751,13 @@ VisualShaderNodeStep::PortType VisualShaderNodeStep::get_input_port_type(int p_p
 				return PORT_TYPE_VECTOR_3D;
 			}
 			break;
+		case OP_TYPE_VECTOR_4D:
+			return PORT_TYPE_VECTOR_4D;
+		case OP_TYPE_VECTOR_4D_SCALAR:
+			if (p_port == 1) {
+				return PORT_TYPE_VECTOR_4D;
+			}
+			break;
 		default:
 			break;
 	}
@@ -3660,6 +3788,10 @@ VisualShaderNodeStep::PortType VisualShaderNodeStep::get_output_port_type(int p_
 			return PORT_TYPE_VECTOR_3D;
 		case OP_TYPE_VECTOR_3D_SCALAR:
 			return PORT_TYPE_VECTOR_3D;
+		case OP_TYPE_VECTOR_4D:
+			return PORT_TYPE_VECTOR_4D;
+		case OP_TYPE_VECTOR_4D_SCALAR:
+			return PORT_TYPE_VECTOR_4D;
 		default:
 			break;
 	}
@@ -3696,6 +3828,14 @@ void VisualShaderNodeStep::set_op_type(OpType p_op_type) {
 			set_input_port_default_value(0, 0.0, get_input_port_default_value(0));
 			set_input_port_default_value(1, Vector3(), get_input_port_default_value(1));
 		} break;
+		case OP_TYPE_VECTOR_4D: {
+			set_input_port_default_value(0, Quaternion(), get_input_port_default_value(0));
+			set_input_port_default_value(1, Quaternion(), get_input_port_default_value(1));
+		} break;
+		case OP_TYPE_VECTOR_4D_SCALAR: {
+			set_input_port_default_value(0, 0.0, get_input_port_default_value(0));
+			set_input_port_default_value(1, Quaternion(), get_input_port_default_value(1));
+		} break;
 		default:
 			break;
 	}
@@ -3721,13 +3861,15 @@ void VisualShaderNodeStep::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("set_op_type", "op_type"), &VisualShaderNodeStep::set_op_type);
 	ClassDB::bind_method(D_METHOD("get_op_type"), &VisualShaderNodeStep::get_op_type);
 
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "op_type", PROPERTY_HINT_ENUM, "Scalar,Vector2,Vector2Scalar,Vector3,Vector3Scalar"), "set_op_type", "get_op_type");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "op_type", PROPERTY_HINT_ENUM, "Scalar,Vector2,Vector2Scalar,Vector3,Vector3Scalar,Vector4,Vector4Scalar"), "set_op_type", "get_op_type");
 
 	BIND_ENUM_CONSTANT(OP_TYPE_SCALAR);
 	BIND_ENUM_CONSTANT(OP_TYPE_VECTOR_2D);
 	BIND_ENUM_CONSTANT(OP_TYPE_VECTOR_2D_SCALAR);
 	BIND_ENUM_CONSTANT(OP_TYPE_VECTOR_3D);
 	BIND_ENUM_CONSTANT(OP_TYPE_VECTOR_3D_SCALAR);
+	BIND_ENUM_CONSTANT(OP_TYPE_VECTOR_4D);
+	BIND_ENUM_CONSTANT(OP_TYPE_VECTOR_4D_SCALAR);
 	BIND_ENUM_CONSTANT(OP_TYPE_MAX);
 }
 
@@ -3762,6 +3904,13 @@ VisualShaderNodeSmoothStep::PortType VisualShaderNodeSmoothStep::get_input_port_
 				return PORT_TYPE_VECTOR_3D; // x
 			}
 			break;
+		case OP_TYPE_VECTOR_4D:
+			return PORT_TYPE_VECTOR_4D;
+		case OP_TYPE_VECTOR_4D_SCALAR:
+			if (p_port == 2) {
+				return PORT_TYPE_VECTOR_4D; // x
+			}
+			break;
 		default:
 			break;
 	}
@@ -3794,6 +3943,10 @@ VisualShaderNodeSmoothStep::PortType VisualShaderNodeSmoothStep::get_output_port
 			return PORT_TYPE_VECTOR_3D;
 		case OP_TYPE_VECTOR_3D_SCALAR:
 			return PORT_TYPE_VECTOR_3D;
+		case OP_TYPE_VECTOR_4D:
+			return PORT_TYPE_VECTOR_4D;
+		case OP_TYPE_VECTOR_4D_SCALAR:
+			return PORT_TYPE_VECTOR_4D;
 		default:
 			break;
 	}
@@ -3835,6 +3988,16 @@ void VisualShaderNodeSmoothStep::set_op_type(OpType p_op_type) {
 			set_input_port_default_value(1, 0.0, get_input_port_default_value(1)); // edge1
 			set_input_port_default_value(2, Vector3(), get_input_port_default_value(2)); // x
 			break;
+		case OP_TYPE_VECTOR_4D:
+			set_input_port_default_value(0, Quaternion(), get_input_port_default_value(0)); // edge0
+			set_input_port_default_value(1, Quaternion(), get_input_port_default_value(1)); // edge1
+			set_input_port_default_value(2, Quaternion(), get_input_port_default_value(2)); // x
+			break;
+		case OP_TYPE_VECTOR_4D_SCALAR:
+			set_input_port_default_value(0, 0.0, get_input_port_default_value(0)); // edge0
+			set_input_port_default_value(1, 0.0, get_input_port_default_value(1)); // edge1
+			set_input_port_default_value(2, Quaternion(), get_input_port_default_value(2)); // x
+			break;
 		default:
 			break;
 	}
@@ -3860,13 +4023,15 @@ void VisualShaderNodeSmoothStep::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("set_op_type", "op_type"), &VisualShaderNodeSmoothStep::set_op_type);
 	ClassDB::bind_method(D_METHOD("get_op_type"), &VisualShaderNodeSmoothStep::get_op_type);
 
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "op_type", PROPERTY_HINT_ENUM, "Scalar,Vector2,Vector2Scalar,Vector3,Vector3Scalar"), "set_op_type", "get_op_type");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "op_type", PROPERTY_HINT_ENUM, "Scalar,Vector2,Vector2Scalar,Vector3,Vector3Scalar,Vector4,Vector4Scalar"), "set_op_type", "get_op_type");
 
 	BIND_ENUM_CONSTANT(OP_TYPE_SCALAR);
 	BIND_ENUM_CONSTANT(OP_TYPE_VECTOR_2D);
 	BIND_ENUM_CONSTANT(OP_TYPE_VECTOR_2D_SCALAR);
 	BIND_ENUM_CONSTANT(OP_TYPE_VECTOR_3D);
 	BIND_ENUM_CONSTANT(OP_TYPE_VECTOR_3D_SCALAR);
+	BIND_ENUM_CONSTANT(OP_TYPE_VECTOR_4D);
+	BIND_ENUM_CONSTANT(OP_TYPE_VECTOR_4D_SCALAR);
 	BIND_ENUM_CONSTANT(OP_TYPE_MAX);
 }
 
@@ -3922,6 +4087,10 @@ void VisualShaderNodeVectorDistance::set_op_type(OpType p_op_type) {
 			set_input_port_default_value(0, Vector3(), get_input_port_default_value(0)); // a
 			set_input_port_default_value(1, Vector3(), get_input_port_default_value(1)); // b
 		} break;
+		case OP_TYPE_VECTOR_4D: {
+			set_input_port_default_value(0, Quaternion(), get_input_port_default_value(0)); // a
+			set_input_port_default_value(1, Quaternion(), get_input_port_default_value(1)); // b
+		} break;
 		default:
 			break;
 	}
@@ -4016,6 +4185,13 @@ VisualShaderNodeMix::PortType VisualShaderNodeMix::get_input_port_type(int p_por
 				break;
 			}
 			return PORT_TYPE_VECTOR_3D;
+		case OP_TYPE_VECTOR_4D:
+			return PORT_TYPE_VECTOR_4D;
+		case OP_TYPE_VECTOR_4D_SCALAR:
+			if (p_port == 2) {
+				break;
+			}
+			return PORT_TYPE_VECTOR_4D;
 		default:
 			break;
 	}
@@ -4046,6 +4222,10 @@ VisualShaderNodeMix::PortType VisualShaderNodeMix::get_output_port_type(int p_po
 			return PORT_TYPE_VECTOR_3D;
 		case OP_TYPE_VECTOR_3D_SCALAR:
 			return PORT_TYPE_VECTOR_3D;
+		case OP_TYPE_VECTOR_4D:
+			return PORT_TYPE_VECTOR_4D;
+		case OP_TYPE_VECTOR_4D_SCALAR:
+			return PORT_TYPE_VECTOR_4D;
 		default:
 			break;
 	}
@@ -4087,6 +4267,16 @@ void VisualShaderNodeMix::set_op_type(OpType p_op_type) {
 			set_input_port_default_value(1, Vector3(), get_input_port_default_value(1)); // b
 			set_input_port_default_value(2, 0.0, get_input_port_default_value(2)); // weight
 		} break;
+		case OP_TYPE_VECTOR_4D: {
+			set_input_port_default_value(0, Quaternion(), get_input_port_default_value(0)); // a
+			set_input_port_default_value(1, Quaternion(), get_input_port_default_value(1)); // b
+			set_input_port_default_value(2, Quaternion(), get_input_port_default_value(2)); // weight
+		} break;
+		case OP_TYPE_VECTOR_4D_SCALAR: {
+			set_input_port_default_value(0, Quaternion(), get_input_port_default_value(0)); // a
+			set_input_port_default_value(1, Quaternion(), get_input_port_default_value(1)); // b
+			set_input_port_default_value(2, 0.0, get_input_port_default_value(2)); // weight
+		} break;
 		default:
 			break;
 	}
@@ -4112,13 +4302,15 @@ void VisualShaderNodeMix::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("set_op_type", "op_type"), &VisualShaderNodeMix::set_op_type);
 	ClassDB::bind_method(D_METHOD("get_op_type"), &VisualShaderNodeMix::get_op_type);
 
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "op_type", PROPERTY_HINT_ENUM, "Scalar,Vector2,Vector2Scalar,Vector3,Vector3Scalar"), "set_op_type", "get_op_type");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "op_type", PROPERTY_HINT_ENUM, "Scalar,Vector2,Vector2Scalar,Vector3,Vector3Scalar,Vector4,Vector4Scalar"), "set_op_type", "get_op_type");
 
 	BIND_ENUM_CONSTANT(OP_TYPE_SCALAR);
 	BIND_ENUM_CONSTANT(OP_TYPE_VECTOR_2D);
 	BIND_ENUM_CONSTANT(OP_TYPE_VECTOR_2D_SCALAR);
 	BIND_ENUM_CONSTANT(OP_TYPE_VECTOR_3D);
 	BIND_ENUM_CONSTANT(OP_TYPE_VECTOR_3D_SCALAR);
+	BIND_ENUM_CONSTANT(OP_TYPE_VECTOR_4D);
+	BIND_ENUM_CONSTANT(OP_TYPE_VECTOR_4D_SCALAR);
 	BIND_ENUM_CONSTANT(OP_TYPE_MAX);
 }
 
@@ -4140,6 +4332,8 @@ int VisualShaderNodeVectorCompose::get_input_port_count() const {
 			return 2;
 		case OP_TYPE_VECTOR_3D:
 			return 3;
+		case OP_TYPE_VECTOR_4D:
+			return 4;
 		default:
 			break;
 	}
@@ -4170,6 +4364,18 @@ String VisualShaderNodeVectorCompose::get_input_port_name(int p_port) const {
 					return "z";
 			}
 		} break;
+		case OP_TYPE_VECTOR_4D: {
+			switch (p_port) {
+				case 0:
+					return "x";
+				case 1:
+					return "y";
+				case 2:
+					return "z";
+				case 3:
+					return "w";
+			}
+		} break;
 		default:
 			break;
 	}
@@ -4205,6 +4411,15 @@ void VisualShaderNodeVectorCompose::set_op_type(OpType p_op_type) {
 			set_input_port_default_value(1, p2);
 			set_input_port_default_value(2, 0.0);
 		} break;
+		case OP_TYPE_VECTOR_4D: {
+			float p1 = get_input_port_default_value(0);
+			float p2 = get_input_port_default_value(1);
+
+			set_input_port_default_value(0, p1);
+			set_input_port_default_value(1, p2);
+			set_input_port_default_value(2, 0.0);
+			set_input_port_default_value(3, 0.0);
+		} break;
 		default:
 			break;
 	}
@@ -4221,6 +4436,9 @@ String VisualShaderNodeVectorCompose::generate_code(Shader::Mode p_mode, VisualS
 		case OP_TYPE_VECTOR_3D: {
 			code += "	" + p_output_vars[0] + " = vec3(" + p_input_vars[0] + ", " + p_input_vars[1] + ", " + p_input_vars[2] + ");\n";
 		} break;
+		case OP_TYPE_VECTOR_4D: {
+			code += "	" + p_output_vars[0] + " = vec4(" + p_input_vars[0] + ", " + p_input_vars[1] + ", " + p_input_vars[2] + ", " + p_input_vars[3] + ");\n";
+		} break;
 		default:
 			break;
 	}
@@ -4301,6 +4519,8 @@ int VisualShaderNodeVectorDecompose::get_output_port_count() const {
 			return 2;
 		case OP_TYPE_VECTOR_3D:
 			return 3;
+		case OP_TYPE_VECTOR_4D:
+			return 4;
 		default:
 			break;
 	}
@@ -4331,6 +4551,18 @@ String VisualShaderNodeVectorDecompose::get_output_port_name(int p_port) const {
 					return "z";
 			}
 		} break;
+		case OP_TYPE_VECTOR_4D: {
+			switch (p_port) {
+				case 0:
+					return "x";
+				case 1:
+					return "y";
+				case 2:
+					return "z";
+				case 3:
+					return "w";
+			}
+		} break;
 		default:
 			break;
 	}
@@ -4349,6 +4581,9 @@ void VisualShaderNodeVectorDecompose::set_op_type(OpType p_op_type) {
 		case OP_TYPE_VECTOR_3D: {
 			set_input_port_default_value(0, Vector3(), get_input_port_default_value(0));
 		} break;
+		case OP_TYPE_VECTOR_4D: {
+			set_input_port_default_value(0, Quaternion(), get_input_port_default_value(0));
+		} break;
 		default:
 			break;
 	}
@@ -4368,6 +4603,12 @@ String VisualShaderNodeVectorDecompose::generate_code(Shader::Mode p_mode, Visua
 			code += "	" + p_output_vars[1] + " = " + p_input_vars[0] + ".y;\n";
 			code += "	" + p_output_vars[2] + " = " + p_input_vars[0] + ".z;\n";
 		} break;
+		case OP_TYPE_VECTOR_4D: {
+			code += "	" + p_output_vars[0] + " = " + p_input_vars[0] + ".x;\n";
+			code += "	" + p_output_vars[1] + " = " + p_input_vars[0] + ".y;\n";
+			code += "	" + p_output_vars[2] + " = " + p_input_vars[0] + ".z;\n";
+			code += "	" + p_output_vars[3] + " = " + p_input_vars[0] + ".w;\n";
+		} break;
 		default:
 			break;
 	}
@@ -5225,6 +5466,106 @@ Vector<StringName> VisualShaderNodeVec3Uniform::get_editable_properties() const
 VisualShaderNodeVec3Uniform::VisualShaderNodeVec3Uniform() {
 }
 
+////////////// Vector4 Uniform
+
+String VisualShaderNodeVec4Uniform::get_caption() const {
+	return "Vector4Uniform";
+}
+
+int VisualShaderNodeVec4Uniform::get_input_port_count() const {
+	return 0;
+}
+
+VisualShaderNodeVec4Uniform::PortType VisualShaderNodeVec4Uniform::get_input_port_type(int p_port) const {
+	return PORT_TYPE_VECTOR_4D;
+}
+
+String VisualShaderNodeVec4Uniform::get_input_port_name(int p_port) const {
+	return String();
+}
+
+int VisualShaderNodeVec4Uniform::get_output_port_count() const {
+	return 1;
+}
+
+VisualShaderNodeVec4Uniform::PortType VisualShaderNodeVec4Uniform::get_output_port_type(int p_port) const {
+	return PORT_TYPE_VECTOR_4D;
+}
+
+String VisualShaderNodeVec4Uniform::get_output_port_name(int p_port) const {
+	return ""; // No output port means the editor will be used as port.
+}
+
+void VisualShaderNodeVec4Uniform::set_default_value_enabled(bool p_enabled) {
+	default_value_enabled = p_enabled;
+	emit_changed();
+}
+
+bool VisualShaderNodeVec4Uniform::is_default_value_enabled() const {
+	return default_value_enabled;
+}
+
+void VisualShaderNodeVec4Uniform::set_default_value(const Quaternion &p_value) {
+	default_value = p_value;
+	emit_changed();
+}
+
+Quaternion VisualShaderNodeVec4Uniform::get_default_value() const {
+	return default_value;
+}
+
+String VisualShaderNodeVec4Uniform::generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const {
+	String code = _get_qual_str() + "uniform vec4 " + get_uniform_name();
+	if (default_value_enabled) {
+		code += vformat(" = vec4(%.6f, %.6f, %.6f, %.6f)", default_value.x, default_value.y, default_value.z, default_value.w);
+	}
+	code += ";\n";
+	return code;
+}
+
+String VisualShaderNodeVec4Uniform::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 {
+	return "	" + p_output_vars[0] + " = " + get_uniform_name() + ";\n";
+}
+
+void VisualShaderNodeVec4Uniform::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("set_default_value_enabled", "enabled"), &VisualShaderNodeVec4Uniform::set_default_value_enabled);
+	ClassDB::bind_method(D_METHOD("is_default_value_enabled"), &VisualShaderNodeVec4Uniform::is_default_value_enabled);
+
+	ClassDB::bind_method(D_METHOD("set_default_value", "value"), &VisualShaderNodeVec4Uniform::set_default_value);
+	ClassDB::bind_method(D_METHOD("get_default_value"), &VisualShaderNodeVec4Uniform::get_default_value);
+
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "default_value_enabled"), "set_default_value_enabled", "is_default_value_enabled");
+	ADD_PROPERTY(PropertyInfo(Variant::QUATERNION, "default_value"), "set_default_value", "get_default_value");
+}
+
+bool VisualShaderNodeVec4Uniform::is_show_prop_names() const {
+	return true;
+}
+
+bool VisualShaderNodeVec4Uniform::is_use_prop_slots() const {
+	return true;
+}
+
+bool VisualShaderNodeVec4Uniform::is_qualifier_supported(Qualifier p_qual) const {
+	return true; // All qualifiers are supported.
+}
+
+bool VisualShaderNodeVec4Uniform::is_convertible_to_constant() const {
+	return true; // Conversion is allowed.
+}
+
+Vector<StringName> VisualShaderNodeVec4Uniform::get_editable_properties() const {
+	Vector<StringName> props = VisualShaderNodeUniform::get_editable_properties();
+	props.push_back("default_value_enabled");
+	if (default_value_enabled) {
+		props.push_back("default_value");
+	}
+	return props;
+}
+
+VisualShaderNodeVec4Uniform::VisualShaderNodeVec4Uniform() {
+}
+
 ////////////// Transform Uniform
 
 String VisualShaderNodeTransformUniform::get_caption() const {
@@ -6080,6 +6421,8 @@ VisualShaderNodeSwitch::PortType VisualShaderNodeSwitch::get_input_port_type(int
 				return PORT_TYPE_VECTOR_2D;
 			case OP_TYPE_VECTOR_3D:
 				return PORT_TYPE_VECTOR_3D;
+			case OP_TYPE_VECTOR_4D:
+				return PORT_TYPE_VECTOR_4D;
 			case OP_TYPE_BOOLEAN:
 				return PORT_TYPE_BOOLEAN;
 			case OP_TYPE_TRANSFORM:
@@ -6116,6 +6459,8 @@ VisualShaderNodeSwitch::PortType VisualShaderNodeSwitch::get_output_port_type(in
 			return PORT_TYPE_VECTOR_2D;
 		case OP_TYPE_VECTOR_3D:
 			return PORT_TYPE_VECTOR_3D;
+		case OP_TYPE_VECTOR_4D:
+			return PORT_TYPE_VECTOR_4D;
 		case OP_TYPE_BOOLEAN:
 			return PORT_TYPE_BOOLEAN;
 		case OP_TYPE_TRANSFORM:
@@ -6152,6 +6497,10 @@ void VisualShaderNodeSwitch::set_op_type(OpType p_op_type) {
 			set_input_port_default_value(1, Vector3(1.0, 1.0, 1.0), get_input_port_default_value(1));
 			set_input_port_default_value(2, Vector3(0.0, 0.0, 0.0), get_input_port_default_value(2));
 			break;
+		case OP_TYPE_VECTOR_4D:
+			set_input_port_default_value(1, Quaternion(1.0, 1.0, 1.0, 1.0), get_input_port_default_value(1));
+			set_input_port_default_value(2, Quaternion(0.0, 0.0, 0.0, 0.0), get_input_port_default_value(2));
+			break;
 		case OP_TYPE_BOOLEAN:
 			set_input_port_default_value(1, true);
 			set_input_port_default_value(2, false);
@@ -6181,12 +6530,13 @@ void VisualShaderNodeSwitch::_bind_methods() { // static
 	ClassDB::bind_method(D_METHOD("set_op_type", "type"), &VisualShaderNodeSwitch::set_op_type);
 	ClassDB::bind_method(D_METHOD("get_op_type"), &VisualShaderNodeSwitch::get_op_type);
 
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "op_type", PROPERTY_HINT_ENUM, "Float,Int,Vector2,Vector3,Boolean,Transform"), "set_op_type", "get_op_type");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "op_type", PROPERTY_HINT_ENUM, "Float,Int,Vector2,Vector3,Vector4,Boolean,Transform"), "set_op_type", "get_op_type");
 
 	BIND_ENUM_CONSTANT(OP_TYPE_FLOAT);
 	BIND_ENUM_CONSTANT(OP_TYPE_INT);
 	BIND_ENUM_CONSTANT(OP_TYPE_VECTOR_2D);
 	BIND_ENUM_CONSTANT(OP_TYPE_VECTOR_3D);
+	BIND_ENUM_CONSTANT(OP_TYPE_VECTOR_4D);
 	BIND_ENUM_CONSTANT(OP_TYPE_BOOLEAN);
 	BIND_ENUM_CONSTANT(OP_TYPE_TRANSFORM);
 	BIND_ENUM_CONSTANT(OP_TYPE_MAX);
@@ -6420,6 +6770,8 @@ VisualShaderNodeCompare::PortType VisualShaderNodeCompare::get_input_port_type(i
 			return PORT_TYPE_VECTOR_2D;
 		case CTYPE_VECTOR_3D:
 			return PORT_TYPE_VECTOR_3D;
+		case CTYPE_VECTOR_4D:
+			return PORT_TYPE_VECTOR_4D;
 		case CTYPE_BOOLEAN:
 			return PORT_TYPE_BOOLEAN;
 		case CTYPE_TRANSFORM:
@@ -6514,6 +6866,12 @@ String VisualShaderNodeCompare::generate_code(Shader::Mode p_mode, VisualShader:
 			code += "		" + p_output_vars[0] + " = " + String(conditions[condition]).replace("$", "_bv") + ";\n";
 			code += "	}\n";
 		} break;
+		case CTYPE_VECTOR_4D: {
+			code += "	{\n";
+			code += "		bvec4 _bv = " + String(functions[func]).replace("$", p_input_vars[0] + ", " + p_input_vars[1]) + ";\n";
+			code += "		" + p_output_vars[0] + " = " + String(conditions[condition]).replace("$", "_bv") + ";\n";
+			code += "	}\n";
+		} break;
 		case CTYPE_BOOLEAN: {
 			if (func > FUNC_NOT_EQUAL) {
 				return "	" + p_output_vars[0] + " = false;\n";
@@ -6558,6 +6916,11 @@ void VisualShaderNodeCompare::set_comparison_type(ComparisonType p_comparison_ty
 			set_input_port_default_value(1, Vector3(), get_input_port_default_value(1));
 			simple_decl = false;
 			break;
+		case CTYPE_VECTOR_4D:
+			set_input_port_default_value(0, Quaternion(), get_input_port_default_value(0));
+			set_input_port_default_value(1, Quaternion(), get_input_port_default_value(1));
+			simple_decl = false;
+			break;
 		case CTYPE_BOOLEAN:
 			set_input_port_default_value(0, false);
 			set_input_port_default_value(1, false);
@@ -6609,7 +6972,7 @@ Vector<StringName> VisualShaderNodeCompare::get_editable_properties() const {
 	Vector<StringName> props;
 	props.push_back("type");
 	props.push_back("function");
-	if (comparison_type == CTYPE_VECTOR_2D || comparison_type == CTYPE_VECTOR_3D) {
+	if (comparison_type == CTYPE_VECTOR_2D || comparison_type == CTYPE_VECTOR_3D || comparison_type == CTYPE_VECTOR_4D) {
 		props.push_back("condition");
 	}
 	return props;
@@ -6625,7 +6988,7 @@ void VisualShaderNodeCompare::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("set_condition", "condition"), &VisualShaderNodeCompare::set_condition);
 	ClassDB::bind_method(D_METHOD("get_condition"), &VisualShaderNodeCompare::get_condition);
 
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "type", PROPERTY_HINT_ENUM, "Float,Int,Vector2,Vector3,Boolean,Transform"), "set_comparison_type", "get_comparison_type");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "type", PROPERTY_HINT_ENUM, "Float,Int,Vector2,Vector3,Vector4,Boolean,Transform"), "set_comparison_type", "get_comparison_type");
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "function", PROPERTY_HINT_ENUM, "a == b,a != b,a > b,a >= b,a < b,a <= b"), "set_function", "get_function");
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "condition", PROPERTY_HINT_ENUM, "All,Any"), "set_condition", "get_condition");
 
@@ -6633,6 +6996,7 @@ void VisualShaderNodeCompare::_bind_methods() {
 	BIND_ENUM_CONSTANT(CTYPE_SCALAR_INT);
 	BIND_ENUM_CONSTANT(CTYPE_VECTOR_2D);
 	BIND_ENUM_CONSTANT(CTYPE_VECTOR_3D);
+	BIND_ENUM_CONSTANT(CTYPE_VECTOR_4D);
 	BIND_ENUM_CONSTANT(CTYPE_BOOLEAN);
 	BIND_ENUM_CONSTANT(CTYPE_TRANSFORM);
 	BIND_ENUM_CONSTANT(CTYPE_MAX);
@@ -6672,6 +7036,8 @@ VisualShaderNodeMultiplyAdd::PortType VisualShaderNodeMultiplyAdd::get_input_por
 			return PORT_TYPE_VECTOR_2D;
 		case OP_TYPE_VECTOR_3D:
 			return PORT_TYPE_VECTOR_3D;
+		case OP_TYPE_VECTOR_4D:
+			return PORT_TYPE_VECTOR_4D;
 		default:
 			break;
 	}
@@ -6699,6 +7065,8 @@ VisualShaderNodeMultiplyAdd::PortType VisualShaderNodeMultiplyAdd::get_output_po
 			return PORT_TYPE_VECTOR_2D;
 		case OP_TYPE_VECTOR_3D:
 			return PORT_TYPE_VECTOR_3D;
+		case OP_TYPE_VECTOR_4D:
+			return PORT_TYPE_VECTOR_4D;
 		default:
 			break;
 	}
@@ -6734,6 +7102,11 @@ void VisualShaderNodeMultiplyAdd::set_op_type(OpType p_op_type) {
 			set_input_port_default_value(1, Vector3(), get_input_port_default_value(1));
 			set_input_port_default_value(2, Vector3(), get_input_port_default_value(2));
 		} break;
+		case OP_TYPE_VECTOR_4D: {
+			set_input_port_default_value(0, Quaternion(), get_input_port_default_value(0));
+			set_input_port_default_value(1, Quaternion(), get_input_port_default_value(1));
+			set_input_port_default_value(2, Quaternion(), get_input_port_default_value(2));
+		} break;
 		default:
 			break;
 	}
@@ -6755,11 +7128,12 @@ void VisualShaderNodeMultiplyAdd::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("set_op_type", "type"), &VisualShaderNodeMultiplyAdd::set_op_type);
 	ClassDB::bind_method(D_METHOD("get_op_type"), &VisualShaderNodeMultiplyAdd::get_op_type);
 
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "op_type", PROPERTY_HINT_ENUM, "Scalar,Vector2,Vector3"), "set_op_type", "get_op_type");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "op_type", PROPERTY_HINT_ENUM, "Scalar,Vector2,Vector3,Vector4"), "set_op_type", "get_op_type");
 
 	BIND_ENUM_CONSTANT(OP_TYPE_SCALAR);
 	BIND_ENUM_CONSTANT(OP_TYPE_VECTOR_2D);
 	BIND_ENUM_CONSTANT(OP_TYPE_VECTOR_3D);
+	BIND_ENUM_CONSTANT(OP_TYPE_VECTOR_4D);
 	BIND_ENUM_CONSTANT(OP_TYPE_MAX);
 }
 
diff --git a/scene/resources/visual_shader_nodes.h b/scene/resources/visual_shader_nodes.h
index eeeb91a3ee..da638c2d10 100644
--- a/scene/resources/visual_shader_nodes.h
+++ b/scene/resources/visual_shader_nodes.h
@@ -44,6 +44,7 @@ public:
 	enum OpType {
 		OP_TYPE_VECTOR_2D,
 		OP_TYPE_VECTOR_3D,
+		OP_TYPE_VECTOR_4D,
 		OP_TYPE_MAX,
 	};
 
@@ -280,6 +281,36 @@ public:
 
 ///////////////////////////////////////
 
+class VisualShaderNodeVec4Constant : public VisualShaderNodeConstant {
+	GDCLASS(VisualShaderNodeVec4Constant, VisualShaderNodeConstant);
+	Quaternion constant;
+
+protected:
+	static void _bind_methods();
+
+public:
+	virtual String get_caption() const override;
+
+	virtual int get_input_port_count() const override;
+	virtual PortType get_input_port_type(int p_port) const override;
+	virtual String get_input_port_name(int p_port) const override;
+
+	virtual int get_output_port_count() const override;
+	virtual PortType get_output_port_type(int p_port) const override;
+	virtual String get_output_port_name(int p_port) const override;
+
+	virtual String 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 = false) const override;
+
+	void set_constant(const Quaternion &p_constant);
+	Quaternion get_constant() const;
+
+	virtual Vector<StringName> get_editable_properties() const override;
+
+	VisualShaderNodeVec4Constant();
+};
+
+///////////////////////////////////////
+
 class VisualShaderNodeTransformConstant : public VisualShaderNodeConstant {
 	GDCLASS(VisualShaderNodeTransformConstant, VisualShaderNodeConstant);
 	Transform3D constant;
@@ -1282,6 +1313,7 @@ public:
 		OP_TYPE_INT,
 		OP_TYPE_VECTOR_2D,
 		OP_TYPE_VECTOR_3D,
+		OP_TYPE_VECTOR_4D,
 		OP_TYPE_MAX,
 	};
 
@@ -1324,6 +1356,7 @@ public:
 		OP_TYPE_SCALAR,
 		OP_TYPE_VECTOR_2D,
 		OP_TYPE_VECTOR_3D,
+		OP_TYPE_VECTOR_4D,
 		OP_TYPE_MAX,
 	};
 
@@ -1427,6 +1460,8 @@ public:
 		OP_TYPE_VECTOR_2D_SCALAR,
 		OP_TYPE_VECTOR_3D,
 		OP_TYPE_VECTOR_3D_SCALAR,
+		OP_TYPE_VECTOR_4D,
+		OP_TYPE_VECTOR_4D_SCALAR,
 		OP_TYPE_MAX,
 	};
 
@@ -1471,6 +1506,8 @@ public:
 		OP_TYPE_VECTOR_2D_SCALAR,
 		OP_TYPE_VECTOR_3D,
 		OP_TYPE_VECTOR_3D_SCALAR,
+		OP_TYPE_VECTOR_4D,
+		OP_TYPE_VECTOR_4D_SCALAR,
 		OP_TYPE_MAX,
 	};
 
@@ -1561,6 +1598,8 @@ public:
 		OP_TYPE_VECTOR_2D_SCALAR,
 		OP_TYPE_VECTOR_3D,
 		OP_TYPE_VECTOR_3D_SCALAR,
+		OP_TYPE_VECTOR_4D,
+		OP_TYPE_VECTOR_4D_SCALAR,
 		OP_TYPE_MAX,
 	};
 
@@ -1990,6 +2029,49 @@ public:
 
 ///////////////////////////////////////
 
+class VisualShaderNodeVec4Uniform : public VisualShaderNodeUniform {
+	GDCLASS(VisualShaderNodeVec4Uniform, VisualShaderNodeUniform);
+
+private:
+	bool default_value_enabled = false;
+	Quaternion default_value;
+
+protected:
+	static void _bind_methods();
+
+public:
+	virtual String get_caption() const override;
+
+	virtual int get_input_port_count() const override;
+	virtual PortType get_input_port_type(int p_port) const override;
+	virtual String get_input_port_name(int p_port) const override;
+
+	virtual int get_output_port_count() const override;
+	virtual PortType get_output_port_type(int p_port) const override;
+	virtual String get_output_port_name(int p_port) const override;
+
+	virtual String generate_global(Shader::Mode p_mode, VisualShader::Type p_type, int p_id) const override;
+	virtual String 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 = false) const override;
+
+	virtual bool is_show_prop_names() const override;
+	virtual bool is_use_prop_slots() const override;
+
+	void set_default_value_enabled(bool p_enabled);
+	bool is_default_value_enabled() const;
+
+	void set_default_value(const Quaternion &p_value);
+	Quaternion get_default_value() const;
+
+	bool is_qualifier_supported(Qualifier p_qual) const override;
+	bool is_convertible_to_constant() const override;
+
+	virtual Vector<StringName> get_editable_properties() const override;
+
+	VisualShaderNodeVec4Uniform();
+};
+
+///////////////////////////////////////
+
 class VisualShaderNodeTransformUniform : public VisualShaderNodeUniform {
 	GDCLASS(VisualShaderNodeTransformUniform, VisualShaderNodeUniform);
 
@@ -2248,6 +2330,7 @@ public:
 		OP_TYPE_INT,
 		OP_TYPE_VECTOR_2D,
 		OP_TYPE_VECTOR_3D,
+		OP_TYPE_VECTOR_4D,
 		OP_TYPE_BOOLEAN,
 		OP_TYPE_TRANSFORM,
 		OP_TYPE_MAX,
@@ -2362,6 +2445,7 @@ public:
 		CTYPE_SCALAR_INT,
 		CTYPE_VECTOR_2D,
 		CTYPE_VECTOR_3D,
+		CTYPE_VECTOR_4D,
 		CTYPE_BOOLEAN,
 		CTYPE_TRANSFORM,
 		CTYPE_MAX,
@@ -2431,6 +2515,7 @@ public:
 		OP_TYPE_SCALAR,
 		OP_TYPE_VECTOR_2D,
 		OP_TYPE_VECTOR_3D,
+		OP_TYPE_VECTOR_4D,
 		OP_TYPE_MAX,
 	};