src/libopengl/opengl.c

   1 /* OpenGL rendering
   2  *
   3  * (C) 2018 by Andreas Eversberg <jolly@eversberg.eu>
   4  * All Rights Reserved
   5  *
   6  * This program is free software: you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation, either version 3 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include <stdio.h>
  21 #include <stdint.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <math.h>
  25 #include <errno.h>
  26 #include "../libsdl/print.h"
  27 #include "opengl.h"
  28 #define GL3_PROTOTYPES 1
  29 #include <GL/glew.h>
  30
  31 #define MAX_OSD 2
  32 static uint8_t *image_rgb = NULL;
  33 static uint8_t *osd_rgba[MAX_OSD] = { NULL, NULL };
  34 static GLuint image_name;
  35 static GLuint osd_name[MAX_OSD];
  36 static int image_width, image_height;
  37 static int osd_width[MAX_OSD], osd_height[MAX_OSD];
  38 static int texture_size;
  39 static int osd_size[MAX_OSD];
  40 static int flip_y;
  41
  42 /* alloc and init an image texture with size that is greater than the power of two */
  43 int init_opengl_image(int _image_width, int _image_height)
  44 {
  45         int rc;
  46
  47         image_width = _image_width;
  48         image_height = _image_height;
  49
  50         /* generate texture */
  51         for (texture_size = 1; texture_size <= image_width || texture_size <= image_height; texture_size *= 2)
  52                 ;
  53
  54         image_rgb = calloc(texture_size * texture_size, 3);
  55         if (!image_rgb) {
  56                 print_error("Failed to allocate texture\n");
  57                 rc = -ENOMEM;
  58                 goto error;
  59         }
  60         glShadeModel(GL_FLAT);
  61         glPixelStorei(GL_UNPACK_ALIGNMENT, 1); /* bytes */
  62         glGenTextures(1, &image_name);
  63         glBindTexture(GL_TEXTURE_2D, image_name);
  64         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
  65         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
  66         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, texture_size, texture_size, 0, GL_RGB, GL_UNSIGNED_BYTE, image_rgb);
  67
  68
  69         return 0;
  70
  71 error:
  72         exit_opengl();
  73         return rc;
  74 }
  75
  76 /* alloc and init an osd texture with size that is greater than the power of two */
  77 int init_opengl_osd(int num, int _osd_width, int _osd_height)
  78 {
  79         int rc;
  80
  81         if (num < 0 || num >= MAX_OSD) {
  82                 print_error("given OSD number out of range");
  83                 rc = -ENOMEM;
  84                 goto error;
  85         }
  86
  87         osd_width[num] = _osd_width;
  88         osd_height[num] = _osd_height;
  89
  90         /* generate texture */
  91         for (osd_size[num] = 1; osd_size[num] <= osd_width[num] || osd_size[num] <= osd_height[num]; osd_size[num] *= 2)
  92                 ;
  93         osd_rgba[num] = calloc(osd_size[num] * osd_size[num], 4);
  94         if (!osd_rgba[num]) {
  95                 print_error("Failed to allocate texture\n");
  96                 rc = -ENOMEM;
  97                 goto error;
  98         }
  99         glPixelStorei(GL_UNPACK_ALIGNMENT, 1); /* bytes */
 100         glGenTextures(1, &osd_name[num]);
 101         glBindTexture(GL_TEXTURE_2D, osd_name[num]);
 102         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
 103         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 104         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, osd_size[num], osd_size[num], 0, GL_RGBA, GL_UNSIGNED_BYTE, osd_rgba[num]);
 105
 106         return 0;
 107
 108 error:
 109         exit_opengl();
 110         return rc;
 111 }
 112
 113 void opengl_clear(int _flip_y)
 114 {
 115         flip_y = _flip_y;
 116
 117         /* clear screen */
 118         glClearColor(0.0, 0.0, 0.0, 1.0);
 119         glClear(GL_COLOR_BUFFER_BIT);
 120 }
 121
 122 /* set viewport for improved rendering */
 123 void opengl_viewport(int view_width, int view_height, int split, int benson_at_line, double fov, double benson_size)
 124 {
 125         int view_x = 0, view_y = 0;
 126         int new_width, new_height;
 127
 128         /* center view, or put it in the top half of the window */
 129         if (split == 1) {
 130                 view_y = view_height / 2;
 131                 view_height = view_height / 2;
 132         } else if (split == 2) {
 133                 view_height = view_height / 2;
 134         }
 135
 136         /* avoid division by zero, if one dimension is too small */
 137         if (view_width < 1 || view_height < 1)
 138                 return;
 139
 140         /* calculate a viewport that has apect of image_width:image_height */
 141         if (view_height * image_width > view_width * image_height) {
 142                 new_height = view_width * image_height / image_width;
 143                 view_y = view_y + view_height / 2 - new_height / 2;
 144                 view_height = new_height;
 145         } else if (view_height * image_width < view_width * image_height) {
 146                 new_width = view_height * image_width / image_height;
 147                 view_x = view_x + view_width / 2 - new_width / 2;
 148                 view_width = new_width;
 149         }
 150
 151         /* avoid views that are too small */
 152         if (view_width < 1 || view_height < 1)
 153                 return;
 154
 155         /* viewport and projection matrix */
 156         glViewport((GLsizei)view_x, (GLsizei)view_y, (GLsizei)view_width, (GLsizei)view_height);
 157         glMatrixMode(GL_PROJECTION);
 158         glLoadIdentity();
 159
 160         /* calculate field-of-view */
 161         double slope = tan(fov / 360 * M_PI);
 162         /* make frustum to center the view in the game view above benson */
 163         double left = -slope;
 164         double right = slope;
 165         double benson_start_at_position = ((double)image_height - (double)benson_at_line) * benson_size;
 166         double top = slope * ((double)image_height - benson_start_at_position) / (double)image_width;
 167         double bottom = -slope * ((double)image_height * 2.0 - ((double)image_height - benson_start_at_position)) / (double)image_width;
 168         glFrustum(left, right, bottom, top, 1.0, 5000000000.0);
 169
 170         glMatrixMode(GL_MODELVIEW);
 171 }
 172
 173 /* render image or only benson */
 174 void opengl_blit_image(uint8_t *rgb, int filter, int benson_at_line, int render_benson_only, double fov, double monitor_distance, double benson_size, int benson_case)
 175 {
 176         double texture_left = 0;
 177         double texture_right = ((double)image_width) / (double)texture_size;
 178         double texture_top = ((double)benson_at_line) / (double)texture_size;
 179         double texture_bottom = ((double)image_height) / (double)texture_size;
 180         double image_start_at_position = ((double)image_height - (double)benson_at_line) * benson_size;
 181         double image_top = -((double)image_height - image_start_at_position) / (double)image_width;
 182         double image_bottom = -((double)image_height * 2.0 - ((double)image_height - image_start_at_position)) / (double)image_width;
 183
 184         /* calculate field-of-view */
 185         double slope = tan(fov / 360 * M_PI) * monitor_distance;
 186
 187         /* render image */
 188
 189         if (benson_case) {
 190                 glEnable(GL_CULL_FACE);
 191                 glFrontFace(GL_CW);
 192                 glCullFace(GL_BACK);
 193         }
 194
 195         glEnable(GL_TEXTURE_2D);
 196         glBindTexture(GL_TEXTURE_2D, image_name);
 197         glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);  /* no modulation with color */
 198         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, (filter) ? GL_LINEAR : GL_NEAREST);
 199         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, (filter) ? GL_LINEAR : GL_NEAREST);
 200         if (render_benson_only) {
 201                 /* render benson only, and copy top line of benson to one line above, so the texture filter will not take false data above benson */
 202                 rgb += image_width * (benson_at_line - 1) * 3;
 203                 memcpy(rgb, rgb + image_width * 3, image_width * 3);
 204                 glTexSubImage2D(GL_TEXTURE_2D, 0, 0, benson_at_line - 1, image_width, image_height - benson_at_line - 1, GL_RGB, GL_UNSIGNED_BYTE, rgb);
 205         } else {
 206                 image_top = -image_top;
 207                 texture_top = 0.0;
 208                 glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, image_width, image_height, GL_RGB, GL_UNSIGNED_BYTE, rgb);
 209         }
 210         glBegin(GL_QUADS);
 211         glTexCoord2f(texture_left, texture_bottom);
 212         glVertex3f(-benson_size * slope, image_bottom * slope, -monitor_distance);
 213         glTexCoord2f(texture_right, texture_bottom);
 214         glVertex3f(benson_size * slope, image_bottom * slope, -monitor_distance);
 215         glTexCoord2f(texture_right, texture_top);
 216         glVertex3f(benson_size * slope, image_top * slope, -monitor_distance);
 217         glTexCoord2f(texture_left, texture_top);
 218         glVertex3f(-benson_size * slope, image_top * slope, -monitor_distance);
 219         glEnd();
 220         glDisable(GL_TEXTURE_2D);
 221         /* render benson case */
 222         if (benson_case) {
 223                 double left, right, bottom, top, near, far;
 224                 left = -benson_size * slope;
 225                 right = benson_size * slope;
 226                 bottom = image_bottom * slope;
 227                 top = image_top * slope;
 228                 near = -monitor_distance;
 229                 far = near - benson_size * slope / 3.0;
 230                 glBegin(GL_QUADS);
 231                 /* back */
 232                 glColor4f(0.3, 0.3, 0.3, 1.0);
 233                 glVertex3f(left, top, far);
 234                 glVertex3f(right, top, far);
 235                 glVertex3f(right, bottom, far);
 236                 glVertex3f(left, bottom, far);
 237                 /* top */
 238                 glColor4f(0.2, 0.2, 0.2, 1.0);
 239                 glVertex3f(left, top, near);
 240                 glVertex3f(right, top, near);
 241                 glVertex3f(right, top, far);
 242                 glVertex3f(left, top, far);
 243                 /* bottom */
 244                 glColor4f(0.05, 0.05, 0.05, 1.0);
 245                 glVertex3f(left, bottom, far);
 246                 glVertex3f(right, bottom, far);
 247                 glVertex3f(right, bottom, near);
 248                 glVertex3f(left, bottom, near);
 249                 /* left */
 250                 glColor4f(0.1, 0.1, 0.1, 1.0);
 251                 glVertex3f(left, bottom, far);
 252                 glVertex3f(left, bottom, near);
 253                 glVertex3f(left, top, near);
 254                 glVertex3f(left, top, far);
 255                 /* right */
 256                 glVertex3f(right, top, far);
 257                 glVertex3f(right, top, near);
 258                 glVertex3f(right, bottom, near);
 259                 glVertex3f(right, bottom, far);
 260                 glEnd();
 261         }
 262
 263         if (benson_case) {
 264                 glDisable(GL_CULL_FACE);
 265         }
 266 }
 267
 268 /* render osd texture */
 269 void opengl_blit_osd(int num, uint8_t *rgba, int filter, int benson_at_line, double fov, double monitor_distance, double benson_size, double scale_x, double scale_y, double offset_x, double offset_y)
 270 {
 271         double texture_left = 0.0;
 272         double texture_right = (double)osd_width[num] / (double)osd_size[num];
 273         double texture_top = 0.0;
 274         double texture_bottom = (double)osd_height[num] / (double)osd_size[num];
 275         double benson_start_at_position;
 276         double osd_left = 0.0;
 277         double osd_right = 1.0;
 278         double osd_top = 0.0;
 279         double osd_bottom = 1.0;
 280         double slope, range, center;
 281         if (fov) {
 282                 osd_left = -1.0;
 283                 osd_right = 1.0;
 284                 benson_start_at_position = ((double)image_height - (double)benson_at_line) * benson_size;
 285                 osd_top = ((double)image_height - benson_start_at_position) / (double)image_width;
 286                 osd_bottom = -((double)image_height * 2.0 - ((double)image_height - benson_start_at_position)) / (double)image_width;
 287                 /* calculate field-of-view */
 288                 slope = tan(fov / 360 * M_PI) * monitor_distance;
 289         }
 290         range = (osd_right - osd_left) / 2.0;
 291         center = (osd_right + osd_left) / 2.0;
 292         osd_left = (osd_left - center) * scale_x + center + range * offset_x;
 293         osd_right = (osd_right - center) * scale_x + center + range * offset_x;
 294         range = (osd_bottom - osd_top) / 2.0;
 295         center = (osd_bottom + osd_top) / 2.0;
 296         osd_top = (osd_top - center) * scale_y + center + range * offset_y;
 297         osd_bottom = (osd_bottom - center) * scale_y + center + range * offset_y;
 298
 299         glEnable(GL_BLEND);
 300         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 301         glEnable(GL_TEXTURE_2D);
 302         glBindTexture(GL_TEXTURE_2D, osd_name[num]);
 303         glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);  /* no modulation with color */
 304         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, (filter) ? GL_LINEAR : GL_NEAREST);
 305         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, (filter) ? GL_LINEAR : GL_NEAREST);
 306         glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, osd_width[num], osd_height[num], GL_RGBA, GL_UNSIGNED_BYTE, rgba);
 307         glBegin(GL_QUADS);
 308         if (fov) {
 309                 /* perspective viewport */
 310                 glTexCoord2f(texture_left, texture_bottom);
 311                 glVertex3f(osd_left * slope, osd_bottom * slope, -monitor_distance);
 312                 glTexCoord2f(texture_right, texture_bottom);
 313                 glVertex3f(osd_right * slope, osd_bottom * slope, -monitor_distance);
 314                 glTexCoord2f(texture_right, texture_top);
 315                 glVertex3f(osd_right * slope, osd_top * slope, -monitor_distance);
 316                 glTexCoord2f(texture_left, texture_top);
 317                 glVertex3f(osd_left * slope, osd_top * slope, -monitor_distance);
 318         } else {
 319                 /* orthogonal viewport */
 320                 glTexCoord2f(texture_left, texture_top);
 321                 glVertex3f(osd_left, osd_top, 0.0);
 322                 glTexCoord2f(texture_right, texture_top);
 323                 glVertex3f(osd_right, osd_top, 0.0);
 324                 glTexCoord2f(texture_right, texture_bottom);
 325                 glVertex3f(osd_right, osd_bottom, 0.0);
 326                 glTexCoord2f(texture_left, texture_bottom);
 327                 glVertex3f(osd_left, osd_bottom, 0.0);
 328         }
 329         glEnd();
 330         glDisable(GL_TEXTURE_2D);
 331         glDisable(GL_BLEND);
 332 }
 333
 334 /* set color and opacity */
 335 void opengl_render_color(double r, double g, double b, double a)
 336 {
 337         if (a < 1.0) {
 338                 glEnable(GL_BLEND);
 339                 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 340                 glColor4d(r, g, b, a);
 341         } else {
 342                 glDisable(GL_BLEND);
 343                 glColor3d(r, g, b);
 344         }
 345 }
 346
 347 /* render polygon */
 348 void opengl_render_polygon(double *x, double *y, double *z, int count, int cull_face)
 349 {
 350         int i;
 351
 352         if (cull_face) {
 353                 glEnable(GL_CULL_FACE);
 354                 glFrontFace((flip_y) ? GL_CCW : GL_CW);
 355                 glCullFace(GL_BACK);
 356         }
 357         glBegin(GL_POLYGON);
 358         for (i = 0; i < count; i++)
 359                 glVertex3d(x[i], y[i], -z[i]);
 360         glEnd();
 361         if (cull_face)
 362                 glDisable(GL_CULL_FACE);
 363 }
 364
 365 /* render polygon, but make sure any size of it is visible */
 366 void opengl_render_polygon_and_line(double *x, double *y, double *z, int count)
 367 {
 368         int i;
 369
 370         glBegin(GL_POLYGON);
 371         for (i = 0; i < count; i++)
 372                 glVertex3d(x[i], y[i], -z[i]);
 373         glEnd();
 374         glBegin(GL_LINE_LOOP);
 375         for (i = 0; i < count; i++)
 376                 glVertex3d(x[i], y[i], -z[i]);
 377         glEnd();
 378 }
 379
 380 /* render line */
 381 void opengl_render_line(double x1, double y1, double z1, double x2, double y2, double z2, double size)
 382 {
 383         if (size == 0.0) {
 384                 glBegin(GL_LINES);
 385                 glVertex3f(x1, y1, -z1);
 386                 glVertex3f(x2, y2, -z2);
 387                 glEnd();
 388                 return;
 389         }
 390 }
 391
 392 /* render point */
 393 void opengl_render_point(double x, double y, double z, double size)
 394 {
 395         if (size == 0.0) {
 396                 glBegin(GL_POINTS);
 397                 glVertex3f(x, y, -z);
 398                 glEnd();
 399                 return;
 400         }
 401 }
 402
 403 /* free image texture */
 404 void exit_opengl(void)
 405 {
 406         int i;
 407
 408         if (image_rgb) {
 409                 free(image_rgb);
 410                 image_rgb = NULL;
 411         }
 412         for (i = 0; i < MAX_OSD; i++) {
 413                 if (osd_rgba[i]) {
 414                         free(osd_rgba[i]);
 415                         osd_rgba[i] = NULL;
 416                 }
 417         }
 418 }
 419