diff --git a/prop_instance.cpp b/prop_instance.cpp
index bb111ec..26ae904 100644
--- a/prop_instance.cpp
+++ b/prop_instance.cpp
@@ -8,8 +8,29 @@
 
 #if VERSION_MAJOR > 3
 #include "core/config/engine.h"
+
+#define VARIANT_ARRAY_GET(arr)             \
+	Vector<Variant> r;                     \
+	for (int i = 0; i < arr.size(); i++) { \
+		r.push_back(arr[i]);               \
+	}                                      \
+	return r;
+
+#include "servers/rendering_server.h"
+typedef class RenderingServer VS;
+
 #else
 #include "core/engine.h"
+
+#define VARIANT_ARRAY_GET(arr)             \
+	Vector<Variant> r;                     \
+	for (int i = 0; i < arr.size(); i++) { \
+		r.push_back(arr[i].get_ref_ptr()); \
+	}                                      \
+	return r;
+
+#include "servers/visual_server.h"
+
 #endif
 
 Ref<PropData> PropInstance::get_prop_data() {
@@ -21,61 +42,170 @@ void PropInstance::set_prop_data(const Ref<PropData> &data) {
 
 	_prop_data = data;
 
-	build();
+	queue_build();
 }
 
-bool PropInstance::get_auto_bake() const {
-	return _auto_bake;
+Ref<PropInstanceJob> PropInstance::get_job() {
+	return _job;
 }
-void PropInstance::set_auto_bake(const bool value) {
-	_auto_bake = value;
+void PropInstance::set_job(const Ref<PropInstanceJob> &job) {
+	_job = job;
 }
 
-bool PropInstance::get_snap_to_mesh() const {
-	return _snap_to_mesh;
-}
-void PropInstance::set_snap_to_mesh(const bool value) {
-	_snap_to_mesh = value;
+#ifdef TEXTURE_PACKER_PRESENT
+bool PropInstance::get_merge_textures() const {
+	return _merge_textures;
 }
 
-Vector3 PropInstance::get_snap_axis() const {
-	return _snap_axis;
+void PropInstance::set_merge_textures(const bool value) {
+	_merge_textures = value;
 }
-void PropInstance::set_snap_axis(const Vector3 &value) {
-	_snap_axis = value;
+#endif
+
+//Materials
+Ref<Material> PropInstance::material_get(const int index) {
+	ERR_FAIL_INDEX_V(index, _materials.size(), Ref<Material>(NULL));
+
+	return _materials[index];
 }
 
-void PropInstance::bake() {
-		_baking = true;
-	_bake_queued = false;
+void PropInstance::material_add(const Ref<Material> &value) {
+	ERR_FAIL_COND(!value.is_valid());
+
+	_materials.push_back(value);
+}
+
+int PropInstance::material_get_num() const {
+	return _materials.size();
+}
+
+void PropInstance::materials_clear() {
+	_materials.clear();
+}
+
+Vector<Variant> PropInstance::materials_get() {
+	VARIANT_ARRAY_GET(_materials);
+}
+
+void PropInstance::materials_set(const Vector<Variant> &materials) {
+	_materials.clear();
+
+	for (int i = 0; i < materials.size(); i++) {
+		Ref<Material> material = Ref<Material>(materials[i]);
+
+		_materials.push_back(material);
+	}
+}
+
+//Meshes
+RID PropInstance::mesh_get(const int index) {
+	ERR_FAIL_INDEX_V(index, _meshes.size(), RID());
+
+	return _meshes[index];
+}
+
+void PropInstance::mesh_add(const RID value) {
+	_meshes.push_back(value);
+}
+
+int PropInstance::mesh_get_num() const {
+	return _meshes.size();
+}
+
+void PropInstance::meshs_clear() {
+	_meshes.clear();
+}
+
+Vector<Variant> PropInstance::meshes_get() {
+	Vector<Variant> r;
+	for (int i = 0; i < _meshes.size(); i++) {
+		r.push_back(_meshes[i]);
+	}
+	return r;
+}
+
+void PropInstance::meshes_set(const Vector<Variant> &meshs) {
+	_meshes.clear();
+
+	for (int i = 0; i < _meshes.size(); i++) {
+		RID mesh = RID(meshs[i]);
+
+		_meshes.push_back(mesh);
+	}
+}
+
+//Collider
+RID PropInstance::collider_get(const int index) {
+	ERR_FAIL_INDEX_V(index, _colliders.size(), RID());
+
+	return _colliders[index];
+}
+
+void PropInstance::collider_add(const RID value) {
+	_colliders.push_back(value);
+}
+
+int PropInstance::collider_get_num() const {
+	return _colliders.size();
+}
+
+void PropInstance::colliders_clear() {
+	_colliders.clear();
+}
+
+Vector<Variant> PropInstance::colliders_get() {
+	Vector<Variant> r;
+	for (int i = 0; i < _colliders.size(); i++) {
+		r.push_back(_colliders[i]);
+	}
+	return r;
+}
+
+void PropInstance::colliders_set(const Vector<Variant> &colliders) {
+	_colliders.clear();
+
+	for (int i = 0; i < colliders.size(); i++) {
+		RID collider = (colliders[i]);
+
+		_colliders.push_back(collider);
+	}
+}
+
+float PropInstance::get_first_lod_distance_squared() {
+	return _first_lod_distance_squared;
+}
+void PropInstance::set_first_lod_distance_squared(const float dist) {
+	_first_lod_distance_squared = dist;
+}
+
+float PropInstance::get_lod_reduction_distance_squared() {
+	return _lod_reduction_distance_squared;
+}
+void PropInstance::set_lod_reduction_distance_squared(const float dist) {
+	_lod_reduction_distance_squared = dist;
+}
+
+void PropInstance::free_meshes() {
+}
+void PropInstance::free_colliders() {
+}
+
+void PropInstance::init_materials() {
+	call("_init_materials");
+}
+void PropInstance::_init_materials() {
+}
+
+void PropInstance::build() {
+	_building = true;
+	_build_queued = false;
 
 	if (!_job.is_valid()) {
-		_job.instance();
+		_job = Ref<PropInstanceJob>(memnew(PropInstancePropJob()));
 	}
 
 	_job->set_prop_instace(this);
 
-}
-
-void PropInstance::bake_finished() {
-	_baking = false;
-
-	if (_bake_queued) {
-		call_deferred("bake");
-	}
-}
-
-void PropInstance::queue_bake() {
-	if (!_bake_queued) {
-		_bake_queued = true;
-
-		if (!_baking) {
-			call_deferred("bake");
-		}
-	}
-}
-
-void PropInstance::build() {
 	if (!is_inside_tree()) {
 		return;
 	}
@@ -107,20 +237,40 @@ void PropInstance::build() {
 			//	n->set_owner(get_tree()->get_edited_scene_root());
 		}
 	}
+}
 
+void PropInstance::queue_build() {
+}
+
+void PropInstance::build_finished() {
+	_building = false;
+
+	if (_build_queued) {
+		call_deferred("build");
+	}
+}
+
+void PropInstance::_build_finished() {
 }
 
 PropInstance::PropInstance() {
-	_baking = false;
-	_bake_queued = false;
-	_snap_to_mesh = false;
-	_snap_axis = Vector3(0, -1, 0);
-	//_job.instance();
-	//_job->connect("completed", this, "bake_finished", Vector<Variant>(), Object::CONNECT_DEFERRED);
+	_build_queued = false;
+	_building = false;
+
+#ifdef TEXTURE_PACKER_PRESENT
+	_merge_textures = true;
+#endif
+
+	_first_lod_distance_squared = 20;
+	_lod_reduction_distance_squared = 10;
 }
+
 PropInstance::~PropInstance() {
-	//_job.unref();
+	_job.unref();
+
 	_prop_data.unref();
+
+	_materials.clear();
 }
 
 void PropInstance::_notification(int p_what) {
@@ -130,6 +280,14 @@ void PropInstance::_notification(int p_what) {
 				build();
 			}
 		}
+		case NOTIFICATION_EXIT_TREE: {
+			if (_job.is_valid()) {
+				_job->set_cancelled(true);
+			}
+
+			free_meshes();
+			free_colliders();
+		}
 	}
 }
 
@@ -138,19 +296,71 @@ void PropInstance::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("set_prop_data", "value"), &PropInstance::set_prop_data);
 	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "prop_data", PROPERTY_HINT_RESOURCE_TYPE, "PropData"), "set_prop_data", "get_prop_data");
 
-	ClassDB::bind_method(D_METHOD("get_auto_bake"), &PropInstance::get_auto_bake);
-	ClassDB::bind_method(D_METHOD("set_auto_bake", "value"), &PropInstance::set_auto_bake);
-	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "auto_bake"), "set_auto_bake", "get_auto_bake");
+	ClassDB::bind_method(D_METHOD("get_job"), &PropInstance::get_job);
+	ClassDB::bind_method(D_METHOD("set_job", "value"), &PropInstance::set_job);
+	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "job", PROPERTY_HINT_RESOURCE_TYPE, "PropInstanceJob", 0), "set_job", "get_job");
 
-	ClassDB::bind_method(D_METHOD("get_snap_to_mesh"), &PropInstance::get_snap_to_mesh);
-	ClassDB::bind_method(D_METHOD("set_snap_to_mesh", "value"), &PropInstance::set_snap_to_mesh);
-	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "snap_to_mesh"), "set_snap_to_mesh", "get_snap_to_mesh");
+#ifdef TEXTURE_PACKER_PRESENT
+	ClassDB::bind_method(D_METHOD("get_merge_textures"), &PropInstance::get_merge_textures);
+	ClassDB::bind_method(D_METHOD("set_merge_textures", "value"), &PropInstance::set_merge_textures);
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "merge_textures"), "set_merge_textures", "get_merge_textures");
+#endif
 
-	ClassDB::bind_method(D_METHOD("get_snap_axis"), &PropInstance::get_snap_axis);
-	ClassDB::bind_method(D_METHOD("set_snap_axis", "value"), &PropInstance::set_snap_axis);
-	ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "snap_axis"), "set_snap_axis", "get_snap_axis");
+	///Materials
+	ClassDB::bind_method(D_METHOD("material_get", "index"), &PropInstance::material_get);
+	ClassDB::bind_method(D_METHOD("material_add", "value"), &PropInstance::material_add);
+	ClassDB::bind_method(D_METHOD("material_get_num"), &PropInstance::material_get_num);
+	ClassDB::bind_method(D_METHOD("materials_clear"), &PropInstance::materials_clear);
 
-	ClassDB::bind_method(D_METHOD("bake"), &PropInstance::bake);
-	ClassDB::bind_method(D_METHOD("queue_bake"), &PropInstance::queue_bake);
-	ClassDB::bind_method(D_METHOD("bake_finished"), &PropInstance::bake_finished);
+	ClassDB::bind_method(D_METHOD("materials_get"), &PropInstance::materials_get);
+	ClassDB::bind_method(D_METHOD("materials_set"), &PropInstance::materials_set);
+	ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "materials", PROPERTY_HINT_NONE, "17/17:Material", PROPERTY_USAGE_DEFAULT, "Material"), "materials_set", "materials_get");
+
+	//Meshes
+	ClassDB::bind_method(D_METHOD("mesh_get", "index"), &PropInstance::mesh_get);
+	ClassDB::bind_method(D_METHOD("mesh_add", "value"), &PropInstance::mesh_add);
+	ClassDB::bind_method(D_METHOD("mesh_get_num"), &PropInstance::mesh_get_num);
+	ClassDB::bind_method(D_METHOD("meshs_clear"), &PropInstance::meshs_clear);
+
+	ClassDB::bind_method(D_METHOD("meshes_get"), &PropInstance::meshes_get);
+	ClassDB::bind_method(D_METHOD("meshes_set"), &PropInstance::meshes_set);
+	ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "meshes", PROPERTY_HINT_NONE, "", 0), "meshes_set", "meshes_get");
+
+	//Colliders
+	ClassDB::bind_method(D_METHOD("collider_get", "index"), &PropInstance::collider_get);
+	ClassDB::bind_method(D_METHOD("collider_add", "value"), &PropInstance::collider_add);
+	ClassDB::bind_method(D_METHOD("collider_get_num"), &PropInstance::collider_get_num);
+	ClassDB::bind_method(D_METHOD("colliders_clear"), &PropInstance::colliders_clear);
+
+	ClassDB::bind_method(D_METHOD("colliders_get"), &PropInstance::colliders_get);
+	ClassDB::bind_method(D_METHOD("colliders_set"), &PropInstance::colliders_set);
+	ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "colliders", PROPERTY_HINT_NONE, "", 0), "colliders_set", "colliders_get");
+
+	//---
+	ClassDB::bind_method(D_METHOD("get_first_lod_distance_squared"), &PropInstance::get_first_lod_distance_squared);
+	ClassDB::bind_method(D_METHOD("set_first_lod_distance_squared", "value"), &PropInstance::set_first_lod_distance_squared);
+	ADD_PROPERTY(PropertyInfo(Variant::REAL, "first_lod_distance_squared"), "set_first_lod_distance_squared", "get_first_lod_distance_squared");
+
+	ClassDB::bind_method(D_METHOD("get_lod_reduction_distance_squared"), &PropInstance::get_lod_reduction_distance_squared);
+	ClassDB::bind_method(D_METHOD("set_lod_reduction_distance_squared", "value"), &PropInstance::set_lod_reduction_distance_squared);
+	ADD_PROPERTY(PropertyInfo(Variant::REAL, "lod_reduction_distance_squared"), "set_lod_reduction_distance_squared", "get_lod_reduction_distance_squared");
+
+	//---
+	ClassDB::bind_method(D_METHOD("free_meshes"), &PropInstance::free_meshes);
+	ClassDB::bind_method(D_METHOD("free_colliders"), &PropInstance::free_colliders);
+
+	//---
+	BIND_VMETHOD(MethodInfo("_init_materials"));
+
+	ClassDB::bind_method(D_METHOD("init_materials"), &PropInstance::init_materials);
+	ClassDB::bind_method(D_METHOD("_init_materials"), &PropInstance::_init_materials);
+
+	//---
+	ClassDB::bind_method(D_METHOD("build"), &PropInstance::build);
+	ClassDB::bind_method(D_METHOD("queue_build"), &PropInstance::queue_build);
+	ClassDB::bind_method(D_METHOD("build_finished"), &PropInstance::build_finished);
+
+	BIND_VMETHOD(MethodInfo("_build_finished"));
+
+	ClassDB::bind_method(D_METHOD("_build_finished"), &PropInstance::_build_finished);
 }
diff --git a/prop_instance.h b/prop_instance.h
index 823a11b..84ca163 100644
--- a/prop_instance.h
+++ b/prop_instance.h
@@ -48,20 +48,57 @@ public:
 	Ref<PropData> get_prop_data();
 	void set_prop_data(const Ref<PropData> &data);
 
-	bool get_auto_bake() const;
-	void set_auto_bake(const bool value);
+	Ref<PropInstanceJob> get_job();
+	void set_job(const Ref<PropInstanceJob> &job);
 
-	bool get_snap_to_mesh() const;
-	void set_snap_to_mesh(const bool value);
+#ifdef TEXTURE_PACKER_PRESENT
+	bool get_merge_textures() const;
+	void set_merge_textures(const bool value);
+#endif
 
-	Vector3 get_snap_axis() const;
-	void set_snap_axis(const Vector3 &value);
+	///Materials
+	Ref<Material> material_get(const int index);
+	void material_add(const Ref<Material> &value);
+	int material_get_num() const;
+	void materials_clear();
 
-	void bake();
-	void queue_bake();
-	void bake_finished();
+	Vector<Variant> materials_get();
+	void materials_set(const Vector<Variant> &materials);
+
+	//Meshes
+	RID mesh_get(const int index);
+	void mesh_add(const RID value);
+	int mesh_get_num() const;
+	void meshs_clear();
+
+	Vector<Variant> meshes_get();
+	void meshes_set(const Vector<Variant> &meshes);
+
+	//Colliders
+	RID collider_get(const int index);
+	void collider_add(const RID value);
+	int collider_get_num() const;
+	void colliders_clear();
+
+	Vector<Variant> colliders_get();
+	void colliders_set(const Vector<Variant> &colliders);
+
+	float get_first_lod_distance_squared();
+	void set_first_lod_distance_squared(const float dist);
+
+	float get_lod_reduction_distance_squared();
+	void set_lod_reduction_distance_squared(const float dist);
+
+	void free_meshes();
+	void free_colliders();
+
+	void init_materials();
+	virtual void _init_materials();
 
 	void build();
+	void queue_build();
+	void build_finished();
+	virtual void _build_finished();
 
 	PropInstance();
 	~PropInstance();
@@ -72,18 +109,22 @@ protected:
 
 private:
 	Ref<PropData> _prop_data;
-	bool _auto_bake;
-	bool _bake_queued;
-	bool _baking;
-	bool _snap_to_mesh;
-	Vector3 _snap_axis;
+
+	bool _build_queued;
+	bool _building;
 
 	Ref<PropInstancePropJob> _job;
 
-	bool _merge_extures;
-	Vector<Ref<Material> > _original_materials;//if !_merge_extures, just use this ?
+#ifdef TEXTURE_PACKER_PRESENT
+	bool _merge_textures;
+#endif
 
-	static HashMap<Ref<PropData>, Ref<Material> > _material_map;
+	Vector<Ref<Material> > _materials;
+	Vector<RID> _meshes;
+	Vector<RID> _colliders;
+
+	float _first_lod_distance_squared;
+	float _lod_reduction_distance_squared;
 };
 
 #endif