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

Last change on this file since 973 was 973, checked in by Sam Hocevar, 14 years ago
  • More coding style fixes in the GL driver.
  • Property svn:keywords set to Id
File size: 17.6 KB
RevLine 
[35]1/*
[672]2 *  libcaca       Colour ASCII-Art library
[527]3 *  Copyright (c) 2002-2006 Sam Hocevar <sam@zoy.org>
[268]4 *                All Rights Reserved
[35]5 *
[769]6 *  $Id: driver_gl.c 973 2006-05-20 08:19:13Z sam $
7 *
[268]8 *  This library is free software; you can redistribute it and/or
[522]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.
[35]12 */
[17]13
[769]14/*
[540]15 *  This file contains the libcaca OpenGL input and output driver
[205]16 */
17
[63]18#include "config.h"
[859]19#include "common.h"
[63]20
[539]21#if defined(USE_GL)
22
[697]23#ifdef HAVE_OPENGL_GL_H
24#   include <OpenGL/gl.h>
25#   include <GLUT/glut.h>
[695]26#else
[697]27#   include <GL/gl.h>
28#   include <GL/glut.h>
29#   include <GL/freeglut_ext.h>
[694]30#endif
31
[147]32#include <string.h>
[17]33#include <stdlib.h>
[550]34#include <stdio.h>
[17]35
[185]36#include "caca.h"
37#include "caca_internals.h"
[524]38#include "cucul.h"
39#include "cucul_internals.h"
[17]40
[247]41/*
42 * Global variables
43 */
44
[811]45static caca_display_t *gl_d; /* FIXME: we ought to get rid of this */
[483]46
[281]47/*
48 * Local functions
49 */
[511]50static void gl_handle_keyboard(unsigned char, int, int);
51static void gl_handle_special_key(int, int, int);
52static void gl_handle_reshape(int, int);
53static void gl_handle_mouse(int, int, int, int);
54static void gl_handle_mouse_motion(int, int);
[799]55#ifdef HAVE_GLUTCLOSEFUNC
56static void gl_handle_close(void);
57#endif
[694]58static void _display(void);
[483]59
[550]60struct driver_private
61{
62    int window;
63    unsigned int width, height;
[553]64    unsigned int new_width, new_height;
[550]65    float font_width, font_height;
66    float incx, incy;
[912]67    int id[(128 - 32)];
[973]68    int id_uni[8]; /* Hack, FIXME */
[799]69    unsigned char close;
[553]70    unsigned char bit;
[550]71    unsigned char mouse_changed, mouse_clicked;
72    unsigned int mouse_x, mouse_y;
73    unsigned int mouse_button, mouse_state;
74
75    unsigned char key;
76    int special_key;
77
78    float sw, sh;
79};
80
[811]81static int gl_init_graphics(caca_display_t *dp)
[227]82{
[539]83    char *empty_texture;
84    char const *geometry;
85    char *argv[2] = { "", NULL };
86    unsigned int width = 0, height = 0;
87    int argc = 1;
88    int i;
[348]89
[811]90    dp->drv.p = malloc(sizeof(struct driver_private));
[550]91
[811]92    gl_d = dp;
[227]93
[684]94#if defined(HAVE_GETENV)
[539]95    geometry = getenv("CACA_GEOMETRY");
[613]96    if(geometry && *geometry)
[539]97        sscanf(geometry, "%ux%u", &width, &height);
[684]98#endif
[231]99
[539]100    if(width && height)
[813]101        _cucul_set_canvas_size(dp->cv, width, height);
[227]102
[811]103    dp->drv.p->font_width = 9;
104    dp->drv.p->font_height = 15;
[227]105
[811]106    dp->drv.p->width = dp->cv->width * dp->drv.p->font_width;
107    dp->drv.p->height = dp->cv->height * dp->drv.p->font_height;
[227]108
[799]109#ifdef HAVE_GLUTCLOSEFUNC
[811]110    dp->drv.p->close = 0;
[799]111#endif
[811]112    dp->drv.p->bit = 0;
[227]113
[811]114    dp->drv.p->mouse_changed = dp->drv.p->mouse_clicked = 0;
115    dp->drv.p->mouse_button = dp->drv.p->mouse_state = 0;
[227]116
[811]117    dp->drv.p->key = 0;
118    dp->drv.p->special_key = 0;
[227]119
[811]120    dp->drv.p->sw = 9.0f / 16.0f;
121    dp->drv.p->sh = 15.0f / 16.0f;
[251]122
[539]123    glutInit(&argc, argv);
[261]124
[539]125    glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);
[811]126    glutInitWindowSize(dp->drv.p->width, dp->drv.p->height);
127    dp->drv.p->window = glutCreateWindow("caca for GL");
[274]128
[811]129    gluOrtho2D(0, dp->drv.p->width, dp->drv.p->height, 0);
[263]130
[539]131    glDisable(GL_CULL_FACE);
132    glDisable(GL_DEPTH_TEST);
[251]133
[539]134    glutKeyboardFunc(gl_handle_keyboard);
135    glutSpecialFunc(gl_handle_special_key);
136    glutReshapeFunc(gl_handle_reshape);
[694]137    glutDisplayFunc(_display);
[263]138
[799]139#ifdef HAVE_GLUTCLOSEFUNC
140    glutCloseFunc(gl_handle_close);
141#endif
[694]142
[539]143    glutMouseFunc(gl_handle_mouse);
144    glutMotionFunc(gl_handle_mouse_motion);
145    glutPassiveMotionFunc(gl_handle_mouse_motion);
[300]146
[539]147    glLoadIdentity();
[263]148
[539]149    glMatrixMode(GL_PROJECTION);
150    glPushMatrix();
151    glLoadIdentity();
[811]152    gluOrtho2D(0, dp->drv.p->width, dp->drv.p->height, 0);
[527]153
[539]154    glMatrixMode(GL_MODELVIEW);
[527]155
[539]156    glClear(GL_COLOR_BUFFER_BIT);
[263]157
[539]158    empty_texture = malloc(16 * 16 * 4);
159    if(empty_texture == NULL)
160        return -1;
[300]161
[539]162    memset(empty_texture, 0xff, 16 * 16 * 4);
163    glEnable(GL_TEXTURE_2D);
[263]164
[557]165    for(i = 32; i < 128; i++)
[972]166    {
167        glGenTextures(1, (GLuint*)&dp->drv.p->id[i - 32]);
168        glBindTexture(GL_TEXTURE_2D, dp->drv.p->id[i - 32]);
169        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
170        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
171        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8,
172                     16, 16, 0, GL_RGB, GL_UNSIGNED_BYTE, empty_texture);
173    }
[336]174
[912]175    for(i = 0; i < 8; i++)
[972]176    {
177        glGenTextures(1, (GLuint*)&dp->drv.p->id_uni[i]);
178        glBindTexture(GL_TEXTURE_2D, dp->drv.p->id_uni[i]);
179        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
180        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
181        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8,
182                     16, 16, 0, GL_RGB, GL_UNSIGNED_BYTE, empty_texture);
183    }
[912]184
[557]185    for(i = 32; i < 128; i++)
[972]186    {
187        glDisable(GL_TEXTURE_2D);
188        glClear(GL_COLOR_BUFFER_BIT);
[483]189
[972]190        glColor3f(1, 1, 1);
191        glRasterPos2f(0, 15);
192        glutBitmapCharacter(GLUT_BITMAP_9_BY_15, i);
[483]193
[972]194        glEnable(GL_TEXTURE_2D);
195        glBindTexture(GL_TEXTURE_2D, dp->drv.p->id[i - 32]);
196        glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB,
197                         0, dp->drv.p->height - 16, 16, 16, 0);
[491]198
[698]199#ifdef HAVE_GLUTCHECKLOOP
[972]200        glutCheckLoop();
[698]201#else
[972]202        glutMainLoopEvent();
[698]203#endif
[972]204        glutSwapBuffers();
[912]205
[972]206    }
207
[912]208    /* CP437 hack */
209    for(i = 0; i < 8; i++)
[972]210    {
211        glDisable(GL_TEXTURE_2D);
212        glClear(GL_COLOR_BUFFER_BIT);
213        glColor3f(1, 1, 1);
214        glTranslatef(0.5,0.5,0);
215
[973]216        switch(i)
[918]217        {
[973]218        case 0: /* 0x00002580 */
[972]219            glBegin(GL_QUADS);
220            glVertex2f(0,0); glVertex2f(9,0); glVertex2f(9,7); glVertex2f(0,7);
221            glEnd();
[973]222            break;
223        case 1: /* 0x00002584 */
[972]224            glBegin(GL_QUADS);
225            glVertex2f(0,7); glVertex2f(9,7); glVertex2f(9,15); glVertex2f(0,15);
226            glEnd();
[973]227            break;
228        case 2: /* 0x00002588 */
[972]229            glBegin(GL_QUADS);
230            glVertex2f(0,0); glVertex2f(9,0); glVertex2f(9,15); glVertex2f(0,15);
231            glEnd();
[973]232            break;
233        case 3: /* 0x0000258c */
[972]234            glBegin(GL_QUADS);
235            glVertex2f(0,0); glVertex2f(4,0); glVertex2f(4,15); glVertex2f(0,15);
236            glEnd();
[973]237            break;
238        case 4: /* 0x00002590 */
[972]239            glBegin(GL_QUADS);
240            glVertex2f(4,0); glVertex2f(9,0); glVertex2f(9,15); glVertex2f(4,15);
241            glEnd();
[973]242            break;
243        default: /* 0x0000259[123] */
244            {
245                int a, j, k = i - 5;
246                for(j = dp->drv.p->font_height; j--; )
247                    for(a = dp->drv.p->font_width; a--; )
248                    {
249                        if(((a + 2 * (j & 1)) & 3) > k)
250                            continue;
[265]251
[973]252                        glBegin(GL_POINTS);
253                        glVertex2f(a, j);
254                        glEnd();
255                    }
256            }
[972]257        }
[912]258
[972]259        glEnable(GL_TEXTURE_2D);
260        glBindTexture(GL_TEXTURE_2D, dp->drv.p->id_uni[i]);
261        glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGB,
262                         0, dp->drv.p->height - 16, 16, 16, 0);
[912]263#ifdef HAVE_GLUTCHECKLOOP
[972]264        glutCheckLoop();
[912]265#else
[972]266        glutMainLoopEvent();
[912]267#endif
[972]268        glutSwapBuffers();
269        glutPostRedisplay();
270    }
[912]271
[227]272    return 0;
273}
274
[811]275static int gl_end_graphics(caca_display_t *dp)
[251]276{
[811]277    glutDestroyWindow(dp->drv.p->window);
278    free(dp->drv.p);
[251]279    return 0;
280}
281
[819]282static int gl_set_display_title(caca_display_t *dp, char const *title)
[343]283{
[539]284    glutSetWindowTitle(title);
[343]285    return 0;
286}
287
[819]288static unsigned int gl_get_display_width(caca_display_t *dp)
[352]289{
[811]290    return dp->drv.p->width;
[352]291}
292
[819]293static unsigned int gl_get_display_height(caca_display_t *dp)
[352]294{
[811]295    return dp->drv.p->height;
[352]296}
297
[811]298static void gl_display(caca_display_t *dp)
[227]299{
[539]300    unsigned int x, y, line;
[227]301
[539]302    glClear(GL_COLOR_BUFFER_BIT);
[227]303
[539]304    line = 0;
[811]305    for(y = 0; y < dp->drv.p->height; y += dp->drv.p->font_height)
[972]306    {
307        uint32_t *attr = dp->cv->attr + line * dp->cv->width;
308
309        for(x = 0; x < dp->drv.p->width; x += dp->drv.p->font_width)
[918]310        {
[972]311            uint16_t bg = _cucul_argb32_to_rgb12bg(*attr++);
312            glDisable(GL_TEXTURE_2D);
313            glColor3b(((bg & 0xf00) >> 8) * 8,
314                      ((bg & 0x0f0) >> 4) * 8,
315                      (bg & 0x00f) * 8);
316            glBegin(GL_QUADS);
317            glVertex2f(x, y);
318            glVertex2f(x + dp->drv.p->font_width, y);
319            glVertex2f(x + dp->drv.p->font_width,
320                       y + dp->drv.p->font_height);
321            glVertex2f(x, y + dp->drv.p->font_height);
322            glEnd();
323        }
[261]324
[972]325        line++;
326    }
[918]327
[539]328    /* 2nd pass, avoids changing render state too much */
329    glEnable(GL_BLEND);
330    glEnable(GL_TEXTURE_2D);
331    glBlendFunc(GL_ONE, GL_ONE);
[336]332
[539]333    line = 0;
[811]334    for(y = 0; y < dp->drv.p->height; y += dp->drv.p->font_height)
[972]335    {
336        uint32_t *attr = dp->cv->attr + line * dp->cv->width;
337        uint32_t *chars = dp->cv->chars + line * dp->cv->width;
338
339        for(x = 0; x < dp->drv.p->width; x += dp->drv.p->font_width)
[508]340        {
[972]341            uint32_t cv = *chars++;
[557]342
[972]343            if(cv > 0x00000020 && cv < 0x00000080)
344            {
345                uint16_t fg = _cucul_argb32_to_rgb12fg(*attr);
346                glBindTexture(GL_TEXTURE_2D, dp->drv.p->id[cv - 32]);
347                glColor3b(((fg & 0xf00) >> 8) * 8,
348                          ((fg & 0x0f0) >> 4) * 8,
349                          (fg & 0x00f) * 8);
350                glBegin(GL_QUADS);
351                glTexCoord2f(0, dp->drv.p->sh);
352                glVertex2f(x, y);
353                glTexCoord2f(dp->drv.p->sw, dp->drv.p->sh);
354                glVertex2f(x + dp->drv.p->font_width, y);
355                glTexCoord2f(dp->drv.p->sw, 0);
356                glVertex2f(x + dp->drv.p->font_width,
357                           y + dp->drv.p->font_height);
358                glTexCoord2f(0, 0);
359                glVertex2f(x, y + dp->drv.p->font_height);
360                glEnd();
361            }
362            else if(cv!=' ')
363            {
364                switch(cv)
[918]365                {
[972]366                case 0x00002580: glBindTexture(GL_TEXTURE_2D, dp->drv.p->id_uni[0]); break;
367                case 0x00002584: glBindTexture(GL_TEXTURE_2D, dp->drv.p->id_uni[1]); break;
368                case 0x00002588: glBindTexture(GL_TEXTURE_2D, dp->drv.p->id_uni[2]); break;
369                case 0x0000258c: glBindTexture(GL_TEXTURE_2D, dp->drv.p->id_uni[3]); break;
370                case 0x00002590: glBindTexture(GL_TEXTURE_2D, dp->drv.p->id_uni[4]); break;
371                case 0x00002591: glBindTexture(GL_TEXTURE_2D, dp->drv.p->id_uni[5]); break;
372                case 0x00002592: glBindTexture(GL_TEXTURE_2D, dp->drv.p->id_uni[6]); break;
373                case 0x00002593: glBindTexture(GL_TEXTURE_2D, dp->drv.p->id_uni[7]); break;
374                default:         glBindTexture(GL_TEXTURE_2D, dp->drv.p->id['?' - 32]); break;
375                }
[491]376
[972]377                uint16_t fg = _cucul_argb32_to_rgb12fg(*attr);
378                glColor3b(((fg & 0xf00) >> 8) * 8,
379                          ((fg & 0x0f0) >> 4) * 8,
380                          (fg & 0x00f) * 8);
381                glBegin(GL_QUADS);
382                glTexCoord2f(0, dp->drv.p->sh);
383                glVertex2f(x, y);
384                glTexCoord2f(dp->drv.p->sw, dp->drv.p->sh);
385                glVertex2f(x + dp->drv.p->font_width, y);
386                glTexCoord2f(dp->drv.p->sw, 0);
387                glVertex2f(x + dp->drv.p->font_width,
388                           y + dp->drv.p->font_height);
389                glTexCoord2f(0, 0);
390                glVertex2f(x, y + dp->drv.p->font_height);
391                glEnd();
[912]392
[972]393            }
[912]394
[972]395            attr++;
[508]396        }
[972]397        line++;
398    }
[539]399    glDisable(GL_BLEND);
400    glDisable(GL_TEXTURE_2D);
[336]401
[698]402#ifdef HAVE_GLUTCHECKLOOP
403    glutCheckLoop();
404#else
[539]405    glutMainLoopEvent();
[698]406#endif
[539]407    glutSwapBuffers();
408    glutPostRedisplay();
[227]409}
410
[811]411static void gl_handle_resize(caca_display_t *dp)
[347]412{
[811]413    dp->drv.p->width = dp->drv.p->new_width;
414    dp->drv.p->height = dp->drv.p->new_height;
[349]415
[539]416    glMatrixMode(GL_PROJECTION);
417    glPushMatrix();
418    glLoadIdentity();
[354]419
[811]420    glViewport(0, 0, dp->drv.p->width, dp->drv.p->height);
421    gluOrtho2D(0, dp->drv.p->width, dp->drv.p->height, 0);
[539]422    glMatrixMode(GL_MODELVIEW);
[347]423}
424
[811]425static int gl_get_event(caca_display_t *dp, caca_event_t *ev)
[548]426{
[698]427#ifdef HAVE_GLUTCHECKLOOP
428    glutCheckLoop();
429#else
[548]430    glutMainLoopEvent();
[698]431#endif
[548]432
[799]433#ifdef HAVE_GLUTCLOSEFUNC
[811]434    if(dp->drv.p->close)
[972]435    {
436        dp->drv.p->close = 0;
437        ev->type = CACA_EVENT_QUIT;
438        return 1;
439    }
[799]440#endif
441
[811]442    if(dp->resize.resized)
[972]443    {
444        ev->type = CACA_EVENT_RESIZE;
445        ev->data.resize.w = dp->cv->width;
446        ev->data.resize.h = dp->cv->height;
447        return 1;
448    }
[548]449
[811]450    if(dp->drv.p->mouse_changed)
[972]451    {
452        ev->type = CACA_EVENT_MOUSE_MOTION;
453        ev->data.mouse.x = dp->mouse.x;
454        ev->data.mouse.y = dp->mouse.y;
455        dp->drv.p->mouse_changed = 0;
456
457        if(dp->drv.p->mouse_clicked)
[918]458        {
[972]459            _push_event(dp, ev);
460            ev->type = CACA_EVENT_MOUSE_PRESS;
461            ev->data.mouse.button = dp->drv.p->mouse_button;
462            dp->drv.p->mouse_clicked = 0;
463        }
[681]464
[972]465        return 1;
466    }
[918]467
[811]468    if(dp->drv.p->key != 0)
[972]469    {
470        ev->type = CACA_EVENT_KEY_PRESS;
471        ev->data.key.ch = dp->drv.p->key;
472        ev->data.key.utf32 = (uint32_t)dp->drv.p->key;
473        ev->data.key.utf8[0] = dp->drv.p->key;
474        ev->data.key.utf8[1] = '\0';
475        dp->drv.p->key = 0;
476        return 1;
477    }
[548]478
[811]479    if(dp->drv.p->special_key != 0)
[972]480    {
481        switch(dp->drv.p->special_key)
[548]482        {
[972]483            case GLUT_KEY_F1 : ev->data.key.ch = CACA_KEY_F1; break;
484            case GLUT_KEY_F2 : ev->data.key.ch = CACA_KEY_F2; break;
485            case GLUT_KEY_F3 : ev->data.key.ch = CACA_KEY_F3; break;
486            case GLUT_KEY_F4 : ev->data.key.ch = CACA_KEY_F4; break;
487            case GLUT_KEY_F5 : ev->data.key.ch = CACA_KEY_F5; break;
488            case GLUT_KEY_F6 : ev->data.key.ch = CACA_KEY_F6; break;
489            case GLUT_KEY_F7 : ev->data.key.ch = CACA_KEY_F7; break;
490            case GLUT_KEY_F8 : ev->data.key.ch = CACA_KEY_F8; break;
491            case GLUT_KEY_F9 : ev->data.key.ch = CACA_KEY_F9; break;
492            case GLUT_KEY_F10: ev->data.key.ch = CACA_KEY_F10; break;
493            case GLUT_KEY_F11: ev->data.key.ch = CACA_KEY_F11; break;
494            case GLUT_KEY_F12: ev->data.key.ch = CACA_KEY_F12; break;
495            case GLUT_KEY_LEFT : ev->data.key.ch = CACA_KEY_LEFT; break;
496            case GLUT_KEY_RIGHT: ev->data.key.ch = CACA_KEY_RIGHT; break;
497            case GLUT_KEY_UP   : ev->data.key.ch = CACA_KEY_UP; break;
498            case GLUT_KEY_DOWN : ev->data.key.ch = CACA_KEY_DOWN; break;
499            case GLUT_KEY_PAGE_UP : ev->data.key.ch = CACA_KEY_PAGEUP; break;
500            case GLUT_KEY_PAGE_DOWN  : ev->data.key.ch = CACA_KEY_PAGEDOWN;
501                break;
502            case GLUT_KEY_HOME : ev->data.key.ch = CACA_KEY_HOME; break;
503            case GLUT_KEY_END : ev->data.key.ch = CACA_KEY_END; break;
504            case GLUT_KEY_INSERT : ev->data.key.ch = CACA_KEY_INSERT; break;
[906]505
[972]506            default: ev->type = CACA_EVENT_NONE; return 0;
507        }
[681]508
[972]509        ev->type = CACA_EVENT_KEY_PRESS;
510        ev->data.key.utf32 = 0;
511        ev->data.key.utf8[0] = '\0';
[681]512
[972]513        dp->drv.p->special_key = 0;
514        return 1;
515    }
[681]516
517    ev->type = CACA_EVENT_NONE;
518    return 0;
[548]519}
520
[686]521
[811]522static void gl_set_mouse(caca_display_t *dp, int flag)
[686]523{
[689]524    if(flag)
525        glutSetCursor(GLUT_CURSOR_RIGHT_ARROW);
526    else
527        glutSetCursor(GLUT_CURSOR_NONE);
[686]528}
529
[539]530/*
531 * XXX: following functions are local
532 */
[281]533
[511]534static void gl_handle_keyboard(unsigned char key, int x, int y)
535{
[811]536    caca_display_t *dp = gl_d;
[527]537
[811]538    dp->drv.p->key = key;
[511]539}
540
541static void gl_handle_special_key(int key, int x, int y)
542{
[811]543    caca_display_t *dp = gl_d;
[527]544
[811]545    dp->drv.p->special_key = key;
[511]546}
547
548static void gl_handle_reshape(int w, int h)
549{
[811]550    caca_display_t *dp = gl_d;
[527]551
[811]552    if(dp->drv.p->bit) /* Do not handle reshaping at the first time */
[972]553    {
554        dp->drv.p->new_width = w;
555        dp->drv.p->new_height = h;
[511]556
[972]557        dp->resize.w = w / dp->drv.p->font_width;
558        dp->resize.h = (h / dp->drv.p->font_height) + 1;
[553]559
[972]560        dp->resize.resized = 1;
561    }
[511]562    else
[811]563        dp->drv.p->bit = 1;
[511]564}
565
566static void gl_handle_mouse(int button, int state, int x, int y)
567{
[811]568    caca_display_t *dp = gl_d;
[527]569
[811]570    dp->drv.p->mouse_clicked = 1;
571    dp->drv.p->mouse_button = button;
572    dp->drv.p->mouse_state = state;
573    dp->drv.p->mouse_x = x / dp->drv.p->font_width;
574    dp->drv.p->mouse_y = y / dp->drv.p->font_height;
575    dp->mouse.x = dp->drv.p->mouse_x;
576    dp->mouse.y = dp->drv.p->mouse_y;
577    dp->drv.p->mouse_changed = 1;
[511]578}
579
580static void gl_handle_mouse_motion(int x, int y)
581{
[811]582    caca_display_t *dp = gl_d;
583    dp->drv.p->mouse_x = x / dp->drv.p->font_width;
584    dp->drv.p->mouse_y = y / dp->drv.p->font_height;
585    dp->mouse.x = dp->drv.p->mouse_x;
586    dp->mouse.y = dp->drv.p->mouse_y;
587    dp->drv.p->mouse_changed = 1;
[511]588}
589
[799]590#ifdef HAVE_GLUTCLOSEFUNC
591static void gl_handle_close(void)
592{
[811]593    caca_display_t *dp = gl_d;
594    dp->drv.p->close = 1;
[799]595}
596#endif
[694]597
598static void _display(void)
599{
[811]600    caca_display_t *dp = gl_d;
601    gl_display(dp);
[694]602}
603
604
[539]605/*
606 * Driver initialisation
607 */
608
[811]609int gl_install(caca_display_t *dp)
[539]610{
[684]611#if defined(HAVE_GETENV) && defined(GLUT_XLIB_IMPLEMENTATION)
612    if(!getenv("DISPLAY") || !*(getenv("DISPLAY")))
613        return -1;
614#endif
615
[811]616    dp->drv.driver = CACA_DRIVER_GL;
[539]617
[811]618    dp->drv.init_graphics = gl_init_graphics;
619    dp->drv.end_graphics = gl_end_graphics;
[819]620    dp->drv.set_display_title = gl_set_display_title;
621    dp->drv.get_display_width = gl_get_display_width;
622    dp->drv.get_display_height = gl_get_display_height;
[811]623    dp->drv.display = gl_display;
624    dp->drv.handle_resize = gl_handle_resize;
625    dp->drv.get_event = gl_get_event;
626    dp->drv.set_mouse = gl_set_mouse;
[689]627
[684]628    return 0;
[539]629}
630
631#endif /* USE_GL */
632
Note: See TracBrowser for help on using the repository browser.