src/Core/e_window.c - master - Zamar_Terrier/TigorEngine

src/Core/e_window.c
164 строки4 KB
Zamar_Terrier
Доработка + нововведения
06 июл 2026, 16:26
06 июл 2026, 16:260d4ab95
#include "Core/e_window.h"
#include "Core/e_memory.h"

#include "wManager/window_manager.h"

#include <vulkan/vulkan.h>

#include "Data/e_resource_data.h"
#include "Data/e_resource_engine.h"

#define VK_KHR_SURFACE_EXTENSION_NAME "VK_KHR_surface"
#define VK_KHR_ANDROID_SURFACE_EXTENSION_NAME "VK_KHR_android_surface"

extern TEngine engine;

bool checkValidationLayerSupport()
{
    uint32_t layerCount;
    vkEnumerateInstanceLayerProperties(&layerCount, NULL);

    VkLayerProperties *availableLayers = (VkLayerProperties *)AllocateMemory(layerCount, sizeof(VkLayerProperties));
    vkEnumerateInstanceLayerProperties(&layerCount, availableLayers);

    bool layerFound;

    for (int i = 0; i < num_valid_layers; i++)
    {
        layerFound = false;

        for (int j = 0; j < layerCount; j++)
        {
            if (strcmp(validationLayers[i], availableLayers[j].layerName) == 0)
            {
                layerFound = true;
                break;
            }
        }

        if (!layerFound)
            return false;
    }

    FreeMemory(availableLayers);

    return true;
}

const char **getRequiredExtensions()
{

    const char **extensions;

    extensions = wManagerGetRequiredInstanceExtensions(&engine.wManagerExtensionCount);

    if (enableValidationLayers)
        engine.wManagerExtensionCount++;

    const char **wManagerExtensions = (const char **)AllocateMemory(engine.wManagerExtensionCount, sizeof(char *));

    int tempIter = enableValidationLayers ? engine.wManagerExtensionCount - 1 : engine.wManagerExtensionCount;

    for (int i = 0; i < tempIter; i++)
        wManagerExtensions[i] = extensions[i];

    if (enableValidationLayers)
        wManagerExtensions[engine.wManagerExtensionCount - 1] = VK_EXT_DEBUG_UTILS_EXTENSION_NAME;

    return wManagerExtensions;
}

void InitWindow()
{
    wManagerInit();
    // wManagerWindowHint(TIGOR_RESIZABLE, false);
    if (!wManagerCreateWindow(engine.window.e_window, engine.width, engine.height, engine.app_name))
    {
        wManagerTerminate();
        printf("Error when create window!\n");
        exit(0);
    }

    wManagerSetFramebufferSizeCallback(engine.window.e_window, (wManagerFrameBufferSizeFun)framebufferResizeCallback);
}

static void framebufferResizeCallback(void *window, int width, int height)
{

    if (engine.framebufferwasResized)
        engine.framebufferResized = true;
}

void createInstance()
{

    if (enableValidationLayers && !checkValidationLayerSupport())
    {
        printf("validation layers requested, but not available\n");
    }

    VkApplicationInfo appInfo = {0};

    appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
    appInfo.pApplicationName = engine.app_name;
    appInfo.applicationVersion = VK_MAKE_VERSION(0, 0, 0);
    appInfo.pEngineName = "TigorEngine";
    appInfo.applicationVersion = VK_MAKE_VERSION(0, 0, 0);
    appInfo.apiVersion = VK_API_VERSION_1_0;

    VkInstanceCreateInfo createInfo = {0};

    createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
    createInfo.pApplicationInfo = &appInfo;

    VkDebugUtilsMessengerCreateInfoEXT debugInfo = {0};

    if (enableValidationLayers)
    {
        populateDebugMessengerCreateInfo(&debugInfo);

        createInfo.pNext = (VkDebugUtilsMessengerCreateInfoEXT *)&debugInfo;
    }
    else
    {
        createInfo.enabledLayerCount = 0;

        createInfo.pNext = NULL;
    }

    const char **wManagerExtensions = getRequiredExtensions();

    createInfo.enabledExtensionCount = engine.wManagerExtensionCount;
    createInfo.ppEnabledExtensionNames = wManagerExtensions;

    VkInstance instance;
    if (vkCreateInstance(&createInfo, NULL, &instance))
    {
        printf("Failed to create instance\n");
        exit(1);
    }

    engine.window.instance = instance;

    FreeMemory(wManagerExtensions);
}

void createSurface()
{

    if (wManagerCreateWindowSurface(engine.window.instance, engine.window.e_window, NULL, (VkSurfaceKHR *)&engine.window.surface) != VK_SUCCESS)
    {
        printf("failed to create window surface!");
        exit(1);
    }
}

vec2 getWindowSize()
{
    vec2 size;

    size.x = engine.width * engine.diffSize.x;
    size.y = engine.height * engine.diffSize.y;

    return size;
}