src/gameObject3D.c - main - Zamar_Terrier/TigorEngineWeb

src/gameObject3D.c
326 строк11 KB
ZamarTerrier
fix objects
20 фев 2026, 22:01
20 фев 2026, 22:016e1ae70
#include "gameObject3D.h"

#include <math.h>

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

#include "e_math.h"

#include "e_vertex.h"

const char *vertexShaderSource3D = 
      "#version 300 es\n"
      "layout(location = 0) in vec3 position;   \n"
      "layout(location = 1) in vec3 normal;   \n"
      "layout(location = 2) in vec3 color;   \n"
      "layout(location = 3) 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, 1.0); \n"
      "   vTextureCoords = textCoord;\n"
      "   vFragColor = color;\n"
      "}                           \n";
const char *fragmentShaderSource3D = 
      "#version 300 es\n"
      "precision highp float;                   \n"
      "uniform sampler2D u_texture;\n"
      "in vec2 vTextureCoords;\n"
      "in vec3 vFragColor;\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 GameObject3DDefaultUpdate(GameObject3D* go) {    
        Camera3D* cam = (Camera3D*) engine.cam3D;    
        
        vec3 cameraUp = {0.0f, 1.0f, 0.0f};

        // draw our first triangle
        glUseProgram(go->self.shaderProgram);

        mat4 model = m4_transform(go->transform.position, go->transform.scale, go->transform.rotation);
        unsigned int tMat = glGetUniformLocation(go->self.shaderProgram, "u_model");
        glUniformMatrix4fv(tMat, 1, GL_FALSE, (const float*) &model);
        
        mat4 view = m4_look_at(cam->position, v3_add(cam->position, cam->rotation), cameraUp);
        tMat = glGetUniformLocation(go->self.shaderProgram, "u_view");
        glUniformMatrix4fv(tMat, 1, GL_FALSE, (const float*) &view);
        
        mat4 proj = m4_perspective(engine.width, engine.height, cam->view_angle, cam->view_near, cam->view_distance);
        //proj.m[1][1] *= -1;
        tMat = glGetUniformLocation(go->self.shaderProgram, "u_proj");
        glUniformMatrix4fv(tMat, 1, GL_FALSE, (const float*) &proj);
                        
}

void GameObject3DDefaultDraw(GameObject3D* go){
    
    glEnable(GL_DEPTH_TEST);
    glDepthFunc(GL_LESS);
    
    glEnable(GL_CULL_FACE); 
    glCullFace(GL_BACK); 

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

    }

    glDisable(GL_DEPTH_TEST);
    glDisable(GL_CULL_FACE);
    
    glBindTexture(GL_TEXTURE_2D, 0);
    glUseProgram(0);
}

void GameObject3DSetShader(GameObject3D *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\n");// << 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\n");// << infoLog << std::endl;
        #endif
    }
    glDeleteShader(vertexShader);
    glDeleteShader(fragmentShader);

    go->self.flags |= TIGOR_GAME_OBJECT_FLAG_SHADED;
}

void GameObject3DInitDefaultShader(GameObject3D *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, &vertexShaderSource3D, 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, &fragmentShaderSource3D, 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\n");// << 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\n");// << 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(Vertex3D);

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

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

    go->self.flags |= TIGOR_GAME_OBJECT_FLAG_INIT;
}

void GameObject3DInitDefault(GameObject3D *go){

    GameObjectShaderInit((GameObject *)go);

    GameObject3DInitDraw(go);
}

void GameObject3DClean(GameObject3D* go){
    //GraphicsObjectClean(&go->graphObj);
}

void GameObject3DRecreate(GameObject3D* go){

    //GameObject3DClean(go);

}

void GameObject3DDestroy(GameObject3D* 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);
    }
    
    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 GameObject3DInit(GameObject3D* go, GameObjectType type)
{
    GameObjectSetInitFunc((GameObject *)go, (void *)GameObject3DInitDefault);
    GameObjectSetUpdateFunc((GameObject *)go, (void *)GameObject3DDefaultUpdate);
    GameObjectSetDrawFunc((GameObject *)go, (void *)GameObject3DDefaultDraw);
    GameObjectSetCleanFunc((GameObject *)go, (void *)GameObject3DClean);
    GameObjectSetRecreateFunc((GameObject *)go, (void *)GameObject3DRecreate);
    GameObjectSetDestroyFunc((GameObject *)go, (void *)GameObject3DDestroy);
    
    GameObjectSetShaderInitFunc((GameObject *)go, (void *)GameObject3DInitDefaultShader);

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

    Transform3DInit(&go->transform);

    switch(type){
        case TIGOR_GAME_OBJECT_TYPE_3D:
            GraphicsObjectInit(&go->graphObj, TIGOR_VERTEX_TYPE_3D_OBJECT);
            break;
        case TIGOR_GAME_OBJECT_TYPE_PARTICLE_3D:
            GraphicsObjectInit(&go->graphObj, TIGOR_VERTEX_TYPE_3D_PARTICLE);
            break;
        case TIGOR_GAME_OBJECT_TYPE_MODEL:
        case TIGOR_GAME_OBJECT_TYPE_2D:
        case TIGOR_GAME_OBJECT_TYPE_PARTICLE_2D:
            break;
    }

}