Merge pull request #36098 from godotengine/vulkan

Add initial Vulkan support, master branch goes UNSTABLE

52 files changed, 1467 insertions, 495 deletions

diff --git a/modules/assimp/editor_scene_importer_assimp.cpp b/modules/assimp/editor_scene_importer_assimp.cpp
index 69ab068648..2e653f4c5d 100644
--- a/modules/assimp/editor_scene_importer_assimp.cpp
+++ b/modules/assimp/editor_scene_importer_assimp.cpp
@@ -167,8 +167,7 @@ struct EditorSceneImporterAssetImportInterpolate {
 		float t2 = t * t;
 		float t3 = t2 * t;
 
-		return 0.5f * ((2.0f * p1) + (-p0 + p2) * t + (2.0f * p0 - 5.0f * p1 + 4 * p2 - p3) * t2 +
-							  (-p0 + 3.0f * p1 - 3.0f * p2 + p3) * t3);
+		return 0.5f * ((2.0f * p1) + (-p0 + p2) * t + (2.0f * p0 - 5.0f * p1 + 4.0f * p2 - p3) * t2 + (-p0 + 3.0f * p1 - 3.0f * p2 + p3) * t3);
 	}
 
 	T bezier(T start, T control_1, T control_2, T end, float t) {
@@ -995,15 +994,15 @@ EditorSceneImporterAssimp::_generate_mesh_from_surface_indices(ImportState &stat
 		}
 
 		aiMaterial *ai_material = state.assimp_scene->mMaterials[ai_mesh->mMaterialIndex];
-		Ref<SpatialMaterial> mat;
+		Ref<StandardMaterial3D> mat;
 		mat.instance();
 
 		int32_t mat_two_sided = 0;
 		if (AI_SUCCESS == ai_material->Get(AI_MATKEY_TWOSIDED, mat_two_sided)) {
 			if (mat_two_sided > 0) {
-				mat->set_cull_mode(SpatialMaterial::CULL_DISABLED);
+				mat->set_cull_mode(StandardMaterial3D::CULL_DISABLED);
 			} else {
-				mat->set_cull_mode(SpatialMaterial::CULL_BACK);
+				mat->set_cull_mode(StandardMaterial3D::CULL_BACK);
 			}
 		}
 
@@ -1015,7 +1014,7 @@ EditorSceneImporterAssimp::_generate_mesh_from_surface_indices(ImportState &stat
 		// Culling handling for meshes
 
 		// cull all back faces
-		mat->set_cull_mode(SpatialMaterial::CULL_DISABLED);
+		mat->set_cull_mode(StandardMaterial3D::CULL_DISABLED);
 
 		// Now process materials
 		aiTextureType base_color = aiTextureType_BASE_COLOR;
@@ -1028,13 +1027,11 @@ EditorSceneImporterAssimp::_generate_mesh_from_surface_indices(ImportState &stat
 
 				// anything transparent must be culled
 				if (image_data.raw_image->detect_alpha() != Image::ALPHA_NONE) {
-					mat->set_feature(SpatialMaterial::FEATURE_TRANSPARENT, true);
-					mat->set_depth_draw_mode(SpatialMaterial::DepthDrawMode::DEPTH_DRAW_ALPHA_OPAQUE_PREPASS);
-					mat->set_cull_mode(
-							SpatialMaterial::CULL_DISABLED); // since you can see both sides in transparent mode
+					mat->set_transparency(StandardMaterial3D::TRANSPARENCY_ALPHA_DEPTH_PRE_PASS);
+					mat->set_cull_mode(StandardMaterial3D::CULL_DISABLED); // since you can see both sides in transparent mode
 				}
 
-				mat->set_texture(SpatialMaterial::TEXTURE_ALBEDO, image_data.texture);
+				mat->set_texture(StandardMaterial3D::TEXTURE_ALBEDO, image_data.texture);
 			}
 		}
 
@@ -1048,22 +1045,18 @@ EditorSceneImporterAssimp::_generate_mesh_from_surface_indices(ImportState &stat
 
 				// anything transparent must be culled
 				if (image_data.raw_image->detect_alpha() != Image::ALPHA_NONE) {
-					mat->set_feature(SpatialMaterial::FEATURE_TRANSPARENT, true);
-					mat->set_depth_draw_mode(SpatialMaterial::DepthDrawMode::DEPTH_DRAW_ALPHA_OPAQUE_PREPASS);
-					mat->set_cull_mode(
-							SpatialMaterial::CULL_DISABLED); // since you can see both sides in transparent mode
+					mat->set_transparency(StandardMaterial3D::TRANSPARENCY_ALPHA_DEPTH_PRE_PASS);
+					mat->set_cull_mode(StandardMaterial3D::CULL_DISABLED); // since you can see both sides in transparent mode
 				}
 
-				mat->set_texture(SpatialMaterial::TEXTURE_ALBEDO, image_data.texture);
+				mat->set_texture(StandardMaterial3D::TEXTURE_ALBEDO, image_data.texture);
 			}
 
 			aiColor4D clr_diffuse;
 			if (AI_SUCCESS == ai_material->Get(AI_MATKEY_COLOR_DIFFUSE, clr_diffuse)) {
 				if (Math::is_equal_approx(clr_diffuse.a, 1.0f) == false) {
-					mat->set_feature(SpatialMaterial::FEATURE_TRANSPARENT, true);
-					mat->set_depth_draw_mode(SpatialMaterial::DepthDrawMode::DEPTH_DRAW_ALPHA_OPAQUE_PREPASS);
-					mat->set_cull_mode(
-							SpatialMaterial::CULL_DISABLED); // since you can see both sides in transparent mode
+					mat->set_transparency(StandardMaterial3D::TRANSPARENCY_ALPHA_DEPTH_PRE_PASS);
+					mat->set_cull_mode(StandardMaterial3D::CULL_DISABLED); // since you can see both sides in transparent mode
 				}
 				mat->set_albedo(Color(clr_diffuse.r, clr_diffuse.g, clr_diffuse.b, clr_diffuse.a));
 			}
@@ -1078,14 +1071,14 @@ EditorSceneImporterAssimp::_generate_mesh_from_surface_indices(ImportState &stat
 			// Process texture normal map
 			if (AssimpUtils::GetAssimpTexture(state, ai_material, tex_normal, filename, path, image_data)) {
 				AssimpUtils::set_texture_mapping_mode(image_data.map_mode, image_data.texture);
-				mat->set_feature(SpatialMaterial::Feature::FEATURE_NORMAL_MAPPING, true);
-				mat->set_texture(SpatialMaterial::TEXTURE_NORMAL, image_data.texture);
+				mat->set_feature(StandardMaterial3D::Feature::FEATURE_NORMAL_MAPPING, true);
+				mat->set_texture(StandardMaterial3D::TEXTURE_NORMAL, image_data.texture);
 			} else {
 				aiString texture_path;
 				if (AI_SUCCESS == ai_material->Get(AI_MATKEY_FBX_NORMAL_TEXTURE, AI_PROPERTIES, texture_path)) {
 					if (AssimpUtils::CreateAssimpTexture(state, texture_path, filename, path, image_data)) {
-						mat->set_feature(SpatialMaterial::Feature::FEATURE_NORMAL_MAPPING, true);
-						mat->set_texture(SpatialMaterial::TEXTURE_NORMAL, image_data.texture);
+						mat->set_feature(StandardMaterial3D::Feature::FEATURE_NORMAL_MAPPING, true);
+						mat->set_texture(StandardMaterial3D::TEXTURE_NORMAL, image_data.texture);
 					}
 				}
 			}
@@ -1100,8 +1093,8 @@ EditorSceneImporterAssimp::_generate_mesh_from_surface_indices(ImportState &stat
 			// Process texture normal map
 			if (AssimpUtils::GetAssimpTexture(state, ai_material, tex_normal_camera, filename, path, image_data)) {
 				AssimpUtils::set_texture_mapping_mode(image_data.map_mode, image_data.texture);
-				mat->set_feature(SpatialMaterial::Feature::FEATURE_NORMAL_MAPPING, true);
-				mat->set_texture(SpatialMaterial::TEXTURE_NORMAL, image_data.texture);
+				mat->set_feature(StandardMaterial3D::Feature::FEATURE_NORMAL_MAPPING, true);
+				mat->set_texture(StandardMaterial3D::TEXTURE_NORMAL, image_data.texture);
 			}
 		}
 
@@ -1114,8 +1107,8 @@ EditorSceneImporterAssimp::_generate_mesh_from_surface_indices(ImportState &stat
 			// Process texture normal map
 			if (AssimpUtils::GetAssimpTexture(state, ai_material, tex_emission_color, filename, path, image_data)) {
 				AssimpUtils::set_texture_mapping_mode(image_data.map_mode, image_data.texture);
-				mat->set_feature(SpatialMaterial::Feature::FEATURE_NORMAL_MAPPING, true);
-				mat->set_texture(SpatialMaterial::TEXTURE_NORMAL, image_data.texture);
+				mat->set_feature(StandardMaterial3D::Feature::FEATURE_NORMAL_MAPPING, true);
+				mat->set_texture(StandardMaterial3D::TEXTURE_NORMAL, image_data.texture);
 			}
 		}
 
@@ -1128,7 +1121,7 @@ EditorSceneImporterAssimp::_generate_mesh_from_surface_indices(ImportState &stat
 			// Process texture normal map
 			if (AssimpUtils::GetAssimpTexture(state, ai_material, tex_metalness, filename, path, image_data)) {
 				AssimpUtils::set_texture_mapping_mode(image_data.map_mode, image_data.texture);
-				mat->set_texture(SpatialMaterial::TEXTURE_METALLIC, image_data.texture);
+				mat->set_texture(StandardMaterial3D::TEXTURE_METALLIC, image_data.texture);
 			}
 		}
 
@@ -1141,7 +1134,7 @@ EditorSceneImporterAssimp::_generate_mesh_from_surface_indices(ImportState &stat
 			// Process texture normal map
 			if (AssimpUtils::GetAssimpTexture(state, ai_material, tex_roughness, filename, path, image_data)) {
 				AssimpUtils::set_texture_mapping_mode(image_data.map_mode, image_data.texture);
-				mat->set_texture(SpatialMaterial::TEXTURE_ROUGHNESS, image_data.texture);
+				mat->set_texture(StandardMaterial3D::TEXTURE_ROUGHNESS, image_data.texture);
 			}
 		}
 
@@ -1154,16 +1147,16 @@ EditorSceneImporterAssimp::_generate_mesh_from_surface_indices(ImportState &stat
 
 			if (AssimpUtils::GetAssimpTexture(state, ai_material, tex_emissive, filename, path, image_data)) {
 				AssimpUtils::set_texture_mapping_mode(image_data.map_mode, image_data.texture);
-				mat->set_feature(SpatialMaterial::FEATURE_EMISSION, true);
-				mat->set_texture(SpatialMaterial::TEXTURE_EMISSION, image_data.texture);
+				mat->set_feature(StandardMaterial3D::FEATURE_EMISSION, true);
+				mat->set_texture(StandardMaterial3D::TEXTURE_EMISSION, image_data.texture);
 			} else {
 				// Process emission textures
 				aiString texture_emissive_path;
 				if (AI_SUCCESS ==
 						ai_material->Get(AI_MATKEY_FBX_MAYA_EMISSION_TEXTURE, AI_PROPERTIES, texture_emissive_path)) {
 					if (AssimpUtils::CreateAssimpTexture(state, texture_emissive_path, filename, path, image_data)) {
-						mat->set_feature(SpatialMaterial::FEATURE_EMISSION, true);
-						mat->set_texture(SpatialMaterial::TEXTURE_EMISSION, image_data.texture);
+						mat->set_feature(StandardMaterial3D::FEATURE_EMISSION, true);
+						mat->set_texture(StandardMaterial3D::TEXTURE_EMISSION, image_data.texture);
 					}
 				} else {
 					float pbr_emission = 0.0f;
@@ -1183,7 +1176,7 @@ EditorSceneImporterAssimp::_generate_mesh_from_surface_indices(ImportState &stat
 			// Process texture normal map
 			if (AssimpUtils::GetAssimpTexture(state, ai_material, tex_specular, filename, path, image_data)) {
 				AssimpUtils::set_texture_mapping_mode(image_data.map_mode, image_data.texture);
-				mat->set_texture(SpatialMaterial::TEXTURE_METALLIC, image_data.texture);
+				mat->set_texture(StandardMaterial3D::TEXTURE_METALLIC, image_data.texture);
 			}
 		}
 
@@ -1196,8 +1189,8 @@ EditorSceneImporterAssimp::_generate_mesh_from_surface_indices(ImportState &stat
 			// Process texture normal map
 			if (AssimpUtils::GetAssimpTexture(state, ai_material, tex_ao_map, filename, path, image_data)) {
 				AssimpUtils::set_texture_mapping_mode(image_data.map_mode, image_data.texture);
-				mat->set_feature(SpatialMaterial::FEATURE_AMBIENT_OCCLUSION, true);
-				mat->set_texture(SpatialMaterial::TEXTURE_AMBIENT_OCCLUSION, image_data.texture);
+				mat->set_feature(StandardMaterial3D::FEATURE_AMBIENT_OCCLUSION, true);
+				mat->set_texture(StandardMaterial3D::TEXTURE_AMBIENT_OCCLUSION, image_data.texture);
 			}
 		}
 
diff --git a/modules/assimp/import_utils.h b/modules/assimp/import_utils.h
index c522b01727..0eb055956b 100644
--- a/modules/assimp/import_utils.h
+++ b/modules/assimp/import_utils.h
@@ -189,7 +189,7 @@ public:
 	}
 
 	/**
-     * Converts aiMatrix4x4 to godot Transform 
+     * Converts aiMatrix4x4 to godot Transform
     */
 	static const Transform assimp_matrix_transform(const aiMatrix4x4 p_matrix) {
 		aiMatrix4x4 matrix = p_matrix;
@@ -322,15 +322,18 @@ public:
 		ERR_FAIL_COND(map_mode == NULL);
 		aiTextureMapMode tex_mode = map_mode[0];
 
-		int32_t flags = Texture::FLAGS_DEFAULT;
+		// FIXME: Commented out during Vulkan port.
+		/*
+		int32_t flags = Texture2D::FLAGS_DEFAULT;
 		if (tex_mode == aiTextureMapMode_Wrap) {
 			//Default
 		} else if (tex_mode == aiTextureMapMode_Clamp) {
-			flags = flags & ~Texture::FLAG_REPEAT;
+			flags = flags & ~Texture2D::FLAG_REPEAT;
 		} else if (tex_mode == aiTextureMapMode_Mirror) {
-			flags = flags | Texture::FLAG_MIRRORED_REPEAT;
+			flags = flags | Texture2D::FLAG_MIRRORED_REPEAT;
 		}
 		texture->set_flags(flags);
+		*/
 	}
 
 	/**
@@ -391,7 +394,7 @@ public:
 			}
 			return Ref<Image>();
 		} else {
-			Ref<Texture> texture = ResourceLoader::load(p_path);
+			Ref<Texture2D> texture = ResourceLoader::load(p_path);
 			ERR_FAIL_COND_V(texture.is_null(), Ref<Image>());
 			Ref<Image> image = texture->get_data();
 			ERR_FAIL_COND_V(image.is_null(), Ref<Image>());
@@ -418,7 +421,8 @@ public:
 			if (image_state.raw_image.is_valid()) {
 				image_state.texture.instance();
 				image_state.texture->create_from_image(image_state.raw_image);
-				image_state.texture->set_storage(ImageTexture::STORAGE_COMPRESS_LOSSY);
+				// FIXME: Commented out during Vulkan port.
+				//image_state.texture->set_storage(ImageTexture::STORAGE_COMPRESS_LOSSY);
 				return true;
 			}
 		}
diff --git a/modules/basis_universal/SCsub b/modules/basis_universal/SCsub
new file mode 100644
index 0000000000..3e179762a5
--- /dev/null
+++ b/modules/basis_universal/SCsub
@@ -0,0 +1,43 @@
+#!/usr/bin/env python
+
+Import('env')
+Import('env_modules')
+
+env_basisu = env_modules.Clone()
+
+# Thirdparty source files
+# Not unbundled so far since not widespread as shared library
+thirdparty_dir = "#thirdparty/basis_universal/"
+tool_sources = [
+	"basisu_astc_decomp.cpp",
+	"basisu_backend.cpp",
+	"basisu_basis_file.cpp",
+	"basisu_comp.cpp",
+	"basisu_enc.cpp",
+	"basisu_etc.cpp",
+	"basisu_frontend.cpp",
+	"basisu_global_selector_palette_helpers.cpp",
+	"basisu_gpu_texture.cpp",
+	"basisu_pvrtc1_4.cpp",
+	"basisu_resample_filters.cpp",
+	"basisu_resampler.cpp",
+	"basisu_ssim.cpp",
+	"basisu_tool.cpp",
+	"lodepng.cpp",
+]
+tool_sources = [thirdparty_dir + file for file in tool_sources]
+transcoder_sources = [thirdparty_dir + "transcoder/basisu_transcoder.cpp"]
+
+env_basisu.Append(CPPPATH=[thirdparty_dir, thirdparty_dir + "transcoder"])
+
+if env['target'] == "debug":
+	env_basisu.Append(CPPFLAGS=["-DBASISU_DEVEL_MESSAGES=1", "-DBASISD_ENABLE_DEBUG_FLAGS=1"])
+
+env_thirdparty = env_basisu.Clone()
+env_thirdparty.disable_warnings()
+if env['tools']:
+    env_thirdparty.add_source_files(env.modules_sources, tool_sources)
+env_thirdparty.add_source_files(env.modules_sources, transcoder_sources)
+
+# Godot source files
+env_basisu.add_source_files(env.modules_sources, "*.cpp")
diff --git a/modules/basis_universal/config.py b/modules/basis_universal/config.py
new file mode 100644
index 0000000000..1c8cd12a2d
--- /dev/null
+++ b/modules/basis_universal/config.py
@@ -0,0 +1,5 @@
+def can_build(env, platform):
+    return True
+
+def configure(env):
+    pass
diff --git a/modules/basis_universal/register_types.cpp b/modules/basis_universal/register_types.cpp
new file mode 100644
index 0000000000..4071f3477a
--- /dev/null
+++ b/modules/basis_universal/register_types.cpp
@@ -0,0 +1,292 @@
+/*************************************************************************/
+/*  register_types.cpp                                                   */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2020 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 "register_types.h"
+
+#include "core/os/os.h"
+#include "servers/visual_server.h"
+#include "texture_basisu.h"
+
+#ifdef TOOLS_ENABLED
+#include <basisu_comp.h>
+#endif
+
+#include <transcoder/basisu_transcoder.h>
+
+enum BasisDecompressFormat {
+	BASIS_DECOMPRESS_RG,
+	BASIS_DECOMPRESS_RGB,
+	BASIS_DECOMPRESS_RGBA,
+	BASIS_DECOMPRESS_RG_AS_RA
+};
+
+//workaround for lack of ETC2 RG
+#define USE_RG_AS_RGBA
+
+basist::etc1_global_selector_codebook *sel_codebook = nullptr;
+
+static PoolVector<uint8_t> basis_universal_packer(const Ref<Image> &p_image, Image::UsedChannels p_channels) {
+
+	PoolVector<uint8_t> budata;
+
+#ifdef TOOLS_ENABLED
+
+	{
+		Ref<Image> image = p_image->duplicate();
+
+		// unfortunately, basis universal does not support compressing supplied mipmaps,
+		// so for the time being, only compressing individual images will have to do.
+
+		if (image->has_mipmaps()) {
+			image->clear_mipmaps();
+		}
+		if (image->get_format() != Image::FORMAT_RGBA8) {
+			image->convert(Image::FORMAT_RGBA8);
+		}
+
+		basisu::image buimg(image->get_width(), image->get_height());
+
+		{
+			PoolVector<uint8_t> vec = image->get_data();
+			PoolVector<uint8_t>::Read r = vec.read();
+
+			memcpy(buimg.get_ptr(), r.ptr(), vec.size());
+		}
+
+		//image->save_png("pepeche.png");
+
+		basisu::basis_compressor_params params;
+		params.m_max_endpoint_clusters = 512;
+		params.m_max_selector_clusters = 512;
+		params.m_multithreading = true;
+		//params.m_no_hybrid_sel_cb = true; //fixme, default on this causes crashes //seems fixed?
+		params.m_pSel_codebook = sel_codebook;
+		//params.m_quality_level = 0;
+		//params.m_disable_hierarchical_endpoint_codebooks = true;
+		//params.m_no_selector_rdo = true;
+		params.m_no_auto_global_sel_pal = true;
+
+		basisu::job_pool jpool(OS::get_singleton()->get_processor_count());
+		params.m_pJob_pool = &jpool;
+
+		params.m_mip_gen = false; //sorry, please some day support provided mipmaps.
+		params.m_source_images.push_back(buimg);
+
+		BasisDecompressFormat decompress_format;
+		params.m_check_for_alpha = false;
+
+		switch (p_channels) {
+			case Image::USED_CHANNELS_L: {
+				decompress_format = BASIS_DECOMPRESS_RGB;
+			} break;
+			case Image::USED_CHANNELS_LA: {
+				params.m_force_alpha = true;
+				decompress_format = BASIS_DECOMPRESS_RGBA;
+			} break;
+			case Image::USED_CHANNELS_R: {
+				decompress_format = BASIS_DECOMPRESS_RGB;
+			} break;
+			case Image::USED_CHANNELS_RG: {
+#ifdef USE_RG_AS_RGBA
+				image->convert_rg_to_ra_rgba8();
+				decompress_format = BASIS_DECOMPRESS_RG_AS_RA;
+
+#else
+
+				params.m_seperate_rg_to_color_alpha = true;
+				decompress_format = BASIS_DECOMPRESS_RG;
+
+#endif
+
+			} break;
+			case Image::USED_CHANNELS_RGB: {
+				decompress_format = BASIS_DECOMPRESS_RGB;
+			} break;
+			case Image::USED_CHANNELS_RGBA: {
+				params.m_force_alpha = true;
+				decompress_format = BASIS_DECOMPRESS_RGBA;
+			} break;
+		}
+
+		basisu::basis_compressor c;
+		c.init(params);
+
+		int buerr = c.process();
+		ERR_FAIL_COND_V(buerr != basisu::basis_compressor::cECSuccess, budata);
+
+		const basisu::uint8_vec &buvec = c.get_output_basis_file();
+		budata.resize(buvec.size() + 4);
+
+		{
+			PoolVector<uint8_t>::Write w = budata.write();
+			uint32_t *decf = (uint32_t *)w.ptr();
+			*decf = decompress_format;
+			memcpy(w.ptr() + 4, &buvec[0], buvec.size());
+		}
+	}
+
+#endif
+	return budata;
+}
+
+static Ref<Image> basis_universal_unpacker(const PoolVector<uint8_t> &p_buffer) {
+	Ref<Image> image;
+
+	PoolVector<uint8_t>::Read r = p_buffer.read();
+	const uint8_t *ptr = r.ptr();
+	int size = p_buffer.size();
+
+	basist::transcoder_texture_format format;
+	Image::Format imgfmt;
+
+	switch (*(uint32_t *)(ptr)) {
+		case BASIS_DECOMPRESS_RG: {
+
+			if (VS::get_singleton()->has_os_feature("rgtc")) {
+				format = basist::cTFBC5; // get this from renderer
+				imgfmt = Image::FORMAT_RGTC_RG;
+			} else if (VS::get_singleton()->has_os_feature("etc2")) {
+				//unfortunately, basis universal does not support
+				//
+				ERR_FAIL_V(image); //unimplemented here
+				//format = basist::cTFETC1; // get this from renderer
+				//imgfmt = Image::FORMAT_RGTC_RG;
+			} else {
+				//decompress
+			}
+		} break;
+		case BASIS_DECOMPRESS_RGB: {
+			if (VS::get_singleton()->has_os_feature("bptc")) {
+				format = basist::cTFBC7_M6_OPAQUE_ONLY; // get this from renderer
+				imgfmt = Image::FORMAT_BPTC_RGBA;
+			} else if (VS::get_singleton()->has_os_feature("s3tc")) {
+				format = basist::cTFBC1; // get this from renderer
+				imgfmt = Image::FORMAT_DXT1;
+			} else if (VS::get_singleton()->has_os_feature("etc")) {
+
+				format = basist::cTFETC1; // get this from renderer
+				imgfmt = Image::FORMAT_ETC;
+			} else {
+				format = basist::cTFBGR565; // get this from renderer
+				imgfmt = Image::FORMAT_RGB565;
+			}
+
+		} break;
+		case BASIS_DECOMPRESS_RGBA: {
+			if (VS::get_singleton()->has_os_feature("bptc")) {
+				format = basist::cTFBC7_M5; // get this from renderer
+				imgfmt = Image::FORMAT_BPTC_RGBA;
+			} else if (VS::get_singleton()->has_os_feature("s3tc")) {
+				format = basist::cTFBC3; // get this from renderer
+				imgfmt = Image::FORMAT_DXT5;
+			} else if (VS::get_singleton()->has_os_feature("etc2")) {
+				format = basist::cTFETC2; // get this from renderer
+				imgfmt = Image::FORMAT_ETC2_RGBA8;
+			} else {
+				//gles2 most likely
+				format = basist::cTFRGBA4444; // get this from renderer
+				imgfmt = Image::FORMAT_RGBA4444;
+			}
+		} break;
+		case BASIS_DECOMPRESS_RG_AS_RA: {
+			if (VS::get_singleton()->has_os_feature("s3tc")) {
+				format = basist::cTFBC3; // get this from renderer
+				imgfmt = Image::FORMAT_DXT5_RA_AS_RG;
+			} else if (VS::get_singleton()->has_os_feature("etc2")) {
+				format = basist::cTFETC2; // get this from renderer
+				imgfmt = Image::FORMAT_ETC2_RGBA8;
+			} else {
+				//gles2 most likely, bad for normalmaps, nothing to do about this.
+				format = basist::cTFRGBA32;
+				imgfmt = Image::FORMAT_RGBA8;
+			}
+		} break;
+	}
+
+	ptr += 4;
+	size -= 4;
+
+	basist::basisu_transcoder tr(NULL);
+
+	ERR_FAIL_COND_V(!tr.validate_header(ptr, size), image);
+
+	basist::basisu_image_info info;
+	tr.get_image_info(ptr, size, info, 0);
+
+	int block_size = basist::basis_get_bytes_per_block(format);
+	PoolVector<uint8_t> gpudata;
+	gpudata.resize(info.m_total_blocks * block_size);
+
+	{
+		PoolVector<uint8_t>::Write w = gpudata.write();
+		uint8_t *dst = w.ptr();
+		for (int i = 0; i < gpudata.size(); i++)
+			dst[i] = 0x00;
+
+		int ofs = 0;
+		tr.start_transcoding(ptr, size);
+		for (uint32_t i = 0; i < info.m_total_levels; i++) {
+
+			basist::basisu_image_level_info level;
+			tr.get_image_level_info(ptr, size, level, 0, i);
+
+			bool ret = tr.transcode_image_level(ptr, size, 0, i, dst + ofs, level.m_total_blocks - i, format);
+			if (!ret) {
+				printf("failed! on level %i\n", i);
+				break;
+			};
+
+			ofs += level.m_total_blocks * block_size;
+		};
+	};
+
+	image.instance();
+	image->create(info.m_width, info.m_height, info.m_total_levels > 1, imgfmt, gpudata);
+
+	return image;
+}
+
+void register_basis_universal_types() {
+#ifdef TOOLS_ENABLED
+	sel_codebook = new basist::etc1_global_selector_codebook(basist::g_global_selector_cb_size, basist::g_global_selector_cb);
+	Image::basis_universal_packer = basis_universal_packer;
+#endif
+	Image::basis_universal_unpacker = basis_universal_unpacker;
+	//ClassDB::register_class<TextureBasisU>();
+}
+
+void unregister_basis_universal_types() {
+
+#ifdef TOOLS_ENABLED
+	delete sel_codebook;
+#endif
+	Image::basis_universal_packer = NULL;
+	Image::basis_universal_unpacker = NULL;
+}
diff --git a/modules/basis_universal/register_types.h b/modules/basis_universal/register_types.h
new file mode 100644
index 0000000000..977374fbfc
--- /dev/null
+++ b/modules/basis_universal/register_types.h
@@ -0,0 +1,32 @@
+/*************************************************************************/
+/*  register_types.h                                                     */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2020 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.                */
+/*************************************************************************/
+
+void register_basis_universal_types();
+void unregister_basis_universal_types();
diff --git a/modules/basis_universal/texture_basisu.cpp b/modules/basis_universal/texture_basisu.cpp
new file mode 100644
index 0000000000..3b3805157b
--- /dev/null
+++ b/modules/basis_universal/texture_basisu.cpp
@@ -0,0 +1,233 @@
+/*************************************************************************/
+/*  texture_basisu.cpp                                                   */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2020 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 "texture_basisu.h"
+#if 0
+#include "core/os/os.h"
+
+#ifdef TOOLS_ENABLED
+#include <basisu_comp.h>
+#endif
+
+#include <transcoder/basisu_transcoder.h>
+
+void TextureBasisU::_bind_methods() {
+
+	ClassDB::bind_method(D_METHOD("set_basisu_data", "data"), &TextureBasisU::set_basisu_data);
+	ClassDB::bind_method(D_METHOD("get_basisu_data"), &TextureBasisU::get_data);
+	ClassDB::bind_method(D_METHOD("import"), &TextureBasisU::import);
+
+	ADD_PROPERTY(PropertyInfo(Variant::POOL_BYTE_ARRAY, "basisu_data"), "set_basisu_data", "get_basisu_data");
+
+};
+
+int TextureBasisU::get_width() const {
+
+	return tex_size.x;
+};
+
+int TextureBasisU::get_height() const {
+
+	return tex_size.y;
+};
+
+RID TextureBasisU::get_rid() const {
+
+	return texture;
+};
+
+
+bool TextureBasisU::has_alpha() const {
+
+	return false;
+};
+
+void TextureBasisU::set_flags(uint32_t p_flags) {
+
+	flags = p_flags;
+	VisualServer::get_singleton()->texture_set_flags(texture, p_flags);
+};
+
+uint32_t TextureBasisU::get_flags() const {
+
+	return flags;
+};
+
+
+void TextureBasisU::set_basisu_data(const PoolVector<uint8_t>& p_data) {
+
+#ifdef TOOLS_ENABLED
+	data = p_data;
+#endif
+
+	PoolVector<uint8_t>::Read r = p_data.read();
+	const void* ptr = r.ptr();
+	int size = p_data.size();
+
+	basist::transcoder_texture_format format;
+	Image::Format imgfmt;
+
+	if (OS::get_singleton()->has_feature("s3tc")) {
+
+		format = basist::cTFBC3; // get this from renderer
+		imgfmt = Image::FORMAT_DXT5;
+
+	} else if (OS::get_singleton()->has_feature("etc2")) {
+
+		format = basist::cTFETC2;
+		imgfmt = Image::FORMAT_ETC2_RGBA8;
+	};
+
+	basist::basisu_transcoder tr(NULL);
+
+	ERR_FAIL_COND(!tr.validate_header(ptr, size));
+
+	basist::basisu_image_info info;
+	tr.get_image_info(ptr, size, info, 0);
+	tex_size = Size2(info.m_width, info.m_height);
+
+	int block_size = basist::basis_get_bytes_per_block(format);
+	PoolVector<uint8_t> gpudata;
+	gpudata.resize(info.m_total_blocks * block_size);
+
+	{
+		PoolVector<uint8_t>::Write w = gpudata.write();
+		uint8_t* dst = w.ptr();
+		for (int i=0; i<gpudata.size(); i++)
+			dst[i] = 0x00;
+
+		int ofs = 0;
+		tr.start_transcoding(ptr, size);
+		for (int i=0; i<info.m_total_levels; i++) {
+
+			basist::basisu_image_level_info level;
+			tr.get_image_level_info(ptr, size, level, 0, i);
+
+			bool ret = tr.transcode_image_level(ptr, size, 0, i, dst + ofs, level.m_total_blocks - i, format);
+			if (!ret) {
+				printf("failed! on level %i\n", i);
+				break;
+			};
+
+			ofs += level.m_total_blocks * block_size;
+		};
+	};
+
+	Ref<Image> img;
+	img.instance();
+	img->create(info.m_width, info.m_height, info.m_total_levels > 1, imgfmt, gpudata);
+
+	VisualServer::get_singleton()->texture_allocate(texture, tex_size.x, tex_size.y, 0, img->get_format(), VS::TEXTURE_TYPE_2D, flags);
+	VisualServer::get_singleton()->texture_set_data(texture, img);
+};
+
+Error TextureBasisU::import(const Ref<Image>& p_img) {
+
+#ifdef TOOLS_ENABLED
+
+	PoolVector<uint8_t> budata;
+
+	{
+		Image::Format format = p_img->get_format();
+		if (format != Image::FORMAT_RGB8 && format != Image::FORMAT_RGBA8) {
+			ERR_FAIL_V(ERR_INVALID_PARAMETER);
+			return ERR_INVALID_PARAMETER;
+		};
+
+		Ref<Image> copy = p_img->duplicate();
+		if (format == Image::FORMAT_RGB8)
+			copy->convert(Image::FORMAT_RGBA8);
+
+		basisu::image buimg(p_img->get_width(), p_img->get_height());
+		int size = p_img->get_width() * p_img->get_height() * 4;
+
+		PoolVector<uint8_t> vec = copy->get_data();
+		{
+			PoolVector<uint8_t>::Read r = vec.read();
+			memcpy(buimg.get_ptr(), r.ptr(), size);
+		};
+
+		basisu::basis_compressor_params params;
+		params.m_max_endpoint_clusters = 512;
+		params.m_max_selector_clusters = 512;
+		params.m_multithreading = true;
+
+		basisu::job_pool jpool(1);
+		params.m_pJob_pool = &jpool;
+
+		params.m_mip_gen = p_img->get_mipmap_count() > 0;
+		params.m_source_images.push_back(buimg);
+
+		basisu::basis_compressor c;
+		c.init(params);
+
+		int buerr = c.process();
+		if (buerr != basisu::basis_compressor::cECSuccess) {
+			ERR_FAIL_V(ERR_INVALID_PARAMETER);
+			return ERR_INVALID_PARAMETER;
+		};
+
+		const basisu::uint8_vec& buvec = c.get_output_basis_file();
+		budata.resize(buvec.size());
+
+		{
+			PoolVector<uint8_t>::Write w = budata.write();
+			memcpy(w.ptr(), &buvec[0], budata.size());
+		};
+	};
+
+	set_basisu_data(budata);
+
+	return OK;
+#else
+
+	return ERR_UNAVAILABLE;
+#endif
+};
+
+
+PoolVector<uint8_t> TextureBasisU::get_basisu_data() const {
+
+	return data;
+};
+
+TextureBasisU::TextureBasisU() {
+
+	flags = FLAGS_DEFAULT;
+	texture = VisualServer::get_singleton()->texture_create();
+};
+
+
+TextureBasisU::~TextureBasisU() {
+
+	VisualServer::get_singleton()->free(texture);
+};
+
+#endif
diff --git a/modules/basis_universal/texture_basisu.h b/modules/basis_universal/texture_basisu.h
new file mode 100644
index 0000000000..8474a63258
--- /dev/null
+++ b/modules/basis_universal/texture_basisu.h
@@ -0,0 +1,77 @@
+/*************************************************************************/
+/*  texture_basisu.h                                                     */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2020 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 "scene/resources/texture.h"
+
+#ifdef TOOLS_ENABLED
+#include <basisu_comp.h>
+#endif
+
+#include <transcoder/basisu_transcoder.h>
+
+#if 0
+class TextureBasisU : public Texture {
+
+	GDCLASS(TextureBasisU, Texture);
+	RES_BASE_EXTENSION("butex");
+
+	RID texture;
+	Size2 tex_size;
+
+	uint32_t flags;
+
+	PoolVector<uint8_t> data;
+
+	static void _bind_methods();
+
+public:
+
+	virtual int get_width() const;
+	virtual int get_height() const;
+	virtual RID get_rid() const;
+	virtual bool has_alpha() const;
+
+	virtual void set_flags(uint32_t p_flags);
+	virtual uint32_t get_flags() const;
+
+
+	Error import(const Ref<Image> &p_img);
+
+	void set_basisu_data(const PoolVector<uint8_t>& p_data);
+
+	PoolVector<uint8_t> get_basisu_data() const;
+	String get_img_path() const;
+
+	TextureBasisU();
+	~TextureBasisU();
+
+};
+
+#endif
diff --git a/modules/bullet/bullet_physics_server.cpp b/modules/bullet/bullet_physics_server.cpp
index e507987297..fceb5d2b4b 100644
--- a/modules/bullet/bullet_physics_server.cpp
+++ b/modules/bullet/bullet_physics_server.cpp
@@ -134,7 +134,7 @@ RID BulletPhysicsServer::shape_create(ShapeType p_shape) {
 }
 
 void BulletPhysicsServer::shape_set_data(RID p_shape, const Variant &p_data) {
-	ShapeBullet *shape = shape_owner.get(p_shape);
+	ShapeBullet *shape = shape_owner.getornull(p_shape);
 	ERR_FAIL_COND(!shape);
 	shape->set_data(p_data);
 }
@@ -144,25 +144,25 @@ void BulletPhysicsServer::shape_set_custom_solver_bias(RID p_shape, real_t p_bia
 }
 
 PhysicsServer::ShapeType BulletPhysicsServer::shape_get_type(RID p_shape) const {
-	ShapeBullet *shape = shape_owner.get(p_shape);
+	ShapeBullet *shape = shape_owner.getornull(p_shape);
 	ERR_FAIL_COND_V(!shape, PhysicsServer::SHAPE_CUSTOM);
 	return shape->get_type();
 }
 
 Variant BulletPhysicsServer::shape_get_data(RID p_shape) const {
-	ShapeBullet *shape = shape_owner.get(p_shape);
+	ShapeBullet *shape = shape_owner.getornull(p_shape);
 	ERR_FAIL_COND_V(!shape, Variant());
 	return shape->get_data();
 }
 
 void BulletPhysicsServer::shape_set_margin(RID p_shape, real_t p_margin) {
-	ShapeBullet *shape = shape_owner.get(p_shape);
+	ShapeBullet *shape = shape_owner.getornull(p_shape);
 	ERR_FAIL_COND(!shape);
 	shape->set_margin(p_margin);
 }
 
 real_t BulletPhysicsServer::shape_get_margin(RID p_shape) const {
-	ShapeBullet *shape = shape_owner.get(p_shape);
+	ShapeBullet *shape = shape_owner.getornull(p_shape);
 	ERR_FAIL_COND_V(!shape, 0.0);
 	return shape->get_margin();
 }
@@ -179,7 +179,7 @@ RID BulletPhysicsServer::space_create() {
 
 void BulletPhysicsServer::space_set_active(RID p_space, bool p_active) {
 
-	SpaceBullet *space = space_owner.get(p_space);
+	SpaceBullet *space = space_owner.getornull(p_space);
 	ERR_FAIL_COND(!space);
 
 	if (space_is_active(p_space) == p_active) {
@@ -196,47 +196,47 @@ void BulletPhysicsServer::space_set_active(RID p_space, bool p_active) {
 }
 
 bool BulletPhysicsServer::space_is_active(RID p_space) const {
-	SpaceBullet *space = space_owner.get(p_space);
+	SpaceBullet *space = space_owner.getornull(p_space);
 	ERR_FAIL_COND_V(!space, false);
 
 	return -1 != active_spaces.find(space);
 }
 
 void BulletPhysicsServer::space_set_param(RID p_space, SpaceParameter p_param, real_t p_value) {
-	SpaceBullet *space = space_owner.get(p_space);
+	SpaceBullet *space = space_owner.getornull(p_space);
 	ERR_FAIL_COND(!space);
 	space->set_param(p_param, p_value);
 }
 
 real_t BulletPhysicsServer::space_get_param(RID p_space, SpaceParameter p_param) const {
-	SpaceBullet *space = space_owner.get(p_space);
+	SpaceBullet *space = space_owner.getornull(p_space);
 	ERR_FAIL_COND_V(!space, 0);
 	return space->get_param(p_param);
 }
 
 PhysicsDirectSpaceState *BulletPhysicsServer::space_get_direct_state(RID p_space) {
-	SpaceBullet *space = space_owner.get(p_space);
+	SpaceBullet *space = space_owner.getornull(p_space);
 	ERR_FAIL_COND_V(!space, NULL);
 
 	return space->get_direct_state();
 }
 
 void BulletPhysicsServer::space_set_debug_contacts(RID p_space, int p_max_contacts) {
-	SpaceBullet *space = space_owner.get(p_space);
+	SpaceBullet *space = space_owner.getornull(p_space);
 	ERR_FAIL_COND(!space);
 
 	space->set_debug_contacts(p_max_contacts);
 }
 
 Vector<Vector3> BulletPhysicsServer::space_get_contacts(RID p_space) const {
-	SpaceBullet *space = space_owner.get(p_space);
+	SpaceBullet *space = space_owner.getornull(p_space);
 	ERR_FAIL_COND_V(!space, Vector<Vector3>());
 
 	return space->get_debug_contacts();
 }
 
 int BulletPhysicsServer::space_get_contact_count(RID p_space) const {
-	SpaceBullet *space = space_owner.get(p_space);
+	SpaceBullet *space = space_owner.getornull(p_space);
 	ERR_FAIL_COND_V(!space, 0);
 
 	return space->get_debug_contact_count();
@@ -250,91 +250,91 @@ RID BulletPhysicsServer::area_create() {
 }
 
 void BulletPhysicsServer::area_set_space(RID p_area, RID p_space) {
-	AreaBullet *area = area_owner.get(p_area);
+	AreaBullet *area = area_owner.getornull(p_area);
 	ERR_FAIL_COND(!area);
 	SpaceBullet *space = NULL;
 	if (p_space.is_valid()) {
-		space = space_owner.get(p_space);
+		space = space_owner.getornull(p_space);
 		ERR_FAIL_COND(!space);
 	}
 	area->set_space(space);
 }
 
 RID BulletPhysicsServer::area_get_space(RID p_area) const {
-	AreaBullet *area = area_owner.get(p_area);
+	AreaBullet *area = area_owner.getornull(p_area);
 	return area->get_space()->get_self();
 }
 
 void BulletPhysicsServer::area_set_space_override_mode(RID p_area, AreaSpaceOverrideMode p_mode) {
-	AreaBullet *area = area_owner.get(p_area);
+	AreaBullet *area = area_owner.getornull(p_area);
 	ERR_FAIL_COND(!area);
 
 	area->set_spOv_mode(p_mode);
 }
 
 PhysicsServer::AreaSpaceOverrideMode BulletPhysicsServer::area_get_space_override_mode(RID p_area) const {
-	AreaBullet *area = area_owner.get(p_area);
+	AreaBullet *area = area_owner.getornull(p_area);
 	ERR_FAIL_COND_V(!area, PhysicsServer::AREA_SPACE_OVERRIDE_DISABLED);
 
 	return area->get_spOv_mode();
 }
 
 void BulletPhysicsServer::area_add_shape(RID p_area, RID p_shape, const Transform &p_transform, bool p_disabled) {
-	AreaBullet *area = area_owner.get(p_area);
+	AreaBullet *area = area_owner.getornull(p_area);
 	ERR_FAIL_COND(!area);
 
-	ShapeBullet *shape = shape_owner.get(p_shape);
+	ShapeBullet *shape = shape_owner.getornull(p_shape);
 	ERR_FAIL_COND(!shape);
 
 	area->add_shape(shape, p_transform, p_disabled);
 }
 
 void BulletPhysicsServer::area_set_shape(RID p_area, int p_shape_idx, RID p_shape) {
-	AreaBullet *area = area_owner.get(p_area);
+	AreaBullet *area = area_owner.getornull(p_area);
 	ERR_FAIL_COND(!area);
 
-	ShapeBullet *shape = shape_owner.get(p_shape);
+	ShapeBullet *shape = shape_owner.getornull(p_shape);
 	ERR_FAIL_COND(!shape);
 
 	area->set_shape(p_shape_idx, shape);
 }
 
 void BulletPhysicsServer::area_set_shape_transform(RID p_area, int p_shape_idx, const Transform &p_transform) {
-	AreaBullet *area = area_owner.get(p_area);
+	AreaBullet *area = area_owner.getornull(p_area);
 	ERR_FAIL_COND(!area);
 
 	area->set_shape_transform(p_shape_idx, p_transform);
 }
 
 int BulletPhysicsServer::area_get_shape_count(RID p_area) const {
-	AreaBullet *area = area_owner.get(p_area);
+	AreaBullet *area = area_owner.getornull(p_area);
 	ERR_FAIL_COND_V(!area, 0);
 
 	return area->get_shape_count();
 }
 
 RID BulletPhysicsServer::area_get_shape(RID p_area, int p_shape_idx) const {
-	AreaBullet *area = area_owner.get(p_area);
+	AreaBullet *area = area_owner.getornull(p_area);
 	ERR_FAIL_COND_V(!area, RID());
 
 	return area->get_shape(p_shape_idx)->get_self();
 }
 
 Transform BulletPhysicsServer::area_get_shape_transform(RID p_area, int p_shape_idx) const {
-	AreaBullet *area = area_owner.get(p_area);
+	AreaBullet *area = area_owner.getornull(p_area);
 	ERR_FAIL_COND_V(!area, Transform());
 
 	return area->get_shape_transform(p_shape_idx);
 }
 
 void BulletPhysicsServer::area_remove_shape(RID p_area, int p_shape_idx) {
-	AreaBullet *area = area_owner.get(p_area);
+	AreaBullet *area = area_owner.getornull(p_area);
 	ERR_FAIL_COND(!area);
 	return area->remove_shape_full(p_shape_idx);
 }
 
 void BulletPhysicsServer::area_clear_shapes(RID p_area) {
-	AreaBullet *area = area_owner.get(p_area);
+	AreaBullet *area = area_owner.getornull(p_area);
 	ERR_FAIL_COND(!area);
 
 	for (int i = area->get_shape_count(); 0 < i; --i)
@@ -342,7 +342,7 @@ void BulletPhysicsServer::area_clear_shapes(RID p_area) {
 }
 
 void BulletPhysicsServer::area_set_shape_disabled(RID p_area, int p_shape_idx, bool p_disabled) {
-	AreaBullet *area = area_owner.get(p_area);
+	AreaBullet *area = area_owner.getornull(p_area);
 	ERR_FAIL_COND(!area);
 
 	area->set_shape_disabled(p_shape_idx, p_disabled);
@@ -352,7 +352,7 @@ void BulletPhysicsServer::area_attach_object_instance_id(RID p_area, ObjectID p_
 	if (space_owner.owns(p_area)) {
 		return;
 	}
-	AreaBullet *area = area_owner.get(p_area);
+	AreaBullet *area = area_owner.getornull(p_area);
 	ERR_FAIL_COND(!area);
 	area->set_instance_id(p_id);
 }
@@ -361,20 +361,20 @@ ObjectID BulletPhysicsServer::area_get_object_instance_id(RID p_area) const {
 	if (space_owner.owns(p_area)) {
 		return 0;
 	}
-	AreaBullet *area = area_owner.get(p_area);
+	AreaBullet *area = area_owner.getornull(p_area);
 	ERR_FAIL_COND_V(!area, ObjectID());
 	return area->get_instance_id();
 }
 
 void BulletPhysicsServer::area_set_param(RID p_area, AreaParameter p_param, const Variant &p_value) {
 	if (space_owner.owns(p_area)) {
-		SpaceBullet *space = space_owner.get(p_area);
+		SpaceBullet *space = space_owner.getornull(p_area);
 		if (space) {
 			space->set_param(p_param, p_value);
 		}
 	} else {
 
-		AreaBullet *area = area_owner.get(p_area);
+		AreaBullet *area = area_owner.getornull(p_area);
 		ERR_FAIL_COND(!area);
 
 		area->set_param(p_param, p_value);
@@ -383,10 +383,10 @@ void BulletPhysicsServer::area_set_param(RID p_area, AreaParameter p_param, cons
 
 Variant BulletPhysicsServer::area_get_param(RID p_area, AreaParameter p_param) const {
 	if (space_owner.owns(p_area)) {
-		SpaceBullet *space = space_owner.get(p_area);
+		SpaceBullet *space = space_owner.getornull(p_area);
 		return space->get_param(p_param);
 	} else {
-		AreaBullet *area = area_owner.get(p_area);
+		AreaBullet *area = area_owner.getornull(p_area);
 		ERR_FAIL_COND_V(!area, Variant());
 
 		return area->get_param(p_param);
@@ -394,58 +394,58 @@ Variant BulletPhysicsServer::area_get_param(RID p_area, AreaParameter p_param) c
 }
 
 void BulletPhysicsServer::area_set_transform(RID p_area, const Transform &p_transform) {
-	AreaBullet *area = area_owner.get(p_area);
+	AreaBullet *area = area_owner.getornull(p_area);
 	ERR_FAIL_COND(!area);
 	area->set_transform(p_transform);
 }
 
 Transform BulletPhysicsServer::area_get_transform(RID p_area) const {
-	AreaBullet *area = area_owner.get(p_area);
+	AreaBullet *area = area_owner.getornull(p_area);
 	ERR_FAIL_COND_V(!area, Transform());
 	return area->get_transform();
 }
 
 void BulletPhysicsServer::area_set_collision_mask(RID p_area, uint32_t p_mask) {
-	AreaBullet *area = area_owner.get(p_area);
+	AreaBullet *area = area_owner.getornull(p_area);
 	ERR_FAIL_COND(!area);
 	area->set_collision_mask(p_mask);
 }
 
 void BulletPhysicsServer::area_set_collision_layer(RID p_area, uint32_t p_layer) {
-	AreaBullet *area = area_owner.get(p_area);
+	AreaBullet *area = area_owner.getornull(p_area);
 	ERR_FAIL_COND(!area);
 	area->set_collision_layer(p_layer);
 }
 
 void BulletPhysicsServer::area_set_monitorable(RID p_area, bool p_monitorable) {
-	AreaBullet *area = area_owner.get(p_area);
+	AreaBullet *area = area_owner.getornull(p_area);
 	ERR_FAIL_COND(!area);
 
 	area->set_monitorable(p_monitorable);
 }
 
 void BulletPhysicsServer::area_set_monitor_callback(RID p_area, Object *p_receiver, const StringName &p_method) {
-	AreaBullet *area = area_owner.get(p_area);
+	AreaBullet *area = area_owner.getornull(p_area);
 	ERR_FAIL_COND(!area);
 
 	area->set_event_callback(CollisionObjectBullet::TYPE_RIGID_BODY, p_receiver ? p_receiver->get_instance_id() : 0, p_method);
 }
 
 void BulletPhysicsServer::area_set_area_monitor_callback(RID p_area, Object *p_receiver, const StringName &p_method) {
-	AreaBullet *area = area_owner.get(p_area);
+	AreaBullet *area = area_owner.getornull(p_area);
 	ERR_FAIL_COND(!area);
 
 	area->set_event_callback(CollisionObjectBullet::TYPE_AREA, p_receiver ? p_receiver->get_instance_id() : 0, p_method);
 }
 
 void BulletPhysicsServer::area_set_ray_pickable(RID p_area, bool p_enable) {
-	AreaBullet *area = area_owner.get(p_area);
+	AreaBullet *area = area_owner.getornull(p_area);
 	ERR_FAIL_COND(!area);
 	area->set_ray_pickable(p_enable);
 }
 
 bool BulletPhysicsServer::area_is_ray_pickable(RID p_area) const {
-	AreaBullet *area = area_owner.get(p_area);
+	AreaBullet *area = area_owner.getornull(p_area);
 	ERR_FAIL_COND_V(!area, false);
 	return area->is_ray_pickable();
 }
@@ -461,12 +461,12 @@ RID BulletPhysicsServer::body_create(BodyMode p_mode, bool p_init_sleeping) {
 }
 
 void BulletPhysicsServer::body_set_space(RID p_body, RID p_space) {
-	RigidBodyBullet *body = rigid_body_owner.get(p_body);
+	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 	SpaceBullet *space = NULL;
 
 	if (p_space.is_valid()) {
-		space = space_owner.get(p_space);
+		space = space_owner.getornull(p_space);
 		ERR_FAIL_COND(!space);
 	}
 
@@ -477,7 +477,7 @@ void BulletPhysicsServer::body_set_space(RID p_body, RID p_space) {
 }
 
 RID BulletPhysicsServer::body_get_space(RID p_body) const {
-	RigidBodyBullet *body = rigid_body_owner.get(p_body);
+	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
 	ERR_FAIL_COND_V(!body, RID());
 
 	SpaceBullet *space = body->get_space();
@@ -487,53 +487,53 @@ RID BulletPhysicsServer::body_get_space(RID p_body) const {
 }
 
 void BulletPhysicsServer::body_set_mode(RID p_body, PhysicsServer::BodyMode p_mode) {
-	RigidBodyBullet *body = rigid_body_owner.get(p_body);
+	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 	body->set_mode(p_mode);
 }
 
 PhysicsServer::BodyMode BulletPhysicsServer::body_get_mode(RID p_body) const {
-	RigidBodyBullet *body = rigid_body_owner.get(p_body);
+	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
 	ERR_FAIL_COND_V(!body, BODY_MODE_STATIC);
 	return body->get_mode();
 }
 
 void BulletPhysicsServer::body_add_shape(RID p_body, RID p_shape, const Transform &p_transform, bool p_disabled) {
 
-	RigidBodyBullet *body = rigid_body_owner.get(p_body);
+	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 
-	ShapeBullet *shape = shape_owner.get(p_shape);
+	ShapeBullet *shape = shape_owner.getornull(p_shape);
 	ERR_FAIL_COND(!shape);
 
 	body->add_shape(shape, p_transform, p_disabled);
 }
 
 void BulletPhysicsServer::body_set_shape(RID p_body, int p_shape_idx, RID p_shape) {
-	RigidBodyBullet *body = rigid_body_owner.get(p_body);
+	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 
-	ShapeBullet *shape = shape_owner.get(p_shape);
+	ShapeBullet *shape = shape_owner.getornull(p_shape);
 	ERR_FAIL_COND(!shape);
 
 	body->set_shape(p_shape_idx, shape);
 }
 
 void BulletPhysicsServer::body_set_shape_transform(RID p_body, int p_shape_idx, const Transform &p_transform) {
-	RigidBodyBullet *body = rigid_body_owner.get(p_body);
+	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_shape_transform(p_shape_idx, p_transform);
 }
 
 int BulletPhysicsServer::body_get_shape_count(RID p_body) const {
-	RigidBodyBullet *body = rigid_body_owner.get(p_body);
+	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
 	ERR_FAIL_COND_V(!body, 0);
 	return body->get_shape_count();
 }
 
 RID BulletPhysicsServer::body_get_shape(RID p_body, int p_shape_idx) const {
-	RigidBodyBullet *body = rigid_body_owner.get(p_body);
+	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
 	ERR_FAIL_COND_V(!body, RID());
 
 	ShapeBullet *shape = body->get_shape(p_shape_idx);
@@ -543,27 +543,27 @@ RID BulletPhysicsServer::body_get_shape(RID p_body, int p_shape_idx) const {
 }
 
 Transform BulletPhysicsServer::body_get_shape_transform(RID p_body, int p_shape_idx) const {
-	RigidBodyBullet *body = rigid_body_owner.get(p_body);
+	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
 	ERR_FAIL_COND_V(!body, Transform());
 	return body->get_shape_transform(p_shape_idx);
 }
 
 void BulletPhysicsServer::body_set_shape_disabled(RID p_body, int p_shape_idx, bool p_disabled) {
-	RigidBodyBullet *body = rigid_body_owner.get(p_body);
+	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_shape_disabled(p_shape_idx, p_disabled);
 }
 
 void BulletPhysicsServer::body_remove_shape(RID p_body, int p_shape_idx) {
-	RigidBodyBullet *body = rigid_body_owner.get(p_body);
+	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->remove_shape_full(p_shape_idx);
 }
 
 void BulletPhysicsServer::body_clear_shapes(RID p_body) {
-	RigidBodyBullet *body = rigid_body_owner.get(p_body);
+	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->remove_all_shapes();
@@ -584,42 +584,42 @@ uint32_t BulletPhysicsServer::body_get_object_instance_id(RID p_body) const {
 }
 
 void BulletPhysicsServer::body_set_enable_continuous_collision_detection(RID p_body, bool p_enable) {
-	RigidBodyBullet *body = rigid_body_owner.get(p_body);
+	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_continuous_collision_detection(p_enable);
 }
 
 bool BulletPhysicsServer::body_is_continuous_collision_detection_enabled(RID p_body) const {
-	RigidBodyBullet *body = rigid_body_owner.get(p_body);
+	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
 	ERR_FAIL_COND_V(!body, false);
 
 	return body->is_continuous_collision_detection_enabled();
 }
 
 void BulletPhysicsServer::body_set_collision_layer(RID p_body, uint32_t p_layer) {
-	RigidBodyBullet *body = rigid_body_owner.get(p_body);
+	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_collision_layer(p_layer);
 }
 
 uint32_t BulletPhysicsServer::body_get_collision_layer(RID p_body) const {
-	const RigidBodyBullet *body = rigid_body_owner.get(p_body);
+	const RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
 	ERR_FAIL_COND_V(!body, 0);
 
 	return body->get_collision_layer();
 }
 
 void BulletPhysicsServer::body_set_collision_mask(RID p_body, uint32_t p_mask) {
-	RigidBodyBullet *body = rigid_body_owner.get(p_body);
+	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_collision_mask(p_mask);
 }
 
 uint32_t BulletPhysicsServer::body_get_collision_mask(RID p_body) const {
-	RigidBodyBullet *body = rigid_body_owner.get(p_body);
+	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
 	ERR_FAIL_COND_V(!body, 0);
 
 	return body->get_collision_mask();
@@ -635,21 +635,21 @@ uint32_t BulletPhysicsServer::body_get_user_flags(RID p_body) const {
 }
 
 void BulletPhysicsServer::body_set_param(RID p_body, BodyParameter p_param, float p_value) {
-	RigidBodyBullet *body = rigid_body_owner.get(p_body);
+	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_param(p_param, p_value);
 }
 
 float BulletPhysicsServer::body_get_param(RID p_body, BodyParameter p_param) const {
-	RigidBodyBullet *body = rigid_body_owner.get(p_body);
+	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
 	ERR_FAIL_COND_V(!body, 0);
 
 	return body->get_param(p_param);
 }
 
 void BulletPhysicsServer::body_set_kinematic_safe_margin(RID p_body, real_t p_margin) {
-	RigidBodyBullet *body = rigid_body_owner.get(p_body);
+	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 
 	if (body->get_kinematic_utilities()) {
@@ -659,7 +659,7 @@ void BulletPhysicsServer::body_set_kinematic_safe_margin(RID p_body, real_t p_ma
 }
 
 real_t BulletPhysicsServer::body_get_kinematic_safe_margin(RID p_body) const {
-	RigidBodyBullet *body = rigid_body_owner.get(p_body);
+	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
 	ERR_FAIL_COND_V(!body, 0);
 
 	if (body->get_kinematic_utilities()) {
@@ -671,90 +671,90 @@ real_t BulletPhysicsServer::body_get_kinematic_safe_margin(RID p_body) const {
 }
 
 void BulletPhysicsServer::body_set_state(RID p_body, BodyState p_state, const Variant &p_variant) {
-	RigidBodyBullet *body = rigid_body_owner.get(p_body);
+	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_state(p_state, p_variant);
 }
 
 Variant BulletPhysicsServer::body_get_state(RID p_body, BodyState p_state) const {
-	RigidBodyBullet *body = rigid_body_owner.get(p_body);
+	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
 	ERR_FAIL_COND_V(!body, Variant());
 
 	return body->get_state(p_state);
 }
 
 void BulletPhysicsServer::body_set_applied_force(RID p_body, const Vector3 &p_force) {
-	RigidBodyBullet *body = rigid_body_owner.get(p_body);
+	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_applied_force(p_force);
 }
 
 Vector3 BulletPhysicsServer::body_get_applied_force(RID p_body) const {
-	RigidBodyBullet *body = rigid_body_owner.get(p_body);
+	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
 	ERR_FAIL_COND_V(!body, Vector3());
 	return body->get_applied_force();
 }
 
 void BulletPhysicsServer::body_set_applied_torque(RID p_body, const Vector3 &p_torque) {
-	RigidBodyBullet *body = rigid_body_owner.get(p_body);
+	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_applied_torque(p_torque);
 }
 
 Vector3 BulletPhysicsServer::body_get_applied_torque(RID p_body) const {
-	RigidBodyBullet *body = rigid_body_owner.get(p_body);
+	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
 	ERR_FAIL_COND_V(!body, Vector3());
 
 	return body->get_applied_torque();
 }
 
 void BulletPhysicsServer::body_add_central_force(RID p_body, const Vector3 &p_force) {
-	RigidBodyBullet *body = rigid_body_owner.get(p_body);
+	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->apply_central_force(p_force);
 }
 
 void BulletPhysicsServer::body_add_force(RID p_body, const Vector3 &p_force, const Vector3 &p_pos) {
-	RigidBodyBullet *body = rigid_body_owner.get(p_body);
+	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->apply_force(p_force, p_pos);
 }
 
 void BulletPhysicsServer::body_add_torque(RID p_body, const Vector3 &p_torque) {
-	RigidBodyBullet *body = rigid_body_owner.get(p_body);
+	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->apply_torque(p_torque);
 }
 
 void BulletPhysicsServer::body_apply_central_impulse(RID p_body, const Vector3 &p_impulse) {
-	RigidBodyBullet *body = rigid_body_owner.get(p_body);
+	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->apply_central_impulse(p_impulse);
 }
 
 void BulletPhysicsServer::body_apply_impulse(RID p_body, const Vector3 &p_pos, const Vector3 &p_impulse) {
-	RigidBodyBullet *body = rigid_body_owner.get(p_body);
+	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->apply_impulse(p_pos, p_impulse);
 }
 
 void BulletPhysicsServer::body_apply_torque_impulse(RID p_body, const Vector3 &p_impulse) {
-	RigidBodyBullet *body = rigid_body_owner.get(p_body);
+	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->apply_torque_impulse(p_impulse);
 }
 
 void BulletPhysicsServer::body_set_axis_velocity(RID p_body, const Vector3 &p_axis_velocity) {
-	RigidBodyBullet *body = rigid_body_owner.get(p_body);
+	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 
 	Vector3 v = body->get_linear_velocity();
@@ -765,39 +765,39 @@ void BulletPhysicsServer::body_set_axis_velocity(RID p_body, const Vector3 &p_ax
 }
 
 void BulletPhysicsServer::body_set_axis_lock(RID p_body, BodyAxis p_axis, bool p_lock) {
-	RigidBodyBullet *body = rigid_body_owner.get(p_body);
+	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 	body->set_axis_lock(p_axis, p_lock);
 }
 
 bool BulletPhysicsServer::body_is_axis_locked(RID p_body, BodyAxis p_axis) const {
-	const RigidBodyBullet *body = rigid_body_owner.get(p_body);
+	const RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
 	ERR_FAIL_COND_V(!body, 0);
 	return body->is_axis_locked(p_axis);
 }
 
 void BulletPhysicsServer::body_add_collision_exception(RID p_body, RID p_body_b) {
-	RigidBodyBullet *body = rigid_body_owner.get(p_body);
+	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 
-	RigidBodyBullet *other_body = rigid_body_owner.get(p_body_b);
+	RigidBodyBullet *other_body = rigid_body_owner.getornull(p_body_b);
 	ERR_FAIL_COND(!other_body);
 
 	body->add_collision_exception(other_body);
 }
 
 void BulletPhysicsServer::body_remove_collision_exception(RID p_body, RID p_body_b) {
-	RigidBodyBullet *body = rigid_body_owner.get(p_body);
+	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 
-	RigidBodyBullet *other_body = rigid_body_owner.get(p_body_b);
+	RigidBodyBullet *other_body = rigid_body_owner.getornull(p_body_b);
 	ERR_FAIL_COND(!other_body);
 
 	body->remove_collision_exception(other_body);
 }
 
 void BulletPhysicsServer::body_get_collision_exceptions(RID p_body, List<RID> *p_exceptions) {
-	RigidBodyBullet *body = rigid_body_owner.get(p_body);
+	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 	for (int i = 0; i < body->get_exceptions().size(); i++) {
 		p_exceptions->push_back(body->get_exceptions()[i]);
@@ -805,14 +805,14 @@ void BulletPhysicsServer::body_get_collision_exceptions(RID p_body, List<RID> *p
 }
 
 void BulletPhysicsServer::body_set_max_contacts_reported(RID p_body, int p_contacts) {
-	RigidBodyBullet *body = rigid_body_owner.get(p_body);
+	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_max_collisions_detection(p_contacts);
 }
 
 int BulletPhysicsServer::body_get_max_contacts_reported(RID p_body) const {
-	RigidBodyBullet *body = rigid_body_owner.get(p_body);
+	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
 	ERR_FAIL_COND_V(!body, 0);
 
 	return body->get_max_collisions_detection();
@@ -828,45 +828,45 @@ float BulletPhysicsServer::body_get_contacts_reported_depth_threshold(RID p_body
 }
 
 void BulletPhysicsServer::body_set_omit_force_integration(RID p_body, bool p_omit) {
-	RigidBodyBullet *body = rigid_body_owner.get(p_body);
+	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_omit_forces_integration(p_omit);
 }
 
 bool BulletPhysicsServer::body_is_omitting_force_integration(RID p_body) const {
-	RigidBodyBullet *body = rigid_body_owner.get(p_body);
+	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
 	ERR_FAIL_COND_V(!body, false);
 
 	return body->get_omit_forces_integration();
 }
 
 void BulletPhysicsServer::body_set_force_integration_callback(RID p_body, Object *p_receiver, const StringName &p_method, const Variant &p_udata) {
-	RigidBodyBullet *body = rigid_body_owner.get(p_body);
+	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 	body->set_force_integration_callback(p_receiver ? p_receiver->get_instance_id() : ObjectID(0), p_method, p_udata);
 }
 
 void BulletPhysicsServer::body_set_ray_pickable(RID p_body, bool p_enable) {
-	RigidBodyBullet *body = rigid_body_owner.get(p_body);
+	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 	body->set_ray_pickable(p_enable);
 }
 
 bool BulletPhysicsServer::body_is_ray_pickable(RID p_body) const {
-	RigidBodyBullet *body = rigid_body_owner.get(p_body);
+	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
 	ERR_FAIL_COND_V(!body, false);
 	return body->is_ray_pickable();
 }
 
 PhysicsDirectBodyState *BulletPhysicsServer::body_get_direct_state(RID p_body) {
-	RigidBodyBullet *body = rigid_body_owner.get(p_body);
+	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
 	ERR_FAIL_COND_V(!body, NULL);
 	return BulletPhysicsDirectBodyState::get_singleton(body);
 }
 
 bool BulletPhysicsServer::body_test_motion(RID p_body, const Transform &p_from, const Vector3 &p_motion, bool p_infinite_inertia, MotionResult *r_result, bool p_exclude_raycast_shapes) {
-	RigidBodyBullet *body = rigid_body_owner.get(p_body);
+	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
 	ERR_FAIL_COND_V(!body, false);
 	ERR_FAIL_COND_V(!body->get_space(), false);
 
@@ -874,7 +874,7 @@ bool BulletPhysicsServer::body_test_motion(RID p_body, const Transform &p_from,
 }
 
 int BulletPhysicsServer::body_test_ray_separation(RID p_body, const Transform &p_transform, bool p_infinite_inertia, Vector3 &r_recover_motion, SeparationResult *r_results, int p_result_max, float p_margin) {
-	RigidBodyBullet *body = rigid_body_owner.get(p_body);
+	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
 	ERR_FAIL_COND_V(!body, 0);
 	ERR_FAIL_COND_V(!body->get_space(), 0);
 
@@ -891,19 +891,19 @@ RID BulletPhysicsServer::soft_body_create(bool p_init_sleeping) {
 }
 
 void BulletPhysicsServer::soft_body_update_visual_server(RID p_body, class SoftBodyVisualServerHandler *p_visual_server_handler) {
-	SoftBodyBullet *body = soft_body_owner.get(p_body);
+	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->update_visual_server(p_visual_server_handler);
 }
 
 void BulletPhysicsServer::soft_body_set_space(RID p_body, RID p_space) {
-	SoftBodyBullet *body = soft_body_owner.get(p_body);
+	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 	SpaceBullet *space = NULL;
 
 	if (p_space.is_valid()) {
-		space = space_owner.get(p_space);
+		space = space_owner.getornull(p_space);
 		ERR_FAIL_COND(!space);
 	}
 
@@ -914,7 +914,7 @@ void BulletPhysicsServer::soft_body_set_space(RID p_body, RID p_space) {
 }
 
 RID BulletPhysicsServer::soft_body_get_space(RID p_body) const {
-	SoftBodyBullet *body = soft_body_owner.get(p_body);
+	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
 	ERR_FAIL_COND_V(!body, RID());
 
 	SpaceBullet *space = body->get_space();
@@ -924,47 +924,47 @@ RID BulletPhysicsServer::soft_body_get_space(RID p_body) const {
 }
 
 void BulletPhysicsServer::soft_body_set_mesh(RID p_body, const REF &p_mesh) {
-	SoftBodyBullet *body = soft_body_owner.get(p_body);
+	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_soft_mesh(p_mesh);
 }
 
 void BulletPhysicsServer::soft_body_set_collision_layer(RID p_body, uint32_t p_layer) {
-	SoftBodyBullet *body = soft_body_owner.get(p_body);
+	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_collision_layer(p_layer);
 }
 
 uint32_t BulletPhysicsServer::soft_body_get_collision_layer(RID p_body) const {
-	const SoftBodyBullet *body = soft_body_owner.get(p_body);
+	const SoftBodyBullet *body = soft_body_owner.getornull(p_body);
 	ERR_FAIL_COND_V(!body, 0);
 
 	return body->get_collision_layer();
 }
 
 void BulletPhysicsServer::soft_body_set_collision_mask(RID p_body, uint32_t p_mask) {
-	SoftBodyBullet *body = soft_body_owner.get(p_body);
+	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_collision_mask(p_mask);
 }
 
 uint32_t BulletPhysicsServer::soft_body_get_collision_mask(RID p_body) const {
-	const SoftBodyBullet *body = soft_body_owner.get(p_body);
+	const SoftBodyBullet *body = soft_body_owner.getornull(p_body);
 	ERR_FAIL_COND_V(!body, 0);
 
 	return body->get_collision_mask();
 }
 
 void BulletPhysicsServer::soft_body_add_collision_exception(RID p_body, RID p_body_b) {
-	SoftBodyBullet *body = soft_body_owner.get(p_body);
+	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 
-	CollisionObjectBullet *other_body = rigid_body_owner.get(p_body_b);
+	CollisionObjectBullet *other_body = rigid_body_owner.getornull(p_body_b);
 	if (!other_body) {
-		other_body = soft_body_owner.get(p_body_b);
+		other_body = soft_body_owner.getornull(p_body_b);
 	}
 	ERR_FAIL_COND(!other_body);
 
@@ -972,12 +972,12 @@ void BulletPhysicsServer::soft_body_add_collision_exception(RID p_body, RID p_bo
 }
 
 void BulletPhysicsServer::soft_body_remove_collision_exception(RID p_body, RID p_body_b) {
-	SoftBodyBullet *body = soft_body_owner.get(p_body);
+	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 
-	CollisionObjectBullet *other_body = rigid_body_owner.get(p_body_b);
+	CollisionObjectBullet *other_body = rigid_body_owner.getornull(p_body_b);
 	if (!other_body) {
-		other_body = soft_body_owner.get(p_body_b);
+		other_body = soft_body_owner.getornull(p_body_b);
 	}
 	ERR_FAIL_COND(!other_body);
 
@@ -985,7 +985,7 @@ void BulletPhysicsServer::soft_body_remove_collision_exception(RID p_body, RID p
 }
 
 void BulletPhysicsServer::soft_body_get_collision_exceptions(RID p_body, List<RID> *p_exceptions) {
-	SoftBodyBullet *body = soft_body_owner.get(p_body);
+	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 	for (int i = 0; i < body->get_exceptions().size(); i++) {
 		p_exceptions->push_back(body->get_exceptions()[i]);
@@ -1004,14 +1004,14 @@ Variant BulletPhysicsServer::soft_body_get_state(RID p_body, BodyState p_state)
 }
 
 void BulletPhysicsServer::soft_body_set_transform(RID p_body, const Transform &p_transform) {
-	SoftBodyBullet *body = soft_body_owner.get(p_body);
+	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_soft_transform(p_transform);
 }
 
 Vector3 BulletPhysicsServer::soft_body_get_vertex_position(RID p_body, int vertex_index) const {
-	const SoftBodyBullet *body = soft_body_owner.get(p_body);
+	const SoftBodyBullet *body = soft_body_owner.getornull(p_body);
 	Vector3 pos;
 	ERR_FAIL_COND_V(!body, pos);
 
@@ -1020,133 +1020,133 @@ Vector3 BulletPhysicsServer::soft_body_get_vertex_position(RID p_body, int verte
 }
 
 void BulletPhysicsServer::soft_body_set_ray_pickable(RID p_body, bool p_enable) {
-	SoftBodyBullet *body = soft_body_owner.get(p_body);
+	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 	body->set_ray_pickable(p_enable);
 }
 
 bool BulletPhysicsServer::soft_body_is_ray_pickable(RID p_body) const {
-	SoftBodyBullet *body = soft_body_owner.get(p_body);
+	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
 	ERR_FAIL_COND_V(!body, false);
 	return body->is_ray_pickable();
 }
 
 void BulletPhysicsServer::soft_body_set_simulation_precision(RID p_body, int p_simulation_precision) {
-	SoftBodyBullet *body = soft_body_owner.get(p_body);
+	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 	body->set_simulation_precision(p_simulation_precision);
 }
 
 int BulletPhysicsServer::soft_body_get_simulation_precision(RID p_body) {
-	SoftBodyBullet *body = soft_body_owner.get(p_body);
+	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
 	ERR_FAIL_COND_V(!body, 0.f);
 	return body->get_simulation_precision();
 }
 
 void BulletPhysicsServer::soft_body_set_total_mass(RID p_body, real_t p_total_mass) {
-	SoftBodyBullet *body = soft_body_owner.get(p_body);
+	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 	body->set_total_mass(p_total_mass);
 }
 
 real_t BulletPhysicsServer::soft_body_get_total_mass(RID p_body) {
-	SoftBodyBullet *body = soft_body_owner.get(p_body);
+	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
 	ERR_FAIL_COND_V(!body, 0.f);
 	return body->get_total_mass();
 }
 
 void BulletPhysicsServer::soft_body_set_linear_stiffness(RID p_body, real_t p_stiffness) {
-	SoftBodyBullet *body = soft_body_owner.get(p_body);
+	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 	body->set_linear_stiffness(p_stiffness);
 }
 
 real_t BulletPhysicsServer::soft_body_get_linear_stiffness(RID p_body) {
-	SoftBodyBullet *body = soft_body_owner.get(p_body);
+	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
 	ERR_FAIL_COND_V(!body, 0.f);
 	return body->get_linear_stiffness();
 }
 
 void BulletPhysicsServer::soft_body_set_areaAngular_stiffness(RID p_body, real_t p_stiffness) {
-	SoftBodyBullet *body = soft_body_owner.get(p_body);
+	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 	body->set_areaAngular_stiffness(p_stiffness);
 }
 
 real_t BulletPhysicsServer::soft_body_get_areaAngular_stiffness(RID p_body) {
-	SoftBodyBullet *body = soft_body_owner.get(p_body);
+	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
 	ERR_FAIL_COND_V(!body, 0.f);
 	return body->get_areaAngular_stiffness();
 }
 
 void BulletPhysicsServer::soft_body_set_volume_stiffness(RID p_body, real_t p_stiffness) {
-	SoftBodyBullet *body = soft_body_owner.get(p_body);
+	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 	body->set_volume_stiffness(p_stiffness);
 }
 
 real_t BulletPhysicsServer::soft_body_get_volume_stiffness(RID p_body) {
-	SoftBodyBullet *body = soft_body_owner.get(p_body);
+	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
 	ERR_FAIL_COND_V(!body, 0.f);
 	return body->get_volume_stiffness();
 }
 
 void BulletPhysicsServer::soft_body_set_pressure_coefficient(RID p_body, real_t p_pressure_coefficient) {
-	SoftBodyBullet *body = soft_body_owner.get(p_body);
+	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 	body->set_pressure_coefficient(p_pressure_coefficient);
 }
 
 real_t BulletPhysicsServer::soft_body_get_pressure_coefficient(RID p_body) {
-	SoftBodyBullet *body = soft_body_owner.get(p_body);
+	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
 	ERR_FAIL_COND_V(!body, 0.f);
 	return body->get_pressure_coefficient();
 }
 
 void BulletPhysicsServer::soft_body_set_pose_matching_coefficient(RID p_body, real_t p_pose_matching_coefficient) {
-	SoftBodyBullet *body = soft_body_owner.get(p_body);
+	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 	return body->set_pose_matching_coefficient(p_pose_matching_coefficient);
 }
 
 real_t BulletPhysicsServer::soft_body_get_pose_matching_coefficient(RID p_body) {
-	SoftBodyBullet *body = soft_body_owner.get(p_body);
+	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
 	ERR_FAIL_COND_V(!body, 0.f);
 	return body->get_pose_matching_coefficient();
 }
 
 void BulletPhysicsServer::soft_body_set_damping_coefficient(RID p_body, real_t p_damping_coefficient) {
-	SoftBodyBullet *body = soft_body_owner.get(p_body);
+	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 	body->set_damping_coefficient(p_damping_coefficient);
 }
 
 real_t BulletPhysicsServer::soft_body_get_damping_coefficient(RID p_body) {
-	SoftBodyBullet *body = soft_body_owner.get(p_body);
+	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
 	ERR_FAIL_COND_V(!body, 0.f);
 	return body->get_damping_coefficient();
 }
 
 void BulletPhysicsServer::soft_body_set_drag_coefficient(RID p_body, real_t p_drag_coefficient) {
-	SoftBodyBullet *body = soft_body_owner.get(p_body);
+	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 	body->set_drag_coefficient(p_drag_coefficient);
 }
 
 real_t BulletPhysicsServer::soft_body_get_drag_coefficient(RID p_body) {
-	SoftBodyBullet *body = soft_body_owner.get(p_body);
+	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
 	ERR_FAIL_COND_V(!body, 0.f);
 	return body->get_drag_coefficient();
 }
 
 void BulletPhysicsServer::soft_body_move_point(RID p_body, int p_point_index, const Vector3 &p_global_position) {
-	SoftBodyBullet *body = soft_body_owner.get(p_body);
+	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 	body->set_node_position(p_point_index, p_global_position);
 }
 
 Vector3 BulletPhysicsServer::soft_body_get_point_global_position(RID p_body, int p_point_index) {
-	SoftBodyBullet *body = soft_body_owner.get(p_body);
+	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
 	ERR_FAIL_COND_V(!body, Vector3(0., 0., 0.));
 	Vector3 pos;
 	body->get_node_position(p_point_index, pos);
@@ -1154,7 +1154,7 @@ Vector3 BulletPhysicsServer::soft_body_get_point_global_position(RID p_body, int
 }
 
 Vector3 BulletPhysicsServer::soft_body_get_point_offset(RID p_body, int p_point_index) const {
-	SoftBodyBullet *body = soft_body_owner.get(p_body);
+	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
 	ERR_FAIL_COND_V(!body, Vector3());
 	Vector3 res;
 	body->get_node_offset(p_point_index, res);
@@ -1162,25 +1162,25 @@ Vector3 BulletPhysicsServer::soft_body_get_point_offset(RID p_body, int p_point_
 }
 
 void BulletPhysicsServer::soft_body_remove_all_pinned_points(RID p_body) {
-	SoftBodyBullet *body = soft_body_owner.get(p_body);
+	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 	body->reset_all_node_mass();
 }
 
 void BulletPhysicsServer::soft_body_pin_point(RID p_body, int p_point_index, bool p_pin) {
-	SoftBodyBullet *body = soft_body_owner.get(p_body);
+	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
 	ERR_FAIL_COND(!body);
 	body->set_node_mass(p_point_index, p_pin ? 0 : 1);
 }
 
 bool BulletPhysicsServer::soft_body_is_point_pinned(RID p_body, int p_point_index) {
-	SoftBodyBullet *body = soft_body_owner.get(p_body);
+	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
 	ERR_FAIL_COND_V(!body, 0.f);
 	return body->get_node_mass(p_point_index);
 }
 
 PhysicsServer::JointType BulletPhysicsServer::joint_get_type(RID p_joint) const {
-	JointBullet *joint = joint_owner.get(p_joint);
+	JointBullet *joint = joint_owner.getornull(p_joint);
 	ERR_FAIL_COND_V(!joint, JOINT_PIN);
 	return joint->get_type();
 }
@@ -1195,28 +1195,28 @@ int BulletPhysicsServer::joint_get_solver_priority(RID p_joint) const {
 }
 
 void BulletPhysicsServer::joint_disable_collisions_between_bodies(RID p_joint, const bool p_disable) {
-	JointBullet *joint = joint_owner.get(p_joint);
+	JointBullet *joint = joint_owner.getornull(p_joint);
 	ERR_FAIL_COND(!joint);
 
 	joint->disable_collisions_between_bodies(p_disable);
 }
 
 bool BulletPhysicsServer::joint_is_disabled_collisions_between_bodies(RID p_joint) const {
-	JointBullet *joint(joint_owner.get(p_joint));
+	JointBullet *joint(joint_owner.getornull(p_joint));
 	ERR_FAIL_COND_V(!joint, false);
 
 	return joint->is_disabled_collisions_between_bodies();
 }
 
 RID BulletPhysicsServer::joint_create_pin(RID p_body_A, const Vector3 &p_local_A, RID p_body_B, const Vector3 &p_local_B) {
-	RigidBodyBullet *body_A = rigid_body_owner.get(p_body_A);
+	RigidBodyBullet *body_A = rigid_body_owner.getornull(p_body_A);
 	ERR_FAIL_COND_V(!body_A, RID());
 
 	JointAssertSpace(body_A, "A", RID());
 
 	RigidBodyBullet *body_B = NULL;
 	if (p_body_B.is_valid()) {
-		body_B = rigid_body_owner.get(p_body_B);
+		body_B = rigid_body_owner.getornull(p_body_B);
 		JointAssertSpace(body_B, "B", RID());
 		JointAssertSameSpace(body_A, body_B, RID());
 	}
@@ -1230,7 +1230,7 @@ RID BulletPhysicsServer::joint_create_pin(RID p_body_A, const Vector3 &p_local_A
 }
 
 void BulletPhysicsServer::pin_joint_set_param(RID p_joint, PinJointParam p_param, float p_value) {
-	JointBullet *joint = joint_owner.get(p_joint);
+	JointBullet *joint = joint_owner.getornull(p_joint);
 	ERR_FAIL_COND(!joint);
 	ERR_FAIL_COND(joint->get_type() != JOINT_PIN);
 	PinJointBullet *pin_joint = static_cast<PinJointBullet *>(joint);
@@ -1238,7 +1238,7 @@ void BulletPhysicsServer::pin_joint_set_param(RID p_joint, PinJointParam p_param
 }
 
 float BulletPhysicsServer::pin_joint_get_param(RID p_joint, PinJointParam p_param) const {
-	JointBullet *joint = joint_owner.get(p_joint);
+	JointBullet *joint = joint_owner.getornull(p_joint);
 	ERR_FAIL_COND_V(!joint, 0);
 	ERR_FAIL_COND_V(joint->get_type() != JOINT_PIN, 0);
 	PinJointBullet *pin_joint = static_cast<PinJointBullet *>(joint);
@@ -1246,7 +1246,7 @@ float BulletPhysicsServer::pin_joint_get_param(RID p_joint, PinJointParam p_para
 }
 
 void BulletPhysicsServer::pin_joint_set_local_a(RID p_joint, const Vector3 &p_A) {
-	JointBullet *joint = joint_owner.get(p_joint);
+	JointBullet *joint = joint_owner.getornull(p_joint);
 	ERR_FAIL_COND(!joint);
 	ERR_FAIL_COND(joint->get_type() != JOINT_PIN);
 	PinJointBullet *pin_joint = static_cast<PinJointBullet *>(joint);
@@ -1254,7 +1254,7 @@ void BulletPhysicsServer::pin_joint_set_local_a(RID p_joint, const Vector3 &p_A)
 }
 
 Vector3 BulletPhysicsServer::pin_joint_get_local_a(RID p_joint) const {
-	JointBullet *joint = joint_owner.get(p_joint);
+	JointBullet *joint = joint_owner.getornull(p_joint);
 	ERR_FAIL_COND_V(!joint, Vector3());
 	ERR_FAIL_COND_V(joint->get_type() != JOINT_PIN, Vector3());
 	PinJointBullet *pin_joint = static_cast<PinJointBullet *>(joint);
@@ -1262,7 +1262,7 @@ Vector3 BulletPhysicsServer::pin_joint_get_local_a(RID p_joint) const {
 }
 
 void BulletPhysicsServer::pin_joint_set_local_b(RID p_joint, const Vector3 &p_B) {
-	JointBullet *joint = joint_owner.get(p_joint);
+	JointBullet *joint = joint_owner.getornull(p_joint);
 	ERR_FAIL_COND(!joint);
 	ERR_FAIL_COND(joint->get_type() != JOINT_PIN);
 	PinJointBullet *pin_joint = static_cast<PinJointBullet *>(joint);
@@ -1270,7 +1270,7 @@ void BulletPhysicsServer::pin_joint_set_local_b(RID p_joint, const Vector3 &p_B)
 }
 
 Vector3 BulletPhysicsServer::pin_joint_get_local_b(RID p_joint) const {
-	JointBullet *joint = joint_owner.get(p_joint);
+	JointBullet *joint = joint_owner.getornull(p_joint);
 	ERR_FAIL_COND_V(!joint, Vector3());
 	ERR_FAIL_COND_V(joint->get_type() != JOINT_PIN, Vector3());
 	PinJointBullet *pin_joint = static_cast<PinJointBullet *>(joint);
@@ -1278,13 +1278,13 @@ Vector3 BulletPhysicsServer::pin_joint_get_local_b(RID p_joint) const {
 }
 
 RID BulletPhysicsServer::joint_create_hinge(RID p_body_A, const Transform &p_hinge_A, RID p_body_B, const Transform &p_hinge_B) {
-	RigidBodyBullet *body_A = rigid_body_owner.get(p_body_A);
+	RigidBodyBullet *body_A = rigid_body_owner.getornull(p_body_A);
 	ERR_FAIL_COND_V(!body_A, RID());
 	JointAssertSpace(body_A, "A", RID());
 
 	RigidBodyBullet *body_B = NULL;
 	if (p_body_B.is_valid()) {
-		body_B = rigid_body_owner.get(p_body_B);
+		body_B = rigid_body_owner.getornull(p_body_B);
 		JointAssertSpace(body_B, "B", RID());
 		JointAssertSameSpace(body_A, body_B, RID());
 	}
@@ -1298,13 +1298,13 @@ RID BulletPhysicsServer::joint_create_hinge(RID p_body_A, const Transform &p_hin
 }
 
 RID BulletPhysicsServer::joint_create_hinge_simple(RID p_body_A, const Vector3 &p_pivot_A, const Vector3 &p_axis_A, RID p_body_B, const Vector3 &p_pivot_B, const Vector3 &p_axis_B) {
-	RigidBodyBullet *body_A = rigid_body_owner.get(p_body_A);
+	RigidBodyBullet *body_A = rigid_body_owner.getornull(p_body_A);
 	ERR_FAIL_COND_V(!body_A, RID());
 	JointAssertSpace(body_A, "A", RID());
 
 	RigidBodyBullet *body_B = NULL;
 	if (p_body_B.is_valid()) {
-		body_B = rigid_body_owner.get(p_body_B);
+		body_B = rigid_body_owner.getornull(p_body_B);
 		JointAssertSpace(body_B, "B", RID());
 		JointAssertSameSpace(body_A, body_B, RID());
 	}
@@ -1318,7 +1318,7 @@ RID BulletPhysicsServer::joint_create_hinge_simple(RID p_body_A, const Vector3 &
 }
 
 void BulletPhysicsServer::hinge_joint_set_param(RID p_joint, HingeJointParam p_param, float p_value) {
-	JointBullet *joint = joint_owner.get(p_joint);
+	JointBullet *joint = joint_owner.getornull(p_joint);
 	ERR_FAIL_COND(!joint);
 	ERR_FAIL_COND(joint->get_type() != JOINT_HINGE);
 	HingeJointBullet *hinge_joint = static_cast<HingeJointBullet *>(joint);
@@ -1326,7 +1326,7 @@ void BulletPhysicsServer::hinge_joint_set_param(RID p_joint, HingeJointParam p_p
 }
 
 float BulletPhysicsServer::hinge_joint_get_param(RID p_joint, HingeJointParam p_param) const {
-	JointBullet *joint = joint_owner.get(p_joint);
+	JointBullet *joint = joint_owner.getornull(p_joint);
 	ERR_FAIL_COND_V(!joint, 0);
 	ERR_FAIL_COND_V(joint->get_type() != JOINT_HINGE, 0);
 	HingeJointBullet *hinge_joint = static_cast<HingeJointBullet *>(joint);
@@ -1334,7 +1334,7 @@ float BulletPhysicsServer::hinge_joint_get_param(RID p_joint, HingeJointParam p_
 }
 
 void BulletPhysicsServer::hinge_joint_set_flag(RID p_joint, HingeJointFlag p_flag, bool p_value) {
-	JointBullet *joint = joint_owner.get(p_joint);
+	JointBullet *joint = joint_owner.getornull(p_joint);
 	ERR_FAIL_COND(!joint);
 	ERR_FAIL_COND(joint->get_type() != JOINT_HINGE);
 	HingeJointBullet *hinge_joint = static_cast<HingeJointBullet *>(joint);
@@ -1342,7 +1342,7 @@ void BulletPhysicsServer::hinge_joint_set_flag(RID p_joint, HingeJointFlag p_fla
 }
 
 bool BulletPhysicsServer::hinge_joint_get_flag(RID p_joint, HingeJointFlag p_flag) const {
-	JointBullet *joint = joint_owner.get(p_joint);
+	JointBullet *joint = joint_owner.getornull(p_joint);
 	ERR_FAIL_COND_V(!joint, false);
 	ERR_FAIL_COND_V(joint->get_type() != JOINT_HINGE, false);
 	HingeJointBullet *hinge_joint = static_cast<HingeJointBullet *>(joint);
@@ -1350,13 +1350,13 @@ bool BulletPhysicsServer::hinge_joint_get_flag(RID p_joint, HingeJointFlag p_fla
 }
 
 RID BulletPhysicsServer::joint_create_slider(RID p_body_A, const Transform &p_local_frame_A, RID p_body_B, const Transform &p_local_frame_B) {
-	RigidBodyBullet *body_A = rigid_body_owner.get(p_body_A);
+	RigidBodyBullet *body_A = rigid_body_owner.getornull(p_body_A);
 	ERR_FAIL_COND_V(!body_A, RID());
 	JointAssertSpace(body_A, "A", RID());
 
 	RigidBodyBullet *body_B = NULL;
 	if (p_body_B.is_valid()) {
-		body_B = rigid_body_owner.get(p_body_B);
+		body_B = rigid_body_owner.getornull(p_body_B);
 		JointAssertSpace(body_B, "B", RID());
 		JointAssertSameSpace(body_A, body_B, RID());
 	}
@@ -1370,7 +1370,7 @@ RID BulletPhysicsServer::joint_create_slider(RID p_body_A, const Transform &p_lo
 }
 
 void BulletPhysicsServer::slider_joint_set_param(RID p_joint, SliderJointParam p_param, float p_value) {
-	JointBullet *joint = joint_owner.get(p_joint);
+	JointBullet *joint = joint_owner.getornull(p_joint);
 	ERR_FAIL_COND(!joint);
 	ERR_FAIL_COND(joint->get_type() != JOINT_SLIDER);
 	SliderJointBullet *slider_joint = static_cast<SliderJointBullet *>(joint);
@@ -1378,7 +1378,7 @@ void BulletPhysicsServer::slider_joint_set_param(RID p_joint, SliderJointParam p
 }
 
 float BulletPhysicsServer::slider_joint_get_param(RID p_joint, SliderJointParam p_param) const {
-	JointBullet *joint = joint_owner.get(p_joint);
+	JointBullet *joint = joint_owner.getornull(p_joint);
 	ERR_FAIL_COND_V(!joint, 0);
 	ERR_FAIL_COND_V(joint->get_type() != JOINT_SLIDER, 0);
 	SliderJointBullet *slider_joint = static_cast<SliderJointBullet *>(joint);
@@ -1386,13 +1386,13 @@ float BulletPhysicsServer::slider_joint_get_param(RID p_joint, SliderJointParam
 }
 
 RID BulletPhysicsServer::joint_create_cone_twist(RID p_body_A, const Transform &p_local_frame_A, RID p_body_B, const Transform &p_local_frame_B) {
-	RigidBodyBullet *body_A = rigid_body_owner.get(p_body_A);
+	RigidBodyBullet *body_A = rigid_body_owner.getornull(p_body_A);
 	ERR_FAIL_COND_V(!body_A, RID());
 	JointAssertSpace(body_A, "A", RID());
 
 	RigidBodyBullet *body_B = NULL;
 	if (p_body_B.is_valid()) {
-		body_B = rigid_body_owner.get(p_body_B);
+		body_B = rigid_body_owner.getornull(p_body_B);
 		JointAssertSpace(body_B, "B", RID());
 		JointAssertSameSpace(body_A, body_B, RID());
 	}
@@ -1404,7 +1404,7 @@ RID BulletPhysicsServer::joint_create_cone_twist(RID p_body_A, const Transform &
 }
 
 void BulletPhysicsServer::cone_twist_joint_set_param(RID p_joint, ConeTwistJointParam p_param, float p_value) {
-	JointBullet *joint = joint_owner.get(p_joint);
+	JointBullet *joint = joint_owner.getornull(p_joint);
 	ERR_FAIL_COND(!joint);
 	ERR_FAIL_COND(joint->get_type() != JOINT_CONE_TWIST);
 	ConeTwistJointBullet *coneTwist_joint = static_cast<ConeTwistJointBullet *>(joint);
@@ -1412,7 +1412,7 @@ void BulletPhysicsServer::cone_twist_joint_set_param(RID p_joint, ConeTwistJoint
 }
 
 float BulletPhysicsServer::cone_twist_joint_get_param(RID p_joint, ConeTwistJointParam p_param) const {
-	JointBullet *joint = joint_owner.get(p_joint);
+	JointBullet *joint = joint_owner.getornull(p_joint);
 	ERR_FAIL_COND_V(!joint, 0.);
 	ERR_FAIL_COND_V(joint->get_type() != JOINT_CONE_TWIST, 0.);
 	ConeTwistJointBullet *coneTwist_joint = static_cast<ConeTwistJointBullet *>(joint);
@@ -1420,13 +1420,13 @@ float BulletPhysicsServer::cone_twist_joint_get_param(RID p_joint, ConeTwistJoin
 }
 
 RID BulletPhysicsServer::joint_create_generic_6dof(RID p_body_A, const Transform &p_local_frame_A, RID p_body_B, const Transform &p_local_frame_B) {
-	RigidBodyBullet *body_A = rigid_body_owner.get(p_body_A);
+	RigidBodyBullet *body_A = rigid_body_owner.getornull(p_body_A);
 	ERR_FAIL_COND_V(!body_A, RID());
 	JointAssertSpace(body_A, "A", RID());
 
 	RigidBodyBullet *body_B = NULL;
 	if (p_body_B.is_valid()) {
-		body_B = rigid_body_owner.get(p_body_B);
+		body_B = rigid_body_owner.getornull(p_body_B);
 		JointAssertSpace(body_B, "B", RID());
 		JointAssertSameSpace(body_A, body_B, RID());
 	}
@@ -1440,7 +1440,7 @@ RID BulletPhysicsServer::joint_create_generic_6dof(RID p_body_A, const Transform
 }
 
 void BulletPhysicsServer::generic_6dof_joint_set_param(RID p_joint, Vector3::Axis p_axis, G6DOFJointAxisParam p_param, float p_value) {
-	JointBullet *joint = joint_owner.get(p_joint);
+	JointBullet *joint = joint_owner.getornull(p_joint);
 	ERR_FAIL_COND(!joint);
 	ERR_FAIL_COND(joint->get_type() != JOINT_6DOF);
 	Generic6DOFJointBullet *generic_6dof_joint = static_cast<Generic6DOFJointBullet *>(joint);
@@ -1448,7 +1448,7 @@ void BulletPhysicsServer::generic_6dof_joint_set_param(RID p_joint, Vector3::Axi
 }
 
 float BulletPhysicsServer::generic_6dof_joint_get_param(RID p_joint, Vector3::Axis p_axis, G6DOFJointAxisParam p_param) {
-	JointBullet *joint = joint_owner.get(p_joint);
+	JointBullet *joint = joint_owner.getornull(p_joint);
 	ERR_FAIL_COND_V(!joint, 0);
 	ERR_FAIL_COND_V(joint->get_type() != JOINT_6DOF, 0);
 	Generic6DOFJointBullet *generic_6dof_joint = static_cast<Generic6DOFJointBullet *>(joint);
@@ -1456,7 +1456,7 @@ float BulletPhysicsServer::generic_6dof_joint_get_param(RID p_joint, Vector3::Ax
 }
 
 void BulletPhysicsServer::generic_6dof_joint_set_flag(RID p_joint, Vector3::Axis p_axis, G6DOFJointAxisFlag p_flag, bool p_enable) {
-	JointBullet *joint = joint_owner.get(p_joint);
+	JointBullet *joint = joint_owner.getornull(p_joint);
 	ERR_FAIL_COND(!joint);
 	ERR_FAIL_COND(joint->get_type() != JOINT_6DOF);
 	Generic6DOFJointBullet *generic_6dof_joint = static_cast<Generic6DOFJointBullet *>(joint);
@@ -1464,7 +1464,7 @@ void BulletPhysicsServer::generic_6dof_joint_set_flag(RID p_joint, Vector3::Axis
 }
 
 bool BulletPhysicsServer::generic_6dof_joint_get_flag(RID p_joint, Vector3::Axis p_axis, G6DOFJointAxisFlag p_flag) {
-	JointBullet *joint = joint_owner.get(p_joint);
+	JointBullet *joint = joint_owner.getornull(p_joint);
 	ERR_FAIL_COND_V(!joint, false);
 	ERR_FAIL_COND_V(joint->get_type() != JOINT_6DOF, false);
 	Generic6DOFJointBullet *generic_6dof_joint = static_cast<Generic6DOFJointBullet *>(joint);
@@ -1472,7 +1472,7 @@ bool BulletPhysicsServer::generic_6dof_joint_get_flag(RID p_joint, Vector3::Axis
 }
 
 void BulletPhysicsServer::generic_6dof_joint_set_precision(RID p_joint, int p_precision) {
-	JointBullet *joint = joint_owner.get(p_joint);
+	JointBullet *joint = joint_owner.getornull(p_joint);
 	ERR_FAIL_COND(!joint);
 	ERR_FAIL_COND(joint->get_type() != JOINT_6DOF);
 	Generic6DOFJointBullet *generic_6dof_joint = static_cast<Generic6DOFJointBullet *>(joint);
@@ -1480,7 +1480,7 @@ void BulletPhysicsServer::generic_6dof_joint_set_precision(RID p_joint, int p_pr
 }
 
 int BulletPhysicsServer::generic_6dof_joint_get_precision(RID p_joint) {
-	JointBullet *joint = joint_owner.get(p_joint);
+	JointBullet *joint = joint_owner.getornull(p_joint);
 	ERR_FAIL_COND_V(!joint, 0);
 	ERR_FAIL_COND_V(joint->get_type() != JOINT_6DOF, 0);
 	Generic6DOFJointBullet *generic_6dof_joint = static_cast<Generic6DOFJointBullet *>(joint);
@@ -1490,7 +1490,7 @@ int BulletPhysicsServer::generic_6dof_joint_get_precision(RID p_joint) {
 void BulletPhysicsServer::free(RID p_rid) {
 	if (shape_owner.owns(p_rid)) {
 
-		ShapeBullet *shape = shape_owner.get(p_rid);
+		ShapeBullet *shape = shape_owner.getornull(p_rid);
 
 		// Notify the shape is configured
 		for (Map<ShapeOwnerBullet *, int>::Element *element = shape->get_owners().front(); element; element = element->next()) {
@@ -1501,7 +1501,7 @@ void BulletPhysicsServer::free(RID p_rid) {
 		bulletdelete(shape);
 	} else if (rigid_body_owner.owns(p_rid)) {
 
-		RigidBodyBullet *body = rigid_body_owner.get(p_rid);
+		RigidBodyBullet *body = rigid_body_owner.getornull(p_rid);
 
 		body->set_space(NULL);
 
@@ -1512,7 +1512,7 @@ void BulletPhysicsServer::free(RID p_rid) {
 
 	} else if (soft_body_owner.owns(p_rid)) {
 
-		SoftBodyBullet *body = soft_body_owner.get(p_rid);
+		SoftBodyBullet *body = soft_body_owner.getornull(p_rid);
 
 		body->set_space(NULL);
 
@@ -1521,7 +1521,7 @@ void BulletPhysicsServer::free(RID p_rid) {
 
 	} else if (area_owner.owns(p_rid)) {
 
-		AreaBullet *area = area_owner.get(p_rid);
+		AreaBullet *area = area_owner.getornull(p_rid);
 
 		area->set_space(NULL);
 
@@ -1532,14 +1532,14 @@ void BulletPhysicsServer::free(RID p_rid) {
 
 	} else if (joint_owner.owns(p_rid)) {
 
-		JointBullet *joint = joint_owner.get(p_rid);
+		JointBullet *joint = joint_owner.getornull(p_rid);
 		joint->destroy_internal_constraint();
 		joint_owner.free(p_rid);
 		bulletdelete(joint);
 
 	} else if (space_owner.owns(p_rid)) {
 
-		SpaceBullet *space = space_owner.get(p_rid);
+		SpaceBullet *space = space_owner.getornull(p_rid);
 
 		space->remove_all_collision_objects();
 
diff --git a/modules/bullet/bullet_physics_server.h b/modules/bullet/bullet_physics_server.h
index 4a3b4a2edc..22032d32e3 100644
--- a/modules/bullet/bullet_physics_server.h
+++ b/modules/bullet/bullet_physics_server.h
@@ -33,13 +33,13 @@
 
 #include "area_bullet.h"
 #include "core/rid.h"
+#include "core/rid_owner.h"
 #include "joint_bullet.h"
 #include "rigid_body_bullet.h"
 #include "servers/physics_server.h"
 #include "shape_bullet.h"
 #include "soft_body_bullet.h"
 #include "space_bullet.h"
-
 /**
 	@author AndreaCatania
 */
@@ -53,12 +53,12 @@ class BulletPhysicsServer : public PhysicsServer {
 	char active_spaces_count;
 	Vector<SpaceBullet *> active_spaces;
 
-	mutable RID_Owner<SpaceBullet> space_owner;
-	mutable RID_Owner<ShapeBullet> shape_owner;
-	mutable RID_Owner<AreaBullet> area_owner;
-	mutable RID_Owner<RigidBodyBullet> rigid_body_owner;
-	mutable RID_Owner<SoftBodyBullet> soft_body_owner;
-	mutable RID_Owner<JointBullet> joint_owner;
+	mutable RID_PtrOwner<SpaceBullet> space_owner;
+	mutable RID_PtrOwner<ShapeBullet> shape_owner;
+	mutable RID_PtrOwner<AreaBullet> area_owner;
+	mutable RID_PtrOwner<RigidBodyBullet> rigid_body_owner;
+	mutable RID_PtrOwner<SoftBodyBullet> soft_body_owner;
+	mutable RID_PtrOwner<JointBullet> joint_owner;
 
 protected:
 	static void _bind_methods();
@@ -67,22 +67,22 @@ public:
 	BulletPhysicsServer();
 	~BulletPhysicsServer();
 
-	_FORCE_INLINE_ RID_Owner<SpaceBullet> *get_space_owner() {
+	_FORCE_INLINE_ RID_PtrOwner<SpaceBullet> *get_space_owner() {
 		return &space_owner;
 	}
-	_FORCE_INLINE_ RID_Owner<ShapeBullet> *get_shape_owner() {
+	_FORCE_INLINE_ RID_PtrOwner<ShapeBullet> *get_shape_owner() {
 		return &shape_owner;
 	}
-	_FORCE_INLINE_ RID_Owner<AreaBullet> *get_area_owner() {
+	_FORCE_INLINE_ RID_PtrOwner<AreaBullet> *get_area_owner() {
 		return &area_owner;
 	}
-	_FORCE_INLINE_ RID_Owner<RigidBodyBullet> *get_rigid_body_owner() {
+	_FORCE_INLINE_ RID_PtrOwner<RigidBodyBullet> *get_rigid_body_owner() {
 		return &rigid_body_owner;
 	}
-	_FORCE_INLINE_ RID_Owner<SoftBodyBullet> *get_soft_body_owner() {
+	_FORCE_INLINE_ RID_PtrOwner<SoftBodyBullet> *get_soft_body_owner() {
 		return &soft_body_owner;
 	}
-	_FORCE_INLINE_ RID_Owner<JointBullet> *get_joint_owner() {
+	_FORCE_INLINE_ RID_PtrOwner<JointBullet> *get_joint_owner() {
 		return &joint_owner;
 	}
 
diff --git a/modules/bullet/rid_bullet.h b/modules/bullet/rid_bullet.h
index 28bcedb01a..b76641ca54 100644
--- a/modules/bullet/rid_bullet.h
+++ b/modules/bullet/rid_bullet.h
@@ -39,7 +39,7 @@
 
 class BulletPhysicsServer;
 
-class RIDBullet : public RID_Data {
+class RIDBullet {
 	RID self;
 	BulletPhysicsServer *physicsServer;
 
diff --git a/modules/bullet/space_bullet.cpp b/modules/bullet/space_bullet.cpp
index 762637ce75..69f3d1b393 100644
--- a/modules/bullet/space_bullet.cpp
+++ b/modules/bullet/space_bullet.cpp
@@ -122,7 +122,7 @@ int BulletPhysicsDirectSpaceState::intersect_shape(const RID &p_shape, const Tra
 	if (p_result_max <= 0)
 		return 0;
 
-	ShapeBullet *shape = space->get_physics_server()->get_shape_owner()->get(p_shape);
+	ShapeBullet *shape = space->get_physics_server()->get_shape_owner()->getornull(p_shape);
 
 	btCollisionShape *btShape = shape->create_bt_shape(p_xform.basis.get_scale_abs(), p_margin);
 	if (!btShape->isConvex()) {
@@ -152,7 +152,7 @@ int BulletPhysicsDirectSpaceState::intersect_shape(const RID &p_shape, const Tra
 }
 
 bool BulletPhysicsDirectSpaceState::cast_motion(const RID &p_shape, const Transform &p_xform, const Vector3 &p_motion, float p_margin, float &r_closest_safe, float &r_closest_unsafe, const Set<RID> &p_exclude, uint32_t p_collision_mask, bool p_collide_with_bodies, bool p_collide_with_areas, ShapeRestInfo *r_info) {
-	ShapeBullet *shape = space->get_physics_server()->get_shape_owner()->get(p_shape);
+	ShapeBullet *shape = space->get_physics_server()->get_shape_owner()->getornull(p_shape);
 
 	btCollisionShape *btShape = shape->create_bt_shape(p_xform.basis.get_scale(), p_margin);
 	if (!btShape->isConvex()) {
@@ -207,7 +207,7 @@ bool BulletPhysicsDirectSpaceState::collide_shape(RID p_shape, const Transform &
 	if (p_result_max <= 0)
 		return 0;
 
-	ShapeBullet *shape = space->get_physics_server()->get_shape_owner()->get(p_shape);
+	ShapeBullet *shape = space->get_physics_server()->get_shape_owner()->getornull(p_shape);
 
 	btCollisionShape *btShape = shape->create_bt_shape(p_shape_xform.basis.get_scale_abs(), p_margin);
 	if (!btShape->isConvex()) {
@@ -239,7 +239,7 @@ bool BulletPhysicsDirectSpaceState::collide_shape(RID p_shape, const Transform &
 
 bool BulletPhysicsDirectSpaceState::rest_info(RID p_shape, const Transform &p_shape_xform, float p_margin, ShapeRestInfo *r_info, const Set<RID> &p_exclude, uint32_t p_collision_mask, bool p_collide_with_bodies, bool p_collide_with_areas) {
 
-	ShapeBullet *shape = space->get_physics_server()->get_shape_owner()->get(p_shape);
+	ShapeBullet *shape = space->get_physics_server()->get_shape_owner()->getornull(p_shape);
 
 	btCollisionShape *btShape = shape->create_bt_shape(p_shape_xform.basis.get_scale_abs(), p_margin);
 	if (!btShape->isConvex()) {
@@ -890,8 +890,8 @@ void SpaceBullet::update_gravity() {
 
 static ImmediateGeometry *motionVec(NULL);
 static ImmediateGeometry *normalLine(NULL);
-static Ref<SpatialMaterial> red_mat;
-static Ref<SpatialMaterial> blue_mat;
+static Ref<StandardMaterial3D> red_mat;
+static Ref<StandardMaterial3D> blue_mat;
 #endif
 
 bool SpaceBullet::test_body_motion(RigidBodyBullet *p_body, const Transform &p_from, const Vector3 &p_motion, bool p_infinite_inertia, PhysicsServer::MotionResult *r_result, bool p_exclude_raycast_shapes) {
@@ -908,21 +908,21 @@ bool SpaceBullet::test_body_motion(RigidBodyBullet *p_body, const Transform &p_f
 		motionVec->set_as_toplevel(true);
 		normalLine->set_as_toplevel(true);
 
-		red_mat = Ref<SpatialMaterial>(memnew(SpatialMaterial));
-		red_mat->set_flag(SpatialMaterial::FLAG_UNSHADED, true);
+		red_mat = Ref<StandardMaterial3D>(memnew(StandardMaterial3D));
+		red_mat->set_shading_mode(StandardMaterial3D::SHADING_MODE_UNSHADED);
 		red_mat->set_line_width(20.0);
-		red_mat->set_feature(SpatialMaterial::FEATURE_TRANSPARENT, true);
-		red_mat->set_flag(SpatialMaterial::FLAG_ALBEDO_FROM_VERTEX_COLOR, true);
-		red_mat->set_flag(SpatialMaterial::FLAG_SRGB_VERTEX_COLOR, true);
+		red_mat->set_transparency(StandardMaterial3D::TRANSPARENCY_ALPHA);
+		red_mat->set_flag(StandardMaterial3D::FLAG_ALBEDO_FROM_VERTEX_COLOR, true);
+		red_mat->set_flag(StandardMaterial3D::FLAG_SRGB_VERTEX_COLOR, true);
 		red_mat->set_albedo(Color(1, 0, 0, 1));
 		motionVec->set_material_override(red_mat);
 
-		blue_mat = Ref<SpatialMaterial>(memnew(SpatialMaterial));
-		blue_mat->set_flag(SpatialMaterial::FLAG_UNSHADED, true);
+		blue_mat = Ref<StandardMaterial3D>(memnew(StandardMaterial3D));
+		blue_mat->set_shading_mode(StandardMaterial3D::SHADING_MODE_UNSHADED);
 		blue_mat->set_line_width(20.0);
-		blue_mat->set_feature(SpatialMaterial::FEATURE_TRANSPARENT, true);
-		blue_mat->set_flag(SpatialMaterial::FLAG_ALBEDO_FROM_VERTEX_COLOR, true);
-		blue_mat->set_flag(SpatialMaterial::FLAG_SRGB_VERTEX_COLOR, true);
+		blue_mat->set_transparency(StandardMaterial3D::TRANSPARENCY_ALPHA);
+		blue_mat->set_flag(StandardMaterial3D::FLAG_ALBEDO_FROM_VERTEX_COLOR, true);
+		blue_mat->set_flag(StandardMaterial3D::FLAG_SRGB_VERTEX_COLOR, true);
 		blue_mat->set_albedo(Color(0, 0, 1, 1));
 		normalLine->set_material_override(blue_mat);
 	}
diff --git a/modules/csg/csg_shape.cpp b/modules/csg/csg_shape.cpp
index c8a72ff813..33e4e9748c 100644
--- a/modules/csg/csg_shape.cpp
+++ b/modules/csg/csg_shape.cpp
@@ -896,7 +896,7 @@ void CSGMesh::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("get_material"), &CSGMesh::get_material);
 
 	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "mesh", PROPERTY_HINT_RESOURCE_TYPE, "Mesh"), "set_mesh", "get_mesh");
-	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "material", PROPERTY_HINT_RESOURCE_TYPE, "SpatialMaterial,ShaderMaterial"), "set_material", "get_material");
+	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "material", PROPERTY_HINT_RESOURCE_TYPE, "StandardMaterial3D,ShaderMaterial"), "set_material", "get_material");
 }
 
 void CSGMesh::set_mesh(const Ref<Mesh> &p_mesh) {
@@ -1059,7 +1059,7 @@ void CSGSphere::_bind_methods() {
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "radial_segments", PROPERTY_HINT_RANGE, "1,100,1"), "set_radial_segments", "get_radial_segments");
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "rings", PROPERTY_HINT_RANGE, "1,100,1"), "set_rings", "get_rings");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "smooth_faces"), "set_smooth_faces", "get_smooth_faces");
-	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "material", PROPERTY_HINT_RESOURCE_TYPE, "SpatialMaterial,ShaderMaterial"), "set_material", "get_material");
+	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "material", PROPERTY_HINT_RESOURCE_TYPE, "StandardMaterial3D,ShaderMaterial"), "set_material", "get_material");
 }
 
 void CSGSphere::set_radius(const float p_radius) {
@@ -1245,7 +1245,7 @@ void CSGBox::_bind_methods() {
 	ADD_PROPERTY(PropertyInfo(Variant::REAL, "width", PROPERTY_HINT_EXP_RANGE, "0.001,1000.0,0.001,or_greater"), "set_width", "get_width");
 	ADD_PROPERTY(PropertyInfo(Variant::REAL, "height", PROPERTY_HINT_EXP_RANGE, "0.001,1000.0,0.001,or_greater"), "set_height", "get_height");
 	ADD_PROPERTY(PropertyInfo(Variant::REAL, "depth", PROPERTY_HINT_EXP_RANGE, "0.001,1000.0,0.001,or_greater"), "set_depth", "get_depth");
-	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "material", PROPERTY_HINT_RESOURCE_TYPE, "SpatialMaterial,ShaderMaterial"), "set_material", "get_material");
+	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "material", PROPERTY_HINT_RESOURCE_TYPE, "StandardMaterial3D,ShaderMaterial"), "set_material", "get_material");
 }
 
 void CSGBox::set_width(const float p_width) {
@@ -1462,7 +1462,7 @@ void CSGCylinder::_bind_methods() {
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "sides", PROPERTY_HINT_RANGE, "3,64,1"), "set_sides", "get_sides");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "cone"), "set_cone", "is_cone");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "smooth_faces"), "set_smooth_faces", "get_smooth_faces");
-	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "material", PROPERTY_HINT_RESOURCE_TYPE, "SpatialMaterial,ShaderMaterial"), "set_material", "get_material");
+	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "material", PROPERTY_HINT_RESOURCE_TYPE, "StandardMaterial3D,ShaderMaterial"), "set_material", "get_material");
 }
 
 void CSGCylinder::set_radius(const float p_radius) {
@@ -1689,7 +1689,7 @@ void CSGTorus::_bind_methods() {
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "sides", PROPERTY_HINT_RANGE, "3,64,1"), "set_sides", "get_sides");
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "ring_sides", PROPERTY_HINT_RANGE, "3,64,1"), "set_ring_sides", "get_ring_sides");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "smooth_faces"), "set_smooth_faces", "get_smooth_faces");
-	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "material", PROPERTY_HINT_RESOURCE_TYPE, "SpatialMaterial,ShaderMaterial"), "set_material", "get_material");
+	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "material", PROPERTY_HINT_RESOURCE_TYPE, "StandardMaterial3D,ShaderMaterial"), "set_material", "get_material");
 }
 
 void CSGTorus::set_inner_radius(const float p_inner_radius) {
@@ -2330,7 +2330,7 @@ void CSGPolygon::_bind_methods() {
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "path_continuous_u"), "set_path_continuous_u", "is_path_continuous_u");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "path_joined"), "set_path_joined", "is_path_joined");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "smooth_faces"), "set_smooth_faces", "get_smooth_faces");
-	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "material", PROPERTY_HINT_RESOURCE_TYPE, "SpatialMaterial,ShaderMaterial"), "set_material", "get_material");
+	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "material", PROPERTY_HINT_RESOURCE_TYPE, "StandardMaterial3D,ShaderMaterial"), "set_material", "get_material");
 
 	BIND_ENUM_CONSTANT(MODE_DEPTH);
 	BIND_ENUM_CONSTANT(MODE_SPIN);
diff --git a/modules/cvtt/image_compress_cvtt.cpp b/modules/cvtt/image_compress_cvtt.cpp
index c261350e89..4d762b7a7b 100644
--- a/modules/cvtt/image_compress_cvtt.cpp
+++ b/modules/cvtt/image_compress_cvtt.cpp
@@ -136,7 +136,7 @@ static void _digest_job_queue(void *p_job_queue) {
 	}
 }
 
-void image_compress_cvtt(Image *p_image, float p_lossy_quality, Image::CompressSource p_source) {
+void image_compress_cvtt(Image *p_image, float p_lossy_quality, Image::UsedChannels p_channels) {
 
 	if (p_image->get_format() >= Image::FORMAT_BPTC_RGBA)
 		return; //do not compress, already compressed
@@ -167,7 +167,7 @@ void image_compress_cvtt(Image *p_image, float p_lossy_quality, Image::CompressS
 
 	flags |= cvtt::Flags::BC7_RespectPunchThrough;
 
-	if (p_source == Image::COMPRESS_SOURCE_NORMAL) {
+	if (p_channels == Image::USED_CHANNELS_RG) { //guessing this is a normalmap
 		flags |= cvtt::Flags::Uniform;
 	}
 
diff --git a/modules/cvtt/image_compress_cvtt.h b/modules/cvtt/image_compress_cvtt.h
index ecb876ecc6..c1772199af 100644
--- a/modules/cvtt/image_compress_cvtt.h
+++ b/modules/cvtt/image_compress_cvtt.h
@@ -33,7 +33,7 @@
 
 #include "core/image.h"
 
-void image_compress_cvtt(Image *p_image, float p_lossy_quality, Image::CompressSource p_source);
+void image_compress_cvtt(Image *p_image, float p_lossy_quality, Image::UsedChannels p_channels);
 void image_decompress_cvtt(Image *p_image);
 
 #endif // IMAGE_COMPRESS_CVTT_H
diff --git a/modules/dds/texture_loader_dds.cpp b/modules/dds/texture_loader_dds.cpp
index a7701329d8..5494744c48 100644
--- a/modules/dds/texture_loader_dds.cpp
+++ b/modules/dds/texture_loader_dds.cpp
@@ -457,7 +457,7 @@ void ResourceFormatDDS::get_recognized_extensions(List<String> *p_extensions) co
 
 bool ResourceFormatDDS::handles_type(const String &p_type) const {
 
-	return ClassDB::is_parent_class(p_type, "Texture");
+	return ClassDB::is_parent_class(p_type, "Texture2D");
 }
 
 String ResourceFormatDDS::get_resource_type(const String &p_path) const {
diff --git a/modules/etc/image_etc.cpp b/modules/etc/image_etc.cpp
index b80138c99d..24ee8e458e 100644
--- a/modules/etc/image_etc.cpp
+++ b/modules/etc/image_etc.cpp
@@ -36,18 +36,18 @@
 #include "core/os/os.h"
 #include "core/print_string.h"
 
-static Image::Format _get_etc2_mode(Image::DetectChannels format) {
+static Image::Format _get_etc2_mode(Image::UsedChannels format) {
 	switch (format) {
-		case Image::DETECTED_R:
+		case Image::USED_CHANNELS_R:
 			return Image::FORMAT_ETC2_R11;
 
-		case Image::DETECTED_RG:
+		case Image::USED_CHANNELS_RG:
 			return Image::FORMAT_ETC2_RG11;
 
-		case Image::DETECTED_RGB:
+		case Image::USED_CHANNELS_RGB:
 			return Image::FORMAT_ETC2_RGB8;
 
-		case Image::DETECTED_RGBA:
+		case Image::USED_CHANNELS_RGBA:
 			return Image::FORMAT_ETC2_RGBA8;
 
 		// TODO: would be nice if we could use FORMAT_ETC2_RGB8A1 for FORMAT_RGBA5551
@@ -88,47 +88,8 @@ static Etc::Image::Format _image_format_to_etc2comp_format(Image::Format format)
 	}
 }
 
-static void _compress_etc(Image *p_img, float p_lossy_quality, bool force_etc1_format, Image::CompressSource p_source) {
+static void _compress_etc(Image *p_img, float p_lossy_quality, bool force_etc1_format, Image::UsedChannels p_channels) {
 	Image::Format img_format = p_img->get_format();
-	Image::DetectChannels detected_channels = p_img->get_detected_channels();
-
-	if (p_source == Image::COMPRESS_SOURCE_LAYERED) {
-		//keep what comes in
-		switch (p_img->get_format()) {
-			case Image::FORMAT_L8: {
-				detected_channels = Image::DETECTED_L;
-			} break;
-			case Image::FORMAT_LA8: {
-				detected_channels = Image::DETECTED_LA;
-			} break;
-			case Image::FORMAT_R8: {
-				detected_channels = Image::DETECTED_R;
-			} break;
-			case Image::FORMAT_RG8: {
-				detected_channels = Image::DETECTED_RG;
-			} break;
-			case Image::FORMAT_RGB8: {
-				detected_channels = Image::DETECTED_RGB;
-			} break;
-			case Image::FORMAT_RGBA8:
-			case Image::FORMAT_RGBA4444:
-			case Image::FORMAT_RGBA5551: {
-				detected_channels = Image::DETECTED_RGBA;
-			} break;
-			default: {
-			}
-		}
-	}
-
-	if (p_source == Image::COMPRESS_SOURCE_SRGB && (detected_channels == Image::DETECTED_R || detected_channels == Image::DETECTED_RG)) {
-		//R and RG do not support SRGB
-		detected_channels = Image::DETECTED_RGB;
-	}
-
-	if (p_source == Image::COMPRESS_SOURCE_NORMAL) {
-		//use RG channels only for normal
-		detected_channels = Image::DETECTED_RG;
-	}
 
 	if (img_format >= Image::FORMAT_DXT1) {
 		return; //do not compress, already compressed
@@ -139,21 +100,24 @@ static void _compress_etc(Image *p_img, float p_lossy_quality, bool force_etc1_f
 		return;
 	}
 
+	// FIXME: Commented out during Vulkan rebase.
+	/*
 	if (force_etc1_format) {
 		// If VRAM compression is using ETC, but image has alpha, convert to RGBA4444 or LA8
 		// This saves space while maintaining the alpha channel
-		if (detected_channels == Image::DETECTED_RGBA) {
+		if (detected_channels == Image::USED_CHANNELS_RGBA) {
 			p_img->convert(Image::FORMAT_RGBA4444);
 			return;
-		} else if (detected_channels == Image::DETECTED_LA) {
+		} else if (detected_channels == Image::USE_CHANNELS_LA) {
 			p_img->convert(Image::FORMAT_LA8);
 			return;
 		}
 	}
+	*/
 
 	uint32_t imgw = p_img->get_width(), imgh = p_img->get_height();
 
-	Image::Format etc_format = force_etc1_format ? Image::FORMAT_ETC : _get_etc2_mode(detected_channels);
+	Image::Format etc_format = force_etc1_format ? Image::FORMAT_ETC : _get_etc2_mode(p_channels);
 
 	Ref<Image> img = p_img->duplicate();
 
@@ -241,11 +205,11 @@ static void _compress_etc(Image *p_img, float p_lossy_quality, bool force_etc1_f
 }
 
 static void _compress_etc1(Image *p_img, float p_lossy_quality) {
-	_compress_etc(p_img, p_lossy_quality, true, Image::COMPRESS_SOURCE_GENERIC);
+	_compress_etc(p_img, p_lossy_quality, true, Image::USED_CHANNELS_RGB);
 }
 
-static void _compress_etc2(Image *p_img, float p_lossy_quality, Image::CompressSource p_source) {
-	_compress_etc(p_img, p_lossy_quality, false, p_source);
+static void _compress_etc2(Image *p_img, float p_lossy_quality, Image::UsedChannels p_channels) {
+	_compress_etc(p_img, p_lossy_quality, false, p_channels);
 }
 
 void _register_etc_compress_func() {
diff --git a/modules/etc/texture_loader_pkm.cpp b/modules/etc/texture_loader_pkm.cpp
index 27c2358306..facdc2e473 100644
--- a/modules/etc/texture_loader_pkm.cpp
+++ b/modules/etc/texture_loader_pkm.cpp
@@ -103,7 +103,7 @@ void ResourceFormatPKM::get_recognized_extensions(List<String> *p_extensions) co
 
 bool ResourceFormatPKM::handles_type(const String &p_type) const {
 
-	return ClassDB::is_parent_class(p_type, "Texture");
+	return ClassDB::is_parent_class(p_type, "Texture2D");
 }
 
 String ResourceFormatPKM::get_resource_type(const String &p_path) const {
diff --git a/modules/gdnative/arvr/arvr_interface_gdnative.cpp b/modules/gdnative/arvr/arvr_interface_gdnative.cpp
index 5efa915f62..7c791a3108 100644
--- a/modules/gdnative/arvr/arvr_interface_gdnative.cpp
+++ b/modules/gdnative/arvr/arvr_interface_gdnative.cpp
@@ -286,9 +286,12 @@ void GDAPI godot_arvr_blit(godot_int p_eye, godot_rid *p_render_target, godot_re
 		screen_rect.size.x /= 2.0;
 		screen_rect.position.x += screen_rect.size.x;
 	}
-
-	VSG::rasterizer->set_current_render_target(RID());
+#ifndef _MSC_VER
+#warning this needs to be redone
+#endif
+#if 0
 	VSG::rasterizer->blit_render_target_to_screen(*render_target, screen_rect, 0);
+#endif
 }
 
 godot_int GDAPI godot_arvr_get_texid(godot_rid *p_render_target) {
@@ -297,7 +300,10 @@ godot_int GDAPI godot_arvr_get_texid(godot_rid *p_render_target) {
 	RID *render_target = (RID *)p_render_target;
 
 	RID eye_texture = VSG::storage->render_target_get_texture(*render_target);
-	uint32_t texid = VS::get_singleton()->texture_get_texid(eye_texture);
+#ifndef _MSC_VER
+#warning need to obtain this ID again
+#endif
+	uint32_t texid = 0; //VS::get_singleton()->texture_get_texid(eye_texture);
 
 	return texid;
 }
diff --git a/modules/gdnative/videodecoder/video_stream_gdnative.cpp b/modules/gdnative/videodecoder/video_stream_gdnative.cpp
index dbe00cdf71..8dcafc1987 100644
--- a/modules/gdnative/videodecoder/video_stream_gdnative.cpp
+++ b/modules/gdnative/videodecoder/video_stream_gdnative.cpp
@@ -132,7 +132,11 @@ bool VideoStreamPlaybackGDNative::open_file(const String &p_file) {
 		pcm_write_idx = -1;
 		samples_decoded = 0;
 
-		texture->create((int)texture_size.width, (int)texture_size.height, Image::FORMAT_RGBA8, Texture::FLAG_FILTER | Texture::FLAG_VIDEO_SURFACE);
+		Ref<Image> img;
+		img.instance();
+		img->create((int)texture_size.width, false, (int)texture_size.height, Image::FORMAT_RGBA8);
+
+		texture->create_from_image(img);
 	}
 
 	return file_opened;
@@ -192,7 +196,7 @@ void VideoStreamPlaybackGDNative::update_texture() {
 
 	Ref<Image> img = memnew(Image(texture_size.width, texture_size.height, 0, Image::FORMAT_RGBA8, *pba));
 
-	texture->set_data(img);
+	texture->update(img, true);
 }
 
 // ctor and dtor
@@ -283,7 +287,7 @@ void VideoStreamPlaybackGDNative::set_paused(bool p_paused) {
 	paused = p_paused;
 }
 
-Ref<Texture> VideoStreamPlaybackGDNative::get_texture() const {
+Ref<Texture2D> VideoStreamPlaybackGDNative::get_texture() const {
 	return texture;
 }
 
diff --git a/modules/gdnative/videodecoder/video_stream_gdnative.h b/modules/gdnative/videodecoder/video_stream_gdnative.h
index bb0346efb4..024cdec196 100644
--- a/modules/gdnative/videodecoder/video_stream_gdnative.h
+++ b/modules/gdnative/videodecoder/video_stream_gdnative.h
@@ -168,7 +168,7 @@ public:
 
 	//virtual int mix(int16_t* p_buffer,int p_frames)=0;
 
-	virtual Ref<Texture> get_texture() const;
+	virtual Ref<Texture2D> get_texture() const;
 	virtual void update(float p_delta);
 
 	virtual void set_mix_callback(AudioMixCallback p_callback, void *p_userdata);
diff --git a/modules/gdnavigation/gd_navigation_server.cpp b/modules/gdnavigation/gd_navigation_server.cpp
index f3ffd93c9c..ddfb3c10fa 100644
--- a/modules/gdnavigation/gd_navigation_server.cpp
+++ b/modules/gdnavigation/gd_navigation_server.cpp
@@ -6,7 +6,7 @@
 /*                      https://godotengine.org                          */
 /*************************************************************************/
 /* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md)    */
+/* Copyright (c) 2014-2020 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       */
@@ -140,7 +140,7 @@ RID GdNavigationServer::map_create() const {
 }
 
 COMMAND_2(map_set_active, RID, p_map, bool, p_active) {
-	NavMap *map = map_owner.get(p_map);
+	NavMap *map = map_owner.getornull(p_map);
 	ERR_FAIL_COND(map == NULL);
 
 	if (p_active) {
@@ -153,56 +153,56 @@ COMMAND_2(map_set_active, RID, p_map, bool, p_active) {
 }
 
 bool GdNavigationServer::map_is_active(RID p_map) const {
-	NavMap *map = map_owner.get(p_map);
+	NavMap *map = map_owner.getornull(p_map);
 	ERR_FAIL_COND_V(map == NULL, false);
 
 	return active_maps.find(map) >= 0;
 }
 
 COMMAND_2(map_set_up, RID, p_map, Vector3, p_up) {
-	NavMap *map = map_owner.get(p_map);
+	NavMap *map = map_owner.getornull(p_map);
 	ERR_FAIL_COND(map == NULL);
 
 	map->set_up(p_up);
 }
 
 Vector3 GdNavigationServer::map_get_up(RID p_map) const {
-	NavMap *map = map_owner.get(p_map);
+	NavMap *map = map_owner.getornull(p_map);
 	ERR_FAIL_COND_V(map == NULL, Vector3());
 
 	return map->get_up();
 }
 
 COMMAND_2(map_set_cell_size, RID, p_map, real_t, p_cell_size) {
-	NavMap *map = map_owner.get(p_map);
+	NavMap *map = map_owner.getornull(p_map);
 	ERR_FAIL_COND(map == NULL);
 
 	map->set_cell_size(p_cell_size);
 }
 
 real_t GdNavigationServer::map_get_cell_size(RID p_map) const {
-	NavMap *map = map_owner.get(p_map);
+	NavMap *map = map_owner.getornull(p_map);
 	ERR_FAIL_COND_V(map == NULL, 0);
 
 	return map->get_cell_size();
 }
 
 COMMAND_2(map_set_edge_connection_margin, RID, p_map, real_t, p_connection_margin) {
-	NavMap *map = map_owner.get(p_map);
+	NavMap *map = map_owner.getornull(p_map);
 	ERR_FAIL_COND(map == NULL);
 
 	map->set_edge_connection_margin(p_connection_margin);
 }
 
 real_t GdNavigationServer::map_get_edge_connection_margin(RID p_map) const {
-	NavMap *map = map_owner.get(p_map);
+	NavMap *map = map_owner.getornull(p_map);
 	ERR_FAIL_COND_V(map == NULL, 0);
 
 	return map->get_edge_connection_margin();
 }
 
 Vector<Vector3> GdNavigationServer::map_get_path(RID p_map, Vector3 p_origin, Vector3 p_destination, bool p_optimize) const {
-	NavMap *map = map_owner.get(p_map);
+	NavMap *map = map_owner.getornull(p_map);
 	ERR_FAIL_COND_V(map == NULL, Vector<Vector3>());
 
 	return map->get_path(p_origin, p_destination, p_optimize);
@@ -219,7 +219,7 @@ RID GdNavigationServer::region_create() const {
 }
 
 COMMAND_2(region_set_map, RID, p_region, RID, p_map) {
-	NavRegion *region = region_owner.get(p_region);
+	NavRegion *region = region_owner.getornull(p_region);
 	ERR_FAIL_COND(region == NULL);
 
 	if (region->get_map() != NULL) {
@@ -232,7 +232,7 @@ COMMAND_2(region_set_map, RID, p_region, RID, p_map) {
 	}
 
 	if (p_map.is_valid()) {
-		NavMap *map = map_owner.get(p_map);
+		NavMap *map = map_owner.getornull(p_map);
 		ERR_FAIL_COND(map == NULL);
 
 		map->add_region(region);
@@ -241,14 +241,14 @@ COMMAND_2(region_set_map, RID, p_region, RID, p_map) {
 }
 
 COMMAND_2(region_set_transform, RID, p_region, Transform, p_transform) {
-	NavRegion *region = region_owner.get(p_region);
+	NavRegion *region = region_owner.getornull(p_region);
 	ERR_FAIL_COND(region == NULL);
 
 	region->set_transform(p_transform);
 }
 
 COMMAND_2(region_set_navmesh, RID, p_region, Ref<NavigationMesh>, p_nav_mesh) {
-	NavRegion *region = region_owner.get(p_region);
+	NavRegion *region = region_owner.getornull(p_region);
 	ERR_FAIL_COND(region == NULL);
 
 	region->set_mesh(p_nav_mesh);
@@ -275,7 +275,7 @@ RID GdNavigationServer::agent_create() const {
 }
 
 COMMAND_2(agent_set_map, RID, p_agent, RID, p_map) {
-	RvoAgent *agent = agent_owner.get(p_agent);
+	RvoAgent *agent = agent_owner.getornull(p_agent);
 	ERR_FAIL_COND(agent == NULL);
 
 	if (agent->get_map()) {
@@ -288,7 +288,7 @@ COMMAND_2(agent_set_map, RID, p_agent, RID, p_map) {
 	agent->set_map(NULL);
 
 	if (p_map.is_valid()) {
-		NavMap *map = map_owner.get(p_map);
+		NavMap *map = map_owner.getornull(p_map);
 		ERR_FAIL_COND(map == NULL);
 
 		agent->set_map(map);
@@ -301,77 +301,77 @@ COMMAND_2(agent_set_map, RID, p_agent, RID, p_map) {
 }
 
 COMMAND_2(agent_set_neighbor_dist, RID, p_agent, real_t, p_dist) {
-	RvoAgent *agent = agent_owner.get(p_agent);
+	RvoAgent *agent = agent_owner.getornull(p_agent);
 	ERR_FAIL_COND(agent == NULL);
 
 	agent->get_agent()->neighborDist_ = p_dist;
 }
 
 COMMAND_2(agent_set_max_neighbors, RID, p_agent, int, p_count) {
-	RvoAgent *agent = agent_owner.get(p_agent);
+	RvoAgent *agent = agent_owner.getornull(p_agent);
 	ERR_FAIL_COND(agent == NULL);
 
 	agent->get_agent()->maxNeighbors_ = p_count;
 }
 
 COMMAND_2(agent_set_time_horizon, RID, p_agent, real_t, p_time) {
-	RvoAgent *agent = agent_owner.get(p_agent);
+	RvoAgent *agent = agent_owner.getornull(p_agent);
 	ERR_FAIL_COND(agent == NULL);
 
 	agent->get_agent()->timeHorizon_ = p_time;
 }
 
 COMMAND_2(agent_set_radius, RID, p_agent, real_t, p_radius) {
-	RvoAgent *agent = agent_owner.get(p_agent);
+	RvoAgent *agent = agent_owner.getornull(p_agent);
 	ERR_FAIL_COND(agent == NULL);
 
 	agent->get_agent()->radius_ = p_radius;
 }
 
 COMMAND_2(agent_set_max_speed, RID, p_agent, real_t, p_max_speed) {
-	RvoAgent *agent = agent_owner.get(p_agent);
+	RvoAgent *agent = agent_owner.getornull(p_agent);
 	ERR_FAIL_COND(agent == NULL);
 
 	agent->get_agent()->maxSpeed_ = p_max_speed;
 }
 
 COMMAND_2(agent_set_velocity, RID, p_agent, Vector3, p_velocity) {
-	RvoAgent *agent = agent_owner.get(p_agent);
+	RvoAgent *agent = agent_owner.getornull(p_agent);
 	ERR_FAIL_COND(agent == NULL);
 
 	agent->get_agent()->velocity_ = RVO::Vector3(p_velocity.x, p_velocity.y, p_velocity.z);
 }
 
 COMMAND_2(agent_set_target_velocity, RID, p_agent, Vector3, p_velocity) {
-	RvoAgent *agent = agent_owner.get(p_agent);
+	RvoAgent *agent = agent_owner.getornull(p_agent);
 	ERR_FAIL_COND(agent == NULL);
 
 	agent->get_agent()->prefVelocity_ = RVO::Vector3(p_velocity.x, p_velocity.y, p_velocity.z);
 }
 
 COMMAND_2(agent_set_position, RID, p_agent, Vector3, p_position) {
-	RvoAgent *agent = agent_owner.get(p_agent);
+	RvoAgent *agent = agent_owner.getornull(p_agent);
 	ERR_FAIL_COND(agent == NULL);
 
 	agent->get_agent()->position_ = RVO::Vector3(p_position.x, p_position.y, p_position.z);
 }
 
 COMMAND_2(agent_set_ignore_y, RID, p_agent, bool, p_ignore) {
-	RvoAgent *agent = agent_owner.get(p_agent);
+	RvoAgent *agent = agent_owner.getornull(p_agent);
 	ERR_FAIL_COND(agent == NULL);
 
 	agent->get_agent()->ignore_y_ = p_ignore;
 }
 
 bool GdNavigationServer::agent_is_map_changed(RID p_agent) const {
-	RvoAgent *agent = agent_owner.get(p_agent);
+	RvoAgent *agent = agent_owner.getornull(p_agent);
 	ERR_FAIL_COND_V(agent == NULL, false);
 
 	return agent->is_map_changed();
 }
 
 COMMAND_4(agent_set_callback, RID, p_agent, Object *, p_receiver, StringName, p_method, Variant, p_udata) {
-	RvoAgent *agent = agent_owner.get(p_agent);
+	RvoAgent *agent = agent_owner.getornull(p_agent);
 	ERR_FAIL_COND(agent == NULL);
 
 	agent->set_callback(p_receiver == NULL ? 0 : p_receiver->get_instance_id(), p_method, p_udata);
@@ -387,7 +387,7 @@ COMMAND_4(agent_set_callback, RID, p_agent, Object *, p_receiver, StringName, p_
 
 COMMAND_1(free, RID, p_object) {
 	if (map_owner.owns(p_object)) {
-		NavMap *map = map_owner.get(p_object);
+		NavMap *map = map_owner.getornull(p_object);
 
 		// Removes any assigned region
 		std::vector<NavRegion *> regions = map->get_regions();
@@ -408,7 +408,7 @@ COMMAND_1(free, RID, p_object) {
 		memdelete(map);
 
 	} else if (region_owner.owns(p_object)) {
-		NavRegion *region = region_owner.get(p_object);
+		NavRegion *region = region_owner.getornull(p_object);
 
 		// Removes this region from the map if assigned
 		if (region->get_map() != NULL) {
@@ -420,7 +420,7 @@ COMMAND_1(free, RID, p_object) {
 		memdelete(region);
 
 	} else if (agent_owner.owns(p_object)) {
-		RvoAgent *agent = agent_owner.get(p_object);
+		RvoAgent *agent = agent_owner.getornull(p_object);
 
 		// Removes this agent from the map if assigned
 		if (agent->get_map() != NULL) {
diff --git a/modules/gdnavigation/gd_navigation_server.h b/modules/gdnavigation/gd_navigation_server.h
index 80ba06880c..564e9870a0 100644
--- a/modules/gdnavigation/gd_navigation_server.h
+++ b/modules/gdnavigation/gd_navigation_server.h
@@ -6,7 +6,7 @@
 /*                      https://godotengine.org                          */
 /*************************************************************************/
 /* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md)    */
+/* Copyright (c) 2014-2020 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       */
@@ -31,6 +31,8 @@
 #ifndef GD_NAVIGATION_SERVER_H
 #define GD_NAVIGATION_SERVER_H
 
+#include "core/rid.h"
+#include "core/rid_owner.h"
 #include "servers/navigation_server.h"
 
 #include "nav_map.h"
@@ -73,9 +75,9 @@ class GdNavigationServer : public NavigationServer {
 
 	std::vector<SetCommand *> commands;
 
-	mutable RID_Owner<NavMap> map_owner;
-	mutable RID_Owner<NavRegion> region_owner;
-	mutable RID_Owner<RvoAgent> agent_owner;
+	mutable RID_PtrOwner<NavMap> map_owner;
+	mutable RID_PtrOwner<NavRegion> region_owner;
+	mutable RID_PtrOwner<RvoAgent> agent_owner;
 
 	bool active;
 	Vector<NavMap *> active_maps;
diff --git a/modules/gdnavigation/nav_map.cpp b/modules/gdnavigation/nav_map.cpp
index 3d0e02c77d..d1765f4da9 100644
--- a/modules/gdnavigation/nav_map.cpp
+++ b/modules/gdnavigation/nav_map.cpp
@@ -1,12 +1,12 @@
 /*************************************************************************/
-/*  rvo_space.cpp                                                        */
+/*  nav_map.cpp                                                          */
 /*************************************************************************/
 /*                       This file is part of:                           */
 /*                           GODOT ENGINE                                */
 /*                      https://godotengine.org                          */
 /*************************************************************************/
 /* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md)    */
+/* Copyright (c) 2014-2020 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       */
diff --git a/modules/gdnavigation/nav_map.h b/modules/gdnavigation/nav_map.h
index 636c07e437..128a82580c 100644
--- a/modules/gdnavigation/nav_map.h
+++ b/modules/gdnavigation/nav_map.h
@@ -1,12 +1,12 @@
 /*************************************************************************/
-/*  rvo_space.h                                                          */
+/*  nav_map.h                                                            */
 /*************************************************************************/
 /*                       This file is part of:                           */
 /*                           GODOT ENGINE                                */
 /*                      https://godotengine.org                          */
 /*************************************************************************/
 /* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md)    */
+/* Copyright (c) 2014-2020 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       */
diff --git a/modules/gdnavigation/nav_region.cpp b/modules/gdnavigation/nav_region.cpp
index 03477085ce..d2d9d8b517 100644
--- a/modules/gdnavigation/nav_region.cpp
+++ b/modules/gdnavigation/nav_region.cpp
@@ -1,12 +1,12 @@
 /*************************************************************************/
-/*  nav_region.h                                                         */
+/*  nav_region.cpp                                                       */
 /*************************************************************************/
 /*                       This file is part of:                           */
 /*                           GODOT ENGINE                                */
 /*                      https://godotengine.org                          */
 /*************************************************************************/
 /* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md)    */
+/* Copyright (c) 2014-2020 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       */
diff --git a/modules/gdnavigation/nav_region.h b/modules/gdnavigation/nav_region.h
index c961257163..d99254d1ad 100644
--- a/modules/gdnavigation/nav_region.h
+++ b/modules/gdnavigation/nav_region.h
@@ -1,12 +1,12 @@
 /*************************************************************************/
-/*  nav_region.cpp                                                       */
+/*  nav_region.h                                                         */
 /*************************************************************************/
 /*                       This file is part of:                           */
 /*                           GODOT ENGINE                                */
 /*                      https://godotengine.org                          */
 /*************************************************************************/
 /* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md)    */
+/* Copyright (c) 2014-2020 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       */
diff --git a/modules/gdnavigation/nav_rid.h b/modules/gdnavigation/nav_rid.h
index 96e22800c2..c119ecc5e0 100644
--- a/modules/gdnavigation/nav_rid.h
+++ b/modules/gdnavigation/nav_rid.h
@@ -1,12 +1,12 @@
 /*************************************************************************/
-/*  rvo_rid.h                                                            */
+/*  nav_rid.h                                                            */
 /*************************************************************************/
 /*                       This file is part of:                           */
 /*                           GODOT ENGINE                                */
 /*                      https://godotengine.org                          */
 /*************************************************************************/
 /* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md)    */
+/* Copyright (c) 2014-2020 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       */
@@ -37,7 +37,7 @@
 	@author AndreaCatania
 */
 
-class NavRid : public RID_Data {
+class NavRid {
 	RID self;
 
 public:
diff --git a/modules/gdnavigation/nav_utils.h b/modules/gdnavigation/nav_utils.h
index 1048f58294..bdf9eb34a8 100644
--- a/modules/gdnavigation/nav_utils.h
+++ b/modules/gdnavigation/nav_utils.h
@@ -1,12 +1,12 @@
 /*************************************************************************/
-/*  utils.h                                                              */
+/*  nav_utils.h                                                          */
 /*************************************************************************/
 /*                       This file is part of:                           */
 /*                           GODOT ENGINE                                */
 /*                      https://godotengine.org                          */
 /*************************************************************************/
 /* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md)    */
+/* Copyright (c) 2014-2020 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       */
diff --git a/modules/gdnavigation/rvo_agent.cpp b/modules/gdnavigation/rvo_agent.cpp
index 37a9b31351..eb66eb3a05 100644
--- a/modules/gdnavigation/rvo_agent.cpp
+++ b/modules/gdnavigation/rvo_agent.cpp
@@ -6,7 +6,7 @@
 /*                      https://godotengine.org                          */
 /*************************************************************************/
 /* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md)    */
+/* Copyright (c) 2014-2020 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       */
diff --git a/modules/gdnavigation/rvo_agent.h b/modules/gdnavigation/rvo_agent.h
index 6a84c1b95c..914cbaa7d9 100644
--- a/modules/gdnavigation/rvo_agent.h
+++ b/modules/gdnavigation/rvo_agent.h
@@ -6,7 +6,7 @@
 /*                      https://godotengine.org                          */
 /*************************************************************************/
 /* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md)    */
+/* Copyright (c) 2014-2020 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       */
diff --git a/modules/glslang/SCsub b/modules/glslang/SCsub
new file mode 100644
index 0000000000..8c9445436e
--- /dev/null
+++ b/modules/glslang/SCsub
@@ -0,0 +1,68 @@
+#!/usr/bin/env python
+
+Import('env')
+Import('env_modules')
+
+env_glslang = env_modules.Clone()
+
+# Thirdparty source files
+if env['builtin_glslang']:
+    thirdparty_dir = "#thirdparty/glslang/"
+    thirdparty_sources = [
+        "glslang/MachineIndependent/RemoveTree.cpp",
+        "glslang/MachineIndependent/ParseHelper.cpp",
+        "glslang/MachineIndependent/iomapper.cpp",
+        "glslang/MachineIndependent/propagateNoContraction.cpp",
+        "glslang/MachineIndependent/Intermediate.cpp",
+        "glslang/MachineIndependent/linkValidate.cpp",
+        "glslang/MachineIndependent/attribute.cpp",
+        "glslang/MachineIndependent/Scan.cpp",
+        "glslang/MachineIndependent/Initialize.cpp",
+        "glslang/MachineIndependent/Constant.cpp",
+        "glslang/MachineIndependent/reflection.cpp",
+        "glslang/MachineIndependent/limits.cpp",
+        "glslang/MachineIndependent/preprocessor/PpScanner.cpp",
+        "glslang/MachineIndependent/preprocessor/PpTokens.cpp",
+        "glslang/MachineIndependent/preprocessor/PpAtom.cpp",
+        "glslang/MachineIndependent/preprocessor/PpContext.cpp",
+        "glslang/MachineIndependent/preprocessor/Pp.cpp",
+        "glslang/MachineIndependent/InfoSink.cpp",
+        "glslang/MachineIndependent/intermOut.cpp",
+        "glslang/MachineIndependent/SymbolTable.cpp",
+        "glslang/MachineIndependent/glslang_tab.cpp",
+        "glslang/MachineIndependent/pch.cpp",
+        "glslang/MachineIndependent/Versions.cpp",
+        "glslang/MachineIndependent/ShaderLang.cpp",
+        "glslang/MachineIndependent/parseConst.cpp",
+        "glslang/MachineIndependent/PoolAlloc.cpp",
+        "glslang/MachineIndependent/ParseContextBase.cpp",
+        "glslang/MachineIndependent/IntermTraverse.cpp",
+        "glslang/GenericCodeGen/Link.cpp",
+        "glslang/GenericCodeGen/CodeGen.cpp",
+        "OGLCompilersDLL/InitializeDll.cpp",
+        "SPIRV/InReadableOrder.cpp",
+        "SPIRV/GlslangToSpv.cpp",
+        "SPIRV/SpvBuilder.cpp",
+        "SPIRV/SpvTools.cpp",
+        "SPIRV/disassemble.cpp",
+        "SPIRV/doc.cpp",
+        "SPIRV/SPVRemapper.cpp",
+        "SPIRV/SpvPostProcess.cpp",
+        "SPIRV/Logger.cpp"
+    ]
+
+    if (env["platform"]=="windows"):
+        thirdparty_sources.append("glslang/OSDependent/Windows/ossource.cpp")
+    else:
+        thirdparty_sources.append("glslang/OSDependent/Unix/ossource.cpp")
+
+    thirdparty_sources = [thirdparty_dir + file for file in thirdparty_sources]
+
+    env_glslang.Prepend(CPPPATH=[thirdparty_dir])
+
+    env_thirdparty = env_glslang.Clone()
+    env_thirdparty.disable_warnings()
+    env_thirdparty.add_source_files(env.modules_sources, thirdparty_sources)
+
+# Godot's own source files
+env_glslang.add_source_files(env.modules_sources, "*.cpp")
diff --git a/modules/glslang/config.py b/modules/glslang/config.py
new file mode 100644
index 0000000000..1c8cd12a2d
--- /dev/null
+++ b/modules/glslang/config.py
@@ -0,0 +1,5 @@
+def can_build(env, platform):
+    return True
+
+def configure(env):
+    pass
diff --git a/modules/glslang/register_types.cpp b/modules/glslang/register_types.cpp
new file mode 100644
index 0000000000..1e4481a6a0
--- /dev/null
+++ b/modules/glslang/register_types.cpp
@@ -0,0 +1,246 @@
+/*************************************************************************/
+/*  register_types.cpp                                                   */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2020 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 "register_types.h"
+
+#include "servers/visual/rendering_device.h"
+
+#include <SPIRV/GlslangToSpv.h>
+#include <glslang/Include/Types.h>
+#include <glslang/Public/ShaderLang.h>
+
+static const TBuiltInResource default_builtin_resource = {
+	/*maxLights*/ 32,
+	/*maxClipPlanes*/ 6,
+	/*maxTextureUnits*/ 32,
+	/*maxTextureCoords*/ 32,
+	/*maxVertexAttribs*/ 64,
+	/*maxVertexUniformComponents*/ 4096,
+	/*maxVaryingFloats*/ 64,
+	/*maxVertexTextureImageUnits*/ 32,
+	/*maxCombinedTextureImageUnits*/ 80,
+	/*maxTextureImageUnits*/ 32,
+	/*maxFragmentUniformComponents*/ 4096,
+	/*maxDrawBuffers*/ 32,
+	/*maxVertexUniformVectors*/ 128,
+	/*maxVaryingVectors*/ 8,
+	/*maxFragmentUniformVectors*/ 16,
+	/*maxVertexOutputVectors*/ 16,
+	/*maxFragmentInputVectors*/ 15,
+	/*minProgramTexelOffset*/ -8,
+	/*maxProgramTexelOffset*/ 7,
+	/*maxClipDistances*/ 8,
+	/*maxComputeWorkGroupCountX*/ 65535,
+	/*maxComputeWorkGroupCountY*/ 65535,
+	/*maxComputeWorkGroupCountZ*/ 65535,
+	/*maxComputeWorkGroupSizeX*/ 1024,
+	/*maxComputeWorkGroupSizeY*/ 1024,
+	/*maxComputeWorkGroupSizeZ*/ 64,
+	/*maxComputeUniformComponents*/ 1024,
+	/*maxComputeTextureImageUnits*/ 16,
+	/*maxComputeImageUniforms*/ 8,
+	/*maxComputeAtomicCounters*/ 8,
+	/*maxComputeAtomicCounterBuffers*/ 1,
+	/*maxVaryingComponents*/ 60,
+	/*maxVertexOutputComponents*/ 64,
+	/*maxGeometryInputComponents*/ 64,
+	/*maxGeometryOutputComponents*/ 128,
+	/*maxFragmentInputComponents*/ 128,
+	/*maxImageUnits*/ 8,
+	/*maxCombinedImageUnitsAndFragmentOutputs*/ 8,
+	/*maxCombinedShaderOutputResources*/ 8,
+	/*maxImageSamples*/ 0,
+	/*maxVertexImageUniforms*/ 0,
+	/*maxTessControlImageUniforms*/ 0,
+	/*maxTessEvaluationImageUniforms*/ 0,
+	/*maxGeometryImageUniforms*/ 0,
+	/*maxFragmentImageUniforms*/ 8,
+	/*maxCombinedImageUniforms*/ 8,
+	/*maxGeometryTextureImageUnits*/ 16,
+	/*maxGeometryOutputVertices*/ 256,
+	/*maxGeometryTotalOutputComponents*/ 1024,
+	/*maxGeometryUniformComponents*/ 1024,
+	/*maxGeometryVaryingComponents*/ 64,
+	/*maxTessControlInputComponents*/ 128,
+	/*maxTessControlOutputComponents*/ 128,
+	/*maxTessControlTextureImageUnits*/ 16,
+	/*maxTessControlUniformComponents*/ 1024,
+	/*maxTessControlTotalOutputComponents*/ 4096,
+	/*maxTessEvaluationInputComponents*/ 128,
+	/*maxTessEvaluationOutputComponents*/ 128,
+	/*maxTessEvaluationTextureImageUnits*/ 16,
+	/*maxTessEvaluationUniformComponents*/ 1024,
+	/*maxTessPatchComponents*/ 120,
+	/*maxPatchVertices*/ 32,
+	/*maxTessGenLevel*/ 64,
+	/*maxViewports*/ 16,
+	/*maxVertexAtomicCounters*/ 0,
+	/*maxTessControlAtomicCounters*/ 0,
+	/*maxTessEvaluationAtomicCounters*/ 0,
+	/*maxGeometryAtomicCounters*/ 0,
+	/*maxFragmentAtomicCounters*/ 8,
+	/*maxCombinedAtomicCounters*/ 8,
+	/*maxAtomicCounterBindings*/ 1,
+	/*maxVertexAtomicCounterBuffers*/ 0,
+	/*maxTessControlAtomicCounterBuffers*/ 0,
+	/*maxTessEvaluationAtomicCounterBuffers*/ 0,
+	/*maxGeometryAtomicCounterBuffers*/ 0,
+	/*maxFragmentAtomicCounterBuffers*/ 1,
+	/*maxCombinedAtomicCounterBuffers*/ 1,
+	/*maxAtomicCounterBufferSize*/ 16384,
+	/*maxTransformFeedbackBuffers*/ 4,
+	/*maxTransformFeedbackInterleavedComponents*/ 64,
+	/*maxCullDistances*/ 8,
+	/*maxCombinedClipAndCullDistances*/ 8,
+	/*maxSamples*/ 4,
+	/*maxMeshOutputVerticesNV*/ 0,
+	/*maxMeshOutputPrimitivesNV*/ 0,
+	/*maxMeshWorkGroupSizeX_NV*/ 0,
+	/*maxMeshWorkGroupSizeY_NV*/ 0,
+	/*maxMeshWorkGroupSizeZ_NV*/ 0,
+	/*maxTaskWorkGroupSizeX_NV*/ 0,
+	/*maxTaskWorkGroupSizeY_NV*/ 0,
+	/*maxTaskWorkGroupSizeZ_NV*/ 0,
+	/*maxMeshViewCountNV*/ 0,
+	/*limits*/ {
+			/*nonInductiveForLoops*/ 1,
+			/*whileLoops*/ 1,
+			/*doWhileLoops*/ 1,
+			/*generalUniformIndexing*/ 1,
+			/*generalAttributeMatrixVectorIndexing*/ 1,
+			/*generalVaryingIndexing*/ 1,
+			/*generalSamplerIndexing*/ 1,
+			/*generalVariableIndexing*/ 1,
+			/*generalConstantMatrixVectorIndexing*/ 1,
+	}
+};
+
+static PoolVector<uint8_t> _compile_shader_glsl(RenderingDevice::ShaderStage p_stage, const String &p_source_code, RenderingDevice::ShaderLanguage p_language, String *r_error) {
+
+	PoolVector<uint8_t> ret;
+
+	ERR_FAIL_COND_V(p_language == RenderingDevice::SHADER_LANGUAGE_HLSL, ret);
+
+	EShLanguage stages[RenderingDevice::SHADER_STAGE_MAX] = {
+		EShLangVertex,
+		EShLangFragment,
+		EShLangTessControl,
+		EShLangTessEvaluation,
+		EShLangCompute
+	};
+
+	int ClientInputSemanticsVersion = 100; // maps to, say, #define VULKAN 100
+
+	glslang::EShTargetClientVersion VulkanClientVersion = glslang::EShTargetVulkan_1_0;
+	glslang::EShTargetLanguageVersion TargetVersion = glslang::EShTargetSpv_1_0;
+	glslang::TShader::ForbidIncluder includer;
+
+	glslang::TShader shader(stages[p_stage]);
+	CharString cs = p_source_code.ascii();
+	const char *cs_strings = cs.get_data();
+
+	shader.setStrings(&cs_strings, 1);
+	shader.setEnvInput(glslang::EShSourceGlsl, stages[p_stage], glslang::EShClientVulkan, ClientInputSemanticsVersion);
+	shader.setEnvClient(glslang::EShClientVulkan, VulkanClientVersion);
+	shader.setEnvTarget(glslang::EShTargetSpv, TargetVersion);
+
+	EShMessages messages = (EShMessages)(EShMsgSpvRules | EShMsgVulkanRules);
+	const int DefaultVersion = 100;
+	std::string pre_processed_code;
+
+	//preprocess
+	if (!shader.preprocess(&default_builtin_resource, DefaultVersion, ENoProfile, false, false, messages, &pre_processed_code, includer)) {
+
+		if (r_error) {
+			(*r_error) = "Failed pre-process:\n";
+			(*r_error) += shader.getInfoLog();
+			(*r_error) += "\n";
+			(*r_error) += shader.getInfoDebugLog();
+		}
+
+		return ret;
+	}
+	//set back..
+	cs_strings = pre_processed_code.c_str();
+	shader.setStrings(&cs_strings, 1);
+
+	//parse
+	if (!shader.parse(&default_builtin_resource, DefaultVersion, false, messages)) {
+		if (r_error) {
+			(*r_error) = "Failed parse:\n";
+			(*r_error) += shader.getInfoLog();
+			(*r_error) += "\n";
+			(*r_error) += shader.getInfoDebugLog();
+		}
+		return ret;
+	}
+
+	//link
+	glslang::TProgram program;
+	program.addShader(&shader);
+
+	if (!program.link(messages)) {
+		if (r_error) {
+			(*r_error) = "Failed link:\n";
+			(*r_error) += program.getInfoLog();
+			(*r_error) += "\n";
+			(*r_error) += program.getInfoDebugLog();
+		}
+
+		return ret;
+	}
+
+	std::vector<uint32_t> SpirV;
+	spv::SpvBuildLogger logger;
+	glslang::SpvOptions spvOptions;
+	glslang::GlslangToSpv(*program.getIntermediate(stages[p_stage]), SpirV, &logger, &spvOptions);
+
+	ret.resize(SpirV.size() * sizeof(uint32_t));
+	{
+		PoolVector<uint8_t>::Write w = ret.write();
+		copymem(w.ptr(), &SpirV[0], SpirV.size() * sizeof(uint32_t));
+	}
+
+	return ret;
+}
+
+void preregister_glslang_types() {
+	// initialize in case it's not initialized. This is done once per thread
+	// and it's safe to call multiple times
+	glslang::InitializeProcess();
+	RenderingDevice::shader_set_compile_function(_compile_shader_glsl);
+}
+
+void register_glslang_types() {
+}
+void unregister_glslang_types() {
+
+	glslang::FinalizeProcess();
+}
diff --git a/modules/glslang/register_types.h b/modules/glslang/register_types.h
new file mode 100644
index 0000000000..37a1ef67f2
--- /dev/null
+++ b/modules/glslang/register_types.h
@@ -0,0 +1,34 @@
+/*************************************************************************/
+/*  register_types.h                                                     */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2020 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.                */
+/*************************************************************************/
+
+#define MODULE_GLSLANG_HAS_PREREGISTER
+void preregister_glslang_types();
+void register_glslang_types();
+void unregister_glslang_types();
diff --git a/modules/gridmap/grid_map.cpp b/modules/gridmap/grid_map.cpp
index 1e73a715db..7fe58f8ce7 100644
--- a/modules/gridmap/grid_map.cpp
+++ b/modules/gridmap/grid_map.cpp
@@ -514,7 +514,7 @@ bool GridMap::_octant_update(const OctantKey &p_key) {
 			Octant::MultimeshInstance mmi;
 
 			RID mm = VS::get_singleton()->multimesh_create();
-			VS::get_singleton()->multimesh_allocate(mm, E->get().size(), VS::MULTIMESH_TRANSFORM_3D, VS::MULTIMESH_COLOR_NONE);
+			VS::get_singleton()->multimesh_allocate(mm, E->get().size(), VS::MULTIMESH_TRANSFORM_3D);
 			VS::get_singleton()->multimesh_set_mesh(mm, mesh_library->get_item_mesh(E->key())->get_rid());
 
 			int idx = 0;
diff --git a/modules/gridmap/grid_map_editor_plugin.cpp b/modules/gridmap/grid_map_editor_plugin.cpp
index 28d301ada1..2144ff264f 100644
--- a/modules/gridmap/grid_map_editor_plugin.cpp
+++ b/modules/gridmap/grid_map_editor_plugin.cpp
@@ -925,7 +925,7 @@ void GridMapEditor::update_palette() {
 	for (List<_CGMEItemSort>::Element *E = il.front(); E; E = E->next()) {
 		int id = E->get().id;
 		String name = mesh_library->get_item_name(id);
-		Ref<Texture> preview = mesh_library->get_item_preview(id);
+		Ref<Texture2D> preview = mesh_library->get_item_preview(id);
 
 		if (name == "") {
 			name = "#" + itos(id);
@@ -1022,8 +1022,7 @@ void GridMapEditor::_draw_grids(const Vector3 &cell_size) {
 	Vector3 edited_floor = node->has_meta("_editor_floor_") ? node->get_meta("_editor_floor_") : Variant();
 
 	for (int i = 0; i < 3; i++) {
-		if (VS::get_singleton()->mesh_get_surface_count(grid[i]) > 0)
-			VS::get_singleton()->mesh_remove_surface(grid[i], 0);
+		VS::get_singleton()->mesh_clear(grid[i]);
 		edit_floor[i] = edited_floor[i];
 	}
 
@@ -1447,8 +1446,8 @@ GridMapEditor::GridMapEditor(EditorNode *p_editor) {
 
 		inner_mat.instance();
 		inner_mat->set_albedo(Color(0.7, 0.7, 1.0, 0.2));
-		inner_mat->set_flag(SpatialMaterial::FLAG_UNSHADED, true);
-		inner_mat->set_feature(SpatialMaterial::FEATURE_TRANSPARENT, true);
+		inner_mat->set_shading_mode(StandardMaterial3D::SHADING_MODE_UNSHADED);
+		inner_mat->set_transparency(StandardMaterial3D::TRANSPARENCY_ALPHA);
 
 		d[VS::ARRAY_VERTEX] = triangles;
 		VisualServer::get_singleton()->mesh_add_surface_from_arrays(selection_mesh, VS::PRIMITIVE_TRIANGLES, d);
@@ -1457,15 +1456,14 @@ GridMapEditor::GridMapEditor(EditorNode *p_editor) {
 		outer_mat.instance();
 		outer_mat->set_albedo(Color(0.7, 0.7, 1.0, 0.8));
 		outer_mat->set_on_top_of_alpha();
-		outer_mat->set_flag(SpatialMaterial::FLAG_UNSHADED, true);
-		outer_mat->set_line_width(3.0);
-		outer_mat->set_feature(SpatialMaterial::FEATURE_TRANSPARENT, true);
+
+		outer_mat->set_shading_mode(StandardMaterial3D::SHADING_MODE_UNSHADED);
+		outer_mat->set_transparency(StandardMaterial3D::TRANSPARENCY_ALPHA);
 
 		selection_floor_mat.instance();
 		selection_floor_mat->set_albedo(Color(0.80, 0.80, 1.0, 1));
 		selection_floor_mat->set_on_top_of_alpha();
-		selection_floor_mat->set_flag(SpatialMaterial::FLAG_UNSHADED, true);
-		selection_floor_mat->set_line_width(3.0);
+		selection_floor_mat->set_shading_mode(StandardMaterial3D::SHADING_MODE_UNSHADED);
 
 		d[VS::ARRAY_VERTEX] = lines;
 		VisualServer::get_singleton()->mesh_add_surface_from_arrays(selection_mesh, VS::PRIMITIVE_LINES, d);
@@ -1492,10 +1490,10 @@ GridMapEditor::GridMapEditor(EditorNode *p_editor) {
 	accumulated_floor_delta = 0.0;
 
 	indicator_mat.instance();
-	indicator_mat->set_flag(SpatialMaterial::FLAG_UNSHADED, true);
-	indicator_mat->set_feature(SpatialMaterial::FEATURE_TRANSPARENT, true);
-	indicator_mat->set_flag(SpatialMaterial::FLAG_SRGB_VERTEX_COLOR, true);
-	indicator_mat->set_flag(SpatialMaterial::FLAG_ALBEDO_FROM_VERTEX_COLOR, true);
+	indicator_mat->set_shading_mode(StandardMaterial3D::SHADING_MODE_UNSHADED);
+	indicator_mat->set_transparency(StandardMaterial3D::TRANSPARENCY_ALPHA);
+	indicator_mat->set_flag(StandardMaterial3D::FLAG_SRGB_VERTEX_COLOR, true);
+	indicator_mat->set_flag(StandardMaterial3D::FLAG_ALBEDO_FROM_VERTEX_COLOR, true);
 	indicator_mat->set_albedo(Color(0.8, 0.5, 0.1));
 }
 
diff --git a/modules/gridmap/grid_map_editor_plugin.h b/modules/gridmap/grid_map_editor_plugin.h
index 5e6221b4f0..d6459cee0a 100644
--- a/modules/gridmap/grid_map_editor_plugin.h
+++ b/modules/gridmap/grid_map_editor_plugin.h
@@ -125,10 +125,10 @@ class GridMapEditor : public VBoxContainer {
 
 	List<ClipboardItem> clipboard_items;
 
-	Ref<SpatialMaterial> indicator_mat;
-	Ref<SpatialMaterial> inner_mat;
-	Ref<SpatialMaterial> outer_mat;
-	Ref<SpatialMaterial> selection_floor_mat;
+	Ref<StandardMaterial3D> indicator_mat;
+	Ref<StandardMaterial3D> inner_mat;
+	Ref<StandardMaterial3D> outer_mat;
+	Ref<StandardMaterial3D> selection_floor_mat;
 
 	bool updating;
 
diff --git a/modules/mobile_vr/mobile_vr_interface.cpp b/modules/mobile_vr/mobile_vr_interface.cpp
index 22b708f206..97bc7945cd 100644
--- a/modules/mobile_vr/mobile_vr_interface.cpp
+++ b/modules/mobile_vr/mobile_vr_interface.cpp
@@ -426,11 +426,13 @@ void MobileVRInterface::commit_for_eye(ARVRInterface::Eyes p_eye, RID p_render_t
 	eye_center.y = 0.0;
 
 	// unset our render target so we are outputting to our main screen by making RasterizerStorageGLES3::system_fbo our current FBO
+#if 0
 	VSG::rasterizer->set_current_render_target(RID());
 
 	// and output
 	VSG::rasterizer->output_lens_distorted_to_screen(p_render_target, dest, k1, k2, eye_center, oversample);
-};
+#endif
+}
 
 void MobileVRInterface::process() {
 	_THREAD_SAFE_METHOD_
diff --git a/modules/opensimplex/noise_texture.cpp b/modules/opensimplex/noise_texture.cpp
index aa1c822813..19aa281a72 100644
--- a/modules/opensimplex/noise_texture.cpp
+++ b/modules/opensimplex/noise_texture.cpp
@@ -42,17 +42,16 @@ NoiseTexture::NoiseTexture() {
 	seamless = false;
 	as_normalmap = false;
 	bump_strength = 8.0;
-	flags = FLAGS_DEFAULT;
 
 	noise = Ref<OpenSimplexNoise>();
 
-	texture = VS::get_singleton()->texture_create();
-
 	_queue_update();
 }
 
 NoiseTexture::~NoiseTexture() {
-	VS::get_singleton()->free(texture);
+	if (texture.is_valid()) {
+		VS::get_singleton()->free(texture);
+	}
 	if (noise_thread) {
 		Thread::wait_to_finish(noise_thread);
 		memdelete(noise_thread);
@@ -101,8 +100,12 @@ void NoiseTexture::_validate_property(PropertyInfo &property) const {
 void NoiseTexture::_set_texture_data(const Ref<Image> &p_image) {
 	data = p_image;
 	if (data.is_valid()) {
-		VS::get_singleton()->texture_allocate(texture, size.x, size.y, 0, Image::FORMAT_RGBA8, VS::TEXTURE_TYPE_2D, flags);
-		VS::get_singleton()->texture_set_data(texture, p_image);
+		if (texture.is_valid()) {
+			RID new_texture = VS::get_singleton()->texture_2d_create(p_image);
+			VS::get_singleton()->texture_replace(texture, new_texture);
+		} else {
+			texture = VS::get_singleton()->texture_2d_create(p_image);
+		}
 	}
 	emit_changed();
 }
@@ -250,13 +253,12 @@ int NoiseTexture::get_height() const {
 	return size.y;
 }
 
-void NoiseTexture::set_flags(uint32_t p_flags) {
-	flags = p_flags;
-	VS::get_singleton()->texture_set_flags(texture, flags);
-}
+RID NoiseTexture::get_rid() const {
+	if (!texture.is_valid()) {
+		texture = VS::get_singleton()->texture_2d_placeholder_create();
+	}
 
-uint32_t NoiseTexture::get_flags() const {
-	return flags;
+	return texture;
 }
 
 Ref<Image> NoiseTexture::get_data() const {
diff --git a/modules/opensimplex/noise_texture.h b/modules/opensimplex/noise_texture.h
index 285fd1eba9..b1d7d3fac9 100644
--- a/modules/opensimplex/noise_texture.h
+++ b/modules/opensimplex/noise_texture.h
@@ -39,8 +39,8 @@
 #include "editor/editor_plugin.h"
 #include "editor/property_editor.h"
 
-class NoiseTexture : public Texture {
-	GDCLASS(NoiseTexture, Texture);
+class NoiseTexture : public Texture2D {
+	GDCLASS(NoiseTexture, Texture2D);
 
 private:
 	Ref<Image> data;
@@ -51,7 +51,7 @@ private:
 	bool update_queued;
 	bool regen_queued;
 
-	RID texture;
+	mutable RID texture;
 	uint32_t flags;
 
 	Ref<OpenSimplexNoise> noise;
@@ -91,10 +91,7 @@ public:
 	int get_width() const;
 	int get_height() const;
 
-	virtual void set_flags(uint32_t p_flags);
-	virtual uint32_t get_flags() const;
-
-	virtual RID get_rid() const { return texture; }
+	virtual RID get_rid() const;
 	virtual bool has_alpha() const { return false; }
 
 	virtual Ref<Image> get_data() const;
diff --git a/modules/pvr/texture_loader_pvr.cpp b/modules/pvr/texture_loader_pvr.cpp
index 65c21d5af8..36f2fe1ba1 100644
--- a/modules/pvr/texture_loader_pvr.cpp
+++ b/modules/pvr/texture_loader_pvr.cpp
@@ -154,16 +154,11 @@ RES ResourceFormatPVR::load(const String &p_path, const String &p_original_path,
 
 	w.release();
 
-	int tex_flags = Texture::FLAG_FILTER | Texture::FLAG_REPEAT;
-
-	if (mipmaps)
-		tex_flags |= Texture::FLAG_MIPMAPS;
-
 	Ref<Image> image = memnew(Image(width, height, mipmaps, format, data));
 	ERR_FAIL_COND_V(image->empty(), RES());
 
 	Ref<ImageTexture> texture = memnew(ImageTexture);
-	texture->create_from_image(image, tex_flags);
+	texture->create_from_image(image);
 
 	if (r_error)
 		*r_error = OK;
@@ -177,12 +172,12 @@ void ResourceFormatPVR::get_recognized_extensions(List<String> *p_extensions) co
 }
 bool ResourceFormatPVR::handles_type(const String &p_type) const {
 
-	return ClassDB::is_parent_class(p_type, "Texture");
+	return ClassDB::is_parent_class(p_type, "Texture2D");
 }
 String ResourceFormatPVR::get_resource_type(const String &p_path) const {
 
 	if (p_path.get_extension().to_lower() == "pvr")
-		return "Texture";
+		return "Texture2D";
 	return "";
 }
 
diff --git a/modules/register_module_types.h b/modules/register_module_types.h
index b410457201..acd9fc7c97 100644
--- a/modules/register_module_types.h
+++ b/modules/register_module_types.h
@@ -31,6 +31,7 @@
 #ifndef REGISTER_MODULE_TYPES_H
 #define REGISTER_MODULE_TYPES_H
 
+void preregister_module_types();
 void register_module_types();
 void unregister_module_types();
 
diff --git a/modules/squish/image_compress_squish.cpp b/modules/squish/image_compress_squish.cpp
index 58b8115dfc..2f680fd3d0 100644
--- a/modules/squish/image_compress_squish.cpp
+++ b/modules/squish/image_compress_squish.cpp
@@ -50,7 +50,7 @@ void image_decompress_squish(Image *p_image) {
 		squish_flags = squish::kDxt1;
 	} else if (p_image->get_format() == Image::FORMAT_DXT3) {
 		squish_flags = squish::kDxt3;
-	} else if (p_image->get_format() == Image::FORMAT_DXT5) {
+	} else if (p_image->get_format() == Image::FORMAT_DXT5 || p_image->get_format() == Image::FORMAT_DXT5_RA_AS_RG) {
 		squish_flags = squish::kDxt5;
 	} else if (p_image->get_format() == Image::FORMAT_RGTC_R) {
 		squish_flags = squish::kBc4;
@@ -71,9 +71,13 @@ void image_decompress_squish(Image *p_image) {
 	}
 
 	p_image->create(p_image->get_width(), p_image->get_height(), p_image->has_mipmaps(), target_format, data);
+
+	if (p_image->get_format() == Image::FORMAT_DXT5_RA_AS_RG) {
+		p_image->convert_ra_rgba8_to_rg();
+	}
 }
 
-void image_compress_squish(Image *p_image, float p_lossy_quality, Image::CompressSource p_source) {
+void image_compress_squish(Image *p_image, float p_lossy_quality, Image::UsedChannels p_channels) {
 
 	if (p_image->get_format() >= Image::FORMAT_DXT1)
 		return; //do not compress, already compressed
@@ -92,75 +96,35 @@ void image_compress_squish(Image *p_image, float p_lossy_quality, Image::Compres
 
 		Image::Format target_format = Image::FORMAT_RGBA8;
 
-		Image::DetectChannels dc = p_image->get_detected_channels();
-
-		if (p_source == Image::COMPRESS_SOURCE_LAYERED) {
-			//keep what comes in
-			switch (p_image->get_format()) {
-				case Image::FORMAT_L8: {
-					dc = Image::DETECTED_L;
-				} break;
-				case Image::FORMAT_LA8: {
-					dc = Image::DETECTED_LA;
-				} break;
-				case Image::FORMAT_R8: {
-					dc = Image::DETECTED_R;
-				} break;
-				case Image::FORMAT_RG8: {
-					dc = Image::DETECTED_RG;
-				} break;
-				case Image::FORMAT_RGB8: {
-					dc = Image::DETECTED_RGB;
-				} break;
-				case Image::FORMAT_RGBA8:
-				case Image::FORMAT_RGBA4444:
-				case Image::FORMAT_RGBA5551: {
-					dc = Image::DETECTED_RGBA;
-				} break;
-				default: {
-				}
-			}
-		}
-
 		p_image->convert(Image::FORMAT_RGBA8); //still uses RGBA to convert
 
-		if (p_source == Image::COMPRESS_SOURCE_SRGB && (dc == Image::DETECTED_R || dc == Image::DETECTED_RG)) {
-			//R and RG do not support SRGB
-			dc = Image::DETECTED_RGB;
-		}
-
-		if (p_source == Image::COMPRESS_SOURCE_NORMAL) {
-			//R and RG do not support SRGB
-			dc = Image::DETECTED_RG;
-		}
-
-		switch (dc) {
-			case Image::DETECTED_L: {
+		switch (p_channels) {
+			case Image::USED_CHANNELS_L: {
 
 				target_format = Image::FORMAT_DXT1;
 				squish_comp |= squish::kDxt1;
 			} break;
-			case Image::DETECTED_LA: {
+			case Image::USED_CHANNELS_LA: {
 
 				target_format = Image::FORMAT_DXT5;
 				squish_comp |= squish::kDxt5;
 			} break;
-			case Image::DETECTED_R: {
+			case Image::USED_CHANNELS_R: {
 
 				target_format = Image::FORMAT_RGTC_R;
 				squish_comp |= squish::kBc4;
 			} break;
-			case Image::DETECTED_RG: {
+			case Image::USED_CHANNELS_RG: {
 
 				target_format = Image::FORMAT_RGTC_RG;
 				squish_comp |= squish::kBc5;
 			} break;
-			case Image::DETECTED_RGB: {
+			case Image::USED_CHANNELS_RGB: {
 
 				target_format = Image::FORMAT_DXT1;
 				squish_comp |= squish::kDxt1;
 			} break;
-			case Image::DETECTED_RGBA: {
+			case Image::USED_CHANNELS_RGBA: {
 
 				//TODO, should convert both, then measure which one does a better job
 				target_format = Image::FORMAT_DXT5;
diff --git a/modules/squish/image_compress_squish.h b/modules/squish/image_compress_squish.h
index b5a209ceb9..19e6d57474 100644
--- a/modules/squish/image_compress_squish.h
+++ b/modules/squish/image_compress_squish.h
@@ -33,7 +33,7 @@
 
 #include "core/image.h"
 
-void image_compress_squish(Image *p_image, float p_lossy_quality, Image::CompressSource p_source);
+void image_compress_squish(Image *p_image, float p_lossy_quality, Image::UsedChannels p_channels);
 void image_decompress_squish(Image *p_image);
 
 #endif // IMAGE_COMPRESS_SQUISH_H
diff --git a/modules/theora/video_stream_theora.cpp b/modules/theora/video_stream_theora.cpp
index 00c7e87568..de229745f5 100644
--- a/modules/theora/video_stream_theora.cpp
+++ b/modules/theora/video_stream_theora.cpp
@@ -110,7 +110,7 @@ void VideoStreamPlaybackTheora::video_write(void) {
 
 	Ref<Image> img = memnew(Image(size.x, size.y, 0, Image::FORMAT_RGBA8, frame_data)); //zero copy image creation
 
-	texture->set_data(img); //zero copy send to visual server
+	texture->update(img, true); //zero copy send to visual server
 
 	frames_pending = 1;
 }
@@ -336,7 +336,9 @@ void VideoStreamPlaybackTheora::set_file(const String &p_file) {
 		size.x = w;
 		size.y = h;
 
-		texture->create(w, h, Image::FORMAT_RGBA8, Texture::FLAG_FILTER | Texture::FLAG_VIDEO_SURFACE);
+		Ref<Image> img;
+		img.instance();
+		img->create(w, h, false, Image::FORMAT_RGBA8);
 
 	} else {
 		/* tear down the partial theora setup */
@@ -369,7 +371,7 @@ float VideoStreamPlaybackTheora::get_time() const {
 	return time - /* AudioServer::get_singleton()->get_output_latency() - */ delay_compensation;
 };
 
-Ref<Texture> VideoStreamPlaybackTheora::get_texture() const {
+Ref<Texture2D> VideoStreamPlaybackTheora::get_texture() const {
 
 	return texture;
 }
diff --git a/modules/theora/video_stream_theora.h b/modules/theora/video_stream_theora.h
index 0f201ffa9d..c0a0faec4b 100644
--- a/modules/theora/video_stream_theora.h
+++ b/modules/theora/video_stream_theora.h
@@ -147,7 +147,7 @@ public:
 
 	void set_file(const String &p_file);
 
-	virtual Ref<Texture> get_texture() const;
+	virtual Ref<Texture2D> get_texture() const;
 	virtual void update(float p_delta);
 
 	virtual void set_mix_callback(AudioMixCallback p_callback, void *p_userdata);
diff --git a/modules/visual_script/visual_script_editor.cpp b/modules/visual_script/visual_script_editor.cpp
index ec20698ae8..18851e6ab6 100644
--- a/modules/visual_script/visual_script_editor.cpp
+++ b/modules/visual_script/visual_script_editor.cpp
@@ -499,7 +499,7 @@ void VisualScriptEditor::_update_graph(int p_only_id) {
 	graph->show();
 	select_func_text->hide();
 
-	Ref<Texture> type_icons[Variant::VARIANT_MAX] = {
+	Ref<Texture2D> type_icons[Variant::VARIANT_MAX] = {
 		Control::get_icon("Variant", "EditorIcons"),
 		Control::get_icon("bool", "EditorIcons"),
 		Control::get_icon("int", "EditorIcons"),
@@ -529,7 +529,7 @@ void VisualScriptEditor::_update_graph(int p_only_id) {
 		Control::get_icon("PoolColorArray", "EditorIcons")
 	};
 
-	Ref<Texture> seq_port = Control::get_icon("VisualShaderPort", "EditorIcons");
+	Ref<Texture2D> seq_port = Control::get_icon("VisualShaderPort", "EditorIcons");
 
 	for (List<StringName>::Element *F = funcs.front(); F; F = F->next()) { // loop through all the functions
 
@@ -702,7 +702,7 @@ void VisualScriptEditor::_update_graph(int p_only_id) {
 				vbc->add_child(hbc2);
 				if (left_ok) {
 
-					Ref<Texture> t;
+					Ref<Texture2D> t;
 					if (left_type >= 0 && left_type < Variant::VARIANT_MAX) {
 						t = type_icons[left_type];
 					}
@@ -830,7 +830,7 @@ void VisualScriptEditor::_update_graph(int p_only_id) {
 						hbc->add_child(memnew(Label(right_name)));
 					}
 
-					Ref<Texture> t;
+					Ref<Texture2D> t;
 					if (right_type >= 0 && right_type < Variant::VARIANT_MAX) {
 						t = type_icons[right_type];
 					}
@@ -846,7 +846,7 @@ void VisualScriptEditor::_update_graph(int p_only_id) {
 
 				bool dark_theme = get_constant("dark_theme", "Editor");
 				if (i < mixed_seq_ports) {
-					gnode->set_slot(slot_idx, left_ok, left_type, _color_from_type(left_type, dark_theme), true, TYPE_SEQUENCE, mono_color, Ref<Texture>(), seq_port);
+					gnode->set_slot(slot_idx, left_ok, left_type, _color_from_type(left_type, dark_theme), true, TYPE_SEQUENCE, mono_color, Ref<Texture2D>(), seq_port);
 				} else {
 					gnode->set_slot(slot_idx, left_ok, left_type, _color_from_type(left_type, dark_theme), right_ok, right_type, _color_from_type(right_type, dark_theme));
 				}
@@ -955,7 +955,7 @@ void VisualScriptEditor::_update_members() {
 	variables->add_button(0, Control::get_icon("Add", "EditorIcons"), -1, false, TTR("Create a new variable."));
 	variables->set_custom_color(0, Control::get_color("mono_color", "Editor"));
 
-	Ref<Texture> type_icons[Variant::VARIANT_MAX] = {
+	Ref<Texture2D> type_icons[Variant::VARIANT_MAX] = {
 		Control::get_icon("Variant", "EditorIcons"),
 		Control::get_icon("bool", "EditorIcons"),
 		Control::get_icon("int", "EditorIcons"),
@@ -2369,7 +2369,7 @@ void VisualScriptEditor::_draw_color_over_button(Object *obj, Color p_color) {
 	button->draw_rect(Rect2(normal->get_offset(), button->get_size() - normal->get_minimum_size()), p_color);
 }
 
-void VisualScriptEditor::_button_resource_previewed(const String &p_path, const Ref<Texture> &p_preview, const Ref<Texture> &p_small_preview, Variant p_ud) {
+void VisualScriptEditor::_button_resource_previewed(const String &p_path, const Ref<Texture2D> &p_preview, const Ref<Texture2D> &p_small_preview, Variant p_ud) {
 
 	Array ud = p_ud;
 	ERR_FAIL_COND(ud.size() != 2);
@@ -2447,7 +2447,7 @@ String VisualScriptEditor::get_name() {
 	return name;
 }
 
-Ref<Texture> VisualScriptEditor::get_icon() {
+Ref<Texture2D> VisualScriptEditor::get_icon() {
 
 	return Control::get_icon("VisualScript", "EditorIcons");
 }
@@ -4467,9 +4467,9 @@ void VisualScriptEditor::_member_rmb_selected(const Vector2 &p_pos) {
 
 	TreeItem *root = members->get_root();
 
-	Ref<Texture> del_icon = Control::get_icon("Remove", "EditorIcons");
+	Ref<Texture2D> del_icon = Control::get_icon("Remove", "EditorIcons");
 
-	Ref<Texture> edit_icon = Control::get_icon("Edit", "EditorIcons");
+	Ref<Texture2D> edit_icon = Control::get_icon("Edit", "EditorIcons");
 
 	if (ti->get_parent() == root->get_children()) {
 
diff --git a/modules/visual_script/visual_script_editor.h b/modules/visual_script/visual_script_editor.h
index 7f3bf79d50..40e9e1cc98 100644
--- a/modules/visual_script/visual_script_editor.h
+++ b/modules/visual_script/visual_script_editor.h
@@ -277,7 +277,7 @@ class VisualScriptEditor : public ScriptEditorBase {
 	void _selected_method(const String &p_method, const String &p_type, const bool p_connecting);
 
 	void _draw_color_over_button(Object *obj, Color p_color);
-	void _button_resource_previewed(const String &p_path, const Ref<Texture> &p_preview, const Ref<Texture> &p_small_preview, Variant p_ud);
+	void _button_resource_previewed(const String &p_path, const Ref<Texture2D> &p_preview, const Ref<Texture2D> &p_small_preview, Variant p_ud);
 
 	VisualScriptNode::TypeGuess _guess_output_type(int p_port_action_node, int p_port_action_output, Set<int> &p_visited_nodes);
 
@@ -298,7 +298,7 @@ public:
 	virtual Vector<String> get_functions();
 	virtual void reload_text();
 	virtual String get_name();
-	virtual Ref<Texture> get_icon();
+	virtual Ref<Texture2D> get_icon();
 	virtual bool is_unsaved();
 	virtual Variant get_edit_state();
 	virtual void set_edit_state(const Variant &p_state);
diff --git a/modules/visual_script/visual_script_property_selector.cpp b/modules/visual_script/visual_script_property_selector.cpp
index 99d7ffd05f..e629175094 100644
--- a/modules/visual_script/visual_script_property_selector.cpp
+++ b/modules/visual_script/visual_script_property_selector.cpp
@@ -98,7 +98,7 @@ void VisualScriptPropertySelector::_update_search() {
 		List<MethodInfo> methods;
 		List<PropertyInfo> props;
 		TreeItem *category = NULL;
-		Ref<Texture> type_icons[Variant::VARIANT_MAX] = {
+		Ref<Texture2D> type_icons[Variant::VARIANT_MAX] = {
 			Control::get_icon("Variant", "EditorIcons"),
 			Control::get_icon("bool", "EditorIcons"),
 			Control::get_icon("int", "EditorIcons"),
@@ -133,7 +133,7 @@ void VisualScriptPropertySelector::_update_search() {
 			if (category) {
 				category->set_text(0, b.replace_first("*", ""));
 				category->set_selectable(0, false);
-				Ref<Texture> icon;
+				Ref<Texture2D> icon;
 				String rep = b.replace("*", "");
 				icon = EditorNode::get_singleton()->get_class_icon(rep);
 				category->set_icon(0, icon);
diff --git a/modules/webm/video_stream_webm.cpp b/modules/webm/video_stream_webm.cpp
index 2763d30bb5..54d34a48c5 100644
--- a/modules/webm/video_stream_webm.cpp
+++ b/modules/webm/video_stream_webm.cpp
@@ -141,7 +141,10 @@ bool VideoStreamPlaybackWebm::open_file(const String &p_file) {
 			}
 
 			frame_data.resize((webm->getWidth() * webm->getHeight()) << 2);
-			texture->create(webm->getWidth(), webm->getHeight(), Image::FORMAT_RGBA8, Texture::FLAG_FILTER | Texture::FLAG_VIDEO_SURFACE);
+			Ref<Image> img;
+			img.instance();
+			img->create(webm->getWidth(), webm->getHeight(), false, Image::FORMAT_RGBA8);
+			texture->create_from_image(img);
 
 			return true;
 		}
@@ -231,7 +234,7 @@ void VideoStreamPlaybackWebm::set_audio_track(int p_idx) {
 	audio_track = p_idx;
 }
 
-Ref<Texture> VideoStreamPlaybackWebm::get_texture() const {
+Ref<Texture2D> VideoStreamPlaybackWebm::get_texture() const {
 
 	return texture;
 }
@@ -356,7 +359,7 @@ void VideoStreamPlaybackWebm::update(float p_delta) {
 
 						if (converted) {
 							Ref<Image> img = memnew(Image(image.w, image.h, 0, Image::FORMAT_RGBA8, frame_data));
-							texture->set_data(img); //Zero copy send to visual server
+							texture->update(img); //Zero copy send to visual server
 							video_frame_done = true;
 						}
 					}
diff --git a/modules/webm/video_stream_webm.h b/modules/webm/video_stream_webm.h
index e679196cf2..f2a68dd701 100644
--- a/modules/webm/video_stream_webm.h
+++ b/modules/webm/video_stream_webm.h
@@ -90,7 +90,7 @@ public:
 
 	virtual void set_audio_track(int p_idx);
 
-	virtual Ref<Texture> get_texture() const;
+	virtual Ref<Texture2D> get_texture() const;
 	virtual void update(float p_delta);
 
 	virtual void set_mix_callback(AudioMixCallback p_callback, void *p_userdata);