Implement Binary Shader Compilation

* Added an extra stage before compiling shader, which is generating a binary blob.
* On Vulkan, this allows caching the SPIRV reflection information, which is expensive to parse.
* On other (future) RenderingDevices, it allows caching converted binary data, such as DXIL or MSL.

This PR makes the shader cache include the reflection information, hence editor startup times are significantly improved.
I tested this well and it appears to work, and I added a lot of consistency checks, but because it includes writing and reading binary information, rare bugs may pop up, so be aware.
There was not much of a choice for storing the reflection information, given shaders can be a lot, take a lot of space and take time to parse.

6 files changed, 163 insertions, 181 deletions

diff --git a/servers/rendering/renderer_rd/shader_rd.cpp b/servers/rendering/renderer_rd/shader_rd.cpp
index 27305cc938..1b9f54d1c8 100644
--- a/servers/rendering/renderer_rd/shader_rd.cpp
+++ b/servers/rendering/renderer_rd/shader_rd.cpp
@@ -116,8 +116,10 @@ void ShaderRD::setup(const char *p_vertex_code, const char *p_fragment_code, con
 	}
 
 	StringBuilder tohash;
-	tohash.append("[VersionKey]");
-	tohash.append(RenderingDevice::get_singleton()->shader_get_cache_key());
+	tohash.append("[SpirvCacheKey]");
+	tohash.append(RenderingDevice::get_singleton()->shader_get_spirv_cache_key());
+	tohash.append("[BinaryCacheKey]");
+	tohash.append(RenderingDevice::get_singleton()->shader_get_binary_cache_key());
 	tohash.append("[Vertex]");
 	tohash.append(p_vertex_code ? p_vertex_code : "");
 	tohash.append("[Fragment]");
@@ -148,8 +150,8 @@ void ShaderRD::_clear_version(Version *p_version) {
 		}
 
 		memdelete_arr(p_version->variants);
-		if (p_version->variant_stages) {
-			memdelete_arr(p_version->variant_stages);
+		if (p_version->variant_data) {
+			memdelete_arr(p_version->variant_data);
 		}
 		p_version->variants = nullptr;
 	}
@@ -203,7 +205,7 @@ void ShaderRD::_compile_variant(uint32_t p_variant, Version *p_version) {
 		return; //variant is disabled, return
 	}
 
-	Vector<RD::ShaderStageData> &stages = p_version->variant_stages[p_variant];
+	Vector<RD::ShaderStageSPIRVData> stages;
 
 	String error;
 	String current_source;
@@ -217,8 +219,8 @@ void ShaderRD::_compile_variant(uint32_t p_variant, Version *p_version) {
 		_build_variant_code(builder, p_variant, p_version, stage_templates[STAGE_TYPE_VERTEX]);
 
 		current_source = builder.as_string();
-		RD::ShaderStageData stage;
-		stage.spir_v = RD::get_singleton()->shader_compile_from_source(RD::SHADER_STAGE_VERTEX, current_source, RD::SHADER_LANGUAGE_GLSL, &error);
+		RD::ShaderStageSPIRVData stage;
+		stage.spir_v = RD::get_singleton()->shader_compile_spirv_from_source(RD::SHADER_STAGE_VERTEX, current_source, RD::SHADER_LANGUAGE_GLSL, &error);
 		if (stage.spir_v.size() == 0) {
 			build_ok = false;
 		} else {
@@ -235,8 +237,8 @@ void ShaderRD::_compile_variant(uint32_t p_variant, Version *p_version) {
 		_build_variant_code(builder, p_variant, p_version, stage_templates[STAGE_TYPE_FRAGMENT]);
 
 		current_source = builder.as_string();
-		RD::ShaderStageData stage;
-		stage.spir_v = RD::get_singleton()->shader_compile_from_source(RD::SHADER_STAGE_FRAGMENT, current_source, RD::SHADER_LANGUAGE_GLSL, &error);
+		RD::ShaderStageSPIRVData stage;
+		stage.spir_v = RD::get_singleton()->shader_compile_spirv_from_source(RD::SHADER_STAGE_FRAGMENT, current_source, RD::SHADER_LANGUAGE_GLSL, &error);
 		if (stage.spir_v.size() == 0) {
 			build_ok = false;
 		} else {
@@ -254,8 +256,8 @@ void ShaderRD::_compile_variant(uint32_t p_variant, Version *p_version) {
 
 		current_source = builder.as_string();
 
-		RD::ShaderStageData stage;
-		stage.spir_v = RD::get_singleton()->shader_compile_from_source(RD::SHADER_STAGE_COMPUTE, current_source, RD::SHADER_LANGUAGE_GLSL, &error);
+		RD::ShaderStageSPIRVData stage;
+		stage.spir_v = RD::get_singleton()->shader_compile_spirv_from_source(RD::SHADER_STAGE_COMPUTE, current_source, RD::SHADER_LANGUAGE_GLSL, &error);
 		if (stage.spir_v.size() == 0) {
 			build_ok = false;
 		} else {
@@ -275,10 +277,15 @@ void ShaderRD::_compile_variant(uint32_t p_variant, Version *p_version) {
 		return;
 	}
 
-	RID shader = RD::get_singleton()->shader_create(stages);
+	Vector<uint8_t> shader_data = RD::get_singleton()->shader_compile_binary_from_spirv(stages);
+
+	ERR_FAIL_COND(shader_data.size() == 0);
+
+	RID shader = RD::get_singleton()->shader_create_from_bytecode(shader_data);
 	{
 		MutexLock lock(variant_set_mutex);
 		p_version->variants[p_variant] = shader;
+		p_version->variant_data[p_variant] = shader_data;
 	}
 }
 
@@ -364,14 +371,12 @@ String ShaderRD::_version_get_sha1(Version *p_version) const {
 }
 
 static const char *shader_file_header = "GDSC";
-static const uint32_t cache_file_version = 1;
+static const uint32_t cache_file_version = 2;
 
 bool ShaderRD::_load_from_cache(Version *p_version) {
 	String sha1 = _version_get_sha1(p_version);
 	String path = shader_cache_dir.plus_file(name).plus_file(base_sha256).plus_file(sha1) + ".cache";
 
-	uint64_t time_from = OS::get_singleton()->get_ticks_usec();
-
 	FileAccessRef f = FileAccess::open(path, FileAccess::READ);
 	if (!f) {
 		return false;
@@ -390,76 +395,43 @@ bool ShaderRD::_load_from_cache(Version *p_version) {
 
 	ERR_FAIL_COND_V(variant_count != (uint32_t)variant_defines.size(), false); //should not happen but check
 
-	bool success = true;
 	for (uint32_t i = 0; i < variant_count; i++) {
-		uint32_t stage_count = f->get_32();
-		p_version->variant_stages[i].resize(stage_count);
-		for (uint32_t j = 0; j < stage_count; j++) {
-			p_version->variant_stages[i].write[j].shader_stage = RD::ShaderStage(f->get_32());
-
-			int compression = f->get_32();
-			uint32_t length = f->get_32();
-
-			if (compression == 0) {
-				Vector<uint8_t> data;
-				data.resize(length);
-
-				f->get_buffer(data.ptrw(), length);
-
-				p_version->variant_stages[i].write[j].spir_v = data;
-			} else {
-				Vector<uint8_t> data;
-
-				if (compression == 2) {
-					//zstd
-					int smol_length = f->get_32();
-					Vector<uint8_t> zstd_data;
-
-					zstd_data.resize(smol_length);
-					f->get_buffer(zstd_data.ptrw(), smol_length);
-
-					data.resize(length);
-					Compression::decompress(data.ptrw(), data.size(), zstd_data.ptr(), zstd_data.size(), Compression::MODE_ZSTD);
-
-				} else {
-					data.resize(length);
-					f->get_buffer(data.ptrw(), length);
-				}
-
-				Vector<uint8_t> spirv;
-				uint32_t spirv_size = smolv::GetDecodedBufferSize(data.ptr(), data.size());
-				spirv.resize(spirv_size);
-				if (!smolv::Decode(data.ptr(), data.size(), spirv.ptrw(), spirv_size)) {
-					ERR_PRINT("Malformed smolv input uncompressing shader " + name + ", variant #" + itos(i) + " stage :" + itos(j));
-					success = false;
-					break;
-				}
-				p_version->variant_stages[i].write[j].spir_v = spirv;
-			}
+		uint32_t variant_size = f->get_32();
+		ERR_FAIL_COND_V(variant_size == 0 && variants_enabled[i], false);
+		if (!variants_enabled[i]) {
+			continue;
 		}
-	}
+		Vector<uint8_t> variant_bytes;
+		variant_bytes.resize(variant_size);
 
-	if (!success) {
-		for (uint32_t i = 0; i < variant_count; i++) {
-			p_version->variant_stages[i].resize(0);
-		}
-		return false;
-	}
+		uint32_t br = f->get_buffer(variant_bytes.ptrw(), variant_size);
 
-	float time_ms = double(OS::get_singleton()->get_ticks_usec() - time_from) / 1000.0;
+		ERR_FAIL_COND_V(br != variant_size, false);
 
-	print_verbose("Shader cache load success '" + path + "' " + rtos(time_ms) + "ms.");
+		p_version->variant_data[i] = variant_bytes;
+	}
 
 	for (uint32_t i = 0; i < variant_count; i++) {
-		RID shader = RD::get_singleton()->shader_create(p_version->variant_stages[i]);
+		if (!variants_enabled[i]) {
+			MutexLock lock(variant_set_mutex);
+			p_version->variants[i] = RID();
+			continue;
+		}
+		RID shader = RD::get_singleton()->shader_create_from_bytecode(p_version->variant_data[i]);
+		if (shader.is_null()) {
+			for (uint32_t j = 0; j < i; j++) {
+				RD::get_singleton()->free(p_version->variants[i]);
+			}
+			ERR_FAIL_COND_V(shader.is_null(), false);
+		}
 		{
 			MutexLock lock(variant_set_mutex);
 			p_version->variants[i] = shader;
 		}
 	}
 
-	memdelete_arr(p_version->variant_stages); //clear stages
-	p_version->variant_stages = nullptr;
+	memdelete_arr(p_version->variant_data); //clear stages
+	p_version->variant_data = nullptr;
 	p_version->valid = true;
 	return true;
 }
@@ -476,49 +448,8 @@ void ShaderRD::_save_to_cache(Version *p_version) {
 	f->store_32(variant_count); //variant count
 
 	for (uint32_t i = 0; i < variant_count; i++) {
-		f->store_32(p_version->variant_stages[i].size()); //stage count
-		for (int j = 0; j < p_version->variant_stages[i].size(); j++) {
-			f->store_32(p_version->variant_stages[i][j].shader_stage); //stage count
-			Vector<uint8_t> spirv = p_version->variant_stages[i][j].spir_v;
-
-			bool save_uncompressed = true;
-			if (shader_cache_save_compressed) {
-				smolv::ByteArray smolv;
-				bool strip_debug = !shader_cache_save_debug;
-				if (!smolv::Encode(spirv.ptr(), spirv.size(), smolv, strip_debug ? smolv::kEncodeFlagStripDebugInfo : 0)) {
-					ERR_PRINT("Error compressing shader " + name + ", variant #" + itos(i) + " stage :" + itos(i));
-				} else {
-					bool compress_zstd = shader_cache_save_compressed_zstd;
-
-					if (compress_zstd) {
-						Vector<uint8_t> zstd;
-						zstd.resize(Compression::get_max_compressed_buffer_size(smolv.size(), Compression::MODE_ZSTD));
-						int dst_size = Compression::compress(zstd.ptrw(), &smolv[0], smolv.size(), Compression::MODE_ZSTD);
-						if (dst_size >= 0 && (uint32_t)dst_size < smolv.size()) {
-							f->store_32(2); //compressed zstd
-							f->store_32(smolv.size()); //size of smolv buffer
-							f->store_32(dst_size); //size of smolv buffer
-							f->store_buffer(zstd.ptr(), dst_size); //smolv buffer
-						} else {
-							compress_zstd = false;
-						}
-					}
-
-					if (!compress_zstd) {
-						f->store_32(1); //compressed
-						f->store_32(smolv.size()); //size of smolv buffer
-						f->store_buffer(&smolv[0], smolv.size()); //smolv buffer
-					}
-					save_uncompressed = false;
-				}
-			}
-
-			if (save_uncompressed) {
-				f->store_32(0); //uncompressed
-				f->store_32(spirv.size()); //stage count
-				f->store_buffer(spirv.ptr(), spirv.size()); //stage count
-			}
-		}
+		f->store_32(p_version->variant_data[i].size()); //stage count
+		f->store_buffer(p_version->variant_data[i].ptr(), p_version->variant_data[i].size());
 	}
 
 	f->close();
@@ -531,8 +462,8 @@ void ShaderRD::_compile_version(Version *p_version) {
 	p_version->dirty = false;
 
 	p_version->variants = memnew_arr(RID, variant_defines.size());
-	typedef Vector<RD::ShaderStageData> ShaderStageArray;
-	p_version->variant_stages = memnew_arr(ShaderStageArray, variant_defines.size());
+	typedef Vector<uint8_t> ShaderStageData;
+	p_version->variant_data = memnew_arr(ShaderStageData, variant_defines.size());
 
 	if (shader_cache_dir_valid) {
 		if (_load_from_cache(p_version)) {
@@ -571,19 +502,19 @@ void ShaderRD::_compile_version(Version *p_version) {
 			}
 		}
 		memdelete_arr(p_version->variants);
-		if (p_version->variant_stages) {
-			memdelete_arr(p_version->variant_stages);
+		if (p_version->variant_data) {
+			memdelete_arr(p_version->variant_data);
 		}
 		p_version->variants = nullptr;
-		p_version->variant_stages = nullptr;
+		p_version->variant_data = nullptr;
 		return;
 	} else if (shader_cache_dir_valid) {
 		//save shader cache
 		_save_to_cache(p_version);
 	}
 
-	memdelete_arr(p_version->variant_stages); //clear stages
-	p_version->variant_stages = nullptr;
+	memdelete_arr(p_version->variant_data); //clear stages
+	p_version->variant_data = nullptr;
 
 	p_version->valid = true;
 }
diff --git a/servers/rendering/renderer_rd/shader_rd.h b/servers/rendering/renderer_rd/shader_rd.h
index 9a68e02007..529328f0ed 100644
--- a/servers/rendering/renderer_rd/shader_rd.h
+++ b/servers/rendering/renderer_rd/shader_rd.h
@@ -59,7 +59,7 @@ class ShaderRD {
 		Map<StringName, CharString> code_sections;
 		Vector<CharString> custom_defines;
 
-		Vector<RD::ShaderStageData> *variant_stages = nullptr;
+		Vector<uint8_t> *variant_data = nullptr;
 		RID *variants = nullptr; //same size as version defines
 
 		bool valid;
diff --git a/servers/rendering/rendering_device.cpp b/servers/rendering/rendering_device.cpp
index 3594939362..b298ad193b 100644
--- a/servers/rendering/rendering_device.cpp
+++ b/servers/rendering/rendering_device.cpp
@@ -38,23 +38,23 @@ RenderingDevice *RenderingDevice::get_singleton() {
 	return singleton;
 }
 
-RenderingDevice::ShaderCompileFunction RenderingDevice::compile_function = nullptr;
+RenderingDevice::ShaderCompileToSPIRVFunction RenderingDevice::compile_to_spirv_function = nullptr;
 RenderingDevice::ShaderCacheFunction RenderingDevice::cache_function = nullptr;
-RenderingDevice::ShaderGetCacheKeyFunction RenderingDevice::get_cache_key_function = nullptr;
+RenderingDevice::ShaderSPIRVGetCacheKeyFunction RenderingDevice::get_spirv_cache_key_function = nullptr;
 
-void RenderingDevice::shader_set_compile_function(ShaderCompileFunction p_function) {
-	compile_function = p_function;
+void RenderingDevice::shader_set_compile_to_spirv_function(ShaderCompileToSPIRVFunction p_function) {
+	compile_to_spirv_function = p_function;
 }
 
-void RenderingDevice::shader_set_cache_function(ShaderCacheFunction p_function) {
+void RenderingDevice::shader_set_spirv_cache_function(ShaderCacheFunction p_function) {
 	cache_function = p_function;
 }
 
-void RenderingDevice::shader_set_get_cache_key_function(ShaderGetCacheKeyFunction p_function) {
-	get_cache_key_function = p_function;
+void RenderingDevice::shader_set_get_cache_key_function(ShaderSPIRVGetCacheKeyFunction p_function) {
+	get_spirv_cache_key_function = p_function;
 }
 
-Vector<uint8_t> RenderingDevice::shader_compile_from_source(ShaderStage p_stage, const String &p_source_code, ShaderLanguage p_language, String *r_error, bool p_allow_cache) {
+Vector<uint8_t> RenderingDevice::shader_compile_spirv_from_source(ShaderStage p_stage, const String &p_source_code, ShaderLanguage p_language, String *r_error, bool p_allow_cache) {
 	if (p_allow_cache && cache_function) {
 		Vector<uint8_t> cache = cache_function(p_stage, p_source_code, p_language);
 		if (cache.size()) {
@@ -62,18 +62,24 @@ Vector<uint8_t> RenderingDevice::shader_compile_from_source(ShaderStage p_stage,
 		}
 	}
 
-	ERR_FAIL_COND_V(!compile_function, Vector<uint8_t>());
+	ERR_FAIL_COND_V(!compile_to_spirv_function, Vector<uint8_t>());
 
-	return compile_function(p_stage, p_source_code, p_language, r_error, &device_capabilities);
+	return compile_to_spirv_function(p_stage, p_source_code, p_language, r_error, &device_capabilities);
 }
 
-String RenderingDevice::shader_get_cache_key() const {
-	if (get_cache_key_function) {
-		return get_cache_key_function(&device_capabilities);
+String RenderingDevice::shader_get_spirv_cache_key() const {
+	if (get_spirv_cache_key_function) {
+		return get_spirv_cache_key_function(&device_capabilities);
 	}
 	return String();
 }
 
+RID RenderingDevice::shader_create_from_spirv(const Vector<ShaderStageSPIRVData> &p_spirv) {
+	Vector<uint8_t> bytecode = shader_compile_binary_from_spirv(p_spirv);
+	ERR_FAIL_COND_V(bytecode.size() == 0, RID());
+	return shader_create_from_bytecode(bytecode);
+}
+
 RID RenderingDevice::_texture_create(const Ref<RDTextureFormat> &p_format, const Ref<RDTextureView> &p_view, const TypedArray<PackedByteArray> &p_data) {
 	ERR_FAIL_COND_V(p_format.is_null(), RID());
 	ERR_FAIL_COND_V(p_view.is_null(), RID());
@@ -170,40 +176,59 @@ RID RenderingDevice::_vertex_array_create(uint32_t p_vertex_count, VertexFormatI
 	return vertex_array_create(p_vertex_count, p_vertex_format, buffers);
 }
 
-Ref<RDShaderBytecode> RenderingDevice::_shader_compile_from_source(const Ref<RDShaderSource> &p_source, bool p_allow_cache) {
-	ERR_FAIL_COND_V(p_source.is_null(), Ref<RDShaderBytecode>());
+Ref<RDShaderSPIRV> RenderingDevice::_shader_compile_spirv_from_source(const Ref<RDShaderSource> &p_source, bool p_allow_cache) {
+	ERR_FAIL_COND_V(p_source.is_null(), Ref<RDShaderSPIRV>());
 
-	Ref<RDShaderBytecode> bytecode;
+	Ref<RDShaderSPIRV> bytecode;
 	bytecode.instantiate();
 	for (int i = 0; i < RD::SHADER_STAGE_MAX; i++) {
 		String error;
 
 		ShaderStage stage = ShaderStage(i);
-		Vector<uint8_t> spirv = shader_compile_from_source(stage, p_source->get_stage_source(stage), p_source->get_language(), &error, p_allow_cache);
+		Vector<uint8_t> spirv = shader_compile_spirv_from_source(stage, p_source->get_stage_source(stage), p_source->get_language(), &error, p_allow_cache);
 		bytecode->set_stage_bytecode(stage, spirv);
 		bytecode->set_stage_compile_error(stage, error);
 	}
 	return bytecode;
 }
 
-RID RenderingDevice::shader_create_from_bytecode(const Ref<RDShaderBytecode> &p_bytecode) {
-	ERR_FAIL_COND_V(p_bytecode.is_null(), RID());
+Vector<uint8_t> RenderingDevice::_shader_compile_binary_from_spirv(const Ref<RDShaderSPIRV> &p_spirv) {
+	ERR_FAIL_COND_V(p_spirv.is_null(), Vector<uint8_t>());
 
-	Vector<ShaderStageData> stage_data;
+	Vector<ShaderStageSPIRVData> stage_data;
 	for (int i = 0; i < RD::SHADER_STAGE_MAX; i++) {
 		ShaderStage stage = ShaderStage(i);
-		ShaderStageData sd;
+		ShaderStageSPIRVData sd;
 		sd.shader_stage = stage;
-		String error = p_bytecode->get_stage_compile_error(stage);
-		ERR_FAIL_COND_V_MSG(error != String(), RID(), "Can't create a shader from an errored bytecode. Check errors in source bytecode.");
-		sd.spir_v = p_bytecode->get_stage_bytecode(stage);
+		String error = p_spirv->get_stage_compile_error(stage);
+		ERR_FAIL_COND_V_MSG(error != String(), Vector<uint8_t>(), "Can't create a shader from an errored bytecode. Check errors in source bytecode.");
+		sd.spir_v = p_spirv->get_stage_bytecode(stage);
 		if (sd.spir_v.is_empty()) {
 			continue;
 		}
 		stage_data.push_back(sd);
 	}
 
-	return shader_create(stage_data);
+	return shader_compile_binary_from_spirv(stage_data);
+}
+
+RID RenderingDevice::_shader_create_from_spirv(const Ref<RDShaderSPIRV> &p_spirv) {
+	ERR_FAIL_COND_V(p_spirv.is_null(), RID());
+
+	Vector<ShaderStageSPIRVData> stage_data;
+	for (int i = 0; i < RD::SHADER_STAGE_MAX; i++) {
+		ShaderStage stage = ShaderStage(i);
+		ShaderStageSPIRVData sd;
+		sd.shader_stage = stage;
+		String error = p_spirv->get_stage_compile_error(stage);
+		ERR_FAIL_COND_V_MSG(error != String(), RID(), "Can't create a shader from an errored bytecode. Check errors in source bytecode.");
+		sd.spir_v = p_spirv->get_stage_bytecode(stage);
+		if (sd.spir_v.is_empty()) {
+			continue;
+		}
+		stage_data.push_back(sd);
+	}
+	return shader_create_from_spirv(stage_data);
 }
 
 RID RenderingDevice::_uniform_set_create(const Array &p_uniforms, RID p_shader, uint32_t p_shader_set) {
@@ -366,8 +391,10 @@ void RenderingDevice::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("index_buffer_create", "size_indices", "format", "data", "use_restart_indices"), &RenderingDevice::index_buffer_create, DEFVAL(Vector<uint8_t>()), DEFVAL(false));
 	ClassDB::bind_method(D_METHOD("index_array_create", "index_buffer", "index_offset", "index_count"), &RenderingDevice::index_array_create);
 
-	ClassDB::bind_method(D_METHOD("shader_compile_from_source", "shader_source", "allow_cache"), &RenderingDevice::_shader_compile_from_source, DEFVAL(true));
-	ClassDB::bind_method(D_METHOD("shader_create", "shader_data"), &RenderingDevice::shader_create_from_bytecode);
+	ClassDB::bind_method(D_METHOD("shader_compile_spirv_from_source", "shader_source", "allow_cache"), &RenderingDevice::_shader_compile_spirv_from_source, DEFVAL(true));
+	ClassDB::bind_method(D_METHOD("shader_compile_binary_from_spirv", "spirv_data"), &RenderingDevice::_shader_compile_binary_from_spirv);
+	ClassDB::bind_method(D_METHOD("shader_create_from_spirv", "spirv_data"), &RenderingDevice::_shader_compile_binary_from_spirv);
+	ClassDB::bind_method(D_METHOD("shader_create_from_bytecode", "binary_data"), &RenderingDevice::shader_create_from_bytecode);
 	ClassDB::bind_method(D_METHOD("shader_get_vertex_input_attribute_mask", "shader"), &RenderingDevice::shader_get_vertex_input_attribute_mask);
 
 	ClassDB::bind_method(D_METHOD("uniform_buffer_create", "size_bytes", "data"), &RenderingDevice::uniform_buffer_create, DEFVAL(Vector<uint8_t>()));
diff --git a/servers/rendering/rendering_device.h b/servers/rendering/rendering_device.h
index 9a154ef7e9..eaf1ace798 100644
--- a/servers/rendering/rendering_device.h
+++ b/servers/rendering/rendering_device.h
@@ -41,7 +41,7 @@ class RDAttachmentFormat;
 class RDSamplerState;
 class RDVertexAttribute;
 class RDShaderSource;
-class RDShaderBytecode;
+class RDShaderSPIRV;
 class RDUniforms;
 class RDPipelineRasterizationState;
 class RDPipelineMultisampleState;
@@ -105,14 +105,14 @@ public:
 		bool supports_multiview = false; // If true this device supports multiview options
 	};
 
-	typedef String (*ShaderGetCacheKeyFunction)(const Capabilities *p_capabilities);
-	typedef Vector<uint8_t> (*ShaderCompileFunction)(ShaderStage p_stage, const String &p_source_code, ShaderLanguage p_language, String *r_error, const Capabilities *p_capabilities);
+	typedef String (*ShaderSPIRVGetCacheKeyFunction)(const Capabilities *p_capabilities);
+	typedef Vector<uint8_t> (*ShaderCompileToSPIRVFunction)(ShaderStage p_stage, const String &p_source_code, ShaderLanguage p_language, String *r_error, const Capabilities *p_capabilities);
 	typedef Vector<uint8_t> (*ShaderCacheFunction)(ShaderStage p_stage, const String &p_source_code, ShaderLanguage p_language);
 
 private:
-	static ShaderCompileFunction compile_function;
+	static ShaderCompileToSPIRVFunction compile_to_spirv_function;
 	static ShaderCacheFunction cache_function;
-	static ShaderGetCacheKeyFunction get_cache_key_function;
+	static ShaderSPIRVGetCacheKeyFunction get_spirv_cache_key_function;
 
 	static RenderingDevice *singleton;
 
@@ -651,24 +651,28 @@ public:
 
 	const Capabilities *get_device_capabilities() const { return &device_capabilities; };
 
-	virtual Vector<uint8_t> shader_compile_from_source(ShaderStage p_stage, const String &p_source_code, ShaderLanguage p_language = SHADER_LANGUAGE_GLSL, String *r_error = nullptr, bool p_allow_cache = true);
-	virtual String shader_get_cache_key() const;
+	virtual Vector<uint8_t> shader_compile_spirv_from_source(ShaderStage p_stage, const String &p_source_code, ShaderLanguage p_language = SHADER_LANGUAGE_GLSL, String *r_error = nullptr, bool p_allow_cache = true);
+	virtual String shader_get_spirv_cache_key() const;
 
-	static void shader_set_compile_function(ShaderCompileFunction p_function);
-	static void shader_set_cache_function(ShaderCacheFunction p_function);
-	static void shader_set_get_cache_key_function(ShaderGetCacheKeyFunction p_function);
+	static void shader_set_compile_to_spirv_function(ShaderCompileToSPIRVFunction p_function);
+	static void shader_set_spirv_cache_function(ShaderCacheFunction p_function);
+	static void shader_set_get_cache_key_function(ShaderSPIRVGetCacheKeyFunction p_function);
 
-	struct ShaderStageData {
+	struct ShaderStageSPIRVData {
 		ShaderStage shader_stage;
 		Vector<uint8_t> spir_v;
 
-		ShaderStageData() {
+		ShaderStageSPIRVData() {
 			shader_stage = SHADER_STAGE_VERTEX;
 		}
 	};
 
-	RID shader_create_from_bytecode(const Ref<RDShaderBytecode> &p_bytecode);
-	virtual RID shader_create(const Vector<ShaderStageData> &p_stages) = 0;
+	virtual String shader_get_binary_cache_key() const = 0;
+	virtual Vector<uint8_t> shader_compile_binary_from_spirv(const Vector<ShaderStageSPIRVData> &p_spirv) = 0;
+
+	virtual RID shader_create_from_spirv(const Vector<ShaderStageSPIRVData> &p_spirv);
+	virtual RID shader_create_from_bytecode(const Vector<uint8_t> &p_shader_binary) = 0;
+
 	virtual uint32_t shader_get_vertex_input_attribute_mask(RID p_shader) = 0;
 
 	/******************/
@@ -1194,7 +1198,9 @@ protected:
 	VertexFormatID _vertex_format_create(const TypedArray<RDVertexAttribute> &p_vertex_formats);
 	RID _vertex_array_create(uint32_t p_vertex_count, VertexFormatID p_vertex_format, const TypedArray<RID> &p_src_buffers);
 
-	Ref<RDShaderBytecode> _shader_compile_from_source(const Ref<RDShaderSource> &p_source, bool p_allow_cache = true);
+	Ref<RDShaderSPIRV> _shader_compile_spirv_from_source(const Ref<RDShaderSource> &p_source, bool p_allow_cache = true);
+	Vector<uint8_t> _shader_compile_binary_from_spirv(const Ref<RDShaderSPIRV> &p_bytecode);
+	RID _shader_create_from_spirv(const Ref<RDShaderSPIRV> &p_spirv);
 
 	RID _uniform_set_create(const Array &p_uniforms, RID p_shader, uint32_t p_shader_set);
 
diff --git a/servers/rendering/rendering_device_binds.cpp b/servers/rendering/rendering_device_binds.cpp
index 2652edb1bc..fa3f2f3895 100644
--- a/servers/rendering/rendering_device_binds.cpp
+++ b/servers/rendering/rendering_device_binds.cpp
@@ -172,7 +172,7 @@ Error RDShaderFile::parse_versions_from_text(const String &p_text, const String
 		/* STEP 2, Compile the versions, add to shader file */
 
 		for (Map<StringName, String>::Element *E = version_texts.front(); E; E = E->next()) {
-			Ref<RDShaderBytecode> bytecode;
+			Ref<RDShaderSPIRV> bytecode;
 			bytecode.instantiate();
 
 			for (int i = 0; i < RD::SHADER_STAGE_MAX; i++) {
@@ -182,7 +182,7 @@ Error RDShaderFile::parse_versions_from_text(const String &p_text, const String
 				}
 				code = code.replace("VERSION_DEFINES", E->get());
 				String error;
-				Vector<uint8_t> spirv = RenderingDevice::get_singleton()->shader_compile_from_source(RD::ShaderStage(i), code, RD::SHADER_LANGUAGE_GLSL, &error, false);
+				Vector<uint8_t> spirv = RenderingDevice::get_singleton()->shader_compile_spirv_from_source(RD::ShaderStage(i), code, RD::SHADER_LANGUAGE_GLSL, &error, false);
 				bytecode->set_stage_bytecode(RD::ShaderStage(i), spirv);
 				if (error != "") {
 					error += String() + "\n\nStage '" + stage_str[i] + "' source code: \n\n";
diff --git a/servers/rendering/rendering_device_binds.h b/servers/rendering/rendering_device_binds.h
index 75a91d8419..ccc3e2fb39 100644
--- a/servers/rendering/rendering_device_binds.h
+++ b/servers/rendering/rendering_device_binds.h
@@ -263,8 +263,8 @@ protected:
 	}
 };
 
-class RDShaderBytecode : public Resource {
-	GDCLASS(RDShaderBytecode, Resource)
+class RDShaderSPIRV : public Resource {
+	GDCLASS(RDShaderSPIRV, Resource)
 
 	Vector<uint8_t> bytecode[RD::SHADER_STAGE_MAX];
 	String compile_error[RD::SHADER_STAGE_MAX];
@@ -280,6 +280,19 @@ public:
 		return bytecode[p_stage];
 	}
 
+	Vector<RD::ShaderStageSPIRVData> get_stages() const {
+		Vector<RD::ShaderStageSPIRVData> stages;
+		for (int i = 0; i < RD::SHADER_STAGE_MAX; i++) {
+			if (bytecode[i].size()) {
+				RD::ShaderStageSPIRVData stage;
+				stage.shader_stage = RD::ShaderStage(i);
+				stage.spir_v = bytecode[i];
+				stages.push_back(stage);
+			}
+		}
+		return stages;
+	}
+
 	void set_stage_compile_error(RD::ShaderStage p_stage, const String &p_compile_error) {
 		ERR_FAIL_INDEX(p_stage, RD::SHADER_STAGE_MAX);
 		compile_error[p_stage] = p_compile_error;
@@ -292,11 +305,11 @@ public:
 
 protected:
 	static void _bind_methods() {
-		ClassDB::bind_method(D_METHOD("set_stage_bytecode", "stage", "bytecode"), &RDShaderBytecode::set_stage_bytecode);
-		ClassDB::bind_method(D_METHOD("get_stage_bytecode", "stage"), &RDShaderBytecode::get_stage_bytecode);
+		ClassDB::bind_method(D_METHOD("set_stage_bytecode", "stage", "bytecode"), &RDShaderSPIRV::set_stage_bytecode);
+		ClassDB::bind_method(D_METHOD("get_stage_bytecode", "stage"), &RDShaderSPIRV::get_stage_bytecode);
 
-		ClassDB::bind_method(D_METHOD("set_stage_compile_error", "stage", "compile_error"), &RDShaderBytecode::set_stage_compile_error);
-		ClassDB::bind_method(D_METHOD("get_stage_compile_error", "stage"), &RDShaderBytecode::get_stage_compile_error);
+		ClassDB::bind_method(D_METHOD("set_stage_compile_error", "stage", "compile_error"), &RDShaderSPIRV::set_stage_compile_error);
+		ClassDB::bind_method(D_METHOD("get_stage_compile_error", "stage"), &RDShaderSPIRV::get_stage_compile_error);
 
 		ADD_GROUP("Bytecode", "bytecode_");
 		ADD_PROPERTYI(PropertyInfo(Variant::PACKED_BYTE_ARRAY, "bytecode_vertex"), "set_stage_bytecode", "get_stage_bytecode", RD::SHADER_STAGE_VERTEX);
@@ -316,24 +329,29 @@ protected:
 class RDShaderFile : public Resource {
 	GDCLASS(RDShaderFile, Resource)
 
-	Map<StringName, Ref<RDShaderBytecode>> versions;
+	Map<StringName, Ref<RDShaderSPIRV>> versions;
 	String base_error;
 
 public:
-	void set_bytecode(const Ref<RDShaderBytecode> &p_bytecode, const StringName &p_version = StringName()) {
+	void set_bytecode(const Ref<RDShaderSPIRV> &p_bytecode, const StringName &p_version = StringName()) {
 		ERR_FAIL_COND(p_bytecode.is_null());
 		versions[p_version] = p_bytecode;
 		emit_changed();
 	}
 
-	Ref<RDShaderBytecode> get_bytecode(const StringName &p_version = StringName()) const {
-		ERR_FAIL_COND_V(!versions.has(p_version), Ref<RDShaderBytecode>());
+	Ref<RDShaderSPIRV> get_spirv(const StringName &p_version = StringName()) const {
+		ERR_FAIL_COND_V(!versions.has(p_version), Ref<RDShaderSPIRV>());
 		return versions[p_version];
 	}
 
+	Vector<RD::ShaderStageSPIRVData> get_spirv_stages(const StringName &p_version = StringName()) const {
+		ERR_FAIL_COND_V(!versions.has(p_version), Vector<RD::ShaderStageSPIRVData>());
+		return versions[p_version]->get_stages();
+	}
+
 	Vector<StringName> get_version_list() const {
 		Vector<StringName> vnames;
-		for (Map<StringName, Ref<RDShaderBytecode>>::Element *E = versions.front(); E; E = E->next()) {
+		for (Map<StringName, Ref<RDShaderSPIRV>>::Element *E = versions.front(); E; E = E->next()) {
 			vnames.push_back(E->key());
 		}
 		vnames.sort_custom<StringName::AlphCompare>();
@@ -353,7 +371,7 @@ public:
 		if (base_error != "") {
 			ERR_PRINT("Error parsing shader '" + p_file + "':\n\n" + base_error);
 		} else {
-			for (Map<StringName, Ref<RDShaderBytecode>>::Element *E = versions.front(); E; E = E->next()) {
+			for (Map<StringName, Ref<RDShaderSPIRV>>::Element *E = versions.front(); E; E = E->next()) {
 				for (int i = 0; i < RD::SHADER_STAGE_MAX; i++) {
 					String error = E->get()->get_stage_compile_error(RD::ShaderStage(i));
 					if (error != String()) {
@@ -390,7 +408,7 @@ protected:
 		p_versions.get_key_list(&keys);
 		for (const Variant &E : keys) {
 			StringName name = E;
-			Ref<RDShaderBytecode> bc = p_versions[E];
+			Ref<RDShaderSPIRV> bc = p_versions[E];
 			ERR_CONTINUE(bc.is_null());
 			versions[name] = bc;
 		}
@@ -400,7 +418,7 @@ protected:
 
 	static void _bind_methods() {
 		ClassDB::bind_method(D_METHOD("set_bytecode", "bytecode", "version"), &RDShaderFile::set_bytecode, DEFVAL(StringName()));
-		ClassDB::bind_method(D_METHOD("get_bytecode", "version"), &RDShaderFile::get_bytecode, DEFVAL(StringName()));
+		ClassDB::bind_method(D_METHOD("get_spirv", "version"), &RDShaderFile::get_spirv, DEFVAL(StringName()));
 		ClassDB::bind_method(D_METHOD("get_version_list"), &RDShaderFile::get_version_list);
 
 		ClassDB::bind_method(D_METHOD("set_base_error", "error"), &RDShaderFile::set_base_error);