diff --git a/Engine/Engine.cpp b/Engine/Engine.cpp
index 8e7d7d1..d76750b 100644
--- a/Engine/Engine.cpp
+++ b/Engine/Engine.cpp
@@ -12,8 +12,6 @@ Engine::Engine()
 
 	mp_renderer = std::make_shared<Renderer>(mp_window->getHandle(), mp_config->width, mp_config->height);
 
-
-	mp_renderer->createNewPipeline(base_pipeline);
 	mp_renderer->createDepthResources();
 	mp_renderer->createFramebuffer();
 
@@ -25,13 +23,13 @@ Engine::~Engine()
 {
 	vkDeviceWaitIdle(mp_renderer->getDevice());
 
-	mp_renderer->cleanSwapchain(std::make_shared<Pipeline>(base_pipeline));
+	mp_renderer->cleanSwapchain();
 
 	for (size_t i = 0; i < mp_scene->getObjects().size(); i++)
 	{
 		for (size_t t = 0; t < mp_scene->getObjects()[i]->getMeshesCount(); t++)
 		{
-			mp_scene->getObjects()[i]->getMesh(t).getMaterial()->destroyTexture();
+			mp_scene->getObjects()[i]->getMesh(t).getMaterial()->DestroyTexture();
 			mp_scene->getObjects()[i]->getMesh(t).destroyMesh();
 		}
 
@@ -58,9 +56,28 @@ void Engine::registerGameObject(std::shared_ptr<GameObject> gameobject)
 	mp_scene->addGameObject(gameobject);
 }
 
-std::shared_ptr<Renderer> Engine::getRenderEngine()
+const std::shared_ptr<Material> Engine::CreateMaterial(const TSHADER shader)
+{
+	return std::make_shared<Material>(shader, mp_renderer);
+}
+
+const std::shared_ptr<Material> Engine::CreateMaterial(const TSHADER shader, const std::string& texture_file)
+{
+	std::shared_ptr<Material> mat = std::make_shared<Material>(shader, mp_renderer);
+	mat->LoadTexture(texture_file);
+	return mat;
+}
+
+const std::shared_ptr<GameObject> Engine::CreateGameObject()
+{
+	return std::make_shared<GameObject>(mp_renderer);
+}
+
+const std::shared_ptr<GameObject> Engine::CreateGameObject(const std::string& object_file)
 {
-	return mp_renderer;
+	std::shared_ptr<GameObject> go = std::make_shared<GameObject>(mp_renderer);
+	go->loadMesh(object_file);
+	return go;
 }
 
 const bool& Engine::shouldClose()
@@ -83,9 +100,9 @@ void Engine::update()
 	const int frame = mp_renderer->getFrameIndex();
 	if (mp_scene->isUpdate(frame))
 	{
-		mp_renderer->beginRecordCommandBuffers(mp_renderer->getCommandBuffer(frame), mp_renderer->getFrameBuffer(frame), base_pipeline);
+		mp_renderer->beginRecordCommandBuffers(mp_renderer->getCommandBuffer(frame), mp_renderer->getFrameBuffer(frame));
 
-		mp_scene->render(base_pipeline, mp_renderer->getCommandBuffer(frame), frame);
+		mp_scene->render(mp_renderer->getCommandBuffer(frame), frame);
 
 		mp_renderer->endRecordCommandBuffers(mp_renderer->getCommandBuffer(frame));
 	}
@@ -98,5 +115,5 @@ void Engine::update()
 
 void Engine::draw()
 {
-	mp_renderer->draw(base_pipeline);
+	mp_renderer->draw();
 }
diff --git a/Engine/Engine.h b/Engine/Engine.h
index ad3f4da..c971bae 100644
--- a/Engine/Engine.h
+++ b/Engine/Engine.h
@@ -19,7 +19,13 @@ class Engine
 	void setScene(std::shared_ptr<Scene> p_scene);
 	void registerGameObject(std::shared_ptr<GameObject> gameobject);
 
-	std::shared_ptr<Renderer> getRenderEngine();
+	// CREATE MATERIAL
+	const std::shared_ptr<Material> CreateMaterial(const TSHADER shader);
+	const std::shared_ptr<Material> CreateMaterial(const TSHADER shader, const std::string& texture_file);
+
+	// CREATE GAMEOBJECT
+	const std::shared_ptr<GameObject> CreateGameObject();
+	const std::shared_ptr<GameObject> CreateGameObject(const std::string& object_file);
 
 	const bool& shouldClose();
 
@@ -32,8 +38,7 @@ class Engine
 	std::shared_ptr<Camera> mp_camera;
 	std::shared_ptr<Player> mp_player;
 	std::shared_ptr<Config> mp_config;
-
-	Pipeline base_pipeline;
+	
 	std::chrono::steady_clock::time_point m_last_time;
 };
 
diff --git a/Engine/Engine.vcxproj b/Engine/Engine.vcxproj
index e383d5c..930dbe4 100644
--- a/Engine/Engine.vcxproj
+++ b/Engine/Engine.vcxproj
@@ -73,6 +73,7 @@
     <ClInclude Include="graphics\Config.h" />
     <ClInclude Include="graphics\Graphics.h" />
     <ClInclude Include="graphics\Math.h" />
+    <ClInclude Include="graphics\Shaders.h" />
     <ClInclude Include="graphics\Vertex.h" />
     <ClInclude Include="Logger.h" />
     <ClInclude Include="renderer\Renderer.h" />
@@ -93,8 +94,10 @@
     <ClInclude Include="world\Texture.h" />
   </ItemGroup>
   <ItemGroup>
-    <None Include="..\shaders\shader.frag" />
-    <None Include="..\shaders\shader.vert" />
+    <None Include="assets\shaders\HLSL\no_texture_shader.frag" />
+    <None Include="assets\shaders\HLSL\shader.vert" />
+    <None Include="assets\shaders\HLSL\shader_compiler.bat" />
+    <None Include="assets\shaders\HLSL\texture_shader.frag" />
   </ItemGroup>
   <PropertyGroup Label="Globals">
     <VCProjectVersion>15.0</VCProjectVersion>
diff --git a/Engine/Engine.vcxproj.filters b/Engine/Engine.vcxproj.filters
index 0353715..9127757 100644
--- a/Engine/Engine.vcxproj.filters
+++ b/Engine/Engine.vcxproj.filters
@@ -173,12 +173,21 @@
     <ClInclude Include="Engine.h">
       <Filter>Header</Filter>
     </ClInclude>
+    <ClInclude Include="graphics\Shaders.h">
+      <Filter>Engine\Graphics</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
-    <None Include="..\shaders\shader.frag">
+    <None Include="assets\shaders\HLSL\no_texture_shader.frag">
+      <Filter>Asset</Filter>
+    </None>
+    <None Include="assets\shaders\HLSL\shader.vert">
+      <Filter>Asset</Filter>
+    </None>
+    <None Include="assets\shaders\HLSL\shader_compiler.bat">
       <Filter>Asset</Filter>
     </None>
-    <None Include="..\shaders\shader.vert">
+    <None Include="assets\shaders\HLSL\texture_shader.frag">
       <Filter>Asset</Filter>
     </None>
   </ItemGroup>
diff --git a/Engine/Source.cpp b/Engine/Source.cpp
index 2db8ede..f186c9b 100644
--- a/Engine/Source.cpp
+++ b/Engine/Source.cpp
@@ -7,19 +7,14 @@ int main()
 		Engine engine;
 		Logger::init();
 
-		std::shared_ptr<Material> room_texture = std::make_shared<Material>();
-		room_texture->loadTexture("assets/textures/viking_room.png", engine.getRenderEngine());
+		std::shared_ptr<Material> room_texture = engine.CreateMaterial(TSHADER::TEXTURE);
+		room_texture->LoadTexture("assets/textures/viking_room.png");
 
-		std::shared_ptr<GameObject> room = std::make_shared<GameObject>(engine.getRenderEngine());
+		std::shared_ptr<GameObject> room = engine.CreateGameObject();
 		room->loadMesh("assets/models/viking_room.obj");
 		room->bindMatToMesh(0, room_texture);
 		room->setPosition({ 3.0f, 0.0f, 0.0f });
 
-		std::shared_ptr<Material> room2_texture = std::make_shared<Material>();
-		room2_texture->loadTexture("assets/textures/viking_room.png", engine.getRenderEngine());
-
-		std::shared_ptr<GameObject> room2 = std::make_shared<GameObject>(engine.getRenderEngine());
-
 		std::shared_ptr<Scene> scene = std::make_shared<Scene>();
 		scene->addGameObject(room);
 
@@ -29,20 +24,6 @@ int main()
 		// running loop
 		do
 		{
-			if (init == 30000) {
-				room2->loadMesh("assets/models/viking_room.obj");
-				room2->bindMatToMesh(0, room2_texture);
-				room2->setPosition({ 13.0f, 0.0f, 0.0f });
-
-				scene->addGameObject(room2);
-			}
-
-			init++;
-
-			if (init == 60000) {
-				scene->removeGameObject(room2);
-			}
-
 			engine.update();
 			engine.draw();
 		} while (!engine.shouldClose());
diff --git a/Engine/assets/shaders/HLSL/no_texture_shader.frag b/Engine/assets/shaders/HLSL/no_texture_shader.frag
new file mode 100644
index 0000000..c33b655
--- /dev/null
+++ b/Engine/assets/shaders/HLSL/no_texture_shader.frag
@@ -0,0 +1,10 @@
+#version 450
+#extension GL_ARB_separate_shader_objects : enable
+
+layout(location = 0) in vec3 fragColor;
+
+layout(location = 0) out vec4 outColor;
+
+void main() {
+    outColor = vec4(fragColor, 1.0f);
+}
\ No newline at end of file
diff --git a/Engine/assets/shaders/shader.vert b/Engine/assets/shaders/HLSL/shader.vert
similarity index 100%
rename from Engine/assets/shaders/shader.vert
rename to Engine/assets/shaders/HLSL/shader.vert
diff --git a/Engine/assets/shaders/HLSL/shader_compiler.bat b/Engine/assets/shaders/HLSL/shader_compiler.bat
new file mode 100644
index 0000000..0e6f3f5
--- /dev/null
+++ b/Engine/assets/shaders/HLSL/shader_compiler.bat
@@ -0,0 +1,7 @@
+F:\Programs\VulkanSDK\1.2.170.0\Bin32\glslangValidator.exe -V shader.vert
+F:\Programs\VulkanSDK\1.2.170.0\Bin32\glslangValidator.exe -V texture_shader.frag
+F:\Programs\VulkanSDK\1.2.170.0\Bin32\glslangValidator.exe -V no_texture_shader.frag
+pause
+F:\Programs\VulkanSDK\1.2.170.0\Bin32\glslc.exe shader.vert -o vert.spv
+F:\Programs\VulkanSDK\1.2.170.0\Bin32\glslc.exe texture_shader.frag -o texture_shader.spv
+F:\Programs\VulkanSDK\1.2.170.0\Bin32\glslc.exe no_texture_shader.frag -o no_texture_shader.spv
\ No newline at end of file
diff --git a/Engine/assets/shaders/shader.frag b/Engine/assets/shaders/HLSL/texture_shader.frag
similarity index 88%
rename from Engine/assets/shaders/shader.frag
rename to Engine/assets/shaders/HLSL/texture_shader.frag
index ffaea9d..4b05b1c 100644
--- a/Engine/assets/shaders/shader.frag
+++ b/Engine/assets/shaders/HLSL/texture_shader.frag
@@ -9,5 +9,6 @@ layout(location = 1) in vec2 fragTexCoord;
 layout(location = 0) out vec4 outColor;
 
 void main() {
+    outColor = vec4(fragColor, 1.0f);
     outColor = texture(texSampler, fragTexCoord);
 }
\ No newline at end of file
diff --git a/Engine/assets/shaders/frag.spv b/Engine/assets/shaders/frag.spv
index eac4c9d..0e7d70f 100644
Binary files a/Engine/assets/shaders/frag.spv and b/Engine/assets/shaders/frag.spv differ
diff --git a/Engine/assets/shaders/no_texture_shader.spv b/Engine/assets/shaders/no_texture_shader.spv
new file mode 100644
index 0000000..cb13e60
Binary files /dev/null and b/Engine/assets/shaders/no_texture_shader.spv differ
diff --git a/Engine/assets/shaders/shader_compiler.bat b/Engine/assets/shaders/shader_compiler.bat
deleted file mode 100644
index 75b899c..0000000
--- a/Engine/assets/shaders/shader_compiler.bat
+++ /dev/null
@@ -1,3 +0,0 @@
-C:\VulkanSDK\1.1.82.1\Bin32\glslangValidator.exe -V shader.vert
-C:\VulkanSDK\1.1.82.1\Bin32\glslangValidator.exe -V shader.frag
-pause
\ No newline at end of file
diff --git a/Engine/assets/shaders/texture_shader.spv b/Engine/assets/shaders/texture_shader.spv
new file mode 100644
index 0000000..10b6f7d
Binary files /dev/null and b/Engine/assets/shaders/texture_shader.spv differ
diff --git a/Engine/assets/shaders/vert.spv b/Engine/assets/shaders/vert.spv
index 8b4708a..d49c384 100644
Binary files a/Engine/assets/shaders/vert.spv and b/Engine/assets/shaders/vert.spv differ
diff --git a/Engine/graphics/Shaders.h b/Engine/graphics/Shaders.h
new file mode 100644
index 0000000..5d979e7
--- /dev/null
+++ b/Engine/graphics/Shaders.h
@@ -0,0 +1,15 @@
+#ifndef _SHADERS_H
+#define _SHADERS_H
+
+#include <array>
+#include <string>
+
+struct Shaders {
+	std::array<const std::string, 3> fragment_shader_files = {
+		"assets/shaders/frag.spv",
+		"assets/shaders/no_texture_shader.spv",
+		"assets/shaders/texture_shader.spv"
+	};
+};
+
+#endif // !_SHADERS_H
\ No newline at end of file
diff --git a/Engine/renderer/Renderer.cpp b/Engine/renderer/Renderer.cpp
index 6111d76..704416e 100644
--- a/Engine/renderer/Renderer.cpp
+++ b/Engine/renderer/Renderer.cpp
@@ -17,7 +17,6 @@ Renderer::Renderer(GLFWwindow& window, uint32_t width, uint32_t height)
 	WIDTH = std::make_unique<uint32_t>(width);
 	HEIGHT = std::make_unique<uint32_t>(height);
 
-	m_pPipelineFactory = std::make_unique<VulkanPipeline>(m_graphic);
 	m_pBufferFactory = std::make_unique<VulkanBuffer>(m_graphic);
 
 	setupInstance(window);
@@ -26,6 +25,8 @@ Renderer::Renderer(GLFWwindow& window, uint32_t width, uint32_t height)
 	setupRenderPass();
 	setupDescriptorSetLayout();
 	setupCommandPool();
+
+	mp_pipelines_manager = std::make_unique<VulkanPipeline>(m_graphic);
 }
 
 
@@ -51,7 +52,7 @@ Renderer::~Renderer()
 	vkDestroyInstance(m_graphic.instance, nullptr);
 }
 
-int32_t Renderer::draw(Pipeline& pipeline)
+int32_t Renderer::draw()
 {
 	vkWaitForFences(m_graphic.device, 1, &m_graphic.fences_in_flight[m_frame_index], VK_TRUE, std::numeric_limits<uint64_t>::max());
 	vkResetFences(m_graphic.device, 1, &m_graphic.fences_in_flight[m_frame_index]);
@@ -67,7 +68,7 @@ int32_t Renderer::draw(Pipeline& pipeline)
 
 	if (result == VK_ERROR_OUT_OF_DATE_KHR)
 	{
-		recreateSwapchain(pipeline);
+		recreateSwapchain();
 		return 1;
 	}
 	else if (result != VK_SUCCESS && result != VK_SUBOPTIMAL_KHR)
@@ -118,7 +119,7 @@ int32_t Renderer::draw(Pipeline& pipeline)
 
 	if (result == VK_ERROR_OUT_OF_DATE_KHR || result == VK_SUBOPTIMAL_KHR)
 	{
-		recreateSwapchain(pipeline);
+		recreateSwapchain();
 		return 1;
 	}
 	else if (result != VK_SUCCESS)
@@ -165,11 +166,6 @@ void Renderer::setupCommandPool()
 	m_commandPool = std::make_unique<VulkanCommandPool>(m_graphic);
 }
 
-void Renderer::createNewPipeline(Pipeline& pipeline)
-{
-	m_pPipelineFactory->createPipeline(pipeline);
-}
-
 VkDevice& Renderer::getDevice()
 {
 	return m_graphic.device;
@@ -205,6 +201,11 @@ std::unique_ptr<VulkanBuffer>& Renderer::getBufferFactory()
 	return m_pBufferFactory;
 }
 
+std::unique_ptr<VulkanPipeline>& Renderer::GetPipelineFactory()
+{
+	return mp_pipelines_manager;
+}
+
 const int Renderer::getFrameIndex()
 {
 	return m_frame_index;
@@ -294,7 +295,7 @@ void Renderer::allocateCommandBuffers()
 	}
 }
 
-void Renderer::beginRecordCommandBuffers(VkCommandBuffer & commandBuffer, VkFramebuffer& frameBuffer, Pipeline & pipeline)
+void Renderer::beginRecordCommandBuffers(VkCommandBuffer & commandBuffer, VkFramebuffer& frameBuffer)
 {
 	std::array<VkClearValue, 2> clear_values = {};
 	clear_values[0].color = { 0.0f, 0.0f, 0.0f, 1.0f };
@@ -322,7 +323,6 @@ void Renderer::beginRecordCommandBuffers(VkCommandBuffer & commandBuffer, VkFram
 	renderPassInfo.pClearValues = clear_values.data();
 
 	m_pRenderpass->beginRenderPass(commandBuffer, renderPassInfo);
-	m_pPipelineFactory->bindPipeline(commandBuffer, pipeline);
 }
 
 void Renderer::endRecordCommandBuffers(VkCommandBuffer & commandBuffer)
@@ -492,20 +492,35 @@ void Renderer::allocateDescriptorSet(VkDescriptorSet& descriptor_set)
 	}
 }
 
-void Renderer::updateDescriptorSet(const VkBuffer& ubo, const VkDescriptorSet& descriptor_set, const VkImageView& image_view, const VkSampler& image_sampler)
+void Renderer::updateDescriptorSet(const VkBuffer& ubo, const VkDescriptorSet& descriptor_set)
 {
+	std::array<VkWriteDescriptorSet, 1> descriptorWrites = {};
+
 	VkDescriptorBufferInfo bufferInfo = {};
 	bufferInfo.buffer = ubo;
 	bufferInfo.offset = 0;
 	bufferInfo.range = sizeof(UniformBufferObject);
 
-	VkDescriptorImageInfo imageInfo = {};
-	imageInfo.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
-	imageInfo.imageView = image_view;
-	imageInfo.sampler = image_sampler;
+	descriptorWrites[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+	descriptorWrites[0].dstSet = descriptor_set;
+	descriptorWrites[0].dstBinding = 0;
+	descriptorWrites[0].dstArrayElement = 0;
+	descriptorWrites[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
+	descriptorWrites[0].descriptorCount = 1;
+	descriptorWrites[0].pBufferInfo = &bufferInfo;
 
+	vkUpdateDescriptorSets(m_graphic.device, static_cast<uint32_t>(descriptorWrites.size()), descriptorWrites.data(), 0, nullptr);
+}
 
+void Renderer::updateDescriptorSet(const VkBuffer& ubo, const VkDescriptorSet& descriptor_set, const VkImageView& image_view, const VkSampler& image_sampler)
+{
 	std::array<VkWriteDescriptorSet, 2> descriptorWrites = {};
+
+	VkDescriptorBufferInfo bufferInfo = {};
+	bufferInfo.buffer = ubo;
+	bufferInfo.offset = 0;
+	bufferInfo.range = sizeof(UniformBufferObject);
+
 	descriptorWrites[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
 	descriptorWrites[0].dstSet = descriptor_set;
 	descriptorWrites[0].dstBinding = 0;
@@ -514,6 +529,11 @@ void Renderer::updateDescriptorSet(const VkBuffer& ubo, const VkDescriptorSet& d
 	descriptorWrites[0].descriptorCount = 1;
 	descriptorWrites[0].pBufferInfo = &bufferInfo;
 
+	VkDescriptorImageInfo imageInfo = {};
+	imageInfo.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
+	imageInfo.imageView = image_view;
+	imageInfo.sampler = image_sampler;
+
 	descriptorWrites[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
 	descriptorWrites[1].dstSet = descriptor_set;
 	descriptorWrites[1].dstBinding = 1;
@@ -605,10 +625,10 @@ void Renderer::createImage(uint32_t width, uint32_t height, VkFormat format, VkI
 	vkBindImageMemory(m_graphic.device, image, imageMemory, 0);
 }
 
-void Renderer::recreateSwapchain(Pipeline& pipeline)
+void Renderer::recreateSwapchain()
 {
 	vkDeviceWaitIdle(m_graphic.device);
-	cleanSwapchain(std::make_shared<Pipeline>(pipeline));
+	cleanSwapchain();
 
 
 	m_swapchain->createSwapchain();
@@ -616,13 +636,13 @@ void Renderer::recreateSwapchain(Pipeline& pipeline)
 	VkFormat format = findSupportedFormat({ VK_FORMAT_D32_SFLOAT, VK_FORMAT_D32_SFLOAT_S8_UINT, VK_FORMAT_D24_UNORM_S8_UINT }, VK_IMAGE_TILING_OPTIMAL, VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT);
 	m_pRenderpass->createRenderPass(format);
 
-	createNewPipeline(pipeline);
+	mp_pipelines_manager->CreatePipelines();
 	createDepthResources();
 	createFramebuffer();
 	allocateCommandBuffers();
 }
 
-void Renderer::cleanSwapchain(std::shared_ptr<Pipeline> pPipeline)
+void Renderer::cleanSwapchain()
 {
 	vkDestroyImageView(m_graphic.device, m_graphic.depth_view, nullptr);
 	vkDestroyImage(m_graphic.device, m_graphic.depth_image, nullptr);
@@ -636,8 +656,7 @@ void Renderer::cleanSwapchain(std::shared_ptr<Pipeline> pPipeline)
 	
 	vkFreeCommandBuffers(m_graphic.device, m_graphic.command_pool, static_cast<uint32_t>(m_graphic.command_buffers.size()), m_graphic.command_buffers.data());
 
-	vkDestroyPipeline(m_graphic.device, pPipeline->handle, nullptr);
-	vkDestroyPipelineLayout(m_graphic.device, pPipeline->layout, nullptr);
+	mp_pipelines_manager->DestroyPipelines();
 
 	vkDestroyRenderPass(m_graphic.device, m_graphic.render_pass, nullptr);
 
diff --git a/Engine/renderer/Renderer.h b/Engine/renderer/Renderer.h
index 6c89ebd..e08375c 100644
--- a/Engine/renderer/Renderer.h
+++ b/Engine/renderer/Renderer.h
@@ -35,7 +35,7 @@ class Renderer
 	Renderer(GLFWwindow& window, uint32_t width, uint32_t height);
 	~Renderer();
 
-	int32_t draw(Pipeline& pipeline);
+	int32_t draw();
 
 	void setupInstance(GLFWwindow& window);
 	void setupDevice();
@@ -43,7 +43,6 @@ class Renderer
 	void setupRenderPass();
 	void setupDescriptorSetLayout();
 	void setupCommandPool();
-	void createNewPipeline(Pipeline& pipeline);
 
 	//getters
 	VkDevice& getDevice();
@@ -53,6 +52,7 @@ class Renderer
 	const size_t getNumberCommandBuffer();
 	VkFramebuffer& getFrameBuffer(const size_t& i);
 	std::unique_ptr<VulkanBuffer>& getBufferFactory();
+	std::unique_ptr<VulkanPipeline>& GetPipelineFactory();
 	const int getFrameIndex();
 
 	//rendering
@@ -62,7 +62,7 @@ class Renderer
 	void createUBO(VkBuffer& uniform_buffer, VkDeviceMemory& uniform_memory);
 
 	void allocateCommandBuffers();
-	void beginRecordCommandBuffers(VkCommandBuffer& commandBuffer, VkFramebuffer& frameBuffer, Pipeline& pipeline);
+	void beginRecordCommandBuffers(VkCommandBuffer& commandBuffer, VkFramebuffer& frameBuffer);
 	void endRecordCommandBuffers(VkCommandBuffer& commandBuffer);
 	//!rendering
 
@@ -74,6 +74,7 @@ class Renderer
 	void createDescriptorLayout();
 	void createDescriptorPool();
 	void allocateDescriptorSet(VkDescriptorSet& descriptor_set);
+	void updateDescriptorSet(const VkBuffer& ubo, const VkDescriptorSet& descriptor_set);
 	void updateDescriptorSet(const VkBuffer& ubo, const VkDescriptorSet& descriptor_set, const VkImageView& image_view, const VkSampler& image_sampler);
 	void createDepthResources();
 
@@ -81,11 +82,11 @@ class Renderer
 	//cleaning
 	void destroyUniformBuffer();
 	void destroyBuffers(Buffer& buffers);
-	void cleanSwapchain(std::shared_ptr<Pipeline> pPipeline);
+	void cleanSwapchain();
 
 
 	//init fonctions
-	void recreateSwapchain(Pipeline& pipeline);
+	void recreateSwapchain();
 	
 
 	//helper fonctions
@@ -136,7 +137,7 @@ class Renderer
 	std::unique_ptr<VulkanRenderPass> m_pRenderpass;
 	std::unique_ptr<VulkanDescriptor> m_descriptor;
 	std::unique_ptr<VulkanCommandPool> m_commandPool;
-	std::unique_ptr<VulkanPipeline> m_pPipelineFactory;
+	std::unique_ptr<VulkanPipeline> mp_pipelines_manager;
 	std::unique_ptr<VulkanBuffer> m_pBufferFactory;
 
 	size_t m_frame_index = 0;
diff --git a/Engine/renderer/VulkanPipeline.cpp b/Engine/renderer/VulkanPipeline.cpp
index c0cf8d1..e68a545 100644
--- a/Engine/renderer/VulkanPipeline.cpp
+++ b/Engine/renderer/VulkanPipeline.cpp
@@ -4,6 +4,7 @@
 
 VulkanPipeline::VulkanPipeline(Graphics & m_graphic) : m_graphic(m_graphic)
 {
+	CreatePipelines();
 }
 
 
@@ -11,13 +12,43 @@ VulkanPipeline::~VulkanPipeline()
 {
 }
 
-void VulkanPipeline::createPipeline(Pipeline& pipeline)
+void VulkanPipeline::CreatePipelines()
+{
+	for (size_t i = 0; i < m_pipelines.size(); i++)
+	{
+		createPipeline(m_pipelines[i], m_shaders.fragment_shader_files[i]);
+	}
+}
+
+void VulkanPipeline::DestroyPipelines()
+{
+	for (size_t i = 0; i < m_pipelines.size(); i++)
+	{
+		vkDestroyPipeline(m_graphic.device, m_pipelines[i].handle, nullptr);
+		vkDestroyPipelineLayout(m_graphic.device, m_pipelines[i].layout, nullptr);
+	}
+}
+
+const Pipeline& VulkanPipeline::GetPipeline(const TSHADER shader)
+{
+	switch (shader)
+	{
+	case TSHADER::NO_TEXTURE:
+		return m_pipelines[1];
+	case TSHADER::TEXTURE:
+		return m_pipelines[2];
+	default:
+		return m_pipelines[0];
+	}
+}
+
+void VulkanPipeline::createPipeline(Pipeline& pipeline, const std::string& shader_file)
 {
 	auto bindingDescription = Vertex::getBindingDescription();
 	auto attributeDescriptions = Vertex::getAttributeDescriptions();
 
 	auto vertShaderCode = readFile("assets/shaders/vert.spv");
-	auto fragShaderCode = readFile("assets/shaders/frag.spv");
+	auto fragShaderCode = readFile(shader_file);
 
 	VkShaderModule vertShaderModule = createShaderModule(vertShaderCode);
 	VkShaderModule fragShaderModule = createShaderModule(fragShaderCode);
@@ -144,9 +175,20 @@ void VulkanPipeline::createPipeline(Pipeline& pipeline)
 	vkDestroyShaderModule(m_graphic.device, vertShaderModule, nullptr);
 }
 
-void VulkanPipeline::bindPipeline(VkCommandBuffer& commandBuffer, Pipeline& pipeline)
+VkShaderModule VulkanPipeline::createShaderModule(const std::vector<char>& code)
 {
-	vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline.handle);
+	VkShaderModuleCreateInfo shader_module_info = {};
+	shader_module_info.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
+	shader_module_info.codeSize = code.size();
+	shader_module_info.pCode = reinterpret_cast<const uint32_t*>(code.data());
+
+	VkShaderModule shaderModule;
+	if (vkCreateShaderModule(m_graphic.device, &shader_module_info, nullptr, &shaderModule) != VK_SUCCESS)
+	{
+		throw std::runtime_error("failed to create shader module!");
+	}
+
+	return shaderModule;
 }
 
 std::vector<char> VulkanPipeline::readFile(const std::string & filename)
@@ -168,19 +210,3 @@ std::vector<char> VulkanPipeline::readFile(const std::string & filename)
 
 	return buffer;
 }
-
-VkShaderModule VulkanPipeline::createShaderModule(const std::vector<char>& code)
-{
-	VkShaderModuleCreateInfo shader_module_info = {};
-	shader_module_info.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
-	shader_module_info.codeSize = code.size();
-	shader_module_info.pCode = reinterpret_cast<const uint32_t*>(code.data());
-
-	VkShaderModule shaderModule;
-	if (vkCreateShaderModule(m_graphic.device, &shader_module_info, nullptr, &shaderModule) != VK_SUCCESS)
-	{
-		throw std::runtime_error("failed to create shader module!");
-	}
-
-	return shaderModule;
-}
diff --git a/Engine/renderer/VulkanPipeline.h b/Engine/renderer/VulkanPipeline.h
index 158cc9e..290a244 100644
--- a/Engine/renderer/VulkanPipeline.h
+++ b/Engine/renderer/VulkanPipeline.h
@@ -5,6 +5,14 @@
 
 #include "../graphics/Vertex.h"
 #include "../graphics/Graphics.h"
+#include "../graphics/Shaders.h"
+
+enum class TSHADER
+{
+	DEFAULT,
+	NO_TEXTURE,
+	TEXTURE
+};
 
 class VulkanPipeline
 {
@@ -12,15 +20,20 @@ class VulkanPipeline
 	VulkanPipeline(Graphics & m_graphic);
 	~VulkanPipeline();
 
-	void createPipeline(Pipeline& pipeline);
-	void bindPipeline(VkCommandBuffer& commandBuffer, Pipeline& pipeline);
+	void CreatePipelines();
+	void DestroyPipelines();
 
-private:
+	const Pipeline& GetPipeline(const TSHADER shader);
 
-	std::vector<char> readFile(const std::string& filename);
+private:
+	void createPipeline(Pipeline& pipeline, const std::string& shader_file);
 	VkShaderModule createShaderModule(const std::vector<char>& code);
 
-	Graphics & m_graphic;
+	std::vector<char> readFile(const std::string& filename);//should be in other file
+
+	std::array<Pipeline, 3> m_pipelines;
+	Graphics & m_graphic;//should be shared ptr
+	Shaders m_shaders;
 };
 
 #endif _VULKAN_PIPELINE_H
\ No newline at end of file
diff --git a/Engine/world/GameObject.cpp b/Engine/world/GameObject.cpp
index 6059165..f06a7e9 100644
--- a/Engine/world/GameObject.cpp
+++ b/Engine/world/GameObject.cpp
@@ -22,11 +22,11 @@ void GameObject::destroy()
 	vkFreeMemory(mp_renderer->getDevice(), m_ubo_memory, nullptr);
 }
 
-void GameObject::registerDrawCmd(VkCommandBuffer& command_buffer, Pipeline& pipeline)
+void GameObject::registerDrawCmd(VkCommandBuffer& command_buffer)
 {
 	for (size_t i = 0; i < m_meshes.size(); i++)
 	{
-		m_meshes[i].draw(command_buffer, pipeline);
+		m_meshes[i].draw(command_buffer);
 	}
 }
 
diff --git a/Engine/world/GameObject.h b/Engine/world/GameObject.h
index cdbec75..5b7fa36 100644
--- a/Engine/world/GameObject.h
+++ b/Engine/world/GameObject.h
@@ -14,7 +14,7 @@ class GameObject
 
 	void destroy();
 
-	void registerDrawCmd(VkCommandBuffer& command_buffer, Pipeline& pipeline);
+	void registerDrawCmd(VkCommandBuffer& command_buffer);
 	void bindMatToMesh(const size_t& index, std::shared_ptr<Material> p_material);
 
 	void loadMesh(const std::string& mesh_path);
diff --git a/Engine/world/Material.cpp b/Engine/world/Material.cpp
index 1b727e0..3bd817a 100644
--- a/Engine/world/Material.cpp
+++ b/Engine/world/Material.cpp
@@ -1,7 +1,8 @@
 #include "Material.h"
 
-Material::Material()
+Material::Material(const TSHADER shader, std::shared_ptr<Renderer> p_renderer) : m_shader(shader), mp_renderer(p_renderer)
 {
+	m_descriptor_set = VK_NULL_HANDLE;
 }
 
 Material::~Material()
@@ -9,21 +10,47 @@ Material::~Material()
 	m_texture.reset();
 }
 
-void Material::loadTexture(const std::string& texture_path, std::shared_ptr<Renderer> renderer)
+void Material::setColor(glm::vec3 color)
 {
-	m_texture = std::make_shared<Texture>(texture_path, renderer);
+	m_color = std::make_shared<glm::vec3>(color);
+}
+
+void Material::clearColor()
+{
+	m_color.reset();
+	m_color = nullptr;
+}
+
+void Material::LoadTexture(const std::string& texture_path)
+{
+	m_texture = std::make_shared<Texture>(texture_path, mp_renderer);
 	m_texture->createTextureImage();
 	m_texture->createTextureImageView();
 	m_texture->createTextureSampler();
 }
 
+void Material::DestroyTexture()
+{
+	m_texture.reset();
+	m_texture = nullptr;
+}
+
+std::shared_ptr<glm::vec3> Material::getColor()
+{
+	return m_color;
+}
+
 std::shared_ptr<Texture> Material::getTexture()
 {
 	return m_texture;
 }
 
-void Material::destroyTexture()
+const Pipeline& Material::GetPipeline()
 {
-	m_texture.reset();
-	m_texture = nullptr;
+	return mp_renderer->GetPipelineFactory()->GetPipeline(m_shader);
+}
+
+VkDescriptorSet& Material::getDescriptorSet()
+{
+	return m_descriptor_set;
 }
diff --git a/Engine/world/Material.h b/Engine/world/Material.h
index 72e6c70..a0425f4 100644
--- a/Engine/world/Material.h
+++ b/Engine/world/Material.h
@@ -10,15 +10,26 @@
 class Material
 {
 public:
-	Material();
+	Material(const TSHADER shader, std::shared_ptr<Renderer> p_renderer);
 	~Material();
 
-	void loadTexture(const std::string& texture_path, std::shared_ptr<Renderer> renderer);
-	std::shared_ptr<Texture> getTexture();
-	void destroyTexture();
+	void setColor(glm::vec3 color);
+	void clearColor();
+
+	void LoadTexture(const std::string& texture_path);
+	void DestroyTexture();
 
+	std::shared_ptr<glm::vec3> getColor();
+	std::shared_ptr<Texture> getTexture();
+	const Pipeline& GetPipeline();
+	VkDescriptorSet& getDescriptorSet();
 private:
 	std::shared_ptr<Texture> m_texture;
+	std::shared_ptr<glm::vec3> m_color;
+
+	const TSHADER m_shader;
+	VkDescriptorSet m_descriptor_set;
+	std::shared_ptr<Renderer> mp_renderer;
 };
 
 #endif // !_MATERIAL_H
\ No newline at end of file
diff --git a/Engine/world/Mesh.cpp b/Engine/world/Mesh.cpp
index 4b7766e..0498ee9 100644
--- a/Engine/world/Mesh.cpp
+++ b/Engine/world/Mesh.cpp
@@ -1,5 +1,8 @@
 #include "Mesh.h"
 
+Mesh::Mesh(std::shared_ptr<Renderer> p_renderer) : mp_renderer(p_renderer)
+{
+}
 
 Mesh::Mesh(const std::string& obj_path, std::shared_ptr<Renderer> p_renderer) : m_obj_path(obj_path), mp_renderer(p_renderer)
 {
@@ -10,15 +13,17 @@ Mesh::~Mesh()
 {
 }
 
-void Mesh::draw(const VkCommandBuffer& command_buffer, const Pipeline& pipeline)
+void Mesh::draw(const VkCommandBuffer& command_buffer)
 {
+	vkCmdBindPipeline(command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, p_material->GetPipeline().handle);
+
 	VkBuffer vertex_buffer[] = { m_buffer.vertex };
 	VkDeviceSize offsets[] = { 0 };
 
 	vkCmdBindVertexBuffers(command_buffer, 0, 1, vertex_buffer, offsets);
 	vkCmdBindIndexBuffer(command_buffer, m_buffer.index, 0, VK_INDEX_TYPE_UINT32);
 
-	vkCmdBindDescriptorSets(command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline.layout, 0, 1, &p_material->getTexture()->getDescriptorSet(), 0, nullptr);
+	vkCmdBindDescriptorSets(command_buffer, VK_PIPELINE_BIND_POINT_GRAPHICS, p_material->GetPipeline().layout, 0, 1, &p_material->getDescriptorSet(), 0, nullptr);
 
 	vkCmdDrawIndexed(command_buffer, static_cast<uint32_t>(m_indices.size()), 1, 0, 0, 0);
 }
@@ -67,8 +72,16 @@ void Mesh::loadModel()
 
 void Mesh::bindMaterial(std::shared_ptr<Material> mat, VkBuffer& ubo, std::shared_ptr<Renderer> renderer)
 {
-	renderer->allocateDescriptorSet(mat->getTexture()->getDescriptorSet());
-	renderer->updateDescriptorSet(ubo, mat->getTexture()->getDescriptorSet(), mat->getTexture()->getImageView(), mat->getTexture()->getSampler());
+	renderer->allocateDescriptorSet(mat->getDescriptorSet());
+
+	if (mat->getTexture() == nullptr)
+	{
+		renderer->updateDescriptorSet(ubo, mat->getDescriptorSet());
+	}
+	else
+	{
+		renderer->updateDescriptorSet(ubo, mat->getDescriptorSet(), mat->getTexture()->getImageView(), mat->getTexture()->getSampler());
+	}
 
 	p_material = mat;
 }
diff --git a/Engine/world/Mesh.h b/Engine/world/Mesh.h
index c6f1f5b..c24de48 100644
--- a/Engine/world/Mesh.h
+++ b/Engine/world/Mesh.h
@@ -17,10 +17,11 @@
 class Mesh
 {
 public:
+	Mesh(std::shared_ptr<Renderer> p_renderer);
 	Mesh(const std::string& obj_path, std::shared_ptr<Renderer> p_renderer);
 	~Mesh();
 
-	void draw(const VkCommandBuffer& command_buffer, const Pipeline& pipeline);
+	void draw(const VkCommandBuffer& command_buffer);
 	void loadModel();
 	void bindMaterial(std::shared_ptr<Material> mat, VkBuffer& ubo, std::shared_ptr<Renderer> renderer);
 	void createBuffer(std::shared_ptr<Renderer> engine);
diff --git a/Engine/world/Scene.cpp b/Engine/world/Scene.cpp
index c0985f2..eca397c 100644
--- a/Engine/world/Scene.cpp
+++ b/Engine/world/Scene.cpp
@@ -44,11 +44,11 @@ R3DResult Scene::removeGameObject(std::shared_ptr<GameObject> gameobject)
 	return R3DResult::R3D_OBJECT_NOT_FOUND;
 }
 
-void Scene::render(Pipeline& pipeline, VkCommandBuffer& command_buffer, const int i)
+void Scene::render(VkCommandBuffer& command_buffer, const int i)
 {
 	for (size_t i = 0; i < vp_objects.size(); i++)
 	{
-		vp_objects[i]->registerDrawCmd(command_buffer, pipeline);
+		vp_objects[i]->registerDrawCmd(command_buffer);
 	}
 
 	m_changed[i] = false;
diff --git a/Engine/world/Scene.h b/Engine/world/Scene.h
index 5f9e626..6c153b7 100644
--- a/Engine/world/Scene.h
+++ b/Engine/world/Scene.h
@@ -18,7 +18,7 @@ class Scene
 
 	R3DResult addGameObject(std::shared_ptr<GameObject> gameobject);
 	R3DResult removeGameObject(std::shared_ptr<GameObject> gameobject);
-	void render(Pipeline& pipeline, VkCommandBuffer& command_buffer, const int i);
+	void render(VkCommandBuffer& command_buffer, const int i);
 	void updateUBO(std::shared_ptr<Camera> p_camera, std::shared_ptr<Renderer> p_renderer);
 
 	const bool& isUpdate(const int i);
diff --git a/Engine/world/Texture.cpp b/Engine/world/Texture.cpp
index 20793d0..6d29022 100644
--- a/Engine/world/Texture.cpp
+++ b/Engine/world/Texture.cpp
@@ -10,7 +10,6 @@ Texture::Texture(const std::string& texture_path, std::shared_ptr<Renderer> p_re
 	m_texture_view = VK_NULL_HANDLE;
 	m_texture_sampler = VK_NULL_HANDLE;
 	m_texture_memory = VK_NULL_HANDLE;
-	m_descriptor_set = VK_NULL_HANDLE;
 }
 
 Texture::~Texture()
@@ -100,8 +99,3 @@ const VkSampler& Texture::getSampler()
 {
 	return m_texture_sampler;
 }
-
-VkDescriptorSet& Texture::getDescriptorSet()
-{
-	return m_descriptor_set;
-}
diff --git a/Engine/world/Texture.h b/Engine/world/Texture.h
index a07a442..a1fbcd3 100644
--- a/Engine/world/Texture.h
+++ b/Engine/world/Texture.h
@@ -15,7 +15,6 @@ class Texture
 
 	const VkImageView& getImageView();
 	const VkSampler& getSampler();
-	VkDescriptorSet& getDescriptorSet();
 
 private:
 	const std::string m_texture_path;
@@ -25,8 +24,6 @@ class Texture
 	VkSampler m_texture_sampler;
 	VkDeviceMemory m_texture_memory;
 
-	VkDescriptorSet m_descriptor_set;
-
 	std::shared_ptr<Renderer> mp_renderer;
 };