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

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