480 lines
14 KiB
C
480 lines
14 KiB
C
/**
|
|
* @file
|
|
* graphics header
|
|
*
|
|
* This file is part of Gem-graph.
|
|
*
|
|
* @cond LICENSE
|
|
* Copyright © 2021 Libre en Communs <contact@a-lec.org>
|
|
* Copyright © 2021-2024 Adrien Bourmault <neox@a-lec.org>
|
|
* Copyright © 2021-2024 Jean Sirmai <jean@a-lec.org>
|
|
*
|
|
* 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/>.
|
|
* @endcond
|
|
*/
|
|
|
|
|
|
#pragma once
|
|
#include "base.h"
|
|
#include <epoxy/gl.h>
|
|
#include <GL/glu.h>
|
|
|
|
#define VERTEX_SHADER_FILE "src/shader.vert" /**< phantom documentation */
|
|
#define FRAG_SHADER_FILE "src/shader.frag" /**< phantom documentation */
|
|
#define GL_TARGET_MAJOR_VERSION 0 /**< phantom documentation */
|
|
#define GL_TARGET_MINOR_VERSION 4 /**< phantom documentation */
|
|
|
|
|
|
/******************************************************************************/
|
|
/* G L A R E A */
|
|
/******************************************************************************/
|
|
|
|
/**
|
|
* Structure describing a gl_area and its parameters, used to create a table
|
|
* of Gem-graph client current gl_areas
|
|
*/
|
|
struct graphics_stack_t {
|
|
|
|
int id; /**< phantom documentation */
|
|
int mode; /**< phantom documentation */
|
|
|
|
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; /**< phantom documentation */
|
|
long arrows_nb; /**< phantom documentation */
|
|
|
|
GLfloat *buffer_vertex_origin; /**< phantom documentation */
|
|
GLfloat *buffer_colors_origin; /**< phantom documentation */
|
|
GLuint *buffer_lines_origin; /**< phantom documentation */
|
|
GLuint *buffer_plans_origin; /**< phantom documentation */
|
|
|
|
long buffer_vertex_size; /**< phantom documentation */
|
|
long buffer_colors_size; /**< phantom documentation */
|
|
long buffer_lines_size; /**< phantom documentation */
|
|
long buffer_plans_size; /**< phantom documentation */
|
|
|
|
long buffer_vertex_0_arrow; /**< phantom documentation */
|
|
long buffer_colors_0_arrow; /**< phantom documentation */
|
|
long buffer_lines_0_arrow; /**< phantom documentation */
|
|
long buffer_plans_0_arrow; /**< phantom documentation */
|
|
};
|
|
|
|
/**
|
|
* Dynamic array of ptrs to dynamically allocated gl_area_entry
|
|
*/
|
|
extern struct graphics_stack_t *graphics_stack;
|
|
|
|
/**
|
|
* Structure describing a gl_area and its parameters, used to create a table
|
|
* of Gem-graph client current gl_areas
|
|
*/
|
|
bool graphics_render_stack(GtkWidget *container_widget);
|
|
|
|
/** phantom documentation */
|
|
bool graphics_setup_glarea(int target_mode, GtkWidget *target_widget);
|
|
|
|
int graphics_init(void *error_buffer);
|
|
|
|
/**
|
|
* Draws the current buffer to a gl_area
|
|
*
|
|
* @param graphics_stack_id
|
|
*/
|
|
void graphics_draw(const int graphics_stack_id);
|
|
|
|
/**
|
|
* Shutdowns a gl_area
|
|
*
|
|
* @param graphics_stack_id
|
|
* @param *error_buffer
|
|
*
|
|
* @return true if success
|
|
*/
|
|
bool graphics_shutdown(const int graphics_stack_id, void *error_buffer);
|
|
|
|
/**
|
|
* Initializes the shaders of a gl_area and link them to a program
|
|
*
|
|
* @param graphics_stack_id
|
|
* gl_area, ptr to the gl_area widget
|
|
*
|
|
* @return true if initialized
|
|
*/
|
|
bool graphics_init_shaders(const int graphics_stack_id);
|
|
|
|
/** phantom documentation */
|
|
bool graphics_init_graphics_stack(void *container_widget, GError *error_buffer);
|
|
|
|
/** phantom documentation */
|
|
bool graphics_shutdown_graphics_stack(void *container_widget, GError *error_buffer);
|
|
|
|
/** phantom documentation */
|
|
bool graphics_update_axis_stack(GtkWidget *container_widget, int axis, int value);
|
|
|
|
/**
|
|
* Initializes the buffer of a gl_area
|
|
* Calls according to the user preferences
|
|
* @param gl_area, ptr to the gl_area widget
|
|
*/
|
|
void graphics_init_buffers(const int graphics_stack_id);
|
|
|
|
/**
|
|
* Draws a vertex (x, y, z)
|
|
* if (console) prints (x, y, z) values to console
|
|
*
|
|
* @param GLfloat x, GLfloat y, GLfloat z
|
|
*/
|
|
void graphics_draw_vertex (const int graphics_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
|
|
*
|
|
*/
|
|
//void graphics_draw_color (const int graphics_stack_id, GLfloat r, GLfloat g, GLfloat b);
|
|
|
|
/**
|
|
* Writes values to describe a line from a to b into the line buffer
|
|
*
|
|
* @use liste de fonctions GTK
|
|
*
|
|
* @param coords GLuint (a,b)
|
|
*/
|
|
void graphics_draw_line (const int graphics_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)
|
|
*/
|
|
void graphics_draw_plan (const int graphics_stack_id, GLuint a, GLuint b, GLuint c);
|
|
|
|
/**
|
|
* Created and compile a shader
|
|
*
|
|
* @param graphics_stack_id,
|
|
* @param shader type
|
|
* @param src (source code of shader)
|
|
*
|
|
* @return shader id
|
|
*/
|
|
static inline GLuint graphics_create_shader(const int graphics_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 graphics_print_stack(int graphics_stack_id)
|
|
{
|
|
static int n = 0;
|
|
|
|
printf("\n[n=%d]***************", n);
|
|
|
|
printf("id = %d\tmode = %d\n",
|
|
graphics_stack[graphics_stack_id].id,
|
|
graphics_stack[graphics_stack_id].mode);
|
|
|
|
printf("rotation_angles = ");
|
|
for (int i = 0; i < N_AXIS; i++) {
|
|
printf("%f\t", graphics_stack[graphics_stack_id].rotation_angles[i]);
|
|
// Rotation angles on each axis
|
|
}
|
|
printf("\n");
|
|
|
|
printf("vao = %d\n", graphics_stack[graphics_stack_id].vao);
|
|
printf("position_buffer = %d\n", graphics_stack[graphics_stack_id].position_buffer);
|
|
printf("color_buffer = %d\n", graphics_stack[graphics_stack_id].color_buffer);
|
|
printf("program = %d\n", graphics_stack[graphics_stack_id].program);
|
|
printf("m = %d\n", graphics_stack[graphics_stack_id].m);
|
|
printf("v = %d\n", graphics_stack[graphics_stack_id].v);
|
|
printf("p = %d\n", graphics_stack[graphics_stack_id].p);
|
|
|
|
printf("arrows_ptr = %p\n", graphics_stack[graphics_stack_id].arrows_ptr);
|
|
printf("arrows_nb = %ld\n", graphics_stack[graphics_stack_id].arrows_nb);
|
|
|
|
printf("buffer_vertex_origin = %p\n", graphics_stack[graphics_stack_id].buffer_vertex_origin);
|
|
printf("buffer_colors_origin = %p\n", graphics_stack[graphics_stack_id].buffer_colors_origin);
|
|
printf("buffer_lines_origin = %p\n", graphics_stack[graphics_stack_id].buffer_lines_origin);
|
|
printf("buffer_plans_origin = %p\n", graphics_stack[graphics_stack_id].buffer_plans_origin);
|
|
|
|
printf("buffer_vertex_size = %ld\n", graphics_stack[graphics_stack_id].buffer_vertex_size);
|
|
printf("buffer_colors_size = %ld\n", graphics_stack[graphics_stack_id].buffer_colors_size);
|
|
printf("buffer_lines_size = %ld\n", graphics_stack[graphics_stack_id].buffer_lines_size);
|
|
printf("buffer_plans_size = %ld\n", graphics_stack[graphics_stack_id].buffer_plans_size);
|
|
|
|
printf("buffer_vertex_0_arrow = %ld\n", graphics_stack[graphics_stack_id].buffer_vertex_0_arrow);
|
|
printf("buffer_colors_0_arrow = %ld\n", graphics_stack[graphics_stack_id].buffer_colors_0_arrow);
|
|
printf("buffer_lines_0_arrow = %ld\n", graphics_stack[graphics_stack_id].buffer_lines_0_arrow);
|
|
printf("buffer_plans_0_arrow = %ld\n", graphics_stack[graphics_stack_id].buffer_plans_0_arrow);
|
|
|
|
printf("********************\n");
|
|
n++;
|
|
}
|
|
|
|
|
|
/**
|
|
* Initializes a gl_area
|
|
*
|
|
* @param *error_buffer 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
|
|
*/
|
|
//void graphics_draw(const int graphics_stack_id);
|
|
|
|
/**
|
|
* Shutdowns a gl_area
|
|
*
|
|
* @param gl_area, ptr to the gl_area widget
|
|
*
|
|
* @return true if success
|
|
*/
|
|
bool graphics_shutdown(const int graphics_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 graphics_stack_id);
|
|
|
|
/**
|
|
* Initializes the buffer of a gl_area
|
|
* Calls according to the user preferences
|
|
* @param graphics_stack_id gl_area, ptr to the gl_area widget
|
|
*/
|
|
void graphics_init_buffers(const int graphics_stack_id);
|
|
|
|
/**
|
|
* Draws a vertex (x, y, z)
|
|
* if (console) prints (x, y, z) values to console
|
|
*
|
|
* @param graphics_stack_id
|
|
* @param x
|
|
* @param y
|
|
* @param z
|
|
*/
|
|
void graphics_draw_vertex (const int graphics_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 graphics_stack_id
|
|
* @param r
|
|
* @param g
|
|
* @param b
|
|
*/
|
|
void graphics_draw_color (const int graphics_stack_id, GLfloat r, GLfloat g, GLfloat b);
|
|
|
|
/**
|
|
* Writes values to describe a line from a to b into the line buffer
|
|
*
|
|
* @param graphics_stack_id
|
|
* @param a
|
|
* @param b
|
|
*/
|
|
void graphics_draw_line (const int graphics_stack_id, GLuint a, GLuint b);
|
|
|
|
/**
|
|
* Writes values to describe an (a,b,c) plan (triangle) into the plan buffer
|
|
*
|
|
* @param graphics_stack_id
|
|
* @param a
|
|
* @param b
|
|
* @param c
|
|
*/
|
|
void graphics_draw_plan (const int graphics_stack_id, GLuint a, GLuint b, GLuint c);
|
|
|
|
/**
|
|
* graphics_model_setup
|
|
*
|
|
* @param graphics_stack_id
|
|
*/
|
|
void graphics_model_setup (const int graphics_stack_id);
|
|
|
|
/**
|
|
* Draws one arrow vertex (x, y, z)
|
|
* if (console) prints (x, y, z) values to console
|
|
*
|
|
* @param graphics_stack_id
|
|
* @param space_X
|
|
* @param space_Y
|
|
* @param space_Z
|
|
* @param weight
|
|
* @param site
|
|
* @param x
|
|
* @param y
|
|
* @param z
|
|
*
|
|
* @returns i
|
|
*/
|
|
int graphics_draw_one_arrow_vertex (const int graphics_stack_id,
|
|
int space_X,
|
|
int space_Y,
|
|
int space_Z,
|
|
int weight,
|
|
int site,
|
|
int x,
|
|
int y,
|
|
int z);
|
|
|
|
/**
|
|
* Draws one arrow vertex (x, y, z)
|
|
* if (console) prints (x, y, z) values to console
|
|
*
|
|
* @param graphics_stack_id
|
|
* @param offset_vertex
|
|
*
|
|
* @returns i
|
|
*/
|
|
int graphics_draw_one_arrow_line(const int graphics_stack_id,
|
|
int offset_vertex);
|
|
|
|
/**
|
|
* Writes grid ridges to vertex and color buffers
|
|
*
|
|
* @param graphics_stack_id
|
|
* @param offset_vertex
|
|
* @param x
|
|
* @param y
|
|
* @param z
|
|
*
|
|
* @returns i
|
|
*/
|
|
int graphics_draw_space_ridges_vertex (const int graphics_stack_id,
|
|
long offset_vertex,
|
|
long x,
|
|
long y,
|
|
long z);
|
|
|
|
/**
|
|
* draw_space_ridges_lines
|
|
*
|
|
* @param graphics_stack_id
|
|
*
|
|
* @returns i
|
|
*/
|
|
int graphics_draw_space_ridges_lines (const int graphics_stack_id);
|
|
|
|
/**
|
|
* Writes grid lines on space faces
|
|
*
|
|
* @param graphics_stack_id
|
|
* @param x
|
|
* @param y
|
|
* @param z
|
|
*
|
|
* @returns l
|
|
*/
|
|
long graphics_draw_grids_on_space_faces_vertex (const int graphics_stack_id,
|
|
long x,
|
|
long y,
|
|
long z);
|
|
|
|
/**
|
|
* @param graphics_stack_id
|
|
* @param offset_vertex
|
|
* @param x
|
|
* @param y
|
|
* @param z
|
|
*
|
|
* @returns l
|
|
*/
|
|
long graphics_draw_grids_on_space_faces_lines (const int graphics_stack_id,
|
|
long offset_vertex,
|
|
long x,
|
|
long y,
|
|
long z);
|
|
|
|
/**
|
|
* set_arrow
|
|
*
|
|
* @param graphics_stack_id
|
|
* @param arrows_nb
|
|
* @param space_X
|
|
* @param space_Y
|
|
* @param space_Z
|
|
* @param requested_weight
|
|
* @param site
|
|
* @param x
|
|
* @param y
|
|
* @param z
|
|
*
|
|
* @returns i
|
|
*/
|
|
int graphics_set_arrow (int graphics_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);
|
|
|