cacalabs
/
libcaca
espelhamento de https://github.com/cacalabs/libcaca.git
1
0
Fork 0
Código Issues 0 Versões 7 Wiki Atividade
Você não pode selecionar mais de 25 tópicos Os tópicos devem começar com uma letra ou um número, podem incluir traços ('-') e podem ter até 35 caracteres.
1209 Commits
1 Branch
55 MiB
 
 
 
 
 
 
Tag: 07b9891afa
Branches Tags
${ item.name }
Criar branch ${ searchTerm }
de 07b9891afa
${ noResults }
libcaca/caca/driver_gl.c

619 linhas
17 KiB
Original Anotar Histórico 

  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 "cucul_internals.h"

  41. #include "caca.h"

  42. #include "caca_internals.h"

  43. 

  44. /*

  45.  * Global variables

  46.  */

  47. 

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

  49. 

  50. /*

  51.  * Local functions

  52.  */

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

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

  55. static void gl_handle_reshape(int, int);

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

  57. static void gl_handle_mouse_motion(int, int);

  58. #ifdef HAVE_GLUTCLOSEFUNC

  59. static void gl_handle_close(void);

  60. #endif

  61. static void _display(void);

  62. static void gl_compute_font(caca_display_t *);

  63. 

  64. struct driver_private

  65. {

  66.     int window;

  67.     unsigned int width, height;

  68.     unsigned int new_width, new_height;

  69.     cucul_font_t *f;

  70.     float font_width, font_height;

  71.     float incx, incy;

  72.     unsigned long int const *blocks;

  73.     int *txid;

  74.     unsigned char close;

  75.     unsigned char bit;

  76.     unsigned char mouse_changed, mouse_clicked;

  77.     unsigned int mouse_x, mouse_y;

  78.     unsigned int mouse_button, mouse_state;

  79. 

  80.     unsigned char key;

  81.     int special_key;

  82. 

  83.     float sw, sh;

  84. };

  85. 

  86. static int gl_init_graphics(caca_display_t *dp)

  87. {

  88.     char const *geometry;

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

  90.     char const * const * fonts;

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

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

  93.     int argc = 1;

  94. 

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

  96. 

  97.     gl_d = dp;

  98. 

  99. #if defined(HAVE_GETENV)

  100.     geometry = getenv("CACA_GEOMETRY");

  101.     if(geometry && *geometry)

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

  103. #endif

  104. 

  105.     dp->resize.allow = 1;

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

  107.     dp->resize.allow = 0;

  108. 

  109.     /* Load a libcucul internal font */

  110.     fonts = cucul_get_font_list();

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

  112.     {

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

  114.         return -1;

  115.     }

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

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

  118.     {

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

  120.         return -1;

  121.     }

  122. 

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

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

  125. 

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

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

  128. 

  129. #ifdef HAVE_GLUTCLOSEFUNC

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

  131. #endif

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

  133. 

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

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

  136. 

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

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

  139. 

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

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

  142. 

  143.     glutInit(&argc, argv);

  144. 

  145.     glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);

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

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

  148. 

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

  150. 

  151.     glDisable(GL_CULL_FACE);

  152.     glDisable(GL_DEPTH_TEST);

  153. 

  154.     glutKeyboardFunc(gl_handle_keyboard);

  155.     glutSpecialFunc(gl_handle_special_key);

  156.     glutReshapeFunc(gl_handle_reshape);

  157.     glutDisplayFunc(_display);

  158. 

  159. #ifdef HAVE_GLUTCLOSEFUNC

  160.     glutCloseFunc(gl_handle_close);

  161. #endif

  162. 

  163.     glutMouseFunc(gl_handle_mouse);

  164.     glutMotionFunc(gl_handle_mouse_motion);

  165.     glutPassiveMotionFunc(gl_handle_mouse_motion);

  166. 

  167.     glLoadIdentity();

  168. 

  169.     glMatrixMode(GL_PROJECTION);

  170.     glPushMatrix();

  171.     glLoadIdentity();

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

  173. 

  174.     glMatrixMode(GL_MODELVIEW);

  175. 

  176.     glClear(GL_COLOR_BUFFER_BIT);

  177.     glEnable(GL_TEXTURE_2D);

  178.     glEnable(GL_BLEND);

  179.     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

  180. 

  181.     glEnable(GL_TEXTURE_2D);

  182. 

  183.     gl_compute_font(dp);

  184. 

  185.     return 0;

  186. }

  187. 

  188. static int gl_end_graphics(caca_display_t *dp)

  189. {

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

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

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

  193.     return 0;

  194. }

  195. 

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

  197. {

  198.     glutSetWindowTitle(title);

  199.     return 0;

  200. }

  201. 

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

  203. {

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

  205. }

  206. 

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

  208. {

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

  210. }

  211. 

  212. static void gl_display(caca_display_t *dp)

  213. {

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

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

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

  217.     unsigned int x, y, line;

  218. 

  219.     glClear(GL_COLOR_BUFFER_BIT);

  220.     glDisable(GL_TEXTURE_2D);

  221.     glDisable(GL_BLEND);

  222.     line = 0;

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

  224.     {

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

  226. 

  227.         /* FIXME: optimise using stride */

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

  229.         {

  230.             uint16_t bg = _cucul_attr_to_rgb12bg(*attrs++);

  231. 

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

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

  234.                       (bg & 0x00f) * 8,

  235.                       0xff);

  236.             glBegin(GL_QUADS);

  237.             glVertex2f(x, y);

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

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

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

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

  242.             glEnd();

  243.         }

  244. 

  245.         line++;

  246.     }

  247. 

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

  249.     glEnable(GL_TEXTURE_2D);

  250.     glEnable(GL_BLEND);

  251. 

  252.     line = 0;

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

  254.     {

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

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

  257. 

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

  259.         {

  260.             uint32_t ch = *chars++;

  261.             uint16_t fg;

  262.             int i, b, fullwidth;

  263. 

  264.             fullwidth = cucul_utf32_is_fullwidth(ch);

  265. 

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

  267.             {

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

  269.                      break;

  270. 

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

  272.                 {

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

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

  275.                     continue;

  276.                 }

  277. 

  278.                 glBindTexture(GL_TEXTURE_2D,

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

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

  281. 

  282.                 fg = _cucul_attr_to_rgb12fg(*attrs);

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

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

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

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

  287.                 glBegin(GL_QUADS);

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

  289.                 glVertex2f(x, y);

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

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

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

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

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

  295.                 glTexCoord2f(0, 0);

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

  297.                 glEnd();

  298.             }

  299. 

  300.             if(fullwidth)

  301.             {

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

  303.             }

  304.         }

  305.     }

  306. 

  307. #ifdef HAVE_GLUTCHECKLOOP

  308.     glutCheckLoop();

  309. #else

  310.     glutMainLoopEvent();

  311. #endif

  312.     glutSwapBuffers();

  313.     glutPostRedisplay();

  314. }

  315. 

  316. static void gl_handle_resize(caca_display_t *dp)

  317. {

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

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

  320. 

  321.     glMatrixMode(GL_PROJECTION);

  322.     glPushMatrix();

  323.     glLoadIdentity();

  324. 

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

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

  327.     glMatrixMode(GL_MODELVIEW);

  328. }

  329. 

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

  331. {

  332. #ifdef HAVE_GLUTCHECKLOOP

  333.     glutCheckLoop();

  334. #else

  335.     glutMainLoopEvent();

  336. #endif

  337. 

  338. #ifdef HAVE_GLUTCLOSEFUNC

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

  340.     {

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

  342.         ev->type = CACA_EVENT_QUIT;

  343.         return 1;

  344.     }

  345. #endif

  346. 

  347.     if(dp->resize.resized)

  348.     {

  349.         ev->type = CACA_EVENT_RESIZE;

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

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

  352.         return 1;

  353.     }

  354. 

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

  356.     {

  357.         ev->type = CACA_EVENT_MOUSE_MOTION;

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

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

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

  361. 

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

  363.         {

  364.             _push_event(dp, ev);

  365.             ev->type = CACA_EVENT_MOUSE_PRESS;

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

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

  368.         }

  369. 

  370.         return 1;

  371.     }

  372. 

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

  374.     {

  375.         ev->type = CACA_EVENT_KEY_PRESS;

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

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

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

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

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

  381.         return 1;

  382.     }

  383. 

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

  385.     {

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

  387.         {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  406.                 break;

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

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

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

  410. 

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

  412.         }

  413. 

  414.         ev->type = CACA_EVENT_KEY_PRESS;

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

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

  417. 

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

  419.         return 1;

  420.     }

  421. 

  422.     ev->type = CACA_EVENT_NONE;

  423.     return 0;

  424. }

  425. 

  426. 

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

  428. {

  429.     if(flag)

  430.         glutSetCursor(GLUT_CURSOR_RIGHT_ARROW);

  431.     else

  432.         glutSetCursor(GLUT_CURSOR_NONE);

  433. }

  434. 

  435. /*

  436.  * XXX: following functions are local

  437.  */

  438. 

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

  440. {

  441.     caca_display_t *dp = gl_d;

  442. 

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

  444. }

  445. 

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

  447. {

  448.     caca_display_t *dp = gl_d;

  449. 

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

  451. }

  452. 

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

  454. {

  455.     caca_display_t *dp = gl_d;

  456. 

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

  458.     {

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

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

  461. 

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

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

  464. 

  465.         dp->resize.resized = 1;

  466.     }

  467.     else

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

  469. }

  470. 

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

  472. {

  473.     caca_display_t *dp = gl_d;

  474. 

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

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

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

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

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

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

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

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

  483. }

  484. 

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

  486. {

  487.     caca_display_t *dp = gl_d;

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

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

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

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

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

  493. }

  494. 

  495. #ifdef HAVE_GLUTCLOSEFUNC

  496. static void gl_handle_close(void)

  497. {

  498.     caca_display_t *dp = gl_d;

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

  500. }

  501. #endif

  502. 

  503. static void _display(void)

  504. {

  505.     caca_display_t *dp = gl_d;

  506.     gl_display(dp);

  507. }

  508. 

  509. static void gl_compute_font(caca_display_t *dp)

  510. {

  511.     cucul_canvas_t *cv;

  512.     uint32_t *image;

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

  514. 

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

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

  517. 

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

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

  520. 

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

  522.     cv = cucul_create_canvas(2, b);

  523.     cucul_set_color_ansi(cv, CUCUL_WHITE, CUCUL_BLACK);

  524. 

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

  526.     {

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

  528. 

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

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

  531. 

  532.         b += n;

  533.     }

  534. 

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

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

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

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

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

  540.     cucul_free_canvas(cv);

  541. 

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

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

  544. 

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

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

  547. 

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

  549.     {

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

  551. 

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

  553.         {

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

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

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

  557.             int fullwidth =

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

  559. 

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

  561.             

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

  563.             {

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

  565.                 {

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

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

  568.                                  >> 8;

  569.                     tmp[offset * 4] = c;

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

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

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

  573.                 }

  574.             }

  575.             

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

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

  578.             glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

  579.             glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

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

  581.                          GL_RGBA, GL_UNSIGNED_BYTE, tmp);

  582.         }

  583. 

  584.         b += n;

  585.     }

  586. 

  587.     free(image);

  588. }

  589. 

  590. /*

  591.  * Driver initialisation

  592.  */

  593. 

  594. int gl_install(caca_display_t *dp)

  595. {

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

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

  598.         return -1;

  599. #endif

  600. 

  601.     dp->drv.driver = CACA_DRIVER_GL;

  602. 

  603.     dp->drv.init_graphics = gl_init_graphics;

  604.     dp->drv.end_graphics = gl_end_graphics;

  605.     dp->drv.set_display_title = gl_set_display_title;

  606.     dp->drv.get_display_width = gl_get_display_width;

  607.     dp->drv.get_display_height = gl_get_display_height;

  608.     dp->drv.display = gl_display;

  609.     dp->drv.handle_resize = gl_handle_resize;

  610.     dp->drv.get_event = gl_get_event;

  611.     dp->drv.set_mouse = gl_set_mouse;

  612.     dp->drv.set_cursor = NULL;

  613. 

  614.     return 0;

  615. }

  616. 

  617. #endif /* USE_GL */