aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
authorChad Versace <chad.versace@intel.com>2011-02-25 20:08:13 -0800
committerChad Versace <chad.versace@intel.com>2011-02-25 20:44:11 -0800
commitc80b78991e8b6c96c0d3117ab5c176237d8717aa (patch)
tree91863b31a7aeeea0591ebca7846127168f255f09 /src
parent71b61a34d0789651ba92143dc2852170dd891e5e (diff)
downloadpiglit-c80b78991e8b6c96c0d3117ab5c176237d8717aa.tar.gz
glut_egl: Impose uniform naming scheme on functions
Some functions used the prefix 'glut', other 'glut_egl'. This changes all functions to use prefix 'glut'. Signed-off-by: Chad Versace <chad.versace@intel.com>
Diffstat (limited to 'src')
-rw-r--r--src/glut_egl/glut_egl.c176
-rw-r--r--src/glut_egl/glut_egl.h20
-rw-r--r--src/glut_egl/glut_egl_x11.c64
-rw-r--r--src/glut_egl/glut_eglint.h22
4 files changed, 141 insertions, 141 deletions
diff --git a/src/glut_egl/glut_egl.c b/src/glut_egl/glut_egl.c
index b99a5391..6347d9d9 100644
--- a/src/glut_egl/glut_egl.c
+++ b/src/glut_egl/glut_egl.c
@@ -34,8 +34,8 @@
#include "glut_eglint.h"
-static struct glut_egl_state _glut_egl_state = {
- .api_mask = GLUT_EGL_OPENGL_ES1_BIT,
+static struct glut_state _glut_state = {
+ .api_mask = GLUT_OPENGL_ES1_BIT,
.display_mode = GLUT_RGB,
.window_width = 300,
.window_height = 300,
@@ -43,10 +43,10 @@ static struct glut_egl_state _glut_egl_state = {
.num_windows = 0,
};
-struct glut_egl_state *_glut_egl = &_glut_egl_state;
+struct glut_state *_glut = &_glut_state;
void
-_glut_eglFatal(char *format, ...)
+_glutFatal(char *format, ...)
{
va_list args;
@@ -62,7 +62,7 @@ _glut_eglFatal(char *format, ...)
/* return current time (in milliseconds) */
int
-_glut_eglNow(void)
+_glutNow(void)
{
struct timeval tv;
#ifdef __VMS
@@ -75,19 +75,19 @@ _glut_eglNow(void)
}
static void
-_glut_eglDestroyWindow(struct glut_egl_window *win)
+_glutDestroyWindow(struct glut_window *win)
{
- if (_glut_egl->surface_type != EGL_PBUFFER_BIT &&
- _glut_egl->surface_type != EGL_SCREEN_BIT_MESA)
- eglDestroySurface(_glut_egl->dpy, win->surface);
+ if (_glut->surface_type != EGL_PBUFFER_BIT &&
+ _glut->surface_type != EGL_SCREEN_BIT_MESA)
+ eglDestroySurface(_glut->dpy, win->surface);
- _glut_eglNativeFiniWindow(win);
+ _glutNativeFiniWindow(win);
- eglDestroyContext(_glut_egl->dpy, win->context);
+ eglDestroyContext(_glut->dpy, win->context);
}
static EGLConfig
-_glut_eglChooseConfig(void)
+_glutChooseConfig(void)
{
EGLConfig config;
EGLint config_attribs[32];
@@ -102,59 +102,59 @@ _glut_eglChooseConfig(void)
config_attribs[i++] = 1;
config_attribs[i++] = EGL_ALPHA_SIZE;
- if (_glut_egl->display_mode & GLUT_ALPHA)
+ if (_glut->display_mode & GLUT_ALPHA)
config_attribs[i++] = 1;
else
config_attribs[i++] = 0;
config_attribs[i++] = EGL_DEPTH_SIZE;
- if (_glut_egl->display_mode & GLUT_DEPTH)
+ if (_glut->display_mode & GLUT_DEPTH)
config_attribs[i++] = 1;
else
config_attribs[i++] = 0;
config_attribs[i++] = EGL_STENCIL_SIZE;
- if (_glut_egl->display_mode & GLUT_STENCIL)
+ if (_glut->display_mode & GLUT_STENCIL)
config_attribs[i++] = 1;
else
config_attribs[i++] = 0;
config_attribs[i++] = EGL_SURFACE_TYPE;
- config_attribs[i++] = _glut_egl->surface_type;
+ config_attribs[i++] = _glut->surface_type;
config_attribs[i++] = EGL_RENDERABLE_TYPE;
renderable_type = 0x0;
- if (_glut_egl->api_mask & GLUT_EGL_OPENGL_BIT)
+ if (_glut->api_mask & GLUT_OPENGL_BIT)
renderable_type |= EGL_OPENGL_BIT;
- if (_glut_egl->api_mask & GLUT_EGL_OPENGL_ES1_BIT)
+ if (_glut->api_mask & GLUT_OPENGL_ES1_BIT)
renderable_type |= EGL_OPENGL_ES_BIT;
- if (_glut_egl->api_mask & GLUT_EGL_OPENGL_ES2_BIT)
+ if (_glut->api_mask & GLUT_OPENGL_ES2_BIT)
renderable_type |= EGL_OPENGL_ES2_BIT;
- if (_glut_egl->api_mask & GLUT_EGL_OPENVG_BIT)
+ if (_glut->api_mask & GLUT_OPENVG_BIT)
renderable_type |= EGL_OPENVG_BIT;
config_attribs[i++] = renderable_type;
config_attribs[i] = EGL_NONE;
- if (!eglChooseConfig(_glut_egl->dpy,
+ if (!eglChooseConfig(_glut->dpy,
config_attribs, &config, 1, &num_configs) || !num_configs)
- _glut_eglFatal("failed to choose a config");
+ _glutFatal("failed to choose a config");
return config;
}
-static struct glut_egl_window *
-_glut_eglCreateWindow(const char *title, int x, int y, int w, int h)
+static struct glut_window *
+_glutCreateWindow(const char *title, int x, int y, int w, int h)
{
- struct glut_egl_window *win;
+ struct glut_window *win;
EGLint context_attribs[4];
EGLint api, i;
win = calloc(1, sizeof(*win));
if (!win)
- _glut_eglFatal("failed to allocate window");
+ _glutFatal("failed to allocate window");
- win->config = _glut_eglChooseConfig();
+ win->config = _glutChooseConfig();
i = 0;
context_attribs[i] = EGL_NONE;
@@ -162,13 +162,13 @@ _glut_eglCreateWindow(const char *title, int x, int y, int w, int h)
/* multiple APIs? */
api = EGL_OPENGL_ES_API;
- if (_glut_egl->api_mask & GLUT_EGL_OPENGL_BIT) {
+ if (_glut->api_mask & GLUT_OPENGL_BIT) {
api = EGL_OPENGL_API;
}
- else if (_glut_egl->api_mask & GLUT_EGL_OPENVG_BIT) {
+ else if (_glut->api_mask & GLUT_OPENVG_BIT) {
api = EGL_OPENVG_API;
}
- else if (_glut_egl->api_mask & GLUT_EGL_OPENGL_ES2_BIT) {
+ else if (_glut->api_mask & GLUT_OPENGL_ES2_BIT) {
context_attribs[i++] = EGL_CONTEXT_CLIENT_VERSION;
context_attribs[i++] = 2;
}
@@ -176,19 +176,19 @@ _glut_eglCreateWindow(const char *title, int x, int y, int w, int h)
context_attribs[i] = EGL_NONE;
eglBindAPI(api);
- win->context = eglCreateContext(_glut_egl->dpy,
+ win->context = eglCreateContext(_glut->dpy,
win->config, EGL_NO_CONTEXT, context_attribs);
if (!win->context)
- _glut_eglFatal("failed to create context");
+ _glutFatal("failed to create context");
- _glut_eglNativeInitWindow(win, title, x, y, w, h);
- switch (_glut_egl->surface_type) {
+ _glutNativeInitWindow(win, title, x, y, w, h);
+ switch (_glut->surface_type) {
case EGL_WINDOW_BIT:
- win->surface = eglCreateWindowSurface(_glut_egl->dpy,
+ win->surface = eglCreateWindowSurface(_glut->dpy,
win->config, win->native.u.window, NULL);
break;
case EGL_PIXMAP_BIT:
- win->surface = eglCreatePixmapSurface(_glut_egl->dpy,
+ win->surface = eglCreatePixmapSurface(_glut->dpy,
win->config, win->native.u.pixmap, NULL);
break;
case EGL_PBUFFER_BIT:
@@ -199,21 +199,21 @@ _glut_eglCreateWindow(const char *title, int x, int y, int w, int h)
break;
}
if (win->surface == EGL_NO_SURFACE)
- _glut_eglFatal("failed to create surface");
+ _glutFatal("failed to create surface");
return win;
}
void
-glut_eglInitAPIMask(int mask)
+glutInitAPIMask(int mask)
{
- _glut_egl->api_mask = mask;
+ _glut->api_mask = mask;
}
void
glutInitDisplayMode(unsigned int mode)
{
- _glut_egl->display_mode = mode;
+ _glut->display_mode = mode;
}
void
@@ -224,8 +224,8 @@ glutInitWindowPosition(int x, int y)
void
glutInitWindowSize(int width, int height)
{
- _glut_egl->window_width = width;
- _glut_egl->window_height = height;
+ _glut->window_width = width;
+ _glut->window_height = height;
}
void
@@ -235,27 +235,27 @@ glutInit(int *argcp, char **argv)
for (i = 1; i < *argcp; i++) {
if (strcmp(argv[i], "-display") == 0)
- _glut_egl->display_name = argv[++i];
+ _glut->display_name = argv[++i];
else if (strcmp(argv[i], "-info") == 0) {
- _glut_egl->verbose = 1;
+ _glut->verbose = 1;
}
}
- _glut_eglNativeInitDisplay();
- _glut_egl->dpy = eglGetDisplay(_glut_egl->native_dpy);
+ _glutNativeInitDisplay();
+ _glut->dpy = eglGetDisplay(_glut->native_dpy);
- if (!eglInitialize(_glut_egl->dpy, &_glut_egl->major, &_glut_egl->minor))
- _glut_eglFatal("failed to initialize EGL display");
+ if (!eglInitialize(_glut->dpy, &_glut->major, &_glut->minor))
+ _glutFatal("failed to initialize EGL display");
- _glut_egl->init_time = _glut_eglNow();
+ _glut->init_time = _glutNow();
- printf("EGL_VERSION = %s\n", eglQueryString(_glut_egl->dpy, EGL_VERSION));
- if (_glut_egl->verbose) {
- printf("EGL_VENDOR = %s\n", eglQueryString(_glut_egl->dpy, EGL_VENDOR));
+ printf("EGL_VERSION = %s\n", eglQueryString(_glut->dpy, EGL_VERSION));
+ if (_glut->verbose) {
+ printf("EGL_VENDOR = %s\n", eglQueryString(_glut->dpy, EGL_VENDOR));
printf("EGL_EXTENSIONS = %s\n",
- eglQueryString(_glut_egl->dpy, EGL_EXTENSIONS));
+ eglQueryString(_glut->dpy, EGL_EXTENSIONS));
printf("EGL_CLIENT_APIS = %s\n",
- eglQueryString(_glut_egl->dpy, EGL_CLIENT_APIS));
+ eglQueryString(_glut->dpy, EGL_CLIENT_APIS));
}
}
@@ -265,8 +265,8 @@ glutGet(int state)
int val;
switch (state) {
- case GLUT_EGL_ELAPSED_TIME:
- val = _glut_eglNow() - _glut_egl->init_time;
+ case GLUT_ELAPSED_TIME:
+ val = _glutNow() - _glut->init_time;
break;
default:
val = -1;
@@ -279,58 +279,58 @@ glutGet(int state)
void
glutIdleFunc(GLUT_EGLidleCB func)
{
- _glut_egl->idle_cb = func;
+ _glut->idle_cb = func;
}
void
glutPostRedisplay(void)
{
- _glut_egl->redisplay = 1;
+ _glut->redisplay = 1;
}
void
glutMainLoop(void)
{
- struct glut_egl_window *win = _glut_egl->current;
+ struct glut_window *win = _glut->current;
if (!win)
- _glut_eglFatal("no window is created\n");
+ _glutFatal("no window is created\n");
if (win->reshape_cb)
win->reshape_cb(win->native.width, win->native.height);
- _glut_eglNativeEventLoop();
+ _glutNativeEventLoop();
}
static void
-_glut_eglFini(void)
+_glutFini(void)
{
- eglTerminate(_glut_egl->dpy);
- _glut_eglNativeFiniDisplay();
+ eglTerminate(_glut->dpy);
+ _glutNativeFiniDisplay();
}
void
glutDestroyWindow(int win)
{
- struct glut_egl_window *window = _glut_egl->current;
+ struct glut_window *window = _glut->current;
if (window->index != win)
return;
/* XXX it causes some bug in st/egl KMS backend */
- if ( _glut_egl->surface_type != EGL_SCREEN_BIT_MESA)
- eglMakeCurrent(_glut_egl->dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+ if ( _glut->surface_type != EGL_SCREEN_BIT_MESA)
+ eglMakeCurrent(_glut->dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
- _glut_eglDestroyWindow(_glut_egl->current);
+ _glutDestroyWindow(_glut->current);
}
static void
-_glut_eglDefaultKeyboard(unsigned char key, int x, int y)
+_glutDefaultKeyboard(unsigned char key, int x, int y)
{
if (key == 27) {
- if (_glut_egl->current)
- glutDestroyWindow(_glut_egl->current->index);
- _glut_eglFini();
+ if (_glut->current)
+ glutDestroyWindow(_glut->current->index);
+ _glutFini();
exit(0);
}
@@ -339,42 +339,42 @@ _glut_eglDefaultKeyboard(unsigned char key, int x, int y)
int
glutCreateWindow(const char *title)
{
- struct glut_egl_window *win;
+ struct glut_window *win;
- win = _glut_eglCreateWindow(title, 0, 0,
- _glut_egl->window_width, _glut_egl->window_height);
+ win = _glutCreateWindow(title, 0, 0,
+ _glut->window_width, _glut->window_height);
- win->index = _glut_egl->num_windows++;
+ win->index = _glut->num_windows++;
win->reshape_cb = NULL;
win->display_cb = NULL;
- win->keyboard_cb = _glut_eglDefaultKeyboard;
+ win->keyboard_cb = _glutDefaultKeyboard;
win->special_cb = NULL;
- if (!eglMakeCurrent(_glut_egl->dpy, win->surface, win->surface, win->context))
- _glut_eglFatal("failed to make window current");
- _glut_egl->current = win;
+ if (!eglMakeCurrent(_glut->dpy, win->surface, win->surface, win->context))
+ _glutFatal("failed to make window current");
+ _glut->current = win;
return win->index;
}
int
-glut_eglGetWindowWidth(void)
+glutGetWindowWidth(void)
{
- struct glut_egl_window *win = _glut_egl->current;
+ struct glut_window *win = _glut->current;
return win->native.width;
}
int
-glut_eglGetWindowHeight(void)
+glutGetWindowHeight(void)
{
- struct glut_egl_window *win = _glut_egl->current;
+ struct glut_window *win = _glut->current;
return win->native.height;
}
void
glutDisplayFunc(GLUT_EGLdisplayCB func)
{
- struct glut_egl_window *win = _glut_egl->current;
+ struct glut_window *win = _glut->current;
win->display_cb = func;
}
@@ -382,21 +382,21 @@ glutDisplayFunc(GLUT_EGLdisplayCB func)
void
glutReshapeFunc(GLUT_EGLreshapeCB func)
{
- struct glut_egl_window *win = _glut_egl->current;
+ struct glut_window *win = _glut->current;
win->reshape_cb = func;
}
void
glutKeyboardFunc(GLUT_EGLkeyboardCB func)
{
- struct glut_egl_window *win = _glut_egl->current;
+ struct glut_window *win = _glut->current;
win->keyboard_cb = func;
}
void
glutSpecialFunc(GLUT_EGLspecialCB func)
{
- struct glut_egl_window *win = _glut_egl->current;
+ struct glut_window *win = _glut->current;
win->special_cb = func;
}
diff --git a/src/glut_egl/glut_egl.h b/src/glut_egl/glut_egl.h
index dddf0f2c..ad59c05f 100644
--- a/src/glut_egl/glut_egl.h
+++ b/src/glut_egl/glut_egl.h
@@ -38,12 +38,12 @@ enum {
GLUT_STENCIL = 32,
};
-/* used by glut_eglInitAPIMask */
+/* used by glutInitAPIMask */
enum {
- GLUT_EGL_OPENGL_BIT = 0x1,
- GLUT_EGL_OPENGL_ES1_BIT = 0x2,
- GLUT_EGL_OPENGL_ES2_BIT = 0x4,
- GLUT_EGL_OPENVG_BIT = 0x8
+ GLUT_OPENGL_BIT = 0x1,
+ GLUT_OPENGL_ES1_BIT = 0x2,
+ GLUT_OPENGL_ES2_BIT = 0x4,
+ GLUT_OPENVG_BIT = 0x8
};
/* used by GLUT_EGLspecialCB */
@@ -71,7 +71,7 @@ enum {
/* used by glutGet */
enum {
- GLUT_EGL_ELAPSED_TIME
+ GLUT_ELAPSED_TIME
};
typedef void (*GLUT_EGLidleCB)(void);
@@ -80,7 +80,7 @@ typedef void (*GLUT_EGLdisplayCB)(void);
typedef void (*GLUT_EGLkeyboardCB)(unsigned char, int, int);
typedef void (*GLUT_EGLspecialCB)(int, int, int);
-void glut_eglInitAPIMask(int mask);
+void glutInitAPIMask(int mask);
void glutInitDisplayMode(unsigned int mode);
void glutInitWindowPosition(int x, int y);
void glutInitWindowSize(int width, int height);
@@ -96,8 +96,8 @@ void glutMainLoop(void);
int glutCreateWindow(const char *title);
void glutDestroyWindow(int win);
-int glut_eglGetWindowWidth(void);
-int glut_eglGetWindowHeight(void);
+int glutGetWindowWidth(void);
+int glutGetWindowHeight(void);
void glutDisplayFunc(GLUT_EGLdisplayCB func);
void glutReshapeFunc(GLUT_EGLreshapeCB func);
@@ -105,4 +105,4 @@ void glutKeyboardFunc(GLUT_EGLkeyboardCB func);
void glutSpecialFunc(GLUT_EGLspecialCB func);
void glutSwapBuffers(void);
-#endif /* GLUT_EGL_H */
+#endif /* GLUTH */
diff --git a/src/glut_egl/glut_egl_x11.c b/src/glut_egl/glut_egl_x11.c
index eae77c8b..e80d5243 100644
--- a/src/glut_egl/glut_egl_x11.c
+++ b/src/glut_egl/glut_egl_x11.c
@@ -30,23 +30,23 @@
#include "glut_eglint.h"
void
-_glut_eglNativeInitDisplay(void)
+_glutNativeInitDisplay(void)
{
- _glut_egl->native_dpy = XOpenDisplay(_glut_egl->display_name);
- if (!_glut_egl->native_dpy)
- _glut_eglFatal("failed to initialize native display");
+ _glut->native_dpy = XOpenDisplay(_glut->display_name);
+ if (!_glut->native_dpy)
+ _glutFatal("failed to initialize native display");
- _glut_egl->surface_type = EGL_WINDOW_BIT;
+ _glut->surface_type = EGL_WINDOW_BIT;
}
void
-_glut_eglNativeFiniDisplay(void)
+_glutNativeFiniDisplay(void)
{
- XCloseDisplay(_glut_egl->native_dpy);
+ XCloseDisplay(_glut->native_dpy);
}
void
-_glut_eglNativeInitWindow(struct glut_egl_window *win, const char *title,
+_glutNativeInitWindow(struct glut_window *win, const char *title,
int x, int y, int w, int h)
{
XVisualInfo *visInfo, visTemplate;
@@ -56,31 +56,31 @@ _glut_eglNativeInitWindow(struct glut_egl_window *win, const char *title,
unsigned long mask;
EGLint vid;
- if (!eglGetConfigAttrib(_glut_egl->dpy,
+ if (!eglGetConfigAttrib(_glut->dpy,
win->config, EGL_NATIVE_VISUAL_ID, &vid))
- _glut_eglFatal("failed to get visual id");
+ _glutFatal("failed to get visual id");
/* The X window visual must match the EGL config */
visTemplate.visualid = vid;
- visInfo = XGetVisualInfo(_glut_egl->native_dpy,
+ visInfo = XGetVisualInfo(_glut->native_dpy,
VisualIDMask, &visTemplate, &num_visuals);
if (!visInfo)
- _glut_eglFatal("failed to get an visual of id 0x%x", vid);
+ _glutFatal("failed to get an visual of id 0x%x", vid);
- root = RootWindow(_glut_egl->native_dpy, DefaultScreen(_glut_egl->native_dpy));
+ root = RootWindow(_glut->native_dpy, DefaultScreen(_glut->native_dpy));
/* window attributes */
attr.background_pixel = 0;
attr.border_pixel = 0;
- attr.colormap = XCreateColormap(_glut_egl->native_dpy,
+ attr.colormap = XCreateColormap(_glut->native_dpy,
root, visInfo->visual, AllocNone);
attr.event_mask = StructureNotifyMask | ExposureMask | KeyPressMask;
mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
- xwin = XCreateWindow(_glut_egl->native_dpy, root, x, y, w, h,
+ xwin = XCreateWindow(_glut->native_dpy, root, x, y, w, h,
0, visInfo->depth, InputOutput, visInfo->visual, mask, &attr);
if (!xwin)
- _glut_eglFatal("failed to create a window");
+ _glutFatal("failed to create a window");
XFree(visInfo);
@@ -92,12 +92,12 @@ _glut_eglNativeInitWindow(struct glut_egl_window *win, const char *title,
sizehints.width = w;
sizehints.height = h;
sizehints.flags = USSize | USPosition;
- XSetNormalHints(_glut_egl->native_dpy, xwin, &sizehints);
- XSetStandardProperties(_glut_egl->native_dpy, xwin,
+ XSetNormalHints(_glut->native_dpy, xwin, &sizehints);
+ XSetStandardProperties(_glut->native_dpy, xwin,
title, title, None, (char **) NULL, 0, &sizehints);
}
- XMapWindow(_glut_egl->native_dpy, xwin);
+ XMapWindow(_glut->native_dpy, xwin);
win->native.u.window = xwin;
win->native.width = w;
@@ -105,9 +105,9 @@ _glut_eglNativeInitWindow(struct glut_egl_window *win, const char *title,
}
void
-_glut_eglNativeFiniWindow(struct glut_egl_window *win)
+_glutNativeFiniWindow(struct glut_window *win)
{
- XDestroyWindow(_glut_egl->native_dpy, win->native.u.window);
+ XDestroyWindow(_glut->native_dpy, win->native.u.window);
}
static int
@@ -177,18 +177,18 @@ lookup_keysym(KeySym sym)
}
static void
-next_event(struct glut_egl_window *win)
+next_event(struct glut_window *win)
{
int redraw = 0;
XEvent event;
- if (!XPending(_glut_egl->native_dpy)) {
- if (_glut_egl->idle_cb)
- _glut_egl->idle_cb();
+ if (!XPending(_glut->native_dpy)) {
+ if (_glut->idle_cb)
+ _glut->idle_cb();
return;
}
- XNextEvent(_glut_egl->native_dpy, &event);
+ XNextEvent(_glut->native_dpy, &event);
switch (event.type) {
case Expose:
@@ -223,23 +223,23 @@ next_event(struct glut_egl_window *win)
; /*no-op*/
}
- _glut_egl->redisplay = redraw;
+ _glut->redisplay = redraw;
}
void
-_glut_eglNativeEventLoop(void)
+_glutNativeEventLoop(void)
{
while (1) {
- struct glut_egl_window *win = _glut_egl->current;
+ struct glut_window *win = _glut->current;
next_event(win);
- if (_glut_egl->redisplay) {
- _glut_egl->redisplay = 0;
+ if (_glut->redisplay) {
+ _glut->redisplay = 0;
if (win->display_cb)
win->display_cb();
- eglSwapBuffers(_glut_egl->dpy, win->surface);
+ eglSwapBuffers(_glut->dpy, win->surface);
}
}
}
diff --git a/src/glut_egl/glut_eglint.h b/src/glut_egl/glut_eglint.h
index d34e77d1..577a5832 100644
--- a/src/glut_egl/glut_eglint.h
+++ b/src/glut_egl/glut_eglint.h
@@ -29,7 +29,7 @@
#include "EGL/egl.h"
#include "glut_egl.h"
-struct glut_egl_window {
+struct glut_window {
EGLConfig config;
EGLContext context;
@@ -53,7 +53,7 @@ struct glut_egl_window {
GLUT_EGLspecialCB special_cb;
};
-struct glut_egl_state {
+struct glut_state {
int api_mask;
int display_mode;
int window_width, window_height;
@@ -72,33 +72,33 @@ struct glut_egl_state {
EGLDisplay dpy;
EGLint major, minor;
- struct glut_egl_window *current;
+ struct glut_window *current;
int redisplay;
};
-extern struct glut_egl_state *_glut_egl;
+extern struct glut_state *_glut;
void
-_glut_eglFatal(char *format, ...);
+_glutFatal(char *format, ...);
int
-_glut_eglNow(void);
+_glutNow(void);
void
-_glut_eglNativeInitDisplay(void);
+_glutNativeInitDisplay(void);
void
-_glut_eglNativeFiniDisplay(void);
+_glutNativeFiniDisplay(void);
void
-_glut_eglNativeInitWindow(struct glut_egl_window *win, const char *title,
+_glutNativeInitWindow(struct glut_window *win, const char *title,
int x, int y, int w, int h);
void
-_glut_eglNativeFiniWindow(struct glut_egl_window *win);
+_glutNativeFiniWindow(struct glut_window *win);
void
-_glut_eglNativeEventLoop(void);
+_glutNativeEventLoop(void);
#endif /* _GLUT_EGLINT_H_ */