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

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