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.
828 Commits
1 Branch
4.9 MiB
 
 
 
 
 
 
Tag: 87cd66a5fd
Branches Tags
${ item.name }
Criar branch ${ searchTerm }
de 87cd66a5fd
${ noResults }
libcaca/caca/driver_gl.c

640 linhas
18 KiB
Original Anotar Histórico 

  1. /*

  2.  *  libcaca       Colour ASCII-Art library

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

  4.  *                All Rights Reserved

  5.  *

  6.  *  $Id$

  7.  *

  8.  *  This library is free software; you can redistribute it and/or

  9.  *  modify it under the terms of the Do What The Fuck You Want To

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

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

  12.  */

  13. 

  14. /*

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

  16.  */

  17. 

  18. #include "config.h"

  19. #include "common.h"

  20. 

  21. #if defined(USE_GL)

  22. 

  23. #ifdef HAVE_OPENGL_GL_H

  24. #   include <OpenGL/gl.h>

  25. #   include <GLUT/glut.h>

  26. #else

  27. #   include <GL/gl.h>

  28. #   include <GL/glut.h>

  29. #   include <GL/freeglut_ext.h>

  30. #endif

  31. 

  32. #include <string.h>

  33. #include <stdlib.h>

  34. #include <stdio.h>

  35. 

  36. #include "caca.h"

  37. #include "caca_internals.h"

  38. #include "cucul.h"

  39. #include "cucul_internals.h"

  40. 

  41. 

  42. /*

  43.  * Global variables

  44.  */

  45. 

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

  47. 

  48. /*

  49.  * Local functions

  50.  */

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

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

  53. static void gl_handle_reshape(int, int);

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

  55. static void gl_handle_mouse_motion(int, int);

  56. #ifdef HAVE_GLUTCLOSEFUNC

  57. static void gl_handle_close(void);

  58. #endif

  59. static void _display(void);

  60. static void gl_generate_glyph(uint32_t, uint32_t, caca_display_t *);

  61. static void gl_generate_unicode_glyph(uint32_t, uint32_t, 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.     int id[(128 - 32)];

  72.     int id_uni[8]; /* Hack, FIXME */

  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 *empty_texture;

  88.     char const *geometry;

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

  90.     char const * const * fonts;

  91.     unsigned int width = 0, height = 0;

  92.     int argc = 1;

  93.     int i;

  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.     if(width && height)

  106.         _cucul_set_canvas_size(dp->cv, width, height);

  107. 

  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 = dp->cv->width * dp->drv.p->font_width;

  127.     dp->drv.p->height = dp->cv->height * 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. 

  182.     empty_texture = malloc(16 * 16 * 4);

  183.     if(empty_texture == NULL)

  184.         return -1;

  185. 

  186.     memset(empty_texture, 0xff, 16 * 16 * 4);

  187.     glEnable(GL_TEXTURE_2D);

  188. 

  189.     /* ASCII glyphes textures initialisation */

  190.     for(i = 32; i < 128; i++)

  191.     {

  192.         glGenTextures(1, (GLuint*)&dp->drv.p->id[i - 32]);

  193.         glBindTexture(GL_TEXTURE_2D, dp->drv.p->id[i - 32]);

  194.         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

  195.         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

  196.         glTexImage2D(GL_TEXTURE_2D, 0, 4,

  197.                      16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, empty_texture);

  198.     }

  199. 

  200.     /* Unicode (CP437) glyphes textures initialisation */

  201.     for(i = 0; i < 8; i++)

  202.     {

  203.         glGenTextures(1, (GLuint*)&dp->drv.p->id_uni[i]);

  204.         glBindTexture(GL_TEXTURE_2D, dp->drv.p->id_uni[i]);

  205.         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

  206.         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

  207.         glTexImage2D(GL_TEXTURE_2D, 0, 4,

  208.                      16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, empty_texture);

  209.     }

  210. 

  211.     /* Get textures for ASCII glyphs */

  212.     for(i = 32; i < 128; i++)

  213.         gl_generate_glyph(i, i-32, dp);

  214. 

  215. 

  216.     gl_generate_unicode_glyph(0x00002580, 0, dp);

  217.     gl_generate_unicode_glyph(0x00002584, 1, dp);

  218.     gl_generate_unicode_glyph(0x00002588, 2, dp);

  219.     gl_generate_unicode_glyph(0x0000258c, 3, dp);

  220.     gl_generate_unicode_glyph(0x00002590, 4, dp);

  221.     gl_generate_unicode_glyph(0x00002591, 5, dp);

  222.     gl_generate_unicode_glyph(0x00002592, 6, dp);

  223.     gl_generate_unicode_glyph(0x00002593, 7, dp);

  224. 

  225.     return 0;

  226. }

  227. 

  228. static int gl_end_graphics(caca_display_t *dp)

  229. {

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

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

  232.     return 0;

  233. }

  234. 

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

  236. {

  237.     glutSetWindowTitle(title);

  238.     return 0;

  239. }

  240. 

  241. static unsigned int gl_get_display_width(caca_display_t *dp)

  242. {

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

  244. }

  245. 

  246. static unsigned int gl_get_display_height(caca_display_t *dp)

  247. {

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

  249. }

  250. 

  251. static void gl_display(caca_display_t *dp)

  252. {

  253.     unsigned int x, y, line;

  254.     static int old_texture = 0;

  255. 

  256.     glClear(GL_COLOR_BUFFER_BIT);

  257.     glDisable(GL_TEXTURE_2D);

  258.     glDisable(GL_BLEND);

  259.     line = 0;

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

  261.     {

  262.         uint32_t *attr = dp->cv->attr + line * dp->cv->width;

  263. 

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

  265.         {

  266.             uint16_t bg = _cucul_argb32_to_rgb12bg(*attr++);

  267. 

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

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

  270.                       (bg & 0x00f) * 8,

  271.                       0xff);

  272.             glBegin(GL_QUADS);

  273.             glVertex2f(x, y);

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

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

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

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

  278.             glEnd();

  279.         }

  280. 

  281.         line++;

  282.     }

  283. 

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

  285.     glEnable(GL_TEXTURE_2D);

  286.     glEnable(GL_BLEND);

  287. 

  288.     line = 0;

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

  290.     {

  291.         uint32_t *attr = dp->cv->attr + line * dp->cv->width;

  292.         uint32_t *chars = dp->cv->chars + line * dp->cv->width;

  293. 

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

  295.         {

  296.             uint32_t cv = *chars++;

  297.             uint16_t fg;

  298. 

  299.             if(cv == ' ')

  300.                 continue;

  301. 

  302.             if(cv > 0x00000020 && cv < 0x00000080)

  303.             {

  304.                 if(old_texture != dp->drv.p->id[cv - 32])

  305.                 {

  306.                     glBindTexture(GL_TEXTURE_2D, dp->drv.p->id[cv - 32]);

  307.                     old_texture = dp->drv.p->id[cv - 32];

  308.                 }

  309.             }

  310.             else switch(cv)

  311.             {

  312.                 case 0x00002580: glBindTexture(GL_TEXTURE_2D, dp->drv.p->id_uni[0]); break;

  313.                 case 0x00002584: glBindTexture(GL_TEXTURE_2D, dp->drv.p->id_uni[1]); break;

  314.                 case 0x00002588: glBindTexture(GL_TEXTURE_2D, dp->drv.p->id_uni[2]); break;

  315.                 case 0x0000258c: glBindTexture(GL_TEXTURE_2D, dp->drv.p->id_uni[3]); break;

  316.                 case 0x00002590: glBindTexture(GL_TEXTURE_2D, dp->drv.p->id_uni[4]); break;

  317.                 case 0x00002591: glBindTexture(GL_TEXTURE_2D, dp->drv.p->id_uni[5]); break;

  318.                 case 0x00002592: glBindTexture(GL_TEXTURE_2D, dp->drv.p->id_uni[6]); break;

  319.                 case 0x00002593: glBindTexture(GL_TEXTURE_2D, dp->drv.p->id_uni[7]); break;

  320.                 default:         glBindTexture(GL_TEXTURE_2D, dp->drv.p->id['?' - 32]); break;

  321.             }

  322. 

  323.             fg = _cucul_argb32_to_rgb12fg(*attr);

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

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

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

  327.             glBegin(GL_QUADS);

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

  329.             glVertex2f(x, y);

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

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

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

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

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

  335.             glTexCoord2f(0, 0);

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

  337.             glEnd();

  338.         }

  339.     }

  340. 

  341. #ifdef HAVE_GLUTCHECKLOOP

  342.     glutCheckLoop();

  343. #else

  344.     glutMainLoopEvent();

  345. #endif

  346.     glutSwapBuffers();

  347.     glutPostRedisplay();

  348. }

  349. 

  350. static void gl_handle_resize(caca_display_t *dp)

  351. {

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

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

  354. 

  355.     glMatrixMode(GL_PROJECTION);

  356.     glPushMatrix();

  357.     glLoadIdentity();

  358. 

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

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

  361.     glMatrixMode(GL_MODELVIEW);

  362. }

  363. 

  364. static int gl_get_event(caca_display_t *dp, caca_event_t *ev)

  365. {

  366. #ifdef HAVE_GLUTCHECKLOOP

  367.     glutCheckLoop();

  368. #else

  369.     glutMainLoopEvent();

  370. #endif

  371. 

  372. #ifdef HAVE_GLUTCLOSEFUNC

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

  374.     {

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

  376.         ev->type = CACA_EVENT_QUIT;

  377.         return 1;

  378.     }

  379. #endif

  380. 

  381.     if(dp->resize.resized)

  382.     {

  383.         ev->type = CACA_EVENT_RESIZE;

  384.         ev->data.resize.w = dp->cv->width;

  385.         ev->data.resize.h = dp->cv->height;

  386.         return 1;

  387.     }

  388. 

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

  390.     {

  391.         ev->type = CACA_EVENT_MOUSE_MOTION;

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

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

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

  395. 

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

  397.         {

  398.             _push_event(dp, ev);

  399.             ev->type = CACA_EVENT_MOUSE_PRESS;

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

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

  402.         }

  403. 

  404.         return 1;

  405.     }

  406. 

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

  408.     {

  409.         ev->type = CACA_EVENT_KEY_PRESS;

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

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

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

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

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

  415.         return 1;

  416.     }

  417. 

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

  419.     {

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

  421.         {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  440.                 break;

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

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

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

  444. 

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

  446.         }

  447. 

  448.         ev->type = CACA_EVENT_KEY_PRESS;

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

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

  451. 

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

  453.         return 1;

  454.     }

  455. 

  456.     ev->type = CACA_EVENT_NONE;

  457.     return 0;

  458. }

  459. 

  460. 

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

  462. {

  463.     if(flag)

  464.         glutSetCursor(GLUT_CURSOR_RIGHT_ARROW);

  465.     else

  466.         glutSetCursor(GLUT_CURSOR_NONE);

  467. }

  468. 

  469. /*

  470.  * XXX: following functions are local

  471.  */

  472. 

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

  474. {

  475.     caca_display_t *dp = gl_d;

  476. 

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

  478. }

  479. 

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

  481. {

  482.     caca_display_t *dp = gl_d;

  483. 

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

  485. }

  486. 

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

  488. {

  489.     caca_display_t *dp = gl_d;

  490. 

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

  492.     {

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

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

  495. 

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

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

  498. 

  499.         dp->resize.resized = 1;

  500.     }

  501.     else

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

  503. }

  504. 

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

  506. {

  507.     caca_display_t *dp = gl_d;

  508. 

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

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

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

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

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

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

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

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

  517. }

  518. 

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

  520. {

  521.     caca_display_t *dp = gl_d;

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

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

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

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

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

  527. }

  528. 

  529. #ifdef HAVE_GLUTCLOSEFUNC

  530. static void gl_handle_close(void)

  531. {

  532.     caca_display_t *dp = gl_d;

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

  534. }

  535. #endif

  536. 

  537. static void _display(void)

  538. {

  539.     caca_display_t *dp = gl_d;

  540.     gl_display(dp);

  541. }

  542. 

  543. static void gl_generate_glyph(uint32_t c, uint32_t tid, caca_display_t *dp)

  544. {

  545.     int s,d;

  546.     uint8_t *glyph8 =  calloc(dp->drv.p->font_width*dp->drv.p->font_height, 1);

  547.     uint8_t *glyph32 = calloc(16*16*4, 1);

  548. 

  549.     cucul_render_glyph(dp->drv.p->f, c, glyph8, dp->drv.p->font_width);

  550. 

  551.     /* Convert resulting 8bbp glyph to 32bits, 16x16*/

  552.     for(s=0;s<(dp->drv.p->font_height<=16?dp->drv.p->font_height:16);s++)

  553.     {

  554.         for(d=0;d<dp->drv.p->font_width;d++)

  555.         {

  556.             uint32_t offset = d*4+(15-s)*16*4;

  557.             uint8_t c = glyph8[d+s*(int)dp->drv.p->font_width];

  558.             glyph32[offset] = c;

  559.             glyph32[1+offset] = c;

  560.             glyph32[2+offset] = c;

  561.             glyph32[3+offset] = c;

  562.         }

  563.     }

  564. 

  565.     glBindTexture(GL_TEXTURE_2D, dp->drv.p->id[tid]);

  566.     glTexImage2D(GL_TEXTURE_2D,

  567.                  0, 4,

  568.                  16,16,

  569.                  0, GL_RGBA, GL_UNSIGNED_BYTE,

  570.                  glyph32);

  571.     glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);

  572.     glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);

  573.     free(glyph8);

  574.     free(glyph32);

  575. }

  576. 

  577. static void gl_generate_unicode_glyph(uint32_t c, uint32_t tid,

  578.                                       caca_display_t *dp)

  579. {

  580.     int s,d;

  581.     uint8_t *glyph8 =  calloc(dp->drv.p->font_width*dp->drv.p->font_height, 1);

  582.     uint8_t *glyph32 = calloc(16*16*4, 1);

  583. 

  584.     cucul_render_glyph(dp->drv.p->f, c, glyph8, dp->drv.p->font_width);

  585. 

  586.     /* Convert resulting 8bbp glyph to 32bits, 16x16*/

  587.     for(s=0;s<(dp->drv.p->font_height<=16?dp->drv.p->font_height:16);s++)

  588.     {

  589.         for(d=0;d<(dp->drv.p->font_width<=16?dp->drv.p->font_width:16);d++)

  590.         {

  591.             uint32_t offset = d*4+(15-s)*16*4;

  592.             uint8_t c = glyph8[d+s*(int)dp->drv.p->font_width];

  593.             glyph32[offset] = c;

  594.             glyph32[1+offset] = c;

  595.             glyph32[2+offset] = c;

  596.             glyph32[3+offset] = c;

  597.         }

  598.     }

  599. 

  600.     glBindTexture(GL_TEXTURE_2D, dp->drv.p->id_uni[tid]);

  601.     glTexImage2D(GL_TEXTURE_2D,

  602.                  0, 4,

  603.                  16,16,

  604.                  0, GL_RGBA, GL_UNSIGNED_BYTE,

  605.                  glyph32);

  606.     glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);

  607.     glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);

  608.     free(glyph8);

  609.     free(glyph32);

  610. }

  611. 

  612. /*

  613.  * Driver initialisation

  614.  */

  615. 

  616. int gl_install(caca_display_t *dp)

  617. {

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

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

  620.         return -1;

  621. #endif

  622. 

  623.     dp->drv.driver = CACA_DRIVER_GL;

  624. 

  625.     dp->drv.init_graphics = gl_init_graphics;

  626.     dp->drv.end_graphics = gl_end_graphics;

  627.     dp->drv.set_display_title = gl_set_display_title;

  628.     dp->drv.get_display_width = gl_get_display_width;

  629.     dp->drv.get_display_height = gl_get_display_height;

  630.     dp->drv.display = gl_display;

  631.     dp->drv.handle_resize = gl_handle_resize;

  632.     dp->drv.get_event = gl_get_event;

  633.     dp->drv.set_mouse = gl_set_mouse;

  634. 

  635.     return 0;

  636. }

  637. 

  638. #endif /* USE_GL */