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

src/Objects/shape_object.c
274 строки7 KB
Ilia Zamaruev
hot fix
17 ноя 2025, 17:55
17 ноя 2025, 17:55732330d
#include "Objects/shape_object.h"

#include <vulkan/vulkan.h>

#include "Core/e_buffer.h"
#include "Core/e_camera.h"
#include "Core/e_memory.h"
#include "Core/e_blue_print.h"

#include "Tools/e_math.h"
#include "Tools/e_shaders.h"

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

extern TEngine engine;

void ShapeObjectCreateQuad(ShapeObject *so)
{
    Vertex2D *verts = AllocateMemory(4, sizeof(Vertex2D));

    verts[0].position.x = -1.0f;
    verts[0].position.y = -1.0f;
    verts[0].texCoord.x = 0;
    verts[0].texCoord.y = 0;

    verts[1].position.x = 1.0f;
    verts[1].position.y = -1.0f;
    verts[1].texCoord.x = 1.0f;
    verts[1].texCoord.y = 0;

    verts[2].position.x = 1.0f;
    verts[2].position.y = 1.0f;
    verts[2].texCoord.x = 1.0f;
    verts[2].texCoord.y = 1.0f;

    verts[3].position.x = -1.0f;
    verts[3].position.y = 1.0f;
    verts[3].texCoord.x = 0;
    verts[3].texCoord.y = 1.0f;

    for(int i=0;i < 4;i++)
    {
        verts[i].color = vec4_f(1, 1, 1, 1);
    }

    uint32_t *tIndx = AllocateMemory(6, sizeof(uint32_t));

    uint32_t indx[] = {
      0, 1, 2, 2, 3, 0
    };

    memcpy(tIndx, indx, 6 * sizeof(uint32_t));

    VertextIterator vi = {0};
    vi.i_index = 6;
    vi.v_index = 4;
    GraphicsObjectSetVertex(&so->go.graphObj, verts, sizeof(Vertex2D), tIndx, &vi);
    
    FreeMemory(verts);
    FreeMemory(tIndx);
}

void ShapeObjectCreateCircle(ShapeObject *so, CircleParams *param)
{
    int freq = param->freq;

    float stackAngle, sectorAngle;

    if(freq < 3)
        freq = 3;


    uint32_t num_verts = (freq + 1);
    Vertex2D *verts = AllocateMemory( num_verts, sizeof(Vertex2D));

    float angInc = 2 * ((float)M_PI / freq);

    verts[0].position.x = 0;
    verts[0].position.y = 0;

    verts[0].texCoord.x = 0.5f;
    verts[0].texCoord.y = 0.5f;

    verts[0].color = param->color;

    float divW = param->radius / engine.width;
    float divH = param->radius / engine.height;

    for(int i=1;i <= freq;i++)
    {
        Vertex2D *vert = &verts[i];

        float x = cos(i * angInc);
        float y = sin(i * angInc);

        vert->position.x = x * divW;
        vert->position.y = y * divH;

        vert->texCoord.x = (float)(x + 1.0f) / 2;
        vert->texCoord.y = (float)(y + 1.0f) / 2;

        vert->color = param->color;
    }

    uint32_t indx_size = (freq + 1) * 3;
    uint32_t *indx = AllocateMemory( indx_size, sizeof(uint32_t));

    int k0 = 0, k1 = 1, k2 = 2, iter = 0;
    for(int i = 0; i <= freq; ++i)
    {
        indx[iter] = k0;
        indx[iter + 1] = k1;
        indx[iter + 2] = k2;

        k1 ++;
        k2 ++;

        if(k2 == num_verts)
            k2 = 1;

        iter +=3;
    }

    VertextIterator vi = { num_verts, indx_size };
    GraphicsObjectSetVertex(&so->go.graphObj, verts, sizeof(Vertex2D), indx, &vi);
    
    FreeMemory(verts);
    FreeMemory(indx);
}

void ShapeObjectCreateShape(ShapeObject *so, ShapeParams *param)
{

    if(param->num_positions <= 2)
        return;

    uint32_t num_verts = param->num_positions + 1;
    Vertex2D *verts = AllocateMemory( num_verts, sizeof(Vertex2D));

    vec2 center = {0, 0};

    vec2 w_size = { engine.width, engine.height };

    vec2 min = param->positions[0];
    vec2 max = param->positions[0];
    for(int i=1; i < param->num_positions; i++)
    {
        if(min.x > param->positions[i].x)
            min.x = param->positions[i].x;
        else if(min.y > param->positions[i].y)
            min.y = param->positions[i].y;

        if(max.x < param->positions[i].x)
            max.x = param->positions[i].x;
        else if(max.y < param->positions[i].y)
            max.y = param->positions[i].y;
    }

    min = v2_div(min, w_size);
    max = v2_div(max, w_size);

    for(int i=0; i < param->num_positions; i++)
    {
        Vertex2D *vert = &verts[i + 1];

        vert->position = v2_div(param->positions[i], w_size);
        vert->texCoord.x = vert->position.x / max.x + min.x;
        vert->texCoord.y = vert->position.y / max.y + min.y;
        vert->color = param->color;

        center = v2_add(center, param->positions[i]);
    }

    center = v2_divs(center, param->num_positions);

    verts[0].position = v2_div(center, w_size);
    verts[0].texCoord.x = 0.5f;
    verts[0].texCoord.y = 0.5f;
    verts[0].color = param->color;


    uint32_t indx_size = (param->num_positions + 1) * 3;
    uint32_t *indx = AllocateMemory( indx_size, sizeof(uint32_t));

    int k0 = 0, k1 = 1, k2 = 2, iter = 0;
    for(int i = 0; i < param->num_positions; ++i)
    {
        indx[iter] = k0;
        indx[iter + 1] = k1;
        indx[iter + 2] = k2;

        k1 ++;
        k2 ++;

        if(k2 == num_verts)
            k2 = 1;

        iter +=3;
    }

    VertextIterator vi = { num_verts, indx_size };
    GraphicsObjectSetVertex(&so->go.graphObj, verts, sizeof(Vertex2D), indx, &vi);
    
    FreeMemory(verts);
    FreeMemory(indx);
}

void ShapeObjectCreateLine(ShapeObject *so, LineParams *line)
{
    Vertex2D *verts = AllocateMemory(2, sizeof(Vertex2D));


    vec2 position;

    verts[0].position.x = line->position.x / engine.width;
    position.x = verts[0].position.x + (line->direction.x * (line->length / engine.width));

    verts[0].position.y = line->position.y / engine.height;
    position.y = verts[0].position.y + (line->direction.y * (line->length / engine.height));

    verts[0].color = line->color;

    verts[1].position = position;
    verts[1].color = line->color;


    VertextIterator vi = { 2, 0 };
    GraphicsObjectSetVertex(&so->go.graphObj, verts, sizeof(Vertex2D), NULL, &vi);
    
    FreeMemory(verts);
}

int ShapeObjectInit(ShapeObject *so, DrawParam *dParam, ShapeType type, void *param)
{
    char *name = "Shape_Object";

    memcpy(so->go.name, name, strlen(name));

    GameObject2DInit((GameObject2D *)so, TIGOR_GAME_OBJECT_TYPE_2D);

    switch(type)
    {
        case TIGOR_SHAPE_OBJECT_LINE:
            ShapeObjectCreateLine(so, param);
            break;
        case TIGOR_SHAPE_OBJECT_QUAD:
            ShapeObjectCreateQuad(so);
            break;
        case TIGOR_SHAPE_OBJECT_CIRCLE:
            ShapeObjectCreateCircle(so, param);
            break;
        case TIGOR_SHAPE_OBJECT_SHAPE:
            ShapeObjectCreateShape(so, param);
            break;
        default:
            printf("Error Shape Type!\n");
            break;
    }

    so->type = type;

    if(dParam != NULL){
        so->go.image = AllocateMemory(1, sizeof(GameObjectImage));

        GameObject2DInitTextures((GameObject2D *)&so->go, dParam);
    }

    so->go.graphObj.num_shapes = 1;

    so->go.self.flags |= TIGOR_GAME_OBJECT_FLAG_PREINIT;

    return 1;
}