main.h

#pragma once

#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"



#include <iostream>
#include <vector>
#include <set>
#include <string.h>
#include <algorithm>
#include <fstream>
#include <unordered_set>
#include <functional>

#include <cmath>

#include "geometry.h"

class Camera;
class UIElement;
class RigidBody;

class CSG{
public:
    CSG();

    // input data of something like the openscad tool
    void parse(std::string s);
    std::string inverseParse();// gets data and nodes and creates a text file which would result in the same model when parsed
    int recurseParse(std::string s, int start, int end);
    std::string inverseParseRecurse(int node, int depth);
    float getSDF(glm::vec3 point);
    glm::vec3 getNormal(glm::vec3 point);

    void addPrimitive(int loc, int primType, int addType);// adds a primitive to a given node using a given bool op
    int deleteNode(int loc);
    void rebuild();
    void rebuildInner(std::vector<glm::vec4> &newData, std::vector<glm::ivec4> &newNodes, int index);
    void moveNode(int loc ,glm::vec3 dir);
    void changeDataOfNode(int loc, int dataLoc, float change);

    const std::vector<glm::vec4>* getDataVector() const {return &data;};
    const std::vector<glm::ivec4>* getNodeVector() const {return &nodes;};
private:
    // data is a large block of data use is dependent on nodes vector
    std::vector<glm::vec4> data;// contains objects and tree
    // each vec4 is a node in the CSG tree
    // it could be a position in the data with how to use it
    // or a binary operation on 2 other nodes
    std::vector<glm::ivec4> nodes;// contains data about above data

    // aabb 2 vec4 each with a corner
    // sphere 1 vec4 with position and radius
};

struct ModelAndForces{
    CSG model;
    std::vector<CSG> forceRegions;
    std::vector<glm::vec4> forceData;
    std::vector<glm::ivec4> forceFields;
};

struct StructureDefinition{
    int space[128][128][128];
    double gridSpacing;
    int dimensions[3];
};

// to big not to be a pointer at all points otherwise seg fault
struct DesignState{
    ModelAndForces mAndF;
    int modelNodeLoc;
    std::vector<int> parentNodes;
    int addType;
    int editFocus;
    int currentForce;
    CSG* currentEditFocus;
};



struct QueueStruct {
    int graphicsFamily = -1;
    int presentFamily = -1;
    int graphicsAndComputeFamily = -1;

    bool isComplete() {
        return (graphicsFamily != -1)&&(presentFamily != -1);
    }
};

struct SwapChainSupportDetails {
    VkSurfaceCapabilitiesKHR capabilities;
    std::vector<VkSurfaceFormatKHR> formats;
    std::vector<VkPresentModeKHR> presentModes;
};

class Program{// class which means I dont have to deal with globals as they can be attributes of this class
            // much of the basics of this class are based another program I wrote which was based of the vulkan tutorial at https://vulkan-tutorial.com/
public:
    Program(bool useValidationLayers, const std::vector<const char*> validationLayersToUse, const std::vector<const char*> deviceExtensionsToUse);
    ~Program();
    void makeWindow();


    void setUpVulkan();

    void createInstance();
    void createSurface();

    void pickHardWareDevices();

    void createLogicalDevice();

    void createSwapChain();
    void createImageViews();

    void createCommandPool();

    void createRenderPass();
    void createDescriptorSetLayouts();
    void createGraphicsPipeline();
    void createUIGraphicsPipeline();
    void createDesignRayCastingPipeline();

    void createDepthResources();

    void createFramebuffers();

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

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

    void createCommandBuffers();

    void createSyncObjects();

    void finishedSetUpBits();

    void addModel(std::vector<Vertex> verts, std::vector<uint16_t> inds);
    void addInstancedModel(std::vector<Vertex> verts, std::vector<uint16_t> inds);
    void addRigidBody(std::vector<Vertex> verts, std::vector<uint16_t> inds,glm::vec4 rotation, glm::vec3 pos, glm::mat3x3 rotInertiaMat);

    void addUIElement(UIElement* e);
    void removeUIElement(UIElement* e);


    bool uiUpdate();// returns whether it is did something
    //void designUpdate(DesignState &state, std::vector<int> &changeInds, std::vector<uint> &changeType);
    glm::ivec3 getCursorPos();

    void openMainLoop();// the thing that shows when first open program may have stuff like settings load create ... options
    void designMainLoop();// bit where creation of the model to be simulated is done
    void simMainLoop(ModelAndForces &design);// simulate the model in memory

    void updateUniformBufferMain(uint32_t currentImage);
    void updateUniformBufferVoxel(uint32_t currentImage, std::vector<int> changesIndex, std::vector<uint> changesType);
    void updateUniformBufferCSG(uint32_t currentImage, ModelAndForces design, DesignState state);
    void drawFrame(bool drawDesign);
    void recordCommandBuffer(VkCommandBuffer commandBuffer, uint32_t imageIndex, bool drawDesign);



    bool checkValidationLayerSupport();

    bool validDevice(VkPhysicalDevice device);
    QueueStruct findQueues(VkPhysicalDevice device);
    bool hasNeededExtensions(VkPhysicalDevice device);
    SwapChainSupportDetails querySwapChainSupport(VkPhysicalDevice device);

    VkSurfaceFormatKHR chooseSwapSurfaceFormat(const std::vector<VkSurfaceFormatKHR>& availableFormats);
    VkPresentModeKHR chooseSwapPresentMode(const std::vector<VkPresentModeKHR>& availablePresentModes);
    VkExtent2D chooseSwapExtent(const VkSurfaceCapabilitiesKHR& capabilities);

    // helper function to create an image view for a image in a wanted format with flags
    VkImageView createImageView(VkImage image, VkFormat format, VkImageAspectFlags aspectFlags);
    void createImage(uint32_t width, uint32_t height, VkFormat format, VkImageTiling tiling, VkImageUsageFlags usage, VkMemoryPropertyFlags properties, VkImage& image, VkDeviceMemory& imageMemory);

    uint32_t findMemoryType(uint32_t typeFilter, VkMemoryPropertyFlags properties);

    VkFormat findDepthFormat();
    VkFormat findSupportedFormat(const std::vector<VkFormat>& candidates, VkImageTiling tiling, VkFormatFeatureFlags features);

    std::vector<char> readFile(const std::string& filename);
    VkShaderModule createShaderModule(const std::vector<char>& code);

    VkCommandBuffer beginSingleTimeCommands();
    void endSingleTimeCommands(VkCommandBuffer commandBuffer);

    void transitionImageLayout(VkImage image, VkFormat format, VkImageLayout oldLayout, VkImageLayout newLayout);

    void copyBufferToImage(VkBuffer buffer, VkImage image, uint32_t width, uint32_t height);

    void createBuffer(VkDeviceSize size, VkBufferUsageFlags usage,VkMemoryPropertyFlags properties, VkBuffer &returnBuffer, VkDeviceMemory &returnBufferMemory);
    void copyBuffer(VkBuffer srcBuffer, VkBuffer dstBuffer, VkDeviceSize size);
    void createDescriptorSetLayout(std::vector<int> stages, int numBuffers,VkDescriptorSetLayout& layout, VkDescriptorType type);
    void 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);
    // for createDescriptorSet you leave the indexes or image inputs as 0 for ones which it is not that

    void recreateSwapChain();
    void cleanupSwapChain();
private:
    Camera* mainCamera;

    int itrNum;

    int oldMouseState;
    std::vector<UIElement*> uiElements;
    Model* rectModel;// because dont need a new model for every billboard

    Model* designModel;// used for bounding box of voxel/CSG thing so know what to raycast in

    VkImage textureImage;
    VkDeviceMemory textureImageMemory;
    VkImageView textureImageView;
    VkSampler textureSampler;

    MemoryManager<Vertex>* verticesMemManager;
    MemoryManager<uint16_t>* indicesMemManager;
    std::vector<Model*> models;
    std::vector<InstancedModel*> instancedModels;
    std::vector<RigidBody*> rigidBodies;

    int MAX_FRAMES_IN_FLIGHT;
    int currentFrame;
    bool framebufferResized;

    bool enableValidationLayers;
    std::vector<const char*> validationLayers;
    GLFWwindow* window;
    VkInstance instance;
    VkSurfaceKHR surface;
    VkPhysicalDevice physicalDevice;
    std::vector<const char*> deviceExtensions;
    VkDevice logicalDevice;
    VkQueue graphicsQueue;
    VkQueue presentQueue;
    VkQueue computeQueue;
    std::vector<VkImage> swapChainImages;
    std::vector<VkImageView> swapChainImageViews;
    VkSwapchainKHR swapChain;
    VkFormat swapChainImageFormat;
    VkExtent2D swapChainExtent;
    std::vector<VkFramebuffer> swapChainFramebuffers;
    VkCommandPool commandPool;


    VkRenderPass renderPass;

    VkDescriptorSetLayout descriptorSetLayout;
    VkDescriptorSetLayout perObjectDataDSLayout;
    VkPipelineLayout pipelineLayout;
    VkPipeline graphicsPipeline;

    VkDescriptorSetLayout uiDescriptorSetLayout;
    VkDescriptorSetLayout uiTextureDescriptorSetLayout;
    VkPipelineLayout uiPipeLineLayout;
    VkPipeline uiGraphicsPipeline;

    VkDescriptorSetLayout designDSLayout;
    VkDescriptorSetLayout designDataDSLayout;
    VkPipelineLayout designPipelineLayout;
    VkPipeline designGraphicsPipeline;



    VkImage depthImage;
    VkDeviceMemory depthImageMemory;
    VkImageView depthImageView;


    std::vector<VkBuffer> buffers;
    std::vector<VkDeviceMemory> buffersMemory;
    std::vector<void*> buffersMapped;

    VkDescriptorPool descriptorPool;
    std::vector<VkDescriptorSet> descriptorSets;
    std::vector<VkDescriptorSet> uiDescriptorSets;
    std::vector<VkDescriptorSet> uiTextureDescriptorSets;
    std::vector<VkDescriptorSet> objDataDescriptorSets;
    std::vector<VkDescriptorSet> designDescriptorSets;
    std::vector<VkDescriptorSet> designDataDescriptorSets;

    std::vector<VkCommandBuffer> commandBuffers;
    std::vector<VkSemaphore> imageAvailableSemaphores;
    std::vector<VkSemaphore> renderFinishedSemaphores;
    std::vector<VkFence> inFlightFences;
};



template <class T>
class MemoryManager{
public:
    MemoryManager(int size, VkDevice logicalDevice, Program* p, T defaultValue, int usageFlags);
    ~MemoryManager();
    T* getMemoryPointer(int loc);
    VkBuffer getBuffer() const {return buffer;};
    int getSize() const {return maxSize;};
    int alloc(int length);
    void free(int start);

    void updateBuffer();
private:
    Program* program;
    VkDevice logicalDevice;

    VkBuffer buffer;
    VkDeviceMemory bufferMemory;
    VkBuffer stagingBuffer;
    VkDeviceMemory stagingBufferMemory;
    void* data; // data is the staging buffers memory map
    std::vector<T> memory; // copied to data when needed


    int maxSize;
    struct MemBlock{
        int start;
        int length;
    };
    std::vector<MemBlock> memoryBlocks;// must be kept ordered
};

template <class T>
MemoryManager<T>::MemoryManager(int size, VkDevice lDevice, Program* p, T defaultValue, int usageFlags){
    program = p;
    maxSize = size;
    memory.reserve(size);
    for (int i = 0; i < size; i++){
        memory.push_back(defaultValue);
    }
    memory.shrink_to_fit();
    logicalDevice = lDevice;


    VkDeviceSize bufferSize = sizeof(memory[0]) * memory.size();
    program->createBuffer(bufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT
                ,stagingBuffer,stagingBufferMemory);

    vkMapMemory(logicalDevice, stagingBufferMemory, 0, bufferSize, 0, &data);

    program->createBuffer(bufferSize, usageFlags, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT
                ,buffer,bufferMemory);


    updateBuffer();
}


template <class T>
MemoryManager<T>::~MemoryManager(){

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

    vkDestroyBuffer(logicalDevice, buffer, nullptr);
    vkFreeMemory(logicalDevice, bufferMemory, nullptr);
}

template <class T>
T* MemoryManager<T>::getMemoryPointer(int loc){
    return &(memory[loc]);// does not like being a const function
}

template <class T>
int MemoryManager<T>::alloc(int length){
    if (length <= 0){// all block sizes must be strict positive
        return -1;
    }
    int lastEnd = 0;
    int pos = 0;
    for (MemBlock i: memoryBlocks){// assumes that memoryBlocks are ordered
        if (i.start-lastEnd >= length){// if enough space between this and last put in in there
            MemBlock newItem;
            newItem.length = length;
            newItem.start = lastEnd;
            memoryBlocks.insert(memoryBlocks.begin()+pos,newItem);// insert adds before iter
            return lastEnd;
        }
        lastEnd = i.start+i.length;
        pos++;
    }
    if (maxSize-lastEnd >= length){// if not inbetween put after all other if space
        MemBlock newItem;
        newItem.length = length;
        newItem.start = lastEnd;
        memoryBlocks.push_back(newItem);// as at end can just add to end of vec
        return lastEnd;
    }
    return -1;
}

template <class T>
void MemoryManager<T>::free(int start){
    for (int i = 0; i < memoryBlocks.size(); i++){
        if (memoryBlocks[i].start == start){
            memoryBlocks.erase(memoryBlocks.begin() + i);
            return;// shouldnt be able to erase multiple and as something is deleted it could mess up pointers
        }
    }
}

template <class T>
void MemoryManager<T>::updateBuffer(){
    VkDeviceSize bufferSize = sizeof(memory[0]) * memory.size();
    memcpy(data, memory.data(), (size_t) bufferSize);
    program->copyBuffer(stagingBuffer, buffer, bufferSize);
}