diff --git a/assets/shaders/vulkan-test.frag b/assets/shaders/vulkan-test.frag
new file mode 100644
index 0000000..7c5b0e7
--- /dev/null
+++ b/assets/shaders/vulkan-test.frag
@@ -0,0 +1,9 @@
+#version 450
+
+layout(location = 0) in vec3 fragColor;
+
+layout(location = 0) out vec4 outColor;
+
+void main() {
+    outColor = vec4(fragColor, 1.0);
+}
diff --git a/assets/shaders/vulkan-test.frag.spv b/assets/shaders/vulkan-test.frag.spv
new file mode 100644
index 0000000..da37f7e
Binary files /dev/null and b/assets/shaders/vulkan-test.frag.spv differ
diff --git a/assets/shaders/vulkan-test.vert b/assets/shaders/vulkan-test.vert
new file mode 100644
index 0000000..02d6810
--- /dev/null
+++ b/assets/shaders/vulkan-test.vert
@@ -0,0 +1,20 @@
+#version 450
+
+layout(location = 0) out vec3 fragColor;
+
+vec2 positions[3] = vec2[](
+vec2(0.0, -0.5),
+vec2(0.5, 0.5),
+vec2(-0.5, 0.5)
+);
+
+vec3 colors[3] = vec3[](
+vec3(1.0, 0.0, 0.0),
+vec3(0.0, 1.0, 0.0),
+vec3(0.0, 0.0, 1.0)
+);
+
+void main() {
+    gl_Position = vec4(positions[gl_VertexIndex], 0.0, 1.0);
+    fragColor = colors[gl_VertexIndex];
+}
diff --git a/assets/shaders/vulkan-test.vert.spv b/assets/shaders/vulkan-test.vert.spv
new file mode 100644
index 0000000..cf7123f
Binary files /dev/null and b/assets/shaders/vulkan-test.vert.spv differ
diff --git a/engine/src/VulkanTest.cpp b/engine/src/VulkanTest.cpp
new file mode 100644
index 0000000..7f21928
--- /dev/null
+++ b/engine/src/VulkanTest.cpp
@@ -0,0 +1,700 @@
+#include "pch/enginepch.h"
+#include "VulkanTest.h"
+
+#include <fstream>
+
+int mainVulkan() {
+    VulkanTest app;
+
+    try {
+        app.run();
+    } catch (const std::exception& e) {
+        std::cerr << e.what() << std::endl;
+        return EXIT_FAILURE;
+    }
+
+    return EXIT_SUCCESS;
+}
+
+void VulkanTest::run() {
+    initWindow();
+    initVulkan();
+    mainLoop();
+    cleanup();
+}
+
+void VulkanTest::initWindow() {
+    glfwInit();
+
+    glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
+
+    window = glfwCreateWindow(1920, 1080, "Vulkan", nullptr, nullptr);
+}
+
+void VulkanTest::initVulkan() {
+    createInstance();
+    createSurface();
+    pickPhysicalDevice();
+    createLogicalDevice();
+    createSwapChain();
+    createImageViews();
+    createRenderPass();
+    createGraphicsPipeline();
+    createFramebuffers();
+    createCommandPool();
+    createCommandBuffers();
+    createSyncObjects();
+}
+
+void VulkanTest::cleanup() const {
+    cleanupSwapChain();
+    device.destroyPipeline(graphicsPipeline);
+    device.destroyPipelineLayout(pipelineLayout);
+    device.destroyRenderPass(renderPass);
+    for (size_t i = 0; i < maxFramesInFlight; i++) {
+        device.destroySemaphore(renderFinishedSemaphores[i]);
+        device.destroySemaphore(imageAvailableSemaphores[i]);
+        device.destroyFence(inFlightFences[i]);
+    }
+    device.destroyCommandPool(commandPool);
+    device.destroy();
+    instance.destroySurfaceKHR(surface);
+    instance.destroy();
+    glfwDestroyWindow(window);
+    glfwTerminate();
+}
+
+void VulkanTest::mainLoop() {
+    while (!glfwWindowShouldClose(window)) {
+        glfwPollEvents();
+        drawFrame();
+    }
+    device.waitIdle();
+}
+
+void VulkanTest::drawFrame() {
+    const vk::Semaphore imageAvailableSemaphore = imageAvailableSemaphores[currentFrame];
+    const vk::Semaphore renderFinishedSemaphore = renderFinishedSemaphores[currentFrame];
+    const vk::Fence inFlightFence = inFlightFences[currentFrame];
+    const vk::CommandBuffer commandBuffer = commandBuffers[currentFrame];
+
+    if (device.waitForFences(1, &inFlightFence, true, std::numeric_limits<uint64_t>::max()) != vk::Result::eSuccess) {
+        throw std::runtime_error("Failed to wait for fence");
+    }
+
+    const auto acquireResult = device.acquireNextImageKHR(swapChain, std::numeric_limits<uint64_t>::max(), imageAvailableSemaphore, nullptr);
+    if (acquireResult.result == vk::Result::eErrorOutOfDateKHR) {
+        recreateSwapChain();
+        return;
+    }
+    if (acquireResult.result != vk::Result::eSuccess && acquireResult.result != vk::Result::eSuboptimalKHR) {
+        throw std::runtime_error("Failed to acquire swap chain image");
+    }
+
+    if (device.resetFences(1, &inFlightFence) != vk::Result::eSuccess) {
+        throw std::runtime_error("Failed to reset fence");
+    }
+
+    commandBuffer.reset();
+    recordCommandBuffer(commandBuffer, acquireResult.value);
+
+    vk::SubmitInfo submitInfo{};
+    vk::Semaphore waitSemaphores[] = {imageAvailableSemaphore};
+    vk::PipelineStageFlags waitStages[] = {vk::PipelineStageFlagBits::eColorAttachmentOutput};
+    submitInfo.waitSemaphoreCount = 1;
+    submitInfo.pWaitSemaphores = waitSemaphores;
+    submitInfo.pWaitDstStageMask = waitStages;
+    submitInfo.commandBufferCount = 1;
+    submitInfo.pCommandBuffers = &commandBuffer;
+    vk::Semaphore signalSemaphores[] = {renderFinishedSemaphore};
+    submitInfo.signalSemaphoreCount = 1;
+    submitInfo.pSignalSemaphores = signalSemaphores;
+    if (graphicsQueue.submit(1, &submitInfo, inFlightFence) != vk::Result::eSuccess) {
+        throw std::runtime_error("Failed to submit draw command buffer");
+    }
+
+    vk::PresentInfoKHR presentInfo{};
+    presentInfo.waitSemaphoreCount = 1;
+    presentInfo.pWaitSemaphores = signalSemaphores;
+
+    vk::SwapchainKHR swapChains[] = {swapChain};
+    presentInfo.swapchainCount = 1;
+    presentInfo.pSwapchains = swapChains;
+    presentInfo.pImageIndices = &acquireResult.value;
+    const auto presentResult = presentQueue.presentKHR(&presentInfo);
+    if (presentResult == vk::Result::eErrorOutOfDateKHR || presentResult == vk::Result::eSuboptimalKHR) {
+        recreateSwapChain();
+    } else if (presentResult != vk::Result::eSuccess) {
+        throw std::runtime_error("Failed to present swap chain image");
+    }
+
+    currentFrame = (currentFrame + 1) % maxFramesInFlight;
+}
+
+void VulkanTest::createInstance() {
+    if (enableValidationLayers && !checkValidationLayerSupport()) {
+        throw std::runtime_error("validation layers requested, but not available");
+    }
+
+    vk::ApplicationInfo appInfo{};
+    appInfo.pApplicationName = "Hello Triangle";
+    appInfo.applicationVersion = VK_MAKE_VERSION(1, 0, 0);
+    appInfo.pEngineName = "No Engine";
+    appInfo.engineVersion = VK_MAKE_VERSION(1, 0, 0);
+    appInfo.apiVersion = VK_API_VERSION_1_0;
+
+    vk::InstanceCreateInfo createInfo{};
+    createInfo.pApplicationInfo = &appInfo;
+
+    uint32_t glfwExtensionCount = 0;
+    const char** glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount);
+
+    createInfo.enabledExtensionCount = glfwExtensionCount;
+    createInfo.ppEnabledExtensionNames = glfwExtensions;
+    if (enableValidationLayers) {
+        createInfo.enabledLayerCount = static_cast<uint32_t>(validationLayers.size());
+        createInfo.ppEnabledLayerNames = validationLayers.data();
+    } else {
+        createInfo.enabledLayerCount = 0;
+    }
+
+    if (vk::createInstance(&createInfo, nullptr, &instance) != vk::Result::eSuccess) {
+        throw std::runtime_error("Failed to create instance");
+    }
+}
+
+bool VulkanTest::checkValidationLayerSupport() const {
+#if defined(VK_ADD_LAYER_PATH) && defined(DE_PLATFORM_WINDOWS)
+    _putenv_s("VK_ADD_LAYER_PATH", VK_ADD_LAYER_PATH);
+#endif
+
+    uint32_t layerCount;
+    if (vk::enumerateInstanceLayerProperties(&layerCount, nullptr) != vk::Result::eSuccess) {
+        throw std::runtime_error("Failed to enumerate instance layer properties");
+    }
+
+    std::vector<vk::LayerProperties> availableLayers(layerCount);
+    if (vk::enumerateInstanceLayerProperties(&layerCount, availableLayers.data()) != vk::Result::eSuccess) {
+        throw std::runtime_error("Failed to enumerate instance layer properties");
+    }
+
+    for (const char* layerName : validationLayers) {
+        bool layerFound = false;
+
+        for (const auto& layerProperties : availableLayers) {
+            if (strcmp(layerName, layerProperties.layerName) == 0) {
+                layerFound = true;
+                break;
+            }
+        }
+
+        if (!layerFound) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+void VulkanTest::pickPhysicalDevice() {
+    uint32_t deviceCount = 0;
+    if (instance.enumeratePhysicalDevices(&deviceCount, nullptr) != vk::Result::eSuccess || deviceCount == 0) {
+        throw std::runtime_error("Failed to find GPUs with Vulkan support");
+    }
+
+    std::vector<vk::PhysicalDevice> devices(deviceCount);
+    if (instance.enumeratePhysicalDevices(&deviceCount, devices.data()) != vk::Result::eSuccess) {
+        throw std::runtime_error("Failed to enumerate physical devices");
+    }
+
+    std::multimap<unsigned int, VkPhysicalDevice> candidates;
+    for (const auto& device : devices) {
+        unsigned int score = rateDeviceSuitability(device);
+        candidates.insert(std::make_pair(score, device));
+    }
+
+    if (candidates.rbegin()->first > 0) {
+        physicalDevice = candidates.rbegin()->second;
+        std::cout << "Selected GPU: " << physicalDevice.getProperties().deviceName << std::endl;
+    } else {
+        throw std::runtime_error("Failed to find a suitable GPU");
+    }
+}
+
+void VulkanTest::createLogicalDevice() {
+    QueueFamilyIndices indices = findQueueFamilies(physicalDevice);
+    std::vector<vk::DeviceQueueCreateInfo> queueCreateInfos;
+    std::set uniqueQueueFamilies = {indices.graphicsFamily.value(), indices.presentFamily.value()};
+
+    float queuePriority = 1.0f;
+    for (unsigned int queueFamily : uniqueQueueFamilies) {
+        vk::DeviceQueueCreateInfo queueCreateInfo{};
+        queueCreateInfo.queueFamilyIndex = queueFamily;
+        queueCreateInfo.queueCount = 1;
+        queueCreateInfo.pQueuePriorities = &queuePriority;
+        queueCreateInfos.emplace_back(queueCreateInfo);
+    }
+
+    vk::PhysicalDeviceFeatures deviceFeatures{};
+    vk::DeviceCreateInfo createInfo{};
+    createInfo.pQueueCreateInfos = queueCreateInfos.data();
+    createInfo.queueCreateInfoCount = static_cast<uint32_t>(queueCreateInfos.size());
+    createInfo.pEnabledFeatures = &deviceFeatures;
+    createInfo.enabledExtensionCount = static_cast<uint32_t>(deviceExtensions.size());
+    createInfo.ppEnabledExtensionNames = deviceExtensions.data();
+    if (physicalDevice.createDevice(&createInfo, nullptr, &device) != vk::Result::eSuccess) {
+        throw std::runtime_error("Failed to create logical device");
+    }
+
+    graphicsQueue = device.getQueue(indices.graphicsFamily.value(), 0);
+    presentQueue = device.getQueue(indices.presentFamily.value(), 0);
+}
+
+void VulkanTest::createSurface() {
+    if (glfwCreateWindowSurface(instance, window, nullptr, reinterpret_cast<VkSurfaceKHR*>(&surface)) != VK_SUCCESS) {
+        throw std::runtime_error("Failed to create window surface");
+    }
+}
+
+void VulkanTest::createSwapChain() {
+    auto [capabilities, formats, presentModes] = querySwapChainSupport(physicalDevice);
+    vk::SurfaceFormatKHR surfaceFormat = chooseSwapSurfaceFormat(formats);
+    vk::PresentModeKHR presentMode = chooseSwapPresentMode(presentModes);
+    vk::Extent2D extent = chooseSwapExtent(capabilities);
+    unsigned int imageCount = capabilities.minImageCount + 1;
+    if (capabilities.maxImageCount > 0 && imageCount > capabilities.maxImageCount) {
+        imageCount = capabilities.maxImageCount;
+    }
+    vk::SwapchainCreateInfoKHR createInfo{};
+    createInfo.surface = surface;
+    createInfo.minImageCount = imageCount;
+    createInfo.imageFormat = surfaceFormat.format;
+    createInfo.imageColorSpace = surfaceFormat.colorSpace;
+    createInfo.imageExtent = extent;
+    createInfo.imageArrayLayers = 1;
+    createInfo.imageUsage = vk::ImageUsageFlagBits::eColorAttachment;
+    const QueueFamilyIndices indices = findQueueFamilies(physicalDevice);
+    const unsigned int queueFamilyIndices[] = {indices.graphicsFamily.value(), indices.presentFamily.value()};
+    if (indices.graphicsFamily != indices.presentFamily) {
+        createInfo.imageSharingMode = vk::SharingMode::eConcurrent;
+        createInfo.queueFamilyIndexCount = 2;
+        createInfo.pQueueFamilyIndices = queueFamilyIndices;
+    } else {
+        createInfo.imageSharingMode = vk::SharingMode::eExclusive;
+    }
+    createInfo.preTransform = capabilities.currentTransform;
+    createInfo.compositeAlpha = vk::CompositeAlphaFlagBitsKHR::eOpaque;
+    createInfo.presentMode = presentMode;
+    createInfo.clipped = true;
+    createInfo.oldSwapchain = nullptr;
+    swapChain = device.createSwapchainKHR(createInfo);
+    swapChainImages = device.getSwapchainImagesKHR(swapChain);
+    swapChainImageFormat = surfaceFormat.format;
+    swapChainExtent = extent;
+}
+
+void VulkanTest::cleanupSwapChain() const {
+    for (const auto& framebuffer : swapChainFramebuffers) {
+        device.destroyFramebuffer(framebuffer);
+    }
+    for (const auto& imageView : swapChainImageViews) {
+        device.destroyImageView(imageView);
+    }
+    device.destroySwapchainKHR(swapChain);
+}
+
+void VulkanTest::recreateSwapChain() {
+    int width = 0, height = 0;
+    glfwGetFramebufferSize(window, &width, &height);
+    while (width == 0 || height == 0) {
+        glfwGetFramebufferSize(window, &width, &height);
+        glfwWaitEvents();
+    }
+
+    device.waitIdle();
+    cleanupSwapChain();
+    createSwapChain();
+    createImageViews();
+    createFramebuffers();
+}
+
+void VulkanTest::createImageViews() {
+    swapChainImageViews.resize(swapChainImages.size());
+    for (size_t i = 0; i < swapChainImages.size(); i++) {
+        vk::ImageViewCreateInfo createInfo{};
+        createInfo.image = swapChainImages[i];
+        createInfo.viewType = vk::ImageViewType::e2D;
+        createInfo.format = swapChainImageFormat;
+        createInfo.components.r = vk::ComponentSwizzle::eIdentity;
+        createInfo.components.g = vk::ComponentSwizzle::eIdentity;
+        createInfo.components.b = vk::ComponentSwizzle::eIdentity;
+        createInfo.components.a = vk::ComponentSwizzle::eIdentity;
+        createInfo.subresourceRange.aspectMask = vk::ImageAspectFlagBits::eColor;
+        createInfo.subresourceRange.baseMipLevel = 0;
+        createInfo.subresourceRange.levelCount = 1;
+        createInfo.subresourceRange.baseArrayLayer = 0;
+        createInfo.subresourceRange.layerCount = 1;
+
+        if (device.createImageView(&createInfo, nullptr, &swapChainImageViews[i]) != vk::Result::eSuccess) {
+            throw std::runtime_error("Failed to create image views");
+        }
+    }
+}
+
+void VulkanTest::createRenderPass() {
+    vk::AttachmentDescription colorAttachment{};
+    colorAttachment.format = swapChainImageFormat;
+    colorAttachment.samples = vk::SampleCountFlagBits::e1;
+    colorAttachment.loadOp = vk::AttachmentLoadOp::eClear;
+    colorAttachment.storeOp = vk::AttachmentStoreOp::eStore;
+    colorAttachment.stencilLoadOp = vk::AttachmentLoadOp::eDontCare;
+    colorAttachment.stencilStoreOp = vk::AttachmentStoreOp::eDontCare;
+    colorAttachment.initialLayout = vk::ImageLayout::eUndefined;
+    colorAttachment.finalLayout = vk::ImageLayout::ePresentSrcKHR;
+
+    vk::AttachmentReference colorAttachmentRef;
+    colorAttachmentRef.attachment = 0;
+    colorAttachmentRef.layout = vk::ImageLayout::eColorAttachmentOptimal;
+
+    vk::SubpassDescription subpass{};
+    subpass.pipelineBindPoint = vk::PipelineBindPoint::eGraphics;
+    subpass.colorAttachmentCount = 1;
+    subpass.pColorAttachments = &colorAttachmentRef;
+
+    vk::SubpassDependency dependency{};
+    dependency.srcSubpass = vk::SubpassExternal;
+    dependency.dstSubpass = 0;
+    dependency.srcStageMask = vk::PipelineStageFlagBits::eColorAttachmentOutput;
+    dependency.srcAccessMask = vk::AccessFlags();
+    dependency.dstStageMask = vk::PipelineStageFlagBits::eColorAttachmentOutput;
+    dependency.dstAccessMask = vk::AccessFlagBits::eColorAttachmentWrite;
+
+    vk::RenderPassCreateInfo renderPassInfo{};
+    renderPassInfo.attachmentCount = 1;
+    renderPassInfo.pAttachments = &colorAttachment;
+    renderPassInfo.subpassCount = 1;
+    renderPassInfo.pSubpasses = &subpass;
+    renderPassInfo.dependencyCount = 1;
+    renderPassInfo.pDependencies = &dependency;
+    renderPass = device.createRenderPass(renderPassInfo);
+}
+
+void VulkanTest::createGraphicsPipeline() {
+    auto vertShaderCode = readFile("../assets/shaders/vulkan-test.vert.spv");
+    auto fragShaderCode = readFile("../assets/shaders/vulkan-test.frag.spv");
+
+    vk::ShaderModule vertShaderModule = createShaderModule(vertShaderCode);
+    vk::ShaderModule fragShaderModule = createShaderModule(fragShaderCode);
+
+    vk::PipelineShaderStageCreateInfo vertShaderStageInfo{};
+    vertShaderStageInfo.stage = vk::ShaderStageFlagBits::eVertex;
+    vertShaderStageInfo.module = vertShaderModule;
+    vertShaderStageInfo.pName = "main";
+    vk::PipelineShaderStageCreateInfo fragShaderStageInfo{};
+    fragShaderStageInfo.stage = vk::ShaderStageFlagBits::eFragment;
+    fragShaderStageInfo.module = fragShaderModule;
+    fragShaderStageInfo.pName = "main";
+    vk::PipelineShaderStageCreateInfo shaderStages[] = {vertShaderStageInfo, fragShaderStageInfo};
+
+    vk::PipelineVertexInputStateCreateInfo vertexInputInfo{};
+    vertexInputInfo.vertexBindingDescriptionCount = 0;
+    vertexInputInfo.pVertexBindingDescriptions = nullptr;
+    vertexInputInfo.vertexAttributeDescriptionCount = 0;
+    vertexInputInfo.pVertexAttributeDescriptions = nullptr;
+
+    vk::PipelineInputAssemblyStateCreateInfo inputAssembly{};
+    inputAssembly.topology = vk::PrimitiveTopology::eTriangleList;
+    inputAssembly.primitiveRestartEnable = VK_FALSE;
+
+    vk::Viewport viewport = {0.0f, 0.0f, static_cast<float>(swapChainExtent.width), static_cast<float>(swapChainExtent.height), 0.0f, 1.0};
+
+    vk::Rect2D scissor = {{0, 0}, swapChainExtent};
+
+    const std::vector dynamicStates = {
+        vk::DynamicState::eViewport,
+        vk::DynamicState::eScissor,
+    };
+    vk::PipelineDynamicStateCreateInfo dynamicState{};
+    dynamicState.dynamicStateCount = static_cast<uint32_t>(dynamicStates.size());
+    dynamicState.pDynamicStates = dynamicStates.data();
+
+    vk::PipelineViewportStateCreateInfo viewportState{};
+    viewportState.viewportCount = 1;
+    viewportState.pViewports = &viewport;
+    viewportState.scissorCount = 1;
+    viewportState.pScissors = &scissor;
+
+    vk::PipelineRasterizationStateCreateInfo rasterizer{};
+    rasterizer.depthClampEnable = VK_FALSE;
+    rasterizer.rasterizerDiscardEnable = VK_FALSE;
+    rasterizer.polygonMode = vk::PolygonMode::eFill;
+    rasterizer.lineWidth = 1.0f;
+    rasterizer.cullMode = vk::CullModeFlagBits::eBack;
+    rasterizer.frontFace = vk::FrontFace::eClockwise;
+    rasterizer.depthBiasEnable = VK_FALSE;
+    rasterizer.depthBiasConstantFactor = 0.0f;
+    rasterizer.depthBiasClamp = 0.0f;
+    rasterizer.depthBiasSlopeFactor = 0.0f;
+
+    vk::PipelineMultisampleStateCreateInfo multisampling{};
+    multisampling.sampleShadingEnable = VK_FALSE;
+    multisampling.rasterizationSamples = vk::SampleCountFlagBits::e1;
+    multisampling.minSampleShading = 1.0f;
+    multisampling.pSampleMask = nullptr;
+    multisampling.alphaToCoverageEnable = VK_FALSE;
+    multisampling.alphaToOneEnable = VK_FALSE;
+
+    vk::PipelineColorBlendAttachmentState colorBlendAttachment{};
+    colorBlendAttachment.colorWriteMask = vk::ColorComponentFlagBits::eR | vk::ColorComponentFlagBits::eG | vk::ColorComponentFlagBits::eB | vk::ColorComponentFlagBits::eA;
+    colorBlendAttachment.blendEnable = VK_FALSE;
+    colorBlendAttachment.srcColorBlendFactor = vk::BlendFactor::eOne;
+    colorBlendAttachment.dstColorBlendFactor = vk::BlendFactor::eZero;
+    colorBlendAttachment.colorBlendOp = vk::BlendOp::eAdd;
+    colorBlendAttachment.srcAlphaBlendFactor = vk::BlendFactor::eOne;
+    colorBlendAttachment.dstAlphaBlendFactor = vk::BlendFactor::eZero;
+    colorBlendAttachment.alphaBlendOp = vk::BlendOp::eAdd;
+
+    vk::PipelineColorBlendStateCreateInfo colorBlending{};
+    colorBlending.logicOpEnable = VK_FALSE;
+    colorBlending.logicOp = vk::LogicOp::eCopy;
+    colorBlending.attachmentCount = 1;
+    colorBlending.pAttachments = &colorBlendAttachment;
+    colorBlending.blendConstants[0] = 0.0f;
+    colorBlending.blendConstants[1] = 0.0f;
+    colorBlending.blendConstants[2] = 0.0f;
+    colorBlending.blendConstants[3] = 0.0f;
+
+    vk::PipelineLayoutCreateInfo pipelineLayoutInfo{};
+    pipelineLayoutInfo.setLayoutCount = 0;
+    pipelineLayoutInfo.pSetLayouts = nullptr;
+    pipelineLayoutInfo.pushConstantRangeCount = 0;
+    pipelineLayoutInfo.pPushConstantRanges = nullptr;
+    pipelineLayout = device.createPipelineLayout(pipelineLayoutInfo);
+
+    vk::GraphicsPipelineCreateInfo pipelineInfo{};
+    pipelineInfo.stageCount = 2;
+    pipelineInfo.pStages = shaderStages;
+    pipelineInfo.pVertexInputState = &vertexInputInfo;
+    pipelineInfo.pInputAssemblyState = &inputAssembly;
+    pipelineInfo.pViewportState = &viewportState;
+    pipelineInfo.pRasterizationState = &rasterizer;
+    pipelineInfo.pMultisampleState = &multisampling;
+    pipelineInfo.pDepthStencilState = nullptr;
+    pipelineInfo.pColorBlendState = &colorBlending;
+    pipelineInfo.pDynamicState = &dynamicState;
+    pipelineInfo.layout = pipelineLayout;
+    pipelineInfo.renderPass = renderPass;
+    pipelineInfo.subpass = 0;
+
+    const vk::ResultValue<vk::Pipeline> result = device.createGraphicsPipeline(nullptr, pipelineInfo);
+    if (result.result != vk::Result::eSuccess) {
+        throw std::runtime_error("Failed to create graphics pipeline");
+    }
+    graphicsPipeline = result.value;
+
+    device.destroyShaderModule(fragShaderModule);
+    device.destroyShaderModule(vertShaderModule);
+}
+
+void VulkanTest::createFramebuffers() {
+    swapChainFramebuffers.resize(swapChainImageViews.size());
+    for (size_t i = 0; i < swapChainImageViews.size(); i++) {
+        const vk::ImageView attachments[] = {swapChainImageViews[i]};
+        vk::FramebufferCreateInfo framebufferInfo{};
+        framebufferInfo.renderPass = renderPass;
+        framebufferInfo.attachmentCount = 1;
+        framebufferInfo.pAttachments = attachments;
+        framebufferInfo.width = swapChainExtent.width;
+        framebufferInfo.height = swapChainExtent.height;
+        framebufferInfo.layers = 1;
+
+        if (device.createFramebuffer(&framebufferInfo, nullptr, &swapChainFramebuffers[i]) != vk::Result::eSuccess) {
+            throw std::runtime_error("failed to create framebuffer");
+        }
+    }
+}
+
+void VulkanTest::createCommandPool() {
+    QueueFamilyIndices queueFamilyIndices = findQueueFamilies(physicalDevice);
+
+    vk::CommandPoolCreateInfo poolInfo{};
+    poolInfo.flags = vk::CommandPoolCreateFlagBits::eResetCommandBuffer;
+    poolInfo.queueFamilyIndex = queueFamilyIndices.graphicsFamily.value();
+
+    if (device.createCommandPool(&poolInfo, nullptr, &commandPool) != vk::Result::eSuccess) {
+        throw std::runtime_error("Failed to create command pool");
+    }
+}
+
+void VulkanTest::createCommandBuffers() {
+    vk::CommandBufferAllocateInfo allocInfo{};
+    allocInfo.commandPool = commandPool;
+    allocInfo.level = vk::CommandBufferLevel::ePrimary;
+    allocInfo.commandBufferCount = maxFramesInFlight;
+    commandBuffers = device.allocateCommandBuffers(allocInfo);
+}
+
+void VulkanTest::createSyncObjects() {
+    imageAvailableSemaphores.resize(maxFramesInFlight);
+    renderFinishedSemaphores.resize(maxFramesInFlight);
+    inFlightFences.resize(maxFramesInFlight);
+
+    const vk::SemaphoreCreateInfo semaphoreInfo{};
+    vk::FenceCreateInfo fenceInfo{};
+    fenceInfo.flags = vk::FenceCreateFlagBits::eSignaled;
+
+    for (size_t i = 0; i < maxFramesInFlight; i++) {
+        imageAvailableSemaphores[i] = device.createSemaphore(semaphoreInfo);
+        renderFinishedSemaphores[i] = device.createSemaphore(semaphoreInfo);
+        inFlightFences[i] = device.createFence(fenceInfo);
+    }
+}
+
+void VulkanTest::recordCommandBuffer(const vk::CommandBuffer commandBuffer, const unsigned int imageIndex) const {
+    constexpr vk::CommandBufferBeginInfo beginInfo{};
+    if (commandBuffer.begin(&beginInfo) != vk::Result::eSuccess) {
+        throw std::runtime_error("Failed to begin recording command buffer");
+    }
+    vk::RenderPassBeginInfo renderPassInfo{};
+    renderPassInfo.renderPass = renderPass;
+    renderPassInfo.framebuffer = swapChainFramebuffers[imageIndex];
+    renderPassInfo.renderArea.offset = vk::Offset2D(0, 0);
+    renderPassInfo.renderArea.extent = swapChainExtent;
+    constexpr vk::ClearValue clearColor = vk::ClearColorValue(std::array{0.0f, 0.0f, 0.0f, 1.0f});
+    renderPassInfo.clearValueCount = 1;
+    renderPassInfo.pClearValues = &clearColor;
+
+    commandBuffer.beginRenderPass(&renderPassInfo, vk::SubpassContents::eInline);
+    commandBuffer.bindPipeline(vk::PipelineBindPoint::eGraphics, graphicsPipeline);
+    commandBuffer.setViewport(0, vk::Viewport(0.0f, 0.0f, static_cast<float>(swapChainExtent.width), static_cast<float>(swapChainExtent.height), 0.0f, 1.0f));
+    commandBuffer.setScissor(0, vk::Rect2D({0, 0}, swapChainExtent));
+    commandBuffer.draw(3, 1, 0, 0);
+    commandBuffer.endRenderPass();
+    commandBuffer.end();
+}
+
+vk::ShaderModule VulkanTest::createShaderModule(const std::vector<char>& code) const {
+    vk::ShaderModuleCreateInfo createInfo{};
+    createInfo.codeSize = code.size();
+    createInfo.pCode = reinterpret_cast<const uint32_t*>(code.data());
+    return device.createShaderModule(createInfo);
+}
+
+VulkanTest::QueueFamilyIndices VulkanTest::findQueueFamilies(const vk::PhysicalDevice device) const {
+    QueueFamilyIndices indices;
+    std::vector<vk::QueueFamilyProperties> queueFamilies = device.getQueueFamilyProperties();
+    int i = 0;
+    for (const auto& queueFamily : queueFamilies) {
+        if (queueFamily.queueFlags & vk::QueueFlagBits::eGraphics) {
+            indices.graphicsFamily = i;
+        }
+        vk::Bool32 presentSupport = false;
+        if (device.getSurfaceSupportKHR(i, surface, &presentSupport) != vk::Result::eSuccess) {
+            throw std::runtime_error("Failed to get device surface support");
+        }
+        if (presentSupport) {
+            indices.presentFamily = i;
+        }
+        if (indices.isComplete()) {
+            break;
+        }
+        i++;
+    }
+    return indices;
+}
+
+bool VulkanTest::checkDeviceExtensionSupport(const vk::PhysicalDevice device) const {
+    const std::vector<vk::ExtensionProperties> availableExtensions = device.enumerateDeviceExtensionProperties();
+    std::set<std::string> requiredExtensions(deviceExtensions.begin(), deviceExtensions.end());
+    for (const auto& extension : availableExtensions) {
+        requiredExtensions.erase(extension.extensionName);
+    }
+    return requiredExtensions.empty();
+}
+
+VulkanTest::SwapChainSupportDetails VulkanTest::querySwapChainSupport(vk::PhysicalDevice device) const {
+    return {
+        .capabilities = device.getSurfaceCapabilitiesKHR(surface),
+        .formats = device.getSurfaceFormatsKHR(surface),
+        .presentModes = device.getSurfacePresentModesKHR(surface),
+    };
+}
+
+vk::SurfaceFormatKHR VulkanTest::chooseSwapSurfaceFormat(const std::vector<vk::SurfaceFormatKHR>& availableFormats) const {
+    for (const auto& availableFormat : availableFormats) {
+        if (availableFormat.format == vk::Format::eB8G8R8A8Srgb && availableFormat.colorSpace == vk::ColorSpaceKHR::eSrgbNonlinear) {
+            return availableFormat;
+        }
+    }
+    return availableFormats[0];
+}
+
+vk::PresentModeKHR VulkanTest::chooseSwapPresentMode(const std::vector<vk::PresentModeKHR>& availablePresentModes) const {
+    for (const auto& availablePresentMode : availablePresentModes) {
+        if (availablePresentMode == vk::PresentModeKHR::eMailbox) {
+            return availablePresentMode;
+        }
+    }
+    return vk::PresentModeKHR::eFifo;
+}
+
+vk::Extent2D VulkanTest::chooseSwapExtent(const vk::SurfaceCapabilitiesKHR& capabilities) const {
+    if (capabilities.currentExtent.width != std::numeric_limits<uint32_t>::max()) {
+        return capabilities.currentExtent;
+    }
+    int width, height;
+    glfwGetFramebufferSize(window, &width, &height);
+    vk::Extent2D actualExtent;
+    actualExtent.width = std::clamp(static_cast<unsigned int>(width), capabilities.minImageExtent.width, capabilities.maxImageExtent.width);
+    actualExtent.height = std::clamp(static_cast<unsigned int>(height), capabilities.minImageExtent.height, capabilities.maxImageExtent.height);
+    return actualExtent;
+}
+
+unsigned int VulkanTest::rateDeviceSuitability(const vk::PhysicalDevice device) {
+    if (!device.getFeatures().geometryShader) {
+        return 0;
+    }
+
+    const QueueFamilyIndices indices = findQueueFamilies(device);
+    if (!indices.isComplete()) {
+        return 0;
+    }
+
+    if (!checkDeviceExtensionSupport(device)) {
+        return 0;
+    }
+
+    SwapChainSupportDetails swapChainSupport = querySwapChainSupport(device);
+    if (swapChainSupport.formats.empty() || swapChainSupport.presentModes.empty()) {
+        return 0;
+    }
+
+    const vk::PhysicalDeviceProperties properties = device.getProperties();
+    unsigned int score = 0;
+
+    if (properties.deviceType == vk::PhysicalDeviceType::eDiscreteGpu) {
+        score += 1000;
+    }
+
+    score += properties.limits.maxImageDimension2D;
+
+    if (indices.graphicsFamily == indices.presentFamily) {
+        score += 1;
+    }
+
+    return score;
+}
+
+std::vector<char> VulkanTest::readFile(const std::string& filename) {
+    std::ifstream file(filename, std::ios::ate | std::ios::binary);
+
+    if (!file.is_open()) {
+        throw std::runtime_error("Failed to open file");
+    }
+    const auto fileSize = file.tellg();
+    std::vector<char> buffer(fileSize);
+    file.seekg(0);
+    file.read(buffer.data(), fileSize);
+    file.close();
+    return buffer;
+}
diff --git a/engine/src/VulkanTest.h b/engine/src/VulkanTest.h
new file mode 100644
index 0000000..6b9268d
--- /dev/null
+++ b/engine/src/VulkanTest.h
@@ -0,0 +1,96 @@
+#pragma once
+#include <vulkan/vulkan.hpp>
+#include <GLFW/glfw3.h>
+
+class VulkanTest {
+public:
+    void run();
+
+private:
+    void initWindow();
+    void initVulkan();
+    void cleanup() const;
+    void mainLoop();
+    void drawFrame();
+
+    void createInstance();
+    bool checkValidationLayerSupport() const;
+    void pickPhysicalDevice();
+    void createLogicalDevice();
+    void createSurface();
+    void createSwapChain();
+    void cleanupSwapChain() const;
+    void recreateSwapChain();
+    void createImageViews();
+    void createRenderPass();
+    void createGraphicsPipeline();
+    void createFramebuffers();
+    void createCommandPool();
+    void createCommandBuffers();
+    void createSyncObjects();
+
+    void recordCommandBuffer(vk::CommandBuffer commandBuffer, unsigned int imageIndex) const;
+
+    unsigned int rateDeviceSuitability(vk::PhysicalDevice device);
+
+    struct QueueFamilyIndices {
+        std::optional<uint32_t> graphicsFamily;
+        std::optional<uint32_t> presentFamily;
+
+        bool isComplete() const {
+            return graphicsFamily.has_value() && presentFamily.has_value();
+        }
+    };
+
+    QueueFamilyIndices findQueueFamilies(vk::PhysicalDevice device) const;
+    bool checkDeviceExtensionSupport(vk::PhysicalDevice device) const;
+
+    struct SwapChainSupportDetails {
+        vk::SurfaceCapabilitiesKHR capabilities;
+        std::vector<vk::SurfaceFormatKHR> formats;
+        std::vector<vk::PresentModeKHR> presentModes;
+    };
+
+    SwapChainSupportDetails querySwapChainSupport(vk::PhysicalDevice device) const;
+    vk::SurfaceFormatKHR chooseSwapSurfaceFormat(const std::vector<vk::SurfaceFormatKHR>& availableFormats) const;
+    vk::PresentModeKHR chooseSwapPresentMode(const std::vector<vk::PresentModeKHR>& availablePresentModes) const;
+    vk::Extent2D chooseSwapExtent(const vk::SurfaceCapabilitiesKHR& capabilities) const;
+
+    vk::ShaderModule createShaderModule(const std::vector<char>& code) const;
+
+    static std::vector<char> readFile(const std::string& filename);
+
+    GLFWwindow* window = nullptr;
+    vk::Instance instance;
+    vk::PhysicalDevice physicalDevice = nullptr;
+    vk::Device device;
+    vk::Queue graphicsQueue;
+    vk::Queue presentQueue;
+    vk::SurfaceKHR surface;
+    vk::SwapchainKHR swapChain;
+    std::vector<vk::Image> swapChainImages;
+    vk::Format swapChainImageFormat = {};
+    vk::Extent2D swapChainExtent;
+    std::vector<vk::ImageView> swapChainImageViews;
+    vk::RenderPass renderPass;
+    vk::PipelineLayout pipelineLayout;
+    vk::Pipeline graphicsPipeline;
+    std::vector<vk::Framebuffer> swapChainFramebuffers;
+    vk::CommandPool commandPool;
+
+    static constexpr unsigned int maxFramesInFlight = 2;
+    std::vector<vk::CommandBuffer> commandBuffers;
+    std::vector<vk::Semaphore> imageAvailableSemaphores;
+    std::vector<vk::Semaphore> renderFinishedSemaphores;
+    std::vector<vk::Fence> inFlightFences;
+    unsigned int currentFrame = 0;
+
+    const std::vector<const char*> validationLayers = {"VK_LAYER_KHRONOS_validation"};
+    const std::vector<const char*> deviceExtensions = {vk::KHRSwapchainExtensionName};
+
+#if defined(DE_DEBUG) && (!defined(DE_PLATFORM_WINDOWS) || defined(VK_ADD_LAYER_PATH))
+    const bool enableValidationLayers = true;
+#else
+    const bool enableValidationLayers = false;
+#endif
+};
diff --git a/engine/src/cef/OSRCefHandler.h b/engine/src/cef/OSRCefHandler.h
index 5c1bd54..d3bb830 100644
--- a/engine/src/cef/OSRCefHandler.h
+++ b/engine/src/cef/OSRCefHandler.h
@@ -12,7 +12,7 @@ class OSRCefHandler : public CefClient, public CefRenderHandler, public CefLoadH
     explicit OSRCefHandler(const Ref<Application>& app);
     ~OSRCefHandler() override;
 
-    void setTexture(const Ref<Texture2D>& texture) {
+    void setTexture(const Ref<Texture>& texture) {
         this->texture = texture;
     }
 
@@ -106,7 +106,7 @@ class OSRCefHandler : public CefClient, public CefRenderHandler, public CefLoadH
     } textureInfo;
     std::mutex textureInfoMutex;
 #endif
-    Ref<Texture2D> texture;
+    Ref<Texture> texture;
     CefRefPtr<CefBrowserHost> host;
     BrowserMessageHandler browserMessageHandler = BrowserMessageHandler();
     bool closing = false;
diff --git a/engine/src/editor/scripts/EditorScript.cpp b/engine/src/editor/scripts/EditorScript.cpp
index 91ec203..a728c86 100644
--- a/engine/src/editor/scripts/EditorScript.cpp
+++ b/engine/src/editor/scripts/EditorScript.cpp
@@ -39,7 +39,7 @@ EditorScript::EditorScript(const Ref<Application>& app, const Ref<Scene>& scene,
             return; // mouse is outside the viewport
         }
 
-        const int entityId = app->getRenderer()->getFramebuffer()->getMousePickingValue(mouseX, mouseY);
+        const int entityId = app->getRenderer()->readPixelIntSync(app->getRenderer()->getMousePickingFramebuffer(), mouseX, mouseY, 0);
         if (entityId >= 0) {
             const Ref<Entity>& selectedEntity = this->scene->getEntity(entityId);
             if (selectedEntity->has<EditorGizmo>()) {
diff --git a/engine/src/editor/scripts/UIScript.h b/engine/src/editor/scripts/UIScript.h
index 271cb89..a62df6b 100644
--- a/engine/src/editor/scripts/UIScript.h
+++ b/engine/src/editor/scripts/UIScript.h
@@ -33,5 +33,5 @@ class UIScript final : public EntityScript {
 };
 
 struct UITexture {
-    Ref<Texture2D> texture;
+    Ref<Texture> texture;
 };
diff --git a/engine/src/events/Dispatcher.h b/engine/src/events/Dispatcher.h
index fb841d3..54cb14d 100644
--- a/engine/src/events/Dispatcher.h
+++ b/engine/src/events/Dispatcher.h
@@ -1,6 +1,5 @@
 #pragma once
 
-#include "pch/enginepch.h"
 #include "Event.h"
 
 // ReSharper disable CppMemberFunctionMayBeStatic
diff --git a/engine/src/images/Image.cpp b/engine/src/images/Image.cpp
index bcfd0f2..45399eb 100644
--- a/engine/src/images/Image.cpp
+++ b/engine/src/images/Image.cpp
@@ -1,44 +1,15 @@
 #include "pch/enginepch.h"
 #include "Image.h"
 
-#include <stb_image.h>
 
-Image::Image(const std::string& path) {
-    const bool isHDR = path.ends_with(".hdr");
-    int width;
-    int height;
-    int channels;
+Image::Image(const unsigned int width, const unsigned int height, const TextureFormat format, const TextureInternalFormat internalFormat, std::unique_ptr<uint8_t[]> data) :
+    width(width), height(height), format(format), internalFormat(internalFormat), data(std::move(data)) {}
 
-    stbi_set_flip_vertically_on_load(true);
-    void* texture;
-    if (isHDR) {
-        texture = stbi_loadf(path.c_str(), &width, &height, &channels, 0);
-    } else {
-        texture = stbi_load(path.c_str(), &width, &height, &channels, 0);
-    }
-
-    if (!texture) {
-        const char* error = stbi_failure_reason();
-        DE_ERROR("Failed to read texture file {0} - {1}", path, error);
-    }
-
-    this->width = width;
-    this->height = height;
-    this->channels = channels;
-    this->bytesPerPixel = isHDR ? sizeof(float) * this->channels : sizeof(uint8_t);
-    this->data = std::make_unique<uint8_t[]>(width * height * bytesPerPixel);
-    memcpy(this->data.get(), texture, width * height * bytesPerPixel);
-
-    stbi_image_free(texture);
-}
-
-Image::Image(const unsigned int width, const unsigned int height, const unsigned int channels, const unsigned int bytesPerPixel, const void* data) : width(width), height(height), channels(channels), bytesPerPixel(bytesPerPixel) {
-    this->data = std::make_unique<uint8_t[]>(width * height * bytesPerPixel);
-    if (data) {
-        memcpy(this->data.get(), data, width * height * bytesPerPixel);
-    }
+Image::Image(const unsigned int width, const unsigned int height, const TextureFormat format, const TextureInternalFormat internalFormat) :
+    width(width), height(height), format(format), internalFormat(internalFormat) {
+    this->data = std::make_unique<uint8_t[]>(getDataSize());
 }
 
 void* Image::getPixelPointer(const unsigned int x, const unsigned int y) const {
-    return this->data.get() + static_cast<size_t>((y * this->width + x) * this->bytesPerPixel);
+    return this->data.get() + static_cast<size_t>((y * this->width + x) * this->internalFormat.getSize());
 }
diff --git a/engine/src/images/Image.h b/engine/src/images/Image.h
index f408358..1118a2c 100644
--- a/engine/src/images/Image.h
+++ b/engine/src/images/Image.h
@@ -1,20 +1,24 @@
 #pragma once
 
+/**
+ * The Image class is similar to Texture but stores the image data in CPU memory.
+ * It cannot be used directly for rendering.
+ */
 class Image {
 public:
     Image() = default;
-    explicit Image(const std::string& path);
-    Image(unsigned int width, unsigned int height, unsigned int channels, unsigned int bytesPerPixel, const void* data);
+    Image(unsigned int width, unsigned int height, TextureFormat format, TextureInternalFormat internalFormat, std::unique_ptr<uint8_t[]> data);
+    Image(unsigned int width, unsigned int height, TextureFormat format, TextureInternalFormat internalFormat);
 
-    Image(Image&& other) noexcept : width(other.width), height(other.height), channels(other.channels), bytesPerPixel(other.bytesPerPixel), data(std::move(other.data)) {}
+    Image(Image&& other) noexcept : width(other.width), height(other.height), format(other.format), internalFormat(other.internalFormat), data(std::move(other.data)) {}
     Image& operator=(Image&& other) noexcept {
         if (this == &other)
             return *this;
-        width = other.width;
-        height = other.height;
-        channels = other.channels;
-        bytesPerPixel = other.bytesPerPixel;
-        data = std::move(other.data);
+        this->width = other.width;
+        this->height = other.height;
+        this->format = other.format;
+        this->internalFormat = other.internalFormat;
+        this->data = std::move(other.data);
         return *this;
     }
 
@@ -22,23 +26,27 @@ class Image {
 
 
     unsigned int getWidth() const {
-        return width;
+        return this->width;
     }
 
     unsigned int getHeight() const {
-        return height;
+        return this->height;
     }
 
-    unsigned int getChannels() const {
-        return channels;
+    TextureFormat getFormat() const {
+        return this->format;
     }
 
-    unsigned int getBytesPerPixel() const {
-        return bytesPerPixel;
+    TextureInternalFormat getInternalFormat() const {
+        return this->internalFormat;
     }
 
-    void* getData() const {
-        return data.get();
+    const std::unique_ptr<uint8_t[]>& getData() const {
+        return this->data;
+    }
+
+    unsigned int getDataSize() const {
+        return this->width * this->height * this->internalFormat.getSize();
     }
 
     void* getPixelPointer(unsigned int x, unsigned int y) const;
@@ -46,7 +54,7 @@ class Image {
 protected:
     unsigned int width;
     unsigned int height;
-    unsigned int channels;
-    unsigned int bytesPerPixel;
+    TextureFormat format;
+    TextureInternalFormat internalFormat;
     std::unique_ptr<uint8_t[]> data;
 };
diff --git a/engine/src/images/ImageUtils.cpp b/engine/src/images/ImageUtils.cpp
index f143761..85217a3 100644
--- a/engine/src/images/ImageUtils.cpp
+++ b/engine/src/images/ImageUtils.cpp
@@ -1,19 +1,71 @@
 #include "pch/enginepch.h"
 #include "ImageUtils.h"
 
+#include <stb_image.h>
+
+Ref<Image> ImageUtils::loadImageFromFile(const std::string& path) {
+    unsigned int width;
+    unsigned int height;
+    TextureFormat format;
+    TextureInternalFormat internalFormat;
+    std::unique_ptr<uint8_t[]> data = loadImageData(path, width, height, format, internalFormat);
+    return std::make_shared<Image>(width, height, format, internalFormat, std::move(data));
+}
+
+Ref<Texture> ImageUtils::loadTextureFromFile(const Ref<Renderer>& renderer, const std::string& path) {
+    unsigned int width;
+    unsigned int height;
+    TextureFormat format;
+    TextureInternalFormat internalFormat;
+    std::unique_ptr<uint8_t[]> data = loadImageData(path, width, height, format, internalFormat);
+    return Texture::builder() //
+        .width(width)
+        .height(height)
+        .format(format)
+        .internalFormat(internalFormat)
+        .type(TextureType::TEXTURE_2D)
+        .data(std::move(data))
+        .build(renderer);
+}
+
+/**
+ * Always remember to free the returned data using stbi_image_free when done using it.
+ */
+std::unique_ptr<uint8_t[]> ImageUtils::loadImageData(const std::string& path, unsigned int& width, unsigned int& height, TextureFormat& format,
+                                                     TextureInternalFormat& internalFormat) {
+    int w, h;
+    int channels;
+
+    stbi_set_flip_vertically_on_load(true);
+    uint8_t* data = stbi_load(path.c_str(), &w, &h, &channels, 0);
+
+    if (!data) {
+        const char* error = stbi_failure_reason();
+        DE_ERROR("Failed to read texture file {0} - {1}", path, error);
+    }
+
+    width = static_cast<unsigned int>(w);
+    height = static_cast<unsigned int>(h);
+    format = channels > 3 ? TextureFormat::RGBA : TextureFormat::RGB;
+    internalFormat = channels > 3 ? TextureInternalFormat::RGBA8 : TextureInternalFormat::RGB8;
+    return std::unique_ptr<uint8_t[]>(data);
+}
+
 Ref<LinearImage> ImageUtils::acesFilmicTonemapping(const Ref<LinearImage>& image) {
-    auto result = std::make_shared<LinearImage>(image->getWidth(), image->getHeight(), nullptr);
+    auto result = std::make_shared<LinearImage>(image->getWidth(), image->getHeight());
     for (unsigned int x = 0; x < image->getWidth(); x++) {
         for (unsigned int y = 0; y < image->getHeight(); y++) {
             const auto originalPixel = static_cast<float*>(image->getPixelPointer(x, y));
             const auto resultPixel = static_cast<float*>(result->getPixelPointer(x, y));
             const auto color = glm::vec3(originalPixel[0], originalPixel[1], originalPixel[2]);
+            const auto alpha = originalPixel[3];
             constexpr float a = 2.51f;
             constexpr float b = 0.03f;
             constexpr float c = 2.43f;
             constexpr float d = 0.59f;
             constexpr float e = 0.14f;
-            *reinterpret_cast<glm::vec3*>(resultPixel) = glm::clamp((color * (a * color + b)) / (color * (c * color + d) + e), glm::vec3(0.0), glm::vec3(1.0));
+            const glm::vec3 mapped = glm::clamp((color * (a * color + b)) / (color * (c * color + d) + e), glm::vec3(0.0), glm::vec3(1.0));
+            *reinterpret_cast<glm::vec4*>(resultPixel) = glm::vec4(mapped, alpha);
         }
     }
     return result;
diff --git a/engine/src/images/ImageUtils.h b/engine/src/images/ImageUtils.h
index 5bb6395..98bb7b3 100644
--- a/engine/src/images/ImageUtils.h
+++ b/engine/src/images/ImageUtils.h
@@ -3,5 +3,13 @@
 
 class ImageUtils {
 public:
+    static Ref<Image> loadImageFromFile(const std::string& path);
+    static Ref<Texture> loadTextureFromFile(const Ref<Renderer>& renderer, const std::string& path);
+    static std::unique_ptr<uint8_t[]> loadImageData(const std::string& path, unsigned int& width, unsigned int& height, TextureFormat& format, TextureInternalFormat& internalFormat);
     static Ref<LinearImage> acesFilmicTonemapping(const Ref<LinearImage>& image);
+
+private:
+    static Ref<Image> createImageFromData(unsigned int width, unsigned int height, TextureFormat format, TextureInternalFormat internalFormat, std::unique_ptr<uint8_t[]> data);
+    static Ref<Texture> createTextureFromData(const Ref<Renderer>& renderer, unsigned int width, unsigned int height, TextureFormat format,
+                                              TextureInternalFormat internalFormat, std::unique_ptr<uint8_t[]> data);
 };
diff --git a/engine/src/images/LinearImage.cpp b/engine/src/images/LinearImage.cpp
index afc7b3a..06abf29 100644
--- a/engine/src/images/LinearImage.cpp
+++ b/engine/src/images/LinearImage.cpp
@@ -3,7 +3,7 @@
 
 #include <fstream>
 
-LinearImage::LinearImage(const std::string& path) : Image(0, 0, 3, sizeof(float) * 3, nullptr) {
+LinearImage::LinearImage(const std::string& path) : Image(0, 0, TextureFormat::RGBA, TextureInternalFormat::RGBA32_FLOAT, nullptr) {
     auto imageStream = std::ifstream(path, std::ios::in | std::ios::binary);
     if (!imageStream.is_open()) {
         DE_ERROR("Failed to open image file {0}", path);
@@ -47,10 +47,10 @@ LinearImage::LinearImage(const std::string& path) : Image(0, 0, 3, sizeof(float)
         return;
     }
 
-    this->data = std::make_unique<unsigned char[]>(width * height * this->bytesPerPixel);
+    this->data = std::make_unique<unsigned char[]>(static_cast<size_t>(width) * height * this->internalFormat.getSize());
 
     std::vector<unsigned char> row;
-    row.reserve(width * 4); // RGBE
+    row.resize(width * 4); // RGBE
 
     // read the first 3 bytes of the file to check if the file is using RLE compression
     const std::streampos position = imageStream.tellg();
@@ -107,7 +107,7 @@ LinearImage::LinearImage(const std::string& path) : Image(0, 0, 3, sizeof(float)
                 }
             }
             for (unsigned int x = 0; x < width; x++) {
-                convertRGBEtoRGB(row.data() + x * 4, reinterpret_cast<float*>(this->data.get()) + (y * width + x) * 3);
+                convertRGBEtoRGB(row.data() + x * 4, reinterpret_cast<float*>(this->data.get()) + (y * width + x) * 4); // TODO: replace 4 with dynamic value
             }
         }
     } else {
@@ -117,21 +117,23 @@ LinearImage::LinearImage(const std::string& path) : Image(0, 0, 3, sizeof(float)
 
     // invert the image vertically
     // this doubles the memory usage, use a different approach if memory is a concern
-    auto invertedData = std::make_unique<uint8_t[]>(width * height * this->bytesPerPixel);
-    unsigned int bytesPerRow = this->bytesPerPixel * width;
+    const unsigned int bbp = this->internalFormat.getSize();
+    auto invertedData = std::make_unique<uint8_t[]>(width * height * bbp);
+    unsigned int bytesPerRow = bbp * width;
     for (unsigned int y = 0; y < height; y++) {
-        float* src = reinterpret_cast<float*>(this->data.get()) + (height - y - 1) * width * 3; // NOLINT(bugprone-implicit-widening-of-multiplication-result)
-        float* dst = reinterpret_cast<float*>(invertedData.get()) + y * width * 3; // NOLINT(bugprone-implicit-widening-of-multiplication-result)
+        // TODO: replace 4 with dynamic value
+        float* src = reinterpret_cast<float*>(this->data.get()) + (height - y - 1) * width * 4; // NOLINT(bugprone-implicit-widening-of-multiplication-result)
+        float* dst = reinterpret_cast<float*>(invertedData.get()) + y * width * 4; // NOLINT(bugprone-implicit-widening-of-multiplication-result)
         std::memcpy(dst, src, bytesPerRow);
     }
     this->data = std::move(invertedData);
 }
 
-LinearImage::LinearImage(const unsigned int width, const unsigned int height, const float* data, const float gamma, const float exposure) :
-    Image(width, height, 3, sizeof(float) * 3, data) {
-    this->gamma = gamma;
-    this->exposure = exposure;
-}
+LinearImage::LinearImage(const unsigned int width, const unsigned int height, std::unique_ptr<uint8_t[]> data, const float gamma, const float exposure) :
+    Image(width, height, TextureFormat::RGBA, TextureInternalFormat::RGBA32_FLOAT, std::move(data)), gamma(gamma), exposure(exposure) {}
+
+LinearImage::LinearImage(const unsigned int width, const unsigned int height, const float gamma, const float exposure) :
+    Image(width, height, TextureFormat::RGBA, TextureInternalFormat::RGBA32_FLOAT), gamma(gamma), exposure(exposure) {}
 
 void LinearImage::convertRGBEtoRGB(const unsigned char* rgbe, float* rgb) {
     if (rgbe[3] == 0) {
diff --git a/engine/src/images/LinearImage.h b/engine/src/images/LinearImage.h
index 6d18146..e1bc695 100644
--- a/engine/src/images/LinearImage.h
+++ b/engine/src/images/LinearImage.h
@@ -1,10 +1,12 @@
 #pragma once
+#include "Image.h"
 
 class LinearImage final : public Image {
 public:
     LinearImage() = default;
     explicit LinearImage(const std::string& path);
-    LinearImage(unsigned int width, unsigned int height, const float* data, float gamma = 1.0f, float exposure = 1.0f);
+    LinearImage(unsigned int width, unsigned int height, std::unique_ptr<uint8_t[]> data, float gamma = 1.0f, float exposure = 1.0f);
+    LinearImage(unsigned int width, unsigned int height, float gamma = 1.0f, float exposure = 1.0f);
 
 
 private:
diff --git a/engine/src/layers/EditorLayer.cpp b/engine/src/layers/EditorLayer.cpp
index f4081d3..ca5fbe5 100644
--- a/engine/src/layers/EditorLayer.cpp
+++ b/engine/src/layers/EditorLayer.cpp
@@ -5,7 +5,10 @@
 
 EditorLayer::EditorLayer(const std::unique_ptr<Context>& ctx) : Layer(ctx) {
     Ref<Entity> uiEntity = this->scene->createEntity("CEF Editor UI");
-    const auto uiMaterial = Material(ctx->renderer->createTexture2D(4, 1, 1, 1, BGRA, std::array<unsigned char, 4>{0, 0, 0, 0}.data()));
+    auto transparent = std::make_unique<uint8_t[]>(4);
+    std::memcpy(transparent.get(), std::array<uint8_t, 4>{0, 0, 0, 0}.data(), 4);
+    const auto uiMaterial =
+        Material(Texture::builder().width(1).height(1).format(TextureFormat::BGRA).internalFormat(TextureInternalFormat::RGBA8).data(std::move(transparent)).build(ctx->renderer));
     this->uiMesh = Plane::create(ctx->renderer, uiMaterial);
     uiEntity->add<UITexture>(uiMaterial.albedo);
     Script& uiScript = uiEntity->add<Script>(std::make_shared<UIScript>(ctx->app, uiEntity));
diff --git a/engine/src/layers/SceneLayer.cpp b/engine/src/layers/SceneLayer.cpp
index 2f56d7e..2a2e9ec 100644
--- a/engine/src/layers/SceneLayer.cpp
+++ b/engine/src/layers/SceneLayer.cpp
@@ -5,7 +5,6 @@
 
 #include "editor/scripts/CameraScript.h"
 #include "editor/scripts/LightScript.h"
-#include "images/Image.h"
 #include "images/ImageUtils.h"
 #include "images/LinearImage.h"
 #include "rendering/skybox/SphericalHarmonics.h"
@@ -32,14 +31,13 @@ SceneLayer::SceneLayer(const std::unique_ptr<Context>& ctx) : Layer(ctx) {
     renderer->setPointLightShadowMapShader(app->getShaderRegistry()->load("../assets/shaders/shadow-map-point-light"));
     Ref<Shader> skyboxShader = app->getShaderRegistry()->load("../assets/shaders/skybox-shader");
     Ref<LinearImage> skyboxHDR = std::make_shared<LinearImage>("../assets/skybox/kloofendal_48d_partly_cloudy_puresky_8k.hdr");
+    // this takes more than 2 seconds, might be worth to improve
     Ref<LinearImage> skyboxToneMapped = ImageUtils::acesFilmicTonemapping(skyboxHDR);
-    Ref<Texture2D> skyboxTexture =
-        renderer->createTexture2D(skyboxHDR->getChannels(), skyboxHDR->getWidth(), skyboxHDR->getHeight(), skyboxHDR->getBytesPerPixel(), skyboxHDR->getData());
-    Ref<Texture2D> skyboxTextureToneMapped = renderer->createTexture2D(skyboxToneMapped->getChannels(), skyboxToneMapped->getWidth(), skyboxToneMapped->getHeight(),
-                                                                       skyboxToneMapped->getBytesPerPixel(), skyboxToneMapped->getData());
+    Ref<Texture> skyboxTexture = Texture::builder().fromImage(skyboxHDR).build(renderer);
+    Ref<Texture> skyboxTextureToneMapped = Texture::builder().fromImage(skyboxToneMapped).build(renderer);
     Ref<Shader> equirectangularToCubemapShader = app->getShaderRegistry()->load("../assets/shaders/equirectangular-to-cubemap");
-    Ref<TextureCube> skyboxCubeTexture = renderer->createTextureCubeFromHDR(skyboxTexture, equirectangularToCubemapShader, 2048);
-    Ref<TextureCube> skyboxCubeToneMapped = renderer->createTextureCubeFromHDR(skyboxTextureToneMapped, equirectangularToCubemapShader, 256);
+    Ref<Texture> skyboxCubeTexture = renderer->createTextureCubeFromHDR(skyboxTexture, equirectangularToCubemapShader, 2048);
+    Ref<Texture> skyboxCubeToneMapped = renderer->createTextureCubeFromHDR(skyboxTextureToneMapped, equirectangularToCubemapShader, 256);
     Ref<CubeMap> skyboxCubeMap = skyboxCubeToneMapped->toCubemap();
     std::vector<glm::vec3> sphericalHarmonics = SphericalHarmonics::calculateSH(skyboxCubeMap, 3, true, true);
     renderer->setIrradianceSH({
@@ -54,11 +52,11 @@ SceneLayer::SceneLayer(const std::unique_ptr<Context>& ctx) : Layer(ctx) {
         sphericalHarmonics[8],
     });
     Ref<Shader> prefilterCubemapShader = app->getShaderRegistry()->load("../assets/shaders/prefilter-cubemap");
-    Ref<TextureCube> prefilteredSkybox = renderer->createPrefilteredCubemap(skyboxCubeToneMapped, prefilterCubemapShader, 256);
+    Ref<Texture> prefilteredSkybox = renderer->createPrefilteredCubemap(skyboxCubeToneMapped, prefilterCubemapShader, 256);
     renderer->setPrefilteredEnvMap(prefilteredSkybox);
     this->skybox = std::make_shared<SkyboxCube>(renderer, skyboxShader, skyboxCubeTexture);
     Ref<Shader> brdfLUTShader = app->getShaderRegistry()->load("../assets/shaders/brdf-lut");
-    Ref<Texture2D> brdfLUT = renderer->createBRDFLUT(brdfLUTShader, 512);
+    Ref<Texture> brdfLUT = renderer->createBRDFLUT(brdfLUTShader, 512);
     renderer->setBRDFLUT(brdfLUT);
 
     this->directionalLight = std::make_shared<DirectionalLight>(Rotation(-70, 90, 0), 2.86f);
@@ -79,6 +77,9 @@ SceneLayer::SceneLayer(const std::unique_ptr<Context>& ctx) : Layer(ctx) {
 
     Ref<Entity> spheres = this->scene->createEntity("Red spheres");
     Model sphereModel = std::move(ModelImporter::importFromFile(renderer, "../assets/models/sphere.glb")[0]);
+    auto red = std::make_unique<uint8_t[]>(3);
+    std::memcpy(red.get(), std::array<uint8_t, 3>{250, 0, 0}.data(), 3);
+    Ref<Texture> redTexture = Texture::builder().width(1).height(1).format(TextureFormat::RGB).internalFormat(TextureInternalFormat::RGB8).data(std::move(red)).build(renderer);
     for (int x = 0; x < 10; x++) {
         for (int z = 0; z < 10; z++) {
             const float xPos = -5.0f + x + 0.5f;
@@ -87,8 +88,10 @@ SceneLayer::SceneLayer(const std::unique_ptr<Context>& ctx) : Layer(ctx) {
             auto vertexDataFloats = reinterpret_cast<const float*>(vertexData);
             unsigned char roughness = static_cast<unsigned char>(static_cast<float>(9 - x) / 9 * 255.0f);
             unsigned char metallic = static_cast<unsigned char>(static_cast<float>(9 - z) / 9 * 255.0f);
-            Material material(renderer->createTexture2D(4, 1, 1, 1, std::array<unsigned char, 4>{250, 0, 0, 255}.data()),
-                              renderer->createTexture2D(3, 1, 1, 1, std::array<unsigned char, 3>{255, roughness, metallic}.data()));
+            auto orm = std::make_unique<uint8_t[]>(3);
+            std::memcpy(orm.get(), std::array<uint8_t, 3>{255, roughness, metallic}.data(), 3);
+            Material material(redTexture,
+                              Texture::builder().width(1).height(1).format(TextureFormat::RGB).internalFormat(TextureInternalFormat::RGB8).data(std::move(orm)).build(renderer));
             Ref<Entity> entity = this->scene->createEntity(std::format("Sphere ({},{})", x, z));
             entity->setParent(spheres);
             entity->add<Mesh>(renderer, vertexDataFloats, sphereModel.vertices.size() * sizeof(VertexData), sphereModel.indexes.data(), sphereModel.indexes.size(), material,
@@ -110,7 +113,10 @@ SceneLayer::SceneLayer(const std::unique_ptr<Context>& ctx) : Layer(ctx) {
         pointLightEntity->setTransform(position, Rotation(), glm::vec3(0.1f));
         const VertexData* vertexData = sphereModel.vertices.data();
         auto vertexDataFloats = reinterpret_cast<const float*>(vertexData);
-        auto material = Material(renderer->createTexture2D(4, 1, 1, 1, std::array<unsigned char, 4>{50, 50, 255, 255}.data()));
+        auto blue = std::make_unique<uint8_t[]>(3);
+        std::memcpy(blue.get(), std::array<uint8_t, 3>{50, 50, 255}.data(), 3);
+        auto material =
+            Material(Texture::builder().width(1).height(1).format(TextureFormat::RGB).internalFormat(TextureInternalFormat::RGB8).data(std::move(blue)).build(renderer));
         material.ignoreLighting = true;
         pointLightEntity->add<Mesh>(renderer, vertexDataFloats, sphereModel.vertices.size() * sizeof(VertexData), sphereModel.indexes.data(), sphereModel.indexes.size(), material,
                                     sphereModel.transformationMatrix);
diff --git a/engine/src/physics/jolt/JoltPhysics.cpp b/engine/src/physics/jolt/JoltPhysics.cpp
index 2a6a97d..b76e27f 100644
--- a/engine/src/physics/jolt/JoltPhysics.cpp
+++ b/engine/src/physics/jolt/JoltPhysics.cpp
@@ -15,7 +15,6 @@
 #include <Jolt/Physics/Collision/Shape/BoxShape.h>
 #include <Jolt/Physics/Collision/Shape/SphereShape.h>
 #include <Jolt/Physics/Body/BodyCreationSettings.h>
-#include <Jolt/Physics/Body/BodyActivationListener.h>
 
 void JoltPhysics::init() {
     JPH::RegisterDefaultAllocator();
diff --git a/engine/src/rendering/Framebuffer.cpp b/engine/src/rendering/Framebuffer.cpp
new file mode 100644
index 0000000..b719c92
--- /dev/null
+++ b/engine/src/rendering/Framebuffer.cpp
@@ -0,0 +1,30 @@
+#include "pch/enginepch.h"
+#include "Framebuffer.h"
+
+Framebuffer::Framebuffer(const FramebufferParams& params, const Ref<Renderer>& renderer) : params(params), renderer(renderer) {
+    for (const auto& texture : params.colorAttachments) {
+        DE_ASSERT(texture->getWidth() == params.width && texture->getHeight() == params.height, "All color attachment textures must have the same dimensions as the framebuffer")
+        DE_ASSERT(texture->getSamples() == params.samples, "All color attachment textures must have the same sample count as the framebuffer")
+    }
+    if (params.depthAttachment) {
+        DE_ASSERT(params.depthAttachment->getWidth() == params.width && params.depthAttachment->getHeight() == params.height,
+                  "Depth attachment texture must have the same dimensions as the framebuffer")
+        DE_ASSERT(params.depthAttachment->getSamples() == params.samples, "Depth attachment texture must have the same sample count as the framebuffer")
+    }
+}
+
+Framebuffer::~Framebuffer() {
+    getRenderer()->destroyFramebuffer(*this);
+}
+
+void Framebuffer::bind() const {
+    getRenderer()->bindFramebuffer(shared_from_this());
+}
+
+FramebufferBuilder Framebuffer::builder() {
+    return {};
+}
+
+Ref<Framebuffer> FramebufferBuilder::build(const Ref<Renderer>& renderer) const {
+    return renderer->createFramebuffer(this->params);
+}
diff --git a/engine/src/rendering/Framebuffer.h b/engine/src/rendering/Framebuffer.h
new file mode 100644
index 0000000..e28f84b
--- /dev/null
+++ b/engine/src/rendering/Framebuffer.h
@@ -0,0 +1,103 @@
+#pragma once
+#include "Texture.h"
+
+class FramebufferBuilder;
+
+class Framebuffer : public std::enable_shared_from_this<Framebuffer> {
+public:
+    virtual ~Framebuffer();
+
+    unsigned int getWidth() const {
+        return this->params.width;
+    }
+
+    unsigned int getHeight() const {
+        return this->params.height;
+    }
+
+    unsigned int getSamples() const {
+        return this->params.samples;
+    }
+
+    const std::vector<Ref<Texture>>& getColorAttachments() const {
+        return this->params.colorAttachments;
+    }
+
+    const Ref<Texture>& getDepthAttachment() const {
+        return this->params.depthAttachment;
+    }
+
+    void bind() const;
+
+    static FramebufferBuilder builder();
+
+    struct FramebufferParams {
+        unsigned int width = 0;
+        unsigned int height = 0;
+        unsigned int samples = 1;
+        std::vector<Ref<Texture>> colorAttachments;
+        Ref<Texture> depthAttachment = nullptr;
+    };
+
+protected:
+    Framebuffer(const FramebufferParams& params, const Ref<Renderer>& renderer);
+
+    Ref<Renderer> getRenderer() const {
+        Ref<Renderer> ref = renderer.lock();
+        if (!ref) {
+            throw std::runtime_error("The renderer associated with this texture has been destroyed.");
+        }
+        return ref;
+    }
+
+    FramebufferParams params;
+
+private:
+    std::weak_ptr<Renderer> renderer;
+};
+
+
+class FramebufferBuilder {
+public:
+    FramebufferBuilder& width(const unsigned int width) {
+        this->params.width = width;
+        return *this;
+    }
+
+    FramebufferBuilder& height(const unsigned int height) {
+        this->params.height = height;
+        return *this;
+    }
+
+    FramebufferBuilder& size(const unsigned int size) {
+        this->width(size);
+        this->height(size);
+        return *this;
+    }
+
+    FramebufferBuilder& size(const unsigned int width, const unsigned int height) {
+        this->width(width);
+        this->height(height);
+        return *this;
+    }
+
+    FramebufferBuilder& samples(const unsigned int samples) {
+        this->params.samples = samples;
+        return *this;
+    }
+
+    FramebufferBuilder& addColorAttachment(const Ref<Texture>& texture) {
+        this->params.colorAttachments.push_back(texture);
+        return *this;
+    }
+
+    FramebufferBuilder& depthAttachment(const Ref<Texture>& texture) {
+        this->params.depthAttachment = texture;
+        return *this;
+    }
+
+    Ref<Framebuffer> build(const Ref<Renderer>& renderer) const;
+
+private:
+    Framebuffer::FramebufferParams params;
+};
diff --git a/engine/src/rendering/Pipeline.h b/engine/src/rendering/Pipeline.h
new file mode 100644
index 0000000..9f149dd
--- /dev/null
+++ b/engine/src/rendering/Pipeline.h
@@ -0,0 +1,81 @@
+#pragma once
+
+enum class PipelineBlendFactor : byte {
+    ZERO,
+    ONE,
+    SRC_COLOR,
+    ONE_MINUS_SRC_COLOR,
+    DST_COLOR,
+    ONE_MINUS_DST_COLOR,
+    SRC_ALPHA,
+    ONE_MINUS_SRC_ALPHA,
+    DST_ALPHA,
+    ONE_MINUS_DST_ALPHA,
+    CONSTANT_COLOR,
+    ONE_MINUS_CONSTANT_COLOR,
+    CONSTANT_ALPHA,
+    ONE_MINUS_CONSTANT_ALPHA,
+    SRC_ALPHA_SATURATE,
+};
+
+enum class PipelineBlendOp : byte {
+    ADD,
+    SUBTRACT,
+    REVERSE_SUBTRACT,
+    MIN,
+    MAX,
+};
+
+enum class PipelineCompareOp : byte {
+    NEVER,
+    LESS,
+    EQUAL,
+    LESS_EQUAL,
+    GREATER,
+    NOT_EQUAL,
+    GREATER_EQUAL,
+    ALWAYS,
+};
+
+enum class PipelineCullMode : byte {
+    NONE,
+    FRONT,
+    BACK,
+    FRONT_AND_BACK,
+};
+
+struct PipelineParams {
+    struct {
+        struct {
+            PipelineBlendFactor srcFactor = PipelineBlendFactor::ONE;
+            PipelineBlendFactor dstFactor = PipelineBlendFactor::ZERO;
+            PipelineBlendOp blendOp = PipelineBlendOp::ADD;
+        } color;
+
+        struct {
+            PipelineBlendFactor srcFactor = PipelineBlendFactor::ONE;
+            PipelineBlendFactor dstFactor = PipelineBlendFactor::ZERO;
+            PipelineBlendOp blendOp = PipelineBlendOp::ADD;
+        } alpha;
+
+        bool enabled = false;
+    } blending;
+
+    struct {
+        PipelineCompareOp compareOp = PipelineCompareOp::LESS;
+        bool test = true;
+        bool write = true;
+    } depth;
+
+    PipelineCullMode cullMode = PipelineCullMode::BACK;
+};
+
+class Pipeline {
+public:
+    Pipeline() = default;
+    virtual ~Pipeline() = default;
+
+    virtual void bind() const = 0;
+
+    PipelineParams params;
+};
diff --git a/engine/src/rendering/RenderCommandQueue.cpp b/engine/src/rendering/RenderCommandQueue.cpp
new file mode 100644
index 0000000..3bb6fa2
--- /dev/null
+++ b/engine/src/rendering/RenderCommandQueue.cpp
@@ -0,0 +1,52 @@
+#include "pch/enginepch.h"
+#include "RenderCommandQueue.h"
+
+void RenderCommandQueue::push(std::function<void(RenderCommands*)> command) {
+    buffers[writeBuffer].push_back(std::move(command));
+}
+
+void RenderCommandQueue::pushSync(std::function<void(RenderCommands*)> command) {
+    if (std::this_thread::get_id() == renderThreadId) {
+        command(renderCommands.get());
+        return;
+    }
+    std::unique_lock lock(mutex);
+    immediateQueue.push_back(std::move(command));
+    immediateExecuted = false;
+    readCondition.notify_one();
+
+    immediateCondition.wait(lock, [this] {
+        return immediateExecuted;
+    });
+}
+
+void RenderCommandQueue::swap() {
+    std::unique_lock lock(mutex);
+    std::swap(writeBuffer, readBuffer);
+    buffers[writeBuffer].clear();
+    readCondition.notify_one();
+}
+
+bool RenderCommandQueue::execute(const unsigned int timeoutMilliseconds) {
+    std::unique_lock lock(mutex);
+    if (!readCondition.wait_for(lock, std::chrono::milliseconds(timeoutMilliseconds), [this] {
+            return !immediateQueue.empty() || !buffers[readBuffer].empty();
+        })) {
+        return false;
+    }
+
+    if (!immediateQueue.empty()) {
+        for (const auto& command : immediateQueue) {
+            command(renderCommands.get());
+        }
+        immediateQueue.clear();
+        immediateExecuted = true;
+        immediateCondition.notify_all();
+    }
+
+    for (const auto& command : buffers[readBuffer]) {
+        command(renderCommands.get());
+    }
+    buffers[readBuffer].clear();
+    return true;
+}
diff --git a/engine/src/rendering/RenderCommandQueue.h b/engine/src/rendering/RenderCommandQueue.h
new file mode 100644
index 0000000..3a308a8
--- /dev/null
+++ b/engine/src/rendering/RenderCommandQueue.h
@@ -0,0 +1,31 @@
+#pragma once
+
+class RenderCommands;
+
+class RenderCommandQueue {
+public:
+    RenderCommandQueue(const Ref<RenderCommands>& renderCommands, const std::thread::id& renderThreadId) : renderCommands(renderCommands), renderThreadId(renderThreadId) {}
+
+    // Push a command to be executed in the next frame (render thread). This is non-blocking.
+    void push(std::function<void(RenderCommands*)> command);
+    // Push a command and block until it has been executed in the render thread.
+    // Once the current queue has been executed, the command will be executed.
+    void pushSync(std::function<void(RenderCommands*)> command);
+
+    void swap();
+
+    bool execute(unsigned int timeoutMilliseconds);
+
+private:
+    Ref<RenderCommands> renderCommands;
+    std::thread::id renderThreadId;
+
+    std::vector<std::function<void(RenderCommands*)>> buffers[2];
+    int writeBuffer = 0;
+    int readBuffer = 1;
+    std::vector<std::function<void(RenderCommands*)>> immediateQueue;
+    std::mutex mutex;
+    std::condition_variable readCondition;
+    std::condition_variable immediateCondition;
+    bool immediateExecuted = false;
+};
diff --git a/engine/src/rendering/RenderCommands.h b/engine/src/rendering/RenderCommands.h
new file mode 100644
index 0000000..e14e287
--- /dev/null
+++ b/engine/src/rendering/RenderCommands.h
@@ -0,0 +1,29 @@
+#pragma once
+
+/**
+ * The Renderer enqueues rendering commands, this class is what actually executes them.
+ */
+class RenderCommands : public std::enable_shared_from_this<RenderCommands> {
+public:
+    virtual ~RenderCommands() = default;
+
+    virtual void initializeTexture(const Ref<Texture>& texture) const = 0;
+    virtual void createTextureStorage(const Ref<Texture>& texture, Ref<uint8_t[]> data) const = 0;
+    virtual void bindTexture(const Ref<const Texture>& texture) const {} // TODO: implement and only bind if not already bound
+    virtual void bindTexture(const Ref<const Texture>& texture, unsigned int slot) const = 0;
+    virtual void clearTexture(const Ref<const Texture>& texture, Ref<uint8_t[]> color) const = 0;
+    virtual void copyTextureData(const Ref<const Texture>& src, unsigned int level, void* destination) const = 0;
+
+    virtual void initializeFramebuffer(const Ref<Framebuffer>& framebuffer) const = 0;
+    virtual void bindFramebuffer(const Ref<const Framebuffer>& framebuffer) const = 0;
+    virtual void clearFramebuffer(const Ref<const Framebuffer>& framebuffer) const = 0;
+    virtual void changeFramebufferFace(const Ref<const Framebuffer>& framebuffer, unsigned int attachmentIndex, unsigned int layer, unsigned int face) const = 0;
+    virtual int readPixelInt(const Ref<const Framebuffer>& framebuffer, unsigned int x, unsigned int y, unsigned int attachmentIndex) const = 0;
+    virtual void copyColorData(const Ref<const Framebuffer>& src, const Ref<const Framebuffer>& dst, unsigned int srcAttachmentIndex, unsigned int dstAttachmentIndex) const = 0;
+    virtual void copyColorDataToScreen(const Ref<const Framebuffer>& src, unsigned int srcAttachmentIndex) const = 0;
+    virtual void copyDepthData(const Ref<const Framebuffer>& src, const Ref<const Framebuffer>& dst) const = 0;
+
+    static void run(const std::function<void()>& function) {
+        function();
+    }
+};
diff --git a/engine/src/rendering/Renderer.cpp b/engine/src/rendering/Renderer.cpp
index 87493c9..78e3da1 100644
--- a/engine/src/rendering/Renderer.cpp
+++ b/engine/src/rendering/Renderer.cpp
@@ -1,8 +1,71 @@
 #include "pch/enginepch.h"
 #include "Renderer.h"
 
+#include "RenderCommands.h"
+#include "images/CubeMap.h"
+#include "images/ImageUtils.h"
 
-void Renderer::setViewport(const int x, const int y, const uint32_t width, const uint32_t height) {
+void Renderer::init(const unsigned int width, const unsigned int height) {
+    setFramebufferDimensions(width, height);
+    setViewport(0, 0, width, height);
+    auto white = std::make_unique<uint8_t[]>(4);
+    std::memcpy(white.get(), std::array<uint8_t, 4>{255, 255, 255, 255}.data(), 4);
+    whitePixelTexture = Texture::builder().size(1).format(TextureFormat::RGBA).internalFormat(TextureInternalFormat::RGBA8).data(std::move(white)).build(shared_from_this());
+    auto occlusionRoughnessMetallic = std::make_unique<uint8_t[]>(3);
+    std::memcpy(occlusionRoughnessMetallic.get(), std::array<uint8_t, 3>{255, 255, 0}.data(), 3);
+    defaultOcclusionRoughnessMetallicTexture =
+        Texture::builder().size(1).format(TextureFormat::RGB).internalFormat(TextureInternalFormat::RGB8).data(std::move(occlusionRoughnessMetallic)).build(shared_from_this());
+    const auto shadowDepthTexture =
+        Texture::builder().size(2048, 2048).format(TextureFormat::DEPTH).internalFormat(TextureInternalFormat::D24).filter(TextureFilter::NEAREST).build(shared_from_this());
+    shadowDepthFramebuffer = Framebuffer::builder().width(2048).height(2048).depthAttachment(shadowDepthTexture).build(shared_from_this());
+}
+
+void Renderer::setFramebufferDimensions(const unsigned int width, const unsigned int height) {
+    constexpr unsigned int samples = 4;
+    {
+        const auto colorTexture =
+            Texture::builder().size(width, height).samples(samples).format(TextureFormat::RGBA).internalFormat(TextureInternalFormat::RGBA8).build(this->shared_from_this());
+        const auto mousePickingTexture =
+            Texture::builder().size(width, height).samples(samples).format(TextureFormat::R_INT).internalFormat(TextureInternalFormat::R32_INT).build(this->shared_from_this());
+        const auto depthTexture = Texture::builder()
+                                      .size(width, height)
+                                      .samples(samples)
+                                      .format(TextureFormat::DEPTH_STENCIL)
+                                      .internalFormat(TextureInternalFormat::D24S8)
+                                      .build(this->shared_from_this());
+        framebuffer = Framebuffer::builder()
+                          .width(width)
+                          .height(height)
+                          .samples(samples)
+                          .addColorAttachment(colorTexture)
+                          .addColorAttachment(mousePickingTexture)
+                          .depthAttachment(depthTexture)
+                          .build(this->shared_from_this());
+    }
+    {
+        const auto renderedMousePickingTexture = Texture::builder()
+                                                     .size(width, height)
+                                                     .format(TextureFormat::R_INT)
+                                                     .internalFormat(TextureInternalFormat::R32_INT)
+                                                     .filter(TextureFilter::NEAREST)
+                                                     .build(this->shared_from_this());
+        mousePickingFramebuffer = Framebuffer::builder().width(width).height(height).addColorAttachment(renderedMousePickingTexture).build(this->shared_from_this());
+    }
+
+    std::array<Ref<Framebuffer>, 2> passFramebuffers;
+    for (auto& passFramebuffer : passFramebuffers) {
+        const auto colorTexture =
+            Texture::builder().size(width, height).samples(samples).format(TextureFormat::RGBA).internalFormat(TextureInternalFormat::RGBA32_FLOAT).build(this->shared_from_this());
+        const auto depthTexture =
+            Texture::builder().size(width, height).samples(samples).format(TextureFormat::DEPTH).internalFormat(TextureInternalFormat::D24).build(this->shared_from_this());
+        passFramebuffer =
+            Framebuffer::builder().width(width).height(height).samples(samples).addColorAttachment(colorTexture).depthAttachment(depthTexture).build(this->shared_from_this());
+    }
+    currentPassFramebuffer = passFramebuffers[0];
+    previousPassFramebuffer = passFramebuffers[1];
+}
+
+void Renderer::setViewport(const unsigned int x, const unsigned int y, const unsigned int width, const unsigned int height) {
     if (this->camera) {
         this->camera->setAspectRatio(static_cast<float>(width) / static_cast<float>(height));
     }
@@ -12,30 +75,148 @@ void Renderer::setViewport(const int x, const int y, const uint32_t width, const
     this->viewport.height = static_cast<int>(height);
 }
 
-const Ref<DepthFramebuffer>& Renderer::getShadowDepthFramebuffer() const {
-    return this->shadowDepthFramebuffer;
-}
-
 void Renderer::swapPassFramebuffers() {
-    const Ref<RenderPassFramebuffer> temp = this->previousPassFramebuffer;
+    const Ref<Framebuffer> temp = this->previousPassFramebuffer;
     this->previousPassFramebuffer = this->currentPassFramebuffer;
     this->currentPassFramebuffer = temp;
-    this->previousPassFramebuffer->copyDepthToBuffer(this->currentPassFramebuffer);
+    copyDepthData(previousPassFramebuffer, currentPassFramebuffer);
+}
+
+Ref<Texture> Renderer::createTexture(const Texture::TextureParams& params, std::unique_ptr<uint8_t[]> data) {
+    Ref<Texture> texture = newTexture(params);
+    initializeTexture(texture);
+    createTextureStorage(texture, std::move(data));
+    return texture;
+}
+
+void Renderer::initializeTexture(const Ref<Texture>& texture) {
+    pushCommand([texture](const RenderCommands* commands) {
+        commands->initializeTexture(texture);
+    });
+}
+
+void Renderer::createTextureStorage(const Ref<Texture>& texture, std::unique_ptr<uint8_t[]> data) {
+    std::shared_ptr dataRef = std::move(data);
+    pushCommand([texture, dataRef](const RenderCommands* commands) {
+        commands->createTextureStorage(texture, dataRef);
+    });
+}
+
+void Renderer::bindTexture(const Ref<const Texture>& texture, const unsigned int slot) {
+    pushCommand([texture, slot](const RenderCommands* commands) {
+        commands->bindTexture(texture, slot);
+    });
+}
+
+void Renderer::clearTexture(const Ref<const Texture>& texture, std::unique_ptr<uint8_t[]> color) {
+    std::shared_ptr colorRef = std::move(color);
+    pushCommand([texture, colorRef](const RenderCommands* commands) {
+        commands->clearTexture(texture, colorRef);
+    });
+}
+
+Ref<CubeMap> Renderer::copyTextureToCubeMap(const Ref<const Texture>& texture) {
+    std::array<Image, 6> faces;
+    pushCommandSync([texture, &faces](const RenderCommands* commands) {
+        commands->bindTexture(texture);
+        for (int i = 0; i < 6; i++) {
+            faces[i] = Image(texture->getWidth(), texture->getHeight(), texture->getFormat(), texture->getInternalFormat());
+            commands->copyTextureData(texture, i, faces[i].getData().get());
+        }
+    });
+    return std::make_shared<CubeMap>(std::move(faces));
+}
+
+Ref<Framebuffer> Renderer::createFramebuffer(const Framebuffer::FramebufferParams& params) {
+    Ref<Framebuffer> framebuffer = newFramebuffer(params);
+    initializeFramebuffer(framebuffer);
+    return framebuffer;
+}
+
+void Renderer::initializeFramebuffer(const Ref<Framebuffer>& framebuffer) {
+    pushCommand([framebuffer](const RenderCommands* commands) {
+        commands->initializeFramebuffer(framebuffer);
+    });
+}
+
+void Renderer::bindFramebuffer(const Ref<const Framebuffer>& framebuffer) {
+    pushCommand([framebuffer](const RenderCommands* commands) {
+        commands->bindFramebuffer(framebuffer);
+    });
+}
+
+void Renderer::clearFramebuffer(const Ref<const Framebuffer>& framebuffer) {
+    pushCommand([framebuffer](const RenderCommands* commands) {
+        commands->clearFramebuffer(framebuffer);
+    });
+}
+
+int Renderer::readPixelIntSync(const Ref<const Framebuffer>& framebuffer, unsigned int x, unsigned int y, unsigned int attachmentIndex) {
+    int value = -1;
+    pushCommandSync([framebuffer, x, y, attachmentIndex, &value](const RenderCommands* commands) {
+        value = commands->readPixelInt(framebuffer, x, y, attachmentIndex);
+    });
+    return value;
+}
+
+void Renderer::copyColorData(const Ref<const Framebuffer>& src, const Ref<const Framebuffer>& dst, unsigned int srcAttachmentIndex, unsigned int dstAttachmentIndex) {
+    pushCommand([src, dst, srcAttachmentIndex, dstAttachmentIndex](const RenderCommands* commands) {
+        commands->copyColorData(src, dst, srcAttachmentIndex, dstAttachmentIndex);
+    });
+}
+
+void Renderer::copyDepthData(const Ref<const Framebuffer>& src, const Ref<const Framebuffer>& dst) {
+    pushCommand([src, dst](const RenderCommands* commands) {
+        commands->copyDepthData(src, dst);
+    });
+}
+
+Ref<Texture> Renderer::createTextureCube(const std::array<std::string, 6>& paths) {
+    const Ref<Image> firstFace = ImageUtils::loadImageFromFile(paths[0]);
+    const size_t dataSize = firstFace->getDataSize();
+    auto data = std::make_unique<uint8_t[]>(dataSize * 6);
+    std::memcpy(data.get(), firstFace->getData().get(), dataSize);
+
+    for (size_t i = 1; i < paths.size(); i++) {
+        const Ref<Image> face = ImageUtils::loadImageFromFile(paths[i]);
+        if (face->getWidth() != firstFace->getWidth() || face->getHeight() != firstFace->getHeight() || face->getFormat() != firstFace->getFormat() ||
+            face->getInternalFormat() != firstFace->getInternalFormat()) {
+            DE_ERROR("All images must have the same dimensions and format to create a cubemap texture");
+            return nullptr;
+        }
+        std::memcpy(data.get() + i * dataSize, face->getData().get(), face->getDataSize());
+    }
+
+    Ref<Texture> textureCube = Texture::builder()
+                                   .size(firstFace->getWidth())
+                                   .layers(6)
+                                   .format(firstFace->getFormat())
+                                   .internalFormat(firstFace->getInternalFormat())
+                                   .type(TextureType::TEXTURE_CUBE)
+                                   .data(std::move(data))
+                                   .build(this->shared_from_this());
+    return textureCube;
+}
+
+void Renderer::endMeshes() {
+    copyColorData(framebuffer, mousePickingFramebuffer, 1, 0);
 }
 
-void Renderer::endMeshes() const {
-    this->getFramebuffer()->saveMousePicking();
+void Renderer::drawToMainFramebuffer() {
+    pushCommand([this](const RenderCommands* commands) {
+        commands->copyColorDataToScreen(this->framebuffer, 0);
+    });
 }
 
 void Renderer::setIrradianceSH(const std::array<glm::vec3, 9>& irradianceSh) {
     this->irradianceSH = irradianceSh;
 }
 
-void Renderer::setPrefilteredEnvMap(const Ref<TextureCube>& prefilteredEnvMap) {
+void Renderer::setPrefilteredEnvMap(const Ref<Texture>& prefilteredEnvMap) {
     this->prefilteredEnvMap = prefilteredEnvMap;
 }
 
-void Renderer::setBRDFLUT(const Ref<Texture2D>& brdfLUT) {
+void Renderer::setBRDFLUT(const Ref<Texture>& brdfLUT) {
     this->brdfLUT = brdfLUT;
 }
 
diff --git a/engine/src/rendering/Renderer.h b/engine/src/rendering/Renderer.h
index 989c9ce..c621175 100644
--- a/engine/src/rendering/Renderer.h
+++ b/engine/src/rendering/Renderer.h
@@ -1,23 +1,21 @@
 #pragma once
+#include "Framebuffer.h"
+#include "RenderCommandQueue.h"
 #include "camera/Camera.h"
 #include "VertexArray.h"
 #include "Shader.h"
 #include "Texture.h"
-#include "framebuffer/DataFramebuffer.h"
-#include "framebuffer/DepthFramebuffer.h"
-#include "framebuffer/RenderFramebuffer.h"
-#include "framebuffer/RenderPassFramebuffer.h"
 #include "framebuffer/ShadowCubeArrayFramebuffer.h"
 #include "scene/components/PointLight.h"
 #include "scene/lights/DirectionalLight.h"
 #include "scene/materials/Material.h"
 #include "skybox/SkyboxCube.h"
 
-enum class RenderAPI { NONE, OPENGL };
+enum class RenderAPI { NONE, OPENGL, VULKAN };
 
-class Renderer {
+class Renderer : public std::enable_shared_from_this<Renderer> {
 public:
-    explicit Renderer(const RenderAPI api) : api(api) {}
+    Renderer(const RenderAPI api, const Ref<RenderCommands>& commands) : queue(commands, std::this_thread::get_id()), api(api) {}
     virtual ~Renderer() = default;
 
     RenderAPI getAPI() const {
@@ -25,10 +23,10 @@ class Renderer {
     }
 
     struct Viewport {
-        int x = 0;
-        int y = 0;
-        int width = 0;
-        int height = 0;
+        unsigned int x = 0;
+        unsigned int y = 0;
+        unsigned int width = 0;
+        unsigned int height = 0;
     };
 
     const Ref<Camera>& getCamera() {
@@ -39,44 +37,68 @@ class Renderer {
         this->camera = camera;
     }
 
-    virtual void init(uint32_t width, uint32_t height) = 0;
-    virtual void setFramebufferDimensions(unsigned int width, unsigned int height) = 0;
-    void setViewport(int x, int y, uint32_t width, uint32_t height);
+    virtual void init(unsigned int width, unsigned int height);
+
+    void setFramebufferDimensions(unsigned int width, unsigned int height);
+
+    void setViewport(unsigned int x, unsigned int y, unsigned int width, unsigned int height);
 
     const Viewport& getViewport() const {
         return this->viewport;
     }
 
-    virtual Ref<RenderFramebuffer> getFramebuffer() const = 0;
-    const Ref<DepthFramebuffer>& getShadowDepthFramebuffer() const;
+    Ref<Framebuffer> getFramebuffer() const {
+        return this->framebuffer;
+    }
+
+    Ref<Framebuffer> getMousePickingFramebuffer() const {
+        return this->mousePickingFramebuffer;
+    }
+
     void swapPassFramebuffers();
 
     virtual Ref<VertexArray> createVertexArray(const Ref<VertexBuffer>& vertexBuffer, const Ref<IndexBuffer>& indexBuffer) const = 0;
     virtual Ref<VertexBuffer> createVertexBuffer(const float* vertices, uint32_t size) const = 0;
     virtual Ref<IndexBuffer> createIndexBuffer(const uint32_t* indexes, uint32_t count) const = 0;
     virtual Ref<Shader> createShader(const std::string& vertexPath, const std::string& fragmentPath) const = 0;
-    virtual Ref<Texture2D> createTexture2D(const std::string& path) const = 0;
-    virtual Ref<Texture2D> createTexture2D(unsigned int channels, unsigned int width, unsigned int height, unsigned int bytesPerPixel, const void* data) const = 0;
-    virtual Ref<Texture2D> createTexture2D(unsigned int channels, unsigned int width, unsigned int height, unsigned int bytesPerPixel, TextureFormat format,
-                                           const void* data) const = 0;
-    virtual Ref<Texture2D> createBRDFLUT(const Ref<Shader>& shader, uint32_t width) const = 0;
-    virtual Ref<TextureCube> createTextureCube(const std::array<std::string, 6>& paths) const = 0;
-    virtual Ref<TextureCube> createTextureCubeFromHDR(const Ref<Texture2D>& hdrTexture, const Ref<Shader>& convertShader, uint32_t size) = 0;
-    virtual Ref<TextureCube> createPrefilteredCubemap(const Ref<TextureCube>& textureCube, const Ref<Shader>& convertShader, uint32_t size) = 0;
+
+    Ref<Texture> createTexture(const Texture::TextureParams& params, std::unique_ptr<uint8_t[]> data);
+    void initializeTexture(const Ref<Texture>& texture);
+    void createTextureStorage(const Ref<Texture>& texture, std::unique_ptr<uint8_t[]> data);
+    void bindTexture(const Ref<const Texture>& texture, unsigned int slot);
+    virtual void destroyTexture(const Texture& texture) = 0;
+    void clearTexture(const Ref<const Texture>& texture, std::unique_ptr<uint8_t[]> color);
+    // This method is synchronous, it will block rendering until the texture data has been copied
+    Ref<CubeMap> copyTextureToCubeMap(const Ref<const Texture>& texture);
+
+    Ref<Framebuffer> createFramebuffer(const Framebuffer::FramebufferParams& params);
+    void initializeFramebuffer(const Ref<Framebuffer>& framebuffer);
+    void bindFramebuffer(const Ref<const Framebuffer>& framebuffer);
+    virtual void destroyFramebuffer(const Framebuffer& texture) = 0;
+    void clearFramebuffer(const Ref<const Framebuffer>& framebuffer);
+    // TODO: async callbacks executed on main thread?
+    int readPixelIntSync(const Ref<const Framebuffer>& framebuffer, unsigned int x, unsigned int y, unsigned int attachmentIndex);
+    void copyColorData(const Ref<const Framebuffer>& src, const Ref<const Framebuffer>& dst, unsigned int srcAttachmentIndex, unsigned int dstAttachmentIndex);
+    void copyDepthData(const Ref<const Framebuffer>& src, const Ref<const Framebuffer>& dst);
+
+    virtual Ref<Texture> createBRDFLUT(const Ref<Shader>& shader, uint32_t width) = 0;
+    Ref<Texture> createTextureCube(const std::array<std::string, 6>& paths);
+    virtual Ref<Texture> createTextureCubeFromHDR(const Ref<Texture>& hdrTexture, const Ref<Shader>& convertShader, uint32_t size) = 0;
+    virtual Ref<Texture> createPrefilteredCubemap(const Ref<Texture>& textureCube, const Ref<Shader>& convertShader, uint32_t size) = 0;
 
     virtual void beginFrame() = 0;
     virtual void beginDirectionalShadows() const = 0;
     virtual void beginPointLightShadows() const = 0;
     virtual void beginPointLightShadow(const PointLight& light, int lightIndex, int faceIndex) const = 0;
     virtual void endShadows() const = 0;
-    void endMeshes() const;
+    void endMeshes();
     virtual void endFrame() const = 0;
-    virtual void clear() const = 0;
-    virtual void drawToMainFramebuffer() const = 0;
+    virtual void clear() = 0;
+    void drawToMainFramebuffer();
 
     void setIrradianceSH(const std::array<glm::vec3, 9>& irradianceSh);
-    void setPrefilteredEnvMap(const Ref<TextureCube>& prefilteredEnvMap);
-    void setBRDFLUT(const Ref<Texture2D>& brdfLUT);
+    void setPrefilteredEnvMap(const Ref<Texture>& prefilteredEnvMap);
+    void setBRDFLUT(const Ref<Texture>& brdfLUT);
     // needs to be called before each frame
     void setDirectionalLight(const Ref<DirectionalLight>& directionalLight);
     void addPointLight(const PointLight& pointLight);
@@ -94,30 +116,54 @@ class Renderer {
     virtual void drawUI(const Ref<VertexArray>& vertexArray, const Ref<Shader>& shader, const Material& material) const = 0;
 
 protected:
+    // todo: replace with queue.push directly after adding multi-threading
+    void pushCommand(const std::function<void(RenderCommands*)>& command) {
+        queue.push(command);
+        queue.swap();
+        queue.execute(16);
+    }
+
+    // todo: same as above
+    void pushCommandSync(const std::function<void(RenderCommands*)>& command) {
+        queue.pushSync(command);
+    }
+
+private:
+    virtual Ref<Texture> newTexture(const Texture::TextureParams& params) = 0;
+    virtual Ref<Framebuffer> newFramebuffer(const Framebuffer::FramebufferParams& params) = 0;
+
+protected:
+    RenderCommandQueue queue;
+
     Ref<Camera> camera;
-    glm::mat4 viewProjectionMatrix;
-    glm::mat4 viewMatrix;
-    glm::mat4 projectionMatrix;
+    glm::mat4 viewProjectionMatrix = glm::identity<glm::mat4>();
+    glm::mat4 viewMatrix = glm::identity<glm::mat4>();
+    glm::mat4 projectionMatrix = glm::identity<glm::mat4>();
     Viewport viewport;
 
+    Ref<Framebuffer> framebuffer;
+    Ref<Framebuffer> mousePickingFramebuffer;
+    Ref<Framebuffer> previousPassFramebuffer; // used to reference in the current pass
+    Ref<Framebuffer> currentPassFramebuffer; // will be swapped with the previous one after each pass
+
+    // default textures
+    Ref<Texture> whitePixelTexture;
+    Ref<Texture> defaultOcclusionRoughnessMetallicTexture;
+
     // lighting
     std::array<glm::vec3, 9> irradianceSH = std::array<glm::vec3, 9>();
-    Ref<TextureCube> prefilteredEnvMap;
-    Ref<Texture2D> brdfLUT;
+    Ref<Texture> prefilteredEnvMap;
+    Ref<Texture> brdfLUT;
     Ref<DirectionalLight> directionalLight;
-    glm::mat4 directionalLightViewProjection;
+    glm::mat4 directionalLightViewProjection = glm::identity<glm::mat4>();
     std::vector<PointLight> pointLights = std::vector<PointLight>();
 
     // shadow mapping
-    Ref<DepthFramebuffer> shadowDepthFramebuffer;
+    Ref<Framebuffer> shadowDepthFramebuffer;
     Ref<Shader> shadowMapShader;
     Ref<ShadowCubeArrayFramebuffer> shadowCubeArrayFramebuffer;
     Ref<Shader> shadowCubeArrayShader;
 
-    Ref<DataFramebuffer> dataFramebuffer;
-    Ref<RenderPassFramebuffer> previousPassFramebuffer; // used to reference in the current pass
-    Ref<RenderPassFramebuffer> currentPassFramebuffer; // will be swapped with the previous one after each pass
-
 private:
     RenderAPI api;
 };
diff --git a/engine/src/rendering/Texture.cpp b/engine/src/rendering/Texture.cpp
index 58c9f42..428f95c 100644
--- a/engine/src/rendering/Texture.cpp
+++ b/engine/src/rendering/Texture.cpp
@@ -1,7 +1,65 @@
 #include "pch/enginepch.h"
 #include "Texture.h"
 
-const glm::mat4 TextureCube::invertedViewMatrices[] = {
+TextureBuilder Texture::builder() {
+    return {};
+}
+
+Texture::Texture(const TextureParams& params, const Ref<Renderer>& renderer) : params(params), renderer(renderer) {
+    if (this->params.type == TextureType::TEXTURE_CUBE) {
+        DE_ASSERT(this->params.layers == 6, "Cubemap must have 6 layers")
+        DE_ASSERT(this->params.width == this->params.height, "Cubemap must be square")
+    } else if (this->params.type == TextureType::TEXTURE_CUBE_ARRAY) {
+        DE_ASSERT(this->params.layers % 6 == 0, "Cubemap array must have a multiple of 6 layers")
+        DE_ASSERT(this->params.width == this->params.height, "Cubemap array must be square")
+    }
+}
+
+Texture::~Texture() {
+    getRenderer()->destroyTexture(*this);
+}
+
+void Texture::bind(const unsigned int slot) const {
+    getRenderer()->bindTexture(shared_from_this(), slot);
+}
+
+void Texture::resize(const unsigned int width, const unsigned int height) {
+    params.width = width;
+    params.height = height;
+    getRenderer()->createTextureStorage(shared_from_this(), nullptr);
+}
+
+void Texture::resize(const unsigned int width, const unsigned int height, const unsigned int layers) {
+    DE_ASSERT(params.type == TextureType::TEXTURE_2D_ARRAY || params.type == TextureType::TEXTURE_CUBE_ARRAY,
+              "Resize with layers is only supported for 2D Array and Cube Array textures")
+    DE_ASSERT(layers % 6 == 0 || params.type == TextureType::TEXTURE_2D_ARRAY, "Cube Array textures must have a multiple of 6 layers")
+    params.width = width;
+    params.height = height;
+    params.layers = layers;
+    getRenderer()->createTextureStorage(shared_from_this(), nullptr);
+}
+
+Ref<CubeMap> Texture::toCubemap() const {
+    DE_ASSERT(params.type == TextureType::TEXTURE_CUBE, "toCubemap is only supported for Cube textures")
+    return getRenderer()->copyTextureToCubeMap(shared_from_this());
+}
+
+TextureBuilder& TextureBuilder::fromImage(const Ref<Image>& image) {
+    this->width(image->getWidth());
+    this->height(image->getHeight());
+    this->format(image->getFormat());
+    this->internalFormat(image->getInternalFormat());
+    auto data = std::make_unique<uint8_t[]>(image->getDataSize());
+    std::memcpy(data.get(), image->getData().get(), image->getDataSize());
+    this->data(std::move(data));
+    return *this;
+}
+
+Ref<Texture> TextureBuilder::build(const Ref<Renderer>& renderer) {
+    return renderer->createTexture(this->params, std::move(this->textureData));
+}
+
+const glm::mat4 TextureCubeUtils::invertedViewMatrices[] = {
     lookAt(glm::vec3(0.0f), glm::vec3(0.0f, 0.0f, 1.0f), glm::vec3(0.0f, -1.0f, 0.0f)), // right
     lookAt(glm::vec3(0.0f), glm::vec3(0.0f, 0.0f, -1.0f), glm::vec3(0.0f, -1.0f, 0.0f)), // left
     lookAt(glm::vec3(0.0f), glm::vec3(0.0f, 1.0f, 0.0f), glm::vec3(1.0f, 0.0f, 0.0f)), // top
@@ -10,7 +68,7 @@ const glm::mat4 TextureCube::invertedViewMatrices[] = {
     lookAt(glm::vec3(0.0f), glm::vec3(-1.0f, 0.0f, 0.0f), glm::vec3(0.0f, -1.0f, 0.0f)), // back
 };
 
-const glm::mat4 TextureCube::shadowViewMatrices[] = {
+const glm::mat4 TextureCubeUtils::shadowViewMatrices[] = {
     lookAt(glm::vec3(0.0f), glm::vec3(1.0f, 0.0f, 0.0f), glm::vec3(0.0f, 1.0f, 0.0f)), // right
     lookAt(glm::vec3(0.0f), glm::vec3(-1.0f, 0.0f, 0.0f), glm::vec3(0.0f, 1.0f, 0.0f)), // left
     lookAt(glm::vec3(0.0f), glm::vec3(0.0f, -1.0f, 0.0f), glm::vec3(0.0f, 0.0f, 1.0f)), // bottom
diff --git a/engine/src/rendering/Texture.h b/engine/src/rendering/Texture.h
index 7268ec2..28d53a2 100644
--- a/engine/src/rendering/Texture.h
+++ b/engine/src/rendering/Texture.h
@@ -1,76 +1,236 @@
 #pragma once
-#include "images/CubeMap.h"
+#include "TextureFormats.h"
+#include "images/Image.h"
 
-class Texture {
-public:
-    virtual ~Texture() = default;
-
-    virtual void bind(unsigned int) const = 0;
-};
 
+class CubeMap;
+class Renderer;
+class TextureBuilder;
 
-class Texture2D : public Texture {
+class Texture : public std::enable_shared_from_this<Texture> {
 public:
-    Texture2D(const unsigned int width, const unsigned int height) : width(width), height(height) {}
+    virtual ~Texture();
 
     unsigned int getWidth() const {
-        return this->width;
+        return this->params.width;
     }
 
     unsigned int getHeight() const {
-        return this->height;
+        return this->params.height;
+    }
+
+    unsigned int getLayers() const {
+        return this->params.layers;
+    }
+
+    unsigned int getSamples() const {
+        return this->params.samples;
+    }
+
+    TextureFormat getFormat() const {
+        return this->params.format;
     }
 
+    TextureInternalFormat getInternalFormat() const {
+        return this->params.internalFormat;
+    }
+
+    TextureType getType() const {
+        return this->params.type;
+    }
+
+    TextureFilter getFilterMin() const {
+        return this->params.filterMin;
+    }
+
+    TextureFilter getFilterMag() const {
+        return this->params.filterMag;
+    }
+
+    TextureWrap getWrapU() const {
+        return this->params.wrapU;
+    }
+
+    TextureWrap getWrapV() const {
+        return this->params.wrapV;
+    }
+
+    TextureWrap getWrapW() const {
+        return this->params.wrapW;
+    }
+
+    bool shouldGenerateMipmaps() const {
+        return this->params.generateMipmaps;
+    }
+
+    void bind(unsigned int slot) const;
+
     virtual void setRawData(const void* data, unsigned int size) = 0;
-    virtual void resize(unsigned int width, unsigned int height) = 0;
+    void resize(unsigned int width, unsigned int height);
+    void resize(unsigned int width, unsigned int height, unsigned int layers);
+
+    Ref<CubeMap> toCubemap() const;
+
+    static TextureBuilder builder();
+
+    struct TextureParams {
+        unsigned int width = 0;
+        unsigned int height = 0;
+        unsigned int layers = 1;
+        unsigned int samples = 1;
+        TextureFormat format = TextureFormat::RGBA;
+        TextureInternalFormat internalFormat = TextureInternalFormat::RGBA8;
+        TextureType type = TextureType::TEXTURE_2D;
+        TextureFilter filterMin = TextureFilter::LINEAR;
+        TextureFilter filterMag = TextureFilter::LINEAR;
+        TextureWrap wrapU = TextureWrap::REPEAT;
+        TextureWrap wrapV = TextureWrap::REPEAT;
+        TextureWrap wrapW = TextureWrap::REPEAT;
+        bool generateMipmaps = false;
+    };
 
 protected:
-    unsigned int width;
-    unsigned int height;
+    Texture(const TextureParams& params, const Ref<Renderer>& renderer);
+
+    Ref<Renderer> getRenderer() const {
+        Ref<Renderer> ref = renderer.lock();
+        if (!ref) {
+            throw std::runtime_error("The renderer associated with this texture has been destroyed.");
+        }
+        return ref;
+    }
+
+    TextureParams params;
+
+private:
+    std::weak_ptr<Renderer> renderer;
+};
+
+
+class TextureCubeUtils {
+public:
+    static const glm::mat4 invertedViewMatrices[6];
+    static const glm::mat4 shadowViewMatrices[6];
 };
 
 
-class TextureCube : public Texture {
+class TextureBuilder {
 public:
-    explicit TextureCube(const unsigned int size) : size(size) {}
+    TextureBuilder& width(const unsigned int width) {
+        this->params.width = width;
+        return *this;
+    }
 
-    unsigned int getSize() const {
-        return this->size;
+    TextureBuilder& height(const unsigned int height) {
+        this->params.height = height;
+        return *this;
     }
 
-    virtual Ref<CubeMap> toCubemap() const = 0;
+    TextureBuilder& size(const unsigned int size) {
+        this->width(size);
+        this->height(size);
+        return *this;
+    }
 
-    static const glm::mat4 invertedViewMatrices[6];
-    static const glm::mat4 shadowViewMatrices[6];
+    TextureBuilder& size(const unsigned int width, const unsigned int height) {
+        this->width(width);
+        this->height(height);
+        return *this;
+    }
 
-protected:
-    unsigned int size;
-};
+    TextureBuilder& layers(const unsigned int layers) {
+        this->params.layers = layers;
+        return *this;
+    }
+
+    TextureBuilder& samples(const unsigned int samples) {
+        this->params.samples = samples;
+        return *this;
+    }
 
+    TextureBuilder& format(const TextureFormat format) {
+        this->params.format = format;
+        return *this;
+    }
 
-class TextureCubeArray : public Texture {
-public:
-    TextureCubeArray(const unsigned int size, const unsigned int layersCount) : size(size), layersCount(layersCount) {}
+    TextureBuilder& internalFormat(const TextureInternalFormat internalFormat) {
+        this->params.internalFormat = internalFormat;
+        return *this;
+    }
 
-    unsigned int getSize() const {
-        return this->size;
+    TextureBuilder& type(const TextureType type) {
+        this->params.type = type;
+        return *this;
     }
 
-    unsigned int getLayersCount() const {
-        return this->layersCount;
+    TextureBuilder& filterMin(const TextureFilter filter) {
+        this->params.filterMin = filter;
+        return *this;
     }
 
-    void setLayersCount(const unsigned int layersCount) {
-        this->layersCount = layersCount;
+    TextureBuilder& filterMag(const TextureFilter filter) {
+        this->params.filterMag = filter;
+        return *this;
     }
 
-protected:
-    unsigned int size;
-    unsigned int layersCount;
-};
+    TextureBuilder& filter(const TextureFilter filter) {
+        this->filterMin(filter);
+        this->filterMag(filter);
+        return *this;
+    }
+
+    TextureBuilder& filter(const TextureFilter minFilter, const TextureFilter maxFilter) {
+        this->filterMin(minFilter);
+        this->filterMag(maxFilter);
+        return *this;
+    }
+
+    TextureBuilder& wrapU(const TextureWrap wrap) {
+        this->params.wrapU = wrap;
+        return *this;
+    }
+
+    TextureBuilder& wrapV(const TextureWrap wrap) {
+        this->params.wrapV = wrap;
+        return *this;
+    }
+
+    TextureBuilder& wrapW(const TextureWrap wrap) {
+        this->params.wrapW = wrap;
+        return *this;
+    }
+
+    TextureBuilder& wrapUV(const TextureWrap wrap) {
+        this->wrapU(wrap);
+        this->wrapV(wrap);
+        return *this;
+    }
+
+    TextureBuilder& wrap(const TextureWrap wrap) {
+        this->wrapU(wrap);
+        this->wrapV(wrap);
+        this->wrapW(wrap);
+        return *this;
+    }
+
+    TextureBuilder& generateMipmaps(const bool generateMipmaps) {
+        this->params.generateMipmaps = generateMipmaps;
+        return *this;
+    }
+
+    TextureBuilder& data(std::unique_ptr<uint8_t[]> data) {
+        this->textureData = std::move(data);
+        return *this;
+    }
+
+    TextureBuilder& fromImage(const Ref<Image>& image);
+
+    Ref<Texture> build(const Ref<Renderer>& renderer);
+
+private:
+    friend class Texture;
+    TextureBuilder() = default;
 
-enum TextureFormat {
-    RGB = 0,
-    RGBA = 1,
-    BGRA = 2,
+    Texture::TextureParams params;
+    std::unique_ptr<uint8_t[]> textureData = nullptr;
 };
diff --git a/engine/src/rendering/TextureFormats.h b/engine/src/rendering/TextureFormats.h
new file mode 100644
index 0000000..9cb1d23
--- /dev/null
+++ b/engine/src/rendering/TextureFormats.h
@@ -0,0 +1,367 @@
+#pragma once
+
+class TextureFormat {
+public:
+    enum FormatEnum : unsigned char {
+        R,
+        R_INT,
+        RG,
+        RG_INT,
+        RGB,
+        RGB_INT,
+        RGBA,
+        RGBA_INT,
+        BGRA, // TODO: test removing this, see if the UI texture still works
+        DEPTH,
+        DEPTH_STENCIL,
+    };
+
+    constexpr TextureFormat() = default;
+    /* implicit */ constexpr TextureFormat(const FormatEnum e) : e(e) {}
+
+    // ReSharper disable once CppNonExplicitConversionOperator
+    // allows comparisons with Enum constants.
+    constexpr operator FormatEnum() const {
+        return e;
+    }
+
+    // prevent if (x)
+    explicit operator bool() const = delete;
+
+    constexpr unsigned int getChannelCount() const {
+        switch (e) {
+            case R:
+            case R_INT:
+            case DEPTH:
+                return 1;
+            case RG:
+            case RG_INT:
+            case DEPTH_STENCIL:
+                return 2;
+            case RGB:
+            case RGB_INT:
+                return 3;
+            case RGBA:
+            case RGBA_INT:
+            case BGRA:
+                return 4;
+            default:
+                return 0;
+        }
+    }
+
+private:
+    FormatEnum e;
+};
+
+
+class TextureDataType {
+public:
+    // ReSharper disable CppInconsistentNaming, IdentifierTypo
+    enum DataTypeEnum {
+        BYTE,
+        UBYTE,
+        SHORT,
+        USHORT,
+        INT,
+        UINT,
+        HALF_FLOAT,
+        FLOAT,
+    };
+    // ReSharper restore CppInconsistentNaming, IdentifierTypo
+
+    constexpr TextureDataType() = default;
+    /* implicit */ constexpr TextureDataType(const DataTypeEnum e) : e(e) {}
+
+    // ReSharper disable once CppNonExplicitConversionOperator
+    // allows comparisons with Enum constants.
+    constexpr operator DataTypeEnum() const {
+        return e;
+    }
+
+    // prevent if (x)
+    explicit operator bool() const = delete;
+
+    constexpr unsigned int getByteSize() const {
+        switch (e) {
+            case INT:
+                return 4;
+            case FLOAT:
+                return 4;
+            default:
+                return 0;
+        }
+    }
+
+private:
+    DataTypeEnum e;
+};
+
+
+class TextureInternalFormat {
+public:
+    // ReSharper disable CppInconsistentNaming
+    enum InternalFormatEnum {
+        R8,
+        R8_SNORM,
+        R8_UINT,
+        R8_INT,
+        R16,
+        R16_SNORM,
+        R16_UINT,
+        R16_INT,
+        R16_FLOAT,
+        R32_UINT,
+        R32_INT,
+        R32_FLOAT,
+        RG8,
+        RG8_SNORM,
+        RG8_UINT,
+        RG8_INT,
+        RG16,
+        RG16_SNORM,
+        RG16_UINT,
+        RG16_INT,
+        RG16_FLOAT,
+        RG32_UINT,
+        RG32_INT,
+        RG32_FLOAT,
+        RGB8,
+        RGB8_SNORM,
+        RGB8_UINT,
+        RGB8_INT,
+        RGBA8,
+        RGBA8_SNORM,
+        RGBA8_UINT,
+        RGBA8_INT,
+        RGBA16,
+        RGBA16_SNORM,
+        RGBA16_UINT,
+        RGBA16_INT,
+        RGBA16_FLOAT,
+        RGBA32_UINT,
+        RGBA32_INT,
+        RGBA32_FLOAT,
+        D16,
+        D24,
+        D32,
+        D24S8,
+    };
+    // ReSharper restore CppInconsistentNaming
+
+    constexpr TextureInternalFormat() = default;
+    /* implicit */ constexpr TextureInternalFormat(const InternalFormatEnum e) : e(e) {}
+
+    // ReSharper disable once CppNonExplicitConversionOperator
+    // allows comparisons with Enum constants.
+    constexpr operator InternalFormatEnum() const {
+        return e;
+    }
+
+    // prevent if (x)
+    explicit operator bool() const = delete;
+
+    constexpr TextureDataType getDataType() const {
+        switch (e) {
+            case R8_SNORM:
+            case RG8_SNORM:
+            case RGB8_SNORM:
+            case RGBA8_SNORM:
+            case R8_INT:
+            case RG8_INT:
+            case RGB8_INT:
+            case RGBA8_INT:
+                return TextureDataType::BYTE;
+            case R8:
+            case RG8:
+            case RGB8:
+            case RGBA8:
+            case R8_UINT:
+            case RG8_UINT:
+            case RGB8_UINT:
+            case RGBA8_UINT:
+                return TextureDataType::UBYTE;
+            case R16_SNORM:
+            case RG16_SNORM:
+            case RGBA16_SNORM:
+            case R16_INT:
+            case RG16_INT:
+            case RGBA16_INT:
+                return TextureDataType::SHORT;
+            case R16:
+            case RG16:
+            case RGBA16:
+            case R16_UINT:
+            case RG16_UINT:
+            case RGBA16_UINT:
+            case D16:
+                return TextureDataType::USHORT;
+            case R32_INT:
+            case RG32_INT:
+            case RGBA32_INT:
+                return TextureDataType::INT;
+            case R32_UINT:
+            case RG32_UINT:
+            case RGBA32_UINT:
+            case D24:
+            case D24S8:
+                return TextureDataType::UINT;
+            case R16_FLOAT:
+            case RG16_FLOAT:
+            case RGBA16_FLOAT:
+                return TextureDataType::HALF_FLOAT;
+            case R32_FLOAT:
+            case RG32_FLOAT:
+            case RGBA32_FLOAT:
+            case D32:
+                return TextureDataType::FLOAT;
+            default:
+                return TextureDataType::FLOAT;
+        }
+    }
+
+    constexpr unsigned int getSize() const {
+        switch (e) {
+            case R8:
+            case R8_SNORM:
+            case R8_UINT:
+            case R8_INT:
+                return 1;
+            case R16:
+            case R16_SNORM:
+            case R16_UINT:
+            case R16_INT:
+            case R16_FLOAT:
+            case RG8:
+            case RG8_SNORM:
+            case RG8_UINT:
+            case RG8_INT:
+            case D16:
+                return 2;
+            case RGB8:
+            case RGB8_SNORM:
+            case RGB8_UINT:
+            case RGB8_INT:
+            case D24:
+                return 3;
+            case R32_UINT:
+            case R32_INT:
+            case R32_FLOAT:
+            case RG16:
+            case RG16_SNORM:
+            case RG16_UINT:
+            case RG16_INT:
+            case RG16_FLOAT:
+            case RGBA8:
+            case RGBA8_SNORM:
+            case RGBA8_UINT:
+            case RGBA8_INT:
+            case D32:
+            case D24S8:
+                return 4;
+            case RG32_UINT:
+            case RG32_INT:
+            case RG32_FLOAT:
+            case RGBA16:
+            case RGBA16_SNORM:
+            case RGBA16_UINT:
+            case RGBA16_INT:
+            case RGBA16_FLOAT:
+                return 8;
+            case RGBA32_UINT:
+            case RGBA32_INT:
+            case RGBA32_FLOAT:
+                return 16;
+            default:
+                return 0;
+        }
+    }
+
+private:
+    InternalFormatEnum e;
+};
+
+class TextureType {
+public:
+    // ReSharper disable CppInconsistentNaming
+    enum TextureTypeEnum {
+        TEXTURE_2D,
+        TEXTURE_2D_ARRAY,
+        TEXTURE_CUBE,
+        TEXTURE_CUBE_ARRAY,
+    };
+    // ReSharper restore CppInconsistentNaming
+
+    constexpr TextureType() = default;
+    /* implicit */ constexpr TextureType(const TextureTypeEnum e) : e(e) {}
+
+    // ReSharper disable once CppNonExplicitConversionOperator
+    // allows comparisons with Enum constants.
+    constexpr operator TextureTypeEnum() const {
+        return e;
+    }
+
+    // prevent if (x)
+    explicit operator bool() const = delete;
+
+    constexpr bool isArray() const {
+        return e == TEXTURE_2D_ARRAY || e == TEXTURE_CUBE_ARRAY;
+    }
+
+private:
+    TextureTypeEnum e;
+};
+
+class TextureWrap {
+public:
+    // ReSharper disable CppInconsistentNaming, IdentifierTypo
+    enum WrapEnum {
+        REPEAT,
+        MIRRORED_REPEAT,
+        CLAMP_TO_EDGE,
+        CLAMP_TO_BORDER,
+    };
+    // ReSharper restore CppInconsistentNaming, IdentifierTypo
+
+    constexpr TextureWrap() = default;
+    /* implicit */ constexpr TextureWrap(const WrapEnum e) : e(e) {}
+
+    // ReSharper disable once CppNonExplicitConversionOperator
+    // allows comparisons with Enum constants.
+    constexpr operator WrapEnum() const {
+        return e;
+    }
+
+    // prevent if (x)
+    explicit operator bool() const = delete;
+
+private:
+    WrapEnum e;
+};
+
+class TextureFilter {
+public:
+    // ReSharper disable CppInconsistentNaming, IdentifierTypo
+    enum FilterEnum {
+        NEAREST,
+        LINEAR,
+        MIPMAP_NEAREST,
+        MIPMAP_LINEAR,
+    };
+    // ReSharper restore CppInconsistentNaming, IdentifierTypo
+
+    constexpr TextureFilter() = default;
+    /* implicit */ constexpr TextureFilter(const FilterEnum e) : e(e) {}
+
+    // ReSharper disable once CppNonExplicitConversionOperator
+    // allows comparisons with Enum constants.
+    constexpr operator FilterEnum() const {
+        return e;
+    }
+
+    // prevent if (x)
+    explicit operator bool() const = delete;
+
+private:
+    FilterEnum e;
+};
diff --git a/engine/src/rendering/framebuffer/DataFramebuffer.h b/engine/src/rendering/framebuffer/DataFramebuffer.h
deleted file mode 100644
index 2202667..0000000
--- a/engine/src/rendering/framebuffer/DataFramebuffer.h
+++ /dev/null
@@ -1,24 +0,0 @@
-#pragma once
-
-class DataFramebuffer {
-public:
-    DataFramebuffer(const unsigned int width, const unsigned int height) : width(width), height(height) {}
-    virtual ~DataFramebuffer() = default;
-
-    unsigned int getWidth() const {
-        return this->width;
-    }
-
-    unsigned int getHeight() const {
-        return this->height;
-    }
-
-    virtual void bind() const = 0;
-    virtual void clear() const = 0;
-
-    virtual const Ref<Texture2D>& getDataTexture() const = 0;
-
-protected:
-    unsigned int width;
-    unsigned int height;
-};
diff --git a/engine/src/rendering/framebuffer/DepthFramebuffer.h b/engine/src/rendering/framebuffer/DepthFramebuffer.h
deleted file mode 100644
index 5306a5c..0000000
--- a/engine/src/rendering/framebuffer/DepthFramebuffer.h
+++ /dev/null
@@ -1,23 +0,0 @@
-#pragma once
-
-class DepthFramebuffer {
-public:
-    DepthFramebuffer(const uint32_t width, const uint32_t height) : width(width), height(height) {}
-    virtual ~DepthFramebuffer() = default;
-
-    uint32_t getWidth() const {
-        return this->width;
-    }
-
-    uint32_t getHeight() const {
-        return this->height;
-    }
-
-    virtual void bind() const = 0;
-
-    virtual const Ref<Texture2D>& getDepthTexture() const = 0;
-
-protected:
-    uint32_t width;
-    uint32_t height;
-};
diff --git a/engine/src/rendering/framebuffer/RenderFramebuffer.h b/engine/src/rendering/framebuffer/RenderFramebuffer.h
deleted file mode 100644
index aa3ec96..0000000
--- a/engine/src/rendering/framebuffer/RenderFramebuffer.h
+++ /dev/null
@@ -1,27 +0,0 @@
-#pragma once
-
-class RenderFramebuffer {
-public:
-    RenderFramebuffer(const uint32_t width, const uint32_t height) : width(width), height(height) {}
-    virtual ~RenderFramebuffer() = default;
-
-    uint32_t getWidth() const {
-        return this->width;
-    }
-
-    uint32_t getHeight() const {
-        return this->height;
-    }
-
-    virtual void bind() const = 0;
-
-    virtual const Ref<Texture2D>& getDepthTexture() const = 0;
-    virtual int getMousePickingValue(int x, int y) const = 0;
-
-    virtual void clear() const = 0;
-    virtual void saveMousePicking() const = 0;
-
-protected:
-    uint32_t width;
-    uint32_t height;
-};
diff --git a/engine/src/rendering/framebuffer/RenderPassFramebuffer.h b/engine/src/rendering/framebuffer/RenderPassFramebuffer.h
deleted file mode 100644
index 99ee5be..0000000
--- a/engine/src/rendering/framebuffer/RenderPassFramebuffer.h
+++ /dev/null
@@ -1,27 +0,0 @@
-#pragma once
-
-class RenderPassFramebuffer {
-public:
-    RenderPassFramebuffer(const unsigned int width, const unsigned int height) : width(width), height(height) {}
-    virtual ~RenderPassFramebuffer() = default;
-
-    unsigned int getWidth() const {
-        return this->width;
-    }
-
-    unsigned int getHeight() const {
-        return this->height;
-    }
-
-    virtual void bind() const = 0;
-    virtual void clear() const = 0;
-
-    virtual const Ref<Texture2D>& getTexture() const = 0;
-    virtual const Ref<Texture2D>& getDepthTexture() const = 0;
-
-    virtual void copyDepthToBuffer(const Ref<RenderPassFramebuffer>& buffer) const = 0;
-
-protected:
-    unsigned int width;
-    unsigned int height;
-};
diff --git a/engine/src/rendering/framebuffer/ShadowCubeArrayFramebuffer.h b/engine/src/rendering/framebuffer/ShadowCubeArrayFramebuffer.h
index fbbd934..94f740c 100644
--- a/engine/src/rendering/framebuffer/ShadowCubeArrayFramebuffer.h
+++ b/engine/src/rendering/framebuffer/ShadowCubeArrayFramebuffer.h
@@ -18,7 +18,7 @@ class ShadowCubeArrayFramebuffer {
 
     virtual void bind(unsigned int layer, unsigned int face) const = 0;
 
-    const Ref<TextureCubeArray>& getShadowCubeArrayTexture() const {
+    const Ref<Texture>& getShadowCubeArrayTexture() const {
         return this->shadowCubeTexture;
     }
 
@@ -26,5 +26,5 @@ class ShadowCubeArrayFramebuffer {
 
 protected:
     unsigned int size;
-    Ref<TextureCubeArray> shadowCubeTexture;
+    Ref<Texture> shadowCubeTexture;
 };
diff --git a/engine/src/rendering/opengl/OpenGLCommands.cpp b/engine/src/rendering/opengl/OpenGLCommands.cpp
new file mode 100644
index 0000000..8ba9821
--- /dev/null
+++ b/engine/src/rendering/opengl/OpenGLCommands.cpp
@@ -0,0 +1,185 @@
+#include "pch/enginepch.h"
+#include "OpenGLCommands.h"
+
+#include "OpenGLFramebuffer.h"
+#include "OpenGLTexture.h"
+#include "OpenGLTypes.h"
+
+void OpenGLCommands::initializeTexture(const Ref<Texture>& texture) const {
+    const Ref<OpenGLTexture> t = std::static_pointer_cast<OpenGLTexture>(texture);
+    glGenTextures(1, &t->id);
+    glBindTexture(t->glTextureType, t->id);
+
+    if (texture->getSamples() <= 1) {
+        glTexParameteri(t->glTextureType, GL_TEXTURE_MIN_FILTER, OpenGLTypes::getFromTextureFilter(texture->getFilterMin()));
+        glTexParameteri(t->glTextureType, GL_TEXTURE_MAG_FILTER, OpenGLTypes::getFromTextureFilter(texture->getFilterMag()));
+        glTexParameteri(t->glTextureType, GL_TEXTURE_WRAP_S, OpenGLTypes::getFromTextureWrap(texture->getWrapU()));
+        glTexParameteri(t->glTextureType, GL_TEXTURE_WRAP_T, OpenGLTypes::getFromTextureWrap(texture->getWrapV()));
+        glTexParameteri(t->glTextureType, GL_TEXTURE_WRAP_R, OpenGLTypes::getFromTextureWrap(texture->getWrapW()));
+    }
+}
+
+void OpenGLCommands::createTextureStorage(const Ref<Texture>& texture, const Ref<uint8_t[]> data) const {
+    const Ref<OpenGLTexture> t = std::static_pointer_cast<OpenGLTexture>(texture);
+    bindTexture(texture);
+    switch (t->glTextureType) {
+        case GL_TEXTURE_2D:
+            glTexImage2D(GL_TEXTURE_2D, 0, t->glInternalFormat, static_cast<int>(t->getWidth()), static_cast<int>(t->getHeight()), 0, t->glFormat, t->dataType, data.get());
+            break;
+        case GL_TEXTURE_2D_MULTISAMPLE:
+            glTexImage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, static_cast<int>(t->getSamples()), t->glInternalFormat, static_cast<int>(t->getWidth()),
+                                    static_cast<int>(t->getHeight()), true);
+            break;
+        case GL_TEXTURE_2D_ARRAY:
+        case GL_TEXTURE_CUBE_MAP_ARRAY:
+            glTexImage3D(t->glTextureType, 0, t->glInternalFormat, static_cast<int>(t->getWidth()), static_cast<int>(t->getHeight()), static_cast<int>(t->getLayers()), 0,
+                         t->glFormat, t->dataType, data.get());
+            break;
+        case GL_TEXTURE_CUBE_MAP:
+            {
+                const size_t faceSize = static_cast<size_t>(t->getWidth()) * t->getHeight() * t->getInternalFormat().getSize();
+                for (int face = 0; face < 6; face++) {
+                    const uint8_t* const dataOffset = data == nullptr ? nullptr : data.get() + (face * faceSize);
+                    glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, 0, t->glInternalFormat, static_cast<int>(t->getWidth()), static_cast<int>(t->getHeight()), 0, t->glFormat,
+                                 t->dataType, dataOffset);
+                }
+                break;
+            }
+        default:
+            DE_ASSERT(false, "Unsupported texture type")
+    }
+
+    if (t->shouldGenerateMipmaps()) {
+        glGenerateMipmap(t->glTextureType);
+    }
+}
+
+void OpenGLCommands::bindTexture(const Ref<const Texture>& texture) const {
+    const Ref<const OpenGLTexture> t = std::static_pointer_cast<const OpenGLTexture>(texture);
+    glBindTexture(t->glTextureType, t->id);
+}
+
+void OpenGLCommands::bindTexture(const Ref<const Texture>& texture, const unsigned slot) const {
+    glBindTextureUnit(slot, std::static_pointer_cast<const OpenGLTexture>(texture)->id);
+}
+
+void OpenGLCommands::clearTexture(const Ref<const Texture>& texture, const Ref<uint8_t[]> color) const {
+    bindTexture(texture);
+    const Ref<const OpenGLTexture> t = std::static_pointer_cast<const OpenGLTexture>(texture);
+    glClearTexImage(t->id, 0, t->glFormat, t->dataType, color.get());
+}
+
+void OpenGLCommands::copyTextureData(const Ref<const Texture>& src, const unsigned level, void* destination) const {
+    if (src->getType() != TextureType::TEXTURE_CUBE) {
+        glGetTexImage(OpenGLTypes::getFromTextureType(src->getType(), src->getSamples()), static_cast<GLint>(level), OpenGLTypes::getFromTextureFormat(src->getFormat()),
+                      OpenGLTypes::getPixelTypeFromInternalFormat(src->getInternalFormat()), destination);
+        return;
+    }
+    // using level as the face index here, refactor if needed
+    glGetTexImage(GL_TEXTURE_CUBE_MAP_POSITIVE_X + level, 0, OpenGLTypes::getFromTextureFormat(src->getFormat()),
+                  OpenGLTypes::getPixelTypeFromInternalFormat(src->getInternalFormat()), destination);
+}
+
+void OpenGLCommands::initializeFramebuffer(const Ref<Framebuffer>& framebuffer) const {
+    const Ref<OpenGLFramebuffer> fb = std::static_pointer_cast<OpenGLFramebuffer>(framebuffer);
+    glGenFramebuffers(1, &fb->id);
+    glBindFramebuffer(GL_FRAMEBUFFER, fb->id);
+
+    std::vector<GLenum> drawBuffers;
+    for (unsigned int i = 0; i < fb->params.colorAttachments.size(); i++) {
+        const Ref<const OpenGLTexture> colorAttachment = std::static_pointer_cast<const OpenGLTexture>(fb->params.colorAttachments[i]);
+        const GLenum attachment = GL_COLOR_ATTACHMENT0 + i;
+        if (colorAttachment->getType().isArray()) {
+            glFramebufferTextureLayer(GL_FRAMEBUFFER, attachment, colorAttachment->id, 0, 0);
+        } else {
+            glFramebufferTexture2D(GL_FRAMEBUFFER, attachment, colorAttachment->glTextureType, colorAttachment->id, 0);
+        }
+        drawBuffers.push_back(attachment);
+    }
+
+    if (drawBuffers.empty()) {
+        glDrawBuffer(GL_NONE);
+    } else {
+        glDrawBuffers(static_cast<GLsizei>(drawBuffers.size()), drawBuffers.data());
+    }
+
+    if (fb->params.depthAttachment) {
+        const Ref<const OpenGLTexture> depthAttachment = std::static_pointer_cast<const OpenGLTexture>(fb->params.depthAttachment);
+        if (depthAttachment->getSamples() > 1) {
+            glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D_MULTISAMPLE, depthAttachment->id, 0);
+        } else {
+            glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, depthAttachment->glTextureType, depthAttachment->id, 0);
+        }
+    }
+
+    glBindFramebuffer(GL_FRAMEBUFFER, 0);
+}
+
+void OpenGLCommands::bindFramebuffer(const Ref<const Framebuffer>& framebuffer) const {
+    const Ref<const OpenGLFramebuffer> fb = std::static_pointer_cast<const OpenGLFramebuffer>(framebuffer);
+    glBindFramebuffer(GL_FRAMEBUFFER, fb->id);
+}
+
+void OpenGLCommands::clearFramebuffer(const Ref<const Framebuffer>& framebuffer) const {
+    bindFramebuffer(framebuffer);
+    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+}
+
+void OpenGLCommands::changeFramebufferFace(const Ref<const Framebuffer>& framebuffer, const unsigned int attachmentIndex, const unsigned int layer, const unsigned int face) const {
+    DE_ASSERT(static_cast<size_t>(attachmentIndex) < framebuffer->getColorAttachments().size(), "Attachment index out of bounds when changing framebuffer face")
+    bindFramebuffer(framebuffer);
+    const auto colorAttachment = std::static_pointer_cast<const OpenGLTexture>(framebuffer->getColorAttachments()[attachmentIndex]);
+    DE_ASSERT(colorAttachment->getType().isArray(), "Changing framebuffer face is only supported for cube map array textures")
+    glFramebufferTextureLayer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + attachmentIndex, colorAttachment->id, 0, static_cast<int>(layer * 6 + face));
+}
+
+int OpenGLCommands::readPixelInt(const Ref<const Framebuffer>& framebuffer, const unsigned int x, const unsigned int y, const unsigned int attachmentIndex) const {
+    DE_ASSERT(static_cast<size_t>(attachmentIndex) < framebuffer->getColorAttachments().size(), "Attachment index out of bounds when reading pixel from framebuffer")
+    bindFramebuffer(framebuffer);
+    const GLenum attachment = GL_COLOR_ATTACHMENT0 + attachmentIndex;
+    glReadBuffer(attachment);
+    const GLenum format = std::static_pointer_cast<const OpenGLTexture>(framebuffer->getColorAttachments()[attachmentIndex])->glFormat;
+    int pixelData = -1;
+    glReadPixels(static_cast<int>(x), static_cast<int>(framebuffer->getHeight() - y), 1, 1, format, GL_INT, &pixelData);
+    return pixelData;
+}
+
+void OpenGLCommands::copyColorData(const Ref<const Framebuffer>& src, const Ref<const Framebuffer>& dst, const unsigned int srcAttachmentIndex,
+                                   const unsigned int dstAttachmentIndex) const {
+    DE_ASSERT(static_cast<size_t>(srcAttachmentIndex) < src->getColorAttachments().size(), "Source attachment index out of bounds when copying color data between framebuffers")
+    DE_ASSERT(static_cast<size_t>(dstAttachmentIndex) < dst->getColorAttachments().size(),
+              "Destination attachment index out of bounds when copying color data between framebuffers")
+    DE_ASSERT(src->getWidth() == dst->getWidth() && src->getHeight() == dst->getHeight(),
+              "Source and destination framebuffers must have the same dimensions when copying color data between them")
+    const GLenum srcAttachment = GL_COLOR_ATTACHMENT0 + srcAttachmentIndex;
+    const GLenum dstAttachment = GL_COLOR_ATTACHMENT0 + dstAttachmentIndex;
+    glBindFramebuffer(GL_READ_FRAMEBUFFER, std::static_pointer_cast<const OpenGLFramebuffer>(src)->id);
+    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, std::static_pointer_cast<const OpenGLFramebuffer>(dst)->id);
+    glReadBuffer(srcAttachment);
+    glDrawBuffer(dstAttachment);
+    glBlitFramebuffer(0, 0, static_cast<int>(src->getWidth()), static_cast<int>(src->getHeight()), 0, 0, static_cast<int>(dst->getWidth()), static_cast<int>(dst->getHeight()),
+                      GL_COLOR_BUFFER_BIT, GL_NEAREST);
+    bindFramebuffer(src);
+}
+
+void OpenGLCommands::copyColorDataToScreen(const Ref<const Framebuffer>& src, unsigned int srcAttachmentIndex) const {
+    DE_ASSERT(static_cast<size_t>(srcAttachmentIndex) < src->getColorAttachments().size(), "Source attachment index out of bounds when copying color data to screen")
+    const GLenum srcAttachment = GL_COLOR_ATTACHMENT0 + srcAttachmentIndex;
+    glBindFramebuffer(GL_READ_FRAMEBUFFER, std::static_pointer_cast<const OpenGLFramebuffer>(src)->id);
+    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
+    glReadBuffer(srcAttachment);
+    glBlitFramebuffer(0, 0, static_cast<int>(src->getWidth()), static_cast<int>(src->getHeight()), 0, 0, static_cast<int>(src->getWidth()), static_cast<int>(src->getHeight()),
+                      GL_COLOR_BUFFER_BIT, GL_NEAREST);
+    bindFramebuffer(src);
+}
+
+void OpenGLCommands::copyDepthData(const Ref<const Framebuffer>& src, const Ref<const Framebuffer>& dst) const {
+    DE_ASSERT(src->getWidth() == dst->getWidth() && src->getHeight() == dst->getHeight(),
+              "Source and destination framebuffers must have the same dimensions when copying depth data between them")
+    glBindFramebuffer(GL_READ_FRAMEBUFFER, std::static_pointer_cast<const OpenGLFramebuffer>(src)->id);
+    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, std::static_pointer_cast<const OpenGLFramebuffer>(dst)->id);
+    glBlitFramebuffer(0, 0, static_cast<int>(src->getWidth()), static_cast<int>(src->getHeight()), 0, 0, static_cast<int>(dst->getWidth()), static_cast<int>(dst->getHeight()),
+                      GL_DEPTH_BUFFER_BIT, GL_NEAREST);
+    bindFramebuffer(src);
+}
diff --git a/engine/src/rendering/opengl/OpenGLCommands.h b/engine/src/rendering/opengl/OpenGLCommands.h
new file mode 100644
index 0000000..db20378
--- /dev/null
+++ b/engine/src/rendering/opengl/OpenGLCommands.h
@@ -0,0 +1,21 @@
+#pragma once
+#include "rendering/RenderCommands.h"
+
+class OpenGLCommands : public RenderCommands {
+public:
+    void initializeTexture(const Ref<Texture>& texture) const override;
+    void createTextureStorage(const Ref<Texture>& texture, Ref<uint8_t[]> data) const override;
+    void bindTexture(const Ref<const Texture>& texture) const override;
+    void bindTexture(const Ref<const Texture>& texture, unsigned slot) const override;
+    void clearTexture(const Ref<const Texture>& texture, Ref<uint8_t[]> color) const override;
+    void copyTextureData(const Ref<const Texture>& src, unsigned level, void* destination) const override;
+
+    void initializeFramebuffer(const Ref<Framebuffer>& framebuffer) const override;
+    void bindFramebuffer(const Ref<const Framebuffer>& framebuffer) const override;
+    void clearFramebuffer(const Ref<const Framebuffer>& framebuffer) const override;
+    void changeFramebufferFace(const Ref<const Framebuffer>& framebuffer, unsigned int attachmentIndex, unsigned int layer, unsigned int face) const override;
+    int readPixelInt(const Ref<const Framebuffer>& framebuffer, unsigned int x, unsigned int y, unsigned int attachmentIndex) const override;
+    void copyColorData(const Ref<const Framebuffer>& src, const Ref<const Framebuffer>& dst, unsigned int srcAttachmentIndex, unsigned int dstAttachmentIndex) const override;
+    void copyColorDataToScreen(const Ref<const Framebuffer>& src, unsigned int srcAttachmentIndex) const override;
+    void copyDepthData(const Ref<const Framebuffer>& src, const Ref<const Framebuffer>& dst) const override;
+};
diff --git a/engine/src/rendering/opengl/OpenGLDataType.h b/engine/src/rendering/opengl/OpenGLDataType.h
deleted file mode 100644
index ef8c1f6..0000000
--- a/engine/src/rendering/opengl/OpenGLDataType.h
+++ /dev/null
@@ -1,35 +0,0 @@
-#pragma once
-#include "rendering/BufferLayout.h"
-#include "glad/gl.h"
-
-static GLenum getOpenGLTypeFromDatatype(DataType type) {
-    switch (type) {
-        case DataType::BOOL:
-            return GL_BOOL;
-        case DataType::INT:
-        case DataType::INT2:
-        case DataType::INT3:
-        case DataType::INT4:
-            return GL_INT;
-        case DataType::FLOAT:
-        case DataType::FLOAT2:
-        case DataType::FLOAT3:
-        case DataType::FLOAT4:
-            return GL_FLOAT;
-    }
-    DE_ERROR("Couldn't find corresponding OpenGL type for DataType {0}", static_cast<int>(type));
-    return 0;
-}
-
-static GLenum getOpenGLTypeFromTextureFormat(TextureFormat format) {
-    switch (format) {
-        case TextureFormat::RGB:
-            return GL_RGB;
-        case TextureFormat::RGBA:
-            return GL_RGBA;
-        case TextureFormat::BGRA:
-            return GL_BGRA;
-    }
-    DE_ERROR("Couldn't find corresponding OpenGL type for TextureFormat {0}", static_cast<int>(format));
-    return 0;
-}
diff --git a/engine/src/rendering/opengl/OpenGLFramebuffer.h b/engine/src/rendering/opengl/OpenGLFramebuffer.h
new file mode 100644
index 0000000..560ebe2
--- /dev/null
+++ b/engine/src/rendering/opengl/OpenGLFramebuffer.h
@@ -0,0 +1,17 @@
+#pragma once
+#include <glad/gl.h>
+
+class OpenGLFramebuffer : public Framebuffer {
+public:
+    OpenGLFramebuffer(const FramebufferParams& params, const Ref<Renderer>& renderer) : Framebuffer(params, renderer) {}
+    OpenGLFramebuffer(const GLuint id, const FramebufferParams& params, const Ref<Renderer>& renderer) : Framebuffer(params, renderer), id(id) {}
+
+    GLuint getId() const {
+        return this->id;
+    }
+
+protected:
+    friend class OpenGLCommands;
+
+    GLuint id = 0;
+};
diff --git a/engine/src/rendering/opengl/OpenGLPipeline.cpp b/engine/src/rendering/opengl/OpenGLPipeline.cpp
new file mode 100644
index 0000000..726fde6
--- /dev/null
+++ b/engine/src/rendering/opengl/OpenGLPipeline.cpp
@@ -0,0 +1,45 @@
+#include "pch/enginepch.h"
+#include "OpenGLPipeline.h"
+
+#include "OpenGLTypes.h"
+
+#include <glad/gl.h>
+
+void OpenGLPipeline::bind() const {
+    if (params.blending.enabled) {
+        glEnable(GL_BLEND);
+        glBlendFuncSeparate(OpenGLTypes::getFromBlendFactor(params.blending.color.srcFactor), OpenGLTypes::getFromBlendFactor(params.blending.color.dstFactor),
+                            OpenGLTypes::getFromBlendFactor(params.blending.alpha.srcFactor), OpenGLTypes::getFromBlendFactor(params.blending.alpha.dstFactor));
+        glBlendEquationSeparate(OpenGLTypes::getFromBlendOp(params.blending.color.blendOp), OpenGLTypes::getFromBlendOp(params.blending.alpha.blendOp));
+    } else {
+        glDisable(GL_BLEND);
+    }
+
+    if (params.depth.test) {
+        glEnable(GL_DEPTH_TEST);
+        glDepthFunc(OpenGLTypes::getFromCompareOp(params.depth.compareOp));
+    } else {
+        glDisable(GL_DEPTH_TEST);
+    }
+    glDepthMask(params.depth.write ? GL_TRUE : GL_FALSE);
+
+    if (params.cullMode == PipelineCullMode::NONE) {
+        glDisable(GL_CULL_FACE);
+    } else {
+        glEnable(GL_CULL_FACE);
+        switch (params.cullMode) {
+            case PipelineCullMode::FRONT:
+                glCullFace(GL_FRONT);
+                break;
+            case PipelineCullMode::BACK:
+                glCullFace(GL_BACK);
+                break;
+            case PipelineCullMode::FRONT_AND_BACK:
+                glCullFace(GL_FRONT_AND_BACK);
+                break;
+            case PipelineCullMode::NONE:
+                DE_ASSERT(false, "Unreachable")
+                break;
+        }
+    }
+}
diff --git a/engine/src/rendering/opengl/OpenGLPipeline.h b/engine/src/rendering/opengl/OpenGLPipeline.h
new file mode 100644
index 0000000..85f0a85
--- /dev/null
+++ b/engine/src/rendering/opengl/OpenGLPipeline.h
@@ -0,0 +1,7 @@
+#pragma once
+#include "rendering/Pipeline.h"
+
+class OpenGLPipeline : public Pipeline {
+public:
+    void bind() const override;
+};
diff --git a/engine/src/rendering/opengl/OpenGLRenderer.cpp b/engine/src/rendering/opengl/OpenGLRenderer.cpp
index 093d3d4..9c997d5 100644
--- a/engine/src/rendering/opengl/OpenGLRenderer.cpp
+++ b/engine/src/rendering/opengl/OpenGLRenderer.cpp
@@ -3,47 +3,28 @@
 
 #include "DebugGroup.h"
 #include "OpenGLBuffer.h"
-#include "OpenGLDataType.h"
+#include "OpenGLFramebuffer.h"
+#include "OpenGLPipeline.h"
+#include "OpenGLTypes.h"
 #include "OpenGLShader.h"
-#include "OpenGLTexture2D.h"
+#include "OpenGLTexture.h"
 #include "OpenGLTextureCube.h"
 #include "OpenGLVertexArray.h"
-#include "framebuffer/OpenGLDataFramebuffer.h"
-#include "framebuffer/OpenGLDepthFramebuffer.h"
-#include "framebuffer/OpenGLRenderFramebuffer.h"
-#include "framebuffer/OpenGLRenderPassFramebuffer.h"
 #include "framebuffer/OpenGLShadowCubeArrayFramebuffer.h"
 
 #include <glad/gl.h>
 #include <glm/glm.hpp>
 
-void OpenGLRenderer::init(const uint32_t width, const uint32_t height) {
+void OpenGLRenderer::init(const unsigned int width, const unsigned int height) {
+    Renderer::init(width, height);
     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
     glEnable(GL_BLEND);
     glEnable(GL_DEPTH_TEST);
     glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS);
     glFrontFace(GL_CW);
-    this->setFramebufferDimensions(width, height);
-    this->setViewport(0, 0, width, height);
-    unsigned char white[4] = {255, 255, 255, 255};
-    this->whitePixelTexture = std::make_shared<OpenGLTexture2D>(1, 1, 1, 1, GL_RGBA, white);
-    this->defaultOcclusionRoughnessMetallicTexture = std::make_shared<OpenGLTexture2D>(3, 1, 1, 1, GL_RGB, std::array<unsigned char, 3>{255, 255, 0}.data());
-    this->shadowDepthFramebuffer = std::make_shared<OpenGLDepthFramebuffer>(2048, 2048);
-    this->shadowCubeArrayFramebuffer = std::make_shared<OpenGLShadowCubeArrayFramebuffer>(1024, 0);
+    this->shadowCubeArrayFramebuffer = std::make_shared<OpenGLShadowCubeArrayFramebuffer>(shared_from_this(), 1024);
 }
 
-void OpenGLRenderer::setFramebufferDimensions(unsigned int width, unsigned int height) {
-    this->framebuffer = std::make_shared<OpenGLRenderFramebuffer>(width, height);
-    this->dataFramebuffer = std::make_shared<OpenGLDataFramebuffer>(width, height);
-    this->previousPassFramebuffer = std::make_shared<OpenGLRenderPassFramebuffer>(width, height);
-    this->currentPassFramebuffer = std::make_shared<OpenGLRenderPassFramebuffer>(width, height);
-}
-
-Ref<RenderFramebuffer> OpenGLRenderer::getFramebuffer() const {
-    return this->framebuffer;
-}
-
-
 Ref<VertexArray> OpenGLRenderer::createVertexArray(const Ref<VertexBuffer>& vertexBuffer, const Ref<IndexBuffer>& indexBuffer) const {
     return std::make_shared<OpenGLVertexArray>(vertexBuffer, indexBuffer);
 }
@@ -60,29 +41,25 @@ Ref<Shader> OpenGLRenderer::createShader(const std::string& vertexPath, const st
     return std::make_shared<OpenGLShader>(vertexPath, fragmentPath);
 }
 
-Ref<Texture2D> OpenGLRenderer::createTexture2D(const std::string& path) const {
-    return std::make_shared<OpenGLTexture2D>(path);
-}
-
-Ref<Texture2D> OpenGLRenderer::createTexture2D(const unsigned int channels, const unsigned int width, const unsigned int height, const unsigned int bytesPerPixel,
-                                               const void* data) const {
-    return std::make_shared<OpenGLTexture2D>(channels, width, height, bytesPerPixel, data);
+void OpenGLRenderer::destroyTexture(const Texture& texture) {
+    const GLuint id = static_cast<const OpenGLTexture&>(texture).getId(); // NOLINT(cppcoreguidelines-pro-type-static-cast-downcast)
+    pushCommand([id](const RenderCommands*) {
+        glDeleteTextures(1, &id);
+    });
 }
 
-Ref<Texture2D> OpenGLRenderer::createTexture2D(const unsigned int channels, const unsigned int width, const unsigned int height, const unsigned int bytesPerPixel,
-                                               const TextureFormat format, const void* data) const {
-    GLenum glFormat = getOpenGLTypeFromTextureFormat(format);
-    return std::make_shared<OpenGLTexture2D>(channels, width, height, bytesPerPixel, glFormat, data);
+void OpenGLRenderer::destroyFramebuffer(const Framebuffer& texture) {
+    const GLuint id = static_cast<const OpenGLFramebuffer&>(texture).getId(); // NOLINT(cppcoreguidelines-pro-type-static-cast-downcast)
+    pushCommand([id](const RenderCommands*) {
+        glDeleteFramebuffers(1, &id);
+    });
 }
 
-Ref<Texture2D> OpenGLRenderer::createBRDFLUT(const Ref<Shader>& shader, const uint32_t size) const {
+Ref<Texture> OpenGLRenderer::createBRDFLUT(const Ref<Shader>& shader, const uint32_t size) {
     DebugGroup group("OpenGLRenderer::createBRDFLUT");
-    unsigned int textureId;
-    glGenTextures(1, &textureId);
-    glBindTexture(GL_TEXTURE_2D, textureId);
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_RG16F, size, size, 0, GL_RG, GL_FLOAT, nullptr);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    const Ref<OpenGLTexture> texture = std::static_pointer_cast<OpenGLTexture>(
+        Texture::builder().size(size).format(TextureFormat::RG).internalFormat(TextureInternalFormat::RG16_FLOAT).build(this->shared_from_this()));
+    glBindTexture(GL_TEXTURE_2D, texture->getId());
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 
@@ -93,7 +70,7 @@ Ref<Texture2D> OpenGLRenderer::createBRDFLUT(const Ref<Shader>& shader, const ui
     glBindFramebuffer(GL_FRAMEBUFFER, captureFramebuffer);
     glBindRenderbuffer(GL_RENDERBUFFER, captureRenderbuffer);
     glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT24, size, size);
-    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, textureId, 0);
+    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture->getId(), 0);
     glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, captureRenderbuffer);
 
     int previousViewport[4];
@@ -126,18 +103,14 @@ Ref<Texture2D> OpenGLRenderer::createBRDFLUT(const Ref<Shader>& shader, const ui
     glViewport(previousViewport[0], previousViewport[1], previousViewport[2], previousViewport[3]);
     glDeleteFramebuffers(1, &captureFramebuffer);
     glDeleteRenderbuffers(1, &captureRenderbuffer);
-    return std::make_shared<OpenGLTexture2D>(textureId, size, size, GL_RG16F, GL_RG, GL_FLOAT);
+    return texture;
 }
 
-Ref<TextureCube> OpenGLRenderer::createTextureCube(const std::array<std::string, 6>& paths) const {
-    return std::make_shared<OpenGLTextureCube>(paths);
-}
-
-Ref<TextureCube> OpenGLRenderer::createTextureCubeFromHDR(const Ref<Texture2D>& hdrTexture, const Ref<Shader>& convertShader, const uint32_t size) {
+Ref<Texture> OpenGLRenderer::createTextureCubeFromHDR(const Ref<Texture>& hdrTexture, const Ref<Shader>& convertShader, const uint32_t size) {
     return OpenGLTextureCube::createFromHDR(shared_from_this(), hdrTexture, convertShader, size);
 }
 
-Ref<TextureCube> OpenGLRenderer::createPrefilteredCubemap(const Ref<TextureCube>& textureCube, const Ref<Shader>& convertShader, const uint32_t size) {
+Ref<Texture> OpenGLRenderer::createPrefilteredCubemap(const Ref<Texture>& textureCube, const Ref<Shader>& convertShader, const uint32_t size) {
     return OpenGLTextureCube::createPrefilteredCubemap(shared_from_this(), textureCube, convertShader, size);
 }
 
@@ -151,9 +124,14 @@ void OpenGLRenderer::beginFrame() {
     this->pointLights.clear();
     this->framebuffer->bind();
     this->clear(); // make sure to clean the framebuffer
-    glEnable(GL_CULL_FACE); // disabled by the skybox
-    glDepthFunc(GL_LESS); // changed by the skybox
-    glStencilMask(0x00);
+    // TODO: this should be handled in a render loop based on commands
+    auto pipeline = OpenGLPipeline();
+    pipeline.params.blending.enabled = true;
+    pipeline.params.blending.color.srcFactor = PipelineBlendFactor::SRC_ALPHA;
+    pipeline.params.blending.color.dstFactor = PipelineBlendFactor::ONE_MINUS_SRC_ALPHA;
+    pipeline.params.blending.alpha.srcFactor = PipelineBlendFactor::SRC_ALPHA;
+    pipeline.params.blending.alpha.dstFactor = PipelineBlendFactor::ONE_MINUS_SRC_ALPHA;
+    pipeline.bind();
 }
 
 void OpenGLRenderer::beginDirectionalShadows() const {
@@ -175,7 +153,7 @@ void OpenGLRenderer::beginPointLightShadow(const PointLight& light, const int li
     glViewport(0, 0, this->shadowCubeArrayFramebuffer->getSize(), this->shadowCubeArrayFramebuffer->getSize());
     glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-    const glm::mat4 faceView = TextureCube::shadowViewMatrices[faceIndex];
+    const glm::mat4 faceView = TextureCubeUtils::shadowViewMatrices[faceIndex];
     const glm::mat4 projection = glm::perspective(glm::radians(90.0f), 1.0f, 0.1f, light.farPlane);
     const glm::mat4 viewProjection = projection * glm::translate(faceView, -light.position);
     this->shadowCubeArrayShader->uploadUniformMat4("uViewProjection", viewProjection);
@@ -194,12 +172,14 @@ void OpenGLRenderer::endFrame() const {
     glBindVertexArray(0);
 }
 
-void OpenGLRenderer::clear() const {
+void OpenGLRenderer::clear() {
     DebugGroup group("OpenGLRenderer::clear");
-    this->framebuffer->clear();
-    this->dataFramebuffer->clear();
-    this->previousPassFramebuffer->clear();
-    this->currentPassFramebuffer->clear();
+    clearFramebuffer(framebuffer);
+    auto minusOne = std::make_unique<uint8_t[]>(1);
+    minusOne[0] = -1;
+    clearTexture(framebuffer->getColorAttachments()[1], std::move(minusOne)); // mouse picking attachment
+    clearFramebuffer(previousPassFramebuffer);
+    clearFramebuffer(currentPassFramebuffer);
     glBindTexture(GL_TEXTURE_CUBE_MAP, 0);
     glBindTexture(GL_TEXTURE_2D, 0);
     glBindVertexArray(0);
@@ -208,10 +188,6 @@ void OpenGLRenderer::clear() const {
     glUseProgram(0);
 }
 
-void OpenGLRenderer::drawToMainFramebuffer() const {
-    this->framebuffer->copyColorToBuffer(0);
-}
-
 
 void OpenGLRenderer::draw(const unsigned int entityId, const Ref<VertexArray>& vertexArray, const glm::mat4& transform, const Ref<Shader>& shader) const {
     this->draw(entityId, vertexArray, transform, shader, Material(this->whitePixelTexture));
@@ -238,7 +214,7 @@ void OpenGLRenderer::draw(const unsigned int entityId, const Ref<VertexArray>& v
     shader->uploadUniformInt("uPrefilteredEnvMap", textureSlot++);
     this->brdfLUT->bind(textureSlot);
     shader->uploadUniformInt("uBRDFLUT", textureSlot++);
-    this->shadowDepthFramebuffer->getDepthTexture()->bind(textureSlot);
+    this->shadowDepthFramebuffer->getDepthAttachment()->bind(textureSlot);
     shader->uploadUniformInt("uDirectionalShadowMap", textureSlot++);
     this->shadowCubeArrayFramebuffer->getShadowCubeArrayTexture()->bind(textureSlot);
     shader->uploadUniformInt("uPointShadowMaps", textureSlot);
@@ -316,9 +292,9 @@ void OpenGLRenderer::drawJumpFloodingPass(const Ref<VertexArray>& vertexArray, c
     this->swapPassFramebuffers();
     this->currentPassFramebuffer->bind();
     shader->bind();
-    this->previousPassFramebuffer->getDepthTexture()->bind(0);
+    this->previousPassFramebuffer->getDepthAttachment()->bind(0);
     shader->uploadUniformInt("uPassDepthTexture", 0);
-    this->previousPassFramebuffer->getTexture()->bind(1);
+    this->previousPassFramebuffer->getColorAttachments()[0]->bind(1);
     shader->uploadUniformInt("uPassTexture", 1);
     shader->uploadUniformInt("uOffset", offset);
     shader->uploadUniformVec2Int("uDirection", vertical ? glm::ivec2(0, 1) : glm::ivec2(1, 0));
@@ -333,11 +309,11 @@ void OpenGLRenderer::drawEditorOverlays(const Ref<VertexArray>& vertexArray, con
     DebugGroup group("OpenGLRenderer::drawEditorOverlays");
     this->framebuffer->bind();
     shader->bind();
-    this->framebuffer->getDepthTexture()->bind(0);
+    this->framebuffer->getDepthAttachment()->bind(0);
     shader->uploadUniformInt("uMainDepthTexture", 0);
-    this->currentPassFramebuffer->getDepthTexture()->bind(1);
+    this->currentPassFramebuffer->getDepthAttachment()->bind(1);
     shader->uploadUniformInt("uPassDepthTexture", 1);
-    this->currentPassFramebuffer->getTexture()->bind(2);
+    this->currentPassFramebuffer->getColorAttachments()[0]->bind(2);
     shader->uploadUniformInt("uPassTexture", 2);
     shader->uploadUniformVec4("uOutlineColor", outlineColor);
     shader->uploadUniformFloat("uOutlineWidth", outlineWidth);
@@ -359,3 +335,11 @@ void OpenGLRenderer::drawUI(const Ref<VertexArray>& vertexArray, const Ref<Shade
     glDrawElements(GL_TRIANGLES, static_cast<int>(vertexArray->getIndexBuffer()->getCount()), GL_UNSIGNED_INT, nullptr);
     glEnable(GL_DEPTH_TEST);
 }
+
+Ref<Texture> OpenGLRenderer::newTexture(const Texture::TextureParams& params) {
+    return std::make_shared<OpenGLTexture>(params, this->shared_from_this());
+}
+
+Ref<Framebuffer> OpenGLRenderer::newFramebuffer(const Framebuffer::FramebufferParams& params) {
+    return std::make_shared<OpenGLFramebuffer>(params, this->shared_from_this());
+}
diff --git a/engine/src/rendering/opengl/OpenGLRenderer.h b/engine/src/rendering/opengl/OpenGLRenderer.h
index 1c946a0..d04a6ac 100644
--- a/engine/src/rendering/opengl/OpenGLRenderer.h
+++ b/engine/src/rendering/opengl/OpenGLRenderer.h
@@ -1,29 +1,25 @@
 #pragma once
-#include "OpenGLTexture2D.h"
-#include "framebuffer/OpenGLRenderFramebuffer.h"
+#include "OpenGLCommands.h"
 #include "rendering/Renderer.h"
 #include "rendering/Shader.h"
 
-class OpenGLRenderer : public Renderer, public std::enable_shared_from_this<OpenGLRenderer> {
+class OpenGLRenderer : public Renderer {
 public:
-    OpenGLRenderer() : Renderer(RenderAPI::OPENGL) {}
+    explicit OpenGLRenderer() : Renderer(RenderAPI::OPENGL, std::make_shared<OpenGLCommands>()) {}
 
-    void init(uint32_t width, uint32_t height) override;
-    void setFramebufferDimensions(unsigned int width, unsigned int height) override;
-    Ref<RenderFramebuffer> getFramebuffer() const override;
+    void init(unsigned int width, unsigned int height) override;
 
     Ref<VertexArray> createVertexArray(const Ref<VertexBuffer>& vertexBuffer, const Ref<IndexBuffer>& indexBuffer) const override;
-    Ref<VertexBuffer> createVertexBuffer(const float* vertices, uint32_t size) const override;
-    Ref<IndexBuffer> createIndexBuffer(const uint32_t* indexes, uint32_t count) const override;
+    Ref<VertexBuffer> createVertexBuffer(const float* vertices, unsigned int size) const override;
+    Ref<IndexBuffer> createIndexBuffer(const unsigned int* indexes, unsigned int count) const override;
     Ref<Shader> createShader(const std::string& vertexPath, const std::string& fragmentPath) const override;
-    Ref<Texture2D> createTexture2D(const std::string& path) const override;
-    Ref<Texture2D> createTexture2D(unsigned int channels, unsigned int width, unsigned int height, unsigned int bytesPerPixel, const void* data) const override;
-    Ref<Texture2D> createTexture2D(unsigned int channels, unsigned int width, unsigned int height, unsigned int bytesPerPixel, TextureFormat format,
-                                   const void* data) const override;
-    Ref<Texture2D> createBRDFLUT(const Ref<Shader>& shader, uint32_t size) const override;
-    Ref<TextureCube> createTextureCube(const std::array<std::string, 6>& paths) const override;
-    Ref<TextureCube> createTextureCubeFromHDR(const Ref<Texture2D>& hdrTexture, const Ref<Shader>& convertShader, uint32_t size) override;
-    Ref<TextureCube> createPrefilteredCubemap(const Ref<TextureCube>& textureCube, const Ref<Shader>& convertShader, uint32_t size) override;
+
+    void destroyTexture(const Texture& texture) override;
+    void destroyFramebuffer(const Framebuffer& texture) override;
+
+    Ref<Texture> createBRDFLUT(const Ref<Shader>& shader, unsigned int size) override;
+    Ref<Texture> createTextureCubeFromHDR(const Ref<Texture>& hdrTexture, const Ref<Shader>& convertShader, unsigned int size) override;
+    Ref<Texture> createPrefilteredCubemap(const Ref<Texture>& textureCube, const Ref<Shader>& convertShader, unsigned int size) override;
 
     void beginFrame() override;
     void beginDirectionalShadows() const override;
@@ -31,8 +27,7 @@ class OpenGLRenderer : public Renderer, public std::enable_shared_from_this<Open
     void beginPointLightShadow(const PointLight& light, int lightIndex, int faceIndex) const override;
     void endShadows() const override;
     void endFrame() const override;
-    void clear() const override;
-    void drawToMainFramebuffer() const override;
+    void clear() override;
 
     void draw(unsigned int entityId, const Ref<VertexArray>& vertexArray, const glm::mat4& transform, const Ref<Shader>& shader) const override;
     void draw(unsigned int entityId, const Ref<VertexArray>& vertexArray, const glm::mat4& transform, const Ref<Shader>& shader, const Material& material) const override;
@@ -45,7 +40,6 @@ class OpenGLRenderer : public Renderer, public std::enable_shared_from_this<Open
     void drawUI(const Ref<VertexArray>& vertexArray, const Ref<Shader>& shader, const Material& material) const override;
 
 private:
-    Ref<OpenGLRenderFramebuffer> framebuffer;
-    Ref<OpenGLTexture2D> whitePixelTexture;
-    Ref<OpenGLTexture2D> defaultOcclusionRoughnessMetallicTexture;
+    Ref<Texture> newTexture(const Texture::TextureParams& params) override;
+    Ref<Framebuffer> newFramebuffer(const Framebuffer::FramebufferParams& params) override;
 };
diff --git a/engine/src/rendering/opengl/OpenGLTexture.cpp b/engine/src/rendering/opengl/OpenGLTexture.cpp
new file mode 100644
index 0000000..0f31ab3
--- /dev/null
+++ b/engine/src/rendering/opengl/OpenGLTexture.cpp
@@ -0,0 +1,45 @@
+#include "pch/enginepch.h"
+#include "OpenGLTexture.h"
+
+#include "OpenGLRenderer.h"
+#include "OpenGLTypes.h"
+
+OpenGLTexture::OpenGLTexture(const TextureParams& params, const Ref<Renderer>& renderer) : Texture(params, renderer) {
+    glFormat = OpenGLTypes::getFromTextureFormat(params.format);
+    glInternalFormat = OpenGLTypes::getFromTextureInternalFormat(params.internalFormat);
+    glTextureType = OpenGLTypes::getFromTextureType(params.type, params.samples);
+    dataType = OpenGLTypes::getPixelTypeFromInternalFormat(params.internalFormat);
+}
+
+OpenGLTexture::OpenGLTexture(const GLuint id, const TextureParams& params, const Ref<Renderer>& renderer) : OpenGLTexture(params, renderer) {
+    this->id = id;
+}
+
+void OpenGLTexture::setRawData(const void* data, const unsigned int size) {
+    DE_ASSERT(params.width * params.height * params.internalFormat.getSize() >= size, "Buffer size is too large: {0}", size)
+    DE_ASSERT(params.type == TextureType::TEXTURE_2D, "setRawData is only supported for 2D textures")
+
+    if (!pbo) {
+        this->initializePBO();
+    }
+
+    glBindBuffer(GL_PIXEL_UNPACK_BUFFER, pbo);
+    glBufferData(GL_PIXEL_UNPACK_BUFFER, size, nullptr, GL_STREAM_DRAW);
+    // map the buffer to get a pointer to its memory
+    if (void* ptr = glMapBuffer(GL_PIXEL_UNPACK_BUFFER, GL_WRITE_ONLY)) {
+        std::memcpy(ptr, data, size);
+        glUnmapBuffer(GL_PIXEL_UNPACK_BUFFER);
+    }
+    glBindTexture(GL_TEXTURE_2D, this->id);
+    // update the texture from the PBO. This will be asynchronous until the texture is used
+    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, static_cast<int>(params.width), static_cast<int>(params.height), glFormat, dataType, nullptr);
+    glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
+}
+
+void OpenGLTexture::initializePBO() {
+    glGenBuffers(1, &pbo);
+    const unsigned int size = params.width * params.height * 4;
+    glBindBuffer(GL_PIXEL_UNPACK_BUFFER, pbo);
+    glBufferData(GL_PIXEL_UNPACK_BUFFER, size, nullptr, GL_STREAM_DRAW);
+    glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
+}
diff --git a/engine/src/rendering/opengl/OpenGLTexture.h b/engine/src/rendering/opengl/OpenGLTexture.h
new file mode 100644
index 0000000..64225ce
--- /dev/null
+++ b/engine/src/rendering/opengl/OpenGLTexture.h
@@ -0,0 +1,28 @@
+#pragma once
+#include "rendering/Texture.h"
+
+#include <glad/gl.h>
+
+class OpenGLTexture : public Texture {
+public:
+    OpenGLTexture(const TextureParams& params, const Ref<Renderer>& renderer);
+    OpenGLTexture(GLuint id, const TextureParams& params, const Ref<Renderer>& renderer);
+
+    void setRawData(const void* data, unsigned int size) override;
+
+    GLuint getId() const {
+        return this->id;
+    }
+
+protected:
+    friend class OpenGLCommands;
+
+    void initializePBO();
+
+    GLuint id = 0;
+    GLenum glFormat;
+    GLint glInternalFormat;
+    GLenum glTextureType;
+    GLenum dataType;
+    GLuint pbo = 0;
+};
diff --git a/engine/src/rendering/opengl/OpenGLTexture2D.cpp b/engine/src/rendering/opengl/OpenGLTexture2D.cpp
deleted file mode 100644
index 0af7c8a..0000000
--- a/engine/src/rendering/opengl/OpenGLTexture2D.cpp
+++ /dev/null
@@ -1,114 +0,0 @@
-#include "pch/enginepch.h"
-#include "OpenGLTexture2D.h"
-
-#include <glad/gl.h>
-#include <stb_image.h>
-
-OpenGLTexture2D::OpenGLTexture2D(const std::string& path) : Texture2D(0, 0), path(path) {
-    const bool isHDR = path.ends_with(".hdr");
-    int width;
-    int height;
-    int channels;
-
-    stbi_set_flip_vertically_on_load(true);
-    void* texture;
-    if (isHDR) {
-        texture = stbi_loadf(path.c_str(), &width, &height, &channels, 0);
-    } else {
-        texture = stbi_load(path.c_str(), &width, &height, &channels, 0);
-    }
-
-    if (!texture) {
-        const char* error = stbi_failure_reason();
-        DE_ERROR("Failed to read texture file {0} - {1}", path, error);
-    }
-
-    this->createTextureWithData(channels, width, height, isHDR, texture);
-    stbi_image_free(texture);
-}
-
-OpenGLTexture2D::OpenGLTexture2D(const unsigned int channels, const unsigned int width, const unsigned int height, const unsigned int bytesPerPixel, const int format,
-                                 const void* data) : Texture2D(width, height) {
-    this->createTextureWithData(channels, width, height, bytesPerPixel == sizeof(float) * channels, format, data);
-}
-
-OpenGLTexture2D::OpenGLTexture2D(const unsigned int channels, const unsigned int width, const unsigned int height, const unsigned int bytesPerPixel, const void* data) :
-    Texture2D(width, height) {
-    this->createTextureWithData(channels, width, height, bytesPerPixel == sizeof(float) * channels, data);
-}
-
-OpenGLTexture2D::OpenGLTexture2D(const unsigned int id, const unsigned int width, const unsigned int height, const int internalFormat, const int format, const int type) :
-    Texture2D(width, height), id(id), internalFormat(internalFormat), format(format), type(type) {}
-
-OpenGLTexture2D::~OpenGLTexture2D() {
-    glDeleteTextures(1, &this->id);
-}
-
-
-void OpenGLTexture2D::bind(const uint32_t slot) const {
-#ifdef OPENGL_4_6
-    glBindTextureUnit(slot, this->id);
-#else
-    glActiveTexture(GL_TEXTURE0 + slot);
-    glBindTexture(GL_TEXTURE_2D, this->id);
-#endif
-}
-
-void OpenGLTexture2D::setRawData(const void* data, const unsigned int size) {
-    DE_ASSERT(this->width * this->height * 4 >= size, "Buffer size is too large: {0}", size)
-    if (!this->pbo) {
-        this->initializePBO();
-    }
-
-    glBindBuffer(GL_PIXEL_UNPACK_BUFFER, this->pbo);
-    glBufferData(GL_PIXEL_UNPACK_BUFFER, size, nullptr, GL_STREAM_DRAW);
-    // map the buffer to get a pointer to its memory
-    if (void* ptr = glMapBuffer(GL_PIXEL_UNPACK_BUFFER, GL_WRITE_ONLY)) {
-        std::memcpy(ptr, data, size);
-        glUnmapBuffer(GL_PIXEL_UNPACK_BUFFER);
-    }
-    glBindTexture(GL_TEXTURE_2D, this->id);
-    // update the texture from the PBO. This will be asynchronous until the texture is used
-    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, this->width, this->height, this->format, this->type, nullptr);
-    glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
-}
-
-void OpenGLTexture2D::resize(const unsigned int width, const unsigned int height) {
-    this->width = width;
-    this->height = height;
-
-    glBindTexture(GL_TEXTURE_2D, this->id);
-    glTexImage2D(GL_TEXTURE_2D, 0, this->internalFormat, width, height, 0, this->format, this->type, nullptr);
-}
-
-void OpenGLTexture2D::createTextureWithData(const unsigned int channels, const unsigned int width, const unsigned int height, const bool isHDR, const void* data) {
-    const int format = !isHDR && channels > 3 ? GL_RGBA : GL_RGB;
-    this->createTextureWithData(channels, width, height, isHDR, format, data);
-}
-
-void OpenGLTexture2D::createTextureWithData(const unsigned int channels, const unsigned int width, const unsigned int height, const bool isHDR, const int format,
-                                            const void* data) {
-    this->width = width;
-    this->height = height;
-    this->internalFormat = isHDR ? GL_RGB16F : channels > 3 ? GL_RGBA8 : GL_RGB8;
-    this->format = format;
-    this->type = isHDR ? GL_FLOAT : GL_UNSIGNED_BYTE;
-
-    glGenTextures(1, &this->id);
-    glBindTexture(GL_TEXTURE_2D, this->id);
-    glTexImage2D(GL_TEXTURE_2D, 0, this->internalFormat, width, height, 0, this->format, this->type, data);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-    if (isHDR) {
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-    }
-}
-
-void OpenGLTexture2D::initializePBO() {
-    glGenBuffers(1, &this->pbo);
-    const unsigned int size = this->width * this->height * 4;
-    glBindBuffer(GL_PIXEL_UNPACK_BUFFER, this->pbo);
-    glBufferData(GL_PIXEL_UNPACK_BUFFER, size, nullptr, GL_STREAM_DRAW);
-    glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
-}
diff --git a/engine/src/rendering/opengl/OpenGLTexture2D.h b/engine/src/rendering/opengl/OpenGLTexture2D.h
deleted file mode 100644
index db93881..0000000
--- a/engine/src/rendering/opengl/OpenGLTexture2D.h
+++ /dev/null
@@ -1,32 +0,0 @@
-#pragma once
-#include "rendering/Texture.h"
-
-class OpenGLTexture2D : public Texture2D {
-public:
-    explicit OpenGLTexture2D(const std::string& path);
-    OpenGLTexture2D(unsigned int channels, unsigned int width, unsigned int height, unsigned int bytesPerPixel, int format, const void* data);
-    OpenGLTexture2D(unsigned int channels, unsigned int width, unsigned int height, unsigned int bytesPerPixel, const void* data);
-    OpenGLTexture2D(unsigned int id, unsigned int width, unsigned int height, int internalFormat, int format, int type);
-    ~OpenGLTexture2D() override;
-
-    void bind(uint32_t) const override;
-
-    void setRawData(const void* data, unsigned int size) override;
-    void resize(unsigned int width, unsigned int height) override;
-
-    void createTextureWithData(unsigned int channels, unsigned int width, unsigned int height, bool isHDR, const void* data);
-    void createTextureWithData(unsigned int channels, unsigned int width, unsigned int height, bool isHDR, int format, const void* data);
-
-private:
-    void initializePBO();
-
-    std::string path;
-    uint32_t id;
-
-    // OpenGL specific
-    int internalFormat;
-    int format;
-    int type;
-
-    unsigned int pbo = 0;
-};
diff --git a/engine/src/rendering/opengl/OpenGLTextureCube.cpp b/engine/src/rendering/opengl/OpenGLTextureCube.cpp
index 9783ac1..6824a7e 100644
--- a/engine/src/rendering/opengl/OpenGLTextureCube.cpp
+++ b/engine/src/rendering/opengl/OpenGLTextureCube.cpp
@@ -1,51 +1,10 @@
 #include "pch/enginepch.h"
 #include "OpenGLTextureCube.h"
 
-#include <glad/gl.h>
-#include <stb_image.h>
-
-
-OpenGLTextureCube::OpenGLTextureCube(const std::array<std::string, 6>& paths) : TextureCube(0), paths(paths) {
-    glGenTextures(1, &this->id);
-    glBindTexture(GL_TEXTURE_CUBE_MAP, this->id);
-
-    int width = -1;
-    int height = -1;
-    int channels = 0;
-    for (unsigned int i = 0; i < paths.size(); i++) {
-        stbi_uc* texture = stbi_load(paths[i].c_str(), &width, &height, &channels, 0);
-        if (!texture) {
-            const char* error = stbi_failure_reason();
-            DE_ERROR("Failed to read texture file {0} - {1}", paths[i], error);
-        }
-
-        glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, texture);
-        stbi_image_free(texture);
-    }
+#include "OpenGLTexture.h"
 
-    this->size = width;
-
-    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
-}
-
-OpenGLTextureCube::OpenGLTextureCube(const uint32_t id, const uint32_t size) : TextureCube(size), id(id) {}
-
-OpenGLTextureCube::~OpenGLTextureCube() {
-    glDeleteTextures(1, &this->id);
-}
+#include <glad/gl.h>
 
-void OpenGLTextureCube::bind(uint32_t slot) const {
-#ifdef OPENGL_4_6
-    glBindTextureUnit(slot, this->id);
-#else
-    glActiveTexture(GL_TEXTURE0 + slot);
-    glBindTexture(GL_TEXTURE_CUBE_MAP, this->id);
-#endif
-}
 
 void setupRenderBuffer(uint32_t& captureFramebuffer, uint32_t& captureRenderbuffer, const uint32_t size) {
     glGenFramebuffers(1, &captureFramebuffer);
@@ -56,27 +15,11 @@ void setupRenderBuffer(uint32_t& captureFramebuffer, uint32_t& captureRenderbuff
     glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, captureRenderbuffer);
 }
 
-void createCubeMap(uint32_t& cubeMapId, const uint32_t size, const bool hasMipmaps) {
-    glGenTextures(1, &cubeMapId);
-    glBindTexture(GL_TEXTURE_CUBE_MAP, cubeMapId);
-    for (unsigned int i = 0; i < 6; i++) {
-        glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_RGB16F, size, size, 0, GL_RGB, GL_FLOAT, nullptr);
-    }
-    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, hasMipmaps ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR);
-    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-    glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
-    if (hasMipmaps) {
-        glGenerateMipmap(GL_TEXTURE_CUBE_MAP);
-    }
-}
-
-void renderToCubemap(const Ref<Renderer>& renderer, const Ref<Shader>& convertShader, const Ref<Texture>& texture, const uint32_t cubeMapId, const int mipLevel = 0) {
+void renderToCubemap(const Ref<Renderer>& renderer, const Ref<Shader>& convertShader, const Ref<Texture>& texture, const unsigned int cubeMapId, const int mipLevel = 0) {
     const auto projection = glm::perspective(glm::radians(90.0f), 1.0f, 0.1f, 10.0f);
     const SkyboxCube cube(renderer, convertShader, texture);
     for (unsigned int i = 0; i < 6; i++) {
-        convertShader->uploadUniformMat4("uViewProjection", projection * TextureCube::invertedViewMatrices[i]);
+        convertShader->uploadUniformMat4("uViewProjection", projection * TextureCubeUtils::invertedViewMatrices[i]);
         glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, cubeMapId, mipLevel);
         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
         cube.getVertexArray()->bind();
@@ -84,23 +27,21 @@ void renderToCubemap(const Ref<Renderer>& renderer, const Ref<Shader>& convertSh
     }
 }
 
-Ref<CubeMap> OpenGLTextureCube::toCubemap() const {
-    std::array<Image, 6> faces;
-    glBindTexture(GL_TEXTURE_CUBE_MAP, this->id);
-    for (int i = 0; i < 6; i++) {
-        faces[i] = Image(this->size, this->size, 3, sizeof(float) * 3, nullptr);
-        glGetTexImage(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, GL_RGB, GL_FLOAT, faces[i].getData());
-    }
-    return std::make_shared<CubeMap>(std::move(faces));
-}
-
-Ref<TextureCube> OpenGLTextureCube::createFromHDR(const Ref<Renderer>& renderer, const Ref<Texture2D>& hdrTexture, const Ref<Shader>& convertShader, const uint32_t size) {
+Ref<Texture> OpenGLTextureCube::createFromHDR(const Ref<Renderer>& renderer, const Ref<Texture>& hdrTexture, const Ref<Shader>& convertShader, const uint32_t size) {
     uint32_t captureFramebuffer;
     uint32_t captureRenderbuffer;
     setupRenderBuffer(captureFramebuffer, captureRenderbuffer, size);
 
-    uint32_t cubeMapId;
-    createCubeMap(cubeMapId, size, false);
+    const Ref<Texture> cubeMap = Texture::builder()
+                                     .size(size)
+                                     .layers(6)
+                                     .format(hdrTexture->getFormat())
+                                     .internalFormat(hdrTexture->getInternalFormat())
+                                     .type(TextureType::TEXTURE_CUBE)
+                                     .filter(TextureFilter::LINEAR)
+                                     .wrap(TextureWrap::CLAMP_TO_EDGE)
+                                     .build(renderer);
+    const unsigned int cubeMapId = std::static_pointer_cast<OpenGLTexture>(cubeMap)->getId();
 
     convertShader->bind();
     hdrTexture->bind(0);
@@ -114,17 +55,25 @@ Ref<TextureCube> OpenGLTextureCube::createFromHDR(const Ref<Renderer>& renderer,
     glViewport(previousViewport[0], previousViewport[1], previousViewport[2], previousViewport[3]);
     glDeleteFramebuffers(1, &captureFramebuffer);
     glDeleteRenderbuffers(1, &captureRenderbuffer);
-    return std::make_shared<OpenGLTextureCube>(cubeMapId, size);
+    return cubeMap;
 }
 
-Ref<TextureCube> OpenGLTextureCube::createPrefilteredCubemap(const Ref<Renderer>& renderer, const Ref<TextureCube>& textureCube, const Ref<Shader>& convertShader,
-                                                             const uint32_t size) {
+Ref<Texture> OpenGLTextureCube::createPrefilteredCubemap(const Ref<Renderer>& renderer, const Ref<Texture>& textureCube, const Ref<Shader>& convertShader, const uint32_t size) {
     uint32_t captureFramebuffer;
     uint32_t captureRenderbuffer;
     setupRenderBuffer(captureFramebuffer, captureRenderbuffer, size);
 
-    uint32_t prefilteredCubemapId;
-    createCubeMap(prefilteredCubemapId, size, true);
+    Ref<Texture> prefilteredCubemap = Texture::builder()
+                                          .size(size)
+                                          .layers(6)
+                                          .format(TextureFormat::RGBA)
+                                          .internalFormat(TextureInternalFormat::RGBA16_FLOAT)
+                                          .type(TextureType::TEXTURE_CUBE)
+                                          .filterMin(TextureFilter::MIPMAP_LINEAR)
+                                          .wrap(TextureWrap::CLAMP_TO_EDGE)
+                                          .generateMipmaps(true)
+                                          .build(renderer);
+    const unsigned int prefilteredCubemapId = std::static_pointer_cast<OpenGLTexture>(prefilteredCubemap)->getId();
 
     convertShader->bind();
     textureCube->bind(0);
@@ -148,5 +97,5 @@ Ref<TextureCube> OpenGLTextureCube::createPrefilteredCubemap(const Ref<Renderer>
     glViewport(previousViewport[0], previousViewport[1], previousViewport[2], previousViewport[3]);
     glDeleteFramebuffers(1, &captureFramebuffer);
     glDeleteRenderbuffers(1, &captureRenderbuffer);
-    return std::make_shared<OpenGLTextureCube>(prefilteredCubemapId, size);
+    return prefilteredCubemap;
 }
diff --git a/engine/src/rendering/opengl/OpenGLTextureCube.h b/engine/src/rendering/opengl/OpenGLTextureCube.h
index 72d84f3..6669ce3 100644
--- a/engine/src/rendering/opengl/OpenGLTextureCube.h
+++ b/engine/src/rendering/opengl/OpenGLTextureCube.h
@@ -2,20 +2,8 @@
 #include "rendering/Texture.h"
 
 
-class OpenGLTextureCube : public TextureCube {
+class OpenGLTextureCube {
 public:
-    explicit OpenGLTextureCube(const std::array<std::string, 6>& paths);
-    explicit OpenGLTextureCube(uint32_t id, uint32_t size);
-    ~OpenGLTextureCube() override;
-
-    void bind(uint32_t) const override;
-
-    Ref<CubeMap> toCubemap() const override;
-
-    static Ref<TextureCube> createFromHDR(const Ref<Renderer>& renderer, const Ref<Texture2D>& hdrTexture, const Ref<Shader>& convertShader, uint32_t size);
-    static Ref<TextureCube> createPrefilteredCubemap(const Ref<Renderer>& renderer, const Ref<TextureCube>& textureCube, const Ref<Shader>& convertShader, uint32_t size);
-
-private:
-    std::array<std::string, 6> paths;
-    uint32_t id;
+    static Ref<Texture> createFromHDR(const Ref<Renderer>& renderer, const Ref<Texture>& hdrTexture, const Ref<Shader>& convertShader, uint32_t size);
+    static Ref<Texture> createPrefilteredCubemap(const Ref<Renderer>& renderer, const Ref<Texture>& textureCube, const Ref<Shader>& convertShader, uint32_t size);
 };
diff --git a/engine/src/rendering/opengl/OpenGLTextureCubeArray.cpp b/engine/src/rendering/opengl/OpenGLTextureCubeArray.cpp
deleted file mode 100644
index 43c2ff8..0000000
--- a/engine/src/rendering/opengl/OpenGLTextureCubeArray.cpp
+++ /dev/null
@@ -1,16 +0,0 @@
-#include "pch/enginepch.h"
-#include "OpenGLTextureCubeArray.h"
-
-#include <glad/gl.h>
-
-
-OpenGLTextureCubeArray::OpenGLTextureCubeArray(const unsigned int id, const unsigned int size, const unsigned int layersCount) : TextureCubeArray(size, layersCount), id(id) {}
-
-OpenGLTextureCubeArray::~OpenGLTextureCubeArray() {
-    glDeleteTextures(1, &this->id);
-}
-
-void OpenGLTextureCubeArray::bind(const unsigned int slot) const {
-    glActiveTexture(GL_TEXTURE0 + slot);
-    glBindTexture(GL_TEXTURE_CUBE_MAP_ARRAY, this->id);
-}
diff --git a/engine/src/rendering/opengl/OpenGLTextureCubeArray.h b/engine/src/rendering/opengl/OpenGLTextureCubeArray.h
deleted file mode 100644
index 2b393dc..0000000
--- a/engine/src/rendering/opengl/OpenGLTextureCubeArray.h
+++ /dev/null
@@ -1,14 +0,0 @@
-#pragma once
-#include "rendering/Texture.h"
-
-
-class OpenGLTextureCubeArray : public TextureCubeArray {
-public:
-    explicit OpenGLTextureCubeArray(unsigned int id, unsigned int size, unsigned int layersCount);
-    ~OpenGLTextureCubeArray() override;
-
-    void bind(unsigned int) const override;
-
-private:
-    unsigned int id;
-};
diff --git a/engine/src/rendering/opengl/OpenGLTypes.h b/engine/src/rendering/opengl/OpenGLTypes.h
new file mode 100644
index 0000000..40ae7b2
--- /dev/null
+++ b/engine/src/rendering/opengl/OpenGLTypes.h
@@ -0,0 +1,315 @@
+#pragma once
+#include "rendering/BufferLayout.h"
+#include "rendering/Pipeline.h"
+
+#include <glad/gl.h>
+
+class OpenGLTypes {
+public:
+    static constexpr GLenum getFromDataType(DataType type) {
+        switch (type) {
+            case DataType::BOOL:
+                return GL_BOOL;
+            case DataType::INT:
+            case DataType::INT2:
+            case DataType::INT3:
+            case DataType::INT4:
+                return GL_INT;
+            case DataType::FLOAT:
+            case DataType::FLOAT2:
+            case DataType::FLOAT3:
+            case DataType::FLOAT4:
+                return GL_FLOAT;
+        }
+        DE_ERROR("Couldn't find corresponding OpenGL data type for DataType {0}", static_cast<int>(type));
+        return 0;
+    }
+
+    static constexpr GLenum getFromTextureFormat(const TextureFormat format) {
+        switch (format) {
+            case TextureFormat::R:
+                return GL_RED;
+            case TextureFormat::R_INT:
+                return GL_RED_INTEGER;
+            case TextureFormat::RG:
+                return GL_RG;
+            case TextureFormat::RG_INT:
+                return GL_RG_INTEGER;
+            case TextureFormat::RGB:
+                return GL_RGB;
+            case TextureFormat::RGB_INT:
+                return GL_RGB_INTEGER;
+            case TextureFormat::RGBA:
+                return GL_RGBA;
+            case TextureFormat::RGBA_INT:
+                return GL_RGBA_INTEGER;
+            case TextureFormat::BGRA:
+                return GL_BGRA;
+            case TextureFormat::DEPTH:
+                return GL_DEPTH_COMPONENT;
+            case TextureFormat::DEPTH_STENCIL:
+                return GL_DEPTH_STENCIL;
+        }
+        DE_ERROR("Couldn't find corresponding OpenGL format for TextureFormat {0}", static_cast<int>(format));
+        return 0;
+    }
+
+    static constexpr GLint getFromTextureInternalFormat(const TextureInternalFormat internalFormat) {
+        switch (internalFormat) {
+            case TextureInternalFormat::R8:
+                return GL_R8;
+            case TextureInternalFormat::R8_SNORM:
+                return GL_R8_SNORM;
+            case TextureInternalFormat::R8_UINT:
+                return GL_R8UI;
+            case TextureInternalFormat::R8_INT:
+                return GL_R8I;
+            case TextureInternalFormat::R16:
+                return GL_R16;
+            case TextureInternalFormat::R16_SNORM:
+                return GL_R16_SNORM;
+            case TextureInternalFormat::R16_UINT:
+                return GL_R16UI;
+            case TextureInternalFormat::R16_INT:
+                return GL_R16I;
+            case TextureInternalFormat::R16_FLOAT:
+                return GL_R16F;
+            case TextureInternalFormat::R32_UINT:
+                return GL_R32UI;
+            case TextureInternalFormat::R32_INT:
+                return GL_R32I;
+            case TextureInternalFormat::R32_FLOAT:
+                return GL_R32F;
+            case TextureInternalFormat::RG8:
+                return GL_RG8;
+            case TextureInternalFormat::RG8_SNORM:
+                return GL_RG8_SNORM;
+            case TextureInternalFormat::RG8_UINT:
+                return GL_RG8UI;
+            case TextureInternalFormat::RG8_INT:
+                return GL_RG8I;
+            case TextureInternalFormat::RG16:
+                return GL_RG16;
+            case TextureInternalFormat::RG16_SNORM:
+                return GL_RG16_SNORM;
+            case TextureInternalFormat::RG16_UINT:
+                return GL_RG16UI;
+            case TextureInternalFormat::RG16_INT:
+                return GL_RG16I;
+            case TextureInternalFormat::RG16_FLOAT:
+                return GL_RG16F;
+            case TextureInternalFormat::RG32_UINT:
+                return GL_RG32UI;
+            case TextureInternalFormat::RG32_INT:
+                return GL_RG32I;
+            case TextureInternalFormat::RG32_FLOAT:
+                return GL_RG32F;
+            case TextureInternalFormat::RGB8:
+                return GL_RGB8;
+            case TextureInternalFormat::RGB8_SNORM:
+                return GL_RGB8_SNORM;
+            case TextureInternalFormat::RGB8_UINT:
+                return GL_RGB8UI;
+            case TextureInternalFormat::RGB8_INT:
+                return GL_RGB8I;
+            case TextureInternalFormat::RGBA8:
+                return GL_RGBA8;
+            case TextureInternalFormat::RGBA8_SNORM:
+                return GL_RGBA8_SNORM;
+            case TextureInternalFormat::RGBA8_UINT:
+                return GL_RGBA8UI;
+            case TextureInternalFormat::RGBA8_INT:
+                return GL_RGBA8I;
+            case TextureInternalFormat::RGBA16:
+                return GL_RGBA16;
+            case TextureInternalFormat::RGBA16_SNORM:
+                return GL_RGBA16_SNORM;
+            case TextureInternalFormat::RGBA16_UINT:
+                return GL_RGBA16UI;
+            case TextureInternalFormat::RGBA16_INT:
+                return GL_RGBA16I;
+            case TextureInternalFormat::RGBA16_FLOAT:
+                return GL_RGBA16F;
+            case TextureInternalFormat::RGBA32_UINT:
+                return GL_RGBA32UI;
+            case TextureInternalFormat::RGBA32_INT:
+                return GL_RGBA32I;
+            case TextureInternalFormat::RGBA32_FLOAT:
+                return GL_RGBA32F;
+            case TextureInternalFormat::D16:
+                return GL_DEPTH_COMPONENT16;
+            case TextureInternalFormat::D24:
+                return GL_DEPTH_COMPONENT24;
+            case TextureInternalFormat::D32:
+                return GL_DEPTH_COMPONENT32;
+            case TextureInternalFormat::D24S8:
+                return GL_DEPTH24_STENCIL8;
+        }
+        DE_ERROR("Couldn't find corresponding OpenGL internal format for TextureInternalFormat {0}", static_cast<int>(internalFormat));
+        return 0;
+    }
+
+    static constexpr GLenum getFromTextureType(const TextureType type, const unsigned int samples) {
+        switch (type) {
+            case TextureType::TEXTURE_2D:
+                return samples > 1 ? GL_TEXTURE_2D_MULTISAMPLE : GL_TEXTURE_2D;
+            case TextureType::TEXTURE_2D_ARRAY:
+                return samples > 1 ? GL_TEXTURE_2D_MULTISAMPLE_ARRAY : GL_TEXTURE_2D_ARRAY;
+            case TextureType::TEXTURE_CUBE:
+                return GL_TEXTURE_CUBE_MAP;
+            case TextureType::TEXTURE_CUBE_ARRAY:
+                return GL_TEXTURE_CUBE_MAP_ARRAY;
+        }
+        DE_ERROR("Couldn't find corresponding OpenGL texture target for TextureType {0}", static_cast<int>(type));
+        return 0;
+    }
+
+    static constexpr GLenum getPixelTypeFromInternalFormat(const TextureInternalFormat internalFormat) {
+        if (internalFormat == TextureInternalFormat::D24S8) {
+            return GL_UNSIGNED_INT_24_8;
+        }
+
+        switch (internalFormat.getDataType()) {
+            case TextureDataType::BYTE:
+                return GL_BYTE;
+            case TextureDataType::UBYTE:
+                return GL_UNSIGNED_BYTE;
+            case TextureDataType::USHORT:
+                return GL_UNSIGNED_SHORT;
+            case TextureDataType::SHORT:
+                return GL_SHORT;
+            case TextureDataType::INT:
+                return GL_INT;
+            case TextureDataType::UINT:
+                return GL_UNSIGNED_INT;
+            case TextureDataType::HALF_FLOAT:
+                return GL_HALF_FLOAT;
+            case TextureDataType::FLOAT:
+                return GL_FLOAT;
+        }
+        DE_ERROR("Couldn't find corresponding OpenGL pixel type for TextureInternalFormat {0}", static_cast<int>(internalFormat));
+        return 0;
+    }
+
+    static constexpr GLint getFromTextureFilter(const TextureFilter filter) {
+        switch (filter) {
+            case TextureFilter::NEAREST:
+                return GL_NEAREST;
+            case TextureFilter::LINEAR:
+                return GL_LINEAR;
+            case TextureFilter::MIPMAP_NEAREST:
+                return GL_NEAREST_MIPMAP_NEAREST;
+            case TextureFilter::MIPMAP_LINEAR:
+                return GL_LINEAR_MIPMAP_LINEAR;
+        }
+        DE_ERROR("Couldn't find corresponding OpenGL filter for TextureFilter {0}", static_cast<int>(filter));
+        return 0;
+    }
+
+    static constexpr GLint getFromTextureWrap(const TextureWrap wrap) {
+        switch (wrap) {
+            case TextureWrap::REPEAT:
+                return GL_REPEAT;
+            case TextureWrap::MIRRORED_REPEAT:
+                return GL_MIRRORED_REPEAT;
+            case TextureWrap::CLAMP_TO_EDGE:
+                return GL_CLAMP_TO_EDGE;
+            case TextureWrap::CLAMP_TO_BORDER:
+                return GL_CLAMP_TO_BORDER;
+        }
+        DE_ERROR("Couldn't find corresponding OpenGL wrap mode for TextureWrap {0}", static_cast<int>(wrap));
+        return 0;
+    }
+
+    static constexpr GLenum getFromBlendFactor(const PipelineBlendFactor factor) {
+        switch (factor) {
+            case PipelineBlendFactor::ZERO:
+                return GL_ZERO;
+            case PipelineBlendFactor::ONE:
+                return GL_ONE;
+            case PipelineBlendFactor::SRC_COLOR:
+                return GL_SRC_COLOR;
+            case PipelineBlendFactor::ONE_MINUS_SRC_COLOR:
+                return GL_ONE_MINUS_SRC_COLOR;
+            case PipelineBlendFactor::DST_COLOR:
+                return GL_DST_COLOR;
+            case PipelineBlendFactor::ONE_MINUS_DST_COLOR:
+                return GL_ONE_MINUS_DST_COLOR;
+            case PipelineBlendFactor::SRC_ALPHA:
+                return GL_SRC_ALPHA;
+            case PipelineBlendFactor::ONE_MINUS_SRC_ALPHA:
+                return GL_ONE_MINUS_SRC_ALPHA;
+            case PipelineBlendFactor::DST_ALPHA:
+                return GL_DST_ALPHA;
+            case PipelineBlendFactor::ONE_MINUS_DST_ALPHA:
+                return GL_ONE_MINUS_DST_ALPHA;
+            case PipelineBlendFactor::CONSTANT_COLOR:
+                return GL_CONSTANT_COLOR;
+            case PipelineBlendFactor::ONE_MINUS_CONSTANT_COLOR:
+                return GL_ONE_MINUS_CONSTANT_COLOR;
+            case PipelineBlendFactor::CONSTANT_ALPHA:
+                return GL_CONSTANT_ALPHA;
+            case PipelineBlendFactor::ONE_MINUS_CONSTANT_ALPHA:
+                return GL_ONE_MINUS_CONSTANT_ALPHA;
+            case PipelineBlendFactor::SRC_ALPHA_SATURATE:
+                return GL_SRC_ALPHA_SATURATE;
+        }
+        DE_ERROR("Couldn't find corresponding OpenGL blend factor for PipelineBlendFactor {0}", static_cast<int>(factor));
+        return 0;
+    }
+
+    static constexpr GLenum getFromBlendOp(const PipelineBlendOp op) {
+        switch (op) {
+            case PipelineBlendOp::ADD:
+                return GL_FUNC_ADD;
+            case PipelineBlendOp::SUBTRACT:
+                return GL_FUNC_SUBTRACT;
+            case PipelineBlendOp::REVERSE_SUBTRACT:
+                return GL_FUNC_REVERSE_SUBTRACT;
+            case PipelineBlendOp::MIN:
+                return GL_MIN;
+            case PipelineBlendOp::MAX:
+                return GL_MAX;
+        }
+        DE_ERROR("Couldn't find corresponding OpenGL blend operation for PipelineBlendOp {0}", static_cast<int>(op));
+        return 0;
+    }
+
+    static constexpr GLenum getFromCompareOp(const PipelineCompareOp op) {
+        switch (op) {
+            case PipelineCompareOp::NEVER:
+                return GL_NEVER;
+            case PipelineCompareOp::LESS:
+                return GL_LESS;
+            case PipelineCompareOp::EQUAL:
+                return GL_EQUAL;
+            case PipelineCompareOp::LESS_EQUAL:
+                return GL_LEQUAL;
+            case PipelineCompareOp::GREATER:
+                return GL_GREATER;
+            case PipelineCompareOp::NOT_EQUAL:
+                return GL_NOTEQUAL;
+            case PipelineCompareOp::GREATER_EQUAL:
+                return GL_GEQUAL;
+            case PipelineCompareOp::ALWAYS:
+                return GL_ALWAYS;
+        }
+        DE_ERROR("Couldn't find corresponding OpenGL compare operation for PipelineCompareOp {0}", static_cast<int>(op));
+        return 0;
+    }
+
+    static constexpr GLenum getFromCullMode(const PipelineCullMode mode) {
+        switch (mode) {
+            case PipelineCullMode::NONE:
+                return GL_NONE;
+            case PipelineCullMode::FRONT:
+                return GL_FRONT;
+            case PipelineCullMode::BACK:
+                return GL_BACK;
+            case PipelineCullMode::FRONT_AND_BACK:
+                return GL_FRONT_AND_BACK;
+        }
+        DE_ERROR("Couldn't find corresponding OpenGL cull mode for PipelineCullMode {0}", static_cast<int>(mode));
+        return 0;
+    }
+};
diff --git a/engine/src/rendering/opengl/OpenGLVertexArray.cpp b/engine/src/rendering/opengl/OpenGLVertexArray.cpp
index 9058c2d..21dc2ac 100644
--- a/engine/src/rendering/opengl/OpenGLVertexArray.cpp
+++ b/engine/src/rendering/opengl/OpenGLVertexArray.cpp
@@ -1,6 +1,6 @@
 #include "pch/enginepch.h"
 #include "OpenGLVertexArray.h"
-#include "OpenGLDataType.h"
+#include "OpenGLTypes.h"
 
 #include <glad/gl.h>
 
@@ -29,7 +29,7 @@ OpenGLVertexArray::OpenGLVertexArray(const Ref<VertexBuffer>& vertexBuffer, cons
         glVertexAttribPointer(
             layoutIndex,
             attribute.getDatatypeCount(),
-            getOpenGLTypeFromDatatype(attribute.type),
+            OpenGLTypes::getFromDataType(attribute.type),
             attribute.isNormalized ? GL_TRUE : GL_FALSE,
             layout.getSize(), // NOLINT(bugprone-narrowing-conversions, cppcoreguidelines-narrowing-conversions)
             #pragma warning(suppress: 4312)
diff --git a/engine/src/rendering/opengl/framebuffer/OpenGLDataFramebuffer.cpp b/engine/src/rendering/opengl/framebuffer/OpenGLDataFramebuffer.cpp
deleted file mode 100644
index 63a3d05..0000000
--- a/engine/src/rendering/opengl/framebuffer/OpenGLDataFramebuffer.cpp
+++ /dev/null
@@ -1,39 +0,0 @@
-#include "pch/enginepch.h"
-#include "OpenGLDataFramebuffer.h"
-
-#include "glad/gl.h"
-#include "rendering/opengl/OpenGLTexture2D.h"
-
-
-OpenGLDataFramebuffer::OpenGLDataFramebuffer(const unsigned int width, const unsigned int height) : DataFramebuffer(width, height) {
-    // data texture, similar to a stencil texture
-    unsigned int dataTextureId;
-    glGenTextures(1, &dataTextureId);
-    glBindTexture(GL_TEXTURE_2D, dataTextureId);
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_R8I, static_cast<int>(width), static_cast<int>(height), 0, GL_RED_INTEGER, GL_BYTE, nullptr);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-    this->depthTexture = std::make_shared<OpenGLTexture2D>(dataTextureId, width, height, GL_R8I, GL_RED_INTEGER, GL_BYTE);
-    // framebuffer
-    glGenFramebuffers(1, &this->id);
-    glBindFramebuffer(GL_FRAMEBUFFER, this->id);
-    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, dataTextureId, 0);
-
-    glBindFramebuffer(GL_FRAMEBUFFER, 0);
-}
-
-OpenGLDataFramebuffer::~OpenGLDataFramebuffer() {
-    glDeleteFramebuffers(1, &this->id);
-}
-
-void OpenGLDataFramebuffer::bind() const {
-    glBindFramebuffer(GL_FRAMEBUFFER, this->id);
-}
-
-void OpenGLDataFramebuffer::clear() const {
-    this->bind();
-    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
-    glClear(GL_COLOR_BUFFER_BIT);
-}
diff --git a/engine/src/rendering/opengl/framebuffer/OpenGLDataFramebuffer.h b/engine/src/rendering/opengl/framebuffer/OpenGLDataFramebuffer.h
deleted file mode 100644
index e561284..0000000
--- a/engine/src/rendering/opengl/framebuffer/OpenGLDataFramebuffer.h
+++ /dev/null
@@ -1,19 +0,0 @@
-#pragma once
-#include "rendering/framebuffer/DataFramebuffer.h"
-
-class OpenGLDataFramebuffer : public DataFramebuffer {
-public:
-    OpenGLDataFramebuffer(unsigned int width, unsigned int height);
-    ~OpenGLDataFramebuffer() override;
-
-    void bind() const override;
-    void clear() const override;
-
-    const Ref<Texture2D>& getDataTexture() const override {
-        return this->depthTexture;
-    }
-
-private:
-    unsigned int id;
-    Ref<Texture2D> depthTexture;
-};
diff --git a/engine/src/rendering/opengl/framebuffer/OpenGLDepthFramebuffer.cpp b/engine/src/rendering/opengl/framebuffer/OpenGLDepthFramebuffer.cpp
deleted file mode 100644
index b08b892..0000000
--- a/engine/src/rendering/opengl/framebuffer/OpenGLDepthFramebuffer.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-#include "pch/enginepch.h"
-#include "OpenGLDepthFramebuffer.h"
-
-#include "glad/gl.h"
-#include "rendering/opengl/OpenGLTexture2D.h"
-
-
-OpenGLDepthFramebuffer::OpenGLDepthFramebuffer(const uint32_t width, const uint32_t height) : DepthFramebuffer(width, height) {
-    // depth texture
-    unsigned int depthTextureId;
-    glGenTextures(1, &depthTextureId);
-    glBindTexture(GL_TEXTURE_2D, depthTextureId);
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, static_cast<int>(width), static_cast<int>(height), 0, GL_DEPTH_COMPONENT, GL_FLOAT, nullptr);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-    this->depthTexture = std::make_shared<OpenGLTexture2D>(depthTextureId, width, height, GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT, GL_FLOAT);
-    // framebuffer
-    glGenFramebuffers(1, &this->id);
-    glBindFramebuffer(GL_FRAMEBUFFER, this->id);
-    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, depthTextureId, 0);
-    glDrawBuffer(GL_NONE); // we don't have a color buffer
-    glReadBuffer(GL_NONE);
-
-    glBindFramebuffer(GL_FRAMEBUFFER, 0);
-}
-
-OpenGLDepthFramebuffer::~OpenGLDepthFramebuffer() {
-    glDeleteFramebuffers(1, &this->id);
-}
-
-void OpenGLDepthFramebuffer::bind() const {
-    glBindFramebuffer(GL_FRAMEBUFFER, this->id);
-}
diff --git a/engine/src/rendering/opengl/framebuffer/OpenGLDepthFramebuffer.h b/engine/src/rendering/opengl/framebuffer/OpenGLDepthFramebuffer.h
deleted file mode 100644
index 3552143..0000000
--- a/engine/src/rendering/opengl/framebuffer/OpenGLDepthFramebuffer.h
+++ /dev/null
@@ -1,18 +0,0 @@
-#pragma once
-#include "rendering/framebuffer/DepthFramebuffer.h"
-
-class OpenGLDepthFramebuffer : public DepthFramebuffer {
-public:
-    OpenGLDepthFramebuffer(uint32_t width, uint32_t height);
-    ~OpenGLDepthFramebuffer() override;
-
-    void bind() const override;
-
-    const Ref<Texture2D>& getDepthTexture() const override {
-        return this->depthTexture;
-    }
-
-private:
-    uint32_t id;
-    Ref<Texture2D> depthTexture;
-};
diff --git a/engine/src/rendering/opengl/framebuffer/OpenGLRenderFramebuffer.cpp b/engine/src/rendering/opengl/framebuffer/OpenGLRenderFramebuffer.cpp
deleted file mode 100644
index b7127d8..0000000
--- a/engine/src/rendering/opengl/framebuffer/OpenGLRenderFramebuffer.cpp
+++ /dev/null
@@ -1,86 +0,0 @@
-#include "pch/enginepch.h"
-#include "OpenGLRenderFramebuffer.h"
-
-#include "glad/gl.h"
-#include "rendering/opengl/OpenGLTexture2D.h"
-
-
-OpenGLRenderFramebuffer::OpenGLRenderFramebuffer(const uint32_t width, const uint32_t height) : RenderFramebuffer(width, height) {
-    // color texture
-    glGenTextures(1, &this->colorTextureId);
-    glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, this->colorTextureId);
-    glTexImage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, 4, GL_RGBA8, static_cast<int>(width), static_cast<int>(height), true);
-    // mouse picking texture
-    glGenTextures(1, &this->mousePickingTextureId);
-    glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, this->mousePickingTextureId);
-    glTexImage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, 4, GL_R32I, static_cast<int>(width), static_cast<int>(height), true);
-    // depth texture
-    glGenTextures(1, &this->depthStencilTextureId);
-    glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, this->depthStencilTextureId);
-    glTexImage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, 4, GL_DEPTH24_STENCIL8, static_cast<int>(width), static_cast<int>(height), true);
-    this->depthTexture = std::make_shared<OpenGLTexture2D>(this->depthStencilTextureId, width, height, GL_DEPTH24_STENCIL8, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8);
-    // framebuffer
-    glGenFramebuffers(1, &this->id);
-    glBindFramebuffer(GL_FRAMEBUFFER, this->id);
-    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D_MULTISAMPLE, this->colorTextureId, 0);
-    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, GL_TEXTURE_2D_MULTISAMPLE, this->mousePickingTextureId, 0);
-    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_2D_MULTISAMPLE, this->depthStencilTextureId, 0);
-    constexpr GLenum drawBuffers[2] = {GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1};
-    glDrawBuffers(2, drawBuffers);
-
-    // mouse picking, non-multisampled
-    glGenTextures(1, &this->renderedMousePickingTextureId);
-    glBindTexture(GL_TEXTURE_2D, this->renderedMousePickingTextureId);
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_R32I, static_cast<int>(width), static_cast<int>(height), 0, GL_RED_INTEGER, GL_INT, nullptr);
-    // rendered framebuffer, non-multisampled for reading pixel values
-    glGenFramebuffers(1, &this->renderedBufferId);
-    glBindFramebuffer(GL_FRAMEBUFFER, this->renderedBufferId);
-    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, this->renderedMousePickingTextureId, 0);
-
-    glBindFramebuffer(GL_FRAMEBUFFER, 0);
-}
-
-OpenGLRenderFramebuffer::~OpenGLRenderFramebuffer() {
-    glDeleteFramebuffers(1, &this->id);
-    glDeleteTextures(1, &this->colorTextureId);
-    glDeleteTextures(1, &this->mousePickingTextureId);
-    glDeleteTextures(1, &this->depthStencilTextureId);
-    glDeleteFramebuffers(1, &this->renderedBufferId);
-    glDeleteTextures(1, &this->renderedMousePickingTextureId);
-}
-
-void OpenGLRenderFramebuffer::bind() const {
-    glBindFramebuffer(GL_FRAMEBUFFER, this->id);
-}
-
-int OpenGLRenderFramebuffer::getMousePickingValue(const int x, const int y) const {
-    glBindFramebuffer(GL_READ_FRAMEBUFFER, this->renderedBufferId);
-    glReadBuffer(GL_COLOR_ATTACHMENT0);
-    int value = -1;
-    glReadPixels(x, static_cast<int>(this->height) - y, 1, 1, GL_RED_INTEGER, GL_INT, &value);
-    return value;
-}
-
-void OpenGLRenderFramebuffer::copyColorToBuffer(const uint32_t destinationId, const GLenum sourceAttachment) const {
-    glBindFramebuffer(GL_READ_FRAMEBUFFER, this->id);
-    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, destinationId);
-    glReadBuffer(sourceAttachment);
-    if (destinationId != 0) {
-        glDrawBuffer(GL_COLOR_ATTACHMENT0);
-    }
-    glBlitFramebuffer(0, 0, static_cast<int>(this->width), static_cast<int>(this->height), 0, 0, static_cast<int>(this->width), static_cast<int>(this->height), GL_COLOR_BUFFER_BIT,
-                      GL_NEAREST);
-    glBindFramebuffer(GL_FRAMEBUFFER, this->id);
-}
-
-void OpenGLRenderFramebuffer::saveMousePicking() const {
-    this->copyColorToBuffer(this->renderedBufferId, GL_COLOR_ATTACHMENT1);
-}
-
-void OpenGLRenderFramebuffer::clear() const {
-    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
-    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-    glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, this->mousePickingTextureId);
-    constexpr int pickingId = -1;
-    glClearTexImage(this->mousePickingTextureId, 0, GL_RED_INTEGER, GL_INT, &pickingId);
-}
diff --git a/engine/src/rendering/opengl/framebuffer/OpenGLRenderFramebuffer.h b/engine/src/rendering/opengl/framebuffer/OpenGLRenderFramebuffer.h
deleted file mode 100644
index 86ec540..0000000
--- a/engine/src/rendering/opengl/framebuffer/OpenGLRenderFramebuffer.h
+++ /dev/null
@@ -1,35 +0,0 @@
-#pragma once
-#include "rendering/framebuffer/RenderFramebuffer.h"
-
-#include <glad/gl.h>
-
-class OpenGLRenderFramebuffer : public RenderFramebuffer {
-public:
-    OpenGLRenderFramebuffer(uint32_t width, uint32_t height);
-    ~OpenGLRenderFramebuffer() override;
-
-    void bind() const override;
-
-    const Ref<Texture2D>& getDepthTexture() const override {
-        return depthTexture;
-    }
-
-    int getMousePickingValue(int x, int y) const override;
-
-    void clear() const override;
-    void saveMousePicking() const override;
-
-    void copyColorToBuffer(uint32_t destinationId, GLenum sourceAttachment = GL_COLOR_ATTACHMENT0) const;
-
-private:
-    // in-progress framebuffer, multisampled
-    uint32_t id;
-    uint32_t colorTextureId;
-    uint32_t mousePickingTextureId;
-    uint32_t depthStencilTextureId;
-    Ref<Texture2D> depthTexture;
-
-    // rendered, non-multisampled for pixel reading
-    uint32_t renderedBufferId;
-    uint32_t renderedMousePickingTextureId;
-};
diff --git a/engine/src/rendering/opengl/framebuffer/OpenGLRenderPassFramebuffer.cpp b/engine/src/rendering/opengl/framebuffer/OpenGLRenderPassFramebuffer.cpp
deleted file mode 100644
index c35045d..0000000
--- a/engine/src/rendering/opengl/framebuffer/OpenGLRenderPassFramebuffer.cpp
+++ /dev/null
@@ -1,48 +0,0 @@
-#include "pch/enginepch.h"
-#include "OpenGLRenderPassFramebuffer.h"
-
-#include "glad/gl.h"
-#include "rendering/opengl/OpenGLTexture2D.h"
-
-
-OpenGLRenderPassFramebuffer::OpenGLRenderPassFramebuffer(const unsigned int width, const unsigned int height) : RenderPassFramebuffer(width, height) {
-    unsigned int textureId;
-    glGenTextures(1, &textureId);
-    glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, textureId);
-    glTexImage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, 4, GL_RGBA32F, static_cast<int>(width), static_cast<int>(height), GL_TRUE);
-    this->texture = std::make_shared<OpenGLTexture2D>(textureId, width, height, GL_RGBA32F, GL_RGBA, GL_FLOAT);
-    // depth texture
-    unsigned int depthTextureId;
-    glGenTextures(1, &depthTextureId);
-    glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, depthTextureId);
-    glTexImage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, 4, GL_DEPTH_COMPONENT24, static_cast<int>(width), static_cast<int>(height), GL_TRUE);
-    this->depthTexture = std::make_shared<OpenGLTexture2D>(depthTextureId, width, height, GL_DEPTH_COMPONENT24, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT);
-    // framebuffer
-    glGenFramebuffers(1, &this->id);
-    glBindFramebuffer(GL_FRAMEBUFFER, this->id);
-    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D_MULTISAMPLE, textureId, 0);
-    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D_MULTISAMPLE, depthTextureId, 0);
-
-    glBindFramebuffer(GL_FRAMEBUFFER, 0);
-}
-
-OpenGLRenderPassFramebuffer::~OpenGLRenderPassFramebuffer() {
-    glDeleteFramebuffers(1, &this->id);
-}
-
-void OpenGLRenderPassFramebuffer::bind() const {
-    glBindFramebuffer(GL_FRAMEBUFFER, this->id);
-}
-
-void OpenGLRenderPassFramebuffer::clear() const {
-    this->bind();
-    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
-    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-}
-
-void OpenGLRenderPassFramebuffer::copyDepthToBuffer(const Ref<RenderPassFramebuffer>& buffer) const {
-    glBindFramebuffer(GL_READ_FRAMEBUFFER, this->id);
-    glBindFramebuffer(GL_DRAW_FRAMEBUFFER, std::static_pointer_cast<OpenGLRenderPassFramebuffer>(buffer)->id);
-    glBlitFramebuffer(0, 0, static_cast<int>(this->width), static_cast<int>(this->height), 0, 0, static_cast<int>(buffer->getWidth()), static_cast<int>(buffer->getHeight()),
-                      GL_DEPTH_BUFFER_BIT, GL_NEAREST);
-}
diff --git a/engine/src/rendering/opengl/framebuffer/OpenGLRenderPassFramebuffer.h b/engine/src/rendering/opengl/framebuffer/OpenGLRenderPassFramebuffer.h
deleted file mode 100644
index df1d4d9..0000000
--- a/engine/src/rendering/opengl/framebuffer/OpenGLRenderPassFramebuffer.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#pragma once
-#include "rendering/framebuffer/RenderPassFramebuffer.h"
-
-class OpenGLRenderPassFramebuffer : public RenderPassFramebuffer {
-public:
-    OpenGLRenderPassFramebuffer(unsigned int width, unsigned int height);
-    ~OpenGLRenderPassFramebuffer() override;
-
-    void bind() const override;
-    void clear() const override;
-
-    const Ref<Texture2D>& getTexture() const override {
-        return this->texture;
-    }
-
-    const Ref<Texture2D>& getDepthTexture() const override {
-        return this->depthTexture;
-    }
-
-    void copyDepthToBuffer(const Ref<RenderPassFramebuffer>& buffer) const override;
-
-private:
-    unsigned int id;
-    Ref<Texture2D> texture;
-    Ref<Texture2D> depthTexture;
-};
diff --git a/engine/src/rendering/opengl/framebuffer/OpenGLShadowCubeArrayFramebuffer.cpp b/engine/src/rendering/opengl/framebuffer/OpenGLShadowCubeArrayFramebuffer.cpp
index 1183476..d053aa7 100644
--- a/engine/src/rendering/opengl/framebuffer/OpenGLShadowCubeArrayFramebuffer.cpp
+++ b/engine/src/rendering/opengl/framebuffer/OpenGLShadowCubeArrayFramebuffer.cpp
@@ -1,54 +1,50 @@
 #include "pch/enginepch.h"
 #include "OpenGLShadowCubeArrayFramebuffer.h"
 
-#include "rendering/opengl/OpenGLTextureCubeArray.h"
+#include "rendering/opengl/OpenGLTexture.h"
 
 #include <glad/gl.h>
 
-OpenGLShadowCubeArrayFramebuffer::OpenGLShadowCubeArrayFramebuffer(const unsigned int size, const unsigned int layersCount) : ShadowCubeArrayFramebuffer(size) {
-    // depth texture
-    glGenTextures(1, &this->depthTextureId);
-    glBindTexture(GL_TEXTURE_2D, depthTextureId);
-    glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, static_cast<int>(size), static_cast<int>(size), 0, GL_DEPTH_COMPONENT, GL_FLOAT, nullptr);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-    // cube map array texture
-    glGenTextures(1, &this->shadowCubeTextureId);
-    glBindTexture(GL_TEXTURE_CUBE_MAP_ARRAY, this->shadowCubeTextureId);
-    glTexImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, GL_R32F, static_cast<int>(size), static_cast<int>(size), static_cast<int>(layersCount) * 6, 0, GL_RED, GL_FLOAT, nullptr);
-    glTexParameteri(GL_TEXTURE_CUBE_MAP_ARRAY, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-    glTexParameteri(GL_TEXTURE_CUBE_MAP_ARRAY, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-    glTexParameteri(GL_TEXTURE_CUBE_MAP_ARRAY, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
-    glTexParameteri(GL_TEXTURE_CUBE_MAP_ARRAY, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-    glTexParameteri(GL_TEXTURE_CUBE_MAP_ARRAY, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-
-    this->shadowCubeTexture = std::make_shared<OpenGLTextureCubeArray>(this->shadowCubeTextureId, size, layersCount);
+OpenGLShadowCubeArrayFramebuffer::OpenGLShadowCubeArrayFramebuffer(const Ref<Renderer>& renderer, const unsigned int size) : ShadowCubeArrayFramebuffer(size) {
+    depthTexture = Texture::builder()
+                       .size(size)
+                       .format(TextureFormat::DEPTH)
+                       .internalFormat(TextureInternalFormat::D24)
+                       .type(TextureType::TEXTURE_2D)
+                       .wrap(TextureWrap::CLAMP_TO_EDGE)
+                       .build(renderer);
+    shadowCubeTexture = Texture::builder()
+                            .size(size)
+                            .layers(0)
+                            .format(TextureFormat::R)
+                            .internalFormat(TextureInternalFormat::R32_FLOAT)
+                            .type(TextureType::TEXTURE_CUBE_ARRAY)
+                            .wrap(TextureWrap::CLAMP_TO_EDGE)
+                            .build(renderer);
+    const unsigned int depthTextureId = std::static_pointer_cast<const OpenGLTexture>(depthTexture)->getId();
+    const unsigned int shadowCubeTextureId = std::static_pointer_cast<const OpenGLTexture>(shadowCubeTexture)->getId();
     // framebuffer
-    glGenFramebuffers(1, &this->id);
-    glBindFramebuffer(GL_FRAMEBUFFER, this->id);
-    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, this->depthTextureId, 0);
-    glFramebufferTextureLayer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, this->shadowCubeTextureId, 0, 0);
+    glGenFramebuffers(1, &id);
+    glBindFramebuffer(GL_FRAMEBUFFER, id);
+    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, depthTextureId, 0);
+    glFramebufferTextureLayer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, shadowCubeTextureId, 0, 0);
     glBindFramebuffer(GL_FRAMEBUFFER, 0);
 }
 
 OpenGLShadowCubeArrayFramebuffer::~OpenGLShadowCubeArrayFramebuffer() {
-    glDeleteFramebuffers(1, &this->id);
-    glDeleteTextures(1, &this->depthTextureId);
+    glDeleteFramebuffers(1, &id);
 }
 
 void OpenGLShadowCubeArrayFramebuffer::bind(const unsigned int layer, const unsigned int face) const {
-    glBindFramebuffer(GL_FRAMEBUFFER, this->id);
-    glFramebufferTextureLayer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, this->shadowCubeTextureId, 0, static_cast<int>(layer * 6 + face));
+    glBindFramebuffer(GL_FRAMEBUFFER, id);
+    const unsigned int shadowCubeTextureId = std::static_pointer_cast<const OpenGLTexture>(shadowCubeTexture)->getId();
+    glFramebufferTextureLayer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, shadowCubeTextureId, 0, static_cast<int>(layer * 6 + face));
 }
 
 void OpenGLShadowCubeArrayFramebuffer::ensureLayersCapacity(const unsigned int layersCount) {
-    if (layersCount <= this->shadowCubeTexture->getLayersCount()) { // at the moment we only scale up
+    if (layersCount <= shadowCubeTexture->getLayers()) { // at the moment we only scale up
         return;
     }
 
-    glBindTexture(GL_TEXTURE_CUBE_MAP_ARRAY, this->shadowCubeTextureId);
-    glTexImage3D(GL_TEXTURE_CUBE_MAP_ARRAY, 0, GL_R32F, static_cast<int>(this->size), static_cast<int>(this->size), static_cast<int>(layersCount) * 6, 0, GL_RED, GL_FLOAT, nullptr);
-    this->shadowCubeTexture->setLayersCount(layersCount);
+    shadowCubeTexture->resize(size, size, layersCount * 6);
 }
diff --git a/engine/src/rendering/opengl/framebuffer/OpenGLShadowCubeArrayFramebuffer.h b/engine/src/rendering/opengl/framebuffer/OpenGLShadowCubeArrayFramebuffer.h
index 4992ca5..43175a5 100644
--- a/engine/src/rendering/opengl/framebuffer/OpenGLShadowCubeArrayFramebuffer.h
+++ b/engine/src/rendering/opengl/framebuffer/OpenGLShadowCubeArrayFramebuffer.h
@@ -2,7 +2,7 @@
 
 class OpenGLShadowCubeArrayFramebuffer : public ShadowCubeArrayFramebuffer {
 public:
-    explicit OpenGLShadowCubeArrayFramebuffer(unsigned int size, unsigned int layersCount);
+    explicit OpenGLShadowCubeArrayFramebuffer(const Ref<Renderer>& renderer, unsigned int size);
     ~OpenGLShadowCubeArrayFramebuffer() override;
 
     void bind(unsigned int layer, unsigned int face) const override;
@@ -11,6 +11,5 @@ class OpenGLShadowCubeArrayFramebuffer : public ShadowCubeArrayFramebuffer {
 
 private:
     unsigned int id;
-    unsigned int depthTextureId;
-    unsigned int shadowCubeTextureId;
+    Ref<Texture> depthTexture;
 };
diff --git a/engine/src/scene/materials/Material.h b/engine/src/scene/materials/Material.h
index fb76ef9..baf5a6f 100644
--- a/engine/src/scene/materials/Material.h
+++ b/engine/src/scene/materials/Material.h
@@ -1,11 +1,11 @@
 #pragma once
 
 struct Material {
-    Ref<Texture2D> albedo;
-    Ref<Texture2D> occlusionRoughnessMetallic;
+    Ref<Texture> albedo;
+    Ref<Texture> occlusionRoughnessMetallic;
     bool ignoreLighting = false;
 
     Material() = default;
-    Material(const Ref<Texture2D>& albedo, const Ref<Texture2D>& occlusionRoughnessMetallic) : albedo(albedo), occlusionRoughnessMetallic(occlusionRoughnessMetallic) {}
-    Material(const Ref<Texture2D>& albedo) : albedo(albedo), occlusionRoughnessMetallic(nullptr) {}
+    Material(const Ref<Texture>& albedo, const Ref<Texture>& occlusionRoughnessMetallic) : albedo(albedo), occlusionRoughnessMetallic(occlusionRoughnessMetallic) {}
+    Material(const Ref<Texture>& albedo) : albedo(albedo), occlusionRoughnessMetallic(nullptr) {}
 };
diff --git a/engine/src/scene/models/ModelImporter.cpp b/engine/src/scene/models/ModelImporter.cpp
index 8ac8ca8..db58448 100644
--- a/engine/src/scene/models/ModelImporter.cpp
+++ b/engine/src/scene/models/ModelImporter.cpp
@@ -1,6 +1,8 @@
 #include "pch/enginepch.h"
 #include "ModelImporter.h"
 
+#include "images/ImageUtils.h"
+
 #include <stack>
 #include <assimp/Importer.hpp>
 #include <assimp/scene.h>
@@ -89,18 +91,17 @@ std::vector<Model> ModelImporter::importFromFile(const Ref<Renderer>& renderer,
     return models;
 }
 
-Ref<Texture2D> ModelImporter::getTextureFromMaterial(const Ref<Renderer>& renderer, const aiScene* scene, const aiMaterial* material, const aiTextureType type,
-                                                     const std::string& basePath) {
+Ref<Texture> ModelImporter::getTextureFromMaterial(const Ref<Renderer>& renderer, const aiScene* scene, const aiMaterial* material, const aiTextureType type,
+                                                   const std::string& basePath) {
     if (material->GetTextureCount(type) == 0) {
         aiColor3D diffuseColor = {1.0f, 1.0f, 1.0f};
         material->Get(AI_MATKEY_COLOR_DIFFUSE, diffuseColor);
-        const auto colorData = std::array{
-            static_cast<unsigned char>(diffuseColor.r * 255),
-            static_cast<unsigned char>(diffuseColor.g * 255),
-            static_cast<unsigned char>(diffuseColor.b * 255),
-            static_cast<unsigned char>(255),
-        };
-        return renderer->createTexture2D(4, 1, 1, 1, colorData.data());
+        auto colorData = std::make_unique<uint8_t[]>(4);
+        colorData[0] = static_cast<uint8_t>(diffuseColor.r * 255);
+        colorData[1] = static_cast<uint8_t>(diffuseColor.g * 255);
+        colorData[2] = static_cast<uint8_t>(diffuseColor.b * 255);
+        colorData[3] = static_cast<uint8_t>(255);
+        return Texture::builder().width(1).height(1).format(TextureFormat::RGBA).internalFormat(TextureInternalFormat::RGBA8).data(std::move(colorData)).build(renderer);
     }
 
     aiString aiTexturePath;
@@ -118,9 +119,11 @@ Ref<Texture2D> ModelImporter::getTextureFromMaterial(const Ref<Renderer>& render
         if (texture->mHeight == 0) { // compressed texture
             data = decompressTexture(data, texture->mWidth, channels, width, height);
         }
-        return renderer->createTexture2D(channels, width, height, 1, data);
+        const TextureFormat format = channels == 4 ? TextureFormat::RGBA : TextureFormat::RGB;
+        const TextureInternalFormat internalFormat = channels == 4 ? TextureInternalFormat::RGBA8 : TextureInternalFormat::RGB8;
+        return Texture::builder().width(width).height(height).format(format).internalFormat(internalFormat).data(std::unique_ptr<uint8_t[]>(data)).build(renderer);
     }
-    return renderer->createTexture2D(basePath + "/" + texturePath);
+    return ImageUtils::loadTextureFromFile(renderer, basePath + "/" + texturePath);
 }
 
 unsigned char* ModelImporter::decompressTexture(const unsigned char* data, const unsigned int size, unsigned int& channels, unsigned int& width, unsigned int& height) {
diff --git a/engine/src/scene/models/ModelImporter.h b/engine/src/scene/models/ModelImporter.h
index cc5823b..a624a96 100644
--- a/engine/src/scene/models/ModelImporter.h
+++ b/engine/src/scene/models/ModelImporter.h
@@ -1,6 +1,5 @@
 #pragma once
 #include "Model.h"
-#include "scene/entities/Entity.h"
 
 #include <assimp/material.h>
 
@@ -12,7 +11,7 @@ class ModelImporter {
     static std::vector<Model> importFromFile(const Ref<Renderer>& renderer, const std::string& filename);
 
 private:
-    static Ref<Texture2D> getTextureFromMaterial(const Ref<Renderer>& renderer, const aiScene* scene, const aiMaterial* material, aiTextureType type,
+    static Ref<Texture> getTextureFromMaterial(const Ref<Renderer>& renderer, const aiScene* scene, const aiMaterial* material, aiTextureType type,
                                                     const std::string& basePath);
     static unsigned char* decompressTexture(const unsigned char* data, unsigned int size, unsigned int& channels, unsigned int& width, unsigned int& height);
 };
diff --git a/vsxmake2022/DicyEngine.sln.DotSettings b/vsxmake2022/DicyEngine.sln.DotSettings
index e141d2b..f86e2c7 100644
--- a/vsxmake2022/DicyEngine.sln.DotSettings
+++ b/vsxmake2022/DicyEngine.sln.DotSettings
@@ -54,6 +54,7 @@
 	<s:String x:Key="/Default/CodeStyle/Naming/CppNamingOptions/Abbreviations/=VM/@EntryIndexedValue">VM</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CppNamingOptions/Rules/=05ACDBD4C8A6634EB75E6639CEC86D6B/@EntryIndexedValue">&lt;NamingElement Priority="13" Title="Union members"&gt;&lt;Descriptor Static="Indeterminate" Constexpr="Indeterminate" Const="Indeterminate" Volatile="Indeterminate" Accessibility="NOT_APPLICABLE"&gt;&lt;type Name="union member" /&gt;&lt;/Descriptor&gt;&lt;Policy Inspect="True" WarnAboutPrefixesAndSuffixes="False" Prefix="" Suffix="" Style="aaBb" /&gt;&lt;/NamingElement&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CppNamingOptions/Rules/=062C54F071BF2C4AA661D2DFC989BE21/@EntryIndexedValue">&lt;NamingElement Priority="2" Title="Concepts"&gt;&lt;Descriptor Static="Indeterminate" Constexpr="Indeterminate" Const="Indeterminate" Volatile="Indeterminate" Accessibility="NOT_APPLICABLE"&gt;&lt;type Name="concept" /&gt;&lt;/Descriptor&gt;&lt;Policy Inspect="True" WarnAboutPrefixesAndSuffixes="False" Prefix="" Suffix="" Style="AaBb" /&gt;&lt;/NamingElement&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/CppNamingOptions/Rules/=0B82708A1BA7774EB13D27F245698A56/@EntryIndexedValue">&lt;NamingElement Priority="1" Title="Classes and structs"&gt;&lt;Descriptor Static="Indeterminate" Constexpr="Indeterminate" Const="Indeterminate" Volatile="Indeterminate" Accessibility="NOT_APPLICABLE"&gt;&lt;type Name="__interface" /&gt;&lt;type Name="class" /&gt;&lt;type Name="struct" /&gt;&lt;/Descriptor&gt;&lt;Policy Inspect="True" WarnAboutPrefixesAndSuffixes="False" Prefix="" Suffix="" Style="AaBb" /&gt;&lt;/NamingElement&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CppNamingOptions/Rules/=0CB3A2F79468E548BCB3F54D4CCE32A2/@EntryIndexedValue">&lt;NamingElement Priority="14" Title="Enum members"&gt;&lt;Descriptor Static="Indeterminate" Constexpr="Indeterminate" Const="Indeterminate" Volatile="Indeterminate" Accessibility="NOT_APPLICABLE"&gt;&lt;type Name="scoped enumerator" /&gt;&lt;type Name="unscoped enumerator" /&gt;&lt;/Descriptor&gt;&lt;Policy Inspect="True" WarnAboutPrefixesAndSuffixes="False" Prefix="" Suffix="" Style="AA_BB" /&gt;&lt;/NamingElement&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CppNamingOptions/Rules/=0D0721F1172E5A40A74E4B34CABA85CB/@EntryIndexedValue">&lt;NamingElement Priority="4" Title="Unions"&gt;&lt;Descriptor Static="Indeterminate" Constexpr="Indeterminate" Const="Indeterminate" Volatile="Indeterminate" Accessibility="NOT_APPLICABLE"&gt;&lt;type Name="union" /&gt;&lt;/Descriptor&gt;&lt;Policy Inspect="True" WarnAboutPrefixesAndSuffixes="False" Prefix="" Suffix="" Style="AaBb" /&gt;&lt;/NamingElement&gt;</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CppNamingOptions/Rules/=19FBA01BDC2B9C4FA34DE30DA90407DC/@EntryIndexedValue">&lt;NamingElement Priority="18" Title="Typedefs"&gt;&lt;Descriptor Static="Indeterminate" Constexpr="Indeterminate" Const="Indeterminate" Volatile="Indeterminate" Accessibility="NOT_APPLICABLE"&gt;&lt;type Name="type alias" /&gt;&lt;type Name="typedef" /&gt;&lt;/Descriptor&gt;&lt;Policy Inspect="True" WarnAboutPrefixesAndSuffixes="False" Prefix="" Suffix="" Style="AaBb" /&gt;&lt;/NamingElement&gt;</s:String>
diff --git a/xmake.lua b/xmake.lua
index 92e84c2..ac7346b 100644
--- a/xmake.lua
+++ b/xmake.lua
@@ -5,6 +5,9 @@ add_repositories("dicy-xmake-registry https://github.com/Dicy/xmake-registry")
 add_requires("spdlog v1.14.1")
 add_requires("glfw 3.4")
 add_requires("glm 1.0.1")
+add_requires("vulkan-headers 1.4.309+0")
+add_requires("vulkan-loader 1.4.309+0")
+add_requires("vulkan-validationlayers 1.4.309+0")
 add_requires("entt v3.13.2")
 add_requires("assimp v5.4.3")
 add_requires("toml++ v3.4.0")
@@ -41,12 +44,20 @@ target("engine")
         end
     end)
 
-    add_packages("spdlog", "glfw", "glm", "entt", "assimp", "toml++", "chromium-embedded-framework", "joltphysics")
+    add_packages("spdlog", "glfw", "glm", "vulkan-headers", "vulkan-loader", "vulkan-validationlayers", "entt", "assimp", "toml++", "chromium-embedded-framework", "joltphysics")
     add_deps("glad", "stb")
 
     add_defines("DE_IS_ENGINE", "GLM_ENABLE_EXPERIMENTAL", "NDEBUG")
     if is_mode("debug") then
         add_defines("DE_DEBUG")
+        -- Pass VK_ADD_LAYER_PATH from environment to the compiler as the runtime path is not loaded by the IDE
+        after_load(function (target)
+            if os.getenv("VK_ADD_LAYER_PATH") then
+                local vk_layer_path = os.getenv("VK_ADD_LAYER_PATH")
+                vk_layer_path = vk_layer_path:gsub("\\", "\\\\")
+                target:add("defines", "VK_ADD_LAYER_PATH=\"" .. vk_layer_path .. "\"")
+            end
+        end)
     else
         add_defines("DE_RELEASE")
     end
@@ -90,7 +101,7 @@ if is_plat("macosx") then
             set_kind("binary")
             set_languages("cxx23")
             add_rules("xcode.application")
-            set_targetdir("$(buildir)/$(plat)/$(arch)/$(mode)/DicyEngine.app/Contents/Frameworks")
+            set_targetdir("$(builddir)/$(plat)/$(arch)/$(mode)/DicyEngine.app/Contents/Frameworks")
 
             add_frameworks("AppKit", "Cocoa", "IOSurface")
             add_packages("chromium-embedded-framework")