gem-graph-client/include/graphics.h

/*
 *      Gem-graph OpenGL experiments
 *
 *      Desc: OpenGL utils header
 *
 *  Copyright (C) 2023 Arthur Menges <arthur.menges@a-lec.org>
 *  Copyright (C) 2023 Adrien Bourmault <neox@a-lec.org>
 *  Copyright (C) 2023 Jean Sirmai <jean@a-lec.org>
 *
 *  This file is part of Gem-graph.
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU Affero General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU Affero General Public License for more details.
 *
 *  You should have received a copy of the GNU Affero General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#pragma once
#include "base.h"
#include <unistd.h>
#include <stdbool.h>
#include <epoxy/gl.h>
#include <GL/glu.h>
#include <GL/glext.h>

#define VERTEX_SHADER_FILE "src/graphics/shaders/shader.vert"
#define FRAG_SHADER_FILE "src/graphics/shaders/shader.frag"
#define GL_TARGET_MAJOR_VERSION 0
#define GL_TARGET_MINOR_VERSION 4

/*
 * Structure describing a gl_area and its parameters, used to create a table
 * of Gem-graph client current gl_areas
 */
struct graphic_stack_t {

    int id;
    int mode;

    float rotation_angles[N_AXIS]; // Rotation angles on each axis

    GLuint vao;             //  init_buffers
    GLuint position_buffer; //  shutdown, draw
    GLuint color_buffer;    //  shutdown, draw
    GLuint program;         //  shutdown, init_shaders, draw
    GLuint m;               //  init_shaders, draw
    GLuint v;               //  init_shaders, draw
    GLuint p;               //  init_shaders, draw

    struct arrow_t *arrows_ptr;
    long arrows_nb;

    GLfloat *buffer_vertex_origin;
    GLfloat *buffer_colors_origin;
    GLuint *buffer_lines_origin;
    GLuint *buffer_plans_origin;

    long buffer_vertex_size;
    long buffer_colors_size;
    long buffer_lines_size;
    long buffer_plans_size;

    long buffer_vertex_0_arrow;
    long buffer_colors_0_arrow;
    long buffer_lines_0_arrow;
    long buffer_plans_0_arrow;
};

/*
 * Dynamic array of ptrs to dynamically allocated gl_area_entry
 */
extern struct graphic_stack_t *graphic_stack;

/*
 * Initializes a gl_area
 *
 * @param   gl_area, ptr to the gl_area widget
 *
 * @return  true if initialized
 */
int graphics_init(void *error_buffer);

/*
 * Draws the current buffer to a gl_area
 *
 * @param   gl_area, ptr to the gl_area widget
 *
 * @return  void
 */
void graphics_draw(const int stack_id);

/*
 * Shutdowns a gl_area
 *
 * @param   gl_area, ptr to the gl_area widget
 *
 * @return  true if success
 */
bool graphics_shutdown(const int stack_id, void *error_buffer);

/*
 * Initializes the shaders of a gl_area and link them to a program
 *
 * @param   gl_area, ptr to the gl_area widget
 *
 * @return  true if initialized
 */
bool graphics_init_shaders(const int stack_id);

/* Initializes the buffer of a gl_area
 * Calls according to the user preferences
 * @param   gl_area, ptr to the gl_area widget
 * @return  void
 */
void graphics_init_buffers(const int stack_id);

/*
 * Draws a vertex (x, y, z)
 * if (console) prints (x, y, z) values to console
 *
 * @param   GLfloat x, GLfloat y, GLfloat z
 *
 * @return  void
 */
void graphics_draw_vertex (const int stack_id,
                           GLfloat x,
                           GLfloat y,
                           GLfloat z);

/*
 * Draws the color (r, g, b) associated to a vertex
 * if (console) prints (r, g, b) values to console
 *
 * @param   GLfloat r, GLfloat g, GLfloat b
 *
 * @return  void
 */
void graphics_draw_color (const int stack_id, GLfloat r, GLfloat g, GLfloat b);

/*
 *  Writes values to describe a line from a to b into the line buffer
 *
 *  @param coords GLuint (a,b)
 *
 *  @return void
 */
void graphics_draw_line (const int stack_id, GLuint a, GLuint b);

/*
 *  Writes values to describe an (a,b,c) plan (triangle) into the plan buffer
 *
 *  @param coords GLuint (a,b,c)
 *
 *  @return void
 */
void graphics_draw_plan (const int stack_id, GLuint a, GLuint b, GLuint c);

/*
 * Initializes an identity matrix
 *
 * @param   res, target ptr
 *
 * @return  void
 */
static inline void compute_i(float *res)
{
    /* initialize to the identity matrix */
    res[0] = 1.f; res[4] = 0.f; res[8] = 0.f; res[12] = 0.f;
    res[1] = 0.f; res[5] = 1.f; res[9] = 0.f; res[13] = 0.f;
    res[2] = 0.f; res[6] = 0.f; res[10] = 1.f; res[14] = 0.f;
    res[3] = 0.f; res[7] = 0.f; res[11] = 0.f; res[15] = 1.f;
}

/*
 * Computes the projection matrix
 *
 * @param   res, target ptr
 *          phi, XXX
 *          theta, XXX
 *          psi, XXX
 *
 * @return  void
 */
static inline void compute_mvp(float *res, float phi, float theta, float psi)
{
    float x = phi *(G_PI / 180.f);
    float y = theta *(G_PI / 180.f);
    float z = psi *(G_PI / 180.f);
    float c1 = cosf(x), s1 = sinf(x);
    float c2 = cosf(y), s2 = sinf(y);
    float c3 = cosf(z), s3 = sinf(z);
    float c3c2 = c3 * c2;
    float s3c1 = s3 * c1;
    float c3s2s1 = c3 * s2 * s1;
    float s3s1 = s3 * s1;
    float c3s2c1 = c3 * s2 * c1;
    float s3c2 = s3 * c2;
    float c3c1 = c3 * c1;
    float s3s2s1 = s3 * s2 * s1;
    float c3s1 = c3 * s1;
    float s3s2c1 = s3 * s2 * c1;
    float c2s1 = c2 * s1;
    float c2c1 = c2 * c1;

    compute_i(res);

    /* apply all three rotations using the three matrices:
     *
     * ⎡  c3 s3  0 ⎤ ⎡ c2  0 -s2 ⎤ ⎡ 1   0  0 ⎤
     * ⎢ -s3 c3  0 ⎥ ⎢  0  1   0 ⎥ ⎢ 0  c1 s1 ⎥
     * ⎣  0   0  1 ⎦ ⎣ s2  0  c2 ⎦ ⎣ 0 -s1 c1 ⎦
     */
    res[0] = c3c2;  res[4] = s3c1 + c3s2s1; res[8] = s3s1 - c3s2c1; res[12] = 0.f;
    res[1] = -s3c2; res[5] = c3c1 - s3s2s1; res[9] = c3s1 + s3s2c1; res[13] = 0.f;
    res[2] = s2;    res[6] = -c2s1;         res[10] = c2c1;         res[14] = 0.f;
    res[3] = 0.f;   res[7] = 0.f;           res[11] = 0.f;          res[15] = 1.f;
}

/*
 * Created and compile a shader
 *
 * @param   type, shader type
 *          src, source code of shader
 *
 * @return  shader id
 */
static inline GLuint create_shader(const int stack_id, int type, const char *src)
{
    GLuint shader;
    int status;

    shader = glCreateShader(type);
    glShaderSource(shader, 1, &src, NULL);
    glCompileShader(shader);

    glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
    if(status == GL_FALSE) {
        int log_len;
        char *buffer;

        glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &log_len);

        buffer = g_malloc(log_len + 1);
        assert (buffer);
        glGetShaderInfoLog(shader, log_len, NULL, buffer);

        g_warning("Compile failure in %s shader:\n%s",
                             type == GL_VERTEX_SHADER ? "vertex" : "fragment",
                             buffer);

        g_free(buffer);

        glDeleteShader(shader);

        return 0;
     }

    return shader;
}

static inline void print_stack(int stack_id)
{
    static int n = 0;

    printf("\n[n=%d]***************", n);

    printf("id = %d\tmode = %d\n",
           graphic_stack[stack_id].id,
           graphic_stack[stack_id].mode);

    printf("rotation_angles = ");
    for (int i = 0; i < N_AXIS; i++) {
        printf("%f\t", graphic_stack[stack_id].rotation_angles[i]); // Rotation angles on each axis
    }
    printf("\n");

    printf("vao = %d\n", graphic_stack[stack_id].vao);
    printf("position_buffer = %d\n", graphic_stack[stack_id].position_buffer);
    printf("color_buffer = %d\n", graphic_stack[stack_id].color_buffer);
    printf("program = %d\n", graphic_stack[stack_id].program);
    printf("m = %d\n", graphic_stack[stack_id].m);
    printf("v = %d\n", graphic_stack[stack_id].v);
    printf("p = %d\n", graphic_stack[stack_id].p);

    printf("arrows_ptr = %p\n", graphic_stack[stack_id].arrows_ptr);
    printf("arrows_nb = %ld\n", graphic_stack[stack_id].arrows_nb);

    printf("buffer_vertex_origin = %p\n", graphic_stack[stack_id].buffer_vertex_origin);
    printf("buffer_colors_origin = %p\n", graphic_stack[stack_id].buffer_colors_origin);
    printf("buffer_lines_origin = %p\n", graphic_stack[stack_id].buffer_lines_origin);
    printf("buffer_plans_origin = %p\n", graphic_stack[stack_id].buffer_plans_origin);

    printf("buffer_vertex_size = %ld\n", graphic_stack[stack_id].buffer_vertex_size);
    printf("buffer_colors_size = %ld\n", graphic_stack[stack_id].buffer_colors_size);
    printf("buffer_lines_size = %ld\n", graphic_stack[stack_id].buffer_lines_size);
    printf("buffer_plans_size = %ld\n", graphic_stack[stack_id].buffer_plans_size);

    printf("buffer_vertex_0_arrow = %p\n", graphic_stack[stack_id].buffer_vertex_0_arrow);
    printf("buffer_colors_0_arrow = %p\n", graphic_stack[stack_id].buffer_colors_0_arrow);
    printf("buffer_lines_0_arrow = %p\n", graphic_stack[stack_id].buffer_lines_0_arrow);
    printf("buffer_plans_0_arrow = %p\n", graphic_stack[stack_id].buffer_plans_0_arrow);

    printf("********************\n");
    n++;
}

/*** TEST ***/

void main_test_graphics (const int stack_id);

/*
 * Structure describing an arrow
 */
struct arrow_t {
    GLuint load;
    GLuint site;
    GLuint x;
    GLuint y;
    GLuint z;
};

int draw_one_arrow_vertex (const int stack_id,
                           int space_X,
                           int space_Y,
                           int space_Z,
                           int weight,
                           int site,
                           int x,
                           int y,
                           int z);

int draw_one_arrow_line(const int stack_id,
                        int offset_vertex);

/*
 *  Writes grid ridges to vertex and color buffers
 *
 *  @param  coords long (x,y,z), step_x, step_y, step_z
 *
 *  @return void
 */
int draw_space_ridges_vertex (const int stack_id,
                              long offset_vertex,
                              long x,
                              long y,
                              long z);

int draw_space_ridges_lines (const int stack_id);

/*
 *  Writes grid lines on space faces
 *
 *  @param  coords long (x,y,z)
 *
 *  @return void
 */
long draw_grids_on_space_faces_vertex (const int stack_id,
                                       long x,
                                       long y,
                                       long z);

long draw_grids_on_space_faces_lines (const int stack_id,
                                      long offset_vertex,
                                      long x,
                                      long y,
                                      long z);

int set_arrow (int stack_id,
               int arrows_nb,
               int space_X,
               int space_Y,
               int space_Z,
               int requested_weight,
               int site,
               int arrow_x,
               int arrow_y,
               int arrow_z);