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

Last change on this file since 1061 was 1061, checked in by Sam Hocevar, 14 years ago
  • Use cucul_render_canvas() instead of cucul_render_glyph() in the GL driver.
  • Property svn:keywords set to Id
File size: 15.7 KB
Line 
1/*
2 *  libcaca       Colour ASCII-Art library
3 *  Copyright (c) 2002-2006 Sam Hocevar <sam@zoy.org>
4 *                All Rights Reserved
5 *
6 *  $Id: driver_gl.c 1061 2006-09-19 00:01:26Z sam $
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
46static caca_display_t *gl_d; /* FIXME: we ought to get rid of this */
47
48/*
49 * Local functions
50 */
51static void gl_handle_keyboard(unsigned char, int, int);
52static void gl_handle_special_key(int, int, int);
53static void gl_handle_reshape(int, int);
54static void gl_handle_mouse(int, int, int, int);
55static void gl_handle_mouse_motion(int, int);
56#ifdef HAVE_GLUTCLOSEFUNC
57static void gl_handle_close(void);
58#endif
59static void _display(void);
60static void gl_compute_font(caca_display_t *);
61static void gl_generate_unicode_glyph(uint32_t, uint32_t, caca_display_t *);
62
63struct 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
85static 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 = 0, height = 0;
91    int argc = 1;
92
93    dp->drv.p = malloc(sizeof(struct driver_private));
94
95    gl_d = dp;
96
97#if defined(HAVE_GETENV)
98    geometry = getenv("CACA_GEOMETRY");
99    if(geometry && *geometry)
100        sscanf(geometry, "%ux%u", &width, &height);
101#endif
102
103    if(width && height)
104        _cucul_set_canvas_size(dp->cv, width, height);
105
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 *attr = dp->cv->attr + line * dp->cv->width;
221
222        for(x = 0; x < dp->drv.p->width; x += dp->drv.p->font_width)
223        {
224            uint16_t bg = _cucul_argb32_to_rgb12bg(*attr++);
225
226            glColor4b(((bg & 0xf00) >> 8) * 8,
227                      ((bg & 0x0f0) >> 4) * 8,
228                      (bg & 0x00f) * 8,
229                      0xff);
230            glBegin(GL_QUADS);
231            glVertex2f(x, y);
232            glVertex2f(x + dp->drv.p->font_width, y);
233            glVertex2f(x + dp->drv.p->font_width,
234                       y + dp->drv.p->font_height);
235            glVertex2f(x, y + dp->drv.p->font_height);
236            glEnd();
237        }
238
239        line++;
240    }
241
242    /* 2nd pass, avoids changing render state too much */
243    glEnable(GL_TEXTURE_2D);
244    glEnable(GL_BLEND);
245
246    line = 0;
247    for(y = 0; y < dp->drv.p->height; y += dp->drv.p->font_height, line++)
248    {
249        uint32_t *attr = dp->cv->attr + line * dp->cv->width;
250        uint32_t *chars = dp->cv->chars + line * dp->cv->width;
251
252        for(x = 0; x < dp->drv.p->width; x += dp->drv.p->font_width, attr++)
253        {
254            uint32_t cv = *chars++;
255            uint16_t fg;
256            int i, b;
257
258            for(b = 0, i = 0; dp->drv.p->blocks[i + 1]; i += 2)
259            {
260                if(cv < dp->drv.p->blocks[i])
261                    break;
262
263                if(cv >= dp->drv.p->blocks[i + 1])
264                {
265                    b += dp->drv.p->blocks[i + 1] - dp->drv.p->blocks[i];
266                    continue;
267                }
268
269                glBindTexture(GL_TEXTURE_2D,
270                              dp->drv.p->txid[b + cv - dp->drv.p->blocks[i]]);
271
272                fg = _cucul_argb32_to_rgb12fg(*attr);
273                glColor3b(((fg & 0xf00) >> 8) * 8,
274                          ((fg & 0x0f0) >> 4) * 8,
275                          (fg & 0x00f) * 8);
276                glBegin(GL_QUADS);
277                glTexCoord2f(0, dp->drv.p->sh);
278                glVertex2f(x, y);
279                glTexCoord2f(dp->drv.p->sw, dp->drv.p->sh);
280                glVertex2f(x + dp->drv.p->font_width, y);
281                glTexCoord2f(dp->drv.p->sw, 0);
282                glVertex2f(x + dp->drv.p->font_width,
283                           y + dp->drv.p->font_height);
284                glTexCoord2f(0, 0);
285                glVertex2f(x, y + dp->drv.p->font_height);
286                glEnd();
287            }
288        }
289    }
290
291#ifdef HAVE_GLUTCHECKLOOP
292    glutCheckLoop();
293#else
294    glutMainLoopEvent();
295#endif
296    glutSwapBuffers();
297    glutPostRedisplay();
298}
299
300static void gl_handle_resize(caca_display_t *dp)
301{
302    dp->drv.p->width = dp->drv.p->new_width;
303    dp->drv.p->height = dp->drv.p->new_height;
304
305    glMatrixMode(GL_PROJECTION);
306    glPushMatrix();
307    glLoadIdentity();
308
309    glViewport(0, 0, dp->drv.p->width, dp->drv.p->height);
310    gluOrtho2D(0, dp->drv.p->width, dp->drv.p->height, 0);
311    glMatrixMode(GL_MODELVIEW);
312}
313
314static int gl_get_event(caca_display_t *dp, caca_event_t *ev)
315{
316#ifdef HAVE_GLUTCHECKLOOP
317    glutCheckLoop();
318#else
319    glutMainLoopEvent();
320#endif
321
322#ifdef HAVE_GLUTCLOSEFUNC
323    if(dp->drv.p->close)
324    {
325        dp->drv.p->close = 0;
326        ev->type = CACA_EVENT_QUIT;
327        return 1;
328    }
329#endif
330
331    if(dp->resize.resized)
332    {
333        ev->type = CACA_EVENT_RESIZE;
334        ev->data.resize.w = dp->cv->width;
335        ev->data.resize.h = dp->cv->height;
336        return 1;
337    }
338
339    if(dp->drv.p->mouse_changed)
340    {
341        ev->type = CACA_EVENT_MOUSE_MOTION;
342        ev->data.mouse.x = dp->mouse.x;
343        ev->data.mouse.y = dp->mouse.y;
344        dp->drv.p->mouse_changed = 0;
345
346        if(dp->drv.p->mouse_clicked)
347        {
348            _push_event(dp, ev);
349            ev->type = CACA_EVENT_MOUSE_PRESS;
350            ev->data.mouse.button = dp->drv.p->mouse_button;
351            dp->drv.p->mouse_clicked = 0;
352        }
353
354        return 1;
355    }
356
357    if(dp->drv.p->key != 0)
358    {
359        ev->type = CACA_EVENT_KEY_PRESS;
360        ev->data.key.ch = dp->drv.p->key;
361        ev->data.key.utf32 = (uint32_t)dp->drv.p->key;
362        ev->data.key.utf8[0] = dp->drv.p->key;
363        ev->data.key.utf8[1] = '\0';
364        dp->drv.p->key = 0;
365        return 1;
366    }
367
368    if(dp->drv.p->special_key != 0)
369    {
370        switch(dp->drv.p->special_key)
371        {
372            case GLUT_KEY_F1 : ev->data.key.ch = CACA_KEY_F1; break;
373            case GLUT_KEY_F2 : ev->data.key.ch = CACA_KEY_F2; break;
374            case GLUT_KEY_F3 : ev->data.key.ch = CACA_KEY_F3; break;
375            case GLUT_KEY_F4 : ev->data.key.ch = CACA_KEY_F4; break;
376            case GLUT_KEY_F5 : ev->data.key.ch = CACA_KEY_F5; break;
377            case GLUT_KEY_F6 : ev->data.key.ch = CACA_KEY_F6; break;
378            case GLUT_KEY_F7 : ev->data.key.ch = CACA_KEY_F7; break;
379            case GLUT_KEY_F8 : ev->data.key.ch = CACA_KEY_F8; break;
380            case GLUT_KEY_F9 : ev->data.key.ch = CACA_KEY_F9; break;
381            case GLUT_KEY_F10: ev->data.key.ch = CACA_KEY_F10; break;
382            case GLUT_KEY_F11: ev->data.key.ch = CACA_KEY_F11; break;
383            case GLUT_KEY_F12: ev->data.key.ch = CACA_KEY_F12; break;
384            case GLUT_KEY_LEFT : ev->data.key.ch = CACA_KEY_LEFT; break;
385            case GLUT_KEY_RIGHT: ev->data.key.ch = CACA_KEY_RIGHT; break;
386            case GLUT_KEY_UP   : ev->data.key.ch = CACA_KEY_UP; break;
387            case GLUT_KEY_DOWN : ev->data.key.ch = CACA_KEY_DOWN; break;
388            case GLUT_KEY_PAGE_UP : ev->data.key.ch = CACA_KEY_PAGEUP; break;
389            case GLUT_KEY_PAGE_DOWN  : ev->data.key.ch = CACA_KEY_PAGEDOWN;
390                break;
391            case GLUT_KEY_HOME : ev->data.key.ch = CACA_KEY_HOME; break;
392            case GLUT_KEY_END : ev->data.key.ch = CACA_KEY_END; break;
393            case GLUT_KEY_INSERT : ev->data.key.ch = CACA_KEY_INSERT; break;
394
395            default: ev->type = CACA_EVENT_NONE; return 0;
396        }
397
398        ev->type = CACA_EVENT_KEY_PRESS;
399        ev->data.key.utf32 = 0;
400        ev->data.key.utf8[0] = '\0';
401
402        dp->drv.p->special_key = 0;
403        return 1;
404    }
405
406    ev->type = CACA_EVENT_NONE;
407    return 0;
408}
409
410
411static void gl_set_mouse(caca_display_t *dp, int flag)
412{
413    if(flag)
414        glutSetCursor(GLUT_CURSOR_RIGHT_ARROW);
415    else
416        glutSetCursor(GLUT_CURSOR_NONE);
417}
418
419/*
420 * XXX: following functions are local
421 */
422
423static void gl_handle_keyboard(unsigned char key, int x, int y)
424{
425    caca_display_t *dp = gl_d;
426
427    dp->drv.p->key = key;
428}
429
430static void gl_handle_special_key(int key, int x, int y)
431{
432    caca_display_t *dp = gl_d;
433
434    dp->drv.p->special_key = key;
435}
436
437static void gl_handle_reshape(int w, int h)
438{
439    caca_display_t *dp = gl_d;
440
441    if(dp->drv.p->bit) /* Do not handle reshaping at the first time */
442    {
443        dp->drv.p->new_width = w;
444        dp->drv.p->new_height = h;
445
446        dp->resize.w = w / dp->drv.p->font_width;
447        dp->resize.h = (h / dp->drv.p->font_height) + 1;
448
449        dp->resize.resized = 1;
450    }
451    else
452        dp->drv.p->bit = 1;
453}
454
455static void gl_handle_mouse(int button, int state, int x, int y)
456{
457    caca_display_t *dp = gl_d;
458
459    dp->drv.p->mouse_clicked = 1;
460    dp->drv.p->mouse_button = button;
461    dp->drv.p->mouse_state = state;
462    dp->drv.p->mouse_x = x / dp->drv.p->font_width;
463    dp->drv.p->mouse_y = y / dp->drv.p->font_height;
464    dp->mouse.x = dp->drv.p->mouse_x;
465    dp->mouse.y = dp->drv.p->mouse_y;
466    dp->drv.p->mouse_changed = 1;
467}
468
469static void gl_handle_mouse_motion(int x, int y)
470{
471    caca_display_t *dp = gl_d;
472    dp->drv.p->mouse_x = x / dp->drv.p->font_width;
473    dp->drv.p->mouse_y = y / dp->drv.p->font_height;
474    dp->mouse.x = dp->drv.p->mouse_x;
475    dp->mouse.y = dp->drv.p->mouse_y;
476    dp->drv.p->mouse_changed = 1;
477}
478
479#ifdef HAVE_GLUTCLOSEFUNC
480static void gl_handle_close(void)
481{
482    caca_display_t *dp = gl_d;
483    dp->drv.p->close = 1;
484}
485#endif
486
487static void _display(void)
488{
489    caca_display_t *dp = gl_d;
490    gl_display(dp);
491}
492
493static void gl_compute_font(caca_display_t *dp)
494{
495    cucul_canvas_t *cv;
496    uint32_t *image;
497    int i, b, w, h, x, y;
498
499    dp->drv.p->blocks = cucul_get_font_blocks(dp->drv.p->f);
500
501    for(b = 0, i = 0; dp->drv.p->blocks[i + 1]; i += 2)
502        b += dp->drv.p->blocks[i + 1] - dp->drv.p->blocks[i];
503
504    dp->drv.p->txid = malloc(b * sizeof(int));
505    cv = cucul_create_canvas(1, b);
506    cucul_set_color(cv, CUCUL_COLOR_WHITE, CUCUL_COLOR_BLACK);
507
508    for(b = 0, i = 0; dp->drv.p->blocks[i + 1]; i += 2)
509    {
510        int j, n = dp->drv.p->blocks[i + 1] - dp->drv.p->blocks[i];
511
512        for(j = 0; j < n; j++)
513            cucul_putchar(cv, 0, b + j, dp->drv.p->blocks[i] + j);
514
515        b += n;
516    }
517
518    image = malloc(b * dp->drv.p->font_height
519                     * dp->drv.p->font_width * sizeof(uint32_t));
520    cucul_render_canvas(cv, dp->drv.p->f, image, dp->drv.p->font_width,
521                        b * dp->drv.p->font_height, 4 * dp->drv.p->font_width);
522    cucul_free_canvas(cv);
523
524    w = dp->drv.p->font_width <= 16 ? dp->drv.p->font_width : 16;
525    h = dp->drv.p->font_height <= 16 ? dp->drv.p->font_height : 16;
526
527    for(i = 0; i < b; i++)
528    {
529        uint8_t tmp[16 * 4 * 16];
530        uint32_t *glyph = image + (int)(i * dp->drv.p->font_width
531                                          * dp->drv.p->font_height);
532        memset(tmp, 0, 16 * 4 * 16);
533
534        for(y = 0; y < h; y++)
535        {
536            for(x = 0; x < w; x++)
537            {
538                uint32_t offset = x + (15 - y) * 16;
539                uint8_t c = glyph[x + y * (int)dp->drv.p->font_width] >> 8;
540                tmp[offset * 4] = c;
541                tmp[offset * 4 + 1] = c;
542                tmp[offset * 4 + 2] = c;
543                tmp[offset * 4 + 3] = c;
544            }
545        }
546
547        glGenTextures(1, (GLuint*)&dp->drv.p->txid[i]);
548        glBindTexture(GL_TEXTURE_2D, dp->drv.p->txid[i]);
549        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
550        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
551        glTexImage2D(GL_TEXTURE_2D, 0, 4, 16, 16, 0,
552                     GL_RGBA, GL_UNSIGNED_BYTE, tmp);
553    }
554
555    free(image);
556}
557
558/*
559 * Driver initialisation
560 */
561
562int gl_install(caca_display_t *dp)
563{
564#if defined(HAVE_GETENV) && defined(GLUT_XLIB_IMPLEMENTATION)
565    if(!getenv("DISPLAY") || !*(getenv("DISPLAY")))
566        return -1;
567#endif
568
569    dp->drv.driver = CACA_DRIVER_GL;
570
571    dp->drv.init_graphics = gl_init_graphics;
572    dp->drv.end_graphics = gl_end_graphics;
573    dp->drv.set_display_title = gl_set_display_title;
574    dp->drv.get_display_width = gl_get_display_width;
575    dp->drv.get_display_height = gl_get_display_height;
576    dp->drv.display = gl_display;
577    dp->drv.handle_resize = gl_handle_resize;
578    dp->drv.get_event = gl_get_event;
579    dp->drv.set_mouse = gl_set_mouse;
580
581    return 0;
582}
583
584#endif /* USE_GL */
585
Note: See TracBrowser for help on using the repository browser.