main.cpp

#define GLFW_INCLUDE_VULKAN
#include <GLFW/glfw3.h>

#define GLM_FORCE_RADIANS
#define GLM_FORCE_DEPTH_ZERO_TO_ONE
#include <glm/vec4.hpp>
#include <glm/mat4x4.hpp>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#define GLM_ENABLE_EXPERIMENTAL
#include "glm/gtx/hash.hpp"

#define STB_IMAGE_IMPLEMENTATION
#include "stb_image.h"

#include <iostream>
#include <vector>
#include <string.h>
#include <algorithm>
#include <fstream>
#include <functional>
#include <sstream>
#include <iomanip>
#include <cmath>
#include <ios>
#include <sys/time.h>

#include "UI_system.h"
#include "geometry.h"
#include "physics.h"
#include "main.h"

#include "tinyfiledialogs.h"

struct MatricesUBO{
    alignas(16) glm::mat4 view;
    alignas(16) glm::mat4 proj;
    alignas(16) glm::vec4 camPos;
};

struct LightUBO{
    alignas(16) glm::vec4 dir;
    alignas(16) glm::vec4 col;
};

struct PerObjectData{
    alignas(16) glm::mat4 model;
};

struct VoxelMetaData {
    alignas(16) glm::vec4 minCorner;//w not used       min corner of whole voxel grid
    alignas(16) glm::vec4 maxCorner;//w not used       max corner of whole voxel grid
    alignas(16) glm::ivec4 stepDim;//w not used        for data reading indexing into buffer increasing pos[i] by 1 increases data loc bby stepDim[i]
    alignas(16) glm::ivec4 voxelDim;//w not used       whole grid dimensions in voxel units
    alignas(16) glm::vec4 voxelSize;//w not used       used to work out cell pos of a id

};

struct CSGMetaData {
    alignas(4) glm::ivec1 primitiveDataSize;
    alignas(4) glm::ivec1 nodeDataSize;
    alignas(4) glm::ivec1 root;
    alignas(4) glm::ivec1 selected;
};

struct VoxelData{
    alignas(4) uint type;
};

struct PrimitiveData{
    alignas(16) glm::vec4 data;
};
struct NodeData{
    alignas(16) glm::ivec4 data;
};

struct MatrixPushConstant{
    alignas(16) glm::mat4 model;
};

struct UIPushConstant{
    alignas(16) glm::mat4 model;
    alignas(16) glm::mat4 texture;
};

class Program;
class CSG;
class Camera;
template <class T>
class MemoryManager;
class Model;
class InstancedModel;
class RigidBody;
class UIElement;
struct DesignState;
struct StructureDefinition;





Program::Program(bool useValidationLayers, const std::vector<const char*> validationLayersToUse, const std::vector<const char*> deviceExtensionsToUse){
    enableValidationLayers = useValidationLayers;
    for (const char* vLayer : validationLayersToUse){
        validationLayers.push_back(vLayer);
    }
    for (const char* ext : deviceExtensionsToUse){
        deviceExtensions.push_back(ext);
    }


    MAX_FRAMES_IN_FLIGHT = 2;
    currentFrame = 0;
    framebufferResized = false;

    mainCamera = new Camera();
}

Program::~Program(){
    for (int i = 0; i < rigidBodies.size(); i++){
        delete rigidBodies[i];
        rigidBodies[i] = nullptr;
    }
    for (int i = 0; i < models.size(); i++){// probably needed as otherwise may try to free its space from a destroyed memory block
        delete models[i];
        models[i] = nullptr;
    }

    for (int i = 0; i < instancedModels.size(); i++){// probably needed as otherwise may try to free its space from a destroyed memory block
        delete instancedModels[i];
        instancedModels[i] = nullptr;
    }

    delete mainCamera;


    std::cout << "closing down\n";
    cleanupSwapChain();

    vkDestroySampler(logicalDevice, textureSampler, nullptr);
    vkDestroyImageView(logicalDevice, textureImageView, nullptr);
    vkDestroyImage(logicalDevice, textureImage, nullptr);
    vkFreeMemory(logicalDevice, textureImageMemory, nullptr);

    for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
        vkDestroySemaphore(logicalDevice, renderFinishedSemaphores[i], nullptr);
        vkDestroySemaphore(logicalDevice, imageAvailableSemaphores[i], nullptr);
        vkDestroyFence(logicalDevice, inFlightFences[i], nullptr);
    }

    delete verticesMemManager;
    delete indicesMemManager;



    vkDestroyCommandPool(logicalDevice, commandPool, nullptr);

    vkDestroyDescriptorPool(logicalDevice, descriptorPool, nullptr);

    vkDestroyDescriptorSetLayout(logicalDevice, descriptorSetLayout, nullptr);
    vkDestroyDescriptorSetLayout(logicalDevice, perObjectDataDSLayout, nullptr);

    vkDestroyDescriptorSetLayout(logicalDevice, uiDescriptorSetLayout, nullptr);
    vkDestroyDescriptorSetLayout(logicalDevice, uiTextureDescriptorSetLayout, nullptr);

    vkDestroyDescriptorSetLayout(logicalDevice, designDSLayout, nullptr);
    vkDestroyDescriptorSetLayout(logicalDevice, designDataDSLayout, nullptr);


    for (int i = 0; i < buffers.size(); i++){
        vkDestroyBuffer(logicalDevice, buffers[i], nullptr);
        vkFreeMemory(logicalDevice, buffersMemory[i], nullptr);
    }

    vkDestroyPipeline(logicalDevice, graphicsPipeline, nullptr);
    vkDestroyPipelineLayout(logicalDevice, pipelineLayout, nullptr);

    vkDestroyPipeline(logicalDevice, uiGraphicsPipeline, nullptr);
    vkDestroyPipelineLayout(logicalDevice, uiPipeLineLayout, nullptr);

    vkDestroyPipeline(logicalDevice, designGraphicsPipeline, nullptr);
    vkDestroyPipelineLayout(logicalDevice, designPipelineLayout, nullptr);


    vkDestroyRenderPass(logicalDevice, renderPass, nullptr);

    vkDestroyImage(logicalDevice, depthImage, nullptr);
    vkFreeMemory(logicalDevice, depthImageMemory, nullptr);
    vkDestroyImageView(logicalDevice, depthImageView, nullptr);


    vkDestroyDevice(logicalDevice, nullptr);

    vkDestroySurfaceKHR(instance, surface, nullptr);
    vkDestroyInstance(instance, nullptr);

    glfwDestroyWindow(window);

    glfwTerminate();
}

void Program::cleanupSwapChain(){
    for (int i = 0; i < swapChainFramebuffers.size(); i++) {
        vkDestroyFramebuffer(logicalDevice, swapChainFramebuffers[i], nullptr);
    }

    for (int i = 0; i < swapChainImageViews.size(); i++) {
        vkDestroyImageView(logicalDevice, swapChainImageViews[i], nullptr);
    }


    vkDestroySwapchainKHR(logicalDevice, swapChain, nullptr);
}

void Program::makeWindow(){
    glfwInit();

    glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
    //glfwWindowHint(GLFW_RESIZABLE, GLFW_FALSE); // due to being able to recreate the swap chain is not needed


    window = glfwCreateWindow(1080, 720, "Structural Simulator", nullptr, nullptr);
    //glfwSetFramebufferSizeCallback(window, framebufferResizeCallback);
}

void Program::setUpVulkan(){
    createInstance();
    createSurface();

    pickHardWareDevices();
    createLogicalDevice();

    createSwapChain();
    createImageViews();

    createCommandPool();

    createRenderPass();
    createDescriptorSetLayouts();// does all pipelines
    createGraphicsPipeline();
    createUIGraphicsPipeline();
    createDesignRayCastingPipeline();

    createDepthResources();

    createFramebuffers();

    createTextureImage();
    createTextureImageView();
    createTextureSampler();

    verticesMemManager = new MemoryManager<Vertex>(65536*16,logicalDevice, this, Vertex{{0.0,0.0,0.0},{0.0,0.0,0.0},{0.0,0.0,0.0}},
                                                    VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT);
    indicesMemManager = new MemoryManager<uint16_t>(65536*16,logicalDevice, this, 0,
                                                    VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_INDEX_BUFFER_BIT);

    createBuffers();
    createDescriptorPool();
    createDescriptorSets();

    createCommandBuffers();

    createSyncObjects();

    finishedSetUpBits();
}

void Program::createInstance(){
    if (enableValidationLayers && !checkValidationLayerSupport()){
        throw std::runtime_error("validation layers not available");
    }
    VkApplicationInfo appInfo{};
    appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
    appInfo.pApplicationName = "Structural simulator";
    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_1;

    VkInstanceCreateInfo createInfo{};
    createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
    createInfo.pApplicationInfo = &appInfo;
    if (enableValidationLayers) {
        createInfo.enabledLayerCount = static_cast<uint32_t>(validationLayers.size());
        createInfo.ppEnabledLayerNames = validationLayers.data();
    } else {
        createInfo.enabledLayerCount = 0;
    }

    uint32_t glfwExtensionCount = 0;
    const char** glfwExtensions;

    glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount);

    createInfo.enabledExtensionCount = glfwExtensionCount;
    createInfo.ppEnabledExtensionNames = glfwExtensions;


    VkResult result = vkCreateInstance(&createInfo, nullptr, &instance);

    if (vkCreateInstance(&createInfo, nullptr, &instance) != VK_SUCCESS) {
        throw std::runtime_error("failed to create instance");
    }
}

bool Program::checkValidationLayerSupport(){
    uint32_t layerCount;
    vkEnumerateInstanceLayerProperties(&layerCount, nullptr);

    std::vector<VkLayerProperties> availableLayers(layerCount);
    vkEnumerateInstanceLayerProperties(&layerCount, availableLayers.data());

    for (const char* layerName : validationLayers){
        bool layerFound = false;

        for (const VkLayerProperties& layerProperties : availableLayers){
            if (strcmp(layerName, layerProperties.layerName) == 0){// strcmp is asking are they equal from string.h
                layerFound = true;
                break;
            }
        }

        if (!layerFound){// if any of wanted layers not available return false
            return false;
        }
    }

    return true;
}

void Program::createSurface(){
    if (glfwCreateWindowSurface(instance, window, nullptr, &surface) != VK_SUCCESS) {
        throw std::runtime_error("failed to create window surface!");
    }
}

void Program::pickHardWareDevices(){
    physicalDevice = VK_NULL_HANDLE;

    uint32_t deviceCount = 0;
    vkEnumeratePhysicalDevices(instance, &deviceCount, nullptr);

    if (deviceCount == 0){
        std::cout << "no gpus with vulkan support\n";
        throw std::runtime_error("failed to find GPUs with Vulkan support!");
    }
    std::cout << deviceCount << " gpus\n";

    std::vector<VkPhysicalDevice> devices(deviceCount);
    vkEnumeratePhysicalDevices(instance, &deviceCount, devices.data());

    for (const VkPhysicalDevice& device : devices) {
        std::cout << devices.size() << "\n";
        if (device == VK_NULL_HANDLE){
            std::cout << "??\n";
        }
        if (validDevice(device)) {
            physicalDevice = device;
            break;
        }
    }
    std::cout << "\n\n";

    if (physicalDevice == VK_NULL_HANDLE) {
        throw std::runtime_error("failed to find a suitable GPU!");
    }
}

bool Program::validDevice(VkPhysicalDevice device){
    std::cout << device << "\n";
    // version supported and other stuff
    VkPhysicalDeviceProperties deviceProperties;
    vkGetPhysicalDeviceProperties(device, &deviceProperties);

    // what optional support is there
    VkPhysicalDeviceFeatures deviceFeatures;
    vkGetPhysicalDeviceFeatures(device, &deviceFeatures);

    QueueStruct indcies = findQueues(device);
    if (!indcies.isComplete()){
        std::cout << "error missing vital queue\n";
        return false;
    }
    std::cout << indcies.graphicsFamily << " graphic queue\n";

    if (!hasNeededExtensions(device)){
        return false;
    }

    bool swapChainAdequate = false;
    SwapChainSupportDetails swapChainSupport = querySwapChainSupport(device);
    swapChainAdequate = !swapChainSupport.formats.empty() && !swapChainSupport.presentModes.empty();
    std::cout << swapChainSupport.formats.size() << " " << swapChainSupport.presentModes.size() << "\n";
    if (!swapChainAdequate){
        std::cout << "not swap chain adequate\n";
        return false;
    }

    return true;
}

QueueStruct Program::findQueues(VkPhysicalDevice device){
    QueueStruct indices;

    uint32_t queueFamilyCount = 0;
    vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyCount, nullptr);

    std::vector<VkQueueFamilyProperties> queueFamilies(queueFamilyCount);
    vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyCount, queueFamilies.data());

    for (int i = 0; i < queueFamilies.size(); i++){
        const VkQueueFamilyProperties& queueFamily = queueFamilies[i];
        std::cout << i << " queue\n";

        if (queueFamily.queueFlags & VK_QUEUE_GRAPHICS_BIT){
            indices.graphicsFamily = i;
        }
        VkBool32 canPresent = false;
        vkGetPhysicalDeviceSurfaceSupportKHR(device, i, surface, &canPresent);

        if (canPresent){
            indices.presentFamily = i;
        }

        if((queueFamily.queueFlags & VK_QUEUE_GRAPHICS_BIT) && (queueFamily.queueFlags & VK_QUEUE_COMPUTE_BIT)){
            indices.graphicsAndComputeFamily = i;
        }

        if (indices.isComplete()){
            //break;
        }
    }

    return indices;
}

bool Program::hasNeededExtensions(VkPhysicalDevice device){


    uint32_t extensionCount;
    vkEnumerateDeviceExtensionProperties(device, nullptr, &extensionCount, nullptr);

    std::vector<VkExtensionProperties> availableExtensions(extensionCount);
    vkEnumerateDeviceExtensionProperties(device, nullptr, &extensionCount, availableExtensions.data());

    std::set<std::string> requiredExtensions(deviceExtensions.begin(), deviceExtensions.end());

    for (const VkExtensionProperties& extension : availableExtensions){ // for each of the availible extensions remove it from needed ones
        requiredExtensions.erase(extension.extensionName);
    }

    return requiredExtensions.empty();// if any left means unavailable extension
}

SwapChainSupportDetails Program::querySwapChainSupport(VkPhysicalDevice device) {
    SwapChainSupportDetails details;

    vkGetPhysicalDeviceSurfaceCapabilitiesKHR(device, surface, &details.capabilities);

    uint32_t formatCount;
    vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, nullptr);

    if (formatCount != 0) {
        details.formats.resize(formatCount);
        vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, details.formats.data());
    }

    uint32_t presentModeCount;
    vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &presentModeCount, nullptr);

    if (presentModeCount != 0) {
        details.presentModes.resize(presentModeCount);
        vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &presentModeCount, details.presentModes.data());
    }

    return details;
}

void Program::createLogicalDevice(){
    QueueStruct indices = findQueues(physicalDevice);


    std::vector<VkDeviceQueueCreateInfo> queueCreateInfos;
    std::set<uint32_t> uniqueQueueFamilies;
    uniqueQueueFamilies.insert(indices.graphicsFamily);
    uniqueQueueFamilies.insert(indices.presentFamily);
    uniqueQueueFamilies.insert(indices.graphicsAndComputeFamily);

    float queuePriority = 1.0f;
    for (uint32_t queueFamily : uniqueQueueFamilies) {
        VkDeviceQueueCreateInfo queueCreateInfo{};
        queueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
        queueCreateInfo.queueFamilyIndex = queueFamily;
        queueCreateInfo.queueCount = 1;
        queueCreateInfo.pQueuePriorities = &queuePriority;
        queueCreateInfos.push_back(queueCreateInfo);
    }

    VkPhysicalDeviceFeatures deviceFeatures{};
    //vkGetPhysicalDeviceFeatures(physicalDevice, &deviceFeatures);

    VkPhysicalDeviceShaderDrawParametersFeatures shaderDrawParameterFeatures{};
    shaderDrawParameterFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES;
    shaderDrawParameterFeatures.pNext = nullptr;
    shaderDrawParameterFeatures.shaderDrawParameters = VK_TRUE;

    VkPhysicalDeviceFeatures2 physicalFeatures2 = {};
    physicalFeatures2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
    physicalFeatures2.pNext = &shaderDrawParameterFeatures;

    vkGetPhysicalDeviceFeatures2(physicalDevice, &physicalFeatures2);
    if (shaderDrawParameterFeatures.shaderDrawParameters == VK_FALSE){throw;}

    VkDeviceCreateInfo createInfo{};
    createInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
    createInfo.queueCreateInfoCount = static_cast<uint32_t>(queueCreateInfos.size());
    createInfo.pQueueCreateInfos = queueCreateInfos.data();

    createInfo.pEnabledFeatures = nullptr;//&deviceFeatures;
    createInfo.pNext = &physicalFeatures2;


    createInfo.enabledExtensionCount = static_cast<uint32_t>(deviceExtensions.size());
    createInfo.ppEnabledExtensionNames = deviceExtensions.data();


    if (enableValidationLayers) {
        createInfo.enabledLayerCount = static_cast<uint32_t>(validationLayers.size());
        createInfo.ppEnabledLayerNames = validationLayers.data();
    } else {
        createInfo.enabledLayerCount = 0;
    }


    if (vkCreateDevice(physicalDevice, &createInfo, nullptr, &logicalDevice) != VK_SUCCESS) {
        throw std::runtime_error("failed to create logical device!");
    }

    vkGetDeviceQueue(logicalDevice, indices.graphicsFamily, 0, &graphicsQueue);
    vkGetDeviceQueue(logicalDevice, indices.presentFamily, 0, &presentQueue);
    vkGetDeviceQueue(logicalDevice, indices.graphicsAndComputeFamily, 0, &computeQueue);

}

void Program::createSwapChain(){
    SwapChainSupportDetails swapChainSupport = querySwapChainSupport(physicalDevice);

    VkSurfaceFormatKHR surfaceFormat = chooseSwapSurfaceFormat(swapChainSupport.formats);
    VkPresentModeKHR presentMode = chooseSwapPresentMode(swapChainSupport.presentModes);
    VkExtent2D extent = chooseSwapExtent(swapChainSupport.capabilities);


    uint32_t imageCount = swapChainSupport.capabilities.minImageCount + 1;// +1 so dont have to wait for driver to finish as much
    if (swapChainSupport.capabilities.maxImageCount > 0 && imageCount > swapChainSupport.capabilities.maxImageCount) {// 0 means no max
        imageCount = swapChainSupport.capabilities.maxImageCount;
    }

    VkSwapchainCreateInfoKHR createInfo{};
    createInfo.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
    createInfo.surface = surface;

    createInfo.minImageCount = imageCount;
    createInfo.imageFormat = surfaceFormat.format;
    createInfo.imageColorSpace = surfaceFormat.colorSpace;
    createInfo.imageExtent = extent;
    createInfo.imageArrayLayers = 1;
    createInfo.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;

    QueueStruct indices = findQueues(physicalDevice);
    uint32_t queueFamilyIndices[] = {static_cast<uint32_t>(indices.graphicsFamily),static_cast<uint32_t>(indices.presentFamily)};

    if (indices.graphicsFamily != indices.presentFamily){
        createInfo.imageSharingMode = VK_SHARING_MODE_CONCURRENT;
        createInfo.queueFamilyIndexCount = 2;
        createInfo.pQueueFamilyIndices = queueFamilyIndices;
    }
    else{
        createInfo.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE;
        createInfo.queueFamilyIndexCount = 0; // Optional
        createInfo.pQueueFamilyIndices = nullptr; // Optional
    }

    createInfo.preTransform = swapChainSupport.capabilities.currentTransform;

    createInfo.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR;

    createInfo.presentMode = presentMode;
    createInfo.clipped = VK_TRUE;

    createInfo.oldSwapchain = VK_NULL_HANDLE;

    if (vkCreateSwapchainKHR(logicalDevice, &createInfo, nullptr, &swapChain) != VK_SUCCESS) {
        throw std::runtime_error("failed to create swap chain!");
    }


    vkGetSwapchainImagesKHR(logicalDevice, swapChain, &imageCount, nullptr);
    swapChainImages.resize(imageCount);
    vkGetSwapchainImagesKHR(logicalDevice, swapChain, &imageCount, swapChainImages.data());


    swapChainImageFormat = surfaceFormat.format;
    swapChainExtent = extent;
}

VkSurfaceFormatKHR Program::chooseSwapSurfaceFormat(const std::vector<VkSurfaceFormatKHR>& availableFormats) {
    for (const VkSurfaceFormatKHR& availableFormat : availableFormats) {
        if (availableFormat.format == VK_FORMAT_B8G8R8A8_SRGB && availableFormat.colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR) {
            return availableFormat;
        }
    }

    return availableFormats[0];
}

VkPresentModeKHR Program::chooseSwapPresentMode(const std::vector<VkPresentModeKHR>& availablePresentModes){
    for (const VkPresentModeKHR& availablePresentMode : availablePresentModes){
        if (availablePresentMode == VK_PRESENT_MODE_MAILBOX_KHR){
            return availablePresentMode;
        }
    }

    return VK_PRESENT_MODE_FIFO_KHR;
}

VkExtent2D Program::chooseSwapExtent(const VkSurfaceCapabilitiesKHR& capabilities){
    if (capabilities.currentExtent.width != std::numeric_limits<uint32_t>::max()){
        return capabilities.currentExtent;
    }
    else{
        int width, height;
        glfwGetFramebufferSize(window, &width, &height);

        VkExtent2D actualExtent = {
            static_cast<uint32_t>(width),
            static_cast<uint32_t>(height)
        };

        actualExtent.width = std::clamp(actualExtent.width, capabilities.minImageExtent.width, capabilities.maxImageExtent.width);
        actualExtent.height = std::clamp(actualExtent.height, capabilities.minImageExtent.height, capabilities.maxImageExtent.height);

        return actualExtent;
    }
}

void Program::createImageViews(){
    swapChainImageViews.resize(swapChainImages.size());
    for (int i = 0; i < swapChainImages.size(); i++) {
        swapChainImageViews[i] = createImageView(swapChainImages[i],swapChainImageFormat,VK_IMAGE_ASPECT_COLOR_BIT);
    }
}

VkImageView Program::createImageView(VkImage image, VkFormat format, VkImageAspectFlags aspectFlags){
    VkImageViewCreateInfo createInfo{};
    createInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
    createInfo.image = image;
    createInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
    createInfo.format = format;

    createInfo.components.r = VK_COMPONENT_SWIZZLE_IDENTITY;
    createInfo.components.g = VK_COMPONENT_SWIZZLE_IDENTITY;
    createInfo.components.b = VK_COMPONENT_SWIZZLE_IDENTITY;
    createInfo.components.a = VK_COMPONENT_SWIZZLE_IDENTITY;

    createInfo.subresourceRange.aspectMask = aspectFlags;
    createInfo.subresourceRange.baseMipLevel = 0;
    createInfo.subresourceRange.levelCount = 1;
    createInfo.subresourceRange.baseArrayLayer = 0;
    createInfo.subresourceRange.layerCount = 1;

    VkImageView imageView;
    if (vkCreateImageView(logicalDevice, &createInfo, nullptr, &imageView) != VK_SUCCESS) {
        throw std::runtime_error("failed to create image view");
    }

    return imageView;
}

void Program::createCommandPool(){
    QueueStruct queueFamilyIndices = findQueues(physicalDevice);

    VkCommandPoolCreateInfo poolInfo{};
    poolInfo.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
    poolInfo.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
    poolInfo.queueFamilyIndex = queueFamilyIndices.graphicsFamily;

    if (vkCreateCommandPool(logicalDevice, &poolInfo, nullptr, &commandPool) != VK_SUCCESS){
        throw std::runtime_error("failed to create command pool!");
    }
}

void Program::createRenderPass(){
    VkAttachmentDescription colorAttachment{};
    colorAttachment.format = swapChainImageFormat;
    colorAttachment.samples = VK_SAMPLE_COUNT_1_BIT;

    colorAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
    colorAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE;

    colorAttachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
    colorAttachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;

    colorAttachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
    colorAttachment.finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR;

    VkAttachmentReference colorAttachmentRef{};
    colorAttachmentRef.attachment = 0;
    colorAttachmentRef.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;

    VkAttachmentDescription depthAttachment{};
    depthAttachment.format = findDepthFormat();
    depthAttachment.samples = VK_SAMPLE_COUNT_1_BIT;
    depthAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
    depthAttachment.storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
    depthAttachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
    depthAttachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
    depthAttachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
    depthAttachment.finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;

    VkAttachmentReference depthAttachmentRef{};
    depthAttachmentRef.attachment = 1;
    depthAttachmentRef.layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;

    VkSubpassDescription subpass{};
    subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
    subpass.colorAttachmentCount = 1;
    subpass.pColorAttachments = &colorAttachmentRef;
    subpass.pDepthStencilAttachment = &depthAttachmentRef;

    VkSubpassDependency dependency{};
    dependency.srcSubpass = VK_SUBPASS_EXTERNAL;
    dependency.dstSubpass = 0;
    dependency.srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT;
    dependency.srcAccessMask = 0;
    dependency.dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT;
    dependency.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;

    std::array<VkAttachmentDescription, 2> attachments = {colorAttachment, depthAttachment};
    VkRenderPassCreateInfo renderPassInfo{};
    renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
    renderPassInfo.attachmentCount = static_cast<uint32_t>(attachments.size());
    renderPassInfo.pAttachments = attachments.data();
    renderPassInfo.subpassCount = 1;
    renderPassInfo.pSubpasses = &subpass;
    renderPassInfo.dependencyCount = 1;
    renderPassInfo.pDependencies = &dependency;



    if (vkCreateRenderPass(logicalDevice, &renderPassInfo, nullptr, &renderPass) != VK_SUCCESS) {
        throw std::runtime_error("failed to create render pass");
    }
}

VkFormat Program::findDepthFormat() {
    return findSupportedFormat(
        {VK_FORMAT_D32_SFLOAT, VK_FORMAT_D32_SFLOAT_S8_UINT, VK_FORMAT_D24_UNORM_S8_UINT},
        VK_IMAGE_TILING_OPTIMAL,
        VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT
    );
}

VkFormat Program::findSupportedFormat(const std::vector<VkFormat>& candidates, VkImageTiling tiling, VkFormatFeatureFlags features){
    for (VkFormat format : candidates) {
        VkFormatProperties props;
        vkGetPhysicalDeviceFormatProperties(physicalDevice, format, &props);
        if (tiling == VK_IMAGE_TILING_LINEAR && (props.linearTilingFeatures & features) == features){
            return format;
        }
        else if (tiling == VK_IMAGE_TILING_OPTIMAL && (props.optimalTilingFeatures & features) == features){
            return format;
        }
    }
    throw std::runtime_error("failed to find supported format!");
}

void Program::createDescriptorSetLayouts(){// makes all decriptor set layouts using below function
    createDescriptorSetLayout({VK_SHADER_STAGE_VERTEX_BIT,VK_SHADER_STAGE_FRAGMENT_BIT},2,descriptorSetLayout,VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER);// main ubo
    createDescriptorSetLayout({},0,uiDescriptorSetLayout,VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER);// ui ubo
    createDescriptorSetLayout({VK_SHADER_STAGE_FRAGMENT_BIT},1,uiTextureDescriptorSetLayout,VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER);// ui texture
    createDescriptorSetLayout({VK_SHADER_STAGE_VERTEX_BIT},1,perObjectDataDSLayout,VK_DESCRIPTOR_TYPE_STORAGE_BUFFER);// main ssbo
    createDescriptorSetLayout({VK_SHADER_STAGE_VERTEX_BIT|VK_SHADER_STAGE_FRAGMENT_BIT,VK_SHADER_STAGE_FRAGMENT_BIT,VK_SHADER_STAGE_FRAGMENT_BIT},3,designDSLayout,VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER);// design ubo (like main ubo but with voxel/CSG meta data)
    createDescriptorSetLayout({VK_SHADER_STAGE_FRAGMENT_BIT,VK_SHADER_STAGE_FRAGMENT_BIT},2,designDataDSLayout,VK_DESCRIPTOR_TYPE_STORAGE_BUFFER);// design ssbo(s?) the CSG version has an extra SSBO as it has 2 undefined size things
}

void Program::createDescriptorSetLayout(std::vector<int> stages, int numBuffers,VkDescriptorSetLayout& layout, VkDescriptorType type){// helper function
    std::vector<VkDescriptorSetLayoutBinding> layoutBindings{};
    for (int i = 0; i < numBuffers; i++){
        layoutBindings.push_back(VkDescriptorSetLayoutBinding{});
        layoutBindings[i].binding = i;
        layoutBindings[i].descriptorType = type;
        layoutBindings[i].descriptorCount = 1;
        layoutBindings[i].stageFlags = stages[i];
        layoutBindings[i].pImmutableSamplers = nullptr; // Optional
    }


    VkDescriptorSetLayoutCreateInfo layoutInfo{};
    layoutInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
    layoutInfo.bindingCount = layoutBindings.size();
    layoutInfo.pBindings = layoutBindings.data();

    if (vkCreateDescriptorSetLayout(logicalDevice, &layoutInfo, nullptr, &layout) != VK_SUCCESS) {
        throw std::runtime_error("failed to create descriptor set layout");
    }
}

void Program::createGraphicsPipeline(){
    std::vector<char> vertShaderCode = readFile("vulkan_shaders/shader_vert.spv");
    std::vector<char> fragShaderCode = readFile("vulkan_shaders/shader_frag.spv");

    VkShaderModule vertShaderModule = createShaderModule(vertShaderCode);
    VkShaderModule fragShaderModule = createShaderModule(fragShaderCode);

    VkPipelineShaderStageCreateInfo vertShaderStageInfo{};
    vertShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
    vertShaderStageInfo.stage = VK_SHADER_STAGE_VERTEX_BIT;
    vertShaderStageInfo.module = vertShaderModule;
    vertShaderStageInfo.pName = "main";

    VkPipelineShaderStageCreateInfo fragShaderStageInfo{};
    fragShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
    fragShaderStageInfo.stage = VK_SHADER_STAGE_FRAGMENT_BIT;
    fragShaderStageInfo.module = fragShaderModule;
    fragShaderStageInfo.pName = "main";


    VkPipelineShaderStageCreateInfo shaderStages[] = {vertShaderStageInfo, fragShaderStageInfo};


    VkPipelineVertexInputStateCreateInfo vertexInputInfo{};
    vertexInputInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
    auto bindingDescription = Vertex::getBindingDescription();
    auto attributeDescriptions = Vertex::getAttributeDescriptions();

    vertexInputInfo.vertexBindingDescriptionCount = 1;
    vertexInputInfo.vertexAttributeDescriptionCount = static_cast<uint32_t>(attributeDescriptions.size());
    vertexInputInfo.pVertexBindingDescriptions = &bindingDescription;
    vertexInputInfo.pVertexAttributeDescriptions = attributeDescriptions.data();

    VkPipelineInputAssemblyStateCreateInfo inputAssembly{};
    inputAssembly.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
    inputAssembly.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
    inputAssembly.primitiveRestartEnable = VK_FALSE;


    std::vector<VkDynamicState> dynamicStates = {
        VK_DYNAMIC_STATE_VIEWPORT,
        VK_DYNAMIC_STATE_SCISSOR
    };

    VkPipelineDynamicStateCreateInfo dynamicState{};
    dynamicState.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
    dynamicState.dynamicStateCount = static_cast<uint32_t>(dynamicStates.size());
    dynamicState.pDynamicStates = dynamicStates.data();

    VkViewport viewport{};
    viewport.x = 0.0f;
    viewport.y = 0.0f;
    viewport.width = (float) swapChainExtent.width;
    viewport.height = (float) swapChainExtent.height;
    viewport.minDepth = 0.0f;
    viewport.maxDepth = 1.0f;

    VkRect2D scissor{};
    scissor.offset = {0, 0};
    scissor.extent = swapChainExtent;

    VkPipelineViewportStateCreateInfo viewportState{};
    viewportState.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
    viewportState.viewportCount = 1;
    viewportState.pViewports = &viewport;
    viewportState.scissorCount = 1;
    viewportState.pScissors = &scissor;

    VkPipelineDepthStencilStateCreateInfo depthStencil{};
    depthStencil.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
    depthStencil.depthTestEnable = VK_TRUE;
    depthStencil.depthWriteEnable = VK_TRUE;
    depthStencil.depthCompareOp = VK_COMPARE_OP_LESS;
    depthStencil.depthBoundsTestEnable = VK_FALSE;
    depthStencil.minDepthBounds = 0.0f; // Optional
    depthStencil.maxDepthBounds = 1.0f; // Optional
    depthStencil.stencilTestEnable = VK_FALSE;
    depthStencil.front = {}; // Optional
    depthStencil.back = {}; // Optional

    VkPipelineRasterizationStateCreateInfo rasterizer{};
    rasterizer.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
    rasterizer.depthClampEnable = VK_FALSE;
    rasterizer.rasterizerDiscardEnable = VK_FALSE;
    rasterizer.polygonMode = VK_POLYGON_MODE_FILL;
    rasterizer.lineWidth = 1.0f; // cant be more than 1 without cahnging something
    rasterizer.cullMode = VK_CULL_MODE_BACK_BIT;
    rasterizer.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;
    rasterizer.depthBiasEnable = VK_FALSE;
    rasterizer.depthBiasConstantFactor = 0.0f; // Optional
    rasterizer.depthBiasClamp = 0.0f; // Optional
    rasterizer.depthBiasSlopeFactor = 0.0f; // Optional

    VkPipelineMultisampleStateCreateInfo multisampling{};
    multisampling.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
    multisampling.sampleShadingEnable = VK_FALSE;
    multisampling.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
    multisampling.minSampleShading = 1.0f; // Optional
    multisampling.pSampleMask = nullptr; // Optional
    multisampling.alphaToCoverageEnable = VK_FALSE; // Optional
    multisampling.alphaToOneEnable = VK_FALSE; // Optional

    VkPipelineColorBlendAttachmentState colorBlendAttachment{};
    colorBlendAttachment.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
    colorBlendAttachment.blendEnable = VK_FALSE;
    colorBlendAttachment.srcColorBlendFactor = VK_BLEND_FACTOR_ONE; // Optional
    colorBlendAttachment.dstColorBlendFactor = VK_BLEND_FACTOR_ZERO; // Optional
    colorBlendAttachment.colorBlendOp = VK_BLEND_OP_ADD; // Optional
    colorBlendAttachment.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE; // Optional
    colorBlendAttachment.dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO; // Optional
    colorBlendAttachment.alphaBlendOp = VK_BLEND_OP_ADD; // Optional

    VkPipelineColorBlendStateCreateInfo colorBlending{};
    colorBlending.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
    colorBlending.logicOpEnable = VK_FALSE;
    colorBlending.logicOp = VK_LOGIC_OP_COPY; // Optional
    colorBlending.attachmentCount = 1;
    colorBlending.pAttachments = &colorBlendAttachment;
    colorBlending.blendConstants[0] = 0.0f; // Optional
    colorBlending.blendConstants[1] = 0.0f; // Optional
    colorBlending.blendConstants[2] = 0.0f; // Optional
    colorBlending.blendConstants[3] = 0.0f; // Optional

    // added to send model matrix per object
    VkPushConstantRange pushConstRange;
    pushConstRange.offset = 0;// only 1 so use the start
    pushConstRange.size = sizeof(MatrixPushConstant);//64;// 4 vec4 is 4 byte per float *16 = 64
    pushConstRange.stageFlags = VK_SHADER_STAGE_VERTEX_BIT;// needs to be in vertex shader

    std::vector<VkDescriptorSetLayout> dsLayouts = {descriptorSetLayout, perObjectDataDSLayout};

    VkPipelineLayoutCreateInfo pipelineLayoutInfo{};
    pipelineLayoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
    pipelineLayoutInfo.setLayoutCount = dsLayouts.size();
    pipelineLayoutInfo.pSetLayouts = dsLayouts.data();
    pipelineLayoutInfo.pushConstantRangeCount = 1;
    pipelineLayoutInfo.pPushConstantRanges = &pushConstRange;

    if (vkCreatePipelineLayout(logicalDevice, &pipelineLayoutInfo, nullptr, &pipelineLayout) != VK_SUCCESS) {
        throw std::runtime_error("failed to create pipeline layout!");
    }

    VkGraphicsPipelineCreateInfo pipelineInfo{};
    pipelineInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
    pipelineInfo.stageCount = 2;
    pipelineInfo.pStages = shaderStages;

    pipelineInfo.pVertexInputState = &vertexInputInfo;
    pipelineInfo.pInputAssemblyState = &inputAssembly;
    pipelineInfo.pViewportState = &viewportState;
    pipelineInfo.pRasterizationState = &rasterizer;
    pipelineInfo.pMultisampleState = &multisampling;
    pipelineInfo.pDepthStencilState = nullptr; // Optional
    pipelineInfo.pColorBlendState = &colorBlending;
    pipelineInfo.pDynamicState = &dynamicState;
    pipelineInfo.pDepthStencilState = &depthStencil;

    pipelineInfo.layout = pipelineLayout;

    pipelineInfo.renderPass = renderPass;
    pipelineInfo.subpass = 0;

    pipelineInfo.basePipelineHandle = VK_NULL_HANDLE; // Optional
    pipelineInfo.basePipelineIndex = -1; // Optional


    if (vkCreateGraphicsPipelines(logicalDevice, VK_NULL_HANDLE, 1, &pipelineInfo, nullptr, &graphicsPipeline) != VK_SUCCESS) {
        throw std::runtime_error("failed to create graphics pipeline!");
    }

    vkDestroyShaderModule(logicalDevice, fragShaderModule, nullptr);
    vkDestroyShaderModule(logicalDevice, vertShaderModule, nullptr);
}

void Program::createUIGraphicsPipeline(){
    std::vector<char> vertShaderCode = readFile("vulkan_shaders/shader_vert_ui.spv");
    std::vector<char> fragShaderCode = readFile("vulkan_shaders/shader_frag_ui.spv");

    VkShaderModule vertShaderModule = createShaderModule(vertShaderCode);
    VkShaderModule fragShaderModule = createShaderModule(fragShaderCode);

    VkPipelineShaderStageCreateInfo vertShaderStageInfo{};
    vertShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
    vertShaderStageInfo.stage = VK_SHADER_STAGE_VERTEX_BIT;
    vertShaderStageInfo.module = vertShaderModule;
    vertShaderStageInfo.pName = "main";

    VkPipelineShaderStageCreateInfo fragShaderStageInfo{};
    fragShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
    fragShaderStageInfo.stage = VK_SHADER_STAGE_FRAGMENT_BIT;
    fragShaderStageInfo.module = fragShaderModule;
    fragShaderStageInfo.pName = "main";


    VkPipelineShaderStageCreateInfo shaderStages[] = {vertShaderStageInfo, fragShaderStageInfo};


    VkPipelineVertexInputStateCreateInfo vertexInputInfo{};
    vertexInputInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
    auto bindingDescription = Vertex::getBindingDescription();
    auto attributeDescriptions = Vertex::getAttributeDescriptions();

    vertexInputInfo.vertexBindingDescriptionCount = 1;
    vertexInputInfo.vertexAttributeDescriptionCount = static_cast<uint32_t>(attributeDescriptions.size());
    vertexInputInfo.pVertexBindingDescriptions = &bindingDescription;
    vertexInputInfo.pVertexAttributeDescriptions = attributeDescriptions.data();

    VkPipelineInputAssemblyStateCreateInfo inputAssembly{};
    inputAssembly.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
    inputAssembly.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
    inputAssembly.primitiveRestartEnable = VK_FALSE;


    std::vector<VkDynamicState> dynamicStates = {
        VK_DYNAMIC_STATE_VIEWPORT,
        VK_DYNAMIC_STATE_SCISSOR
    };

    VkPipelineDynamicStateCreateInfo dynamicState{};
    dynamicState.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
    dynamicState.dynamicStateCount = static_cast<uint32_t>(dynamicStates.size());
    dynamicState.pDynamicStates = dynamicStates.data();

    VkViewport viewport{};
    viewport.x = 0.0f;
    viewport.y = 0.0f;
    viewport.width = (float) swapChainExtent.width;
    viewport.height = (float) swapChainExtent.height;
    viewport.minDepth = 0.0f;
    viewport.maxDepth = 1.0f;

    VkRect2D scissor{};
    scissor.offset = {0, 0};
    scissor.extent = swapChainExtent;

    VkPipelineViewportStateCreateInfo viewportState{};
    viewportState.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
    viewportState.viewportCount = 1;
    viewportState.pViewports = &viewport;
    viewportState.scissorCount = 1;
    viewportState.pScissors = &scissor;

    VkPipelineDepthStencilStateCreateInfo depthStencil{};
    depthStencil.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
    depthStencil.depthTestEnable = VK_TRUE;
    depthStencil.depthWriteEnable = VK_TRUE;
    depthStencil.depthCompareOp = VK_COMPARE_OP_ALWAYS;// this is a key change to other pipeline as means ui is always rendered (need to make sure in right order)
    depthStencil.depthBoundsTestEnable = VK_FALSE;
    depthStencil.minDepthBounds = 0.0f; // Optional
    depthStencil.maxDepthBounds = 1.0f; // Optional
    depthStencil.stencilTestEnable = VK_FALSE;
    depthStencil.front = {}; // Optional
    depthStencil.back = {}; // Optional

    VkPipelineRasterizationStateCreateInfo rasterizer{};
    rasterizer.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
    rasterizer.depthClampEnable = VK_FALSE;
    rasterizer.rasterizerDiscardEnable = VK_FALSE;
    rasterizer.polygonMode = VK_POLYGON_MODE_FILL;
    rasterizer.lineWidth = 1.0f; // cant be more than 1 without changing something (also dont use lines)
    rasterizer.cullMode = VK_CULL_MODE_NONE;// dont need to cull
    rasterizer.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;
    rasterizer.depthBiasEnable = VK_FALSE;
    rasterizer.depthBiasConstantFactor = 0.0f; // Optional
    rasterizer.depthBiasClamp = 0.0f; // Optional
    rasterizer.depthBiasSlopeFactor = 0.0f; // Optional

    VkPipelineMultisampleStateCreateInfo multisampling{};
    multisampling.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
    multisampling.sampleShadingEnable = VK_FALSE;
    multisampling.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
    multisampling.minSampleShading = 1.0f; // Optional
    multisampling.pSampleMask = nullptr; // Optional
    multisampling.alphaToCoverageEnable = VK_FALSE; // Optional
    multisampling.alphaToOneEnable = VK_FALSE; // Optional

    VkPipelineColorBlendAttachmentState colorBlendAttachment{};
    colorBlendAttachment.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
    colorBlendAttachment.blendEnable = VK_FALSE;
    colorBlendAttachment.srcColorBlendFactor = VK_BLEND_FACTOR_ONE; // Optional
    colorBlendAttachment.dstColorBlendFactor = VK_BLEND_FACTOR_ZERO; // Optional
    colorBlendAttachment.colorBlendOp = VK_BLEND_OP_ADD; // Optional
    colorBlendAttachment.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE; // Optional
    colorBlendAttachment.dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO; // Optional
    colorBlendAttachment.alphaBlendOp = VK_BLEND_OP_ADD; // Optional

    VkPipelineColorBlendStateCreateInfo colorBlending{};
    colorBlending.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
    colorBlending.logicOpEnable = VK_FALSE;
    colorBlending.logicOp = VK_LOGIC_OP_COPY; // Optional
    colorBlending.attachmentCount = 1;
    colorBlending.pAttachments = &colorBlendAttachment;
    colorBlending.blendConstants[0] = 0.0f; // Optional
    colorBlending.blendConstants[1] = 0.0f; // Optional
    colorBlending.blendConstants[2] = 0.0f; // Optional
    colorBlending.blendConstants[3] = 0.0f; // Optional

    // added to send model matrix per object using same format as main pipeline
    VkPushConstantRange pushConstRange;
    pushConstRange.offset = 0;// only 1 so use the start
    pushConstRange.size = sizeof(UIPushConstant);//128;// 8 vec4 is 4 byte per float *32 = 128
    pushConstRange.stageFlags = VK_SHADER_STAGE_VERTEX_BIT;// needs to be in vertex shader


    std::vector<VkDescriptorSetLayout> uidsl{uiDescriptorSetLayout, uiTextureDescriptorSetLayout};
    VkPipelineLayoutCreateInfo pipelineLayoutInfo{};
    pipelineLayoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
    pipelineLayoutInfo.setLayoutCount = uidsl.size();
    pipelineLayoutInfo.pSetLayouts = uidsl.data();
    pipelineLayoutInfo.pushConstantRangeCount = 1;
    pipelineLayoutInfo.pPushConstantRanges = &pushConstRange;

    if (vkCreatePipelineLayout(logicalDevice, &pipelineLayoutInfo, nullptr, &uiPipeLineLayout) != VK_SUCCESS) {
        throw std::runtime_error("failed to create pipeline layout!");
    }

    VkGraphicsPipelineCreateInfo pipelineInfo{};
    pipelineInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
    pipelineInfo.stageCount = 2;
    pipelineInfo.pStages = shaderStages;

    pipelineInfo.pVertexInputState = &vertexInputInfo;
    pipelineInfo.pInputAssemblyState = &inputAssembly;
    pipelineInfo.pViewportState = &viewportState;
    pipelineInfo.pRasterizationState = &rasterizer;
    pipelineInfo.pMultisampleState = &multisampling;
    pipelineInfo.pDepthStencilState = nullptr; // Optional
    pipelineInfo.pColorBlendState = &colorBlending;
    pipelineInfo.pDynamicState = &dynamicState;
    pipelineInfo.pDepthStencilState = &depthStencil;

    pipelineInfo.layout = uiPipeLineLayout;

    pipelineInfo.renderPass = renderPass;
    pipelineInfo.subpass = 0;

    pipelineInfo.basePipelineHandle = VK_NULL_HANDLE; // Optional
    pipelineInfo.basePipelineIndex = -1; // Optional


    if (vkCreateGraphicsPipelines(logicalDevice, VK_NULL_HANDLE, 1, &pipelineInfo, nullptr, &uiGraphicsPipeline) != VK_SUCCESS) {
        throw std::runtime_error("failed to create graphics pipeline!");
    }

    vkDestroyShaderModule(logicalDevice, fragShaderModule, nullptr);
    vkDestroyShaderModule(logicalDevice, vertShaderModule, nullptr);
}



void Program::createDesignRayCastingPipeline(){
    //std::vector<char> vertShaderCode = readFile("vulkan_shaders/voxel_shader_vert.spv");
    //std::vector<char> fragShaderCode = readFile("vulkan_shaders/voxel_shader_frag.spv");
    std::vector<char> vertShaderCode = readFile("vulkan_shaders/CSG_shader_vert.spv");
    std::vector<char> fragShaderCode = readFile("vulkan_shaders/CSG_shader_frag.spv");

    VkShaderModule vertShaderModule = createShaderModule(vertShaderCode);
    VkShaderModule fragShaderModule = createShaderModule(fragShaderCode);

    VkPipelineShaderStageCreateInfo vertShaderStageInfo{};
    vertShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
    vertShaderStageInfo.stage = VK_SHADER_STAGE_VERTEX_BIT;
    vertShaderStageInfo.module = vertShaderModule;
    vertShaderStageInfo.pName = "main";

    VkPipelineShaderStageCreateInfo fragShaderStageInfo{};
    fragShaderStageInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
    fragShaderStageInfo.stage = VK_SHADER_STAGE_FRAGMENT_BIT;
    fragShaderStageInfo.module = fragShaderModule;
    fragShaderStageInfo.pName = "main";


    VkPipelineShaderStageCreateInfo shaderStages[] = {vertShaderStageInfo, fragShaderStageInfo};


    VkPipelineVertexInputStateCreateInfo vertexInputInfo{};
    vertexInputInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
    auto bindingDescription = Vertex::getBindingDescription();
    auto attributeDescriptions = Vertex::getAttributeDescriptions();

    vertexInputInfo.vertexBindingDescriptionCount = 1;
    vertexInputInfo.vertexAttributeDescriptionCount = static_cast<uint32_t>(attributeDescriptions.size());
    vertexInputInfo.pVertexBindingDescriptions = &bindingDescription;
    vertexInputInfo.pVertexAttributeDescriptions = attributeDescriptions.data();

    VkPipelineInputAssemblyStateCreateInfo inputAssembly{};
    inputAssembly.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
    inputAssembly.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
    inputAssembly.primitiveRestartEnable = VK_FALSE;


    std::vector<VkDynamicState> dynamicStates = {
        VK_DYNAMIC_STATE_VIEWPORT,
        VK_DYNAMIC_STATE_SCISSOR
    };

    VkPipelineDynamicStateCreateInfo dynamicState{};
    dynamicState.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
    dynamicState.dynamicStateCount = static_cast<uint32_t>(dynamicStates.size());
    dynamicState.pDynamicStates = dynamicStates.data();

    VkViewport viewport{};
    viewport.x = 0.0f;
    viewport.y = 0.0f;
    viewport.width = (float) swapChainExtent.width;
    viewport.height = (float) swapChainExtent.height;
    viewport.minDepth = 0.0f;
    viewport.maxDepth = 1.0f;

    VkRect2D scissor{};
    scissor.offset = {0, 0};
    scissor.extent = swapChainExtent;

    VkPipelineViewportStateCreateInfo viewportState{};
    viewportState.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
    viewportState.viewportCount = 1;
    viewportState.pViewports = &viewport;
    viewportState.scissorCount = 1;
    viewportState.pScissors = &scissor;

    VkPipelineDepthStencilStateCreateInfo depthStencil{};
    depthStencil.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
    depthStencil.depthTestEnable = VK_TRUE;
    depthStencil.depthWriteEnable = VK_TRUE;
    depthStencil.depthCompareOp = VK_COMPARE_OP_LESS;
    depthStencil.depthBoundsTestEnable = VK_FALSE;
    depthStencil.minDepthBounds = 0.0f; // Optional
    depthStencil.maxDepthBounds = 1.0f; // Optional
    depthStencil.stencilTestEnable = VK_FALSE;
    depthStencil.front = {}; // Optional
    depthStencil.back = {}; // Optional

    VkPipelineRasterizationStateCreateInfo rasterizer{};
    rasterizer.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
    rasterizer.depthClampEnable = VK_FALSE;
    rasterizer.rasterizerDiscardEnable = VK_FALSE;
    rasterizer.polygonMode = VK_POLYGON_MODE_FILL;
    rasterizer.lineWidth = 1.0f; // cant be more than 1 without changing something (also dont use lines)
    rasterizer.cullMode = VK_CULL_MODE_FRONT_BIT;// significant change means only back faces render this means if inside it will still render
    rasterizer.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;
    rasterizer.depthBiasEnable = VK_FALSE;
    rasterizer.depthBiasConstantFactor = 0.0f; // Optional
    rasterizer.depthBiasClamp = 0.0f; // Optional
    rasterizer.depthBiasSlopeFactor = 0.0f; // Optional

    VkPipelineMultisampleStateCreateInfo multisampling{};
    multisampling.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
    multisampling.sampleShadingEnable = VK_FALSE;
    multisampling.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
    multisampling.minSampleShading = 1.0f; // Optional
    multisampling.pSampleMask = nullptr; // Optional
    multisampling.alphaToCoverageEnable = VK_FALSE; // Optional
    multisampling.alphaToOneEnable = VK_FALSE; // Optional

    VkPipelineColorBlendAttachmentState colorBlendAttachment{};
    colorBlendAttachment.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
    colorBlendAttachment.blendEnable = VK_FALSE;
    colorBlendAttachment.srcColorBlendFactor = VK_BLEND_FACTOR_ONE; // Optional
    colorBlendAttachment.dstColorBlendFactor = VK_BLEND_FACTOR_ZERO; // Optional
    colorBlendAttachment.colorBlendOp = VK_BLEND_OP_ADD; // Optional
    colorBlendAttachment.srcAlphaBlendFactor = VK_BLEND_FACTOR_ONE; // Optional
    colorBlendAttachment.dstAlphaBlendFactor = VK_BLEND_FACTOR_ZERO; // Optional
    colorBlendAttachment.alphaBlendOp = VK_BLEND_OP_ADD; // Optional

    VkPipelineColorBlendStateCreateInfo colorBlending{};
    colorBlending.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
    colorBlending.logicOpEnable = VK_FALSE;
    colorBlending.logicOp = VK_LOGIC_OP_COPY; // Optional
    colorBlending.attachmentCount = 1;
    colorBlending.pAttachments = &colorBlendAttachment;
    colorBlending.blendConstants[0] = 0.0f; // Optional
    colorBlending.blendConstants[1] = 0.0f; // Optional
    colorBlending.blendConstants[2] = 0.0f; // Optional
    colorBlending.blendConstants[3] = 0.0f; // Optional

    // added to send model matrix per object using same format as main pipeline is used unlike in main
    VkPushConstantRange pushConstRange;
    pushConstRange.offset = 0;// only 1 so use the start
    pushConstRange.size = sizeof(MatrixPushConstant);//64;// 4 vec4 is 4 byte per float *16 = 64
    pushConstRange.stageFlags = VK_SHADER_STAGE_VERTEX_BIT;// needs to be in vertex shader


    std::vector<VkDescriptorSetLayout> dsLayouts = {designDSLayout, designDataDSLayout};

    VkPipelineLayoutCreateInfo pipelineLayoutInfo{};
    pipelineLayoutInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
    pipelineLayoutInfo.setLayoutCount = dsLayouts.size();
    pipelineLayoutInfo.pSetLayouts = dsLayouts.data();
    pipelineLayoutInfo.pushConstantRangeCount = 1;
    pipelineLayoutInfo.pPushConstantRanges = &pushConstRange;

    if (vkCreatePipelineLayout(logicalDevice, &pipelineLayoutInfo, nullptr, &designPipelineLayout) != VK_SUCCESS) {
        throw std::runtime_error("failed to create pipeline layout!");
    }

    VkGraphicsPipelineCreateInfo pipelineInfo{};
    pipelineInfo.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
    pipelineInfo.stageCount = 2;
    pipelineInfo.pStages = shaderStages;

    pipelineInfo.pVertexInputState = &vertexInputInfo;
    pipelineInfo.pInputAssemblyState = &inputAssembly;
    pipelineInfo.pViewportState = &viewportState;
    pipelineInfo.pRasterizationState = &rasterizer;
    pipelineInfo.pMultisampleState = &multisampling;
    pipelineInfo.pDepthStencilState = nullptr; // Optional
    pipelineInfo.pColorBlendState = &colorBlending;
    pipelineInfo.pDynamicState = &dynamicState;
    pipelineInfo.pDepthStencilState = &depthStencil;

    pipelineInfo.layout = designPipelineLayout;

    pipelineInfo.renderPass = renderPass;
    pipelineInfo.subpass = 0;

    pipelineInfo.basePipelineHandle = VK_NULL_HANDLE; // Optional
    pipelineInfo.basePipelineIndex = -1; // Optional


    if (vkCreateGraphicsPipelines(logicalDevice, VK_NULL_HANDLE, 1, &pipelineInfo, nullptr, &designGraphicsPipeline) != VK_SUCCESS) {
        throw std::runtime_error("failed to create graphics pipeline!");
    }

    vkDestroyShaderModule(logicalDevice, fragShaderModule, nullptr);
    vkDestroyShaderModule(logicalDevice, vertShaderModule, nullptr);
}

std::vector<char> Program::readFile(const std::string& filename) {
    std::ifstream file(filename, std::ios::ate | std::ios::binary);//start reading from end so know how big it is

    if (!file.is_open()) {
        throw std::runtime_error("failed to open file!");
    }

    size_t fileSize = (size_t) file.tellg();
    std::vector<char> buffer(fileSize);

    file.seekg(0);
    file.read(buffer.data(), fileSize);

    file.close();

    return buffer;
}

VkShaderModule Program::createShaderModule(const std::vector<char>& code) {
    VkShaderModuleCreateInfo createInfo{};
    createInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
    createInfo.codeSize = code.size();
    createInfo.pCode = reinterpret_cast<const uint32_t*>(code.data());

    VkShaderModule shaderModule;
    if (vkCreateShaderModule(logicalDevice, &createInfo, nullptr, &shaderModule) != VK_SUCCESS) {
        throw std::runtime_error("failed to create shader module!");
    }
    return shaderModule;
}

void Program::createDepthResources(){
    VkFormat depthFormat = findDepthFormat();
    createImage(swapChainExtent.width, swapChainExtent.height, depthFormat, VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, depthImage, depthImageMemory);
    depthImageView = createImageView(depthImage, depthFormat,VK_IMAGE_ASPECT_DEPTH_BIT);

}

void Program::createImage(uint32_t width, uint32_t height, VkFormat format, VkImageTiling tiling, VkImageUsageFlags usage, VkMemoryPropertyFlags properties, VkImage& image, VkDeviceMemory& imageMemory) {
    VkImageCreateInfo imageInfo{};
    imageInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
    imageInfo.imageType = VK_IMAGE_TYPE_2D;
    imageInfo.extent.width = width;
    imageInfo.extent.height = height;
    imageInfo.extent.depth = 1;
    imageInfo.mipLevels = 1;
    imageInfo.arrayLayers = 1;
    imageInfo.format = format;
    imageInfo.tiling = tiling;
    imageInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
    imageInfo.usage = usage;
    imageInfo.samples = VK_SAMPLE_COUNT_1_BIT;
    imageInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;

    if (vkCreateImage(logicalDevice, &imageInfo, nullptr, &image) != VK_SUCCESS){
        throw std::runtime_error("failed to create image!");
    }

    VkMemoryRequirements memRequirements;
    vkGetImageMemoryRequirements(logicalDevice, image, &memRequirements);

    VkMemoryAllocateInfo allocInfo{};
    allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
    allocInfo.allocationSize = memRequirements.size;
    allocInfo.memoryTypeIndex = findMemoryType(memRequirements.memoryTypeBits, properties);

    if (vkAllocateMemory(logicalDevice, &allocInfo, nullptr, &imageMemory) != VK_SUCCESS){
        throw std::runtime_error("failed to allocate image memory!");
    }

    vkBindImageMemory(logicalDevice, image, imageMemory, 0);
}

uint32_t Program::findMemoryType(uint32_t typeFilter, VkMemoryPropertyFlags properties){
    VkPhysicalDeviceMemoryProperties memProperties;
    vkGetPhysicalDeviceMemoryProperties(physicalDevice, &memProperties);

    for (uint32_t i = 0; i < memProperties.memoryTypeCount; i++) {
        if (typeFilter & (1 << i) && (memProperties.memoryTypes[i].propertyFlags & properties) == properties){
            return i;
        }
    }

    throw std::runtime_error("failed to find suitable memory type!");
}

void Program::createTextureImage(){
    int texWidth, texHeight, texChannels;
    stbi_uc* pixels = stbi_load("images/sprite_sheet.png", &texWidth, &texHeight, &texChannels, STBI_rgb_alpha);// get info about image
    VkDeviceSize imageSize = texWidth * texHeight * 4;

    if (!pixels) {
        throw std::runtime_error("failed to load texture image!");
    }

    VkBuffer stagingBuffer;
    VkDeviceMemory stagingBufferMemory;

    createBuffer(imageSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, stagingBuffer, stagingBufferMemory);

    void* data;
    vkMapMemory(logicalDevice, stagingBufferMemory, 0, imageSize, 0, &data);// copy the stb image to the staging buffer
    memcpy(data, pixels, static_cast<size_t>(imageSize));
    vkUnmapMemory(logicalDevice, stagingBufferMemory);

    stbi_image_free(pixels);// delete the stb image

    createImage(texWidth, texHeight, VK_FORMAT_R8G8B8A8_SRGB, VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, textureImage, textureImageMemory);

    transitionImageLayout(textureImage, VK_FORMAT_R8G8B8A8_SRGB, VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
    copyBufferToImage(stagingBuffer, textureImage, static_cast<uint32_t>(texWidth), static_cast<uint32_t>(texHeight));
    transitionImageLayout(textureImage, VK_FORMAT_R8G8B8A8_SRGB, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);

    vkDestroyBuffer(logicalDevice, stagingBuffer, nullptr);
    vkFreeMemory(logicalDevice, stagingBufferMemory, nullptr);
}

void Program::createTextureImageView(){
    textureImageView = createImageView(textureImage, VK_FORMAT_R8G8B8A8_SRGB,VK_IMAGE_ASPECT_COLOR_BIT);
}

void Program::createTextureSampler(){
    VkSamplerCreateInfo samplerInfo{};
    samplerInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
    samplerInfo.magFilter = VK_FILTER_LINEAR;
    samplerInfo.minFilter = VK_FILTER_LINEAR;
    samplerInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_REPEAT;
    samplerInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_REPEAT;
    samplerInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_REPEAT;
    samplerInfo.anisotropyEnable = VK_TRUE;

    VkPhysicalDeviceProperties properties{};
    vkGetPhysicalDeviceProperties(physicalDevice, &properties);
    samplerInfo.maxAnisotropy = properties.limits.maxSamplerAnisotropy;

    samplerInfo.borderColor = VK_BORDER_COLOR_INT_OPAQUE_BLACK;
    samplerInfo.unnormalizedCoordinates = VK_FALSE;
    samplerInfo.compareEnable = VK_FALSE;
    samplerInfo.compareOp = VK_COMPARE_OP_ALWAYS;

    samplerInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
    samplerInfo.mipLodBias = 0.0f;
    samplerInfo.minLod = 0.0f;
    samplerInfo.maxLod = 0.0f;

    if (vkCreateSampler(logicalDevice, &samplerInfo, nullptr, &textureSampler) != VK_SUCCESS) {
        throw std::runtime_error("failed to create texture sampler!");
    }
}

void Program::transitionImageLayout(VkImage image, VkFormat format, VkImageLayout oldLayout, VkImageLayout newLayout){
    VkCommandBuffer commandBuffer = beginSingleTimeCommands();

    VkImageMemoryBarrier barrier{};
    barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
    barrier.oldLayout = oldLayout;
    barrier.newLayout = newLayout;
    barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
    barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
    barrier.image = image;
    barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
    barrier.subresourceRange.baseMipLevel = 0;
    barrier.subresourceRange.levelCount = 1;
    barrier.subresourceRange.baseArrayLayer = 0;
    barrier.subresourceRange.layerCount = 1;
    barrier.srcAccessMask = 0;// done below in if statements
    barrier.dstAccessMask = 0;// done below in if statements

    VkPipelineStageFlags sourceStage;
    VkPipelineStageFlags destinationStage;

    if (oldLayout == VK_IMAGE_LAYOUT_UNDEFINED && newLayout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL) {
        barrier.srcAccessMask = 0;
        barrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;

        sourceStage = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
        destinationStage = VK_PIPELINE_STAGE_TRANSFER_BIT;
    } else if (oldLayout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL && newLayout == VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL) {
        barrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
        barrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;

        sourceStage = VK_PIPELINE_STAGE_TRANSFER_BIT;
        destinationStage = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
    } else {
        throw std::invalid_argument("unsupported layout transition!");
    }

    vkCmdPipelineBarrier(
        commandBuffer,
        sourceStage , destinationStage ,
        0,
        0, nullptr,
        0, nullptr,
        1, &barrier
    );

    endSingleTimeCommands(commandBuffer);
}

void Program::copyBufferToImage(VkBuffer buffer, VkImage image, uint32_t width, uint32_t height){
    VkCommandBuffer commandBuffer = beginSingleTimeCommands();

    VkBufferImageCopy region{};
    region.bufferOffset = 0;
    region.bufferRowLength = 0;
    region.bufferImageHeight = 0;

    region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
    region.imageSubresource.mipLevel = 0;
    region.imageSubresource.baseArrayLayer = 0;
    region.imageSubresource.layerCount = 1;

    region.imageOffset = {0, 0, 0};
    region.imageExtent = {
        width,
        height,
        1
    };

    vkCmdCopyBufferToImage(
        commandBuffer,
        buffer,
        image,
        VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
        1,
        &region
    );


    endSingleTimeCommands(commandBuffer);
}

VkCommandBuffer Program::beginSingleTimeCommands() {
    VkCommandBufferAllocateInfo allocInfo{};
    allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
    allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
    allocInfo.commandPool = commandPool;
    allocInfo.commandBufferCount = 1;

    VkCommandBuffer commandBuffer;
    vkAllocateCommandBuffers(logicalDevice, &allocInfo, &commandBuffer);

    VkCommandBufferBeginInfo beginInfo{};
    beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
    beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;

    vkBeginCommandBuffer(commandBuffer, &beginInfo);

    return commandBuffer;
}

void Program::endSingleTimeCommands(VkCommandBuffer commandBuffer) {
    vkEndCommandBuffer(commandBuffer);

    VkSubmitInfo submitInfo{};
    submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
    submitInfo.commandBufferCount = 1;
    submitInfo.pCommandBuffers = &commandBuffer;

    vkQueueSubmit(graphicsQueue, 1, &submitInfo, VK_NULL_HANDLE);
    vkQueueWaitIdle(graphicsQueue);

    vkFreeCommandBuffers(logicalDevice, commandPool, 1, &commandBuffer);
}

void Program::createFramebuffers(){
    swapChainFramebuffers.resize(swapChainImageViews.size());
    for (int i = 0; i < swapChainImageViews.size(); i++){
        std::array<VkImageView,2> attachments = {
            swapChainImageViews[i],
            depthImageView
        };

        VkFramebufferCreateInfo framebufferInfo{};
        framebufferInfo.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
        framebufferInfo.renderPass = renderPass;
        framebufferInfo.attachmentCount = static_cast<uint32_t>(attachments.size());
        framebufferInfo.pAttachments = attachments.data();
        framebufferInfo.width = swapChainExtent.width;
        framebufferInfo.height = swapChainExtent.height;
        framebufferInfo.layers = 1;

        if (vkCreateFramebuffer(logicalDevice, &framebufferInfo, nullptr, &swapChainFramebuffers[i]) != VK_SUCCESS) {
            throw std::runtime_error("failed to create framebuffers");
        }
    }
}

void Program::createBuffer(VkDeviceSize size, VkBufferUsageFlags usage,VkMemoryPropertyFlags properties, VkBuffer &returnBuffer, VkDeviceMemory &returnBufferMemory){
    VkBufferCreateInfo bufferInfo{};
    bufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
    bufferInfo.size = size;
    bufferInfo.usage = usage;
    bufferInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
    std::cout << bufferInfo.usage << " usage flags\n";
    if (vkCreateBuffer(logicalDevice, &bufferInfo, nullptr, &returnBuffer) != VK_SUCCESS){
        throw std::runtime_error("failed to create vertex buffer!");
    }

    VkMemoryRequirements memRequirements;
    vkGetBufferMemoryRequirements(logicalDevice, returnBuffer, &memRequirements);

    VkMemoryAllocateInfo allocInfo{};
    allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
    allocInfo.allocationSize = memRequirements.size;
    allocInfo.memoryTypeIndex = findMemoryType(memRequirements.memoryTypeBits, properties);

    if (vkAllocateMemory(logicalDevice, &allocInfo, nullptr, &returnBufferMemory) != VK_SUCCESS){
        throw std::runtime_error("failed to allocate vertex buffer memory!");
    }


    vkBindBufferMemory(logicalDevice, returnBuffer, returnBufferMemory, 0);
}

void Program::copyBuffer(VkBuffer srcBuffer, VkBuffer dstBuffer, VkDeviceSize size){

    VkCommandBuffer commandBuffer = beginSingleTimeCommands();

    VkBufferCopy copyRegion{};
    copyRegion.srcOffset = 0; // Optional
    copyRegion.dstOffset = 0; // Optional
    copyRegion.size = size;
    vkCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, 1, &copyRegion);

    endSingleTimeCommands(commandBuffer);
}

void Program::createBuffers(){
    VkDeviceSize bufferSize;
    const int MAX_NUM_OBJS = 16384;
    const int MAX_NUM_VOXELS = 128*128*128;
    const int MAX_NODE_NUM = 512;
    const int MAX_PRIM_SIZE = 16384;

    const std::vector<int> numBuffers = {1,1,1,1,1,1};// num of type, ......
    const std::vector<VkDeviceSize> sizeBuffers = {sizeof( MatricesUBO )
                                                    ,sizeof( LightUBO )
                                                    ,(sizeof( PerObjectData )* MAX_NUM_OBJS)
                                                    //,sizeof( VoxelMetaData )
                                                    //,(sizeof( VoxelData )* MAX_NUM_VOXELS)
                                                    ,sizeof( CSGMetaData )
                                                    ,(sizeof( NodeData )* MAX_NUM_VOXELS)
                                                    ,(sizeof( NodeData )* MAX_NODE_NUM)
                                                    };// sizeof type , ......
    const std::vector<VkBufferUsageFlagBits> usageOfBuffers = {VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT
                                                            , VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT
                                                            , VK_BUFFER_USAGE_STORAGE_BUFFER_BIT
                                                            , VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT
                                                            , VK_BUFFER_USAGE_STORAGE_BUFFER_BIT
                                                            , VK_BUFFER_USAGE_STORAGE_BUFFER_BIT};// there is an extra storage buffer here for CSG rendering

    std::vector<int> cumulativeSum = {0};
    for (int i = 0; i < numBuffers.size(); i++){// work out how many i need and how many will be finished by the time i finish a type
        cumulativeSum.push_back(numBuffers[i]*MAX_FRAMES_IN_FLIGHT +cumulativeSum[i]);
    }

    buffers.resize(cumulativeSum[cumulativeSum.size()-1]);
    buffersMemory.resize(cumulativeSum[cumulativeSum.size()-1]);
    buffersMapped.resize(cumulativeSum[cumulativeSum.size()-1]);

    int index = 0;

    for (int i = 0; i < cumulativeSum[cumulativeSum.size()-1]; i++){
        while (cumulativeSum[index] <= i){
            index++;
            bufferSize = sizeBuffers[index-1];
        }
        std::cout << usageOfBuffers[index-1] << "\n";
        std::cout << i << "\n";
        std::cout << index << "\n";
        createBuffer(bufferSize, usageOfBuffers[index-1], VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, buffers[i], buffersMemory[i]);

        vkMapMemory(logicalDevice, buffersMemory[i], 0, bufferSize, 0, &buffersMapped[i]);
    }
}

void Program::createDescriptorPool(){
    std::array<VkDescriptorPoolSize,3> poolSizes{};
    poolSizes[0].type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
    poolSizes[0].descriptorCount = static_cast<uint32_t>(MAX_FRAMES_IN_FLIGHT *16);
    poolSizes[1].type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
    poolSizes[1].descriptorCount = static_cast<uint32_t>(MAX_FRAMES_IN_FLIGHT *4);
    poolSizes[2].type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
    poolSizes[2].descriptorCount = static_cast<uint32_t>(MAX_FRAMES_IN_FLIGHT);

    VkDescriptorPoolCreateInfo poolInfo{};
    poolInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
    poolInfo.poolSizeCount = static_cast<uint32_t>(poolSizes.size());
    poolInfo.pPoolSizes = poolSizes.data();

    poolInfo.maxSets = static_cast<uint32_t>(MAX_FRAMES_IN_FLIGHT *21);

    if (vkCreateDescriptorPool(logicalDevice, &poolInfo, nullptr, &descriptorPool) != VK_SUCCESS) {
        throw std::runtime_error("failed to create descriptor pool!");
    }

}

void Program::createDescriptorSet(std::vector<int> indexes, std::vector<VkDescriptorSet> &descriptorSetVecRef, VkDescriptorSetLayout &descriptorSetLayoutRef
                                , std::vector<VkDeviceSize> sizes, std::vector<VkDescriptorType> types, std::vector<VkImageView> imageViews, std::vector<VkSampler> imageSamplers){
    std::vector<VkDescriptorSetLayout> layouts(MAX_FRAMES_IN_FLIGHT, descriptorSetLayoutRef);
    VkDescriptorSetAllocateInfo allocInfo{};
    allocInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
    allocInfo.descriptorPool = descriptorPool;
    allocInfo.descriptorSetCount = static_cast<uint32_t>(MAX_FRAMES_IN_FLIGHT);
    allocInfo.pSetLayouts = layouts.data();

    descriptorSetVecRef.resize(MAX_FRAMES_IN_FLIGHT);
    if (vkAllocateDescriptorSets(logicalDevice, &allocInfo, descriptorSetVecRef.data()) != VK_SUCCESS) {
        throw std::runtime_error("failed to allocate descriptor sets!");
    }

    for (size_t i = 0; i < MAX_FRAMES_IN_FLIGHT; i++) {
        std::vector<VkWriteDescriptorSet> descriptorWrites{};
        for (int j = 0; j < types.size(); j++){
            descriptorWrites.push_back(VkWriteDescriptorSet{});

            descriptorWrites[j].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
            descriptorWrites[j].dstSet = descriptorSetVecRef[i];
            descriptorWrites[j].dstBinding = j;
            descriptorWrites[j].dstArrayElement = 0;

            descriptorWrites[j].descriptorType = types[j];
            descriptorWrites[j].descriptorCount = 1;


            VkDescriptorBufferInfo* bufferInfo = new VkDescriptorBufferInfo{};
            VkDescriptorImageInfo* imageInfo = new VkDescriptorImageInfo{};
            switch (types[j])
            {
            case VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER:
            case VK_DESCRIPTOR_TYPE_STORAGE_BUFFER:
                bufferInfo->buffer = buffers[MAX_FRAMES_IN_FLIGHT*(indexes[j]) + i];
                bufferInfo->offset = 0;
                bufferInfo->range = sizes[j];

                descriptorWrites[j].pBufferInfo = bufferInfo;
                descriptorWrites[j].pImageInfo = nullptr; // Optional
                descriptorWrites[j].pTexelBufferView = nullptr; // Optional

                delete imageInfo;
                break;

            case VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER:
                imageInfo->imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
                imageInfo->imageView = imageViews[j];
                imageInfo->sampler = imageSamplers[j];

                descriptorWrites[j].pBufferInfo = nullptr; // Optional
                descriptorWrites[j].pImageInfo = imageInfo;
                descriptorWrites[j].pTexelBufferView = nullptr; // Optional

                delete bufferInfo;
                break;

            default:
                break;
            }
        }

        vkUpdateDescriptorSets(logicalDevice, static_cast<uint32_t>(descriptorWrites.size()), descriptorWrites.data(), 0, nullptr);
        for (int j = 0; j < descriptorWrites.size(); j++){// deal with memory leak
            delete descriptorWrites[j].pBufferInfo;
        }
        for (int j = 0; j < descriptorWrites.size(); j++){// deal with memory leak
            delete descriptorWrites[j].pImageInfo;
        }
    }
}

void Program::createDescriptorSets(){
    std::cout << "ds 1\n";
    std::vector<int> indexes1 = {0,1};
    std::vector<VkDeviceSize> sizes1 = {sizeof(MatricesUBO), sizeof(LightUBO)};
    std::vector<VkDescriptorType> types1 = {VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER};
    createDescriptorSet(indexes1,descriptorSets,descriptorSetLayout,sizes1,types1,{},{});

    std::cout << "ds 2\n";
    std::vector<int> indexes2 = {};
    std::vector<VkDeviceSize> sizes2 = {};
    std::vector<VkDescriptorType> types2 = {};
    createDescriptorSet(indexes2,uiDescriptorSets,uiDescriptorSetLayout,sizes2,types2,{},{});

    std::cout << "ds 3\n";
    std::vector<VkImageView> imageViews3 = {textureImageView};
    std::vector<VkSampler> imageSamplers3 = {textureSampler};
    std::vector<VkDescriptorType> types3 = {VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER};
    createDescriptorSet({},uiTextureDescriptorSets,uiTextureDescriptorSetLayout,{},types3,imageViews3,imageSamplers3);

    std::cout << "ds 4\n";
    const int MAX_NUM_OBJS = 16384;
    std::vector<int> indexes4 = {2};
    std::vector<VkDeviceSize> sizes4 = {sizeof(PerObjectData)*MAX_NUM_OBJS};
    std::vector<VkDescriptorType> types4 = {VK_DESCRIPTOR_TYPE_STORAGE_BUFFER};
    createDescriptorSet(indexes4,objDataDescriptorSets,perObjectDataDSLayout,sizes4,types4,{},{});

    std::cout << "ds 5\n";
    std::vector<int> indexes5 = {0,3,1};
    //std::vector<VkDeviceSize> sizes5 = {sizeof(MatricesUBO), sizeof(VoxelMetaData), sizeof(LightUBO)};
    std::vector<VkDeviceSize> sizes5 = {sizeof(MatricesUBO), sizeof(CSGMetaData), sizeof(LightUBO)};
    std::vector<VkDescriptorType> types5 = {VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER};
    createDescriptorSet(indexes5,designDescriptorSets,designDSLayout,sizes5,types5,{},{});

    std::cout << "ds 6\n";
    const int MAX_NUM_VOXELS = 128*128*128;
    const int MAX_NODE_NUM = 512;
    const int MAX_PRIM_SIZE = 16384;
    std::vector<int> indexes6 = {4,5};// added the 5 here for CSG rendering
    //std::vector<VkDeviceSize> sizes6 = {sizeof(VoxelData)*MAX_NUM_VOXELS};
    std::vector<VkDeviceSize> sizes6 = {sizeof(PrimitiveData)*MAX_PRIM_SIZE, sizeof(NodeData)*MAX_NODE_NUM};
    //std::vector<VkDescriptorType> types6 = {VK_DESCRIPTOR_TYPE_STORAGE_BUFFER};
    std::vector<VkDescriptorType> types6 = {VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,VK_DESCRIPTOR_TYPE_STORAGE_BUFFER};
    createDescriptorSet(indexes6,designDataDescriptorSets,designDataDSLayout,sizes6,types6,{},{});
}

void Program::createCommandBuffers(){
    commandBuffers.resize(MAX_FRAMES_IN_FLIGHT);


    VkCommandBufferAllocateInfo allocInfo{};
    allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
    allocInfo.commandPool = commandPool;
    allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
    allocInfo.commandBufferCount = (uint32_t) commandBuffers.size();

    if (vkAllocateCommandBuffers(logicalDevice, &allocInfo, commandBuffers.data()) != VK_SUCCESS) {
        throw std::runtime_error("failed to allocate command buffers!");
    }
}

void Program::createSyncObjects(){
    imageAvailableSemaphores.resize(MAX_FRAMES_IN_FLIGHT);
    renderFinishedSemaphores.resize(MAX_FRAMES_IN_FLIGHT);
    inFlightFences.resize(MAX_FRAMES_IN_FLIGHT);



    VkSemaphoreCreateInfo semaphoreInfo{};
    semaphoreInfo.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;

    VkFenceCreateInfo fenceInfo{};
    fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
    fenceInfo.flags = VK_FENCE_CREATE_SIGNALED_BIT;

    for (int i = 0; i < MAX_FRAMES_IN_FLIGHT; i++){
        if (vkCreateSemaphore(logicalDevice, &semaphoreInfo, nullptr, &imageAvailableSemaphores[i]) != VK_SUCCESS ||
            vkCreateSemaphore(logicalDevice, &semaphoreInfo, nullptr, &renderFinishedSemaphores[i]) != VK_SUCCESS ||
            vkCreateFence(logicalDevice, &fenceInfo, nullptr, &inFlightFences[i]) != VK_SUCCESS) {
            throw std::runtime_error("failed to create semaphores!");
        }
    }
}

// for things which need to be set up but must be done after the vulkan is set up
void Program::finishedSetUpBits(){
    const float zVal = 0;
    std::vector<Vertex> uiV{
        {{-1,-1,zVal},{0,0,0},{1,1,1}},
        {{-1,1,zVal},{0,1,0},{1,1,1}},
        {{1,-1,zVal},{1,0,0},{1,1,1}},
        {{1,1,zVal},{1,1,0},{1,1,1}}
    };
    std::vector<uint16_t> uiI{
        0,1,2,
        1,2,3
    };
    rectModel = new Model(verticesMemManager,indicesMemManager,uiV,uiI);

    const float size = 64;
    const std::vector<Vertex> voxV = {
        {{-size, -size, size}, {-1.0,-1.0,1.0}, {1.0f, 1.0f, 1.0f}},
        {{size, -size, size}, {1.0,-1.0,1.0}, {1.0f, 1.0f, 1.0f}},
        {{size, size, size}, {1.0,1.0,1.0}, {1.0f, 1.0f, 1.0f}},
        {{-size, size, size}, {-1.0,1.0,1.0}, {1.0f, 1.0f, 1.0f}},
        {{-size, -size, -size}, {-1.0,-1.0,-1.0}, {1.0f, 1.0f, 1.0f}},
        {{size, -size, -size}, {1.0,-1.0,-1.0}, {1.0f, 1.0f, 1.0f}},
        {{size, size, -size}, {1.0,1.0,-1.0}, {1.0f, 1.0f, 1.0f}},
        {{-size, size, -size}, {-1.0,1.0,-1.0}, {1.0f, 1.0f, 1.0f}}};
    const std::vector<uint16_t> voxI = {
        //0, 1, 2, 2, 3, 0
        3,0,1,
        5,4,7,
        1,0,4,
        2,1,5,
        7,3,2,
        7,4,0,
        2,3,1,
        6,5,7,
        5,1,4,
        6,2,5,
        6,7,2,
        3,7,0};

    designModel = new Model(verticesMemManager, indicesMemManager, voxV, voxI);

    /*for (int currentImage = 0; currentImage < MAX_FRAMES_IN_FLIGHT; currentImage++){

        VoxelData* voxelDataSSBO = (VoxelData*)buffersMapped[currentImage+4*MAX_FRAMES_IN_FLIGHT];
        for (int i = 0; i < 128; i++){
            for (int j = 0; j < 128; j++){
                for (int k = 0; k < 128; k++){
                    voxelDataSSBO[i*128*128+j*128+k].type = 0;
                }
            }
        }
        // need speed so not just copy everything only changes;
    }*/
}

void Program::addUIElement(UIElement* e){
    uiElements.push_back(e);
}

void Program::removeUIElement(UIElement* e){
    bool found = false;
    for (int i = 0; i < uiElements.size(); i++){
        if (found){
            uiElements[i-1] = uiElements[i];
        }
        else if (uiElements[i] == e){
            delete uiElements[i];
            found = true;
        }
    }
    if (found){
        uiElements.pop_back();
    }
}

bool Program::uiUpdate(){
    //glm::vec3 forward = (mainCamera->getViewMatrix()*glm::vec4(0.0,1.0,0.0,0.0));
    //std::cout << forward[0] << " " << forward[1] << " " << forward[2] << "\n";
    double xPos,yPos;
    glfwGetCursorPos(window,&xPos,&yPos);
    int newState = glfwGetMouseButton(window, GLFW_MOUSE_BUTTON_LEFT);
    //std::cout << newState << "\n";
    xPos = (xPos/swapChainExtent.width)*2 -1;
    yPos = (yPos/swapChainExtent.height)*2 -1;
    //std::cout << xPos << " " << yPos << "\n";
    bool didSomething = false;
    for (int i = uiElements.size()-1; i >= 0; i--){// the order is opposite to order of rendering
        if (uiElements[i]->onElement(xPos,yPos) && uiElements[i]->getActive()){
            didSomething = true;
            if (newState == GLFW_RELEASE && oldMouseState == GLFW_PRESS){// only triggers when releasing the mouse button and on button
                uiElements[i]->clickOn();
            }
        }
    }
    oldMouseState = newState;
    return didSomething;
}

void Program::openMainLoop(){
    mainCamera->moveTo(glm::vec3(-32,0,6));
    for (UIElement* uiE: uiElements){
        delete uiE;
    }
    uiElements.clear();

    float size = 0.5;
    const std::vector<Vertex> vertices = {
        {{-size, -size, size}, {-0.0,-0.0,1.0}, {1.0f, 1.0f, 1.0f}},
        {{size, -size, size}, {0.0,-0.0,1.0}, {1.0f, 1.0f, 1.0f}},
        {{size, size, size}, {0.0,0.0,1.0}, {1.0f, 1.0f, 1.0f}},
        {{-size, size, size}, {-0.0,0.0,1.0}, {1.0f, 1.0f, 1.0f}},
        {{-size, -size, -size}, {-0.0,-0.0,-1.0}, {1.0f, 1.0f, 1.0f}},
        {{size, -size, -size}, {0.0,-0.0,-1.0}, {1.0f, 1.0f, 1.0f}},
        {{size, size, -size}, {0.0,0.0,-1.0}, {1.0f, 1.0f, 1.0f}},
        {{-size, size, -size}, {-0.0,0.0,-1.0}, {1.0f, 1.0f, 1.0f}},

        {{-size, -size, size}, {-0.0,-1.0,0.0}, {1.0f, 1.0f, 1.0f}},
        {{size, -size, size}, {0.0,-1.0,0.0}, {1.0f, 1.0f, 1.0f}},
        {{size, size, size}, {0.0,1.0,0.0}, {1.0f, 1.0f, 1.0f}},
        {{-size, size, size}, {-0.0,1.0,0.0}, {1.0f, 1.0f, 1.0f}},
        {{-size, -size, -size}, {-0.0,-1.0,-0.0}, {1.0f, 1.0f, 1.0f}},
        {{size, -size, -size}, {0.0,-1.0,-0.0}, {1.0f, 1.0f, 1.0f}},
        {{size, size, -size}, {0.0,1.0,-0.0}, {1.0f, 1.0f, 1.0f}},
        {{-size, size, -size}, {-0.0,1.0,-0.0}, {1.0f, 1.0f, 1.0f}},

        {{-size, -size, size}, {-1.0,-0.0,0.0}, {1.0f, 1.0f, 1.0f}},
        {{size, -size, size}, {1.0,-0.0,0.0}, {1.0f, 1.0f, 1.0f}},
        {{size, size, size}, {1.0,0.0,0.0}, {1.0f, 1.0f, 1.0f}},
        {{-size, size, size}, {-1.0,0.0,0.0}, {1.0f, 1.0f, 1.0f}},
        {{-size, -size, -size}, {-1.0,-0.0,-0.0}, {1.0f, 1.0f, 1.0f}},
        {{size, -size, -size}, {1.0,-0.0,-0.0}, {1.0f, 1.0f, 1.0f}},
        {{size, size, -size}, {1.0,0.0,-0.0}, {1.0f, 1.0f, 1.0f}},
        {{-size, size, -size}, {-1.0,0.0,-0.0}, {1.0f, 1.0f, 1.0f}}};
    /*const std::vector<uint16_t> indices = {// old simple model
        3,0,1,
        5,4,7,
        1,0,4,
        2,1,5,
        7,3,2,
        7,4,0,
        2,3,1,
        6,5,7,
        5,1,4,
        6,2,5,
        6,7,2,
        3,7,0};*/

    const std::vector<uint16_t> indices = {
        3,0,1,
        5,4,7,
        9,8,12,// add 8
        18,17,21,// add 16
        15,11,10,// add 8
        23,20,16,// add 16
        2,3,1,
        6,5,7,
        13,9,12,// add 8
        22,18,21,// add 16
        14,15,10,// add 8
        19,23,16// add 16
    };

    for (int i = 0; i < 3; i++){
        for (int j = 0; j < 3; j++){
            for (int k = 0; k < 12; k++){
                glm::vec3 pos = glm::vec3(3.0*i +0.05*sin(12987491.0*k + 839201.0*i + 940373.0*j),3.0*j-3+0.05*sin(427843102.0*k + 4832943.0*i + 2971903.0*j),1.5 + 1.5*k);
                glm::vec4 rot = glm::vec4(0.0,0.0,cos(i),sin(i));
                glm::mat3x3 rotInertia = glm::mat3x3(1/12.0);
                addRigidBody(vertices, indices, rot, pos,rotInertia);
            }
        }
    }


    bool startDesignMainLoop = false;
    std::cout << "hi\n";
    uiElements.push_back(new UIElement(this,-0.65,-0.7,0.4,0.2 , 0.5,0.2,0.1,0.5));
    auto start = [&startDesignMainLoop] () {
        startDesignMainLoop = true;
    };
    uiElements[0]->setClickOnFunc(std::bind(start));
    uiElements[0]->setText(std::string("start"),1.6);

    struct timeval timeSinceEpoch;
    gettimeofday(&timeSinceEpoch, NULL);
    long int currentTime = timeSinceEpoch.tv_sec * 1000000 + timeSinceEpoch.tv_usec;

    itrNum = 0;
    while(!glfwWindowShouldClose(window)) {
        glfwPollEvents();
        uiUpdate();
        simulate(rigidBodies);
        updateUniformBufferMain(currentFrame);
        drawFrame(false);
        if (itrNum%100 == 0){

            gettimeofday(&timeSinceEpoch, NULL);
            long int newTime = timeSinceEpoch.tv_sec * 1000000 + timeSinceEpoch.tv_usec;
            long int dt = newTime-currentTime;
            std::cout << dt/100000.0 << " ms per frame\n";
            currentTime = newTime;
            std::cout << itrNum << " frame num\n";
        }
        itrNum++;
        //throw std::runtime_error("check");
        if (startDesignMainLoop){
            std::cout << "hi\n";
            designMainLoop();
        }
    }


    vkDeviceWaitIdle(logicalDevice);
}

glm::ivec3 Program::getCursorPos(){
    mainCamera->getUserInput(window);
    double cursorx;
    double cursory;
    glfwGetCursorPos(window, &cursorx, &cursory);
    cursorx /= swapChainExtent.width;
    cursory /= swapChainExtent.height;
    cursorx = 2*cursorx-1.0;
    cursory = 2*cursory-1.0;

    glm::mat4x4 perspectiveMat = glm::perspective((float)M_PI/4.0f, swapChainExtent.width/(float) swapChainExtent.height, 0.1f,1000.0f);
    perspectiveMat[1][1] *= -1;//because it was designed for opengl y flip

    glm::vec3 rayStart = mainCamera->getPos();
    //std::cout << cursorx << " " << cursory << "\n";
    //std::cout << rayStart[0] << " " << rayStart[1] << " " << rayStart[2] << " cam pos\n";
    glm::vec4 invPerspectiveCursorPos = (glm::inverse(perspectiveMat) * glm::vec4(cursorx,cursory,0.0,1.0));
    glm::vec4 cursorPos = (mainCamera->getInverseViewMatrix()* invPerspectiveCursorPos);
    cursorPos /= cursorPos[3];
    glm::vec3 cursorDirection = (rayStart-glm::vec3(cursorPos));

    //std::cout << invPerspectiveCursorPos[0] << " " << invPerspectiveCursorPos[1] << " " << invPerspectiveCursorPos[2] << " " << invPerspectiveCursorPos[3] << " invPerspectiveCursorPos\n";
    //std::cout << cursorPos[0] << " " << cursorPos[1] << " " << cursorPos[2] << " " << cursorPos[3] << " cursor pos\n";
    //std::cout << cursorDirection[0] << " " << cursorDirection[1] << " " << cursorDirection[2] << " ray dir\n";

    glm::ivec3 cursorLoc = glm::ivec3(rayStart + cursorDirection * glm::vec3(-500.0)) + glm::ivec3(64);
    return cursorLoc;
}

/*void Program::designUpdate(DesignState &state, std::vector<int> &changeInds, std::vector<uint> &changeType){

    bool onButton = uiUpdate();
    if (onButton){// dont want to be doing stuff if the cursor is on the ui hiding whats happening
        return;
    }

    glm::ivec3 cursorLoc = getCursorPos();

    std::cout << state.cursorPos[0] << " " << state.cursorPos[1] << " " << state.cursorPos[2] << "\n";
    std::cout << cursorLoc[0] << " " << cursorLoc[1] << " " << cursorLoc[2] << "\n";
    if (cursorLoc[0] > 0 && cursorLoc[0] < state.structureDef->dimensions[0] &&
        cursorLoc[1] > 0 && cursorLoc[1] < state.structureDef->dimensions[1] &&
        cursorLoc[2] > 0 && cursorLoc[2] < state.structureDef->dimensions[2]){
            std::cout << "cursor in box\n";
            int min[3];
            int max[3];
            for (int i = 0; i < 3; i++){
                if (cursorLoc[i] > state.cursorPos[i]){
                    min[i] = state.cursorPos[i];
                    max[i] = cursorLoc[i];
                }
                else{
                    min[i] = cursorLoc[i];
                    max[i] = state.cursorPos[i];
                }
            }
            for (int i = min[0]; i <= max[0]; i++){
                for (int j = min[1]; j <= max[1]; j++){
                    for (int k = min[2]; k <= max[2]; k++){
                        state.structureDef->space[i][j][k] = 1;
                        changeInds.push_back(i*128*128+j*128+k);
                        changeType.push_back(1);
                    }
                }
            }
            state.cursorPos[0] = cursorLoc[0];
            state.cursorPos[1] = cursorLoc[1];
            state.cursorPos[2] = cursorLoc[2];
    }
}*/

void Program::designMainLoop(){
    mainCamera->moveTo(glm::vec3(-256,0,0));
    std::cout << "start func\n";
    for (UIElement* uiE: uiElements){
        delete uiE;
    }
    uiElements.clear();


    for (int i = 0; i < rigidBodies.size(); i++){
        delete rigidBodies[i];
        rigidBodies[i] = nullptr;
    }
    rigidBodies.clear();

    for (int i = 0; i < models.size(); i++){// this is just deleting all models as there should be no models except for from rigidbodies which I am trying to remove
        delete models[i];
        models[i] = nullptr;
    }
    models.clear();


    DesignState state;
    std::string code = "I{S(20,0,0,20),C(20,0,0,16,16,16)}";// default values as not make sense to not have anything
    //std::string code = "D{I{C(32,0,0,48,16,16),U{U{U{S(0,0,0,20),S(10,0,0,20)},U{S(20,0,0,20),S(30,0,0,20)}},U{S(40,0,0,20),S(50,0,0,20)}}},U{C(0,0,0,80,8,8),U{U{U{C(0,0,0,6,80,6),C(24,0,0,6,80,6)},C(48,0,0,6,80,6)},U{U{C(0,0,0,6,6,80),C(24,0,0,6,6,80)},C(48,0,0,6,6,80)}}";// default values as not make sense to not have anything
    state.mAndF.model.parse(code);

    state.modelNodeLoc = 0;// currently at root nood (root node is the last one so 0 is last in default)
    state.addType = 0;// bool op used to add
    state.editFocus = 0;// start editing model
    state.currentForce = 0;// start force focus on first null force
    state.currentEditFocus = &state.mAndF.model;// start editing model



    state.mAndF.forceRegions.push_back(CSG());// initial null force
    state.mAndF.forceRegions[0].parse("S(0,0,0,10)");

    state.mAndF.forceData.push_back(glm::vec4(0.0,0.0,0.0,0.0));
    state.mAndF.forceFields.push_back(glm::ivec4(0,0,2,0));







    TextInputUIElement textButtons(this);




    UIElement* startSimulateButton = new UIElement(this,-0.9,-0.9,0.2,0.2 , 384.0/2304.0,32.0/256.0,96.0/2304.0,64.0/256.0);
    UIElement* traverseRightButton = new UIElement(this,0.9,0.9,0.15,0.15 , 672.0/2304.0,96.0/256.0,96.0/2304.0,64.0/256.0);// traverse right
    UIElement* traverseLeftButton = new UIElement(this,0.725,0.9,0.15,0.15 , 576.0/2304.0,96.0/256.0,96.0/2304.0,64.0/256.0);// traverse left
    UIElement* traverseUpButton = new UIElement(this,0.8125,0.725,0.15,0.15 , 480.0/2304.0,96.0/256.0,96.0/2304.0,64.0/256.0);// traverse up

    UIElement* changeAddTypeButton = new UIElement(this,-0.925,-0.725,0.1,0.1 , 576.0/2304.0,32.0/256.0,96.0/2304.0,64.0/256.0);// change add mode
    UIElement* addCuboidButton = new UIElement(this,-0.925,-0.6,0.1,0.1 , 0,32.0/256.0,96.0/2304.0,64.0/256.0);// add cuboid
    UIElement* addSphereButton = new UIElement(this,-0.925,-0.475,0.1,0.1 , 96.0/2304.0,32.0/256.0,96.0/2304.0,64.0/256.0);// add sphere
    UIElement* deleteNodeButton = new UIElement(this,-0.925,-0.325,0.1,0.1 , 480.0/2304.0,32.0/256.0,96.0/2304.0,64.0/256.0);// delete node

    UIElement* moveObjButtons[6];
    for (int dim = 0; dim < 3; dim++){
        for (int pos = 0; pos < 2; pos++){
            moveObjButtons[pos + 2*dim] = new UIElement(this,-0.9 + 0.1*dim,0.8 + 0.1*pos, 0.05, 0.05 , (288.0-pos*96.0)/2304.0,32.0/256.0,96.0/2304.0,64.0/256.0);// move node
        }
    }
    UIElement* scaleObjButtons[8];
    for (int dim = 0; dim < 4; dim++){
        for (int pos = 0; pos < 2; pos++){
            scaleObjButtons[pos + 2*dim] = new UIElement(this,-0.5 + 0.1*dim,0.8 + 0.1*pos, 0.05, 0.05 , (192.0+pos*96.0)/2304.0,96.0/256.0,96.0/2304.0,64.0/256.0);// scale
        }
    }

    UIElement* changeEditFocusButton = new UIElement(this,0.9, -0.9, 0.15, 0.15 , 384.0/2304.0,160.0/256.0,96.0/2304.0,64.0/256.0);// edit forces or model or look at both
    UIElement* nextForceSelectButton = new UIElement(this,0.9, -0.725, 0.15, 0.15 , 768.0/2304.0,96.0/256.0,96.0/2304.0,64.0/256.0);// change focus to next force
    UIElement* addForceButton = new UIElement(this,0.9, -0.55, 0.15, 0.15 , 768.0/2304.0,160.0/256.0,96.0/2304.0,64.0/256.0);// add force
    UIElement* deleteForceButton = new UIElement(this,0.9, -0.375, 0.15, 0.15 , 672.0/2304.0,160.0/256.0,96.0/2304.0,64.0/256.0);// delete force

    UIElement* saveButton = new UIElement(this,-0.7, -0.9, 0.15, 0.15, 192.0/2304.0,160.0/256.0,96.0/2304.0,64.0/256.0);
    UIElement* loadButton = new UIElement(this,-0.5, -0.9, 0.15, 0.15, 288.0/2304.0,160.0/256.0,96.0/2304.0,64.0/256.0);

    UIElement* swapForceTypeButton = new UIElement(this, 0.7,-0.9,0.1,0.1, 864.0/2304.0,32.0/256.0,96.0/2304.0,64.0/256.0);
    UIElement* setXForceButton = new UIElement(this, 0.25,-0.9,0.1,0.1, 0,0,1,1);
    UIElement* setYForceButton = new UIElement(this, 0.4,-0.9,0.1,0.1, 0,0,1,1);
    UIElement* setZForceButton = new UIElement(this, 0.55,-0.9,0.1,0.1, 0,0,1,1);


    auto updateAddMode = [&state, &changeAddTypeButton] (){
        changeAddTypeButton->changeTexture(state.addType*96.0/2304.0 + 576.0/2304.0,32.0/256.0,96.0/2304.0,64.0/256.0);
    };
    auto updateEditMode = [&state, &changeEditFocusButton] (){
        changeEditFocusButton->changeTexture(state.editFocus*96.0/2304.0 + 384.0/2304.0,160.0/256.0,96.0/2304.0,64.0/256.0);
    };
    auto updateForceMode = [&state, &swapForceTypeButton] (){
        swapForceTypeButton->changeTexture(state.mAndF.forceFields[state.currentForce][2]*96.0/2304.0 + 864.0/2304.0,32.0/256.0,96.0/2304.0,64.0/256.0);
    };

    // to be used if current force or edit focus are changed
    auto updateEditFocus = [&state] (){
        switch (state.editFocus)
        {
        case 0:// edit model
            state.currentEditFocus = &state.mAndF.model;
            break;
        case 1:// edit force
            state.currentEditFocus = &state.mAndF.forceRegions[state.mAndF.forceFields[state.currentForce][0]];
            break;
        case 2:// see both
            state.currentEditFocus = nullptr;
            break;
        default:
            break;
        }
    };

    // to be used if type of force is changed or current force is changed
    auto updateForceVarDisplays = [&state, &setXForceButton, &setYForceButton, &setZForceButton] (){
        std::ostringstream ss;// to turn floats to strings
        switch (state.mAndF.forceFields[state.currentForce][2])
        {
        case 0:// fixed
            setXForceButton->setText("",1);
            setYForceButton->setText("",1);
            setZForceButton->setText("",1);
            break;
        case 1:// fix 1 dim
            setXForceButton->setText("False",0.6);
            setYForceButton->setText("False",0.6);
            setZForceButton->setText("False",0.6);
            if (state.mAndF.forceFields[state.currentForce][3] == 0){
                setXForceButton->setText("True",0.6);
            }
            if (state.mAndF.forceFields[state.currentForce][3] == 1){
                setYForceButton->setText("True",0.6);
            }
            if (state.mAndF.forceFields[state.currentForce][3] == 2){
                setZForceButton->setText("True",0.6);
            }
            break;
        case 2:
            ss << std::fixed << std::setprecision(3) << (state.mAndF.forceData[state.mAndF.forceFields[state.currentForce][1]][0]);
            setXForceButton->setText(ss.str(),0.6);
            ss.str("");
            ss << std::fixed << std::setprecision(3) << (state.mAndF.forceData[state.mAndF.forceFields[state.currentForce][1]][1]);
            setYForceButton->setText(ss.str(),0.6);
            ss.str("");
            ss << std::fixed << std::setprecision(3) << (state.mAndF.forceData[state.mAndF.forceFields[state.currentForce][1]][2]);
            setZForceButton->setText(ss.str(),0.6);
            break;
        default:
            break;
        }
    };

    updateForceVarDisplays();
    updateForceMode();

    bool startSimulateMainLoop = false;
    uiElements.push_back(startSimulateButton);
    auto start = [&startSimulateMainLoop] () {
        startSimulateMainLoop = true;
    };
    startSimulateButton->setClickOnFunc(std::bind(start));




    uiElements.push_back(traverseRightButton);
    auto traverseRight = [&state] () {
        if (state.currentEditFocus != nullptr){
            if ((*state.currentEditFocus->getNodeVector())[state.modelNodeLoc][0] == 0){
                state.parentNodes.push_back(state.modelNodeLoc);
                state.modelNodeLoc = (*state.currentEditFocus->getNodeVector())[state.modelNodeLoc][3];
                std::cout << state.modelNodeLoc << "\n";
            }
        }
    };
    traverseRightButton->setClickOnFunc(std::bind(traverseRight));

    uiElements.push_back(traverseLeftButton);
    auto traverseLeft = [&state] () {
        if (state.currentEditFocus != nullptr){
            if ((*(state.currentEditFocus->getNodeVector()))[state.modelNodeLoc][0] == 0){
                state.parentNodes.push_back(state.modelNodeLoc);
                state.modelNodeLoc = (*state.currentEditFocus->getNodeVector())[state.modelNodeLoc][1];
                std::cout << state.modelNodeLoc << "\n";
            }
        }
    };
    traverseLeftButton->setClickOnFunc(std::bind(traverseLeft));

    uiElements.push_back(traverseUpButton);
    auto traverseUp = [&state] () {
        if (state.parentNodes.size() != 0){
            state.modelNodeLoc = state.parentNodes[state.parentNodes.size()-1];
            state.parentNodes.pop_back();
            std::cout << state.modelNodeLoc << "\n";
        }
    };
    traverseUpButton->setClickOnFunc(std::bind(traverseUp));

    uiElements.push_back(changeAddTypeButton);
    auto changeAddType = [&state, &updateAddMode] () {
        state.addType = (state.addType+1)%3;
        updateAddMode();
    };
    changeAddTypeButton->setClickOnFunc(std::bind(changeAddType));

    uiElements.push_back(addCuboidButton);
    auto addCuboid = [&state] () {
        std::cout << state.currentEditFocus << "\n";
        if (state.currentEditFocus != nullptr){
            state.currentEditFocus->addPrimitive(state.modelNodeLoc,1,state.addType);
            std::cout << "cuboid\n";
        }
    };
    addCuboidButton->setClickOnFunc(std::bind(addCuboid));

    uiElements.push_back(addSphereButton);
    auto addSphere = [&state] () {
        std::cout << state.currentEditFocus << "\n";
        if (state.currentEditFocus != nullptr){
            state.currentEditFocus->addPrimitive(state.modelNodeLoc,2,state.addType);
            std::cout << "sphere\n";
        }
    };
    addSphereButton->setClickOnFunc(std::bind(addSphere));

    uiElements.push_back(deleteNodeButton);
    auto deleteNode = [&state] () {
        if (state.currentEditFocus != nullptr){
            int newNodeID = state.currentEditFocus->deleteNode(state.modelNodeLoc);
            std::cout << "delete\n";
            while (state.parentNodes.size() != 0){
                if (state.modelNodeLoc == newNodeID){// cant be part of while statement as could be empty vector
                    break;
                }
                state.modelNodeLoc = state.parentNodes[state.parentNodes.size()-1];
                state.parentNodes.pop_back();
            }
        }
    };
    deleteNodeButton->setClickOnFunc(std::bind(deleteNode));

    for (int dim = 0; dim < 3; dim++){
        for (int pos = 0; pos < 2; pos++){// whether it is in the positive dir or not
            uiElements.push_back(moveObjButtons[pos + 2*dim]);
            auto moveObj = [&state,dim,pos] () {
                if (state.currentEditFocus != nullptr){
                    glm::vec3 dir = glm::vec3(0);
                    dir[dim] = 1-pos*2;
                    state.currentEditFocus->moveNode(state.modelNodeLoc,dir);
                }
            };
            moveObjButtons[pos + 2*dim]->setClickOnFunc(std::bind(moveObj));
        }
    }

    for (int dim = 0; dim < 4; dim++){
        for (int pos = 0; pos < 2; pos++){// whether it is in the positive dir or not
            uiElements.push_back(scaleObjButtons[pos + 2*dim]);
            auto scaleObj = [&state,dim,pos] () {
                if (state.currentEditFocus != nullptr){
                    state.currentEditFocus->changeDataOfNode(state.modelNodeLoc, dim+3, 1-pos*2);
                    std::cout << dim+3 <<" scale\n";
                }
            };
            scaleObjButtons[pos + 2*dim]->setClickOnFunc(std::bind(scaleObj));
        }
    }

    uiElements.push_back(changeEditFocusButton);
    auto changeEditFocus = [&state, &updateEditFocus, &updateEditMode] () {
        state.editFocus = (state.editFocus+1)%3;
        state.modelNodeLoc = 0;
        state.parentNodes.clear();

        updateEditFocus();
        updateEditMode();

        std::cout << state.editFocus << " edit focus\n";
    };
    changeEditFocusButton->setClickOnFunc(std::bind(changeEditFocus));

    uiElements.push_back(nextForceSelectButton);
    auto nextForceSelect = [&state, &updateEditFocus, &updateForceVarDisplays, &updateForceMode] () {
        state.currentForce = (state.currentForce+1)%state.mAndF.forceFields.size();
        std::cout << state.currentForce << " current force\n";

        updateEditFocus();
        updateForceVarDisplays();
        updateForceMode();
    };
    nextForceSelectButton->setClickOnFunc(std::bind(nextForceSelect));

    uiElements.push_back(addForceButton);
    auto addForce = [&state, &updateEditFocus, &updateForceVarDisplays, &updateForceMode] () {
        state.mAndF.forceFields.push_back(glm::ivec4(state.mAndF.forceRegions.size(),state.mAndF.forceData.size(),2,0));// create a new force
        state.mAndF.forceRegions.push_back(CSG());
        state.mAndF.forceRegions[state.mAndF.forceRegions.size()-1].parse("S(0,0,0,10)");// default region
        state.mAndF.forceData.push_back(glm::vec4(0.0,0.0,0.0,0.0));// no inital force
        state.currentForce = state.mAndF.forceFields.size()-1;
        std::cout << state.currentForce << " current force (just added)\n";

        updateEditFocus();
        updateForceVarDisplays();
        updateForceMode();
    };
    addForceButton->setClickOnFunc(std::bind(addForce));

    uiElements.push_back(deleteForceButton);
    auto deleteForce = [&state, &updateEditFocus, &updateForceVarDisplays, &updateForceMode] () {
        int regionRemoved = state.mAndF.forceFields[state.currentForce][0];
        int dataRemoved = state.mAndF.forceFields[state.currentForce][1];
        state.mAndF.forceFields.erase(state.mAndF.forceFields.begin() + state.currentForce);
        state.mAndF.forceRegions.erase(state.mAndF.forceRegions.begin() + regionRemoved);
        state.mAndF.forceData.erase(state.mAndF.forceData.begin() + dataRemoved);

        for (int i = 0; i < state.mAndF.forceFields.size(); i++){// update pointers which may have changed
            if (state.mAndF.forceFields[i][0] > regionRemoved){
                state.mAndF.forceFields[i][0] -= 1;
            }
            if (state.mAndF.forceFields[i][1] > dataRemoved){
                state.mAndF.forceFields[i][1] -= 1;
            }
        }

        if (state.mAndF.forceRegions.size() == 0){// no force add null force back

            state.mAndF.forceRegions.push_back(CSG());// initial null force
            state.mAndF.forceRegions[0].parse("S(0,0,0,10)");
            state.mAndF.forceData.push_back(glm::vec4(0.0,0.0,0.0,0.0));
            state.mAndF.forceFields.push_back(glm::ivec4(0,0,2,0));

            state.currentForce = 0;
        }
        else{
            state.currentForce = state.currentForce%state.mAndF.forceFields.size();// if out of bounds set back to 0
        }

        updateEditFocus();
        updateForceVarDisplays();
        updateForceMode();

        std::cout << state.currentForce << " current force (just deleted)\n";
    };
    deleteForceButton->setClickOnFunc(std::bind(deleteForce));

    uiElements.push_back(saveButton);
    auto saveButtonFunc = [&state] () {
        const char* returnFileName = tinyfd_saveFileDialog(
            "save thing",// title
            "file.txt",// default value
            0,// number of patterns (next input)
            NULL,// stuff like regex {"*.txt"}
            NULL);// description of the above

        if (returnFileName){
            std::string fileName = returnFileName;
            std::cout << fileName << "\n";
            std::ofstream file(fileName);// open, if does not exist creates a new file
            // also clears file once added as not appending
            file << "model|" << state.mAndF.model.inverseParse() << "\n";
            for (int i = 0; i < state.mAndF.forceFields.size(); i++){
                file << "force|" << state.mAndF.forceFields[i][2] << "|";
                switch (state.mAndF.forceFields[i][2])// extra data such as directions
                {
                case 0:// fixed object no extra data
                    break;
                case 1:// fixed in 1 dimension
                    file << state.mAndF.forceFields[i][3];// which direction fixed
                    break;
                case 2:// apply normal force
                    file << std::fixed << std::setprecision(3) << state.mAndF.forceData[state.mAndF.forceFields[i][1]][0] << ","
                         << state.mAndF.forceData[state.mAndF.forceFields[i][1]][1] << ","
                         << state.mAndF.forceData[state.mAndF.forceFields[i][1]][2];
                    break;
                default:
                    break;
                }
                file << "|" << state.mAndF.forceRegions[state.mAndF.forceFields[i][0]].inverseParse() << "\n";
            }
        }
        else{// failure or cancel
            std::cout << "cancel save\n";
        }
    };
    saveButton->setClickOnFunc(std::bind(saveButtonFunc));

    uiElements.push_back(loadButton);
    auto loadButtonFunc = [&state, &updateEditFocus, &updateForceVarDisplays, &updateForceMode] () {
        const char* returnFileName = tinyfd_openFileDialog(
            "load file",
            "file.txt",
            0,
            NULL,
            NULL,
            0);

        if (returnFileName){

            state.mAndF.forceRegions.clear();
            state.mAndF.forceFields.clear();
            state.mAndF.forceData.clear();


            std::string fileName = returnFileName;
            std::cout << fileName << "\n";
            std::ifstream file(fileName);
            std::stringstream buffer;
            buffer << file.rdbuf();
            std::string contents = buffer.str();

            int start = 0;
            int end = 0;
            while (end < contents.size()){
                bool processSlice = false;
                if (end+1 == contents.size()){
                    processSlice = true;
                }
                else{
                    if (contents[end+1] == 'm' || contents[end+1] == 'f'){
                        processSlice = true;
                    }
                }
                if (processSlice){
                    int mode = 0;// what type of thing is being read (e.g. is it a CSG definition)
                    int typeOfObj = 0;// force or model
                    int forceType = 0;// force type
                    std::vector<float> extraData;
                    int csgStart = -1;
                    int csgEnd = -1;

                    int value = 0;
                    int floatValue = 0;
                    bool negative = false;
                    int dp = 0;

                    for (int i = start; i <= end; i++){
                        switch (mode)
                        {
                        case 0:// first part whether model or force
                            if (contents[i] == 'm'){
                                typeOfObj = 0;
                            }
                            if (contents[i] == 'f'){
                                typeOfObj = 1;
                            }
                            if (contents[i] == '|'){
                                if (typeOfObj == 0){
                                    mode = 3;
                                }
                                else{
                                    mode = 1;
                                }
                            }
                            break;
                        case 1:// type of force (positive integer so dont need to worry about - or .)
                            if (contents[i] == '|'){
                                forceType = value;
                                value = 0;
                                mode = 2;
                            }
                            else{
                                value = value*10 + contents[i]-'0';// multiply by 10 and add next digit (cast to int and offset)
                            }
                            break;
                        case 2:// extra data (could be negitive or decimal)
                            if (forceType != 0){

                                if (contents[i] >= 48 && contents[i] < 58){// if a digit
                                    if (dp == 0){// int part
                                        value = 10*value + contents[i]-'0';
                                    }
                                    else{// float part
                                        floatValue = 10*floatValue + contents[i]-'0';
                                        dp *= 10;
                                    }
                                }

                                if (contents[i] == '.'){
                                    dp = 1;
                                }
                                if (contents[i] == '-'){
                                    negative = true;
                                }

                                if (contents[i] == ',' || contents[i] == '|'){
                                    if (dp == 0){
                                        dp = 1;
                                    }
                                    if (negative){
                                        extraData.push_back(-float(value) - float(floatValue)/float(dp));
                                    }
                                    else{
                                        extraData.push_back(float(value) + float(floatValue)/float(dp));
                                    }

                                    value = 0;
                                    floatValue = 0;
                                    dp = 0;
                                    negative = false;
                                }
                            }
                            if (contents[i] == '|'){
                                mode = 3;
                            }
                            break;
                        case 3:// CSG definition
                            if (contents[i] == '|'){// should not happen
                                i = end+1;// break from loop
                            }
                            if (csgStart == -1){
                                csgStart = i;
                            }
                            csgEnd = i;
                            break;
                        default:
                            break;
                        }
                    }

                    if (typeOfObj == 0 && csgStart != -1 && csgEnd != -1){// model
                        state.mAndF.model.parse(contents.substr(csgStart, csgEnd-csgStart+1));// set it to given thing
                    }
                    if (typeOfObj == 1 && csgStart != -1 && csgEnd != -1){// force
                        int indField = state.mAndF.forceFields.size();
                        int indRegion = state.mAndF.forceRegions.size();
                        int indData = state.mAndF.forceData.size();
                        state.mAndF.forceFields.push_back(glm::ivec4(indRegion,indData,0,0));
                        state.mAndF.forceRegions.push_back(CSG());
                        state.mAndF.forceRegions[indRegion].parse(contents.substr(csgStart, csgEnd-csgStart+1));
                        state.mAndF.forceData.push_back(glm::vec4());
                        state.mAndF.forceFields[indField][2] = forceType;
                        if (forceType == 1 && extraData.size() != 0){
                            state.mAndF.forceFields[indField][3] = extraData[0];
                        }
                        if (forceType == 2){
                            for (int i = 0; i < 3; i++){
                                if (i == extraData.size()){
                                    break;// avoid segfault if not enough data
                                }
                                state.mAndF.forceData[indData][i] = extraData[i];
                            }
                        }


                        if ((*state.mAndF.forceRegions[indRegion].getNodeVector()).size() == 0){// if resulted in null region
                            state.mAndF.forceFields.pop_back();
                            state.mAndF.forceData.pop_back();
                            state.mAndF.forceRegions.pop_back();
                        }

                        std::cout << state.mAndF.forceFields.size() << " forces\n";
                    }

                    start = end+1;
                }

                end += 1;
            }

            if ((*state.mAndF.model.getNodeVector()).size() == 0){// if uninitiated (no nodes)
                state.mAndF.model.parse("I{S(20,0,0,20),C(20,0,0,16,16,16)}");
                std::cout << "model unitiated\n";
            }
            if (state.mAndF.forceFields.size() == 0){// no forces need default values
                state.mAndF.forceFields.push_back(glm::ivec4(0,0,2,0));// pushing force
                state.mAndF.forceData.push_back(glm::vec4(0,0,0,0));// null force
                state.mAndF.forceRegions.push_back(CSG());
                state.mAndF.forceRegions[0].parse("S(0,0,0,10)");// small sphere at centre
                std::cout << "no forces in file\n";
            }

            // below attributes of state rely on pointers which may now be hanging
            state.parentNodes.clear();
            state.modelNodeLoc = 0;
            state.currentForce = 0;
            updateEditFocus();
            updateForceVarDisplays();
            updateForceMode();

        }
        else{// failure or cancel
            std::cout << "cancel open\n";
        }
    };
    loadButton->setClickOnFunc(std::bind(loadButtonFunc));

    uiElements.push_back(swapForceTypeButton);
    auto swapForceType = [&state, &updateForceVarDisplays, &updateForceMode] (){
        // change type of force (there are 3 types of forces atm)
        state.mAndF.forceFields[state.currentForce][2] = (state.mAndF.forceFields[state.currentForce][2]+1)%3;
        // the data is currently only used for type 2 so if leave it in no problems caused
        // likewise for component 3 of force fields which is only used for type 1
        updateForceVarDisplays();
        updateForceMode();
    };
    swapForceTypeButton->setClickOnFunc(std::bind(swapForceType));

    uiElements.push_back(setXForceButton);
    auto setxForce = [&state, &setXForceButton, &textButtons, &updateForceVarDisplays] (){
        switch (state.mAndF.forceFields[state.currentForce][2])
        {
        case 0:
            break;
        case 1:
            state.mAndF.forceFields[state.currentForce][3] = 0;
            updateForceVarDisplays();
            break;
        case 2:
            textButtons.setActive(true);
            textButtons.setTarget(&(state.mAndF.forceData[state.mAndF.forceFields[state.currentForce][1]][0]), setXForceButton, std::bind(updateForceVarDisplays),0.6);
            break;
        default:
            break;
        }
        std::cout << "hello\n";
    };
    setXForceButton->setClickOnFunc(std::bind(setxForce));

    uiElements.push_back(setYForceButton);
    auto setyForce = [&state, &setYForceButton, &textButtons, &updateForceVarDisplays] (){
        switch (state.mAndF.forceFields[state.currentForce][2])
        {
        case 0:
            break;
        case 1:
            state.mAndF.forceFields[state.currentForce][3] = 1;
            updateForceVarDisplays();
            break;
        case 2:
            textButtons.setActive(true);
            textButtons.setTarget(&(state.mAndF.forceData[state.mAndF.forceFields[state.currentForce][1]][1]), setYForceButton, std::bind(updateForceVarDisplays),0.6);
            break;
        default:
            break;
        }
        std::cout << "hello\n";
    };
    setYForceButton->setClickOnFunc(std::bind(setyForce));

    uiElements.push_back(setZForceButton);
    auto setzForce = [&state, &setZForceButton, &textButtons, &updateForceVarDisplays] (){
        switch (state.mAndF.forceFields[state.currentForce][2])
        {
        case 0:
            break;
        case 1:
            state.mAndF.forceFields[state.currentForce][3] = 2;
            updateForceVarDisplays();
            break;
        case 2:
            textButtons.setActive(true);
            textButtons.setTarget(&(state.mAndF.forceData[state.mAndF.forceFields[state.currentForce][1]][2]), setZForceButton, std::bind(updateForceVarDisplays),0.6);
            break;
        default:
            break;
        }
        std::cout << "hello\n";
    };
    setZForceButton->setClickOnFunc(std::bind(setzForce));



    state.mAndF.forceRegions.push_back(CSG());
    state.mAndF.forceRegions[1].parse("S(116,0,0,100)");

    state.mAndF.forceData.push_back(glm::vec4(0.0,0.0,-0.01,0.0));
    state.mAndF.forceFields.push_back(glm::ivec4(1,1,0,0));



    struct timeval timeSinceEpoch;
    gettimeofday(&timeSinceEpoch, NULL);
    long int currentTime = timeSinceEpoch.tv_sec * 1000000 + timeSinceEpoch.tv_usec;

    itrNum = 0;
    while(!glfwWindowShouldClose(window)){
        glfwPollEvents();
        uiUpdate();
        textButtons.update(window);
        updateUniformBufferMain(currentFrame);
        updateUniformBufferCSG(currentFrame, state.mAndF, state);
        drawFrame(true);
        if (itrNum%100 == 0){

            gettimeofday(&timeSinceEpoch, NULL);
            long int newTime = timeSinceEpoch.tv_sec * 1000000 + timeSinceEpoch.tv_usec;
            long int dt = newTime-currentTime;
            std::cout << dt/100000.0 << " ms per frame\n";
            currentTime = newTime;
            std::cout << itrNum << " frame num\n";
        }
        itrNum++;
        //throw std::runtime_error("check");
        if (startSimulateMainLoop){
            simMainLoop(state.mAndF);
        }
    }


    vkDeviceWaitIdle(logicalDevice);
}

void Program::simMainLoop(ModelAndForces &design){
    for (UIElement* uiE: uiElements){
        delete uiE;
    }
    uiElements.clear();

    float size = 0.5;
    const std::vector<Vertex> vertices = {
        {{-size, -size, size}, {-1.0,-1.0,1.0}, {1.0f, 1.0f, 1.0f}},
        {{size, -size, size}, {1.0,-1.0,1.0}, {1.0f, 1.0f, 1.0f}},
        {{size, size, size}, {1.0,1.0,1.0}, {1.0f, 1.0f, 1.0f}},
        {{-size, size, size}, {-1.0,1.0,1.0}, {1.0f, 1.0f, 1.0f}},
        {{-size, -size, -size}, {-1.0,-1.0,-1.0}, {1.0f, 1.0f, 1.0f}},
        {{size, -size, -size}, {1.0,-1.0,-1.0}, {1.0f, 1.0f, 1.0f}},
        {{size, size, -size}, {1.0,1.0,-1.0}, {1.0f, 1.0f, 1.0f}},
        {{-size, size, -size}, {-1.0,1.0,-1.0}, {1.0f, 1.0f, 1.0f}}};
    const std::vector<uint16_t> indices = {
        //0, 1, 2, 2, 3, 0
        3,0,1,
        5,4,7,
        1,0,4,
        2,1,5,
        7,3,2,
        7,4,0,
        2,3,1,
        6,5,7,
        5,1,4,
        6,2,5,
        6,7,2,
        3,7,0};

    /*for (int i = 0; i < 1; i++){
        for (int j = 0; j < 16; j++){
            glm::vec3 pos = glm::vec3(2.0*i,-1.0,1.5 + 1.5*j);
            glm::vec4 rot = glm::vec4(0.0,0.0,cos(i),sin(i));
            glm::mat3x3 rotInertia = glm::mat3x3(1/12.0);
            addRigidBody(vertices, indices, rot, pos,rotInertia);
        }
    }*/

    FEStructure structure = FEStructure(this, design);
    //structure.getGlobalStiffnessMatrix();
    structure.getSparseGlobalStiffnessMatrix();
    structure.solveStiffnessMatrix(design);
    float structPos[3] = {0,0,0};
    models[models.size()-1]->moveTo(structPos);


    struct timeval timeSinceEpoch;
    gettimeofday(&timeSinceEpoch, NULL);
    long int currentTime = timeSinceEpoch.tv_sec * 1000000 + timeSinceEpoch.tv_usec;

    itrNum = 0;
    while(!glfwWindowShouldClose(window)) {
        glfwPollEvents();
        updateUniformBufferMain(currentFrame);
        //simulate(rigidBodies);
        drawFrame(false);
        if (itrNum%100 == 0){

            gettimeofday(&timeSinceEpoch, NULL);
            long int newTime = timeSinceEpoch.tv_sec * 1000000 + timeSinceEpoch.tv_usec;
            long int dt = newTime-currentTime;
            std::cout << dt/100000.0 << " ms per frame\n";
            currentTime = newTime;
            std::cout << itrNum << " frame num\n";
        }
        itrNum++;
        //throw std::runtime_error("check");
    }


    vkDeviceWaitIdle(logicalDevice);
}

void Program::drawFrame(bool drawDesign){
    VkSubmitInfo submitInfo{};
    submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;


    // graphic stuff
    vkWaitForFences(logicalDevice, 1, &inFlightFences[currentFrame], VK_TRUE, UINT64_MAX);

    uint32_t imageIndex;

    VkResult result = vkAcquireNextImageKHR(logicalDevice, swapChain, UINT64_MAX, imageAvailableSemaphores[currentFrame], VK_NULL_HANDLE, &imageIndex);
    if (result == VK_ERROR_OUT_OF_DATE_KHR || framebufferResized) {
        framebufferResized = false;
        recreateSwapChain();
        return;
    } else if (result != VK_SUCCESS && result != VK_SUBOPTIMAL_KHR) {
        std::cout << result << " error num\n";
        throw std::runtime_error("failed to acquire swap chain image!");
    }


    vkResetFences(logicalDevice, 1, &inFlightFences[currentFrame]);// here as may exit early

    vkResetCommandBuffer(commandBuffers[currentFrame], 0);
    recordCommandBuffer(commandBuffers[currentFrame], imageIndex, drawDesign);

    VkSemaphore waitSemaphores[] = {imageAvailableSemaphores[currentFrame]};
    VkPipelineStageFlags waitStages[] = { VK_PIPELINE_STAGE_VERTEX_INPUT_BIT, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT};
    submitInfo.waitSemaphoreCount = 1;
    submitInfo.pWaitSemaphores = waitSemaphores;
    submitInfo.pWaitDstStageMask = waitStages;

    submitInfo.commandBufferCount = 1;
    submitInfo.pCommandBuffers = &commandBuffers[currentFrame];

    VkSemaphore signalSemaphores[] = {renderFinishedSemaphores[currentFrame]};
    submitInfo.signalSemaphoreCount = 1;
    submitInfo.pSignalSemaphores = signalSemaphores;

    if (vkQueueSubmit(graphicsQueue, 1, &submitInfo, inFlightFences[currentFrame]) != VK_SUCCESS) {
        throw std::runtime_error("failed to submit draw command buffer!");
    }

    VkPresentInfoKHR presentInfo{};
    presentInfo.sType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;

    presentInfo.waitSemaphoreCount = 1;
    presentInfo.pWaitSemaphores = signalSemaphores;

    VkSwapchainKHR swapChains[] = {swapChain};
    presentInfo.swapchainCount = 1;
    presentInfo.pSwapchains = swapChains;
    presentInfo.pImageIndices = &imageIndex;
    presentInfo.pResults = nullptr; // Optional

    result = vkQueuePresentKHR(presentQueue, &presentInfo);

    if (result == VK_ERROR_OUT_OF_DATE_KHR || result == VK_SUBOPTIMAL_KHR || framebufferResized) {
        framebufferResized = false;
        recreateSwapChain();
    }
    else if (result != VK_SUCCESS){
        std::cout << result << " error num\n";
        throw std::runtime_error("failed to present swap chain image!");
    }

    currentFrame = (currentFrame + 1) % MAX_FRAMES_IN_FLIGHT;
}

void Program::recordCommandBuffer(VkCommandBuffer commandBuffer, uint32_t imageIndex, bool drawDesign){
    VkCommandBufferBeginInfo beginInfo{};
    beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
    beginInfo.flags = 0; // Optional
    beginInfo.pInheritanceInfo = nullptr; // Optional

    if (vkBeginCommandBuffer(commandBuffer, &beginInfo) != VK_SUCCESS) {
        throw std::runtime_error("failed to begin recording command buffer!");
    }

    VkRenderPassBeginInfo renderPassInfo{};
    renderPassInfo.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
    renderPassInfo.renderPass = renderPass;
    renderPassInfo.framebuffer = swapChainFramebuffers[imageIndex];

    renderPassInfo.renderArea.offset = {0, 0};
    renderPassInfo.renderArea.extent = swapChainExtent;

    std::array<VkClearValue,2> clearValues;
    clearValues[0] = {{0.0f, 0.0f, 0.0f, 1.0f}};
    clearValues[1] = {{1.0f, 0.0f}};
    renderPassInfo.clearValueCount = static_cast<uint32_t>(clearValues.size());
    renderPassInfo.pClearValues = clearValues.data();

    vkCmdBeginRenderPass(commandBuffer, &renderPassInfo, VK_SUBPASS_CONTENTS_INLINE);

    VkViewport viewport{};
    viewport.x = 0.0f;
    viewport.y = 0.0f;
    viewport.width = static_cast<float>(swapChainExtent.width);
    viewport.height = static_cast<float>(swapChainExtent.height);
    viewport.minDepth = 0.0f;
    viewport.maxDepth = 1.0f;
    vkCmdSetViewport(commandBuffer, 0, 1, &viewport);

    VkRect2D scissor{};
    scissor.offset = {0, 0};
    scissor.extent = swapChainExtent;
    vkCmdSetScissor(commandBuffer, 0, 1, &scissor);

    VkBuffer vertexBuffers[] = {verticesMemManager->getBuffer()};
    VkDeviceSize offsets[] = {0};
    vkCmdBindVertexBuffers(commandBuffer, 0, 1, vertexBuffers, offsets);

    vkCmdBindIndexBuffer(commandBuffer, indicesMemManager->getBuffer(), 0, VK_INDEX_TYPE_UINT16);


    if (drawDesign){
        vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, designGraphicsPipeline);

        std::vector<VkDescriptorSet> ds{designDescriptorSets[currentFrame], designDataDescriptorSets[currentFrame]};
        vkCmdBindDescriptorSets(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, designPipelineLayout, 0, ds.size(), ds.data(), 0, nullptr);

        MatrixPushConstant modelMatrix;
        modelMatrix.model = glm::mat4x4(1);//designModel->getModelTransform();
        vkCmdPushConstants(commandBuffer, designPipelineLayout, VK_SHADER_STAGE_VERTEX_BIT, 0, sizeof(MatrixPushConstant), &modelMatrix);
        vkCmdDrawIndexed(commandBuffer, static_cast<uint32_t>(designModel->getIndsLength()), 1, designModel->getIndsStart(), designModel->getVertStart(), 0/* not matter as does not have access to mat ssbo*/);
    }


    vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, graphicsPipeline);

    std::vector<VkDescriptorSet> ds{descriptorSets[currentFrame], objDataDescriptorSets[currentFrame]};
    vkCmdBindDescriptorSets(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, ds.size(), ds.data(), 0, nullptr);

    for (int i = 0; i < models.size(); i++){
        MatrixPushConstant modelMatrix;
        modelMatrix.model = models[i]->getModelTransform();
        vkCmdPushConstants(commandBuffer, pipelineLayout, VK_SHADER_STAGE_VERTEX_BIT, 0, sizeof(MatrixPushConstant), &modelMatrix);
        vkCmdDrawIndexed(commandBuffer, static_cast<uint32_t>(models[i]->getIndsLength()), 1, models[i]->getIndsStart(), models[i]->getVertStart(), i);
    }

    int matInst = models.size();
    for (int i = 0; i < instancedModels.size(); i++){
        //std::cout << i << " instanced\n";
        const std::vector<glm::mat4x4> mats = instancedModels[i]->getModelTransforms();
        MatrixPushConstant modelMatrix;
        modelMatrix.model = mats[0];
        int numMats = mats.size();
        //std::cout << numMats << " num instances\n";
        vkCmdPushConstants(commandBuffer, pipelineLayout, VK_SHADER_STAGE_VERTEX_BIT, 0, sizeof(MatrixPushConstant), &modelMatrix);
        vkCmdDrawIndexed(commandBuffer, static_cast<uint32_t>(instancedModels[i]->getIndsLength()), numMats, instancedModels[i]->getIndsStart(), instancedModels[i]->getVertStart(), matInst);
        matInst += numMats;
    }

    vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, uiGraphicsPipeline);

    std::vector<VkDescriptorSet> uids{uiDescriptorSets[currentFrame], uiTextureDescriptorSets[currentFrame]};
    vkCmdBindDescriptorSets(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, uiPipeLineLayout, 0, uids.size(), uids.data(), 0, nullptr);

    for (int i = 0; i < uiElements.size(); i++){
        //std::cout << i << "hi\n";
        for (int j = 0; j < uiElements[i]->getNumTextures(); j++){
            if (uiElements[i]->getActive()){
                UIPushConstant modelMatrix;
                modelMatrix.model = (uiElements[i]->getTransform())[j];
                modelMatrix.texture = (uiElements[i]->getTextureTransform())[j];

                vkCmdPushConstants(commandBuffer, uiPipeLineLayout, VK_SHADER_STAGE_VERTEX_BIT, 0, sizeof(UIPushConstant), &modelMatrix);
                vkCmdDrawIndexed(commandBuffer, static_cast<uint32_t>(rectModel->getIndsLength()), 1, rectModel->getIndsStart(), rectModel->getVertStart(), 0);
            }
        }
    }

    vkCmdEndRenderPass(commandBuffer);

    if (vkEndCommandBuffer(commandBuffer) != VK_SUCCESS) {
        throw std::runtime_error("failed to record command buffer!");
    }

}

void Program::recreateSwapChain() {

    int width = 0, height = 0;
    glfwGetFramebufferSize(window, &width, &height);
    while (width == 0 || height == 0) { // wait while 0 size
        glfwGetFramebufferSize(window, &width, &height);
        glfwWaitEvents();
    }

    vkDeviceWaitIdle(logicalDevice);

    cleanupSwapChain();

    createSwapChain();
    createImageViews();
    createFramebuffers();
}

void Program::updateUniformBufferMain(uint32_t currentImage){
    mainCamera->getUserInput(window);
    glm::mat4x4 camViewMat = mainCamera->getViewMatrix();
    MatricesUBO matUBO{};
    matUBO.view = camViewMat;
    matUBO.proj = glm::perspective((float)M_PI/4.0f, swapChainExtent.width/(float) swapChainExtent.height, 0.1f,1000.0f);
    matUBO.proj[1][1] *= -1;//because it was designed for opengl y flip
    matUBO.camPos = glm::vec4(mainCamera->getPos(),0.0);

    memcpy(buffersMapped[currentImage], &matUBO, sizeof(matUBO));

    LightUBO lightsUBO{};
    lightsUBO.dir = glm::normalize(glm::vec4(0.3f,0.6f,-0.9f,0.0f));
    lightsUBO.col = glm::vec4(1.0f,1.0f,1.0f,0.0f);

    memcpy(buffersMapped[currentImage+1*MAX_FRAMES_IN_FLIGHT], &lightsUBO, sizeof(lightsUBO));

    const int MAX_NUM_OBJS = 16384;
    PerObjectData* objectSSBO = (PerObjectData*)buffersMapped[currentImage+2*MAX_FRAMES_IN_FLIGHT];
    int numMats = MAX_NUM_OBJS;
    for (int i = 0; i < models.size(); i++)
    {
        PerObjectData object{};
        object.model = models[i]->getModelTransform();
        objectSSBO[i].model = object.model;
    }
    int matInst = models.size();
    for (int i = 0; i < instancedModels.size(); i++){
        const std::vector<glm::mat4x4> mats = instancedModels[i]->getModelTransforms();
        for (int j = 0; j < mats.size(); j++){
            PerObjectData object{};
            object.model = mats[j];
            objectSSBO[matInst+j].model = object.model;
        }
        matInst += mats.size();
    }
}
void Program::updateUniformBufferVoxel(uint32_t currentImage, std::vector<int> changesIndex, std::vector<uint> changesType){

    VoxelMetaData voxelMetaDataUBO{};
    voxelMetaDataUBO.maxCorner = glm::vec4(64.0,64.0,64.0,0.0);
    voxelMetaDataUBO.minCorner = glm::vec4(-64.0,-64.0,-64.0,0.0);
    voxelMetaDataUBO.stepDim = glm::ivec4(128*128,128,1,0);
    voxelMetaDataUBO.voxelDim = glm::ivec4(128,128,128,0);
    voxelMetaDataUBO.voxelSize = glm::vec4(1.0,1.0,1.0,0.0);

    memcpy(buffersMapped[currentImage+3*MAX_FRAMES_IN_FLIGHT], &voxelMetaDataUBO, sizeof(voxelMetaDataUBO));

    VoxelData* voxelDataSSBO = (VoxelData*)buffersMapped[currentImage+4*MAX_FRAMES_IN_FLIGHT];
    for (int i = 0; i < changesIndex.size(); i++){
        voxelDataSSBO[changesIndex[i]].type = changesType[i];
    }
    // need speed so not just copy everything only changes;
}
void Program::updateUniformBufferCSG(uint32_t currentImage, ModelAndForces design, DesignState state){

    const std::vector<glm::vec4>* prim = design.model.getDataVector();
    const std::vector<glm::ivec4>* nodes = design.model.getNodeVector();
    const std::vector<glm::vec4>* forcePrim = design.forceRegions[design.forceFields[state.currentForce][0]].getDataVector();
    const std::vector<glm::ivec4>* forceNodes = design.forceRegions[design.forceFields[state.currentForce][0]].getNodeVector();

    CSGMetaData CSGMetaDataUBO{};
    switch (state.editFocus)
    {
    case 0:// edit model
        CSGMetaDataUBO.nodeDataSize = glm::ivec1(nodes->size());
        CSGMetaDataUBO.primitiveDataSize = glm::ivec1(prim->size());
        CSGMetaDataUBO.root = glm::ivec1(0);
        CSGMetaDataUBO.selected = glm::ivec1(state.modelNodeLoc);
        break;
    case 1:// edit forces
        CSGMetaDataUBO.nodeDataSize = glm::ivec1(forceNodes->size());
        CSGMetaDataUBO.primitiveDataSize = glm::ivec1(forcePrim->size());
        CSGMetaDataUBO.root = glm::ivec1(0);
        CSGMetaDataUBO.selected = glm::ivec1(state.modelNodeLoc);
        break;
    case 2:// see both
        CSGMetaDataUBO.nodeDataSize = glm::ivec1(nodes->size() + forceNodes->size());
        CSGMetaDataUBO.primitiveDataSize = glm::ivec1(prim->size() + forcePrim->size());
        CSGMetaDataUBO.root = glm::ivec1(0);
        CSGMetaDataUBO.selected = glm::ivec1(nodes->size());
        break;

    default:
        break;
    }

    memcpy(buffersMapped[currentImage+3*MAX_FRAMES_IN_FLIGHT], &CSGMetaDataUBO, sizeof(CSGMetaDataUBO));

    //std::cout << nodes->size() << " " << prim->size() << "\n";

    PrimitiveData* primDataSSBO = (PrimitiveData*)buffersMapped[currentImage+4*MAX_FRAMES_IN_FLIGHT];
    NodeData* nodeDataSSBO = (NodeData*)buffersMapped[currentImage+5*MAX_FRAMES_IN_FLIGHT];


    switch (state.editFocus)
    {
    case 0:// edit model
        for (int i = 0; i < prim->size(); i++){
            primDataSSBO[i].data = (*prim)[i];
            //std::cout << (*prim)[i][0] << " " << (*prim)[i][1] << " " << (*prim)[i][2] << " " << (*prim)[i][3] << "\n";
        }
        for (int i = 0; i < nodes->size(); i++){
            nodeDataSSBO[i].data = (*nodes)[i];
            //std::cout << (*nodes)[i][0] << " " << (*nodes)[i][1] << " " << (*nodes)[i][2] << " " << (*nodes)[i][3] << "\n";
        }
        break;

    case 1:// edit forces
        for (int i = 0; i < forcePrim->size(); i++){
            primDataSSBO[i].data = (*forcePrim)[i];
            //std::cout << primDataSSBO[i].data[0] << " " << primDataSSBO[i].data[1] << " " << primDataSSBO[i].data[2] << " " << primDataSSBO[i].data[3] << "\n";
        }
        for (int i = 0; i < forceNodes->size(); i++){
            nodeDataSSBO[i].data = (*forceNodes)[i];
            //std::cout << nodeDataSSBO[i].data[0] << " " << nodeDataSSBO[i].data[1] << " " << nodeDataSSBO[i].data[2] << " " << nodeDataSSBO[i].data[3] << "\n";
        }
        break;

    case 2:// see both
        for (int i = 0; i < prim->size(); i++){
            primDataSSBO[i].data = (*prim)[i];
            //std::cout << (*prim)[i][0] << " " << (*prim)[i][1] << " " << (*prim)[i][2] << " " << (*prim)[i][3] << "\n";
        }
        for (int i = 0; i < forcePrim->size(); i++){
            primDataSSBO[i + prim->size()].data = (*forcePrim)[i];
            //std::cout << primDataSSBO[i + prim->size()].data[0] << " " << primDataSSBO[i + prim->size()].data[1] << " " << primDataSSBO[i + prim->size()].data[2] << " " << primDataSSBO[i + prim->size()].data[3] << "\n";
        }

        for (int i = 0; i < nodes->size(); i++){
            nodeDataSSBO[i].data = (*nodes)[i];
            //std::cout << (*nodes)[i][0] << " " << (*nodes)[i][1] << " " << (*nodes)[i][2] << " " << (*nodes)[i][3] << "\n";
        }
        for (int i = 0; i < forceNodes->size(); i++){
            nodeDataSSBO[i+nodes->size()].data = (*forceNodes)[i];
            if (nodeDataSSBO[i+nodes->size()].data[0] == 0){// fix the indices
                nodeDataSSBO[i+nodes->size()].data[1] += nodes->size();
                nodeDataSSBO[i+nodes->size()].data[3] += nodes->size();
            }
            else{
                nodeDataSSBO[i+nodes->size()].data[1] += prim->size();
            }
            //std::cout << nodeDataSSBO[i+nodes->size()].data[0] << " " << nodeDataSSBO[i+nodes->size()].data[1] << " " << nodeDataSSBO[i+nodes->size()].data[2] << " " << nodeDataSSBO[i+nodes->size()].data[3] << "\n";
        }
        break;

    default:
        break;
    }
}

void Program::addModel(std::vector<Vertex> verts, std::vector<uint16_t> inds){
    Model* newModel = new Model(verticesMemManager,indicesMemManager, verts, inds);
    models.push_back(newModel);
}

void Program::addInstancedModel(std::vector<Vertex> verts, std::vector<uint16_t> inds){
    InstancedModel* newModel = new InstancedModel(verticesMemManager,indicesMemManager, verts, inds);
    instancedModels.push_back(newModel);
}


void Program::addRigidBody(std::vector<Vertex> verts, std::vector<uint16_t> inds, glm::vec4 rotation, glm::vec3 pos, glm::mat3x3 rotInertiaMat){
    Model* newModel = new Model(verticesMemManager,indicesMemManager, verts, inds);
    models.push_back(newModel);
    RigidBody* newRigidBody = new RigidBody(newModel, rotation, pos, rotInertiaMat,verts,inds);
    rigidBodies.push_back(newRigidBody);
}

CSG::CSG(){

}

int CSG::recurseParse(std::string s, int start, int end){
    std::cout << start << " " << end << " hi\n";


    if (s[start] == 'U' || s[start] == 'I' || s[start] == 'D'){// if bool op  this will recurse into two different items
        std::vector<int> starts;
        std::vector<int> ends;
        int thisLoc = nodes.size();
        nodes.push_back(glm::ivec4(0,0,0,0));


        int opType = 0;
        if (s[start] == 'U'){
            opType = 0;
        }
        if (s[start] == 'I'){
            opType = 1;
        }
        if (s[start] == 'D'){
            opType = 2;
        }
        nodes[thisLoc][2] = opType;

        int depth = 0;
        for (int loc = start; loc < end; loc++){// find the start and end of each item
            if (s[loc] == '{' || s[loc] == '('){
                depth += 1;
            }
            if (s[loc] == '}' || s[loc] == ')'){
                depth -= 1;
            }
            if (depth == 1){// check if the start of an item
                if (s[loc] == '{' || s[loc] == ','){
                    starts.push_back(loc+1);
                    if (s[loc] == ','){
                        ends.push_back(loc);
                    }
                }
            }
            if (depth == 0 && s[loc] == '}'){
                ends.push_back(loc);
            }
        }

        std::vector<int> locations;
        for (int i = 0; i < starts.size(); i++){
            locations.push_back(recurseParse(s,starts[i],ends[i]));
        }
        nodes[thisLoc][1] = locations[0];
        nodes[thisLoc][3] = locations[1];

        return thisLoc;
    }
    if (s[start] == 'S' || s[start] == 'C'/* || any other things to be added*/){// a primitive object
        std::vector<float> vars;
        int depth = 0;
        int intValue = 0;
        int floatValue = 0;
        bool negative = false;
        int dp = 0;

        int loc = start;
        while (loc < s.length()){

            if (depth == 1){
                int ascVal = s[loc];
                if (ascVal >= 48 && ascVal < 58){// if a digit
                    if (dp == 0){// int part
                        intValue = 10*intValue + ascVal-'0';
                    }
                    else{// float part
                        floatValue = 10*floatValue + ascVal-'0';
                        dp *= 10;
                    }
                }

                if (s[loc] == '.'){
                    dp = 1;
                }
                if (s[loc] == '-'){
                    negative = true;
                }

                if (s[loc] == ',' || s[loc] == ')'){
                    if (dp == 0){
                        dp = 1;
                    }
                    float newVal = float(intValue) + float(floatValue)/float(dp);
                    if (negative){
                        vars.push_back(-newVal);
                    }
                    else{
                        vars.push_back(newVal);
                    }

                    intValue = 0;
                    floatValue = 0;
                    dp = 0;
                    negative = false;
                }

            }


            if (s[loc] == '(' || s[loc] == '{'){
                depth++;
            }
            if (s[loc] == ')' || s[loc] == '}'){
                depth--;
                if (depth == 0){
                    break;
                }
            }


            loc++;
        }

        if (s[start] == 'C'){
            std::cout << vars.size() << "\n";
            if (vars.size() >= 6){
                int ind = data.size();
                glm::vec4 newData = glm::vec4(vars[0],vars[1],vars[2],0);// centre
                data.push_back(newData);
                glm::vec4 newData2 = glm::vec4(fabs(vars[3]),fabs(vars[4]),fabs(vars[5]),0);// half size
                data.push_back(newData2);
                glm::ivec4 newNode = glm::ivec4(1, ind, 0, 0);
                nodes.push_back(newNode);
            }
            else{
                std::cout << "num vars" << vars.size() << "\n";
                throw std::runtime_error("parsing error: insufficient variables");
            }
        }

        if (s[start] == 'S'){
            std::cout << vars.size() << "\n";
            if (vars.size() >= 4){
                int ind = data.size();
                glm::vec4 newData = glm::vec4(vars[0],vars[1],vars[2],fabs(vars[3]));
                data.push_back(newData);
                glm::ivec4 newNode = glm::ivec4(2, ind, 0, 0);
                nodes.push_back(newNode);
            }
            else{
                std::cout << "num vars" << vars.size() << "\n";
                throw std::runtime_error("parsing error: insufficient variables");
            }
        }

        return nodes.size()-1;
    }

    return 0;
}

std::string CSG::inverseParse(){
    return inverseParseRecurse(0,0);
    // return the subtree of the root node and set depth counter to 0
}

std::string CSG::inverseParseRecurse(int node, int depth){
    if (depth > 1000){
        throw std::runtime_error("inverse parse seem stuck in loop");
    }

    // all numbers are rounded to the 3dp to make it readable in the text file
    std::ostringstream returnStream;
    switch (nodes[node][0])// type of node
    {
    case 0:// bool op
        switch (nodes[node][2])// type of bool op
        {
        case 0:
            returnStream << "U{";
            break;
        case 1:
            returnStream << "I{";
            break;
        case 2:
            returnStream << "D{";
            break;
        default:
            break;
        }
        returnStream << inverseParseRecurse(nodes[node][1],depth+1) << ","
         << inverseParseRecurse(nodes[node][3],depth+1) << "}";
        break;
    case 1:// cuboid
        returnStream << std::fixed << std::setprecision(3) << "C("
        << data[nodes[node][1]][0] << ","// pos
        << data[nodes[node][1]][1] << ","
        << data[nodes[node][1]][2] << ","

        << data[nodes[node][1]+1][0] << ","// half size
        << data[nodes[node][1]+1][1] << ","
        << data[nodes[node][1]+1][2] << ")";
        break;
    case 2:// sphere
        returnStream << std::fixed << std::setprecision(3) << "S("
        << data[nodes[node][1]][0] << ","// pos
        << data[nodes[node][1]][1] << ","
        << data[nodes[node][1]][2] << ","
        << data[nodes[node][1]][3] << ")";// radius
        break;

    default:
        break;
    }
    std::string returnString = returnStream.str();

    return returnString;
}

void CSG::parse(std::string s){
    data.clear();
    nodes.clear();

    recurseParse(s,0,s.length());

    for (int i = 0; i < nodes.size(); i++){
        std::cout << nodes[i][0] << " " << nodes[i][1] << " " << nodes[i][2] << " " << nodes[i][3] << " " << "\n";
    }
    std::cout << "\n";
    for (int i = 0; i < data.size(); i++){
        std::cout << data[i][0] << " " << data[i][1] << " " << data[i][2] << " " << data[i][3] << " " << "\n";
    }
}

float CSG::getSDF(glm::vec3 point){
    std::vector<float> SDF;
    for (int i = 0; i < nodes.size(); i++){
        SDF.push_back(0.0);
    }

    for (int i = nodes.size()-1; i >= 0; i--){// assume all nodes only dependent on later nodes in the vec so run backwards
        float SDF_val = 0;
        glm::vec3 d = glm::vec3(0.0);// purely to make non boolean operations easier to read
        switch (nodes[i][0]){
            case 0:// bool op
                switch (nodes[i][2]){
                    case 0:// union
                        SDF_val = std::min(SDF[nodes[i][1]],SDF[nodes[i][3]]);
                        break;
                    case 1:// intersection
                        SDF_val = std::max(SDF[nodes[i][1]],SDF[nodes[i][3]]);
                        break;
                    case 2:// difference
                        SDF_val = std::max(SDF[nodes[i][1]],-SDF[nodes[i][3]]);
                        break;
                    default:
                        SDF_val = 0;
                        break;
                }
                break;
            case 1:// axis aligned cuboid
                d = glm::abs(glm::vec3(data[nodes[i][1]]) - point) - glm::vec3(data[nodes[i][1] +1]);

                SDF_val = std::min(std::max(d.x,std::max(d.y,d.z)),0.0f)
                            +glm::length(glm::max(d,glm::vec3(0.0)));
                break;
            case 2:// sphere
                d = glm::vec3(data[nodes[i][1]]) - point;
                SDF_val = sqrt((d.x)*(d.x) + (d.y)*(d.y) + (d.z)*(d.z))-(data[nodes[i][1]][3]);
                break;
            default:
                SDF_val = 0;
                break;
        }


        SDF[i] = SDF_val;
    }

    return SDF[0];
}

glm::vec3 CSG::getNormal(glm::vec3 point){
    return glm::normalize(glm::vec3(getSDF(point + glm::vec3(0.001,0.0,0.0)) - getSDF(point - glm::vec3(0.001,0.0,0.0)),
                                    getSDF(point + glm::vec3(0.0,0.001,0.0)) - getSDF(point - glm::vec3(0.0,0.001,0.0)),
                                    getSDF(point + glm::vec3(0.0,0.0,0.001)) - getSDF(point - glm::vec3(0.0,0.0,0.001))));
}

void CSG::addPrimitive(int loc, int primType, int addType){
    // move the current object at loc
    // if it is a primitive append it on the end
    // if a bool op then move everything >= loc and redo the pointers
    // set the loc to a bool op pointing to where object at loc was moved to and new item added at end

    if (nodes[loc][0] == 0){// is a bool op must maintain that early depends on late
        // vector has an implemented insert function to insert into a given position
        glm::vec4 boolOpNode = glm::ivec4(0,loc,addType,nodes.size());// these will be incremented
        nodes.insert(nodes.begin()+loc,boolOpNode);// bool op
        for (int i = 0; i < nodes.size(); i++){// fix the pointers
            if (nodes[i][0] == 0){// it points to other nodes as is a bool op
                if (nodes[i][1] >= loc){
                    nodes[i][1] += 1;
                }
                if (nodes[i][3] >= loc){
                    nodes[i][3] += 1;
                }
            }
        }
    }
    else{// just a primitve much simpler and faster
        nodes.push_back(nodes[loc]);// copy current node to end as it depends on nothing you can move it down the vector
        nodes[loc] = glm::ivec4(0,nodes.size()-1,addType,nodes.size());// set loc to bool op
    }


    nodes.push_back(glm::ivec4(primType,data.size(),0,0));// add new prim
    switch (primType)
    {
    case 1:// cuboid
        data.push_back(glm::vec4(0,0,0,0));// pos
        data.push_back(glm::vec4(7,7,7,0));// size
        break;
    case 2:// sphere
        data.push_back(glm::vec4(0,0,0,10));// pos and r
        break;

    default:
        break;
    }



    for (int i = 0; i < nodes.size(); i++){
        std::cout << nodes[i][0] << " " << nodes[i][1] << " " << nodes[i][2] << " " << nodes[i][3] << " " << "\n";
    }
    std::cout << "\n";
    for (int i = 0; i < data.size(); i++){
        std::cout << data[i][0] << " " << data[i][1] << " " << data[i][2] << " " << data[i][3] << " " << "\n";
    }
}

void CSG::rebuild(){// this rebuilds the arrays removing nodes to be removed
    std::vector<glm::vec4> newData;
    std::vector<glm::ivec4> newNodes;
    rebuildInner(newData,newNodes,0);// everything should be a child node to node 0

    data = std::move(newData);// update attributes with new data
    nodes = std::move(newNodes);
}

void CSG::rebuildInner(std::vector<glm::vec4> &newData, std::vector<glm::ivec4> &newNodes, int index){// recursive rebuild

    int currentInd = newNodes.size();
    switch (nodes[index][0])
    {
    case 0:
        newNodes.push_back(glm::ivec4(nodes[index][0], currentInd+1, nodes[index][2] , -1));// sub nodes will be next and to be set later
        rebuildInner(newData,newNodes,nodes[index][1]);
        newNodes[currentInd][3] = newNodes.size();// set right ind
        rebuildInner(newData,newNodes,nodes[index][3]);

        break;

    case 1:
    case 2:
        newNodes.push_back(glm::ivec4(nodes[index][0], newData.size(), 0 ,0));

        newData.push_back(data[nodes[index][1]]);
        if (nodes[index][0] == 1){// if a cube there are 2 data pieces
            newData.push_back(data[nodes[index][1]+1]);
        }

        break;

    default:
        break;
    }
}

int CSG::deleteNode(int loc){
    // returns position a pointer to this node should be after deletion
    // if delete root node then clear all and add a single primitive
    // else if not a left node of a difference operation replace parent node with the other node
    // if right node of a difference operation delete the parent node recusively

    if (loc == 0){
        nodes.clear();
        data.clear();

        nodes.push_back(glm::ivec4(1,0,0,0));
        data.push_back(glm::vec4(0,0,0,0));
        data.push_back(glm::vec4(7,7,7,0));

        return 0;
    }
    else{
        int parentNode = loc;
        for (int i = 0; i < loc; i++){
            if (nodes[i][0] == 0 && (nodes[i][1] == loc || nodes[i][3] == loc)){
                parentNode = i;
                break;
            }
        }


        if (parentNode == loc){// no parent node rebuild tree to delete
            rebuild();
            return 0;// dont know where should be return to start
        }
        else if (nodes[parentNode][2] == 2 && nodes[parentNode][1] == loc){// delete parent node
            return deleteNode(parentNode);
        }
        else{// delete this node and premote sibling node to parent nodes position
            int otherNodeInd = nodes[parentNode][1];
            if (otherNodeInd == loc){
                otherNodeInd = nodes[parentNode][3];
            }

            nodes[parentNode] = nodes[otherNodeInd];

            rebuild();
            return parentNode;
        }

    }
}

void CSG::moveNode(int loc, glm::vec3 dir){// translation applyed recursivly if needed
    switch (nodes[loc][0])
    {
    case 0:
        moveNode(nodes[loc][1], dir);// recurse to children
        moveNode(nodes[loc][3], dir);
        break;

    case 1:
    case 2:
        data[nodes[loc][1]] += glm::vec4(dir,0);
        break;

    default:
        break;
    }
}

void CSG::changeDataOfNode(int loc, int dataLoc, float change){// change data of node used for scale
    std::cout << loc << " " << dataLoc << " " << change << "\n";
    switch (nodes[loc][0])
    {
    case 0:// should not do anything
        break;

    case 1:
        if (dataLoc >= 4 && dataLoc <= 6){
            data[nodes[loc][1]+1][dataLoc%4] += change;
            if (data[nodes[loc][1]+1][dataLoc%4] < 1){
                data[nodes[loc][1]+1][dataLoc%4] = 1;// cant be 0 or less length
            }
        }
        break;
    case 2:
        if (dataLoc == 3){// radius
            data[nodes[loc][1]][3] += change;
            if (data[nodes[loc][1]][3] < 1){
                data[nodes[loc][1]][3] = 1;// cant be 0 or less radius
            }
            std::cout << data[nodes[loc][1]][3] << "\n";
        }
        break;

    default:
        break;
    }
}

int main(){
    const std::vector<const char*> validationLayers = {
        "VK_LAYER_KHRONOS_validation"
    };
    const std::vector<const char *> deviceExtensions = {
        VK_KHR_SWAPCHAIN_EXTENSION_NAME
    };
    const std::vector<Vertex> vertices2 = {
        {{-16.0, -16.0, 0.0}, {-1.0,-1.0,1.0}, {1.0f, 1.0f, 1.0f}},
        {{16.0, -16.0, 0.0}, {1.0,-1.0,1.0}, {1.0f, 1.0f, 1.0f}},
        {{16.0, 16.0, 0.0}, {1.0,1.0,1.0}, {1.0f, 1.0f, 1.0f}},
        {{-16.0, 16.0, 0.0}, {-1.0,1.0,1.0}, {1.0f, 1.0f, 1.0f}}
    };
    const std::vector<uint16_t> indices2 = {
        0, 1, 2,
        2, 3, 0
    };

    Program theProgram = Program(true,validationLayers,deviceExtensions);
    theProgram.makeWindow();
    theProgram.setUpVulkan();
    std::cout << "start\n";
    theProgram.openMainLoop();
}