source: libcaca/trunk/caca/driver_gl.c @ 1774

Last change on this file since 1774 was 1772, checked in by Sam Hocevar, 13 years ago
  • Fixed OpenGL fullwidth support, courtesy of Ben Wiley Sittler.
  • Property svn:keywords set to Id
File size: 17.0 KB
Line 
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: driver_gl.c 1772 2007-06-27 13:35:59Z sam $
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 "caca.h"
40#include "caca_internals.h"
41#include "cucul.h"
42#include "cucul_internals.h"
43
44
45/*
46 * Global variables
47 */
48
49static caca_display_t *gl_d; /* FIXME: we ought to get rid of this */
50
51/*
52 * Local functions
53 */
54static void gl_handle_keyboard(unsigned char, int, int);
55static void gl_handle_special_key(int, int, int);
56static void gl_handle_reshape(int, int);
57static void gl_handle_mouse(int, int, int, int);
58static void gl_handle_mouse_motion(int, int);
59#ifdef HAVE_GLUTCLOSEFUNC
60static void gl_handle_close(void);
61#endif
62static void _display(void);
63static void gl_compute_font(caca_display_t *);
64
65struct driver_private
66{
67    int window;
68    unsigned int width, height;
69    unsigned int new_width, new_height;
70    cucul_font_t *f;
71    float font_width, font_height;
72    float incx, incy;
73    unsigned long int const *blocks;
74    int *txid;
75    unsigned char close;
76    unsigned char bit;
77    unsigned char mouse_changed, mouse_clicked;
78    unsigned int mouse_x, mouse_y;
79    unsigned int mouse_button, mouse_state;
80
81    unsigned char key;
82    int special_key;
83
84    float sw, sh;
85};
86
87static int gl_init_graphics(caca_display_t *dp)
88{
89    char const *geometry;
90    char *argv[2] = { "", NULL };
91    char const * const * fonts;
92    unsigned int width = dp->cv->width, height = dp->cv->height;
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    _cucul_set_canvas_size(dp->cv, width ? width : 80, height ? height : 32);
106
107    /* Load a libcucul internal font */
108    fonts = cucul_get_font_list();
109    if(fonts[0] == NULL)
110    {
111        fprintf(stderr, "error: libcucul was compiled without any fonts\n");
112        return -1;
113    }
114    dp->drv.p->f = cucul_load_font(fonts[0], 0);
115    if(dp->drv.p->f == NULL)
116    {
117        fprintf(stderr, "error: could not load font \"%s\"\n", fonts[0]);
118        return -1;
119    }
120
121    dp->drv.p->font_width = cucul_get_font_width(dp->drv.p->f);
122    dp->drv.p->font_height = cucul_get_font_height(dp->drv.p->f);
123
124    dp->drv.p->width = dp->cv->width * dp->drv.p->font_width;
125    dp->drv.p->height = dp->cv->height * dp->drv.p->font_height;
126
127#ifdef HAVE_GLUTCLOSEFUNC
128    dp->drv.p->close = 0;
129#endif
130    dp->drv.p->bit = 0;
131
132    dp->drv.p->mouse_changed = dp->drv.p->mouse_clicked = 0;
133    dp->drv.p->mouse_button = dp->drv.p->mouse_state = 0;
134
135    dp->drv.p->key = 0;
136    dp->drv.p->special_key = 0;
137
138    dp->drv.p->sw = ((float)dp->drv.p->font_width) / 16.0f;
139    dp->drv.p->sh = ((float)dp->drv.p->font_height) / 16.0f;
140
141    glutInit(&argc, argv);
142
143    glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);
144    glutInitWindowSize(dp->drv.p->width, dp->drv.p->height);
145    dp->drv.p->window = glutCreateWindow("caca for GL");
146
147    gluOrtho2D(0, dp->drv.p->width, dp->drv.p->height, 0);
148
149    glDisable(GL_CULL_FACE);
150    glDisable(GL_DEPTH_TEST);
151
152    glutKeyboardFunc(gl_handle_keyboard);
153    glutSpecialFunc(gl_handle_special_key);
154    glutReshapeFunc(gl_handle_reshape);
155    glutDisplayFunc(_display);
156
157#ifdef HAVE_GLUTCLOSEFUNC
158    glutCloseFunc(gl_handle_close);
159#endif
160
161    glutMouseFunc(gl_handle_mouse);
162    glutMotionFunc(gl_handle_mouse_motion);
163    glutPassiveMotionFunc(gl_handle_mouse_motion);
164
165    glLoadIdentity();
166
167    glMatrixMode(GL_PROJECTION);
168    glPushMatrix();
169    glLoadIdentity();
170    gluOrtho2D(0, dp->drv.p->width, dp->drv.p->height, 0);
171
172    glMatrixMode(GL_MODELVIEW);
173
174    glClear(GL_COLOR_BUFFER_BIT);
175    glEnable(GL_TEXTURE_2D);
176    glEnable(GL_BLEND);
177    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
178
179    glEnable(GL_TEXTURE_2D);
180
181    gl_compute_font(dp);
182
183    return 0;
184}
185
186static int gl_end_graphics(caca_display_t *dp)
187{
188    glutDestroyWindow(dp->drv.p->window);
189    free(dp->drv.p->txid);
190    free(dp->drv.p);
191    return 0;
192}
193
194static int gl_set_display_title(caca_display_t *dp, char const *title)
195{
196    glutSetWindowTitle(title);
197    return 0;
198}
199
200static unsigned int gl_get_display_width(caca_display_t *dp)
201{
202    return dp->drv.p->width;
203}
204
205static unsigned int gl_get_display_height(caca_display_t *dp)
206{
207    return dp->drv.p->height;
208}
209
210static void gl_display(caca_display_t *dp)
211{
212    unsigned int x, y, line;
213
214    glClear(GL_COLOR_BUFFER_BIT);
215    glDisable(GL_TEXTURE_2D);
216    glDisable(GL_BLEND);
217    line = 0;
218    for(y = 0; y < dp->drv.p->height; y += dp->drv.p->font_height)
219    {
220        uint32_t *attrs = dp->cv->attrs + line * dp->cv->width;
221
222        /* FIXME: optimise using stride */
223        for(x = 0; x < dp->drv.p->width; x += dp->drv.p->font_width)
224        {
225            uint16_t bg = _cucul_attr_to_rgb12bg(*attrs++);
226
227            glColor4b(((bg & 0xf00) >> 8) * 8,
228                      ((bg & 0x0f0) >> 4) * 8,
229                      (bg & 0x00f) * 8,
230                      0xff);
231            glBegin(GL_QUADS);
232            glVertex2f(x, y);
233            glVertex2f(x + dp->drv.p->font_width, y);
234            glVertex2f(x + dp->drv.p->font_width,
235                       y + dp->drv.p->font_height);
236            glVertex2f(x, y + dp->drv.p->font_height);
237            glEnd();
238        }
239
240        line++;
241    }
242
243    /* 2nd pass, avoids changing render state too much */
244    glEnable(GL_TEXTURE_2D);
245    glEnable(GL_BLEND);
246
247    line = 0;
248    for(y = 0; y < dp->drv.p->height; y += dp->drv.p->font_height, line++)
249    {
250        uint32_t *attrs = dp->cv->attrs + line * dp->cv->width;
251        uint32_t *chars = dp->cv->chars + line * dp->cv->width;
252
253        for(x = 0; x < dp->drv.p->width; x += dp->drv.p->font_width, attrs++)
254        {
255            uint32_t ch = *chars++;
256            uint16_t fg;
257            int i, b, fullwidth;
258
259            fullwidth = cucul_utf32_is_fullwidth(ch);
260
261            for(b = 0, i = 0; dp->drv.p->blocks[i + 1]; i += 2)
262            {
263                if(ch < (uint32_t)dp->drv.p->blocks[i])
264                     break;
265
266                if(ch >= (uint32_t)dp->drv.p->blocks[i + 1])
267                {
268                    b += (uint32_t)(dp->drv.p->blocks[i + 1]
269                                     - dp->drv.p->blocks[i]);
270                    continue;
271                }
272
273                glBindTexture(GL_TEXTURE_2D,
274                              dp->drv.p->txid[b + ch
275                                        - (uint32_t)dp->drv.p->blocks[i]]);
276
277                fg = _cucul_attr_to_rgb12fg(*attrs);
278                glColor3b(((fg & 0xf00) >> 8) * 8,
279                          ((fg & 0x0f0) >> 4) * 8,
280                          (fg & 0x00f) * 8);
281                /* FIXME: handle fullwidth glyphs here */
282                glBegin(GL_QUADS);
283                glTexCoord2f(0, dp->drv.p->sh);
284                glVertex2f(x, y);
285                glTexCoord2f(dp->drv.p->sw, dp->drv.p->sh);
286                glVertex2f(x + dp->drv.p->font_width * (fullwidth ? 2 : 1), y);
287                glTexCoord2f(dp->drv.p->sw, 0);
288                glVertex2f(x + dp->drv.p->font_width * (fullwidth ? 2 : 1),
289                           y + dp->drv.p->font_height);
290                glTexCoord2f(0, 0);
291                glVertex2f(x, y + dp->drv.p->font_height);
292                glEnd();
293            }
294
295            if(fullwidth)
296            {
297                chars++; attrs++; x += dp->drv.p->font_width;
298            }
299        }
300    }
301
302#ifdef HAVE_GLUTCHECKLOOP
303    glutCheckLoop();
304#else
305    glutMainLoopEvent();
306#endif
307    glutSwapBuffers();
308    glutPostRedisplay();
309}
310
311static void gl_handle_resize(caca_display_t *dp)
312{
313    dp->drv.p->width = dp->drv.p->new_width;
314    dp->drv.p->height = dp->drv.p->new_height;
315
316    glMatrixMode(GL_PROJECTION);
317    glPushMatrix();
318    glLoadIdentity();
319
320    glViewport(0, 0, dp->drv.p->width, dp->drv.p->height);
321    gluOrtho2D(0, dp->drv.p->width, dp->drv.p->height, 0);
322    glMatrixMode(GL_MODELVIEW);
323}
324
325static int gl_get_event(caca_display_t *dp, caca_event_t *ev)
326{
327#ifdef HAVE_GLUTCHECKLOOP
328    glutCheckLoop();
329#else
330    glutMainLoopEvent();
331#endif
332
333#ifdef HAVE_GLUTCLOSEFUNC
334    if(dp->drv.p->close)
335    {
336        dp->drv.p->close = 0;
337        ev->type = CACA_EVENT_QUIT;
338        return 1;
339    }
340#endif
341
342    if(dp->resize.resized)
343    {
344        ev->type = CACA_EVENT_RESIZE;
345        ev->data.resize.w = dp->cv->width;
346        ev->data.resize.h = dp->cv->height;
347        return 1;
348    }
349
350    if(dp->drv.p->mouse_changed)
351    {
352        ev->type = CACA_EVENT_MOUSE_MOTION;
353        ev->data.mouse.x = dp->mouse.x;
354        ev->data.mouse.y = dp->mouse.y;
355        dp->drv.p->mouse_changed = 0;
356
357        if(dp->drv.p->mouse_clicked)
358        {
359            _push_event(dp, ev);
360            ev->type = CACA_EVENT_MOUSE_PRESS;
361            ev->data.mouse.button = dp->drv.p->mouse_button;
362            dp->drv.p->mouse_clicked = 0;
363        }
364
365        return 1;
366    }
367
368    if(dp->drv.p->key != 0)
369    {
370        ev->type = CACA_EVENT_KEY_PRESS;
371        ev->data.key.ch = dp->drv.p->key;
372        ev->data.key.utf32 = (uint32_t)dp->drv.p->key;
373        ev->data.key.utf8[0] = dp->drv.p->key;
374        ev->data.key.utf8[1] = '\0';
375        dp->drv.p->key = 0;
376        return 1;
377    }
378
379    if(dp->drv.p->special_key != 0)
380    {
381        switch(dp->drv.p->special_key)
382        {
383            case GLUT_KEY_F1 : ev->data.key.ch = CACA_KEY_F1; break;
384            case GLUT_KEY_F2 : ev->data.key.ch = CACA_KEY_F2; break;
385            case GLUT_KEY_F3 : ev->data.key.ch = CACA_KEY_F3; break;
386            case GLUT_KEY_F4 : ev->data.key.ch = CACA_KEY_F4; break;
387            case GLUT_KEY_F5 : ev->data.key.ch = CACA_KEY_F5; break;
388            case GLUT_KEY_F6 : ev->data.key.ch = CACA_KEY_F6; break;
389            case GLUT_KEY_F7 : ev->data.key.ch = CACA_KEY_F7; break;
390            case GLUT_KEY_F8 : ev->data.key.ch = CACA_KEY_F8; break;
391            case GLUT_KEY_F9 : ev->data.key.ch = CACA_KEY_F9; break;
392            case GLUT_KEY_F10: ev->data.key.ch = CACA_KEY_F10; break;
393            case GLUT_KEY_F11: ev->data.key.ch = CACA_KEY_F11; break;
394            case GLUT_KEY_F12: ev->data.key.ch = CACA_KEY_F12; break;
395            case GLUT_KEY_LEFT : ev->data.key.ch = CACA_KEY_LEFT; break;
396            case GLUT_KEY_RIGHT: ev->data.key.ch = CACA_KEY_RIGHT; break;
397            case GLUT_KEY_UP   : ev->data.key.ch = CACA_KEY_UP; break;
398            case GLUT_KEY_DOWN : ev->data.key.ch = CACA_KEY_DOWN; break;
399            case GLUT_KEY_PAGE_UP : ev->data.key.ch = CACA_KEY_PAGEUP; break;
400            case GLUT_KEY_PAGE_DOWN  : ev->data.key.ch = CACA_KEY_PAGEDOWN;
401                break;
402            case GLUT_KEY_HOME : ev->data.key.ch = CACA_KEY_HOME; break;
403            case GLUT_KEY_END : ev->data.key.ch = CACA_KEY_END; break;
404            case GLUT_KEY_INSERT : ev->data.key.ch = CACA_KEY_INSERT; break;
405
406            default: ev->type = CACA_EVENT_NONE; return 0;
407        }
408
409        ev->type = CACA_EVENT_KEY_PRESS;
410        ev->data.key.utf32 = 0;
411        ev->data.key.utf8[0] = '\0';
412
413        dp->drv.p->special_key = 0;
414        return 1;
415    }
416
417    ev->type = CACA_EVENT_NONE;
418    return 0;
419}
420
421
422static void gl_set_mouse(caca_display_t *dp, int flag)
423{
424    if(flag)
425        glutSetCursor(GLUT_CURSOR_RIGHT_ARROW);
426    else
427        glutSetCursor(GLUT_CURSOR_NONE);
428}
429
430/*
431 * XXX: following functions are local
432 */
433
434static void gl_handle_keyboard(unsigned char key, int x, int y)
435{
436    caca_display_t *dp = gl_d;
437
438    dp->drv.p->key = key;
439}
440
441static void gl_handle_special_key(int key, int x, int y)
442{
443    caca_display_t *dp = gl_d;
444
445    dp->drv.p->special_key = key;
446}
447
448static void gl_handle_reshape(int w, int h)
449{
450    caca_display_t *dp = gl_d;
451
452    if(dp->drv.p->bit) /* Do not handle reshaping at the first time */
453    {
454        dp->drv.p->new_width = w;
455        dp->drv.p->new_height = h;
456
457        dp->resize.w = w / dp->drv.p->font_width;
458        dp->resize.h = (h / dp->drv.p->font_height) + 1;
459
460        dp->resize.resized = 1;
461    }
462    else
463        dp->drv.p->bit = 1;
464}
465
466static void gl_handle_mouse(int button, int state, int x, int y)
467{
468    caca_display_t *dp = gl_d;
469
470    dp->drv.p->mouse_clicked = 1;
471    dp->drv.p->mouse_button = button;
472    dp->drv.p->mouse_state = state;
473    dp->drv.p->mouse_x = x / dp->drv.p->font_width;
474    dp->drv.p->mouse_y = y / dp->drv.p->font_height;
475    dp->mouse.x = dp->drv.p->mouse_x;
476    dp->mouse.y = dp->drv.p->mouse_y;
477    dp->drv.p->mouse_changed = 1;
478}
479
480static void gl_handle_mouse_motion(int x, int y)
481{
482    caca_display_t *dp = gl_d;
483    dp->drv.p->mouse_x = x / dp->drv.p->font_width;
484    dp->drv.p->mouse_y = y / dp->drv.p->font_height;
485    dp->mouse.x = dp->drv.p->mouse_x;
486    dp->mouse.y = dp->drv.p->mouse_y;
487    dp->drv.p->mouse_changed = 1;
488}
489
490#ifdef HAVE_GLUTCLOSEFUNC
491static void gl_handle_close(void)
492{
493    caca_display_t *dp = gl_d;
494    dp->drv.p->close = 1;
495}
496#endif
497
498static void _display(void)
499{
500    caca_display_t *dp = gl_d;
501    gl_display(dp);
502}
503
504static void gl_compute_font(caca_display_t *dp)
505{
506    cucul_canvas_t *cv;
507    uint32_t *image;
508    int i, b, w, h, x, y;
509
510    /* Count how many glyphs this font has */
511    dp->drv.p->blocks = cucul_get_font_blocks(dp->drv.p->f);
512
513    for(b = 0, i = 0; dp->drv.p->blocks[i + 1]; i += 2)
514        b += (int)(dp->drv.p->blocks[i + 1] - dp->drv.p->blocks[i]);
515
516    /* Allocate a libcucul canvas and print all the glyphs on it */
517    cv = cucul_create_canvas(2, b);
518    cucul_set_color_ansi(cv, CUCUL_WHITE, CUCUL_BLACK);
519
520    for(b = 0, i = 0; dp->drv.p->blocks[i + 1]; i += 2)
521    {
522        int j, n = (int)(dp->drv.p->blocks[i + 1] - dp->drv.p->blocks[i]);
523
524        for(j = 0; j < n; j++)
525            cucul_put_char(cv, 0, b + j, dp->drv.p->blocks[i] + j);
526
527        b += n;
528    }
529
530    /* Draw the cucul canvas onto an image buffer */
531    image = malloc(b * dp->drv.p->font_height *
532                   2 * dp->drv.p->font_width * sizeof(uint32_t));
533    cucul_render_canvas(cv, dp->drv.p->f, image, 2 * dp->drv.p->font_width,
534                        b * dp->drv.p->font_height, 8 * dp->drv.p->font_width);
535    cucul_free_canvas(cv);
536
537    /* Convert all glyphs in the image buffer to GL textures */
538    dp->drv.p->txid = malloc(b * sizeof(int));
539
540    w = dp->drv.p->font_width <= 16 ? dp->drv.p->font_width : 16;
541    h = dp->drv.p->font_height <= 16 ? dp->drv.p->font_height : 16;
542
543    for(b = 0, i = 0; dp->drv.p->blocks[i + 1]; i += 2)
544    {
545        int j, n = (int)(dp->drv.p->blocks[i + 1] - dp->drv.p->blocks[i]);
546
547        for(j = 0; j < n; j++)
548        {
549            uint8_t tmp[16 * 8 * 16];
550            uint32_t *glyph = image + (int)((b + j) * dp->drv.p->font_width * 2
551                                            * dp->drv.p->font_height);
552            int fullwidth =
553                    cucul_utf32_is_fullwidth(dp->drv.p->blocks[i] + j);
554
555            memset(tmp, 0, 16 * 8 * 16);
556           
557            for(y = 0; y < h; y++)
558            {
559                for(x = 0; x < w * (fullwidth ? 2 : 1); x++)
560                {
561                    int offset = x + (15 - y) * (fullwidth ? 32 : 16);
562                    uint8_t c = glyph[x + y * 2 * (int)dp->drv.p->font_width]
563                                 >> 8;
564                    tmp[offset * 4] = c;
565                    tmp[offset * 4 + 1] = c;
566                    tmp[offset * 4 + 2] = c;
567                    tmp[offset * 4 + 3] = c;
568                }
569            }
570           
571            glGenTextures(1, (GLuint*)&dp->drv.p->txid[b + j]);
572            glBindTexture(GL_TEXTURE_2D, dp->drv.p->txid[b + j]);
573            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
574            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
575            glTexImage2D(GL_TEXTURE_2D, 0, 4, (fullwidth ? 32 : 16), 16, 0,
576                         GL_RGBA, GL_UNSIGNED_BYTE, tmp);
577        }
578
579        b += n;
580    }
581
582    free(image);
583}
584
585/*
586 * Driver initialisation
587 */
588
589int gl_install(caca_display_t *dp)
590{
591#if defined(HAVE_GETENV) && defined(GLUT_XLIB_IMPLEMENTATION)
592    if(!getenv("DISPLAY") || !*(getenv("DISPLAY")))
593        return -1;
594#endif
595
596    dp->drv.driver = CACA_DRIVER_GL;
597
598    dp->drv.init_graphics = gl_init_graphics;
599    dp->drv.end_graphics = gl_end_graphics;
600    dp->drv.set_display_title = gl_set_display_title;
601    dp->drv.get_display_width = gl_get_display_width;
602    dp->drv.get_display_height = gl_get_display_height;
603    dp->drv.display = gl_display;
604    dp->drv.handle_resize = gl_handle_resize;
605    dp->drv.get_event = gl_get_event;
606    dp->drv.set_mouse = gl_set_mouse;
607    dp->drv.set_cursor = NULL;
608
609    return 0;
610}
611
612#endif /* USE_GL */
613
Note: See TracBrowser for help on using the repository browser.