Fully Ported PropToolMesh.

SCsub

@@ -57,6 +57,8 @@ sources = [
     "clutter/ground_clutter_foliage.cpp",
 
     "world/voxel_world_editor.cpp",
+
+    "prop_tool/prop_tool_mesh.cpp",
     #"prop_tool/prop_tool_editor_plugin.cpp",
 ]
 

prop_tool/prop_tool_mesh.cpp

@@ -22,11 +22,41 @@ SOFTWARE.
 
 #include "prop_tool_mesh.h"
 
+Ref<MeshDataResource> PropToolMesh::get_mesh_data() {
+	return _mesh_data;
+}
+void PropToolMesh::set_mesh_data(const Ref<MeshDataResource> &data) {
+	_mesh_data = data;
+}
+
 Ref<PropDataMesh> PropToolMesh::get_data() {
 	return _prop_mesh;
+
+	if (!is_visible() || !_mesh_data.is_valid())
+		return Ref<PropDataMesh>();
+
+	if (!_prop_mesh.is_valid())
+		_prop_mesh.instance();
+
+	_prop_mesh->set_mesh(_mesh_data);
+	_prop_mesh->set_texture(_texture);
+	_prop_mesh->set_snap_to_mesh(_snap_to_mesh);
+	_prop_mesh->set_snap_axis(_snap_axis);
+
+	return _prop_mesh;
 }
 void PropToolMesh::set_data(const Ref<PropDataMesh> &data) {
 	_prop_mesh = data;
+
+	if (!_prop_mesh.is_valid())
+		return;
+
+	_texture = _prop_mesh->get_texture();
+
+	_snap_to_mesh = _prop_mesh->get_snap_to_mesh();
+	_snap_axis = _prop_mesh->get_snap_axis();
+
+	set_generate(true);
 }
 
 Ref<Texture> PropToolMesh::get_texture() {
@@ -61,7 +91,8 @@ void PropToolMesh::generate() {
 }
 
 PropToolMesh::PropToolMesh() {
-	bool _snap_to_mesh;
+	_snap_to_mesh = false;
+	_snap_axis = Vector3(0, -1, 0);
 }
 PropToolMesh::~PropToolMesh() {
 	_prop_mesh.unref();
@@ -69,97 +100,80 @@ PropToolMesh::~PropToolMesh() {
 }
 
 void PropToolMesh::set_generate(bool value) {
+	if (!value)
+		return;
+
+	if (!_mesh_data.is_valid()) {
+		mesh.unref();
+		return;
+	}
+
+	Ref<ArrayMesh> m;
+	m.instance();
+
+	Array arr;
+	arr.resize(ArrayMesh::ARRAY_MAX);
+
+	Array mda = _mesh_data->get_array();
+
+	PoolVector3Array v;
+	v.append_array(mda[Mesh::ARRAY_VERTEX]);
+	arr.set(Mesh::ARRAY_VERTEX, v);
+
+	PoolVector3Array norm;
+	norm.append_array(mda[Mesh::ARRAY_NORMAL]);
+	arr.set(Mesh::ARRAY_NORMAL, norm);
+
+	PoolVector2Array uv;
+	uv.append_array(mda[Mesh::ARRAY_TEX_UV]);
+	arr.set(Mesh::ARRAY_TEX_UV, uv);
+
+	PoolIntArray ind;
+	ind.append_array(mda[Mesh::ARRAY_INDEX]);
+	arr.set(Mesh::ARRAY_INDEX, ind);
+
+	m->add_surface_from_arrays(Mesh::PRIMITIVE_TRIANGLES, arr);
+
+	mesh = m;
+
+	if (_texture.is_valid()) {
+		if (!_material.is_valid())
+			_material.instance();
+
+		_material->set_texture(SpatialMaterial::TEXTURE_ALBEDO, _texture);
+
+		set_material_override(_material);
+	}
 }
 
 void PropToolMesh::_bind_methods() {
+	ClassDB::bind_method(D_METHOD("get_mesh_data"), &PropToolMesh::get_mesh_data);
+	ClassDB::bind_method(D_METHOD("set_mesh_data", "value"), &PropToolMesh::set_mesh_data);
+	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "mesh_data", PROPERTY_HINT_RESOURCE_TYPE, "MeshDataResource"), "set_mesh_data", "get_mesh_data");
+
+	ClassDB::bind_method(D_METHOD("get_data"), &PropToolMesh::get_data);
+	ClassDB::bind_method(D_METHOD("set_data", "value"), &PropToolMesh::set_data);
+	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "PropDataMesh"), "set_data", "get_data");
+
+	ClassDB::bind_method(D_METHOD("get_texture"), &PropToolMesh::get_texture);
+	ClassDB::bind_method(D_METHOD("set_texture", "value"), &PropToolMesh::set_texture);
+	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "texture", PROPERTY_HINT_RESOURCE_TYPE, "Texture"), "set_texture", "get_texture");
+
+	ClassDB::bind_method(D_METHOD("get_snap_to_mesh"), &PropToolMesh::get_snap_to_mesh);
+	ClassDB::bind_method(D_METHOD("set_snap_to_mesh", "value"), &PropToolMesh::set_snap_to_mesh);
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "snap_to_mesh"), "set_snap_to_mesh", "get_snap_to_mesh");
+
+	ClassDB::bind_method(D_METHOD("get_snap_axis"), &PropToolMesh::get_snap_axis);
+	ClassDB::bind_method(D_METHOD("set_snap_axis", "value"), &PropToolMesh::set_snap_axis);
+	ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "snap_axis"), "set_snap_axis", "get_snap_axis");
+
+	ClassDB::bind_method(D_METHOD("get_prop_mesh"), &PropToolMesh::get_prop_mesh);
+	ClassDB::bind_method(D_METHOD("set_prop_mesh", "value"), &PropToolMesh::set_prop_mesh);
+	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "prop_mesh", PROPERTY_HINT_RESOURCE_TYPE, "MeshDataResource"), "set_prop_mesh", "get_prop_mesh");
+
+	ClassDB::bind_method(D_METHOD("generate"), &PropToolMesh::generate);
+
+	ClassDB::bind_method(D_METHOD("get_generate"), &PropToolMesh::get_generate);
+	ClassDB::bind_method(D_METHOD("set_generate"), &PropToolMesh::set_generate);
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "generate"), "set_generate", "get_generate");
 }
-
-/*
-tool
-extends MeshInstance
-class_name PropToolMesh
-
-export(MeshDataResource) var mesh_data : MeshDataResource setget set_prop_mesh
-export(Texture) var texture : Texture setget set_texture
-export(bool) var snap_to_mesh : bool = false
-export(Vector3) var snap_axis : Vector3 = Vector3(0, -1, 0)
-
-export(bool) var generate : bool setget set_generate
-
-var _prop_mesh : PropDataMesh
-var _material : SpatialMaterial
-
-func get_data() -> PropDataMesh:
-	if not visible or mesh_data == null:
-		return null
-	
-	if _prop_mesh == null:
-		_prop_mesh = PropDataMesh.new()
-		
-	_prop_mesh.mesh = mesh_data
-	_prop_mesh.texture = texture
-	_prop_mesh.snap_to_mesh = snap_to_mesh
-	_prop_mesh.snap_axis = snap_axis
-
-	return _prop_mesh
-
-func set_data(data : PropDataMesh) -> void:
-	_prop_mesh = data
-	
-	set_texture(_prop_mesh.texture)
-	set_prop_mesh(_prop_mesh.mesh)
-	
-	snap_to_mesh = _prop_mesh.snap_to_mesh
-	snap_axis = _prop_mesh.snap_axis
-
-func set_prop_mesh(md : MeshDataResource) -> void:
-	mesh_data = md
-	
-	set_generate(true)
-	
-func set_texture(tex : Texture) -> void:
-	texture = tex
-	
-func set_generate(val : bool) -> void:
-	if val:
-		if !mesh_data:
-			mesh = null
-			return
-			
-		var m : ArrayMesh = ArrayMesh.new()
-		
-		var arr = []
-		arr.resize(ArrayMesh.ARRAY_MAX)
-		
-		var v : PoolVector3Array = PoolVector3Array()
-		v.append_array(mesh_data.array[Mesh.ARRAY_VERTEX])
-		arr[Mesh.ARRAY_VERTEX] = v
-		
-		var norm : PoolVector3Array = PoolVector3Array()
-		norm.append_array(mesh_data.array[Mesh.ARRAY_NORMAL])
-		arr[Mesh.ARRAY_NORMAL] = norm
-		
-		var uv : PoolVector2Array = PoolVector2Array()
-		uv.append_array(mesh_data.array[Mesh.ARRAY_TEX_UV])
-		arr[Mesh.ARRAY_TEX_UV] = uv
-
-		var ind : PoolIntArray = PoolIntArray()
-		ind.append_array(mesh_data.array[Mesh.ARRAY_INDEX])
-		arr[Mesh.ARRAY_INDEX] = ind
-		
-		m.add_surface_from_arrays(Mesh.PRIMITIVE_TRIANGLES, arr)
-
-		mesh = m
-		
-		if texture != null:
-			if _material == null:
-				_material = SpatialMaterial.new()
-			
-			_material.albedo_texture = texture
-			
-			material_override = _material
-		
-
-
-
-*/

prop_tool/prop_tool_mesh.h

@@ -23,19 +23,18 @@ SOFTWARE.
 #ifndef PROP_TOOL_MESH_H
 #define PROP_TOOL_MESH_H
 
-class EditorNode;
+#include "core/math/vector3.h"
-class EditorPlugin;
-class PropData;
 
 #include "../props/prop_data_mesh.h"
 #include "scene/3d/mesh_instance.h"
 
-class propData;
-
 class PropToolMesh : public MeshInstance {
 	GDCLASS(PropToolMesh, MeshInstance);
 
 public:
+	Ref<MeshDataResource> get_mesh_data();
+	void set_mesh_data(const Ref<MeshDataResource> &data);
+
 	Ref<PropDataMesh> get_data();
 	void set_data(const Ref<PropDataMesh> &data);
 
@@ -57,11 +56,13 @@ public:
 	~PropToolMesh();
 
 protected:
+	bool get_generate() { return false; }
 	void set_generate(bool value);
 
 	static void _bind_methods();
 
 private:
+	Ref<MeshDataResource> _mesh_data;
 	Ref<PropDataMesh> _prop_mesh;
 	Ref<Texture> _texture;
 	Ref<SpatialMaterial> _material;

register_types.cpp

@@ -64,6 +64,7 @@ SOFTWARE.
 
 #include "world/voxel_world_editor.h"
 
+#include "prop_tool/prop_tool_mesh.h"
 //#include "prop_tool/prop_tool_editor_plugin.h"
 
 void register_voxelman_types() {
@@ -107,6 +108,8 @@ void register_voxelman_types() {
 
 	ClassDB::register_class<GroundClutterFoliage>();
 
+	ClassDB::register_class<PropToolMesh>();
+
 #ifdef TOOLS_ENABLED
 	EditorPlugins::add_by_type<VoxelWorldEditorPlugin>();
 #endif