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

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