cacalabs
/
libcaca
mirror of https://github.com/cacalabs/libcaca.git
1
0
Fork 0
Code Issues 0 Releases 7 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1256 Commits
1 Branch
37 MiB
 
 
 
 
 
 
Tree: 7e75ff3c1d
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '7e75ff3c1d'
${ noResults }
libcaca/caca/driver_gl.c

618 lines
17 KiB
Raw Blame History 

  1. /*

  2.  *  libcaca       Colour ASCII-Art library

  3.  *  Copyright (c) 2002-2006 Sam Hocevar <sam@zoy.org>

  4.  *                2006 Jean-Yves Lamoureux <jylam@lnxscene.org>

  5.  *                2007 Ben Wiley Sittler <bsittler@gmail.com>

  6.  *                All Rights Reserved

  7.  *

  8.  *  $Id$

  9.  *

  10.  *  This library is free software. It comes without any warranty, to

  11.  *  the extent permitted by applicable law. You can redistribute it

  12.  *  and/or modify it under the terms of the Do What The Fuck You Want

  13.  *  To Public License, Version 2, as published by Sam Hocevar. See

  14.  *  http://sam.zoy.org/wtfpl/COPYING for more details.

  15.  */

  16. 

  17. /*

  18.  *  This file contains the libcaca OpenGL input and output driver

  19.  */

  20. 

  21. #include "config.h"

  22. #include "common.h"

  23. 

  24. #if defined(USE_GL)

  25. 

  26. #ifdef HAVE_OPENGL_GL_H

  27. #   include <OpenGL/gl.h>

  28. #   include <GLUT/glut.h>

  29. #else

  30. #   include <GL/gl.h>

  31. #   include <GL/glut.h>

  32. #   include <GL/freeglut_ext.h>

  33. #endif

  34. 

  35. #include <string.h>

  36. #include <stdlib.h>

  37. #include <stdio.h>

  38. 

  39. #include "cucul.h"

  40. #include "caca.h"

  41. #include "caca_internals.h"

  42. 

  43. /*

  44.  * Global variables

  45.  */

  46. 

  47. static caca_display_t *gl_d; /* FIXME: we ought to get rid of this */

  48. 

  49. /*

  50.  * Local functions

  51.  */

  52. static void gl_handle_keyboard(unsigned char, int, int);

  53. static void gl_handle_special_key(int, int, int);

  54. static void gl_handle_reshape(int, int);

  55. static void gl_handle_mouse(int, int, int, int);

  56. static void gl_handle_mouse_motion(int, int);

  57. #ifdef HAVE_GLUTCLOSEFUNC

  58. static void gl_handle_close(void);

  59. #endif

  60. static void _display(void);

  61. static void gl_compute_font(caca_display_t *);

  62. 

  63. struct driver_private

  64. {

  65.     int window;

  66.     unsigned int width, height;

  67.     unsigned int new_width, new_height;

  68.     cucul_font_t *f;

  69.     float font_width, font_height;

  70.     float incx, incy;

  71.     unsigned long int const *blocks;

  72.     int *txid;

  73.     unsigned char close;

  74.     unsigned char bit;

  75.     unsigned char mouse_changed, mouse_clicked;

  76.     unsigned int mouse_x, mouse_y;

  77.     unsigned int mouse_button, mouse_state;

  78. 

  79.     unsigned char key;

  80.     int special_key;

  81. 

  82.     float sw, sh;

  83. };

  84. 

  85. static int gl_init_graphics(caca_display_t *dp)

  86. {

  87.     char const *geometry;

  88.     char *argv[2] = { "", NULL };

  89.     char const * const * fonts;

  90.     unsigned int width = cucul_get_canvas_width(dp->cv);

  91.     unsigned int height = cucul_get_canvas_height(dp->cv);

  92.     int argc = 1;

  93. 

  94.     dp->drv.p = malloc(sizeof(struct driver_private));

  95. 

  96.     gl_d = dp;

  97. 

  98. #if defined(HAVE_GETENV)

  99.     geometry = getenv("CACA_GEOMETRY");

  100.     if(geometry && *geometry)

  101.         sscanf(geometry, "%ux%u", &width, &height);

  102. #endif

  103. 

  104.     dp->resize.allow = 1;

  105.     cucul_set_canvas_size(dp->cv, width ? width : 80, height ? height : 32);

  106.     dp->resize.allow = 0;

  107. 

  108.     /* Load a libcucul internal font */

  109.     fonts = cucul_get_font_list();

  110.     if(fonts[0] == NULL)

  111.     {

  112.         fprintf(stderr, "error: libcucul was compiled without any fonts\n");

  113.         return -1;

  114.     }

  115.     dp->drv.p->f = cucul_load_font(fonts[0], 0);

  116.     if(dp->drv.p->f == NULL)

  117.     {

  118.         fprintf(stderr, "error: could not load font \"%s\"\n", fonts[0]);

  119.         return -1;

  120.     }

  121. 

  122.     dp->drv.p->font_width = cucul_get_font_width(dp->drv.p->f);

  123.     dp->drv.p->font_height = cucul_get_font_height(dp->drv.p->f);

  124. 

  125.     dp->drv.p->width = cucul_get_canvas_width(dp->cv) * dp->drv.p->font_width;

  126.     dp->drv.p->height = cucul_get_canvas_height(dp->cv) * dp->drv.p->font_height;

  127. 

  128. #ifdef HAVE_GLUTCLOSEFUNC

  129.     dp->drv.p->close = 0;

  130. #endif

  131.     dp->drv.p->bit = 0;

  132. 

  133.     dp->drv.p->mouse_changed = dp->drv.p->mouse_clicked = 0;

  134.     dp->drv.p->mouse_button = dp->drv.p->mouse_state = 0;

  135. 

  136.     dp->drv.p->key = 0;

  137.     dp->drv.p->special_key = 0;

  138. 

  139.     dp->drv.p->sw = ((float)dp->drv.p->font_width) / 16.0f;

  140.     dp->drv.p->sh = ((float)dp->drv.p->font_height) / 16.0f;

  141. 

  142.     glutInit(&argc, argv);

  143. 

  144.     glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);

  145.     glutInitWindowSize(dp->drv.p->width, dp->drv.p->height);

  146.     dp->drv.p->window = glutCreateWindow("caca for GL");

  147. 

  148.     gluOrtho2D(0, dp->drv.p->width, dp->drv.p->height, 0);

  149. 

  150.     glDisable(GL_CULL_FACE);

  151.     glDisable(GL_DEPTH_TEST);

  152. 

  153.     glutKeyboardFunc(gl_handle_keyboard);

  154.     glutSpecialFunc(gl_handle_special_key);

  155.     glutReshapeFunc(gl_handle_reshape);

  156.     glutDisplayFunc(_display);

  157. 

  158. #ifdef HAVE_GLUTCLOSEFUNC

  159.     glutCloseFunc(gl_handle_close);

  160. #endif

  161. 

  162.     glutMouseFunc(gl_handle_mouse);

  163.     glutMotionFunc(gl_handle_mouse_motion);

  164.     glutPassiveMotionFunc(gl_handle_mouse_motion);

  165. 

  166.     glLoadIdentity();

  167. 

  168.     glMatrixMode(GL_PROJECTION);

  169.     glPushMatrix();

  170.     glLoadIdentity();

  171.     gluOrtho2D(0, dp->drv.p->width, dp->drv.p->height, 0);

  172. 

  173.     glMatrixMode(GL_MODELVIEW);

  174. 

  175.     glClear(GL_COLOR_BUFFER_BIT);

  176.     glEnable(GL_TEXTURE_2D);

  177.     glEnable(GL_BLEND);

  178.     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

  179. 

  180.     glEnable(GL_TEXTURE_2D);

  181. 

  182.     gl_compute_font(dp);

  183. 

  184.     return 0;

  185. }

  186. 

  187. static int gl_end_graphics(caca_display_t *dp)

  188. {

  189.     glutDestroyWindow(dp->drv.p->window);

  190.     free(dp->drv.p->txid);

  191.     free(dp->drv.p);

  192.     return 0;

  193. }

  194. 

  195. static int gl_set_display_title(caca_display_t *dp, char const *title)

  196. {

  197.     glutSetWindowTitle(title);

  198.     return 0;

  199. }

  200. 

  201. static unsigned int gl_get_display_width(caca_display_t const *dp)

  202. {

  203.     return dp->drv.p->width;

  204. }

  205. 

  206. static unsigned int gl_get_display_height(caca_display_t const *dp)

  207. {

  208.     return dp->drv.p->height;

  209. }

  210. 

  211. static void gl_display(caca_display_t *dp)

  212. {

  213.     uint32_t const *cvchars = (uint32_t const *)cucul_get_canvas_chars(dp->cv);

  214.     uint32_t const *cvattrs = (uint32_t const *)cucul_get_canvas_attrs(dp->cv);

  215.     unsigned int width = cucul_get_canvas_width(dp->cv);

  216.     unsigned int x, y, line;

  217. 

  218.     glClear(GL_COLOR_BUFFER_BIT);

  219.     glDisable(GL_TEXTURE_2D);

  220.     glDisable(GL_BLEND);

  221.     line = 0;

  222.     for(y = 0; y < dp->drv.p->height; y += dp->drv.p->font_height)

  223.     {

  224.         uint32_t const *attrs = cvattrs + line * width;

  225. 

  226.         /* FIXME: optimise using stride */

  227.         for(x = 0; x < dp->drv.p->width; x += dp->drv.p->font_width)

  228.         {

  229.             uint16_t bg = cucul_attr_to_rgb12_bg(*attrs++);

  230. 

  231.             glColor4b(((bg & 0xf00) >> 8) * 8,

  232.                       ((bg & 0x0f0) >> 4) * 8,

  233.                       (bg & 0x00f) * 8,

  234.                       0xff);

  235.             glBegin(GL_QUADS);

  236.             glVertex2f(x, y);

  237.             glVertex2f(x + dp->drv.p->font_width, y);

  238.             glVertex2f(x + dp->drv.p->font_width,

  239.                        y + dp->drv.p->font_height);

  240.             glVertex2f(x, y + dp->drv.p->font_height);

  241.             glEnd();

  242.         }

  243. 

  244.         line++;

  245.     }

  246. 

  247.     /* 2nd pass, avoids changing render state too much */

  248.     glEnable(GL_TEXTURE_2D);

  249.     glEnable(GL_BLEND);

  250. 

  251.     line = 0;

  252.     for(y = 0; y < dp->drv.p->height; y += dp->drv.p->font_height, line++)

  253.     {

  254.         uint32_t const *attrs = cvattrs + line * width;

  255.         uint32_t const *chars = cvchars + line * width;

  256. 

  257.         for(x = 0; x < dp->drv.p->width; x += dp->drv.p->font_width, attrs++)

  258.         {

  259.             uint32_t ch = *chars++;

  260.             uint16_t fg;

  261.             int i, b, fullwidth;

  262. 

  263.             fullwidth = cucul_utf32_is_fullwidth(ch);

  264. 

  265.             for(b = 0, i = 0; dp->drv.p->blocks[i + 1]; i += 2)

  266.             {

  267.                 if(ch < (uint32_t)dp->drv.p->blocks[i])

  268.                      break;

  269. 

  270.                 if(ch >= (uint32_t)dp->drv.p->blocks[i + 1])

  271.                 {

  272.                     b += (uint32_t)(dp->drv.p->blocks[i + 1]

  273.                                      - dp->drv.p->blocks[i]);

  274.                     continue;

  275.                 }

  276. 

  277.                 glBindTexture(GL_TEXTURE_2D,

  278.                               dp->drv.p->txid[b + ch

  279.                                         - (uint32_t)dp->drv.p->blocks[i]]);

  280. 

  281.                 fg = cucul_attr_to_rgb12_fg(*attrs);

  282.                 glColor3b(((fg & 0xf00) >> 8) * 8,

  283.                           ((fg & 0x0f0) >> 4) * 8,

  284.                           (fg & 0x00f) * 8);

  285.                 /* FIXME: handle fullwidth glyphs here */

  286.                 glBegin(GL_QUADS);

  287.                 glTexCoord2f(0, dp->drv.p->sh);

  288.                 glVertex2f(x, y);

  289.                 glTexCoord2f(dp->drv.p->sw, dp->drv.p->sh);

  290.                 glVertex2f(x + dp->drv.p->font_width * (fullwidth ? 2 : 1), y);

  291.                 glTexCoord2f(dp->drv.p->sw, 0);

  292.                 glVertex2f(x + dp->drv.p->font_width * (fullwidth ? 2 : 1),

  293.                            y + dp->drv.p->font_height);

  294.                 glTexCoord2f(0, 0);

  295.                 glVertex2f(x, y + dp->drv.p->font_height);

  296.                 glEnd();

  297.             }

  298. 

  299.             if(fullwidth)

  300.             {

  301.                 chars++; attrs++; x += dp->drv.p->font_width;

  302.             }

  303.         }

  304.     }

  305. 

  306. #ifdef HAVE_GLUTCHECKLOOP

  307.     glutCheckLoop();

  308. #else

  309.     glutMainLoopEvent();

  310. #endif

  311.     glutSwapBuffers();

  312.     glutPostRedisplay();

  313. }

  314. 

  315. static void gl_handle_resize(caca_display_t *dp)

  316. {

  317.     dp->drv.p->width = dp->drv.p->new_width;

  318.     dp->drv.p->height = dp->drv.p->new_height;

  319. 

  320.     glMatrixMode(GL_PROJECTION);

  321.     glPushMatrix();

  322.     glLoadIdentity();

  323. 

  324.     glViewport(0, 0, dp->drv.p->width, dp->drv.p->height);

  325.     gluOrtho2D(0, dp->drv.p->width, dp->drv.p->height, 0);

  326.     glMatrixMode(GL_MODELVIEW);

  327. }

  328. 

  329. static int gl_get_event(caca_display_t *dp, caca_privevent_t *ev)

  330. {

  331. #ifdef HAVE_GLUTCHECKLOOP

  332.     glutCheckLoop();

  333. #else

  334.     glutMainLoopEvent();

  335. #endif

  336. 

  337. #ifdef HAVE_GLUTCLOSEFUNC

  338.     if(dp->drv.p->close)

  339.     {

  340.         dp->drv.p->close = 0;

  341.         ev->type = CACA_EVENT_QUIT;

  342.         return 1;

  343.     }

  344. #endif

  345. 

  346.     if(dp->resize.resized)

  347.     {

  348.         ev->type = CACA_EVENT_RESIZE;

  349.         ev->data.resize.w = cucul_get_canvas_width(dp->cv);

  350.         ev->data.resize.h = cucul_get_canvas_height(dp->cv);

  351.         return 1;

  352.     }

  353. 

  354.     if(dp->drv.p->mouse_changed)

  355.     {

  356.         ev->type = CACA_EVENT_MOUSE_MOTION;

  357.         ev->data.mouse.x = dp->mouse.x;

  358.         ev->data.mouse.y = dp->mouse.y;

  359.         dp->drv.p->mouse_changed = 0;

  360. 

  361.         if(dp->drv.p->mouse_clicked)

  362.         {

  363.             _push_event(dp, ev);

  364.             ev->type = CACA_EVENT_MOUSE_PRESS;

  365.             ev->data.mouse.button = dp->drv.p->mouse_button;

  366.             dp->drv.p->mouse_clicked = 0;

  367.         }

  368. 

  369.         return 1;

  370.     }

  371. 

  372.     if(dp->drv.p->key != 0)

  373.     {

  374.         ev->type = CACA_EVENT_KEY_PRESS;

  375.         ev->data.key.ch = dp->drv.p->key;

  376.         ev->data.key.utf32 = (uint32_t)dp->drv.p->key;

  377.         ev->data.key.utf8[0] = dp->drv.p->key;

  378.         ev->data.key.utf8[1] = '\0';

  379.         dp->drv.p->key = 0;

  380.         return 1;

  381.     }

  382. 

  383.     if(dp->drv.p->special_key != 0)

  384.     {

  385.         switch(dp->drv.p->special_key)

  386.         {

  387.             case GLUT_KEY_F1 : ev->data.key.ch = CACA_KEY_F1; break;

  388.             case GLUT_KEY_F2 : ev->data.key.ch = CACA_KEY_F2; break;

  389.             case GLUT_KEY_F3 : ev->data.key.ch = CACA_KEY_F3; break;

  390.             case GLUT_KEY_F4 : ev->data.key.ch = CACA_KEY_F4; break;

  391.             case GLUT_KEY_F5 : ev->data.key.ch = CACA_KEY_F5; break;

  392.             case GLUT_KEY_F6 : ev->data.key.ch = CACA_KEY_F6; break;

  393.             case GLUT_KEY_F7 : ev->data.key.ch = CACA_KEY_F7; break;

  394.             case GLUT_KEY_F8 : ev->data.key.ch = CACA_KEY_F8; break;

  395.             case GLUT_KEY_F9 : ev->data.key.ch = CACA_KEY_F9; break;

  396.             case GLUT_KEY_F10: ev->data.key.ch = CACA_KEY_F10; break;

  397.             case GLUT_KEY_F11: ev->data.key.ch = CACA_KEY_F11; break;

  398.             case GLUT_KEY_F12: ev->data.key.ch = CACA_KEY_F12; break;

  399.             case GLUT_KEY_LEFT : ev->data.key.ch = CACA_KEY_LEFT; break;

  400.             case GLUT_KEY_RIGHT: ev->data.key.ch = CACA_KEY_RIGHT; break;

  401.             case GLUT_KEY_UP   : ev->data.key.ch = CACA_KEY_UP; break;

  402.             case GLUT_KEY_DOWN : ev->data.key.ch = CACA_KEY_DOWN; break;

  403.             case GLUT_KEY_PAGE_UP : ev->data.key.ch = CACA_KEY_PAGEUP; break;

  404.             case GLUT_KEY_PAGE_DOWN  : ev->data.key.ch = CACA_KEY_PAGEDOWN;

  405.                 break;

  406.             case GLUT_KEY_HOME : ev->data.key.ch = CACA_KEY_HOME; break;

  407.             case GLUT_KEY_END : ev->data.key.ch = CACA_KEY_END; break;

  408.             case GLUT_KEY_INSERT : ev->data.key.ch = CACA_KEY_INSERT; break;

  409. 

  410.             default: ev->type = CACA_EVENT_NONE; return 0;

  411.         }

  412. 

  413.         ev->type = CACA_EVENT_KEY_PRESS;

  414.         ev->data.key.utf32 = 0;

  415.         ev->data.key.utf8[0] = '\0';

  416. 

  417.         dp->drv.p->special_key = 0;

  418.         return 1;

  419.     }

  420. 

  421.     ev->type = CACA_EVENT_NONE;

  422.     return 0;

  423. }

  424. 

  425. 

  426. static void gl_set_mouse(caca_display_t *dp, int flag)

  427. {

  428.     if(flag)

  429.         glutSetCursor(GLUT_CURSOR_RIGHT_ARROW);

  430.     else

  431.         glutSetCursor(GLUT_CURSOR_NONE);

  432. }

  433. 

  434. /*

  435.  * XXX: following functions are local

  436.  */

  437. 

  438. static void gl_handle_keyboard(unsigned char key, int x, int y)

  439. {

  440.     caca_display_t *dp = gl_d;

  441. 

  442.     dp->drv.p->key = key;

  443. }

  444. 

  445. static void gl_handle_special_key(int key, int x, int y)

  446. {

  447.     caca_display_t *dp = gl_d;

  448. 

  449.     dp->drv.p->special_key = key;

  450. }

  451. 

  452. static void gl_handle_reshape(int w, int h)

  453. {

  454.     caca_display_t *dp = gl_d;

  455. 

  456.     if(dp->drv.p->bit) /* Do not handle reshaping at the first time */

  457.     {

  458.         dp->drv.p->new_width = w;

  459.         dp->drv.p->new_height = h;

  460. 

  461.         dp->resize.w = w / dp->drv.p->font_width;

  462.         dp->resize.h = (h / dp->drv.p->font_height) + 1;

  463. 

  464.         dp->resize.resized = 1;

  465.     }

  466.     else

  467.         dp->drv.p->bit = 1;

  468. }

  469. 

  470. static void gl_handle_mouse(int button, int state, int x, int y)

  471. {

  472.     caca_display_t *dp = gl_d;

  473. 

  474.     dp->drv.p->mouse_clicked = 1;

  475.     dp->drv.p->mouse_button = button;

  476.     dp->drv.p->mouse_state = state;

  477.     dp->drv.p->mouse_x = x / dp->drv.p->font_width;

  478.     dp->drv.p->mouse_y = y / dp->drv.p->font_height;

  479.     dp->mouse.x = dp->drv.p->mouse_x;

  480.     dp->mouse.y = dp->drv.p->mouse_y;

  481.     dp->drv.p->mouse_changed = 1;

  482. }

  483. 

  484. static void gl_handle_mouse_motion(int x, int y)

  485. {

  486.     caca_display_t *dp = gl_d;

  487.     dp->drv.p->mouse_x = x / dp->drv.p->font_width;

  488.     dp->drv.p->mouse_y = y / dp->drv.p->font_height;

  489.     dp->mouse.x = dp->drv.p->mouse_x;

  490.     dp->mouse.y = dp->drv.p->mouse_y;

  491.     dp->drv.p->mouse_changed = 1;

  492. }

  493. 

  494. #ifdef HAVE_GLUTCLOSEFUNC

  495. static void gl_handle_close(void)

  496. {

  497.     caca_display_t *dp = gl_d;

  498.     dp->drv.p->close = 1;

  499. }

  500. #endif

  501. 

  502. static void _display(void)

  503. {

  504.     caca_display_t *dp = gl_d;

  505.     gl_display(dp);

  506. }

  507. 

  508. static void gl_compute_font(caca_display_t *dp)

  509. {

  510.     cucul_canvas_t *cv;

  511.     uint32_t *image;

  512.     int i, b, w, h, x, y;

  513. 

  514.     /* Count how many glyphs this font has */

  515.     dp->drv.p->blocks = cucul_get_font_blocks(dp->drv.p->f);

  516. 

  517.     for(b = 0, i = 0; dp->drv.p->blocks[i + 1]; i += 2)

  518.         b += (int)(dp->drv.p->blocks[i + 1] - dp->drv.p->blocks[i]);

  519. 

  520.     /* Allocate a libcucul canvas and print all the glyphs on it */

  521.     cv = cucul_create_canvas(2, b);

  522.     cucul_set_color_ansi(cv, CUCUL_WHITE, CUCUL_BLACK);

  523. 

  524.     for(b = 0, i = 0; dp->drv.p->blocks[i + 1]; i += 2)

  525.     {

  526.         int j, n = (int)(dp->drv.p->blocks[i + 1] - dp->drv.p->blocks[i]);

  527. 

  528.         for(j = 0; j < n; j++)

  529.             cucul_put_char(cv, 0, b + j, dp->drv.p->blocks[i] + j);

  530. 

  531.         b += n;

  532.     }

  533. 

  534.     /* Draw the cucul canvas onto an image buffer */

  535.     image = malloc(b * dp->drv.p->font_height *

  536.                    2 * dp->drv.p->font_width * sizeof(uint32_t));

  537.     cucul_render_canvas(cv, dp->drv.p->f, image, 2 * dp->drv.p->font_width,

  538.                         b * dp->drv.p->font_height, 8 * dp->drv.p->font_width);

  539.     cucul_free_canvas(cv);

  540. 

  541.     /* Convert all glyphs in the image buffer to GL textures */

  542.     dp->drv.p->txid = malloc(b * sizeof(int));

  543. 

  544.     w = dp->drv.p->font_width <= 16 ? dp->drv.p->font_width : 16;

  545.     h = dp->drv.p->font_height <= 16 ? dp->drv.p->font_height : 16;

  546. 

  547.     for(b = 0, i = 0; dp->drv.p->blocks[i + 1]; i += 2)

  548.     {

  549.         int j, n = (int)(dp->drv.p->blocks[i + 1] - dp->drv.p->blocks[i]);

  550. 

  551.         for(j = 0; j < n; j++)

  552.         {

  553.             uint8_t tmp[16 * 8 * 16];

  554.             uint32_t *glyph = image + (int)((b + j) * dp->drv.p->font_width * 2

  555.                                             * dp->drv.p->font_height);

  556.             int fullwidth =

  557.                     cucul_utf32_is_fullwidth(dp->drv.p->blocks[i] + j);

  558. 

  559.             memset(tmp, 0, 16 * 8 * 16);

  560.             

  561.             for(y = 0; y < h; y++)

  562.             {

  563.                 for(x = 0; x < w * (fullwidth ? 2 : 1); x++)

  564.                 {

  565.                     int offset = x + (15 - y) * (fullwidth ? 32 : 16);

  566.                     uint8_t c = glyph[x + y * 2 * (int)dp->drv.p->font_width]

  567.                                  >> 8;

  568.                     tmp[offset * 4] = c;

  569.                     tmp[offset * 4 + 1] = c;

  570.                     tmp[offset * 4 + 2] = c;

  571.                     tmp[offset * 4 + 3] = c;

  572.                 }

  573.             }

  574.             

  575.             glGenTextures(1, (GLuint*)&dp->drv.p->txid[b + j]);

  576.             glBindTexture(GL_TEXTURE_2D, dp->drv.p->txid[b + j]);

  577.             glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

  578.             glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

  579.             glTexImage2D(GL_TEXTURE_2D, 0, 4, (fullwidth ? 32 : 16), 16, 0,

  580.                          GL_RGBA, GL_UNSIGNED_BYTE, tmp);

  581.         }

  582. 

  583.         b += n;

  584.     }

  585. 

  586.     free(image);

  587. }

  588. 

  589. /*

  590.  * Driver initialisation

  591.  */

  592. 

  593. int gl_install(caca_display_t *dp)

  594. {

  595. #if defined(HAVE_GETENV) && defined(GLUT_XLIB_IMPLEMENTATION)

  596.     if(!getenv("DISPLAY") || !*(getenv("DISPLAY")))

  597.         return -1;

  598. #endif

  599. 

  600.     dp->drv.driver = CACA_DRIVER_GL;

  601. 

  602.     dp->drv.init_graphics = gl_init_graphics;

  603.     dp->drv.end_graphics = gl_end_graphics;

  604.     dp->drv.set_display_title = gl_set_display_title;

  605.     dp->drv.get_display_width = gl_get_display_width;

  606.     dp->drv.get_display_height = gl_get_display_height;

  607.     dp->drv.display = gl_display;

  608.     dp->drv.handle_resize = gl_handle_resize;

  609.     dp->drv.get_event = gl_get_event;

  610.     dp->drv.set_mouse = gl_set_mouse;

  611.     dp->drv.set_cursor = NULL;

  612. 

  613.     return 0;

  614. }

  615. 

  616. #endif /* USE_GL */