From b18191cf306c255fe5eff7762fc8e419e043a621 Mon Sep 17 00:00:00 2001 From: Claudio Ciccani Date: Wed, 31 May 2006 17:02:45 +0000 Subject: [PATCH] Added DirectFB GLUT implementation. --- src/glut/directfb/Makefile | 86 +++++ src/glut/directfb/callback.c | 278 ++++++++++++++++ src/glut/directfb/color.c | 39 +++ src/glut/directfb/cursor.c | 167 ++++++++++ src/glut/directfb/cursors.h | 306 ++++++++++++++++++ src/glut/directfb/events.c | 383 ++++++++++++++++++++++ src/glut/directfb/ext.c | 195 ++++++++++++ src/glut/directfb/font.c | 213 +++++++++++++ src/glut/directfb/font.h | 58 ++++ src/glut/directfb/game.c | 153 +++++++++ src/glut/directfb/globals.c | 63 ++++ src/glut/directfb/init.c | 128 ++++++++ src/glut/directfb/internal.h | 180 +++++++++++ src/glut/directfb/menu.c | 87 +++++ src/glut/directfb/models.c | 599 +++++++++++++++++++++++++++++++++++ src/glut/directfb/overlay.c | 62 ++++ src/glut/directfb/state.c | 258 +++++++++++++++ src/glut/directfb/teapot.c | 212 +++++++++++++ src/glut/directfb/window.c | 576 +++++++++++++++++++++++++++++++++ 19 files changed, 4043 insertions(+) create mode 100644 src/glut/directfb/Makefile create mode 100644 src/glut/directfb/callback.c create mode 100644 src/glut/directfb/color.c create mode 100644 src/glut/directfb/cursor.c create mode 100644 src/glut/directfb/cursors.h create mode 100644 src/glut/directfb/events.c create mode 100644 src/glut/directfb/ext.c create mode 100644 src/glut/directfb/font.c create mode 100644 src/glut/directfb/font.h create mode 100644 src/glut/directfb/game.c create mode 100644 src/glut/directfb/globals.c create mode 100644 src/glut/directfb/init.c create mode 100644 src/glut/directfb/internal.h create mode 100644 src/glut/directfb/menu.c create mode 100644 src/glut/directfb/models.c create mode 100644 src/glut/directfb/overlay.c create mode 100644 src/glut/directfb/state.c create mode 100644 src/glut/directfb/teapot.c create mode 100644 src/glut/directfb/window.c diff --git a/src/glut/directfb/Makefile b/src/glut/directfb/Makefile new file mode 100644 index 00000000000..9e3caaa5c2f --- /dev/null +++ b/src/glut/directfb/Makefile @@ -0,0 +1,86 @@ +# subset glut + +TOP = ../../.. +include $(TOP)/configs/current + +MARK = $(TOP)/src/glut/glx + +GLUT_MAJOR = 3 +GLUT_MINOR = 7 +GLUT_TINY = 1 + +INCLUDES = -I$(TOP)/include -I$(MARK) $(shell pkg-config --cflags directfb) + +GLUT_LIB_DEPS += $(shell pkg-config --libs directfb) + +CORE_SOURCES = \ + callback.c \ + color.c \ + cursor.c \ + ext.c \ + events.c \ + font.c \ + game.c \ + globals.c \ + init.c \ + menu.c \ + models.c \ + overlay.c \ + state.c \ + teapot.c \ + window.c \ + + +MARK_SOURCES = \ + $(MARK)/glut_8x13.c \ + $(MARK)/glut_9x15.c \ + $(MARK)/glut_hel10.c \ + $(MARK)/glut_hel12.c \ + $(MARK)/glut_hel18.c \ + $(MARK)/glut_tr10.c \ + $(MARK)/glut_tr24.c + +SOURCES = $(CORE_SOURCES) $(MARK_SOURCES) + +OBJECTS = $(SOURCES:.c=.o) + + +##### RULES ##### + +.c.o: + $(CC) -c $(INCLUDES) $(CFLAGS) $(DEFINES) $< -o $@ + +.S.o: + $(CC) -c $(INCLUDES) $(CFLAGS) $(DEFINES) $< -o $@ + + +##### TARGETS ##### + +default: depend $(LIB_DIR)/$(GLUT_LIB_NAME) + + +# Make the library +$(LIB_DIR)/$(GLUT_LIB_NAME): depend $(OBJECTS) + $(TOP)/bin/mklib -o $(GLUT_LIB) -linker '$(CC)' \ + -major $(GLUT_MAJOR) -minor $(GLUT_MINOR) -patch $(GLUT_TINY) \ + $(GLUT_LIB_DEPS) -install $(LIB_DIR) \ + $(MKLIB_OPTIONS) $(OBJECTS) + + +# Run 'make -f Makefile.solo dep' to update the dependencies if you change +# what's included by any source file. +depend: $(SOURCES) + touch depend + $(MKDEP) $(MKDEP_OPTIONS) $(INCLUDES) $(SOURCES) > /dev/null + +# Emacs tags +tags: + etags `find . -name \*.[ch]` `find ../include` + + +# Remove .o and backup files +clean: depend + -rm -f depend + -rm -f *.o *~ *.o *~ *.so libglut.so.3.7 + +include depend diff --git a/src/glut/directfb/callback.c b/src/glut/directfb/callback.c new file mode 100644 index 00000000000..38cfccbd4f8 --- /dev/null +++ b/src/glut/directfb/callback.c @@ -0,0 +1,278 @@ +/* + * Copyright (C) 2006 Claudio Ciccani + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +#include +#include +#include +#include + +#include "internal.h" + + +typedef void (GLUTCALLBACK *__GlutTimerCallback) ( int value ); + +typedef struct __GlutTimer_s { + unsigned int interval; + struct timeval expire; + + __GlutTimerCallback func; + int value; + + struct __GlutTimer_s *next; + struct __GlutTimer_s *prev; +} __GlutTimer; + +/*****************************************************************************/ + +static __GlutTimer *g_timers = NULL; + +/*****************************************************************************/ + + +void GLUTAPIENTRY +glutDisplayFunc( void (GLUTCALLBACK *func) (void) ) +{ + display_func = func; +} + + +void GLUTAPIENTRY +glutReshapeFunc( void (GLUTCALLBACK *func) (int width, int height) ) +{ + reshape_func = func; +} + + +void GLUTAPIENTRY +glutKeyboardFunc( void (GLUTCALLBACK *func) (unsigned char key, int x, int y) ) +{ + keyboard_func = func; +} + + +void GLUTAPIENTRY +glutMouseFunc( void (GLUTCALLBACK *func) (int button, int state, int x, int y) ) +{ + mouse_func = func; +} + + +void GLUTAPIENTRY +glutMotionFunc( void (GLUTCALLBACK *func) (int x, int y) ) +{ + motion_func = func; +} + + +void GLUTAPIENTRY +glutPassiveMotionFunc( void (GLUTCALLBACK *func) (int x, int y) ) +{ + passive_motion_func = func; +} + + +void GLUTAPIENTRY +glutEntryFunc( void (GLUTCALLBACK *func) (int state) ) +{ + entry_func = func; +} + + +void GLUTAPIENTRY +glutVisibilityFunc( void (GLUTCALLBACK *func) (int state) ) +{ + visibility_func = func; +} + + +void GLUTAPIENTRY +glutMenuStateFunc( void (GLUTCALLBACK *func) (int state) ) +{ + menu_state_func = func; +} + + +void GLUTAPIENTRY +glutSpecialFunc( void (GLUTCALLBACK *func) (int key, int x, int y) ) +{ + special_func = func; +} + + +void GLUTAPIENTRY +glutSpaceballMotionFunc( void (GLUTCALLBACK *func) (int x, int y, int z) ) +{ +} + + +void GLUTAPIENTRY +glutSpaceballRotateFunc( void (GLUTCALLBACK *func) (int x, int y, int z) ) +{ +} + + +void GLUTAPIENTRY +glutSpaceballButtonFunc( void (GLUTCALLBACK *func) (int button, int state) ) +{ +} + + +void GLUTAPIENTRY +glutButtonBoxFunc( void (GLUTCALLBACK *func) (int button, int state) ) +{ +} + + +void GLUTAPIENTRY +glutDialsFunc( void (GLUTCALLBACK *func) (int dial, int value) ) +{ +} + + +void GLUTAPIENTRY +glutTabletMotionFunc( void (GLUTCALLBACK *func) (int x, int y) ) +{ +} + + +void GLUTAPIENTRY +glutTabletButtonFunc( void (GLUTCALLBACK *func) (int button, int state, int x, int y) ) +{ +} + + +void GLUTAPIENTRY +glutMenuStatusFunc( void (GLUTCALLBACK *func) (int status, int x, int y) ) +{ +} + + +void GLUTAPIENTRY +glutOverlayDisplayFunc( void (GLUTCALLBACK *func) (void) ) +{ +} + + +void GLUTAPIENTRY +glutWindowStatusFunc( void (GLUTCALLBACK *func) (int state) ) +{ +} + + +void GLUTAPIENTRY +glutKeyboardUpFunc( void (GLUTCALLBACK *func) (unsigned char key, int x, int y) ) +{ + keyboard_up_func = func; +} + + +void GLUTAPIENTRY +glutSpecialUpFunc( void (GLUTCALLBACK *func) (int key, int x, int y) ) +{ + special_up_func = func; +} + + +void GLUTAPIENTRY +glutJoystickFunc( void (GLUTCALLBACK *func)(unsigned int buttons, int x, int y, int z), int pollInterval ) +{ + joystick_func = func; + /* FIXME: take care of pollInterval */ +} + + +void GLUTAPIENTRY +glutIdleFunc( void (GLUTCALLBACK *func) (void) ) +{ + idle_func = func; +} + + +void GLUTAPIENTRY +glutTimerFunc( unsigned int msec, void (GLUTCALLBACK *func) (int value), int value ) +{ + __GlutTimer *timer; + struct timeval now; + + if (!func) + return; + + timer = calloc( 1, sizeof(__GlutTimer) ); + if (!timer) + __glutFatalError( "out of memory" ); + + gettimeofday( &now, NULL ); + + timer->interval = msec; + timer->expire.tv_sec = now.tv_sec + (now.tv_usec/1000 + msec) / 1000; + timer->expire.tv_usec = (now.tv_usec + msec*1000) % 1000000; + + timer->func = func; + timer->value = value; + + if (g_timers) { + timer->prev = g_timers->prev; + g_timers->prev->next = timer; + g_timers->prev = timer; + } + else { + g_timers = timer; + g_timers->prev = timer; + } +} + + +void +__glutHandleTimers( void ) +{ + __GlutTimer *cur; + struct timeval now; + + for (cur = g_timers; cur; cur = cur->next ) { + gettimeofday( &now, NULL ); + + if (cur->expire.tv_sec > now.tv_sec || + (cur->expire.tv_sec == now.tv_sec && + cur->expire.tv_usec >= now.tv_usec)) + { + g_idle = GL_FALSE; + + cur->func( cur->value ); + + cur->expire.tv_sec += (cur->expire.tv_usec/1000 + cur->interval) / 1000; + cur->expire.tv_usec = (cur->expire.tv_usec + cur->interval*1000) % 1000000; + } + } +} + + +void +__glutFreeTimers( void ) +{ + __GlutTimer *cur = g_timers; + + while (cur) { + __GlutTimer *next = cur->next; + free( cur ); + cur = next; + } + + g_timers = NULL; +} + diff --git a/src/glut/directfb/color.c b/src/glut/directfb/color.c new file mode 100644 index 00000000000..26c514c6d5f --- /dev/null +++ b/src/glut/directfb/color.c @@ -0,0 +1,39 @@ +/* + * Copyright (C) 2006 Claudio Ciccani + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +#include "internal.h" + + +void GLUTAPIENTRY +glutSetColor( int index, GLfloat red, GLfloat green, GLfloat blue ) +{ +} + + +GLfloat GLUTAPIENTRY +glutGetColor( int index, int component ) +{ + return 0.0; +} + + +void GLUTAPIENTRY +glutCopyColormap( int win ) +{ +} diff --git a/src/glut/directfb/cursor.c b/src/glut/directfb/cursor.c new file mode 100644 index 00000000000..905fa5ee119 --- /dev/null +++ b/src/glut/directfb/cursor.c @@ -0,0 +1,167 @@ +/* + * Copyright (C) 2006 Claudio Ciccani + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +#include +#include +#include + +#include "internal.h" + +#include "cursors.h" + + +void GLUTAPIENTRY +glutSetCursor( int type ) +{ + const unsigned char *cursor; + DFBSurfaceDescription dsc; + IDirectFBSurface *shape; + __u8 *src, *msk; + void *dst; + int pitch; + int x, y; + + if (!g_current || !g_current->window) + return; + + if (g_current->cursor == type) + return; + + switch (type) { + case GLUT_CURSOR_RIGHT_ARROW: + cursor = &cur_right_arrow[0]; + break; + case GLUT_CURSOR_LEFT_ARROW: + cursor = &cur_left_arrow[0]; + break; + case GLUT_CURSOR_INFO: + cursor = &cur_info[0]; + break; + case GLUT_CURSOR_DESTROY: + cursor = &cur_destroy[0]; + break; + case GLUT_CURSOR_HELP: + cursor = &cur_help[0]; + break; + case GLUT_CURSOR_CYCLE: + cursor = &cur_cycle[0]; + break; + case GLUT_CURSOR_SPRAY: + cursor = &cur_spray[0]; + break; + case GLUT_CURSOR_WAIT: + cursor = &cur_wait[0]; + break; + case GLUT_CURSOR_TEXT: + cursor = &cur_text[0]; + break; + case GLUT_CURSOR_CROSSHAIR: + cursor = &cur_crosshair[0]; + break; + case GLUT_CURSOR_UP_DOWN: + cursor = &cur_up_down[0]; + break; + case GLUT_CURSOR_LEFT_RIGHT: + cursor = &cur_left_right[0]; + break; + case GLUT_CURSOR_TOP_SIDE: + cursor = &cur_top_side[0]; + break; + case GLUT_CURSOR_BOTTOM_SIDE: + cursor = &cur_bottom_side[0]; + break; + case GLUT_CURSOR_LEFT_SIDE: + cursor = &cur_left_side[0]; + break; + case GLUT_CURSOR_RIGHT_SIDE: + cursor = &cur_right_side[0]; + break; + case GLUT_CURSOR_TOP_LEFT_CORNER: + cursor = &cur_top_left[0]; + break; + case GLUT_CURSOR_TOP_RIGHT_CORNER: + cursor = &cur_top_right[0]; + break; + case GLUT_CURSOR_BOTTOM_RIGHT_CORNER: + cursor = &cur_bottom_right[0]; + break; + case GLUT_CURSOR_BOTTOM_LEFT_CORNER: + cursor = &cur_bottom_left[0]; + break; + default: + cursor = &cur_right_arrow[0]; + break; + } + + dsc.flags = DSDESC_WIDTH | DSDESC_HEIGHT | DSDESC_PIXELFORMAT; + dsc.width = cursor[0]; + dsc.height = cursor[0]; + dsc.pixelformat = DSPF_ARGB; + + if (dfb->CreateSurface( dfb, &dsc, &shape )) + return; + + if (shape->Lock( shape, DSLF_WRITE, &dst, &pitch )) { + shape->Release( shape ); + return; + } + + src = (__u8*) &cursor[3]; + msk = src + cursor[0]*cursor[0]/8; + + for (y = 0; y < cursor[0]; y++) { + for (x = 0; x < cursor[0]; x++) { + int p = x & 7; + + ((__u32*)dst)[x] = ((src[x>>3] & (0x80 >> p)) ? 0 : 0x00ffffff) | + ((msk[x>>3] & (0x80 >> p)) ? 0xff000000 : 0); + } + + dst += pitch; + src += 2; + msk += 2; + } + + shape->Unlock( shape ); + + g_current->window->SetCursorShape( g_current->window, + shape, cursor[1], cursor[2] ); + g_current->cursor = type; + + shape->Release( shape ); +} + + +void GLUTAPIENTRY +glutWarpPointer( int x, int y ) +{ + if (g_current) { + if (!g_game) { + int wx, wy; + g_current->window->GetPosition( g_current->window, &wx, &wy ); + primary->WarpCursor( primary, wx+x, wy+y ); + } + else { + g_current->cx = x; + g_current->cy = y; + } + } +} + + diff --git a/src/glut/directfb/cursors.h b/src/glut/directfb/cursors.h new file mode 100644 index 00000000000..30ab7c348e6 --- /dev/null +++ b/src/glut/directfb/cursors.h @@ -0,0 +1,306 @@ +#ifndef __GLUT_CURSORS_H__ +#define __GLUT_CURSORS_H__ + + +static const unsigned char cur_right_arrow[] = { + 16, /* size */ + 1, 2, /* hotspot */ + /* data */ + 0x00, 0x00, 0x60, 0x00, 0x78, 0x00, 0x3e, 0x00, + 0x3f, 0x80, 0x1f, 0xe0, 0x1f, 0xf8, 0x0f, 0x80, + 0x0f, 0xc0, 0x06, 0xe0, 0x06, 0x70, 0x02, 0x38, + 0x02, 0x1c, 0x00, 0x0e, 0x00, 0x04, 0x00, 0x00, + /* mask */ + 0xe0, 0x00, 0xf8, 0x00, 0xfe, 0x00, 0x7f, 0x80, + 0x7f, 0xe0, 0x3f, 0xf8, 0x3f, 0xfc, 0x1f, 0xfc, + 0x1f, 0xe0, 0x0f, 0xf0, 0x0f, 0xf8, 0x07, 0x7c, + 0x07, 0x3e, 0x02, 0x1f, 0x00, 0x0e, 0x00, 0x04, +}; + +static const unsigned char cur_left_arrow[] = { + 16, /* size */ + 1, 15, /* hotspot */ + /* data */ + 0x00, 0x00, 0x80, 0x06, 0x00, 0x1e, 0x00, 0x7c, + 0x01, 0xfc, 0x07, 0xf8, 0x1f, 0xf8, 0x01, 0xf0, + 0x01, 0xf0, 0x02, 0x60, 0x04, 0x60, 0x08, 0x40, + 0x10, 0x40, 0x20, 0x00, 0x40, 0x00, 0x00, 0x00, + /* mask */ + 0x00, 0x07, 0x00, 0x1f, 0x00, 0x7f, 0x01, 0xfe, + 0x07, 0xfe, 0x3f, 0xfc, 0x3f, 0xfc, 0x3f, 0xf8, + 0x03, 0xf8, 0x07, 0xf0, 0x0e, 0xf0, 0x1c, 0xe0, + 0x38, 0xe0, 0x70, 0xe0, 0xe0, 0x00, 0xc0, 0x00, +}; + +static const unsigned char cur_info[] = { + 16, /* size */ + 0, 2, /* hotspot */ + /* data */ + 0x30, 0x00, 0x3c, 0x00, 0x0f, 0x00, 0x07, 0x80, + 0x03, 0xc0, 0x07, 0xe0, 0x0f, 0xf0, 0x07, 0xf4, + 0x0f, 0xfe, 0x0f, 0xfa, 0x07, 0xe0, 0x03, 0xe0, + 0x00, 0x52, 0x00, 0x46, 0x00, 0x2c, 0x00, 0x18, + /* mask */ + 0xb8, 0x00, 0x3e, 0x00, 0x1f, 0x80, 0x0f, 0xc0, + 0x07, 0xe0, 0x0f, 0xf0, 0x1f, 0xfc, 0x1f, 0xfe, + 0x1f, 0xfe, 0x1f, 0xfe, 0x0f, 0xfe, 0x07, 0xfe, + 0x03, 0xfe, 0x00, 0xfe, 0x00, 0x7e, 0x00, 0x3c, +}; + +static const unsigned char cur_destroy[] = { + 16, /* size */ + 12, 8, /* hotspot */ + /* data */ + 0x01, 0xe0, 0x03, 0xf0, 0x07, 0xf8, 0x0c, 0xcc, + 0x0c, 0xcc, 0x07, 0xf8, 0x03, 0xf0, 0x01, 0xe0, + 0x21, 0xe1, 0x61, 0xe1, 0x10, 0xc2, 0x0e, 0x1c, + 0x01, 0xe0, 0x47, 0xf8, 0x7c, 0x0f, 0x20, 0x01, + /* mask */ + 0x03, 0xf0, 0x07, 0xf8, 0x0f, 0xfc, 0x1f, 0xfe, + 0x1f, 0xfe, 0x0f, 0xfc, 0x07, 0xf8, 0x83, 0xf1, + 0xe3, 0xf1, 0xf3, 0xf3, 0x39, 0xef, 0x1e, 0x1e, + 0x01, 0xe0, 0xc7, 0xfe, 0xff, 0xff, 0x7c, 0x0f, +}; + +static const unsigned char cur_help[] = { + 16, /* size */ + 7, 8, /* hotspot */ + /* data */ + 0x83, 0xe0, 0x07, 0xf0, 0x0e, 0x38, 0x0c, 0x18, + 0x0c, 0x38, 0x0e, 0x30, 0x07, 0x00, 0x03, 0xc0, + 0x01, 0xc0, 0x01, 0x40, 0x01, 0x40, 0x07, 0x70, + 0x03, 0x60, 0x01, 0xc0, 0x00, 0x80, 0x00, 0x00, + /* mask */ + 0x03, 0xe0, 0x07, 0xf0, 0x0f, 0xf8, 0x1f, 0xfc, + 0x1e, 0x3c, 0x1e, 0x7c, 0x1f, 0x78, 0x0f, 0xf0, + 0x07, 0xe0, 0x03, 0xe0, 0x03, 0xe0, 0x07, 0xf0, + 0x0f, 0xf8, 0x07, 0xf0, 0x03, 0xe0, 0x01, 0xc0, +}; + +static const unsigned char cur_cycle[] = { + 16, /* size */ + 7, 9, /* hotspot */ + /* data */ + 0x00, 0x00, 0x07, 0xe2, 0x0f, 0xf6, 0x18, 0x3e, + 0x10, 0x12, 0x00, 0x32, 0x00, 0x7e, 0x00, 0x00, + 0x00, 0x00, 0x7e, 0x00, 0x4c, 0x00, 0x48, 0x08, + 0x7c, 0x18, 0x6f, 0xf0, 0x47, 0xe0, 0x00, 0x00, + /* mask */ + 0x07, 0xe3, 0x0f, 0xf7, 0x1f, 0xff, 0x3f, 0xff, + 0x38, 0x3f, 0x30, 0xff, 0x00, 0xff, 0x00, 0xff, + 0xff, 0x00, 0xff, 0x00, 0xfe, 0x0c, 0xfc, 0x1c, + 0xff, 0xfc, 0xff, 0xf8, 0xef, 0xf0, 0xc7, 0xe0, +}; + +static const unsigned char cur_spray[] = { + 16, /* size */ + 2, 4, /* hotspot */ + /* data */ + 0x98, 0x00, 0x02, 0x00, 0x18, 0xb0, 0x02, 0x78, + 0x18, 0x58, 0x00, 0xfc, 0x00, 0x84, 0x00, 0x9c, + 0x00, 0x94, 0x00, 0x9c, 0x00, 0x94, 0x00, 0x9c, + 0x00, 0x9c, 0x00, 0x84, 0x00, 0x84, 0x00, 0xfc, + /* mask */ + 0x30, 0x00, 0x34, 0x60, 0x35, 0xf0, 0x35, 0xf0, + 0x35, 0xf8, 0x03, 0xfc, 0x03, 0xfc, 0x03, 0xfc, + 0x03, 0xfc, 0x03, 0xfc, 0x03, 0xfc, 0x03, 0xfc, + 0x03, 0xfc, 0x03, 0xfc, 0x03, 0xfc, 0x03, 0xfc, +}; + +static const unsigned char cur_wait[] = { + 16, /* size */ + 9, 1, /* hotspot */ + /* data */ + 0x07, 0xf8, 0x07, 0xf8, 0x07, 0xf8, 0x0f, 0xfc, + 0x18, 0x86, 0x30, 0x83, 0xe0, 0x81, 0xe1, 0xc1, + 0xe1, 0xc1, 0xe0, 0x21, 0x30, 0x13, 0x18, 0x06, + 0x0f, 0xfc, 0x07, 0xf8, 0x07, 0xf8, 0x07, 0xf8, + /* mask */ + 0x0f, 0xfc, 0x0f, 0xfc, 0x0f, 0xfc, 0x1f, 0xfe, + 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x3f, 0xff, + 0x1f, 0xfe, 0x0f, 0xfc, 0x0f, 0xfc, 0x0f, 0xfc, +}; + +static const unsigned char cur_text[] = { + 16, /* size */ + 8, 8, /* hotspot */ + /* data */ + 0x00, 0x00, 0x0f, 0x70, 0x09, 0xc0, 0x00, 0x80, + 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, + 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, + 0x00, 0x80, 0x01, 0xc0, 0x07, 0x70, 0x00, 0x00, + /* mask */ + 0x0f, 0x78, 0x0f, 0xf8, 0x0f, 0xf8, 0x03, 0xe0, + 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, + 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, + 0x03, 0xe0, 0x0f, 0xf8, 0x0f, 0xf8, 0x0f, 0x78, +}; + +static const unsigned char cur_crosshair[] = { + 16, /* size */ + 7, 9, /* hotspot */ + /* data */ + 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, + 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0xff, 0x7f, + 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, + 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x00, + /* mask */ + 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, + 0x01, 0xc0, 0x01, 0xc0, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, + 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, +}; + +static const unsigned char cur_up_down[] = { + 16, /* size */ + 7, 8, /* hotspot */ + /* data */ + 0x00, 0x80, 0x09, 0xc0, 0x03, 0xe0, 0x07, 0xf0, + 0x01, 0x40, 0x01, 0x40, 0x01, 0x40, 0x01, 0x40, + 0x01, 0x40, 0x01, 0x40, 0x01, 0x40, 0x07, 0xf0, + 0x03, 0xe0, 0x01, 0xc0, 0x00, 0x80, 0x00, 0x00, + /* mask */ + 0x01, 0xc0, 0x03, 0xe0, 0x07, 0xf0, 0x0f, 0xf8, + 0x0f, 0xf8, 0x03, 0xe0, 0x03, 0xe0, 0x03, 0xe0, + 0x03, 0xe0, 0x03, 0xe0, 0x0f, 0xf8, 0x0f, 0xf8, + 0x07, 0xf0, 0x03, 0xe0, 0x01, 0xc0, 0x00, 0x00, +}; + +static const unsigned char cur_left_right[] = { + 16, /* size */ + 7, 8, /* hotspot */ + /* data */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x08, 0x08, 0x18, 0x0c, 0x3f, 0xfe, 0x78, 0x0f, + 0x3f, 0xfe, 0x18, 0x0c, 0x08, 0x08, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + /* mask */ + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8c, 0x18, + 0x1c, 0x1c, 0x3f, 0xfe, 0x7f, 0xff, 0x7f, 0xff, + 0x7f, 0xff, 0x3f, 0xfe, 0x1c, 0x1c, 0x0c, 0x18, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +}; + +static const unsigned char cur_top_side[] = { + 16, /* size */ + 1, 8, /* hotspot */ + /* data */ + 0x00, 0x00, 0xff, 0xfe, 0x3f, 0xfe, 0x00, 0x00, + 0x00, 0x80, 0x01, 0xc0, 0x02, 0xa0, 0x04, 0x90, + 0x08, 0x88, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, + 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x00, + /* mask */ + 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xff, + 0x01, 0xc0, 0x03, 0xe0, 0x07, 0xf0, 0x0f, 0xf8, + 0x1d, 0xdc, 0x19, 0xcc, 0x01, 0xc0, 0x01, 0xc0, + 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, +}; + +static const unsigned char cur_bottom_side[] = { + 16, /* size */ + 14, 8, /* hotspot */ + /* data */ + 0x00, 0x00, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, + 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x08, 0x88, + 0x04, 0x90, 0x02, 0xa0, 0x01, 0xc0, 0x00, 0x80, + 0x00, 0x00, 0x3f, 0xfe, 0x3f, 0xfe, 0x00, 0x00, + /* mask */ + 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, + 0x01, 0xc0, 0x01, 0xc0, 0x19, 0xcc, 0x1d, 0xdc, + 0x0f, 0xf8, 0x07, 0xf0, 0x03, 0xe0, 0x01, 0xc0, + 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xff, 0x7f, 0xff, +}; + +static const unsigned char cur_left_side[] = { + 16, /* size */ + 7, 15, /* hotspot */ + /* data */ + 0x00, 0x00, 0x00, 0x06, 0x00, 0x06, 0x01, 0x06, + 0x00, 0x86, 0x00, 0x46, 0x00, 0x26, 0x7f, 0xf6, + 0x00, 0x26, 0x00, 0x46, 0x00, 0x86, 0x01, 0x06, + 0x00, 0x06, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, + /* mask */ + 0x00, 0x0f, 0x00, 0x0f, 0x03, 0x0f, 0x03, 0x8f, + 0x01, 0xcf, 0x00, 0xef, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x00, 0xef, 0x01, 0xcf, 0x03, 0x8f, + 0x03, 0x0f, 0x00, 0x0f, 0x00, 0x0f, 0x00, 0x00, +}; + +static const unsigned char cur_right_side[] = { + 16, /* size */ + 7, 2, /* hotspot */ + /* data */ + 0x00, 0x00, 0x60, 0x00, 0x60, 0x00, 0x60, 0x80, + 0x61, 0x00, 0x62, 0x00, 0x64, 0x00, 0x6f, 0xfe, + 0x64, 0x00, 0x62, 0x00, 0x61, 0x00, 0x60, 0x80, + 0x60, 0x00, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, + /* mask */ + 0xf0, 0x00, 0xf0, 0x00, 0xf0, 0xc0, 0xf1, 0xc0, + 0xf3, 0x80, 0xf7, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xf7, 0x00, 0xf3, 0x80, 0xf1, 0xc0, + 0xf0, 0xc0, 0xf0, 0x00, 0xf0, 0x00, 0x00, 0x00, +}; + +static const unsigned char cur_top_left[] = { + 16, /* size */ + 1, 15, /* hotspot */ + /* data */ + 0x00, 0x00, 0xff, 0xfe, 0x7f, 0xfe, 0x00, 0x06, + 0x00, 0x06, 0x00, 0x06, 0x1f, 0xc6, 0x00, 0xc6, + 0x01, 0x46, 0x02, 0x46, 0x04, 0x46, 0x08, 0x46, + 0x10, 0x46, 0x00, 0x06, 0x00, 0x06, 0x00, 0x00, + /* mask */ + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x0f, 0x3f, 0xef, 0x3f, 0xef, 0x3f, 0xef, + 0x03, 0xef, 0x07, 0xef, 0x0e, 0xef, 0x1c, 0xef, + 0x38, 0xef, 0x30, 0xef, 0x00, 0x0f, 0x00, 0x0f, +}; + +static const unsigned char cur_top_right[] = { + 16, /* size */ + 1, 2, /* hotspot */ + /* data */ + 0x00, 0x00, 0xff, 0xfe, 0x7f, 0xfe, 0x60, 0x00, + 0x60, 0x00, 0x60, 0x00, 0x63, 0xf8, 0x63, 0x00, + 0x62, 0x80, 0x62, 0x40, 0x62, 0x20, 0x62, 0x10, + 0x62, 0x08, 0x60, 0x00, 0x60, 0x00, 0x00, 0x00, + /* mask */ + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xf0, 0x00, 0xf7, 0xfc, 0xf7, 0xfc, 0xf7, 0xfc, + 0xf7, 0xc0, 0xf7, 0xe0, 0xf7, 0x70, 0xf7, 0x38, + 0xf7, 0x1c, 0xf7, 0x0c, 0xf0, 0x00, 0xf0, 0x00, +}; + +static const unsigned char cur_bottom_right[] = { + 16, /* size */ + 14, 2, /* hotspot */ + /* data */ + 0x00, 0x00, 0x60, 0x00, 0x60, 0x00, 0x62, 0x08, + 0x62, 0x10, 0x62, 0x20, 0x62, 0x40, 0x62, 0x80, + 0x63, 0x00, 0x63, 0xf8, 0x60, 0x00, 0x60, 0x00, + 0x60, 0x00, 0x7f, 0xfe, 0x7f, 0xfe, 0x00, 0x00, + /* mask */ + 0xf0, 0x00, 0xf0, 0x00, 0xf7, 0x0c, 0xf7, 0x1c, + 0xf7, 0x38, 0xf7, 0x70, 0xf7, 0xe0, 0xf7, 0xc0, + 0xf7, 0xfc, 0xf7, 0xfc, 0xf7, 0xfc, 0xf0, 0x00, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, +}; + +static const unsigned char cur_bottom_left[] = { + 16, /* size */ + 14, 15, /* hotspot */ + /* data */ + 0x00, 0x00, 0x00, 0x06, 0x00, 0x06, 0x10, 0x46, + 0x08, 0x46, 0x04, 0x46, 0x02, 0x46, 0x01, 0x46, + 0x00, 0xc6, 0x1f, 0xc6, 0x00, 0x06, 0x00, 0x06, + 0x00, 0x06, 0x7f, 0xfe, 0x7f, 0xfe, 0x00, 0x00, + /* mask */ + 0x00, 0x0f, 0x00, 0x0f, 0x30, 0xef, 0x38, 0xef, + 0x1c, 0xef, 0x0e, 0xef, 0x07, 0xef, 0x03, 0xef, + 0x3f, 0xef, 0x3f, 0xef, 0x3f, 0xef, 0x00, 0x0f, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, +}; + + +#endif /* __GLUT_CURSORS_H__ */ diff --git a/src/glut/directfb/events.c b/src/glut/directfb/events.c new file mode 100644 index 00000000000..17c58483c99 --- /dev/null +++ b/src/glut/directfb/events.c @@ -0,0 +1,383 @@ +/* + * Copyright (C) 2006 Claudio Ciccani + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +#include +#include +#include + +#include "internal.h" + + +int GLUTAPIENTRY +glutGetModifiers( void ) +{ + if (g_current) + return g_current->modifiers; + return 0; +} + + +void GLUTAPIENTRY +glutIgnoreKeyRepeat( int ignore ) +{ +} + + +void GLUTAPIENTRY +glutSetKeyRepeat( int mode ) +{ +} + + +void GLUTAPIENTRY +glutForceJoystickFunc( void ) +{ + if (g_game && joystick && joystick_func) { + joystick_func( g_game->buttons, + g_game->cx, g_game->cy, g_game->cz ); + } +} + + +static int +__glutSpecialKey( DFBInputDeviceKeySymbol key ) +{ + switch (key) { + case DIKS_F1: + return GLUT_KEY_F1; + case DIKS_F2: + return GLUT_KEY_F2; + case DIKS_F3: + return GLUT_KEY_F3; + case DIKS_F4: + return GLUT_KEY_F4; + case DIKS_F5: + return GLUT_KEY_F5; + case DIKS_F6: + return GLUT_KEY_F6; + case DIKS_F7: + return GLUT_KEY_F7; + case DIKS_F8: + return GLUT_KEY_F8; + case DIKS_F9: + return GLUT_KEY_F9; + case DIKS_F10: + return GLUT_KEY_F10; + case DIKS_F11: + return GLUT_KEY_F11; + case DIKS_F12: + return GLUT_KEY_F12; + case DIKS_CURSOR_LEFT: + return GLUT_KEY_LEFT; + case DIKS_CURSOR_UP: + return GLUT_KEY_UP; + case DIKS_CURSOR_RIGHT: + return GLUT_KEY_RIGHT; + case DIKS_CURSOR_DOWN: + return GLUT_KEY_DOWN; + case DIKS_PAGE_UP: + return GLUT_KEY_PAGE_UP; + case DIKS_PAGE_DOWN: + return GLUT_KEY_PAGE_DOWN; + case DIKS_HOME: + return GLUT_KEY_HOME; + case DIKS_END: + return GLUT_KEY_END; + case DIKS_INSERT: + return GLUT_KEY_INSERT; + default: + break; + } + + return 0; +} + + +static int +__glutButton( DFBInputDeviceButtonIdentifier button ) +{ + switch (button) { + case DIBI_LEFT: + return GLUT_LEFT_BUTTON; + case DIBI_MIDDLE: + return GLUT_MIDDLE_BUTTON; + case DIBI_RIGHT: + return GLUT_RIGHT_BUTTON; + default: + break; + } + + return 0; +} + + +static int +__glutModifiers( DFBInputDeviceModifierMask mask ) +{ + return ((mask & DIMM_SHIFT) ? GLUT_ACTIVE_SHIFT : 0) | + ((mask & DIMM_CONTROL) ? GLUT_ACTIVE_CTRL : 0) | + ((mask & DIMM_ALT) ? GLUT_ACTIVE_ALT : 0); +} + + +static void +__glutWindowEvent( DFBWindowEvent *e ) +{ + __GlutWindow *window; + + window = __glutFindWindow( e->window_id ); + if (!window) /* window was destroyed */ + return; + + switch (e->type) { + case DWET_KEYDOWN: + window->modifiers = __glutModifiers( e->modifiers ); + if (DFB_KEY_IS_ASCII( e->key_symbol )) { + if (keyboard_func) { + __glutSetWindow( window ); + keyboard_func( e->key_symbol, e->x, e->y ); + } + } + else { + int key = __glutSpecialKey( e->key_symbol ); + if (key && special_func) { + __glutSetWindow( window ); + special_func( key, e->x, e->y ); + } + } + break; + case DWET_KEYUP: + window->modifiers = __glutModifiers( e->modifiers ); + if (DFB_KEY_IS_ASCII( e->key_symbol )) { + if (keyboard_up_func) { + __glutSetWindow( window ); + keyboard_up_func( e->key_symbol, e->x, e->y ); + } + } + else { + int key = __glutSpecialKey( e->key_symbol ); + if (key && special_up_func) { + __glutSetWindow( window ); + special_up_func( key, e->x, e->y ); + } + } + break; + case DWET_BUTTONDOWN: + if (mouse_func) { + __glutSetWindow( window ); + mouse_func( __glutButton( e->button ), GLUT_DOWN, e->x, e->y ); + } + break; + case DWET_BUTTONUP: + if (mouse_func) { + __glutSetWindow( window ); + mouse_func( __glutButton( e->button ), GLUT_UP, e->x, e->y ); + } + break; + case DWET_MOTION: + if (e->buttons) { + if (motion_func) { + __glutSetWindow( window ); + motion_func( e->cx, e->cy ); + } + } + else { + if (passive_motion_func) { + __glutSetWindow( window ); + passive_motion_func( e->cx, e->cy ); + } + } + break; + case DWET_ENTER: + if (entry_func) { + __glutSetWindow( window ); + entry_func( GLUT_ENTERED ); + } + break; + case DWET_LEAVE: + if (entry_func) { + __glutSetWindow( window ); + entry_func( GLUT_LEFT ); + } + break; + case DWET_SIZE: + window->reshape = GL_TRUE; + window->redisplay = GL_TRUE; + break; + default: + break; + } +} + + +static void +__glutInputEvent( DFBInputEvent *e ) +{ + __glutAssert( g_game != NULL ); + + switch (e->type) { + case DIET_KEYPRESS: + g_game->modifiers = __glutModifiers( e->modifiers ); + if (DFB_KEY_IS_ASCII( e->key_symbol )) { + if (keyboard_func) { + __glutSetWindow( g_game ); + keyboard_func( e->key_symbol, g_game->cx, g_game->cy ); + } + } + else { + int key = __glutSpecialKey( e->key_symbol ); + if (key && special_func) { + __glutSetWindow( g_game ); + special_func( key, g_game->cx, g_game->cy ); + } + } + break; + case DIET_KEYRELEASE: + g_game->modifiers = __glutModifiers( e->modifiers ); + if (DFB_KEY_IS_ASCII( e->key_symbol )) { + if (keyboard_up_func) { + __glutSetWindow( g_game ); + keyboard_up_func( e->key_symbol, g_game->cx, g_game->cy ); + } + } + else { + int key = __glutSpecialKey( e->key_symbol ); + if (key && special_up_func) { + __glutSetWindow( g_game ); + special_up_func( key, g_game->cx, g_game->cy ); + } + } + break; + case DIET_BUTTONPRESS: + if (e->device_id == DIDID_JOYSTICK) { + g_game->buttons = e->buttons; + if (joystick_func) { + __glutSetWindow( g_game ); + joystick_func( g_game->buttons, + g_game->cx, g_game->cy, g_game->cz ); + } + } + else { + if (mouse_func) { + __glutSetWindow( g_game ); + mouse_func( __glutButton( e->button ), + GLUT_DOWN, g_game->cx, g_game->cy ); + } + } + break; + case DIET_BUTTONRELEASE: + if (e->device_id == DIDID_JOYSTICK) { + g_game->buttons = e->buttons; + if (joystick_func) { + __glutSetWindow( g_game ); + joystick_func( g_game->buttons, + g_game->cx, g_game->cy, g_game->cz ); + } + } + else { + if (mouse_func) { + __glutSetWindow( g_game ); + mouse_func( __glutButton( e->button ), + GLUT_UP, g_game->cx, g_game->cy ); + } + } + break; + case DIET_AXISMOTION: + switch (e->axis) { + case DIAI_X: + if (e->flags & DIEF_AXISABS) + g_game->cx = e->axisabs; + else if (e->flags & DIEF_AXISREL) + g_game->cx += e->axisrel; + break; + case DIAI_Y: + if (e->flags & DIEF_AXISABS) + g_game->cy = e->axisabs; + else if (e->flags & DIEF_AXISREL) + g_game->cy += e->axisrel; + break; + case DIAI_Z: + if (e->flags & DIEF_AXISABS) + g_game->cz = e->axisabs; + else if (e->flags & DIEF_AXISREL) + g_game->cz += e->axisrel; + break; + default: + return; + } + if (e->device_id == DIDID_JOYSTICK) { + if (joystick_func) { + __glutSetWindow( g_game ); + joystick_func( g_game->buttons, + g_game->cx, g_game->cy, g_game->cz ); + } + } + else if (e->axis != DIAI_Z) { + if (e->buttons && motion_func) { + __glutSetWindow( g_game ); + motion_func( g_game->cx, g_game->cy ); + } + else if (!e->buttons && passive_motion_func) { + __glutSetWindow( g_game ); + passive_motion_func( g_game->cx, g_game->cy ); + } + } + break; + default: + break; + } +} + + +void GLUTAPIENTRY +glutMainLoop( void ) +{ + __glutAssert( events != NULL ); + + while (GL_TRUE) { + DFBEvent evt; + + g_idle = GL_TRUE; + + __glutHandleTimers(); + __glutHandleWindows(); + + while (events->GetEvent( events, &evt ) == DFB_OK) { + g_idle = GL_FALSE; + + if (evt.clazz == DFEC_WINDOW) + __glutWindowEvent( &evt.window ); + else + __glutInputEvent( &evt.input ); + + __glutHandleTimers(); + } + + if (g_idle) { + if (idle_func) { + idle_func(); + } + else { + __glutSetWindow( NULL ); + usleep( 500 ); + } + } + } +} + diff --git a/src/glut/directfb/ext.c b/src/glut/directfb/ext.c new file mode 100644 index 00000000000..d7338ce5f7b --- /dev/null +++ b/src/glut/directfb/ext.c @@ -0,0 +1,195 @@ +/* + * Copyright (C) 2006 Claudio Ciccani + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +#include +#include +#include + +#include "internal.h" + + +static const struct { + const char *name; + const GLUTproc address; +} glut_functions[] = { + { "glutInit", (const GLUTproc) glutInit }, + { "glutInitDisplayMode", (const GLUTproc) glutInitDisplayMode }, + { "glutInitDisplayString", (const GLUTproc) glutInitDisplayString }, + { "glutInitWindowPosition", (const GLUTproc) glutInitWindowPosition }, + { "glutInitWindowSize", (const GLUTproc) glutInitWindowSize }, + { "glutMainLoop", (const GLUTproc) glutMainLoop }, + { "glutCreateWindow", (const GLUTproc) glutCreateWindow }, + { "glutCreateSubWindow", (const GLUTproc) glutCreateSubWindow }, + { "glutDestroyWindow", (const GLUTproc) glutDestroyWindow }, + { "glutPostRedisplay", (const GLUTproc) glutPostRedisplay }, + { "glutPostWindowRedisplay", (const GLUTproc) glutPostWindowRedisplay }, + { "glutSwapBuffers", (const GLUTproc) glutSwapBuffers }, + { "glutGetWindow", (const GLUTproc) glutGetWindow }, + { "glutSetWindow", (const GLUTproc) glutSetWindow }, + { "glutSetWindowTitle", (const GLUTproc) glutSetWindowTitle }, + { "glutSetIconTitle", (const GLUTproc) glutSetIconTitle }, + { "glutPositionWindow", (const GLUTproc) glutPositionWindow }, + { "glutReshapeWindow", (const GLUTproc) glutReshapeWindow }, + { "glutPopWindow", (const GLUTproc) glutPopWindow }, + { "glutPushWindow", (const GLUTproc) glutPushWindow }, + { "glutIconifyWindow", (const GLUTproc) glutIconifyWindow }, + { "glutShowWindow", (const GLUTproc) glutShowWindow }, + { "glutHideWindow", (const GLUTproc) glutHideWindow }, + { "glutFullScreen", (const GLUTproc) glutFullScreen }, + { "glutSetCursor", (const GLUTproc) glutSetCursor }, + { "glutWarpPointer", (const GLUTproc) glutWarpPointer }, + { "glutEstablishOverlay", (const GLUTproc) glutEstablishOverlay }, + { "glutRemoveOverlay", (const GLUTproc) glutRemoveOverlay }, + { "glutUseLayer", (const GLUTproc) glutUseLayer }, + { "glutPostOverlayRedisplay", (const GLUTproc) glutPostOverlayRedisplay }, + { "glutPostWindowOverlayRedisplay", (const GLUTproc) glutPostWindowOverlayRedisplay }, + { "glutShowOverlay", (const GLUTproc) glutShowOverlay }, + { "glutHideOverlay", (const GLUTproc) glutHideOverlay }, + { "glutCreateMenu", (const GLUTproc) glutCreateMenu }, + { "glutDestroyMenu", (const GLUTproc) glutDestroyMenu }, + { "glutGetMenu", (const GLUTproc) glutGetMenu }, + { "glutSetMenu", (const GLUTproc) glutSetMenu }, + { "glutAddMenuEntry", (const GLUTproc) glutAddMenuEntry }, + { "glutAddSubMenu", (const GLUTproc) glutAddSubMenu }, + { "glutChangeToMenuEntry", (const GLUTproc) glutChangeToMenuEntry }, + { "glutChangeToSubMenu", (const GLUTproc) glutChangeToSubMenu }, + { "glutRemoveMenuItem", (const GLUTproc) glutRemoveMenuItem }, + { "glutAttachMenu", (const GLUTproc) glutAttachMenu }, + { "glutDetachMenu", (const GLUTproc) glutDetachMenu }, + { "glutDisplayFunc", (const GLUTproc) glutDisplayFunc }, + { "glutReshapeFunc", (const GLUTproc) glutReshapeFunc }, + { "glutKeyboardFunc", (const GLUTproc) glutKeyboardFunc }, + { "glutMouseFunc", (const GLUTproc) glutMouseFunc }, + { "glutMotionFunc", (const GLUTproc) glutMotionFunc }, + { "glutPassiveMotionFunc", (const GLUTproc) glutPassiveMotionFunc }, + { "glutEntryFunc", (const GLUTproc) glutEntryFunc }, + { "glutVisibilityFunc", (const GLUTproc) glutVisibilityFunc }, + { "glutIdleFunc", (const GLUTproc) glutIdleFunc }, + { "glutTimerFunc", (const GLUTproc) glutTimerFunc }, + { "glutMenuStateFunc", (const GLUTproc) glutMenuStateFunc }, + { "glutSpecialFunc", (const GLUTproc) glutSpecialFunc }, + { "glutSpaceballMotionFunc", (const GLUTproc) glutSpaceballMotionFunc }, + { "glutSpaceballRotateFunc", (const GLUTproc) glutSpaceballRotateFunc }, + { "glutSpaceballButtonFunc", (const GLUTproc) glutSpaceballButtonFunc }, + { "glutButtonBoxFunc", (const GLUTproc) glutButtonBoxFunc }, + { "glutDialsFunc", (const GLUTproc) glutDialsFunc }, + { "glutTabletMotionFunc", (const GLUTproc) glutTabletMotionFunc }, + { "glutTabletButtonFunc", (const GLUTproc) glutTabletButtonFunc }, + { "glutMenuStatusFunc", (const GLUTproc) glutMenuStatusFunc }, + { "glutOverlayDisplayFunc", (const GLUTproc) glutOverlayDisplayFunc }, + { "glutWindowStatusFunc", (const GLUTproc) glutWindowStatusFunc }, + { "glutKeyboardUpFunc", (const GLUTproc) glutKeyboardUpFunc }, + { "glutSpecialUpFunc", (const GLUTproc) glutSpecialUpFunc }, + { "glutJoystickFunc", (const GLUTproc) glutJoystickFunc }, + { "glutSetColor", (const GLUTproc) glutSetColor }, + { "glutGetColor", (const GLUTproc) glutGetColor }, + { "glutCopyColormap", (const GLUTproc) glutCopyColormap }, + { "glutGet", (const GLUTproc) glutGet }, + { "glutDeviceGet", (const GLUTproc) glutDeviceGet }, + { "glutExtensionSupported", (const GLUTproc) glutExtensionSupported }, + { "glutGetModifiers", (const GLUTproc) glutGetModifiers }, + { "glutLayerGet", (const GLUTproc) glutLayerGet }, + { "glutGetProcAddress", (const GLUTproc) glutGetProcAddress }, + { "glutBitmapCharacter", (const GLUTproc) glutBitmapCharacter }, + { "glutBitmapWidth", (const GLUTproc) glutBitmapWidth }, + { "glutStrokeCharacter", (const GLUTproc) glutStrokeCharacter }, + { "glutStrokeWidth", (const GLUTproc) glutStrokeWidth }, + { "glutBitmapLength", (const GLUTproc) glutBitmapLength }, + { "glutStrokeLength", (const GLUTproc) glutStrokeLength }, + { "glutWireSphere", (const GLUTproc) glutWireSphere }, + { "glutSolidSphere", (const GLUTproc) glutSolidSphere }, + { "glutWireCone", (const GLUTproc) glutWireCone }, + { "glutSolidCone", (const GLUTproc) glutSolidCone }, + { "glutWireCube", (const GLUTproc) glutWireCube }, + { "glutSolidCube", (const GLUTproc) glutSolidCube }, + { "glutWireTorus", (const GLUTproc) glutWireTorus }, + { "glutSolidTorus", (const GLUTproc) glutSolidTorus }, + { "glutWireDodecahedron", (const GLUTproc) glutWireDodecahedron }, + { "glutSolidDodecahedron", (const GLUTproc) glutSolidDodecahedron }, + { "glutWireTeapot", (const GLUTproc) glutWireTeapot }, + { "glutSolidTeapot", (const GLUTproc) glutSolidTeapot }, + { "glutWireOctahedron", (const GLUTproc) glutWireOctahedron }, + { "glutSolidOctahedron", (const GLUTproc) glutSolidOctahedron }, + { "glutWireTetrahedron", (const GLUTproc) glutWireTetrahedron }, + { "glutSolidTetrahedron", (const GLUTproc) glutSolidTetrahedron }, + { "glutWireIcosahedron", (const GLUTproc) glutWireIcosahedron }, + { "glutSolidIcosahedron", (const GLUTproc) glutSolidIcosahedron }, +// { "glutVideoResizeGet", (const GLUTproc) glutVideoResizeGet }, +// { "glutSetupVideoResizing", (const GLUTproc) glutSetupVideoResizing }, +// { "glutStopVideoResizing", (const GLUTproc) glutStopVideoResizing }, +// { "glutVideoResize", (const GLUTproc) glutVideoResize }, +// { "glutVideoPan", (const GLUTproc) glutVideoPan }, + { "glutReportErrors", (const GLUTproc) glutReportErrors }, + { "glutIgnoreKeyRepeat", (const GLUTproc) glutIgnoreKeyRepeat }, + { "glutSetKeyRepeat", (const GLUTproc) glutSetKeyRepeat }, + { "glutForceJoystickFunc", (const GLUTproc) glutForceJoystickFunc }, + { "glutGameModeString", (const GLUTproc) glutGameModeString }, + { "glutEnterGameMode", (const GLUTproc) glutEnterGameMode }, + { "glutLeaveGameMode", (const GLUTproc) glutLeaveGameMode }, + { "glutGameModeGet", (const GLUTproc) glutGameModeGet }, +}; + + +GLUTproc GLUTAPIENTRY +glutGetProcAddress( const char *name ) +{ + int i; + + for (i = 0; i < sizeof(glut_functions)/sizeof(glut_functions[0]); i++) { + if (!strcmp( name, glut_functions[i].name )) + return glut_functions[i].address; + } + + return NULL; +} + + +int GLUTAPIENTRY +glutExtensionSupported( const char *name ) +{ + GLubyte *extensions; + int length; + + if (!name || !*name) + return 0; + + length = strlen( name ); + extensions = (GLubyte*) glGetString( GL_EXTENSIONS ); + + while (extensions && *extensions) { + GLubyte *next; + + next = strchr( extensions, ' ' ); + if (next) { + if (length == (int)(next - extensions)) { + if (!strncmp( extensions, name, length )) + return 1; + } + extensions = next+1; + } + else { + if (!strcmp( extensions, name )) + return 1; + break; + } + } + + return 0; +} + diff --git a/src/glut/directfb/font.c b/src/glut/directfb/font.c new file mode 100644 index 00000000000..0139cddbecd --- /dev/null +++ b/src/glut/directfb/font.c @@ -0,0 +1,213 @@ +/* Copyright (c) Mark J. Kilgard, 1994, 1998. + + This program is freely distributable without licensing fees + and is provided without guarantee or warrantee expressed or + implied. This program is -not- in the public domain. */ + +#include "internal.h" +#include "font.h" + + +#if defined(_WIN32) || defined (GLUT_IMPORT_LIB) + +static inline void* +__glutFont( void *font ) +{ + switch((long)font) { + case (long)GLUT_STROKE_ROMAN: + return &glutStrokeRoman; + case (long)GLUT_STROKE_MONO_ROMAN: + return &glutStrokeMonoRoman; + case (long)GLUT_BITMAP_9_BY_15: + return &glutBitmap9By15; + case (long)GLUT_BITMAP_8_BY_13: + return &glutBitmap8By13; + case (long)GLUT_BITMAP_TIMES_ROMAN_10: + return &glutBitmapTimesRoman10; + case (long)GLUT_BITMAP_TIMES_ROMAN_24: + return &glutBitmapTimesRoman24; + case (long)GLUT_BITMAP_HELVETICA_10: + return &glutBitmapHelvetica10; + case (long)GLUT_BITMAP_HELVETICA_12: + return &glutBitmapHelvetica12; + case (long)GLUT_BITMAP_HELVETICA_18: + return &glutBitmapHelvetica18; + } + + return NULL; +} + +#else + +static inline void* +__glutFont( void *font ) +{ + return font; +} + +#endif + + +void GLUTAPIENTRY +glutBitmapCharacter( GLUTbitmapFont font, int c ) +{ + const BitmapCharRec *ch; + BitmapFontPtr fontinfo; + GLint swapbytes, lsbfirst, rowlength; + GLint skiprows, skippixels, alignment; + + fontinfo = (BitmapFontPtr) __glutFont( font ); + + if (!fontinfo || c < fontinfo->first || + c >= fontinfo->first + fontinfo->num_chars) + return; + + ch = fontinfo->ch[c - fontinfo->first]; + if (ch) { + /* Save current modes. */ + glGetIntegerv(GL_UNPACK_SWAP_BYTES, &swapbytes); + glGetIntegerv(GL_UNPACK_LSB_FIRST, &lsbfirst); + glGetIntegerv(GL_UNPACK_ROW_LENGTH, &rowlength); + glGetIntegerv(GL_UNPACK_SKIP_ROWS, &skiprows); + glGetIntegerv(GL_UNPACK_SKIP_PIXELS, &skippixels); + glGetIntegerv(GL_UNPACK_ALIGNMENT, &alignment); + /* Little endian machines (DEC Alpha for example) could + benefit from setting GL_UNPACK_LSB_FIRST to GL_TRUE + instead of GL_FALSE, but this would require changing the + generated bitmaps too. */ + glPixelStorei(GL_UNPACK_SWAP_BYTES, GL_FALSE); + glPixelStorei(GL_UNPACK_LSB_FIRST, GL_FALSE); + glPixelStorei(GL_UNPACK_ROW_LENGTH, 0); + glPixelStorei(GL_UNPACK_SKIP_ROWS, 0); + glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0); + glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + glBitmap(ch->width, ch->height, ch->xorig, ch->yorig, + ch->advance, 0, ch->bitmap); + /* Restore saved modes. */ + glPixelStorei(GL_UNPACK_SWAP_BYTES, swapbytes); + glPixelStorei(GL_UNPACK_LSB_FIRST, lsbfirst); + glPixelStorei(GL_UNPACK_ROW_LENGTH, rowlength); + glPixelStorei(GL_UNPACK_SKIP_ROWS, skiprows); + glPixelStorei(GL_UNPACK_SKIP_PIXELS, skippixels); + glPixelStorei(GL_UNPACK_ALIGNMENT, alignment); + } +} + + +int GLUTAPIENTRY +glutBitmapWidth( GLUTbitmapFont font, int c ) +{ + BitmapFontPtr fontinfo; + const BitmapCharRec *ch; + + fontinfo = (BitmapFontPtr) __glutFont( font ); + + if (!fontinfo || c < fontinfo->first || + c >= fontinfo->first + fontinfo->num_chars) + return 0; + + ch = fontinfo->ch[c - fontinfo->first]; + if (ch) + return ch->advance; + + return 0; +} + + +int GLUTAPIENTRY +glutBitmapLength( GLUTbitmapFont font, const unsigned char *string ) +{ + int c, length; + BitmapFontPtr fontinfo; + const BitmapCharRec *ch; + + fontinfo = (BitmapFontPtr) __glutFont( font ); + if (!fontinfo) + return 0; + + for (length = 0; *string != '\0'; string++) { + c = *string; + if (c >= fontinfo->first && + c < fontinfo->first + fontinfo->num_chars) { + ch = fontinfo->ch[c - fontinfo->first]; + if (ch) + length += ch->advance; + } + } + + return length; +} + + +void GLUTAPIENTRY +glutStrokeCharacter( GLUTstrokeFont font, int c ) +{ + const StrokeCharRec *ch; + const StrokeRec *stroke; + const CoordRec *coord; + StrokeFontPtr fontinfo; + int i, j; + + fontinfo = (StrokeFontPtr) __glutFont( font ); + + if (!fontinfo || c < 0 || c >= fontinfo->num_chars) + return; + + ch = &(fontinfo->ch[c]); + if (ch) { + for (i = ch->num_strokes, stroke = ch->stroke; + i > 0; i--, stroke++) { + glBegin(GL_LINE_STRIP); + for (j = stroke->num_coords, coord = stroke->coord; + j > 0; j--, coord++) { + glVertex2f(coord->x, coord->y); + } + glEnd(); + } + glTranslatef(ch->right, 0.0, 0.0); + } +} + + +int GLUTAPIENTRY +glutStrokeWidth( GLUTstrokeFont font, int c ) +{ + StrokeFontPtr fontinfo; + const StrokeCharRec *ch; + + fontinfo = (StrokeFontPtr) __glutFont( font ); + + if (!fontinfo || c < 0 || c >= fontinfo->num_chars) + return 0; + + ch = &(fontinfo->ch[c]); + if (ch) + return ch->right; + + return 0; +} + + +int GLUTAPIENTRY +glutStrokeLength( GLUTstrokeFont font, const unsigned char *string ) +{ + int c, length; + StrokeFontPtr fontinfo; + const StrokeCharRec *ch; + + fontinfo = (StrokeFontPtr) __glutFont( font ); + if (!fontinfo) + return 0; + + for (length = 0; *string != '\0'; string++) { + c = *string; + if (c >= 0 && c < fontinfo->num_chars) { + ch = &(fontinfo->ch[c]); + if (ch) + length += ch->right; + } + } + + return length; +} + diff --git a/src/glut/directfb/font.h b/src/glut/directfb/font.h new file mode 100644 index 00000000000..b1e76838a0f --- /dev/null +++ b/src/glut/directfb/font.h @@ -0,0 +1,58 @@ +/* Copyright (c) Mark J. Kilgard, 1994, 1998. */ + +/* This program is freely distributable without licensing fees + and is provided without guarantee or warrantee expressed or + implied. This program is -not- in the public domain. */ + +#ifndef __GLUT_FONT_H__ +#define __GLUT_FONT_H__ + + +typedef struct { + const GLsizei width; + const GLsizei height; + const GLfloat xorig; + const GLfloat yorig; + const GLfloat advance; + const GLubyte *bitmap; +} BitmapCharRec, *BitmapCharPtr; + +typedef struct { + const char *name; + const int num_chars; + const int first; + const BitmapCharRec * const *ch; +} BitmapFontRec, *BitmapFontPtr; + +typedef void *GLUTbitmapFont; + + +typedef struct { + float x; + float y; +} CoordRec, *CoordPtr; + +typedef struct { + int num_coords; + const CoordRec *coord; +} StrokeRec, *StrokePtr; + +typedef struct { + int num_strokes; + const StrokeRec *stroke; + float center; + float right; +} StrokeCharRec, *StrokeCharPtr; + +typedef struct { + const char *name; + int num_chars; + const StrokeCharRec *ch; + float top; + float bottom; +} StrokeFontRec, *StrokeFontPtr; + +typedef void *GLUTstrokeFont; + + +#endif /* __GLUT_FONT_H__ */ diff --git a/src/glut/directfb/game.c b/src/glut/directfb/game.c new file mode 100644 index 00000000000..4c027a68f65 --- /dev/null +++ b/src/glut/directfb/game.c @@ -0,0 +1,153 @@ +/* + * Copyright (C) 2006 Claudio Ciccani + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +#include +#include +#include + +#include "internal.h" + + +/*****************************************************************************/ + +static int g_display_changed = 0; + +/*****************************************************************************/ + + +void GLUTAPIENTRY +glutGameModeString( const char *string ) +{ + int x, y, bpp; + char *tmp; + + if (!string) + return; + + tmp = strchr( string, 'x' ); + if (tmp) { + x = strtol( string, NULL, 10 ); + y = strtol( tmp+1, NULL, 10 ); + + if (x > 0 && y > 0) { + g_width = x; + g_height = y; + } + } + + tmp = strchr( string, ':' ); + if (tmp) { + bpp = strtol( tmp+1, NULL, 10 ); + + if (bpp > 0) + g_bpp = bpp; + } +} + + +int GLUTAPIENTRY +glutEnterGameMode( void ) +{ + DFBDisplayLayerConfig prev, cur; + + glutInit( NULL, NULL ); + + primary->GetConfiguration( primary, &prev ); + primary->SetCooperativeLevel( primary, DLSCL_EXCLUSIVE ); + + if (g_game) + __glutDestroyWindow( g_game ); + + g_game = __glutCreateWindow( GL_TRUE ); + if (!g_game) + return 0; + + __glutSetWindow( g_game ); + g_game->cursor = GLUT_CURSOR_NONE; + + primary->GetConfiguration( primary, &cur ); + g_display_changed = (cur.width != prev.width || + cur.height != prev.height || + cur.pixelformat != prev.pixelformat); + + return g_game->id; +} + + +void GLUTAPIENTRY +glutLeaveGameMode( void ) +{ + if (g_game) + __glutDestroyWindow( g_game ); + + primary->SetCooperativeLevel( primary, DLSCL_ADMINISTRATIVE ); +} + + +int GLUTAPIENTRY +glutGameModeGet( GLenum type ) +{ + switch (type) { + case GLUT_GAME_MODE_ACTIVE: + return (g_game != NULL); + case GLUT_GAME_MODE_POSSIBLE: + if (primary) { + DFBDisplayLayerConfig c; + c.flags = DLCONF_WIDTH | DLCONF_HEIGHT; + c.width = g_width; + c.height = g_height; + /* XXX: bpp */ + if (primary->TestConfiguration( primary, &c, 0 ) == DFB_OK) + return 1; + } + break; + case GLUT_GAME_MODE_WIDTH: + if (g_game) { + int w; + g_game->surface->GetSize( g_game->surface, &w, 0 ); + return w; + } + break; + case GLUT_GAME_MODE_HEIGHT: + if (g_game) { + int h; + g_game->surface->GetSize( g_game->surface, 0, &h ); + return h; + } + break; + case GLUT_GAME_MODE_PIXEL_DEPTH: + if (g_game) { + DFBSurfacePixelFormat f; + g_game->surface->GetPixelFormat( g_game->surface, &f ); + return DFB_COLOR_BITS_PER_PIXEL( f ); + } + break; + case GLUT_GAME_MODE_REFRESH_RATE: + return 60; /* assume 60hz */ + case GLUT_GAME_MODE_DISPLAY_CHANGED: + return g_display_changed; + default: + break; + } + + return 0; +} + + + diff --git a/src/glut/directfb/globals.c b/src/glut/directfb/globals.c new file mode 100644 index 00000000000..2a5291137e2 --- /dev/null +++ b/src/glut/directfb/globals.c @@ -0,0 +1,63 @@ +/* + * Copyright (C) 2006 Claudio Ciccani + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +#include "internal.h" + +IDirectFB *dfb = NULL; +IDirectFBDisplayLayer *primary = NULL; +IDirectFBEventBuffer *events = NULL; +IDirectFBInputDevice *keyboard = NULL; +IDirectFBInputDevice *mouse = NULL; +IDirectFBInputDevice *joystick = NULL; + +GLenum g_display_mode = 0; +GLuint g_width = DEFAULT_WIDTH; +GLuint g_height = DEFAULT_HEIGHT; +GLint g_xpos = 0; +GLint g_ypos = 0; +GLint g_bpp = 0; +GLboolean g_idle = GL_TRUE; +__GlutWindow *g_current = NULL; +__GlutWindow *g_game = NULL; + + +void (GLUTCALLBACK *display_func) (void) = 0; +void (GLUTCALLBACK *reshape_func) (int width, int height) = 0; +void (GLUTCALLBACK *keyboard_func) (unsigned char key, int x, int y) = 0; +void (GLUTCALLBACK *mouse_func) (int button, int state, int x, int y) = 0; +void (GLUTCALLBACK *motion_func) (int x, int y) = 0; +void (GLUTCALLBACK *passive_motion_func) (int x, int y) = 0; +void (GLUTCALLBACK *entry_func) (int state) = 0; +void (GLUTCALLBACK *visibility_func) (int state) = 0; +void (GLUTCALLBACK *idle_func) (void) = 0; +void (GLUTCALLBACK *menu_state_func) (int state) = 0; +void (GLUTCALLBACK *special_func) (int key, int x, int y) = 0; +void (GLUTCALLBACK *spaceball_motion_func) (int x, int y, int z) = 0; +void (GLUTCALLBACK *spaceball_rotate_func) (int x, int y, int z) = 0; +void (GLUTCALLBACK *spaceball_button_func) (int button, int state) = 0; +void (GLUTCALLBACK *button_box_func) (int button, int state) = 0; +void (GLUTCALLBACK *dials_func) (int dial, int value) = 0; +void (GLUTCALLBACK *tablet_motion_func) (int x, int y) = 0; +void (GLUTCALLBACK *tabled_button_func) (int button, int state, int x, int y) = 0; +void (GLUTCALLBACK *menu_status_func) (int status, int x, int y) = 0; +void (GLUTCALLBACK *overlay_display_func) (void) = 0; +void (GLUTCALLBACK *window_status_func) (int state) = 0; +void (GLUTCALLBACK *keyboard_up_func) (unsigned char key, int x, int y) = 0; +void (GLUTCALLBACK *special_up_func) (int key, int x, int y) = 0; +void (GLUTCALLBACK *joystick_func) (unsigned int buttons, int x, int y, int z) = 0; diff --git a/src/glut/directfb/init.c b/src/glut/directfb/init.c new file mode 100644 index 00000000000..ba1a49adf2c --- /dev/null +++ b/src/glut/directfb/init.c @@ -0,0 +1,128 @@ +/* + * Copyright (C) 2006 Claudio Ciccani + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +#include +#include +#include + +#include "internal.h" + + +static void +__glutExit( void ) +{ + __glutFreeTimers(); + __glutDestroyWindows(); + + if (events) { + events->Release( events ); + events = NULL; + } + + if (joystick) { + joystick->Release( joystick ); + joystick = NULL; + } + + if (mouse) { + mouse->Release( mouse ); + mouse = NULL; + } + + if (keyboard) { + keyboard->Release( keyboard ); + keyboard = NULL; + } + + if (primary) { + primary->Release( primary ); + primary = NULL; + } + + if (dfb) { + dfb->Release( dfb ); + dfb = NULL; + } +} + + +void GLUTAPIENTRY +glutInit( int *argcp, char **argv ) +{ + DFBResult ret; + + if (dfb) + return; + + glutGet( GLUT_ELAPSED_TIME ); + + ret = DirectFBInit( argcp, argv ? &argv : NULL ); + if (ret) + DirectFBErrorFatal( "DirectFBInit()", ret ); + + ret = DirectFBCreate( &dfb ); + if (ret) + DirectFBErrorFatal( "DirectFBCreate()", ret ); + + ret = dfb->GetDisplayLayer( dfb, DLID_PRIMARY, &primary ); + if (ret) + DirectFBErrorFatal( "IDirectFB::GetDisplayLayer()", ret ); + + ret = dfb->CreateEventBuffer( dfb, &events ); + if (ret) + DirectFBErrorFatal( "IDirectFB::CreateEventBuffer()", ret ); + + dfb->GetInputDevice( dfb, DIDID_KEYBOARD, &keyboard ); + dfb->GetInputDevice( dfb, DIDID_MOUSE, &mouse ); + dfb->GetInputDevice( dfb, DIDID_JOYSTICK, &joystick ); + + primary->SetCooperativeLevel( primary, DLSCL_ADMINISTRATIVE ); + + atexit( __glutExit ); +} + + +void GLUTAPIENTRY +glutInitDisplayMode( unsigned int mode ) +{ + g_display_mode = mode; +} + + +void GLUTAPIENTRY +glutInitWindowPosition( int x, int y ) +{ + g_xpos = x; + g_ypos = y; +} + + +void GLUTAPIENTRY +glutInitWindowSize( int width, int height ) +{ + g_width = width; + g_height = height; +} + + +void GLUTAPIENTRY +glutInitDisplayString( const char *string ) +{ +} + diff --git a/src/glut/directfb/internal.h b/src/glut/directfb/internal.h new file mode 100644 index 00000000000..787ef89543a --- /dev/null +++ b/src/glut/directfb/internal.h @@ -0,0 +1,180 @@ +/* + * Copyright (C) 2006 Claudio Ciccani + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +#ifndef __GLUT_INTERNAL_H__ +#define __GLUT_INTERNAL_H__ + +#include +#include + +#include +#include + +#include "GL/glut.h" +#include "GL/directfbgl.h" + + +#define VERSION_CODE( M, m, r ) (((M) << 16) | ((m) << 8) | ((r))) + +#define DIRECTFB_VERSION_CODE VERSION_CODE( DIRECTFB_MAJOR_VERSION, \ + DIRECTFB_MINOR_VERSION, \ + DIRECTFB_MICRO_VERSION ) + + +#define DEFAULT_WIDTH 640 +#define DEFAULT_HEIGHT 480 + +/* + * Window request flags + */ +#define WINDOW_REQUEST_POSITION 0x00000001 +#define WINDOW_REQUEST_RESIZE 0x00000002 +#define WINDOW_REQUEST_RESTACK 0x00000004 +#define WINDOW_REQUEST_SHOW 0x00000008 +#define WINDOW_REQUEST_HIDE 0x00000010 +#define WINDOW_REQUEST_DESTROY 0x00000020 + +/* + * GLUT Window implementation + */ +typedef struct __GlutWindow_s { + int id; + DFBWindowID wid; + + IDirectFBWindow *window; /* NULL = fullscreen (game mode) */ + IDirectFBSurface *surface; + IDirectFBGL *gl; + + /* pointer position in fullscreen mode */ + int cx; + int cy; + int cz; + /* pressed modifiers */ + int modifiers; + /* pressed buttons */ + int buttons; + /* current cursor shape */ + int cursor; + + struct { + int flags; + int x; + int y; + int w; + int h; + int z; + } req; + + GLboolean visible; + GLboolean redisplay; + GLboolean reshape; + GLboolean visibility; + + struct __GlutWindow_s *next; + struct __GlutWindow_s *prev; +} __GlutWindow; + + +/* Global Vars */ +extern IDirectFB *dfb; +extern IDirectFBDisplayLayer *primary; +extern IDirectFBEventBuffer *events; +extern IDirectFBInputDevice *keyboard; +extern IDirectFBInputDevice *mouse; +extern IDirectFBInputDevice *joystick; + +extern GLenum g_display_mode; +extern GLuint g_width; +extern GLuint g_height; +extern GLint g_xpos; +extern GLint g_ypos; +extern GLint g_bpp; +extern GLboolean g_idle; +extern __GlutWindow *g_current; +extern __GlutWindow *g_game; + + +/* Global Funcs */ +/* window.c */ +extern __GlutWindow* __glutCreateWindow( GLboolean fullscreen ); +extern __GlutWindow* __glutFindWindow( DFBWindowID id ); +extern void __glutSetWindow( __GlutWindow *window ); +extern void __glutHandleWindows( void ); +extern void __glutDestroyWindow( __GlutWindow *window ); +extern void __glutDestroyWindows( void ); +/* callback.c */ +extern void __glutHandleTimers( void ); +extern void __glutFreeTimers( void ); + + +/* Global Callbacks */ +extern void (GLUTCALLBACK *display_func) (void); +extern void (GLUTCALLBACK *reshape_func) (int width, int height); +extern void (GLUTCALLBACK *keyboard_func) (unsigned char key, int x, int y); +extern void (GLUTCALLBACK *mouse_func) (int button, int state, int x, int y); +extern void (GLUTCALLBACK *motion_func) (int x, int y); +extern void (GLUTCALLBACK *passive_motion_func) (int x, int y); +extern void (GLUTCALLBACK *entry_func) (int state); +extern void (GLUTCALLBACK *visibility_func) (int state); +extern void (GLUTCALLBACK *idle_func) (void); +extern void (GLUTCALLBACK *menu_state_func) (int state); +extern void (GLUTCALLBACK *special_func) (int key, int x, int y); +extern void (GLUTCALLBACK *spaceball_motion_func) (int x, int y, int z); +extern void (GLUTCALLBACK *spaceball_rotate_func) (int x, int y, int z); +extern void (GLUTCALLBACK *spaceball_button_func) (int button, int state); +extern void (GLUTCALLBACK *button_box_func) (int button, int state); +extern void (GLUTCALLBACK *dials_func) (int dial, int value); +extern void (GLUTCALLBACK *tablet_motion_func) (int x, int y); +extern void (GLUTCALLBACK *tabled_button_func) (int button, int state, int x, int y); +extern void (GLUTCALLBACK *menu_status_func) (int status, int x, int y); +extern void (GLUTCALLBACK *overlay_display_func) (void); +extern void (GLUTCALLBACK *window_status_func) (int state); +extern void (GLUTCALLBACK *keyboard_up_func) (unsigned char key, int x, int y); +extern void (GLUTCALLBACK *special_up_func) (int key, int x, int y); +extern void (GLUTCALLBACK *joystick_func) (unsigned int buttons, int x, int y, int z); + + +#ifdef DEBUG +# define __glutAssert( exp ) {\ + if (!(exp)) {\ + fprintf( stderr, "(!!) *** Assertion [%s] failed in %s() ***\n",\ + #exp, __FUNCTION__ ); + fflush( stderr );\ + exit( -1 );\ + }\ + } +#else +# define __glutAssert( exp ) +#endif + +#define __glutWarning( format, ... ) {\ + fprintf( stderr, "(!) GLUT: " format "!\n", ## __VA_ARGS__ );\ + fflush( stderr );\ +} + +#define __glutFatalError( format, ... ) {\ + fprintf( stderr, "(!) GLUT: " format "!\n", ## __VA_ARGS__ );\ + fprintf( stderr, "\t-> from %s() at line %d\n", __FUNCTION__, __LINE__ );\ + fflush( stderr );\ + exit( -1 );\ +} + + +#endif /* __GLUT_INTERNAL_H__ */ + diff --git a/src/glut/directfb/menu.c b/src/glut/directfb/menu.c new file mode 100644 index 00000000000..400e966bbbe --- /dev/null +++ b/src/glut/directfb/menu.c @@ -0,0 +1,87 @@ +/* + * Copyright (C) 2006 Claudio Ciccani + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +#include "internal.h" + + +int GLUTAPIENTRY +glutCreateMenu( void (GLUTCALLBACK *func) (int) ) +{ + return 0; +} + +void GLUTAPIENTRY +glutDestroyMenu( int menu ) +{ +} + + +int GLUTAPIENTRY +glutGetMenu( void ) +{ + return 0; +} + + +void GLUTAPIENTRY +glutSetMenu( int menu ) +{ +} + + +void GLUTAPIENTRY +glutAddMenuEntry( const char *label, int value ) +{ +} + + +void GLUTAPIENTRY +glutAddSubMenu( const char *label, int submenu ) +{ +} + + +void GLUTAPIENTRY +glutChangeToMenuEntry( int item, const char *label, int value ) +{ +} + + +void GLUTAPIENTRY +glutChangeToSubMenu( int item, const char *label, int submenu ) +{ +} + + +void GLUTAPIENTRY +glutRemoveMenuItem( int item ) +{ +} + + +void GLUTAPIENTRY +glutAttachMenu( int button ) +{ +} + + +void GLUTAPIENTRY +glutDetachMenu( int button ) +{ +} diff --git a/src/glut/directfb/models.c b/src/glut/directfb/models.c new file mode 100644 index 00000000000..d96a8f50776 --- /dev/null +++ b/src/glut/directfb/models.c @@ -0,0 +1,599 @@ + +/* Copyright (c) Mark J. Kilgard, 1994, 1997. */ + +/** +(c) Copyright 1993, Silicon Graphics, Inc. + +ALL RIGHTS RESERVED + +Permission to use, copy, modify, and distribute this software +for any purpose and without fee is hereby granted, provided +that the above copyright notice appear in all copies and that +both the copyright notice and this permission notice appear in +supporting documentation, and that the name of Silicon +Graphics, Inc. not be used in advertising or publicity +pertaining to distribution of the software without specific, +written prior permission. + +THE MATERIAL EMBODIED ON THIS SOFTWARE IS PROVIDED TO YOU +"AS-IS" AND WITHOUT WARRANTY OF ANY KIND, EXPRESS, IMPLIED OR +OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF +MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. IN NO +EVENT SHALL SILICON GRAPHICS, INC. BE LIABLE TO YOU OR ANYONE +ELSE FOR ANY DIRECT, SPECIAL, INCIDENTAL, INDIRECT OR +CONSEQUENTIAL DAMAGES OF ANY KIND, OR ANY DAMAGES WHATSOEVER, +INCLUDING WITHOUT LIMITATION, LOSS OF PROFIT, LOSS OF USE, +SAVINGS OR REVENUE, OR THE CLAIMS OF THIRD PARTIES, WHETHER OR +NOT SILICON GRAPHICS, INC. HAS BEEN ADVISED OF THE POSSIBILITY +OF SUCH LOSS, HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, +ARISING OUT OF OR IN CONNECTION WITH THE POSSESSION, USE OR +PERFORMANCE OF THIS SOFTWARE. + +US Government Users Restricted Rights + +Use, duplication, or disclosure by the Government is subject to +restrictions set forth in FAR 52.227.19(c)(2) or subparagraph +(c)(1)(ii) of the Rights in Technical Data and Computer +Software clause at DFARS 252.227-7013 and/or in similar or +successor clauses in the FAR or the DOD or NASA FAR +Supplement. Unpublished-- rights reserved under the copyright +laws of the United States. Contractor/manufacturer is Silicon +Graphics, Inc., 2011 N. Shoreline Blvd., Mountain View, CA +94039-7311. + +OpenGL(TM) is a trademark of Silicon Graphics, Inc. +*/ + +#include +#include +#include + +#include "internal.h" + +/* Some files do not define M_PI... */ +#ifndef M_PI +#define M_PI 3.14159265358979323846 +#endif + +static GLUquadricObj *quadObj; + +#define QUAD_OBJ_INIT() { if(!quadObj) initQuadObj(); } + +static void +initQuadObj(void) +{ + quadObj = gluNewQuadric(); + if (!quadObj) + __glutFatalError("out of memory"); +} + +/* CENTRY */ +void GLUTAPIENTRY +glutWireSphere(GLdouble radius, GLint slices, GLint stacks) +{ + QUAD_OBJ_INIT(); + gluQuadricDrawStyle(quadObj, GLU_LINE); + gluQuadricNormals(quadObj, GLU_SMOOTH); + /* If we ever changed/used the texture or orientation state + of quadObj, we'd need to change it to the defaults here + with gluQuadricTexture and/or gluQuadricOrientation. */ + gluSphere(quadObj, radius, slices, stacks); +} + +void GLUTAPIENTRY +glutSolidSphere(GLdouble radius, GLint slices, GLint stacks) +{ + QUAD_OBJ_INIT(); + gluQuadricDrawStyle(quadObj, GLU_FILL); + gluQuadricNormals(quadObj, GLU_SMOOTH); + /* If we ever changed/used the texture or orientation state + of quadObj, we'd need to change it to the defaults here + with gluQuadricTexture and/or gluQuadricOrientation. */ + gluSphere(quadObj, radius, slices, stacks); +} + +void GLUTAPIENTRY +glutWireCone(GLdouble base, GLdouble height, + GLint slices, GLint stacks) +{ + QUAD_OBJ_INIT(); + gluQuadricDrawStyle(quadObj, GLU_LINE); + gluQuadricNormals(quadObj, GLU_SMOOTH); + /* If we ever changed/used the texture or orientation state + of quadObj, we'd need to change it to the defaults here + with gluQuadricTexture and/or gluQuadricOrientation. */ + gluCylinder(quadObj, base, 0.0, height, slices, stacks); +} + +void GLUTAPIENTRY +glutSolidCone(GLdouble base, GLdouble height, + GLint slices, GLint stacks) +{ + QUAD_OBJ_INIT(); + gluQuadricDrawStyle(quadObj, GLU_FILL); + gluQuadricNormals(quadObj, GLU_SMOOTH); + /* If we ever changed/used the texture or orientation state + of quadObj, we'd need to change it to the defaults here + with gluQuadricTexture and/or gluQuadricOrientation. */ + gluCylinder(quadObj, base, 0.0, height, slices, stacks); +} + +/* ENDCENTRY */ + +static void +drawBox(GLfloat size, GLenum type) +{ + static GLfloat n[6][3] = + { + {-1.0, 0.0, 0.0}, + {0.0, 1.0, 0.0}, + {1.0, 0.0, 0.0}, + {0.0, -1.0, 0.0}, + {0.0, 0.0, 1.0}, + {0.0, 0.0, -1.0} + }; + static GLint faces[6][4] = + { + {0, 1, 2, 3}, + {3, 2, 6, 7}, + {7, 6, 5, 4}, + {4, 5, 1, 0}, + {5, 6, 2, 1}, + {7, 4, 0, 3} + }; + GLfloat v[8][3]; + GLint i; + + v[0][0] = v[1][0] = v[2][0] = v[3][0] = -size / 2; + v[4][0] = v[5][0] = v[6][0] = v[7][0] = size / 2; + v[0][1] = v[1][1] = v[4][1] = v[5][1] = -size / 2; + v[2][1] = v[3][1] = v[6][1] = v[7][1] = size / 2; + v[0][2] = v[3][2] = v[4][2] = v[7][2] = -size / 2; + v[1][2] = v[2][2] = v[5][2] = v[6][2] = size / 2; + + for (i = 5; i >= 0; i--) { + glBegin(type); +/* glNormal3fv(&n[i][0]); */ + glVertex3fv(&v[faces[i][0]][0]); + glVertex3fv(&v[faces[i][1]][0]); + glVertex3fv(&v[faces[i][2]][0]); + glVertex3fv(&v[faces[i][3]][0]); + glEnd(); + } +} + +/* CENTRY */ +void GLUTAPIENTRY +glutWireCube(GLdouble size) +{ + drawBox(size, GL_LINE_LOOP); +} + +void GLUTAPIENTRY +glutSolidCube(GLdouble size) +{ + drawBox(size, GL_QUADS); +} + +/* ENDCENTRY */ + +static void +doughnut(GLfloat r, GLfloat R, GLint nsides, GLint rings) +{ + int i, j; + GLfloat theta, phi, theta1; + GLfloat cosTheta, sinTheta; + GLfloat cosTheta1, sinTheta1; + GLfloat ringDelta, sideDelta; + + ringDelta = 2.0 * M_PI / rings; + sideDelta = 2.0 * M_PI / nsides; + + theta = 0.0; + cosTheta = 1.0; + sinTheta = 0.0; + for (i = rings - 1; i >= 0; i--) { + theta1 = theta + ringDelta; + cosTheta1 = cos(theta1); + sinTheta1 = sin(theta1); + glBegin(GL_QUAD_STRIP); + phi = 0.0; + for (j = nsides; j >= 0; j--) { + GLfloat cosPhi, sinPhi, dist; + + phi += sideDelta; + cosPhi = cos(phi); + sinPhi = sin(phi); + dist = R + r * cosPhi; + +/* glNormal3f(cosTheta1 * cosPhi, -sinTheta1 * cosPhi, sinPhi); */ + glVertex3f(cosTheta1 * dist, -sinTheta1 * dist, r * sinPhi); +/* glNormal3f(cosTheta * cosPhi, -sinTheta * cosPhi, sinPhi); */ + glVertex3f(cosTheta * dist, -sinTheta * dist, r * sinPhi); + } + glEnd(); + theta = theta1; + cosTheta = cosTheta1; + sinTheta = sinTheta1; + } +} + +/* CENTRY */ +void GLUTAPIENTRY +glutWireTorus(GLdouble innerRadius, GLdouble outerRadius, + GLint nsides, GLint rings) +{ +/* glPushAttrib(GL_POLYGON_BIT); */ +/* glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); */ + doughnut(innerRadius, outerRadius, nsides, rings); +/* glPopAttrib(); */ +} + +void GLUTAPIENTRY +glutSolidTorus(GLdouble innerRadius, GLdouble outerRadius, + GLint nsides, GLint rings) +{ + doughnut(innerRadius, outerRadius, nsides, rings); +} + +/* ENDCENTRY */ + +static GLfloat dodec[20][3]; + +static void +initDodecahedron(void) +{ + GLfloat alpha, beta; + + alpha = sqrt(2.0 / (3.0 + sqrt(5.0))); + beta = 1.0 + sqrt(6.0 / (3.0 + sqrt(5.0)) - + 2.0 + 2.0 * sqrt(2.0 / (3.0 + sqrt(5.0)))); + /* *INDENT-OFF* */ + dodec[0][0] = -alpha; dodec[0][1] = 0; dodec[0][2] = beta; + dodec[1][0] = alpha; dodec[1][1] = 0; dodec[1][2] = beta; + dodec[2][0] = -1; dodec[2][1] = -1; dodec[2][2] = -1; + dodec[3][0] = -1; dodec[3][1] = -1; dodec[3][2] = 1; + dodec[4][0] = -1; dodec[4][1] = 1; dodec[4][2] = -1; + dodec[5][0] = -1; dodec[5][1] = 1; dodec[5][2] = 1; + dodec[6][0] = 1; dodec[6][1] = -1; dodec[6][2] = -1; + dodec[7][0] = 1; dodec[7][1] = -1; dodec[7][2] = 1; + dodec[8][0] = 1; dodec[8][1] = 1; dodec[8][2] = -1; + dodec[9][0] = 1; dodec[9][1] = 1; dodec[9][2] = 1; + dodec[10][0] = beta; dodec[10][1] = alpha; dodec[10][2] = 0; + dodec[11][0] = beta; dodec[11][1] = -alpha; dodec[11][2] = 0; + dodec[12][0] = -beta; dodec[12][1] = alpha; dodec[12][2] = 0; + dodec[13][0] = -beta; dodec[13][1] = -alpha; dodec[13][2] = 0; + dodec[14][0] = -alpha; dodec[14][1] = 0; dodec[14][2] = -beta; + dodec[15][0] = alpha; dodec[15][1] = 0; dodec[15][2] = -beta; + dodec[16][0] = 0; dodec[16][1] = beta; dodec[16][2] = alpha; + dodec[17][0] = 0; dodec[17][1] = beta; dodec[17][2] = -alpha; + dodec[18][0] = 0; dodec[18][1] = -beta; dodec[18][2] = alpha; + dodec[19][0] = 0; dodec[19][1] = -beta; dodec[19][2] = -alpha; + /* *INDENT-ON* */ + +} + +#define DIFF3(_a,_b,_c) { \ + (_c)[0] = (_a)[0] - (_b)[0]; \ + (_c)[1] = (_a)[1] - (_b)[1]; \ + (_c)[2] = (_a)[2] - (_b)[2]; \ +} + +static void +crossprod(GLfloat v1[3], GLfloat v2[3], GLfloat prod[3]) +{ + GLfloat p[3]; /* in case prod == v1 or v2 */ + + p[0] = v1[1] * v2[2] - v2[1] * v1[2]; + p[1] = v1[2] * v2[0] - v2[2] * v1[0]; + p[2] = v1[0] * v2[1] - v2[0] * v1[1]; + prod[0] = p[0]; + prod[1] = p[1]; + prod[2] = p[2]; +} + +static void +normalize(GLfloat v[3]) +{ + GLfloat d; + + d = sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]); + if (d == 0.0) { +/* __glutWarning("normalize: zero length vector"); */ + v[0] = d = 1.0; + } + d = 1 / d; + v[0] *= d; + v[1] *= d; + v[2] *= d; +} + +static void +pentagon(int a, int b, int c, int d, int e, GLenum shadeType) +{ + GLfloat n0[3], d1[3], d2[3]; + + DIFF3(dodec[a], dodec[b], d1); + DIFF3(dodec[b], dodec[c], d2); + crossprod(d1, d2, n0); + normalize(n0); + + glBegin(shadeType); +/* glNormal3fv(n0); */ + glVertex3fv(&dodec[a][0]); + glVertex3fv(&dodec[b][0]); + glVertex3fv(&dodec[c][0]); + glVertex3fv(&dodec[d][0]); + glVertex3fv(&dodec[e][0]); + glEnd(); +} + +static void +dodecahedron(GLenum type) +{ + static int inited = 0; + + if (inited == 0) { + inited = 1; + initDodecahedron(); + } + pentagon(0, 1, 9, 16, 5, type); + pentagon(1, 0, 3, 18, 7, type); + pentagon(1, 7, 11, 10, 9, type); + pentagon(11, 7, 18, 19, 6, type); + pentagon(8, 17, 16, 9, 10, type); + pentagon(2, 14, 15, 6, 19, type); + pentagon(2, 13, 12, 4, 14, type); + pentagon(2, 19, 18, 3, 13, type); + pentagon(3, 0, 5, 12, 13, type); + pentagon(6, 15, 8, 10, 11, type); + pentagon(4, 17, 8, 15, 14, type); + pentagon(4, 12, 5, 16, 17, type); +} + +/* CENTRY */ +void GLUTAPIENTRY +glutWireDodecahedron(void) +{ + dodecahedron(GL_LINE_LOOP); +} + +void GLUTAPIENTRY +glutSolidDodecahedron(void) +{ + dodecahedron(GL_TRIANGLE_FAN); +} + +/* ENDCENTRY */ + +static void +recorditem(GLfloat * n1, GLfloat * n2, GLfloat * n3, + GLenum shadeType) +{ + GLfloat q0[3], q1[3]; + + DIFF3(n1, n2, q0); + DIFF3(n2, n3, q1); + crossprod(q0, q1, q1); + normalize(q1); + + glBegin(shadeType); +/* glNormal3fv(q1); */ + glVertex3fv(n1); + glVertex3fv(n2); + glVertex3fv(n3); + glEnd(); +} + +static void +subdivide(GLfloat * v0, GLfloat * v1, GLfloat * v2, + GLenum shadeType) +{ + int depth; + GLfloat w0[3], w1[3], w2[3]; + GLfloat l; + int i, j, k, n; + + depth = 1; + for (i = 0; i < depth; i++) { + for (j = 0; i + j < depth; j++) { + k = depth - i - j; + for (n = 0; n < 3; n++) { + w0[n] = (i * v0[n] + j * v1[n] + k * v2[n]) / depth; + w1[n] = ((i + 1) * v0[n] + j * v1[n] + (k - 1) * v2[n]) + / depth; + w2[n] = (i * v0[n] + (j + 1) * v1[n] + (k - 1) * v2[n]) + / depth; + } + l = sqrt(w0[0] * w0[0] + w0[1] * w0[1] + w0[2] * w0[2]); + w0[0] /= l; + w0[1] /= l; + w0[2] /= l; + l = sqrt(w1[0] * w1[0] + w1[1] * w1[1] + w1[2] * w1[2]); + w1[0] /= l; + w1[1] /= l; + w1[2] /= l; + l = sqrt(w2[0] * w2[0] + w2[1] * w2[1] + w2[2] * w2[2]); + w2[0] /= l; + w2[1] /= l; + w2[2] /= l; + recorditem(w1, w0, w2, shadeType); + } + } +} + +static void +drawtriangle(int i, GLfloat data[][3], int ndx[][3], + GLenum shadeType) +{ + GLfloat *x0, *x1, *x2; + + x0 = data[ndx[i][0]]; + x1 = data[ndx[i][1]]; + x2 = data[ndx[i][2]]; + subdivide(x0, x1, x2, shadeType); +} + +/* octahedron data: The octahedron produced is centered at the + origin and has radius 1.0 */ +static GLfloat odata[6][3] = +{ + {1.0, 0.0, 0.0}, + {-1.0, 0.0, 0.0}, + {0.0, 1.0, 0.0}, + {0.0, -1.0, 0.0}, + {0.0, 0.0, 1.0}, + {0.0, 0.0, -1.0} +}; + +static int ondex[8][3] = +{ + {0, 4, 2}, + {1, 2, 4}, + {0, 3, 4}, + {1, 4, 3}, + {0, 2, 5}, + {1, 5, 2}, + {0, 5, 3}, + {1, 3, 5} +}; + +static void +octahedron(GLenum shadeType) +{ + int i; + + for (i = 7; i >= 0; i--) { + drawtriangle(i, odata, ondex, shadeType); + } +} + +/* CENTRY */ +void GLUTAPIENTRY +glutWireOctahedron(void) +{ + octahedron(GL_LINE_LOOP); +} + +void GLUTAPIENTRY +glutSolidOctahedron(void) +{ + octahedron(GL_TRIANGLES); +} + +/* ENDCENTRY */ + +/* icosahedron data: These numbers are rigged to make an + icosahedron of radius 1.0 */ + +#define X .525731112119133606 +#define Z .850650808352039932 + +static GLfloat idata[12][3] = +{ + {-X, 0, Z}, + {X, 0, Z}, + {-X, 0, -Z}, + {X, 0, -Z}, + {0, Z, X}, + {0, Z, -X}, + {0, -Z, X}, + {0, -Z, -X}, + {Z, X, 0}, + {-Z, X, 0}, + {Z, -X, 0}, + {-Z, -X, 0} +}; + +static int index[20][3] = +{ + {0, 4, 1}, + {0, 9, 4}, + {9, 5, 4}, + {4, 5, 8}, + {4, 8, 1}, + {8, 10, 1}, + {8, 3, 10}, + {5, 3, 8}, + {5, 2, 3}, + {2, 7, 3}, + {7, 10, 3}, + {7, 6, 10}, + {7, 11, 6}, + {11, 0, 6}, + {0, 1, 6}, + {6, 1, 10}, + {9, 0, 11}, + {9, 11, 2}, + {9, 2, 5}, + {7, 2, 11}, +}; + +static void +icosahedron(GLenum shadeType) +{ + int i; + + for (i = 19; i >= 0; i--) { + drawtriangle(i, idata, index, shadeType); + } +} + +/* CENTRY */ +void GLUTAPIENTRY +glutWireIcosahedron(void) +{ + icosahedron(GL_LINE_LOOP); +} + +void GLUTAPIENTRY +glutSolidIcosahedron(void) +{ + icosahedron(GL_TRIANGLES); +} + +/* ENDCENTRY */ + +/* tetrahedron data: */ + +#define T 1.73205080756887729 + +static GLfloat tdata[4][3] = +{ + {T, T, T}, + {T, -T, -T}, + {-T, T, -T}, + {-T, -T, T} +}; + +static int tndex[4][3] = +{ + {0, 1, 3}, + {2, 1, 0}, + {3, 2, 0}, + {1, 2, 3} +}; + +static void +tetrahedron(GLenum shadeType) +{ + int i; + + for (i = 3; i >= 0; i--) + drawtriangle(i, tdata, tndex, shadeType); +} + +/* CENTRY */ +void GLUTAPIENTRY +glutWireTetrahedron(void) +{ + tetrahedron(GL_LINE_LOOP); +} + +void GLUTAPIENTRY +glutSolidTetrahedron(void) +{ + tetrahedron(GL_TRIANGLES); +} + +/* ENDCENTRY */ diff --git a/src/glut/directfb/overlay.c b/src/glut/directfb/overlay.c new file mode 100644 index 00000000000..714be5f1a28 --- /dev/null +++ b/src/glut/directfb/overlay.c @@ -0,0 +1,62 @@ +/* + * Copyright (C) 2006 Claudio Ciccani + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +#include "internal.h" + + +void GLUTAPIENTRY +glutEstablishOverlay( void ) +{ +} + + +void GLUTAPIENTRY +glutRemoveOverlay( void ) +{ +} + + +void GLUTAPIENTRY +glutUseLayer( GLenum layer ) +{ +} + + +void GLUTAPIENTRY +glutPostOverlayRedisplay( void ) +{ +} + + +void GLUTAPIENTRY +glutPostWindowOverlayRedisplay( int win ) +{ +} + + +void GLUTAPIENTRY +glutShowOverlay( void ) +{ +} + + +void GLUTAPIENTRY +glutHideOverlay( void ) +{ +} diff --git a/src/glut/directfb/state.c b/src/glut/directfb/state.c new file mode 100644 index 00000000000..c6800ffecd4 --- /dev/null +++ b/src/glut/directfb/state.c @@ -0,0 +1,258 @@ +/* + * Copyright (C) 2006 Claudio Ciccani + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +#include +#include +#include + +#include "GL/glu.h" + +#include "internal.h" + + +int GLUTAPIENTRY +glutGet( GLenum type ) +{ + switch (type) { + case GLUT_WINDOW_X: + if (g_current && g_current->window) { + int x; + g_current->window->GetPosition( g_current->window, &x, 0 ); + return x; + } + break; + case GLUT_WINDOW_Y: + if (g_current && g_current->window) { + int y; + g_current->window->GetPosition( g_current->window, 0, &y ); + return y; + } + break; + + case GLUT_WINDOW_WIDTH: + if (g_current) { + int w; + g_current->surface->GetSize( g_current->surface, &w, 0 ); + return w; + } + break; + case GLUT_WINDOW_HEIGHT: + if (g_current) { + int h; + g_current->surface->GetSize( g_current->surface, 0, &h ); + return h; + } + break; + + case GLUT_WINDOW_BUFFER_SIZE: + if (g_current) { + DFBGLAttributes a; + g_current->gl->GetAttributes( g_current->gl, &a ); + return a.buffer_size; + } + break; + case GLUT_WINDOW_STENCIL_SIZE: + if (g_current) { + DFBGLAttributes a; + g_current->gl->GetAttributes( g_current->gl, &a ); + return a.stencil_size; + } + break; + case GLUT_WINDOW_DEPTH_SIZE: + if (g_current) { + DFBGLAttributes a; + g_current->gl->GetAttributes( g_current->gl, &a ); + return a.depth_size; + } + break; + case GLUT_WINDOW_RED_SIZE: + if (g_current) { + DFBGLAttributes a; + g_current->gl->GetAttributes( g_current->gl, &a ); + return a.red_size; + } + break; + case GLUT_WINDOW_GREEN_SIZE: + if (g_current) { + DFBGLAttributes a; + g_current->gl->GetAttributes( g_current->gl, &a ); + return a.green_size; + } + break; + case GLUT_WINDOW_BLUE_SIZE: + if (g_current) { + DFBGLAttributes a; + g_current->gl->GetAttributes( g_current->gl, &a ); + return a.blue_size; + } + break; + case GLUT_WINDOW_ALPHA_SIZE: + if (g_current) { + DFBGLAttributes a; + g_current->gl->GetAttributes( g_current->gl, &a ); + return a.alpha_size; + } + break; + case GLUT_WINDOW_ACCUM_RED_SIZE: + if (g_current) { + DFBGLAttributes a; + g_current->gl->GetAttributes( g_current->gl, &a ); + return a.accum_red_size; + } + break; + case GLUT_WINDOW_ACCUM_GREEN_SIZE: + if (g_current) { + DFBGLAttributes a; + g_current->gl->GetAttributes( g_current->gl, &a ); + return a.accum_green_size; + } + break; + case GLUT_WINDOW_ACCUM_BLUE_SIZE: + if (g_current) { + DFBGLAttributes a; + g_current->gl->GetAttributes( g_current->gl, &a ); + return a.accum_blue_size; + } + break; + case GLUT_WINDOW_ACCUM_ALPHA_SIZE: + if (g_current) { + DFBGLAttributes a; + g_current->gl->GetAttributes( g_current->gl, &a ); + return a.accum_alpha_size; + } + break; + case GLUT_WINDOW_DOUBLEBUFFER: + if (g_current) { + DFBGLAttributes a; + g_current->gl->GetAttributes( g_current->gl, &a ); + return a.double_buffer; + } + break; + + case GLUT_WINDOW_RGBA: + return 1; + + case GLUT_WINDOW_CURSOR: + if (g_current) + return g_current->cursor; + break; + + case GLUT_SCREEN_WIDTH: + if (primary) { + DFBDisplayLayerConfig c; + primary->GetConfiguration( primary, &c ); + return c.width; + } + break; + case GLUT_SCREEN_HEIGHT: + if (primary) { + DFBDisplayLayerConfig c; + primary->GetConfiguration( primary, &c ); + return c.height; + } + break; + + case GLUT_INIT_DISPLAY_MODE: + return g_display_mode; + case GLUT_INIT_WINDOW_X: + return g_xpos; + case GLUT_INIT_WINDOW_Y: + return g_ypos; + case GLUT_INIT_WINDOW_WIDTH: + return g_width; + case GLUT_INIT_WINDOW_HEIGHT: + return g_height; + + case GLUT_ELAPSED_TIME: + { + static long long start = -1; + struct timeval t; + + gettimeofday( &t, NULL ); + if (start == -1) { + start = t.tv_sec * 1000ll + t.tv_usec / 1000ll; + return 0; + } + return (t.tv_sec * 1000ll + t.tv_usec / 1000ll - start); + } + break; + + default: + break; + } + + return 0; +} + + +int GLUTAPIENTRY +glutLayerGet( GLenum type ) +{ + return 0; +} + +int GLUTAPIENTRY +glutDeviceGet( GLenum type ) +{ + switch (type) { + case GLUT_HAS_KEYBOARD: + return (keyboard != NULL); + case GLUT_HAS_MOUSE: + return (mouse != NULL); + case GLUT_NUM_MOUSE_BUTTONS: + if (mouse) { + DFBInputDeviceDescription dsc; + mouse->GetDescription( mouse, &dsc ); + return dsc.max_button+1; + } + break; + case GLUT_HAS_JOYSTICK: + return (g_game && joystick); /* only available in game mode */ + case GLUT_JOYSTICK_BUTTONS: + if (joystick) { + DFBInputDeviceDescription dsc; + joystick->GetDescription( joystick, &dsc ); + return dsc.max_button+1; + } + break; + case GLUT_JOYSTICK_AXES: + if (joystick) { + DFBInputDeviceDescription dsc; + joystick->GetDescription( joystick, &dsc ); + return dsc.max_axis+1; + } + break; + default: + break; + } + + return 0; +} + + +void GLUTAPIENTRY +glutReportErrors( void ) +{ + GLenum error; + + while ((error = glGetError()) != GL_NO_ERROR) + __glutWarning( "**OpenGL Error** %s", gluErrorString( error ) ); +} + + diff --git a/src/glut/directfb/teapot.c b/src/glut/directfb/teapot.c new file mode 100644 index 00000000000..e7f1ee812fa --- /dev/null +++ b/src/glut/directfb/teapot.c @@ -0,0 +1,212 @@ + +/* Copyright (c) Mark J. Kilgard, 1994. */ + +/** +(c) Copyright 1993, Silicon Graphics, Inc. + +ALL RIGHTS RESERVED + +Permission to use, copy, modify, and distribute this software +for any purpose and without fee is hereby granted, provided +that the above copyright notice appear in all copies and that +both the copyright notice and this permission notice appear in +supporting documentation, and that the name of Silicon +Graphics, Inc. not be used in advertising or publicity +pertaining to distribution of the software without specific, +written prior permission. + +THE MATERIAL EMBODIED ON THIS SOFTWARE IS PROVIDED TO YOU +"AS-IS" AND WITHOUT WARRANTY OF ANY KIND, EXPRESS, IMPLIED OR +OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF +MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. IN NO +EVENT SHALL SILICON GRAPHICS, INC. BE LIABLE TO YOU OR ANYONE +ELSE FOR ANY DIRECT, SPECIAL, INCIDENTAL, INDIRECT OR +CONSEQUENTIAL DAMAGES OF ANY KIND, OR ANY DAMAGES WHATSOEVER, +INCLUDING WITHOUT LIMITATION, LOSS OF PROFIT, LOSS OF USE, +SAVINGS OR REVENUE, OR THE CLAIMS OF THIRD PARTIES, WHETHER OR +NOT SILICON GRAPHICS, INC. HAS BEEN ADVISED OF THE POSSIBILITY +OF SUCH LOSS, HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, +ARISING OUT OF OR IN CONNECTION WITH THE POSSESSION, USE OR +PERFORMANCE OF THIS SOFTWARE. + +US Government Users Restricted Rights + +Use, duplication, or disclosure by the Government is subject to +restrictions set forth in FAR 52.227.19(c)(2) or subparagraph +(c)(1)(ii) of the Rights in Technical Data and Computer +Software clause at DFARS 252.227-7013 and/or in similar or +successor clauses in the FAR or the DOD or NASA FAR +Supplement. Unpublished-- rights reserved under the copyright +laws of the United States. Contractor/manufacturer is Silicon +Graphics, Inc., 2011 N. Shoreline Blvd., Mountain View, CA +94039-7311. + +OpenGL(TM) is a trademark of Silicon Graphics, Inc. +*/ + +#include +#include +#include "GL/glut.h" + +/* Rim, body, lid, and bottom data must be reflected in x and + y; handle and spout data across the y axis only. */ + +static int patchdata[][16] = +{ + /* rim */ + {102, 103, 104, 105, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15}, + /* body */ + {12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, + 24, 25, 26, 27}, + {24, 25, 26, 27, 29, 30, 31, 32, 33, 34, 35, 36, + 37, 38, 39, 40}, + /* lid */ + {96, 96, 96, 96, 97, 98, 99, 100, 101, 101, 101, + 101, 0, 1, 2, 3,}, + {0, 1, 2, 3, 106, 107, 108, 109, 110, 111, 112, + 113, 114, 115, 116, 117}, + /* bottom */ + {118, 118, 118, 118, 124, 122, 119, 121, 123, 126, + 125, 120, 40, 39, 38, 37}, + /* handle */ + {41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, + 53, 54, 55, 56}, + {53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, + 28, 65, 66, 67}, + /* spout */ + {68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, + 80, 81, 82, 83}, + {80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, + 92, 93, 94, 95} +}; +/* *INDENT-OFF* */ + +static float cpdata[][3] = +{ + {0.2, 0, 2.7}, {0.2, -0.112, 2.7}, {0.112, -0.2, 2.7}, {0, + -0.2, 2.7}, {1.3375, 0, 2.53125}, {1.3375, -0.749, 2.53125}, + {0.749, -1.3375, 2.53125}, {0, -1.3375, 2.53125}, {1.4375, + 0, 2.53125}, {1.4375, -0.805, 2.53125}, {0.805, -1.4375, + 2.53125}, {0, -1.4375, 2.53125}, {1.5, 0, 2.4}, {1.5, -0.84, + 2.4}, {0.84, -1.5, 2.4}, {0, -1.5, 2.4}, {1.75, 0, 1.875}, + {1.75, -0.98, 1.875}, {0.98, -1.75, 1.875}, {0, -1.75, + 1.875}, {2, 0, 1.35}, {2, -1.12, 1.35}, {1.12, -2, 1.35}, + {0, -2, 1.35}, {2, 0, 0.9}, {2, -1.12, 0.9}, {1.12, -2, + 0.9}, {0, -2, 0.9}, {-2, 0, 0.9}, {2, 0, 0.45}, {2, -1.12, + 0.45}, {1.12, -2, 0.45}, {0, -2, 0.45}, {1.5, 0, 0.225}, + {1.5, -0.84, 0.225}, {0.84, -1.5, 0.225}, {0, -1.5, 0.225}, + {1.5, 0, 0.15}, {1.5, -0.84, 0.15}, {0.84, -1.5, 0.15}, {0, + -1.5, 0.15}, {-1.6, 0, 2.025}, {-1.6, -0.3, 2.025}, {-1.5, + -0.3, 2.25}, {-1.5, 0, 2.25}, {-2.3, 0, 2.025}, {-2.3, -0.3, + 2.025}, {-2.5, -0.3, 2.25}, {-2.5, 0, 2.25}, {-2.7, 0, + 2.025}, {-2.7, -0.3, 2.025}, {-3, -0.3, 2.25}, {-3, 0, + 2.25}, {-2.7, 0, 1.8}, {-2.7, -0.3, 1.8}, {-3, -0.3, 1.8}, + {-3, 0, 1.8}, {-2.7, 0, 1.575}, {-2.7, -0.3, 1.575}, {-3, + -0.3, 1.35}, {-3, 0, 1.35}, {-2.5, 0, 1.125}, {-2.5, -0.3, + 1.125}, {-2.65, -0.3, 0.9375}, {-2.65, 0, 0.9375}, {-2, + -0.3, 0.9}, {-1.9, -0.3, 0.6}, {-1.9, 0, 0.6}, {1.7, 0, + 1.425}, {1.7, -0.66, 1.425}, {1.7, -0.66, 0.6}, {1.7, 0, + 0.6}, {2.6, 0, 1.425}, {2.6, -0.66, 1.425}, {3.1, -0.66, + 0.825}, {3.1, 0, 0.825}, {2.3, 0, 2.1}, {2.3, -0.25, 2.1}, + {2.4, -0.25, 2.025}, {2.4, 0, 2.025}, {2.7, 0, 2.4}, {2.7, + -0.25, 2.4}, {3.3, -0.25, 2.4}, {3.3, 0, 2.4}, {2.8, 0, + 2.475}, {2.8, -0.25, 2.475}, {3.525, -0.25, 2.49375}, + {3.525, 0, 2.49375}, {2.9, 0, 2.475}, {2.9, -0.15, 2.475}, + {3.45, -0.15, 2.5125}, {3.45, 0, 2.5125}, {2.8, 0, 2.4}, + {2.8, -0.15, 2.4}, {3.2, -0.15, 2.4}, {3.2, 0, 2.4}, {0, 0, + 3.15}, {0.8, 0, 3.15}, {0.8, -0.45, 3.15}, {0.45, -0.8, + 3.15}, {0, -0.8, 3.15}, {0, 0, 2.85}, {1.4, 0, 2.4}, {1.4, + -0.784, 2.4}, {0.784, -1.4, 2.4}, {0, -1.4, 2.4}, {0.4, 0, + 2.55}, {0.4, -0.224, 2.55}, {0.224, -0.4, 2.55}, {0, -0.4, + 2.55}, {1.3, 0, 2.55}, {1.3, -0.728, 2.55}, {0.728, -1.3, + 2.55}, {0, -1.3, 2.55}, {1.3, 0, 2.4}, {1.3, -0.728, 2.4}, + {0.728, -1.3, 2.4}, {0, -1.3, 2.4}, {0, 0, 0}, {1.425, + -0.798, 0}, {1.5, 0, 0.075}, {1.425, 0, 0}, {0.798, -1.425, + 0}, {0, -1.5, 0.075}, {0, -1.425, 0}, {1.5, -0.84, 0.075}, + {0.84, -1.5, 0.075} +}; + +static float tex[2][2][2] = +{ + { {0, 0}, + {1, 0}}, + { {0, 1}, + {1, 1}} +}; + +/* *INDENT-ON* */ + +static void +teapot(GLint grid, GLdouble scale, GLenum type) +{ + float p[4][4][3], q[4][4][3], r[4][4][3], s[4][4][3]; + long i, j, k, l; + + glPushAttrib(GL_ENABLE_BIT | GL_EVAL_BIT); + glEnable(GL_AUTO_NORMAL); + glEnable(GL_NORMALIZE); + glEnable(GL_MAP2_VERTEX_3); + glEnable(GL_MAP2_TEXTURE_COORD_2); + glPushMatrix(); + glRotatef(270.0, 1.0, 0.0, 0.0); + glScalef(0.5 * scale, 0.5 * scale, 0.5 * scale); + glTranslatef(0.0, 0.0, -1.5); + for (i = 0; i < 10; i++) { + for (j = 0; j < 4; j++) { + for (k = 0; k < 4; k++) { + for (l = 0; l < 3; l++) { + p[j][k][l] = cpdata[patchdata[i][j * 4 + k]][l]; + q[j][k][l] = cpdata[patchdata[i][j * 4 + (3 - k)]][l]; + if (l == 1) + q[j][k][l] *= -1.0; + if (i < 6) { + r[j][k][l] = + cpdata[patchdata[i][j * 4 + (3 - k)]][l]; + if (l == 0) + r[j][k][l] *= -1.0; + s[j][k][l] = cpdata[patchdata[i][j * 4 + k]][l]; + if (l == 0) + s[j][k][l] *= -1.0; + if (l == 1) + s[j][k][l] *= -1.0; + } + } + } + } + glMap2f(GL_MAP2_TEXTURE_COORD_2, 0, 1, 2, 2, 0, 1, 4, 2, + &tex[0][0][0]); + glMap2f(GL_MAP2_VERTEX_3, 0, 1, 3, 4, 0, 1, 12, 4, + &p[0][0][0]); + glMapGrid2f(grid, 0.0, 1.0, grid, 0.0, 1.0); + glEvalMesh2(type, 0, grid, 0, grid); + glMap2f(GL_MAP2_VERTEX_3, 0, 1, 3, 4, 0, 1, 12, 4, + &q[0][0][0]); + glEvalMesh2(type, 0, grid, 0, grid); + if (i < 6) { + glMap2f(GL_MAP2_VERTEX_3, 0, 1, 3, 4, 0, 1, 12, 4, + &r[0][0][0]); + glEvalMesh2(type, 0, grid, 0, grid); + glMap2f(GL_MAP2_VERTEX_3, 0, 1, 3, 4, 0, 1, 12, 4, + &s[0][0][0]); + glEvalMesh2(type, 0, grid, 0, grid); + } + } + glPopMatrix(); + glPopAttrib(); +} + +/* CENTRY */ +void GLUTAPIENTRY +glutSolidTeapot(GLdouble scale) +{ + teapot(7, scale, GL_FILL); +} + +void GLUTAPIENTRY +glutWireTeapot(GLdouble scale) +{ + teapot(10, scale, GL_LINE); +} + +/* ENDCENTRY */ diff --git a/src/glut/directfb/window.c b/src/glut/directfb/window.c new file mode 100644 index 00000000000..7907c45e67a --- /dev/null +++ b/src/glut/directfb/window.c @@ -0,0 +1,576 @@ +/* + * Copyright (C) 2006 Claudio Ciccani + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +#include +#include +#include +#include + +#include "internal.h" + + +/*****************************************************************************/ + +static __GlutWindow *g_stack = NULL; + +/*****************************************************************************/ + + +__GlutWindow* +__glutCreateWindow( GLboolean fullscreen ) +{ + __GlutWindow *new; + DFBResult ret; + static int curid = 1; + + new = calloc( 1, sizeof(__GlutWindow) ); + if (!new) + __glutFatalError( "out of memory" ); + + new->id = curid++; + + if (fullscreen) { + DFBDisplayLayerConfig config; + DFBDisplayLayerConfigFlags fail = 0; + + config.flags = DLCONF_WIDTH | DLCONF_HEIGHT | + DLCONF_BUFFERMODE; + config.width = g_width; + config.height = g_height; + + if (g_display_mode & GLUT_DOUBLE) + config.buffermode = DLBM_BACKVIDEO; + else + config.buffermode = DLBM_FRONTONLY; + + if (g_bpp) { + config.flags |= DLCONF_PIXELFORMAT; + + switch (g_bpp) { + case 8: + config.pixelformat = DSPF_RGB332; + break; + case 15: + config.pixelformat = DSPF_ARGB1555; + break; + case 16: + config.pixelformat = DSPF_RGB16; + break; + case 24: + case 32: + config.pixelformat = DSPF_RGB32; + break; + default: + config.flags &= ~DLCONF_PIXELFORMAT; + break; + } + } + + primary->TestConfiguration( primary, &config, &fail ); + config.flags &= ~fail; + primary->SetConfiguration( primary, &config ); + + ret = primary->GetSurface( primary, &new->surface ); + if (ret) { + DirectFBError( "IDirectFBDisplayLayer::GetSurface()", ret ); + free( new ); + return NULL; + } + + ret = new->surface->GetGL( new->surface, &new->gl ); + if (ret) { + DirectFBError( "IDirectFBSurface::GetGL()", ret ); + new->surface->Release( new->surface ); + free( new ); + return NULL; + } + + events->Reset( events ); + if (keyboard) + keyboard->AttachEventBuffer( keyboard, events ); + if (mouse) + mouse->AttachEventBuffer( mouse, events ); + if (joystick) + joystick->AttachEventBuffer( joystick, events ); + + new->visible = GL_TRUE; + } + else { + DFBWindowDescription dsc; + + dsc.flags = DWDESC_CAPS | DWDESC_POSX | DWDESC_POSY | + DWDESC_WIDTH | DWDESC_HEIGHT; + dsc.caps = DWCAPS_NONE; + dsc.posx = g_xpos; + dsc.posy = g_ypos; + dsc.width = g_width; + dsc.height = g_height; + + if (g_display_mode & GLUT_DOUBLE) + dsc.caps |= DWCAPS_DOUBLEBUFFER; + if (g_display_mode & GLUT_ALPHA) + dsc.caps |= DWCAPS_ALPHACHANNEL; + + ret = primary->CreateWindow( primary, &dsc, &new->window ); + if (ret) { + DirectFBError( "IDirectFBDisplayLayer::CreateWindow()", ret ); + free( new ); + return NULL; + } + + new->window->GetID( new->window, &new->wid ); + + ret = new->window->GetSurface( new->window, &new->surface ); + if (ret) { + DirectFBError( "IDirectFBWindow::GetSurface()", ret ); + new->window->Release( new->window ); + free( new ); + return NULL; + } + + ret = new->surface->GetGL( new->surface, &new->gl ); + if (ret) { + DirectFBError( "IDirectFBSurface::GetGl()", ret ); + new->surface->Release( new->surface ); + new->window->Release( new->window ); + free( new ); + return NULL; + } + + new->window->AttachEventBuffer( new->window, events ); + /* enable only handled events */ + new->window->EnableEvents( new->window, DWET_KEYDOWN | DWET_KEYUP | + DWET_BUTTONDOWN | DWET_BUTTONUP | + DWET_ENTER | DWET_LEAVE | + DWET_MOTION | DWET_SIZE ); + + + new->req.flags |= WINDOW_REQUEST_SHOW; + } + + new->reshape = GL_TRUE; + new->visibility = GL_TRUE; + new->redisplay = GL_TRUE; + + if (g_stack) { + new->prev = g_stack->prev; + g_stack->prev->next = new; + g_stack->prev = new; + } + else { + new->prev = new; + g_stack = new; + } + + return new; +} + + +__GlutWindow* +__glutFindWindow( DFBWindowID id ) +{ + __GlutWindow *cur; + + for (cur = g_stack; cur; cur = cur->next) { + if (cur->wid == id) + return cur; + } + + __glutFatalError( "Window %d not found", id ); + + return NULL; +} + + +void +__glutSetWindow( __GlutWindow *window ) +{ + if (g_current) { + if (g_current == window) + return; + g_current->gl->Unlock( g_current->gl ); + } + + if (window) + window->gl->Lock( window->gl ); + g_current = window; +} + + +void +__glutHandleWindows( void ) +{ + __GlutWindow *cur = g_stack; + + while (cur) { + __GlutWindow *next = cur->next; + + if (cur->window && cur->req.flags) { + if (cur == g_current) + cur->gl->Unlock( cur->gl ); + + if (cur->req.flags & WINDOW_REQUEST_DESTROY) { + __glutDestroyWindow( cur ); + cur = next; + continue; + } + + if (cur->req.flags & WINDOW_REQUEST_POSITION) { + cur->window->MoveTo( cur->window, + cur->req.x, cur->req.y ); + } + + if (cur->req.flags & WINDOW_REQUEST_RESIZE) { + cur->window->Resize( cur->window, + cur->req.w, cur->req.h ); + cur->reshape = GL_TRUE; + cur->redisplay = GL_TRUE; + } + + if (cur->req.flags & WINDOW_REQUEST_RESTACK) { + while (cur->req.z > 0) { + if (cur->req.z >= +1000) { + cur->window->RaiseToTop( cur->window ); + cur->req.z = 0; + break; + } + + cur->window->Raise( cur->window ); + cur->req.z--; + } + + while (cur->req.z < 0) { + if (cur->req.z <= -1000) { + cur->window->LowerToBottom( cur->window ); + cur->req.z = 0; + break; + } + + cur->window->Lower( cur->window ); + cur->req.z++; + } + } + + if (cur->req.flags & WINDOW_REQUEST_SHOW) { + cur->window->SetOpacity( cur->window, 0xff ); + cur->visible = GL_TRUE; + cur->visibility = GL_TRUE; + } + else if (cur->req.flags & WINDOW_REQUEST_HIDE) { + cur->window->SetOpacity( cur->window, 0x00 ); + cur->visible = GL_FALSE; + cur->visibility = GL_TRUE; + } + + cur->req.flags = 0; + + if (cur == g_current) + cur->gl->Lock( cur->gl ); + } + + if (cur->reshape && reshape_func) { + int w, h; + g_idle = GL_FALSE; + cur->surface->GetSize( cur->surface, &w, &h ); + __glutSetWindow( cur ); + reshape_func( w, h ); + } + + if (cur->visibility && visibility_func) { + g_idle = GL_FALSE; + __glutSetWindow( cur ); + visibility_func( cur->visible ? GLUT_VISIBLE : GLUT_NOT_VISIBLE ); + } + + if (cur->redisplay && display_func) { + g_idle = GL_FALSE; + __glutSetWindow( cur ); + display_func(); + } + + cur->reshape = GL_FALSE; + cur->visibility = GL_FALSE; + cur->redisplay = GL_FALSE; + + cur = next; + } +} + + +void +__glutDestroyWindow( __GlutWindow *window ) +{ + __GlutWindow *next = window->next; + __GlutWindow *prev = window->prev; + + __glutAssert( window != NULL ); + + if (window == g_current) + g_current = NULL; + if (window == g_game) + g_game = NULL; + + window->gl->Unlock( window->gl ); + window->gl->Release( window->gl ); + window->surface->Release( window->surface ); + + if (window->window) { + window->window->Destroy( window->window ); + window->window->Release( window->window ); + } + else { +#if DIRECTFB_VERSION_CODE >= VERSION_CODE(0,9,26) + if (joystick) + joystick->DetachEventBuffer( joystick, events ); + if (mouse) + mouse->DetachEventBuffer( mouse, events ); + if (keyboard) + keyboard->DetachEventBuffer( keyboard, events ); +#endif + events->Reset( events ); + } + + free( window ); + + if (next) + next->prev = prev; + else + g_stack->prev = prev; + + if (window == g_stack) + g_stack = next; + else + prev->next = next; +} + + +void +__glutDestroyWindows( void ) +{ + __GlutWindow *cur = g_stack; + + while (cur) { + __GlutWindow *next = cur->next; + __glutDestroyWindow( cur ); + cur = next; + } +} + + +int GLUTAPIENTRY +glutCreateWindow( const char *title ) +{ + __GlutWindow *window; + + if (getenv( "__GLUT_GAME_MODE" )) + return glutEnterGameMode(); + + glutInit( NULL, NULL ); + + window = __glutCreateWindow( GL_FALSE ); + if (!window) + return 0; + + __glutSetWindow( window ); + glutSetCursor( GLUT_CURSOR_INHERIT ); + + return window->id; +} + + +int GLUTAPIENTRY +glutCreateSubWindow( int win, int x, int y, int width, int height ) +{ + return GL_FALSE; +} + + +void GLUTAPIENTRY +glutDestroyWindow( int win ) +{ + __GlutWindow *cur; + + for (cur = g_stack; cur; cur = cur->next) { + if (cur->id == win) { + if (cur->window) + cur->window->Destroy( cur->window ); + + cur->req.flags |= WINDOW_REQUEST_DESTROY; + break; + } + } +} + + +void GLUTAPIENTRY +glutPostRedisplay( void ) +{ + if (g_current) + g_current->redisplay = GL_TRUE; +} + + +void GLUTAPIENTRY +glutPostWindowRedisplay( int win ) +{ + __GlutWindow *cur; + + for (cur = g_stack; cur; cur = cur->next) { + if (cur->id == win) { + cur->redisplay = GL_TRUE; + break; + } + } +} + + +void GLUTAPIENTRY +glutSwapBuffers( void ) +{ + if (g_current) { + g_current->gl->Unlock( g_current->gl ); + g_current->surface->Flip( g_current->surface, NULL, 0 ); + g_current->gl->Lock( g_current->gl ); + } +} + + +int GLUTAPIENTRY +glutGetWindow( void ) +{ + return (g_current) ? g_current->id : 0; +} + + +void GLUTAPIENTRY +glutSetWindow( int win ) +{ + __GlutWindow *cur; + + if (g_current && g_current->id == win) + return; + + for (cur = g_stack; cur; cur = cur->next) { + if (cur->id == win) { + __glutSetWindow( cur ); + break; + } + } +} + + +void GLUTAPIENTRY +glutSetWindowTitle( const char *title ) +{ +} + + +void GLUTAPIENTRY +glutSetIconTitle( const char *title ) +{ +} + + +void GLUTAPIENTRY +glutFullScreen( void ) +{ + if (g_current && !g_game) { + DFBDisplayLayerConfig config; + + primary->GetConfiguration( primary, &config ); + + g_current->req.flags |= WINDOW_REQUEST_POSITION | + WINDOW_REQUEST_RESIZE | + WINDOW_REQUEST_RESTACK; + g_current->req.x = 0; + g_current->req.y = 0; + g_current->req.w = config.width; + g_current->req.h = config.height; + g_current->req.z = 1000; + } +} + + +void GLUTAPIENTRY +glutPositionWindow( int x, int y ) +{ + if (g_current && !g_game) { + g_current->req.flags |= WINDOW_REQUEST_POSITION; + g_current->req.x = x; + g_current->req.y = y; + } +} + + +void GLUTAPIENTRY +glutReshapeWindow( int width, int height ) +{ + if (g_current && !g_game) { + g_current->req.flags |= WINDOW_REQUEST_RESIZE; + g_current->req.w = width; + g_current->req.h = height; + } +} + + +void GLUTAPIENTRY +glutPopWindow( void ) +{ + if (g_current && !g_game) { + g_current->req.flags |= WINDOW_REQUEST_RESTACK; + g_current->req.z--; + } +} + + +void GLUTAPIENTRY +glutPushWindow( void ) +{ + if (g_current && !g_game) { + g_current->req.flags |= WINDOW_REQUEST_RESTACK; + g_current->req.z++; + } +} + + +void GLUTAPIENTRY +glutIconifyWindow( void ) +{ +} + + +void GLUTAPIENTRY +glutShowWindow( void ) +{ + if (g_current && !g_game) { + g_current->req.flags |= WINDOW_REQUEST_SHOW; + g_current->req.flags &= ~WINDOW_REQUEST_HIDE; + } +} + + +void GLUTAPIENTRY +glutHideWindow( void ) +{ + if (g_current && !g_game) { + g_current->req.flags |= WINDOW_REQUEST_HIDE; + g_current->req.flags &= ~WINDOW_REQUEST_SHOW; + } +} + -- 2.30.2