includes/Variabels/engine_includes.h - master - Zamar_Terrier/TigorEngine

includes/Variabels/engine_includes.h
621 строка13 KB
Zamar_Terrier
Офигенное обновление движка
31 июл 2026, 21:03
31 июл 2026, 21:031682686
/**
* @file engine_includes.h
* @brief Основные типы и константы движка TigorEngine
* @details Содержит определение основных типов данных, структур, перечислений
* и констант, используемых во всем проекте. Подключает необходимые заголовочные
* файлы Vulkan и внутренние модули движка.
*/
#ifndef STDINC_H
#define STDINC_H

#include <vulkan/vulkan.h>

#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

#include "Tools/e_direct.h"

#include "e_vertex.h"
#include "e_buffers_variables.h"

#include "e_math_variables.h"

#include "wManager/key_defines.h"

#define TIGOR_DEFINE_NON_DISPATCHABLE_HANDLE(object) typedef struct object##_T *object;

#define MAX_FONTS 32
#define MAX_SHADERS 32
#define MAX_IMAGES 64
#define MAX_PIPELINES 16
#define MAX_UNIFORMS 8
#define MAX_BLUE_PRINTS 8

#define MAX_DRAW_OBJECTS UINT16_MAX

#define MAX_GUI_CALLBACKS 64

#define MAX_SHAPES 8

#define MAX_INSTANCES UINT16_MAX

#define ERROR_TEXTURE_ENABLE true

#ifndef M_PI
#define M_PI		3.14159265358979323846
#endif

#ifdef __cplusplus
extern "C"
{
#endif

#ifndef __cplusplus
    #include <stdbool.h>
#endif

struct GameObject_T;
struct RenderTexture_T;

typedef void (*EngineDrawFunc)();
typedef void (*EngineRecreateFunc)(int width, int height);
typedef void (*EngineUpdateFunc)(float deltaTime);

typedef enum{
    TIGOR_TEXTURE2D_FLAG_GENERATED = 0x1,
    TIGOR_TEXTURE2D_FLAG_VIEW = 0x2,
    TIGOR_TEXTURE2D_IS_FONT = 0x4,
    TIGOR_TEXTURE2D_NO_INITIAL = 0x8,
} EngineTexture2DFlag;

typedef enum{
    TIGOR_LIGHT_OBJECT_TYPE_POINT_LIGHT,
    TIGOR_LIGHT_OBJECT_TYPE_DIRECTIONAL_LIGHT,
    TIGOR_LIGHT_OBJECT_TYPE_SPOT_LIGHT,
} LightObjectType;

typedef struct{
    char *path;
    char *buffer;
    char *data;
    uint32_t buff_size;
    uint32_t texWidth;
    uint32_t texHeight;
    uint32_t texChannels;
    uint32_t mip_levels;
} ImageFileData;

typedef struct{
    VkImage image;
    VkImageView image_view;
    VkDeviceMemory memory;
    VkSampler sampler;
    uint32_t textureType;
    uint32_t imageLayout;
    ImageFileData image_data;
    EngineTexture2DFlag flags;
} Texture2D;

typedef struct{
    VkInstance instance;
    VkSurfaceKHR surface;

    void *e_window;

} TWindow;

typedef struct{

    VkPhysicalDevice e_physicalDevice;
    VkDevice e_device;
    void* e_device_mutex;

    void* graphicsQueue_mutex;
    VkQueue graphicsQueue;
    VkQueue presentQueue;

    void* commandPool_mutex;
    VkCommandPool commandPool;
    void* commandBuffers_mutex;
    VkCommandBuffer* commandBuffers;

} TDevice;

typedef struct{
    VkSwapchainKHR  swapChain;
    VkImage *swapChainImages;
    VkImageView *swapChainImageViews;

    Texture2D depth_texture;

    uint32_t swapChainImageFormat;

    VkExtent2D swapChainExtent;
} TSwapChain;

typedef struct LightObject {
#ifdef _MSC_VER
    __declspec(align(16)) vec3 position;
    __declspec(align(16)) vec3 color;
    __declspec(align(16)) vec3 direction; // Для направленного и фонарного света
#else
    vec3 position __attribute__((aligned(16)));
    vec3 color __attribute__((aligned(16)));
    vec3 direction __attribute__((aligned(16))); // Для направленного и фонарного света
#endif
    float intensity;
    int type;
    float cutoff; // Угол освещения фонарного света внутренний круг
    float outCutOff; // Угол освещения фонарного света внешний круг
    float radius;
} LightObject;

typedef struct LightBuffer {
    LightObject lights[10];
    int num_lights;
    int light_enable;
} LightBuffer;

typedef enum{
    TIGOR_CHILD_STACK_FLAG_IS_HEAD = 0x1
} ChildStackFlags;

typedef struct ChildStack{
    struct ChildStack* next;
    struct ChildStack* before;
    void (*destroyer)(void *);
    void *node;
    char *name;
    char flags;
} ChildStack;

typedef struct CustomVector{
    void *ptr;
    uint32_t elem_size;
    uint32_t curr_size;
    uint32_t array_size;
    void (*destroyer)(void *);
    char *name[64];
} CustomVector;

typedef struct{
    struct RenderTexture *objects[MAX_DRAW_OBJECTS];
    uint32_t size;
} EngineRenderItems;

typedef struct{
    LightObject lights[10];
    uint32_t size;
} EngineLightItems;

typedef struct{
    struct GameObject *objects[MAX_DRAW_OBJECTS];
    uint32_t size;
} EngineGameObjects;

typedef struct FontCache{
    char path[256];
    void *cdata;
    void *info;
    void *texture;
} FontCache;

typedef enum ShaderCacheFlag{
    TIGOR_SHADER_CACHE_FLAG_DIFFUSE = 0x1,
    TIGOR_SHADER_CACHE_FLAG_NORMAL = 0x2,
    TIGOR_SHADER_CACHE_FLAG_SPECULAR = 0x4,
}ShaderCacheFlag;

typedef struct ShaderCache{
    char name[64];
    void *vector;
    void *vertShader;
    void *fragShader;
    void *teseShader;
    void *tescShader;
    uint32_t args[16];
} ShaderCache;

typedef struct{
    char app_name[256];
    int width;
    int height;
    void* cam2D;
    void* cam3D;

    int nbFrames;
    int fpsCounter;
    double lastTime;

    vec2 viewSize;
    vec2 diffSize;

    void *global_mutex;
    void *global_shader_mutex;

    TWindow window;
    TDevice device;
    TSwapChain swapchain;

    EngineRenderItems renders;
    EngineLightItems  lights;

    EngineDrawFunc Drawer;
    EngineUpdateFunc Updater;
    EngineRecreateFunc Recreator;

    e_charCallback internal_charCallback;
    e_keyCallback internal_keyCallback;

    struct{
        ChildStack *alloc_buffers_memory_head;
        ChildStack *alloc_descriptor_head;
        ChildStack *alloc_pipeline_head;
    } cache;

    void *e_var_current_entry;

    void *main_render;
    void *current_render;
    void *current_widget;

    size_t currentFrame;
    uint32_t imageIndex;

    uint32_t extensionCount;
    uint32_t imagesCount;
    uint32_t wManagerExtensionCount;

    bool framebufferResized;
    bool framebufferwasResized;

    VkDebugUtilsMessengerEXT debugMessenger;

    bool present;

    struct SynC{
        VkSemaphore* imageAvailableSemaphores;
        VkSemaphore* renderFinishedSemaphores;

        VkFence* inFlightFences;
    }Sync;

    struct DataR{
        char *font_path;
        void *e_var_images;
        int e_var_num_images;

        void *e_var_fonts;
        uint32_t e_var_num_fonts;

        void *e_var_shaders;
        uint32_t e_var_num_shaders;

        int define_font_loaded;
    } DataR;

    // Post-processing fields
    void *postProcessingPipeline;
    VkRenderPass postProcessingRenderPass;
    void *fullscreenQuad;
} TEngine;

typedef enum{
    TIGOR_DRAW_PARAM_FLAG_ADD_SHADOW = 0x1,
    TIGOR_DRAW_PARAM_FLAG_DRAW_INDEXED = 0x2
} EngineDrawParamFlags;

typedef struct{
    char path[256];
    char *buffer;
    int size;
    int imgWidth;
    int imgHeight;
    uint32_t img_type;
    uint32_t flags;
} GameObjectImage;

typedef struct {
    vec4 color;
    float depth;
    uint32_t next;
} Node;

typedef struct {
    uint32_t count;
    uint32_t maxNodeCount;
} GeometrySBO;

typedef struct PipelineCache{
    void *GraphicsPipeline;
    void *GraphicsPipelineLayout;
    void *setting;
} PipelineCache;


typedef struct {
    VkVertexInputAttributeDescription* inputDescription;
    uint32_t size;
} attrDescr;

typedef struct{
    vec3 position;
    vec3 rotation;
} SomeDirLight;

typedef struct{
    uint32_t type;
    vec3 orig;
    vec3 dir;
    float angle;
} TreePeace;

typedef struct{
    uint32_t v_index;
    uint32_t i_index;
} VertextIterator;

typedef struct{
    char *diffuse;
    char *specular;
    char *normal;
    char second[256];
    char font[256];
    char vertShader[256];
    char fragShader[256];
    char topology;
    char flags;
    void *render;
    void *geom;
} DrawParam;

typedef struct{
    uint32_t FindLetter;
    uint16_t IndexLetter;
} FontIndexes;

typedef struct EPViewport {
    float    x;
    float    y;
    float    width;
    float    height;
    float    minDepth;
    float    maxDepth;
} EPViewport;

typedef struct{
    char* code_shader;
    uint32_t size_code_shader;
    uint32_t type_code_shader;
    uint32_t flags;
} EngineShaderStage;

typedef struct{
    char poligonMode;
    char topology;
    char cull_mode;
    EngineShaderStage stages[6];
    uint32_t num_stages;
    char dynamicState;
    EPViewport viewport;
    VkRect2D scissor;
    uint32_t flags;
    uint32_t vert_indx;
} PipelineSetting;

typedef struct{
    VkPipeline pipeline;
    void *layout;
} PipelineStruct;

typedef struct{
    VkDescriptorPool        descr_pool;
    VkDescriptorSetLayout   descr_set_layout;
    VkDescriptorSet         descr_sets[MAX_UNIFORMS];
} ShaderDescriptor;

typedef struct{
    ShaderDescriptor descriptor;
    PipelineStruct pipeline;
} ShaderPack;

typedef struct{
    ShaderPack shader_packs[MAX_BLUE_PRINTS];
    uint32_t num_shader_packs;
    bool perspective;
} GraphicItems;

typedef enum{
    TIGOR_BUFFER_ALLOCATE_VERTEX,
    TIGOR_BUFFER_ALLOCATE_INDEX,
    TIGOR_BUFFER_ALLOCATE_UNIFORM,
    TIGOR_BUFFER_ALLOCATE_STAGING,
} BufferAllocType;

typedef struct BufferObject{
    BufferAllocType type;
    VkBuffer        buffer;
    VkDeviceMemory  memory;
} BufferObject;

typedef struct BufferContainer{
    BufferObject buffers[8];
    uint32_t type_size;
    uint32_t count;
} BufferContainer;

typedef struct{
    void *update;
    Texture2D textures[8];
    BufferContainer uniform;
    VkDescriptorType descrType;
    uint32_t desr_set_indx;
    uint32_t binding;
    uint32_t stageflag;
    uint32_t count;
    uint32_t buffsize;
    uint32_t flags;
    uint32_t indx_layer;
    GameObjectImage *image;
} BluePrintDescriptor;

typedef struct{
    uint32_t stageFlags;
    uint32_t offset;
    uint32_t size;
} BluePrintPushConstant;

typedef struct{
    PipelineSetting setting;
    BluePrintDescriptor descriptors[MAX_UNIFORMS];
    uint32_t num_descriptors;
    BluePrintPushConstant push_constants[MAX_UNIFORMS];
    uint32_t num_push_constants;
    uint32_t curr_bind;
} BluePrintPack;

typedef struct{
    BluePrintPack blue_print_packs[MAX_BLUE_PRINTS];
    uint32_t num_blue_print_packs;
    uint32_t isShadow;
} BluePrints;

typedef struct{
    vec2 position;
    vec2 positionOrig;
    float rotation;
    vec2 scale;
    vec2 scaleOrig;
    struct{
        vec2 offset;
        vec2 scale;
        float rotation;
    }img;
    mat4 model;
} Transform2D;

typedef struct{
    vec3 position;
    vec3 rotation;
    vec3 scale;
    vec4 quaternion;
    struct{
        vec2 offset;
        vec2 scale;
    }img;
    mat4 model;
} Transform3D;

typedef struct GameObject{
    void (*InitPoint)(struct GameObject* go);
    void (*UpdatePoint)(struct GameObject* go);
    void (*DrawPoint)(struct GameObject* go);
    void (*CleanPoint)(struct GameObject* go);
    void (*RecreatePoint)(struct GameObject* go);
    void (*DestroyPoint)(struct GameObject* go);

    void (*ShaderInitPoint)(struct GameObject* go);

    uint32_t obj_type;
    uint32_t flags;
    ChildStack *mem_pool;
    void *mutex;
} GameObject;

typedef struct{
    char vertShader[256];
    char fragShader[256];
} aboutShader;

typedef struct{
    BufferObject buffer;
    uint32_t typeSize;
    uint32_t bufferSize;
    bool extend;
    void* vertices;
    uint32_t num_verts;
} VertexParam;

typedef struct{
    BufferObject buffer;
    uint32_t typeSize;
    uint32_t indexesSize;
    uint32_t bufferSize;
    bool extend;
    uint32_t* indices;
} IndexParam;

typedef struct{
    IndexParam iParam;
    VertexParam vParam;

    VkVertexInputBindingDescription* bindingDescription;
    VkVertexInputAttributeDescription* attr;
    uint32_t countBind;
    uint32_t countAttr;

    uint32_t type;

    bool init;
} Shape;
/// @brief Структура, родитель любого отрисовываемого объекта
typedef struct{
    BluePrints BluePrints;
    GraphicItems gItems;
    aboutShader aShader;
    bool lock;
    Shape shapes[MAX_SHAPES];
    uint32_t num_shapes;
    void *render_point;
    void *shader_mutex;
    void *mem_pool;
    void *buffer_pool;
} GraphicsObject;
/**
 * @defgroup GameObject2D Game Object 2D Структура
 * @ingroup GameObject2D
 * @{
 */

/// @brief Структура двумерного объекта
/// @details Данная структура используется для создания любого двумерного объекта.
typedef struct{
    GameObject self;
    GraphicsObject graphObj;
    Transform2D transform;
    GameObjectImage *image;
    uint32_t num_images;
    char name[64];
} GameObject2D;
/// @}
/**
 * @defgroup GameObject3D Game Object 3D Структура
 * @ingroup GameObject3D
 * @{
 */
/// @brief Структура трёхмерного объекта
typedef struct{
    GameObject self;
    GraphicsObject graphObj;
    Transform3D transform;
    GameObjectImage *diffuses;
    uint32_t num_diffuses;
    GameObjectImage *normals;
    uint32_t num_normals;
    GameObjectImage *speculars;
    uint32_t num_speculars;
    VertexInstance3D *instances;
    BufferObject buffer;
    uint32_t num_instances;
    char name[64];
} GameObject3D;
/// @}

#ifdef __cplusplus
}
#endif

#endif