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

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) {

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);

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);
 }

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);

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) {

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;

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()) {

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;

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());
 

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;

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);
 

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);

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);

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);

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);

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) {

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;
 	}
 

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) {

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);

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 {

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) {

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());

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;
 	}