Exposed RenderingDevice to script API

Also added an easier way to load native GLSL shaders.

Extras:

Had to fix no-cache for subresources in resource loader, it was not properly working, making shaders not properly reload.

Note:

The precommit hooks are broken because they don't seem to support enums from one class being used in another.
Feel free to fix this after merging this PR.

5 files changed, 491 insertions, 0 deletions

diff --git a/editor/editor_node.cpp b/editor/editor_node.cpp
index 849908c132..3569cd411d 100644
--- a/editor/editor_node.cpp
+++ b/editor/editor_node.cpp
@@ -98,6 +98,7 @@
 #include "editor/import/resource_importer_layered_texture.h"
 #include "editor/import/resource_importer_obj.h"
 #include "editor/import/resource_importer_scene.h"
+#include "editor/import/resource_importer_shader_file.h"
 #include "editor/import/resource_importer_texture.h"
 #include "editor/import/resource_importer_texture_atlas.h"
 #include "editor/import/resource_importer_wav.h"
@@ -148,6 +149,7 @@
 #include "editor/plugins/script_editor_plugin.h"
 #include "editor/plugins/script_text_editor.h"
 #include "editor/plugins/shader_editor_plugin.h"
+#include "editor/plugins/shader_file_editor_plugin.h"
 #include "editor/plugins/skeleton_2d_editor_plugin.h"
 #include "editor/plugins/skeleton_3d_editor_plugin.h"
 #include "editor/plugins/skeleton_ik_3d_editor_plugin.h"
@@ -5716,6 +5718,10 @@ EditorNode::EditorNode() {
 		import_obj.instance();
 		ResourceFormatImporter::get_singleton()->add_importer(import_obj);
 
+		Ref<ResourceImporterShaderFile> import_shader_file;
+		import_shader_file.instance();
+		ResourceFormatImporter::get_singleton()->add_importer(import_shader_file);
+
 		Ref<ResourceImporterScene> import_scene;
 		import_scene.instance();
 		ResourceFormatImporter::get_singleton()->add_importer(import_scene);
@@ -6633,6 +6639,7 @@ EditorNode::EditorNode() {
 
 	add_editor_plugin(VersionControlEditorPlugin::get_singleton());
 	add_editor_plugin(memnew(ShaderEditorPlugin(this)));
+	add_editor_plugin(memnew(ShaderFileEditorPlugin(this)));
 	add_editor_plugin(memnew(VisualShaderEditorPlugin(this)));
 
 	add_editor_plugin(memnew(Camera3DEditorPlugin(this)));
diff --git a/editor/import/resource_importer_shader_file.cpp b/editor/import/resource_importer_shader_file.cpp
new file mode 100644
index 0000000000..a2f178de12
--- /dev/null
+++ b/editor/import/resource_importer_shader_file.cpp
@@ -0,0 +1,90 @@
+#include "resource_importer_shader_file.h"
+
+#include "core/io/marshalls.h"
+#include "core/io/resource_saver.h"
+#include "core/os/file_access.h"
+#include "editor/editor_node.h"
+#include "editor/plugins/shader_file_editor_plugin.h"
+#include "servers/rendering/rendering_device_binds.h"
+
+String ResourceImporterShaderFile::get_importer_name() const {
+
+	return "glsl";
+}
+
+String ResourceImporterShaderFile::get_visible_name() const {
+
+	return "GLSL Shader File";
+}
+void ResourceImporterShaderFile::get_recognized_extensions(List<String> *p_extensions) const {
+
+	p_extensions->push_back("glsl");
+}
+String ResourceImporterShaderFile::get_save_extension() const {
+	return "res";
+}
+
+String ResourceImporterShaderFile::get_resource_type() const {
+
+	return "RDShaderFile";
+}
+
+int ResourceImporterShaderFile::get_preset_count() const {
+	return 0;
+}
+String ResourceImporterShaderFile::get_preset_name(int p_idx) const {
+
+	return String();
+}
+
+void ResourceImporterShaderFile::get_import_options(List<ImportOption> *r_options, int p_preset) const {
+}
+
+bool ResourceImporterShaderFile::get_option_visibility(const String &p_option, const Map<StringName, Variant> &p_options) const {
+	return true;
+}
+static String _include_function(const String &p_path, void *userpointer) {
+	Error err;
+
+	String *base_path = (String *)userpointer;
+
+	String include = p_path;
+	if (include.is_rel_path()) {
+		include = base_path->plus_file(include);
+	}
+
+	FileAccessRef file_inc = FileAccess::open(include, FileAccess::READ, &err);
+	if (err != OK) {
+		return String();
+	}
+	return file_inc->get_as_utf8_string();
+}
+
+Error ResourceImporterShaderFile::import(const String &p_source_file, const String &p_save_path, const Map<StringName, Variant> &p_options, List<String> *r_platform_variants, List<String> *r_gen_files, Variant *r_metadata) {
+
+	/* STEP 1, Read shader code */
+
+	Error err;
+	FileAccessRef file = FileAccess::open(p_source_file, FileAccess::READ, &err);
+	ERR_FAIL_COND_V(err != OK, ERR_CANT_OPEN);
+	ERR_FAIL_COND_V(!file.operator->(), ERR_CANT_OPEN);
+
+	String file_txt = file->get_as_utf8_string();
+	Ref<RDShaderFile> shader_file;
+	shader_file.instance();
+	String base_path = p_source_file.get_base_dir();
+	err = shader_file->parse_versions_from_text(file_txt, _include_function, &base_path);
+
+	if (err != OK) {
+		if (!ShaderFileEditor::singleton->is_visible_in_tree()) {
+			EditorNode::get_singleton()->add_io_error(vformat(TTR("Error importing GLSL shader file: '%s'. Open the file in the filesystem dock in order to see the reason."), p_source_file));
+		}
+	}
+
+	ResourceSaver::save(p_save_path + ".res", shader_file);
+
+	return OK;
+}
+
+ResourceImporterShaderFile::ResourceImporterShaderFile() {
+}
diff --git a/editor/import/resource_importer_shader_file.h b/editor/import/resource_importer_shader_file.h
new file mode 100644
index 0000000000..f6b50bee9e
--- /dev/null
+++ b/editor/import/resource_importer_shader_file.h
@@ -0,0 +1,27 @@
+#ifndef RESOURCE_IMPORTER_SHADER_FILE_H
+#define RESOURCE_IMPORTER_SHADER_FILE_H
+
+#include "core/io/resource_importer.h"
+
+class ResourceImporterShaderFile : public ResourceImporter {
+	GDCLASS(ResourceImporterShaderFile, ResourceImporter);
+
+public:
+	virtual String get_importer_name() const;
+	virtual String get_visible_name() const;
+	virtual void get_recognized_extensions(List<String> *p_extensions) const;
+	virtual String get_save_extension() const;
+	virtual String get_resource_type() const;
+
+	virtual int get_preset_count() const;
+	virtual String get_preset_name(int p_idx) const;
+
+	virtual void get_import_options(List<ImportOption> *r_options, int p_preset = 0) const;
+	virtual bool get_option_visibility(const String &p_option, const Map<StringName, Variant> &p_options) const;
+
+	virtual Error import(const String &p_source_file, const String &p_save_path, const Map<StringName, Variant> &p_options, List<String> *r_platform_variants, List<String> *r_gen_files = nullptr, Variant *r_metadata = nullptr);
+
+	ResourceImporterShaderFile();
+};
+
+#endif // RESOURCE_IMPORTER_SHADER_FILE_H
diff --git a/editor/plugins/shader_file_editor_plugin.cpp b/editor/plugins/shader_file_editor_plugin.cpp
new file mode 100644
index 0000000000..296c7a01b6
--- /dev/null
+++ b/editor/plugins/shader_file_editor_plugin.cpp
@@ -0,0 +1,303 @@
+#include "shader_file_editor_plugin.h"
+
+#include "core/io/resource_loader.h"
+#include "core/io/resource_saver.h"
+#include "core/os/keyboard.h"
+#include "core/os/os.h"
+#include "editor/editor_node.h"
+#include "editor/editor_scale.h"
+#include "editor/editor_settings.h"
+#include "editor/property_editor.h"
+#include "servers/display_server.h"
+#include "servers/rendering/shader_types.h"
+
+/*** SHADER SCRIPT EDITOR ****/
+
+/*** SCRIPT EDITOR ******/
+
+void ShaderFileEditor::_update_version(const StringName &p_version_txt, const RD::ShaderStage p_stage) {
+}
+
+void ShaderFileEditor::_version_selected(int p_option) {
+
+	int c = versions->get_current();
+	StringName version_txt = versions->get_item_metadata(c);
+
+	RD::ShaderStage stage = RD::SHADER_STAGE_MAX;
+	int first_found = -1;
+
+	Ref<RDShaderBytecode> bytecode = shader_file->get_bytecode(version_txt);
+	ERR_FAIL_COND(bytecode.is_null());
+
+	for (int i = 0; i < RD::SHADER_STAGE_MAX; i++) {
+		if (bytecode->get_stage_bytecode(RD::ShaderStage(i)).empty() && bytecode->get_stage_compile_error(RD::ShaderStage(i)) == String()) {
+			stages[i]->set_icon(Ref<Texture2D>());
+			continue;
+		}
+
+		Ref<Texture2D> icon;
+		if (bytecode->get_stage_compile_error(RD::ShaderStage(i)) != String()) {
+			icon = get_theme_icon("ImportFail", "EditorIcons");
+		} else {
+			icon = get_theme_icon("ImportCheck", "EditorIcons");
+		}
+		stages[i]->set_icon(icon);
+
+		if (first_found == -1) {
+			first_found = i;
+		}
+
+		if (stages[i]->is_pressed()) {
+			stage = RD::ShaderStage(i);
+			break;
+		}
+	}
+
+	error_text->clear();
+
+	if (stage == RD::SHADER_STAGE_MAX) { //need to change stage, does not have it
+		if (first_found == -1) {
+			error_text->add_text(TTR("No valid shader stages found."));
+			return; //well you did not put any stage I guess?
+		}
+		stages[first_found]->set_pressed(true);
+		stage = RD::ShaderStage(first_found);
+	}
+
+	String error = bytecode->get_stage_compile_error(stage);
+
+	error_text->push_font(get_theme_font("source", "EditorFonts"));
+
+	if (error == String()) {
+		error_text->add_text(TTR("Shader stage compiled without errors."));
+	} else {
+		error_text->add_text(error);
+	}
+}
+
+void ShaderFileEditor::_update_options() {
+
+	ERR_FAIL_COND(shader_file.is_null());
+
+	if (shader_file->get_base_error() != String()) {
+		stage_hb->hide();
+		versions->hide();
+		error_text->clear();
+		error_text->push_font(get_theme_font("source", "EditorFonts"));
+		error_text->add_text(vformat(TTR("File structure for '%s' contains unrecoverable errors:\n\n"), shader_file->get_path().get_file()));
+		error_text->add_text(shader_file->get_base_error());
+		return;
+	}
+
+	stage_hb->show();
+	versions->show();
+
+	int c = versions->get_current();
+	//remember current
+	versions->clear();
+	Vector<StringName> version_list = shader_file->get_version_list();
+
+	if (c >= version_list.size()) {
+		c = version_list.size() - 1;
+	}
+	if (c < 0) {
+		c = 0;
+	}
+
+	StringName current_version;
+
+	for (int i = 0; i < version_list.size(); i++) {
+		String title = version_list[i];
+		if (title == "") {
+			title = "default";
+		}
+
+		Ref<Texture2D> icon;
+
+		Ref<RDShaderBytecode> bytecode = shader_file->get_bytecode(version_list[i]);
+		ERR_FAIL_COND(bytecode.is_null());
+
+		bool failed = false;
+		for (int j = 0; j < RD::SHADER_STAGE_MAX; j++) {
+			String error = bytecode->get_stage_compile_error(RD::ShaderStage(j));
+			if (error != String()) {
+				failed = true;
+			}
+		}
+
+		if (failed) {
+			icon = get_theme_icon("ImportFail", "EditorIcons");
+		} else {
+			icon = get_theme_icon("ImportCheck", "EditorIcons");
+		}
+
+		versions->add_item(title, icon);
+		versions->set_item_metadata(i, version_list[i]);
+
+		if (i == c) {
+			versions->select(i);
+			current_version = version_list[i];
+		}
+	}
+
+	if (version_list.size() == 0) {
+		for (int i = 0; i < RD::SHADER_STAGE_MAX; i++) {
+			stages[i]->set_disabled(true);
+		}
+		return;
+	}
+
+	Ref<RDShaderBytecode> bytecode = shader_file->get_bytecode(current_version);
+	ERR_FAIL_COND(bytecode.is_null());
+	int first_valid = -1;
+	int current = -1;
+	for (int i = 0; i < RD::SHADER_STAGE_MAX; i++) {
+		Vector<uint8_t> bc = bytecode->get_stage_bytecode(RD::ShaderStage(i));
+		String error = bytecode->get_stage_compile_error(RD::ShaderStage(i));
+		bool disable = error == String() && bc.empty();
+		stages[i]->set_disabled(disable);
+		if (!disable) {
+			if (stages[i]->is_pressed()) {
+				current = i;
+			}
+			first_valid = i;
+		}
+	}
+
+	if (current == -1 && first_valid != -1) {
+		stages[first_valid]->set_pressed(true);
+	}
+
+	_version_selected(0);
+}
+
+void ShaderFileEditor::_notification(int p_what) {
+
+	if (p_what == NOTIFICATION_WM_FOCUS_IN) {
+		if (is_visible_in_tree() && shader_file.is_valid()) {
+			_update_options();
+		}
+	}
+}
+
+void ShaderFileEditor::_editor_settings_changed() {
+
+	if (is_visible_in_tree() && shader_file.is_valid()) {
+		_update_options();
+	}
+}
+
+void ShaderFileEditor::_bind_methods() {
+}
+
+void ShaderFileEditor::edit(const Ref<RDShaderFile> &p_shader) {
+
+	if (p_shader.is_null()) {
+		if (shader_file.is_valid()) {
+			shader_file->disconnect("changed", callable_mp(this, &ShaderFileEditor::_shader_changed));
+		}
+		return;
+	}
+
+	if (shader_file == p_shader)
+		return;
+
+	shader_file = p_shader;
+
+	if (shader_file.is_valid()) {
+		shader_file->connect("changed", callable_mp(this, &ShaderFileEditor::_shader_changed));
+	}
+
+	_update_options();
+}
+
+void ShaderFileEditor::_shader_changed() {
+
+	if (is_visible_in_tree()) {
+		_update_options();
+	}
+}
+
+ShaderFileEditor *ShaderFileEditor::singleton = nullptr;
+
+ShaderFileEditor::ShaderFileEditor(EditorNode *p_node) {
+	singleton = this;
+	HSplitContainer *main_hs = memnew(HSplitContainer);
+
+	add_child(main_hs);
+
+	versions = memnew(ItemList);
+	versions->connect("item_selected", callable_mp(this, &ShaderFileEditor::_version_selected));
+	versions->set_custom_minimum_size(Size2i(200 * EDSCALE, 0));
+	main_hs->add_child(versions);
+
+	VBoxContainer *main_vb = memnew(VBoxContainer);
+	main_vb->set_h_size_flags(SIZE_EXPAND_FILL);
+	main_hs->add_child(main_vb);
+
+	static const char *stage_str[RD::SHADER_STAGE_MAX] = {
+		"Vertex",
+		"Fragment",
+		"TessControl",
+		"TessEval",
+		"Compute"
+	};
+
+	stage_hb = memnew(HBoxContainer);
+	main_vb->add_child(stage_hb);
+
+	Ref<ButtonGroup> bg;
+	bg.instance();
+	for (int i = 0; i < RD::SHADER_STAGE_MAX; i++) {
+		Button *button = memnew(Button(stage_str[i]));
+		button->set_toggle_mode(true);
+		button->set_focus_mode(FOCUS_NONE);
+		stage_hb->add_child(button);
+		stages[i] = button;
+		button->set_button_group(bg);
+		button->connect("pressed", callable_mp(this, &ShaderFileEditor::_version_selected), varray(i));
+	}
+
+	error_text = memnew(RichTextLabel);
+	error_text->set_v_size_flags(SIZE_EXPAND_FILL);
+	main_vb->add_child(error_text);
+}
+
+void ShaderFileEditorPlugin::edit(Object *p_object) {
+
+	RDShaderFile *s = Object::cast_to<RDShaderFile>(p_object);
+	shader_editor->edit(s);
+}
+
+bool ShaderFileEditorPlugin::handles(Object *p_object) const {
+
+	RDShaderFile *shader = Object::cast_to<RDShaderFile>(p_object);
+	return shader != nullptr;
+}
+
+void ShaderFileEditorPlugin::make_visible(bool p_visible) {
+
+	if (p_visible) {
+		button->show();
+		editor->make_bottom_panel_item_visible(shader_editor);
+
+	} else {
+
+		button->hide();
+		if (shader_editor->is_visible_in_tree())
+			editor->hide_bottom_panel();
+	}
+}
+
+ShaderFileEditorPlugin::ShaderFileEditorPlugin(EditorNode *p_node) {
+
+	editor = p_node;
+	shader_editor = memnew(ShaderFileEditor(p_node));
+
+	shader_editor->set_custom_minimum_size(Size2(0, 300) * EDSCALE);
+	button = editor->add_bottom_panel_item(TTR("ShaderFile"), shader_editor);
+	button->hide();
+}
+
+ShaderFileEditorPlugin::~ShaderFileEditorPlugin() {
+}
diff --git a/editor/plugins/shader_file_editor_plugin.h b/editor/plugins/shader_file_editor_plugin.h
new file mode 100644
index 0000000000..44d32de2f1
--- /dev/null
+++ b/editor/plugins/shader_file_editor_plugin.h
@@ -0,0 +1,64 @@
+#ifndef SHADER_FILE_EDITOR_PLUGIN_H
+#define SHADER_FILE_EDITOR_PLUGIN_H
+
+#include "editor/code_editor.h"
+#include "editor/editor_plugin.h"
+#include "scene/gui/menu_button.h"
+#include "scene/gui/panel_container.h"
+#include "scene/gui/rich_text_label.h"
+#include "scene/gui/tab_container.h"
+#include "scene/gui/text_edit.h"
+#include "scene/main/timer.h"
+#include "servers/rendering/rendering_device_binds.h"
+
+class ShaderFileEditor : public PanelContainer {
+
+	GDCLASS(ShaderFileEditor, PanelContainer);
+
+	Ref<RDShaderFile> shader_file;
+
+	HBoxContainer *stage_hb;
+	ItemList *versions;
+	Button *stages[RD::SHADER_STAGE_MAX];
+	RichTextLabel *error_text;
+
+	void _update_version(const StringName &p_version_txt, const RenderingDevice::ShaderStage p_stage);
+	void _version_selected(int p_stage);
+	void _editor_settings_changed();
+
+	void _update_options();
+	void _shader_changed();
+
+protected:
+	void _notification(int p_what);
+	static void _bind_methods();
+
+public:
+	static ShaderFileEditor *singleton;
+	void edit(const Ref<RDShaderFile> &p_shader);
+
+	ShaderFileEditor(EditorNode *p_node);
+};
+
+class ShaderFileEditorPlugin : public EditorPlugin {
+
+	GDCLASS(ShaderFileEditorPlugin, EditorPlugin);
+
+	ShaderFileEditor *shader_editor;
+	EditorNode *editor;
+	Button *button;
+
+public:
+	virtual String get_name() const { return "ShaderFile"; }
+	bool has_main_screen() const { return false; }
+	virtual void edit(Object *p_object);
+	virtual bool handles(Object *p_object) const;
+	virtual void make_visible(bool p_visible);
+
+	ShaderFileEditor *get_shader_editor() const { return shader_editor; }
+
+	ShaderFileEditorPlugin(EditorNode *p_node);
+	~ShaderFileEditorPlugin();
+};
+
+#endif // SHADER_FILE_EDITOR_PLUGIN_H