Discern between virtual and abstract class bindings

* Previous "virtual" classes (which can't be instantiated) are not corretly named "abstract".
* Added a new "virtual" category for classes, they can't be instantiated from the editor, but can be inherited from script and extensions.
* Converted a large amount of classes from "abstract" to "virtual" where it makes sense.

Most classes that make sense have been converted. Missing:

* Physics servers
* VideoStream
* Script* classes.

which will go in a separate PR due to the complexity involved.

10 files changed, 484 insertions, 55 deletions

diff --git a/scene/resources/material.cpp b/scene/resources/material.cpp
index 6fb0c0468d..a0e6cc28ce 100644
--- a/scene/resources/material.cpp
+++ b/scene/resources/material.cpp
@@ -88,6 +88,37 @@ void Material::inspect_native_shader_code() {
 	}
 }
 
+RID Material::get_shader_rid() const {
+	RID ret;
+	if (GDVIRTUAL_REQUIRED_CALL(_get_shader_rid, ret)) {
+		return ret;
+	}
+	return RID();
+}
+Shader::Mode Material::get_shader_mode() const {
+	Shader::Mode ret;
+	if (GDVIRTUAL_REQUIRED_CALL(_get_shader_mode, ret)) {
+		return ret;
+	}
+
+	return Shader::MODE_MAX;
+}
+
+bool Material::_can_do_next_pass() const {
+	bool ret;
+	if (GDVIRTUAL_CALL(_can_do_next_pass, ret)) {
+		return ret;
+	}
+	return false;
+}
+bool Material::_can_use_render_priority() const {
+	bool ret;
+	if (GDVIRTUAL_CALL(_can_use_render_priority, ret)) {
+		return ret;
+	}
+	return false;
+}
+
 void Material::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("set_next_pass", "next_pass"), &Material::set_next_pass);
 	ClassDB::bind_method(D_METHOD("get_next_pass"), &Material::get_next_pass);
@@ -103,6 +134,11 @@ void Material::_bind_methods() {
 
 	BIND_CONSTANT(RENDER_PRIORITY_MAX);
 	BIND_CONSTANT(RENDER_PRIORITY_MIN);
+
+	GDVIRTUAL_BIND(_get_shader_rid)
+	GDVIRTUAL_BIND(_get_shader_mode)
+	GDVIRTUAL_BIND(_can_do_next_pass)
+	GDVIRTUAL_BIND(_can_use_render_priority)
 }
 
 Material::Material() {
diff --git a/scene/resources/material.h b/scene/resources/material.h
index a79f072f9a..07227c037c 100644
--- a/scene/resources/material.h
+++ b/scene/resources/material.h
@@ -51,11 +51,15 @@ class Material : public Resource {
 protected:
 	_FORCE_INLINE_ RID _get_material() const { return material; }
 	static void _bind_methods();
-	virtual bool _can_do_next_pass() const { return false; }
-	virtual bool _can_use_render_priority() const { return false; }
+	virtual bool _can_do_next_pass() const;
+	virtual bool _can_use_render_priority() const;
 
 	void _validate_property(PropertyInfo &property) const override;
 
+	GDVIRTUAL0RC(RID, _get_shader_rid)
+	GDVIRTUAL0RC(Shader::Mode, _get_shader_mode)
+	GDVIRTUAL0RC(bool, _can_do_next_pass)
+	GDVIRTUAL0RC(bool, _can_use_render_priority)
 public:
 	enum {
 		RENDER_PRIORITY_MAX = RS::MATERIAL_RENDER_PRIORITY_MAX,
@@ -68,9 +72,8 @@ public:
 	int get_render_priority() const;
 
 	virtual RID get_rid() const override;
-	virtual RID get_shader_rid() const = 0;
-
-	virtual Shader::Mode get_shader_mode() const = 0;
+	virtual RID get_shader_rid() const;
+	virtual Shader::Mode get_shader_mode() const;
 	Material();
 	virtual ~Material();
 };
diff --git a/scene/resources/mesh.cpp b/scene/resources/mesh.cpp
index 6b44b05e02..3c67a20f50 100644
--- a/scene/resources/mesh.cpp
+++ b/scene/resources/mesh.cpp
@@ -40,6 +40,122 @@
 
 Mesh::ConvexDecompositionFunc Mesh::convex_decomposition_function = nullptr;
 
+int Mesh::get_surface_count() const {
+	int ret;
+	if (GDVIRTUAL_REQUIRED_CALL(_get_surface_count, ret)) {
+		return ret;
+	}
+	return 0;
+}
+
+int Mesh::surface_get_array_len(int p_idx) const {
+	int ret;
+	if (GDVIRTUAL_REQUIRED_CALL(_surface_get_array_len, p_idx, ret)) {
+		return ret;
+	}
+	return 0;
+}
+
+int Mesh::surface_get_array_index_len(int p_idx) const {
+	int ret;
+	if (GDVIRTUAL_REQUIRED_CALL(_surface_get_array_index_len, p_idx, ret)) {
+		return ret;
+	}
+	return 0;
+}
+
+Array Mesh::surface_get_arrays(int p_surface) const {
+	Array ret;
+	if (GDVIRTUAL_REQUIRED_CALL(_surface_get_arrays, p_surface, ret)) {
+		return ret;
+	}
+	return Array();
+}
+
+Array Mesh::surface_get_blend_shape_arrays(int p_surface) const {
+	Array ret;
+	if (GDVIRTUAL_REQUIRED_CALL(_surface_get_blend_shape_arrays, p_surface, ret)) {
+		return ret;
+	}
+
+	return Array();
+}
+
+Dictionary Mesh::surface_get_lods(int p_surface) const {
+	Dictionary ret;
+	if (GDVIRTUAL_REQUIRED_CALL(_surface_get_lods, p_surface, ret)) {
+		return ret;
+	}
+
+	return Dictionary();
+}
+
+uint32_t Mesh::surface_get_format(int p_idx) const {
+	uint32_t ret;
+	if (GDVIRTUAL_REQUIRED_CALL(_surface_get_format, p_idx, ret)) {
+		return ret;
+	}
+
+	return 0;
+}
+
+Mesh::PrimitiveType Mesh::surface_get_primitive_type(int p_idx) const {
+	uint32_t ret;
+	if (GDVIRTUAL_REQUIRED_CALL(_surface_get_primitive_type, p_idx, ret)) {
+		return (Mesh::PrimitiveType)ret;
+	}
+
+	return PRIMITIVE_MAX;
+}
+
+void Mesh::surface_set_material(int p_idx, const Ref<Material> &p_material) {
+	if (GDVIRTUAL_REQUIRED_CALL(_surface_set_material, p_idx, p_material)) {
+		return;
+	}
+}
+
+Ref<Material> Mesh::surface_get_material(int p_idx) const {
+	Ref<Material> ret;
+	if (GDVIRTUAL_REQUIRED_CALL(_surface_get_material, p_idx, ret)) {
+		return ret;
+	}
+
+	return Ref<Material>();
+}
+
+int Mesh::get_blend_shape_count() const {
+	int ret;
+	if (GDVIRTUAL_REQUIRED_CALL(_get_blend_shape_count, ret)) {
+		return ret;
+	}
+
+	return 0;
+}
+
+StringName Mesh::get_blend_shape_name(int p_index) const {
+	StringName ret;
+	if (GDVIRTUAL_REQUIRED_CALL(_get_blend_shape_name, p_index, ret)) {
+		return ret;
+	}
+
+	return StringName();
+}
+
+void Mesh::set_blend_shape_name(int p_index, const StringName &p_name) {
+	if (GDVIRTUAL_REQUIRED_CALL(_set_blend_shape_name, p_index, p_name)) {
+		return;
+	}
+}
+
+AABB Mesh::get_aabb() const {
+	AABB ret;
+	if (GDVIRTUAL_REQUIRED_CALL(_get_aabb, ret)) {
+		return ret;
+	}
+
+	return AABB();
+}
+
 Ref<TriangleMesh> Mesh::generate_triangle_mesh() const {
 	if (triangle_mesh.is_valid()) {
 		return triangle_mesh;
@@ -502,6 +618,21 @@ void Mesh::_bind_methods() {
 
 	BIND_ENUM_CONSTANT(BLEND_SHAPE_MODE_NORMALIZED);
 	BIND_ENUM_CONSTANT(BLEND_SHAPE_MODE_RELATIVE);
+
+	GDVIRTUAL_BIND(_get_surface_count)
+	GDVIRTUAL_BIND(_surface_get_array_len, "index")
+	GDVIRTUAL_BIND(_surface_get_array_index_len, "index")
+	GDVIRTUAL_BIND(_surface_get_arrays, "index")
+	GDVIRTUAL_BIND(_surface_get_blend_shape_arrays, "index")
+	GDVIRTUAL_BIND(_surface_get_lods, "index")
+	GDVIRTUAL_BIND(_surface_get_format, "index")
+	GDVIRTUAL_BIND(_surface_get_primitive_type, "index")
+	GDVIRTUAL_BIND(_surface_set_material, "index", "material")
+	GDVIRTUAL_BIND(_surface_get_material, "index")
+	GDVIRTUAL_BIND(_get_blend_shape_count)
+	GDVIRTUAL_BIND(_get_blend_shape_name, "index")
+	GDVIRTUAL_BIND(_set_blend_shape_name, "index", "name")
+	GDVIRTUAL_BIND(_get_aabb)
 }
 
 void Mesh::clear_cache() const {
diff --git a/scene/resources/mesh.h b/scene/resources/mesh.h
index 08d834bdb9..652c045a24 100644
--- a/scene/resources/mesh.h
+++ b/scene/resources/mesh.h
@@ -45,9 +45,34 @@ class Mesh : public Resource {
 	mutable Vector<Vector3> debug_lines;
 	Size2i lightmap_size_hint;
 
+public:
+	enum PrimitiveType {
+		PRIMITIVE_POINTS = RenderingServer::PRIMITIVE_POINTS,
+		PRIMITIVE_LINES = RenderingServer::PRIMITIVE_LINES,
+		PRIMITIVE_LINE_STRIP = RenderingServer::PRIMITIVE_LINE_STRIP,
+		PRIMITIVE_TRIANGLES = RenderingServer::PRIMITIVE_TRIANGLES,
+		PRIMITIVE_TRIANGLE_STRIP = RenderingServer::PRIMITIVE_TRIANGLE_STRIP,
+		PRIMITIVE_MAX = RenderingServer::PRIMITIVE_MAX,
+	};
+
 protected:
 	static void _bind_methods();
 
+	GDVIRTUAL0RC(int, _get_surface_count)
+	GDVIRTUAL1RC(int, _surface_get_array_len, int)
+	GDVIRTUAL1RC(int, _surface_get_array_index_len, int)
+	GDVIRTUAL1RC(Array, _surface_get_arrays, int)
+	GDVIRTUAL1RC(Array, _surface_get_blend_shape_arrays, int)
+	GDVIRTUAL1RC(Dictionary, _surface_get_lods, int)
+	GDVIRTUAL1RC(uint32_t, _surface_get_format, int)
+	GDVIRTUAL1RC(uint32_t, _surface_get_primitive_type, int)
+	GDVIRTUAL2(_surface_set_material, int, Ref<Material>)
+	GDVIRTUAL1RC(Ref<Material>, _surface_get_material, int)
+	GDVIRTUAL0RC(int, _get_blend_shape_count)
+	GDVIRTUAL1RC(StringName, _get_blend_shape_name, int)
+	GDVIRTUAL2(_set_blend_shape_name, int, StringName)
+	GDVIRTUAL0RC(AABB, _get_aabb)
+
 public:
 	enum {
 		NO_INDEX_ARRAY = RenderingServer::NO_INDEX_ARRAY,
@@ -120,28 +145,20 @@ public:
 
 	};
 
-	enum PrimitiveType {
-		PRIMITIVE_POINTS = RenderingServer::PRIMITIVE_POINTS,
-		PRIMITIVE_LINES = RenderingServer::PRIMITIVE_LINES,
-		PRIMITIVE_LINE_STRIP = RenderingServer::PRIMITIVE_LINE_STRIP,
-		PRIMITIVE_TRIANGLES = RenderingServer::PRIMITIVE_TRIANGLES,
-		PRIMITIVE_TRIANGLE_STRIP = RenderingServer::PRIMITIVE_TRIANGLE_STRIP,
-		PRIMITIVE_MAX = RenderingServer::PRIMITIVE_MAX,
-	};
-
-	virtual int get_surface_count() const = 0;
-	virtual int surface_get_array_len(int p_idx) const = 0;
-	virtual int surface_get_array_index_len(int p_idx) const = 0;
-	virtual Array surface_get_arrays(int p_surface) const = 0;
-	virtual Array surface_get_blend_shape_arrays(int p_surface) const = 0;
-	virtual Dictionary surface_get_lods(int p_surface) const = 0;
-	virtual uint32_t surface_get_format(int p_idx) const = 0;
-	virtual PrimitiveType surface_get_primitive_type(int p_idx) const = 0;
-	virtual void surface_set_material(int p_idx, const Ref<Material> &p_material) = 0;
-	virtual Ref<Material> surface_get_material(int p_idx) const = 0;
-	virtual int get_blend_shape_count() const = 0;
-	virtual StringName get_blend_shape_name(int p_index) const = 0;
-	virtual void set_blend_shape_name(int p_index, const StringName &p_name) = 0;
+	virtual int get_surface_count() const;
+	virtual int surface_get_array_len(int p_idx) const;
+	virtual int surface_get_array_index_len(int p_idx) const;
+	virtual Array surface_get_arrays(int p_surface) const;
+	virtual Array surface_get_blend_shape_arrays(int p_surface) const;
+	virtual Dictionary surface_get_lods(int p_surface) const;
+	virtual uint32_t surface_get_format(int p_idx) const;
+	virtual PrimitiveType surface_get_primitive_type(int p_idx) const;
+	virtual void surface_set_material(int p_idx, const Ref<Material> &p_material);
+	virtual Ref<Material> surface_get_material(int p_idx) const;
+	virtual int get_blend_shape_count() const;
+	virtual StringName get_blend_shape_name(int p_index) const;
+	virtual void set_blend_shape_name(int p_index, const StringName &p_name);
+	virtual AABB get_aabb() const;
 
 	Vector<Face3> get_faces() const;
 	Ref<TriangleMesh> generate_triangle_mesh() const;
@@ -153,8 +170,6 @@ public:
 
 	Ref<Mesh> create_outline(float p_margin) const;
 
-	virtual AABB get_aabb() const = 0;
-
 	void set_lightmap_size_hint(const Size2i &p_size);
 	Size2i get_lightmap_size_hint() const;
 	void clear_cache() const;
diff --git a/scene/resources/primitive_meshes.cpp b/scene/resources/primitive_meshes.cpp
index 38acd0af0a..781e219f1f 100644
--- a/scene/resources/primitive_meshes.cpp
+++ b/scene/resources/primitive_meshes.cpp
@@ -36,11 +36,17 @@
 */
 void PrimitiveMesh::_update() const {
 	Array arr;
-	arr.resize(RS::ARRAY_MAX);
-	_create_mesh_array(arr);
+	if (GDVIRTUAL_CALL(_create_mesh_array, arr)) {
+		ERR_FAIL_COND_MSG(arr.size() != RS::ARRAY_MAX, "_create_mesh_array must return an array of Mesh.ARRAY_MAX elements.");
+	} else {
+		arr.resize(RS::ARRAY_MAX);
+		_create_mesh_array(arr);
+	}
 
 	Vector<Vector3> points = arr[RS::ARRAY_VERTEX];
 
+	ERR_FAIL_COND_MSG(points.size() == 0, "_create_mesh_array must return at least a vertex array.");
+
 	aabb = AABB();
 
 	int pc = points.size();
@@ -210,6 +216,8 @@ void PrimitiveMesh::_bind_methods() {
 	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "material", PROPERTY_HINT_RESOURCE_TYPE, "BaseMaterial3D,ShaderMaterial"), "set_material", "get_material");
 	ADD_PROPERTY(PropertyInfo(Variant::AABB, "custom_aabb", PROPERTY_HINT_NONE, ""), "set_custom_aabb", "get_custom_aabb");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "flip_faces"), "set_flip_faces", "get_flip_faces");
+
+	GDVIRTUAL_BIND(_create_mesh_array);
 }
 
 void PrimitiveMesh::set_material(const Ref<Material> &p_material) {
diff --git a/scene/resources/primitive_meshes.h b/scene/resources/primitive_meshes.h
index 3fc5fd4a16..eef5eb3f7d 100644
--- a/scene/resources/primitive_meshes.h
+++ b/scene/resources/primitive_meshes.h
@@ -64,8 +64,9 @@ protected:
 
 	static void _bind_methods();
 
-	virtual void _create_mesh_array(Array &p_arr) const = 0;
+	virtual void _create_mesh_array(Array &p_arr) const {}
 	void _request_update();
+	GDVIRTUAL0RC(Array, _create_mesh_array)
 
 public:
 	virtual int get_surface_count() const override;
diff --git a/scene/resources/style_box.cpp b/scene/resources/style_box.cpp
index 5afd424e03..fe52761482 100644
--- a/scene/resources/style_box.cpp
+++ b/scene/resources/style_box.cpp
@@ -34,10 +34,28 @@
 
 #include <limits.h>
 
+float StyleBox::get_style_margin(Side p_side) const {
+	float ret;
+	if (GDVIRTUAL_REQUIRED_CALL(_get_style_margin, p_side, ret)) {
+		return ret;
+	}
+	return 0;
+}
 bool StyleBox::test_mask(const Point2 &p_point, const Rect2 &p_rect) const {
+	bool ret;
+	if (GDVIRTUAL_CALL(_test_mask, p_point, p_rect, ret)) {
+		return ret;
+	}
+
 	return true;
 }
 
+void StyleBox::draw(RID p_canvas_item, const Rect2 &p_rect) const {
+	if (GDVIRTUAL_REQUIRED_CALL(_draw, p_canvas_item, p_rect)) {
+		return;
+	}
+}
+
 void StyleBox::set_default_margin(Side p_side, float p_value) {
 	ERR_FAIL_INDEX((int)p_side, 4);
 
@@ -74,10 +92,19 @@ Point2 StyleBox::get_offset() const {
 }
 
 Size2 StyleBox::get_center_size() const {
+	Size2 ret;
+	if (GDVIRTUAL_CALL(_get_center_size, ret)) {
+		return ret;
+	}
+
 	return Size2();
 }
 
 Rect2 StyleBox::get_draw_rect(const Rect2 &p_rect) const {
+	Rect2 ret;
+	if (GDVIRTUAL_CALL(_get_draw_rect, p_rect, ret)) {
+		return ret;
+	}
 	return p_rect;
 }
 
@@ -100,6 +127,12 @@ void StyleBox::_bind_methods() {
 	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "content_margin_right", PROPERTY_HINT_RANGE, "-1,2048,1"), "set_default_margin", "get_default_margin", SIDE_RIGHT);
 	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "content_margin_top", PROPERTY_HINT_RANGE, "-1,2048,1"), "set_default_margin", "get_default_margin", SIDE_TOP);
 	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, "content_margin_bottom", PROPERTY_HINT_RANGE, "-1,2048,1"), "set_default_margin", "get_default_margin", SIDE_BOTTOM);
+
+	GDVIRTUAL_BIND(_get_style_margin, "side")
+	GDVIRTUAL_BIND(_test_mask, "point", "rect")
+	GDVIRTUAL_BIND(_get_center_size)
+	GDVIRTUAL_BIND(_get_draw_rect, "rect")
+	GDVIRTUAL_BIND(_draw, "to_canvas_item", "rect")
 }
 
 StyleBox::StyleBox() {
diff --git a/scene/resources/style_box.h b/scene/resources/style_box.h
index 4c41f42293..68ad41b69c 100644
--- a/scene/resources/style_box.h
+++ b/scene/resources/style_box.h
@@ -44,9 +44,15 @@ class StyleBox : public Resource {
 	float margin[4];
 
 protected:
-	virtual float get_style_margin(Side p_side) const = 0;
+	virtual float get_style_margin(Side p_side) const;
 	static void _bind_methods();
 
+	GDVIRTUAL1RC(float, _get_style_margin, Side)
+	GDVIRTUAL2RC(bool, _test_mask, Point2, Rect2)
+	GDVIRTUAL0RC(Size2, _get_center_size)
+	GDVIRTUAL1RC(Rect2, _get_draw_rect, Rect2)
+	GDVIRTUAL2C(_draw, RID, Rect2)
+
 public:
 	virtual bool test_mask(const Point2 &p_point, const Rect2 &p_rect) const;
 
@@ -56,7 +62,7 @@ public:
 	virtual Size2 get_center_size() const;
 
 	virtual Rect2 get_draw_rect(const Rect2 &p_rect) const;
-	virtual void draw(RID p_canvas_item, const Rect2 &p_rect) const = 0;
+	virtual void draw(RID p_canvas_item, const Rect2 &p_rect) const;
 
 	CanvasItem *get_current_item_drawn() const;
 
diff --git a/scene/resources/texture.cpp b/scene/resources/texture.cpp
index 1ab1d81355..d541284381 100644
--- a/scene/resources/texture.cpp
+++ b/scene/resources/texture.cpp
@@ -38,23 +38,61 @@
 #include "scene/resources/bit_map.h"
 #include "servers/camera/camera_feed.h"
 
+int Texture2D::get_width() const {
+	int ret;
+	if (GDVIRTUAL_REQUIRED_CALL(_get_width, ret)) {
+		return ret;
+	}
+	return 0;
+}
+
+int Texture2D::get_height() const {
+	int ret;
+	if (GDVIRTUAL_REQUIRED_CALL(_get_height, ret)) {
+		return ret;
+	}
+	return 0;
+}
+
 Size2 Texture2D::get_size() const {
 	return Size2(get_width(), get_height());
 }
 
 bool Texture2D::is_pixel_opaque(int p_x, int p_y) const {
+	bool ret;
+	if (GDVIRTUAL_CALL(_is_pixel_opaque, p_x, p_y, ret)) {
+		return ret;
+	}
+
+	return true;
+}
+bool Texture2D::has_alpha() const {
+	bool ret;
+	if (GDVIRTUAL_CALL(_has_alpha, ret)) {
+		return ret;
+	}
+
 	return true;
 }
 
 void Texture2D::draw(RID p_canvas_item, const Point2 &p_pos, const Color &p_modulate, bool p_transpose) const {
+	if (GDVIRTUAL_CALL(_draw, p_canvas_item, p_pos, p_modulate, p_transpose)) {
+		return;
+	}
 	RenderingServer::get_singleton()->canvas_item_add_texture_rect(p_canvas_item, Rect2(p_pos, get_size()), get_rid(), false, p_modulate, p_transpose);
 }
 
 void Texture2D::draw_rect(RID p_canvas_item, const Rect2 &p_rect, bool p_tile, const Color &p_modulate, bool p_transpose) const {
+	if (GDVIRTUAL_CALL(_draw_rect, p_canvas_item, p_rect, p_tile, p_modulate, p_transpose)) {
+		return;
+	}
 	RenderingServer::get_singleton()->canvas_item_add_texture_rect(p_canvas_item, p_rect, get_rid(), p_tile, p_modulate, p_transpose);
 }
 
 void Texture2D::draw_rect_region(RID p_canvas_item, const Rect2 &p_rect, const Rect2 &p_src_rect, const Color &p_modulate, bool p_transpose, bool p_clip_uv) const {
+	if (GDVIRTUAL_CALL(_draw_rect_region, p_canvas_item, p_rect, p_src_rect, p_modulate, p_transpose, p_clip_uv)) {
+		return;
+	}
 	RenderingServer::get_singleton()->canvas_item_add_texture_rect_region(p_canvas_item, p_rect, get_rid(), p_src_rect, p_modulate, p_transpose, p_clip_uv);
 }
 
@@ -75,6 +113,15 @@ void Texture2D::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("get_image"), &Texture2D::get_image);
 
 	ADD_GROUP("", "");
+
+	GDVIRTUAL_BIND(_get_width);
+	GDVIRTUAL_BIND(_get_height);
+	GDVIRTUAL_BIND(_is_pixel_opaque, "x", "y");
+	GDVIRTUAL_BIND(_has_alpha);
+
+	GDVIRTUAL_BIND(_draw, "to_canvas_item", "pos", "modulate", "transpose")
+	GDVIRTUAL_BIND(_draw_rect, "to_canvas_item", "rect", "tile", "modulate", "transpose")
+	GDVIRTUAL_BIND(_draw_rect_region, "tp_canvas_item", "rect", "src_rect", "modulate", "transpose", "clip_uv");
 }
 
 Texture2D::Texture2D() {
@@ -740,7 +787,7 @@ String ResourceFormatLoaderCompressedTexture2D::get_resource_type(const String &
 
 ////////////////////////////////////
 
-TypedArray<Image> Texture3D::_get_data() const {
+TypedArray<Image> Texture3D::_get_datai() const {
 	Vector<Ref<Image>> data = get_data();
 
 	TypedArray<Image> ret;
@@ -751,13 +798,73 @@ TypedArray<Image> Texture3D::_get_data() const {
 	return ret;
 }
 
+Image::Format Texture3D::get_format() const {
+	Image::Format ret;
+	if (GDVIRTUAL_REQUIRED_CALL(_get_format, ret)) {
+		return ret;
+	}
+	return Image::FORMAT_MAX;
+}
+
+int Texture3D::get_width() const {
+	int ret;
+	if (GDVIRTUAL_REQUIRED_CALL(_get_width, ret)) {
+		return ret;
+	}
+	return 0;
+}
+
+int Texture3D::get_height() const {
+	int ret;
+	if (GDVIRTUAL_REQUIRED_CALL(_get_height, ret)) {
+		return ret;
+	}
+	return 0;
+}
+
+int Texture3D::get_depth() const {
+	int ret;
+	if (GDVIRTUAL_REQUIRED_CALL(_get_depth, ret)) {
+		return ret;
+	}
+
+	return 0;
+}
+
+bool Texture3D::has_mipmaps() const {
+	bool ret;
+	if (GDVIRTUAL_REQUIRED_CALL(_has_mipmaps, ret)) {
+		return ret;
+	}
+	return 0;
+}
+
+Vector<Ref<Image>> Texture3D::get_data() const {
+	TypedArray<Image> ret;
+	if (GDVIRTUAL_REQUIRED_CALL(_get_data, ret)) {
+		Vector<Ref<Image>> data;
+		data.resize(ret.size());
+		for (int i = 0; i < data.size(); i++) {
+			data.write[i] = ret[i];
+		}
+		return data;
+	}
+	return Vector<Ref<Image>>();
+}
 void Texture3D::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("get_format"), &Texture3D::get_format);
 	ClassDB::bind_method(D_METHOD("get_width"), &Texture3D::get_width);
 	ClassDB::bind_method(D_METHOD("get_height"), &Texture3D::get_height);
 	ClassDB::bind_method(D_METHOD("get_depth"), &Texture3D::get_depth);
 	ClassDB::bind_method(D_METHOD("has_mipmaps"), &Texture3D::has_mipmaps);
-	ClassDB::bind_method(D_METHOD("get_data"), &Texture3D::_get_data);
+	ClassDB::bind_method(D_METHOD("get_data"), &Texture3D::_get_datai);
+
+	GDVIRTUAL_BIND(_get_format);
+	GDVIRTUAL_BIND(_get_width);
+	GDVIRTUAL_BIND(_get_height);
+	GDVIRTUAL_BIND(_get_depth);
+	GDVIRTUAL_BIND(_has_mipmaps);
+	GDVIRTUAL_BIND(_get_data);
 }
 //////////////////////////////////////////
 
@@ -2446,6 +2553,63 @@ AnimatedTexture::~AnimatedTexture() {
 
 ///////////////////////////////
 
+Image::Format TextureLayered::get_format() const {
+	Image::Format ret;
+	if (GDVIRTUAL_REQUIRED_CALL(_get_format, ret)) {
+		return ret;
+	}
+	return Image::FORMAT_MAX;
+}
+
+TextureLayered::LayeredType TextureLayered::get_layered_type() const {
+	uint32_t ret;
+	if (GDVIRTUAL_REQUIRED_CALL(_get_layered_type, ret)) {
+		return (LayeredType)ret;
+	}
+	return LAYERED_TYPE_2D_ARRAY;
+}
+
+int TextureLayered::get_width() const {
+	int ret;
+	if (GDVIRTUAL_REQUIRED_CALL(_get_width, ret)) {
+		return ret;
+	}
+	return 0;
+}
+
+int TextureLayered::get_height() const {
+	int ret;
+	if (GDVIRTUAL_REQUIRED_CALL(_get_height, ret)) {
+		return ret;
+	}
+	return 0;
+}
+
+int TextureLayered::get_layers() const {
+	int ret;
+	if (GDVIRTUAL_REQUIRED_CALL(_get_layers, ret)) {
+		return ret;
+	}
+
+	return 0;
+}
+
+bool TextureLayered::has_mipmaps() const {
+	bool ret;
+	if (GDVIRTUAL_REQUIRED_CALL(_has_mipmaps, ret)) {
+		return ret;
+	}
+	return false;
+}
+
+Ref<Image> TextureLayered::get_layer_data(int p_layer) const {
+	Ref<Image> ret;
+	if (GDVIRTUAL_REQUIRED_CALL(_get_layer_data, p_layer, ret)) {
+		return ret;
+	}
+	return Ref<Image>();
+}
+
 void TextureLayered::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("get_format"), &TextureLayered::get_format);
 	ClassDB::bind_method(D_METHOD("get_layered_type"), &TextureLayered::get_layered_type);
@@ -2458,6 +2622,14 @@ void TextureLayered::_bind_methods() {
 	BIND_ENUM_CONSTANT(LAYERED_TYPE_2D_ARRAY);
 	BIND_ENUM_CONSTANT(LAYERED_TYPE_CUBEMAP);
 	BIND_ENUM_CONSTANT(LAYERED_TYPE_CUBEMAP_ARRAY);
+
+	GDVIRTUAL_BIND(_get_format);
+	GDVIRTUAL_BIND(_get_layered_type);
+	GDVIRTUAL_BIND(_get_width);
+	GDVIRTUAL_BIND(_get_height);
+	GDVIRTUAL_BIND(_get_layers);
+	GDVIRTUAL_BIND(_has_mipmaps);
+	GDVIRTUAL_BIND(_get_layer_data, "layer_index");
 }
 
 ///////////////////////////////
diff --git a/scene/resources/texture.h b/scene/resources/texture.h
index a3c147610d..1e07b83547 100644
--- a/scene/resources/texture.h
+++ b/scene/resources/texture.h
@@ -57,14 +57,23 @@ class Texture2D : public Texture {
 protected:
 	static void _bind_methods();
 
+	GDVIRTUAL0RC(int, _get_width)
+	GDVIRTUAL0RC(int, _get_height)
+	GDVIRTUAL2RC(bool, _is_pixel_opaque, int, int)
+	GDVIRTUAL0RC(bool, _has_alpha)
+
+	GDVIRTUAL4C(_draw, RID, Point2, Color, bool)
+	GDVIRTUAL5C(_draw_rect, RID, Rect2, bool, Color, bool)
+	GDVIRTUAL6C(_draw_rect_region, RID, Rect2, Rect2, Color, bool, bool)
+
 public:
-	virtual int get_width() const = 0;
-	virtual int get_height() const = 0;
+	virtual int get_width() const;
+	virtual int get_height() const;
 	virtual Size2 get_size() const;
 
 	virtual bool is_pixel_opaque(int p_x, int p_y) const;
 
-	virtual bool has_alpha() const = 0;
+	virtual bool has_alpha() const;
 
 	virtual void draw(RID p_canvas_item, const Point2 &p_pos, const Color &p_modulate = Color(1, 1, 1), bool p_transpose = false) const;
 	virtual void draw_rect(RID p_canvas_item, const Rect2 &p_rect, bool p_tile = false, const Color &p_modulate = Color(1, 1, 1), bool p_transpose = false) const;
@@ -300,6 +309,13 @@ class TextureLayered : public Texture {
 protected:
 	static void _bind_methods();
 
+	GDVIRTUAL0RC(Image::Format, _get_format)
+	GDVIRTUAL0RC(uint32_t, _get_layered_type)
+	GDVIRTUAL0RC(int, _get_width)
+	GDVIRTUAL0RC(int, _get_height)
+	GDVIRTUAL0RC(int, _get_layers)
+	GDVIRTUAL0RC(bool, _has_mipmaps)
+	GDVIRTUAL1RC(Ref<Image>, _get_layer_data, int)
 public:
 	enum LayeredType {
 		LAYERED_TYPE_2D_ARRAY,
@@ -307,13 +323,15 @@ public:
 		LAYERED_TYPE_CUBEMAP_ARRAY
 	};
 
-	virtual Image::Format get_format() const = 0;
-	virtual LayeredType get_layered_type() const = 0;
-	virtual int get_width() const = 0;
-	virtual int get_height() const = 0;
-	virtual int get_layers() const = 0;
-	virtual bool has_mipmaps() const = 0;
-	virtual Ref<Image> get_layer_data(int p_layer) const = 0;
+	virtual Image::Format get_format() const;
+	virtual LayeredType get_layered_type() const;
+	virtual int get_width() const;
+	virtual int get_height() const;
+	virtual int get_layers() const;
+	virtual bool has_mipmaps() const;
+	virtual Ref<Image> get_layer_data(int p_layer) const;
+
+	TextureLayered() {}
 };
 
 VARIANT_ENUM_CAST(TextureLayered::LayeredType)
@@ -474,15 +492,21 @@ class Texture3D : public Texture {
 protected:
 	static void _bind_methods();
 
-	TypedArray<Image> _get_data() const;
-
-public:
-	virtual Image::Format get_format() const = 0;
-	virtual int get_width() const = 0;
-	virtual int get_height() const = 0;
-	virtual int get_depth() const = 0;
-	virtual bool has_mipmaps() const = 0;
-	virtual Vector<Ref<Image>> get_data() const = 0;
+	TypedArray<Image> _get_datai() const;
+
+	GDVIRTUAL0RC(Image::Format, _get_format)
+	GDVIRTUAL0RC(int, _get_width)
+	GDVIRTUAL0RC(int, _get_height)
+	GDVIRTUAL0RC(int, _get_depth)
+	GDVIRTUAL0RC(bool, _has_mipmaps)
+	GDVIRTUAL0RC(TypedArray<Image>, _get_data)
+public:
+	virtual Image::Format get_format() const;
+	virtual int get_width() const;
+	virtual int get_height() const;
+	virtual int get_depth() const;
+	virtual bool has_mipmaps() const;
+	virtual Vector<Ref<Image>> get_data() const;
 };
 
 class ImageTexture3D : public Texture3D {