Adding shader preprocessor support

Co-authored-by: TheOrangeDay <6472143+TheOrangeDay@users.noreply.github.com>

4 files changed, 1421 insertions, 27 deletions

diff --git a/servers/rendering/shader_language.cpp b/servers/rendering/shader_language.cpp
index ad9b51ac0c..f4de32d14b 100644
--- a/servers/rendering/shader_language.cpp
+++ b/servers/rendering/shader_language.cpp
@@ -33,6 +33,7 @@
 #include "core/os/os.h"
 #include "core/string/print_string.h"
 #include "servers/rendering_server.h"
+#include "shader_preprocessor.h"
 
 #define HAS_WARNING(flag) (warning_flags & flag)
 
@@ -4118,6 +4119,10 @@ void ShaderLanguage::get_keyword_list(List<String> *r_keywords) {
 	}
 }
 
+void ShaderLanguage::get_preprocessor_keyword_list(List<String> *r_keywords, bool p_include_shader_keywords) {
+	ShaderPreprocessor::get_keyword_list(r_keywords, p_include_shader_keywords);
+}
+
 bool ShaderLanguage::is_control_flow_keyword(String p_keyword) {
 	return p_keyword == "break" ||
 			p_keyword == "case" ||
@@ -7677,35 +7682,60 @@ Error ShaderLanguage::_validate_precision(DataType p_type, DataPrecision p_preci
 	return OK;
 }
 
-Error ShaderLanguage::_parse_shader(const HashMap<StringName, FunctionInfo> &p_functions, const Vector<ModeInfo> &p_render_modes, const HashSet<String> &p_shader_types) {
-	Token tk = _get_token();
+Error ShaderLanguage::_preprocess_shader(const String &p_code, String &r_result, int *r_completion_type) {
+	Error error = OK;
+
+	ShaderPreprocessor processor(p_code);
+	processor.preprocess(r_result);
+
+	ShaderPreprocessor::State *state = processor.get_state();
+	if (!state->error.is_empty()) {
+		error_line = state->error_line;
+		error_set = true;
+		error_str = state->error;
+		error = FAILED;
+	}
+
+	if (r_completion_type != nullptr) {
+		*r_completion_type = (int)state->completion_type;
+	}
+
+	return error;
+}
+
+Error ShaderLanguage::_parse_shader(const HashMap<StringName, FunctionInfo> &p_functions, const Vector<ModeInfo> &p_render_modes, const HashSet<String> &p_shader_types, bool p_is_include) {
+	Token tk;
 	TkPos prev_pos;
 	Token next;
 
-	if (tk.type != TK_SHADER_TYPE) {
-		_set_error(vformat(RTR("Expected '%s' at the beginning of shader. Valid types are: %s."), "shader_type", _get_shader_type_list(p_shader_types)));
-		return ERR_PARSE_ERROR;
-	}
+	if (!p_is_include) {
+		tk = _get_token();
+
+		if (tk.type != TK_SHADER_TYPE) {
+			_set_error(vformat(RTR("Expected '%s' at the beginning of shader. Valid types are: %s."), "shader_type", _get_shader_type_list(p_shader_types)));
+			return ERR_PARSE_ERROR;
+		}
 #ifdef DEBUG_ENABLED
-	keyword_completion_context = CF_UNSPECIFIED;
+		keyword_completion_context = CF_UNSPECIFIED;
 #endif // DEBUG_ENABLED
 
-	_get_completable_identifier(nullptr, COMPLETION_SHADER_TYPE, shader_type_identifier);
-	if (shader_type_identifier == StringName()) {
-		_set_error(vformat(RTR("Expected an identifier after '%s', indicating the type of shader. Valid types are: %s."), "shader_type", _get_shader_type_list(p_shader_types)));
-		return ERR_PARSE_ERROR;
-	}
-	if (!p_shader_types.has(shader_type_identifier)) {
-		_set_error(vformat(RTR("Invalid shader type. Valid types are: %s"), _get_shader_type_list(p_shader_types)));
-		return ERR_PARSE_ERROR;
-	}
-	prev_pos = _get_tkpos();
-	tk = _get_token();
+		_get_completable_identifier(nullptr, COMPLETION_SHADER_TYPE, shader_type_identifier);
+		if (shader_type_identifier == StringName()) {
+			_set_error(vformat(RTR("Expected an identifier after '%s', indicating the type of shader. Valid types are: %s."), "shader_type", _get_shader_type_list(p_shader_types)));
+			return ERR_PARSE_ERROR;
+		}
+		if (!p_shader_types.has(shader_type_identifier)) {
+			_set_error(vformat(RTR("Invalid shader type. Valid types are: %s"), _get_shader_type_list(p_shader_types)));
+			return ERR_PARSE_ERROR;
+		}
+		prev_pos = _get_tkpos();
+		tk = _get_token();
 
-	if (tk.type != TK_SEMICOLON) {
-		_set_tkpos(prev_pos);
-		_set_expected_after_error(";", "shader_type " + String(shader_type_identifier));
-		return ERR_PARSE_ERROR;
+		if (tk.type != TK_SEMICOLON) {
+			_set_tkpos(prev_pos);
+			_set_expected_after_error(";", "shader_type " + String(shader_type_identifier));
+			return ERR_PARSE_ERROR;
+		}
 	}
 
 #ifdef DEBUG_ENABLED
@@ -9470,6 +9500,97 @@ String ShaderLanguage::get_shader_type(const String &p_code) {
 	return String();
 }
 
+void ShaderLanguage::get_shader_dependencies(const String &p_code, HashSet<Ref<ShaderInclude>> *r_dependencies) {
+	bool reading_inc = false;
+	String cur_identifier;
+
+	for (int i = _get_first_ident_pos(p_code); i < p_code.length(); i++) {
+		if (p_code[i] == ';') {
+			continue;
+
+		} else if (p_code[i] <= 32) {
+			if (cur_identifier == "#include") {
+				reading_inc = true;
+				cur_identifier = String();
+			} else {
+				if (reading_inc) {
+					String path = cur_identifier;
+					if (path.begins_with("\"") && path.ends_with("\"")) {
+						path = path.substr(1, path.length() - 2);
+						if (!path.begins_with("res://")) {
+							path = path.insert(0, "res://");
+						}
+						Ref<ShaderInclude> inc = ResourceLoader::load(path);
+						if (inc.is_valid()) {
+							r_dependencies->insert(inc);
+						}
+					}
+					reading_inc = false;
+				}
+			}
+		} else {
+			cur_identifier += String::chr(p_code[i]);
+		}
+	}
+}
+
+String ShaderLanguage::get_shader_type_and_dependencies(const String &p_code, HashSet<Ref<ShaderInclude>> *r_dependencies) {
+	bool read_type = true;
+	bool reading_type = false;
+	bool reading_inc = false;
+	String type;
+
+	String cur_identifier;
+
+	for (int i = _get_first_ident_pos(p_code); i < p_code.length(); i++) {
+		if (p_code[i] == ';') {
+			continue;
+
+		} else if (p_code[i] <= 32) {
+			if (!cur_identifier.is_empty()) {
+				if (read_type) {
+					if (!reading_type) {
+						if (cur_identifier == "shader_type") {
+							reading_type = true;
+							cur_identifier = String();
+						}
+					} else {
+						type = cur_identifier;
+						read_type = false;
+						cur_identifier = String();
+					}
+				} else if (cur_identifier == "#include") {
+					reading_inc = true;
+					cur_identifier = String();
+				} else {
+					if (reading_inc) {
+						String path = cur_identifier;
+						if (path.begins_with("\"") && path.ends_with("\"")) {
+							path = path.substr(1, path.length() - 2);
+							if (!path.begins_with("res://")) {
+								path = path.insert(0, "res://");
+							}
+							Ref<ShaderInclude> inc = ResourceLoader::load(path);
+							if (inc.is_valid()) {
+								r_dependencies->insert(inc);
+							}
+						}
+						reading_inc = false;
+					}
+				}
+			}
+		} else {
+			cur_identifier += String::chr(p_code[i]);
+		}
+	}
+
+	if (reading_type) {
+		return type;
+	}
+
+	return String();
+}
+
 #ifdef DEBUG_ENABLED
 void ShaderLanguage::_check_warning_accums() {
 	for (const KeyValue<ShaderWarning::Code, HashMap<StringName, HashMap<StringName, Usage>> *> &E : warnings_check_map2) {
@@ -9509,14 +9630,21 @@ uint32_t ShaderLanguage::get_warning_flags() const {
 Error ShaderLanguage::compile(const String &p_code, const ShaderCompileInfo &p_info) {
 	clear();
 
-	code = p_code;
+	Error err = _preprocess_shader(p_code, code);
+	if (err != OK) {
+		return err;
+	}
+
+	// Clear after preprocessing. Because preprocess uses the resource loader, it means if this instance is held in a singleton, it can have a changed state after.
+	clear();
+
 	global_var_get_type_func = p_info.global_variable_type_func;
 	varying_function_names = p_info.varying_function_names;
 
 	nodes = nullptr;
 
 	shader = alloc_node<ShaderNode>();
-	Error err = _parse_shader(p_info.functions, p_info.render_modes, p_info.shader_types);
+	err = _parse_shader(p_info.functions, p_info.render_modes, p_info.shader_types, p_info.is_include);
 
 #ifdef DEBUG_ENABLED
 	if (check_warnings) {
@@ -9533,14 +9661,51 @@ Error ShaderLanguage::compile(const String &p_code, const ShaderCompileInfo &p_i
 Error ShaderLanguage::complete(const String &p_code, const ShaderCompileInfo &p_info, List<ScriptLanguage::CodeCompletionOption> *r_options, String &r_call_hint) {
 	clear();
 
-	code = p_code;
+	int preprocessor_completion_type;
+	Error error = _preprocess_shader(p_code, code, &preprocessor_completion_type);
+
+	switch (preprocessor_completion_type) {
+		case ShaderPreprocessor::COMPLETION_TYPE_DIRECTIVE: {
+			static List<String> options;
+
+			if (options.is_empty()) {
+				ShaderPreprocessor::get_keyword_list(&options, true);
+			}
+
+			for (const String &E : options) {
+				ScriptLanguage::CodeCompletionOption option(E, ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT);
+				r_options->push_back(option);
+			}
+
+			return OK;
+		} break;
+		case ShaderPreprocessor::COMPLETION_TYPE_PRAGMA: {
+			static List<String> options;
+
+			if (options.is_empty()) {
+				ShaderPreprocessor::get_pragma_list(&options);
+			}
+
+			for (const String &E : options) {
+				ScriptLanguage::CodeCompletionOption option(E, ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT);
+				r_options->push_back(option);
+			}
+
+			return OK;
+		} break;
+	}
+
+	if (error != OK) {
+		return error;
+	}
+
 	varying_function_names = p_info.varying_function_names;
 
 	nodes = nullptr;
 	global_var_get_type_func = p_info.global_variable_type_func;
 
 	shader = alloc_node<ShaderNode>();
-	_parse_shader(p_info.functions, p_info.render_modes, p_info.shader_types);
+	_parse_shader(p_info.functions, p_info.render_modes, p_info.shader_types, p_info.is_include);
 
 #ifdef DEBUG_ENABLED
 	// Adds context keywords.
diff --git a/servers/rendering/shader_language.h b/servers/rendering/shader_language.h
index 2b147fbeb1..59d679fd98 100644
--- a/servers/rendering/shader_language.h
+++ b/servers/rendering/shader_language.h
@@ -38,6 +38,7 @@
 #include "core/templates/rb_map.h"
 #include "core/typedefs.h"
 #include "core/variant/variant.h"
+#include "scene/resources/shader_include.h"
 
 #ifdef DEBUG_ENABLED
 #include "shader_warnings.h"
@@ -776,6 +777,7 @@ public:
 	static uint32_t get_datatype_size(DataType p_type);
 
 	static void get_keyword_list(List<String> *r_keywords);
+	static void get_preprocessor_keyword_list(List<String> *r_keywords, bool p_include_shader_keywords);
 	static bool is_control_flow_keyword(String p_keyword);
 	static void get_builtin_funcs(List<String> *r_keywords);
 
@@ -1070,7 +1072,8 @@ private:
 	String _get_shader_type_list(const HashSet<String> &p_shader_types) const;
 	String _get_qualifier_str(ArgumentQualifier p_qualifier) const;
 
-	Error _parse_shader(const HashMap<StringName, FunctionInfo> &p_functions, const Vector<ModeInfo> &p_render_modes, const HashSet<String> &p_shader_types);
+	Error _preprocess_shader(const String &p_code, String &r_result, int *r_completion_type = nullptr);
+	Error _parse_shader(const HashMap<StringName, FunctionInfo> &p_functions, const Vector<ModeInfo> &p_render_modes, const HashSet<String> &p_shader_types, bool p_is_include);
 
 	Error _find_last_flow_op_in_block(BlockNode *p_block, FlowOperation p_op);
 	Error _find_last_flow_op_in_op(ControlFlowNode *p_flow, FlowOperation p_op);
@@ -1091,6 +1094,8 @@ public:
 	void clear();
 
 	static String get_shader_type(const String &p_code);
+	static void get_shader_dependencies(const String &p_code, HashSet<Ref<ShaderInclude>> *r_dependencies);
+	static String get_shader_type_and_dependencies(const String &p_code, HashSet<Ref<ShaderInclude>> *r_dependencies);
 
 	struct ShaderCompileInfo {
 		HashMap<StringName, FunctionInfo> functions;
@@ -1098,6 +1103,7 @@ public:
 		VaryingFunctionNames varying_function_names = VaryingFunctionNames();
 		HashSet<String> shader_types;
 		GlobalVariableGetTypeFunc global_variable_type_func = nullptr;
+		bool is_include = false;
 	};
 
 	Error compile(const String &p_code, const ShaderCompileInfo &p_info);
diff --git a/servers/rendering/shader_preprocessor.cpp b/servers/rendering/shader_preprocessor.cpp
new file mode 100644
index 0000000000..3890c63e9f
--- /dev/null
+++ b/servers/rendering/shader_preprocessor.cpp
@@ -0,0 +1,1027 @@
+/*************************************************************************/
+/*  shader_preprocessor.cpp                                              */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#include "shader_preprocessor.h"
+#include "core/math/expression.h"
+
+const char32_t CURSOR = 0xFFFF;
+
+// Tokenizer
+
+void ShaderPreprocessor::Tokenizer::add_generated(const ShaderPreprocessor::Token &p_t) {
+	generated.push_back(p_t);
+}
+
+char32_t ShaderPreprocessor::Tokenizer::next() {
+	if (index < size) {
+		return code[index++];
+	}
+	return 0;
+}
+
+int ShaderPreprocessor::Tokenizer::get_line() const {
+	return line;
+}
+
+int ShaderPreprocessor::Tokenizer::get_index() const {
+	return index;
+}
+
+void ShaderPreprocessor::Tokenizer::get_and_clear_generated(Vector<ShaderPreprocessor::Token> *r_out) {
+	for (int i = 0; i < generated.size(); i++) {
+		r_out->push_back(generated[i]);
+	}
+	generated.clear();
+}
+
+void ShaderPreprocessor::Tokenizer::backtrack(char32_t p_what) {
+	while (index >= 0) {
+		char32_t c = code[index];
+		if (c == p_what) {
+			break;
+		}
+		index--;
+	}
+}
+
+char32_t ShaderPreprocessor::Tokenizer::peek() {
+	if (index < size) {
+		return code[index];
+	}
+	return 0;
+}
+
+LocalVector<ShaderPreprocessor::Token> ShaderPreprocessor::Tokenizer::advance(char32_t p_what) {
+	LocalVector<ShaderPreprocessor::Token> tokens;
+
+	while (index < size) {
+		char32_t c = code[index++];
+
+		tokens.push_back(ShaderPreprocessor::Token(c, line));
+
+		if (c == '\n') {
+			add_generated(ShaderPreprocessor::Token('\n', line));
+			line++;
+		}
+
+		if (c == p_what || c == 0) {
+			return tokens;
+		}
+	}
+	return LocalVector<ShaderPreprocessor::Token>();
+}
+
+void ShaderPreprocessor::Tokenizer::skip_whitespace() {
+	while (is_char_space(peek())) {
+		next();
+	}
+}
+
+String ShaderPreprocessor::Tokenizer::get_identifier(bool *r_is_cursor, bool p_started) {
+	if (r_is_cursor != nullptr) {
+		*r_is_cursor = false;
+	}
+
+	LocalVector<char32_t> text;
+
+	while (true) {
+		char32_t c = peek();
+		if (is_char_end(c) || c == '(' || c == ')' || c == ',' || c == ';') {
+			break;
+		}
+
+		if (is_whitespace(c) && p_started) {
+			break;
+		}
+		if (!is_whitespace(c)) {
+			p_started = true;
+		}
+
+		char32_t n = next();
+		if (n == CURSOR) {
+			if (r_is_cursor != nullptr) {
+				*r_is_cursor = true;
+			}
+		} else {
+			if (p_started) {
+				text.push_back(n);
+			}
+		}
+	}
+
+	String id = vector_to_string(text);
+	if (!id.is_valid_identifier()) {
+		return "";
+	}
+
+	return id;
+}
+
+String ShaderPreprocessor::Tokenizer::peek_identifier() {
+	const int original = index;
+	String id = get_identifier();
+	index = original;
+	return id;
+}
+
+ShaderPreprocessor::Token ShaderPreprocessor::Tokenizer::get_token() {
+	while (index < size) {
+		const char32_t c = code[index++];
+		const Token t = ShaderPreprocessor::Token(c, line);
+
+		switch (c) {
+			case ' ':
+			case '\t':
+				skip_whitespace();
+				return ShaderPreprocessor::Token(' ', line);
+			case '\n':
+				line++;
+				return t;
+			default:
+				return t;
+		}
+	}
+	return ShaderPreprocessor::Token(char32_t(0), line);
+}
+
+ShaderPreprocessor::Tokenizer::Tokenizer(const String &p_code) {
+	code = p_code;
+	line = 0;
+	index = 0;
+	size = code.size();
+}
+
+// ShaderPreprocessor::CommentRemover
+
+String ShaderPreprocessor::CommentRemover::get_error() const {
+	if (comments_open != 0) {
+		return "Block comment mismatch";
+	}
+	return "";
+}
+
+int ShaderPreprocessor::CommentRemover::get_error_line() const {
+	if (comments_open != 0) {
+		return comment_line_open;
+	}
+	return -1;
+}
+
+char32_t ShaderPreprocessor::CommentRemover::peek() const {
+	if (index < code.size()) {
+		return code[index];
+	}
+	return 0;
+}
+
+bool ShaderPreprocessor::CommentRemover::advance(char32_t p_what) {
+	while (index < code.size()) {
+		char32_t c = code[index++];
+
+		if (c == '\n') {
+			line++;
+			stripped.push_back('\n');
+		}
+
+		if (c == p_what) {
+			return true;
+		}
+	}
+	return false;
+}
+
+String ShaderPreprocessor::CommentRemover::strip() {
+	stripped.clear();
+	index = 0;
+	line = 0;
+	comment_line_open = 0;
+	comments_open = 0;
+	strings_open = 0;
+
+	while (index < code.size()) {
+		char32_t c = code[index++];
+
+		if (c == CURSOR) {
+			// Cursor. Maintain.
+			stripped.push_back(c);
+		} else if (c == '"') {
+			if (strings_open <= 0) {
+				strings_open++;
+			} else {
+				strings_open--;
+			}
+			stripped.push_back(c);
+		} else if (c == '/' && strings_open == 0) {
+			char32_t p = peek();
+			if (p == '/') { // Single line comment.
+				advance('\n');
+			} else if (p == '*') { // Start of a block comment.
+				index++;
+				comment_line_open = line;
+				comments_open++;
+				while (advance('*')) {
+					if (peek() == '/') { // End of a block comment.
+						comments_open--;
+						index++;
+						break;
+					}
+				}
+			} else {
+				stripped.push_back(c);
+			}
+		} else if (c == '*' && strings_open == 0) {
+			if (peek() == '/') { // Unmatched end of a block comment.
+				comment_line_open = line;
+				comments_open--;
+			} else {
+				stripped.push_back(c);
+			}
+		} else if (c == '\n') {
+			line++;
+			stripped.push_back(c);
+		} else {
+			stripped.push_back(c);
+		}
+	}
+	return vector_to_string(stripped);
+}
+
+ShaderPreprocessor::CommentRemover::CommentRemover(const String &p_code) {
+	code = p_code;
+	index = 0;
+	line = 0;
+	comment_line_open = 0;
+	comments_open = 0;
+	strings_open = 0;
+}
+
+// ShaderPreprocessor::Token
+
+ShaderPreprocessor::Token::Token() {
+	text = 0;
+	line = -1;
+}
+
+ShaderPreprocessor::Token::Token(char32_t p_text, int p_line) {
+	text = p_text;
+	line = p_line;
+}
+
+// ShaderPreprocessor
+
+bool ShaderPreprocessor::is_char_word(char32_t p_char) {
+	if ((p_char >= '0' && p_char <= '9') ||
+			(p_char >= 'a' && p_char <= 'z') ||
+			(p_char >= 'A' && p_char <= 'Z') ||
+			p_char == '_') {
+		return true;
+	}
+
+	return false;
+}
+
+bool ShaderPreprocessor::is_char_space(char32_t p_char) {
+	return p_char == ' ' || p_char == '\t';
+}
+
+bool ShaderPreprocessor::is_char_end(char32_t p_char) {
+	return p_char == '\n' || p_char == 0;
+}
+
+String ShaderPreprocessor::vector_to_string(const LocalVector<char32_t> &p_v, int p_start, int p_end) {
+	const int stop = (p_end == -1) ? p_v.size() : p_end;
+	const int count = stop - p_start;
+
+	String result;
+	result.resize(count + 1);
+	for (int i = 0; i < count; i++) {
+		result[i] = p_v[p_start + i];
+	}
+	result[count] = 0; // Ensure string is null terminated for length() to work.
+	return result;
+}
+
+String ShaderPreprocessor::tokens_to_string(const LocalVector<Token> &p_tokens) {
+	LocalVector<char32_t> result;
+	for (uint32_t i = 0; i < p_tokens.size(); i++) {
+		result.push_back(p_tokens[i].text);
+	}
+	return vector_to_string(result);
+}
+
+void ShaderPreprocessor::process_directive(Tokenizer *p_tokenizer) {
+	bool is_cursor;
+	String directive = p_tokenizer->get_identifier(&is_cursor, true);
+	if (is_cursor) {
+		state->completion_type = COMPLETION_TYPE_DIRECTIVE;
+	}
+
+	if (directive == "if") {
+		if (check_directive_before_type(p_tokenizer, directive)) {
+			process_if(p_tokenizer);
+		}
+	} else if (directive == "ifdef") {
+		if (check_directive_before_type(p_tokenizer, directive)) {
+			process_ifdef(p_tokenizer);
+		}
+	} else if (directive == "ifndef") {
+		if (check_directive_before_type(p_tokenizer, directive)) {
+			process_ifndef(p_tokenizer);
+		}
+	} else if (directive == "else") {
+		if (check_directive_before_type(p_tokenizer, directive)) {
+			process_else(p_tokenizer);
+		}
+	} else if (directive == "endif") {
+		if (check_directive_before_type(p_tokenizer, directive)) {
+			process_endif(p_tokenizer);
+		}
+	} else if (directive == "define") {
+		if (check_directive_before_type(p_tokenizer, directive)) {
+			process_define(p_tokenizer);
+		}
+	} else if (directive == "undef") {
+		if (check_directive_before_type(p_tokenizer, directive)) {
+			process_undef(p_tokenizer);
+		}
+	} else if (directive == "include") {
+		if (check_directive_before_type(p_tokenizer, directive)) {
+			process_include(p_tokenizer);
+		}
+	} else if (directive == "pragma") {
+		if (check_directive_before_type(p_tokenizer, directive)) {
+			process_pragma(p_tokenizer);
+		}
+	} else {
+		set_error(RTR("Unknown directive."), p_tokenizer->get_line());
+	}
+}
+
+void ShaderPreprocessor::process_define(Tokenizer *p_tokenizer) {
+	const int line = p_tokenizer->get_line();
+
+	String label = p_tokenizer->get_identifier();
+	if (label.is_empty()) {
+		set_error(RTR("Invalid macro name."), line);
+		return;
+	}
+
+	if (state->defines.has(label)) {
+		set_error(RTR("Macro redefinition."), line);
+		return;
+	}
+
+	if (p_tokenizer->peek() == '(') {
+		// Macro has arguments.
+		p_tokenizer->get_token();
+
+		Vector<String> args;
+		while (true) {
+			String name = p_tokenizer->get_identifier();
+			if (name.is_empty()) {
+				set_error(RTR("Invalid argument name."), line);
+				return;
+			}
+			args.push_back(name);
+
+			p_tokenizer->skip_whitespace();
+			char32_t next = p_tokenizer->get_token().text;
+			if (next == ')') {
+				break;
+			} else if (next != ',') {
+				set_error(RTR("Expected a comma in the macro argument list."), line);
+				return;
+			}
+		}
+
+		Define *define = memnew(Define);
+		define->arguments = args;
+		define->body = tokens_to_string(p_tokenizer->advance('\n')).strip_edges();
+		state->defines[label] = define;
+	} else {
+		// Simple substitution macro.
+		Define *define = memnew(Define);
+		define->body = tokens_to_string(p_tokenizer->advance('\n')).strip_edges();
+		state->defines[label] = define;
+	}
+}
+
+void ShaderPreprocessor::process_else(Tokenizer *p_tokenizer) {
+	if (state->skip_stack_else.is_empty()) {
+		set_error(RTR("Unmatched else."), p_tokenizer->get_line());
+		return;
+	}
+	p_tokenizer->advance('\n');
+
+	bool skip = state->skip_stack_else[state->skip_stack_else.size() - 1];
+	state->skip_stack_else.remove_at(state->skip_stack_else.size() - 1);
+
+	Vector<SkippedCondition *> vec = state->skipped_conditions[state->current_include];
+	int index = vec.size() - 1;
+	if (index >= 0) {
+		SkippedCondition *cond = vec[index];
+		if (cond->end_line == -1) {
+			cond->end_line = p_tokenizer->get_line();
+		}
+	}
+
+	if (skip) {
+		Vector<String> ends;
+		ends.push_back("endif");
+		next_directive(p_tokenizer, ends);
+	}
+}
+
+void ShaderPreprocessor::process_endif(Tokenizer *p_tokenizer) {
+	state->condition_depth--;
+	if (state->condition_depth < 0) {
+		set_error(RTR("Unmatched endif."), p_tokenizer->get_line());
+		return;
+	}
+
+	Vector<SkippedCondition *> vec = state->skipped_conditions[state->current_include];
+	int index = vec.size() - 1;
+	if (index >= 0) {
+		SkippedCondition *cond = vec[index];
+		if (cond->end_line == -1) {
+			cond->end_line = p_tokenizer->get_line();
+		}
+	}
+
+	p_tokenizer->advance('\n');
+}
+
+void ShaderPreprocessor::process_if(Tokenizer *p_tokenizer) {
+	int line = p_tokenizer->get_line();
+
+	String body = tokens_to_string(p_tokenizer->advance('\n')).strip_edges();
+	if (body.is_empty()) {
+		set_error(RTR("Missing condition."), line);
+		return;
+	}
+
+	Error error = expand_macros(body, line, body);
+	if (error != OK) {
+		return;
+	}
+
+	Expression expression;
+	Vector<String> names;
+	error = expression.parse(body, names);
+	if (error != OK) {
+		set_error(expression.get_error_text(), line);
+		return;
+	}
+
+	Variant v = expression.execute(Array(), nullptr, false);
+	if (v.get_type() == Variant::NIL) {
+		set_error(RTR("Condition evaluation error."), line);
+		return;
+	}
+
+	bool success = v.booleanize();
+	start_branch_condition(p_tokenizer, success);
+}
+
+void ShaderPreprocessor::process_ifdef(Tokenizer *p_tokenizer) {
+	const int line = p_tokenizer->get_line();
+
+	String label = p_tokenizer->get_identifier();
+	if (label.is_empty()) {
+		set_error(RTR("Invalid macro name."), line);
+		return;
+	}
+
+	p_tokenizer->skip_whitespace();
+	if (!is_char_end(p_tokenizer->peek())) {
+		set_error(RTR("Invalid ifdef."), line);
+		return;
+	}
+	p_tokenizer->advance('\n');
+
+	bool success = state->defines.has(label);
+	start_branch_condition(p_tokenizer, success);
+}
+
+void ShaderPreprocessor::process_ifndef(Tokenizer *p_tokenizer) {
+	const int line = p_tokenizer->get_line();
+
+	String label = p_tokenizer->get_identifier();
+	if (label.is_empty()) {
+		set_error(RTR("Invalid macro name."), line);
+		return;
+	}
+
+	p_tokenizer->skip_whitespace();
+	if (!is_char_end(p_tokenizer->peek())) {
+		set_error(RTR("Invalid ifndef."), line);
+		return;
+	}
+	p_tokenizer->advance('\n');
+
+	bool success = !state->defines.has(label);
+	start_branch_condition(p_tokenizer, success);
+}
+
+void ShaderPreprocessor::process_include(Tokenizer *p_tokenizer) {
+	const int line = p_tokenizer->get_line();
+
+	p_tokenizer->advance('"');
+	String path = tokens_to_string(p_tokenizer->advance('"'));
+	path = path.substr(0, path.length() - 1);
+	p_tokenizer->skip_whitespace();
+
+	if (path.is_empty() || !is_char_end(p_tokenizer->peek())) {
+		set_error(RTR("Invalid path."), line);
+		return;
+	}
+
+	Ref<Resource> res = ResourceLoader::load(path);
+	if (res.is_null()) {
+		set_error(RTR("Shader include load failed. Does the shader include exist? Is there a cyclic dependency?"), line);
+		return;
+	}
+
+	Ref<ShaderInclude> shader_inc = Object::cast_to<ShaderInclude>(*res);
+	if (shader_inc.is_null()) {
+		set_error(RTR("Shader include resource type is wrong."), line);
+		return;
+	}
+
+	String included = shader_inc->get_code();
+	if (!included.is_empty()) {
+		uint64_t code_hash = included.hash64();
+		if (state->cyclic_include_hashes.find(code_hash)) {
+			set_error(RTR("Cyclic include found."), line);
+			return;
+		}
+	}
+
+	const String real_path = shader_inc->get_path();
+	if (state->includes.has(real_path)) {
+		// Already included, skip.
+		// This is a valid check because 2 separate include paths could use some
+		// of the same shared functions from a common shader include.
+		return;
+	}
+
+	// Mark as included.
+	state->includes.insert(real_path);
+
+	state->include_depth++;
+	if (state->include_depth > 25) {
+		set_error(RTR("Shader max include depth exceeded."), line);
+		return;
+	}
+
+	String old_include = state->current_include;
+	state->current_include = real_path;
+	ShaderPreprocessor processor(included);
+
+	int prev_condition_depth = state->condition_depth;
+	state->condition_depth = 0;
+
+	String result;
+	processor.preprocess(state, result);
+	add_to_output(result);
+
+	// Reset to last include if there are no errors. We want to use this as context.
+	if (state->error.is_empty()) {
+		state->current_include = old_include;
+	} else {
+		return;
+	}
+
+	state->include_depth--;
+	state->condition_depth = prev_condition_depth;
+}
+
+void ShaderPreprocessor::process_pragma(Tokenizer *p_tokenizer) {
+	const int line = p_tokenizer->get_line();
+
+	bool is_cursor;
+	const String label = p_tokenizer->get_identifier(&is_cursor);
+	if (is_cursor) {
+		state->completion_type = COMPLETION_TYPE_PRAGMA;
+	}
+
+	if (label.is_empty()) {
+		set_error(RTR("Invalid pragma directive."), line);
+		return;
+	}
+
+	// Rxplicitly handle pragma values here.
+	// If more pragma options are created, then refactor into a more defined structure.
+	if (label == "disable_preprocessor") {
+		state->disabled = true;
+	} else {
+		set_error(RTR("Invalid pragma directive."), line);
+		return;
+	}
+
+	p_tokenizer->advance('\n');
+}
+
+void ShaderPreprocessor::process_undef(Tokenizer *p_tokenizer) {
+	const int line = p_tokenizer->get_line();
+	const String label = p_tokenizer->get_identifier();
+	if (label.is_empty() || !state->defines.has(label)) {
+		set_error(RTR("Invalid name."), line);
+		return;
+	}
+
+	p_tokenizer->skip_whitespace();
+	if (!is_char_end(p_tokenizer->peek())) {
+		set_error(RTR("Invalid undef."), line);
+		return;
+	}
+
+	memdelete(state->defines[label]);
+	state->defines.erase(label);
+}
+
+void ShaderPreprocessor::start_branch_condition(Tokenizer *p_tokenizer, bool p_success) {
+	state->condition_depth++;
+
+	if (p_success) {
+		state->skip_stack_else.push_back(true);
+	} else {
+		SkippedCondition *cond = memnew(SkippedCondition());
+		cond->start_line = p_tokenizer->get_line();
+		state->skipped_conditions[state->current_include].push_back(cond);
+
+		Vector<String> ends;
+		ends.push_back("else");
+		ends.push_back("endif");
+		if (next_directive(p_tokenizer, ends) == "else") {
+			state->skip_stack_else.push_back(false);
+		} else {
+			state->skip_stack_else.push_back(true);
+		}
+	}
+}
+
+void ShaderPreprocessor::expand_output_macros(int p_start, int p_line_number) {
+	String line = vector_to_string(output, p_start, output.size());
+
+	Error error = expand_macros(line, p_line_number - 1, line); // We are already on next line, so -1.
+	if (error != OK) {
+		return;
+	}
+
+	output.resize(p_start);
+
+	add_to_output(line);
+}
+
+Error ShaderPreprocessor::expand_macros(const String &p_string, int p_line, String &r_expanded) {
+	Vector<Pair<String, Define *>> active_defines;
+	active_defines.resize(state->defines.size());
+	int index = 0;
+	for (const RBMap<String, Define *>::Element *E = state->defines.front(); E; E = E->next()) {
+		active_defines.set(index++, Pair<String, Define *>(E->key(), E->get()));
+	}
+
+	return expand_macros(p_string, p_line, active_defines, r_expanded);
+}
+
+Error ShaderPreprocessor::expand_macros(const String &p_string, int p_line, Vector<Pair<String, Define *>> p_defines, String &r_expanded) {
+	r_expanded = p_string;
+	// When expanding macros we must only evaluate them once.
+	// Later we continue expanding but with the already
+	// evaluated macros removed.
+	for (int i = 0; i < p_defines.size(); i++) {
+		Pair<String, Define *> define_pair = p_defines[i];
+
+		Error error = expand_macros_once(r_expanded, p_line, define_pair, r_expanded);
+		if (error != OK) {
+			return error;
+		}
+
+		// Remove expanded macro and recursively replace remaining.
+		p_defines.remove_at(i);
+		return expand_macros(r_expanded, p_line, p_defines, r_expanded);
+	}
+
+	return OK;
+}
+
+Error ShaderPreprocessor::expand_macros_once(const String &p_line, int p_line_number, Pair<String, Define *> p_define_pair, String &r_expanded) {
+	String result = p_line;
+
+	const String &key = p_define_pair.first;
+	const Define *define = p_define_pair.second;
+
+	int index_start = 0;
+	int index = 0;
+	while (find_match(result, key, index, index_start)) {
+		String body = define->body;
+		if (define->arguments.size() > 0) {
+			// Complex macro with arguments.
+			int args_start = index + key.length();
+			int args_end = p_line.find(")", args_start);
+			if (args_start == -1 || args_end == -1) {
+				set_error(RTR("Missing macro argument parenthesis."), p_line_number);
+				return FAILED;
+			}
+
+			String values = result.substr(args_start + 1, args_end - (args_start + 1));
+			Vector<String> args = values.split(",");
+			if (args.size() != define->arguments.size()) {
+				set_error(RTR("Invalid macro argument count."), p_line_number);
+				return FAILED;
+			}
+
+			// Insert macro arguments into the body.
+			for (int i = 0; i < args.size(); i++) {
+				String arg_name = define->arguments[i];
+				int arg_index_start = 0;
+				int arg_index = 0;
+				while (find_match(body, arg_name, arg_index, arg_index_start)) {
+					body = body.substr(0, arg_index) + args[i] + body.substr(arg_index + arg_name.length(), body.length() - (arg_index + arg_name.length()));
+					// Manually reset arg_index_start to where the arg value of the define finishes.
+					// This ensures we don't skip the other args of this macro in the string.
+					arg_index_start = arg_index + args[i].length() + 1;
+				}
+			}
+
+			result = result.substr(0, index) + " " + body + " " + result.substr(args_end + 1, result.length());
+		} else {
+			result = result.substr(0, index) + body + result.substr(index + key.length(), result.length() - (index + key.length()));
+			// Manually reset index_start to where the body value of the define finishes.
+			// This ensures we don't skip another instance of this macro in the string.
+			index_start = index + body.length() + 1;
+			break;
+		}
+	}
+	r_expanded = result;
+	return OK;
+}
+
+bool ShaderPreprocessor::find_match(const String &p_string, const String &p_value, int &r_index, int &r_index_start) {
+	// Looks for value in string and then determines if the boundaries
+	// are non-word characters. This method semi-emulates \b in regex.
+	r_index = p_string.find(p_value, r_index_start);
+	while (r_index > -1) {
+		if (r_index > 0) {
+			if (is_char_word(p_string[r_index - 1])) {
+				r_index_start = r_index + 1;
+				r_index = p_string.find(p_value, r_index_start);
+				continue;
+			}
+		}
+
+		if (r_index + p_value.length() < p_string.length()) {
+			if (is_char_word(p_string[r_index + p_value.length()])) {
+				r_index_start = r_index + p_value.length() + 1;
+				r_index = p_string.find(p_value, r_index_start);
+				continue;
+			}
+		}
+
+		// Return and shift index start automatically for next call.
+		r_index_start = r_index + p_value.length() + 1;
+		return true;
+	}
+
+	return false;
+}
+
+String ShaderPreprocessor::next_directive(Tokenizer *p_tokenizer, const Vector<String> &p_directives) {
+	const int line = p_tokenizer->get_line();
+	int nesting = 0;
+
+	while (true) {
+		p_tokenizer->advance('#');
+
+		String id = p_tokenizer->peek_identifier();
+		if (id.is_empty()) {
+			break;
+		}
+
+		if (nesting == 0) {
+			for (int i = 0; i < p_directives.size(); i++) {
+				if (p_directives[i] == id) {
+					p_tokenizer->backtrack('#');
+					return id;
+				}
+			}
+		}
+
+		if (id == "ifdef" || id == "ifndef" || id == "if") {
+			nesting++;
+		} else if (id == "endif") {
+			nesting--;
+		}
+	}
+
+	set_error(RTR("Can't find matching branch directive."), line);
+	return "";
+}
+
+void ShaderPreprocessor::add_to_output(const String &p_str) {
+	for (int i = 0; i < p_str.length(); i++) {
+		output.push_back(p_str[i]);
+	}
+}
+
+void ShaderPreprocessor::set_error(const String &p_error, int p_line) {
+	if (state->error.is_empty()) {
+		state->error = p_error;
+		state->error_line = p_line + 1;
+	}
+}
+
+bool ShaderPreprocessor::check_directive_before_type(Tokenizer *p_tokenizer, const String &p_directive) {
+	if (p_tokenizer->get_index() < state->shader_type_pos) {
+		set_error(vformat(RTR("`#%s` may not be defined before `shader_type`."), p_directive), p_tokenizer->get_line());
+		return false;
+	}
+	return true;
+}
+
+ShaderPreprocessor::State *ShaderPreprocessor::create_state() {
+	State *new_state = memnew(State);
+
+	String platform = OS::get_singleton()->get_name().replace(" ", "_").to_upper();
+	new_state->defines[platform] = create_define("true");
+
+	Engine *engine = Engine::get_singleton();
+	new_state->defines["EDITOR"] = create_define(engine->is_editor_hint() ? "true" : "false");
+
+	return new_state;
+}
+
+ShaderPreprocessor::Define *ShaderPreprocessor::create_define(const String &p_body) {
+	ShaderPreprocessor::Define *define = memnew(Define);
+	define->body = p_body;
+	return define;
+}
+
+void ShaderPreprocessor::clear() {
+	if (state_owner && state != nullptr) {
+		for (const RBMap<String, Define *>::Element *E = state->defines.front(); E; E = E->next()) {
+			memdelete(E->get());
+		}
+
+		for (const RBMap<String, Vector<SkippedCondition *>>::Element *E = state->skipped_conditions.front(); E; E = E->next()) {
+			for (SkippedCondition *condition : E->get()) {
+				memdelete(condition);
+			}
+		}
+
+		memdelete(state);
+	}
+	state_owner = false;
+	state = nullptr;
+}
+
+Error ShaderPreprocessor::preprocess(State *p_state, String &r_result) {
+	clear();
+
+	output.clear();
+
+	state = p_state;
+	if (state == nullptr) {
+		state = create_state();
+		state_owner = true;
+	}
+
+	CommentRemover remover(code);
+	String stripped = remover.strip();
+	String error = remover.get_error();
+	if (!error.is_empty()) {
+		set_error(error, remover.get_error_line());
+		return FAILED;
+	}
+
+	// Track code hashes to prevent cyclic include.
+	uint64_t code_hash = code.hash64();
+	state->cyclic_include_hashes.push_back(code_hash);
+
+	Tokenizer p_tokenizer(stripped);
+	int last_size = 0;
+	bool has_symbols_before_directive = false;
+
+	while (true) {
+		const Token &t = p_tokenizer.get_token();
+
+		if (t.text == 0) {
+			break;
+		}
+
+		if (state->disabled) {
+			// Preprocessor was disabled.
+			// Read the rest of the file into the output.
+			output.push_back(t.text);
+			continue;
+		} else {
+			// Add autogenerated tokens.
+			Vector<Token> generated;
+			p_tokenizer.get_and_clear_generated(&generated);
+			for (int i = 0; i < generated.size(); i++) {
+				output.push_back(generated[i].text);
+			}
+		}
+
+		if (t.text == '#') {
+			if (has_symbols_before_directive) {
+				set_error(RTR("Invalid symbols placed before directive."), p_tokenizer.get_line());
+				state->cyclic_include_hashes.erase(code_hash); // Remove this hash.
+				return FAILED;
+			}
+			process_directive(&p_tokenizer);
+		} else {
+			if (is_char_end(t.text)) {
+				expand_output_macros(last_size, p_tokenizer.get_line());
+				last_size = output.size();
+				has_symbols_before_directive = false;
+			} else if (!is_char_space(t.text)) {
+				has_symbols_before_directive = true;
+			}
+			output.push_back(t.text);
+		}
+
+		if (!state->error.is_empty()) {
+			state->cyclic_include_hashes.erase(code_hash); // Remove this hash.
+			return FAILED;
+		}
+	}
+	state->cyclic_include_hashes.erase(code_hash); // Remove this hash.
+
+	if (!state->disabled) {
+		if (state->condition_depth != 0) {
+			set_error(RTR("Unmatched conditional statement."), p_tokenizer.line);
+			return FAILED;
+		}
+
+		expand_output_macros(last_size, p_tokenizer.get_line());
+	}
+
+	r_result = vector_to_string(output);
+
+	return OK;
+}
+
+Error ShaderPreprocessor::preprocess(String &r_result) {
+	return preprocess(nullptr, r_result);
+}
+
+ShaderPreprocessor::State *ShaderPreprocessor::get_state() {
+	return state;
+}
+
+void ShaderPreprocessor::get_keyword_list(List<String> *r_keywords, bool p_include_shader_keywords) {
+	r_keywords->push_back("define");
+	if (p_include_shader_keywords) {
+		r_keywords->push_back("else");
+	}
+	r_keywords->push_back("endif");
+	if (p_include_shader_keywords) {
+		r_keywords->push_back("if");
+	}
+	r_keywords->push_back("ifdef");
+	r_keywords->push_back("ifndef");
+	r_keywords->push_back("include");
+	r_keywords->push_back("pragma");
+	r_keywords->push_back("undef");
+}
+
+void ShaderPreprocessor::get_pragma_list(List<String> *r_pragmas) {
+	r_pragmas->push_back("disable_preprocessor");
+}
+
+ShaderPreprocessor::ShaderPreprocessor(const String &p_code) :
+		code(p_code) {
+}
+
+ShaderPreprocessor::~ShaderPreprocessor() {
+	clear();
+}
diff --git a/servers/rendering/shader_preprocessor.h b/servers/rendering/shader_preprocessor.h
new file mode 100644
index 0000000000..1cbab8e36f
--- /dev/null
+++ b/servers/rendering/shader_preprocessor.h
@@ -0,0 +1,196 @@
+/*************************************************************************/
+/*  shader_preprocessor.h                                                */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifndef SHADER_PREPROCESSOR_H
+#define SHADER_PREPROCESSOR_H
+
+#include "core/string/ustring.h"
+#include "core/templates/list.h"
+#include "core/templates/local_vector.h"
+#include "core/templates/rb_map.h"
+#include "core/templates/rb_set.h"
+#include "core/typedefs.h"
+
+#include "core/io/resource_loader.h"
+#include "core/os/os.h"
+#include "scene/resources/shader.h"
+#include "scene/resources/shader_include.h"
+
+class ShaderPreprocessor {
+private:
+	struct Token {
+		char32_t text;
+		int line;
+
+		Token();
+		Token(char32_t p_text, int p_line);
+	};
+
+	// The real preprocessor that understands basic shader and preprocessor language syntax.
+	class Tokenizer {
+	public:
+		String code;
+		int line;
+		int index;
+		int size;
+		Vector<Token> generated;
+
+	private:
+		void add_generated(const Token &p_t);
+		char32_t next();
+
+	public:
+		int get_line() const;
+		int get_index() const;
+		char32_t peek();
+
+		void get_and_clear_generated(Vector<Token> *r_out);
+		void backtrack(char32_t p_what);
+		LocalVector<Token> advance(char32_t p_what);
+		void skip_whitespace();
+		String get_identifier(bool *r_is_cursor = nullptr, bool p_started = false);
+		String peek_identifier();
+		Token get_token();
+
+		Tokenizer(const String &p_code);
+	};
+
+	class CommentRemover {
+	private:
+		LocalVector<char32_t> stripped;
+		String code;
+		int index;
+		int line;
+		int comment_line_open;
+		int comments_open;
+		int strings_open;
+
+	public:
+		String get_error() const;
+		int get_error_line() const;
+		char32_t peek() const;
+
+		bool advance(char32_t p_what);
+		String strip();
+
+		CommentRemover(const String &p_code);
+	};
+
+	struct Define {
+		Vector<String> arguments;
+		String body;
+	};
+
+	struct SkippedCondition {
+		int start_line = -1;
+		int end_line = -1;
+	};
+
+public:
+	enum CompletionType {
+		COMPLETION_TYPE_NONE,
+		COMPLETION_TYPE_DIRECTIVE,
+		COMPLETION_TYPE_PRAGMA_DIRECTIVE,
+		COMPLETION_TYPE_PRAGMA,
+	};
+
+	struct State {
+		RBMap<String, Define *> defines;
+		Vector<bool> skip_stack_else;
+		int condition_depth = 0;
+		RBSet<String> includes;
+		List<uint64_t> cyclic_include_hashes; // Holds code hash of includes.
+		int include_depth = 0;
+		String current_include;
+		String current_shader_type;
+		int shader_type_pos = -1;
+		String error;
+		int error_line = -1;
+		RBMap<String, Vector<SkippedCondition *>> skipped_conditions;
+		bool disabled = false;
+		CompletionType completion_type = COMPLETION_TYPE_NONE;
+	};
+
+private:
+	String code;
+	LocalVector<char32_t> output;
+	State *state = nullptr;
+	bool state_owner = false;
+
+private:
+	static bool is_char_word(char32_t p_char);
+	static bool is_char_space(char32_t p_char);
+	static bool is_char_end(char32_t p_char);
+	static String vector_to_string(const LocalVector<char32_t> &p_v, int p_start = 0, int p_end = -1);
+	static String tokens_to_string(const LocalVector<Token> &p_tokens);
+
+	void process_directive(Tokenizer *p_tokenizer);
+	void process_define(Tokenizer *p_tokenizer);
+	void process_else(Tokenizer *p_tokenizer);
+	void process_endif(Tokenizer *p_tokenizer);
+	void process_if(Tokenizer *p_tokenizer);
+	void process_ifdef(Tokenizer *p_tokenizer);
+	void process_ifndef(Tokenizer *p_tokenizer);
+	void process_include(Tokenizer *p_tokenizer);
+	void process_pragma(Tokenizer *p_tokenizer);
+	void process_undef(Tokenizer *p_tokenizer);
+
+	void start_branch_condition(Tokenizer *p_tokenizer, bool p_success);
+
+	void expand_output_macros(int p_start, int p_line);
+	Error expand_macros(const String &p_string, int p_line, String &r_result);
+	Error expand_macros(const String &p_string, int p_line, Vector<Pair<String, Define *>> p_defines, String &r_result);
+	Error expand_macros_once(const String &p_line, int p_line_number, Pair<String, Define *> p_define_pair, String &r_expanded);
+	bool find_match(const String &p_string, const String &p_value, int &r_index, int &r_index_start);
+
+	String next_directive(Tokenizer *p_tokenizer, const Vector<String> &p_directives);
+	void add_to_output(const String &p_str);
+	void set_error(const String &p_error, int p_line);
+	bool check_directive_before_type(Tokenizer *p_tokenizer, const String &p_directive);
+
+	static State *create_state();
+	static Define *create_define(const String &p_body);
+
+	void clear();
+
+public:
+	Error preprocess(State *p_state, String &r_result);
+	Error preprocess(String &r_result);
+
+	State *get_state();
+
+	static void get_keyword_list(List<String> *r_keywords, bool p_include_shader_keywords = false);
+	static void get_pragma_list(List<String> *r_pragmas);
+
+	ShaderPreprocessor(const String &p_code);
+	~ShaderPreprocessor();
+};
+
+#endif // SHADER_PREPROCESSOR_H