diff --git a/.gitmodules b/.gitmodules
index c9eb19ee6ba09ded88a81b5ad253b2ae8c73c814..ae8c7aef11bba6c98adc54f5f9899f3255125196 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -14,7 +14,7 @@
 	path = modules/asset_loader/lib/stb
 	url = https://github.com/nothings/stb.git
 [submodule "modules/camera/lib/glm"]
-	path = modules/camera/lib/glm
+	path = modules/geometry/lib/glm
 	url = https://github.com/g-truc/glm.git
 [submodule "modules/shader_compiler/lib/glslang"]
 	path = modules/shader_compiler/lib/glslang
diff --git a/modules/CMakeLists.txt b/modules/CMakeLists.txt
index 1bd5a48df5ea3c53a26509e76aa8daed0fea5b10..e5bc34dfdf183f8dc26639771f44201597beaa73 100644
--- a/modules/CMakeLists.txt
+++ b/modules/CMakeLists.txt
@@ -7,6 +7,7 @@ add_subdirectory(algorithm)
 add_subdirectory(asset_loader)
 add_subdirectory(camera)
 add_subdirectory(effects)
+add_subdirectory(geometry)
 add_subdirectory(gui)
 add_subdirectory(material)
 add_subdirectory(meshlet)
diff --git a/modules/camera/CMakeLists.txt b/modules/camera/CMakeLists.txt
index cfc3414651ea116cd9dd9c18b35f72c6a0d52b36..dbe5c85c0ae839a0b0ab8c3de059c442d22f2d59 100644
--- a/modules/camera/CMakeLists.txt
+++ b/modules/camera/CMakeLists.txt
@@ -27,15 +27,21 @@ add_library(vkcv_camera ${vkcv_build_attribute} ${vkcv_camera_sources})
 set(vkcv_camera_lib lib)
 set(vkcv_camera_lib_path ${PROJECT_SOURCE_DIR}/${vkcv_camera_lib})
 
-include(config/GLM.cmake)
-
-target_link_libraries(vkcv_camera PUBLIC ${vkcv_camera_libraries} vkcv)
+target_link_libraries(vkcv_camera PUBLIC
+		${vkcv_camera_libraries}
+		vkcv
+		vkcv_geometry
+)
 
-target_include_directories(vkcv_camera SYSTEM BEFORE PRIVATE ${vkcv_camera_includes} ${vkcv_include} ${vkcv_includes})
+target_include_directories(vkcv_camera SYSTEM BEFORE PRIVATE
+		${vkcv_camera_includes}
+		${vkcv_include}
+		${vkcv_includes}
+		${vkcv_geometry_include}
+)
 
 # add the own include directory for public headers
 target_include_directories(vkcv_camera BEFORE PUBLIC ${vkcv_camera_include} ${vkcv_camera_includes})
-
 target_compile_definitions(vkcv_camera PUBLIC ${vkcv_camera_definitions})
 
 if (vkcv_parent_scope)
diff --git a/modules/camera/README.md b/modules/camera/README.md
index d59b4bcaef00d7bf68776b68ba6b36e9f79dbd71..c88253a1fc343337d1b2b0178306ed9c04505fed 100644
--- a/modules/camera/README.md
+++ b/modules/camera/README.md
@@ -2,14 +2,6 @@
 
 A VkCV module to manage cameras and their handle view and projection matrices
 
-## Build
-
-### Dependencies (required):
-
-| Name of dependency | Used as submodule |
-|----------------------------------------------------|---|
-| [GLM](https://github.com/g-truc/glm)   | ✅ |
-
 ## Docs
 
 Here is a [link](https://userpages.uni-koblenz.de/~vkcv/doc/group__vkcv__camera.html) to this module.
diff --git a/modules/camera/config/GLM.cmake b/modules/camera/config/GLM.cmake
deleted file mode 100644
index 53960241b8c147f522afd7afa3bfedb20f4f0761..0000000000000000000000000000000000000000
--- a/modules/camera/config/GLM.cmake
+++ /dev/null
@@ -1,23 +0,0 @@
-
-find_package(glm QUIET)
-
-if (glm_FOUND)
-    list(APPEND vkcv_camera_includes ${GLM_INCLUDE_DIRS})
-    list(APPEND vkcv_camera_libraries glm)
-else()
-    use_git_submodule("${vkcv_camera_lib_path}/glm" glm_status)
-
-    if (${glm_status})
-        add_subdirectory(${vkcv_camera_lib}/glm)
-
-        list(APPEND vkcv_camera_includes ${vkcv_camera_lib_path}/glm)
-        list(APPEND vkcv_camera_libraries glm)
-    endif ()
-endif ()
-
-list(APPEND vkcv_camera_definitions GLM_DEPTH_ZERO_TO_ONE)
-list(APPEND vkcv_camera_definitions GLM_FORCE_LEFT_HANDED)
-
-if ((WIN32) AND (${CMAKE_SIZEOF_VOID_P} MATCHES 4))
-    list(APPEND vkcv_camera_definitions GLM_ENABLE_EXPERIMENTAL)
-endif()
diff --git a/modules/geometry/CMakeLists.txt b/modules/geometry/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..183b7f4ddda01d12a2bbdb0a4a44c644276bd310
--- /dev/null
+++ b/modules/geometry/CMakeLists.txt
@@ -0,0 +1,52 @@
+cmake_minimum_required(VERSION 3.16)
+project(vkcv_geometry)
+
+# setting c++ standard for the project
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+set(vkcv_geometry_source ${PROJECT_SOURCE_DIR}/src)
+set(vkcv_geometry_include ${PROJECT_SOURCE_DIR}/include)
+
+set(vkcv_geometry_sources
+		${vkcv_geometry_include}/vkcv/geometry/Geometry.hpp
+		${vkcv_geometry_source}/vkcv/geometry/Geometry.cpp
+		${vkcv_geometry_include}/vkcv/geometry/Volume.hpp
+		${vkcv_geometry_source}/vkcv/geometry/Volume.cpp
+		${vkcv_geometry_include}/vkcv/geometry/Sphere.hpp
+		${vkcv_geometry_source}/vkcv/geometry/Sphere.cpp
+		${vkcv_geometry_include}/vkcv/geometry/Cuboid.hpp
+		${vkcv_geometry_source}/vkcv/geometry/Cuboid.cpp
+)
+
+# adding source files to the project
+add_library(vkcv_geometry ${vkcv_build_attribute} ${vkcv_geometry_sources})
+
+# Setup some path variables to load libraries
+set(vkcv_geometry_lib lib)
+set(vkcv_geometry_lib_path ${PROJECT_SOURCE_DIR}/${vkcv_geometry_lib})
+
+include(config/GLM.cmake)
+
+target_link_libraries(vkcv_geometry PUBLIC
+		${vkcv_geometry_libraries}
+		vkcv
+)
+
+target_include_directories(vkcv_geometry SYSTEM BEFORE PRIVATE
+		${vkcv_geometry_includes}
+		${vkcv_include}
+		${vkcv_includes}
+)
+
+# add the own include directory for public headers
+target_include_directories(vkcv_geometry BEFORE PUBLIC ${vkcv_geometry_include} ${vkcv_geometry_includes})
+target_compile_definitions(vkcv_geometry PUBLIC ${vkcv_geometry_definitions})
+
+if (vkcv_parent_scope)
+	list(APPEND vkcv_modules_includes ${vkcv_geometry_include})
+	list(APPEND vkcv_modules_libraries vkcv_geometry)
+	
+	set(vkcv_modules_includes ${vkcv_modules_includes} PARENT_SCOPE)
+	set(vkcv_modules_libraries ${vkcv_modules_libraries} PARENT_SCOPE)
+endif()
diff --git a/modules/geometry/README.md b/modules/geometry/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..3148a94f9c8d782cd4f1a127fd6b8f94e43d9b60
--- /dev/null
+++ b/modules/geometry/README.md
@@ -0,0 +1,15 @@
+# Geometry
+
+A VkCV module to use basic geometry for rendering.
+
+## Build
+
+### Dependencies (required):
+
+| Name of dependency                   | Used as submodule |
+|--------------------------------------|---|
+| [GLM](https://github.com/g-truc/glm) | ✅ |
+
+## Docs
+
+Here is a [link](https://userpages.uni-koblenz.de/~vkcv/doc/group__vkcv__geometry.html) to this module.
diff --git a/modules/geometry/config/GLM.cmake b/modules/geometry/config/GLM.cmake
new file mode 100644
index 0000000000000000000000000000000000000000..6a1e463ba94de14fcc707270671e535df1e45a2f
--- /dev/null
+++ b/modules/geometry/config/GLM.cmake
@@ -0,0 +1,23 @@
+
+find_package(glm QUIET)
+
+if (glm_FOUND)
+    list(APPEND vkcv_geometry_includes ${GLM_INCLUDE_DIRS})
+    list(APPEND vkcv_geometry_libraries glm)
+else()
+    use_git_submodule("${vkcv_geometry_lib_path}/glm" glm_status)
+
+    if (${glm_status})
+        add_subdirectory(${vkcv_geometry_lib}/glm)
+
+        list(APPEND vkcv_geometry_includes ${vkcv_geometry_lib_path}/glm)
+        list(APPEND vkcv_geometry_libraries glm)
+    endif ()
+endif ()
+
+list(APPEND vkcv_geometry_definitions GLM_DEPTH_ZERO_TO_ONE)
+list(APPEND vkcv_geometry_definitions GLM_FORCE_LEFT_HANDED)
+
+if ((WIN32) AND (${CMAKE_SIZEOF_VOID_P} MATCHES 4))
+    list(APPEND vkcv_geometry_definitions GLM_ENABLE_EXPERIMENTAL)
+endif()
diff --git a/modules/geometry/include/vkcv/geometry/Cuboid.hpp b/modules/geometry/include/vkcv/geometry/Cuboid.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..1ff0eafd36f1f6819110612e67835549b1ace94d
--- /dev/null
+++ b/modules/geometry/include/vkcv/geometry/Cuboid.hpp
@@ -0,0 +1,41 @@
+#pragma once
+
+#include "Volume.hpp"
+
+namespace vkcv::geometry {
+	
+	/**
+     * @addtogroup vkcv_geometry
+     * @{
+     */
+	
+	class Cuboid : public Volume {
+	private:
+		glm::vec3 m_size;
+		
+	public:
+		Cuboid(const glm::vec3& position, const glm::vec3& size);
+		
+		Cuboid(const glm::vec3& position, float size);
+		
+		Cuboid(const Cuboid& other) = default;
+		Cuboid(Cuboid&& other) = default;
+		
+		~Cuboid() = default;
+		
+		Cuboid& operator=(const Cuboid& other) = default;
+		Cuboid& operator=(Cuboid&& other) = default;
+		
+		[[nodiscard]]
+		const glm::vec3& getSize() const;
+		
+		void setSize(const glm::vec3& size);
+		
+		[[nodiscard]]
+		float distanceTo(const glm::vec3& point) override;
+		
+	};
+	
+	/** @} */
+	
+}
diff --git a/modules/geometry/include/vkcv/geometry/Geometry.hpp b/modules/geometry/include/vkcv/geometry/Geometry.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..281ff2a1f55151fdcf255894c4d6047b8b3bb542
--- /dev/null
+++ b/modules/geometry/include/vkcv/geometry/Geometry.hpp
@@ -0,0 +1,37 @@
+#pragma once
+
+#include <glm/glm.hpp>
+
+namespace vkcv::geometry {
+	
+	/**
+     * @defgroup vkcv_geometry Geometry Module
+     * A module to use basic geometry for rendering.
+     * @{
+     */
+	
+	class Geometry {
+	private:
+		glm::vec3 m_position;
+		
+	public:
+		explicit Geometry(const glm::vec3& position);
+		
+		Geometry(const Geometry& other) = default;
+		Geometry(Geometry&& other) = default;
+		
+		~Geometry() = default;
+		
+		Geometry& operator=(const Geometry& other) = default;
+		Geometry& operator=(Geometry&& other) = default;
+		
+		[[nodiscard]]
+		const glm::vec3& getPosition() const;
+		
+		void setPosition(const glm::vec3& position);
+		
+	};
+	
+	/** @} */
+
+}
diff --git a/modules/geometry/include/vkcv/geometry/Sphere.hpp b/modules/geometry/include/vkcv/geometry/Sphere.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..8370d5030571271c4b0f801977b8945386fcafac
--- /dev/null
+++ b/modules/geometry/include/vkcv/geometry/Sphere.hpp
@@ -0,0 +1,39 @@
+#pragma once
+
+#include "Volume.hpp"
+
+namespace vkcv::geometry {
+	
+	/**
+     * @addtogroup vkcv_geometry
+     * @{
+     */
+	
+	class Sphere : public Volume {
+	private:
+		float m_radius;
+		
+	public:
+		Sphere(const glm::vec3& position, float radius);
+	
+		Sphere(const Sphere& other) = default;
+		Sphere(Sphere&& other) = default;
+	
+		~Sphere() = default;
+		
+		Sphere& operator=(const Sphere& other) = default;
+		Sphere& operator=(Sphere&& other) = default;
+		
+		[[nodiscard]]
+		float getRadius() const;
+		
+		void setRadius(float radius);
+		
+		[[nodiscard]]
+		float distanceTo(const glm::vec3& point) override;
+		
+	};
+	
+	/** @} */
+
+}
diff --git a/modules/geometry/include/vkcv/geometry/Volume.hpp b/modules/geometry/include/vkcv/geometry/Volume.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..b4ba66c6d99494e56b750143d2b59134f55d9124
--- /dev/null
+++ b/modules/geometry/include/vkcv/geometry/Volume.hpp
@@ -0,0 +1,35 @@
+#pragma once
+
+#include "Geometry.hpp"
+
+namespace vkcv::geometry {
+	
+	/**
+     * @addtogroup vkcv_geometry
+     * @{
+     */
+	
+	class Volume : public Geometry {
+	private:
+	public:
+		explicit Volume(const glm::vec3& position);
+		
+		Volume(const Volume& other) = default;
+		Volume(Volume&& other) = default;
+		
+		~Volume() = default;
+		
+		Volume& operator=(const Volume& other) = default;
+		Volume& operator=(Volume&& other) = default;
+
+		[[nodiscard]]
+		virtual float distanceTo(const glm::vec3& point) = 0;
+		
+		[[nodiscard]]
+		bool contains(const glm::vec3& point);
+		
+	};
+	
+	/** @} */
+	
+}
diff --git a/modules/camera/lib/glm b/modules/geometry/lib/glm
similarity index 100%
rename from modules/camera/lib/glm
rename to modules/geometry/lib/glm
diff --git a/modules/geometry/src/vkcv/geometry/Cuboid.cpp b/modules/geometry/src/vkcv/geometry/Cuboid.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0952d5d070e2ce929bebb8ace55662382578846e
--- /dev/null
+++ b/modules/geometry/src/vkcv/geometry/Cuboid.cpp
@@ -0,0 +1,32 @@
+
+#include "vkcv/geometry/Cuboid.hpp"
+
+namespace vkcv::geometry {
+	
+	Cuboid::Cuboid(const glm::vec3 &position, const glm::vec3 &size)
+	: Volume(position), m_size(size) {}
+	
+	Cuboid::Cuboid(const glm::vec3 &position, float size)
+	: Cuboid(position, glm::vec3(size)) {}
+	
+	const glm::vec3 &Cuboid::getSize() const {
+		return m_size;
+	}
+	
+	void Cuboid::setSize(const glm::vec3 &size) {
+		m_size = size;
+	}
+	
+	float Cuboid::distanceTo(const glm::vec3 &point) {
+		const auto offset = (point - getPosition());
+		const auto distance = (glm::abs(offset) - getSize() * 0.5f);
+		const auto inside = glm::lessThanEqual(distance, glm::vec3(0.0f));
+		
+		if (glm::all(inside)) {
+			return glm::max(glm::max(distance.x, distance.y), distance.z);
+		} else {
+			return glm::length(glm::vec3(glm::not_(inside)) * distance);
+		}
+	}
+	
+}
diff --git a/modules/geometry/src/vkcv/geometry/Geometry.cpp b/modules/geometry/src/vkcv/geometry/Geometry.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ccdc45fc1be7301691f1ec14e705a0f68d83fe88
--- /dev/null
+++ b/modules/geometry/src/vkcv/geometry/Geometry.cpp
@@ -0,0 +1,17 @@
+
+#include "vkcv/geometry/Geometry.hpp"
+
+namespace vkcv::geometry {
+	
+	Geometry::Geometry(const glm::vec3 &position)
+	: m_position(position) {}
+	
+	const glm::vec3 &Geometry::getPosition() const {
+		return m_position;
+	}
+	
+	void Geometry::setPosition(const glm::vec3 &position) {
+		m_position = position;
+	}
+	
+}
diff --git a/modules/geometry/src/vkcv/geometry/Sphere.cpp b/modules/geometry/src/vkcv/geometry/Sphere.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5b32f72d3f2023636315615519c55eab57c14ee9
--- /dev/null
+++ b/modules/geometry/src/vkcv/geometry/Sphere.cpp
@@ -0,0 +1,21 @@
+
+#include "vkcv/geometry/Sphere.hpp"
+
+namespace vkcv::geometry {
+	
+	Sphere::Sphere(const glm::vec3& position, float radius)
+	: Volume(position), m_radius(radius) {}
+	
+	float Sphere::getRadius() const {
+		return m_radius;
+	}
+	
+	void Sphere::setRadius(float radius) {
+		m_radius = radius;
+	}
+	
+	float Sphere::distanceTo(const glm::vec3 &point) {
+		return glm::distance(getPosition(), point) - getRadius();
+	}
+
+}
diff --git a/modules/geometry/src/vkcv/geometry/Volume.cpp b/modules/geometry/src/vkcv/geometry/Volume.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0b503eb907aea6cc0aaeb24affb485d4d101bf4d
--- /dev/null
+++ b/modules/geometry/src/vkcv/geometry/Volume.cpp
@@ -0,0 +1,13 @@
+
+#include "vkcv/geometry/Volume.hpp"
+
+namespace vkcv::geometry {
+	
+	Volume::Volume(const glm::vec3 &position)
+	: Geometry(position) {}
+	
+	bool Volume::contains(const glm::vec3 &point) {
+		return (this->distanceTo(point) <= 0.0f);
+	}
+
+}
diff --git a/modules/scene/include/vkcv/scene/MeshPart.hpp b/modules/scene/include/vkcv/scene/MeshPart.hpp
index 61ed8fc31dc1b6d17a4d2c4ef41db59f870e5ed6..72fd6151f64c31377fb9f38b3c8dedae44905d4d 100644
--- a/modules/scene/include/vkcv/scene/MeshPart.hpp
+++ b/modules/scene/include/vkcv/scene/MeshPart.hpp
@@ -32,24 +32,9 @@ namespace vkcv::scene {
 		Scene& m_scene;
 
         /**
-         * The buffer handle of its vertex buffer.
+         * The vertex data containing its part of the mesh.
          */
-		BufferHandle m_vertices;
-
-        /**
-         * The list of the used vertex buffer bindings.
-         */
-		std::vector<VertexBufferBinding> m_vertexBindings;
-
-        /**
-         * The buffer handle of its index buffer.
-         */
-		BufferHandle m_indices;
-
-        /**
-         * The amount of indices in its index buffer.
-         */
-		size_t m_indexCount;
+		VertexData m_data;
 
         /**
          * Axis aligned bounding box of the mesh part.
diff --git a/modules/scene/src/vkcv/scene/MeshPart.cpp b/modules/scene/src/vkcv/scene/MeshPart.cpp
index d7ceacff91172fce1050ffe12aa250b89fcebf6a..959148b0c82f9ddc4068e669f56f9936f5462055 100644
--- a/modules/scene/src/vkcv/scene/MeshPart.cpp
+++ b/modules/scene/src/vkcv/scene/MeshPart.cpp
@@ -8,10 +8,7 @@ namespace vkcv::scene {
 	
 	MeshPart::MeshPart(Scene& scene) :
 	m_scene(scene),
-	m_vertices(),
-	m_vertexBindings(),
-	m_indices(),
-	m_indexCount(0),
+	m_data(),
 	m_bounds(),
 	m_materialIndex(std::numeric_limits<size_t>::max()) {}
 	
@@ -26,21 +23,44 @@ namespace vkcv::scene {
 		);
 		
 		vertexBuffer.fill(vertexGroup.vertexBuffer.data);
-		m_vertices = vertexBuffer.getHandle();
 		
-		m_vertexBindings = asset::loadVertexBufferBindings(
-				vertexGroup.vertexBuffer.attributes,
-				vertexBuffer.getHandle(),
-				types
+		m_data = VertexData(
+				asset::loadVertexBufferBindings(
+						vertexGroup.vertexBuffer.attributes,
+						vertexBuffer.getHandle(),
+						types
+				)
 		);
 		
-		auto indexBuffer = buffer<uint8_t>(
-				core, BufferType::INDEX, vertexGroup.indexBuffer.data.size()
-		);
-		
-		indexBuffer.fill(vertexGroup.indexBuffer.data);
-		m_indices = indexBuffer.getHandle();
-		m_indexCount = vertexGroup.numIndices;
+		if (!vertexGroup.indexBuffer.data.empty()) {
+			auto indexBuffer = buffer<uint8_t>(
+					core, BufferType::INDEX, vertexGroup.indexBuffer.data.size()
+			);
+			
+			indexBuffer.fill(vertexGroup.indexBuffer.data);
+			
+			IndexBitCount indexBitCount;
+			switch (vertexGroup.indexBuffer.type) {
+				case asset::IndexType::UINT8:
+					indexBitCount = IndexBitCount::Bit8;
+					break;
+				case asset::IndexType::UINT16:
+					indexBitCount = IndexBitCount::Bit16;
+					break;
+				case asset::IndexType::UINT32:
+					indexBitCount = IndexBitCount::Bit32;
+					break;
+				default:
+					indexBitCount = IndexBitCount::Bit16;
+					vkcv_log(LogLevel::WARNING, "Unsupported index type!");
+					break;
+			}
+			
+			m_data.setIndexBuffer(indexBuffer.getHandle(), indexBitCount);
+			m_data.setCount(vertexGroup.numIndices);
+		} else {
+			m_data.setCount(vertexGroup.numVertices);
+		}
 		
 		m_bounds.setMin(glm::vec3(
 				vertexGroup.min.x,
@@ -70,28 +90,8 @@ namespace vkcv::scene {
 		if (*this) {
 			const auto& material = getMaterial();
 			
-			IndexBitCount indexBitCount;
-			
-			switch (vertexGroup.indexBuffer.type) {
-				case asset::IndexType::UINT16:
-					indexBitCount = IndexBitCount::Bit16;
-					break;
-				case asset::IndexType::UINT32:
-					indexBitCount = IndexBitCount::Bit32;
-					break;
-				default:
-					indexBitCount = IndexBitCount::Bit16;
-					vkcv_log(LogLevel::WARNING, "Unsupported index type!");
-					break;
-			}
-			
-			VertexData vertexData (m_vertexBindings);
-			vertexData.setIndexBuffer(indexBuffer.getHandle(), indexBitCount);
-			vertexData.setCount(m_indexCount);
-			
-			InstanceDrawcall drawcall (vertexData);
+			InstanceDrawcall drawcall (m_data);
 			drawcall.useDescriptorSet(0, material.getDescriptorSet());
-			
 			drawcalls.push_back(drawcall);
 		}
 	}
@@ -102,10 +102,7 @@ namespace vkcv::scene {
 	
 	MeshPart::MeshPart(const MeshPart &other) :
 			m_scene(other.m_scene),
-			m_vertices(other.m_vertices),
-			m_vertexBindings(other.m_vertexBindings),
-			m_indices(other.m_indices),
-			m_indexCount(other.m_indexCount),
+			m_data(other.m_data),
 			m_bounds(other.m_bounds),
 			m_materialIndex(other.m_materialIndex) {
 		m_scene.increaseMaterialUsage(m_materialIndex);
@@ -113,10 +110,7 @@ namespace vkcv::scene {
 	
 	MeshPart::MeshPart(MeshPart &&other) noexcept :
 			m_scene(other.m_scene),
-			m_vertices(other.m_vertices),
-			m_vertexBindings(other.m_vertexBindings),
-			m_indices(other.m_indices),
-			m_indexCount(other.m_indexCount),
+			m_data(other.m_data),
 			m_bounds(other.m_bounds),
 			m_materialIndex(other.m_materialIndex) {
 		m_scene.increaseMaterialUsage(m_materialIndex);
@@ -127,10 +121,7 @@ namespace vkcv::scene {
 			return *this;
 		}
 		
-		m_vertices = other.m_vertices;
-		m_vertexBindings = other.m_vertexBindings;
-		m_indices = other.m_indices;
-		m_indexCount = other.m_indexCount;
+		m_data = other.m_data;
 		m_bounds = other.m_bounds;
 		m_materialIndex = other.m_materialIndex;
 		
@@ -138,10 +129,7 @@ namespace vkcv::scene {
 	}
 	
 	MeshPart &MeshPart::operator=(MeshPart &&other) noexcept {
-		m_vertices = other.m_vertices;
-		m_vertexBindings = other.m_vertexBindings;
-		m_indices = other.m_indices;
-		m_indexCount = other.m_indexCount;
+		m_data = other.m_data;
 		m_bounds = other.m_bounds;
 		m_materialIndex = other.m_materialIndex;
 		
@@ -155,16 +143,14 @@ namespace vkcv::scene {
 	MeshPart::operator bool() const {
 		return (
 				(getMaterial()) &&
-				(m_vertices) &&
-				(m_indices)
+				(m_data.getCount() > 0)
 		);
 	}
 	
 	bool MeshPart::operator!() const {
 		return (
 				(!getMaterial()) ||
-				(!m_vertices) ||
-				(!m_indices)
+				(m_data.getCount() <= 0)
 		);
 	}