Rename RID's `getornull()` to `get_or_null()`

30 files changed, 1717 insertions, 1717 deletions

diff --git a/core/templates/rid_owner.h b/core/templates/rid_owner.h
index e947d2211c..71d41eacc4 100644
--- a/core/templates/rid_owner.h
+++ b/core/templates/rid_owner.h
@@ -151,7 +151,7 @@ public:
 		return _allocate_rid();
 	}
 
-	_FORCE_INLINE_ T *getornull(const RID &p_rid, bool p_initialize = false) {
+	_FORCE_INLINE_ T *get_or_null(const RID &p_rid, bool p_initialize = false) {
 		if (p_rid == RID()) {
 			return nullptr;
 		}
@@ -210,12 +210,12 @@ public:
 		return ptr;
 	}
 	void initialize_rid(RID p_rid) {
-		T *mem = getornull(p_rid, true);
+		T *mem = get_or_null(p_rid, true);
 		ERR_FAIL_COND(!mem);
 		memnew_placement(mem, T);
 	}
 	void initialize_rid(RID p_rid, const T &p_value) {
-		T *mem = getornull(p_rid, true);
+		T *mem = get_or_null(p_rid, true);
 		ERR_FAIL_COND(!mem);
 		memnew_placement(mem, T(p_value));
 	}
@@ -399,8 +399,8 @@ public:
 		alloc.initialize_rid(p_rid, p_ptr);
 	}
 
-	_FORCE_INLINE_ T *getornull(const RID &p_rid) {
-		T **ptr = alloc.getornull(p_rid);
+	_FORCE_INLINE_ T *get_or_null(const RID &p_rid) {
+		T **ptr = alloc.get_or_null(p_rid);
 		if (unlikely(!ptr)) {
 			return nullptr;
 		}
@@ -408,7 +408,7 @@ public:
 	}
 
 	_FORCE_INLINE_ void replace(const RID &p_rid, T *p_new_ptr) {
-		T **ptr = alloc.getornull(p_rid);
+		T **ptr = alloc.get_or_null(p_rid);
 		ERR_FAIL_COND(!ptr);
 		*ptr = p_new_ptr;
 	}
@@ -469,8 +469,8 @@ public:
 		alloc.initialize_rid(p_rid, p_ptr);
 	}
 
-	_FORCE_INLINE_ T *getornull(const RID &p_rid) {
-		return alloc.getornull(p_rid);
+	_FORCE_INLINE_ T *get_or_null(const RID &p_rid) {
+		return alloc.get_or_null(p_rid);
 	}
 
 	_FORCE_INLINE_ bool owns(const RID &p_rid) {
diff --git a/drivers/vulkan/rendering_device_vulkan.cpp b/drivers/vulkan/rendering_device_vulkan.cpp
index f8fc949220..086d3b4284 100644
--- a/drivers/vulkan/rendering_device_vulkan.cpp
+++ b/drivers/vulkan/rendering_device_vulkan.cpp
@@ -47,7 +47,7 @@
 RenderingDeviceVulkan::Buffer *RenderingDeviceVulkan::_get_buffer_from_owner(RID p_buffer, VkPipelineStageFlags &r_stage_mask, VkAccessFlags &r_access_mask, uint32_t p_post_barrier) {
 	Buffer *buffer = nullptr;
 	if (vertex_buffer_owner.owns(p_buffer)) {
-		buffer = vertex_buffer_owner.getornull(p_buffer);
+		buffer = vertex_buffer_owner.get_or_null(p_buffer);
 
 		r_stage_mask |= VK_PIPELINE_STAGE_VERTEX_INPUT_BIT;
 		r_access_mask |= VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT;
@@ -64,7 +64,7 @@ RenderingDeviceVulkan::Buffer *RenderingDeviceVulkan::_get_buffer_from_owner(RID
 	} else if (index_buffer_owner.owns(p_buffer)) {
 		r_stage_mask |= VK_PIPELINE_STAGE_VERTEX_INPUT_BIT;
 		r_access_mask |= VK_ACCESS_INDEX_READ_BIT;
-		buffer = index_buffer_owner.getornull(p_buffer);
+		buffer = index_buffer_owner.get_or_null(p_buffer);
 	} else if (uniform_buffer_owner.owns(p_buffer)) {
 		if (p_post_barrier & BARRIER_MASK_RASTER) {
 			r_stage_mask |= VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
@@ -73,7 +73,7 @@ RenderingDeviceVulkan::Buffer *RenderingDeviceVulkan::_get_buffer_from_owner(RID
 			r_stage_mask |= VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
 		}
 		r_access_mask |= VK_ACCESS_UNIFORM_READ_BIT;
-		buffer = uniform_buffer_owner.getornull(p_buffer);
+		buffer = uniform_buffer_owner.get_or_null(p_buffer);
 	} else if (texture_buffer_owner.owns(p_buffer)) {
 		if (p_post_barrier & BARRIER_MASK_RASTER) {
 			r_stage_mask |= VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
@@ -84,9 +84,9 @@ RenderingDeviceVulkan::Buffer *RenderingDeviceVulkan::_get_buffer_from_owner(RID
 			r_access_mask |= VK_ACCESS_SHADER_READ_BIT;
 		}
 
-		buffer = &texture_buffer_owner.getornull(p_buffer)->buffer;
+		buffer = &texture_buffer_owner.get_or_null(p_buffer)->buffer;
 	} else if (storage_buffer_owner.owns(p_buffer)) {
-		buffer = storage_buffer_owner.getornull(p_buffer);
+		buffer = storage_buffer_owner.get_or_null(p_buffer);
 		if (p_post_barrier & BARRIER_MASK_RASTER) {
 			r_stage_mask |= VK_PIPELINE_STAGE_VERTEX_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
 			r_access_mask |= VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT;
@@ -2048,12 +2048,12 @@ RID RenderingDeviceVulkan::texture_create(const TextureFormat &p_format, const T
 RID RenderingDeviceVulkan::texture_create_shared(const TextureView &p_view, RID p_with_texture) {
 	_THREAD_SAFE_METHOD_
 
-	Texture *src_texture = texture_owner.getornull(p_with_texture);
+	Texture *src_texture = texture_owner.get_or_null(p_with_texture);
 	ERR_FAIL_COND_V(!src_texture, RID());
 
 	if (src_texture->owner.is_valid()) { //ahh this is a share
 		p_with_texture = src_texture->owner;
-		src_texture = texture_owner.getornull(src_texture->owner);
+		src_texture = texture_owner.get_or_null(src_texture->owner);
 		ERR_FAIL_COND_V(!src_texture, RID()); //this is a bug
 	}
 
@@ -2173,12 +2173,12 @@ RID RenderingDeviceVulkan::texture_create_shared(const TextureView &p_view, RID
 RID RenderingDeviceVulkan::texture_create_shared_from_slice(const TextureView &p_view, RID p_with_texture, uint32_t p_layer, uint32_t p_mipmap, TextureSliceType p_slice_type) {
 	_THREAD_SAFE_METHOD_
 
-	Texture *src_texture = texture_owner.getornull(p_with_texture);
+	Texture *src_texture = texture_owner.get_or_null(p_with_texture);
 	ERR_FAIL_COND_V(!src_texture, RID());
 
 	if (src_texture->owner.is_valid()) { //ahh this is a share
 		p_with_texture = src_texture->owner;
-		src_texture = texture_owner.getornull(src_texture->owner);
+		src_texture = texture_owner.get_or_null(src_texture->owner);
 		ERR_FAIL_COND_V(!src_texture, RID()); //this is a bug
 	}
 
@@ -2299,12 +2299,12 @@ Error RenderingDeviceVulkan::_texture_update(RID p_texture, uint32_t p_layer, co
 	ERR_FAIL_COND_V_MSG((draw_list || compute_list) && !p_use_setup_queue, ERR_INVALID_PARAMETER,
 			"Updating textures is forbidden during creation of a draw or compute list");
 
-	Texture *texture = texture_owner.getornull(p_texture);
+	Texture *texture = texture_owner.get_or_null(p_texture);
 	ERR_FAIL_COND_V(!texture, ERR_INVALID_PARAMETER);
 
 	if (texture->owner != RID()) {
 		p_texture = texture->owner;
-		texture = texture_owner.getornull(texture->owner);
+		texture = texture_owner.get_or_null(texture->owner);
 		ERR_FAIL_COND_V(!texture, ERR_BUG); //this is a bug
 	}
 
@@ -2601,7 +2601,7 @@ Vector<uint8_t> RenderingDeviceVulkan::_texture_get_data_from_image(Texture *tex
 Vector<uint8_t> RenderingDeviceVulkan::texture_get_data(RID p_texture, uint32_t p_layer) {
 	_THREAD_SAFE_METHOD_
 
-	Texture *tex = texture_owner.getornull(p_texture);
+	Texture *tex = texture_owner.get_or_null(p_texture);
 	ERR_FAIL_COND_V(!tex, Vector<uint8_t>());
 
 	ERR_FAIL_COND_V_MSG(tex->bound, Vector<uint8_t>(),
@@ -2731,7 +2731,7 @@ Vector<uint8_t> RenderingDeviceVulkan::texture_get_data(RID p_texture, uint32_t
 bool RenderingDeviceVulkan::texture_is_shared(RID p_texture) {
 	_THREAD_SAFE_METHOD_
 
-	Texture *tex = texture_owner.getornull(p_texture);
+	Texture *tex = texture_owner.get_or_null(p_texture);
 	ERR_FAIL_COND_V(!tex, false);
 	return tex->owner.is_valid();
 }
@@ -2743,7 +2743,7 @@ bool RenderingDeviceVulkan::texture_is_valid(RID p_texture) {
 Size2i RenderingDeviceVulkan::texture_size(RID p_texture) {
 	_THREAD_SAFE_METHOD_
 
-	Texture *tex = texture_owner.getornull(p_texture);
+	Texture *tex = texture_owner.get_or_null(p_texture);
 	ERR_FAIL_COND_V(!tex, Size2i());
 	return Size2i(tex->width, tex->height);
 }
@@ -2751,7 +2751,7 @@ Size2i RenderingDeviceVulkan::texture_size(RID p_texture) {
 Error RenderingDeviceVulkan::texture_copy(RID p_from_texture, RID p_to_texture, const Vector3 &p_from, const Vector3 &p_to, const Vector3 &p_size, uint32_t p_src_mipmap, uint32_t p_dst_mipmap, uint32_t p_src_layer, uint32_t p_dst_layer, uint32_t p_post_barrier) {
 	_THREAD_SAFE_METHOD_
 
-	Texture *src_tex = texture_owner.getornull(p_from_texture);
+	Texture *src_tex = texture_owner.get_or_null(p_from_texture);
 	ERR_FAIL_COND_V(!src_tex, ERR_INVALID_PARAMETER);
 
 	ERR_FAIL_COND_V_MSG(src_tex->bound, ERR_INVALID_PARAMETER,
@@ -2772,7 +2772,7 @@ Error RenderingDeviceVulkan::texture_copy(RID p_from_texture, RID p_to_texture,
 	ERR_FAIL_COND_V(p_src_mipmap >= src_tex->mipmaps, ERR_INVALID_PARAMETER);
 	ERR_FAIL_COND_V(p_src_layer >= src_layer_count, ERR_INVALID_PARAMETER);
 
-	Texture *dst_tex = texture_owner.getornull(p_to_texture);
+	Texture *dst_tex = texture_owner.get_or_null(p_to_texture);
 	ERR_FAIL_COND_V(!dst_tex, ERR_INVALID_PARAMETER);
 
 	ERR_FAIL_COND_V_MSG(dst_tex->bound, ERR_INVALID_PARAMETER,
@@ -2939,7 +2939,7 @@ Error RenderingDeviceVulkan::texture_copy(RID p_from_texture, RID p_to_texture,
 Error RenderingDeviceVulkan::texture_resolve_multisample(RID p_from_texture, RID p_to_texture, uint32_t p_post_barrier) {
 	_THREAD_SAFE_METHOD_
 
-	Texture *src_tex = texture_owner.getornull(p_from_texture);
+	Texture *src_tex = texture_owner.get_or_null(p_from_texture);
 	ERR_FAIL_COND_V(!src_tex, ERR_INVALID_PARAMETER);
 
 	ERR_FAIL_COND_V_MSG(src_tex->bound, ERR_INVALID_PARAMETER,
@@ -2950,7 +2950,7 @@ Error RenderingDeviceVulkan::texture_resolve_multisample(RID p_from_texture, RID
 	ERR_FAIL_COND_V_MSG(src_tex->type != TEXTURE_TYPE_2D, ERR_INVALID_PARAMETER, "Source texture must be 2D (or a slice of a 3D/Cube texture)");
 	ERR_FAIL_COND_V_MSG(src_tex->samples == TEXTURE_SAMPLES_1, ERR_INVALID_PARAMETER, "Source texture must be multisampled.");
 
-	Texture *dst_tex = texture_owner.getornull(p_to_texture);
+	Texture *dst_tex = texture_owner.get_or_null(p_to_texture);
 	ERR_FAIL_COND_V(!dst_tex, ERR_INVALID_PARAMETER);
 
 	ERR_FAIL_COND_V_MSG(dst_tex->bound, ERR_INVALID_PARAMETER,
@@ -3110,7 +3110,7 @@ Error RenderingDeviceVulkan::texture_resolve_multisample(RID p_from_texture, RID
 Error RenderingDeviceVulkan::texture_clear(RID p_texture, const Color &p_color, uint32_t p_base_mipmap, uint32_t p_mipmaps, uint32_t p_base_layer, uint32_t p_layers, uint32_t p_post_barrier) {
 	_THREAD_SAFE_METHOD_
 
-	Texture *src_tex = texture_owner.getornull(p_texture);
+	Texture *src_tex = texture_owner.get_or_null(p_texture);
 	ERR_FAIL_COND_V(!src_tex, ERR_INVALID_PARAMETER);
 
 	ERR_FAIL_COND_V_MSG(src_tex->bound, ERR_INVALID_PARAMETER,
@@ -3880,7 +3880,7 @@ RID RenderingDeviceVulkan::framebuffer_create(const Vector<RID> &p_texture_attac
 	FramebufferPass pass;
 
 	for (int i = 0; i < p_texture_attachments.size(); i++) {
-		Texture *texture = texture_owner.getornull(p_texture_attachments[i]);
+		Texture *texture = texture_owner.get_or_null(p_texture_attachments[i]);
 		ERR_FAIL_COND_V_MSG(!texture, RID(), "Texture index supplied for framebuffer (" + itos(i) + ") is not a valid texture.");
 
 		ERR_FAIL_COND_V_MSG(texture->layers != p_view_count, RID(), "Layers of our texture doesn't match view count for this framebuffer");
@@ -3905,7 +3905,7 @@ RID RenderingDeviceVulkan::framebuffer_create_multipass(const Vector<RID> &p_tex
 	Size2i size;
 
 	for (int i = 0; i < p_texture_attachments.size(); i++) {
-		Texture *texture = texture_owner.getornull(p_texture_attachments[i]);
+		Texture *texture = texture_owner.get_or_null(p_texture_attachments[i]);
 		ERR_FAIL_COND_V_MSG(!texture, RID(), "Texture index supplied for framebuffer (" + itos(i) + ") is not a valid texture.");
 
 		ERR_FAIL_COND_V_MSG(texture->layers != p_view_count, RID(), "Layers of our texture doesn't match view count for this framebuffer");
@@ -3951,7 +3951,7 @@ RID RenderingDeviceVulkan::framebuffer_create_multipass(const Vector<RID> &p_tex
 RenderingDevice::FramebufferFormatID RenderingDeviceVulkan::framebuffer_get_format(RID p_framebuffer) {
 	_THREAD_SAFE_METHOD_
 
-	Framebuffer *framebuffer = framebuffer_owner.getornull(p_framebuffer);
+	Framebuffer *framebuffer = framebuffer_owner.get_or_null(p_framebuffer);
 	ERR_FAIL_COND_V(!framebuffer, INVALID_ID);
 
 	return framebuffer->format_id;
@@ -4101,7 +4101,7 @@ RID RenderingDeviceVulkan::vertex_array_create(uint32_t p_vertex_count, VertexFo
 	vertex_array.description = p_vertex_format;
 	vertex_array.max_instances_allowed = 0xFFFFFFFF; //by default as many as you want
 	for (int i = 0; i < p_src_buffers.size(); i++) {
-		Buffer *buffer = vertex_buffer_owner.getornull(p_src_buffers[i]);
+		Buffer *buffer = vertex_buffer_owner.get_or_null(p_src_buffers[i]);
 
 		//validate with buffer
 		{
@@ -4197,7 +4197,7 @@ RID RenderingDeviceVulkan::index_array_create(RID p_index_buffer, uint32_t p_ind
 
 	ERR_FAIL_COND_V(!index_buffer_owner.owns(p_index_buffer), RID());
 
-	IndexBuffer *index_buffer = index_buffer_owner.getornull(p_index_buffer);
+	IndexBuffer *index_buffer = index_buffer_owner.get_or_null(p_index_buffer);
 
 	ERR_FAIL_COND_V(p_index_count == 0, RID());
 	ERR_FAIL_COND_V(p_index_offset + p_index_count > index_buffer->index_count, RID());
@@ -4241,7 +4241,7 @@ static VkShaderStageFlagBits shader_stage_masks[RenderingDevice::SHADER_STAGE_MA
 
 String RenderingDeviceVulkan::_shader_uniform_debug(RID p_shader, int p_set) {
 	String ret;
-	const Shader *shader = shader_owner.getornull(p_shader);
+	const Shader *shader = shader_owner.get_or_null(p_shader);
 	ERR_FAIL_COND_V(!shader, String());
 	for (int i = 0; i < shader->sets.size(); i++) {
 		if (p_set >= 0 && i != p_set) {
@@ -5272,7 +5272,7 @@ RID RenderingDeviceVulkan::shader_create_from_bytecode(const Vector<uint8_t> &p_
 uint32_t RenderingDeviceVulkan::shader_get_vertex_input_attribute_mask(RID p_shader) {
 	_THREAD_SAFE_METHOD_
 
-	const Shader *shader = shader_owner.getornull(p_shader);
+	const Shader *shader = shader_owner.get_or_null(p_shader);
 	ERR_FAIL_COND_V(!shader, 0);
 	return shader->vertex_input_mask;
 }
@@ -5494,7 +5494,7 @@ RID RenderingDeviceVulkan::uniform_set_create(const Vector<Uniform> &p_uniforms,
 
 	ERR_FAIL_COND_V(p_uniforms.size() == 0, RID());
 
-	Shader *shader = shader_owner.getornull(p_shader);
+	Shader *shader = shader_owner.get_or_null(p_shader);
 	ERR_FAIL_COND_V(!shader, RID());
 
 	ERR_FAIL_COND_V_MSG(p_shader_set >= (uint32_t)shader->sets.size() || shader->sets[p_shader_set].uniform_info.size() == 0, RID(),
@@ -5563,7 +5563,7 @@ RID RenderingDeviceVulkan::uniform_set_create(const Vector<Uniform> &p_uniforms,
 				Vector<VkDescriptorImageInfo> image_info;
 
 				for (int j = 0; j < uniform.ids.size(); j++) {
-					VkSampler *sampler = sampler_owner.getornull(uniform.ids[j]);
+					VkSampler *sampler = sampler_owner.get_or_null(uniform.ids[j]);
 					ERR_FAIL_COND_V_MSG(!sampler, RID(), "Sampler (binding: " + itos(uniform.binding) + ", index " + itos(j) + ") is not a valid sampler.");
 
 					VkDescriptorImageInfo img_info;
@@ -5596,10 +5596,10 @@ RID RenderingDeviceVulkan::uniform_set_create(const Vector<Uniform> &p_uniforms,
 				Vector<VkDescriptorImageInfo> image_info;
 
 				for (int j = 0; j < uniform.ids.size(); j += 2) {
-					VkSampler *sampler = sampler_owner.getornull(uniform.ids[j + 0]);
+					VkSampler *sampler = sampler_owner.get_or_null(uniform.ids[j + 0]);
 					ERR_FAIL_COND_V_MSG(!sampler, RID(), "SamplerBuffer (binding: " + itos(uniform.binding) + ", index " + itos(j + 1) + ") is not a valid sampler.");
 
-					Texture *texture = texture_owner.getornull(uniform.ids[j + 1]);
+					Texture *texture = texture_owner.get_or_null(uniform.ids[j + 1]);
 					ERR_FAIL_COND_V_MSG(!texture, RID(), "Texture (binding: " + itos(uniform.binding) + ", index " + itos(j) + ") is not a valid texture.");
 
 					ERR_FAIL_COND_V_MSG(!(texture->usage_flags & TEXTURE_USAGE_SAMPLING_BIT), RID(),
@@ -5621,7 +5621,7 @@ RID RenderingDeviceVulkan::uniform_set_create(const Vector<Uniform> &p_uniforms,
 						mutable_sampled_textures.push_back(texture);
 					}
 					if (texture->owner.is_valid()) {
-						texture = texture_owner.getornull(texture->owner);
+						texture = texture_owner.get_or_null(texture->owner);
 						ERR_FAIL_COND_V(!texture, RID()); //bug, should never happen
 					}
 
@@ -5652,7 +5652,7 @@ RID RenderingDeviceVulkan::uniform_set_create(const Vector<Uniform> &p_uniforms,
 				Vector<VkDescriptorImageInfo> image_info;
 
 				for (int j = 0; j < uniform.ids.size(); j++) {
-					Texture *texture = texture_owner.getornull(uniform.ids[j]);
+					Texture *texture = texture_owner.get_or_null(uniform.ids[j]);
 					ERR_FAIL_COND_V_MSG(!texture, RID(), "Texture (binding: " + itos(uniform.binding) + ", index " + itos(j) + ") is not a valid texture.");
 
 					ERR_FAIL_COND_V_MSG(!(texture->usage_flags & TEXTURE_USAGE_SAMPLING_BIT), RID(),
@@ -5675,7 +5675,7 @@ RID RenderingDeviceVulkan::uniform_set_create(const Vector<Uniform> &p_uniforms,
 					}
 
 					if (texture->owner.is_valid()) {
-						texture = texture_owner.getornull(texture->owner);
+						texture = texture_owner.get_or_null(texture->owner);
 						ERR_FAIL_COND_V(!texture, RID()); //bug, should never happen
 					}
 
@@ -5705,7 +5705,7 @@ RID RenderingDeviceVulkan::uniform_set_create(const Vector<Uniform> &p_uniforms,
 				Vector<VkDescriptorImageInfo> image_info;
 
 				for (int j = 0; j < uniform.ids.size(); j++) {
-					Texture *texture = texture_owner.getornull(uniform.ids[j]);
+					Texture *texture = texture_owner.get_or_null(uniform.ids[j]);
 
 					ERR_FAIL_COND_V_MSG(!texture, RID(),
 							"Image (binding: " + itos(uniform.binding) + ", index " + itos(j) + ") is not a valid texture.");
@@ -5723,7 +5723,7 @@ RID RenderingDeviceVulkan::uniform_set_create(const Vector<Uniform> &p_uniforms,
 					}
 
 					if (texture->owner.is_valid()) {
-						texture = texture_owner.getornull(texture->owner);
+						texture = texture_owner.get_or_null(texture->owner);
 						ERR_FAIL_COND_V(!texture, RID()); //bug, should never happen
 					}
 
@@ -5755,7 +5755,7 @@ RID RenderingDeviceVulkan::uniform_set_create(const Vector<Uniform> &p_uniforms,
 				Vector<VkBufferView> buffer_view;
 
 				for (int j = 0; j < uniform.ids.size(); j++) {
-					TextureBuffer *buffer = texture_buffer_owner.getornull(uniform.ids[j]);
+					TextureBuffer *buffer = texture_buffer_owner.get_or_null(uniform.ids[j]);
 					ERR_FAIL_COND_V_MSG(!buffer, RID(), "Texture Buffer (binding: " + itos(uniform.binding) + ", index " + itos(j) + ") is not a valid texture buffer.");
 
 					buffer_info.push_back(buffer->buffer.buffer_info);
@@ -5786,10 +5786,10 @@ RID RenderingDeviceVulkan::uniform_set_create(const Vector<Uniform> &p_uniforms,
 				Vector<VkBufferView> buffer_view;
 
 				for (int j = 0; j < uniform.ids.size(); j += 2) {
-					VkSampler *sampler = sampler_owner.getornull(uniform.ids[j + 0]);
+					VkSampler *sampler = sampler_owner.get_or_null(uniform.ids[j + 0]);
 					ERR_FAIL_COND_V_MSG(!sampler, RID(), "SamplerBuffer (binding: " + itos(uniform.binding) + ", index " + itos(j + 1) + ") is not a valid sampler.");
 
-					TextureBuffer *buffer = texture_buffer_owner.getornull(uniform.ids[j + 1]);
+					TextureBuffer *buffer = texture_buffer_owner.get_or_null(uniform.ids[j + 1]);
 
 					VkDescriptorImageInfo img_info;
 					img_info.sampler = *sampler;
@@ -5821,7 +5821,7 @@ RID RenderingDeviceVulkan::uniform_set_create(const Vector<Uniform> &p_uniforms,
 				ERR_FAIL_COND_V_MSG(uniform.ids.size() != 1, RID(),
 						"Uniform buffer supplied (binding: " + itos(uniform.binding) + ") must provide one ID (" + itos(uniform.ids.size()) + " provided).");
 
-				Buffer *buffer = uniform_buffer_owner.getornull(uniform.ids[0]);
+				Buffer *buffer = uniform_buffer_owner.get_or_null(uniform.ids[0]);
 				ERR_FAIL_COND_V_MSG(!buffer, RID(), "Uniform buffer supplied (binding: " + itos(uniform.binding) + ") is invalid.");
 
 				ERR_FAIL_COND_V_MSG(buffer->size != (uint32_t)set_uniform.length, RID(),
@@ -5842,9 +5842,9 @@ RID RenderingDeviceVulkan::uniform_set_create(const Vector<Uniform> &p_uniforms,
 				Buffer *buffer = nullptr;
 
 				if (storage_buffer_owner.owns(uniform.ids[0])) {
-					buffer = storage_buffer_owner.getornull(uniform.ids[0]);
+					buffer = storage_buffer_owner.get_or_null(uniform.ids[0]);
 				} else if (vertex_buffer_owner.owns(uniform.ids[0])) {
-					buffer = vertex_buffer_owner.getornull(uniform.ids[0]);
+					buffer = vertex_buffer_owner.get_or_null(uniform.ids[0]);
 
 					ERR_FAIL_COND_V_MSG(!(buffer->usage & VK_BUFFER_USAGE_STORAGE_BUFFER_BIT), RID(), "Vertex buffer supplied (binding: " + itos(uniform.binding) + ") was not created with storage flag.");
 				}
@@ -5875,7 +5875,7 @@ RID RenderingDeviceVulkan::uniform_set_create(const Vector<Uniform> &p_uniforms,
 				Vector<VkDescriptorImageInfo> image_info;
 
 				for (int j = 0; j < uniform.ids.size(); j++) {
-					Texture *texture = texture_owner.getornull(uniform.ids[j]);
+					Texture *texture = texture_owner.get_or_null(uniform.ids[j]);
 
 					ERR_FAIL_COND_V_MSG(!texture, RID(),
 							"InputAttachment (binding: " + itos(uniform.binding) + ", index " + itos(j) + ") is not a valid texture.");
@@ -5888,7 +5888,7 @@ RID RenderingDeviceVulkan::uniform_set_create(const Vector<Uniform> &p_uniforms,
 					img_info.imageView = texture->view;
 
 					if (texture->owner.is_valid()) {
-						texture = texture_owner.getornull(texture->owner);
+						texture = texture_owner.get_or_null(texture->owner);
 						ERR_FAIL_COND_V(!texture, RID()); //bug, should never happen
 					}
 
@@ -5977,7 +5977,7 @@ bool RenderingDeviceVulkan::uniform_set_is_valid(RID p_uniform_set) {
 }
 
 void RenderingDeviceVulkan::uniform_set_set_invalidation_callback(RID p_uniform_set, UniformSetInvalidatedCallback p_callback, void *p_userdata) {
-	UniformSet *us = uniform_set_owner.getornull(p_uniform_set);
+	UniformSet *us = uniform_set_owner.get_or_null(p_uniform_set);
 	ERR_FAIL_COND(!us);
 	us->invalidated_callback = p_callback;
 	us->invalidated_callback_userdata = p_userdata;
@@ -6126,7 +6126,7 @@ RID RenderingDeviceVulkan::render_pipeline_create(RID p_shader, FramebufferForma
 	_THREAD_SAFE_METHOD_
 
 	//needs a shader
-	Shader *shader = shader_owner.getornull(p_shader);
+	Shader *shader = shader_owner.get_or_null(p_shader);
 	ERR_FAIL_COND_V(!shader, RID());
 
 	ERR_FAIL_COND_V_MSG(shader->is_compute, RID(),
@@ -6568,7 +6568,7 @@ RID RenderingDeviceVulkan::compute_pipeline_create(RID p_shader, const Vector<Pi
 	_THREAD_SAFE_METHOD_
 
 	//needs a shader
-	Shader *shader = shader_owner.getornull(p_shader);
+	Shader *shader = shader_owner.get_or_null(p_shader);
 	ERR_FAIL_COND_V(!shader, RID());
 
 	ERR_FAIL_COND_V_MSG(!shader->is_compute, RID(),
@@ -6779,7 +6779,7 @@ Error RenderingDeviceVulkan::_draw_list_setup_framebuffer(Framebuffer *p_framebu
 		framebuffer_create_info.renderPass = version.render_pass;
 		Vector<VkImageView> attachments;
 		for (int i = 0; i < p_framebuffer->texture_ids.size(); i++) {
-			Texture *texture = texture_owner.getornull(p_framebuffer->texture_ids[i]);
+			Texture *texture = texture_owner.get_or_null(p_framebuffer->texture_ids[i]);
 			ERR_FAIL_COND_V(!texture, ERR_BUG);
 			attachments.push_back(texture->view);
 			ERR_FAIL_COND_V(texture->width != p_framebuffer->size.width, ERR_BUG);
@@ -6831,7 +6831,7 @@ Error RenderingDeviceVulkan::_draw_list_render_pass_begin(Framebuffer *framebuff
 	{
 		int color_index = 0;
 		for (int i = 0; i < framebuffer->texture_ids.size(); i++) {
-			Texture *texture = texture_owner.getornull(framebuffer->texture_ids[i]);
+			Texture *texture = texture_owner.get_or_null(framebuffer->texture_ids[i]);
 			VkClearValue clear_value;
 
 			if (color_index < p_clear_colors.size() && texture->usage_flags & TEXTURE_USAGE_COLOR_ATTACHMENT_BIT) {
@@ -6859,7 +6859,7 @@ Error RenderingDeviceVulkan::_draw_list_render_pass_begin(Framebuffer *framebuff
 	render_pass_begin.pClearValues = clear_values.ptr();
 
 	for (int i = 0; i < p_storage_textures.size(); i++) {
-		Texture *texture = texture_owner.getornull(p_storage_textures[i]);
+		Texture *texture = texture_owner.get_or_null(p_storage_textures[i]);
 		ERR_CONTINUE_MSG(!(texture->usage_flags & TEXTURE_USAGE_STORAGE_BIT), "Supplied storage texture " + itos(i) + " for draw list is not set to be used for storage.");
 
 		if (texture->usage_flags & TEXTURE_USAGE_SAMPLING_BIT) {
@@ -6897,7 +6897,7 @@ Error RenderingDeviceVulkan::_draw_list_render_pass_begin(Framebuffer *framebuff
 	draw_list_unbind_depth_textures = p_final_depth_action != FINAL_ACTION_CONTINUE;
 
 	for (int i = 0; i < framebuffer->texture_ids.size(); i++) {
-		Texture *texture = texture_owner.getornull(framebuffer->texture_ids[i]);
+		Texture *texture = texture_owner.get_or_null(framebuffer->texture_ids[i]);
 		texture->bound = true;
 		draw_list_bound_textures.push_back(framebuffer->texture_ids[i]);
 	}
@@ -6909,7 +6909,7 @@ void RenderingDeviceVulkan::_draw_list_insert_clear_region(DrawList *draw_list,
 	Vector<VkClearAttachment> clear_attachments;
 	int color_index = 0;
 	for (int i = 0; i < framebuffer->texture_ids.size(); i++) {
-		Texture *texture = texture_owner.getornull(framebuffer->texture_ids[i]);
+		Texture *texture = texture_owner.get_or_null(framebuffer->texture_ids[i]);
 		VkClearAttachment clear_at = {};
 
 		if (p_clear_color && texture->usage_flags & TEXTURE_USAGE_COLOR_ATTACHMENT_BIT) {
@@ -6952,7 +6952,7 @@ RenderingDevice::DrawListID RenderingDeviceVulkan::draw_list_begin(RID p_framebu
 	ERR_FAIL_COND_V_MSG(draw_list != nullptr, INVALID_ID, "Only one draw list can be active at the same time.");
 	ERR_FAIL_COND_V_MSG(compute_list != nullptr && !compute_list->state.allow_draw_overlap, INVALID_ID, "Only one draw/compute list can be active at the same time.");
 
-	Framebuffer *framebuffer = framebuffer_owner.getornull(p_framebuffer);
+	Framebuffer *framebuffer = framebuffer_owner.get_or_null(p_framebuffer);
 	ERR_FAIL_COND_V(!framebuffer, INVALID_ID);
 
 	Point2i viewport_offset;
@@ -6993,7 +6993,7 @@ RenderingDevice::DrawListID RenderingDeviceVulkan::draw_list_begin(RID p_framebu
 
 		int color_count = 0;
 		for (int i = 0; i < framebuffer->texture_ids.size(); i++) {
-			Texture *texture = texture_owner.getornull(framebuffer->texture_ids[i]);
+			Texture *texture = texture_owner.get_or_null(framebuffer->texture_ids[i]);
 
 			if (texture->usage_flags & TEXTURE_USAGE_COLOR_ATTACHMENT_BIT) {
 				color_count++;
@@ -7056,7 +7056,7 @@ Error RenderingDeviceVulkan::draw_list_begin_split(RID p_framebuffer, uint32_t p
 
 	ERR_FAIL_COND_V(p_splits < 1, ERR_INVALID_DECLARATION);
 
-	Framebuffer *framebuffer = framebuffer_owner.getornull(p_framebuffer);
+	Framebuffer *framebuffer = framebuffer_owner.get_or_null(p_framebuffer);
 	ERR_FAIL_COND_V(!framebuffer, ERR_INVALID_DECLARATION);
 
 	Point2i viewport_offset;
@@ -7091,7 +7091,7 @@ Error RenderingDeviceVulkan::draw_list_begin_split(RID p_framebuffer, uint32_t p
 
 		int color_count = 0;
 		for (int i = 0; i < framebuffer->texture_ids.size(); i++) {
-			Texture *texture = texture_owner.getornull(framebuffer->texture_ids[i]);
+			Texture *texture = texture_owner.get_or_null(framebuffer->texture_ids[i]);
 
 			if (texture->usage_flags & TEXTURE_USAGE_COLOR_ATTACHMENT_BIT) {
 				color_count++;
@@ -7192,7 +7192,7 @@ void RenderingDeviceVulkan::draw_list_bind_render_pipeline(DrawListID p_list, RI
 	ERR_FAIL_COND_MSG(!dl->validation.active, "Submitted Draw Lists can no longer be modified.");
 #endif
 
-	const RenderPipeline *pipeline = render_pipeline_owner.getornull(p_render_pipeline);
+	const RenderPipeline *pipeline = render_pipeline_owner.get_or_null(p_render_pipeline);
 	ERR_FAIL_COND(!pipeline);
 #ifdef DEBUG_ENABLED
 	ERR_FAIL_COND(pipeline->validation.framebuffer_format != draw_list_framebuffer_format && pipeline->validation.render_pass != draw_list_current_subpass);
@@ -7267,7 +7267,7 @@ void RenderingDeviceVulkan::draw_list_bind_uniform_set(DrawListID p_list, RID p_
 	ERR_FAIL_COND_MSG(!dl->validation.active, "Submitted Draw Lists can no longer be modified.");
 #endif
 
-	const UniformSet *uniform_set = uniform_set_owner.getornull(p_uniform_set);
+	const UniformSet *uniform_set = uniform_set_owner.get_or_null(p_uniform_set);
 	ERR_FAIL_COND(!uniform_set);
 
 	if (p_index > dl->state.set_count) {
@@ -7315,7 +7315,7 @@ void RenderingDeviceVulkan::draw_list_bind_vertex_array(DrawListID p_list, RID p
 	ERR_FAIL_COND_MSG(!dl->validation.active, "Submitted Draw Lists can no longer be modified.");
 #endif
 
-	const VertexArray *vertex_array = vertex_array_owner.getornull(p_vertex_array);
+	const VertexArray *vertex_array = vertex_array_owner.get_or_null(p_vertex_array);
 	ERR_FAIL_COND(!vertex_array);
 
 	if (dl->state.vertex_array == p_vertex_array) {
@@ -7339,7 +7339,7 @@ void RenderingDeviceVulkan::draw_list_bind_index_array(DrawListID p_list, RID p_
 	ERR_FAIL_COND_MSG(!dl->validation.active, "Submitted Draw Lists can no longer be modified.");
 #endif
 
-	const IndexArray *index_array = index_array_owner.getornull(p_index_array);
+	const IndexArray *index_array = index_array_owner.get_or_null(p_index_array);
 	ERR_FAIL_COND(!index_array);
 
 	if (dl->state.index_array == p_index_array) {
@@ -7425,7 +7425,7 @@ void RenderingDeviceVulkan::draw_list_draw(DrawListID p_list, bool p_use_indices
 			if (dl->state.sets[i].uniform_set_format == 0) {
 				ERR_FAIL_MSG("Uniforms were never supplied for set (" + itos(i) + ") at the time of drawing, which are required by the pipeline");
 			} else if (uniform_set_owner.owns(dl->state.sets[i].uniform_set)) {
-				UniformSet *us = uniform_set_owner.getornull(dl->state.sets[i].uniform_set);
+				UniformSet *us = uniform_set_owner.get_or_null(dl->state.sets[i].uniform_set);
 				ERR_FAIL_MSG("Uniforms supplied for set (" + itos(i) + "):\n" + _shader_uniform_debug(us->shader_id, us->shader_set) + "\nare not the same format as required by the pipeline shader. Pipeline shader requires the following bindings:\n" + _shader_uniform_debug(dl->state.pipeline_shader));
 			} else {
 				ERR_FAIL_MSG("Uniforms supplied for set (" + itos(i) + ", which was was just freed) are not the same format as required by the pipeline shader. Pipeline shader requires the following bindings:\n" + _shader_uniform_debug(dl->state.pipeline_shader));
@@ -7696,7 +7696,7 @@ void RenderingDeviceVulkan::draw_list_end(uint32_t p_post_barrier) {
 	vkCmdEndRenderPass(frames[frame].draw_command_buffer);
 
 	for (int i = 0; i < draw_list_bound_textures.size(); i++) {
-		Texture *texture = texture_owner.getornull(draw_list_bound_textures[i]);
+		Texture *texture = texture_owner.get_or_null(draw_list_bound_textures[i]);
 		ERR_CONTINUE(!texture); //wtf
 		if (draw_list_unbind_color_textures && (texture->usage_flags & TEXTURE_USAGE_COLOR_ATTACHMENT_BIT)) {
 			texture->bound = false;
@@ -7744,7 +7744,7 @@ void RenderingDeviceVulkan::draw_list_end(uint32_t p_post_barrier) {
 	}
 
 	for (uint32_t i = 0; i < image_barrier_count; i++) {
-		Texture *texture = texture_owner.getornull(draw_list_storage_textures[i]);
+		Texture *texture = texture_owner.get_or_null(draw_list_storage_textures[i]);
 
 		VkImageMemoryBarrier &image_memory_barrier = image_barriers[i];
 		image_memory_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
@@ -7810,7 +7810,7 @@ void RenderingDeviceVulkan::compute_list_bind_compute_pipeline(ComputeListID p_l
 
 	ComputeList *cl = compute_list;
 
-	const ComputePipeline *pipeline = compute_pipeline_owner.getornull(p_compute_pipeline);
+	const ComputePipeline *pipeline = compute_pipeline_owner.get_or_null(p_compute_pipeline);
 	ERR_FAIL_COND(!pipeline);
 
 	if (p_compute_pipeline == cl->state.pipeline) {
@@ -7883,7 +7883,7 @@ void RenderingDeviceVulkan::compute_list_bind_uniform_set(ComputeListID p_list,
 	ERR_FAIL_COND_MSG(!cl->validation.active, "Submitted Compute Lists can no longer be modified.");
 #endif
 
-	UniformSet *uniform_set = uniform_set_owner.getornull(p_uniform_set);
+	UniformSet *uniform_set = uniform_set_owner.get_or_null(p_uniform_set);
 	ERR_FAIL_COND(!uniform_set);
 
 	if (p_index > cl->state.set_count) {
@@ -8082,7 +8082,7 @@ void RenderingDeviceVulkan::compute_list_dispatch(ComputeListID p_list, uint32_t
 			if (cl->state.sets[i].uniform_set_format == 0) {
 				ERR_FAIL_MSG("Uniforms were never supplied for set (" + itos(i) + ") at the time of drawing, which are required by the pipeline");
 			} else if (uniform_set_owner.owns(cl->state.sets[i].uniform_set)) {
-				UniformSet *us = uniform_set_owner.getornull(cl->state.sets[i].uniform_set);
+				UniformSet *us = uniform_set_owner.get_or_null(cl->state.sets[i].uniform_set);
 				ERR_FAIL_MSG("Uniforms supplied for set (" + itos(i) + "):\n" + _shader_uniform_debug(us->shader_id, us->shader_set) + "\nare not the same format as required by the pipeline shader. Pipeline shader requires the following bindings:\n" + _shader_uniform_debug(cl->state.pipeline_shader));
 			} else {
 				ERR_FAIL_MSG("Uniforms supplied for set (" + itos(i) + ", which was was just freed) are not the same format as required by the pipeline shader. Pipeline shader requires the following bindings:\n" + _shader_uniform_debug(cl->state.pipeline_shader));
@@ -8125,7 +8125,7 @@ void RenderingDeviceVulkan::compute_list_dispatch_indirect(ComputeListID p_list,
 	ERR_FAIL_COND(!compute_list);
 
 	ComputeList *cl = compute_list;
-	Buffer *buffer = storage_buffer_owner.getornull(p_buffer);
+	Buffer *buffer = storage_buffer_owner.get_or_null(p_buffer);
 	ERR_FAIL_COND(!buffer);
 
 	ERR_FAIL_COND_MSG(!(buffer->usage & STORAGE_BUFFER_USAGE_DISPATCH_INDIRECT), "Buffer provided was not created to do indirect dispatch.");
@@ -8159,7 +8159,7 @@ void RenderingDeviceVulkan::compute_list_dispatch_indirect(ComputeListID p_list,
 			if (cl->state.sets[i].uniform_set_format == 0) {
 				ERR_FAIL_MSG("Uniforms were never supplied for set (" + itos(i) + ") at the time of drawing, which are required by the pipeline");
 			} else if (uniform_set_owner.owns(cl->state.sets[i].uniform_set)) {
-				UniformSet *us = uniform_set_owner.getornull(cl->state.sets[i].uniform_set);
+				UniformSet *us = uniform_set_owner.get_or_null(cl->state.sets[i].uniform_set);
 				ERR_FAIL_MSG("Uniforms supplied for set (" + itos(i) + "):\n" + _shader_uniform_debug(us->shader_id, us->shader_set) + "\nare not the same format as required by the pipeline shader. Pipeline shader requires the following bindings:\n" + _shader_uniform_debug(cl->state.pipeline_shader));
 			} else {
 				ERR_FAIL_MSG("Uniforms supplied for set (" + itos(i) + ", which was was just freed) are not the same format as required by the pipeline shader. Pipeline shader requires the following bindings:\n" + _shader_uniform_debug(cl->state.pipeline_shader));
@@ -8371,25 +8371,25 @@ void RenderingDeviceVulkan::draw_list_render_secondary_to_framebuffer(ID p_frame
 void RenderingDeviceVulkan::_free_internal(RID p_id) {
 	//push everything so it's disposed of next time this frame index is processed (means, it's safe to do it)
 	if (texture_owner.owns(p_id)) {
-		Texture *texture = texture_owner.getornull(p_id);
+		Texture *texture = texture_owner.get_or_null(p_id);
 		frames[frame].textures_to_dispose_of.push_back(*texture);
 		texture_owner.free(p_id);
 	} else if (framebuffer_owner.owns(p_id)) {
-		Framebuffer *framebuffer = framebuffer_owner.getornull(p_id);
+		Framebuffer *framebuffer = framebuffer_owner.get_or_null(p_id);
 		frames[frame].framebuffers_to_dispose_of.push_back(*framebuffer);
 		framebuffer_owner.free(p_id);
 	} else if (sampler_owner.owns(p_id)) {
-		VkSampler *sampler = sampler_owner.getornull(p_id);
+		VkSampler *sampler = sampler_owner.get_or_null(p_id);
 		frames[frame].samplers_to_dispose_of.push_back(*sampler);
 		sampler_owner.free(p_id);
 	} else if (vertex_buffer_owner.owns(p_id)) {
-		Buffer *vertex_buffer = vertex_buffer_owner.getornull(p_id);
+		Buffer *vertex_buffer = vertex_buffer_owner.get_or_null(p_id);
 		frames[frame].buffers_to_dispose_of.push_back(*vertex_buffer);
 		vertex_buffer_owner.free(p_id);
 	} else if (vertex_array_owner.owns(p_id)) {
 		vertex_array_owner.free(p_id);
 	} else if (index_buffer_owner.owns(p_id)) {
-		IndexBuffer *index_buffer = index_buffer_owner.getornull(p_id);
+		IndexBuffer *index_buffer = index_buffer_owner.get_or_null(p_id);
 		Buffer b;
 		b.allocation = index_buffer->allocation;
 		b.buffer = index_buffer->buffer;
@@ -8400,24 +8400,24 @@ void RenderingDeviceVulkan::_free_internal(RID p_id) {
 	} else if (index_array_owner.owns(p_id)) {
 		index_array_owner.free(p_id);
 	} else if (shader_owner.owns(p_id)) {
-		Shader *shader = shader_owner.getornull(p_id);
+		Shader *shader = shader_owner.get_or_null(p_id);
 		frames[frame].shaders_to_dispose_of.push_back(*shader);
 		shader_owner.free(p_id);
 	} else if (uniform_buffer_owner.owns(p_id)) {
-		Buffer *uniform_buffer = uniform_buffer_owner.getornull(p_id);
+		Buffer *uniform_buffer = uniform_buffer_owner.get_or_null(p_id);
 		frames[frame].buffers_to_dispose_of.push_back(*uniform_buffer);
 		uniform_buffer_owner.free(p_id);
 	} else if (texture_buffer_owner.owns(p_id)) {
-		TextureBuffer *texture_buffer = texture_buffer_owner.getornull(p_id);
+		TextureBuffer *texture_buffer = texture_buffer_owner.get_or_null(p_id);
 		frames[frame].buffers_to_dispose_of.push_back(texture_buffer->buffer);
 		frames[frame].buffer_views_to_dispose_of.push_back(texture_buffer->view);
 		texture_buffer_owner.free(p_id);
 	} else if (storage_buffer_owner.owns(p_id)) {
-		Buffer *storage_buffer = storage_buffer_owner.getornull(p_id);
+		Buffer *storage_buffer = storage_buffer_owner.get_or_null(p_id);
 		frames[frame].buffers_to_dispose_of.push_back(*storage_buffer);
 		storage_buffer_owner.free(p_id);
 	} else if (uniform_set_owner.owns(p_id)) {
-		UniformSet *uniform_set = uniform_set_owner.getornull(p_id);
+		UniformSet *uniform_set = uniform_set_owner.get_or_null(p_id);
 		frames[frame].uniform_sets_to_dispose_of.push_back(*uniform_set);
 		if (uniform_set->invalidated_callback != nullptr) {
 			uniform_set->invalidated_callback(p_id, uniform_set->invalidated_callback_userdata);
@@ -8425,11 +8425,11 @@ void RenderingDeviceVulkan::_free_internal(RID p_id) {
 
 		uniform_set_owner.free(p_id);
 	} else if (render_pipeline_owner.owns(p_id)) {
-		RenderPipeline *pipeline = render_pipeline_owner.getornull(p_id);
+		RenderPipeline *pipeline = render_pipeline_owner.get_or_null(p_id);
 		frames[frame].render_pipelines_to_dispose_of.push_back(*pipeline);
 		render_pipeline_owner.free(p_id);
 	} else if (compute_pipeline_owner.owns(p_id)) {
-		ComputePipeline *pipeline = compute_pipeline_owner.getornull(p_id);
+		ComputePipeline *pipeline = compute_pipeline_owner.get_or_null(p_id);
 		frames[frame].compute_pipelines_to_dispose_of.push_back(*pipeline);
 		compute_pipeline_owner.free(p_id);
 	} else {
@@ -8448,49 +8448,49 @@ void RenderingDeviceVulkan::free(RID p_id) {
 // We just expose the resources that are owned and can be accessed easily.
 void RenderingDeviceVulkan::set_resource_name(RID p_id, const String p_name) {
 	if (texture_owner.owns(p_id)) {
-		Texture *texture = texture_owner.getornull(p_id);
+		Texture *texture = texture_owner.get_or_null(p_id);
 		if (texture->owner.is_null()) {
 			// Don't set the source texture's name when calling on a texture view
 			context->set_object_name(VK_OBJECT_TYPE_IMAGE, uint64_t(texture->image), p_name);
 		}
 		context->set_object_name(VK_OBJECT_TYPE_IMAGE_VIEW, uint64_t(texture->view), p_name + " View");
 	} else if (framebuffer_owner.owns(p_id)) {
-		//Framebuffer *framebuffer = framebuffer_owner.getornull(p_id);
+		//Framebuffer *framebuffer = framebuffer_owner.get_or_null(p_id);
 		// Not implemented for now as the relationship between Framebuffer and RenderPass is very complex
 	} else if (sampler_owner.owns(p_id)) {
-		VkSampler *sampler = sampler_owner.getornull(p_id);
+		VkSampler *sampler = sampler_owner.get_or_null(p_id);
 		context->set_object_name(VK_OBJECT_TYPE_SAMPLER, uint64_t(*sampler), p_name);
 	} else if (vertex_buffer_owner.owns(p_id)) {
-		Buffer *vertex_buffer = vertex_buffer_owner.getornull(p_id);
+		Buffer *vertex_buffer = vertex_buffer_owner.get_or_null(p_id);
 		context->set_object_name(VK_OBJECT_TYPE_BUFFER, uint64_t(vertex_buffer->buffer), p_name);
 	} else if (index_buffer_owner.owns(p_id)) {
-		IndexBuffer *index_buffer = index_buffer_owner.getornull(p_id);
+		IndexBuffer *index_buffer = index_buffer_owner.get_or_null(p_id);
 		context->set_object_name(VK_OBJECT_TYPE_BUFFER, uint64_t(index_buffer->buffer), p_name);
 	} else if (shader_owner.owns(p_id)) {
-		Shader *shader = shader_owner.getornull(p_id);
+		Shader *shader = shader_owner.get_or_null(p_id);
 		context->set_object_name(VK_OBJECT_TYPE_PIPELINE_LAYOUT, uint64_t(shader->pipeline_layout), p_name + " Pipeline Layout");
 		for (int i = 0; i < shader->sets.size(); i++) {
 			context->set_object_name(VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT, uint64_t(shader->sets[i].descriptor_set_layout), p_name);
 		}
 	} else if (uniform_buffer_owner.owns(p_id)) {
-		Buffer *uniform_buffer = uniform_buffer_owner.getornull(p_id);
+		Buffer *uniform_buffer = uniform_buffer_owner.get_or_null(p_id);
 		context->set_object_name(VK_OBJECT_TYPE_BUFFER, uint64_t(uniform_buffer->buffer), p_name);
 	} else if (texture_buffer_owner.owns(p_id)) {
-		TextureBuffer *texture_buffer = texture_buffer_owner.getornull(p_id);
+		TextureBuffer *texture_buffer = texture_buffer_owner.get_or_null(p_id);
 		context->set_object_name(VK_OBJECT_TYPE_BUFFER, uint64_t(texture_buffer->buffer.buffer), p_name);
 		context->set_object_name(VK_OBJECT_TYPE_BUFFER_VIEW, uint64_t(texture_buffer->view), p_name + " View");
 	} else if (storage_buffer_owner.owns(p_id)) {
-		Buffer *storage_buffer = storage_buffer_owner.getornull(p_id);
+		Buffer *storage_buffer = storage_buffer_owner.get_or_null(p_id);
 		context->set_object_name(VK_OBJECT_TYPE_BUFFER, uint64_t(storage_buffer->buffer), p_name);
 	} else if (uniform_set_owner.owns(p_id)) {
-		UniformSet *uniform_set = uniform_set_owner.getornull(p_id);
+		UniformSet *uniform_set = uniform_set_owner.get_or_null(p_id);
 		context->set_object_name(VK_OBJECT_TYPE_DESCRIPTOR_SET, uint64_t(uniform_set->descriptor_set), p_name);
 	} else if (render_pipeline_owner.owns(p_id)) {
-		RenderPipeline *pipeline = render_pipeline_owner.getornull(p_id);
+		RenderPipeline *pipeline = render_pipeline_owner.get_or_null(p_id);
 		context->set_object_name(VK_OBJECT_TYPE_PIPELINE, uint64_t(pipeline->pipeline), p_name);
 		context->set_object_name(VK_OBJECT_TYPE_PIPELINE_LAYOUT, uint64_t(pipeline->pipeline_layout), p_name + " Layout");
 	} else if (compute_pipeline_owner.owns(p_id)) {
-		ComputePipeline *pipeline = compute_pipeline_owner.getornull(p_id);
+		ComputePipeline *pipeline = compute_pipeline_owner.get_or_null(p_id);
 		context->set_object_name(VK_OBJECT_TYPE_PIPELINE, uint64_t(pipeline->pipeline), p_name);
 		context->set_object_name(VK_OBJECT_TYPE_PIPELINE_LAYOUT, uint64_t(pipeline->pipeline_layout), p_name + " Layout");
 	} else {
@@ -9037,31 +9037,31 @@ uint64_t RenderingDeviceVulkan::get_driver_resource(DriverResource p_resource, R
 			return context->get_graphics_queue_family_index();
 		}; break;
 		case DRIVER_RESOURCE_VULKAN_IMAGE: {
-			Texture *tex = texture_owner.getornull(p_rid);
+			Texture *tex = texture_owner.get_or_null(p_rid);
 			ERR_FAIL_NULL_V(tex, 0);
 
 			return (uint64_t)tex->image;
 		}; break;
 		case DRIVER_RESOURCE_VULKAN_IMAGE_VIEW: {
-			Texture *tex = texture_owner.getornull(p_rid);
+			Texture *tex = texture_owner.get_or_null(p_rid);
 			ERR_FAIL_NULL_V(tex, 0);
 
 			return (uint64_t)tex->view;
 		}; break;
 		case DRIVER_RESOURCE_VULKAN_IMAGE_NATIVE_TEXTURE_FORMAT: {
-			Texture *tex = texture_owner.getornull(p_rid);
+			Texture *tex = texture_owner.get_or_null(p_rid);
 			ERR_FAIL_NULL_V(tex, 0);
 
 			return vulkan_formats[tex->format];
 		}; break;
 		case DRIVER_RESOURCE_VULKAN_SAMPLER: {
-			VkSampler *sampler = sampler_owner.getornull(p_rid);
+			VkSampler *sampler = sampler_owner.get_or_null(p_rid);
 			ERR_FAIL_NULL_V(sampler, 0);
 
 			return uint64_t(*sampler);
 		}; break;
 		case DRIVER_RESOURCE_VULKAN_DESCRIPTOR_SET: {
-			UniformSet *uniform_set = uniform_set_owner.getornull(p_rid);
+			UniformSet *uniform_set = uniform_set_owner.get_or_null(p_rid);
 			ERR_FAIL_NULL_V(uniform_set, 0);
 
 			return uint64_t(uniform_set->descriptor_set);
@@ -9069,15 +9069,15 @@ uint64_t RenderingDeviceVulkan::get_driver_resource(DriverResource p_resource, R
 		case DRIVER_RESOURCE_VULKAN_BUFFER: {
 			Buffer *buffer = nullptr;
 			if (vertex_buffer_owner.owns(p_rid)) {
-				buffer = vertex_buffer_owner.getornull(p_rid);
+				buffer = vertex_buffer_owner.get_or_null(p_rid);
 			} else if (index_buffer_owner.owns(p_rid)) {
-				buffer = index_buffer_owner.getornull(p_rid);
+				buffer = index_buffer_owner.get_or_null(p_rid);
 			} else if (uniform_buffer_owner.owns(p_rid)) {
-				buffer = uniform_buffer_owner.getornull(p_rid);
+				buffer = uniform_buffer_owner.get_or_null(p_rid);
 			} else if (texture_buffer_owner.owns(p_rid)) {
-				buffer = &texture_buffer_owner.getornull(p_rid)->buffer;
+				buffer = &texture_buffer_owner.get_or_null(p_rid)->buffer;
 			} else if (storage_buffer_owner.owns(p_rid)) {
-				buffer = storage_buffer_owner.getornull(p_rid);
+				buffer = storage_buffer_owner.get_or_null(p_rid);
 			}
 
 			ERR_FAIL_NULL_V(buffer, 0);
@@ -9085,13 +9085,13 @@ uint64_t RenderingDeviceVulkan::get_driver_resource(DriverResource p_resource, R
 			return uint64_t(buffer->buffer);
 		}; break;
 		case DRIVER_RESOURCE_VULKAN_COMPUTE_PIPELINE: {
-			ComputePipeline *compute_pipeline = compute_pipeline_owner.getornull(p_rid);
+			ComputePipeline *compute_pipeline = compute_pipeline_owner.get_or_null(p_rid);
 			ERR_FAIL_NULL_V(compute_pipeline, 0);
 
 			return uint64_t(compute_pipeline->pipeline);
 		}; break;
 		case DRIVER_RESOURCE_VULKAN_RENDER_PIPELINE: {
-			RenderPipeline *render_pipeline = render_pipeline_owner.getornull(p_rid);
+			RenderPipeline *render_pipeline = render_pipeline_owner.get_or_null(p_rid);
 			ERR_FAIL_NULL_V(render_pipeline, 0);
 
 			return uint64_t(render_pipeline->pipeline);
diff --git a/drivers/vulkan/vulkan_context.cpp b/drivers/vulkan/vulkan_context.cpp
index bb0123e536..1c7e83af21 100644
--- a/drivers/vulkan/vulkan_context.cpp
+++ b/drivers/vulkan/vulkan_context.cpp
@@ -2084,12 +2084,12 @@ RID VulkanContext::local_device_create() {
 }
 
 VkDevice VulkanContext::local_device_get_vk_device(RID p_local_device) {
-	LocalDevice *ld = local_device_owner.getornull(p_local_device);
+	LocalDevice *ld = local_device_owner.get_or_null(p_local_device);
 	return ld->device;
 }
 
 void VulkanContext::local_device_push_command_buffers(RID p_local_device, const VkCommandBuffer *p_buffers, int p_count) {
-	LocalDevice *ld = local_device_owner.getornull(p_local_device);
+	LocalDevice *ld = local_device_owner.get_or_null(p_local_device);
 	ERR_FAIL_COND(ld->waiting);
 
 	VkSubmitInfo submit_info;
@@ -2119,7 +2119,7 @@ void VulkanContext::local_device_push_command_buffers(RID p_local_device, const
 }
 
 void VulkanContext::local_device_sync(RID p_local_device) {
-	LocalDevice *ld = local_device_owner.getornull(p_local_device);
+	LocalDevice *ld = local_device_owner.get_or_null(p_local_device);
 	ERR_FAIL_COND(!ld->waiting);
 
 	vkDeviceWaitIdle(ld->device);
@@ -2127,7 +2127,7 @@ void VulkanContext::local_device_sync(RID p_local_device) {
 }
 
 void VulkanContext::local_device_free(RID p_local_device) {
-	LocalDevice *ld = local_device_owner.getornull(p_local_device);
+	LocalDevice *ld = local_device_owner.get_or_null(p_local_device);
 	vkDestroyDevice(ld->device, nullptr);
 	local_device_owner.free(p_local_device);
 }
diff --git a/modules/bullet/bullet_physics_server.cpp b/modules/bullet/bullet_physics_server.cpp
index ed05e51e53..3054debaec 100644
--- a/modules/bullet/bullet_physics_server.cpp
+++ b/modules/bullet/bullet_physics_server.cpp
@@ -124,7 +124,7 @@ RID BulletPhysicsServer3D::shape_create(ShapeType p_shape) {
 }
 
 void BulletPhysicsServer3D::shape_set_data(RID p_shape, const Variant &p_data) {
-	ShapeBullet *shape = shape_owner.getornull(p_shape);
+	ShapeBullet *shape = shape_owner.get_or_null(p_shape);
 	ERR_FAIL_COND(!shape);
 	shape->set_data(p_data);
 }
@@ -134,25 +134,25 @@ void BulletPhysicsServer3D::shape_set_custom_solver_bias(RID p_shape, real_t p_b
 }
 
 PhysicsServer3D::ShapeType BulletPhysicsServer3D::shape_get_type(RID p_shape) const {
-	ShapeBullet *shape = shape_owner.getornull(p_shape);
+	ShapeBullet *shape = shape_owner.get_or_null(p_shape);
 	ERR_FAIL_COND_V(!shape, PhysicsServer3D::SHAPE_CUSTOM);
 	return shape->get_type();
 }
 
 Variant BulletPhysicsServer3D::shape_get_data(RID p_shape) const {
-	ShapeBullet *shape = shape_owner.getornull(p_shape);
+	ShapeBullet *shape = shape_owner.get_or_null(p_shape);
 	ERR_FAIL_COND_V(!shape, Variant());
 	return shape->get_data();
 }
 
 void BulletPhysicsServer3D::shape_set_margin(RID p_shape, real_t p_margin) {
-	ShapeBullet *shape = shape_owner.getornull(p_shape);
+	ShapeBullet *shape = shape_owner.get_or_null(p_shape);
 	ERR_FAIL_COND(!shape);
 	shape->set_margin(p_margin);
 }
 
 real_t BulletPhysicsServer3D::shape_get_margin(RID p_shape) const {
-	ShapeBullet *shape = shape_owner.getornull(p_shape);
+	ShapeBullet *shape = shape_owner.get_or_null(p_shape);
 	ERR_FAIL_COND_V(!shape, 0.0);
 	return shape->get_margin();
 }
@@ -168,7 +168,7 @@ RID BulletPhysicsServer3D::space_create() {
 }
 
 void BulletPhysicsServer3D::space_set_active(RID p_space, bool p_active) {
-	SpaceBullet *space = space_owner.getornull(p_space);
+	SpaceBullet *space = space_owner.get_or_null(p_space);
 	ERR_FAIL_COND(!space);
 
 	if (space_is_active(p_space) == p_active) {
@@ -185,47 +185,47 @@ void BulletPhysicsServer3D::space_set_active(RID p_space, bool p_active) {
 }
 
 bool BulletPhysicsServer3D::space_is_active(RID p_space) const {
-	SpaceBullet *space = space_owner.getornull(p_space);
+	SpaceBullet *space = space_owner.get_or_null(p_space);
 	ERR_FAIL_COND_V(!space, false);
 
 	return -1 != active_spaces.find(space);
 }
 
 void BulletPhysicsServer3D::space_set_param(RID p_space, SpaceParameter p_param, real_t p_value) {
-	SpaceBullet *space = space_owner.getornull(p_space);
+	SpaceBullet *space = space_owner.get_or_null(p_space);
 	ERR_FAIL_COND(!space);
 	space->set_param(p_param, p_value);
 }
 
 real_t BulletPhysicsServer3D::space_get_param(RID p_space, SpaceParameter p_param) const {
-	SpaceBullet *space = space_owner.getornull(p_space);
+	SpaceBullet *space = space_owner.get_or_null(p_space);
 	ERR_FAIL_COND_V(!space, 0);
 	return space->get_param(p_param);
 }
 
 PhysicsDirectSpaceState3D *BulletPhysicsServer3D::space_get_direct_state(RID p_space) {
-	SpaceBullet *space = space_owner.getornull(p_space);
+	SpaceBullet *space = space_owner.get_or_null(p_space);
 	ERR_FAIL_COND_V(!space, nullptr);
 
 	return space->get_direct_state();
 }
 
 void BulletPhysicsServer3D::space_set_debug_contacts(RID p_space, int p_max_contacts) {
-	SpaceBullet *space = space_owner.getornull(p_space);
+	SpaceBullet *space = space_owner.get_or_null(p_space);
 	ERR_FAIL_COND(!space);
 
 	space->set_debug_contacts(p_max_contacts);
 }
 
 Vector<Vector3> BulletPhysicsServer3D::space_get_contacts(RID p_space) const {
-	SpaceBullet *space = space_owner.getornull(p_space);
+	SpaceBullet *space = space_owner.get_or_null(p_space);
 	ERR_FAIL_COND_V(!space, Vector<Vector3>());
 
 	return space->get_debug_contacts();
 }
 
 int BulletPhysicsServer3D::space_get_contact_count(RID p_space) const {
-	SpaceBullet *space = space_owner.getornull(p_space);
+	SpaceBullet *space = space_owner.get_or_null(p_space);
 	ERR_FAIL_COND_V(!space, 0);
 
 	return space->get_debug_contact_count();
@@ -239,91 +239,91 @@ RID BulletPhysicsServer3D::area_create() {
 }
 
 void BulletPhysicsServer3D::area_set_space(RID p_area, RID p_space) {
-	AreaBullet *area = area_owner.getornull(p_area);
+	AreaBullet *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 	SpaceBullet *space = nullptr;
 	if (p_space.is_valid()) {
-		space = space_owner.getornull(p_space);
+		space = space_owner.get_or_null(p_space);
 		ERR_FAIL_COND(!space);
 	}
 	area->set_space(space);
 }
 
 RID BulletPhysicsServer3D::area_get_space(RID p_area) const {
-	AreaBullet *area = area_owner.getornull(p_area);
+	AreaBullet *area = area_owner.get_or_null(p_area);
 	return area->get_space()->get_self();
 }
 
 void BulletPhysicsServer3D::area_set_space_override_mode(RID p_area, AreaSpaceOverrideMode p_mode) {
-	AreaBullet *area = area_owner.getornull(p_area);
+	AreaBullet *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 
 	area->set_spOv_mode(p_mode);
 }
 
 PhysicsServer3D::AreaSpaceOverrideMode BulletPhysicsServer3D::area_get_space_override_mode(RID p_area) const {
-	AreaBullet *area = area_owner.getornull(p_area);
+	AreaBullet *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND_V(!area, PhysicsServer3D::AREA_SPACE_OVERRIDE_DISABLED);
 
 	return area->get_spOv_mode();
 }
 
 void BulletPhysicsServer3D::area_add_shape(RID p_area, RID p_shape, const Transform3D &p_transform, bool p_disabled) {
-	AreaBullet *area = area_owner.getornull(p_area);
+	AreaBullet *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 
-	ShapeBullet *shape = shape_owner.getornull(p_shape);
+	ShapeBullet *shape = shape_owner.get_or_null(p_shape);
 	ERR_FAIL_COND(!shape);
 
 	area->add_shape(shape, p_transform, p_disabled);
 }
 
 void BulletPhysicsServer3D::area_set_shape(RID p_area, int p_shape_idx, RID p_shape) {
-	AreaBullet *area = area_owner.getornull(p_area);
+	AreaBullet *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 
-	ShapeBullet *shape = shape_owner.getornull(p_shape);
+	ShapeBullet *shape = shape_owner.get_or_null(p_shape);
 	ERR_FAIL_COND(!shape);
 
 	area->set_shape(p_shape_idx, shape);
 }
 
 void BulletPhysicsServer3D::area_set_shape_transform(RID p_area, int p_shape_idx, const Transform3D &p_transform) {
-	AreaBullet *area = area_owner.getornull(p_area);
+	AreaBullet *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 
 	area->set_shape_transform(p_shape_idx, p_transform);
 }
 
 int BulletPhysicsServer3D::area_get_shape_count(RID p_area) const {
-	AreaBullet *area = area_owner.getornull(p_area);
+	AreaBullet *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND_V(!area, 0);
 
 	return area->get_shape_count();
 }
 
 RID BulletPhysicsServer3D::area_get_shape(RID p_area, int p_shape_idx) const {
-	AreaBullet *area = area_owner.getornull(p_area);
+	AreaBullet *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND_V(!area, RID());
 
 	return area->get_shape(p_shape_idx)->get_self();
 }
 
 Transform3D BulletPhysicsServer3D::area_get_shape_transform(RID p_area, int p_shape_idx) const {
-	AreaBullet *area = area_owner.getornull(p_area);
+	AreaBullet *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND_V(!area, Transform3D());
 
 	return area->get_shape_transform(p_shape_idx);
 }
 
 void BulletPhysicsServer3D::area_remove_shape(RID p_area, int p_shape_idx) {
-	AreaBullet *area = area_owner.getornull(p_area);
+	AreaBullet *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 	return area->remove_shape_full(p_shape_idx);
 }
 
 void BulletPhysicsServer3D::area_clear_shapes(RID p_area) {
-	AreaBullet *area = area_owner.getornull(p_area);
+	AreaBullet *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 
 	for (int i = area->get_shape_count(); 0 < i; --i) {
@@ -332,7 +332,7 @@ void BulletPhysicsServer3D::area_clear_shapes(RID p_area) {
 }
 
 void BulletPhysicsServer3D::area_set_shape_disabled(RID p_area, int p_shape_idx, bool p_disabled) {
-	AreaBullet *area = area_owner.getornull(p_area);
+	AreaBullet *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 
 	area->set_shape_disabled(p_shape_idx, p_disabled);
@@ -342,7 +342,7 @@ void BulletPhysicsServer3D::area_attach_object_instance_id(RID p_area, ObjectID
 	if (space_owner.owns(p_area)) {
 		return;
 	}
-	AreaBullet *area = area_owner.getornull(p_area);
+	AreaBullet *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 	area->set_instance_id(p_id);
 }
@@ -351,19 +351,19 @@ ObjectID BulletPhysicsServer3D::area_get_object_instance_id(RID p_area) const {
 	if (space_owner.owns(p_area)) {
 		return ObjectID();
 	}
-	AreaBullet *area = area_owner.getornull(p_area);
+	AreaBullet *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND_V(!area, ObjectID());
 	return area->get_instance_id();
 }
 
 void BulletPhysicsServer3D::area_set_param(RID p_area, AreaParameter p_param, const Variant &p_value) {
 	if (space_owner.owns(p_area)) {
-		SpaceBullet *space = space_owner.getornull(p_area);
+		SpaceBullet *space = space_owner.get_or_null(p_area);
 		if (space) {
 			space->set_param(p_param, p_value);
 		}
 	} else {
-		AreaBullet *area = area_owner.getornull(p_area);
+		AreaBullet *area = area_owner.get_or_null(p_area);
 		ERR_FAIL_COND(!area);
 
 		area->set_param(p_param, p_value);
@@ -372,10 +372,10 @@ void BulletPhysicsServer3D::area_set_param(RID p_area, AreaParameter p_param, co
 
 Variant BulletPhysicsServer3D::area_get_param(RID p_area, AreaParameter p_param) const {
 	if (space_owner.owns(p_area)) {
-		SpaceBullet *space = space_owner.getornull(p_area);
+		SpaceBullet *space = space_owner.get_or_null(p_area);
 		return space->get_param(p_param);
 	} else {
-		AreaBullet *area = area_owner.getornull(p_area);
+		AreaBullet *area = area_owner.get_or_null(p_area);
 		ERR_FAIL_COND_V(!area, Variant());
 
 		return area->get_param(p_param);
@@ -383,52 +383,52 @@ Variant BulletPhysicsServer3D::area_get_param(RID p_area, AreaParameter p_param)
 }
 
 void BulletPhysicsServer3D::area_set_transform(RID p_area, const Transform3D &p_transform) {
-	AreaBullet *area = area_owner.getornull(p_area);
+	AreaBullet *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 	area->set_transform(p_transform);
 }
 
 Transform3D BulletPhysicsServer3D::area_get_transform(RID p_area) const {
-	AreaBullet *area = area_owner.getornull(p_area);
+	AreaBullet *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND_V(!area, Transform3D());
 	return area->get_transform();
 }
 
 void BulletPhysicsServer3D::area_set_collision_mask(RID p_area, uint32_t p_mask) {
-	AreaBullet *area = area_owner.getornull(p_area);
+	AreaBullet *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 	area->set_collision_mask(p_mask);
 }
 
 void BulletPhysicsServer3D::area_set_collision_layer(RID p_area, uint32_t p_layer) {
-	AreaBullet *area = area_owner.getornull(p_area);
+	AreaBullet *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 	area->set_collision_layer(p_layer);
 }
 
 void BulletPhysicsServer3D::area_set_monitorable(RID p_area, bool p_monitorable) {
-	AreaBullet *area = area_owner.getornull(p_area);
+	AreaBullet *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 
 	area->set_monitorable(p_monitorable);
 }
 
 void BulletPhysicsServer3D::area_set_monitor_callback(RID p_area, Object *p_receiver, const StringName &p_method) {
-	AreaBullet *area = area_owner.getornull(p_area);
+	AreaBullet *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 
 	area->set_event_callback(CollisionObjectBullet::TYPE_RIGID_BODY, p_receiver ? p_receiver->get_instance_id() : ObjectID(), p_method);
 }
 
 void BulletPhysicsServer3D::area_set_area_monitor_callback(RID p_area, Object *p_receiver, const StringName &p_method) {
-	AreaBullet *area = area_owner.getornull(p_area);
+	AreaBullet *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 
 	area->set_event_callback(CollisionObjectBullet::TYPE_AREA, p_receiver ? p_receiver->get_instance_id() : ObjectID(), p_method);
 }
 
 void BulletPhysicsServer3D::area_set_ray_pickable(RID p_area, bool p_enable) {
-	AreaBullet *area = area_owner.getornull(p_area);
+	AreaBullet *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 	area->set_ray_pickable(p_enable);
 }
@@ -445,12 +445,12 @@ RID BulletPhysicsServer3D::body_create(BodyMode p_mode, bool p_init_sleeping) {
 }
 
 void BulletPhysicsServer3D::body_set_space(RID p_body, RID p_space) {
-	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
+	RigidBodyBullet *body = rigid_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 	SpaceBullet *space = nullptr;
 
 	if (p_space.is_valid()) {
-		space = space_owner.getornull(p_space);
+		space = space_owner.get_or_null(p_space);
 		ERR_FAIL_COND(!space);
 	}
 
@@ -462,7 +462,7 @@ void BulletPhysicsServer3D::body_set_space(RID p_body, RID p_space) {
 }
 
 RID BulletPhysicsServer3D::body_get_space(RID p_body) const {
-	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
+	RigidBodyBullet *body = rigid_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, RID());
 
 	SpaceBullet *space = body->get_space();
@@ -473,52 +473,52 @@ RID BulletPhysicsServer3D::body_get_space(RID p_body) const {
 }
 
 void BulletPhysicsServer3D::body_set_mode(RID p_body, PhysicsServer3D::BodyMode p_mode) {
-	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
+	RigidBodyBullet *body = rigid_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 	body->set_mode(p_mode);
 }
 
 PhysicsServer3D::BodyMode BulletPhysicsServer3D::body_get_mode(RID p_body) const {
-	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
+	RigidBodyBullet *body = rigid_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, BODY_MODE_STATIC);
 	return body->get_mode();
 }
 
 void BulletPhysicsServer3D::body_add_shape(RID p_body, RID p_shape, const Transform3D &p_transform, bool p_disabled) {
-	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
+	RigidBodyBullet *body = rigid_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
-	ShapeBullet *shape = shape_owner.getornull(p_shape);
+	ShapeBullet *shape = shape_owner.get_or_null(p_shape);
 	ERR_FAIL_COND(!shape);
 
 	body->add_shape(shape, p_transform, p_disabled);
 }
 
 void BulletPhysicsServer3D::body_set_shape(RID p_body, int p_shape_idx, RID p_shape) {
-	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
+	RigidBodyBullet *body = rigid_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
-	ShapeBullet *shape = shape_owner.getornull(p_shape);
+	ShapeBullet *shape = shape_owner.get_or_null(p_shape);
 	ERR_FAIL_COND(!shape);
 
 	body->set_shape(p_shape_idx, shape);
 }
 
 void BulletPhysicsServer3D::body_set_shape_transform(RID p_body, int p_shape_idx, const Transform3D &p_transform) {
-	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
+	RigidBodyBullet *body = rigid_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_shape_transform(p_shape_idx, p_transform);
 }
 
 int BulletPhysicsServer3D::body_get_shape_count(RID p_body) const {
-	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
+	RigidBodyBullet *body = rigid_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, 0);
 	return body->get_shape_count();
 }
 
 RID BulletPhysicsServer3D::body_get_shape(RID p_body, int p_shape_idx) const {
-	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
+	RigidBodyBullet *body = rigid_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, RID());
 
 	ShapeBullet *shape = body->get_shape(p_shape_idx);
@@ -528,27 +528,27 @@ RID BulletPhysicsServer3D::body_get_shape(RID p_body, int p_shape_idx) const {
 }
 
 Transform3D BulletPhysicsServer3D::body_get_shape_transform(RID p_body, int p_shape_idx) const {
-	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
+	RigidBodyBullet *body = rigid_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, Transform3D());
 	return body->get_shape_transform(p_shape_idx);
 }
 
 void BulletPhysicsServer3D::body_set_shape_disabled(RID p_body, int p_shape_idx, bool p_disabled) {
-	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
+	RigidBodyBullet *body = rigid_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_shape_disabled(p_shape_idx, p_disabled);
 }
 
 void BulletPhysicsServer3D::body_remove_shape(RID p_body, int p_shape_idx) {
-	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
+	RigidBodyBullet *body = rigid_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->remove_shape_full(p_shape_idx);
 }
 
 void BulletPhysicsServer3D::body_clear_shapes(RID p_body) {
-	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
+	RigidBodyBullet *body = rigid_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->remove_all_shapes();
@@ -569,42 +569,42 @@ ObjectID BulletPhysicsServer3D::body_get_object_instance_id(RID p_body) const {
 }
 
 void BulletPhysicsServer3D::body_set_enable_continuous_collision_detection(RID p_body, bool p_enable) {
-	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
+	RigidBodyBullet *body = rigid_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_continuous_collision_detection(p_enable);
 }
 
 bool BulletPhysicsServer3D::body_is_continuous_collision_detection_enabled(RID p_body) const {
-	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
+	RigidBodyBullet *body = rigid_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, false);
 
 	return body->is_continuous_collision_detection_enabled();
 }
 
 void BulletPhysicsServer3D::body_set_collision_layer(RID p_body, uint32_t p_layer) {
-	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
+	RigidBodyBullet *body = rigid_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_collision_layer(p_layer);
 }
 
 uint32_t BulletPhysicsServer3D::body_get_collision_layer(RID p_body) const {
-	const RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
+	const RigidBodyBullet *body = rigid_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, 0);
 
 	return body->get_collision_layer();
 }
 
 void BulletPhysicsServer3D::body_set_collision_mask(RID p_body, uint32_t p_mask) {
-	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
+	RigidBodyBullet *body = rigid_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_collision_mask(p_mask);
 }
 
 uint32_t BulletPhysicsServer3D::body_get_collision_mask(RID p_body) const {
-	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
+	RigidBodyBullet *body = rigid_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, 0);
 
 	return body->get_collision_mask();
@@ -620,21 +620,21 @@ uint32_t BulletPhysicsServer3D::body_get_user_flags(RID p_body) const {
 }
 
 void BulletPhysicsServer3D::body_set_param(RID p_body, BodyParameter p_param, real_t p_value) {
-	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
+	RigidBodyBullet *body = rigid_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_param(p_param, p_value);
 }
 
 real_t BulletPhysicsServer3D::body_get_param(RID p_body, BodyParameter p_param) const {
-	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
+	RigidBodyBullet *body = rigid_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, 0);
 
 	return body->get_param(p_param);
 }
 
 void BulletPhysicsServer3D::body_set_kinematic_safe_margin(RID p_body, real_t p_margin) {
-	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
+	RigidBodyBullet *body = rigid_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	if (body->get_kinematic_utilities()) {
@@ -643,7 +643,7 @@ void BulletPhysicsServer3D::body_set_kinematic_safe_margin(RID p_body, real_t p_
 }
 
 real_t BulletPhysicsServer3D::body_get_kinematic_safe_margin(RID p_body) const {
-	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
+	RigidBodyBullet *body = rigid_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, 0);
 
 	if (body->get_kinematic_utilities()) {
@@ -654,90 +654,90 @@ real_t BulletPhysicsServer3D::body_get_kinematic_safe_margin(RID p_body) const {
 }
 
 void BulletPhysicsServer3D::body_set_state(RID p_body, BodyState p_state, const Variant &p_variant) {
-	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
+	RigidBodyBullet *body = rigid_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_state(p_state, p_variant);
 }
 
 Variant BulletPhysicsServer3D::body_get_state(RID p_body, BodyState p_state) const {
-	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
+	RigidBodyBullet *body = rigid_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, Variant());
 
 	return body->get_state(p_state);
 }
 
 void BulletPhysicsServer3D::body_set_applied_force(RID p_body, const Vector3 &p_force) {
-	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
+	RigidBodyBullet *body = rigid_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_applied_force(p_force);
 }
 
 Vector3 BulletPhysicsServer3D::body_get_applied_force(RID p_body) const {
-	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
+	RigidBodyBullet *body = rigid_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, Vector3());
 	return body->get_applied_force();
 }
 
 void BulletPhysicsServer3D::body_set_applied_torque(RID p_body, const Vector3 &p_torque) {
-	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
+	RigidBodyBullet *body = rigid_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_applied_torque(p_torque);
 }
 
 Vector3 BulletPhysicsServer3D::body_get_applied_torque(RID p_body) const {
-	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
+	RigidBodyBullet *body = rigid_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, Vector3());
 
 	return body->get_applied_torque();
 }
 
 void BulletPhysicsServer3D::body_add_central_force(RID p_body, const Vector3 &p_force) {
-	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
+	RigidBodyBullet *body = rigid_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->apply_central_force(p_force);
 }
 
 void BulletPhysicsServer3D::body_add_force(RID p_body, const Vector3 &p_force, const Vector3 &p_position) {
-	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
+	RigidBodyBullet *body = rigid_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->apply_force(p_force, p_position);
 }
 
 void BulletPhysicsServer3D::body_add_torque(RID p_body, const Vector3 &p_torque) {
-	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
+	RigidBodyBullet *body = rigid_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->apply_torque(p_torque);
 }
 
 void BulletPhysicsServer3D::body_apply_central_impulse(RID p_body, const Vector3 &p_impulse) {
-	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
+	RigidBodyBullet *body = rigid_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->apply_central_impulse(p_impulse);
 }
 
 void BulletPhysicsServer3D::body_apply_impulse(RID p_body, const Vector3 &p_impulse, const Vector3 &p_position) {
-	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
+	RigidBodyBullet *body = rigid_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->apply_impulse(p_impulse, p_position);
 }
 
 void BulletPhysicsServer3D::body_apply_torque_impulse(RID p_body, const Vector3 &p_impulse) {
-	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
+	RigidBodyBullet *body = rigid_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->apply_torque_impulse(p_impulse);
 }
 
 void BulletPhysicsServer3D::body_set_axis_velocity(RID p_body, const Vector3 &p_axis_velocity) {
-	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
+	RigidBodyBullet *body = rigid_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	Vector3 v = body->get_linear_velocity();
@@ -748,39 +748,39 @@ void BulletPhysicsServer3D::body_set_axis_velocity(RID p_body, const Vector3 &p_
 }
 
 void BulletPhysicsServer3D::body_set_axis_lock(RID p_body, BodyAxis p_axis, bool p_lock) {
-	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
+	RigidBodyBullet *body = rigid_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 	body->set_axis_lock(p_axis, p_lock);
 }
 
 bool BulletPhysicsServer3D::body_is_axis_locked(RID p_body, BodyAxis p_axis) const {
-	const RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
+	const RigidBodyBullet *body = rigid_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, 0);
 	return body->is_axis_locked(p_axis);
 }
 
 void BulletPhysicsServer3D::body_add_collision_exception(RID p_body, RID p_body_b) {
-	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
+	RigidBodyBullet *body = rigid_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
-	RigidBodyBullet *other_body = rigid_body_owner.getornull(p_body_b);
+	RigidBodyBullet *other_body = rigid_body_owner.get_or_null(p_body_b);
 	ERR_FAIL_COND(!other_body);
 
 	body->add_collision_exception(other_body);
 }
 
 void BulletPhysicsServer3D::body_remove_collision_exception(RID p_body, RID p_body_b) {
-	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
+	RigidBodyBullet *body = rigid_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
-	RigidBodyBullet *other_body = rigid_body_owner.getornull(p_body_b);
+	RigidBodyBullet *other_body = rigid_body_owner.get_or_null(p_body_b);
 	ERR_FAIL_COND(!other_body);
 
 	body->remove_collision_exception(other_body);
 }
 
 void BulletPhysicsServer3D::body_get_collision_exceptions(RID p_body, List<RID> *p_exceptions) {
-	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
+	RigidBodyBullet *body = rigid_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 	for (int i = 0; i < body->get_exceptions().size(); i++) {
 		p_exceptions->push_back(body->get_exceptions()[i]);
@@ -788,14 +788,14 @@ void BulletPhysicsServer3D::body_get_collision_exceptions(RID p_body, List<RID>
 }
 
 void BulletPhysicsServer3D::body_set_max_contacts_reported(RID p_body, int p_contacts) {
-	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
+	RigidBodyBullet *body = rigid_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_max_collisions_detection(p_contacts);
 }
 
 int BulletPhysicsServer3D::body_get_max_contacts_reported(RID p_body) const {
-	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
+	RigidBodyBullet *body = rigid_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, 0);
 
 	return body->get_max_collisions_detection();
@@ -811,39 +811,39 @@ real_t BulletPhysicsServer3D::body_get_contacts_reported_depth_threshold(RID p_b
 }
 
 void BulletPhysicsServer3D::body_set_omit_force_integration(RID p_body, bool p_omit) {
-	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
+	RigidBodyBullet *body = rigid_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_omit_forces_integration(p_omit);
 }
 
 bool BulletPhysicsServer3D::body_is_omitting_force_integration(RID p_body) const {
-	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
+	RigidBodyBullet *body = rigid_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, false);
 
 	return body->get_omit_forces_integration();
 }
 
 void BulletPhysicsServer3D::body_set_force_integration_callback(RID p_body, const Callable &p_callable, const Variant &p_udata) {
-	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
+	RigidBodyBullet *body = rigid_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 	body->set_force_integration_callback(p_callable, p_udata);
 }
 
 void BulletPhysicsServer3D::body_set_ray_pickable(RID p_body, bool p_enable) {
-	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
+	RigidBodyBullet *body = rigid_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 	body->set_ray_pickable(p_enable);
 }
 
 PhysicsDirectBodyState3D *BulletPhysicsServer3D::body_get_direct_state(RID p_body) {
-	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
+	RigidBodyBullet *body = rigid_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, nullptr);
 	return BulletPhysicsDirectBodyState3D::get_singleton(body);
 }
 
 bool BulletPhysicsServer3D::body_test_motion(RID p_body, const Transform3D &p_from, const Vector3 &p_motion, bool p_infinite_inertia, MotionResult *r_result, bool p_exclude_raycast_shapes, const Set<RID> &p_exclude) {
-	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
+	RigidBodyBullet *body = rigid_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, false);
 	ERR_FAIL_COND_V(!body->get_space(), false);
 
@@ -851,7 +851,7 @@ bool BulletPhysicsServer3D::body_test_motion(RID p_body, const Transform3D &p_fr
 }
 
 int BulletPhysicsServer3D::body_test_ray_separation(RID p_body, const Transform3D &p_transform, bool p_infinite_inertia, Vector3 &r_recover_motion, SeparationResult *r_results, int p_result_max, real_t p_margin) {
-	RigidBodyBullet *body = rigid_body_owner.getornull(p_body);
+	RigidBodyBullet *body = rigid_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, 0);
 	ERR_FAIL_COND_V(!body->get_space(), 0);
 
@@ -869,19 +869,19 @@ RID BulletPhysicsServer3D::soft_body_create(bool p_init_sleeping) {
 }
 
 void BulletPhysicsServer3D::soft_body_update_rendering_server(RID p_body, RenderingServerHandler *p_rendering_server_handler) {
-	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
+	SoftBodyBullet *body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->update_rendering_server(p_rendering_server_handler);
 }
 
 void BulletPhysicsServer3D::soft_body_set_space(RID p_body, RID p_space) {
-	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
+	SoftBodyBullet *body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 	SpaceBullet *space = nullptr;
 
 	if (p_space.is_valid()) {
-		space = space_owner.getornull(p_space);
+		space = space_owner.get_or_null(p_space);
 		ERR_FAIL_COND(!space);
 	}
 
@@ -893,7 +893,7 @@ void BulletPhysicsServer3D::soft_body_set_space(RID p_body, RID p_space) {
 }
 
 RID BulletPhysicsServer3D::soft_body_get_space(RID p_body) const {
-	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
+	SoftBodyBullet *body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, RID());
 
 	SpaceBullet *space = body->get_space();
@@ -904,7 +904,7 @@ RID BulletPhysicsServer3D::soft_body_get_space(RID p_body) const {
 }
 
 void BulletPhysicsServer3D::soft_body_set_mesh(RID p_body, const REF &p_mesh) {
-	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
+	SoftBodyBullet *body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_soft_mesh(p_mesh);
@@ -918,40 +918,40 @@ AABB BulletPhysicsServer::soft_body_get_bounds(RID p_body) const {
 }
 
 void BulletPhysicsServer3D::soft_body_set_collision_layer(RID p_body, uint32_t p_layer) {
-	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
+	SoftBodyBullet *body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_collision_layer(p_layer);
 }
 
 uint32_t BulletPhysicsServer3D::soft_body_get_collision_layer(RID p_body) const {
-	const SoftBodyBullet *body = soft_body_owner.getornull(p_body);
+	const SoftBodyBullet *body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, 0);
 
 	return body->get_collision_layer();
 }
 
 void BulletPhysicsServer3D::soft_body_set_collision_mask(RID p_body, uint32_t p_mask) {
-	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
+	SoftBodyBullet *body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_collision_mask(p_mask);
 }
 
 uint32_t BulletPhysicsServer3D::soft_body_get_collision_mask(RID p_body) const {
-	const SoftBodyBullet *body = soft_body_owner.getornull(p_body);
+	const SoftBodyBullet *body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, 0);
 
 	return body->get_collision_mask();
 }
 
 void BulletPhysicsServer3D::soft_body_add_collision_exception(RID p_body, RID p_body_b) {
-	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
+	SoftBodyBullet *body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
-	CollisionObjectBullet *other_body = rigid_body_owner.getornull(p_body_b);
+	CollisionObjectBullet *other_body = rigid_body_owner.get_or_null(p_body_b);
 	if (!other_body) {
-		other_body = soft_body_owner.getornull(p_body_b);
+		other_body = soft_body_owner.get_or_null(p_body_b);
 	}
 	ERR_FAIL_COND(!other_body);
 
@@ -959,12 +959,12 @@ void BulletPhysicsServer3D::soft_body_add_collision_exception(RID p_body, RID p_
 }
 
 void BulletPhysicsServer3D::soft_body_remove_collision_exception(RID p_body, RID p_body_b) {
-	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
+	SoftBodyBullet *body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
-	CollisionObjectBullet *other_body = rigid_body_owner.getornull(p_body_b);
+	CollisionObjectBullet *other_body = rigid_body_owner.get_or_null(p_body_b);
 	if (!other_body) {
-		other_body = soft_body_owner.getornull(p_body_b);
+		other_body = soft_body_owner.get_or_null(p_body_b);
 	}
 	ERR_FAIL_COND(!other_body);
 
@@ -972,7 +972,7 @@ void BulletPhysicsServer3D::soft_body_remove_collision_exception(RID p_body, RID
 }
 
 void BulletPhysicsServer3D::soft_body_get_collision_exceptions(RID p_body, List<RID> *p_exceptions) {
-	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
+	SoftBodyBullet *body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 	for (int i = 0; i < body->get_exceptions().size(); i++) {
 		p_exceptions->push_back(body->get_exceptions()[i]);
@@ -991,98 +991,98 @@ Variant BulletPhysicsServer3D::soft_body_get_state(RID p_body, BodyState p_state
 }
 
 void BulletPhysicsServer3D::soft_body_set_transform(RID p_body, const Transform3D &p_transform) {
-	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
+	SoftBodyBullet *body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_soft_transform(p_transform);
 }
 
 void BulletPhysicsServer3D::soft_body_set_ray_pickable(RID p_body, bool p_enable) {
-	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
+	SoftBodyBullet *body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 	body->set_ray_pickable(p_enable);
 }
 
 void BulletPhysicsServer3D::soft_body_set_simulation_precision(RID p_body, int p_simulation_precision) {
-	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
+	SoftBodyBullet *body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 	body->set_simulation_precision(p_simulation_precision);
 }
 
 int BulletPhysicsServer3D::soft_body_get_simulation_precision(RID p_body) const {
-	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
+	SoftBodyBullet *body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, 0.f);
 	return body->get_simulation_precision();
 }
 
 void BulletPhysicsServer3D::soft_body_set_total_mass(RID p_body, real_t p_total_mass) {
-	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
+	SoftBodyBullet *body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 	body->set_total_mass(p_total_mass);
 }
 
 real_t BulletPhysicsServer3D::soft_body_get_total_mass(RID p_body) const {
-	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
+	SoftBodyBullet *body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, 0.f);
 	return body->get_total_mass();
 }
 
 void BulletPhysicsServer3D::soft_body_set_linear_stiffness(RID p_body, real_t p_stiffness) const {
-	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
+	SoftBodyBullet *body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 	body->set_linear_stiffness(p_stiffness);
 }
 
 real_t BulletPhysicsServer3D::soft_body_get_linear_stiffness(RID p_body) {
-	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
+	SoftBodyBullet *body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, 0.f);
 	return body->get_linear_stiffness();
 }
 
 void BulletPhysicsServer3D::soft_body_set_pressure_coefficient(RID p_body, real_t p_pressure_coefficient) {
-	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
+	SoftBodyBullet *body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 	body->set_pressure_coefficient(p_pressure_coefficient);
 }
 
 real_t BulletPhysicsServer3D::soft_body_get_pressure_coefficient(RID p_body) const {
-	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
+	SoftBodyBullet *body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, 0.f);
 	return body->get_pressure_coefficient();
 }
 
 void BulletPhysicsServer3D::soft_body_set_damping_coefficient(RID p_body, real_t p_damping_coefficient) {
-	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
+	SoftBodyBullet *body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 	body->set_damping_coefficient(p_damping_coefficient);
 }
 
 real_t BulletPhysicsServer3D::soft_body_get_damping_coefficient(RID p_body) const {
-	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
+	SoftBodyBullet *body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, 0.f);
 	return body->get_damping_coefficient();
 }
 
 void BulletPhysicsServer3D::soft_body_set_drag_coefficient(RID p_body, real_t p_drag_coefficient) {
-	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
+	SoftBodyBullet *body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 	body->set_drag_coefficient(p_drag_coefficient);
 }
 
 real_t BulletPhysicsServer3D::soft_body_get_drag_coefficient(RID p_body) const {
-	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
+	SoftBodyBullet *body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, 0.f);
 	return body->get_drag_coefficient();
 }
 
 void BulletPhysicsServer3D::soft_body_move_point(RID p_body, int p_point_index, const Vector3 &p_global_position) {
-	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
+	SoftBodyBullet *body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 	body->set_node_position(p_point_index, p_global_position);
 }
 
 Vector3 BulletPhysicsServer3D::soft_body_get_point_global_position(RID p_body, int p_point_index) const {
-	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
+	SoftBodyBullet *body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, Vector3(0., 0., 0.));
 	Vector3 pos;
 	body->get_node_position(p_point_index, pos);
@@ -1090,25 +1090,25 @@ Vector3 BulletPhysicsServer3D::soft_body_get_point_global_position(RID p_body, i
 }
 
 void BulletPhysicsServer3D::soft_body_remove_all_pinned_points(RID p_body) {
-	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
+	SoftBodyBullet *body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 	body->reset_all_node_mass();
 }
 
 void BulletPhysicsServer3D::soft_body_pin_point(RID p_body, int p_point_index, bool p_pin) {
-	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
+	SoftBodyBullet *body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 	body->set_node_mass(p_point_index, p_pin ? 0 : 1);
 }
 
 bool BulletPhysicsServer3D::soft_body_is_point_pinned(RID p_body, int p_point_index) const {
-	SoftBodyBullet *body = soft_body_owner.getornull(p_body);
+	SoftBodyBullet *body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, 0.f);
 	return body->get_node_mass(p_point_index);
 }
 
 PhysicsServer3D::JointType BulletPhysicsServer3D::joint_get_type(RID p_joint) const {
-	JointBullet *joint = joint_owner.getornull(p_joint);
+	JointBullet *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND_V(!joint, JOINT_PIN);
 	return joint->get_type();
 }
@@ -1123,28 +1123,28 @@ int BulletPhysicsServer3D::joint_get_solver_priority(RID p_joint) const {
 }
 
 void BulletPhysicsServer3D::joint_disable_collisions_between_bodies(RID p_joint, const bool p_disable) {
-	JointBullet *joint = joint_owner.getornull(p_joint);
+	JointBullet *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND(!joint);
 
 	joint->disable_collisions_between_bodies(p_disable);
 }
 
 bool BulletPhysicsServer3D::joint_is_disabled_collisions_between_bodies(RID p_joint) const {
-	JointBullet *joint(joint_owner.getornull(p_joint));
+	JointBullet *joint(joint_owner.get_or_null(p_joint));
 	ERR_FAIL_COND_V(!joint, false);
 
 	return joint->is_disabled_collisions_between_bodies();
 }
 
 RID BulletPhysicsServer3D::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.getornull(p_body_A);
+	RigidBodyBullet *body_A = rigid_body_owner.get_or_null(p_body_A);
 	ERR_FAIL_COND_V(!body_A, RID());
 
 	JointAssertSpace(body_A, "A", RID());
 
 	RigidBodyBullet *body_B = nullptr;
 	if (p_body_B.is_valid()) {
-		body_B = rigid_body_owner.getornull(p_body_B);
+		body_B = rigid_body_owner.get_or_null(p_body_B);
 		JointAssertSpace(body_B, "B", RID());
 		JointAssertSameSpace(body_A, body_B, RID());
 	}
@@ -1158,7 +1158,7 @@ RID BulletPhysicsServer3D::joint_create_pin(RID p_body_A, const Vector3 &p_local
 }
 
 void BulletPhysicsServer3D::pin_joint_set_param(RID p_joint, PinJointParam p_param, real_t p_value) {
-	JointBullet *joint = joint_owner.getornull(p_joint);
+	JointBullet *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND(!joint);
 	ERR_FAIL_COND(joint->get_type() != JOINT_PIN);
 	PinJointBullet *pin_joint = static_cast<PinJointBullet *>(joint);
@@ -1166,7 +1166,7 @@ void BulletPhysicsServer3D::pin_joint_set_param(RID p_joint, PinJointParam p_par
 }
 
 real_t BulletPhysicsServer3D::pin_joint_get_param(RID p_joint, PinJointParam p_param) const {
-	JointBullet *joint = joint_owner.getornull(p_joint);
+	JointBullet *joint = joint_owner.get_or_null(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);
@@ -1174,7 +1174,7 @@ real_t BulletPhysicsServer3D::pin_joint_get_param(RID p_joint, PinJointParam p_p
 }
 
 void BulletPhysicsServer3D::pin_joint_set_local_a(RID p_joint, const Vector3 &p_A) {
-	JointBullet *joint = joint_owner.getornull(p_joint);
+	JointBullet *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND(!joint);
 	ERR_FAIL_COND(joint->get_type() != JOINT_PIN);
 	PinJointBullet *pin_joint = static_cast<PinJointBullet *>(joint);
@@ -1182,7 +1182,7 @@ void BulletPhysicsServer3D::pin_joint_set_local_a(RID p_joint, const Vector3 &p_
 }
 
 Vector3 BulletPhysicsServer3D::pin_joint_get_local_a(RID p_joint) const {
-	JointBullet *joint = joint_owner.getornull(p_joint);
+	JointBullet *joint = joint_owner.get_or_null(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);
@@ -1190,7 +1190,7 @@ Vector3 BulletPhysicsServer3D::pin_joint_get_local_a(RID p_joint) const {
 }
 
 void BulletPhysicsServer3D::pin_joint_set_local_b(RID p_joint, const Vector3 &p_B) {
-	JointBullet *joint = joint_owner.getornull(p_joint);
+	JointBullet *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND(!joint);
 	ERR_FAIL_COND(joint->get_type() != JOINT_PIN);
 	PinJointBullet *pin_joint = static_cast<PinJointBullet *>(joint);
@@ -1198,7 +1198,7 @@ void BulletPhysicsServer3D::pin_joint_set_local_b(RID p_joint, const Vector3 &p_
 }
 
 Vector3 BulletPhysicsServer3D::pin_joint_get_local_b(RID p_joint) const {
-	JointBullet *joint = joint_owner.getornull(p_joint);
+	JointBullet *joint = joint_owner.get_or_null(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);
@@ -1206,13 +1206,13 @@ Vector3 BulletPhysicsServer3D::pin_joint_get_local_b(RID p_joint) const {
 }
 
 RID BulletPhysicsServer3D::joint_create_hinge(RID p_body_A, const Transform3D &p_hinge_A, RID p_body_B, const Transform3D &p_hinge_B) {
-	RigidBodyBullet *body_A = rigid_body_owner.getornull(p_body_A);
+	RigidBodyBullet *body_A = rigid_body_owner.get_or_null(p_body_A);
 	ERR_FAIL_COND_V(!body_A, RID());
 	JointAssertSpace(body_A, "A", RID());
 
 	RigidBodyBullet *body_B = nullptr;
 	if (p_body_B.is_valid()) {
-		body_B = rigid_body_owner.getornull(p_body_B);
+		body_B = rigid_body_owner.get_or_null(p_body_B);
 		JointAssertSpace(body_B, "B", RID());
 		JointAssertSameSpace(body_A, body_B, RID());
 	}
@@ -1226,13 +1226,13 @@ RID BulletPhysicsServer3D::joint_create_hinge(RID p_body_A, const Transform3D &p
 }
 
 RID BulletPhysicsServer3D::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.getornull(p_body_A);
+	RigidBodyBullet *body_A = rigid_body_owner.get_or_null(p_body_A);
 	ERR_FAIL_COND_V(!body_A, RID());
 	JointAssertSpace(body_A, "A", RID());
 
 	RigidBodyBullet *body_B = nullptr;
 	if (p_body_B.is_valid()) {
-		body_B = rigid_body_owner.getornull(p_body_B);
+		body_B = rigid_body_owner.get_or_null(p_body_B);
 		JointAssertSpace(body_B, "B", RID());
 		JointAssertSameSpace(body_A, body_B, RID());
 	}
@@ -1246,7 +1246,7 @@ RID BulletPhysicsServer3D::joint_create_hinge_simple(RID p_body_A, const Vector3
 }
 
 void BulletPhysicsServer3D::hinge_joint_set_param(RID p_joint, HingeJointParam p_param, real_t p_value) {
-	JointBullet *joint = joint_owner.getornull(p_joint);
+	JointBullet *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND(!joint);
 	ERR_FAIL_COND(joint->get_type() != JOINT_HINGE);
 	HingeJointBullet *hinge_joint = static_cast<HingeJointBullet *>(joint);
@@ -1254,7 +1254,7 @@ void BulletPhysicsServer3D::hinge_joint_set_param(RID p_joint, HingeJointParam p
 }
 
 real_t BulletPhysicsServer3D::hinge_joint_get_param(RID p_joint, HingeJointParam p_param) const {
-	JointBullet *joint = joint_owner.getornull(p_joint);
+	JointBullet *joint = joint_owner.get_or_null(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);
@@ -1262,7 +1262,7 @@ real_t BulletPhysicsServer3D::hinge_joint_get_param(RID p_joint, HingeJointParam
 }
 
 void BulletPhysicsServer3D::hinge_joint_set_flag(RID p_joint, HingeJointFlag p_flag, bool p_value) {
-	JointBullet *joint = joint_owner.getornull(p_joint);
+	JointBullet *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND(!joint);
 	ERR_FAIL_COND(joint->get_type() != JOINT_HINGE);
 	HingeJointBullet *hinge_joint = static_cast<HingeJointBullet *>(joint);
@@ -1270,7 +1270,7 @@ void BulletPhysicsServer3D::hinge_joint_set_flag(RID p_joint, HingeJointFlag p_f
 }
 
 bool BulletPhysicsServer3D::hinge_joint_get_flag(RID p_joint, HingeJointFlag p_flag) const {
-	JointBullet *joint = joint_owner.getornull(p_joint);
+	JointBullet *joint = joint_owner.get_or_null(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);
@@ -1278,13 +1278,13 @@ bool BulletPhysicsServer3D::hinge_joint_get_flag(RID p_joint, HingeJointFlag p_f
 }
 
 RID BulletPhysicsServer3D::joint_create_slider(RID p_body_A, const Transform3D &p_local_frame_A, RID p_body_B, const Transform3D &p_local_frame_B) {
-	RigidBodyBullet *body_A = rigid_body_owner.getornull(p_body_A);
+	RigidBodyBullet *body_A = rigid_body_owner.get_or_null(p_body_A);
 	ERR_FAIL_COND_V(!body_A, RID());
 	JointAssertSpace(body_A, "A", RID());
 
 	RigidBodyBullet *body_B = nullptr;
 	if (p_body_B.is_valid()) {
-		body_B = rigid_body_owner.getornull(p_body_B);
+		body_B = rigid_body_owner.get_or_null(p_body_B);
 		JointAssertSpace(body_B, "B", RID());
 		JointAssertSameSpace(body_A, body_B, RID());
 	}
@@ -1298,7 +1298,7 @@ RID BulletPhysicsServer3D::joint_create_slider(RID p_body_A, const Transform3D &
 }
 
 void BulletPhysicsServer3D::slider_joint_set_param(RID p_joint, SliderJointParam p_param, real_t p_value) {
-	JointBullet *joint = joint_owner.getornull(p_joint);
+	JointBullet *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND(!joint);
 	ERR_FAIL_COND(joint->get_type() != JOINT_SLIDER);
 	SliderJointBullet *slider_joint = static_cast<SliderJointBullet *>(joint);
@@ -1306,7 +1306,7 @@ void BulletPhysicsServer3D::slider_joint_set_param(RID p_joint, SliderJointParam
 }
 
 real_t BulletPhysicsServer3D::slider_joint_get_param(RID p_joint, SliderJointParam p_param) const {
-	JointBullet *joint = joint_owner.getornull(p_joint);
+	JointBullet *joint = joint_owner.get_or_null(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);
@@ -1314,13 +1314,13 @@ real_t BulletPhysicsServer3D::slider_joint_get_param(RID p_joint, SliderJointPar
 }
 
 RID BulletPhysicsServer3D::joint_create_cone_twist(RID p_body_A, const Transform3D &p_local_frame_A, RID p_body_B, const Transform3D &p_local_frame_B) {
-	RigidBodyBullet *body_A = rigid_body_owner.getornull(p_body_A);
+	RigidBodyBullet *body_A = rigid_body_owner.get_or_null(p_body_A);
 	ERR_FAIL_COND_V(!body_A, RID());
 	JointAssertSpace(body_A, "A", RID());
 
 	RigidBodyBullet *body_B = nullptr;
 	if (p_body_B.is_valid()) {
-		body_B = rigid_body_owner.getornull(p_body_B);
+		body_B = rigid_body_owner.get_or_null(p_body_B);
 		JointAssertSpace(body_B, "B", RID());
 		JointAssertSameSpace(body_A, body_B, RID());
 	}
@@ -1332,7 +1332,7 @@ RID BulletPhysicsServer3D::joint_create_cone_twist(RID p_body_A, const Transform
 }
 
 void BulletPhysicsServer3D::cone_twist_joint_set_param(RID p_joint, ConeTwistJointParam p_param, real_t p_value) {
-	JointBullet *joint = joint_owner.getornull(p_joint);
+	JointBullet *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND(!joint);
 	ERR_FAIL_COND(joint->get_type() != JOINT_CONE_TWIST);
 	ConeTwistJointBullet *coneTwist_joint = static_cast<ConeTwistJointBullet *>(joint);
@@ -1340,7 +1340,7 @@ void BulletPhysicsServer3D::cone_twist_joint_set_param(RID p_joint, ConeTwistJoi
 }
 
 real_t BulletPhysicsServer3D::cone_twist_joint_get_param(RID p_joint, ConeTwistJointParam p_param) const {
-	JointBullet *joint = joint_owner.getornull(p_joint);
+	JointBullet *joint = joint_owner.get_or_null(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);
@@ -1348,13 +1348,13 @@ real_t BulletPhysicsServer3D::cone_twist_joint_get_param(RID p_joint, ConeTwistJ
 }
 
 RID BulletPhysicsServer3D::joint_create_generic_6dof(RID p_body_A, const Transform3D &p_local_frame_A, RID p_body_B, const Transform3D &p_local_frame_B) {
-	RigidBodyBullet *body_A = rigid_body_owner.getornull(p_body_A);
+	RigidBodyBullet *body_A = rigid_body_owner.get_or_null(p_body_A);
 	ERR_FAIL_COND_V(!body_A, RID());
 	JointAssertSpace(body_A, "A", RID());
 
 	RigidBodyBullet *body_B = nullptr;
 	if (p_body_B.is_valid()) {
-		body_B = rigid_body_owner.getornull(p_body_B);
+		body_B = rigid_body_owner.get_or_null(p_body_B);
 		JointAssertSpace(body_B, "B", RID());
 		JointAssertSameSpace(body_A, body_B, RID());
 	}
@@ -1368,7 +1368,7 @@ RID BulletPhysicsServer3D::joint_create_generic_6dof(RID p_body_A, const Transfo
 }
 
 void BulletPhysicsServer3D::generic_6dof_joint_set_param(RID p_joint, Vector3::Axis p_axis, G6DOFJointAxisParam p_param, real_t p_value) {
-	JointBullet *joint = joint_owner.getornull(p_joint);
+	JointBullet *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND(!joint);
 	ERR_FAIL_COND(joint->get_type() != JOINT_6DOF);
 	Generic6DOFJointBullet *generic_6dof_joint = static_cast<Generic6DOFJointBullet *>(joint);
@@ -1376,7 +1376,7 @@ void BulletPhysicsServer3D::generic_6dof_joint_set_param(RID p_joint, Vector3::A
 }
 
 real_t BulletPhysicsServer3D::generic_6dof_joint_get_param(RID p_joint, Vector3::Axis p_axis, G6DOFJointAxisParam p_param) {
-	JointBullet *joint = joint_owner.getornull(p_joint);
+	JointBullet *joint = joint_owner.get_or_null(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);
@@ -1384,7 +1384,7 @@ real_t BulletPhysicsServer3D::generic_6dof_joint_get_param(RID p_joint, Vector3:
 }
 
 void BulletPhysicsServer3D::generic_6dof_joint_set_flag(RID p_joint, Vector3::Axis p_axis, G6DOFJointAxisFlag p_flag, bool p_enable) {
-	JointBullet *joint = joint_owner.getornull(p_joint);
+	JointBullet *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND(!joint);
 	ERR_FAIL_COND(joint->get_type() != JOINT_6DOF);
 	Generic6DOFJointBullet *generic_6dof_joint = static_cast<Generic6DOFJointBullet *>(joint);
@@ -1392,7 +1392,7 @@ void BulletPhysicsServer3D::generic_6dof_joint_set_flag(RID p_joint, Vector3::Ax
 }
 
 bool BulletPhysicsServer3D::generic_6dof_joint_get_flag(RID p_joint, Vector3::Axis p_axis, G6DOFJointAxisFlag p_flag) {
-	JointBullet *joint = joint_owner.getornull(p_joint);
+	JointBullet *joint = joint_owner.get_or_null(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);
@@ -1401,7 +1401,7 @@ bool BulletPhysicsServer3D::generic_6dof_joint_get_flag(RID p_joint, Vector3::Ax
 
 void BulletPhysicsServer3D::free(RID p_rid) {
 	if (shape_owner.owns(p_rid)) {
-		ShapeBullet *shape = shape_owner.getornull(p_rid);
+		ShapeBullet *shape = shape_owner.get_or_null(p_rid);
 
 		// Notify the shape is configured
 		for (Map<ShapeOwnerBullet *, int>::Element *element = shape->get_owners().front(); element; element = element->next()) {
@@ -1411,7 +1411,7 @@ void BulletPhysicsServer3D::free(RID p_rid) {
 		shape_owner.free(p_rid);
 		bulletdelete(shape);
 	} else if (rigid_body_owner.owns(p_rid)) {
-		RigidBodyBullet *body = rigid_body_owner.getornull(p_rid);
+		RigidBodyBullet *body = rigid_body_owner.get_or_null(p_rid);
 
 		body->set_space(nullptr);
 
@@ -1421,7 +1421,7 @@ void BulletPhysicsServer3D::free(RID p_rid) {
 		bulletdelete(body);
 
 	} else if (soft_body_owner.owns(p_rid)) {
-		SoftBodyBullet *body = soft_body_owner.getornull(p_rid);
+		SoftBodyBullet *body = soft_body_owner.get_or_null(p_rid);
 
 		body->set_space(nullptr);
 
@@ -1429,7 +1429,7 @@ void BulletPhysicsServer3D::free(RID p_rid) {
 		bulletdelete(body);
 
 	} else if (area_owner.owns(p_rid)) {
-		AreaBullet *area = area_owner.getornull(p_rid);
+		AreaBullet *area = area_owner.get_or_null(p_rid);
 
 		area->set_space(nullptr);
 
@@ -1439,13 +1439,13 @@ void BulletPhysicsServer3D::free(RID p_rid) {
 		bulletdelete(area);
 
 	} else if (joint_owner.owns(p_rid)) {
-		JointBullet *joint = joint_owner.getornull(p_rid);
+		JointBullet *joint = joint_owner.get_or_null(p_rid);
 		joint->destroy_internal_constraint();
 		joint_owner.free(p_rid);
 		bulletdelete(joint);
 
 	} else if (space_owner.owns(p_rid)) {
-		SpaceBullet *space = space_owner.getornull(p_rid);
+		SpaceBullet *space = space_owner.get_or_null(p_rid);
 
 		space->remove_all_collision_objects();
 
@@ -1493,38 +1493,38 @@ int BulletPhysicsServer3D::get_process_info(ProcessInfo p_info) {
 
 SpaceBullet *BulletPhysicsServer3D::get_space(RID p_rid) const {
 	ERR_FAIL_COND_V_MSG(space_owner.owns(p_rid) == false, nullptr, "The RID is not valid.");
-	return space_owner.getornull(p_rid);
+	return space_owner.get_or_null(p_rid);
 }
 
 ShapeBullet *BulletPhysicsServer3D::get_shape(RID p_rid) const {
 	ERR_FAIL_COND_V_MSG(shape_owner.owns(p_rid) == false, nullptr, "The RID is not valid.");
-	return shape_owner.getornull(p_rid);
+	return shape_owner.get_or_null(p_rid);
 }
 
 CollisionObjectBullet *BulletPhysicsServer3D::get_collision_object(RID p_object) const {
 	if (rigid_body_owner.owns(p_object)) {
-		return rigid_body_owner.getornull(p_object);
+		return rigid_body_owner.get_or_null(p_object);
 	}
 	if (area_owner.owns(p_object)) {
-		return area_owner.getornull(p_object);
+		return area_owner.get_or_null(p_object);
 	}
 	if (soft_body_owner.owns(p_object)) {
-		return soft_body_owner.getornull(p_object);
+		return soft_body_owner.get_or_null(p_object);
 	}
 	ERR_FAIL_V_MSG(nullptr, "The RID is no valid.");
 }
 
 RigidCollisionObjectBullet *BulletPhysicsServer3D::get_rigid_collision_object(RID p_object) const {
 	if (rigid_body_owner.owns(p_object)) {
-		return rigid_body_owner.getornull(p_object);
+		return rigid_body_owner.get_or_null(p_object);
 	}
 	if (area_owner.owns(p_object)) {
-		return area_owner.getornull(p_object);
+		return area_owner.get_or_null(p_object);
 	}
 	ERR_FAIL_V_MSG(nullptr, "The RID is no valid.");
 }
 
 JointBullet *BulletPhysicsServer3D::get_joint(RID p_rid) const {
 	ERR_FAIL_COND_V_MSG(joint_owner.owns(p_rid) == false, nullptr, "The RID is not valid.");
-	return joint_owner.getornull(p_rid);
+	return joint_owner.get_or_null(p_rid);
 }
diff --git a/modules/bullet/space_bullet.cpp b/modules/bullet/space_bullet.cpp
index 0cfd658bd5..66d7370bd7 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
 		return 0;
 	}
 
-	ShapeBullet *shape = space->get_physics_server()->get_shape_owner()->getornull(p_shape);
+	ShapeBullet *shape = space->get_physics_server()->get_shape_owner()->get_or_null(p_shape);
 	ERR_FAIL_COND_V(!shape, 0);
 
 	btCollisionShape *btShape = shape->create_bt_shape(p_xform.basis.get_scale_abs(), p_margin);
@@ -158,7 +158,7 @@ bool BulletPhysicsDirectSpaceState::cast_motion(const RID &p_shape, const Transf
 	btVector3 bt_motion;
 	G_TO_B(p_motion, bt_motion);
 
-	ShapeBullet *shape = space->get_physics_server()->get_shape_owner()->getornull(p_shape);
+	ShapeBullet *shape = space->get_physics_server()->get_shape_owner()->get_or_null(p_shape);
 	ERR_FAIL_COND_V(!shape, false);
 
 	btCollisionShape *btShape = shape->create_bt_shape(p_xform.basis.get_scale(), p_margin);
@@ -219,7 +219,7 @@ bool BulletPhysicsDirectSpaceState::collide_shape(RID p_shape, const Transform3D
 		return false;
 	}
 
-	ShapeBullet *shape = space->get_physics_server()->get_shape_owner()->getornull(p_shape);
+	ShapeBullet *shape = space->get_physics_server()->get_shape_owner()->get_or_null(p_shape);
 	ERR_FAIL_COND_V(!shape, false);
 
 	btCollisionShape *btShape = shape->create_bt_shape(p_shape_xform.basis.get_scale_abs(), p_margin);
@@ -251,7 +251,7 @@ bool BulletPhysicsDirectSpaceState::collide_shape(RID p_shape, const Transform3D
 }
 
 bool BulletPhysicsDirectSpaceState::rest_info(RID p_shape, const Transform3D &p_shape_xform, real_t 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()->getornull(p_shape);
+	ShapeBullet *shape = space->get_physics_server()->get_shape_owner()->get_or_null(p_shape);
 	ERR_FAIL_COND_V(!shape, false);
 
 	btCollisionShape *btShape = shape->create_bt_shape(p_shape_xform.basis.get_scale_abs(), p_margin);
diff --git a/modules/navigation/godot_navigation_server.cpp b/modules/navigation/godot_navigation_server.cpp
index fd965674d6..f600f07c87 100644
--- a/modules/navigation/godot_navigation_server.cpp
+++ b/modules/navigation/godot_navigation_server.cpp
@@ -133,13 +133,13 @@ RID GodotNavigationServer::map_create() const {
 	GodotNavigationServer *mut_this = const_cast<GodotNavigationServer *>(this);
 	MutexLock lock(mut_this->operations_mutex);
 	RID rid = map_owner.make_rid();
-	NavMap *space = map_owner.getornull(rid);
+	NavMap *space = map_owner.get_or_null(rid);
 	space->set_self(rid);
 	return rid;
 }
 
 COMMAND_2(map_set_active, RID, p_map, bool, p_active) {
-	NavMap *map = map_owner.getornull(p_map);
+	NavMap *map = map_owner.get_or_null(p_map);
 	ERR_FAIL_COND(map == nullptr);
 
 	if (p_active) {
@@ -156,84 +156,84 @@ COMMAND_2(map_set_active, RID, p_map, bool, p_active) {
 }
 
 bool GodotNavigationServer::map_is_active(RID p_map) const {
-	NavMap *map = map_owner.getornull(p_map);
+	NavMap *map = map_owner.get_or_null(p_map);
 	ERR_FAIL_COND_V(map == nullptr, false);
 
 	return active_maps.find(map) >= 0;
 }
 
 COMMAND_2(map_set_up, RID, p_map, Vector3, p_up) {
-	NavMap *map = map_owner.getornull(p_map);
+	NavMap *map = map_owner.get_or_null(p_map);
 	ERR_FAIL_COND(map == nullptr);
 
 	map->set_up(p_up);
 }
 
 Vector3 GodotNavigationServer::map_get_up(RID p_map) const {
-	const NavMap *map = map_owner.getornull(p_map);
+	const NavMap *map = map_owner.get_or_null(p_map);
 	ERR_FAIL_COND_V(map == nullptr, Vector3());
 
 	return map->get_up();
 }
 
 COMMAND_2(map_set_cell_size, RID, p_map, real_t, p_cell_size) {
-	NavMap *map = map_owner.getornull(p_map);
+	NavMap *map = map_owner.get_or_null(p_map);
 	ERR_FAIL_COND(map == nullptr);
 
 	map->set_cell_size(p_cell_size);
 }
 
 real_t GodotNavigationServer::map_get_cell_size(RID p_map) const {
-	const NavMap *map = map_owner.getornull(p_map);
+	const NavMap *map = map_owner.get_or_null(p_map);
 	ERR_FAIL_COND_V(map == nullptr, 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.getornull(p_map);
+	NavMap *map = map_owner.get_or_null(p_map);
 	ERR_FAIL_COND(map == nullptr);
 
 	map->set_edge_connection_margin(p_connection_margin);
 }
 
 real_t GodotNavigationServer::map_get_edge_connection_margin(RID p_map) const {
-	const NavMap *map = map_owner.getornull(p_map);
+	const NavMap *map = map_owner.get_or_null(p_map);
 	ERR_FAIL_COND_V(map == nullptr, 0);
 
 	return map->get_edge_connection_margin();
 }
 
 Vector<Vector3> GodotNavigationServer::map_get_path(RID p_map, Vector3 p_origin, Vector3 p_destination, bool p_optimize, uint32_t p_layers) const {
-	const NavMap *map = map_owner.getornull(p_map);
+	const NavMap *map = map_owner.get_or_null(p_map);
 	ERR_FAIL_COND_V(map == nullptr, Vector<Vector3>());
 
 	return map->get_path(p_origin, p_destination, p_optimize, p_layers);
 }
 
 Vector3 GodotNavigationServer::map_get_closest_point_to_segment(RID p_map, const Vector3 &p_from, const Vector3 &p_to, const bool p_use_collision) const {
-	const NavMap *map = map_owner.getornull(p_map);
+	const NavMap *map = map_owner.get_or_null(p_map);
 	ERR_FAIL_COND_V(map == nullptr, Vector3());
 
 	return map->get_closest_point_to_segment(p_from, p_to, p_use_collision);
 }
 
 Vector3 GodotNavigationServer::map_get_closest_point(RID p_map, const Vector3 &p_point) const {
-	const NavMap *map = map_owner.getornull(p_map);
+	const NavMap *map = map_owner.get_or_null(p_map);
 	ERR_FAIL_COND_V(map == nullptr, Vector3());
 
 	return map->get_closest_point(p_point);
 }
 
 Vector3 GodotNavigationServer::map_get_closest_point_normal(RID p_map, const Vector3 &p_point) const {
-	const NavMap *map = map_owner.getornull(p_map);
+	const NavMap *map = map_owner.get_or_null(p_map);
 	ERR_FAIL_COND_V(map == nullptr, Vector3());
 
 	return map->get_closest_point_normal(p_point);
 }
 
 RID GodotNavigationServer::map_get_closest_point_owner(RID p_map, const Vector3 &p_point) const {
-	const NavMap *map = map_owner.getornull(p_map);
+	const NavMap *map = map_owner.get_or_null(p_map);
 	ERR_FAIL_COND_V(map == nullptr, RID());
 
 	return map->get_closest_point_owner(p_point);
@@ -243,13 +243,13 @@ RID GodotNavigationServer::region_create() const {
 	GodotNavigationServer *mut_this = const_cast<GodotNavigationServer *>(this);
 	MutexLock lock(mut_this->operations_mutex);
 	RID rid = region_owner.make_rid();
-	NavRegion *reg = region_owner.getornull(rid);
+	NavRegion *reg = region_owner.get_or_null(rid);
 	reg->set_self(rid);
 	return rid;
 }
 
 COMMAND_2(region_set_map, RID, p_region, RID, p_map) {
-	NavRegion *region = region_owner.getornull(p_region);
+	NavRegion *region = region_owner.get_or_null(p_region);
 	ERR_FAIL_COND(region == nullptr);
 
 	if (region->get_map() != nullptr) {
@@ -262,7 +262,7 @@ COMMAND_2(region_set_map, RID, p_region, RID, p_map) {
 	}
 
 	if (p_map.is_valid()) {
-		NavMap *map = map_owner.getornull(p_map);
+		NavMap *map = map_owner.get_or_null(p_map);
 		ERR_FAIL_COND(map == nullptr);
 
 		map->add_region(region);
@@ -271,28 +271,28 @@ COMMAND_2(region_set_map, RID, p_region, RID, p_map) {
 }
 
 COMMAND_2(region_set_transform, RID, p_region, Transform3D, p_transform) {
-	NavRegion *region = region_owner.getornull(p_region);
+	NavRegion *region = region_owner.get_or_null(p_region);
 	ERR_FAIL_COND(region == nullptr);
 
 	region->set_transform(p_transform);
 }
 
 COMMAND_2(region_set_layers, RID, p_region, uint32_t, p_layers) {
-	NavRegion *region = region_owner.getornull(p_region);
+	NavRegion *region = region_owner.get_or_null(p_region);
 	ERR_FAIL_COND(region == nullptr);
 
 	region->set_layers(p_layers);
 }
 
 uint32_t GodotNavigationServer::region_get_layers(RID p_region) const {
-	NavRegion *region = region_owner.getornull(p_region);
+	NavRegion *region = region_owner.get_or_null(p_region);
 	ERR_FAIL_COND_V(region == nullptr, 0);
 
 	return region->get_layers();
 }
 
 COMMAND_2(region_set_navmesh, RID, p_region, Ref<NavigationMesh>, p_nav_mesh) {
-	NavRegion *region = region_owner.getornull(p_region);
+	NavRegion *region = region_owner.get_or_null(p_region);
 	ERR_FAIL_COND(region == nullptr);
 
 	region->set_mesh(p_nav_mesh);
@@ -309,21 +309,21 @@ void GodotNavigationServer::region_bake_navmesh(Ref<NavigationMesh> r_mesh, Node
 }
 
 int GodotNavigationServer::region_get_connections_count(RID p_region) const {
-	NavRegion *region = region_owner.getornull(p_region);
+	NavRegion *region = region_owner.get_or_null(p_region);
 	ERR_FAIL_COND_V(!region, 0);
 
 	return region->get_connections_count();
 }
 
 Vector3 GodotNavigationServer::region_get_connection_pathway_start(RID p_region, int p_connection_id) const {
-	NavRegion *region = region_owner.getornull(p_region);
+	NavRegion *region = region_owner.get_or_null(p_region);
 	ERR_FAIL_COND_V(!region, Vector3());
 
 	return region->get_connection_pathway_start(p_connection_id);
 }
 
 Vector3 GodotNavigationServer::region_get_connection_pathway_end(RID p_region, int p_connection_id) const {
-	NavRegion *region = region_owner.getornull(p_region);
+	NavRegion *region = region_owner.get_or_null(p_region);
 	ERR_FAIL_COND_V(!region, Vector3());
 
 	return region->get_connection_pathway_end(p_connection_id);
@@ -333,13 +333,13 @@ RID GodotNavigationServer::agent_create() const {
 	GodotNavigationServer *mut_this = const_cast<GodotNavigationServer *>(this);
 	MutexLock lock(mut_this->operations_mutex);
 	RID rid = agent_owner.make_rid();
-	RvoAgent *agent = agent_owner.getornull(rid);
+	RvoAgent *agent = agent_owner.get_or_null(rid);
 	agent->set_self(rid);
 	return rid;
 }
 
 COMMAND_2(agent_set_map, RID, p_agent, RID, p_map) {
-	RvoAgent *agent = agent_owner.getornull(p_agent);
+	RvoAgent *agent = agent_owner.get_or_null(p_agent);
 	ERR_FAIL_COND(agent == nullptr);
 
 	if (agent->get_map()) {
@@ -353,7 +353,7 @@ COMMAND_2(agent_set_map, RID, p_agent, RID, p_map) {
 	agent->set_map(nullptr);
 
 	if (p_map.is_valid()) {
-		NavMap *map = map_owner.getornull(p_map);
+		NavMap *map = map_owner.get_or_null(p_map);
 		ERR_FAIL_COND(map == nullptr);
 
 		agent->set_map(map);
@@ -366,77 +366,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.getornull(p_agent);
+	RvoAgent *agent = agent_owner.get_or_null(p_agent);
 	ERR_FAIL_COND(agent == nullptr);
 
 	agent->get_agent()->neighborDist_ = p_dist;
 }
 
 COMMAND_2(agent_set_max_neighbors, RID, p_agent, int, p_count) {
-	RvoAgent *agent = agent_owner.getornull(p_agent);
+	RvoAgent *agent = agent_owner.get_or_null(p_agent);
 	ERR_FAIL_COND(agent == nullptr);
 
 	agent->get_agent()->maxNeighbors_ = p_count;
 }
 
 COMMAND_2(agent_set_time_horizon, RID, p_agent, real_t, p_time) {
-	RvoAgent *agent = agent_owner.getornull(p_agent);
+	RvoAgent *agent = agent_owner.get_or_null(p_agent);
 	ERR_FAIL_COND(agent == nullptr);
 
 	agent->get_agent()->timeHorizon_ = p_time;
 }
 
 COMMAND_2(agent_set_radius, RID, p_agent, real_t, p_radius) {
-	RvoAgent *agent = agent_owner.getornull(p_agent);
+	RvoAgent *agent = agent_owner.get_or_null(p_agent);
 	ERR_FAIL_COND(agent == nullptr);
 
 	agent->get_agent()->radius_ = p_radius;
 }
 
 COMMAND_2(agent_set_max_speed, RID, p_agent, real_t, p_max_speed) {
-	RvoAgent *agent = agent_owner.getornull(p_agent);
+	RvoAgent *agent = agent_owner.get_or_null(p_agent);
 	ERR_FAIL_COND(agent == nullptr);
 
 	agent->get_agent()->maxSpeed_ = p_max_speed;
 }
 
 COMMAND_2(agent_set_velocity, RID, p_agent, Vector3, p_velocity) {
-	RvoAgent *agent = agent_owner.getornull(p_agent);
+	RvoAgent *agent = agent_owner.get_or_null(p_agent);
 	ERR_FAIL_COND(agent == nullptr);
 
 	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.getornull(p_agent);
+	RvoAgent *agent = agent_owner.get_or_null(p_agent);
 	ERR_FAIL_COND(agent == nullptr);
 
 	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.getornull(p_agent);
+	RvoAgent *agent = agent_owner.get_or_null(p_agent);
 	ERR_FAIL_COND(agent == nullptr);
 
 	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.getornull(p_agent);
+	RvoAgent *agent = agent_owner.get_or_null(p_agent);
 	ERR_FAIL_COND(agent == nullptr);
 
 	agent->get_agent()->ignore_y_ = p_ignore;
 }
 
 bool GodotNavigationServer::agent_is_map_changed(RID p_agent) const {
-	RvoAgent *agent = agent_owner.getornull(p_agent);
+	RvoAgent *agent = agent_owner.get_or_null(p_agent);
 	ERR_FAIL_COND_V(agent == nullptr, 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.getornull(p_agent);
+	RvoAgent *agent = agent_owner.get_or_null(p_agent);
 	ERR_FAIL_COND(agent == nullptr);
 
 	agent->set_callback(p_receiver == nullptr ? ObjectID() : p_receiver->get_instance_id(), p_method, p_udata);
@@ -452,7 +452,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.getornull(p_object);
+		NavMap *map = map_owner.get_or_null(p_object);
 
 		// Removes any assigned region
 		std::vector<NavRegion *> regions = map->get_regions();
@@ -474,7 +474,7 @@ COMMAND_1(free, RID, p_object) {
 		map_owner.free(p_object);
 
 	} else if (region_owner.owns(p_object)) {
-		NavRegion *region = region_owner.getornull(p_object);
+		NavRegion *region = region_owner.get_or_null(p_object);
 
 		// Removes this region from the map if assigned
 		if (region->get_map() != nullptr) {
@@ -485,7 +485,7 @@ COMMAND_1(free, RID, p_object) {
 		region_owner.free(p_object);
 
 	} else if (agent_owner.owns(p_object)) {
-		RvoAgent *agent = agent_owner.getornull(p_object);
+		RvoAgent *agent = agent_owner.get_or_null(p_object);
 
 		// Removes this agent from the map if assigned
 		if (agent->get_map() != nullptr) {
diff --git a/modules/raycast/raycast_occlusion_cull.cpp b/modules/raycast/raycast_occlusion_cull.cpp
index a55b81c05d..3975e83797 100644
--- a/modules/raycast/raycast_occlusion_cull.cpp
+++ b/modules/raycast/raycast_occlusion_cull.cpp
@@ -207,7 +207,7 @@ void RaycastOcclusionCull::occluder_initialize(RID p_occluder) {
 }
 
 void RaycastOcclusionCull::occluder_set_mesh(RID p_occluder, const PackedVector3Array &p_vertices, const PackedInt32Array &p_indices) {
-	Occluder *occluder = occluder_owner.getornull(p_occluder);
+	Occluder *occluder = occluder_owner.get_or_null(p_occluder);
 	ERR_FAIL_COND(!occluder);
 
 	occluder->vertices = p_vertices;
@@ -228,7 +228,7 @@ void RaycastOcclusionCull::occluder_set_mesh(RID p_occluder, const PackedVector3
 }
 
 void RaycastOcclusionCull::free_occluder(RID p_occluder) {
-	Occluder *occluder = occluder_owner.getornull(p_occluder);
+	Occluder *occluder = occluder_owner.get_or_null(p_occluder);
 	ERR_FAIL_COND(!occluder);
 	memdelete(occluder);
 	occluder_owner.free(p_occluder);
@@ -268,7 +268,7 @@ void RaycastOcclusionCull::scenario_set_instance(RID p_scenario, RID p_instance,
 	bool changed = false;
 
 	if (instance.occluder != p_occluder) {
-		Occluder *old_occluder = occluder_owner.getornull(instance.occluder);
+		Occluder *old_occluder = occluder_owner.get_or_null(instance.occluder);
 		if (old_occluder) {
 			old_occluder->users.erase(InstanceID(p_scenario, p_instance));
 		}
@@ -276,7 +276,7 @@ void RaycastOcclusionCull::scenario_set_instance(RID p_scenario, RID p_instance,
 		instance.occluder = p_occluder;
 
 		if (p_occluder.is_valid()) {
-			Occluder *occluder = occluder_owner.getornull(p_occluder);
+			Occluder *occluder = occluder_owner.get_or_null(p_occluder);
 			ERR_FAIL_COND(!occluder);
 			occluder->users.insert(InstanceID(p_scenario, p_instance));
 		}
@@ -308,7 +308,7 @@ void RaycastOcclusionCull::scenario_remove_instance(RID p_scenario, RID p_instan
 		OccluderInstance &instance = scenario.instances[p_instance];
 
 		if (!instance.removed) {
-			Occluder *occluder = occluder_owner.getornull(instance.occluder);
+			Occluder *occluder = occluder_owner.get_or_null(instance.occluder);
 			if (occluder) {
 				occluder->users.erase(InstanceID(p_scenario, p_instance));
 			}
@@ -330,7 +330,7 @@ void RaycastOcclusionCull::Scenario::_update_dirty_instance(int p_idx, RID *p_in
 		return;
 	}
 
-	Occluder *occ = raycast_singleton->occluder_owner.getornull(occ_inst->occluder);
+	Occluder *occ = raycast_singleton->occluder_owner.get_or_null(occ_inst->occluder);
 
 	if (!occ) {
 		return;
@@ -446,7 +446,7 @@ bool RaycastOcclusionCull::Scenario::update(ThreadWorkPool &p_thread_pool) {
 	const RID *inst_rid = nullptr;
 	while ((inst_rid = instances.next(inst_rid))) {
 		OccluderInstance *occ_inst = instances.getptr(*inst_rid);
-		Occluder *occ = raycast_singleton->occluder_owner.getornull(occ_inst->occluder);
+		Occluder *occ = raycast_singleton->occluder_owner.get_or_null(occ_inst->occluder);
 
 		if (!occ || !occ_inst->enabled) {
 			continue;
diff --git a/modules/text_server_adv/text_server_adv.cpp b/modules/text_server_adv/text_server_adv.cpp
index c93f353cea..acc447018d 100644
--- a/modules/text_server_adv/text_server_adv.cpp
+++ b/modules/text_server_adv/text_server_adv.cpp
@@ -333,11 +333,11 @@ String TextServerAdvanced::get_name() const {
 void TextServerAdvanced::free(RID p_rid) {
 	_THREAD_SAFE_METHOD_
 	if (font_owner.owns(p_rid)) {
-		FontDataAdvanced *fd = font_owner.getornull(p_rid);
+		FontDataAdvanced *fd = font_owner.get_or_null(p_rid);
 		font_owner.free(p_rid);
 		memdelete(fd);
 	} else if (shaped_owner.owns(p_rid)) {
-		ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_rid);
+		ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_rid);
 		shaped_owner.free(p_rid);
 		memdelete(sd);
 	}
@@ -1596,7 +1596,7 @@ _FORCE_INLINE_ void TextServerAdvanced::_font_clear_cache(FontDataAdvanced *p_fo
 }
 
 hb_font_t *TextServerAdvanced::_font_get_hb_handle(RID p_font_rid, int p_size) const {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, nullptr);
 
 	MutexLock lock(fd->mutex);
@@ -1614,7 +1614,7 @@ RID TextServerAdvanced::create_font() {
 }
 
 void TextServerAdvanced::font_set_data(RID p_font_rid, const PackedByteArray &p_data) {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -1625,7 +1625,7 @@ void TextServerAdvanced::font_set_data(RID p_font_rid, const PackedByteArray &p_
 }
 
 void TextServerAdvanced::font_set_data_ptr(RID p_font_rid, const uint8_t *p_data_ptr, size_t p_data_size) {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -1636,7 +1636,7 @@ void TextServerAdvanced::font_set_data_ptr(RID p_font_rid, const uint8_t *p_data
 }
 
 void TextServerAdvanced::font_set_antialiased(RID p_font_rid, bool p_antialiased) {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -1647,7 +1647,7 @@ void TextServerAdvanced::font_set_antialiased(RID p_font_rid, bool p_antialiased
 }
 
 bool TextServerAdvanced::font_is_antialiased(RID p_font_rid) const {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, false);
 
 	MutexLock lock(fd->mutex);
@@ -1655,7 +1655,7 @@ bool TextServerAdvanced::font_is_antialiased(RID p_font_rid) const {
 }
 
 void TextServerAdvanced::font_set_multichannel_signed_distance_field(RID p_font_rid, bool p_msdf) {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -1666,7 +1666,7 @@ void TextServerAdvanced::font_set_multichannel_signed_distance_field(RID p_font_
 }
 
 bool TextServerAdvanced::font_is_multichannel_signed_distance_field(RID p_font_rid) const {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, false);
 
 	MutexLock lock(fd->mutex);
@@ -1674,7 +1674,7 @@ bool TextServerAdvanced::font_is_multichannel_signed_distance_field(RID p_font_r
 }
 
 void TextServerAdvanced::font_set_msdf_pixel_range(RID p_font_rid, int p_msdf_pixel_range) {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -1685,7 +1685,7 @@ void TextServerAdvanced::font_set_msdf_pixel_range(RID p_font_rid, int p_msdf_pi
 }
 
 int TextServerAdvanced::font_get_msdf_pixel_range(RID p_font_rid) const {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, false);
 
 	MutexLock lock(fd->mutex);
@@ -1693,7 +1693,7 @@ int TextServerAdvanced::font_get_msdf_pixel_range(RID p_font_rid) const {
 }
 
 void TextServerAdvanced::font_set_msdf_size(RID p_font_rid, int p_msdf_size) {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -1704,7 +1704,7 @@ void TextServerAdvanced::font_set_msdf_size(RID p_font_rid, int p_msdf_size) {
 }
 
 int TextServerAdvanced::font_get_msdf_size(RID p_font_rid) const {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, false);
 
 	MutexLock lock(fd->mutex);
@@ -1712,7 +1712,7 @@ int TextServerAdvanced::font_get_msdf_size(RID p_font_rid) const {
 }
 
 void TextServerAdvanced::font_set_fixed_size(RID p_font_rid, int p_fixed_size) {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -1722,7 +1722,7 @@ void TextServerAdvanced::font_set_fixed_size(RID p_font_rid, int p_fixed_size) {
 }
 
 int TextServerAdvanced::font_get_fixed_size(RID p_font_rid) const {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, false);
 
 	MutexLock lock(fd->mutex);
@@ -1730,7 +1730,7 @@ int TextServerAdvanced::font_get_fixed_size(RID p_font_rid) const {
 }
 
 void TextServerAdvanced::font_set_force_autohinter(RID p_font_rid, bool p_force_autohinter) {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -1741,7 +1741,7 @@ void TextServerAdvanced::font_set_force_autohinter(RID p_font_rid, bool p_force_
 }
 
 bool TextServerAdvanced::font_is_force_autohinter(RID p_font_rid) const {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, false);
 
 	MutexLock lock(fd->mutex);
@@ -1749,7 +1749,7 @@ bool TextServerAdvanced::font_is_force_autohinter(RID p_font_rid) const {
 }
 
 void TextServerAdvanced::font_set_hinting(RID p_font_rid, TextServer::Hinting p_hinting) {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -1760,7 +1760,7 @@ void TextServerAdvanced::font_set_hinting(RID p_font_rid, TextServer::Hinting p_
 }
 
 TextServer::Hinting TextServerAdvanced::font_get_hinting(RID p_font_rid) const {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, HINTING_NONE);
 
 	MutexLock lock(fd->mutex);
@@ -1768,7 +1768,7 @@ TextServer::Hinting TextServerAdvanced::font_get_hinting(RID p_font_rid) const {
 }
 
 void TextServerAdvanced::font_set_variation_coordinates(RID p_font_rid, const Dictionary &p_variation_coordinates) {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -1779,7 +1779,7 @@ void TextServerAdvanced::font_set_variation_coordinates(RID p_font_rid, const Di
 }
 
 Dictionary TextServerAdvanced::font_get_variation_coordinates(RID p_font_rid) const {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, Dictionary());
 
 	MutexLock lock(fd->mutex);
@@ -1787,7 +1787,7 @@ Dictionary TextServerAdvanced::font_get_variation_coordinates(RID p_font_rid) co
 }
 
 void TextServerAdvanced::font_set_oversampling(RID p_font_rid, real_t p_oversampling) {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -1798,7 +1798,7 @@ void TextServerAdvanced::font_set_oversampling(RID p_font_rid, real_t p_oversamp
 }
 
 real_t TextServerAdvanced::font_get_oversampling(RID p_font_rid) const {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, 0.f);
 
 	MutexLock lock(fd->mutex);
@@ -1806,7 +1806,7 @@ real_t TextServerAdvanced::font_get_oversampling(RID p_font_rid) const {
 }
 
 Array TextServerAdvanced::font_get_size_cache_list(RID p_font_rid) const {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, Array());
 
 	MutexLock lock(fd->mutex);
@@ -1818,7 +1818,7 @@ Array TextServerAdvanced::font_get_size_cache_list(RID p_font_rid) const {
 }
 
 void TextServerAdvanced::font_clear_size_cache(RID p_font_rid) {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -1829,7 +1829,7 @@ void TextServerAdvanced::font_clear_size_cache(RID p_font_rid) {
 }
 
 void TextServerAdvanced::font_remove_size_cache(RID p_font_rid, const Vector2i &p_size) {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -1840,7 +1840,7 @@ void TextServerAdvanced::font_remove_size_cache(RID p_font_rid, const Vector2i &
 }
 
 void TextServerAdvanced::font_set_ascent(RID p_font_rid, int p_size, real_t p_ascent) {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -1851,7 +1851,7 @@ void TextServerAdvanced::font_set_ascent(RID p_font_rid, int p_size, real_t p_as
 }
 
 real_t TextServerAdvanced::font_get_ascent(RID p_font_rid, int p_size) const {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, 0.f);
 
 	MutexLock lock(fd->mutex);
@@ -1867,7 +1867,7 @@ real_t TextServerAdvanced::font_get_ascent(RID p_font_rid, int p_size) const {
 }
 
 void TextServerAdvanced::font_set_descent(RID p_font_rid, int p_size, real_t p_descent) {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	Vector2i size = _get_size(fd, p_size);
@@ -1877,7 +1877,7 @@ void TextServerAdvanced::font_set_descent(RID p_font_rid, int p_size, real_t p_d
 }
 
 real_t TextServerAdvanced::font_get_descent(RID p_font_rid, int p_size) const {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, 0.f);
 
 	MutexLock lock(fd->mutex);
@@ -1893,7 +1893,7 @@ real_t TextServerAdvanced::font_get_descent(RID p_font_rid, int p_size) const {
 }
 
 void TextServerAdvanced::font_set_underline_position(RID p_font_rid, int p_size, real_t p_underline_position) {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -1904,7 +1904,7 @@ void TextServerAdvanced::font_set_underline_position(RID p_font_rid, int p_size,
 }
 
 real_t TextServerAdvanced::font_get_underline_position(RID p_font_rid, int p_size) const {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, 0.f);
 
 	MutexLock lock(fd->mutex);
@@ -1920,7 +1920,7 @@ real_t TextServerAdvanced::font_get_underline_position(RID p_font_rid, int p_siz
 }
 
 void TextServerAdvanced::font_set_underline_thickness(RID p_font_rid, int p_size, real_t p_underline_thickness) {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -1931,7 +1931,7 @@ void TextServerAdvanced::font_set_underline_thickness(RID p_font_rid, int p_size
 }
 
 real_t TextServerAdvanced::font_get_underline_thickness(RID p_font_rid, int p_size) const {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, 0.f);
 
 	MutexLock lock(fd->mutex);
@@ -1947,7 +1947,7 @@ real_t TextServerAdvanced::font_get_underline_thickness(RID p_font_rid, int p_si
 }
 
 void TextServerAdvanced::font_set_scale(RID p_font_rid, int p_size, real_t p_scale) {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -1958,7 +1958,7 @@ void TextServerAdvanced::font_set_scale(RID p_font_rid, int p_size, real_t p_sca
 }
 
 real_t TextServerAdvanced::font_get_scale(RID p_font_rid, int p_size) const {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, 0.f);
 
 	MutexLock lock(fd->mutex);
@@ -1974,7 +1974,7 @@ real_t TextServerAdvanced::font_get_scale(RID p_font_rid, int p_size) const {
 }
 
 void TextServerAdvanced::font_set_spacing(RID p_font_rid, int p_size, TextServer::SpacingType p_spacing, int p_value) {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -1995,7 +1995,7 @@ void TextServerAdvanced::font_set_spacing(RID p_font_rid, int p_size, TextServer
 }
 
 int TextServerAdvanced::font_get_spacing(RID p_font_rid, int p_size, TextServer::SpacingType p_spacing) const {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, 0);
 
 	MutexLock lock(fd->mutex);
@@ -2026,7 +2026,7 @@ int TextServerAdvanced::font_get_spacing(RID p_font_rid, int p_size, TextServer:
 }
 
 int TextServerAdvanced::font_get_texture_count(RID p_font_rid, const Vector2i &p_size) const {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, 0);
 
 	MutexLock lock(fd->mutex);
@@ -2038,7 +2038,7 @@ int TextServerAdvanced::font_get_texture_count(RID p_font_rid, const Vector2i &p
 }
 
 void TextServerAdvanced::font_clear_textures(RID p_font_rid, const Vector2i &p_size) {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 	MutexLock lock(fd->mutex);
 	Vector2i size = _get_size_outline(fd, p_size);
@@ -2048,7 +2048,7 @@ void TextServerAdvanced::font_clear_textures(RID p_font_rid, const Vector2i &p_s
 }
 
 void TextServerAdvanced::font_remove_texture(RID p_font_rid, const Vector2i &p_size, int p_texture_index) {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -2060,7 +2060,7 @@ void TextServerAdvanced::font_remove_texture(RID p_font_rid, const Vector2i &p_s
 }
 
 void TextServerAdvanced::font_set_texture_image(RID p_font_rid, const Vector2i &p_size, int p_texture_index, const Ref<Image> &p_image) {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 	ERR_FAIL_COND(p_image.is_null());
 
@@ -2086,7 +2086,7 @@ void TextServerAdvanced::font_set_texture_image(RID p_font_rid, const Vector2i &
 }
 
 Ref<Image> TextServerAdvanced::font_get_texture_image(RID p_font_rid, const Vector2i &p_size, int p_texture_index) const {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, Ref<Image>());
 
 	MutexLock lock(fd->mutex);
@@ -2101,7 +2101,7 @@ Ref<Image> TextServerAdvanced::font_get_texture_image(RID p_font_rid, const Vect
 }
 
 void TextServerAdvanced::font_set_texture_offsets(RID p_font_rid, const Vector2i &p_size, int p_texture_index, const PackedInt32Array &p_offset) {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -2116,7 +2116,7 @@ void TextServerAdvanced::font_set_texture_offsets(RID p_font_rid, const Vector2i
 }
 
 PackedInt32Array TextServerAdvanced::font_get_texture_offsets(RID p_font_rid, const Vector2i &p_size, int p_texture_index) const {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, PackedInt32Array());
 
 	MutexLock lock(fd->mutex);
@@ -2129,7 +2129,7 @@ PackedInt32Array TextServerAdvanced::font_get_texture_offsets(RID p_font_rid, co
 }
 
 Array TextServerAdvanced::font_get_glyph_list(RID p_font_rid, const Vector2i &p_size) const {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, Array());
 
 	MutexLock lock(fd->mutex);
@@ -2146,7 +2146,7 @@ Array TextServerAdvanced::font_get_glyph_list(RID p_font_rid, const Vector2i &p_
 }
 
 void TextServerAdvanced::font_clear_glyphs(RID p_font_rid, const Vector2i &p_size) {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -2157,7 +2157,7 @@ void TextServerAdvanced::font_clear_glyphs(RID p_font_rid, const Vector2i &p_siz
 }
 
 void TextServerAdvanced::font_remove_glyph(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph) {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -2168,7 +2168,7 @@ void TextServerAdvanced::font_remove_glyph(RID p_font_rid, const Vector2i &p_siz
 }
 
 Vector2 TextServerAdvanced::font_get_glyph_advance(RID p_font_rid, int p_size, int32_t p_glyph) const {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, Vector2());
 
 	MutexLock lock(fd->mutex);
@@ -2189,7 +2189,7 @@ Vector2 TextServerAdvanced::font_get_glyph_advance(RID p_font_rid, int p_size, i
 }
 
 void TextServerAdvanced::font_set_glyph_advance(RID p_font_rid, int p_size, int32_t p_glyph, const Vector2 &p_advance) {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -2204,7 +2204,7 @@ void TextServerAdvanced::font_set_glyph_advance(RID p_font_rid, int p_size, int3
 }
 
 Vector2 TextServerAdvanced::font_get_glyph_offset(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph) const {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, Vector2());
 
 	MutexLock lock(fd->mutex);
@@ -2225,7 +2225,7 @@ Vector2 TextServerAdvanced::font_get_glyph_offset(RID p_font_rid, const Vector2i
 }
 
 void TextServerAdvanced::font_set_glyph_offset(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph, const Vector2 &p_offset) {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -2240,7 +2240,7 @@ void TextServerAdvanced::font_set_glyph_offset(RID p_font_rid, const Vector2i &p
 }
 
 Vector2 TextServerAdvanced::font_get_glyph_size(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph) const {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, Vector2());
 
 	MutexLock lock(fd->mutex);
@@ -2261,7 +2261,7 @@ Vector2 TextServerAdvanced::font_get_glyph_size(RID p_font_rid, const Vector2i &
 }
 
 void TextServerAdvanced::font_set_glyph_size(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph, const Vector2 &p_gl_size) {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -2276,7 +2276,7 @@ void TextServerAdvanced::font_set_glyph_size(RID p_font_rid, const Vector2i &p_s
 }
 
 Rect2 TextServerAdvanced::font_get_glyph_uv_rect(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph) const {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, Rect2());
 
 	MutexLock lock(fd->mutex);
@@ -2292,7 +2292,7 @@ Rect2 TextServerAdvanced::font_get_glyph_uv_rect(RID p_font_rid, const Vector2i
 }
 
 void TextServerAdvanced::font_set_glyph_uv_rect(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph, const Rect2 &p_uv_rect) {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -2307,7 +2307,7 @@ void TextServerAdvanced::font_set_glyph_uv_rect(RID p_font_rid, const Vector2i &
 }
 
 int TextServerAdvanced::font_get_glyph_texture_idx(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph) const {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, -1);
 
 	MutexLock lock(fd->mutex);
@@ -2323,7 +2323,7 @@ int TextServerAdvanced::font_get_glyph_texture_idx(RID p_font_rid, const Vector2
 }
 
 void TextServerAdvanced::font_set_glyph_texture_idx(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph, int p_texture_idx) {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -2338,7 +2338,7 @@ void TextServerAdvanced::font_set_glyph_texture_idx(RID p_font_rid, const Vector
 }
 
 bool TextServerAdvanced::font_get_glyph_contours(RID p_font_rid, int p_size, int32_t p_index, Vector<Vector3> &r_points, Vector<int32_t> &r_contours, bool &r_orientation) const {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, false);
 
 	MutexLock lock(fd->mutex);
@@ -2372,7 +2372,7 @@ bool TextServerAdvanced::font_get_glyph_contours(RID p_font_rid, int p_size, int
 }
 
 Array TextServerAdvanced::font_get_kerning_list(RID p_font_rid, int p_size) const {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, Array());
 
 	MutexLock lock(fd->mutex);
@@ -2388,7 +2388,7 @@ Array TextServerAdvanced::font_get_kerning_list(RID p_font_rid, int p_size) cons
 }
 
 void TextServerAdvanced::font_clear_kerning_map(RID p_font_rid, int p_size) {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -2399,7 +2399,7 @@ void TextServerAdvanced::font_clear_kerning_map(RID p_font_rid, int p_size) {
 }
 
 void TextServerAdvanced::font_remove_kerning(RID p_font_rid, int p_size, const Vector2i &p_glyph_pair) {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -2410,7 +2410,7 @@ void TextServerAdvanced::font_remove_kerning(RID p_font_rid, int p_size, const V
 }
 
 void TextServerAdvanced::font_set_kerning(RID p_font_rid, int p_size, const Vector2i &p_glyph_pair, const Vector2 &p_kerning) {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -2421,7 +2421,7 @@ void TextServerAdvanced::font_set_kerning(RID p_font_rid, int p_size, const Vect
 }
 
 Vector2 TextServerAdvanced::font_get_kerning(RID p_font_rid, int p_size, const Vector2i &p_glyph_pair) const {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, Vector2());
 
 	MutexLock lock(fd->mutex);
@@ -2454,7 +2454,7 @@ Vector2 TextServerAdvanced::font_get_kerning(RID p_font_rid, int p_size, const V
 }
 
 int32_t TextServerAdvanced::font_get_glyph_index(RID p_font_rid, int p_size, char32_t p_char, char32_t p_variation_selector) const {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, 0);
 
 	MutexLock lock(fd->mutex);
@@ -2477,7 +2477,7 @@ int32_t TextServerAdvanced::font_get_glyph_index(RID p_font_rid, int p_size, cha
 }
 
 bool TextServerAdvanced::font_has_char(RID p_font_rid, char32_t p_char) const {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, false);
 
 	MutexLock lock(fd->mutex);
@@ -2495,7 +2495,7 @@ bool TextServerAdvanced::font_has_char(RID p_font_rid, char32_t p_char) const {
 }
 
 String TextServerAdvanced::font_get_supported_chars(RID p_font_rid) const {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, String());
 
 	MutexLock lock(fd->mutex);
@@ -2529,7 +2529,7 @@ String TextServerAdvanced::font_get_supported_chars(RID p_font_rid) const {
 }
 
 void TextServerAdvanced::font_render_range(RID p_font_rid, const Vector2i &p_size, char32_t p_start, char32_t p_end) {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -2547,7 +2547,7 @@ void TextServerAdvanced::font_render_range(RID p_font_rid, const Vector2i &p_siz
 }
 
 void TextServerAdvanced::font_render_glyph(RID p_font_rid, const Vector2i &p_size, int32_t p_index) {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -2557,7 +2557,7 @@ void TextServerAdvanced::font_render_glyph(RID p_font_rid, const Vector2i &p_siz
 }
 
 void TextServerAdvanced::font_draw_glyph(RID p_font_rid, RID p_canvas, int p_size, const Vector2 &p_pos, int32_t p_index, const Color &p_color) const {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -2597,7 +2597,7 @@ void TextServerAdvanced::font_draw_glyph(RID p_font_rid, RID p_canvas, int p_siz
 }
 
 void TextServerAdvanced::font_draw_glyph_outline(RID p_font_rid, RID p_canvas, int p_size, int p_outline_size, const Vector2 &p_pos, int32_t p_index, const Color &p_color) const {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -2637,7 +2637,7 @@ void TextServerAdvanced::font_draw_glyph_outline(RID p_font_rid, RID p_canvas, i
 }
 
 bool TextServerAdvanced::font_is_language_supported(RID p_font_rid, const String &p_language) const {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, false);
 
 	MutexLock lock(fd->mutex);
@@ -2649,7 +2649,7 @@ bool TextServerAdvanced::font_is_language_supported(RID p_font_rid, const String
 }
 
 void TextServerAdvanced::font_set_language_support_override(RID p_font_rid, const String &p_language, bool p_supported) {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -2657,7 +2657,7 @@ void TextServerAdvanced::font_set_language_support_override(RID p_font_rid, cons
 }
 
 bool TextServerAdvanced::font_get_language_support_override(RID p_font_rid, const String &p_language) {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, false);
 
 	MutexLock lock(fd->mutex);
@@ -2665,7 +2665,7 @@ bool TextServerAdvanced::font_get_language_support_override(RID p_font_rid, cons
 }
 
 void TextServerAdvanced::font_remove_language_support_override(RID p_font_rid, const String &p_language) {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -2673,7 +2673,7 @@ void TextServerAdvanced::font_remove_language_support_override(RID p_font_rid, c
 }
 
 Vector<String> TextServerAdvanced::font_get_language_support_overrides(RID p_font_rid) {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, Vector<String>());
 
 	MutexLock lock(fd->mutex);
@@ -2685,7 +2685,7 @@ Vector<String> TextServerAdvanced::font_get_language_support_overrides(RID p_fon
 }
 
 bool TextServerAdvanced::font_is_script_supported(RID p_font_rid, const String &p_script) const {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, false);
 
 	MutexLock lock(fd->mutex);
@@ -2699,7 +2699,7 @@ bool TextServerAdvanced::font_is_script_supported(RID p_font_rid, const String &
 }
 
 void TextServerAdvanced::font_set_script_support_override(RID p_font_rid, const String &p_script, bool p_supported) {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -2707,7 +2707,7 @@ void TextServerAdvanced::font_set_script_support_override(RID p_font_rid, const
 }
 
 bool TextServerAdvanced::font_get_script_support_override(RID p_font_rid, const String &p_script) {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, false);
 
 	MutexLock lock(fd->mutex);
@@ -2715,7 +2715,7 @@ bool TextServerAdvanced::font_get_script_support_override(RID p_font_rid, const
 }
 
 void TextServerAdvanced::font_remove_script_support_override(RID p_font_rid, const String &p_script) {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -2723,7 +2723,7 @@ void TextServerAdvanced::font_remove_script_support_override(RID p_font_rid, con
 }
 
 Vector<String> TextServerAdvanced::font_get_script_support_overrides(RID p_font_rid) {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, Vector<String>());
 
 	MutexLock lock(fd->mutex);
@@ -2735,7 +2735,7 @@ Vector<String> TextServerAdvanced::font_get_script_support_overrides(RID p_font_
 }
 
 Dictionary TextServerAdvanced::font_supported_feature_list(RID p_font_rid) const {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, Dictionary());
 
 	MutexLock lock(fd->mutex);
@@ -2745,7 +2745,7 @@ Dictionary TextServerAdvanced::font_supported_feature_list(RID p_font_rid) const
 }
 
 Dictionary TextServerAdvanced::font_supported_variation_list(RID p_font_rid) const {
-	FontDataAdvanced *fd = font_owner.getornull(p_font_rid);
+	FontDataAdvanced *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, Dictionary());
 
 	MutexLock lock(fd->mutex);
@@ -2776,7 +2776,7 @@ void TextServerAdvanced::font_set_global_oversampling(real_t p_oversampling) {
 			List<RID> text_bufs;
 			shaped_owner.get_owned_list(&text_bufs);
 			for (const RID &E : text_bufs) {
-				invalidate(shaped_owner.getornull(E));
+				invalidate(shaped_owner.get_or_null(E));
 			}
 		}
 	}
@@ -2837,7 +2837,7 @@ void TextServerAdvanced::invalidate(TextServerAdvanced::ShapedTextDataAdvanced *
 }
 
 void TextServerAdvanced::full_copy(ShapedTextDataAdvanced *p_shaped) {
-	ShapedTextDataAdvanced *parent = shaped_owner.getornull(p_shaped->parent);
+	ShapedTextDataAdvanced *parent = shaped_owner.get_or_null(p_shaped->parent);
 
 	for (Map<Variant, ShapedTextData::EmbeddedObject>::Element *E = parent->objects.front(); E; E = E->next()) {
 		if (E->get().pos >= p_shaped->start && E->get().pos < p_shaped->end) {
@@ -2868,7 +2868,7 @@ RID TextServerAdvanced::create_shaped_text(TextServer::Direction p_direction, Te
 }
 
 void TextServerAdvanced::shaped_text_clear(RID p_shaped) {
-	ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped);
+	ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND(!sd);
 
 	MutexLock lock(sd->mutex);
@@ -2883,7 +2883,7 @@ void TextServerAdvanced::shaped_text_clear(RID p_shaped) {
 }
 
 void TextServerAdvanced::shaped_text_set_direction(RID p_shaped, TextServer::Direction p_direction) {
-	ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped);
+	ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND(!sd);
 
 	MutexLock lock(sd->mutex);
@@ -2897,7 +2897,7 @@ void TextServerAdvanced::shaped_text_set_direction(RID p_shaped, TextServer::Dir
 }
 
 TextServer::Direction TextServerAdvanced::shaped_text_get_direction(RID p_shaped) const {
-	const ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped);
+	const ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, TextServer::DIRECTION_LTR);
 
 	MutexLock lock(sd->mutex);
@@ -2905,7 +2905,7 @@ TextServer::Direction TextServerAdvanced::shaped_text_get_direction(RID p_shaped
 }
 
 void TextServerAdvanced::shaped_text_set_bidi_override(RID p_shaped, const Vector<Vector2i> &p_override) {
-	ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped);
+	ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND(!sd);
 
 	MutexLock lock(sd->mutex);
@@ -2917,7 +2917,7 @@ void TextServerAdvanced::shaped_text_set_bidi_override(RID p_shaped, const Vecto
 }
 
 void TextServerAdvanced::shaped_text_set_orientation(RID p_shaped, TextServer::Orientation p_orientation) {
-	ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped);
+	ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND(!sd);
 
 	MutexLock lock(sd->mutex);
@@ -2931,7 +2931,7 @@ void TextServerAdvanced::shaped_text_set_orientation(RID p_shaped, TextServer::O
 }
 
 void TextServerAdvanced::shaped_text_set_preserve_invalid(RID p_shaped, bool p_enabled) {
-	ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped);
+	ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND(!sd);
 
 	MutexLock lock(sd->mutex);
@@ -2943,7 +2943,7 @@ void TextServerAdvanced::shaped_text_set_preserve_invalid(RID p_shaped, bool p_e
 }
 
 bool TextServerAdvanced::shaped_text_get_preserve_invalid(RID p_shaped) const {
-	const ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped);
+	const ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, false);
 
 	MutexLock lock(sd->mutex);
@@ -2951,7 +2951,7 @@ bool TextServerAdvanced::shaped_text_get_preserve_invalid(RID p_shaped) const {
 }
 
 void TextServerAdvanced::shaped_text_set_preserve_control(RID p_shaped, bool p_enabled) {
-	ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped);
+	ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND(!sd);
 
 	MutexLock lock(sd->mutex);
@@ -2965,7 +2965,7 @@ void TextServerAdvanced::shaped_text_set_preserve_control(RID p_shaped, bool p_e
 }
 
 bool TextServerAdvanced::shaped_text_get_preserve_control(RID p_shaped) const {
-	const ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped);
+	const ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, false);
 
 	MutexLock lock(sd->mutex);
@@ -2973,7 +2973,7 @@ bool TextServerAdvanced::shaped_text_get_preserve_control(RID p_shaped) const {
 }
 
 TextServer::Orientation TextServerAdvanced::shaped_text_get_orientation(RID p_shaped) const {
-	const ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped);
+	const ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, TextServer::ORIENTATION_HORIZONTAL);
 
 	MutexLock lock(sd->mutex);
@@ -2981,13 +2981,13 @@ TextServer::Orientation TextServerAdvanced::shaped_text_get_orientation(RID p_sh
 }
 
 bool TextServerAdvanced::shaped_text_add_string(RID p_shaped, const String &p_text, const Vector<RID> &p_fonts, int p_size, const Dictionary &p_opentype_features, const String &p_language) {
-	ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped);
+	ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, false);
 	ERR_FAIL_COND_V(p_size <= 0, false);
 
 	MutexLock lock(sd->mutex);
 	for (int i = 0; i < p_fonts.size(); i++) {
-		ERR_FAIL_COND_V(!font_owner.getornull(p_fonts[i]), false);
+		ERR_FAIL_COND_V(!font_owner.get_or_null(p_fonts[i]), false);
 	}
 
 	if (p_text.is_empty()) {
@@ -3016,7 +3016,7 @@ bool TextServerAdvanced::shaped_text_add_string(RID p_shaped, const String &p_te
 
 bool TextServerAdvanced::shaped_text_add_object(RID p_shaped, Variant p_key, const Size2 &p_size, InlineAlign p_inline_align, int p_length) {
 	_THREAD_SAFE_METHOD_
-	ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped);
+	ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, false);
 	ERR_FAIL_COND_V(p_key == Variant(), false);
 	ERR_FAIL_COND_V(sd->objects.has(p_key), false);
@@ -3045,7 +3045,7 @@ bool TextServerAdvanced::shaped_text_add_object(RID p_shaped, Variant p_key, con
 }
 
 bool TextServerAdvanced::shaped_text_resize_object(RID p_shaped, Variant p_key, const Size2 &p_size, InlineAlign p_inline_align) {
-	ShapedTextData *sd = shaped_owner.getornull(p_shaped);
+	ShapedTextData *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, false);
 
 	MutexLock lock(sd->mutex);
@@ -3178,7 +3178,7 @@ bool TextServerAdvanced::shaped_text_resize_object(RID p_shaped, Variant p_key,
 }
 
 RID TextServerAdvanced::shaped_text_substr(RID p_shaped, int p_start, int p_length) const {
-	const ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped);
+	const ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, RID());
 
 	MutexLock lock(sd->mutex);
@@ -3371,7 +3371,7 @@ RID TextServerAdvanced::shaped_text_substr(RID p_shaped, int p_start, int p_leng
 }
 
 RID TextServerAdvanced::shaped_text_get_parent(RID p_shaped) const {
-	ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped);
+	ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, RID());
 
 	MutexLock lock(sd->mutex);
@@ -3379,7 +3379,7 @@ RID TextServerAdvanced::shaped_text_get_parent(RID p_shaped) const {
 }
 
 real_t TextServerAdvanced::shaped_text_fit_to_width(RID p_shaped, real_t p_width, uint8_t /*JustificationFlag*/ p_jst_flags) {
-	ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped);
+	ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, 0.f);
 
 	MutexLock lock(sd->mutex);
@@ -3515,7 +3515,7 @@ real_t TextServerAdvanced::shaped_text_fit_to_width(RID p_shaped, real_t p_width
 }
 
 real_t TextServerAdvanced::shaped_text_tab_align(RID p_shaped, const Vector<real_t> &p_tab_stops) {
-	ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped);
+	ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, 0.f);
 
 	MutexLock lock(sd->mutex);
@@ -3565,7 +3565,7 @@ real_t TextServerAdvanced::shaped_text_tab_align(RID p_shaped, const Vector<real
 }
 
 void TextServerAdvanced::shaped_text_overrun_trim_to_width(RID p_shaped_line, real_t p_width, uint8_t p_trim_flags) {
-	ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped_line);
+	ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped_line);
 	ERR_FAIL_COND_MSG(!sd, "ShapedTextDataAdvanced invalid.");
 
 	MutexLock lock(sd->mutex);
@@ -3692,7 +3692,7 @@ void TextServerAdvanced::shaped_text_overrun_trim_to_width(RID p_shaped_line, re
 }
 
 TextServer::TrimData TextServerAdvanced::shaped_text_get_trim_data(RID p_shaped) const {
-	ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped);
+	ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V_MSG(!sd, TrimData(), "ShapedTextDataAdvanced invalid.");
 
 	MutexLock lock(sd->mutex);
@@ -3700,7 +3700,7 @@ TextServer::TrimData TextServerAdvanced::shaped_text_get_trim_data(RID p_shaped)
 }
 
 bool TextServerAdvanced::shaped_text_update_breaks(RID p_shaped) {
-	ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped);
+	ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, false);
 
 	MutexLock lock(sd->mutex);
@@ -3892,7 +3892,7 @@ _FORCE_INLINE_ int _generate_kashida_justification_opportunies(const String &p_d
 }
 
 bool TextServerAdvanced::shaped_text_update_justification_ops(RID p_shaped) {
-	ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped);
+	ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, false);
 
 	MutexLock lock(sd->mutex);
@@ -4249,7 +4249,7 @@ void TextServerAdvanced::_shape_run(ShapedTextDataAdvanced *p_sd, int32_t p_star
 }
 
 bool TextServerAdvanced::shaped_text_shape(RID p_shaped) {
-	ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped);
+	ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, false);
 
 	MutexLock lock(sd->mutex);
@@ -4479,7 +4479,7 @@ bool TextServerAdvanced::shaped_text_shape(RID p_shaped) {
 }
 
 bool TextServerAdvanced::shaped_text_is_ready(RID p_shaped) const {
-	const ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped);
+	const ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, false);
 
 	MutexLock lock(sd->mutex);
@@ -4487,7 +4487,7 @@ bool TextServerAdvanced::shaped_text_is_ready(RID p_shaped) const {
 }
 
 Vector<TextServer::Glyph> TextServerAdvanced::shaped_text_get_glyphs(RID p_shaped) const {
-	const ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped);
+	const ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, Vector<TextServer::Glyph>());
 
 	MutexLock lock(sd->mutex);
@@ -4498,7 +4498,7 @@ Vector<TextServer::Glyph> TextServerAdvanced::shaped_text_get_glyphs(RID p_shape
 }
 
 Vector2i TextServerAdvanced::shaped_text_get_range(RID p_shaped) const {
-	const ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped);
+	const ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, Vector2i());
 
 	MutexLock lock(sd->mutex);
@@ -4506,7 +4506,7 @@ Vector2i TextServerAdvanced::shaped_text_get_range(RID p_shaped) const {
 }
 
 Vector<TextServer::Glyph> TextServerAdvanced::shaped_text_sort_logical(RID p_shaped) {
-	ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped);
+	ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, Vector<TextServer::Glyph>());
 
 	MutexLock lock(sd->mutex);
@@ -4525,7 +4525,7 @@ Vector<TextServer::Glyph> TextServerAdvanced::shaped_text_sort_logical(RID p_sha
 
 Array TextServerAdvanced::shaped_text_get_objects(RID p_shaped) const {
 	Array ret;
-	const ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped);
+	const ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, ret);
 
 	MutexLock lock(sd->mutex);
@@ -4537,7 +4537,7 @@ Array TextServerAdvanced::shaped_text_get_objects(RID p_shaped) const {
 }
 
 Rect2 TextServerAdvanced::shaped_text_get_object_rect(RID p_shaped, Variant p_key) const {
-	const ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped);
+	const ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, Rect2());
 
 	MutexLock lock(sd->mutex);
@@ -4549,7 +4549,7 @@ Rect2 TextServerAdvanced::shaped_text_get_object_rect(RID p_shaped, Variant p_ke
 }
 
 Size2 TextServerAdvanced::shaped_text_get_size(RID p_shaped) const {
-	const ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped);
+	const ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, Size2());
 
 	MutexLock lock(sd->mutex);
@@ -4564,7 +4564,7 @@ Size2 TextServerAdvanced::shaped_text_get_size(RID p_shaped) const {
 }
 
 real_t TextServerAdvanced::shaped_text_get_ascent(RID p_shaped) const {
-	const ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped);
+	const ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, 0.f);
 
 	MutexLock lock(sd->mutex);
@@ -4575,7 +4575,7 @@ real_t TextServerAdvanced::shaped_text_get_ascent(RID p_shaped) const {
 }
 
 real_t TextServerAdvanced::shaped_text_get_descent(RID p_shaped) const {
-	const ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped);
+	const ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, 0.f);
 
 	MutexLock lock(sd->mutex);
@@ -4586,7 +4586,7 @@ real_t TextServerAdvanced::shaped_text_get_descent(RID p_shaped) const {
 }
 
 real_t TextServerAdvanced::shaped_text_get_width(RID p_shaped) const {
-	const ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped);
+	const ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, 0.f);
 
 	MutexLock lock(sd->mutex);
@@ -4597,7 +4597,7 @@ real_t TextServerAdvanced::shaped_text_get_width(RID p_shaped) const {
 }
 
 real_t TextServerAdvanced::shaped_text_get_underline_position(RID p_shaped) const {
-	const ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped);
+	const ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, 0.f);
 
 	MutexLock lock(sd->mutex);
@@ -4609,7 +4609,7 @@ real_t TextServerAdvanced::shaped_text_get_underline_position(RID p_shaped) cons
 }
 
 real_t TextServerAdvanced::shaped_text_get_underline_thickness(RID p_shaped) const {
-	const ShapedTextDataAdvanced *sd = shaped_owner.getornull(p_shaped);
+	const ShapedTextDataAdvanced *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, 0.f);
 
 	MutexLock lock(sd->mutex);
diff --git a/modules/text_server_fb/text_server_fb.cpp b/modules/text_server_fb/text_server_fb.cpp
index 0dd48f98e2..b1ce85d505 100644
--- a/modules/text_server_fb/text_server_fb.cpp
+++ b/modules/text_server_fb/text_server_fb.cpp
@@ -80,11 +80,11 @@ String TextServerFallback::get_name() const {
 void TextServerFallback::free(RID p_rid) {
 	_THREAD_SAFE_METHOD_
 	if (font_owner.owns(p_rid)) {
-		FontDataFallback *fd = font_owner.getornull(p_rid);
+		FontDataFallback *fd = font_owner.get_or_null(p_rid);
 		font_owner.free(p_rid);
 		memdelete(fd);
 	} else if (shaped_owner.owns(p_rid)) {
-		ShapedTextData *sd = shaped_owner.getornull(p_rid);
+		ShapedTextData *sd = shaped_owner.get_or_null(p_rid);
 		shaped_owner.free(p_rid);
 		memdelete(sd);
 	}
@@ -811,7 +811,7 @@ RID TextServerFallback::create_font() {
 }
 
 void TextServerFallback::font_set_data(RID p_font_rid, const PackedByteArray &p_data) {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -822,7 +822,7 @@ void TextServerFallback::font_set_data(RID p_font_rid, const PackedByteArray &p_
 }
 
 void TextServerFallback::font_set_data_ptr(RID p_font_rid, const uint8_t *p_data_ptr, size_t p_data_size) {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -833,7 +833,7 @@ void TextServerFallback::font_set_data_ptr(RID p_font_rid, const uint8_t *p_data
 }
 
 void TextServerFallback::font_set_antialiased(RID p_font_rid, bool p_antialiased) {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -844,7 +844,7 @@ void TextServerFallback::font_set_antialiased(RID p_font_rid, bool p_antialiased
 }
 
 bool TextServerFallback::font_is_antialiased(RID p_font_rid) const {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, false);
 
 	MutexLock lock(fd->mutex);
@@ -852,7 +852,7 @@ bool TextServerFallback::font_is_antialiased(RID p_font_rid) const {
 }
 
 void TextServerFallback::font_set_multichannel_signed_distance_field(RID p_font_rid, bool p_msdf) {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -863,7 +863,7 @@ void TextServerFallback::font_set_multichannel_signed_distance_field(RID p_font_
 }
 
 bool TextServerFallback::font_is_multichannel_signed_distance_field(RID p_font_rid) const {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, false);
 
 	MutexLock lock(fd->mutex);
@@ -871,7 +871,7 @@ bool TextServerFallback::font_is_multichannel_signed_distance_field(RID p_font_r
 }
 
 void TextServerFallback::font_set_msdf_pixel_range(RID p_font_rid, int p_msdf_pixel_range) {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -882,7 +882,7 @@ void TextServerFallback::font_set_msdf_pixel_range(RID p_font_rid, int p_msdf_pi
 }
 
 int TextServerFallback::font_get_msdf_pixel_range(RID p_font_rid) const {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, false);
 
 	MutexLock lock(fd->mutex);
@@ -890,7 +890,7 @@ int TextServerFallback::font_get_msdf_pixel_range(RID p_font_rid) const {
 }
 
 void TextServerFallback::font_set_msdf_size(RID p_font_rid, int p_msdf_size) {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -901,7 +901,7 @@ void TextServerFallback::font_set_msdf_size(RID p_font_rid, int p_msdf_size) {
 }
 
 int TextServerFallback::font_get_msdf_size(RID p_font_rid) const {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, false);
 
 	MutexLock lock(fd->mutex);
@@ -909,7 +909,7 @@ int TextServerFallback::font_get_msdf_size(RID p_font_rid) const {
 }
 
 void TextServerFallback::font_set_fixed_size(RID p_font_rid, int p_fixed_size) {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -919,7 +919,7 @@ void TextServerFallback::font_set_fixed_size(RID p_font_rid, int p_fixed_size) {
 }
 
 int TextServerFallback::font_get_fixed_size(RID p_font_rid) const {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, false);
 
 	MutexLock lock(fd->mutex);
@@ -927,7 +927,7 @@ int TextServerFallback::font_get_fixed_size(RID p_font_rid) const {
 }
 
 void TextServerFallback::font_set_force_autohinter(RID p_font_rid, bool p_force_autohinter) {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -938,7 +938,7 @@ void TextServerFallback::font_set_force_autohinter(RID p_font_rid, bool p_force_
 }
 
 bool TextServerFallback::font_is_force_autohinter(RID p_font_rid) const {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, false);
 
 	MutexLock lock(fd->mutex);
@@ -946,7 +946,7 @@ bool TextServerFallback::font_is_force_autohinter(RID p_font_rid) const {
 }
 
 void TextServerFallback::font_set_hinting(RID p_font_rid, TextServer::Hinting p_hinting) {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -957,7 +957,7 @@ void TextServerFallback::font_set_hinting(RID p_font_rid, TextServer::Hinting p_
 }
 
 TextServer::Hinting TextServerFallback::font_get_hinting(RID p_font_rid) const {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, HINTING_NONE);
 
 	MutexLock lock(fd->mutex);
@@ -965,7 +965,7 @@ TextServer::Hinting TextServerFallback::font_get_hinting(RID p_font_rid) const {
 }
 
 void TextServerFallback::font_set_variation_coordinates(RID p_font_rid, const Dictionary &p_variation_coordinates) {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -976,7 +976,7 @@ void TextServerFallback::font_set_variation_coordinates(RID p_font_rid, const Di
 }
 
 Dictionary TextServerFallback::font_get_variation_coordinates(RID p_font_rid) const {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, Dictionary());
 
 	MutexLock lock(fd->mutex);
@@ -984,7 +984,7 @@ Dictionary TextServerFallback::font_get_variation_coordinates(RID p_font_rid) co
 }
 
 void TextServerFallback::font_set_oversampling(RID p_font_rid, real_t p_oversampling) {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -995,7 +995,7 @@ void TextServerFallback::font_set_oversampling(RID p_font_rid, real_t p_oversamp
 }
 
 real_t TextServerFallback::font_get_oversampling(RID p_font_rid) const {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, 0.f);
 
 	MutexLock lock(fd->mutex);
@@ -1003,7 +1003,7 @@ real_t TextServerFallback::font_get_oversampling(RID p_font_rid) const {
 }
 
 Array TextServerFallback::font_get_size_cache_list(RID p_font_rid) const {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, Array());
 
 	MutexLock lock(fd->mutex);
@@ -1015,7 +1015,7 @@ Array TextServerFallback::font_get_size_cache_list(RID p_font_rid) const {
 }
 
 void TextServerFallback::font_clear_size_cache(RID p_font_rid) {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -1026,7 +1026,7 @@ void TextServerFallback::font_clear_size_cache(RID p_font_rid) {
 }
 
 void TextServerFallback::font_remove_size_cache(RID p_font_rid, const Vector2i &p_size) {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -1037,7 +1037,7 @@ void TextServerFallback::font_remove_size_cache(RID p_font_rid, const Vector2i &
 }
 
 void TextServerFallback::font_set_ascent(RID p_font_rid, int p_size, real_t p_ascent) {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -1048,7 +1048,7 @@ void TextServerFallback::font_set_ascent(RID p_font_rid, int p_size, real_t p_as
 }
 
 real_t TextServerFallback::font_get_ascent(RID p_font_rid, int p_size) const {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, 0.f);
 
 	MutexLock lock(fd->mutex);
@@ -1064,7 +1064,7 @@ real_t TextServerFallback::font_get_ascent(RID p_font_rid, int p_size) const {
 }
 
 void TextServerFallback::font_set_descent(RID p_font_rid, int p_size, real_t p_descent) {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	Vector2i size = _get_size(fd, p_size);
@@ -1074,7 +1074,7 @@ void TextServerFallback::font_set_descent(RID p_font_rid, int p_size, real_t p_d
 }
 
 real_t TextServerFallback::font_get_descent(RID p_font_rid, int p_size) const {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, 0.f);
 
 	MutexLock lock(fd->mutex);
@@ -1090,7 +1090,7 @@ real_t TextServerFallback::font_get_descent(RID p_font_rid, int p_size) const {
 }
 
 void TextServerFallback::font_set_underline_position(RID p_font_rid, int p_size, real_t p_underline_position) {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -1101,7 +1101,7 @@ void TextServerFallback::font_set_underline_position(RID p_font_rid, int p_size,
 }
 
 real_t TextServerFallback::font_get_underline_position(RID p_font_rid, int p_size) const {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, 0.f);
 
 	MutexLock lock(fd->mutex);
@@ -1117,7 +1117,7 @@ real_t TextServerFallback::font_get_underline_position(RID p_font_rid, int p_siz
 }
 
 void TextServerFallback::font_set_underline_thickness(RID p_font_rid, int p_size, real_t p_underline_thickness) {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -1128,7 +1128,7 @@ void TextServerFallback::font_set_underline_thickness(RID p_font_rid, int p_size
 }
 
 real_t TextServerFallback::font_get_underline_thickness(RID p_font_rid, int p_size) const {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, 0.f);
 
 	MutexLock lock(fd->mutex);
@@ -1144,7 +1144,7 @@ real_t TextServerFallback::font_get_underline_thickness(RID p_font_rid, int p_si
 }
 
 void TextServerFallback::font_set_scale(RID p_font_rid, int p_size, real_t p_scale) {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -1155,7 +1155,7 @@ void TextServerFallback::font_set_scale(RID p_font_rid, int p_size, real_t p_sca
 }
 
 real_t TextServerFallback::font_get_scale(RID p_font_rid, int p_size) const {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, 0.f);
 
 	MutexLock lock(fd->mutex);
@@ -1171,7 +1171,7 @@ real_t TextServerFallback::font_get_scale(RID p_font_rid, int p_size) const {
 }
 
 void TextServerFallback::font_set_spacing(RID p_font_rid, int p_size, TextServer::SpacingType p_spacing, int p_value) {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -1192,7 +1192,7 @@ void TextServerFallback::font_set_spacing(RID p_font_rid, int p_size, TextServer
 }
 
 int TextServerFallback::font_get_spacing(RID p_font_rid, int p_size, TextServer::SpacingType p_spacing) const {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, 0);
 
 	MutexLock lock(fd->mutex);
@@ -1223,7 +1223,7 @@ int TextServerFallback::font_get_spacing(RID p_font_rid, int p_size, TextServer:
 }
 
 int TextServerFallback::font_get_texture_count(RID p_font_rid, const Vector2i &p_size) const {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, 0);
 
 	MutexLock lock(fd->mutex);
@@ -1235,7 +1235,7 @@ int TextServerFallback::font_get_texture_count(RID p_font_rid, const Vector2i &p
 }
 
 void TextServerFallback::font_clear_textures(RID p_font_rid, const Vector2i &p_size) {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 	MutexLock lock(fd->mutex);
 	Vector2i size = _get_size_outline(fd, p_size);
@@ -1245,7 +1245,7 @@ void TextServerFallback::font_clear_textures(RID p_font_rid, const Vector2i &p_s
 }
 
 void TextServerFallback::font_remove_texture(RID p_font_rid, const Vector2i &p_size, int p_texture_index) {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -1257,7 +1257,7 @@ void TextServerFallback::font_remove_texture(RID p_font_rid, const Vector2i &p_s
 }
 
 void TextServerFallback::font_set_texture_image(RID p_font_rid, const Vector2i &p_size, int p_texture_index, const Ref<Image> &p_image) {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 	ERR_FAIL_COND(p_image.is_null());
 
@@ -1283,7 +1283,7 @@ void TextServerFallback::font_set_texture_image(RID p_font_rid, const Vector2i &
 }
 
 Ref<Image> TextServerFallback::font_get_texture_image(RID p_font_rid, const Vector2i &p_size, int p_texture_index) const {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, Ref<Image>());
 
 	MutexLock lock(fd->mutex);
@@ -1298,7 +1298,7 @@ Ref<Image> TextServerFallback::font_get_texture_image(RID p_font_rid, const Vect
 }
 
 void TextServerFallback::font_set_texture_offsets(RID p_font_rid, const Vector2i &p_size, int p_texture_index, const PackedInt32Array &p_offset) {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -1313,7 +1313,7 @@ void TextServerFallback::font_set_texture_offsets(RID p_font_rid, const Vector2i
 }
 
 PackedInt32Array TextServerFallback::font_get_texture_offsets(RID p_font_rid, const Vector2i &p_size, int p_texture_index) const {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, PackedInt32Array());
 
 	MutexLock lock(fd->mutex);
@@ -1326,7 +1326,7 @@ PackedInt32Array TextServerFallback::font_get_texture_offsets(RID p_font_rid, co
 }
 
 Array TextServerFallback::font_get_glyph_list(RID p_font_rid, const Vector2i &p_size) const {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, Array());
 
 	MutexLock lock(fd->mutex);
@@ -1343,7 +1343,7 @@ Array TextServerFallback::font_get_glyph_list(RID p_font_rid, const Vector2i &p_
 }
 
 void TextServerFallback::font_clear_glyphs(RID p_font_rid, const Vector2i &p_size) {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -1354,7 +1354,7 @@ void TextServerFallback::font_clear_glyphs(RID p_font_rid, const Vector2i &p_siz
 }
 
 void TextServerFallback::font_remove_glyph(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph) {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -1365,7 +1365,7 @@ void TextServerFallback::font_remove_glyph(RID p_font_rid, const Vector2i &p_siz
 }
 
 Vector2 TextServerFallback::font_get_glyph_advance(RID p_font_rid, int p_size, int32_t p_glyph) const {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, Vector2());
 
 	MutexLock lock(fd->mutex);
@@ -1386,7 +1386,7 @@ Vector2 TextServerFallback::font_get_glyph_advance(RID p_font_rid, int p_size, i
 }
 
 void TextServerFallback::font_set_glyph_advance(RID p_font_rid, int p_size, int32_t p_glyph, const Vector2 &p_advance) {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -1401,7 +1401,7 @@ void TextServerFallback::font_set_glyph_advance(RID p_font_rid, int p_size, int3
 }
 
 Vector2 TextServerFallback::font_get_glyph_offset(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph) const {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, Vector2());
 
 	MutexLock lock(fd->mutex);
@@ -1422,7 +1422,7 @@ Vector2 TextServerFallback::font_get_glyph_offset(RID p_font_rid, const Vector2i
 }
 
 void TextServerFallback::font_set_glyph_offset(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph, const Vector2 &p_offset) {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -1437,7 +1437,7 @@ void TextServerFallback::font_set_glyph_offset(RID p_font_rid, const Vector2i &p
 }
 
 Vector2 TextServerFallback::font_get_glyph_size(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph) const {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, Vector2());
 
 	MutexLock lock(fd->mutex);
@@ -1458,7 +1458,7 @@ Vector2 TextServerFallback::font_get_glyph_size(RID p_font_rid, const Vector2i &
 }
 
 void TextServerFallback::font_set_glyph_size(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph, const Vector2 &p_gl_size) {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -1473,7 +1473,7 @@ void TextServerFallback::font_set_glyph_size(RID p_font_rid, const Vector2i &p_s
 }
 
 Rect2 TextServerFallback::font_get_glyph_uv_rect(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph) const {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, Rect2());
 
 	MutexLock lock(fd->mutex);
@@ -1489,7 +1489,7 @@ Rect2 TextServerFallback::font_get_glyph_uv_rect(RID p_font_rid, const Vector2i
 }
 
 void TextServerFallback::font_set_glyph_uv_rect(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph, const Rect2 &p_uv_rect) {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -1504,7 +1504,7 @@ void TextServerFallback::font_set_glyph_uv_rect(RID p_font_rid, const Vector2i &
 }
 
 int TextServerFallback::font_get_glyph_texture_idx(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph) const {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, -1);
 
 	MutexLock lock(fd->mutex);
@@ -1520,7 +1520,7 @@ int TextServerFallback::font_get_glyph_texture_idx(RID p_font_rid, const Vector2
 }
 
 void TextServerFallback::font_set_glyph_texture_idx(RID p_font_rid, const Vector2i &p_size, int32_t p_glyph, int p_texture_idx) {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -1535,7 +1535,7 @@ void TextServerFallback::font_set_glyph_texture_idx(RID p_font_rid, const Vector
 }
 
 bool TextServerFallback::font_get_glyph_contours(RID p_font_rid, int p_size, int32_t p_index, Vector<Vector3> &r_points, Vector<int32_t> &r_contours, bool &r_orientation) const {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, false);
 
 	MutexLock lock(fd->mutex);
@@ -1569,7 +1569,7 @@ bool TextServerFallback::font_get_glyph_contours(RID p_font_rid, int p_size, int
 }
 
 Array TextServerFallback::font_get_kerning_list(RID p_font_rid, int p_size) const {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, Array());
 
 	MutexLock lock(fd->mutex);
@@ -1585,7 +1585,7 @@ Array TextServerFallback::font_get_kerning_list(RID p_font_rid, int p_size) cons
 }
 
 void TextServerFallback::font_clear_kerning_map(RID p_font_rid, int p_size) {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -1596,7 +1596,7 @@ void TextServerFallback::font_clear_kerning_map(RID p_font_rid, int p_size) {
 }
 
 void TextServerFallback::font_remove_kerning(RID p_font_rid, int p_size, const Vector2i &p_glyph_pair) {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -1607,7 +1607,7 @@ void TextServerFallback::font_remove_kerning(RID p_font_rid, int p_size, const V
 }
 
 void TextServerFallback::font_set_kerning(RID p_font_rid, int p_size, const Vector2i &p_glyph_pair, const Vector2 &p_kerning) {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -1618,7 +1618,7 @@ void TextServerFallback::font_set_kerning(RID p_font_rid, int p_size, const Vect
 }
 
 Vector2 TextServerFallback::font_get_kerning(RID p_font_rid, int p_size, const Vector2i &p_glyph_pair) const {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, Vector2());
 
 	MutexLock lock(fd->mutex);
@@ -1657,7 +1657,7 @@ int32_t TextServerFallback::font_get_glyph_index(RID p_font_rid, int p_size, cha
 }
 
 bool TextServerFallback::font_has_char(RID p_font_rid, char32_t p_char) const {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, false);
 
 	MutexLock lock(fd->mutex);
@@ -1675,7 +1675,7 @@ bool TextServerFallback::font_has_char(RID p_font_rid, char32_t p_char) const {
 }
 
 String TextServerFallback::font_get_supported_chars(RID p_font_rid) const {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, String());
 
 	MutexLock lock(fd->mutex);
@@ -1709,7 +1709,7 @@ String TextServerFallback::font_get_supported_chars(RID p_font_rid) const {
 }
 
 void TextServerFallback::font_render_range(RID p_font_rid, const Vector2i &p_size, char32_t p_start, char32_t p_end) {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -1721,7 +1721,7 @@ void TextServerFallback::font_render_range(RID p_font_rid, const Vector2i &p_siz
 }
 
 void TextServerFallback::font_render_glyph(RID p_font_rid, const Vector2i &p_size, int32_t p_index) {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -1731,7 +1731,7 @@ void TextServerFallback::font_render_glyph(RID p_font_rid, const Vector2i &p_siz
 }
 
 void TextServerFallback::font_draw_glyph(RID p_font_rid, RID p_canvas, int p_size, const Vector2 &p_pos, int32_t p_index, const Color &p_color) const {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -1771,7 +1771,7 @@ void TextServerFallback::font_draw_glyph(RID p_font_rid, RID p_canvas, int p_siz
 }
 
 void TextServerFallback::font_draw_glyph_outline(RID p_font_rid, RID p_canvas, int p_size, int p_outline_size, const Vector2 &p_pos, int32_t p_index, const Color &p_color) const {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -1811,7 +1811,7 @@ void TextServerFallback::font_draw_glyph_outline(RID p_font_rid, RID p_canvas, i
 }
 
 bool TextServerFallback::font_is_language_supported(RID p_font_rid, const String &p_language) const {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, false);
 
 	MutexLock lock(fd->mutex);
@@ -1823,7 +1823,7 @@ bool TextServerFallback::font_is_language_supported(RID p_font_rid, const String
 }
 
 void TextServerFallback::font_set_language_support_override(RID p_font_rid, const String &p_language, bool p_supported) {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -1831,7 +1831,7 @@ void TextServerFallback::font_set_language_support_override(RID p_font_rid, cons
 }
 
 bool TextServerFallback::font_get_language_support_override(RID p_font_rid, const String &p_language) {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, false);
 
 	MutexLock lock(fd->mutex);
@@ -1839,7 +1839,7 @@ bool TextServerFallback::font_get_language_support_override(RID p_font_rid, cons
 }
 
 void TextServerFallback::font_remove_language_support_override(RID p_font_rid, const String &p_language) {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -1847,7 +1847,7 @@ void TextServerFallback::font_remove_language_support_override(RID p_font_rid, c
 }
 
 Vector<String> TextServerFallback::font_get_language_support_overrides(RID p_font_rid) {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, Vector<String>());
 
 	MutexLock lock(fd->mutex);
@@ -1859,7 +1859,7 @@ Vector<String> TextServerFallback::font_get_language_support_overrides(RID p_fon
 }
 
 bool TextServerFallback::font_is_script_supported(RID p_font_rid, const String &p_script) const {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, false);
 
 	MutexLock lock(fd->mutex);
@@ -1871,7 +1871,7 @@ bool TextServerFallback::font_is_script_supported(RID p_font_rid, const String &
 }
 
 void TextServerFallback::font_set_script_support_override(RID p_font_rid, const String &p_script, bool p_supported) {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -1879,7 +1879,7 @@ void TextServerFallback::font_set_script_support_override(RID p_font_rid, const
 }
 
 bool TextServerFallback::font_get_script_support_override(RID p_font_rid, const String &p_script) {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, false);
 
 	MutexLock lock(fd->mutex);
@@ -1887,7 +1887,7 @@ bool TextServerFallback::font_get_script_support_override(RID p_font_rid, const
 }
 
 void TextServerFallback::font_remove_script_support_override(RID p_font_rid, const String &p_script) {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND(!fd);
 
 	MutexLock lock(fd->mutex);
@@ -1897,7 +1897,7 @@ void TextServerFallback::font_remove_script_support_override(RID p_font_rid, con
 }
 
 Vector<String> TextServerFallback::font_get_script_support_overrides(RID p_font_rid) {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, Vector<String>());
 
 	MutexLock lock(fd->mutex);
@@ -1913,7 +1913,7 @@ Dictionary TextServerFallback::font_supported_feature_list(RID p_font_rid) const
 }
 
 Dictionary TextServerFallback::font_supported_variation_list(RID p_font_rid) const {
-	FontDataFallback *fd = font_owner.getornull(p_font_rid);
+	FontDataFallback *fd = font_owner.get_or_null(p_font_rid);
 	ERR_FAIL_COND_V(!fd, Dictionary());
 
 	MutexLock lock(fd->mutex);
@@ -1944,7 +1944,7 @@ void TextServerFallback::font_set_global_oversampling(real_t p_oversampling) {
 			List<RID> text_bufs;
 			shaped_owner.get_owned_list(&text_bufs);
 			for (const RID &E : text_bufs) {
-				invalidate(shaped_owner.getornull(E));
+				invalidate(shaped_owner.get_or_null(E));
 			}
 		}
 	}
@@ -1969,7 +1969,7 @@ void TextServerFallback::invalidate(ShapedTextData *p_shaped) {
 }
 
 void TextServerFallback::full_copy(ShapedTextData *p_shaped) {
-	ShapedTextData *parent = shaped_owner.getornull(p_shaped->parent);
+	ShapedTextData *parent = shaped_owner.get_or_null(p_shaped->parent);
 
 	for (Map<Variant, ShapedTextData::EmbeddedObject>::Element *E = parent->objects.front(); E; E = E->next()) {
 		if (E->get().pos >= p_shaped->start && E->get().pos < p_shaped->end) {
@@ -2000,7 +2000,7 @@ RID TextServerFallback::create_shaped_text(TextServer::Direction p_direction, Te
 }
 
 void TextServerFallback::shaped_text_clear(RID p_shaped) {
-	ShapedTextData *sd = shaped_owner.getornull(p_shaped);
+	ShapedTextData *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND(!sd);
 
 	MutexLock lock(sd->mutex);
@@ -2024,7 +2024,7 @@ TextServer::Direction TextServerFallback::shaped_text_get_direction(RID p_shaped
 }
 
 void TextServerFallback::shaped_text_set_orientation(RID p_shaped, TextServer::Orientation p_orientation) {
-	ShapedTextData *sd = shaped_owner.getornull(p_shaped);
+	ShapedTextData *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND(!sd);
 
 	MutexLock lock(sd->mutex);
@@ -2042,7 +2042,7 @@ void TextServerFallback::shaped_text_set_bidi_override(RID p_shaped, const Vecto
 }
 
 TextServer::Orientation TextServerFallback::shaped_text_get_orientation(RID p_shaped) const {
-	const ShapedTextData *sd = shaped_owner.getornull(p_shaped);
+	const ShapedTextData *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, TextServer::ORIENTATION_HORIZONTAL);
 
 	MutexLock lock(sd->mutex);
@@ -2050,7 +2050,7 @@ TextServer::Orientation TextServerFallback::shaped_text_get_orientation(RID p_sh
 }
 
 void TextServerFallback::shaped_text_set_preserve_invalid(RID p_shaped, bool p_enabled) {
-	ShapedTextData *sd = shaped_owner.getornull(p_shaped);
+	ShapedTextData *sd = shaped_owner.get_or_null(p_shaped);
 
 	MutexLock lock(sd->mutex);
 	ERR_FAIL_COND(!sd);
@@ -2064,7 +2064,7 @@ void TextServerFallback::shaped_text_set_preserve_invalid(RID p_shaped, bool p_e
 }
 
 bool TextServerFallback::shaped_text_get_preserve_invalid(RID p_shaped) const {
-	const ShapedTextData *sd = shaped_owner.getornull(p_shaped);
+	const ShapedTextData *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, false);
 
 	MutexLock lock(sd->mutex);
@@ -2072,7 +2072,7 @@ bool TextServerFallback::shaped_text_get_preserve_invalid(RID p_shaped) const {
 }
 
 void TextServerFallback::shaped_text_set_preserve_control(RID p_shaped, bool p_enabled) {
-	ShapedTextData *sd = shaped_owner.getornull(p_shaped);
+	ShapedTextData *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND(!sd);
 
 	MutexLock lock(sd->mutex);
@@ -2086,7 +2086,7 @@ void TextServerFallback::shaped_text_set_preserve_control(RID p_shaped, bool p_e
 }
 
 bool TextServerFallback::shaped_text_get_preserve_control(RID p_shaped) const {
-	const ShapedTextData *sd = shaped_owner.getornull(p_shaped);
+	const ShapedTextData *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, false);
 
 	MutexLock lock(sd->mutex);
@@ -2094,14 +2094,14 @@ bool TextServerFallback::shaped_text_get_preserve_control(RID p_shaped) const {
 }
 
 bool TextServerFallback::shaped_text_add_string(RID p_shaped, const String &p_text, const Vector<RID> &p_fonts, int p_size, const Dictionary &p_opentype_features, const String &p_language) {
-	ShapedTextData *sd = shaped_owner.getornull(p_shaped);
+	ShapedTextData *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, false);
 
 	MutexLock lock(sd->mutex);
 	ERR_FAIL_COND_V(p_size <= 0, false);
 
 	for (int i = 0; i < p_fonts.size(); i++) {
-		ERR_FAIL_COND_V(!font_owner.getornull(p_fonts[i]), false);
+		ERR_FAIL_COND_V(!font_owner.get_or_null(p_fonts[i]), false);
 	}
 
 	if (p_text.is_empty()) {
@@ -2141,7 +2141,7 @@ bool TextServerFallback::shaped_text_add_string(RID p_shaped, const String &p_te
 }
 
 bool TextServerFallback::shaped_text_add_object(RID p_shaped, Variant p_key, const Size2 &p_size, InlineAlign p_inline_align, int p_length) {
-	ShapedTextData *sd = shaped_owner.getornull(p_shaped);
+	ShapedTextData *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, false);
 
 	MutexLock lock(sd->mutex);
@@ -2172,7 +2172,7 @@ bool TextServerFallback::shaped_text_add_object(RID p_shaped, Variant p_key, con
 }
 
 bool TextServerFallback::shaped_text_resize_object(RID p_shaped, Variant p_key, const Size2 &p_size, InlineAlign p_inline_align) {
-	ShapedTextData *sd = shaped_owner.getornull(p_shaped);
+	ShapedTextData *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, false);
 
 	MutexLock lock(sd->mutex);
@@ -2305,7 +2305,7 @@ bool TextServerFallback::shaped_text_resize_object(RID p_shaped, Variant p_key,
 }
 
 RID TextServerFallback::shaped_text_substr(RID p_shaped, int p_start, int p_length) const {
-	const ShapedTextData *sd = shaped_owner.getornull(p_shaped);
+	const ShapedTextData *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, RID());
 
 	MutexLock lock(sd->mutex);
@@ -2459,7 +2459,7 @@ RID TextServerFallback::shaped_text_substr(RID p_shaped, int p_start, int p_leng
 }
 
 RID TextServerFallback::shaped_text_get_parent(RID p_shaped) const {
-	ShapedTextData *sd = shaped_owner.getornull(p_shaped);
+	ShapedTextData *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, RID());
 
 	MutexLock lock(sd->mutex);
@@ -2467,7 +2467,7 @@ RID TextServerFallback::shaped_text_get_parent(RID p_shaped) const {
 }
 
 real_t TextServerFallback::shaped_text_fit_to_width(RID p_shaped, real_t p_width, uint8_t /*JustificationFlag*/ p_jst_flags) {
-	ShapedTextData *sd = shaped_owner.getornull(p_shaped);
+	ShapedTextData *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, 0.f);
 
 	MutexLock lock(sd->mutex);
@@ -2547,7 +2547,7 @@ real_t TextServerFallback::shaped_text_fit_to_width(RID p_shaped, real_t p_width
 }
 
 real_t TextServerFallback::shaped_text_tab_align(RID p_shaped, const Vector<real_t> &p_tab_stops) {
-	ShapedTextData *sd = shaped_owner.getornull(p_shaped);
+	ShapedTextData *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, 0.f);
 
 	MutexLock lock(sd->mutex);
@@ -2597,7 +2597,7 @@ real_t TextServerFallback::shaped_text_tab_align(RID p_shaped, const Vector<real
 }
 
 bool TextServerFallback::shaped_text_update_breaks(RID p_shaped) {
-	ShapedTextData *sd = shaped_owner.getornull(p_shaped);
+	ShapedTextData *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, false);
 
 	MutexLock lock(sd->mutex);
@@ -2638,7 +2638,7 @@ bool TextServerFallback::shaped_text_update_breaks(RID p_shaped) {
 }
 
 bool TextServerFallback::shaped_text_update_justification_ops(RID p_shaped) {
-	ShapedTextData *sd = shaped_owner.getornull(p_shaped);
+	ShapedTextData *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, false);
 
 	MutexLock lock(sd->mutex);
@@ -2654,7 +2654,7 @@ bool TextServerFallback::shaped_text_update_justification_ops(RID p_shaped) {
 }
 
 void TextServerFallback::shaped_text_overrun_trim_to_width(RID p_shaped_line, real_t p_width, uint8_t p_trim_flags) {
-	ShapedTextData *sd = shaped_owner.getornull(p_shaped_line);
+	ShapedTextData *sd = shaped_owner.get_or_null(p_shaped_line);
 	ERR_FAIL_COND_MSG(!sd, "ShapedTextDataFallback invalid.");
 
 	MutexLock lock(sd->mutex);
@@ -2771,7 +2771,7 @@ void TextServerFallback::shaped_text_overrun_trim_to_width(RID p_shaped_line, re
 }
 
 TextServer::TrimData TextServerFallback::shaped_text_get_trim_data(RID p_shaped) const {
-	ShapedTextData *sd = shaped_owner.getornull(p_shaped);
+	ShapedTextData *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V_MSG(!sd, TrimData(), "ShapedTextDataFallback invalid.");
 
 	MutexLock lock(sd->mutex);
@@ -2779,7 +2779,7 @@ TextServer::TrimData TextServerFallback::shaped_text_get_trim_data(RID p_shaped)
 }
 
 bool TextServerFallback::shaped_text_shape(RID p_shaped) {
-	ShapedTextData *sd = shaped_owner.getornull(p_shaped);
+	ShapedTextData *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, false);
 
 	MutexLock lock(sd->mutex);
@@ -2973,7 +2973,7 @@ bool TextServerFallback::shaped_text_shape(RID p_shaped) {
 }
 
 bool TextServerFallback::shaped_text_is_ready(RID p_shaped) const {
-	const ShapedTextData *sd = shaped_owner.getornull(p_shaped);
+	const ShapedTextData *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, false);
 
 	MutexLock lock(sd->mutex);
@@ -2981,7 +2981,7 @@ bool TextServerFallback::shaped_text_is_ready(RID p_shaped) const {
 }
 
 Vector<TextServer::Glyph> TextServerFallback::shaped_text_get_glyphs(RID p_shaped) const {
-	const ShapedTextData *sd = shaped_owner.getornull(p_shaped);
+	const ShapedTextData *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, Vector<TextServer::Glyph>());
 
 	MutexLock lock(sd->mutex);
@@ -2992,7 +2992,7 @@ Vector<TextServer::Glyph> TextServerFallback::shaped_text_get_glyphs(RID p_shape
 }
 
 Vector2i TextServerFallback::shaped_text_get_range(RID p_shaped) const {
-	const ShapedTextData *sd = shaped_owner.getornull(p_shaped);
+	const ShapedTextData *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, Vector2i());
 
 	MutexLock lock(sd->mutex);
@@ -3000,7 +3000,7 @@ Vector2i TextServerFallback::shaped_text_get_range(RID p_shaped) const {
 }
 
 Vector<TextServer::Glyph> TextServerFallback::shaped_text_sort_logical(RID p_shaped) {
-	const ShapedTextData *sd = shaped_owner.getornull(p_shaped);
+	const ShapedTextData *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, Vector<TextServer::Glyph>());
 
 	MutexLock lock(sd->mutex);
@@ -3013,7 +3013,7 @@ Vector<TextServer::Glyph> TextServerFallback::shaped_text_sort_logical(RID p_sha
 
 Array TextServerFallback::shaped_text_get_objects(RID p_shaped) const {
 	Array ret;
-	const ShapedTextData *sd = shaped_owner.getornull(p_shaped);
+	const ShapedTextData *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, ret);
 
 	MutexLock lock(sd->mutex);
@@ -3025,7 +3025,7 @@ Array TextServerFallback::shaped_text_get_objects(RID p_shaped) const {
 }
 
 Rect2 TextServerFallback::shaped_text_get_object_rect(RID p_shaped, Variant p_key) const {
-	const ShapedTextData *sd = shaped_owner.getornull(p_shaped);
+	const ShapedTextData *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, Rect2());
 
 	MutexLock lock(sd->mutex);
@@ -3037,7 +3037,7 @@ Rect2 TextServerFallback::shaped_text_get_object_rect(RID p_shaped, Variant p_ke
 }
 
 Size2 TextServerFallback::shaped_text_get_size(RID p_shaped) const {
-	const ShapedTextData *sd = shaped_owner.getornull(p_shaped);
+	const ShapedTextData *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, Size2());
 
 	MutexLock lock(sd->mutex);
@@ -3052,7 +3052,7 @@ Size2 TextServerFallback::shaped_text_get_size(RID p_shaped) const {
 }
 
 real_t TextServerFallback::shaped_text_get_ascent(RID p_shaped) const {
-	const ShapedTextData *sd = shaped_owner.getornull(p_shaped);
+	const ShapedTextData *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, 0.f);
 
 	MutexLock lock(sd->mutex);
@@ -3063,7 +3063,7 @@ real_t TextServerFallback::shaped_text_get_ascent(RID p_shaped) const {
 }
 
 real_t TextServerFallback::shaped_text_get_descent(RID p_shaped) const {
-	const ShapedTextData *sd = shaped_owner.getornull(p_shaped);
+	const ShapedTextData *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, 0.f);
 
 	MutexLock lock(sd->mutex);
@@ -3074,7 +3074,7 @@ real_t TextServerFallback::shaped_text_get_descent(RID p_shaped) const {
 }
 
 real_t TextServerFallback::shaped_text_get_width(RID p_shaped) const {
-	const ShapedTextData *sd = shaped_owner.getornull(p_shaped);
+	const ShapedTextData *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, 0.f);
 
 	MutexLock lock(sd->mutex);
@@ -3085,7 +3085,7 @@ real_t TextServerFallback::shaped_text_get_width(RID p_shaped) const {
 }
 
 real_t TextServerFallback::shaped_text_get_underline_position(RID p_shaped) const {
-	const ShapedTextData *sd = shaped_owner.getornull(p_shaped);
+	const ShapedTextData *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, 0.f);
 
 	MutexLock lock(sd->mutex);
@@ -3097,7 +3097,7 @@ real_t TextServerFallback::shaped_text_get_underline_position(RID p_shaped) cons
 }
 
 real_t TextServerFallback::shaped_text_get_underline_thickness(RID p_shaped) const {
-	const ShapedTextData *sd = shaped_owner.getornull(p_shaped);
+	const ShapedTextData *sd = shaped_owner.get_or_null(p_shaped);
 	ERR_FAIL_COND_V(!sd, 0.f);
 
 	MutexLock lock(sd->mutex);
diff --git a/servers/physics_2d/body_direct_state_2d_sw.cpp b/servers/physics_2d/body_direct_state_2d_sw.cpp
index 1e924a831e..22a5fc2b36 100644
--- a/servers/physics_2d/body_direct_state_2d_sw.cpp
+++ b/servers/physics_2d/body_direct_state_2d_sw.cpp
@@ -175,7 +175,7 @@ Variant PhysicsDirectBodyState2DSW::get_contact_collider_shape_metadata(int p_co
 	if (!PhysicsServer2DSW::singletonsw->body_owner.owns(body->contacts[p_contact_idx].collider)) {
 		return Variant();
 	}
-	Body2DSW *other = PhysicsServer2DSW::singletonsw->body_owner.getornull(body->contacts[p_contact_idx].collider);
+	Body2DSW *other = PhysicsServer2DSW::singletonsw->body_owner.get_or_null(body->contacts[p_contact_idx].collider);
 
 	int sidx = body->contacts[p_contact_idx].collider_shape;
 	if (sidx < 0 || sidx >= other->get_shape_count()) {
diff --git a/servers/physics_2d/physics_server_2d_sw.cpp b/servers/physics_2d/physics_server_2d_sw.cpp
index e052258a92..b4338217df 100644
--- a/servers/physics_2d/physics_server_2d_sw.cpp
+++ b/servers/physics_2d/physics_server_2d_sw.cpp
@@ -112,32 +112,32 @@ RID PhysicsServer2DSW::concave_polygon_shape_create() {
 }
 
 void PhysicsServer2DSW::shape_set_data(RID p_shape, const Variant &p_data) {
-	Shape2DSW *shape = shape_owner.getornull(p_shape);
+	Shape2DSW *shape = shape_owner.get_or_null(p_shape);
 	ERR_FAIL_COND(!shape);
 	shape->set_data(p_data);
 };
 
 void PhysicsServer2DSW::shape_set_custom_solver_bias(RID p_shape, real_t p_bias) {
-	Shape2DSW *shape = shape_owner.getornull(p_shape);
+	Shape2DSW *shape = shape_owner.get_or_null(p_shape);
 	ERR_FAIL_COND(!shape);
 	shape->set_custom_bias(p_bias);
 }
 
 PhysicsServer2D::ShapeType PhysicsServer2DSW::shape_get_type(RID p_shape) const {
-	const Shape2DSW *shape = shape_owner.getornull(p_shape);
+	const Shape2DSW *shape = shape_owner.get_or_null(p_shape);
 	ERR_FAIL_COND_V(!shape, SHAPE_CUSTOM);
 	return shape->get_type();
 };
 
 Variant PhysicsServer2DSW::shape_get_data(RID p_shape) const {
-	const Shape2DSW *shape = shape_owner.getornull(p_shape);
+	const Shape2DSW *shape = shape_owner.get_or_null(p_shape);
 	ERR_FAIL_COND_V(!shape, Variant());
 	ERR_FAIL_COND_V(!shape->is_configured(), Variant());
 	return shape->get_data();
 };
 
 real_t PhysicsServer2DSW::shape_get_custom_solver_bias(RID p_shape) const {
-	const Shape2DSW *shape = shape_owner.getornull(p_shape);
+	const Shape2DSW *shape = shape_owner.get_or_null(p_shape);
 	ERR_FAIL_COND_V(!shape, 0);
 	return shape->get_custom_bias();
 }
@@ -193,9 +193,9 @@ void PhysicsServer2DSW::_shape_col_cbk(const Vector2 &p_point_A, const Vector2 &
 }
 
 bool PhysicsServer2DSW::shape_collide(RID p_shape_A, const Transform2D &p_xform_A, const Vector2 &p_motion_A, RID p_shape_B, const Transform2D &p_xform_B, const Vector2 &p_motion_B, Vector2 *r_results, int p_result_max, int &r_result_count) {
-	Shape2DSW *shape_A = shape_owner.getornull(p_shape_A);
+	Shape2DSW *shape_A = shape_owner.get_or_null(p_shape_A);
 	ERR_FAIL_COND_V(!shape_A, false);
-	Shape2DSW *shape_B = shape_owner.getornull(p_shape_B);
+	Shape2DSW *shape_B = shape_owner.get_or_null(p_shape_B);
 	ERR_FAIL_COND_V(!shape_B, false);
 
 	if (p_result_max == 0) {
@@ -218,7 +218,7 @@ RID PhysicsServer2DSW::space_create() {
 	RID id = space_owner.make_rid(space);
 	space->set_self(id);
 	RID area_id = area_create();
-	Area2DSW *area = area_owner.getornull(area_id);
+	Area2DSW *area = area_owner.get_or_null(area_id);
 	ERR_FAIL_COND_V(!area, RID());
 	space->set_default_area(area);
 	area->set_space(space);
@@ -228,7 +228,7 @@ RID PhysicsServer2DSW::space_create() {
 };
 
 void PhysicsServer2DSW::space_set_active(RID p_space, bool p_active) {
-	Space2DSW *space = space_owner.getornull(p_space);
+	Space2DSW *space = space_owner.get_or_null(p_space);
 	ERR_FAIL_COND(!space);
 	if (p_active) {
 		active_spaces.insert(space);
@@ -238,45 +238,45 @@ void PhysicsServer2DSW::space_set_active(RID p_space, bool p_active) {
 }
 
 bool PhysicsServer2DSW::space_is_active(RID p_space) const {
-	const Space2DSW *space = space_owner.getornull(p_space);
+	const Space2DSW *space = space_owner.get_or_null(p_space);
 	ERR_FAIL_COND_V(!space, false);
 
 	return active_spaces.has(space);
 }
 
 void PhysicsServer2DSW::space_set_param(RID p_space, SpaceParameter p_param, real_t p_value) {
-	Space2DSW *space = space_owner.getornull(p_space);
+	Space2DSW *space = space_owner.get_or_null(p_space);
 	ERR_FAIL_COND(!space);
 
 	space->set_param(p_param, p_value);
 }
 
 real_t PhysicsServer2DSW::space_get_param(RID p_space, SpaceParameter p_param) const {
-	const Space2DSW *space = space_owner.getornull(p_space);
+	const Space2DSW *space = space_owner.get_or_null(p_space);
 	ERR_FAIL_COND_V(!space, 0);
 	return space->get_param(p_param);
 }
 
 void PhysicsServer2DSW::space_set_debug_contacts(RID p_space, int p_max_contacts) {
-	Space2DSW *space = space_owner.getornull(p_space);
+	Space2DSW *space = space_owner.get_or_null(p_space);
 	ERR_FAIL_COND(!space);
 	space->set_debug_contacts(p_max_contacts);
 }
 
 Vector<Vector2> PhysicsServer2DSW::space_get_contacts(RID p_space) const {
-	Space2DSW *space = space_owner.getornull(p_space);
+	Space2DSW *space = space_owner.get_or_null(p_space);
 	ERR_FAIL_COND_V(!space, Vector<Vector2>());
 	return space->get_debug_contacts();
 }
 
 int PhysicsServer2DSW::space_get_contact_count(RID p_space) const {
-	Space2DSW *space = space_owner.getornull(p_space);
+	Space2DSW *space = space_owner.get_or_null(p_space);
 	ERR_FAIL_COND_V(!space, 0);
 	return space->get_debug_contact_count();
 }
 
 PhysicsDirectSpaceState2D *PhysicsServer2DSW::space_get_direct_state(RID p_space) {
-	Space2DSW *space = space_owner.getornull(p_space);
+	Space2DSW *space = space_owner.get_or_null(p_space);
 	ERR_FAIL_COND_V(!space, nullptr);
 	ERR_FAIL_COND_V_MSG((using_threads && !doing_sync) || space->is_locked(), nullptr, "Space state is inaccessible right now, wait for iteration or physics process notification.");
 
@@ -291,12 +291,12 @@ RID PhysicsServer2DSW::area_create() {
 };
 
 void PhysicsServer2DSW::area_set_space(RID p_area, RID p_space) {
-	Area2DSW *area = area_owner.getornull(p_area);
+	Area2DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 
 	Space2DSW *space = nullptr;
 	if (p_space.is_valid()) {
-		space = space_owner.getornull(p_space);
+		space = space_owner.get_or_null(p_space);
 		ERR_FAIL_COND(!space);
 	}
 
@@ -309,7 +309,7 @@ void PhysicsServer2DSW::area_set_space(RID p_area, RID p_space) {
 };
 
 RID PhysicsServer2DSW::area_get_space(RID p_area) const {
-	Area2DSW *area = area_owner.getornull(p_area);
+	Area2DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND_V(!area, RID());
 
 	Space2DSW *space = area->get_space();
@@ -320,34 +320,34 @@ RID PhysicsServer2DSW::area_get_space(RID p_area) const {
 };
 
 void PhysicsServer2DSW::area_set_space_override_mode(RID p_area, AreaSpaceOverrideMode p_mode) {
-	Area2DSW *area = area_owner.getornull(p_area);
+	Area2DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 
 	area->set_space_override_mode(p_mode);
 }
 
 PhysicsServer2D::AreaSpaceOverrideMode PhysicsServer2DSW::area_get_space_override_mode(RID p_area) const {
-	const Area2DSW *area = area_owner.getornull(p_area);
+	const Area2DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND_V(!area, AREA_SPACE_OVERRIDE_DISABLED);
 
 	return area->get_space_override_mode();
 }
 
 void PhysicsServer2DSW::area_add_shape(RID p_area, RID p_shape, const Transform2D &p_transform, bool p_disabled) {
-	Area2DSW *area = area_owner.getornull(p_area);
+	Area2DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 
-	Shape2DSW *shape = shape_owner.getornull(p_shape);
+	Shape2DSW *shape = shape_owner.get_or_null(p_shape);
 	ERR_FAIL_COND(!shape);
 
 	area->add_shape(shape, p_transform, p_disabled);
 }
 
 void PhysicsServer2DSW::area_set_shape(RID p_area, int p_shape_idx, RID p_shape) {
-	Area2DSW *area = area_owner.getornull(p_area);
+	Area2DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 
-	Shape2DSW *shape = shape_owner.getornull(p_shape);
+	Shape2DSW *shape = shape_owner.get_or_null(p_shape);
 	ERR_FAIL_COND(!shape);
 	ERR_FAIL_COND(!shape->is_configured());
 
@@ -355,14 +355,14 @@ void PhysicsServer2DSW::area_set_shape(RID p_area, int p_shape_idx, RID p_shape)
 }
 
 void PhysicsServer2DSW::area_set_shape_transform(RID p_area, int p_shape_idx, const Transform2D &p_transform) {
-	Area2DSW *area = area_owner.getornull(p_area);
+	Area2DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 
 	area->set_shape_transform(p_shape_idx, p_transform);
 }
 
 void PhysicsServer2DSW::area_set_shape_disabled(RID p_area, int p_shape, bool p_disabled) {
-	Area2DSW *area = area_owner.getornull(p_area);
+	Area2DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 	ERR_FAIL_INDEX(p_shape, area->get_shape_count());
 	FLUSH_QUERY_CHECK(area);
@@ -371,14 +371,14 @@ void PhysicsServer2DSW::area_set_shape_disabled(RID p_area, int p_shape, bool p_
 }
 
 int PhysicsServer2DSW::area_get_shape_count(RID p_area) const {
-	Area2DSW *area = area_owner.getornull(p_area);
+	Area2DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND_V(!area, -1);
 
 	return area->get_shape_count();
 }
 
 RID PhysicsServer2DSW::area_get_shape(RID p_area, int p_shape_idx) const {
-	Area2DSW *area = area_owner.getornull(p_area);
+	Area2DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND_V(!area, RID());
 
 	Shape2DSW *shape = area->get_shape(p_shape_idx);
@@ -388,21 +388,21 @@ RID PhysicsServer2DSW::area_get_shape(RID p_area, int p_shape_idx) const {
 }
 
 Transform2D PhysicsServer2DSW::area_get_shape_transform(RID p_area, int p_shape_idx) const {
-	Area2DSW *area = area_owner.getornull(p_area);
+	Area2DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND_V(!area, Transform2D());
 
 	return area->get_shape_transform(p_shape_idx);
 }
 
 void PhysicsServer2DSW::area_remove_shape(RID p_area, int p_shape_idx) {
-	Area2DSW *area = area_owner.getornull(p_area);
+	Area2DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 
 	area->remove_shape(p_shape_idx);
 }
 
 void PhysicsServer2DSW::area_clear_shapes(RID p_area) {
-	Area2DSW *area = area_owner.getornull(p_area);
+	Area2DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 
 	while (area->get_shape_count()) {
@@ -412,86 +412,86 @@ void PhysicsServer2DSW::area_clear_shapes(RID p_area) {
 
 void PhysicsServer2DSW::area_attach_object_instance_id(RID p_area, ObjectID p_id) {
 	if (space_owner.owns(p_area)) {
-		Space2DSW *space = space_owner.getornull(p_area);
+		Space2DSW *space = space_owner.get_or_null(p_area);
 		p_area = space->get_default_area()->get_self();
 	}
-	Area2DSW *area = area_owner.getornull(p_area);
+	Area2DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 	area->set_instance_id(p_id);
 }
 
 ObjectID PhysicsServer2DSW::area_get_object_instance_id(RID p_area) const {
 	if (space_owner.owns(p_area)) {
-		Space2DSW *space = space_owner.getornull(p_area);
+		Space2DSW *space = space_owner.get_or_null(p_area);
 		p_area = space->get_default_area()->get_self();
 	}
-	Area2DSW *area = area_owner.getornull(p_area);
+	Area2DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND_V(!area, ObjectID());
 	return area->get_instance_id();
 }
 
 void PhysicsServer2DSW::area_attach_canvas_instance_id(RID p_area, ObjectID p_id) {
 	if (space_owner.owns(p_area)) {
-		Space2DSW *space = space_owner.getornull(p_area);
+		Space2DSW *space = space_owner.get_or_null(p_area);
 		p_area = space->get_default_area()->get_self();
 	}
-	Area2DSW *area = area_owner.getornull(p_area);
+	Area2DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 	area->set_canvas_instance_id(p_id);
 }
 
 ObjectID PhysicsServer2DSW::area_get_canvas_instance_id(RID p_area) const {
 	if (space_owner.owns(p_area)) {
-		Space2DSW *space = space_owner.getornull(p_area);
+		Space2DSW *space = space_owner.get_or_null(p_area);
 		p_area = space->get_default_area()->get_self();
 	}
-	Area2DSW *area = area_owner.getornull(p_area);
+	Area2DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND_V(!area, ObjectID());
 	return area->get_canvas_instance_id();
 }
 
 void PhysicsServer2DSW::area_set_param(RID p_area, AreaParameter p_param, const Variant &p_value) {
 	if (space_owner.owns(p_area)) {
-		Space2DSW *space = space_owner.getornull(p_area);
+		Space2DSW *space = space_owner.get_or_null(p_area);
 		p_area = space->get_default_area()->get_self();
 	}
-	Area2DSW *area = area_owner.getornull(p_area);
+	Area2DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 	area->set_param(p_param, p_value);
 };
 
 void PhysicsServer2DSW::area_set_transform(RID p_area, const Transform2D &p_transform) {
-	Area2DSW *area = area_owner.getornull(p_area);
+	Area2DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 	area->set_transform(p_transform);
 };
 
 Variant PhysicsServer2DSW::area_get_param(RID p_area, AreaParameter p_param) const {
 	if (space_owner.owns(p_area)) {
-		Space2DSW *space = space_owner.getornull(p_area);
+		Space2DSW *space = space_owner.get_or_null(p_area);
 		p_area = space->get_default_area()->get_self();
 	}
-	Area2DSW *area = area_owner.getornull(p_area);
+	Area2DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND_V(!area, Variant());
 
 	return area->get_param(p_param);
 };
 
 Transform2D PhysicsServer2DSW::area_get_transform(RID p_area) const {
-	Area2DSW *area = area_owner.getornull(p_area);
+	Area2DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND_V(!area, Transform2D());
 
 	return area->get_transform();
 };
 
 void PhysicsServer2DSW::area_set_pickable(RID p_area, bool p_pickable) {
-	Area2DSW *area = area_owner.getornull(p_area);
+	Area2DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 	area->set_pickable(p_pickable);
 }
 
 void PhysicsServer2DSW::area_set_monitorable(RID p_area, bool p_monitorable) {
-	Area2DSW *area = area_owner.getornull(p_area);
+	Area2DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 	FLUSH_QUERY_CHECK(area);
 
@@ -499,28 +499,28 @@ void PhysicsServer2DSW::area_set_monitorable(RID p_area, bool p_monitorable) {
 }
 
 void PhysicsServer2DSW::area_set_collision_mask(RID p_area, uint32_t p_mask) {
-	Area2DSW *area = area_owner.getornull(p_area);
+	Area2DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 
 	area->set_collision_mask(p_mask);
 }
 
 void PhysicsServer2DSW::area_set_collision_layer(RID p_area, uint32_t p_layer) {
-	Area2DSW *area = area_owner.getornull(p_area);
+	Area2DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 
 	area->set_collision_layer(p_layer);
 }
 
 void PhysicsServer2DSW::area_set_monitor_callback(RID p_area, Object *p_receiver, const StringName &p_method) {
-	Area2DSW *area = area_owner.getornull(p_area);
+	Area2DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 
 	area->set_monitor_callback(p_receiver ? p_receiver->get_instance_id() : ObjectID(), p_method);
 }
 
 void PhysicsServer2DSW::area_set_area_monitor_callback(RID p_area, Object *p_receiver, const StringName &p_method) {
-	Area2DSW *area = area_owner.getornull(p_area);
+	Area2DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 
 	area->set_area_monitor_callback(p_receiver ? p_receiver->get_instance_id() : ObjectID(), p_method);
@@ -536,11 +536,11 @@ RID PhysicsServer2DSW::body_create() {
 }
 
 void PhysicsServer2DSW::body_set_space(RID p_body, RID p_space) {
-	Body2DSW *body = body_owner.getornull(p_body);
+	Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 	Space2DSW *space = nullptr;
 	if (p_space.is_valid()) {
-		space = space_owner.getornull(p_space);
+		space = space_owner.get_or_null(p_space);
 		ERR_FAIL_COND(!space);
 	}
 
@@ -553,7 +553,7 @@ void PhysicsServer2DSW::body_set_space(RID p_body, RID p_space) {
 };
 
 RID PhysicsServer2DSW::body_get_space(RID p_body) const {
-	Body2DSW *body = body_owner.getornull(p_body);
+	Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, RID());
 
 	Space2DSW *space = body->get_space();
@@ -564,7 +564,7 @@ RID PhysicsServer2DSW::body_get_space(RID p_body) const {
 };
 
 void PhysicsServer2DSW::body_set_mode(RID p_body, BodyMode p_mode) {
-	Body2DSW *body = body_owner.getornull(p_body);
+	Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 	FLUSH_QUERY_CHECK(body);
 
@@ -572,27 +572,27 @@ void PhysicsServer2DSW::body_set_mode(RID p_body, BodyMode p_mode) {
 };
 
 PhysicsServer2D::BodyMode PhysicsServer2DSW::body_get_mode(RID p_body) const {
-	Body2DSW *body = body_owner.getornull(p_body);
+	Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, BODY_MODE_STATIC);
 
 	return body->get_mode();
 };
 
 void PhysicsServer2DSW::body_add_shape(RID p_body, RID p_shape, const Transform2D &p_transform, bool p_disabled) {
-	Body2DSW *body = body_owner.getornull(p_body);
+	Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
-	Shape2DSW *shape = shape_owner.getornull(p_shape);
+	Shape2DSW *shape = shape_owner.get_or_null(p_shape);
 	ERR_FAIL_COND(!shape);
 
 	body->add_shape(shape, p_transform, p_disabled);
 }
 
 void PhysicsServer2DSW::body_set_shape(RID p_body, int p_shape_idx, RID p_shape) {
-	Body2DSW *body = body_owner.getornull(p_body);
+	Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
-	Shape2DSW *shape = shape_owner.getornull(p_shape);
+	Shape2DSW *shape = shape_owner.get_or_null(p_shape);
 	ERR_FAIL_COND(!shape);
 	ERR_FAIL_COND(!shape->is_configured());
 
@@ -600,33 +600,33 @@ void PhysicsServer2DSW::body_set_shape(RID p_body, int p_shape_idx, RID p_shape)
 }
 
 void PhysicsServer2DSW::body_set_shape_transform(RID p_body, int p_shape_idx, const Transform2D &p_transform) {
-	Body2DSW *body = body_owner.getornull(p_body);
+	Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_shape_transform(p_shape_idx, p_transform);
 }
 
 void PhysicsServer2DSW::body_set_shape_metadata(RID p_body, int p_shape_idx, const Variant &p_metadata) {
-	Body2DSW *body = body_owner.getornull(p_body);
+	Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 	body->set_shape_metadata(p_shape_idx, p_metadata);
 }
 
 Variant PhysicsServer2DSW::body_get_shape_metadata(RID p_body, int p_shape_idx) const {
-	Body2DSW *body = body_owner.getornull(p_body);
+	Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, Variant());
 	return body->get_shape_metadata(p_shape_idx);
 }
 
 int PhysicsServer2DSW::body_get_shape_count(RID p_body) const {
-	Body2DSW *body = body_owner.getornull(p_body);
+	Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, -1);
 
 	return body->get_shape_count();
 }
 
 RID PhysicsServer2DSW::body_get_shape(RID p_body, int p_shape_idx) const {
-	Body2DSW *body = body_owner.getornull(p_body);
+	Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, RID());
 
 	Shape2DSW *shape = body->get_shape(p_shape_idx);
@@ -636,21 +636,21 @@ RID PhysicsServer2DSW::body_get_shape(RID p_body, int p_shape_idx) const {
 }
 
 Transform2D PhysicsServer2DSW::body_get_shape_transform(RID p_body, int p_shape_idx) const {
-	Body2DSW *body = body_owner.getornull(p_body);
+	Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, Transform2D());
 
 	return body->get_shape_transform(p_shape_idx);
 }
 
 void PhysicsServer2DSW::body_remove_shape(RID p_body, int p_shape_idx) {
-	Body2DSW *body = body_owner.getornull(p_body);
+	Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->remove_shape(p_shape_idx);
 }
 
 void PhysicsServer2DSW::body_clear_shapes(RID p_body) {
-	Body2DSW *body = body_owner.getornull(p_body);
+	Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	while (body->get_shape_count()) {
@@ -659,7 +659,7 @@ void PhysicsServer2DSW::body_clear_shapes(RID p_body) {
 }
 
 void PhysicsServer2DSW::body_set_shape_disabled(RID p_body, int p_shape_idx, bool p_disabled) {
-	Body2DSW *body = body_owner.getornull(p_body);
+	Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 	ERR_FAIL_INDEX(p_shape_idx, body->get_shape_count());
 	FLUSH_QUERY_CHECK(body);
@@ -668,7 +668,7 @@ void PhysicsServer2DSW::body_set_shape_disabled(RID p_body, int p_shape_idx, boo
 }
 
 void PhysicsServer2DSW::body_set_shape_as_one_way_collision(RID p_body, int p_shape_idx, bool p_enable, real_t p_margin) {
-	Body2DSW *body = body_owner.getornull(p_body);
+	Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 	ERR_FAIL_INDEX(p_shape_idx, body->get_shape_count());
 	FLUSH_QUERY_CHECK(body);
@@ -677,109 +677,109 @@ void PhysicsServer2DSW::body_set_shape_as_one_way_collision(RID p_body, int p_sh
 }
 
 void PhysicsServer2DSW::body_set_continuous_collision_detection_mode(RID p_body, CCDMode p_mode) {
-	Body2DSW *body = body_owner.getornull(p_body);
+	Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 	body->set_continuous_collision_detection_mode(p_mode);
 }
 
 PhysicsServer2DSW::CCDMode PhysicsServer2DSW::body_get_continuous_collision_detection_mode(RID p_body) const {
-	const Body2DSW *body = body_owner.getornull(p_body);
+	const Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, CCD_MODE_DISABLED);
 
 	return body->get_continuous_collision_detection_mode();
 }
 
 void PhysicsServer2DSW::body_attach_object_instance_id(RID p_body, ObjectID p_id) {
-	Body2DSW *body = body_owner.getornull(p_body);
+	Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_instance_id(p_id);
 };
 
 ObjectID PhysicsServer2DSW::body_get_object_instance_id(RID p_body) const {
-	Body2DSW *body = body_owner.getornull(p_body);
+	Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, ObjectID());
 
 	return body->get_instance_id();
 };
 
 void PhysicsServer2DSW::body_attach_canvas_instance_id(RID p_body, ObjectID p_id) {
-	Body2DSW *body = body_owner.getornull(p_body);
+	Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_canvas_instance_id(p_id);
 };
 
 ObjectID PhysicsServer2DSW::body_get_canvas_instance_id(RID p_body) const {
-	Body2DSW *body = body_owner.getornull(p_body);
+	Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, ObjectID());
 
 	return body->get_canvas_instance_id();
 };
 
 void PhysicsServer2DSW::body_set_collision_layer(RID p_body, uint32_t p_layer) {
-	Body2DSW *body = body_owner.getornull(p_body);
+	Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 	body->set_collision_layer(p_layer);
 };
 
 uint32_t PhysicsServer2DSW::body_get_collision_layer(RID p_body) const {
-	Body2DSW *body = body_owner.getornull(p_body);
+	Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, 0);
 
 	return body->get_collision_layer();
 };
 
 void PhysicsServer2DSW::body_set_collision_mask(RID p_body, uint32_t p_mask) {
-	Body2DSW *body = body_owner.getornull(p_body);
+	Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 	body->set_collision_mask(p_mask);
 };
 
 uint32_t PhysicsServer2DSW::body_get_collision_mask(RID p_body) const {
-	Body2DSW *body = body_owner.getornull(p_body);
+	Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, 0);
 
 	return body->get_collision_mask();
 };
 
 void PhysicsServer2DSW::body_set_param(RID p_body, BodyParameter p_param, const Variant &p_value) {
-	Body2DSW *body = body_owner.getornull(p_body);
+	Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_param(p_param, p_value);
 };
 
 Variant PhysicsServer2DSW::body_get_param(RID p_body, BodyParameter p_param) const {
-	Body2DSW *body = body_owner.getornull(p_body);
+	Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, 0);
 
 	return body->get_param(p_param);
 };
 
 void PhysicsServer2DSW::body_reset_mass_properties(RID p_body) {
-	Body2DSW *body = body_owner.getornull(p_body);
+	Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	return body->reset_mass_properties();
 }
 
 void PhysicsServer2DSW::body_set_state(RID p_body, BodyState p_state, const Variant &p_variant) {
-	Body2DSW *body = body_owner.getornull(p_body);
+	Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_state(p_state, p_variant);
 };
 
 Variant PhysicsServer2DSW::body_get_state(RID p_body, BodyState p_state) const {
-	Body2DSW *body = body_owner.getornull(p_body);
+	Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, Variant());
 
 	return body->get_state(p_state);
 };
 
 void PhysicsServer2DSW::body_set_applied_force(RID p_body, const Vector2 &p_force) {
-	Body2DSW *body = body_owner.getornull(p_body);
+	Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_applied_force(p_force);
@@ -787,13 +787,13 @@ void PhysicsServer2DSW::body_set_applied_force(RID p_body, const Vector2 &p_forc
 };
 
 Vector2 PhysicsServer2DSW::body_get_applied_force(RID p_body) const {
-	Body2DSW *body = body_owner.getornull(p_body);
+	Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, Vector2());
 	return body->get_applied_force();
 };
 
 void PhysicsServer2DSW::body_set_applied_torque(RID p_body, real_t p_torque) {
-	Body2DSW *body = body_owner.getornull(p_body);
+	Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_applied_torque(p_torque);
@@ -801,14 +801,14 @@ void PhysicsServer2DSW::body_set_applied_torque(RID p_body, real_t p_torque) {
 };
 
 real_t PhysicsServer2DSW::body_get_applied_torque(RID p_body) const {
-	Body2DSW *body = body_owner.getornull(p_body);
+	Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, 0);
 
 	return body->get_applied_torque();
 };
 
 void PhysicsServer2DSW::body_apply_central_impulse(RID p_body, const Vector2 &p_impulse) {
-	Body2DSW *body = body_owner.getornull(p_body);
+	Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->apply_central_impulse(p_impulse);
@@ -816,7 +816,7 @@ void PhysicsServer2DSW::body_apply_central_impulse(RID p_body, const Vector2 &p_
 }
 
 void PhysicsServer2DSW::body_apply_torque_impulse(RID p_body, real_t p_torque) {
-	Body2DSW *body = body_owner.getornull(p_body);
+	Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	_update_shapes();
@@ -826,7 +826,7 @@ void PhysicsServer2DSW::body_apply_torque_impulse(RID p_body, real_t p_torque) {
 }
 
 void PhysicsServer2DSW::body_apply_impulse(RID p_body, const Vector2 &p_impulse, const Vector2 &p_position) {
-	Body2DSW *body = body_owner.getornull(p_body);
+	Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	_update_shapes();
@@ -836,7 +836,7 @@ void PhysicsServer2DSW::body_apply_impulse(RID p_body, const Vector2 &p_impulse,
 };
 
 void PhysicsServer2DSW::body_add_central_force(RID p_body, const Vector2 &p_force) {
-	Body2DSW *body = body_owner.getornull(p_body);
+	Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->add_central_force(p_force);
@@ -844,7 +844,7 @@ void PhysicsServer2DSW::body_add_central_force(RID p_body, const Vector2 &p_forc
 };
 
 void PhysicsServer2DSW::body_add_force(RID p_body, const Vector2 &p_force, const Vector2 &p_position) {
-	Body2DSW *body = body_owner.getornull(p_body);
+	Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->add_force(p_force, p_position);
@@ -852,7 +852,7 @@ void PhysicsServer2DSW::body_add_force(RID p_body, const Vector2 &p_force, const
 };
 
 void PhysicsServer2DSW::body_add_torque(RID p_body, real_t p_torque) {
-	Body2DSW *body = body_owner.getornull(p_body);
+	Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->add_torque(p_torque);
@@ -860,7 +860,7 @@ void PhysicsServer2DSW::body_add_torque(RID p_body, real_t p_torque) {
 };
 
 void PhysicsServer2DSW::body_set_axis_velocity(RID p_body, const Vector2 &p_axis_velocity) {
-	Body2DSW *body = body_owner.getornull(p_body);
+	Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	_update_shapes();
@@ -874,7 +874,7 @@ void PhysicsServer2DSW::body_set_axis_velocity(RID p_body, const Vector2 &p_axis
 };
 
 void PhysicsServer2DSW::body_add_collision_exception(RID p_body, RID p_body_b) {
-	Body2DSW *body = body_owner.getornull(p_body);
+	Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->add_exception(p_body_b);
@@ -882,7 +882,7 @@ void PhysicsServer2DSW::body_add_collision_exception(RID p_body, RID p_body_b) {
 };
 
 void PhysicsServer2DSW::body_remove_collision_exception(RID p_body, RID p_body_b) {
-	Body2DSW *body = body_owner.getornull(p_body);
+	Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->remove_exception(p_body_b);
@@ -890,7 +890,7 @@ void PhysicsServer2DSW::body_remove_collision_exception(RID p_body, RID p_body_b
 };
 
 void PhysicsServer2DSW::body_get_collision_exceptions(RID p_body, List<RID> *p_exceptions) {
-	Body2DSW *body = body_owner.getornull(p_body);
+	Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	for (int i = 0; i < body->get_exceptions().size(); i++) {
@@ -899,55 +899,55 @@ void PhysicsServer2DSW::body_get_collision_exceptions(RID p_body, List<RID> *p_e
 };
 
 void PhysicsServer2DSW::body_set_contacts_reported_depth_threshold(RID p_body, real_t p_threshold) {
-	Body2DSW *body = body_owner.getornull(p_body);
+	Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 };
 
 real_t PhysicsServer2DSW::body_get_contacts_reported_depth_threshold(RID p_body) const {
-	Body2DSW *body = body_owner.getornull(p_body);
+	Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, 0);
 	return 0;
 };
 
 void PhysicsServer2DSW::body_set_omit_force_integration(RID p_body, bool p_omit) {
-	Body2DSW *body = body_owner.getornull(p_body);
+	Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_omit_force_integration(p_omit);
 };
 
 bool PhysicsServer2DSW::body_is_omitting_force_integration(RID p_body) const {
-	Body2DSW *body = body_owner.getornull(p_body);
+	Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, false);
 	return body->get_omit_force_integration();
 };
 
 void PhysicsServer2DSW::body_set_max_contacts_reported(RID p_body, int p_contacts) {
-	Body2DSW *body = body_owner.getornull(p_body);
+	Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 	body->set_max_contacts_reported(p_contacts);
 }
 
 int PhysicsServer2DSW::body_get_max_contacts_reported(RID p_body) const {
-	Body2DSW *body = body_owner.getornull(p_body);
+	Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, -1);
 	return body->get_max_contacts_reported();
 }
 
 void PhysicsServer2DSW::body_set_state_sync_callback(RID p_body, void *p_instance, BodyStateCallback p_callback) {
-	Body2DSW *body = body_owner.getornull(p_body);
+	Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 	body->set_state_sync_callback(p_instance, p_callback);
 }
 
 void PhysicsServer2DSW::body_set_force_integration_callback(RID p_body, const Callable &p_callable, const Variant &p_udata) {
-	Body2DSW *body = body_owner.getornull(p_body);
+	Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 	body->set_force_integration_callback(p_callable, p_udata);
 }
 
 bool PhysicsServer2DSW::body_collide_shape(RID p_body, int p_body_shape, RID p_shape, const Transform2D &p_shape_xform, const Vector2 &p_motion, Vector2 *r_results, int p_result_max, int &r_result_count) {
-	Body2DSW *body = body_owner.getornull(p_body);
+	Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, false);
 	ERR_FAIL_INDEX_V(p_body_shape, body->get_shape_count(), false);
 
@@ -955,13 +955,13 @@ bool PhysicsServer2DSW::body_collide_shape(RID p_body, int p_body_shape, RID p_s
 }
 
 void PhysicsServer2DSW::body_set_pickable(RID p_body, bool p_pickable) {
-	Body2DSW *body = body_owner.getornull(p_body);
+	Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 	body->set_pickable(p_pickable);
 }
 
 bool PhysicsServer2DSW::body_test_motion(RID p_body, const Transform2D &p_from, const Vector2 &p_motion, real_t p_margin, MotionResult *r_result, bool p_collide_separation_ray, const Set<RID> &p_exclude) {
-	Body2DSW *body = body_owner.getornull(p_body);
+	Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, false);
 	ERR_FAIL_COND_V(!body->get_space(), false);
 	ERR_FAIL_COND_V(body->get_space()->is_locked(), false);
@@ -974,7 +974,7 @@ bool PhysicsServer2DSW::body_test_motion(RID p_body, const Transform2D &p_from,
 PhysicsDirectBodyState2D *PhysicsServer2DSW::body_get_direct_state(RID p_body) {
 	ERR_FAIL_COND_V_MSG((using_threads && !doing_sync), nullptr, "Body state is inaccessible right now, wait for iteration or physics process notification.");
 
-	Body2DSW *body = body_owner.getornull(p_body);
+	Body2DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, nullptr);
 
 	ERR_FAIL_COND_V(!body->get_space(), nullptr);
@@ -993,7 +993,7 @@ RID PhysicsServer2DSW::joint_create() {
 }
 
 void PhysicsServer2DSW::joint_clear(RID p_joint) {
-	Joint2DSW *joint = joint_owner.getornull(p_joint);
+	Joint2DSW *joint = joint_owner.get_or_null(p_joint);
 	if (joint->get_type() != JOINT_TYPE_MAX) {
 		Joint2DSW *empty_joint = memnew(Joint2DSW);
 		empty_joint->copy_settings_from(joint);
@@ -1004,7 +1004,7 @@ void PhysicsServer2DSW::joint_clear(RID p_joint) {
 }
 
 void PhysicsServer2DSW::joint_set_param(RID p_joint, JointParam p_param, real_t p_value) {
-	Joint2DSW *joint = joint_owner.getornull(p_joint);
+	Joint2DSW *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND(!joint);
 
 	switch (p_param) {
@@ -1021,7 +1021,7 @@ void PhysicsServer2DSW::joint_set_param(RID p_joint, JointParam p_param, real_t
 }
 
 real_t PhysicsServer2DSW::joint_get_param(RID p_joint, JointParam p_param) const {
-	const Joint2DSW *joint = joint_owner.getornull(p_joint);
+	const Joint2DSW *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND_V(!joint, -1);
 
 	switch (p_param) {
@@ -1040,7 +1040,7 @@ real_t PhysicsServer2DSW::joint_get_param(RID p_joint, JointParam p_param) const
 }
 
 void PhysicsServer2DSW::joint_disable_collisions_between_bodies(RID p_joint, const bool p_disable) {
-	Joint2DSW *joint = joint_owner.getornull(p_joint);
+	Joint2DSW *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND(!joint);
 
 	joint->disable_collisions_between_bodies(p_disable);
@@ -1060,22 +1060,22 @@ void PhysicsServer2DSW::joint_disable_collisions_between_bodies(RID p_joint, con
 }
 
 bool PhysicsServer2DSW::joint_is_disabled_collisions_between_bodies(RID p_joint) const {
-	const Joint2DSW *joint = joint_owner.getornull(p_joint);
+	const Joint2DSW *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND_V(!joint, true);
 
 	return joint->is_disabled_collisions_between_bodies();
 }
 
 void PhysicsServer2DSW::joint_make_pin(RID p_joint, const Vector2 &p_pos, RID p_body_a, RID p_body_b) {
-	Body2DSW *A = body_owner.getornull(p_body_a);
+	Body2DSW *A = body_owner.get_or_null(p_body_a);
 	ERR_FAIL_COND(!A);
 	Body2DSW *B = nullptr;
 	if (body_owner.owns(p_body_b)) {
-		B = body_owner.getornull(p_body_b);
+		B = body_owner.get_or_null(p_body_b);
 		ERR_FAIL_COND(!B);
 	}
 
-	Joint2DSW *prev_joint = joint_owner.getornull(p_joint);
+	Joint2DSW *prev_joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND(prev_joint == nullptr);
 
 	Joint2DSW *joint = memnew(PinJoint2DSW(p_pos, A, B));
@@ -1086,13 +1086,13 @@ void PhysicsServer2DSW::joint_make_pin(RID p_joint, const Vector2 &p_pos, RID p_
 }
 
 void PhysicsServer2DSW::joint_make_groove(RID p_joint, const Vector2 &p_a_groove1, const Vector2 &p_a_groove2, const Vector2 &p_b_anchor, RID p_body_a, RID p_body_b) {
-	Body2DSW *A = body_owner.getornull(p_body_a);
+	Body2DSW *A = body_owner.get_or_null(p_body_a);
 	ERR_FAIL_COND(!A);
 
-	Body2DSW *B = body_owner.getornull(p_body_b);
+	Body2DSW *B = body_owner.get_or_null(p_body_b);
 	ERR_FAIL_COND(!B);
 
-	Joint2DSW *prev_joint = joint_owner.getornull(p_joint);
+	Joint2DSW *prev_joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND(prev_joint == nullptr);
 
 	Joint2DSW *joint = memnew(GrooveJoint2DSW(p_a_groove1, p_a_groove2, p_b_anchor, A, B));
@@ -1103,13 +1103,13 @@ void PhysicsServer2DSW::joint_make_groove(RID p_joint, const Vector2 &p_a_groove
 }
 
 void PhysicsServer2DSW::joint_make_damped_spring(RID p_joint, const Vector2 &p_anchor_a, const Vector2 &p_anchor_b, RID p_body_a, RID p_body_b) {
-	Body2DSW *A = body_owner.getornull(p_body_a);
+	Body2DSW *A = body_owner.get_or_null(p_body_a);
 	ERR_FAIL_COND(!A);
 
-	Body2DSW *B = body_owner.getornull(p_body_b);
+	Body2DSW *B = body_owner.get_or_null(p_body_b);
 	ERR_FAIL_COND(!B);
 
-	Joint2DSW *prev_joint = joint_owner.getornull(p_joint);
+	Joint2DSW *prev_joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND(prev_joint == nullptr);
 
 	Joint2DSW *joint = memnew(DampedSpringJoint2DSW(p_anchor_a, p_anchor_b, A, B));
@@ -1120,7 +1120,7 @@ void PhysicsServer2DSW::joint_make_damped_spring(RID p_joint, const Vector2 &p_a
 }
 
 void PhysicsServer2DSW::pin_joint_set_param(RID p_joint, PinJointParam p_param, real_t p_value) {
-	Joint2DSW *j = joint_owner.getornull(p_joint);
+	Joint2DSW *j = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND(!j);
 	ERR_FAIL_COND(j->get_type() != JOINT_TYPE_PIN);
 
@@ -1129,7 +1129,7 @@ void PhysicsServer2DSW::pin_joint_set_param(RID p_joint, PinJointParam p_param,
 }
 
 real_t PhysicsServer2DSW::pin_joint_get_param(RID p_joint, PinJointParam p_param) const {
-	Joint2DSW *j = joint_owner.getornull(p_joint);
+	Joint2DSW *j = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND_V(!j, 0);
 	ERR_FAIL_COND_V(j->get_type() != JOINT_TYPE_PIN, 0);
 
@@ -1138,7 +1138,7 @@ real_t PhysicsServer2DSW::pin_joint_get_param(RID p_joint, PinJointParam p_param
 }
 
 void PhysicsServer2DSW::damped_spring_joint_set_param(RID p_joint, DampedSpringParam p_param, real_t p_value) {
-	Joint2DSW *j = joint_owner.getornull(p_joint);
+	Joint2DSW *j = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND(!j);
 	ERR_FAIL_COND(j->get_type() != JOINT_TYPE_DAMPED_SPRING);
 
@@ -1147,7 +1147,7 @@ void PhysicsServer2DSW::damped_spring_joint_set_param(RID p_joint, DampedSpringP
 }
 
 real_t PhysicsServer2DSW::damped_spring_joint_get_param(RID p_joint, DampedSpringParam p_param) const {
-	Joint2DSW *j = joint_owner.getornull(p_joint);
+	Joint2DSW *j = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND_V(!j, 0);
 	ERR_FAIL_COND_V(j->get_type() != JOINT_TYPE_DAMPED_SPRING, 0);
 
@@ -1156,7 +1156,7 @@ real_t PhysicsServer2DSW::damped_spring_joint_get_param(RID p_joint, DampedSprin
 }
 
 PhysicsServer2D::JointType PhysicsServer2DSW::joint_get_type(RID p_joint) const {
-	Joint2DSW *joint = joint_owner.getornull(p_joint);
+	Joint2DSW *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND_V(!joint, JOINT_TYPE_PIN);
 
 	return joint->get_type();
@@ -1166,7 +1166,7 @@ void PhysicsServer2DSW::free(RID p_rid) {
 	_update_shapes(); // just in case
 
 	if (shape_owner.owns(p_rid)) {
-		Shape2DSW *shape = shape_owner.getornull(p_rid);
+		Shape2DSW *shape = shape_owner.get_or_null(p_rid);
 
 		while (shape->get_owners().size()) {
 			ShapeOwner2DSW *so = shape->get_owners().front()->key();
@@ -1176,7 +1176,7 @@ void PhysicsServer2DSW::free(RID p_rid) {
 		shape_owner.free(p_rid);
 		memdelete(shape);
 	} else if (body_owner.owns(p_rid)) {
-		Body2DSW *body = body_owner.getornull(p_rid);
+		Body2DSW *body = body_owner.get_or_null(p_rid);
 
 		/*
 		if (body->get_state_query())
@@ -1196,7 +1196,7 @@ void PhysicsServer2DSW::free(RID p_rid) {
 		memdelete(body);
 
 	} else if (area_owner.owns(p_rid)) {
-		Area2DSW *area = area_owner.getornull(p_rid);
+		Area2DSW *area = area_owner.get_or_null(p_rid);
 
 		/*
 		if (area->get_monitor_query())
@@ -1212,7 +1212,7 @@ void PhysicsServer2DSW::free(RID p_rid) {
 		area_owner.free(p_rid);
 		memdelete(area);
 	} else if (space_owner.owns(p_rid)) {
-		Space2DSW *space = space_owner.getornull(p_rid);
+		Space2DSW *space = space_owner.get_or_null(p_rid);
 
 		while (space->get_objects().size()) {
 			CollisionObject2DSW *co = (CollisionObject2DSW *)space->get_objects().front()->get();
@@ -1224,7 +1224,7 @@ void PhysicsServer2DSW::free(RID p_rid) {
 		space_owner.free(p_rid);
 		memdelete(space);
 	} else if (joint_owner.owns(p_rid)) {
-		Joint2DSW *joint = joint_owner.getornull(p_rid);
+		Joint2DSW *joint = joint_owner.get_or_null(p_rid);
 
 		joint_owner.free(p_rid);
 		memdelete(joint);
diff --git a/servers/physics_2d/space_2d_sw.cpp b/servers/physics_2d/space_2d_sw.cpp
index 1058f75407..df37b11c1b 100644
--- a/servers/physics_2d/space_2d_sw.cpp
+++ b/servers/physics_2d/space_2d_sw.cpp
@@ -206,7 +206,7 @@ int PhysicsDirectSpaceState2DSW::intersect_shape(const RID &p_shape, const Trans
 		return 0;
 	}
 
-	Shape2DSW *shape = PhysicsServer2DSW::singletonsw->shape_owner.getornull(p_shape);
+	Shape2DSW *shape = PhysicsServer2DSW::singletonsw->shape_owner.get_or_null(p_shape);
 	ERR_FAIL_COND_V(!shape, 0);
 
 	Rect2 aabb = p_xform.xform(shape->get_aabb());
@@ -251,7 +251,7 @@ int PhysicsDirectSpaceState2DSW::intersect_shape(const RID &p_shape, const Trans
 }
 
 bool PhysicsDirectSpaceState2DSW::cast_motion(const RID &p_shape, const Transform2D &p_xform, const Vector2 &p_motion, real_t p_margin, real_t &p_closest_safe, real_t &p_closest_unsafe, const Set<RID> &p_exclude, uint32_t p_collision_mask, bool p_collide_with_bodies, bool p_collide_with_areas) {
-	Shape2DSW *shape = PhysicsServer2DSW::singletonsw->shape_owner.getornull(p_shape);
+	Shape2DSW *shape = PhysicsServer2DSW::singletonsw->shape_owner.get_or_null(p_shape);
 	ERR_FAIL_COND_V(!shape, false);
 
 	Rect2 aabb = p_xform.xform(shape->get_aabb());
@@ -338,7 +338,7 @@ bool PhysicsDirectSpaceState2DSW::collide_shape(RID p_shape, const Transform2D &
 		return false;
 	}
 
-	Shape2DSW *shape = PhysicsServer2DSW::singletonsw->shape_owner.getornull(p_shape);
+	Shape2DSW *shape = PhysicsServer2DSW::singletonsw->shape_owner.get_or_null(p_shape);
 	ERR_FAIL_COND_V(!shape, 0);
 
 	Rect2 aabb = p_shape_xform.xform(shape->get_aabb());
@@ -435,7 +435,7 @@ static void _rest_cbk_result(const Vector2 &p_point_A, const Vector2 &p_point_B,
 }
 
 bool PhysicsDirectSpaceState2DSW::rest_info(RID p_shape, const Transform2D &p_shape_xform, const Vector2 &p_motion, real_t 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) {
-	Shape2DSW *shape = PhysicsServer2DSW::singletonsw->shape_owner.getornull(p_shape);
+	Shape2DSW *shape = PhysicsServer2DSW::singletonsw->shape_owner.get_or_null(p_shape);
 	ERR_FAIL_COND_V(!shape, 0);
 
 	real_t min_contact_depth = p_margin * TEST_MOTION_MIN_CONTACT_DEPTH_FACTOR;
diff --git a/servers/physics_3d/physics_server_3d_sw.cpp b/servers/physics_3d/physics_server_3d_sw.cpp
index 8fbb0ba477..ece1fe46e7 100644
--- a/servers/physics_3d/physics_server_3d_sw.cpp
+++ b/servers/physics_3d/physics_server_3d_sw.cpp
@@ -102,25 +102,25 @@ RID PhysicsServer3DSW::custom_shape_create() {
 }
 
 void PhysicsServer3DSW::shape_set_data(RID p_shape, const Variant &p_data) {
-	Shape3DSW *shape = shape_owner.getornull(p_shape);
+	Shape3DSW *shape = shape_owner.get_or_null(p_shape);
 	ERR_FAIL_COND(!shape);
 	shape->set_data(p_data);
 };
 
 void PhysicsServer3DSW::shape_set_custom_solver_bias(RID p_shape, real_t p_bias) {
-	Shape3DSW *shape = shape_owner.getornull(p_shape);
+	Shape3DSW *shape = shape_owner.get_or_null(p_shape);
 	ERR_FAIL_COND(!shape);
 	shape->set_custom_bias(p_bias);
 }
 
 PhysicsServer3D::ShapeType PhysicsServer3DSW::shape_get_type(RID p_shape) const {
-	const Shape3DSW *shape = shape_owner.getornull(p_shape);
+	const Shape3DSW *shape = shape_owner.get_or_null(p_shape);
 	ERR_FAIL_COND_V(!shape, SHAPE_CUSTOM);
 	return shape->get_type();
 };
 
 Variant PhysicsServer3DSW::shape_get_data(RID p_shape) const {
-	const Shape3DSW *shape = shape_owner.getornull(p_shape);
+	const Shape3DSW *shape = shape_owner.get_or_null(p_shape);
 	ERR_FAIL_COND_V(!shape, Variant());
 	ERR_FAIL_COND_V(!shape->is_configured(), Variant());
 	return shape->get_data();
@@ -134,7 +134,7 @@ real_t PhysicsServer3DSW::shape_get_margin(RID p_shape) const {
 }
 
 real_t PhysicsServer3DSW::shape_get_custom_solver_bias(RID p_shape) const {
-	const Shape3DSW *shape = shape_owner.getornull(p_shape);
+	const Shape3DSW *shape = shape_owner.get_or_null(p_shape);
 	ERR_FAIL_COND_V(!shape, 0);
 	return shape->get_custom_bias();
 }
@@ -144,7 +144,7 @@ RID PhysicsServer3DSW::space_create() {
 	RID id = space_owner.make_rid(space);
 	space->set_self(id);
 	RID area_id = area_create();
-	Area3DSW *area = area_owner.getornull(area_id);
+	Area3DSW *area = area_owner.get_or_null(area_id);
 	ERR_FAIL_COND_V(!area, RID());
 	space->set_default_area(area);
 	area->set_space(space);
@@ -158,7 +158,7 @@ RID PhysicsServer3DSW::space_create() {
 };
 
 void PhysicsServer3DSW::space_set_active(RID p_space, bool p_active) {
-	Space3DSW *space = space_owner.getornull(p_space);
+	Space3DSW *space = space_owner.get_or_null(p_space);
 	ERR_FAIL_COND(!space);
 	if (p_active) {
 		active_spaces.insert(space);
@@ -168,27 +168,27 @@ void PhysicsServer3DSW::space_set_active(RID p_space, bool p_active) {
 }
 
 bool PhysicsServer3DSW::space_is_active(RID p_space) const {
-	const Space3DSW *space = space_owner.getornull(p_space);
+	const Space3DSW *space = space_owner.get_or_null(p_space);
 	ERR_FAIL_COND_V(!space, false);
 
 	return active_spaces.has(space);
 }
 
 void PhysicsServer3DSW::space_set_param(RID p_space, SpaceParameter p_param, real_t p_value) {
-	Space3DSW *space = space_owner.getornull(p_space);
+	Space3DSW *space = space_owner.get_or_null(p_space);
 	ERR_FAIL_COND(!space);
 
 	space->set_param(p_param, p_value);
 }
 
 real_t PhysicsServer3DSW::space_get_param(RID p_space, SpaceParameter p_param) const {
-	const Space3DSW *space = space_owner.getornull(p_space);
+	const Space3DSW *space = space_owner.get_or_null(p_space);
 	ERR_FAIL_COND_V(!space, 0);
 	return space->get_param(p_param);
 }
 
 PhysicsDirectSpaceState3D *PhysicsServer3DSW::space_get_direct_state(RID p_space) {
-	Space3DSW *space = space_owner.getornull(p_space);
+	Space3DSW *space = space_owner.get_or_null(p_space);
 	ERR_FAIL_COND_V(!space, nullptr);
 	ERR_FAIL_COND_V_MSG((using_threads && !doing_sync) || space->is_locked(), nullptr, "Space state is inaccessible right now, wait for iteration or physics process notification.");
 
@@ -196,19 +196,19 @@ PhysicsDirectSpaceState3D *PhysicsServer3DSW::space_get_direct_state(RID p_space
 }
 
 void PhysicsServer3DSW::space_set_debug_contacts(RID p_space, int p_max_contacts) {
-	Space3DSW *space = space_owner.getornull(p_space);
+	Space3DSW *space = space_owner.get_or_null(p_space);
 	ERR_FAIL_COND(!space);
 	space->set_debug_contacts(p_max_contacts);
 }
 
 Vector<Vector3> PhysicsServer3DSW::space_get_contacts(RID p_space) const {
-	Space3DSW *space = space_owner.getornull(p_space);
+	Space3DSW *space = space_owner.get_or_null(p_space);
 	ERR_FAIL_COND_V(!space, Vector<Vector3>());
 	return space->get_debug_contacts();
 }
 
 int PhysicsServer3DSW::space_get_contact_count(RID p_space) const {
-	Space3DSW *space = space_owner.getornull(p_space);
+	Space3DSW *space = space_owner.get_or_null(p_space);
 	ERR_FAIL_COND_V(!space, 0);
 	return space->get_debug_contact_count();
 }
@@ -221,12 +221,12 @@ RID PhysicsServer3DSW::area_create() {
 };
 
 void PhysicsServer3DSW::area_set_space(RID p_area, RID p_space) {
-	Area3DSW *area = area_owner.getornull(p_area);
+	Area3DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 
 	Space3DSW *space = nullptr;
 	if (p_space.is_valid()) {
-		space = space_owner.getornull(p_space);
+		space = space_owner.get_or_null(p_space);
 		ERR_FAIL_COND(!space);
 	}
 
@@ -239,7 +239,7 @@ void PhysicsServer3DSW::area_set_space(RID p_area, RID p_space) {
 };
 
 RID PhysicsServer3DSW::area_get_space(RID p_area) const {
-	Area3DSW *area = area_owner.getornull(p_area);
+	Area3DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND_V(!area, RID());
 
 	Space3DSW *space = area->get_space();
@@ -250,34 +250,34 @@ RID PhysicsServer3DSW::area_get_space(RID p_area) const {
 };
 
 void PhysicsServer3DSW::area_set_space_override_mode(RID p_area, AreaSpaceOverrideMode p_mode) {
-	Area3DSW *area = area_owner.getornull(p_area);
+	Area3DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 
 	area->set_space_override_mode(p_mode);
 }
 
 PhysicsServer3D::AreaSpaceOverrideMode PhysicsServer3DSW::area_get_space_override_mode(RID p_area) const {
-	const Area3DSW *area = area_owner.getornull(p_area);
+	const Area3DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND_V(!area, AREA_SPACE_OVERRIDE_DISABLED);
 
 	return area->get_space_override_mode();
 }
 
 void PhysicsServer3DSW::area_add_shape(RID p_area, RID p_shape, const Transform3D &p_transform, bool p_disabled) {
-	Area3DSW *area = area_owner.getornull(p_area);
+	Area3DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 
-	Shape3DSW *shape = shape_owner.getornull(p_shape);
+	Shape3DSW *shape = shape_owner.get_or_null(p_shape);
 	ERR_FAIL_COND(!shape);
 
 	area->add_shape(shape, p_transform, p_disabled);
 }
 
 void PhysicsServer3DSW::area_set_shape(RID p_area, int p_shape_idx, RID p_shape) {
-	Area3DSW *area = area_owner.getornull(p_area);
+	Area3DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 
-	Shape3DSW *shape = shape_owner.getornull(p_shape);
+	Shape3DSW *shape = shape_owner.get_or_null(p_shape);
 	ERR_FAIL_COND(!shape);
 	ERR_FAIL_COND(!shape->is_configured());
 
@@ -285,21 +285,21 @@ void PhysicsServer3DSW::area_set_shape(RID p_area, int p_shape_idx, RID p_shape)
 }
 
 void PhysicsServer3DSW::area_set_shape_transform(RID p_area, int p_shape_idx, const Transform3D &p_transform) {
-	Area3DSW *area = area_owner.getornull(p_area);
+	Area3DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 
 	area->set_shape_transform(p_shape_idx, p_transform);
 }
 
 int PhysicsServer3DSW::area_get_shape_count(RID p_area) const {
-	Area3DSW *area = area_owner.getornull(p_area);
+	Area3DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND_V(!area, -1);
 
 	return area->get_shape_count();
 }
 
 RID PhysicsServer3DSW::area_get_shape(RID p_area, int p_shape_idx) const {
-	Area3DSW *area = area_owner.getornull(p_area);
+	Area3DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND_V(!area, RID());
 
 	Shape3DSW *shape = area->get_shape(p_shape_idx);
@@ -309,21 +309,21 @@ RID PhysicsServer3DSW::area_get_shape(RID p_area, int p_shape_idx) const {
 }
 
 Transform3D PhysicsServer3DSW::area_get_shape_transform(RID p_area, int p_shape_idx) const {
-	Area3DSW *area = area_owner.getornull(p_area);
+	Area3DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND_V(!area, Transform3D());
 
 	return area->get_shape_transform(p_shape_idx);
 }
 
 void PhysicsServer3DSW::area_remove_shape(RID p_area, int p_shape_idx) {
-	Area3DSW *area = area_owner.getornull(p_area);
+	Area3DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 
 	area->remove_shape(p_shape_idx);
 }
 
 void PhysicsServer3DSW::area_clear_shapes(RID p_area) {
-	Area3DSW *area = area_owner.getornull(p_area);
+	Area3DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 
 	while (area->get_shape_count()) {
@@ -332,7 +332,7 @@ void PhysicsServer3DSW::area_clear_shapes(RID p_area) {
 }
 
 void PhysicsServer3DSW::area_set_shape_disabled(RID p_area, int p_shape_idx, bool p_disabled) {
-	Area3DSW *area = area_owner.getornull(p_area);
+	Area3DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 	ERR_FAIL_INDEX(p_shape_idx, area->get_shape_count());
 	FLUSH_QUERY_CHECK(area);
@@ -341,74 +341,74 @@ void PhysicsServer3DSW::area_set_shape_disabled(RID p_area, int p_shape_idx, boo
 
 void PhysicsServer3DSW::area_attach_object_instance_id(RID p_area, ObjectID p_id) {
 	if (space_owner.owns(p_area)) {
-		Space3DSW *space = space_owner.getornull(p_area);
+		Space3DSW *space = space_owner.get_or_null(p_area);
 		p_area = space->get_default_area()->get_self();
 	}
-	Area3DSW *area = area_owner.getornull(p_area);
+	Area3DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 	area->set_instance_id(p_id);
 }
 
 ObjectID PhysicsServer3DSW::area_get_object_instance_id(RID p_area) const {
 	if (space_owner.owns(p_area)) {
-		Space3DSW *space = space_owner.getornull(p_area);
+		Space3DSW *space = space_owner.get_or_null(p_area);
 		p_area = space->get_default_area()->get_self();
 	}
-	Area3DSW *area = area_owner.getornull(p_area);
+	Area3DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND_V(!area, ObjectID());
 	return area->get_instance_id();
 }
 
 void PhysicsServer3DSW::area_set_param(RID p_area, AreaParameter p_param, const Variant &p_value) {
 	if (space_owner.owns(p_area)) {
-		Space3DSW *space = space_owner.getornull(p_area);
+		Space3DSW *space = space_owner.get_or_null(p_area);
 		p_area = space->get_default_area()->get_self();
 	}
-	Area3DSW *area = area_owner.getornull(p_area);
+	Area3DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 	area->set_param(p_param, p_value);
 };
 
 void PhysicsServer3DSW::area_set_transform(RID p_area, const Transform3D &p_transform) {
-	Area3DSW *area = area_owner.getornull(p_area);
+	Area3DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 	area->set_transform(p_transform);
 };
 
 Variant PhysicsServer3DSW::area_get_param(RID p_area, AreaParameter p_param) const {
 	if (space_owner.owns(p_area)) {
-		Space3DSW *space = space_owner.getornull(p_area);
+		Space3DSW *space = space_owner.get_or_null(p_area);
 		p_area = space->get_default_area()->get_self();
 	}
-	Area3DSW *area = area_owner.getornull(p_area);
+	Area3DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND_V(!area, Variant());
 
 	return area->get_param(p_param);
 };
 
 Transform3D PhysicsServer3DSW::area_get_transform(RID p_area) const {
-	Area3DSW *area = area_owner.getornull(p_area);
+	Area3DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND_V(!area, Transform3D());
 
 	return area->get_transform();
 };
 
 void PhysicsServer3DSW::area_set_collision_layer(RID p_area, uint32_t p_layer) {
-	Area3DSW *area = area_owner.getornull(p_area);
+	Area3DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 
 	area->set_collision_layer(p_layer);
 }
 
 void PhysicsServer3DSW::area_set_collision_mask(RID p_area, uint32_t p_mask) {
-	Area3DSW *area = area_owner.getornull(p_area);
+	Area3DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 
 	area->set_collision_mask(p_mask);
 }
 
 void PhysicsServer3DSW::area_set_monitorable(RID p_area, bool p_monitorable) {
-	Area3DSW *area = area_owner.getornull(p_area);
+	Area3DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 	FLUSH_QUERY_CHECK(area);
 
@@ -416,21 +416,21 @@ void PhysicsServer3DSW::area_set_monitorable(RID p_area, bool p_monitorable) {
 }
 
 void PhysicsServer3DSW::area_set_monitor_callback(RID p_area, Object *p_receiver, const StringName &p_method) {
-	Area3DSW *area = area_owner.getornull(p_area);
+	Area3DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 
 	area->set_monitor_callback(p_receiver ? p_receiver->get_instance_id() : ObjectID(), p_method);
 }
 
 void PhysicsServer3DSW::area_set_ray_pickable(RID p_area, bool p_enable) {
-	Area3DSW *area = area_owner.getornull(p_area);
+	Area3DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 
 	area->set_ray_pickable(p_enable);
 }
 
 void PhysicsServer3DSW::area_set_area_monitor_callback(RID p_area, Object *p_receiver, const StringName &p_method) {
-	Area3DSW *area = area_owner.getornull(p_area);
+	Area3DSW *area = area_owner.get_or_null(p_area);
 	ERR_FAIL_COND(!area);
 
 	area->set_area_monitor_callback(p_receiver ? p_receiver->get_instance_id() : ObjectID(), p_method);
@@ -446,12 +446,12 @@ RID PhysicsServer3DSW::body_create() {
 };
 
 void PhysicsServer3DSW::body_set_space(RID p_body, RID p_space) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	Space3DSW *space = nullptr;
 	if (p_space.is_valid()) {
-		space = space_owner.getornull(p_space);
+		space = space_owner.get_or_null(p_space);
 		ERR_FAIL_COND(!space);
 	}
 
@@ -464,7 +464,7 @@ void PhysicsServer3DSW::body_set_space(RID p_body, RID p_space) {
 };
 
 RID PhysicsServer3DSW::body_get_space(RID p_body) const {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, RID());
 
 	Space3DSW *space = body->get_space();
@@ -475,55 +475,55 @@ RID PhysicsServer3DSW::body_get_space(RID p_body) const {
 };
 
 void PhysicsServer3DSW::body_set_mode(RID p_body, BodyMode p_mode) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_mode(p_mode);
 };
 
 PhysicsServer3D::BodyMode PhysicsServer3DSW::body_get_mode(RID p_body) const {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, BODY_MODE_STATIC);
 
 	return body->get_mode();
 };
 
 void PhysicsServer3DSW::body_add_shape(RID p_body, RID p_shape, const Transform3D &p_transform, bool p_disabled) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
-	Shape3DSW *shape = shape_owner.getornull(p_shape);
+	Shape3DSW *shape = shape_owner.get_or_null(p_shape);
 	ERR_FAIL_COND(!shape);
 
 	body->add_shape(shape, p_transform, p_disabled);
 }
 
 void PhysicsServer3DSW::body_set_shape(RID p_body, int p_shape_idx, RID p_shape) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
-	Shape3DSW *shape = shape_owner.getornull(p_shape);
+	Shape3DSW *shape = shape_owner.get_or_null(p_shape);
 	ERR_FAIL_COND(!shape);
 	ERR_FAIL_COND(!shape->is_configured());
 
 	body->set_shape(p_shape_idx, shape);
 }
 void PhysicsServer3DSW::body_set_shape_transform(RID p_body, int p_shape_idx, const Transform3D &p_transform) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_shape_transform(p_shape_idx, p_transform);
 }
 
 int PhysicsServer3DSW::body_get_shape_count(RID p_body) const {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, -1);
 
 	return body->get_shape_count();
 }
 
 RID PhysicsServer3DSW::body_get_shape(RID p_body, int p_shape_idx) const {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, RID());
 
 	Shape3DSW *shape = body->get_shape(p_shape_idx);
@@ -533,7 +533,7 @@ RID PhysicsServer3DSW::body_get_shape(RID p_body, int p_shape_idx) const {
 }
 
 void PhysicsServer3DSW::body_set_shape_disabled(RID p_body, int p_shape_idx, bool p_disabled) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 	ERR_FAIL_INDEX(p_shape_idx, body->get_shape_count());
 	FLUSH_QUERY_CHECK(body);
@@ -542,21 +542,21 @@ void PhysicsServer3DSW::body_set_shape_disabled(RID p_body, int p_shape_idx, boo
 }
 
 Transform3D PhysicsServer3DSW::body_get_shape_transform(RID p_body, int p_shape_idx) const {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, Transform3D());
 
 	return body->get_shape_transform(p_shape_idx);
 }
 
 void PhysicsServer3DSW::body_remove_shape(RID p_body, int p_shape_idx) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->remove_shape(p_shape_idx);
 }
 
 void PhysicsServer3DSW::body_clear_shapes(RID p_body) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	while (body->get_shape_count()) {
@@ -565,21 +565,21 @@ void PhysicsServer3DSW::body_clear_shapes(RID p_body) {
 }
 
 void PhysicsServer3DSW::body_set_enable_continuous_collision_detection(RID p_body, bool p_enable) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_continuous_collision_detection(p_enable);
 }
 
 bool PhysicsServer3DSW::body_is_continuous_collision_detection_enabled(RID p_body) const {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, false);
 
 	return body->is_continuous_collision_detection_enabled();
 }
 
 void PhysicsServer3DSW::body_set_collision_layer(RID p_body, uint32_t p_layer) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_collision_layer(p_layer);
@@ -587,14 +587,14 @@ void PhysicsServer3DSW::body_set_collision_layer(RID p_body, uint32_t p_layer) {
 }
 
 uint32_t PhysicsServer3DSW::body_get_collision_layer(RID p_body) const {
-	const Body3DSW *body = body_owner.getornull(p_body);
+	const Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, 0);
 
 	return body->get_collision_layer();
 }
 
 void PhysicsServer3DSW::body_set_collision_mask(RID p_body, uint32_t p_mask) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_collision_mask(p_mask);
@@ -602,20 +602,20 @@ void PhysicsServer3DSW::body_set_collision_mask(RID p_body, uint32_t p_mask) {
 }
 
 uint32_t PhysicsServer3DSW::body_get_collision_mask(RID p_body) const {
-	const Body3DSW *body = body_owner.getornull(p_body);
+	const Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, 0);
 
 	return body->get_collision_mask();
 }
 
 void PhysicsServer3DSW::body_attach_object_instance_id(RID p_body, ObjectID p_id) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	if (body) {
 		body->set_instance_id(p_id);
 		return;
 	}
 
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	if (soft_body) {
 		soft_body->set_instance_id(p_id);
 		return;
@@ -625,61 +625,61 @@ void PhysicsServer3DSW::body_attach_object_instance_id(RID p_body, ObjectID p_id
 };
 
 ObjectID PhysicsServer3DSW::body_get_object_instance_id(RID p_body) const {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, ObjectID());
 
 	return body->get_instance_id();
 };
 
 void PhysicsServer3DSW::body_set_user_flags(RID p_body, uint32_t p_flags) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 };
 
 uint32_t PhysicsServer3DSW::body_get_user_flags(RID p_body) const {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, 0);
 
 	return 0;
 };
 
 void PhysicsServer3DSW::body_set_param(RID p_body, BodyParameter p_param, const Variant &p_value) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_param(p_param, p_value);
 };
 
 Variant PhysicsServer3DSW::body_get_param(RID p_body, BodyParameter p_param) const {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, 0);
 
 	return body->get_param(p_param);
 };
 
 void PhysicsServer3DSW::body_reset_mass_properties(RID p_body) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	return body->reset_mass_properties();
 }
 
 void PhysicsServer3DSW::body_set_state(RID p_body, BodyState p_state, const Variant &p_variant) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_state(p_state, p_variant);
 };
 
 Variant PhysicsServer3DSW::body_get_state(RID p_body, BodyState p_state) const {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, Variant());
 
 	return body->get_state(p_state);
 };
 
 void PhysicsServer3DSW::body_set_applied_force(RID p_body, const Vector3 &p_force) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_applied_force(p_force);
@@ -687,13 +687,13 @@ void PhysicsServer3DSW::body_set_applied_force(RID p_body, const Vector3 &p_forc
 };
 
 Vector3 PhysicsServer3DSW::body_get_applied_force(RID p_body) const {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, Vector3());
 	return body->get_applied_force();
 };
 
 void PhysicsServer3DSW::body_set_applied_torque(RID p_body, const Vector3 &p_torque) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_applied_torque(p_torque);
@@ -701,14 +701,14 @@ void PhysicsServer3DSW::body_set_applied_torque(RID p_body, const Vector3 &p_tor
 };
 
 Vector3 PhysicsServer3DSW::body_get_applied_torque(RID p_body) const {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, Vector3());
 
 	return body->get_applied_torque();
 };
 
 void PhysicsServer3DSW::body_add_central_force(RID p_body, const Vector3 &p_force) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->add_central_force(p_force);
@@ -716,7 +716,7 @@ void PhysicsServer3DSW::body_add_central_force(RID p_body, const Vector3 &p_forc
 }
 
 void PhysicsServer3DSW::body_add_force(RID p_body, const Vector3 &p_force, const Vector3 &p_position) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->add_force(p_force, p_position);
@@ -724,7 +724,7 @@ void PhysicsServer3DSW::body_add_force(RID p_body, const Vector3 &p_force, const
 };
 
 void PhysicsServer3DSW::body_add_torque(RID p_body, const Vector3 &p_torque) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->add_torque(p_torque);
@@ -732,7 +732,7 @@ void PhysicsServer3DSW::body_add_torque(RID p_body, const Vector3 &p_torque) {
 };
 
 void PhysicsServer3DSW::body_apply_central_impulse(RID p_body, const Vector3 &p_impulse) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	_update_shapes();
@@ -742,7 +742,7 @@ void PhysicsServer3DSW::body_apply_central_impulse(RID p_body, const Vector3 &p_
 }
 
 void PhysicsServer3DSW::body_apply_impulse(RID p_body, const Vector3 &p_impulse, const Vector3 &p_position) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	_update_shapes();
@@ -752,7 +752,7 @@ void PhysicsServer3DSW::body_apply_impulse(RID p_body, const Vector3 &p_impulse,
 };
 
 void PhysicsServer3DSW::body_apply_torque_impulse(RID p_body, const Vector3 &p_impulse) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	_update_shapes();
@@ -762,7 +762,7 @@ void PhysicsServer3DSW::body_apply_torque_impulse(RID p_body, const Vector3 &p_i
 };
 
 void PhysicsServer3DSW::body_set_axis_velocity(RID p_body, const Vector3 &p_axis_velocity) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	_update_shapes();
@@ -776,7 +776,7 @@ void PhysicsServer3DSW::body_set_axis_velocity(RID p_body, const Vector3 &p_axis
 };
 
 void PhysicsServer3DSW::body_set_axis_lock(RID p_body, BodyAxis p_axis, bool p_lock) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_axis_lock(p_axis, p_lock);
@@ -784,13 +784,13 @@ void PhysicsServer3DSW::body_set_axis_lock(RID p_body, BodyAxis p_axis, bool p_l
 }
 
 bool PhysicsServer3DSW::body_is_axis_locked(RID p_body, BodyAxis p_axis) const {
-	const Body3DSW *body = body_owner.getornull(p_body);
+	const Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, 0);
 	return body->is_axis_locked(p_axis);
 }
 
 void PhysicsServer3DSW::body_add_collision_exception(RID p_body, RID p_body_b) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->add_exception(p_body_b);
@@ -798,7 +798,7 @@ void PhysicsServer3DSW::body_add_collision_exception(RID p_body, RID p_body_b) {
 };
 
 void PhysicsServer3DSW::body_remove_collision_exception(RID p_body, RID p_body_b) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->remove_exception(p_body_b);
@@ -806,7 +806,7 @@ void PhysicsServer3DSW::body_remove_collision_exception(RID p_body, RID p_body_b
 };
 
 void PhysicsServer3DSW::body_get_collision_exceptions(RID p_body, List<RID> *p_exceptions) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	for (int i = 0; i < body->get_exceptions().size(); i++) {
@@ -815,61 +815,61 @@ void PhysicsServer3DSW::body_get_collision_exceptions(RID p_body, List<RID> *p_e
 };
 
 void PhysicsServer3DSW::body_set_contacts_reported_depth_threshold(RID p_body, real_t p_threshold) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 };
 
 real_t PhysicsServer3DSW::body_get_contacts_reported_depth_threshold(RID p_body) const {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, 0);
 	return 0;
 };
 
 void PhysicsServer3DSW::body_set_omit_force_integration(RID p_body, bool p_omit) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 
 	body->set_omit_force_integration(p_omit);
 };
 
 bool PhysicsServer3DSW::body_is_omitting_force_integration(RID p_body) const {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, false);
 	return body->get_omit_force_integration();
 };
 
 void PhysicsServer3DSW::body_set_max_contacts_reported(RID p_body, int p_contacts) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 	body->set_max_contacts_reported(p_contacts);
 }
 
 int PhysicsServer3DSW::body_get_max_contacts_reported(RID p_body) const {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, -1);
 	return body->get_max_contacts_reported();
 }
 
 void PhysicsServer3DSW::body_set_state_sync_callback(RID p_body, void *p_instance, BodyStateCallback p_callback) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 	body->set_state_sync_callback(p_instance, p_callback);
 }
 
 void PhysicsServer3DSW::body_set_force_integration_callback(RID p_body, const Callable &p_callable, const Variant &p_udata) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 	body->set_force_integration_callback(p_callable, p_udata);
 }
 
 void PhysicsServer3DSW::body_set_ray_pickable(RID p_body, bool p_enable) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!body);
 	body->set_ray_pickable(p_enable);
 }
 
 bool PhysicsServer3DSW::body_test_motion(RID p_body, const Transform3D &p_from, const Vector3 &p_motion, real_t p_margin, MotionResult *r_result, int p_max_collisions, bool p_collide_separation_ray, const Set<RID> &p_exclude) {
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!body, false);
 	ERR_FAIL_COND_V(!body->get_space(), false);
 	ERR_FAIL_COND_V(body->get_space()->is_locked(), false);
@@ -882,7 +882,7 @@ bool PhysicsServer3DSW::body_test_motion(RID p_body, const Transform3D &p_from,
 PhysicsDirectBodyState3D *PhysicsServer3DSW::body_get_direct_state(RID p_body) {
 	ERR_FAIL_COND_V_MSG((using_threads && !doing_sync), nullptr, "Body state is inaccessible right now, wait for iteration or physics process notification.");
 
-	Body3DSW *body = body_owner.getornull(p_body);
+	Body3DSW *body = body_owner.get_or_null(p_body);
 	ERR_FAIL_NULL_V(body, nullptr);
 
 	ERR_FAIL_NULL_V(body->get_space(), nullptr);
@@ -901,19 +901,19 @@ RID PhysicsServer3DSW::soft_body_create() {
 }
 
 void PhysicsServer3DSW::soft_body_update_rendering_server(RID p_body, RenderingServerHandler *p_rendering_server_handler) {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!soft_body);
 
 	soft_body->update_rendering_server(p_rendering_server_handler);
 }
 
 void PhysicsServer3DSW::soft_body_set_space(RID p_body, RID p_space) {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!soft_body);
 
 	Space3DSW *space = nullptr;
 	if (p_space.is_valid()) {
-		space = space_owner.getornull(p_space);
+		space = space_owner.get_or_null(p_space);
 		ERR_FAIL_COND(!space);
 	}
 
@@ -925,7 +925,7 @@ void PhysicsServer3DSW::soft_body_set_space(RID p_body, RID p_space) {
 }
 
 RID PhysicsServer3DSW::soft_body_get_space(RID p_body) const {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!soft_body, RID());
 
 	Space3DSW *space = soft_body->get_space();
@@ -936,49 +936,49 @@ RID PhysicsServer3DSW::soft_body_get_space(RID p_body) const {
 }
 
 void PhysicsServer3DSW::soft_body_set_collision_layer(RID p_body, uint32_t p_layer) {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!soft_body);
 
 	soft_body->set_collision_layer(p_layer);
 }
 
 uint32_t PhysicsServer3DSW::soft_body_get_collision_layer(RID p_body) const {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!soft_body, 0);
 
 	return soft_body->get_collision_layer();
 }
 
 void PhysicsServer3DSW::soft_body_set_collision_mask(RID p_body, uint32_t p_mask) {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!soft_body);
 
 	soft_body->set_collision_mask(p_mask);
 }
 
 uint32_t PhysicsServer3DSW::soft_body_get_collision_mask(RID p_body) const {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!soft_body, 0);
 
 	return soft_body->get_collision_mask();
 }
 
 void PhysicsServer3DSW::soft_body_add_collision_exception(RID p_body, RID p_body_b) {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!soft_body);
 
 	soft_body->add_exception(p_body_b);
 }
 
 void PhysicsServer3DSW::soft_body_remove_collision_exception(RID p_body, RID p_body_b) {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!soft_body);
 
 	soft_body->remove_exception(p_body_b);
 }
 
 void PhysicsServer3DSW::soft_body_get_collision_exceptions(RID p_body, List<RID> *p_exceptions) {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!soft_body);
 
 	for (int i = 0; i < soft_body->get_exceptions().size(); i++) {
@@ -987,154 +987,154 @@ void PhysicsServer3DSW::soft_body_get_collision_exceptions(RID p_body, List<RID>
 }
 
 void PhysicsServer3DSW::soft_body_set_state(RID p_body, BodyState p_state, const Variant &p_variant) {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!soft_body);
 
 	soft_body->set_state(p_state, p_variant);
 }
 
 Variant PhysicsServer3DSW::soft_body_get_state(RID p_body, BodyState p_state) const {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!soft_body, Variant());
 
 	return soft_body->get_state(p_state);
 }
 
 void PhysicsServer3DSW::soft_body_set_transform(RID p_body, const Transform3D &p_transform) {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!soft_body);
 
 	soft_body->set_state(BODY_STATE_TRANSFORM, p_transform);
 }
 
 void PhysicsServer3DSW::soft_body_set_ray_pickable(RID p_body, bool p_enable) {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!soft_body);
 
 	soft_body->set_ray_pickable(p_enable);
 }
 
 void PhysicsServer3DSW::soft_body_set_simulation_precision(RID p_body, int p_simulation_precision) {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!soft_body);
 
 	soft_body->set_iteration_count(p_simulation_precision);
 }
 
 int PhysicsServer3DSW::soft_body_get_simulation_precision(RID p_body) const {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!soft_body, 0.f);
 
 	return soft_body->get_iteration_count();
 }
 
 void PhysicsServer3DSW::soft_body_set_total_mass(RID p_body, real_t p_total_mass) {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!soft_body);
 
 	soft_body->set_total_mass(p_total_mass);
 }
 
 real_t PhysicsServer3DSW::soft_body_get_total_mass(RID p_body) const {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!soft_body, 0.f);
 
 	return soft_body->get_total_mass();
 }
 
 void PhysicsServer3DSW::soft_body_set_linear_stiffness(RID p_body, real_t p_stiffness) {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!soft_body);
 
 	soft_body->set_linear_stiffness(p_stiffness);
 }
 
 real_t PhysicsServer3DSW::soft_body_get_linear_stiffness(RID p_body) const {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!soft_body, 0.f);
 
 	return soft_body->get_linear_stiffness();
 }
 
 void PhysicsServer3DSW::soft_body_set_pressure_coefficient(RID p_body, real_t p_pressure_coefficient) {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!soft_body);
 
 	soft_body->set_pressure_coefficient(p_pressure_coefficient);
 }
 
 real_t PhysicsServer3DSW::soft_body_get_pressure_coefficient(RID p_body) const {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!soft_body, 0.f);
 
 	return soft_body->get_pressure_coefficient();
 }
 
 void PhysicsServer3DSW::soft_body_set_damping_coefficient(RID p_body, real_t p_damping_coefficient) {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!soft_body);
 
 	soft_body->set_damping_coefficient(p_damping_coefficient);
 }
 
 real_t PhysicsServer3DSW::soft_body_get_damping_coefficient(RID p_body) const {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!soft_body, 0.f);
 
 	return soft_body->get_damping_coefficient();
 }
 
 void PhysicsServer3DSW::soft_body_set_drag_coefficient(RID p_body, real_t p_drag_coefficient) {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!soft_body);
 
 	soft_body->set_drag_coefficient(p_drag_coefficient);
 }
 
 real_t PhysicsServer3DSW::soft_body_get_drag_coefficient(RID p_body) const {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!soft_body, 0.f);
 
 	return soft_body->get_drag_coefficient();
 }
 
 void PhysicsServer3DSW::soft_body_set_mesh(RID p_body, const REF &p_mesh) {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!soft_body);
 
 	soft_body->set_mesh(p_mesh);
 }
 
 AABB PhysicsServer3DSW::soft_body_get_bounds(RID p_body) const {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!soft_body, AABB());
 
 	return soft_body->get_bounds();
 }
 
 void PhysicsServer3DSW::soft_body_move_point(RID p_body, int p_point_index, const Vector3 &p_global_position) {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!soft_body);
 
 	soft_body->set_vertex_position(p_point_index, p_global_position);
 }
 
 Vector3 PhysicsServer3DSW::soft_body_get_point_global_position(RID p_body, int p_point_index) const {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!soft_body, Vector3());
 
 	return soft_body->get_vertex_position(p_point_index);
 }
 
 void PhysicsServer3DSW::soft_body_remove_all_pinned_points(RID p_body) {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!soft_body);
 
 	soft_body->unpin_all_vertices();
 }
 
 void PhysicsServer3DSW::soft_body_pin_point(RID p_body, int p_point_index, bool p_pin) {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND(!soft_body);
 
 	if (p_pin) {
@@ -1145,7 +1145,7 @@ void PhysicsServer3DSW::soft_body_pin_point(RID p_body, int p_point_index, bool
 }
 
 bool PhysicsServer3DSW::soft_body_is_point_pinned(RID p_body, int p_point_index) const {
-	SoftBody3DSW *soft_body = soft_body_owner.getornull(p_body);
+	SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_body);
 	ERR_FAIL_COND_V(!soft_body, false);
 
 	return soft_body->is_vertex_pinned(p_point_index);
@@ -1161,7 +1161,7 @@ RID PhysicsServer3DSW::joint_create() {
 }
 
 void PhysicsServer3DSW::joint_clear(RID p_joint) {
-	Joint3DSW *joint = joint_owner.getornull(p_joint);
+	Joint3DSW *joint = joint_owner.get_or_null(p_joint);
 	if (joint->get_type() != JOINT_TYPE_MAX) {
 		Joint3DSW *empty_joint = memnew(Joint3DSW);
 		empty_joint->copy_settings_from(joint);
@@ -1172,7 +1172,7 @@ void PhysicsServer3DSW::joint_clear(RID p_joint) {
 }
 
 void PhysicsServer3DSW::joint_make_pin(RID p_joint, RID p_body_A, const Vector3 &p_local_A, RID p_body_B, const Vector3 &p_local_B) {
-	Body3DSW *body_A = body_owner.getornull(p_body_A);
+	Body3DSW *body_A = body_owner.get_or_null(p_body_A);
 	ERR_FAIL_COND(!body_A);
 
 	if (!p_body_B.is_valid()) {
@@ -1180,12 +1180,12 @@ void PhysicsServer3DSW::joint_make_pin(RID p_joint, RID p_body_A, const Vector3
 		p_body_B = body_A->get_space()->get_static_global_body();
 	}
 
-	Body3DSW *body_B = body_owner.getornull(p_body_B);
+	Body3DSW *body_B = body_owner.get_or_null(p_body_B);
 	ERR_FAIL_COND(!body_B);
 
 	ERR_FAIL_COND(body_A == body_B);
 
-	Joint3DSW *prev_joint = joint_owner.getornull(p_joint);
+	Joint3DSW *prev_joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND(prev_joint == nullptr);
 
 	Joint3DSW *joint = memnew(PinJoint3DSW(body_A, p_local_A, body_B, p_local_B));
@@ -1196,7 +1196,7 @@ void PhysicsServer3DSW::joint_make_pin(RID p_joint, RID p_body_A, const Vector3
 }
 
 void PhysicsServer3DSW::pin_joint_set_param(RID p_joint, PinJointParam p_param, real_t p_value) {
-	Joint3DSW *joint = joint_owner.getornull(p_joint);
+	Joint3DSW *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND(!joint);
 	ERR_FAIL_COND(joint->get_type() != JOINT_TYPE_PIN);
 	PinJoint3DSW *pin_joint = static_cast<PinJoint3DSW *>(joint);
@@ -1204,7 +1204,7 @@ void PhysicsServer3DSW::pin_joint_set_param(RID p_joint, PinJointParam p_param,
 }
 
 real_t PhysicsServer3DSW::pin_joint_get_param(RID p_joint, PinJointParam p_param) const {
-	Joint3DSW *joint = joint_owner.getornull(p_joint);
+	Joint3DSW *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND_V(!joint, 0);
 	ERR_FAIL_COND_V(joint->get_type() != JOINT_TYPE_PIN, 0);
 	PinJoint3DSW *pin_joint = static_cast<PinJoint3DSW *>(joint);
@@ -1212,7 +1212,7 @@ real_t PhysicsServer3DSW::pin_joint_get_param(RID p_joint, PinJointParam p_param
 }
 
 void PhysicsServer3DSW::pin_joint_set_local_a(RID p_joint, const Vector3 &p_A) {
-	Joint3DSW *joint = joint_owner.getornull(p_joint);
+	Joint3DSW *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND(!joint);
 	ERR_FAIL_COND(joint->get_type() != JOINT_TYPE_PIN);
 	PinJoint3DSW *pin_joint = static_cast<PinJoint3DSW *>(joint);
@@ -1220,7 +1220,7 @@ void PhysicsServer3DSW::pin_joint_set_local_a(RID p_joint, const Vector3 &p_A) {
 }
 
 Vector3 PhysicsServer3DSW::pin_joint_get_local_a(RID p_joint) const {
-	Joint3DSW *joint = joint_owner.getornull(p_joint);
+	Joint3DSW *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND_V(!joint, Vector3());
 	ERR_FAIL_COND_V(joint->get_type() != JOINT_TYPE_PIN, Vector3());
 	PinJoint3DSW *pin_joint = static_cast<PinJoint3DSW *>(joint);
@@ -1228,7 +1228,7 @@ Vector3 PhysicsServer3DSW::pin_joint_get_local_a(RID p_joint) const {
 }
 
 void PhysicsServer3DSW::pin_joint_set_local_b(RID p_joint, const Vector3 &p_B) {
-	Joint3DSW *joint = joint_owner.getornull(p_joint);
+	Joint3DSW *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND(!joint);
 	ERR_FAIL_COND(joint->get_type() != JOINT_TYPE_PIN);
 	PinJoint3DSW *pin_joint = static_cast<PinJoint3DSW *>(joint);
@@ -1236,7 +1236,7 @@ void PhysicsServer3DSW::pin_joint_set_local_b(RID p_joint, const Vector3 &p_B) {
 }
 
 Vector3 PhysicsServer3DSW::pin_joint_get_local_b(RID p_joint) const {
-	Joint3DSW *joint = joint_owner.getornull(p_joint);
+	Joint3DSW *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND_V(!joint, Vector3());
 	ERR_FAIL_COND_V(joint->get_type() != JOINT_TYPE_PIN, Vector3());
 	PinJoint3DSW *pin_joint = static_cast<PinJoint3DSW *>(joint);
@@ -1244,7 +1244,7 @@ Vector3 PhysicsServer3DSW::pin_joint_get_local_b(RID p_joint) const {
 }
 
 void PhysicsServer3DSW::joint_make_hinge(RID p_joint, RID p_body_A, const Transform3D &p_frame_A, RID p_body_B, const Transform3D &p_frame_B) {
-	Body3DSW *body_A = body_owner.getornull(p_body_A);
+	Body3DSW *body_A = body_owner.get_or_null(p_body_A);
 	ERR_FAIL_COND(!body_A);
 
 	if (!p_body_B.is_valid()) {
@@ -1252,12 +1252,12 @@ void PhysicsServer3DSW::joint_make_hinge(RID p_joint, RID p_body_A, const Transf
 		p_body_B = body_A->get_space()->get_static_global_body();
 	}
 
-	Body3DSW *body_B = body_owner.getornull(p_body_B);
+	Body3DSW *body_B = body_owner.get_or_null(p_body_B);
 	ERR_FAIL_COND(!body_B);
 
 	ERR_FAIL_COND(body_A == body_B);
 
-	Joint3DSW *prev_joint = joint_owner.getornull(p_joint);
+	Joint3DSW *prev_joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND(prev_joint == nullptr);
 
 	Joint3DSW *joint = memnew(HingeJoint3DSW(body_A, body_B, p_frame_A, p_frame_B));
@@ -1268,7 +1268,7 @@ void PhysicsServer3DSW::joint_make_hinge(RID p_joint, RID p_body_A, const Transf
 }
 
 void PhysicsServer3DSW::joint_make_hinge_simple(RID p_joint, 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) {
-	Body3DSW *body_A = body_owner.getornull(p_body_A);
+	Body3DSW *body_A = body_owner.get_or_null(p_body_A);
 	ERR_FAIL_COND(!body_A);
 
 	if (!p_body_B.is_valid()) {
@@ -1276,12 +1276,12 @@ void PhysicsServer3DSW::joint_make_hinge_simple(RID p_joint, RID p_body_A, const
 		p_body_B = body_A->get_space()->get_static_global_body();
 	}
 
-	Body3DSW *body_B = body_owner.getornull(p_body_B);
+	Body3DSW *body_B = body_owner.get_or_null(p_body_B);
 	ERR_FAIL_COND(!body_B);
 
 	ERR_FAIL_COND(body_A == body_B);
 
-	Joint3DSW *prev_joint = joint_owner.getornull(p_joint);
+	Joint3DSW *prev_joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND(prev_joint == nullptr);
 
 	Joint3DSW *joint = memnew(HingeJoint3DSW(body_A, body_B, p_pivot_A, p_pivot_B, p_axis_A, p_axis_B));
@@ -1292,7 +1292,7 @@ void PhysicsServer3DSW::joint_make_hinge_simple(RID p_joint, RID p_body_A, const
 }
 
 void PhysicsServer3DSW::hinge_joint_set_param(RID p_joint, HingeJointParam p_param, real_t p_value) {
-	Joint3DSW *joint = joint_owner.getornull(p_joint);
+	Joint3DSW *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND(!joint);
 	ERR_FAIL_COND(joint->get_type() != JOINT_TYPE_HINGE);
 	HingeJoint3DSW *hinge_joint = static_cast<HingeJoint3DSW *>(joint);
@@ -1300,7 +1300,7 @@ void PhysicsServer3DSW::hinge_joint_set_param(RID p_joint, HingeJointParam p_par
 }
 
 real_t PhysicsServer3DSW::hinge_joint_get_param(RID p_joint, HingeJointParam p_param) const {
-	Joint3DSW *joint = joint_owner.getornull(p_joint);
+	Joint3DSW *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND_V(!joint, 0);
 	ERR_FAIL_COND_V(joint->get_type() != JOINT_TYPE_HINGE, 0);
 	HingeJoint3DSW *hinge_joint = static_cast<HingeJoint3DSW *>(joint);
@@ -1308,7 +1308,7 @@ real_t PhysicsServer3DSW::hinge_joint_get_param(RID p_joint, HingeJointParam p_p
 }
 
 void PhysicsServer3DSW::hinge_joint_set_flag(RID p_joint, HingeJointFlag p_flag, bool p_value) {
-	Joint3DSW *joint = joint_owner.getornull(p_joint);
+	Joint3DSW *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND(!joint);
 	ERR_FAIL_COND(joint->get_type() != JOINT_TYPE_HINGE);
 	HingeJoint3DSW *hinge_joint = static_cast<HingeJoint3DSW *>(joint);
@@ -1316,7 +1316,7 @@ void PhysicsServer3DSW::hinge_joint_set_flag(RID p_joint, HingeJointFlag p_flag,
 }
 
 bool PhysicsServer3DSW::hinge_joint_get_flag(RID p_joint, HingeJointFlag p_flag) const {
-	Joint3DSW *joint = joint_owner.getornull(p_joint);
+	Joint3DSW *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND_V(!joint, false);
 	ERR_FAIL_COND_V(joint->get_type() != JOINT_TYPE_HINGE, false);
 	HingeJoint3DSW *hinge_joint = static_cast<HingeJoint3DSW *>(joint);
@@ -1324,19 +1324,19 @@ bool PhysicsServer3DSW::hinge_joint_get_flag(RID p_joint, HingeJointFlag p_flag)
 }
 
 void PhysicsServer3DSW::joint_set_solver_priority(RID p_joint, int p_priority) {
-	Joint3DSW *joint = joint_owner.getornull(p_joint);
+	Joint3DSW *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND(!joint);
 	joint->set_priority(p_priority);
 }
 
 int PhysicsServer3DSW::joint_get_solver_priority(RID p_joint) const {
-	Joint3DSW *joint = joint_owner.getornull(p_joint);
+	Joint3DSW *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND_V(!joint, 0);
 	return joint->get_priority();
 }
 
 void PhysicsServer3DSW::joint_disable_collisions_between_bodies(RID p_joint, const bool p_disable) {
-	Joint3DSW *joint = joint_owner.getornull(p_joint);
+	Joint3DSW *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND(!joint);
 
 	joint->disable_collisions_between_bodies(p_disable);
@@ -1356,20 +1356,20 @@ void PhysicsServer3DSW::joint_disable_collisions_between_bodies(RID p_joint, con
 }
 
 bool PhysicsServer3DSW::joint_is_disabled_collisions_between_bodies(RID p_joint) const {
-	Joint3DSW *joint = joint_owner.getornull(p_joint);
+	Joint3DSW *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND_V(!joint, true);
 
 	return joint->is_disabled_collisions_between_bodies();
 }
 
 PhysicsServer3DSW::JointType PhysicsServer3DSW::joint_get_type(RID p_joint) const {
-	Joint3DSW *joint = joint_owner.getornull(p_joint);
+	Joint3DSW *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND_V(!joint, JOINT_TYPE_PIN);
 	return joint->get_type();
 }
 
 void PhysicsServer3DSW::joint_make_slider(RID p_joint, RID p_body_A, const Transform3D &p_local_frame_A, RID p_body_B, const Transform3D &p_local_frame_B) {
-	Body3DSW *body_A = body_owner.getornull(p_body_A);
+	Body3DSW *body_A = body_owner.get_or_null(p_body_A);
 	ERR_FAIL_COND(!body_A);
 
 	if (!p_body_B.is_valid()) {
@@ -1377,12 +1377,12 @@ void PhysicsServer3DSW::joint_make_slider(RID p_joint, RID p_body_A, const Trans
 		p_body_B = body_A->get_space()->get_static_global_body();
 	}
 
-	Body3DSW *body_B = body_owner.getornull(p_body_B);
+	Body3DSW *body_B = body_owner.get_or_null(p_body_B);
 	ERR_FAIL_COND(!body_B);
 
 	ERR_FAIL_COND(body_A == body_B);
 
-	Joint3DSW *prev_joint = joint_owner.getornull(p_joint);
+	Joint3DSW *prev_joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND(prev_joint == nullptr);
 
 	Joint3DSW *joint = memnew(SliderJoint3DSW(body_A, body_B, p_local_frame_A, p_local_frame_B));
@@ -1393,7 +1393,7 @@ void PhysicsServer3DSW::joint_make_slider(RID p_joint, RID p_body_A, const Trans
 }
 
 void PhysicsServer3DSW::slider_joint_set_param(RID p_joint, SliderJointParam p_param, real_t p_value) {
-	Joint3DSW *joint = joint_owner.getornull(p_joint);
+	Joint3DSW *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND(!joint);
 	ERR_FAIL_COND(joint->get_type() != JOINT_TYPE_SLIDER);
 	SliderJoint3DSW *slider_joint = static_cast<SliderJoint3DSW *>(joint);
@@ -1401,7 +1401,7 @@ void PhysicsServer3DSW::slider_joint_set_param(RID p_joint, SliderJointParam p_p
 }
 
 real_t PhysicsServer3DSW::slider_joint_get_param(RID p_joint, SliderJointParam p_param) const {
-	Joint3DSW *joint = joint_owner.getornull(p_joint);
+	Joint3DSW *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND_V(!joint, 0);
 	ERR_FAIL_COND_V(joint->get_type() != JOINT_TYPE_CONE_TWIST, 0);
 	SliderJoint3DSW *slider_joint = static_cast<SliderJoint3DSW *>(joint);
@@ -1409,7 +1409,7 @@ real_t PhysicsServer3DSW::slider_joint_get_param(RID p_joint, SliderJointParam p
 }
 
 void PhysicsServer3DSW::joint_make_cone_twist(RID p_joint, RID p_body_A, const Transform3D &p_local_frame_A, RID p_body_B, const Transform3D &p_local_frame_B) {
-	Body3DSW *body_A = body_owner.getornull(p_body_A);
+	Body3DSW *body_A = body_owner.get_or_null(p_body_A);
 	ERR_FAIL_COND(!body_A);
 
 	if (!p_body_B.is_valid()) {
@@ -1417,12 +1417,12 @@ void PhysicsServer3DSW::joint_make_cone_twist(RID p_joint, RID p_body_A, const T
 		p_body_B = body_A->get_space()->get_static_global_body();
 	}
 
-	Body3DSW *body_B = body_owner.getornull(p_body_B);
+	Body3DSW *body_B = body_owner.get_or_null(p_body_B);
 	ERR_FAIL_COND(!body_B);
 
 	ERR_FAIL_COND(body_A == body_B);
 
-	Joint3DSW *prev_joint = joint_owner.getornull(p_joint);
+	Joint3DSW *prev_joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND(prev_joint == nullptr);
 
 	Joint3DSW *joint = memnew(ConeTwistJoint3DSW(body_A, body_B, p_local_frame_A, p_local_frame_B));
@@ -1433,7 +1433,7 @@ void PhysicsServer3DSW::joint_make_cone_twist(RID p_joint, RID p_body_A, const T
 }
 
 void PhysicsServer3DSW::cone_twist_joint_set_param(RID p_joint, ConeTwistJointParam p_param, real_t p_value) {
-	Joint3DSW *joint = joint_owner.getornull(p_joint);
+	Joint3DSW *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND(!joint);
 	ERR_FAIL_COND(joint->get_type() != JOINT_TYPE_CONE_TWIST);
 	ConeTwistJoint3DSW *cone_twist_joint = static_cast<ConeTwistJoint3DSW *>(joint);
@@ -1441,7 +1441,7 @@ void PhysicsServer3DSW::cone_twist_joint_set_param(RID p_joint, ConeTwistJointPa
 }
 
 real_t PhysicsServer3DSW::cone_twist_joint_get_param(RID p_joint, ConeTwistJointParam p_param) const {
-	Joint3DSW *joint = joint_owner.getornull(p_joint);
+	Joint3DSW *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND_V(!joint, 0);
 	ERR_FAIL_COND_V(joint->get_type() != JOINT_TYPE_CONE_TWIST, 0);
 	ConeTwistJoint3DSW *cone_twist_joint = static_cast<ConeTwistJoint3DSW *>(joint);
@@ -1449,7 +1449,7 @@ real_t PhysicsServer3DSW::cone_twist_joint_get_param(RID p_joint, ConeTwistJoint
 }
 
 void PhysicsServer3DSW::joint_make_generic_6dof(RID p_joint, RID p_body_A, const Transform3D &p_local_frame_A, RID p_body_B, const Transform3D &p_local_frame_B) {
-	Body3DSW *body_A = body_owner.getornull(p_body_A);
+	Body3DSW *body_A = body_owner.get_or_null(p_body_A);
 	ERR_FAIL_COND(!body_A);
 
 	if (!p_body_B.is_valid()) {
@@ -1457,12 +1457,12 @@ void PhysicsServer3DSW::joint_make_generic_6dof(RID p_joint, RID p_body_A, const
 		p_body_B = body_A->get_space()->get_static_global_body();
 	}
 
-	Body3DSW *body_B = body_owner.getornull(p_body_B);
+	Body3DSW *body_B = body_owner.get_or_null(p_body_B);
 	ERR_FAIL_COND(!body_B);
 
 	ERR_FAIL_COND(body_A == body_B);
 
-	Joint3DSW *prev_joint = joint_owner.getornull(p_joint);
+	Joint3DSW *prev_joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND(prev_joint == nullptr);
 
 	Joint3DSW *joint = memnew(Generic6DOFJoint3DSW(body_A, body_B, p_local_frame_A, p_local_frame_B, true));
@@ -1473,7 +1473,7 @@ void PhysicsServer3DSW::joint_make_generic_6dof(RID p_joint, RID p_body_A, const
 }
 
 void PhysicsServer3DSW::generic_6dof_joint_set_param(RID p_joint, Vector3::Axis p_axis, G6DOFJointAxisParam p_param, real_t p_value) {
-	Joint3DSW *joint = joint_owner.getornull(p_joint);
+	Joint3DSW *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND(!joint);
 	ERR_FAIL_COND(joint->get_type() != JOINT_TYPE_6DOF);
 	Generic6DOFJoint3DSW *generic_6dof_joint = static_cast<Generic6DOFJoint3DSW *>(joint);
@@ -1481,7 +1481,7 @@ void PhysicsServer3DSW::generic_6dof_joint_set_param(RID p_joint, Vector3::Axis
 }
 
 real_t PhysicsServer3DSW::generic_6dof_joint_get_param(RID p_joint, Vector3::Axis p_axis, G6DOFJointAxisParam p_param) const {
-	Joint3DSW *joint = joint_owner.getornull(p_joint);
+	Joint3DSW *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND_V(!joint, 0);
 	ERR_FAIL_COND_V(joint->get_type() != JOINT_TYPE_6DOF, 0);
 	Generic6DOFJoint3DSW *generic_6dof_joint = static_cast<Generic6DOFJoint3DSW *>(joint);
@@ -1489,7 +1489,7 @@ real_t PhysicsServer3DSW::generic_6dof_joint_get_param(RID p_joint, Vector3::Axi
 }
 
 void PhysicsServer3DSW::generic_6dof_joint_set_flag(RID p_joint, Vector3::Axis p_axis, G6DOFJointAxisFlag p_flag, bool p_enable) {
-	Joint3DSW *joint = joint_owner.getornull(p_joint);
+	Joint3DSW *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND(!joint);
 	ERR_FAIL_COND(joint->get_type() != JOINT_TYPE_6DOF);
 	Generic6DOFJoint3DSW *generic_6dof_joint = static_cast<Generic6DOFJoint3DSW *>(joint);
@@ -1497,7 +1497,7 @@ void PhysicsServer3DSW::generic_6dof_joint_set_flag(RID p_joint, Vector3::Axis p
 }
 
 bool PhysicsServer3DSW::generic_6dof_joint_get_flag(RID p_joint, Vector3::Axis p_axis, G6DOFJointAxisFlag p_flag) const {
-	Joint3DSW *joint = joint_owner.getornull(p_joint);
+	Joint3DSW *joint = joint_owner.get_or_null(p_joint);
 	ERR_FAIL_COND_V(!joint, false);
 	ERR_FAIL_COND_V(joint->get_type() != JOINT_TYPE_6DOF, false);
 	Generic6DOFJoint3DSW *generic_6dof_joint = static_cast<Generic6DOFJoint3DSW *>(joint);
@@ -1508,7 +1508,7 @@ void PhysicsServer3DSW::free(RID p_rid) {
 	_update_shapes(); //just in case
 
 	if (shape_owner.owns(p_rid)) {
-		Shape3DSW *shape = shape_owner.getornull(p_rid);
+		Shape3DSW *shape = shape_owner.get_or_null(p_rid);
 
 		while (shape->get_owners().size()) {
 			ShapeOwner3DSW *so = shape->get_owners().front()->key();
@@ -1518,7 +1518,7 @@ void PhysicsServer3DSW::free(RID p_rid) {
 		shape_owner.free(p_rid);
 		memdelete(shape);
 	} else if (body_owner.owns(p_rid)) {
-		Body3DSW *body = body_owner.getornull(p_rid);
+		Body3DSW *body = body_owner.get_or_null(p_rid);
 
 		/*
 		if (body->get_state_query())
@@ -1537,14 +1537,14 @@ void PhysicsServer3DSW::free(RID p_rid) {
 		body_owner.free(p_rid);
 		memdelete(body);
 	} else if (soft_body_owner.owns(p_rid)) {
-		SoftBody3DSW *soft_body = soft_body_owner.getornull(p_rid);
+		SoftBody3DSW *soft_body = soft_body_owner.get_or_null(p_rid);
 
 		soft_body->set_space(nullptr);
 
 		soft_body_owner.free(p_rid);
 		memdelete(soft_body);
 	} else if (area_owner.owns(p_rid)) {
-		Area3DSW *area = area_owner.getornull(p_rid);
+		Area3DSW *area = area_owner.get_or_null(p_rid);
 
 		/*
 		if (area->get_monitor_query())
@@ -1560,7 +1560,7 @@ void PhysicsServer3DSW::free(RID p_rid) {
 		area_owner.free(p_rid);
 		memdelete(area);
 	} else if (space_owner.owns(p_rid)) {
-		Space3DSW *space = space_owner.getornull(p_rid);
+		Space3DSW *space = space_owner.get_or_null(p_rid);
 
 		while (space->get_objects().size()) {
 			CollisionObject3DSW *co = (CollisionObject3DSW *)space->get_objects().front()->get();
@@ -1574,7 +1574,7 @@ void PhysicsServer3DSW::free(RID p_rid) {
 		space_owner.free(p_rid);
 		memdelete(space);
 	} else if (joint_owner.owns(p_rid)) {
-		Joint3DSW *joint = joint_owner.getornull(p_rid);
+		Joint3DSW *joint = joint_owner.get_or_null(p_rid);
 
 		joint_owner.free(p_rid);
 		memdelete(joint);
diff --git a/servers/physics_3d/space_3d_sw.cpp b/servers/physics_3d/space_3d_sw.cpp
index 78c4e30c83..3718babbd6 100644
--- a/servers/physics_3d/space_3d_sw.cpp
+++ b/servers/physics_3d/space_3d_sw.cpp
@@ -187,7 +187,7 @@ int PhysicsDirectSpaceState3DSW::intersect_shape(const RID &p_shape, const Trans
 		return 0;
 	}
 
-	Shape3DSW *shape = PhysicsServer3DSW::singletonsw->shape_owner.getornull(p_shape);
+	Shape3DSW *shape = PhysicsServer3DSW::singletonsw->shape_owner.get_or_null(p_shape);
 	ERR_FAIL_COND_V(!shape, 0);
 
 	AABB aabb = p_xform.xform(shape->get_aabb());
@@ -238,7 +238,7 @@ int PhysicsDirectSpaceState3DSW::intersect_shape(const RID &p_shape, const Trans
 }
 
 bool PhysicsDirectSpaceState3DSW::cast_motion(const RID &p_shape, const Transform3D &p_xform, const Vector3 &p_motion, real_t p_margin, real_t &p_closest_safe, real_t &p_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) {
-	Shape3DSW *shape = PhysicsServer3DSW::singletonsw->shape_owner.getornull(p_shape);
+	Shape3DSW *shape = PhysicsServer3DSW::singletonsw->shape_owner.get_or_null(p_shape);
 	ERR_FAIL_COND_V(!shape, false);
 
 	AABB aabb = p_xform.xform(shape->get_aabb());
@@ -361,7 +361,7 @@ bool PhysicsDirectSpaceState3DSW::collide_shape(RID p_shape, const Transform3D &
 		return false;
 	}
 
-	Shape3DSW *shape = PhysicsServer3DSW::singletonsw->shape_owner.getornull(p_shape);
+	Shape3DSW *shape = PhysicsServer3DSW::singletonsw->shape_owner.get_or_null(p_shape);
 	ERR_FAIL_COND_V(!shape, 0);
 
 	AABB aabb = p_shape_xform.xform(shape->get_aabb());
@@ -487,7 +487,7 @@ static void _rest_cbk_result(const Vector3 &p_point_A, int p_index_A, const Vect
 }
 
 bool PhysicsDirectSpaceState3DSW::rest_info(RID p_shape, const Transform3D &p_shape_xform, real_t 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) {
-	Shape3DSW *shape = PhysicsServer3DSW::singletonsw->shape_owner.getornull(p_shape);
+	Shape3DSW *shape = PhysicsServer3DSW::singletonsw->shape_owner.get_or_null(p_shape);
 	ERR_FAIL_COND_V(!shape, 0);
 
 	real_t min_contact_depth = p_margin * TEST_MOTION_MIN_CONTACT_DEPTH_FACTOR;
@@ -543,9 +543,9 @@ bool PhysicsDirectSpaceState3DSW::rest_info(RID p_shape, const Transform3D &p_sh
 }
 
 Vector3 PhysicsDirectSpaceState3DSW::get_closest_point_to_object_volume(RID p_object, const Vector3 p_point) const {
-	CollisionObject3DSW *obj = PhysicsServer3DSW::singletonsw->area_owner.getornull(p_object);
+	CollisionObject3DSW *obj = PhysicsServer3DSW::singletonsw->area_owner.get_or_null(p_object);
 	if (!obj) {
-		obj = PhysicsServer3DSW::singletonsw->body_owner.getornull(p_object);
+		obj = PhysicsServer3DSW::singletonsw->body_owner.get_or_null(p_object);
 	}
 	ERR_FAIL_COND_V(!obj, Vector3());
 
diff --git a/servers/rendering/rasterizer_dummy.h b/servers/rendering/rasterizer_dummy.h
index 35bb7722e7..f95221c05b 100644
--- a/servers/rendering/rasterizer_dummy.h
+++ b/servers/rendering/rasterizer_dummy.h
@@ -224,7 +224,7 @@ public:
 		return texture_owner.make_rid(texture);
 	}
 	void texture_2d_initialize(RID p_texture, const Ref<Image> &p_image) override {
-		DummyTexture *t = texture_owner.getornull(p_texture);
+		DummyTexture *t = texture_owner.get_or_null(p_texture);
 		ERR_FAIL_COND(!t);
 		t->image = p_image->duplicate();
 	}
@@ -241,7 +241,7 @@ public:
 	void texture_3d_placeholder_initialize(RID p_texture) override {}
 
 	Ref<Image> texture_2d_get(RID p_texture) const override {
-		DummyTexture *t = texture_owner.getornull(p_texture);
+		DummyTexture *t = texture_owner.get_or_null(p_texture);
 		ERR_FAIL_COND_V(!t, Ref<Image>());
 		return t->image;
 	}
@@ -661,7 +661,7 @@ public:
 	bool free(RID p_rid) override {
 		if (texture_owner.owns(p_rid)) {
 			// delete the texture
-			DummyTexture *texture = texture_owner.getornull(p_rid);
+			DummyTexture *texture = texture_owner.get_or_null(p_rid);
 			texture_owner.free(p_rid);
 			memdelete(texture);
 			return true;
diff --git a/servers/rendering/renderer_canvas_cull.cpp b/servers/rendering/renderer_canvas_cull.cpp
index 456c736731..46683e8e68 100644
--- a/servers/rendering/renderer_canvas_cull.cpp
+++ b/servers/rendering/renderer_canvas_cull.cpp
@@ -100,7 +100,7 @@ void _collect_ysort_children(RendererCanvasCull::Item *p_canvas_item, Transform2
 void _mark_ysort_dirty(RendererCanvasCull::Item *ysort_owner, RID_Owner<RendererCanvasCull::Item, true> &canvas_item_owner) {
 	do {
 		ysort_owner->ysort_children_count = -1;
-		ysort_owner = canvas_item_owner.owns(ysort_owner->parent) ? canvas_item_owner.getornull(ysort_owner->parent) : nullptr;
+		ysort_owner = canvas_item_owner.owns(ysort_owner->parent) ? canvas_item_owner.get_or_null(ysort_owner->parent) : nullptr;
 	} while (ysort_owner && ysort_owner->sort_y);
 }
 
@@ -396,9 +396,9 @@ void RendererCanvasCull::canvas_initialize(RID p_rid) {
 }
 
 void RendererCanvasCull::canvas_set_item_mirroring(RID p_canvas, RID p_item, const Point2 &p_mirroring) {
-	Canvas *canvas = canvas_owner.getornull(p_canvas);
+	Canvas *canvas = canvas_owner.get_or_null(p_canvas);
 	ERR_FAIL_COND(!canvas);
-	Item *canvas_item = canvas_item_owner.getornull(p_item);
+	Item *canvas_item = canvas_item_owner.get_or_null(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	int idx = canvas->find_item(canvas_item);
@@ -407,7 +407,7 @@ void RendererCanvasCull::canvas_set_item_mirroring(RID p_canvas, RID p_item, con
 }
 
 void RendererCanvasCull::canvas_set_modulate(RID p_canvas, const Color &p_color) {
-	Canvas *canvas = canvas_owner.getornull(p_canvas);
+	Canvas *canvas = canvas_owner.get_or_null(p_canvas);
 	ERR_FAIL_COND(!canvas);
 	canvas->modulate = p_color;
 }
@@ -417,7 +417,7 @@ void RendererCanvasCull::canvas_set_disable_scale(bool p_disable) {
 }
 
 void RendererCanvasCull::canvas_set_parent(RID p_canvas, RID p_parent, float p_scale) {
-	Canvas *canvas = canvas_owner.getornull(p_canvas);
+	Canvas *canvas = canvas_owner.get_or_null(p_canvas);
 	ERR_FAIL_COND(!canvas);
 
 	canvas->parent = p_parent;
@@ -432,15 +432,15 @@ void RendererCanvasCull::canvas_item_initialize(RID p_rid) {
 }
 
 void RendererCanvasCull::canvas_item_set_parent(RID p_item, RID p_parent) {
-	Item *canvas_item = canvas_item_owner.getornull(p_item);
+	Item *canvas_item = canvas_item_owner.get_or_null(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	if (canvas_item->parent.is_valid()) {
 		if (canvas_owner.owns(canvas_item->parent)) {
-			Canvas *canvas = canvas_owner.getornull(canvas_item->parent);
+			Canvas *canvas = canvas_owner.get_or_null(canvas_item->parent);
 			canvas->erase_item(canvas_item);
 		} else if (canvas_item_owner.owns(canvas_item->parent)) {
-			Item *item_owner = canvas_item_owner.getornull(canvas_item->parent);
+			Item *item_owner = canvas_item_owner.get_or_null(canvas_item->parent);
 			item_owner->child_items.erase(canvas_item);
 
 			if (item_owner->sort_y) {
@@ -453,13 +453,13 @@ void RendererCanvasCull::canvas_item_set_parent(RID p_item, RID p_parent) {
 
 	if (p_parent.is_valid()) {
 		if (canvas_owner.owns(p_parent)) {
-			Canvas *canvas = canvas_owner.getornull(p_parent);
+			Canvas *canvas = canvas_owner.get_or_null(p_parent);
 			Canvas::ChildItem ci;
 			ci.item = canvas_item;
 			canvas->child_items.push_back(ci);
 			canvas->children_order_dirty = true;
 		} else if (canvas_item_owner.owns(p_parent)) {
-			Item *item_owner = canvas_item_owner.getornull(p_parent);
+			Item *item_owner = canvas_item_owner.get_or_null(p_parent);
 			item_owner->child_items.push_back(canvas_item);
 			item_owner->children_order_dirty = true;
 
@@ -476,7 +476,7 @@ void RendererCanvasCull::canvas_item_set_parent(RID p_item, RID p_parent) {
 }
 
 void RendererCanvasCull::canvas_item_set_visible(RID p_item, bool p_visible) {
-	Item *canvas_item = canvas_item_owner.getornull(p_item);
+	Item *canvas_item = canvas_item_owner.get_or_null(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	canvas_item->visible = p_visible;
@@ -485,35 +485,35 @@ void RendererCanvasCull::canvas_item_set_visible(RID p_item, bool p_visible) {
 }
 
 void RendererCanvasCull::canvas_item_set_light_mask(RID p_item, int p_mask) {
-	Item *canvas_item = canvas_item_owner.getornull(p_item);
+	Item *canvas_item = canvas_item_owner.get_or_null(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	canvas_item->light_mask = p_mask;
 }
 
 void RendererCanvasCull::canvas_item_set_transform(RID p_item, const Transform2D &p_transform) {
-	Item *canvas_item = canvas_item_owner.getornull(p_item);
+	Item *canvas_item = canvas_item_owner.get_or_null(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	canvas_item->xform = p_transform;
 }
 
 void RendererCanvasCull::canvas_item_set_clip(RID p_item, bool p_clip) {
-	Item *canvas_item = canvas_item_owner.getornull(p_item);
+	Item *canvas_item = canvas_item_owner.get_or_null(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	canvas_item->clip = p_clip;
 }
 
 void RendererCanvasCull::canvas_item_set_distance_field_mode(RID p_item, bool p_enable) {
-	Item *canvas_item = canvas_item_owner.getornull(p_item);
+	Item *canvas_item = canvas_item_owner.get_or_null(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	canvas_item->distance_field = p_enable;
 }
 
 void RendererCanvasCull::canvas_item_set_custom_rect(RID p_item, bool p_custom_rect, const Rect2 &p_rect) {
-	Item *canvas_item = canvas_item_owner.getornull(p_item);
+	Item *canvas_item = canvas_item_owner.get_or_null(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	canvas_item->custom_rect = p_custom_rect;
@@ -521,35 +521,35 @@ void RendererCanvasCull::canvas_item_set_custom_rect(RID p_item, bool p_custom_r
 }
 
 void RendererCanvasCull::canvas_item_set_modulate(RID p_item, const Color &p_color) {
-	Item *canvas_item = canvas_item_owner.getornull(p_item);
+	Item *canvas_item = canvas_item_owner.get_or_null(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	canvas_item->modulate = p_color;
 }
 
 void RendererCanvasCull::canvas_item_set_self_modulate(RID p_item, const Color &p_color) {
-	Item *canvas_item = canvas_item_owner.getornull(p_item);
+	Item *canvas_item = canvas_item_owner.get_or_null(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	canvas_item->self_modulate = p_color;
 }
 
 void RendererCanvasCull::canvas_item_set_draw_behind_parent(RID p_item, bool p_enable) {
-	Item *canvas_item = canvas_item_owner.getornull(p_item);
+	Item *canvas_item = canvas_item_owner.get_or_null(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	canvas_item->behind = p_enable;
 }
 
 void RendererCanvasCull::canvas_item_set_update_when_visible(RID p_item, bool p_update) {
-	Item *canvas_item = canvas_item_owner.getornull(p_item);
+	Item *canvas_item = canvas_item_owner.get_or_null(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	canvas_item->update_when_visible = p_update;
 }
 
 void RendererCanvasCull::canvas_item_add_line(RID p_item, const Point2 &p_from, const Point2 &p_to, const Color &p_color, float p_width) {
-	Item *canvas_item = canvas_item_owner.getornull(p_item);
+	Item *canvas_item = canvas_item_owner.get_or_null(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	Item::CommandPrimitive *line = canvas_item->alloc_command<Item::CommandPrimitive>();
@@ -573,7 +573,7 @@ void RendererCanvasCull::canvas_item_add_line(RID p_item, const Point2 &p_from,
 
 void RendererCanvasCull::canvas_item_add_polyline(RID p_item, const Vector<Point2> &p_points, const Vector<Color> &p_colors, float p_width, bool p_antialiased) {
 	ERR_FAIL_COND(p_points.size() < 2);
-	Item *canvas_item = canvas_item_owner.getornull(p_item);
+	Item *canvas_item = canvas_item_owner.get_or_null(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	Color color = Color(1, 1, 1, 1);
@@ -714,7 +714,7 @@ void RendererCanvasCull::canvas_item_add_polyline(RID p_item, const Vector<Point
 
 void RendererCanvasCull::canvas_item_add_multiline(RID p_item, const Vector<Point2> &p_points, const Vector<Color> &p_colors, float p_width) {
 	ERR_FAIL_COND(p_points.size() < 2);
-	Item *canvas_item = canvas_item_owner.getornull(p_item);
+	Item *canvas_item = canvas_item_owner.get_or_null(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	Item::CommandPolygon *pline = canvas_item->alloc_command<Item::CommandPolygon>();
@@ -730,7 +730,7 @@ void RendererCanvasCull::canvas_item_add_multiline(RID p_item, const Vector<Poin
 }
 
 void RendererCanvasCull::canvas_item_add_rect(RID p_item, const Rect2 &p_rect, const Color &p_color) {
-	Item *canvas_item = canvas_item_owner.getornull(p_item);
+	Item *canvas_item = canvas_item_owner.get_or_null(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	Item::CommandRect *rect = canvas_item->alloc_command<Item::CommandRect>();
@@ -740,7 +740,7 @@ void RendererCanvasCull::canvas_item_add_rect(RID p_item, const Rect2 &p_rect, c
 }
 
 void RendererCanvasCull::canvas_item_add_circle(RID p_item, const Point2 &p_pos, float p_radius, const Color &p_color) {
-	Item *canvas_item = canvas_item_owner.getornull(p_item);
+	Item *canvas_item = canvas_item_owner.get_or_null(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	Item::CommandPolygon *circle = canvas_item->alloc_command<Item::CommandPolygon>();
@@ -776,7 +776,7 @@ void RendererCanvasCull::canvas_item_add_circle(RID p_item, const Point2 &p_pos,
 }
 
 void RendererCanvasCull::canvas_item_add_texture_rect(RID p_item, const Rect2 &p_rect, RID p_texture, bool p_tile, const Color &p_modulate, bool p_transpose) {
-	Item *canvas_item = canvas_item_owner.getornull(p_item);
+	Item *canvas_item = canvas_item_owner.get_or_null(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	Item::CommandRect *rect = canvas_item->alloc_command<Item::CommandRect>();
@@ -807,7 +807,7 @@ void RendererCanvasCull::canvas_item_add_texture_rect(RID p_item, const Rect2 &p
 }
 
 void RendererCanvasCull::canvas_item_add_msdf_texture_rect_region(RID p_item, const Rect2 &p_rect, RID p_texture, const Rect2 &p_src_rect, const Color &p_modulate, int p_outline_size, float p_px_range) {
-	Item *canvas_item = canvas_item_owner.getornull(p_item);
+	Item *canvas_item = canvas_item_owner.get_or_null(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	Item::CommandRect *rect = canvas_item->alloc_command<Item::CommandRect>();
@@ -841,7 +841,7 @@ void RendererCanvasCull::canvas_item_add_msdf_texture_rect_region(RID p_item, co
 }
 
 void RendererCanvasCull::canvas_item_add_texture_rect_region(RID p_item, const Rect2 &p_rect, RID p_texture, const Rect2 &p_src_rect, const Color &p_modulate, bool p_transpose, bool p_clip_uv) {
-	Item *canvas_item = canvas_item_owner.getornull(p_item);
+	Item *canvas_item = canvas_item_owner.get_or_null(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	Item::CommandRect *rect = canvas_item->alloc_command<Item::CommandRect>();
@@ -882,7 +882,7 @@ void RendererCanvasCull::canvas_item_add_texture_rect_region(RID p_item, const R
 }
 
 void RendererCanvasCull::canvas_item_add_nine_patch(RID p_item, const Rect2 &p_rect, const Rect2 &p_source, RID p_texture, const Vector2 &p_topleft, const Vector2 &p_bottomright, RS::NinePatchAxisMode p_x_axis_mode, RS::NinePatchAxisMode p_y_axis_mode, bool p_draw_center, const Color &p_modulate) {
-	Item *canvas_item = canvas_item_owner.getornull(p_item);
+	Item *canvas_item = canvas_item_owner.get_or_null(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	Item::CommandNinePatch *style = canvas_item->alloc_command<Item::CommandNinePatch>();
@@ -906,7 +906,7 @@ void RendererCanvasCull::canvas_item_add_primitive(RID p_item, const Vector<Poin
 	uint32_t pc = p_points.size();
 	ERR_FAIL_COND(pc == 0 || pc > 4);
 
-	Item *canvas_item = canvas_item_owner.getornull(p_item);
+	Item *canvas_item = canvas_item_owner.get_or_null(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	Item::CommandPrimitive *prim = canvas_item->alloc_command<Item::CommandPrimitive>();
@@ -932,7 +932,7 @@ void RendererCanvasCull::canvas_item_add_primitive(RID p_item, const Vector<Poin
 }
 
 void RendererCanvasCull::canvas_item_add_polygon(RID p_item, const Vector<Point2> &p_points, const Vector<Color> &p_colors, const Vector<Point2> &p_uvs, RID p_texture) {
-	Item *canvas_item = canvas_item_owner.getornull(p_item);
+	Item *canvas_item = canvas_item_owner.get_or_null(p_item);
 	ERR_FAIL_COND(!canvas_item);
 #ifdef DEBUG_ENABLED
 	int pointcount = p_points.size();
@@ -953,7 +953,7 @@ void RendererCanvasCull::canvas_item_add_polygon(RID p_item, const Vector<Point2
 }
 
 void RendererCanvasCull::canvas_item_add_triangle_array(RID p_item, const Vector<int> &p_indices, const Vector<Point2> &p_points, const Vector<Color> &p_colors, const Vector<Point2> &p_uvs, const Vector<int> &p_bones, const Vector<float> &p_weights, RID p_texture, int p_count) {
-	Item *canvas_item = canvas_item_owner.getornull(p_item);
+	Item *canvas_item = canvas_item_owner.get_or_null(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	int vertex_count = p_points.size();
@@ -976,7 +976,7 @@ void RendererCanvasCull::canvas_item_add_triangle_array(RID p_item, const Vector
 }
 
 void RendererCanvasCull::canvas_item_add_set_transform(RID p_item, const Transform2D &p_transform) {
-	Item *canvas_item = canvas_item_owner.getornull(p_item);
+	Item *canvas_item = canvas_item_owner.get_or_null(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	Item::CommandTransform *tr = canvas_item->alloc_command<Item::CommandTransform>();
@@ -985,7 +985,7 @@ void RendererCanvasCull::canvas_item_add_set_transform(RID p_item, const Transfo
 }
 
 void RendererCanvasCull::canvas_item_add_mesh(RID p_item, const RID &p_mesh, const Transform2D &p_transform, const Color &p_modulate, RID p_texture) {
-	Item *canvas_item = canvas_item_owner.getornull(p_item);
+	Item *canvas_item = canvas_item_owner.get_or_null(p_item);
 	ERR_FAIL_COND(!canvas_item);
 	ERR_FAIL_COND(!p_mesh.is_valid());
 
@@ -1004,7 +1004,7 @@ void RendererCanvasCull::canvas_item_add_mesh(RID p_item, const RID &p_mesh, con
 }
 
 void RendererCanvasCull::canvas_item_add_particles(RID p_item, RID p_particles, RID p_texture) {
-	Item *canvas_item = canvas_item_owner.getornull(p_item);
+	Item *canvas_item = canvas_item_owner.get_or_null(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	Item::CommandParticles *part = canvas_item->alloc_command<Item::CommandParticles>();
@@ -1018,7 +1018,7 @@ void RendererCanvasCull::canvas_item_add_particles(RID p_item, RID p_particles,
 }
 
 void RendererCanvasCull::canvas_item_add_multimesh(RID p_item, RID p_mesh, RID p_texture) {
-	Item *canvas_item = canvas_item_owner.getornull(p_item);
+	Item *canvas_item = canvas_item_owner.get_or_null(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	Item::CommandMultiMesh *mm = canvas_item->alloc_command<Item::CommandMultiMesh>();
@@ -1029,7 +1029,7 @@ void RendererCanvasCull::canvas_item_add_multimesh(RID p_item, RID p_mesh, RID p
 }
 
 void RendererCanvasCull::canvas_item_add_clip_ignore(RID p_item, bool p_ignore) {
-	Item *canvas_item = canvas_item_owner.getornull(p_item);
+	Item *canvas_item = canvas_item_owner.get_or_null(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	Item::CommandClipIgnore *ci = canvas_item->alloc_command<Item::CommandClipIgnore>();
@@ -1038,7 +1038,7 @@ void RendererCanvasCull::canvas_item_add_clip_ignore(RID p_item, bool p_ignore)
 }
 
 void RendererCanvasCull::canvas_item_add_animation_slice(RID p_item, double p_animation_length, double p_slice_begin, double p_slice_end, double p_offset) {
-	Item *canvas_item = canvas_item_owner.getornull(p_item);
+	Item *canvas_item = canvas_item_owner.get_or_null(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	Item::CommandAnimationSlice *as = canvas_item->alloc_command<Item::CommandAnimationSlice>();
@@ -1050,7 +1050,7 @@ void RendererCanvasCull::canvas_item_add_animation_slice(RID p_item, double p_an
 }
 
 void RendererCanvasCull::canvas_item_set_sort_children_by_y(RID p_item, bool p_enable) {
-	Item *canvas_item = canvas_item_owner.getornull(p_item);
+	Item *canvas_item = canvas_item_owner.get_or_null(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	canvas_item->sort_y = p_enable;
@@ -1061,21 +1061,21 @@ void RendererCanvasCull::canvas_item_set_sort_children_by_y(RID p_item, bool p_e
 void RendererCanvasCull::canvas_item_set_z_index(RID p_item, int p_z) {
 	ERR_FAIL_COND(p_z < RS::CANVAS_ITEM_Z_MIN || p_z > RS::CANVAS_ITEM_Z_MAX);
 
-	Item *canvas_item = canvas_item_owner.getornull(p_item);
+	Item *canvas_item = canvas_item_owner.get_or_null(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	canvas_item->z_index = p_z;
 }
 
 void RendererCanvasCull::canvas_item_set_z_as_relative_to_parent(RID p_item, bool p_enable) {
-	Item *canvas_item = canvas_item_owner.getornull(p_item);
+	Item *canvas_item = canvas_item_owner.get_or_null(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	canvas_item->z_relative = p_enable;
 }
 
 void RendererCanvasCull::canvas_item_attach_skeleton(RID p_item, RID p_skeleton) {
-	Item *canvas_item = canvas_item_owner.getornull(p_item);
+	Item *canvas_item = canvas_item_owner.get_or_null(p_item);
 	ERR_FAIL_COND(!canvas_item);
 	if (canvas_item->skeleton == p_skeleton) {
 		return;
@@ -1104,7 +1104,7 @@ void RendererCanvasCull::canvas_item_attach_skeleton(RID p_item, RID p_skeleton)
 }
 
 void RendererCanvasCull::canvas_item_set_copy_to_backbuffer(RID p_item, bool p_enable, const Rect2 &p_rect) {
-	Item *canvas_item = canvas_item_owner.getornull(p_item);
+	Item *canvas_item = canvas_item_owner.get_or_null(p_item);
 	ERR_FAIL_COND(!canvas_item);
 	if (p_enable && (canvas_item->copy_back_buffer == nullptr)) {
 		canvas_item->copy_back_buffer = memnew(RendererCanvasRender::Item::CopyBackBuffer);
@@ -1121,25 +1121,25 @@ void RendererCanvasCull::canvas_item_set_copy_to_backbuffer(RID p_item, bool p_e
 }
 
 void RendererCanvasCull::canvas_item_clear(RID p_item) {
-	Item *canvas_item = canvas_item_owner.getornull(p_item);
+	Item *canvas_item = canvas_item_owner.get_or_null(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	canvas_item->clear();
 }
 
 void RendererCanvasCull::canvas_item_set_draw_index(RID p_item, int p_index) {
-	Item *canvas_item = canvas_item_owner.getornull(p_item);
+	Item *canvas_item = canvas_item_owner.get_or_null(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	canvas_item->index = p_index;
 
 	if (canvas_item_owner.owns(canvas_item->parent)) {
-		Item *canvas_item_parent = canvas_item_owner.getornull(canvas_item->parent);
+		Item *canvas_item_parent = canvas_item_owner.get_or_null(canvas_item->parent);
 		canvas_item_parent->children_order_dirty = true;
 		return;
 	}
 
-	Canvas *canvas = canvas_owner.getornull(canvas_item->parent);
+	Canvas *canvas = canvas_owner.get_or_null(canvas_item->parent);
 	if (canvas) {
 		canvas->children_order_dirty = true;
 		return;
@@ -1147,21 +1147,21 @@ void RendererCanvasCull::canvas_item_set_draw_index(RID p_item, int p_index) {
 }
 
 void RendererCanvasCull::canvas_item_set_material(RID p_item, RID p_material) {
-	Item *canvas_item = canvas_item_owner.getornull(p_item);
+	Item *canvas_item = canvas_item_owner.get_or_null(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	canvas_item->material = p_material;
 }
 
 void RendererCanvasCull::canvas_item_set_use_parent_material(RID p_item, bool p_enable) {
-	Item *canvas_item = canvas_item_owner.getornull(p_item);
+	Item *canvas_item = canvas_item_owner.get_or_null(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	canvas_item->use_parent_material = p_enable;
 }
 
 void RendererCanvasCull::canvas_item_set_visibility_notifier(RID p_item, bool p_enable, const Rect2 &p_area, const Callable &p_enter_callable, const Callable &p_exit_callable) {
-	Item *canvas_item = canvas_item_owner.getornull(p_item);
+	Item *canvas_item = canvas_item_owner.get_or_null(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	if (p_enable) {
@@ -1181,7 +1181,7 @@ void RendererCanvasCull::canvas_item_set_visibility_notifier(RID p_item, bool p_
 }
 
 void RendererCanvasCull::canvas_item_set_canvas_group_mode(RID p_item, RS::CanvasGroupMode p_mode, float p_clear_margin, bool p_fit_empty, float p_fit_margin, bool p_blur_mipmaps) {
-	Item *canvas_item = canvas_item_owner.getornull(p_item);
+	Item *canvas_item = canvas_item_owner.get_or_null(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	if (p_mode == RS::CANVAS_GROUP_MODE_DISABLED) {
@@ -1206,12 +1206,12 @@ RID RendererCanvasCull::canvas_light_allocate() {
 }
 void RendererCanvasCull::canvas_light_initialize(RID p_rid) {
 	canvas_light_owner.initialize_rid(p_rid);
-	RendererCanvasRender::Light *clight = canvas_light_owner.getornull(p_rid);
+	RendererCanvasRender::Light *clight = canvas_light_owner.get_or_null(p_rid);
 	clight->light_internal = RSG::canvas_render->light_create();
 }
 
 void RendererCanvasCull::canvas_light_set_mode(RID p_light, RS::CanvasLightMode p_mode) {
-	RendererCanvasRender::Light *clight = canvas_light_owner.getornull(p_light);
+	RendererCanvasRender::Light *clight = canvas_light_owner.get_or_null(p_light);
 	ERR_FAIL_COND(!clight);
 
 	if (clight->mode == p_mode) {
@@ -1232,11 +1232,11 @@ void RendererCanvasCull::canvas_light_set_mode(RID p_light, RS::CanvasLightMode
 }
 
 void RendererCanvasCull::canvas_light_attach_to_canvas(RID p_light, RID p_canvas) {
-	RendererCanvasRender::Light *clight = canvas_light_owner.getornull(p_light);
+	RendererCanvasRender::Light *clight = canvas_light_owner.get_or_null(p_light);
 	ERR_FAIL_COND(!clight);
 
 	if (clight->canvas.is_valid()) {
-		Canvas *canvas = canvas_owner.getornull(clight->canvas);
+		Canvas *canvas = canvas_owner.get_or_null(clight->canvas);
 		if (clight->mode == RS::CANVAS_LIGHT_MODE_POINT) {
 			canvas->lights.erase(clight);
 		} else {
@@ -1251,7 +1251,7 @@ void RendererCanvasCull::canvas_light_attach_to_canvas(RID p_light, RID p_canvas
 	clight->canvas = p_canvas;
 
 	if (clight->canvas.is_valid()) {
-		Canvas *canvas = canvas_owner.getornull(clight->canvas);
+		Canvas *canvas = canvas_owner.get_or_null(clight->canvas);
 		if (clight->mode == RS::CANVAS_LIGHT_MODE_POINT) {
 			canvas->lights.insert(clight);
 		} else {
@@ -1261,28 +1261,28 @@ void RendererCanvasCull::canvas_light_attach_to_canvas(RID p_light, RID p_canvas
 }
 
 void RendererCanvasCull::canvas_light_set_enabled(RID p_light, bool p_enabled) {
-	RendererCanvasRender::Light *clight = canvas_light_owner.getornull(p_light);
+	RendererCanvasRender::Light *clight = canvas_light_owner.get_or_null(p_light);
 	ERR_FAIL_COND(!clight);
 
 	clight->enabled = p_enabled;
 }
 
 void RendererCanvasCull::canvas_light_set_texture_scale(RID p_light, float p_scale) {
-	RendererCanvasRender::Light *clight = canvas_light_owner.getornull(p_light);
+	RendererCanvasRender::Light *clight = canvas_light_owner.get_or_null(p_light);
 	ERR_FAIL_COND(!clight);
 
 	clight->scale = p_scale;
 }
 
 void RendererCanvasCull::canvas_light_set_transform(RID p_light, const Transform2D &p_transform) {
-	RendererCanvasRender::Light *clight = canvas_light_owner.getornull(p_light);
+	RendererCanvasRender::Light *clight = canvas_light_owner.get_or_null(p_light);
 	ERR_FAIL_COND(!clight);
 
 	clight->xform = p_transform;
 }
 
 void RendererCanvasCull::canvas_light_set_texture(RID p_light, RID p_texture) {
-	RendererCanvasRender::Light *clight = canvas_light_owner.getornull(p_light);
+	RendererCanvasRender::Light *clight = canvas_light_owner.get_or_null(p_light);
 	ERR_FAIL_COND(!clight);
 
 	if (clight->texture == p_texture) {
@@ -1294,35 +1294,35 @@ void RendererCanvasCull::canvas_light_set_texture(RID p_light, RID p_texture) {
 }
 
 void RendererCanvasCull::canvas_light_set_texture_offset(RID p_light, const Vector2 &p_offset) {
-	RendererCanvasRender::Light *clight = canvas_light_owner.getornull(p_light);
+	RendererCanvasRender::Light *clight = canvas_light_owner.get_or_null(p_light);
 	ERR_FAIL_COND(!clight);
 
 	clight->texture_offset = p_offset;
 }
 
 void RendererCanvasCull::canvas_light_set_color(RID p_light, const Color &p_color) {
-	RendererCanvasRender::Light *clight = canvas_light_owner.getornull(p_light);
+	RendererCanvasRender::Light *clight = canvas_light_owner.get_or_null(p_light);
 	ERR_FAIL_COND(!clight);
 
 	clight->color = p_color;
 }
 
 void RendererCanvasCull::canvas_light_set_height(RID p_light, float p_height) {
-	RendererCanvasRender::Light *clight = canvas_light_owner.getornull(p_light);
+	RendererCanvasRender::Light *clight = canvas_light_owner.get_or_null(p_light);
 	ERR_FAIL_COND(!clight);
 
 	clight->height = p_height;
 }
 
 void RendererCanvasCull::canvas_light_set_energy(RID p_light, float p_energy) {
-	RendererCanvasRender::Light *clight = canvas_light_owner.getornull(p_light);
+	RendererCanvasRender::Light *clight = canvas_light_owner.get_or_null(p_light);
 	ERR_FAIL_COND(!clight);
 
 	clight->energy = p_energy;
 }
 
 void RendererCanvasCull::canvas_light_set_z_range(RID p_light, int p_min_z, int p_max_z) {
-	RendererCanvasRender::Light *clight = canvas_light_owner.getornull(p_light);
+	RendererCanvasRender::Light *clight = canvas_light_owner.get_or_null(p_light);
 	ERR_FAIL_COND(!clight);
 
 	clight->z_min = p_min_z;
@@ -1330,7 +1330,7 @@ void RendererCanvasCull::canvas_light_set_z_range(RID p_light, int p_min_z, int
 }
 
 void RendererCanvasCull::canvas_light_set_layer_range(RID p_light, int p_min_layer, int p_max_layer) {
-	RendererCanvasRender::Light *clight = canvas_light_owner.getornull(p_light);
+	RendererCanvasRender::Light *clight = canvas_light_owner.get_or_null(p_light);
 	ERR_FAIL_COND(!clight);
 
 	clight->layer_max = p_max_layer;
@@ -1338,35 +1338,35 @@ void RendererCanvasCull::canvas_light_set_layer_range(RID p_light, int p_min_lay
 }
 
 void RendererCanvasCull::canvas_light_set_item_cull_mask(RID p_light, int p_mask) {
-	RendererCanvasRender::Light *clight = canvas_light_owner.getornull(p_light);
+	RendererCanvasRender::Light *clight = canvas_light_owner.get_or_null(p_light);
 	ERR_FAIL_COND(!clight);
 
 	clight->item_mask = p_mask;
 }
 
 void RendererCanvasCull::canvas_light_set_item_shadow_cull_mask(RID p_light, int p_mask) {
-	RendererCanvasRender::Light *clight = canvas_light_owner.getornull(p_light);
+	RendererCanvasRender::Light *clight = canvas_light_owner.get_or_null(p_light);
 	ERR_FAIL_COND(!clight);
 
 	clight->item_shadow_mask = p_mask;
 }
 
 void RendererCanvasCull::canvas_light_set_directional_distance(RID p_light, float p_distance) {
-	RendererCanvasRender::Light *clight = canvas_light_owner.getornull(p_light);
+	RendererCanvasRender::Light *clight = canvas_light_owner.get_or_null(p_light);
 	ERR_FAIL_COND(!clight);
 
 	clight->directional_distance = p_distance;
 }
 
 void RendererCanvasCull::canvas_light_set_blend_mode(RID p_light, RS::CanvasLightBlendMode p_mode) {
-	RendererCanvasRender::Light *clight = canvas_light_owner.getornull(p_light);
+	RendererCanvasRender::Light *clight = canvas_light_owner.get_or_null(p_light);
 	ERR_FAIL_COND(!clight);
 
 	clight->blend_mode = p_mode;
 }
 
 void RendererCanvasCull::canvas_light_set_shadow_enabled(RID p_light, bool p_enabled) {
-	RendererCanvasRender::Light *clight = canvas_light_owner.getornull(p_light);
+	RendererCanvasRender::Light *clight = canvas_light_owner.get_or_null(p_light);
 	ERR_FAIL_COND(!clight);
 
 	if (clight->use_shadow == p_enabled) {
@@ -1378,21 +1378,21 @@ void RendererCanvasCull::canvas_light_set_shadow_enabled(RID p_light, bool p_ena
 }
 
 void RendererCanvasCull::canvas_light_set_shadow_filter(RID p_light, RS::CanvasLightShadowFilter p_filter) {
-	RendererCanvasRender::Light *clight = canvas_light_owner.getornull(p_light);
+	RendererCanvasRender::Light *clight = canvas_light_owner.get_or_null(p_light);
 	ERR_FAIL_COND(!clight);
 
 	clight->shadow_filter = p_filter;
 }
 
 void RendererCanvasCull::canvas_light_set_shadow_color(RID p_light, const Color &p_color) {
-	RendererCanvasRender::Light *clight = canvas_light_owner.getornull(p_light);
+	RendererCanvasRender::Light *clight = canvas_light_owner.get_or_null(p_light);
 	ERR_FAIL_COND(!clight);
 
 	clight->shadow_color = p_color;
 }
 
 void RendererCanvasCull::canvas_light_set_shadow_smooth(RID p_light, float p_smooth) {
-	RendererCanvasRender::Light *clight = canvas_light_owner.getornull(p_light);
+	RendererCanvasRender::Light *clight = canvas_light_owner.get_or_null(p_light);
 	ERR_FAIL_COND(!clight);
 	clight->shadow_smooth = p_smooth;
 }
@@ -1405,11 +1405,11 @@ void RendererCanvasCull::canvas_light_occluder_initialize(RID p_rid) {
 }
 
 void RendererCanvasCull::canvas_light_occluder_attach_to_canvas(RID p_occluder, RID p_canvas) {
-	RendererCanvasRender::LightOccluderInstance *occluder = canvas_light_occluder_owner.getornull(p_occluder);
+	RendererCanvasRender::LightOccluderInstance *occluder = canvas_light_occluder_owner.get_or_null(p_occluder);
 	ERR_FAIL_COND(!occluder);
 
 	if (occluder->canvas.is_valid()) {
-		Canvas *canvas = canvas_owner.getornull(occluder->canvas);
+		Canvas *canvas = canvas_owner.get_or_null(occluder->canvas);
 		canvas->occluders.erase(occluder);
 	}
 
@@ -1420,24 +1420,24 @@ void RendererCanvasCull::canvas_light_occluder_attach_to_canvas(RID p_occluder,
 	occluder->canvas = p_canvas;
 
 	if (occluder->canvas.is_valid()) {
-		Canvas *canvas = canvas_owner.getornull(occluder->canvas);
+		Canvas *canvas = canvas_owner.get_or_null(occluder->canvas);
 		canvas->occluders.insert(occluder);
 	}
 }
 
 void RendererCanvasCull::canvas_light_occluder_set_enabled(RID p_occluder, bool p_enabled) {
-	RendererCanvasRender::LightOccluderInstance *occluder = canvas_light_occluder_owner.getornull(p_occluder);
+	RendererCanvasRender::LightOccluderInstance *occluder = canvas_light_occluder_owner.get_or_null(p_occluder);
 	ERR_FAIL_COND(!occluder);
 
 	occluder->enabled = p_enabled;
 }
 
 void RendererCanvasCull::canvas_light_occluder_set_polygon(RID p_occluder, RID p_polygon) {
-	RendererCanvasRender::LightOccluderInstance *occluder = canvas_light_occluder_owner.getornull(p_occluder);
+	RendererCanvasRender::LightOccluderInstance *occluder = canvas_light_occluder_owner.get_or_null(p_occluder);
 	ERR_FAIL_COND(!occluder);
 
 	if (occluder->polygon.is_valid()) {
-		LightOccluderPolygon *occluder_poly = canvas_light_occluder_polygon_owner.getornull(p_polygon);
+		LightOccluderPolygon *occluder_poly = canvas_light_occluder_polygon_owner.get_or_null(p_polygon);
 		if (occluder_poly) {
 			occluder_poly->owners.erase(occluder);
 		}
@@ -1447,7 +1447,7 @@ void RendererCanvasCull::canvas_light_occluder_set_polygon(RID p_occluder, RID p
 	occluder->occluder = RID();
 
 	if (occluder->polygon.is_valid()) {
-		LightOccluderPolygon *occluder_poly = canvas_light_occluder_polygon_owner.getornull(p_polygon);
+		LightOccluderPolygon *occluder_poly = canvas_light_occluder_polygon_owner.get_or_null(p_polygon);
 		if (!occluder_poly) {
 			occluder->polygon = RID();
 			ERR_FAIL_COND(!occluder_poly);
@@ -1461,19 +1461,19 @@ void RendererCanvasCull::canvas_light_occluder_set_polygon(RID p_occluder, RID p
 }
 
 void RendererCanvasCull::canvas_light_occluder_set_as_sdf_collision(RID p_occluder, bool p_enable) {
-	RendererCanvasRender::LightOccluderInstance *occluder = canvas_light_occluder_owner.getornull(p_occluder);
+	RendererCanvasRender::LightOccluderInstance *occluder = canvas_light_occluder_owner.get_or_null(p_occluder);
 	ERR_FAIL_COND(!occluder);
 }
 
 void RendererCanvasCull::canvas_light_occluder_set_transform(RID p_occluder, const Transform2D &p_xform) {
-	RendererCanvasRender::LightOccluderInstance *occluder = canvas_light_occluder_owner.getornull(p_occluder);
+	RendererCanvasRender::LightOccluderInstance *occluder = canvas_light_occluder_owner.get_or_null(p_occluder);
 	ERR_FAIL_COND(!occluder);
 
 	occluder->xform = p_xform;
 }
 
 void RendererCanvasCull::canvas_light_occluder_set_light_mask(RID p_occluder, int p_mask) {
-	RendererCanvasRender::LightOccluderInstance *occluder = canvas_light_occluder_owner.getornull(p_occluder);
+	RendererCanvasRender::LightOccluderInstance *occluder = canvas_light_occluder_owner.get_or_null(p_occluder);
 	ERR_FAIL_COND(!occluder);
 
 	occluder->light_mask = p_mask;
@@ -1484,12 +1484,12 @@ RID RendererCanvasCull::canvas_occluder_polygon_allocate() {
 }
 void RendererCanvasCull::canvas_occluder_polygon_initialize(RID p_rid) {
 	canvas_light_occluder_polygon_owner.initialize_rid(p_rid);
-	LightOccluderPolygon *occluder_poly = canvas_light_occluder_polygon_owner.getornull(p_rid);
+	LightOccluderPolygon *occluder_poly = canvas_light_occluder_polygon_owner.get_or_null(p_rid);
 	occluder_poly->occluder = RSG::canvas_render->occluder_polygon_create();
 }
 
 void RendererCanvasCull::canvas_occluder_polygon_set_shape(RID p_occluder_polygon, const Vector<Vector2> &p_shape, bool p_closed) {
-	LightOccluderPolygon *occluder_poly = canvas_light_occluder_polygon_owner.getornull(p_occluder_polygon);
+	LightOccluderPolygon *occluder_poly = canvas_light_occluder_polygon_owner.get_or_null(p_occluder_polygon);
 	ERR_FAIL_COND(!occluder_poly);
 
 	uint32_t pc = p_shape.size();
@@ -1513,7 +1513,7 @@ void RendererCanvasCull::canvas_occluder_polygon_set_shape(RID p_occluder_polygo
 }
 
 void RendererCanvasCull::canvas_occluder_polygon_set_cull_mode(RID p_occluder_polygon, RS::CanvasOccluderPolygonCullMode p_mode) {
-	LightOccluderPolygon *occluder_poly = canvas_light_occluder_polygon_owner.getornull(p_occluder_polygon);
+	LightOccluderPolygon *occluder_poly = canvas_light_occluder_polygon_owner.get_or_null(p_occluder_polygon);
 	ERR_FAIL_COND(!occluder_poly);
 	occluder_poly->cull_mode = p_mode;
 	RSG::canvas_render->occluder_polygon_set_cull_mode(occluder_poly->occluder, p_mode);
@@ -1550,12 +1550,12 @@ void RendererCanvasCull::canvas_texture_set_texture_repeat(RID p_canvas_texture,
 }
 
 void RendererCanvasCull::canvas_item_set_default_texture_filter(RID p_item, RS::CanvasItemTextureFilter p_filter) {
-	Item *ci = canvas_item_owner.getornull(p_item);
+	Item *ci = canvas_item_owner.get_or_null(p_item);
 	ERR_FAIL_COND(!ci);
 	ci->texture_filter = p_filter;
 }
 void RendererCanvasCull::canvas_item_set_default_texture_repeat(RID p_item, RS::CanvasItemTextureRepeat p_repeat) {
-	Item *ci = canvas_item_owner.getornull(p_item);
+	Item *ci = canvas_item_owner.get_or_null(p_item);
 	ERR_FAIL_COND(!ci);
 	ci->texture_repeat = p_repeat;
 }
@@ -1600,11 +1600,11 @@ void RendererCanvasCull::update_visibility_notifiers() {
 
 bool RendererCanvasCull::free(RID p_rid) {
 	if (canvas_owner.owns(p_rid)) {
-		Canvas *canvas = canvas_owner.getornull(p_rid);
+		Canvas *canvas = canvas_owner.get_or_null(p_rid);
 		ERR_FAIL_COND_V(!canvas, false);
 
 		while (canvas->viewports.size()) {
-			RendererViewport::Viewport *vp = RSG::viewport->viewport_owner.getornull(canvas->viewports.front()->get());
+			RendererViewport::Viewport *vp = RSG::viewport->viewport_owner.get_or_null(canvas->viewports.front()->get());
 			ERR_FAIL_COND_V(!vp, true);
 
 			Map<RID, RendererViewport::Viewport::CanvasData>::Element *E = vp->canvas_map.find(p_rid);
@@ -1629,15 +1629,15 @@ bool RendererCanvasCull::free(RID p_rid) {
 		canvas_owner.free(p_rid);
 
 	} else if (canvas_item_owner.owns(p_rid)) {
-		Item *canvas_item = canvas_item_owner.getornull(p_rid);
+		Item *canvas_item = canvas_item_owner.get_or_null(p_rid);
 		ERR_FAIL_COND_V(!canvas_item, true);
 
 		if (canvas_item->parent.is_valid()) {
 			if (canvas_owner.owns(canvas_item->parent)) {
-				Canvas *canvas = canvas_owner.getornull(canvas_item->parent);
+				Canvas *canvas = canvas_owner.get_or_null(canvas_item->parent);
 				canvas->erase_item(canvas_item);
 			} else if (canvas_item_owner.owns(canvas_item->parent)) {
-				Item *item_owner = canvas_item_owner.getornull(canvas_item->parent);
+				Item *item_owner = canvas_item_owner.get_or_null(canvas_item->parent);
 				item_owner->child_items.erase(canvas_item);
 
 				if (item_owner->sort_y) {
@@ -1663,11 +1663,11 @@ bool RendererCanvasCull::free(RID p_rid) {
 		canvas_item_owner.free(p_rid);
 
 	} else if (canvas_light_owner.owns(p_rid)) {
-		RendererCanvasRender::Light *canvas_light = canvas_light_owner.getornull(p_rid);
+		RendererCanvasRender::Light *canvas_light = canvas_light_owner.get_or_null(p_rid);
 		ERR_FAIL_COND_V(!canvas_light, true);
 
 		if (canvas_light->canvas.is_valid()) {
-			Canvas *canvas = canvas_owner.getornull(canvas_light->canvas);
+			Canvas *canvas = canvas_owner.get_or_null(canvas_light->canvas);
 			if (canvas) {
 				canvas->lights.erase(canvas_light);
 			}
@@ -1678,25 +1678,25 @@ bool RendererCanvasCull::free(RID p_rid) {
 		canvas_light_owner.free(p_rid);
 
 	} else if (canvas_light_occluder_owner.owns(p_rid)) {
-		RendererCanvasRender::LightOccluderInstance *occluder = canvas_light_occluder_owner.getornull(p_rid);
+		RendererCanvasRender::LightOccluderInstance *occluder = canvas_light_occluder_owner.get_or_null(p_rid);
 		ERR_FAIL_COND_V(!occluder, true);
 
 		if (occluder->polygon.is_valid()) {
-			LightOccluderPolygon *occluder_poly = canvas_light_occluder_polygon_owner.getornull(occluder->polygon);
+			LightOccluderPolygon *occluder_poly = canvas_light_occluder_polygon_owner.get_or_null(occluder->polygon);
 			if (occluder_poly) {
 				occluder_poly->owners.erase(occluder);
 			}
 		}
 
 		if (occluder->canvas.is_valid() && canvas_owner.owns(occluder->canvas)) {
-			Canvas *canvas = canvas_owner.getornull(occluder->canvas);
+			Canvas *canvas = canvas_owner.get_or_null(occluder->canvas);
 			canvas->occluders.erase(occluder);
 		}
 
 		canvas_light_occluder_owner.free(p_rid);
 
 	} else if (canvas_light_occluder_polygon_owner.owns(p_rid)) {
-		LightOccluderPolygon *occluder_poly = canvas_light_occluder_polygon_owner.getornull(p_rid);
+		LightOccluderPolygon *occluder_poly = canvas_light_occluder_polygon_owner.get_or_null(p_rid);
 		ERR_FAIL_COND_V(!occluder_poly, true);
 		RSG::canvas_render->free(occluder_poly->occluder);
 
diff --git a/servers/rendering/renderer_rd/forward_clustered/render_forward_clustered.cpp b/servers/rendering/renderer_rd/forward_clustered/render_forward_clustered.cpp
index fa3741c077..2377702738 100644
--- a/servers/rendering/renderer_rd/forward_clustered/render_forward_clustered.cpp
+++ b/servers/rendering/renderer_rd/forward_clustered/render_forward_clustered.cpp
@@ -2695,7 +2695,7 @@ void RenderForwardClustered::_geometry_instance_update(GeometryInstance *p_geome
 		} break;
 #if 0
 		case RS::INSTANCE_IMMEDIATE: {
-			RasterizerStorageGLES3::Immediate *immediate = storage->immediate_owner.getornull(inst->base);
+			RasterizerStorageGLES3::Immediate *immediate = storage->immediate_owner.get_or_null(inst->base);
 			ERR_CONTINUE(!immediate);
 
 			_add_geometry(immediate, inst, nullptr, -1, p_depth_pass, p_shadow_pass);
diff --git a/servers/rendering/renderer_rd/forward_mobile/render_forward_mobile.cpp b/servers/rendering/renderer_rd/forward_mobile/render_forward_mobile.cpp
index a5cc2db48f..75de2f6fbd 100644
--- a/servers/rendering/renderer_rd/forward_mobile/render_forward_mobile.cpp
+++ b/servers/rendering/renderer_rd/forward_mobile/render_forward_mobile.cpp
@@ -2440,7 +2440,7 @@ void RenderForwardMobile::_geometry_instance_update(GeometryInstance *p_geometry
 		} break;
 #if 0
 		case RS::INSTANCE_IMMEDIATE: {
-			RasterizerStorageGLES3::Immediate *immediate = storage->immediate_owner.getornull(inst->base);
+			RasterizerStorageGLES3::Immediate *immediate = storage->immediate_owner.get_or_null(inst->base);
 			ERR_CONTINUE(!immediate);
 
 			_add_geometry(immediate, inst, nullptr, -1, p_depth_pass, p_shadow_pass);
diff --git a/servers/rendering/renderer_rd/renderer_canvas_render_rd.cpp b/servers/rendering/renderer_rd/renderer_canvas_render_rd.cpp
index c2227587ec..673df00c18 100644
--- a/servers/rendering/renderer_rd/renderer_canvas_render_rd.cpp
+++ b/servers/rendering/renderer_rd/renderer_canvas_render_rd.cpp
@@ -1144,7 +1144,7 @@ void RendererCanvasRenderRD::canvas_render_items(RID p_to_render_target, Item *p
 				continue;
 			}
 
-			CanvasLight *clight = canvas_light_owner.getornull(l->light_internal);
+			CanvasLight *clight = canvas_light_owner.get_or_null(l->light_internal);
 			if (!clight) { //unused or invalid texture
 				l->render_index_cache = -1;
 				l = l->next_ptr;
@@ -1207,7 +1207,7 @@ void RendererCanvasRenderRD::canvas_render_items(RID p_to_render_target, Item *p
 				continue;
 			}
 
-			CanvasLight *clight = canvas_light_owner.getornull(l->light_internal);
+			CanvasLight *clight = canvas_light_owner.get_or_null(l->light_internal);
 			if (!clight) { //unused or invalid texture
 				l->render_index_cache = -1;
 				l = l->next_ptr;
@@ -1481,7 +1481,7 @@ RID RendererCanvasRenderRD::light_create() {
 }
 
 void RendererCanvasRenderRD::light_set_texture(RID p_rid, RID p_texture) {
-	CanvasLight *cl = canvas_light_owner.getornull(p_rid);
+	CanvasLight *cl = canvas_light_owner.get_or_null(p_rid);
 	ERR_FAIL_COND(!cl);
 	if (cl->texture == p_texture) {
 		return;
@@ -1497,7 +1497,7 @@ void RendererCanvasRenderRD::light_set_texture(RID p_rid, RID p_texture) {
 }
 
 void RendererCanvasRenderRD::light_set_use_shadow(RID p_rid, bool p_enable) {
-	CanvasLight *cl = canvas_light_owner.getornull(p_rid);
+	CanvasLight *cl = canvas_light_owner.get_or_null(p_rid);
 	ERR_FAIL_COND(!cl);
 
 	cl->shadow.enabled = p_enable;
@@ -1537,7 +1537,7 @@ void RendererCanvasRenderRD::_update_shadow_atlas() {
 	}
 }
 void RendererCanvasRenderRD::light_update_shadow(RID p_rid, int p_shadow_index, const Transform2D &p_light_xform, int p_light_mask, float p_near, float p_far, LightOccluderInstance *p_occluders) {
-	CanvasLight *cl = canvas_light_owner.getornull(p_rid);
+	CanvasLight *cl = canvas_light_owner.get_or_null(p_rid);
 	ERR_FAIL_COND(!cl->shadow.enabled);
 
 	_update_shadow_atlas();
@@ -1591,7 +1591,7 @@ void RendererCanvasRenderRD::light_update_shadow(RID p_rid, int p_shadow_index,
 		LightOccluderInstance *instance = p_occluders;
 
 		while (instance) {
-			OccluderPolygon *co = occluder_polygon_owner.getornull(instance->occluder);
+			OccluderPolygon *co = occluder_polygon_owner.get_or_null(instance->occluder);
 
 			if (!co || co->index_array.is_null() || !(p_light_mask & instance->light_mask)) {
 				instance = instance->next;
@@ -1615,7 +1615,7 @@ void RendererCanvasRenderRD::light_update_shadow(RID p_rid, int p_shadow_index,
 }
 
 void RendererCanvasRenderRD::light_update_directional_shadow(RID p_rid, int p_shadow_index, const Transform2D &p_light_xform, int p_light_mask, float p_cull_distance, const Rect2 &p_clip_rect, LightOccluderInstance *p_occluders) {
-	CanvasLight *cl = canvas_light_owner.getornull(p_rid);
+	CanvasLight *cl = canvas_light_owner.get_or_null(p_rid);
 	ERR_FAIL_COND(!cl->shadow.enabled);
 
 	_update_shadow_atlas();
@@ -1666,7 +1666,7 @@ void RendererCanvasRenderRD::light_update_directional_shadow(RID p_rid, int p_sh
 	LightOccluderInstance *instance = p_occluders;
 
 	while (instance) {
-		OccluderPolygon *co = occluder_polygon_owner.getornull(instance->occluder);
+		OccluderPolygon *co = occluder_polygon_owner.get_or_null(instance->occluder);
 
 		if (!co || co->index_array.is_null() || !(p_light_mask & instance->light_mask)) {
 			instance = instance->next;
@@ -1732,7 +1732,7 @@ void RendererCanvasRenderRD::render_sdf(RID p_render_target, LightOccluderInstan
 	LightOccluderInstance *instance = p_occluders;
 
 	while (instance) {
-		OccluderPolygon *co = occluder_polygon_owner.getornull(instance->occluder);
+		OccluderPolygon *co = occluder_polygon_owner.get_or_null(instance->occluder);
 
 		if (!co || co->sdf_index_array.is_null()) {
 			instance = instance->next;
@@ -1766,7 +1766,7 @@ RID RendererCanvasRenderRD::occluder_polygon_create() {
 }
 
 void RendererCanvasRenderRD::occluder_polygon_set_shape(RID p_occluder, const Vector<Vector2> &p_points, bool p_closed) {
-	OccluderPolygon *oc = occluder_polygon_owner.getornull(p_occluder);
+	OccluderPolygon *oc = occluder_polygon_owner.get_or_null(p_occluder);
 	ERR_FAIL_COND(!oc);
 
 	Vector<Vector2> lines;
@@ -1935,7 +1935,7 @@ void RendererCanvasRenderRD::occluder_polygon_set_shape(RID p_occluder, const Ve
 }
 
 void RendererCanvasRenderRD::occluder_polygon_set_cull_mode(RID p_occluder, RS::CanvasOccluderPolygonCullMode p_mode) {
-	OccluderPolygon *oc = occluder_polygon_owner.getornull(p_occluder);
+	OccluderPolygon *oc = occluder_polygon_owner.get_or_null(p_occluder);
 	ERR_FAIL_COND(!oc);
 	oc->cull_mode = p_mode;
 }
@@ -2611,7 +2611,7 @@ void fragment() {
 
 bool RendererCanvasRenderRD::free(RID p_rid) {
 	if (canvas_light_owner.owns(p_rid)) {
-		CanvasLight *cl = canvas_light_owner.getornull(p_rid);
+		CanvasLight *cl = canvas_light_owner.get_or_null(p_rid);
 		ERR_FAIL_COND_V(!cl, false);
 		light_set_use_shadow(p_rid, false);
 		canvas_light_owner.free(p_rid);
diff --git a/servers/rendering/renderer_rd/renderer_scene_gi_rd.cpp b/servers/rendering/renderer_rd/renderer_scene_gi_rd.cpp
index fb308da38d..ecc560fc5d 100644
--- a/servers/rendering/renderer_rd/renderer_scene_gi_rd.cpp
+++ b/servers/rendering/renderer_rd/renderer_scene_gi_rd.cpp
@@ -1450,7 +1450,7 @@ void RendererSceneGIRD::SDFGI::pre_process_gi(const Transform3D &p_transform, Re
 				break;
 			}
 
-			RendererSceneRenderRD::LightInstance *li = p_scene_render->light_instance_owner.getornull(p_scene_render->render_state.sdfgi_update_data->directional_lights->get(j));
+			RendererSceneRenderRD::LightInstance *li = p_scene_render->light_instance_owner.get_or_null(p_scene_render->render_state.sdfgi_update_data->directional_lights->get(j));
 			ERR_CONTINUE(!li);
 
 			if (storage->light_directional_is_sky_only(li->light)) {
@@ -1484,7 +1484,7 @@ void RendererSceneGIRD::SDFGI::pre_process_gi(const Transform3D &p_transform, Re
 				break;
 			}
 
-			RendererSceneRenderRD::LightInstance *li = p_scene_render->light_instance_owner.getornull(p_scene_render->render_state.sdfgi_update_data->positional_light_instances[j]);
+			RendererSceneRenderRD::LightInstance *li = p_scene_render->light_instance_owner.get_or_null(p_scene_render->render_state.sdfgi_update_data->positional_light_instances[j]);
 			ERR_CONTINUE(!li);
 
 			uint32_t max_sdfgi_cascade = storage->light_get_max_sdfgi_cascade(li->light);
@@ -1534,7 +1534,7 @@ void RendererSceneGIRD::SDFGI::pre_process_gi(const Transform3D &p_transform, Re
 
 void RendererSceneGIRD::SDFGI::render_region(RID p_render_buffers, int p_region, const PagedArray<RendererSceneRender::GeometryInstance *> &p_instances, RendererSceneRenderRD *p_scene_render) {
 	//print_line("rendering region " + itos(p_region));
-	RendererSceneRenderRD::RenderBuffers *rb = p_scene_render->render_buffers_owner.getornull(p_render_buffers);
+	RendererSceneRenderRD::RenderBuffers *rb = p_scene_render->render_buffers_owner.get_or_null(p_render_buffers);
 	ERR_FAIL_COND(!rb); // we wouldn't be here if this failed but...
 	AABB bounds;
 	Vector3i from;
@@ -1892,7 +1892,7 @@ void RendererSceneGIRD::SDFGI::render_region(RID p_render_buffers, int p_region,
 }
 
 void RendererSceneGIRD::SDFGI::render_static_lights(RID p_render_buffers, uint32_t p_cascade_count, const uint32_t *p_cascade_indices, const PagedArray<RID> *p_positional_light_cull_result, RendererSceneRenderRD *p_scene_render) {
-	RendererSceneRenderRD::RenderBuffers *rb = p_scene_render->render_buffers_owner.getornull(p_render_buffers);
+	RendererSceneRenderRD::RenderBuffers *rb = p_scene_render->render_buffers_owner.get_or_null(p_render_buffers);
 	ERR_FAIL_COND(!rb); // we wouldn't be here if this failed but...
 
 	RD::get_singleton()->draw_command_begin_label("SDFGI Render Static Lighs");
@@ -1921,7 +1921,7 @@ void RendererSceneGIRD::SDFGI::render_static_lights(RID p_render_buffers, uint32
 					break;
 				}
 
-				RendererSceneRenderRD::LightInstance *li = p_scene_render->light_instance_owner.getornull(p_positional_light_cull_result[i][j]);
+				RendererSceneRenderRD::LightInstance *li = p_scene_render->light_instance_owner.get_or_null(p_positional_light_cull_result[i][j]);
 				ERR_CONTINUE(!li);
 
 				uint32_t max_sdfgi_cascade = storage->light_get_max_sdfgi_cascade(li->light);
@@ -3024,7 +3024,7 @@ void RendererSceneGIRD::setup_voxel_gi_instances(RID p_render_buffers, const Tra
 	r_voxel_gi_instances_used = 0;
 
 	// feels a little dirty to use our container this way but....
-	RendererSceneRenderRD::RenderBuffers *rb = p_scene_render->render_buffers_owner.getornull(p_render_buffers);
+	RendererSceneRenderRD::RenderBuffers *rb = p_scene_render->render_buffers_owner.get_or_null(p_render_buffers);
 	ERR_FAIL_COND(rb == nullptr);
 
 	RID voxel_gi_buffer = p_scene_render->render_buffers_get_voxel_gi_buffer(p_render_buffers);
@@ -3119,9 +3119,9 @@ void RendererSceneGIRD::setup_voxel_gi_instances(RID p_render_buffers, const Tra
 void RendererSceneGIRD::process_gi(RID p_render_buffers, RID p_normal_roughness_buffer, RID p_voxel_gi_buffer, RID p_environment, const CameraMatrix &p_projection, const Transform3D &p_transform, const PagedArray<RID> &p_voxel_gi_instances, RendererSceneRenderRD *p_scene_render) {
 	RD::get_singleton()->draw_command_begin_label("GI Render");
 
-	RendererSceneRenderRD::RenderBuffers *rb = p_scene_render->render_buffers_owner.getornull(p_render_buffers);
+	RendererSceneRenderRD::RenderBuffers *rb = p_scene_render->render_buffers_owner.get_or_null(p_render_buffers);
 	ERR_FAIL_COND(rb == nullptr);
-	RendererSceneEnvironmentRD *env = p_scene_render->environment_owner.getornull(p_environment);
+	RendererSceneEnvironmentRD *env = p_scene_render->environment_owner.get_or_null(p_environment);
 
 	if (rb->ambient_buffer.is_null() || rb->gi.using_half_size_gi != half_resolution) {
 		if (rb->ambient_buffer.is_valid()) {
@@ -3393,7 +3393,7 @@ void RendererSceneGIRD::voxel_gi_update(RID p_probe, bool p_update_light_instanc
 }
 
 void RendererSceneGIRD::debug_voxel_gi(RID p_voxel_gi, RD::DrawListID p_draw_list, RID p_framebuffer, const CameraMatrix &p_camera_with_transform, bool p_lighting, bool p_emission, float p_alpha) {
-	VoxelGIInstance *voxel_gi = voxel_gi_instance_owner.getornull(p_voxel_gi);
+	VoxelGIInstance *voxel_gi = voxel_gi_instance_owner.get_or_null(p_voxel_gi);
 	ERR_FAIL_COND(!voxel_gi);
 
 	voxel_gi->debug(p_draw_list, p_framebuffer, p_camera_with_transform, p_lighting, p_emission, p_alpha);
diff --git a/servers/rendering/renderer_rd/renderer_scene_gi_rd.h b/servers/rendering/renderer_rd/renderer_scene_gi_rd.h
index 0b4622646f..5bd41a104e 100644
--- a/servers/rendering/renderer_rd/renderer_scene_gi_rd.h
+++ b/servers/rendering/renderer_rd/renderer_scene_gi_rd.h
@@ -383,7 +383,7 @@ public:
 	mutable RID_Owner<VoxelGIInstance> voxel_gi_instance_owner;
 
 	_FORCE_INLINE_ VoxelGIInstance *get_probe_instance(RID p_probe) const {
-		return voxel_gi_instance_owner.getornull(p_probe);
+		return voxel_gi_instance_owner.get_or_null(p_probe);
 	};
 
 	_FORCE_INLINE_ RID voxel_gi_instance_get_texture(RID p_probe) {
diff --git a/servers/rendering/renderer_rd/renderer_scene_render_rd.cpp b/servers/rendering/renderer_rd/renderer_scene_render_rd.cpp
index 0f98417215..e7156accfa 100644
--- a/servers/rendering/renderer_rd/renderer_scene_render_rd.cpp
+++ b/servers/rendering/renderer_rd/renderer_scene_render_rd.cpp
@@ -48,8 +48,8 @@ void get_vogel_disk(float *r_kernel, int p_sample_count) {
 }
 
 void RendererSceneRenderRD::sdfgi_update(RID p_render_buffers, RID p_environment, const Vector3 &p_world_position) {
-	RendererSceneEnvironmentRD *env = environment_owner.getornull(p_environment);
-	RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
+	RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_environment);
+	RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
 	bool needs_sdfgi = env && env->sdfgi_enabled;
 
 	if (!needs_sdfgi) {
@@ -83,7 +83,7 @@ void RendererSceneRenderRD::sdfgi_update(RID p_render_buffers, RID p_environment
 }
 
 int RendererSceneRenderRD::sdfgi_get_pending_region_count(RID p_render_buffers) const {
-	RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
+	RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
 
 	ERR_FAIL_COND_V(rb == nullptr, 0);
 
@@ -113,7 +113,7 @@ AABB RendererSceneRenderRD::sdfgi_get_pending_region_bounds(RID p_render_buffers
 	AABB bounds;
 	Vector3i from;
 	Vector3i size;
-	RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
+	RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
 	ERR_FAIL_COND_V(rb == nullptr, AABB());
 	ERR_FAIL_COND_V(rb->sdfgi == nullptr, AABB());
 
@@ -126,7 +126,7 @@ uint32_t RendererSceneRenderRD::sdfgi_get_pending_region_cascade(RID p_render_bu
 	AABB bounds;
 	Vector3i from;
 	Vector3i size;
-	RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
+	RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
 	ERR_FAIL_COND_V(rb == nullptr, -1);
 	ERR_FAIL_COND_V(rb->sdfgi == nullptr, -1);
 
@@ -164,139 +164,139 @@ void RendererSceneRenderRD::environment_initialize(RID p_rid) {
 }
 
 void RendererSceneRenderRD::environment_set_background(RID p_env, RS::EnvironmentBG p_bg) {
-	RendererSceneEnvironmentRD *env = environment_owner.getornull(p_env);
+	RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
 	ERR_FAIL_COND(!env);
 	env->background = p_bg;
 }
 
 void RendererSceneRenderRD::environment_set_sky(RID p_env, RID p_sky) {
-	RendererSceneEnvironmentRD *env = environment_owner.getornull(p_env);
+	RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
 	ERR_FAIL_COND(!env);
 	env->sky = p_sky;
 }
 
 void RendererSceneRenderRD::environment_set_sky_custom_fov(RID p_env, float p_scale) {
-	RendererSceneEnvironmentRD *env = environment_owner.getornull(p_env);
+	RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
 	ERR_FAIL_COND(!env);
 	env->sky_custom_fov = p_scale;
 }
 
 void RendererSceneRenderRD::environment_set_sky_orientation(RID p_env, const Basis &p_orientation) {
-	RendererSceneEnvironmentRD *env = environment_owner.getornull(p_env);
+	RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
 	ERR_FAIL_COND(!env);
 	env->sky_orientation = p_orientation;
 }
 
 void RendererSceneRenderRD::environment_set_bg_color(RID p_env, const Color &p_color) {
-	RendererSceneEnvironmentRD *env = environment_owner.getornull(p_env);
+	RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
 	ERR_FAIL_COND(!env);
 	env->bg_color = p_color;
 }
 
 void RendererSceneRenderRD::environment_set_bg_energy(RID p_env, float p_energy) {
-	RendererSceneEnvironmentRD *env = environment_owner.getornull(p_env);
+	RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
 	ERR_FAIL_COND(!env);
 	env->bg_energy = p_energy;
 }
 
 void RendererSceneRenderRD::environment_set_canvas_max_layer(RID p_env, int p_max_layer) {
-	RendererSceneEnvironmentRD *env = environment_owner.getornull(p_env);
+	RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
 	ERR_FAIL_COND(!env);
 	env->canvas_max_layer = p_max_layer;
 }
 
 void RendererSceneRenderRD::environment_set_ambient_light(RID p_env, const Color &p_color, RS::EnvironmentAmbientSource p_ambient, float p_energy, float p_sky_contribution, RS::EnvironmentReflectionSource p_reflection_source, const Color &p_ao_color) {
-	RendererSceneEnvironmentRD *env = environment_owner.getornull(p_env);
+	RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
 	ERR_FAIL_COND(!env);
 	env->set_ambient_light(p_color, p_ambient, p_energy, p_sky_contribution, p_reflection_source, p_ao_color);
 }
 
 RS::EnvironmentBG RendererSceneRenderRD::environment_get_background(RID p_env) const {
-	RendererSceneEnvironmentRD *env = environment_owner.getornull(p_env);
+	RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
 	ERR_FAIL_COND_V(!env, RS::ENV_BG_MAX);
 	return env->background;
 }
 
 RID RendererSceneRenderRD::environment_get_sky(RID p_env) const {
-	RendererSceneEnvironmentRD *env = environment_owner.getornull(p_env);
+	RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
 	ERR_FAIL_COND_V(!env, RID());
 	return env->sky;
 }
 
 float RendererSceneRenderRD::environment_get_sky_custom_fov(RID p_env) const {
-	RendererSceneEnvironmentRD *env = environment_owner.getornull(p_env);
+	RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
 	ERR_FAIL_COND_V(!env, 0);
 	return env->sky_custom_fov;
 }
 
 Basis RendererSceneRenderRD::environment_get_sky_orientation(RID p_env) const {
-	RendererSceneEnvironmentRD *env = environment_owner.getornull(p_env);
+	RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
 	ERR_FAIL_COND_V(!env, Basis());
 	return env->sky_orientation;
 }
 
 Color RendererSceneRenderRD::environment_get_bg_color(RID p_env) const {
-	RendererSceneEnvironmentRD *env = environment_owner.getornull(p_env);
+	RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
 	ERR_FAIL_COND_V(!env, Color());
 	return env->bg_color;
 }
 
 float RendererSceneRenderRD::environment_get_bg_energy(RID p_env) const {
-	RendererSceneEnvironmentRD *env = environment_owner.getornull(p_env);
+	RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
 	ERR_FAIL_COND_V(!env, 0);
 	return env->bg_energy;
 }
 
 int RendererSceneRenderRD::environment_get_canvas_max_layer(RID p_env) const {
-	RendererSceneEnvironmentRD *env = environment_owner.getornull(p_env);
+	RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
 	ERR_FAIL_COND_V(!env, 0);
 	return env->canvas_max_layer;
 }
 
 Color RendererSceneRenderRD::environment_get_ambient_light_color(RID p_env) const {
-	RendererSceneEnvironmentRD *env = environment_owner.getornull(p_env);
+	RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
 	ERR_FAIL_COND_V(!env, Color());
 	return env->ambient_light;
 }
 
 RS::EnvironmentAmbientSource RendererSceneRenderRD::environment_get_ambient_source(RID p_env) const {
-	RendererSceneEnvironmentRD *env = environment_owner.getornull(p_env);
+	RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
 	ERR_FAIL_COND_V(!env, RS::ENV_AMBIENT_SOURCE_BG);
 	return env->ambient_source;
 }
 
 float RendererSceneRenderRD::environment_get_ambient_light_energy(RID p_env) const {
-	RendererSceneEnvironmentRD *env = environment_owner.getornull(p_env);
+	RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
 	ERR_FAIL_COND_V(!env, 0);
 	return env->ambient_light_energy;
 }
 
 float RendererSceneRenderRD::environment_get_ambient_sky_contribution(RID p_env) const {
-	RendererSceneEnvironmentRD *env = environment_owner.getornull(p_env);
+	RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
 	ERR_FAIL_COND_V(!env, 0);
 	return env->ambient_sky_contribution;
 }
 
 RS::EnvironmentReflectionSource RendererSceneRenderRD::environment_get_reflection_source(RID p_env) const {
-	RendererSceneEnvironmentRD *env = environment_owner.getornull(p_env);
+	RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
 	ERR_FAIL_COND_V(!env, RS::ENV_REFLECTION_SOURCE_DISABLED);
 	return env->reflection_source;
 }
 
 Color RendererSceneRenderRD::environment_get_ao_color(RID p_env) const {
-	RendererSceneEnvironmentRD *env = environment_owner.getornull(p_env);
+	RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
 	ERR_FAIL_COND_V(!env, Color());
 	return env->ao_color;
 }
 
 void RendererSceneRenderRD::environment_set_tonemap(RID p_env, RS::EnvironmentToneMapper p_tone_mapper, float p_exposure, float p_white, bool p_auto_exposure, float p_min_luminance, float p_max_luminance, float p_auto_exp_speed, float p_auto_exp_scale) {
-	RendererSceneEnvironmentRD *env = environment_owner.getornull(p_env);
+	RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
 	ERR_FAIL_COND(!env);
 	env->set_tonemap(p_tone_mapper, p_exposure, p_white, p_auto_exposure, p_min_luminance, p_max_luminance, p_auto_exp_speed, p_auto_exp_scale);
 }
 
 void RendererSceneRenderRD::environment_set_glow(RID p_env, bool p_enable, Vector<float> p_levels, float p_intensity, float p_strength, float p_mix, float p_bloom_threshold, RS::EnvironmentGlowBlendMode p_blend_mode, float p_hdr_bleed_threshold, float p_hdr_bleed_scale, float p_hdr_luminance_cap) {
-	RendererSceneEnvironmentRD *env = environment_owner.getornull(p_env);
+	RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
 	ERR_FAIL_COND(!env);
 	env->set_glow(p_enable, p_levels, p_intensity, p_strength, p_mix, p_bloom_threshold, p_blend_mode, p_hdr_bleed_threshold, p_hdr_bleed_scale, p_hdr_luminance_cap);
 }
@@ -310,7 +310,7 @@ void RendererSceneRenderRD::environment_glow_set_use_high_quality(bool p_enable)
 }
 
 void RendererSceneRenderRD::environment_set_sdfgi(RID p_env, bool p_enable, RS::EnvironmentSDFGICascades p_cascades, float p_min_cell_size, RS::EnvironmentSDFGIYScale p_y_scale, bool p_use_occlusion, float p_bounce_feedback, bool p_read_sky, float p_energy, float p_normal_bias, float p_probe_bias) {
-	RendererSceneEnvironmentRD *env = environment_owner.getornull(p_env);
+	RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
 	ERR_FAIL_COND(!env);
 
 	if (!is_dynamic_gi_supported()) {
@@ -321,58 +321,58 @@ void RendererSceneRenderRD::environment_set_sdfgi(RID p_env, bool p_enable, RS::
 }
 
 void RendererSceneRenderRD::environment_set_fog(RID p_env, bool p_enable, const Color &p_light_color, float p_light_energy, float p_sun_scatter, float p_density, float p_height, float p_height_density, float p_fog_aerial_perspective) {
-	RendererSceneEnvironmentRD *env = environment_owner.getornull(p_env);
+	RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
 	ERR_FAIL_COND(!env);
 
 	env->set_fog(p_enable, p_light_color, p_light_energy, p_sun_scatter, p_density, p_height, p_height_density, p_fog_aerial_perspective);
 }
 
 bool RendererSceneRenderRD::environment_is_fog_enabled(RID p_env) const {
-	const RendererSceneEnvironmentRD *env = environment_owner.getornull(p_env);
+	const RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
 	ERR_FAIL_COND_V(!env, false);
 
 	return env->fog_enabled;
 }
 Color RendererSceneRenderRD::environment_get_fog_light_color(RID p_env) const {
-	const RendererSceneEnvironmentRD *env = environment_owner.getornull(p_env);
+	const RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
 	ERR_FAIL_COND_V(!env, Color());
 	return env->fog_light_color;
 }
 float RendererSceneRenderRD::environment_get_fog_light_energy(RID p_env) const {
-	const RendererSceneEnvironmentRD *env = environment_owner.getornull(p_env);
+	const RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
 	ERR_FAIL_COND_V(!env, 0);
 	return env->fog_light_energy;
 }
 float RendererSceneRenderRD::environment_get_fog_sun_scatter(RID p_env) const {
-	const RendererSceneEnvironmentRD *env = environment_owner.getornull(p_env);
+	const RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
 	ERR_FAIL_COND_V(!env, 0);
 	return env->fog_sun_scatter;
 }
 float RendererSceneRenderRD::environment_get_fog_density(RID p_env) const {
-	const RendererSceneEnvironmentRD *env = environment_owner.getornull(p_env);
+	const RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
 	ERR_FAIL_COND_V(!env, 0);
 	return env->fog_density;
 }
 float RendererSceneRenderRD::environment_get_fog_height(RID p_env) const {
-	const RendererSceneEnvironmentRD *env = environment_owner.getornull(p_env);
+	const RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
 	ERR_FAIL_COND_V(!env, 0);
 
 	return env->fog_height;
 }
 float RendererSceneRenderRD::environment_get_fog_height_density(RID p_env) const {
-	const RendererSceneEnvironmentRD *env = environment_owner.getornull(p_env);
+	const RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
 	ERR_FAIL_COND_V(!env, 0);
 	return env->fog_height_density;
 }
 
 float RendererSceneRenderRD::environment_get_fog_aerial_perspective(RID p_env) const {
-	const RendererSceneEnvironmentRD *env = environment_owner.getornull(p_env);
+	const RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
 	ERR_FAIL_COND_V(!env, 0);
 	return env->fog_aerial_perspective;
 }
 
 void RendererSceneRenderRD::environment_set_volumetric_fog(RID p_env, bool p_enable, float p_density, const Color &p_light, float p_light_energy, float p_length, float p_detail_spread, float p_gi_inject, bool p_temporal_reprojection, float p_temporal_reprojection_amount) {
-	RendererSceneEnvironmentRD *env = environment_owner.getornull(p_env);
+	RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
 	ERR_FAIL_COND(!env);
 
 	if (!is_volumetric_supported()) {
@@ -403,7 +403,7 @@ void RendererSceneRenderRD::environment_set_sdfgi_frames_to_update_light(RS::Env
 }
 
 void RendererSceneRenderRD::environment_set_ssr(RID p_env, bool p_enable, int p_max_steps, float p_fade_int, float p_fade_out, float p_depth_tolerance) {
-	RendererSceneEnvironmentRD *env = environment_owner.getornull(p_env);
+	RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
 	ERR_FAIL_COND(!env);
 
 	env->set_ssr(p_enable, p_max_steps, p_fade_int, p_fade_out, p_depth_tolerance);
@@ -418,7 +418,7 @@ RS::EnvironmentSSRRoughnessQuality RendererSceneRenderRD::environment_get_ssr_ro
 }
 
 void RendererSceneRenderRD::environment_set_ssao(RID p_env, bool p_enable, float p_radius, float p_intensity, float p_power, float p_detail, float p_horizon, float p_sharpness, float p_light_affect, float p_ao_channel_affect) {
-	RendererSceneEnvironmentRD *env = environment_owner.getornull(p_env);
+	RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
 	ERR_FAIL_COND(!env);
 
 	env->set_ssao(p_enable, p_radius, p_intensity, p_power, p_detail, p_horizon, p_sharpness, p_light_affect, p_ao_channel_affect);
@@ -434,30 +434,30 @@ void RendererSceneRenderRD::environment_set_ssao_quality(RS::EnvironmentSSAOQual
 }
 
 bool RendererSceneRenderRD::environment_is_ssao_enabled(RID p_env) const {
-	RendererSceneEnvironmentRD *env = environment_owner.getornull(p_env);
+	RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
 	ERR_FAIL_COND_V(!env, false);
 	return env->ssao_enabled;
 }
 
 float RendererSceneRenderRD::environment_get_ssao_ao_affect(RID p_env) const {
-	RendererSceneEnvironmentRD *env = environment_owner.getornull(p_env);
+	RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
 	ERR_FAIL_COND_V(!env, 0.0);
 	return env->ssao_ao_channel_affect;
 }
 
 float RendererSceneRenderRD::environment_get_ssao_light_affect(RID p_env) const {
-	RendererSceneEnvironmentRD *env = environment_owner.getornull(p_env);
+	RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
 	ERR_FAIL_COND_V(!env, 0.0);
 	return env->ssao_direct_light_affect;
 }
 
 bool RendererSceneRenderRD::environment_is_ssr_enabled(RID p_env) const {
-	RendererSceneEnvironmentRD *env = environment_owner.getornull(p_env);
+	RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
 	ERR_FAIL_COND_V(!env, false);
 	return env->ssr_enabled;
 }
 bool RendererSceneRenderRD::environment_is_sdfgi_enabled(RID p_env) const {
-	RendererSceneEnvironmentRD *env = environment_owner.getornull(p_env);
+	RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
 	ERR_FAIL_COND_V(!env, false);
 	return env->sdfgi_enabled;
 }
@@ -467,7 +467,7 @@ bool RendererSceneRenderRD::is_environment(RID p_env) const {
 }
 
 Ref<Image> RendererSceneRenderRD::environment_bake_panorama(RID p_env, bool p_bake_irradiance, const Size2i &p_size) {
-	RendererSceneEnvironmentRD *env = environment_owner.getornull(p_env);
+	RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
 	ERR_FAIL_COND_V(!env, Ref<Image>());
 
 	if (env->background == RS::ENV_BG_CAMERA_FEED || env->background == RS::ENV_BG_CANVAS || env->background == RS::ENV_BG_KEEP) {
@@ -522,7 +522,7 @@ RID RendererSceneRenderRD::reflection_atlas_create() {
 }
 
 void RendererSceneRenderRD::reflection_atlas_set_size(RID p_ref_atlas, int p_reflection_size, int p_reflection_count) {
-	ReflectionAtlas *ra = reflection_atlas_owner.getornull(p_ref_atlas);
+	ReflectionAtlas *ra = reflection_atlas_owner.get_or_null(p_ref_atlas);
 	ERR_FAIL_COND(!ra);
 
 	if (ra->size == p_reflection_size && ra->count == p_reflection_count) {
@@ -557,7 +557,7 @@ void RendererSceneRenderRD::reflection_atlas_set_size(RID p_ref_atlas, int p_ref
 }
 
 int RendererSceneRenderRD::reflection_atlas_get_size(RID p_ref_atlas) const {
-	ReflectionAtlas *ra = reflection_atlas_owner.getornull(p_ref_atlas);
+	ReflectionAtlas *ra = reflection_atlas_owner.get_or_null(p_ref_atlas);
 	ERR_FAIL_COND_V(!ra, 0);
 
 	return ra->size;
@@ -573,7 +573,7 @@ RID RendererSceneRenderRD::reflection_probe_instance_create(RID p_probe) {
 }
 
 void RendererSceneRenderRD::reflection_probe_instance_set_transform(RID p_instance, const Transform3D &p_transform) {
-	ReflectionProbeInstance *rpi = reflection_probe_instance_owner.getornull(p_instance);
+	ReflectionProbeInstance *rpi = reflection_probe_instance_owner.get_or_null(p_instance);
 	ERR_FAIL_COND(!rpi);
 
 	rpi->transform = p_transform;
@@ -581,13 +581,13 @@ void RendererSceneRenderRD::reflection_probe_instance_set_transform(RID p_instan
 }
 
 void RendererSceneRenderRD::reflection_probe_release_atlas_index(RID p_instance) {
-	ReflectionProbeInstance *rpi = reflection_probe_instance_owner.getornull(p_instance);
+	ReflectionProbeInstance *rpi = reflection_probe_instance_owner.get_or_null(p_instance);
 	ERR_FAIL_COND(!rpi);
 
 	if (rpi->atlas.is_null()) {
 		return; //nothing to release
 	}
-	ReflectionAtlas *atlas = reflection_atlas_owner.getornull(rpi->atlas);
+	ReflectionAtlas *atlas = reflection_atlas_owner.get_or_null(rpi->atlas);
 	ERR_FAIL_COND(!atlas);
 	ERR_FAIL_INDEX(rpi->atlas_index, atlas->reflections.size());
 	atlas->reflections.write[rpi->atlas_index].owner = RID();
@@ -596,7 +596,7 @@ void RendererSceneRenderRD::reflection_probe_release_atlas_index(RID p_instance)
 }
 
 bool RendererSceneRenderRD::reflection_probe_instance_needs_redraw(RID p_instance) {
-	ReflectionProbeInstance *rpi = reflection_probe_instance_owner.getornull(p_instance);
+	ReflectionProbeInstance *rpi = reflection_probe_instance_owner.get_or_null(p_instance);
 	ERR_FAIL_COND_V(!rpi, false);
 
 	if (rpi->rendering) {
@@ -615,18 +615,18 @@ bool RendererSceneRenderRD::reflection_probe_instance_needs_redraw(RID p_instanc
 }
 
 bool RendererSceneRenderRD::reflection_probe_instance_has_reflection(RID p_instance) {
-	ReflectionProbeInstance *rpi = reflection_probe_instance_owner.getornull(p_instance);
+	ReflectionProbeInstance *rpi = reflection_probe_instance_owner.get_or_null(p_instance);
 	ERR_FAIL_COND_V(!rpi, false);
 
 	return rpi->atlas.is_valid();
 }
 
 bool RendererSceneRenderRD::reflection_probe_instance_begin_render(RID p_instance, RID p_reflection_atlas) {
-	ReflectionAtlas *atlas = reflection_atlas_owner.getornull(p_reflection_atlas);
+	ReflectionAtlas *atlas = reflection_atlas_owner.get_or_null(p_reflection_atlas);
 
 	ERR_FAIL_COND_V(!atlas, false);
 
-	ReflectionProbeInstance *rpi = reflection_probe_instance_owner.getornull(p_instance);
+	ReflectionProbeInstance *rpi = reflection_probe_instance_owner.get_or_null(p_instance);
 	ERR_FAIL_COND_V(!rpi, false);
 
 	RD::get_singleton()->draw_command_begin_label("Reflection probe render");
@@ -701,7 +701,7 @@ bool RendererSceneRenderRD::reflection_probe_instance_begin_render(RID p_instanc
 			uint64_t pass_min = 0;
 
 			for (int i = 0; i < atlas->reflections.size(); i++) {
-				ReflectionProbeInstance *rpi2 = reflection_probe_instance_owner.getornull(atlas->reflections[i].owner);
+				ReflectionProbeInstance *rpi2 = reflection_probe_instance_owner.get_or_null(atlas->reflections[i].owner);
 				if (rpi2->last_pass < pass_min) {
 					pass_min = rpi2->last_pass;
 					rpi->atlas_index = i;
@@ -733,12 +733,12 @@ RID RendererSceneRenderRD::reflection_probe_create_framebuffer(RID p_color, RID
 }
 
 bool RendererSceneRenderRD::reflection_probe_instance_postprocess_step(RID p_instance) {
-	ReflectionProbeInstance *rpi = reflection_probe_instance_owner.getornull(p_instance);
+	ReflectionProbeInstance *rpi = reflection_probe_instance_owner.get_or_null(p_instance);
 	ERR_FAIL_COND_V(!rpi, false);
 	ERR_FAIL_COND_V(!rpi->rendering, false);
 	ERR_FAIL_COND_V(rpi->atlas.is_null(), false);
 
-	ReflectionAtlas *atlas = reflection_atlas_owner.getornull(rpi->atlas);
+	ReflectionAtlas *atlas = reflection_atlas_owner.get_or_null(rpi->atlas);
 	if (!atlas || rpi->atlas_index == -1) {
 		//does not belong to an atlas anymore, cancel (was removed from atlas or atlas changed while rendering)
 		rpi->rendering = false;
@@ -779,30 +779,30 @@ bool RendererSceneRenderRD::reflection_probe_instance_postprocess_step(RID p_ins
 }
 
 uint32_t RendererSceneRenderRD::reflection_probe_instance_get_resolution(RID p_instance) {
-	ReflectionProbeInstance *rpi = reflection_probe_instance_owner.getornull(p_instance);
+	ReflectionProbeInstance *rpi = reflection_probe_instance_owner.get_or_null(p_instance);
 	ERR_FAIL_COND_V(!rpi, 0);
 
-	ReflectionAtlas *atlas = reflection_atlas_owner.getornull(rpi->atlas);
+	ReflectionAtlas *atlas = reflection_atlas_owner.get_or_null(rpi->atlas);
 	ERR_FAIL_COND_V(!atlas, 0);
 	return atlas->size;
 }
 
 RID RendererSceneRenderRD::reflection_probe_instance_get_framebuffer(RID p_instance, int p_index) {
-	ReflectionProbeInstance *rpi = reflection_probe_instance_owner.getornull(p_instance);
+	ReflectionProbeInstance *rpi = reflection_probe_instance_owner.get_or_null(p_instance);
 	ERR_FAIL_COND_V(!rpi, RID());
 	ERR_FAIL_INDEX_V(p_index, 6, RID());
 
-	ReflectionAtlas *atlas = reflection_atlas_owner.getornull(rpi->atlas);
+	ReflectionAtlas *atlas = reflection_atlas_owner.get_or_null(rpi->atlas);
 	ERR_FAIL_COND_V(!atlas, RID());
 	return atlas->reflections[rpi->atlas_index].fbs[p_index];
 }
 
 RID RendererSceneRenderRD::reflection_probe_instance_get_depth_framebuffer(RID p_instance, int p_index) {
-	ReflectionProbeInstance *rpi = reflection_probe_instance_owner.getornull(p_instance);
+	ReflectionProbeInstance *rpi = reflection_probe_instance_owner.get_or_null(p_instance);
 	ERR_FAIL_COND_V(!rpi, RID());
 	ERR_FAIL_INDEX_V(p_index, 6, RID());
 
-	ReflectionAtlas *atlas = reflection_atlas_owner.getornull(rpi->atlas);
+	ReflectionAtlas *atlas = reflection_atlas_owner.get_or_null(rpi->atlas);
 	ERR_FAIL_COND_V(!atlas, RID());
 	return atlas->depth_fb;
 }
@@ -829,7 +829,7 @@ void RendererSceneRenderRD::_update_shadow_atlas(ShadowAtlas *shadow_atlas) {
 }
 
 void RendererSceneRenderRD::shadow_atlas_set_size(RID p_atlas, int p_size, bool p_16_bits) {
-	ShadowAtlas *shadow_atlas = shadow_atlas_owner.getornull(p_atlas);
+	ShadowAtlas *shadow_atlas = shadow_atlas_owner.get_or_null(p_atlas);
 	ERR_FAIL_COND(!shadow_atlas);
 	ERR_FAIL_COND(p_size < 0);
 	p_size = next_power_of_2(p_size);
@@ -851,7 +851,7 @@ void RendererSceneRenderRD::shadow_atlas_set_size(RID p_atlas, int p_size, bool
 
 	//erase shadow atlas reference from lights
 	for (Map<RID, uint32_t>::Element *E = shadow_atlas->shadow_owners.front(); E; E = E->next()) {
-		LightInstance *li = light_instance_owner.getornull(E->key());
+		LightInstance *li = light_instance_owner.get_or_null(E->key());
 		ERR_CONTINUE(!li);
 		li->shadow_atlases.erase(p_atlas);
 	}
@@ -864,7 +864,7 @@ void RendererSceneRenderRD::shadow_atlas_set_size(RID p_atlas, int p_size, bool
 }
 
 void RendererSceneRenderRD::shadow_atlas_set_quadrant_subdivision(RID p_atlas, int p_quadrant, int p_subdivision) {
-	ShadowAtlas *shadow_atlas = shadow_atlas_owner.getornull(p_atlas);
+	ShadowAtlas *shadow_atlas = shadow_atlas_owner.get_or_null(p_atlas);
 	ERR_FAIL_COND(!shadow_atlas);
 	ERR_FAIL_INDEX(p_quadrant, 4);
 	ERR_FAIL_INDEX(p_subdivision, 16384);
@@ -886,7 +886,7 @@ void RendererSceneRenderRD::shadow_atlas_set_quadrant_subdivision(RID p_atlas, i
 	for (int i = 0; i < shadow_atlas->quadrants[p_quadrant].shadows.size(); i++) {
 		if (shadow_atlas->quadrants[p_quadrant].shadows[i].owner.is_valid()) {
 			shadow_atlas->shadow_owners.erase(shadow_atlas->quadrants[p_quadrant].shadows[i].owner);
-			LightInstance *li = light_instance_owner.getornull(shadow_atlas->quadrants[p_quadrant].shadows[i].owner);
+			LightInstance *li = light_instance_owner.get_or_null(shadow_atlas->quadrants[p_quadrant].shadows[i].owner);
 			ERR_CONTINUE(!li);
 			li->shadow_atlases.erase(p_atlas);
 		}
@@ -947,7 +947,7 @@ bool RendererSceneRenderRD::_shadow_atlas_find_shadow(ShadowAtlas *shadow_atlas,
 				break;
 			}
 
-			LightInstance *sli = light_instance_owner.getornull(sarr[j].owner);
+			LightInstance *sli = light_instance_owner.get_or_null(sarr[j].owner);
 			ERR_CONTINUE(!sli);
 
 			if (sli->last_scene_pass != scene_pass) {
@@ -999,7 +999,7 @@ bool RendererSceneRenderRD::_shadow_atlas_find_omni_shadows(ShadowAtlas *shadow_
 			uint64_t pass = 0;
 
 			if (sarr[j].owner.is_valid()) {
-				LightInstance *sli = light_instance_owner.getornull(sarr[j].owner);
+				LightInstance *sli = light_instance_owner.get_or_null(sarr[j].owner);
 				ERR_CONTINUE(!sli);
 
 				if (sli->last_scene_pass == scene_pass) {
@@ -1014,7 +1014,7 @@ bool RendererSceneRenderRD::_shadow_atlas_find_omni_shadows(ShadowAtlas *shadow_
 			}
 
 			if (sarr[j + 1].owner.is_valid()) {
-				LightInstance *sli = light_instance_owner.getornull(sarr[j + 1].owner);
+				LightInstance *sli = light_instance_owner.get_or_null(sarr[j + 1].owner);
 				ERR_CONTINUE(!sli);
 
 				if (sli->last_scene_pass == scene_pass) {
@@ -1053,10 +1053,10 @@ bool RendererSceneRenderRD::_shadow_atlas_find_omni_shadows(ShadowAtlas *shadow_
 }
 
 bool RendererSceneRenderRD::shadow_atlas_update_light(RID p_atlas, RID p_light_intance, float p_coverage, uint64_t p_light_version) {
-	ShadowAtlas *shadow_atlas = shadow_atlas_owner.getornull(p_atlas);
+	ShadowAtlas *shadow_atlas = shadow_atlas_owner.get_or_null(p_atlas);
 	ERR_FAIL_COND_V(!shadow_atlas, false);
 
-	LightInstance *li = light_instance_owner.getornull(p_light_intance);
+	LightInstance *li = light_instance_owner.get_or_null(p_light_intance);
 	ERR_FAIL_COND_V(!li, false);
 
 	if (shadow_atlas->size == 0 || shadow_atlas->smallest_subdiv == 0) {
@@ -1179,7 +1179,7 @@ bool RendererSceneRenderRD::shadow_atlas_update_light(RID p_atlas, RID p_light_i
 
 void RendererSceneRenderRD::_shadow_atlas_invalidate_shadow(RendererSceneRenderRD::ShadowAtlas::Quadrant::Shadow *p_shadow, RID p_atlas, RendererSceneRenderRD::ShadowAtlas *p_shadow_atlas, uint32_t p_quadrant, uint32_t p_shadow_idx) {
 	if (p_shadow->owner.is_valid()) {
-		LightInstance *sli = light_instance_owner.getornull(p_shadow->owner);
+		LightInstance *sli = light_instance_owner.get_or_null(p_shadow->owner);
 		uint32_t old_key = p_shadow_atlas->shadow_owners[p_shadow->owner];
 
 		if (old_key & ShadowAtlas::OMNI_LIGHT_FLAG) {
@@ -1260,7 +1260,7 @@ int RendererSceneRenderRD::get_directional_light_shadow_size(RID p_light_intance
 
 	Rect2i r = _get_directional_shadow_rect(directional_shadow.size, directional_shadow.light_count, 0);
 
-	LightInstance *light_instance = light_instance_owner.getornull(p_light_intance);
+	LightInstance *light_instance = light_instance_owner.get_or_null(p_light_intance);
 	ERR_FAIL_COND_V(!light_instance, 0);
 
 	switch (storage->light_directional_get_shadow_mode(light_instance->light)) {
@@ -1296,7 +1296,7 @@ void RendererSceneRenderRD::camera_effects_set_dof_blur_bokeh_shape(RS::DOFBokeh
 }
 
 void RendererSceneRenderRD::camera_effects_set_dof_blur(RID p_camera_effects, bool p_far_enable, float p_far_distance, float p_far_transition, bool p_near_enable, float p_near_distance, float p_near_transition, float p_amount) {
-	CameraEffects *camfx = camera_effects_owner.getornull(p_camera_effects);
+	CameraEffects *camfx = camera_effects_owner.get_or_null(p_camera_effects);
 	ERR_FAIL_COND(!camfx);
 
 	camfx->dof_blur_far_enabled = p_far_enable;
@@ -1311,7 +1311,7 @@ void RendererSceneRenderRD::camera_effects_set_dof_blur(RID p_camera_effects, bo
 }
 
 void RendererSceneRenderRD::camera_effects_set_custom_exposure(RID p_camera_effects, bool p_enable, float p_exposure) {
-	CameraEffects *camfx = camera_effects_owner.getornull(p_camera_effects);
+	CameraEffects *camfx = camera_effects_owner.get_or_null(p_camera_effects);
 	ERR_FAIL_COND(!camfx);
 
 	camfx->override_exposure_enabled = p_enable;
@@ -1321,7 +1321,7 @@ void RendererSceneRenderRD::camera_effects_set_custom_exposure(RID p_camera_effe
 RID RendererSceneRenderRD::light_instance_create(RID p_light) {
 	RID li = light_instance_owner.make_rid(LightInstance());
 
-	LightInstance *light_instance = light_instance_owner.getornull(li);
+	LightInstance *light_instance = light_instance_owner.get_or_null(li);
 
 	light_instance->self = li;
 	light_instance->light = p_light;
@@ -1334,21 +1334,21 @@ RID RendererSceneRenderRD::light_instance_create(RID p_light) {
 }
 
 void RendererSceneRenderRD::light_instance_set_transform(RID p_light_instance, const Transform3D &p_transform) {
-	LightInstance *light_instance = light_instance_owner.getornull(p_light_instance);
+	LightInstance *light_instance = light_instance_owner.get_or_null(p_light_instance);
 	ERR_FAIL_COND(!light_instance);
 
 	light_instance->transform = p_transform;
 }
 
 void RendererSceneRenderRD::light_instance_set_aabb(RID p_light_instance, const AABB &p_aabb) {
-	LightInstance *light_instance = light_instance_owner.getornull(p_light_instance);
+	LightInstance *light_instance = light_instance_owner.get_or_null(p_light_instance);
 	ERR_FAIL_COND(!light_instance);
 
 	light_instance->aabb = p_aabb;
 }
 
 void RendererSceneRenderRD::light_instance_set_shadow_transform(RID p_light_instance, const CameraMatrix &p_projection, const Transform3D &p_transform, float p_far, float p_split, int p_pass, float p_shadow_texel_size, float p_bias_scale, float p_range_begin, const Vector2 &p_uv_scale) {
-	LightInstance *light_instance = light_instance_owner.getornull(p_light_instance);
+	LightInstance *light_instance = light_instance_owner.get_or_null(p_light_instance);
 	ERR_FAIL_COND(!light_instance);
 
 	ERR_FAIL_INDEX(p_pass, 6);
@@ -1364,7 +1364,7 @@ void RendererSceneRenderRD::light_instance_set_shadow_transform(RID p_light_inst
 }
 
 void RendererSceneRenderRD::light_instance_mark_visible(RID p_light_instance) {
-	LightInstance *light_instance = light_instance_owner.getornull(p_light_instance);
+	LightInstance *light_instance = light_instance_owner.get_or_null(p_light_instance);
 	ERR_FAIL_COND(!light_instance);
 
 	light_instance->last_scene_pass = scene_pass;
@@ -1407,7 +1407,7 @@ RID RendererSceneRenderRD::decal_instance_create(RID p_decal) {
 }
 
 void RendererSceneRenderRD::decal_instance_set_transform(RID p_decal, const Transform3D &p_transform) {
-	DecalInstance *di = decal_instance_owner.getornull(p_decal);
+	DecalInstance *di = decal_instance_owner.get_or_null(p_decal);
 	ERR_FAIL_COND(!di);
 	di->transform = p_transform;
 }
@@ -1420,7 +1420,7 @@ RID RendererSceneRenderRD::lightmap_instance_create(RID p_lightmap) {
 	return lightmap_instance_owner.make_rid(li);
 }
 void RendererSceneRenderRD::lightmap_instance_set_transform(RID p_lightmap, const Transform3D &p_transform) {
-	LightmapInstance *li = lightmap_instance_owner.getornull(p_lightmap);
+	LightmapInstance *li = lightmap_instance_owner.get_or_null(p_lightmap);
 	ERR_FAIL_COND(!li);
 	li->transform = p_transform;
 }
@@ -1452,7 +1452,7 @@ void RendererSceneRenderRD::voxel_gi_update(RID p_probe, bool p_update_light_ins
 }
 
 void RendererSceneRenderRD::_debug_sdfgi_probes(RID p_render_buffers, RD::DrawListID p_draw_list, RID p_framebuffer, const CameraMatrix &p_camera_with_transform) {
-	RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
+	RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
 	ERR_FAIL_COND(!rb);
 
 	if (!rb->sdfgi) {
@@ -1790,7 +1790,7 @@ void RendererSceneRenderRD::_free_render_buffer_data(RenderBuffers *rb) {
 }
 
 void RendererSceneRenderRD::_process_sss(RID p_render_buffers, const CameraMatrix &p_camera) {
-	RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
+	RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
 	ERR_FAIL_COND(!rb);
 
 	bool can_use_effects = rb->width >= 8 && rb->height >= 8;
@@ -1808,7 +1808,7 @@ void RendererSceneRenderRD::_process_sss(RID p_render_buffers, const CameraMatri
 }
 
 void RendererSceneRenderRD::_process_ssr(RID p_render_buffers, RID p_dest_framebuffer, RID p_normal_buffer, RID p_specular_buffer, RID p_metallic, const Color &p_metallic_mask, RID p_environment, const CameraMatrix &p_projection, bool p_use_additive) {
-	RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
+	RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
 	ERR_FAIL_COND(!rb);
 
 	bool can_use_effects = rb->width >= 8 && rb->height >= 8;
@@ -1819,7 +1819,7 @@ void RendererSceneRenderRD::_process_ssr(RID p_render_buffers, RID p_dest_frameb
 		return;
 	}
 
-	RendererSceneEnvironmentRD *env = environment_owner.getornull(p_environment);
+	RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_environment);
 	ERR_FAIL_COND(!env);
 
 	ERR_FAIL_COND(!env->ssr_enabled);
@@ -1860,10 +1860,10 @@ void RendererSceneRenderRD::_process_ssr(RID p_render_buffers, RID p_dest_frameb
 }
 
 void RendererSceneRenderRD::_process_ssao(RID p_render_buffers, RID p_environment, RID p_normal_buffer, const CameraMatrix &p_projection) {
-	RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
+	RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
 	ERR_FAIL_COND(!rb);
 
-	RendererSceneEnvironmentRD *env = environment_owner.getornull(p_environment);
+	RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_environment);
 	ERR_FAIL_COND(!env);
 
 	RENDER_TIMESTAMP("Process SSAO");
@@ -2005,7 +2005,7 @@ void RendererSceneRenderRD::_process_ssao(RID p_render_buffers, RID p_environmen
 }
 
 void RendererSceneRenderRD::_render_buffers_copy_screen_texture(const RenderDataRD *p_render_data) {
-	RenderBuffers *rb = render_buffers_owner.getornull(p_render_data->render_buffers);
+	RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_data->render_buffers);
 	ERR_FAIL_COND(!rb);
 
 	RD::get_singleton()->draw_command_begin_label("Copy screen texture");
@@ -2034,7 +2034,7 @@ void RendererSceneRenderRD::_render_buffers_copy_screen_texture(const RenderData
 }
 
 void RendererSceneRenderRD::_render_buffers_copy_depth_texture(const RenderDataRD *p_render_data) {
-	RenderBuffers *rb = render_buffers_owner.getornull(p_render_data->render_buffers);
+	RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_data->render_buffers);
 	ERR_FAIL_COND(!rb);
 
 	RD::get_singleton()->draw_command_begin_label("Copy depth texture");
@@ -2057,12 +2057,12 @@ void RendererSceneRenderRD::_render_buffers_copy_depth_texture(const RenderDataR
 }
 
 void RendererSceneRenderRD::_render_buffers_post_process_and_tonemap(const RenderDataRD *p_render_data) {
-	RenderBuffers *rb = render_buffers_owner.getornull(p_render_data->render_buffers);
+	RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_data->render_buffers);
 	ERR_FAIL_COND(!rb);
 
-	RendererSceneEnvironmentRD *env = environment_owner.getornull(p_render_data->environment);
+	RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_render_data->environment);
 	//glow (if enabled)
-	CameraEffects *camfx = camera_effects_owner.getornull(p_render_data->camera_effects);
+	CameraEffects *camfx = camera_effects_owner.get_or_null(p_render_data->camera_effects);
 
 	bool can_use_effects = rb->width >= 8 && rb->height >= 8;
 	bool can_use_storage = _render_buffers_can_be_storage();
@@ -2251,10 +2251,10 @@ void RendererSceneRenderRD::_render_buffers_post_process_and_tonemap(const Rende
 void RendererSceneRenderRD::_post_process_subpass(RID p_source_texture, RID p_framebuffer, const RenderDataRD *p_render_data) {
 	RD::get_singleton()->draw_command_begin_label("Post Process Subpass");
 
-	RenderBuffers *rb = render_buffers_owner.getornull(p_render_data->render_buffers);
+	RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_data->render_buffers);
 	ERR_FAIL_COND(!rb);
 
-	RendererSceneEnvironmentRD *env = environment_owner.getornull(p_render_data->environment);
+	RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_render_data->environment);
 
 	bool can_use_effects = rb->width >= 8 && rb->height >= 8;
 
@@ -2311,7 +2311,7 @@ void RendererSceneRenderRD::_post_process_subpass(RID p_source_texture, RID p_fr
 }
 
 void RendererSceneRenderRD::_disable_clear_request(const RenderDataRD *p_render_data) {
-	RenderBuffers *rb = render_buffers_owner.getornull(p_render_data->render_buffers);
+	RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_data->render_buffers);
 	ERR_FAIL_COND(!rb);
 
 	storage->render_target_disable_clear_request(rb->render_target);
@@ -2320,7 +2320,7 @@ void RendererSceneRenderRD::_disable_clear_request(const RenderDataRD *p_render_
 void RendererSceneRenderRD::_render_buffers_debug_draw(RID p_render_buffers, RID p_shadow_atlas, RID p_occlusion_buffer) {
 	EffectsRD *effects = storage->get_effects();
 
-	RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
+	RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
 	ERR_FAIL_COND(!rb);
 
 	if (debug_draw == RS::VIEWPORT_DEBUG_DRAW_SHADOW_ATLAS) {
@@ -2386,7 +2386,7 @@ void RendererSceneRenderRD::_render_buffers_debug_draw(RID p_render_buffers, RID
 }
 
 void RendererSceneRenderRD::environment_set_adjustment(RID p_env, bool p_enable, float p_brightness, float p_contrast, float p_saturation, bool p_use_1d_color_correction, RID p_color_correction) {
-	RendererSceneEnvironmentRD *env = environment_owner.getornull(p_env);
+	RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
 	ERR_FAIL_COND(!env);
 
 	env->adjustments_enabled = p_enable;
@@ -2398,7 +2398,7 @@ void RendererSceneRenderRD::environment_set_adjustment(RID p_env, bool p_enable,
 }
 
 RID RendererSceneRenderRD::render_buffers_get_back_buffer_texture(RID p_render_buffers) {
-	RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
+	RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
 	ERR_FAIL_COND_V(!rb, RID());
 	if (!rb->blur[0].texture.is_valid()) {
 		return RID(); //not valid at the moment
@@ -2407,7 +2407,7 @@ RID RendererSceneRenderRD::render_buffers_get_back_buffer_texture(RID p_render_b
 }
 
 RID RendererSceneRenderRD::render_buffers_get_back_depth_texture(RID p_render_buffers) {
-	RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
+	RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
 	ERR_FAIL_COND_V(!rb, RID());
 	if (!rb->depth_back_texture.is_valid()) {
 		return RID(); //not valid at the moment
@@ -2416,21 +2416,21 @@ RID RendererSceneRenderRD::render_buffers_get_back_depth_texture(RID p_render_bu
 }
 
 RID RendererSceneRenderRD::render_buffers_get_depth_texture(RID p_render_buffers) {
-	RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
+	RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
 	ERR_FAIL_COND_V(!rb, RID());
 
 	return rb->depth_texture;
 }
 
 RID RendererSceneRenderRD::render_buffers_get_ao_texture(RID p_render_buffers) {
-	RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
+	RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
 	ERR_FAIL_COND_V(!rb, RID());
 
 	return rb->ssao.ao_final;
 }
 
 RID RendererSceneRenderRD::render_buffers_get_voxel_gi_buffer(RID p_render_buffers) {
-	RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
+	RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
 	ERR_FAIL_COND_V(!rb, RID());
 	if (rb->gi.voxel_gi_buffer.is_null()) {
 		rb->gi.voxel_gi_buffer = RD::get_singleton()->uniform_buffer_create(sizeof(RendererSceneGIRD::VoxelGIData) * RendererSceneGIRD::MAX_VOXEL_GI_INSTANCES);
@@ -2443,31 +2443,31 @@ RID RendererSceneRenderRD::render_buffers_get_default_voxel_gi_buffer() {
 }
 
 RID RendererSceneRenderRD::render_buffers_get_gi_ambient_texture(RID p_render_buffers) {
-	RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
+	RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
 	ERR_FAIL_COND_V(!rb, RID());
 	return rb->ambient_buffer;
 }
 RID RendererSceneRenderRD::render_buffers_get_gi_reflection_texture(RID p_render_buffers) {
-	RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
+	RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
 	ERR_FAIL_COND_V(!rb, RID());
 	return rb->reflection_buffer;
 }
 
 uint32_t RendererSceneRenderRD::render_buffers_get_sdfgi_cascade_count(RID p_render_buffers) const {
-	const RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
+	const RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
 	ERR_FAIL_COND_V(!rb, 0);
 	ERR_FAIL_COND_V(!rb->sdfgi, 0);
 
 	return rb->sdfgi->cascades.size();
 }
 bool RendererSceneRenderRD::render_buffers_is_sdfgi_enabled(RID p_render_buffers) const {
-	const RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
+	const RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
 	ERR_FAIL_COND_V(!rb, false);
 
 	return rb->sdfgi != nullptr;
 }
 RID RendererSceneRenderRD::render_buffers_get_sdfgi_irradiance_probes(RID p_render_buffers) const {
-	const RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
+	const RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
 	ERR_FAIL_COND_V(!rb, RID());
 	ERR_FAIL_COND_V(!rb->sdfgi, RID());
 
@@ -2475,7 +2475,7 @@ RID RendererSceneRenderRD::render_buffers_get_sdfgi_irradiance_probes(RID p_rend
 }
 
 Vector3 RendererSceneRenderRD::render_buffers_get_sdfgi_cascade_offset(RID p_render_buffers, uint32_t p_cascade) const {
-	const RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
+	const RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
 	ERR_FAIL_COND_V(!rb, Vector3());
 	ERR_FAIL_COND_V(!rb->sdfgi, Vector3());
 	ERR_FAIL_UNSIGNED_INDEX_V(p_cascade, rb->sdfgi->cascades.size(), Vector3());
@@ -2484,7 +2484,7 @@ Vector3 RendererSceneRenderRD::render_buffers_get_sdfgi_cascade_offset(RID p_ren
 }
 
 Vector3i RendererSceneRenderRD::render_buffers_get_sdfgi_cascade_probe_offset(RID p_render_buffers, uint32_t p_cascade) const {
-	const RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
+	const RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
 	ERR_FAIL_COND_V(!rb, Vector3i());
 	ERR_FAIL_COND_V(!rb->sdfgi, Vector3i());
 	ERR_FAIL_UNSIGNED_INDEX_V(p_cascade, rb->sdfgi->cascades.size(), Vector3i());
@@ -2494,14 +2494,14 @@ Vector3i RendererSceneRenderRD::render_buffers_get_sdfgi_cascade_probe_offset(RI
 }
 
 float RendererSceneRenderRD::render_buffers_get_sdfgi_normal_bias(RID p_render_buffers) const {
-	const RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
+	const RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
 	ERR_FAIL_COND_V(!rb, 0);
 	ERR_FAIL_COND_V(!rb->sdfgi, 0);
 
 	return rb->sdfgi->normal_bias;
 }
 float RendererSceneRenderRD::render_buffers_get_sdfgi_cascade_probe_size(RID p_render_buffers, uint32_t p_cascade) const {
-	const RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
+	const RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
 	ERR_FAIL_COND_V(!rb, 0);
 	ERR_FAIL_COND_V(!rb->sdfgi, 0);
 	ERR_FAIL_UNSIGNED_INDEX_V(p_cascade, rb->sdfgi->cascades.size(), 0);
@@ -2509,7 +2509,7 @@ float RendererSceneRenderRD::render_buffers_get_sdfgi_cascade_probe_size(RID p_r
 	return float(rb->sdfgi->cascade_size) * rb->sdfgi->cascades[p_cascade].cell_size / float(rb->sdfgi->probe_axis_count - 1);
 }
 uint32_t RendererSceneRenderRD::render_buffers_get_sdfgi_cascade_probe_count(RID p_render_buffers) const {
-	const RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
+	const RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
 	ERR_FAIL_COND_V(!rb, 0);
 	ERR_FAIL_COND_V(!rb->sdfgi, 0);
 
@@ -2517,7 +2517,7 @@ uint32_t RendererSceneRenderRD::render_buffers_get_sdfgi_cascade_probe_count(RID
 }
 
 uint32_t RendererSceneRenderRD::render_buffers_get_sdfgi_cascade_size(RID p_render_buffers) const {
-	const RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
+	const RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
 	ERR_FAIL_COND_V(!rb, 0);
 	ERR_FAIL_COND_V(!rb->sdfgi, 0);
 
@@ -2525,7 +2525,7 @@ uint32_t RendererSceneRenderRD::render_buffers_get_sdfgi_cascade_size(RID p_rend
 }
 
 bool RendererSceneRenderRD::render_buffers_is_sdfgi_using_occlusion(RID p_render_buffers) const {
-	const RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
+	const RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
 	ERR_FAIL_COND_V(!rb, false);
 	ERR_FAIL_COND_V(!rb->sdfgi, false);
 
@@ -2533,14 +2533,14 @@ bool RendererSceneRenderRD::render_buffers_is_sdfgi_using_occlusion(RID p_render
 }
 
 float RendererSceneRenderRD::render_buffers_get_sdfgi_energy(RID p_render_buffers) const {
-	const RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
+	const RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
 	ERR_FAIL_COND_V(!rb, 0.0);
 	ERR_FAIL_COND_V(!rb->sdfgi, 0.0);
 
 	return rb->sdfgi->energy;
 }
 RID RendererSceneRenderRD::render_buffers_get_sdfgi_occlusion_texture(RID p_render_buffers) const {
-	const RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
+	const RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
 	ERR_FAIL_COND_V(!rb, RID());
 	ERR_FAIL_COND_V(!rb->sdfgi, RID());
 
@@ -2548,20 +2548,20 @@ RID RendererSceneRenderRD::render_buffers_get_sdfgi_occlusion_texture(RID p_rend
 }
 
 bool RendererSceneRenderRD::render_buffers_has_volumetric_fog(RID p_render_buffers) const {
-	const RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
+	const RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
 	ERR_FAIL_COND_V(!rb, false);
 
 	return rb->volumetric_fog != nullptr;
 }
 RID RendererSceneRenderRD::render_buffers_get_volumetric_fog_texture(RID p_render_buffers) {
-	const RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
+	const RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
 	ERR_FAIL_COND_V(!rb || !rb->volumetric_fog, RID());
 
 	return rb->volumetric_fog->fog_map;
 }
 
 RID RendererSceneRenderRD::render_buffers_get_volumetric_fog_sky_uniform_set(RID p_render_buffers) {
-	const RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
+	const RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
 	ERR_FAIL_COND_V(!rb, RID());
 
 	if (!rb->volumetric_fog) {
@@ -2572,12 +2572,12 @@ RID RendererSceneRenderRD::render_buffers_get_volumetric_fog_sky_uniform_set(RID
 }
 
 float RendererSceneRenderRD::render_buffers_get_volumetric_fog_end(RID p_render_buffers) {
-	const RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
+	const RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
 	ERR_FAIL_COND_V(!rb || !rb->volumetric_fog, 0);
 	return rb->volumetric_fog->length;
 }
 float RendererSceneRenderRD::render_buffers_get_volumetric_fog_detail_spread(RID p_render_buffers) {
-	const RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
+	const RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
 	ERR_FAIL_COND_V(!rb || !rb->volumetric_fog, 0);
 	return rb->volumetric_fog->spread;
 }
@@ -2597,7 +2597,7 @@ bool RendererSceneRenderRD::_render_buffers_can_be_storage() {
 void RendererSceneRenderRD::render_buffers_configure(RID p_render_buffers, RID p_render_target, int p_width, int p_height, RS::ViewportMSAA p_msaa, RenderingServer::ViewportScreenSpaceAA p_screen_space_aa, bool p_use_debanding, uint32_t p_view_count) {
 	ERR_FAIL_COND_MSG(p_view_count == 0, "Must have at least 1 view");
 
-	RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
+	RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
 
 	// Should we add an overrule per viewport?
 	rb->width = p_width;
@@ -2801,7 +2801,7 @@ bool RendererSceneRenderRD::is_using_radiance_cubemap_array() const {
 }
 
 RendererSceneRenderRD::RenderBufferData *RendererSceneRenderRD::render_buffers_get_data(RID p_render_buffers) {
-	RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
+	RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
 	ERR_FAIL_COND_V(!rb, nullptr);
 	return rb->data;
 }
@@ -2814,7 +2814,7 @@ void RendererSceneRenderRD::_setup_reflections(const PagedArray<RID> &p_reflecti
 			break;
 		}
 
-		ReflectionProbeInstance *rpi = reflection_probe_instance_owner.getornull(p_reflections[i]);
+		ReflectionProbeInstance *rpi = reflection_probe_instance_owner.get_or_null(p_reflections[i]);
 		if (!rpi) {
 			continue;
 		}
@@ -2900,7 +2900,7 @@ void RendererSceneRenderRD::_setup_lights(const PagedArray<RID> &p_lights, const
 	r_directional_light_soft_shadows = false;
 
 	for (int i = 0; i < (int)p_lights.size(); i++) {
-		LightInstance *li = light_instance_owner.getornull(p_lights[i]);
+		LightInstance *li = light_instance_owner.get_or_null(p_lights[i]);
 		if (!li) {
 			continue;
 		}
@@ -3129,7 +3129,7 @@ void RendererSceneRenderRD::_setup_lights(const PagedArray<RID> &p_lights, const
 	ShadowAtlas *shadow_atlas = nullptr;
 
 	if (p_shadow_atlas.is_valid() && p_using_shadows) {
-		shadow_atlas = shadow_atlas_owner.getornull(p_shadow_atlas);
+		shadow_atlas = shadow_atlas_owner.get_or_null(p_shadow_atlas);
 	}
 
 	bool using_forward_ids = _uses_forward_ids();
@@ -3312,7 +3312,7 @@ void RendererSceneRenderRD::_setup_decals(const PagedArray<RID> &p_decals, const
 			break;
 		}
 
-		DecalInstance *di = decal_instance_owner.getornull(p_decals[i]);
+		DecalInstance *di = decal_instance_owner.get_or_null(p_decals[i]);
 		if (!di) {
 			continue;
 		}
@@ -3495,9 +3495,9 @@ void RendererSceneRenderRD::_volumetric_fog_erase(RenderBuffers *rb) {
 
 void RendererSceneRenderRD::_update_volumetric_fog(RID p_render_buffers, RID p_environment, const CameraMatrix &p_cam_projection, const Transform3D &p_cam_transform, RID p_shadow_atlas, int p_directional_light_count, bool p_use_directional_shadows, int p_positional_light_count, int p_voxel_gi_count) {
 	ERR_FAIL_COND(!is_clustered_enabled()); // can't use volumetric fog without clustered
-	RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
+	RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
 	ERR_FAIL_COND(!rb);
-	RendererSceneEnvironmentRD *env = environment_owner.getornull(p_environment);
+	RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_environment);
 
 	float ratio = float(rb->width) / float((rb->width + rb->height) / 2);
 	uint32_t target_width = uint32_t(float(volumetric_fog_size) * ratio);
@@ -3566,7 +3566,7 @@ void RendererSceneRenderRD::_update_volumetric_fog(RID p_render_buffers, RID p_e
 			RD::Uniform u;
 			u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 			u.binding = 1;
-			ShadowAtlas *shadow_atlas = shadow_atlas_owner.getornull(p_shadow_atlas);
+			ShadowAtlas *shadow_atlas = shadow_atlas_owner.get_or_null(p_shadow_atlas);
 			if (shadow_atlas == nullptr || shadow_atlas->depth.is_null()) {
 				u.ids.push_back(storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_BLACK));
 			} else {
@@ -3888,7 +3888,7 @@ void RendererSceneRenderRD::_update_volumetric_fog(RID p_render_buffers, RID p_e
 
 bool RendererSceneRenderRD::_needs_post_prepass_render(RenderDataRD *p_render_data, bool p_use_gi) {
 	if (p_render_data->render_buffers.is_valid()) {
-		RenderBuffers *rb = render_buffers_owner.getornull(p_render_data->render_buffers);
+		RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_data->render_buffers);
 		if (rb->sdfgi != nullptr) {
 			return true;
 		}
@@ -3899,14 +3899,14 @@ bool RendererSceneRenderRD::_needs_post_prepass_render(RenderDataRD *p_render_da
 void RendererSceneRenderRD::_post_prepass_render(RenderDataRD *p_render_data, bool p_use_gi) {
 	if (p_render_data->render_buffers.is_valid()) {
 		if (p_use_gi) {
-			RenderBuffers *rb = render_buffers_owner.getornull(p_render_data->render_buffers);
+			RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_data->render_buffers);
 			ERR_FAIL_COND(rb == nullptr);
 			if (rb->sdfgi == nullptr) {
 				return;
 			}
 
-			RendererSceneEnvironmentRD *env = environment_owner.getornull(p_render_data->environment);
-			rb->sdfgi->update_probes(env, sky.sky_owner.getornull(env->sky));
+			RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_render_data->environment);
+			rb->sdfgi->update_probes(env, sky.sky_owner.get_or_null(env->sky));
 		}
 	}
 }
@@ -3923,7 +3923,7 @@ void RendererSceneRenderRD::_pre_opaque_render(RenderDataRD *p_render_data, bool
 	// Render shadows while GI is rendering, due to how barriers are handled, this should happen at the same time
 
 	if (p_render_data->render_buffers.is_valid() && p_use_gi) {
-		RenderBuffers *rb = render_buffers_owner.getornull(p_render_data->render_buffers);
+		RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_data->render_buffers);
 		ERR_FAIL_COND(rb == nullptr);
 		if (rb->sdfgi != nullptr) {
 			rb->sdfgi->store_probes();
@@ -3938,7 +3938,7 @@ void RendererSceneRenderRD::_pre_opaque_render(RenderDataRD *p_render_data, bool
 	float lod_distance_multiplier = p_render_data->cam_projection.get_lod_multiplier();
 	{
 		for (int i = 0; i < render_state.render_shadow_count; i++) {
-			LightInstance *li = light_instance_owner.getornull(render_state.render_shadows[i].light);
+			LightInstance *li = light_instance_owner.get_or_null(render_state.render_shadows[i].light);
 
 			if (storage->light_get_type(li->light) == RS::LIGHT_DIRECTIONAL) {
 				render_state.directional_shadows.push_back(i);
@@ -4058,7 +4058,7 @@ void RendererSceneRenderRD::render_scene(RID p_render_buffers, const CameraData
 	// getting this here now so we can direct call a bunch of things more easily
 	RenderBuffers *rb = nullptr;
 	if (p_render_buffers.is_valid()) {
-		rb = render_buffers_owner.getornull(p_render_buffers);
+		rb = render_buffers_owner.get_or_null(p_render_buffers);
 		ERR_FAIL_COND(!rb);
 	}
 
@@ -4140,7 +4140,7 @@ void RendererSceneRenderRD::render_scene(RID p_render_buffers, const CameraData
 	//assign render indices to voxel_gi_instances
 	if (is_dynamic_gi_supported()) {
 		for (uint32_t i = 0; i < (uint32_t)p_voxel_gi_instances.size(); i++) {
-			RendererSceneGIRD::VoxelGIInstance *voxel_gi_inst = gi.voxel_gi_instance_owner.getornull(p_voxel_gi_instances[i]);
+			RendererSceneGIRD::VoxelGIInstance *voxel_gi_inst = gi.voxel_gi_instance_owner.get_or_null(p_voxel_gi_instances[i]);
 			if (voxel_gi_inst) {
 				voxel_gi_inst->render_index = i;
 			}
@@ -4151,8 +4151,8 @@ void RendererSceneRenderRD::render_scene(RID p_render_buffers, const CameraData
 		// render_data.render_buffers == p_render_buffers so we can use our already retrieved rb
 		current_cluster_builder = rb->cluster_builder;
 	} else if (reflection_probe_instance_owner.owns(render_data.reflection_probe)) {
-		ReflectionProbeInstance *rpi = reflection_probe_instance_owner.getornull(render_data.reflection_probe);
-		ReflectionAtlas *ra = reflection_atlas_owner.getornull(rpi->atlas);
+		ReflectionProbeInstance *rpi = reflection_probe_instance_owner.get_or_null(render_data.reflection_probe);
+		ReflectionAtlas *ra = reflection_atlas_owner.get_or_null(rpi->atlas);
 		if (!ra) {
 			ERR_PRINT("reflection probe has no reflection atlas! Bug?");
 			current_cluster_builder = nullptr;
@@ -4230,7 +4230,7 @@ void RendererSceneRenderRD::_debug_draw_cluster(RID p_render_buffers) {
 }
 
 void RendererSceneRenderRD::_render_shadow_pass(RID p_light, RID p_shadow_atlas, int p_pass, const PagedArray<GeometryInstance *> &p_instances, const Plane &p_camera_plane, float p_lod_distance_multiplier, float p_screen_lod_threshold, bool p_open_pass, bool p_close_pass, bool p_clear_region, RendererScene::RenderInfo *p_render_info) {
-	LightInstance *light_instance = light_instance_owner.getornull(p_light);
+	LightInstance *light_instance = light_instance_owner.get_or_null(p_light);
 	ERR_FAIL_COND(!light_instance);
 
 	Rect2i atlas_rect;
@@ -4301,7 +4301,7 @@ void RendererSceneRenderRD::_render_shadow_pass(RID p_light, RID p_shadow_atlas,
 	} else {
 		//set from shadow atlas
 
-		ShadowAtlas *shadow_atlas = shadow_atlas_owner.getornull(p_shadow_atlas);
+		ShadowAtlas *shadow_atlas = shadow_atlas_owner.get_or_null(p_shadow_atlas);
 		ERR_FAIL_COND(!shadow_atlas);
 		ERR_FAIL_COND(!shadow_atlas->shadow_owners.has(p_light));
 
@@ -4424,7 +4424,7 @@ void RendererSceneRenderRD::render_particle_collider_heightfield(RID p_collider,
 
 bool RendererSceneRenderRD::free(RID p_rid) {
 	if (render_buffers_owner.owns(p_rid)) {
-		RenderBuffers *rb = render_buffers_owner.getornull(p_rid);
+		RenderBuffers *rb = render_buffers_owner.get_or_null(p_rid);
 		_free_render_buffer_data(rb);
 		memdelete(rb->data);
 		if (rb->sdfgi) {
@@ -4447,24 +4447,24 @@ bool RendererSceneRenderRD::free(RID p_rid) {
 		camera_effects_owner.free(p_rid);
 	} else if (reflection_atlas_owner.owns(p_rid)) {
 		reflection_atlas_set_size(p_rid, 0, 0);
-		ReflectionAtlas *ra = reflection_atlas_owner.getornull(p_rid);
+		ReflectionAtlas *ra = reflection_atlas_owner.get_or_null(p_rid);
 		if (ra->cluster_builder) {
 			memdelete(ra->cluster_builder);
 		}
 		reflection_atlas_owner.free(p_rid);
 	} else if (reflection_probe_instance_owner.owns(p_rid)) {
-		ReflectionProbeInstance *rpi = reflection_probe_instance_owner.getornull(p_rid);
+		ReflectionProbeInstance *rpi = reflection_probe_instance_owner.get_or_null(p_rid);
 		_free_forward_id(FORWARD_ID_TYPE_REFLECTION_PROBE, rpi->forward_id);
 		reflection_probe_release_atlas_index(p_rid);
 		reflection_probe_instance_owner.free(p_rid);
 	} else if (decal_instance_owner.owns(p_rid)) {
-		DecalInstance *di = decal_instance_owner.getornull(p_rid);
+		DecalInstance *di = decal_instance_owner.get_or_null(p_rid);
 		_free_forward_id(FORWARD_ID_TYPE_DECAL, di->forward_id);
 		decal_instance_owner.free(p_rid);
 	} else if (lightmap_instance_owner.owns(p_rid)) {
 		lightmap_instance_owner.free(p_rid);
 	} else if (gi.voxel_gi_instance_owner.owns(p_rid)) {
-		RendererSceneGIRD::VoxelGIInstance *voxel_gi = gi.voxel_gi_instance_owner.getornull(p_rid);
+		RendererSceneGIRD::VoxelGIInstance *voxel_gi = gi.voxel_gi_instance_owner.get_or_null(p_rid);
 		if (voxel_gi->texture.is_valid()) {
 			RD::get_singleton()->free(voxel_gi->texture);
 			RD::get_singleton()->free(voxel_gi->write_buffer);
@@ -4480,11 +4480,11 @@ bool RendererSceneRenderRD::free(RID p_rid) {
 		sky.update_dirty_skys();
 		sky.free_sky(p_rid);
 	} else if (light_instance_owner.owns(p_rid)) {
-		LightInstance *light_instance = light_instance_owner.getornull(p_rid);
+		LightInstance *light_instance = light_instance_owner.get_or_null(p_rid);
 
 		//remove from shadow atlases..
 		for (Set<RID>::Element *E = light_instance->shadow_atlases.front(); E; E = E->next()) {
-			ShadowAtlas *shadow_atlas = shadow_atlas_owner.getornull(E->get());
+			ShadowAtlas *shadow_atlas = shadow_atlas_owner.get_or_null(E->get());
 			ERR_CONTINUE(!shadow_atlas->shadow_owners.has(p_rid));
 			uint32_t key = shadow_atlas->shadow_owners[p_rid];
 			uint32_t q = (key >> ShadowAtlas::QUADRANT_SHIFT) & 0x3;
diff --git a/servers/rendering/renderer_rd/renderer_scene_render_rd.h b/servers/rendering/renderer_rd/renderer_scene_render_rd.h
index db423b7d25..fa80b84cfe 100644
--- a/servers/rendering/renderer_rd/renderer_scene_render_rd.h
+++ b/servers/rendering/renderer_rd/renderer_scene_render_rd.h
@@ -149,7 +149,7 @@ protected:
 
 	RendererSceneEnvironmentRD *get_environment(RID p_environment) {
 		if (p_environment.is_valid()) {
-			return environment_owner.getornull(p_environment);
+			return environment_owner.get_or_null(p_environment);
 		} else {
 			return nullptr;
 		}
@@ -814,19 +814,19 @@ public:
 	virtual void shadow_atlas_set_quadrant_subdivision(RID p_atlas, int p_quadrant, int p_subdivision) override;
 	virtual bool shadow_atlas_update_light(RID p_atlas, RID p_light_intance, float p_coverage, uint64_t p_light_version) override;
 	_FORCE_INLINE_ bool shadow_atlas_owns_light_instance(RID p_atlas, RID p_light_intance) {
-		ShadowAtlas *atlas = shadow_atlas_owner.getornull(p_atlas);
+		ShadowAtlas *atlas = shadow_atlas_owner.get_or_null(p_atlas);
 		ERR_FAIL_COND_V(!atlas, false);
 		return atlas->shadow_owners.has(p_light_intance);
 	}
 
 	_FORCE_INLINE_ RID shadow_atlas_get_texture(RID p_atlas) {
-		ShadowAtlas *atlas = shadow_atlas_owner.getornull(p_atlas);
+		ShadowAtlas *atlas = shadow_atlas_owner.get_or_null(p_atlas);
 		ERR_FAIL_COND_V(!atlas, RID());
 		return atlas->depth;
 	}
 
 	_FORCE_INLINE_ Size2i shadow_atlas_get_size(RID p_atlas) {
-		ShadowAtlas *atlas = shadow_atlas_owner.getornull(p_atlas);
+		ShadowAtlas *atlas = shadow_atlas_owner.get_or_null(p_atlas);
 		ERR_FAIL_COND_V(!atlas, Size2i());
 		return Size2(atlas->size, atlas->size);
 	}
@@ -942,7 +942,7 @@ public:
 	virtual void camera_effects_set_custom_exposure(RID p_camera_effects, bool p_enable, float p_exposure) override;
 
 	bool camera_effects_uses_dof(RID p_camera_effects) {
-		CameraEffects *camfx = camera_effects_owner.getornull(p_camera_effects);
+		CameraEffects *camfx = camera_effects_owner.get_or_null(p_camera_effects);
 
 		return camfx && (camfx->dof_blur_near_enabled || camfx->dof_blur_far_enabled) && camfx->dof_blur_amount > 0.0;
 	}
@@ -954,18 +954,18 @@ public:
 	virtual void light_instance_mark_visible(RID p_light_instance) override;
 
 	_FORCE_INLINE_ RID light_instance_get_base_light(RID p_light_instance) {
-		LightInstance *li = light_instance_owner.getornull(p_light_instance);
+		LightInstance *li = light_instance_owner.get_or_null(p_light_instance);
 		return li->light;
 	}
 
 	_FORCE_INLINE_ Transform3D light_instance_get_base_transform(RID p_light_instance) {
-		LightInstance *li = light_instance_owner.getornull(p_light_instance);
+		LightInstance *li = light_instance_owner.get_or_null(p_light_instance);
 		return li->transform;
 	}
 
 	_FORCE_INLINE_ Rect2 light_instance_get_shadow_atlas_rect(RID p_light_instance, RID p_shadow_atlas, Vector2i &r_omni_offset) {
-		ShadowAtlas *shadow_atlas = shadow_atlas_owner.getornull(p_shadow_atlas);
-		LightInstance *li = light_instance_owner.getornull(p_light_instance);
+		ShadowAtlas *shadow_atlas = shadow_atlas_owner.get_or_null(p_shadow_atlas);
+		LightInstance *li = light_instance_owner.get_or_null(p_light_instance);
 		uint32_t key = shadow_atlas->shadow_owners[li->self];
 
 		uint32_t quadrant = (key >> ShadowAtlas::QUADRANT_SHIFT) & 0x3;
@@ -1000,16 +1000,16 @@ public:
 	}
 
 	_FORCE_INLINE_ CameraMatrix light_instance_get_shadow_camera(RID p_light_instance, int p_index) {
-		LightInstance *li = light_instance_owner.getornull(p_light_instance);
+		LightInstance *li = light_instance_owner.get_or_null(p_light_instance);
 		return li->shadow_transform[p_index].camera;
 	}
 
 	_FORCE_INLINE_ float light_instance_get_shadow_texel_size(RID p_light_instance, RID p_shadow_atlas) {
 #ifdef DEBUG_ENABLED
-		LightInstance *li = light_instance_owner.getornull(p_light_instance);
+		LightInstance *li = light_instance_owner.get_or_null(p_light_instance);
 		ERR_FAIL_COND_V(!li->shadow_atlases.has(p_shadow_atlas), 0);
 #endif
-		ShadowAtlas *shadow_atlas = shadow_atlas_owner.getornull(p_shadow_atlas);
+		ShadowAtlas *shadow_atlas = shadow_atlas_owner.get_or_null(p_shadow_atlas);
 		ERR_FAIL_COND_V(!shadow_atlas, 0);
 #ifdef DEBUG_ENABLED
 		ERR_FAIL_COND_V(!shadow_atlas->shadow_owners.has(p_light_instance), 0);
@@ -1027,59 +1027,59 @@ public:
 
 	_FORCE_INLINE_ Transform3D
 	light_instance_get_shadow_transform(RID p_light_instance, int p_index) {
-		LightInstance *li = light_instance_owner.getornull(p_light_instance);
+		LightInstance *li = light_instance_owner.get_or_null(p_light_instance);
 		return li->shadow_transform[p_index].transform;
 	}
 	_FORCE_INLINE_ float light_instance_get_shadow_bias_scale(RID p_light_instance, int p_index) {
-		LightInstance *li = light_instance_owner.getornull(p_light_instance);
+		LightInstance *li = light_instance_owner.get_or_null(p_light_instance);
 		return li->shadow_transform[p_index].bias_scale;
 	}
 	_FORCE_INLINE_ float light_instance_get_shadow_range(RID p_light_instance, int p_index) {
-		LightInstance *li = light_instance_owner.getornull(p_light_instance);
+		LightInstance *li = light_instance_owner.get_or_null(p_light_instance);
 		return li->shadow_transform[p_index].farplane;
 	}
 	_FORCE_INLINE_ float light_instance_get_shadow_range_begin(RID p_light_instance, int p_index) {
-		LightInstance *li = light_instance_owner.getornull(p_light_instance);
+		LightInstance *li = light_instance_owner.get_or_null(p_light_instance);
 		return li->shadow_transform[p_index].range_begin;
 	}
 
 	_FORCE_INLINE_ Vector2 light_instance_get_shadow_uv_scale(RID p_light_instance, int p_index) {
-		LightInstance *li = light_instance_owner.getornull(p_light_instance);
+		LightInstance *li = light_instance_owner.get_or_null(p_light_instance);
 		return li->shadow_transform[p_index].uv_scale;
 	}
 
 	_FORCE_INLINE_ Rect2 light_instance_get_directional_shadow_atlas_rect(RID p_light_instance, int p_index) {
-		LightInstance *li = light_instance_owner.getornull(p_light_instance);
+		LightInstance *li = light_instance_owner.get_or_null(p_light_instance);
 		return li->shadow_transform[p_index].atlas_rect;
 	}
 
 	_FORCE_INLINE_ float light_instance_get_directional_shadow_split(RID p_light_instance, int p_index) {
-		LightInstance *li = light_instance_owner.getornull(p_light_instance);
+		LightInstance *li = light_instance_owner.get_or_null(p_light_instance);
 		return li->shadow_transform[p_index].split;
 	}
 
 	_FORCE_INLINE_ float light_instance_get_directional_shadow_texel_size(RID p_light_instance, int p_index) {
-		LightInstance *li = light_instance_owner.getornull(p_light_instance);
+		LightInstance *li = light_instance_owner.get_or_null(p_light_instance);
 		return li->shadow_transform[p_index].shadow_texel_size;
 	}
 
 	_FORCE_INLINE_ void light_instance_set_render_pass(RID p_light_instance, uint64_t p_pass) {
-		LightInstance *li = light_instance_owner.getornull(p_light_instance);
+		LightInstance *li = light_instance_owner.get_or_null(p_light_instance);
 		li->last_pass = p_pass;
 	}
 
 	_FORCE_INLINE_ uint64_t light_instance_get_render_pass(RID p_light_instance) {
-		LightInstance *li = light_instance_owner.getornull(p_light_instance);
+		LightInstance *li = light_instance_owner.get_or_null(p_light_instance);
 		return li->last_pass;
 	}
 
 	_FORCE_INLINE_ ForwardID light_instance_get_forward_id(RID p_light_instance) {
-		LightInstance *li = light_instance_owner.getornull(p_light_instance);
+		LightInstance *li = light_instance_owner.get_or_null(p_light_instance);
 		return li->forward_id;
 	}
 
 	_FORCE_INLINE_ RS::LightType light_instance_get_type(RID p_light_instance) {
-		LightInstance *li = light_instance_owner.getornull(p_light_instance);
+		LightInstance *li = light_instance_owner.get_or_null(p_light_instance);
 		return li->light_type;
 	}
 
@@ -1088,7 +1088,7 @@ public:
 	virtual int reflection_atlas_get_size(RID p_ref_atlas) const override;
 
 	_FORCE_INLINE_ RID reflection_atlas_get_texture(RID p_ref_atlas) {
-		ReflectionAtlas *atlas = reflection_atlas_owner.getornull(p_ref_atlas);
+		ReflectionAtlas *atlas = reflection_atlas_owner.get_or_null(p_ref_atlas);
 		ERR_FAIL_COND_V(!atlas, RID());
 		return atlas->reflection;
 	}
@@ -1107,41 +1107,41 @@ public:
 	RID reflection_probe_instance_get_depth_framebuffer(RID p_instance, int p_index);
 
 	_FORCE_INLINE_ RID reflection_probe_instance_get_probe(RID p_instance) {
-		ReflectionProbeInstance *rpi = reflection_probe_instance_owner.getornull(p_instance);
+		ReflectionProbeInstance *rpi = reflection_probe_instance_owner.get_or_null(p_instance);
 		ERR_FAIL_COND_V(!rpi, RID());
 
 		return rpi->probe;
 	}
 
 	_FORCE_INLINE_ ForwardID reflection_probe_instance_get_forward_id(RID p_instance) {
-		ReflectionProbeInstance *rpi = reflection_probe_instance_owner.getornull(p_instance);
+		ReflectionProbeInstance *rpi = reflection_probe_instance_owner.get_or_null(p_instance);
 		ERR_FAIL_COND_V(!rpi, 0);
 
 		return rpi->forward_id;
 	}
 
 	_FORCE_INLINE_ void reflection_probe_instance_set_render_pass(RID p_instance, uint32_t p_render_pass) {
-		ReflectionProbeInstance *rpi = reflection_probe_instance_owner.getornull(p_instance);
+		ReflectionProbeInstance *rpi = reflection_probe_instance_owner.get_or_null(p_instance);
 		ERR_FAIL_COND(!rpi);
 		rpi->last_pass = p_render_pass;
 	}
 
 	_FORCE_INLINE_ uint32_t reflection_probe_instance_get_render_pass(RID p_instance) {
-		ReflectionProbeInstance *rpi = reflection_probe_instance_owner.getornull(p_instance);
+		ReflectionProbeInstance *rpi = reflection_probe_instance_owner.get_or_null(p_instance);
 		ERR_FAIL_COND_V(!rpi, 0);
 
 		return rpi->last_pass;
 	}
 
 	_FORCE_INLINE_ Transform3D reflection_probe_instance_get_transform(RID p_instance) {
-		ReflectionProbeInstance *rpi = reflection_probe_instance_owner.getornull(p_instance);
+		ReflectionProbeInstance *rpi = reflection_probe_instance_owner.get_or_null(p_instance);
 		ERR_FAIL_COND_V(!rpi, Transform3D());
 
 		return rpi->transform;
 	}
 
 	_FORCE_INLINE_ int reflection_probe_instance_get_atlas_index(RID p_instance) {
-		ReflectionProbeInstance *rpi = reflection_probe_instance_owner.getornull(p_instance);
+		ReflectionProbeInstance *rpi = reflection_probe_instance_owner.get_or_null(p_instance);
 		ERR_FAIL_COND_V(!rpi, -1);
 
 		return rpi->atlas_index;
@@ -1151,32 +1151,32 @@ public:
 	virtual void decal_instance_set_transform(RID p_decal, const Transform3D &p_transform) override;
 
 	_FORCE_INLINE_ RID decal_instance_get_base(RID p_decal) const {
-		DecalInstance *decal = decal_instance_owner.getornull(p_decal);
+		DecalInstance *decal = decal_instance_owner.get_or_null(p_decal);
 		return decal->decal;
 	}
 
 	_FORCE_INLINE_ ForwardID decal_instance_get_forward_id(RID p_decal) const {
-		DecalInstance *decal = decal_instance_owner.getornull(p_decal);
+		DecalInstance *decal = decal_instance_owner.get_or_null(p_decal);
 		return decal->forward_id;
 	}
 
 	_FORCE_INLINE_ Transform3D decal_instance_get_transform(RID p_decal) const {
-		DecalInstance *decal = decal_instance_owner.getornull(p_decal);
+		DecalInstance *decal = decal_instance_owner.get_or_null(p_decal);
 		return decal->transform;
 	}
 
 	virtual RID lightmap_instance_create(RID p_lightmap) override;
 	virtual void lightmap_instance_set_transform(RID p_lightmap, const Transform3D &p_transform) override;
 	_FORCE_INLINE_ bool lightmap_instance_is_valid(RID p_lightmap_instance) {
-		return lightmap_instance_owner.getornull(p_lightmap_instance) != nullptr;
+		return lightmap_instance_owner.get_or_null(p_lightmap_instance) != nullptr;
 	}
 
 	_FORCE_INLINE_ RID lightmap_instance_get_lightmap(RID p_lightmap_instance) {
-		LightmapInstance *li = lightmap_instance_owner.getornull(p_lightmap_instance);
+		LightmapInstance *li = lightmap_instance_owner.get_or_null(p_lightmap_instance);
 		return li->lightmap;
 	}
 	_FORCE_INLINE_ Transform3D lightmap_instance_get_transform(RID p_lightmap_instance) {
-		LightmapInstance *li = lightmap_instance_owner.getornull(p_lightmap_instance);
+		LightmapInstance *li = lightmap_instance_owner.get_or_null(p_lightmap_instance);
 		return li->transform;
 	}
 
diff --git a/servers/rendering/renderer_rd/renderer_scene_sky_rd.cpp b/servers/rendering/renderer_rd/renderer_scene_sky_rd.cpp
index c388da755c..14a4111038 100644
--- a/servers/rendering/renderer_rd/renderer_scene_sky_rd.cpp
+++ b/servers/rendering/renderer_rd/renderer_scene_sky_rd.cpp
@@ -1772,7 +1772,7 @@ void RendererSceneSkyRD::initialize_sky_rid(RID p_rid) {
 }
 
 RendererSceneSkyRD::Sky *RendererSceneSkyRD::get_sky(RID p_sky) const {
-	return sky_owner.getornull(p_sky);
+	return sky_owner.get_or_null(p_sky);
 }
 
 void RendererSceneSkyRD::free_sky(RID p_sky) {
diff --git a/servers/rendering/renderer_rd/renderer_storage_rd.cpp b/servers/rendering/renderer_rd/renderer_storage_rd.cpp
index ed87932762..a0751d3689 100644
--- a/servers/rendering/renderer_rd/renderer_storage_rd.cpp
+++ b/servers/rendering/renderer_rd/renderer_storage_rd.cpp
@@ -842,7 +842,7 @@ void RendererStorageRD::texture_3d_initialize(RID p_texture, Image::Format p_for
 }
 
 void RendererStorageRD::texture_proxy_initialize(RID p_texture, RID p_base) {
-	Texture *tex = texture_owner.getornull(p_base);
+	Texture *tex = texture_owner.get_or_null(p_base);
 	ERR_FAIL_COND(!tex);
 	Texture proxy_tex = *tex;
 
@@ -865,7 +865,7 @@ void RendererStorageRD::texture_proxy_initialize(RID p_texture, RID p_base) {
 void RendererStorageRD::_texture_2d_update(RID p_texture, const Ref<Image> &p_image, int p_layer, bool p_immediate) {
 	ERR_FAIL_COND(p_image.is_null() || p_image->is_empty());
 
-	Texture *tex = texture_owner.getornull(p_texture);
+	Texture *tex = texture_owner.get_or_null(p_texture);
 	ERR_FAIL_COND(!tex);
 	ERR_FAIL_COND(tex->is_render_target);
 	ERR_FAIL_COND(p_image->get_width() != tex->width || p_image->get_height() != tex->height);
@@ -889,7 +889,7 @@ void RendererStorageRD::texture_2d_update(RID p_texture, const Ref<Image> &p_ima
 }
 
 void RendererStorageRD::texture_3d_update(RID p_texture, const Vector<Ref<Image>> &p_data) {
-	Texture *tex = texture_owner.getornull(p_texture);
+	Texture *tex = texture_owner.get_or_null(p_texture);
 	ERR_FAIL_COND(!tex);
 	ERR_FAIL_COND(tex->type != Texture::TYPE_3D);
 	Image::Image3DValidateError verr = Image::validate_3d_image(tex->format, tex->width, tex->height, tex->depth, tex->mipmaps > 1, p_data);
@@ -926,10 +926,10 @@ void RendererStorageRD::texture_3d_update(RID p_texture, const Vector<Ref<Image>
 }
 
 void RendererStorageRD::texture_proxy_update(RID p_texture, RID p_proxy_to) {
-	Texture *tex = texture_owner.getornull(p_texture);
+	Texture *tex = texture_owner.get_or_null(p_texture);
 	ERR_FAIL_COND(!tex);
 	ERR_FAIL_COND(!tex->is_proxy);
-	Texture *proxy_to = texture_owner.getornull(p_proxy_to);
+	Texture *proxy_to = texture_owner.get_or_null(p_proxy_to);
 	ERR_FAIL_COND(!proxy_to);
 	ERR_FAIL_COND(proxy_to->is_proxy);
 
@@ -943,7 +943,7 @@ void RendererStorageRD::texture_proxy_update(RID p_texture, RID p_proxy_to) {
 			RD::get_singleton()->free(tex->rd_texture_srgb);
 			tex->rd_texture_srgb = RID();
 		}
-		Texture *prev_tex = texture_owner.getornull(tex->proxy_to);
+		Texture *prev_tex = texture_owner.get_or_null(tex->proxy_to);
 		ERR_FAIL_COND(!prev_tex);
 		prev_tex->proxies.erase(p_texture);
 	}
@@ -1030,7 +1030,7 @@ void RendererStorageRD::texture_3d_placeholder_initialize(RID p_texture) {
 }
 
 Ref<Image> RendererStorageRD::texture_2d_get(RID p_texture) const {
-	Texture *tex = texture_owner.getornull(p_texture);
+	Texture *tex = texture_owner.get_or_null(p_texture);
 	ERR_FAIL_COND_V(!tex, Ref<Image>());
 
 #ifdef TOOLS_ENABLED
@@ -1058,7 +1058,7 @@ Ref<Image> RendererStorageRD::texture_2d_get(RID p_texture) const {
 }
 
 Ref<Image> RendererStorageRD::texture_2d_layer_get(RID p_texture, int p_layer) const {
-	Texture *tex = texture_owner.getornull(p_texture);
+	Texture *tex = texture_owner.get_or_null(p_texture);
 	ERR_FAIL_COND_V(!tex, Ref<Image>());
 
 	Vector<uint8_t> data = RD::get_singleton()->texture_get_data(tex->rd_texture, p_layer);
@@ -1075,7 +1075,7 @@ Ref<Image> RendererStorageRD::texture_2d_layer_get(RID p_texture, int p_layer) c
 }
 
 Vector<Ref<Image>> RendererStorageRD::texture_3d_get(RID p_texture) const {
-	Texture *tex = texture_owner.getornull(p_texture);
+	Texture *tex = texture_owner.get_or_null(p_texture);
 	ERR_FAIL_COND_V(!tex, Vector<Ref<Image>>());
 	ERR_FAIL_COND_V(tex->type != Texture::TYPE_3D, Vector<Ref<Image>>());
 
@@ -1106,10 +1106,10 @@ Vector<Ref<Image>> RendererStorageRD::texture_3d_get(RID p_texture) const {
 }
 
 void RendererStorageRD::texture_replace(RID p_texture, RID p_by_texture) {
-	Texture *tex = texture_owner.getornull(p_texture);
+	Texture *tex = texture_owner.get_or_null(p_texture);
 	ERR_FAIL_COND(!tex);
 	ERR_FAIL_COND(tex->proxy_to.is_valid()); //can't replace proxy
-	Texture *by_tex = texture_owner.getornull(p_by_texture);
+	Texture *by_tex = texture_owner.get_or_null(p_by_texture);
 	ERR_FAIL_COND(!by_tex);
 	ERR_FAIL_COND(by_tex->proxy_to.is_valid()); //can't replace proxy
 
@@ -1155,7 +1155,7 @@ void RendererStorageRD::texture_replace(RID p_texture, RID p_by_texture) {
 }
 
 void RendererStorageRD::texture_set_size_override(RID p_texture, int p_width, int p_height) {
-	Texture *tex = texture_owner.getornull(p_texture);
+	Texture *tex = texture_owner.get_or_null(p_texture);
 	ERR_FAIL_COND(!tex);
 	ERR_FAIL_COND(tex->type != Texture::TYPE_2D);
 	tex->width_2d = p_width;
@@ -1163,7 +1163,7 @@ void RendererStorageRD::texture_set_size_override(RID p_texture, int p_width, in
 }
 
 void RendererStorageRD::texture_set_path(RID p_texture, const String &p_path) {
-	Texture *tex = texture_owner.getornull(p_texture);
+	Texture *tex = texture_owner.get_or_null(p_texture);
 	ERR_FAIL_COND(!tex);
 	tex->path = p_path;
 }
@@ -1173,21 +1173,21 @@ String RendererStorageRD::texture_get_path(RID p_texture) const {
 }
 
 void RendererStorageRD::texture_set_detect_3d_callback(RID p_texture, RS::TextureDetectCallback p_callback, void *p_userdata) {
-	Texture *tex = texture_owner.getornull(p_texture);
+	Texture *tex = texture_owner.get_or_null(p_texture);
 	ERR_FAIL_COND(!tex);
 	tex->detect_3d_callback_ud = p_userdata;
 	tex->detect_3d_callback = p_callback;
 }
 
 void RendererStorageRD::texture_set_detect_normal_callback(RID p_texture, RS::TextureDetectCallback p_callback, void *p_userdata) {
-	Texture *tex = texture_owner.getornull(p_texture);
+	Texture *tex = texture_owner.get_or_null(p_texture);
 	ERR_FAIL_COND(!tex);
 	tex->detect_normal_callback_ud = p_userdata;
 	tex->detect_normal_callback = p_callback;
 }
 
 void RendererStorageRD::texture_set_detect_roughness_callback(RID p_texture, RS::TextureDetectRoughnessCallback p_callback, void *p_userdata) {
-	Texture *tex = texture_owner.getornull(p_texture);
+	Texture *tex = texture_owner.get_or_null(p_texture);
 	ERR_FAIL_COND(!tex);
 	tex->detect_roughness_callback_ud = p_userdata;
 	tex->detect_roughness_callback = p_callback;
@@ -1235,7 +1235,7 @@ void RendererStorageRD::canvas_texture_initialize(RID p_rid) {
 }
 
 void RendererStorageRD::canvas_texture_set_channel(RID p_canvas_texture, RS::CanvasTextureChannel p_channel, RID p_texture) {
-	CanvasTexture *ct = canvas_texture_owner.getornull(p_canvas_texture);
+	CanvasTexture *ct = canvas_texture_owner.get_or_null(p_canvas_texture);
 	switch (p_channel) {
 		case RS::CANVAS_TEXTURE_CHANNEL_DIFFUSE: {
 			ct->diffuse = p_texture;
@@ -1252,7 +1252,7 @@ void RendererStorageRD::canvas_texture_set_channel(RID p_canvas_texture, RS::Can
 }
 
 void RendererStorageRD::canvas_texture_set_shading_parameters(RID p_canvas_texture, const Color &p_specular_color, float p_shininess) {
-	CanvasTexture *ct = canvas_texture_owner.getornull(p_canvas_texture);
+	CanvasTexture *ct = canvas_texture_owner.get_or_null(p_canvas_texture);
 	ct->specular_color.r = p_specular_color.r;
 	ct->specular_color.g = p_specular_color.g;
 	ct->specular_color.b = p_specular_color.b;
@@ -1261,13 +1261,13 @@ void RendererStorageRD::canvas_texture_set_shading_parameters(RID p_canvas_textu
 }
 
 void RendererStorageRD::canvas_texture_set_texture_filter(RID p_canvas_texture, RS::CanvasItemTextureFilter p_filter) {
-	CanvasTexture *ct = canvas_texture_owner.getornull(p_canvas_texture);
+	CanvasTexture *ct = canvas_texture_owner.get_or_null(p_canvas_texture);
 	ct->texture_filter = p_filter;
 	ct->clear_sets();
 }
 
 void RendererStorageRD::canvas_texture_set_texture_repeat(RID p_canvas_texture, RS::CanvasItemTextureRepeat p_repeat) {
-	CanvasTexture *ct = canvas_texture_owner.getornull(p_canvas_texture);
+	CanvasTexture *ct = canvas_texture_owner.get_or_null(p_canvas_texture);
 	ct->texture_repeat = p_repeat;
 	ct->clear_sets();
 }
@@ -1275,7 +1275,7 @@ void RendererStorageRD::canvas_texture_set_texture_repeat(RID p_canvas_texture,
 bool RendererStorageRD::canvas_texture_get_uniform_set(RID p_texture, RS::CanvasItemTextureFilter p_base_filter, RS::CanvasItemTextureRepeat p_base_repeat, RID p_base_shader, int p_base_set, RID &r_uniform_set, Size2i &r_size, Color &r_specular_shininess, bool &r_use_normal, bool &r_use_specular) {
 	CanvasTexture *ct = nullptr;
 
-	Texture *t = texture_owner.getornull(p_texture);
+	Texture *t = texture_owner.get_or_null(p_texture);
 
 	if (t) {
 		//regular texture
@@ -1286,7 +1286,7 @@ bool RendererStorageRD::canvas_texture_get_uniform_set(RID p_texture, RS::Canvas
 
 		ct = t->canvas_texture;
 	} else {
-		ct = canvas_texture_owner.getornull(p_texture);
+		ct = canvas_texture_owner.get_or_null(p_texture);
 	}
 
 	if (!ct) {
@@ -1308,7 +1308,7 @@ bool RendererStorageRD::canvas_texture_get_uniform_set(RID p_texture, RS::Canvas
 			u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 			u.binding = 0;
 
-			t = texture_owner.getornull(ct->diffuse);
+			t = texture_owner.get_or_null(ct->diffuse);
 			if (!t) {
 				u.ids.push_back(texture_rd_get_default(DEFAULT_RD_TEXTURE_WHITE));
 				ct->size_cache = Size2i(1, 1);
@@ -1323,7 +1323,7 @@ bool RendererStorageRD::canvas_texture_get_uniform_set(RID p_texture, RS::Canvas
 			u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 			u.binding = 1;
 
-			t = texture_owner.getornull(ct->normal_map);
+			t = texture_owner.get_or_null(ct->normal_map);
 			if (!t) {
 				u.ids.push_back(texture_rd_get_default(DEFAULT_RD_TEXTURE_NORMAL));
 				ct->use_normal_cache = false;
@@ -1338,7 +1338,7 @@ bool RendererStorageRD::canvas_texture_get_uniform_set(RID p_texture, RS::Canvas
 			u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 			u.binding = 2;
 
-			t = texture_owner.getornull(ct->specular);
+			t = texture_owner.get_or_null(ct->specular);
 			if (!t) {
 				u.ids.push_back(texture_rd_get_default(DEFAULT_RD_TEXTURE_WHITE));
 				ct->use_specular_cache = false;
@@ -1384,7 +1384,7 @@ void RendererStorageRD::shader_initialize(RID p_rid) {
 }
 
 void RendererStorageRD::shader_set_code(RID p_shader, const String &p_code) {
-	Shader *shader = shader_owner.getornull(p_shader);
+	Shader *shader = shader_owner.get_or_null(p_shader);
 	ERR_FAIL_COND(!shader);
 
 	shader->code = p_code;
@@ -1456,13 +1456,13 @@ void RendererStorageRD::shader_set_code(RID p_shader, const String &p_code) {
 }
 
 String RendererStorageRD::shader_get_code(RID p_shader) const {
-	Shader *shader = shader_owner.getornull(p_shader);
+	Shader *shader = shader_owner.get_or_null(p_shader);
 	ERR_FAIL_COND_V(!shader, String());
 	return shader->code;
 }
 
 void RendererStorageRD::shader_get_param_list(RID p_shader, List<PropertyInfo> *p_param_list) const {
-	Shader *shader = shader_owner.getornull(p_shader);
+	Shader *shader = shader_owner.get_or_null(p_shader);
 	ERR_FAIL_COND(!shader);
 	if (shader->data) {
 		return shader->data->get_param_list(p_param_list);
@@ -1470,7 +1470,7 @@ void RendererStorageRD::shader_get_param_list(RID p_shader, List<PropertyInfo> *
 }
 
 void RendererStorageRD::shader_set_default_texture_param(RID p_shader, const StringName &p_name, RID p_texture) {
-	Shader *shader = shader_owner.getornull(p_shader);
+	Shader *shader = shader_owner.get_or_null(p_shader);
 	ERR_FAIL_COND(!shader);
 
 	if (p_texture.is_valid() && texture_owner.owns(p_texture)) {
@@ -1488,7 +1488,7 @@ void RendererStorageRD::shader_set_default_texture_param(RID p_shader, const Str
 }
 
 RID RendererStorageRD::shader_get_default_texture_param(RID p_shader, const StringName &p_name) const {
-	Shader *shader = shader_owner.getornull(p_shader);
+	Shader *shader = shader_owner.get_or_null(p_shader);
 	ERR_FAIL_COND_V(!shader, RID());
 	if (shader->default_texture_parameter.has(p_name)) {
 		return shader->default_texture_parameter[p_name];
@@ -1498,7 +1498,7 @@ RID RendererStorageRD::shader_get_default_texture_param(RID p_shader, const Stri
 }
 
 Variant RendererStorageRD::shader_get_param_default(RID p_shader, const StringName &p_param) const {
-	Shader *shader = shader_owner.getornull(p_shader);
+	Shader *shader = shader_owner.get_or_null(p_shader);
 	ERR_FAIL_COND_V(!shader, Variant());
 	if (shader->data) {
 		return shader->data->get_default_parameter(p_param);
@@ -1512,7 +1512,7 @@ void RendererStorageRD::shader_set_data_request_function(ShaderType p_shader_typ
 }
 
 RS::ShaderNativeSourceCode RendererStorageRD::shader_get_native_source_code(RID p_shader) const {
-	Shader *shader = shader_owner.getornull(p_shader);
+	Shader *shader = shader_owner.get_or_null(p_shader);
 	ERR_FAIL_COND_V(!shader, RS::ShaderNativeSourceCode());
 	if (shader->data) {
 		return shader->data->get_native_source_code();
@@ -1527,7 +1527,7 @@ RID RendererStorageRD::material_allocate() {
 }
 void RendererStorageRD::material_initialize(RID p_rid) {
 	material_owner.initialize_rid(p_rid);
-	Material *material = material_owner.getornull(p_rid);
+	Material *material = material_owner.get_or_null(p_rid);
 	material->self = p_rid;
 }
 
@@ -1543,7 +1543,7 @@ void RendererStorageRD::_material_queue_update(Material *material, bool p_unifor
 }
 
 void RendererStorageRD::material_set_shader(RID p_material, RID p_shader) {
-	Material *material = material_owner.getornull(p_material);
+	Material *material = material_owner.get_or_null(p_material);
 	ERR_FAIL_COND(!material);
 
 	if (material->data) {
@@ -1563,7 +1563,7 @@ void RendererStorageRD::material_set_shader(RID p_material, RID p_shader) {
 		return;
 	}
 
-	Shader *shader = shader_owner.getornull(p_shader);
+	Shader *shader = shader_owner.get_or_null(p_shader);
 	ERR_FAIL_COND(!shader);
 	material->shader = shader;
 	material->shader_type = shader->type;
@@ -1586,7 +1586,7 @@ void RendererStorageRD::material_set_shader(RID p_material, RID p_shader) {
 }
 
 void RendererStorageRD::material_set_param(RID p_material, const StringName &p_param, const Variant &p_value) {
-	Material *material = material_owner.getornull(p_material);
+	Material *material = material_owner.get_or_null(p_material);
 	ERR_FAIL_COND(!material);
 
 	if (p_value.get_type() == Variant::NIL) {
@@ -1605,7 +1605,7 @@ void RendererStorageRD::material_set_param(RID p_material, const StringName &p_p
 }
 
 Variant RendererStorageRD::material_get_param(RID p_material, const StringName &p_param) const {
-	Material *material = material_owner.getornull(p_material);
+	Material *material = material_owner.get_or_null(p_material);
 	ERR_FAIL_COND_V(!material, Variant());
 	if (material->params.has(p_param)) {
 		return material->params[p_param];
@@ -1615,7 +1615,7 @@ Variant RendererStorageRD::material_get_param(RID p_material, const StringName &
 }
 
 void RendererStorageRD::material_set_next_pass(RID p_material, RID p_next_material) {
-	Material *material = material_owner.getornull(p_material);
+	Material *material = material_owner.get_or_null(p_material);
 	ERR_FAIL_COND(!material);
 
 	if (material->next_pass == p_next_material) {
@@ -1631,7 +1631,7 @@ void RendererStorageRD::material_set_next_pass(RID p_material, RID p_next_materi
 }
 
 void RendererStorageRD::material_set_render_priority(RID p_material, int priority) {
-	Material *material = material_owner.getornull(p_material);
+	Material *material = material_owner.get_or_null(p_material);
 	ERR_FAIL_COND(!material);
 	material->priority = priority;
 	if (material->data) {
@@ -1640,7 +1640,7 @@ void RendererStorageRD::material_set_render_priority(RID p_material, int priorit
 }
 
 bool RendererStorageRD::material_is_animated(RID p_material) {
-	Material *material = material_owner.getornull(p_material);
+	Material *material = material_owner.get_or_null(p_material);
 	ERR_FAIL_COND_V(!material, false);
 	if (material->shader && material->shader->data) {
 		if (material->shader->data->is_animated()) {
@@ -1653,7 +1653,7 @@ bool RendererStorageRD::material_is_animated(RID p_material) {
 }
 
 bool RendererStorageRD::material_casts_shadows(RID p_material) {
-	Material *material = material_owner.getornull(p_material);
+	Material *material = material_owner.get_or_null(p_material);
 	ERR_FAIL_COND_V(!material, true);
 	if (material->shader && material->shader->data) {
 		if (material->shader->data->casts_shadows()) {
@@ -1666,7 +1666,7 @@ bool RendererStorageRD::material_casts_shadows(RID p_material) {
 }
 
 void RendererStorageRD::material_get_instance_shader_parameters(RID p_material, List<InstanceShaderParam> *r_parameters) {
-	Material *material = material_owner.getornull(p_material);
+	Material *material = material_owner.get_or_null(p_material);
 	ERR_FAIL_COND(!material);
 	if (material->shader && material->shader->data) {
 		material->shader->data->get_instance_param_list(r_parameters);
@@ -1678,7 +1678,7 @@ void RendererStorageRD::material_get_instance_shader_parameters(RID p_material,
 }
 
 void RendererStorageRD::material_update_dependency(RID p_material, DependencyTracker *p_instance) {
-	Material *material = material_owner.getornull(p_material);
+	Material *material = material_owner.get_or_null(p_material);
 	ERR_FAIL_COND(!material);
 	p_instance->update_dependency(&material->dependency);
 	if (material->next_pass.is_valid()) {
@@ -2309,7 +2309,7 @@ void RendererStorageRD::MaterialData::update_textures(const Map<StringName, Vari
 		} else {
 			bool srgb = p_use_linear_color && (p_texture_uniforms[i].hint == ShaderLanguage::ShaderNode::Uniform::HINT_ALBEDO || p_texture_uniforms[i].hint == ShaderLanguage::ShaderNode::Uniform::HINT_BLACK_ALBEDO);
 
-			Texture *tex = singleton->texture_owner.getornull(texture);
+			Texture *tex = singleton->texture_owner.get_or_null(texture);
 
 			if (tex) {
 				rd_texture = (srgb && tex->rd_texture_srgb.is_valid()) ? tex->rd_texture_srgb : tex->rd_texture;
@@ -2470,14 +2470,14 @@ bool RendererStorageRD::MaterialData::update_parameters_uniform_set(const Map<St
 
 void RendererStorageRD::_material_uniform_set_erased(const RID &p_set, void *p_material) {
 	RID rid = *(RID *)p_material;
-	Material *material = base_singleton->material_owner.getornull(rid);
+	Material *material = base_singleton->material_owner.get_or_null(rid);
 	if (material) {
 		material->dependency.changed_notify(DEPENDENCY_CHANGED_MATERIAL);
 	}
 }
 
 void RendererStorageRD::material_force_update_textures(RID p_material, ShaderType p_shader_type) {
-	Material *material = material_owner.getornull(p_material);
+	Material *material = material_owner.get_or_null(p_material);
 	if (material->shader_type != p_shader_type) {
 		return;
 	}
@@ -2518,7 +2518,7 @@ void RendererStorageRD::mesh_initialize(RID p_rid) {
 void RendererStorageRD::mesh_set_blend_shape_count(RID p_mesh, int p_blend_shape_count) {
 	ERR_FAIL_COND(p_blend_shape_count < 0);
 
-	Mesh *mesh = mesh_owner.getornull(p_mesh);
+	Mesh *mesh = mesh_owner.get_or_null(p_mesh);
 	ERR_FAIL_COND(!mesh);
 
 	ERR_FAIL_COND(mesh->surface_count > 0); //surfaces already exist
@@ -2528,7 +2528,7 @@ void RendererStorageRD::mesh_set_blend_shape_count(RID p_mesh, int p_blend_shape
 
 /// Returns stride
 void RendererStorageRD::mesh_add_surface(RID p_mesh, const RS::SurfaceData &p_surface) {
-	Mesh *mesh = mesh_owner.getornull(p_mesh);
+	Mesh *mesh = mesh_owner.get_or_null(p_mesh);
 	ERR_FAIL_COND(!mesh);
 
 	ERR_FAIL_COND(mesh->surface_count == RS::MAX_MESH_SURFACES);
@@ -2732,13 +2732,13 @@ void RendererStorageRD::mesh_add_surface(RID p_mesh, const RS::SurfaceData &p_su
 }
 
 int RendererStorageRD::mesh_get_blend_shape_count(RID p_mesh) const {
-	const Mesh *mesh = mesh_owner.getornull(p_mesh);
+	const Mesh *mesh = mesh_owner.get_or_null(p_mesh);
 	ERR_FAIL_COND_V(!mesh, -1);
 	return mesh->blend_shape_count;
 }
 
 void RendererStorageRD::mesh_set_blend_shape_mode(RID p_mesh, RS::BlendShapeMode p_mode) {
-	Mesh *mesh = mesh_owner.getornull(p_mesh);
+	Mesh *mesh = mesh_owner.get_or_null(p_mesh);
 	ERR_FAIL_COND(!mesh);
 	ERR_FAIL_INDEX((int)p_mode, 2);
 
@@ -2746,13 +2746,13 @@ void RendererStorageRD::mesh_set_blend_shape_mode(RID p_mesh, RS::BlendShapeMode
 }
 
 RS::BlendShapeMode RendererStorageRD::mesh_get_blend_shape_mode(RID p_mesh) const {
-	Mesh *mesh = mesh_owner.getornull(p_mesh);
+	Mesh *mesh = mesh_owner.get_or_null(p_mesh);
 	ERR_FAIL_COND_V(!mesh, RS::BLEND_SHAPE_MODE_NORMALIZED);
 	return mesh->blend_shape_mode;
 }
 
 void RendererStorageRD::mesh_surface_update_vertex_region(RID p_mesh, int p_surface, int p_offset, const Vector<uint8_t> &p_data) {
-	Mesh *mesh = mesh_owner.getornull(p_mesh);
+	Mesh *mesh = mesh_owner.get_or_null(p_mesh);
 	ERR_FAIL_COND(!mesh);
 	ERR_FAIL_UNSIGNED_INDEX((uint32_t)p_surface, mesh->surface_count);
 	ERR_FAIL_COND(p_data.size() == 0);
@@ -2763,7 +2763,7 @@ void RendererStorageRD::mesh_surface_update_vertex_region(RID p_mesh, int p_surf
 }
 
 void RendererStorageRD::mesh_surface_update_attribute_region(RID p_mesh, int p_surface, int p_offset, const Vector<uint8_t> &p_data) {
-	Mesh *mesh = mesh_owner.getornull(p_mesh);
+	Mesh *mesh = mesh_owner.get_or_null(p_mesh);
 	ERR_FAIL_COND(!mesh);
 	ERR_FAIL_UNSIGNED_INDEX((uint32_t)p_surface, mesh->surface_count);
 	ERR_FAIL_COND(p_data.size() == 0);
@@ -2775,7 +2775,7 @@ void RendererStorageRD::mesh_surface_update_attribute_region(RID p_mesh, int p_s
 }
 
 void RendererStorageRD::mesh_surface_update_skin_region(RID p_mesh, int p_surface, int p_offset, const Vector<uint8_t> &p_data) {
-	Mesh *mesh = mesh_owner.getornull(p_mesh);
+	Mesh *mesh = mesh_owner.get_or_null(p_mesh);
 	ERR_FAIL_COND(!mesh);
 	ERR_FAIL_UNSIGNED_INDEX((uint32_t)p_surface, mesh->surface_count);
 	ERR_FAIL_COND(p_data.size() == 0);
@@ -2787,7 +2787,7 @@ void RendererStorageRD::mesh_surface_update_skin_region(RID p_mesh, int p_surfac
 }
 
 void RendererStorageRD::mesh_surface_set_material(RID p_mesh, int p_surface, RID p_material) {
-	Mesh *mesh = mesh_owner.getornull(p_mesh);
+	Mesh *mesh = mesh_owner.get_or_null(p_mesh);
 	ERR_FAIL_COND(!mesh);
 	ERR_FAIL_UNSIGNED_INDEX((uint32_t)p_surface, mesh->surface_count);
 	mesh->surfaces[p_surface]->material = p_material;
@@ -2797,7 +2797,7 @@ void RendererStorageRD::mesh_surface_set_material(RID p_mesh, int p_surface, RID
 }
 
 RID RendererStorageRD::mesh_surface_get_material(RID p_mesh, int p_surface) const {
-	Mesh *mesh = mesh_owner.getornull(p_mesh);
+	Mesh *mesh = mesh_owner.get_or_null(p_mesh);
 	ERR_FAIL_COND_V(!mesh, RID());
 	ERR_FAIL_UNSIGNED_INDEX_V((uint32_t)p_surface, mesh->surface_count, RID());
 
@@ -2805,7 +2805,7 @@ RID RendererStorageRD::mesh_surface_get_material(RID p_mesh, int p_surface) cons
 }
 
 RS::SurfaceData RendererStorageRD::mesh_get_surface(RID p_mesh, int p_surface) const {
-	Mesh *mesh = mesh_owner.getornull(p_mesh);
+	Mesh *mesh = mesh_owner.get_or_null(p_mesh);
 	ERR_FAIL_COND_V(!mesh, RS::SurfaceData());
 	ERR_FAIL_UNSIGNED_INDEX_V((uint32_t)p_surface, mesh->surface_count, RS::SurfaceData());
 
@@ -2845,32 +2845,32 @@ RS::SurfaceData RendererStorageRD::mesh_get_surface(RID p_mesh, int p_surface) c
 }
 
 int RendererStorageRD::mesh_get_surface_count(RID p_mesh) const {
-	Mesh *mesh = mesh_owner.getornull(p_mesh);
+	Mesh *mesh = mesh_owner.get_or_null(p_mesh);
 	ERR_FAIL_COND_V(!mesh, 0);
 	return mesh->surface_count;
 }
 
 void RendererStorageRD::mesh_set_custom_aabb(RID p_mesh, const AABB &p_aabb) {
-	Mesh *mesh = mesh_owner.getornull(p_mesh);
+	Mesh *mesh = mesh_owner.get_or_null(p_mesh);
 	ERR_FAIL_COND(!mesh);
 	mesh->custom_aabb = p_aabb;
 }
 
 AABB RendererStorageRD::mesh_get_custom_aabb(RID p_mesh) const {
-	Mesh *mesh = mesh_owner.getornull(p_mesh);
+	Mesh *mesh = mesh_owner.get_or_null(p_mesh);
 	ERR_FAIL_COND_V(!mesh, AABB());
 	return mesh->custom_aabb;
 }
 
 AABB RendererStorageRD::mesh_get_aabb(RID p_mesh, RID p_skeleton) {
-	Mesh *mesh = mesh_owner.getornull(p_mesh);
+	Mesh *mesh = mesh_owner.get_or_null(p_mesh);
 	ERR_FAIL_COND_V(!mesh, AABB());
 
 	if (mesh->custom_aabb != AABB()) {
 		return mesh->custom_aabb;
 	}
 
-	Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);
+	Skeleton *skeleton = skeleton_owner.get_or_null(p_skeleton);
 
 	if (!skeleton || skeleton->size == 0) {
 		return mesh->aabb;
@@ -2968,16 +2968,16 @@ AABB RendererStorageRD::mesh_get_aabb(RID p_mesh, RID p_skeleton) {
 }
 
 void RendererStorageRD::mesh_set_shadow_mesh(RID p_mesh, RID p_shadow_mesh) {
-	Mesh *mesh = mesh_owner.getornull(p_mesh);
+	Mesh *mesh = mesh_owner.get_or_null(p_mesh);
 	ERR_FAIL_COND(!mesh);
 
-	Mesh *shadow_mesh = mesh_owner.getornull(mesh->shadow_mesh);
+	Mesh *shadow_mesh = mesh_owner.get_or_null(mesh->shadow_mesh);
 	if (shadow_mesh) {
 		shadow_mesh->shadow_owners.erase(mesh);
 	}
 	mesh->shadow_mesh = p_shadow_mesh;
 
-	shadow_mesh = mesh_owner.getornull(mesh->shadow_mesh);
+	shadow_mesh = mesh_owner.get_or_null(mesh->shadow_mesh);
 
 	if (shadow_mesh) {
 		shadow_mesh->shadow_owners.insert(mesh);
@@ -2987,7 +2987,7 @@ void RendererStorageRD::mesh_set_shadow_mesh(RID p_mesh, RID p_shadow_mesh) {
 }
 
 void RendererStorageRD::mesh_clear(RID p_mesh) {
-	Mesh *mesh = mesh_owner.getornull(p_mesh);
+	Mesh *mesh = mesh_owner.get_or_null(p_mesh);
 	ERR_FAIL_COND(!mesh);
 	for (uint32_t i = 0; i < mesh->surface_count; i++) {
 		Mesh::Surface &s = *mesh->surfaces[i];
@@ -3041,7 +3041,7 @@ void RendererStorageRD::mesh_clear(RID p_mesh) {
 }
 
 bool RendererStorageRD::mesh_needs_instance(RID p_mesh, bool p_has_skeleton) {
-	Mesh *mesh = mesh_owner.getornull(p_mesh);
+	Mesh *mesh = mesh_owner.get_or_null(p_mesh);
 	ERR_FAIL_COND_V(!mesh, false);
 
 	return mesh->blend_shape_count > 0 || (mesh->has_bone_weights && p_has_skeleton);
@@ -3050,11 +3050,11 @@ bool RendererStorageRD::mesh_needs_instance(RID p_mesh, bool p_has_skeleton) {
 /* MESH INSTANCE */
 
 RID RendererStorageRD::mesh_instance_create(RID p_base) {
-	Mesh *mesh = mesh_owner.getornull(p_base);
+	Mesh *mesh = mesh_owner.get_or_null(p_base);
 	ERR_FAIL_COND_V(!mesh, RID());
 
 	RID rid = mesh_instance_owner.make_rid();
-	MeshInstance *mi = mesh_instance_owner.getornull(rid);
+	MeshInstance *mi = mesh_instance_owner.get_or_null(rid);
 
 	mi->mesh = mesh;
 
@@ -3069,7 +3069,7 @@ RID RendererStorageRD::mesh_instance_create(RID p_base) {
 	return rid;
 }
 void RendererStorageRD::mesh_instance_set_skeleton(RID p_mesh_instance, RID p_skeleton) {
-	MeshInstance *mi = mesh_instance_owner.getornull(p_mesh_instance);
+	MeshInstance *mi = mesh_instance_owner.get_or_null(p_mesh_instance);
 	if (mi->skeleton == p_skeleton) {
 		return;
 	}
@@ -3079,7 +3079,7 @@ void RendererStorageRD::mesh_instance_set_skeleton(RID p_mesh_instance, RID p_sk
 }
 
 void RendererStorageRD::mesh_instance_set_blend_shape_weight(RID p_mesh_instance, int p_shape, float p_weight) {
-	MeshInstance *mi = mesh_instance_owner.getornull(p_mesh_instance);
+	MeshInstance *mi = mesh_instance_owner.get_or_null(p_mesh_instance);
 	ERR_FAIL_COND(!mi);
 	ERR_FAIL_INDEX(p_shape, (int)mi->blend_weights.size());
 	mi->blend_weights[p_shape] = p_weight;
@@ -3151,7 +3151,7 @@ void RendererStorageRD::_mesh_instance_add_surface(MeshInstance *mi, Mesh *mesh,
 }
 
 void RendererStorageRD::mesh_instance_check_for_update(RID p_mesh_instance) {
-	MeshInstance *mi = mesh_instance_owner.getornull(p_mesh_instance);
+	MeshInstance *mi = mesh_instance_owner.get_or_null(p_mesh_instance);
 
 	bool needs_update = mi->dirty;
 
@@ -3165,7 +3165,7 @@ void RendererStorageRD::mesh_instance_check_for_update(RID p_mesh_instance) {
 	}
 
 	if (!needs_update && mi->skeleton.is_valid()) {
-		Skeleton *sk = skeleton_owner.getornull(mi->skeleton);
+		Skeleton *sk = skeleton_owner.get_or_null(mi->skeleton);
 		if (sk && sk->version != mi->skeleton_version) {
 			needs_update = true;
 		}
@@ -3196,7 +3196,7 @@ void RendererStorageRD::update_mesh_instances() {
 	while (dirty_mesh_instance_arrays.first()) {
 		MeshInstance *mi = dirty_mesh_instance_arrays.first()->self();
 
-		Skeleton *sk = skeleton_owner.getornull(mi->skeleton);
+		Skeleton *sk = skeleton_owner.get_or_null(mi->skeleton);
 
 		for (uint32_t i = 0; i < mi->surfaces.size(); i++) {
 			if (mi->surfaces[i].uniform_set == RID() || mi->mesh->surfaces[i]->uniform_set == RID()) {
@@ -3443,7 +3443,7 @@ void RendererStorageRD::multimesh_initialize(RID p_rid) {
 }
 
 void RendererStorageRD::multimesh_allocate_data(RID p_multimesh, int p_instances, RS::MultimeshTransformFormat p_transform_format, bool p_use_colors, bool p_use_custom_data) {
-	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
+	MultiMesh *multimesh = multimesh_owner.get_or_null(p_multimesh);
 	ERR_FAIL_COND(!multimesh);
 
 	if (multimesh->instances == p_instances && multimesh->xform_format == p_transform_format && multimesh->uses_colors == p_use_colors && multimesh->uses_custom_data == p_use_custom_data) {
@@ -3486,13 +3486,13 @@ void RendererStorageRD::multimesh_allocate_data(RID p_multimesh, int p_instances
 }
 
 int RendererStorageRD::multimesh_get_instance_count(RID p_multimesh) const {
-	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
+	MultiMesh *multimesh = multimesh_owner.get_or_null(p_multimesh);
 	ERR_FAIL_COND_V(!multimesh, 0);
 	return multimesh->instances;
 }
 
 void RendererStorageRD::multimesh_set_mesh(RID p_multimesh, RID p_mesh) {
-	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
+	MultiMesh *multimesh = multimesh_owner.get_or_null(p_multimesh);
 	ERR_FAIL_COND(!multimesh);
 	if (multimesh->mesh == p_mesh) {
 		return;
@@ -3638,7 +3638,7 @@ void RendererStorageRD::_multimesh_re_create_aabb(MultiMesh *multimesh, const fl
 }
 
 void RendererStorageRD::multimesh_instance_set_transform(RID p_multimesh, int p_index, const Transform3D &p_transform) {
-	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
+	MultiMesh *multimesh = multimesh_owner.get_or_null(p_multimesh);
 	ERR_FAIL_COND(!multimesh);
 	ERR_FAIL_INDEX(p_index, multimesh->instances);
 	ERR_FAIL_COND(multimesh->xform_format != RS::MULTIMESH_TRANSFORM_3D);
@@ -3668,7 +3668,7 @@ void RendererStorageRD::multimesh_instance_set_transform(RID p_multimesh, int p_
 }
 
 void RendererStorageRD::multimesh_instance_set_transform_2d(RID p_multimesh, int p_index, const Transform2D &p_transform) {
-	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
+	MultiMesh *multimesh = multimesh_owner.get_or_null(p_multimesh);
 	ERR_FAIL_COND(!multimesh);
 	ERR_FAIL_INDEX(p_index, multimesh->instances);
 	ERR_FAIL_COND(multimesh->xform_format != RS::MULTIMESH_TRANSFORM_2D);
@@ -3694,7 +3694,7 @@ void RendererStorageRD::multimesh_instance_set_transform_2d(RID p_multimesh, int
 }
 
 void RendererStorageRD::multimesh_instance_set_color(RID p_multimesh, int p_index, const Color &p_color) {
-	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
+	MultiMesh *multimesh = multimesh_owner.get_or_null(p_multimesh);
 	ERR_FAIL_COND(!multimesh);
 	ERR_FAIL_INDEX(p_index, multimesh->instances);
 	ERR_FAIL_COND(!multimesh->uses_colors);
@@ -3716,7 +3716,7 @@ void RendererStorageRD::multimesh_instance_set_color(RID p_multimesh, int p_inde
 }
 
 void RendererStorageRD::multimesh_instance_set_custom_data(RID p_multimesh, int p_index, const Color &p_color) {
-	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
+	MultiMesh *multimesh = multimesh_owner.get_or_null(p_multimesh);
 	ERR_FAIL_COND(!multimesh);
 	ERR_FAIL_INDEX(p_index, multimesh->instances);
 	ERR_FAIL_COND(!multimesh->uses_custom_data);
@@ -3738,14 +3738,14 @@ void RendererStorageRD::multimesh_instance_set_custom_data(RID p_multimesh, int
 }
 
 RID RendererStorageRD::multimesh_get_mesh(RID p_multimesh) const {
-	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
+	MultiMesh *multimesh = multimesh_owner.get_or_null(p_multimesh);
 	ERR_FAIL_COND_V(!multimesh, RID());
 
 	return multimesh->mesh;
 }
 
 Transform3D RendererStorageRD::multimesh_instance_get_transform(RID p_multimesh, int p_index) const {
-	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
+	MultiMesh *multimesh = multimesh_owner.get_or_null(p_multimesh);
 	ERR_FAIL_COND_V(!multimesh, Transform3D());
 	ERR_FAIL_INDEX_V(p_index, multimesh->instances, Transform3D());
 	ERR_FAIL_COND_V(multimesh->xform_format != RS::MULTIMESH_TRANSFORM_3D, Transform3D());
@@ -3776,7 +3776,7 @@ Transform3D RendererStorageRD::multimesh_instance_get_transform(RID p_multimesh,
 }
 
 Transform2D RendererStorageRD::multimesh_instance_get_transform_2d(RID p_multimesh, int p_index) const {
-	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
+	MultiMesh *multimesh = multimesh_owner.get_or_null(p_multimesh);
 	ERR_FAIL_COND_V(!multimesh, Transform2D());
 	ERR_FAIL_INDEX_V(p_index, multimesh->instances, Transform2D());
 	ERR_FAIL_COND_V(multimesh->xform_format != RS::MULTIMESH_TRANSFORM_2D, Transform2D());
@@ -3801,7 +3801,7 @@ Transform2D RendererStorageRD::multimesh_instance_get_transform_2d(RID p_multime
 }
 
 Color RendererStorageRD::multimesh_instance_get_color(RID p_multimesh, int p_index) const {
-	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
+	MultiMesh *multimesh = multimesh_owner.get_or_null(p_multimesh);
 	ERR_FAIL_COND_V(!multimesh, Color());
 	ERR_FAIL_INDEX_V(p_index, multimesh->instances, Color());
 	ERR_FAIL_COND_V(!multimesh->uses_colors, Color());
@@ -3824,7 +3824,7 @@ Color RendererStorageRD::multimesh_instance_get_color(RID p_multimesh, int p_ind
 }
 
 Color RendererStorageRD::multimesh_instance_get_custom_data(RID p_multimesh, int p_index) const {
-	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
+	MultiMesh *multimesh = multimesh_owner.get_or_null(p_multimesh);
 	ERR_FAIL_COND_V(!multimesh, Color());
 	ERR_FAIL_INDEX_V(p_index, multimesh->instances, Color());
 	ERR_FAIL_COND_V(!multimesh->uses_custom_data, Color());
@@ -3847,7 +3847,7 @@ Color RendererStorageRD::multimesh_instance_get_custom_data(RID p_multimesh, int
 }
 
 void RendererStorageRD::multimesh_set_buffer(RID p_multimesh, const Vector<float> &p_buffer) {
-	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
+	MultiMesh *multimesh = multimesh_owner.get_or_null(p_multimesh);
 	ERR_FAIL_COND(!multimesh);
 	ERR_FAIL_COND(p_buffer.size() != (multimesh->instances * (int)multimesh->stride_cache));
 
@@ -3880,7 +3880,7 @@ void RendererStorageRD::multimesh_set_buffer(RID p_multimesh, const Vector<float
 }
 
 Vector<float> RendererStorageRD::multimesh_get_buffer(RID p_multimesh) const {
-	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
+	MultiMesh *multimesh = multimesh_owner.get_or_null(p_multimesh);
 	ERR_FAIL_COND_V(!multimesh, Vector<float>());
 	if (multimesh->buffer.is_null()) {
 		return Vector<float>();
@@ -3903,7 +3903,7 @@ Vector<float> RendererStorageRD::multimesh_get_buffer(RID p_multimesh) const {
 }
 
 void RendererStorageRD::multimesh_set_visible_instances(RID p_multimesh, int p_visible) {
-	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
+	MultiMesh *multimesh = multimesh_owner.get_or_null(p_multimesh);
 	ERR_FAIL_COND(!multimesh);
 	ERR_FAIL_COND(p_visible < -1 || p_visible > multimesh->instances);
 	if (multimesh->visible_instances == p_visible) {
@@ -3921,13 +3921,13 @@ void RendererStorageRD::multimesh_set_visible_instances(RID p_multimesh, int p_v
 }
 
 int RendererStorageRD::multimesh_get_visible_instances(RID p_multimesh) const {
-	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
+	MultiMesh *multimesh = multimesh_owner.get_or_null(p_multimesh);
 	ERR_FAIL_COND_V(!multimesh, 0);
 	return multimesh->visible_instances;
 }
 
 AABB RendererStorageRD::multimesh_get_aabb(RID p_multimesh) const {
-	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
+	MultiMesh *multimesh = multimesh_owner.get_or_null(p_multimesh);
 	ERR_FAIL_COND_V(!multimesh, AABB());
 	if (multimesh->aabb_dirty) {
 		const_cast<RendererStorageRD *>(this)->_update_dirty_multimeshes();
@@ -3998,7 +3998,7 @@ void RendererStorageRD::particles_initialize(RID p_rid) {
 }
 
 void RendererStorageRD::particles_set_mode(RID p_particles, RS::ParticlesMode p_mode) {
-	Particles *particles = particles_owner.getornull(p_particles);
+	Particles *particles = particles_owner.get_or_null(p_particles);
 	ERR_FAIL_COND(!particles);
 	if (particles->mode == p_mode) {
 		return;
@@ -4010,7 +4010,7 @@ void RendererStorageRD::particles_set_mode(RID p_particles, RS::ParticlesMode p_
 }
 
 void RendererStorageRD::particles_set_emitting(RID p_particles, bool p_emitting) {
-	Particles *particles = particles_owner.getornull(p_particles);
+	Particles *particles = particles_owner.get_or_null(p_particles);
 	ERR_FAIL_COND(!particles);
 
 	particles->emitting = p_emitting;
@@ -4018,7 +4018,7 @@ void RendererStorageRD::particles_set_emitting(RID p_particles, bool p_emitting)
 
 bool RendererStorageRD::particles_get_emitting(RID p_particles) {
 	ERR_FAIL_COND_V_MSG(RSG::threaded, false, "This function should never be used with threaded rendering, as it stalls the renderer.");
-	Particles *particles = particles_owner.getornull(p_particles);
+	Particles *particles = particles_owner.get_or_null(p_particles);
 	ERR_FAIL_COND_V(!particles, false);
 
 	return particles->emitting;
@@ -4073,7 +4073,7 @@ void RendererStorageRD::_particles_free_data(Particles *particles) {
 }
 
 void RendererStorageRD::particles_set_amount(RID p_particles, int p_amount) {
-	Particles *particles = particles_owner.getornull(p_particles);
+	Particles *particles = particles_owner.get_or_null(p_particles);
 	ERR_FAIL_COND(!particles);
 
 	if (particles->amount == p_amount) {
@@ -4093,48 +4093,48 @@ void RendererStorageRD::particles_set_amount(RID p_particles, int p_amount) {
 }
 
 void RendererStorageRD::particles_set_lifetime(RID p_particles, double p_lifetime) {
-	Particles *particles = particles_owner.getornull(p_particles);
+	Particles *particles = particles_owner.get_or_null(p_particles);
 	ERR_FAIL_COND(!particles);
 	particles->lifetime = p_lifetime;
 }
 
 void RendererStorageRD::particles_set_one_shot(RID p_particles, bool p_one_shot) {
-	Particles *particles = particles_owner.getornull(p_particles);
+	Particles *particles = particles_owner.get_or_null(p_particles);
 	ERR_FAIL_COND(!particles);
 	particles->one_shot = p_one_shot;
 }
 
 void RendererStorageRD::particles_set_pre_process_time(RID p_particles, double p_time) {
-	Particles *particles = particles_owner.getornull(p_particles);
+	Particles *particles = particles_owner.get_or_null(p_particles);
 	ERR_FAIL_COND(!particles);
 	particles->pre_process_time = p_time;
 }
 void RendererStorageRD::particles_set_explosiveness_ratio(RID p_particles, real_t p_ratio) {
-	Particles *particles = particles_owner.getornull(p_particles);
+	Particles *particles = particles_owner.get_or_null(p_particles);
 	ERR_FAIL_COND(!particles);
 	particles->explosiveness = p_ratio;
 }
 void RendererStorageRD::particles_set_randomness_ratio(RID p_particles, real_t p_ratio) {
-	Particles *particles = particles_owner.getornull(p_particles);
+	Particles *particles = particles_owner.get_or_null(p_particles);
 	ERR_FAIL_COND(!particles);
 	particles->randomness = p_ratio;
 }
 
 void RendererStorageRD::particles_set_custom_aabb(RID p_particles, const AABB &p_aabb) {
-	Particles *particles = particles_owner.getornull(p_particles);
+	Particles *particles = particles_owner.get_or_null(p_particles);
 	ERR_FAIL_COND(!particles);
 	particles->custom_aabb = p_aabb;
 	particles->dependency.changed_notify(DEPENDENCY_CHANGED_AABB);
 }
 
 void RendererStorageRD::particles_set_speed_scale(RID p_particles, double p_scale) {
-	Particles *particles = particles_owner.getornull(p_particles);
+	Particles *particles = particles_owner.get_or_null(p_particles);
 	ERR_FAIL_COND(!particles);
 
 	particles->speed_scale = p_scale;
 }
 void RendererStorageRD::particles_set_use_local_coordinates(RID p_particles, bool p_enable) {
-	Particles *particles = particles_owner.getornull(p_particles);
+	Particles *particles = particles_owner.get_or_null(p_particles);
 	ERR_FAIL_COND(!particles);
 
 	particles->use_local_coords = p_enable;
@@ -4142,7 +4142,7 @@ void RendererStorageRD::particles_set_use_local_coordinates(RID p_particles, boo
 }
 
 void RendererStorageRD::particles_set_fixed_fps(RID p_particles, int p_fps) {
-	Particles *particles = particles_owner.getornull(p_particles);
+	Particles *particles = particles_owner.get_or_null(p_particles);
 	ERR_FAIL_COND(!particles);
 
 	particles->fixed_fps = p_fps;
@@ -4158,21 +4158,21 @@ void RendererStorageRD::particles_set_fixed_fps(RID p_particles, int p_fps) {
 }
 
 void RendererStorageRD::particles_set_interpolate(RID p_particles, bool p_enable) {
-	Particles *particles = particles_owner.getornull(p_particles);
+	Particles *particles = particles_owner.get_or_null(p_particles);
 	ERR_FAIL_COND(!particles);
 
 	particles->interpolate = p_enable;
 }
 
 void RendererStorageRD::particles_set_fractional_delta(RID p_particles, bool p_enable) {
-	Particles *particles = particles_owner.getornull(p_particles);
+	Particles *particles = particles_owner.get_or_null(p_particles);
 	ERR_FAIL_COND(!particles);
 
 	particles->fractional_delta = p_enable;
 }
 
 void RendererStorageRD::particles_set_trails(RID p_particles, bool p_enable, double p_length) {
-	Particles *particles = particles_owner.getornull(p_particles);
+	Particles *particles = particles_owner.get_or_null(p_particles);
 	ERR_FAIL_COND(!particles);
 	ERR_FAIL_COND(p_length < 0.1);
 	p_length = MIN(10.0, p_length);
@@ -4191,7 +4191,7 @@ void RendererStorageRD::particles_set_trails(RID p_particles, bool p_enable, dou
 }
 
 void RendererStorageRD::particles_set_trail_bind_poses(RID p_particles, const Vector<Transform3D> &p_bind_poses) {
-	Particles *particles = particles_owner.getornull(p_particles);
+	Particles *particles = particles_owner.get_or_null(p_particles);
 	ERR_FAIL_COND(!particles);
 	if (particles->trail_bind_pose_buffer.is_valid() && particles->trail_bind_poses.size() != p_bind_poses.size()) {
 		_particles_free_data(particles);
@@ -4208,49 +4208,49 @@ void RendererStorageRD::particles_set_trail_bind_poses(RID p_particles, const Ve
 }
 
 void RendererStorageRD::particles_set_collision_base_size(RID p_particles, real_t p_size) {
-	Particles *particles = particles_owner.getornull(p_particles);
+	Particles *particles = particles_owner.get_or_null(p_particles);
 	ERR_FAIL_COND(!particles);
 
 	particles->collision_base_size = p_size;
 }
 
 void RendererStorageRD::particles_set_transform_align(RID p_particles, RS::ParticlesTransformAlign p_transform_align) {
-	Particles *particles = particles_owner.getornull(p_particles);
+	Particles *particles = particles_owner.get_or_null(p_particles);
 	ERR_FAIL_COND(!particles);
 
 	particles->transform_align = p_transform_align;
 }
 
 void RendererStorageRD::particles_set_process_material(RID p_particles, RID p_material) {
-	Particles *particles = particles_owner.getornull(p_particles);
+	Particles *particles = particles_owner.get_or_null(p_particles);
 	ERR_FAIL_COND(!particles);
 
 	particles->process_material = p_material;
 }
 
 void RendererStorageRD::particles_set_draw_order(RID p_particles, RS::ParticlesDrawOrder p_order) {
-	Particles *particles = particles_owner.getornull(p_particles);
+	Particles *particles = particles_owner.get_or_null(p_particles);
 	ERR_FAIL_COND(!particles);
 
 	particles->draw_order = p_order;
 }
 
 void RendererStorageRD::particles_set_draw_passes(RID p_particles, int p_passes) {
-	Particles *particles = particles_owner.getornull(p_particles);
+	Particles *particles = particles_owner.get_or_null(p_particles);
 	ERR_FAIL_COND(!particles);
 
 	particles->draw_passes.resize(p_passes);
 }
 
 void RendererStorageRD::particles_set_draw_pass_mesh(RID p_particles, int p_pass, RID p_mesh) {
-	Particles *particles = particles_owner.getornull(p_particles);
+	Particles *particles = particles_owner.get_or_null(p_particles);
 	ERR_FAIL_COND(!particles);
 	ERR_FAIL_INDEX(p_pass, particles->draw_passes.size());
 	particles->draw_passes.write[p_pass] = p_mesh;
 }
 
 void RendererStorageRD::particles_restart(RID p_particles) {
-	Particles *particles = particles_owner.getornull(p_particles);
+	Particles *particles = particles_owner.get_or_null(p_particles);
 	ERR_FAIL_COND(!particles);
 
 	particles->restart_request = true;
@@ -4274,7 +4274,7 @@ void RendererStorageRD::_particles_allocate_emission_buffer(Particles *particles
 }
 
 void RendererStorageRD::particles_set_subemitter(RID p_particles, RID p_subemitter_particles) {
-	Particles *particles = particles_owner.getornull(p_particles);
+	Particles *particles = particles_owner.get_or_null(p_particles);
 	ERR_FAIL_COND(!particles);
 	ERR_FAIL_COND(p_particles == p_subemitter_particles);
 
@@ -4287,7 +4287,7 @@ void RendererStorageRD::particles_set_subemitter(RID p_particles, RID p_subemitt
 }
 
 void RendererStorageRD::particles_emit(RID p_particles, const Transform3D &p_transform, const Vector3 &p_velocity, const Color &p_color, const Color &p_custom, uint32_t p_emit_flags) {
-	Particles *particles = particles_owner.getornull(p_particles);
+	Particles *particles = particles_owner.get_or_null(p_particles);
 	ERR_FAIL_COND(!particles);
 	ERR_FAIL_COND(particles->amount == 0);
 
@@ -4330,7 +4330,7 @@ void RendererStorageRD::particles_emit(RID p_particles, const Transform3D &p_tra
 }
 
 void RendererStorageRD::particles_request_process(RID p_particles) {
-	Particles *particles = particles_owner.getornull(p_particles);
+	Particles *particles = particles_owner.get_or_null(p_particles);
 	ERR_FAIL_COND(!particles);
 
 	if (!particles->dirty) {
@@ -4345,7 +4345,7 @@ AABB RendererStorageRD::particles_get_current_aabb(RID p_particles) {
 		WARN_PRINT_ONCE("Calling this function with threaded rendering enabled stalls the renderer, use with care.");
 	}
 
-	const Particles *particles = particles_owner.getornull(p_particles);
+	const Particles *particles = particles_owner.get_or_null(p_particles);
 	ERR_FAIL_COND_V(!particles, AABB());
 
 	int total_amount = particles->amount;
@@ -4393,28 +4393,28 @@ AABB RendererStorageRD::particles_get_current_aabb(RID p_particles) {
 }
 
 AABB RendererStorageRD::particles_get_aabb(RID p_particles) const {
-	const Particles *particles = particles_owner.getornull(p_particles);
+	const Particles *particles = particles_owner.get_or_null(p_particles);
 	ERR_FAIL_COND_V(!particles, AABB());
 
 	return particles->custom_aabb;
 }
 
 void RendererStorageRD::particles_set_emission_transform(RID p_particles, const Transform3D &p_transform) {
-	Particles *particles = particles_owner.getornull(p_particles);
+	Particles *particles = particles_owner.get_or_null(p_particles);
 	ERR_FAIL_COND(!particles);
 
 	particles->emission_transform = p_transform;
 }
 
 int RendererStorageRD::particles_get_draw_passes(RID p_particles) const {
-	const Particles *particles = particles_owner.getornull(p_particles);
+	const Particles *particles = particles_owner.get_or_null(p_particles);
 	ERR_FAIL_COND_V(!particles, 0);
 
 	return particles->draw_passes.size();
 }
 
 RID RendererStorageRD::particles_get_draw_pass_mesh(RID p_particles, int p_pass) const {
-	const Particles *particles = particles_owner.getornull(p_particles);
+	const Particles *particles = particles_owner.get_or_null(p_particles);
 	ERR_FAIL_COND_V(!particles, RID());
 	ERR_FAIL_INDEX_V(p_pass, particles->draw_passes.size(), RID());
 
@@ -4422,19 +4422,19 @@ RID RendererStorageRD::particles_get_draw_pass_mesh(RID p_particles, int p_pass)
 }
 
 void RendererStorageRD::particles_add_collision(RID p_particles, RID p_particles_collision_instance) {
-	Particles *particles = particles_owner.getornull(p_particles);
+	Particles *particles = particles_owner.get_or_null(p_particles);
 	ERR_FAIL_COND(!particles);
 	particles->collisions.insert(p_particles_collision_instance);
 }
 
 void RendererStorageRD::particles_remove_collision(RID p_particles, RID p_particles_collision_instance) {
-	Particles *particles = particles_owner.getornull(p_particles);
+	Particles *particles = particles_owner.get_or_null(p_particles);
 	ERR_FAIL_COND(!particles);
 	particles->collisions.erase(p_particles_collision_instance);
 }
 
 void RendererStorageRD::particles_set_canvas_sdf_collision(RID p_particles, bool p_enable, const Transform2D &p_xform, const Rect2 &p_to_screen, RID p_texture) {
-	Particles *particles = particles_owner.getornull(p_particles);
+	Particles *particles = particles_owner.get_or_null(p_particles);
 	ERR_FAIL_COND(!particles);
 	particles->has_sdf_collision = p_enable;
 	particles->sdf_collision_transform = p_xform;
@@ -4476,7 +4476,7 @@ void RendererStorageRD::_particles_process(Particles *p_particles, double p_delt
 			RD::Uniform u;
 			u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
 			u.binding = 3;
-			Particles *sub_emitter = particles_owner.getornull(p_particles->sub_emitter);
+			Particles *sub_emitter = particles_owner.get_or_null(p_particles->sub_emitter);
 			if (sub_emitter) {
 				if (sub_emitter->emission_buffer == nullptr) { //no emission buffer, allocate emission buffer
 					_particles_allocate_emission_buffer(sub_emitter);
@@ -4593,11 +4593,11 @@ void RendererStorageRD::_particles_process(Particles *p_particles, double p_delt
 
 		uint32_t collision_3d_textures_used = 0;
 		for (const Set<RID>::Element *E = p_particles->collisions.front(); E; E = E->next()) {
-			ParticlesCollisionInstance *pci = particles_collision_instance_owner.getornull(E->get());
+			ParticlesCollisionInstance *pci = particles_collision_instance_owner.get_or_null(E->get());
 			if (!pci || !pci->active) {
 				continue;
 			}
-			ParticlesCollision *pc = particles_collision_owner.getornull(pci->collision);
+			ParticlesCollision *pc = particles_collision_owner.get_or_null(pci->collision);
 			ERR_CONTINUE(!pc);
 
 			Transform3D to_collider = pci->transform;
@@ -4745,7 +4745,7 @@ void RendererStorageRD::_particles_process(Particles *p_particles, double p_delt
 				for (uint32_t i = 0; i < ParticlesFrameParams::MAX_3D_TEXTURES; i++) {
 					RID rd_tex;
 					if (i < collision_3d_textures_used) {
-						Texture *t = texture_owner.getornull(collision_3d_textures[i]);
+						Texture *t = texture_owner.get_or_null(collision_3d_textures[i]);
 						if (t && t->type == Texture::TYPE_3D) {
 							rd_tex = t->rd_texture;
 						}
@@ -4790,7 +4790,7 @@ void RendererStorageRD::_particles_process(Particles *p_particles, double p_delt
 
 	p_particles->force_sub_emit = false; //reset
 
-	Particles *sub_emitter = particles_owner.getornull(p_particles->sub_emitter);
+	Particles *sub_emitter = particles_owner.get_or_null(p_particles->sub_emitter);
 
 	if (sub_emitter && sub_emitter->emission_storage_buffer.is_valid()) {
 		//	print_line("updating subemitter buffer");
@@ -4870,7 +4870,7 @@ void RendererStorageRD::_particles_process(Particles *p_particles, double p_delt
 }
 
 void RendererStorageRD::particles_set_view_axis(RID p_particles, const Vector3 &p_axis, const Vector3 &p_up_axis) {
-	Particles *particles = particles_owner.getornull(p_particles);
+	Particles *particles = particles_owner.get_or_null(p_particles);
 	ERR_FAIL_COND(!particles);
 
 	if (particles->draw_order != RS::PARTICLES_DRAW_ORDER_VIEW_DEPTH && particles->transform_align != RS::PARTICLES_TRANSFORM_ALIGN_Z_BILLBOARD && particles->transform_align != RS::PARTICLES_TRANSFORM_ALIGN_Z_BILLBOARD_Y_TO_VELOCITY) {
@@ -5228,7 +5228,7 @@ void RendererStorageRD::update_particles() {
 
 bool RendererStorageRD::particles_is_inactive(RID p_particles) const {
 	ERR_FAIL_COND_V_MSG(RSG::threaded, false, "This function should never be used with threaded rendering, as it stalls the renderer.");
-	const Particles *particles = particles_owner.getornull(p_particles);
+	const Particles *particles = particles_owner.get_or_null(p_particles);
 	ERR_FAIL_COND_V(!particles, false);
 	return !particles->emitting && particles->inactive;
 }
@@ -5406,7 +5406,7 @@ void RendererStorageRD::particles_collision_initialize(RID p_rid) {
 }
 
 RID RendererStorageRD::particles_collision_get_heightfield_framebuffer(RID p_particles_collision) const {
-	ParticlesCollision *particles_collision = particles_collision_owner.getornull(p_particles_collision);
+	ParticlesCollision *particles_collision = particles_collision_owner.get_or_null(p_particles_collision);
 	ERR_FAIL_COND_V(!particles_collision, RID());
 	ERR_FAIL_COND_V(particles_collision->type != RS::PARTICLES_COLLISION_TYPE_HEIGHTFIELD_COLLIDE, RID());
 
@@ -5441,7 +5441,7 @@ RID RendererStorageRD::particles_collision_get_heightfield_framebuffer(RID p_par
 }
 
 void RendererStorageRD::particles_collision_set_collision_type(RID p_particles_collision, RS::ParticlesCollisionType p_type) {
-	ParticlesCollision *particles_collision = particles_collision_owner.getornull(p_particles_collision);
+	ParticlesCollision *particles_collision = particles_collision_owner.get_or_null(p_particles_collision);
 	ERR_FAIL_COND(!particles_collision);
 
 	if (p_type == particles_collision->type) {
@@ -5457,13 +5457,13 @@ void RendererStorageRD::particles_collision_set_collision_type(RID p_particles_c
 }
 
 void RendererStorageRD::particles_collision_set_cull_mask(RID p_particles_collision, uint32_t p_cull_mask) {
-	ParticlesCollision *particles_collision = particles_collision_owner.getornull(p_particles_collision);
+	ParticlesCollision *particles_collision = particles_collision_owner.get_or_null(p_particles_collision);
 	ERR_FAIL_COND(!particles_collision);
 	particles_collision->cull_mask = p_cull_mask;
 }
 
 void RendererStorageRD::particles_collision_set_sphere_radius(RID p_particles_collision, real_t p_radius) {
-	ParticlesCollision *particles_collision = particles_collision_owner.getornull(p_particles_collision);
+	ParticlesCollision *particles_collision = particles_collision_owner.get_or_null(p_particles_collision);
 	ERR_FAIL_COND(!particles_collision);
 
 	particles_collision->radius = p_radius;
@@ -5471,7 +5471,7 @@ void RendererStorageRD::particles_collision_set_sphere_radius(RID p_particles_co
 }
 
 void RendererStorageRD::particles_collision_set_box_extents(RID p_particles_collision, const Vector3 &p_extents) {
-	ParticlesCollision *particles_collision = particles_collision_owner.getornull(p_particles_collision);
+	ParticlesCollision *particles_collision = particles_collision_owner.get_or_null(p_particles_collision);
 	ERR_FAIL_COND(!particles_collision);
 
 	particles_collision->extents = p_extents;
@@ -5479,41 +5479,41 @@ void RendererStorageRD::particles_collision_set_box_extents(RID p_particles_coll
 }
 
 void RendererStorageRD::particles_collision_set_attractor_strength(RID p_particles_collision, real_t p_strength) {
-	ParticlesCollision *particles_collision = particles_collision_owner.getornull(p_particles_collision);
+	ParticlesCollision *particles_collision = particles_collision_owner.get_or_null(p_particles_collision);
 	ERR_FAIL_COND(!particles_collision);
 
 	particles_collision->attractor_strength = p_strength;
 }
 
 void RendererStorageRD::particles_collision_set_attractor_directionality(RID p_particles_collision, real_t p_directionality) {
-	ParticlesCollision *particles_collision = particles_collision_owner.getornull(p_particles_collision);
+	ParticlesCollision *particles_collision = particles_collision_owner.get_or_null(p_particles_collision);
 	ERR_FAIL_COND(!particles_collision);
 
 	particles_collision->attractor_directionality = p_directionality;
 }
 
 void RendererStorageRD::particles_collision_set_attractor_attenuation(RID p_particles_collision, real_t p_curve) {
-	ParticlesCollision *particles_collision = particles_collision_owner.getornull(p_particles_collision);
+	ParticlesCollision *particles_collision = particles_collision_owner.get_or_null(p_particles_collision);
 	ERR_FAIL_COND(!particles_collision);
 
 	particles_collision->attractor_attenuation = p_curve;
 }
 
 void RendererStorageRD::particles_collision_set_field_texture(RID p_particles_collision, RID p_texture) {
-	ParticlesCollision *particles_collision = particles_collision_owner.getornull(p_particles_collision);
+	ParticlesCollision *particles_collision = particles_collision_owner.get_or_null(p_particles_collision);
 	ERR_FAIL_COND(!particles_collision);
 
 	particles_collision->field_texture = p_texture;
 }
 
 void RendererStorageRD::particles_collision_height_field_update(RID p_particles_collision) {
-	ParticlesCollision *particles_collision = particles_collision_owner.getornull(p_particles_collision);
+	ParticlesCollision *particles_collision = particles_collision_owner.get_or_null(p_particles_collision);
 	ERR_FAIL_COND(!particles_collision);
 	particles_collision->dependency.changed_notify(DEPENDENCY_CHANGED_AABB);
 }
 
 void RendererStorageRD::particles_collision_set_height_field_resolution(RID p_particles_collision, RS::ParticlesCollisionHeightfieldResolution p_resolution) {
-	ParticlesCollision *particles_collision = particles_collision_owner.getornull(p_particles_collision);
+	ParticlesCollision *particles_collision = particles_collision_owner.get_or_null(p_particles_collision);
 	ERR_FAIL_COND(!particles_collision);
 	ERR_FAIL_INDEX(p_resolution, RS::PARTICLES_COLLISION_HEIGHTFIELD_RESOLUTION_MAX);
 
@@ -5530,7 +5530,7 @@ void RendererStorageRD::particles_collision_set_height_field_resolution(RID p_pa
 }
 
 AABB RendererStorageRD::particles_collision_get_aabb(RID p_particles_collision) const {
-	ParticlesCollision *particles_collision = particles_collision_owner.getornull(p_particles_collision);
+	ParticlesCollision *particles_collision = particles_collision_owner.get_or_null(p_particles_collision);
 	ERR_FAIL_COND_V(!particles_collision, AABB());
 
 	switch (particles_collision->type) {
@@ -5553,13 +5553,13 @@ AABB RendererStorageRD::particles_collision_get_aabb(RID p_particles_collision)
 }
 
 Vector3 RendererStorageRD::particles_collision_get_extents(RID p_particles_collision) const {
-	const ParticlesCollision *particles_collision = particles_collision_owner.getornull(p_particles_collision);
+	const ParticlesCollision *particles_collision = particles_collision_owner.get_or_null(p_particles_collision);
 	ERR_FAIL_COND_V(!particles_collision, Vector3());
 	return particles_collision->extents;
 }
 
 bool RendererStorageRD::particles_collision_is_heightfield(RID p_particles_collision) const {
-	const ParticlesCollision *particles_collision = particles_collision_owner.getornull(p_particles_collision);
+	const ParticlesCollision *particles_collision = particles_collision_owner.get_or_null(p_particles_collision);
 	ERR_FAIL_COND_V(!particles_collision, false);
 	return particles_collision->type == RS::PARTICLES_COLLISION_TYPE_HEIGHTFIELD_COLLIDE;
 }
@@ -5570,12 +5570,12 @@ RID RendererStorageRD::particles_collision_instance_create(RID p_collision) {
 	return particles_collision_instance_owner.make_rid(pci);
 }
 void RendererStorageRD::particles_collision_instance_set_transform(RID p_collision_instance, const Transform3D &p_transform) {
-	ParticlesCollisionInstance *pci = particles_collision_instance_owner.getornull(p_collision_instance);
+	ParticlesCollisionInstance *pci = particles_collision_instance_owner.get_or_null(p_collision_instance);
 	ERR_FAIL_COND(!pci);
 	pci->transform = p_transform;
 }
 void RendererStorageRD::particles_collision_instance_set_active(RID p_collision_instance, bool p_active) {
-	ParticlesCollisionInstance *pci = particles_collision_instance_owner.getornull(p_collision_instance);
+	ParticlesCollisionInstance *pci = particles_collision_instance_owner.get_or_null(p_collision_instance);
 	ERR_FAIL_COND(!pci);
 	pci->active = p_active;
 }
@@ -5589,25 +5589,25 @@ void RendererStorageRD::visibility_notifier_initialize(RID p_notifier) {
 	visibility_notifier_owner.initialize_rid(p_notifier, VisibilityNotifier());
 }
 void RendererStorageRD::visibility_notifier_set_aabb(RID p_notifier, const AABB &p_aabb) {
-	VisibilityNotifier *vn = visibility_notifier_owner.getornull(p_notifier);
+	VisibilityNotifier *vn = visibility_notifier_owner.get_or_null(p_notifier);
 	ERR_FAIL_COND(!vn);
 	vn->aabb = p_aabb;
 	vn->dependency.changed_notify(DEPENDENCY_CHANGED_AABB);
 }
 void RendererStorageRD::visibility_notifier_set_callbacks(RID p_notifier, const Callable &p_enter_callbable, const Callable &p_exit_callable) {
-	VisibilityNotifier *vn = visibility_notifier_owner.getornull(p_notifier);
+	VisibilityNotifier *vn = visibility_notifier_owner.get_or_null(p_notifier);
 	ERR_FAIL_COND(!vn);
 	vn->enter_callback = p_enter_callbable;
 	vn->exit_callback = p_exit_callable;
 }
 
 AABB RendererStorageRD::visibility_notifier_get_aabb(RID p_notifier) const {
-	const VisibilityNotifier *vn = visibility_notifier_owner.getornull(p_notifier);
+	const VisibilityNotifier *vn = visibility_notifier_owner.get_or_null(p_notifier);
 	ERR_FAIL_COND_V(!vn, AABB());
 	return vn->aabb;
 }
 void RendererStorageRD::visibility_notifier_call(RID p_notifier, bool p_enter, bool p_deferred) {
-	VisibilityNotifier *vn = visibility_notifier_owner.getornull(p_notifier);
+	VisibilityNotifier *vn = visibility_notifier_owner.get_or_null(p_notifier);
 	ERR_FAIL_COND(!vn);
 
 	if (p_enter) {
@@ -5651,7 +5651,7 @@ void RendererStorageRD::_skeleton_make_dirty(Skeleton *skeleton) {
 }
 
 void RendererStorageRD::skeleton_allocate_data(RID p_skeleton, int p_bones, bool p_2d_skeleton) {
-	Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);
+	Skeleton *skeleton = skeleton_owner.get_or_null(p_skeleton);
 	ERR_FAIL_COND(!skeleton);
 	ERR_FAIL_COND(p_bones < 0);
 
@@ -5694,14 +5694,14 @@ void RendererStorageRD::skeleton_allocate_data(RID p_skeleton, int p_bones, bool
 }
 
 int RendererStorageRD::skeleton_get_bone_count(RID p_skeleton) const {
-	Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);
+	Skeleton *skeleton = skeleton_owner.get_or_null(p_skeleton);
 	ERR_FAIL_COND_V(!skeleton, 0);
 
 	return skeleton->size;
 }
 
 void RendererStorageRD::skeleton_bone_set_transform(RID p_skeleton, int p_bone, const Transform3D &p_transform) {
-	Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);
+	Skeleton *skeleton = skeleton_owner.get_or_null(p_skeleton);
 
 	ERR_FAIL_COND(!skeleton);
 	ERR_FAIL_INDEX(p_bone, skeleton->size);
@@ -5726,7 +5726,7 @@ void RendererStorageRD::skeleton_bone_set_transform(RID p_skeleton, int p_bone,
 }
 
 Transform3D RendererStorageRD::skeleton_bone_get_transform(RID p_skeleton, int p_bone) const {
-	Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);
+	Skeleton *skeleton = skeleton_owner.get_or_null(p_skeleton);
 
 	ERR_FAIL_COND_V(!skeleton, Transform3D());
 	ERR_FAIL_INDEX_V(p_bone, skeleton->size, Transform3D());
@@ -5753,7 +5753,7 @@ Transform3D RendererStorageRD::skeleton_bone_get_transform(RID p_skeleton, int p
 }
 
 void RendererStorageRD::skeleton_bone_set_transform_2d(RID p_skeleton, int p_bone, const Transform2D &p_transform) {
-	Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);
+	Skeleton *skeleton = skeleton_owner.get_or_null(p_skeleton);
 
 	ERR_FAIL_COND(!skeleton);
 	ERR_FAIL_INDEX(p_bone, skeleton->size);
@@ -5774,7 +5774,7 @@ void RendererStorageRD::skeleton_bone_set_transform_2d(RID p_skeleton, int p_bon
 }
 
 Transform2D RendererStorageRD::skeleton_bone_get_transform_2d(RID p_skeleton, int p_bone) const {
-	Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);
+	Skeleton *skeleton = skeleton_owner.get_or_null(p_skeleton);
 
 	ERR_FAIL_COND_V(!skeleton, Transform2D());
 	ERR_FAIL_INDEX_V(p_bone, skeleton->size, Transform2D());
@@ -5794,7 +5794,7 @@ Transform2D RendererStorageRD::skeleton_bone_get_transform_2d(RID p_skeleton, in
 }
 
 void RendererStorageRD::skeleton_set_base_transform_2d(RID p_skeleton, const Transform2D &p_base_transform) {
-	Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);
+	Skeleton *skeleton = skeleton_owner.get_or_null(p_skeleton);
 
 	ERR_FAIL_COND(!skeleton->use_2d);
 
@@ -5873,14 +5873,14 @@ void RendererStorageRD::spot_light_initialize(RID p_light) {
 }
 
 void RendererStorageRD::light_set_color(RID p_light, const Color &p_color) {
-	Light *light = light_owner.getornull(p_light);
+	Light *light = light_owner.get_or_null(p_light);
 	ERR_FAIL_COND(!light);
 
 	light->color = p_color;
 }
 
 void RendererStorageRD::light_set_param(RID p_light, RS::LightParam p_param, float p_value) {
-	Light *light = light_owner.getornull(p_light);
+	Light *light = light_owner.get_or_null(p_light);
 	ERR_FAIL_COND(!light);
 	ERR_FAIL_INDEX(p_param, RS::LIGHT_PARAM_MAX);
 
@@ -5915,7 +5915,7 @@ void RendererStorageRD::light_set_param(RID p_light, RS::LightParam p_param, flo
 }
 
 void RendererStorageRD::light_set_shadow(RID p_light, bool p_enabled) {
-	Light *light = light_owner.getornull(p_light);
+	Light *light = light_owner.get_or_null(p_light);
 	ERR_FAIL_COND(!light);
 	light->shadow = p_enabled;
 
@@ -5924,13 +5924,13 @@ void RendererStorageRD::light_set_shadow(RID p_light, bool p_enabled) {
 }
 
 void RendererStorageRD::light_set_shadow_color(RID p_light, const Color &p_color) {
-	Light *light = light_owner.getornull(p_light);
+	Light *light = light_owner.get_or_null(p_light);
 	ERR_FAIL_COND(!light);
 	light->shadow_color = p_color;
 }
 
 void RendererStorageRD::light_set_projector(RID p_light, RID p_texture) {
-	Light *light = light_owner.getornull(p_light);
+	Light *light = light_owner.get_or_null(p_light);
 	ERR_FAIL_COND(!light);
 
 	if (light->projector == p_texture) {
@@ -5952,14 +5952,14 @@ void RendererStorageRD::light_set_projector(RID p_light, RID p_texture) {
 }
 
 void RendererStorageRD::light_set_negative(RID p_light, bool p_enable) {
-	Light *light = light_owner.getornull(p_light);
+	Light *light = light_owner.get_or_null(p_light);
 	ERR_FAIL_COND(!light);
 
 	light->negative = p_enable;
 }
 
 void RendererStorageRD::light_set_cull_mask(RID p_light, uint32_t p_mask) {
-	Light *light = light_owner.getornull(p_light);
+	Light *light = light_owner.get_or_null(p_light);
 	ERR_FAIL_COND(!light);
 
 	light->cull_mask = p_mask;
@@ -5969,7 +5969,7 @@ void RendererStorageRD::light_set_cull_mask(RID p_light, uint32_t p_mask) {
 }
 
 void RendererStorageRD::light_set_reverse_cull_face_mode(RID p_light, bool p_enabled) {
-	Light *light = light_owner.getornull(p_light);
+	Light *light = light_owner.get_or_null(p_light);
 	ERR_FAIL_COND(!light);
 
 	light->reverse_cull = p_enabled;
@@ -5979,7 +5979,7 @@ void RendererStorageRD::light_set_reverse_cull_face_mode(RID p_light, bool p_ena
 }
 
 void RendererStorageRD::light_set_bake_mode(RID p_light, RS::LightBakeMode p_bake_mode) {
-	Light *light = light_owner.getornull(p_light);
+	Light *light = light_owner.get_or_null(p_light);
 	ERR_FAIL_COND(!light);
 
 	light->bake_mode = p_bake_mode;
@@ -5989,7 +5989,7 @@ void RendererStorageRD::light_set_bake_mode(RID p_light, RS::LightBakeMode p_bak
 }
 
 void RendererStorageRD::light_set_max_sdfgi_cascade(RID p_light, uint32_t p_cascade) {
-	Light *light = light_owner.getornull(p_light);
+	Light *light = light_owner.get_or_null(p_light);
 	ERR_FAIL_COND(!light);
 
 	light->max_sdfgi_cascade = p_cascade;
@@ -5999,7 +5999,7 @@ void RendererStorageRD::light_set_max_sdfgi_cascade(RID p_light, uint32_t p_casc
 }
 
 void RendererStorageRD::light_omni_set_shadow_mode(RID p_light, RS::LightOmniShadowMode p_mode) {
-	Light *light = light_owner.getornull(p_light);
+	Light *light = light_owner.get_or_null(p_light);
 	ERR_FAIL_COND(!light);
 
 	light->omni_shadow_mode = p_mode;
@@ -6009,14 +6009,14 @@ void RendererStorageRD::light_omni_set_shadow_mode(RID p_light, RS::LightOmniSha
 }
 
 RS::LightOmniShadowMode RendererStorageRD::light_omni_get_shadow_mode(RID p_light) {
-	const Light *light = light_owner.getornull(p_light);
+	const Light *light = light_owner.get_or_null(p_light);
 	ERR_FAIL_COND_V(!light, RS::LIGHT_OMNI_SHADOW_CUBE);
 
 	return light->omni_shadow_mode;
 }
 
 void RendererStorageRD::light_directional_set_shadow_mode(RID p_light, RS::LightDirectionalShadowMode p_mode) {
-	Light *light = light_owner.getornull(p_light);
+	Light *light = light_owner.get_or_null(p_light);
 	ERR_FAIL_COND(!light);
 
 	light->directional_shadow_mode = p_mode;
@@ -6025,7 +6025,7 @@ void RendererStorageRD::light_directional_set_shadow_mode(RID p_light, RS::Light
 }
 
 void RendererStorageRD::light_directional_set_blend_splits(RID p_light, bool p_enable) {
-	Light *light = light_owner.getornull(p_light);
+	Light *light = light_owner.get_or_null(p_light);
 	ERR_FAIL_COND(!light);
 
 	light->directional_blend_splits = p_enable;
@@ -6034,56 +6034,56 @@ void RendererStorageRD::light_directional_set_blend_splits(RID p_light, bool p_e
 }
 
 bool RendererStorageRD::light_directional_get_blend_splits(RID p_light) const {
-	const Light *light = light_owner.getornull(p_light);
+	const Light *light = light_owner.get_or_null(p_light);
 	ERR_FAIL_COND_V(!light, false);
 
 	return light->directional_blend_splits;
 }
 
 void RendererStorageRD::light_directional_set_sky_only(RID p_light, bool p_sky_only) {
-	Light *light = light_owner.getornull(p_light);
+	Light *light = light_owner.get_or_null(p_light);
 	ERR_FAIL_COND(!light);
 
 	light->directional_sky_only = p_sky_only;
 }
 
 bool RendererStorageRD::light_directional_is_sky_only(RID p_light) const {
-	const Light *light = light_owner.getornull(p_light);
+	const Light *light = light_owner.get_or_null(p_light);
 	ERR_FAIL_COND_V(!light, false);
 
 	return light->directional_sky_only;
 }
 
 RS::LightDirectionalShadowMode RendererStorageRD::light_directional_get_shadow_mode(RID p_light) {
-	const Light *light = light_owner.getornull(p_light);
+	const Light *light = light_owner.get_or_null(p_light);
 	ERR_FAIL_COND_V(!light, RS::LIGHT_DIRECTIONAL_SHADOW_ORTHOGONAL);
 
 	return light->directional_shadow_mode;
 }
 
 uint32_t RendererStorageRD::light_get_max_sdfgi_cascade(RID p_light) {
-	const Light *light = light_owner.getornull(p_light);
+	const Light *light = light_owner.get_or_null(p_light);
 	ERR_FAIL_COND_V(!light, 0);
 
 	return light->max_sdfgi_cascade;
 }
 
 RS::LightBakeMode RendererStorageRD::light_get_bake_mode(RID p_light) {
-	const Light *light = light_owner.getornull(p_light);
+	const Light *light = light_owner.get_or_null(p_light);
 	ERR_FAIL_COND_V(!light, RS::LIGHT_BAKE_DISABLED);
 
 	return light->bake_mode;
 }
 
 uint64_t RendererStorageRD::light_get_version(RID p_light) const {
-	const Light *light = light_owner.getornull(p_light);
+	const Light *light = light_owner.get_or_null(p_light);
 	ERR_FAIL_COND_V(!light, 0);
 
 	return light->version;
 }
 
 AABB RendererStorageRD::light_get_aabb(RID p_light) const {
-	const Light *light = light_owner.getornull(p_light);
+	const Light *light = light_owner.get_or_null(p_light);
 	ERR_FAIL_COND_V(!light, AABB());
 
 	switch (light->type) {
@@ -6114,7 +6114,7 @@ void RendererStorageRD::reflection_probe_initialize(RID p_reflection_probe) {
 }
 
 void RendererStorageRD::reflection_probe_set_update_mode(RID p_probe, RS::ReflectionProbeUpdateMode p_mode) {
-	ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
+	ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe);
 	ERR_FAIL_COND(!reflection_probe);
 
 	reflection_probe->update_mode = p_mode;
@@ -6122,35 +6122,35 @@ void RendererStorageRD::reflection_probe_set_update_mode(RID p_probe, RS::Reflec
 }
 
 void RendererStorageRD::reflection_probe_set_intensity(RID p_probe, float p_intensity) {
-	ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
+	ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe);
 	ERR_FAIL_COND(!reflection_probe);
 
 	reflection_probe->intensity = p_intensity;
 }
 
 void RendererStorageRD::reflection_probe_set_ambient_mode(RID p_probe, RS::ReflectionProbeAmbientMode p_mode) {
-	ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
+	ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe);
 	ERR_FAIL_COND(!reflection_probe);
 
 	reflection_probe->ambient_mode = p_mode;
 }
 
 void RendererStorageRD::reflection_probe_set_ambient_color(RID p_probe, const Color &p_color) {
-	ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
+	ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe);
 	ERR_FAIL_COND(!reflection_probe);
 
 	reflection_probe->ambient_color = p_color;
 }
 
 void RendererStorageRD::reflection_probe_set_ambient_energy(RID p_probe, float p_energy) {
-	ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
+	ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe);
 	ERR_FAIL_COND(!reflection_probe);
 
 	reflection_probe->ambient_color_energy = p_energy;
 }
 
 void RendererStorageRD::reflection_probe_set_max_distance(RID p_probe, float p_distance) {
-	ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
+	ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe);
 	ERR_FAIL_COND(!reflection_probe);
 
 	reflection_probe->max_distance = p_distance;
@@ -6159,7 +6159,7 @@ void RendererStorageRD::reflection_probe_set_max_distance(RID p_probe, float p_d
 }
 
 void RendererStorageRD::reflection_probe_set_extents(RID p_probe, const Vector3 &p_extents) {
-	ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
+	ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe);
 	ERR_FAIL_COND(!reflection_probe);
 
 	if (reflection_probe->extents == p_extents) {
@@ -6170,7 +6170,7 @@ void RendererStorageRD::reflection_probe_set_extents(RID p_probe, const Vector3
 }
 
 void RendererStorageRD::reflection_probe_set_origin_offset(RID p_probe, const Vector3 &p_offset) {
-	ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
+	ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe);
 	ERR_FAIL_COND(!reflection_probe);
 
 	reflection_probe->origin_offset = p_offset;
@@ -6178,7 +6178,7 @@ void RendererStorageRD::reflection_probe_set_origin_offset(RID p_probe, const Ve
 }
 
 void RendererStorageRD::reflection_probe_set_as_interior(RID p_probe, bool p_enable) {
-	ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
+	ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe);
 	ERR_FAIL_COND(!reflection_probe);
 
 	reflection_probe->interior = p_enable;
@@ -6186,14 +6186,14 @@ void RendererStorageRD::reflection_probe_set_as_interior(RID p_probe, bool p_ena
 }
 
 void RendererStorageRD::reflection_probe_set_enable_box_projection(RID p_probe, bool p_enable) {
-	ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
+	ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe);
 	ERR_FAIL_COND(!reflection_probe);
 
 	reflection_probe->box_projection = p_enable;
 }
 
 void RendererStorageRD::reflection_probe_set_enable_shadows(RID p_probe, bool p_enable) {
-	ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
+	ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe);
 	ERR_FAIL_COND(!reflection_probe);
 
 	reflection_probe->enable_shadows = p_enable;
@@ -6201,7 +6201,7 @@ void RendererStorageRD::reflection_probe_set_enable_shadows(RID p_probe, bool p_
 }
 
 void RendererStorageRD::reflection_probe_set_cull_mask(RID p_probe, uint32_t p_layers) {
-	ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
+	ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe);
 	ERR_FAIL_COND(!reflection_probe);
 
 	reflection_probe->cull_mask = p_layers;
@@ -6209,7 +6209,7 @@ void RendererStorageRD::reflection_probe_set_cull_mask(RID p_probe, uint32_t p_l
 }
 
 void RendererStorageRD::reflection_probe_set_resolution(RID p_probe, int p_resolution) {
-	ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
+	ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe);
 	ERR_FAIL_COND(!reflection_probe);
 	ERR_FAIL_COND(p_resolution < 32);
 
@@ -6217,7 +6217,7 @@ void RendererStorageRD::reflection_probe_set_resolution(RID p_probe, int p_resol
 }
 
 void RendererStorageRD::reflection_probe_set_lod_threshold(RID p_probe, float p_ratio) {
-	ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
+	ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe);
 	ERR_FAIL_COND(!reflection_probe);
 
 	reflection_probe->lod_threshold = p_ratio;
@@ -6226,7 +6226,7 @@ void RendererStorageRD::reflection_probe_set_lod_threshold(RID p_probe, float p_
 }
 
 AABB RendererStorageRD::reflection_probe_get_aabb(RID p_probe) const {
-	const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
+	const ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe);
 	ERR_FAIL_COND_V(!reflection_probe, AABB());
 
 	AABB aabb;
@@ -6237,96 +6237,96 @@ AABB RendererStorageRD::reflection_probe_get_aabb(RID p_probe) const {
 }
 
 RS::ReflectionProbeUpdateMode RendererStorageRD::reflection_probe_get_update_mode(RID p_probe) const {
-	const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
+	const ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe);
 	ERR_FAIL_COND_V(!reflection_probe, RS::REFLECTION_PROBE_UPDATE_ALWAYS);
 
 	return reflection_probe->update_mode;
 }
 
 uint32_t RendererStorageRD::reflection_probe_get_cull_mask(RID p_probe) const {
-	const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
+	const ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe);
 	ERR_FAIL_COND_V(!reflection_probe, 0);
 
 	return reflection_probe->cull_mask;
 }
 
 Vector3 RendererStorageRD::reflection_probe_get_extents(RID p_probe) const {
-	const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
+	const ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe);
 	ERR_FAIL_COND_V(!reflection_probe, Vector3());
 
 	return reflection_probe->extents;
 }
 
 Vector3 RendererStorageRD::reflection_probe_get_origin_offset(RID p_probe) const {
-	const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
+	const ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe);
 	ERR_FAIL_COND_V(!reflection_probe, Vector3());
 
 	return reflection_probe->origin_offset;
 }
 
 bool RendererStorageRD::reflection_probe_renders_shadows(RID p_probe) const {
-	const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
+	const ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe);
 	ERR_FAIL_COND_V(!reflection_probe, false);
 
 	return reflection_probe->enable_shadows;
 }
 
 float RendererStorageRD::reflection_probe_get_origin_max_distance(RID p_probe) const {
-	const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
+	const ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe);
 	ERR_FAIL_COND_V(!reflection_probe, 0);
 
 	return reflection_probe->max_distance;
 }
 
 float RendererStorageRD::reflection_probe_get_lod_threshold(RID p_probe) const {
-	const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
+	const ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe);
 	ERR_FAIL_COND_V(!reflection_probe, 0);
 
 	return reflection_probe->lod_threshold;
 }
 
 int RendererStorageRD::reflection_probe_get_resolution(RID p_probe) const {
-	const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
+	const ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe);
 	ERR_FAIL_COND_V(!reflection_probe, 0);
 
 	return reflection_probe->resolution;
 }
 
 float RendererStorageRD::reflection_probe_get_intensity(RID p_probe) const {
-	const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
+	const ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe);
 	ERR_FAIL_COND_V(!reflection_probe, 0);
 
 	return reflection_probe->intensity;
 }
 
 bool RendererStorageRD::reflection_probe_is_interior(RID p_probe) const {
-	const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
+	const ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe);
 	ERR_FAIL_COND_V(!reflection_probe, false);
 
 	return reflection_probe->interior;
 }
 
 bool RendererStorageRD::reflection_probe_is_box_projection(RID p_probe) const {
-	const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
+	const ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe);
 	ERR_FAIL_COND_V(!reflection_probe, false);
 
 	return reflection_probe->box_projection;
 }
 
 RS::ReflectionProbeAmbientMode RendererStorageRD::reflection_probe_get_ambient_mode(RID p_probe) const {
-	const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
+	const ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe);
 	ERR_FAIL_COND_V(!reflection_probe, RS::REFLECTION_PROBE_AMBIENT_DISABLED);
 	return reflection_probe->ambient_mode;
 }
 
 Color RendererStorageRD::reflection_probe_get_ambient_color(RID p_probe) const {
-	const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
+	const ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe);
 	ERR_FAIL_COND_V(!reflection_probe, Color());
 
 	return reflection_probe->ambient_color;
 }
 float RendererStorageRD::reflection_probe_get_ambient_color_energy(RID p_probe) const {
-	const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
+	const ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe);
 	ERR_FAIL_COND_V(!reflection_probe, 0);
 
 	return reflection_probe->ambient_color_energy;
@@ -6340,14 +6340,14 @@ void RendererStorageRD::decal_initialize(RID p_decal) {
 }
 
 void RendererStorageRD::decal_set_extents(RID p_decal, const Vector3 &p_extents) {
-	Decal *decal = decal_owner.getornull(p_decal);
+	Decal *decal = decal_owner.get_or_null(p_decal);
 	ERR_FAIL_COND(!decal);
 	decal->extents = p_extents;
 	decal->dependency.changed_notify(DEPENDENCY_CHANGED_AABB);
 }
 
 void RendererStorageRD::decal_set_texture(RID p_decal, RS::DecalTexture p_type, RID p_texture) {
-	Decal *decal = decal_owner.getornull(p_decal);
+	Decal *decal = decal_owner.get_or_null(p_decal);
 	ERR_FAIL_COND(!decal);
 	ERR_FAIL_INDEX(p_type, RS::DECAL_TEXTURE_MAX);
 
@@ -6371,32 +6371,32 @@ void RendererStorageRD::decal_set_texture(RID p_decal, RS::DecalTexture p_type,
 }
 
 void RendererStorageRD::decal_set_emission_energy(RID p_decal, float p_energy) {
-	Decal *decal = decal_owner.getornull(p_decal);
+	Decal *decal = decal_owner.get_or_null(p_decal);
 	ERR_FAIL_COND(!decal);
 	decal->emission_energy = p_energy;
 }
 
 void RendererStorageRD::decal_set_albedo_mix(RID p_decal, float p_mix) {
-	Decal *decal = decal_owner.getornull(p_decal);
+	Decal *decal = decal_owner.get_or_null(p_decal);
 	ERR_FAIL_COND(!decal);
 	decal->albedo_mix = p_mix;
 }
 
 void RendererStorageRD::decal_set_modulate(RID p_decal, const Color &p_modulate) {
-	Decal *decal = decal_owner.getornull(p_decal);
+	Decal *decal = decal_owner.get_or_null(p_decal);
 	ERR_FAIL_COND(!decal);
 	decal->modulate = p_modulate;
 }
 
 void RendererStorageRD::decal_set_cull_mask(RID p_decal, uint32_t p_layers) {
-	Decal *decal = decal_owner.getornull(p_decal);
+	Decal *decal = decal_owner.get_or_null(p_decal);
 	ERR_FAIL_COND(!decal);
 	decal->cull_mask = p_layers;
 	decal->dependency.changed_notify(DEPENDENCY_CHANGED_AABB);
 }
 
 void RendererStorageRD::decal_set_distance_fade(RID p_decal, bool p_enabled, float p_begin, float p_length) {
-	Decal *decal = decal_owner.getornull(p_decal);
+	Decal *decal = decal_owner.get_or_null(p_decal);
 	ERR_FAIL_COND(!decal);
 	decal->distance_fade = p_enabled;
 	decal->distance_fade_begin = p_begin;
@@ -6404,20 +6404,20 @@ void RendererStorageRD::decal_set_distance_fade(RID p_decal, bool p_enabled, flo
 }
 
 void RendererStorageRD::decal_set_fade(RID p_decal, float p_above, float p_below) {
-	Decal *decal = decal_owner.getornull(p_decal);
+	Decal *decal = decal_owner.get_or_null(p_decal);
 	ERR_FAIL_COND(!decal);
 	decal->upper_fade = p_above;
 	decal->lower_fade = p_below;
 }
 
 void RendererStorageRD::decal_set_normal_fade(RID p_decal, float p_fade) {
-	Decal *decal = decal_owner.getornull(p_decal);
+	Decal *decal = decal_owner.get_or_null(p_decal);
 	ERR_FAIL_COND(!decal);
 	decal->normal_fade = p_fade;
 }
 
 AABB RendererStorageRD::decal_get_aabb(RID p_decal) const {
-	Decal *decal = decal_owner.getornull(p_decal);
+	Decal *decal = decal_owner.get_or_null(p_decal);
 	ERR_FAIL_COND_V(!decal, AABB());
 
 	return AABB(-decal->extents, decal->extents * 2.0);
@@ -6431,7 +6431,7 @@ void RendererStorageRD::voxel_gi_initialize(RID p_voxel_gi) {
 }
 
 void RendererStorageRD::voxel_gi_allocate_data(RID p_voxel_gi, const Transform3D &p_to_cell_xform, const AABB &p_aabb, const Vector3i &p_octree_size, const Vector<uint8_t> &p_octree_cells, const Vector<uint8_t> &p_data_cells, const Vector<uint8_t> &p_distance_field, const Vector<int> &p_level_counts) {
-	VoxelGI *voxel_gi = voxel_gi_owner.getornull(p_voxel_gi);
+	VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi);
 	ERR_FAIL_COND(!voxel_gi);
 
 	if (voxel_gi->octree_buffer.is_valid()) {
@@ -6556,20 +6556,20 @@ void RendererStorageRD::voxel_gi_allocate_data(RID p_voxel_gi, const Transform3D
 }
 
 AABB RendererStorageRD::voxel_gi_get_bounds(RID p_voxel_gi) const {
-	VoxelGI *voxel_gi = voxel_gi_owner.getornull(p_voxel_gi);
+	VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi);
 	ERR_FAIL_COND_V(!voxel_gi, AABB());
 
 	return voxel_gi->bounds;
 }
 
 Vector3i RendererStorageRD::voxel_gi_get_octree_size(RID p_voxel_gi) const {
-	VoxelGI *voxel_gi = voxel_gi_owner.getornull(p_voxel_gi);
+	VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi);
 	ERR_FAIL_COND_V(!voxel_gi, Vector3i());
 	return voxel_gi->octree_size;
 }
 
 Vector<uint8_t> RendererStorageRD::voxel_gi_get_octree_cells(RID p_voxel_gi) const {
-	VoxelGI *voxel_gi = voxel_gi_owner.getornull(p_voxel_gi);
+	VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi);
 	ERR_FAIL_COND_V(!voxel_gi, Vector<uint8_t>());
 
 	if (voxel_gi->octree_buffer.is_valid()) {
@@ -6579,7 +6579,7 @@ Vector<uint8_t> RendererStorageRD::voxel_gi_get_octree_cells(RID p_voxel_gi) con
 }
 
 Vector<uint8_t> RendererStorageRD::voxel_gi_get_data_cells(RID p_voxel_gi) const {
-	VoxelGI *voxel_gi = voxel_gi_owner.getornull(p_voxel_gi);
+	VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi);
 	ERR_FAIL_COND_V(!voxel_gi, Vector<uint8_t>());
 
 	if (voxel_gi->data_buffer.is_valid()) {
@@ -6589,7 +6589,7 @@ Vector<uint8_t> RendererStorageRD::voxel_gi_get_data_cells(RID p_voxel_gi) const
 }
 
 Vector<uint8_t> RendererStorageRD::voxel_gi_get_distance_field(RID p_voxel_gi) const {
-	VoxelGI *voxel_gi = voxel_gi_owner.getornull(p_voxel_gi);
+	VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi);
 	ERR_FAIL_COND_V(!voxel_gi, Vector<uint8_t>());
 
 	if (voxel_gi->data_buffer.is_valid()) {
@@ -6599,21 +6599,21 @@ Vector<uint8_t> RendererStorageRD::voxel_gi_get_distance_field(RID p_voxel_gi) c
 }
 
 Vector<int> RendererStorageRD::voxel_gi_get_level_counts(RID p_voxel_gi) const {
-	VoxelGI *voxel_gi = voxel_gi_owner.getornull(p_voxel_gi);
+	VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi);
 	ERR_FAIL_COND_V(!voxel_gi, Vector<int>());
 
 	return voxel_gi->level_counts;
 }
 
 Transform3D RendererStorageRD::voxel_gi_get_to_cell_xform(RID p_voxel_gi) const {
-	VoxelGI *voxel_gi = voxel_gi_owner.getornull(p_voxel_gi);
+	VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi);
 	ERR_FAIL_COND_V(!voxel_gi, Transform3D());
 
 	return voxel_gi->to_cell_xform;
 }
 
 void RendererStorageRD::voxel_gi_set_dynamic_range(RID p_voxel_gi, float p_range) {
-	VoxelGI *voxel_gi = voxel_gi_owner.getornull(p_voxel_gi);
+	VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi);
 	ERR_FAIL_COND(!voxel_gi);
 
 	voxel_gi->dynamic_range = p_range;
@@ -6621,14 +6621,14 @@ void RendererStorageRD::voxel_gi_set_dynamic_range(RID p_voxel_gi, float p_range
 }
 
 float RendererStorageRD::voxel_gi_get_dynamic_range(RID p_voxel_gi) const {
-	VoxelGI *voxel_gi = voxel_gi_owner.getornull(p_voxel_gi);
+	VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi);
 	ERR_FAIL_COND_V(!voxel_gi, 0);
 
 	return voxel_gi->dynamic_range;
 }
 
 void RendererStorageRD::voxel_gi_set_propagation(RID p_voxel_gi, float p_range) {
-	VoxelGI *voxel_gi = voxel_gi_owner.getornull(p_voxel_gi);
+	VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi);
 	ERR_FAIL_COND(!voxel_gi);
 
 	voxel_gi->propagation = p_range;
@@ -6636,72 +6636,72 @@ void RendererStorageRD::voxel_gi_set_propagation(RID p_voxel_gi, float p_range)
 }
 
 float RendererStorageRD::voxel_gi_get_propagation(RID p_voxel_gi) const {
-	VoxelGI *voxel_gi = voxel_gi_owner.getornull(p_voxel_gi);
+	VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi);
 	ERR_FAIL_COND_V(!voxel_gi, 0);
 	return voxel_gi->propagation;
 }
 
 void RendererStorageRD::voxel_gi_set_energy(RID p_voxel_gi, float p_energy) {
-	VoxelGI *voxel_gi = voxel_gi_owner.getornull(p_voxel_gi);
+	VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi);
 	ERR_FAIL_COND(!voxel_gi);
 
 	voxel_gi->energy = p_energy;
 }
 
 float RendererStorageRD::voxel_gi_get_energy(RID p_voxel_gi) const {
-	VoxelGI *voxel_gi = voxel_gi_owner.getornull(p_voxel_gi);
+	VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi);
 	ERR_FAIL_COND_V(!voxel_gi, 0);
 	return voxel_gi->energy;
 }
 
 void RendererStorageRD::voxel_gi_set_bias(RID p_voxel_gi, float p_bias) {
-	VoxelGI *voxel_gi = voxel_gi_owner.getornull(p_voxel_gi);
+	VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi);
 	ERR_FAIL_COND(!voxel_gi);
 
 	voxel_gi->bias = p_bias;
 }
 
 float RendererStorageRD::voxel_gi_get_bias(RID p_voxel_gi) const {
-	VoxelGI *voxel_gi = voxel_gi_owner.getornull(p_voxel_gi);
+	VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi);
 	ERR_FAIL_COND_V(!voxel_gi, 0);
 	return voxel_gi->bias;
 }
 
 void RendererStorageRD::voxel_gi_set_normal_bias(RID p_voxel_gi, float p_normal_bias) {
-	VoxelGI *voxel_gi = voxel_gi_owner.getornull(p_voxel_gi);
+	VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi);
 	ERR_FAIL_COND(!voxel_gi);
 
 	voxel_gi->normal_bias = p_normal_bias;
 }
 
 float RendererStorageRD::voxel_gi_get_normal_bias(RID p_voxel_gi) const {
-	VoxelGI *voxel_gi = voxel_gi_owner.getornull(p_voxel_gi);
+	VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi);
 	ERR_FAIL_COND_V(!voxel_gi, 0);
 	return voxel_gi->normal_bias;
 }
 
 void RendererStorageRD::voxel_gi_set_anisotropy_strength(RID p_voxel_gi, float p_strength) {
-	VoxelGI *voxel_gi = voxel_gi_owner.getornull(p_voxel_gi);
+	VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi);
 	ERR_FAIL_COND(!voxel_gi);
 
 	voxel_gi->anisotropy_strength = p_strength;
 }
 
 float RendererStorageRD::voxel_gi_get_anisotropy_strength(RID p_voxel_gi) const {
-	VoxelGI *voxel_gi = voxel_gi_owner.getornull(p_voxel_gi);
+	VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi);
 	ERR_FAIL_COND_V(!voxel_gi, 0);
 	return voxel_gi->anisotropy_strength;
 }
 
 void RendererStorageRD::voxel_gi_set_interior(RID p_voxel_gi, bool p_enable) {
-	VoxelGI *voxel_gi = voxel_gi_owner.getornull(p_voxel_gi);
+	VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi);
 	ERR_FAIL_COND(!voxel_gi);
 
 	voxel_gi->interior = p_enable;
 }
 
 void RendererStorageRD::voxel_gi_set_use_two_bounces(RID p_voxel_gi, bool p_enable) {
-	VoxelGI *voxel_gi = voxel_gi_owner.getornull(p_voxel_gi);
+	VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi);
 	ERR_FAIL_COND(!voxel_gi);
 
 	voxel_gi->use_two_bounces = p_enable;
@@ -6709,43 +6709,43 @@ void RendererStorageRD::voxel_gi_set_use_two_bounces(RID p_voxel_gi, bool p_enab
 }
 
 bool RendererStorageRD::voxel_gi_is_using_two_bounces(RID p_voxel_gi) const {
-	VoxelGI *voxel_gi = voxel_gi_owner.getornull(p_voxel_gi);
+	VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi);
 	ERR_FAIL_COND_V(!voxel_gi, false);
 	return voxel_gi->use_two_bounces;
 }
 
 bool RendererStorageRD::voxel_gi_is_interior(RID p_voxel_gi) const {
-	VoxelGI *voxel_gi = voxel_gi_owner.getornull(p_voxel_gi);
+	VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi);
 	ERR_FAIL_COND_V(!voxel_gi, 0);
 	return voxel_gi->interior;
 }
 
 uint32_t RendererStorageRD::voxel_gi_get_version(RID p_voxel_gi) {
-	VoxelGI *voxel_gi = voxel_gi_owner.getornull(p_voxel_gi);
+	VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi);
 	ERR_FAIL_COND_V(!voxel_gi, 0);
 	return voxel_gi->version;
 }
 
 uint32_t RendererStorageRD::voxel_gi_get_data_version(RID p_voxel_gi) {
-	VoxelGI *voxel_gi = voxel_gi_owner.getornull(p_voxel_gi);
+	VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi);
 	ERR_FAIL_COND_V(!voxel_gi, 0);
 	return voxel_gi->data_version;
 }
 
 RID RendererStorageRD::voxel_gi_get_octree_buffer(RID p_voxel_gi) const {
-	VoxelGI *voxel_gi = voxel_gi_owner.getornull(p_voxel_gi);
+	VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi);
 	ERR_FAIL_COND_V(!voxel_gi, RID());
 	return voxel_gi->octree_buffer;
 }
 
 RID RendererStorageRD::voxel_gi_get_data_buffer(RID p_voxel_gi) const {
-	VoxelGI *voxel_gi = voxel_gi_owner.getornull(p_voxel_gi);
+	VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi);
 	ERR_FAIL_COND_V(!voxel_gi, RID());
 	return voxel_gi->data_buffer;
 }
 
 RID RendererStorageRD::voxel_gi_get_sdf_texture(RID p_voxel_gi) {
-	VoxelGI *voxel_gi = voxel_gi_owner.getornull(p_voxel_gi);
+	VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi);
 	ERR_FAIL_COND_V(!voxel_gi, RID());
 
 	return voxel_gi->sdf_texture;
@@ -6762,20 +6762,20 @@ void RendererStorageRD::lightmap_initialize(RID p_lightmap) {
 }
 
 void RendererStorageRD::lightmap_set_textures(RID p_lightmap, RID p_light, bool p_uses_spherical_haromics) {
-	Lightmap *lm = lightmap_owner.getornull(p_lightmap);
+	Lightmap *lm = lightmap_owner.get_or_null(p_lightmap);
 	ERR_FAIL_COND(!lm);
 
 	lightmap_array_version++;
 
 	//erase lightmap users
 	if (lm->light_texture.is_valid()) {
-		Texture *t = texture_owner.getornull(lm->light_texture);
+		Texture *t = texture_owner.get_or_null(lm->light_texture);
 		if (t) {
 			t->lightmap_users.erase(p_lightmap);
 		}
 	}
 
-	Texture *t = texture_owner.getornull(p_light);
+	Texture *t = texture_owner.get_or_null(p_light);
 	lm->light_texture = p_light;
 	lm->uses_spherical_harmonics = p_uses_spherical_haromics;
 
@@ -6810,19 +6810,19 @@ void RendererStorageRD::lightmap_set_textures(RID p_lightmap, RID p_light, bool
 }
 
 void RendererStorageRD::lightmap_set_probe_bounds(RID p_lightmap, const AABB &p_bounds) {
-	Lightmap *lm = lightmap_owner.getornull(p_lightmap);
+	Lightmap *lm = lightmap_owner.get_or_null(p_lightmap);
 	ERR_FAIL_COND(!lm);
 	lm->bounds = p_bounds;
 }
 
 void RendererStorageRD::lightmap_set_probe_interior(RID p_lightmap, bool p_interior) {
-	Lightmap *lm = lightmap_owner.getornull(p_lightmap);
+	Lightmap *lm = lightmap_owner.get_or_null(p_lightmap);
 	ERR_FAIL_COND(!lm);
 	lm->interior = p_interior;
 }
 
 void RendererStorageRD::lightmap_set_probe_capture_data(RID p_lightmap, const PackedVector3Array &p_points, const PackedColorArray &p_point_sh, const PackedInt32Array &p_tetrahedra, const PackedInt32Array &p_bsp_tree) {
-	Lightmap *lm = lightmap_owner.getornull(p_lightmap);
+	Lightmap *lm = lightmap_owner.get_or_null(p_lightmap);
 	ERR_FAIL_COND(!lm);
 
 	if (p_points.size()) {
@@ -6838,26 +6838,26 @@ void RendererStorageRD::lightmap_set_probe_capture_data(RID p_lightmap, const Pa
 }
 
 PackedVector3Array RendererStorageRD::lightmap_get_probe_capture_points(RID p_lightmap) const {
-	Lightmap *lm = lightmap_owner.getornull(p_lightmap);
+	Lightmap *lm = lightmap_owner.get_or_null(p_lightmap);
 	ERR_FAIL_COND_V(!lm, PackedVector3Array());
 
 	return lm->points;
 }
 
 PackedColorArray RendererStorageRD::lightmap_get_probe_capture_sh(RID p_lightmap) const {
-	Lightmap *lm = lightmap_owner.getornull(p_lightmap);
+	Lightmap *lm = lightmap_owner.get_or_null(p_lightmap);
 	ERR_FAIL_COND_V(!lm, PackedColorArray());
 	return lm->point_sh;
 }
 
 PackedInt32Array RendererStorageRD::lightmap_get_probe_capture_tetrahedra(RID p_lightmap) const {
-	Lightmap *lm = lightmap_owner.getornull(p_lightmap);
+	Lightmap *lm = lightmap_owner.get_or_null(p_lightmap);
 	ERR_FAIL_COND_V(!lm, PackedInt32Array());
 	return lm->tetrahedra;
 }
 
 PackedInt32Array RendererStorageRD::lightmap_get_probe_capture_bsp_tree(RID p_lightmap) const {
-	Lightmap *lm = lightmap_owner.getornull(p_lightmap);
+	Lightmap *lm = lightmap_owner.get_or_null(p_lightmap);
 	ERR_FAIL_COND_V(!lm, PackedInt32Array());
 	return lm->bsp_tree;
 }
@@ -6867,7 +6867,7 @@ void RendererStorageRD::lightmap_set_probe_capture_update_speed(float p_speed) {
 }
 
 void RendererStorageRD::lightmap_tap_sh_light(RID p_lightmap, const Vector3 &p_point, Color *r_sh) {
-	Lightmap *lm = lightmap_owner.getornull(p_lightmap);
+	Lightmap *lm = lightmap_owner.get_or_null(p_lightmap);
 	ERR_FAIL_COND(!lm);
 
 	for (int i = 0; i < 9; i++) {
@@ -6917,13 +6917,13 @@ void RendererStorageRD::lightmap_tap_sh_light(RID p_lightmap, const Vector3 &p_p
 }
 
 bool RendererStorageRD::lightmap_is_interior(RID p_lightmap) const {
-	const Lightmap *lm = lightmap_owner.getornull(p_lightmap);
+	const Lightmap *lm = lightmap_owner.get_or_null(p_lightmap);
 	ERR_FAIL_COND_V(!lm, false);
 	return lm->interior;
 }
 
 AABB RendererStorageRD::lightmap_get_aabb(RID p_lightmap) const {
-	const Lightmap *lm = lightmap_owner.getornull(p_lightmap);
+	const Lightmap *lm = lightmap_owner.get_or_null(p_lightmap);
 	ERR_FAIL_COND_V(!lm, AABB());
 	return lm->bounds;
 }
@@ -6963,7 +6963,7 @@ void RendererStorageRD::_update_render_target(RenderTarget *rt) {
 		//create a placeholder until updated
 		rt->texture = texture_allocate();
 		texture_2d_placeholder_initialize(rt->texture);
-		Texture *tex = texture_owner.getornull(rt->texture);
+		Texture *tex = texture_owner.get_or_null(rt->texture);
 		tex->is_render_target = true;
 	}
 
@@ -7010,7 +7010,7 @@ void RendererStorageRD::_update_render_target(RenderTarget *rt) {
 
 	{ //update texture
 
-		Texture *tex = texture_owner.getornull(rt->texture);
+		Texture *tex = texture_owner.get_or_null(rt->texture);
 
 		//free existing textures
 		if (RD::get_singleton()->texture_is_valid(tex->rd_texture)) {
@@ -7117,7 +7117,7 @@ void RendererStorageRD::render_target_set_position(RID p_render_target, int p_x,
 }
 
 void RendererStorageRD::render_target_set_size(RID p_render_target, int p_width, int p_height, uint32_t p_view_count) {
-	RenderTarget *rt = render_target_owner.getornull(p_render_target);
+	RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
 	ERR_FAIL_COND(!rt);
 	if (rt->size.x != p_width || rt->size.y != p_height || rt->view_count != p_view_count) {
 		rt->size.x = p_width;
@@ -7128,7 +7128,7 @@ void RendererStorageRD::render_target_set_size(RID p_render_target, int p_width,
 }
 
 RID RendererStorageRD::render_target_get_texture(RID p_render_target) {
-	RenderTarget *rt = render_target_owner.getornull(p_render_target);
+	RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
 	ERR_FAIL_COND_V(!rt, RID());
 
 	return rt->texture;
@@ -7138,53 +7138,53 @@ void RendererStorageRD::render_target_set_external_texture(RID p_render_target,
 }
 
 void RendererStorageRD::render_target_set_flag(RID p_render_target, RenderTargetFlags p_flag, bool p_value) {
-	RenderTarget *rt = render_target_owner.getornull(p_render_target);
+	RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
 	ERR_FAIL_COND(!rt);
 	rt->flags[p_flag] = p_value;
 	_update_render_target(rt);
 }
 
 bool RendererStorageRD::render_target_was_used(RID p_render_target) {
-	RenderTarget *rt = render_target_owner.getornull(p_render_target);
+	RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
 	ERR_FAIL_COND_V(!rt, false);
 	return rt->was_used;
 }
 
 void RendererStorageRD::render_target_set_as_unused(RID p_render_target) {
-	RenderTarget *rt = render_target_owner.getornull(p_render_target);
+	RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
 	ERR_FAIL_COND(!rt);
 	rt->was_used = false;
 }
 
 Size2 RendererStorageRD::render_target_get_size(RID p_render_target) {
-	RenderTarget *rt = render_target_owner.getornull(p_render_target);
+	RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
 	ERR_FAIL_COND_V(!rt, Size2());
 
 	return rt->size;
 }
 
 RID RendererStorageRD::render_target_get_rd_framebuffer(RID p_render_target) {
-	RenderTarget *rt = render_target_owner.getornull(p_render_target);
+	RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
 	ERR_FAIL_COND_V(!rt, RID());
 
 	return rt->framebuffer;
 }
 
 RID RendererStorageRD::render_target_get_rd_texture(RID p_render_target) {
-	RenderTarget *rt = render_target_owner.getornull(p_render_target);
+	RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
 	ERR_FAIL_COND_V(!rt, RID());
 
 	return rt->color;
 }
 
 RID RendererStorageRD::render_target_get_rd_backbuffer(RID p_render_target) {
-	RenderTarget *rt = render_target_owner.getornull(p_render_target);
+	RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
 	ERR_FAIL_COND_V(!rt, RID());
 	return rt->backbuffer;
 }
 
 RID RendererStorageRD::render_target_get_rd_backbuffer_framebuffer(RID p_render_target) {
-	RenderTarget *rt = render_target_owner.getornull(p_render_target);
+	RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
 	ERR_FAIL_COND_V(!rt, RID());
 
 	if (!rt->backbuffer.is_valid()) {
@@ -7195,32 +7195,32 @@ RID RendererStorageRD::render_target_get_rd_backbuffer_framebuffer(RID p_render_
 }
 
 void RendererStorageRD::render_target_request_clear(RID p_render_target, const Color &p_clear_color) {
-	RenderTarget *rt = render_target_owner.getornull(p_render_target);
+	RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
 	ERR_FAIL_COND(!rt);
 	rt->clear_requested = true;
 	rt->clear_color = p_clear_color;
 }
 
 bool RendererStorageRD::render_target_is_clear_requested(RID p_render_target) {
-	RenderTarget *rt = render_target_owner.getornull(p_render_target);
+	RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
 	ERR_FAIL_COND_V(!rt, false);
 	return rt->clear_requested;
 }
 
 Color RendererStorageRD::render_target_get_clear_request_color(RID p_render_target) {
-	RenderTarget *rt = render_target_owner.getornull(p_render_target);
+	RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
 	ERR_FAIL_COND_V(!rt, Color());
 	return rt->clear_color;
 }
 
 void RendererStorageRD::render_target_disable_clear_request(RID p_render_target) {
-	RenderTarget *rt = render_target_owner.getornull(p_render_target);
+	RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
 	ERR_FAIL_COND(!rt);
 	rt->clear_requested = false;
 }
 
 void RendererStorageRD::render_target_do_clear_request(RID p_render_target) {
-	RenderTarget *rt = render_target_owner.getornull(p_render_target);
+	RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
 	ERR_FAIL_COND(!rt);
 	if (!rt->clear_requested) {
 		return;
@@ -7233,7 +7233,7 @@ void RendererStorageRD::render_target_do_clear_request(RID p_render_target) {
 }
 
 void RendererStorageRD::render_target_set_sdf_size_and_scale(RID p_render_target, RS::ViewportSDFOversize p_size, RS::ViewportSDFScale p_scale) {
-	RenderTarget *rt = render_target_owner.getornull(p_render_target);
+	RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
 	ERR_FAIL_COND(!rt);
 	if (rt->sdf_oversize == p_size && rt->sdf_scale == p_scale) {
 		return;
@@ -7275,28 +7275,28 @@ Rect2i RendererStorageRD::_render_target_get_sdf_rect(const RenderTarget *rt) co
 }
 
 Rect2i RendererStorageRD::render_target_get_sdf_rect(RID p_render_target) const {
-	const RenderTarget *rt = render_target_owner.getornull(p_render_target);
+	const RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
 	ERR_FAIL_COND_V(!rt, Rect2i());
 
 	return _render_target_get_sdf_rect(rt);
 }
 
 void RendererStorageRD::render_target_mark_sdf_enabled(RID p_render_target, bool p_enabled) {
-	RenderTarget *rt = render_target_owner.getornull(p_render_target);
+	RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
 	ERR_FAIL_COND(!rt);
 
 	rt->sdf_enabled = p_enabled;
 }
 
 bool RendererStorageRD::render_target_is_sdf_enabled(RID p_render_target) const {
-	const RenderTarget *rt = render_target_owner.getornull(p_render_target);
+	const RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
 	ERR_FAIL_COND_V(!rt, false);
 
 	return rt->sdf_enabled;
 }
 
 RID RendererStorageRD::render_target_get_sdf_texture(RID p_render_target) {
-	RenderTarget *rt = render_target_owner.getornull(p_render_target);
+	RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
 	ERR_FAIL_COND_V(!rt, RID());
 	if (rt->sdf_buffer_read.is_null()) {
 		// no texture, create a dummy one for the 2D uniform set
@@ -7431,7 +7431,7 @@ void RendererStorageRD::_render_target_clear_sdf(RenderTarget *rt) {
 }
 
 RID RendererStorageRD::render_target_get_sdf_framebuffer(RID p_render_target) {
-	RenderTarget *rt = render_target_owner.getornull(p_render_target);
+	RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
 	ERR_FAIL_COND_V(!rt, RID());
 
 	if (rt->sdf_buffer_write_fb.is_null()) {
@@ -7441,7 +7441,7 @@ RID RendererStorageRD::render_target_get_sdf_framebuffer(RID p_render_target) {
 	return rt->sdf_buffer_write_fb;
 }
 void RendererStorageRD::render_target_sdf_process(RID p_render_target) {
-	RenderTarget *rt = render_target_owner.getornull(p_render_target);
+	RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
 	ERR_FAIL_COND(!rt);
 	ERR_FAIL_COND(rt->sdf_buffer_write_fb.is_null());
 
@@ -7516,7 +7516,7 @@ void RendererStorageRD::render_target_sdf_process(RID p_render_target) {
 }
 
 void RendererStorageRD::render_target_copy_to_back_buffer(RID p_render_target, const Rect2i &p_region, bool p_gen_mipmaps) {
-	RenderTarget *rt = render_target_owner.getornull(p_render_target);
+	RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
 	ERR_FAIL_COND(!rt);
 	if (!rt->backbuffer.is_valid()) {
 		_create_render_target_backbuffer(rt);
@@ -7556,7 +7556,7 @@ void RendererStorageRD::render_target_copy_to_back_buffer(RID p_render_target, c
 }
 
 void RendererStorageRD::render_target_clear_back_buffer(RID p_render_target, const Rect2i &p_region, const Color &p_color) {
-	RenderTarget *rt = render_target_owner.getornull(p_render_target);
+	RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
 	ERR_FAIL_COND(!rt);
 	if (!rt->backbuffer.is_valid()) {
 		_create_render_target_backbuffer(rt);
@@ -7577,7 +7577,7 @@ void RendererStorageRD::render_target_clear_back_buffer(RID p_render_target, con
 }
 
 void RendererStorageRD::render_target_gen_back_buffer_mipmaps(RID p_render_target, const Rect2i &p_region) {
-	RenderTarget *rt = render_target_owner.getornull(p_render_target);
+	RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
 	ERR_FAIL_COND(!rt);
 	if (!rt->backbuffer.is_valid()) {
 		_create_render_target_backbuffer(rt);
@@ -7609,66 +7609,66 @@ void RendererStorageRD::render_target_gen_back_buffer_mipmaps(RID p_render_targe
 }
 
 RID RendererStorageRD::render_target_get_framebuffer_uniform_set(RID p_render_target) {
-	RenderTarget *rt = render_target_owner.getornull(p_render_target);
+	RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
 	ERR_FAIL_COND_V(!rt, RID());
 	return rt->framebuffer_uniform_set;
 }
 RID RendererStorageRD::render_target_get_backbuffer_uniform_set(RID p_render_target) {
-	RenderTarget *rt = render_target_owner.getornull(p_render_target);
+	RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
 	ERR_FAIL_COND_V(!rt, RID());
 	return rt->backbuffer_uniform_set;
 }
 
 void RendererStorageRD::render_target_set_framebuffer_uniform_set(RID p_render_target, RID p_uniform_set) {
-	RenderTarget *rt = render_target_owner.getornull(p_render_target);
+	RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
 	ERR_FAIL_COND(!rt);
 	rt->framebuffer_uniform_set = p_uniform_set;
 }
 void RendererStorageRD::render_target_set_backbuffer_uniform_set(RID p_render_target, RID p_uniform_set) {
-	RenderTarget *rt = render_target_owner.getornull(p_render_target);
+	RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
 	ERR_FAIL_COND(!rt);
 	rt->backbuffer_uniform_set = p_uniform_set;
 }
 
 void RendererStorageRD::base_update_dependency(RID p_base, DependencyTracker *p_instance) {
 	if (mesh_owner.owns(p_base)) {
-		Mesh *mesh = mesh_owner.getornull(p_base);
+		Mesh *mesh = mesh_owner.get_or_null(p_base);
 		p_instance->update_dependency(&mesh->dependency);
 	} else if (multimesh_owner.owns(p_base)) {
-		MultiMesh *multimesh = multimesh_owner.getornull(p_base);
+		MultiMesh *multimesh = multimesh_owner.get_or_null(p_base);
 		p_instance->update_dependency(&multimesh->dependency);
 		if (multimesh->mesh.is_valid()) {
 			base_update_dependency(multimesh->mesh, p_instance);
 		}
 	} else if (reflection_probe_owner.owns(p_base)) {
-		ReflectionProbe *rp = reflection_probe_owner.getornull(p_base);
+		ReflectionProbe *rp = reflection_probe_owner.get_or_null(p_base);
 		p_instance->update_dependency(&rp->dependency);
 	} else if (decal_owner.owns(p_base)) {
-		Decal *decal = decal_owner.getornull(p_base);
+		Decal *decal = decal_owner.get_or_null(p_base);
 		p_instance->update_dependency(&decal->dependency);
 	} else if (voxel_gi_owner.owns(p_base)) {
-		VoxelGI *gip = voxel_gi_owner.getornull(p_base);
+		VoxelGI *gip = voxel_gi_owner.get_or_null(p_base);
 		p_instance->update_dependency(&gip->dependency);
 	} else if (lightmap_owner.owns(p_base)) {
-		Lightmap *lm = lightmap_owner.getornull(p_base);
+		Lightmap *lm = lightmap_owner.get_or_null(p_base);
 		p_instance->update_dependency(&lm->dependency);
 	} else if (light_owner.owns(p_base)) {
-		Light *l = light_owner.getornull(p_base);
+		Light *l = light_owner.get_or_null(p_base);
 		p_instance->update_dependency(&l->dependency);
 	} else if (particles_owner.owns(p_base)) {
-		Particles *p = particles_owner.getornull(p_base);
+		Particles *p = particles_owner.get_or_null(p_base);
 		p_instance->update_dependency(&p->dependency);
 	} else if (particles_collision_owner.owns(p_base)) {
-		ParticlesCollision *pc = particles_collision_owner.getornull(p_base);
+		ParticlesCollision *pc = particles_collision_owner.get_or_null(p_base);
 		p_instance->update_dependency(&pc->dependency);
 	} else if (visibility_notifier_owner.owns(p_base)) {
-		VisibilityNotifier *vn = visibility_notifier_owner.getornull(p_base);
+		VisibilityNotifier *vn = visibility_notifier_owner.get_or_null(p_base);
 		p_instance->update_dependency(&vn->dependency);
 	}
 }
 
 void RendererStorageRD::skeleton_update_dependency(RID p_skeleton, DependencyTracker *p_instance) {
-	Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);
+	Skeleton *skeleton = skeleton_owner.get_or_null(p_skeleton);
 	ERR_FAIL_COND(!skeleton);
 
 	p_instance->update_dependency(&skeleton->dependency);
@@ -7774,7 +7774,7 @@ void RendererStorageRD::_update_decal_atlas() {
 		while ((K = decal_atlas.textures.next(K))) {
 			DecalAtlas::SortItem &si = itemsv.write[idx];
 
-			Texture *src_tex = texture_owner.getornull(*K);
+			Texture *src_tex = texture_owner.get_or_null(*K);
 
 			si.size.width = (src_tex->width / border) + 1;
 			si.size.height = (src_tex->height / border) + 1;
@@ -7923,7 +7923,7 @@ void RendererStorageRD::_update_decal_atlas() {
 				const RID *K = nullptr;
 				while ((K = decal_atlas.textures.next(K))) {
 					DecalAtlas::Texture *t = decal_atlas.textures.getptr(*K);
-					Texture *src_tex = texture_owner.getornull(*K);
+					Texture *src_tex = texture_owner.get_or_null(*K);
 					effects->copy_to_atlas_fb(src_tex->rd_texture, mm.fb, t->uv_rect, draw_list, false, t->panorama_to_dp_users > 0);
 				}
 
@@ -8339,7 +8339,7 @@ void RendererStorageRD::global_variable_set(const StringName &p_name, const Vari
 		} else {
 			//texture
 			for (Set<RID>::Element *E = gv.texture_materials.front(); E; E = E->next()) {
-				Material *material = material_owner.getornull(E->get());
+				Material *material = material_owner.get_or_null(E->get());
 				ERR_CONTINUE(!material);
 				_material_queue_update(material, false, true);
 			}
@@ -8370,7 +8370,7 @@ void RendererStorageRD::global_variable_set_override(const StringName &p_name, c
 	} else {
 		//texture
 		for (Set<RID>::Element *E = gv.texture_materials.front(); E; E = E->next()) {
-			Material *material = material_owner.getornull(E->get());
+			Material *material = material_owner.get_or_null(E->get());
 			ERR_CONTINUE(!material);
 			_material_queue_update(material, false, true);
 		}
@@ -8581,7 +8581,7 @@ void RendererStorageRD::_update_global_variables() {
 		// only happens in the case of a buffer variable added or removed,
 		// so not often.
 		for (const RID &E : global_variables.materials_using_buffer) {
-			Material *material = material_owner.getornull(E);
+			Material *material = material_owner.get_or_null(E);
 			ERR_CONTINUE(!material); //wtf
 
 			_material_queue_update(material, true, false);
@@ -8594,7 +8594,7 @@ void RendererStorageRD::_update_global_variables() {
 		// only happens in the case of a buffer variable added or removed,
 		// so not often.
 		for (const RID &E : global_variables.materials_using_texture) {
-			Material *material = material_owner.getornull(E);
+			Material *material = material_owner.get_or_null(E);
 			ERR_CONTINUE(!material); //wtf
 
 			_material_queue_update(material, false, true);
@@ -8639,7 +8639,7 @@ bool RendererStorageRD::has_os_feature(const String &p_feature) const {
 
 bool RendererStorageRD::free(RID p_rid) {
 	if (texture_owner.owns(p_rid)) {
-		Texture *t = texture_owner.getornull(p_rid);
+		Texture *t = texture_owner.get_or_null(p_rid);
 
 		ERR_FAIL_COND_V(!t, false);
 		ERR_FAIL_COND_V(t->is_render_target, false);
@@ -8653,7 +8653,7 @@ bool RendererStorageRD::free(RID p_rid) {
 		}
 
 		if (t->is_proxy && t->proxy_to.is_valid()) {
-			Texture *proxy_to = texture_owner.getornull(t->proxy_to);
+			Texture *proxy_to = texture_owner.get_or_null(t->proxy_to);
 			if (proxy_to) {
 				proxy_to->proxies.erase(p_rid);
 			}
@@ -8665,7 +8665,7 @@ bool RendererStorageRD::free(RID p_rid) {
 		}
 
 		for (int i = 0; i < t->proxies.size(); i++) {
-			Texture *p = texture_owner.getornull(t->proxies[i]);
+			Texture *p = texture_owner.get_or_null(t->proxies[i]);
 			ERR_CONTINUE(!p);
 			p->proxy_to = RID();
 			p->rd_texture = RID();
@@ -8680,7 +8680,7 @@ bool RendererStorageRD::free(RID p_rid) {
 	} else if (canvas_texture_owner.owns(p_rid)) {
 		canvas_texture_owner.free(p_rid);
 	} else if (shader_owner.owns(p_rid)) {
-		Shader *shader = shader_owner.getornull(p_rid);
+		Shader *shader = shader_owner.get_or_null(p_rid);
 		//make material unreference this
 		while (shader->owners.size()) {
 			material_set_shader(shader->owners.front()->get()->self, RID());
@@ -8692,7 +8692,7 @@ bool RendererStorageRD::free(RID p_rid) {
 		shader_owner.free(p_rid);
 
 	} else if (material_owner.owns(p_rid)) {
-		Material *material = material_owner.getornull(p_rid);
+		Material *material = material_owner.get_or_null(p_rid);
 		material_set_shader(p_rid, RID()); //clean up shader
 		material->dependency.deleted_notify(p_rid);
 
@@ -8700,7 +8700,7 @@ bool RendererStorageRD::free(RID p_rid) {
 	} else if (mesh_owner.owns(p_rid)) {
 		mesh_clear(p_rid);
 		mesh_set_shadow_mesh(p_rid, RID());
-		Mesh *mesh = mesh_owner.getornull(p_rid);
+		Mesh *mesh = mesh_owner.get_or_null(p_rid);
 		mesh->dependency.deleted_notify(p_rid);
 		if (mesh->instances.size()) {
 			ERR_PRINT("deleting mesh with active instances");
@@ -8714,7 +8714,7 @@ bool RendererStorageRD::free(RID p_rid) {
 		}
 		mesh_owner.free(p_rid);
 	} else if (mesh_instance_owner.owns(p_rid)) {
-		MeshInstance *mi = mesh_instance_owner.getornull(p_rid);
+		MeshInstance *mi = mesh_instance_owner.get_or_null(p_rid);
 		_mesh_instance_clear(mi);
 		mi->mesh->instances.erase(mi->I);
 		mi->I = nullptr;
@@ -8724,21 +8724,21 @@ bool RendererStorageRD::free(RID p_rid) {
 	} else if (multimesh_owner.owns(p_rid)) {
 		_update_dirty_multimeshes();
 		multimesh_allocate_data(p_rid, 0, RS::MULTIMESH_TRANSFORM_2D);
-		MultiMesh *multimesh = multimesh_owner.getornull(p_rid);
+		MultiMesh *multimesh = multimesh_owner.get_or_null(p_rid);
 		multimesh->dependency.deleted_notify(p_rid);
 		multimesh_owner.free(p_rid);
 	} else if (skeleton_owner.owns(p_rid)) {
 		_update_dirty_skeletons();
 		skeleton_allocate_data(p_rid, 0);
-		Skeleton *skeleton = skeleton_owner.getornull(p_rid);
+		Skeleton *skeleton = skeleton_owner.get_or_null(p_rid);
 		skeleton->dependency.deleted_notify(p_rid);
 		skeleton_owner.free(p_rid);
 	} else if (reflection_probe_owner.owns(p_rid)) {
-		ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_rid);
+		ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_rid);
 		reflection_probe->dependency.deleted_notify(p_rid);
 		reflection_probe_owner.free(p_rid);
 	} else if (decal_owner.owns(p_rid)) {
-		Decal *decal = decal_owner.getornull(p_rid);
+		Decal *decal = decal_owner.get_or_null(p_rid);
 		for (int i = 0; i < RS::DECAL_TEXTURE_MAX; i++) {
 			if (decal->textures[i].is_valid() && texture_owner.owns(decal->textures[i])) {
 				texture_remove_from_decal_atlas(decal->textures[i]);
@@ -8748,30 +8748,30 @@ bool RendererStorageRD::free(RID p_rid) {
 		decal_owner.free(p_rid);
 	} else if (voxel_gi_owner.owns(p_rid)) {
 		voxel_gi_allocate_data(p_rid, Transform3D(), AABB(), Vector3i(), Vector<uint8_t>(), Vector<uint8_t>(), Vector<uint8_t>(), Vector<int>()); //deallocate
-		VoxelGI *voxel_gi = voxel_gi_owner.getornull(p_rid);
+		VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_rid);
 		voxel_gi->dependency.deleted_notify(p_rid);
 		voxel_gi_owner.free(p_rid);
 	} else if (lightmap_owner.owns(p_rid)) {
 		lightmap_set_textures(p_rid, RID(), false);
-		Lightmap *lightmap = lightmap_owner.getornull(p_rid);
+		Lightmap *lightmap = lightmap_owner.get_or_null(p_rid);
 		lightmap->dependency.deleted_notify(p_rid);
 		lightmap_owner.free(p_rid);
 
 	} else if (light_owner.owns(p_rid)) {
 		light_set_projector(p_rid, RID()); //clear projector
 		// delete the texture
-		Light *light = light_owner.getornull(p_rid);
+		Light *light = light_owner.get_or_null(p_rid);
 		light->dependency.deleted_notify(p_rid);
 		light_owner.free(p_rid);
 
 	} else if (particles_owner.owns(p_rid)) {
 		update_particles();
-		Particles *particles = particles_owner.getornull(p_rid);
+		Particles *particles = particles_owner.get_or_null(p_rid);
 		particles->dependency.deleted_notify(p_rid);
 		_particles_free_data(particles);
 		particles_owner.free(p_rid);
 	} else if (particles_collision_owner.owns(p_rid)) {
-		ParticlesCollision *particles_collision = particles_collision_owner.getornull(p_rid);
+		ParticlesCollision *particles_collision = particles_collision_owner.get_or_null(p_rid);
 
 		if (particles_collision->heightfield_texture.is_valid()) {
 			RD::get_singleton()->free(particles_collision->heightfield_texture);
@@ -8779,18 +8779,18 @@ bool RendererStorageRD::free(RID p_rid) {
 		particles_collision->dependency.deleted_notify(p_rid);
 		particles_collision_owner.free(p_rid);
 	} else if (visibility_notifier_owner.owns(p_rid)) {
-		VisibilityNotifier *vn = visibility_notifier_owner.getornull(p_rid);
+		VisibilityNotifier *vn = visibility_notifier_owner.get_or_null(p_rid);
 		vn->dependency.deleted_notify(p_rid);
 		visibility_notifier_owner.free(p_rid);
 	} else if (particles_collision_instance_owner.owns(p_rid)) {
 		particles_collision_instance_owner.free(p_rid);
 	} else if (render_target_owner.owns(p_rid)) {
-		RenderTarget *rt = render_target_owner.getornull(p_rid);
+		RenderTarget *rt = render_target_owner.get_or_null(p_rid);
 
 		_clear_render_target(rt);
 
 		if (rt->texture.is_valid()) {
-			Texture *tex = texture_owner.getornull(rt->texture);
+			Texture *tex = texture_owner.get_or_null(rt->texture);
 			tex->is_render_target = false;
 			free(rt->texture);
 		}
diff --git a/servers/rendering/renderer_rd/renderer_storage_rd.h b/servers/rendering/renderer_rd/renderer_storage_rd.h
index 4950b7d5e5..d56afcc448 100644
--- a/servers/rendering/renderer_rd/renderer_storage_rd.h
+++ b/servers/rendering/renderer_rd/renderer_storage_rd.h
@@ -1350,7 +1350,7 @@ public:
 		if (p_texture.is_null()) {
 			return RID();
 		}
-		Texture *tex = texture_owner.getornull(p_texture);
+		Texture *tex = texture_owner.get_or_null(p_texture);
 
 		if (!tex) {
 			return RID();
@@ -1362,7 +1362,7 @@ public:
 		if (p_texture.is_null()) {
 			return Size2i();
 		}
-		Texture *tex = texture_owner.getornull(p_texture);
+		Texture *tex = texture_owner.get_or_null(p_texture);
 
 		if (!tex) {
 			return Size2i();
@@ -1430,12 +1430,12 @@ public:
 	void material_set_data_request_function(ShaderType p_shader_type, MaterialDataRequestFunction p_function);
 
 	_FORCE_INLINE_ uint32_t material_get_shader_id(RID p_material) {
-		Material *material = material_owner.getornull(p_material);
+		Material *material = material_owner.get_or_null(p_material);
 		return material->shader_id;
 	}
 
 	_FORCE_INLINE_ MaterialData *material_get_data(RID p_material, ShaderType p_shader_type) {
-		Material *material = material_owner.getornull(p_material);
+		Material *material = material_owner.get_or_null(p_material);
 		if (!material || material->shader_type != p_shader_type) {
 			return nullptr;
 		} else {
@@ -1488,7 +1488,7 @@ public:
 	virtual void update_mesh_instances();
 
 	_FORCE_INLINE_ const RID *mesh_get_surface_count_and_materials(RID p_mesh, uint32_t &r_surface_count) {
-		Mesh *mesh = mesh_owner.getornull(p_mesh);
+		Mesh *mesh = mesh_owner.get_or_null(p_mesh);
 		ERR_FAIL_COND_V(!mesh, nullptr);
 		r_surface_count = mesh->surface_count;
 		if (r_surface_count == 0) {
@@ -1505,7 +1505,7 @@ public:
 	}
 
 	_FORCE_INLINE_ void *mesh_get_surface(RID p_mesh, uint32_t p_surface_index) {
-		Mesh *mesh = mesh_owner.getornull(p_mesh);
+		Mesh *mesh = mesh_owner.get_or_null(p_mesh);
 		ERR_FAIL_COND_V(!mesh, nullptr);
 		ERR_FAIL_UNSIGNED_INDEX_V(p_surface_index, mesh->surface_count, nullptr);
 
@@ -1513,7 +1513,7 @@ public:
 	}
 
 	_FORCE_INLINE_ RID mesh_get_shadow_mesh(RID p_mesh) {
-		Mesh *mesh = mesh_owner.getornull(p_mesh);
+		Mesh *mesh = mesh_owner.get_or_null(p_mesh);
 		ERR_FAIL_COND_V(!mesh, RID());
 
 		return mesh->shadow_mesh;
@@ -1599,7 +1599,7 @@ public:
 	}
 
 	_FORCE_INLINE_ void mesh_instance_surface_get_vertex_arrays_and_format(RID p_mesh_instance, uint32_t p_surface_index, uint32_t p_input_mask, RID &r_vertex_array_rd, RD::VertexFormatID &r_vertex_format) {
-		MeshInstance *mi = mesh_instance_owner.getornull(p_mesh_instance);
+		MeshInstance *mi = mesh_instance_owner.get_or_null(p_mesh_instance);
 		ERR_FAIL_COND(!mi);
 		Mesh *mesh = mi->mesh;
 		ERR_FAIL_UNSIGNED_INDEX(p_surface_index, mesh->surface_count);
@@ -1640,7 +1640,7 @@ public:
 	}
 
 	_FORCE_INLINE_ uint32_t mesh_surface_get_render_pass_index(RID p_mesh, uint32_t p_surface_index, uint64_t p_render_pass, uint32_t *r_index) {
-		Mesh *mesh = mesh_owner.getornull(p_mesh);
+		Mesh *mesh = mesh_owner.get_or_null(p_mesh);
 		Mesh::Surface *s = mesh->surfaces[p_surface_index];
 
 		if (s->render_pass != p_render_pass) {
@@ -1653,7 +1653,7 @@ public:
 	}
 
 	_FORCE_INLINE_ uint32_t mesh_surface_get_multimesh_render_pass_index(RID p_mesh, uint32_t p_surface_index, uint64_t p_render_pass, uint32_t *r_index) {
-		Mesh *mesh = mesh_owner.getornull(p_mesh);
+		Mesh *mesh = mesh_owner.get_or_null(p_mesh);
 		Mesh::Surface *s = mesh->surfaces[p_surface_index];
 
 		if (s->multimesh_render_pass != p_render_pass) {
@@ -1666,7 +1666,7 @@ public:
 	}
 
 	_FORCE_INLINE_ uint32_t mesh_surface_get_particles_render_pass_index(RID p_mesh, uint32_t p_surface_index, uint64_t p_render_pass, uint32_t *r_index) {
-		Mesh *mesh = mesh_owner.getornull(p_mesh);
+		Mesh *mesh = mesh_owner.get_or_null(p_mesh);
 		Mesh::Surface *s = mesh->surfaces[p_surface_index];
 
 		if (s->particles_render_pass != p_render_pass) {
@@ -1708,22 +1708,22 @@ public:
 	AABB multimesh_get_aabb(RID p_multimesh) const;
 
 	_FORCE_INLINE_ RS::MultimeshTransformFormat multimesh_get_transform_format(RID p_multimesh) const {
-		MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
+		MultiMesh *multimesh = multimesh_owner.get_or_null(p_multimesh);
 		return multimesh->xform_format;
 	}
 
 	_FORCE_INLINE_ bool multimesh_uses_colors(RID p_multimesh) const {
-		MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
+		MultiMesh *multimesh = multimesh_owner.get_or_null(p_multimesh);
 		return multimesh->uses_colors;
 	}
 
 	_FORCE_INLINE_ bool multimesh_uses_custom_data(RID p_multimesh) const {
-		MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
+		MultiMesh *multimesh = multimesh_owner.get_or_null(p_multimesh);
 		return multimesh->uses_custom_data;
 	}
 
 	_FORCE_INLINE_ uint32_t multimesh_get_instances_to_draw(RID p_multimesh) const {
-		MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
+		MultiMesh *multimesh = multimesh_owner.get_or_null(p_multimesh);
 		if (multimesh->visible_instances >= 0) {
 			return multimesh->visible_instances;
 		}
@@ -1731,7 +1731,7 @@ public:
 	}
 
 	_FORCE_INLINE_ RID multimesh_get_3d_uniform_set(RID p_multimesh, RID p_shader, uint32_t p_set) const {
-		MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
+		MultiMesh *multimesh = multimesh_owner.get_or_null(p_multimesh);
 		if (!multimesh->uniform_set_3d.is_valid()) {
 			Vector<RD::Uniform> uniforms;
 			RD::Uniform u;
@@ -1746,7 +1746,7 @@ public:
 	}
 
 	_FORCE_INLINE_ RID multimesh_get_2d_uniform_set(RID p_multimesh, RID p_shader, uint32_t p_set) const {
-		MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
+		MultiMesh *multimesh = multimesh_owner.get_or_null(p_multimesh);
 		if (!multimesh->uniform_set_2d.is_valid()) {
 			Vector<RD::Uniform> uniforms;
 			RD::Uniform u;
@@ -1775,11 +1775,11 @@ public:
 	Transform2D skeleton_bone_get_transform_2d(RID p_skeleton, int p_bone) const;
 
 	_FORCE_INLINE_ bool skeleton_is_valid(RID p_skeleton) {
-		return skeleton_owner.getornull(p_skeleton) != nullptr;
+		return skeleton_owner.get_or_null(p_skeleton) != nullptr;
 	}
 
 	_FORCE_INLINE_ RID skeleton_get_3d_uniform_set(RID p_skeleton, RID p_shader, uint32_t p_set) const {
-		Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);
+		Skeleton *skeleton = skeleton_owner.get_or_null(p_skeleton);
 		ERR_FAIL_COND_V(!skeleton, RID());
 		ERR_FAIL_COND_V(skeleton->size == 0, RID());
 		if (skeleton->use_2d) {
@@ -1833,7 +1833,7 @@ public:
 	RS::LightOmniShadowMode light_omni_get_shadow_mode(RID p_light);
 
 	_FORCE_INLINE_ RS::LightType light_get_type(RID p_light) const {
-		const Light *light = light_owner.getornull(p_light);
+		const Light *light = light_owner.get_or_null(p_light);
 		ERR_FAIL_COND_V(!light, RS::LIGHT_DIRECTIONAL);
 
 		return light->type;
@@ -1841,70 +1841,70 @@ public:
 	AABB light_get_aabb(RID p_light) const;
 
 	_FORCE_INLINE_ float light_get_param(RID p_light, RS::LightParam p_param) {
-		const Light *light = light_owner.getornull(p_light);
+		const Light *light = light_owner.get_or_null(p_light);
 		ERR_FAIL_COND_V(!light, 0);
 
 		return light->param[p_param];
 	}
 
 	_FORCE_INLINE_ RID light_get_projector(RID p_light) {
-		const Light *light = light_owner.getornull(p_light);
+		const Light *light = light_owner.get_or_null(p_light);
 		ERR_FAIL_COND_V(!light, RID());
 
 		return light->projector;
 	}
 
 	_FORCE_INLINE_ Color light_get_color(RID p_light) {
-		const Light *light = light_owner.getornull(p_light);
+		const Light *light = light_owner.get_or_null(p_light);
 		ERR_FAIL_COND_V(!light, Color());
 
 		return light->color;
 	}
 
 	_FORCE_INLINE_ Color light_get_shadow_color(RID p_light) {
-		const Light *light = light_owner.getornull(p_light);
+		const Light *light = light_owner.get_or_null(p_light);
 		ERR_FAIL_COND_V(!light, Color());
 
 		return light->shadow_color;
 	}
 
 	_FORCE_INLINE_ uint32_t light_get_cull_mask(RID p_light) {
-		const Light *light = light_owner.getornull(p_light);
+		const Light *light = light_owner.get_or_null(p_light);
 		ERR_FAIL_COND_V(!light, 0);
 
 		return light->cull_mask;
 	}
 
 	_FORCE_INLINE_ bool light_has_shadow(RID p_light) const {
-		const Light *light = light_owner.getornull(p_light);
+		const Light *light = light_owner.get_or_null(p_light);
 		ERR_FAIL_COND_V(!light, RS::LIGHT_DIRECTIONAL);
 
 		return light->shadow;
 	}
 
 	_FORCE_INLINE_ bool light_has_projector(RID p_light) const {
-		const Light *light = light_owner.getornull(p_light);
+		const Light *light = light_owner.get_or_null(p_light);
 		ERR_FAIL_COND_V(!light, RS::LIGHT_DIRECTIONAL);
 
 		return texture_owner.owns(light->projector);
 	}
 
 	_FORCE_INLINE_ bool light_is_negative(RID p_light) const {
-		const Light *light = light_owner.getornull(p_light);
+		const Light *light = light_owner.get_or_null(p_light);
 		ERR_FAIL_COND_V(!light, RS::LIGHT_DIRECTIONAL);
 
 		return light->negative;
 	}
 
 	_FORCE_INLINE_ float light_get_transmittance_bias(RID p_light) const {
-		const Light *light = light_owner.getornull(p_light);
+		const Light *light = light_owner.get_or_null(p_light);
 		ERR_FAIL_COND_V(!light, 0.0);
 
 		return light->param[RS::LIGHT_PARAM_TRANSMITTANCE_BIAS];
 	}
 
 	_FORCE_INLINE_ float light_get_shadow_volumetric_fog_fade(RID p_light) const {
-		const Light *light = light_owner.getornull(p_light);
+		const Light *light = light_owner.get_or_null(p_light);
 		ERR_FAIL_COND_V(!light, 0.0);
 
 		return light->param[RS::LIGHT_PARAM_SHADOW_VOLUMETRIC_FOG_FADE];
@@ -1971,62 +1971,62 @@ public:
 	virtual void decal_set_normal_fade(RID p_decal, float p_fade);
 
 	_FORCE_INLINE_ Vector3 decal_get_extents(RID p_decal) {
-		const Decal *decal = decal_owner.getornull(p_decal);
+		const Decal *decal = decal_owner.get_or_null(p_decal);
 		return decal->extents;
 	}
 
 	_FORCE_INLINE_ RID decal_get_texture(RID p_decal, RS::DecalTexture p_texture) {
-		const Decal *decal = decal_owner.getornull(p_decal);
+		const Decal *decal = decal_owner.get_or_null(p_decal);
 		return decal->textures[p_texture];
 	}
 
 	_FORCE_INLINE_ Color decal_get_modulate(RID p_decal) {
-		const Decal *decal = decal_owner.getornull(p_decal);
+		const Decal *decal = decal_owner.get_or_null(p_decal);
 		return decal->modulate;
 	}
 
 	_FORCE_INLINE_ float decal_get_emission_energy(RID p_decal) {
-		const Decal *decal = decal_owner.getornull(p_decal);
+		const Decal *decal = decal_owner.get_or_null(p_decal);
 		return decal->emission_energy;
 	}
 
 	_FORCE_INLINE_ float decal_get_albedo_mix(RID p_decal) {
-		const Decal *decal = decal_owner.getornull(p_decal);
+		const Decal *decal = decal_owner.get_or_null(p_decal);
 		return decal->albedo_mix;
 	}
 
 	_FORCE_INLINE_ uint32_t decal_get_cull_mask(RID p_decal) {
-		const Decal *decal = decal_owner.getornull(p_decal);
+		const Decal *decal = decal_owner.get_or_null(p_decal);
 		return decal->cull_mask;
 	}
 
 	_FORCE_INLINE_ float decal_get_upper_fade(RID p_decal) {
-		const Decal *decal = decal_owner.getornull(p_decal);
+		const Decal *decal = decal_owner.get_or_null(p_decal);
 		return decal->upper_fade;
 	}
 
 	_FORCE_INLINE_ float decal_get_lower_fade(RID p_decal) {
-		const Decal *decal = decal_owner.getornull(p_decal);
+		const Decal *decal = decal_owner.get_or_null(p_decal);
 		return decal->lower_fade;
 	}
 
 	_FORCE_INLINE_ float decal_get_normal_fade(RID p_decal) {
-		const Decal *decal = decal_owner.getornull(p_decal);
+		const Decal *decal = decal_owner.get_or_null(p_decal);
 		return decal->normal_fade;
 	}
 
 	_FORCE_INLINE_ bool decal_is_distance_fade_enabled(RID p_decal) {
-		const Decal *decal = decal_owner.getornull(p_decal);
+		const Decal *decal = decal_owner.get_or_null(p_decal);
 		return decal->distance_fade;
 	}
 
 	_FORCE_INLINE_ float decal_get_distance_fade_begin(RID p_decal) {
-		const Decal *decal = decal_owner.getornull(p_decal);
+		const Decal *decal = decal_owner.get_or_null(p_decal);
 		return decal->distance_fade_begin;
 	}
 
 	_FORCE_INLINE_ float decal_get_distance_fade_length(RID p_decal) {
-		const Decal *decal = decal_owner.getornull(p_decal);
+		const Decal *decal = decal_owner.get_or_null(p_decal);
 		return decal->distance_fade_length;
 	}
 
@@ -2101,18 +2101,18 @@ public:
 		return lightmap_probe_capture_update_speed;
 	}
 	_FORCE_INLINE_ RID lightmap_get_texture(RID p_lightmap) const {
-		const Lightmap *lm = lightmap_owner.getornull(p_lightmap);
+		const Lightmap *lm = lightmap_owner.get_or_null(p_lightmap);
 		ERR_FAIL_COND_V(!lm, RID());
 		return lm->light_texture;
 	}
 	_FORCE_INLINE_ int32_t lightmap_get_array_index(RID p_lightmap) const {
 		ERR_FAIL_COND_V(!using_lightmap_array, -1); //only for arrays
-		const Lightmap *lm = lightmap_owner.getornull(p_lightmap);
+		const Lightmap *lm = lightmap_owner.get_or_null(p_lightmap);
 		return lm->array_index;
 	}
 	_FORCE_INLINE_ bool lightmap_uses_spherical_harmonics(RID p_lightmap) const {
 		ERR_FAIL_COND_V(!using_lightmap_array, false); //only for arrays
-		const Lightmap *lm = lightmap_owner.getornull(p_lightmap);
+		const Lightmap *lm = lightmap_owner.get_or_null(p_lightmap);
 		return lm->uses_spherical_harmonics;
 	}
 	_FORCE_INLINE_ uint64_t lightmap_array_get_version() const {
@@ -2181,13 +2181,13 @@ public:
 	virtual bool particles_is_inactive(RID p_particles) const;
 
 	_FORCE_INLINE_ RS::ParticlesMode particles_get_mode(RID p_particles) {
-		Particles *particles = particles_owner.getornull(p_particles);
+		Particles *particles = particles_owner.get_or_null(p_particles);
 		ERR_FAIL_COND_V(!particles, RS::PARTICLES_MODE_2D);
 		return particles->mode;
 	}
 
 	_FORCE_INLINE_ uint32_t particles_get_amount(RID p_particles, uint32_t &r_trail_divisor) {
-		Particles *particles = particles_owner.getornull(p_particles);
+		Particles *particles = particles_owner.get_or_null(p_particles);
 		ERR_FAIL_COND_V(!particles, 0);
 
 		if (particles->trails_enabled && particles->trail_bind_poses.size() > 1) {
@@ -2200,21 +2200,21 @@ public:
 	}
 
 	_FORCE_INLINE_ bool particles_has_collision(RID p_particles) {
-		Particles *particles = particles_owner.getornull(p_particles);
+		Particles *particles = particles_owner.get_or_null(p_particles);
 		ERR_FAIL_COND_V(!particles, 0);
 
 		return particles->has_collision_cache;
 	}
 
 	_FORCE_INLINE_ uint32_t particles_is_using_local_coords(RID p_particles) {
-		Particles *particles = particles_owner.getornull(p_particles);
+		Particles *particles = particles_owner.get_or_null(p_particles);
 		ERR_FAIL_COND_V(!particles, false);
 
 		return particles->use_local_coords;
 	}
 
 	_FORCE_INLINE_ RID particles_get_instance_buffer_uniform_set(RID p_particles, RID p_shader, uint32_t p_set) {
-		Particles *particles = particles_owner.getornull(p_particles);
+		Particles *particles = particles_owner.get_or_null(p_particles);
 		ERR_FAIL_COND_V(!particles, RID());
 		if (particles->particles_transforms_buffer_uniform_set.is_null()) {
 			_particles_update_buffers(particles);
diff --git a/servers/rendering/renderer_rd/shader_rd.cpp b/servers/rendering/renderer_rd/shader_rd.cpp
index 82efa1318c..ffaf65ec35 100644
--- a/servers/rendering/renderer_rd/shader_rd.cpp
+++ b/servers/rendering/renderer_rd/shader_rd.cpp
@@ -292,7 +292,7 @@ void ShaderRD::_compile_variant(uint32_t p_variant, Version *p_version) {
 }
 
 RS::ShaderNativeSourceCode ShaderRD::version_get_native_source_code(RID p_version) {
-	Version *version = version_owner.getornull(p_version);
+	Version *version = version_owner.get_or_null(p_version);
 	RS::ShaderNativeSourceCode source_code;
 	ERR_FAIL_COND_V(!version, source_code);
 
@@ -524,7 +524,7 @@ void ShaderRD::_compile_version(Version *p_version) {
 void ShaderRD::version_set_code(RID p_version, const Map<String, String> &p_code, const String &p_uniforms, const String &p_vertex_globals, const String &p_fragment_globals, const Vector<String> &p_custom_defines) {
 	ERR_FAIL_COND(is_compute);
 
-	Version *version = version_owner.getornull(p_version);
+	Version *version = version_owner.get_or_null(p_version);
 	ERR_FAIL_COND(!version);
 	version->vertex_globals = p_vertex_globals.utf8();
 	version->fragment_globals = p_fragment_globals.utf8();
@@ -549,7 +549,7 @@ void ShaderRD::version_set_code(RID p_version, const Map<String, String> &p_code
 void ShaderRD::version_set_compute_code(RID p_version, const Map<String, String> &p_code, const String &p_uniforms, const String &p_compute_globals, const Vector<String> &p_custom_defines) {
 	ERR_FAIL_COND(!is_compute);
 
-	Version *version = version_owner.getornull(p_version);
+	Version *version = version_owner.get_or_null(p_version);
 	ERR_FAIL_COND(!version);
 
 	version->compute_globals = p_compute_globals.utf8();
@@ -573,7 +573,7 @@ void ShaderRD::version_set_compute_code(RID p_version, const Map<String, String>
 }
 
 bool ShaderRD::version_is_valid(RID p_version) {
-	Version *version = version_owner.getornull(p_version);
+	Version *version = version_owner.get_or_null(p_version);
 	ERR_FAIL_COND_V(!version, false);
 
 	if (version->dirty) {
@@ -585,7 +585,7 @@ bool ShaderRD::version_is_valid(RID p_version) {
 
 bool ShaderRD::version_free(RID p_version) {
 	if (version_owner.owns(p_version)) {
-		Version *version = version_owner.getornull(p_version);
+		Version *version = version_owner.get_or_null(p_version);
 		_clear_version(version);
 		version_owner.free(p_version);
 	} else {
diff --git a/servers/rendering/renderer_rd/shader_rd.h b/servers/rendering/renderer_rd/shader_rd.h
index 529328f0ed..984b168659 100644
--- a/servers/rendering/renderer_rd/shader_rd.h
+++ b/servers/rendering/renderer_rd/shader_rd.h
@@ -141,7 +141,7 @@ public:
 		ERR_FAIL_INDEX_V(p_variant, variant_defines.size(), RID());
 		ERR_FAIL_COND_V(!variants_enabled[p_variant], RID());
 
-		Version *version = version_owner.getornull(p_version);
+		Version *version = version_owner.get_or_null(p_version);
 		ERR_FAIL_COND_V(!version, RID());
 
 		if (version->dirty) {
diff --git a/servers/rendering/renderer_scene_cull.cpp b/servers/rendering/renderer_scene_cull.cpp
index a4e4715292..705e72c13d 100644
--- a/servers/rendering/renderer_scene_cull.cpp
+++ b/servers/rendering/renderer_scene_cull.cpp
@@ -47,7 +47,7 @@ void RendererSceneCull::camera_initialize(RID p_rid) {
 }
 
 void RendererSceneCull::camera_set_perspective(RID p_camera, float p_fovy_degrees, float p_z_near, float p_z_far) {
-	Camera *camera = camera_owner.getornull(p_camera);
+	Camera *camera = camera_owner.get_or_null(p_camera);
 	ERR_FAIL_COND(!camera);
 	camera->type = Camera::PERSPECTIVE;
 	camera->fov = p_fovy_degrees;
@@ -56,7 +56,7 @@ void RendererSceneCull::camera_set_perspective(RID p_camera, float p_fovy_degree
 }
 
 void RendererSceneCull::camera_set_orthogonal(RID p_camera, float p_size, float p_z_near, float p_z_far) {
-	Camera *camera = camera_owner.getornull(p_camera);
+	Camera *camera = camera_owner.get_or_null(p_camera);
 	ERR_FAIL_COND(!camera);
 	camera->type = Camera::ORTHOGONAL;
 	camera->size = p_size;
@@ -65,7 +65,7 @@ void RendererSceneCull::camera_set_orthogonal(RID p_camera, float p_size, float
 }
 
 void RendererSceneCull::camera_set_frustum(RID p_camera, float p_size, Vector2 p_offset, float p_z_near, float p_z_far) {
-	Camera *camera = camera_owner.getornull(p_camera);
+	Camera *camera = camera_owner.get_or_null(p_camera);
 	ERR_FAIL_COND(!camera);
 	camera->type = Camera::FRUSTUM;
 	camera->size = p_size;
@@ -75,32 +75,32 @@ void RendererSceneCull::camera_set_frustum(RID p_camera, float p_size, Vector2 p
 }
 
 void RendererSceneCull::camera_set_transform(RID p_camera, const Transform3D &p_transform) {
-	Camera *camera = camera_owner.getornull(p_camera);
+	Camera *camera = camera_owner.get_or_null(p_camera);
 	ERR_FAIL_COND(!camera);
 	camera->transform = p_transform.orthonormalized();
 }
 
 void RendererSceneCull::camera_set_cull_mask(RID p_camera, uint32_t p_layers) {
-	Camera *camera = camera_owner.getornull(p_camera);
+	Camera *camera = camera_owner.get_or_null(p_camera);
 	ERR_FAIL_COND(!camera);
 
 	camera->visible_layers = p_layers;
 }
 
 void RendererSceneCull::camera_set_environment(RID p_camera, RID p_env) {
-	Camera *camera = camera_owner.getornull(p_camera);
+	Camera *camera = camera_owner.get_or_null(p_camera);
 	ERR_FAIL_COND(!camera);
 	camera->env = p_env;
 }
 
 void RendererSceneCull::camera_set_camera_effects(RID p_camera, RID p_fx) {
-	Camera *camera = camera_owner.getornull(p_camera);
+	Camera *camera = camera_owner.get_or_null(p_camera);
 	ERR_FAIL_COND(!camera);
 	camera->effects = p_fx;
 }
 
 void RendererSceneCull::camera_set_use_vertical_aspect(RID p_camera, bool p_enable) {
-	Camera *camera = camera_owner.getornull(p_camera);
+	Camera *camera = camera_owner.get_or_null(p_camera);
 	ERR_FAIL_COND(!camera);
 	camera->vaspect = p_enable;
 }
@@ -354,7 +354,7 @@ RID RendererSceneCull::scenario_allocate() {
 void RendererSceneCull::scenario_initialize(RID p_rid) {
 	scenario_owner.initialize_rid(p_rid);
 
-	Scenario *scenario = scenario_owner.getornull(p_rid);
+	Scenario *scenario = scenario_owner.get_or_null(p_rid);
 	scenario->self = p_rid;
 
 	scenario->reflection_probe_shadow_atlas = scene_render->shadow_atlas_create();
@@ -373,25 +373,25 @@ void RendererSceneCull::scenario_initialize(RID p_rid) {
 }
 
 void RendererSceneCull::scenario_set_environment(RID p_scenario, RID p_environment) {
-	Scenario *scenario = scenario_owner.getornull(p_scenario);
+	Scenario *scenario = scenario_owner.get_or_null(p_scenario);
 	ERR_FAIL_COND(!scenario);
 	scenario->environment = p_environment;
 }
 
 void RendererSceneCull::scenario_set_camera_effects(RID p_scenario, RID p_camera_effects) {
-	Scenario *scenario = scenario_owner.getornull(p_scenario);
+	Scenario *scenario = scenario_owner.get_or_null(p_scenario);
 	ERR_FAIL_COND(!scenario);
 	scenario->camera_effects = p_camera_effects;
 }
 
 void RendererSceneCull::scenario_set_fallback_environment(RID p_scenario, RID p_environment) {
-	Scenario *scenario = scenario_owner.getornull(p_scenario);
+	Scenario *scenario = scenario_owner.get_or_null(p_scenario);
 	ERR_FAIL_COND(!scenario);
 	scenario->fallback_environment = p_environment;
 }
 
 void RendererSceneCull::scenario_set_reflection_atlas_size(RID p_scenario, int p_reflection_size, int p_reflection_count) {
-	Scenario *scenario = scenario_owner.getornull(p_scenario);
+	Scenario *scenario = scenario_owner.get_or_null(p_scenario);
 	ERR_FAIL_COND(!scenario);
 	scene_render->reflection_atlas_set_size(scenario->reflection_atlas, p_reflection_size, p_reflection_count);
 }
@@ -401,13 +401,13 @@ bool RendererSceneCull::is_scenario(RID p_scenario) const {
 }
 
 RID RendererSceneCull::scenario_get_environment(RID p_scenario) {
-	Scenario *scenario = scenario_owner.getornull(p_scenario);
+	Scenario *scenario = scenario_owner.get_or_null(p_scenario);
 	ERR_FAIL_COND_V(!scenario, RID());
 	return scenario->environment;
 }
 
 void RendererSceneCull::scenario_remove_viewport_visibility_mask(RID p_scenario, RID p_viewport) {
-	Scenario *scenario = scenario_owner.getornull(p_scenario);
+	Scenario *scenario = scenario_owner.get_or_null(p_scenario);
 	ERR_FAIL_COND(!scenario);
 	if (!scenario->viewport_visibility_masks.has(p_viewport)) {
 		return;
@@ -419,7 +419,7 @@ void RendererSceneCull::scenario_remove_viewport_visibility_mask(RID p_scenario,
 }
 
 void RendererSceneCull::scenario_add_viewport_visibility_mask(RID p_scenario, RID p_viewport) {
-	Scenario *scenario = scenario_owner.getornull(p_scenario);
+	Scenario *scenario = scenario_owner.get_or_null(p_scenario);
 	ERR_FAIL_COND(!scenario);
 	ERR_FAIL_COND(scenario->viewport_visibility_masks.has(p_viewport));
 
@@ -459,7 +459,7 @@ RID RendererSceneCull::instance_allocate() {
 }
 void RendererSceneCull::instance_initialize(RID p_rid) {
 	instance_owner.initialize_rid(p_rid);
-	Instance *instance = instance_owner.getornull(p_rid);
+	Instance *instance = instance_owner.get_or_null(p_rid);
 	instance->self = p_rid;
 }
 
@@ -493,7 +493,7 @@ void RendererSceneCull::_instance_update_mesh_instance(Instance *p_instance) {
 }
 
 void RendererSceneCull::instance_set_base(RID p_instance, RID p_base) {
-	Instance *instance = instance_owner.getornull(p_instance);
+	Instance *instance = instance_owner.get_or_null(p_instance);
 	ERR_FAIL_COND(!instance);
 
 	Scenario *scenario = instance->scenario;
@@ -710,7 +710,7 @@ void RendererSceneCull::instance_set_base(RID p_instance, RID p_base) {
 }
 
 void RendererSceneCull::instance_set_scenario(RID p_instance, RID p_scenario) {
-	Instance *instance = instance_owner.getornull(p_instance);
+	Instance *instance = instance_owner.get_or_null(p_instance);
 	ERR_FAIL_COND(!instance);
 
 	if (instance->scenario) {
@@ -772,7 +772,7 @@ void RendererSceneCull::instance_set_scenario(RID p_instance, RID p_scenario) {
 	}
 
 	if (p_scenario.is_valid()) {
-		Scenario *scenario = scenario_owner.getornull(p_scenario);
+		Scenario *scenario = scenario_owner.get_or_null(p_scenario);
 		ERR_FAIL_COND(!scenario);
 
 		instance->scenario = scenario;
@@ -805,7 +805,7 @@ void RendererSceneCull::instance_set_scenario(RID p_instance, RID p_scenario) {
 }
 
 void RendererSceneCull::instance_set_layer_mask(RID p_instance, uint32_t p_mask) {
-	Instance *instance = instance_owner.getornull(p_instance);
+	Instance *instance = instance_owner.get_or_null(p_instance);
 	ERR_FAIL_COND(!instance);
 
 	instance->layer_mask = p_mask;
@@ -820,7 +820,7 @@ void RendererSceneCull::instance_set_layer_mask(RID p_instance, uint32_t p_mask)
 }
 
 void RendererSceneCull::instance_set_transform(RID p_instance, const Transform3D &p_transform) {
-	Instance *instance = instance_owner.getornull(p_instance);
+	Instance *instance = instance_owner.get_or_null(p_instance);
 	ERR_FAIL_COND(!instance);
 
 	if (instance->transform == p_transform) {
@@ -845,14 +845,14 @@ void RendererSceneCull::instance_set_transform(RID p_instance, const Transform3D
 }
 
 void RendererSceneCull::instance_attach_object_instance_id(RID p_instance, ObjectID p_id) {
-	Instance *instance = instance_owner.getornull(p_instance);
+	Instance *instance = instance_owner.get_or_null(p_instance);
 	ERR_FAIL_COND(!instance);
 
 	instance->object_id = p_id;
 }
 
 void RendererSceneCull::instance_set_blend_shape_weight(RID p_instance, int p_shape, float p_weight) {
-	Instance *instance = instance_owner.getornull(p_instance);
+	Instance *instance = instance_owner.get_or_null(p_instance);
 	ERR_FAIL_COND(!instance);
 
 	if (instance->update_item.in_list()) {
@@ -865,7 +865,7 @@ void RendererSceneCull::instance_set_blend_shape_weight(RID p_instance, int p_sh
 }
 
 void RendererSceneCull::instance_set_surface_override_material(RID p_instance, int p_surface, RID p_material) {
-	Instance *instance = instance_owner.getornull(p_instance);
+	Instance *instance = instance_owner.get_or_null(p_instance);
 	ERR_FAIL_COND(!instance);
 
 	if (instance->base_type == RS::INSTANCE_MESH) {
@@ -881,7 +881,7 @@ void RendererSceneCull::instance_set_surface_override_material(RID p_instance, i
 }
 
 void RendererSceneCull::instance_set_visible(RID p_instance, bool p_visible) {
-	Instance *instance = instance_owner.getornull(p_instance);
+	Instance *instance = instance_owner.get_or_null(p_instance);
 	ERR_FAIL_COND(!instance);
 
 	if (instance->visible == p_visible) {
@@ -926,7 +926,7 @@ inline bool is_geometry_instance(RenderingServer::InstanceType p_type) {
 }
 
 void RendererSceneCull::instance_set_custom_aabb(RID p_instance, AABB p_aabb) {
-	Instance *instance = instance_owner.getornull(p_instance);
+	Instance *instance = instance_owner.get_or_null(p_instance);
 	ERR_FAIL_COND(!instance);
 	ERR_FAIL_COND(!is_geometry_instance(instance->base_type));
 
@@ -951,7 +951,7 @@ void RendererSceneCull::instance_set_custom_aabb(RID p_instance, AABB p_aabb) {
 }
 
 void RendererSceneCull::instance_attach_skeleton(RID p_instance, RID p_skeleton) {
-	Instance *instance = instance_owner.getornull(p_instance);
+	Instance *instance = instance_owner.get_or_null(p_instance);
 	ERR_FAIL_COND(!instance);
 
 	if (instance->skeleton == p_skeleton) {
@@ -976,7 +976,7 @@ void RendererSceneCull::instance_attach_skeleton(RID p_instance, RID p_skeleton)
 }
 
 void RendererSceneCull::instance_set_extra_visibility_margin(RID p_instance, real_t p_margin) {
-	Instance *instance = instance_owner.getornull(p_instance);
+	Instance *instance = instance_owner.get_or_null(p_instance);
 	ERR_FAIL_COND(!instance);
 
 	instance->extra_margin = p_margin;
@@ -985,7 +985,7 @@ void RendererSceneCull::instance_set_extra_visibility_margin(RID p_instance, rea
 
 Vector<ObjectID> RendererSceneCull::instances_cull_aabb(const AABB &p_aabb, RID p_scenario) const {
 	Vector<ObjectID> instances;
-	Scenario *scenario = scenario_owner.getornull(p_scenario);
+	Scenario *scenario = scenario_owner.get_or_null(p_scenario);
 	ERR_FAIL_COND_V(!scenario, instances);
 
 	const_cast<RendererSceneCull *>(this)->update_dirty_instances(); // check dirty instances before culling
@@ -1009,7 +1009,7 @@ Vector<ObjectID> RendererSceneCull::instances_cull_aabb(const AABB &p_aabb, RID
 
 Vector<ObjectID> RendererSceneCull::instances_cull_ray(const Vector3 &p_from, const Vector3 &p_to, RID p_scenario) const {
 	Vector<ObjectID> instances;
-	Scenario *scenario = scenario_owner.getornull(p_scenario);
+	Scenario *scenario = scenario_owner.get_or_null(p_scenario);
 	ERR_FAIL_COND_V(!scenario, instances);
 	const_cast<RendererSceneCull *>(this)->update_dirty_instances(); // check dirty instances before culling
 
@@ -1032,7 +1032,7 @@ Vector<ObjectID> RendererSceneCull::instances_cull_ray(const Vector3 &p_from, co
 
 Vector<ObjectID> RendererSceneCull::instances_cull_convex(const Vector<Plane> &p_convex, RID p_scenario) const {
 	Vector<ObjectID> instances;
-	Scenario *scenario = scenario_owner.getornull(p_scenario);
+	Scenario *scenario = scenario_owner.get_or_null(p_scenario);
 	ERR_FAIL_COND_V(!scenario, instances);
 	const_cast<RendererSceneCull *>(this)->update_dirty_instances(); // check dirty instances before culling
 
@@ -1056,7 +1056,7 @@ Vector<ObjectID> RendererSceneCull::instances_cull_convex(const Vector<Plane> &p
 }
 
 void RendererSceneCull::instance_geometry_set_flag(RID p_instance, RS::InstanceFlags p_flags, bool p_enabled) {
-	Instance *instance = instance_owner.getornull(p_instance);
+	Instance *instance = instance_owner.get_or_null(p_instance);
 	ERR_FAIL_COND(!instance);
 
 	//ERR_FAIL_COND(((1 << instance->base_type) & RS::INSTANCE_GEOMETRY_MASK));
@@ -1131,7 +1131,7 @@ void RendererSceneCull::instance_geometry_set_flag(RID p_instance, RS::InstanceF
 }
 
 void RendererSceneCull::instance_geometry_set_cast_shadows_setting(RID p_instance, RS::ShadowCastingSetting p_shadow_casting_setting) {
-	Instance *instance = instance_owner.getornull(p_instance);
+	Instance *instance = instance_owner.get_or_null(p_instance);
 	ERR_FAIL_COND(!instance);
 
 	instance->cast_shadows = p_shadow_casting_setting;
@@ -1161,7 +1161,7 @@ void RendererSceneCull::instance_geometry_set_cast_shadows_setting(RID p_instanc
 }
 
 void RendererSceneCull::instance_geometry_set_material_override(RID p_instance, RID p_material) {
-	Instance *instance = instance_owner.getornull(p_instance);
+	Instance *instance = instance_owner.get_or_null(p_instance);
 	ERR_FAIL_COND(!instance);
 
 	instance->material_override = p_material;
@@ -1174,7 +1174,7 @@ void RendererSceneCull::instance_geometry_set_material_override(RID p_instance,
 }
 
 void RendererSceneCull::instance_geometry_set_visibility_range(RID p_instance, float p_min, float p_max, float p_min_margin, float p_max_margin) {
-	Instance *instance = instance_owner.getornull(p_instance);
+	Instance *instance = instance_owner.get_or_null(p_instance);
 	ERR_FAIL_COND(!instance);
 
 	instance->visibility_range_begin = p_min;
@@ -1194,7 +1194,7 @@ void RendererSceneCull::instance_geometry_set_visibility_range(RID p_instance, f
 }
 
 void RendererSceneCull::instance_set_visibility_parent(RID p_instance, RID p_parent_instance) {
-	Instance *instance = instance_owner.getornull(p_instance);
+	Instance *instance = instance_owner.get_or_null(p_instance);
 	ERR_FAIL_COND(!instance);
 
 	Instance *old_parent = instance->visibility_parent;
@@ -1207,7 +1207,7 @@ void RendererSceneCull::instance_set_visibility_parent(RID p_instance, RID p_par
 		instance->visibility_parent = nullptr;
 	}
 
-	Instance *parent = instance_owner.getornull(p_parent_instance);
+	Instance *parent = instance_owner.get_or_null(p_parent_instance);
 	ERR_FAIL_COND(p_parent_instance.is_valid() && !parent);
 
 	if (parent) {
@@ -1312,7 +1312,7 @@ void RendererSceneCull::_update_instance_visibility_dependencies(Instance *p_ins
 }
 
 void RendererSceneCull::instance_geometry_set_lightmap(RID p_instance, RID p_lightmap, const Rect2 &p_lightmap_uv_scale, int p_slice_index) {
-	Instance *instance = instance_owner.getornull(p_instance);
+	Instance *instance = instance_owner.get_or_null(p_instance);
 	ERR_FAIL_COND(!instance);
 
 	if (instance->lightmap) {
@@ -1321,7 +1321,7 @@ void RendererSceneCull::instance_geometry_set_lightmap(RID p_instance, RID p_lig
 		instance->lightmap = nullptr;
 	}
 
-	Instance *lightmap_instance = instance_owner.getornull(p_lightmap);
+	Instance *lightmap_instance = instance_owner.get_or_null(p_lightmap);
 
 	instance->lightmap = lightmap_instance;
 	instance->lightmap_uv_scale = p_lightmap_uv_scale;
@@ -1342,7 +1342,7 @@ void RendererSceneCull::instance_geometry_set_lightmap(RID p_instance, RID p_lig
 }
 
 void RendererSceneCull::instance_geometry_set_lod_bias(RID p_instance, float p_lod_bias) {
-	Instance *instance = instance_owner.getornull(p_instance);
+	Instance *instance = instance_owner.get_or_null(p_instance);
 	ERR_FAIL_COND(!instance);
 
 	instance->lod_bias = p_lod_bias;
@@ -1354,7 +1354,7 @@ void RendererSceneCull::instance_geometry_set_lod_bias(RID p_instance, float p_l
 }
 
 void RendererSceneCull::instance_geometry_set_shader_parameter(RID p_instance, const StringName &p_parameter, const Variant &p_value) {
-	Instance *instance = instance_owner.getornull(p_instance);
+	Instance *instance = instance_owner.get_or_null(p_instance);
 	ERR_FAIL_COND(!instance);
 
 	ERR_FAIL_COND(p_value.get_type() == Variant::OBJECT);
@@ -1377,7 +1377,7 @@ void RendererSceneCull::instance_geometry_set_shader_parameter(RID p_instance, c
 }
 
 Variant RendererSceneCull::instance_geometry_get_shader_parameter(RID p_instance, const StringName &p_parameter) const {
-	const Instance *instance = const_cast<RendererSceneCull *>(this)->instance_owner.getornull(p_instance);
+	const Instance *instance = const_cast<RendererSceneCull *>(this)->instance_owner.get_or_null(p_instance);
 	ERR_FAIL_COND_V(!instance, Variant());
 
 	if (instance->instance_shader_parameters.has(p_parameter)) {
@@ -1387,7 +1387,7 @@ Variant RendererSceneCull::instance_geometry_get_shader_parameter(RID p_instance
 }
 
 Variant RendererSceneCull::instance_geometry_get_shader_parameter_default_value(RID p_instance, const StringName &p_parameter) const {
-	const Instance *instance = const_cast<RendererSceneCull *>(this)->instance_owner.getornull(p_instance);
+	const Instance *instance = const_cast<RendererSceneCull *>(this)->instance_owner.get_or_null(p_instance);
 	ERR_FAIL_COND_V(!instance, Variant());
 
 	if (instance->instance_shader_parameters.has(p_parameter)) {
@@ -1397,7 +1397,7 @@ Variant RendererSceneCull::instance_geometry_get_shader_parameter_default_value(
 }
 
 void RendererSceneCull::instance_geometry_get_shader_parameter_list(RID p_instance, List<PropertyInfo> *p_parameters) const {
-	const Instance *instance = const_cast<RendererSceneCull *>(this)->instance_owner.getornull(p_instance);
+	const Instance *instance = const_cast<RendererSceneCull *>(this)->instance_owner.get_or_null(p_instance);
 	ERR_FAIL_COND(!instance);
 
 	const_cast<RendererSceneCull *>(this)->update_dirty_instances();
@@ -2354,7 +2354,7 @@ bool RendererSceneCull::_light_instance_update_shadow(Instance *p_instance, cons
 void RendererSceneCull::render_camera(RID p_render_buffers, RID p_camera, RID p_scenario, RID p_viewport, Size2 p_viewport_size, float p_screen_lod_threshold, RID p_shadow_atlas, Ref<XRInterface> &p_xr_interface, RenderInfo *r_render_info) {
 #ifndef _3D_DISABLED
 
-	Camera *camera = camera_owner.getornull(p_camera);
+	Camera *camera = camera_owner.get_or_null(p_camera);
 	ERR_FAIL_COND(!camera);
 
 	RendererSceneRender::CameraData camera_data;
@@ -2747,9 +2747,9 @@ void RendererSceneCull::_scene_cull(CullData &cull_data, InstanceCullResult &cul
 }
 
 void RendererSceneCull::_render_scene(const RendererSceneRender::CameraData *p_camera_data, RID p_render_buffers, RID p_environment, RID p_force_camera_effects, uint32_t p_visible_layers, RID p_scenario, RID p_viewport, RID p_shadow_atlas, RID p_reflection_probe, int p_reflection_probe_pass, float p_screen_lod_threshold, bool p_using_shadows, RendererScene::RenderInfo *r_render_info) {
-	Instance *render_reflection_probe = instance_owner.getornull(p_reflection_probe); //if null, not rendering to it
+	Instance *render_reflection_probe = instance_owner.get_or_null(p_reflection_probe); //if null, not rendering to it
 
-	Scenario *scenario = scenario_owner.getornull(p_scenario);
+	Scenario *scenario = scenario_owner.get_or_null(p_scenario);
 
 	render_pass++;
 
@@ -3103,12 +3103,12 @@ void RendererSceneCull::_render_scene(const RendererSceneRender::CameraData *p_c
 }
 
 RID RendererSceneCull::_render_get_environment(RID p_camera, RID p_scenario) {
-	Camera *camera = camera_owner.getornull(p_camera);
+	Camera *camera = camera_owner.get_or_null(p_camera);
 	if (camera && scene_render->is_environment(camera->env)) {
 		return camera->env;
 	}
 
-	Scenario *scenario = scenario_owner.getornull(p_scenario);
+	Scenario *scenario = scenario_owner.get_or_null(p_scenario);
 	if (!scenario) {
 		return RID();
 	}
@@ -3125,7 +3125,7 @@ RID RendererSceneCull::_render_get_environment(RID p_camera, RID p_scenario) {
 
 void RendererSceneCull::render_empty_scene(RID p_render_buffers, RID p_scenario, RID p_shadow_atlas) {
 #ifndef _3D_DISABLED
-	Scenario *scenario = scenario_owner.getornull(p_scenario);
+	Scenario *scenario = scenario_owner.get_or_null(p_scenario);
 
 	RID environment;
 	if (scenario->environment.is_valid()) {
@@ -3750,7 +3750,7 @@ bool RendererSceneCull::free(RID p_rid) {
 		camera_owner.free(p_rid);
 
 	} else if (scenario_owner.owns(p_rid)) {
-		Scenario *scenario = scenario_owner.getornull(p_rid);
+		Scenario *scenario = scenario_owner.get_or_null(p_rid);
 
 		while (scenario->instances.first()) {
 			instance_set_scenario(scenario->instances.first()->self()->self, RID());
@@ -3771,7 +3771,7 @@ bool RendererSceneCull::free(RID p_rid) {
 
 		update_dirty_instances();
 
-		Instance *instance = instance_owner.getornull(p_rid);
+		Instance *instance = instance_owner.get_or_null(p_rid);
 
 		instance_geometry_set_lightmap(p_rid, RID(), Rect2(), 0);
 		instance_set_scenario(p_rid, RID());
diff --git a/servers/rendering/renderer_viewport.cpp b/servers/rendering/renderer_viewport.cpp
index 8af2049ab3..2c07929357 100644
--- a/servers/rendering/renderer_viewport.cpp
+++ b/servers/rendering/renderer_viewport.cpp
@@ -554,7 +554,7 @@ void RendererViewport::draw_viewports() {
 		}
 
 		if (vp->update_mode == RS::VIEWPORT_UPDATE_WHEN_PARENT_VISIBLE) {
-			Viewport *parent = viewport_owner.getornull(vp->parent);
+			Viewport *parent = viewport_owner.get_or_null(vp->parent);
 			if (parent && parent->last_pass == draw_viewports_pass) {
 				visible = true;
 			}
@@ -671,7 +671,7 @@ RID RendererViewport::viewport_allocate() {
 
 void RendererViewport::viewport_initialize(RID p_rid) {
 	viewport_owner.initialize_rid(p_rid);
-	Viewport *viewport = viewport_owner.getornull(p_rid);
+	Viewport *viewport = viewport_owner.get_or_null(p_rid);
 	viewport->self = p_rid;
 	viewport->render_target = RSG::storage->render_target_create();
 	viewport->shadow_atlas = RSG::scene->shadow_atlas_create();
@@ -679,7 +679,7 @@ void RendererViewport::viewport_initialize(RID p_rid) {
 }
 
 void RendererViewport::viewport_set_use_xr(RID p_viewport, bool p_use_xr) {
-	Viewport *viewport = viewport_owner.getornull(p_viewport);
+	Viewport *viewport = viewport_owner.get_or_null(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
 	if (viewport->use_xr == p_use_xr) {
@@ -691,7 +691,7 @@ void RendererViewport::viewport_set_use_xr(RID p_viewport, bool p_use_xr) {
 }
 
 void RendererViewport::viewport_set_scale_3d(RID p_viewport, RenderingServer::ViewportScale3D p_scale_3d) {
-	Viewport *viewport = viewport_owner.getornull(p_viewport);
+	Viewport *viewport = viewport_owner.get_or_null(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
 	if (viewport->scale_3d == p_scale_3d) {
@@ -720,7 +720,7 @@ uint32_t RendererViewport::Viewport::get_view_count() {
 void RendererViewport::viewport_set_size(RID p_viewport, int p_width, int p_height) {
 	ERR_FAIL_COND(p_width < 0 && p_height < 0);
 
-	Viewport *viewport = viewport_owner.getornull(p_viewport);
+	Viewport *viewport = viewport_owner.get_or_null(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
 	viewport->size = Size2(p_width, p_height);
@@ -732,7 +732,7 @@ void RendererViewport::viewport_set_size(RID p_viewport, int p_width, int p_heig
 }
 
 void RendererViewport::viewport_set_active(RID p_viewport, bool p_active) {
-	Viewport *viewport = viewport_owner.getornull(p_viewport);
+	Viewport *viewport = viewport_owner.get_or_null(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
 	if (p_active) {
@@ -745,21 +745,21 @@ void RendererViewport::viewport_set_active(RID p_viewport, bool p_active) {
 }
 
 void RendererViewport::viewport_set_parent_viewport(RID p_viewport, RID p_parent_viewport) {
-	Viewport *viewport = viewport_owner.getornull(p_viewport);
+	Viewport *viewport = viewport_owner.get_or_null(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
 	viewport->parent = p_parent_viewport;
 }
 
 void RendererViewport::viewport_set_clear_mode(RID p_viewport, RS::ViewportClearMode p_clear_mode) {
-	Viewport *viewport = viewport_owner.getornull(p_viewport);
+	Viewport *viewport = viewport_owner.get_or_null(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
 	viewport->clear_mode = p_clear_mode;
 }
 
 void RendererViewport::viewport_attach_to_screen(RID p_viewport, const Rect2 &p_rect, DisplayServer::WindowID p_screen) {
-	Viewport *viewport = viewport_owner.getornull(p_viewport);
+	Viewport *viewport = viewport_owner.get_or_null(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
 	if (p_screen != DisplayServer::INVALID_WINDOW_ID) {
@@ -785,7 +785,7 @@ void RendererViewport::viewport_attach_to_screen(RID p_viewport, const Rect2 &p_
 }
 
 void RendererViewport::viewport_set_render_direct_to_screen(RID p_viewport, bool p_enable) {
-	Viewport *viewport = viewport_owner.getornull(p_viewport);
+	Viewport *viewport = viewport_owner.get_or_null(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
 	if (p_enable == viewport->viewport_render_direct_to_screen) {
@@ -809,21 +809,21 @@ void RendererViewport::viewport_set_render_direct_to_screen(RID p_viewport, bool
 }
 
 void RendererViewport::viewport_set_update_mode(RID p_viewport, RS::ViewportUpdateMode p_mode) {
-	Viewport *viewport = viewport_owner.getornull(p_viewport);
+	Viewport *viewport = viewport_owner.get_or_null(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
 	viewport->update_mode = p_mode;
 }
 
 RID RendererViewport::viewport_get_texture(RID p_viewport) const {
-	const Viewport *viewport = viewport_owner.getornull(p_viewport);
+	const Viewport *viewport = viewport_owner.get_or_null(p_viewport);
 	ERR_FAIL_COND_V(!viewport, RID());
 
 	return RSG::storage->render_target_get_texture(viewport->render_target);
 }
 
 RID RendererViewport::viewport_get_occluder_debug_texture(RID p_viewport) const {
-	const Viewport *viewport = viewport_owner.getornull(p_viewport);
+	const Viewport *viewport = viewport_owner.get_or_null(p_viewport);
 	ERR_FAIL_COND_V(!viewport, RID());
 
 	if (viewport->use_occlusion_culling && viewport->debug_draw == RenderingServer::VIEWPORT_DEBUG_DRAW_OCCLUDERS) {
@@ -833,35 +833,35 @@ RID RendererViewport::viewport_get_occluder_debug_texture(RID p_viewport) const
 }
 
 void RendererViewport::viewport_set_disable_2d(RID p_viewport, bool p_disable) {
-	Viewport *viewport = viewport_owner.getornull(p_viewport);
+	Viewport *viewport = viewport_owner.get_or_null(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
 	viewport->disable_2d = p_disable;
 }
 
 void RendererViewport::viewport_set_disable_environment(RID p_viewport, bool p_disable) {
-	Viewport *viewport = viewport_owner.getornull(p_viewport);
+	Viewport *viewport = viewport_owner.get_or_null(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
 	viewport->disable_environment = p_disable;
 }
 
 void RendererViewport::viewport_set_disable_3d(RID p_viewport, bool p_disable) {
-	Viewport *viewport = viewport_owner.getornull(p_viewport);
+	Viewport *viewport = viewport_owner.get_or_null(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
 	viewport->disable_3d = p_disable;
 }
 
 void RendererViewport::viewport_attach_camera(RID p_viewport, RID p_camera) {
-	Viewport *viewport = viewport_owner.getornull(p_viewport);
+	Viewport *viewport = viewport_owner.get_or_null(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
 	viewport->camera = p_camera;
 }
 
 void RendererViewport::viewport_set_scenario(RID p_viewport, RID p_scenario) {
-	Viewport *viewport = viewport_owner.getornull(p_viewport);
+	Viewport *viewport = viewport_owner.get_or_null(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
 	if (viewport->scenario.is_valid()) {
@@ -875,11 +875,11 @@ void RendererViewport::viewport_set_scenario(RID p_viewport, RID p_scenario) {
 }
 
 void RendererViewport::viewport_attach_canvas(RID p_viewport, RID p_canvas) {
-	Viewport *viewport = viewport_owner.getornull(p_viewport);
+	Viewport *viewport = viewport_owner.get_or_null(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
 	ERR_FAIL_COND(viewport->canvas_map.has(p_canvas));
-	RendererCanvasCull::Canvas *canvas = RSG::canvas->canvas_owner.getornull(p_canvas);
+	RendererCanvasCull::Canvas *canvas = RSG::canvas->canvas_owner.get_or_null(p_canvas);
 	ERR_FAIL_COND(!canvas);
 
 	canvas->viewports.insert(p_viewport);
@@ -890,10 +890,10 @@ void RendererViewport::viewport_attach_canvas(RID p_viewport, RID p_canvas) {
 }
 
 void RendererViewport::viewport_remove_canvas(RID p_viewport, RID p_canvas) {
-	Viewport *viewport = viewport_owner.getornull(p_viewport);
+	Viewport *viewport = viewport_owner.get_or_null(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
-	RendererCanvasCull::Canvas *canvas = RSG::canvas->canvas_owner.getornull(p_canvas);
+	RendererCanvasCull::Canvas *canvas = RSG::canvas->canvas_owner.get_or_null(p_canvas);
 	ERR_FAIL_COND(!canvas);
 
 	viewport->canvas_map.erase(p_canvas);
@@ -901,7 +901,7 @@ void RendererViewport::viewport_remove_canvas(RID p_viewport, RID p_canvas) {
 }
 
 void RendererViewport::viewport_set_canvas_transform(RID p_viewport, RID p_canvas, const Transform2D &p_offset) {
-	Viewport *viewport = viewport_owner.getornull(p_viewport);
+	Viewport *viewport = viewport_owner.get_or_null(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
 	ERR_FAIL_COND(!viewport->canvas_map.has(p_canvas));
@@ -909,7 +909,7 @@ void RendererViewport::viewport_set_canvas_transform(RID p_viewport, RID p_canva
 }
 
 void RendererViewport::viewport_set_transparent_background(RID p_viewport, bool p_enabled) {
-	Viewport *viewport = viewport_owner.getornull(p_viewport);
+	Viewport *viewport = viewport_owner.get_or_null(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
 	RSG::storage->render_target_set_flag(viewport->render_target, RendererStorage::RENDER_TARGET_TRANSPARENT, p_enabled);
@@ -917,14 +917,14 @@ void RendererViewport::viewport_set_transparent_background(RID p_viewport, bool
 }
 
 void RendererViewport::viewport_set_global_canvas_transform(RID p_viewport, const Transform2D &p_transform) {
-	Viewport *viewport = viewport_owner.getornull(p_viewport);
+	Viewport *viewport = viewport_owner.get_or_null(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
 	viewport->global_transform = p_transform;
 }
 
 void RendererViewport::viewport_set_canvas_stacking(RID p_viewport, RID p_canvas, int p_layer, int p_sublayer) {
-	Viewport *viewport = viewport_owner.getornull(p_viewport);
+	Viewport *viewport = viewport_owner.get_or_null(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
 	ERR_FAIL_COND(!viewport->canvas_map.has(p_canvas));
@@ -933,7 +933,7 @@ void RendererViewport::viewport_set_canvas_stacking(RID p_viewport, RID p_canvas
 }
 
 void RendererViewport::viewport_set_shadow_atlas_size(RID p_viewport, int p_size, bool p_16_bits) {
-	Viewport *viewport = viewport_owner.getornull(p_viewport);
+	Viewport *viewport = viewport_owner.get_or_null(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
 	viewport->shadow_atlas_size = p_size;
@@ -943,14 +943,14 @@ void RendererViewport::viewport_set_shadow_atlas_size(RID p_viewport, int p_size
 }
 
 void RendererViewport::viewport_set_shadow_atlas_quadrant_subdivision(RID p_viewport, int p_quadrant, int p_subdiv) {
-	Viewport *viewport = viewport_owner.getornull(p_viewport);
+	Viewport *viewport = viewport_owner.get_or_null(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
 	RSG::scene->shadow_atlas_set_quadrant_subdivision(viewport->shadow_atlas, p_quadrant, p_subdiv);
 }
 
 void RendererViewport::viewport_set_msaa(RID p_viewport, RS::ViewportMSAA p_msaa) {
-	Viewport *viewport = viewport_owner.getornull(p_viewport);
+	Viewport *viewport = viewport_owner.get_or_null(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
 	if (viewport->msaa == p_msaa) {
@@ -961,7 +961,7 @@ void RendererViewport::viewport_set_msaa(RID p_viewport, RS::ViewportMSAA p_msaa
 }
 
 void RendererViewport::viewport_set_screen_space_aa(RID p_viewport, RS::ViewportScreenSpaceAA p_mode) {
-	Viewport *viewport = viewport_owner.getornull(p_viewport);
+	Viewport *viewport = viewport_owner.get_or_null(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
 	if (viewport->screen_space_aa == p_mode) {
@@ -972,7 +972,7 @@ void RendererViewport::viewport_set_screen_space_aa(RID p_viewport, RS::Viewport
 }
 
 void RendererViewport::viewport_set_use_debanding(RID p_viewport, bool p_use_debanding) {
-	Viewport *viewport = viewport_owner.getornull(p_viewport);
+	Viewport *viewport = viewport_owner.get_or_null(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
 	if (viewport->use_debanding == p_use_debanding) {
@@ -983,7 +983,7 @@ void RendererViewport::viewport_set_use_debanding(RID p_viewport, bool p_use_deb
 }
 
 void RendererViewport::viewport_set_use_occlusion_culling(RID p_viewport, bool p_use_occlusion_culling) {
-	Viewport *viewport = viewport_owner.getornull(p_viewport);
+	Viewport *viewport = viewport_owner.get_or_null(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
 	if (viewport->use_occlusion_culling == p_use_occlusion_culling) {
@@ -1018,7 +1018,7 @@ void RendererViewport::viewport_set_occlusion_culling_build_quality(RS::Viewport
 }
 
 void RendererViewport::viewport_set_lod_threshold(RID p_viewport, float p_pixels) {
-	Viewport *viewport = viewport_owner.getornull(p_viewport);
+	Viewport *viewport = viewport_owner.get_or_null(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
 	viewport->lod_threshold = p_pixels;
@@ -1027,7 +1027,7 @@ void RendererViewport::viewport_set_lod_threshold(RID p_viewport, float p_pixels
 int RendererViewport::viewport_get_render_info(RID p_viewport, RS::ViewportRenderInfoType p_type, RS::ViewportRenderInfo p_info) {
 	ERR_FAIL_INDEX_V(p_info, RS::VIEWPORT_RENDER_INFO_MAX, -1);
 
-	Viewport *viewport = viewport_owner.getornull(p_viewport);
+	Viewport *viewport = viewport_owner.get_or_null(p_viewport);
 	if (!viewport) {
 		return 0; //there should be a lock here..
 	}
@@ -1036,62 +1036,62 @@ int RendererViewport::viewport_get_render_info(RID p_viewport, RS::ViewportRende
 }
 
 void RendererViewport::viewport_set_debug_draw(RID p_viewport, RS::ViewportDebugDraw p_draw) {
-	Viewport *viewport = viewport_owner.getornull(p_viewport);
+	Viewport *viewport = viewport_owner.get_or_null(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
 	viewport->debug_draw = p_draw;
 }
 
 void RendererViewport::viewport_set_measure_render_time(RID p_viewport, bool p_enable) {
-	Viewport *viewport = viewport_owner.getornull(p_viewport);
+	Viewport *viewport = viewport_owner.get_or_null(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
 	viewport->measure_render_time = p_enable;
 }
 
 float RendererViewport::viewport_get_measured_render_time_cpu(RID p_viewport) const {
-	Viewport *viewport = viewport_owner.getornull(p_viewport);
+	Viewport *viewport = viewport_owner.get_or_null(p_viewport);
 	ERR_FAIL_COND_V(!viewport, 0);
 
 	return double(viewport->time_cpu_end - viewport->time_cpu_begin) / 1000.0;
 }
 
 float RendererViewport::viewport_get_measured_render_time_gpu(RID p_viewport) const {
-	Viewport *viewport = viewport_owner.getornull(p_viewport);
+	Viewport *viewport = viewport_owner.get_or_null(p_viewport);
 	ERR_FAIL_COND_V(!viewport, 0);
 
 	return double((viewport->time_gpu_end - viewport->time_gpu_begin) / 1000) / 1000.0;
 }
 
 void RendererViewport::viewport_set_snap_2d_transforms_to_pixel(RID p_viewport, bool p_enabled) {
-	Viewport *viewport = viewport_owner.getornull(p_viewport);
+	Viewport *viewport = viewport_owner.get_or_null(p_viewport);
 	ERR_FAIL_COND(!viewport);
 	viewport->snap_2d_transforms_to_pixel = p_enabled;
 }
 
 void RendererViewport::viewport_set_snap_2d_vertices_to_pixel(RID p_viewport, bool p_enabled) {
-	Viewport *viewport = viewport_owner.getornull(p_viewport);
+	Viewport *viewport = viewport_owner.get_or_null(p_viewport);
 	ERR_FAIL_COND(!viewport);
 	viewport->snap_2d_vertices_to_pixel = p_enabled;
 }
 
 void RendererViewport::viewport_set_default_canvas_item_texture_filter(RID p_viewport, RS::CanvasItemTextureFilter p_filter) {
 	ERR_FAIL_COND_MSG(p_filter == RS::CANVAS_ITEM_TEXTURE_FILTER_DEFAULT, "Viewport does not accept DEFAULT as texture filter (it's the topmost choice already).)");
-	Viewport *viewport = viewport_owner.getornull(p_viewport);
+	Viewport *viewport = viewport_owner.get_or_null(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
 	viewport->texture_filter = p_filter;
 }
 void RendererViewport::viewport_set_default_canvas_item_texture_repeat(RID p_viewport, RS::CanvasItemTextureRepeat p_repeat) {
 	ERR_FAIL_COND_MSG(p_repeat == RS::CANVAS_ITEM_TEXTURE_REPEAT_DEFAULT, "Viewport does not accept DEFAULT as texture repeat (it's the topmost choice already).)");
-	Viewport *viewport = viewport_owner.getornull(p_viewport);
+	Viewport *viewport = viewport_owner.get_or_null(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
 	viewport->texture_repeat = p_repeat;
 }
 
 void RendererViewport::viewport_set_sdf_oversize_and_scale(RID p_viewport, RS::ViewportSDFOversize p_size, RS::ViewportSDFScale p_scale) {
-	Viewport *viewport = viewport_owner.getornull(p_viewport);
+	Viewport *viewport = viewport_owner.get_or_null(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
 	RSG::storage->render_target_set_sdf_size_and_scale(viewport->render_target, p_size, p_scale);
@@ -1099,7 +1099,7 @@ void RendererViewport::viewport_set_sdf_oversize_and_scale(RID p_viewport, RS::V
 
 bool RendererViewport::free(RID p_rid) {
 	if (viewport_owner.owns(p_rid)) {
-		Viewport *viewport = viewport_owner.getornull(p_rid);
+		Viewport *viewport = viewport_owner.get_or_null(p_rid);
 
 		RSG::storage->free(viewport->render_target);
 		RSG::scene->free(viewport->shadow_atlas);
@@ -1132,7 +1132,7 @@ void RendererViewport::handle_timestamp(String p_timestamp, uint64_t p_cpu_time,
 		return;
 	}
 
-	Viewport *viewport = viewport_owner.getornull(*vp);
+	Viewport *viewport = viewport_owner.get_or_null(*vp);
 	if (!viewport) {
 		return;
 	}