src/gameObject2D.c - main - Zamar_Terrier/TigorEngineWeb

src/gameObject2D.c
486 строк18 KB
Zamar_Terrier
add json and xml parsers
12 мар 2026, 17:40
12 мар 2026, 17:40becab97
#include "gameObject2D.h"

#include <math.h>

#include "e_memory.h"
#include "e_camera.h"

#include "e_math.h"

#include "e_vertex.h"

const char *vertexShaderSource2D = 
      "#version 300 es\n"
      "in vec2 position;   \n"
      "in vec3 color;   \n"
      "in vec2 textCoord;\n"
      "uniform mat4 u_model; \n"
      "uniform mat4 u_view; \n"
      "uniform mat4 u_proj; \n"
      "out vec2 vTextureCoords;\n"
      "out vec3 vFragColor;\n"
      "void main()                 \n"
      "{                           \n"
      "   gl_Position = u_proj * u_view * u_model * vec4(position, 0.0, 1.0); \n"
      "   vTextureCoords = textCoord;\n"
      "   vFragColor = color;\n"
      "}                           \n";      
const char *vertexInstancedShaderSource2D =
      "#version 300 es\n"
      "layout(location = 0) in vec2 position;   \n"
      "layout(location = 1) in vec3 color;   \n"
      "layout(location = 2) in vec2 textCoord;\n"
      "layout(location = 3) in vec2 aInstanceOffset;\n"
      "layout(location = 4) in vec2 aInstanceUV;\n"
      "uniform mat4 u_model; \n"
      "uniform mat4 u_view; \n"
      "uniform mat4 u_proj; \n"
      "out vec2 vTextureCoords;\n"
      "out vec3 vFragColor;\n"
      "void main()                 \n"
      "{                           \n"
      "   gl_Position = u_proj * u_view * u_model * vec4(position + aInstanceOffset, 0.0, 1.0); \n"
      "   vTextureCoords = textCoord + aInstanceUV;\n"
      "   vFragColor = color;\n"
      "}";
const char *fragmentShaderSource2D = 
      "#version 300 es\n"
      "precision highp float;\n"
      "in vec2 vTextureCoords;\n"
      "in vec3 vFragColor;\n"
      "uniform sampler2D u_texture;\n"
      "out vec4 fragColor;\n"
      "void main()                                \n"
      "{                                          \n"
      "  vec4 color = texture(u_texture, vTextureCoords); \n"
      "  fragColor = vec4(vec3(vFragColor * color.rgb), color.a); \n"
      "}                                          \n";

extern TEngine engine;

void GameObject2DInstancedUpdate(GameObject2D* go) {    
        Camera2D* cam = (Camera2D*) engine.cam2D;    
        
        // draw our first triangle
        glUseProgram(go->self.shaderProgram);
        
        mat4 model = m4_transform2D(go->transform.position, go->transform.scale, go->transform.rotation);
        GLint tMat = glGetUniformLocation(go->self.shaderProgram, "u_model");
        glUniformMatrix4fv(tMat, 1, GL_FALSE, (const float*) &model);
        
        mat4 view = m4_transform2D(v2_muls(cam->position, -1), cam->scale, cam->angle);
        tMat = glGetUniformLocation(go->self.shaderProgram, "u_view");
        glUniformMatrix4fv(tMat, 1, GL_FALSE, (const float*) &view);
        
        mat4 proj = m4_ortho(0, engine.width, engine.height, 0.0, -1.0, 1.0f);
        tMat = glGetUniformLocation(go->self.shaderProgram, "u_proj");
        glUniformMatrix4fv(tMat, 1, GL_FALSE, (const float*) &proj);
        
        char buff[64] = {0};        
        for(int i=0;i < go->num_instanced;i++){
            sprintf(buff, "instances[%i]", i);
            tMat = glGetUniformLocation(go->self.shaderProgram, buff);
            glUniform4f(tMat, go->instanced[i].position.x, go->instanced[i].position.y, go->instanced[i].uv.x, go->instanced[i].uv.y);
        }     
}

void GameObject2DInstancedDraw(GameObject2D* go){
        
    if(go->image != NULL){
        glActiveTexture(GL_TEXTURE0);
        glBindTexture(GL_TEXTURE_2D, go->image->texture_id);
    }

    for(int i=0; i < go->graphObj.num_shapes;i++){   
        glBindVertexArray(go->graphObj.shapes[i].VAO);    
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, go->graphObj.shapes[i].iParam.buffer);    
        glDrawElementsInstanced(GL_TRIANGLES, go->graphObj.shapes[i].iParam.count, GL_UNSIGNED_INT, 0, go->num_instanced);
    }
    
    glBindTexture(GL_TEXTURE_2D, 0);
    glUseProgram(0);
}

void GameObject2DDefaultUpdate(GameObject2D* go) {    
        Camera2D* cam = (Camera2D*) engine.cam2D;    
        
        // draw our first triangle
        glUseProgram(go->self.shaderProgram);
        
        mat4 model = m4_transform2D(go->transform.position, go->transform.scale, go->transform.rotation);
        GLint tMat = glGetUniformLocation(go->self.shaderProgram, "u_model");
        glUniformMatrix4fv(tMat, 1, GL_FALSE, (const float*) &model);
        
        mat4 view = m4_transform2D(v2_muls(cam->position, -1), cam->scale, cam->angle);
        tMat = glGetUniformLocation(go->self.shaderProgram, "u_view");
        glUniformMatrix4fv(tMat, 1, GL_FALSE, (const float*) &view);
        
        mat4 proj = m4_ortho(0, engine.width, engine.height, 0.0, -1.0, 1.0f);
        tMat = glGetUniformLocation(go->self.shaderProgram, "u_proj");
        glUniformMatrix4fv(tMat, 1, GL_FALSE, (const float*) &proj);
}

void GameObject2DDefaultDraw(GameObject2D* go){
        
    if(go->image != NULL){
        glActiveTexture(GL_TEXTURE0);
        glBindTexture(GL_TEXTURE_2D, go->image->texture_id);
    }

    for(int i=0; i < go->graphObj.num_shapes;i++){   
        glBindVertexArray(go->graphObj.shapes[i].VAO);    
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, go->graphObj.shapes[i].iParam.buffer);    
        glDrawElements(GL_TRIANGLES, go->graphObj.shapes[i].iParam.count, GL_UNSIGNED_INT, 0);
    }
    
    glBindTexture(GL_TEXTURE_2D, 0);
    glUseProgram(0);
}

void GameObject2DSetShader(GameObject2D *go, const char *vert_source, const char *frag_source){
    
    // build and compile our shader program
    // ------------------------------------
    // vertex shader
    unsigned int vertexShader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vertexShader, 1, (const GLchar *const *) &vert_source, NULL);
    glCompileShader(vertexShader);
    // check for shader compile errors
    int success;
    char infoLog[512];
    glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
    if (!success)
    {
        glGetShaderInfoLog(vertexShader, 512, NULL, infoLog);
        #ifndef NDEBUG
        printf("ERROR::SHADER::VERTEX::COMPILATION_FAILED\n");// << infoLog << std::endl;
        #endif
    }
    // fragment shader
    unsigned int fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fragmentShader, 1, (const GLchar *const *) &frag_source, NULL);
    glCompileShader(fragmentShader);
    // check for shader compile errors
    glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
    if (!success)
    {
        glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog);
        #ifndef NDEBUG
        printf("ERROR::SHADER::FRAGMENT::COMPILATION_FAILED, %s\n", infoLog);// << infoLog << std::endl;
        #endif
    }
    // link shaders
    go->self.shaderProgram = glCreateProgram();
    glAttachShader(go->self.shaderProgram, vertexShader);
    glAttachShader(go->self.shaderProgram, fragmentShader);
    glLinkProgram(go->self.shaderProgram);
    // check for linking errors
    glGetProgramiv(go->self.shaderProgram, GL_LINK_STATUS, &success);
    if (!success) {
        glGetProgramInfoLog(go->self.shaderProgram, 512, NULL, infoLog);
        #ifndef NDEBUG
        printf("ERROR::SHADER::PROGRAM::LINKING_FAILED, %s\n", infoLog);// << infoLog << std::endl;
        #endif
    }
    glDeleteShader(vertexShader);
    glDeleteShader(fragmentShader);
    
    go->self.flags |= TIGOR_GAME_OBJECT_FLAG_SHADED;
}

void GameObject2DInitInstancedShader(GameObject2D *go){    
    
    if(go->self.flags & TIGOR_GAME_OBJECT_FLAG_SHADED)
        return;
    
    // build and compile our shader program
    // ------------------------------------
    // vertex shader
    unsigned int vertexShader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vertexShader, 1, &vertexInstancedShaderSource2D, NULL);
    glCompileShader(vertexShader);
    // check for shader compile errors
    int success;
    char infoLog[512];
    glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
    if (!success)
    {
        glGetShaderInfoLog(vertexShader, 512, NULL, infoLog);
        #ifndef NDEBUG
        printf("ERROR::SHADER::VERTEX::COMPILATION_FAILED, %s\n", infoLog);// << infoLog << std::endl;
        #endif
    }
    // fragment shader
    unsigned int fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fragmentShader, 1, &fragmentShaderSource2D, NULL);
    glCompileShader(fragmentShader);
    // check for shader compile errors
    glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
    if (!success)
    {
        glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog);
        #ifndef NDEBUG
        printf("ERROR::SHADER::FRAGMENT::COMPILATION_FAILED, %s\n", infoLog);// << infoLog << std::endl;
        #endif
    }
    // link shaders
    go->self.shaderProgram = glCreateProgram();
    glAttachShader(go->self.shaderProgram, vertexShader);
    glAttachShader(go->self.shaderProgram, fragmentShader);
    glLinkProgram(go->self.shaderProgram);
    // check for linking errors
    glGetProgramiv(go->self.shaderProgram, GL_LINK_STATUS, &success);
    if (!success) {
        glGetProgramInfoLog(go->self.shaderProgram, 512, NULL, infoLog);
        #ifndef NDEBUG
        printf("ERROR::SHADER::PROGRAM::LINKING_FAILED, %s\n", infoLog);// << infoLog << std::endl;
        #endif
    }
    glDeleteShader(vertexShader);
    glDeleteShader(fragmentShader);
    
    glBindVertexArray(go->graphObj.shapes[0].VAO);
    glBindBuffer(GL_ARRAY_BUFFER, go->graphObj.shapes[0].vParam.buffer);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, go->graphObj.shapes[0].iParam.buffer);

    uint32_t size = sizeof(Vertex2D);

    GLint positionAttribute, colorAttribute, uvAttribute;    
    if((positionAttribute = glGetAttribLocation(go->self.shaderProgram, "position")) < 0){
        #ifndef NDEBUG
        printf("Error to get positition attribute!\n");
        #endif
    }
    if((colorAttribute = glGetAttribLocation(go->self.shaderProgram, "color")) < 0){
        #ifndef NDEBUG
        printf("Error to get color attribute!\n");
        #endif
    }
    if((uvAttribute = glGetAttribLocation(go->self.shaderProgram, "textCoord")) < 0){
        #ifndef NDEBUG
        printf("Error to get textCoord attribute!\n");
        #endif
    }
    glEnableVertexAttribArray(positionAttribute);
    glVertexAttribPointer(positionAttribute, 2, GL_FLOAT, GL_FALSE, size, (void*)0);
    glEnableVertexAttribArray(colorAttribute);
    glVertexAttribPointer(colorAttribute, 3, GL_FLOAT, GL_FALSE, size, (void*)(2 * sizeof(float)));
    glEnableVertexAttribArray(uvAttribute);
    glVertexAttribPointer(uvAttribute, 2, GL_FLOAT, GL_FALSE, size, (void*)(5 * sizeof(float)));
    
    glGenBuffers(1, &go->instanceBuffer);
    glBindBuffer(GL_ARRAY_BUFFER, go->instanceBuffer);
    glBufferData(GL_ARRAY_BUFFER, go->num_instanced * sizeof(InstanceObj), go->instanced, GL_DYNAMIC_DRAW);

    // Атрибут 2: aInstanceOffset (vec3)
    glEnableVertexAttribArray(3);
    glVertexAttribPointer(3, 3, GL_FLOAT, GL_FALSE, sizeof(InstanceObj), (void*)offsetof(InstanceObj, position));
    glVertexAttribDivisor(3, 1); // Один раз на экземпляр

    // Атрибут 3: aInstanceUV (vec2)
    glEnableVertexAttribArray(4);
    glVertexAttribPointer(4, 2, GL_FLOAT, GL_FALSE, sizeof(InstanceObj), (void*)offsetof(InstanceObj, uv));
    glVertexAttribDivisor(4, 1); // Один раз на экземпляр

    glBindBuffer(GL_ARRAY_BUFFER, 0); 
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); 
    glBindVertexArray(0); 
        
    go->self.flags |= TIGOR_GAME_OBJECT_FLAG_SHADED;
}

void GameObject2DInitDefaultShader(GameObject2D *go){    
    
    if(go->self.flags & TIGOR_GAME_OBJECT_FLAG_SHADED)
        return;
    
    // build and compile our shader program
    // ------------------------------------
    // vertex shader
    unsigned int vertexShader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vertexShader, 1, &vertexShaderSource2D, NULL);
    glCompileShader(vertexShader);
    // check for shader compile errors
    int success;
    char infoLog[512];
    glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
    if (!success)
    {
        glGetShaderInfoLog(vertexShader, 512, NULL, infoLog);
        #ifndef NDEBUG
        printf("ERROR::SHADER::VERTEX::COMPILATION_FAILED, %s\n", infoLog);// << infoLog << std::endl;
        #endif
    }
    // fragment shader
    unsigned int fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fragmentShader, 1, &fragmentShaderSource2D, NULL);
    glCompileShader(fragmentShader);
    // check for shader compile errors
    glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
    if (!success)
    {
        glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog);
        #ifndef NDEBUG
        printf("ERROR::SHADER::FRAGMENT::COMPILATION_FAILED, %s\n", infoLog);// << infoLog << std::endl;
        #endif
    }
    // link shaders
    go->self.shaderProgram = glCreateProgram();
    glAttachShader(go->self.shaderProgram, vertexShader);
    glAttachShader(go->self.shaderProgram, fragmentShader);
    glLinkProgram(go->self.shaderProgram);
    // check for linking errors
    glGetProgramiv(go->self.shaderProgram, GL_LINK_STATUS, &success);
    if (!success) {
        glGetProgramInfoLog(go->self.shaderProgram, 512, NULL, infoLog);
        #ifndef NDEBUG
        printf("ERROR::SHADER::PROGRAM::LINKING_FAILED, %s\n", infoLog);// << infoLog << std::endl;
        #endif
    }
    glDeleteShader(vertexShader);
    glDeleteShader(fragmentShader);
    
    glBindVertexArray(go->graphObj.shapes[0].VAO);
    glBindBuffer(GL_ARRAY_BUFFER, go->graphObj.shapes[0].vParam.buffer);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, go->graphObj.shapes[0].iParam.buffer);

    uint32_t size = sizeof(Vertex2D);

    GLint positionAttribute, colorAttribute, uvAttribute;    
    if((positionAttribute = glGetAttribLocation(go->self.shaderProgram, "position")) < 0){
        #ifndef NDEBUG
        printf("Error to get positition attribute!\n");
        #endif
    }
    if((colorAttribute = glGetAttribLocation(go->self.shaderProgram, "color")) < 0){
        #ifndef NDEBUG
        printf("Error to get color attribute!\n");
        #endif
    }
    if((uvAttribute = glGetAttribLocation(go->self.shaderProgram, "textCoord")) < 0){
        #ifndef NDEBUG
        printf("Error to get textCoord attribute!\n");
        #endif
    }
    glEnableVertexAttribArray(positionAttribute);
    glVertexAttribPointer(positionAttribute, 2, GL_FLOAT, GL_FALSE, size, (void*)0);
    glEnableVertexAttribArray(colorAttribute);
    glVertexAttribPointer(colorAttribute, 3, GL_FLOAT, GL_FALSE, size, (void*)(2 * sizeof(float)));
    glEnableVertexAttribArray(uvAttribute);
    glVertexAttribPointer(uvAttribute, 2, GL_FLOAT, GL_FALSE, size, (void*)(5 * sizeof(float)));
    
    glBindBuffer(GL_ARRAY_BUFFER, 0); 
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); 
    glBindVertexArray(0); 
        
    go->self.flags |= TIGOR_GAME_OBJECT_FLAG_SHADED;
}

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

    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);

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

}

void GameObject2DDestroy(GameObject2D* go){

    //GraphicsObjectDestroy(&go->graphObj);

    if(go->image != NULL)
    {
        if(strlen(go->image->path))
            FreeMemory(go->image->path);

        if(go->image->size > 0)
            FreeMemory(go->image->buffer);

        FreeMemory(go->image);
    }

    for(int i=0; i < go->graphObj.num_shapes; i++)
    {
        if(go->graphObj.shapes[i].vParam.count)
            FreeMemory(go->graphObj.shapes[i].vParam.vertices);

        if(go->graphObj.shapes[i].iParam.count)
            FreeMemory(go->graphObj.shapes[i].iParam.indices);
    }

    if(go->instanceBuffer != 0){
        glDeleteBuffers(1, (const GLuint *)go->instanceBuffer);
    }
    
    glDeleteShader(go->self.shaderProgram);
    glDeleteBuffers(1, &go->graphObj.shapes[0].vParam.buffer);
    glDeleteBuffers(1, &go->graphObj.shapes[0].iParam.buffer);
    glDeleteVertexArrays(1, &go->graphObj.shapes[0].VAO);

    go->self.flags &= ~(TIGOR_GAME_OBJECT_FLAG_INIT);
}

void GameObject2DInitInstanced(GameObject2D* go, uint32_t count, GameObjectType type){
    GameObject2DInit(go, type);

    memset(go->instanced , 0, sizeof(go->instanced));
    go->num_instanced = count;
    
    GameObjectSetDrawFunc((GameObject *)go, (void *)GameObject2DInstancedDraw);
    GameObjectSetUpdateFunc((GameObject *)go, (void *)GameObject2DInstancedUpdate);
    GameObjectSetShaderInitFunc((GameObject *)go, (void *)GameObject2DInitInstancedShader);
}

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

    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;
    go->instanceBuffer = 0;

    Transform2DInit(&go->transform);

    switch(type){
        case TIGOR_GAME_OBJECT_TYPE_3D:
        case TIGOR_GAME_OBJECT_TYPE_MODEL:
        case TIGOR_GAME_OBJECT_TYPE_PARTICLE_3D:
            break;
        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;
    }

}