source: libcaca/trunk/caca/driver/gl.c @ 3584

Last change on this file since 3584 was 3582, checked in by Sam Hocevar, 11 years ago

Coding style: remove tabs and trailing spaces.

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