src/Objects/gameObject2D.c - master - Zamar_Terrier/TigorEngine

src/Objects/gameObject2D.c
613 строк24 KB
Zamar_Terrier
Офигенное обновление движка
31 июл 2026, 21:03
31 июл 2026, 21:031682686
#include "Objects/gameObject2D.h"

#include <vulkan/vulkan.h>
#include <math.h>

#include "Core/e_device.h"
#include "Core/e_buffer.h"
#include "Core/pipeline.h"
#include "Core/e_camera.h"
#include "Core/e_memory.h"

#include "Objects/render_texture.h"

#include "Tools/e_math.h"
#include "Tools/e_shaders.h"
#include "Tools/glsl_parser.h"
#include "Tools/glsl_to_spirv.h"
#include "Tools/shader_builder.h"

#include "Variabels/e_pipeline_variables.h"

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

#include "tigor.h"

extern TEngine engine;

void GameObject2DTransformBufferUpdate(GameObject2D *go, void *data)
{
    RenderTexture *render = (RenderTexture *)go->graphObj.render_point;
    Camera2D* cam = (Camera2D*) &render->cam2D;

    TransformBuffer tbo;
    tbo.model = m4_transform2D(go->transform.position, go->transform.scale, go->transform.rotation);
    tbo.view = m4_transform2D(v2_muls(cam->position, -1), cam->scale, cam->angle);
    tbo.proj = m4_ortho(0, render->width, 0, render->height, -1.0, 1.0f);

    memcpy(data, &tbo, sizeof(tbo));
}

void GameObject2DImageBuffer(GameObject2D *go, void *data)
{
    ImageBufferObjects ibo;
    ibo.model = m4_transform2D(go->transform.img.offset, go->transform.img.scale, go->transform.img.rotation);
    ibo.proj = m4_ortho(0, go->transform.scale.x, go->transform.scale.y, 0, -1.0, 1.0f);

    memcpy(data, &ibo, sizeof(ibo));
}

void GameObject2DDefaultUpdate(GameObject2D* go) {
    for(int i=0; i < go->graphObj.gItems.num_shader_packs;i++)
    {
        BluePrintPack *pack = &go->graphObj.BluePrints.blue_print_packs[i];

        if(go->graphObj.render_point == engine.current_render)
        {
            for(int j=0;j < pack->num_descriptors;j++)
            {
                BluePrintDescriptor *descriptor = &pack->descriptors[j];

                if(descriptor->descrType == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER)
                {
                    if(descriptor->uniform.count == 0 || descriptor->update == NULL)
                        continue;

                    void *point;
                    vkMapMemory(engine.device.e_device, descriptor->uniform.buffers[engine.imageIndex].memory, 0, descriptor->buffsize, 0, &point);
                    UpdateDescriptor update = descriptor->update;
                    update(go, point);
                    vkUnmapMemory(engine.device.e_device, descriptor->uniform.buffers[engine.imageIndex].memory);
                }
            }
        }
    }
}

void GameObject2DDefaultDraw(GameObject2D* go){
    VkCommandBuffer command = engine.device.commandBuffers[engine.imageIndex];
    for(int i = 0; i < go->graphObj.gItems.num_shader_packs; i++) {
        BluePrintPack *bp_pack = &go->graphObj.BluePrints.blue_print_packs[i]; // Переименовано

        if(go->graphObj.render_point == engine.current_render) {
            ShaderPack *shader_pack = &go->graphObj.gItems.shader_packs[i];
            PipelineSetting *settings = &bp_pack->setting; // Используем bp_pack

            VertexParam *vParam = &go->graphObj.shapes[settings->vert_indx].vParam;
            IndexParam *iParam = &go->graphObj.shapes[settings->vert_indx].iParam;

            if(vParam->num_verts == 0) continue;

            if (shader_pack->pipeline.pipeline == VK_NULL_HANDLE) {
                printf("[CRITICAL] Pipeline is NULL for shader pack %i! Skipping draw to prevent crash.\n", i);
                continue;
            }

            vkCmdBindPipeline(command, VK_PIPELINE_BIND_POINT_GRAPHICS, (VkPipeline)shader_pack->pipeline.pipeline);

            if(settings->flags & TIGOR_PIPELINE_FLAG_DYNAMIC_VIEW){
                vkCmdSetViewport(command, 0, 1, (const VkViewport *)&settings->viewport);
                vkCmdSetScissor(command, 0, 1, (const VkRect2D *)&settings->scissor);
            }

            VkBuffer vertexBuffers[] = {vParam->buffer.buffer};
            VkDeviceSize offsets[] = {0};
            vkCmdBindVertexBuffers(command, 0, 1, vertexBuffers, offsets);
            vkCmdBindDescriptorSets(command, VK_PIPELINE_BIND_POINT_GRAPHICS, (VkPipelineLayout)shader_pack->pipeline.layout, 0, 1, &shader_pack->descriptor.descr_sets[engine.imageIndex], 0, NULL);

            if(settings->flags & TIGOR_PIPELINE_FLAG_DRAW_INDEXED){
                vkCmdBindIndexBuffer(command, iParam->buffer.buffer, 0, VK_INDEX_TYPE_UINT32);
                vkCmdDrawIndexed(command, iParam->indexesSize, 1, 0, 0, 0);
            } else {
                vkCmdDraw(command, vParam->num_verts, 1, 0, 0);
            }
        }
    }
}

void GameObject2DAddDescriptor(GameObject2D* go, uint32_t shader_indx, uint32_t size, uint32_t stage_bit, UpdateDescriptor Updater, uint32_t layer_indx){
    BluePrintAddUniformObject(&go->graphObj.BluePrints, shader_indx, size, stage_bit, Updater, layer_indx);
}

void GameObject2DAddDescriptorTexture(GameObject2D* go, uint32_t shader_indx, uint32_t stage_bit, GameObjectImage *image){
    BluePrintAddTextureImage(&go->graphObj.BluePrints, shader_indx, image, stage_bit);
}

void GameObject2DSetDescriptorUpdate(GameObject2D* go, uint32_t shader_indx, uint32_t bind_index, UpdateDescriptor Updater){
    BluePrintAddSomeUpdater(&go->graphObj.BluePrints, shader_indx, bind_index, Updater);
}

void GameObject2DSetDescriptorTexture(GameObject2D* go, uint32_t shader_indx, uint32_t bind_index, Texture2D *texture){
    BluePrintSetTextureImage(&go->graphObj.BluePrints, shader_indx, texture, bind_index);
}

void GameObject2DSetDescriptorTextureCreate(GameObject2D* go, uint32_t shader_indx, uint32_t bind_index, GameObjectImage *image){
    BluePrintSetTextureImageCreate(&go->graphObj.BluePrints, shader_indx, image, bind_index);
}

void GameObject2DSetGLSLShaderForMemory(GameObject2D *go, char *nameOfCache, char *vert_code, char *frag_code){

    ShaderBuilder *variable = NULL;
    ShaderCache *cache = ShadersFind(nameOfCache, NULL, 0);

    if(cache == NULL){
        cache = ShadersMakeLiteNewShader(nameOfCache);
        uint32_t res = ShadersMakeThatShaderBuilderFromMemory(vert_code, cache->vertShader, SHADER_TYPE_VERTEX);
        if(res) return;
        res = ShadersMakeThatShaderBuilderFromMemory(frag_code, cache->fragShader, SHADER_TYPE_FRAGMENT);
        if(res) return;
        cache = ShadersFind(nameOfCache, NULL, 0);
    }

    uint32_t num_pack = BluePrintInit(&go->graphObj.BluePrints);
    ShaderObject vert_shader = {0};
    variable = cache->vertShader;
    vert_shader.code = (char *)variable->code;
    vert_shader.size = variable->size * sizeof(uint32_t);
    ShaderObject frag_shader = {0};
    variable = cache->fragShader;
    frag_shader.code = (char *)variable->code;
    frag_shader.size = variable->size * sizeof(uint32_t);

    GraphicsObjectSetShaderWithUniform(&go->graphObj, &vert_shader, num_pack);
    GraphicsObjectSetShaderWithUniform(&go->graphObj, &frag_shader, num_pack);

    GameObject2DSetDescriptorUpdate((GameObject2D *)go, num_pack, 0, (UpdateDescriptor)GameObject2DTransformBufferUpdate);
    GameObject2DSetDescriptorUpdate((GameObject2D *)go, num_pack, 1, (UpdateDescriptor)GameObject2DImageBuffer);

    if(go->num_images > 0)
        GameObject2DSetDescriptorTextureCreate(go, num_pack, 2, go->image);
    else
        GameObject2DSetDescriptorTextureCreate(go, num_pack, 2, NULL);

    uint32_t flags = BluePrintGetSettingsValue(&go->graphObj.BluePrints, num_pack, 3);
    BluePrintsetSettingsValue(&go->graphObj.BluePrints, num_pack, 3, flags | TIGOR_PIPELINE_FLAG_FACE_CLOCKWISE);

    go->self.flags |= TIGOR_GAME_OBJECT_FLAG_SHADED;
}

uint32_t GameObject2DSetGLSLShaderForMemorySimple(GameObject2D *go, char *nameOfCache, char *vert_code, char *frag_code){

    ShaderBuilder *variable = NULL;
    ShaderCache *cache = ShadersFind(nameOfCache, NULL, 0);

    if(cache == NULL){
        cache = ShadersMakeLiteNewShader(nameOfCache);
        uint32_t res = ShadersMakeThatShaderBuilderFromMemory(vert_code, cache->vertShader, SHADER_TYPE_VERTEX);
        if(res) return 0xFFFFFFFF;
        res = ShadersMakeThatShaderBuilderFromMemory(frag_code, cache->fragShader, SHADER_TYPE_FRAGMENT);
        if(res) return 0xFFFFFFFF;
        cache = ShadersFind(nameOfCache, NULL, 0);
    }

    uint32_t num_pack = BluePrintInit(&go->graphObj.BluePrints);
    ShaderObject vert_shader = {0};
    variable = cache->vertShader;
    vert_shader.code = (char *)variable->code;
    vert_shader.size = variable->size * sizeof(uint32_t);
    ShaderObject frag_shader = {0};
    variable = cache->fragShader;
    frag_shader.code = (char *)variable->code;
    frag_shader.size = variable->size * sizeof(uint32_t);

    GraphicsObjectSetShaderWithUniform(&go->graphObj, &vert_shader, num_pack);
    GraphicsObjectSetShaderWithUniform(&go->graphObj, &frag_shader, num_pack);

    uint32_t flags = BluePrintGetSettingsValue(&go->graphObj.BluePrints, num_pack, 3);
    BluePrintsetSettingsValue(&go->graphObj.BluePrints, num_pack, 3, flags | TIGOR_PIPELINE_FLAG_FACE_CLOCKWISE);

    go->self.flags |= TIGOR_GAME_OBJECT_FLAG_SHADED;

    return num_pack;
}

void GameObject2DSetShader(GameObject2D *go, char *vert_path, char *frag_path){
    char *currPath = DirectGetCurrentFilePath();
    char *full_path_vert = ToolsMakePath(currPath, vert_path);
    if(!full_path_vert || !DirectIsFileExist(full_path_vert)){
        if(full_path_vert) FreeMemory(full_path_vert);
        if(currPath) FreeMemory(currPath);
        return;
    }
    char *full_path_frag = ToolsMakePath(currPath, frag_path);
    if(!full_path_frag || !DirectIsFileExist(full_path_frag)){
        if(full_path_vert) FreeMemory(full_path_vert);
        if(full_path_frag) FreeMemory(full_path_frag);
        if(currPath) FreeMemory(currPath);
        return;
    }

    uint32_t num_pack = BluePrintInit(&go->graphObj.BluePrints);
    ShaderObject vert_code = ReadSPIRVFile(full_path_vert);
    vert_code.flags |= TIGOR_SHADER_OBJECT_READED;
    ShaderObject frag_code = ReadSPIRVFile(full_path_frag);
    frag_code.flags |= TIGOR_SHADER_OBJECT_READED;

    GraphicsObjectSetShaderWithUniform(&go->graphObj, &vert_code, num_pack);
    GraphicsObjectSetShaderWithUniform(&go->graphObj, &frag_code, num_pack);

    FreeMemory(currPath);
    FreeMemory(full_path_vert);
    FreeMemory(full_path_frag);
    go->self.flags |= TIGOR_GAME_OBJECT_FLAG_SHADED;
}

void GameObject2DSetGLSLShader(GameObject2D *go, char *nameOfCache, char *vert_path, char *frag_path){
    char *currPath = DirectGetCurrentFilePath();
    char *full_path_vert = ToolsMakePath(currPath, vert_path);
    if(!full_path_vert || !DirectIsFileExist(full_path_vert)){
        if(full_path_vert) FreeMemory(full_path_vert);
        if(currPath) FreeMemory(currPath);
        return;
    }
    char *full_path_frag = ToolsMakePath(currPath, frag_path);
    if(!full_path_frag || !DirectIsFileExist(full_path_frag)){
        if(full_path_vert) FreeMemory(full_path_vert);
        if(full_path_frag) FreeMemory(full_path_frag);
        if(currPath) FreeMemory(currPath);
        return;
    }

    ShaderBuilder *variable = NULL;
    ShaderCache *cache = ShadersFind(nameOfCache, NULL, 0);

    if(cache == NULL){
        cache = ShadersMakeLiteNewShader(nameOfCache);
        uint32_t res = ShadersMakeThatShaderBuilder(full_path_vert, cache->vertShader, SHADER_TYPE_VERTEX);
        if(res) return;
        res = ShadersMakeThatShaderBuilder(full_path_frag, cache->fragShader, SHADER_TYPE_FRAGMENT);
        if(res) return;
        cache = ShadersFind(nameOfCache, NULL, 0);
    }

    uint32_t num_pack = BluePrintInit(&go->graphObj.BluePrints);
    ShaderObject vert_code = {0};
    variable = cache->vertShader;
    vert_code.code = (char *)variable->code;
    vert_code.size = variable->size * sizeof(uint32_t);
    ShaderObject frag_code = {0};
    variable = cache->fragShader;
    frag_code.code = (char *)variable->code;
    frag_code.size = variable->size * sizeof(uint32_t);

    GraphicsObjectSetShaderWithUniform(&go->graphObj, &vert_code, num_pack);
    GraphicsObjectSetShaderWithUniform(&go->graphObj, &frag_code, num_pack);

    GameObject2DSetDescriptorUpdate((GameObject2D *)go, num_pack, 0, (UpdateDescriptor)GameObject2DTransformBufferUpdate);
    GameObject2DSetDescriptorUpdate((GameObject2D *)go, num_pack, 1, (UpdateDescriptor)GameObject2DImageBuffer);

    if(go->num_images > 0)
        GameObject2DSetDescriptorTextureCreate(go, num_pack, 2, go->image);
    else
        GameObject2DSetDescriptorTextureCreate(go, num_pack, 2, NULL);

    uint32_t flags = BluePrintGetSettingsValue(&go->graphObj.BluePrints, num_pack, 3);
    BluePrintsetSettingsValue(&go->graphObj.BluePrints, num_pack, 3, flags | TIGOR_PIPELINE_FLAG_FACE_CLOCKWISE);

    FreeMemory(currPath);
    FreeMemory(full_path_vert);
    FreeMemory(full_path_frag);

    go->self.flags |= TIGOR_GAME_OBJECT_FLAG_SHADED;
}

uint32_t GameObject2DSetGLSLShaderSimple(GameObject2D *go, char *nameOfCache, char *vert_path, char *frag_path){
    char *currPath = DirectGetCurrentFilePath();
    char *full_path_vert = ToolsMakePath(currPath, vert_path);
    if(!full_path_vert || !DirectIsFileExist(full_path_vert)){
        if(full_path_vert) FreeMemory(full_path_vert);
        if(currPath) FreeMemory(currPath);
        return 0xFFFFFFFF;
    }
    char *full_path_frag = ToolsMakePath(currPath, frag_path);
    if(!full_path_frag || !DirectIsFileExist(full_path_frag)){
        if(full_path_vert) FreeMemory(full_path_vert);
        if(full_path_frag) FreeMemory(full_path_frag);
        if(currPath) FreeMemory(currPath);
        return 0xFFFFFFFF;
    }

    ShaderBuilder *variable = NULL;
    ShaderCache *cache = ShadersFind(nameOfCache, NULL, 0);

    if(cache == NULL){
        cache = ShadersMakeLiteNewShader(nameOfCache);
        uint32_t res = ShadersMakeThatShaderBuilder(full_path_vert, cache->vertShader, SHADER_TYPE_VERTEX);
        if(res) return 0xFFFFFFFF;
        res = ShadersMakeThatShaderBuilder(full_path_frag, cache->fragShader, SHADER_TYPE_FRAGMENT);
        if(res) return 0xFFFFFFFF;
        cache = ShadersFind(nameOfCache, NULL, 0);
    }

    uint32_t num_pack = BluePrintInit(&go->graphObj.BluePrints);
    ShaderObject vert_code = {0};
    variable = cache->vertShader;
    vert_code.code = (char *)variable->code;
    vert_code.size = variable->size * sizeof(uint32_t);
    ShaderObject frag_code = {0};
    variable = cache->fragShader;
    frag_code.code = (char *)variable->code;
    frag_code.size = variable->size * sizeof(uint32_t);

    GraphicsObjectSetShaderWithUniform(&go->graphObj, &vert_code, num_pack);
    GraphicsObjectSetShaderWithUniform(&go->graphObj, &frag_code, num_pack);

    uint32_t flags = BluePrintGetSettingsValue(&go->graphObj.BluePrints, num_pack, 3);
    BluePrintsetSettingsValue(&go->graphObj.BluePrints, num_pack, 3, flags | TIGOR_PIPELINE_FLAG_FACE_CLOCKWISE);

    FreeMemory(currPath);
    FreeMemory(full_path_vert);
    FreeMemory(full_path_frag);

    go->self.flags |= TIGOR_GAME_OBJECT_FLAG_SHADED;

    return num_pack;
}

void GameObject2DSetShaderSimple(GameObject2D *go, char *vert_path, char *frag_path){
    char *currPath = DirectGetCurrentFilePath();
    char *full_path_vert = ToolsMakePath(currPath, vert_path);
    if(!full_path_vert || !DirectIsFileExist(full_path_vert)){
        if(full_path_vert) FreeMemory(full_path_vert);
        if(currPath) FreeMemory(currPath);
        return;
    }
    char *full_path_frag = ToolsMakePath(currPath, frag_path);
    if(!full_path_frag || !DirectIsFileExist(full_path_frag)){
        if(full_path_vert) FreeMemory(full_path_vert);
        if(full_path_frag) FreeMemory(full_path_frag);
        if(currPath) FreeMemory(currPath);
        return;
    }

    uint32_t num_pack = BluePrintInit(&go->graphObj.BluePrints);

    ShaderObject vert_code = ReadSPIRVFile(full_path_vert);
    vert_code.flags |= TIGOR_SHADER_OBJECT_READED;
    ShaderObject frag_code = ReadSPIRVFile(full_path_frag);
    frag_code.flags |= TIGOR_SHADER_OBJECT_READED;

    GraphicsObjectSetShader(&go->graphObj, &vert_code, num_pack, VK_SHADER_STAGE_VERTEX_BIT);
    GraphicsObjectSetShader(&go->graphObj, &frag_code, num_pack, VK_SHADER_STAGE_FRAGMENT_BIT);

    FreeMemory(currPath);
    FreeMemory(full_path_vert);
    FreeMemory(full_path_frag);

    go->self.flags |= TIGOR_GAME_OBJECT_FLAG_SHADED;
}

void GameObject2DInitDefaultShaderWithName(GameObject2D *go, char *name){

    if(go->self.flags & TIGOR_GAME_OBJECT_FLAG_SHADED)
        return;

    uint32_t num_pack = BluePrintInit(&go->graphObj.BluePrints);

    ShaderCache *shader = ShadersFind(name, (uint32_t []){ ERROR_TEXTURE_ENABLE ? true : go->num_images > 0 }, 1);

    if(shader == NULL){
        ShadersMakeDefault2DShader(ERROR_TEXTURE_ENABLE ? true : go->num_images > 0);
        shader = ShadersFind(name, (uint32_t []){ ERROR_TEXTURE_ENABLE ? true : go->num_images > 0 }, 1);
    }

    ShaderBuilder *vert = (ShaderBuilder *)shader->vertShader;
    ShaderBuilder *frag = (ShaderBuilder *)shader->fragShader;

    ShaderObject vert_shader = { 0 }, frag_shader = { 0 };

    vert_shader.code = (char *)vert->code;
    vert_shader.size = vert->size * sizeof(uint32_t);

    frag_shader.code = (char *)frag->code;
    frag_shader.size = frag->size * sizeof(uint32_t);

    GraphicsObjectSetShaderWithUniform(&go->graphObj, &vert_shader, num_pack);
    GraphicsObjectSetShaderWithUniform(&go->graphObj, &frag_shader, num_pack);

    uint32_t flags = BluePrintGetSettingsValue(&go->graphObj.BluePrints, num_pack, 3);
    BluePrintsetSettingsValue(&go->graphObj.BluePrints, num_pack, 3, flags | TIGOR_PIPELINE_FLAG_FACE_CLOCKWISE);

    go->self.flags |= TIGOR_GAME_OBJECT_FLAG_SHADED;
}

void GameObject2DInitDefaultShader(GameObject2D *go){

    if(go->self.flags & TIGOR_GAME_OBJECT_FLAG_SHADED)
        return;

    uint32_t num_pack = BluePrintInit(&go->graphObj.BluePrints);

    ShaderCache *shader = ShadersFind("2DDefault", (uint32_t []){ ERROR_TEXTURE_ENABLE ? true : go->num_images > 0 }, 1);

    if(shader == NULL){
        ShadersMakeDefault2DShader(ERROR_TEXTURE_ENABLE ? true : go->num_images > 0);
        shader = ShadersFind("2DDefault", (uint32_t []){ ERROR_TEXTURE_ENABLE ? true : go->num_images > 0 }, 1);
    }

    ShaderBuilder *vert = (ShaderBuilder *)shader->vertShader;
    ShaderBuilder *frag = (ShaderBuilder *)shader->fragShader;

    ShaderObject vert_shader = { 0 }, frag_shader = { 0 };

    vert_shader.code = (char *)vert->code;
    vert_shader.size = vert->size * sizeof(uint32_t);

    frag_shader.code = (char *)frag->code;
    frag_shader.size = frag->size * sizeof(uint32_t);

    GraphicsObjectSetShaderWithUniform(&go->graphObj, &vert_shader, num_pack);
    GraphicsObjectSetShaderWithUniform(&go->graphObj, &frag_shader, num_pack);

    GameObject2DSetDescriptorUpdate((GameObject2D *)go, num_pack, 0, (UpdateDescriptor)GameObject2DTransformBufferUpdate);
    GameObject2DSetDescriptorUpdate((GameObject2D *)go, num_pack, 1, (UpdateDescriptor)GameObject2DImageBuffer);

    if(go->num_images > 0)
        GameObject2DSetDescriptorTextureCreate(go, num_pack, 2, go->image);
    else
        GameObject2DSetDescriptorTextureCreate(go, num_pack, 2, NULL);

    uint32_t flags = BluePrintGetSettingsValue(&go->graphObj.BluePrints, num_pack, 3);
    BluePrintsetSettingsValue(&go->graphObj.BluePrints, num_pack, 3, flags | TIGOR_PIPELINE_FLAG_FACE_CLOCKWISE);

    /*if(so->type == TIGOR_SHAPE_OBJECT_LINE)
    {
        flags = BluePrintGetSettingsValue(&so->go.graphObj.BluePrints, num_pack, 3);

        BluePrintsetSettingsValue(&so->go.graphObj.BluePrints, num_pack, 1, VK_PRIMITIVE_TOPOLOGY_LINE_LIST);
        BluePrintsetSettingsValue(&so->go.graphObj.BluePrints, num_pack, 3, flags & ~(TIGOR_PIPELINE_FLAG_DRAW_INDEXED));
    }*/

    go->self.flags |= TIGOR_GAME_OBJECT_FLAG_SHADED;
}

void GameObject2DTextureFromRender(GameObject2D *go, void *render){
    BluePrintAddRenderImage(&go->graphObj.BluePrints, 0, render, 2);
}

void GameObject2DInitDraw(GameObject2D *go)
{
    if(!(go->self.flags & TIGOR_GAME_OBJECT_FLAG_SHADED))
        return;

    GraphicsObjectCreateDrawItems(&go->graphObj);

    PipelineCreateGraphics(&go->graphObj);

    go->self.flags |= TIGOR_GAME_OBJECT_FLAG_INIT;
}

void GameObject2DInitDefault(GameObject2D *go){

    GameObjectShaderInit((GameObject *)go);

    GameObject2DInitDraw(go);
}

void GameObject2DClean(GameObject2D* go){
    GraphicsObjectClean(&go->graphObj);
}

void GameObject2DRecreate(GameObject2D* go){

    GameObject2DClean(go);

    for(int i=0; i < go->graphObj.gItems.num_shader_packs;i++)
    {
        BluePrintPack *pack = &go->graphObj.BluePrints.blue_print_packs[i];

        PipelineSetting *settings = &pack->setting;

        settings->scissor.offset.x = 0;
        settings->scissor.offset.y = 0;
        settings->scissor.extent.height = engine.height;
        settings->scissor.extent.width = engine.width;
        settings->viewport.x = 0;
        settings->viewport.y = 0;
        settings->viewport.height = engine.height;
        settings->viewport.width = engine.width;
    }

    BuffersRecreateUniform((BluePrints *)&go->graphObj.BluePrints);

    GraphicsObjectCreateDrawItems(&go->graphObj);
    PipelineCreateGraphics(&go->graphObj);

    Transform2DReposition((GameObject2D *)go);
    Transform2DRescale((GameObject2D *)go);

}

void GameObject2DDestroy(GameObject2D* go){
    if(go->self.flags & TIGOR_GAME_OBJECT_FLAG_DESTROYED) return;

    GraphicsObjectDestroy(&go->graphObj);

    if(go->image != NULL) {
        if(go->image->size > 0 && go->image->buffer != NULL) {
            FreeMemory(go->image->buffer);
        }
        FreeMemory(go->image);
        go->image = NULL;
    }

    tigor_mutex_destroy(go->self.mutex);
    go->self.flags = TIGOR_GAME_OBJECT_FLAG_DESTROYED;
}

int GameObject2DInitTextures(GameObject2D *go, DrawParam *dParam) {
    if(go->image == NULL) {
        go->image = (GameObjectImage *)calloc(1, sizeof(GameObjectImage));
    }

    char *currPath = DirectGetCurrentFilePath();
    if(dParam->diffuse != NULL && strlen(dParam->diffuse) != 0) {
        char *full_path = ToolsMakePath(currPath, dParam->diffuse);
        if(!full_path || !DirectIsFileExist(full_path)){
            if(full_path) FreeMemory(full_path);
            if(currPath) FreeMemory(currPath);
            go->self.flags |= TIGOR_GAME_OBJECT_FLAG_ERROR_IMAGE;
            return 0;
        }
        int len = strlen(full_path);
        if(len >= 2048) len = 2047;
        memcpy(go->image->path, full_path, len);
        go->image->path[len] = '\0';
        go->num_images++;
        FreeMemory(full_path);
    }
    if(currPath) FreeMemory(currPath);
    return 1;
}

void GameObject2DSetRender(GameObject2D *go, void *render){
    go->graphObj.render_point = render;
}

void GameObject2DInit(GameObject2D* go, GameObjectType type)
{
    memset(go, 0, sizeof(GameObject2D));

    tigor_mutex_init((tigor_mutex_t **)&go->self.mutex, 0, NULL);
    GameObjectSetInitFunc((GameObject *)go, (void *)GameObject2DInitDefault);
    GameObjectSetUpdateFunc((GameObject *)go, (void *)GameObject2DDefaultUpdate);
    GameObjectSetDrawFunc((GameObject *)go, (void *)GameObject2DDefaultDraw);
    GameObjectSetCleanFunc((GameObject *)go, (void *)GameObject2DClean);
    GameObjectSetRecreateFunc((GameObject *)go, (void *)GameObject2DRecreate);
    GameObjectSetDestroyFunc((GameObject *)go, (void *)GameObject2DDestroy);

    GameObjectSetShaderInitFunc((GameObject *)go, (void *)GameObject2DInitDefaultShader);

    go->self.obj_type = type;
    go->self.flags = 0;

    Transform2DInit(&go->transform);

    switch(type){
        case TIGOR_GAME_OBJECT_TYPE_2D:
            GraphicsObjectInit(&go->graphObj, TIGOR_VERTEX_TYPE_2D_OBJECT);
            break;
        case TIGOR_GAME_OBJECT_TYPE_PARTICLE_2D:
            GraphicsObjectInit(&go->graphObj, TIGOR_VERTEX_TYPE_2D_PARTICLE);
            break;
    }
}

vec2 GameObject2DGetSize(GameObject2D* go)
{
    /*vec2 size;
    size.x = fabs((go->graphObj.shape.vParam.vertices[1].position.x - go->graphObj.shape.vParam.vertices[3].position.x) * (viewSize.x * diffSize.x)) * go->transform.scale.x;
    size.y = fabs((go->graphObj.shape.vParam.vertices[1].position.y - go->graphObj.shape.vParam.vertices[3].position.y) * (viewSize.y * diffSize.y)) * go->transform.scale.y;
    return size;*/
}