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

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