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

Last change on this file since 1050 was 1050, checked in by Jean-Yves Lamoureux, 14 years ago
  • Updated README, just to say my coding style is just perfect, sam is too pedantic.
  • Property svn:keywords set to Id
File size: 18.1 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 1050 2006-09-17 13:15:12Z jylam $
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    int id[(128 - 32)];
72    int id_uni[8]; /* Hack, FIXME */
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;
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    /* ASCII glyphes textures initialisation */
190    for(i = 32; i < 128; i++)
191    {
192        glGenTextures(1, (GLuint*)&dp->drv.p->id[i - 32]);
193        glBindTexture(GL_TEXTURE_2D, dp->drv.p->id[i - 32]);
194        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
195        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
196        glTexImage2D(GL_TEXTURE_2D, 0, 4,
197                     16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, empty_texture);
198    }
199
200    /* Unicode (CP437) glyphes textures initialisation */
201    for(i = 0; i < 8; i++)
202    {
203        glGenTextures(1, (GLuint*)&dp->drv.p->id_uni[i]);
204        glBindTexture(GL_TEXTURE_2D, dp->drv.p->id_uni[i]);
205        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
206        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
207        glTexImage2D(GL_TEXTURE_2D, 0, 4,
208                     16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, empty_texture);
209    }
210
211    /* Get textures for ASCII glyphs */
212    for(i = 32; i < 128; i++)
213        gl_generate_glyph(i, i-32, dp);
214
215
216    gl_generate_unicode_glyph(0x00002580, 0, dp);
217    gl_generate_unicode_glyph(0x00002584, 1, dp);
218    gl_generate_unicode_glyph(0x00002588, 2, dp);
219    gl_generate_unicode_glyph(0x0000258c, 3, dp);
220    gl_generate_unicode_glyph(0x00002590, 4, dp);
221    gl_generate_unicode_glyph(0x00002591, 5, dp);
222    gl_generate_unicode_glyph(0x00002592, 6, dp);
223    gl_generate_unicode_glyph(0x00002593, 7, dp);
224
225    return 0;
226}
227
228static int gl_end_graphics(caca_display_t *dp)
229{
230    glutDestroyWindow(dp->drv.p->window);
231    free(dp->drv.p);
232    return 0;
233}
234
235static int gl_set_display_title(caca_display_t *dp, char const *title)
236{
237    glutSetWindowTitle(title);
238    return 0;
239}
240
241static unsigned int gl_get_display_width(caca_display_t *dp)
242{
243    return dp->drv.p->width;
244}
245
246static unsigned int gl_get_display_height(caca_display_t *dp)
247{
248    return dp->drv.p->height;
249}
250
251static void gl_display(caca_display_t *dp)
252{
253    unsigned int x, y, line;
254    static int old_texture = 0;
255
256    glClear(GL_COLOR_BUFFER_BIT);
257    glDisable(GL_TEXTURE_2D);
258    glDisable(GL_BLEND);
259    line = 0;
260    for(y = 0; y < dp->drv.p->height; y += dp->drv.p->font_height)
261    {
262        uint32_t *attr = dp->cv->attr + line * dp->cv->width;
263
264        for(x = 0; x < dp->drv.p->width; x += dp->drv.p->font_width)
265        {
266            uint16_t bg = _cucul_argb32_to_rgb12bg(*attr++);
267
268            glColor4b(((bg & 0xf00) >> 8) * 8,
269                      ((bg & 0x0f0) >> 4) * 8,
270                      (bg & 0x00f) * 8,
271                      0xff);
272            glBegin(GL_QUADS);
273            glVertex2f(x, y);
274            glVertex2f(x + dp->drv.p->font_width, y);
275            glVertex2f(x + dp->drv.p->font_width,
276                       y + dp->drv.p->font_height);
277            glVertex2f(x, y + dp->drv.p->font_height);
278            glEnd();
279        }
280
281        line++;
282    }
283
284    /* 2nd pass, avoids changing render state too much */
285    glEnable(GL_TEXTURE_2D);
286    glEnable(GL_BLEND);
287
288    line = 0;
289    for(y = 0; y < dp->drv.p->height; y += dp->drv.p->font_height, line++)
290    {
291        uint32_t *attr = dp->cv->attr + line * dp->cv->width;
292        uint32_t *chars = dp->cv->chars + line * dp->cv->width;
293
294        for(x = 0; x < dp->drv.p->width; x += dp->drv.p->font_width, attr++)
295        {
296            uint32_t cv = *chars++;
297            uint16_t fg;
298
299            if(cv == ' ')
300                continue;
301
302            if(cv > 0x00000020 && cv < 0x00000080)
303            {
304                if(old_texture != dp->drv.p->id[cv - 32])
305                {
306                    glBindTexture(GL_TEXTURE_2D, dp->drv.p->id[cv - 32]);
307                    old_texture = dp->drv.p->id[cv - 32];
308                }
309            }
310            else switch(cv)
311            {
312                case 0x00002580: glBindTexture(GL_TEXTURE_2D, dp->drv.p->id_uni[0]); break;
313                case 0x00002584: glBindTexture(GL_TEXTURE_2D, dp->drv.p->id_uni[1]); break;
314                case 0x00002588: glBindTexture(GL_TEXTURE_2D, dp->drv.p->id_uni[2]); break;
315                case 0x0000258c: glBindTexture(GL_TEXTURE_2D, dp->drv.p->id_uni[3]); break;
316                case 0x00002590: glBindTexture(GL_TEXTURE_2D, dp->drv.p->id_uni[4]); break;
317                case 0x00002591: glBindTexture(GL_TEXTURE_2D, dp->drv.p->id_uni[5]); break;
318                case 0x00002592: glBindTexture(GL_TEXTURE_2D, dp->drv.p->id_uni[6]); break;
319                case 0x00002593: glBindTexture(GL_TEXTURE_2D, dp->drv.p->id_uni[7]); break;
320                default:         glBindTexture(GL_TEXTURE_2D, dp->drv.p->id['?' - 32]); break;
321            }
322
323            fg = _cucul_argb32_to_rgb12fg(*attr);
324            glColor3b(((fg & 0xf00) >> 8) * 8,
325                      ((fg & 0x0f0) >> 4) * 8,
326                      (fg & 0x00f) * 8);
327            glBegin(GL_QUADS);
328            glTexCoord2f(0, dp->drv.p->sh);
329            glVertex2f(x, y);
330            glTexCoord2f(dp->drv.p->sw, dp->drv.p->sh);
331            glVertex2f(x + dp->drv.p->font_width, y);
332            glTexCoord2f(dp->drv.p->sw, 0);
333            glVertex2f(x + dp->drv.p->font_width,
334                       y + dp->drv.p->font_height);
335            glTexCoord2f(0, 0);
336            glVertex2f(x, y + dp->drv.p->font_height);
337            glEnd();
338        }
339    }
340
341#ifdef HAVE_GLUTCHECKLOOP
342    glutCheckLoop();
343#else
344    glutMainLoopEvent();
345#endif
346    glutSwapBuffers();
347    glutPostRedisplay();
348}
349
350static void gl_handle_resize(caca_display_t *dp)
351{
352    dp->drv.p->width = dp->drv.p->new_width;
353    dp->drv.p->height = dp->drv.p->new_height;
354
355    glMatrixMode(GL_PROJECTION);
356    glPushMatrix();
357    glLoadIdentity();
358
359    glViewport(0, 0, dp->drv.p->width, dp->drv.p->height);
360    gluOrtho2D(0, dp->drv.p->width, dp->drv.p->height, 0);
361    glMatrixMode(GL_MODELVIEW);
362}
363
364static int gl_get_event(caca_display_t *dp, caca_event_t *ev)
365{
366#ifdef HAVE_GLUTCHECKLOOP
367    glutCheckLoop();
368#else
369    glutMainLoopEvent();
370#endif
371
372#ifdef HAVE_GLUTCLOSEFUNC
373    if(dp->drv.p->close)
374    {
375        dp->drv.p->close = 0;
376        ev->type = CACA_EVENT_QUIT;
377        return 1;
378    }
379#endif
380
381    if(dp->resize.resized)
382    {
383        ev->type = CACA_EVENT_RESIZE;
384        ev->data.resize.w = dp->cv->width;
385        ev->data.resize.h = dp->cv->height;
386        return 1;
387    }
388
389    if(dp->drv.p->mouse_changed)
390    {
391        ev->type = CACA_EVENT_MOUSE_MOTION;
392        ev->data.mouse.x = dp->mouse.x;
393        ev->data.mouse.y = dp->mouse.y;
394        dp->drv.p->mouse_changed = 0;
395
396        if(dp->drv.p->mouse_clicked)
397        {
398            _push_event(dp, ev);
399            ev->type = CACA_EVENT_MOUSE_PRESS;
400            ev->data.mouse.button = dp->drv.p->mouse_button;
401            dp->drv.p->mouse_clicked = 0;
402        }
403
404        return 1;
405    }
406
407    if(dp->drv.p->key != 0)
408    {
409        ev->type = CACA_EVENT_KEY_PRESS;
410        ev->data.key.ch = dp->drv.p->key;
411        ev->data.key.utf32 = (uint32_t)dp->drv.p->key;
412        ev->data.key.utf8[0] = dp->drv.p->key;
413        ev->data.key.utf8[1] = '\0';
414        dp->drv.p->key = 0;
415        return 1;
416    }
417
418    if(dp->drv.p->special_key != 0)
419    {
420        switch(dp->drv.p->special_key)
421        {
422            case GLUT_KEY_F1 : ev->data.key.ch = CACA_KEY_F1; break;
423            case GLUT_KEY_F2 : ev->data.key.ch = CACA_KEY_F2; break;
424            case GLUT_KEY_F3 : ev->data.key.ch = CACA_KEY_F3; break;
425            case GLUT_KEY_F4 : ev->data.key.ch = CACA_KEY_F4; break;
426            case GLUT_KEY_F5 : ev->data.key.ch = CACA_KEY_F5; break;
427            case GLUT_KEY_F6 : ev->data.key.ch = CACA_KEY_F6; break;
428            case GLUT_KEY_F7 : ev->data.key.ch = CACA_KEY_F7; break;
429            case GLUT_KEY_F8 : ev->data.key.ch = CACA_KEY_F8; break;
430            case GLUT_KEY_F9 : ev->data.key.ch = CACA_KEY_F9; break;
431            case GLUT_KEY_F10: ev->data.key.ch = CACA_KEY_F10; break;
432            case GLUT_KEY_F11: ev->data.key.ch = CACA_KEY_F11; break;
433            case GLUT_KEY_F12: ev->data.key.ch = CACA_KEY_F12; break;
434            case GLUT_KEY_LEFT : ev->data.key.ch = CACA_KEY_LEFT; break;
435            case GLUT_KEY_RIGHT: ev->data.key.ch = CACA_KEY_RIGHT; break;
436            case GLUT_KEY_UP   : ev->data.key.ch = CACA_KEY_UP; break;
437            case GLUT_KEY_DOWN : ev->data.key.ch = CACA_KEY_DOWN; break;
438            case GLUT_KEY_PAGE_UP : ev->data.key.ch = CACA_KEY_PAGEUP; break;
439            case GLUT_KEY_PAGE_DOWN  : ev->data.key.ch = CACA_KEY_PAGEDOWN;
440                break;
441            case GLUT_KEY_HOME : ev->data.key.ch = CACA_KEY_HOME; break;
442            case GLUT_KEY_END : ev->data.key.ch = CACA_KEY_END; break;
443            case GLUT_KEY_INSERT : ev->data.key.ch = CACA_KEY_INSERT; break;
444
445            default: ev->type = CACA_EVENT_NONE; return 0;
446        }
447
448        ev->type = CACA_EVENT_KEY_PRESS;
449        ev->data.key.utf32 = 0;
450        ev->data.key.utf8[0] = '\0';
451
452        dp->drv.p->special_key = 0;
453        return 1;
454    }
455
456    ev->type = CACA_EVENT_NONE;
457    return 0;
458}
459
460
461static void gl_set_mouse(caca_display_t *dp, int flag)
462{
463    if(flag)
464        glutSetCursor(GLUT_CURSOR_RIGHT_ARROW);
465    else
466        glutSetCursor(GLUT_CURSOR_NONE);
467}
468
469/*
470 * XXX: following functions are local
471 */
472
473static void gl_handle_keyboard(unsigned char key, int x, int y)
474{
475    caca_display_t *dp = gl_d;
476
477    dp->drv.p->key = key;
478}
479
480static void gl_handle_special_key(int key, int x, int y)
481{
482    caca_display_t *dp = gl_d;
483
484    dp->drv.p->special_key = key;
485}
486
487static void gl_handle_reshape(int w, int h)
488{
489    caca_display_t *dp = gl_d;
490
491    if(dp->drv.p->bit) /* Do not handle reshaping at the first time */
492    {
493        dp->drv.p->new_width = w;
494        dp->drv.p->new_height = h;
495
496        dp->resize.w = w / dp->drv.p->font_width;
497        dp->resize.h = (h / dp->drv.p->font_height) + 1;
498
499        dp->resize.resized = 1;
500    }
501    else
502        dp->drv.p->bit = 1;
503}
504
505static void gl_handle_mouse(int button, int state, int x, int y)
506{
507    caca_display_t *dp = gl_d;
508
509    dp->drv.p->mouse_clicked = 1;
510    dp->drv.p->mouse_button = button;
511    dp->drv.p->mouse_state = state;
512    dp->drv.p->mouse_x = x / dp->drv.p->font_width;
513    dp->drv.p->mouse_y = y / dp->drv.p->font_height;
514    dp->mouse.x = dp->drv.p->mouse_x;
515    dp->mouse.y = dp->drv.p->mouse_y;
516    dp->drv.p->mouse_changed = 1;
517}
518
519static void gl_handle_mouse_motion(int x, int y)
520{
521    caca_display_t *dp = gl_d;
522    dp->drv.p->mouse_x = x / dp->drv.p->font_width;
523    dp->drv.p->mouse_y = y / dp->drv.p->font_height;
524    dp->mouse.x = dp->drv.p->mouse_x;
525    dp->mouse.y = dp->drv.p->mouse_y;
526    dp->drv.p->mouse_changed = 1;
527}
528
529#ifdef HAVE_GLUTCLOSEFUNC
530static void gl_handle_close(void)
531{
532    caca_display_t *dp = gl_d;
533    dp->drv.p->close = 1;
534}
535#endif
536
537static void _display(void)
538{
539    caca_display_t *dp = gl_d;
540    gl_display(dp);
541}
542
543static void gl_generate_glyph(uint32_t c, uint32_t tid, caca_display_t *dp)
544{
545    int s,d;
546    uint8_t *glyph8 =  calloc(dp->drv.p->font_width*dp->drv.p->font_height, 1);
547    uint8_t *glyph32 = calloc(16*16*4, 1);
548
549    cucul_render_glyph(dp->drv.p->f, c, glyph8, dp->drv.p->font_width);
550
551    /* Convert resulting 8bbp glyph to 32bits, 16x16*/
552    for(s=0;s<(dp->drv.p->font_height<=16?dp->drv.p->font_height:16);s++)
553    {
554        for(d=0;d<dp->drv.p->font_width;d++)
555        {
556            uint32_t offset = d*4+(15-s)*16*4;
557            uint8_t c = glyph8[d+s*(int)dp->drv.p->font_width];
558            glyph32[offset] = c;
559            glyph32[1+offset] = c;
560            glyph32[2+offset] = c;
561            glyph32[3+offset] = c;
562        }
563    }
564
565    glBindTexture(GL_TEXTURE_2D, dp->drv.p->id[tid]);
566    glTexImage2D(GL_TEXTURE_2D,
567                 0, 4,
568                 16,16,
569                 0, GL_RGBA, GL_UNSIGNED_BYTE,
570                 glyph32);
571    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
572    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
573    free(glyph8);
574    free(glyph32);
575}
576
577static void gl_generate_unicode_glyph(uint32_t c, uint32_t tid,
578                                      caca_display_t *dp)
579{
580    int s,d;
581    uint8_t *glyph8 =  calloc(dp->drv.p->font_width*dp->drv.p->font_height, 1);
582    uint8_t *glyph32 = calloc(16*16*4, 1);
583
584    cucul_render_glyph(dp->drv.p->f, c, glyph8, dp->drv.p->font_width);
585
586    /* Convert resulting 8bbp glyph to 32bits, 16x16*/
587    for(s=0;s<(dp->drv.p->font_height<=16?dp->drv.p->font_height:16);s++)
588    {
589        for(d=0;d<(dp->drv.p->font_width<=16?dp->drv.p->font_width:16);d++)
590        {
591            uint32_t offset = d*4+(15-s)*16*4;
592            uint8_t c = glyph8[d+s*(int)dp->drv.p->font_width];
593            glyph32[offset] = c;
594            glyph32[1+offset] = c;
595            glyph32[2+offset] = c;
596            glyph32[3+offset] = c;
597        }
598    }
599
600    glBindTexture(GL_TEXTURE_2D, dp->drv.p->id_uni[tid]);
601    glTexImage2D(GL_TEXTURE_2D,
602                 0, 4,
603                 16,16,
604                 0, GL_RGBA, GL_UNSIGNED_BYTE,
605                 glyph32);
606    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
607    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
608    free(glyph8);
609    free(glyph32);
610}
611
612/*
613 * Driver initialisation
614 */
615
616int gl_install(caca_display_t *dp)
617{
618#if defined(HAVE_GETENV) && defined(GLUT_XLIB_IMPLEMENTATION)
619    if(!getenv("DISPLAY") || !*(getenv("DISPLAY")))
620        return -1;
621#endif
622
623    dp->drv.driver = CACA_DRIVER_GL;
624
625    dp->drv.init_graphics = gl_init_graphics;
626    dp->drv.end_graphics = gl_end_graphics;
627    dp->drv.set_display_title = gl_set_display_title;
628    dp->drv.get_display_width = gl_get_display_width;
629    dp->drv.get_display_height = gl_get_display_height;
630    dp->drv.display = gl_display;
631    dp->drv.handle_resize = gl_handle_resize;
632    dp->drv.get_event = gl_get_event;
633    dp->drv.set_mouse = gl_set_mouse;
634
635    return 0;
636}
637
638#endif /* USE_GL */
639
Note: See TracBrowser for help on using the repository browser.