From 3f59e99ba1b5632ee4f51427775291367aebd754 Mon Sep 17 00:00:00 2001 From: Jean Sirmai Date: Sun, 2 Jul 2023 00:38:45 +0200 Subject: [PATCH] =?UTF-8?q?WIP:=20content=20!=20=20premiere=20r=C3=A9organ?= =?UTF-8?q?isation=20OK=20=20(ajustements,=20r=C3=A9glages,...)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- include/buffers.h | 6 +- src/graphics/buffers.c | 365 ++++++++++++++++++++++++---------------- src/graphics/graphics.c | 27 +-- 3 files changed, 236 insertions(+), 162 deletions(-) diff --git a/include/buffers.h b/include/buffers.h index eebe238..d88fa51 100644 --- a/include/buffers.h +++ b/include/buffers.h @@ -40,15 +40,17 @@ /*----------------------------------------------------------------------------*/ -bool compute_space(int model_space_size_x, +bool compute_space_and_arrows(int model_space_size_x, GLfloat *vertex_base, GLfloat *color_base, GLubyte *line_origin, GLubyte *plan_origin, - GLubyte *arrows, + GLubyte *arrows, int model_arrows_nb, + int vgap, int cgap, int lgap, int pgap, bool pref_3D_xor_2D_space, bool pref_lines_planes_or_mix, bool pref_mark_unit_space_first, bool pref_mark_unit_space_last); + // bool compute_arrow(int state_size, // GLfloat *vertex_base, GLfloat *color_base, // GLubyte *line_ndx, GLubyte *plan_ndx, diff --git a/src/graphics/buffers.c b/src/graphics/buffers.c index 574292f..5536e66 100644 --- a/src/graphics/buffers.c +++ b/src/graphics/buffers.c @@ -46,9 +46,9 @@ int line_ndx = 0; #define V 1 -#define I 0 +#define I 1 #define EDGE 0.999999 -static bool compute_space_2D(int state_size, +static bool compute_space_2D(int space_size_x, GLfloat *vertex_base, GLfloat *color_base, GLubyte *line_origin, GLubyte *plan_origin, bool pref_lines_planes_or_mix, @@ -57,24 +57,24 @@ static bool compute_space_2D(int state_size, { float x = 0; - // for (int k = 0; k < state_size + 1; k++) <=> + 1 + // for (int k = 0; k < space_size_x + 1; k++) <=> + 1 // car on passe du nombre de cases = (n) // au nombre de séparations entre les cases + les deux bords = (n + 1) - if (V) printf("vertices "); - for (int k = 0; k < state_size; k++){ // barres verticales + if (V) printf("vertex "); + for (int k = 0; k < space_size_x; k++){ // barres verticales // - x = ((state_size % 2) * (state_size / 2 - k) - + (state_size % 2 - 1) * (k + 0.5f - state_size / 2)) / state_size * 2 * EDGE; + x = ((space_size_x % 2) * (space_size_x / 2 - k) + + (space_size_x % 2 - 1) * (k + 0.5f - space_size_x / 2)) / space_size_x * 2 * EDGE; if (V) printf("[%1.1f] ", x); *(vertex_base + k * 6 + 0) = - x; - *(vertex_base + k * 6 + 1) = 1.0f / state_size; + *(vertex_base + k * 6 + 1) = 1.0f / space_size_x; *(vertex_base + k * 6 + 2) = 0.0f; *(vertex_base + k * 6 + 3) = - x; - *(vertex_base + k * 6 + 4) = - 1.0f / state_size; + *(vertex_base + k * 6 + 4) = - 1.0f / space_size_x; *(vertex_base + k * 6 + 5) = 0.0f; *(color_base + k * 6 + 0) = 1; @@ -94,28 +94,28 @@ static bool compute_space_2D(int state_size, *(color_base + 4) = 1; *(color_base + 5) = 1; - *(color_base + (state_size - 1) * 6 + 0) = 1; - *(color_base + (state_size - 1) * 6 + 1) = 1; - *(color_base + (state_size - 1) * 6 + 2) = 1; + *(color_base + (space_size_x - 1) * 6 + 0) = 1; + *(color_base + (space_size_x - 1) * 6 + 1) = 1; + *(color_base + (space_size_x - 1) * 6 + 2) = 1; - *(color_base + (state_size - 1) * 6 + 3) = 0; - *(color_base + (state_size - 1) * 6 + 4) = 0; - *(color_base + (state_size - 1) * 6 + 5) = 0; + *(color_base + (space_size_x - 1) * 6 + 3) = 0; + *(color_base + (space_size_x - 1) * 6 + 4) = 0; + *(color_base + (space_size_x - 1) * 6 + 5) = 0; - if (V) printf(" n = %d x 2 côté = [%1.1f]\n", state_size + 1, 2.0f / state_size); + if (V) printf(" n = %d x 2 côté = [%1.1f]\n", space_size_x + 1, 2.0f / space_size_x); - for (int k = 0; k < state_size * 2; k++) *(line_origin + k) = k; - line_ndx += state_size * 2; + for (int k = 0; k < space_size_x * 2; k++) *(line_origin + k) = k; + line_ndx += space_size_x * 2; *(line_origin + line_ndx + 0) = 0; - *(line_origin + line_ndx + 1) = state_size * 2 - 2; // barre horizontale du bas + *(line_origin + line_ndx + 1) = space_size_x * 2 - 2; // barre horizontale du bas *(line_origin + line_ndx + 2) = 1; - *(line_origin + line_ndx + 3) = state_size * 2 - 1; // barre horizontale du haut + *(line_origin + line_ndx + 3) = space_size_x * 2 - 1; // barre horizontale du haut - if (I) printf("line_origin (%d - state_size(0)) x (%d - state_size(1)) ", 0, 1); + if (I) printf("line_origin (%d - space_size_x(0)) x (%d - space_size_x(1)) ", 0, 1); - for (int v = 0; v < state_size + 2; v++) + for (int v = 0; v < space_size_x + 2; v++) if (I) printf("(%d-%d) ", *(line_origin + v), *(line_origin + v + 1)); if (pref_mark_unit_space_first) { // diagonales to mark first space unit @@ -128,98 +128,109 @@ static bool compute_space_2D(int state_size, if (pref_mark_unit_space_last) { // diagonales to mark last space unit line_ndx +=4; - *(line_origin + line_ndx + 0) = (state_size - 2) * 2 + 0; - *(line_origin + line_ndx + 1) = (state_size - 2) * 2 + 3; - *(line_origin + line_ndx + 2) = (state_size - 2) * 2 + 1; - *(line_origin + line_ndx + 3) = (state_size - 2) * 2 + 2; + *(line_origin + line_ndx + 0) = (space_size_x - 2) * 2 + 0; + *(line_origin + line_ndx + 1) = (space_size_x - 2) * 2 + 3; + *(line_origin + line_ndx + 2) = (space_size_x - 2) * 2 + 1; + *(line_origin + line_ndx + 3) = (space_size_x - 2) * 2 + 2; } - if (I) printf(" n = 4 + (%d x 2)\n", state_size + 2); + if (I) printf(" n = 4 + (%d x 2)\n", space_size_x + 2); return 1; } -static bool compute_arrow_2D(int state_size, - GLfloat *vertex_base, GLfloat *color_base, - GLubyte *line_origin, GLubyte *plan_ndx, - int vgap, int igap, int cgap, - int weight, int site, int x, int y, int z) +static bool compute_arrow_2D(int space_size_x, + GLfloat *vertex_base, + GLfloat *color_base, + GLubyte *line_origin, + GLubyte *plan_origin, + bool pref_lines_planes_or_mix, + int vgap, int cgap, int lgap, int pgap, + int weight, int site, int x, int y, int z) { - float zero = 0.0f; - float center = (1.0f / state_size) * (2 * x - state_size + 2); - // float tip = center + (2 * site - 1) * (1.0f / state_size); - float base = center + (2 * site - 1) * (0.1f / state_size); + float center = (1.0f / space_size_x) * (2 * x - space_size_x + 2); + // float tip = center + (2 * site - 1) * (1.0f / space_size_x); + float base = center + (2 * site - 1) * (0.1f / space_size_x); - *(vertex_base + vgap + 0) = center + (2 * site - 1) * (1.0f / state_size - 0.01f); + vgap = space_size_x * 6; + + *(vertex_base + vgap + 0) = center + (2 * site - 1) * (1.0f / space_size_x - 0.01f); *(vertex_base + vgap + 1) = zero; *(vertex_base + vgap + 2) = zero; *(vertex_base + vgap + 3) = base; - *(vertex_base + vgap + 4) = 0.4f / state_size; + *(vertex_base + vgap + 4) = 0.4f / space_size_x; *(vertex_base + vgap + 5) = zero; *(vertex_base + vgap + 6) = base; - *(vertex_base + vgap + 7) = - 0.4f / state_size; + *(vertex_base + vgap + 7) = - 0.4f / space_size_x; *(vertex_base + vgap + 8) = zero; + lgap = space_size_x * 4; - *(line_origin + igap + 0) = vgap / 3 + 0; - *(line_origin + igap + 1) = vgap / 3 + 1; - *(line_origin + igap + 2) = vgap / 3 + 0; - *(line_origin + igap + 3) = vgap / 3 + 2; - *(line_origin + igap + 4) = vgap / 3 + 1; - *(line_origin + igap + 5) = vgap / 3 + 2; + if (pref_lines_planes_or_mix == 0) { + *(line_origin + lgap + 0) = vgap / 3 + 0; + *(line_origin + lgap + 1) = vgap / 3 + 1; + *(line_origin + lgap + 2) = vgap / 3 + 0; + *(line_origin + lgap + 3) = vgap / 3 + 2; + *(line_origin + lgap + 4) = vgap / 3 + 1; + *(line_origin + lgap + 5) = vgap / 3 + 2; + } - *(plan_ndx + 0) = vgap / 3 + 0; - *(plan_ndx + 1) = vgap / 3 + 1; - *(plan_ndx + 2) = vgap / 3 + 2; + pgap = 0; - *(plan_ndx + 3) = vgap / 3 + 0; - *(plan_ndx + 4) = vgap / 3 + 1; - *(plan_ndx + 5) = vgap / 3 + 2; + if (pref_lines_planes_or_mix == 1) { + *(plan_origin + pgap + 0) = vgap / 3 + 0; + *(plan_origin + pgap + 1) = vgap / 3 + 1; + *(plan_origin + pgap + 2) = vgap / 3 + 2; - return 1; + *(plan_origin + pgap + 3) = vgap / 3 + 0; + *(plan_origin + pgap + 4) = vgap / 3 + 1; + *(plan_origin + pgap + 5) = vgap / 3 + 2; + } + return 0; } -static bool compute_space_3D(int state_size, +static bool compute_space_3D(int space_size_x, GLfloat *vertex_base, GLfloat *color_base, - GLubyte *line_origin, + GLubyte *line_origin, GLubyte *plan_origin, + bool pref_lines_planes_or_mix, bool pref_mark_unit_space_first, bool pref_mark_unit_space_last) { float x = 0; - // for (int k = 0; k < state_size + 1; k++) <=> + 1 car + // for (int k = 0; k < space_size_x + 1; k++) <=> + 1 car // on passe du nombre de cases = (n) // au nombre de séparations entre les cases + les deux bords = (n + 1) - if (V) printf("vertices "); - for (int k = 0; k < state_size; k++){ // barres verticales + if (V) printf("vertex "); + for (int k = 0; k < space_size_x; k++){ // barres verticales // - x = ((state_size % 2) * (state_size / 2 - k) - + (state_size % 2 - 1) * (k + 0.5f - state_size / 2)) / state_size * 2 * EDGE; + x = ((space_size_x % 2) * (space_size_x / 2 - k) + + (space_size_x % 2 - 1) * (k + 0.5f - space_size_x / 2)) / space_size_x * 2 * EDGE; if (V) printf("[%1.1f] ", x); *(vertex_base + k * 12 + 0) = - x; - *(vertex_base + k * 12 + 1) = 1.0f / state_size; - *(vertex_base + k * 12 + 2) = 1.0f / state_size; + *(vertex_base + k * 12 + 1) = 1.0f / space_size_x; + *(vertex_base + k * 12 + 2) = 1.0f / space_size_x; *(vertex_base + k * 12 + 3) = - x; - *(vertex_base + k * 12 + 4) = - 1.0f / state_size; - *(vertex_base + k * 12 + 5) = - 1.0f / state_size; + *(vertex_base + k * 12 + 4) = - 1.0f / space_size_x; + *(vertex_base + k * 12 + 5) = - 1.0f / space_size_x; *(vertex_base + k * 12 + 6) = - x; - *(vertex_base + k * 12 + 7) = 1.0f / state_size; - *(vertex_base + k * 12 + 8) = - 1.0f / state_size; + *(vertex_base + k * 12 + 7) = 1.0f / space_size_x; + *(vertex_base + k * 12 + 8) = - 1.0f / space_size_x; *(vertex_base + k * 12 + 9) = - x; - *(vertex_base + k * 12 + 10) = - 1.0f / state_size; - *(vertex_base + k * 12 + 11) = 1.0f / state_size; + *(vertex_base + k * 12 + 10) = - 1.0f / space_size_x; + *(vertex_base + k * 12 + 11) = 1.0f / space_size_x; - *(color_base + k * 12 + 0) = 1; // 1 - (k / state_size); + *(color_base + k * 12 + 0) = 1; // 1 - (k / space_size_x); *(color_base + k * 12 + 1) = 0; *(color_base + k * 12 + 2) = 0; @@ -252,47 +263,47 @@ static bool compute_space_3D(int state_size, *(color_base + 10) = 1; *(color_base + 11) = 1; - *(color_base + (state_size - 1) * 12 + 0) = 1; - *(color_base + (state_size - 1) * 12 + 1) = 1; - *(color_base + (state_size - 1) * 12 + 2) = 1; + *(color_base + (space_size_x - 1) * 12 + 0) = 1; + *(color_base + (space_size_x - 1) * 12 + 1) = 1; + *(color_base + (space_size_x - 1) * 12 + 2) = 1; - *(color_base + (state_size - 1) * 12 + 3) = 0; - *(color_base + (state_size - 1) * 12 + 4) = 0; - *(color_base + (state_size - 1) * 12 + 5) = 0; + *(color_base + (space_size_x - 1) * 12 + 3) = 0; + *(color_base + (space_size_x - 1) * 12 + 4) = 0; + *(color_base + (space_size_x - 1) * 12 + 5) = 0; - *(color_base + (state_size - 1) * 12 + 6) = 0; - *(color_base + (state_size - 1) * 12 + 7) = 0; - *(color_base + (state_size - 1) * 12 + 8) = 0; + *(color_base + (space_size_x - 1) * 12 + 6) = 0; + *(color_base + (space_size_x - 1) * 12 + 7) = 0; + *(color_base + (space_size_x - 1) * 12 + 8) = 0; - *(color_base + (state_size - 1) * 12 + 9) = 1; - *(color_base + (state_size - 1) * 12 + 10) = 1; - *(color_base + (state_size - 1) * 12 + 11) = 1; + *(color_base + (space_size_x - 1) * 12 + 9) = 1; + *(color_base + (space_size_x - 1) * 12 + 10) = 1; + *(color_base + (space_size_x - 1) * 12 + 11) = 1; - if (V) printf(" n = %d x 2 côté = [%1.1f]\n", state_size + 1, 2.0f / state_size); + if (V) printf(" n = %d x 2 côté = [%1.1f]\n", space_size_x + 1, 2.0f / space_size_x); *(line_origin + 4) = 0; - *(line_origin + 5) = state_size * 4 - 4; // barre horizontale du bas arr + *(line_origin + 5) = space_size_x * 4 - 4; // barre horizontale du bas arr *(line_origin + 6) = 1; - *(line_origin + 7) = state_size * 4 - 3; // barre horizontale du haut arr + *(line_origin + 7) = space_size_x * 4 - 3; // barre horizontale du haut arr *(line_origin + 0) = 2; - *(line_origin + 1) = state_size * 4 - 2; // barre horizontale du bas av + *(line_origin + 1) = space_size_x * 4 - 2; // barre horizontale du bas av *(line_origin + 2) = 3; - *(line_origin + 3) = state_size * 4 - 1; // barre horizontale du haut av + *(line_origin + 3) = space_size_x * 4 - 1; // barre horizontale du haut av - /* *(plan_ndx + 0) = 0; */ - /* *(plan_ndx + 1) = 1; */ - /* *(plan_ndx + 2) = 2; */ + /* *(plan_origin + 0) = 0; */ + /* *(plan_origin + 1) = 1; */ + /* *(plan_origin + 2) = 2; */ - /* *(plan_ndx + 3) = 0; */ - /* *(plan_ndx + 4) = 1; */ - /* *(plan_ndx + 5) = 3; */ + /* *(plan_origin + 3) = 0; */ + /* *(plan_origin + 4) = 1; */ + /* *(plan_origin + 5) = 3; */ - for (int k = 8; k <= state_size * 8; k += 8){ // for (int k = 8; k < state_size * 8; k += 8){ + for (int k = 8; k <= space_size_x * 8; k += 8){ // for (int k = 8; k < space_size_x * 8; k += 8){ *(line_origin + k + 0) = k / 2 - 4; // + 0; @@ -310,24 +321,24 @@ static bool compute_space_3D(int state_size, if (pref_mark_unit_space_first) { - *(line_origin + (2 + state_size) * 8 - 4) = 0 + 0; // diagonales pour marquer la case zéro - *(line_origin + (2 + state_size) * 8 - 3) = 0 + 1; + *(line_origin + (2 + space_size_x) * 8 - 4) = 0 + 0; // diagonales pour marquer la case zéro + *(line_origin + (2 + space_size_x) * 8 - 3) = 0 + 1; - *(line_origin + (2 + state_size) * 8 - 2) = 0 + 2; // diagonales pour marquer la case zéro - *(line_origin + (2 + state_size) * 8 - 1) = 0 + 3; + *(line_origin + (2 + space_size_x) * 8 - 2) = 0 + 2; // diagonales pour marquer la case zéro + *(line_origin + (2 + space_size_x) * 8 - 1) = 0 + 3; } if (pref_mark_unit_space_last) { - *(line_origin + (2 + state_size) * 8 - 8) = (state_size - 1) * 4 + 0; // diagonales pour marquer la case finale - *(line_origin + (2 + state_size) * 8 - 7) = (state_size - 1) * 4 + 1; + *(line_origin + (2 + space_size_x) * 8 - 8) = (space_size_x - 1) * 4 + 0; // diagonales pour marquer la case finale + *(line_origin + (2 + space_size_x) * 8 - 7) = (space_size_x - 1) * 4 + 1; - *(line_origin + (2 + state_size) * 8 - 6) = (state_size - 1) * 4 + 2; // diagonales pour marquer la case finale - *(line_origin + (2 + state_size) * 8 - 5) = (state_size - 1) * 4 + 3; + *(line_origin + (2 + space_size_x) * 8 - 6) = (space_size_x - 1) * 4 + 2; // diagonales pour marquer la case finale + *(line_origin + (2 + space_size_x) * 8 - 5) = (space_size_x - 1) * 4 + 3; } if (I) printf("line_origin "); - for (int v = 0; v < state_size + 2; v++) { + for (int v = 0; v < space_size_x + 2; v++) { if (I) printf("(%d-%d) ", *(line_origin + v), *(line_origin + v + 1)); } @@ -338,105 +349,163 @@ if (pref_mark_unit_space_last) { return 1; } -static bool compute_arrow_3D(int state_size, +static bool compute_arrow_3D(int space_size_x, GLfloat *vertex_base, GLfloat *color_base, - GLubyte *line_origin, GLubyte *plan_ndx, - int vgap, int igap, int cgap, + GLubyte *line_origin, GLubyte *plan_origin, + bool pref_lines_planes_or_mix, + int vgap, int cgap, int lgap, int pgap, int weight, int site, int x, int y, int z) { float zero = 0.0f; - float center = (1.0f / state_size) * (2 * x - state_size + 2); - float tip = center + (2 * site - 1) * (1.0f / state_size); - float base = center + (2 * site - 1) * (0.1f / state_size); + float center = (1.0f / space_size_x) * (2 * x - space_size_x + 2); + float tip = center + (2 * site - 1) * (1.0f / space_size_x); + float base = center + (2 * site - 1) * (0.1f / space_size_x); if (I) printf("compute_arrow_3D vgap = %d\n", vgap); - *(vertex_base + vgap + 0) = center + (2 * site - 1) * (1.0f / state_size - 0.01f); + vgap = space_size_x * 12; + + *(vertex_base + vgap + 0) = center + (2 * site - 1) * (1.0f / space_size_x - 0.01f); *(vertex_base + vgap + 1) = zero; *(vertex_base + vgap + 2) = zero; *(vertex_base + vgap + 3) = base; - *(vertex_base + vgap + 4) = 0.4f / state_size; - *(vertex_base + vgap + 5) = 0.4f / state_size; + *(vertex_base + vgap + 4) = 0.4f / space_size_x; + *(vertex_base + vgap + 5) = 0.4f / space_size_x; *(vertex_base + vgap + 6) = base; - *(vertex_base + vgap + 7) = 0.4f / state_size; - *(vertex_base + vgap + 8) = - 0.4f / state_size; + *(vertex_base + vgap + 7) = 0.4f / space_size_x; + *(vertex_base + vgap + 8) = - 0.4f / space_size_x; *(vertex_base + vgap + 9) = base; - *(vertex_base + vgap + 10) = - 0.4f / state_size; - *(vertex_base + vgap + 11) = - 0.4f / state_size; + *(vertex_base + vgap + 10) = - 0.4f / space_size_x; + *(vertex_base + vgap + 11) = - 0.4f / space_size_x; *(vertex_base + vgap + 12) = base; - *(vertex_base + vgap + 13) = - 0.4f / state_size; - *(vertex_base + vgap + 14) = 0.4f / state_size; + *(vertex_base + vgap + 13) = - 0.4f / space_size_x; + *(vertex_base + vgap + 14) = 0.4f / space_size_x; if (I) printf("x = %d site = %d center = %f tip = %f base = %f\n",\ x, site, center, tip, base); // vgap=%d igap=%d - *(line_origin + igap + 0) = vgap / 3 + 0; - *(line_origin + igap + 1) = vgap / 3 + 1; + if (pref_lines_planes_or_mix == 0) { - *(line_origin + igap + 2) = vgap / 3 + 0; - *(line_origin + igap + 3) = vgap / 3 + 2; + lgap = space_size_x * 11; - *(line_origin + igap + 4) = vgap / 3 + 0; - *(line_origin + igap + 5) = vgap / 3 + 3; + *(line_origin + lgap + 0) = vgap / 3 + 0; + *(line_origin + lgap + 1) = vgap / 3 + 1; - *(line_origin + igap + 6) = vgap / 3 + 0; - *(line_origin + igap + 7) = vgap / 3 + 4; + *(line_origin + lgap + 2) = vgap / 3 + 0; + *(line_origin + lgap + 3) = vgap / 3 + 2; - *(line_origin + igap + 8) = vgap / 3 + 1; - *(line_origin + igap + 9) = vgap / 3 + 2; + *(line_origin + lgap + 4) = vgap / 3 + 0; + *(line_origin + lgap + 5) = vgap / 3 + 3; - *(line_origin + igap + 10) = vgap / 3 + 2; - *(line_origin + igap + 11) = vgap / 3 + 3; + *(line_origin + lgap + 6) = vgap / 3 + 0; + *(line_origin + lgap + 7) = vgap / 3 + 4; - *(line_origin + igap + 12) = vgap / 3 + 3; - *(line_origin + igap + 13) = vgap / 3 + 4; + *(line_origin + lgap + 8) = vgap / 3 + 1; + *(line_origin + lgap + 9) = vgap / 3 + 2; - *(line_origin + igap + 14) = vgap / 3 + 4; - *(line_origin + igap + 15) = vgap / 3 + 1; + *(line_origin + lgap + 10) = vgap / 3 + 2; + *(line_origin + lgap + 11) = vgap / 3 + 3; + *(line_origin + lgap + 12) = vgap / 3 + 3; + *(line_origin + lgap + 13) = vgap / 3 + 4; - *(plan_ndx + 0) = vgap / 3 + 0; - *(plan_ndx + 1) = vgap / 3 + 1; - *(plan_ndx + 2) = vgap / 3 + 2; + *(line_origin + lgap + 14) = vgap / 3 + 4; + *(line_origin + lgap + 15) = vgap / 3 + 1; + } - *(plan_ndx + 3) = vgap / 3 + 0; - *(plan_ndx + 4) = vgap / 3 + 1; - *(plan_ndx + 5) = vgap / 3 + 2; + if (pref_lines_planes_or_mix == 1) { + + pgap = 0; + + *(plan_origin + pgap + 0) = vgap / 3 + 0; + *(plan_origin + pgap + 1) = vgap / 3 + 1; + *(plan_origin + pgap + 2) = vgap / 3 + 2; + + *(plan_origin + pgap + 3) = vgap / 3 + 0; + *(plan_origin + pgap + 4) = vgap / 3 + 3; + *(plan_origin + pgap + 5) = vgap / 3 + 4; + + *(plan_origin + pgap + 0) = vgap / 3 + 0; + *(plan_origin + pgap + 1) = vgap / 3 + 1; + *(plan_origin + pgap + 2) = vgap / 3 + 3; + + *(plan_origin + pgap + 3) = vgap / 3 + 0; + *(plan_origin + pgap + 4) = vgap / 3 + 2; + *(plan_origin + pgap + 5) = vgap / 3 + 4; + } return 1; } - -bool compute_space(int model_space_size_x, +#define A 1 +bool compute_space_and_arrows(int model_space_size_x, GLfloat *vertex_base, GLfloat *color_base, GLubyte *line_origin, GLubyte *plan_origin, - GLubyte *arrows, + GLubyte *arrows, int model_arrows_nb, + int vgap, int cgap, int lgap, int pgap, bool pref_3D_xor_2D_space, bool pref_lines_planes_or_mix, bool pref_mark_unit_space_first, bool pref_mark_unit_space_last) { - printf("Prefer : mark_unit_space_first = %d mark_unit_space_last = %d 3D_xor_2D_space = %d\n", + if (A) printf("buffers.compute_space_and_arrows() prefer : mark_unit_space_first = %d\ + mark_unit_space_last = %d 3D_xor_2D_space = %d (0 is 3D) (1 is 2D)\n", pref_mark_unit_space_first, pref_mark_unit_space_last, pref_3D_xor_2D_space); - if (pref_3D_xor_2D_space) { // 2D - printf("buffers.compute_space() pref_3D_xor_2D_space > 2D \n"); + printf("buffers.compute_space_and_arrows() vgap %d cgap %d lgap %d pgap %d \n", vgap, cgap, lgap, pgap); + if (pref_3D_xor_2D_space){ compute_space_2D(model_space_size_x, + vertex_base, color_base, + line_origin, plan_origin, + pref_lines_planes_or_mix, + pref_mark_unit_space_first, + pref_mark_unit_space_last); + + // GLubyte arrows[] = { 1, 1, 0, 1, 2, 1, 1, 1, 10, 1, 2, 11, 1, 1, 20, 1, 2, 21 }; + if (A) for (int i = 0; i < model_arrows_nb; i++) { + printf("[%d] = %2d, %2d, %2d\n",\ + i, *(arrows + i * 3), *(arrows + i * 3 + 1), *(arrows + i * 3 + 2)); + } + { // ... on verra demain ... + int i = 0; + + compute_arrow_2D(model_space_size_x, + vertex_base, color_base, + line_origin, plan_origin, + pref_lines_planes_or_mix, + vgap, cgap, lgap, pgap, + *(arrows + i * 3 + 0), + *(arrows + i * 3 + 1), + *(arrows + i * 3 + 2), + 0, 0); + } + + } else { // 3D + + compute_space_3D(model_space_size_x, vertex_base, color_base, line_origin, plan_origin, pref_lines_planes_or_mix, pref_mark_unit_space_first, pref_mark_unit_space_last); - return 0; - } else { // 3D - printf("buffers.compute_space() pref_3D_xor_2D_space > 3D \n"); + int i = 0; + + compute_arrow_3D(model_space_size_x, + vertex_base, color_base, + line_origin, plan_origin, + pref_lines_planes_or_mix, + vgap, cgap, lgap, pgap, + *(arrows + i * 3 + 0), + *(arrows + i * 3 + 1), + *(arrows + i * 3 + 2), + 0, 0); /* compute_arrow_3D(model_space_size_x, */ /* vertex_base, color_base, */ @@ -450,9 +519,7 @@ bool compute_space(int model_space_size_x, /* compute_arrow_3D(entry, model_space_size_x, vgap, igap, 1, 0, model_space_size_x - 2, 0, 0); vgap += 15; igap += 16; cgap += 15; ++model_arrows_nb; */ /* compute_arrow_3D(entry, model_space_size_x, vgap, igap, 1, 1, model_space_size_x - 2, 0, 0); vgap += 15; igap += 16; cgap += 15; ++model_arrows_nb; */ - return 0; } - printf("buffers.compute_space() end.\n"); return 0; } diff --git a/src/graphics/graphics.c b/src/graphics/graphics.c index c1ef59d..d79f02f 100644 --- a/src/graphics/graphics.c +++ b/src/graphics/graphics.c @@ -489,12 +489,13 @@ int model_space_size_x = 0; int model_space_size_y = 0; int model_space_size_z = 0; int model_arrows_nb = 0; -GLubyte *arrows = NULL; //{ 1, 1, 0, 1, 2, 1, 1, 1, 10, 1, 2, 11, 1, 1, 20, 1, 2, 21 }; +GLubyte // arrows[] = { 1, 1, 0, 1, 2, 1, 1, 1, 10, 1, 2, 11, 1, 1, 20, 1, 2, 21 }; // GLubyte ? + arrows[] = { 1, 1, 0, 1, 2, 1, 1, 1, 3, 1, 2, 4, 1, 1, 6, 1, 2, 7 }; bool pref_3D_xor_2D_space = 0; // default view == 0 == 3D bool pref_3D_xor_2D_arrows = 0; // default view == 0 == 3D -bool pref_lines_planes_or_mix = 0; // default view == 0 == lines only +bool pref_lines_planes_or_mix = 0; // arrows as lines = 0, as planes = 1 bool pref_mark_unit_space_first = 0; // default == 0 == no mark bool pref_mark_unit_space_last = 0; // default == 0 == no mark bool pref_background_color = 0; // don't know yet... @@ -514,15 +515,16 @@ static void get_model_data_and_user_preferences(){ // The model data (arrows) to use (from model.xml) // int *arrows = { 1, 1, 0, 1, 2, 1, 1, 1, 10, 1, 2, 11, 1, 1, 20, 1, 2, 21 }; - model_space_size_x = 6; // 2 < model_space_size_x < 32 - model_arrows_nb = 0; // assert : leur emplacement est contraint par + model_space_size_x = 12; // 2 < model_space_size_x < 32 + model_arrows_nb = 6; // assert : leur emplacement est contraint par // model_space_size_x, y, z et le nombre de sites - pref_3D_xor_2D_space = 1; // default == 0 == 3D - pref_3D_xor_2D_arrows = 1; // default == 0 == 3D - pref_mark_unit_space_first = 1; // default == 0 == no mark + pref_3D_xor_2D_space = 0; // default == 0 == 3D + pref_3D_xor_2D_arrows = 0; // default == 0 == 3D + pref_mark_unit_space_first = 0; // default == 0 == no mark pref_mark_unit_space_last = 1; // default == 0 == no mark pref_background_color = 0; // TODO + pref_lines_planes_or_mix = 1; // arrows as lines = 0, as planes = 1 } static void compute_buffers_sizes(int model_space_size_x, @@ -610,7 +612,7 @@ void graphics_init_buffers(const void *gl_area) entry = find_entry_from_ptr(gl_area); get_model_data_and_user_preferences(); - /* une struct en retour pour ne plus utiliser de variables globales ? (facile) */ + /* une struct en retour pour ne plus utiliser de variables globales ? */ compute_buffers_sizes(model_space_size_x, model_space_size_y, @@ -622,16 +624,19 @@ void graphics_init_buffers(const void *gl_area) pref_mark_unit_space_first, pref_mark_unit_space_last); -// g_malloc vertex_base = g_malloc0(buffer_vertex_size * sizeof(GLfloat) * 2); color_base = g_malloc0(buffer_colors_size * sizeof(GLfloat) * 2); line_origin = g_malloc0(buffer_lines_size * 2 * sizeof(GLubyte) * 2); plan_origin = g_malloc0(buffer_plans_size * 3 * sizeof(GLubyte) * 2); - compute_space (model_space_size_x, + compute_space_and_arrows (model_space_size_x, vertex_base, color_base, line_origin, plan_origin, - arrows, + arrows, model_arrows_nb, + buffer_vertex_size, + buffer_colors_size, + buffer_lines_size, + buffer_plans_size, pref_3D_xor_2D_space, pref_lines_planes_or_mix, pref_mark_unit_space_first,