#ifdef __VMS
#include <GL/vms_x_fix.h>
#endif
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#if !defined(_WIN32)
#include <X11/Xlib.h>
#include <X11/Xatom.h>
#endif
#if defined(_SGI_EXTRA_PREDEFINES) && !defined(NO_FAST_ATOMS)
#include <X11/SGIFastAtom.h>
#else
#define XSGIFastInternAtom(dpy,string,fast_name,how) XInternAtom(dpy,string,how)
#endif
#include "glutint.h"
char *__glutProgramName = NULL;
int __glutArgc = 0;
char **__glutArgv = NULL;
char *__glutGeometry = NULL;
Display *__glutDisplay = NULL;
int __glutScreen;
Window __glutRoot;
int __glutScreenHeight;
int __glutScreenWidth;
GLboolean __glutIconic = GL_FALSE;
GLboolean __glutDebug = GL_FALSE;
unsigned int __glutDisplayMode =
GLUT_RGB | GLUT_SINGLE | GLUT_DEPTH;
char *__glutDisplayString = NULL;
int __glutConnectionFD;
XSizeHints __glutSizeHints = {0};
int __glutInitWidth = 300, __glutInitHeight = 300;
int __glutInitX = -1, __glutInitY = -1;
GLboolean __glutForceDirect = GL_FALSE,
__glutTryDirect = GL_TRUE;
Atom __glutWMDeleteWindow;
#ifdef _WIN32
void (__cdecl *__glutExitFunc)(int retval) = NULL;
#endif
static Bool synchronize = False;
#if defined(_WIN32)
#ifdef __BORLANDC__
#include <float.h>
#endif
void
__glutOpenWin32Connection(char* display)
{
static char *classname;
WNDCLASS wc;
HINSTANCE hInstance = GetModuleHandle(NULL);
if(classname)
return;
#ifdef __BORLANDC__
_control87(MCW_EM,MCW_EM);
#endif
classname = "GLUT";
memset(&wc, 0, sizeof(WNDCLASS));
wc.style = CS_OWNDC;
wc.lpfnWndProc = (WNDPROC)__glutWindowProc;
wc.hInstance = hInstance;
wc.hIcon = LoadIcon(hInstance, "GLUT_ICON");
wc.hCursor = LoadCursor(hInstance, IDC_ARROW);
wc.hbrBackground = NULL;
wc.lpszMenuName = NULL;
wc.lpszClassName = classname;
if(!wc.hIcon)
wc.hIcon = LoadIcon(NULL, IDI_WINLOGO);
if(!RegisterClass(&wc)) {
__glutFatalError("RegisterClass() failed:"
"Cannot register GLUT window class.");
}
__glutScreenWidth = GetSystemMetrics(SM_CXSCREEN);
__glutScreenHeight = GetSystemMetrics(SM_CYSCREEN);
__glutRoot = NULL;
__glutDisplay = (Display*)1;
__glutScreen = 0;
}
#else
void
__glutOpenXConnection(char *display)
{
int errorBase, eventBase;
__glutDisplay = XOpenDisplay(display);
if (!__glutDisplay)
__glutFatalError("could not open display: %s",
XDisplayName(display));
if (synchronize)
XSynchronize(__glutDisplay, True);
if (!glXQueryExtension(__glutDisplay, &errorBase, &eventBase))
__glutFatalError(
"OpenGL GLX extension not supported by display: %s",
XDisplayName(display));
__glutScreen = DefaultScreen(__glutDisplay);
__glutRoot = RootWindow(__glutDisplay, __glutScreen);
__glutScreenWidth = DisplayWidth(__glutDisplay, __glutScreen);
__glutScreenHeight = DisplayHeight(__glutDisplay,
__glutScreen);
__glutConnectionFD = ConnectionNumber(__glutDisplay);
__glutWMDeleteWindow = XSGIFastInternAtom(__glutDisplay,
"WM_DELETE_WINDOW", SGI_XA_WM_DELETE_WINDOW, False);
}
#endif
void
#ifdef OLD_VMS
__glutInitTime(struct timeval6 *beginning)
#else
__glutInitTime(struct timeval *beginning)
#endif
{
static int beenhere = 0;
#ifdef OLD_VMS
static struct timeval6 genesis;
#else
static struct timeval genesis;
#endif
if (!beenhere) {
GETTIMEOFDAY(&genesis);
beenhere = 1;
}
*beginning = genesis;
}
static void
removeArgs(int *argcp, char **argv, int numToRemove)
{
int i, j;
for (i = 0, j = numToRemove; argv[j]; i++, j++) {
argv[i] = argv[j];
}
argv[i] = NULL;
*argcp -= numToRemove;
}
void GLUTAPIENTRY
glutInit(int *argcp, char **argv)
{
char *display = NULL;
char *str, *geometry = NULL;
#ifdef OLD_VMS
struct timeval6 unused;
#else
struct timeval unused;
#endif
int i;
if (__glutDisplay) {
__glutWarning("glutInit being called a second time.");
return;
}
str = strrchr(argv[0], '/');
if (str == NULL) {
__glutProgramName = argv[0];
} else {
__glutProgramName = str + 1;
}
__glutArgc = *argcp;
__glutArgv = (char **) malloc(__glutArgc * sizeof(char *));
if (!__glutArgv)
__glutFatalError("out of memory.");
for (i = 0; i < __glutArgc; i++) {
__glutArgv[i] = __glutStrdup(argv[i]);
if (!__glutArgv[i])
__glutFatalError("out of memory.");
}
str = strrchr(__glutArgv[0], '/');
if (str == NULL) {
__glutProgramName = __glutArgv[0];
} else {
__glutProgramName = str + 1;
}
for (i = 1; i < __glutArgc; i++) {
if (!strcmp(__glutArgv[i], "-display")) {
#if defined(_WIN32)
__glutWarning("-display option not supported by Win32 GLUT.");
#endif
if (++i >= __glutArgc) {
__glutFatalError(
"follow -display option with X display name.");
}
display = __glutArgv[i];
removeArgs(argcp, &argv[1], 2);
} else if (!strcmp(__glutArgv[i], "-geometry")) {
if (++i >= __glutArgc) {
__glutFatalError(
"follow -geometry option with geometry parameter.");
}
geometry = __glutArgv[i];
removeArgs(argcp, &argv[1], 2);
} else if (!strcmp(__glutArgv[i], "-direct")) {
#if defined(_WIN32)
__glutWarning("-direct option not supported by Win32 GLUT.");
#endif
if (!__glutTryDirect)
__glutFatalError(
"cannot force both direct and indirect rendering.");
__glutForceDirect = GL_TRUE;
removeArgs(argcp, &argv[1], 1);
} else if (!strcmp(__glutArgv[i], "-indirect")) {
#if defined(_WIN32)
__glutWarning("-indirect option not supported by Win32 GLUT.");
#endif
if (__glutForceDirect)
__glutFatalError(
"cannot force both direct and indirect rendering.");
__glutTryDirect = GL_FALSE;
removeArgs(argcp, &argv[1], 1);
} else if (!strcmp(__glutArgv[i], "-iconic")) {
__glutIconic = GL_TRUE;
removeArgs(argcp, &argv[1], 1);
} else if (!strcmp(__glutArgv[i], "-gldebug")) {
__glutDebug = GL_TRUE;
removeArgs(argcp, &argv[1], 1);
} else if (!strcmp(__glutArgv[i], "-sync")) {
#if defined(_WIN32)
__glutWarning("-sync option not supported by Win32 GLUT.");
#endif
synchronize = GL_TRUE;
removeArgs(argcp, &argv[1], 1);
} else {
break;
}
}
#if defined(_WIN32)
__glutOpenWin32Connection(display);
#else
__glutOpenXConnection(display);
#endif
if (geometry) {
int flags, x, y, width, height;
width = 0;
height = 0;
flags = XParseGeometry(geometry, &x, &y,
(unsigned int *) &width, (unsigned int *) &height);
if (WidthValue & flags) {
if (width > 0)
__glutInitWidth = width;
}
if (HeightValue & flags) {
if (height > 0)
__glutInitHeight = height;
}
glutInitWindowSize(__glutInitWidth, __glutInitHeight);
if (XValue & flags) {
if (XNegative & flags)
x = DisplayWidth(__glutDisplay, __glutScreen) +
x - __glutSizeHints.width;
if (x >= 0)
__glutInitX = x;
}
if (YValue & flags) {
if (YNegative & flags)
y = DisplayHeight(__glutDisplay, __glutScreen) +
y - __glutSizeHints.height;
if (y >= 0)
__glutInitY = y;
}
glutInitWindowPosition(__glutInitX, __glutInitY);
}
__glutInitTime(&unused);
{
const char *fps = getenv("GLUT_FPS");
if (fps) {
sscanf(fps, "%d", &__glutFPS);
if (__glutFPS <= 0)
__glutFPS = 5000;
}
}
}
#ifdef _WIN32
void GLUTAPIENTRY
__glutInitWithExit(int *argcp, char **argv, void (__cdecl *exitfunc)(int))
{
__glutExitFunc = exitfunc;
glutInit(argcp, argv);
}
#endif
void GLUTAPIENTRY
glutInitWindowPosition(int x, int y)
{
__glutInitX = x;
__glutInitY = y;
if (x >= 0 && y >= 0) {
__glutSizeHints.x = x;
__glutSizeHints.y = y;
__glutSizeHints.flags |= USPosition;
} else {
__glutSizeHints.flags &= ~USPosition;
}
}
void GLUTAPIENTRY
glutInitWindowSize(int width, int height)
{
__glutInitWidth = width;
__glutInitHeight = height;
if (width > 0 && height > 0) {
__glutSizeHints.width = width;
__glutSizeHints.height = height;
__glutSizeHints.flags |= USSize;
} else {
__glutSizeHints.flags &= ~USSize;
}
}
void GLUTAPIENTRY
glutInitDisplayMode(unsigned int mask)
{
__glutDisplayMode = mask;
}