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

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